文章目录
B站上的视频： Tensorflow2
源码等网盘：
链接： 网盘链接
提取码：w3ke
1-6章源码
提供者：
1. 基础知识
1.1 张量生成
import tensorflow as tf
a = tf.constant([1, 5], dtype=tf.int64)
print(a)
print(a.dtype)
print(a.shape)
# numpy格式转换成张量
import numpy as np
a = np.arange(0, 5)
b = tf.convert_to_tensor(a, dtype=tf.int64)
print(a)
print(b)
# 创建全为0的张量
tf.zeros(维度)
# 创建全为1的张量
tf.ones(维度)
# 创建全为指定值的张量
tf.fill(维度, 指定值)
a = tf.zeros([2, 3])
b = tf.ones(4)
c = tf.fill([2, 2], 9)
# 生成正态分布的随机数
tf.random.normal(维度, mean=均值, stddev=标准差)
# 生成截断式正态分布的随机数
tf.random.truncated_normal(维度, mean=均值, stddev=标准差)
# 生成均匀分布随机数
tf.random.uniform(维度, minval=最小值, maxval=最大值)
1.2 常用函数
import tensorflow as tf
# 强制tensor转换为该数据类型
tf.cast(张量名, dtype=数据类型)
# 计算张量维度上元素的最小值
tf.reduce_min(张量名)
# 计算张量维度上元素最大值
tf.reduce_max(张量名)
# axis=0表示对每行进行操作，为纵向，axis=1位横向
# 计算张量维度均值
tf.reduce_mean(张量名, axis=操作轴)
# 计算张量维度和
tf.reduce_sum(张量名, axis=操作轴)
# 将变量标记为可训练的，可记录梯度信息进行反向传播
tf.Variable(初始值)
# 维度相同的张量四则运算
tf.add(张量1, 张量2)
tf.subtract(张量1, 张量2)
tf.multiply(张量1, 张量2)
tf.divide(张量1, 张量2)
# 平方、次方与开方
tf.square(张量名)
tf.pow(张量名, n次方数)
tf.sqrt(张量名)
# 矩阵乘
tf.matmul(矩阵1, 矩阵2)
# 切分传入张量的第一维度，生成输入特征/标签对，构建数据集（numpy和tensor均可）
data = tf.data.Dataset.from_tensor_slices((输入特征, 标签))
features = tf.constant([12, 23, 10, 17])
labels = tf.constant([0, 1, 1, 0])
dataset = tf.data.Dataset.from_tensor_slices((features, labels))
print(dataset)
for element in dataset:
print(element)
# with结构记录计算过程，gradient求出张量的梯度
with tf.GradientTape() as tape:
若干个计算过程
grad = tape.gradient(函数, 对谁求导)
with tf.GradientTape() as tape:
w = tf.Variable(tf.constant(3.0))
loss = tf.pow(w, 2)
grad = tape.gradient(loss, w)
print(grad)
"""
运行结果：
tf.Tensor(6.0, shape=(), dtype=float32)
"""
# 元素遍历
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, element)
# 独热编码
classes = 3
labels = tf.constant([1, 0, 2])
output = tf.one_hot(labels, depth=classes)
print(output)
# 使输出复合概率分布
y = tf.constant([1.01, 2.01, -0.66])
y_pro = tf.nn.softmax(y)
# 赋值操作，更细参数的值并返回，需先设定为Variable可训练
w = tf.Variable(4)
w.assign_sub(1) # 自减
print(w)
# 返回张量沿指定维度最大值的索引号
import numpy as np
test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2])
print(test)
print(tf.argmax(test, axis=0)) # 返回每一列（经度）最大值所有
print(tf.argmax(test, axis=1)) # 返回每一行（纬度）最大值的索引
1.3 实例: 鸢尾花分类
from sklearn.datasets import load_iris
from pandas import DataFrame
import pandas as pd
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target
x_data = DataFrame(x_data, columns=['花萼长度', ['花萼宽度'],
['花瓣长度'], ['花瓣宽度']])
pd.set_option('display.unicode.east_asian_width', True)
x_data['类别'] = y_data
# 数据集乱序
np.random.seed(116)
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)
# 划分训练集和测试集
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
x_test = y_data[-30:]
# 配成[输入特征, 标签]对，分batch
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
# 定义神经网络中所有可训练参数
w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
lr = 0.1
train_loss_results = []
test_acc = []
Epoch = 500
loss_all = 0
# 嵌套循环迭代，with结构更新参数，显示当前loss
for epoch in range(Epoch): # 数据集级别迭代
for step, (x_train, y_train) in enumerate(train_db):
with tf.GradientTape() as tape:
y = tf.matmul(x_train, w1) + b1
y = tf.nn.softmax(y)
y_ = tf.one_hot(y_train, depth=3)
loss = tf.reduce_mean(tf.square(y_ - y))
loss_all += loss.numpy()
grads = tape.gradient(loss, [w1, b1])
w1.assign_sub(lr * grads[0])
b1.assign_sub(lr * grads[1])
print("Epoch {}, loss: {}".format(epoch, loss_all/4))
train_loss_results.append(loss_all / 4)
loss_all = 0
# 测试部分
total_correct, total_number = 0, 0
for x_test, y_test in test_db:
# 使用更新后的参数进行预测
y = tf.matmul(x_test. w1) + b1
y = tf.nn.softmax(y)
pred = tf.argmax(y, axis=1)
pred = tf.cast(pred, dtype=y_test.dtype)
correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_correct += int(correct)
total_number += x_test.shape[0]
acc = total_correct / total_number
test_acc.append(acc)
print("Test_acc:", acc)
print('-----------------------------')
# 绘制loss曲线
plt.title('Loss Function Cureve')
plt.xlabel('Epoch')
plt.ylabel('loss')
plt.plot(train_loss_results, label='$Loss$')
plt.legend()
plt.show()
# 绘制acc曲线
plt.title('Acc Cureve')
plt.xlabel('Epoch')
plt.ylabel('Acc')
plt.plot(test_acc, label='$Accuracy$')
plt.legend()
plt.show()
2. 神经网络的优化过程（手工实现）
2.1 预备知识
# 条件语句真返回A，条件语句假返回B
tf.where(条件语句, 真返回A, 假返回B)
# 返回[0, 1)之间的随机数
np.random.RandomState.rand(维度)
# 将两个数组按垂直方向叠加
np.vstack(数组1, 数组2)
# 返回若干组维度相同的等差数组
np.mgrid[起始值: 结束值: 步长, 起始值: 结束值: 步长, ...]
# 多维数组展平
x.ravel()
# 使返回的间隔数值点配对
np.c_[数组1, 数组2, ...]
2.2 神经网络复杂度
NN复杂度：多用NN层数和NN参数的个数表示
空间复杂度：
- 层数 = 隐藏层层数+1个输出层
- 总参数 = 总w + 总b
时间复杂度：乘加运算次数
指数衰减学习率 = 初 始 学 习 率 ∗ 学 习 率 衰 减 率 ( 当 前 轮 数 / 多 少 轮 衰 减 − 次 ) {初始学习率*学习率衰减率}^{(当前轮数/多少轮衰减-次)} 初始学习率∗学习率衰减率(当前轮数/多少轮衰减−次)
2.3 激活函数
tf.nn.sigmoid(x)
tf.math.tanh(x)
tf.nn.relu(x)
tf.nn.leaky_relu(x)
2.4 损失函数
mse = tf.reduce_mean(tf.square(y_ - y))
# 案例
SEED = 23455
rdm = np.random.RandomState(seed=SEED)
x = rdm.rand(32, 2)
y_ = [[x1 + x2 + (rdm.rand() / 10.0 - 0.05)] for (x1, x2)in x]
x = tf.cast(x, dtype=tf.float32)
w1 = tf.Variable(tf.random.normal([2, 1], stddev=1, seed=1))
Epoch = 15000
lr = 0.002
for epoch in range(Epoch):
with tf.GradieentTape() as tape:
y = tf.matmul(x, w1)
loss_mse = tf.reduce_mean(tf.square(y_ - y))
grads = tape.gradient(loss_mse, w1)
w1.assign_sub(lr * grads)
if epoch % 500 == 0:
print("After %d training steps, w1 is" % (epoch))
print(w1.numpy(), '\n')
print('Final w1 is: ', w1.numpy())
# 自定义损失函数
loss_zdy = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_) * COST), (y_ - y) * PROFIT)
# 交叉熵损失
tf.losses.categorical_crossentropy(y_, y)
# softmax和交叉熵损失结合
tf.nn.softmax_cross_entropy_with_logits(y_, y)
2.5 缓解过拟合
欠拟合解决方法：增加输入特征项、增加网络参数、减少正则化参数；
过拟合解决方法：数据清洗、增大训练集、采用正则化、增大正则化参数
# L2正则化解决过拟合
loss_reg = []
loss_reg.append(tf.nn.l2_loss(w1))
loss_reg.append(tf.nn.l2_loss(w2))
loss_reg = tf.reduce_sum(loss_reg)
loss = loss_reg + 0.03 * loss_reg
# 详见class2/p29_regulirazationfree.py
2.6 优化器
在梯度下降计算过程中，待优化参数 w w w，损失函数 l o s s loss loss，学习率 l r lr lr，每次迭代一个 b a t c h batch batch， t t t表示当前 b a t c h batch batch迭代的总次数：
- 计算 t t t时刻损失函数关于当前参数的梯度 g t = ∇ l o s s = ∂ l o s s ∂ ( w t ) g_t=\nabla loss=\frac{\partial loss}{\partial (w_t)} gt=∇loss=∂(wt)∂loss
- 计算 t t t时刻一阶动量 m t m_t mt和二阶动量 V t V_t Vt
- 计算 t t t时刻下降梯度： η t = l r ⋅ m t / V t \eta_{t}=lr·m_t/\sqrt{V_t} ηt=lr⋅mt/Vt
- 计算 t + 1 t+1 t+1时刻参数： w t + 1 = w t − η t = w t − l r ⋅ m t / V t w_{t+1}=w_t-\eta_t=w_t-lr·m_t/\sqrt{V_t} wt+1=wt−ηt=wt−lr⋅mt/Vt
随机梯度下降SGD，无动量，实现具体文件:class2/p32_sgd.py
m
t
=
g
t
m_t=g_t
mt=gt，
V
t
=
1
V_t=1
Vt=1，
η
t
=
l
r
⋅
m
t
/
V
t
=
l
r
⋅
g
t
\eta_t=lr·m_t/\sqrt{V_t}=lr·g_t
ηt=lr⋅mt/Vt=lr⋅gt
w
t
+
1
=
w
t
−
η
t
=
w
t
−
l
r
⋅
m
t
/
V
t
=
w
t
−
l
r
⋅
g
t
w_{t+1}=w_t-\eta_t=w_t-lr·m_t/\sqrt{V_t}=w_t-lr·g_t
wt+1=wt−ηt=wt−lr⋅mt/Vt=wt−lr⋅gt
w
t
+
1
=
w
t
−
l
r
∗
∂
l
o
s
s
∂
w
t
w_{t+1}=w_t-lr*\frac{\partial loss}{\partial w_t}
wt+1=wt−lr∗∂wt∂loss
SGDM：含动量的SGD，实现具体文件:class2/p32_sgdm.py
m
t
=
β
⋅
m
t
−
1
+
(
1
−
β
)
⋅
g
t
m_t=\beta ·m_{t-1}+(1-\beta)·g_t
mt=β⋅mt−1+(1−β)⋅gt，
V
t
=
1
V_t=1
Vt=1，
η
t
=
l
r
⋅
m
t
/
V
t
=
l
r
⋅
m
t
=
l
r
⋅
(
β
⋅
m
t
−
1
+
(
1
−
β
)
⋅
g
t
)
\eta_t=lr·m_t/\sqrt{V_t}=lr·m_t=lr·(\beta·m_{t-1}+(1-\beta)·g_t)
ηt=lr⋅mt/Vt=lr⋅mt=lr⋅(β⋅mt−1+(1−β)⋅gt)，
w
t
+
1
=
w
t
−
η
t
=
w
t
−
l
r
⋅
(
β
⋅
m
t
−
1
+
(
1
−
β
)
⋅
g
t
)
w_{t+1}=w_t-\eta_t=w_t-lr·(\beta·m_{t-1}+(1-\beta)·g_t)
wt+1=wt−ηt=wt−lr⋅(β⋅mt−1+(1−β)⋅gt)
Adagrad：在SGD基础上增加二阶动量，实现具体文件:class2/p36_adagrad.py
m
t
=
g
t
m_t=g_t
mt=gt，
V
t
=
∑
τ
=
1
t
g
τ
2
V_t=\sum_{\tau=1}^{t}{g_\tau}^2
Vt=∑τ=1tgτ2，
η
t
=
l
r
⋅
m
t
/
(
V
t
)
=
l
r
⋅
g
t
/
(
∑
τ
=
1
t
g
τ
2
)
\eta_t=lr·m_t/(\sqrt{V_t})=lr·g_t/(\sqrt {\sum_{\tau=1}^{t}{g_\tau}^2})
ηt=lr⋅mt/(Vt)=lr⋅gt/(∑τ=1tgτ2)，
w
t
+
1
=
w
t
−
η
t
=
w
t
−
l
r
⋅
g
t
/
(
∑
τ
=
1
t
g
t
2
)
w_{t+1}=w_t-\eta_t=w_t-lr·g_t/(\sqrt{\sum_{\tau=1}^{t}{g_t}^2})
wt+1=wt−ηt=wt−lr⋅gt/(∑τ=1tgt2)
RMSProp：在SGD基础上增加二阶动量，实现具体文件:class2/p38_rmsprop.py
m
t
=
g
t
m_t=g_t
mt=gt，
V
t
=
β
⋅
V
t
−
1
+
(
1
−
β
)
⋅
g
t
2
V_t=\beta ·V_{t-1}+(1-\beta)·{g_t}^2
Vt=β⋅Vt−1+(1−β)⋅gt2，
η
t
=
l
r
⋅
m
t
/
V
t
=
l
r
⋅
g
t
/
(
β
⋅
V
t
−
1
+
(
1
−
β
)
⋅
g
t
2
)
\eta_t=lr·m_t/\sqrt{V_t}=lr·g_t/(\sqrt{\beta·V_{t-1}+(1-\beta)·{g_t}^2})
ηt=lr⋅mt/Vt=lr⋅gt/(β⋅Vt−1+(1−β)⋅gt2)，
w
t
+
1
=
w
t
−
η
t
=
w
t
−
l
r
⋅
g
t
/
(
β
⋅
V
t
−
1
+
(
1
−
β
)
⋅
g
t
2
)
w_{t+1}=w_t-\eta_t=w_t-lr·g_t/(\sqrt{\beta·V_{t-1}+(1-\beta)·{g_t}^2})
wt+1=wt−ηt=wt−lr⋅gt/(β⋅Vt−1+(1−β)⋅gt2)
Adam：同时结合SGDM一阶动量和RMSProp二阶动量，实现具体文件:class2/p38_rmsprop.py
m
t
=
β
1
⋅
m
t
−
1
+
(
1
−
β
1
)
⋅
g
t
m_t=\beta_1·m_{t-1}+(1-\beta_1)·g_t
mt=β1⋅mt−1+(1−β1)⋅gt
修正一阶动量的偏差：
m
t
^
=
m
t
1
−
β
1
t
\hat{m_t}=\frac{m_t}{1-{\beta_1}^t}
mt^=1−β1tmt
V
t
=
β
2
⋅
V
s
t
e
p
−
1
+
(
1
−
β
2
)
⋅
g
t
2
V_t=\beta_2·V_{step-1}+(1-\beta_2)·{g_t}^2
Vt=β2⋅Vstep−1+(1−β2)⋅gt2
修正二阶动量的偏差：
V
t
^
=
V
t
1
−
β
2
t
\hat{V_t}=\frac{V_t}{1-{\beta_2}^t}
Vt^=1−β2tVt
η
t
=
l
r
⋅
m
t
^
/
V
t
^
=
l
r
⋅
m
t
1
−
β
1
t
/
V
t
1
−
β
2
t
\eta_t=lr·\hat{m_t}/\sqrt{\hat{V_t}}=lr·\frac{m_t}{1-{\beta_1}^t}/\sqrt{\frac{V_t}{1-{\beta_2}^t}}
ηt=lr⋅mt^/Vt^=lr⋅1−β1tmt/1−β2tVt
w
t
+
1
=
w
t
−
η
t
=
w
t
−
l
r
⋅
m
t
1
−
β
1
t
/
V
t
1
−
β
2
t
w_{t+1}=w_t-\eta_t=w_t-lr·\frac{m_t}{1-{\beta_1}^t}/\sqrt{\frac{V_t}{1-{\beta_2}^t}}
wt+1=wt−ηt=wt−lr⋅1−β1tmt/1−β2tVt
3. 搭建网络（内置八股方式）
3.1 基础八股
"""
六步法
import
train, test
model = tf.keras.models.Sequential
model.compile
model.fit
model.summary
"""
model = tf.keras.models.Sequential([网络结构])
# 拉直层
tf.keras.layers.Flatten()
# 全连接层
tf.keras.layers.Dense(神经元个数, activation="激活函数", kernel_regularizer=那种正则化)
# activation: relu/softmax/sigmoid/tanh
# kernel_regularizer: tf.keras.regularizers.l1()/tf.keras.regularizers.l2()
# 卷积层
tf.keras.Conv2D(filters=卷积核个数, kernel_size=卷积核尺寸, strides=卷积步长, padding="valid" or "same")
# LSTM层
tf.keras.layers.LSTM()
# 配置训练方法
model.compile(optimizer=优化器, loss=损失函数, metrices=["准确率"])
"""
Optimizer可选：
"sgd" or tf.keras.optimizers.SGD(lr=学习率, momentum=动量参数)
'adagrad' or tf.keras.optimizers.Adagrad(lr=学习率)
'adadelta' or tf.keras.optimizers.Adadelta(lr=学习率)
'adam' or tf.keras.optimizers.Adam(lr=学习率, beta_1=0.9, beta_2=0.999)
loss可选：
'mse' or tf.keras.losses.MeanSquaredError()
'sparse_categorical_crossentropy' or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
Metrices可选：
'accuracy'：y_和y都是数值，如y_=[1],y=[1]
'categorical_accuracy'：y_和y都是独热编码(概率分布)
'sparse_categorical_accuracy'：y_是数值，y是独热编码（概率分布）
"""
# 训练和验证
model.fit(训练集的输入特征, 训练集的标签, batch_size=, epochs=, validation_data=(测试集的输入特征, 测试集的标签), validation_split=从训练集划分多少比例给测试集, validation_freq=多少次epoch测试一次)
# 打印网络结构和参数统计
model.summary()
# 鸢尾花分类见：class3/p8_iris_sequential.py
3.2 搭建网络结构类
class MyModel(Model):
def __init__(self):
super(MyModel, self).__init__()
pass
# 前向传播
def call(self, x):
pass
return y
model = MyModel()
# 基于iris、minist、fashion数据集的分类识别实例详见class3中的py文件
4. 搭建网络（进阶）
4.1 自制数据集
"""
AI/class4/MINIST_FC/minist_image_label
# 图片
minist_train_jpg_60000
0_5.jpg 1_0.jpg......
minist_test_jpg_10000
.......
# 标签
minist_train_jpg_60000.txt
minist_test_jpg_10000.txt
0_5.jpg 5
1_0.jpg 0
......
"""
def generateds(path, txt):
f = open(txt, 'r')
contents = f.readlinse()
f.close()
x, y_ = [], []
for content in contents:
value = content.split()
img_path = path + value[0]
img = Image.open(img_path)
# 8位灰度格式
img = np.array(img.convert('L'))
# 图片归一化
img = img / 255
x.append(img)
y_.append(value[1])
print('loading: '+ content)
x = np.array(x)
y_ = np.array(y)
y_ = y_.astype(np.int64)
return x, y_
x_train, y_train = generateds(train_path, train_txt)
# ......
4.2 数据增强
# 数据增强，增加数据量
img_gen_train = tf.keras.preprocessing.image.ImageDataGenerator(rescale=所有数据将乘以该数值,
rotation_range=随机旋转角度数范围,
width_shift_range=随机宽度偏移量,
height_shift_range=随机高度偏移量,
horizontal_flip=是否随机水平翻转,
zoom_range=随机缩放的范围[1-n, 1+n])
img_gen_train.fit(x_train)
4.3 断点续训
# 读取模型
load_weights(路径文件名)
# 保存模型
cp_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=路径文件名,
save_weights_only=True/False,
save_best_only=True/False,
history=model.fit(callbacks=[cp_callback]))
4.4 参数提取
# 返回模型中可训练的参数
model.trainable_variables
# 设置print输出格式
np.set_printoptions(threshold=超过多少省略显示)
4.5 acc曲线与loss曲线
# 显示训练集和验证集的acc和loss曲线
acc = history.history['sparse_categorical_accuracy']
val_acc = history.history['val_sparse_categorical_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.subplot(1, 2, 1)
plt.plot(acc, label="Training Accuracy")
plt.plot(val_acc, label="Validation Accuracy")
plt.title("Training and Validation Accuracy")
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(loss, label="Training Loss")
plt.plot(val_loss, label="Validation Loss")
plt.title("Training and Validation Loss")
plt.legend()
plt.show()
4.6 应用程序：给图识物
predict(输入特征, batch_size=整数)
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='doftmax')
])
# 加载参数
model.load_weights(model_save_path)
# 预测结果
result = model.predict(x_predict)
5. 卷积神经网络
5.1 卷积层细节（CBAPD）
# C
tf.keras.layers.Conv2D(
filters=卷积核个数,
kernel_size=卷积核尺寸, # 正方形写核长整数，或（核高h，宽w）
strides=滑动步长, # 横纵向相同写步长整数，或（纵向步长h，横向步长w）
padding='same' or 'valid', # 使用全零填充是same，不用是valid
activation='relu' or 'sigmoid', 'tanh', 'softmac'等,
input_shape=(高, 宽, 通道数)
)
# B
# 批标准化
tf.keras.layers.BatchNormalization()
# A，激活函数
# P
# 池化
# 最大池化
tf.keras.layers.MaxPool2D(
pool_size=池化核尺寸,
strides=步长,
padding='same' or 'valid'
)
# 平均池化
tf.keras.layers.AveragePooling2D(
pool_size=池化核尺寸,
strides=步长,
padding='same' or 'valid'
)
# D
# 舍弃部分神经元
tf.keras.layers.Dropout(舍弃率)
5.2 LeNet
class LeNet5(Model):
def __init__(self):
super(LeNet5, self).__init__()
self.c1 = Conv2D(filters=6,
kernel_size=(5, 5),
activation='sigmoid')
self.p1 = MaxPool2D(pool_size=(2, 2),
strides=2)
self.c2 = Conv2D(filters=16,
kernel_size=(5, 5),
activation='sigmoid')
self.p2 = MaxPool2D(pool_size=(2, 2),
strides=2)
self.flatten = Flatten()
self.f1 = Dense(120, activation='sigmoid')
self.f2 = Dense(84, activation='sigmoid')
self.f3 = Dense(10, activation='softmax')
def call(self, x):
x = self.c1(x)
x = self.p1(x)
x = self.c2(x)
x = self.p2(x)
x = self.flatten(x)
x = self.f1(x)
x = self.f2(x)
x = self.f3(x)
5.3 InceptionNet-10
class ConvBNRelu(Model):
def __init__(self, ch, kernelsz=3, strides=1, padding='same'):
super(ConvBNRelu, self).__init__()
self.model = tf.keras.models.Sequential([
conv2D(ch, kernelsz, strides=strides, padding=padding),
BatchNormalization(),
Activation('relu')
])
def call(self, x):
x = self.model(x)
return x
class InceptionBlk(Model):
def __init__(self, ch, strides=1):
super(InceptionBlk, self).__init__()
self.ch = ch
self.strides = strides
self.c1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
self.c2_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
self.c2_2 = ConvBNRelu(ch, kernelsz=3, strides=1)
self.c3_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
self.c3_2 = ConvBNRelu(ch, kernelsz=5, strides=1)
self.p4_1 = MaxPool2D(3, strides=1, paddinf='same')
self.c4_2 = ConvBNRelu(ch, kernelsz=1, strides=strides)
def call(self, x):
x1 = self.c1(x)
x2_1 = self.c2_1(x)
x2_2 = self.c2_2(x2_!)
x3_1 = self.c3_1(x)
x3_2 = self.c3_2(x3_1)
x4_1 = self.p4_1(x)
x4_2 = self.c4_2(x4_1)
x = tf.concat([x1, x2_2, x3_2, x4_2], axis=3)
return x
class Inception10(Model):
def __init__(self, num_blocks, num_classes, init_ch=16, **kwargs):
super(Inception10, self).__init__(**kwargs)
self.in_channels = init_ch
self.out_channels = init_ch
self.num_blocks = num_blocks
self.init_ch = init_ch
self.c1 = ConvBNRelu(init_ch)
self.blocks = tf.keras.models.Sequential()
for block_id in range(num_blocks):
for layer_id in range(2):
if layer_id == 0:
block = InceptionBlk(self.out_channels, strides=2)
else:
block = InceptionBlk(self.out_channels, strides=1)
self.blocks.add(block)
# enlarger out_channels per block
self.out_channels *= 2
self.p1 = GlobalAveragePooling2D()
self.f1 = Dense(num_classes, activation='softmax')
def call(self, x):
x = self.c1(x)
x = self.blocks(x)
x = self.p1(x)
y = self.f1(x)
return y
5.4 ResNet-18
class ResnetBlock(Model):
def __init__(self, filters, strides=1, residual_path=False):
super(ResnetBlock, self).__init__()
self.filters = filters
self.strides = strides
self.residual_path = residual_path
self.c1 = Conv2D(filters, (3, 3), strides=strides, padding='same', use_bias=False)
self.b1 = BatchNormalization()
self.a1 = Activation('relu')
self.c2 = Conv2D(filters, (3, 3), strides=1, padding='same', use_bias=False)
self.b2 = BatchNormalization()
# residual_path为True时，对输入进行下采样，即用1x1的卷积核做卷积操作，保证x能和F(x)维度相同，顺利相加
if residual_path:
self.down_c1 = Conv2D(filters, (1, 1), strides=strides, padding='same', use_bias=False)
self.down_b1 = BatchNormalization()
self.a2 = Activation('relu')
def call(self, inputs):
residual = inputs # residual等于输入值本身，即residual=x
# 将输入通过卷积、BN层、激活层，计算F(x)
x = self.c1(inputs)
x = self.b1(x)
x = self.a1(x)
x = self.c2(x)
y = self.b2(x)
if self.residual_path:
residual = self.down_c1(inputs)
residual = self.down_b1(residual)
out = self.a2(y + residual) # 最后输出的是两部分的和，即F(x)+x或F(x)+Wx,再过激活函数
return out
class ResNet18(Model):
def __init__(self, block_list, initial_filters=64): # block_list表示每个block有几个卷积层
super(ResNet18, self).__init__()
self.num_blocks = len(block_list) # 共有几个block
self.block_list = block_list
self.out_filters = initial_filters
self.c1 = Conv2D(self.out_filters, (3, 3), strides=1, padding='same', use_bias=False)
self.b1 = BatchNormalization()
self.a1 = Activation('relu')
self.blocks = tf.keras.models.Sequential()
# 构建ResNet网络结构
for block_id in range(len(block_list)): # 第几个resnet block
for layer_id in range(block_list[block_id]): # 第几个卷积层
if block_id != 0 and layer_id == 0: # 对除第一个block以外的每个block的输入进行下采样
block = ResnetBlock(self.out_filters, strides=2, residual_path=True)
else:
block = ResnetBlock(self.out_filters, residual_path=False)
self.blocks.add(block) # 将构建好的block加入resnet
self.out_filters *= 2 # 下一个block的卷积核数是上一个block的2倍
self.p1 = tf.keras.layers.GlobalAveragePooling2D()
self.f1 = tf.keras.layers.Dense(10, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
def call(self, inputs):
x = self.c1(inputs)
x = self.b1(x)
x = self.a1(x)
x = self.blocks(x)
x = self.p1(x)
y = self.f1(x)
return y
6. 循环神经网络
6.1 RNN
tf.keras.layers.SimpleRNN(记忆体个数, activation='激活函数'， return_sequences=是否每个时刻输出ht到下一层)
# x_trian维度
[送入样本数，循环核时间展开步数，每个时间步输入特征个数]
# Embedding编码
tf.keras.layers.Embedding(词汇大小, 编码维度)
# 入embedding时，x_train维度
[送入样本数, 循环核时间展开步数]
# LSTM
tf.keras.layers.LSTM(记忆体个数, return_sequences=是否返回输出)
# GRU
tf.keras.layers.GRU(记忆体个数, return_sequences=是否返回输出)
很多实战细节没有写下来，在网盘链接中都有。
1356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
