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)