兰州 网站建设公司哪家好网站建设数据库系统

PyTorch是一个Python深度学习框架，它将数据封装成张量（Tensor）来进行计算。PyTorch中张量就是元素为同一种数据类型的多维矩阵。在PyTorch中，
张量以"类"的形式封装起来，对张量的一些运算、处理方法被封装在类中。

基本创建方式

1. torch.tensor 根据指定数据创建张量

2. torch.Tensor 根据形状创建张量，也可创建指定数据张量

3. torh.IntTensor,torch.FloatTensor,torch.DoubleTensor创建指定类型张量

import torch
import numpy as np
import random
# 1. 根据已有数据创建张量
def test01():# 1. 创建张量标量data = torch.tensor(10)print(data)
# 2. numpy 数组, 由于 data 为 float64, 下⾯代码也使⽤该类型data = np.random.randn(2, 3)print(data)data = torch.tensor(data)print(data)
# 3. 列表, 下⾯代码使⽤默认元素类型 float32data = [[10., 20., 30.], [40., 50., 60.]]data = torch.tensor(data)print(data)

test01()  #也就是用numpy生成的数据，或者手动建一个list的二维列表，tensor都可以改成张量形成

tensor(10)
[[ 0.99729177  0.8347698  -0.19685624][ 0.31439596 -0.5259964   0.58403897]]
tensor([[ 0.9973,  0.8348, -0.1969],[ 0.3144, -0.5260,  0.5840]], dtype=torch.float64)
tensor([[10., 20., 30.],[40., 50., 60.]])

# 2. 创建指定形状的张量
def test02():
#程序输出结果:
# 1. 创建2⾏4列的张量, 默认 dtype 为 float32data = torch.Tensor(2, 4)print(data)
# 2. 注意: 如果传递列表, 则创建包含指定元素的张量data = torch.Tensor([10])print(data)data = torch.Tensor([10, 20])print(data)

test02()

tensor([[-1.2085e+21,  1.9716e-42,  0.0000e+00,  0.0000e+00],[ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00]])
tensor([10.])
tensor([10., 20.])

3. 使⽤具体类型的张量

def test03():

1. 创建2⾏3列, dtype 为 int32 的张量

data = torch.IntTensor(2, 3)
print(data)

2. 注意: 如果传递的元素类型不正确, 则会进⾏类型转换

data = torch.IntTensor([2.5, 3.3])
print(data)

3. 其他的类型

data = torch.ShortTensor(2,3) # int16
print(data)
data = torch.LongTensor(2,3) # int64
print(data)
data = torch.FloatTensor(2,3) # float32
print(data)
data = torch.DoubleTensor(2,3) # float64
print(data)

if name == ‘main’:
test03()

创建线性和随机张量

1. torch.arange和torch.linspace创建线性张量

2. torch.random.init_seed和torch.random.manual_seed随机种子设置

3. torch.randn 创建随机张量

# 1. 创建线性空间的张量
def test01():
# 1. 在指定区间按照步⻓⽣成元素 [start, end, step)data = torch.arange(0, 10, 2)print(data)
# 2. 在指定区间按照元素个数⽣成data = torch.linspace(0, 11, 10)print(data)

def test02():

1. 创建随机张量

data = torch.randn(2, 3) # 创建2⾏3列张量
print(data)

2. 随机数种⼦设置

print('随机数种⼦:', torch.random.initial_seed())
torch.random.manual_seed(100)
print('随机数种⼦:', torch.random.initial_seed())
torch.random.manual_seed(torch.initial_seed())
print('随机数种⼦:', torch.random.initial_seed())

if __name__ == '__main__':test01()

tensor([0, 2, 4, 6, 8])
tensor([ 0.0000,  1.2222,  2.4444,  3.6667,  4.8889,  6.1111,  7.3333,  8.5556,9.7778, 11.0000])

if __name__ == '__main__':test02()

tensor([[ 0.3607, -0.2859, -0.3938],[ 0.2429, -1.3833, -2.3134]])
随机数种⼦: 100
随机数种⼦: 100
随机数种⼦: 100

创建01张量

1. torhc.ones和torch.ones_like创建全1张量

2. torch.zeros和torch.zeros_like创建全0张量

3. torch.full和torch.full_like创建全为指定张量

# 创建全0张量
def test01():
# 1. 创建指定形状全0张量data = torch.zeros(2, 3)print(data)
# 2. 根据张量形状创建全0张量data = torch.zeros_like(data)print(data)
# 2. 创建全1张量
def test02():
# 1. 创建指定形状全1张量data = torch.ones(2, 3)print(data)
# 2. 根据张量形状创建全1张量data = torch.ones_like(data)print(data)
# 3. 创建全为指定值的张量
def test03():
# 1. 创建指定形状指定值的张量data = torch.full([2, 3], 10)print(data)
# 2. 根据张量形状创建指定值的张量data = torch.full_like(data, 20)print(data)
if __name__ == '__main__':test01()test02()test03()

tensor([[0., 0., 0.],[0., 0., 0.]])
tensor([[0., 0., 0.],[0., 0., 0.]])
tensor([[1., 1., 1.],[1., 1., 1.]])
tensor([[1., 1., 1.],[1., 1., 1.]])
tensor([[10, 10, 10],[10, 10, 10]])
tensor([[20, 20, 20],[20, 20, 20]])

张量元素类型转换

1. tensor.type(torch.Double Tensor)

2. torch.double()

def test():
data = torch.full([2, 3], 10)
print(data.dtype)

默认整型是64，和LongTensor一样

将 data 元素类型转换为 float64 类型

1. 第⼀种⽅法

data = data.type(torch.DoubleTensor)
print(data.dtype)

转换为其他类型

data = data.type(torch.ShortTensor)
print(data.dtype)
data = data.type(torch.IntTensor)
print(data.dtype)
data = data.type(torch.LongTensor)
print(data.dtype)
data = data.type(torch.FloatTensor)
print(data.dtype)

2. 第⼆种⽅法

data = data.double()
print(data.dtype)

转换为其他类型

data = data.short()

data = data.int()

data = data.long()

data = data.float()

if name == ‘main’:
test()

## 张量基本运算
### add,sub,mul,div,neg 等，如果是带下划线的就是修改原数据，不带的话就是不修改。

def test():data = torch.randint(0, 10, [2, 3])print(data)print('-' * 50)
# 1. 不修改原数据new_data = data.add(10) # 等价 new_data = data + 10print(new_data)print(data)print('-' * 50)
# 2. 直接修改原数据
# 注意: 带下划线的函数为修改原数据本身data.add_(10) # 等价 data += 10print(data)
# 3. 其他函数print(data.sub(100))print(data.mul(100))print(data.div(100))print(data.neg())
if __name__ == '__main__':test()

tensor([[0, 2, 5],[9, 5, 1]])
--------------------------------------------------
tensor([[10, 12, 15],[19, 15, 11]])
tensor([[0, 2, 5],[9, 5, 1]])
--------------------------------------------------
tensor([[10, 12, 15],[19, 15, 11]])
tensor([[-90, -88, -85],[-81, -85, -89]])
tensor([[1000, 1200, 1500],[1900, 1500, 1100]])
tensor([[0.1000, 0.1200, 0.1500],[0.1900, 0.1500, 0.1100]])
tensor([[-10, -12, -15],[-19, -15, -11]])

阿达玛积

矩阵对应位置元素相乘

import numpy as np
import torch
def test():data1 = torch.tensor([[2, 5], [3, 4]])data2 = torch.tensor([[3, 7], [7, 8]])
# 第⼀种⽅式data = torch.mul(data1, data2)print(data)print('-' * 50)
# 第⼆种⽅式data = data1 * data2print(data)print('-' * 50)
if __name__ == '__main__':test()

tensor([[ 6, 35],[21, 32]])
--------------------------------------------------
tensor([[ 6, 35],[21, 32]])
--------------------------------------------------

## 点积运算
### 点积运算要求第⼀个矩阵 shape: (n, m)，第⼆个矩阵 shape: (m, p), 两个矩阵点积运算 shape 为: (n, p)。
### 1. 运算符 @ ⽤于进⾏两个矩阵的点乘运算
### 2. torch.mm ⽤于进⾏两个矩阵点乘运算, 要求输⼊的矩阵为2维
### 3. torch.bmm ⽤于批量进⾏矩阵点乘运算, 要求输⼊的矩阵为3维
### 4. torch.matmul 对进⾏点乘运算的两矩阵形状没有限定.

import numpy as np
import torch
# 1. 点积运算
def test01():data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])data2 = torch.tensor([[5, 6], [7, 8]])
# 第⼀种⽅式data = data1 @ data2print(data)print('-' * 50)
# 第⼆种⽅式data = torch.mm(data1, data2)print(data)print('-' * 50)
# 第三种⽅式data = torch.matmul(data1, data2)print(data)print('-' * 50)
# 2. torch.mm 和 torch.matmull 的区别
def test02():
# matmul 可以两个维度可以不同
# 第⼀个张量: (3, 4, 5)
# 第⼆个张量: (5, 4)
# torch.mm 不可以相乘，⽽ matmul 则可以相乘print(torch.matmul(torch.randn(3, 4, 5), torch.randn(5, 4)).shape)print(torch.matmul(torch.randn(5, 4), torch.randn(3, 4, 5)).shape)
# 3. torch.mm 函数的⽤法
def test03():
# 批量点积运算
# 第⼀个维度为 batch_size
# 矩阵的⼆三维要满⾜矩阵乘法规则data1 = torch.randn(3, 4, 5)data2 = torch.randn(3, 5, 8)data = torch.bmm(data1, data2)print(data.shape)
if __name__ == '__main__':test01()test02()test03()

tensor([[19, 22],[43, 50],[67, 78]])
--------------------------------------------------
tensor([[19, 22],[43, 50],[67, 78]])
--------------------------------------------------
tensor([[19, 22],[43, 50],[67, 78]])
--------------------------------------------------
torch.Size([3, 4, 4])
torch.Size([3, 5, 5])
torch.Size([3, 4, 8])

指定运算设备

PyTorch 默认会将张量创建在 CPU 控制的内存中, 即: 默认的运算设备为 CPU。我们也可以将张量创建在
GPU 上, 能够利⽤对于矩阵计算的优势加快模型训练。将张量移动到 GPU 上有两种⽅法:

1. 使⽤ cuda ⽅法

2. 直接在 GPU 上创建张量

3. 使⽤ to ⽅法指定设备

# 1. 使⽤ cuda ⽅法
def test01():data = torch.tensor([10, 20 ,30])print('存储设备:', data.device)
# 如果安装的不是 gpu 版本的 PyTorch
# 或电脑本身没有 NVIDIA 卡的计算环境
# 下⾯代码可能会报错#data = data.cuda()#print('存储设备:', data.device)# 使⽤ cpu 函数将张量移动到 cpu 上data = data.cpu()print('存储设备:', data.device)
# 输出结果:
# 存储设备: cpu
# 存储设备: cuda:0
# 存储设备: cpu
test01()

存储设备: cpu
存储设备: cpu

# 2. 直接将张量创建在 GPU 上
def test02():data = torch.tensor([10, 20, 30], device='cuda:0')print('存储设备:', data.device)
# 使⽤ cpu 函数将张量移动到 cpu 上data = data.cpu()print('存储设备:', data.device)
# 输出结果:
# 存储设备: cuda:0
# 存储设备: cpu
test02()

存储设备: cpu
存储设备: cpu

def test03():data = torch.tensor([10, 20, 30])print('存储设备:', data.device)data = data.to('cuda:0')print('存储设备:', data.device)
# 输出结果:
# 存储设备: cpu
# 存储设备: cuda:0
# 4. 存储在不同设备的张量不能运算
def test04():data1 = torch.tensor([10, 20, 30], device='cuda:0')data2 = torch.tensor([10, 20, 30])print(data1.device, data2.device)
# RuntimeError: Expected all tensors to be on the same device,
# but found at least two devices, cuda:0 and cpu!data = data1 + data2print(data)

张量类型转换

张量转换为numpy数组

使⽤ Tensor.numpy 函数可以将张量转换为 ndarray 数组，但是共享内存，可以使⽤ copy 函数避免共
享。

# 1. 将张量转换为 numpy 数组
def test01():data_tensor = torch.tensor([2, 3, 4])
# 使⽤张量对象中的 numpy 函数进⾏转换data_numpy = data_tensor.numpy()print(type(data_tensor))print(type(data_numpy))
# 注意: data_tensor 和 data_numpy 共享内存
# 修改其中的⼀个，另外⼀个也会发⽣改变
# data_tensor[0] = 100data_numpy[0] = 100print(data_tensor)print(data_numpy)
if __name__ == '__main__':test01()

<class 'torch.Tensor'>
<class 'numpy.ndarray'>
tensor([100,   3,   4])
[100   3   4]

numpy转换为张量

1. 使⽤ torch.from_numpy 可以将 ndarray 数组转换为 Tensor，默认共享内存，使⽤ copy 函数避免共享。

2. 使⽤ torch.tensor 可以将 ndarray 数组转换为 Tensor，默认不共享内存。

def test01():data_numpy = np.array([2, 3, 4])
# 将 numpy 数组转换为张量类型
# 1. from_numpy
# 2. torch.tensor(ndarray)
# 浅拷⻉data_tensor = torch.from_numpy(data_numpy)
# nunpy 和 tensor 共享内存
# data_numpy[0] = 100data_tensor[0] = 100print(data_tensor)print(data_numpy)print(data_tensor.dtype)print(data_numpy.dtype)data_numpy[1] = 200 print(data_tensor)print(data_numpy)test01()
#这个就很神奇，共享内存，一段数据，2个名字，一个numpy，一个tensor.改一种一个数据
#另一个也会改

tensor([100,   3,   4], dtype=torch.int32)
[100   3   4]
torch.int32
int32
tensor([100, 200,   4], dtype=torch.int32)
[100 200   4]

# 2. 使⽤ torch.tensor 函数
def test02():data_numpy = np.array([2, 3, 4])data_tensor = torch.tensor(data_numpy)
# nunpy 和 tensor 不共享内存
# data_numpy[0] = 100data_tensor[0] = 100print(data_tensor)print(data_numpy)
if __name__ == '__main__':test02()

tensor([100,   3,   4], dtype=torch.int32)
[2 3 4]

标量张量和数字的转换

可以通过item取出

def test03():
# 当张量只包含⼀个元素时, 可以通过 item 函数提取出该值data = torch.tensor([30])print(data.item())data = torch.tensor(30)print(data.item())
test03()

30
30

张量拼接操作

张量的拼接操作在神经⽹络搭建过程中是⾮常常⽤的⽅法，例如: 在后⾯将要学习到的残差⽹络、注意⼒机
制中都使⽤到了张量拼接

1. torch.cat 函数可以将两个张量根据指定的维度拼接起来.

2. torch.stack 函数可以将两个张量根据指定的维度叠加起来.

def test():data1 = torch.randint(0, 10, [3, 5, 4])data2 = torch.randint(0, 10, [3, 5, 4])print(data1)print(data2)print('-' * 50)
# 1. 按0维度拼接new_data = torch.cat([data1, data2], dim=0)print(new_data.shape)print('-' * 50)
# 2. 按1维度拼接new_data = torch.cat([data1, data2], dim=1)print(new_data.shape)print('-' * 50)
# 3. 按2维度拼接new_data = torch.cat([data1, data2], dim=2)print(new_data.shape)
if __name__ == '__main__':test()

tensor([[[9, 6, 3, 1],[7, 4, 2, 6],[7, 4, 4, 1],[8, 9, 7, 5],[4, 3, 3, 4]],[[2, 0, 8, 6],[3, 8, 7, 2],[7, 4, 8, 9],[1, 9, 7, 9],[6, 1, 1, 2]],[[2, 9, 7, 5],[8, 7, 7, 0],[9, 4, 6, 6],[3, 3, 1, 7],[6, 7, 1, 6]]])
tensor([[[3, 4, 2, 5],[2, 3, 5, 3],[0, 1, 5, 5],[4, 9, 7, 4],[4, 7, 6, 1]],[[7, 0, 8, 2],[0, 5, 0, 1],[5, 7, 9, 4],[4, 7, 0, 2],[2, 2, 9, 7]],[[0, 6, 3, 6],[6, 7, 2, 7],[1, 9, 2, 4],[5, 2, 3, 6],[9, 6, 5, 2]]])
--------------------------------------------------
torch.Size([6, 5, 4])
--------------------------------------------------
torch.Size([3, 10, 4])
--------------------------------------------------
torch.Size([3, 5, 8])

def test():data1= torch.randint(0, 10, [2, 3])data2= torch.randint(0, 10, [2, 3])print(data1)print(data2)new_data = torch.stack([data1, data2], dim=0)print(new_data.shape)print(new_data)new_data = torch.stack([data1, data2], dim=1)print(new_data.shape)print(new_data)new_data = torch.stack([data1, data2], dim=2)print(new_data.shape)print(new_data)
if __name__ == '__main__':test()

tensor([[1, 9, 1],[9, 3, 6]])
tensor([[6, 8, 7],[4, 8, 1]])
torch.Size([2, 2, 3])
tensor([[[1, 9, 1],[9, 3, 6]],[[6, 8, 7],[4, 8, 1]]])
torch.Size([2, 2, 3])
tensor([[[1, 9, 1],[6, 8, 7]],[[9, 3, 6],[4, 8, 1]]])
torch.Size([2, 3, 2])
tensor([[[1, 6],[9, 8],[1, 7]],[[9, 4],[3, 8],[6, 1]]])