经典卷积神经网络简介(使用tensflow实现)

最新推荐文章于 2023-07-04 14:33:45 发布
最新推荐文章于 2023-07-04 14:33:45 发布
阅读量984 收藏 2
点赞数 2
分类专栏： Machine Learning 文章标签： cnn 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy3233/article/details/122812205
版权

参考: https://blog.csdn.net/weixin_39589455/article/details/114950664
https

文章目录

LeNet

参考: https://zhuanlan.zhihu.com/p/82495268
https://blog.csdn.net/zrh_CSDN/article/details/81267873
https://blog.csdn.net/weixin_39589455/article/details/114950664
LeNet又被称为LeNet-5，其之所以称为这个名称是由于原始的LeNet是一个5层的卷积神经网络，它主要包括两部分：
卷积层 2
全连接层 3
在这里插入图片描述
LeNet 各层参数详解：

  1. INPUT层 – 输入层
    输入层通常不被视为网络层次结构
    输入图像尺寸统一进行预处理为 32*32

  2. 第一层卷积使用CBAPD描述
    C(6个55的卷积核, 步长1 填充:valid)
    B: None LetNet提出时还没有BN操作
    A:激活函数 sigmoid
    P: 池化核 2    2 步长2 max:最大池化 填充: valid
    D: None LetNet提出时还没有Dropout操作

  3. 第二层卷积 使用CBAPD描述
    C(16个55的卷积核, 步长1 填充:valid)
    B: None LetNet提出时还没有BN操作
    A:激活函数 sigmoid
    P: 池化核 2    2 步长2 max:最大池化 填充: valid
    D: None LetNet提出时还没有Dropout操作

  4. Flatten层 拉直层

  5. 3个全连接层
    Dense(神经元个数: 120 激活函数: sigmoid)
    Dense(神经元个数: 84 激活函数: sigmoid)
    Dense(神经元个数: 10 激活函数: softmax) # 使输出符合概率分布

小知识点: Input层到C1层叫卷积 经过卷积核降参数
C1层到S2层叫池化,一般使用最大值max(池化矩阵中取最大值)或者平均值mean(池化矩阵中取平均值)
池化和卷积参考: https://blog.csdn.net/weixin_41417982/article/details/81412076

LeNet版cifar10代码如下:

# -*- coding: utf-8 -*-
import tensorflow as tf
import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.python.keras.datasets.cifar import load_batch


def load_cifar10_data():
    # 获取数据  直接使用    tf.keras.datasets.cifar10.load_data() 会报错
    # cifar10数据下载 参考   https://zhuanlan.zhihu.com/p/129078357
    # path 为解压后的路径
    path = 'D:\\Repository\\ai_data\\DeepLearing_TensorFlow2.0-book\\cifar10\\cifar-10-batches-py\\'
    num_train_samples = 50000
    x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')
    y_train = np.empty((num_train_samples,), dtype='uint8')
    for i in range(1, 6):
        fpath = os.path.join(path, 'data_batch_' + str(i))
        (x_train[(i - 1) * 10000:i * 10000, :, :, :],
         y_train[(i - 1) * 10000:i * 10000]) = load_batch(fpath)
    fpath = os.path.join(path, 'test_batch')
    x_test, y_test = load_batch(fpath)
    y_train = np.reshape(y_train, (len(y_train), 1))
    y_test = np.reshape(y_test, (len(y_test), 1))
    if tf.keras.backend.image_data_format() == 'channels_last':
        x_train = x_train.transpose(0, 2, 3, 1)
        x_test = x_test.transpose(0, 2, 3, 1)
    x_test = x_test.astype(x_train.dtype)
    y_test = y_test.astype(y_train.dtype)
    x_train, x_test = x_train / 255.0, x_test / 255.0  # 数据归一化
    return (x_train, y_train), (x_test, y_test)


class LeNetModel(tf.keras.Model):
    def __init__(self):
        super(LeNetModel, self).__init__()
        # 第一层
        self.c1 = tf.keras.layers.Conv2D(filters=6, kernel_size=(5, 5),
                         activation='sigmoid')
        self.p1 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2)

        # 第二层
        self.c2 = tf.keras.layers.Conv2D(filters=16, kernel_size=(5, 5),
                         activation='sigmoid')
        self.p2 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2)
        # 拉直层
        self.flatten = tf.keras.layers.Flatten()
        # 三层全连接层
        self.f1 = tf.keras.layers.Dense(120, activation='sigmoid')
        self.f2 = tf.keras.layers.Dense(84, activation='sigmoid')
        self.f3 = tf.keras.layers.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)
        y = self.f3(x)
        return y


def load_local_model(model_path):
    if os.path.exists(model_path + '/saved_model.pb'):
        tf.print('-------------load the model-----------------')
        local_model = tf.keras.models.load_model(model_path)
    else:
        local_model = LetNetModel()
        local_model.compile(optimizer='adam',
                            loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
                            metrics=['sparse_categorical_accuracy'])
    return local_model


if __name__ == '__main__':
    (x_train, y_train), (x_test, y_test) = load_cifar10_data()
    model_path = "./data/model/cifar/letnet"
    model = load_local_model(model_path)
    # 机器垃圾 跑不快 运行3次
    history = model.fit(x_train, y_train, batch_size=32, epochs=3, validation_data=(x_test, y_test),
                                 validation_freq=1)
    model.summary()
    # 保存模型
    model.save(model_path, save_format="tf")

AlexNet

参考: https://zhuanlan.zhihu.com/p/42914388
2012年出现,AlexNet使用relu激活函数,提省了训练速度,使用Dropout缓解了过拟合。
AlexNet共有8层, 5层卷积，3层全连接层。
在这里插入图片描述
AlexNet 各层参数详解：

  1. 第一层卷积使用CBAPD描述
    C(96个33的卷积核, 步长1 填充:valid)
    B: Yes , LRN
    A:激活函数 relu
    P: 池化核 2    2 步长2 max:最大池化 填充: valid
    D: None
  2. 第二层卷积使用CBAPD描述
    C(256个33的卷积核, 步长1 填充:valid)
    B: Yes , LRN
    A:激活函数 relu
    P: 池化核 3    3 步长2 max:最大池化 填充: valid
    D: None
  3. 第三层卷积使用CBAPD描述
    C(384个3*3的卷积核, 步长1 填充:same)
    B: None
    A:激活函数 relu
    P: None
    D: None
  4. 第四层卷积使用CBAPD描述
    C(384个3*3的卷积核, 步长1 填充:same)
    B: None
    A:激活函数 relu
    P: None
    D: None
  5. 第五层卷积使用CBAPD描述
    C(256个33的卷积核, 步长1 填充:same)
    B: None
    A: 激活函数 relu
    P: 池化核 3    3 步长2 max:最大池化 填充: valid
    D: None
  6. Flatten拉直层
  7. 全连接层
    Dense(神经元:2048,激活函数: relu,Dropout: 0.5 )
    Dense(神经元:2048,激活函数: relu,Dropout: 0.5 )
    Dense(神经元:10,激活函数:softmax)

AlexNet 运行需要大量资源 cpu电脑就不要尝试了

AlexNet版cifar10代码如下:

# -*- coding: utf-8 -*-
import tensorflow as tf
import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.python.keras.datasets.cifar import load_batch


def load_cifar10_data():
    # 获取数据  直接使用    tf.keras.datasets.cifar10.load_data() 会报错
    # cifar10数据下载 参考   https://zhuanlan.zhihu.com/p/129078357
    # path 为解压后的路径
    path = 'D:\\Repository\\ai_data\\DeepLearing_TensorFlow2.0-book\\cifar10\\cifar-10-batches-py\\'
    num_train_samples = 50000
    x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')
    y_train = np.empty((num_train_samples,), dtype='uint8')
    for i in range(1, 6):
        fpath = os.path.join(path, 'data_batch_' + str(i))
        (x_train[(i - 1) * 10000:i * 10000, :, :, :],
         y_train[(i - 1) * 10000:i * 10000]) = load_batch(fpath)
    fpath = os.path.join(path, 'test_batch')
    x_test, y_test = load_batch(fpath)
    y_train = np.reshape(y_train, (len(y_train), 1))
    y_test = np.reshape(y_test, (len(y_test), 1))
    if tf.keras.backend.image_data_format() == 'channels_last':
        x_train = x_train.transpose(0, 2, 3, 1)
        x_test = x_test.transpose(0, 2, 3, 1)
    x_test = x_test.astype(x_train.dtype)
    y_test = y_test.astype(y_train.dtype)
    x_train, x_test = x_train / 255.0, x_test / 255.0  # 数据归一化
    return (x_train, y_train), (x_test, y_test)


class AlexNetModel(tf.keras.Model):
    def __init__(self):
        super(AlexNetModel, self).__init__()
        self.c1 = tf.keras.layers.Conv2D(filters=96, kernel_size=(3, 3))
        self.b1 = tf.keras.layers.BatchNormalization()
        self.a1 = tf.keras.layers.Activation('relu')
        self.p1 = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=2)

        self.c2 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3))
        self.b2 = tf.keras.layers.BatchNormalization()
        self.a2 = tf.keras.layers.Activation('relu')
        self.p2 = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=2)

        self.c3 = tf.keras.layers.Conv2D(filters=384, kernel_size=(3, 3), padding='same',
                         activation='relu')

        self.c4 = tf.keras.layers.Conv2D(filters=384, kernel_size=(3, 3), padding='same',
                         activation='relu')

        self.c5 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same',
                         activation='relu')
        self.p3 = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=2)

        self.flatten = tf.keras.layers.Flatten()
        self.f1 = tf.keras.layers.Dense(2048, activation='relu')
        self.d1 = tf.keras.layers.Dropout(0.5)
        self.f2 = tf.keras.layers.Dense(2048, activation='relu')
        self.d2 = tf.keras.layers.Dropout(0.5)
        self.f3 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)
        x = self.p1(x)

        x = self.c2(x)
        x = self.b2(x)
        x = self.a2(x)
        x = self.p2(x)

        x = self.c3(x)

        x = self.c4(x)

        x = self.c5(x)
        x = self.p3(x)

        x = self.flatten(x)
        x = self.f1(x)
        x = self.d1(x)
        x = self.f2(x)
        x = self.d2(x)
        y = self.f3(x)
        return y


def load_local_model(model_path):
    if os.path.exists(model_path + '/saved_model.pb'):
        tf.print('-------------load the model-----------------')
        local_model = tf.keras.models.load_model(model_path)
    else:
        local_model = AlexNetModel()
        local_model.compile(optimizer='adam',
                            loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
                            metrics=['sparse_categorical_accuracy'])
    return local_model


if __name__ == '__main__':
    (x_train, y_train), (x_test, y_test) = load_cifar10_data()
    model_path = "./data/model/cifar/alexnet"
    model = load_local_model(model_path)
    # 机器垃圾 跑不快 运行1次  cpu电脑一次也别跑了
    history = model.fit(x_train, y_train, batch_size=32, epochs=3, validation_data=(x_test, y_test),
                                 validation_freq=1)
    model.summary()
    # 保存模型
    model.save(model_path, save_format="tf")

VGGNet

诞生于2014年,VGGNet使用小尺寸卷积核,在减少参数的同时,提高了识别准确率。 VGGNet的网络结构规整,非常适合硬件加速(也就是说VGGNet更耗资源,cpu机器带不动了)
以VGGNet16为例
还是卷积层+ 全连接层
VGGNet版cifar10代码如下:

# -*- coding: utf-8 -*-
import tensorflow as tf
import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.python.keras.datasets.cifar import load_batch


def load_cifar10_data():
    # 获取数据  直接使用    tf.keras.datasets.cifar10.load_data() 会报错
    # cifar10数据下载 参考   https://zhuanlan.zhihu.com/p/129078357
    # path 为解压后的路径
    path = 'D:\\Repository\\ai_data\\DeepLearing_TensorFlow2.0-book\\cifar10\\cifar-10-batches-py\\'
    num_train_samples = 50000
    x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')
    y_train = np.empty((num_train_samples,), dtype='uint8')
    for i in range(1, 6):
        fpath = os.path.join(path, 'data_batch_' + str(i))
        (x_train[(i - 1) * 10000:i * 10000, :, :, :],
         y_train[(i - 1) * 10000:i * 10000]) = load_batch(fpath)
    fpath = os.path.join(path, 'test_batch')
    x_test, y_test = load_batch(fpath)
    y_train = np.reshape(y_train, (len(y_train), 1))
    y_test = np.reshape(y_test, (len(y_test), 1))
    if tf.keras.backend.image_data_format() == 'channels_last':
        x_train = x_train.transpose(0, 2, 3, 1)
        x_test = x_test.transpose(0, 2, 3, 1)
    x_test = x_test.astype(x_train.dtype)
    y_test = y_test.astype(y_train.dtype)
    x_train, x_test = x_train / 255.0, x_test / 255.0  # 数据归一化
    return (x_train, y_train), (x_test, y_test)


class VGGNetModel(tf.keras.Model):
    def __init__(self):
        super(VGGNetModel, self).__init__()
        # vgg是两次CBA CBAPD
        # 第一层 CBA
        self.c1 = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same')  # 卷积层1
        self.b1 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a1 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第二层 CBAPD
        self.c2 = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same', )
        self.b2 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a2 = tf.keras.layers.Activation('relu')  # 激活层1
        self.p2 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d2 = tf.keras.layers.Dropout(0.2)  # dropout层

        # 第三层 CBA
        self.c3 = tf.keras.layers.Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b3 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a3 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第四层 CBAPD
        self.c4 = tf.keras.layers.Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b4 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a4 = tf.keras.layers.Activation('relu')  # 激活层1
        self.p4 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d4 = tf.keras.layers.Dropout(0.2)  # dropout层

        # 随后三次 CBA CBA CBAPD
        # 第五层 CBA
        self.c5 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b5 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a5 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第6层 CBA
        self.c6 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b6 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a6 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第7层 CBAPD
        self.c7 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b7 = tf.keras.layers.BatchNormalization()
        self.a7 = tf.keras.layers.Activation('relu')
        self.p7 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d7 = tf.keras.layers.Dropout(0.2)

        # 第8层 CBA
        self.c8 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b8 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a8 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第9层 CBA
        self.c9 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b9 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a9 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第10层 CBAPD
        self.c10 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b10 = tf.keras.layers.BatchNormalization()
        self.a10 = tf.keras.layers.Activation('relu')
        self.p10 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d10 = tf.keras.layers.Dropout(0.2)

        # 第11层 CBA
        self.c11 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b11 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a11 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第12层 CBA
        self.c12 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b12 = tf.keras.layers.BatchNormalization()  # BN层1
        self.a12 = tf.keras.layers.Activation('relu')  # 激活层1

        # 第13层 CBAPD
        self.c13 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b13 = tf.keras.layers.BatchNormalization()
        self.a13 = tf.keras.layers.Activation('relu')
        self.p13 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d13 = tf.keras.layers.Dropout(0.2)

        # 拉直层
        self.flatten = tf.keras.layers.Flatten()
        # 第14层 全连接层
        self.f14 = tf.keras.layers.Dense(512, activation='relu')
        self.d14 = tf.keras.layers.Dropout(0.2)

        # 第15层 全连接层
        self.f15 = tf.keras.layers.Dense(512, activation='relu')
        self.d15 = tf.keras.layers.Dropout(0.2)

        # 第16层 全连接层
        self.f16 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)

        x = self.c2(x)
        x = self.b2(x)
        x = self.a2(x)
        x = self.p2(x)
        x = self.d2(x)

        x = self.c3(x)
        x = self.b3(x)
        x = self.a3(x)

        x = self.c4(x)
        x = self.b4(x)
        x = self.a4(x)
        x = self.p4(x)
        x = self.d4(x)

        x = self.c5(x)
        x = self.b5(x)
        x = self.a5(x)

        x = self.c6(x)
        x = self.b6(x)
        x = self.a6(x)

        x = self.c7(x)
        x = self.b7(x)
        x = self.a7(x)
        x = self.p7(x)
        x = self.d7(x)

        x = self.c8(x)
        x = self.b8(x)
        x = self.a8(x)

        x = self.c9(x)
        x = self.b9(x)
        x = self.a9(x)

        x = self.c10(x)
        x = self.b10(x)
        x = self.a10(x)
        x = self.p10(x)
        x = self.d10(x)

        x = self.c11(x)
        x = self.b11(x)
        x = self.a11(x)

        x = self.c12(x)
        x = self.b12(x)
        x = self.a12(x)

        x = self.c13(x)
        x = self.b13(x)
        x = self.a13(x)
        x = self.p13(x)
        x = self.d13(x)

        x = self.flatten(x)
        x = self.f14(x)
        x = self.d14(x)

        x = self.f15(x)
        x = self.d15(x)

        y = self.f16(x)
        return y


def load_local_model(model_path):
    if os.path.exists(model_path + '/saved_model.pb'):
        tf.print('-------------load the model-----------------')
        local_model = tf.keras.models.load_model(model_path)
    else:
        local_model = VGGNetModel()
        local_model.compile(optimizer='adam',
                            loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
                            metrics=['sparse_categorical_accuracy'])
    return local_model


if __name__ == '__main__':
    (x_train, y_train), (x_test, y_test) = load_cifar10_data()
    model_path = "./data/model/cifar/vgg"
    model = load_local_model(model_path)
    # 机器垃圾 跑不快 运行1次
    history = model.fit(x_train, y_train, batch_size=32, epochs=1, validation_data=(x_test, y_test),
                        validation_freq=1)
    model.summary()
    # 保存模型
    model.save(model_path, save_format="tf")

inceptionNet

InceptionNet诞生于2014年,它引入了Inception结构块
在同一层网络内使用不同尺寸的卷积核,提升了感知力,使用了批标准化,缓解了梯度消失。(GoogleNet即inception-V1)
InceptionNet核心是它的基本单元Inception机构块

Inception机构块
在这里插入图片描述
InceptionNet在同一层网络内使用不同尺寸的卷积核,可以提取不同尺寸的特征,
通过11卷积核 作用到每个输入特征图的每个像素点,通过设定少于输入特征深度的11卷积核个数,减少了输出特征图深度,起到了降维的作用,减少了参数量和计算量
Inception结构块包含4个分支

  1. 经过1*1卷积核输出到卷积连接器
  2. 经过11卷积核配合33卷积核输出到卷积连接器
  3. 经过11卷积核配合55卷积核输出到卷积连接器
  4. 经过33最大池化核配合11卷积核输出到卷积连接器
    送到卷积连接器的特征尺寸相同,卷积连接器会把接收到的四路特征数据按深度方向拼接,行程Inception结构块的输出
    InceptionNet版cifar10代码
# -*- coding: utf-8 -*-
import tensorflow as tf
import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.python.keras.datasets.cifar import load_batch


def load_cifar10_data():
    # 获取数据  直接使用    tf.keras.datasets.cifar10.load_data() 会报错
    # cifar10数据下载 参考   https://zhuanlan.zhihu.com/p/129078357
    # path 为解压后的路径
    path = 'D:\\Repository\\ai_data\\DeepLearing_TensorFlow2.0-book\\cifar10\\cifar-10-batches-py\\'
    num_train_samples = 50000
    x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')
    y_train = np.empty((num_train_samples,), dtype='uint8')
    for i in range(1, 6):
        fpath = os.path.join(path, 'data_batch_' + str(i))
        (x_train[(i - 1) * 10000:i * 10000, :, :, :],
         y_train[(i - 1) * 10000:i * 10000]) = load_batch(fpath)
    fpath = os.path.join(path, 'test_batch')
    x_test, y_test = load_batch(fpath)
    y_train = np.reshape(y_train, (len(y_train), 1))
    y_test = np.reshape(y_test, (len(y_test), 1))
    if tf.keras.backend.image_data_format() == 'channels_last':
        x_train = x_train.transpose(0, 2, 3, 1)
        x_test = x_test.transpose(0, 2, 3, 1)
    x_test = x_test.astype(x_train.dtype)
    y_test = y_test.astype(y_train.dtype)
    x_train, x_test = x_train / 255.0, x_test / 255.0  # 数据归一化
    return (x_train, y_train), (x_test, y_test)


class ConvBNRelu(tf.keras.Model):
    '''
    Inception结构块中的4个分支都包含相同结构(CBA结构)
    可以写成一个类 从而减少代码长度

    '''

    #
    def __init__(self, filters, kernel_size=3, strides=1, padding='same'):
        super(ConvBNRelu, self).__init__()
        self.model = tf.keras.models.Sequential([
            tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, padding=padding),
            tf.keras.layers.BatchNormalization(),
            tf.keras.layers.Activation('relu')
        ])

    def call(self, x):
        # 在training=False时，BN通过整个训练集计算均值、方差去做批归一化，training=True时，通过当前batch的均值、方差去做批归一化。推理时 training=False效果好
        x = self.model(x, training=False)
        return x


class InceptionStruct(tf.keras.Model):
    '''
    Inception结构块
    filters, kernel_size=3, strides=1, padding='same'
    '''

    def __init__(self, filters, strides=1):
        super(InceptionStruct, self).__init__()
        self.filters = filters
        self.strides = strides
        self.c1 = ConvBNRelu(filters, kernel_size=1, strides=strides)
        self.c2_1 = ConvBNRelu(filters, kernel_size=1, strides=strides)
        self.c2_2 = ConvBNRelu(filters, kernel_size=3, strides=1)
        self.c3_1 = ConvBNRelu(filters, kernel_size=1, strides=strides)
        self.c3_2 = ConvBNRelu(filters, kernel_size=5, strides=1)
        self.p4_1 = tf.keras.layers.MaxPool2D(3, strides=1, padding='same')
        self.c4_2 = ConvBNRelu(filters, kernel_size=1, strides=strides)

    def call(self, x):
        x1 = self.c1(x)
        x2_1 = self.c2_1(x)
        x2_2 = self.c2_2(x2_1)
        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)
        # 使用concat函数将他们堆叠在一起
        x = tf.concat([x1, x2_2, x3_2, x4_2], axis=3)
        return x


class InceptionModel(tf.keras.Model):
    def __init__(self, num_blocks, num_classes, init_ch=16, **kwargs):
        super(InceptionModel, 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 = InceptionStruct(self.out_channels, strides=2)
                else:
                    block = InceptionStruct(self.out_channels, strides=1)
                self.blocks.add(block)
            # enlarger out_channels per block
            self.out_channels *= 2
        self.p1 = tf.keras.layers.GlobalAveragePooling2D()
        self.f1 = tf.keras.layers.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


def load_local_model(model_path):
    if os.path.exists(model_path + '/saved_model.pb'):
        tf.print('-------------load the model-----------------')
        local_model = tf.keras.models.load_model(model_path)
    else:
        local_model = InceptionModel(num_blocks=2, num_classes=10)
        local_model.compile(optimizer='adam',
                            loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
                            metrics=['sparse_categorical_accuracy'])
    return local_model


if __name__ == '__main__':
    (x_train, y_train), (x_test, y_test) = load_cifar10_data()
    # 数据量太大跑不动 仅用作测试
    (x_train, y_train), (x_test, y_test) = (x_train[0:256], y_train[0:256]), (x_test[0:256], y_test[0:256])
    model_path = "./data/model/cifar/inception"
    model = load_local_model(model_path)
    history = model.fit(x_train, y_train, batch_size=32, epochs=6, validation_data=(x_test, y_test),
                        validation_freq=1)
    model.summary()
    # 保存模型
    model.save(model_path, save_format="tf")

ResNet

ResNet诞生于2015年,ResNet提出了层间残差跳连,引入了前方信息,缓解梯度消失, 使神经网络层数增加成为可能。
在这里插入图片描述
ResNet块有两种形式
一种在堆叠卷积前后维度不同
一种在堆叠卷积前后维度相同
ResNet版cifar10代码

# -*- coding: utf-8 -*-
import tensorflow as tf
import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.python.keras.datasets.cifar import load_batch


def load_cifar10_data():
    # 获取数据  直接使用    tf.keras.datasets.cifar10.load_data() 会报错
    # cifar10数据下载 参考   https://zhuanlan.zhihu.com/p/129078357
    # path 为解压后的路径
    path = 'D:\\Repository\\ai_data\\DeepLearing_TensorFlow2.0-book\\cifar10\\cifar-10-batches-py\\'
    num_train_samples = 50000
    x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')
    y_train = np.empty((num_train_samples,), dtype='uint8')
    for i in range(1, 6):
        fpath = os.path.join(path, 'data_batch_' + str(i))
        (x_train[(i - 1) * 10000:i * 10000, :, :, :],
         y_train[(i - 1) * 10000:i * 10000]) = load_batch(fpath)
    fpath = os.path.join(path, 'test_batch')
    x_test, y_test = load_batch(fpath)
    y_train = np.reshape(y_train, (len(y_train), 1))
    y_test = np.reshape(y_test, (len(y_test), 1))
    if tf.keras.backend.image_data_format() == 'channels_last':
        x_train = x_train.transpose(0, 2, 3, 1)
        x_test = x_test.transpose(0, 2, 3, 1)
    x_test = x_test.astype(x_train.dtype)
    y_test = y_test.astype(y_train.dtype)
    x_train, x_test = x_train / 255.0, x_test / 255.0  # 数据归一化
    return (x_train, y_train), (x_test, y_test)


class ResStruct(tf.keras.Model):
    '''
    Res结构块
    filters, kernel_size=3, strides=1, residual_path
    '''

    def __init__(self, filters, strides=1, residual_path=False):
        super(ResStruct, self).__init__()
        self.filters = filters
        self.strides = strides
        self.residual_path = residual_path

        self.c1 = tf.keras.layers.Conv2D(filters, (3, 3), strides=strides, padding='same', use_bias=False)
        self.b1 = tf.keras.layers.BatchNormalization()
        self.a1 = tf.keras.layers.Activation('relu')

        self.c2 = tf.keras.layers.Conv2D(filters, (3, 3), strides=1, padding='same', use_bias=False)
        self.b2 = tf.keras.layers.BatchNormalization()

        # residual_path为True时，对输入进行下采样，即用1x1的卷积核做卷积操作，保证x能和F(x)维度相同，顺利相加
        if residual_path:
            self.down_c1 = tf.keras.layers.Conv2D(filters, (1, 1), strides=strides, padding='same', use_bias=False)
            self.down_b1 = tf.keras.layers.BatchNormalization()

        self.a2 = tf.keras.layers.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 ResNetModel(tf.keras.Model):
    def __init__(self, block_list, initial_filters=64):  # block_list表示每个block有几个卷积层
        super(ResNetModel, self).__init__()
        self.num_blocks = len(block_list)  # 共有几个block
        self.block_list = block_list
        self.out_filters = initial_filters
        self.c1 = tf.keras.layers.Conv2D(self.out_filters, (3, 3), strides=1, padding='same', use_bias=False)
        self.b1 = tf.keras.layers.BatchNormalization()
        self.a1 = tf.keras.layers.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 = ResStruct(self.out_filters, strides=2, residual_path=True)
                else:
                    block = ResStruct(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


def load_local_model(model_path):
    if os.path.exists(model_path + '/saved_model.pb'):
        tf.print('-------------load the model-----------------')
        local_model = tf.keras.models.load_model(model_path)
    else:
        local_model = ResNetModel([2, 2, 2, 2])
        local_model.compile(optimizer='adam',
                            loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
                            metrics=['sparse_categorical_accuracy'])
    return local_model


if __name__ == '__main__':
    (x_train, y_train), (x_test, y_test) = load_cifar10_data()
    (x_train, y_train), (x_test, y_test) = (x_train[0:256], y_train[0:256]), (x_test[0:256], y_test[0:256])
    model_path = "./data/model/cifar/resnet"
    model = load_local_model(model_path)
    # 机器垃圾 跑不快 运行3次
    history = model.fit(x_train, y_train, batch_size=64, epochs=3, validation_data=(x_test, y_test),
                                 validation_freq=1)
    model.summary()
    # 保存模型
    model.save(model_path, save_format="tf")

经典神经网络小结:
在这里插入图片描述

Fuly1024
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
tensorflow实践
wzl_python的博客
05-01 341
tensorflow的安装1. Anaconda的安装1.1 从官网下载Anaconda1.2 软件的安装2.TensorFlow-CPU版本的安装3. tensorflow-gpu 版本的安装3.2 CUDA与cudnn的安装3.2 tensorflow-gpu版本的安装3.3 Jupyter Notebook的安装4. 验证是否安装成功5. 安装总结5.1 CPU版本的安装比较简单5.2 GP...
深度学习之卷积神经网络CNN及tensorflow代码实现示例
热门推荐
cxmscb的博客
05-01 22万+
一、CNN的引入在人工的全连接神经网络中，每相邻两层之间的每个神经元之间都是有边相连的。当输入层的特征维度变得很高时，这时全连接网络需要训练的参数就会增大很多，计算速度就会变得很慢，例如一张黑白的 28×2828×28 的手写数字图片，输入层的神经元就有784个，如下图所示： 若在中间只使用一层隐藏层，参数 ww 就有 784×15=11760784×15 = 11760 多个；若输入的
数十种TensorFlow实现案例汇集：代码+笔记
Jingle的专栏
10-18 1万+
2016-10-17 13:08:31    开源    0 0 0 这是使用 TensorFlow 实现流行的机器学习算法的教程汇集。本汇集的目标是让读者可以轻松通过案例深入 TensorFlow。 这些案例适合那些想要清晰简明的 TensorFlow 实现案例的初学者。本教程还包含了笔记和带有注解的代码。 项目地址：https://github.com/
Tensor FLow简单使用
theVicTory的博客
07-09 966
1、基础概念 Tensor表示张量，是一种多维数组的数据结构。Flow代表流，是指张量之间通过计算而转换的过程。TensorFLow通过一个计算图的形式表示编程过程，数据在每个节点之间流动，经过节点加工之后流向下一个节点。 计算图是一个有向图，其组成如下：节点：代表一个操作。边：代表节点之间的数据传递和控制依赖，其中实线代表两个节点之间的数据传递关系，虚线代表两个节点之间存在控制相关。 张量...
Tensorflow1.0 第一集: 最简单的神经网络
好好做人
07-23 260
Tensorflow 1.0 第一集 （希望实习结束的时候就算我没学会tableau，也能学会Tensorflow吧！） 定义会话 import tensorflow as tf m1 = tf.constant([[3,3]]) m2 = tf.constant([[2],[3]]) product = tf.matmul(m1, m2) print(product) # 定义一个会话，启动默认图 Sess = tf.Session() print(Sess.run(product)) Sess.cl
tensflow
weixin_48993940的博客
09-27 989
rang（3）循环三次 常用的一个优化器 梯度下降 规定训练次数，in range
卷积神经网络验证码识别tensorflow实现
07-14
在这个“卷积神经网络验证码识别tensorflow实现”的项目中，我们使用了CNN来解决四位数字和字母组成的验证码识别问题。验证码识别是计算机视觉领域的一个常见任务，它有助于防止自动化机器人和恶意软件对网站的滥用...
卷积神经网络-基于tensorflow实现的人脸识别卷积神经网络.zip
05-03
总之，这个基于TensorFlow实现的人脸识别卷积神经网络项目展示了如何利用深度学习技术解决实际问题。通过对图像数据的处理、模型构建、训练和优化，我们可以构建一个高效、准确的人脸识别系统。在不断学习和实践中，...
卷积神经网络-基于tensorflow实现的人脸性别检测算法.zip
最新发布
05-03
本项目通过TensorFlow实现的卷积神经网络，为理解深度学习在人脸识别和性别检测领域的应用提供了一个很好的实例。通过学习和实践，开发者可以掌握CNN和TensorFlow的关键概念，进而应用于其他计算机视觉任务。
神经网络（tensroflow)
weixin_43928799的博客
04-20 273
卷积神经网络 class Baseline(Model): def __init__(self): super(Baseline, self).__init__() sefl.c1 = Conv2D(filters=6, kernel_size=(5, 5), padding='same') self.b1 = BatchNormalization() self.a1 = Activation('relu') self.p1 = MaxPool2D(pool_size=(2,2),
TensFlow样例文件
04-08
TensorFlow™ 是一个采用数据流图(data flow graphs),用于数值计算的开源软件库。节点(Nodes)在图中表示数学操作,图中的线(edges)则表示在节点间相互联系的多维.
Tensflow实战pdf 高清
04-12
高清无删减无广告，回馈研究人员。！！！！！！！！！！！！！！！！！
我的Tensorflow学习之路
大学之道，在明明德
09-27 2万+
最近两年深度学习真的是火的不要不要的，关于深度学习，每个人都有自己的看法。有人说就是炼丹，得个准确率召回率什么的，拿到实际中，问问为什么，都答不上来。各种连代码都没写过的人，也纷纷表示这东西就是小孩堆积木，然后整个大功耗的服务器跑上几天，调调参数。然后每个实验室招生，都说自己是做什么深度学习，机器 学习，大数据分析的，以此来吸引学生。可是可是，他们实验室很可能连一块 GPU 都没有。 小时候，我
入门tenserflow(简单神经网络，识别花鸢尾花初实践)
qq_40533899的博客
03-17 513
from sklearn import datasets from pandas import DataFrame import pandas as pd x_data=datasets.load_iris().data #return the flowers dataset print("x_data: \n",x_data) y_data=datasets.load_iris().target #the iris tag print("y_data\n",y_data) x_data=DataFr.
Tensorflow入门（1）——深度学习框架Tesnsflow入门 & 环境配置 & 认识Tensorflow
Arya的博客，专注后端领域
07-04 2276
2、 tf.app.flags.,在flags有一个FLAGS标志，它在程序中可以调用到我们前面具体定义的flag_name3、通过tf.app.run()启动main(argv)函数# 定义命令行参数# 1 、首先定义有哪些参数需要在运行时候指定# 2 、程序当中获取定义命令行参数。
用Tensflow写简单的神经网络
Sonnet
02-25 2891
一个简单神经网络所具有的模块结构，首先输入层(Input Layer)，接受相关的结构化化数据；其次是隐藏层(Hidden Layer)，隐藏层主要加权运算，通过激活函数达到拟合线性非线性函数的目的；最后有输出层(Output Layer)，其结果成为下一次迭代的初始值。
机器学习笔记4：TensorFlow基础入门介绍
ChenHaoUESTC的博客
08-26 1248
机器学习笔记4：TensorFlow基础入门介绍
TensorFlow介绍_中文版
SnailTyan
10-03 4057
TensorFlow是一个关于机器智能的开源软件库
TensorFlow 教程 - 新手入门笔记
云笔记
12-13 7万+
介绍TensorFlow™ 是一个采用数据流图（data flow graphs），用于数值计算的开源软件库。TensorFlow 最初由Google大脑小组（隶属于Google机器智能研究机构）的研究员和工程师们开发出来，用于机器学习和深度神经网络方面的研究，但这个系统的通用性使其也可广泛用于其他计算领域。它是谷歌基于DistBelief进行研发的第二代人工智能学习系统。2015年11月9日，Go
卷积神经网络怎么使用tensorflow和keras
05-12
在TensorFlow和Keras中，使用卷积神经网络模型非常简单，下面是一个基本的例子： 首先，导入必要的库： ```python import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers ``...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值