pytorch学习

最新推荐文章于 2024-06-18 18:25:22 发布

阿畅AHNU

最新推荐文章于 2024-06-18 18:25:22 发布

阅读量448

点赞数 4

分类专栏：笔记文章标签： pytorch 学习人工智能

本文链接：https://blog.csdn.net/weixin_51161807/article/details/136438516

版权

笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

pip安装加速

1.更换镜像源

##1.单次提速
pip install 包名 -i https://pypi.tuna.tsinghua.edu.cn/simple
源地址：http://pypi.python.org/simple/
清华：https://pypi.tuna.tsinghua.edu.cn/simple
阿里云：http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
华中理工大学：http://pypi.hustunique.com/
山东理工大学：http://pypi.sdutlinux.org/
豆瓣：http://pypi.douban.com/simple/
##2.设置pip默认访问地址
找到pip.ini文件添加以下内容
[global]
index-url = 镜像地址
	#或者更换pip源
    pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
	pip config get global.index-url  //检测是否成功设置了

2.若计算机里已将安装了包，直接使用安装的包

pip install --cache-dir=/path/to/cache_dir package_name

环境安装

conda create -n pytorch python=3.6    //创建一个pytorch  python的版本号是3.6，但我本机上的python版本是3.11
conda activate pytorch   //激活pytorch
激活后就成了：
(base) C:\Users\LiuChang> 变成 (pytorch) C:\Users\LiuChang>
pip list  //使用命令查看pytorch中的包列表
(pytorch) C:\Users\LiuChang>pip list
    Package      Version
    ------------ ---------
    certifi      2021.5.30
    pip          21.2.2
    setuptools   58.0.4
    wheel        0.37.1
    wincertstore 0.2
里面没有pytorch，我们需要安装pytorch
官网安装pytorch     官网：www.pytorch.org  复制指令在(pytorch) C:\Users\LiuChang>里粘贴安装 
测试pytorch有没有安装成功 pip list
(pytorch) C:\Users\LiuChang>python
 >>>import torch
 >>>torch.cuda.is_available() //返回True则表示GPU可以使用cuda

anaconda历史版本：https://repo.anaconda.com/
本文使用了：Anaconda3-5.2.0-Windows-x86 64.exe

jupyter的使用

因为在安装annaconda的时候安装了jupyter了，在base中含jupyter了但不包含typroch，两种方法，一是在base中安装typorch，二是在typorch中安装jupyter
我们使用第二种方法：(pytorch) C:\Users\LiuChang>conda install nb_conda
安装完成后执行指令(pytorch) C:\Users\LiuChang>jupyter notebook  //跳转到jupyter界面

数据加载

数据集（dataset）: 作用是提供一种方式去获取数据和label 如何获取每一个数据及其label 告诉我们一共有多少个数据

数据加载（dataloader）：

TensorBoard的使用

SummaryWriter的使用

from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter("logs")

for i in range(100):
    writer.add_scalar("y=x",i,i)
    
writer.close()  //会在根目录下创建log文件夹并生成文件  这里需要安装tensorboard包  pip insatll tensorboard
#使用tensorboard --logdir=logs命令查看文件
//--port来指定对应端口
(pytorch) PS D:\Desktop\PycharmTestAnaconda> tensorboard --logdir=runs --port=6007

add_image() 的使用：常用来观察训练的结果

from torch.utils.tensorboard import SummaryWriter
from PIL import Image
import numpy as np

image_path = "dataset/ants/800px-Meat_eater_ant_qeen_excavating_hole.jpg"
writer = SummaryWriter("logs")
image = Image.open(image_path)
image_array = np.array(image)
writer.add_image("ant",image_array,1,dataformats='HWC')
for i in range(100):
    writer.add_scalar("y=x", i, i)
writer.close()

Transformer的使用

Tensor数据类型

通过Transformer.Tensor去看待两个问题：一是transformer如何使用，二是为什么我们要使用Tensor

from PIL import Image
from torchvision import transforms
image_path="dataset/ants/800px-Meat_eater_ant_qeen_excavating_hole.jpg"
image = Image.open(image_path)
tensor = transforms.ToTensor()
print(tensor(image))

from PIL import Image
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriter
image_path="dataset/ants/800px-Meat_eater_ant_qeen_excavating_hole.jpg"
image = Image.open(image_path)
tensor = transforms.ToTensor()
image_tensor = tensor(image)
write = SummaryWriter("logs")
write.add_image("tensor_image",image_tensor)
write.close()

Normalize的使用

from PIL import Image
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriter
image_path="dataset/ants/800px-Meat_eater_ant_qeen_excavating_hole.jpg"

writer=SummaryWriter("logs")
img = Image.open(image_path)
#ToTensor
trans_totensor = transforms.ToTensor()
img_tensor = trans_totensor(img)
writer.add_image("ToTensor",img_tensor)
#Normalize
trans_norm=transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
img_norm =trans_norm(img_tensor)

writer.close()

Resize的使用
Compose的使用

#compose - resize
trans_resize2 = transforms.Resize(512)
trans_compose = transforms.Compose([trans_resize2,trans_totensor])
img_resize2 = trans_compose(img)
writer.add_image("Resize",img_resize2,1)

使用的注意事项：关注输入和输出的类型，多看官方文档，关注方法需要的参数，使用print（）或者debug来调试查看

数据集-torchvision

这里在终端使用 “/” 指定下一级目录进行查看tensorboard：(pytorch) PS D:\Desktop\PycharmTestAnaconda> tensorboard --logdir=UseDataset/log

import torchvision
from torch.utils.tensorboard import SummaryWriter

dataset_transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])# PIL->Tensor
train_set = torchvision.datasets.CIFAR10("dataset",transform=dataset_transform,train=True,download=True) # PIL->Tensor
test_set = torchvision.datasets.CIFAR10("dataset",transform=dataset_transform,train=False,download=True)
writer = SummaryWriter("./log")
for i in range(10):
    img, target = test_set[i]
    writer.add_image("test_set", img, i)

writer.close()

DataLoader使用
在使用tensorboard的时候，往summary中添加图片时，如果tag变动，只要运行一下代码并在端口上刷新一下就行，不用重新在终端执行打开文件命令（有可能图片会显示错误）

import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("dataset",train=False,transform=torchvision.transforms.ToTensor(),download=False)#拿数据
test_loader = DataLoader(dataset=dataset,batch_size=64,shuffle=False,drop_last=False) #每批大小、是否打乱顺序、是否显示剩余图片
#测试数据集中的第一张图片
# img, target = dataset[0]
# print(dataset[0])
# print(img.shape)
# print(target)
writer = SummaryWriter("logLoader") #用于可视化数据
step=0
for data in test_loader:
    imgs, target = data
    writer.add_images("test_data_loader",imgs,step)
    step=step+1

writer.close()

神经网络的基本框架

module torch.nn使用手册：torch.nn — PyTorch 2.1 documentation

import torch
from torch import nn
class MyModule(nn.Module):     #继承Module父类，重写父类init方法，forward方法里写用来操作数据（input）的过程
    def __init__(self) -> None:
        super().__init__()

    def forward(self, input):
        output = input + 1
        return output
testModule = MyModule()
x = torch.tensor(1.0)
print(testModule(x))   #输出：tensor(2.)

import torch
import torch.nn.functional as F

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]])
kernel = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])
print(input.shape)       # torch.Size([5, 5])
print(kernel.shape)      # torch.Size([3, 3])
input = torch.reshape(input, (1, 1, 5, 5))
kernel = torch.reshape(kernel, (1, 1, 3, 3))
print(input.shape)       #torch.Size([1, 1, 5, 5])
print(kernel.shape)      #torch.Size([1, 1, 3, 3])
#stride是左右上下移动步数，padding是在周围增加空单元格的数量
output1 = F.conv2d(input, kernel, stride=1)
print(output1)           # tensor([[[[10, 12, 12],[18, 16, 16],[13,  9,  3]]]])
output2 = F.conv2d(input, kernel, stride=2)
print(output2)           # tensor([[[[10, 12],[13,  3]]]])
output3 = F.conv2d(input, kernel, stride=1,padding=1)
print(output3)           # tensor([[[[ 1,  3,  4, 10,  8],[ 5, 10, 12, 12,  6],[ 7, 18, 16, 16,  8],[11, 13,  9,  3,  4],[14, 13,  9,  7,  4]]]])

批量（Batch）： 批量是指一次性处理的样本数量。在训练神经网络时，通常会选择一小批样本（例如，32个样本）进行前向传播和反向传播。这样的做法有助于提高训练的效率，减少梯度的方差，从而使模型更加稳定。

在 torch.reshape 中，第一个 1 表示批量大小。如果你的数据集中有多个样本，那么这个数字可能会大于 1，例如 (batch_size, channels, height, width)。

通道（Channel）： 通道是指输入数据的特征维度。在图像处理中，通道通常对应于图像的颜色通道或特定的特征通道。例如，对于彩色图像，可能有三个通道对应于红色、绿色和蓝色。对于卷积神经网络，通道也可以对应于卷积核的数量，即学习到的不同特征的数量。
在 torch.reshape 中，第二个 1 表示通道数。如果你的数据包含多个特征，例如多个颜色通道或多个卷积核，那么这个数字可能会大于 1。

神经网络-卷积层

下载数据
加载数据
建立卷积模型使用tensorboard数据可视化

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# 拿数据
dataset = torchvision.datasets.CIFAR10("../UseDataset/dataset", train=False,
                                       transform=torchvision.transforms.ToTensor(), download=True)
# 加载数据
data_load = DataLoader(dataset, batch_size=64)


# 建立模型
class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=3, kernel_size=3, out_channels=6, stride=1, padding=0)

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


# 使用模型
module = MyModule()
writer = SummaryWriter("log")
step = 0
for data in data_load:
    imgs, targets = data
    output = module(imgs)
    writer.add_images("imgs", imgs, step)
    # 针对下面的报错，改变output的形状，让其切开放到batch_size上
    # [64, 6, 30, 30] ->[xxx, 3, 30, 30]
    output = torch.reshape(output,(-1,3,30,30))
    writer.add_images("output", output, step)  # 这里报错assert I.ndim == 4 and I.shape[1] == 3，因为我们输出的是6channel，参数需要的是3个channel

    step += 1
    print(imgs.shape)  # torch.Size([64, 3, 32, 32])
    print(output.shape)  # torch.Size([64, 6, 30, 30]) 30是因为卷积核是3X3输出了30

神经网络-池化层

池化的作用：把数据缩小，比如1080P转成720P的视频

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../UseDataset/dataset", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, 64)


# 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)
# input = torch.reshape(input,(-1,1,5,5))
# print(input.shape)  #torch.Size([1, 1, 5, 5])

class ModuleDemo(nn.Module):

    def __init__(self) -> None:
        super().__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=False)  #设置池化层 

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


module = ModuleDemo()
writer = SummaryWriter("log_pool")
step = 0
for data in dataloader:
    imgs, target = data
    writer.add_images("output", imgs, step)
    output = module(imgs)
    writer.add_images("output_pool", output, step)
    step += 1
writer.close()
# output = module(input)
# print(output)  #tensor([[[[2.]]]])

神经网络-非线性激活

ReLu和Sigmoid函数

import torch
from torch import nn
from torch.nn import ReLU
input = torch.tensor([
    [1,-0.5],
    [-1,2]
])
output = torch.reshape(input,(-1,1,2,2))
print(output.shape)  #torch.Size([1, 1, 2, 2])

class ModuleDemo(nn.Module):

    def __init__(self) -> None:
        super().__init__()
        self.relu1=ReLU()
    def forward(self,input):
        return self.relu1(input)
module = ModuleDemo()
output = module(input)
print(output)  #tensor([[1., 0.],[0., 2.]])

神经网络-线性层及其他层的介绍

神经网络-Sequencial使用

转换前

import torch.nn as nn
import torch


class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, 5, padding=2)
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(32, 32, 5, padding=2)
        self.pool2 = nn.MaxPool2d(2)
        self.conv3 = nn.Conv2d(32, 64, 5, padding=2)
        self.pool3 = nn.MaxPool2d(2)
        self.flat = nn.Flatten()
        self.linear1 = nn.Linear(1024, 64)
        self.linear2 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = self.conv3(x)
        x = self.pool3(x)
        x = self.flat(x)
        x = self.linear1(x)
        x = self.linear2(x)
        return x


module = MyModule()
input = torch.ones((64, 3, 32, 32))
print(input.shape)
print(module)
output = module(input)

print(output.shape)

转换后

from torch import nn
import torch


class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        #转换的部分
        self.moduel1 = nn.Sequential(
        nn.Conv2d(3, 32, 5, padding=2),
        nn.MaxPool2d(2),
        nn.Conv2d(32, 32, 5, padding=2),
        nn.MaxPool2d(2),
        nn.Conv2d(32, 64, 5, padding=2),
        nn.MaxPool2d(2),
        nn.Flatten(),
        nn.Linear(1024, 64),
        nn.Linear(64, 10),
        )
	#转换的部分
    def forward(self, x):
        x = self.moduel1(x)
        return x


module = MyModule()
input = torch.ones((64, 3, 32, 32))
print(input.shape)
print(module)
output = module(input)

print(output.shape)

# module()

#这里可以让每层网络可视化
writer = SummaryWriter("logs_sequential")
writer.add_graph(module,input)
writer.close()

损失函数与反向传播

Loss损失函数：1. 计算实际输出和目标之间的差距、2. 为我们更新输出提供了一定的依据，grad

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../UseDataset/dataset", train=False,
                                       transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, 1)


class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.moduel1 = nn.Sequential(
            nn.Conv2d(3, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10),
        )

    def forward(self, x):
        x = self.moduel1(x)
        return x
module = MyModule()
loss = nn.CrossEntropyLoss()
for dataset in dataloader:
    imgs,targets =dataset
    output = module(imgs)
    result_loss = loss(output,targets)
    print(result_loss)