深度学习(1)介绍、数据操作、张量数据操作、数据预处理
·
参考github作者，我只是用来学习。
1.预告
2.课程安排
3.深度学习介绍
3.1 AI地图
① 如下图所示，X轴是不同的模式，最早的是符号学，然后概率模型、机器学习。Y轴是我们想做什么东西，感知是我了解这是什么东西，推理形成自己的知识，然后做规划。
② 感知类似我能看到前面有个屏幕，推理是基于我看到的东西想象未来会发生什么事，根据看到的现象、数据，形成自己的知识，知道所有知识后能进行长远的规划，未来怎么做
① 自然语言处理目前还是停留在感知上，人几秒钟能反应过来的东西都属于感知范围，即使像中文翻译成英文，英文翻译成中文那种。
② 计算机视觉可以在图片里面可以做一些推理。
③ 自然语言处理里面有符号，所以有符号学，并且还可以用概率模型、机器学习。计算机视觉面对的是图片，图片里面都是一个个像素，像素很难用符号学来解释，所以计算机视觉大部分用概率模型、机器学习来解释。
④ 深度学习是计算机视觉中的一种方法，它还有其他应用方法。
3.2. IMAGENET数据集
① 深度学习最早在图片分类上做了比较大的突破。
② IMAGENET是比较大的图片分类数据集，如下图所示，它包括了一千类的自然物体的图片，它大概有一百万张图片。
3.3 图片分类错误率
① 可以看到从12年开始，图片分类错误率开始有一个比较大的下降，12年就是深度学习引入图片分类的开始。
② 17年的时候，几乎所有的团队都可以做到5%以内的错误率，基本上可以达到人类在图片识别上的精度了。可以说在图片分类上，深度学习已经做的很好了。
3.4. 物体检测和分割
① 知道图片是内容，在什么地方，这就是物体检测。
② 物体分割是指每个像素它到底是飞机还是人。
3.5. 样式迁移
① 内容图片结合样式图片(滤镜)，可以把内容图片映射到其他风格。
3.6. 人脸合成
① 下面的所有图都为算法合成的假人脸。
3.7. 文字生成
① 下面的图片都是由上面的文字生成出来的。
3.8. 文字生成
① 下左图为算法会根据人问的问题，机器生成回答。
② 下右图为机器根据人的需求，给我们写代码。
3.9. 无人驾驶
① 下图为计算机视觉的无人驾驶领域的应用。
3.10. 广告点击
① 根据用户的点击，看给怎么样的广告。
3.11. 领域专家、数据科学家、AI专家
4.安装
5.数据操作
5.1. N维数组
① 机器学习用的最多的是N维数组，N维数组是机器学习和神经网络的主要数据结构。
5.2. 创建数组
① 创建数组需要：形状、数据类型、元素值。
5.3. 访问元素
① 可以根据切片，或者间隔步长访问元素。
② [::3,::2]是每隔3行、2列访问。
③[1:3,1:]前面是左闭右开的区间，后边是从第一列到后面的所有
4. 张量数据操作
4.1 导入torch库
① 虽然库为PyTorch库，但应该导入torch，而不是pytorch。
输入
import torch x = torch.arange(12) # 初始化一个0-11的张量 x s 输出
tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
4.2 访问张量形状
① 可以通过张量的shape属性来访问张量的形状和张量中元素的总数。
import torch x = torch.arange(12) # 初始化一个0-11的张量 x.shape # 张量的形状
torch.Size([12])
import torch x = torch.arange(12) # 初始化一个0-11的张量 x.numel() # 张量中元素的总数
12
4.3 改变张量形状
① 要改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。
import torch x = torch.arange(12) # 初始化一个0-11的张量 x = x.reshape(3,4) # 一维张量改为3行四列的张量 x
tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
4.4 创建全0、全1张量
① 使用全0、全1、其他常量或者从特定分布中随即采样的数字。
import torch y = torch.zeros((2,3,4)) print(y)
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.]]])
import torch
y = torch.ones((2,3,4))
print(y)
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.]]])
4.5 创建特定值张量
① 通过提供包含数值的Python列表（或嵌套列表）来为所需张量中的每个元素赋予确定值。
import torch y = torch.tensor([[2,1,4,3],[1,2,3,4],[4,3,2,1]]) # 二维tensor z = torch.tensor([[[2,1,4,3],[1,2,3,4],[4,3,2,1]]]) # 三维tensor print(y) print(z)
tensor([[2, 1, 4, 3],
[1, 2, 3, 4],
[4, 3, 2, 1]])
tensor([[[2, 1, 4, 3],
[1, 2, 3, 4],
[4, 3, 2, 1]]])
import torch y = torch.tensor([[2,1,4,3],[1,2,3,4],[4,3,2,1]]) # 二维tensor z = torch.tensor([[[2,1,4,3],[1,2,3,4],[4,3,2,1]]]) # 三维tensor print(y.shape) print(z.shape)
channel 1,width 3,height 4
torch.Size([3, 4]) torch.Size([1, 3, 4])
4.6 张量运算操作
① 常见的标准算术运算符(+、-、*、/、和 **)都可以被升级为按元素运算。
标量是0维张量，向量是1维张量，矩阵是2维张量
import torch x = torch.tensor([1.0,2,4,8]) y = torch.tensor([2,2,2,2]) print(x+y) print(x-y) print(x*y) print(x/y) print(x**y) # **运算符是求幂运算
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.])
② 对每个元素应用更多的计算。
import torch x = torch.tensor([1.0,2,4,8]) x = torch.exp(x) # e的x次方 print(x)
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
4.7 张量合并操作
⑧ 可以把多个张量结合在一起。
import torch
长度为12，即0-11，类型也指明了，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]])
m = torch.cat((x,y),dim=0) # 按行合并起来
n = torch.cat((x,y),dim=1) # 按列合并起来
print(m)
print(n)
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.]])
2D中：dim就是告诉 PyTorch：“我要沿着哪个轴干活。”dim=0是竖着干，dim=1是横着干3D中
dim=0：沿着 batch 方向（不同样本之间）
dim=1：沿着 row 方向
dim=2：沿着 col 方向
4.8 张量逻辑运算
① 通过逻辑运算符构建二元张量。
import torch 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]]) print(x) print(y) print(x == y) # 对应元素相等为 True，否则为 False
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
tensor([[2., 1., 4., 3.],
[1., 2., 3., 4.],
[4., 3., 2., 1.]])
tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
4.9 张量累加运算
① 对张量中所有元素进行求和会产生一个只有一个元素的张量。
import torch x = torch.arange(12,dtype=torch.float32).reshape((3,4)) print(x.sum())
tensor(66.)
4.10 张量广播运算
① 即使形状不同，仍然可以通过调用广播机制(broadcasting mechanism) 来执行按元素操作。
import torch a = torch.arange(3).reshape((3,1)) b = torch.arange(2).reshape((1,2)) print(a) print(b) print(a+b) # a会复制出一个3*2的矩阵，b复制出一个3*2的矩阵，然后再相加，会得到一个3*2矩阵
PS：如果两个张量在某一维的大小都不同且都不为1，则会引发错误
扩展的详细机制
a 扩展前: a 扩展后（复制列）: [[0], → [[0, 0], [1], [1, 1], [2]] [2, 2]]b 扩展前: b 扩展后（复制行）: [[0, 1]] → [[0, 1], [0, 1], [0, 1]]自动复制小张量，让它和大张量形状匹配
tensor([[0],
[1],
[2]])
tensor([[0, 1]])
tensor([[0, 1],
[1, 2],
[2, 3]])
4.11 张量访问运算
① 可以用[-1]选择最后一个元素，可以用[1:3]【左闭右开】选择第二个和第三个元素。
import torch x = torch.arange(12,dtype=torch.float32).reshape((3,4)) print(x[-1]) print(x[1:3])
tensor([ 8., 9., 10., 11.])#最后一行
tensor([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
4.12 张量元素改写
① 除读取外，还可以通过指定索引来将元素写入矩阵。
import torch x = torch.arange(12,dtype=torch.float32).reshape((3,4)) x[1,2] = 9 print(x)
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 9., 7.],
[ 8., 9., 10., 11.]])
② 为多个元素赋值相同的值，只需要索引所有元素，然后为它们赋值。
import torch x = torch.arange(12,dtype=torch.float32).reshape((3,4)) x[0:2,:] = 12 #0-1行的所有列选中赋值12 print(x)
tensor([[12., 12., 12., 12.],
[12., 12., 12., 12.],
[ 8., 9., 10., 11.]])
4.13 张量内存变化
① 运行一些操作可能会导致为新结果分配内容。
import torch 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]]) before = id(y) #将之前的地址存起来 y = x + y print(id(y) == before) # 运行操作后，赋值后的y的id和原来的id不一样
False
执行原地操作
import torch
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]])
z = torch.zeros_like(y) # z 的数据类型、尺寸和y一样，里面的元素全为0
print("id(z):",id(z))
z[:] = x + y
print("id(z):",id(z))
id(z): 2712056119192 id(z): 2712056119192
② 如果在后续计算中没有重复使用X，即内存不会过多复制，也可以使用X[:] = X + Y 或 X += Y 来减少操作的内存开销。
import torch 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]]) before = id(x) x += y print(id(x) == before)
True
4.14 张量转Numpy
① 张量转 NumPy。
import torch x = torch.arange(12,dtype=torch.float32).reshape((3,4)) A = x.numpy()#.numpy()是把 PyTorch 张量转换成 NumPy 数组,A 是一个 NumPy 数组，内容和 x 完 全一样 B = torch.tensor(A)#torch.tensor() 把 NumPy 数组转换回 PyTorch 张量 print(type(A),type(B))
<class 'numpy.ndarray'> <class 'torch.Tensor'>
场景 用哪个 原因 模型训练、GPU计算 PyTorch 张量 支持自动求导、GPU加速 数据预处理、可视化 NumPy 数组 科学计算库更丰富，matplotlib 画图方便
② 将大小为1的张量转为 Python 标量。
import torch a = torch.tensor([3.5]) print(a) print(a.item()) print(float(a)) print(int(a))
tensor([3.5000]) 3.5 3.5 3
表达式 结果 说明 a.item()3.5从单元素张量里取出 Python 数字 atensor([3.5000])张量本身 float(a)3.5强制转换成 Python 浮点数 int(a)3强制转换成 Python 整数（小数部分被截断）
5. 数据预处理
5.1 创建数据集
① 创建一个人工数据集，并存储在csv(逗号分隔符)文件。
import os
os.makedirs(os.path.join('.','01_Data'),exist_ok=True) # 相对路径，创建文件夹
data_file = os.path.join('.','01_Data','01_house_tiny.csv')
print(data_file)
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')
.\01_Data\01_house_tiny.csv
5.2 加载数据集
① 从创建的csv文件中加载原始数据集。
# 如果没有安装pandas，只需取消对以下行的注释：
# !pip install pandas
import pandas as pd
import os
os.makedirs(os.path.join('.','01_Data'),exist_ok=True) # 相对路径，创建文件夹
data_file = os.path.join('.','01_Data','01_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')
data_file = os.path.join('.','01_Data','01_house_tiny.csv')
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
5.3 预处理数据集
① 为了处理缺失的数据，典型的方法包括插值和删除，这里，我们考虑插值。
# 如果没有安装pandas，只需取消对以下行的注释：
# !pip install pandas
import pandas as pd
import os
os.makedirs(os.path.join('.','01_Data'),exist_ok=True) # 相对路径，创建文件夹
data_file = os.path.join('.','01_Data','01_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')
data_file = os.path.join('.','01_Data','01_house_tiny.csv')
data = pd.read_csv(data_file)
inputs, outputs = data.iloc[:,0:2], data.iloc[:,2]
# 只对数值列进行均值填充
# 选择数值类型的列
numeric_columns = inputs.select_dtypes(include=['number']).columns
inputs[numeric_columns] = inputs[numeric_columns].fillna(inputs[numeric_columns].mean())
# 对非数值列（如 Alley）用其他方式填充，比如用 "Unknown"
inputs['Alley'] = inputs['Alley'].fillna('Unknown')
#inputs = inputs.fillna(inputs.mean()) # 对 NaN 值用均值插值 print(inputs)
NumRooms Alley 0 3.0 Pave 1 2.0 NaN 2 4.0 NaN 3 3.0 NaN
② 对于inputs中的类别值或离散值，将“NaN”视为一个类别。
# 如果没有安装pandas，只需取消对以下行的注释：
# !pip install pandas
import pandas as pd
import os
os.makedirs(os.path.join('.','01_Data'),exist_ok=True) # 相对路径，创建文件夹
data_file = os.path.join('.','01_Data','01_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')
data_file = os.path.join('.','01_Data','01_house_tiny.csv')
data = pd.read_csv(data_file)
inputs, outputs = data.iloc[:,0:2], data.iloc[:,2]
inputs = inputs.fillna(inputs.mean()) # 对 NaN 值用均值插值
print(inputs)
inputs = pd.get_dummies(inputs, dummy_na=True) #
print(inputs) # Alley列中，如果之前值为Pave，则新赋值为1，如果之 前值为Nan，则新赋值为1
NumRooms Alley 0 3.0 Pave 1 2.0 NaN 2 4.0 NaN 3 3.0 NaN NumRooms Alley_Pave Alley_nan 0 3.0 1 0 1 2.0 0 1 2 4.0 0 1 3 3.0 0 1
分类为0和1
dummy_na=True表示对nan单独编码，即保留缺失值信息
5.4 数据集转张量
① inputs 和 outputs 中的所有条目都是数值类型，它们可以转换为张量格式。
# 如果没有安装pandas，只需取消对以下行的注释：
# !pip install pandas
import pandas as pd
import os
os.makedirs(os.path.join('.','01_Data'),exist_ok=True) # 相对路径，创建文件夹
data_file = os.path.join('.','01_Data','01_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')
data_file = os.path.join('.','01_Data','01_house_tiny.csv')
data = pd.read_csv(data_file)
inputs, outputs = data.iloc[:,0:2], data.iloc[:,2]
inputs = inputs.fillna(inputs.mean()) # 对 NaN 值用均值插值
inputs = pd.get_dummies(inputs, dummy_na=True) # dummy_na=True 使得 Alley中的每种类型为一列，在各自的列中该类型为1，其余类型为0
print(inputs)
x, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
print(x)
print(y)
NumRooms Alley_Pave Alley_nan
0 3.0 1 0
1 2.0 0 1
2 4.0 0 1
3 3.0 0 1
tensor([[3., 1., 0.],
[2., 0., 1.],
[4., 0., 1.],
[3., 0., 1.]], dtype=torch.float64)
tensor([127500, 106000, 178100, 140000])
更多推荐
6
0- 0
已为社区贡献31条内容
所有评论(0)