T2学习笔记

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

设置GPU

import tensorflow as tf
gpus = tf.config.list_physical_devices("GPU")

if gpus:
    gpu0 = gpus[0] #如果有多个GPU，仅使用第0个GPU
    tf.config.experimental.set_memory_growth(gpu0, True) #设置GPU显存用量按需使用
    tf.config.set_visible_devices([gpu0],"GPU")

导入数据

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

# 将像素的值标准化至0到1的区间内。
# 归一化的目的将数据转换成具有统一尺度的形式,使得不同特征之间的数值范围相似或
# 相同,使得模型更容易学习到合适的权重,提高模型性能,同时可以将所有特征的尺度统一到一
# 个范围内,避免特征之间不合理的权重分配。
train_images, test_images = train_images / 255.0, test_images / 255.0

train_images.shape,test_images.shape,train_labels.shape,test_labels.shape

((50000, 32, 32, 3), (10000, 32, 32, 3), (50000, 1), (10000, 1))

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer','dog', 'frog', 'horse', 'ship', 'truck']

plt.figure(figsize=(20,10))
for i in range(20):
    plt.subplot(5,10,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i][0]])
plt.show()

• ReLu函数作为激活励函数可以增强判定函数和整个神经网络的非线性特性,而本身并不会改变卷积层;它可以将神经网络的训练速度提升数倍,而并不会对模型的泛化准确度造成显著影响。

model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)), #卷积层1，卷积核3*3
    layers.MaxPooling2D((2, 2)),                   #池化层1，2*2采样
    layers.Conv2D(64, (3, 3), activation='relu'),  #卷积层2，卷积核3*3
    layers.MaxPooling2D((2, 2)),                   #池化层2，2*2采样
    layers.Conv2D(64, (3, 3), activation='relu'),  #卷积层3，卷积核3*3

    layers.Flatten(),                      #Flatten层，连接卷积层与全连接层
    layers.Dense(64, activation='relu'),   #全连接层，特征进一步提取
    layers.Dense(10)                       #输出层，输出预期结果
])

model.summary()  # 打印网络结构

C:\Users\11054\.conda\envs\py311\Lib\site-packages\keras\src\layers\convolutional\base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

Model: "sequential"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ conv2d (Conv2D)                      │ (None, 30, 30, 32)          │             896 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d (MaxPooling2D)         │ (None, 15, 15, 32)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_1 (Conv2D)                    │ (None, 13, 13, 64)          │          18,496 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_1 (MaxPooling2D)       │ (None, 6, 6, 64)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_2 (Conv2D)                    │ (None, 4, 4, 64)            │          36,928 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten (Flatten)                    │ (None, 1024)                │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense (Dense)                        │ (None, 64)                  │          65,600 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_1 (Dense)                      │ (None, 10)                  │             650 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 122,570 (478.79 KB)

 Trainable params: 122,570 (478.79 KB)

 Non-trainable params: 0 (0.00 B)

编译

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

训练模型

history = model.fit(train_images, train_labels, epochs=10,
                    validation_data=(test_images, test_labels))

Epoch 1/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m25s[0m 15ms/step - accuracy: 0.3394 - loss: 1.7716 - val_accuracy: 0.5455 - val_loss: 1.2667
Epoch 2/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m42s[0m 16ms/step - accuracy: 0.5605 - loss: 1.2450 - val_accuracy: 0.6039 - val_loss: 1.1120
Epoch 3/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m25s[0m 16ms/step - accuracy: 0.6226 - loss: 1.0781 - val_accuracy: 0.6452 - val_loss: 1.0220
Epoch 4/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m41s[0m 16ms/step - accuracy: 0.6559 - loss: 0.9902 - val_accuracy: 0.6157 - val_loss: 1.1237
Epoch 5/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m26s[0m 16ms/step - accuracy: 0.6842 - loss: 0.9066 - val_accuracy: 0.6800 - val_loss: 0.9211
Epoch 6/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m25s[0m 16ms/step - accuracy: 0.7057 - loss: 0.8448 - val_accuracy: 0.6794 - val_loss: 0.9333
Epoch 7/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m41s[0m 16ms/step - accuracy: 0.7246 - loss: 0.7855 - val_accuracy: 0.6889 - val_loss: 0.9176
Epoch 8/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m25s[0m 16ms/step - accuracy: 0.7382 - loss: 0.7457 - val_accuracy: 0.6996 - val_loss: 0.8860
Epoch 9/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m41s[0m 16ms/step - accuracy: 0.7555 - loss: 0.6957 - val_accuracy: 0.6812 - val_loss: 0.9643
Epoch 10/10
[1m1563/1563[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m38s[0m 14ms/step - accuracy: 0.7647 - loss: 0.6687 - val_accuracy: 0.6978 - val_loss: 0.8894

预测

plt.imshow(test_images[1])

import numpy as np

pre = model.predict(test_images)
print(class_names[np.argmax(pre[1])])

[1m313/313[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 8ms/step
ship

模型评估

import matplotlib.pyplot as plt

plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0.5, 1])
plt.legend(loc='lower right')
plt.show()

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

313/313 - 2s - 7ms/step - accuracy: 0.6978 - loss: 0.8894

个人总结

• 使用layers.Dropout(0.4) 可以防止过拟合 提升模型准确度达到0.71

Dropout 基本思想：在每次训练过程中，随机地忽略（即“丢弃”）一部分神经元及其连接，以此来减少神经元之间的相互依赖。具体来说，在每次训练迭代时，Dropout 会以一定的概率（例如 0.4，这意味着有 40% 的概率）将神经元“关闭”，即不考虑这些神经元的输出。

Dropout 工作原理：

在训练过程中，随机选择一部分神经元，并将它们的输出值设置为零。
在测试过程中，所有的神经元都被使用，但它们的输出值被按训练过程中被保留的概率进行缩放。
为什么 Dropout 防止过拟合
减少神经元之间的相互依赖：

在没有 Dropout 的情况下，某些神经元可能会对一些特定的特征非常敏感，导致模型对特定的训练数据过于依赖。
Dropout 强制每个神经元在预测时不能依赖于其他特定的神经元，从而迫使网络学习更加鲁棒的特征。
实现隐形的模型集成：

每次训练迭代时，Dropout 会创建一个不同的子网络。可以认为，每个子网络都是从原始网络中随机采样而来。
在测试时，所有的神经元都被使用，相当于对所有可能的子网络进行了集成预测，从而提升模型的泛化能力。
减少过拟合：

Dropout 通过随机丢弃神经元来减少神经网络的复杂度，从而降低了过拟合的风险。