1.一些基本的概念问题理解

1.1 训练模型

在机器学习中，学习是一个训练模型的过程，基本步骤就是，从一个随机初始化参数的模型开始，然后获取数据样本（包含对应的标签），调整参数，是模型在这些样本中表现得更好，重复获取、调整得步骤，一直到模型在任务中得表现最好，如图1.1.1所示。

图1.1.1训练流程图
参数可以看作旋钮，可以调整程序的行为，调整参数后的程序被称为模型。
通过操作参数而生成的所有不同程序（输入——输出——映射）的集合成为模型族。
使用数据集来选择参数的元程序被称为学习算法。

1.2 机器学习关键组件

用来学习的数据——data
如何转换数据的模型——model
一个目标函数——量化模型的有效性
调整模型参数以优化目标函数的算法

在监督学习问题中，要预测的是一个特殊的属性，被称为标签（label，或目标（target））。
每个样本的特征类别数量相同的时候，其特征向量是固定长度的，这个长度被称为数据的维数。固定长度的特征向量是一个方便的属性，它可以用来量化学习大量样本。。
深度学习的一个优势是可以处理不同长度的数据。
深度学习与经典方法的区别主要在于：深度学习关注的功能强大的模型，这些模型由神经网络错综复杂的交织在一起，包含层层数据转换。
定义模型的优劣程度的度量在大多数情况下是可以优化的，被称之为目标函数，并优化到最低点，越低越好，也称为损失函数，最常见的损失函数是平方误差（预测值与实际值之差的平方）。
解决分类问题，最常见的目标函数是最小化错误率（预测与实际不符的样本比例）。
损失函数根据模型参数来定义，并取决于数据集。在一个数据集上，可以通过最小化总损失来学习模型参数的最佳值。该数据集由一些为训练而收集的样本组成——训练数据集（训练集）。但是在训练数据上表现良好的模型，并不一定在新数据集上有相同的性能——测试数据集（测试集）。
综上，可用数据集可以分为两部分，训练集用于拟合模型参数，测试集用于评估拟合的模型。 然后观察模型在这两部分数据集的性能。测试性能可能会显著偏离训练性能。
一个模型在训练集上表现良好，但不能推广到测试集时，这个模型被称为过拟合。
获得数据源及其表示、一个模型和一个合适的损失函数，接下来需要一种算法，它能够搜索出最佳参数，以最小化损失函数。
深度学习中，大多流行的优化算法通常基于一种基本方法——梯度下降。 即，在每个步骤中，梯度下降法都会检查每个参数，看看如果仅对该参数进行少量变动，训练集损失会朝哪个方向移动。然后它在可以减少损失的方向上优化参数。

1.3 机器学习各种问题

监督学习擅长在给定输入特征的情况下预测标签，每个“特征-标签”对都称为一个样本。即使标签未知，样本也可以指代输入特征。我们的目标是生成一个模型，能够将任何输入特征映射到标签（即预测）。
监督学习之所以能发挥作用，是因为在训练参数时，我们为模型提供了一个数据集，其中每个样本都有真实的标签。即，希望预测“给定输入特征的标签”的条件概率。
监督学习的三大步骤：
先从大量数据样本中随机选取一个子集，为每个样本获取真实标签。有些样本已有标签（例如，患者是否在下一年康复？），有些样本可能需要被人工标记（例如，图像分类），这些输入和相应的标签一起构成了训练数据集。
然后选择有监督的学习算法，它将训练数据集作为输入，并输出一个“已完成学习的模型”。
接着将之前没有见过的样本特征放到这个“已经完成学习的模型中”，使用模型的输出作为相应标签的预测，监督学习过程如图1.3.1所示。

图1.3.1 监督学习流程图
当标签取任意数值时（比如销售价格不定），称之为回归问题，此时的目标是生成一个模型，使它的预测非常接近实际标签值。一些预测类问题就可能是回归问题，比如这个手术需要多长时间。
分类问题，比如支票扫描功能，就是自动理解从图像中看到的文本，并将手写字符映射到对应的已知字符上，这种“哪一个”的问题叫做分类问题。分类问题希望模型能够预测样本属于哪个类别，正式成为类，例如手写数字可能有10类，标签被设置为数字0~9。最简单的为二项分类，例如，数据集可能由动物组成，标签可能是猫狗两类。
回归是训练一个回归函数来输出一个数值，分类是训练一个分类器来输出预测的类别。
当有两个以上的类别时，成为多项分类，分类问题的常见损失函数为交叉熵。
序列学习，如果输入是连续的，模型可能就需要记忆功能，比如处理视频片段，前一帧后一帧需要记忆。
目前所有的例子都与监督学习有关。即需要向模型提供巨大数据集：每个样本包含特征和相应标签值。
监督学习有明确的目标，模型在每种情况下应该做什么都是知道的，直到模型学会从情况到行动的映射。如果没有具体的目标，需要自发的去学习，不含有目标的机器学习问题称为无监督学习。
无监督学习可以回答聚类问题（没有标签的情况下给数据分类，比如给定一组照片，可以分成风景照片、猫、山峰的照片吗）、主成分分析问题（找到少量的参数来准确捕捉数据的线性相关属性，比如一个球的运动轨迹可以用球的速度、直径和质量来描述）、因果关系和概率图模型问题（观察到许多数据的根本原因）、生成对抗性网络（提供一种合成数据的方法，甚至像图像和音频这样复杂的非结构化数据）。
强化学习问题，如果对使用机器学习开发与环境交互并采取行动感兴趣，那么最终会专注于强化学习。 智能体在一系列的时间步骤上与环境交互。在每个特定的时间点，智能体从环境接收一些观察，并且必须选择一个动作，然后通过某种机制（有时成为执行器）将其传输回环境，最后智能体从环境中获得奖励。此后新一轮循环开始，智能体接收后续观察，并选择后续动作，以此类推。强化学习的目标是产生一个好的策略。强化学习智能体选择的“动作”受策略控制，即一个从环境观察映射到行动的功能。如图1.3.2所示。

图1.3.2 强化学习和环境之间的相互作用

2.预备知识

2.1数据操作

n维数组就是张量，这个得记住，张量类在Pytorch中为Tensor。张量表示一个由数值组成的数组，这个数组可能由多个维度。具有一个轴的张量对应数学上的向量，具有两个轴的张量对应数学上的矩阵。

2.1.1 一些入门操作

import torch
# arange创建行向量，包含0开始的12个整数，张量中的每一个值都称为张量的元素，除非额外指定，新的张量将存储在内存中，并采用基于CPU的计算
x=torch.arange(12)
print(x)
# 通过张量的shape属性来访问张量（沿每个轴的长度）的形状
print(x.shape)
# 输出张量中元素的总数
print(x.numel())
# 改变张量的形状而不改变元素的数量和元素值，可以调用reshape函数，例如可以把张量x从形状为（12，）的行向量转换为形状为（3，4）的矩阵，这个新张量包含与之前的张量相同的值，但是转换为了3行4列的矩阵，张量的形状改变了，但是张量的大小没改变
# 或者写成X=x.reshape(-1,4)或者X=x.reshape(3,-1)也行，-1代表自动算出维度，都表示3行4列的矩阵
X=x.reshape(3,4)
print(X)

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
torch.Size([12])
12
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

# 改变张量的形状而不改变元素的数量和元素值，可以调用reshape函数，例如可以把张量x从形状为（12，）的行向量转换为形状为（3，4）的矩阵，这个新张量包含与之前的张量相同的值，但是转换为了3行4列的矩阵，张量的形状改变了，但是张量的大小没改变
# 或者写成X=x.reshape(-1,4)或者X=x.reshape(3,-1)也行，-1代表自动算出维度，都表示3行4列的矩阵
X=x.reshape(3,4)
print(X)
# 用全0初始化矩阵.例如建立形状为2，3，4的矩阵
Y=torch.zeros((2,3,4))
print(Y)
# 用全1初始化矩阵.例如建立形状为2，3，4的矩阵
Y=torch.ones((2,3,4))
print(Y)

# 用全0初始化矩阵.例如建立形状为2，3，4的矩阵
Y=torch.zeros((2,3,4))
print(Y)
# 用全1初始化矩阵.例如建立形状为2，3，4的矩阵
Y=torch.ones((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.]]])
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.]]])

# 有时我们通过从某个特定的概率分布中随机采样来得到张量中每个元素的值，例如，构造数组来作为神经网络中的参数，通常会随机初始化参数的的值。
# 比如，创建一个形状为（3，4）的张量，每个元素服从均值为0，标准差为1的正态分布中随机采样
Y=torch.randn(3,4)
print(Y)
# 通过包含特定值的python列表来为所需张量中的每个元素赋予确定值，外层列表代表0轴，内层列表代表1轴
# 0轴代表矩阵里竖着的方向，1轴代表矩阵里横着的那个方向
Z=torch.tensor([[2,1,4,3],[1,2,3,4],[4,3,2,1]])
print(Z)

tensor([[-0.2730,  0.7017,  0.3421,  1.5155],
        [ 0.8651,  0.9948, -0.8967, -0.2379],
        [-0.0683,  0.0246,  0.2120, -0.7771]])
tensor([[2, 1, 4, 3],
        [1, 2, 3, 4],
        [4, 3, 2, 1]])

2.1.2运算符

对于任意具有相同形状的张量，常见的标准算术运算符都可以被升级为按元素运算，可以在同一形状的任意两个张量上调用按元素操作。比如，使用逗号来表示一个具有5个元素的元组，其中每个元素都是按元素操作的结果。如下边示例。

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(torch.exp(x))

tensor([ 3.,  4.,  6., 10.])
tensor([-1.,  0.,  2.,  6.])
tensor([0.5000, 1.0000, 2.0000, 4.0000])
tensor([ 1.,  4., 16., 64.])
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

连接张量

#将张量连接在一起，端对端的叠起来形成一个更大的张量，我们只需提供张量列表，并给出沿哪个轴连接
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]])
#dim=0表示竖着连接，dim=1代表横着连接
print(torch.cat((X,Y),dim=0))
print(torch.cat((X,Y),dim=1))
#如果x和y在该位置相等，则新张量中在该位置为true
print(X==Y)
#对张量中的所有元素求和，会产生一个单元素张量
print(X.sum())

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.]])
tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])
tensor(66.)

2.1.3 广播机制（张量形状不同的情况下）

广播机制：通过复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状。然后对生成的数组执行按元素操作。
多数情况，将沿着数组中长度为1的轴进行广播。

a=torch.arange(3).reshape((3,1))
b=torch.arange(2).reshape((1,2))
print(a)
print(b)
# a和b分别是3乘1、1乘2矩阵，直接相加会不匹配，所以将a复制列，b复制行，然后就可以相加为3乘2矩阵
print(a+b)

tensor([[0],
        [1],
        [2]])
tensor([[0, 1]])
tensor([[0, 1],
        [1, 2],
        [2, 3]])

2.1.4 张量元素的索引操作

# -1代表最后一个元素，[1:3]代表选择第二个和第三个元素
X=torch.arange(12,dtype=torch.float32).reshape(3,4)
print(X[-1])
print(X[1:3])
#除了读取操作外，还可以通过指定索引来将元素写入矩阵
X[1,2]=9
print(X)
#如果想为多个元素赋值相同的值，只需要索引所有元素，然后赋值即可
# [0:2，:]表示访问第1行和第2行，第二个冒号代表沿轴1的所有元素
X[0:2,:]=12
print(X)

tensor([ 8.,  9., 10., 11.])
tensor([[ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]])
tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  9.,  7.],
        [ 8.,  9., 10., 11.]])
tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

2.1.5 节省内存小技巧

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)
print('id(Z):',id(Z))
# 运用以下切片写法可以将操作的结果分配给先前分配的数组，而不会重新开辟新的空间
Z[:]=X+Y
print('id(Z):',id(Z))
#也可以用X[:]=X+Y或者X+=Y来减少操作的内存开销
print(id(X))
X+=Y#不要写成X=X+Y
print(id(X))

id(Z): 2058229593496
id(Z): 2058229593496
2058230047032
2058230047032

2.1.6转换为其他python对象

#将深度学习框架定义的张量转换为NumPy张量（ndarray），或者反过来也行。
# torch张量和numpy数组将共享它们的底层内存，就地操作更改一个张量也会同时更改另一个张量
A=X.numpy()
B=torch.tensor(A)
print(type(A))
print(type(B))
# 将大小为1的张量转换为Python标量，可以调用item函数或者python的内置函数
a=torch.tensor([3.5])
print(a)
print(a.item())
print(float(a))
print(int(a))

<class 'numpy.ndarray'>
<class 'torch.Tensor'>
tensor([3.5000])
3.5
3.5
3

2.1.7 总结+练习

总结：
深度学习存储和操作的主要接口是张量（n为数组）。它提供了各种功能，包括基本数学运算、广播、索引、切片、内存节省和转换其他Python对象。
练习：
1、将条件语句X == Y更改为X < Y或X > Y，然后看看可以得到什么样的张量？

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==Y)
print(X>Y)
print(X<Y)

tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])
tensor([[False, False, False, False],
        [ True,  True,  True,  True],
        [ True,  True,  True,  True]])
tensor([[ True, False,  True, False],
        [False, False, False, False],
        [False, False, False, False]])

2、用其他形状（例如三维张量）替换广播机制中按元素操作的两个张量。结果是否与预期相同？

a = torch.arange(3*4*2).reshape((3,4,2))
b = torch.arange(8).reshape((1, 4, 2))
print(a)
print(b)
print(a + b)

tensor([[[ 0,  1],
         [ 2,  3],
         [ 4,  5],
         [ 6,  7]],

        [[ 8,  9],
         [10, 11],
         [12, 13],
         [14, 15]],

        [[16, 17],
         [18, 19],
         [20, 21],
         [22, 23]]])
tensor([[[0, 1],
         [2, 3],
         [4, 5],
         [6, 7]]])
tensor([[[ 0,  2],
         [ 4,  6],
         [ 8, 10],
         [12, 14]],

        [[ 8, 10],
         [12, 14],
         [16, 18],
         [20, 22]],

        [[16, 18],
         [20, 22],
         [24, 26],
         [28, 30]]])

三维张量参考链接

最后

以上就是高贵大树为你收集整理的深度学习——预备知识（1）数据操作1.一些基本的概念问题理解2.预备知识的全部内容，希望文章能够帮你解决深度学习——预备知识（1）数据操作1.一些基本的概念问题理解2.预备知识所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。