pytorch入门笔记01
Pytorch 张量
该笔记从02开始后面是pytorch官网上的60分钟入门篇，我自己翻译的，翻译的不太好，凑活看哈哈哈。。。
标量（0D）
只包含一个元素的张量为标量。类型通常为FloatTensor或LongTensor
import torch
x = torch.rand(10)
x.size()
向量（1D）
import torch
x = torch.FloatTensor([1.0,2.0,3.0,4.0])
out:
torch.Size([4])
矩阵（2D）
x = torch.FloatTensor([[1,2],[3,4]])
print(x.size())
out:
torch.Size([2, 2])
三维向量
多个矩阵累加在一起。比如一张图片，有三个通道，每个通道都有一个矩阵。此处的pic2.jpg是一个28x28x3的图片。
import numpy as np
import torch
import cv2 as cv
src = cv.imread('../pic2.jpg')
matrix = np.array(src)
tensor = torch.from_numpy(matrix)
print(tensor.size())
out:
torch.Size([28, 28, 3])
切片张量
这里和python的用法一样
sales = torch.FloatTensor([1.0,2.0,3.0,4.0,5.0])
print(sales[:2])
out:
tensor([1., 2.])
对于前面的如果需要其中一个通道。一种用切片向量，一种用opencv的split方法。
import numpy as np
import torch
import cv2 as cv
src = cv.imread('../pic2.jpg')
matrix = np.array(src)
tensor = torch.from_numpy(matrix)
#切片
qp_tensor = tensor[:,:,0]
print(qp_tensor.size)
#opencv方法
b,g,r = cv.split(src)
4维张量
对于多张图片，批处理那种
5维张量
视频数据。
GPU上的张量
import torch
import time
a = torch.rand(10000,10000)
b = torch.rand(10000,10000)
cpustart = time.time()
a.matmul(b)
cpuEnd = time.time()
#将张量转移到GPU
a = a.cuda()
b = b.cuda()
gpustart = time.time()
a.matmul(b)
gpuEnd = time.time()
print("CPU cost: " + str(cpuEnd - cpustart))
print("GPU cost: " + str(gpuEnd - gpustart))
out:
CPU cost: 7.888931035995483
GPU cost: 0.1765275001525879
常见的方法
判断GPU是否可用
if torch.cuda.is_available():
tensor = tensor.to('cuda')
print(f"device tensor is stored on: {tensor.device}")
生成空矩阵
没有初始化
import torch
# 构造一个5 x 3的矩阵,没有初始化
x = torch.empty(5,3)
print(x)
out:
tensor([[9.3673e-39, 9.5511e-39, 1.0194e-38],
[4.2246e-39, 1.0286e-38, 1.0653e-38],
[1.0194e-38, 8.4490e-39, 1.0469e-38],
[9.3674e-39, 9.9184e-39, 8.7245e-39],
[9.2755e-39, 8.9082e-39, 9.9184e-39]])
随机初始化
# 构造一个随机初始化的矩阵
x1 = torch.rand(5,3)
out:
tensor([[0.4749, 0.0095, 0.4786],
[0.5207, 0.4228, 0.0364],
[0.8313, 0.9352, 0.6975],
[0.2701, 0.5206, 0.8709],
[0.3670, 0.3378, 0.9704]])
创建零矩阵
# 构造一个矩阵全为0，数据类型是long类型的
x2 = torch.zeros(5,3,dtype=torch.long)
out:
tensor([[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
构造一个张量
#构造一个张量，直接使用数据
x3 = torch.tensor([5.5,3])
out:
tensor([5.5000, 3.0000])
基于一个已存在的tensor创建一个
# 创建一个tensor基于已经存在的tensor
x4 = x.new_ones(5,3,dtype=torch.double)
#Tensor.new_ones 返回一个与size大小相同的用1填充的张量，
#默认情况下，返回的Tensor具有次张量相同的torch.dtype和torch.device
# randn_like,基于已存在的tensor，创建随机相似的
x5 = torch.randn_like(x4,dtype=torch.float)
print(x4)
print(x5)
out:
tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]], dtype=torch.float64)
tensor([[-0.7830, 0.2870, 0.3721],
[ 0.2931, 0.4255, 0.3800],
[-0.1016, 0.6011, -0.7567],
[ 0.4526, -1.0510, -0.4116],
[ 1.4605, 1.4378, 0.4322]])
获取维度信息
#获取维度信息
print(x5.size())
out:
torch.Size([5, 3])
加法
#######################加法####################
y1 = torch.ones(5,3) #创建一个全是1的矩阵
print(x4 + y1)
x6 = torch.add(x4,y1)
torch.add(x4,y1,out=x) #提供输出tensor作为参数
#还可以in-place
y1.add_(x4)
# 任何使张量发生变化的操作都有一个前缀'_'
out:
tensor([[2., 2., 2.],
[2., 2., 2.],
[2., 2., 2.],
[2., 2., 2.],
[2., 2., 2.]])
numpy一样标准的索引和切片
import torch
tensor = torch.ones(4,4)
tensor[:,1] = 0
print(tensor)
out:
tensor([[1., 0., 1., 1.],
[1., 0., 1., 1.],
[1., 0., 1., 1.],
[1., 0., 1., 1.]])
乘法
a = torch.rand(2,2)
b = torch.rand(2,2)
#乘法 对应位置相乘
print(a * b)
print(a.mul(b))
#自身乘法，相当于a = a * b
print(a.mul_(b))
print(a)
矩阵乘法计算，行乘列求和的那种
mul = tensor.matmul(tensor.t())
mul2 = tensor @ tensor.t()
print(mul)
print(mul2)
out:
tensor([[3., 3., 3., 3.],
[3., 3., 3., 3.],
[3., 3., 3., 3.],
[3., 3., 3., 3.]])
tensor([[3., 3., 3., 3.],
[3., 3., 3., 3.],
[3., 3., 3., 3.],
[3., 3., 3., 3.]])
连接张量
连接张量可以使用torch.cat。 将给定维数的张量顺序连接起来，也可以用torch.stack，另一种张量连接，略有不同
t1 = torch.cat([tensor,tensor],dim=1)
print(t1)
out:
tensor(
[[1., 0., 1., 1., 1., 0., 1., 1.],
[1., 0., 1., 1., 1., 0., 1., 1.],
[1., 0., 1., 1., 1., 0., 1., 1.],
[1., 0., 1., 1., 1., 0., 1., 1.]])
改变tensor的形状
#改变tensor大小或形状 torch.view
x7 = torch.randn(4,4)
y = x7.view(16)
z = x7.view(-1,8) #尺寸设为-1，表示自己算这个大小
print(x7.size(),y.size(),z.size())
out:
torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
获取标量的值
#如果只有一个tensor，使用item()可以获得这个value
x8 = torch.tensor([1])
print(x8)
print(x8.item())
out:
tensor([1])
1
numpy和tensor相互转换
numpy转pytorch
import numpy as np
import torch
import cv2 as cv
src = cv.imread('../pic2.jpg')
cv.imshow("hello",src)
matrix = np.array(src)
panda_tensor = torch.from_numpy(matrix)
print(panda_tensor.size())
cv.waitKey(0)
cv.destroyAllWindows()
主要是torch.from_numpy()
pytorch转numpy
tensor = torch_data.numpy()
# torch_data是一个tensor
模型的保存和读取
# 保存
def save():
net1 = torch.nn.Sequential(
torch.nn.Linear(1,10),
torch.nn.ReLU(),
torch.nn.Linear(10,1)
)
optimizer = torch.optim.SGD(net1.parameters(),lr=0.5)
for t in range(100):
prediction = net1(x)
loss = F.mse_loss(prediction,y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
torch.save(net1,'net.pkl') # 方式1： 直接保存当前网络
torch.save(net1.state_dict(),'net_params.pkl') # 方式2： 保存网络中的参数parameters
def restore_net():
net2 = torch.load('net.pkl') # 加载网络
def restore_params():
net3 = torch.nn.Sequential(
torch.nn.Linear(1,10),
torch.nn.ReLU(),
torch.nn.Linear(10,1)
)
# 通过Parameters加载，由于存储的是参数而不是网络，所以这个需要构建一个和保存时候一样的网络，然后加载参数即可。
# 加载参数比直接加载网络要快。
net3.load_state_dict(torch.load('net_params.pkl'))