PyTorch 卷积神经network(CNN)

import torch
import torch.nn as nn

# creation一个卷积层
conv_layer = nn.Conv2d(
    in_channels=1,      # 输入通道数, 灰度graph像 for 1, RGBgraph像 for 3
    out_channels=6,     # 输出通道数, 即卷积核 数量
    kernel_size=3,      # 卷积核 big  small , 3x3
    stride=1,           # 步 long 
    padding=1           # 填充, 保持输出 big  small  and 输入相同
)

# 查看卷积层 parameter
print(conv_layer)
print(f"卷积核数量: {conv_layer.out_channels}")
print(f"卷积核 big  small : {conv_layer.kernel_size}")
print(f"步 long : {conv_layer.stride}")
print(f"填充: {conv_layer.padding}")

# 输入example: 1个灰度graph像,  big  small  for 28x28
input = torch.randn(1, 1, 28, 28)

#  before 向传播
output = conv_layer(input)
print(f"输入形状: {input.shape}")
print(f"输出形状: {output.shape}")

# 激活functionexample
relu = nn.ReLU()
sigmoid = nn.Sigmoid()
tanh = nn.Tanh()
leaky_relu = nn.LeakyReLU()
elu = nn.ELU()

# usingexample
x = torch.tensor([-1.0, 0.0, 1.0])
print(f"输入: {x}")
print(f"ReLU输出: {relu(x)}")
print(f"Sigmoid输出: {sigmoid(x)}")
print(f"Tanh输出: {tanh(x)}")
print(f"Leaky ReLU输出: {leaky_relu(x)}")
print(f"ELU输出: {elu(x)}")

# 最 big 池化层
max_pool = nn.MaxPool2d(
    kernel_size=2,  # 池化窗口 big  small 
    stride=2        # 步 long 
)

# 平均池化层
avg_pool = nn.AvgPool2d(
    kernel_size=2,  # 池化窗口 big  small 
    stride=2        # 步 long 
)

# 输入example
input = torch.randn(1, 6, 28, 28)  # 6个特征graph, 每个 big  small  for 28x28

# 最 big 池化
max_output = max_pool(input)
print(f"输入形状: {input.shape}")
print(f"最 big 池化输出形状: {max_output.shape}")

# 平均池化
avg_output = avg_pool(input)
print(f"平均池化输出形状: {avg_output.shape}")

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 卷积层1: 1个输入通道, 16个输出通道, 3x3卷积核
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)
        # 激活function
        self.relu = nn.ReLU()
        # 池化层: 2x2最 big 池化
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        # 卷积层2: 16个输入通道, 32个输出通道, 3x3卷积核
        self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)
        # 全连接层1: 32*7*7输入, 128输出
        self.fc1 = nn.Linear(32 * 7 * 7, 128)
        # 全连接层2: 128输入, 10输出 (MNIST has 10个class别) 
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        # 第一层卷积
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)  # 输出形状: (batch_size, 16, 14, 14)
        
        # 第二层卷积
        x = self.conv2(x)
        x = self.relu(x)
        x = self.pool(x)  # 输出形状: (batch_size, 32, 7, 7)
        
        # 展平特征graph
        x = x.view(-1, 32 * 7 * 7)  # 输出形状: (batch_size, 32*7*7)
        
        # 全连接层
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)  # 输出形状: (batch_size, 10)
        
        return x

# creationmodelinstance
model = SimpleCNN()
print(model)

import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 设置设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# data预processing
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换 for 张量
    transforms.Normalize((0.1307,), (0.3081,))  # 归一化, 均值 and 标准差 is MNISTdata集 statistics值
])

# 加载MNISTdata集
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# creationdata加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 初始化model, 损失function and optimization器
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练model
epochs = 5
for epoch in range(epochs):
    run_loss = 0.0
    correct = 0
    total = 0
    
    model.train()  # 切换 to 训练模式
    for inputs, targets in train_loader:
        inputs, targets = inputs.to(device), targets.to(device)
        
        #  before 向传播
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        
        # 反向传播 and optimization
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # statistics损失 and 准确率
        run_loss += loss.item() * inputs.size(0)
        _, predicted = torch.max(outputs.data, 1)
        total += targets.size(0)
        correct += (predicted == targets).sum().item()
    
    # 计算平均损失 and 准确率
avg_loss = run_loss / len(train_loader.dataset)
accuracy = correct / total
    
    print(f'Epoch [{epoch+1}/{epochs}], Loss: {avg_loss:.4f}, Accuracy: {accuracy:.4f}')

# assessmentmodel
model.eval()  # 切换 to assessment模式
test_correct = 0
test_total = 0
with torch.no_grad():
    for inputs, targets in test_loader:
        inputs, targets = inputs.to(device), targets.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        test_total += targets.size(0)
        test_correct += (predicted == targets).sum().item()

test_accuracy = test_correct / test_total
print(f'Test Accuracy: {test_accuracy:.4f}')

from torchvision import models

# 加载预训练 ResNet18model
resnet18 = models.resnet18(pretrained=True)
print(resnet18)

# 加载预训练 VGG16model
vgg16 = models.vgg16(pretrained=True)
print(vgg16)

# 加载预训练 GoogLeNetmodel
googlenet = models.googlenet(pretrained=True)
print(googlenet)

# 冻结model 卷积层parameter
for param in resnet18.parameters():
    param.requires_grad = False

# modify最 after 一层全连接层, adapting to new classificationtask
num_ftrs = resnet18.fc.in_features
resnet18.fc = nn.Linear(num_ftrs, 10)  # 10个class别

print(resnet18.fc)