NNDL 实验二 pytorch入门

 一. 概念：张量、算子

张量是形似n维数组，是向量，

算子是张量之间的映射

二. 使用pytorch实现张量运算
1.2 张量
1.2.1 创建张量
1.2.1.1 指定数据创建张量

a = np.array([1, 2, 3])
t1 = torch.Tensor(a)

1.2.1.2 指定形状创建

#全零张量
a = torch.zeros([2, 3])
#全一张量
b=torch.ones([2,3])
#指定值张量
c=torch.full([2,3],10)

1.2.1.3 指定区间创建

import numpy as np
#用arange函数创建指定步长，区间的张量
a=torch.arange(1,5,1)
#用linspace函数创建指定个数，区间的张量
b=torch.linspace(1,5,5)

1.2.2 张量的属性
1.2.2.1 张量的形状

#打印张量的形状
a=torch.ones([2,3,4,5])
print(a.shape)
print(a.shape[0])
print(a.shape[-1])
print(a.size())

1.2.2.2 形状的改变

a=torch.ones([2,3,4,5])
b=torch.reshape(a,[5,4,3,2])
print(b.shape)

1.2.2.3 张量的数据类型

#.dtype查看数据类型，torch.from_numpy函数将numpy数组转化为张量
a=np.array([2,3])
print(torch.from_numpy(a).dtype)
b=a=np.array([2.0,3.0])
print(torch.from_numpy(b).dtype)

#.double()转换数据类型
a=np.array([1,2])
b=torch.tensor(a)
c=b.double()
print(b.dtype,c.dtype)

1.2.2.4 张量的设备位置

# 创建CPU上的Tensor
cpu_Tensor = torch.tensor(1, device='cpu')
# 通过Tensor.place查看张量所在设备位置
print('cpu Tensor: ', cpu_Tensor.device)
# 创建GPU上的Tensor
gpu_Tensor = torch.tensor([1,2], device="cuda")
print('gpu Tensor: ', gpu_Tensor.device)

1.2.3 张量与Numpy数组转换

#torch.tensor 将numpy数组转化为张量
ndim_1_Tensor =torch.tensor([1., 2.])
#tensor.numpy()将张量转化为numpy数组
print(ndim_1_Tensor.numpy())

 

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

我们可以通过索引或切片方便地访问或修改张量。飞桨使用标准的Python索引规则与Numpy索引规则，具有以下特点：

• 基于0−n0-n0−n的下标进行索引，如果下标为负数，则从尾部开始计算。
• 通过冒号“:”分隔切片参数start:stop:step来进行切片操作，也就是访问start到stop范围内的部分元素并生成一个新的序列。其中start为切片的起始位置，stop为切片的截止位置，step是切片的步长，这三个参数均可缺省。

 

1.2.4.2 访问张量

# 定义1个一维Tensor,torch 不支持[::-1]逆序
ndim_1_Tensor = torch.tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])

print("Origin Tensor:", ndim_1_Tensor)
print("First element:", ndim_1_Tensor[0])
print("Last element:", ndim_1_Tensor[-1])
print("All element:", ndim_1_Tensor[:])
print("Before 3:", ndim_1_Tensor[:3])
print("Interval of 3:", ndim_1_Tensor[::3])

1.2.4.3 修改张量

# 定义1个二维Tensor
ndim_2_Tensor= torch.ones(size=(2,3),dtype=torch.float32)
print('Origin Tensor: ', ndim_2_Tensor)
# 修改第1维为0
ndim_2_Tensor[0] = 0
print('change Tensor: ', ndim_2_Tensor)
# 修改第1维为2.1
ndim_2_Tensor[0:1] = 2.1
print('change Tensor: ', ndim_2_Tensor)
# 修改全部Tensor
ndim_2_Tensor[...] = 3
print('change Tensor: ', ndim_2_Tensor)

 

1.2.5 张量的运算

# 定义两个Tensor
x = torch.tensor([[1.1, 2.2], [3.3, 4.4]], dtype=torch.float64)
y = torch.tensor([[5.5, 6.6], [7.7, 8.8]], dtype=torch.float64)
# 第一种调用方法，paddle.add逐元素相加算子，并将各个位置的输出元素保存到返回结果中
print('Method 1: ', torch.add(x, y))
# 第二种调用方法
print('Method 2: ', x.add(y))

1.2.5.1 数学运算

x.abs() # 逐元素取绝对值

x.ceil() # 逐元素向上取整

x.floor() # 逐元素向下取整

x.round() # 逐元素四舍五入

x.exp() # 逐元素计算自然常数为底的指数

x.log() # 逐元素计算x的自然对数

x.reciprocal() # 逐元素求倒数

x.square() # 逐元素计算平方

x.sqrt() # 逐元素计算平方根

x.sin() # 逐元素计算正弦

x.cos() # 逐元素计算余弦

x.add(y) # 逐元素加

x.subtract(y) # 逐元素减

x.multiply(y) # 逐元素乘（积）

x.divide(y) # 逐元素除

x.mod(y) # 逐元素除并取余

x.pow(y) # 逐元素幂

x.max() # 指定维度上元素最大值，默认为全部维度

x.min() # 指定维度上元素最小值，默认为全部维度

x.prod() # 指定维度上元素累乘，默认为全部维度

x.sum() # 指定维度上元素的和，默认为全部维度

1.2.5.2 逻辑运算

x.isfinite()                  # 判断Tensor中元素是否是有限的数字，即不包括inf与nan
x.equal_all(y)                # 判断两个Tensor的全部元素是否相等，并返回形状为[1]的布尔类Tensor
x.equal(y)                    # 判断两个Tensor的每个元素是否相等，并返回形状相同的布尔类Tensor
x.not_equal(y)                # 判断两个Tensor的每个元素是否不相等
x.less_than(y)                # 判断Tensor x的元素是否小于Tensor y的对应元素
x.less_equal(y)               # 判断Tensor x的元素是否小于或等于Tensor y的对应元素
x.greater_than(y)             # 判断Tensor x的元素是否大于Tensor y的对应元素
x.greater_equal(y)            # 判断Tensor x的元素是否大于或等于Tensor y的对应元素
x.allclose(y)                 # 判断两个Tensor的全部元素是否接近

1.2.5.3 矩阵运算

x.t() # 矩阵转置

x.transpose([1, 0]) # 交换第 0 维与第 1 维的顺序

x.norm('fro') # 矩阵的弗罗贝尼乌斯范数

x.dist(y, p=2) # 矩阵（x-y）的2范数

x.matmul(y) # 矩阵乘法

1.2.5.4 广播机制

# 当两个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)

 

#不能广播
x = torch.ones((2, 3, 4))
y = torch.ones((2, 3, 6))
z = x + y

 

三. 使用pytorch实现数据预处理
1. 读取数据集 house_tiny.csv、boston_house_prices.csv、Iris.csv

import os

os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n')  # 列名
    f.write('NA,Pave,127500\n')  # 每行表示一个数据样本
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

import pandas as pd

data = pd.read_csv(data_file)
print(data)

2. 处理缺失值

#注意，“NaN”项代表缺失值。 为了处理缺失的数据，典型的方法包括插值法和删除法， 其中插值法用一个替代值弥补缺失值，而删除法则直接忽略缺失值。 在这里，我们将考虑插值法。通过位置索引iloc，我们将data分成inputs和outputs， 其中前者为data的前两列，而后者为data的最后一列。 对于inputs中缺少的数值，我们用同一列的均值替换“NaN”项。

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.mean())
print(inputs)

#对于inputs中的类别值或离散值，我们将“NaN”视为一个类别。 由于“巷子类型”（“Alley”）列只接受两种类型的类别值“Pave”和“NaN”， pandas可以自动将此列转换为两列“Alley_Pave”和“Alley_nan”。 巷子类型为“Pave”的行会将“Alley_Pave”的值设置为1，“Alley_nan”的值设置为0。 缺少巷子类型的行会将“Alley_Pave”和“Alley_nan”分别设置为0和1。

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

 

3. 转换为张量格式

#现在inputs和outputs中的所有条目都是数值类型，它们可以转换为张量格式。 当数据采用张量格式后，可以通过在 2.1节中引入的那些张量函数来进一步操作。
import torch
X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
print(X,y)

 

 

参考网址：

飞桨AI Studio - 人工智能学习与实训社区 (baidu.com)

2.2. 数据预处理 — 动手学深度学习 2.0.0-beta1 documentation (d2l.ai)