python—Tensor（张量）的含义，创建

Posted 2023-03-30 码啥码

Tensor

含义

张量（Tensor）：是一个多维数组，它是标量、向量、矩阵的高维拓展。

创建

非随机创建

1.用数组创建

将数组转化为tensor
np.ones([a,b]) 全为1

#首先导入PyTorch
import torch

#数组创建
import numpy as np
a=np.array([2,3.3])#维度为一的矩阵
torch.from_numpy(a)#转化为tensor
#out:tensor([2.0000, 3.3000], dtype=torch.float64)

a=np.ones([2,3])#2行3列全为1
torch.from_numpy(a)
'''out
tensor([[1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
'''

torch.zeros([a,b]) 全为0
torch.eye([a,b]) 对角线上全为1
torch.ones([a,b]) 全为1

torch.zeros(3,3)
'''
tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
'''
torch.eye(3,3)#不适用于3维以上
'''
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])
'''
torch.ones(3,3)
'''
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])
'''

2.给定数字直接创建

#直接用用给定的数字创建tensor
torch.tensor([2.,3.2])#list，小写tensor接受的是现有的数据
#out:tensor([2.0000, 3.2000])

3.创建空的tensor

#创建一个空的tensor,数字随机
torch.empty(1)#未初始化的维度1的数据
#out：tensor([-1.8860e+26])
#Torch.FloatTensor(d1, d2, d3)

torch.Tensor(2,3)#创建一个2行3列的数,默认float类
'''out:
tensor([[2.5353e+30, 2.8026e-44, 8.0519e-42],
        [9.4081e-39, 7.8194e-25, 2.5353e+30]])'''

torch.IntTensor(2,3)#创建2行3列的整数
#注意会出现数据非常大或者非常小的情况，要记得覆盖数据
'''out
tensor([[1912602624,         20,       5746],
        [   6713856,  393347072, 1912602624]], dtype=torch.int32)
'''

4.如何更改默认类型

torch.set_default_tensor_type(torch.DoubleTensor)#设置默认类型为double

随机初始化

1.产生0-1之间

采用rand随即产生0-1之间的数字填充在创建的张量中

a=torch.rand(3,3)#随机2行3列数据，01之间
'''
tensor([[0.5724, 0.5070, 0.7747],
        [0.0624, 0.9298, 0.5318],
        [0.8444, 0.1081, 0.1214]])
'''
torch.rand_like(a)#_like代表的就是tensor函数，随机生成一个像a一样的3行3列的数
'''
tensor([[0.1703, 0.8234, 0.6707],
        [0.2379, 0.7012, 0.6451],
        [0.6607, 0.2193, 0.7388]])
'''

2.自定义区间

randiant自定义区间

torch.randint(1,10,[3,3])#自定义区间，最大值不包含在区间内
#区间1-10，数据是3*3的矩阵

3.自定义均值和方差

#自定义均值和方差
torch.normal(mean=torch.full([10],0.),std=torch.arange(1,0.,-0.1))
#torch.full([10],0.)生成度为10，均值为0
#std=torch.arange(1,0.,-0.1)，方差在慢慢减少

4.重复数

tensor中的数字一样

#生成2行3列全是7
torch.full([2,3],7)

arange/range

#生成0-9数
torch.arange(0,10)
#tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

#range在torch中不建议使用
torch.range(0,10)

linspace/logspace等分¶

#边包含[0,10]，等分切steps个数字
torch.linspace(0,10,steps=4)
#tensor([ 0.0000,  3.3333,  6.6667, 10.0000])

#返回logx
torch.logspace(0,-1,steps=10)
#tensor([1.0000, 0.7743, 0.5995, 0.4642, 0.3594, 0.2783, 0.2154, 0.1668, 0.1292,0.1000])

randperm

torch.randperm(10)#0-9之间随机生成,随即打散
#tensor([2, 6, 4, 9, 1, 3, 7, 0, 8, 5])

#掉换行
a=torch.rand(3,3)
b=torch.rand(3,2)
idx=torch.randperm(3)
a,b,idx
'''
(tensor([[0.5896, 0.2464, 0.6245],
         [0.0282, 0.2187, 0.4708],
         [0.8680, 0.9148, 0.7411]]),
 tensor([[0.7101, 0.0145],
         [0.3003, 0.3720],
         [0.4903, 0.2437]]))
 tensor([0, 2, 1])'''
idx=torch.randperm(3)
idx
#tensor([2, 1, 0])
a[idx]#给a做索引，相反
b[idx]#idx保持一致，随机打散的种子
'''
tensor([[0.8680, 0.9148, 0.7411],
        [0.0282, 0.2187, 0.4708],
        [0.5896, 0.2464, 0.6245]])  
tensor([[0.4903, 0.2437],
        [0.3003, 0.3720],
        [0.7101, 0.0145]])'''      
         

pytorch之张量的相关介绍

目录

张量是什么：各种数值数据

张量的创建

使用Python中的列表或者序列

使用numpy中的数组创建tensor

使用torch的API创建tensor

torch.Tensor和torch.tensor的区别

torch.Tensor

torch.tensor()

Pytorch中tensor的常用方法

获取tensor中的数据(当tensor中只有一个元素可用)：tensor.item()

转化为numpy数组：t1.numpy()

获取形状:tensor.size()

形状改变：tensor.view((3,4))

获取维数：tensor.dim()

获取最值：tensor.max() tensor.min()

转置：tensor.t() tensor.transpose(dim1,dim2) tensor.permute(维度参数列表)

tensor的切片和索引

tensor的数据类型

获取tensor的数据类型 tensor.dtype

创建数据的时候指定类型

将tensor类型的数据转换成特定类型

tensor的其他操作

tensor和tensor相加

CUDA中的tensor

---

张量是什么：各种数值数据

• 0阶张量：常数，eg：1

• 1阶张量：向量，eg：[1,2,3]

• 2阶张量：矩阵，eg：[[1.2]]

• n阶张量

阶指的是一个高维数组的形状

张量的创建

首先需要先安装好Torch包，导入torch

import torch

使用Python中的列表或者序列

import torch
import numpy as np
print(torch.tensor([[1.,-1.],[1.,-1.]]))

运行结果：

tensor([[ 1., -1.],

[ 1., -1.]])

使用numpy中的数组创建tensor

array1=np.arange(12).reshape(3,4)
print(array1)
print(torch.tensor(array1))
print(torch.tensor(np.array([[1,2,3],[4,5,6]])))

运行结果：

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

tensor([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]], dtype=torch.int32)

tensor([[1, 2, 3],

[4, 5, 6]], dtype=torch.int32)

使用torch的API创建tensor

(根据观察和实践，括号里加不加[]输出结果都一样，含义都是形状参数)

• torch.empty(3,4) #创建3行4列的空的tensor，会用无用数据进行填充

• torch.ones([3,4]) #创建3行4列的全为1的tensor

• torch.zeros([3,4]) #创建3行4列的全为0的tensor

• torch.rand([3,4]) #创建3行4列的随机值的tensor，随机值的区间是[0,1)

• torch.randint(low=0,high=10,size=[3,4]) #创建3行4列的随机值的tensor，随机值的区间是[low,high)

• torch.randint(0,10,(3,4))

• torch.randn(3,4)#创建3行4列的随机值的tensor，随机值的分布式均为0，方差为1

以上代码的输出结果为：

tensor([[1.0194e-38, 1.0469e-38, 1.0010e-38, 8.9081e-39],

[8.9082e-39, 5.9694e-39, 8.9082e-39, 1.0194e-38],

[9.1837e-39, 4.6837e-39, 9.9184e-39, 9.0000e-39]])

tensor([[1., 1., 1., 1.],

[1., 1., 1., 1.],

[1., 1., 1., 1.]])

tensor([[0., 0., 0., 0.],

[0., 0., 0., 0.],

[0., 0., 0., 0.]])

tensor([[0.3854, 0.2613, 0.5499, 0.7777],

[0.0138, 0.0527, 0.2157, 0.7534],

[0.9140, 0.2811, 0.4065, 0.6411]])

tensor([[6, 8, 7, 5],

[7, 1, 2, 1],

[3, 4, 5, 4]])

tensor([[8, 4, 6, 2],

[0, 0, 9, 0],

[0, 1, 9, 2]])

tensor([[-1.8722, -0.5870, 0.4326, -1.3008],

[ 0.2789, -0.4924, 0.8317, -1.5052],

[ 1.1085, -2.1004, 0.4730, 1.7097]])

torch.Tensor和torch.tensor的区别

在Pytorch中，Tensor和tensor都用于生成新的张量。但还是有区别的！

torch.Tensor

torch.Tensor() Python类，更明确的说，是默认张量类型torch.FloatTensor()的别名，torch.Tensor([1,2]) 会调用Tensor类的构造函数init()，生成单精度浮点类型的张量。

a=torch.Tensor([1,2])
print(a)
print(a.type())

运行结果：

tensor([1., 2.])

torch.FloatTensor

torch.tensor()

torch.tensor()仅仅是Python的函数，函数原型是：

torch.tensor(data, dtype=None, device=None, requires_grad=False)

其中data可以是：list, tuple, array, scalar等类型。 torch.tensor()可以从data中的数据部分做拷贝(而不是直接引用)，根据原始数据类型生成相应的torch.LongTensor，torch.FloatTensor，torch.DoubleTensor。

如下例：

a=torch.tensor([1,2])
print(a.type())
b=torch.tensor([1.,2.])
print(b.type())
c=torch.tensor([1,2],dtype=torch.float64)
print(c.type())

运行结果：

torch.LongTensor

torch.FloatTensor

torch.DoubleTensor

Pytorch中tensor的常用方法

获取tensor中的数据(当tensor中只有一个元素可用)：tensor.item()

a=torch.tensor(np.arange(1))
print(a)
print(a.item())

运行结果

tensor([0], dtype=torch.int32)

0

转化为numpy数组：t1.numpy()

t1=torch.tensor([[[1]]])
print(t1)
print(t1.numpy())

运行结果：

tensor([[[1]]])

[[[1]]]

获取形状:tensor.size()

t2=torch.tensor([[1,2,3],[5,5,8]])
print(t2.size())
print(t2.size(-1))#获取最后一个维度的形状

运行结果：

torch.Size([2, 3])

3

形状改变：tensor.view((3,4))

类似于numpy的reshape，是一种浅拷贝，仅仅是形状发生改变

说明：view()中若有参数-1，说明这个数组根据形状自动补齐

如：

t3=torch.tensor([[1,2],[3,4],[5,6]])
print(t3)
print(t3.view((2,3)))#不会改变t3本身的形状
print(t3)
print(t3.view(-1))#一维
print(t3.view(6,-1))#6行1列
print(t3.view(2,-1))#2行3列

运行结果：

tensor([[1, 2],

[3, 4],

[5, 6]])

tensor([[1, 2, 3],

[4, 5, 6]])

tensor([[1, 2],

[3, 4],

[5, 6]])

tensor([1, 2, 3, 4, 5, 6])

tensor([[1],

[2],

[3],

[4],

[5],

[6]])

tensor([[1, 2, 3],

[4, 5, 6]])

获取维数：tensor.dim()

t3=torch.tensor([[1,2],[3,4],[5,6]])
print(t3.dim())

运行结果：

2

获取最值：tensor.max() tensor.min()

t3=torch.tensor([[1,2],[3,4],[5,6]])
print(t3.min())
print(t3.max())

运行结果：

tensor(1)

tensor(6)

可见执行结果只会返回tensor类型的一个数

转置：tensor.t() tensor.transpose(dim1,dim2) tensor.permute(维度参数列表)

t4=torch.tensor(np.arange(24).reshape(2,3,4))*#**生成一个三维数组，形状见输出
print(t4)
print(t4.transpose(0,1))#n维数组需要2个参数，作用是交换两个维度，这里使t4数组的第一维和第二维转置
print(t4.permute(0,2,1))#n维数组，需要n个参数，把需要交换的维度标清楚
print(t4) #这里可见转置操作不会改变张量本身的形状
t5=torch.tensor(np.arange(15).reshape(3,5))
print(t5)
print(t5.t())#只支持2维
print(t5.transpose(0,1))#2维的话参数不可以省略
print(t5.permute(1,0))#2维的话参数 不可以省略

运行结果：

tensor([[[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]],

[[12, 13, 14, 15],

[16, 17, 18, 19],

[20, 21, 22, 23]]], dtype=torch.int32)

tensor([[[ 0, 1, 2, 3],

[12, 13, 14, 15]],

[[ 4, 5, 6, 7],

[16, 17, 18, 19]],

[[ 8, 9, 10, 11],

[20, 21, 22, 23]]], dtype=torch.int32)

tensor([[[ 0, 4, 8],

[ 1, 5, 9],

[ 2, 6, 10],

[ 3, 7, 11]],

[[12, 16, 20],

[13, 17, 21],

[14, 18, 22],

[15, 19, 23]]], dtype=torch.int32)

tensor([[[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]],

[[12, 13, 14, 15],

[16, 17, 18, 19],

[20, 21, 22, 23]]], dtype=torch.int32)

tensor([[ 0, 1, 2, 3, 4],

[ 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14]], dtype=torch.int32)

tensor([[ 0, 5, 10],

[ 1, 6, 11],

[ 2, 7, 12],

[ 3, 8, 13],

[ 4, 9, 14]], dtype=torch.int32)

tensor([[ 0, 5, 10],

[ 1, 6, 11],

[ 2, 7, 12],

[ 3, 8, 13],

[ 4, 9, 14]], dtype=torch.int32)

tensor([[ 0, 5, 10],

[ 1, 6, 11],

[ 2, 7, 12],

[ 3, 8, 13],

[ 4, 9, 14]], dtype=torch.int32)

tensor的切片和索引

和numpy中大致相同

t4=torch.tensor(np.arange(24).reshape(2,3,4))#生成一个三维数组，形状见输出
print(t4)
print(t4[0,0,0])#获取数字0
print(t4[1,2,3])#获取数字23
print(t4[0])#与下面等价，切片
print(t4[0,:,:])
print(t4[:,:,1])

运行结果：

tensor([[[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]],

[[12, 13, 14, 15],

[16, 17, 18, 19],

[20, 21, 22, 23]]], dtype=torch.int32)

tensor(0, dtype=torch.int32)

tensor(23, dtype=torch.int32)

tensor([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]], dtype=torch.int32)

tensor([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]], dtype=torch.int32)

tensor([[ 1, 5, 9],

[13, 17, 21]], dtype=torch.int32)

tensor的数据类型

获取tensor的数据类型 tensor.dtype

t4=torch.tensor(np.arange(24).reshape(2,3,4))#生成一个三维数组，形状见输出
print(t4.dtype)

运行结果：

torch.int32

创建数据的时候指定类型

print(torch.ones((2,3),dtype=torch.float32))#默认情况都是float32
print(torch.ones((2,3),dtype=torch.int32))
print(torch.ones((2,3),dtype=torch.float64))
print(torch.tensor(([1,2],[3,4]),dtype=torch.float64))

运行结果：

tensor([[1., 1., 1.],

[1., 1., 1.]])

tensor([[1, 1, 1],

[1, 1, 1]], dtype=torch.int32)

tensor([[1., 1., 1.],

[1., 1., 1.]], dtype=torch.float64)

tensor([[1., 2.],

[3., 4.]], dtype=torch.float64)

将tensor类型的数据转换成特定类型

t5=torch.tensor([[2.3,5.6],[3.5,6.9]])
print(t5)
print(t5.half())
print(t5.float())
print(t5.double())
print(t5.short())
print(t5.int())
print(t5.long())
print(t5)#上述操作均不会改变t5本身

运行结果：

tensor([[2.3000, 5.6000],

[3.5000, 6.9000]])

tensor([[2.3008, 5.6016],

[3.5000, 6.8984]], dtype=torch.float16)

tensor([[2.3000, 5.6000],

[3.5000, 6.9000]])

tensor([[2.3000, 5.6000],

[3.5000, 6.9000]], dtype=torch.float64)

tensor([[2, 5],

[3, 6]], dtype=torch.int16)

tensor([[2, 5],

[3, 6]], dtype=torch.int32)

tensor([[2, 5],

[3, 6]])

tensor([[2.3000, 5.6000],

[3.5000, 6.9000]])

tensor的其他操作

方法加下划线(如add_())会就地修改数据本身

tensor和tensor相加

x=torch.ones(3,5)
y=torch.rand(3,5)
print(x+y)
print(torch.add(x,y))
print(x.add(y))
print(x)#以上操作不会改变x本身
print(x.add_(y))
print(x)#add_会改变x本身

运行结果：

tensor([[1.0626, 1.2198, 1.2891, 1.7517, 1.4450],

[1.0384, 1.2170, 1.3615, 1.4150, 1.0491],

[1.5048, 1.5946, 1.4347, 1.3700, 1.8832]])

tensor([[1.0626, 1.2198, 1.2891, 1.7517, 1.4450],

[1.0384, 1.2170, 1.3615, 1.4150, 1.0491],

[1.5048, 1.5946, 1.4347, 1.3700, 1.8832]])

tensor([[1.0626, 1.2198, 1.2891, 1.7517, 1.4450],

[1.0384, 1.2170, 1.3615, 1.4150, 1.0491],

[1.5048, 1.5946, 1.4347, 1.3700, 1.8832]])

tensor([[1., 1., 1., 1., 1.],

[1., 1., 1., 1., 1.],

[1., 1., 1., 1., 1.]])

tensor([[1.0626, 1.2198, 1.2891, 1.7517, 1.4450],

[1.0384, 1.2170, 1.3615, 1.4150, 1.0491],

[1.5048, 1.5946, 1.4347, 1.3700, 1.8832]])

tensor([[1.0626, 1.2198, 1.2891, 1.7517, 1.4450],

[1.0384, 1.2170, 1.3615, 1.4150, 1.0491],

[1.5048, 1.5946, 1.4347, 1.3700, 1.8832]])

CUDA中的tensor

CUDA( Compute Unified Device Architecture)，是NVIDIA推出的运算平台，CUDATM是种由NVIDIA推出的通用并行计算架构，该架构使GP能够解决复杂的计问题。

torch.cuda这个模块增加了对 CUDA tensor的支持，能够在cpu和gpu上使用相同的方法操作tensor。

通过.to方法能够把一个tensor转移到另外一个设备(比如从CPU转到GPU)

print(torch.cuda.is_available()) #表示我的电脑上不支持GPU执行torch代码
device=torch.device('cuda' if torch.cuda.is_available()else 'cpu')
print(device)#输出cuda
print(torch.zeros([2,3],device=device))#唉，俺的电脑GPU不支持，该换啦
a=torch.zeros(1,3)
print(a.to(device))

运行结果：

False

cpu

tensor([[0., 0., 0.],

[0., 0., 0.]])

tensor([[0., 0., 0.]])

归纳GPU中tensor的使用：

实例化device：torch.devive(‘cuda:0’ if torch.cuda.is_available() else 'cpu')

tensor.to(device) #把tensor转化成CUDA或者CPU支持的tensor。

更多Pytorch知识梳理，请参考： pytorch学习笔记

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。