深度学习 Day10——T10数据增强

Keras神经网络的学习与使用(4)-数据增强 数据增强数据增强的作用数据增强的概述Keras实现数据增强自己实现数据增强 数据增强的作用 深度学习有3个核心要素,分别是: 优秀的算法设计 高性能的计算能力 大数据 因此在我们拥有优秀的算法设计和高性能的计算能力的同时,我们也需要大量的高质量数据。 但是,对于个人,学校团队甚至普通的工程师团队来说,数据的搜集能力都是十分有限的。缺乏大量高质量的训练样本,便难以训练处一个具有很好泛化能力的模型... 阅读详情


前言

本文将采用CNN实现猫狗识别。简单讲述实现代码与执行结果,并浅谈涉及知识点。
关键字:图像增强

一、我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm2020.2.3
  • 深度学习环境: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
from tqdm import tqdm
import tensorflow.keras.backend as K
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")

执行结果

True
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

3.导入数据

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

4.查看数据

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

执行结果:

图片总数为: 3400
JPEG (512, 512) RGB

在这里插入图片描述

5.加载数据

 '''数据预处理-加载数据'''
batch_size = 64
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=12,
    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=12,
    image_size=(img_height, img_width),
    batch_size=batch_size)
# 我们可以通过class_names输出数据集的标签。标签将按字母顺序对应于目录名称。
class_names = train_ds.class_names
print(class_names)

运行结果:

Found 3400 files belonging to 2 classes.
Using 2720 files for training.
Found 3400 files belonging to 2 classes.
Using 680 files for validation.
['cat', 'dog']

6.再次检查数据

'''数据预处理-再次检查数据'''
# 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

运行结果

(64, 224, 224, 3)
(64,)

7.配置数据集

AUTOTUNE = tf.data.AUTOTUNE


def preprocess_image(image, label):
    return (image / 255.0, label)


# 归一化处理
train_ds = train_ds.map(preprocess_image, num_parallel_calls=AUTOTUNE)
val_ds = val_ds.map(preprocess_image, num_parallel_calls=AUTOTUNE)
test_ds = test_ds.map(preprocess_image, num_parallel_calls=AUTOTUNE)

train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

8.可视化数据

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

在这里插入图片描述

9.构建CNN网络模型

#VGG16
def VGG16(class_names, img_height, img_width):
    model = models.Sequential([
        # 1
        layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same',
                      input_shape=(img_height, img_width, 3)),
        layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 2
        layers.Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 3
        layers.Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 4
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 5
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # FC
        layers.Flatten(),
        layers.Dense(4096, activation='relu'),
        layers.Dense(4096, activation='relu'),
        layers.Dense(len(class_names), activation='softmax')
      ])
    return model
model = VGG16(class_names, img_height, img_width)
model.summary()

网络结构结果如下:

Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 224, 224, 64)      1792      
                                                                 
 conv2d_1 (Conv2D)           (None, 224, 224, 64)      36928     
                                                                 
 max_pooling2d (MaxPooling2D  (None, 112, 112, 64)     0         
 )                                                               
                                                                 
 conv2d_2 (Conv2D)           (None, 112, 112, 128)     73856     
                                                                 
 conv2d_3 (Conv2D)           (None, 112, 112, 128)     147584    
                                                                 
 max_pooling2d_1 (MaxPooling  (None, 56, 56, 128)      0         
 2D)                                                             
                                                                 
 conv2d_4 (Conv2D)           (None, 56, 56, 256)       295168    
                                                                 
 conv2d_5 (Conv2D)           (None, 56, 56, 256)       590080    
                                                                 
 conv2d_6 (Conv2D)           (None, 56, 56, 256)       590080    
                                                                 
 max_pooling2d_2 (MaxPooling  (None, 28, 28, 256)      0         
 2D)                                                             
                                                                 
 conv2d_7 (Conv2D)           (None, 28, 28, 512)       1180160   
                                                                 
 conv2d_8 (Conv2D)           (None, 28, 28, 512)       2359808   
                                                                 
 conv2d_9 (Conv2D)           (None, 28, 28, 512)       2359808   
                                                                 
 max_pooling2d_3 (MaxPooling  (None, 14, 14, 512)      0         
 2D)                                                             
                                                                 
 conv2d_10 (Conv2D)          (None, 14, 14, 512)       2359808   
                                                                 
 conv2d_11 (Conv2D)          (None, 14, 14, 512)       2359808   
                                                                 
 conv2d_12 (Conv2D)          (None, 14, 14, 512)       2359808   
                                                                 
 max_pooling2d_4 (MaxPooling  (None, 7, 7, 512)        0         
 2D)                                                             
                                                                 
 flatten (Flatten)           (None, 25088)             0         
                                                                 
 dense (Dense)               (None, 4096)              102764544 
                                                                 
 dense_1 (Dense)             (None, 4096)              16781312  
                                                                 
 dense_2 (Dense)             (None, 2)                 8194      
                                                                 
=================================================================
Total params: 134,268,738
Trainable params: 134,268,738
Non-trainable params: 0
_________________________________________________________________

10.编译模型

'''编译模型'''
#设置初始学习率
initial_learning_rate = 1e-4
opt = tf.keras.optimizers.Adam(learning_rate=initial_learning_rate)
model.compile(optimizer=opt,
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

11.训练模型

'''训练模型'''
epochs = 10
history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=epochs,
    shuffle=False
)

训练记录如下:

Epoch 1/10

43/43 [==============================] - 42s 606ms/step - loss: 0.6830 - accuracy: 0.5511 - val_loss: 0.7328 - val_accuracy: 0.6630
Epoch 2/10
43/43 [==============================] - 17s 384ms/step - loss: 0.4927 - accuracy: 0.7614 - val_loss: 0.3283 - val_accuracy: 0.8714
Epoch 3/10
43/43 [==============================] - 17s 385ms/step - loss: 0.2113 - accuracy: 0.9165 - val_loss: 0.1986 - val_accuracy: 0.9221
Epoch 4/10
43/43 [==============================] - 17s 385ms/step - loss: 0.1173 - accuracy: 0.9555 - val_loss: 0.0977 - val_accuracy: 0.9620
Epoch 5/10
43/43 [==============================] - 17s 385ms/step - loss: 0.0561 - accuracy: 0.9798 - val_loss: 0.0789 - val_accuracy: 0.9728
Epoch 6/10
43/43 [==============================] - 17s 385ms/step - loss: 0.0483 - accuracy: 0.9816 - val_loss: 0.0578 - val_accuracy: 0.9783
Epoch 7/10
43/43 [==============================] - 17s 385ms/step - loss: 0.0457 - accuracy: 0.9838 - val_loss: 0.0551 - val_accuracy: 0.9783
Epoch 8/10
43/43 [==============================] - 17s 385ms/step - loss: 0.0372 - accuracy: 0.9875 - val_loss: 0.0985 - val_accuracy: 0.9692
Epoch 9/10
43/43 [==============================] - 17s 385ms/step - loss: 0.0324 - accuracy: 0.9915 - val_loss: 0.0264 - val_accuracy: 0.9873
Epoch 10/10
43/43 [==============================] - 17s 385ms/step - loss: 0.0109 - accuracy: 0.9967 - val_loss: 0.0408 - val_accuracy: 0.9891
2/2 [==============================] - 0s 116ms/step - loss: 0.0615 - accuracy: 0.9922
Accuracy 0.9921875


12.模型评估

'''模型评估'''
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(len(loss))
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()

loss, acc = model.evaluate(test_ds)
print("Accuracy", acc)

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

2/2 [==============================] - 0s 116ms/step - loss: 0.0615 - accuracy: 0.9922
Accuracy 0.9921875

三、知识点详解

1.图像增强

在深度学习中,有的时候训练集不够多,或者某一类数据较少,或者为了防止过拟合,让模型更加鲁棒性,data augmentation是一个不错的选择。
通过数据增强,我们可以将一些已经存在的数据进行相应的变换(可以选择将这些变换之后的数据增加到新的原来的数据集之中,也可以直接在原来的数据集上进行变换),从而实现数据种类多样性的增加。
对于图片数据,常见的数据增强方式包括:

  • 随机水平翻转:
  • 随机的裁剪;
  • 随机调整明亮程度;
  • 其他方式等

1.1TensorFlow 之中进行图像数据增强

在 TensorFlow 之中进行图像数据增强的方式主要有两种:

  • 使用 tf.keras 的预处理层进行图像数据增强;
  • 使用 tf.image 进行数据增强。

1.1.1使用 tf.keras 的预处理层进行图像数据增强

使用 tf.keras 的预处理层进行图像数据增强要使用的最主要的 API 包括在一下包之中:

tf.keras.layers.experimental.preprocessing

在这个包之中,我们最常用的数据增强 API 包括:

tf.keras.layers.experimental.preprocessing.RandomFlip(mode): 将输入的图片进行随机翻转,一般我们会取 mode=“horizontal” ,因为这代表水平旋转;而 mode=“vertical” 则代表随机进行上下翻转;
tf.keras.layers.experimental.preprocessing.RandomRotation§: 按照旋转角度(单位为弧度) p 将输入的图片进行随机的旋转;
tf.keras.layers.experimental.preprocessing.RandomContrast§:按照 P 的概率将输入的图片进行随机的图像色相翻转;
tf.keras.layers.experimental.preprocessing.CenterCrop(height, width):使用 height * width 的大小的裁剪框,在数据的中心进行裁剪。
该API有两种使用方式:一个是将其嵌入model中,一个是在Dataset数据集中进行数据增强

方式一:嵌入model中
调用方式如下

# tf.keras.layers.experimental.preprocessing图像增强 第一个层表示进行随机的水平和垂直翻转,而第二个层表示按照 0.2 的弧度值进行随机旋转。
data_augmentation = tf.keras.Sequential([
  tf.keras.layers.experimental.preprocessing.RandomFlip("horizontal_and_vertical",input_shape=(img_height, img_width, 3)),
  tf.keras.layers.experimental.preprocessing.RandomRotation(0.2),
])
model = tf.keras.Sequential([
  data_augmentation,
  layers.Conv2D(16, 3, padding='same', activation='relu'),
  layers.MaxPooling2D(),
])
# 图像增强 可视化效果图
for images, labels in train_ds.take(1):
    # Add the image to a batch.
    image = tf.expand_dims(images[0], 0)
    plt.figure(figsize=(8, 8))
    for i in range(9):
        augmented_image = data_augmentation(image)
        ax = plt.subplot(3, 3, i + 1)
        plt.imshow(augmented_image[0])
        plt.axis("off")
    plt.show()
    break

本文案例使用如下

data_augmentation = tf.keras.Sequential([
  tf.keras.layers.experimental.preprocessing.RandomFlip("horizontal_and_vertical",input_shape=(img_height, img_width, 3)),
  tf.keras.layers.experimental.preprocessing.RandomRotation(0.2),
])
#方式一图像增强:tf.keras.layers.experimental.preprocessing方式实现的图像增强,嵌入模型中
#只有在模型训练时(Model.fit)才会进行增强,在模型评估(Model.evaluate)以及预测(Model.predict)时并不会进行增强操作
def VGG16_aug0(class_names, img_height, img_width):
    model = models.Sequential([
        data_augmentation,
        # 1
        layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same',
                      input_shape=(img_height, img_width, 3)),
        layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 2
        layers.Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 3
        layers.Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 4
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # 5
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same'),
        layers.MaxPool2D(pool_size=(2, 2), strides=2),
        # FC
        layers.Flatten(),
        layers.Dense(4096, activation='relu'),
        layers.Dense(4096, activation='relu'),
        layers.Dense(len(class_names), activation='softmax')
      ])
    return model
model = VGG16_aug0(class_names, img_height, img_width) # 方式一图像增强
model.summary()

# 图像增强 可视化效果图
for images, labels in train_ds.take(1):
    # Add the image to a batch.
    image = tf.expand_dims(images[0], 0)
    plt.figure(figsize=(8, 8))
    for i in range(9):
        augmented_image = data_augmentation(image)
        ax = plt.subplot(3, 3, i + 1)
        plt.imshow(augmented_image[0])
        plt.axis("off")
    plt.show()
    break

在这里插入图片描述

在这里插入图片描述

方式二:在Dataset数据集中进行数据增强
本文案例使用如下

#方式二图像增强:tf.keras.layers.experimental.preprocessing方式实现的图像增强.在Dataset数据集中进行数据增强
AUTOTUNE = tf.data.AUTOTUNE

def prepare(ds):
    ds = ds.map(lambda x, y: (data_augmentation(x, training=True), y), num_parallel_calls=AUTOTUNE)
    return ds
train_ds1 = prepare(train_ds)

'''训练模型'''
epochs = 20
history = model.fit(
    train_ds1,
    validation_data=val_ds,
    epochs=epochs    
)

在这里插入图片描述
本文试验效果并不理想

1.1.2 使用 tf.image 进行数据增强

使用 tf.image 是 TensorFlow 最原生的一种增强方式,使用这种方式可以实现更多、更加个性化的数据增强。

其中包含的数据增强方式主要包括:

tf.image.flip_left_right (img):将图片进行水平翻转;
tf.image.rgb_to_grayscale (img):将 RGB 图像转化为灰度图像;
tf.image.adjust_saturation (image, f):将 image 图像按照 f 参数进行饱和度的调节;
tf.image.adjust_brightness (image, f):将 image 图像按照 f 参数进行亮度的调节;
tf.image.central_crop (image, central_fraction):按照 p 的比例进行图片的中心裁剪,比如如果 p 是 0.5 ,那么裁剪后的长、宽就是原来图像的一半;
tf.image.rot90 (image):将 image 图像逆时针旋转 90 度。
可以看到,很多的 tf.image 数据增强方式并不提供随机化选项,因此我们需要手动进行随机化。

也正是因为上述特性,tf.image 数据增强主要用在一些自定义的模型之中,从而可以实现数据增强的自定义化。

参考链接在 TensorFlow 之中进行数据增强

1.2自定义增强函数

import random
# 这是大家可以自由发挥的一个地方
def aug_img(image,label):
    seed = (random.randint(0, 9), 0)
    # 随机改变图像对比度
    stateless_random_brightness = tf.image.stateless_random_contrast(image, lower=0.1, upper=1.0, seed=seed)
    return stateless_random_brightness,label
train_ds2 = train_ds.map(aug_img, num_parallel_calls=AUTOTUNE)

# 图像增强 可视化效果图
for images, labels in train_ds.take(1):
    # Add the image to a batch.
    image = tf.expand_dims(images[0], 0)
    plt.figure(figsize=(8, 8))
    for i in range(9):
        augmented_image = aug_img(image)
        ax = plt.subplot(3, 3, i + 1)
        # plt.imshow(augmented_image[0].numpy().astype("uint8"))
        plt.imshow(augmented_image[0][0])
        plt.axis("off")
    plt.show()
    break

在这里插入图片描述
在这里插入图片描述
效果也不是很理想,知道调用方法就行,针对不同案例实现图像增强

1.3 图像增强数据与原始数据合并作为新样本

操作步骤如下:

  • 读取原始数据并图像增强
  • 保存增强效果图
  • 将原始数据与新生成的增强数据一起符号链接到新目录

读取原始数据并图像增强,保存增强效果图

from pathlib import Path
import cv2
import matplotlib.pyplot as plt
import warnings

warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印
def saveaugimg(imgfile,newdir,prefix="aug_"):

    # cv2保存中文路径的图像
    imgFile = imgfile  # 读取文件的路径
    img = cv2.imread(imgFile, flags=1)  # flags=1 读取彩色图像(BGR)
    img1 = cv2.flip(img, 2)  # 水平翻转
    img2 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
    # plt.imshow(img2)
    # plt.show()
    saveFile = imgfile.replace(r"D:\DeepLearning\data\CatDog", newdir)  # 带有中文的保存文件路径
    newname=prefix+str(Path(imgfile).name)
    saveFile = Path(saveFile).parent / newname
    Path(saveFile).parent.mkdir(parents=True, exist_ok=True)  # 创建新文件夹
    # cv2.imwrite(saveFile, img)  # imwrite 不支持中文路径和文件名,读取失败,但不会报错!
    img_write = cv2.imencode(".jpg", img1)[1].tofile(saveFile)

dirs=r"D:\DeepLearning\data\CatDog"
newdir = r"D:\DeepLearning\data\CatDog_aug"
for p in Path(dirs).rglob("*"):
    if p.is_file():  # 如果是文件
        imgfile=str(p)
        saveaugimg(imgfile, newdir)

将原始数据与新生成的增强数据一起符号链接到新目录

from pathlib import Path


# 对目录dirs做符号链接
def createslinkbatfile(dirs, slinkdirs, batfile="slink.bat"):
    print(f"为{dirs}创建符号链接目录{slinkdirs}\n")
    # 创建符号链接目录
    Path(slinkdirs).mkdir(parents=True, exist_ok=True)

    # 创建bat文件,为了解决bat脚本中文输出乱码问题,
    # 我们需要在bat脚本开头添加chcp 65001来设置控制台编码格式为UTF-8。
    # 同时,我们还需要使用setlocal enabledelayedexpansion启用延迟变量扩展
    with open(batfile, 'a', encoding='utf-8') as file:
        file.write("@echo off\nchcp 65001\nsetlocal enabledelayedexpansion " + '\n')

    # 遍历目标目录下的文件夹及文件,创建符号链接cmd命令
    for p in Path(dirs).rglob("*"):
        slink = Path(str(p).replace(str(dirs), str(slinkdirs)))  # 替换符号链接文件夹目录
        if p.is_dir():  # 目录符号链接
            command = f"mklink /d \"{slink}\" \"{str(p)}\""
        else:  # 文件符号链接
            command = f"mklink \"{slink}\" \"{str(p)}\""

        # 将符号链接cmd命令写入bat文件
        with open(batfile, 'a', encoding='utf-8') as file:
            # 增加编码encoding='utf-8',解决中文乱码问题解决方法
            file.write(command + '\n')
            print(command)


# 对目录dirs做符号链接,生成后右击bat文件,选用管理员身份运行

Path("slink.bat").unlink(missing_ok=False)# 删除bat文件
dirs=r"D:\DeepLearning\data\CatDog"
newdirs = r"D:\DeepLearning\data\CatDog_aug"
slinkdirs = r"D:\DeepLearning\data\CatDog_all"
createslinkbatfile(dirs, slinkdirs)
createslinkbatfile(newdirs, slinkdirs)

部分bat内容同如下

@echo off
chcp 65001
setlocal enabledelayedexpansion 
mklink /d "D:\DeepLearning\data\CatDog_all\cat" "D:\DeepLearning\data\CatDog\cat"
mklink /d "D:\DeepLearning\data\CatDog_all\dog" "D:\DeepLearning\data\CatDog\dog"
mklink "D:\DeepLearning\data\CatDog_all\cat\flickr_cat_000002.jpg" "D:\DeepLearning\data\CatDog\cat\flickr_cat_000002.jpg"
mklink "D:\DeepLearning\data\CatDog_all\cat\flickr_cat_000003.jpg" "D:\DeepLearning\data\CatDog\cat\flickr_cat_000003.jpg"
mklink "D:\DeepLearning\data\CatDog_all\cat\flickr_cat_000004.jpg" "D:\DeepLearning\data\CatDog\cat\flickr_cat_000004.jpg"
mklink "D:\DeepLearning\data\CatDog_all\cat\flickr_cat_000005.jpg" "D:\DeepLearning\data\CatDog\cat\flickr_cat_000005.jpg"

tf.keras.preprocessing.image_dataset_from_directory()传入新的文件夹目录

data_dir1 = r"D:\DeepLearning\data\CatDog_all"  # 将自定义数据增强后的数据保存后,与原始数据一起合并加入样本中
data_dir = Path(data_dir1)

在这里插入图片描述

总结

通过本次的学习,学习到了几种图像增强调用方式,原文中增强方式均为增强数据替代原始数据加入训练集,本文加入将增强数据与原始数据一起合并作为样本的方法,本文中的增强方式加入案例,效果并没有很理想,跟数据集实际情况有关,可将本文提到的图像增强方式运用到其他案例中。

深度学习在托卡马克磁约束控制中的实时应用 托卡马克磁约束控制是高维非线性动态系统控制的典型代表,其核心挑战在于毫秒级响应、强耦合、模型失配与突发失稳(如ELM、破裂)并存。传统PID与模型预测控制(MPC)因物理建模偏差大、计算延迟高而难以胜任。深度学习凭借端到端时序建模能力,可直接从多源传感器数据中学习‘状态→线圈指令’映射关系,天然适配等离子体演化前兆识别与残差补偿需求。该技术已实现在EAST装置上37%放电时长提升与89% ELM抑制率,具备向高能加速器、柔性电网、等离子体工艺设备等强实时物理系统迁移的价值。 阅读详情

相关推荐

星载AI实战:深空探测中的轻量化深度学习与自主导航

深度学习正从地面服务器走向深空探测器,其核心已非算法创新,而是如何在极端物理约束下实现可靠部署。在通信延迟、辐射环境、功耗内存严苛限制下,星载AI必须依托模型轻量化、INT8量化感知训练、FPGA/ASIC异构加速及物理驱动的合成数据构建等关键技术,支撑地形可通行性评估、科学目标识别与异常自主响应等实时任务。本文聚焦火星探测场景,系统解析遥感解译、自主导航闭环与抗辐照加固等工程实践,为航天嵌入式AI研发提供可复用的技术路径和验证范式。

676

Keras中的数据增强

深度网络需要大量的训练数据才能达到良好的性能。为了用很少的训练数据构建强大的图像分类器,通常需要图像增强来提高深度网络的性能。图像增强通过不同的处理方式或多种处理的组合,如随机旋转、平移、剪切、翻转等,人工生成训练图像。 在Keras中使用imagedatgenerator生成增强图像 使用对比度拉伸,直方图均衡化,自适应直方图均衡化生成自定义增强图像 利用图像增强技术在CIFAR-10数据集上训练卷积神经网络 1.导入相关库 from __future__ import print_function

weixin_43229348的博客 2528

【博弈论】势博弈(potential game)、EPG以及最佳响应、Nash均衡和帕累托(pareto)最优的理解

文章目录前言一、Potential game二、Nash均衡和Pareto-optimal(帕累托最优)1.Nash 均衡2.Pareto最优三、Best response(最佳响应)四、Exact potential game(EPG)1.合作-傀儡博弈2.合作博弈3.傀儡博弈4.自激博弈5.双边对称交互博弈使用理解 前言 本文主要详细讲解potential game的概念以及Exact potential game 的定义和分类,以及这么博弈方法是如何在论文中引入并使用的,本文仅是对自己在该模块

weixin_44535200的博客 2万+

人工智能--Keras数据加载与增强

Keras图像数据加载和增强的方法

看,好自为之的博客!!! 1604

Python抓取摄像头图像,进行AI识别(一)

本文介绍了如何用Python获取海康威视摄像头的图像并进行AI识别。主要内容包括:1)准备工作,包括摄像头IP设置和密码重置方法;2)使用Python的Requests库通过ISAPI接口获取实时图像;3)示例代码展示如何保存摄像头图像。整个过程为后续AI图像识别提供了基础,通过简单的Python代码即可实现专业监控设备的图像采集功能。

Hahafantuan的博客 1517

在AutoDL的A100云服务器上,用Docker搞定Sapien+RobotWin环境(附完整conda list)

本文详细介绍了在AutoDL的A100云服务器上使用Docker构建Sapien+RobotWin环境的完整指南。通过配置Vulkan渲染管线、精确复现Conda环境以及解决常见问题,帮助研究人员高效搭建稳定的机器人仿真开发环境,特别适合需要高性能GPU加速的复杂仿真任务。

weixin_30689307的博客 434

keras_cv进行数据增强

使用tensorflow的keras_cv库进行分类数据增强

dddeee的专栏 1767

使用Typora时LaTeX内联公式简单汇总

0、前言 在使用Typora写笔记时,有时候需要添加上LaTeX排版的公式。以下是整理出的一份简单笔记,方便记忆不清楚时查阅。笔记暂时不够完善,之后再补充。 注:有些公式语法KateX不能解析,但在Typora中可以使用(不用在意) 1、一些基本内联公式 位置关系 展示 LaTeX 说明 x2x^{2}x2 x^{2} 右上标 x2x_{2}x2​ x_{2} 右下标 2x{}^{2}x2x {}^{2}x 左上标 2x{}_{2}x2​x {}_{2}x 左下标

白白旧维的博客 4446

Keras之数据增强

为了尽量利用我们有限的训练数据,我们将通过一系列随机变换对数据进行提升,这样我们的模型将看不到任何两张完全相同的图片,这有利于我们抑制过拟合,使得模型的泛化能力更好。 在Keras中,这个步骤可以通过keras.preprocessing.image.ImageDataGenerator来实现,这个类使你可以: 在训练过程中,设置要实行的随机变换 通过.flow或.flo...

王猛的专栏 7045

告别重打包:在Android 9上实现免Root的Frida-Gadget持久化Hook(附AOSP源码修改详解)

本文详细介绍了在Android 9上实现免Root的Frida-Gadget持久化Hook技术方案。通过修改AOSP源码,绕过传统重打包方式面临的签名校验和完整性检查,实现在非Root环境下的系统级Hook。文章包含核心代码修改、编译配置调整及调试技巧,为移动安全研究提供高效稳定的解决方案。

weixin_33726313的博客 501

PaddleOCR实战:DBnet++与DBnet模型训练全流程解析

本文详细解析了基于PaddleOCR框架的DBnet与DBnet++文字检测模型的完整训练流程。从环境配置、数据集准备、配置文件解读,到模型训练、评估调参及最终推理部署,提供了实战指南。重点对比了DBnet++与DBnet在精度、速度及适用场景上的差异,帮助开发者高效构建定制化的OCR检测模型。

weixin_29038155的博客 336

数据增强系列(2)如何使用Augly库进行数据增强

在机器学习和深度学习中,拥有更多数据对于帮助您从模型中获得良好性能非常重要。您可以使用称为数据增强 的技术来创建更多数据。数据增强是从业者用来通过从现有数据创建修改后的数据来增加数据的技术。 如果您的项目数据集很小,或者您想减少 ML 或深度学习 (DL) 模型中的过度拟合,那么使用数据增强技术是一种很好的做法。 在本文中,您将学习如何使用来自 Facebook 的名为Augly的新开源库来执行数据增强。 1. 什么是Augly? AugLy 是一个数据增强库,可以帮助您评估和提高模型的稳健性。该库支持四种

weixin_43229348的博客 1635

麒麟V10 x86_64系统下Qt 5.12.7安装全攻略(附常见报错解决方案)

本文详细介绍了在麒麟V10 x86_64系统上安装Qt 5.12.7的完整流程,包括在线和离线两种安装方案,并提供了常见报错的解决方案。从环境准备到项目配置优化,再到高级调试技巧,全面覆盖Qt开发在国产操作系统上的实践要点,帮助开发者高效搭建开发环境。

weixin_29294395的博客 511

深度学习-学习笔记 DAY-2(线性模型)

引入Do-Calculus框架区分相关与因果关系,避免如"除夕效应"的误判。验证损失从440改善到410,证明深度网络需要特殊结构保障信息流动。类比物体运动惯性,实验显示加入动量后收敛迭代次数减少40%发现T-1、T-7、T-28天特征贡献度占整体70%但56天特征未带来提升,说明信息增益存在边际效应。在3层网络上应用后,验证损失从380降低到350。7天周期特征的引入使MAE从580降低到490。验证集综合指标提升22%,计算代价增加35%使训练数据量扩大2倍,验证MAE提升5%

gezijian20040315的博客 961

基于YOLOv8的MVTec AD缺陷检测系统设计与实现

速度快,精度高;支持 anchor-free 架构;支持实例分割和图像分类;模块化代码,易于部署与改进;完美兼容 ONNX、TensorRT 等推理框架;官方支持多平台训练和推理(CPU/GPU)。YOLOv8 是工业视觉检测落地非常理想的选择。MVTec AD(Anomaly Detection)数据集包括15类工业对象,每个对象包括多个子类缺陷(例如 “scratch”, “crack”, “hole”)及正常图像。类别缺陷子类bottlecablecapsule。

YOLO 932

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Day11 深度学习与特征

本文系统梳理了深度学习模型分类与特征,涵盖CNN、RNN、Transformer等7类主流模型的核心特性及应用场景。重点分析了无监督学习方法,包括对比学习(Simsaim)、生成对抗网络(Cycle-GAN)和自编码器等技术原理,强调通过数据重构/生成任务实现特征学习。特别指出无监督预训练(如GPT)作为上游任务的价值,以及对比学习在小样本场景的优势。最后解析自编码器通过"编码-解码"架构实现特征分离与降维的机制,展现了无监督学习在特征提取方面的强大潜力。(149字)

liuan957的博客 1112

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

还没跑通第一个模型?看完这个 Day 4 实录你就懂了!

​今天是机器学习算法打卡的Day 7。​在前几天的学习中,我一直在啃 CNN(卷积神经网络)的理论,什么卷积核、池化层、全连接层,听起来都很高大上,但不动手写代码,永远不知道坑在哪里。不仅要写代码,还要把模型真正“跑”起来,并看到可视化的结果。​我的项目课题是**《基于数据增强 CNN 的轴承故障诊断系统》**。作为一个计算机专业的学生,能看着终端里的 Accuracy(准确率)一行行上涨,那种多巴胺分泌的感觉,真的比打游戏还爽!​✅ 熟练使用 Conda 管理环境。

2501_93948918的博客 520

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Python训练营打卡Day41

Flatten -> Dense (with Dropout,可选) -> Dense (Output)1. 输入 → 卷积层 → Batch归一化层(可选) → 池化层 → 激活函数 → 下一层。尝试手动修改下不同的调度器和CNN的结构,观察训练的差异。batch归一化:调整一个批次的分布,常用与图像数据。特征图:只有卷积操作输出的才叫特征图。调度器:直接修改基础学习率。卷积神经网络定义的写法。

y10212104的博客 167

【Python打卡Day48】随机张量与广播机制@浙大疏锦行

在继续讲解模块消融前,先补充几个之前没提的基础概念尤其需要搞懂张量的维度、以及计算后的维度,这对于你未来理解复杂的网络至关重要。

m0_74766454的博客 1034

Pytorch学习Day04[连载]

Transform专场——图像增强一、transforms——变换1、Crop(裁剪)1)CenterCrop2)RandomCrop3)RandomResizedCrop4)FiveCrop5)TenCrop2、Flip(翻转)1)Horizontal Flip2)Vertical Flip3)RandomRotation3、Pad(填充)4、ColorJitter(图像颜色调整)5、Grays...

sinat_38213499的博客 326

Day44 简单CNN

【代码】Day44 简单CNN。

2401_84698961的博客 199

python打卡day41@浙大疏锦行

2. Flatten -> Dense (with Dropout,可选) -> Dense (Output)- 大通道数 (如64/128):模型容量大,但计算量高,需注意过拟合。作业:尝试手动修改下不同的调度器和CNN的结构,观察训练的差异。- 小通道数 (如32/64):训练快、显存占用低,但可能欠拟合。- 不带BN层 :对初始化敏感,适合小批量数据。- Swish :梯度更平滑,适合深层网络。- Cosine :平滑调整,适合连续训练。- 带BN层 :训练稳定,允许更大学习率。

2301_82134064的博客 316

Python打卡 DAY 51 复习实践:提升自定义数据集CNN模型性能

使用TensorBoard/PyTorch Lightning记录实验。可视化注意力热图分析CBAM效果。:使用ResNet等作为基础。增加/减少数据增强强度。调整Dropout比率。调整CBAM插入位置。

2301_76970300的博客 738

深度学习在视网膜病变检测中的技术实践与优化

深度学习技术在医学影像分析领域展现出巨大潜力,特别是在视网膜病变检测中。通过卷积神经网络(CNN)和生成对抗网络(GAN)等先进算法,可以有效识别微动脉瘤等微小病变特征。技术实现上,采用自适应归一化处理多源设备差异,结合小样本增强策略解决数据不均衡问题。在医疗AI系统中,模型轻量化和TensorRT加速显著提升推理效率,使基层医院部署成为可能。典型应用场景包括糖尿病视网膜病变(DR)和年龄相关性黄斑变性(AMD)的早期筛查,其中EfficientNet等架构在灵敏度与特异性指标上已接近医生水平。当前技术突破

weixin_33744854的博客 431

图像分类学习笔记DAY04

柠檬分类实战 思考并动手进行调优,以在验证集上的准确率为评价指标,验证集上准确率越高,得分越高! 思考:数据本身已进行了数据增强,所以可以从其他方面入手来实现提高准确率。本文通过修改定义Adam优化器以及batch_size(从32改为128)提高了准确率。因为效果比较好,所以没有对网络模型进行优化。模型的优化也是一个重要的方面。 # 导入所需要的库 from sklearn.utils import shuffle import os import pandas as pd import numpy as

sunniness_7的博客 306

python训练营day44

尝试在cifar10对比如下其他的预训练模型,观察差异,尽可能和他人选择的不同。尝试通过ctrl进入resnet的内部,观察残差究竟是什么。预训练代码实战:resnet18。图像预训练模型的发展史。常见的分类预训练模型。

2202_75296561的博客 299
上一篇: 深度学习 Day9——T9猫狗识别2
下一篇: 深度学习 Day11——T11优化器对比实验
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值