深度学习 Day7——T7咖啡豆识别

《YOLOv8:从入门到实战》报错解决 & 专栏答疑 《YOLOv8:从入门到实战》专栏上线后,部分同学在学习过程中提出了一些问题,笔者相信这些问题其他同学也有可能遇到。为了让大家可以更好地学习本专栏内容,笔者特意推出了该篇专栏答疑,针对同学们在学习过程中所提出的问题进行汇总记录,并不断实时更新,希望能够帮助到大家!🌈 阅读详情


前言

本文将采用VGG16网络实现咖啡豆识别。简单讲述实现代码与执行结果,并浅谈涉及知识点。
关键字:VGG16详解、模型轻量化-全局平均池化层代替全连接层、Batch Normalization详解。

一、我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm
  • 深度学习环境:TensorFlow 2.10.1
  • 显卡:NVIDIA GeForce RTX 4070

二、代码实现与执行结果

1.引入库

from PIL import Image
import numpy as np
from pathlib import Path
import tensorflow as tf
from tensorflow.keras import datasets, layers, models, regularizers
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras import layers, models, Input
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout, BatchNormalization
import matplotlib.pyplot as plt
import warnings

warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印

2.设置GPU(如果使用的是CPU可以忽略这步)

''前期工作-设置GPU(如果使用的是CPU可以忽略这步)'''
# 检查GPU是否可用
print(tf.test.is_built_with_cuda())
gpus = tf.config.list_physical_devices("GPU")
print(gpus)
if gpus:
    gpu0 = gpus[0]  # 如果有多个GPU,仅使用第0个GPU
    tf.config.experimental.set_memory_growth(gpu0, True)  # 设置GPU显存用量按需使用
    tf.config.set_visible_devices([gpu0], "GPU")

本人电脑前期无独显,故该步骤被注释,未执行,后觉得没有GPU加速实在太慢,新增显卡,则取消注释。

3.导入数据

'''前期工作-导入数据'''
data_dir = r"D:\DeepLearning\data\CoffeeBean"
data_dir = Path(data_dir)

4.查看数据

'''前期工作-查看数据'''
image_count = len(list(data_dir.glob('*/*.png')))
print("图片总数为:", image_count)
image_list = list(data_dir.glob('Green/*.png'))
image = Image.open(str(image_list[1]))
# 查看图像实例的属性
print(image.format, image.size, image.mode)
plt.imshow(image)
plt.show()

执行结果:

图片总数为: 1200
PNG (224, 224) RGB

在这里插入图片描述

5.加载数据

 '''数据预处理-加载数据'''
batch_size = 32
img_height = 224
img_width = 224
"""
关于image_dataset_from_directory()的详细介绍可以参考文章:https://mtyjkh.blog.youkuaiyun.com/article/details/117018789
"""
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=123,
    image_size=(img_height, img_width),
    batch_size=batch_size)
val_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=123,
    image_size=(img_height, img_width),
    batch_size=batch_size)
# 我们可以通过class_names输出数据集的标签。标签将按字母顺序对应于目录名称。
class_names = train_ds.class_names
print(class_names)

运行结果:

Found 1200 files belonging to 4 classes.
Using 960 files for training.
Found 1200 files belonging to 4 classes.
Using 240 files for validation.
['Dark', 'Green', 'Light', 'Medium']

6.可视化数据

'''数据预处理-可视化数据'''
plt.figure(figsize=(25, 20))
for images, labels in train_ds.take(1):
    for i in range(20):
        ax = plt.subplot(5, 4, i + 1)
        plt.imshow(images[i].numpy().astype("uint8"))
        plt.title(class_names[labels[i]], fontsize=40)
        plt.axis("off")
# 显示图片
plt.show()

在这里插入图片描述

7.再次检查数据

'''数据预处理-再次检查数据'''
# Image_batch是形状的张量(32,180,180,3)。这是一批形状180x180x3的32张图片(最后一维指的是彩色通道RGB)。
# Label_batch是形状(32,)的张量,这些标签对应32张图片
for image_batch, labels_batch in train_ds:
    print(image_batch.shape)
    print(labels_batch.shape)
    break

运行结果

(32, 224, 224, 3)
(32,)

8.配置数据集

本人电脑无GPU加速,故并未起到加速作用

'''数据预处理-配置数据集'''
AUTOTUNE = tf.data.AUTOTUNE
# shuffle():打乱数据,关于此函数的详细介绍可以参考:https://zhuanlan.zhihu.com/p/42417456
# prefetch():预取数据,加速运行
# cache():将数据集缓存到内存当中,加速运行
train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

normalization_layer = layers.experimental.preprocessing.Rescaling(1./255)

train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
val_ds   = val_ds.map(lambda x, y: (normalization_layer(x), y))
image_batch, labels_batch = next(iter(val_ds))
first_image = image_batch[0]

# 查看归一化后的数据
print(np.min(first_image), np.max(first_image))

运行结果

0.0 1.0

本人电脑不带GPU,故prefetch无效

9.构建CNN网络模型

'''构建CNN网络'''

def VGG16(nb_classes, input_shape):
    input_tensor = Input(shape=input_shape)
    # 1st block
    x = Conv2D(64, (3,3), activation='relu', padding='same',name='block1_conv1')(input_tensor)
    x = Conv2D(64, (3,3), activation='relu', padding='same',name='block1_conv2')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block1_pool')(x)
    # 2nd block
    x = Conv2D(128, (3,3), activation='relu', padding='same',name='block2_conv1')(x)
    x = Conv2D(128, (3,3), activation='relu', padding='same',name='block2_conv2')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block2_pool')(x)
    # 3rd block
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv1')(x)
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv2')(x)
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv3')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block3_pool')(x)
    # 4th block
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv1')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv2')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv3')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block4_pool')(x)
    # 5th block
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv1')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv2')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv3')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block5_pool')(x)
    # full connection
    x = Flatten()(x)
    x = Dense(4096, activation='relu',  name='fc1')(x)
    x = Dense(4096, activation='relu', name='fc2')(x)
    output_tensor = Dense(nb_classes, activation='softmax', name='predictions')(x)

    model = Model(input_tensor, output_tensor)
    return model
    
model=VGG16(len(class_names), (img_width, img_height, 3))
model.summary()

网络结构结果如下:

Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_1 (InputLayer)        [(None, 224, 224, 3)]     0         
                                                                 
 block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      
                                                                 
 block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     
                                                                 
 block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         
                                                                 
 block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     
                                                                 
 block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    
                                                                 
 block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         
                                                                 
 block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    
                                                                 
 block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    
                                                                 
 block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    
                                                                 
 block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         
                                                                 
 block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   
                                                                 
 block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   
                                                                 
 block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   
                                                                 
 block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         
                                                                 
 block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         
                                                                 
 flatten (Flatten)           (None, 25088)             0         
                                                                 
 fc1 (Dense)                 (None, 4096)              102764544 
                                                                 
 fc2 (Dense)                 (None, 4096)              16781312  
                                                                 
 predictions (Dense)         (None, 4)                 16388     
                                                                 
=================================================================
Total params: 134,276,932
Trainable params: 134,276,932
Non-trainable params: 0

10.编译模型

'''编译模型'''
# 设置初始学习率
initial_learning_rate = 1e-4

lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
        initial_learning_rate,
        decay_steps=30,      # 敲黑板!!!这里是指 steps,不是指epochs
        decay_rate=0.92,     # lr经过一次衰减就会变成 decay_rate*lr
        staircase=True)

# 设置优化器
opt = tf.keras.optimizers.Adam(learning_rate=initial_learning_rate)

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

11.训练模型

'''训练模型'''
epochs = 20

history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=epochs
)

训练记录如下:

Epoch 1/20
30/30 [==============================] - 267s 9s/step - loss: 1.3496 - accuracy: 0.2573 - val_loss: 1.1989 - val_accuracy: 0.5708
Epoch 2/20
30/30 [==============================] - 282s 9s/step - loss: 0.8790 - accuracy: 0.5396 - val_loss: 0.6942 - val_accuracy: 0.5875
Epoch 3/20
30/30 [==============================] - 282s 9s/step - loss: 0.6644 - accuracy: 0.6521 - val_loss: 0.6914 - val_accuracy: 0.6208
Epoch 4/20
30/30 [==============================] - 282s 9s/step - loss: 0.6401 - accuracy: 0.6917 - val_loss: 0.4857 - val_accuracy: 0.8167
Epoch 5/20
30/30 [==============================] - 283s 9s/step - loss: 0.5974 - accuracy: 0.7000 - val_loss: 0.4269 - val_accuracy: 0.8417
Epoch 6/20
30/30 [==============================] - 284s 9s/step - loss: 0.4448 - accuracy: 0.8021 - val_loss: 0.4033 - val_accuracy: 0.8333
Epoch 7/20
30/30 [==============================] - 283s 9s/step - loss: 0.3612 - accuracy: 0.8604 - val_loss: 0.3296 - val_accuracy: 0.8500
Epoch 8/20
30/30 [==============================] - 282s 9s/step - loss: 0.3452 - accuracy: 0.8396 - val_loss: 0.2594 - val_accuracy: 0.9042
Epoch 9/20
30/30 [==============================] - 281s 9s/step - loss: 0.1486 - accuracy: 0.9438 - val_loss: 0.1974 - val_accuracy: 0.9375
Epoch 10/20
30/30 [==============================] - 283s 9s/step - loss: 0.1229 - accuracy: 0.9563 - val_loss: 0.1365 - val_accuracy: 0.9417
Epoch 11/20
30/30 [==============================] - 281s 9s/step - loss: 0.0952 - accuracy: 0.9625 - val_loss: 0.1694 - val_accuracy: 0.9250
Epoch 12/20
30/30 [==============================] - 281s 9s/step - loss: 0.0992 - accuracy: 0.9667 - val_loss: 0.1305 - val_accuracy: 0.9542
Epoch 13/20
30/30 [==============================] - 282s 9s/step - loss: 0.1078 - accuracy: 0.9625 - val_loss: 0.2315 - val_accuracy: 0.9208
Epoch 14/20
30/30 [==============================] - 281s 9s/step - loss: 0.0620 - accuracy: 0.9802 - val_loss: 0.0593 - val_accuracy: 0.9792
Epoch 15/20
30/30 [==============================] - 280s 9s/step - loss: 0.0193 - accuracy: 0.9927 - val_loss: 0.0631 - val_accuracy: 0.9792
Epoch 16/20
30/30 [==============================] - 281s 9s/step - loss: 0.0380 - accuracy: 0.9875 - val_loss: 0.1255 - val_accuracy: 0.9625
Epoch 17/20
30/30 [==============================] - 281s 9s/step - loss: 0.0151 - accuracy: 0.9937 - val_loss: 0.0493 - val_accuracy: 0.9875
Epoch 18/20
30/30 [==============================] - 280s 9s/step - loss: 0.0084 - accuracy: 0.9979 - val_loss: 0.0912 - val_accuracy: 0.9750
Epoch 19/20
30/30 [==============================] - 293s 10s/step - loss: 0.0274 - accuracy: 0.9896 - val_loss: 0.0824 - val_accuracy: 0.9667
Epoch 20/20
30/30 [==============================] - 390s 13s/step - loss: 0.0210 - accuracy: 0.9917 - val_loss: 0.0904 - val_accuracy: 0.9750

最好效果为loss: 0.0151 - accuracy: 0.9937 - val_loss: 0.0493 - val_accuracy: 0.9875

12.模型评估

'''模型评估'''
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(epochs)
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

执行结果
在这里插入图片描述

三、知识点详解

1.VGG16详解

VGG优缺点分析:
● VGG优点
VGG的结构非常简洁,整个网络都使用了同样大小的卷积核尺寸(3x3)和最大池化尺寸(2x2)。
● VGG缺点
1)训练时间过长,调参难度大。2)需要的存储容量大,不利于部署。例如存储VGG-16权重值文件的大小为500多MB,不利于安装到嵌入式系统中。

1. 1 VGG16官方模型

官网模型调用:

def keras_vgg16(class_names, img_height, img_width):
    model = tf.keras.applications.VGG16(
        include_top=True,
        weights=None,
        input_tensor=None,
        input_shape=(img_height, img_width, 3),
        pooling=max,
        classes=len(class_names),
        classifier_activation="softmax",
    )
    return model
model = keras_vgg16(class_names, img_height, img_width)
model.summary()

或者

model = tf.keras.applications.VGG16(weights='imagenet')
model.summary()

1. 2 VGG16 网络结构图

结构说明:

● 13个卷积层(Convolutional Layer),分别用blockX_convX表示
● 3个全连接层(Fully connected Layer),分别用fcX与predictions表示
● 5个池化层(Pool layer),分别用blockX_pool表示
VGG-16包含了16个隐藏层(13个卷积层和3个全连接层),故称为VGG-16
在这里插入图片描述
在这里插入图片描述

1.3 保存最好参数模型+设置早停+动态设置学习率

'''编译模型'''
# 设置初始学习率
initial_learning_rate = 1e-4

lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
        initial_learning_rate,
        decay_steps=30,      # 敲黑板!!!这里是指 steps,不是指epochs
        decay_rate=0.92,     # lr经过一次衰减就会变成 decay_rate*lr
        staircase=True)

# 设置优化器
# opt = tf.keras.optimizers.Adam(learning_rate=initial_learning_rate)
# model.compile(optimizer=opt,
#               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
#               metrics=['accuracy'])
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
model.compile(optimizer=optimizer,
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

'''训练模型'''
epochs = 50
# 保存最佳模型参数
checkpointer = ModelCheckpoint('best_model.h5',
                               monitor='val_accuracy',
                               verbose=1,
                               save_best_only=True,
                               save_weights_only=True)
# 设置早停
earlystopper = EarlyStopping(monitor='val_accuracy',
                             min_delta=0.001,
                             patience=10,
                             verbose=1)
history = model.fit(train_ds,
                    validation_data=val_ds,
                    epochs=epochs,
                    callbacks=[checkpointer, earlystopper])

训练结果:

Epoch 1/50
30/30 [==============================] - ETA: 0s - loss: 1.3116 - accuracy: 0.2823
Epoch 1: val_accuracy improved from -inf to 0.38333, saving model to best_model.h5
30/30 [==============================] - 291s 10s/step - loss: 1.3116 - accuracy: 0.2823 - val_loss: 1.0678 - val_accuracy: 0.3833
Epoch 2/50
30/30 [==============================] - ETA: 0s - loss: 0.9069 - accuracy: 0.5094 
Epoch 2: val_accuracy improved from 0.38333 to 0.53333, saving model to best_model.h5
30/30 [==============================] - 426s 14s/step - loss: 0.9069 - accuracy: 0.5094 - val_loss: 0.9735 - val_accuracy: 0.5333
......
Epoch 26: val_accuracy did not improve from 0.98750
30/30 [==============================] - 352s 12s/step - loss: 0.0037 - accuracy: 0.9990 - val_loss: 0.0536 - val_accuracy: 0.9833
Epoch 26: early stopping

最好效果为loss: 0.0148 - accuracy: 0.9948 - val_loss: 0.0370 - val_accuracy: 0.9875
从acc曲线图看,设置动态学习率可以更快的收敛。

在这里插入图片描述

2.模型轻量化-全局平均池化层代替全连接层

全连接存在的问题:参数量过大,降低了训练的速度,且很容易过拟合
全连接层将卷积层展开成向量之后不还是要针对每个feature map进行分类,而GAP的思路就是将上述两个过程合二为一,一起做了。
如图所示:
在这里插入图片描述
GAP替换掉密集的全连接层即卷积层+全局平均池化代替卷积层+全连接层,极大的减少了网络的参数量,减小模型大小,相当于在网络结构上做正则,防止模型发生过拟合。

CNN+FC结构的模型,对于训练过程而言,整个模型的学习压力主要集中在FC层(FC层的参数量占整个模型参数量的80%),此时CNN层学习到的特征更倾向于低层的通用特征,即使CNN层学习到的特征比较低级,强大的FC层也可以通过学习调整参数做到很好的分类
CNN+GAP结构的模型,因为使用GAP代替了FC,模型的参数量骤减,此时模型的学习压力全部前导到CNN层,相比于CNN+FC层,此时的CNN层不仅仅需要学习到低层的通用特征,还要学习到更加高级的分类特征,学习难度变大,网络收敛变慢

def VGG16_GAP(nb_classes, input_shape):
    input_tensor = Input(shape=input_shape)
    # 1st block
    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(input_tensor)
    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
    # 2nd block
    x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)
    x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
    # 3rd block
    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)
    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)
    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
    # 4th block
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
    # 5th block
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
    # GAP
    x = layers.GlobalAveragePooling2D()(x)  # GAP层
    output_tensor = Dense(nb_classes, activation='softmax', name='predictions')(x)  # 输出层

    model = Model(input_tensor, output_tensor)
    return model
model = VGG16_GAP(len(class_names), (img_width, img_height, 3))
model.summary()
Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_1 (InputLayer)        [(None, 224, 224, 3)]     0         
                                                                 
 block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      
                                                                 
 block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     
                                                                 
 block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         
                                                                 
 block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     
                                                                 
 block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    
                                                                 
 block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         
                                                                 
 block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    
                                                                 
 block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    
                                                                 
 block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    
                                                                 
 block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         
                                                                 
 block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   
                                                                 
 block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   
                                                                 
 block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   
                                                                 
 block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         
                                                                 
 block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         
                                                                 
 global_average_pooling2d (G  (None, 512)              0         
 lobalAveragePooling2D)                                          
                                                                 
 predictions (Dense)         (None, 4)                 2052      
                                                                 
=================================================================
Total params: 14,716,740
Trainable params: 14,716,740
Non-trainable params: 0
_________________________________________________________________

全局平均池化层代替全连接层后参数量由134,276,932降至14,716,740
训练结果:

Epoch 1/50
30/30 [==============================] - ETA: 0s - loss: 1.3810 - accuracy: 0.2531
Epoch 1: val_accuracy improved from -inf to 0.22083, saving model to best_model.h5
30/30 [==============================] - 312s 11s/step - loss: 1.3810 - accuracy: 0.2531 - val_loss: 1.3408 - val_accuracy: 0.2208
Epoch 2/50
30/30 [==============================] - ETA: 0s - loss: 1.1375 - accuracy: 0.4208 
Epoch 2: val_accuracy improved from 0.22083 to 0.44583, saving model to best_model.h5
30/30 [==============================] - 392s 13s/step - loss: 1.1375 - accuracy: 0.4208 - val_loss: 1.1361 - val_accuracy: 0.4458

......

Epoch 31/50
30/30 [==============================] - ETA: 0s - loss: 0.0242 - accuracy: 0.9958 
Epoch 31: val_accuracy did not improve from 0.99167
30/30 [==============================] - 395s 13s/step - loss: 0.0242 - accuracy: 0.9958 - val_loss: 0.0421 - val_accuracy: 0.9875
Epoch 31: early stopping

最好效果为loss: loss: 0.0578 - accuracy: 0.9792 - val_loss: 0.0394 - val_accuracy: 0.9917
acc和loss图
在这里插入图片描述

从acc曲线图看,既减少参数,识别率还有所提升。

3 Batch Normalization详解

Batch Normalization(BN),该方法对每个mini-batch都进行normalize,会把mini-batch中的数据正规化到均值为0,标准差为1,同时还引入了两个可以学的参数,分别为scale和shift,让模型学习其适合的分布。scale和shift是模型自动学习的,神经网络可以自己琢磨前面的正规化有没有起到优化作用,没有的话就"反"正规化,抵消之前的正规化操作带来的影响。

3.1 Batch Normalization作用

(1) 可以加快模型训练时的收敛速度,使得模型训练过程更加稳定,避免梯度爆炸或者梯度消失
拿sigmoid激活函数距离,从图中,我们很容易知道,数据值越靠近0梯度越大,越远离0梯度越接近0,我们通过BN改变数据分布到0附近,从而解决梯度消失问题。
在这里插入图片描述
(2)解决了Internal Covariate Shift(ICS)问题
由于训练过程中参数的变化,导致各层数据分布变化较大,神经网络就要学习新的分布,随着层数的加深,学习过程就变的愈加困难,要解决这个问题需要使用较低的学习率,由此又产生收敛速度慢,因此引入BN可以很有效的解决这个问题。
(3)加速了模型的收敛
和对原始特征做归一化类似,BN使得每一维数据对结果的影响是相同的,由此就能加速模型的收敛速度。
在这里插入图片描述
(4)具有正则化效果
BN层和正规化/归一化不同,BN层是在mini-batch中计算均值方差,因此会带来一些较小的噪声,在神经网络中添加随机噪声可以带来正则化的效果。

tips

Batch Normalization作用总结
(1)将输入神经网络的数据先对其做平移和伸缩变换,将数据分布规范化成在固定区间范围的标准分布
(2)可以加快模型训练时的收敛速度,使得模型训练过程更加稳定,避免梯度爆炸或者梯度消失
(3)并且起到一定的正则化作用,几乎代替了Dropout。控制过拟合,可以少用或不用Dropout和正则
(4)降低网络对初始化权重不敏感
(5)允许使用较大的学习率

3.3 Batch Normalization放在哪个位置

在CNN中一般应作用与非线性激活函数之前,但是,实际上放在激活函数之后效果可能会更好。
BN消除了对dropout的依赖,因为BN也有和dropout本质一样的正则化的效果,像是ResNet, DenseNet等等并没有使用dropout,如果要用并用BN和dropout,还是建议BN放在dropout之前。

# 放在非线性激活函数之前
model.add(tf.keras.layers.Conv2D(64, (3, 3)))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Activation('relu'))

# 放在激活函数之后
model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu'))
model.add(tf.keras.layers.BatchNormalization())

3.3 增加Batch Normalization的网络模型

# 模型轻量化-全局平均池化层代替全连接层+BN
def VGG16_BN_GAP(nb_classes, input_shape):
    input_tensor = Input(shape=input_shape)
    # 1st block
    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(input_tensor)
    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
    x = BatchNormalization()(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
    # 2nd block
    x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)
    x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)
    x = BatchNormalization()(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
    # 3rd block
    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)
    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)
    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)
    x = BatchNormalization()(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
    # 4th block
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)
    x = BatchNormalization()(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
    # 5th block
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)
    x = BatchNormalization()(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
    # GAP
    x = layers.GlobalAveragePooling2D()(x)  # GAP层
    output_tensor = Dense(nb_classes, activation='softmax', name='predictions')(x)  # 输出层

    model = Model(input_tensor, output_tensor)
    return model

model = VGG16_BN_GAP(len(class_names), (img_width, img_height, 3))
model.summary()

模型结构

Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_1 (InputLayer)        [(None, 224, 224, 3)]     0         
                                                                 
 block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      
                                                                 
 block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     
                                                                 
 batch_normalization (BatchN  (None, 224, 224, 64)     256       
 ormalization)                                                   
                                                                 
 block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         
                                                                 
 block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     
                                                                 
 block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    
                                                                 
 batch_normalization_1 (Batc  (None, 112, 112, 128)    512       
 hNormalization)                                                 
                                                                 
 block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         
                                                                 
 block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    
                                                                 
 block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    
                                                                 
 block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    
                                                                 
 batch_normalization_2 (Batc  (None, 56, 56, 256)      1024      
 hNormalization)                                                 
                                                                 
 block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         
                                                                 
 block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   
                                                                 
 block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   
                                                                 
 block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   
                                                                 
 batch_normalization_3 (Batc  (None, 28, 28, 512)      2048      
 hNormalization)                                                 
                                                                 
 block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         
                                                                 
 block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   
                                                                 
 batch_normalization_4 (Batc  (None, 14, 14, 512)      2048      
 hNormalization)                                                 
                                                                 
 block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         
                                                                 
 global_average_pooling2d (G  (None, 512)              0         
 lobalAveragePooling2D)                                          
                                                                 
 predictions (Dense)         (None, 4)                 2052      
                                                                 
=================================================================
Total params: 14,722,628
Trainable params: 14,719,684
Non-trainable params: 2,944
_________________________________________________________________

训练结果:

Epoch 1/50
30/30 [==============================] - ETA: 0s - loss: 0.2237 - accuracy: 0.9083
Epoch 1: val_accuracy improved from -inf to 0.32083, saving model to best_model.h5
30/30 [==============================] - 321s 11s/step - loss: 0.2237 - accuracy: 0.9083 - val_loss: 1.6336 - val_accuracy: 0.3208
Epoch 2/50
30/30 [==============================] - ETA: 0s - loss: 0.0717 - accuracy: 0.9760 
Epoch 2: val_accuracy did not improve from 0.32083
......
Epoch 11/50
30/30 [==============================] - ETA: 0s - loss: 4.2546e-04 - accuracy: 1.0000
Epoch 11: val_accuracy did not improve from 0.32083
30/30 [==============================] - 274s 9s/step - loss: 4.2546e-04 - accuracy: 1.0000 - val_loss: 8.0358 - val_accuracy: 0.3208
Epoch 11: early stopping

最好效果为loss: 0.0148 - accuracy: 0.9948 - val_loss: 0.0370 - val_accuracy: 0.9875
acc和loss图

从acc曲线图看,设置动态学习率可以更快的收敛。
增大初始学习率initial_learning_rate = 0.01后,最好效果为loss: 0.0077 - accuracy: 1.0000 - val_loss: 0.0293 - val_accuracy: 0.9917
在这里插入图片描述
从结果看,增加BN层后,怎个网络不一定变好,因为BN层主要作用是解决过拟合的,而本文这个并未过拟合现象发生,因此慎用BN层。

总结

通过本次的学习,能通过tenserflow框架创建cnn网络模型进行猴痘病识别,学习本章节时设置保存权重可以便于查看模型效果最好时候的信息,尽管增加BN层有很多好处,但是他主要用于解决过拟合情况,在未发生过拟合的网络下增加BN层可能还有反效果。

面向精准医疗的多模态影像融合:实现前列腺MRI与大病理切片的三维配准与空间重建研究 亲爱的同学,当你能完整实现“前列腺MRI与大病理组织学图像的3D配准及体素重建”,你会发现医学影像交叉领域的毕设课题充满挑战与乐趣。我们将从临床需求出发,拆解3D配准与体素重建的核心技术,带你从原理到代码实现完整流程,让你的毕设不仅能顺利完成,更能体现临床应用价值。,让MRI和病理图像在同一空间对齐,能实现“术前影像-术后病理”的精准关联,为前列腺癌的精准诊疗、预后评估提供关键依据——这一课题既有技术挑战性,又有临床意义,是毕设的优质选择。(如NCC、Dice、配准时间),用数据证明方法的优越性。 阅读详情

相关推荐

Python+OpenCV实现游戏自动刷怪脚本(附完整代码)

本文详细介绍了如何使用Python和OpenCV开发游戏自动刷怪脚本,涵盖环境搭建、图像识别、行为决策引擎及反检测优化等关键技术。通过完整的代码示例,帮助开发者实现从简单脚本到智能自动化系统的升级,提升游戏效率。

weixin_29032489的博客 525

卷积网络识别好莱坞明星

卷积网络识别好莱坞明星

m0_60524373的博客 642

UReport2 报表设计器 在线表格

UReport2官网 一、UReport2报表设计器 UReport2是一个开源的可视化报表设计器,功能强大,操作简单,可以实现复杂的报表统计,有各种各样的导出和打印功能,支持导入Excel表格! 1、报表设计器 2、设计一个简单的用户列表展示 二、可编辑表格 扩展了layui的表格,支持多元化数据编辑(单选,多些、日期、下拉联动),开发简单、高效、便捷。有了它就可以轻松开发类似进销存系统的表格录入功能了,用户拿来即用! 三、主从表录......

ejinxian的专栏 2万+

【深度学习打卡】:第七周咖啡豆识别

1.自己用PPT搭建网络模型,并学会如何搭建简单的卷积、池化和全连接2.训练的速度很慢,参数量多3.训练集和测试集在第30个epoch是能达到准确率最佳的状态4.将优化器从Adam改为SGD后发现惊人的现象,训练集的准确率在初期就达到100%,测试集也在初期准确率就达到98.5%,并且一直维持,Adam优化器需要早30个epoch后才能达到这个效果。为什么会出现这样的情况呢?

m0_45216728的博客 594

Nvidia Tesla A100 驱动安装方法

Nvidia Tesla A100 驱动安装方法 遇到的问题:以前安装tesla系列、geforce系列等gpu 驱动的时候,只需执行nvidiaxxxx.run驱动包或者安装nvidiaxxxx.rpm包即可,但遇到新的GPU Nvidia Tesla A100的时候,安装完驱动似乎不起作用,找了半天资料,原来需要以下步骤才可以使用;

qq_24343177的博客 2万+

核密度估计及其Python实践

一、参数估计简介 很多情况下,我们只有有限的样本集,而类条件概率密度函数p(x|ωi)和先验概率P(ωi)是未知的,需要根据已有样本进行参数估计,然后将估计值当作真实值来使用。 由给定样本集求解随机变量的分布密度函数问题是统计机器学习和概率统计学的基本问题之一。解决该问题的方法包括参数估计和非参数估计两大类: 1.参数估计方法 已知概率密度函数的形式而函数的有关参数未知,通过估计参数来估计概率密度函数的方法。有两种主要参数估计法:确定性参数估计方法是把参数看作确定而未知的, 典型方法为最大似然估计。随机参数

袁易学的博客(Yuan Yixue's Blog) 1万+

深度学习 Day18——P7咖啡豆识别

关键字: 增加Dropout层,全局平均池化层代替全连接层(模型轻量化)

LittleRuby的博客 1538

HyperMesh实战:5种复杂载荷场景下的field映射技巧(附TCL脚本)

本文详细介绍了HyperMesh在5种复杂载荷场景下的field映射技巧,包括轴承载荷的圆柱坐标系映射、粉末压力中的切向力处理、实验数据到有限元模型的场映射、多工况载荷的组合映射以及局部细化网格的边界条件传递。通过实战案例和TCL脚本,帮助工程师高效解决有限元分析中的载荷映射难题,提升工作效率。

fanta的博客 295

【深度学习——咖啡豆的识别】

本实验总结如下:1、数据预处理和加载:通过torchvision.transforms模块定义了训练集和测试集的数据预处理方式。使用datasets.ImageFolder加载数据集,并按照一定比例划分为训练集和测试集。使用torch.utils.data.DataLoader创建训练集和测试集的数据加载器。2、构建模型:定义了一个VGG16的神经网络模型,包括卷积层、池化层和全连接层。3、训练和测试循环:实现了训练和测试函数,包括计算损失、准确率等指标。

qq_45786199的博客 536

超越音频!STM32 SAI接口在AD7768高速ADC采集中的妙用(含PCB布局指南)

本文深入探讨了如何将STM32的SAI接口应用于AD7768高速ADC的数据采集系统,超越了其传统的音频应用范畴。文章详细解析了SAI协议与ADC时序的匹配方法,提供了从CubeMX配置、DMA数据搬运到关键PCB布局指南的完整实战方案,旨在帮助工程师实现稳定、高精度的工业级高速数据采集。

efc12345678的博客 305

WPF用户控件间属性传递的艺术

本文详细介绍了WPF中父控件向子控件传递属性的方法。针对常见的绑定失效问题,重点讲解了使用RelativeSource绑定技术,通过指定AncestorType确保正确访问父控件属性。文章通过实例演示了从ParentModel传递属性到ChildUserControl依赖属性的完整实现过程,包括模型定义、XAML结构设计和代码实现。这种方法有效解决了数据上下文混淆问题,为WPF开发中的控件交互提供了可靠解决方案,有助于提升应用的灵活性和可维护性。

2501_90323865的博客 58

深度学习Week13——利用TensorFlow实现咖啡豆识别

🍨 本文为🔗365天深度学习训练营中的学习记录博客K同学啊 | 接辅导、项目定制本篇内容分为两个部分,前面部分是学习K同学给的算法知识点以及复现,后半部分是自己的拓展与未解决的问题。

Ying_xiaotao的博客 1080

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

从零搭建可落地的推荐引擎:轻量架构与工程实践

推荐系统本质上是连接用户行为与商业目标的工程管道,其核心不在模型复杂度,而在数据链路稳定性、特征实时性与业务规则可插拔性。本文聚焦‘中小规模场景下如何用有限资源快速上线可用推荐’这一高频搜索需求,深入解析召回-排序-规则三层轻量架构设计原理,涵盖Item-CF工程化改造、Redis热点缓存降级、YAML驱动的特征管理等真实落地技术点。内容特别适配无算法团队、无GPU集群、无特征平台的初创或区域型业务场景,强调冷启动策略、AB灰度验证与可观测性建设,帮助开发者绕过‘论文模型陷阱’,直击推荐系统在电商、小程序等

weixin_30753873的博客 328

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

手把手构建可上线的电商推荐系统:从规则到轻量模型

推荐系统是现代电商平台的核心能力,其本质是通过用户行为建模实现个性化匹配。理解协同过滤原理、时间衰减机制与行为置信度设计,是构建高可用推荐引擎的基础。技术价值在于平衡可解释性、实时性与业务可控性——尤其在中小规模场景(日活3万、SKU 8万)下,轻量级架构比深度学习更易落地、更易归因。典型应用场景包括首页猜你喜欢、买了又买、购物车关联推荐等,需应对冷启动、数据稀疏、热门商品霸榜等真实挑战。本文聚焦电商领域,详解Item-CF召回、销售动线聚类、滑动窗口热度等关键实践,提供从日志解析到混合排序的完整可运行路径

weixin_30608503的博客 364

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Xception实现动物识别(TensorFlow)

Xception实现动物识别(TensorFlow)

人工智能方向,计算机视觉(https://github.com/chenshunpeng) 2481

深度学习Day-07:实现咖啡豆识别(VGG-16复现)

深度学习pytorch

m0_51359915的博客 1014

Pytorch入门实战第七周:咖啡豆识别(VGG-16复现)

🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客🍖 原作者:[K同学啊](https://mtyjkh.blog.youkuaiyun.com/)本周学习目标:基本要求——自己搭建VGG-16网络框架、调用官方的VGG-16网络框架、如何查看模型的参数量以及相关指标;拔高要求——验证集准确率达到100%、使用PPT画出VGG-16算法框架图;

weixin_46620278的博客 1277

pytorch(七):咖啡豆识别

🍨 本文为🔗中的学习记录博客🏡 我的环境:语言环境:Python3.8深度学习环境:Pytorch。

weixin_43175664的博客 280

第P7周:咖啡豆识别(VGG-16复现)

1.这几次的框架几乎都是相同的,唯一区别的就是每次都是只了一种网络模型去跑2感觉可以修改的也就只有优化器和调整动态学习率了。

weixin_51520249的博客 589

深度学习第七周:VGG-16复现——咖啡豆识别

深度学习入门:VGG16复现和优化器

qq1273882425的博客 1253

P7周:咖啡豆识别

设置好图片路径,并在总的图片基础上划分训练集与测试集,这里我把训练集与测试集中的图片比例设为0.8:0.2,加载训练集与测试集,获取并打印出总的图片数。将图片裁剪为统一尺寸并转化为张量,并将张量进行归一化,然后进行标准化处理。前面设置的网络模型进行引用,启用交叉熵损失函数与优化函数,并设置学习率。导入一些即将用到的库,定义一个cuda设备并进行打印。本次数据集由K同学提供,如有需要,请联系K同学。设置所选图片的路径,使用训练的权重。更新最佳精度并保存到权重文件中。导入所需的包并进行预处理。

geo436872的博客 287

Week7-P7:咖啡豆识别

P7让我学习了使用PyTorch实现一个VGG-16模型的过程,目的是识别不同的咖啡豆品种。我对VGG-16网络的结构和原理有了更深的理解,也学习了如何选择合适的损失函数和优化器来训练模型。我还利用了可视化工具来展示模型的结果,包括损失和准确率曲线,发现模型在一些图片上的预测很准确,但在一些图片上还有改进的空间。

weixin_56547604的博客 553

365天深度学习训练营-第7周:咖啡豆识别

VGG-16模型、LeNet5模型、以及模型的简单优化

m0_58585940的博客 1609

RNNoise-SpeexDSP-WebRTC使用说明

本文介绍RNNoise、SpeexDSP与WebRTC音频处理库的下载、调用及参数配置方法,适用于Android语音工程集成。RNNoise基于深度学习,适合非稳态噪声降噪,需48kHz输入;SpeexDSP支持多采样率与回声消除,适用于全双工场景;WebRTC提供轻量级窄带处理。三者可串联使用:麦克风信号先经前级降噪(RNNoise或SpeexDSP),再进入WebRTC媒体引擎进行编码。重点说明各库的典型应用场景、接口调用方式、关键参数调节策略及采样率转换注意事项,帮助开发者高效集成与优化语音处理链路。

知识共享,你我皆是知识的搬运工 239

基于深度学习的商品评论情感分析系统-毕业设计

面向商品评论的中文情感分析系统,支持单条预测、批量分析、情感分布与关键词、报告导出。TextCNN、BiLSTM、Transformer 在同一词表、同一数据切分、同一种子与超参下公平对比,测试集 F1 分别为 0.9101、0.9089、0.9075。结论是这一规模下模型复杂度未带来收益,但误差结构不同。附技术栈、截图、文档预览与演示视频。

csbysj2020 158

Transformer 为什么能取代 RNN?从自注意力讲起

2017 年谷歌在《Attention Is All You Need》中提出 Transformer,核心是。它如今是 GPT、BERT、ChatGPT 的共同底座。

anew___的博客 979
上一篇: 深度学习 Day6——T6好莱坞明星识别
下一篇: 深度学习--GPU环境准备
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值