【Pytorch从零入门深度学习实战教程】B站

Pytorch教程代码：https://github.com/DA-southampton/NLP_ability/tree/master/Pytorch

【参考：秒杀Pytorch，从零入门深度学习实战教程，通俗易懂，小白首选_哔哩哔哩_bilibili】

MLP | Pytorch构建模板

逻辑回归 dasou_mlp.py

import torch
import numpy as np
from torch.utils.data import Dataset
from torch.utils.data import DataLoader


## 自己实现一个Dataset类去加载本地的CSV数据集
## 需要三个函数：init get_item len


class DasouDataset(Dataset):
    def __init__(self, filepath):  ## 加载原始数据集，并对特征数据和lable数据进行拆分
        xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32)
        self.len = xy.shape[0]  # shape(多少行，多少列)
        self.x_data = torch.from_numpy(xy[:, :-1])
        self.y_data = torch.from_numpy(xy[:, [-1]]) # 取（所有行的）最后一列

    def __getitem__(self, index):  ## 根据索引返回单一样本数据
        return self.x_data[index], self.y_data[index] # label,target

    def __len__(self):  ## 返回长度
        return self.len

dataset = DasouDataset('./sigmoid.csv')

train_loader = DataLoader(dataset=dataset, batch_size=32, shuffle=True) #num_workers 多线程


class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = torch.nn.Linear(8, 6)
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.sigmoid = torch.nn.Sigmoid()

    def forward(self, x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return x


model = Model()

# construct loss and optimizer
criterion = torch.nn.BCELoss(reduction='mean')
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(100):
    for i, data in enumerate(train_loader):  # train_loader 是先shuffle后mini_batch
        inputs, labels = data## 获取数据
        y_pred = model(inputs)## 把数据喂进去给模型，获得结果
        loss = criterion(y_pred, labels)## 预测结果和真实值做损失函数
        print(epoch, i, loss.item())
        optimizer.zero_grad()## 梯度清零
        loss.backward()## 反向传播，更新参数

99 19 0.8558803796768188
99 20 0.8558577299118042
99 21 0.7427063584327698
99 22 0.7427690029144287
99 23 0.895809531211853

CNN

难点在处理数据那块

import pandas as pd
import numpy as np
from PIL import Image
import torch
from torch import device
from torch.utils.data import Dataset
from torchvision import transforms
import torch.nn as nn
import torchvision


class MnistDataset(Dataset):

    def __init__(self, image_path, image_label, transform=None):
        super(MnistDataset, self).__init__()
        self.image_path = image_path  # 初始化图像路径列表
        self.image_label = image_label  # 初始化图像标签列表
        self.transform = transform  # 初始化数据增强方法

    def __getitem__(self, index):
        """
        获取对应index的图像，并视情况进行数据增强
        """
        image = Image.open(self.image_path[index])
        image = np.array(image)
        label = int(self.image_label[index])

        if self.transform is not None:
            image = self.transform(image)

        return image, torch.tensor(label)

    def __len__(self):
        return len(self.image_path)

    
def get_path_label(img_root, label_file_path):
    """
    获取数字图像的路径和标签并返回对应列表
    @para: img_root: 保存图像的根目录
    @para:label_file_path: 保存图像标签数据的文件路径 .csv 或 .txt 分隔符为','
    @return: 图像的路径列表和对应标签列表
    """
    data = pd.read_csv(label_file_path, names=['img', 'label'])
    data['img'] = data['img'].apply(lambda x: img_root + x)
    return data['img'].tolist(), data['label'].tolist()


# 获取训练集路径列表和标签列表
train_data_root = './mnist_data/train/'
train_label = './mnist_data/train.txt'
train_img_list, train_label_list = get_path_label(train_data_root, train_label)  
# 训练集dataset
train_dataset = MnistDataset(train_img_list,
                             train_label_list,
                             transform=transforms.Compose([transforms.ToTensor()]))

# 获取测试集路径列表和标签列表
test_data_root = './mnist_data/test/'
test_label = './mnist_data/test.txt'
test_img_list, test_label_list = get_path_label(test_data_root, test_label)
# 测试集sdataset
test_dataset = MnistDataset(test_img_list,
                            test_label_list,
                            transform=transforms.Compose([transforms.ToTensor()]))

num_epochs = 5
num_classes = 10
batch_size = 100
learning_rate = 0.001


train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size, 
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size, 
                                          shuffle=False)

class ConvNet(nn.Module):
    def __init__(self, num_classes=10):
        super(ConvNet, self).__init__()
        ## 池化+batchnorm+relu激活+池化
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)) 
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.fc = nn.Linear(7*7*32, num_classes) ## 全连接
        
    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)
        return out

model = ConvNet(num_classes)

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# Train the model
total_step = len(train_loader)
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = images
        labels = labels
        
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if (i+1) % 100 == 0:
            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' 
                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))

RNN