各位同学好，今天和大家分享一下 TensorFlow 深度学习中如何搭载 Resnet18 和 Resnet34 残差神经网络，残差网络 利用 shotcut 的方法成功解决了网络退化的问题，在训练集和校验集上，都证明了的更深的网络错误率越小。
论文中给出的具体的网络结构如下：
Resnet50 网络结构我已经在之前的博客中复现过，感兴趣的可以看一下：https://blog.csdn.net/dgvv4/article/details/121878494
感谢简书大佬画的残差网络结构图：https://www.jianshu.com/p/085f4c8256f1
1. 构建单个残差块
一个残差单元的结构如下。输入为X ； weight layer 代表卷积层，这里是指 convolution卷积层 + batch normalization批标准化层；relu 是激活函数 ； identity 是将输入 X 经过变换后与卷积层的输出结果相加，下面会详细说明。
残差块中的 第一个卷积层 self.conv1，主要用于 下采样特征提取。
如果 步长 strides=1，由于 padding='same'，该层的 输入和输出特征图的size不变。属于结构图中左侧蓝色部分。
如果 步长 strides=2，表示 该层输出的特征图的 size 是输入的特征图 size 的一半。由于卷积核的size是 33 ，卷积核移动时会出现滑窗无法覆盖所有的像素格的现象。可能会出现，该层的输出特征图size不等于输入size的一半。 通过padding='same'自动填充输入图像，让输出size等于一半的输入size。*属于结构图中的左侧后三种颜色的部分
残差块中的 第二个卷积层 self.conv2，主要用于 进一步提取特征，不进行下采样。
规定其 步长 stride=1，由于 padding='same'，该层的 输入和输出特征图的size不变 。
完成卷积部分convblock之后，接下来看短接部分identityblock
identity负责 将输入 X的shape 变换到和卷积部分的输出的shape相同。
如果 第一个卷积层 self.conv1的 步长 strides=1，那么 输入特征图的 shape 和卷积层输出的特征图的 shape 相同，这时 identity 不需要变换输入特征图 X 的shape。
如果 第一个卷积层 self.conv1的 步长 strides=2，那么 输入特征图的 size 变成了原来的一半。这时，为了能将输入 X 和 卷积层输出结果相加，需要 通过 identity 重塑输入 X 的shape。这里使用的是 1*1 卷积传递特征， 1*1的卷积核遍历所有的像素格后不会改变特征图的size，设置 步长strides=2，成功将 特征图的size变成原来的一半。属于结构图中的左侧后三种颜色的部分。
这样，我们就完成了对单个残差块中所有层的初始化，接下来 将层之间的 前向传播过程 写在 call() 函数中。这里需要注意的就是 layers.add([out, identity])，将 卷积层的输出特征图的结果和输入的特征图相加。 identity只负责 将输入特征图的 shape 变换成和卷积部分输出特征图的 shape 相同。
该部分的代码如下：
# Basic Bolck 残差块
# x--> 卷积 --> bn --> relu --> 卷积 --> bn --> 输出
# |---------------Identity(短接)----------------|
# 定义子类，一个残差块
class BasicBlock(layers.Layer): # 继承父类的方法和属性
#（1）子类初始化
# filter_num 代表传入卷积核数量，将输入图像的通道数变成残差块的规定的通道数
# stride 代表步长，默认为1，代表不对输入图片的size采样，如果不做padding，得到的图像的size就略小，做padding后输入和输出的size保持一致
# strdie=2时，代表二分采样，输出的size只有输入size的一半
def __init__(self, filter_num, stride=1):
# 继承父类的初始化方法，
# super()中的第一个参数是子类名称，第二个是子类的实例化对象
super(BasicBlock, self).__init__()
# 在父类初始化的基础上添加新的属性
# 卷积层1，传入卷积核数量，卷积核size，步长
# 如果stride=1，为避免输出小于输入，设置padding='same'，使输入等于输出
# 如果stride=2，若输入为32*32，由于卷积核3*3的影响，使输出不等于16*16，这时通过padding=same在输入图像上自动补全，如果输出小于16会自动补成16
self.conv1 = layers.Conv2D(filter_num, (3,3), strides=stride, padding='same')
# 标准化层batchnormalizeation
self.bn1 = layers.BatchNormalization()
# relu激活函数层，没有其他参数，可以作为一个函数使用多次。而有参数设置的一些层，只能单独对应使用
self.relu = layers.Activation('relu')
# 卷积层2，如果上一个卷积层stride=2完成下采样，那么这里的卷积层就不进行下采样了，保持stride=1
self.conv2 = layers.Conv2D(filter_num, (3,3), strides=1, padding='same')
# 标准化层
self.bn2 = layers.BatchNormalization()
# identity层需进行维度变换，将原始输入图像和卷积后的图像相匹配
# 进行1*1卷积匹配通道数，通过stride匹配图像的size
self.downsample = Sequential() # 设置容器
# 在容器中添加1*1卷积和步长变换
# stride保持和第一个卷积层一致，保证convblock和identityblock能直接相加
# 如果第一个卷积层的stride=1时，那么输入和输出的shape保持一致
self.downsample.add(layers.Conv2D(filter_num, (1,1), strides=stride))
#（2）前向传播
# 定义类方法，self为类实例化对象
def call(self, inputs, training=None):
# 卷积层1，调用初始化后的属性
x = self.conv1(inputs) # 输入原始图像
x = self.bn1(x)
x = self.relu(x)
# 卷积层2
x = self.conv2(x)
out = self.bn2(x)
# identity层，输入的是原始输入图像
identity = self.downsample(inputs)
# 将convblock和identityblock相加得到最终的残差块的输出结果
output = layers.add([out, identity])
# 最终结果经过一个非线性函数
output = tf.nn.relu(output)
# 返回残差块的输出结果
return output
2. 叠加多个残差块
上面我们已经成功完成了一个残差块，然而一个残差结构是由多个残差块叠加而成的。下面是放大了的结构图，可见 resnet18中 每一个残差结构是由 2 个残差单元组合而成
我们定义一个函数 build_resblock用来组合残差结构。这里需要注意的是， blocks代表 一个残差结构需要堆叠几个残差单元， resnet18 和 32 中是2个。看结构图可知，在 残差结构中只有第一个残差单元具备下采样改变特征图 size 的能力。因此第一个残差块的 步长 stride，需要根据输入来确定。而 除第一个以外的残差块都不会改变特征图的size，因此 固定步长stride=1 。每一个残差结构的卷积核个数都是相同的，要通过输入来确定。
# 利用单个已定义的残差块，叠加多个残差块
# filter_num，代表当前图像的特征图个数
# blocks，需要代表堆叠几个残差块
# stride，代表当前的步长，等于1
def build_resblock(self, filter_num, blocks, strides=1):
# 使用Sequential容器装填网络结构
res_blocks = Sequential()
# 在ResNet类中对BasicBlock类实例化，构成组合关系
# ResNet类可调用BasicBlock类中的所有属性和方法
# 添加网络层
# 第一个残差块有下采样功能，stride可能等于2
res_blocks.add(BasicBlock(filter_num, strides))
# 每个残差结构中剩余的残差块不具备下采样功能，stride=1
for _ in range(1, blocks):
# 残差结构中剩余的残差块保持图像的shape不变
res_blocks.add(BasicBlock(filter_num, stride=1))
# 返回构建的残差结构
return res_blocks
3. 构建残差网络
我们已经完成了上面剩余区块的构建，现在我们需要做的就是将这些剩余结构堆叠在一起，以形成剩余网络。
[En]
We have completed the construction of the residual blocks above, and now all we need to do is stack these residual structures together in order to form a residual network.
首先我们看初始化函数中的代码。 self.stem是用来 处理原始输入图像的，假设 原始输入的shape为 [224, 224, 3]，根据网络结构图设置预处理卷积层的各个参数。通过 最大池化 layers.MaxPool2D 指定步长为2，将预处理卷积层的 特征图的size减半
接下去就可以根据每个残差结构的配置参数， 第一个残差结构 self.layer1由图可知， 没有进行下采样，因此 步长 stride=1，第一个残差结构中的卷积核个数统一是64个， 每个残差结构由2个残差单元组成 layer_dims=[2,2,2,2]，初始化时都是调用的上面定义的残差结构函数 build_resblock。
第二个残差结构 self.layer2由图可知， 第一个残差块进行了下采样，因此，要指定 步长 strides=2，特征图的 size 减半，特征图的个数统一都是128。同理其他两个残差结构。
最后将残差层的输出结果经过 全局平均池化后放入全连接层，得出分类结果。 layers.GlobalAveragePooling2D()是 在通道维度上对w和h维度求平均值。将 特征图的shape从 [b, w, h, c] 变成 [b, 1, 1, c]
完成对所有层的初始化 init 之后，在 call()方法中定义层与层之间的 前向传播的方法。
# 定义子类ResNet，继承父类keras.Model
class ResNet(keras.Model):
#（1）初始化
# layer_dims=[2,2,2,2]，resnet18包含4个残差结构res_blocks，每个残差结构中有2个残差块
# num_classes 代表最终的输出的分类数
def __init__(self, layer_dims, num_classes=1000):
# 调用父类的初始化方法
super(ResNet, self).__init__(self)
# 分配属性
# 原始图像输入的预处理卷积和池化
self.stem = Sequential([layers.Conv2D(64, (7,7), strides=(2,2), padding='same'), # 3*3卷积提取特征
layers.BatchNormalization(), # 标准化
layers.Activation('relu'), # 激活函数
layers.MaxPool2D(pool_size=(3,3), strides=(2,2), padding='same')]) # 最大池化，输入图像的size减半
# 创建4个残差结构，layer_dims=[2,2,2,2]
self.layer1 = self.build_resblock(64, layer_dims[0]) # 第一个残差结构指定64个卷积核，包含2个残差块
self.layer2 = self.build_resblock(128, layer_dims[1], strides=2) # 第二个残差结构128个卷积核，包含2个残差块，步长为2，图像的size减半
self.layer3 = self.build_resblock(256, layer_dims[2], strides=2)
self.layer4 = self.build_resblock(512, layer_dims[3], strides=2)
# 全局平均池化，不管卷积层输出的长和宽是多少，在channel维度上将所有的长和宽加起来取均值
# [b, w, h, c] ==> [b,c]
self.avgpool = layers.GlobalAveragePooling2D()
# 全连接层用于图像分类
self.fc = layers.Dense(num_classes)
#（2）定义前向传播的类方法
def call(self, inputs, training=None):
# 原始输入经过预处理卷积层
x = self.stem(inputs)
# 经过4个残差结构
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
# 输出层
x = self.avgpool(x) # 输出shape[b,c] --> [None, 512]
x = self.fc(x) # 输出[b,1000]
# 返回分类结果
return x
4. 打印查看网络结构
resnet18 和 resnet34 的差别就在每个残差结构所包含的残差块的个数不同，因此，只需稍作修改修改。我们再看一下这张网络结构表。
resnet18 网络的每个残差层的残差块个数都是2，因此设置参数 ResNet([2, 2, 2, 2])，即可返回网络结构。同理，只需要指定 resnet34网络中每个残差层的残差块个数 ResNet([3, 4, 6, 3])。返回得到了输出层的结果，这时只需设置网络输入层的 输入维度 model.build()，那么整个网络就构建完了。
# 构造resnet18，传入参数
def resnet18():
# 实例化网络结构，一共有4个残差结构，每个残差结构由2个残差块组成
return ResNet([2, 2, 2, 2])
# 构造resnet34，传入参数
def resnet34():
# 实例化，一共有4个残差结构，每个残差结构有如下个数的残差单元
return ResNet([3, 4, 6, 3])
# 主函数
def main():
# 构造网络resnet18
model18 = resnet18()
# 确定输入层
model18.build(input_shape=(None,224,224,3))
# 查看网络结构
model18.summary()
# 构造网络resnet34
model34 = resnet34()
# 确定输入层
model34.build(input_shape=(None,224,224,3))
# 查看网络结构
model34.summary()
if __name__ == '__main__':
main()
利用 model.summary()查看网络具体的结构，其中 第一个 multiple 的值等于 [None, 512]， 第二个 multiple 的值等于 [None, 1000]。下表中，layer 是 sequential 的 Output Shape代表 每一个残差层的输出 shape
resnet18 网络结构如下：
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
sequential (Sequential) (None, 56, 56, 64) 9728
sequential_1 (Sequential) (None, 56, 56, 64) 157056
sequential_4 (Sequential) (None, 28, 28, 128) 543488
sequential_7 (Sequential) (None, 14, 14, 256) 2168320
sequential_10 (Sequential) (None, 7, 7, 512) 8662016
global_average_pooling2d (G multiple 0
lobalAveragePooling2D)
dense (Dense) multiple 513000
=================================================================
Total params: 12,053,608
Trainable params: 12,045,800
Non-trainable params: 7,808
_________________________________________________________________
resnet34 网络结构如下：
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
sequential_13 (Sequential) (None, 56, 56, 64) 9728
sequential_14 (Sequential) (None, 56, 56, 64) 235584
sequential_18 (Sequential) (None, 28, 28, 128) 1168896
sequential_23 (Sequential) (None, 14, 14, 256) 7160320
sequential_30 (Sequential) (None, 7, 7, 512) 13648384
global_average_pooling2d_1 multiple 0
(GlobalAveragePooling2D)
dense_1 (Dense) multiple 513000
=================================================================
Total params: 22,735,912
Trainable params: 22,720,680
Non-trainable params: 15,232
_________________________________________________________________
完整代码：
# 类方法写resnet18、34
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, Sequential
# Basic Bolck 残差块
# x--> 卷积 --> bn --> relu --> 卷积 --> bn --> 输出
# |---------------Identity(短接)----------------|
# 定义子类，一个残差块
class BasicBlock(layers.Layer): # 继承父类的方法和属性
#（2）子类初始化
# filter_num 代表传入卷积核数量，将输入图像的通道数变成残差块的规定的通道数
# stride 代表步长，默认为1，代表不对输入图片的size采样，如果不做padding，得到的图像的size就略小，做padding后输入和输出的size保持一致
# strdie=2时，代表二分采样，输出的size只有输入size的一半
def __init__(self, filter_num, stride=1):
# 继承父类的初始化方法，
# super()中的第一个参数是子类名称，第二个是子类的实例化对象
super(BasicBlock, self).__init__()
# 在父类初始化的基础上添加新的属性
# 卷积层1，传入卷积核数量，卷积核size，步长
# 如果stride=1，为避免输出小于输入，设置padding='same'，使输入等于输出
# 如果stride=2，若输入为32*32，由于卷积核3*3的影响，使输出不等于16*16，这时通过padding=same在输入图像上自动补全，如果输出小于16会自动补成16
self.conv1 = layers.Conv2D(filter_num, (3,3), strides=stride, padding='same')
# 标准化层batchnormalizeation
self.bn1 = layers.BatchNormalization()
# relu激活函数层，没有其他参数，可以作为一个函数使用多次。而有参数设置的一些层，只能单独对应使用
self.relu = layers.Activation('relu')
# 卷积层2，如果上一个卷积层stride=2完成下采样，那么这里的卷积层就不进行下采样了，保持stride=1
self.conv2 = layers.Conv2D(filter_num, (3,3), strides=1, padding='same')
# 标准化层
self.bn2 = layers.BatchNormalization()
# identity层需进行维度变换，将原始输入图像和卷积后的图像相匹配
# 进行1*1卷积匹配通道数，通过stride匹配图像的size
self.downsample = Sequential() # 设置容器
# 在容器中添加1*1卷积和步长变换
# stride保持和第一个卷积层一致，保证convblock和identityblock能直接相加
# 如果第一个卷积层的stride=1时，那么输入和输出的shape保持一致
self.downsample.add(layers.Conv2D(filter_num, (1,1), strides=stride))
#（2）前向传播
# 定义类方法，self为类实例化对象
def call(self, inputs, training=None):
# 卷积层1，调用初始化后的属性
x = self.conv1(inputs) # 输入原始图像
x = self.bn1(x)
x = self.relu(x)
# 卷积层2
x = self.conv2(x)
out = self.bn2(x)
# identity层，输入的是原始输入图像
identity = self.downsample(inputs)
# 将convblock和identityblock相加得到最终的残差块的输出结果
output = layers.add([out, identity])
# 最终结果经过一个非线性函数
output = tf.nn.relu(output)
# 返回残差块的输出结果
return output
#（3）多个残差块叠加
# 定义子类ResNet，继承父类keras.Model
class ResNet(keras.Model):
# 初始化
# layer_dims=[2,2,2,2]，resnet18包含4个残差结构res_blocks，每个残差结构中有2个残差块
# num_classes 代表最终的输出的分类数
def __init__(self, layer_dims, num_classes=1000):
# 调用父类的初始化方法
super(ResNet, self).__init__(self)
# 分配属性
# 原始图像输入的预处理卷积和池化
self.stem = Sequential([layers.Conv2D(64, (7,7), strides=(2,2), padding='same'), # 3*3卷积提取特征
layers.BatchNormalization(), # 标准化
layers.Activation('relu'), # 激活函数
layers.MaxPool2D(pool_size=(3,3), strides=(2,2), padding='same')]) # 最大池化，输入图像的size减半
# 创建4个残差结构，layer_dims=[2,2,2,2]
self.layer1 = self.build_resblock(64, layer_dims[0]) # 第一个残差结构指定64个卷积核，包含2个残差块
self.layer2 = self.build_resblock(128, layer_dims[1], strides=2) # 第二个残差结构128个卷积核，包含2个残差块，步长为2，图像的size减半
self.layer3 = self.build_resblock(256, layer_dims[2], strides=2)
self.layer4 = self.build_resblock(512, layer_dims[3], strides=2)
# 全局平均池化，不管卷积层输出的长和宽是多少，在channel维度上将所有的长和宽加起来取均值
# [b, w, h, c] ==> [b,c]
self.avgpool = layers.GlobalAveragePooling2D()
# 全连接层用于图像分类
self.fc = layers.Dense(num_classes)
# 定义前向传播的类方法
def call(self, inputs, training=None):
# 原始输入经过预处理卷积层
x = self.stem(inputs)
# 经过4个残差结构
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
# 输出层
x = self.avgpool(x) # 输出shape[b,c]
x = self.fc(x) # 输出[b,1000]
# 返回分类结果
return x
# 利用单个已定义的残差块，叠加多个残差块
# filter_num，代表当前图像的特征图个数
# blocks，需要代表堆叠几个残差块
# stride，代表当前的步长，等于1
def build_resblock(self, filter_num, blocks, strides=1):
# 使用Sequential容器装填网络结构
res_blocks = Sequential()
# 在ResNet类中对BasicBlock类实例化，构成组合关系
# ResNet类可调用BasicBlock类中的所有属性和方法
# 添加网络层
# 第一个残差块有下采样功能，stride可能等于2
res_blocks.add(BasicBlock(filter_num, strides))
# 每个残差结构中剩余的残差块不具备下采样功能，stride=1
for _ in range(1, blocks):
# 残差结构中剩余的残差块保持图像的shape不变
res_blocks.add(BasicBlock(filter_num, stride=1))
# 返回构建的残差结构
return res_blocks
# 构造resnet18，传入参数
def resnet18():
# 实例化网络结构，一共有4个残差结构，每个残差结构由2个残差块组成
return ResNet([2, 2, 2, 2])
# 构造resnet34，传入参数
def resnet34():
# 实例化，一共有4个残差结构，每个残差结构有如下个数的残差单元
return ResNet([3, 4, 6, 3])
# 主函数
def main():
# 构造网络resnet18
model18 = resnet18()
# 确定输入层
model18.build(input_shape=(None,224,224,3))
# 查看网络结构
model18.summary()
# 构造网络resnet34
model34 = resnet34()
# 确定输入层
model34.build(input_shape=(None,224,224,3))
# 查看网络结构
model34.summary()
if __name__ == '__main__':
main()
Original: https://blog.csdn.net/dgvv4/article/details/122396424
Author: 立Sir
Title: 【神经网络】(10) Resnet18、34 残差网络复现，附python完整代码
相关阅读
Title: python金融数据分析及可视化
目录
1、数据来源——Wind金融终端
在Wind数据库中下载到的宁德时代（代码300750.SZ）从2020-01-03到2021-12-31共485个数据，包括开盘价，最高价，最低价，收盘价以及交易量。
(需要数据进行操作的同学可以在我的资源上下载，由于Wind资讯金融终端不是免费的，而且作为喜欢白嫖的我们，有什么办法得到免费的数据呢，下次找到了一定分享给大家zll[doge]）
; 2、数据读取及其基本描述
import pandas as pd
import matplotlib.pyplot as plt
data = pd.read_excel('....../300750SZ.xls')
此处注意新版pandas.read_excel()函数并不支持.xlsx文件的读取，因此需要将数据文件类型转化为xls（或者可以用其他库函数，不过我觉得这个办法是最简单的）
df = pd.DataFrame(data)
df.head()
将数据data转化为DataFrame类型，并打印出前五行：
df.describe()
3、收盘价与成交量关系图
df['close'].plot()
df[['close','volume']].plot(subplots=True)
基本上我们就可以得到收盘价与成交量之间的关系图了，但是从两张图中来看，其x轴均不是日期，并且成交量一般使用的是柱状图，所以，我们加一点点细节让图变得好看一些。
list_date = list(df['Date'])
df.index = list_date
price = df['close']
volumes = df['volume']
top = plt.subplot2grid((4,4), (0,0), rowspan=3, colspan=4)
top.plot(price.index, price, label='close')
plt.title('300750.SZ Close Price from 2020-2021')
plt.legend(loc=2)
bottom = plt.subplot2grid((4,4), (3,0), rowspan=1, colspan=4)
bottom.bar(volumes.index, volumes)
plt.title('300750.SZ Daily Trading Volume')
plt.gcf().set_size_inches(12,8)
plt.subplots_adjust(hspace=0.75)
4、收益率曲线
（>......
Original: https://blog.csdn.net/weixin_47974364/article/details/123408886
Author: 貮叁
Title: python金融数据分析及可视化
人工智能
windows下delf配置：delf环境（二）
人工智能
TensorFlow 新手踩坑杂谈
人工智能
浅说正则——会了就不会忘
人工智能
【Anaconda】超简单安装教程 Tensorflow OpenCV
人工智能
【计算机视觉】【聚类】DeepCluster：用于视觉特征无监督学习的深度聚类算法
人工智能
Opencv3.4.6+VS2019+win10安装教程
人工智能
语音识别1： 音频信号采集、并存入 wav文件
人工智能
【流行学习】拉普拉斯映射（Laplacian Eigenmaps）
人工智能
TensorFlow安装和下载详细教程-内附多种解决方案
人工智能
如何快速学会9键打字_微信聊天打字慢，按下这个键一分钟打200字，学会教父母…
人工智能
YOLOv3目标检测全过程记录
人工智能
零售销售数据分析案例实战
人工智能
微信小程序云开发问题篇7_微信小程序调百度语音识别接口问题小记（报错1： invalid audio length 、报错2：json param error 、关于json和row两种方式的请求）
人工智能
ESMap 城市三维地图在气象数据监测的应用-智慧城市数字孪生
人工智能
