python与深度学习(九):CNN和cifar10

这篇具有很好参考价值的文章主要介绍了python与深度学习(九):CNN和cifar10。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1. 说明

本篇文章是CNN的另外一个例子,cifar10,是彩色的十分类数据集。
可以搭建卷积神经网络来训练模型。

2. cifar10实战

2.1 导入相关库

以下第三方库是python专门用于深度学习的库

# 导入tensorflow
import tensorflow as tf
# 导入keras
from tensorflow import keras
from keras.datasets import cifar10
# 引入绘制acc和loss曲线的库
import matplotlib.pyplot as plt
# 引入ANN的必要的类
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten
from keras.models import Sequential
from keras import optimizers, losses
from keras.preprocessing.image import ImageDataGenerator

2.2 加载数据

把cifar10数据集进行加载
x_train是fashion_mnist训练集图片,大小的32323的,y_train是对应的标签是数字。
x_test是fashion_mnist测试集图片,大小的32323的,y_test是对应的标签是数字。
因为y的形状是(None,1)的,如果直接进行独热编码会变成(None,1,10),会和神经网络的输出形状(None,10)不匹配,因此需要对独热编码之前的y的形状进行降维处理变成(None,)。

"1.加载数据"
"""
x_train是fashion_mnist训练集图片,大小的32*32*3的,y_train是对应的标签是数字
x_test是fashion_mnist测试集图片,大小的32*32*3的,y_test是对应的标签是数字
"""
(x_train, y_train), (x_test, y_test) = cifar10.load_data()  # 加载cifar10数据集
print('mnist_data:', x_train.shape, y_train.shape, x_test.shape, y_test.shape)  # 打印训练数据和测试数据的形状
"""
因为y的形状是(None,1)的,如果直接进行独热编码会变成(None,1,10),会和神经网络的输出形状(None,10)不匹配,
因此需要对独热编码之前的y的形状进行降维处理变成(None,)
"""
y_train = tf.squeeze(y_train, axis=1)
y_test = tf.squeeze(y_test, axis=1)

2.3 数据预处理

(1) 将输入的图片进行归一化,从0-255变换到0-1;
(2) 将标签y进行独热编码,因为神经网络的输出是10个概率值,而y是1个数, 计算loss时无法对应计算,因此将y进行独立编码成为10个数的行向量,然后进行loss的计算 独热编码:例如数值1的10分类的独热编码是[0 1 0 0 0 0 0 0 0 0,即1的位置为1,其余位置为0。

def preprocess(x, y):  # 数据预处理函数
    x = tf.cast(x, dtype=tf.float32) / 255.  # 将输入的图片进行归一化,从0-255变换到0-1
    y = tf.cast(y, dtype=tf.int32)  # 将输入图片的标签转换为int32类型
    y = tf.one_hot(y, depth=10)
    """
    # 将标签y进行独热编码,因为神经网络的输出是10个概率值,而y是1个数,
    计算loss时无法对应计算,因此将y进行独立编码成为10个数的行向量,然后进行loss的计算
    独热编码:例如数值1的10分类的独热编码是[0 1 0 0 0 0 0 0 0 0,即1的位置为1,其余位置为0
    """
    return x, y

2.4 数据处理

数据加载进入内存后,需要转换成 Dataset 对象,才能利用 TensorFlow 提供的各种便捷功能。
通过 Dataset.from_tensor_slices 可以将训练部分的数据图片 x 和标签 y 都转换成Dataset 对象

batchsz = 128  # 每次输入给神经网络的图片数
"""
数据加载进入内存后,需要转换成 Dataset 对象,才能利用 TensorFlow 提供的各种便捷功能。
通过 Dataset.from_tensor_slices 可以将训练部分的数据图片 x 和标签 y 都转换成Dataset 对象
"""
db = tf.data.Dataset.from_tensor_slices((x_train, y_train))  # 构建训练集对象
db = db.map(preprocess).shuffle(60000).batch(batchsz)  # 将数据进行预处理,随机打散和批量处理
ds_val = tf.data.Dataset.from_tensor_slices((x_test, y_test))  # 构建测试集对象
ds_val = ds_val.map(preprocess).batch(batchsz)  # 将数据进行预处理,随机打散和批量处理

2.5 构建网络模型

构建了两层卷积层,两层池化层,然后是展平层(将二维特征图拉直输入给全连接层),然后是三层全连接层。

"3.构建网络模型"
model = Sequential([Conv2D(filters=6, kernel_size=(5, 5), activation='relu'),
                    MaxPool2D(pool_size=(2, 2), strides=2),
                    Conv2D(filters=16, kernel_size=(5, 5), activation='relu'),
                    MaxPool2D(pool_size=(2, 2), strides=2),
                    Flatten(),
                    Dense(120, activation='relu'),
                    Dense(84, activation='relu'),
                    Dense(10,activation='softmax')])

model.build(input_shape=(None, 32, 32, 3))  # 模型的输入大小
model.summary()  # 打印网络结构

2.6 模型编译

模型的优化器是Adam,另外一种优化方法,学习率是0.01,
损失函数是losses.CategoricalCrossentropy,多分类交叉熵,
性能指标是正确率accuracy。

"4.模型编译"
model.compile(optimizer='Adam',
              loss=losses.CategoricalCrossentropy(from_logits=False),
              metrics=['accuracy']
                )
"""
模型的优化器是Adam
损失函数是losses.CategoricalCrossentropy,
性能指标是正确率accuracy
"""

2.7 模型训练

模型训练的次数是20,每1次循环进行测试

"5.模型训练"
history = model.fit(db, epochs=20, validation_data=ds_val, validation_freq=1)
"""
模型训练的次数是20,每1次循环进行测试
"""

2.8 模型保存

以.h5文件格式保存模型

"6.模型保存"
model.save('cnn_cifar10.h5')  # 以.h5文件格式保存模型

2.9 模型评价

得到测试集的正确率

"7.模型评价"
model.evaluate(ds_val)  # 得到测试集的正确率

2.10 模型测试

对模型进行测试

"8.模型测试"
sample = next(iter(ds_val))  # 取一个batchsz的测试集数据
x = sample[0]  # 测试集数据
y = sample[1]  # 测试集的标签
pred = model.predict(x)  # 将一个batchsz的测试集数据输入神经网络的结果
pred = tf.argmax(pred, axis=1)  # 每个预测的结果的概率最大值的下标,也就是预测的数字
y = tf.argmax(y, axis=1)  # 每个标签的最大值对应的下标,也就是标签对应的数字
print(pred)  # 打印预测结果
print(y)  # 打印标签类别

2.11 模型训练结果的可视化

对模型的训练结果进行可视化

"9.模型训练时的可视化"
# 显示训练集和验证集的acc和loss曲线
acc = history.history['accuracy']  # 获取模型训练中的accuracy
val_acc = history.history['val_accuracy']  # 获取模型训练中的val_accuracy
loss = history.history['loss']  # 获取模型训练中的loss
val_loss = history.history['val_loss']  # 获取模型训练中的val_loss
# 绘值acc曲线
plt.figure(1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()
# 绘制loss曲线
plt.figure(2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()  # 将结果显示出来

3. cifar10的CNN模型可视化结果图

Epoch 1/20
391/391 [==============================] - 20s 44ms/step - loss: 1.7699 - accuracy: 0.3471 - val_loss: 1.5087 - val_accuracy: 0.4547
Epoch 2/20
391/391 [==============================] - 20s 49ms/step - loss: 1.4580 - accuracy: 0.4737 - val_loss: 1.4031 - val_accuracy: 0.4884
Epoch 3/20
391/391 [==============================] - 21s 51ms/step - loss: 1.3519 - accuracy: 0.5168 - val_loss: 1.3040 - val_accuracy: 0.5345
Epoch 4/20
391/391 [==============================] - 21s 51ms/step - loss: 1.2646 - accuracy: 0.5506 - val_loss: 1.2333 - val_accuracy: 0.5646
Epoch 5/20
391/391 [==============================] - 19s 47ms/step - loss: 1.2030 - accuracy: 0.5753 - val_loss: 1.2309 - val_accuracy: 0.5673
Epoch 6/20
391/391 [==============================] - 19s 46ms/step - loss: 1.1519 - accuracy: 0.5941 - val_loss: 1.1947 - val_accuracy: 0.5716
Epoch 7/20
391/391 [==============================] - 18s 44ms/step - loss: 1.1104 - accuracy: 0.6088 - val_loss: 1.1496 - val_accuracy: 0.5987
Epoch 8/20
391/391 [==============================] - 19s 46ms/step - loss: 1.0726 - accuracy: 0.6235 - val_loss: 1.1330 - val_accuracy: 0.6031
Epoch 9/20
391/391 [==============================] - 19s 47ms/step - loss: 1.0393 - accuracy: 0.6327 - val_loss: 1.1079 - val_accuracy: 0.6119
Epoch 10/20
391/391 [==============================] - 21s 51ms/step - loss: 1.0149 - accuracy: 0.6440 - val_loss: 1.1023 - val_accuracy: 0.6160
Epoch 11/20
391/391 [==============================] - 19s 47ms/step - loss: 0.9798 - accuracy: 0.6550 - val_loss: 1.0828 - val_accuracy: 0.6265
Epoch 12/20
391/391 [==============================] - 19s 47ms/step - loss: 0.9594 - accuracy: 0.6621 - val_loss: 1.0978 - val_accuracy: 0.6191
Epoch 13/20
391/391 [==============================] - 18s 44ms/step - loss: 0.9325 - accuracy: 0.6709 - val_loss: 1.0803 - val_accuracy: 0.6264
Epoch 14/20
391/391 [==============================] - 20s 49ms/step - loss: 0.9106 - accuracy: 0.6801 - val_loss: 1.0792 - val_accuracy: 0.6212
Epoch 15/20
391/391 [==============================] - 23s 54ms/step - loss: 0.8928 - accuracy: 0.6873 - val_loss: 1.0586 - val_accuracy: 0.6382
Epoch 16/20
391/391 [==============================] - 20s 50ms/step - loss: 0.8695 - accuracy: 0.6931 - val_loss: 1.0825 - val_accuracy: 0.6303
Epoch 17/20
391/391 [==============================] - 22s 54ms/step - loss: 0.8524 - accuracy: 0.6993 - val_loss: 1.0917 - val_accuracy: 0.6296
Epoch 18/20
391/391 [==============================] - 19s 46ms/step - loss: 0.8314 - accuracy: 0.7074 - val_loss: 1.0753 - val_accuracy: 0.6341
Epoch 19/20
391/391 [==============================] - 19s 48ms/step - loss: 0.8117 - accuracy: 0.7136 - val_loss: 1.0701 - val_accuracy: 0.6376
Epoch 20/20
391/391 [==============================] - 20s 50ms/step - loss: 0.7967 - accuracy: 0.7200 - val_loss: 1.0715 - val_accuracy: 0.6376
79/79 [==============================] - 1s 17ms/step - loss: 1.0715 - accuracy: 0.6376
4/4 [==============================] - 0s 6ms/step

python与深度学习(九):CNN和cifar10,python,深度学习,深度学习,python
python与深度学习(九):CNN和cifar10,python,深度学习,深度学习,python
从以上结果可知,模型的准确率达到了63%,太低了,原因是网络结构有点简单,因此进行改变网络结构,同时为了降低过拟合的影响,加入数据增强部分。

4. 完整代码

# 导入tensorflow
import tensorflow as tf
# 导入keras
from tensorflow import keras
from keras.datasets import cifar10
# 引入绘制acc和loss曲线的库
import matplotlib.pyplot as plt
# 引入ANN的必要的类
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten
from keras.models import Sequential
from keras import optimizers, losses
from keras.preprocessing.image import ImageDataGenerator
"1.加载数据"
"""
x_train是fashion_mnist训练集图片,大小的32*32*3的,y_train是对应的标签是数字
x_test是fashion_mnist测试集图片,大小的32*32*3的,y_test是对应的标签是数字
"""
(x_train, y_train), (x_test, y_test) = cifar10.load_data()  # 加载cifar10数据集
print('mnist_data:', x_train.shape, y_train.shape, x_test.shape, y_test.shape)  # 打印训练数据和测试数据的形状
"""
因为y的形状是(None,1)的,如果直接进行独热编码会变成(None,1,10),会和神经网络的输出形状(None,10)不匹配,
因此需要对独热编码之前的y的形状进行降维处理变成(None,)
"""
y_train = tf.squeeze(y_train, axis=1)
y_test = tf.squeeze(y_test, axis=1)
"2.数据预处理"


def preprocess(x, y):  # 数据预处理函数
    x = tf.cast(x, dtype=tf.float32) / 255.  # 将输入的图片进行归一化,从0-255变换到0-1
    y = tf.cast(y, dtype=tf.int32)  # 将输入图片的标签转换为int32类型
    y = tf.one_hot(y, depth=10)
    """
    # 将标签y进行独热编码,因为神经网络的输出是10个概率值,而y是1个数,
    计算loss时无法对应计算,因此将y进行独立编码成为10个数的行向量,然后进行loss的计算
    独热编码:例如数值1的10分类的独热编码是[0 1 0 0 0 0 0 0 0 0,即1的位置为1,其余位置为0
    """
    return x, y


batchsz = 128  # 每次输入给神经网络的图片数
"""
数据加载进入内存后,需要转换成 Dataset 对象,才能利用 TensorFlow 提供的各种便捷功能。
通过 Dataset.from_tensor_slices 可以将训练部分的数据图片 x 和标签 y 都转换成Dataset 对象
"""
db = tf.data.Dataset.from_tensor_slices((x_train, y_train))  # 构建训练集对象
db = db.map(preprocess).shuffle(60000).batch(batchsz)  # 将数据进行预处理,随机打散和批量处理
ds_val = tf.data.Dataset.from_tensor_slices((x_test, y_test))  # 构建测试集对象
ds_val = ds_val.map(preprocess).batch(batchsz)  # 将数据进行预处理,随机打散和批量处理


"3.构建网络模型"
model = Sequential([Conv2D(filters=6, kernel_size=(5, 5), activation='relu'),
                    MaxPool2D(pool_size=(2, 2), strides=2),
                    Conv2D(filters=16, kernel_size=(5, 5), activation='relu'),
                    MaxPool2D(pool_size=(2, 2), strides=2),
                    Flatten(),
                    Dense(120, activation='relu'),
                    Dense(84, activation='relu'),
                    Dense(10,activation='softmax')])

model.build(input_shape=(None, 32, 32, 3))  # 模型的输入大小
model.summary()  # 打印网络结构

"4.模型编译"
model.compile(optimizer='Adam',
              loss=losses.CategoricalCrossentropy(from_logits=False),
              metrics=['accuracy']
                )
"""
模型的优化器是Adam
损失函数是losses.CategoricalCrossentropy,
性能指标是正确率accuracy
"""

"5.模型训练"
history = model.fit(db, epochs=20, validation_data=ds_val, validation_freq=1)
"""
模型训练的次数是20,每1次循环进行测试
"""
"6.模型保存"
model.save('cnn_cifar10.h5')  # 以.h5文件格式保存模型

"7.模型评价"
model.evaluate(ds_val)  # 得到测试集的正确率

"8.模型测试"
sample = next(iter(ds_val))  # 取一个batchsz的测试集数据
x = sample[0]  # 测试集数据
y = sample[1]  # 测试集的标签
pred = model.predict(x)  # 将一个batchsz的测试集数据输入神经网络的结果
pred = tf.argmax(pred, axis=1)  # 每个预测的结果的概率最大值的下标,也就是预测的数字
y = tf.argmax(y, axis=1)  # 每个标签的最大值对应的下标,也就是标签对应的数字
print(pred)  # 打印预测结果
print(y)  # 打印标签类别

"9.模型训练时的可视化"
# 显示训练集和验证集的acc和loss曲线
acc = history.history['accuracy']  # 获取模型训练中的accuracy
val_acc = history.history['val_accuracy']  # 获取模型训练中的val_accuracy
loss = history.history['loss']  # 获取模型训练中的loss
val_loss = history.history['val_loss']  # 获取模型训练中的val_loss
# 绘值acc曲线
plt.figure(1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()
# 绘制loss曲线
plt.figure(2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()  # 将结果显示出来


5. 改进后的代码和结果

# 导入tensorflow
import tensorflow as tf
# 导入keras
from tensorflow import keras
from keras.datasets import cifar10
# 引入绘制acc和loss曲线的库
import matplotlib.pyplot as plt
# 引入ANN的必要的类
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Dropout
from keras.models import Sequential
from keras import optimizers, losses
from keras.preprocessing.image import ImageDataGenerator
"1.加载数据"
"""
x_train是fashion_mnist训练集图片,大小的32*32*3的,y_train是对应的标签是数字
x_test是fashion_mnist测试集图片,大小的32*32*3的,y_test是对应的标签是数字
"""
(x_train, y_train), (x_test, y_test) = cifar10.load_data()  # 加载cifar10数据集
print('mnist_data:', x_train.shape, y_train.shape, x_test.shape, y_test.shape)  # 打印训练数据和测试数据的形状
image_gen_train = ImageDataGenerator(
    rescale=1. / 1.,  # 如为图像,分母为255时,可归至0~1
    rotation_range=45,  # 随机45度旋转
    width_shift_range=.15,  # 宽度偏移
    height_shift_range=.15,  # 高度偏移
    horizontal_flip=False,  # 水平翻转
    zoom_range=0.5  # 将图像随机缩放阈量50%
)
image_gen_train.fit(x_train)
"""
因为y的形状是(None,1)的,如果直接进行独热编码会变成(None,1,10),会和神经网络的输出形状(None,10)不匹配,
因此需要对独热编码后的y的形状进行降维处理变成(None,10)
"""
y_train = tf.squeeze(y_train, axis=1)
y_test = tf.squeeze(y_test, axis=1)
"2.数据预处理"


def preprocess(x, y):  # 数据预处理函数
    x = tf.cast(x, dtype=tf.float32) / 255.  # 将输入的图片进行归一化,从0-255变换到0-1
    y = tf.cast(y, dtype=tf.int32)  # 将输入图片的标签转换为int32类型
    y = tf.one_hot(y, depth=10)
    """
    # 将标签y进行独热编码,因为神经网络的输出是10个概率值,而y是1个数,
    计算loss时无法对应计算,因此将y进行独立编码成为10个数的行向量,然后进行loss的计算
    独热编码:例如数值1的10分类的独热编码是[0 1 0 0 0 0 0 0 0 0,即1的位置为1,其余位置为0
    """
    return x, y


batchsz = 128  # 每次输入给神经网络的图片数
"""
数据加载进入内存后,需要转换成 Dataset 对象,才能利用 TensorFlow 提供的各种便捷功能。
通过 Dataset.from_tensor_slices 可以将训练部分的数据图片 x 和标签 y 都转换成Dataset 对象
"""
db = tf.data.Dataset.from_tensor_slices((x_train, y_train))  # 构建训练集对象
db = db.map(preprocess).shuffle(50000).batch(batchsz)  # 将数据进行预处理,随机打散和批量处理
ds_val = tf.data.Dataset.from_tensor_slices((x_test, y_test))  # 构建测试集对象
ds_val = ds_val.map(preprocess).batch(batchsz)  # 将数据进行预处理,随机打散和批量处理


"3.构建网络模型"
model = Sequential([Conv2D(32, kernel_size=(3, 3), padding='same', activation='relu'),
                    Dropout(0.25),
                    MaxPool2D(pool_size=(2, 2), strides=2),
                    Conv2D(filters=64, kernel_size=(3, 3),padding='same', activation='relu'),
                    Dropout(0.25),
                    MaxPool2D(pool_size=(2, 2), strides=2),
                    Conv2D(filters=128, kernel_size=(3, 3), padding='same', activation='relu'),
                    Dropout(0.25),
                    MaxPool2D(pool_size=(2, 2), strides=2),
                    Flatten(),
                    Dense(1024, activation='relu'),
                    Dense(10,activation='softmax')])

model.build(input_shape=(None, 32, 32, 3))  # 模型的输入大小
model.summary()  # 打印网络结构

"4.模型编译"
model.compile(optimizer='Adam',
              loss=losses.CategoricalCrossentropy(from_logits=False),
              metrics=['accuracy']
                )
"""
模型的优化器是Adam
损失函数是losses.CategoricalCrossentropy,
性能指标是正确率accuracy
"""

"5.模型训练"
history = model.fit(db, epochs=20, validation_data=ds_val, validation_freq=1)
"""
模型训练的次数是10,每1次循环进行测试
"""
"6.模型保存"
model.save('cnn_cifar10_4.h5')  # 以.h5文件格式保存模型

"7.模型评价"
model.evaluate(ds_val)  # 得到测试集的正确率

"8.模型测试"
sample = next(iter(ds_val))  # 取一个batchsz的测试集数据
x = sample[0]  # 测试集数据
y = sample[1]  # 测试集的标签
pred = model.predict(x)  # 将一个batchsz的测试集数据输入神经网络的结果
pred = tf.argmax(pred, axis=1)  # 每个预测的结果的概率最大值的下标,也就是预测的数字
y = tf.argmax(y, axis=1)  # 每个标签的最大值对应的下标,也就是标签对应的数字
print(pred)  # 打印预测结果
print(y)  # 打印标签类别

"9.模型训练时的可视化"
# 显示训练集和验证集的acc和loss曲线
acc = history.history['accuracy']  # 获取模型训练中的accuracy
val_acc = history.history['val_accuracy']  # 获取模型训练中的val_accuracy
loss = history.history['loss']  # 获取模型训练中的loss
val_loss = history.history['val_loss']  # 获取模型训练中的val_loss
# 绘值acc曲线
plt.figure(1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()
# 绘制loss曲线
plt.figure(2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()  # 将结果显示出来


Epoch 1/20
391/391 [==============================] - 109s 272ms/step - loss: 1.4598 - accuracy: 0.4688 - val_loss: 1.2981 - val_accuracy: 0.5713
Epoch 2/20
391/391 [==============================] - 103s 262ms/step - loss: 1.0536 - accuracy: 0.6297 - val_loss: 1.0809 - val_accuracy: 0.6476
Epoch 3/20
391/391 [==============================] - 104s 264ms/step - loss: 0.8955 - accuracy: 0.6840 - val_loss: 0.9347 - val_accuracy: 0.7052
Epoch 4/20
391/391 [==============================] - 103s 262ms/step - loss: 0.7785 - accuracy: 0.7258 - val_loss: 0.9195 - val_accuracy: 0.6880
Epoch 5/20
391/391 [==============================] - 104s 264ms/step - loss: 0.6896 - accuracy: 0.7575 - val_loss: 0.8039 - val_accuracy: 0.7330
Epoch 6/20
391/391 [==============================] - 103s 262ms/step - loss: 0.6085 - accuracy: 0.7864 - val_loss: 0.8141 - val_accuracy: 0.7296
Epoch 7/20
391/391 [==============================] - 102s 261ms/step - loss: 0.5378 - accuracy: 0.8102 - val_loss: 0.7418 - val_accuracy: 0.7463
Epoch 8/20
391/391 [==============================] - 102s 259ms/step - loss: 0.4698 - accuracy: 0.8335 - val_loss: 0.6867 - val_accuracy: 0.7693
Epoch 9/20
391/391 [==============================] - 102s 259ms/step - loss: 0.4042 - accuracy: 0.8563 - val_loss: 0.6729 - val_accuracy: 0.7734
Epoch 10/20
391/391 [==============================] - 103s 261ms/step - loss: 0.3474 - accuracy: 0.8763 - val_loss: 0.6690 - val_accuracy: 0.7696
Epoch 11/20
391/391 [==============================] - 102s 261ms/step - loss: 0.2969 - accuracy: 0.8958 - val_loss: 0.6920 - val_accuracy: 0.7660
Epoch 12/20
391/391 [==============================] - 102s 260ms/step - loss: 0.2597 - accuracy: 0.9072 - val_loss: 0.7243 - val_accuracy: 0.7558
Epoch 13/20
391/391 [==============================] - 102s 259ms/step - loss: 0.2146 - accuracy: 0.9235 - val_loss: 0.7107 - val_accuracy: 0.7599
Epoch 14/20
391/391 [==============================] - 106s 269ms/step - loss: 0.1904 - accuracy: 0.9318 - val_loss: 0.6790 - val_accuracy: 0.7760
Epoch 15/20
391/391 [==============================] - 103s 262ms/step - loss: 0.1703 - accuracy: 0.9404 - val_loss: 0.7177 - val_accuracy: 0.7706
Epoch 16/20
391/391 [==============================] - 103s 262ms/step - loss: 0.1526 - accuracy: 0.9463 - val_loss: 0.7038 - val_accuracy: 0.7781
Epoch 17/20
391/391 [==============================] - 103s 262ms/step - loss: 0.1333 - accuracy: 0.9520 - val_loss: 0.7267 - val_accuracy: 0.7770
Epoch 18/20
391/391 [==============================] - 103s 263ms/step - loss: 0.1253 - accuracy: 0.9576 - val_loss: 0.7518 - val_accuracy: 0.7728
Epoch 19/20
391/391 [==============================] - 103s 263ms/step - loss: 0.1210 - accuracy: 0.9570 - val_loss: 0.7855 - val_accuracy: 0.7670
Epoch 20/20
391/391 [==============================] - 104s 265ms/step - loss: 0.1105 - accuracy: 0.9607 - val_loss: 0.8065 - val_accuracy: 0.7721
79/79 [==============================] - 4s 48ms/step - loss: 0.8065 - accuracy: 0.7721
4/4 [==============================] - 0s 15ms/step

python与深度学习(九):CNN和cifar10,python,深度学习,深度学习,python
python与深度学习(九):CNN和cifar10,python,深度学习,深度学习,python
结果有所改善,但是过拟合仍然存在。文章来源地址https://www.toymoban.com/news/detail-614102.html

到了这里,关于python与深度学习(九):CNN和cifar10的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 深度学习毕设项目 深度学习猫狗分类 - python opencv cnn

    🔥 这两年开始毕业设计和毕业答辩的要求和难度不断提升,传统的毕设题目缺少创新和亮点,往往达不到毕业答辩的要求,这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。 为了大家能够顺利以及最少的精力通过毕设,学长分享优质毕业设计项目,今天

    2024年02月03日
    浏览(55)
  • 深度学习毕设项目 深度学习疲劳检测 驾驶行为检测 - python opencv cnn

    🔥 这两年开始毕业设计和毕业答辩的要求和难度不断提升,传统的毕设题目缺少创新和亮点,往往达不到毕业答辩的要求,这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。 为了大家能够顺利以及最少的精力通过毕设,学长分享优质毕业设计项目,今天

    2024年02月03日
    浏览(41)
  • 【毕业设计】深度学习水果识别系统 - python CNN

    🔥 Hi,大家好,这里是丹成学长的毕设系列文章! 🔥 对毕设有任何疑问都可以问学长哦! 这两年开始,各个学校对毕设的要求越来越高,难度也越来越大… 毕业设计耗费时间,耗费精力,甚至有些题目即使是专业的老师或者硕士生也需要很长时间,所以一旦发现问题,一定

    2023年04月13日
    浏览(50)
  • python与深度学习(六):CNN和手写数字识别二

    本篇文章是对上篇文章训练的模型进行测试。首先是将训练好的模型进行重新加载,然后采用opencv对图片进行加载,最后将加载好的图片输送给模型并且显示结果。 在这里导入需要的第三方库如cv2,如果没有,则需要自行下载。 把MNIST数据集进行加载,并且把训练好的模型也

    2024年02月15日
    浏览(35)
  • 计算机竞赛 基于CNN实现谣言检测 - python 深度学习 机器学习

    🔥 优质竞赛项目系列,今天要分享的是 基于CNN实现谣言检测 该项目较为新颖,适合作为竞赛课题方向,学长非常推荐! 🧿 更多资料, 项目分享: https://gitee.com/dancheng-senior/postgraduate 社交媒体的发展在加速信息传播的同时,也带来了虚假谣言信息的泛滥,往往会引发诸多不

    2024年02月12日
    浏览(56)
  • 文本分类系统Python,基于深度学习CNN卷积神经网络

    文本分类系统,使用Python作为主要开发语言,通过TensorFlow搭建CNN卷积神经网络对十余种不同种类的文本数据集进行训练,最后得到一个h5格式的本地模型文件,然后采用Django开发网页界面,实现用户在界面中输入一段文字,识别其所属的文本种类。 在我们的日常生活和工作中

    2024年02月08日
    浏览(50)
  • python与深度学习(七):CNN和fashion_mnist

    本篇文章是CNN的另外一个例子,fashion_mnist,是衣服类的数据集。 可以搭建和手写数字识别的一样的模神经网络来训练模型。 以下第三方库是python专门用于深度学习的库 把fashion_mnist数据集进行加载 (1) 将输入的图片进行归一化,从0-255变换到0-1; (2) 将输入图片的形状(60000,

    2024年02月15日
    浏览(28)
  • 竞赛 深度学习疫情社交安全距离检测算法 - python opencv cnn

    🔥 优质竞赛项目系列,今天要分享的是 🚩 **基于深度学习疫情社交安全距离检测算法 ** 该项目较为新颖,适合作为竞赛课题方向,学长非常推荐! 🥇学长这里给一个题目综合评分(每项满分5分) 难度系数:3分 工作量:3分 创新点:5分 🧿 更多资料, 项目分享: https://git

    2024年02月03日
    浏览(52)
  • 车牌识别系统Python,基于深度学习CNN卷积神经网络算法

    车牌识别系统,基于Python实现,通过TensorFlow搭建CNN卷积神经网络模型,对车牌数据集图片进行训练最后得到模型,并基于Django框架搭建网页端平台,实现用户在网页端输入一张图片识别其结果,并基于Pyqt5搭建桌面端可视化界面。 在智能交通和车辆监控领域,车牌识别技术扮

    2024年02月07日
    浏览(66)
  • 【大数据毕设选题】基于CNN实现谣言检测 - python 深度学习 机器学习

    Hi,大家好,今天向大家介绍 一个深度学习项目 基于CNN实现谣言检测 社交媒体的发展在加速信息传播的同时,也带来了虚假谣言信息的泛滥,往往会引发诸多不安定因素,并对经济和社会产生巨大的影响。 本项目所使用的数据是从新浪微博不实信息举报平台抓取的中文谣言

    2024年01月20日
    浏览(57)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包