• CNN入门实战：猫狗分类

    前言

            CNN（Convolutional Neural Network，卷积神经网络）是一种深度学习模型，特别适用于处理图像数据。它通过多层卷积和池化层来提取图像的特征，并通过全连接层进行分类或回归等任务。CNN在图像识别、目标检测、图像分割等领域取得了很大的成功。

    CNN网络结构

            目标分类是指识别图像中的物体，并将其归类到不同的类别中。例如，猫狗分类就是一个目标分类的任务，CNN可以帮助我们构建一个模型来自动识别图像中的猫和狗。

    如何入门CNN

    要入门CNN，可以先了解深度学习的基本概念和原理，然后学习如何构建和训练CNN模型。可以选择一些经典的教材、在线课程或者教程来学习深度学习和CNN的基础知识。

    实战案例分析

    以下是一个简单的使用PyTorch构建CNN模型的示例代码：

    1、导包

    1. from PIL import Image
    2. import torch
    3. import torchvision.transforms as transforms
    4. from torch.utils.data import DataLoader,  random_split, Dataset
    5. from torchvision import datasets, models
    6.  
    7. import torch.nn as nn 
    8. import torch.nn.functional as F
    9. import torch.optim as optim 
    10.  
    11. import numpy as np 
    12. import pandas as pd 
    13. import matplotlib.pyplot as plt
    14. import os
    15. from tqdm import tqdm

    2、设置数据集目录

    1. # Setting the data directories/ paths
    2.  
    3. data_pth = '/你的数据集目录'
    4. cats_dir = data_pth + '/Cat'
    5. dogs_dir = data_pth + '/Dog'

    3、打印图像的数量

    1. print("Total Cats Images:", len(os.listdir(cats_dir)))
    2. print("Total Dogs Images:", len(os.listdir(dogs_dir)))
    3. print("Total Images:", len(os.listdir(cats_dir)) + len(os.listdir(dogs_dir)))

    4、查看Cat数据

    1. cat_img = Image.open(cats_dir + '/'  + os.listdir(cats_dir)[0])
    2.  
    3. print('Shape of cat image:', cat_img.size)
    4. cat_img

    5、查看Dog的数据

    1. dog_img = Image.open(dogs_dir + '/'  + os.listdir(dogs_dir)[0])
    2.  
    3. print('Shape of dog image:', dog_img.size)
    4. dog_img

    6、自定义加载数据集方法

    1. class CustomDataset(Dataset):
    2.     def __init__(self, data_path, transform=None):
    3.         # Initialize your dataset here
    4.         self.data = data
    5.         self.transform = transform
    6.  
    7.     def __len__(self):
    8.         # Return the number of samples in your dataset
    9.         return len(self.data)
    10.  
    11.     def __getitem__(self, idx):
    12.         # Implement how to get a sample at the given index
    13.         sample = self.data[idx]
    14.         
    15.         try:
    16.             img = Image.open(data_pth + '/Cat/' + sample)
    17.             label = 0
    18.             
    19.         except:
    20.             img = Image.open(data_pth + '/Dog/' + sample)
    21.             label = 1
    22.  
    23.         # Apply any transformations (e.g., preprocessing)
    24.         
    25.         if self.transform:
    26.             img = self.transform(img)
    27.  
    28.         return img, label

    7、定义数据转换（调整大小、规格化、转换为张量等）

    在训练目标分类模型时，我们通常会使用转换数据来对输入数据进行预处理，以便更好地适应模型的训练和提高模型的性能。

    使用转换数据的原因包括：

    1. 调整大小：输入数据通常具有不同的尺寸和分辨率，为了确保模型能够处理这些不同尺寸的数据，我们需要将其调整为统一的大小。这样可以确保模型在训练和预测时能够处理相同大小的输入数据。

    2. 规格化：规格化是指将输入数据的数值范围调整到相似的范围，以便更好地适应模型的训练。规格化可以帮助模型更快地收敛，提高模型的稳定性和准确性。

    3. 转换为张量：在深度学习中，输入数据通常需要转换为张量形式，以便与神经网络模型进行计算。因此，我们需要将输入数据转换为张量形式，以便能够输入到模型中进行训练和预测。

    总之，转换数据是为了确保模型能够更好地适应输入数据，并提高模型的性能和准确性。通过调整大小、规格化和转换为张量等操作，我们可以更好地准备输入数据，使其更适合用于训练目标分类模型。

    1. # Define the data transformation (resize, normalize, convert to tensor, etc.)
    2.     
    3. transform = transforms.Compose([
    4.     transforms.Resize((224, 224)),  # Resize images to a fixed size (adjust as needed)
    5.     transforms.Grayscale(num_output_channels=1),
    6.     transforms.ToTensor(),           # Convert images to PyTorch tensors
    7. ])
    8.  
    9. data = [i for i in os.listdir(data_pth + '/Cat') if i.endswith('.jpg')] + [i for i in os.listdir(data_pth + '/Dog') if i.endswith('.jpg')]
    10.  
    11. combined_dataset = CustomDataset(data_path=data, transform=transform)
    12. #dataloader = torch.utils.data.DataLoader(custom_dataset, batch_size=64, shuffle=False)

    8、定义拆分比例（例如，80%用于培训，20%用于测试）

    1. # Define the ratio for splitting (e.g., 80% for training, 20% for testing)
    2. train_ratio = 0.8
    3. test_ratio = 1.0 - train_ratio
    4.  
    5. # Calculate the number of samples for training and testing
    6. num_samples = len(combined_dataset)
    7. num_train_samples = int(train_ratio * num_samples)
    8. num_test_samples = num_samples - num_train_samples
    9.  
    10. # Use random_split to split the dataset
    11. train_dataset, test_dataset = random_split(combined_dataset, [num_train_samples, num_test_samples])
    12.  
    13. # Create data loaders for training and testing datasets
    14. batch_size = 32
    15. train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=False)
    16. test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

    9、自定义CNN模型

    1. # Define the CNN model
    2. class CNN(nn.Module):
    3.     def __init__(self):
    4.         super(CNN, self).__init__()
    5.         self.conv = nn.Sequential(
    6.             nn.Conv2d(1, 8, kernel_size=3, stride=2),
    7.             nn.MaxPool2d(2, 2),
    8.             nn.ReLU(),
    9.  
    10.             nn.Conv2d(8, 16, kernel_size=3, stride=2),
    11.             nn.MaxPool2d(2, 2),
    12.             nn.ReLU(),
    13.  
    14.             nn.Conv2d(16, 32, kernel_size=3, stride=2),
    15.             nn.MaxPool2d(2, 2),
    16.             nn.ReLU(),
    17.         )
    18.  
    19.         self.fc = nn.Sequential(
    20.             nn.Flatten(),
    21.             nn.Linear(288, 128),
    22.             nn.ReLU(),
    23.             nn.Linear(128, 1),
    24.             nn.Sigmoid()
    25.         )
    26.  
    27.     def forward(self, x):
    28.         x = self.conv(x)
    29.         x = self.fc(x)
    30.  
    31.         return x

    10、GPU是否可用

    1. # check if gpu is available or not
    2.  
    3. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    4. print(device)

    11、初始化模型、损失函数和优化器

         训练过程中的关键步骤，其重要性如下：

    1. 初始化模型：模型的初始化是指对模型参数进行初始赋值。正确的初始化可以加速模型的收敛，提高训练的效率和稳定性。如果模型参数的初始值过大或过小，可能会导致梯度爆炸或梯度消失，从而影响模型的训练效果。

    2. 损失函数：损失函数是用来衡量模型预测结果与真实标签之间的差距。选择合适的损失函数可以帮助模型更好地学习数据的特征，并且在训练过程中不断优化模型参数，使得损失函数值逐渐减小。

    3. 优化器：优化器是用来更新模型参数的算法，常见的优化器包括随机梯度下降（SGD）、Adam、RMSprop等。选择合适的优化器可以加速模型的收敛，提高训练的效率和稳定性。不同的优化器有不同的更新规则，可以根据具体的任务和数据特点选择合适的优化器。

    因此，初始化模型、损失函数和优化器是CNN训练过程中的关键步骤，它们的选择和设置会直接影响模型的训练效果和性能。

    1. # Initialize the model, loss function, and optimizer
    2. net = CNN().to(device)
    3. criterion = nn.BCELoss()
    4. optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

    12 、开始训练数据

    1. epochs = 5
    2. net.train()
    3. for epoch in range(epochs):
    4.     running_loss = 0.0
    5.     for idx, (inputs, labels) in tqdm(enumerate(train_loader), total=len(train_loader)):
    6.  
    7.         inputs = inputs.to(device)
    8.         labels = labels.to(device).to(torch.float32)
    9.  
    10.         optimizer.zero_grad()
    11.  
    12.         outputs = net(inputs).reshape(-1)
    13.         loss = criterion(outputs, labels)
    14.         loss.backward()
    15.         optimizer.step()
    16.  
    17.         running_loss += loss.item()
    18.  
    19.     print(f'Epoch: {epoch + 1}, Loss: {running_loss}')
    20.  
    21. print('Training Finished!')

    13、验证数据

    1. net.eval()  # Set the model to evaluation mode
    2. correct = 0
    3. total = 0
    4.  
    5. with torch.no_grad():
    6.     for idx, (inputs, labels) in tqdm(enumerate(test_loader), total=len(test_loader)):
    7.         inputs = inputs.to(device)
    8.         labels = labels.to(device).to(torch.float32)
    9.  
    10.         outputs = net(inputs).reshape(-1)
    11.         predicted = (outputs > 0.5).float()  # Assuming a binary classification threshold of 0.5
    12.  
    13.         correct += (predicted == labels).sum().item()
    14.         total += labels.size(0)
    15.  
    16. accuracy = correct / total if total > 0 else 0.0
    17. print(f'Test Accuracy: {accuracy:.2%}')

    14、测试数据

    1. label_names = ['cat', 'dog']
    2. fig, ax = plt.subplots(1, 5, figsize=(15, 5))
    3. outputs = outputs.cpu()
    4. inputs = inputs.cpu()
    5. labels = labels.cpu()
    6.  
    7. for i in range(5):
    8.     ax[i].imshow(inputs[i].permute(1,2,0))
    9.     ax[i].set_title(f'True: {label_names[labels[i].to(int)]}, Pred: {label_names[torch.where(outputs[i] > 0.5, 1, 0).item()]}')
    10.     ax[i].axis(False)
    11.  
    12. plt.show()

    至此，一个CNN训练模型从搭建到测试的完整实现过程就完成了，我们使用了PyTorch构建了一个简单的CNN模型，并使用猫狗分类的训练数据对模型进行训练。首先准备了训练数据集，然后构建了一个简单的CNN模型，定义了损失函数和优化器，最后进行了模型的训练。

    数据集训练完整代码

    1. from PIL import Image
    2. import torch
    3. import torchvision.transforms as transforms
    4. from torch.utils.data import DataLoader,  random_split, Dataset
    5. from torchvision import datasets, models
    6.  
    7. import torch.nn as nn 
    8. import torch.nn.functional as F
    9. import torch.optim as optim 
    10.  
    11. import numpy as np 
    12. import pandas as pd 
    13. import matplotlib.pyplot as plt
    14. import os
    15. from tqdm import tqdm
    16.  
    17.  
    18.  
    19. data_pth = '/你的数据集目录'
    20. cats_dir = data_pth + '/Cat'
    21. dogs_dir = data_pth + '/Dog'
    22.  
    23. cat_img = Image.open(cats_dir + '/'  + os.listdir(cats_dir)[0])
    24. dog_img = Image.open(dogs_dir + '/'  + os.listdir(dogs_dir)[0])
    25.  
    26. #定义加载数据集方法
    27. class CustomDataset(Dataset):
    28.     def __init__(self, data_path, transform=None):
    29.         # Initialize your dataset here
    30.         self.data = data
    31.         self.transform = transform
    32.  
    33.     def __len__(self):
    34.         # 返回数据集数量
    35.         return len(self.data)
    36.  
    37.     def __getitem__(self, idx):
    38.         # 获取数据集对应的下标
    39.         sample = self.data[idx]
    40.         
    41.         try:
    42.             img = Image.open(data_pth + '/Cat/' + sample)
    43.             label = 0
    44.             
    45.         except:
    46.             img = Image.open(data_pth + '/Dog/' + sample)
    47.             label = 1
    48.  
    49.        
    50.         if self.transform:
    51.             img = self.transform(img)
    52.  
    53.         return img, label
    54.  
    55. transform = transforms.Compose([
    56.     transforms.Resize((224, 224)),  # Resize images to a fixed size (adjust as needed)
    57.     transforms.Grayscale(num_output_channels=1),
    58.     transforms.ToTensor(),           # Convert images to PyTorch tensors
    59. ])
    60.  
    61. data = [i for i in os.listdir(data_pth + '/Cat') if i.endswith('.jpg')] + [i for i in os.listdir(data_pth + '/Dog') if i.endswith('.jpg')]
    62.  
    63. combined_dataset = CustomDataset(data_path=data, transform=transform)
    64.  
    65.  
    66. #划分数据集
    67. train_ratio = 0.8
    68. test_ratio = 1.0 - train_ratio
    69.  
    70. # Calculate the number of samples for training and testing
    71. num_samples = len(combined_dataset)
    72. num_train_samples = int(train_ratio * num_samples)
    73. num_test_samples = num_samples - num_train_samples
    74.  
    75. # Use random_split to split the dataset
    76. train_dataset, test_dataset = random_split(combined_dataset, [num_train_samples, num_test_samples])
    77.  
    78. # Create data loaders for training and testing datasets
    79. batch_size = 32
    80. train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=False)
    81. test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
    82.  
    83.  
    84. #自定义CNN模型
    85. class CNN(nn.Module):
    86.     def __init__(self):
    87.         super(CNN, self).__init__()
    88.         self.conv = nn.Sequential(
    89.             nn.Conv2d(1, 8, kernel_size=3, stride=2),
    90.             nn.MaxPool2d(2, 2),
    91.             nn.ReLU(),
    92.  
    93.             nn.Conv2d(8, 16, kernel_size=3, stride=2),
    94.             nn.MaxPool2d(2, 2),
    95.             nn.ReLU(),
    96.  
    97.             nn.Conv2d(16, 32, kernel_size=3, stride=2),
    98.             nn.MaxPool2d(2, 2),
    99.             nn.ReLU(),
    100.         )
    101.  
    102.         self.fc = nn.Sequential(
    103.             nn.Flatten(),
    104.             nn.Linear(288, 128),
    105.             nn.ReLU(),
    106.             nn.Linear(128, 1),
    107.             nn.Sigmoid()
    108.         )
    109.  
    110.     def forward(self, x):
    111.         x = self.conv(x)
    112.         x = self.fc(x)
    113.  
    114.         return x
    115.  
    116. #GPU是否可用
    117. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    118.  
    119. #初始化模型、损失函数和优化器
    120. net = CNN().to(device)
    121. criterion = nn.BCELoss()
    122. optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    123.  
    124. #开始训练
    125. epochs = 5
    126. net.train()
    127. for epoch in range(epochs):
    128.     running_loss = 0.0
    129.     for idx, (inputs, labels) in tqdm(enumerate(train_loader), total=len(train_loader)):
    130.  
    131.         inputs = inputs.to(device)
    132.         labels = labels.to(device).to(torch.float32)
    133.  
    134.         optimizer.zero_grad()
    135.  
    136.         outputs = net(inputs).reshape(-1)
    137.         loss = criterion(outputs, labels)
    138.         loss.backward()
    139.         optimizer.step()
    140.  
    141.         running_loss += loss.item()
    142.  
    143.     print(f'Epoch: {epoch + 1}, Loss: {running_loss}')
    144.  
    145. print('Training Finished!')

    数据集下载

    百度网盘：https://pan.baidu.com/s/1CjTNLGvBBDxmKEADN3SNWw?pwd=o37e 
    提取码：o37e

  • 相关阅读:
    Java反射，看完就会用
    SAP UI5 index.html 根节点的 css 类填充逻辑
    ES6之函数的扩展
    Java项目:SSH学生学籍管理系统及教务管理系统
    手动引入jar包，解决Dependency ‘XXX‘ not found的两种方式
    CSS实现图片滑动对比
    【计算机组成与设计】-第五章 memory hierarchy（三）
    网络变压器工厂：了解POE POE+ 网络变压器（网络隔离滤波器）
    Spring Boot 3.2发布：大量Java 21的支持上线，改进可观测性
    Abaqus周期性边界条件
  • 原文地址：https://blog.csdn.net/qq_39312146/article/details/134290713