TensorFlow2学习四之函数

构建神经网络

1. 准备数据：采集大量“特征、标签”数据
2. 搭建网络：搭建神经网络结构
3. 优化参数：训练网络获取最佳参数
4. 应用网络：将网络保存为模型，输入新数据分类或预测结果

损失函数（loss function）：预测值（y）与标准答案（y_）的差距。

损失函数可以定量判断W、b的优劣，当损失函数输出最小时，参数W、b回出现最优值。

梯度下降

目的：找到一组参数w和b，使得损失函数最小。
梯度：函数对各参数求偏导后的向量。
（函数梯度下降的方向是函数减小方向）
梯度下降：沿损失函数梯度下降的方向，寻找损失函数最小值，得到最优参数的方法。

学习率（learning rate）

学习率过小时，收敛过程会十分缓慢；学习率过大时，梯度可能会在最小值周围徘徊，导致无法收敛。

反向传播

从后向前，逐层求损失函数对每层神经元参数的偏导数，迭代更新所有参数。

张量（Tensor）：多维数组（列表）

阶：张量的维数
0阶张量：标量（scalar）
1阶张量：向量（vector）
2阶张量：矩阵（matrix）

创建张量

tf.constant(张量内容, dtype=数据类型）

a = tf.constant([1, 7], dtype=tf.int32)
print("a.dtype:", a.dtype)
print("a.shape:", a.shape)

a.dtype: <dtype: ‘int64’>
a.shape: (2,)

将numpy的数据类型转换为Tensor数据类型： tf.convert_to_tensor(name, dtype=datatype）

a = np.arange(0, 5)
b = tf.convert_to_tensor(a, dtype=tf.int32)

print("a:", a)
print("b:", b)

a: [0 1 2 3 4]
b: tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int32)

数据类型

tf.int
tf.float
tf.bool
tf.string

强制tensor转换为该数据类型
tf.cast(张量名, dtype=数据类型)

计算张量维度上元素的最小/大值
tf.reduce_min (张量名)
tf.reduce_max (张量名)

x1 = tf.constant([1., 2., 3.], dtype=tf.float64)
x2 = tf.cast(x1, tf.int32)
print("minimum of x2：", tf.reduce_min(x2))
print("maxmum of x2:", tf.reduce_max(x2))

指定创建zeros/ones/fill

tf.zeros(维度) # 全为0的张量
tf.ones(维度) # 创建全为1的张量
tf.fill(维度,指定值) # 创建全为指定值得张量

a = tf.zeros([4, 5])
b = tf.ones(3)
c = tf.fill([2, 2], 5)

随机数

1. 生成正泰分布的随机数，默认均值为0，标准差为1
   tf.random.normal(维度,mean=均值,stddev=标准差)
2. 生成截断式正态分布的随机数
   tf.random.truncated_normal(维度,mean=均值,stddev=标准差)
3. 生成均匀分布随机数
   tf.random.uniform([2,2],minval=最小值,maxval=最大值)

d = tf.random.normal([2, 2], mean=0.5, stddev=1)
e = tf.random.truncated_normal([2, 2], mean=0.5, stddev=1)
f = tf.random.uniform([2, 2], minval=0, maxval=1)

常用函数

1. axis
   在一个二维张量或数组中，可以通过调整 axis 等于0或1 控制执行维度。

axis=0代表跨行（经度，down)，而axis=1代表跨列（纬度，across)。

如果不指定axis，则所有元素参与计算。

2. 计算张量沿着指定维度的平均值
   tf.reduce_mean (张量名，axis=操作轴)
   计算张量沿着指定维度的和
   tf.reduce_sum (张量名，axis=操作轴)

x = tf.constant([[1, 2, 3], [2, 2, 3]])
print("x:", x)
print("mean of x:", tf.reduce_mean(x))  
print("sum of x:", tf.reduce_sum(x, axis=1))

3. tf.Variable标记待训练参数
   tf.Variable(初始值)
   注：被标记的变量会在反向传播
   中记录梯度信息。

4. 数学运算
   实现两个张量的对应元素相加tf.add (张量1，张量2)
   实现两个张量的对应元素相减tf.subtract (张量1，张量2)
   实现两个张量的对应元素相乘tf.multiply (张量1，张量2)
   实现两个张量的对应元素相除tf.divide (张量1，张量2)
   注：只有维度相同的张量才可以做四则运算

a = tf.ones([1, 3])
b = tf.fill([1, 3], 3.)
print("a+b:", tf.add(a, b))
print("a-b:", tf.subtract(a, b))
print("a*b:", tf.multiply(a, b))
print("b/a:", tf.divide(b, a))

5. 平方、次方、开方、矩阵乘
   计算某个张量的平方tf.square (张量名)
   计算某个张量的n次方tf.pow (张量名，n次方数)
   计算某个张量的开方tf.sqrt (张量名）
   实现两个矩阵的相乘tf.matmul(矩阵1，矩阵2)

a = tf.fill([1, 2], 3.)
print(tf.pow(a, 3))
print(tf.square(a))
print(tf.sqrt(a))

a = tf.ones([3, 2])
b = tf.fill([2, 3], 3.)
print("a*b:", tf.matmul(a, b))

6. 切分传入张量的第一维度，生成输入特征/标签对，构建数据集data = tf.data.Dataset.from_tensor_slices((输入特征, 标签))
   （Numpy和Tensor格式都可用该语句读入数据）

features = tf.constant([12, 23, 10, 17])
labels = tf.constant([0, 1, 1, 0])
dataset = tf.data.Dataset.from_tensor_slices((features, labels))
for element in dataset:
    print(element)

tf.GradientTape

with结构记录计算过程，gradient求出张量的梯度

with tf.GradientTape( ) as tape:
	计算过程
grad=tape.gradient(函数，对谁求导)

with tf.GradientTape() as tape:
    x = tf.Variable(tf.constant(3.0))
    y = tf.pow(x, 2)
grad = tape.gradient(y, x)
print(grad)

tf.Tensor(6.0, shape=(), dtype=float32)

enumerate(列表名)

enumerate是python的内建函数，它可遍历每个元素(如列表、元组或字符串)，组合为：索引 元素，常在for循环中使用。

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i, element)

tf.one_hot (待转换数据, depth=几分类)

独热编码（one-hot encoding）：在分类问题中，常用独热码做标签，标记类别：1表示是，0表示非。

tf.one_hot()函数将待转换数据，转换为one-hot形式的数据输出。

classes = 3
labels = tf.constant([1, 0, 2])  # 输入的元素值最小为0，最大为2
output = tf.one_hot(labels, depth=classes)
print("result of labels1:", output)

tf.nn.softmax(x)

n分类的n个输出 （y0 ，y1, …… yn-1）通过softmax( ) 函数后符合概率分布。

y = tf.constant([1.01, 2.01, -0.66])
y_pro = tf.nn.softmax(y)
print(y_pro)
print(tf.reduce_sum(y_pro))

w.assign_sub (w要自减的内容)

1. 赋值操作，更新参数的值并返回。
2. 调用assign_sub前，先用 tf.Variable 定义变量 w 为可训练（可自更新）。

x = tf.Variable(4)
x.assign_sub(1)
print("x:", x)

tf.argmax (张量名,axis=操作轴)

返回张量沿指定维度最大值的索引

test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]])
print("每一列的最大值的索引：", tf.argmax(test, axis=0))
print("每一行的最大值的索引", tf.argmax(test, axis=1))

tf.where(条件语句，真返回A, 假返回B)

条件语句真返回A，条件语句假返回B

a = tf.constant([1, 2, 3, 1, 1])
b = tf.constant([0, 1, 3, 4, 5])
c = tf.where(tf.greater(a, b), a, b)
# 若a>b，返回a对应位置的元素，否则返回b对应位置的元素
print("c：", c)

c： tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)

np.random.RandomState.rand(n)

返回一个[0,1)之间的随机数，若n为空则返回标量。

rdm = np.random.RandomState(seed=1)
a = rdm.rand()
b = rdm.rand(2, 3)
print("a:", a)
print("b:", b)

a: 0.417022004702574
b: [[7.20324493e-01 1.14374817e-04 3.02332573e-01]
[1.46755891e-01 9.23385948e-02 1.86260211e-01]]

np.vstack(数组1, 数组2)

将两个数组按垂直方向叠加

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.vstack((a, b))

[[1 2 3]
[4 5 6]]

np.mgrid[]、x.ravel()、np.c_[]

np.mgrid[ 起始值 : 结束值 : 步长 ，起始值 : 结束值 : 步长 , … ]

x.ravel( ) 将x变为一维数组，“把 . 前变量拉直”

np.c_[ 数组1，数组2， … ] # 使返回的间隔数值点配对

# 生成等间隔数值点
x, y = np.mgrid[1:3:1, 2:4:0.5]
# 将x, y拉直，并合并配对为二维张量，生成二维坐标点
grid = np.c_[x.ravel(), y.ravel()]
print("x:\n", x)
print("y:\n", y)
print("x.ravel():\n", x.ravel())
print("y.ravel():\n", y.ravel())
print('grid:\n', grid)

x:
 [[1. 1. 1. 1.]
 [2. 2. 2. 2.]]
y:
 [[2.  2.5 3.  3.5]
 [2.  2.5 3.  3.5]]
x.ravel():
 [1. 1. 1. 1. 2. 2. 2. 2.]
y.ravel():
 [2.  2.5 3.  3.5 2.  2.5 3.  3.5]
grid:
 [[1.  2. ]
 [1.  2.5]
 [1.  3. ]
 [1.  3.5]
 [2.  2. ]
 [2.  2.5]
 [2.  3. ]
 [2.  3.5]]