04数据操作+数据预处理

动手学深度学习 深度学习
发布时间 :
阅读 :
  1. 04数据操作+数据预处理
    1. N维数组样例
    2. 创建数组
    3. 访问元素
    4. 数据操作
    5. 数据预处理

04数据操作+数据预处理

N维数组样例

  • N维数据是机器学习和神经网络的主要数据结构。

创建数组

  • 创建数组需要
    • 形状：例如3x4矩阵
    • 每个元素的数据类型：例如32位浮点数
    • 每个元素的值，例如全是0，或者随机数

访问元素

一个元素：[1, 2]

一行：[1, :]

一列：[:, 1]

子区域：[1:3, 1:]

子区域：[::3, ::2]
跳着访问，每三行一跳，每两列一跳

数据操作

首先，我们导入torch

1
import torch


张量表示一个数值组成的数组，这个数组可以有多个维度

1
2
x = torch.arange(12)
x


我们可以通过张量的shape属性来访问张量的形状和张量中元素的总数

1
x.shape

1
x.numel()


要改变一个张量的形状而不改变元素数量和元素值，我们可以调用reshape函数

1
2
x = x.reshape(3, 4) #三行四列
x


使用全0、全1、其他常量或者从特定分布中随机采样的数字

1
torch.zeros((2, 3, 4)) #全0

1
torch.ones((2, 3, 4)) #全1


通过提供包含数值的Python列表（或嵌套列表)来为所需张量中的每一个元素赋予确定值

1
2
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
#二维数组

1
2
torch.tensor([[[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]]])
#三维数组
1
torch.tensor([[[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]]]).shape

深度为1，3行4列

常见的标准算术运算符（+、-、*、/ 和 **)都可以升级为按元素运算

1
2
3
x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x ** y


按元素方式应用更多的计算

1
torch.exp(x)


我们也可以把多个张量连结在一起

1
2
3
4
x = torch.arange(12, dtype=torch.float32).reshape((3, 4))
y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((x, y), dim=0), torch.cat((x,y), dim=1)
#按行合并                   #按列合并


通过逻辑运算符构建二元张量

1
x == y


对张量中的所有元素进行求和会产生一个只有一个元素 的张量

1
x.sum()


即使形状不同，我们仍然可以通过调用广播机制来执行按元素操作

1
2
3
4
5
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

a + b


可以用[-1]选择最后一个元素，可以用[1: 3]选择第二个和第三个元素

1
x[-1], x[1: 3]


除读取之外，我们还可以通过指定索引来将元素写入矩阵

1
2
x[1, 2] = 9
x


为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值

1
2
x[0:2, :] = 12
x


运行一些操作可能会导致为新的结果分配内存

1
2
3
before = id(y)
y = y + x
id(y) == before


执行原地操作

1
2
3
4
z = torch.zeros_like(y)
print('id(z):', id(z))
z[:] = x + y
print('id(z):', id(z))


如果在后续计算中没有重复使用x，我们也可以使用x[:] = x + y或x += y来减少操作的内存开销

1
2
3
before = id(x)
x += y
id(x) == before


转换为NumPy张量

1
2
3
A = x.numpy()
B = torch.tensor(A)
type(A), type(B)


将大小为1的张量转换为Python标量

1
2
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

数据预处理

创建一个人工数据集，并存储在csv（逗号分隔值）文件

1
2
3
4
5
6
7
8
9
10
11
12
import os

os.makedirs(os.path.join('\\', 'data'), exist_ok=True) #创建一个文件夹
data_file = os.path.join('\\', 'data', 'house_tiny.csv') #创建一个文件名为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')


从创建的csv文件中加载原始数据集

1
2
3
4
import pandas as pd

data = pd.read_csv(data_file) #读取文件数据
data


为了处理缺失的数据，典型的方法包括插值和删除，这里，我们将考虑插值

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


对于inputs中的类别值或离散值，我们将“NaN”视为一个类别

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


现在inputs和outputs中的所有条目都是数值类型，它们可以转换为张量格式

1
2
3
4
import torch

X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
X, y

©2017 YJT

Built with Hexo and 3-hexo theme