pytorch深度学习入门与实战代码与标注（一）

# _*_ coding: utf-8 _*_
"""
Time:     2021/11/13 21:14
Author:   LucifMonX
Version:  V 3.9
File:     第一章 入门篇.py.py
Describe: 入门简单介绍相关元素
"""
import torch

# 输出pytorch版本
print(torch.__version__)  # 1.9.0
print('--------------------1.张量Tensor--------------')
'''
数学中：
标量：一个单独的数
向量：一列或一行数组
矩阵：二维数组
若数组的维度超过2，则称该数组为Tensor张量
但在pytorch中，tensor包括了前面所有，甚至更高维度的数组
'''
# 1.1张量的数据类型
# 获取张量的数据类型 使用torch.tensor()函数生成一个张量，然后使用.dtype方法获取张量 torch中默认的数据类型是32位浮点型
torch_type = torch.tensor([1.2, 3.4]).dtype
print(torch_type)  # torch.float32
# 将张量的默认数据类型设置为双精度浮点double
torch.set_default_tensor_type(torch.DoubleTensor)
torch_type = torch.tensor([1.2, 3.4]).dtype
print(torch_type)  # torch.float64
# 还有其他数据类型
a = torch.tensor([1.2, 3.4])
print("a的数据类型(由于26行设置成64位浮点):", a.dtype)  # a的数据类型(由于26行设置成64位浮点): torch.float64
print("a转换成 长整型long:", a.long().dtype)  # a转换成 长整型long: torch.int64
print("a转换成 整型int:", a.int().dtype)  # a转换成 整型int: torch.int32
print("a转换成 32浮点数float:", a.float().dtype)  # a转换成 32浮点数float: torch.float32
# 设置回32位浮点float
torch.set_default_tensor_type(torch.FloatTensor)
# 获取默认的数据类型
print(torch.get_default_dtype())# torch.float32
# 1.2 张量的生成
# 1.2.1 使用torch.tensor()函数生成张量
A = torch.tensor([[1.0, 1.0], [2, 2]])
print(A)
'''
tensor([[1., 1.],
        [2., 2.]])
'''
# 获取张量的维度
print(A.shape)#torch.Size([2, 2])
# 获取张量的形状大小
print(A.size())# torch.Size([2, 2])
# 计算张量中包含的元素数量
print(A.numel())#4
# 在使用torch.tensor()函数时，可以使用参数dtype来指定张量的数据类型，使用参数requires_grad来指定张量是否需要计算梯度
B = torch.tensor((1, 2, 3), dtype=torch.float32, requires_grad=True)
print(B)#tensor([1., 2., 3.], requires_grad=True)
# 因为张量B是可以计算梯度的，故可以计算sum(B**2)的梯度
y = B.pow(2).sum()
y.backward()
print(y)#tensor(14., grad_fn=)
print(B.grad)#tensor([2., 4., 6.])
# 只有浮点类型的张量允许计算梯度
# B = torch.tensor((1, 2, 3), dtype=torch.int32,
#                  requires_grad=True)  # RuntimeError: Only Tensors of floating point and complex dtype can require gradients
# 1.2.2 torch.Tensor() 也可以生成张量
C = torch.Tensor([1, 2, 3, 4])
print(C)#tensor([1., 2., 3., 4.])
# 根据形状参数生成特定尺寸的张量
D = torch.Tensor(2, 3)
print(D)
'''
tensor([[0., 0., 0.],
        [0., 0., 0.]])
'''
# 使用torch.ones_like()函数生成与指定张量维度相同，性质相似的全1张量
E = torch.ones_like(D)
print(E)
'''
tensor([[1., 1., 1.],
        [1., 1., 1.]])
'''
# 使用torch.zeros_like()函数生成与指定张量维度相同，性质相似的全0张量
F = torch.zeros_like(D)
print(F)
'''
tensor([[0., 0., 0.],
        [0., 0., 0.]])
'''
# 使用torch.rand_like()生成与D维度相同的随机张量
G = torch.rand_like(D)
print(G)
'''
tensor([[0.3603, 0.6763, 0.3772],
        [0.6505, 0.4359, 0.5046]])
'''
# 针对一个创建好的张量D，可以使用.new_**()创建出新的张量。 使用D.new_tensor(e)将列表E转换为32位浮点型张量
e = [[1, 2], [3, 4]]
e = D.new_tensor(e)
print(D.dtype, E.dtype)#torch.float32 torch.float32
# 张量和Numpy数据相互转换 可以使用torch.as_tensor()函数和torch.from_numpy()函数
# 利用Numpy数组生成张量
import numpy as np

F = np.ones((3, 3))
print(F)
'''
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
'''
# 使用torch.as_tensor()函数
Ftensor = torch.as_tensor(F)
print(Ftensor)
'''
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
'''
# 使用torch.from_numpy()函数
Ftensor = torch.from_numpy(F)
print(F)
'''
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
'''
# 使用torch.numpy()函数转化成Numpy数组
Ftensor.numpy()
print(Ftensor)
'''
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
'''
# 随机数生成张量并可以指定生成随机数的分布函数等,
# 在生成随机数之前，可以使用torch.manual_seed()函数，指定生成随机数的种子，用于保证生成的随机数是可以重复出现的
# 如使用torch.normal()生成服从01正态分布的随机数
torch.manual_seed(123)
A = torch.normal(mean=0.0, std=torch.tensor(1.0))
print(A)#tensor(-0.1115)
# torch.normal()函数中，通过mean参数指定随机数的均值，std参数指定随机数的标准差，如果mean参数和std参数都只有一个元素则只会生成一个随机数；如果有多个值，则可生成多个随机数
torch.manual_seed(123)
A = torch.normal(mean=0.0, std=torch.arange(1, 5.0))
print(A)#tensor([-0.1115,  0.2407, -1.1089, -0.9617])
# 上面例子中，每个随机数服从的分布均值是0,但他们分布的标准差分别是1、2、3、4.当然也可以分别指定每个随机数服从的均值
torch.manual_seed(123)
A = torch.normal(mean=torch.arange(1, 5.0), std=torch.arange(1, 5.0))
print(A)#tensor([0.8885, 2.2407, 1.8911, 3.0383])
# 也可以使用torch.rand()函数，区间[0,1]上生成服从均匀分布的张量
torch.manual_seed(123)
B = torch.rand(3, 4)
print(B)
'''
tensor([[0.2961, 0.5166, 0.2517, 0.6886],
        [0.0740, 0.8665, 0.1366, 0.1025],
        [0.1841, 0.7264, 0.3153, 0.6871]])
'''
# torch.rand_like函数，则可根据其他张量维度，生成与其他维度相同的随机数张量
torch.manual_seed(123)
C = torch.ones(2, 3)
D = torch.rand_like(C)
print(D)
'''
tensor([[0.2961, 0.5166, 0.2517],
        [0.6886, 0.0740, 0.8665]])
'''
# 使用torch.randn()和torch.randn_like()函数则可生成服从标准正态分布的随机数张量
print(torch.randn(3, 3))
'''
tensor([[ 0.9447,  0.6217, -1.3501],
        [-0.1881, -2.3891, -0.4759],
        [ 1.7603,  0.6547,  0.5490]])
'''
print(torch.randn_like(C))
'''
tensor([[ 0.3671,  0.1219,  0.6466],
        [-1.4168,  0.8429, -0.6307]])
'''
# 将0~9这10个数字的整数随机排序
torch.manual_seed(123)
print(torch.randperm(10))#tensor([2, 0, 8, 1, 3, 7, 4, 9, 5, 6])
# 其他生成张量的函数
# 使用torch.arange()生成张量 参数从start开始，在参数end指定结束。step为指定步长。
print(torch.arange(start=0, end=10, step=2))#tensor([0, 2, 4, 6, 8])
# 可使用torch.linspace()函数在范围内生成固定数量的等间隔张量
print(torch.linspace(start=1, end=10, steps=5))#tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])
# 使用torch.logspace()函数生成以对数为间隔的张量
print(torch.logspace(start=0.1, end=1.0, steps=5))#tensor([ 1.2589,  2.1135,  3.5481,  5.9566, 10.0000])
# 常用的生成张量系列函数
# 3*3的全0张量
print(torch.zeros(3, 3))
'''
tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
'''
# 3*3的全1张量
print(torch.ones(3, 3))
'''
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])
'''
# 3*3的单位张量
print(torch.eye(3))
'''
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])
'''
# 3*3使用0.25填充的张量
print(torch.full((3, 3), fill_value=0.25))
'''
tensor([[0.2500, 0.2500, 0.2500],
        [0.2500, 0.2500, 0.2500],
        [0.2500, 0.2500, 0.2500]])
'''
# 3*3的空张量
print(torch.empty(3, 3))
'''
tensor([[0.9447, 0.6217, 1.3501],
        [0.1881, 2.3891, 0.4759],
        [1.7603, 0.6547, 0.5490]])
'''
# 1.2 张量操作
# 使用tensor.reshape()方法设置张量的形状大小
A = torch.arange(12.0)
print(A)#tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11.])
A = A.reshape(3, 4)
print(A)
'''
tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]])
'''
# 或者直接通过torch.reshape()函数改变输入张量的形状 torch.reshape(input,shape)：传入的参数可以有一个-1，表示其具体值由其他维度信息和元素总个数推断出来。
print(torch.reshape(input=A, shape=(2, -1)))
'''
tensor([[ 0.,  1.,  2.,  3.,  4.,  5.],
        [ 6.,  7.,  8.,  9., 10., 11.]])
'''
# 用resize_()方法改变张量的形状
A = A.resize_(2, 6)
print(A)
'''
tensor([[ 0.,  1.,  2.,  3.,  4.,  5.],
        [ 6.,  7.,  8.,  9., 10., 11.]])
'''
# A.resize_as_(B)方法，可以将张量A的形状尺寸，设置为跟张量B相同的形状大小
B = torch.arange(10.0, 19.0).reshape(3, 3)
print(B)
'''
tensor([[10., 11., 12.],
        [13., 14., 15.],
        [16., 17., 18.]])
'''
print(A.resize_as_(B))
'''
tensor([[0., 1., 2.],
        [3., 4., 5.],
        [6., 7., 8.]])
'''
# torch.unsqueeze()函数在指定维度插入尺寸为1的新张量
A = torch.arange(12.0).reshape(2, 6)
print(A)
'''
tensor([[ 0.,  1.,  2.,  3.,  4.,  5.],
        [ 6.,  7.,  8.,  9., 10., 11.]])
'''
B = torch.unsqueeze(A, dim=0)
print(B.shape)#torch.Size([1, 2, 6])
# torch.squeeze()函数移除所有维度为1的维度
C = B.unsqueeze(dim=3)
print("C.shape:", C.shape)#C.shape: torch.Size([1, 2, 6, 1])
D = torch.squeeze(C)
print("D.shape:", D.shape)#D.shape: torch.Size([2, 6])
# 移除指定维度为1的维度
E = torch.squeeze(C, dim=0)#E.shape: torch.Size([2, 6, 1])
print("E.shape:", E.shape)
# 使用.expand()方法拓展张量
A = torch.arange(3)
B = A.expand(3, -1)
print(B)
'''
tensor([[0, 1, 2],
        [0, 1, 2],
        [0, 1, 2]])
'''
# 使用.expand_as()方法拓展张量
C = torch.arange(6).reshape(2, 3)
B = A.expand_as(C)
print(B)
'''
tensor([[0, 1, 2],
        [0, 1, 2]])
'''

gitee:https://gitee.com/orange_xiao_victor_admin/deep-learning_-ai