PyTorch中的Tensor

程序员文章站 2022-07-13 10:11:33

...

Tensor 与 Variable

Variable

torch.autograd.Variable()

Variable 是torch.autograd中的数据类型(但目前已并入Tensor), 主要用于封装tensor, 进行自动求导

data: 被包装的tensor
grad: data 的梯度
grad_fn: 创建Tensor的Function(加法，乘法等), 是自动求导的关键
requires_grad: 指示是否需要梯度
is_leaf: 指示是否是叶子结点(张量)

Tensor

PyTorch0.4.0版开始，Variable并入Tensor

data, grad, grad_fn, requires_grad, is_leaf 同上
dtype：张量的数据类型，如torch.FloatTensor（32位）, torch.cuda.FloatTensor
shape: 张量的形状，如(64, 3, 255, 255)
device: 张量所在设备， GPU/CPU

Tensor的创建

一：直接创建

1.1 torch.tensor()

torch.tensor(
			data,
			dytpe=None,
			device=none，
			requires_grad=False,
			pin_memory=False)

功能: 从data创建tensor

参数:

data: 数据，可以是list， numpy
dtype: 数据类型，默认与data一致
device: 所在设备， cuda/cpu
requires_grad: 是否需要梯度
pin_memory: 是否存于锁页内存

import torch
import numpy as np

# 通过torch.tensor 创建张量
flag = True
if flag:
    arr = np.ones((3, 3))
    print('ndarry的数据类型: ', arr.dtype)
    t1 = torch.tensor(arr, device='cuda')
    t2 = torch.tensor(arr)
    print('t1=', t1)
    print('t2=', t2)
    
>>>
ndarry的数据类型:  float64
t1= tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], device='cuda:0', dtype=torch.float64)
t2= tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)

‘cuda:0’: 0是因为本地只有1个GPU

1.2 torch.from_numpy()

torch.from_numpy(ndarray)

功能：从numpy创建tensor

注意事项: 从tensor.from_numpy创建的tensor与原ndarray共享内存，当修改其中一个的数据，另一个也将被改动

flag = True
if flag:
    arr = np.array([[1, 2, 3], [4, 5, 6]])
    t = torch.from_numpy(arr)
    print('numpy array: ', arr)
    print('tensor: ', t)
    
    print('\n修改arr')
    arr[0, 0] = 0
    print('numpy array: ', arr)
    print('tensor: ', t)
    
    print('\n修改tensor')
    arr[0, 0] = -1
    print('numpy array: ', arr)
    print('tensor: ', t)
    # arr 和 t 的地址不同
    print(id(arr) == id(t))
>>>
numpy array:  [[1 2 3]
 [4 5 6]]
tensor:  tensor([[1, 2, 3],
        [4, 5, 6]], dtype=torch.int32)

修改arr
numpy array:  [[0 2 3]
 [4 5 6]]
tensor:  tensor([[0, 2, 3],
        [4, 5, 6]], dtype=torch.int32)

修改tensor
numpy array:  [[-1  2  3]
 [ 4  5  6]]
tensor:  tensor([[-1,  2,  3],
        [ 4,  5,  6]], dtype=torch.int32)
False

二、依据数值创建

2.1 torch.zeros()

torch.zeros(*size,
			out=None,
			dtype=None,
			layout=torch.strided,
			device=None,
			requires_grad=False)

功能: 依size创建全0张量
参数:

size: 张量的形状，如(3, 3), (3, 224, 224)
out: 输出的张量
layout: 内存中布局形式, 有strided, sparse_coo(稀疏张量时设置，可以提供效率)等
device: 所在设备， gpu/cpu
requires_grad: 是否需要梯度

# 通过torch.zeros 创建张量

flag = True
if flag:
    out_t = torch.tensor([1])
    print('out_t: ', out_t)
    # t和out_t是同一个数据， out将torch。zeros生成的张量t赋给了out_t
    t = torch.zeros((3, 3), out=out_t)
    
    print('out_t: ', out_t)
    print('t: ', t)
    print('id(out_t): ', id(out_t))
    print('id(t): ', id(t))
    print(id(out_t) == id(t))
>>>
out_t:  tensor([1])
out_t:  tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
t:  tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
id(out_t):  2227084130560
id(t):  2227084130560
True

2.2 torch.zeros_like()

torch.zeros_like(input, 
				dtype=None,
				layout=None,
				device=None,
				requires_grad=False)

功能: 依input形状创建全0张量
参数:

input: 创建与input同形状的全0张量
dtype: 数据类型
layout: 内存中的布局形式

2.3 torch.ones()

torch.ones(*size,
			out=Noen,
			dtype=None, 
			layout=torch,strided,
			device=None,
			requires_grad=False)

2.4 torch.ones_like()

torch.ones_like(input,
				dtype=None, 
				layout=None,
				device=None, 
				require_grad=False)

功能: 依input形状创建全1张量
参数

size: 张量的形状, 如(3, 3), (3, 224, 224)
input: 创建与input同形状的全1张量
dtype: 数据类型
layout: 内存中的布局形式
requires_grad: 是否需要梯度

2.5 torch.full()

torch.full(size,
			fill_value,
			out=Noen,
			dtype=None, 
			layout=torch,strided,
			device=None,
			requires_grad=False)

功能: 依input创建全fill_valu的值
参数

size：张量的形状, 如（3, 3）
fill_value: 张量的值

flag = True
if flag:
    t = torch.full((3, 3), 5)
    print(t)
>>>
tensor([[5., 5., 5.],
        [5., 5., 5.],
        [5., 5., 5.]])

2.6 torch.full_like()

2.7 torch.arange()

torch.arange(start=0,
			end,
			step=1,
			out=None,
			dtype=None, 
			layout=torch.strided,
			device=None,
			requires_grad=False)

功能: 创建等差的1维张量
注意事项: 数值区间为[start, end）
参数:

start: 数列起始值
end: 数列结束值，取不到
step: 数列公差，默认为1

flag = True
if flag:
    # 创建一个偶数列
    t = torch.arange(0, 10, 2)
    print(t)
>>>
tensor([0, 2, 4, 6, 8])

2.8 torch.linspace()

torch.linspace(start, 
				end,
				steps=100,
				out=None,
				dtype=None, 
				layout=torch.strided,
				device=None,
				requires_grad=False)

功能: 创建均分的1维张量
注意事项: 数值区间是[start, end]
参数:

start: 数列起始值
end: 数列的结束值
steps：数列长度

flag = True
if flag:
    t = torch.linspace(0, 10, 5)
    print(t)
>>>
tensor([ 0.0000,  2.5000,  5.0000,  7.5000, 10.0000])

2.9 torch.logspace()

torch.logspace(strat,
				end,
				steps=100,
				base=10.0,
				out=None,
				dtype=None,
				layout=torch.strided,
				device=None,
				requires_grad=False)

功能: 创建对数均分的1维张量
注意事项: 长度为steps，底为base
参数:

start: 数列起始值
end: 数列的结束值
steps: 数列长度
base: 对数函数的底，默认为10

2.10 torch.eye()

torch.eye(n,
		m=None,
		out=None,
		dtype=None,
		layout=torch.strided,
		device=None,
		requires_grad=False)

功能: 创建单位对角矩阵（2维张量）
注意事项: 默认方阵
参数:

n: 矩阵行数
m: 矩阵列数

三、依概率分布创建张量

3.1 torch.normal()

torch.normal(mean,
			std,
			out=None)
			
torch.normal(mean,
			std,
			size,
			out=None)

功能：生成正态分布
参数：

mean: 均值
std: 标准差
四种模式:
mean是标量， std是标量 (没能运行成功，可能版本问题)
mean是标量， std是张量
mean是张量， std是标量
mean是张量， std是张量

flag = True
if flag:
    # mean: 张量； std: 张量
    mean = torch.arange(1, 5, dtype=torch.float)
    std = torch.arange(1, 5, dtype=torch.float)
    t_normal1 = torch.normal(mean, std)
    print('mean:{}\nstd:{}'.format(mean, std))
    print(t_normal1)
    
    # mean： 张量， std： 标量
    t_normal2 = torch.normal(mean, 1)
    print(t_normal2)
    
    # mean： 标量， std： 张量
    t_normal2 = torch.normal(0., std)
    print(t_normal2)
>>>
mean:tensor([1., 2., 3., 4.])
std:tensor([1., 2., 3., 4.])
tensor([1.5164, 0.7705, 9.4894, 0.7906])
tensor([0.6021, 1.2874, 2.5276, 3.1236])
tensor([-1.2483, -1.6057,  3.2328, -0.6405])

3.2 torch.randn()

torch.randn(*size,
			out=Noen,
			dtype=None, 
			layout=torch,strided,
			device=None,
			requires_grad=False)

功能: 生成标准正态分布
参数:

size: 张量的形状

3.3 torch.randn_like()

3.4 torch.rand()

torch.rand(*size,
			out=Noen,
			dtype=None, 
			layout=torch,strided,
			device=None,
			requires_grad=False)

功能: 再区间[0, 1)上，生成均匀分布

3.5 torch.rand_like()

3.6 torch.randint()

torch.randint(low=0,
			high,
			size,
			out=Noen,
			dtype=None, 
			layout=torch,strided,
			device=None,
			requires_grad=False)

功能: 区间[low, high)上生成整数均匀分布
参数:

size: 张量的形状

3.8 torch.randperm()

torch.randperm(n,
			out=Noen,
			dtype=None, 
			layout=torch,strided,
			device=None,
			requires_grad=False)

功能: 生成从0到n-1的随机排列
参数:

n: 张量的长度

3.9 torch.bernoulli()

torch.bernoulli(input,
				*,
				generator=None,
				out=None)

功能: 以input为概率，生成伯努利分布(0-1分布，两点分布)
参数:

input: 概率值