Pytorch 框架

第一章  数据加载

Dataset:提供一种方式去获取数据及其标签，并告诉我们有多少数据

Dataloader:为后面的网络提供不同的数据形式

class MyData(Dataset):               #创建一个MyData类，去继承Dataset

   def __init__(self,root_dir,label_dir):         #创建全局变量，比如数据的路径
      self.root_dir = root_dir
      self.label_dir = label_dir             #self.设置全局变量
      self.path = os.path.join(self.root_dir,self.label_dir)  #得到的是拼接的路径
      self.img_path = os.listdir(self.path)    #获得path路径下的所有文件（名字）,是一个数组

   def __getiem__(self,index):       #获得图片
       img_name = self.img_path[index]   #获得数组中的一个（文件名），不是路径
       img_item_path = os.path.join(self.root_dir,self.label_dir,img_name)#再拼接上文件名
       label = self.label_dir
       return img,label

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

#使用
root_dir = "database/train"
data_label_dir = "data"
data_dataset = MyDate(root_dir,data_label_dir)
img,label = data_dataset[0]    #第一张数据
img.show()     #放出来
       

第二章  tensorboard的使用 

主要用于看loss的变化

writer = SummaryWriter("logs")    #把文件存储在logs文件夹下

#有三种主要的使用
writer.add_image()    #用来把图片显示在ten里
writer.add_scalar()   #显示函数
writer.close()

#在终端输入命令，复制地址可打开。
#tensorboard --logdir=logs    其中logdir=事件文件所在文件夹名
#tensorboard --logdir=logs --port=6007    指定端口

其中add_image()读取数据的类型必须是 torch.Tensor,  numpy.array,  或者是string/blobname类型，故 要进行数据类型转换。

opencv-python是最常用来打开numpy类型的包

import numpy as np
from PIL import Image

image_path = '地址'
img_PIL = Image.open(image_path)
img_array = np.array(img_PIL)      #先获得PIL数据类型
print(type(img_array))

第三章   transforms

用来对图像进行变换，也就是输入一个特定格式的图片，经过transforms的函数后输出我们想要的图片结果

totensor数据类型：

img_path = '路径'
img = Image.open(img_path) 
print(img)   #PIL类型的图片

tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)   #将PIL转换为tensor数据类型
 

Resize改变尺寸：

t_resize = transforms.Resize((512,512))
img_size = t_resize(img)

第四章  数据集的加载

转换为tensor数据类型

import torchvision

dataset_transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])

五   神经网络的搭建 

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):  #相当于nn.Module是一个网络框架，我们对其一部分进行更改
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):      #神经网络经过forward得到一个输出（前向传播）
        x = F.relu(self.conv1(x))    # x经过一次卷积conv1，再经过一次非线性relu
        return F.relu(self.conv2(x))    #得到的x再经过一次conv2再经过一次relu

卷积：用卷积核在输入图像上对应相乘再相加。

import torch
input = torch.tensor([[1,2,0,3,1],    #[[表示是二维矩阵   #输入图像
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]],dtype=torch.float32)#把lang型的1变成浮点型的1.0

kernel = torch.tensor([[1,2,1],      #卷积核
                       [0,1,0],
                       [2,1,0]])

print(input.shape)              # torch.Size([5,5])
input = torch.reshape(input,(1,1,5,5))   # 1-bachsize为1；1- 平面所以通道为1；(5,5)H，W
kernel = torch.reshape(kernel,(1,1,3,3))

#卷积
import torch.nn.functional as F

output = F.conv2d(input,kernel,stride = 1)     #stride = 1 走一步 padding输入图片填充
print(output)   #结果就是对应相乘相加得到的矩阵

 conv2d的输入要求：input(minibatch,in_channels,H,W)四个参数，而图片的shape只输出(H,W)因此采用reshape函数

class Module(nn.Module)
    def __init__(self):
        super(Module,self).__init__()     #初始化父类
        self.conv1 = Conv2d(in_channels=3,out_channels=6,   #3-彩色，6-自己想要的层
                          kernel_size=3,stride=1,padding=0) #3-卷积核3✖3

    def forward(self,x):
        x = self.conv1(x)
        return x          #想得到输出x，所以返回x

m = Module()
print(m)

六      最大池化

       最大池化是指，对应相乘的最大值（不相加）。最大池化的目的是保留输入的特征，同时又把数据量进行减小。

class Module(nn.Module)
    def __init__(self):
        super(Module,self).__init__()     #初始化父类
        self.maxpool1 = MaxPool2d(kernel_size = 3,ceil_mode = True) #最大池化
                                            #ceil_mode=True 卷积核移动的时候边边也算

    def forward(self,input):
        output = self.maxpool1(input)
        return x 

module = Module()
output = module(input)    #把输入的数组传进去

#如何把图应用在网络里
dataset = torchvision.datasets.CIFAR10('../data',train=False,download=True,
                                   transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset,batch_size = 64)   #按每次64张输入图片

for data in dataloader:   
    imgs,targets = data
    out = module(imgs)

七       非线性激活 

非线性变换目的是为网络引入一些非线性特征，因为非线性越多，网络才能训练出符合各种曲线特征的模型。如果大家都是线性的话，那模型的泛化能力将不够好

nn.ReLU

class Module(nn.Module)
    def __init__(self):
        super(Module,self).__init__()     #初始化父类
        self.relu1 = ReLU()               #ReLU函数表示 小于0的为0，大于0的线性输出

    def forward(self,input):
        output = self.relu1(input)
        return output

ReLU对图像的作用不是很明显，Sigmoid函数明显一些。

八      正则化

可以加快神经网络的训练速度。用的少