TowardsDataScience 博客中文翻译 2022（二百六十四）

原文：TowardsDataScience

协议：CC BY-NC-SA 4.0

机器学习 102:逻辑回归

原文：https://towardsdatascience.com/machine-learning-102-logistic-regression-9e6dc2807772

回到分类的基础

在之前的一篇文章中，我探索了线性回归——机器学习和数据科学中使用的所有其他高级模型的基础。线性回归模型连续因变量，如股票价格。

然而，在数据科学和机器学习中，我们通常也必须处理布尔或分类相关变量。典型的布尔因变量包括像债务人的贷款违约状态——完全偿还/违约，或分类猫的图片——是猫/不是猫🐈！

用于模拟布尔因变量的最基本模型之一是逻辑回归模型。在本文中，我将深入探讨以下细节:

• 逻辑回归模型背后的基本数学。
• 布尔因变量的损失函数。
• 随机梯度下降法。
• 如何使用 Python 创建逻辑回归模型🐍。

如果您刚刚开始学习数据科学，或者尽管您已经有了很高的职业生涯，但只是想修改一些基本概念，请继续阅读，直到本文结束！

英国斯凯岛。由罗伯特·卢克曼在 Unsplash 上拍摄的照片。

布尔因变量、概率和赔率

在本节中，我们将探索逻辑回归背后的数学，从机器学习中最基本的模型开始— 线性回归。

在线性回归中，因变量 d 连续无界，与解释变量mg₁、 g ₂、… gₘ 成线性关系:

d=c₁g₁+c₂g₂+…+cₘgₘ，

其中 c ₁、 c ₂、… cₘ 为与解释变量相关联的 m 模型参数。

然而，在二进制分类问题中，因变量 d 是布尔型的: d 只有 0 或 1 的值。由于上述线性回归方程为 d 返回连续且无界的值，因此不能直接用于模拟布尔因变量。

我们可以尝试将 d 的连续输出视为一种概率。然而，我们不能有负概率或大于 1 的概率！因此， d 不能作为概率来对待。

也许我们可以试着用几率来处理它，而不是把 d 当作一种概率。赔率通过以下关系与概率密切相关:

O = P / (1 - P )，

其中 O 是赔率， P 是概率。

当概率 P 的范围为[0，1]时，赔率 O 的范围为[0，∞)使得其对于正值是无界的。我们仍然需要考虑负值。为此，我们取几率的对数 O 得到几率的对数 l :

l = log( O )，

其中 l 是连续的，有值域(-∞，∞)，并且没有任何一般性损失，log 是以 e 为底的对数。

这正是我们需要的解决方案，以便使用上面的线性回归方程，使用赔率和概率对布尔因变量进行建模！我们需要做的就是将 d 视为对数比 l :

l= log(o)= log(p/(1-p)=c₁g₁+c₂g₂+…+cₘgₘ.

我们可以重新排列这个等式，用 P 代替:

p/(1-p)= exp(c₁g₁+c₂g₂+…+cₘgₘ)
p= 1/(1+exp(-(c₁

可以更简洁地写成:

p= 1/(1+exp(-mᵀg)，

其中 m 是长度为 m 的向量，包含模型参数:m=**[c₁， c ₂，… cₘ ]ᵀ， g 也是长度为 m 的向量，包含解释变量: g 该方程也被称为逻辑函数，因此被称为“逻辑回归”！**

线性回归模型d=mᵀg已经转化为逻辑回归模型p= 1/(1+exp(-mᵀg*))，将概率 P 建模为 m 和 g 的非线性函数！请注意，原始布尔因变量 d 没有出现在逻辑回归模型中——我们只处理概率！d’稍后将再次出现在损失函数中。***

等式p= 1/(1+exp(-mᵀg*))可能很难理解，所以让我们用图表来看看最简单的可能情况。最简单的情况，P= 1/(1+exp(-g))只有 1 个解释变量 g 如下图所示。当 g 增大时， P 趋于 1，当 g 减小时， P 趋于 0。图表中还包括一些合成布尔数据点，用于 d ’ = 0 和 d ’ = 1。***

蓝色表示 P = 1 / (1 + exp(- g ))，橙色点表示 d’ = 0，绿色点表示 d’ = 1。作者创造的形象。

当 d ’ = 1 时， P 理想情况下应具有接近 1 的对应值，而当 d ’ = 0 时， P 应具有接近 0 的对应值。由逻辑回归模型定义的分类问题被简化为寻找一组模型参数m*=[c₁、 c ₂、… cₘ ]ᵀ ，这导致了这里描述的行为。***

布尔因变量的向量

在上一节中，我们算出了单布尔因变量 d 的逻辑回归方程。在现实生活中，我们更可能需要处理一个布尔因变量的向量，它对应于一组不同的测量值: d ’ = [ d’ ₁， d’ ₂，… d’ₙ ]ᵀ.

在这种情况下，对应于 d 中第 u 个元素的概率由逻辑回归模型用一组对应的 m 解释变量 Gᵤ ₁ 、Gᵤ ₂、… Gᵤₘ 来建模:

pᵤ= 1/(1+exp(-(gᵤ₁c₁+gᵤ₂c*₂+…+gᵤₘcₘ))。*****

注意， Pᵤ 只是向量中的第 u 个元素: P = [ P ₁， P ₂，… Pₙ ]ᵀ.对于 P ,该等式也可以向量形式写成:

P= 1/(1+exp(-Gm))，

其中 G 是一个大小为n×m 的矩阵，结构如下:

g=【g₁₁、 G ₁₂、… G ₁ ₘ 、
。…….[ G ₂₁、 G ₂₂、… G ₂ ₘ 、
。…….…
。…….[ Gₙ ₁， Gₙ ₂，… Gₙₘ ]]，

其中ugg第一行包含 m 解释变量的向量 Gᵤ ₁ 、Gᵤ ₂、… Gᵤₘ 、和m*=**[c₁、*******

最小化二元交叉熵损失函数

为了量化我们的逻辑回归模型的表现，我们需要最小化模型的概率预测 P 和关于模型参数 m 的布尔基础真值 d 之间的误差。

用于量化分类问题中的预测误差的最常用损失函数之一是二元交叉熵。对于第 u 个数据点，二元交叉熵为:

lᵤ(m)=-d’ᵤ原木(pᵤ(m)-(1-d’ᵤ)原木(1 - Pᵤ ( m )。

Lᵤ ( m )中的第一项仅在 d’ᵤ = 1 时有效，第二项仅在 d ’ ᵤ = 0 时有效。要获得所有 n 个数据点的损失，我们只需求和:

l(m)=σᵤlᵤ(m)。**

我们希望最小化关于模型参数 m 的损失函数 L ( m )。为此，我们将 Lᵤ ( m )相对于 m 进行区分:

∂lᵤ(m)/∂m=∂/∂m(-d’ᵤ原木(pᵤ(m)-(1-d’ᵤ)原木(1 - Pᵤ ( m ))******

这个导数看起来令人生畏，但是我们可以使用乘积法则将∂lᵤ(m)/∂m分解成更简单的成分:******

∂lᵤ(m)/∂m=∂lᵤ(m)/∂pᵤ(m∂pǐ(m)/∩m。******

术语∂lᵤ(m)/∂pᵤ(m)可以评估为:****

∂lᵤ(m)/∂pᵤ(m)=-d’ᵤ/pᵤ+(1-d’ᵤ)/(1****

而∂pᵤ(m)/∂m可以由p= 1/(1+exp(-mᵀg))计算为:******

∂pᵤ(m)/∂m=-1/(1+exp(-mᵀgᵤ)(-gt118】ᵤt121】exp(-mᵀg**********

其中gt140】ᵤ=[gₙ₁、 Gₙ ₂、… Gₙₘ ]ᵀ是包含矩阵 G 的第 u 行的向量。

使用这些结果，导数∂lᵤ(m)/∂m现在可以被评估为:**

∂lᵤ(m)/∂m=(pᵤ-d’ᵤ)/(pᵤ(1-pᵤ)gᵤ**p(1-p)**

理想情况下，我们将设置∂lᵤ(m)/∂m= 0，并求解最佳模型参数 m 。不幸的是，我们无法求解出 m ，因为它们没有出现在∂lᵤ(m)/∂m的表达式中！因此，看起来我们可能需要求助于数值方法来最小化相对于 m 的 Lᵤ ( m )。****

随机梯度下降

可以使用各种数值方法，例如牛顿法或随机梯度下降法来最小化逻辑回归模型的损失函数。对于本文，我们将探索随机梯度下降法，其变体仍在更高级的模型中积极使用，如神经网络或联邦学习框架。

随机梯度下降是一种一阶迭代优化算法，用于通过沿最陡负梯度方向迭代移动来搜索可微函数的局部最小值。如下图所示，从绿点开始，如果我们沿着蓝色曲线朝着最陡负梯度的方向继续在 x 中小步前进，最终应该会到达红点——最小点。

从绿点到红点向最陡的负梯度方向移动。作者创造的形象。

记住，我们希望相对于 m 最小化 L ( m )。利用随机梯度下降算法，我们沿着最陡负梯度的方向在 m 中采取多个小步骤:-∂lᵤ(m)/∂m向 L ( m )的最小值点前进。**

因此，我们使用∂lᵤ(m)/∂m对 d ’ = [ d’ ₁、 d’ ₂、… d’ₙ ]ᵀ:中的所有 n 元素迭代更新模型参数 m**

m:=m-r∂lᵤ(m)/∂m，******

其中 R 是某个学习率，它控制我们所走的步数的大小。

学习率的大小非常重要:如果 R 太小，步长几乎不会改变 m 的值，另一方面，如果 R 太大，那么我们可能会超过最小点！为 R 选择一个好的值取决于所涉及的数据。

随机梯度下降算法可以用伪代码编写:

****# Initialize the model parameters with some initial value.
m = initialize_m()# Iterate the algorithm until some termination condition is reached.
while termination_condition == False:
    # Shuffle the rows the training data.
    shuffle_training_data() # Iterate through all the n elements in the data.
    for i in range(n):
        # Update the model parameters m using the derivative of the 
        # loss function for that element.
        m = m - R * dLdm[i] # Check if the termination condition is reached.
    check_termination_condition()****

概述

我们已经讨论了很多细节，所以在继续用 Python 编码之前，让我们回顾一下我们已经讨论过的内容！

1. 我们希望对布尔因变量 d ’ ∈ {0，1}进行建模。
2. 我们没有直接对布尔值建模，而是使用:p= 1/(1+exp(-(c₁g₁+c₂g₂+…+cₘgₘ))对概率建模。****
3. 我们用二元交叉熵来衡量模型的预测误差:
   (m)=-d’ᵤlog(pᵤ(m)-(1-d’ᵤ)log(1-【t74
4. 为了找到最佳的模型参数 m ，我们相对于 m 最小化 Lᵤ ( m )。不幸的是，这个最小化问题必须使用数值方法来解决，例如随机梯度下降。

使用 Python 进行逻辑回归

我们现在已经做了足够的数学！在本节中，我们将使用 Python 创建一个逻辑回归模型求解器！

首先，我们定义实现逻辑回归模型的logistic_regression:

**import numpy as npdef logistic_regression(G, m):
    """
    Logistic regression model. Inputs
    G: np.array of shape nxm containing the explanatory variables.
    m: np.array of length m containing the model parameters. Returns
    P: np.array of length n containing the modeled probabilities.
    """
    return 1 / (1 + np.exp(-np.dot(G, m)))**

接下来我们定义binary_cross_entropy和binary_cross_entropy_grad，它们计算二元交叉熵及其梯度。

**def binary_cross_entropy(d, P):
    """
    Calculates the mean binary cross entropy for all n data points. Inputs
    d: np.array of length n containing the boolean dependent 
       variables.
    P: np.array of length n containing the model's probability 
       predictions. Returns
    bce: float containing the mean binary cross entropy.
    """

    # For d = 1:
    d_1 = d[d == 1] * np.log(P[d == 1])
    # For d = 0:
    d_0 = (1 - d[d == 0]) * np.log(1 - P[d == 0])
    return -np.mean(d_1) - np.mean(d_0)def binary_cross_entropy_grad(g, d, p):
    """
    Calculates the gradient of the binary cross entropy loss for a 
    single data point. Inputs:
    g: np.array of length m containing the vector of explanatory 
       variables for 1 data point.
    d: integer containing the boolean dependent variable for 1 data 
       point.
    p: float containing the model's probability predictions for 1 
       data point. Returns:
    bce_grad: np.array of length m containing the gradients of the 
              binary cross entropy.
    """
    return g * (p - d)**

最后，我们定义SGD，它执行随机梯度下降算法，使用所有数据点逐一迭代更新模型参数。

**def SGD(d, G, m, R = 0.01):
    """
    Stochastic gradient descent. Updates the model parameters m 
    iteratively using all individual data points in d.

    Inputs
    d: np.array of length n containing the boolean dependent 
       variables.
    G: np.array of shape nxm containing the explanatory variables.
    m: np.array of length m containing the initial model parameters.
    R: float containing the SGD learning rate.

    Returns
    m: np.array of length m containing the updated model parameters.
    """
    # Shuffle the data points.
    indices = np.arange(len(d))
    np.random.shuffle(indices)
    d = d[indices]
    G = G[indices] # Iteratively update the model parameters using every single
    # data point one by one.
    for i in range(len(d)):
        P = logistic_regression(G[i], m)
        m = m - R * binary_cross_entropy_grad(G[i], d[i], P) return m**

现在我们只需要一些数据来测试我们的逻辑回归求解器！我们使用从sklearn获得的鸢尾花分类数据集。原始数据集提供了 3 个不同的类:0、1 和 2。我们将数据集仅限于 0 和 1 的类。

**from sklearn.datasets import load_iris# Load the iris flower dataset from sklearn.
data = load_iris()
G = data["data"]   # Explanatory variable matrix.
d = data["target"] # Dependent variable array.# The dataset has 3 classes. For the time being, restrict the data
# to only classes 0 and 1 in order to create boolean dependent
# variables.                  
want = (d == 0) | (d == 1)G = G[want]
d = d[want]**

因为我们的逻辑回归模型

p= 1/(1+exp(-(c₁g₁+c₂g₂+…+cₘgₘ))

没有明确包括偏差项，我们需要在矩阵 G 的第一列添加一列 1。这列 1 将扮演偏置项的角色。

**# Because we do not explicitly account for a bias term in our
# logistic regression model, we need to add a column of 1s to the
# matrix G. This will play the term of the bias term.
G = np.hstack([np.ones([len(G), 1]), G])# Take a look at the first 3 data points in the dataset.
for i in range(3):
    print(G[i], d[i]) [1\.  5.1 3.5 1.4 0.2] 0
[1\.  4.9 3\.  1.4 0.2] 0
[1\.  4.7 3.2 1.3 0.2] 0**

现在我们已经准备好了数据结构 G 和 d ，是时候对模型参数 m 进行初步猜测了！由于每个数据点有 5 个解释变量，因此在 m 中将有 5 个模型参数。我们猜测模型参数的值为 1。

**m = np.ones(5)**

接下来，我们运行随机梯度下降解算器 20 次迭代，使用学习率 R = 0.01 来防止算法超过最小点。

**# Run the SGD algorithm 20 times.
for i in range(20):
    # Use a learning rate of 0.01.
    m = SGD(d, G, m, 0.01) # Calculate the mean loss for all data in the dataset.
    P = logistic_regression(G, m)
    bce = binary_cross_entropy(d, P) print("Step {:3d} : m = [ ".format(i+1), end = "")
    for j in range(len(m)):
        print("{:6.3f}".format(m[j]), end = " ")
    print("], loss = {:.3f}.".format(bce)) Step   1 : m = [  0.692 -0.506 -0.080  0.640  0.961 ], loss = 0.548\. Step   2 : m = [  0.674 -0.517 -0.207  0.854  1.050 ], loss = 0.417\. Step   3 : m = [  0.643 -0.609 -0.355  0.985  1.110 ], loss = 0.322\. Step   4 : m = [  0.629 -0.620 -0.440  1.124  1.168 ], loss = 0.258\. Step   5 : m = [  0.616 -0.638 -0.514  1.234  1.214 ], loss = 0.218\. Step   6 : m = [  0.608 -0.635 -0.568  1.337  1.257 ], loss = 0.187\. Step   7 : m = [  0.598 -0.652 -0.626  1.417  1.291 ], loss = 0.165\. Step   8 : m = [  0.592 -0.652 -0.668  1.495  1.324 ], loss = 0.148\. Step   9 : m = [  0.579 -0.691 -0.726  1.545  1.348 ], loss = 0.135\. Step  10 : m = [  0.573 -0.699 -0.765  1.605  1.373 ], loss = 0.123\. Step  11 : m = [  0.568 -0.697 -0.796  1.665  1.398 ], loss = 0.113\. Step  12 : m = [  0.563 -0.702 -0.828  1.716  1.420 ], loss = 0.104\. Step  13 : m = [  0.556 -0.716 -0.862  1.759  1.439 ], loss = 0.097\. Step  14 : m = [  0.551 -0.723 -0.891  1.802  1.457 ], loss = 0.091\. Step  15 : m = [  0.547 -0.729 -0.918  1.843  1.475 ], loss = 0.086\. Step  16 : m = [  0.542 -0.736 -0.944  1.880  1.491 ], loss = 0.081\. Step  17 : m = [  0.538 -0.741 -0.968  1.916  1.506 ], loss = 0.077\. Step  18 : m = [  0.535 -0.741 -0.987  1.953  1.522 ], loss = 0.073\. Step  19 : m = [  0.531 -0.748 -1.009  1.985  1.536 ], loss = 0.069\. Step  20 : m = [  0.528 -0.748 -1.027  2.018  1.549 ], loss = 0.066.**

从上面的结果来看，平均二进制交叉熵似乎一直在下降，这意味着该模型应该朝着一组令人满意的参数收敛，所以接下来让我们检查该模型的准确性。由于这是一个小数据集，我们将简单地直接打印所有 n 个数据点的结果，并直观地检查它们。

**# Print the ground truth.
print(d)# Print the modeled probabilities of the logistic regression model, 
# rounded to the nearest integer value.
print(np.round(logistic_regression(G, m)).astype(int)) [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1][0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]**

似乎我们的模型已经完美地分类了数据集中的每一个数据点！接下来让我们仔细看看模型的实际非舍入输出，包括 d ’ = 1 和 d ’ = 0 两种情况。

**# Get the probability predictions from the model.
P = logistic_regression(G, m)# d' = 0
print("d' = {}, P = {:.3f}.".format(d[0], P[0]))
# d' = 1
print("d' = {}, P = {:.3f}.".format(d[-1], P[-1])) d' = 0, P = 0.023\. 
d' = 1, P = 0.975.**

我们看到，当 d ’ = 1 时， P 非常接近 1，当 d ’ = 0 时， P 非常接近 0——这正是我们预期的行为！

提醒一句

在上面的例子中，使用的数据是非常容易分离的。也就是说， d ’ = 1 和 d ’ = 0 之间的解释变量存在明显差异。这就是我们如何在预测中获得完美结果的。

在实际的数据科学项目中，数据通常没有这么干净——我们需要设计数据中的特征，考虑 d 中 0 和 1 的数量之间的比例，以及微调模型训练过程。根据数据，其他损失函数，如聚焦损失或正则化损失函数可能比二元交叉熵更好。

在本文中，我们使用随机梯度下降来最小化损失函数。随机梯度下降并不总是适用于所有数据集，在其他数据集中，其他更高级的优化算法，如有限内存 BFGS 或 Adam 可能适用。

指标也是另一个需要考虑的重要因素。在上面的例子中，我们简单地比较了模型的输出。在现实生活中，对于包含数千个数据点的数据集，这种方法显然是行不通的！使用哪种指标将取决于所涉及的数据。分类中使用的常用指标包括准确度、接收器工作特性或精确度和召回率。

此外，我们在用于训练模型的数据上测试了我们的模型——实际上，整个数据集应该分成训练和验证数据集！该模型应在训练数据集上进行训练，然后在验证数据集上进行测试-这是为了确保该模型不只是记住了训练数据集，而且能够将其预测推广到以前没有见过的数据！

数据科学和机器学习是极其深入和广阔的领域！一旦你完全理解了基本原理是如何工作的，那么就开始花些时间探索更高级的话题吧！

摘要

在本文中，我们探索了逻辑回归模型背后的数学，并使用 Python 创建了一个基于随机梯度下降的求解器！今天探索的概念，如使用数值方法最小化损失函数可能是基本的，但适用于所有其他高级模型，如深度学习图像分类或分割模型！我希望您能够更好地理解分类模型今天是如何工作的。一如既往的感谢您的阅读，下篇文章再见！

参考

[1] W. M. Menke (2012)，地球物理数据分析:离散逆理论 MATLAB 版，Elsevier。
【2】艾伦·b·唐尼(2014)，Think Stats Python 中的探索性数据分析，绿茶出版社。

机器学习 103:损失函数

原文：https://towardsdatascience.com/machine-learning-103-loss-functions-37b84f3e9b73

为什么机器学习是一个优化问题

在之前的两篇文章中，我介绍了机器学习中使用的两个最基本的模型——线性回归和逻辑回归。在这两种情况下，我们感兴趣的是搜索产生被观察目标 d 的最佳模型预测**d’的一组模型参数 m ，并且在这两种情况下，这是通过最小化一些损失函数 L ( m )来完成的，该损失函数测量d’**和 d 之间的误差。

很大一部分机器学习——从简单的线性回归到深度学习模型，本质上都涉及某种损失函数的最小化——然而，许多数据科学或机器学习书籍/教程/材料往往更强调模型本身，而不是损失函数！在这篇文章中，我们将继续前两篇文章的内容，并在以后的文章中探索更高级的模型之前，重点关注损失函数！

美国肯塔基州观测到的美丽日食。照片由李宗盛在 Unsplash 拍摄。

简而言之，训练机器学习模型

很大一部分训练机器学习模型可以简化如下:

1. 我们有一组观察目标 d 和一组相应的解释变量 G 。我们希望使用相应的新值 G 来预测新值 d 。 d — G 对的例子包括信用分析中的贷款违约状态—信用数据，物理实验中的摆的周期—摆长的平方根，或者猫狗图像分类中的图像标签— RGB 图像🐈/🐕。
2. 我们想要创建一个机器学习模型 f ( G ， m )，该模型使用一组模型参数 m 在给定一些解释变量G:d’=f(G， m )的情况下对 d 进行预测。
3. 训练模型 f ( G ， m )本质上是寻找能够给出最佳预测的 m 。使用某种损失函数 L ( m )来衡量模型预测的质量； d ，d’)，为了方便起见我们写成 L ( m )。损失函数本质上是测量**d’**和 d 之间的误差，一般来说 L ( m )的值越小，模型的预测越好。
4. 当我们最终找到导致最小 L ( m )值的 m 时，我们就结束了我们的搜索——对于给定的一组 d 和 G ，我们已经最小化(或优化) L ( m )！

现在，正如“最佳”是一个非常主观的词，损失函数也是如此！在某些情况下，一些损失函数会比其他函数更好，使用好的损失函数可以显著提高模型性能！不幸的是，对于某些任务，找到一个好的损失函数可能是一个不小的问题。

在许多情况下，我们通常从众所周知的损失函数开始，然后再转向更复杂的损失函数。通过使用不同的损失函数重新创建模型，我们通常最终会找到产生最佳性能模型的东西！

在接下来的两节中，我们将讨论回归和分类问题中使用的一些损失函数。

线性回归的损失函数

对于这里的回归损失函数，我们将预测值和观测值之间的误差定义为: eᵤ ( m )是向量的第 u 个元素:

e(m)=d-f(G， m )，

而 mᵥ 是矢量 m 的第 v 个元素。

为了进一步显示不同回归损失函数的效果，我们对以下问题执行线性回归:通过由等式产生的 19 个点找到最佳拟合曲线:

y(x)= 3x-x+2、

在原始数据集的右侧添加了两个异常点。

从 y(x)= 3x-x+2 中抽取的一些数据点，有两个离群点。作者创作的人物。

• 均方误差(L2 范数)
  l(m)=σᵤ*(eᵤ(m))。
  这可能是回归问题最广泛使用的损失函数，假设数据中的噪声来自高斯分布。由于误差的平方，该损失函数受到异常值的强烈影响，如下图所示。*

使用 L2 范数误差(均方差)训练的模型的最佳拟合曲线。L2 范数误差受离群数据点的影响。作者创作的人物。

• 平均绝对误差(L1 范数)
  l(m)=σᵤ*|eᵤ(m)|。
  该损失函数不像均方误差那样广泛使用，因为它假设数据中的噪声来自指数分布。由于使用了误差的绝对值，该损失函数不会受到异常值的强烈影响，如下图所示——最佳拟合曲线完全忽略了两个异常点！*

使用 L1 范数误差(平均绝对误差)训练的模型的最佳拟合曲线。L1 范数误差不受离群数据点的强烈影响。作者创作的人物。

• Lasso 正则化均方误差(L2 范数带 L1 正则化)
  l(m)=σᵤ*(eᵤ(m)+λσᵥ|mᵥ|，其中λ为待指定的超参数。如果λ = 0，这个损失函数就变成了均方误差。
  如果数据包含许多异常值，则使用 lasso 正则化均方误差，但如果假设数据中的噪声来自高斯分布。实质上，套索正则化迫使模型参数尽可能接近零。lasso 误差损失函数受异常数据点的影响不如正则化项导致的均方误差大，但比误差项平方导致的平均绝对误差大，如下图所示。*

使用套索误差训练的模型的最佳拟合曲线。lasso 误差受异常数据点的影响不如均方差大，但比平均绝对误差大。作者创作的人物。

• 岭正则化均方误差(L2 范数加 L2 正则化)
  l(m)=σᵤ*(eᵤ(m)+λσᵥmᵥ，其中λ为待指定的超参数。如果λ = 0，这个损失函数就变成了均方误差。
  岭正则化均方误差用于数据中存在多重共线性。理想情况下，解释变量中的任何两个特征都不应该相互关联。然而，这有时是无法避免的，可以使用岭正则化来确保模型参数具有相同的大小。下图显示了岭正则化线性回归模型的最佳拟合曲线。*

使用岭误差损失函数训练的模型的最佳拟合曲线。如果数据中存在多重共线性，则岭误差会变得有意义，但这里的情况并非如此。作者创作的人物。

逻辑回归的损失函数

在机器学习 102:逻辑回归中，我们展示了对于分类问题，我们建模概率而不是实际类别。因此，分类问题中使用的损失函数直接处理来自模型的概率输出:p(m)=f(G， m )。

为了进一步显示不同损失函数的影响，我们对用 scikit-learn 打包的乳腺癌数据集进行了逻辑回归。原始数据集有 357 个良性(1 级)和 212 个恶性(0 级)数据点。虽然原始数据集已经不平衡，但我们通过将恶性数据点的数量减少到 50 个来进一步扭曲数据，导致 1 类和 0 类之间的比例为 87:12。

• 二元交叉熵
  L(m)=-(ylog(p(m)+(1-y)log(1-p(m))。
  这是最广泛使用的二元分类损失函数。对于多类分类，存在一个等价的分类。然而，由于二进制交叉熵平等地对待类 0 和类 1，因此它通常不适合不平衡的数据集，这可以从下面的分类报告中看出-训练的模型无法检测类 0 的任何实例。

 *precision    recall  f1-score   support 0       0.00      0.00      0.00        15 
           1       0.85      1.00      0.92        87 accuracy                           0.85       102
   macro avg       0.43      0.50      0.46       102
weighted avg       0.73      0.85      0.79       102*

• 焦十字熵
  l(m)=-(y**α(1-p(m)ᵞlog(p(m)+(1-y如果 α = 1 且 γ = 0，则该焦交叉熵损失转化为二元交叉熵损失。默认情况下， α = 0.25， γ = 2。
  焦点交叉熵损失是对二元交叉熵损失的扩展，它考虑了具有比例因子的两个类别的比例: α 和(1 - α ，并迫使模型关注具有调制因子的错误分类预测:(1-p(m)ᵞ和p*(【)对于不平衡数据集，焦点交叉熵损失往往优于二进制交叉熵损失，如下面的分类报告所示-训练模型现在更能够检测类 0 的实例。*

 *precision    recall  f1-score   support 0       1.00      0.87      0.93        15
           1       0.98      1.00      0.99        87 accuracy                           0.98       102
   macro avg       0.99      0.93      0.96       102
weighted avg       0.98      0.98      0.98       102*

复杂模型的损失函数

在前两节中，我们介绍了回归和分类模型中一些常用的损失函数。上面的列表并不详尽，还有许多其他更复杂的损失函数！此外，某些机器学习算法使用特别定制的损失——例如铰链损失被广泛用于支持向量机，而基尼杂质被广泛用于基于决策树的模型。

此外，深度学习模型等高度复杂模型的损失函数往往具有多个局部最小值。在这种情况下，在模型训练期间，优化过程很可能陷入局部最小值，而不是收敛到损失函数的全局最小值。因此，对于复杂模型，通常使用不同的随机生成的初始模型参数同时训练几个模型，以增加模型收敛的机会，并使用随机优化器，如随机梯度下降，以随机将优化器踢出局部最小值。

摘要

在本文中，我们仔细研究了损失函数在训练机器学习模型中所起的作用，以及使用不同的损失函数如何导致同一组数据的非常不同的模型性能。使用适当的损失函数将确定回归模型是否过度拟合离群数据点，或者分类模型是否过度拟合多数类。数据科学家和机器学习工程师应该注意使用适合他们正在处理的问题的损失函数！

参考

[1] W. M. Menke (2012)，地球物理数据分析:离散逆理论 MATLAB 版，Elsevier。

[2] C. M. Bishop (2006)，模式识别与机器学习，Springer

[3]宗-林逸，普里亚·戈亚尔，罗斯·吉尔希克，明凯·何和皮奥特·多勒(2018)， 密集物体探测的焦损失 ， arXiv:1708.02002 。

机器学习:科学的朋友还是敌人？

原文：https://towardsdatascience.com/machine-learning-a-friend-or-a-foe-for-science-9c0b421eabd8

机器学习如何影响科学再现性以及如何解决它

图片由作者使用 DALL-E 2 拍摄

再现性是科学进步的基础，但机器学习的日益使用正在影响它。为什么再现性很重要？为什么机器学习的使用有一个有问题的副作用？我们如何解决它？

并非所有闪亮的东西都是钻石

复制另一篇文章的结果。图片由作者使用 DALL-E 2

2016 年，科学杂志《自然》发表了一项调查的结果。他们要求 1576 名研究人员回答一份关于研究中可重复性的简短问卷。结果显示，超过 70%的科学家未能重现另一位研究员的实验。调查中超过 50%的研究人员宣称存在再现性危机。

这个问题涉及到所有的科学学科，从医学到生物学，从经济学到物理学，从心理学到化学。这位科学家回答说，这背后的主要原因是两个因素:发表的压力(“发表或灭亡”)和选择性报道。其他人指出，统计能力低和技术困难也可能是一个原因。事实上， p 值和其他统计方法正在接受审查以找到更好的方法来分析数据。

研究人员宣称，当试图复制学术发现时，不到 40%的尝试是成功的。此外，实验室中的许多本科生对复制失败感到沮丧(导致他们精疲力竭)。此外，通常当一位科学家能够复制这些发现时，其结果远不如最初的论文热情(效应的大小远小于宣称的)。事实上，通常他们所寻求的突破性发现对结果的影响要小得多。

"疯狂的定义是一遍又一遍地做同样的事情，却期待不同的结果."归功于爱因斯坦

然而，再现性危机的影响超出了学术界。该行业经常试图重现研究人员的发现。例如，制药公司正在寻找有前景的研究，以开发新的潜在疗法。然而，他们在复制结果时也遇到了困难。这是导致 II 期临床试验成功率(尤其是肿瘤学)较低的原因之一。

你能信任这台机器吗？

在过去的十年里，机器学习已经在许多不同的领域产生了影响(从政治学到心理学，从物理学到生物医学)。例如，欧洲核子研究中心的实验或新的韦伯望远镜正在产生大量的数据。在医学领域，有成千上万的电子病历、庞大的患者数据图像数据集等等。生物学也是如此，由于组学革命，我们正在积累数据。

越来越多的政治学文章使用机器学习(这里的术语“内战”和“机器学习”用于数据库中的研究)。图片来源(原文)。

因此，数据科学和机器学习为许多研究应用找到了空间。然而，最近发表的一篇文章对机器学习在科学中的应用投下了阴影。

“机器学习正在作为一种工具出售，研究人员可以在几个小时内学会并自行使用。但是你不能指望一个化学家能够通过网络课程学习如何管理实验室”——萨亚什·卡普尔在《自然》杂志上说

作者在不同的科学领域使用机器学习方法时发现了不同的错误。事实上，作者对 20 篇科学文章(17 个研究领域的 20 篇综述)进行了元分析，发现了 329 篇研究论文的结果无法重复，他们确定了机器学习错误应用的原因。该图显示，大多数论文中的突出错误是某种形式的数据泄漏。

对 20 篇科学文章的调查，这些文章确定了在不同领域采用机器学习方法的陷阱。在表中，代表某种形式的数据泄漏的标题被作者用粗体突出显示。图片来源(原创文章)。

用胶带封好你的管子(管线)

在 Unsplash.com，米凯拉·帕兰特拍摄的照片

数据泄露，在机器学习中，是指模型在训练期间访问了不应该被允许看到的信息。例如，它应该是测试集和训练集之间的信息泄漏，因为模型将在其上进行评估。事实上，由于模型已经看到了答案，它会比现实中表现得更好。

虽然防止某些形式的数据泄漏(如缺少测试集、重复条目)很容易，但其他形式的泄漏则更加微妙。数据集预处理过程中的一个常见错误是缺乏训练和测试的清晰分离。事实上，标准化、缺失值插补和过采样/欠采样步骤应该在训练集和测试集上分别执行。此外，即使不太明显，特征选择应该为训练集和测试集分别执行(否则模型将知道哪些特征在集合上执行得更好)。

事实是，作为一名数据科学家，你随时都有可能出现数据泄露的情况，比如准备、清理数据、估算缺失值、删除异常值等。——做数据科学:直话直说

一个常见但更难注意到的错误是时间泄漏，即来自较晚时间的数据点包含在测试数据中。例如，如果用于预测股票价值的模型是用未来的数据点训练的。例如，2011 年，研究人员声称他们的模型可以利用 Twitter 用户的情绪预测股市。然而，令人难以置信的准确性(87%)是由于时间泄漏误差。要处理的其他复杂错误是训练和样本之间的非独立性(例如，训练和测试集包含来自相同患者的图像)和测试分布中的采样偏差。

有趣的是，作者正确地表明了数据泄漏错误对许多模型的性能有很大的影响。

该图表明，通过纠正不同政治学文章中的数据泄漏错误，已发布模型的性能正在急剧下降。图片来源(原创文章)。

此外，研究人员经常声称他们的模型比其他模型表现更好。作者表明，通过纠正数据泄漏错误，复杂模型(如随机森林、 AdaBoost 、梯度增强树等)实际上比简单模型(如逻辑回归)表现更差。下表中有几个例子:

由于某些情况下的数据泄漏，复杂模型比逻辑回归表现得更好。图片来源(原文)。

结论

再现性是科学的基础。随着机器学习和人工智能在科学领域的使用越来越多，再现性面临着额外的变化。事实上，这种重复性的缺乏正在影响从科学论文中获得应用的可能性。

传统上，科学论文在发表之前必须通过一个被称为同行评议的过程(论文由该领域的专家进行修改)。然而，如今的评论者更难找到(因为他们没有报酬)，而且他们往往对机器学习知之甚少。因此，文章中的方法错误很容易在审查过程中被忽略。

“到目前为止，人工智能最大的危险是，人们过早地断定他们理解它。”—埃利泽·尤德科夫斯基

作者在文章中提出了一个模型信息表，以确保科学论文检测/防止数据泄漏。然而，许多科学文章呈现不完整的方法部分，并且经常不发布代码。此外，代码通常写得不好或者没有适当的文档，因此很难重用。因此，科学期刊的编辑在选择审稿人时应该更加小心，并要求根据标准指南发布和记录代码。

例如，心理学从统计学的使用中获得了有益的效果，但是它的粗心使用造成了再现性问题。同样，机器学习(和人工智能)在科学研究中具有变革力量，但应该由专家来处理(或至少与知道如何使用它的人合作)。

其他资源

• 关于再现性危机(此处，此处)
• 关于数据泄露(此处，此处)
• 机器学习中的再现性(这里，这里)

如果你觉得有趣:

你可以寻找我的其他文章，你也可以 订阅 在我发表文章时获得通知，你也可以在**LinkedIn**上连接或联系我。感谢您的支持！

这是我的 Github 知识库的链接，我计划在这里收集代码和许多与机器学习、人工智能等相关的资源。

**https://github.com/SalvatoreRa/tutorial

或者随意查看我在 Medium 上的其他文章:

**

机器学习算法备忘单

原文：https://towardsdatascience.com/machine-learning-algorithms-cheat-sheet-2f01d1d3aa37

5 种常见算法的快速参考指南

凯勒·琼斯在 Unsplash 上拍摄的照片

机器学习的“ 没有免费的午餐” 定理指出，没有单一的机器学习算法可以解决所有类型的机器学习问题。

机器学习任务可能会有很大差异，算法的选择将取决于数据的大小、维度和稀疏性等因素。目标变量、数据质量以及特征内部和特征与目标变量之间存在的相互作用和统计关系。

因此，不可能简单地选择一种算法用于“一刀切”的方法。不同的算法将更适合特定的任务，这取决于它们的具体工作方式。数据科学家通常会选择最终使用的算法，首先确定适合特定问题的算法子集，然后对这些算法进行实验以找到最佳选择。

在本文中，我将提供一个快速参考指南，介绍机器学习中最常用的五种算法。这将介绍算法的内部工作原理，以及使每个算法更适合某些任务的考虑因素。

这将包括对线性回归、逻辑回归、随机森林、XGBoost 和 K-means 的简要介绍。对于每个算法，我将涵盖以下内容:

1. 算法如何工作。
2. 一个示例代码实现。
3. 在适当情况下使用算法的指南。
4. 优缺点。

1.线性回归

线性回归是一种受监督的机器学习算法，用于预测连续的目标变量。对于简单的线性回归，其中有一个自变量(特征)和一个因变量(目标)，该算法可由以下等式表示。

y = a + bX

其中 y 为因变量， X 为解释变量，b为直线的斜率， a 为截距。

简单的线性回归可视为散点图，其中 x 轴包含因变量，y 轴包含自变量。线性回归算法通过数据点绘制一条最佳拟合线，使预测输出和实际输出之间的差异最小化。

线性回归。作者图片

代码示例

应该在什么时候使用？

• 线性回归只能用于解决基于回归的问题。
• 因变量和自变量之间必须有线性关系。
• 残差必须形成正态分布。
• 特征之间必须没有相关性。
• 该算法假设训练数据是随机采样的。
• 最适合基于回归的问题，其中数据中的关系既线性又简单。

优势

• 高度可解释性和快速训练。
• 在线性可分数据上表现非常好。

不足之处

• 对异常值不稳健。
• 非常简单，因此它不能很好地模拟现实世界数据中的复杂性。
• 这种算法也容易过拟合。

2.逻辑回归

逻辑回归本质上是为适应分类问题而建模的线性回归。逻辑回归不是拟合直线，而是应用逻辑函数 来压缩 0 和 1 之间的线性方程的输出。结果是穿过数据点的 S 形曲线而不是直线，如下图所示。

逻辑回归曲线。作者图片

选择介于 0 和 1 之间的阈值来分隔类别，通常为 0.5。本质上，我们在 0.5 处画一条横过 S 曲线的水平线。这条线以上的任何数据点都属于 1 类，线以下的任何数据点都属于 0 类。

代码示例

应该在什么时候使用？

• 这种算法只能用于解决分类问题。
• 特征和目标变量之间必须有线性关系。
• 观察值的数量必须大于特征的数量。
• 最适合于数据关系既线性又简单的分类问题。

优势

• 与线性回归一样，该算法可解释性强，训练速度快。
• 它在线性可分数据上表现非常好。

不足之处

• 容易过度拟合。
• 与线性回归一样，它不能很好地模拟复杂的关系。

3.随机森林

随机森林算法构建了一个决策树的“森林”。森林中的每棵树都根据一组给定的特征生成一个预测。一旦生成了所有预测，就进行多数投票，并且最常预测的类别形成最终预测。

随机森林生成的单一决策树。作者图片

决策树是一种非常直观的算法。它有一个类似流程图的结构，包含一系列代表测试的节点。每个测试的结果导致一个分裂，并且一个或多个叶节点被创建，直到实现最终预测。超参数决定了树增长的深度和使用的节点分裂函数。

随机森林算法遵循以下步骤序列:

1. 根据森林中树木的数量，将训练数据集随机分成多个样本。树的数量通过超参数设置。
2. 使用其中一个数据子集并行训练决策树。
3. 评估所有树的输出，并将最常发生的预测作为最终结果。

代码示例

应该在什么时候使用？

• 该算法可用于解决基于分类和回归的问题。
• 由于该算法固有地执行特征选择，因此它特别适合于具有高维数的大型数据集。

优势

• 它可以模拟线性和非线性关系。
• 它对异常值不敏感。
• 随机森林能够在包含缺失数据的数据集上运行良好。

不足之处

• 随机森林很容易过度适应，虽然这可以通过修剪得到一定程度的缓解。
• 它不像线性回归和逻辑回归那样具有可解释性，尽管可以提取特征重要性来提供某种程度的可解释性。

4.XGBoost

XGBoost 是一种基于梯度推进决策树的算法。它与 Random Forest 相似，都是构建一个决策树集合，但 XGBoost 不是并行训练模型，而是顺序训练模型。每个决策树从先前模型产生的错误中学习。这种顺序训练模型的技术被称为增强。

XGBoost 中的梯度指的是使用弱学习者的特定类型的增强。弱学习者是非常简单的模型，仅仅比随机机会表现得更好。该算法从一个初始的弱学习者开始。每个随后的模型都以先前决策树产生的错误为目标。这种情况会持续下去，直到无法取得进一步的改进，并最终形成一个强学习者模型。

代码示例

应该在什么时候使用？

• 它可用于解决基于分类和回归的问题。
• XGBoost 通常被认为是对结构化数据进行监督学习的最佳和最灵活的算法之一，因此适用于广泛的数据集和问题类型。

优势

• XGboost 非常灵活，在小型和大型数据集上都能很好地工作。
• 与其他复杂算法相比，该算法计算效率高，因此训练模型更快。

不足之处

• 它不能很好地处理非常稀疏或者非结构化的数据。
• 它被认为是一个黑盒模型，比其他一些算法更难解释。
• 由于模型从其前辈的错误中学习的机制，XGBoost 可能对异常值很敏感。

5.k 表示

K-means 是最流行的聚类算法之一，这是一种无监督的机器学习形式，旨在找到训练数据集中的相似示例组。

该算法首先初始化随机聚类质心。然后，对于每个数据点，通常使用距离度量 欧几里德 距离或 余弦 相似度来将其分配给最近的质心。一旦分配了所有数据点，质心就移动到所分配数据点的平均值。重复这些步骤，直到质心分配停止变化。

k-意味着具有可视化质心的簇。作者图片

代码示例

应该在什么时候使用？

• K-means 只适合于非监督聚类。
• 对于这类问题，它通常被认为是一个很好的全能算法。

优势

• 这是一个实现起来相对简单的算法。
• 它可以用于大型数据集。
• 由此产生的聚类很容易解释。

不足之处

• k 均值对异常值很敏感。
• 该算法没有找到最佳的聚类数。这必须在实现之前通过其他技术来确定。
• 聚类的结果不一致。如果 K-means 在数据集上运行多次，每次都会产生不同的结果。

本文涵盖的算法是机器学习中最广泛使用的一些算法。还有许多算法可供使用，每一种算法都有自己适合特定问题的地方。正如本文开头提到的，目前没有一种算法可以解决所有问题，尽管 XGBoost 是解决结构化数据问题的最接近的算法。

这一介绍将提供一些关于数据科学家如何以及为什么选择一种算法而不是另一种算法的见解。下面是每种算法对特定类型问题的适用性的简要总结:

• **线性回归:**最适合解决基于回归的数据集问题，其中存在线性关系，且关系相对简单。
• **逻辑回归:**最适合解决数据线性可分、数据集维度低的分类问题。
• **随机森林:**最适合具有复杂关系的大型高维数据集。
• XGBoost: 适用于广泛的结构化数据集和问题。与随机森林相比，计算效率更高。
• K-means: 最适合解决无监督聚类问题。

感谢阅读！

承认

iris 数据集用于生成本文中的决策树图: 该数据集用于 r . a . Fisher 1936 年的经典论文， 分类问题中多重测量的使用 。它是在 CCO 1.0 通用版(CCO 1)许可下使用的。

机器学习与 Rust(第四部分):Torch 中的神经网络

原文：https://towardsdatascience.com/machine-learning-and-rust-part-4-neural-networks-in-torch-85ee623f87a

我们可以在 Rust 中使用 PyTorch 吗？什么是锈绑定？tch-rs 是什么？Rust 中的神经网络研究

乔尔·菲利普在 Unsplash 上拍摄的图片

自从我们上次看到 Rust 及其在机器学习中的应用已经有一段时间了——请向下滚动到底部，查看以前关于 ML 和 Rust 的教程。今天我将向大家介绍 Rust 中的神经网络。存在一个铁锈火炬，它允许我们创建任何我们想要的神经网络。捆绑是焊炬落地的关键。绑定允许创建外部函数接口或 FFI，这在 Rust 和用语言编写的函数/代码之间建立了一座桥梁。在 Rust nomicon 中可以找到很好的例子

要用 C 和 C++创建绑定，我们可以使用 bindgen，一个由自动生成 Rust FFI 的库。从绑定到 PyTorch 的 C++ api， Laurent Mazare 已经帮助 Rust 社区拥有了一个 Rustacean 版本的 PyTorch。正如 GitHub 页面所说，tch 在 C++ libtorch 周围提供了薄薄的包装。最大的好处是，这个库和原来的严格相似，所以没有学习障碍需要克服。核心代码相当易读。

初始化和线性:让我们学习巨人肩膀上的铁锈

首先，我们来看一下代码。这是进一步了解 Rust 基础设施的最佳起点。

首先，为了对 Rust FFI 有所了解，我们可以查看这些文件。其中大部分是自动生成的，而 Laurent 和他的同事们已经编写了大量代码，将 c++ Torch API 与 Rust 连接起来。

下面，我们就可以开始阅读src中的核心代码了，具体来看一下[init.rs](https://github.com/LaurentMazare/tch-rs/blob/main/src/nn/init.rs:)。在定义了一个enum Init 之后，有一个公共函数pub fn f_init ，它匹配输入初始化方法并返回一个权重张量和一个偏差张量。我们可以学习 C 中反映switch的match和 Python 3.10 中的match的用法。权重和偏差张量通过随机、统一、明凯或正交方法初始化(图 1)。

图 Rust 中的匹配大小写，它反映了 C 中的 switch 和 Python 3.10 中的 match

然后，对于类型enum Init，我们有了方法实现 [impl Init](https://github.com/LaurentMazare/tch-rs/blob/a022da9861efbe66a4920d318166341c3a60be9e/src/nn/init.rs#L82) 。实现的方法是一个 setter pub fn set(self, tensor: &mut Tensor)，这是一个很好的例子来进一步理解 Rust 中所有权和借用的概念:

图 init 的实现。注意&mut 张量，这是解释 Rust 中借力的一个很好的例子。

我们在第一个教程中谈到了借贷。现在是更好地理解这个概念的时候了。假设我们可以有一个类似的set函数:

pub fn set(self, tensor: Tensor){}

在主代码中，我们可以调用这个函数，传递一个张量Tensor。Tensor会被设定，我们会很开心。但是，如果我们再次在Tensor上呼叫set呢？嗯，我们会遇到错误value used here after move。这是什么意思？这个错误告诉你你把Tensor移到了set。 A *move* 表示您已经将所有权转让给了set中的self，当您再次调用set(self, tensor: Tensor)时，您希望将所有权归还给Tensor以便再次设置。幸运的是，在 Rust 中这是不可能的，而在 C++中则不同。在 Rust 中，一旦一个 *move* 已经完成，分配给该进程的内存将被释放。因此，我们在这里要做的是将Tensor的值借用给set，这样我们就可以保留所有权。为此，我们需要通过引用调用Tensor，因此tensor: &Tensor。因为我们预计Tensor会发生变异，所以我们必须添加mut以便:tensor: &mut Tensor

接下来，我们可以看到另一个重要的元素，它很简单，使用了Init类:[Linear](https://github.com/LaurentMazare/tch-rs/blob/main/src/nn/linear.rs)，即一个完全连接的神经网络层:

图 3:定义线性结构并为其实现默认配置

图 3 显示了建立一个完全连接的层是多么容易，它由一个权重矩阵ws_init和偏置矩阵bs_init组成。重量的默认初始化是通过super::Init::KaimingUniform完成的，这是我们在上面看到的功能。

然后可以使用功能linear创建主全连接层。正如您在函数签名中看到的，也就是在<...>之间，有一些有趣的事情(图 4)。其一， 一生注释 ['a](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html)。如上所述，Rust 会自动识别变量何时超出范围并被释放。我们可以注释一些变量，让它们有一个特定的生命周期，这样我们就可以决定它们能活多久。标准注释是'a，其中'表示寿命参数。需要记住的一件重要事情是，这个签名不会修改函数中的任何内容，但是它告诉函数借用者识别所有那些其生存期可以满足我们所施加的约束的变量。

图 4:实现完全连接的神经网络层的功能。在函数签名中，您可以注意到一个生存期注释和一个通用变量 T，它从 nn::Path 借用了一个值

第二个参数是T: Borrow<super::Path<'a>这个注释的意思是:取 [var_store.rs](https://github.com/LaurentMazare/tch-rs/blob/2c2b4545966be04e8377ffa7f34fe01b9a20acd0/src/nn/var_store.rs#L40)中指定的nn::Path ，把这个类型借用到T。Rust 中的任何类型都可以自由借用为几种不同的类型。该类型将用于定义输入硬件(如 GPU)，如您在vs:T中所见。最后，网络的输入和输出维度与LinearConfig一起被指定为整数in_dim: i64, out_dim: i64，用于初始化权重和偏差c: LinearConfig.

让我们与巨人同行:你在 Rust 的第一个神经网络

是时候弄脏我们的手玩火炬锈了。让我们使用 MNIST 数据集建立一个简单的线性神经网络，然后是序列网络，最后是卷积神经网络。一如既往，你可以在我的 ML ❤生锈回购上找到所有的材料。 Yann LeCun 和 Corinna Cortes 拥有 MNIST 数据集的版权，并已根据知识共享署名-类似共享 3.0 许可证的条款提供。

Rust 中的一个简单神经网络

和往常一样，新 Rust 项目的第一步是cargo new NAME_OF_THE_PROJECT，在这里是simple_neural_networks。然后，我们可以开始用我们需要的所有包设置Cargo.toml:我们将使用mnist、ndarry，显然还有tch——图 5。我决定使用mnist提取原始的 MNIST 数据，这样我们可以看到如何转换和处理数组和张量。请随意使用tch.中已经存在的vision资源

图 5: Cargo.toml 用于建立一个简单的线性神经网络。

我们将使用mnist下载 MNIST 数据集，使用ndarray对图像向量执行一些转换，并将它们转换成tch::Tensor。

让我们跳到main.rs代码。简而言之，我们需要:

1. 下载并提取 MNIST 图像，并返回用于训练、验证和测试数据的向量。
2. 从这些向量中，我们必须执行一些到Tensor的转换，这样我们就可以使用tch。
3. 最后，我们将实现一系列时段，在每个时段中，我们将输入数据乘以神经网络权重矩阵，并执行反向传播来更新权重值。

mnist自动从下载输入文件到这里。我们需要在Cargo.toml中添加features = ['download']来激活下载功能。下载文件后，提取原始数据download_and_extract()，并细分为训练集、验证集和测试集。注意，主函数不会返回任何东西，所以您需要在代码末尾指定-> Results<(), Box<dyn, Error>>和Ok(())(图 6)

图 6:从 mnist::MnistBuilder 下载、提取和创建训练、验证和测试集。

现在，代码的第一件事:将一个数组转换成Tensor.，mnist的输出数据是Vec<u8>。训练向量结构具有TRAIN_SIZE个图像，其尺寸是HEIGHT乘以WIDTH。这三个参数可以指定为usize类型，与输入数据向量一起，可以传递给image_to_tensor函数，如图 7 所示，返回Tensor

图 7: image_to_tensor 函数，给定输入数据向量、图像数量、高度和宽度，我们将返回 tch::Tensor

输入的Vec<u8>数据可以用from_shape_vec整形到Array3，数值被归一化并转换到f32，即.map(|x| *x as f32/256.0)。从一个数组很容易建立一个火炬张量，如第 14 行所示。对于我们的训练数据，输出张量大小为dim1 x (dim2*dim3)，设置TRAIN_SIZE=50'000、HEIGHT=28和WIDTH=28，输出训练张量大小为50'000 x 784。

类似地，我们将标签转换为张量，其大小将为dim1 —因此对于训练标签，我们将有一个50'000长张量https://github . com/ste boss/ML _ and _ Rust/blob/aa7d 495 C4 a2 C7 a 416d 0b 03 Fe 62 e 522 b 6225180 ab/tutorial _ 3/simple _ neural _ networks/src/main . RS # L42

我们现在准备开始处理线性神经网络。在权重和偏差矩阵的零初始化之后:

let mut ws = Tensor::zeros(&[(HEIGHT*WIDTH) as i64, LABELS], kind::FLOAT_CPU).set_requires_grad(true);let mut bs = Tensor::zeros(&[LABELS], kind::FLOAT_CPU).set_requires_grad(true);

类似于 PyTorch 实现，我们可以开始计算神经网络权重。

图 8:主要训练功能。对于 N _ EPOCHS，我们在输入数据和权重及偏差之间执行 matmul。计算每个历元的精确度和损失。如果两个连续损失之间的差异小于三，我们停止学习迭代。

图 8 示出了运行线性神经网络训练的主例程。首先，我们可以用'train给最外层的 for 循环命名，在这种情况下，撇号不是生命期的指示器，而是循环名的指示器。我们正在监控每个时期的损失。如果两个连续的损失差小于THRES，当我们达到收敛时，我们可以停止最外面的循环——你可以不同意，但目前让我们保持它:)整个实现非常容易阅读，只是在从计算的logits中提取精度时需要注意一点，工作就完成了:)

当你准备好了，你可以直接在我的 2019 年 MacBook Pro 上用cargo run运行整个main.rs代码，2.6GHZ，6 核英特尔酷睿 i7，16GB RAM，计算时间不到一分钟，在 65 个周期后达到 90.45%的测试准确率

顺序神经网络

现在我们来看顺序神经网络实现https://github . com/ste boss/ML _ and _ Rust/tree/master/tutorial _ 3/custom _ nnet

图 9 解释了顺序网络是如何建立的。首先，我们需要导入tch::nn::Module。然后我们可以为神经网络fn net(vs: &nn::Path) -> impl Module创建一个函数。该函数返回Module的实现，并接收作为输入的nn::Path，该输入是关于用于运行网络的硬件的结构信息(例如 CPU 或 GPU)。然后，时序网络被实现为输入大小为IMAGE_DIM和HIDDEN_NODES节点的线性层、relu和具有HIDDEN_NODES输入和LABELS输出的最终线性层的组合。

图 9:顺序神经网络的实现

因此，在主代码中，我们将神经网络创建称为:

// set up variable store to check if cuda is available
let vs = nn::VarStore::new(Device::cuda_if_available());// set up the seq net
let net = net(&vs.root());// set up optimizer
let mut opt = nn::Adam::default().build(&vs, 1e-4)?;

还有一个 Adam 优化器— 记住 [opt](https://www.google.com/search?client=safari&rls=en&q=question+mark+in+Rust&ie=UTF-8&oe=UTF-8) https://www.google.com/search?client=safari&rls=en&q=question+mark+in+Rust&ie=UTF-8&oe=UTF-8末尾的 [?](https://www.google.com/search?client=safari&rls=en&q=question+mark+in+Rust&ie=UTF-8&oe=UTF-8) ，否则你会返回一个Result<>类型，它没有我们需要的功能。在这一点上，我们可以简单地按照 PyTorch 的过程来做，所以我们将设置一些 epochs，并用优化器的backward_step方法和给定的loss来执行反向传播

图 10:针对给定的历元数 N_EPOCHS 训练序列神经网络，并使用 opt.backward_step(&loss)设置反向推进；

卷积神经网络

我们今天的最后一步是处理卷积神经网络:https://github . com/ste boss/ML _ and _ Rust/tree/master/tutorial _ 3/conv _ nnet/src

图 11:卷积神经网络结构

首先，你可以注意到我们现在使用的是nn::ModuleT。这个模块特征是附加训练参数。这通常用于区分训练和评估之间的网络行为。然后，我们可以开始定义网络Net的结构，它由两个 conv2d 层和两个线性层组成。Net的实现陈述了网络是如何构成的，两个卷积层的步幅分别为 1 和 32，填充为 32 和 64，膨胀分别为 5 和 5。线性层接收 1024 的输入，最后一层返回 10 个元素的输出。最后，我们需要为Net定义ModuleT实现。这里，前进步骤forward_t接收一个额外的布尔参数train，它将返回一个Tensor。前一步应用卷积层，以及max_pool_2d和dropout。dropout 步骤只是出于训练目的，所以它与布尔值train绑定在一起。

为了提高训练性能，我们将从输入张量中分批训练 conv 层。为此，您需要实现一个函数来将输入张量分成随机批次:

图 12:为从图像输入池创建批次生成随机索引

generate_random_index获取输入图像数组和我们想要分割的批次大小。它创建一个随机整数的输出张量::randint。

图 13:卷积神经网络的训练时期。对于每个时期，我们通过输入数据集进行批处理，并训练计算交叉熵的模型。

图 13 显示了训练步骤。输入数据集被分成n_it批，其中let n_it = (TRAIN_SIZE as i64)/BATCH_SIZE;。对于每一批，我们计算网络损耗并用backward_step反向传播误差。

在我的本地笔记本电脑上运行卷积网络需要几分钟，实现了 97.60%的验证准确率。

结论

你成功了！我为你骄傲！今天我们来了解一下tch以及如何设置一些计算机视觉实验。我们看到了初始化和线性层代码的内部结构。我们回顾了 Rust 中关于借用的一些重要概念，并了解了什么是终生注释。然后，我们开始实现一个简单的线性神经网络、一个顺序神经网络和一个卷积神经网络。在这里，我们学习了如何处理如何输入图像并将其转换为tch::Tensor.，我们看到了如何使用模块nn:Module作为一个简单的神经网络，来实现一个向前的步骤，我们还看到了它的扩展nn:ModuleT。对于所有这些实验，我们看到了两种执行反向传播的方法，要么使用zero_grad和backward，要么直接将backward_step应用于优化器。

希望你喜欢我的教程:)敬请期待下一集。

支持我的写作:

通过我的推荐链接加入 Medium 来支持我的写作和项目:

https://stefanobosisio1.medium.com/membership

如果有任何问题或意见，请随时给我发电子邮件，地址是:stefanobosisio1@gmail.com，或者直接在 Medium 这里。

以前关于 Rust 和 ML 的教程

https://levelup.gitconnected.com/machine-learning-and-rust-part-1-getting-started-745885771bc2 https://levelup.gitconnected.com/machine-learning-and-rust-part-2-linear-regression-d3b820ed28f9 https://levelup.gitconnected.com/machine-learning-and-rust-part-3-smartcore-dataframe-and-linear-regression-10451fdc2e60

什么是正则化:偏差-方差权衡

原文：https://towardsdatascience.com/machine-learning-bias-variance-tradeoff-and-regularization-94846f945131

用看不见的数据改进预测的良好实践

马库斯·温克勒在 Unsplash 上的照片

当我们谈论使用机器学习模型的预测时，理解预测误差(即偏差和方差)很重要。任何机器学习模型的目标都是找到一个最小化对看不见的数据的预测误差的模型。在模型最小化偏差和方差之间的预测误差的能力上有一个权衡。理解这些概念将有助于我们解决过拟合和欠拟合的问题。

图 1(作者图片)

什么是偏见？

当我们开发一个模型时，我们可以用训练好的模型对目标进行单独的预测。例如，贝叶斯线性回归可以使用遵循多元高斯分布的所有可能的回归权重进行重复预测。因此，对于给定的模型，我们可能有一组不同的预测值。

在图 1 中，我们假设红色目标的中心是真实的输出值。使用训练好的模型，我们可以在蓝色圆圈内生成预测，因此蓝色圆圈的中心代表平均预测值。

偏差是我们模型的平均预测值和我们试图预测的真实值之间的差异。

偏差告诉我们训练模型预测真实目标的能力。偏差越低，给定的训练模型就越有能力。

什么是方差？

在图 1 中，假设蓝色圆圈的半径代表预测值的方差。

方差是对训练模型给定输入的预测值的可变性(又名分布)的度量。

方差越低，经过训练的模型做出的预测就越精确。

什么是不可约误差？

除了偏差和方差之外，第三种误差称为不可约误差。

不可约误差代表数据中的噪声无法被训练好的模型解释。不管训练出来的模型有多好，它总是存在的。

预测误差是方差、偏差和不可约误差的总和

让我们从数学上证明**。**

****

什么是不合身？

当模型无法捕捉和概括数据的潜在趋势时，就会出现欠拟合。直觉上，它与数据拟合得不够好，因此，它会在训练和测试数据上产生很高的误差(即高偏差**)。**

不适合的原因可能是

• 缺乏开发模型的数据(例如，少量的训练数据，关键解释变量不可用)。
• 基础模型不能捕捉数据中的模式(例如，使用具有非线性数据的线性模型)

什么是过度拟合？

另一方面，当模型太好地拟合训练并且它开始对训练数据的噪声建模时，发生过拟合。它在训练数据中具有低误差(即低偏差**，但在测试数据中具有高误差(即高方差)**

过度拟合的原因可能是

• 由于模型过于复杂，包括太多变量或包括有问题的变量**，如高阶多项式变量、无关变量、高度相关的变量或同时受响应变量影响的变量。**
• 模型的过度训练。例如，在没有显式停止标准的情况下训练决策树容易过度拟合。

偏差-方差权衡

理想情况下，我们希望减少模型的偏差和方差。然而，这是非常困难的，有时是不可能实现的。当您试图减少定型数据的预测误差时，测试数据的预测误差可能会增加。偏差和方差经常朝着相反的方向移动。

当使用训练数据开发模型时，很容易拟合复杂的模型来进行偏差较小的预测，但由于测试数据的预测方差较高，可能不会产生最佳结果。

或者，我们可以探索偏差和方差之间的权衡，在这种情况下，接受一些偏差以减少方差可能会更好。因此，我们对未知数据的预测误差会更小。

图 2(作者图片)

什么是正规化？

正则化是一种实现偏差和方差的折衷的概念，有助于减少预测误差。先说一些常用的正则化技术。

类型 1:修改成本函数

在线性回归模型中，我们可以改变 代价函数 来构建实现正则化的不同模型。

例如，在一个岭回归模型中，我们将成本函数修改为

在一个拉索回归模型中，我们将成本函数修改为

在弹性网回归模型中，我们将成本函数修改为

线性回归的这三个变量与正则化相关联，正则化会损害模型的灵活性和复杂性，以防止过度拟合的风险。

这里λ是一个超参数，它决定了模型的灵活性将受到多大的惩罚。λ的值越高，对每个特征的权重施加的约束就越多，因此，它可以防止权重变得太大，从而避免过度拟合。然而，如果λ的值太高，可能会产生欠拟合的问题，因为关键解释变量的权重变得太小，它不能准确地解释响应变量。

我们可以使用 K 倍交叉验证找到λ的最佳值(我们将在后面介绍)。

类型 2: K 倍交叉验证

K-Fold 交叉验证是另一种用于训练机器学习模型的流行工具。这种方法的思想很简单，我们从观测数据中创建多组训练数据，然后训练模型并基于验证数据评估模型，这类似于在看不见的数据上评估模型。它包括以下步骤，

图 3(作者图片)

步骤 1:我们将观察到的数据拆分成训练数据和测试数据(例如，1:9 拆分，有时需要分层)。然后，我们将训练数据随机放入训练文件夹和验证文件夹。例如，在 5 重交叉验证中，我们将有 5 组训练数据和验证数据。

步骤 2:在每组中，我们使用来自训练文件夹的数据训练模型，并在验证文件夹中评估模型性能。使用验证折叠评估模型模拟了 ML 模型的实际应用(即样本外预测或对未知数据的预测)。然后我们得到 K 个性能结果。

步骤 3:对于给定的训练模型，我们通过平均 K 个性能结果来计算总体性能分数。

步骤 4:挑选具有最佳总体性能得分的训练模型，并将该模型应用于测试数据以计算性能得分。

测试数据中的性能分数应该接近整体性能分数。如果情况更糟，那么我们需要更深入地研究数据，调查差异。

类型 3:修改最大似然算法

另一种避免过度拟合的方法是简单地改变机器学习算法。例如，一棵过度生长的决策树容易过度拟合。为了解决这个问题，我们可以使用一个具有预定义最大树深度的随机森林。在训练神经网络的情况下，我们可以应用 dropout 方法来确保模型可以用所选节点的随机子集来概括模式。

最终注释

为了训练一个预测误差最小的机器学习模型，我们需要确保我们探索了偏差和方差之间的权衡。正则化是我们在开发模型时需要考虑的一个重要步骤。

如果你对线性回归和因果推断感兴趣，这里有一些相关的帖子可以浏览。

• 因果推断:计量经济模型 vs. A/B 检验
• 线性回归与逻辑回归:OLS、最大似然估计、梯度下降
• OLS 线性回归:无偏、一致、蓝色、最佳(有效)估计量
• 线性回归因果推断:省略变量和无关变量
• 用线性回归进行因果推断:内生性
• 与 OLS 的线性回归:异方差和自相关

感谢您的阅读！！！

如果你喜欢这篇文章，并且想请我喝杯咖啡，请点击这里。****

您可以注册一个 会员 来解锁对我的文章的完全访问，并且可以无限制地访问介质上的所有内容。如果你想在我发表新文章时收到电子邮件通知，请订阅。

机器学习猫狗品种分类器

原文：https://towardsdatascience.com/machine-learning-cats-and-dogs-breeds-classifier-b26a9df45000

实践教程

机器学习猫狗品种分类器

了解如何使用 Python 中的机器学习模型来创建猫狗品种分类器，以预测您宠物的品种

遇见卡罗莱娜(没错，是一个人的名字；不，不是我选的)——图片作者

谁不喜欢动物呢，对吧？就我个人而言，如果我能把它们放在我所有的项目中，我就能享受生活了。如果你有点像我，想探索机器学习技术，那么这个教程可能就是你正在寻找的。

我们要做什么？

在本教程中，我将向您展示如何获取一个充满可爱动物图像的数据集，使用一些黑魔法，最终得到一个甚至可以对您的个人宠物图片进行分类的模型。这个模型可以用在你的个人应用程序中，这样你就可以向你的朋友和家人展示你学到的很酷的东西。

这篇教程是基于我和同事 Pedro Silva 一起为大学课程做的一个项目。我们一起设法在测试集上创建了一个准确率为 92%的模型。也就是说，它正确地分类了未用于训练的数据集部分中 92%的图像。这不是一个糟糕的分数，但它可以被改进——我也将告诉你如何改进！

在我们开始之前，你应该知道这些技术在计算上非常昂贵，并且很可能需要很长时间来执行。但是不要因此而气馁！在等待的时候，你可以做很多事情，比如遛狗……或者喝杯咖啡，或者小睡一会儿。事实上，如果你想拖延，这是一个很好的借口；)

数据集

为了实现我们的目标，我们将使用 Kaggle 上的猫狗品种分类牛津数据集(可以根据知识共享署名-共享 4.0 国际许可证下载用于商业/研究目的)。这个数据集总共有 7384 张宠物的图片，可以分为 37 个品种(或者，在这个上下文中，类)。

数据集中的图像示例—数据集中的图像

这些图片都是非正式的宠物图片，就像我们通常在手机上看到的一样，这很重要，因为这意味着我们的模型将更加通用。否则，只有当照片具有某种特征或以特定方式拍摄时，它才能理解宠物品种。

我们需要验证的另一件事是每个类的图像分布。我们需要知道这一点，因为如果类别中的图像数量不完全相同，那么该模型就不太擅长预测某些品种。为了了解这种情况，让我们绘制一个图表，并开始分析数据集！

绘制数据集中每个类别的图片数量

首先，我们需要导入一些依赖项，并将所有图像文件名加载到一个列表中。我们发现有些图像打不开，所以我们把它们的文件名放在一个集合中，从一开始就把它们排除在外。

加载所有图像的名称

数据集包括一个文本文件，其中包含一些关于信息组织方式的信息。我们可以使用这些信息来填充 2 个字典:info_by_name和info_by_id。尽管该文件也给了我们关于图像数量的信息，但我决定不信任它，并在代码中对其进行计数。我知道这是可选的，我只是展示我是如何做的。

将相关数据保存到字典中，以便于访问

现在我们已经有了字典中提到的所有信息，我们可以继续绘制条形图。

用每个品种的图片分布绘制图表

并且输出应该如下！

每个品种图片分布的条形图—按作者分类的图片

正如我们所见，每个品种的图像数量变化不大，这很好！尽管猫和狗的图片数量差异很大，但这应该不是问题，因为分类器并不专注于确定图片是猫还是狗。

基本原则

现在我们已经看了数据，是时候考虑我们将要构建的基础了。因为这个问题被认为是细粒度图像分类的一个问题——它旨在区分具有非常相似特征的类别——经典的机器学习方法不会成功。

一般来说，在解决这类问题时，一个好的做法是从查看以前的类似作品开始。在研究这个问题时，我们发现一些作品特别有趣和有用:“使用深度学习识别狗的品种”(z . rádully，C. Sulyok，Z. Vadászi 和 a . zlde)，“了解你的狗品种:用深度学习识别狗的品种”(P. Borwarnginn，W. Kusakunniran，S. Karnjanapreechakorn，和
K. Thongkanchorn) 和“狗分类成 12

普遍的看法是，卷积神经网络(CNN)对于涉及大量复杂数据的问题是最可行的，从这些数据中必须获得抽象特征，如形状和颜色，以获得准确的结果。我不会详细介绍什么是 CNN 在 Medium 上有很多关于它的文章——但我会在必要时给出一个概述。

迁移学习

许多被分析的文献提到迁移学习是一种好的方法，不仅可以提高模型的性能，还可以降低其训练的计算复杂度。

该技术包括:使用预先训练的模型作为起点；冻结这些图层，以避免在拟合阶段破坏它们已经拥有的信息；给它添加一些新的图层。

基本模型被用作理解图像分类任务中的共同特征的框架，例如形状和颜色。前提是这些特征对于每幅图像都是相似的，因此我们可以节省一些时间来重新使用它们之前计算的权重。另一方面，新层的目的是使模型适应新的更具体的特征，从而允许模型对我们新的和具体的数据集进行预测。

这甚至可以通过解冻先前训练好的模型的最后几层来改善，这个过程叫做微调。我们一会儿就来看看这个。

模型架构

由于在 imagenet 数据集上预训练的 InceptionV3 架构在文献中多次被提及，被认为是解决类似问题的迁移学习基础模型的良好架构，我们将使用它。

该架构由不同层的多种组合组成，包括卷积层、批量归一化层、和池层。这是一个非常深刻和复杂的网络，我不打算详述。

在基本模型的末尾，我们将添加 5 层:

• 池层:该层将直接与 InceptionV3 层的输出交互。通过应用将形成像素组的过滤器并对其应用操作，池化图层用于对输入进行缩减采样。在我们的例子中，使用了平均池，它计算那些像素组的平均值。
• 密集层:具有特定数量神经元的单一连接层——在我们的例子中是 256 个。选择的激活函数是 ReLU ，它简单地将任何负输入映射到 0，将任何正输入映射到自身。它被广泛使用，因为它是实际输入的线性函数，没有任何饱和风险。
• 丢弃层:其目的是根据正则化参数随机忽略前一层输出的一定百分比。这一层的目标是防止数据过度拟合。
• 批量标准化层:用于按顺序缩放输出，使其平均值为 0，标准差为 1。
• 密集层:这是输出层，全连接的一层，有 37 个神经元，每个对应我们的一个分类类。这里使用了 SoftMax 激活功能。与逻辑函数(如 sigmoid )相比，对于多分类问题，这是一个更好的激活函数。这是因为 SoftMax 输出一个概率向量，每个类对应一个值，使我们能够轻松理解哪些类具有更高的值，以及更大的概率是正确的。

我们还需要向我们的模型添加一个新的输入层，以正确的格式准备要传递给 InceptionV3 模型的图像。该图层直接与输入数据交互，并将接收到的每个值重新调整为-1 和 1 之间的值。

优化器选择为 Adam ，并实现随机梯度下降，其默认学习率为 0.001，我们将在稍后更改。准确性是我们将在培训期间用来评估模型性能的指标。

使用 Keras 库，很容易使用这个架构组装模型。

函数创建具有指定配置的模型

准备图像

为了让这些图像可以在模型中使用，我们必须对它们进行预处理。这包括将它们重新整形为(299，299，3)张量，因为这是 InceptionV3 模型输入的推荐形状。

一个常见的预处理任务是将图像的彩色图变为黑白。我们不打算这样做，因为颜色实际上是这个问题所必需的，因为它们对区分品种有特殊的重要性。此外，我们的模型需要一个三维输入。

这里我们将使用之前填充的info_by_breed字典来获取每张图片的品种标识符，这样我们就可以将图片数据保存在其 ID 中。

创建两个数组:一个包含正确格式的图像，另一个包含各自的 ID

现在我们有了数据，我们需要把它分成两大部分:训练和测试数据。为此，我们要做一个叫做 的分层拆分 。这意味着每一类中图像数量之间的比例在测试集中保持相等。

使用分层分离来分离训练和测试数据

超参数优化

尽管我们已经有了一个(希望)可行的模型，但是它的开发过程还没有结束！为了改进当前的设置，我们可以改变很多变量，以了解哪些变量可以产生最好的结果。我们将迅速探索改变学习率和下降值如何影响模型的能力。

如果您想立即测试这个模型，您可以向下滚动以了解如何。我建议您继续阅读本节，了解超参数优化的工作原理及其重要性，从我们如何发现某个配置是否适合我们的问题开始。

k 倍交叉验证

K-Fold 交叉验证是一种众所周知的优化超参数的技术。这是一种将训练数据分为 K 部分(或倍)的技术。然后，该模型将在 K-1 个零件上进行训练，并在其余零件上进行验证。这要做 K 次，因为每个折叠都有机会扮演验证的角色。然后对结果进行平均。这试图解决所使用的验证数据不能很好地代表模型性能的问题。因为所有数据都间接用于验证，所以这种情况不会发生。

尽管最常见的折叠次数似乎是 5 次或 10 次，但我们决定只用 3 次，因为这个过程需要时间。由于时间限制，我们使用了 32 和 15 个时期的批量大小。我鼓励你尝试其他的价值观！

以下函数返回一个字典，其中包含一些指标随时间的变化:训练数据准确性和丢失，以及验证准确性和丢失。

在这里，您可能注意到了代码中的一些奇怪之处——函数onehotencode_func！其定义如下:

它有一个非常重要的目标，将我们在y_train数组中使用的品种 id 的十进制表示转换为另一种表示——只使用 1 和 0。每个值都将被转换成一个包含 37 个元素的数组，这些元素是我们的数据集中的类的数量，除了在与被转换的值相等的位置之外，都用 0 填充。例如，数字 0 将被转换为[1,0,0,0,0,0,...]，数字 3 将被转换为[0,0,0,1,0,0,...]。

还记得我们的密集层有 37 个神经元，每个神经元输出一个概率值吗？我们可以把每一个看作是数组中的一个元素。如果我们将最大值设置为 1，并将所有其他值设置为 0，我们将最终得到一个数字一个 - 热编码。该数字是模型对该输入的预测！

学习率

下一个要点中的代码对学习率的不同值执行这个过程，并将提到的度量保存在一个名为lr的字典中。

现在我们可以使用存储在这本字典中的数据来可视化信息。

输出应该是两个图表——每个学习率值一个图表，每个图表都有一条针对每个指标的曲线。

不同学习率指标的演变—图片由作者提供

可以清楚地看到较低的学习率如何有益于该模型。训练和验证的准确性显示出相似的曲线和值，甚至训练损失也是相似的，尽管随着学习率的降低，训练损失会有所降低。最大的区别在于验证损失。随着更大的学习速率，该曲线没有收敛到一个值，可能是因为由于更大的步长，它“跳跃”通过局部最小值。在这次经历中，我们得出结论，0.001 是所有比较中最好的学习。

下降值

改变其他变量的过程非常相似。下一个代码片段重复了相同的过程，但是更改了 dropout 值。

显示图表的代码与之前的非常相似！如果一切顺利，结果应该如下。

指标的演变改变了差值—按作者分类的图片

在这种情况下，差异似乎更不明显。在最后一个时期中，具有 0.25 的下降的训练精度仅好于 0.007，并且还具有大约 0.037 的较低训练损失。当参考验证数据时，精度比 0.35 的压降低 0.003，验证损失大 0.025。这里没有明确的“赢家”，但是我们将假设 0.35 是一个更好的值，因为在验证数据中结果稍微好一些。

模型评估

正如我们所划分的，训练集构成了总数据集的 30%,其对应于 2216 幅图像。既然我们已经发现了最佳超参数，我们终于可以用它来检查我们模型的准确性了。

首先，我们创建一个模型，并根据训练数据对其进行训练。我使用了 32 和 15 个时期的批量大小。然后，我们让它根据我们的测试数据进行预测，并将值从一次性编码转换为十进制值——预测品种的 ID，以便更好地可视化正在发生的事情。

现在有一些有趣的方法来直观显示模型预测图像的好坏。其中之一是混淆矩阵，这是理解模型预测错误的情况的一种非常好的方式。我们可以用下面的代码展示这个矩阵的热图表示。

这段代码应该会向我们展示一个如下图所示的图形。

混淆矩阵-作者图片

有趣的是，这个模型在预测埃及猫品种时遇到了一些麻烦。它经常预测品种孟加拉而不是它。当看这些图片时，就有可能明白为什么会发生这种情况，因为它们彼此相当接近，尽管有时它们有不同的皮毛颜色。然而，在绝大多数情况下，分类器能够预测正确的品种。

孟加拉猫和埃及猫图片示例-来自数据集的图片

微调基本模型

正如我之前所说的，在许多事情中，有一件事我们可以做，以提高模型性能，我想在这里探讨一下，这就是解冻预训练的 InceptionV3 模型的最后一些层。

有了一个已经根据我们的数据训练好的模型，我们现在可以解冻基础模型的一些层。在这种情况下，我们选择解冻基础模型层的最后三分之一。然后，该模型使用 0.0001 的非常低的学习率再训练 10 个时期。程序如下。

现在我们可以像以前一样重复同样的技术来评估我们新改进的模型。如果我们给出混淆矩阵的一个表示，我们应该得到一个这样的表示。

混淆矩阵-作者图片

很明显，这一次模型在区分孟加拉猫和埃及猫时没有那么多麻烦。我们甚至成功地将精确度、召回率、f1 分数和准确度提高到了 92%。

结论

这当然不是一篇短文，但是我真诚地希望你在这个过程中学到了一些东西。我们仍然可以做很多事情来改进这个模型，使它更加稳健。我把它作为家庭作业留给你:)你也可以在 GitHub 上点击查看 Jupyter 笔记本上的所有代码(以及更多)！

非常感谢您的阅读！请留下您的任何反馈意见。

机器学习工程师——企业中扩展人工智能的合作伙伴

原文：https://towardsdatascience.com/machine-learning-engineers-partners-for-scaling-ai-in-enterprises-ea8d89593e14

(图片由作者提供)

许多行业的企业都在快速采用人工智能(AI)和机器学习(ML)。加速采用的原因有几个，包括需要从多渠道客户交互产生的大量数据中实现价值，以及来自企业运营各个方面的数据存储不断增加。这种增长提出了一个问题，需要哪些知识和技能来帮助组织在企业中扩展 AI 和 ML？

要回答这个问题，重要的是要了解企业为了更好地利用数据正在经历哪些类型的转型。

成长 AI/ML 成熟度

许多大型组织已经超越了单个团队内的试点或样本 AI/ML 用例，开始考虑如何巩固他们的数据科学项目，并将其扩展到其他业务领域。随着数据的变化或更新，组织需要不断优化 ML 模型的结果。

数据科学主流化

数据科学已经成为许多组织的主流。在产品、营销和供应链等各种业务线团队中工作的人都渴望应用预测分析。随着这种增长，分散的数据科学团队正在单个企业中涌现。对于许多希望应用预测技术的人来说，他们在数据科学方面的培训或生产规模 AI/ML 基础设施基础知识方面的培训有限。此外，企业面临着特别技术、工具和流程的激增。

数据日益复杂

已经取得了一些早期的胜利，通常是在结构化或表格数据用例中，组织渴望从大量的非结构化数据中获取价值，包括语言、视觉、自然语言等。组织越来越多地寻求帮助来应对这些挑战的一个角色是机器学习工程师。

什么是机器学习工程师？

我观察到，随着组织在人工智能/人工智能实践中的成熟，他们会超越数据科学家，雇佣具有人工智能工程技能的人。对数百个机器学习工程师职位发布的定性审查揭示了为什么这个角色是满足企业变革需求的一种方式。例如，检查某些术语在招聘信息的自由文本中的出现频率，会发现几个主题；

软件工程

ML 工程师与软件工程功能紧密相关。雇用 ML 工程师的组织已经在他们最初的 AI/ML 试点中取得了一些胜利，他们正在从实施 ML 用例到在他们的组织中扩展、操作和优化 ML 的 ML 采用曲线上移动。许多招聘信息强调 ML 的软件工程方面，而不是纯粹的数据科学技能。ML 工程师需要应用软件工程实践并编写高性能的产品质量代码。

数据

企业正在寻找有能力为 ML 工作流程的各个方面创建管道或可重用流程的人。这既包括与数据工程师(另一个受欢迎的角色)合作，也包括在整个端到端的 ML 过程中为健壮的数据实践创建基础设施。换句话说，ML 工程师创建流程和合作关系，以帮助清理、标记和处理来自整个企业的大规模数据。

生产

许多雇主寻找有端到端 ML 流程经验的 ML 工程师，尤其是将 ML 模型投入生产的工程师。ML 工程师与数据科学家合作，为大规模部署准备好数据和模型；为模型的持续培训、自动验证和版本控制建立管道。

系统

许多人工智能工程师被雇佣来帮助组织将架构、系统和最佳实践落实到位，以将人工智能/人工智能模型投入生产。ML 工程师在云环境或内部基础设施上将 ML 模型部署到生产中。对系统和最佳实践的强调有助于推动一致性，因为数据科学或基础架构基础知识有限的人学会了从预测分析中获取价值。这种对系统化人工智能/人工智能的关注也是开发人工智能/人工智能治理策略的重要前提。

(图片由作者提供)

ML 工程师做什么？

• 大数据
• 复杂的问题
• 驱动洞察力
• 实现商业价值(如客户获取和增长)
• 规模—影响数百万用户(B2B 和消费者)的项目
• 建立最佳实践

(图片由作者提供)

ML 工程师如何工作？

• 跨多个角色的跨职能协作
• 交叉业务
• 软件开发实践
• 敏捷
• 利用最佳实践

ML 工程师居住在组织的什么地方？

在企业内部，ML 工程师存在于各种团队中，包括数据科学、软件工程、研发、产品组、流程/运营和其他业务部门。

有哪些行业在寻找这项技能？

虽然对 ML 工程师的需求空前高涨，但有几个行业正处于雇佣这些角色的前沿。对 ML 工程师需求最高的行业包括；计算机和软件、金融和银行业以及专业服务。

这个角色有什么好学的？

随着 AI 和 ML 实践在企业中不断发展和成熟，机器学习工程师在帮助扩大 AI/ML 的使用和成果方面发挥着关键作用。ML 工程师使数据科学家能够专注于他们最擅长的领域——通过建立基础设施、流程和最佳实践，在生产中实现 AI/ML 模型的商业价值。随着数据量和用例复杂性的增加，情况尤其如此。

**结束语:**这份关于人工智能工程职位的总结并不是基于对某个特定职位发布的评估，甚至也不是针对我所在企业的评估，它反映了对人工智能/人工智能工程师(企业衡量人工智能/人工智能的一个关键角色)的公开职位发布的总体主题的定性评估。

关于作者:詹妮弗·奥蒂格贝在人、技术和设计的交叉点上写作和进行研究。她目前在谷歌领导着一个专门的 UX 团队，致力于开发软件工具，使企业开发人员能够利用人工智能和人工智能进行创作。

用于预测的机器学习:规模很重要

原文：https://towardsdatascience.com/machine-learning-for-forecasting-size-matters-b5271ec784dc

经典预测方法与机器学习的比较

米卡·鲍梅斯特在 Unsplash 上的照片

机器学习已经越来越多地应用于解决预测问题。ARIMA 或指数平滑等经典预测方法正在被 XGBoost、高斯过程或深度学习等机器学习回归算法所取代。然而，尽管受到越来越多的关注，但对机器学习方法的预测性能仍然存在疑虑。

Makridakis 是预测文献中最著名的名字之一，他最近提出的证据表明，对于单变量时间序列预测，经典方法系统地优于机器学习方法[1]。这包括 LSTM、多层感知器或高斯过程等算法。令人惊讶的是(或者不是，正如我们将看到的)，其中大多数甚至无法胜过简单的季节性朴素模型— 使用同一季节的最后观察值来预测未来观察值。后来，Makridakis 发表了另一篇文章，对需求预测进行了类似的比较[2]。在这项新的研究中，他们得出结论，机器学习方法提供了更好的需求预测性能。

第一项研究的结论是，需要找到机器学习预测模型相对于经典预测模型表现不佳的原因。

这是不是只是具体应用的问题，也就是机器学习对于需求预测表现很好但不全面？

尺寸很重要

照片由安德鲁·詹金斯在 Unsplash 上拍摄

我对此的看法是，第一项研究偏向于极小的时间序列。他们对一组超过 1000 个时间序列进行了实验，但是每个单独的时间序列都非常小。平均观察次数只有 118 次。在机器学习社区中，众所周知，当使用较大的训练集时，具有大量参数的模型往往比具有较少参数的模型表现得更好。这就是为什么深度学习只是在大型数据集变得可用之后才成为一件事情的原因之一——神经网络可以有许多参数，并且众所周知非常渴望数据。因此，很明显，对于机器学习标准来说，平均 118 个数据点可能不足以创建一个性能良好的模型。

在他们的第二项研究中，大部分系列包括了 280 多项观察。虽然对于机器学习标准来说，这仍然被认为是小规模的，但这比之前的研究中使用的要多得多。不幸的是，他们没有测试训练样本大小对结果的影响。

测试我的假设

我做了一些实验来测试在应用机器学习进行预测时训练样本大小很重要的假设。我尝试了五种经典方法(ARIMA、ETS、TBATS、Theta 和 Naive)和五种机器学习方法(高斯过程、M5、LASSO、随机森林和 MARS)来预测时间序列的下一个值，并通过增加训练样本量来检查它们的性能。

结果如下图 1 所示，图 1 显示了随着训练集的增长，每个模型的误差。x 轴表示训练样本大小，即有多少数据用于拟合预测模型。y 轴代表所有时间序列中每个模型的平均误差，使用交叉验证进行计算。以粗体显示的是两条平滑线，代表根据局部加权回归的每种方法的平滑误差。最后，点 118 处的垂直黑线代表 Makridakis 在实验中使用的平均样本大小。

图 1:随着训练样本量的增加，多个预测模型(分为经典和机器学习方法)的误差。图片作者。

结果显示了一个明显的趋势:当只有少数观测值可用时，经典方法表现出更好的性能，从而证实了 Makridakis 的发现。然而，随着样本规模的增长，机器学习方法优于经典方法。

你可以在这里查看我的文章。你可以用我在 Github 账户上分享的代码重现这些结果:

• https://github.com/vcerqueira/MLforForecasting

混合解决方案

自然，机器学习模型无法从小数据集进行归纳的证据可以被视为相对于传统方法的限制。特别是因为预测在宏观或微观经济领域中非常重要，在这些领域中，观测数据通常很少。在这种情况下，更简单的模型(参数更少)更可取。

尽管如此，机器学习模型可以在更大的时间序列中产生重要影响，例如传感器收集的时间序列。

也许更好的解决方案在于机器学习与经典模型的结合。这是广受欢迎的 M4 预测竞赛获胜者采用的方法。竞赛的获胜者 Slawek Smyl 使用指数平滑法对进行去季节化并对序列进行归一化，同时深度神经网络(LSTM)完成外推工作。

外卖

• 机器学习方法在预测方面是有竞争力的，前提是它们有足够大的训练数据集；
• 当只有少量的观测值时，ARIMA 或指数平滑等经典方法是更可取的；
• 将指数平滑等经典方法与机器学习相结合，可以提高预测的准确性。

参考文献

[1] Makridakis，Spyros，Evangelos Spiliotis，和 Vassilios Assimakopoulos。"统计和机器学习预测方法:关注点和前进方向."PloS one13.3(2018):e 0194889。

[2] Spiliotis，Evangelos 等人，“每日 SKU 需求预测的统计和机器学习方法的比较”运筹学 (2020)

[3]塞尔奎拉、熊伟、路易斯·托戈和卡洛斯·苏亚雷斯。“时间序列预测的机器学习与统计方法:大小问题.” arXiv 预印本 arXiv:1909.13316 (2019)。

用于预测的机器学习:多变量时间序列的监督学习

原文：https://towardsdatascience.com/machine-learning-for-forecasting-supervised-learning-with-multivariate-time-series-b5b5044fe068

使用 Python 对自回归分布滞后模型的介绍。

图 1:关于每月葡萄酒销售的多元时间序列。此处为数据源的链接。图片作者。

在这里，您将学习如何使用多元时间序列创建预测模型。

这是我在之前的帖子的后续。在那里，我描述了单变量时间序列监督学习的主要步骤。

介绍

如果一个时间序列包含一个以上的变量，那么它就是多元的。

参见图 1 中的示例。它显示了不同类型的葡萄酒销售的每月多元时间序列。每种葡萄酒都是时间序列中的一个变量。

假设你想预测其中一个变量。说一下，气泡酒的销量(个人最喜欢:-)。你如何建立一个模型来做到这一点？

一种常见的方法是将该变量视为一个单变量时间序列。有很多方法可以用来模拟这些序列。例子包括 ARIMA，指数平滑，或脸书的先知。自动回归机器学习方法越来越多地被使用。

然而，其他变量可能包含关于起泡酒未来销售的重要线索。看看下面的相关矩阵。

图 2:不同类型葡萄酒之间的相关矩阵。图片作者。

起泡酒的销售(第二行)显示出与其他酒的销售有相当的相关性。

因此，尝试将这些变量包含在模型中可能是个好主意。

我们可以用一种叫做自回归分布滞后(ARDL) 的方法来实现。

自回归分布滞后

单变量时间序列的自回归

顾名思义，ARDL 模型依赖于自回归。

自回归是大多数单变量时间序列模型的支柱。它分两步工作。

首先，我们将(单变量)时间序列从值序列转换为矩阵。我们用延时嵌入的方法做到这一点。尽管名字很花哨，但这种方法非常简单。这个想法是根据每个值之前的最近值来为每个值建模。查看我之前的帖子，了解详细的解释和实现。

然后，我们建立一个回归模型。未来值代表目标变量。解释变量是过去的最近值。

多元案例

对于多元时间序列来说，这个想法是相似的。但是，您也将其他变量的过去值添加到解释变量中。这导致了被称为**自回归分布滞后的方法。**分布式滞后名称是指使用额外变量的滞后。

把这些放在一起。时间序列中一个变量的未来值取决于它自己的滞后和其他变量的滞后。

让我们把这个方法编码清楚。

把手放在某物或者某人身上

多元时间序列通常指许多相关产品的销售数据。我们将以葡萄酒销售时间序列为例。可以从这里或者这里得到。然而，ARDL 的方法也适用于零售以外的其他领域。

转变时间序列

我们首先使用下面的脚本转换时间序列。

我们将函数time _ delay _ embedding应用于时间序列中的每个变量(第 18–22 行)。第 23 行的结果被连接成一个 pandas 数据帧。

解释变量( X )是每个时间步长上每个变量的最后 12 个已知值(第 29 行)。以下是滞后 t-1 的情况(为简明起见，省略了其他滞后):

滞后 t-1 时的解释变量样本。图片作者。

第 30 行定义了目标变量。这些指的是起泡酒销售的未来 6 个价值:

目标变量的样本。图片作者。

建立模型

准备好数据后，您就可以构建模型了。下面，我使用一个随机森林应用一个简单的训练和测试周期。

拟合模型后(第 11 行)，我们得到测试集中的预测(第 14 行)。该模型的平均绝对误差为 288.13。

选择滞后的数量

米凯尔·克里斯滕森在 Unsplash 拍摄的照片

我们使用每个变量的 12 个滞后作为解释变量。这在函数 time_delay_embedding 的参数 n_lags 中定义。

应该如何设置这个参数的值？

很难说应该包括多少个值。这取决于输入数据和具体变量。

一个简单的方法是使用特征选择。首先，从大量的值开始。然后根据重要性分数或预测性能减少这个数字。

这是这个过程的一个简化版本。根据随机森林的重要性分数选择前 10 个特征。然后，重复训练和测试循环。

前 10 个特征显示出比所有原始预测器更好的预测性能。以下是这些功能的重要性:

前 10 个特征的重要性分数。作者图片

正如所料，目标变量(闪光)的滞后是最重要的。但是，其他变量的一些滞后也是相关的。

ARDL 的延伸

多目标变量

我们旨在预测一个单一变量(起泡酒)。如果我们有兴趣预测几个呢？

这将导致一种称为向量自回归(VAR)的方法。

像在 ARDL 一样，每个变量都是基于其滞后和其他变量的滞后来建模的。当你想预测许多变量，而不仅仅是一个变量时，使用 VAR。

与全球预测模型的关系

值得注意的是，ARDL 并不等同于全球预测模型。

在 ARDL 的情况下，每个变量的信息被添加到解释变量中。变量的数量通常很少，并且大小相同。

全球预测模型汇集了许多时间序列的历史观测数据。一个模型符合这些观察结果。因此，每个新的系列都作为新的观察值添加进来。此外，全球预测模型通常涉及多达数千个时间序列。在的上一篇文章中，我描述了全球预测模型是如何运作的。这些是越来越多地用于预测的方法。

外卖

• 多元时间序列包含两个或更多的变量；
• ARDL 方法可用于多变量时间序列的监督学习；
• 使用特征选择策略优化滞后的数量。
• 如果要预测多个变量，请使用 VAR 方法。

感谢阅读，下一个故事再见！

参考

[1] Rob Hyndman 和 Yangzhuoran Yang (2018)。时间序列数据库。https://pkg.yangzhuoranyang.com/tsdl/的

用于预测的机器学习:转换和特征提取

原文：https://towardsdatascience.com/machine-learning-for-forecasting-transformations-and-feature-extraction-bbbea9de0ac2

时间序列的监督学习。如何使用 Python 创建单变量预测模型

亚当·米格尔斯基在 Unsplash 上的照片

在本文中，您将学习使用 Python 对时间序列应用监督学习。

这包括两件事:

• 将时间序列从序列转换成表格格式；
• 基于汇总统计信息添加新功能。

介绍

预测是数据科学中研究最多的问题之一。目标是预测时间序列的未来值。

准确的预测对决策者来说是非常宝贵的。它们减少了未来的不确定性，从而改进了行动计划。

传统的预测方法包括 ARIMA 或指数平滑法。但是，机器学习回归方法越来越多地被用来解决这个问题。

机器学习方法将任务构建为监督学习。目标是基于历史数据创建一个模型。然而，还不清楚如何使用一系列值作为输入来训练模型。

事实证明，有一个巧妙的转变让我们可以做到这一点。

延时嵌入

模型被训练以导出观察和那些观察的结果之间的模式。

我们如何处理时间序列呢？

时间序列的值可以被认为是它之前的最近值的结果。该值作为目标变量。过去最近的值被用作解释变量。

这种过程将序列从一系列值转变为表格格式。这个变换叫做延时嵌入，是自回归的关键。

这里有一个 Python 函数来完成:

以下是将该函数应用于从 1 到 9 的序列时的数据集:

作者图片

以第一行为例。目标是预测数字 4(列系列(t+1))。解释变量是它之前的过去 3 个值:3、2 和 1。

延时嵌入有很强的理论基础。详情可查阅参考文献[1]。嵌入定理假定时间序列在变换前后是等价的。

完整示例

让我们编写一个完整的例子。我们将使用太阳黑子时间序列。该数据集可在 pmdarima 库中获得。它看起来是这样的:

太阳黑子时间序列。作者图片

下面是如何转换时间序列和训练自回归模型的示例。

在每一步中查看更多的上下文注释。

滞后次数和预测范围

转换时间序列需要指定滞后的数量。也就是我们要用多少最近的过去值来预测下一个点。

对此有一些处方。例如，检查部分自相关并确定它在哪里是显著的。您还可以使用交叉验证来优化该参数。

另一个参数是预测范围。这是您想要预测的未来步数。如果该值为 1，则该问题被称为单步提前预测。否则，多步提前预测。

值得一提的是，转换并没有取代其他预处理步骤。

您仍然需要考虑趋势和季节因素，并在需要时删除它们。

特征抽出

由 Pratiksha Mohanty 在 Unsplash 上拍摄的照片

自回归方法背后有一个基本假设。过去的滞后包含了足够多的关于系列将如何发展的信息。

然而，你可以从中获得更多的信息。

在机器学习中，特征工程是建立精确模型的关键部分。这也可以用于预测问题。

我们可以用统计数据总结最近的数值。这些统计数据丰富了时间序列的表示。希望这能转化为更好的预测性能。

例如，过去几个值的平均值可能很有用。它给出了级数在每个点的平滑指标。

这里有一个例子。我重复了上面的代码，但是添加了一个特性工程步骤(第 20–22 行)。

在第 21 行和第 22 行，我添加了滞后的平均值作为解释变量。这使得预测性能略有提高。

下面是功能重要性的样子:

作者图片

均值特征是最重要的特征。

在这个例子中，我添加了一个特性。但是，你只受到你的想象力的限制。

您可以测试其他几个汇总统计数据，并检查它们是否改进了模型。

外卖食品

• 使用时间延迟嵌入将时间序列转换为矩阵
• 时间序列中的值是根据它们过去的滞后时间建模的(自动回归)
• 用部分自相关分析或交叉验证选择滞后数
• 使用汇总统计从过去的滞后中提取更多特征

感谢阅读，下一个故事再见！

你可能想读的以前的故事

</12-things-you-should-know-about-time-series-975a185f4eb2>

参考

[1]塔肯斯，芙罗莉丝。"探测湍流中的奇怪吸引子."动力系统和湍流，沃里克 1980 。施普林格，柏林，海德堡，1981。366–381.

[2] Bontempi、Gianluca、Souhaib Ben Taieb 和 Yann-al Le bor gne。"时间序列预测的机器学习策略."欧洲商业智能暑期学校。施普林格，柏林，海德堡，2012。

区块链上的机器学习

原文：https://towardsdatascience.com/machine-learning-haiku-generator-on-blockchain-f6e5a801ca25

我如何建立一个运行在区块链上的俳句生成器

在这篇文章中，我将描述我创建的 Bitku，一个完全在区块链上运行的俳句生成器。我开始的目标是创造真正区块链本土的艺术——在链条上产生和储存的艺术。我将描述生成艺术 NFTs 的现有景观以及它的不足之处。然后，我将介绍培训和部署第一个在区块链上运行的生产机器学习模型的过程。

Bitku #40

现有的创成式 NFT

生成艺术 NFTs 的趋势越来越明显——艺术是由一种算法创造的，并被“铸造”以在区块链上创造出该艺术的独特表现，从而可以证明所有权。有几种生成 NFT 的现有方法:

Art Blocks 是最大的生成性 NFT 平台之一。艺术家们创建一个脚本(通常使用 p5js )可以将一个数字转化为一件艺术品。每个数字将产生不同的输出。该脚本作为文本保存在以太坊区块链上。当你在艺术块上铸造一个 NFT 时，交易会在你的以太坊地址存储一个随机种子。为了观看艺术，你的计算机从区块链中取出脚本，取出你的种子，然后你的计算机在那个种子上运行脚本。所有的计算都发生在观看艺术品的电脑上；区块链只是一个记录剧本和谁拥有哪些种子的账本。

另一种方法是按需生成艺术，但是通过调用区块链之外的 API。这就是所谓的神谕。Oracles 通常用于访问外部数据源，比如金融应用程序的汇率。但是它们也可以用于调用一个使用 GPT-3 生成文本的 API，或者一个代表你的区块链碳排放的像素艺术树。在这种情况下，艺术是由一个黑盒生成的，你不知道你是如何得到你所得到的结果的。结果也是离线存储的，所以区块链不能保证不变性。

还有一个就是提前创造艺术。例如，使用处理生成 100 个随机的 jpg 图像，然后在 OpenSea 上将这些图像制作成 NFT。这些图像将被存储在区块链之外，使用类似 IPFS 的东西，区块链上的 NFT 将链接到该图像。

有真正了不起的艺术家创作出令人惊叹和新奇的艺术作品。我并不批评艺术的质量。但从技术的角度来看，我发现这些方法并不令人满意，因为它们都有一个共同点:它们将生成艺术的计算复杂性从区块链转移到其他一些计算机上，无论是你的计算机、云中的 API 还是艺术家的计算机。NFT 仅仅是作为所有权的证明，并不是艺术品本身的一部分。

没有做的是在区块链本身上运行生成代码——原因很好，我稍后会解释。

鉴于这是一个多么糟糕的主意，这正是我要做的。

Bitku #240

这个想法

我打算做的是创造完全生活在区块链上的生成艺术，没有任何外部依赖性。只要区块链存在，任何人都应该能够确切地知道这件艺术品是什么以及它是如何产生的。

为了满足第一个要求，我们需要将艺术本身存储在区块链上，为了满足第二个要求，我们需要在区块链上运行生成过程。

为什么这是个坏主意

区块链，本质上，有时间和空间的限制。区块链通过在许多计算机上重复计算和存储来工作。

以以太坊为例，全世界有几千个全节点，每个全节点都会执行事务，再加上几十万个矿工，其中一部分会执行事务。试图用大量的计算来运行一个复杂的过程是不可行的，也是不环保的。

这一成本反映在执行事务的 gas 需求中。以太坊黄皮书概述了不同操作的成本，例如计算、存储或加载字节。储存 1MB 的天然气需要花费 6.4 亿美元，按照今天的天然气价格和汇率，这大约相当于 64 ETH 或 17 万美元。这只是存储，并没有计算成本的因素。

考虑到这些限制，在区块链存放视觉艺术显然是不可行的。俳句，我之前已经和 T1 一起试验过了，看起来非常适合:它们是文本——而且是很短的文本。

有了目标，下一个问题是如何在区块链创作俳句。我上面链接的项目使用了一个递归深度学习模型，它在磁盘上有 140MB，运行起来计算量很大。

Bitku #29

马尔可夫链模型

进入马尔可夫链:它们远不如最先进的深度学习模型强大——它们生成的文本更不真实。但是它们很小，很容易理解。

马尔可夫链对一系列事件进行建模，其中下一个事件的概率取决于当前状态。在我们的例子中，这可能意味着为了生成句子中的下一个单词，我们将考虑当前的单词。

下图显示了一条马尔可夫链，训练在 的第一句话上，鼠标、鸟和香肠 。

“很久很久以前，一只老鼠、一只鸟和一根香肠合伙建立了一所房子。”|作者用 PlantUML 创建的图像

每个单词都通过前一个单词后面的那个单词的概率与其他单词相联系。要从中生成文本，如果我们从“once”开始，100%的时间我们会选择单词“once”，从那里我们总是选择“a”。在这一点上，我们有几个单词可以跟随。每当我们生成一个包含“a”的句子时，我们可能会在后面出现一个不同的单词:“一只鸟”或“一根香肠”

这些概率来自训练过程。训练是通过处理一组文本(称为语料库)并记录单词之间的每个过渡来完成的。

在这种情况下，“once”总是跟在“once”后面，所以在我们的模型中它有 100%的概率跟在它后面。而“a”后面有四个单词，每个单词出现的次数相等，所以它们都有 25%的机会。

随着语料库的增长，这变得更加复杂，但想法是相同的:词对在语料库中出现的频率将为模型提供生成该词对的概率。

比特库#189

打造区块链俳句生成器

此时，我已经确定了我的目标和需求:构建一个可以在区块链上生成和存储俳句的马尔可夫模型。是时候建造它了！

流量区块链

我的第一步是选择一个区块链一起工作。由于生态系统的流行和成熟，以太坊是显而易见的选择，但由于上面提到的限制，我显然需要寻找其他地方。我将搜索重点放在区块链的利益证明(PoS)上，以最小化我需要的计算对环境的影响。

在考虑了几个选项后，我登陆了流。Flow 是一个相对较新的应用，最出名的是《T2》和《NBA 顶级射手》，但它的应用生态系统正在不断发展。Flow 使用一种 PoS 一致性算法，该算法被划分到几个不同类型的节点。结果是，与大多数区块链相比，执行发生在相对较少的计算机上。很难估计在区块链上运行复杂交易的计算/能源/碳影响，因为交易目前都被收取相当于不到百分之一便士的统一费用，但可以肯定的是，这比使用以太坊等区块链低几个数量级。

相比其他 PoS 区块链，将我推向 Flow 的是它的编程语言、 Cadence 和开发者生态系统。Cadence 为智能合约编程提供了一个简单易懂的界面，尤其是对于初次接触智能合约编程的人，比如我自己。有很好的教程和一个在线平台，可以帮助你入门和了解 API 参考文档。Flow 和 Cadence 仍在积极开发中，因此我确实遇到了一些文档过时的地方，开发人员生态系统的一些部分仍处于早期阶段——如 JavaScript 库——但总体而言，我在 Flow 上有很好的开发体验。

构建生成俳句的马尔可夫模型

在上面的例子中，马尔可夫模型的状态只是当前的字。当当前单词是“在”时，下一个单词将是“a”。从“a”有四个相等的选择。该模型的一个可能输出是:

从前，香肠和老鼠合伙，老鼠和老鼠…

很容易看出我们如何产生无意义的结果。选择一个好的下一个单词需要更多关于句子的上下文。但是状态不一定只是当前的词。为了这个项目，我训练了一个马尔可夫模型，其中状态由当前单词、前一个单词和行号组成。这远非完美，但比仅使用当前单词的情况有了很大的改进，同时足够简单以适应约束条件。

训练语料来自几个来源。没有很多俳句训练数据，所以这个模型的大部分是在其他诗歌或散文句子上训练的，这些句子被重组为具有类似俳句的外观。总之，我有几百兆字节的训练数据。

我处理了每个“俳句”来分类从状态(行号、当前单词和前一个单词)到下一个单词的转换。在这一步之后，我有大约 650 万次转换。

以下示例显示了从当前单词(The)到“the”后面的每个单词的这些转换，以及这些转换发生了多少次。

the, world, 644
the, night, 474
…
the, sudden, 2
the, change, 1

有了这个，你可以计算从一个状态到一个单词的概率。如果这四个词是我们语料库中“the”之后仅有的四个词，“世界”发生的时间为 57.4%，“夜晚”发生的时间为 42.3%，“变化”发生的时间不到 0.1%。这意味着当我使用这个模型生成俳句时，57.4%的情况下当前单词是“the”，下一个生成的单词将是“world”，而“change”的情况很少。

创建马尔可夫模型就像计算训练数据中每个转换的概率一样简单。我从这组转换中创建了三个不同的马尔可夫模型:

• 第一个模型使用行号、当前单词和前一个单词来生成下一个单词。
• 第二个模型使用行号和当前单词来生成下一个单词。当第一个模型中不存在当前状态时，此模型是一个后备。例如，当我们在俳句的开头时，我们还没有两个单词，或者如果生成了一个不常用的词对，如“the change”，就是这种情况
• 最后一个模型专门模拟了俳句的结尾。我以前在创作俳句时遇到的一个问题是，因为俳句的篇幅有限(只有有限的行数和音节数)，所以你在诗的结尾经常会留下不完整的想法。我通过在训练数据中建立俳句末尾的状态模型来解决这个问题。如果在生成一首诗的结尾附近遇到了那个状态*，我们将选择那个选项并结束这首诗，而不是试图继续生成。*

处理训练数据和建立模型的完整代码可以在这里找到。

移植到流

训练好模型后，我必须让模型在区块链上运行。这需要将我的 Python 代码移植到 Cadence 智能合约中。Cadence 是一种“面向资源”的编程语言，它使得安全可靠地完成所有区块链部分变得非常容易——铸造 NFT，将它们存储在正确的帐户中，以及交换资金。但是尽管 Cadence 已经完全成熟，但它比 Python 这样的语言更受限制，这使得移植俳句生成代码更具挑战性。

缩小我的模型

但最大的挑战是找到一个由 Cadence 支持的模型表示，它足够小，可以存储在区块链上。我对这三种模式的实际限制是 1-2MB，来自 Flow 的 4MB 事务大小限制。

为了将数百 MB 的训练数据和 650 万个状态转换减少到只有几 MB，我做了以下工作:

• 将字典中的单词删减到 1000 个最常用的单词。由于新单词和其他单词之间的无数相互联系，随着字典中单词数量的增加，最终模型的大小呈指数增长。我发现 1000 是模型大小和生成的俳句种类之间的一个很好的平衡。
• 删除剩余单词之间不常见的过渡。这也是以减少产出多样性为代价的。以上面的例子为例:尽管“the”和“change”包含在 1000 字的字典中，但“the change”并不作为状态转换包含在内。这不仅节省了空间，而且有助于防止语法错误的转换。当“change”是一个名词时,“change”可能是正确的，如“给我零钱”,通常“change”是一个动词。该模型不知道一个单词被用作哪个词性，因此“change”通常会被解释为动词，后跟“my”和“your”等单词。
• 把单词压缩成更小的表示法。我的压缩方案是用唯一的字母数字代码替换单词，给最常见的单词赋予最短的代码。

当我创建模型并在 Flow 上测试它们时，获得不频繁转换的确切字数和阈值是一个迭代过程。Flow/Cadence 还处于早期阶段，Cadence 运行时的新版本迫使我几次调整模型的大小。

下面是字典中用于反转压缩的一个片段:

{
  "a":"END",
  "b":"START",
  "c":"\n",
  "d":"the",
  "e":"I",
  "f":"to",
  "g":"and",
  "h":"a",
  "i":"of",
  …,
  "pg":"walking",
  "ph":"lonely",
  "pi":"thousand"
}

“开始”和“结束”是我用来标记俳句开始和结束的符号。之后，“\n”(换行符)是最常见的，其次是“the”和“I”。“千”碰巧是字典中 1000 个单词中出现频率最低的，正如您所看到的，可以压缩为两个字符(“pi”)。

这是模型的样子:

{
  "d":{
    0:{"c":8,"aw":9,…,"i6":34,"d7":35},
    1:{"c":7,"bB":8,…,"gm":46,"aj":47},
    2:{"cP":1,"bG":2,…,"k9":51,"mc":52}
  }
}

这是单词“d”后面的单词模型，翻译过来就是“the”里面有三本字典，每一本分别对应三行俳句。对于第一行，跟在“the”后面最常见的词是“c”(“\ n”)，其次是“aw”(“only”)，最后是“D7”(“Lord”)。最大数量是 35，所以要在俳句的第一行“The”后面生成一个单词，请在 1 到 35 之间随机选择一个数字，并选择其值小于或等于该数字的第一个单词。5 会翻译成“\n”，而 9 会翻译成“only”转换成百分比，对于这个特定的情况，这意味着大约 23%的时间换行符跟在“the”后面，而其他每个单词有 3%的机会。

将生成代码移植到 Cadence

模型整理出来并与 Cadence 兼容后，下一步是用它们生成俳句。

基本思想是从模型中随机抽取一个词，然后用这个词随机挑选下一个词。在生成过程中，如果第一行有 5 个或更多音节，或者第二行有 7 个或更多音节，则插入一个换行符作为下一个“单词”在最后一行，如果有 4 个或更多的音节，那么我们试着从上面描述的特定于结尾的模型中提取。

虽然我一直在谈论选择“随机”单词，但我们实际上想要一个伪随机单词——一些看起来随机但行为可重复的单词。在区块链建造这座桥的好处之一是它是俳句的明确来源。我们不仅可以像了解其他 NFT 一样了解所有权历史，还可以确切地了解它是如何生成的。假设我们有种子，我们总是可以回去，追溯代码，并了解发生了什么产生任何给定的俳句。

在这种情况下，我用块的 ID 和俳句的 ID(每个俳句都用一个唯一的序列 ID 标记)作为伪随机数发生器的种子。因为块 ID 包含在种子中，所以你永远不知道在你创作之前俳句会是什么。

*如果您足够快，可能会提前知道您的事务将包含在哪个块中，但实际上这是不可预测的。

智能合约的完整代码，包括模型和生成代码，可以在这里找到。

结果

接下来是有趣的部分——结果。我已经在本文中介绍了其中的一些。以下是我更喜欢的几个:

Bitku #0

比特库#5

比特库#221

是的，最后一个就是两个字。正如我之前提到的，使用区块链的一个好处是，给定随机数种子，你可以准确地计算出发生了什么。(我将把它作为一个练习留给读者；这里的是产生俳句#221 的事务。)

你可以阅读更多关于这个项目的内容，也可以在下面找到所有的源代码:https://github.com/docmarionum1/bitku

如果你想阅读更多关于生成俳句的内容，可以阅读关于使用 深度学习 ，以及关于从 生成俳句的工作描述 。

杰里米·内曼在他的网站上做着同样毫无意义的事情:http://jeremyneiman.com/

感谢 Abigail Pope-Brooks 的编辑和反馈。

本文中的所有图片均由作者创作，除非另有说明。

[1]附录:区块链中机器学习的状态

据我所知，Bitku 是第一个在生产区块链上运行的机器学习实现。

我只能找到在智能合约中实现机器学习的另一个源代码实例:微软研究院的区块链上的分散&协作 AI(也称为在区块链上共享可更新模型(SUM))。

这是一个有趣的项目，其主要焦点是确定如何利用区块链来民主化训练模型，并访问它们进行预测。要点是，它们提供了一种激励机制来为模型提供数据，实现了易于更新的最大似然模型(如最近质心分类器)，从而降低了交易成本，然后允许免费访问预测，因为从区块链读取是免费的。

该项目在 Ethereum 上实现，并显示使用本地仿真器工作。我找不到任何迹象表明它被部署到 mainnet 上，而且现在使用它成本太高。但是我可以看到这种方法在 PoS 区块链上工作。

除此之外，我在区块链上找不到任何 ML 的实现。

• 有一篇论文提出了一个利用区块链来激励创造有效模型的方案(想想 Kaggle，但在区块链)，但据我所知，这只是理论。
• 有专门针对区块链的研究，以促进机器学习，如拟议的学习链，但那是一个完全不同的野兽——它使用区块链来协调和保护分布式机器学习——它不在智能合同中运行机器学习。

5 分钟机器学习

原文：https://towardsdatascience.com/machine-learning-in-5-minutes-2fad75721850

引起媒体热议的新兴技术

凯文·Ku 在 Unsplash 上的照片

机器学习。它向你展示你的抖音推荐，让谷歌助手回复你的查询，这是一项可怕的技术，有一天将接管世界。但是真正的内幕是什么呢？让我们一起去看看🧐吧

基础知识

任何人工智能算法实际上都只是一个巨大的数学问题。你得到一堆输入，对这些输入执行数百个等式，然后得到想要的输出。

信用:塔拉普罗尔

这些圆圈中的每一个🔵代表一个数学方程式。两个圆圈之间的每条线代表一个变量，或者说权重，这是在一个叫做**训练的过程中“学会”的。权重允许确定这些圆或神经元、**之间关系的不同强度，这可以帮助神经网络找出最终的分类或预测。连接越强，权重值越高。

为了学习赋予机器学习算法其唯一的基于连接的值的权重值，神经网络需要**数据。**神经网络中常用的数据集的一个例子是 MNIST -存储在图像文件中的大量手写数字，每个数字都由其中包含的数字来标记。

MNIST 数据集

机器学习算法获取这个大规模数据集，并学习它可以用来确定如何获得该输出的模式。训练数据允许计算机查看成千上万的例子来完善它的技术。测试数据允许程序员测试他们的算法对训练集中没有的数据执行得有多好。

以下是在 MNIST 数据集的训练过程中会发生的情况:

1. 所有手写数字图像都被输入到模型中。
2. 每个图像中的像素序列乘以一组权重。然后产品被送入下一层。
3. 这个过程一层一层地继续，直到到达输出层。
4. 还有另一个函数，在这种情况下， softmax 函数 **，**应用于该输出层中的值集…
5. 计算预测值(数字分类的标签),并将其与基础事实标签进行比较，基础事实标签是包含在原始数据集中的标签，用于说明图像实际属于哪一类。

很简单，对吧？等等，我们还没完呢。真正神奇的🪄of 神经网络发生在之后预测被计算出来，与你可能相信的相反。训练过程以所谓的反向传播达到高潮，它允许程序回过头来调整它认为将有助于神经网络在未来表现更好的任何数字。

它通过计算一个损失值来实现这一点，损失值是模型对数据表现好坏的指标。根据使用的数据类型，有许多不同的损失函数用于计算该值。

一个优化器获取损失值，用它来计算模型的错误有多严重，并相应地调整模型的权重。一旦模型被调整，训练过程再次开始。该过程的每次运行被称为单个时期。

这是你的总结:

1. 向模型中输入进料
2. 乘以一组权重，重复！
3. 将 softmax 功能应用于输出
4. soft max 的输出用于预测类别标签
5. 使用损失值和优化器返回并修复导致问题的权重(反向传播)

一旦运行了期望数量的时期以获得性能良好的模型，训练过程就完成了。然后，在指定的测试数据上测试该模型的性能，并为在现实世界中的应用做好准备😎

神经网络的基本类型及其用途

本节包含不同种类的 ML 模型以及它们通常的用途。我还会链接到我的其他文章，这样你可以了解更多！

**CNN-**卷积神经网络。主要用于对图像数据的操作，如对不同种类的路标或水果进行分类。当你看谷歌镜头或那些告诉你一张图片中有哪些种类的植物的应用程序时，那些就是 CNN。

多层感知器。用于股票分析、垃圾邮件检测、路线规划和选举投票预测等任务。当您查看电子邮件收件箱时，注意到一些电子邮件被转到了垃圾邮件区，这很可能是受过识别网络钓鱼和诈骗训练的 MLP 所为。

RNNs- 递归神经网络。用于项目顺序很重要的任务，如视频分类或语音标记。当你上传一个视频到 YouTube 上时，它会被扫描是否可能侵犯版权。这可能是 RNN 在起作用，因为必须考虑视频帧和音频文件的顺序才能正确处理它。

强化学习- 当你想教计算机一项技能时使用。使用一个分数系统来强化和重复想要的行为，同时以同样的方式阻止不想要的行为。例如，智能人工视频游戏敌人可以使用强化学习来学习如何正确地玩游戏。

摘要

1. 简单地说，人工智能算法是一个非常大的数学问题。
2. 图像或数据集等输入乘以一组权重，在训练过程中对这些权重进行优化调整，以最好地完成手头的任务。
3. 经过这些“层”的权重相乘后，到达输出层。
4. 将一个函数应用于输出图层，以获得最终的预测或分类，该预测或分类可用于做出真实世界的决策。
5. 有许多不同种类的神经网络，每一种都用于它们自己独特类型的任务(图像识别、基于数据的预测、学习新技能等)。

我真不敢相信这篇文章已经结束了！我希望你学到了一些关于人工智能世界的新知识。如果您有任何问题，请随时通过LinkedIn与我联系，并通过 订阅我的简讯 定期了解我的最新动态。

数据仓库中的机器学习

原文：https://towardsdatascience.com/machine-learning-in-a-data-warehouse-ab0701bbf631

使用 Snowpark Python 开始机器学习

贾斯珀盖伊在 Unsplash 上的照片

如果您是一名商业环境中的数据科学家，您将从数据仓库或数据湖中提取大量数据用于机器学习。大多数数据科学项目需要大规模的计算能力和对所需 python 库的访问，以处理海量数据和训练机器学习模型。

通常，数据被移动到另一个位置，例如云存储桶，在那里它可以被标准数据科学工具包使用。

这种情况导致了机器学习工作流的碎片化，这是许多云提供商正在寻求解决的问题。我之前写过关于 BigQueryML ，这是一个谷歌云平台(GCP)工具，它允许机器学习模型在 GCP 的数据仓库平台内纯粹使用 SQL 来开发和训练。

雪花，一个基于云的数据和分析平台，最近提供了另一个工具，试图以类似的方式简化数据科学的工作流程。

Snowpark Python API 允许使用数据科学家熟悉的工具在 Snowflake 中开发、训练和部署机器学习模型。与 BigQueryML 一样，可以开发模型，而无需数据离开存储位置，然而，使用 Snowpark 而不是用 SQL 编写代码，数据科学家现在可以使用 Python。

在这篇文章中，我写了一个使用 Snowpark 开始机器学习的简要指南。这并不意味着对机器学习本身的详尽指导，所以我将跳过通常工作流程中的一些步骤，如探索性数据分析和特征工程。它旨在给出 API 的一个应用的基本介绍。

本教程中的大部分代码都受到了雪花团队提供的示例的极大启发，这些示例可以在本 Github repo 中找到。

首先，一些有用的定义

雪花与您可能使用过的其他数据仓库工具有一点不同，因此首先理解雪花上下文中的一些常用术语可能会有所帮助。

**数据库:**一个雪花数据库由优化的数据存储组成。通常，一个数据库包含许多模式，每个模式包含一组表。在本教程中，我们将利用数据库来存储训练数据和预测。

仓库: Snowflake 为大规模查询处理提供独立的计算集群。每个计算集群被称为一个虚拟仓库。这些仓库的规模可以根据您的加工需求而定。我们将使用仓库计算来执行模型训练和推理。

**Stage:**Stage 是一个存储位置，用于存储数据和构件，以便在雪花中使用。在本教程中，我们将使用一个 stage 来存储我们训练好的模型。

**存储过程:**存储过程是存储在雪花中供以后重用的函数和操作的集合。Snowpark 存储过程提供了一种机制，可以通过 Snowpark 或其他 python 库(如 sci-kit-learn)使用雪花计算来运行 Python 代码。我们将使用存储过程来执行模型训练。

**用户定义函数(UDF)😗*UDF 是在雪花中运行 Python 函数的另一种方法。这些过程在许多方面不同于存储过程。这篇文章详细描述了两者的区别。在本教程中，我们将使用 UDF 来使用训练好的模型生成推理。

建立雪地公园

如果你还没有雪花的权限，你可以在这里注册免费试用。注册后，您需要配置一个数据库、仓库和模式。雪花有一个很棒的 20 分钟指南在这里。

对于本教程的剩余部分，我将假设您已经配置了雪花资源。

本文的设置部分介绍了 Snowpark 的本地安装。该设置基于 macOS。

Snowpark 使用 Snowflake 中的 Anaconda 环境来管理 Python 包。因此，虽然也可以使用 virtualenv，但是最好在本地复制这个环境。

要安装 Anaconda，请运行以下命令。

$ brew install --cask anaconda

接下来，将以下内容添加到您的。zshrc 文件。

export PATH="/usr/local/anaconda3/bin:$PATH"

现在，您可以通过运行以下命令来创建 conda 环境。SnowPark 目前只支持 Python 3.8。

$ conda create --name py38_env -c https://repo.anaconda.com/pkgs/snowflake python=3.8 numpy pandas sklearn

运行以下程序初始化 conda。您只需要运行一次。

$ conda init zsh

要激活环境，请运行。

$ conda activate my_env

进入环境后，安装 snowpark 和 Jupyter 笔记本。

$ conda install snowflake-snowpark-python$ conda install notebook

要运行 Jupyter 笔记本，请键入以下内容。

$ jupyter notebook

Jupyter 笔记本将推出 Python 3 内核。我的内核如下图所示。

带雪地公园的 Jupyter 笔记本。作者图片

雪地公园会议

一旦你设置了 Snowpark 的本地安装，你就可以开始运行代码了。使用 Snowpark API 执行的所有操作都在雪花仓库计算上运行。

要开始使用这台计算机，您需要创建一个 Snowpark 会话，该会话允许您进行身份验证并创建一个与您的数据库和仓库的连接。

要启动雪花会话，我们键入并执行以下命令:

数据准备

在本教程的剩余部分，我们将使用 Snowpark 来准备数据集，训练机器学习模型，然后使用该模型来生成预测。

我们将使用来自openml.org的‘credit-g’数据集。这包括银行客户的许多特征，带有一个标签，表明他们是好的还是坏的信用风险。可以使用如下所示的 sklearn API 下载数据集。

接下来，我们希望将数据帧写回 Snowflake，以用于训练模型。

以下代码将 pandas 数据帧转换为 Snowpark 数据帧，然后将其作为一个表写入 Snowflake。我们还保留了一个小数据集，用于稍后使用训练好的模型进行测试推断。这也保存为雪花中的一个表。

训练模型

对于模型定型，我们将创建一个存储过程。在此之前，我们需要将我们打算使用的包添加到会话中，如下所示。

我们现在可以创建存储过程了。这里的代码将数据分成测试集和训练集，并使用 scikit-learn 管道来执行预处理和训练。模型被训练，保存到指定阶段，并返回分类报告。

批量预测

既然我们已经训练了模型，我们想要测试在我们先前保留的推理数据集上生成预测。

在此之前，我们需要将模型位置添加到会话中。

接下来，我们创建一个 UDF 来使用该模型生成预测。

以下代码读入我们为推断保留的数据，并使用 UDF 生成预测。

让我们在雪花中查看结果表。

预测保存到雪花。作者图片

机器学习领域仍然非常分散。典型组织中的机器学习工作流由许多不同的工具组成，这些工具在该过程中扮演不同的角色。数据是这种碎片化可能严重影响机器学习模型的质量和成功的领域之一。

将数据从一个工具移动到另一个工具的需求可能会导致存储相同数据的多个副本，带来数据质量问题和潜在的安全漏洞。Snowpark 和 BigQueryML 等工具寻求最小化这种数据移动，并从本质上将数据科学引入数据仓库。

本教程简单介绍了机器学习工作流，包括 Snowpark Python API 的训练和部署。该工具远不止我在此分享的内容，还有许多实现数据科学工作流的潜在选项。为了获得更全面的指导，我参考了本文开头链接的 Snowpark 示例。

感谢阅读！

机器学习在乳腺癌研究中的应用

原文：https://towardsdatascience.com/machine-learning-in-breast-cancer-research-d1dd99f7819a

可解释的机器学习如何应用于乳腺癌研究中的模式识别

照片由来自 Pexels 的 Tara Winstead 拍摄

在过去的几年里，围绕机器学习将如何改变许多行业有很多炒作。经常提到的一个行业是医疗保健。在下面的博客文章中，我们将探索一种可以产生的影响。我们将通过检查 2021 年发表在《自然》杂志上的一篇文章来做到这一点。这篇文章的名字是通过可解释的机器学习进行形态学和分子乳腺癌剖析。

这篇文章将有三个部分:研究的目的、研究的方法 /结果以及为什么这对肿瘤学和卫生保健很重要。

目的

从历史上看，肿瘤学研究中的各种分析技术之间缺乏整合。这使得癌症特性的分子数据和形态学数据有些脱节。这项研究中的研究人员着手通过机器学习建立一种联系，在这两种类型的分析技术之间架起一座桥梁。如果成功，这种方法可以帮助产生细胞类型和分子特性之间联系的假设。

方法/结果

机器学习算法

这项研究使用的机器学习方法基于一种称为分层相关性传播(LRP)的技术。逐层相关性传播是一种可解释的机器学习算法。该方法可以突出用于给定输出的最重要的输入特征，而不是只给出特定输入的输出。对于使用图像的情况，突出显示的特征是像素。结果是输入图像上的热图，显示哪些像素对输出的波动影响最大。在给定分类的情况下，具有高颜色强度的像素与像素的高相关性分数相关。这个过程的基本等式可以表示为:

j 和 k 代表神经网络中连续两层的神经元。Zjk 表示神经元 j 对使神经元 k 相关有多少贡献。 R 是 j 和k的关联分数

LRP 计算的属性解释了输入要素的总贡献，而不是您在注意力热图中获得的对输入变化的敏感度。对于逐层相关性传播如何工作的更多技术解释，请参考以下论文:逐层相关性传播概述。

算法的应用

既然我们讨论了逐层相关性传播如何工作的概述，我们将探索研究团队如何能够将其用于癌症形态学和分子乳腺癌数据。

该团队首先创建了一个图像数据库(柏林癌症图像库，B-CIB ),其中包含显微镜图像数据的注释补丁。使用 LRP，研究小组能够区分癌细胞和肿瘤浸润淋巴细胞(til)。til 是淋巴细胞，可以渗透到肿瘤组织中，识别并杀死癌细胞。它们存在的密度可以用作预测患者存活的特征。LRP 允许他们的密度的视觉表现。

然后，研究人员使用形态学图像数据作为算法的输入来预测分子特征。本质上，试图通过扫描图像来获得对患者分子特性的洞察。用于训练的数据由组合的图像和分子谱数据组成。考虑到这部分研究的目的以及通过数据集获得的用于训练的信息，不需要手动空间注记。他们可以让算法在训练期间通过输入分子数据和形态学数据来识别图像中的模式。为了减少分类任务的维度，他们对不同的分子特征使用了高低分类方法。该算法基于对分子特征的表达是高还是低的预测给出分类，给定形态学图像作为输入。表达水平得分较高的两个基因是 CDH1 和 TP53。

CD h1 和 TP53 基因的重要性

基于它们对乳腺癌的影响的先验知识，为这些分子特征产生高表达分数的算法是有意义的。

TP53 基因被认为是一种肿瘤抑制基因。它调节细胞有丝分裂的水平。当这种基因突变时，就会发生过度的细胞分裂，形成肿瘤。

CDH1 突变通过增加增殖(即细胞数量增加)和转移(即癌症生长远离原发地)与癌症进展相关。CDH1 产生的蛋白质是 E-钙粘蛋白，它对细胞粘附至关重要，使细胞保持在一起，人们认为这种基因的遗传变化可以导致癌细胞更容易从肿瘤的原发部位分离，从而导致转移。

该团队还尝试预测分子特征的空间定位。该预测显示了与某些分子特征表达统计相关的空间区域。这些信息可用于创建关于肿瘤微环境的特定成分与分子肿瘤概况特征的相关性的假设，从而推动发现图像中显示的肿瘤组织学特征和可能表达的分子特征之间可能存在的潜在联系。这些链接可以导致候选人名单可用于分子特征。这些列表将包括与乳腺癌相关的分子特征。

最终，机器学习方法揭示了与各种分子特征的表达统计相关的空间和形态学特征。这些信息通过热图显示，热图显示了在大多数情况下，分子特征如何与测试的形态组(癌细胞、til 和间质(支持细胞))有特定的关联。

为了测试结果的有效性，该团队使用了一种称为免疫组织化学(IHC)染色的技术，将结果与机器学习算法生成的热图进行比较。他们利用样方测试来显示两者之间的联系。样方检验可用于测量点格局的空间随机性。象限检验通过卡方检验来测量空间随机性。总的来说，IHC 模式反映了从验证机器学习方法的机器学习算法预测的模式。

为什么

我们今天看到的研究是机器学习如何用于癌症研究目的的一个很好的例子。它不一定会取代已经存在的工具，但它可以作为这些工具的补充。肿瘤学研究的一些用例涉及通过基于机器学习的方法可能出现的新模式生成假设。从本文探索的研究中可能产生的假设的例子大多与在非空间分子特征和空间信息之间发现的新关系有关。这些关系有助于更精确的肿瘤分级和潜在靶向治疗的新候选列表。

在模式识别至关重要的行业，机器学习可以充当进一步推动发现的指路明灯。

分层相关性传播:概述 ResearchGate 上的科学数字。可从:https://www . researchgate . net/figure/Illustration-of-the-LRP-procedure-Each-neuron-re distributes-to-the-lower-layer-as-much _ fig 2 _ 335708351【2022 年 8 月 17 日获取】

Binder，a .，Bockmayr，m .，Hä gele，m .等,《通过可解释的机器学习进行形态学和分子乳腺癌剖析》。自然机器智能 3，355–366(2021)。【https://doi.org/10.1038/s42256-021-00303-4 号

MEDLINE plus[互联网]。贝塞斯达(MD):美国国家医学图书馆(US)；[更新于 2020 年 6 月 24 日]。CDH1 基因；【更新于 2017 年 8 月 1 日；已审核 2018 年 7 月 1 日；引用 2022 年 8 月 17 日]；供货地:【https://medlineplus.gov/genetics/gene/cdh1/#conditions

数字营销中的机器学习:4 个用例及未来展望

原文：https://towardsdatascience.com/machine-learning-in-digital-marketing-4-use-cases-and-future-outlook-654a49c131ad

照片:pix abay:https://www.pexels.com/ru-ru/photo/ipad-35550/

虽然适用于公司运营的机器学习解决方案并不缺乏，但营销已准备好从 ML 中获得最大收益。今天的公司收集了无数关于客户行为的数据点，从一个品牌的社交媒体页面上的赞数到客户点击“订单”所需的时间，一切都可以被记录和分析。

在这篇文章中，我们讨论了组织如何在数字营销中使用机器学习来寻找新客户，简化消费者细分，并使客户体验更加个性化。

寻找新客户

人们每天在网上产生的大量数据是每个营销人员的金矿。人们发布、喜欢、分享、搜索和互动的所有类型的内容可以帮助营销人员识别最有可能在不久的将来购买特定类型产品或服务的消费者。

同时，与计算机视觉解决方案相结合的自然语言处理引擎可以自动检测特定客户最感兴趣的主题。

事实上，这正是谷歌应用活动的运作方式。一个专有的机器学习模型分析了用户在线执行的无数操作，并向最有可能购买的用户显示品牌广告。更重要的是，谷歌的 ML 模型还负责应用广告的设计和格式。公司只需要提供相关的文本、视频、图像和 HTML5 资产，ML 就会计算出广告的最佳组合。谷歌通过自动测试 Google Play、Google Search、Discover 和 YouTube 上的不同广告设计来揭示哪些特定广告设计表现最佳。

改善客户群细分

客户细分是最古老和最有效的实践之一，它使营销人员能够降低每次采购成本(CPA)并提高投资回报率。传统上，营销人员主要根据年龄、地点、收入、生活方式选择、兴趣和其他直觉上合理的特征对客户进行分组。但 ML 可以帮助营销人员将客户的属性分组，这些属性乍一看没有意义。

这是在无监督 ML 算法的帮助下完成的，该算法可以在未标记的数据中找到模式。用非常粗略的术语来说，你可以将一个巨大的数据集扔给一个无监督的 ML 算法，它会自动找到不同客户之间的相似之处，并将他们聚集在细分市场中。首先，该解决方案可以显著减少客户细分所需的时间。其次，它允许揭示看似不相关的客户和客户群之间的隐藏关系。

增强个性化

在过去的十年里，个性化一直是营销领域的热门话题。营销人员通过基于规则的个性化方法取得了不同程度的成功，然而，随着目标受众随着产品供应范围的扩大，个性化变得越来越难以实现。最重要的是，客户的需求和希望是不断波动的，这使得手动个性化方法从长远来看是无效的。

ML 部分消除了人工配置个性化策略的需要，并允许公司实现大规模个性化。借助协作式和基于内容的过滤，组织可以节省大量时间来确定在下一封电子邮件简讯中或在客户购买了特定类别的产品后提供什么产品。从内容创建到推荐引擎，ML 让营销人员能够提高品牌忠诚度，培养长期客户参与度。

预测客户流失和需求

使用 ML，公司可以预测需求并确定客户流失的原因。虽然需求预测通常与财务管理相关联，但这种洞察力已被证明有利于改进营销活动。了解什么产品在特定时期会引起高度兴趣可以帮助营销人员推动更多的转化。

ML 模型还可以检测客户行为模式，并帮助企业了解流失背后的原因。这样，营销人员可以使用 ML 来了解哪些客户最有可能取消订阅时事通讯或取消订阅，并为他们提供特殊优惠和促销。

此外，对于大多数公司来说，获得一个新客户的成本要比留住一个现有客户高得多。ML 能够预测客户的终身价值，这使得营销人员能够确保最有价值的客户在长期内流失的可能性最小。

结论

上面提到的数字营销中 ML 应用的例子只是触及了该技术真正潜力的表面。简而言之，ML 允许营销人员不断分析其过去、现在和未来的消费者不断产生的巨大数据流。

在这个时间点上，忽视基于 ML 的营销必然会导致未来的竞争劣势。当一个顾客意识到他或她需要购买一个特定的产品时，使用 ML 的营销人员可以比不使用 ML 的营销人员更快地发现这个潜在客户。从那里开始，不同的品牌将根据广告的时机和设计相互竞争，这也迅速成为大联盟的专长之一。这样，随着技术的不断进步，营销竞争优势变得更加依赖于公司驾驭 ML 的能力。

实际上，ML 与营销运作的这种深度整合还需要数年时间，因为技术仍有改进的空间，法规也有跟进的空间。然而，当这种技术在营销环境中变得无处不在时，那些已经在探索 ML 驱动策略的人将拥有明显的优势。

材料科学中的机器学习

原文：https://towardsdatascience.com/machine-learning-in-materials-science-8c6c0db5ce7a

探索机器学习在材料科学中的应用

图片改编自 Adobe Stock

随着人工智能和机器学习领域的爆炸式增长，它们的普适性越来越明显。机器学习正在大量的子领域中发挥作用，材料科学和聚合物科学也不例外。本文将作为系列文章的第一篇，我将简要讨论与机器学习和材料科学相关的研究论文，其目标只是探索机器学习在该领域中的不同应用方式。

在这次迭代中，我们将关注聚合物。由于聚合物科学是一个非常特殊的领域，如果你正在阅读这篇文章，我假设你已经熟悉了它的基础知识。然而，如果你和我一样，只是天生好奇，我们会用一些基础知识作为论文评论的序言。我必须声明一下我的背景:虽然我在一个实验室工作过，在那里我经常进行聚合物特性测试，但我绝不是一个专家——我只是熟悉这个空间和一些使用的实验室技术。当我试图触及事情的科学方面时，请记住这一点。😃

聚合物基础

在深入了解什么是分子水平的聚合物之前，让我们看看一些熟悉的材料，它们是很好的例子。聚合物的一些例子包括:塑料、尼龙、橡胶、木材、蛋白质和 DNA。在这种情况下，我们将主要关注塑料和尼龙等合成聚合物。

图片改编自 Adobe Stock

在分子水平上，聚合物由长链重复分子组成。在这个链中重复的分子被称为单体(或亚单位)。单体就像链条中的一环。下图显示了多个单体连接在一起形成的聚合物，其中重复序列(用括号表示)可以重复 n 次。

作者图片

有大量的潜在分子可以用作单体:我们将要看的论文提到，已知的化合物大约在 10⁸，而据信最多在 10⁶⁰也可能存在！让我们来看看一些经典的单体例子。

作者图片

显然，单体有各种形状和大小！这一点很重要，因为单体是材料的基本组成部分，所以不同的分子结构会导致截然不同的材料特性。分子设计(设计和发现用作单体的新分子)是聚合物科学研究的一个关键领域，我们将看到一些专注于此的论文(在这篇文章中，以及在未来的迭代中)。

聚合物链并不总是只由一种重复单元组成。均聚物是重复亚单元相同的聚合物，而共聚物将包含两种类型的亚单元。甚至还有三元共聚物(3)和四元共聚物(4)！当聚合物有一种以上的亚单元时，它们不一定要交替，如下图所示。

作者图片

亚基的不同组成和构型可以产生不同的性质。在一级结构(链的线性序列)之上，聚合物还可以包含支链、交联或网络结构。

作者图片

作者图片

作者图片

更高级的结构取向和形态也会影响性能。进一步的细节超出了这篇文章的范围，但是这里要说明的一点是，有很多复杂性需要考虑，除此之外，在结构和组成上有无限的可能性(所有这些都会改变材料的属性和行为)。尽管如此，很明显，考虑到时间、材料和劳动力成本等因素，在实验室中探索所有可能性基本上是不可能的。这就是计算和机器学习的用武之地！

在聚合物信息学中，机器学习可以应用于聚合物的加速表征、建模和分析、性能预测和分子设计。将 ML 应用于研究工作流可以节省大量的时间和金钱，因为大多数试错过程都通过计算和预测来减少，从而大大缩小了实验室中实际工作的搜索空间。这听起来像是推进研究的一个不可思议的解决方案，但必须考虑到一些关键挑战:

• 与聚合物相关的数据有限
• 通常需要专家参与的混合方法
• 验证需要实验室分析

随着这一领域的工作越来越多，这些挑战的影响应该会大大减少。也就是说，这篇评论选择的论文专注于分子设计，并且有一个非常有趣的方法来克服这些关键挑战之一。我们去看看吧！

论文综述:使用分子设计算法通过机器学习辅助发现高导热聚合物

吴，近藤，杨，木本，马。等【使用分子设计算法的高导热聚合物的机器学习辅助发现】(https://rdcu.be/cNgzd)。npj 计算机材料 5，66 (2019)。https://doi.org/10.1038/s41524-019-0203-2

具有机器学习的分子设计非常有前途，并且有许多工作正在探索这个空间。在本文中，目标是设计具有高热导率的新型聚合物材料(侧重于重复亚单元的化学结构)，与最先进的热塑性塑料相当。

图片改编自 Adobe Stock

这篇论文的有趣之处在于，该模型提出的分子结构是在实验室合成和验证的。引用作者的话:

“在聚合物的特殊情况下，设计的聚合物被合成和实验证实是前所未有的.”

这项工作的另一个有趣的方面是使用领域知识来克服只有 28 个热导率数据训练实例的数据集。作者使用了替代数据，而是将玻璃化转变温度和熔点作为“代理属性”，因为他们知道玻璃化转变温度和熔点较高的聚合物往往也具有较高的导热性。

使用概率语言模型的贝叶斯分子设计

通常，当涉及到机器学习的分子设计时，预测有两个方向。“向前”方向被称为定量结构-性质关系，或 QSPR 。基本上在这个方向上，物理和化学性质是用给定的化学结构输入来预测的。后向方向被称为逆 QSPR ，正如它听起来的那样:给定一组目标物理或化学性质，一个分子结构被预测。

旁注:定量结构-活性关系(QSAR)类似于 QSPR，但它模拟的是分子结构和生物活性之间的关系，而不是物理/化学性质。这种类型的分子设计对于药物发现是必不可少的。

在本文中，使用了被称为贝叶斯分子设计的机器学习算法。如前所述，目标是在给定一组目标物理性质(iQSPR)的情况下设计单体单元的分子结构。化学结构使用简化的分子输入行输入系统(SMILES)符号表示，该符号实质上将化学结构压缩成一个字符串:

SMILES 算法的可视化。图片来源: 百科

正向模型定义为p(Y∈U|S)，反向模型定义为p(S|Y∈U):

给定其物理性质 Y 的化学结构 S 的概率位于区域 U 中，其中 Y 是热导率， U 是所需的值范围。

先验分布

先验分布 p(S) 用于最小化模型预测的无效化学结构的出现。为了定义 p(S) ，在 PolyInfo 数据库中的 14423 个均聚物上训练n = 10阶的 n-gram 模型，以学习真实且有利的结构分子模式。

这个可视化中没有有意义的数据，只有分布:)来源:作者

正向预测步骤

使用正向预测模型训练 1000 个神经网络，旨在预测玻璃化转变温度。和熔化温度。以单体化学结构作为输入。从这里开始，使用在预测热导率的原始目标方面表现最好的模型，并使用迁移学习和 MXNet 对少量热导率数据进行微调。

向后预测步骤和验证

最后，利用先验分布和正向模型，形成反向模型，并使用顺序蒙特卡罗方法用于产生 1000 个化学结构。从这些结构中，使用 SA 分数基于它们的理论可合成性和加工的容易程度选择了 3 个。

合成了 3 种选定的聚合物(称为 4、13 和 19 ),并在实验室测试了它们的热物理性质。4、13 和 19 的热导率绝对预测误差分别为 0.015、0.001 和 0.017 W/mK，表明预测值和实验值之间高度一致。最终，这些值的范围从0.18-0.41 W/mK，与最先进的热塑性塑料相当，并且与研究人员的目标范围一致。

这些结果确实令人兴奋，尤其是考虑到这个领域公开可用的数据仍然缺乏。如果科学界能够贡献并显著扩展可用的聚合物数据，我认为一些真正有前途的研究可以利用机器学习来完成。如果你对本文所用方法的细节感兴趣，我鼓励你读一读！

结论

看到机器学习应用到不同的领域真的很迷人，我认为在材料科学和工程领域可以取得一些非常酷和重要的成果，特别是在优化可持续发展和改善环境友好性方面。😃

希望长期延续这个系列，欢迎任何批评或改进建议！感谢阅读！

参考文献

• https://link.springer.com/article/10.1007/s10822-016-0008-z
• https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7050509/
• https://onlinelibrary.wiley.com/doi/10.1002/inf2.12167

生产中的机器学习

原文：https://towardsdatascience.com/machine-learning-in-production-mlops-80ab59628d97

(istockphoto.com)

介绍

机器学习模型很棒，但除非你知道如何将它们投入生产，否则很难让它们创造最大的可能价值。机器学习项目的工作流程是系统地规划出机器学习项目的生命周期。当构建机器学习系统时，思考机器学习项目的生命周期是计划出所有需要努力的步骤的有效方法。

例如，我们正在使用计算机视觉来检查从生产线上下来的手机，看看它们是否有缺陷。在下图中，左边的手机没有任何划痕。但如果有一段裂缝或其他什么，计算机视觉算法将有望找到这种类型的裂缝或缺陷。也许在它周围放上边框作为质量控制的一部分。如果你得到一组有划痕的手机的数据，你可以训练一个可能在你的网络中的计算机视觉算法来检测这些类型的缺陷。但是，为了将其投入生产部署，您现在需要做些什么呢？

图 1:示例计算机视觉项目，用于检查从生产线上下来的手机，看它们是否有缺陷。

这是一个如何部署这样一个系统的例子。您可能有一个边缘设备，即位于制造这些智能手机的工厂内的设备。边缘设备会有一个检查软件，它的工作是拍摄手机照片，看看是否有拉伸，然后决定这款手机是否可以接受。这实际上通常在工厂中完成，并被称为自动化视觉缺陷检查。检测软件所做的是，它将控制一台相机，当智能手机从生产线上下线时，该相机将拍摄智能手机的照片。然后，它必须进行 API 调用，以将该图片传递给预测服务器。预测服务器的工作是接受这些 API 调用，接收图像，决定该手机是否有缺陷，并返回该预测。最后，检测软件可以做出适当的控制决定，是否让它继续在生产线上运行。

ML 基础设施要求

在过去的十年里，机器学习模型受到了很多关注。然而，部署机器学习模型和产品需要的不仅仅是机器学习代码。所以你的神经网络或者另一种算法，学习从一些输入到一些输出的函数映射。这是机器学习模型的惊人进步。

但事实证明，如果你看一个生产中的机器学习系统，如果这个橙色的小矩形代表机器学习代码，机器学习模型代码[1]。然后这些就是你整个机器学习项目需要的所有代码。很多机器学习项目，可能只有 5–10%，甚至更少的机器学习代码。

图 2:只有一小部分真实世界的 ML 系统由 ML 代码组成，如中间的橙色小框所示。所需的周边基础设施庞大而复杂[1]。

这也是为什么当你在 Jupyter 笔记本上使用概念验证模型时。从最初概念验证到生产部署，仍然有许多工作要做。所以有时人们会提到 POC。或者对生产差距的概念证明。这种差距很大程度上是因为除了最初的机器学习模型代码之外，还要编写所有这些代码。

除了机器学习代码，还有许多组件，尤其是用于管理数据的组件，如数据收集、数据验证、特征提取。在你服务它之后，如何监控系统将监控回来的数据，帮助你分析它。但是通常还需要构建许多其他组件来支持工作生产部署。

机器学习项目生命周期

机器学习项目的工作流程是系统地规划出机器学习项目的生命周期。这些是机器学习项目的主要步骤。首先是范围界定，你必须定义项目或者决定做什么。你到底想对什么应用机器学习，什么是 X，什么是 y，在选择了项目之后，你就必须收集数据或者获取你的算法需要的数据。这包括定义数据和建立基线，然后标记和组织数据。有了数据之后，就必须训练模型。在建模阶段，您必须选择和训练模型，还要执行错误分析。

图 3: MLOps(机器学习操作)是一个新兴的学科，由一套工具和原则组成，以支持 ML 项目生命周期的进展[2]。

你可能知道机器学习通常是一项高度迭代的任务。在错误分析过程中，您可能会返回并更新模型，或者您也可能会返回到早期阶段并决定还需要收集更多数据。在部署系统之前，作为错误分析的一部分，您通常还会执行最终检查，可能是最终审计，以确保系统的性能足够好，并且对于应用程序来说足够可靠。当你第一次部署一个系统时，你可能已经完成了一半的工作，因为通常只有在你开启实时流量后，你才能学到使系统运行良好所需的重要课程的后半部分。

部署

任何机器学习项目中最令人兴奋的时刻之一是当你开始部署你的模型时，但是是什么使得部署变得困难呢？部署机器学习模型有两大类挑战。首先，是机器学习或统计问题，其次，是软件引擎问题[4]。

概念漂移和数据漂移

许多部署面临的挑战之一是概念漂移和数据漂移。不严格地说，这意味着如果您的数据在您的系统已经部署之后发生了变化，该怎么办呢？在我们之前的制造示例中，您可能已经训练了一个学习算法来在一组照明条件下检测智能手机上的划痕，然后工厂中的照明可能会发生变化。这是数据变化分布的一个例子。重要的是，你要认识到数据是如何变化的，以及你是否因此需要更新你的学习算法。当数据发生变化时，有时是一种渐进的变化，例如英语确实在变化，但变化非常缓慢，新词汇的引入速度相对较慢。有时，当系统突然受到冲击时，数据会突然改变。

新冠肺炎和信用卡诈骗系统

当疫情袭击新冠肺炎时，许多信用卡欺诈系统开始失效，因为个人的购买模式突然改变了。许多很少进行网上购物的人突然开始更多地使用网上购物。所以人们使用信用卡的方式突然改变了，这实际上触发了很多反欺诈系统。这种向数据分布的突然转变意味着，许多机器学习团队在 COVID 的开始阶段有点混乱，以收集新数据并重新训练系统，以便使它们适应这种非常新的数据分布。

有时，描述这些数据变化的术语并不完全一致，但有时，术语数据漂移用于描述输入分布 x 是否发生变化，例如，如果一位新的政治家或名人突然变得众所周知，他被提及的次数比以前多得多。术语概念漂移指的是从 x 到 y 的期望映射是否改变，例如在新冠肺炎之前的 if。也许对于一个给定的用户来说，许多令人惊讶的网上购物应该已经标志着该帐户的欺诈。在新冠肺炎开始后，就萎靡不振而言，也许同样的购买不会真的引起任何恐慌。那张信用卡可能被偷了。

软件工程问题

除了管理这些数据的变更之外，第二组问题是软件工程问题，您必须设法成功地部署一个系统。您正在实现一个预测服务，它的工作是接受查询 x 并输出预测 y，对于如何实现这个软件，您有很多设计选择。这里有一个问题清单，可以帮助你做出管理软件工程问题的正确决定。对于您的应用程序，您必须做出的一个决定是，您需要实时预测还是批量预测？例如，如果您正在构建一个语音识别系统，其中用户说话，您需要在半秒钟内得到响应，那么显然您需要实时预测。相比之下，为医院建立系统，记录病人的病历。拿走电子健康记录，运行一个通宵批处理程序，看看是否有与病人相关的东西，我们可以发现。因此，在这种类型的系统中，如果我们只是每晚在一批患者记录中运行一次，就没问题了。无论你是否需要编写实时软件，它们可以在数百毫秒内做出响应，或者你是否可以编写一夜之间完成大量计算的软件，这将影响你如何实现你的软件。

部署模式

当你训练学习算法时，部署它的最佳方式通常不是打开它并抱最好的希望，因为，嗯，如果出了问题怎么办？首次部署与维护和更新部署之间的一些差异。让我们把它充实得更详细一点。一种类型的部署是，如果您提供以前没有提供过的新产品或新功能。例如，如果您正在提供以前没有提供过的语音识别服务，在这种情况下，常见的设计模式是启动少量流量，然后逐渐增加流量。第二个常见的部署用例是，如果有人已经在做一些事情，但我们现在希望使用一种学习算法来自动完成或帮助完成这项任务。例如，如果你让工厂里的人检查智能手机的划痕，但现在你想使用一种学习算法来帮助或自动完成这项任务。人们以前这样做的事实为您如何部署提供了更多的选择。

阴影模式部署

让我们从视觉检查的一个例子开始，也许你已经让人工检查员检查智能手机的划痕缺陷。你现在想用一个学习算法来自动完成一些工作。当您最初让人们执行任务时，一种常见的部署模式是使用影子模式部署。

图 4: ML 系统遮蔽了人，并行运行。在此阶段，ML 系统的输出不用于任何决策。样本输出并验证 ML 系统的预测

这意味着，你将首先让一个机器学习算法跟随人类检查员，并与人类检查员并行运行。在这个初始阶段，学习算法输出不用于工厂的任何决策。因此，无论学习算法说什么，我们现在都要遵循人类的判断。假设这个智能手机，人们说它很好，没有缺陷。学习算法说没问题。也许对于这个中间大拉伸的例子，这个人说这不好，学习算法也同意。也许对于这个拉伸较小的例子，也许这个人说这不好，但学习算法犯了一个错误，实际上认为这是好的。影子模式部署的目的是让您收集数据，了解学习算法的执行情况以及与人类判断的对比情况。使用影子模式部署是一种非常有效的方法，可以让您在让学习算法做出任何真正的决定之前验证它们的性能。

金丝雀部署

当您准备好让学习算法开始做出真正的决策时，常见的部署模式是使用金丝雀部署。在金丝雀部署中，您可能会部署一小部分流量，可能是 5%，可能最初甚至更少，并开始让算法做出真正的决策。

图 5:最初推出一小部分流量(比如说 5%)。监控系统并逐渐增加流量。

但是，如果只在一小部分流量上运行这种算法，如果算法出现任何错误，它将只影响一小部分流量。这为您提供了更多的机会来监控系统，并且只有在您对此性能更有信心的情况下，才会逐渐提高流量百分比。Canary 部署允许您在问题可能对工厂或您部署学习算法的其他环境产生过大后果之前，及早发现问题。

蓝绿色展开

有时使用的另一种部署模式是蓝绿色部署。假设我们有一个系统，相机软件，用于在您的工厂收集手机图片(图 6)。这些手机图像被发送到一个软件，该软件获取这些图像并将其发送到一些视觉检测系统。在蓝绿色部署的术语中，您的软件的旧版本被称为蓝色版本，而新版本，即您刚刚实现的学习算法被称为绿色版本。在蓝绿色部署中，您要做的是让路由器向旧版本或蓝色版本发送图像，并让它们做出决策。

图 6:启用回滚的简单方法。

然后，当您想要切换到新版本时，您需要做的是让路由器停止向旧版本发送图像，并突然切换到新版本。因此，蓝绿部署的实现方式是，您将拥有一个旧的预测服务，它可能运行在某种类型的服务上。然后你会启动一个新的预测服务，绿色版本，你会让路由器突然将流量从旧的切换到新的**。**蓝绿色部署的优势在于可以轻松实现回滚。在蓝绿部署的典型实施中，人们会想到同时 100%地切换流量。

自动化程度

MLOps 工具可以帮助实现这些部署模式，或者您可以自己实现它们。考虑如何部署系统的最有用的框架之一是考虑部署，而不是像 0，1 那样要么部署要么不部署，而是设计一个系统，考虑什么是适当的自动化程度。例如，在智能手机的视觉检测中，一个极端是如果没有自动化，那么只有人类的系统。如果您的系统运行的是影子模式，那就是稍微自动化的模式。所以你的学习算法是把预测，但它实际上并没有用在工厂里。这就是影子模式。自动化程度稍高一点的将是人工智能辅助，给定一张像这样的智能手机照片，你可能会让人类检查员做出决定。

图 7:设计一个系统，考虑什么是适当的自动化程度。您可以选择在实现完全自动化之前停止。

但也许人工智能系统可以影响用户界面，突出显示有划痕的区域，以帮助吸引人们的注意力，让他们看起来最有用。用户界面或 UI 设计对于人工协助至关重要。但这可能是一种在保持人在循环中的同时获得稍微更高程度的自动化的方法。更大程度的自动化可能是部分自动化，如果给我们一部智能手机，如果学习算法确定它没问题，那就是它的决定。它肯定是有缺陷的，然后我们就去算法的决定。但是如果学习算法不确定，换句话说，如果学习算法预测不太有把握，0 或 1，也许只有这样我们才会把这个发给人类。所以这是部分自动化。对于学习算法的性能对于完全自动化来说不够好的应用程序，部分自动化有时是一个非常好的设计点。

当然，除了部分自动化，还有完全自动化，我们可以让学习算法做出每一个决定。因此，在左边有一个只使用人类决策的范围，一直到在右边只使用人工智能系统的决策。而且很多部署应用会从左边开始，逐渐向右移动。我发现，消费者的互联网应用程序，如如果你运行一个网络搜索引擎，写一个在线语音识别系统。许多消费软件互联网企业不得不使用完全自动化，因为每次有人进行网络搜索或产品搜索时，让后端的人做一些工作是不可行的。但是在消费软件互联网之外，例如，检查东西和工厂。它们实际上是许多应用程序，其中最佳设计点可能是人在回路中的部署，而不是完全自动化的部署。

监控

你如何监控一个机器学习系统，以确保它满足你的性能预期？监控机器学习系统最常见的方式是使用仪表板来跟踪它如何超时工作。根据您的应用程序，您的仪表板可能会监控不同的指标。例如，您可能有一个仪表板来监控服务器负载，或者有一个不同的仪表板来监控非空输出的衍射。当你试图决定监控什么时，我建议你和你的团队坐下来，头脑风暴所有可能出错的事情。然后你想知道是否有什么事情出错了。对于所有可能出错的事情，头脑风暴一些统计数据或一些度量标准来检测问题。例如，如果您担心用户流量激增，导致服务过载，那么服务器负载可能是一个指标，您可以跟踪其他示例。

当我第一次设计我的监控仪表板时，我认为可以从许多不同的指标开始，监控一个相对较大的集合，然后逐渐删除那些随着时间的推移你发现不是特别有用的指标。这里有一些我们的观点或者我见过的其他人在各种项目中使用的度量标准的例子。首先是软件指标，如内存、计算、延迟、吞吐量、服务器负载等，这些指标有助于您监控预测服务的软件实现或围绕您的学习算法的其他软件的健康状况。除了软件指标，我经常会选择其他指标来帮助监控统计健康或学习算法的性能。

当然，对于 web 搜索，您也可以使用非常粗略的指标，如点击率或 CTR，只是为了确保整个系统是健康的。这些输出指标可以帮助您找出您的学习算法，输出 y 是否以某种方式发生了变化，或者在您的学习算法输出之后是否发生了一些事情，例如用户切换到打字，是否以某种方式发生了重大变化。因为输入和输出指标是特定于应用程序的，所以大多数 MLOps 工具都需要专门配置来跟踪应用程序的输入和输出指标。

正如 ML 建模是迭代的一样，部署也是迭代的

你可能已经知道机器学习建模是一个高度迭代的过程，部署也是如此。以建模为例，你会提出一个机器学习模型和一些数据，训练模型，这是一个实验。然后进行误差分析，并使用误差分析来找出如何改进模型或数据，通过多次迭代这个循环，你就有希望得到一个好的模型。

图 8:选择正确的度量集进行监控的迭代过程。

强烈建议将部署视为一个迭代过程。当您启动并运行您的第一批部署，并设置一组监控仪表板时。这只是这个迭代过程的开始。一个运行的系统让你获得真实的用户数据或者真实的流量。通过查看您的学习算法在真实流量的真实数据上的表现，您可以进行性能分析，这反过来有助于您更新部署并持续监控您的系统。在您选择了一组要监控的指标之后，通常的做法是设置警报的阈值。您可以根据这个设置来决定，如果服务器负载超过 0.91，可能会触发警报或通知，让您或团队知道是否有问题，并可能启动更多的服务器。或者，如果不是这样，一小部分缺失值会高于或低于某组阈值，这可能会触发警报，如果您随时间推移调整指标和阈值，以确保它们向您标记最相关的问题案例，也没关系。如果这是与学习算法的准确性相关的性能问题，那么您可能需要更新您的模型。或者，如果这是一个与学习算法的准确性相关的问题，那么您可能需要回去修复它。这就是为什么随着时间的推移，许多机器学习模型需要一点维护或再培训。

管道监控

许多人工智能系统不仅仅是运行预测服务的单一机器学习模型，而是涉及多个步骤的流水线。那么什么是机器学习管道，你如何为此建立监控系统呢？让我们看一个涉及用户配置文件的例子。也许我使用了诸如点击流数据之类的数据来显示用户正在点击什么。并且这可以用来建立试图捕捉用户的关键属性或关键特征的用户简档。例如，我曾经建立了用户档案，试图预测用户的许多属性，包括用户是否拥有汽车。

图 9:点击流数据，显示用户点击什么来建立用户简档，试图捕捉用户简档的关键属性或关键特征。

因为这将帮助我们决定是否值得尝试向用户提供汽车保险办公室。建立用户档案的典型方法是使用学习算法来预测汽车用户。这种类型的用户配置文件可以有一个很长的预测属性列表，然后可以提供给推荐系统。然后，另一种学习算法利用这种对用户的理解，尝试生成产品推荐。现在，如果点击流数据发生变化，也许这种输入分布发生变化，那么随着时间的推移，如果我们失去了判断用户是否拥有汽车的能力，那么未知标签的比例可能会上升。并且因为用户简档输出改变，推荐系统的输入现在改变，并且这可能影响产品推荐的质量。当你有一个机器学习管道时，管道中的这些级联效应可能很复杂，难以跟踪。但是，如果未知标签的百分比确实上升了，这可能是您想要提醒的事情，以便您可以在需要时更新推荐系统，以确保您继续生成高质量的产品推荐。

摘要

随着机器学习(ML)社区继续积累多年的实时系统经验，一种普遍而令人不安的趋势已经出现:开发和部署 ML 系统相对快速而便宜，但随着时间的推移维护它们是困难和昂贵的。除了机器学习代码，还有许多组件，尤其是用于管理数据的组件，如数据收集、数据验证、特征提取。在你服务它之后，如何监控系统将监控回来的数据，帮助你分析它。但是通常还需要构建许多其他组件来支持工作生产部署。因此，我们在所有这些其他软件中所学到的东西对于有价值的生产部署是必需的。但是，比起查看所有这些复杂的部分，这是最有用的组织框架之一。机器学习项目的工作流程是系统地规划出机器学习项目的生命周期。我们深入研究了机器学习项目的整个生命周期。希望这个框架对你未来计划部署的所有机器学习项目都非常有用。

👋感谢阅读。如果你喜欢我的作品，别忘了喜欢，在 medium 上关注我。这将激励我为媒体社区提供更多的内容！😊

参考资料:

[1]斯卡利博士、霍尔特博士、戈洛文博士、达维多夫博士和菲利普博士(未标明)。机器学习系统中隐藏的技术债务。2021 年 4 月 28 日从 Nips 检索。https://papers . nips . cc/paper/2015/file/86 df 7 dcfd 896 fcaf 2674 f 757 a 2463 EBA-paper . pdf

【2】深度学习。人工智能

[3] AndKonstantinos，Katsiapis，Karmarkar，a .，Altay，a .，Zaks，a .，Polyzotis，n .，…李，Z. (2020)。迈向 ML 工程:张量流扩展简史(TFX)。http://arxiv.org/abs/2010.02013

[4]帕里耶斯，a .，乌尔马，R.-G .，&劳伦斯，未标明日期(2020 年)。部署机器学习的挑战:案例研究调查。【http://arxiv.org/abs/2011.09926