tensor的索引操作 tensor()

Tensor基础

1. Tensor

• Tensor又叫做张量，实际上标量、向量和矩阵都是张量。只是标量是0维张量，向量是一维张量，矩阵是二维张量，除此以外，张量还可以向更高维度扩展，四维五维等等。
• 
  

张量的创建方法

首先需要导入torch的包，使用**torch.Tensor( )**函数创建,传入的参数（2,4）是构造一个2*4的矩阵

import torch
x = torch.Tensor(2,4)

使用**torch.DoubleTensor( )**函数创建一个234的64位浮点数

y = torch.DoubleTensor(2,3,4)

一些快速创建Tensor的方法

torch.zero_(2,4)  # 创建元素全为0的Tensor
torch.eye(3)  # 创建对角线元素全为1，其余元素为0的3*3的Tensor
torch.ones(2,4)  # 创建元素全为1的Tensor
torch.rand(2,4)  # 用于创建将元素初始化为[0,1)的随机数Tensor
torch.arange(1,4,0.5)  # 创建在区间内按照指定步长递增的一维Tensor
torch.from_numpy()   # 将NumPy的ndarray对象转换成Tensor

Tensor中常用的数学操作
add( )方法,包括以下三种加法形式：

a = torch.Tensor({[1, 2, 3], [4, 5, 6]})
b = torch.rand(2, 3)
b.add(a)  # 直接运算
torch.add(a, b)  # 利用torch包的方法
b.add_(a)  # 如果函数带有下划线，返回值将会覆盖原来的对象
"__________________三种加法____________________"
a = torch.rand(3)
a + 2  # 第一种加法形式
torch.add(a, 2)  # 第二种加法形式
a.add(2)  # 第三种加法形式

除此以外，还有

torch.abs()  # 取Tensor每个元素的绝对值
torch.ceil()  # 向上取整
torch.exp()  # 返回每个元素以e为底的指数
torch.max()  # 返回所有元素的最大值

线性代数运算

torch.dot()  # 求两个向量的点积
torch.mv()  # 矩阵与向量相乘
torch.mm()  # 两个矩阵相乘
torch.eig()  # 计算方阵的特征值和特征向量
torch.ger()  # 计算两个张量的张量积
torch.inverse()  # 对方阵求逆

连接和切片

1.连接

a = torch.rand(2, 2)
b = torch.rand(2, 2)
print(a)
print(b)
# 拼接函数cat需要传入两个参数：第一个参数是需要拼接的tensor组成的元组，第二个参数是拼接的维度
print(torch.cat((a,b),0))  # 按照第一个维度拼接，则第二个参数需要传入0
print(torch.cat((a,b),1))  # 按照第二个维度拼接，则第二个参数需要传入1

运行结果为

tensor([[[ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00],
         [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00],
         [5.4323e-311, 2.1990e-308, 1.5342e-319, 2.2131e-308]],

        [[        nan, 2.1903e-308, 1.5316e-319, 2.1903e-308],
         [1.5316e-319, 2.1903e-308, 1.5316e-319, 2.1903e-308],
         [1.5316e-319, 2.1903e-308, 1.5316e-319, 2.1903e-308]]],
       dtype=torch.float64)
tensor([[0.6106, 0.9396],
        [0.6980, 0.1699]])
tensor([[0.8052, 0.7393],
        [0.0585, 0.7705]])
tensor([[0.6106, 0.9396],
        [0.6980, 0.1699],
        [0.8052, 0.7393],
        [0.0585, 0.7705]])
tensor([[0.6106, 0.9396, 0.8052, 0.7393],
        [0.6980, 0.1699, 0.0585, 0.7705]])

2.切片
切片函数torch.chunk( )需要传入三个函数，第一个是需要切片的Tensor对象，第二个参数是被切分的块数，第三个参数是切分的维度
函数torch.t( )负责求转置矩阵，不过只适合于二维的tensor

c = torch.rand(2, 4)
print(c)
print(torch.chunk(c, 2, 1))
print(torch.t(c))

结果如下：

tensor([[0.3695, 0.9640, 0.6598, 0.3485],
        [0.3169, 0.7920, 0.3817, 0.9554]])
(tensor([[0.3695, 0.9640],
        [0.3169, 0.7920]]), tensor([[0.6598, 0.3485],
        [0.3817, 0.9554]]))
tensor([[0.3695, 0.3169],
        [0.9640, 0.7920],
        [0.6598, 0.3817],
        [0.3485, 0.9554]])

变形

x = torch.rand(2, 3, 4)
print(x)
y = x.view(2, 12)  # 转换成一个2*12的Tensor
print(y)
z = x.view(-1, 1)  # -1作为参数时，代表该维度自动计算，代码表示第一维自动运算，得到24*1的Tensor
print(z)

运行结果太占地方，就不演示了

cuda加速

print(torch.cuda.is_available())

如果输出为True，恭喜你，你可以使用GPU进行加速计算

检查GPu是否安装CUDA，进行CUDA加速，输入测试代码，如果是False，则有两种情况：要么就是计算机没有支持CUDA的NVIDIA显卡，要么就是显卡驱动没有安装成功。

为了比较GPU和CPU的计算速度差距，做一个小测试来实验一下，我们以100010000的矩阵与1000010000矩阵相乘为例，对比他们两个所花费的时间，具体代码如下：

import torch
from time import perf_counter
x = torch.rand(1000, 10000)
y = torch.rand(10000, 10000)
# CPU
start = perf_counter()
x.mm(y)
finish = perf_counter()
time = finish - start
print("CPU计算时间:%s" % time)
# GPU
if torch.cuda.is_available():
    x = x.cuda()
    y = y.cuda()
    start = perf_counter()
    x.mm(y)
    finish = perf_counter()
    time_cuda = finish - start
    print("GPU加速计算的时间:%s" % time_cuda)
    print("CPU计算时间是GPU加速计算时间的%s倍" % str(time / time_cuda))
else:
    print("未支持CUDA")

输出结果如下：

CPU计算时间:0.45977439999999997
GPU加速计算的时间:0.42851169999999983
CPU计算时间是GPU加速计算时间的1.0729564676997154倍

搞不懂为什么我的GPU这么慢！！！只比CPU快一点点，是不是与电脑配置有关系，懂得小伙伴评论区告我一声啊

2. Autograd

Autograd是自动微分也就是自动求导，后面会用到特别多，具体在以后学习中再介绍。