Pytorch学习

PIL读取图片

from PIL import Image
img_path = 'D:\\Project\\pytorch\\datasets\\practice_dataset\\train\\ants_image\\0013035.jpg'
img = Image.open(img_path)
img.show()

加载数据集

from torch.utils.data import Dataset
from PIL import Image
import os
class MyData(Dataset):
    def __init__(self, root_dir,label_dir):
        """
        :param root_dir:根路径
        :param label_dir: 图片路径
        """
        self.root_dir = root_dir
        self.label_dir = label_dir
        self.path = os.path.join(self.root_dir, self.label_dir)
        self.img_path  = os.listdir(self.path)
    def __getitem__(self, idx):
        """
        :param idx:id
        :return:
        """
        img_name = self.img_path[idx]
        img_item_path = os.path.join(self.root_dir, self.label_dir, img_name)
        img = Image.open(img_item_path)
        label = self.label_dir
        return img, label
    def __len__(self):
        return len(self.img_path)

root_dir = "datasets/practice_dataset/train"
ants_label_dir = "ants_image"
ants_dataset = MyData(root_dir, ants_label_dir)
img ,label = ants_dataset[0]
img.show()
print(label)

绝对路径和相对路径

# 绝对路径
img_path = 'D:\\Project\\pytorch\\datasets\\practice_dataset\\train\\ants_image'

# 相对路径
img_path = 'datasets/practice_dataset/train/ants_image'

TensorBoard

神经网络

import torch
from jinja2 import optimizer
from torch import nn
# from model import Network
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
class Network(nn.Module):
    def __init__(self):
        super().__init__()
        # 线性层1：输入层和隐藏层之间的线性层
        self.layer1 = nn.Linear(784,256)
        # 线性层2：隐藏层和输出层之间的线性层
        self.layer2 = nn.Linear(256,10)
    def forward(self,x):
        x = x.view(-1,28*28) # 使用view函数，将x展平
        x = self.layer1(x) # 将x输入至layer1
        x = torch.relu(x) # 使用relu激活
        return self.layer2(x) # 输入至layer2计算结果
        # 这里我们没有直接定义softmax层

if __name__ == '__main__':

    # 1 加载数据集
    transform = transforms.Compose([
        transforms.Grayscale(num_output_channels=1),  #转化为单通道灰度图
        transforms.ToTensor() #转化为张量
    ])
    # 读入并构造数据集
    train_dataset = datasets.ImageFolder(root='./mnist_images/train', transform=transform)
    print("train_dataset length:",len(train_dataset))

    # 小批量的数据读入
    train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
    print("train_loader length:",len(train_loader))


    # 2 训练过程
    for epoch in range(10):
    # 训练轮次

        for batch_index ,(data,label) in enumerate(train_loader):
            # enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
            # 同时列出数据和数据下标，一般用在for 循环当中。
            # 1 计算神经网络的前向传播结果
            output = model(data)
            # 2 计算output和标签label之间的损失loss
            loss = criterion(output,label)
            # 使用backward计算梯度
            loss.backward()
            # 3 使用backward计算梯度
            optimizer.step()
            optimizer.zero_grad()
            if batch_index % 100 == 0:
                print(f"epoch:{epoch} batch:{batch_index} loss:{loss}")
    # 3 保存训练模型
    torch.save(model.state_dict(),'./mnist_model.pth') # 保存模型

    # 4 测试
    right = 0 # 保存正确识别的数量
    for i ,(x,y) in enumerate(train_dataset):
        output = model(x) # 将其中的数据x输入到模型
        predict = output.argmax(1).item() # 选择概率最大标签的作为预测结果
        # 对比预测值predict和真实标签y
        if predict == y:
            right += 1
        else :
            img_path = test_dataset.samples[i][0]
            print(f"wrong case:predict = {predict} y = {y} img_path:{img_path}")

输入层

隐藏层

输出层