1-pytorch介绍与张量的创建

1. pytorch 官网安装(建议anaconda安装)

pytorch官网
具体安装详见链接anaconda安装

2. tensor

torch.tensor 和 numpy 的区别在于 torch.tensor 可以在GPU上进行加速处理，而numpy只能在CPU上处理，torch.tensor 和 numpy ndarrays 共享内存，方便处理数据

2.1 张量的初始化

• 从列表list中生成张量tensor;(list->tensor)

# 创建一个列表 data 类型 list
data = [[1, 2], [3, 4]]
# 将 list 类型转换成 tensor
tensor_data = torch.tensor(data)
print(f"type(data)={type(data)}")
# 输出结果： type(data)=<class 'list'>
print(f"type(tensor_data)={type(tensor_data)}")
# 输出结果： type(tensor_data)=<class 'torch.Tensor'>

• 从 array 中创建张量tensor(array->tensor)

import torch
import numpy as np

# 创建一个列表 data 类型 list
data = [[1, 2], [3, 4]]
# list 转换成 numpy的array类型
numpy_data = np.array(data)

# 将 list 类型转换成 tensor
tensor_data = torch.tensor(data)

# 将 numpy的array类型转换成 tensor
from_numpy_data = torch.tensor(numpy_data)

print(f"type(data)={type(data)}")
# type(data)=<class 'list'>
print(f"type(tensor_data)={type(tensor_data)}")
# type(tensor_data)=<class 'torch.Tensor'>
print(f"type(numpy_data)={type(numpy_data)}")
# type(numpy_data)=<class 'numpy.ndarray'>
print(f"type(from_numpy_data)={type(from_numpy_data)}")
# type(from_numpy_data)=<class 'torch.Tensor'>

• 创建形状大小相同的全1张量和全0张量

import torch
# 创建一个3行4列的张量
x = torch.arange(12, dtype=torch.float32).reshape(3, 4)
# 创建一个大小跟x一致的全为1的张量
x_ones_like = torch.ones_like(x)
# 创建一个大小跟x一致的全为0的张量
x_zero_like = torch.zeros_like(x)
# 创建一个大小跟x一致的随机数值的张量
x_rand_like = torch.rand_like(x)

print(f"x={x}")
print(f"x.shape={x.shape}")
print(f"x_ones_like={x_ones_like}")
print(f"x_ones_like.shape={x_ones_like.shape}")
print(f"x_zero_like={x_zero_like}")
print(f"x_zero_like.shape={x_zero_like.shape}")
print(f"x_rand_like={x_rand_like}")
print(f"x_rand_like.shape={x_rand_like.shape}")

输出结果：

x=tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]])
x.shape=torch.Size([3, 4])
x_ones_like=tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
x_ones_like.shape=torch.Size([3, 4])
x_zero_like=tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
x_zero_like.shape=torch.Size([3, 4])
x_rand_like=tensor([[0.7255, 0.4085, 0.1030, 0.5015],
        [0.7218, 0.2461, 0.4869, 0.4901],
        [0.8253, 0.6355, 0.7635, 0.4630]])
x_rand_like.shape=torch.Size([3, 4])

• 根据给定形状来创建张量

# 形状的大小是元祖类型
shape_tuple = (2, 2)
# 形状的大小是元祖类型，多了一个逗号，可忽略
shape_tuple_dot = (2, 2,)
# 形状的大小是列表类型
shape_list = [2, 2]
# 形状的大小是列表类型，多了一个逗号，可忽略
shape_list_dot = [2, 2, ]
x_tuple_dot = torch.ones(shape_tuple_dot)
x_tuple = torch.ones(shape_tuple)
x_list_dot = torch.ones(shape_list_dot)
x_list = torch.ones(shape_list)
print(f"x_tuple={x_tuple}")
# 查看 x_tuple的形状
print(f"x_tuple.shape={x_tuple.shape}")
# 查看 x_tuple的类型
print(f"x_tuple.dtype={x_tuple.dtype}")
# 查看 x_tuple在哪里创建
print(f"x_tuple.device={x_tuple.device}")
print(f"x_list={x_list}")
print(f"x_list.shape={x_list.shape}")
print(f"x_tuple_dot={x_tuple_dot}")
print(f"x_tuple_dot.shape={x_tuple_dot.shape}")
print(f"x_list_dot={x_list_dot}")
print(f"x_list_dot.shape={x_list_dot.shape}")

输出结果

x_tuple=tensor([[1., 1.],
        [1., 1.]])
x_tuple.shape=torch.Size([2, 2])
x_tuple.dtype=torch.float32
x_tuple.device=cpu
x_list=tensor([[1., 1.],
        [1., 1.]])
x_list.shape=torch.Size([2, 2])
x_tuple_dot=tensor([[1., 1.],
        [1., 1.]])
x_tuple_dot.shape=torch.Size([2, 2])
x_list_dot=tensor([[1., 1.],
        [1., 1.]])
x_list_dot.shape=torch.Size([2, 2])

• torch.is_tensor 判断输入的是否是张量
• torch.is_nonzero 判断输入的单值是否为0，注意：输入的必须是一个单值，多值则会报错。
• torch.numel(x) 计算张量x中的个数

x = torch.tensor([2,3])

# 判断 x 是否是张量
x_is_tensor = torch.is_tensor(x)
print(f"x_is_tensor={x_is_tensor}")
# x_is_tensor=True
a = torch.tensor([0])
b = torch.tensor([1])
# 判断 a,b 是否是单值非零张量
a_is_nonzero = torch.is_nonzero(a)
b_is_nonzero = torch.is_nonzero(b)
print(f"a_is_nonzero={a_is_nonzero}")
# a_is_nonzero=False
print(f"b_is_nonzero={b_is_nonzero}")
# b_is_nonzero=True
print(f"torch.numel(x)={torch.numel(x)}")
# torch.numel(x)=2

• torch.arange(x) 创建一个一维张量[0,x)
• torch.linspace() 创建一个均匀变化的张量

x_arange = torch.arange(start=2, end=12, step=3)
x_arange_1 = torch.arange(5)
print(f"x_arange={x_arange}")
# x_arange=tensor([ 2,  5,  8, 11])
print(f"x_arange_1={x_arange_1}")
# x_arange=tensor([ 2,  5,  8, 11])


# 创建一个均匀变化的张量，torch.linspace(start=2,end=10,6)
# 创建一个2开头，10结尾，数值个数为6的一维张量，所以间隔为1.6 = (10-2)/(6-1)
x_linspace = torch.linspace(2, 10, 6)
print(f"x_linspace={x_linspace}")
# x_linspace=tensor([ 2.0000,  3.6000,  5.2000,  6.8000,  8.4000, 10.0000])
print(f"x_linspace.numel()={x_linspace.numel()}")
# x_linspace.numel()=6

• torch.eye 创建一个对角线的张量，对角线元素为1，其他值为0
• torch.full((3,4),10) 创建一个3行4列大小的矩阵，其值全部填充为10

# 创建一个对角矩阵，5X5的对角矩阵，对角线上的值都为1，其他为0
x_eye = torch.eye(5)
print(f"x_eye={x_eye}")
# x_eye=tensor([[1., 0., 0., 0., 0.],
#         [0., 1., 0., 0., 0.],
#         [0., 0., 1., 0., 0.],
#         [0., 0., 0., 1., 0.],
#         [0., 0., 0., 0., 1.]])
# 创建一个3行4列矩阵，所有元素填充为10
x_full = torch.full((3,4),10)
print(f"x_full={x_full}")
# x_full=tensor([[10, 10, 10, 10],
#         [10, 10, 10, 10],
#         [10, 10, 10, 10]])

2.2 张量间的操作

• torch.cat(x,y,dim=n)将张量x,张量y按照第n维进行结合在一起

# 创建一个3行4列全为1的张量
x_ones = torch.ones((3,4))
# 创建一个3行4列全为0的张量
y_zeros = torch.zeros((3,4))
# 将x_ones,y_zeros按行进行结合在一起
x_y_dim_0 = torch.cat([x_ones,y_zeros],dim=0)
# 将x_ones,y_zeros按列进行结合在一起
x_y_dim_1 = torch.cat([x_ones,y_zeros],dim=1)
print(f"x_y_dim_0={x_y_dim_0}")
print(f"x_y_dim_1={x_y_dim_1}")

x_y_dim_0=tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
x_y_dim_1=tensor([[1., 1., 1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0.]])