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的几种属性

内置类型

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'>

创建指定张量

使用方式基本和numpy类似

随机操作

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])