深度学习模型Lenet5/GoogleNet的代码（TensorFlow）

穆月月

已于 2024-02-21 12:47:25 修改

阅读量450

点赞数 8

分类专栏：深度学习文章标签：深度学习 tensorflow 人工智能

于 2023-11-22 20:50:55 首次发布

本文链接：https://blog.csdn.net/m0_73704655/article/details/134562317

版权

深度学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Lenet5

import tensorflow as tf
from tensorflow import keras
import numpy as np
import os
import pandas as pd
import matplotlib.pyplot as plt
 
# 加载MNIST数据集
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
 
# 对数据进行归一化和重塑，将图像的像素值归一化到[0, 1]范围内，以便在神经网络中进行训练。
x_train_scaled = x_train.astype(np.float32) / 255.0
x_test_scaled = x_test.astype(np.float32) / 255.0
 
# 划分验证集
from sklearn.model_selection import train_test_split
x_train_scaled, x_valid_scaled, y_train, y_valid = train_test_split(x_train_scaled, y_train, test_size=0.1, random_state=42)
 
print("训练集大小:", x_train_scaled.shape, y_train.shape)
print("验证集大小:", x_valid_scaled.shape, y_valid.shape)
 
#数据标准化
from sklearn.preprocessing import StandardScaler
scaler=StandardScaler()
x_train_scaled = scaler.fit_transform(x_train_scaled.astype(np.float32).reshape(-1,1)).reshape(-1,28,28,1)
x_valid_scaled = scaler.transform(x_valid_scaled.astype(np.float32).reshape(-1,1)).reshape(-1,28,28,1)
x_test_scaled = scaler.transform(x_test.astype(np.float32).reshape(-1,1)).reshape(-1,28,28,1)
 
#构建CNN模型
model = tf.keras.models.Sequential([
    #卷积层，6个滤波器，尺寸为5×5，
    keras.layers.Conv2D(filters = 6,kernel_size=5,activation='sigmoid',input_shape=(28,28,1),padding='same'),
    #最大池化层，窗口大小2×2，移动步长为2
    keras.layers.MaxPool2D(pool_size = 2,strides = 2),
    keras.layers.Conv2D(filters = 16,kernel_size=5,activation='sigmoid',input_shape=(28,28,1)),
    keras.layers.MaxPool2D(pool_size = 2,strides = 2),
    #扁平化层，将之前卷积层和池化层输出的多维特征图展开成一个一维向量，为全连接层的输入做准备
    keras.layers.Flatten(),
    #这是一个全连接层，包含120个神经元。
    keras.layers.Dense(120,activation = 'sigmoid'),
    #这是一个全连接层，包含84个神经元。
    keras.layers.Dense(84,activation = 'sigmoid'),
    #这是输出层，包含10个神经元
    keras.layers.Dense(10,activation = 'sigmoid'),
])
 
#设置回调函数
logdir = 'D:/cnn3'#定义了一个文件路径 logdir，用于存储日志和模型文件
if not os.path.exists(logdir):
    os.mkdir(logdir)
output_model_file=os.path.join(logdir,"output_model.h5")#创建一个指向输出模型文件的路径
callbacks=[#创建列表，包含3个不同的回调函数
    keras.callbacks.ModelCheckpoint(output_model_file, save_best_only=True),#在每个训练周期结束时保存模型
    keras.callbacks.EarlyStopping(patience = 5,min_delta = 1e-3),
    #监视模型的指标，如果经过 patience 个训练周期（这里是5个周期）模型性能没有提升超过 min_delta （这里是0.001），则停止训练。这可以避免过拟合，节省训练时间。
    keras.callbacks.TensorBoard(log_dir=logdir)
    #将训练过程中的日志信息保存到指定的 logdir 路径中
]
 
#编译模型，使用交叉熵作为损失函数，随机梯度下降（SGD）作为优化器，准确率作为评估指标。
model.compile(loss='sparse_categorical_crossentropy',optimizer=keras.optimizers.SGD(learning_rate=0.9),metrics=['accuracy'])
 
 
#训练模型，使用训练数据训练模型，进行10个epochs的训练，使用256批量大小。
history=model.fit(x_train_scaled,y_train,epochs=10,batch_size=256,callbacks=callbacks,validation_data=(x_valid_scaled,y_valid))
 
#绘制学习曲线，这个函数用于绘制训练过程中的损失和准确率的变化情况，以便进行可视化分析
def plot_learning_curves(history):
    pd.DataFrame(history.history).plot(figsize=(8,3))
    plt.grid(True)
    plt.show()
plot_learning_curves(history)

GoogleNet

# %%
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
from tensorflow.keras.datasets import fashion_mnist
from tensorflow.keras import layers, models
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import SparseCategoricalCrossentropy
import pandas as pd

# %%


# %%
class Inception(tf.keras.layers.Layer):
    def __init__(self, in_c, c1, c2, c3, c4):
        super(Inception, self).__init__()
        self.p1_1 = tf.keras.layers.Conv2D(c1, kernel_size=1, activation='relu')
        self.p2_1 = tf.keras.layers.Conv2D(c2[0], kernel_size=1, activation='relu')
        self.p2_2 = tf.keras.layers.Conv2D(c2[1], kernel_size=3, padding='same', activation='relu')
        self.p3_1 = tf.keras.layers.Conv2D(c3[0], kernel_size=1, activation='relu')
        self.p3_2 = tf.keras.layers.Conv2D(c3[1], kernel_size=5, padding='same', activation='relu')
        self.p4_1 = tf.keras.layers.MaxPooling2D(pool_size=3, strides=1, padding='same')
        self.p4_2 = tf.keras.layers.Conv2D(c4, kernel_size=1, activation='relu')

    def call(self, x):
        p1 = self.p1_1(x)
        p2 = self.p2_2(self.p2_1(x))
        p3 = self.p3_2(self.p3_1(x))
        p4 = self.p4_2(self.p4_1(x))
        return tf.concat([p1, p2, p3, p4], axis=-1)

# %%
class GlobalAvgPool2D(tf.keras.layers.Layer):
    def call(self, x):
        return tf.reduce_mean(x, axis=[1, 2])

# %%

class GoogLeNet(tf.keras.Model):
    def __init__(self, num_classes=1000):
        super(GoogLeNet, self).__init__()

        self.b1 = tf.keras.Sequential([
            tf.keras.layers.Conv2D(64, kernel_size=7, strides=2, padding='same', activation='relu'),
            tf.keras.layers.MaxPooling2D(pool_size=3, strides=2, padding='same')
        ])

        self.b2 = tf.keras.Sequential([
            tf.keras.layers.Conv2D(64, kernel_size=1, activation='relu'),
            tf.keras.layers.Conv2D(192, kernel_size=3, padding='same', activation='relu'),
            tf.keras.layers.MaxPooling2D(pool_size=3, strides=2, padding='same')
        ])

        self.b3 = tf.keras.Sequential([
            Inception(192, 64, (96, 128), (16, 32), 32),
            Inception(256, 128, (128, 192), (32, 96), 64),
            tf.keras.layers.MaxPooling2D(pool_size=3, strides=2, padding='same')
        ])

        self.b4 = tf.keras.Sequential([
            Inception(480, 192, (96, 208), (16, 48), 64),
            Inception(512, 160, (112, 224), (24, 64), 64),
            Inception(512, 128, (128, 256), (24, 64), 64),
            Inception(512, 112, (144, 288), (32, 64), 64),
            Inception(528, 256, (160, 320), (32, 128), 128),
            tf.keras.layers.MaxPooling2D(pool_size=3, strides=2, padding='same')
        ])

        self.b5 = tf.keras.Sequential([
            Inception(832, 256, (160, 320), (32, 128), 128),
            Inception(832, 384, (192, 384), (48, 128), 128),
            GlobalAvgPool2D()
        ])

        self.output_layer = tf.keras.Sequential([
            tf.keras.layers.Flatten(),
            tf.keras.layers.Dropout(0.4),
            tf.keras.layers.Dense(num_classes)
        ])

    def call(self, x):
        x = self.b1(x)
        x = self.b2(x)
        x = self.b3(x)
        x = self.b4(x)
        x = self.b5(x)
        x = self.output_layer(x)
        return x

# %%
# 加载Fashion MNIST数据集
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()

# 数据预处理
x_train, x_test = x_train / 255.0, x_test / 255.0  # 归一化

# 在通道维上添加一维，使其与模型输入的通道数一致（Fashion MNIST是灰度图像，通道数为1）
x_train = x_train.reshape((-1, 28, 28, 1))
x_test = x_test.reshape((-1, 28, 28, 1))

# 创建GoogLeNet模型
base_model = GoogLeNet(num_classes=10)  # Fashion MNIST有10个类别

# 编译模型
base_model.compile(optimizer=Adam(),
                   loss=SparseCategoricalCrossentropy(from_logits=True),
                   metrics=['accuracy'])

# 训练模型（这里只进行了几个epoch的示例训练，实际中你可能需要更多的epoch）
# 加载Fashion MNIST数据集
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()

# 数据预处理
x_train, x_test = x_train / 255.0, x_test / 255.0  # 归一化

# 在通道维上添加一维，使其与模型输入的通道数一致（Fashion MNIST是灰度图像，通道数为1）
x_train = x_train.reshape((-1, 28, 28, 1))
x_test = x_test.reshape((-1, 28, 28, 1))

# 创建GoogLeNet模型
base_model = GoogLeNet(num_classes=10)  # Fashion MNIST有10个类别

# 编译模型
base_model.compile(optimizer=Adam(),
                   loss=SparseCategoricalCrossentropy(from_logits=True),
                   metrics=['accuracy'])



history=base_model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))

# 使用模型进行预测
predictions = base_model.predict(x_test)

# %%

#绘制学习曲线，这个函数用于绘制训练过程中的损失和准确率的变化情况，以便进行可视化分析
def plot_learning_curves(history):
    pd.DataFrame(history.history).plot(figsize=(8,3))
    plt.grid(True)
    plt.show()
plot_learning_curves(history)