【深度学习笔记】01 数据操作与预处理

LiuXiaoli07202023-11-26 20:12

01 数据操作与预处理

一、数据操作

1.1 基本数据操作

导入torch

python 复制代码 
import torch

张量表示一个由数值组成的数组，这个数组可能有多个维度（轴）。具有一个轴的张量对应数学上的向量（vector），具有两个轴的张量对应数学上的矩阵（matrix），具有两个以上轴的张量没有特定的数学名称。

张量中的每个值称为张量的元素（element）。

python 复制代码 
# 使用arange创建一个行向量x
x = torch.arange(12)
x
tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

可以通过张量的shape属性来访问张量（沿每个轴的长度）的形状（shape）

python 复制代码 
x.shape
torch.Size([12])

如果只想知道张量中元素的总数，即形状的所有元素乘积，可以检查它的大小（size）。因为这里处理的是一个向量，所以它的shape与size相同。

python 复制代码 
x.numel()
12
python 复制代码 
x.size()
torch.Size([12])

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

python 复制代码 
X = x.reshape(3, 4)
X
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

如果我们的目标形状是（高度，宽度），那么在知道宽度后，高度会被自动计算得出。我们可以通过-1来调用此自动计算出形状，即可以用x.reshape(-1, 4)获x.reshape(3, -1)来取代x.reshape(3, 4)。

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

python 复制代码 
# 全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.]]])
python 复制代码 
# 全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.]]])
python 复制代码 
# 每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样的矩阵
torch.randn(3, 4)
tensor([[-0.1503, -0.1886,  0.3691, -0.5482],
        [ 1.1731,  0.1596,  1.1706,  0.0437],
        [ 0.0513, -0.5481, -0.7855, -0.9853]])

运算符：

python 复制代码 
x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x / y, x ** y  # **运算符表示求幂运算
(tensor([ 3.,  4.,  6., 10.]),
 tensor([-1.,  0.,  2.,  6.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1.,  4., 16., 64.]))
python 复制代码 
torch.exp(x)  # 求幂
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

把多个张量连接（concatenate）在一起

python 复制代码 
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)  
(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.]]))

逻辑运算符构建二元张量：

python 复制代码 
X == Y
tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])

对张量中所有元素求和，会产生一个单元素张量

python 复制代码 
X.sum()
tensor(66.)

1.2 广播机制

在某些情况下，即使张量形状不同，我们仍然可以通过调用广播机制（broadcasting mechanism）来执行按元素操作。这种机制的工作方式如下：

​ （1）通过适当复制元素来扩展一个获两个数组，以便在转换之后，两个张量具有相同的形状；

​ （2）对生成的数组执行按元素操作。

python 复制代码 
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))
python 复制代码 
a + b
tensor([[0, 1],
        [1, 2],
        [2, 3]])

1.3 索引和切片

与任何python数组一样，第一个元素的索引是0，最后一个元素的索引是-1；可以指定范围以包含第一个元素和最后一个之前的元素。

python 复制代码 
X[-1], X[1:3]
(tensor([ 8.,  9., 10., 11.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))

除读取外，还可以通过制定索引将元素写入矩阵

python 复制代码 
X[1, 2] = 9
X
tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  9.,  7.],
        [ 8.,  9., 10., 11.]])

如果想为多个元素赋相同的值，只需要索引所有元素，然后赋值。

python 复制代码 
X[0:2, :] = 12
X
tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

其中，[0:2, :]访问第1行和第2行，其中":"代表沿轴1（列）的所有元素

1.4 节省内存

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

例如，如果我们用Y = X + Y，将取消引用Y指向的张量，而是指向新分配的内存处的张量。

python 复制代码 
before = id(Y)
Y = Y + X
id(Y) == before
False

运行Y = Y + X后，会发现id(Y)指向另一个位置。

这是因为Python首先计算Y + X，为结果分配新的内存，然后使Y指向内存中的这个新位置。

这可能是不可取的，原因有两个：

  1. 首先，我们不想总是不必要地分配内存。在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。通常情况下，我们希望原地执行这些更新；
  2. 如果我们不原地更新，其他引用仍然会指向旧的内存位置，这样我们的某些代码可能会无意中引用旧的参数。

执行原地操作非常简单。

我们可以使用切片表示法将操作的结果分配给先前分配的数组，例如Y[:] = 。

为了说明这一点，我们首先创建一个新的矩阵Z，其形状与另一个Y相同，

使用zeros_like来分配一个全0的块。

python 复制代码 
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
id(Z): 1343601274288
id(Z): 1343601274288

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

python 复制代码 
before = id(X)
X += Y
id(X) == before
True

1.5 转换为其他Python对象

python 复制代码 
A = X.numpy()
B = torch.tensor(A)
type(A), type(B)
(numpy.ndarray, torch.Tensor)

要将大小为1的张量转换为Python标量，可以调用item函数或Python的内置函数

python 复制代码 
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)
(tensor([3.5000]), 3.5, 3.5, 3)

二、数据预处理

读取数据集

创建一个人工数据集，并存储在csv文件中

python 复制代码 
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')

导入pandas包并调用read_csv函数

python 复制代码 
import pandas as pd

data = pd.read_csv(data_file)
print(data)
   NumRooms Alley   Price
0       NaN  Pave  127500
1       2.0   NaN  106000
2       4.0   NaN  178100
3       NaN   NaN  140000

处理缺失值

"NaN"项代表缺失值

处理缺失数据的典型方法包括插值法和删除法，其中插值法用一个替代值弥补缺失值，删除法则直接忽略缺失值

在这里考虑插值法。通过位置索引iloc，将data分成inputs和outputs，其中前者为data的前两列，后者为data的最后一列。对于inputs中缺少的数值，用同一列的均值替换"NaN"项。

python 复制代码 
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.select_dtypes(include = 'number').mean())  # 区别于书中的inputs.fillna(inputs.mean())
print(inputs)
   NumRooms Alley
0       3.0  Pave
1       2.0   NaN
2       4.0   NaN
3       3.0   NaN

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

python 复制代码 
inputs = pd.get_dummies(inputs, dummy_na = True)
print(inputs)
   NumRooms  Alley_Pave  Alley_nan
0       NaN        True      False
1       2.0       False       True
2       4.0       False       True
3       NaN       False       True

转换为张量格式

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

python 复制代码 
import torch

X = torch.tensor(inputs.to_numpy(dtype = float))
y = torch.tensor(outputs.to_numpy(dtype = float))
X, y
(tensor([[nan, 1., 0.],
         [2., 0., 1.],
         [4., 0., 1.],
         [nan, 0., 1.]], dtype=torch.float64),
 tensor([127500., 106000., 178100., 140000.], dtype=torch.float64))

练习

创建包含更多行和列的原始数据集

（1）删除缺失值最多的列

（2）将预处理后的数据集转换为张量格式

python 复制代码 
# 创建数据集
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,others\n')  # 列名
    f.write('NA,Pave,127500,Pave\n')  # 每行表示一个数据样本
    f.write('2,NA,106000,NA\n')
    f.write('4,NA,178100,Pave\n')
    f.write('NA,NA,140000,Pave\n')
python 复制代码 
import pandas as pd

data = pd.read_csv(data_file)
print(data)
   NumRooms Alley   Price others
0       NaN  Pave  127500   Pave
1       2.0   NaN  106000    NaN
2       4.0   NaN  178100   Pave
3       NaN   NaN  140000   Pave
python 复制代码 
# 删除缺失值最多的列
count = 0
count_max = 0
labels = ['NumRooms','Alley','Price','others']
for label in labels:
    count = data[label].isna().sum()
    if count > count_max:
        count_max = count
        flag = label
data_new = data.drop(flag, axis = 1)
data_new

| | NumRooms | Price | others |
| 0 | NaN | 127500 | Pave |
| 1 | 2.0 | 106000 | NaN |
| 2 | 4.0 | 178100 | Pave |

3 NaN 140000 Pave
python 复制代码 
# 将data_new分成inputs和outputs，其中前者为data_new的前两列，后者为data_new的最后一列
inputs, outputs = data_new.iloc[:, 0:2], data_new.iloc[:, 2]
inputs = inputs.fillna(inputs.select_dtypes(include = 'number').mean())  # 对于inputs中的缺失值，用同一列的均值替换
print(inputs)
outputs = pd.get_dummies(outputs, dummy_na = True)
print(outputs)
   NumRooms   Price
0       3.0  127500
1       2.0  106000
2       4.0  178100
3       3.0  140000
    Pave    NaN
0   True  False
1  False   True
2   True  False
3   True  False
python 复制代码 
# 转换为张量格式
import torch

X = torch.tensor(inputs.to_numpy(dtype = float))
y = torch.tensor(outputs.to_numpy(dtype = float))
X, y
(tensor([[3.0000e+00, 1.2750e+05],
         [2.0000e+00, 1.0600e+05],
         [4.0000e+00, 1.7810e+05],
         [3.0000e+00, 1.4000e+05]], dtype=torch.float64),
 tensor([[1., 0.],
         [0., 1.],
         [1., 0.],
         [1., 0.]], dtype=torch.float64))
相关推荐
翔云API8 分钟前
PHP静默活体识别API接口应用场景与集成方案
人工智能
浊酒南街14 分钟前
吴恩达深度学习笔记：卷积神经网络（Foundations of Convolutional Neural Networks）4.9-4.10
人工智能·深度学习·神经网络·cnn
Tony聊跨境30 分钟前
独立站SEO类型及优化：来检查这些方面你有没有落下
网络·人工智能·tcp/ip·ip
懒惰才能让科技进步36 分钟前
从零学习大模型（十二）-----基于梯度的重要性剪枝（Gradient-based Pruning）
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
Qspace丨轻空间1 小时前
气膜场馆：推动体育文化旅游创新发展的关键力量—轻空间
大数据·人工智能·安全·生活·娱乐
没有不重的名么1 小时前
门控循环单元GRU
人工智能·深度学习·gru
love_and_hope1 小时前
Pytorch学习--神经网络--搭建小实战（手撕CIFAR 10 model structure）和 Sequential 的使用
人工智能·pytorch·python·深度学习·学习
芊寻(嵌入式)1 小时前
C转C++学习笔记--基础知识摘录总结
开发语言·c++·笔记·学习
2403_875736871 小时前
道品科技智慧农业中的自动气象检测站
网络·人工智能·智慧城市
学术头条2 小时前
AI 的「phone use」竟是这样练成的，清华、智谱团队发布 AutoGLM 技术报告
人工智能·科技·深度学习·语言模型
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解