NNDL 实验二 pytorch入门

一. 概念：张量、算子

张量
在深度学习的实践中，我们通常使用向量或矩阵运算来提高计算效率。比如w1x1+w2x2+⋯+wNxN的计算可以用w⊤x来代替（其中w=[w1w2⋯wN]⊤，x=[x1x2⋯xN]⊤），这样可以充分利用计算机的并行计算能力，特别是利用GPU来实现高效矩阵运算。
在深度学习框架中，数据经常用张量(Tensor)的形式来存储。张量是矩阵的扩展与延伸，可以认为是高阶的矩阵。1阶张量为向量，2阶张量为矩阵。如果你对Numpy熟悉，那么张量是类似于Numpy的多维数组(ndarray)的概念，可以具有任意多的维度。
注意：这里的“维度”是“阶”的概念，和线性代数中向量的“维度”含义不同。
张量的大小可以用形状（shape）来描述。比如一个三维张量的形状是 [2,2,5]，表示每一维（也称为轴（axis））的元素的数量，即第0轴上元素数量是2，第1轴上元素数量是2，第2轴上的元素数量为5。
下图给出了3种纬度的张量可视化表示。

张量中元素的类型可以是布尔型数据、整数、浮点数或者复数，但同一张量中所有元素的数据类型均相同。因此我们可以给张量定义一个数据类型(dtype)来表示其元素的类型。
算子
深度学习算法由一个个计算单元组成，我们称这些计算单元为算子（Operator，简称OP）。在网络模型中，算子对应层中的计算逻辑，例如：卷积层（Convolution Layer）是一个算子；全连接层（Fully-connected Layer， FC layer）中的权值求和过程，是一个算子。
再例如：tanh、ReLU等，为在网络模型中被用做激活函数的算子。

二. 使用pytorch实现张量运算

1.2 张量
1.2.1 创建张量
1.2.1.1 指定数据创建张量
（1）通过指定的Python列表数据[2.0, 3.0, 4.0]，创建一个一维张量。

# 导入torch
import torch
# 创建一维Tensor
data = torch.Tensor([2.0,3.0,4.0])
print(data)

运行结果：
tensor([2., 3., 4.])

（2）通过指定的Python列表数据来创建类似矩阵（matrix）的二维张量。

# 创建二维Tensor
import torch
data = torch.Tensor([[1.0, 2.0, 3.0],
                                  [4.0, 5.0, 6.0]])
print(data)

运行结果：
tensor([[1., 2., 3.],
        [4., 5., 6.]])

（3）同样地，还可以创建维度为3、4…N等更复杂的多维张量。

# 创建多维Tensor
import torch
data = torch.Tensor([[[1, 2, 3, 4, 5],
                      [6, 7, 8, 9, 10]],
                     [[11, 12, 13, 14, 15],
                      [16, 17, 18, 19, 20]]])
print(data)

运行结果：
tensor([[[ 1.,  2.,  3.,  4.,  5.],
         [ 6.,  7.,  8.,  9., 10.]],

        [[11., 12., 13., 14., 15.],
         [16., 17., 18., 19., 20.]]])

需要注意的是，张量在任何一个维度上的元素数量必须相等。下面尝试定义一个在同一维度上元素数量不等的张量。

import torch
# 尝试定义在不同维度上元素数量不等的Tensor
data = torch.tensor([[1.0, 2.0],
                                  [4.0, 5

运行结果：

1.2.1.2 指定形状创建

import torch

m, n = 2, 3
# 使用torch.zeros创建数据全为0，形状为[m, n]的Tensor
zeros_Tensor = torch.zeros([m, n])
# 使用torch.ones创建数据全为1，形状为[m, n]的Tensor
ones_Tensor =torch.ones([m, n])

# 使用torch.full创建数据全为指定值，形状为[m, n]的Tensor，这里我们指定数据为10
full_Tensor = torch.full([m, n], 10)

print('zeros Tensor: ', zeros_Tensor)
print('ones Tensor: ', ones_Tensor)
print('full Tensor: ', full_Tensor)

运行结果：
zeros Tensor:  tensor([[0., 0., 0.],
        [0., 0., 0.]])
ones Tensor:  tensor([[1., 1., 1.],
        [1., 1., 1.]])
full Tensor:  tensor([[10, 10, 10],
        [10, 10, 10]])

1.2.1.3 指定区间创建

import torch
# 创建以步长step=2均匀分隔数值区间[start=1, end=6)的一维Tensor
arange_Tensor = torch.arange(1, 6, 2)

# 创建以元素个数num=5均匀分隔数值区间[start=1, stop=5]的Tensor
linspace_Tensor = torch.linspace(1, 5, 5)

print('arange Tensor: ', arange_Tensor)
print('linspace Tensor: ', linspace_Tensor)

运行结果：
arange Tensor:  tensor([1, 3, 5])
linspace Tensor:  tensor([1., 2., 3., 4., 5.])

1.2.2 张量的属性
1.2.2.1 张量的形状
张量具有如下形状属性:
<1>tensor.ndim:张量的维度，例如向量的维度为1，矩阵的维度为2。
<2>tensor.shape:张量每个维度上元素的数量。
<3>tensor.shape[n]:张量第n维的大小。第n维也称为轴（axis）。
<4>tensor.size:返回的是当前张量的形状,返回值是元组tuple的一个子类。

创建一个四维张量，并打印出shape、ndim、shape[n]、size属性。

import torch

ndim_4_Tensor = torch.tensor([2, 3, 4, 5])

print("Number of dimensions:", ndim_4_Tensor.ndim)
print("Shape of Tensor:", ndim_4_Tensor.shape)
print("Elements number along axis 0 of Tensor:", ndim_4_Tensor.shape[0])
print("Elements number along the last axis of Tensor:", ndim_4_Tensor.shape[-1])
print('Number of elements in Tensor: ', ndim_4_Tensor.size())

运行结果：
Number of dimensions: 1
Shape of Tensor: torch.Size([4])
Elements number along axis 0 of Tensor: 4
Elements number along the last axis of Tensor: 4
Number of elements in Tensor:  torch.Size([4])

1.2.2.2 形状的改变

import torch

# 定义一个shape为[3,2,5]的三维Tensor
ndim_3_Tensor = torch.tensor([[[1, 2, 3, 4, 5],
                                   [6, 7, 8, 9, 10]],
                                  [[11, 12, 13, 14, 15],
                                   [16, 17, 18, 19, 20]],
                                  [[21, 22, 23, 24, 25],
                                   [26, 27, 28, 29, 30]]])
print("the shape of ndim_3_Tensor:", ndim_3_Tensor.shape)

# paddle.reshape 可以保持在输入数据不变的情况下，改变数据形状。这里我们设置reshape为[2,5,3]
reshape_Tensor = torch.reshape(ndim_3_Tensor, [2, 5, 3])
print("After reshape:", reshape_Tensor)

运行结果：
the shape of ndim_3_Tensor: torch.Size([3, 2, 5])
After reshape: tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9],
         [10, 11, 12],
         [13, 14, 15]],

        [[16, 17, 18],
         [19, 20, 21],
         [22, 23, 24],
         [25, 26, 27],
         [28, 29, 30]]])

1.2.2.3 张量的数据类型

import torch

print("Tensor dtype from Python integers:", torch.tensor(1).dtype)
print("Tensor dtype from Python floating point:", torch.tensor(1.0).dtype)

运行结果：
Tensor dtype from Python integers: torch.int64
Tensor dtype from Python floating point: torch.float32```

1.2.2.4 张量的设备位置

import torch

ndim_4_Tensor = torch.tensor([2, 3, 4, 5])
print(ndim_4_Tensor.device

运行结果：
cpu

1.2.3 张量与Numpy数组转换
张量和Numpy数组可以相互转换，可以通过Tensor.numpy()函数将张量转化为Numpy数组。

import torch

ndim_1_Tensor = torch.tensor([1., 2.])
# 将当前 Tensor 转化为 numpy.ndarray
print('Tensor to convert: ', ndim_1_Tensor.numpy())

运行结果：
Tensor to convert:  [1. 2.]

1.2.4 张量的访问
1.2.4.1 索引和切片
索引：

import torch

data = torch.Tensor([[1.0, 2.0, 3.0],
                                  [4.0, 5.0, 6.0]])
print(data[1])

运行结果：
tensor([4., 5., 6.])

切片：

print(data[0:1])

运行结果:
tensor([[1., 2., 3.]])

1.2.4.2 访问张量

print(data[0:2, 1:3])

运行结果:
tensor([[2., 3.],
        [5., 6.]])

1.2.4.3 修改张量

data[1,0]=7
print(data)

运行结果：
tensor([[1., 2., 3.],
        [7., 5., 6.]])

1.2.5 张量的运算
1.2.5.1 数学运算

import torch

x = torch.tensor([[1., 2.], [3., 4.]])
y = torch.tensor([[5., 6.], [7., 8.]])
print("加法运算：",x + y)
print("减法运算：",x - y)
print("乘法运算：",x * y)
print("除法运算：",x / y)
print("幂运算：",x**y)
print("对数运算：",torch.log(x))
print("开方运算：",torch.sqrt(y)

运算结果：
加法运算： tensor([[ 6.,  8.],
        [10., 12.]])
减法运算： tensor([[-4., -4.],
        [-4., -4.]])
乘法运算： tensor([[ 5., 12.],
        [21., 32.]])
除法运算： tensor([[0.2000, 0.3333],
        [0.4286, 0.5000]])
幂运算： tensor([[1.0000e+00, 6.4000e+01],
        [2.1870e+03, 6.5536e+04]])
对数运算： tensor([[0.0000, 0.6931],
        [1.0986, 1.3863]])
开方运算： tensor([[2.2361, 2.4495],
        [2.6458, 2.8284]])

1.2.5.2 逻辑运算

import torch

x= torch.tensor([[True, True], [True, True]])
y= torch.tensor([[False, False], [False, False]])

print(x & y)    # 与运算
print(x | y)    # 或运算
print(~x)   # 取反
print(x ^ y)    # 异或运算
print(torch.eq(x, y))    # 判断每个分量是否相等
print(torch.equal(x, y))     # 判断整体是否相等

运算结果：
tensor([[False, False],
        [False, False]])
tensor([[True, True],
        [True, True]])
tensor([[False, False],
        [False, False]])
tensor([[True, True],
        [True, True]])
tensor([[False, False],
        [False, False]])
False

Process finished with exit code -1073741749 (0xC000004B)

1.2.5.3 矩阵运算
乘法：

import torch

x = torch.arange(12, dtype=torch.float32).reshape((4, 3))
y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print("矩阵相乘：", x.matmul(y) )

运行结果：
矩阵相乘： tensor([[ 9.,  8.,  7.,  6.],
        [30., 26., 34., 30.],
        [51., 44., 61., 54.],
        [72., 62., 88., 78.]])

转置：

import torch

x = torch.ones(2, 1)
print(x)
print("转置后：",x.t())

运行结果：
tensor([[1.],
        [1.]])
转置后： tensor([[1., 1.]])

1.2.5.4 广播机制
广播机制需要满足两个条件：
<1>每个张量至少有一个维度
<２>从后往前比较张量的形状，当前维度的大小要么相等，要么其中一个等于1，要么其中一个不存在。

import torch

# 当两个Tensor的形状一致时，可以广播
x = torch.ones((2, 3, 4))
y = torch.ones((2, 3, 4))
z = x + y
print('broadcasting with two same shape tensor: ', z.shape)

x = torch.ones((2, 3, 1, 5))
y = torch.ones((3, 4, 1))
# 从后往前依次比较：
# 第一次：y的维度大小是1
# 第二次：x的维度大小是1
# 第三次：x和y的维度大小相等，都为3
# 第四次：y的维度不存在
# 所以x和y是可以广播的
z = x + y
print('broadcasting with two different shape tensor:', z.shape)

运行结果：
broadcasting with two same shape tensor:  torch.Size([2, 3, 4])
broadcasting with two different shape tensor: torch.Size([2, 3, 4, 5])

从输出结果看，x与y在上述两种情况中均遵循广播规则，因此在张量相加时可以广播。
现在我们知道在什么情况下两个张量是可以广播的。两个张量进行广播后的结果张量的形状计算规则如下：

1）如果两个张量shape的长度不一致，那么需要在较小长度的shape前添加1，直到两个张量的形状长度相等。

2） 保证两个张量形状相等之后，每个维度上的结果维度就是当前维度上较大的那个。

三. 使用pytorch实现数据预处理

1. 读取数据集 house_tiny.csv、boston_house_prices.csv、Iris.csv

import pandas as pd

house_tiny_path = './house_tiny.csv'
boston_house_prices_path = './boston_house_prices.csv'
Iris_path = './Iris.csv'

house_tiny_data = pd.read_csv(house_tiny_path)
boston_house_prices_data = pd.read_csv(boston_house_prices_path)
Iris_data = pd.read_csv(Iris_path)

print(house_tiny_data)
print(boston_house_prices_data)
print(boston_house_prices_data)

运行结果：
   NumRooms Alley   Price
0       NaN  Pave  127500
1       2.0   NaN  106000
2       4.0   NaN  178100
3       NaN   NaN  140000
        CRIM    ZN  INDUS  CHAS    NOX  ...  RAD  TAX  PTRATIO  LSTAT  MEDV
0    0.00632  18.0   2.31     0  0.538  ...    1  296     15.3   4.98  24.0
1    0.02731   0.0   7.07     0  0.469  ...    2  242     17.8   9.14  21.6
2    0.02729   0.0   7.07     0  0.469  ...    2  242     17.8   4.03  34.7
3    0.03237   0.0   2.18     0  0.458  ...    3  222     18.7   2.94  33.4
4    0.06905   0.0   2.18     0  0.458  ...    3  222     18.7   5.33  36.2
..       ...   ...    ...   ...    ...  ...  ...  ...      ...    ...   ...
501  0.06263   0.0  11.93     0  0.573  ...    1  273     21.0   9.67  22.4
502  0.04527   0.0  11.93     0  0.573  ...    1  273     21.0   9.08  20.6
503  0.06076   0.0  11.93     0  0.573  ...    1  273     21.0   5.64  23.9
504  0.10959   0.0  11.93     0  0.573  ...    1  273     21.0   6.48  22.0
505  0.04741   0.0  11.93     0  0.573  ...    1  273     21.0   7.88  11.9

[506 rows x 13 columns]
        CRIM    ZN  INDUS  CHAS    NOX  ...  RAD  TAX  PTRATIO  LSTAT  MEDV
0    0.00632  18.0   2.31     0  0.538  ...    1  296     15.3   4.98  24.0
1    0.02731   0.0   7.07     0  0.469  ...    2  242     17.8   9.14  21.6
2    0.02729   0.0   7.07     0  0.469  ...    2  242     17.8   4.03  34.7
3    0.03237   0.0   2.18     0  0.458  ...    3  222     18.7   2.94  33.4
4    0.06905   0.0   2.18     0  0.458  ...    3  222     18.7   5.33  36.2
..       ...   ...    ...   ...    ...  ...  ...  ...      ...    ...   ...
501  0.06263   0.0  11.93     0  0.573  ...    1  273     21.0   9.67  22.4
502  0.04527   0.0  11.93     0  0.573  ...    1  273     21.0   9.08  20.6
503  0.06076   0.0  11.93     0  0.573  ...    1  273     21.0   5.64  23.9
504  0.10959   0.0  11.93     0  0.573  ...    1  273     21.0   6.48  22.0
505  0.04741   0.0  11.93     0  0.573  ...    1  273     21.0   7.88  11.9

[506 rows x 13 columns]

Process finished with exit code -1073741749 (0xC000004B)

2. 处理缺失值

import pandas as pd

house_tiny_path = './house_tiny.csv'
boston_house_prices_path = './boston_house_prices.csv'
Iris_path = './Iris.csv'

house_tiny_data = pd.read_csv(house_tiny_path)
boston_house_prices_data = pd.read_csv(boston_house_prices_path)
Iris_data = pd.read_csv(Iris_path)

X = house_tiny_data.iloc[:, 0:2]
print(X)
y = house_tiny_data.iloc[:, 2]
print(y)

X = X.fillna(X.mean())
print(X)

运行结果：
   NumRooms Alley
0       NaN  Pave
1       2.0   NaN
2       4.0   NaN
3       NaN   NaN
0    127500
1    106000
2    178100
3    140000
Name: Price, dtype: int64
   NumRooms Alley
0       3.0  Pave
1       2.0   NaN
2       4.0   NaN
3       3.0   NaN

3. 转换为张量格式

import pandas as pd
import torch
import numpy as np

house_tiny_path = './house_tiny.csv'
boston_house_prices_path = './boston_house_prices.csv'
Iris_path = './Iris.csv'

house_tiny_data = pd.read_csv(house_tiny_path)
boston_house_prices_data = pd.read_csv(boston_house_prices_path)
Iris_data = pd.read_csv(Iris_path)

X = house_tiny_data.iloc[:, 0:2]
y = house_tiny_data.iloc[:, 2]

X = pd.get_dummies(X, dummy_na=True)

X_tensor, y_tensor = torch.Tensor(X.values), torch.Tensor(y.values)
print(X_tensor, y_tensor)

运行结果：
tensor([[nan, 1., 0.],
        [2., 0., 1.],
        [4., 0., 1.],
        [nan, 0., 1.]]) tensor([127500., 106000., 178100., 140000.])

总结：
本篇文章了解了张量和量子的概念，然后使用pytorch实现张量运算，学习了如何创建张量，张量的属性（张量与Numpy数组转换等），以及张量的访问（包括索引和切片、访问张量、修改张量），还有张量的四种运算（数学运算、逻辑运算、矩阵运算和广播机制），还使用pytorch进行了数据预处理，有数据集的读取，处理缺失值并转换为张量格式。在这次实验中收获了很多并且加深了对tensor的认识，对torch有了更多的了解。