pytorch 基本数据类型

python与pytorch对比

pytoch 中没有string类型 。

import torch
a = torch.randn(2,3) #用torch 产生一个 二维（2,3）服从正态分布的随机张量
print(a.type()) #用自带的type方法 打印数据类型
print(type(a)) # 用python自带type函数打印类型
print(isinstance(a,torch.FloatTensor)) #用isinstance() 可检验参数的合法化，判断目标类型是否与需求一致

torch.FloatTensor
<class 'torch.Tensor'>
True

CPU与GPU数据类型

print(isinstance(a,torch.cuda.FloatTensor)) #判断a是否为GPU数据类型
a = a.cuda() #转换成GPU类型
print(isinstance(a,torch.cuda.FloatTensor))

False
True

标量（维度为0的张量），其主要用于最终的误差求和，生成的loss就是一个标量（pytorch 在0.3版本之前不存在维度为0的张量），需要说明的是，dim（维度）指的是tensor的size的长度，size和shape指的是tensor具体的形态。如 tensor(1.2000) 就是一个标量，维度为0，tensor([1.2000]) 就是一个向量维度为1，其中 [] 符号 可简单理解为维度的标识符

import torch
a = torch.tensor(1.2) # 生成一个值为1.2的标量
print(a.shape)  # .shape 是一个成员
print(a.size()) # size 是一个成员函数 与.shape功能一致 输出张量的大小
print(len(a.shape)) # 打印维度的大小

tensor(1.2000)
torch.Size([])
torch.Size([])
0

一维张量,主要用于神经网络的 bias 层 ，线性输入层（把图片的二维张量展开成一维张量作为网络模型的输入）

import torch
import numpy as np
a = torch.tensor([1.2])   # 生成维度为1，数量为1，值为1.2向量
b = torch.tensor([1,2])   #  生成维度为1,数量为2，值为[1,2] 的向量 用torch.tensor方法指定张量的初始值
c = torch.FloatTensor(1)  # torch.FloatTensor 指定维度为1 数量为1的张量,初始值为0
d = torch.FloatTensor(2)  # torch.FloatTensor 指定维度为1 数量为2的张量,初始值为0
#torch.tensor 以列表 [] 作为参数传递并指定初值  torch.FloatTensor 直接传入数字（向量的个数），并赋初值为0
e = np.ones(2)            # numpy 生成一个维度为1 数量为2 的 向量
f = torch.from_numpy(e)   # numpy转换成tensor类型
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)

tensor([1.2000])
tensor([1, 2])
tensor([0.])
tensor([0., 0.])
[1. 1.]
tensor([1., 1.], dtype=torch.float64)

维度

print(a.shape)  # .shape 是一个成员
print(b.size()) # size 是一个成员函数 与.shape功能一致 输出张量的组成方式
print(len(a.shape)) #求a的维度
print(len(b.shape))

可以看到 a大小为1 b 的大小为2 他们代表张量成员的个数，维度都是1

torch.Size([1])
torch.Size([2])
1
1

二维张量

import torch
import numpy as np
a = torch.randn(2,3)   # 随机正态分布生成一个 2x3的二维张量
print(a,a.type())  #求a的值，和数据类型
print("dim is %d" %len(a.shape)) #求维度
print(a.shape)   #求a 的具体形态
print(a.shape[0],a.shape[1]) #每个维度的具体值
print(a.size(0), a.size(1))  #每个维度的具体值

其中 [[ 代表两个维度

tensor([[ 0.4353,  1.3542, -1.1641],
        [-0.4719, -0.8931, -1.5653]]) torch.FloatTensor
dim is 2      #维度
torch.Size([2, 3])  # shape 2X3的张量
2 3      			# 第一个维度为2 第二个维度为3
2 3      			# 第一个维度为2 第二个维度为3

三维张量 适用于RNN网络

import torch
import numpy as np
a = torch.rand(2,3,4)   # 随机均匀分布生成一个 2x3x4的三维张量
print(a,a.shape)  # 打印a的值  a的形态
print(len(a.shape),len(a.size())) #求a的维度
print(a.size(0),a.size(1),a.size(2)) # 求各个维度的值
print(list(a.shape))  #同list列表方法 把shape 转换成一个列表

[[[ 可看作三个维度

tensor([[[0.2943, 0.3214, 0.3520, 0.9765],
         [0.0958, 0.0679, 0.5109, 0.0849],
         [0.5389, 0.4507, 0.7460, 0.7773]],

        [[0.3300, 0.1943, 0.9387, 0.2567],
         [0.8556, 0.2846, 0.9829, 0.0866],
         [0.9474, 0.3237, 0.1736, 0.9583]]]) torch.Size([2, 3, 4])
3 3   
2 3 4
[2, 3, 4]

四维张量 适用于CNN [b,c,h,w] => b-照片的张数 c-通道数 h-高 w-宽

import torch
import numpy as np
a = torch.rand(2,3,48,48)   # 随机均匀分布生成一个 2x3x48x48的四维张量
print(a,a.shape) 
print(list(a.shape))

tensor([[[[0.8260, 0.4347, 0.8981,  ..., 0.2524, 0.5228, 0.3624],
          [0.9618, 0.7880, 0.7358,  ..., 0.5682, 0.9813, 0.7242],
          [0.1235, 0.8410, 0.7469,  ..., 0.2841, 0.8190, 0.1437],
          ...,
          [0.7999, 0.1442, 0.5369,  ..., 0.0971, 0.5551, 0.3157],
          [0.3729, 0.0963, 0.2127,  ..., 0.6911, 0.2194, 0.9099],
          [0.6989, 0.4880, 0.7724,  ..., 0.1028, 0.0493, 0.2309]],

         [[0.2113, 0.2822, 0.9181,  ..., 0.9421, 0.4821, 0.1630],
          [0.0885, 0.4826, 0.2909,  ..., 0.6333, 0.1274, 0.5563],
          [0.5081, 0.9917, 0.4737,  ..., 0.2265, 0.6959, 0.5084],
          ...,
          [0.6041, 0.0215, 0.6343,  ..., 0.3354, 0.1518, 0.2756],
          [0.9662, 0.0313, 0.8436,  ..., 0.4414, 0.9310, 0.0436],
          [0.7744, 0.2229, 0.4326,  ..., 0.0743, 0.4762, 0.2480]],

         [[0.3135, 0.5217, 0.3739,  ..., 0.2771, 0.6247, 0.4271],
          [0.4316, 0.6927, 0.5674,  ..., 0.7470, 0.7377, 0.2578],
          [0.3683, 0.6519, 0.0378,  ..., 0.0429, 0.8470, 0.8525],
          ...,
          [0.9568, 0.9325, 0.0064,  ..., 0.0251, 0.5706, 0.4804],
          [0.5041, 0.1380, 0.8703,  ..., 0.3757, 0.2478, 0.1100],
          [0.1715, 0.5275, 0.7434,  ..., 0.4851, 0.5039, 0.5853]]],


        [[[0.2119, 0.4860, 0.7654,  ..., 0.2593, 0.2143, 0.2609],
          [0.8796, 0.9284, 0.8687,  ..., 0.3293, 0.0961, 0.8592],
          [0.8040, 0.4880, 0.5111,  ..., 0.7662, 0.3960, 0.9988],
          ...,
          [0.5812, 0.5579, 0.3685,  ..., 0.7791, 0.5538, 0.8663],
          [0.5176, 0.1550, 0.1750,  ..., 0.9778, 0.6193, 0.9034],
          [0.2889, 0.1482, 0.1641,  ..., 0.7012, 0.7535, 0.0092]],

         [[0.4903, 0.1565, 0.6346,  ..., 0.8339, 0.3220, 0.6715],
          [0.7923, 0.9867, 0.6269,  ..., 0.2035, 0.0624, 0.9882],
          [0.5221, 0.5229, 0.0726,  ..., 0.2971, 0.8135, 0.6742],
          ...,
          [0.7777, 0.5725, 0.1051,  ..., 0.2272, 0.4493, 0.4333],
          [0.3686, 0.2511, 0.4292,  ..., 0.4215, 0.9916, 0.9034],
          [0.4269, 0.5832, 0.2611,  ..., 0.4323, 0.9250, 0.3870]],

         [[0.2953, 0.3896, 0.6098,  ..., 0.8344, 0.1551, 0.1925],
          [0.5900, 0.6153, 0.0572,  ..., 0.4023, 0.4597, 0.1264],
          [0.9375, 0.0138, 0.5105,  ..., 0.9098, 0.7066, 0.4147],
          ...,
          [0.2089, 0.0049, 0.1782,  ..., 0.6800, 0.1878, 0.5292],
          [0.4365, 0.5406, 0.1852,  ..., 0.5937, 0.3136, 0.3325],
          [0.9992, 0.7915, 0.3433,  ..., 0.6778, 0.4627, 0.7575]]]]) torch.Size([2, 3, 48, 48])
[2, 3, 48, 48] #简单理解成 2张 3通道的 48x48分辨大小的图片

求张量维度，及元素个数

import torch
import numpy as np
a = torch.rand(2)
b = torch.rand(2,3)
c = torch.rand(2,3,4)
#求维度 可用 len(.shape) len(.size())
#.dim() 可直接求取维度  .numel() 求张量的元素个数  number of element
print("a 的维度是：{} ， 占用空间是：{}".format(a.dim(),a.numel()))
print("b 的维度是：{} ， 占用空间是：{}".format(b.dim(),b.numel()))
print("c 的维度是：{} ， 占用空间是：{}".format(c.dim(),c.numel()))

a 的维度是：1 ， 占用空间是：2
b 的维度是：2 ， 占用空间是：6
c 的维度是：3 ， 占用空见是：24