数据操作-运算

一、张量

概念：张量表示一个数值组成的数组，这个数组可能有多个维度

具有一个轴的张量对应数学上的向量（vector）

具有两个轴的张量对应数学上的矩阵（matrix）

二、数据操作

1、使用arange创建一个行向量。创建的行向量包含从0开始的前12个整数，默认创建为浮点数。张量中的每个值都称为张量的元素（element）

#第一步，导入pytorch包
import torch

#第二步，创建行向量
# 新的张量存储在内存中，并采用基于CPU的计算
x = torch.arange(12)
print(x,type(x))

x.shape

#输出结果

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]) <class 'torch.Tensor'>
torch.Size([12])

　　

2、可以使用张量shape属性来访问张量的形状，对向量来说可以理解为求张量中元素的总数，对矩阵来说，可以理解为沿每个轴的长度

print(x.shape)
x.numel()

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


#输出结果
#可以看见，因为x是向量，可以直接查看元素个数
torch.Size([12])
#因为y是矩阵，shape便显示在每个方向上的大小，也就是元素个数
torch.Size([2, 3])
tensor([[1, 2, 3],
        [4, 5, 6]])

　　

3、改变一个张量的形状而不改变元素数量和元素值，可以调用 reshape 函数，同时注意的是，reshape函数只改变他的形状不改变元素值。

我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)，-1表示缺省值，由系统自动计算出

# x是一个向量，也就是一个12*1的矩阵
print(x)
print(type(x))

# 使用reshape函数把它变为一个三行四列的矩阵
# 只是形状发生了变化，但是值的大小没有变化
X = x.reshape(3, 4)
print(X)
print(type(X))

#输出

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
<class 'torch.Tensor'>
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
<class 'torch.Tensor'>

　　

4、使用全0、全1、其他常量或者从特定分布中随机采样的数字来初始化矩阵

设置全0：zeros

# zeros将所有元素设为0
torch.zeros((2, 3, 4))
#通过输出可以发现，在这个张量中有两个元素，每个元素由一个‘两行三列’的元素组成

输出结果：

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

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

设置全1：ones

# ones将所有元素设为1
torch.ones((2, 3, 4))

#输出结果

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

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

随机设置：randn

# randn创建一个形状为（3，4）的张量，每个元素都从均值为0、标准差为1的正态分布中随机采样
torch.randn(3, 4)

#输出结果

tensor([[-0.1957, -0.0284,  1.0563,  0.2526],
        [-0.4205,  0.2026,  0.2376, -0.3273],
        [-0.6187,  0.3032, -0.0050, -0.6948]])

　　

5、直接赋值创建tensor

通过提供包含数值的python列表来为所需张量中的每个元素赋予确定值。在这里，最外层的列表对应于轴0，内层的列表对应于轴1

y=torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

x=torch.tensor([[1,2,3],[4,5,6]])

print(x)
print(y)

#输出结果

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

　　

6、数据运算——加减乘除

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])

# size()不能看一个张量的个数，可以看arange向量的个数
# numel()可以查看一个张量中元素的个数
print(x)
print(x.numel())
print(y)
print(y.numel())
x + y, x - y, x * y, x / y, x**y  # **运算符是求幂运算

#输出结果

tensor([1., 2., 4., 8.])
4
tensor([2, 2, 2, 2])
4
(tensor([ 3.,  4.,  6., 10.]),
 tensor([-1.,  0.,  2.,  6.]),
 tensor([ 2.,  4.,  8., 16.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1.,  4., 16., 64.]))

　　

7、指数运算，就e的次方

# 求e的多少次方
import math
print(math.exp(1))
# 可以直接按元素顺序进行计算
torch.exp(x)

#输出结果

2.718281828459045
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

　　

8、张量连接

把多个张量 连结（concatenate） 在一起，把它们端对端地叠起来形成一个更大的张量。

X = torch.arange(12, dtype=torch.float32).reshape((3, 4))
print(X,type(X))

Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print(Y,type(Y))

# cat函数用于连接两个tensor
# dim=0 表示按行连接
print(torch.cat((X, Y), dim=0))
# dim=1 表示按列连接
print(torch.cat((X, Y), dim=1))

#输出结果

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]]) <class 'torch.Tensor'>
tensor([[2., 1., 4., 3.],
        [1., 2., 3., 4.],
        [4., 3., 2., 1.]]) <class 'torch.Tensor'>
tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.],
        [ 2.,  1.,  4.,  3.],
        [ 1.,  2.,  3.,  4.],
        [ 4.,  3.,  2.,  1.]])
tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
        [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
        [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]])

　　

9、逻辑运算符构建二元张量

以 X == Y 为例。 对于每个位置，如果 X 和 Y 在该位置相等，则新张量中相应项的值为1，这意味着逻辑语句 X == Y 在该位置处为真，否则该位置为 0

# 通过逻辑运算符构建二元张量
# 如果X、Y在该位置相等，则新张量中相应项的值为1
X == Y

#输出结果

tensor([[False, False, False, False],
        [False, False, False, False],
        [False, False, False, False]])

　　

10、张量中所有元素求和会产生一个只有一个元素的张量

# 对所有元素求和，产生了一个只有一个元素的张量
X.sum()

#输出结果

tensor(66.)