pytorch-tensor张量

torch

目录

• torch
  • • 张量
    • tensor的几种属性
    • 内置类型
      • torch.type()
      • type_as()
      • 设置默认类型
      • 类型转换
    • 创建tensor
      • 创建Tensor时指明数据类型
      • 获取数据类型
      • 转换数据类型
      • torch.tensor(data)
      • torch.from_numpy(ndarray)
      • tensor.tolist()
      • tensor.numpy()
    • 创建指定张量
  • 随机操作

张量

张量（Tensor）是线性代数中的一种数据结构，是向量和矩阵的推广，我们可以在张量上进行算术运算。Tensors 类似于 NumPy 的 ndarrays ，同时 Tensors 可以使用 GPU 进行计算

判断是否是张量

import torch

var_1 = 1
print(torch.is_tensor(var_1)) 
# False

tensor的几种属性

	属性	描述
	tensor.data	存储的数据
	tensor.type()		有括号，其他的没有
	tensor.shape
	tensor.device
	tensor.requires_grad
	tenor.grad

内置类型

	type	CPU	GPU
	torch.float32	torch.FloatTensor	torch.cuda.FloatTensor
	torch.float64	torch.DoubleTensor	torch.cuda.DoubleTensor
	torch.float16	torch.HalfTensor	torch.HalfTensor
	torch.uint8	torch.ByteTensor	torch.cuda.ByteTensor
	torch.int8	torch.CharTensor	torch.cuda.CharTensor
	torch.int16	torch.ShortTensor	torch.cuda.ShortTensor
	torch.int32	torch.IntTensor	torch.cuda.IntTensor
	torch.int64	torch.LongTensor	torch.cuda.LongTensor
	torch.bool	torch.BoolTensor	torch.cuda.BoolTensor

torch.type()

t1 = torch.LongTensor(3, 5)
print(t1.type())
# 转换为其他类型
t2=t1.type(torch.FloatTensor)
print(t2.type())
 
 
torch.LongTensor
torch.FloatTensor

type_as()

t1=torch.Tensor(2,3)
t2=torch.IntTensor(3,5)
t3=t1.type_as(t2)
print(t3.type())
 
torch.IntTensor

设置默认类型

torch.set_default_tensor_type(torch.FloatTensor)

torch.get_default_dtype()
#  torch.float32

类型转换

import torch
 
tensor = torch.randn(2, 2)
print(tensor.type())
 
# torch.long() 将tensor转换为long类型
long_tensor = tensor.long()
print(long_tensor.type())
 
# torch.half()将tensor转换为半精度浮点类型
half_tensor = tensor.half()
print(half_tensor.type())
 
# torch.int()将该tensor转换为int类型
int_tensor = tensor.int()
print(int_tensor.type())
 
# torch.double()将该tensor转换为double类型
double_tensor = tensor.double()
print(double_tensor.type())
 
# torch.float()将该tensor转换为float类型
float_tensor = tensor.float()
print(float_tensor.type())
 
# torch.char()将该tensor转换为char类型
char_tensor = tensor.char()
print(char_tensor.type())
 
# torch.byte()将该tensor转换为byte类型
byte_tensor = tensor.byte()
print(byte_tensor.type())
 
# torch.short()将该tensor转换为short类型
short_tensor = tensor.short()
print(short_tensor.type())
 
    
torch.FloatTensor
torch.LongTensor
torch.HalfTensor
torch.IntTensor
torch.DoubleTensor
torch.FloatTensor
torch.CharTensor
torch.ByteTensor
torch.ShortTensor

创建tensor

创建Tensor时指明数据类型

import torch

double_points = torch.ones((10, 2), dtype=torch.double)
short_points = torch.tensor([[1,2],[3,4]], dtype=torch.short)

获取数据类型

tensor.type()

tenor=torch.tensor([1,2,3]).type()
torch.set_default_tensor_type(torch.FloatTensor)
tenor2=torch.tensor([1.2, 3]).type() 
print(tenor)
print(tenor2)

torch.LongTensor
torch.FloatTensor

转换数据类型

3种方式

import torch
# （1）直接在tensor后面接.dtype()进行转换

double_points = torch.zeros(10,2).double()

# （2）使用to进行转换
double_points = torch.zeros(10,2).to(torch.double)

# （3）使用type()进行转换
double_points = torch.zeros(10,2).type(torch.short)

torch.tensor(data)

data 可以是list, numpy

torch.tensor( data, dtype=None, device=None, requires_grad=False, pin_memory=False)
"""
data就是张量中存储的数据，可以是list，numpy；
dtype数据类型默认和data一致；
device所在设备（cuda or cpu）；
requires_grad是否需要计算梯度
"""

import torch
import numpy as np
 
# 创建numpy数据
arry = np.ones((3,3))
print("array的数据类型：",arry.dtype)
 
# 创建tensor
t = torch.tensor(arry)
print(t)
# --------------------------------------------------------------
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)

torch.from_numpy(ndarray)

tensor和ndarray是共享内存的，当修改一个数据时另一个数据也会随之改变

import torch
import numpy as np
 
# 创建numpy数据
arry = np.array([[1,2,3],[4,5,6]])
print("numpy：",arry)
 
# 创建tensor
t = torch.from_numpy(arry)
print("tensor:",t)
 
# 测试共享内存
 
arry[0][0] = 10
print("numpy：",arry)
print("tensor:",t)
# --------------------------------------------------------
numpy： [[1 2 3]
 [4 5 6]]       
tensor: tensor([[1, 2, 3],
        [4, 5, 6]], dtype=torch.int32)
numpy： [[10  2  3]
 [ 4  5  6]]
tensor: tensor([[10,  2,  3],
        [ 4,  5,  6]], dtype=torch.int32)

torch.as_tensor(data)

torch.as_tensor()和torch.from_numpy() 原生的numpy数组共享内存

import torch

a = np.array([1, 2, 3])
t_1 = torch.as_tensor(a)
print(t1)
a[[0,1,2]] = 0
print(t1)
# ----------------------------------------------------
tensor([1, 2, 3], dtype=torch.int32)
array([0, 0, 0])

tensor.tolist()

tenor_rand = torch.randn(2,3)
print(tenor_rand)
print(tenor_rand.tolist())
print(type(tenor_rand.tolist()))

# tensor([[-0.3383,  0.4823,  0.3448],
#         [ 0.2380,  0.1300, -0.1907]])
# [[-0.3383448123931885, 0.482287734746933, 0.34484198689460754], 
#  [0.23801031708717346, 0.12998750805854797, -0.19072400033473969]]
# <class 'list'>

tensor.numpy()

tenor_rand = torch.randn(2,3)
print(tenor_rand.numpy())
print(type(tenor_rand.numpy()))

# [[ 1.6192089  -0.7044066   0.8276266 ]
#  [-0.10407448  0.11350407 -0.9923446 ]]
# <class 'numpy.ndarray'>

创建指定张量

	函数	描述
	torch.zeros(size)	创建全为0的张量
	torch.zeros_like(input)	创建和input一样大小的全0张量
	torch.ones(size)	创建全1张量
	torch.ones_like(input)	创建和input一样大小的全1张量
	torch.full(size, fill_value)	创建全”full_value“张量
	torch.full_like(input,fill_value)
	torch.eye(n,m)	创建单位对角矩阵（二维张量），默认为方阵	n：矩阵行数 m： 矩阵列数。
	torch.arange (start=0, end, step=1)	创建等差的一维张量，数值区间为[ start, end )
	torch.linspace(start, end, steps)	创建均分的一维张量，数值区间为[start, end]	steps:生成的样本数
	torch.logspace(start, end, steps)

使用方式基本和numpy类似

随机操作

	torch.manual_seed()	随机种子
	torch.rand(size)	区间[0, 1)的均匀分布 float
	torch.randn(size)	均值为0，方差为1，标准正态分布 float
	torch.normal(means, std, out=None)	指定均值means和标准差std的离散正态分布
	torch.randint(low,high,size)	在区间[low,high)上，生成整数均匀分布
	torch.randperm(n)	生成从0到n-1的随机排列
	torch.bernoulli(input)	以input为概率，生成伯努利分布（0-1分布，两点分布）

import torch
rand = torch.rand(2, 3)  # 返回一个张量，包含了从区间[0,1)的均匀分布中抽取的一组随机数
print(rand)  # 随机初始化的值在 [0,1) 之间
# tensor([[0.5047, 0.8442, 0.1771],
#         [0.3896, 0.5468, 0.9686]])
# torch.rand_like()

#---------------------------------------------------------------------------
randn = torch.randn(2, 3)  
# 返回一个张量，包含了从标准正态分布(均值为0，方差为 1，即高斯白噪声)中抽取一组随机数
print(randn)
# tensor([[ 0.0539,  0.8289, -1.6746],
#         [-1.7428,  0.6285,  0.1432]])
# torch.randn_like()

	
#--------------------------------------------------------------------------
randint_01 = torch.randint(3, 5, (3,))
print(randint_01)
# tensor([3, 4, 3])