一、基本数据类型与用法
1.torch.tensor(张量)
按照维度不同(中括号的对数)，可以用torch.tensor创建scalar(标量)、vector(向量)、matrix(矩阵)，
一般的，一维是标量，二维是向量，三维是矩阵，n维是张量(包含1~3维)
# code:
scalar = torch.tensor(7)
vector = torch.tensor(3, 4)
matrix = torch.tensor(\[1, 2,
3, 4])
print(scalar.ndim)
print(vector.ndim)
print(matrix.ndim)
print(scalar.shape)
print(vector.shape)
print(matrix.shape)
# out:
0
1
2
torch.Size(\[\])
torch.Size(2)
torch.Size(2, 2)
2.random_tensor(随机张量)
随机张量在深度学习中经常使用，在为每个神经网络进行初始化赋值时，就是用随机张量矩阵为每个节点赋予一个初始值，用法为torch.rand，参数为张量矩阵形状，生成结果为一个随机数组成的张量矩阵。
# code:
random_tensor = torch.rand(3,4)
random_tensor
# out:
tensor([[0.3376, 0.6243, 0.1119, 0.2120], [0.5750, 0.4984, 0.5371, 0.4670], [0.0507, 0.3727, 0.0362, 0.0290]])
3.torch.ones和torch.zeros
这两个方法分别用来创建内容全为1或全为0的张量矩阵，用法同rand类似。
# code:
zeros = torch.zeros(3,4)
zeros
# out:
tensor([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])# code:
zeros = torch.ones(3,4)
zeros
# out:
tensor([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]])
4.常用tensor属性
shape表示矩阵形状，ndim表示张量维度(中括号对数)，dtype表示张量数据类型(默认为float32)，其中shape属性获取结果与zeros.size()方法获取结果相同。
# code:
zeros = torch.ones(3,4)
print(zeros.shape)
print(zeros.ndim)
print(zeros.dtype)
# out:
torch.Size(3, 4)
2
torch.float32
dtype可以在创建张量时指定，如tensor=torch.tensor(1,2,3,dtype=float16)，它们指定了计算的精度；dtype常用类型包括float32(单精度)、float16(半精度)、float64(双精度)。 若要更改dtype，可以调用to()方法进行修改
device属性在创建张量时默认为cpu，若要采用gpu加速，将其设置为cuda。
tensor = torch.tensor(1,2,3, dtype=float64, device='cuda')
tensor.to(torch.float16)
5.torch.arange
创建一个从指定位置出发，到指定范围结束的张量，可以设置间隔。
# code:
rangeTensor = torch.arange(1, 20, 4)
rangeTensor
# out:
tensor([ 1, 5, 9, 13, 17])
6.torch.zeros_like与torch.ones_like
创建与指定张量相同形状的张量，内容分别为0和1，结果的dtype为int64
# code:
rangeTensor = torch.tensor(\[1,2,3,
4,5,6])
tensorLike = torch.ones_like(rangeTensor)
tensorLike
# out:
tensor([[1, 1, 1], [1, 1, 1]])# code:
rangeTensor = torch.tensor(\[1,2,3,
4,5,6])
tensorLike = torch.zeros_like(rangeTensor)
tensorLike
# out:
tensor([[0, 0, 0], [0, 0, 0]])
7.张量与常数的运算
张量与常数的运算遵循广播机制，即张量会对所有元素进行相应运算。
运算有两种方式，一种是直接用python运算符，另一种是用torch提供的方法执行，但一般推荐直接使用运算符，因为二者结果相同，运算符操作更为直观。
# code:
tensor = torch.tensor(4,6,8)
print(tensor+3)
print(tensor*3)
print(torch.add(tensor, 3))
print(torch.mul(tensor, 3))
# out:
tensor( 7, 9, 11)
tensor(12, 18, 24)
tensor( 7, 9, 11)
tensor(12, 18, 24)
8.张量与张量的运算
①矩阵元素运算
矩阵的加减乘除需要满足两矩阵形状相同，加减时对应位置元素相加减乘除。
# code:
tensor1 = torch.tensor(4,6,8)
tensor2 = torch.tensor(2,4,7)
tensor1 + tensor2
# out:
tensor([ 6, 10, 15])
②矩阵乘法
矩阵乘法又被称为"点积"，和矩阵元素相乘不同，其运算过程如下图:
# code:
tensor1 = torch.tensor(\[1, 2, 3,
4, 5, 6])
tensor2 = torch.tensor(\[1, 4, 7,
2, 5, 8,
2, 3, 4])
torch.matmul(tensor1, tensor2)
# out:
tensor([[11, 23, 35], [26, 59, 92]])
需要注意的一点是不是任何矩阵都能直接相乘，前提条件是第一个矩阵的列数要等于第二个矩阵的行数，如(2, 3)的矩阵可与(3, 1)的矩阵进行点积运算。
事实上，使用tensor运算就是因为矩阵相乘在计算机上的运算效率要高于循环运算数千倍，正因如此，也造就了当今各大框架都以tensor为基本运算单元的现状。 以下是一段速度对比代码：
# code:
import torch
import time
import numpy as np
定义矩阵大小
matrix_size = 100
生成两个随机矩阵
tensor1 = torch.rand(matrix_size, matrix_size)
tensor2 = torch.rand(matrix_size, matrix_size)
使用张量的点积运算
start_time = time.time()
result_tensor = torch.matmul(tensor1, tensor2)
end_time = time.time()
tensor_time = end_time - start_time
使用传统的循环运算计算点积
start_time = time.time()
result_loop = torch.zeros((matrix_size, matrix_size))
for i in range(matrix_size):
for j in range(matrix_size):
result_loopi, j = sum(tensor1i, : * tensor2:, j)
end_time = time.time()
loop_time = end_time - start_time
输出执行时间
print("张量点积运算时间:", tensor_time)
print("传统循环运算时间:", loop_time)
out:
张量点积运算时间: 0.0005884170532226562
传统循环运算时间: 5.478101968765259
剩余部分正在学习中......