基于卷积神经网络CNN,使用二维卷积Conv2D实现MNIST数字识别的四种方法

手写

前言

系列专栏:机器学习:高级应用与实践【项目实战100+】【2024】✨︎
在本专栏中不仅包含一些适合初学者的最新机器学习项目,每个项目都处理一组不同的问题,包括监督和无监督学习、分类、回归和聚类,而且涉及创建深度学习模型、处理非结构化数据以及指导复杂的模型,如卷积神经网络、门控循环单元、大型语言模型和强化学习模型

使用 MNIST 数据集进行手写数字识别是一个借助神经网络完成的重要项目。深度神经网络是机器学习和人工智能的一个分支,这种网络能够从提供的无组织或无标记数据中进行无监督学习。

我们在此基础上更进一步,我们的手写数字识别系统不仅能检测手写数字的扫描图像,还能借助集成的图形用户界面在屏幕上书写数字进行识别。它主要检测手写数字的扫描图像。

目录

  • 1. 相关库和数据集
    • 1.1 相关库介绍
    • 1.2 数据集介绍
  • 2. 数据预处理
    • 2.1 特征缩放
    • 2.2 数据重塑
    • 2.3 格式变换
  • 3. 模型建立
    • 3.1 数据准备
    • 3.2 构建模型(4 种不同的模型结构)
      • 3.2.1 密集神经网络
      • 3.2.2 二维卷积网络(密集+最大池化)
      • 3.2.3 二维卷积网络(密集+最大池化+Dropout)
      • 3.2.4 二维卷积网络(密集+最大池化+Dropout+BN算法)
  • 4. 模型评估
    • 4.1 预测性能
    • 4.2 比較結果
    • 4.3 结果可视化

1. 相关库和数据集

1.1 相关库介绍

Python 库使我们能够非常轻松地处理数据并使用一行代码执行典型和复杂的任务。

  • Numpy – 是一种开源的数值计算扩展,可用来存储和处理大型矩阵,缩短大型计算的时间。
  • Matplotlib – 此库用于绘制可视化效果,用于展现数据之间的相互关系。
  • TensorFlow™ – 是一个基于数据流编程的符号数学系统,被广泛应用于各类机器学习算法的编程实现。
  • Keras – 是一个由Python编写的开源人工神经网络库,可以作为Tensorflow的高阶应用程序接口,进行深度学习模型的设计、调试、评估、应用和可视化。
import numpy as np
import matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_split
import tensorflow as tffrom tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.datasets import mnist
from keras.utils import to_categorical

1.2 数据集介绍

MNIST 数据集是一组由中学生和美国人口普查局雇员手写的 70,000 个小图,由高中生和美国人口普查局的员工手写而成。每个图像都标有所代表的数字,人们对该数据集进行了大量研究,因此它经常被称为机器学习的 “Hello World”。

(x_train, y_train), (x_test, y_test) = mnist.load_data()
print("Training Shape:", x_train.shape, y_train.shape)
print("----------------------------------------")
print("Testing Shape:", x_test.shape, y_test.shape)
Training Shape: (60000, 28, 28) (60000,)
----------------------------------------
Testing Shape: (10000, 28, 28) (10000,)

2. 数据预处理

2.1 特征缩放

①将像素值(0-255)归一化为(0-1),以便更好地进行训练

# Normalize pixel values (0-255) to (0-1) --> 0 for better training
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0print("Min: %.3f, Max: %.3f" % (x_train.min(), x_train.max()))
print("Min: %.3f, Max: %.3f" % (x_test.min(), x_test.max()))
Min: 0.000, Max: 1.000
Min: 0.000, Max: 1.000

2.2 数据重塑

②重塑数据以便输入神经网络

# Reshape the data for input to the neural network (28x28 pixels)
x_train = x_train.reshape((x_train.shape[0], 28, 28, 1))
x_test = x_test.reshape((x_test.shape[0], 28, 28, 1))print("Training Shape:", x_train.shape)
print("----------------------------")
print("Testing Shape:", x_test.shape)
Training Shape: (60000, 28, 28, 1)
----------------------------
Testing Shape: (10000, 28, 28, 1)

2.3 格式变换

③将标签从整数格式转换为 one-hot 编码向量

y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)print(y_train[0])
print(y_test[0])
[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]

3. 模型建立

3.1 数据准备

①将数据拆分为训练数据、验证数据和测试数据

x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.20, random_state=1)
print("Training Shape:", x_train.shape, y_train.shape)
print("------------------------------------------")
print("validation Shape:", x_val.shape, y_val.shape)
Training Shape: (48000, 28, 28, 1) (48000, 10)
------------------------------------------
validation Shape: (12000, 28, 28, 1) (12000, 10)

3.2 构建模型(4 种不同的模型结构)

3.2.1 密集神经网络

# 使用Sequential模型,并通过Input层指定输入形状
model_1 = keras.Sequential([layers.Input(shape=(28, 28, 1)),  # 这里的Input层定义了模型的输入形状layers.Flatten(),layers.Dense(512, activation='relu'),layers.Dense(256, activation='relu'),layers.Dense(10, activation='softmax')
])
# compile the model
model_1.compile(optimizer= 'adam',loss='categorical_crossentropy',metrics=['accuracy']
)

模型概要

model_1.summary()
Model: "sequential"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ flatten (Flatten)(None, 784)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense (Dense)(None, 512)401,920 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_1 (Dense)(None, 256)131,328 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_2 (Dense)(None, 10)2,570 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘Total params: 535,818 (2.04 MB)Trainable params: 535,818 (2.04 MB)Non-trainable params: 0 (0.00 B)

模型训练

model_1.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=10, batch_size=32)
Epoch 1/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 6s 4ms/step - accuracy: 0.8948 - loss: 0.3426 - val_accuracy: 0.9642 - val_loss: 0.1150
Epoch 2/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 4s 3ms/step - accuracy: 0.9745 - loss: 0.0825 - val_accuracy: 0.9719 - val_loss: 0.0933
Epoch 3/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 5s 3ms/step - accuracy: 0.9829 - loss: 0.0534 - val_accuracy: 0.9727 - val_loss: 0.0980
Epoch 4/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 4s 3ms/step - accuracy: 0.9865 - loss: 0.0380 - val_accuracy: 0.9709 - val_loss: 0.1073
Epoch 5/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 4s 3ms/step - accuracy: 0.9892 - loss: 0.0302 - val_accuracy: 0.9778 - val_loss: 0.0905
Epoch 6/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 4s 3ms/step - accuracy: 0.9927 - loss: 0.0225 - val_accuracy: 0.9760 - val_loss: 0.1015
Epoch 7/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 4s 3ms/step - accuracy: 0.9936 - loss: 0.0186 - val_accuracy: 0.9775 - val_loss: 0.0990
Epoch 8/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 5s 3ms/step - accuracy: 0.9933 - loss: 0.0196 - val_accuracy: 0.9778 - val_loss: 0.1068
Epoch 9/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 4s 3ms/step - accuracy: 0.9939 - loss: 0.0182 - val_accuracy: 0.9772 - val_loss: 0.1158
Epoch 10/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 4s 3ms/step - accuracy: 0.9938 - loss: 0.0182 - val_accuracy: 0.9770 - val_loss: 0.1083

模型评估

test_loss_1, test_accuracy_1 = model_1.evaluate(x_test, y_test)print("\nAccuracy =", test_accuracy_1, "\n-----------------------------", "\nLoss =", test_loss_1)
313/313 ━━━━━━━━━━━━━━━━━━━━ 2s 5ms/step - accuracy: 0.9749 - loss: 0.1182Accuracy = 0.978600025177002 
----------------------------- 
Loss = 0.09816069155931473

3.2.2 二维卷积网络(密集+最大池化)

model_2 = keras.Sequential([layers.Input(shape=(28, 28, 1)),layers.Conv2D(32, (3,3), activation='relu'),layers.MaxPooling2D((2,2)),layers.Conv2D(64, (3,3), activation='relu'),layers.MaxPooling2D((2,2)),layers.Flatten(),layers.Dense(128, activation='relu'),layers.Dense(10, activation='softmax')
])
# compile the model
model_2.compile(optimizer= 'Adam',loss='categorical_crossentropy',metrics=['accuracy']
)

模型概要

model_2.summary()
Model: "sequential_1"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ conv2d (Conv2D)(None, 26, 26, 32)320 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d (MaxPooling2D)(None, 13, 13, 32)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_1 (Conv2D)(None, 11, 11, 64)18,496 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_1 (MaxPooling2D)(None, 5, 5, 64)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten_1 (Flatten)(None, 1600)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_3 (Dense)(None, 128)204,928 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_4 (Dense)(None, 10)1,290 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘Total params: 225,034 (879.04 KB)Trainable params: 225,034 (879.04 KB)Non-trainable params: 0 (0.00 B)

模型训练

model_2.fit(x_train, y_train, batch_size=32, validation_data=(x_val, y_val), epochs=10)
Epoch 1/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9023 - loss: 0.3260 - val_accuracy: 0.9793 - val_loss: 0.0674
Epoch 2/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9849 - loss: 0.0485 - val_accuracy: 0.9789 - val_loss: 0.0650
Epoch 3/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9909 - loss: 0.0299 - val_accuracy: 0.9829 - val_loss: 0.0585
Epoch 4/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9933 - loss: 0.0195 - val_accuracy: 0.9861 - val_loss: 0.0483
Epoch 5/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9937 - loss: 0.0173 - val_accuracy: 0.9868 - val_loss: 0.0493
Epoch 6/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9964 - loss: 0.0112 - val_accuracy: 0.9873 - val_loss: 0.0515
Epoch 7/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9963 - loss: 0.0101 - val_accuracy: 0.9865 - val_loss: 0.0533
Epoch 8/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9963 - loss: 0.0098 - val_accuracy: 0.9867 - val_loss: 0.0603
Epoch 9/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9979 - loss: 0.0058 - val_accuracy: 0.9880 - val_loss: 0.0528
Epoch 10/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 7s 4ms/step - accuracy: 0.9983 - loss: 0.0052 - val_accuracy: 0.9884 - val_loss: 0.0608

模型评估

test_loss_2, test_accuracy_2 = model_2.evaluate(x_test, y_test)print("\nAccuracy =", test_accuracy_2, "\n-----------------------------", "\nLoss =", test_loss_2)
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9851 - loss: 0.0610Accuracy = 0.9889000058174133 
----------------------------- 
Loss = 0.046354446560144424

3.2.3 二维卷积网络(密集+最大池化+Dropout)

model_3 = keras.Sequential([layers.Input(shape=(28, 28, 1)),layers.Conv2D(32, (3,3), activation='relu'),layers.MaxPooling2D((2,2)),layers.Conv2D(64, (3,3), activation='relu'),layers.MaxPooling2D((2,2)),layers.Conv2D(128, (3,3), activation='relu'),layers.Flatten(),layers.Dropout(0.5),layers.Dense(128, activation='relu'),layers.Dropout(0.5),layers.Dense(10, activation='softmax')
])
model_3.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy']
)

模型概要

model_3.summary()
Model: "sequential_2"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ conv2d_2 (Conv2D)(None, 26, 26, 32)320 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_2 (MaxPooling2D)(None, 13, 13, 32)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_3 (Conv2D)(None, 11, 11, 64)18,496 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_3 (MaxPooling2D)(None, 5, 5, 64)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_4 (Conv2D)(None, 3, 3, 128)73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten_2 (Flatten)(None, 1152)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout (Dropout)(None, 1152)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_5 (Dense)(None, 128)147,584 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_1 (Dropout)(None, 128)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_6 (Dense)(None, 10)1,290 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘Total params: 241,546 (943.54 KB)Trainable params: 241,546 (943.54 KB)Non-trainable params: 0 (0.00 B)

模型训练

model_3.fit(x_train, y_train, batch_size=32, validation_data=(x_val, y_val), epochs=10)
Epoch 1/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 9s 5ms/step - accuracy: 0.8248 - loss: 0.5350 - val_accuracy: 0.9796 - val_loss: 0.0631
Epoch 2/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9706 - loss: 0.0949 - val_accuracy: 0.9853 - val_loss: 0.0475
Epoch 3/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9805 - loss: 0.0652 - val_accuracy: 0.9874 - val_loss: 0.0422
Epoch 4/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9840 - loss: 0.0566 - val_accuracy: 0.9894 - val_loss: 0.0381
Epoch 5/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 10s 5ms/step - accuracy: 0.9867 - loss: 0.0456 - val_accuracy: 0.9895 - val_loss: 0.0380
Epoch 6/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9879 - loss: 0.0389 - val_accuracy: 0.9900 - val_loss: 0.0338
Epoch 7/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9888 - loss: 0.0378 - val_accuracy: 0.9896 - val_loss: 0.0367
Epoch 8/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9906 - loss: 0.0332 - val_accuracy: 0.9872 - val_loss: 0.0484
Epoch 9/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9901 - loss: 0.0338 - val_accuracy: 0.9917 - val_loss: 0.0319
Epoch 10/10
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 8s 5ms/step - accuracy: 0.9913 - loss: 0.0263 - val_accuracy: 0.9911 - val_loss: 0.0346

模型评估

test_loss_3, test_accuracy_3 = model_3.evaluate(x_test, y_test)print("\nAccuracy =", test_accuracy_3, "\n-----------------------------", "\nLoss =", test_loss_3)
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9883 - loss: 0.0389Accuracy = 0.991100013256073 
----------------------------- 
Loss = 0.030680162832140923

3.2.4 二维卷积网络(密集+最大池化+Dropout+BN算法)

model_4 = keras.Sequential([layers.Input(shape=(28, 28, 1)),layers.Conv2D(32, (3,3), activation='relu'),layers.BatchNormalization(),layers.MaxPooling2D((2,2)),layers.Conv2D(64, (3,3), activation='relu'),layers.BatchNormalization(),layers.MaxPooling2D((2,2)),layers.Conv2D(128, (3,3), activation='relu'),layers.Flatten(),layers.Dropout(0.2),             # using 20% dropout instead of 50%layers.Dense(128, activation='relu'),layers.Dropout(0.2),layers.Dense(10, activation='softmax'),
])
model_4.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy']
)

模型概要

model_4.summary()
Model: "sequential_3"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ conv2d_5 (Conv2D)(None, 26, 26, 32)320 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization                  │ (None, 26, 26, 32)128 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_4 (MaxPooling2D)(None, 13, 13, 32)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_6 (Conv2D)(None, 11, 11, 64)18,496 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_1                │ (None, 11, 11, 64)256 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_5 (MaxPooling2D)(None, 5, 5, 64)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_7 (Conv2D)(None, 3, 3, 128)73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten_3 (Flatten)(None, 1152)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_2 (Dropout)(None, 1152)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_7 (Dense)(None, 128)147,584 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_3 (Dropout)(None, 128)0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_8 (Dense)(None, 10)1,290 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘Total params: 241,930 (945.04 KB)Trainable params: 241,738 (944.29 KB)Non-trainable params: 192 (768.00 B)

模型训练

model_4.fit(x_train, y_train, batch_size=64, validation_data=(x_val, y_val), epochs=6)
Epoch 1/6
750/750 ━━━━━━━━━━━━━━━━━━━━ 12s 14ms/step - accuracy: 0.9043 - loss: 0.3018 - val_accuracy: 0.9855 - val_loss: 0.0485
Epoch 2/6
750/750 ━━━━━━━━━━━━━━━━━━━━ 10s 13ms/step - accuracy: 0.9841 - loss: 0.0517 - val_accuracy: 0.9862 - val_loss: 0.0458
Epoch 3/6
750/750 ━━━━━━━━━━━━━━━━━━━━ 10s 13ms/step - accuracy: 0.9882 - loss: 0.0379 - val_accuracy: 0.9881 - val_loss: 0.0442
Epoch 4/6
750/750 ━━━━━━━━━━━━━━━━━━━━ 10s 13ms/step - accuracy: 0.9906 - loss: 0.0286 - val_accuracy: 0.9873 - val_loss: 0.0452
Epoch 5/6
750/750 ━━━━━━━━━━━━━━━━━━━━ 10s 13ms/step - accuracy: 0.9923 - loss: 0.0252 - val_accuracy: 0.9845 - val_loss: 0.0545
Epoch 6/6
750/750 ━━━━━━━━━━━━━━━━━━━━ 10s 13ms/step - accuracy: 0.9923 - loss: 0.0236 - val_accuracy: 0.9871 - val_loss: 0.0486

模型评估

test_loss_4, test_accuracy_4 = model_4.evaluate(x_test, y_test)print("\nAccuracy =", test_accuracy_4, "\n-----------------------------", "\nLoss =", test_loss_4)
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9856 - loss: 0.0679Accuracy = 0.9901000261306763 
----------------------------- 
Loss = 0.04728936031460762

4. 模型评估

4.1 预测性能

①构建模型性能预测函数

def predict(model, image):reshaped_image = image.reshape((1, 28, 28, 1))prediction = model.predict(reshaped_image)predicted_class = np.argmax(prediction)return predicted_class
predict_image_class = predict(model_1, x_test[0])
print("Predicted Class Label: ", predict_image_class)
print("Actual Class Label of the same image:",(np.argmax(y_test[0])))
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step
Predicted Class Label:  7
Actual Class Label of the same image: 7

4.2 比較結果

def compare_models(models, x_test, y_test):accuracies = []model_names = []for model in models:_, accuracy = model.evaluate(x_test, y_test)accuracies.append(accuracy)best_model_index = np.argmax(accuracies)best_model = models[best_model_index]best_accuracy = accuracies[best_model_index]model_names = [f"Model {i+1}" for i in range(len(models))]plt.plot(model_names, accuracies, marker='o')plt.xlabel('Models')plt.ylabel('Accuracy')plt.title('Comparison of Model Accuracies')plt.xticks(rotation=45)plt.show()print("Comparison Results:")for i in range(len(models)):print(f"Model {i+1} - Accuracy: { accuracies[i]:.4f}")print(f"Best Model : Model {best_model_index+1}")print(f"Best Accuracy: {best_accuracy:.4f}")return best_model
models = [model_1, model_2, model_3, model_4]
best_model = compare_models(models, x_test, y_test)
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9749 - loss: 0.1182
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9851 - loss: 0.0610
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9883 - loss: 0.0389
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9856 - loss: 0.0679

4.3 结果可视化

评估结果可视化

Comparison Results:
Model 1 - Accuracy: 0.9786
Model 2 - Accuracy: 0.9889
Model 3 - Accuracy: 0.9911
Model 4 - Accuracy: 0.9901
Best Model : Model 3
Best Accuracy: 0.9911

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/12948.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

ROS 2边学边练(48)-- 将URDF与robot_state_publisher一起使用

前言 本篇将完成一个行走的机器人,并以tf2消息的方式实时发布机器人状态,以便我们在Rviz中同步查看。 首先,我们创建描述机器人装配的URDF模型。接下来,我们编写一个节点,用于模拟运动并发布JointState和位姿变换。然后…

C-函数的由浅入深

1.函数的定义 数据类型 函数名 (【数据类型 形参名,数据类型 形参名, …】) 2.函数的传参 值传递 地址传递 全局变量 3.函数的调用 嵌套调用 递归 4.函数与数组 5.函数与指针 指针函数 函数指针 函数指针数组 函数的定义 #inclu…

醉了,面个功能测试,还问我Python装饰器

Python 装饰器是个强大的工具,可帮你生成整洁、可重用和可维护的代码。某种意义上说,会不会用装饰器是区分新手和老鸟的重要标志。如果你不熟悉装饰器,你可以将它们视为将函数作为输入并在不改变其主要用途的情况下扩展其功能的函数。装饰器可…

dhcp(接口和全局地址池模式)

接口地址池和全局地址池 dhcp应用 1.全部开启dhcp功能 2.ar5 0口接口地址池 1口全局地址池 3.ar6和ar7配置,查看能否自动获取ip 左右不同两个网络,接口和全局地址池的区别 部分截图 ar6 ar7 ar5

(实测验证)【移远EC800M-CN 】TCP 透传

引言 本文章使用自研“超小体积TTL转4GGPS集成模块”进行实测验证; 1、配置移远EC800M-CN TCP 透传 串口助手发送: ATQIOPEN1,0,"TCP","36.137.226.30",39755,0,2 //配置服务器地址和端口号; 4G模组返回…

07-Fortran基础--Fortran指针(Pointer)的使用

07-Fortran基础--Fortran指针Pointer的使用 0 引言1 指针(Poionter)的有关内容1.1 一般类型指针1.2 数组指针1.3 派生类(type)指针1.4 函数指针 2 可运行code 0 引言 Fortran是一种广泛使用的编程语言,特别适合科学计算和数值分析。Fortran 9…

java代码混淆工具ProGuard混淆插件

java代码混淆工具ProGuard混淆插件 介绍 ProGuard是一个纯java编写的混淆工具,有客户端跟jar包两种使用方式。可以将程序打包为jar,然后用工具进行混淆,也可以在maven中导入ProGuard的插件,对代码进行混淆。 大家都知道 java代…

【华为OD机试-C卷D卷-200分】田忌赛马(C++/Java/Python)

【华为OD机试】-(A卷+B卷+C卷+D卷)-2024真题合集目录 【华为OD机试】-(C卷+D卷)-2024最新真题目录 题目描述 给定两个只包含数字的数组a,b,调整数组 a 里面的数字的顺序,使得尽可能多的a[i] > b[i]。 数组a和b中的数字各不相同。 输出所有可以达到最优结果的a数组的…

SadTalker 自定义容器化部署配置

Docker 环境检查 执行docker info 查看环境种是否有安装docker,否则首先安装好docker 运行环境。在线环境安装执行执行两条指令即可 sudo apt install docker sudo apt-get install docker-ce sudo apt-get install docker-composesudo systemctl restart dockerG…

langchain源码

itemgetter:返回一个函数,函数取输入dict的某个指定key Runnable 的基本方法有 invoke、 batch、 await、 ainvoke、 abatch 同步转异步 Runnable 还具有的方法:bind、 with_config。 input_schema 属性、output_schema 属性 with_retry方…

Uniapp H5开发常见问题解析

引言 在移动应用开发领域,Uniapp已经成为一个备受瞩目的技术框架,其跨平台能力和高效开发特性使得开发者能够更加便捷地构建出功能丰富、性能优越的应用程序。特别是在H5开发中,Uniapp的应用场景日益广泛,然而,随之而…

Vue2之使用provide和inject实现两个不相干组件之间的通信

Vue2之使用provide和inject实现两个不相干组件之间的通信 文章目录 Vue2之使用provide和inject实现两个不相干组件之间的通信1. 祖先组件中使用provide提供数据2.后代组件A中使用inject注入并使用数据3.后代组件B中使用inject注入并使用数据 在Vue 2中以使用provide和inject来实…

[ciscn 2022 东北赛区]math

1.题目 import gmpy2 from Crypto.Util.number import * from flag import flag assert flag.startswith(b"flag{") assert flag.endswith(b"}") messagebytes_to_long(flag) def keygen(nbit, dbit):if 2*dbit < nbit:while True:a1 getRandomNBitIn…

编辑器目录树的设计,一点也不简单

朋友们好&#xff0c;我是优秀的大鹏 今天花了很长时间思考一个网页文档编辑器&#xff0c;云端目录树要怎么设计 这个看似简单的需求&#xff0c;技术上和产品上的思考却非常复杂 下面以几种编辑器为例&#xff0c;讲一下各种编辑器在技术上和产品的思考 1、以Vscode为代表的本…

Delphi DataSet转JSon (使用SuperObject)

Delphi中将TDataSet转换为JSon字符串。 with ATM.LoadDataSet() dobeginif IsEmpty thenbeginLogObj.WriteLog(未查询到该视图名称下该时间段内的上传数据&#xff0c;视图名称&#xff1a; AViewname 开始时间&#xff1a; AStartdate 结束时间&#xff1a; AEnddate);exit…

【神经网络与深度学习】Transformer原理

transformer ENCODER 输入部分 对拆分后的语句x [batch_size, seq_len]进行以下操作 Embedding 将离散的输入&#xff08;如单词索引或其他类别特征&#xff09;转换为稠密的实数向量&#xff0c;以便可以在神经网络中使用。位置编码 与RNN相比&#xff0c;RNN是一个字一个字…

Django Rest Framework 全局异常处理

在Django Rest Framework&#xff08;DRF&#xff09;中&#xff0c;全局异常处理是一种重要的机制&#xff0c;它可以帮助我们更好地管理API中的异常情况&#xff0c;并返回统一的错误响应。本文将详细介绍两种全局异常处理的方法&#xff1a;使用中间件&#xff08;Middlewar…

机器学习(3)

目录 3-1线性回归 3-2最小二乘解 3-3多元线性回归 3-4广义线性模型 3-5对率回归 3-6对率回归求解 3-7线性判别分析 3-8LDA的多类推广 3-9多分类学习基本思路 3-10类别不平衡 3-1线性回归 线性模型为什么重要&#xff1f; 人类在考虑问题时&#xff0c;通常…

用python写一个自动生成android开机动画的工具

要创建一个自动生成Android开机动画的工具&#xff0c;你需要一些基本的知识&#xff0c;比如Python编程、图像处理和Android开机动画的格式。以下是一个简单的Python脚本示例&#xff0c;它可以生成一个基本的Android开机动画&#xff0c;具体效果可能需要更多的调整和优化。 …

记录glide加载图片,设置圆角

支持所有角的圆角&#xff0c;自动计算合适的半径&#xff0c;不用担心图片比预定值小导致的圆角过大的问题 修改自&#xff1a;https://blog.csdn.net/qq_15059163/article/details/97613790 增加了指定图片尺寸、解决了图片某些情况下圆角过大的问题 public class GlideRou…