一、传入数据

tensor只能传入数据

可以传入现有的数据列表或矩阵

import torch
# 当是标量时候,即只有一个数据时候,[]括号是可以省略的
torch.tensor(2)
# 输出:
    tensor(2)

# 如果是向量或矩阵,必须有[]括号
torch.tensor([2, 3])
# 输出:
    tensor([2, 3])

Tensor可以传入数据、维度。

建议tensor给数据,Tensor给维度,不然容易把维度和数据搞混淆

# 没有[]时候是指维度,数据是随机初始化的,都接近于0
torch.Tensor(4)
# 输出:
    tensor([0., 0., 0., 0.])

# 当有[]时候是指数据
torch.Tensor([2])
# 输出:
      tensor([2.])

```python
# float类型
torch.FloatTensor(3)
# 输出:
      tensor([0., 0., 0.])

# double类型。
# 一般在增强学习里面用Double类型,因为增强学习对数据精度要求更高。
# 其他地方一般用float类型就够了。精度越高消耗的资源也会越多。
torch.DoubleTensor(3)
# 输出:
    tensor([3.5825e+246, 2.0475e+161, 3.1725e+180], dtype=torch.float64)

二、传入维度的方法

rand

# 传入维度,随机生成相应维度数据
# 生成的数是0~1之间的,随机分布的数据(均匀分布)
# 默认是N(0, 1)均值为0,方差为1
# 推荐使用rand方法初始化数据
torch.rand(2, 3, 2)
# 输出:
    tensor([[[0.0316, 0.3464],
             [0.2537, 0.3074],
             [0.4512, 0.5535]],
    
            [[0.5645, 0.9134],
             [0.7151, 0.2645],
             [0.9773, 0.6580]]])

# 维度可以加括号
torch.rand([2, 3, 2])
# 输出:
    tensor([[[0.3623, 0.7754],
             [0.7515, 0.0527],
             [0.2006, 0.6329]],
    
            [[0.7246, 0.0875],
             [0.8303, 0.2042],
             [0.7149, 0.2826]]])


rand_like

a  = torch.ones(2, 3)
a
# 输出:
    tensor([[1., 1., 1.],
            [1., 1., 1.]])

# 根据a数据的shape来生成随机数据
# 另外还有:ones_like、zeros_like等。
torch.rand_like(a)
# 输出:
    tensor([[0.6721, 0.8581, 0.2823],
            [0.0510, 0.9334, 0.8291]])

randint

# 生成1~10之间随机整数
# [2, 5]是维度
torch.randint(1, 10, [2, 5]) 
# 输出:
    tensor([[8, 2, 5, 5, 2],
            [5, 7, 8, 1, 7]])

normal

# 生成正态分布数据
# 维度2行3列
# 均值为4
# 方差0.6-0.1的数据。方差数据量需要与维度数据量相等:
# 比如此处是2*3=6个数据。方差就是6个数据。
torch.normal(mean=torch.full([2, 3], 4), std=torch.arange(0.6, 0, -0.1))
# 输出:
    tensor([[3.7889, 3.9049, 3.9840],
            [4.1137, 3.9285, 4.0589]])

full

# 生成给定维度,全部数据相等的数据
torch.full([2, 3], 7)
# 输出:
    tensor([[7., 7., 7.],
            [7., 7., 7.]])
# 也可以给定空维度,生成标量
torch.full([], 7)
# 输出:
    tensor(7.)
# 一维,长度为1的向量
torch.full([1], 7)
# 输出:
    tensor([7.])

arange

也可以用 range(),但不推荐

# 生成[0, 10)的tensor
torch.arange(0, 10)
# 输出:
    tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 生成[0, 10)间隔为2的tensor
torch.arange(0, 10, 2)
# 输出:
    tensor([0, 2, 4, 6, 8])

linspace

# 将[0,10]等分切割成4份
torch.linspace(0, 10, steps=4)
# 输出:
    tensor([ 0.0000,  3.3333,  6.6667, 10.0000])

ones

# 给定维度,生成全为1的数据
c = torch.ones(3, 3)
c
# 输出:
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])

ones_like

torch.ones_like(c)
# 输出:
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])

zeros

# 生成全为0的tensor
a = torch.zeros(3, 3) 
a
# 输出:
    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])

zeros_like

torch.zeros_like(a)
# 输出:
    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])

eye

 torch.eye(3, 3)  # 生成对角矩阵
# 输出:
    tensor([[1., 0., 0.],
            [0., 1., 0.],
            [0., 0., 1.]])
 torch.eye(3, 4)  # 若不是方阵,最后多的列会用0填充
# 输出:
    tensor([[1., 0., 0., 0.],
            [0., 1., 0., 0.],
            [0., 0., 1., 0.]])

empty

# 给定维度,随机生成未初始化的数据
# 非常不规则,可能出现非常大,非常小的情况,尽量要覆盖完成数据
torch.empty(1, 2)
# 输出:
    tensor([[        inf, 6.9533e-310]])

randperm

生成随机排序的整数序列

torch.randperm(10)  # 相当于[0, 10) 的随机排序
# 输出:
    tensor([0, 5, 3, 9, 8, 1, 2, 6, 7, 4])

# 定义a、b两个维度相等的数据
a = torch.rand(2, 3)
a
# 输出:
    tensor([[0.5030, 0.5566, 0.5968],
            [0.9044, 0.5012, 0.2717]])
b = torch.rand(2, 3)
b
# 输出:
    tensor([[0.4264, 0.5325, 0.4145],
            [0.6967, 0.1065, 0.0063]])

# 随机生成2个维度数据
idx = torch.randperm(2)
idx
# 输出:
    tensor([1, 0])

# 相当于a、b同时根据随机生成的维度排序+
a[idx]
# 输出:
    tensor([[0.9044, 0.5012, 0.2717],
            [0.5030, 0.5566, 0.5968]])
b[idx]
# 输出:
    tensor([[0.6967, 0.1065, 0.0063],
            [0.4264, 0.5325, 0.4145]])

三、数据维度查看

# 生成数据
a = torch.Tensor(2, 3, 4)
a
# 输出:
    tensor([[[0., 0., 0., 0.],
             [0., 0., 0., 0.],
             [0., 0., 0., 0.]],
    
            [[0., 0., 0., 0.],
             [0., 0., 0., 0.],
             [0., 0., 0., 0.]]])

a.shape  # 注意shape没有括号
# 输出:
    torch.Size([2, 3, 4])

a.size()  # 与shape等价
# 输出:
    torch.Size([2, 3, 4])

a.dim()  # 表示维度
# 输出:
    3

len(a)  # 查看第一维度数据大小
# 输出:
    2

tensor数据内存大小查看

a.numel()
# 输出:
  24  

四、pytorch数据类型

  1. 标量:
    可以理解为常量,没有方向的向量(只有数值,没有方向),dimension=0
    常用于计算loss。预测值与真实值之间误差计算出来就是标量

  2. 张量:
    张量与标量的区别:张量有方向(维度)
    二维:适合线性batch输入,比如:torch.randn(2, 3) # 随机生成2行3列的张量。
    三维:torch.rand(1, 2, 3);三维适合RNN,[10, 20, 100] 20个句子,10个单词,每个单词用一个100维的向量表示
    四维:torch.rand(2, 3, 28, 28) 2张照片,3个通道,照片大小28(h)*28(w);

  3. pytorch数据类型:
    pytorch只支持数字类型数据,不支持字符串类型数据。
    如果要用pytorch来表示string,就将string转换为数字编码(或矩阵、向量)来处理。常用方法:One-hot,Embedding(Word2vec, glove)

pytorch创建tensor数据

tensor和numpy类型互换:

直接将tensor转换为numpy

a = torch.Tensor([2, 3])
a
# 输出:
    tensor([2., 3.])

a.numpy()
# 输出:
   array([2., 3.]) 

将numpy数据转换为张量

import numpy as np

a = np.array([3, 4])
a
# 输出:
    array([3, 4])

torch.from_numpy(a)  
# 输出:
    tensor([3, 4], dtype=torch.int32)

1. tensor数据类型查看

a = torch.Tensor(2)
a.type()  # 查看tensor的数值类型
# 输出:
    'torch.DoubleTensor'

type(a)  # 返回数据类型是tensor,但是不会返回具体的数值类型
# 输出:
    torch.Tensor

2. 判断数字类型是否是指定类型

a = torch.Tensor(2)
# 判断a的数值类型是否是float
isinstance(a, torch.FloatTensor), isinstance(a, torch.DoubleTensor)
# 输出:
    (False, True)

# GPU与CPU数据比较
b = a.cuda()  # 将b布置在GPU上。(数据默认是布置在CPU上的)
# CPU和GPU数据不能直接比较
isinstance(b, torch.FloatTensor), isinstance(b, torch.DoubleTensor)
# 输出:
    (False, False)

# 若要进行比较,需要将数据转换为GPU
isinstance(b, torch.cuda.FloatTensor), isinstance(b, torch.cuda.DoubleTensor)
# 输出:
    (False, True)

设置默认数据类型

1. 设置默认数据类型前

# Tensor默认是Float类型
a = torch.Tensor(2)
a.type()  # 查看数据类型
# 输出:
    'torch.FloatTensor'

a = torch.Tensor([2.])
a.type()
# 输出:
   'torch.FloatTensor' 

# tensor传入整数默认是LongTensor类型
a = torch.tensor(2)
a.type()
# 输出:
    'torch.LongTensor'

# 传入小数,是Float类型
a = torch.tensor(2.)
a.type()
# 输出:
   'torch.FloatTensor' 


2. 设置默认数据类型后

# 设置默认tensor数据类型
torch.set_default_tensor_type(torch.DoubleTensor)

# 即使设置了默认数据类型是double,但是给定的数据中至少要有一个是小数,不然设置会无效
a = torch.tensor([2, 3])
a.type()
# 输出:
    'torch.LongTensor'    

# 加了小数后,数据类型就是设置的默认double类型
b = torch.tensor([2., 3])
b.type()
# 输出:
    'torch.DoubleTensor'