python笔记

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)