python
flatten()
flatten()方法用于将多维数组转换为一维数组：
# 创建一个二维数组
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
# 使用 flatten() 方法将其展平为一维数组
array_1d = array_2d.flatten()
print(array_1d)
输出结果是：
[1,2,3,4,5,6]
是X.flatten( )[: , None]，则表示切片操作，这个操作会在数组的最后增加一个纬度，从而将一维数组转换为二维数组，例：
# 创建一个二维数组
X = np.array([[1, 2, 3], [4, 5, 6]])
# 展平为一维数组
X_flat = X.flatten()
print("展平后的一维数组:")
print(X_flat)
print("形状:", X_flat.shape)
# 使用 [:, None] 将一维数组转换为列向量
X_flat_col_vector = X_flat[:, None]
print("转换为列向量后:")
print(X_flat_col_vector)
print("形状:", X_flat_col_vector.shape)
输出结果是：
展平后的一维数组:
[1 2 3 4 5 6]
形状: (6,)
转换为列向量后:
[[1]
[2]
[3]
[4]
[5]
[6]]
形状: (6, 1)
np.hstack()
np.hstack()将一系列数组按水平方向堆叠在一起，如：
# 创建两个示例数组
a = np.array([[1], [2], [3]])
b = np.array([[4], [5], [6]])
# 使用 np.hstack 将它们水平堆叠
c = np.hstack((a, b))
print("数组 a:")
print(a)
print("数组 b:")
print(b)
print("水平堆叠后的数组 c:")
print(c)
结果是：
数组 a:
[[1]
[2]
[3]]
数组 b:
[[4]
[5]
[6]]
水平堆叠后的数组 c:
[[1 4]
[2 5]
[3 6]]
即np.hstack将两个形状为(3，1)的数组堆叠在一起，形成了一个(3,2)的新数组.
@tf.function
@tf.function是TensorFlow中的一个装饰器，作用是将python函数转换为TensorFlow图，以提高函数的执行效率。
具体来说，使用 @tf.function 装饰器可以将函数中的计算过程转换为 TensorFlow 图的形式。TensorFlow 图是一种静态图，其中的计算操作被表示为节点，数据流通过边连接这些节点。相比于动态图，静态图可以进行更多的优化，例如自动并行化、自动求导等，从而提高计算效率。
with tf.GradientTape() as tape 梯度带
简单的梯度计算：
import tensorflow as tf
x = tf.Variable(3.)
with tf.GradientTape() as tape:
tape.watch(x) # 在梯度带上设置计算谁的梯度
y = tf.pow(x, 4) # 表达式y = x^4
dy_dx = tape.gradient(y, x) # 计算一阶梯度后, y_ = 4*x^3
print(dy_dx) # 带入x = 3.0后, 得出梯度y_ = 108
del tape
计算二阶梯度：
x = tf.Variable(4.)
with tf.GradientTape() as tape1:
tape1.watch(x)
with tf.GradientTape() as tape2:
tape2.watch(x)
y = tf.pow(x, 4)
dy_dx = tape2.gradient(y, x) # y' = 4x^3
print(dy_dx)
dy2_dx2 = tape1.gradient(dy_dx, x) # y'' = 12x^2
print(dy2_dx2)
del tape1,tape2
计算多个函数的梯度：(这里需要注意要在GradientType中加上persistent=True, 否则计算一次梯度后, 第二次就失效了)
x = tf.Variable(3.)
with tf.GradientTape(persistent=True) as tape:
tape.watch(x)
y = tf.pow(x, 4) # y = x^4
z = tf.multiply(x, 3) # z = 3*x
dy_dx = tape.gradient(y, x)
dz_dx = tape.gradient(z, x)
print(dy_dx)
print(dz_dx)
del tape
其中如果persistent=True的时候需要把tape.gradient部分移到with tf.GradientTape的外面，否则相当于求导这个操作被磁带记录，会增加内存消耗和warning.
zip()
zip()返回的是zip对象，可以通过list()转换成list查看，也可以通过dict()转换成字典查看，例如：
a = ["a","c","e","g"]
b = ["b","d","f","h"]
print("这是一个列表\n",list(zip(a,b))) #转换成列表
print("这是一个字典\n",dict(zip(a,b))) #转换成字典
输出：
这是一个列表
[('a', 'b'), ('c', 'd'), ('e', 'f'), ('g', 'h')]
这是一个字典
{'a': 'b', 'c': 'd', 'e': 'f', 'g': 'h'}
如果每个迭代器的元素个数不一致，则返回的列表长度与最短的一致.
a = ["a","b","c","d"] #4个元素
b = [1,2,3,4,5,6,7] #7个元素
print(list(zip(a,b)))
输出：
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
tf.Variable()
通过变量名获取变量的机制
tf.Variable(initializer, name)
tf.random.truncated_normal(shape, mean, stddev, dtype=tf.float32, seed=None, name=None)
截断的产生正态分布的随机数，即随机数与均值的差值若大于两倍标准差，则重新生成。
- shape，生成张量的维度
- mean，均值
- stddev，标准差
- dtype，输出的类型 (可选)
- seed，一个整数，当设置之后，每次生成的随机数都一样 (可选)
- name，操作名称 (可选)
optimizer = tf.keras.optimizers.Adam()
定义一个优化器Adam.
之后可以用optimizer.apply_gradients(zip(gradients,model.weights_model.biases))进行参数更新.
tf.cast()
tf.cast(x,dtype,name=None) 将张量转换为新类型.
tf.matmul()
将矩阵A乘以矩阵B，生成 A × B A\times B A×B.
tf.add()
tf.add(x,y) 使得两个参数x和y的两个参数的元素相加，返回的tensor数据类型和x的数据类型相同.
tf.concat()
tf.concat([tensor1,tensor2,tensor3,···],axis)，
axis=0表示在第0个维度拼接；axis=1表示在第1个维度拼接.
tf.square()
对各元素求平方.
tf.random.normal()
用随机正态分布值填充的指定形状的张量.
tf.reduce_mean()
tf.reduce_mean(input_tensor,
axis=None,
keep_dims=False,
name=None,
reduction_indices=None)
这个函数用于计算张量tensor沿着指定的数轴(tensor的某一维度)上的平均值。
第一个参数input_tensor：输入的待降维的tensor；
第二个参数axis：指定的轴，如果不指定，则计算所有元素的均值；
第三个参数keep_dims：是否降维度，设置为True，输出的结果保持输入tensor的形状，设置为False，输出结果会降低维度；
第四个参数name：操作的名称；
a[: , 1:1]
a[: , 1:1]是一个切片操作。一般的索引如a[: , 1:2]表示选择索引1到索引2（不包括2）的列。
所以a[: , 1:1]表示从索引1到索引1的列，实际上这个切片不会选择任何列。
.numpy()
a.numpy( )将a转换为ndarray，这里的a是一个tensor
也就是说.numpy( )方法是tensor flow中特有的，用于将tensor转换为numpy数组
plt.figure()
plt.figure(figsize=None, facecolor=None, edgecolor= None)函数的作用就是创建一个图像，其中figsize就是指定figure的宽和高，单位为英寸；facecolor是指背景颜色；edgecolor是指边框颜色.
plt.subplot()
plt.subplot()就是用来创建单个子图，**但每条subplot命令只会创建一个子图 ，**例如：
# 设置数据
x = np.arange(0, 3, 0.1)
y1 = np.sin(np.pi*x)
y2 = np.cos(np.pi*x)
plt.figure(figsize = (10,6), facecolor = 'r', edgecolor = 'y')
# 绘制第一个子图
plt.subplot(211)
plt.plot(x, y1)
# 绘制第二个子图
plt.subplot(212)
plt.plot(x, y2)
plt.subplot(211)表示绘制两行一列的图像，现在选取第一个.
plt.subplots()
每条subplot命令只会创建一个子图，但是subplots 可以创建多个子图。例如：
# 设置数据
x = np.arange(0, 3, 0.1)
y1 = np.sin(np.pi*x)
y2 = np.cos(np.pi*x)
y3 = np.sin(2*np.pi*x)
y4 = np.cos(2*np.pi*x)
# 创建figure
plt.figure(figsize = (10,6), facecolor = 'r', edgecolor = 'y')
# 划分子图
fig,axes=plt.subplots(2,2)
ax1=axes[0,0]
ax2=axes[0,1]
ax3=axes[1,0]
ax4=axes[1,1]
# 绘制4 个子图
ax1.plot(x, y1)
ax2.plot(x, y2)
ax3.plot(x, y3)
ax4.plot(x, y4)
plt.show()
plt.xticks()
plt.xticks([ ]) 就是表示不显示x轴的刻度.
plt.xticks(np.arange(3)) 就将生成的最后一个图的横坐标设置为只有0、1和2三个刻度 。
gradients = tape.gradient(loss_tol, self.weights + self.biases)
用loss_tol对weights+biases求导的原因：将权重和偏置参数组合成一个列表，也就是这个模型中的所有参数，一次性计算它们的参数.
tf.keras.layers.Dense(units, activation=None, use_bias=True)
参数units，定义了输出空间的维度。如果上一层输出形状为(None, 32)，通过Dense(units=16)层后，输出形状为(None, 16)；如果输出形状为(None, 32, 32)，通过Dense(units=16)层后，输出形状为(None, 32, 16)。更准确的说，这个参数改变了输出空间最后一维的大小。
activation指定了激活函数类型；use_bias指定了是否需要使用偏置.
np.random.uniform
语法如下：
numpy.random.uniform(low, high, size)
表示生成在low到high这个区域内的大小是size的随机数.
tf.trainable_variables()
这个函数可以查看可训练的变量
开区间内等步长取点
代码如下：
import numpy as np
# 定义开区间的起点和终点
start = 0
end = 1
num_points = 10 # 需要取的点数
# 使用linspace函数，去掉起点和终点
points = np.linspace(start, end, num_points + 2)[1:-1]
print("在开区间 (0, 1) 内的等步长取点：", points)
通过切片操作去掉起点和终点
但是上述的linspace是生成一维数组（10，），如果想要变成二维数组（10，1），组需要如下代码：
x = x.reshape(-1,1)
如何解决’NoneType’ object has no attribute ‘numpy’
首先在之前定义了一个函数train_step，没有设置返回值，导致在调用train_step这个函数时返回None而不是一个张量.
np.where
第一种用法：np.where(condition, x, y)，即condition为条件，当满足条件输出为x，不满足条件则输出为y，如：
a = np.arange(10)
//array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print(np.where(a > 5, 1, -1))
//array([-1, -1, -1, -1, -1, -1, 1, 1, 1, 1])
第二种用法：np.where(condition)，此时输出满足条件元素的坐标，如：
>>> a = np.array([2,4,6,8,10])
>>> np.where(a > 5)
//(array([2, 3, 4]),) 返回索引值
>>> a[np.where(a > 5)]
//array([ 6, 8, 10]) 返回元素值,即a[索引]
所以np.where()经常用来刻画Riemann问题的间断初始条件.
np.concatenate
np.concatenate是用于合并多个数组的函数，例如：
pythonCopy code
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
c = np.concatenate((a, b), axis=1)
print(c)
上述代码用于合并二维数组，沿着axis=1轴，表示只有axis=1的轴维数变化.
enumerate()
将一个可遍历的iterable数据对象组合为一个索引序列，同时列出数据和数据下标，如：
ll=[22, 36, 54, 41, 19, 62, 14, 92, 17, 67]
for index,item in enumerate(ll):
print(index, "=",item)
