TowardsDataScience-博客中文翻译-2016-2018-二十五-

TowardsDataScience 博客中文翻译 2016~2018(二十五)

原文:TowardsDataScience Blog

协议:CC BY-NC-SA 4.0

逻辑回归—详细概述

原文:https://towardsdatascience.com/logistic-regression-detailed-overview-46c4da4303bc?source=collection_archive---------1-----------------------

Figure 1: Logistic Regression Model (Source:http://dataaspirant.com/2017/03/02/how-logistic-regression-model-works/)

逻辑回归在二十世纪早期被用于生物科学。后来,它被用于许多社会科学应用中。当因变量(目标)是分类变量时,使用逻辑回归。

举个例子,

  • 要预测电子邮件是垃圾邮件(1)还是(0)
  • 肿瘤是恶性的(1)还是非恶性的(0)

考虑一个场景,我们需要对一封电子邮件是否是垃圾邮件进行分类。如果我们对这个问题使用线性回归,就需要设置一个阈值,根据这个阈值可以进行分类。比方说,如果实际类别是恶性的,预测连续值为 0.4,阈值为 0.5,则数据点将被分类为非恶性的,这会导致实时的严重后果。

从这个例子可以推断,线性回归不适合分类问题。线性回归是无限的,这就带来了逻辑回归。它们的值严格地在 0 到 1 之间。

简单逻辑回归

(完整源代码:https://github . com/SSaishruthi/LogisticRegression _ Vectorized _ Implementation/blob/master/Logistic _ regression . ipynb)

型号

输出= 0 或 1

假设=> Z = WX + B

hθ(x)= sigmoid(Z)

乙状结肠功能

Figure 2: Sigmoid Activation Function

如果‘Z’趋于无穷大,Y(预测)将变为 1,如果‘Z’趋于负无穷大,Y(预测)将变为 0。

分析假设

假设的输出是估计的概率。这用于推断给定输入 x 时,预测值与实际值的可信度。考虑以下示例,

X = [x0 x1] = [1 个 IP 地址]

基于 x1 值,假设我们获得的估计概率为 0.8。这表明一封电子邮件有 80%的可能是垃圾邮件。

从数学上讲,这可以写成:

Figure 3: Mathematical Representation

这证明了“逻辑回归”这个名称的合理性。将数据拟合到线性回归模型中,然后由预测目标分类因变量的逻辑函数对其进行操作。

逻辑回归的类型

1.二元逻辑回归

分类回答只有两种可能的结果。示例:垃圾邮件与否

2.多项式逻辑回归

三个或更多类别,无需排序。示例:预测哪种食物更受欢迎(素食、非素食、纯素食)

3.有序逻辑回归

三个或三个以上的分类与排序。示例:电影等级从 1 到 5

决定边界

为了预测数据属于哪一类,可以设置一个阈值。基于该阈值,将所获得的估计概率分类。

比如说,如果 predicted_value ≥ 0.5,那么将邮件归类为垃圾邮件,否则归类为非垃圾邮件。

决策边界可以是线性或非线性的。多项式阶可以增加,以获得复杂的决策边界。

成本函数

Figure 4: Cost Function of Logistic Regression

为什么用于线性的成本函数不能用于逻辑?

线性回归使用均方误差作为其成本函数。如果这用于逻辑回归,那么它将是参数(θ)的非凸函数。梯度下降只有在函数是凸的情况下才会收敛到全局极小值。

Figure 5: Convex and non-convex cost function

成本函数解释

Figure 6: Cost Function part 1

Figure 7: Cost Function part 2

简化成本函数

Figure 8: Simplified Cost Function

为什么这个成本函数?

Figure 9: Maximum Likelihood Explanation part-1

Figure 10: Maximum Likelihood Explanation part-2

这个负函数是因为我们在训练的时候,需要通过最小化损失函数来最大化概率。假设样本是从完全独立的分布中抽取的,降低成本将增加最大可能性。

推导梯度下降算法的公式

Figure 11: Gradient Descent Algorithm part 1

Figure 12: Gradient Descent part 2

Python 实现

def weightInitialization(n_features):
    w = np.zeros((1,n_features))
    b = 0
    return w,bdef sigmoid_activation(result):
    final_result = 1/(1+np.exp(-result))
    return final_result def model_optimize(w, b, X, Y):
    m = X.shape[0]

    #Prediction
    final_result = sigmoid_activation(np.dot(w,X.T)+b)
    Y_T = Y.T
    cost = (-1/m)*(np.sum((Y_T*np.log(final_result)) + ((1-Y_T)*(np.log(1-final_result)))))
    #

    #Gradient calculation
    dw = (1/m)*(np.dot(X.T, (final_result-Y.T).T))
    db = (1/m)*(np.sum(final_result-Y.T))

    grads = {"dw": dw, "db": db}

    return grads, costdef model_predict(w, b, X, Y, learning_rate, no_iterations):
    costs = []
    for i in range(no_iterations):
        #
        grads, cost = model_optimize(w,b,X,Y)
        #
        dw = grads["dw"]
        db = grads["db"]
        #weight update
        w = w - (learning_rate * (dw.T))
        b = b - (learning_rate * db)
        #

        if (i % 100 == 0):
            costs.append(cost)
            #print("Cost after %i iteration is %f" %(i, cost))

    #final parameters
    coeff = {"w": w, "b": b}
    gradient = {"dw": dw, "db": db}

    return coeff, gradient, costsdef predict(final_pred, m):
    y_pred = np.zeros((1,m))
    for i in range(final_pred.shape[1]):
        if final_pred[0][i] > 0.5:
            y_pred[0][i] = 1
    return y_pred

成本与迭代次数

Figure 13: Cost Reduction

系统的训练和测试准确率为 100 %

该实现用于二元逻辑回归。对于超过 2 类的数据,必须使用 softmax 回归。

这是一个教育性的帖子,灵感来自吴恩达教授的深度学习课程。

完整代码:https://github . com/SSaishruthi/LogisticRegression _ Vectorized _ Implementation/blob/master/Logistic _ regression . ipynb

用于面部识别的逻辑回归

原文:https://towardsdatascience.com/logistic-regression-for-facial-recognition-ab051acf6e4?source=collection_archive---------14-----------------------

使用 sklearn 的混淆矩阵和 ROC-AUC 曲线

**注意 :此帖子不再是最新的,可能包含错误。它是为了透明而保留的。更新版本可以在这里找到

面部识别算法一直令我着迷,为了在一些数据上展示我新发现的逻辑回归技能,我基于一个名为“皮肤分割”的数据集创建了一个模型。

正如其描述中所指出的,皮肤分割中的数据是“通过从各种年龄组(青年、中年和老年)、种族组(白人、黑人和亚洲人)以及从 FERET 数据库和 PAL 数据库获得的性别的面部图像中随机采样 B、G、R 值来收集的。”数据集具有 245,057 行和 4 列(B、G、R 和指示图像被分类为包含皮肤还是不包含皮肤的二进制列)。后者,二元列使这个数据集适合逻辑回归。

(如果你想阅读使用该数据集的两篇(付费)学术文章,请参见此处的和此处的和。)

回归

我的专长是 Python,我特别想测试一下 scikit-learn 库,因为它是回归等科学任务的行业标准。我还选择使用 Juypter Notebook 作为我的 IDE,而不是 Atom 这样的文本编辑器,因为它的入门门槛较低;凭借其叙事结构,Jupyter 让大多数人都能感受到代码是如何工作的。

要自己运行这段代码,您需要在您的机器上/虚拟环境中安装/导入 Python 3、scikit-learn、Pandas、NumPy、matplotlib、Seaborn、Itertools 和 imb learn(requirements . txt 文件即将发布!).

你可以在这里找到这个项目的回购。在那里,你可以找到一个深入的 Jupyter 笔记本,概述了这篇文章中总结的所有步骤。

芒格

我必须对这个数据集进行的数据管理相当简单。在通过 URL 读入文本文件并保存到 Pandas dataframe 后,您可以看到它唯一真正的问题是缺少列标题。

Original dataframe

在将第一行下推到数据框中并重命名列标题后,我能够得到这样的结果:

Munged dataframe

在这个数据集中,1 表示没有皮肤的像素,2 表示有皮肤的像素。

正如您所预料的,1 和 2 确实很有帮助,但是我们真的希望 1 和 0 用于逻辑回归。所以,我为皮肤或无皮肤专栏制作了假人。(我还将数据类型强制为 int64,以便与数据帧中的其他列保持一致。)

Making dummies and coercing datatype.

正如你所看到的,我把这个皮肤或者无皮肤列变成了我的 y 变量(我的因变量)。其他列我变成了一个矩阵(X)。

X matrix

在我的 X 矩阵中,我还想让我的所有变量都在同一标度上,所以我让它们通过一个最小-最大归一化器,并让它们都在 0-1 标度上。

Normalizing X values

训练-测试-分割和建立模型

在使我的数据进入可工作状态后,我使用 sklearn 将它分成测试集和训练集。我还创建了我的模型,使其适合我的训练数据,然后在我的训练和测试数据上运行我的模型,以查看它的性能如何。

Train-test-split

Creating and fitting my model

Running the model on my training and test data

评估性能,第 1 部分:简单的读数

我查看了我的预测值(y_hat_train 和 y_hat_test)与我的原始 y_train 和 y_test 值之间的差异,以评估我的模型的准确性。

Evaluating initial performance

在读数中,与真实值相比,0 的数量是正确预测的数量,1 的数量是错误预测的数量。normalize = True 只是将读数的第一部分从预测数转换为百分比。

您可以看到,根据我们的训练数据,我们的模型在 90.7%的时间内是准确的,而根据我们的测试数据,它在 90.6%的时间内是准确的。相当不错!

评估性能,第 2 部分:混淆矩阵

我还想看看我的模型在混淆矩阵方面表现如何。(关于混淆矩阵的精彩阅读,见这里。)

Confusion matrix for initial model

正如你在评论中看到的,这里 0 是被分类为没有皮肤的像素,1 是被分类为有皮肤的像素。

为了让我的混淆矩阵的值更容易理解,我运行了一个分类报告,以获得一些常见的指标,如精确度、召回率和 f1 分数。

Classification Report from sklearn.metrics

您可以在这里看到,我们的模型的准确率为 96%,召回率为 92%,f1 值为 94%。我还想知道我的准确率,所以我简单地手动计算了一下,得到了 91%(与我们在上面的简单读数部分的测试数据中得到的数字相同)。

为了更好地展示每个分数的含义,请参见下图。

Recall and precision mapped onto a confusion matrix

评估绩效,第 3 部分:ROC-AUC 曲线

ROC-AUC 曲线是一个有用的指标,因为它们衡量的是真阳性率和假阳性率。

我为我的训练和测试数据生成了 ROC-AUC 曲线,但是它们看起来基本相同,所以我在这里只显示训练图像。(训练数据的 AUC 为 93.4%,而测试数据的 AUC 为 93.2%。)

Creating my ROC curve

ROC-AUC curve for testing data.

更多关于 ROC-AUC 曲线及其目的可以在这里这里找到。

如你所见,我们的 ROC 曲线紧挨着图表的左上角,这正是我们想要的。

倒回一点:ROC-AUC 曲线和类别不平衡

ROC-AUC 曲线最有用的一点是,即使原始数据集中存在类别不平衡,它们也允许我们评估模型。

类别不平衡是指在您的数据中,一种类别明显多于另一种类别。这有能力真正搞乱你的分析。举个例子,一个罕见疾病的数据集是有偏差的(即存在类别不平衡问题)。我们假设 1000 个案例中只有 2 个是阳性的。即使你做了一个蹩脚的模型,把一切都归类为负面,你仍然会达到 99.8%的准确率(即 998 / 1000 的分类是正确的)。因此,当模型在不平衡的数据集上运行时,您需要更多的上下文来真正评估您的模型。

所以,让我们倒回去一点,看看我们的数据是否不平衡。也许我们可以让我们的模型变得更好。

Class balance for original data

我们可以看到,我们的数据有点奇怪——大约 79%被归类为 1(即包含皮肤的像素),只有大约 21%被归类为 0(即不包含皮肤的像素)。

所以,在我们今天结束之前,让我们运行一个叫做 SMOTE(合成少数过采样)的东西。SMOTE 创建合成数据来为我们的少数类填充更多的值(在我们的例子中,这意味着它将为我们提供更多的 0 数据点)。尽管创建合成数据看起来像是作弊,但这在数据科学世界中是非常常见的做法,因为数据集通常并不均衡。

对我们的原始数据运行 SMOTE 并重新生成我们的混淆矩阵和分类报告,我们得到以下结果。

SMOTE confusion matrix

Classification Report for SMOTE-ized data, showing both training and test readouts

我们可以看到这些数字与我们最初的数字有很大的不同。回想一下,第一次我们的准确率为 96%,召回率为 92%,f1 得分为 94%。通过 SMOTE 运行我们的数据后,我们的准确率为 85%,召回率为 92%,f1 得分为 89%。所以,我们的模型在试图补偿阶级不平衡后实际上变得更差

作为数据科学家,何时对我们的数据运行 SMOTE 之类的操作,或者让我们的数据保持原样,这取决于我们。在这种情况下,我们可以看到,让我们的数据保持原样是正确的做法。

那么,这一切意味着什么呢?

除了是一个很好的学习机会,我们真的创造了一个很好的模式。我们知道,在这种情况下,对我们的数据做其他事情,例如试图补偿阶级不平衡,肯定不是我们应该做的。我们的原始模型是我们表现最好的,在 94%的时间里正确预测了有皮肤的图像(使用我们的 f1 分数)。

虽然这听起来可能是一个不错的分类率,但创建用于面部识别的算法会带来无数的伦理问题。如果我们的模型被用来在人群中识别被通缉的恐怖分子呢?这当然不同于在 Snapchat 中为滤镜识别人脸。

From Christoph Auer-Welsbach’s post “The Ethics of AI: Building technology that benefits people and society

这是我们作为数据科学家在创建算法时需要尽可能多的信息的地方。如果我们的模型用于 Snapchat 过滤器,我们可能会希望优化以提高我们的回忆分数——表面上看,当事物不是人脸时,我们错误地将它们识别为人脸比有时只识别真实人脸要好。

另一方面,如果我们的模型用于在人群中发现通缉犯,我们可能仍然希望优化回忆,但结果将会大不相同。如果这意味着你几乎 100%的时间都能抓到被通缉的罪犯,那么把无辜的人带进来审问并潜在地侵犯他们的权利值得吗?或许不会。

当我们在人工智能的世界里玩耍时,我们需要仔细思考这些问题。正如凯茜·奥尼尔在数学毁灭武器中所写的,构建算法需要“道德想象力,而这只有人类才能提供。”

Python 中的逻辑回归在销售营销系统盈利能力评估中的应用

原文:https://towardsdatascience.com/logistic-regression-in-python-to-evaluate-profitability-of-sales-marketing-system-fe2261964fa4?source=collection_archive---------2-----------------------

任何企业的销售和营销领域都负责寻找客户、进行销售和创造收入。销售代表通过多种沟通方式联系现有客户和潜在客户,但由于相关的时间和成本,无法联系到所有人。在本文中,逻辑回归作为一种机器学习技术将被用来识别具有较高转换概率的目标人群,并估计锁定所识别群体的盈利能力。

我的 GitHub 上的 Python 代码和数据:

[## saivishnuk/数据科学

在 GitHub 上创建一个帐户,为数据科学的发展做出贡献。

github.com](https://github.com/saivishnuk/Data-Science/tree/master/Logistic-Regression-to-evaluate-profitability-of-Sales-Marketing-System)

更多我的博客,请查看我的 和我的 GitHub

文章大纲:

  • 从总体上理解销售-营销系统,并给出一个将在本文中使用的例子
  • 理解逻辑回归作为一种技术,以及它在这种情况下如何有用
  • 评估盈利能力的方法、代码和结果

从总体上理解销售-营销系统,并给出一个将在本文中使用的示例

大多数系统使用现场销售代理通过个人拜访或移动电话联系客户。产生潜在客户和将潜在客户转化为客户需要一定的成本,接触所有客户是一项既费时又费钱的任务。

例如,一家公司推出了一款新产品,希望接触到可能对该产品感兴趣的现有客户。公司现有客户数量为 41,188,公司估计接触客户的平均成本为 10 美元,如果客户购买了产品,则客户的平均收入为 50 美元。只看数字,成本收入比为 1: 5,这项工作将产生大量利润。意识到之前营销活动对类似产品的转换率(约 11.5%),经理明白瞄准每一个客户将是一个巨大的损失。因此,经理决定首先确定目标受众,然后决定预算。他希望团队中的数据科学家回答 3 个问题:

  • 实现最高投资回报率的成本是多少?
  • 实现最高利润的成本是多少?
  • 利润-投资回报率均衡点的成本是多少?

理解逻辑回归作为一种技术,以及它在这种情况下如何有用

二项式逻辑回归,根据一个或多个连续或分类的独立变量,预测观察值落入两类二分因变量之一的概率。在销售-营销系统中,先前营销活动的结果是因变量,自变量是先前活动的度量,如“过去联系客户的次数”、“自上次购买以来的天数”,..和顾客的一些人口统计特征。在本文中,我们假设数据已按 70/30 的比例分为训练数据集和测试数据集,重点只放在衡量盈利能力的方法上。

评估盈利能力的方法、代码和结果

  1. 在培训和测试数据集中,结果变量(因变量)为“1”(购买了产品)的客户比例约为 11.2%
  2. 通过接触训练数据中的所有客户来计算“每个客户的平均利润”。

这表明,通过接触转换率约为 11.2%的所有客户,将导致 1,25710 美元的损失。这保证了目标受众的选择具有较高的转换几率。

3.对训练数据执行逻辑回归,并使用事件发生的预测概率来计算间隔为 0.01 的每个概率值的成本、收入、利润和投资回报(ROI)。

ROI= (Profit/Cost)*100

上述函数将“实际结果”、“事件发生的预测概率”、“每个人的成本”、“每个人的收入”、“要检查的概率范围”作为输入。下面的代码片段是对上述函数的调用,使用培训数据作为输入,并使用经理确定的每个人的估计成本和收入。

在这里,“事件发生的概率”被认为是区分顾客是否会购买产品的临界值。我们可以观察到,随着“事件发生的概率”增加,“目标人群百分比”减少,这意味着考虑更高的概率作为截止点会导致分离更少数量的客户作为目标人群。但有趣的事实是,随着“事件发生的概率”增加,“投资回报率”也增加,这意味着尽管我们针对的人口较少,但与针对更多人口相比,我们得到了良好的结果,这也可以在下图中看到。

不同事件发生预测概率的收入、成本和利润图表:

该图显示,随着“事件发生的概率”增加,成本、收入、利润等指标下降,而 ROI 增加。根据当时的需要,如“预算限制”、“高投资回报率”,可以选择特定的概率作为临界值,但也有必要确保使用测试数据可以复制相同的结果。

不同成本下的投资回报和利润图

从前面的结果可以看出,该图还显示成本类似于利润,投资回报率随着成本的增加而降低。这个图表可以用来回答经理提出的三个问题。

经理的三个问题

  • **实现最高投资回报率的成本是多少?**花费更少会带来更高的投资回报率,但与花费更多相比,相关的利润会更少
  • 实现最高利润的成本是多少?花费更多会带来更高的利润,但与花费更少相比,投资回报率会更低
  • 利润-投资回报率均衡点涉及的成本是多少?花费 11,300 美元将产生 25,300 美元的利润,该支出的投资回报率为 224,即削减 0.42。

我们还需要确保将截止概率取为 0.42 不会导致任何过拟合或欠拟合,并且测试数据的结果大致接近训练数据。

在上面的代码中,model_eval 是一个用户定义的函数,结果显示训练和测试结果的模型评估指标几乎相同。因此,0.42 可以被认为是临界值,并且所有估计概率高于 0.42 的客户可以被认为是目标人群。

谢谢你的阅读。如果你喜欢这篇文章,给它一些掌声👏。希望你有一个伟大的一天!

使用 Python 进行逻辑回归(scikit-learn)

原文:https://towardsdatascience.com/logistic-regression-using-python-sklearn-numpy-mnist-handwriting-recognition-matplotlib-a6b31e2b166a?source=collection_archive---------0-----------------------

Visualizing the Images and Labels in the MNIST Dataset

Python 的 scikit-learn 库最令人惊讶的一点是,它有一个 4 步建模模式,使编写机器学习分类器变得很容易。虽然本教程使用了一个称为逻辑回归的分类器,但本教程中的编码过程也适用于 sklearn 中的其他分类器(决策树、K-最近邻等)。在本教程中,我们使用逻辑回归来预测基于图像的数字标签。上图显示了一组来自 MNIST 数据集的训练数字(观察值),其类别成员是已知的(标签 0-9)。使用逻辑回归训练模型后,它可用于预测给定图像的图像标签(标签 0-9)。

Logistic Regression using Python Video

这篇教程文章的第一部分介绍了一个玩具数据集(digits dataset ),快速展示了 scikit-learn 的 4 步建模模式,并展示了逻辑回归算法的行为。本教程的第二部分介绍了一个更真实的数据集(MNIST 数据集),以简要说明更改模型的默认参数如何影响性能(包括模型的计时和精度)。就这样,让我们开始吧。如果你迷路了,我建议在一个单独的标签中打开上面的视频。本教程中使用的代码如下

数字逻辑回归(教程代码的第一部分)

MNIST 逻辑回归(教程代码的第二部分)

入门(先决条件)

如果您已经安装了 anaconda,请跳到下一节。我建议安装 anaconda(Python 2 或 3 对本教程来说都很好),这样在导入库时就不会有任何问题。

您可以从官方网站下载 anaconda 并自行安装,也可以按照下面的 anaconda 安装教程在您的操作系统上安装 anaconda。

在 Windows 上安装 Anaconda:链接

在 Mac 上安装 Anaconda:链接

在 Ubuntu 上安装 Anaconda(Linux):链接

数字数据集上的逻辑回归

加载数据(数字数据集)

digits 数据集是 scikit-learn 附带的数据集之一,不需要从外部网站下载任何文件。下面的代码将加载数字数据集。

from sklearn.datasets import load_digits
digits = load_digits()

现在您已经加载了数据集,您可以使用下面的命令

# Print to show there are 1797 images (8 by 8 images for a dimensionality of 64)
print(“Image Data Shape” , digits.data.shape)# Print to show there are 1797 labels (integers from 0–9)
print("Label Data Shape", digits.target.shape)

要查看数据集中有 1797 个图像和 1797 个标签

显示图像和标签(数字数据集)

这一部分实际上只是展示图像和标签的样子。可视化数据通常有助于了解您正在处理的内容。

import numpy as np 
import matplotlib.pyplot as pltplt.figure(figsize=(20,4))
for index, (image, label) in enumerate(zip(digits.data[0:5], digits.target[0:5])):
 plt.subplot(1, 5, index + 1)
 plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
 plt.title('Training: %i\n' % label, fontsize = 20)

Visualizing the Images and Labels in our Dataset

将数据分为训练集和测试集(数字数据集)

下面的代码执行训练测试分割,将 75%的数据放入训练集,25%的数据放入测试集。这是为了确保我们的分类算法能够很好地推广到新数据。

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

sci kit-学习 4 步建模模式(数字数据集)

第一步。导入您想要使用的模型

在 sklearn 中,所有的机器学习模型都是作为 Python 类实现的

from sklearn.linear_model import LogisticRegression

第二步。制作模型的一个实例

# all parameters not specified are set to their defaults
logisticRegr = LogisticRegression()

第三步。根据数据训练模型,存储从数据中学习到的信息

模型正在学习数字(x_train)和标签(y_train)之间的关系

logisticRegr.fit(x_train, y_train)

第四步。预测新数据(新图像)的标签

使用模型在模型训练过程中学习到的信息

# Returns a NumPy Array
# Predict for One Observation (image)
logisticRegr.predict(x_test[0].reshape(1,-1))

一次预测多个观察结果(图像)

logisticRegr.predict(x_test[0:10])

对整个测试数据进行预测

predictions = logisticRegr.predict(x_test)

衡量模型性能(数字数据集)

虽然有其他方法来衡量模型性能(精确度、召回率、F1 分数、 ROC 曲线等),但我们将保持简单,使用精确度作为我们的衡量标准。
要做到这一点,我们要看看模型在新数据(测试集)上的表现

精确度定义为:

(正确预测的分数):正确预测/数据点总数

# Use score method to get accuracy of model
score = logisticRegr.score(x_test, y_test)
print(score)

我们的准确率是 95.3%。

混淆矩阵(数字数据集)

混淆矩阵是一个表格,通常用于描述一个分类模型(或“分类器”)对一组真实值已知的测试数据的性能。在这一节中,我将展示两个 python 包(Seaborn 和 Matplotlib ),它们使混淆矩阵更容易理解,在视觉上更有吸引力。

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import metrics

下面的混淆矩阵在视觉上并不丰富,也不吸引人。

cm = metrics.confusion_matrix(y_test, predictions)
print(cm)

Not a visually appealing way to view a confusion matrix

方法 1(海上分娩)

正如你在下面看到的,这个方法使用 seaborn 产生了一个更容易理解和视觉可读的混淆矩阵。

plt.figure(figsize=(9,9))
sns.heatmap(cm, annot=True, fmt=".3f", linewidths=.5, square = True, cmap = 'Blues_r');
plt.ylabel('Actual label');
plt.xlabel('Predicted label');
all_sample_title = 'Accuracy Score: {0}'.format(score)
plt.title(all_sample_title, size = 15);

Confusion Matrix using Seaborn

方法 2 (Matplotlib)
这个方法显然多了很多代码。我只是想向人们展示如何在 matplotlib 中也这样做。

plt.figure(figsize=(9,9))
plt.imshow(cm, interpolation='nearest', cmap='Pastel1')
plt.title('Confusion matrix', size = 15)
plt.colorbar()
tick_marks = np.arange(10)
plt.xticks(tick_marks, ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], rotation=45, size = 10)
plt.yticks(tick_marks, ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], size = 10)
plt.tight_layout()
plt.ylabel('Actual label', size = 15)
plt.xlabel('Predicted label', size = 15)
width, height = cm.shapefor x in xrange(width):
 for y in xrange(height):
  plt.annotate(str(cm[x][y]), xy=(y, x), 
  horizontalalignment='center',
  verticalalignment='center')

Confusion Matrix using Matplotlib

逻辑回归(MNIST)

需要强调的一点是,sklearn 中包含的数字数据集太小,不能代表真实世界的机器学习任务。
我们将使用 MNIST 数据集,因为它是为那些希望在真实世界数据上尝试学习技术和模式识别方法,同时在预处理和格式化方面花费最少精力的人准备的。我们将注意到的一件事是,参数调整可以大大加快机器学习算法的训练时间。

下载数据(MNIST)

MNIST 数据集并非来自 scikit-learn 内部

from sklearn.datasets import fetch_mldata
mnist = fetch_mldata('MNIST original')

现在您已经加载了数据集,您可以使用下面的命令

# These are the images
# There are 70,000 images (28 by 28 images for a dimensionality of 784)
print(mnist.data.shape)# These are the labels
print(mnist.target.shape)

要查看数据集中有 70000 张图像和 70000 个标签

将数据分成训练集和测试集(MNIST)

下面的代码执行了一次列车测试分割test_size=1/7.0使训练集大小为 60,000 幅图像,测试集大小为 10,000 幅图像。

from sklearn.model_selection import train_test_splittrain_img, test_img, train_lbl, test_lbl = train_test_split(
 mnist.data, mnist.target, test_size=1/7.0, random_state=0)

显示图像和标签(MNIST)

import numpy as np
import matplotlib.pyplot as pltplt.figure(figsize=(20,4))
for index, (image, label) in enumerate(zip(train_img[0:5], train_lbl[0:5])):
 plt.subplot(1, 5, index + 1)
 plt.imshow(np.reshape(image, (28,28)), cmap=plt.cm.gray)
 plt.title('Training: %i\n' % label, fontsize = 20)

Visualizing the Images and Labels in our Dataset

sci kit-学习 4 步建模模式(MNIST)

我想提到的一点是参数调整的重要性。虽然对于较小的数字数据集来说,这可能没什么关系,但对于较大和更复杂的数据集来说,这就有很大的不同了。虽然通常是为了精确而调整参数,但在下面的例子中,我们调整了参数求解器以加速模型的拟合。

第一步。导入您想要使用的模型

在 sklearn 中,所有的机器学习模型都是作为 Python 类实现的

from sklearn.linear_model import LogisticRegression

第二步。制作模型的一个实例

如果你想知道变化求解器是做什么的,请看这个教程。本质上,我们正在改变优化算法。

# all parameters not specified are set to their defaults
# default solver is incredibly slow thats why we change it
logisticRegr = LogisticRegression(solver = 'lbfgs')

第三步。根据数据训练模型,存储从数据中学习到的信息

模型正在学习 x(数字)和 y(标签)之间的关系

logisticRegr.fit(train_img, train_lbl)

第四步。预测新数据(新图像)的标签
使用模型在模型训练过程中学习到的信息

# Returns a NumPy Array
# Predict for One Observation (image)
logisticRegr.predict(test_img[0].reshape(1,-1))

一次预测多个观察结果(图像)

logisticRegr.predict(test_img[0:10])

对整个测试数据进行预测

predictions = logisticRegr.predict(test_img)

衡量模型性能(MNIST)

虽然有其他方法来衡量模型性能(精确度、召回率、F1 分数、 ROC 曲线等),但我们将保持简单,使用精确度作为我们的衡量标准。
为此,我们将观察模型在新数据(测试集)上的表现

精确度定义为:

(正确预测的分数):正确预测/数据点总数

score = logisticRegr.score(test_img, test_lbl)
print(score)

我想简单提一下的一件事是,默认的优化算法参数是solver = liblinear,它花了 2893.1 秒运行,准确率为 91.45%。我设置solver = lbfgs的时候,用了 52.86 秒运行,准确率 91.3%。改变求解器对精确度有一个小的影响,但至少它快了很多。

Depending on the problem, some optimization algorithms can take longer (image source)

显示带有预测标签的错误分类图像(MNIST)

虽然我可以展示另一个混淆矩阵,但我认为人们宁愿看到错误分类的图片,也不希望有人觉得有趣。

获取错误分类图像的索引

import numpy as np 
import matplotlib.pyplot as pltindex = 0
misclassifiedIndexes = []
for label, predict in zip(test_lbl, predictions):
 if label != predict: 
  misclassifiedIndexes.append(index)
  index +=1

使用 matplotlib 显示错误分类的图像和图像标签

plt.figure(figsize=(20,4))
for plotIndex, badIndex in enumerate(misclassifiedIndexes[0:5]):
 plt.subplot(1, 5, plotIndex + 1)
 plt.imshow(np.reshape(test_img[badIndex], (28,28)), cmap=plt.cm.gray)
 plt.title(‘Predicted: {}, Actual: {}’.format(predictions[badIndex], test_lbl[badIndex]), fontsize = 15)

Showing Misclassified Digits

结束语

这里需要注意的重要一点是,在 scikit-learn 中制作一个机器学习模型并不需要很多工作。我希望这篇文章对你正在做的事情有所帮助。我的下一个机器学习教程使用 Python 复习了 PCA。如果你对本教程有任何问题或想法,欢迎在下面的评论中,通过 YouTube 视频页面,或通过 Twitter 联系我们!如果想学习其他机器学习算法,请考虑上我的机器学习 with Scikit-Learn LinkedIn 学习课程

逻辑回归的“Logit ”;了解基本原理

原文:https://towardsdatascience.com/logit-of-logistic-regression-understanding-the-fundamentals-f384152a33d1?source=collection_archive---------1-----------------------

在我学习机器学习基础的旅程的最开始,我记得花了很多时间来清楚地理解逻辑回归的基础。希望这个冥想会给你留下更多的答案和正确的概念,而不是与逻辑回归相关的困惑。

在这篇文章中,我将尝试涵盖—

  • 赔率和赔率比
  • 理解逻辑回归,从线性回归开始。
  • 逻辑函数作为分类器;用伯努利分布连接 Logit。
  • 关于癌症数据集和设置概率阈值以对恶性和良性进行分类的示例。

优势和优势比

在我们深入研究逻辑回归之前,我们需要弄清楚一些概率的基础知识。为简单起见,我们将考虑一个数据集,它告诉我们,客户是否会购买产品取决于性别。我们导入并检查数据集

import pandas as pdgender_df = pd.read_csv('gender_purchase.csv')print gender_df.head(3)>>> Gender Purchase
0  Female      Yes
1  Female      Yes
2  Female       No

我们将使用pandascrosstab功能,根据性别创建一个“是”和“否”的频率表。这张表对理解以后的优势和优势比有很大的用处。

table = pd.crosstab(gender_df['Gender'], gender_df['Purchase'])
print table>>> Purchase   No  Yes
Gender            
Female    106  159
Male      125  121

我们现在准备定义几率、 几率,它描述了成功与失败的比率。考虑到女性群体,我们看到女性购买(成功)产品的概率= 159/265(是/女性总数)。女性失败(不购买)的概率为 106/265。在这种情况下,赔率定义为(159/265)/(106/265) = 1.5。可能性越大,成功的机会就越大。赔率范围可以是【0,∞】*之间的任意数字。*如果我们对这些数字取自然对数,范围会发生什么变化?log(x)定义为 x≥0,但范围从[-∞,∞]变化。您可以使用一段代码进行检查

random=[]
xlist = []
for i in range(100):
 x = uniform(0,10)# choose numbers between 0 and 10 
 xlist.append(x)
 random.append(math.log(x))plt.scatter(xlist, random, c='purple',alpha=0.3,label=r'$log x$')
plt.ylabel(r'$log \, x$', fontsize=17)
plt.xlabel(r'$x$',fontsize=17)
plt.legend(fontsize=16)
plt.show()

Figure 1: log x vs x; for all +’ve’ values of x, log x can vary between -∞ to + ∞.

到目前为止,我们已经理解了概率。我们来描述一下赔率,顾名思义就是赔率的比值。考虑到上面的例子,比值比,代表哪一组(男性/女性)有更好的成功几率,它是通过计算每一组的比值比给出的。所以女性成功购买的几率=女性成功购买的几率/男性成功购买的几率= (159/106)/(121/125)。男性的优势比是上述数字的倒数。

我们可以清楚地认识到,虽然比值比可以在 0 到正无穷大之间变化,但 log(比值比)将在[-∞,∞]之间变化。特别是当比值比位于[0,1]之间时,log(比值比)为负。

线性到逻辑回归

由于“回归”一词在逻辑回归中容易引起混淆,我们可以花几秒钟来回顾一下回归。回归通常指连续性,即预测连续变量(药品价格、出租车费等。)取决于特性。然而,逻辑回归是关于预测二元变量,即当目标变量是分类变量时。 *逻辑回归可能是一个初露头角的数据科学家应该尝试掌握分类问题的第一件事。*我们将从线性回归模型开始,逐步理解实现 logistic 模型。

在线性回归中,特征变量可以取任何值,因此输出(标签)可以从负到正无穷大连续。

Range of label and feature in linear regression case

因为逻辑回归是关于分类的,即 Y 是分类变量。很明显,用线性回归模型(方程式)不可能获得这样的输出。1.1),因为两侧量程不匹配。我们的目标是以这样的方式变换 LHS,使得它匹配 RHS 的范围,RHS 的范围由特征变量的范围[-∞,∞]来控制。

我们将遵循一些直观的步骤来探索如何可能达到这样的结果。

  • 对于线性回归, XY 的范围都是从负无穷大到正无穷大。逻辑中的 Y 是绝对的,或者对于上面的问题,它取两个不同值 0,1 中的一个。首先,我们尝试使用回归模型预测概率。现在 LHS 可以取从 0 到 1 的任何值,而不是两个不同的值,但是范围仍然不同于 RHS。

  • 我上面讨论过,赔率和赔率比从[0,∞]不等。这比概率(限制在 0 和 1 之间)更好,并且更接近匹配 RHS 的范围。
  • 你们中的许多人已经明白,如果我们现在考虑(等式)的 LHS 的自然对数。1.3)那么两侧的范围匹配。

这样,我们实现了一个回归模型,其中输出是概率的自然对数,也称为 logit 。对数的底数并不重要,但取赔率的对数才重要。

我们可以从 eq 中检索成功的概率。1.4 如下。

From odds to probability where probability distribution resembles a sigmoid function

如果我们知道自变量的系数 X s 和截距 a,我们就可以预测概率。我们将使用软件(sklearn)进行优化。根据问题,我们可以从概率值中选择输出属于 A 类还是 b 类。当我们通过一个示例时,这将更加清楚。

逻辑函数

如果你看到等式 1.5 的 RHS。也称为逻辑函数,与 sigmoid 函数非常相似。我们可以用一小段 python 代码来检查这个函数的行为。

random1=[]
random2=[]random3=[]xlist = []
theta=[10, 1,0.1]
for i in range(100):
 x = uniform(-5,5)
 xlist.append(x)
 logreg1 = 1/(1+math.exp(-(theta[0]*x)))
 logreg2 = 1/(1+math.exp(-(theta[1]*x)))
 logreg3 = 1/(1+math.exp(-(theta[2]*x)))
 random1.append(logreg1)
 random2.append(logreg2)
 random3.append(logreg3)plt.scatter(xlist, random1, marker='*',s=40, c='orange',alpha=0.5,label=r'$\theta = %3.1f$'%(theta[0]))
plt.scatter(xlist, random2, c='magenta',alpha=0.3,label=r'$\theta = %3.1f$'%(theta[1]))
plt.scatter(xlist, random3, c='navy',marker='d', alpha=0.3,label=r'$\theta = %3.1f$'%(theta[2]))plt.axhline(y=0.5, label='P=0.5')
plt.ylabel(r'$P=\frac{1}{1+e^{-\theta \, x}}$', fontsize=19)
plt.xlabel(r'$x$',fontsize=18)
plt.legend(fontsize=16)
plt.show()

Figure 2: Probability vs independent variable x; resembles sigmoid function plot.

从上面的图中,注意自变量(这里是 X )的系数(橙色星星)值越高,它就能更好地表示两个不同的概率 0 和 1。对于较低的系数值,它基本上是一条直线,类似于一个简单的线性回归函数。对比等式(1.5),图 2 中固定项 a 取为 0。固定项对逻辑函数的影响也可以通过下图来理解

Figure 3: Sigmoid function for different values of intercept (a).

就像线性回归中的常数项表示 Y 轴上的截距(因此沿 Y 轴移动),这里对于逻辑函数,常数项沿 X 轴移动 s 曲线。上面的数字(图 2,3)应该让你相信,使用可以分类数据的逻辑回归来优化模型确实是可能的,例如预测 0 或 1。

伯努利和罗吉特

逻辑回归的目的是针对独立变量(特征)的任何给定线性组合,预测成功事件的某个未知概率 P 。那么如题所示,logit 和 Bernoulli 函数是如何联系的呢?回想一下二项式分布,它是在 N 次试验中有 n 次成功的概率分布,假设

Binomial distribution

每个试验以概率 P 为真,以概率 Q=1-P 为假。伯努利分布另一方面是一个离散分布,有两种可能的结果,标记为 n=0n=1 ,其中 n=1 (成功事件)以概率 P 发生,而失败即 n=0 以概率发生

Bernoulli distribution as a special case of binomial distribution

可以理解的是,伯努利分布是单次试验的二项分布的特例(等式 1.6 中 N=1 )。**最重要的是,我们看到逻辑回归中的因变量遵循具有未知概率 p 的伯努利分布。因此,logit,即几率的对数,将自变量( Xs )与伯努利分布联系起来。**在 logit 情况下,P 是未知的,但是在伯努利分布(eq。1.6)我们知道。让我们画出 logit 函数。

Figure 4: Logit Function i.e. Natural logarithm of odds

我们看到函数的定义域位于 0 和 1 之间,函数的范围从负到正无穷大。我们需要逻辑回归的 y 轴上的概率 P ,这可以通过取 logit 函数的反函数来实现。如果你以前注意过 sigmoid 函数曲线(图 2 和图 3),你可能已经找到了联系。的确, sigmoid 函数是 logit 的逆(检查等式。1.5).

癌症数据集和概率阈值的例子

不再拖延,让我们看看逻辑回归在癌症数据集上的应用。这里我们将集中讨论如何设置概率阈值来对我们的模型进行分类。为了简单起见,我将使用数据集的所有特征,但你可以阅读关于使用RFE 方法选择最佳特征的详细信息,我已经在单独的帖子中描述了该方法。

from sklearn.datasets import load_breast_cancercancer = load_breast_cancer()
cancer_df=pd.DataFrame(cancer.data,columns=cancer.feature_names)X_trainc, X_testc, y_trainc, y_testc = train_test_split(cancer.data, cancer.target, test_size=0.3, stratify=cancer.target, random_state=30)cancerclf = LogisticRegression()
cancerclf.fit(X_trainc, y_trainc)#print "Logreg score on cancer data set", cancerclf.score(X_testc, y_testc) # you can check the score if you want, which is not the main purpose. 

我们将使用predict_proba方法进行逻辑回归,引用 scikit-learn 的话“返回按类别标签排序的所有类别的概率估计值”。我们在测试数据集上调用这个方法。

probac = cancerclf.predict_proba(X_testc)print probac[1:10] >>> [[5.86216203e-02 9.41378380e-01]
 [7.25210884e-03 9.92747891e-01]
 [9.99938102e-01 6.18983128e-05]
 [4.75502091e-02 9.52449791e-01]
 [9.66861480e-01 3.31385203e-02]
 [3.09660805e-01 6.90339195e-01]
 [9.99687981e-01 3.12018784e-04]
 [6.80759215e-04 9.99319241e-01]
 [9.99998223e-01 1.77682663e-06]]

由于我们的目标要么是 0,要么是 1,那么打印predict_proba 会给我们维数为(N,2)的概率矩阵,N 是实例的数量。第一个指标指的是数据属于类 0 的概率,第二个指标指的是数据属于类 1 的概率。默认情况下,如果该概率大于 0.5,则该预测被归类为正面结果。对于每一行,两列相加应该等于 1,因为成功的概率 (P) 和失败的概率 (1-P) 应该等于 1。

我们现在可以转向predict方法,它预测类别标签,在默认情况下,对于二元分类,它将小于 0.5 的概率归类为 0,反之亦然。

predict = cancerclf.predict(X_testc)print predict >>> [1 1 1 0 1 0 1 0 1 0 1 1 1 1 .....]# didn't show the complete list

现在我们考虑probac=cancerclf.predict_proba(X_testc)数组的第一列,它由 0 类概率组成(在癌症数据集中,这是恶性类)。我们用这个数组做了一个迷你数据框。

probability = probac[:,0]
prob_df = pd.DataFrame(probability)
print prob_df.head(10) # this should match the probac 1st column >>>    0
0  0.005366
1  0.058622
2  0.007252
3  0.999938
4  0.047550
5  0.966861
6  0.309661
7  0.999688
8  0.000681
9  0.999998

我们进一步修改这个数据帧,以理解改变阈值的影响。

prob_df['predict'] = np.where(prob_df[0]>=0.90, 1, 0)# create a new column
print prob_df.head(10)>>>    0        predict
0  0.005366        0
1  0.058622        0
2  0.007252        0
3  0.999938        1
4  0.047550        0
5  **0.966861        1**
6  0.309661        0
7  0.999688        1
8  0.000681        0
9  0.999998        1

我们设定≥ 90%作为恶性分类选择的阈值。在打印出的示例中,我们看到值为 0.96,因此将阈值更改为 97%会将该样本从恶性类别中排除。

prob_df['predict'] = np.where(prob_df[0]>=0.97, 1, 0)
print prob_df.head(10)>>>    0       predict
0  0.005366        0
1  0.058622        0
2  0.007252        0
3  0.999938        1
4  0.047550        0
5  **0.966861        0 # here is the change**
6  0.309661        0
7  0.999688        1
8  0.000681        0
9  0.999998        1

还可以检查对测试样本总数的影响

prob_df['predict'] = np.where(prob_df[0]>=0.50 1, 0)
print len(prob_df[prob_df['predict']==1])>>> 56prob_df['predict'] = np.where(prob_df[0]>=0.97 1, 0)
print len(prob_df[prob_df['predict']==1])>>> 45

我们已经看到如何改变概率阈值来选择或拒绝来自特定类别的样本。

逻辑回归默认使用 L2 正则化,可以检查改变正则化参数的结果,并与线性回归进行比较。我之前和岭回归讨论过这个问题,感兴趣的可以去看看。使用RFE选择最佳参数是逻辑回归的一个重要部分,因为最好有很少或没有多重共线性,这是确保选择少量可以描述模型的相关参数的方法之一。

总而言之,我们已经学习了一些关于开发可用于分类的回归模型的基本思想

我推荐你去看看吴恩达的课堂笔记或者 YouTube 上的讲座。本帖的基本思想受到了 Kumar,a .的《用 Python 学习预测分析》一书的影响,该书明确描述了线性和逻辑回归的联系。将伯努利函数和 logit 函数之间的联系联系起来是受 B. Larget (UoW,麦迪森)的演示幻灯片的启发,该幻灯片可公开获得。

保持坚强,干杯!

如果你对更深入的基础机器学习概念感兴趣,可以考虑加盟 Medium 使用 我的链接 。你不用额外付钱,但我会得到一点佣金。感谢大家!!

使用 SSD 的图像中的徽标检测

原文:https://towardsdatascience.com/logo-detection-in-images-using-ssd-bcd3732e1776?source=collection_archive---------2-----------------------

徽标有时也称为商标,在当今的营销世界中非常重要。产品、公司和不同的游戏联盟通常由它们各自的标志来识别。图像和视频中的徽标识别是许多应用中的关键问题,例如版权侵权检测、智能交通控制系统的车辆徽标、增强现实、上下文广告投放等。在本帖中,我们将探讨如何使用 Tensorflow API 的 SSD 来检测和定位电视节目(Big Boss India)图像中的品牌徽标。任务是从展会的图像中检测和定位六个品牌标志: fizz,oppo,samsung,garnier,faber,cpplus

什么是固态硬盘,它是如何工作的?

根据关于 SSD 的论文,SSD: Single Shot Multibox Detector 是一种使用单一深度神经网络检测图像中对象的方法。SSD 将边界框的输出空间离散化为一组默认框,每个要素地图位置具有不同的纵横比和比例。在预测时,网络为每个默认框中每个对象类别的存在生成分数,并对框进行调整以更好地匹配对象形状。此外,该网络结合了来自不同分辨率的多个特征地图的预测,以自然地处理各种尺寸的物体。在 PASCAL VOC、COCO 和 ILSVRC 数据集上的实验结果证实,SSD 具有与利用额外的对象提议步骤的方法竞争的准确性,并且速度快得多,同时为训练和推理提供了统一的框架。

目标检测、定位和分类的任务在网络的单次前向传递中完成。

Multi box concept in SSD(Source: Udemy A-Z Computer Vision)

固态硬盘的架构

标志检测数据集

这项任务的数据是通过从节目的视频剪辑中捕捉单个帧获得的。总共拍摄了 6267 张图像。我用了 600 张图片进行测试,剩下的用于训练部分。
现在,下一步是注释获得的图像。为此,我使用了 LabelImg 。LabelImg 是一个图形化的图像注释工具。生成的注释以 PASCAL VOC 格式保存为 XML 文件。存储库中提供了安装说明。

Annotating Image using labelImg

类似地,我必须浏览数据集的所有图像,并逐个注释它们。

TFRecords

如果我们正在处理大型数据集,使用二进制文件格式存储数据会对导入管道的性能产生重大影响,从而缩短模型的训练时间。二进制数据占用的磁盘空间更少,复制时间更短,从磁盘读取的效率也更高。这就是 TFRecord 出现的地方。然而,纯粹的性能并不是 TFRecord 文件格式的唯一优势。它通过多种方式针对 Tensorflow 的使用进行了优化。首先,它可以轻松地组合多个数据集,并与库提供的数据导入和预处理功能无缝集成。特别是对于太大而无法完全存储在内存中的数据集,这是一个优势,因为只有当时需要的数据(例如一批)才会从磁盘加载,然后进行处理。因为我们将使用 Tensorflow API,所以我们将把 XML 文件转换成 TFRecords。

将 XML 转换为 TFRecord

为了将 XML 文件转换成 TFRecord,我们将首先使用 python 脚本将它们转换成 CSV,这要感谢这个。需要引入一些小的变化。下面是将 XML 文件转换成 CSV 文件的代码。

存储在**‘图像/训练’‘图像/测试’**中的 XML 文件被转换成两个 CSV 文件,一个用于训练,一个用于测试,它们在文件夹【T8’‘数据’中生成。(如果您想要在自定义数据集上训练 SSD 模型,请注意这些细节)

一旦 XML 文件被转换成 CSV 文件,我们就可以使用 python 脚本从同一个存储库中输出 TFRecords,并做一些修改。

对于自定义数据集的训练,请在 class_text_to_int 函数中更改类名。此外,确保您按照这里的中的安装说明来安装依赖项,以运行上面的代码。同样克隆 tensorflow 存储库。以后会有帮助的。

一旦完成安装,我们就可以使用上面的代码片段生成 tfrecords 了。在您的终端中键入这个命令,为训练数据生成 tfrecord。

python generate_tfrecord.py — csv_input=data/train_labels.csv — output_path=data/train.record

啊终于来了!!我们有我们的 train.record。同样地,对测试数据也这样做。

python generate_tfrecord.py — csv_input=data/test_labels.csv — output_path=data/test.record

训练品牌标识检测器

为了获得我们的品牌徽标检测器,我们可以使用预先训练的模型,然后使用迁移学习来学习新对象,或者我们可以完全从头开始学习新对象。迁移学习的好处是训练可以快得多,你可能需要的数据也少得多。出于这个原因,我们将在这里进行迁移学习。TensorFlow 有相当多的预训练模型,带有可用的检查点文件和配置文件。

对于这个任务,我使用了 Inception 。你可以使用其他型号。你可以从这里获得模型列表及其下载链接。点击此处,获取相应型号的配置文件。现在,我们已经完成了模型和配置文件的下载,我们需要根据数据集编辑配置文件。

在您的配置文件中搜索“ PATH_TO_BE_CONFIGURED ,并将其更改为类似于上面代码片段中所示的内容。此外,更改配置文件中的类的数量。

在我们开始训练之前,还有最后一件事要做,就是创建标签图。标签映射基本上是一个字典,包含我们想要检测的类的 id 和名称。

detection.pbtxt

就是这样。就是这样。我们现在可以开始训练了。啊终于来了!
将您的所有数据复制到系统上克隆的 tensorflow 存储库(如果您之前没有,请克隆它)。并从'**models/object _ detection '**中在您的终端中键入此命令。

python3 train.py --logtostderr --train_dir=training/ --pipeline_config_path=training/ssd_inception_v2_coco_2017_11_17.config

可以等到总损失达到 1 左右。

测试品牌标志检测器

为了测试我们的模型做得有多好,我们需要导出推理图。在'models/object _ detection'目录中,有一个脚本为我们完成了这项工作:'export _ inference _ graph . py'
要运行它,您只需要传入您的检查点和您的管道配置。你的检查点文件应该在' training '目录下。只要找一个步长最大的(破折号后最大的数字),那就是你要用的。接下来,确保将 pipeline_config_path 设置为您选择的任何配置文件,然后最后选择输出目录的名称。例如:

python3 export_inference_graph.py \
    --input_type image_tensor \
    --pipeline_config_path training/ssd_inception_v2_coco_2017_11_17.config \
    --trained_checkpoint_prefix training/model.ckpt-7051 \
    --output_directory logos_inference_graph

一旦成功运行,您应该有一个名为' logos_inference_graph '的新目录。在此之后,打开'object _ detection _ tutorial . ipynb,将' MODEL_NAME 更改为' logos_inference_graph ,并更改变量部分中的类的数量。接下来,我们可以删除笔记本中的整个下载模型部分,因为我们不再需要下载我们的模型。在' Test_Images_Path '中,您可以输入存储测试图像的目录。

结果

以下是我的一些结果:

Samsung logo detected

Fizz logo detected

Cpplus logo detected

总结

为了检测图像中的徽标,我遵循了以下步骤:

  1. 获取数据集
  2. 使用 LabelImg 创建 XML 文件
  3. 将 XML 文件转换为 TFRecords
  4. 下载模型并编辑相应的配置文件
  5. 创建标注地图
  6. 开始训练

参考文献

  1. https://arxiv.org/pdf/1512.02325.pdf
  2. https://github.com/tensorflow/tensorflow
  3. https://python programming . net/introduction-use-tensor flow-object-detection-API-tutorial/
  4. https://github.com/tzutalin/labelImg
  5. https://github.com/datitran/raccoon_dataset
  6. https://medium . com/mosely-ai/tensor flow-records-what-them-and-how-to-use-them-c 46 BC 4 BBB 564
  7. https://towards data science . com/understanding-SSD-multi box-real-time-object-detection-in-deep-learning-495 ef 744 fab

如果你喜欢,请随意评论你的观点并鼓掌。

2018 伦敦设计节(第二部分):自然语言处理

原文:https://towardsdatascience.com/london-design-festival-2018-part-2-natural-language-processing-595f3c2dc24f?source=collection_archive---------16-----------------------

第二部分:11,000 条推文的自然语言处理

介绍

在本系列的第 1 部分中,我对 2018 年伦敦设计节的 11,000 条推文进行了探索性的数据分析,这是一个为期七天的设计节,发生在 2018 年 9 月 15 日周六至 23 日周日之间。

伦敦设计节 2018 (LDF18)有一个非常活跃的活动计划,横跨伦敦 11 个不同的“设计区”、5 个“设计目的地”和 3 条“设计路线”。这是伦敦作为一个建筑环境的灵活性的另一个极好的例子,作为一个画布来展示创造性的想法。

本文的目的是介绍我的自然语言处理分析对这 11,000 条推文的研究结果,以了解情绪以及人们对 LDF18 的看法。

请向下滚动,通过交互式数据可视化查看我的分析!

Image by Ben Terrett on Flickr

数据和方法

这一事件的官方标签是#LDF18。在通过 Twitter API 在事件发生时收集了 11000 条包含这个标签的推文之后,我首先在 Python 笔记本中预处理和清理了文本数据。

然后,我使用谷歌的 langdetect 库 过滤掉非英语推文,并从 NLP 分析中删除所有转发,这样就不会出现重复。经过这些步骤,我剩下了 5700 条独特的推文。接下来,我使用谷歌云自然语言 API 来获取每条推文的情感。

最后,我使用 gensim 库的 Word2Vec 模型来获取整个 tweets 语料库中与单词“LDF18”相关的每个单词的单词嵌入向量。Word2Vec 用于从大型文本语料库中计算单词之间的相似度— Kavita Ganesan文章是一个很好的解释。

一旦我有了每个单词的向量,我就使用 scikitlearn 库来执行主成分分析(PCA)以进行降维,并绘制出与“LDF18”最相似的单词(最近邻)。

你可以在这里查看我的 Kaggle 内核对这篇文章的所有分析。

分析推文

在这一节中,我将展示我的自然语言处理(NLP)分析的发现。下面,我报告以下三个指标:

  1. 每日推文的情感分析;
  2. 词频和标签频率分析;
  3. Word2Vec 模型的输出:主成分分析(PCA)和最近邻分析。

Alphabet by Kellenberger White Photography by @leemawdsley 3— Taken from Flickr

情感分析

每条推文的情绪是使用谷歌的云 NLP API 计算的。下面的条形图显示了每天推文的平均情绪,其中-1 表示非常消极的情绪,+1 表示非常积极的情绪。

我们看到,LDF18 开始时的平均情绪相对较低,随着时间的推移逐渐上升。9 月 18 日星期二,也就是奖牌获得者晚宴后的第二天,出现了 0.53 的峰值——人们显然对此很高兴!

Figure 1: Line chart showing the average sentiment of the tweets per day

下表显示了按情感分类的前五条(绿色)和后五条(红色)推文。你可以通过左边的推文清楚地看到,积极的语言被云 NLP API 检测到,类似地,负面的推文在右边。

许多积极的推文是关于设计奖的奖牌获得者,还有那周举行的晚宴…小吃很棒,我会让你知道的!

LDF18 上展示的一些装置是关于塑料垃圾和气候变化的,不幸的是,NLP API 将提到这些装置的推文归类为“负面”;这凸显了情绪分析 API 的一些问题。

Table 1: Tabel showing the top five (left) and bottom five (right) tweets by sentiment score

文本频率分析

下面的条形图显示了一个词出现的次数,还有一个标签出现在所有推文中,分别在左边和右边。不出所料,“ldf18”出现的次数最多。

然而,这些结果在告诉我们人们对该事件的看法方面并不十分有用,因为标签的频率显然是单词频率的一个混淆变量。在未来的分析中,我将从文本频率分析中删除 hashtag 单词。

Figure 2: Bar graphs showing the count of words and hashtags appearing in all the tweets

最近的邻居

Word2Vec 是神经语言机器学习模型。它将大量文本(在本例中,来自 11,000 条推文的文本)作为输入,并产生一个向量空间,通常有数百个维度,每个唯一的单词对应于空间中的一个向量——单词嵌入。然后使用主成分分析将 Word2Vec 空间的维度降低到 xy 坐标。

重要的是,Word2Vec 用于从 11,000 条推文中捕捉单词之间的相似性和关系。具体来说,空间中距离较近的对象意味着它们是相似的。“最近邻”是来自 Word2Vec 模型的少数几个基于余弦度量相似性得分与“LDF18”最相似的单词。

Figure 3: PCA output of the nearest neighbours of #LumiereLDN from the Word2Vec model

散点图显示了“LDF18”的最近邻。我们看到诸如“建筑”、“工艺”、“纺织品”和“设计”等名词是密切相关的。

但重要的是,形容词“漂亮”、“创新”、“灵感”也是密切相关的。一个非常积极的结果!统计表明,这些词最能代表人们在推特上谈论 LDF18 时的感受。

Waugh Thistleton Architects: MultiPly —Taken from Flickr — All rights reserved by the London Design Festival

结论

所以你有它!我在 11,000 条关于 2018 年伦敦设计节的推文中展示了我的 NLP 的调查结果。Word2Vec 模型的输出显示,人们对该事件持积极态度。

如果你有任何想法或建议,请在下面或在我的 Kaggle 内核上留下评论——如果能给 Kaggle 投票,我将不胜感激:)

有这么多的 NLP 库,我很可能会在未来使用 GloVeTensorflowBert 重新审视这个分析。

下次…

在我的下一篇文章(第 3 部分)中,我将展示我的计算机视觉分析的发现。期待看到哪些艺术品出现的次数最多。敬请关注。

感谢阅读!

Vishal

在你离开之前…

如果你觉得这篇文章有帮助或有趣,请在 Twitter、脸书或 LinkedIn 上分享这篇文章,这样每个人都能从中受益。

Vishal 是一名文化数据科学家,也是伦敦 UCL 学院的研究生。他对城市文化的经济和社会影响感兴趣。你可以在Twitter或者LinkedIn上与他取得联系。在insta gram或他的 网站 上看到更多 Vishal 的作品。

基于 GARCH 模型的长期资产配置策略——R

原文:https://towardsdatascience.com/long-term-asset-allocation-strategies-based-on-garch-models-a-simulation-exercise-in-r-24e5b71b1d0b?source=collection_archive---------6-----------------------

在这篇文章中,我想分享我在量化金融领域做的一个模拟练习的结果。我所遵循的方法是基于金融模型的(因此,一些定量金融知识肯定会使它更容易理解),但是,对于专注于数据科学的人来说,这篇文章可能会很有趣,因为我展示了一个如何使用并行蒙特卡罗模拟来预测股票价格的示例。

在这个练习中,我建立了一个基于资产价格预测的简化资产配置策略。为了预测资产价格,我使用了条件波动率模型,其中的自回归成分决定了回报过程的条件均值部分。

我只在媒体上发布一个缩略版本。我强烈推荐阅读我在 GitHub 上分享的更详细的“论文”(以及参考资料)。

1.方法学

数据生成过程

在量化金融中,处理资产回报是很常见的,可以定义为

其中 P 代表资产价格, t 是时间指数。以下等式表示实验中的数据生成过程:

随着

条件均值方程(第一个方程)由具有一阶滞后的自回归过程控制,条件方差方程是 Glosten、Jagannathan 和 Runkle (1993)的 GJR-GARCH 模型。它是 Bollerslev(1986 年)著名的 GARCH (广义自回归条件异方差 ) 模型的扩展,具有考虑正负创新对方差影响不同的情况的额外优势。换句话说,参数 alpha 衡量积极创新的效果,而 alpha + gamma 用于消极创新的情况。GARCH 模型是通过将 GJR-GARCH 的 gamma 设置为 0 得到的。

数据生成过程基于奥尔巴克(2013)提供的规范。然而,这个实验使用他的规范集中于股票收益的点预测和相关的方差,而没有建模更高的矩(偏度和峰度)。

在此分析中,GARCH 和 GJR-GARCH 模型均被考虑在内,并考虑了新息的以下分布( z_t ):正态分布(N)、偏态分布(SN)、 t (T)、偏态分布- t (ST)、广义误差分布(GED)及其偏态分布(SGED)。

此外,我采用了三种评估方法:固定、滚动和扩展窗口方法。对于固定模型,我在估计样本上估计 GARCH 模型,并在整个样本外预测中使用相同的参数集。在滚动方法中,我滚动长度等于整个估计样本的窗口,一次一个周期,而在扩展窗口方法中,我简单地扩展估计样本。

总之,固定窗口方法总是使用相同的数据集,滚动窗口使用相同数量但来自不同时段的数据,而扩展窗口使用最大量的数据。因此,我调查了 GARCH 模型类型、新息分布和估计变量的总共 36 种组合。

模拟样本路径

我通过模拟选定股票收益的长度为 K 周期的 N 条样本路径来解决长期资产配置问题。我遵循插入式方法,,即,我是在分布参数已知的假设下操作的。为了获得这些(以及初始化模拟所需的时间 T_0 新息和条件方差等变量),我使用 MLE 估计所有规格的选定 GARCH 模型,并实施估计的参数以从选定的分布中生成随机新息。更准确地说,我生成了 N * K 随机新息,其中范围 K 从 1 到 52,取决于模拟的时间点。

动态资产分配问题

在这个实验中,我只选择了一个股票指数,并以 1%的网格步长将权重限制在 0%到 100%之间,这是由于使用数值方法时的维数灾难。随着当今计算能力和云解决方案的快速增长,将其扩展到多资产框架应该不成问题。然而,我会关注研究论文,目前只关注单一风险资产。

因为建模无风险利率不是这个项目的目标,所以我让它随着时间的推移保持不变,并且等于估计期间无风险利率的平均值(它是-0.0819%)。

此外,我假设投资者面临的投资期限为 K 期,他的分配期开始于时间 T_0 。他使用估计样本(截至时间点 T_0 的数据)估计一个考虑的模型,并指定他的最优投资组合权重 w_ 。然后,他进行到时间段 T_0 + 1 ,因此在滚动/扩展窗口改变信息集的情况下,能够用更新的估计样本重新估计所考虑的模型。通过在时间上前进一个周期,他的投资范围减少到 K - 1 。在时段 T_0 + K - 1 中,他的范围等于 1,并且他可以使用直到该点的所有可用数据来根据估计方法选择他的最后分配权重。通过所述过程获得的组合权重序列 K 导致一个最终财富值 w_{T_0 + K} 。我遵循类似于 Barberis (2000)提出的方法。投资者的偏好由 CRRA(常数相对风险厌恶)幂效用函数描述。初始财富归一化为 1。我直接优化幂效用函数来获得最优权重。

请注意,投资者的问题可以描述为最大化以下等式:

这意味着投资者从时间 T_0 开始,最大化终端财富(W)总体决策。

近似条件期望的一种方法是采用跨路径样本均值:

然而,在这种情况下,这是不可能的,因为不同的路径具有不同的模拟预测变量,这又意味着不同的条件期望。使用的预测变量是:条件方差和滞后模拟回报由于自回归结构的条件平均方程。根据 Brandt 和 van Binsbergen (2007),我使用跨路径 OLS 回归来近似条件期望。跨路径样本均值可用于算法的最后一步。关于后向递归资产配置策略步骤的更详细描述,请参考 Brandt 和 van Binsbergen (2007)的论文。

为长期投资者评估不同规格的表现

先验,我预计具有更复杂创新分布的模型和/或使用滚动/扩展窗口的模型将优于简单模型。因此,我通过与所考虑的模型中的基准模型进行比较来衡量模型的性能。作为一项比较措施,使用了以下修正夏普比率(mSR)

其中m0sigma 0是基准规格的平均收益和波动率,下标 p 是指比较中更复杂的规格。这种方法的一个缺点是它没有考虑投资组合收益的高阶矩(偏度,峰度)。换句话说,不考虑非正态分布的影响。

2.R 中的解析部分

加载和操作数据

在这个练习中,我使用了标准普尔 500 指数回报,这是一个美国最大的 500 家上市公司的市值加权指数。我之所以选择它,是因为美国市场在全球市场资本总额和交易量中所占的比例是最大的市场,因此它不太可能通过极端行为来推动结果,而这种极端行为可能会在更奇特的数据中出现。

我使用tseries包中的get.hist.quote()函数从雅虎财经下载每周收盘价。

从下载的价格,我计算简单的回报。

除了退货系列,我还需要一些外部数据,,即。,无风险利率和通货膨胀。对于无风险利率,我采用联邦基金利率。我还使用 FRED 数据库中的 CPI(消费者价格指数)数据来调整通货膨胀的回报。你也可以在我的 GitHub 上找到这些数据。

我将数据集分成两个子样本:估计样本(覆盖 1988-1999 年,共有 626 个观察值)和评估样本(2000 年,有 52 个观察值)。

下一步是将无风险和通货膨胀的频率从每月一次改为每周一次。

最后,我需要考虑退货系列中的通货膨胀。

汇总统计数据

要注意的第一个重要方面是,评估样本的年化平均回报率为负。在此期间也有较高的方差。这两个特征都会影响资产配置策略的表现。负偏度和过度峰度(高阶矩)符合资产收益的程式化事实,,资产收益的分布不是高斯分布,可以用厚尾、尖峰(过度峰度效应)、负偏态分布来表征。然而,Jarque-Bera 正态性检验只在估计样本的情况下证实了这一假设。回报中也有一些序列相关性的证据(也是平方回报)。平方收益的相关性意味着二阶矩的时间变化,这也符合资产收益的程式化事实。

运行模拟

在运行模拟之前,我需要准备一个可能组合的网格。这三个类别包括:

  • 模型类型:GARCH 或 GJR-GARCH
  • 新息分布:高斯分布、偏态高斯分布、 t 、偏态 t 、广义误差分布和偏态 GED
  • 估计类型:固定/滚动/扩展窗口

对于 GARCH 模型的估计,我使用了rugarch包,它包含了所有必要的 GARCH 规范(GJR 变量,以及创新的多重分布)。由于这些计算相当繁重和耗时,我使用doParallelforeach并行运行它们。我做的另一个假设是关于投资者的风险厌恶水平——我只考虑风险厌恶系数lambda = 5不太厌恶风险的投资者。当然,通过在函数调用中更改参数值,可以很容易地获得其他参数值的结果。为了确保结果稳定,我对每个配置都进行了n = 100000模拟。

分析结果

本节介绍模拟实验的结果。由于大量的估计变量,我将不包括 GARCH 模型的估计系数。相反,我把重点放在投资组合回报和各种规格之间的比较上。

获得模拟结果后,我计算已实现投资组合回报的汇总统计数据(均值、标准差、偏斜度、峰度和夏普比率)。

人们可以观察到,年化平均投资组合回报是积极的,在绝大多数情况下,高于最简单的高斯创新和固定窗口方法的 GARCH 模型。此外,在大多数情况下,年化标准差低于基准情况,夏普比率高于基准。

下图显示了模拟投资组合回报随时间的演变。对该图的分析得出结论,使用不同的模型规格导致分配策略的某种相似的性能。然而,在一些时期,可以观察到不同的投资组合回报。值得注意的是,通过遵循源于 GARCH 模型的策略,投资者能够获得比单纯投资标准普尔 500 指数(如 2000 年 4 月)更低的负回报。因此,减少了损失。因为关于滚动/扩展窗口估计类型的图可以类比地解释,所以我不在这里附加它们。

最后一步是评估基于更先进模型的资产配置策略如何优于简单的基准。为此,我选择了一个具有固定窗口的高斯 GARCH 模型作为最简单的模型,并将它作为基准。在修正的夏普比率的帮助下完成了对优异性的评估,并且结果呈现在下表中。

可以观察到,当将更复杂的模型规格与简单的基准进行比较时,就修正的夏普比率而言,性能几乎总是更好。固定窗口估计类型和 GED 分布式创新的少数案例表现比基准差,但没有明确的迹象表明其背后的原因。

3.结论

在这个练习中,我研究了投资者是否能从使用不同规格的 AR(1) — (GJR)GARCH 模型准确预测股票收益(以标准普尔 500 指数为例)中获益。因此,我假设投资者的无风险利率和风险厌恶水平不变。实证结果表明,在某些情况下,通过修改夏普比率,使用更复杂的单变量模型会导致更有利可图的资产配置策略。例如,与基准模型相比,具有偏斜 t 分布和扩展窗口估计的(GJR-)GARCH 具有最好的表现。

进一步工作的一些想法:

  • 向实验中添加更多资产
  • 向条件均值方程添加额外的外生变量(额外来自自回归分量)
  • 检查在不同的模型中使用相同的资产配置框架(包含许多可能影响股票价格的变量的回归模型)是否会导致更好的资产配置

这个简短的实验到此结束。如果你对这个问题有任何想法,请告诉我。和往常一样,完整的 R 代码,以及更详细的“研究论文”版本可以在我的 GitHub 上找到。

我最近出版了一本关于使用 Python 解决金融领域实际任务的书。如果你感兴趣,我在贴了一篇文章介绍这本书的内容。你可以在亚马逊或者 Packt 的网站上买到这本书。

参考文献:

  • Barberis,N. (2000)回报可预测时的长期投资,金融杂志,55(1),225-264。
  • t . bollerslev(1986)广义自回归条件异方差,计量经济学杂志,31(3),307–327。
  • Glosten,l .,Jagannathan,R. & Runkle,D. (1993)股票名义超额收益的期望值和波动性之间的关系,金融杂志,48,1779-1801。
  • 奥尔巴克,A. (2013)时变高阶矩密度预测:模型置信集方法,预测杂志,32(1),19–31。
  • 范宾斯卑尔根,J. H .和 M. W .勃兰特(2007 年)。通过递归优化投资组合权重或价值函数解决动态投资组合选择问题,《计算经济学》, 29(3–4),355–367。

相似之处:大海捞针

原文:https://towardsdatascience.com/lookalikes-finding-needles-in-a-haystack-683bae8fdfff?source=collection_archive---------3-----------------------

合著者:康斯坦丁诺·博萨斯斯特凡诺·科斯坦蒂尼

合作者:弗拉迪斯拉夫·索尔达托夫迈克尔·戴维

在 Schibsted,我们使用数据科学来构建聚合用户行为和偏好的模型。广告商可以将这些结合起来,将用户分组,称为目标细分市场。

取决于它们是如何定义的,其中一些细分市场可能相当小众,限制了它们的覆盖范围。然而,广告商总是在寻找进一步扩大潜在受众的方法。

有什么比找到行为与他们已经瞄准的潜在客户相似的用户更好的呢?可以肯定的是,这些用户会比普通用户更容易接受他们的信息,从而提供了目标明确的受众。我们称这些额外的用户为长相相似的用户。

这听起来很棒,但是我们怎样才能找到他们呢?

我们的出发点是关于用户浏览行为的信息。例如,我们收集他们访问我们网站的不同方面的数据,如他们浏览的页面,他们访问这些页面的时间以及他们使用的设备。这可以帮助我们识别长相相似的用户。

然而,如此丰富的信息是福也是祸。这是一件幸事,因为它为我们提供了以各种方式模拟用户行为的灵活性,并选择最能描述用户活动的特性集。但这也是一个诅咒,因为考虑到数据的高维数,找到正确的特征集是一个挑战。如果选择了错误的功能集,就很难在浩瀚的用户大海中找到珍贵的针。

下图是根据已经标记的数据构建的,说明了这个问题。图像中的每个点都是每个用户原始特征的 2D t-SNE 投影。蓝点代表一组初始用户——在这种情况下是一组报纸订户——我们需要为他们寻找相似者。红点是真正的相似者(即初始集合中不包括的其他订户),而黄点是没有订阅报纸的普通用户。

t-SNE project of the feature space

我们的目标是挑选真正的订户(“红色”),排除普通用户(“黄色”)。正如我们在图中看到的,这似乎是一个棘手的问题。

在这篇文章中,我们展示了我们是如何解决这个问题的。这是一个实用的解决方案,允许我们充分利用原始种子集中包含的信息,充分利用我们可用的多种功能。

长相相似的问题

我们可以将我们的目标定义如下:

  • 假设 u 是在 d 维空间中的特征向量形式的用户表示。

the initial set of users, called the ‘seed set’

a second set of users, where typically n >> m

  • 根据某些标准返回 LT ,其中包括看起来像 S 中的用户的用户。在我们的例子中,用户在 Schibsted 网站上的在线活动。

在我们的实验中,用户表示向量 u 是二进制的,对用户在线行为的特定特征的存在或不存在进行编码。

如何实现这一点?我们在下面讨论它,但是首先我们从一个难题开始:我们应该使用监督的还是无监督的学习方法?这两种方法都旨在找到 L,但是每种方法都以完全不同的方式实现

在无人监督的情况下,该模型逐个检查 S 中的所有用户,并且对于每个用户,它从 T 中检索其活动看起来与给定用户的活动最相似的用户。在这种方法下,“长相相似”用户的集合将包含与初始集合中包含的用户相似的用户。但是,结果集可能与初始集一样异构。

在受监督的情况下,我们使用集合 ST 中的用户信息来训练受监督的机器学习算法,该算法将识别与初始集合中的用户相似的用户。该模型将尝试学习使初始种子集中的用户在一般人群中脱颖而出的隐含特征,并使用它们来寻找长相相似的用户。这种方法的主要优点是,假设初始集合中的用户共享一些共同的潜在特征,它可以非常有效地识别相似的用户。然而,由于缺乏明确的反例,寻找相似者不是一个普通的监督学习问题。有一些方法可以解决这些问题,比如积极未知学习,或者一类分类。

从工程的角度来看,无监督的方法更容易实现和维护,因为不需要模型的训练、参数调整、存储和服务。

简单明了

我们从我们可以使用的最简单的方法开始: K 近邻法 (KNN)。

在这种方法下,针对输入种子集 S 对群体 T 中的每个用户进行评分。我们通过计算 T 中每个用户与 S 中每个用户的相似度来给每个用户打分,然后取平均值。因此,对于每个用户,最终的相似性得分由下式给出:

user score

在计算了 T 中每个用户的相似性得分之后,我们可以按照与初始种子集的“接近程度”对他们进行排序,然后挑选得分最高的前 K 个用户作为相似集。

但是,这种方法有效吗?这个问题把我们带回了我们在引言中讨论过的数据维度问题。具体来说,我们的数据具有大约 30,000–40,000 的维度(取决于我们选择的特性集)。这让我们直面维度诅咒

当特征空间如此巨大时,可用数据变得稀疏。因此,区分每个用户的活动和其他人的活动变得更加困难,因为每个人在某些方面看起来都与其他人不同。

尽管面临这一挑战,我们还是用我们的数据集评估了传统的 KNN 方法,以建立一个基线。余弦距离用于所有实验,因为我们发现它比我们数据中的其他度量产生更好的结果。

相似模型的评估不像典型的二进制分类问题那样简单,因为缺乏否定的基本事实。在早期的原型制作阶段,我们通过混淆完全已知的数据集中的部分标签来克服这个障碍。在这种情况下,我们使用传统的分类指标,如精确度和召回率。但是这种方法只能带我们走这么远。

在现实生活中,比如我们在这篇文章中考虑的情况,阴性样本是不可用的。因此,我们需要一个替代的性能指标。在这种情况下,我们选择使用Mean Average Precision(MAP),它测量模型将正面类排在 lookalike 排名顶部的程度。下图显示了地图计算是如何工作的,以及地图的改进意味着什么。首先,假设我们有一个 lookalike 算法,它提供了下图顶部所示的排名。我们知道阳性样本应该排在前面。在这种情况下,我们发现它们位于位置 1、5 和 7。相应的,这个排名的映射是 0.609。现在,假设我们发现了一项改进,改变了排名,如图底部所示。在这种情况下,随着阳性样本越来越向顶部聚集(在位置 1、2 和 5),MAP 上升到 0.866。

Mean Average Precision (MAP) explained

**在我们的例子中,普通 KNN 方法的 MAP 得分是 0.704 **。这个可以和一个随机排名的图比较,0.196。还不错,但是我们可以做得更好。是时候寻求更好地处理高维数据的方法了。

利用你所知道的

虽然天真的方法似乎能够在某种程度上识别长相相似的用户,但原始的特征空间可能并不能很好地服务于我们的目的。我们需要一种方法来降低数据的维数。

用于降维的标准技术是 PCA,然而当我们应用它时,我们没有得到任何对 MAP 分数的改进。这可以被解释为因为 PCA 试图仅保持具有最高可变性的正交分量,并且对于种子用户活动和大用户池之间出现的不同趋势是不可知的。

如果我们确定了哪些特征对问题最有价值,即有助于区分种子集用户和其他用户的特征,而不是使用 PCA 或其他降维方法,也许我们可以进一步提高性能。如果我们知道这一点,我们就可以更多地依靠最相关的特征来计算用户相似性。

我们从这样的假设开始,即输入种子集包含表现出我们想要在整个群体中识别的特定行为的用户,而群体中的大多数个体表现出一般行为。通过比较这两个集合,我们可以突出它们之间的差异,并使用该信息来识别应该给予更多重视的特征。

更正式地说,为了度量每个特征的重要性,我们可以使用信息论度量,比如互信息。具体来说,马等人(T3)发现,信息值(T5)(IV)工作良好:我们对我们的问题采用了类似的方法。信息值常用于变量选择,定义如下:

Information Value score

其中 p _i 和 q _i 分别是在种子集 S 和种群集 T 中激活特征 i (f_i)的用户比例。

由于我们的特征向量是二进制的,我们可以通过将计算的 IV 权重 w 乘以向量 u 来生成新的加权特征向量。这个过程产生一个新的特征空间,具有更高的鉴别潜力。

我们通过在新的特征空间中生成相同样本的 2D t-SNE 投影来直观地演示这一点。

t-SNE projection of the of the original features space and the weighted one

正如我们可以看到的,当我们使用 IV 加权特征时,用户的类别看起来更加分离:正面测试集现在与未知测试集明显区分开来。此外,我们可以看到属于阳性集合的样本与种子集合中的样本被分组在一起。正如所料,这对 lookalike 算法的性能有积极的影响:加权特征空间上的 MAP 是 0.791,比我们的基线好 12%以上。

扩大规模

每天大约有 2 亿用户访问 Schibsted 的媒体和市场网站。扩展加权 KNN 原型是一项严峻的挑战,也是成功交付产品的关键部分。

我们算法的简化复杂度分析如下:

两个向量之间的余弦相似度大约需要 3d 次运算(点积 1 次,每个向量范数 1 次),其中 d 是向量维数。

  • 对于参考集样本,我们需要|S| x 3d +|S|操作(一次计算距离,一次对所有距离求和)。
  • 我们已经注意到,如果种子集大小很大,那么对单个样本进行评分会非常昂贵。
  • 最后,为了对整个参考集|T| x (|S|x3d + |S|)进行排序,需要进行运算。

即使我们的特征的稀疏特性意味着每次距离计算可以在比 3d 运算少得多的运算中解决,当处理几百万个用户时,总的计算工作量也是巨大的。

幸运的是,这个任务可以并行化。

在我们的生产设置中,我们使用 Spark 和 Scala。我们发现,利用我们的特征的稀疏性,通过实施稀疏矩阵乘法方法并结合在 Spark 中广播种子集稀疏矩阵和种子集范数,我们可以显著地加速该过程。如果 u_T^i 是待排序的特征向量, W 种子集稀疏矩阵, g 是保存种子集范数的向量, vu_T^i 的范数,那么将特征向量乘以种子集矩阵z**=u_t^i^t w就可以得到余弦距离的分子**

alternative user score formula

下面是实现过程:

我们也知道近似最近邻搜索技术,如本地敏感哈希(LSH),但上面介绍的精确搜索的实施可以处理我们的用户群,并在中等规模的集群中在不到一个小时的时间内生成结果。

有用吗?

当机器学习算法在现实世界中表现良好时,它就会显示出真正的价值。为了验证这一点,我们设立了两个在线活动:第一个向属于已知细分市场的用户展示定向广告,第二个由第一个细分市场的相似用户制作。我们通过应用上述算法,使用已知片段作为种子集来构建第二片段。

长相相似的细分市场旨在扩大第一个细分市场的受众范围。然而,只有当该段的性能与原始段的性能相当时,这才是可实现的。下图比较了展示给原始细分市场(左)和相似细分市场(右)用户的广告的点击率 (CTRs)。图表显示,基于长相相似的广告活动的表现与最初的广告活动不相上下。

原始部分在桌面上表现更好,而长相相似的部分在移动设备上表现出更高的点击率。不过,在这两种情况下,差异都在误差范围内。最重要的是,相似片段的性能并不比原始片段的性能差很多。该结果表明,相似算法可以用于其预期的受众扩展目标。具体来说,在上面的案例中,我们能够在保持 CTR 性能的同时,将段的大小翻倍。总而言之,成功的第一次在线测试。我们目前正在对不同的广告活动和广告客户进行更多的测试,初步结果很有希望。

加拿大各大银行找工作?银行求职俱乐部给你洞察热门的 IT 技能

原文:https://towardsdatascience.com/looking-for-jobs-in-canada-major-banks-bank-job-club-give-you-insight-hot-it-skills-there-3ded1b24426d?source=collection_archive---------6-----------------------

image credit https://upload.wikimedia.org/wikipedia/commons/3/39/NYC_Top_of_the_Rock_Pano.jpg

学习是对你职业生涯的专业投资。对技术学习的投资和对金融领域的投资一样有风险。是因为科技太快了,每天都有太多的流行语出现。许多技术来来去去,只有少数技术在特定领域占据主导地位。

三个月前,我正从一家大型传统科技公司转行到金融机构。我开始分析在我们加拿大的主要银行里什么样的 IT 技能是热门的。快速浏览几个招聘职位让我了解到哪些技能在银行很热门。因此,我决定发起一个项目——银行求职俱乐部,来分析。

我参与这个项目的旅程

收集数据

数据作为软件中的自然资源,是我首先需要的。没有这种正式的数据来源。所以我开始从银行的公开网站上搜集数据。我早就听说 python 有一套工具来完成这种工作,所以我尝试了一下。利用 dryscrapeBeautifulSoup ,我可以轻松地从内容由 JavaScript 代码动态创建的网站中提取基本信息。这是可能的,因为 dryscape 利用一个 headless webkit 服务器来获得 HTML 呈现。

这里有一个如何找到工作内容的例子。在这个站点中,内容的 div 有唯一的类名,我们可以用这个属性来标识内容。

**import** dryscrape
**from** bs4 **import** BeautifulSoupsession = dryscrape.Session()
session.set_attribute(**'auto_load_images'**, **False**)
session.visit(url)
time.sleep(2)
response = session.body()
soup = BeautifulSoup(response, **"lxml"**)
tags = soup.findAll(**'div'**, {**'class'**: **'jd-info au-target'**})

存储数据

我选择了 mongodb 作为我的持久存储,因为我的数据模型很简单。一个简单的 json 文档就足够了。不需要为表定义多个模式,也不需要通过创建桥表来处理关系。为了让我的 python 程序执行 db 操作,我利用了 pymongo

**from** pymongo **import** MongoClientclient = MongoClient(**'localhost'**, 27017)
db = client.job_bank_db
all_jobs = db.jobs
**for** job **in** jobs:
    **try**
        all_jobs.insert_one(job.__dict__)
    **except** Exception **as** ex:
        print(**"Found exception: "**)
        print(job)
        **continue**

Cron 作业

在我们的世界里,能自动化的事情就应该自动化。所以我有一个程序来提取银行工作的信息。我需要它每天至少执行一次,以保持我的应用程序显示最新的数据。在 Linux 的世界里,这很简单:

crontab -e
# than edit the file in specific format
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/

服务

我用 Express.js 在 Node.js 中创建了一组 Restful web 服务,该服务的职责就像从 mongo 提供数据并进行过滤和排序一样简单。

即 GET /jobs 端点

*// GET jobs* router.**route**(**'/jobs'**)
  .get(**function** (req, res) {
    res.setHeader(**'Content-Type'**, **'application/json'**);
    **query_object** = {};
    **var** bank_name = req.**query**.bank;
    **if** (bank_name) {
      **query_object**.**company** = bank_name;
    }
    **var** skill = req.**query**.skill;
    **if** (skill) {
      skill = skill.replace(/\./g, **'-'**);
      **query_object**[**'stats.'** + skill] = {**$gt**: 0};
    }
    **var** page = req.query.page;
    **if** (page) {
      page = parseInt(page);
    } **else** {
      page = 0;
    }
    **var** page_size = req.query.page_size;
    **if** (page_size) {
      page_size = parseInt(page_size);
    } **else** {
      page_size = 20;
    }
    **var** skip = page_size * page;

    Job.find(query_object)
      .sort(**'-post_date'**)
      .limit(page_size)
      .skip(skip)
      .exec(**function** (err, jobs) {
        **if** (err) {
          res.send(err);
        } **else** {
          Job.count(query_object, **function** (err, c) {
            result = {count: c, jobs: jobs};
            res.json(result);
          });
        }
      });
  });

用户界面

UI 层在应用中越来越受到重视。越来越多的逻辑被转移到这一层。现在有一些不错的框架和库。React.js + Redux 成为我的选择,因为我喜欢它们如何处理应用程序中的状态和数据流的概念。有 react.js 教程redux 官方 doc 这样的好教程。另外, create-react-app 是一个方便的工具,可以帮助我快速创建一个可运行的结构项目。

从 UI 到 webservice 的通信并不简单。在开发过程中,我将它们作为两个不同的存储库,它们在开发过程中运行在不同的服务器上。react.js 应用运行在自己的嵌入式开发服务器上。当 web 服务在 express 服务器上运行时。向另一个服务器发出请求被认为是浏览器不允许的跨源资源共享。所以我需要在我的 react.js 应用程序的 package.json 中指定代理。

"proxy": "[http://localhost:8080](http://localhost:8080)" 

通过这样做,应用程序内部发出的 http 请求将被路由到 localhost:8080 上托管的 webservice。解决这个问题不需要代码。

注意 此代理仅用于开发。

生产中,您可以在同一个服务器上运行两者,因此不需要代理。这样,您可以通过覆盖一个目录来热更新 UI。

首先,生成生产缩小包。在 react.js 项目中运行下面的命令。

npm run build

将构建目录移动到 webservice 项目中。

cp build $service_project_dir

在 webservice 中,告诉服务器构建目录包含静态资源。

app.use(express.static(__dirname + '/build'));

启动服务器PORT=80 npm start

来自数据的初步见解

敏捷——这个行话

令人惊讶的是,敏捷是银行招聘信息中排名第一的关键词。这表明几乎所有的银行都在采用敏捷方法。因此,如果你有敏捷的经验,你有很大的优势。但是你应该预料到痛苦,因为在开始采用敏捷的大公司中可能会有许多冲突。

Java——广泛使用的语言

不管你讨厌它还是喜欢它,Java 仍然是银行就业市场上最需要的编程语言。有了这个,我们可以假设 SSH (Spring、Structs 和 Hibernate)可能是银行坚持使用的技术栈。

数据库

关系数据库仍然占主导地位。Oracle 是最常被提及的数据库,其次是 SQL server 和 DB2。NoSQL 目前不太出现在工作岗位上。

终于第一次发布完成了。随时欢迎反馈。

[## 加拿大银行的技术技能

该平台提供加拿大银行 IT 工作的热门 IT 技能分析。

银行-工作.俱乐部](http://bank-jobs.club/)

我的帖子:

我关于金融和科技的帖子

我关于 FAANG 访谈的帖子

从 CRUD web 应用开发到语音助手中的 SDE——我正在进行的机器学习之旅

全栈开发教程:将 AWS Lambda 无服务器服务集成到 Angular SPA 中

全栈开发教程:用运行在 AWS Lambda 上的无服务器 REST API 提供交易数据

全栈开发教程:在 Angular SPA 上可视化交易数据(1)

强化学习:Q 学习简介

无损三重损耗

原文:https://towardsdatascience.com/lossless-triplet-loss-7e932f990b24?source=collection_archive---------1-----------------------

pexels.com

一种更有效的暹罗神经网络损失函数

在工作中,我们与暹罗神经网络(NN)合作,对电信数据进行一次性训练。我们的目标是创建一个可以轻松检测电信运营商网络故障的神经网络。为此,我们构建了 N 维编码来描述网络的实际状态。通过这种编码,我们可以评估网络的状态并检测故障。这种编码与单词编码( Word2Vec 或其他)的目标相同。为了训练这种编码,我们使用一个暹罗网络【科赫等人】来创建一个一次性编码,这样它就可以在任何网络上工作。暹罗网络的简单描述可以在这里找到。关于我们实验的更多细节,你可以阅读我的同事的博客,他是这个想法背后的主脑。

coffeeanddata.ca 上的原始帖子

目前的实验,到目前为止效果很好。这个网络可以分割不同的交通场景。正如您在这张图片上看到的,良好的流量(绿色)很容易从错误类型 1(红色)和错误类型 2(橙色)中分离出来

Current Model

问题是

那么问题是什么,它似乎工作得很好,不是吗?经过一番思考,我意识到损失函数有一个很大的缺陷。

首先是我们模型的代码。(不必阅读所有代码,我会指出问题。)

我的问题是这条损失函数线。

loss = K.maximum(basic_loss,0.0)

这里有一个主要问题,每次你的损失低于 0,你就失去了信息,大量的信息。首先让我们看看这个函数。

它基本上是这样的:

Schroff et al.

它试图使锚(当前记录)与正(理论上与锚相似的记录)尽可能接近负(与锚不同的记录)。

这一损失的实际公式为:

Schroff et al.

这个过程在论文 FaceNet 中有详细介绍:一个统一嵌入用于人脸识别和聚类的byFlorian SchroffDmitry KalenichenkoJames Philbin

因此,只要负值比正值+α更大,算法就不会有增益来压缩正值和锚点。我的意思是:

Distance costs

让我们假设:

  • 阿尔法是 0.2
  • 负距离是 2.4
  • 正距离是 1.2

损失函数结果将是 1.2–2.4+0.2 =-1。然后,当我们查看 Max(-1,0)时,我们最终得到 0 作为损失。正距离可以是大于 1 的任何值,损失也是一样的。在这种情况下,算法将很难减少锚和正值之间的距离。

作为一个更直观的例子,这里有两个场景 A 和 b。它们都代表了损失函数为我们测量的内容。

在 Max 函数之后,A 和 B 现在都返回 0 作为它们的损失,这是明显的信息损失。单纯看,可以说 B 比 a 好。

换句话说,你不能相信损失函数的结果,例如 50 年前后的结果。损失(训练和开发)为 0,但显然结果并不完美。

其他损失

另一个著名的损失函数是严乐存和他的团队在他们的论文中描述的对比损失,通过学习不变映射进行降维,也最大化了负面结果,这产生了相同的问题。

The Contrastive Loss Function, (LeCun)

解决办法

有了标题,你很容易猜到我的计划是什么…做一个损失函数,它将捕捉 0 以下的“丢失”信息。在一些基本的几何学之后,我意识到如果你包含了计算损失的 N 维空间,你可以更有效地控制它。所以第一步是修改模型。最后一层(嵌入层)需要控制大小。通过使用 Sigmoï de 激活函数而不是线性函数,我们可以保证每个维度都在 0 和 1 之间。

Sigmoïde activation

那么我们可以假设距离的最大值是 N,N 是维数。举个例子,如果我的锚点在 0,0,0,我的负点在 1,1,1。基于 Schroff 公式的距离将是 1 +1 +1 = 3 。所以如果我们考虑维度的数量,我们可以推导出最大距离。这是我提出的公式。

Linear loss function

其中 N 是嵌入向量的维数。这看起来非常相似,但通过使用 sigmode 和适当的 N 设置,我们可以保证该值保持在 0 以上。

初步结果

经过一些初步测试,我们最终有了这个模型。

Merge results

好的一面是,我们可以看到来自同一个集群的所有点都变得非常紧密,甚至到了它们变得相同的程度。但不利的一面是,这两种错误情况(橙色和红色)重叠了。

这样做的原因是,当红色和橙色分开时,这样的损失较小。所以我们需要找到打破成本线性的方法;换句话说,随着错误越来越多,成本越来越高。

非线性

代替线性成本,我们提出了非线性成本函数:

From Google Graph

curve function

其中当 N = 3 时,曲线由 ln 函数表示

有了这个新的非线性,我们的成本函数现在看起来像:

Lossless triplet loss

其中 N 是维数(网络的输出数;用于嵌入的特征数量),β是比例因子。我们建议将其设置为 N,但也可以使用其他值来修改非线性成本。

如您所见,结果不言自明:

Result of classification with lossless triplet loss

我们现在有非常浓缩的点群,比标准的三元组函数结果要多得多。

作为参考,损失函数的代码如下:

记住,为了使它工作,你需要你的 NN 最后一层使用 Sigmoï de 激活函数。

即使在 1000 个历元之后,无损三重损耗也不会像标准三重损耗那样产生 0 损耗。

差异

基于我的同事做的他的模型的很酷的动画,我决定做同样的事情,但是用两个损失函数的现场比较。这是现场结果,左边是标准三重损耗(来自 Schroff paper ),右边是无损三重损耗:

结论

这个损失函数看起来不错,现在我需要在更多的数据、不同的用例上测试它,看看它是否真的是一个稳健的损失函数。让我知道你对这个损失函数的看法。

想要阅读更多内容

关注我的博客: coffeeanddata.ca

参考

  • 科赫、格雷戈里、理查德·泽梅尔和鲁斯兰·萨拉胡季诺夫。“用于一次性图像识别的连体神经网络。” ICML 深度学习工场。第二卷。2015.
  • 《向量空间中单词表征的有效估计》 arXiv 预印本 arXiv:1301.3781 (2013)。
  • 施洛夫、弗洛里安、德米特里·卡列尼琴科和詹姆斯·菲尔宾。" Facenet:人脸识别和聚类的统一嵌入."IEEE 计算机视觉和模式识别会议论文集。2015.
  • 哈德塞尔、拉亚、苏米特·乔普拉和扬·勒昆。"通过学习不变映射来降低维数."计算机视觉与模式识别,2006 年 IEEE 计算机学会会议于。第二卷。IEEE,2006 年。
  • 【https://thelonenutblog.wordpress.com/
  • https://hacker noon . com/one-shot-learning-with-siamese-networks-in-py torch-8d daab 10340 e

低预算和高期望:机器学习初创公司

原文:https://towardsdatascience.com/low-budgets-and-high-expectations-machine-learning-startups-c428f3f82569?source=collection_archive---------5-----------------------

在之前关于如何雇佣人工智能顾问和如何给人工智能项目定价的文章中,我试图让你了解人工智能咨询领域的工作方式。我也让你们感受到了许多在的老牌组织在将他们的数据放入云端时所面临的特殊挑战。

这篇文章是关于那些更小更新的公司的。让我先说一下,并不是所有的创业公司都是一样的。每个人都是一朵特别的花,生长或枯萎都是如此。现在,我们来概括一下。在人工智能真正炙手可热的创业世界中,存在一种奇怪的动态,然而当谈到对预期进行定价时,预期和现实之间的一致性却很不正常。企业客户通常需要一些快速解决方案来部署 apache sparkhadoop等等,以便及时获取他们的数据。这还是在考虑机器学习之前。对于初创公司来说,这同样具有挑战性。

一旦可以访问数据,就需要设计、构建、测试和部署 ML 系统。对于某些模型来说,这非常简单,但是这些步骤仍然需要时间。可能需要尝试几种不同的模式。客户端几乎总是需要配置 GPU 资源,即使这仅仅意味着在 p2 实例上加载 AWS 中的 AMI。这需要更多的时间。不要忘记有时你想要一个保留实例来降低成本。也许你想比较 GCP 和 AWS 的平台。现在,系统几乎总是需要超过用户名和密码的安全性。我喜欢使用 PPK/pem 证书和谷歌认证器。所以简而言之,即使是创业公司的小型机器学习项目也没有那么小。

我开始写这篇文章之前,一个小的一个人创业公司上周接触到我们公司的一个项目,将需要 3 个月的兼职基础上,成本上限为 1000 美元。我喜欢非常节省时间,但这是愚蠢的。如果这个项目预计需要 4 个小时,我还是不得不拒绝。只是为了通过 NDA 和计费流程…是的。这说不通。

现在,这家创业公司不是想耍我。这是他们能承受的。我不得不建议这位企业家去为他的想法筹集资金,并保持联系。这些关于 ML 创业的困难的思考对我来说并不新鲜

我喜欢凯文·德瓦尔特关于企业客户机器学习项目成本估算的表格。请参见下面的链接:

[## AI 第 1 年预算模板

规划你的第一个人工智能产品的起点

blog.prolego.io](https://blog.prolego.io/ai-year-1-budget-template-85d4d419a5a1)

Kevin 列出的成本比许多初创公司机器学习项目都高,因为许多初创公司没有针对其原型的大数据要求。然而,它应该让每个人都很好地了解保持机器学习项目正常运行的成本。

有些风险是值得的,比如早期未付费的客户演示,这样才有机会赢得项目。但是,有时候客户对可能发生的事情抱有非常不切实际的期望。时间、金钱、质量→选择 2

更奇怪的是。ML 开发是关于结果的,而不是你的顾问花了多少时间编码。在一个商品化的市场中,我们会对 ML 项目收费,就像软件公司对网络开发收费一样。更多的时间意味着更多的钱,工作时间和结果之间的关系是线性的(也许真的更像一条 tanh S 曲线)。然而,在 ML 中,努力输入经常导致未知的结果输出。数据科学仍然是一门艺术,有时最大的成果来自于知道在哪里寻找正确的库(低努力;高回报),而不是写最激进的代码(高努力;奖励高)。

我想分享一下我上周与一个客户的数据打交道的经历,让我明白 ML 的发展是一条曲折的道路:

我从客户的约 10,000 条记录的小型单表 mySQL 数据集开始,用于回归和分类模型。因为体积小,我从无监督迁移学习开始。我取得了不错的成绩,但怀疑自己还能做得更好。接下来,我着手开发一个监督学习模型,它可以编译,但结果更差。接下来,我继续研究生成模型。结果比以前更糟,迫使我回到最初的解决方案。我在最初的方法中添加了一些特性工程,并在性能上取得了一点点改进。现在,这个模型似乎已经达到了这个阶段的最佳状态。在这里,在概念验证项目的最后,我花费了超过 80%的精力在不会被使用的代码上。而性能最好的代码是我在项目的前 20%写的东西。大多是前 20 分钟!

我们从这件事中学到的是,时间和结果之间的关系是变化无常和怪异的。数据科学更多的是化学和柠檬派,而不是土木工程和纯数学。这是一个更加动态和实用的过程,而不是一个金钱投入/结果产出的等式。

我对创业期望的建议是,在开始你的机器学习项目之前,尽可能多地收集、组织和标记你的数据。与你的利益相关者讨论你的资源,不要羞于从不同的供应商那里得到多个报价。你会发现价格和质量的权衡,就像其他购物一样。缓和你的期望,但不是你的兴奋。部署机器学习的时间到了

如果你喜欢这个帖子,那么请推荐它,分享它,或者给它一些爱(❤).我也很高兴在评论中听到你的反馈。

编码快乐!

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

TensorRT 低精度推理

原文:https://towardsdatascience.com/low-precision-inference-with-tensorrt-6eb3cda0730b?source=collection_archive---------2-----------------------

声明:这是而不是一个 NVIDIA 的官方帖子。只是总结一下我从演讲、听的演讲和与人的互动中学到的和收集到的东西。Post 假设对深度学习(DL)有一些基本的了解。

深度学习程序通常有两个阶段,即,

  1. 训练,利用一堆数据和某些优化技术,机器学习归纳(嗯,这是它能得到的最简单的)。通常离线完成。
  2. 推理,机器将学习到的概括应用于看不见的数据。通常在生产环境中使用。

训练是对大量数据的迭代过程。它的计算量非常大。根据问题定义、数据等,可以使用从单个 GPU 到一群 GPU 的任何东西。

另一方面,推理在计算上相对容易(由于较小的批量和没有反向传递),但是在大多数 DNN(深度神经网络)应用中实现实时推理仍然是一个困难的问题。

注意,训练过程一般没有“实时的约束。另一方面,实际推理是受时间和力量(尤其是嵌入式)约束的。TensorRT 是 Nvidia 软件解决方案,用于为深度学习模型的生产部署生成优化模型。这篇 parallel forall 博客文章对 TensorRT,以前被称为 GPU 推理引擎(GIE ),博客使用旧行话)做了很好的介绍。

这篇博客将主要集中在一个重要的优化技术上:低精度推理(LPI)

在开始理解 LPI 之前,我将快速总结一下所有博文的相似之处。

Fig. 1: TensortRT in one picture

上图很好地概括了 TRT 的工作。它基本上是作为一个 SDK 公开的。你输入你已经训练好的网络(这将意味着模型定义和学习参数)和其他参数,如推理批量大小和精度,TRT 做优化,并建立一个执行计划,可以使用或序列化,并保存到磁盘上,供以后使用。推理时不需要深度学习框架。只要使用 TRT 输出的执行计划,就可以了。在服务器、台式机甚至嵌入式设备上使用它。此外,对于给定的模型,这是一次性的事情。没有附加条件:)

优化引擎

这就是奇迹发生的地方(嗯,不完全是,这只是科学)。TRT 做了一些优化。

  • 图形优化:

Fig.2: Vertical Fusion — Input

Fig.3: Vertical Fusion — Optimized graph

上图解释了 TRT 所做的垂直融合优化。卷积(C)、偏置(B)和激活(本例中为 R、ReLU)都被合并到一个节点中(就实现而言,这意味着 C、B 和 R 只启动一个 CUDA 内核)。

Fig.4: Horizontal Fusion

是的。还有一种水平融合,其中如果具有相同操作的多个节点正在向多个节点馈送,则它被转换为一个单个节点向多个节点馈送。三个 1x1 CBRs 被融合成一个,并且它们的输出被定向到适当的节点。

其他优化

除了图形优化之外,TRT 还通过实验并基于诸如批量大小、卷积核(过滤器)大小等参数,为网络中的操作选择高效的算法和核(CUDA 核)。

低精度推理

那么,为什么我们真的需要低精度的推理呢?

正如已经提到的,执行时间和功率并不便宜,在实时应用中是至关重要的。考虑到所需的计算量,我们希望在不影响准确性的情况下,优化我们的推理,以利于时间和能力。因此,我们转移到参数的 8 位表示和推理时的激活。与 32 位相比,8 位需要更少周期来获取存储器。还有一个新的硬件指令(DP4A)形式的优势,我将在本文稍后介绍。

这有用吗?

是的,当然。如果不是这样的话,这个博客就是浪费时间了:)。在训练过程中,参数和激活在 FP32 中显示。FP32 的高精度有利于训练,因为每个训练步骤都会对参数进行少量修正。DL 算法通常对噪声有弹性。在学习模型的过程中,通常会尝试选择性地保留预测所需的特征。所以,扔掉不必要的东西是这个过程的一部分。所以我们希望低精度表示引入的噪声被模型扔掉(这里也是非常外行的术语)。据我所知,没有严格的数学证明说低精度应该在推理过程中像 FP32 一样好。

将 FP32 映射到 8 位

这是 TensorRT 为应用程序/客户端做的事情。应用程序/客户端只需要实现一个提供校准信息和一些缓存相关代码的接口。很快会有更多的报道。在此之前,让我们看看 TRT 进行 32 位到 8 位映射的步骤。

映射的候选对象是每一层的输入(将输入到第一层,并激活其余层)和学习参数。最简单的映射/量化形式是线性量化。

FP32 张量(T) = scale_factor(sf) * 8 位张量(t) + FP32_bias (b)

很简单,不是吗?让我们把它变得简单些。(从实验中)发现偏差项并没有真正增加任何价值。所以,摆脱它。

T = sf * t

注意这里的 sf 是每个层中每个张量的比例因子。现在,下一个问题是找到比例因子。一个简单的方法是如下图所示:

Fig.5: A simple max-max mapping

我们简单地将张量中的-|max|和|max| FP32 值分别映射到-127 和 127。其余的值相应地线性缩放。但是,这里有一个问题。实验表明,这种映射会导致显著的精度损失。因此,TRT 采取了以下措施:

Fig.6: Threshold instead of max

而不是看|max|值。固定一个阈值(如何?我们稍后会看到)。然后像前面一样进行映射。阈值范围内的任何值都调整为-127 或 127。例如,在上图中,三个“红叉”被映射到-127。

那么接下来的问题就是阈值 T 的最优值是多少?这里有两种分布。我们有 FP32 张量,它在 FP32 分布中表现得最好。但是,我们希望用不同的分布(8 位)来表示它们,这不是最好的分布。我们希望看到这些分布有多大的不同,并希望将差异最小化。TRT 使用 Kullback-Leibler 散度( KL-divergence )来衡量差异,并旨在将其最小化。

可选:什么是 KL-divergence?为什么是 KL-divergence?一些直觉:<可选开头> 让我们在这里稍微进入编码理论。假设我有一系列符号,我知道它们出现的概率。如果我要对符号进行最佳编码,我会使用比如说“T3”T 比特。注意 T 是最佳位数。让我们称这个代码为代码' A '。现在,我有了同样的一组符号,但是它们出现的概率变了。现在,对于具有新概率的符号,如果我使用代码' A '来编码符号,则用于编码的比特数将是次优的,并且大于' T '。KL-divergence 精确地测量这种差异,即最优和次优之间的差异(由于选择了错误的代码)。在我们的例子中,张量值的正确代码是 FP32,但我们选择用 8 位错误代码来表示(嗯,不是错误,但你明白了)。所以有一个惩罚,用 KL 散度来衡量。我们的工作是尽量减少处罚。如果你已经用 DL 解决了一些问题,你可能会用交叉熵作为一个代价函数。KL 散度与交叉熵密切相关。虽然 KL-divergence 表示由于在错误代码中编码而导致的比特数(或所需的额外比特数)的差异,但是交叉熵表示在该错误代码中编码符号所需的确切比特数。所以, KL-divergence =(交叉熵)——(最优码所需比特数)<可选结束>

因此,我们需要最小化 FP32 值和相应的 8 位值之间的 KL 偏差。TRT 使用简单的迭代搜索最小散度,而不是基于梯度下降的方法。步骤如下:

Fig.7: Threshold finding process

校准

TRT 采用基于实验的阈值迭代搜索。校准是其中的主要部分。应用程序/客户向 TRT 提供了一个样本数据集(理想情况下是验证集的子集),称为“校准数据集”,用于执行所谓的校准。TRT 在校准数据集上运行 FP32 推理。收集激活直方图并生成具有不同阈值的 8 位表示的集合并选择具有最小 KL 散度的一个。KL 散度在参考分布(FP32 激活)和量化分布(8 位量化激活)之间。TRT 2.1 提供了IInt8EntropyCalibrator接口,客户端需要实现该接口来提供校准数据集和一些用于缓存校准结果的样板代码。

DP4A

这就是 TRT 如何进行优化的简要介绍。还有一件事不完全相关,但 TRT 依赖于 8 位快速推理。从 Pascal 一代 GPU(选定的 SKU)开始,有一种称为 DP4A 的新硬件指令。

Fig.8: DP4A (Dot Product of 4 8-bits Accumulated to a 32-bit)

它基本上是一条指令,执行 4 次 8 位乘法,并累加成一个 32 位整数。点积构成了卷积运算的数学基础,该指令通过最小化执行时间和功耗,提供了非常好的提升。这篇关于 CUDA 8 的博客更详细地讨论了 DP4A。如果有兴趣,一定要去看看。

因此,总的来说,优化的空间很大。考虑到 TRT 的优化和正确的硬件(支持 DP4A 的 GPU),您不仅可以将 GPU 推向极限,同时还可以保持其效率。所以去做一些有效的推断,直到你推断出生命的意义:D

**一些参考:**我无耻地从博客和演示文稿中抄袭数据:)

图 1 至图 4:tensort

图 5 至图 8 : GTC PPT

这大部分是基于在 2017 年 GTC 上的这个出色的展示

PS:请随意评论/批评/ ♥这篇文章。

使用张量流的 LSTM 示例

原文:https://towardsdatascience.com/lstm-by-example-using-tensorflow-feb0c1968537?source=collection_archive---------0-----------------------

在深度学习中,递归神经网络(RNN)是一个神经网络家族,擅长从序列数据中学习。已经找到实际应用的一类 RNN 是长短期记忆(LSTM ),因为它对长期依赖的问题是稳健的。解释 LSTM 的文章和参考资料并不缺乏。推荐的两个参考文献是:

Goodfellow 等人的《深度学习》一书的第十章。艾尔。

克里斯·奥拉解读 LSTM 网络

也不缺乏好的库来构建基于 LSTM 的机器学习应用。在 GitHub 中,谷歌的 Tensorflow 在撰写本文时已经有超过 50,000 颗星,这表明它在机器学习从业者中非常受欢迎。

似乎缺少的是关于如何基于 LSTM 构建易于理解的 Tensorflow 应用程序的良好文档和示例。这是这篇文章背后的动机。

假设我们想训练 LSTM 使用一个简单的小故事伊索寓言来预测下一个单词:

很久以前,老鼠们开了一个全体会议,考虑采取什么措施来智取它们共同的敌人——猫。有些人这样说,有些人那样说,但最后一只年轻的老鼠站起来说,他有一个建议,他认为会满足的情况。你们都会同意,他说,我们的主要危险在于敌人向我们逼近的狡猾和奸诈的方式。现在,如果我们能收到一些她接近的信号,我们就能轻易地逃离她。因此,我斗胆提议买一个小铃铛,用丝带系在猫的脖子上。通过这种方式,我们应该总是知道她在哪里,当她在附近时,我们可以很容易地退休。这个提议得到了普遍的掌声,直到一只老老鼠站起来说,这一切都很好,但是谁来给猫系上铃铛呢?老鼠们面面相觑,谁也不说话。然后老老鼠说,很容易提出不可能的补救措施。

清单 1。一个来自伊索寓言的小故事,有 112 个独特的符号。单词和标点符号都被认为是符号。

如果我们将来自 3 个符号作为输入和 1 个标记符号的文本的正确序列输入给 LSTM,最终神经网络将学会正确预测下一个符号(图 1)。

图一。具有三个输入和一个输出的 LSTM 单元。

从技术上讲,LSTM 输入只能理解实数。将符号转换为数字的一种方法是根据出现的频率为每个符号分配一个唯一的整数。例如,在上面的文本中有 112 个独特的符号。清单 2 中的函数用以下条目构建了一个字典[",":0 ] [ "the" : 1 ],…,[ "council" : 37 ],…,[ "spoke" : 111 ]。还生成反向字典,因为它将用于解码 LSTM 的输出。

**def** build_dataset(words):
    count = collections.Counter(words).most_common()
    dictionary = dict()
    **for** word, _ **in** count:
        dictionary[word] = len(dictionary)
    reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys()))
    **return** dictionary, reverse_dictionary

清单 2。建立字典和反向字典的功能。

类似地,预测是唯一的整数,标识预测符号的反向字典中的索引。比如预测是 37,预测的符号其实是“理事会”。

输出的生成听起来可能很简单,但实际上 LSTM 为下一个由 softmax()函数归一化的符号生成一个 112 元素的预测概率向量。具有最高概率的元素的索引是符号在反向字典中的预测索引(即一个热码向量)。图 2 显示了这个过程。

图二。每个输入符号被其分配的唯一整数替换。输出是识别反向字典中预测符号的索引的独热向量。

该应用程序的核心是 LSTM 模型。令人惊讶的是,在 Tensorflow 中实现非常简单:

**def** RNN(x, weights, biases):

    *# reshape to [1, n_input]* x = tf.reshape(x, [-1, n_input])

    *# Generate a n_input-element sequence of inputs
    # (eg. [had] [a] [general] -> [20] [6] [33])* x = tf.split(x,n_input,1)

    *# 1-layer LSTM with n_hidden units.* rnn_cell = rnn.BasicLSTMCell(n_hidden)

    *# generate prediction* outputs, states = rnn.static_rnn(rnn_cell, x, dtype=tf.float32)

    *# there are n_input outputs but
    # we only want the last output* **return** tf.matmul(outputs[-1], weights[**'out'**]) + biases[**'out'**]

清单 3。具有 512 单位 LSTM 单元的模型

最棘手的部分是以正确的格式和顺序输入。在这个例子中,LSTM 以 3 个整数的序列为食(例如 int 的 1x3 向量)。

常数、权重和偏差是:

vocab_size = len(dictionary)
n_input = 3*# number of units in RNN cell* n_hidden = 512*# RNN output node weights and biases* weights = {
    **'out'**: tf.Variable(tf.random_normal([n_hidden, vocab_size]))
}
biases = {
    **'out'**: tf.Variable(tf.random_normal([vocab_size]))
}

清单 4。常数和训练参数

在训练过程中,在每一步,从训练数据中检索 3 个符号。这 3 个符号被转换成整数以形成输入向量。

symbols_in_keys = [ [dictionary[ str(training_data[i])]] **for** i **in** range(offset, offset+n_input) ]

清单 5。符号到 int 的向量作为输入

训练标签是来自 3 个输入符号之后的符号的独热向量。

symbols_out_onehot = np.zeros([vocab_size], dtype=float)
symbols_out_onehot[dictionary[str(training_data[offset+n_input])]] = 1.0

清单 6。一键向量作为标签

在重新调整以适合提要字典后,优化运行:

_, acc, loss, onehot_pred = session.run([optimizer, accuracy, cost, pred], feed_dict={x: symbols_in_keys, y: symbols_out_onehot})

清单 7。训练步骤优化

累积准确度和损失以监控训练的进度。50,000 次迭代通常足以达到可接受精度。

...
Iter= 49000, Average Loss= 0.528684, Average Accuracy= 88.50%
['could', 'easily', 'retire'] - [while] vs [while]
Iter= 50000, Average Loss= 0.415811, Average Accuracy= 91.20%
['this', 'means', 'we'] - [should] vs [should]

清单 8。每次训练的样本预测和准确性数据(1000 步)

成本是使用 RMSProp 以 0.001 的学习率优化的 label 和 softmax()预测之间的交叉熵。在这种情况下,RMSProp 的性能通常优于 Adam 和 SGD。

pred = RNN(x, weights, biases)

*# Loss and optimizer* cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
optimizer = tf.train.RMSPropOptimizer(learning_rate=learning_rate).minimize(cost)

清单 9。损失和优化器

LSTM 的精确度可以通过附加层来提高。

rnn_cell = rnn.MultiRNNCell([rnn.BasicLSTMCell(n_hidden),rnn.BasicLSTMCell(n_hidden)])

清单 10。改进的 LSTM

现在,有趣的部分。让我们通过反馈预测的输出作为输入中的下一个符号来生成一个故事。这个示例输出的输入是“had a general ”,它预测正确的输出是“council”。“理事会”作为新输入的一部分反馈给“总理事会”,以预测新的输出“到”,以此类推。令人惊讶的是,LSTM 创造了一个莫名其妙的故事。

had a general council to consider what measures they could take to outwit their common enemy , the cat . some said this , and some said that but at last a young mouse got

清单 11。示例故事生成的故事。被截断为最多 32 个预测。

如果我们输入另一个序列(例如“老鼠”,“老鼠”,“老鼠”),但不一定是故事中的序列,另一个叙事就会自动产生。

mouse mouse mouse , neighbourhood and could receive a outwit always the neck of the cat . some said this , and some said that but at last a young mouse got up and said

清单 12。故事中找不到带有序列的输入。

实际的示例代码可以在这里找到。示例文本文件是这里的

最终注释:

  1. 使用 int 对符号进行编码很容易,但是单词的“含义”却丢失了。Symbol to int 用于简化关于使用 Tensorflow 构建 LSTM 应用程序的讨论。Word2Vec 是将符号编码为矢量的更优方式。
  2. 输出的一键向量表示是低效的,尤其是当我们有一个真实的词汇量时。牛津词典有超过 17 万个单词。上面的例子有 112 个。同样,这只是为了简化讨论。
  3. 这里使用的代码是受 Tensorflow-Examples 的启发。
  4. 本例中的输入数是 3,看看使用其他数字(例如 4、5 或更多)时会发生什么。
  5. 每次运行代码可能会产生不同的结果和预测能力,因为准确性取决于参数的初始随机值。更高的训练步数(超过 150,000)可以获得更好的精度。预计每次运行也会有不同的字典。
  6. Tensorboard 在调试中非常有用,尤其是在判断代码是否正确构建了图形时。
  7. 尝试使用另一个故事,尤其是使用不同的语言。

LSTM——实际应用的金块

原文:https://towardsdatascience.com/lstm-nuggets-for-practical-applications-5beef5252092?source=collection_archive---------2-----------------------

keras functional API 中的代码示例

什么是 LSTM?

LSTM 代表长短期记忆,意思是短期记忆在长时间内保持在 LSTM 细胞状态。LSTM 通过克服 simpleRNN 架构中典型的消失梯度问题实现了这一点。

LSTM 的记忆单位和细胞状态是什么?

LSTMs 是递归网络,其中每个神经元由一个 存储单元 代替。存储单元包含一个具有循环自连接的实际神经元。记忆单元内那些神经元的激活被称为 LSTM 网络的 细胞状态

那么 LSTM 是如何维持其细胞状态和隐藏状态的呢?

随着更多的新信息输入到 LSTM,LSTM 的门控结构允许它学习三个基本的东西(即,在每个时间步,存储单元接收来自其他存储单元的输入,并计算以下内容)

Cell state of LSTM

  • 需要保留的记忆(即,保留多少神经元先前的激活)。该信息在 单元状态 中更新
  • 由于新信息的到来,它的内存需要更新多少(也就是说——将多少输入转发给实际的神经元——注意,这些信息也在 细胞状态 中得到更新

Hidden state computed from its cell state

  • 下一个时间步需要读取多少内存(也就是说,需要输出多少激活)。正如我们从下图中看到的,我们计算内存单元的输出,方法是获取其状态,应用激活函数,然后将结果乘以表示输出多少激活的输出门。来自所有存储单元的输出向量是 LSTM 网络的输出。这就是通常所说的LSTM 的隐藏状态。 简单来说——细胞状态和隐藏状态不过是利用神经元的权重、偏置和激活计算出来的向量。

GRU ( outputs its memory state directly)

顺便提一下,在类似的 GRU 网络中,存储单元直接输出它们的状态。

我们在定义 LSTM 时指定的超参数是 存储单元数量(也称为单元大小)

我们可以在任何时间步长从 LSTM 获得以下输出——当前单元格状态、当前隐藏状态及其当前隐藏状态作为其当前输出。我们在 Keras 中这样做的方法是指定—

  • return_states = True 用于获取单元格状态和隐藏状态
  • return_sequences = True 用于获取当前时间步的输出

some_LSTM = LSTM(256,return_sequences=True,return _ state = True) 输出,隐藏 _ 状态,单元格 _ 状态 = some_LSTM(输入)

要送入 LSTM 的输入数组应该是三维的。让我们在将几行句子输入到 LSTM 的上下文中来看这个问题,其中每个句子都是单词的集合,句子的大小可以是固定的/可变的。

  • 第一个维度是我们语料库中的句子数量。
  • 第二维指定时间步长的数量。在这种情况下,时间步长可以被视为特定句子中的单词数*(假设每个单词都被转换为一个向量)。否则可以是句子中的字符数(假设每个字符都转换成一个向量)*。还要注意,这可以是固定长度或可变长度,因为每个句子可以有不同数量的单词/字符。我们可以通过在任何需要的地方用零填充所有的序列来使这个长度固定。
  • 第三维指定特征的数量。例如,它可以是语料库中的单词数,或者在我们进行字符级翻译的情况下,它可以是字符数。

但是当我们定义 LSTM 的输入形状时,我们只将其定义为 2D,而不是 3D — 我们没有指定样本的数量或批次大小 。我们只指定时间步长的数量和特征的数量。在 keras 中,我们将其定义为—

  • 输入(shape=(nb_timesteps,nb_features))。如上所述,nb_timesteps 可以对应于输入数组的固定或可变序列长度。如果我们希望它是一个可变长度,那么我们指定这个为 None。 那样的话,就要 输入(shape=( None ,nb_features))。

当时间步长的数量为 无、 时,LSTM 将动态展开时间步长,直到到达序列的末尾。这是典型的涉及编码器-解码器网络的神经机器翻译架构。

我们可以在输入时用初始状态初始化 LSTM。这也是典型的编码器-解码器架构,其中解码器 LSTM 需要用最终的编码器单元状态和隐藏状态进行初始化。在这种情况下,我们将 intial_state 参数与输入一起传递。

  • 解码器 _LSTM(解码器 _ 输入,初始 _ 状态=编码器 _ 状态)

琉米爱尔伦敦 2018(第三部分):计算机视觉

原文:https://towardsdatascience.com/lumiere-london-2018-part-3-computer-vision-d4918effff4?source=collection_archive---------18-----------------------

第三部分:用计算机视觉分析 5000 张 Flickr 图片

介绍

在这一系列的最后一篇博客文章中,我应用计算机视觉技术来理解 5000 张关于琉米爱尔伦敦 2018 的 Flickr 图像,这是今年 1 月初在伦敦举行的一场大型灯光节。

在 2018 年伦敦琉米爱尔展期间,53 位艺术家的 50 多件公共艺术品在伦敦的六个区展出,为期四天,从 1 月 18 日星期四到 1 月 21 日星期日,超过 100 万人参加了这个节日!

在本系列的第二部分第一部分中,我展示了自然语言处理和对 11000 条关于这个节日的推文的探索性数据分析。

本文的目的是使用计算机视觉分析来理解我从 Flickr 上传的 5000 张图片,并把它们放在上下文中。

请向下滚动查看分析!

An image of Lumiere London 2018. Source: Flickr

数据和方法

使用 Flickr API ,它使用起来相当简单,我收集了包含文本“琉米爱尔伦敦”的图像,这些图像是在 2018 年 1 月 1 日至 4 月 1 日之间上传到 Flickr 上的。总共有 5047 张图片。

然后,使用谷歌云的视觉 API 提取每张图像的标签。Cloud Vision API 利用“谷歌庞大的机器学习专业知识网络”(g reat article 作者 Sara Robinson )来检测图像的特征和标签。总共,5047 张图片被赋予了 487 个不同的标签。

被称为特征提取反向图像搜索的机器学习技术然后使用基因科岗的代码来基于视觉相似性找到图像。首先,使用预训练的卷积神经网络来提取每幅图像的“特征”,然后,计算这些特征的余弦相似度,以“搜索”少量与查询图像相似的图像。

特征在计算机视觉中的主要作用是“将视觉信息转换到向量空间”。相似的图像应该产生相似的特征,我们可以利用这些特征进行信息检索。基于这些特征,我们还可以通过使用一种叫做 t-SNE 的方法来对图像进行相似性聚类。

An image of Lumiere London 2018. Source: Flickr

图像分析

在这一节中,我将展示我的计算机视觉分析的结果。下面,我报告以下三个指标:

  1. 图像的标签检测;
  2. 基于视觉相似性的图像搜索:
  3. 基于视觉相似性的图像聚类。

标签检测

每张照片的标签都是使用谷歌云视觉 API 生成的。这背后的想法是将图片分类,这样我就可以识别相似的图片。下面的条形图显示了 5,000 幅图像的前 10 个标签。

我们看到“夜”和“光”出现的次数最多。这些标签很有意义,因为这是一个灯光装置的夜晚节日!然而,它们没有明确描述艺术品本身,这突出了一些标签检测技术的缺点。

Figure 1: label count of 5,000 images of Lumiere London 2018. Source: Flickr

为图像生成标签在各种其他应用程序中非常有用,例如训练机器学习模型或构建推荐系统,但对于这篇文章来说,它们没有那么有用。

不可否认,我没有最大限度地使用 vision API 这篇由 Sara Robinson 撰写的文章突出了 API 的许多伟大特性——这可能是因为调用 API 是有成本的!

图像搜索—视觉相似度

我们可以通过编程让计算机学习图像之间的视觉相似性,而不是使用标签来理解图像。一种叫做特征提取反向图像搜索的技术就是这样做的。

使用在 TensorFlow 后端上运行的 Keras VGG16 神经网络模型,我首先为数据集中的每张图像提取了一个特征。一个特征是每个图像的 4096 元素的数字数组。我们的期望是“该特征形成图像的非常好的表示,使得相似的图像将具有相似的特征”(吉恩·科岗,2018 )。

然后使用主成分分析(PCA)降低特征的维度,以创建一个嵌入,然后计算一个图像的 PCA 嵌入到另一个图像的距离余弦距离。我终于能够向计算机发送随机查询图像,它选择并返回数据集中具有相似特征向量的五个其他图像。

下面是三个例子:

A reverse image search for Reflecktor by Studio Roso at Lumiere London 2018

A reverse image search for Illumaphanium by Michael David and Cosmoscope by Simeon Nelson at Lumiere London 2018

当试图从一个有一百万张图片的相册中找到相似的图片时,这种技术非常有用!

图像聚类—相似性

既然我们在向量空间中嵌入了每个图像,我们可以使用一种流行的叫做 t-SNE 的机器学习可视化算法来聚类,然后在二维空间中可视化向量空间。

“tSNE 的目标是聚集相似数据点的小“邻域”,同时减少数据的整体维度,以便更容易可视化”(谷歌人工智能博客,2018 年)

下面我们看到基于视觉相似性的聚类形成。

The clustering of images of Lumiere London 2018. Source: Flickr

在下图中,我重点展示了三件艺术品——圣詹姆斯教堂的克里斯·普兰特的 Harmonic Portal,粮仓广场的金奎大·鲁斯加德Waterlicht,威斯敏斯特教堂的帕特里斯·沃伦纳The Light of The Spirit——以及它们的集群剖面。

The clustering of images of three art installations at Lumiere London 2018. Source: Flickr

结论

所以你有它!我只是刚刚涉足计算机视觉的奇妙世界。还有很多东西需要我去学习,但这对我来说是很好的第一步。

我的发现表明,使用机器学习和计算机视觉技术来理解和联系琉米爱尔伦敦 2018 灯光节的图像是可能的。

对我来说,下一步显然是计算在数据集中出现了多少艺术装置,以衡量“受欢迎程度”。我将继续研究这个数据集。

An image of Lumiere London 2018. Source: Flickr

结束了!

这是我关于琉米爱尔伦敦 2018 系列博客的结尾!这个系列是我正在进行的关于使用数据科学来理解和衡量城市文化影响的长期讨论的一部分。

明年,我将开始新的项目,在那里我将主要使用 JavaScript。敬请期待!

感谢阅读!

Vishal

Vishal 是伦敦 UCLThe Bartlett的文化数据科学家和研究生。他对城市文化的经济和社会影响感兴趣。

演示中的登月

原文:https://towardsdatascience.com/lunar-landings-from-demonstrations-27b553b00ce2?source=collection_archive---------10-----------------------

深度强化学习算法在许多问题上取得了显著的成果,这些问题曾经被认为在没有人类直觉和创造力的帮助下无法解决。RL 代理可以在没有任何事先指导的情况下学习掌握像象棋复古视频游戏这样的任务——通常超过甚至最伟大的人类专家的表现。但是这些方法效率很低,并且依赖于在取得任何进展之前从数百甚至数千次完全失败中学习。当任务简单或可以模拟时,这是我们可以负担得起的奢侈品,如 Atari 屏幕或棋盘,但至少是 RL 相对较短的现实世界应用程序列表的部分原因。例如,让自动驾驶算法通过将一辆真正的汽车撞上一堵真正的墙来学习,可能需要 1000 次迭代才能弄清楚刹车的作用,或者通过撞毁前 500 次来学习着陆火箭,这将是极其危险、昂贵和时间效率低下的。

如果我们能够快速度过灾难性失败的早期阶段,让代理从第一次尝试就开始在真实世界中学习,那就太好了。一种方法是让代理在任务的模拟版本中度过它的失败阶段,其中它的行为不会产生后果。这很好,但大多数应用程序没有完美的模拟器,将学习从简化的类似游戏的环境转移到现实世界会带来许多问题(源于神经网络没有我们喜欢给它们的信用那样好的概括,并且经常不能理解两个领域之间的微妙差异)。然而,许多任务确实有近乎完美的控制者的例子——一个可以提供演示数据来指导代理尽早并经常成功的专家。

这就是 深度 Q-示范学习 中给出的解决方案。他们的算法是一种叫做 DQfD 的深度 Q 网络(DQN)的模仿学习变体。

DQfD 的工作原理是在标准 TD 误差的基础上增加一个模拟损耗。在预训练 *阶段,*代理从专家的演示中取样转换,并被激励在任何给定状态下复制专家的动作。

The large-margin classification loss used to push the agent’s actions towards the expert. l(ae, a) is a zero matrix with positive entries where the agent chooses an action that the expert did not recommend.

一旦预训练完成,代理开始自己与环境交互,生成自己的转换并探索更大的状态空间。因此,损失是监督、单步和n-步 TD 误差的组合。这是这项技术相对于其他模仿学习方法的真正优势;大多数模仿者只是希望成为演示者的淡化版本,但 DQfD 将学习加速到专家的水平,然后利用标准 DQN 的成功,试图超越这一基准。

代理将自己的经验和专家的经验一起存储在重放缓冲区中,使用优先经验重放来使演示的权重高于自己的数据。在每一个训练步骤中,它都按照优先级进行采样,确保将自生成过渡的模仿损失设置为 0。当重放缓冲区填满时,它只覆盖自己的数据,而演示则保持不变。

示例:月球着陆器中更安全的初始控制

我们可以用一个玩具问题来思考这个研究方向可能产生的潜在影响。

LunarLander-v2

LunarLander Gym 环境要求一个装备有主、左、右侧引擎的航天器在一个被随机生成的地形包围的目标区域着陆。状态空间是连续的,是ℝ⁸中的一个向量,有一个离散的动作空间{什么都不做,左引擎,右引擎,主引擎}。回报是到目标的距离、速度和燃油消耗的函数,着陆成功或不成功都有一个正(或负)常数。

起动性能

这里的想法是使用可用于训练新的 ML 代理的专家控制器,并且在大多数真实世界应用中,这将意味着使用人类专家。但它也可能是另一个人工代理,在这种情况下,是一个优先双决斗(PDD) DQN 给予足够的时间来训练:

Prioritized Double Dueling performance over the first 15k episodes. Note that the reward is modified from the raw environment using a log scale that overcomes some of the shortcomings of DQN’s reward clipping approach. (See the DQfD paper for details).

虽然它的最终性能可能足够好,但 PDD DQN 花费了前几千次尝试将着陆器粉碎。这是处于试错优化问题核心的探索/开发冲突的产物。该实验使用了一种e-贪婪方法,该方法将贪婪(当前最佳)行为的概率指定为:

Where |A(s)| is the size of the action space

根据以下因素选择次优措施:

这保证了探索…和彻底的失败。这就是演示数据如此有价值的原因:DQfD 可以快速了解专家的政策,而无需自己去摸索。代替从 1.0 开始的退火的ε值,我们可以使用一个仅仅 0.01 的常量值,这让它探索刚好足以超过演示者的性能。

DQfD 从它与“真实”环境的第一次交互中成功着陆——绕过了伴随成千上万次重复失败而来的所有障碍。预训练阶段的采样效率也非常高:初始差距是在大约 50k 的演示样本上仅进行 15k 预训练步骤的结果。即使是雅达利上使用的大型卷积网络,也只需要 750k 步。

DQfD in action

这种方法带来的一个挑战是,在预训练过程中,演示内容往往会过多。此时,网络开始牺牲其在整个输入空间中进行归纳的能力,以支持训练集中特定示例的高准确性。从语音识别到语言建模和图像分类,这几乎是每个监督学习应用中的一个问题。显而易见的答案是扩大训练集,在大数据世界中,大多数时候这就像听起来那么简单。但是我们不太可能有同样源源不断的数据用于模仿学习,尤其是当我们需要人类示范者的时候;这些数据并不便宜。DQfD 必须找到另一个答案,这是一个精心调整的数量 l2 正则化,惩罚大的权重变化,以努力防止网络在演示集的损失中追逐每个局部最小值。

l2 regularization over the first 15K episodes

这里,调整正则化项,而其他超参数是固定的。高系数导致不适合,损害初始性能并减缓/破坏整体学习进度,而适当调整的值让网络紧密结合演示数据,而不会在有机会驾驶着陆器时崩溃。

样品效率和难探索问题

Pretraining length makes almost no difference on a problem of this difficulty; DQfD learns the expert’s actions in as few as 15 thousand steps.

月球着陆器是使用 DQfD 几乎瞬间解决相对简单的探索问题的一个例子,但它也可以用于在真正的回报信号很少时通过给网络一些东西来最小化,从而在传统方法无望的问题上取得进展。这实际上是这篇文章的主要焦点,在像 Pitfall 这样的游戏上运行测试!英雄。事实上,一种更先进的算法叫做 Ape-X DQfD 是第一个完成著名的艰苦探索游戏蒙特祖马的复仇的 RL 代理。

(Video originally posted here on YouTube)

( 有趣读一读有多大关系 )

这种 TD/模仿混合技术的另一个影响是它加速训练周期的能力。预训练阶段可以从每次训练中节省数百万个时间步和几个 GPU 小时,这将超过超参数网格搜索或扫描大型问题集(就像 ALE 中的所有 60 款 Atari 游戏)。例如,论文发现,在他们测试的 Atari 游戏上,DQfD 比 DQN 节省了大约8300 万帧。

DQfD saving millions of timesteps in Asteroids

一个足够大的重放缓冲区将把模仿损失推到接近 0,基本上将 DQfD 降低到一个超采样效率的 DQN。DeepMind 甚至表明,该算法可以快速启动人类演示,并且仍然足够灵活,可以转向它从零开始时会发现的非人类策略——这意味着这种方法甚至可以在已知演示者的策略不太完美的情况下工作。

Agents typically beat Road Runner using a very non-human gameplay strategy. DQfD uses human demonstrations to increase learning speed, but is still able to find that ‘exploit’. (Demo data average was ~20k.)

你也可以让重放缓冲覆盖演示,在这种情况下,你会有一个更复杂版本的重放缓冲峰值技术。

你可以在 Github 上访问这个项目的源代码。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

杰克·格雷斯比 休·琼斯

弗吉尼亚大学骑士机器学习

www.cavml.com

M2M 第 185 天:我试图直观地解释自动驾驶汽车算法是如何工作的

原文:https://towardsdatascience.com/m2m-day-185-my-attempt-to-intuitively-explain-how-this-self-driving-car-algorithm-works-7422eb2b135e?source=collection_archive---------7-----------------------

这篇文章是为期 12 个月的加速学习项目月掌握的一部分。今年五月,我的目标是打造无人驾驶汽车的软件部分

昨天,我想出了如何在道路的前向图像中识别车道线。嗯……我至少知道了如何运行能做到这一点的代码。

The output from yesterday

老实说,我不明白代码实际上是如何工作的,所以今天我试图改变这一点。

下面是我昨天使用的主要代码块。特别是,我复制了主要的函数,这个函数叫做**“draw _ lane _ lines”**。基本上,函数是一个代码块,它接受一些输入(在本例中是一张照片),以某种方式操作输入,然后输出操作(在本例中是车道线)。

这个主函数使用了一些在代码中其他地方定义的其他辅助函数,但是这些辅助函数大多只是使用我昨天下载的库中的预制函数(例如 OpenCV)的稍微干净的方式。

def draw_lane_lines(image): imshape = image.shape

   ** # Greyscale image**
    greyscaled_image = grayscale(image)

    **# Gaussian Blur**
    blurred_grey_image = gaussian_blur(greyscaled_image, 5)

   ** # Canny edge detection**
    edges_image = canny(blurred_grey_image, 50, 150)

    **# Mask edges image**
    border = 0
    vertices = np.array([[(0,imshape[0]),(465, 320), (475, 320), 
    (imshape[1],imshape[0])]], dtype=np.int32)
    edges_image_with_mask = region_of_interest(edges_image, 
    vertices)

    **# Hough lines**
    rho = 2 
    theta = np.pi/180 
    threshold = 45    
    min_line_len = 40
    max_line_gap = 100 
    lines_image = hough_lines(edges_image_with_mask, rho, theta,  
    threshold, min_line_len, max_line_gap) **# Convert Hough from single channel to RGB to prep for weighted**
    hough_rgb_image = cv2.cvtColor(lines_image, cv2.COLOR_GRAY2BGR)

    **# Combine lines image with original image**
    final_image = weighted_img(hough_rgb_image, image)

    return final_image

粗体注释是对图像处理流水线主要部分的描述,这基本上意味着这是为了输出车道线而对输入图像顺序执行的七个操作。

今天,我的目标是了解这七个步骤中的每一个都做了什么,以及为什么要使用它们。

实际上,我只关注前五个,它们输出车道线的数学表示。最后两个操作只是创建了视觉效果,因此我们人类可以在视觉上欣赏数学(换句话说,当自动驾驶汽车实际消耗输出的数据时,这些步骤是不必要的)。

因此,基于我今天的研究,我现在将试图解释以下图像处理事件的顺序:输入图像→ 1。灰度图像,2。高斯模糊,3。Canny 边缘检测,4。遮罩边缘图像,5。霍夫线→车道线输出

输入图像

这是开始的输入图像。

重要的是要记住,图像只不过是一堆排列成矩形的像素。这个特殊的矩形是 960 像素乘 540 像素。

每个像素的值是红色、绿色和蓝色的某种组合,由三个一组的数字表示,其中每个数字对应一种颜色的值。每种颜色的值可以从 0 到 255,其中 0 表示完全没有颜色,255 表示 100%强度。

例如,白色表示为(255,255,255),黑色表示为(0,0,0)。

因此,这个输入图像可以用 960 x 540 = 518,400 个三元组数字来描述,范围从(0,0,0)到(255,255,255)。

现在这个图像只是一个数字的集合,我们可以开始使用 math 以有用的方式操作这些数字。

1.灰度图像

第一个处理步骤是将彩色图像转换为灰度,有效地将彩色空间从三维降级为一维。只在一维上操作图像更容易(也更有效):这一维是像素的“暗度”或“强度”,0 代表黑色,255 代表白色,126 代表某种中间灰色。

凭直觉,我认为灰度过滤器只是一个将红色、蓝色和绿色值平均在一起得到灰度输出的函数。

举个例子,这是原始照片中天空的颜色:

它可以在 RGB(红、绿、蓝)空间中表示为(120,172,209)。

如果我将这些值平均在一起,我得到(120 + 172 + 209)/3 = 167,或者灰度空间中的这个颜色。

但是,事实证明,当我使用上述函数将这种颜色转换为灰度时,实际输出的颜色是 164,这与我使用简单的平均方法生成的颜色略有不同。

虽然我的方法本身并不“错误”,但常用的方法是计算一个更符合我们眼睛感知颜色的加权平均值。换句话说,由于我们的眼睛有比红色或蓝色受体更多的绿色受体,绿色的值应该在灰度函数中占更大的权重。

一种常见的方法,称为色度转换,使用这种加权和: 0.2126 红色+ 0.7152 绿色+ 0.0722 蓝色。

通过灰度过滤器处理原始图像后,我们得到以下输出…

2。高斯模糊

下一步是模糊图像使用高斯模糊

通过应用轻微的模糊,我们可以从图像中移除最高频率的信息(也就是噪声),这将为我们提供“更平滑”的颜色块,以便我们进行分析。

同样,高斯模糊的基本数学是非常基本的:模糊只是取更多像素的平均值(这种平均过程是一种类型的内核卷积,对于我将要解释的内容来说,这是一个不必要的花哨名称)。

基本上,要生成模糊,您必须完成以下步骤:

  1. 选择照片中的像素并确定其值
  2. 查找所选像素的局部相邻像素的值(我们可以任意定义这个“局部区域”的大小,但它通常相当小)
  3. 取原始像素和相邻像素的值,并使用某种加权系统对它们进行平均
  4. 用输出的平均值替换原始像素的值
  5. 对所有像素都这样做

这个过程本质上是在说*“让所有的像素和附近的像素更相似”*,直观上听起来像是模糊。

对于高斯模糊,我们简单地使用高斯分布(即钟形曲线)来确定上面步骤 3 中的权重。这意味着像素离所选像素越近,其权重就越大。

无论如何,我们不想让图像变得太模糊,但只要足够让我们可以从照片中移除一些噪声即可。以下是我们得到的结果…

3。Canny 边缘检测

现在我们有了一个灰度和高斯模糊的图像,我们将试着找到这张照片中所有的边缘。

边缘仅仅是图像中值突然跳跃的区域。

例如,在灰色道路和虚白线之间存在清晰的边缘,因为灰色道路可能具有类似 126 的值,白线具有接近 255 的值,并且在这些值之间没有逐渐过渡。

同样,Canny 边缘检测滤波器使用非常简单的数学方法来寻找边缘:

  1. 选择照片中的像素
  2. 确定所选像素左侧和右侧像素组的值
  3. 取这两组之间的差值(即从另一组中减去一组的值)。
  4. 将所选像素的值更改为步骤 3 中计算的差值。
  5. 对所有像素都这样做。

所以,假设我们只看到了所选像素左边和右边的一个像素,并想象这些是值:(左像素,所选像素,右像素)= (133,134,155)。然后,我们将计算左右像素之间的差值,155–133 = 22,并将所选像素的新值设置为 22。

如果所选像素是边缘,则左右像素之间的差值将更大(接近 255),因此在输出的图像中将显示为白色。如果所选像素不是边缘,差值将接近 0,并显示为黑色。

当然,您可能已经注意到,上述方法只能找到垂直方向的边缘,因此我们必须执行第二个过程,比较所选像素上方和下方的像素,以处理水平方向的边缘。

这些差异被称为梯度,我们可以通过本质上使用毕达哥拉斯定理来计算总梯度,以相加来自垂直和水平梯度的单独贡献。换句话说,我们可以说总梯度=垂直梯度+水平梯度

所以,比如说垂直渐变= 22,水平渐变= 143,那么总渐变= sqrt(22 +143 ) = ~145。

输出看起来像这样…

Canny 边缘检测滤波器现在又完成了一步。

Canny 边缘检测过滤器并不仅仅显示所有边缘而是试图识别重要边缘。**

为此,我们设置了两个阈值:高阈值和低阈值。假设高门槛 200,低门槛 150。

对于任何值大于高阈值 200 的总梯度*,该像素自动被视为边缘并转换为纯白(255)。对于任何小于低阈值 155 的总渐变,该像素自动被视为“不是边缘”,并转换为纯黑色(0)。*

对于 150 到 200 之间的任何渐变,只有当像素直接接触另一个已经被计为边缘的像素时,该像素才被计为边缘。

这里的假设是,如果这个软边连接到硬边*,那么它很可能是同一个对象的一部分。*

在对所有像素完成这个过程后,我们得到一个看起来像这样的图像…

4。掩模边缘图像

下一步非常简单:创建一个遮罩,消除照片中我们认为没有车道线的所有部分。

我们得到了这个…

这似乎是一个相当激进和放肆的面具,但这是目前在原始代码中写的。所以,继续前进…

5。霍夫莱恩斯

最后一步是使用霍夫变换找到车道线的数学表达式。

霍夫变换背后的数学比我们上面做的所有加权平均的东西稍微复杂一点,但仅仅是一点点。

这是基本概念:

直线的等式是 y = mx + b,其中 m 和 b 是常数,分别表示直线的斜率和直线的 y 截距。

本质上,为了使用霍夫变换,我们确定 m 和 b 的一些二维空间。此空间代表我们认为可能为车道线生成最佳拟合线的 m 和 b 的所有组合。

然后,我们在 m 和 b 的空间中导航,对于每一对(m,b ),我们可以为 y = mx + b 形式的特定线确定一个方程。此时,我们希望测试这条线,因此我们找到照片中位于这条线上的所有像素,并要求他们投票这是否是对车道线的良好猜测。如果像素是白色的(也就是边的一部分),它会投“是”,如果是黑色的,它会投“否”。

获得最多投票的(m,b)对(或者在这种情况下,获得最多投票的两对)被确定为两条车道线。

这是霍夫变换的输出…

我跳过了这一部分,霍夫变换不是使用公式 y = mx + b 来表示直线,而是使用极坐标/三角式表示,使用 rhotheta 作为两个参数。

这种区别不是非常重要(对我们的理解来说),因为空间仍然是二维参数化的,逻辑完全相同,但这种三角表示法确实有助于解决我们无法用 y = mx + b 方程表达完全垂直线的事实。

无论如何,这就是为什么在上面的代码中使用了 rhotheta 的原因。

最终输出

我们结束了。

程序输出两个参数来描述两条车道线(有趣的是,这些输出被转换回 m,b 参数化)。该程序还提供了每条车道线端点的坐标。

车道线 1

斜率:-0.740605727717;截距:6640 . 666866666667

第一点:(475,311)第二点:(960,599)

车道线 2

coef:-0.740605727717;截距:6640 . 666866666667

第一点:(475,311)第二点:(0,664)

将这些线叠加在原始图像上,我们看到我们已经使用基本的数学运算有效地识别了车道线。

阅读下一篇文章。阅读上一篇文章

Max Deutsch 是一名痴迷的学习者、产品制造者、为期个月以掌握的试验品,以及 Openmind 的创始人。

如果你想跟随 Max 长达一年的加速学习项目,请确保跟随这个媒介账户

M2M 第 189 天:我想我教会了我的电脑如何驾驶自动驾驶汽车。但是,我就是想不出如何证实这个事实。

原文:https://towardsdatascience.com/m2m-day-189-i-think-i-taught-my-computer-how-to-steer-a-self-driving-car-94292e1ca0ba?source=collection_archive---------8-----------------------

这篇文章是为期 12 个月的加速学习项目月掌握的一部分。今年五月,我的目标是打造无人驾驶汽车的软件部分

昨晚,在“绝望的编码坑”中溺死了几个小时后,我终于取得了一些前进的进展。

作为一个提醒,在过去的几天里,我一直在试图找到并运行可以根据道路的输入图像生成转向指令(为我的自动驾驶汽车)的代码。

经过几个小时的搜索和摆弄,我找到了一篇由英伟达(一家制造自动驾驶汽车硬件和软件的公司)的研究人员撰写的学术论文。

正如论文摘要中所述,他们设计的系统可以*“将单个前置摄像头的原始像素直接映射到转向命令”*。

这正是我需要的!

我随后在 Github 上找到了英伟达系统的 TensorFlow 实现,经过几次尝试,我实际上已经能够根据英伟达的一些数据来“训练模型”。

快速澄清一些术语:1。“模型”是描述如何将像素转换成转向指令的函数,以及 2。“训练模型”意味着使用机器学习技术迭代地改进这个函数。我将在以后的文章中更详细地解释这个过程。

无论如何,NVIDIA 的数据集包括 25 分钟逐帧分解的视频,其中每一帧都标有真实转向角度(即人类驾驶员使用的转向角度)。

Frame 45,522

在终端,我运行程序来训练模型,尽管有一些警告,它开始工作了:

在这个屏幕截图中,一个“步骤”描述了每次通过系统输入一部分数据进行训练。“纪元”只是一个包含多个步骤的更广泛的类别。

为了训练这个模型,我使用了 30 个时期,每个时期几十步。

截图中的“损失”描述了型号(或功能)的准确程度。从概念上讲,为了计算损失,将真实转向角与模型预测的转向角进行比较。差额越大,损失越大。

最终,当训练模型时,程序使用一些数学技巧(我将在以后的帖子中描述)来试图通过每个迭代步骤减少损失。

于是,“训练模型”不过是“减少损失”。

这是一个曲线图,X 轴是步长,Y 轴是损耗。(昨晚,使用一种叫做 Tensorboard 的东西,我的电脑在训练时绘制了这个)。

例如,在步骤 126,损失的值为 5.708。

而在步骤 3,241,几乎 6 小时后,损失具有明显更好的值 0.1615。

现在训练已经正式完成,模型现在理论上已经可以驾驶汽车了,超级酷。

当我今天下班回家时,我试图测试这个模型(又名“驾驶汽车”),看看它的表现如何。可悲的是,当我试图运行程序时,我得到了这个错误…

我花了整整一个小时试图克服这个问题,但似乎我下载的一些代码无法在 Mac 上运行(即使可以,我也找不到让它运行的方法)。

我有一个解决办法的想法,但它必须等到明天。

与此同时,我可以庆祝这样一个事实,即我(很可能)已经有了一个功能合理、经过训练的自动驾驶汽车模型,可以随时投入使用。希望明天,我能弄清楚如何实际使用它…

阅读下一篇。看了以前的帖子

马克斯·多伊奇是一名痴迷的学习者、产品建造者、为期个月以掌握的试验品,以及 Openmind 的创始人。

如果你想跟随 Max 长达一年的加速学习项目,请确保跟随这个媒介账户

M2M 第 191 天:解构自动驾驶汽车模型(基于我目前的知识)

原文:https://towardsdatascience.com/m2m-day-191-deconstructing-a-self-driving-car-model-based-on-my-current-knowledge-69def7e8e6c0?source=collection_archive---------6-----------------------

这篇文章是为期 12 个月的加速学习项目月掌握的一部分。今年五月,我的目标是打造无人驾驶汽车的软件部分

现在我已经有了可以工作的无人驾驶汽车代码(见昨天的视频),在接下来的几天里,我计划解构代码,并试图理解它到底是如何工作的。

今天,我将特别关注“模型”,它可以被认为是代码的部分:模型定义了如何将输入图像转换成转向指令。

今天我没有太多的时间,所以我不会完整地描述代码是如何工作的(因为我还不知道,还需要做大量的研究)。相反,我会对代码行的含义做一些假设,然后记录我需要进一步研究的开放性问题。

这将使我有条理地学习材料。

这是自动驾驶模型的完整代码。它只有 50 行代码加上注释和空格(这是相当疯狂的,因为它在驾驶汽车和其他东西……)

import tensorflow as tf
import scipydef weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)def conv2d(x, W, stride):
  return tf.nn.conv2d(x, W, strides=[1, stride, stride, 1], padding='VALID')x = tf.placeholder(tf.float32, shape=[None, 66, 200, 3])
y_ = tf.placeholder(tf.float32, shape=[None, 1])x_image = x**#first convolutional layer**
W_conv1 = weight_variable([5, 5, 3, 24])
b_conv1 = bias_variable([24])h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1, 2) + b_conv1)**#second convolutional layer**
W_conv2 = weight_variable([5, 5, 24, 36])
b_conv2 = bias_variable([36])h_conv2 = tf.nn.relu(conv2d(h_conv1, W_conv2, 2) + b_conv2)**#third convolutional layer**
W_conv3 = weight_variable([5, 5, 36, 48])
b_conv3 = bias_variable([48])h_conv3 = tf.nn.relu(conv2d(h_conv2, W_conv3, 2) + b_conv3)**#fourth convolutional layer**
W_conv4 = weight_variable([3, 3, 48, 64])
b_conv4 = bias_variable([64])h_conv4 = tf.nn.relu(conv2d(h_conv3, W_conv4, 1) + b_conv4)**#fifth convolutional layer**
W_conv5 = weight_variable([3, 3, 64, 64])
b_conv5 = bias_variable([64])h_conv5 = tf.nn.relu(conv2d(h_conv4, W_conv5, 1) + b_conv5)**#FCL 1**
W_fc1 = weight_variable([1152, 1164])
b_fc1 = bias_variable([1164])h_conv5_flat = tf.reshape(h_conv5, [-1, 1152])
h_fc1 = tf.nn.relu(tf.matmul(h_conv5_flat, W_fc1) + b_fc1)keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)**#FCL 2**
W_fc2 = weight_variable([1164, 100])
b_fc2 = bias_variable([100])h_fc2 = tf.nn.relu(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)h_fc2_drop = tf.nn.dropout(h_fc2, keep_prob)**#FCL 3**
W_fc3 = weight_variable([100, 50])
b_fc3 = bias_variable([50])h_fc3 = tf.nn.relu(tf.matmul(h_fc2_drop, W_fc3) + b_fc3)h_fc3_drop = tf.nn.dropout(h_fc3, keep_prob)**#FCL 4**
W_fc4 = weight_variable([50, 10])
b_fc4 = bias_variable([10])h_fc4 = tf.nn.relu(tf.matmul(h_fc3_drop, W_fc4) + b_fc4)h_fc4_drop = tf.nn.dropout(h_fc4, keep_prob)**#Output**
W_fc5 = weight_variable([10, 1])
b_fc5 = bias_variable([1])y = tf.mul(tf.atan(tf.matmul(h_fc4_drop, W_fc5) + b_fc5), 2)

逐行评论

现在,我将分块研究代码,并描述我认为每个块的意思/作用。

import tensorflow as tf
import scipy

前两行很简单。

我们正在导入 TensorFlow 库(我们将在代码的其他地方将其称为“tf ”)和 SciPy 库。TensorFlow 是由 Google 编写的 python 库,它将帮助抽象出大多数地面级机器学习实现。SciPy 会在数学方面帮忙。

这里没什么新东西可学。

def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

好的,这里我认为我们正在定义新的对象,这基本上意味着我们可以在代码的其他地方使用“weight_variable”和“bias_variable”的概念,而不必一次重新定义它们。

在机器学习中,我们试图求解的函数通常表示为 Wx+b = y,其中给定了 x(输入图像列表)和 y(对应的转向指令列表),想要找到 W 和 b 的最佳组合,使方程平衡。

w 和 b 实际上不是单一的数字,而是系数的集合。这些集合是多维的,并且这些集合的大小对应于机器学习网络中的节点数量。(至少,我现在是这么理解的)。

所以,在上面的代码中, weight_variable 对象代表 W, bias_variable 对象代表 b,在广义上。

这些对象接受一个称为“形状”的输入,它基本上定义了 W 和 b 的维数。

这些 W 和 b 对象由一个名为“normal”的函数初始化。我很确定这意味着…当最初创建 W 和 b 的集合时,单个系数的值应该基于标准偏差为 0.1 的正态分布(即钟形曲线)随机分配。标准偏差或多或少定义了我们希望初始系数有多随机。

所以,令人惊讶的是,我想我基本上理解了这段代码。乍一看,我不确定这是怎么回事,但写出来有助于我整理思绪。

**我还需要学习的:**我需要学习更多关于 Wx + b = y 结构的知识,为什么使用它,它是如何工作的,等等。,但我理解代码的基本原理。

def conv2d(x, W, stride):
  return tf.nn.conv2d(x, W, strides=[1, stride, stride, 1], padding='VALID')

我相信这个 conv2d 是一个对某些输入执行核卷积的函数。内核卷积是我几天前在中学到的一种更通用的图像操作。

就我而言,核卷积操纵图像来突出图像的某些特征,无论是图像的边缘、角落等等。

这个特殊的特征是由“内核”定义的,它似乎是用上面的步幅=[1,步幅,步幅,1] 定义的。虽然,我不知道大步是什么意思,也不知道这到底是怎么回事。

这个图像处理函数似乎有三个输入:1 .内核/步幅(说明如何操作图像);2.x(也就是图像本身);第三。w(我猜它是一组系数,用于在某种程度上将不同的图像操作混合在一起)。

我必须更多地了解 W 在这一切中的角色。

不过,在高层次上,该函数以某种方式操纵图像,以自动将图像缩减为更有助于训练模型的独特特征。

**我还需要学习的:**卷积函数在数学上到底是如何定义的,W 在其中又是如何发挥作用的?

x = tf.placeholder(tf.float32, shape=[None, 66, 200, 3])
y_ = tf.placeholder(tf.float32, shape=[None, 1])x_image = x

接下来的几行看起来很简单。我们再一次回到等式 Wx + b = y。

这里我们本质上是为 x 和 y 变量定义了占位符*。这些占位符设置了变量的维度(记住:这些变量代表一个值的集合,而不仅仅是一个数字)。*

我们将 x 设置为接收特定尺寸的图像,将 y 设置为输出一个数字(即转向角)。

然后我们把 x 改名为“x_image”来提醒自己,x 是一个图像,因为……为什么不是。

这里没什么新东西可学。

**#first convolutional layer**
W_conv1 = weight_variable([5, 5, 3, 24])
b_conv1 = bias_variable([24])h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1, 2) + b_conv1)

好了,我们现在进入第一个卷积层。

我们定义 W_conv1 ,它只是我上面解释的 weight_variable 的一个具体实例(用 shape [5,5,3,24])。我不确定这个形状是如何或为什么以这种特殊的方式设置的。

然后我们定义 b_conv1 ,它只是我上面解释的 bias_variable 的一个具体实例(具有形状[24])。这个 24 可能需要匹配 W_conv1 形状的 24,但我不确定为什么(除了这将有助于使矩阵乘法工作)。

h_conv1 是一个中间对象,它将卷积函数应用于输入 x_image 和 W_conv1,将 bconv1 添加到卷积的输出,然后通过一个名为 relu 的函数处理一切。

这个 relu 的东西听起来很熟悉,但是我不记得它到底是做什么的了。我的猜测是,这是某种“squasher”或规范化功能,在某种程度上平滑一切,无论这意味着什么。我得调查一下。

虽然我可以阅读大部分代码,但我不太确定为什么“卷积层”要以这种方式设置。

**我还需要学习的:**什么是卷积层,它应该做什么,它是如何做到的?

**#second convolutional layer**
W_conv2 = weight_variable([5, 5, 24, 36])
b_conv2 = bias_variable([36])h_conv2 = tf.nn.relu(conv2d(h_conv1, W_conv2, 2) + b_conv2)**#third convolutional layer**
W_conv3 = weight_variable([5, 5, 36, 48])
b_conv3 = bias_variable([48])h_conv3 = tf.nn.relu(conv2d(h_conv2, W_conv3, 2) + b_conv3)**#fourth convolutional layer**
W_conv4 = weight_variable([3, 3, 48, 64])
b_conv4 = bias_variable([64])h_conv4 = tf.nn.relu(conv2d(h_conv3, W_conv4, 1) + b_conv4)**#fifth convolutional layer**
W_conv5 = weight_variable([3, 3, 64, 64])
b_conv5 = bias_variable([64])h_conv5 = tf.nn.relu(conv2d(h_conv4, W_conv5, 1) + b_conv5)

我们继续有四个以上的卷积层,其功能与第一层完全相同,但不是使用 x_image 作为输入,而是使用来自前一层的输出(即 h_conv 的东西)。

我不确定我们是如何决定使用五层的,也不知道为什么每个 conv 的形状都不一样。

**我还需要学习的是:**为什么有五层,我们如何为每一层选择形状?

**#FCL 1**
W_fc1 = weight_variable([1152, 1164])
b_fc1 = bias_variable([1164])h_conv5_flat = tf.reshape(h_conv5, [-1, 1152])
h_fc1 = tf.nn.relu(tf.matmul(h_conv5_flat, W_fc1) + b_fc1)keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)**#FCL 2**
W_fc2 = weight_variable([1164, 100])
b_fc2 = bias_variable([100])h_fc2 = tf.nn.relu(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)h_fc2_drop = tf.nn.dropout(h_fc2, keep_prob)**#FCL 3**
W_fc3 = weight_variable([100, 50])
b_fc3 = bias_variable([50])h_fc3 = tf.nn.relu(tf.matmul(h_fc2_drop, W_fc3) + b_fc3)h_fc3_drop = tf.nn.dropout(h_fc3, keep_prob)**#FCL 4**
W_fc4 = weight_variable([50, 10])
b_fc4 = bias_variable([10])h_fc4 = tf.nn.relu(tf.matmul(h_fc3_drop, W_fc4) + b_fc4)h_fc4_drop = tf.nn.dropout(h_fc4, keep_prob)

接下来,我们有四个 fcl,我相信它们代表“全连接层”。

这些层的设置似乎类似于卷积步骤,但我不确定这里发生了什么。我认为这只是普通的神经网络的东西(我写它是为了假装我完全理解“普通的神经网络的东西”)。

不管怎样,我会更深入地调查这件事。

**我还需要学习的:**什么是 FCL,每个 FCL 步骤中发生了什么?

**#Output**
W_fc5 = weight_variable([10, 1])
b_fc5 = bias_variable([1])y = tf.mul(tf.atan(tf.matmul(h_fc4_drop, W_fc5) + b_fc5), 2)

最后,我们采用最终 FCL 层的输出,进行一些疯狂的三角运算,然后输出 y,即预测的转向角。

这一步似乎只是“把数学算出来”,但我不确定。

我还需要学习的:产量是如何以及为什么以这种方式计算的?

完成了。

这比预期的要长——主要是因为我能够解析的东西比预期的多。

TensorFlow 库抽象出了多少实现,而构建一个完全有能力的自动驾驶汽车模型所需的底层数学知识又是如此之少,这有点疯狂。

对于我们作为模型构造者来说,似乎唯一重要的事情就是如何设置模型的深度(例如层数)、每层的形状以及层的类型。

我的猜测是,这可能更像是一门艺术,而不是科学,但很可能是一门受过教育的艺术。

我明天开始钻研我的开放式问题。

阅读下一篇。看了以前的帖子

马克斯·多伊奇是一名痴迷的学习者、产品建造者、为期个月以掌握的试验品,以及 Openmind 的创始人。

如果你想跟随 Max 长达一年的加速学习项目,请确保跟随这个媒介账户

M2M 第 197 天:掉进兔子洞的悲伤旅程…

原文:https://towardsdatascience.com/m2m-day-197-a-sad-journey-down-the-rabbit-hole-325d48a515ee?source=collection_archive---------6-----------------------

这篇文章是为期 12 个月的加速学习项目月掌握的一部分。今年五月,我的目标是打造无人驾驶汽车的软件部分

今天是一个错误和障碍的可悲集合(没有快乐的结局)。当我试图挽回自己时,我在兔子洞里越陷越深。

昨天开始——我成功地重新格式化了 Udacity 数据,并开始训练自动驾驶汽车模型。

在模型完成训练后,我快速看了一下损失图(损失衡量模型的“准确性”——损失越低,模型越好……在大多数情况下)。

经过 30 个时期的训练,损失甚至没有下降到 1.00 以下,而当我根据英伟达的数据训练模型时,损失大幅下降到 1.00 以下,一直到大约 0.16。

我不确定为什么我期望发生一些不同的事情——我使用的 Udacity 数据集只有 NVIDIA 数据集的 1/8 大小。

这是我的第一个错误:我不小心使用了测试数据集来训练模型。相反,我应该使用大得多的训练数据集,然后在测试数据集上测试训练好的模型。

问题不大:我去了 Udacity Github 页面,下载了更大的数据集用于训练。或者,至少我尝试过。

下载到一半,我的电脑完全崩溃了。

原来我电脑的本地存储/启动盘完全满了。太满了,以至于我的电脑拒绝运行任何程序。甚至 Finder 也意外崩溃。

我插上我的外部硬盘,开始把我一个月的主文档从我的本地机器上转移出去。

顺便说一句,我不得不用手机给我的电脑屏幕拍照,因为我的电脑没有足够的空间来截图……

总之,前六个月的 M2M 文档超过了 132GB,其中 70.8 GB 在我的本地机器上,所以,一旦传输完成,我就可以将 70 GB 的本地文件转移到垃圾桶。

然后,在试图清空我的垃圾时,我的电脑死机了…

重启电脑几次后,我的垃圾终于清空了,30 分钟后,我又开始工作了。

现在我的电脑上有了空间,我回到 Udacity Github 页面下载训练数据集

训练数据集实际上是在 torrent 中压缩的,所以我需要安装 BitTorrent 来下载数据集。

种子下载后,我解压文件。我期望看到一堆 JPEG 图像和一个 data.txt 文件,就像我们之前看到的一样,但是相反,我看到了这个…

显然,Udacity 认为将数据打包在中是个好主意。包文件。我实际上从未听说过。之前的包文件,但似乎是自动驾驶汽车(或者其他“机器人”保存数据的原生方式。

因此,我需要找出如何从个人中提取 JPEGs 和 CSV。袋装文件。

有一个叫做 ROS(机器人操作系统)的库需要使用。包文件,所以我试图安装它。

但是,这是我在 ROS 安装页面上发现的…

换句话说,制作 ROS 的人基本上是在说*“这是行不通的。会失败的。不好意思。”*

他们是对的,它确实失败了。

然而,我花了更多的时间试图解决这个错误,最终看起来我已经成功地安装了我需要的所有东西。但是,后来我尝试运行提取脚本,仍然失败。

此时,我不得不停下来过夜。

明天,希望我能取得一些进步。

阅读下一篇。阅读上一篇文章

Max Deutsch 是一名痴迷的学习者、产品建造者、为期个月以掌握的试验品,以及 Openmind 的创始人。

如果你想跟随 Max 长达一年的速成学习项目,请确保跟随这个媒介账户

M2M 第 90 天——我如何使用人工智能来自动化 Tinder

原文:https://towardsdatascience.com/m2m-day-89-how-i-used-artificial-intelligence-to-automate-tinder-ced91b947e53?source=collection_archive---------2-----------------------

这篇文章是杰夫为期 12 个月的加速学习项目“掌握的一个月”的一部分对于 March,他正在下载构建人工智能的能力。

如果你有兴趣了解更多关于我的信息,请查看我的 网站

介绍

前几天,当我坐在马桶上拉屎时,我拿出手机,打开了所有马桶应用之王:Tinder。我点击打开应用程序,开始无意识滑动。

现在我们有了约会应用程序,与应用程序出现之前的时代相比,每个人突然都有机会与更多的人约会。湾区倾向于男性多于女性。湾区也吸引了来自世界各地的超级成功的聪明男人。作为一个额头很大、身高 5 英尺 9 英寸、不怎么拍照的亚洲男人,旧金山约会领域的竞争非常激烈。

通过使用约会应用程序与女性朋友交谈,旧金山的女性几乎每刷一次就能匹配到一次。假设女性在一小时内有 20 场比赛,她们没有时间去和每个给她们发信息的男人约会。显然,他们会根据个人资料+最初的信息来挑选他们最喜欢的男人。

我是一个相貌出众的人。然而,在亚洲男人的海洋中,纯粹基于长相,我的脸不会出现在页面上。在股票交易所,我们有买家和卖家。顶级投资者通过信息优势赚取利润。在牌桌上,如果你比牌桌上的其他人有技能优势,你就变得有利可图。如果我们认为约会是一个“竞争市场”,你如何给自己竞争优势?竞争优势可能是:惊人的外表、事业成功、社交魅力、冒险精神、接近、巨大的社交圈等等。

在约会应用上,在照片和短信技能上具有竞争优势的男性和女性将从应用中获得最高的投资回报率。因此,我将约会应用的奖励系统分解为一个公式,假设我们将消息质量从 0 到 1 标准化:

Credit: Me

你的照片越漂亮,你就越不需要写高质量的信息。如果你有糟糕的照片,不管你的信息有多好,没有人会回应。如果你有很棒的照片,一条机智的信息会显著提高你的投资回报率。如果你不刷卡,你的投资回报率为零。

虽然我没有最好的照片,但我的主要瓶颈是我没有足够高的点击量。我只是认为这种无意识的刷卡是在浪费我的时间,我更喜欢亲自去见人。然而,这样做的问题是,这种策略严重限制了我可以约会的人的范围。为了解决这个刷卡量问题,我决定建立一个自动化 tinder 的人工智能,名为:THE DATE-A MINER。

日期-矿工是一个人工智能,它学习我喜欢的约会配置文件。一旦它学习完我喜欢什么,约会矿工就会自动在我的 Tinder 应用程序上的每个个人资料上向左或向右滑动。因此,这将显著增加刷卡量,从而增加我的预计 Tinder 投资回报率。一旦我找到匹配,人工智能会自动给匹配者发送信息。

虽然这并没有给我照片方面的竞争优势,但这确实给了我点击量和初始信息方面的优势。让我们深入研究一下我的方法:

数据收集

为了建立一个日期-一个矿工,我需要喂她很多图像。结果,我使用 pynder 访问了 Tinder API。这个 API 允许我通过我的终端界面而不是应用程序来使用 Tinder:

我写了一个脚本,我可以在每个配置文件中滑动,并将每个图像保存到“喜欢”或“不喜欢”的文件夹中。我花了几个小时刷,收集了大约 10,000 张图片。

我注意到的一个问题是,我向左滑动了大约 80%的个人资料。结果,我有大约 8000 个不喜欢的文件夹和 2000 个喜欢的文件夹。这是一个严重不平衡的数据集。因为我的“喜欢”文件夹中的图片很少,所以约会达人不会训练有素地知道我喜欢什么。它只会知道我不喜欢什么。

为了解决这个问题,我在谷歌上找到了一些我觉得有吸引力的人的图片。然后我收集了这些图像,并在我的数据集中使用它们。

数据预处理

现在我有了图像,但还有一些问题。Tinder 上有各种各样的图片。有些个人资料有多位朋友的照片。一些图像被缩小。有些图像质量很差。很难从如此多种多样的图像中提取信息。

为了解决这个问题,我使用了一个 Haars 级联分类器算法从图像中提取人脸,然后保存下来。分类器本质上使用多个正/负矩形。让它通过预先训练的 AdaBoost 模型来检测可能的面部尺寸:

Credit: OpenCV

该算法在大约 70%的数据中未能检测到人脸。这使我的数据集缩减到 3000 张图片。

建模

为了对这些数据进行建模,我使用了一个卷积神经网络。因为我的分类问题非常详细&主观,所以我需要一种算法来提取足够多的特征,以检测我喜欢和不喜欢的简档之间的差异。cNN 也是为图像分类问题而建立的。

为了对这些数据建模,我使用了两种方法:

三层模型:我没想到三层模型会表现得很好。每当我构建任何模型时,我的目标都是让一个笨模型先工作起来。这是我的笨模型。我使用了一个非常基本的架构:

 model = Sequential()
model.add(Convolution2D(32, 3, 3, activation=’relu’, input_shape=(img_size, img_size, 3)))
model.add(MaxPooling2D(pool_size=(2,2)))model.add(Convolution2D(32, 3, 3, activation=’relu’))
model.add(MaxPooling2D(pool_size=(2,2)))model.add(Convolution2D(64, 3, 3, activation=’relu’))
model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Flatten())
model.add(Dense(128, activation=’relu’))
model.add(Dropout(0.5))
model.add(Dense(2, activation=’softmax’))adam = optimizers.SGD(lr=1e-4, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss=’categorical_crossentropy’,
 optimizer= adam,
 metrics=[‘accuracy’])

最终的准确度约为 67%。

**使用 VGG19 进行迁移学习:**三层模型的问题是,我正在一个超小的数据集上训练 cNN:3000 张图像。在数百万张图片上表现最好的 cNN 列车。

因此,我使用了一种叫做“迁移学习”的技术迁移学习,基本上就是把别人建立的模型用在你自己的数据上。当你有一个非常小的数据集时,这通常是可行的方法。我在 VGG19 上冻结了前 21 层,只训练了后两层。然后,我展平并在它上面拍了一个分类器。下面是代码的样子:

model = applications.VGG19(weights = “imagenet”, include_top=False, input_shape = (img_size, img_size, 3))top_model = Sequential()top_model.add(Flatten(input_shape=model.output_shape[1:]))
top_model.add(Dense(128, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(2, activation='softmax'))new_model = Sequential() #new model
for layer in model.layers: 
    new_model.add(layer)

new_model.add(top_model) # now this worksfor layer in model.layers[:21]:
    layer.trainable = Falseadam = optimizers.SGD(lr=1e-4, decay=1e-6, momentum=0.9, nesterov=True)
new_model.compile(loss='categorical_crossentropy',
              optimizer= adam,
              metrics=['accuracy'])new_model.fit(X_train, Y_train, 
          batch_size=64, nb_epoch=10, verbose=2 )new_model.save('model_V3.h5')

结果是:

准确度 : 73%

精度: 59%

召回率: 44.61%

准确性只是正确地预测我是喜欢还是不喜欢这张图片。

Precision 告诉我们“在我的算法预测为真的所有配置文件中,我真正喜欢的有多少?”低精度分数意味着我的算法没有用,因为我得到的大多数匹配都是我不喜欢的简档。

回忆,告诉我们“在所有我实际上喜欢的配置文件中,算法正确预测了多少?”如果这个分数很低,这意味着算法过于挑剔。

你可以看到斯嘉丽·约翰逊的算法预测:

运行机器人

现在我已经建立了算法,我需要把它连接到机器人上。制造这个机器人并不太难。在这里,你可以看到机器人的动作:

我故意在每次滑动时添加了 3 到 15 秒的延迟,这样 Tinder 就不会发现这是一个在我的个人资料上运行的机器人。不幸的是,我没有时间给这个程序添加 GUI。

未来工作

我只给自己一个月的兼职来完成这个项目。事实上,我还可以做无数其他的事情:

**对个人资料文本/兴趣的自然语言处理:**我可以提取个人资料描述和 facebook 兴趣,并将其纳入评分标准,以开发更准确的点击。

**创建一个“总个人资料得分”:**我可以让算法查看每张照片,并将累积的滑动决策汇编成一个得分指标,以决定她应该向右还是向左滑动,而不是从第一张有效照片中做出滑动决策。

**更多数据:**我只对 3000 张图片进行了训练。如果我可以在 150,000 张 Tinder 图片上训练,我相信我会有 80–90%的算法执行率。此外,我还可以改进面部提取程序,这样我就不会丢失 70%的数据。

**适应铰链,咖啡遇上百吉饼,邦布尔:**为了拓宽我的量,适应算法击中多个频道。

**A/B 测试:**有一个框架来 AB 测试不同的消息,剖析图片,并有分析支持这些不同的决策。

谷歌的 Inception,VGG16: 这些都是不同的预先训练好的 cNN 的。我想试试这些,但是我没有时间了。

**添加 GUI/Turn 成为一个用户友好的应用:**这将允许非技术人员使用它。

现在,该刷卡了!

如果您有兴趣查看代码或为自己重新创建这个项目,请单击此处的。如果你有兴趣了解更多关于我的信息,请查看我的网站。

演职员表:

看下一个帖子。

杰夫·李正在通过将矩阵技术下载到他的大脑中来拯救世界。他是……"超级收入者"

如果你爱我和这个项目,关注这个媒介账号或者查看我的网站。讨厌我,你还是应该关注这个中等账号。这里有一个选择……

MachinaNova:一个个人新闻推荐引擎

原文:https://towardsdatascience.com/machinanova-a-personal-news-recommendation-engine-d465cbed3661?source=collection_archive---------12-----------------------

MachinaNova Logo

几个月前,我订购了一个叫做 Paper.li 的工具,我可以把它添加到我的网站上。它的承诺是“收集相关内容,并把它发送到你想去的任何地方”——这正是我早上工作时需要的。

让我解释一下…我喜欢我的早晨惯例。它包括吃早餐、喝咖啡和坐下来浏览数字新闻和内容的丛林。我的目标:带着我还没有的珍闻出现在新闻丛林的另一边;希望我打算吃的一些咖啡和百吉饼能在我嘴里落地。

说真的,我点击了几十个书签,浏览了标题,最终还是屈服于点击疲劳。每天早上,我都会看久经考验的《哈佛商业评论》 …因为它们每次都很棒。

如果 Paper.li 照他们说的做了,我的日常工作时间就会减少,我终于可以享受我的百吉饼了,而不是把它往我脸上推。我需要这个解决方案!

The image above is a real picture of a portion of the bookmarks saved on my Google Chrome browser.

新闻聚合现实:它烂透了百吉饼。

坦白地说,李的方案很糟糕。它在推荐文章方面很有效;但是它们很少有趣。通常,被推荐的文章都是推广个人项目的博客帖子或推文,我很少能找到任何可以应用到我职业生涯中的真正内容。

李(以及其他新闻聚合网站——看看你,Flipboard,Medium 和其他所有解决方案)是糟糕的。它只是不适合我想读的内容。如果你不是像我一样的完美主义者,这很好…

然而,我是一个完美主义者…

我有能力解决这个问题。

是时候建造 MachinaNova 了。

MachinaNova,新闻机|解决方案概述

MachinaNova 是一个应用程序,它可以找到我感兴趣的新闻,并以我每天都可以阅读的格式呈现出来。这就引出了一个问题…它怎么知道我想读什么?

这是一个神奇的新闻推荐系统。

嗯,其实是我训练的识别我喜欢的文章的软件。我将把解决方案分解成几个部分,这样就容易理解了,但是在高层次上,MachinaNova 是一个推荐系统。

就我而言,MachinaNova 预测了我通过阅读“喜欢”一篇文章的可能性。除了预测之外,它还会产生一个置信度得分,告诉我有多确信我会喜欢这篇文章。每天,它都会呈现根据可信度排序的前 12 篇“赞”文章。

解决方案相对简单,而且非常有用。我已经用了几个星期了——我喜欢它!

MachinaNova 查看文章的来源、标题和摘要来预测“喜欢”或“不喜欢”

谢谢你,机械诺娃!你其实知道我喜欢什么。

为了理解文章的内容,MachinaNova 使用自然语言处理来阅读文章。我一会儿会谈到这是什么,但是把它想象成我在早晨例行公事中可能做的事情。我浏览来源,阅读标题,也许还有文章的摘要。在我的日常生活中,如果我不喜欢某篇文章,我会继续看下一篇;如果我喜欢,我可能会点击阅读。唯一不同的是,MachinaNova 可以在几秒钟内阅读和评分数千篇文章。

我很嫉妒…我一年可能会读几千篇文章…人工智能正在接管。

MachinaNova,新闻机器|采集新闻

为了建立 MachinaNova,我需要做的第一件事就是抓取我喜欢的文章。幸运的是,有一种预置的方法可以轻松地从网络上获取新闻。RSS 源。RSS 源是新闻提供商提供的服务,允许快速分发他们的内容。在 RSS 提要中,您可以找到诸如文章名称、作者、链接、图片等内容。

为了捕获有价值的 RSS 数据,我构建了一个 Python 脚本来调用我最喜欢的 RSS 提要,并将信息存储在我的本地机器 Ocean 上的数据库中。(海洋这个名字是因为它的 3TB 固态硬盘。)

海洋自 2018 年 6 月以来一直愉快地捕捉文章。在撰写本文时,我的本地数据库包含来自华尔街日报、芝加哥论坛报和哈佛商业评论等来源的 20,000 多篇文章。

作为最终 MachinaNova 解决方案的一部分,我需要在 Amazon Web Services 上复制 Postgres 数据库。我还需要在 AWS Lambda 中复制我的 Python 脚本,并使用 Cloudwatch 服务从 RSS 提要中获取数据,并将它们存储在我的 Amazon Postgres RDS 解决方案中。

与此同时,Lambda 还将来自 RSS 提要的徽标存储在亚马逊 S3 中,这样 MachinaNova web 应用程序就可以将这些图像作为源呈现给最终用户。

在我将 Python 脚本和 Postgres dB 迁移到 AWS 之后,我的本地 Python 脚本于 2018 年 10 月初退役。

MachinaNova,新闻机器|网络应用

在构建了捕获新闻文章的方法之后,我需要告诉我的应用程序我喜欢和不喜欢哪些文章。在我的本地计算机(Ocean)上,我构建了一个 Django 应用程序,它可以读取我存储在 Amazon RDS 中的文章。

这个 Django 应用程序,并没有对公众开放,它是一个界面,在我的电脑屏幕上显示一篇随机的未经训练的文章。在应用程序中,我可以看到两个按钮“喜欢”和“不喜欢”。如果我喜欢这篇文章,我会选择“喜欢”,如果不喜欢,我会选择“不喜欢”。在我的数据库中,0 代表“不喜欢”,1 代表“喜欢”

喝了几杯酒,经过几个晚上的打分,我已经根据自己的喜好训练出了大约 1200 篇文章。

现在,我们有了一个真正的数据科学项目的开端——机器学习!

MachinaNova,新闻机器|机器学习

这部分可以自成一篇。所以,我要把它保持在一个很高的水平。这是一个家庭友好的博客帖子。

记得我之前说过,我的解决方案可以使用自然语言处理来阅读文章。为此,MachinaNova 使用一种叫做空间的解决方案来“阅读”每个单词(和标点符号)。) Spacy 与生俱来的对单词在邻近的其他单词的上下文中的含义的理解(例如,“苹果”是一家公司,而不是一种水果,当伴随着其他商业单词时。)

使用 Spacy 和它的 NLP 功能,我建立了一个单词包模型,计算一篇文章、标题甚至来源中使用的单词数。然后,它会查看这些单词,并将其与我过去喜欢的文章的常用单词和字数的训练数据集进行比较。

本质上,MachinaNova 会寻找那些与我以前喜欢的文章有相似文字的文章。

为了给每篇文章打分,我使用了一种叫做支持向量机的算法,用核心技巧在“N”维中表示这些单词,以便在我“喜欢”和“不喜欢”的文章之间划出一条线。这在一开始还不错,但需要优化。为了优化算法,我使用了 TF-IDF(术语频率,逆文档频率)等其他技巧,甚至使用 n 元语法创建了一些短语。

还和我在一起吗?

一旦我的机器学习算法达到预期,我就使用 Docker、亚马逊 ECR、亚马逊 ECS 和使用亚马逊 Fargate 的自动缩放计算资源将其部署到 AWS。机器学习算法使用 Cloudwatch 和 Cron 调度在每天早上 5:45 运行。

MachinaNova,新闻机器|用户界面和演示

在这一点上,我们在 Amazon Web Services 上有一个数据库,每天更新数千篇新闻文章。现在是时候向最终用户展示这些信息了。

我爱 Django,Jinja2 和 Materialize CSS!

在这个项目中,我爱上了一个超级易用的软件,它允许我使用我最喜欢的语言 Python 来构建漂亮的 web 应用程序。解决方案 Django 创建了一个数据库,给了我一些安全特性,并允许我引入模板和 CSS 来使我的应用程序漂亮、更新并与我收集的数据集成。

所以,我建立的解决方案已经准备好了,可以在我的网站上找到,地址是courtneyperigo.com/news;但肮脏的事实是,该解决方案实际上由亚马逊的 Route 53 安全托管在 newsml.machinanova.ninja

我很自豪完成了这个项目。它挑战我学习新工具,迫使我学习 AWS,并彻底击败了其他新闻推荐服务。

吮吸面包圈、纸团的李!

这个项目的代号是基多项目。因为一旦我完成了这样一个项目,我会奖励自己一个假期。看来我需要温习一下我的西班牙语。

机器共情:机器学习如何给 UX 设计带来真正的洞察力

原文:https://towardsdatascience.com/machine-empathy-how-machine-learning-can-bring-real-insight-to-ux-design-f5fee5cb5e10?source=collection_archive---------7-----------------------

Created on iPhone6s with Prisma

将同理心和数据挖掘结合起来,打造更好的 UX

移情已经理所当然地成为良好用户体验(UX)设计的前提。但是设计师用来达到共鸣的手段——比如人物角色——并没有达到他们的预期目的。

虽然使用人物角色的动机是高尚的,但是他们经常是建立在人口统计资料上的理想化用户的产品,而不是来源于真实用户行为的原始洞察力。

人物角色的局限性是众所周知的。这个最近的视频很好地分析了局限性,而 2010 年的这篇论文描述了开发人物角色的各种陷阱,从过程不科学到倾向于群体思维和确认偏差。

但是人物角色应该被完全抛弃吗?如果没有确定要服务的群体,通过什么方法可以确定设计的优先级?如果不知道也不考虑用户的动机或心态,那么 UX 的设计怎么能像经常被引用的那样具有同理心呢?

移情的另一种方法——渐进主义——使用行为数据来渐进地改变设计,以达到优化的 UX。但是这种注重转换而非体验质量的方法,通过渐进式改进而不是整体解决方案来抑制创新。

我们相信,通过将设计师的需求与正确的数据和分析工具相匹配,有一种更好的方法来应对 UX 的挑战。

问题的根源

在我们深入研究解决方案之前,有必要了解一下我们为什么会走到这一步:

  1. 过度依赖一个工具,谷歌分析
  2. UX 网站只使用网络数据的孤岛式思维
  3. 对可用数据的肤浅分析使河马效应成为可能,并导致人物角色的主观创造

第一点是其他两点的根本原因。谷歌分析的专业知识被错误地认为是网站分析的专业知识。当其他来源和分析工具可用时,对于网站数据来说,这是马兹洛的锤子。简而言之,错误的工具和不充分的信息导致设计的任意起点。

让我们举一个交通信息网站的简单例子,其中一个关键的性能指标——在网站上的时间——可能与相反的动机和对体验的错误理解有关。有一次,一条火车线路瘫痪,通勤者需要使用该网站寻找替代路线。长时间在网站上与用户在寻找相关信息时的摩擦和挫折有关。相反,在旅游旺季规划城市路线的游客需要更多的时间来考虑如何最好地游览景点。

如果不了解不同用户想要达到的目标,善意的网站目标可能会成为性能的错误标志。

理解用户行为的更好方法

在 UX 设计中,对用户进行分组仍然是开发优先级的关键,但是如何进行呢?其实就是收集更有意义的用户数据,使用正确的分析工具和方法这么简单。

下面是我们发展丰富而有意义的用户群的 4 个步骤:

1.掌控您的网络用户数据

早在 2005 年,当谷歌收购顽童软件时,网络分析的选择有点有限,而且都是付费的或者非常简单。很难想象无处不在的顽童一旦免费并更名为谷歌分析会变得怎样。值得称赞的是(也是有益的),谷歌给了每个运营网站的人一个以简单有效的方式衡量其表现的机会,但除非你支付 10 万美元购买高级版本,否则你无法获得原始数据用于外部分析。

你也不需要投资像 Adobe 或 Webtrends 这样的商业级系统。虽然这些系统很强大,但你只是用不必要的花费和时间,把一个围墙花园换成另一个。

相反,有一些低成本或免费的系统可以提供丰富的访问者数据,这些数据可以导出供外部分析。我们使用的系统有:

  • Piwik —开源免费分析软件
  • Opentracker —提供访客身份识别的低成本软件

这些可以很容易地作为代码片段安装在网站主页模板或标签管理器中,与 Google Analytics 并行运行。

所有权超越了由一个公司实体控制您的信息的陈腐概念。虽然随着时间的推移,数字媒体的双头垄断可能会使这种担忧更加主流,但主要的威胁是,分析工具与谷歌和/或脸书认为对他们最有利可图的功能优先级相关联,而不是对你。

2.考虑所有影响用户对你的网站的动机和心态的外部因素

通常情况下,我们会举办客户研讨会,在用户到达网站之前绘制他们的旅程,并对所有可用的相关数据进行分类,包括网络分析之外的来源。例如,在上面引用的旅行示例中,我们收集了与天气异常和服务中断相关的数据集。

发现的场景和用户旅程越多,可以利用的外部数据就越多。

3.收集所有数据并进行分析

这就是事情开始变得有趣的地方。分析需要正确的工具和技能。幸运的是,这两者都相当丰富。

我们的选择通常是:

要分析的数据应该尽可能的平坦和整洁,这意味着每一行都是一次访问(观察),每一列都是一个描述符(变量)。如果您来自关系数据库领域,当用于分析的数据可能有数百万行和数十列时,这看起来可能是浪费。r 是为大规模工作而设计的;在笔记本电脑上分析几十万行可能需要几秒钟。对于大型数据集,可以在个人电脑上使用数据样本开发原型,然后相同的分析代码可以在整个数据集上运行。

一旦数据整理好,我们就可以通过 r 中的“Cluster”包使用无监督机器学习,这种类型的分析被用于从医学研究到手机套餐定价等各种领域。这听起来可能真的很复杂,有点吓人,但事实并非如此。数学很复杂,但原理和实际执行很简单:机器学习算法通过同时最大化和最小化描述访问的所有变量之间的距离,将每次访问分配到一个组(集群)中。

首先,我们需要知道聚类的最佳数量。试错法可以在视觉上评估得到的聚类是过于相似、过于不同还是恰到好处。或者,factoextra 包中的 fviz_nbclust 函数可以给出最佳数字:

k 统计峰值在 4 左右,因此我们将针对 4 个集群的目标运行函数。

有许多可视化输出;一种流行的方法是使用雷达图来了解每个星团的变量大小。

该图的每个雷达段显示了每个聚类中每个变量的相对重要性。数字输出还将告诉我们每个聚类代表整个样本的多少比例,从而给出客观的优先级。

4.将集群应用于用户组

从上面的雷达图中,我们可以将星团解释成有意义的部分。即使只有两个外部因素,天气和服务,也给三个网络分析指标带来了更大的背景。

对于上面的示例,分段可能是:

  1. 千夫所指 —恶劣天气和现场低时段;他们急需信息
  2. 通才——不太确定他们需要什么信息,但会在网站上逛逛
  3. 考虑者 —高参与度
  4. 恐慌者 —从另一个站点转介来检查服务

上述示例仅使用了五个变量,变量越多,最终用户的信息就越多,但是从可用的集群中,我们可以直观地了解设计的一些优先事项:

  • 如何最好地标示出恐慌者管理者所需的特定旅行和服务状态内容?
  • 我们能否为多面手提供一个逻辑导航结构,让他们更高效地到达需要的地方?
  • 什么样的行动号召最能满足考虑者渴望的参与度?

由于每次访问都被分配到一个集群中,如果我们服务于这些优先事项,那么就没有什么需要解决的了。

重申一下,我们从每次用户访问中获取的变量越有意义,集群的描述性就越强,关于细分和设计简报的结论就越好。

Created on iPhone6s with Prisma

合成创造力还是机器共情?

机器学习的数学可以通过将用户数据与上下文因素结合起来,消除对网络分析意味着什么的任意概念。但是仍然需要人类的解释和创造力来为数字之间的巨大空白着色。为了取得成功,设计师和数据科学家需要合作开发有意义的见解和目的驱动的细分市场。

人工智能能够弥合分析和创造力之间的差距吗?还没有,但随着每一天和每一个改进的算法,我们朝着真正的机器移情又迈进了一步。

最初发表于T5【www.deducive.com】

旅游和运输行业的机器智能

原文:https://towardsdatascience.com/machine-intelligence-in-the-travel-transportation-industry-e63606cd45f1?source=collection_archive---------10-----------------------

Photo by Tomasz Frankowski on Unsplash

滑道 每季度发行一本名为 观光客 的旅游营销杂志。这篇文章的一个版本将出现在第三季度。

TL;博士:

努力在人工和自动与客户互动之间找到正确的平衡。方便和同理心同样重要。

在流程自动化之前关注流程改进。自动化糟糕的流程增加了糟糕事情发生的速度。

技术史

几代人以来,机器智能一直在改变我们的旅行方式。1946 年,美国航空公司发布了第一个自动订票系统。到 1976 年,联合航空公司向旅行社部署了他们的计算机化预订系统。20 世纪 90 年代,孤独星球的第一个网站 Expedia 和 Priceline 诞生了。在整个 21 世纪初,全球分销系统和互联网使得 Kayak 和 Hotwire 通过聚合创新了 OTA 模式。今天,几乎每个航空公司都有一个“智能的”(或者至少是动态的)应用程序;大型连锁酒店正在部署自动化礼宾顾问;美国运输安全管理局利用无数的扫描和视觉识别安全技术;旅行者的偏好和数字行为被用来提供量身定制的产品,他们甚至可以在机场的航站楼之间购买行李。

然而,在过去的几十年里,对于发明并没有一致的坚持。20 世纪 60 年代机器翻译取得的进步和 20 世纪 80 年代“专家系统”的激增都让位于他们自己的研究经费的崩溃。这几十年的创新休眠通常被称为“人工智能冬天”。虽然有些人认为我们很容易再经历一次,但许多人断言过去几代人的人工智能冬天现在完全是后知后觉。无论你持哪种观点,最近的上涨都可以追溯到几个关键的技术和基础设施促成因素:

集中和分散计算

高级数据操作技术需要强大的计算能力。像亚马逊网络服务和谷歌的云部门这样的公司将服务器(和 GPU 集群)集中化,以允许软件应用程序在外部或“云”上运行,并传输到设备。与此同时,在我们的手掌中,今天移动设备中使用的硬件非常先进,使得大量计算可以在设备本身或“边缘”进行。

移动“应用”和应用间服务

手机是人类历史上最大的经济平台。因此,数以百万计的应用程序被创建出来。如今,终端用户手动浏览这些应用程序,通常85%的设备使用时间只花在五个应用程序上。随着不太普及和小众的消费者服务作为应用程序上线,它们之间的运营结构变得越来越重要。 Button 是这种服务的一个很好的例子——使最终用户能够在应用程序之间无缝导航,以完成诸如安排优步之旅以获得 OpenTable 预订等任务。

自然语言处理

互联网上(以及企业内部)大约 80%的信息被认为是非结构化数据,即既没有预定义也没有组织的信息。非结构化信息通常以文本为主,包含日期、数字和事实等数据。NLP 领域的进步有助于通过解释意义、意图和情感来理解这些数据,使公司能够更好地了解受众对产品或服务的感受。

计算机视觉

部署算法来学习视觉线索的最新技术开辟了自动化工作流和业务流程的途径,包括标记和/或解释图像。Chute 内置了自己的视觉识别引擎,名为 IRIS 。它可以根据场景类型、徽标和对象过滤和标记图像。capricity是另一个很好的例子—在保险工作流程中处理扫描的文档和图像。

训练、优化和预测

机器学习算法通过训练数据和反馈回路来提高性能。搜索引擎优化(SEO)是谷歌和必应(Bing)等公司大规模对回复进行排名的一个例子。在大大小小的规模上,优化算法正被部署来利用过去的在线或数字行为来推荐未来的活动,随着时间的推移不断校准和定制建议。

语音识别

语音识别技术现在产生了大约 5%的错误率,这与人类的能力相当。像苹果的 Siri 和亚马逊的 Alexa 这样的语音激活代理正在打开我们可以简单地请求激活我们移动设备上的无数服务的方法的窗口。想象一下客户服务电话上的交互式语音应答(IVR)实际上是有效的。

通过利用这些使能技术,开发人员友好的服务已经建立起来——促进技术专家社区的采用,从而推动今天利用机器智能的应用的扩散。以下主题剖析了这些技术对旅行体验产生最大影响的方式。

订婚

聊天机器人是一种独特而有效的联系客户的媒介。Facebook Messenger、IBM Watson、Heroku、Amazon Alexa 和 Slack(以及许多其他平台)为构建和训练聊天机器人提供了框架。这些应用程序可能被部署为酒店的礼宾员,帮助定位健身房,或者航空公司应用程序的信使,提醒旅客延误,或者语音命令界面,预订机票。

搜索&探索

旅行者现在可以用自然语言搜索,无论他们去哪里,都能找到想要的和定制的体验。像 WayBlazer 这样的智能服务通过结合评论、排名和旅行指南,推荐最有可能引起旅行者共鸣的活动、餐馆、公园、博物馆和体验。

物流&运营

现在,在 200 多个国家使用数十种语言进行预订比以往任何时候都更容易、更快捷。智能交通系统——从无人机场铁路到突破性的自动驾驶汽车技术——正在改变旅行者从 A 地到 b 地的出行方式。此外,动态定价算法正在改变我们基于整个旅行体验中的实时供需的花钱方式——包括预订和运输。

未来会怎样?

很快,简单地预订一张机票就会引发一场无人驾驶的旅行。真正个性化的餐厅和活动推荐将通过 messenger 应用程序的一键式预订功能立即自动发送。旅行计划将花费比现在少得多的时间。即使在到达机场后,旅客也会被引导到他们的登机口,沿途有购物、休闲和用餐的建议。机场不仅仅是去其他地方的一种手段;这将是一个独立的地方。

当影响者到达餐厅酒吧或入住酒店时,社交监控系统将通知酒店员工,使服务团队能够主动为他们创造令人难以置信的体验——也许是免费的饮料或甜点。航空公司甚至可能瞄准特定的忠诚和有影响力的受延误困扰的乘客,以独特的方式进行补偿。

就像飞机上的自动驾驶仪一样,机器智能无法管理旅游业提供的所有操作和服务。飞行员处理起飞和降落的方式类似于旅游公司继续为旅行者提供差异化体验的方式。然而,在整个飞行和旅行过程中,智能有助于优化个性化、规模和便利性。

2017 年机器智能峰会

原文:https://towardsdatascience.com/machine-intelligence-summit-2017-3e02003fa7ba?source=collection_archive---------3-----------------------

阿姆斯特丹#reworkMI 概述

上周,我在阿姆斯特丹参加了第四届机器智能峰会。这项活动的任务是:

“……让政府官员、学者、企业家、投资者和行业专业人士齐聚一堂,讨论机器学习、深度学习和人工智能的最新突破,并探索它们在工业中的应用及其潜在影响……”

当我在第二天对房间进行快速举手调查时,看起来观众大多来自学术界或创业背景(我承认,我忘了问政府官员)。

完整的时间表和摘要可以在网上找到,我通过回顾那里来写这个摘要。以下是演讲的简要概述,按主题分组(而不是按演讲者顺序):

计算机视觉

来自 DFKI 的 Damian Borth】讨论了从形容词-名词对的角度探索由生成对抗网络(GANs)创造的潜在空间,以捕捉图像的主观特征。展示的结果包括一种翻译图像以更好地捕捉某些特征的方法;例如,将图像从“多雾的天空”翻译成“美丽的天空”

来自 EyeEM 的 Appu Shaji 讨论了 EyeEM 如何使用计算机视觉为客户创造新体验。他讨论的一个有趣的应用是“EyeEM 选择”功能(见这篇博客文章),它从你的图库中挑选最好的照片来展示。

时尚&美丽

来自欧莱雅的 Panagiotis-Alexandros Bokaris承诺我们的演讲“不仅仅是关于口红”他的演讲涵盖了增强现实和计算机视觉交叉领域正在进行的广泛工作——并指出这些技术如何进入美容相关产品,如智能发刷(和口红)。

来自 Zalando Research 的 Roland Vollgraf 讨论了深度学习在服装项目上的应用。通过学习产品图片、文字描述和供应商属性,他们创建了一个“时尚 DNA”,它可以应用于聚类项目,也可以生成不存在的服装项目..还没有。

搜索&推荐

Google Research的 Aleksandr Chucklin 做了一个关于搜索引擎结果页面评估的演示(Arxiv 论文此处)。这是另一个展示搜索结果评估变得多么微妙的演讲——有关于移动/网络搜索差异的研究,关于评估“良好放弃”的研究,以及关于评估混合内容和非线性搜索结果页面的质量的研究。

在 Skyscanner 做了一个关于引导目的地发现系统的演讲,并且可能是少数几个没有讨论深度学习应用的人之一(至少现在是这样!).更多信息请见另一篇博文。我想这是我第一次出现在潜望镜上。

购物&拍卖

来自野餐会的 Daniel Gleber 从机器学习的角度概述了野餐会(荷兰在线购物服务)正在解决的各种问题:它们跨越了整个顾客旅程,等等。例如,这包括扩展客户反馈系统,在该系统中,用户可以请求当前没有库存的商品,从一个松散的渠道变成一个自动分类系统。另一个重点领域是预测交付时间——图表的 y 轴显示的错误度量单位是秒!

来自 Catawiki 的 Peter Tegelaar 讨论了深度学习在 Catawiki 的拍卖系统中的各种应用。这包括从使用分类来支持产品分类到估计物品的价格。彼得还公开谈到了深度学习的一个对他们不起作用的应用(估计客户终身价值),并警告我们不要把一切都当成钉子,现在深度学习是最新的锤子。

机器人和硬件

来自波恩大学的 Sven Behnke 教授讨论了深度学习在机器人认知方面的应用。这个空间有各种角度。他讨论的许多有趣的应用之一是在 RoboCup 2016 中使用这些方法,参与者与在非结构化环境中执行自动分拣任务的机器人竞争(参见亚马逊机器人挑战赛)。

阿姆斯特丹大学的 Theo ge vers概述了他的团队在自动物体检测、分割和重建方面的研究。他演示了一个应用程序,可以从实时视频流中自动推断一个人的情绪、年龄和性别。毫不奇怪,第一个问题是关于隐私的。

NVIDIA 的 Adam Grzywaczewski概述了由于对深度学习的兴趣激增而出现的基础设施挑战。他收到的一个问题是,英伟达的 GPU 与谷歌的 TPUs 相比如何。他的回答?我不知道,我不能出去买谷歌的主板来和我们的比较。

小型机器人公司的 Ben Scott-Robinson 发表了一篇关于三个机器人的演讲:Tom、Dick 和 Harry,以及它们是如何被设计来帮助农民做从土壤分析到播种的一切事情的。将正在设计的机器人拟人化是一个有趣的焦点,看到这种“农业即服务”模式的发展将会很有趣。

来自 ING 的 Dor Kedem 发表了一篇关于大型计算集群中资源分配的演讲,以及如何使用机器学习和集群利用模式来节省大量资金,否则这些资金将被用于分配最终闲置的资源。

文档分析&嵌入

来自 Swisscom 的 Sotirios Fokeas 发表了一篇关于使用句子嵌入来提取文档中高覆盖率关键短语的演讲。句子嵌入是一种有趣的方法,最近也受到了很多关注。

来自凯泽斯劳滕大学的 Marcus Liwicki 给出了一个在分析文档方面行之有效的方法的概述。这包括著名的长短期记忆(LSTM)网络。

LSTMs 也出现在米哈伊·罗塔鲁关于 Textkernel 的谈话中;他做了一个关于使用深度学习从候选人的简历中自动解析数据,并使用这些数据将申请人与工作匹配的演讲。这包括考虑独立于语言的模型,并通过嵌入找到职位相似性。

用机器学习进行数据分析

苏黎世联邦理工学院的 Vahid Moosavi】发表了一篇关于使用数据来模拟城市现象的演讲,比如房地产价格和空气污染流量。他提出的一个关键点是,将数据和机器学习应用于传统上依赖领域知识的问题空间,正在将“专业知识”的定义从拥有已知问题答案的“T2”转向知道提出好问题的“T4”。

来自伦敦大学学院的 Ingo Waldmann 发表了一篇关于使用深度学习来自动分析和发现太阳系外行星的演讲(参见“梦想大气层”),以及天文学如何成为不断增长的研究领域的最新受害者,在这些领域中,数据可用性超过了我们的分析能力。

用深度学习扩充专家

来自 Scyfer 的 Tijmen Blankevoort】谈到了人在回路或主动学习。这包括在医学成像中的应用。来自 COSMONiO 的 Larens Hogeweg 也讨论了深度学习在医学成像上的应用。特别是,他专注于从“小数据”(甚至 1 或 2 个样本)中学习,并展示了方法如何能够很好地推广。

贝叶斯方法

来自 alpha-i 的 Christopher Bonnett 介绍了在深度学习中使用贝叶斯方法来揭示模型预测中的不确定性,以及预测本身。

来自 Freeletics 的 Laith Alkurdi 发表了一篇关于贝叶斯方法如何被用于在 Freeletics 应用程序中建模用户和创建“教练人工智能”的演讲。

小组讨论

第一天的小组讨论重点是投资人工智能。该小组由马修·布拉德利( Forward Partners )主持,成员包括朱利叶斯·吕斯曼( Earlybird Venture Capital )、卡洛斯·爱德华多·埃斯皮纳尔( Seedcamp )和丹尼尔·格莱伯(野餐)。有趣的片段包括评估初创公司在访问训练数据方面的竞争优势,以及在多面手人工智能初创公司和那些在特定垂直领域增长的初创公司之间进行平衡。

与会议的其他部分相比,第二场小组讨论有点变化,重点是应对网络安全方面日益增长的威胁。该小组由 Eelco Stofbergen ( CGI )主持,成员包括 Tanya Harris(Harrman Cyber)、Ian Bryant(trust worthy Software Foundation)和 Colin Williams(University of Warwick)。该小组收到的一个有趣的问题是,在安全攻击/防御中,“好人”还是“坏人”更好地利用了人工智能:答案是“我们必须拭目以待”。

收尾思路

#reworkMI 是一个有趣的会议,我遇到了一群很棒的人。每个人都对深度学习感到兴奋——这并不奇怪——而且这种兴奋主要是从非常技术的角度来看的。然而,许多演讲者都有幻灯片,讲述了他们目前在深度学习系统中面临的挑战(如下所示):这些挑战跨越了整个产品生命周期。仍有许多工作要做。

机器学习 101:梯度下降的直观介绍

原文:https://towardsdatascience.com/machine-learning-101-an-intuitive-introduction-to-gradient-descent-366b77b52645?source=collection_archive---------2-----------------------

毫无疑问,梯度下降是大多数机器学习(ML)算法的核心和灵魂。我绝对相信你应该花时间去理解它。因为一旦你这样做了,首先,你会更好地理解大多数最大似然算法是如何工作的。此外,理解基本概念是发展对更复杂主题的直觉的关键。

为了理解梯度下降的核心,让我们有一个运行的例子。这个任务是这个领域中的一个老任务——使用一些历史数据作为先验知识来预测房价。

但我们的目标是讨论梯度下降。为了做到这一点,让我们的例子足够简单,这样我们就可以集中在好的部分。

但是,在我们继续之前,你可以在这里得到代码。

基本概念

假设你想爬一座很高的山。你的目标是最快到达山顶。你环顾四周,意识到你有不止一条路可以开始。因为你在底部,所有这些选项似乎都让你更接近顶峰。

但是你想以最快的方式到达顶峰。那么,你如何做到这一点呢?你如何迈出一步让你尽可能接近顶峰?

到目前为止,还不清楚如何迈出这一步。这就是梯度可以帮助你的地方。

正如汗学院的视频中所说,梯度捕捉了一个多变量函数的所有偏导数。

我们一步一步来,看看效果如何。

简单来说,导数是函数在给定点的变化率或斜率。

f(x) = x 函数为例。 f(x) 的导数是另一个函数f’(x),它计算 f(x) 在给定点 x 的斜率。这种情况下,对于 x = 2f(x) = x 的斜率为 2x22 = 4* 。

The slope of f(x)=x² at different points.

简单来说,导数指向最陡上坡的方向。好的一面是,梯度是完全一样的。除了一个例外,梯度是存储偏导数的向量值函数。换句话说,梯度是一个向量,它的每个分量都是一个特定变量的偏导数。

再以函数, f(x,y) = 2x + y 为例。

这里, f(x,y) 是一个多元函数。它的梯度是一个向量,包含 f(x,y) 的偏导数。第一个相对于 x,第二个相对于 y。

如果我们计算 f(x,y) 的偏导数,我们得到。

所以梯度是下面的向量:

请注意,每个分量表示每个函数变量的最陡上升方向。换个说法,梯度指向函数增加最多的方向。

回到爬山的例子,坡度把你指向最快到达山顶的方向。换句话说,梯度指向表面的较高高度。

同样,如果我们得到一个有 4 个变量的函数,我们将得到一个有 4 个偏导数的梯度向量。一般来说, n 变量函数会产生一个 n 维梯度向量。

然而,对于梯度下降,我们不想尽可能快地最大化 f ,我们想要最小化f。

但是,让我们先定义我们的任务,事情会看起来干净得多。

预测房价

我们要解决根据历史数据预测房价的问题。为了建立一个机器学习模型,我们通常至少需要 3 样东西。一个问题 T ,一个性能度量 P ,以及一个经验 E ,我们的模型将从这些地方学习模式。

为了解决任务 T ,我们将使用一个简单的线性回归模型。这个模型将从经验中学习,经过训练后,它将能够将其知识推广到看不见的数据中。

线性模型是一个很好的学习模型。它是许多其他 ML 算法的基础,如神经网络和支持向量机。

对于这个例子,体验 E ,是房屋数据集。房屋数据集包含圣路易斯奥比斯波县及其周边地区最近的房地产列表。

该集合包含 781 条数据记录,可在此处以 CSV 格式下载。在 8 个可用特性中,为了简单起见,我们将只关注其中的两个:尺寸和价格。对于 781 条记录中的每一条,以平方英尺为单位的大小将是我们的输入特征,价格将是我们的目标值。

此外,为了检查我们的模型是否恰当地从经验中学习,我们需要一种机制来衡量它的性能。为此,我们采用均方误差(MSE)作为性能指标。

多年来,MSE 一直是线性回归的标准。但是从理论上讲,任何其他的误差度量,比如绝对误差,都是可行的。MSE 的一些好处是它对较大误差的惩罚大于绝对误差。

既然我们已经形式化了我们的学习算法,让我们深入代码。

首先,我们使用 Pandas 加载 python 中的数据,并分离大小和价格特性。之后,我们将数据标准化,以防止一些特征的价值超过其他一些特征。此外,梯度下降与归一化数据相比收敛速度更快。

下图,你可以通过它的面积以平方米为单位看到房价的分布。

Distribution of house prices by Size. The data is normalized to the [0,1] interval.

线性回归模型的工作原理是在数据上画一条线。因此,我们的模型由一个简单的直线方程表示。

Line equation. m and b are the slope and the y-intercept respectively. The x variable is the placeholder for the input values.

对于线性模型,两个自由参数是斜率 m 和 y 截距 y 。这两个变量是我们要改变的旋钮,为了找到最好的线方程。

迭代地,我们将对它们进行细微的改变,这样它就可以沿着误差面上最陡下降的方向。在每次迭代之后,这些权重变化将改进我们的模型,以便它能够代表数据集的趋势。

在继续之前,请记住,对于梯度下降,我们希望采取与梯度相反的方向。

你可以把梯度下降想象成一个球滚下山谷。我们希望它坐落在大山的最深处,然而,很容易看出事情可能会出错。

In analogy, we can think of Gradient Descent as being a ball rolling down on a valley. The deepest valley is the optimal global minimum and that is the place we aim for.

根据球开始滚动的位置,它可能会停在谷底。但不是在最低的一个。这被称为局部最小值,在我们的模型中,谷是误差面。

注意,在类比中,并不是所有的局部最小值都是不好的。有些其实和最低(全局)的差不多低(好)。事实上,对于高维误差曲面,最常见的是采用这些局部最小值中的一个(不算太坏)。

类似地,我们初始化模型权重的方式可能导致它停留在局部最小值。为了避免这种情况,我们用来自具有零均值和低方差的随机正态分布的值来初始化两个权重向量。

在每次迭代中,我们将随机选取数据集的一个子集,并将其与权重进行线性组合。这个子集被称为小批量。线性组合后,我们将结果向量输入 MSE 函数,以计算当前误差。

有了这个误差信号,我们就可以计算误差的偏导数,得到梯度。

首先,我们得到关于 W0 的偏导数。

Partial with respect to W0

第二,我们做同样的事情,但是把 W1 作为演员。

Partial with respect to W1

有了这两个分音,我们就有了梯度向量:

The Gradient

其中 Err 是 MSE 误差函数。

这样,我们的下一步是使用梯度更新权重向量 W0W1 ,以最小化误差。

我们希望更新权重,以便它们可以在下一次迭代中降低误差。我们需要使它们遵循每个梯度信号的相反方向。为了做到这一点,我们要在那个方向上迈出η大小的小步。

步长η是学习速率,它控制学习速率。根据经验,一个好的起点是 0.1。最后,更新步骤规则被设置为:

在代码中,完整的模型如下所示。看两个梯度 DW0DW1 前面的负号。这保证了我们将采取与梯度方向相反的步骤。

更新重量后,我们用另一个随机小批量重复该过程。就是这样。

一步一步地,每一次权重更新都会导致线条向其最佳表现方向发生微小的移动。最后,当误差方差足够小时,我们可以停止学习。

Linear model conversion over time. The first weight updates cause the line to rapidly reach an ideal representation.

这个版本的梯度下降被称为小批量随机梯度下降。在这个版本中,我们使用训练数据的一个小子集来计算梯度。每个小批量梯度提供了最佳方向的近似值。即使梯度没有指向准确的方向,但实际上它收敛到非常好的解。

Error signal by epoch. Note that after decreasing the error signal very fast the model slows down and converges.

如果你仔细观察错误/事件图表,你会发现在开始时,学习的速度更快。

然而,经过一段时间后,它开始减速并趋于平稳。发生这种情况是因为,在开始时,指向最陡下降的梯度向量的幅度很大。结果,两个权重变量 W0W1 遭受更剧烈的变化。

然而,随着它们越来越接近误差表面的顶点,梯度慢慢变得越来越小,这导致权重的变化非常小。

最后,学习曲线稳定下来,这个过程就完成了。

尽情享受吧!

机器学习 101 -简介

原文:https://towardsdatascience.com/machine-learning-101-part-1-an-introduction-494cb654d50b?source=collection_archive---------10-----------------------

如果你是一名软件工程师,我敢肯定在某个时候你想做“一些机器学习”,破解宇宙的秘密,找到生命、宇宙和一切的最终答案。

然而,机器学习可能是一个相当大且令人生畏的话题:一种与你日常所做/使用的非常不同的范式,由大数据、数学模型驱动……简而言之:它超出了你通常的舒适区。

不过没关系——事实上,这是我将尝试向您介绍机器学习的主要概念的系列文章的第一部分。

© Michele Preziuso

其核心是,在机器学习中,一边是大数据,一边是你认为大数据可以解决或提供答案的问题

大数据

一般来说,大数据是一组具有以下特征的数据:

Big data characteristics — © Michele Preziuso

Volume
生成和存储数据的数量。数据的大小决定了价值和潜在的洞察力,以及是否能被认为是大数据。

Variety数据的类型和性质。这有助于分析它的人有效地使用由此产生的洞察力。大数据来自文本、图像、音频、视频;此外,它通过数据融合完成缺失的部分。

速度
在这种情况下,生成和处理数据以满足增长和发展道路上的需求和挑战的速度。大数据通常是实时可用的。与小数据相比,大数据的产生更加持续。与大数据相关的两种速度是生成的频率以及处理、记录和发布的频率。

准确性
是对大数据的扩展定义,指的是数据质量和数据价值。捕获数据的数据质量可能会有很大差异,从而影响准确的分析。

如何使用机器学习解决大数据问题?

在你可以开始考虑你的机器学习解决方案之前,你必须从问题开始:你必须完全理解它并描述它。

  1. 有什么问题?
  2. 为什么需要解决?
  3. 你会怎么解决?

1.有什么问题?

a .非正式地描述一下
软启动:像向朋友描述问题一样描述问题

b .正式描述它
我发现用正式语言描述问题非常有用,这是汤姆·米切尔在他的书机器学习中描述的(我非常推荐阅读这本书,因为这是机器学习的一个很好的起点):

机器学习领域关注的是如何构造能随着经验自动改进的计算机程序的问题。
[...
如果计算机在 T 中的任务上的性能(由 P 测量)随着经验 E 而提高,则称其从关于某类任务 T 和性能测量 P 的经验 E 中学习。

我们应该能够用 E、T 和 P 写出问题的正式描述,或者更好的是,用标题 E、T 和 P 列出我们的问题

c .研究并列出相似的问题 研究并列出任何你认为与你正在试图解决的问题相似的问题。这可以帮助你找到解决方案,在你旅途中遇到问题和潜在问题之前限制它们的范围。

d .列出所有假设和额外信息 列出所有对你的问题的表述很重要但在描述中没有提到的假设。它们可能很微妙,但能帮助你更快达到预期的结果。

以分析点击流来预测流量峰值的经典示例为例,您可以说:

  • 响应大小和用户代理无关紧要
  • 推荐可能与模型相关
  • 日期和时间是一个基本维度

2.为什么需要解决问题?

简单地考虑一下解决方案:你为什么需要构建它,你(或你的客户)将从解决这个问题中获得什么好处,…最后,你还应该考虑一下解决方案在短期内和长期内将如何使用。

通过自己的方式找到解决方案是可以的,但是您应该始终牢记长期目标,构建一个可以在未来的验证服务中轻松转换的解决方案——当然,除非您将此作为学习练习。

3.你会如何解决这个问题?

对你的数据进行取样并观察它。思考你的问题,从原始数据出发,探索你将如何获得最终结果。

编写一个高级算法,只需列出从数据收集开始执行的所有手动步骤,如何处理数据以及如何最终解决问题。

接下来就是自动化这些步骤:如果有必要的话,添加这些步骤,并构建你的解决方案的原型。容器、Jupyter 笔记本和许多其他工具是你的朋友,不要害怕使用它们,失败后再尝试。

一旦你定义了问题,你实际上可以开始构建你的机器学习解决方案——你会在这个系列的第二部分的中找到更多关于这个的内容。

机器学习 101 -解决问题的工作流程

原文:https://towardsdatascience.com/machine-learning-101-problem-solving-workflow-c1ba6b4e0e30?source=collection_archive---------16-----------------------

你如何从原始数据到一个完全工作的机器学习解决方案?

如果你是一名软件工程师,我敢肯定在某个时候你想做“一些机器学习”,破解宇宙的秘密,找到生命、宇宙和一切的最终答案。

然而,机器学习可能是一个相当大且令人生畏的话题:一种与你日常所做/使用的非常不同的范式,由大数据、数学模型驱动……简而言之:它超出了你通常的舒适区。

不过没关系——事实上,这是我将尝试向您介绍机器学习的主要概念的系列文章的第二部分。

你可以在这里找到第一部分。

© Michele Preziuso

一旦你遵循了简介文章中强调的步骤,你就应该有一个非常清晰明确的问题,以及一堆高速、大容量、高度多样化和高度准确的数据,我们称之为大数据

你如何从零到英雄?

  1. 准备您的数据
  2. 抽查机器学习算法
  3. 优化您的结果

一旦你有了想要的结果,是时候把数据可视化,成为一个英雄了!

机器学习 101 |监督、非监督、强化和超越

原文:https://towardsdatascience.com/machine-learning-101-supervised-unsupervised-reinforcement-beyond-f18e722069bc?source=collection_archive---------1-----------------------

机器学习包含数据科学家和其他专业人员使用的大量想法、工具和技术。

让我们来看看其中的一些概念,以及如何用它们来解决问题。

监督机器学习的问题和解决方案

最简单的任务属于监督学习的范畴。在监督学习中,我们可以访问正确的输入输出对的示例,并在训练阶段展示给机器。手写识别的常见示例通常被视为监督学习任务。我们向计算机显示一些手写数字的图像以及这些数字的正确标签,计算机学习将图像与标签相关联的模式。

通过明确的例子,学习如何以这种方式执行任务,相对容易理解,也容易实现,但有一项至关重要的任务:只有当我们能够访问正确的输入输出对的数据集时,我们才能完成这项任务。在手写的例子中,这意味着在某些时候我们需要派人去对训练集中的图像进行分类。这是一项费力的工作,通常不可行,但在数据确实存在的地方,监督学习算法在广泛的任务中非常有效。

监督机器学习任务可以大致分为两个子组:回归分类。回归是估计或预测连续量的问题。一个月后,S & P 500 的价值会是多少?孩子成年后会有多高?今年我们有多少客户会转向竞争对手?这些是归入回归范畴的问题的例子。为了在有监督的机器学习框架中解决这些问题,我们将收集过去处理相同问题的“正确答案”输入/输出对的例子。对于输入,我们将确定我们认为能够预测我们希望预测的结果的特征

对于第一个问题,我们可以尝试收集给定日期标准普尔 500 下股票的历史价格以及一个月后标准普尔 500 的价值作为特性。这将形成我们的训练集,机器将尝试从中确定特征和最终标准普尔 500 值之间的某种函数关系。

分类处理将观察值分配到离散的类别,而不是估计连续的数量。在最简单的情况下,有两种可能的类别;这种情况被称为二元分类。许多重要的问题都可以用二元分类法来描述。某个客户会离开我们去找竞争对手吗?给定的患者是否患有癌症?给定的图像包含热狗吗?用于执行二进制分类的算法特别重要,因为许多用于执行更一般类型的分类(其中存在任意标签)的算法仅仅是一组一起工作的二进制分类器。例如,手写识别问题的简单解决方案是简单地训练一组二进制分类器:0-检测器、1-检测器、2-检测器等等,它们输出图像是它们各自数字的确定性。分类器仅输出其分类器具有最高确定性的数字。

无监督机器学习

另一方面,有一类完全不同的任务被称为无监督学习。监督学习任务找到我们有一个“正确答案”数据集可以学习的模式。无监督的学习任务可以找到我们找不到的模式。这可能是因为“正确的答案”是不可观察的,或不可行的,或者对于一个给定的问题,甚至没有一个“正确的答案”本身。

无监督任务的一大子类就是聚类的问题。聚类指的是将观察结果分组在一起,使得同一组的成员彼此相似,而与其他组的成员不同。这里的一个常见应用是在市场营销中,我们希望识别具有相似偏好或购买习惯的客户或潜在客户的细分市场。集群的一个主要挑战是,通常很难或者不可能知道应该存在多少个集群,或者集群应该是什么样子。

Source: https://arxiv.org/abs/1511.06434

一类非常有趣的无监督任务是生成模型。生成模型是模拟生成训练数据的过程的模型。一个好的生成模型将能够生成在某种意义上类似于训练数据的新数据。这种类型的学习是无监督的,因为生成数据的过程是不可直接观察的——只有数据本身是可观察的。

这一领域的最新发展导致了图像生成方面惊人的、有时甚至是可怕的进步。这里的图像是通过训练一种称为深度卷积广义对抗网络模型的无监督学习模型来生成面部图像,并向其请求微笑男子的图像而创建的。

强化学习、混合和超越

一种新型的学习问题最近引起了广泛关注,它被称为强化学习。在强化学习中,我们不为机器提供正确的输入输出对的例子,但我们确实以奖励信号的形式为机器提供了量化其性能的方法。强化学习方法类似于人类和动物的学习方式:机器尝试一系列不同的事情,当它做得好的时候就会得到奖励。

强化学习在解空间巨大或无限的情况下是有用的,并且通常应用于机器可以被认为是与其环境交互的代理的情况。这种模型的第一个大成功故事是由一个小团队完成的,训练了一个强化学习模型,只使用游戏的像素输出作为输入来玩雅达利视频游戏。该模型最终能够在三场游戏中超越人类玩家,而创建该模型的公司不久后被谷歌以超过 5 亿美元收购。

为了对玩 Atari 视频游戏的问题实施监督学习,我们需要一个数据集,该数据集包含数百万或数十亿个由真人玩的示例游戏,以供机器学习。相比之下,强化学习的工作原理是根据机器在任务中的表现给予奖励。简单的视频游戏非常适合这种类型的任务,因为分数可以作为一种奖励。机器继续通过模拟来学习哪种模式能最大化它的回报。

通常,一些或所有这些不同领域之间的混合方法会产生好的结果。例如,某些领域的一项重要任务是异常检测的任务。异常检测算法监控一些信号,并指示何时发生了奇怪的事情。欺诈检测就是一个很好的例子。我们需要一种算法来监控信用卡交易流,并标记出奇怪的交易。但是怪异是什么意思呢?这个问题适合于一种监督/无监督的混合方法。当然,我们希望算法能够检测到一些已知的模式,我们可以通过向监督学习模型显示已知欺诈模式的示例来训练它。但我们也希望能够检测出以前未知的潜在欺诈或其他异常活动的例子,这可能通过无监督学习的方法来实现。

你可以用机器学习的基础知识走很长的路

许多最先进的工具需要大量复杂的知识,包括高等数学、统计学和软件工程。对于一个想要开始的初学者来说,这可能看起来势不可挡,特别是如果你想与一些令人兴奋的新型模型合作,这些模型会产生令人毛骨悚然的微笑男子图像或驾驶自动驾驶汽车。

好消息是,你可以用基础的东西做很多事情,这些东西很容易得到。在 R 和 Python 中实现了各种监督和非监督学习模型,这些模型可以免费获得,并且可以在您自己的计算机上直接设置,甚至像线性或逻辑回归这样的简单模型也可以用于执行有趣和重要的机器学习任务。

有兴趣了解更多机器学习背后的科学吗? 了解更多关于我们的 数据科学 课程。

这篇文章最初出现在 BrainStation 博客上。

机器学习 101 | TELUS 的数据科学家解释道

原文:https://towardsdatascience.com/machine-learning-101-telus-data-scientist-explains-32aa61995b24?source=collection_archive---------10-----------------------

如果你在技术领域工作,或者甚至正在考虑这个问题,你可能会遇到“机器学习”这个术语。在 Indeed.com 上的快速搜索显示,在撰写本文时,仅在温哥华就有超过 300 个包含“机器学习”一词的工作职位,这些工作的估计中值年薪超过 11 万美元。谷歌趋势显示,搜索词“机器学习”的受欢迎程度在最近三年增长了约 400%。显然,对具有机器学习知识的人有很高的需求——但它到底是什么?在这篇文章中,我将描述术语“机器学习”的确切含义,并解释为什么它对现代企业如此重要。

机器学习的概念定义

计算机科学家汤姆·M·米切尔有一个著名的定义,这个定义经常被使用,我将在这里改写一下。我们说一个计算机程序正在学习如何执行某项任务,如果它随着积累经验而在执行任务方面变得更好的话。因此,以这种方式学习的计算机程序被称为属于机器学习的范畴。

通过考虑满足这个定义的程序可能有助于理解这个定义。在数学和计算机科学的一些领域中,一个重要的问题是寻找一个数的质因数。如果您将数字 1081 输入到解决这个问题的程序中,它将返回数字 23 和 47 作为输出,因为 1081 = 23 * 47。想出如何编写一个简单的程序来解决这个问题并不太难——一个显而易见的方法就是尝试将 1081 除以所有小于 1081 的数。这个程序完成了任务,但是它没有学习:它没有随着经验变得更好。你可以在一百万个输入上运行这个程序,它永远不会比你第一次运行它时更快或更好地分解数字 1081。

现在让我们考虑一种不同的任务:识别笔迹。假设我们想写一个程序,它输入一个手写数字的图像,输出一个从 0 到 9 的数字。想出一个简单的方法来解决这个问题并不像上面的整数分解问题那样简单,但是我们可能会有一些想法。你可能会写一个类似这样的程序:

  • 如果图像是椭圆形,则返回 0。
  • 如果图像是垂直线,则返回 1。
  • 如果图像是上下两个圆,返回 8。

也许这种方法注定失败的原因显而易见。不同的人写的不一样。用这些规则来捕捉每一个可接受的变化,哪怕是一个数字,都是不可行的,更不用说所有的 10 个数字了。但无论如何,即使你可以,这种类型的解决方案也不能算作机器学习:规则不会随着经验的增长而改变或适应。

机器学习方法以完全不同的方式解决这个问题。机器学习程序不是试图从一开始就强加规则,而是试图通过查看示例来发现规则。在机器学习解决方案中,我们不是试图提出规则,而是试图提出数据。我们将尽可能多的预先标记的数字图像收集到所谓的训练集中,用于训练计算机程序。我们把所有的 1 的图像拿出来,给计算机看,告诉它它们是 1。然后我们对 2 的图像做同样的处理,以此类推。对于每一个数字,计算机试图自己找出这个数字的图像有什么共同之处。

我在细节上挥了一下手,但是你可以看到这种方法将如何根据我们对机器学习的工作定义随着经验而改进。有些人在他们的 7 上画十字。如果我开始的图像集不包含任何画十字的 7,我的程序可能无法识别画十字的 7 应该被标记为 7。但是随着我增加它需要看的例子的数量,最终它会以一些交叉的 7 结束,并且会知道有时 7 是交叉的。类似地,任何其他可能发生的普通变化也是如此。

Images of 7’s from the MNIST dataset. Original source: http://cs.nyu.edu/~roweis/data.html

事实证明,设计巧妙的机器学习程序可以变得非常擅长这种任务。学习如何进行机器学习的一个常见的入门项目是在一个名为的著名图像数据集 MNIST 数据库上执行这项任务。非常简单的机器学习算法可以学习以优于 90%的准确率对这些图像进行正确分类,研究人员已经使用更先进的机器学习工具达到了优于 99.7%的准确率。

机器学习什么时候起作用?

为什么手写识别问题非常适合机器学习解决方案,而整数因式分解问题却不适合?有几个关键的区别。

一个是控制投入和产出之间关系的规则的复杂性。整数因式分解问题在某种技术意义上非常困难,但因式分解问题的输入和输出之间的关系非常简单:如果程序输出的数字是质数,并且相乘得到输入,那么你就得到正确的答案。将笔迹图像与它们所代表的数字联系起来的规则要复杂、模糊得多,也难以捕捉。

一个相关的区别是,在因式分解问题中,我们正在寻找一个精确的解决方案,而在手写识别问题中,我们对一个非常好的近似解决方案感到满意。事实上,手写识别问题的精确解决方案即使在理论上也是不可行的。一些 3 看起来像 5,一些 4 看起来像 9,唯一能确定正确标签的方法是询问第一个写下数字的人。对于手写识别的解决方案,我们所能合理期望的是它在大多数情况下是正确的。

最后,手写识别似乎天生就是一项统计概率任务。作为人类,我们实际上从来不确定我们看到的是 9 还是 4。我们认为一个数字可能是 9,因为它看起来更像我们过去见过的 9,而不是我们过去见过的 4。大多数时候,我们对自己的猜测很有把握,但我们仍在猜测。我们也不应该期望计算机能做得比这更好。

为什么机器学习适用于商业问题

机器学习非常适合具有手写识别问题特征的问题,即高度复杂的问题,近似解决方案就足够的问题,以及固有的统计或概率问题。企业越来越发现他们的许多问题都有这些特征。例如,考虑标记欺诈性信用卡交易的问题。

  • **复杂性:**识别欺诈性信用卡交易的规则非常复杂,而且不断变化。
  • **近似值就足够了:**我们正在标记事务以供进一步审查,所以如果程序有时出错也没关系。
  • **解决方案是概率性的:**在我们通过联系客户进行核实之前,我们永远不能确定交易是欺诈性的。

对于这样的商业问题,我们需要什么来实现机器学习解决方案呢?数据——现代企业大量供应的一种商品。由于这些原因,企业正在发现机器学习的工具非常自然地符合他们的活动和目标,这就是为什么我们看到机器学习工具和技术在商业领域的应用如此引人注目。

自从研究人员在大约 20 世纪 60 年代开始考虑这些想法以来,机器学习作为一个领域已经成熟了很多,现在有一些基本的工具和想法被认为是机器学习的基础。除了抽象的概念定义,还有一种任何开始学习机器的人都应该理解的语言。在我的下一篇关于机器学习的文章中,我将更仔细地看看这些工具和想法,并更详细地回顾现代机器学习的语言。

有兴趣了解机器学习背后的科学吗?看看我们即将推出的数据科学课程。

这篇文章最初出现在 BrainStation 博客上。

机器学习介绍#1

原文:https://towardsdatascience.com/machine-learning-65dbd95f1603?source=collection_archive---------10-----------------------

机器学习是在没有明确编程的情况下赋予计算机学习能力的研究领域。

简单来说,机器学习就是根据数据进行预测。

Architecture of Machine Learning

机器学习现在正被广泛使用。我们日常使用的一些例子:

脸书已经使用机器学习对新闻提要故事进行排名和个性化,过滤掉攻击性内容,突出趋势话题,对搜索结果进行排名,以及识别图像和视频内容。

脸书正在使用深度学习算法来读取图像和视频内容,并用于为业务做广告。假设如果照片中有养猫的人,那么他/她一定是爱猫人士,那么脸书可以向该用户宣传猫产品。

谷歌 几乎在每个产品中都使用机器学习:

  • 照片 -:使用机器学习来识别人脸、位置、情绪等。
  • Gmail -:分析电子邮件的内容并提供智能回复。

reference : http://mashable.com/2017/05/17/gmail-smart-replies/#YQTo1XeWYOqR

  • Google now -:单词 person 的发音在世界不同的地方可能因人而异。“玩”这个词在各自的语言中发音不同。谷歌现在从不同的样本数据中学习,并在此基础上提供最佳搜索结果。
  • Youtube : Youtube 使用机器学习来改善搜索结果。以前,它用于根据内容创建者提供的元标签和文本进行搜索,但现在它分析视频内容,并向用户提供最佳内容。

亚马逊 利用机器学习进行商品推荐。

优步 使用 UberEATS 中的机器学习来计算配送食物的预计时间。

The UberEATS app hosts an estimated delivery time feature powered by machine learning models built on Michelangelo reference :- https://eng.uber.com/michelangelo/

开发者可以使用谷歌亚马逊微软IBM 提供的服务来存储数据——为了机器学习的目的训练他们自己的模型。

有很多公司投资机器学习。Udacity 在博客上提供了关于日常使用机器学习的项目的信息。

有用的链接

机器学习:温和的介绍。

原文:https://towardsdatascience.com/machine-learning-a-gentle-introduction-17e96d8143fc?source=collection_archive---------8-----------------------

在过去十年左右的时间里,机器学习和广义的数据科学席卷了技术前沿。几乎每个科技发烧友都有或想拥有一份。2012 年,《哈佛商业评论》称数据科学家的工作为“21 世纪最性感的工作”,六年后,它仍然保持着这个标签。

**但是是什么让它如此吸引人呢?**让我们仔细看看。

机器学习指的是机器或计算机学习执行某项任务并在没有明确编程的情况下做得更好的各种技术和方法。

更正式地说,

如果由 P 测量的计算机程序在 T 中的任务的性能随着经验 E 而提高,则称该计算机程序相对于某类任务 T 和性能测量 P 从经验 E 中学习。

—汤姆·米契尔(机器学习)

仅仅是机器能够自己学习执行任务的想法,就已经成为今天围绕人工智能(AI)这个子领域的广泛兴奋和热情的最大驱动力之一。

最近几项令人兴奋的发展,如自动驾驶汽车和虚拟游戏机器人,更加点燃了这一领域的好奇心,而网飞和亚马逊使用的推荐系统、谷歌翻译、语音助手 Siri、Alexa 和谷歌助手等机器学习的应用和实现,已经使我们的日常生活比几年前更加方便。

机器学习工作流

机器学习大致包括以下步骤,

Machine Learning Work-flow

  1. 数据收集:第一步也是最重要的一步是收集与我们的问题陈述相对应的相关数据。准确的数据收集对于维护我们机器学习项目的完整性至关重要。
  2. 数据预处理:上一步收集的数据很可能还不适合我们的机器学习算法使用,因为这些数据可能是不完整不一致,并且很可能包含许多错误缺失 。在处理完数据集中的所有不一致、错误和缺失数据后,我们继续进行特征工程。特征是所有独立单元共享的属性或特性,将对其进行分析或预测。特征工程是使用数据的领域知识来创建相关特征,使机器学习算法表现良好的过程。
  3. 模型训练:预处理后的数据首先主要分为两个部分,即训练/测试比通常为 70/30 或 80/20 的训练/测试数据集,对于较小的数据集,随着我们的原始数据集大小的增加,测试数据集的大小通常会减小,即使对于非常大的数据集,训练/测试比也应达到 99/1。模型训练是一个过程,机器学习算法通过该过程从训练数据集中获取见解,并且在训练期间学习特定参数,这些参数将最小化损失或者它在训练数据集中的表现有多差。
  4. 模型评估:在模型被训练之后,使用一些评估标准,在测试数据集上对它进行评估,这是它以前从未见过的。“以前从未见过”意味着模型没有从这个特定的数据集中获得任何洞察力来学习上面提到的那些参数。因此,该模型尝试仅使用从训练数据集获得的知识在测试数据集上执行。一些最常见的评估指标是准确度分数、F1 分数、平均绝对误差(MAE)和均方误差(MSE)。
  5. 性能改进:通过使用各种技术,如交叉验证超参数调整,或者通过尝试多种机器学习算法并使用表现最佳甚至更好的算法,通过使用组合多种算法结果的集成方法,可以进一步改进模型在训练和测试数据集上的性能。

机器学习的类型

  1. 监督学习
  2. 无监督学习
  3. 强化学习

监督学习

监督学习是一种机器学习任务,其中使用训练数据集在给定的一组输入特征和输出特征之间建立关系,或者更具体地说是学习一个函数。然后,这个学习的函数进一步用于预测来自测试数据集的一组新输入的输出。监督学习对标记为的训练数据进行操作,即对于每组输入特征,我们都有相应的正确的输出到学习功能映射。

监督学习主要分为两个具体任务:分类和回归。

  1. 分类:将每组输入变量分类或分离到可能的之一作为输出的监督学习任务,即输出将只由某个离散值表示。

例如,给定一个班级的学生在一年中以前的考试中的表现,我们希望预测某个特定的学生是否会通过期末考试。这种类型的问题通常被称为二进制分类问题,因为我们试图预测两类形式的输出,即“通过”或“失败”。具有两个以上类别进行预测的问题被称为多类别分类问题。

Supervised Learning Example

2.回归:它是一种监督学习任务,对于每一组输入变量,输出由连续的值表示。

修改前面的例子,给定一个班级的学生在一年中以前的考试中的表现,我们希望预测学生在期末考试中的分数百分比。分数表示为连续值,例如,百分比分数为 96.75/100 或 59.25/100。

无监督学习

与监督学习相反,无监督学习是一种机器学习任务,其中从由没有标记响应的输入数据组成的数据集得出推论,手头的主要工作是学习给定数据的结构和模式。由于我们没有标记数据,评估模型的性能不再像监督学习那样简单。最重要的无监督学习算法之一是聚类

聚类:它的任务是将一组对象分组,使得同一组中的对象(称为聚类)彼此之间比其他组(聚类)中的对象更相似(在某种意义上)。

Clustering (grouping) the given unlabelled data into 3 clusters.

强化学习

强化学习(RL)是一项机器学习任务,涉及软件代理如何在环境中采取行动,以最大化某种累积回报的概念。它遵循击中和试验方法的概念。代理人的正确或错误答案会得到一分奖励或惩罚,基于获得的正奖励分,模型会训练自己。并且一旦被训练,它就准备好预测呈现给它的新数据。

举个例子,

一个孩子正在学习如何走路。在他真正能够行走之前,他有相当多的任务要完成,比如站立、保持平衡和迈出第一步。假设他的母亲拿着巧克力站在他身边,如果他成功地完成了这些任务的一部分,这将是孩子的奖励,如果他没有完成,他也不会得到奖励。所以,孩子一步一步地学习,去做那些能给他带来回报的事情,而不去做那些不会给他带来回报的事情。

Basic Reinforcement Learning Process

在这里,在这个类比中,孩子是代理人,地板和奖励系统(母亲)组成了环境他通过采取行动与之互动,即从一个状态改变到另一个状态,即从一个子任务到另一个子任务,以最大化他的积极奖励,其中,得到巧克力是积极奖励,没有得到巧克力是消极奖励**。**

这里有一个很棒的视频让你兴奋。它展示了一个代理如何在没有任何事先指导的情况下自学行走、奔跑、跳跃和攀爬。这个人工智能是由谷歌的 DeepMind 开发的。

深度学习

深度学习一直是人工智能像今天这样快速前进的最大贡献者之一。深度学习是机器学习的一个子领域,它利用了一种被称为人工神经网络(ANNs)的机器学习算法,这种算法是由人脑模糊地启发的。神经网络的主要吸引力在于其学习输入数据的复杂非线性表示的能力。

Different Model Performance Trends

如上图所示,深度学习模型往往在处理大量数据时表现良好,而旧的机器学习模型在达到某个饱和点后就会停止改善。还可以看出,更大(更深)的神经网络往往表现得更好,但它们招致更大的计算成本。那么为什么深度学习现在正在兴起呢?

正是因为这三大原因:

  1. 开发更好的算法技术和方法。
  2. 多亏了互联网,今天有了大量的数据。
  3. GPU 的出现增强了计算能力。

最后的想法

机器学习发展得如此之快、如此之好,以至于它几乎可以应用于所有其他研究领域。大公司越来越多地投资于基于 ML 的解决方案,以解决人类难以解决或耗时的问题。现在有大量的资源可以用来开始机器学习,这些资源在五年前甚至都不存在,在无数的平台上以如此多不同的形式存在。

现在是进入机器学习和人工智能领域的最佳时机。

机器学习:一条必经之路

原文:https://towardsdatascience.com/machine-learning-a-path-that-must-be-travelled-7bd7967b2912?source=collection_archive---------7-----------------------

随着科技的进步,这个时代变得多么容易,而且每天都在进步。从自动人脸检测到癌症预测,天气预报到地震预测,你的私人助理,如苹果的 Siri 和谷歌的助手(对不起 Cortana),智能机器人到自动驾驶汽车,还有更多应用有待开发。机器学习自诞生以来已经走过了数英里,并从根本上扩大了计算的范围。现在你有了能做决定的智能电脑,让你的生活变得简单。这个博客只是关于我对机器学习的了解和思考。

这个旅程始于六个月前,我在寒假开始学习 ML。我投资了我的 15 天假期,并对它产生了兴趣。对我来说,ML 不仅仅是关于统计学,概率,而是更多的高级概念,它是我在数学课上学到的知识的应用。最初对我来说,理解这些概念非常困难,因为观想能力差,所以我把它留了下来,想在暑假开始。所以我又开始学习这些概念,并且我决定我不会停止学习,直到我从自己身上得到积极的反馈。

我从一个著名的学习平台 Coursera 开始学习 ML,导师是 Andrew ng,他是 ML 初学者领域的知名人士之一。我真的很喜欢这门课程,到今天为止,我已经了解了回归概念,这是监督学习的一部分,简单地说,它是给定数据集的直线拟合或曲线拟合,并基于这些对给定特征集的输出进行预测。例如,假设你要去一个城市,在你的预算范围内寻找一所房子,你有以下一组数据

  1. 卧室数量
  2. 公寓类型
  3. 学校数量
  4. 该地区的公共汽车数量

然后使用回归,您可以获得该地区房屋的租金或价格(大约)信息。这些是我为智能城市假设的一些功能,您可以添加/删除更多功能,这些功能可以为您提供更好的训练集。这只是回归的一个很小的例子,这个概念有很广泛的应用。这只是我旅程中很小的一部分,还有更多的路要走,更多的路要走。

~ उत्कर्ष_उवाच

机器学习算法 vs 精算……谁会赢?

原文:https://towardsdatascience.com/machine-learning-algorithm-vs-actuarial-science-who-will-win-b203f31145ce?source=collection_archive---------0-----------------------

机器学习算法 vs 精算……保险行业谁会赢?

机器学习算法与精算科学:

在当今快节奏的技术世界中,保险业高管或有抱负的领导者必须考虑未来、投资者预期、扩展和利用技术,以及这个新问题 “机器学习算法与精算科学?”

ML 与 AS——有什么区别?

机器学习(ML) 是一种人工智能(AI),它为计算机提供了学习的能力,而无需显式编程。机器学习专注于开发计算机程序,这些程序可以在接触到新数据时教会自己成长和变化。

精算学(AS) 是应用数学和统计方法评估保险、金融等行业和职业风险的学科。精算师是通过密集的教育和丰富的经验在该领域获得资格的专业人士。精算师使用统计推断来帮助预测未来。精算师帮助保险商理解数据中的“为什么”,他们为试图通过统计数据理解风险的保险商和组织带来巨大的价值。

机器学习算法与精算科学是保险行业领导者持续争论的话题。最终,一名精算师将与一名数据科学家合作,构建一种可以做到这两点的算法和工具。在此之前,我们将关注这两个领域相互竞争的观点。

承销商需要知道原因吗?如果他们能通过 ML 算法得到结果呢?

你或你的股东会为了增加规模、相关性和速度而牺牲风险或股本的最佳回报吗?这一代保险公司/再保险人的问题。

如果你可以使用 ML 算法获得 8–9%的净资产收益率,同时降低你的费用和规模,那么使用传统精算学获得 10%的净资产收益率是否是可持续的?如果 ML 算法产生了同样的 ROE ~10%会怎样?

这些例子强调了一个基本问题——精算过程是否提供了足够的价值来支持时间、成本和约束?或者,行业高管是否应该专注于使用 ML 算法来构建类似的回报&利用该技术来扩大规模,提高与客户/经纪人/市场的相关性。

如果不是,您是否愿意使用算法返回承保结果的 Beta 值,而不是使用精算师生成 alpha 值?

机器学习算法方法的优势

费用节省

如果需要更少的精算师,速度会提高,承销商可以更容易地调整他们的投资组合,从而节省更多的费用。

如果这些节省下来的钱被用来雇佣更多的理赔人员。用于评估风险价格(精算工资)的购置费用中节省的资金可以重新分配给索赔人员/资源。正如这里讨论的,我们认为索赔是分配资源以改善结果的最佳方式之一——重点应放在损失成本方面。这应该是被保险人保险公司的重点——以及我们如何随着时间的推移为客户增加价值。

通过雇佣额外的索赔专家,保险公司可以节省成本。例如,节省 250 万美元对损失率的影响相当于承保 1000 万至 2500 万美元的保费——取决于产品线损失率。当您看到对底线的影响时,增加理赔人员会对您有所帮助。

时间分析速度

如果算法正在处理提交信息,则可以提高事务和分析的速度。因此,为承保人提供了改进的覆盖范围和风险分析的周转时间。

刻度

ML 算法的性质将允许保险公司/再保险公司扩大规模和增长。这种规模提供了许多好处——如前所述,有助于降低费用和费用比率。这种规模还将帮助你维持与核心客户的首选关系,以及吸收冲击损失的能力。

从 1 亿美元的投资组合中赚取 3000 万美元的利润,与从 1.5 亿美元的投资组合中赚取 5000 万美元的利润一样好还是更好?

结果

我们预计这场辩论将持续相当长一段时间,因为该行业历来不愿接受变革。但是,我们预测会发生以下情况:

  • 保险业将需要数据工程师
  • 保险业将需要数据科学家
  • 保险业将需要更少的“纯精算师”资源
  • 软件开发人员将构建平台,为非数据科学家提供易于使用的输出
  • 保险公司和再保险公司拥有的数据和员工将成为他们创造 Alpha 的最有价值的资产
  • 我们预测这些新工具将产生不同类型的未来保险公司/再保险公司,以及来自投资者的不同期望。
  • 承销商将继续销售产品,评估风险,并改变覆盖范围,但必须精通数据科学领域
  • 两种不同类型的保险公司
  • 快速报价和小行——这将产生市场的 beta 回报
  • 慢速报价较大的行使用精算科学—生成 alpha
  • 两种不同类型的再保险人
  • 快速报价和小行——这将产生市场的 beta 回报
  • 慢速报价较大行使用精算科学-生成 alpha

更多关于保险行业的信息可以在www.myinsuranceshark.com找到

Python 中的层次凝聚聚类算法实例

原文:https://towardsdatascience.com/machine-learning-algorithms-part-12-hierarchical-agglomerative-clustering-example-in-python-1e18e0075019?source=collection_archive---------1-----------------------

分层聚类算法将相似的对象分组为称为的组。有两种类型的分层聚类算法:

  • 凝聚—自下而上的方法。从许多小集群开始,将它们合并在一起以创建更大的集群。
  • 分裂——自上而下的方法。从单个集群开始,然后将它分成更小的集群。

分层聚类的一些优点和缺点

赞成的意见

  • 不假设特定数量的聚类(即 k 均值)
  • 可能对应有意义的分类法

骗局

  • 一旦决定合并两个集群,就无法撤销
  • 对于大型数据集太慢,O(𝑛2 log(𝑛))

它是如何工作的

  1. 使每个数据点成为一个群集

2.取两个最近的集群,并使它们成为一个集群

3.重复步骤 2,直到只有一个集群

系统树图

我们可以使用树状图来可视化分组的历史,并计算出最佳的聚类数。

  1. 确定不与任何其他聚类相交的最大垂直距离
  2. 在两端画一条水平线
  3. 聚类的最佳数量等于穿过水平线的垂直线的数量

例如,在下面的情况中,集群数量的最佳选择将是 4

链接标准

类似于梯度下降,您可以调整某些参数,以获得截然不同的结果。

链接标准指的是如何计算聚类之间的距离。

单键

两个聚类之间的距离是每个聚类中两点之间的最短距离

完全连锁

两个聚类之间的距离是每个聚类中两点之间的最长距离

平均连锁

聚类之间的距离是一个聚类中的每个点到另一个聚类中的每个点的平均距离

病房联动

聚类之间的距离是所有聚类内的平方差之和

距离度量

您用来计算数据点之间距离的方法将影响最终结果。

欧几里得距离

两点之间的最短距离。例如,如果 x=(a,b)且 y=(c,d),则 x 和 y 之间的欧几里德距离为√(a c)+(b d)

曼哈顿距离

想象一下,你在一个大城市的市中心,你想从 A 点到 b 点。你不能穿过建筑物,而是必须沿着不同的街道行走。例如,如果 x=(a,b)且 y=(c,d),则 x 和 y 之间的曼哈顿距离为| a c |+| b d |

python 中的示例

让我们看一个具体的例子,看看我们如何使用层次凝聚聚类来标记数据。

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
from sklearn.cluster import AgglomerativeClustering
import scipy.cluster.hierarchy as sch

在本教程中,我们使用 csv 文件,其中包含一个客户列表,包括他们的性别、年龄、年收入和支出分数。

如果你想跟进,你可以从 superdatascience 网站获得数据集。

[## 机器学习 A-Z:下载实践数据集-超级数据科学-大数据|分析职业生涯…

欢迎来到机器学习课程的数据仓库,作者是基里尔·叶列缅科和哈德琳·德·庞特维斯…

www.superdatascience.com](https://www.superdatascience.com/machine-learning/)

为了稍后在图表上显示我们的数据,我们只能取两个变量(年收入和支出分数)。

dataset = pd.read_csv('./data.csv')

X = dataset.iloc[:, [3, 4]].values

查看树状图,不与任何集群相交的最高垂直距离是中间的绿色。假设有 5 条垂直线穿过阈值,则最佳聚类数是 5。

dendrogram = sch.dendrogram(sch.linkage(X, method='ward'))

我们创建了一个实例AgglomerativeClustering,使用欧几里得距离作为点之间距离的度量,并使用 ward 连接来计算聚类的邻近度。

model = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')
model.fit(X)
labels = model.labels_

属性返回一个整数数组,其中的值对应于不同的类别。

我们可以使用简写符号将属于某一类别的所有样本显示为特定的颜色。

plt.scatter(X[labels==0, 0], X[labels==0, 1], s=50, marker='o', color='red')
plt.scatter(X[labels==1, 0], X[labels==1, 1], s=50, marker='o', color='blue')
plt.scatter(X[labels==2, 0], X[labels==2, 1], s=50, marker='o', color='green')
plt.scatter(X[labels==3, 0], X[labels==3, 1], s=50, marker='o', color='purple')
plt.scatter(X[labels==4, 0], X[labels==4, 1], s=50, marker='o', color='orange')
plt.show()

Python 中的均值漂移聚类算法示例

原文:https://towardsdatascience.com/machine-learning-algorithms-part-13-mean-shift-clustering-example-in-python-4d6452720b00?source=collection_archive---------12-----------------------

均值漂移是一种分层聚类算法。与有监督的机器学习算法相比,聚类试图在没有首先对标记数据进行训练的情况下对数据进行分组。聚类被广泛应用于搜索引擎、学术排名和医学等领域。与 K-Means 相反,当使用 Mean Shift 时,您不需要事先知道类别(聚类)的数量。均值漂移的缺点是计算量很大——O(n)。

它是如何工作的

  1. 定义一个窗口(内核的带宽)并将该窗口放置在一个数据点上

2.计算窗口中所有点的平均值

3.将窗口的中心移动到平均值的位置

4.重复步骤 2 和 3,直到收敛

python 中的示例

让我们看看如何使用 python 中的均值漂移算法来标注数据。

import numpy as np
import pandas as pd
from sklearn.cluster import MeanShift
from sklearn.datasets.samples_generator import make_blobs
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

我们使用make_blobs方法生成自己的数据。

clusters = [[1,1,1],[5,5,5],[3,10,10]]
X, _ = make_blobs(n_samples = 150, centers = clusters, cluster_std = 0.60)

在训练模型之后,我们存储聚类中心的坐标。

ms = MeanShift()
ms.fit(X)
cluster_centers = ms.cluster_centers_

最后,我们在 3D 图形中绘制数据点和质心。

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')ax.scatter(X[:,0], X[:,1], X[:,2], marker='o')ax.scatter(cluster_centers[:,0], cluster_centers[:,1], cluster_centers[:,2], marker='x', color='red', s=300, linewidth=5, zorder=10)plt.show()

K-means 聚类 Python 示例

原文:https://towardsdatascience.com/machine-learning-algorithms-part-9-k-means-example-in-python-f2ad05ed5203?source=collection_archive---------0-----------------------

K-Means 聚类是一种无监督的机器学习算法。与传统的监督机器学习算法相比,K-Means 试图在没有首先用标记数据训练的情况下对数据进行分类。一旦运行了算法并定义了组,任何新数据都可以很容易地分配到最相关的组。

K-Means 的实际应用包括:

  • 客户特征分析
  • 市场分割
  • 计算机视觉
  • 搜索引擎
  • 天文学

它是如何工作的

  1. 选择 K (即 2) 个随机点作为称为质心的聚类中心

2.通过计算每个数据点相对于每个质心的距离,将每个数据点分配给最近的聚类

3.通过计算指定点的平均值来确定新的聚类中心

4.重复第 2 步和第 3 步,直到集群分配没有任何变化

选择正确的集群数量

通常情况下,您要处理的数据会有多个维度,因此很难可视化。因此,最佳聚类数不再明显。幸运的是,我们有办法从数学上确定这一点。

我们绘制了聚类数和聚类平方和(WCSS)之间的关系,然后我们选择了 WCSS 变化开始变平的聚类数(肘形法)。

WCSS 被定义为集群的每个成员与其质心之间的平方距离之和。

例如,为图 1 的计算的 WCSS 将大于为图 2计算的 WCSS。

Figure 1

Figure 2

密码

让我们看看如何使用 python 的 K-Means 算法对数据进行分类。和往常一样,我们需要从导入所需的库开始。

import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.datasets.samples_generator import make_blobs
from sklearn.cluster import KMeans

在本教程中,我们将使用来自sklearn.datasets模块的make_blobs函数生成我们自己的数据。centers参数指定了集群的数量。

X, y = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)plt.scatter(X[:,0], X[:,1])

即使我们已经知道了最佳的集群数量,我认为我们仍然可以从使用肘方法来确定它中获益。为了获得图表中使用的值,我们使用不同数量的分类来训练多个模型,并且每次都存储intertia_属性(WCSS)的值。

wcss = []for i in range(1, 11):
    kmeans = KMeans(n_clusters=i, init='k-means++', max_iter=300, n_init=10, random_state=0)
    kmeans.fit(X)
    wcss.append(kmeans.inertia_)
plt.plot(range(1, 11), wcss)
plt.title('Elbow Method')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()

接下来,我们将使用上一步中确定的最佳聚类数(4)对数据进行分类。k-means++确保你得到的东西不会落入随机初始化陷阱。

kmeans = KMeans(n_clusters=4, init='k-means++', max_iter=300, n_init=10, random_state=0)
pred_y = kmeans.fit_predict(X)plt.scatter(X[:,0], X[:,1])
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=300, c='red')
plt.show()

机器学习——一个错误,不管它叫什么名字…

原文:https://towardsdatascience.com/machine-learning-an-error-by-any-other-name-a7760a702c4d?source=collection_archive---------1-----------------------

在计算机科学和人工智能取得巨大进步的时代,人们很容易忘记模型本身并不完美。最令人头疼的问题之一是如何衡量一个模型相对于已知事实的准确性。

第一步是理解错误的代价。你宁愿错误地猜测某事是真的,而事实并非如此,还是根本不去猜测。有时,失去一个客户比花时间留住他们更便宜,或者相反,那些可能没有得病的人接种疫苗的成本比疾病的潜在传播成本更便宜。这种成本/收益分析将告知用于确定出错概率的方法。

假设的重要性

建模最重要的部分是从一个有意义的问题开始。出于本能,我们会提出一个问题,作为对某事的肯定,比如“飞机座位之间的空间正在缩小。”然而,最好的统计实践是创建一个像“座位之间的距离保持不变”这样的无效假设(也经常被称为 H0),然后试图证明它是错误的。

这提供了无罪推定的统计版本,有助于消除随机性的影响。如果零假设在统计学上被证明是不成立的,那么另一个假设(被称为 H1)将被重新审视,航空公司的萎缩趋势现在被认为是一个可能但不确定的解释。

重要的是要注意,零假设并不完全与替代假设相反,而是验证观察结果的原因不仅仅是随机的。

概率和 P 值

概率提供了一种解释模型统计强度的通用方法。称为 p 值,范围从 0 到 1,表示如果零假设(H1)为真,得到结果的可能性有多大。这意味着值越低,替代假设(H1)实际上是正确的指示就越好。

p 值的阈值称为显著性水平。如果概率等于或小于 0.05(尽管取决于可能改变的用例),那么结果通常被认为是显著的。更简单地说,我们很可能 100 次中有 5 次证实了零假设(或者相反,100 次中有 95 次证实了另一个假设)。p 值越高,越接近随机机会,越有可能出现零假设。

分类问题中的误差度量

分类问题通常是二元识别,确定一个观察值是否是某个条件。任何分类模型都有四种类型的结果。

真阳性(TP)-真阳性测试结果是指当条件存在时检测到该条件。

假阳性(FP)-也称为I 型错误,假阳性测试结果是在条件不存在时检测到的条件。

假阴性(FN)-也称为II 型错误,假阴性测试结果是指当条件存在时没有检测到条件。

真阴性(TN) -真阴性测试结果是指当条件不存在时,没有检测到条件。

根据这四种状态,用不同的比率和公式计算误差。很容易看出,根据类型 I 或类型 II 的成本,测量误差的方法可以调整。

测量误差

为了理解模型是如何执行的,有多种方法来衡量各种条件的相互作用。一个混淆矩阵 (是的,确实是这么叫的)用于呈现多种类型的误差测量,以便数据科学家可以确定模型是否表现良好。下面我们将介绍以下类型的误差测量:

  • 特异性或真阴性率(TNR)
  • 精确度,阳性预测值(PPV)
  • 回忆、敏感度、命中率或真阳性率(TPR)
  • f 测量(F1,F0.5,F2)
  • 马修相关系数
  • ROC 面积(ROC AUC)
  • 辐射、假阳性率(FPR)
  • 决定系数
  • 均方根误差(RMSE)
  • 平均绝对误差

特异性或真阴性率(TNR)

TNR(范围从 0 到 1,越高越好)测量被正确识别为阴性的比例(例如,被正确识别为没有该状况的健康人的百分比)。

TNR = TN/(TN+FP)

如果缺失负值的成本很高,这是一个很好的衡量标准。

精确度,阳性预测值(PPV)

PPV(范围从 0 到 1,越高越好)是真阳性与所有真阳性和假阳性的比率:

PPV = TP/(TP+FP)

高精度意味着算法返回的相关结果比不相关的结果多得多,换句话说,它返回的所有结果越有可能是正确的,但这并不意味着它可能会得到所有正确的结果。

同样,这也可以用负预测值(NPV)来完成,将正预测值转换为负预测值,并进行计算以确定负预测值的精度。NPV 的补充是错误遗漏率(FOR)。

回忆、敏感度、命中率或真阳性率(TPR)

TPR(范围从 0 到 1,越高越好)是真阳性与真阳性和假阴性之和的比率:

TPR = TP / (TP+FN)

高召回率意味着一个算法返回了大部分相关结果,但它可能会有一堆错误的返回,就像一张拖网,它肯定会抓住你想要的鱼,但也会抓住一堆你不想要的鱼。

f 测度

F Measure(范围从 0 到 1)是描述精确度(PPV)和召回率(TPR)之间平衡的比率。使用调和平均值,它可以描述一个模型向某个方向倾斜的程度。

F = (PPV*TPR)/(PPV+TPR)

或者

F = 2TP/(2TP+FP+FN)

最常见的称为 F1,而另外两种常用的 F 度量是 F2 度量和 F0.5 度量,F2 度量的权重召回率高于召回率,F 0.5 度量的权重召回率高于召回率。

马修相关系数(MCC)

MCC(范围从-1 到 1)是生物化学家 Brian W. Matthews 在 1975 年提出的。MCC 本质上是观察到的和预测的二元分类之间的相关系数。系数+1 代表完美的预测,0 等于不比随机预测好,1 表示预测和观察完全不一致。这通常被表示为关联热图,就像这里一样,并允许快速观察哪些功能是有用的(进一步深入阅读这里关于所有类型的关联)。

MCC =(TP * TN—FP * FN)/Sqr(FT+FP)(TN+FP)(TN+FN)

0.05+的值可用作模型的特征,在某些情况下,负相关也是有用的。

ROC 面积(ROC AUC )

ROC 或“接收机工作特性”(范围从 0 到 1,越高越好)最初用于第二次世界大战中的雷达目标探测。ROC 面积是通过绘制 TPR 和 FPR 之间的比率而产生的曲线下面积的度量,值范围从 1-.8 是很好,0.8-. 6 是一般差,低于 0.8 不是好于随机机会。

最近,由于结果的嘈杂和不一致,使用 ROC 的有效性受到质疑(几篇论文的一个例子是这里是)。

辐射、假阳性率(FPR)

FPR(范围从 0 到 1,越低越好)是被错误分类为阳性(假阳性)的阴性事件数与实际阴性事件总数之间的比率。

FDR = FP/(FP+TN)

与上面的许多错误率不同,值越高越糟糕,因为这意味着识别出的假阴性越多。

精确度(ACC)

精确度(范围从 0 到 1,越高越好)就是正确预测的观测值与总观测值的比率。

ACC = (TP+TN)/(TP+FP+FN+TN)

人们本能地认为准确性是一个很好的衡量标准,但它实际上很少告诉你什么是假阳性和假阴性。

回归和误差方法

与上面的分类问题不同,回归不产生二进制绝对值,而是产生一个数值范围。理想情况下,算法应该是稳定的,尽管这意味着很大程度上取决于具体情况。

r,决定系数

决定系数(范围从 0 到 1,越大越好),通常也称为 R 或 R,是使用普通最小二乘回归时数据与回归拟合程度的比例。

根据具体情况,有多个优化版本的 R 可供使用。R 的性质意味着变量的加入,不管有用与否,总会增加它的值。在这些情况下,可以使用调整后的 R。

均方根误差(RMSE)

RMSE(范围从 0 到无穷大,越低越好),也称为均方根偏差(RMSD),是一种基于平方的规则,用于测量误差的绝对平均幅度。从技术上来说,它是通过取残差(回归模型和实际数据之间的差异),平方它,平均所有结果,然后取平均值的平方根而产生的。因此,乘积总是正数。

因为值是在平均值之前平方的,较大误差的影响(想想 3 对 8 的结果)被极大地放大了,并且应该被用来识别那些类型的误差是很重要的(是一篇很好的文章,详细解释了很多)。

为了在不同尺度的模型之间进行比较,RMSD 可以通过平均值或范围进行归一化。它通常用百分数来表示,并用 NRMSD 或 NRMSE 来表示。

平均绝对误差

MAE(范围从 0 到无穷大,越低越好)与 RMSE 非常相似,但它不是对残差的差求平方并取结果的平方根,而是对残差的绝对差求平均值。这只会产生正数,对较大的误差反应较小,但可以更好地显示细微差别。随着时间的推移,它也失宠了。

摘要

了解如何衡量误差可以帮助你判断什么时候事情好得不像真的,或者它是否真的有效。在将这些放在一起时,我个人意识到我需要探索的下一件事是规范化以及它如何影响错误识别。记住,在创建识别错误的方法之前,要考虑错误的代价,否则它会让你追逐蝴蝶,而不是识别正确的优化。

考虑到任何模型都是针对其接受训练的数据进行高度优化的。预计新数据的错误率将总是高于训练集的错误率。

这远不是全面的误差测量列表,去探索吧!

其他链接:

[## 模型精度

模型精度通常通过测量拟合质量(通常是均方误差)来评估。

medium.com](https://medium.com/@FranklynZhu/model-accuracy-3f374f242d93) [## 混淆矩阵术语简单指南

混淆矩阵是一个表格,通常用于描述分类模型(或“分类器”)的性能

www.dataschool.io](http://www.dataschool.io/simple-guide-to-confusion-matrix-terminology/) [## 精确测量模型预测误差

在评估模型的质量时,能够准确测量其预测误差是非常重要的…

scott.fortmann-roe.com](http://scott.fortmann-roe.com/docs/MeasuringError.html) [## 评估机器学习中的模型性能

本文演示了如何在 Azure Machine Learning Studio 中评估模型的性能,并提供了一个

docs.microsoft.com](https://docs.microsoft.com/en-us/azure/machine-learning/studio/evaluate-model-performance) [## 什么是假设检验?- Minitab

假设检验检验关于总体的两种相反的假设:零假设和备择假设。

support.minitab.com](https://support.minitab.com/en-us/minitab/18/help-and-how-to/statistics/basic-statistics/supporting-topics/basics/what-is-a-hypothesis-test/)

机器学习|简介

原文:https://towardsdatascience.com/machine-learning-an-introduction-23b84d51e6d0?source=collection_archive---------0-----------------------

内容

介绍

不可否认,机器学习是当今世界最有影响力和最强大的技术之一。更重要的是,我们远远没有看到它的全部潜力。毫无疑问,在可预见的未来,它将继续成为头条新闻。本文旨在介绍机器学习的概念,涵盖所有的基本概念,但不要太深奥。

机器学习是一种将信息转化为知识的工具。在过去的 50 年里,数据呈爆炸式增长。除非我们对这些数据进行分析并找出其中隐藏的模式,否则这些数据毫无用处。机器学习技术被用来自动发现复杂数据中有价值的潜在模式,否则我们将很难发现。隐藏的模式和关于问题的知识可以用来预测未来的事件和执行各种复杂的决策。

我们淹没在信息中,渴望知识——约翰·奈斯比特

我们大多数人都没有意识到,我们每天都在与机器学习互动。每当我们谷歌一些东西,听一首歌,甚至拍一张照片,机器学习都在成为其背后引擎的一部分,不断从每次交互中学习和改进。它也是改变世界的进步的背后,如检测癌症,创造新药和无人驾驶汽车。

机器学习之所以如此令人兴奋,是因为它与我们以前所有基于规则的系统有所不同:

if(x = y): do z

传统上,软件工程结合人类创造的规则数据创造出问题的答案。相反,机器学习使用数据答案发现问题背后的规则。(乔莱,2017 年)

Traditional Programming vs Machine Learning

为了学习支配现象的规则,机器必须经历一个**学习过程,**尝试不同的规则,并从它们的表现中学习。因此,它被称为机器学习。

机器学习有多种形式;有监督、无监督、半监督和强化学习。每种形式的机器学习都有不同的方法,但它们都遵循相同的基本过程和理论。这个解释涵盖了一般的机器学习概念,然后集中在每一种方法。

术语

  • 数据集:一组数据示例,包含对解决问题很重要的特征。
  • 特征:帮助我们理解问题的重要数据。这些被输入到机器学习算法中来帮助它学习。
  • 模型:机器学习算法已经学习到的现象的表示(内部模型)。它从训练期间显示的数据中学习这一点。模型是你训练一个算法后得到的输出。例如,决策树算法将被训练并产生决策树模型。

过程

  1. **数据收集:**收集算法将要学习的数据。
  2. **数据准备:**将数据格式化,工程化为最优格式,提取重要特征,进行降维。
  3. **训练:**也称为拟合阶段,这是机器学习算法通过向它显示已经收集和准备的数据来实际学习的阶段。
  4. **评估:**测试模型,看其表现如何。
  5. **调整:**微调模型,使其性能最大化。

背景理论

起源

分析引擎编织代数模式,就像贾夸德编织花朵和树叶一样——阿达·洛芙莱斯

阿达·洛芙莱斯,计算机的创始人之一,也可能是第一个计算机程序员,意识到世界上的任何事情都可以用数学来描述。

更重要的是,这意味着可以创建一个数学公式来推导代表任何现象的关系。阿达·洛芙莱斯意识到机器有潜力在不需要人类帮助的情况下理解世界。

大约 200 年后,这些基本思想在机器学习中至关重要。无论问题是什么,它的信息都可以作为数据点绘制到图表上。机器学习然后试图找到隐藏在原始信息中的数学模式和关系。

概率论

概率是有序的观点……从数据中推断无非是根据相关的新信息对这种观点的修正——托马斯·贝叶斯

另一位数学家托马斯·贝叶斯创立了概率论中的基本思想,这些思想体现在机器学习中。

我们生活在一个概率世界。所有发生的事情都有不确定性。概率的贝叶斯解释是机器学习的基础。贝叶斯概率意味着我们认为概率是量化事件的不确定性。

正因为如此,我们不得不将概率建立在关于一个事件的可用信息上,而不是计算重复试验的次数。例如,当预测一场足球比赛时,贝叶斯方法将使用相关信息,如当前状态、联赛排名和首发球队,而不是计算曼联战胜利物浦的总次数。

采用这种方法的好处是概率仍然可以分配给罕见事件,因为决策过程是基于相关特征推理

机器学习方法

在进行机器学习时,有许多方法可以采用。它们通常分为以下几个方面。监督和非监督是公认的方法,也是最常用的方法。半监督和强化学习是更新和更复杂的,但已经显示出令人印象深刻的结果。

没有免费的午餐定理在机器学习中很有名。它指出,没有一种算法可以适用于所有的任务。你试图解决的每一个任务都有它自己的特点。因此,有许多算法和方法来适应每个问题各自的特点。更多类型的机器学习和人工智能将不断推出,以更好地适应不同的问题。

监督学习

在监督学习中,目标是学习一组输入输出之间的映射**(规则)。**

例如,输入可以是天气预报,输出可以是海滩的游客。监督学习的目标是学习描述温度和海滩游客数量之间关系的映射。

示例标记为的数据在学习过程中提供给过去的输入和输出对,以教导模型应该如何运行,因此是“受监督的”学习。对于海滩的例子,新的输入然后可以被输入到预测温度的中,然后机器学习算法将输出游客数量的未来预测**。**

能够适应新的输入并做出预测是机器学习的关键概括部分。在训练中,我们希望最大化一般化,因此监督模型定义了真正的“一般”潜在关系。如果模型被过度训练,我们会导致过度拟合所使用的例子,并且模型将无法适应新的、之前未见过的输入。

在监督学习中需要注意的一个副作用是,我们提供的监督会给学习带来偏差。该模型只能完全模仿它被展示的样子,所以向它展示可靠的、无偏见的例子是非常重要的。还有,监督学习在学习之前通常需要大量的数据。获得足够的可靠标记的数据通常是使用监督学习最困难和最昂贵的部分。(这就是数据被称为新石油的原因!)

受监督的机器学习模型的输出可以是来自有限集合的类别,例如海滩游客数量的【低、中、高】:

Input [temperature=**20**] -> *Model* -> Output = [visitors=**high**]

在这种情况下,它决定如何对输入进行分类,因此称为分类**。**

或者,输出可以是一个真实世界标量(输出一个数字):

Input [temperature=**20**] -> *Model* -> Output = [visitors=**300**]

在这种情况下,它被称为回归

分类

分类用于将相似的数据点分组到不同的部分,以便对它们进行分类。机器学习用于寻找解释如何分离不同数据点的规则

但是神奇的规则是怎么创造出来的呢?嗯,有多种方法可以发现规律。他们都专注于使用的数据和答案来发现线性分离数据点的规则

线性可分性是机器学习中的一个关键概念。所有的线性可分性意味着‘不同的数据点可以用一条线分开吗?’。简而言之,分类方法试图找到用一条线分隔数据点的最佳方式。

类之间的界限被称为决策边界。被选择来定义一个类的整个区域被称为决策面。决策面定义了如果一个数据点落在它的边界内,它将被分配一个特定的类。

回归

回归是监督学习的另一种形式。分类和回归的区别在于回归输出一个数字而不是一个类。因此,当预测基于数字的问题时,如股票市场价格、给定日期的温度或事件的概率,回归是有用的。

例子

回归在金融交易中用于寻找股票和其他资产的模式,以决定何时买入/卖出并获利。对于分类,它已经被用来分类你收到的电子邮件是否是垃圾邮件。

分类和回归监督学习技术都可以扩展到更复杂的任务。例如,涉及语音和音频的任务。图像分类、物体检测和聊天机器人就是一些例子。

下面显示的一个最近的例子使用了一个经过监督学习训练的模型来逼真地伪造人们说话的视频。

您可能想知道这个复杂的基于图像的任务与分类或回归有什么关系?嗯,这又回到了世界上的一切,甚至是复杂的现象,从根本上用数学和数字来描述。在这个例子中,神经网络仍然只输出回归中的数字。但是在这个例子中,数字是面部网格的数字 3d 坐标值。

无监督学习

在无监督学习中,在示例中仅提供了输入数据。没有目标明确的示例输出。但令人惊讶的是,仍然有可能在没有任何标签的数据中发现许多有趣而复杂的模式。

现实生活中无监督学习的一个例子是将不同颜色的硬币分类成不同的堆。没有人教你如何把它们分开,但是通过观察它们的特征,比如颜色,你可以看出哪些颜色的硬币与它们相关联,并把它们归入正确的类别。

An unsupervised learning algorithm (t-SNE) correctly clusters handwritten digits into groups, based only on their characteristics

无监督学习可能比有监督学习更难,因为监督的去除意味着问题变得不太明确。该算法对于寻找什么样的模式不太关注。

在自己的学习中想一想。如果你在老师的指导下学习弹吉他,通过重复使用音符、和弦和节奏的知识,你会学得很快。但是如果你只是自学,你会发现知道从哪里开始要困难得多。

通过在自由放任的教学风格中不受监督,你可以从一张没有偏见的白纸开始,甚至可能找到一种新的、更好的方法来解决问题。所以,这也是为什么无监督学习又被称为知识发现的原因。在进行探索性数据分析时,无监督学习非常有用。

为了在未标记的数据中找到感兴趣的结构,我们使用密度估计。其中最常见的形式是集群。其中还有降维潜在变量模型异常检测。更复杂的无监督技术涉及神经网络,如自动编码器和深度信念网络,但我们不会在这篇介绍博客中深入讨论它们。

使聚集

无监督学习多用于聚类。聚类是创建具有不同特征的群体的行为。聚类试图在一个数据集中找到各种子组。由于这是无监督的学习,我们不受任何标签集的限制,可以自由选择创建多少个聚类。这既是福也是祸。必须通过经验模型选择过程来挑选具有正确数量的聚类(复杂性)的模型。

关联

在关联学习中,你希望发现描述你的数据的规则。例如,如果一个人观看视频 A,他们可能会观看视频 b。关联规则非常适合于这样的例子,例如您想要查找相关项目

异常检测

与大多数数据不同的稀有或不寻常项目的识别。例如,您的银行将利用这一点来检测您卡上的欺诈活动。你正常的消费习惯会在正常的行为和价值观范围内。但是当有人试图用你的卡偷你的东西时,这种行为将与你的正常模式不同。异常检测使用无监督学习来分离和检测这些奇怪的事件

降维

降维的目的是找到最重要的特征将原始特征集减少到一个更小更有效的集合中,而仍然对重要数据进行编码

例如,在预测海滩的游客数量时,我们可以使用温度、星期几、月份和当天安排的活动数量作为输入。但是月份实际上对于预测游客数量可能并不重要。

诸如此类的不相关特征可能会混淆机器学习算法,使它们的效率和准确性降低。通过使用维度缩减,仅识别和使用最重要的特征。主成分分析(PCA)是一种常用的技术。

例子

在现实世界中,聚类已被成功地用于发现一种新类型的恒星,通过研究恒星的子群根据恒星的特征自动形成。在市场营销中,它通常用于根据客户的行为和特征将客户分成相似的组。

关联学习用于推荐或查找相关项目。一个常见的例子是市场篮子分析。在购物篮分析中,发现关联规则可以根据客户在购物篮中放了什么来预测他们可能购买的其他商品。亚马逊用这个。如果你把一台新的笔记本电脑放在你的购物篮里,他们会通过他们的关联规则推荐像笔记本电脑外壳这样的东西。

异常检测非常适合欺诈检测和恶意软件检测等场景。

半监督学习

半监督学习是监督和非监督方法的混合。学习过程并没有受到每一个输入的示例输出的密切监督,但是我们也不会让算法自行其是,也不会提供任何形式的反馈。半监督学习走的是中间道路。

通过能够将少量已标记数据与更大的未标记数据集混合在一起,减少了拥有足够已标记数据的负担。因此,它开启了更多需要用机器学习来解决的问题。

生成对抗网络

生成对抗网络(GANs)是最近的突破,取得了令人难以置信的结果。GANs 使用两个神经网络,一个发生器鉴别器。生成器生成输出,鉴别器对其进行评价。通过互相争斗,他们都变得越来越熟练。

通过使用一个网络产生输入,另一个网络产生输出,我们不需要每次都提供明确的标签,因此它可以被归类为半监督的。

例子

一个完美的例子是医学扫描,如乳腺癌扫描。需要训练有素的专家来标记这些标签,这既耗时又非常昂贵。相反,专家可以标记一小组乳腺癌扫描,半监督算法将能够利用这个小组集并将其应用于更大的扫描组

对我来说,甘的是半监督学习最令人印象深刻的例子之一。下面是一个视频,其中一个生成式对抗网络使用无监督学习将一个图像的各个方面映射到另一个图像。

A neural network known as a GAN (generative adversarial network) is used to synthesize pictures, without using labelled training data.

强化学习

最后一种机器学习是我最喜欢的。它不太常见,也复杂得多,但它产生了令人难以置信的结果。它不使用标签,而是使用奖励来学习。

如果你熟悉心理学,你应该听说过强化学习。如果没有,你已经从我们在日常生活中的学习中了解了这个概念。在这种方法中,偶然的正反馈被用来强化行为。把它想象成训练一只狗,好的行为会得到奖励,变得更加普遍。不良行为受到惩罚,变得不那么普遍。这种奖励激励的行为是强化学习的关键。

这与我们人类学习的方式非常相似。在我们的一生中,我们会收到积极和消极的信号,并不断从中学习。我们大脑中的化学物质是我们获得这些信号的许多方式之一。当好事发生时,我们大脑中的神经元会提供一系列积极的神经递质,如多巴胺,这让我们感觉良好,我们更有可能重复那个特定的动作。我们不需要像在监督学习中那样不断的监督来学习。通过偶尔给出强化信号,我们仍然可以非常有效地学习。

强化学习最令人兴奋的部分之一是,这是远离静态数据集训练的第一步,而不是能够使用动态、嘈杂的数据丰富的环境。这使得机器学习更接近人类使用的学习方式。这个世界就是我们嘈杂、复杂、数据丰富的环境。

游戏在强化学习研究中非常流行。它们提供了理想的数据丰富的环境。游戏中的分数是训练奖励激励行为的理想奖励信号。此外,时间可以在模拟游戏环境中加速,以减少总的训练时间。

一种强化学习算法的目的是通过一遍又一遍地玩游戏来最大化它的回报。如果你能用一个频繁的“得分”作为奖励来框定一个问题,它很可能适合强化学习。

例子

强化学习在现实世界中还没有被广泛使用,因为它太新太复杂了。但现实世界的一个例子是使用强化学习,通过以更有效的方式控制冷却系统来降低数据中心的运行成本。该算法学习如何行动的最优策略,以便获得最低的能量成本。成本越低,获得的回报越多。

在研究中,它经常在游戏中使用。完全信息游戏(你可以看到环境的整体状态)和不完全信息游戏(部分状态是隐藏的,例如真实世界)都取得了超越人类的惊人成功。

谷歌 DeepMind 已经在研究中使用强化学习来玩超人级别的围棋和雅达利游戏。

A neural network known as Deep Q learns to play Breakout by itself using the score as rewards.

机器学习入门到此为止!请留意即将出现的更多博客,它们将对特定主题进行更深入的探讨。

如果你喜欢我的作品,想了解最新的出版物,或者想与我取得联系,可以在 twitter 上找到我,地址是 @GavinEdwards_AI ,或者在 Medium 上找到我,地址是Gavin Edwards——谢谢!🤖🧠

参考

Chollet,F. 用 Python 进行深度学习。庇护岛曼宁。

机器学习和音乐分类:一种基于内容的过滤方法

原文:https://towardsdatascience.com/machine-learning-and-music-classification-a-content-based-filtering-approach-f2c4eb13bade?source=collection_archive---------11-----------------------

使用 Librosa Python 库、KNN 和 Random Forest 对音乐进行分类

在我之前的博客文章音乐推荐和机器学习简介中,我讨论了音乐推荐系统的两种方法,基于内容的过滤和协同过滤。协作过滤方法涉及基于用户收听历史推荐音乐,而基于内容的方法使用对一首音乐的实际特征的分析。在这篇博客文章中,我将更深入地研究基于内容的方法,使用 Librosa Python 库进行“音乐信息检索”,并尝试一些机器学习分类算法,根据歌曲的特征将歌曲分类。

基于 Librosa 的特征提取

当我第一次开始研究音乐信息检索这一主题时,即基于音频信号处理提取音乐及其音频内容信息的过程,这似乎是一项非常艰巨的任务,需要足够的技术专业知识。嗯,当然有,甚至有一整个领域致力于这项任务。幸运的是, Librosa Python 库的创建者使得这个过程变得更加容易。Python 用户可以使用这个库轻松提取任何 mp3 上的信息。请观看下面的视频,该视频由该库的创建者之一提供了一个简短的教程:

Librosa 可以轻松提取许多特征,包括节拍跟踪、 mel 音阶、与音高类别信息相关的色图,以及分离音频的谐波和打击成分的能力。下面我提供了我用来为电台司令的歌曲古怪的鱼检索这些信息的代码。同样,所有这些步骤的一个很好的教程和更多内容可以在这里找到。

第一步:加载所需的模块

梅尔功率光谱图

色谱图

相当简单!Librosa 真的是一个很棒的音乐信息检索工具。对于我探索基于内容的过滤的下一步,我想建立一个完整的模型,能够根据各种特征将音乐分类到正确的流派。对于数据,我决定使用 Spotify 的 Web API 提供的信息,而不是使用 Librosa 提供的信息,如果你试图分析大量的歌曲,这可能需要相当多的时间和计算能力。Spotify 提供了一些歌曲特征,我可以将它们用于一个分类模型,这些特征在本质上不像 Librosa 提供的那么技术性。例如,一些特征包括“可跳舞性”,其“描述了基于包括速度、节奏稳定性、节拍强度和整体规律性在内的音乐元素的组合,一首曲目有多适合跳舞。”以及“能量”,其“代表强度和活动的感知量度”。通常,充满活力的曲目让人感觉速度快、声音大、嘈杂。”在这篇文章的下一部分,你可以在我的数据中找到这些特性的完整列表及其描述。这个 API 很酷的一点是,它提供了描述一首歌曲的非技术方法,这些方法来自于对音乐进行的更加技术化和科学化的基于内容的分析。

基于 K 近邻的音乐分类

下面我提供了我的K-最近邻分类模型的代码,在这里我试图将歌曲分类到正确的流派。我的数据包括大约 300 首歌曲,其中大约 1/3 是嘻哈音乐,1/3 是电子音乐,1/3 是古典音乐。我还包含了使用 Spotify Web API 的代码,这一开始可能有点棘手。不过,在你查看之前,我先简单介绍一下我从 Spotify API 获得的功能:

声音度——0.0 到 1.0 之间的置信度,表示音轨是否是声音的。1.0 表示音轨是声学的高置信度。

可舞性——可舞性描述了基于音乐元素的组合,包括速度、节奏稳定性、节拍强度和整体规律性,一个曲目适合跳舞的程度。值 0.0 最不适合跳舞,1.0 最适合跳舞。

能量——能量是一个从 0.0 到 1.0 的量度,代表强度和活动的感知量度。通常,高能轨道感觉起来很快,很响,很嘈杂。例如,死亡金属具有高能量,而巴赫前奏曲在音阶上得分较低。对该属性有贡献的感知特征包括动态范围、感知响度、音色、开始速率和一般熵。

乐器性—预测轨道是否不包含人声。“Ooh”和“aah”在这种情况下被视为乐器。Rap 或口语词轨道明显是“有声的”。乐器度值越接近 1.0,轨道不包含人声内容的可能性就越大。高于 0.5 的值旨在表示乐器轨道,但随着该值接近 1.0,置信度会更高。

调—轨道所在的调。整数使用标准音高分类符号映射到音高。例如,0 = C,1 = C♯/D♭,2 = D,等等。

活跃度—检测录音中是否有观众。较高的活跃度值表示音轨被现场执行的概率增加。高于 0.8 的值表示该轨迹很有可能是实时的。

响度—轨道的整体响度,以分贝(dB)为单位。响度值是整个轨道的平均值,可用于比较轨道的相对响度。响度是声音的质量,是与体力(振幅)相关的主要心理因素。值的典型范围在-60 和 0 db 之间。

语速—语速检测音轨中是否存在口语单词。越是类似语音的录音(例如脱口秀、有声读物、诗歌),属性值就越接近 1.0。高于 0.66 的值描述可能完全由口语单词组成的轨道。介于 0.33 和 0.66 之间的值描述可能包含音乐和语音的轨道,可以是分段的,也可以是分层的,包括说唱音乐。低于 0.33 的值很可能代表音乐和其他非语音类轨道。

速度—轨道的总体估计速度,单位为每分钟节拍数(BPM)。在音乐术语中,速度是给定作品的速度或节奏,直接来源于平均节拍持续时间。

拍号—轨道的估计整体拍号。拍号(拍子)是一种符号约定,用于指定每个小节(或小节)中有多少拍。

化合价——一个从 0.0 到 1.0 的量度,描述轨道传达的音乐积极性。高价曲目听起来更积极(例如,快乐、愉快、欣快),而低价曲目听起来更消极(例如,悲伤、沮丧、愤怒)。

简单描述一下这个过程:我首先从三个 Spotify 播放列表中请求曲目 id,每个流派一个播放列表。然后,我要求每首歌曲的功能,并将所有的歌曲组合成一个熊猫数据帧。然后,我使用 Scikit Learn K-Nearest-Neighbors 模型,遍历多个 K 值,为我的模型找到最佳的一个。最终导致 K 值为 9,这是我在将模型拟合到训练数据时使用的值。以下是分类模型在测试数据上的得分:

Test Scores for KNN Model

我的测试集的 F1 分数大约为 0.93。查看混淆矩阵,似乎模型在处理嘻哈歌曲时遇到了一些问题,有时会将它们归类为电子音乐。不错的分数,但是让我们看看我们是否可以使用另一个模型做得更好。

使用随机森林的音乐分类

接下来,我尝试使用随机森林模型进行分类,这是一种集成方法,我希望它能让我获得更准确的结果,使用我在 K-最近邻模型中使用的相同特征。请参见下面的代码和结果:

Test Scores for Random Forest Model

使用随机森林让我得到了完美的分类分数!您还可以看到一个条形图,显示模型中各个特征的重要性。显然,随机森林模型比 K-最近邻模型更准确,考虑到 K-最近邻的简单性,这并不奇怪。

我对音乐推荐系统中基于内容的过滤的简要介绍到此结束。流派分类只是这个难题的一小部分,我期待着探索这些系统的其他部分和音乐数据。

机器学习和苹果落地定律

原文:https://towardsdatascience.com/machine-learning-and-the-law-of-falling-apples-f6a9cfc06ac3?source=collection_archive---------5-----------------------

免责声明:本文的目的不是以任何形式贬低机器学习。机器学习很可爱,我靠它谋生!重点是简单地探索边缘,试着看看更远处是什么。

想象一下年轻的艾萨克·牛顿坐在树下,注意到一个苹果落下。他想了一会儿,意识到他从来没有真正见过苹果除了直直地掉下来之外还做了什么。他们从不向上或向旁边走。

现在,如果牛顿知道机器学习,并且有真正的机器来进行学习,那么他可能会这样做。首先,他可以用三个类别标签“向下”、“向上”和“横向”建立一个分类问题。然后他会收集苹果下落方向的数据。他会注意到他的数据集非常不平衡。但是,他不会气馁,他会继续训练他的分类器。如果他的分类器还不错的话,在大多数情况下,它会预测“向下”是跌倒的方向。

如果他更有进取心的话,他会注意到树越高,苹果落地的时间越长。为了想出一个更好的模型,他会测量他能找到的每棵苹果树的高度。然后他会站在每个苹果下面,等着苹果落下来。在每一种情况下,他都会记录下苹果落地的时间。在做了一些探索性的数据分析后,他会意识到,如果他使用树高的平方根作为特征,他将能够拟合更好的线性回归模型。最后,他将拟合这个线性回归模型,得到了非常好的拟合。

有了所有这些认识,他就可以制定出“苹果下落定律”:苹果几乎总是直线下落,它们落到地面所用的时间大约与树高的平方根成正比。

谢天谢地,牛顿完全忘记了机器学习。相反,他用传统的方式去做这件事。他认真思考了这个问题,并得出结论:苹果垂直落下是一个更深层次原则的体现。这一深刻的潜在原则不仅影响从树上落下的苹果,还影响我们周围的一切。它同样影响着地球和天体。它影响着宇宙中的一切。牛顿阐明了万有引力定律。

牛顿在看到一个苹果落下后阐明万有引力定律的故事可能是虚构的。然而,这是一个很好的例子,说明了是什么让科学如此强大——它的概括能力,从有限的数据中发现普遍真理的能力。科学探究的核心是基于一系列关于宇宙本质的基本推测。在很大程度上,机器学习通过科学获得其经验方法,同时尽可能用计算能力取代人类的创造力。但是这种相似性有多远呢?要回答这个问题,让我们来玩类比的游戏。

科学的基本猜想是宇宙中有秩序等待被发现。虽然这听起来微不足道,但没有这个核心信念,任何科学研究都是不可能的。就科学而言,我们不会停下来考虑这个猜想的重要性,因为它已经被一次又一次地证实了。我们只是认为这是理所当然的。

但是,机器学习呢?嗯,机器学习并不关心整个宇宙的命运,而是关心数据。机器学习实际上是通过归纳概括进行函数近似的艺术,即基于数据样本“猜测”函数形式的聪明方法。对于监督学习来说,上面的陈述显然是正确的。稍加思考和阐述,也可以看出对于强化学习和无监督学习也是如此。(为了简单起见,在本文的其余部分,我将接近监督学习的语言)。

为了猜测一个函数,我们需要假设一个函数首先存在,并且一个函数只不过是规则的编码。于是,机器学习的第一个基本猜想是: 很有可能观测到的数据中会包含着等待被发现的规律

或者换句话说,给定输入 X 和输出 Y ,存在函数 F 使得

Y = F(X)

与科学不同,机器学习的第一个猜想不是给定的,而是需要在每一个数据样本上进行验证。如果发现不真实,那么机器学习对于该数据集没有多大用处。

规律性是有用的,因为它们有助于从已知中预测未知。但是为了做到这一点,人们需要能够用一种足够强大的语言来表达它们。在物理科学中,这种语言是数学的语言。关键的猜想是数学为表达和利用物理现象的规律提供了充分的基础。同样,这可能看起来像一个微不足道的观察,但它远非如此。没有它的有效性,大部分现代科学技术赖以存在的大厦将会倒塌。

机器学习的语言也是数学语言,尽管范围有些狭窄。机器学习背后的底层数学机制是向量空间中的分段可微函数(粗略地说,微积分和线性代数)。这台机器有两个非常特别的特性。首先,可以在向量空间中以具体的方式定义“接近”的概念,从而定义“变化”的概念(通过定义距离)。第二,对于分段可微函数,小的变化导致小的影响。这两个属性合在一起,最终导致了机器学习的巨大威力;它超越观察数据的概括能力。

因此,为了成功地将机器学习应用于任何数据集,我们应该能够将数据转换为适合其底层机器的形式,

Y = F(X) = O(G(I(X)))

其中 IO 是从原始表示到可以应用机器的表示的变换(特征空间表示),而 G 是使用特征空间表示中的机器构建的模型的函数。

上面提到的使特征空间表示非常强大的特性,也使它受到难以置信的限制。不是每个数据集都应该有合适的特征空间表示。然而,大多数是这样的,这导致了机器学习的第二个基本猜想: 如果观察到的数据显示出规律性,那么很可能存在一种数据表示,其中小的变化产生小的影响。

将原始数据转换成特征空间表示的行为称为特征工程。根据吴恩达的说法— *想出新功能是困难的,耗时的,需要专业知识。“应用机器学习”基本上是特征工程。*机器学习任务的成功严重依赖于能够找到正确的转换 IO 。通常它们是由深厚的领域知识和神秘的巫术相结合而精心手工制作的!

深度学习试图通过使特征工程的过程部分自动化来减轻这一负担。本质上,在深度学习中,I 和 O 的转换是由深度神经网络的第一层和最后几层执行的。因此,非线性转换的单调乏味的工作被外包给机器,同时保留人类的聪明才智以获得更有影响力的见解。

当我们在玩类比的游戏时,我们必然会注意到,在科学中还有最后一个基本猜想。这是一种推测,即普遍真理是存在的,不同的现象只是这些普遍真理的表现。正是这一猜想使得科学能够从一组狭窄的观察数据中归纳出涵盖众多现象的普遍规律。需要明确的是,仅仅这个猜想并不能自动体现那些普遍规律。人们需要牛顿的天才才能从观察下落的苹果中推导出万有引力定律。但是,最终,正是这种猜想为直觉的飞跃提供了基础,将科学从集邮提升为进步和启蒙的引擎。

在机器学习中有可能做出类似的猜想吗?当然,机器学习没有任何发现普遍真理的宏伟计划。然而,它能够而且必须有打破狭隘领域壁垒的雄心。当然,在筛选了数百万张有猫的照片后,能够识别照片中的猫是有用的。然而,更有用的是,如果人们可以利用这些数据得出一些关于图片一般是如何构成的结论。或者,更好的是,如果有人能说出照片背后摄影师的意图或情感。

请注意,这是一种不同的概括。这不是那种必然以普遍性为目标的概括。而是可以转让的那种。可跨领域转移——从猫图片领域到视觉构成领域或人类情感领域。但是我们如何找到这种可转移的概括呢?

如果特征空间表示不仅仅是计算的拐杖,而是编码了更深层次的东西呢?如果这些表示( G )中的模型不仅仅是在这个特定领域中连接输入和输出的操作工具,而是实际上揭示了跨越多个领域的潜在结构规则,那会怎么样?

事实证明,这些“如果”不仅仅是一厢情愿的想法。在许多情况下,可观测数据确实具有这种通用性。这个重要的观察结果支持了迁移学习的基本前提。因此,机器学习的第三个基本猜想是: (迁移学习)存在观察到的数据是潜在(可能是概率和近似)规律的表现的情况。

和前面的案例一样,光靠推测不足以取得进展。有许多问题尚未得到解答。哪些情况适合迁移学习?如何知道自己是否在 IGO 之间正确分割了 F ?毕竟,它们只是在一次转换中是独一无二的。深度学习是唯一可以受益于迁移学习的技术吗?

我们刚刚开始意识到迁移学习在将机器学习带到下一个前沿领域——跨领域推广——方面的潜力。根据吴恩达的说法,迁移学习将是机器学习成功的下一个驱动力。这种乐观是很有根据的。迁移学习为机器学习提供了从掉落的苹果到万有引力定律的难以捉摸的桥梁。

机器学习和视觉搜索:谁是正确的?

原文:https://towardsdatascience.com/machine-learning-and-visual-search-who-is-getting-it-right-e889d0a9a25f?source=collection_archive---------9-----------------------

“我语言的极限意味着我世界的极限”——路德维希·维特斯坦根

从历史上看,搜索中的输入输出关系一直由文本主导。即使输出变得更加多样化(例如视频和图像结果),输入也是基于文本的。这限制和塑造了搜索引擎的潜力,因为它们试图从相对静态的关键字数据集中提取更多的上下文含义。

视觉搜索引擎正在重新定义我们语言的界限,开辟了人与计算机之间交流的新途径。如果我们将语言视为一个流动的符号和标志系统,而不是一套固定的口语或书面语,我们会对搜索的未来有一个更加引人注目和深刻的了解。

我们的文化是视觉的,这是视觉搜索引擎急于利用的事实。

具体的电子商务视觉搜索技术已经比比皆是:亚马逊、沃尔玛和 ASOS 都在行动。这些公司的应用程序将用户的智能手机摄像头变成了一个视觉发现工具,可以根据帧中的任何内容搜索类似的项目。然而,这只是一个用例,视觉搜索的潜力远远大于直接的电子商务交易。

经过大量的试验和错误,这项技术正在走向成熟。处于视觉搜索核心的无监督机器学习系统只是这个过程的结果。

我们现在正处于精确、实时视觉搜索的风口浪尖,由机器学习和人工智能驱动。

下面,本文将回顾这个行业的三个主要参与者:Pinterest、Google 和 Bing 取得的进展。

拼趣

Pinterest 的视觉搜索技术旨在为探索搜索开辟一个必去之地。他们宣称的目标呼应了这篇文章的开篇引言:“当你找不到描述它们的词语时,帮助你找到它们。”

Pinterest 没有直接与谷歌对抗,而是决定向用户和广告商提供一些微妙不同的东西。人们去 Pinterest 发现新想法,创建情绪板,获得灵感。因此,Pinterest 敦促其 2 亿用户“跳出框框搜索”,这可以被解读为对谷歌无处不在的搜索栏的温和嘲讽。

所有这些都是由 Pinterest Lens 驱动的,这是一个复杂的视觉搜索工具,它使用智能手机摄像头扫描物理世界,识别物体,并返回相关结果。它可以通过智能手机应用程序使用,但 Pinterest 的视觉搜索功能也可以通过谷歌 Chrome 扩展在桌面上使用。

Pinterest 超过 1000 亿个 pin 的庞大数据集为机器学习应用提供了完美的训练材料。因此,物理世界和数字世界之间形成了新的联系,使用图形处理单元(GPU)来加速这一过程。

在实践中,Pinterest Lens 运行得非常好,并且随着时间的推移变得越来越好。图像检测令人印象深刻的准确和相关引脚的建议是相关的。

以下是使用 Pinterest 和 Samsung visual search 搜索时选择的相同对象:

Image created by author

结果的差异很能说明问题。

在左边,Pinterest 识别物体的形状、材料、用途以及设计的定义特征。这允许比直接搜索另一个黑色马克杯更深入的结果。Pinterest 知道,不太明显的风格细节才是真正吸引用户的。因此,我们看到不同颜色的杯子的结果,但风格相似。

在右边,三星的 Bixby 助手可以识别物体、颜色和用途。三星的搜索结果由亚马逊提供支持,与 Pinterest 提供的选项相比,它们没有那么鼓舞人心。图像变成了对[黑咖啡杯]的关键字搜索,这使得视觉搜索元素有点多余。

当视觉搜索引擎为我们表达一些我们难以用语言表达的东西时,它们工作得最好。Pinterest 比大多数人更了解并兑现这一承诺。

Pinterest 视觉搜索:关键事实

  • 每月用户超过 2 亿
  • 侧重于搜索的“发现”阶段
  • Pinterest Lens 是中央视觉搜索技术
  • 零售商的绝佳平台,具有明显的盈利可能性
  • 付费搜索广告是该公司的核心增长领域
  • 越来越有效的视觉搜索结果,尤其是更深层次的审美

谷歌

随着谷歌眼镜的推出,谷歌在视觉搜索领域掀起了早期浪潮。这款安卓应用于 2010 年推出,允许用户使用智能手机摄像头进行搜索。例如,它在著名的地标上工作得很好,但是它在相当长的时间内没有显著更新。

谷歌似乎不太可能在视觉搜索上保持长时间的沉默,今年的 I/O 开发揭示了这个搜索巨头一直在后台进行的工作。

谷歌镜头将通过照片应用和谷歌助手提供,这将是对早期谷歌护目镜计划的重大改革。

任何与 Pinterest 产品在命名上的相似之处都可能不仅仅是巧合。谷歌最近悄悄升级了它的图像和视觉搜索引擎,推出了类似 Pinterest 格式的搜索结果:

谷歌的“类似商品”产品是利用搜索发现阶段的又一举措,展示相关结果可能会进一步激起消费者的好奇心。

Google Lens 将提供对象检测技术,在一个强大的视觉搜索引擎中将所有这些链接在一起。在测试版中,Lens 提供了以下视觉搜索类别:

  • 全部
  • 衣服
  • 鞋子
  • 手提包
  • 太阳镜
  • 条形码
  • 制品
  • 地方

一些开发人员有机会尝试 Lens 的早期版本,许多人报告了不同的结果:

貌似谷歌不认自己家的智能中枢……(来源: XDA 开发者 )

对于 Google Lens 来说,现在还是非常早期的阶段,因此我们可以期待这项技术在从错误和成功中学习的过程中会有显著的进步。

当它这样做时,谷歌处于独特的位置,使视觉搜索成为用户和广告商的强大工具。在线零售商通过付费搜索获得的机会是不言而喻的,但实体零售商也有巨大的潜力利用超本地搜索。

尽管 Pinterest 取得了令人印象深刻的进步,但它不具备像谷歌那样渗透到用户生活方方面面的生态系统。随着一款新的 Pixel 智能手机的研发,谷歌可以在语音搜索的同时使用视觉搜索来整合其软件和硬件。对于使用 DoubleClick 管理搜索和显示广告的广告商来说,这是一个非常诱人的前景。

我们还应该预计,谷歌将在不久的将来进一步发展这种视觉搜索技术。

谷歌将向所有开发者开放其 ARCore 产品,这将为增强现实带来无限可能。ARCore 是苹果 ARKit 的直接竞争对手,它可以提供释放视觉搜索全部潜力的钥匙。我们也不应该排除进军可穿戴设备市场的可能性,可能会推出新版谷歌眼镜。

谷歌视觉搜索:关键事实

  • 谷歌眼镜于 2010 年推出,是视觉搜索市场的早期进入者
  • 护目镜在一些地标上仍能很好地工作,但很难在拥挤的画面中分离出物体
  • 谷歌眼镜计划于今年晚些时候(日期待定)推出,作为对护目镜的全面改造
  • Lens 将把视觉搜索与谷歌搜索和谷歌地图联系起来
  • 物体检测还不完善,但是产品还在测试阶段
  • 一旦技术的准确性提高,谷歌最适合围绕其视觉搜索引擎开发广告产品

自 2012 年推出必应视觉搜索产品以来,微软在这方面一直非常低调。它从未真正起飞,也许大众对视觉搜索引擎的胃口还不太大。

最近,Bing 有趣地重新加入了这场争论,宣布了一个完全改进的视觉搜索引擎:

这种策略的改变是由人工智能的进步导致的,人工智能可以自动扫描图像并隔离项目。

这种搜索功能的早期版本需要用户输入,在图像的特定区域周围画出方框,以便进一步检查。Bing 最近宣布,这将不再需要,因为技术已经发展到自动化这一过程。

Bing 上视觉搜索结果的布局与 Pinterest 惊人地相似。如果模仿是最真诚的奉承形式,Pinterest 现在应该已经被奉承淹没了。

视觉搜索技术可以锁定大多数图像中的对象,然后进一步建议用户可能感兴趣的项目。目前这仅在桌面上可用,但很快将添加移动支持。

结果在某些地方是不完整的,但是当探测到一个物体时,就会给出相关的建议。在下面的例子中,使用西装图片进行搜索会导致热门的可购物链接:

然而,它没有考虑衬衫或领带——唯一可搜索的方面是西装。

使用拥挤的图片进行搜索,事情变得更加不完整。使用图片搜索客厅装饰创意会带来一些相关的结果,但不会总是专注于特定的项目。

就像所有的机器学习技术一样,这个产品将继续改进,目前来看,Bing 在这方面领先谷歌一步。尽管如此,从长远来看,微软缺乏用户基础和移动硬件来对视觉搜索市场发起真正的攻击。

视觉搜索因数据而繁荣;在这方面,谷歌和 Pinterest 都抢在了必应的前面。

必应视觉搜索:关键事实

  • 最初于 2009 年推出,但由于缺乏接受度,于 2012 年取消
  • 于 2017 年 7 月重新推出,由人工智能支持,以识别和分析物体
  • 广告商可以使用 Bing 视觉搜索来放置可购买的图片
  • 这项技术还处于起步阶段,但物体识别相当准确
  • 目前仅限于桌面,但手机很快就会跟上

那么,谁拥有最好的可视化搜索引擎呢?

目前来看,Pinterest。数十亿个数据点和一些经验丰富的图像搜索专业人士推动着这项技术,它提供了最流畅和最准确的体验。它还通过抓住物体的风格特征,而不仅仅是它们的形状或颜色,做出了一些独特的事情。因此,它改变了我们可以使用的语言,扩展了搜索的范围。

Bing 最近在这一领域取得了巨大的进步,但是它缺少一个足以吸引谷歌搜索者的杀手级应用。Bing 视觉搜索准确且功能强大,但不能像 Pinterest 那样创建与相关项目的联系。

谷歌眼镜的推出肯定也会彻底撼动这个市场。如果谷歌能够确定自动物体识别(它无疑会做到),谷歌眼镜可能会成为将传统搜索与增强现实联系起来的产品。从长远来看,谷歌拥有的资源和产品套件使其成为可能的赢家。

最初发表于【searchenginewatch.com】

机器学习在物联网中的应用

原文:https://towardsdatascience.com/machine-learning-application-in-iot-ff859f9ab4fe?source=collection_archive---------5-----------------------

机器学习(ML)和物联网(IoT)是目前非常流行的表达方式,它们都接近炒作周期的顶峰。

Gartner 2016 年新兴技术炒作周期——机器学习正处于炒作周期的顶峰,物联网平台和其他相关物联网技术处于上升阶段。

鉴于围绕机器学习和物联网的所有建设和讨论,很难透过喧嚣理解真正的尊重所在。

数据分析与机器学习

随着所有前面提到的围绕机器学习的建立,许多协会正在询问是否应该以某种方式在他们的业务中应用机器学习。

在大多数情况下,适当的回应是一个回响

机器学习获取大量信息,并创造有价值的知识来帮助组织。这可能意味着改进形式、削减开支、为客户提供更好的服务,或者开发新的商业模式计划。

事实是,大多数协会可以从传统的数据分析中获得大量的这些优势,而不需要更复杂的机器学习应用程序。

传统的数据分析在澄清信息方面令人难以置信。你可以为过去发生的事情或今天正在发生的事情制作报告或模型,吸引有价值的经验应用到组织中。

数据分析可以帮助评估和跟踪目标,实现更明智的决策,然后提供衡量长期成功的方法。

那么机器学习什么时候有价值呢?

传统数据分析中运行的数据模型通常是静态的,在处理快速变化的非结构化信息时用途有限。关于物联网,区分许多传感器信息源和外部组件之间的连接通常很重要,这些外部组件会快速创建大量数据点。

传统的数据分析需要一个基于过去信息和主评估的模型来建立因素之间的联系,而机器学习从结果因素(例如保留活力)开始,然后自然地搜索指标因素及其关联。

总的来说,当你理解你需要什么时,机器学习是很重要的,但是你没有关于决定选择的关键信息因素的线索。因此,你给机器学习算法设定目标,然后它从信息中“学习”哪些因素对实现目标至关重要。

一个很棒的例子是一年前谷歌在其数据中心 利用机器学习。数据中心需要保持冷却,因此它们需要大量的活力来使它们的冷却框架正常工作。这对谷歌来说是一个值得注意的成本,所以我们的目标是通过机器学习来提高效率。

机器学习明显降低了谷歌数据中心的功耗

通过机器学习实现的预测分析对于一些物联网应用来说非常有利可图。我们应该调查几个确凿的例证…

机器学习在物联网中的应用

工业应用中的成本节约

预测能力在机械环境中非常有用。通过从机器内部或机器上的不同传感器获取信息,机器学习计算可以“意识到”对机器来说司空见惯的事情,然后识别何时开始发生不寻常的事情。

预见机器何时需要维护是难以想象的重要,可以转化为大量的节约成本。

公司现在使用机器学习来预测机器何时需要维护,准确率超过 90%,这意味着巨大的成本削减。

塑造个人体验

事实上,我们在日常生活中都熟悉机器学习应用。亚马逊和网飞都利用机器计算出如何接受我们的倾向,并给客户一个优越的考验。这可能意味着提出你可能喜欢的项目,或者给电影和电视节目相关的建议。

同样,在物联网中,机器学习在很大程度上可以按照我们自己的意愿形成我们的条件。

Nest 恒温器是一个很棒的例子,它利用机器计算出如何根据你的喜好进行加热和冷却,确保你下班回家或早上起床时房子的温度正确。

更多

上面描述的利用案例只是所有意图和目的的大量可想象的结果中的几个,然而它们是至关重要的,因为它们是目前正在物联网中进行的机器学习的有价值的使用。

虽然机器学习和物联网都处于建设的高潮,但机器学习在物联网中的应用的命运值得这种建设。我们真的只是开始揭露想象之下的东西。

关于作者

Muhammad Anser Naseer 是东方集团公司技术开发部门 BlueEast 的高级软件工程师。BlueEast 是世界上第一台内置电能表的智能 DC 变频空调背后的大脑。 阅读更多……

机器学习在地球物理测井数据中的应用

原文:https://towardsdatascience.com/machine-learning-applied-to-geophysical-well-log-data-58ebb6ee2bc6?source=collection_archive---------7-----------------------

无监督学习是对地球物理测井中的岩性进行分类的一个很好的工具。

近年来,机器学习(ML)变得非常流行,许多行业都在将它应用于他们的数据集。本文是关于将最大似然法应用于测井数据,并了解最大似然法帮助学习井中岩性的方法。

An offshore drilling rig (courtesy: https://unsplash.com/s/photos/oil-rig available for download)

什么是测井记录?

测井记录是在井中记录的地下物理特性的单点测量,并随深度垂直变化。这些特性是随机的和非周期性的,取决于矿物成分或岩性、孔隙度、胶结和压实、流体的存在等因素。,显示了从海上区域记录的一套常规测井记录。每条测井曲线都显示了这些特性是如何随深度变化的。在这里,我们正在观察 500 万到 1600 万年前沉积在的沉积物!!这难道不令人印象深刻吗!!

测井特性

好的,现在有些测井像伽马射线和泊松比是极好的岩性指标,而其他像密度和纵波速度测井对于了解**岩石类型、孔隙流体类型以及沉积沉积物中的压力和压实趋势是有用的。**密度孔隙度,一种源自密度测井的物理性质,用于测量相同岩石类型或不同岩石类型的孔隙空间量。

沉积物通常由河流搬运并沉积在盆地中,因此岩性取决于风化的岩石类型以及河流携带沉积物通过的区域。此处所示的测井记录来自河流三角洲系统,该系统主要由砂层和页岩组成。常见的岩石类型有:

砂岩(储层)和页岩(非储层)

砂岩/砂:由石英颗粒、长石、方解石、重矿物和其他岩石碎片组成的岩石。

页岩:由粘土矿物组成的岩石,其中一些具有放射性。

粉砂岩/淤泥,一种由沙子和页岩组成的岩石也可能存在。

**特别提示 😗* 如果没有 Ramya Ravindranathan ,这项研究就不可能完成。数据集和解释是她提供的。

Fluvial- Deltaic system (image used from http://www.sepmstrata.org/page.aspx?pageid=72)

对于不同的岩性,相对于地层边界的测井响应是不同的。较低的 GR、泊松比、密度、速度值和较高的孔隙度值是干净砂岩的特征。与砂相比,页岩的 GR 值更高。与砂岩相比,孔隙度极低,而密度、泊松比和速度值较高。淤泥的性质介于沙子和页岩之间。

Suite of well logs extending from 2800 ft to 10250 ft

这口井遇到的单个砂层范围为 10-150 英尺(3.04-45.72 米),被厚或薄的页岩层隔开。砂的储层质量通过粘土百分比来衡量**。**最好的储层粘土含量最低。如果能根据粘土含量来划分岩性就太好了。理想的情况是钻许多井来获得地下的清晰图像,但这是一件非常昂贵的事情,因为钻一口井要花费数十亿美元。

可靠地预测岩性成为储层描述的关键问题之一。在实践中,结合物理模型局部地质 知识和经验,将大型地震和测井数据集简化为地球的低维模型*。不幸的是,这些简化的物理和地质假设在实践中并不总是正确的,这使得推断的模型高度不确定和有偏差

这个问题可以用一般的机器学习模型来重新表述。因此,用一些算法来预测盆地中巨大井数据集的岩性将是一个好主意。

利用井数据集的无监督学习

用井数据集识别岩性是无标记数据无监督问题的一个典型例子。无监督机器学习用于测井记录,以获得可与井的岩性相关的聚类。当推断的结构比原始数据维数低时,无监督方法特别有用。巧合的是,由地球科学工作流程生成的解释图像和地质图的维度远低于原始现场数据。

这篇文章解释了以下因素。

无监督学习可以根据区域内的岩性对数据进行分类吗?

聚类是否与测井曲线特征变化的深度相匹配?

这里探讨的两个无监督学习任务是(a) 通过相似性将数据聚类成组。本研究中使用的 K-means 聚类就属于这个类别**。**和(b) 降维压缩数据,同时保持其结构和有用性,包括 PCAt-SNE

数据集由各种测井记录组成,这些测井记录具有各种各样的单位。因此,在使用聚类算法之前,需要对数据集进行规范化。在这个问题中,有> 7000 个离散的深度点。

k 均值聚类用于创建数据点组,使得不同聚类中的点不相似,而一个聚类中的点相似。利用 k-means 聚类,测井数据点被分组为 k 组,定义不同的岩性。较大的 k 创建粒度更大的较小组,而较低的 k 意味着较大的组和较小的粒度。“肘”方法计算一系列聚类数的平均分数。折线图类似于一只手臂,而“肘”(曲线上的拐点)是最佳集群数量的良好指示。

在弯管图的当前分析中,拐点可以在 6°或 7°处。肘形图,很多时候,并不表明一个拐点,因此,进一步的验证是必不可少的。

t-分布式随机邻居嵌入(t-SNE) 是一种非线性降维技术,用于在二维或三维的低维空间中嵌入高维数据进行可视化。它通过二维或三维点对每个高维对象进行建模,以这种方式,相似的对象通过附近的点进行建模,而不相似的对象通过远处的点进行建模的概率很高。

t-SNE 算法将原始数据分为 7 类。轴是高维数据映射到二维时生成的数字。该图显示 SNE 霸王龙产生了明显的、分离良好的集群。配色方案是根据 k-mean 算法生成的标签。似乎来自 k-均值聚类的少数点与 t-SNE 聚类不一致(少数紫色点与绿色点分类在一起)。

映射到二维空间的 t-SNE 簇。根据标记的 k-均值聚类的颜色方案。

使用 PCA 对最佳聚类数进行最终验证。主成分分析(PCA) 是一种无监督的方法,它在保持数据集结构(方差)的同时降低了维数,从而降低了复杂性。它对数据进行旋转,使新轴的方差最大化。将高维数据投射到低维子空间(在 2-3 维中可视化。).

PCA 聚类将数据集聚类成 7 个类,并且类之间的边界是不同的。质心清晰可见。

PCA clusters mapped onto 2-D space

提取标记聚类

基于这三种聚类算法,测井曲线中的**最优聚类数为 7。**对七个聚类再次运行 k-means 方法,并生成聚类标签。该算法将相应的聚类标签分配给数据集中的所有深度点。

直方图显示了根据深度点绘制的 7 个聚类。直方图的颜色方案和标签现在用于绘制测井曲线和岩性(从聚类中生成)。解释表也有相同的配色方案和标签。

Histogram showing the distribution of points in cluster generated by k-means. The color scheme and labels of the match with the table

研究 k-means 算法的一个挑战是,如果初始状态不相同,那么簇的大小就会改变。大约有 10-15 个点不同,约占测井记录总点数的 0.2%。

解读

选择 7000 至 8500 英尺和 8500 至 10250 英尺两个深度范围进行解释和比较,看数据聚类是否与测井数据解释的岩性相匹配。该表总结了与测井特征和岩性相关的聚类标签。发现的主要端员岩性为砂岩和页岩,具有各种不同的分级岩性,如砂质页岩和泥质砂岩。在本研究区域,我们将具有良好孔隙度的干净砂层归类为良好储层组 1 和 6 ),一般来说,这种含有碳氢化合物(石油或天然气)的砂层在垂直柱中非常少,并且它们与聚类方法(组 6)具有良好的相关性,聚类方法表明这种点的数量非常少。页岩表现为非常粗的柱状,而集群(集群 3)显示的点数最多。有趣的是,聚类方法可以区分不同的岩性,如泥质砂岩(聚类 5)和砂质页岩(聚类 0)。这项研究似乎对区分潜在油藏和非油藏非常有用。

Well log data from 7000–8500 ft. Clusters are interpreted from k-means unsupervised learning

Well log data from 8500–10250 ft. Clusters are interpreted from k-means unsupervised learning

将最大似然算法集成到岩性分析中有用吗?

总之,这证明了最大似然法在解释大量测井资料方面有着广阔的应用前景。地球物理数据确实属于机器学习模型的范畴。无监督学习可以用于直接从数据中提取有用的信息。无监督学习方法确实将数据集分类到有用的簇中。当与深度匹配时,这些群集确实产生了有用的岩性,并提供了有用的岩石特征。

在未来的研究中,地质解释可以作为标签来训练分类器,并对相似的数据集进行预测。如果有足够的数据集,就有可能对地球物理问题进行更科学的基准测试。

我欢迎反馈和建设性的批评。可以通过 LinkedIn 联系到我。这项研究的代码可以在这里找到。


  • Bougher,B. B. (2016 年)。机器学习在地球物理数据分析中的应用(不列颠哥伦比亚大学博士论文)。

使用机器学习方法的异常检测:对法国政治的应用。

原文:https://towardsdatascience.com/machine-learning-approaches-detect-outlier-values-that-do-not-follow-a-common-trend-detecting-cc0252f637bd?source=collection_archive---------23-----------------------

检测勒庞在 2017 年总统大选中的得分偏离基于社会经济变量的预测的法国地区。

复制分析所需的代码和数据可在 github 上获得。

目标

通常,机器学习者寻求调整学习机器,以便最大化分类或回归标准。当提供黑盒机器学习(ML)算法时,这是一个期望的目标。然而,当运行最大似然算法时,可以通过查看预测精度最低的点来提取有价值的信息。

为了说明我的观点,我分析了 2017 年法国总统选举第二轮的结果。在法国总统选举的最后一轮,马林·勒·庞面对埃马纽埃尔·马克龙。这可以被视为唐纳德·特朗普和希拉里·克林顿之间决斗的法国版,勒庞扮演特朗普的角色,马克龙扮演克林顿的角色。

在下文中,我研究了法国总统选举的结果在多大程度上是由社会经济变量决定的。如引言中所述,我正在寻找基于社会经济变量的得分预测最差的城市或地区。政治要想在下次选举中提高自己的全球得分,就应该去这些城市或地区开选前会。

所有的统计分析都在 r。

数据集可用 data.gouv.fr

首先,我下载了第一个数据集,它包含了法国总统选举的结果,可以在 data.gouv.fr 网站上找到。我在 github 上放了一个 csv 版本的数据文件。

然后,我执行一些技术操作来计算每个城市的城市代码(称为 CODGEO ),这将在合并 2 个不同的数据集时使用。

第二个数据集也可在 data.gouv.fr 网站上获得,包含法国每个城市(市镇)的各种社会经济数据。社会经济变量包括几个与税收、医生密度、商店密度、业主比例、工人比例相关的变量……我再次将 csv 版本的数据文件放在 github 上。我删除了地理变量(如部门代码),只保留社会经济数据。

城市规模的预测分数和实际分数的比较

然后,我将这两个数据集合并成一个数据框架,其中包含勒庞的得分和社会经济变量。为了训练回归模型,我使用随机森林来回归勒庞在社会经济变量上的得分。为了避免过度拟合,我使用双重交叉验证,其中我使用一半的数据来训练模型,另一半来进行预测,然后我交换了两个数据子集的角色。

真实得分和预测得分之间的平方相关性为 53% ,这是显著的,表明社会经济变量传达了预测总统选举结果的信息。

然后,我将勒庞的预测得分显示为真实得分的函数。

在图中,红点对应于超过 75,000 居民的城市。一个引人注目的异常值是加莱,得分为 57%,而预测值低得多,为 43% 。曾是难民营的加莱丛林或许可以解释为什么勒庞的得分比基于社会经济因素的应有得分高出 15%。

南部城市如尼斯、土伦和佩皮尼昂的得分高于基于预测值的预期。

我还发现有趣的是,巴黎和凡尔赛的预测得分相同,约为 16%,表明社会经济背景相似,但勒庞在巴黎的实际得分为 10%,而在凡尔赛为 24%。

在相反的方向上,鲁贝脱颖而出,预计勒庞的得分在 40%左右,但实际得分为 23%。令人惊讶的是,这种差异在紧邻鲁贝的图尔昆并没有出现

部门级预测分数与实际分数的比较

我最终对勒庞的实际得分和预测得分之间的城市差异进行了平均。在一个法国部门的范围内,这导致了一个值,我称之为“勒庞的超额票数”。我提供了一个阴谋来将勒庞 w.r.t .的超额选票的社会经济背景合法化。

为了制作一张法国地图,我使用了法国 R 大师科林·费伊提供的代码。

勒庞的超额选票最多的部门的实际和预测得分之间的差异在 2%和 2.5%之间。它们包括

  • 科尔塞省和东南部的一些省份(滨海阿尔卑斯省 06, Var 83,科尔塞省 2A),
  • 来自加龙河谷的一个部门( Tarn-et-Garonne 82)和来自该河谷的邻近部门也有多余的选票,但重要性较小(Tarn 81,Lot et Garonne 47),
  • 贝尔福地区 (90)。

相比之下,勒庞的得分比基于社会经济价值的预测低得多的部门是

  • 巴黎 (75)勒庞的得票率在 7%(!)小于它基于社会经济价值应该达到的水平,
  • 差异大于 2%的上塞纳省 (92)和邻近的塞纳-圣但尼省(93)也遵循这一趋势,但差异小于 2%。
  • Indre-et-Loire (37)差异大于 2%。

结论

机器学习方法可以检测出不遵循共同趋势的异常值。在这里,我提供了一个政治方面的例子,以找到勒庞在 2017 年法国第二轮总统选举中的得分偏离他们根据社会经济变量预测应该达到的城市或部门。

两个地区显示勒庞的票数过多,包括东南部和加龙河谷的省份。与预期相比,巴黎和一些邻近省份(92,93)显示勒庞的选票较少。很明显,在巴黎及其周边地区,勒庞的得分并没有达到应有的水平,经济并不是唯一的解释。还有神秘的 Indre-et-Loire,那里有城堡,勒庞的得票率大大低于预期。

机器学习——艺术还是科学?

原文:https://towardsdatascience.com/machine-learning-art-or-science-b660dc4db4a7?source=collection_archive---------0-----------------------

大数据的激增和确认偏差的挑战,导致数据科学家寻求一种方法来揭示隐藏的见解。在预测分析中,他们经常求助于机器学习来扭转局面。机器学习似乎是使用训练集处理大数据的理想候选。它还通过进行数据驱动的预测而享有浓厚的科学气息。但是机器学习真的没有偏见吗?我们如何更有意识地利用这个工具?

为什么机器学习是一门科学:

我们经常听到机器学习算法对数据进行学习和预测。因此,他们应该更少受到人为错误和偏见的影响。我们人类倾向于寻求对我们已经想到或相信的东西的确认,这导致了确认偏见,使我们忽略了与我们的理论相矛盾的事实,而过分强调了那些肯定理论的事实。

在机器学习中,数据教会我们,还有什么比这更纯粹的呢?当使用基于规则的算法或专家系统时,我们依靠专家来制定“正确的”规则。我们无法避免他/她的判断和立场渗透到这些规则中。对直觉的研究甚至可以更进一步说,我们希望专家的经验和观点影响这些规则——它们使他/她成为专家!

无论哪种方式,当我们使用机器学习算法从数据中自下而上工作时,我们似乎已经绕过了这种偏见。

为什么机器学习是一门艺术:

事实不是科学,数据也不是。我们发明科学理论来给出数据背景和解释。帮助我们区分因果关系和相关性。苹果落在牛顿头上是事实;引力是解释它的理论。但是我们如何提出这个理论呢?有没有科学的方法来预测灵光一现?

我们使用科学工具来测试假设,但我们不会以这种方式产生假设,至少不会产生体现创新思维的假设。另一方面,艺术需要一种富有想象力的技巧来表达和创造新事物。在行为分析中,它可以采取理性或非理性人类行为的形式。用户点击内容是事实;解释因果关系的理论可能是它回答了他/她正在寻找的问题,或者它与他/她基于以前的行为感兴趣的领域有关。

人类行为固有的模糊性,甚至更多我们的因果关系或动机,赋予了艺术在预测分析中尊贵的地位。机器学习是归纳的艺术。即使是无监督的学习也使用由人根据他/她的知识和创造力选择、调整和验证的客观工具。

薛定谔:

另一种方式是将机器学习视为艺术和科学。就像薛定谔的猫既活又死,佛教的中道,或者告诉我们光既是波又是粒子的量子物理学。至少在我们测量它之前……你看,如果我们使用科学工具来测量基于机器学习的模型的预测性,我们就同意科学的方法来给予我们的结论某种专业的验证。然而,如果我们专注于衡量潜在的假设,或表示或评估方法,我们会意识到模型只像它的创造者一样“纯粹”。

在行为分析中,很多都依赖于将人类行为解释为可量化的事件。这件作品源于艺术领域。当将行为分析与科学事实相结合时,正如在使用医学或健康研究时经常发生的那样,我们真正创造了一门艺术科学或科学艺术。我们再也不能将科学本质与行为培养分开。

实际实施

虽然这可能是一个有趣的哲学或学术讨论,这里的目的是帮助实用工具和技巧。那么,这对于开发基于机器学习的模型或依赖它们进行行为分析的人来说意味着什么呢(基于我自己的经验加上这篇文章作者的见解——如下)?

1.投资方法论

数据是不够的。叙述数据的理论给了它背景。你在表示、评估和优化这三个阶段做出的选择容易受到糟糕艺术的影响。因此,当需要机器学习模型时,在开发东西之前,请咨询各种专家,选择最适合你情况的方法。

2.垃圾进垃圾出

机器学习不是炼金术。这个模型不能把煤变成钻石。准备数据往往是艺术(或“黑色艺术”)多于科学。而且它占用了大部分时间…对你所依赖的模型中的内容保持批判性的关注,如果你是设计方,尽可能保持透明。记住,更多的相关数据比更聪明的算法更有效。

3.数据准备是特定领域的

没有办法完全自动化数据准备(即特征工程)。一些功能可能只有在与其他功能结合时才会增加价值,从而创造新的事件。通常,这些事件需要让产品或业务有意义,就像它们需要让算法有意义一样。请记住,功能设计或事件提取需要与建模完全不同的技能。

4.关键是整个链中的迭代

你收集原始数据,准备它,然后学习和优化,测试和验证,最后在产品或业务环境中使用。但这个循环只是第一次迭代。一个良好的算法通常会让你重新收集一个略有不同的原始数据,从另一个角度绘制曲线,以不同的方式建模、调整和验证它,甚至以不同的方式使用它。你在这个链条上培养合作的能力,尤其是涉及火星建模师和金星营销人员的地方,是关键!

5.小心做出你的假设

阿基米德说:“给我一根足够长的杠杆和一个支点,我可以撬动地球。”机器学习是一个杠杆,不是魔法。它依赖于感应。你在这个过程中的知识和创造性假设决定了你的立场。如果你选择了正确的杠杆(即方法论),归纳科学将会处理剩下的事情。但决定交战规则的是你的艺术判断。

6.如果可以,获取实验数据

机器学习可以帮助预测基于训练数据集的结果。分割测试(又名 A/B 测试)用于测量因果关系,群组分析有助于分割和定制每个细分市场的解决方案。将来自分裂测试和群组分析的实验数据与机器学习相结合,可以证明比坚持其中一个更有效。你选择整合这两种科学方法的方式非常有创意。

7.污染警报!

不要让调整算法的艺术过程污染了你对其预测性的科学测试。记住保持训练集和测试集的完全分离。如果可能的话,在算法完全优化之前,不要向开发人员公开测试集。

8.国王死了,国王万岁!

这个模型(及其基础理论)只有在更好的模型出现之前才有效。如果你不想成为死亡之王,这是一个好主意,在上一个发布的那一刻开始开发下一代模型。不要把精力花在维护你的模型上;花在试图取代它上。你失败的时间越长,它就变得越强大…

概述

机器学习算法通常用于帮助做出数据驱动的决策。但是机器学习算法并不都是科学,尤其是应用于行为分析的时候。理解这些算法的“艺术”方面及其与科学方面的关系,可以帮助制作更好的机器学习算法,并更有效地使用它们。


我很高兴看到你的反馈。请在下面留下你的评论。

我要感谢穆罕默德·欣达维法比奥·莫里塔阿里尔·沙米尔贡献了他们的见解,阿里尔·沙米尔向我推荐了佩德罗·多明戈斯关于这个主题的一篇有趣的论文

贡献者:

美国好事达保险公司数据科学副总裁穆罕默德·欣达维·FCAS 博士

Fabio Ohara Morita,巴西 Porto Seguro 保险公司技术总监(首席精算师)

Ariel Shamir,以色列 IDC Efi Arazi 计算机科学学院副院长教授

多明戈斯佩德罗。“关于机器学习需要知道的一些有用的事情。”美国计算机学会的通信55.10(2012):78–87。

原载于 2016 年 12 月 2 日orensteinberg.com

机器学习即服务:第 1 部分

原文:https://towardsdatascience.com/machine-learning-as-a-service-487e930265b2?source=collection_archive---------5-----------------------

情感分析:10 个应用和 4 个服务

She loves me, she loves me not …

目录

什么是情感分析?

用户生成内容的爆炸式增长和归档材料的数字化产生了大量数据集,其中包含大量人就几乎每一个主题发表的意见。

在某些情况下,这些数据的生成是通过用户界面结构化的。例如,在电子商务网站上处理客户评论相对容易,因为用户需要在产品评论的文本旁边张贴一个评级。

然而,大多数数据都是以非结构化形式提供的。它不包含一个标准化的总结说“这个内容表达了一个积极的,消极的,混合的或中立的观点。”

例如,WordPress.com 报告称,仅在 2018 年 5 月,使用他们平台的博客就发布了超过 8700 万条帖子。[1]据 YouTube 首席执行官苏珊·沃西基称,每分钟有超过 400 个小时的内容被上传到这个视频分享网站。[2]与此同时,谷歌图书项目已经将 400 种语言的至少 2500 万册图书数字化。[3]

每当用户在自由文本字段中键入内容或对着麦克风说话时,都需要进行推理来对情感进行分类。

情感分析正是专注于这项任务的领域。它是自然语言处理的一个分支,研究旨在将文本文档映射到情感表达的函数。

随着精确语音和文本识别的出现,情感分析的范围已经超出了易于访问的数字文本数据,并且覆盖了越来越多的媒体。

情感分析可以做什么?

情感分析有助于我们了解过去,预测未来,并在当下采取适当的措施。

假设你有机会分析你的客户、竞争对手、学生或其他感兴趣的人所表达的观点。你会用这些知识做什么?

以下是十个想法:

  • 票房收入:Asur &胡伯尔曼(2010)在一个模型中包含了积极情绪与消极情绪的比率,该模型被训练来预测电影上映前的票房收入。[4]
  • 品牌监控:Ghiassi 等人(2013 年)描述了一个旨在监控表达品牌和名人情感的推文的系统。[5]
  • 计算历史:Acerbi (2013)使用 20 世纪出版的书籍档案生成了一个积极和消极情绪的时间序列。[6]
  • 客户反馈:Gamon (2005)在客户调查和知识库中提供的反馈的背景下探索了情感分析。[7]
  • 辍学率:Wen 等人(2014)使用大规模开放在线课程(MOOC)论坛中表达的观点来预测学生流失。[8]
  • 政治情绪的监测:Abbasi 等人(2008)分析了极端主义团体论坛中的政治情绪。[9]
  • 产品评论:在他的经典论文中,Turney (2002)将情感分析应用于不同类型产品和服务的在线评论。[10]
  • 股票市场预测:Bollen 等人(2011 年)在一个预测道琼斯工业平均指数变化的模型中纳入了对公众情绪的估计。[11]
  • 故事弧线:Reagan 等人(2016)使用情感挖掘来确定古腾堡计划小说集中情感轨迹的基本形状。[12]
  • 作为子任务的情感分析:Pang & Lee (2008)提到情感分析作为高阶系统中的一个组件的使用。例如,摘要可能受益于包含对特定主题表达不同意见的来源。[13]

我必须提供什么?我得到了什么回报?

我们已经说过,情感分析将一个文本文档作为输入,并将一个情感的表示作为输出返回。

关于投入没什么好说的。这只是你想要分析的书籍/评论/客户调查/电子邮件/新闻文章/产品评论/推文或其他类型文档的文本内容。

现在,让我们转向输出。

二元情感分析

二元情感分析,最简单的情况,提出如下问题:“文本文档中表达的观点是正面的还是负面的?”

这里,输出要么是概率,要么是分数。

我们先来考虑概率

高概率表示给定文本可能表达正面观点。例如,0.9 的输出表示所表达的意见有 90%的可能性是正面的。

相反,低概率表示给定文本可能是负面观点的表达。例如,0.1 的输出表示 10%的可能性意见是正面的,或者换句话说,90%的可能性意见是负面的。

可选地,情感的预测可以被表达为分数。这里也没有惊喜。积极的分数表明积极的情绪。负分表示负面情绪。绝对值越大表明情感越强烈。

多类情感分析

在多类别情感分析中,输出是在 n 个可能类别上的概率分布,或者换句话说,是一列加起来等于 1 的 n 个非负数。要对意见进行分类,您可以选择与最高概率相关的类别。

二元情感分析是多类情感分析的特例,其中 n=2

二元情感分析的一个简单扩展是引入中性意见类。在这种情况下,输出是三类( n = 3) 的概率分布。这三种概率可以按如下顺序排列:负概率中性概率正概率

例如,对于侧重于技术细节的综述的预测可以具有与此类似的分布:【0.1,0.85,0.05】

现在,假设一个客户发布了一个混合评论,列出了产品的正面和负面。三级情感分析器的输出可以类似于下面的分布:【0.4,0.1,0.5】

处理这个问题的一个方法是包含一个混合的类别。假设我们把四类排序如下:阴性、中性、混合型、阳性。混合产品评审示例中的输出可能类似于这样:【0.15,0.05,0.7,0.1】。**

有哪些好的情感分析服务?

为了完成这一概述,我们将看看领先云计算平台的四种情感分析服务。

An overview of four leading sentiment analysis services

为了提供这些服务性能的第一印象,我使用 Kotzias 等人(2015 年)整理的数据创建了一个基准。[14]

这个汇编包括了来自著名数据集的三个评论子集,每个子集有 1000 个实例:亚马逊产品评论、来自 IMDB 数据集的电影评论和 Yelp 餐馆评论。

亚马逊理解

亚马逊的自然语言处理解决方案understand于去年推出,目前支持英语和西班牙语文档

请求以 100 个字符为单位进行衡量,每个请求最小为 3 个单位。

就像这里列出的其他服务一样,Amazon understand 根据每月的请求数量进行分层。最高 1000 万台,每 1000 台的价格为 0.1 美元。对于超过 5000 万的请求,价格设置为 0.025 美元。

给定凭证提供者、文本和语言代码,可以如下请求情绪的预测:

Sentiment analysis with Amazon Comprehend

API 支持多达 25 个文档(最多 5000 个字符)的批处理请求,并生成四类概率分布:混合中性

不出所料,understand 在 1000 条亚马逊商品评论上取得了最佳表现。结合其他两个数据集上接近 90%的准确率,这使得亚马逊的 API 在基准测试中获得了亚军

谷歌云自然语言 API

Google 的云自然语言 API 支持九种语言,生成两个情感分析值: 分值量级

文档情感的得分表示文档的整体情感。

量级表示文档中存在多少情感内容,并且通常与文档的长度成比例。

表达很少情绪或混合情绪的文档,中性分在 0.0 左右。幅度值可用于消除这两种情况的歧义。低情绪文档具有低量值,而混合情绪与较高的量值相关联。

定价模型基于每个文档 1000 个字符的单位。对于范围在 5,000 个单位和 100 万个单位之间的每月请求,每 1,000 个单位的价格是 1 美元。在 5000 到 100 万件之间,每 1000 件的价格为 1 美元。对于 500 万到 2000 万件范围内的请求,价格降至 0.25 美元。

假设GOOGLE _ APPLICATION _ CREDENTIALS环境变量被设置为包含项目凭证的 JSON 文件的路径,下面的代码对给定的文本执行情感分析:

Sentiment analysis with Googles’ Cloud Natural Language API

谷歌的服务以 92.1 %的出色准确率弥补了批处理的不足,在三个数据集的两个中实现了最佳性能。就性能而言,云自然语言 API 无疑是我们竞争中的赢家。

Microsoft 文本分析 API

微软的情感分析器执行二进制分类,并因此给每个文档分配一个概率。当一个文本不能被分析或者没有情感时,服务总是精确地返回 0.5。

每月有 5,000 笔交易的免费层允许您在没有财务负担的情况下探索 API。入门级标准 S0 层的价格为每月 74.71 美元,有 25000 个请求。最昂贵的公开披露层,标准 S4 ,每月花费 4999.99 美元,包括 1000 万个请求。

高于等级限制的每 1000 笔交易的价格从 0.50 美元到 3 美元不等。

API 支持 15 种欧洲语言多达 1000 个文档的批量请求。

不幸的是,在我们的测试中,这些特性与它的性能并不匹配。文本分析 API 的平均准确率为 81.8%,落后谷歌服务超过 10 个百分点。

Java SDK 的测试版已经推出,但是使用 Unirest 和 GSON 更容易:

沃森自然语言理解

IBM Watson 的情感分析器支持十种语言,并返回一个范围从-1 到+1 的分数。

计费单位由 10,000 个字符组成。根据免费 Lite 计划,每月可购买 30,000 台。标准计划的入门级包括每月前 250,000 台,价格为每 1,000 台 3 美元。500 万件之后,价格下降到 0.20 美元。

在我们的测试中,Watson API 的表现明显好于微软的文本分析 API,但不如 Amazon intensive。

Java SDK 似乎不支持批处理请求。

结论

情感分析对文本文档中表达的观点进行分类。

用户生成内容的增加以及越来越精确的文本和语音识别推动了它的发展。

我们简要介绍了 10 个不同领域的应用:从票房收入预测和品牌监测到股票市场建模和识别故事弧线中情感轨迹的基本形状。

二元分类返回表示正面或负面观点的概率(或分数)。一些情感分析器扩展了这种二分法,并且包括混合和/或中性情感的类别。

然后,我们比较了领先云计算平台的四种情感分析服务。

如果你对情感分析 a 服务感兴趣,我建议你从亚马逊领悟或者谷歌自然语言理解 API 开始。

感谢您的阅读!如果您喜欢这篇文章,请关注我,了解更多关于云中机器学习服务的信息。

参考

[1]https://wordpress.com/activity/posting/

https://youtu.be/O6JPxCBlBh8?t=10m45s

[3]海曼,S. 2015。Google Books:一个复杂而有争议的实验。nytimes.com*。可在:https://www . nytimes . com/2015/10/29/arts/international/Google-books-a-complex-and-contractive-experiment . html【2018 年 6 月 10 日访问】。*

[4]阿苏尔和胡伯尔曼,文学学士,2010 年 8 月。用社交媒体预测未来。2010 年 IEEE/WIC/ACM 网络智能和智能代理技术国际会议论文集-第 01 卷(第 492–499 页)。IEEE 计算机学会。

[5]m . GHI assi,j . Skinner 和 and Zimbra,2013 年。Twitter 品牌情感分析:使用 n-gram 分析和动态人工神经网络的混合系统。专家系统与应用40 (16),第 6266–6282 页。

[6]阿塞尔比,兰波斯,v .,加内特,p .和本特利,R.A .,2013。20 世纪书籍中的情感表达。 PloS one8 (3),p.e59030。

[7]m .加蒙,2004 年 8 月。顾客反馈数据的情感分类:噪声数据、大特征向量和语言分析的作用。第 20 届国际计算语言学会议论文集(第 841 页)。计算语言学协会。

[8]文,男,杨,d 和罗斯,c,2014 年 7 月。MOOC 论坛中的情感分析:它告诉了我们什么?。在教育数据挖掘 2014

[9]a .阿巴西、h .陈和 a .塞勒姆,2008 年。多语言中的情感分析:网络论坛中观点分类的特征选择。《美国计算机学会信息系统汇刊》(TOIS)26 (3),第 12 页

10 特尼博士,2002 年 7 月。竖起大拇指还是竖起大拇指?:语义导向应用于评论的无监督分类。在计算语言学协会第 40 届年会论文集(第 417-424 页)。计算语言学协会。

[11] Bollen,j .,Mao,h .和曾,x .,2011 年。推特情绪预测股市。计算科学杂志2 (1),第 1–8 页。

[12]里根,A.J .,米切尔,l .,凯利,d .,丹福斯,C.M .和多兹,P.S .,2016 年。故事的情感弧线由六种基本形状决定。 EPJ 数据科学5 (1),第 31 页

[13]庞和李,2008 年。观点挖掘和情感分析。信息检索基础与趋势2(1-2),第 1-135 页。

[14]d . Kotzias,m . Denil,n . De Freitas 和 Smyth,p .,2015 年 8 月。使用深层特征从组标签到单个标签。第 21 届 ACM SIGKDD 知识发现和数据挖掘国际会议论文集(第 597–606 页)。ACM。

机器学习即服务

原文:https://towardsdatascience.com/machine-learning-as-a-service-af9ae8af6f4?source=collection_archive---------12-----------------------

[## 机器学习即服务|地理杂志的博客

机器学习,人工智能的矛头之一,在当前打开了不可想象的视角…

地理. gs](https://geographica.gs/en/blog/machine-learning-as-a-service/)

机器学习,人工智能的矛头之一,开启了当前数字时代不可想象的视角。在大数据的背景下,它在最不同的领域带来了巨大的进步,并且似乎没有尽头。

这一切都要归功于不同领域和学科的进步带来的巨大推动力,如数学、计算能力、物联网传感器和云计算。另一方面,这种场景允许将其用作服务。

它们的应用数不胜数,令人惊讶,而且在许多情况下令人兴奋。的确,应用领域是巨大的,有时是不可预测的。电子商务和营销等行业只是机器学习项目提供的使用可能性的一个小样本。

机器学习:无尽的应用

可能的应用列表几乎是无限的,但最重要的是,这是一个开放的列表,肯定会有许多惊喜。在其他用途中,自动学习算法使社交网络或搜索引擎中的推荐系统以及易贝或亚马逊等公司的平台成为可能。

同样,自动学习有助于在线安全,有助于检测故障、消费者趋势或潜在客户,此外还能够预测城市交通、疾病、执行更好的诊断、语音识别或例如打开门与机器通信。

微软首席执行官塞特亚·纳德拉表示,由于它在识别行为模式方面的关键作用,它还有助于提高员工和公司的生产力和效率,以及改善业务数据。

按照纳德拉的说法,它显示自己是一个伟大的盟友:

“在业务流程中重塑销售、营销和人才管理。”

但是对于这一点,不管每个项目的方向是什么,重要的是将产生的数据转换成对公司有价值的信息。

机器学习即服务选项

这就是我们从理论的世界,以难以置信的可能性来实施项目,到一个有形的现实:我们的。也是在那个时候,我们必须考虑,既犯了乌托邦目标的错误,又因为害怕失败而放弃。

机器学习,人工智能的矛头之一,开启了当前数字时代不可想象的视角。

虽然没有意识到自动学习系统的应用是复杂的,但机器学习作为一种服务的应用可以使事情变得容易得多,这也是事实。

假设技术和数据都在那里,等着我们去利用它们,押注于它们的使用是一个资本决策,因为这意味着利用一个黄金机会来做出更好的决策。因此,无论何时预见到好处,以谨慎和研究的方式启动它是为渴望的竞争优势加分的第一步。对于许多公司来说,这一决定意味着在云中使用机器学习作为服务,并且没有太多的复杂性。

它的优点是什么?

虽然有一些限制,但今天的机器学习对于那些希望通过机器学习即服务的公式来利用其可能性的人来说是可行的,机器学习即服务是云中的一系列服务,包括自动学习工具。

在市场上,我们会发现不同的云计算 MLaaS 供应商,一方面,他们在各自的数据中心使用不同类型的工具进行计算。其中,预测分析工具、数据建模 API、自动学习算法、数据转换、深度学习、面部识别、数据可视化或者例如自然语言处理。

这些服务的优势恰恰在于易用性,因为客户可以开始在云中应用它,而不必投资安装软件。像任何其他云服务一样,它可以在云中使用,也可以以混合方式使用,在这种情况下,机器学习必须与本地 it 基础设施相集成。

巨大的商业潜力

在增加销售和改善商业决策方面,机器学习的应用领域涵盖了非常不同的领域,可以转化为最多样和最雄心勃勃的项目。
然而,在实践中,项目需要组织层面的文化支持,这并不总是容易实现的。此外,其准确性取决于多种因素,如需求、创造力或可用的技术和人力资源。

事实上,提供价值和竞争优势需要熟练的工人,即在自动学习系统的帮助下,通过预测将数据转化为有价值的信息的专家。

虽然机器学习即服务为我们提供了自动化、可扩展的系统,能够在很少人工干预的情况下评估和改进分析过程,但我们只有通过专家的技能才能取得成功。幸运的是,您可以访问这些资源,而不必投资复杂的基础设施。

事实上,提供价值和竞争优势需要熟练的工人,即在自动学习系统的帮助下,通过预测将数据转化为有价值的信息的专家。

通过使用云中的机器学习服务和一个小团队,我们可以开始:设计第一个策略,并建立我们的第一个工作模型,以实现开始给出结果的预测。

由于平台的计算能力,机器学习即服务项目的目标是通过自动化流程理解我们自己的数据,识别模式并获得有价值的信息。显然,这一切都是为了扩大业务。

有了这些最少的资源(这些资源将根据每个提供商提供的解决方案而有所不同),使用机器学习作为服务对公司来说具有巨大的潜力,因为模型会不断更新自己,从而赢得时间并降低成本。

即使有机器学习服务的帮助,这一挑战也需要奉献和无数的努力,如果我们考虑它可以带来的优势,这些努力才是真正值得的。基本上,它是关于创建预测模型,通过与业务流程优化相关的成就为组织提供附加值。

由于对客户有了更好的了解,这将更容易保持忠诚度,吸引潜在的买家或用户,并找到新的收入渠道,节省成本,以及识别潜在的威胁,降低风险和脆弱性。事实上,自动化学习可以提高组织中关键数据的安全性。

美好的前景,但还有很长的路要走

虽然在机器学习的运用上成功案例不胜枚举,但也确实还有很长的路要走。从这个意义上来说,Drum 最近的一份报告探讨了机器学习在解决商业挑战中的应用,并得出结论,其重要性正在以一种重要的方式增加,成为该领域议程的优先事项之一。

与此同时,Wakefield Research and Demand Base 的一项调查显示,80%的营销高管认为人工智能在五年内将在该领域发挥革命性的作用。

然而,这些专业人士中几乎有三分之一声称他们不知道如何利用它,这与 Forrester Consulting 的一项研究相同,该研究也发现了同样的知识缺乏。或许,机器学习作为一种服务的公式被称为供给的缺乏。

黑客攻击海马体:机器学习的下一个前沿和超越…

原文:https://towardsdatascience.com/machine-learning-as-hacking-of-the-brain-6aab8c4a9e7d?source=collection_archive---------7-----------------------

在我们每个人的头骨深处,都有一个像鳄鱼的大脑一样的东西。围绕 R-复合体的是边缘系统或哺乳动物的大脑,它在几千万年前从哺乳动物但还不是灵长类动物的祖先进化而来。它是我们情绪和情感的主要来源,是我们关心和爱护年轻人的主要来源。最后,在外部,与更原始的大脑处于不稳定的休战状态的是大脑皮层;文明是大脑皮层的产物。”

——卡尔·萨根,宇宙 276–277 页

关于人类大脑的神经科学知识仍然是如此不完整,以至于我们只能从神经科学家的想法中获得灵感,而不是基于坚如磐石的科学证据。然而最近深度学习的成功表明这种方法是可行的。

监督学习的强大性能匹配甚至超过了上面引用的卡尔·萨根的“鳄鱼的大脑”。“边缘系统或哺乳动物大脑”是下一站。它的核心是海马体,这是大脑皮层根部的一个单一的弯曲的灰质细胞层。海马体被广泛认为介导了许多认知功能,因为它密集的相互轴突投射到和来自皮质。

认知功能的调节者

想象你的身体是一架无人机,由两个不同的人驾驶。其中一个有驾驶舱视角(或者他们称之为“第一人称视角”)。这位飞行员可以在单独的显示器上看到无人机的垂直和水平位置,但前方的视野是他获取信息的主要渠道。第一个飞行员可以立即将当前的驾驶舱视图与之前任务中拍摄的电影和快照进行比较。更重要的是,这位飞行员可以在每次识别出熟悉的路径时开启巡航控制甚至自动驾驶模式。

另一名飞行员通过在 3D 显示器上操作一个小模型来驾驶同一架无人机。第二名飞行员有时会从远处(他们称之为“在视线范围内”)看一眼无人机,但大多数时候他只能看到无人机模型在环境模型中的位置。(无人驾驶飞机和环境的)两个模型都已创建,并根据以前任务记录的比较和无人驾驶飞机所有传感器的新数据输入进行即时调整。

现在想象一下,两个飞行员不能互相交谈或以任何其他方式交换信息。他们只能通过理想观察者的决定来交换无人机的控制权。理想的观察者看不到任何一个飞行员的显示器。他只能以理想的准确度测量在那些显示器上已经发生、实际发生和预测将发生的所有事件的概率,以及关于那些事件的信息的可信度。理想的观察者就像一个交换台,在两个飞行员之间交换控制。第一个试验在存在关于可能或不可能事件的高可信度信息的情况下是很好的,但是当信息的可信度低时,它会完全丢失。然后第二个飞行员就位。它通过地标导航,并探索环境以获得更可信的信息。

探索和观察探索者

在这一点上,海马体第一次成为我们关注的焦点,因为它是负责做出探索决策的大脑区域,即关于在被动和主动学习会话之间切换的决策。西北大学的一组研究人员在 2014 年发表在《细胞》杂志上的一篇文章中指出“海马活动因此直接与眼球运动模式相对应,从而在海马活动和支持探索决策的特定眼球运动行为相关信息之间建立了紧密的联系。”。

来自加州理工学院的研究人员在 2015 年从一个不同的角度解读了海马体在学习过程中的作用,“在神经层面,我们的研究结果表明,根据我们的模型,在支持一次性学习的学习速率范围内,有证据表明涉及一个非常特定的神经系统。具体来说,相对于较慢的学习速度,高学习速度的海马体活动增加(90%或以上),相反,海马体没有活动。因此,海马体似乎是以类似开关的方式被招募的,只有在一次性学习发生时才会出现,否则就会保持沉默。”

海马和爬行动物的大脑

海马形似海马,故名。它是哺乳动物大脑边缘系统的一部分。尾状核位于人脑最古老也是最小的区域。它在数亿年前进化而来,更像是当今爬行动物的整个大脑。由于这个原因,它通常被称为爬行动物的大脑。

加拿大麦吉尔大学的研究人员在 2013 年的实验中重复了他们之前许多其他研究人员的结果,这些结果显示了“海马依赖的空间导航策略和尾状核依赖的刺激反应导航策略之间的明显差异……海马对于以别为中心的空间学习和记忆以及认知地图的形成至关重要,即学习和记忆环境地标之间的关系,而不管观察者的位置如何。 这样就可以从任何起始位置直接到达任何目标位置……相比之下,纹状体(尾状核)对于反应学习和记忆以及通过建立严格的刺激-反应关联形成习惯至关重要。”

他们还指出,“海马体和纹状体(尾状核)也参与决策过程。依赖于海马体的决策过程,包括将自己投射到未来的情境中,以创造对行动结果的期望。相比之下,依赖于纹状体的决策过程利用过去的经验将行为与价值联系起来。

蒙特利尔大学的科学家在为期四年的研究中展示了“纹状体和海马体中的灰质之间的反比关系”正如他们所说,“有大量证据支持这样的假设,即空间策略的使用与海马灰质和活动的增加有关,而反应策略的使用与纹状体灰质和活动的增加** …”**

海马启发的神经网络架构

最近,来自 DeepMind 的研究人员提出了一种预测地图理论,其灵感来自最近对海马体的神经科学研究以及他们对强化学习算法的了解。他们认为"预测映射理论可以转化为神经网络架构"

甚至比这更早,来自加拿大莱斯布里奇大学的研究人员在他们的论文(发表于 2016 年 12 月)中提出了这样的想法:“海马体中处理的关键特征支持一种灵活的基于模型的强化学习(MBRL)机制,用于空间导航**,这种机制在计算上是高效的,可以快速适应变化。”他们写道,“我们通过**实现一个计算 MBRL 框架来研究这一想法,该框架包含了受海马体计算属性启发的功能:空间的分层表示,“向前扫描”未来的空间轨迹,以及环境驱动的位置细胞的重新映射。我们发现,空间的分层抽象极大地减少了适应不断变化的环境条件所需的计算负载(脑力劳动),并允许高效地扩展到大型问题。它还允许在高水平上获得的抽象知识来指导对新障碍的适应。此外,上下文驱动的重新映射机制允许学习和记忆多个任务。”

世界模型的认知地图

现在发现海马体的作用远远超出了空间导航。“鉴于海马体对于通过认知地图**、进行空间导航至关重要,它的作用来自认知地图的关系组织和灵活性,而不是来自空间领域的选择性作用。相应地,海马网络映射出多种导航策略,以及其他强调关系组织的空间和非空间记忆和知识领域。这些观察表明海马系统并不致力于空间认知和导航,而是组织记忆中的经验,空间映射和导航既是对关系记忆组织的隐喻,也是其突出应用。来自波士顿大学的 Howard Eichenbaum 于 2017 年 4 月在他的论文中写道。**

2017 年,巴黎大学认知神经成像部门的研究人员就该主题提供了一个更广泛的观点,称我们的大脑实施了“置信度加权学习算法,充当统计学家,使用概率信息来估计世界的层次模型****

逆向破解道德大脑

这个故事始于我对童话的兴趣。尤其令我着迷的是一项系统发育研究,该研究追溯了一些最受欢迎的现代童话故事的起源,可以追溯到青铜时代。民间传说和讲故事领域最杰出的研究人员写了许多书和文章,他们是:弗拉迪米尔·普罗普、克洛德·列维·斯特劳斯、杰克·齐普斯、杰罗姆·布鲁纳,这些书和文章让我相信,神奇的民间故事在人类的驯化过程中发挥了至关重要的作用。

大多数研究人员都同意童话对我们的大脑有潜移默化的影响这一点,尽管他们的研究同时集中在童话的显性语言上。例如,克洛德·列维·斯特劳斯建议童话可以在普通语言之上承载一种元语言**。杰罗姆·布鲁纳(Jerome Bruner)在强调一个好故事的影响的隐含本质时创造了术语来驯服不确定性**

南加州大学神经科学家在 2017 年 9 月发表的研究显示,对英语、波斯语或普通话故事的分布式表示的识别发生在大脑中被称为默认模式网络的相同区域。那个网络包括海马**。研究结果表明,“叙事的神经语义编码发生在比个体语义单位更高的层次上,这种编码在个体和语言中都是系统的。”**

我们假设一个童话故事是一串密集的事件,具有随机变化的概率和可信度,它改变了学习的平衡,从依赖先前的知识转向探索新获得的信息。我们把童话故事中包含的隐性大脑编码叫做大脑刷新按钮**。它对语言或文化不敏感。它增强了人们独立运用理性的能力,而不管文化背景如何。**

耶鲁大学心理学教授保罗·布鲁姆和他的团队在研究婴儿道德时发现,人类大脑很可能有一套固定的基本(或幼稚)道德原则和道德情感**。天真的道德原则和情感需要根据现实生活和现代世界进行调整。正如布鲁姆教授所说,“在这个领域,先天能力、文化学习和个人理性实践之间存在着令人着迷的相互作用。”。**

我们相信,好的童话在校准天真的道德原则和情感中起着关键作用。除此之外,他们利用大脑刷新按钮来做到这一点。现在,我们正在制造工具,使好的童话故事的隐含代码恢复活力,因为我们周围的绝大多数故事都是坏的。它们已经被修改,只针对人类大脑中最大化自动反应短期回报的爬行动物部分。

意识可以被黑吗?

来自伯尔尼大学的研究人员在 2015 年提出了一个概念,即“海马是无意识和有意识记忆相互作用的地方。”

来自石勒苏益格-荷尔斯泰因大学医院和德国基尔大学的一组研究人员在 2011 年发表的一篇论文中宣布了他们的研究结果,这些研究结果提供了证据表明人类海马 CA1 神经元对于自传体 情景记忆的提取至关重要,并且它们对于自主意识也很重要。

未完待续…

机器学习:平衡模型性能和商业目标

原文:https://towardsdatascience.com/machine-learning-balancing-model-performance-with-business-goals-57eaa870ff66?source=collection_archive---------15-----------------------

这篇文章旨在为评估使用机器学习解决您的业务问题提供一些指导。

作为一名数据科学家,我非常渴望找到“最佳”模型——我的预测有多接近完美?然而,更多的时候,我努力争取的增量是不必要的。我优先考虑的成功标准并不总是业务优化的量化指标。

例如,如果我告诉你我的一个客户实现了一个准确率为 64.2%的模型,你可能会大吃一惊。然而,他们认为没有必要及时投资来改进模型。事实上,它有助于取代耗费数周时间的以手工为主(且不受欢迎)的工作流程。新的解决方案只花了几天时间,让团队有时间去做他们喜欢的更具挑战性的任务。

这篇文章将讨论评估机器学习模型的商业考虑。此外,它还提供了回归问题(预测数值)、分类问题(预测项目的类别)和建议的示例。

基线

基线是一个度量标准,表明您今天解决问题的成功程度。使用任何新解决方案的目标——无论是否有机器学习——都应该是改善这一点。

让我们考虑一下我上面提到的客户的情况…

例如:目前,员工手动完成这项任务需要 X 个小时,花费$Y。他们往往有 Z%的时间是正确的,但发现这项任务令人沮丧。

我们有三个可量化的指标:时间、成本和准确性。还有一个定性点表明当前的解决方案不受员工欢迎;在某些情况下,您甚至可能希望为此捕获一个可量化的指标。

目标:创建一个解决方案,将这项任务从员工身上移除,让他们可以做自己喜欢的工作,提高员工满意度,同时节省时间和金钱。

如上所述,企业认为模型准确性不如删除不必要的工作负载和节省时间重要。

因此,要理解一个模型是否适合生产,您需要考虑和平衡多个指标。我考虑的三个主要因素是:

1。性能

这表明解决方案在预测正确结果方面有多好。

衡量标准本身因问题的类型而异。无论为机器学习模型选择哪一个,都应该用于计算性能基线。

2。时间

这是完成任务所需的持续时间。

对于基线,这是在没有机器学习模型的情况下需要多长时间;无论是使用替代软件解决方案还是手动方式。

3。钱

这是任务的货币影响。

对于基线,这可能与完成任务的成本或当前解决方案的销售额有关。

作为一名数据科学家,我经常非常关注性能,因为这是我可以控制的。然而,为了让我的模型用于生产,评估和交流这些其他量词是很重要的。然后,利益相关者可以做出明智的决定,决定是否继续我所构建的内容。

示例场景

回归——预测房价

假设我们拥有一家房地产代理公司。该公司有很多股票,并希望探索机器学习是否可以帮助决定每栋房子的要价。

目前,一个人会阅读关于房产的文件,并根据该地区最近出售的其他类似房屋,对房子的价值做出明智的决定。然后,他们将根据自己的经验决定报价。

我们决定专注于建立一个预测房子价值的模型。然后,代理可以使用该模型的预测来决定合适的报价。

我们希望该模型能够发现与价格相关的特征的趋势和模式。然而,我们仍然意识到,它可能会错过人类可以捕捉到的细微差别,例如,财产的状况,这就是为什么在这种情况下,我们希望他们做出最终决定。

表演

基线——代理商之前的预测与销售价格有多接近?

度量——平均绝对误差(MAE)、均方根误差(RMSE)

我们应该计算当前的性能值——一个代理平均做出一个好的预测的能力——并与我们最好的模型的性能进行比较。

时间

基线—代理进行预测需要多长时间?

如果这对于我们的代理人来说是一项耗时的任务,并且使用机器学习模型可以使其明显更快,那么仅此一点就可以证明推进我们的模型是正确的。

基线—公司让代理人为房屋定价需要多少成本?错了要付出多大代价?

最终,该机构希望赚最多的钱。如果投资机器学习模型会让公司付出成本,他们需要了解他们将在哪里省钱,或者他们可能在哪里赚钱。

分类—预测欺诈性银行活动

假设我们是一家社区银行,想要探索更好地防止欺诈活动的方法。

目前,我们有简单的规则来标记“可疑”交易,例如:超过特定的阈值金额,或在州外购买。对于每一笔被标记的交易,员工都要检查账户所有人的档案和以前的交易,以便更好地了解这是否不合常规。然后,他们运用自己的最佳判断,要么允许交易,要么在认为这是欺诈时采取适当的行动。

我们希望建立一个预测模型来更好地识别欺诈。该模型应减少我们的员工审查非欺诈交易的次数,同时确保我们捕捉到欺诈交易。

和前面的例子一样,我们仍然需要决定如何在生产中使用这个模型。一种选择是让员工参与进来,让他们仍然评估个人资料,但确保他们有更少的内容需要审查。或者,我们相信模型会直接进入流程的下一步:打电话给客户,验证交易是他们的。这是一个需要由企业做出的决定,但以下指标也可以帮助指导这一决定。

性能

基线—标记为可疑的交易中有多大比例实际上是欺诈?有多少交易实际上是欺诈性的?

指标——准确度、精确度、召回率、F1 分数

了解当今欺诈活动的识别能力,使我们能够与任何已建立的模型进行比较。企业应该评估可用的指标,并决定哪一个对他们最重要——准确性是最直观的,但不一定是最适合每个问题的。

时间

基线—从交易发生到银行代理将其识别为欺诈之间有多长时间?代理人向客户确认交易是否有效需要多长时间?

可能有机会使用模型来最大限度地减少代理处理此任务的时间。然而,推迟释放资金也可能产生后果。

基线——银行让欺诈交易通过需要多少成本?反过来说,跟进一个客户以确认他们的交易需要多少钱?

欺诈显然会耗费企业的资金,但在每笔交易都与客户澄清之前,阻止释放资金是不可行的。了解这些相关成本可以让您做出适当的商业决策。

推荐—推荐图书

对于这个场景,我们拥有一个在线书店。我们有许多回头客,他们登录网页进行购买。我们有谁购买了什么的历史数据,以及用户为他们的购买提供的评级。我们希望利用信息更好地提出建议。

目前,我们计算每个流派的热门书籍:过去 30 天内最畅销的书籍。前 20 名作为推荐显示给用户。

我们希望根据顾客之前的购买和兴趣进行个性化定制,而不是纯粹根据销售额对每个顾客进行同样的预测。

由于我们有历史购买和评论,我们有明确和隐含的数据。评级是明确的数据:顾客告诉我们喜欢或不喜欢一件商品的程度。同时,购买数据是隐含的:购买商品意味着他们喜欢该产品,但这可能实际上并不成立。

性能

基线——平均而言,顾客会购买多少本推荐书籍?被推荐书籍的平均评分是多少?

指标(隐含、购买)—召回、精确度、平均精确度(MAP)

指标(明确,评级)—平均绝对误差(MAE),均方根误差(RMSE)

当我们建立模型时,我们用历史数据评估它的性能。我们可能还希望在我们的用户子集上运行这个产品,以评估它在产品中的性能,这是 A/B 测试。

时间

基线—当前推荐模型显示推荐需要多长时间?

推荐过程已经自动化,但我们正在寻找替代它。由于算法的复杂性,一些推荐引擎可能具有更高的延迟(返回结果所需的时间),这应被视为不确定良好的用户体验。

基线——目前的建议能赚多少钱?

在这里,我们试图赚更多的钱,而不是像前面的例子那样试图省钱。我们需要了解当前的财务提升来自于建议,这样我们就可以与我们期望模型实现的目标进行比较。

机器学习—基础知识

原文:https://towardsdatascience.com/machine-learning-basics-part-1-a36d38c7916?source=collection_archive---------0-----------------------

机器学习领域的基础理论

本文介绍了机器学习理论的基础,奠定了所涉及的常见概念和技术。这篇文章是为刚开始学习机器的人准备的,让他们很容易理解核心概念,并熟悉机器学习的基础知识。

Source

什么是机器学习?

1959 年,人工智能研究的先驱、计算机科学家亚瑟·塞缪尔(Arthur Samuel)将机器学习描述为“在没有明确编程的情况下赋予计算机学习能力的研究。”

艾伦·图灵的开创性论文(图灵, 1950 年)介绍了一个展示机器智能的基准标准,即机器必须具有智能和响应能力,其方式不能与人类有所不同。

机器学习是人工智能的一种应用,其中计算机/机器从过去的经验(输入数据)中学习,并做出未来的预测。这样一个系统的性能至少应该是人的水平。

Tom m . Mitchell(1997)给出了一个更具技术性的定义:“如果一个计算机程序在 T 类任务中的性能(如 P 所测量的)随着经验 E 而提高,那么就可以说它从经验 E 中学习了一些任务 T 和性能测量 P。”例如:

**A handwriting recognition learning problem:****Task T**: recognizing and classifying handwritten words within images
**Performance measure P**: percent of words correctly classified, accuracy
**Training experience E**: a data-set of handwritten words with given classifications

为了执行任务 T,系统从所提供的数据集进行学习。数据集是许多例子的集合。一个例子是特征的集合。

机器学习类别

机器学习通常分为三种类型:监督学习、非监督学习、强化学习

监督学习:

在监督学习中,机器会经历这些例子以及每个例子的标签或目标。数据中的标签有助于算法关联特征。

两个最常见的监督机器学习任务是分类回归

In **classification** problems the machine must learn to predict discrete values. That is, the machine must predict the most probable category, class, or label for new examples. Applications of classification include predicting whether a stock's price will rise or fall, or deciding if a news article belongs to the politics or leisure section. In **regression** problems the machine must predict the value of a continuous response variable. Examples of regression problems include predicting the sales for a new product, or the salary for a job based on its description.

无监督学习:

当我们有未分类和未标记的数据时,系统试图从数据中发现模式。这些示例没有给出标签或目标。一个常见的任务是将相似的例子组合在一起,称为聚类。

强化学习:

强化学习是指面向目标的算法,它学习如何在许多步骤中实现复杂的目标或沿着特定的维度最大化。这种方法允许机器和软件代理自动确定特定上下文中的理想行为,以便最大化其性能。代理人需要简单的奖励反馈来学习哪一个动作是最好的;这就是所谓的强化信号。例如,在一场游戏中,通过多次移动来最大化赢得的点数。

监督机器学习技术

回归是一种技术,用于从一个或多个预测变量(自变量)预测响应变量(因变量)的值。

最常用的回归技术有:线性回归逻辑回归。我们将讨论这两种突出技术背后的理论,同时解释机器学习中涉及的许多其他关键概念,如Gradient-descent算法、Over-fit/Under-fitError analysisRegularizationHyper-parametersCross-validation技术。

线性回归

在线性回归问题中,目标是从给定的模式*X*中预测实值变量*y* 。在线性回归的情况下,输出是输入的线性函数。假设*ŷ*是我们的模型预测的输出:*ŷ* = *WX*+*b*

这里*X*是向量(示例的特征),*W*是确定每个特征如何影响预测的权重(参数的向量),*b*是偏差项。因此,我们的任务*T*是从*X*预测*y*,现在我们需要测量性能*P*以了解模型的表现如何。

现在来计算模型的性能,我们首先计算每个例子*i*的误差为:

我们采用误差的绝对值来考虑误差的正值和负值。

最后,我们计算所有记录的绝对误差的平均值(所有绝对误差的平均和)。

平均绝对误差(MAE) =所有绝对误差的平均值

更流行的测量模型性能的方法是使用

均方误差(MSE) :预测值与实际观测值的平方差的平均值。

平均值被减半(1/2 ),以便于计算梯度下降(稍后讨论),因为平方函数的导数项将抵消 1/2 项。有关 MAE 与 MSE 的更多讨论,请参考[1]和[2]。

训练 ML 算法的主要目的是调整权重*W*以减少 MAE 或 MSE。

为了最小化误差,模型在经历训练集的例子时,更新模型参数*W*。这些根据*W*绘制的误差计算也被称为成本函数 *J(w)*,因为它决定了模型的成本/惩罚。因此最小化误差也被称为最小化成本函数 j。

梯度下降算法:

当我们绘制成本函数*J(w) vs w*时。它表示如下:

从曲线中我们可以看出,存在一个参数值*W*,它具有最小的成本*Jmin*。现在我们需要找到一种方法来达到这个最低成本。

在梯度下降算法中,我们从随机模型参数开始,计算每次学习迭代的误差,不断更新模型参数,以更接近产生最小成本的值。

重复直到最小成本:{

}

在上面的等式中,我们在每次迭代后更新模型参数。方程的第二项计算每次迭代时曲线的斜率或梯度。

成本函数的梯度被计算为成本函数*J* 相对于每个模型参数*wj* *j*取特征数量[1 to n]的值。*α*alpha ,是学习率,或者说我们想要多快地向最小值移动。如果*α*太大,我们可以超调。如果*α*太小,意味着学习的步骤很小,因此模型观察所有示例所花费的总时间会更多。

梯度下降有三种方式:

**批量梯度下降:**使用所有的训练实例来更新每次迭代中的模型参数。

**小批量梯度下降:**小批量梯度下降不是使用所有的例子,而是将训练集分成更小的称为“b”的批量。因此,小批量“b”用于在每次迭代中更新模型参数。

随机梯度下降(SGD): 在每次迭代中仅使用单个训练实例更新参数。训练实例通常是随机选择的。当有成千上万或更多的训练实例时,随机梯度下降通常是优化成本函数的首选,因为它比批量梯度下降收敛得更快[3]。

逻辑回归

在某些问题中,响应变量不是正态分布的。例如,抛硬币会有两种结果:正面或反面。伯努利分布描述了随机变量的概率分布,该随机变量可以采用概率为*P*的正情况或概率为*1-P*的负情况。如果响应变量代表一个概率,它必须被限制在{0,1}的范围内。

在逻辑回归中,响应变量描述了结果是正面情况的概率。如果响应变量等于或超过判别阈值,则预测阳性类别;否则,预测负类。

使用逻辑函数将响应变量建模为输入变量的线性组合的函数。

由于我们的假设*ŷ*必须满足0 ≤ *ŷ* ≤ 1,这可以通过插入逻辑函数或“Sigmoid 函数”来实现

函数*g(z)*将任何实数映射到(0, 1)区间,这对于将任意值函数转换为更适合分类的函数非常有用。以下是范围{-6,6}内 sigmoid 函数值的曲线图:

现在回到我们的逻辑回归问题,让我们假设*z*是单个解释变量*x*的线性函数。我们可以将*z*表达如下:

逻辑函数现在可以写成:

注意*g(x)*解释为因变量的概率。
*g(x) = 0.7*,给我们 70%的概率,我们的输出是 1。我们预测为 0 的概率正好是我们预测为 1 的概率的补充(例如,如果预测为 1 的概率是 70%,那么预测为 0 的概率是 30%)。

sigmoid 函数‘g’的输入不需要是线性函数。它可以是圆形或任何形状。

价值函数

我们不能使用用于线性回归的相同成本函数,因为 Sigmoid 函数将导致输出波动,从而导致许多局部最优。换句话说,它不会是凸函数。

Non-convex cost function

为了确保成本函数是凸的(并因此确保收敛到全局最小值),使用 sigmoid 函数的对数来变换成本函数。逻辑回归的成本函数如下所示:

可以写成:

所以逻辑回归的成本函数是:

由于成本函数是凸函数,我们可以运行梯度下降算法来找到最小成本。

装配不足和过度装配

我们试图通过增加或减少模型容量来使机器学习算法适应输入数据。在线性回归问题中,我们增加或减少多项式的次数。

考虑从*x ∈ R*预测*y*的问题。下面最左边的图显示了将一条线拟合到一个数据集的结果。由于数据不在一条直线上,所以拟合不是很好(左图)。

为了增加模型容量,我们通过添加术语*x²*来添加另一个特性。这产生了更好的拟合(中间的数字)。但是如果我们继续这样做(*x⁵*,5 阶多项式,图在右边),我们可能能够更好地拟合数据,但是对于新数据将不能很好地概括。第一个数字表示欠拟合,最后一个数字表示过拟合。

欠拟合:

当模型具有较少的特征,因此不能很好地从数据中学习时。这个模型有很高的偏差。

过度装配:

当模型具有复杂的函数,因此能够很好地拟合数据,但不能进行归纳以预测新数据时。这个模型有很高的方差。

有三个主要选项来解决过度拟合问题:

  1. **减少特征数量:**手动选择保留哪些特征。这样做,我们可能会错过一些重要的信息,如果我们扔掉一些功能。
  2. **正则化:**保留所有特征,但减少权重 w 的大小。当我们有许多稍微有用的特征时,正则化工作得很好。
  3. **提前停止:**当我们迭代地训练一个学习算法时,比如使用梯度下降,我们可以测量模型的每次迭代执行得有多好。达到一定的迭代次数后,每次迭代都会改进模型。然而,在这一点之后,模型的概括能力会减弱,因为它开始过度拟合训练数据。

正规化

通过向误差函数添加惩罚项,正则化可以应用于线性和逻辑回归,以阻止系数或权重达到大值。

正则化线性回归

最简单的这种罚项采取所有系数的平方和的形式,导致修正的线性回归误差函数:

其中λ是我们的正则化参数。

现在为了使误差最小化,我们使用梯度下降算法。我们不断更新模型参数,以更接近产生最小成本的值。

重复直到收敛(使用正则化):{

}

通过一些操作,上述等式也可以表示为:

上述等式中的第一项,

将始终小于 1。直观上,你可以看到每次更新时,系数的值都会减少一些。

正则化逻辑回归

正则化逻辑回归的成本函数为:

重复直到收敛(使用正则化):{

}

L1 和 L2 正规化

前面方程中使用的正则项称为 L2 正则化或岭正则化。

L2 罚旨在最小化权重的平方。

还有一种称为 L1 或拉索的正则化:

L1 罚旨在最小化权重的绝对值

L1 和 L2 的区别
L2 以相同的比例缩小所有系数,但不消除任何系数,而 L1 可以将一些系数缩小到零,从而执行特征选择。欲了解更多详情,请阅读

超参数

超参数是描述关于模型的结构信息的“高级”参数,该结构信息必须在拟合模型参数之前决定,到目前为止我们讨论的超参数的例子有:
学习率α,正则化λ。

交叉验证

选择超参数最优值的过程称为模型选择。如果我们在模型选择过程中反复使用相同的测试数据集,它将成为我们训练数据的一部分,因此模型更有可能过度拟合。

整个数据集分为:

  1. 训练数据集
  2. 验证数据集
  3. 测试数据集。

训练集用于拟合不同的模型,然后验证集的性能用于模型选择。在训练和模型选择步骤中保留模型之前未见过的测试集的优点是,我们避免了过度拟合模型,并且模型能够更好地推广到未见过的数据。

然而,在许多应用中,用于训练和测试的数据供应将是有限的,并且为了建立良好的模型,我们希望使用尽可能多的可用数据来进行训练。然而,如果验证集很小,它将给出预测性能的相对嘈杂的估计。解决这个难题的一个方法是使用交叉验证,如下图所示。

下面的交叉验证步骤是从到这里的进行的,在这里添加是为了完整。

逐步交叉验证:

使用 K-fold 交叉验证选择超参数的步骤如下:

  1. 将你的训练数据分成 K = 4 等份,或者“折叠”
  2. 选择一组您希望优化的超参数。
  3. 使用前 3 个折叠的超参数集训练您的模型。
  4. 在第四次折叠时评估它,或“保持”折叠。
  5. 用相同的超参数集重复步骤(3)和(4) K (4)次,每次保持不同的折叠。
  6. 汇总所有 4 次折叠的性能。这是一组超参数的性能指标。
  7. 对您希望考虑的所有超参数集重复步骤(2)至(6)。

交叉验证允许我们仅用我们的训练集来调整超参数。这使得我们可以将测试集作为真正不可见的数据集来选择最终模型。

结论

我们已经涵盖了机器学习领域的一些关键概念,从机器学习的定义开始,然后涵盖了不同类型的机器学习技术。我们讨论了最常见的回归技术(线性和逻辑)背后的理论,并讨论了机器学习的其他关键概念。

感谢阅读。

参考

[1]https://medium . com/human-in-a-machine-world/Mae-and-RMSE-metric-is-better-e 60 AC 3 bde 13d

[2]https://towardsdatascience . com/ml-notes-why-the-least-square-error-BF 27 FDD 9 a 721

[3]https://towards data science . com/gradient-descent-algorithm-and-its-variants-10f 652806 a3

[4]https://elitedata science . com/machine-learning-iteration # micro

机器学习基础—第 1 部分—回归的概念

原文:https://towardsdatascience.com/machine-learning-basics-part-1-concept-of-regression-31982e8d8ced?source=collection_archive---------3-----------------------

Photo by Andre Benz on Unsplash — https://unsplash.com/photos/cXU6tNxhub0

在这篇文章中,我重温了 Andre Ng 在 coursera 上的《神奇的机器学习课程》中的学习材料,并对这些概念做了一个概述。除非另有明确说明,否则所有引用都是指本课程的材料。

目录

定义

如果计算机程序在 T 中的任务上的性能(如 P 所测量的)随着经验 E 而提高,则称该程序从关于某类任务 T 和性能测量 P 的经验 E 中学习。—汤姆·米切尔

一元线性回归

模型表示

线性回归试图将点拟合到由算法生成的直线上。该优化线(模型)能够预测某些输入值的值,并且可以绘制出来。

价值函数

我们希望设置参数,以实现预测值和实际值之间的最小差异。

我们可以通过使用成本函数来衡量假设函数的准确性。这是假设的所有结果与 x 的输入和 y 的实际输出的平均差(实际上是一个更好的平均版本)。

梯度下降

梯度下降不断改变参数以逐渐降低成本函数。随着每一次迭代,我们将更接近最小值。每次迭代时,参数必须同时调整!“步长”/迭代的大小由参数α(学习速率)决定。

我们这样做的方法是对成本函数求导(函数的切线)。切线的斜率是该点的导数,它会给我们一个前进的方向。我们沿着下降速度最快的方向逐步降低成本函数。

选择α的值至关重要。如果它太小,算法将很慢,如果它太大,它将无法收敛。

当具体应用于线性回归的情况时,可以导出新形式的梯度下降方程,其中 m 是训练集的大小。同样,两个参数必须同时更新。

注意,虽然梯度下降通常易受局部极小值的影响,但我们在此提出的线性回归优化问题只有一个全局最优值,没有其他局部最优值;因此梯度下降总是收敛(假设学习率α不太大)到全局最小值。

多元线性回归

现在,我们有多个特征/变量,而不是一个特征/变量负责某个结果。

因此,假设相应地改变,并考虑多个参数。这同样适用于梯度下降。它只是附加参数的扩展,这些参数必须更新。

特征缩放和均值归一化

要确保所有的要素值都在相同的范围内并具有相同的平均值,有必要使用要素缩放和平均值归一化。

特征缩放包括将输入值除以输入变量的范围(即最大值减去最小值),从而得到一个仅为 1 的新范围。均值归一化包括从某个输入变量的值中减去该输入变量的平均值,从而得出该输入变量的新平均值正好为零。

学习率

为了选择一个合适的学习率,必须绘制梯度下降图并进行“调试”。

在 x 轴上绘制迭代次数的曲线图。现在绘制梯度下降迭代次数的成本函数 J(θ)。如果 J(θ)增加,那么你可能需要减少α。

如果 J(0)在迭代步骤中停止显著下降,则可以宣布收敛。

多项式回归

可以通过将假设函数重新定义为二次、三次或平方根函数来改善特征。

在这种情况下,必须特别强调特征缩放!

正规方程(用于分析计算)

法线方程将导数设置为零,而不是使用梯度下降来逐渐最小化成本函数。

正规方程不需要学习率α,根本不需要迭代,但需要设计矩阵的转置。当您有大量的要素(例如 10000)时,计算将比梯度下降的迭代过程花费更长的时间。为了提高法方程算法的质量,应该正则化特征并删除冗余特征。

逻辑回归

分类

为了对数据进行分类,结果应该是 0 或 1(二进制分类)。从回归的角度来看,这可能意味着将大于等于 0.5 的输出分类为 1,将小于 0.5 的输出分类为 0(而 0.5 是决策界限)。

使用 logistic/sigmoid 函数,修改后的假设现在是:

它返回输出为 1 的概率!

适应的成本函数和梯度下降

由于使用了 sigmoid 函数,因此必须通过使用对数来相应地调整成本函数。因为现在的目标不是最小化与预测值的距离,而是最小化假设的输出与 y (0 或 1)之间的距离。

或者对于矢量化实现:

然而,梯度下降保持不变,因为公式使用了假设的导数部分!

或者对于矢量化实现:

梯度下降的替代方案

更复杂的优化算法,如

  • 共轭梯度,
  • BFGS 或
  • 左旋 BFGS

通常允许更快的计算,而不需要选择学习速率α。

多类分类

先前描述的分类问题解决仅适用于二元分类。具有多于 n=2 的可能结果称为多类分类。为了在多个类别上应用该概念,使用了“一个对所有”方法,其本质上是在每个类别上应用二元分类(一个类别是正面的,所有其余的是负面的)。不是将 y 设置为 0 或 1,而是将 y 设置为 I,这本身是针对所有其他类进行测试的。基本上这个过程是双重的:

  1. 将逻辑分类器设置为 y。(如果 y 是 3,我们创建 3 个分类器)
  2. 针对所有分类器测试新输入,并选择概率最高的分类器。

过拟合问题和正则化的使用

在过度拟合的情况下,模型完美地捕获了数据结构,而在欠拟合的情况下,模型没有捕获足够的数据结构(即模型的图形几乎不接触所有的数据点)。

为了解决过度拟合的问题,可以减少特征或者调整它们的值的大小。

正规化

为了正则化模型,必须将参数(λ)添加到成本函数中。它减小或增大了参数θ。

因此,将其应用于逻辑回归看起来像这样:

请注意正则化参数如何从 1 开始,而不是正则化偏置项θ0

这就结束了第一部分。在下一篇中,将描述神经网络。敬请期待!

关于

丹尼尔是一名企业家、软件开发人员和商业法毕业生。他曾在各种 IT 公司、税务咨询、管理咨询和奥地利法院工作。

他的知识和兴趣目前围绕着编程机器学习应用程序及其所有相关方面。从本质上说,他认为自己是复杂环境的问题解决者,这在他的各种项目中都有所体现。

如果您有想法、项目或问题,请不要犹豫与我们联系。

你可以在 https://www.buymeacoffee.com/createdd[上支持我](https://www.buymeacoffee.com/createdd)

连接到:

机器学习基础—第 2 部分—神经网络的概念以及如何调试学习算法

原文:https://towardsdatascience.com/machine-learning-basics-part-2-concept-of-neural-networks-and-how-to-debug-a-learning-algorithm-8a5af671d535?source=collection_archive---------1-----------------------

Photo by Matteo Catanese on Unsplash — https://unsplash.com/photos/PI8Hk-3ZcCU

在这篇文章中,我重温了 Andre Ng 在 coursera 上的惊人的机器学习课程的学习材料,并创建了一个概念概述。除非另有明确说明,否则所有引用都是指本课程的材料。

目录

神经网络模型表示

对于神经网络,我们从探索统计回归中获得发现,并试图将其放入类脑架构中。

所使用的术语略有变化,因为逻辑函数通常被称为 sigmoid 激活函数,而θ参数被称为权重。基本概念保持不变。代替偏置项θ0,现在使用值为 1 的偏置单位。

神经网络架构由至少 3 层组成。即

  • 输入,
  • 隐藏的,
  • 输出

层。(尽管许多神经网络有不止一个隐藏层)

在激活单元中,重新计算和重新测量前一层中每个单元的加权输入。你可以说,神经网络基本上可以通过越来越多的高级输入多次实现统计回归的概念。

当然,这个概念也可以通过矢量化来应用。因此,我们使用一个新的变量,它包含了 g 函数中的权重参数,作为一个激活单元。这里跟踪和可视化矩阵的维度非常重要,因为它会很快变得非常复杂(取决于你的神经网络结构)。

看看这篇令人难以置信的文章,它用漂亮的图片很好地解释了这个概念。

一个很好的介绍例子是异或问题。这篇文章解释的很好。

神经网络中的成本函数

对于要在神经网络中使用的逻辑回归,成本函数必须被扩展以保持输出单位 K,并且正则化部分需要层数、当前层中的节点数(加上偏置项)和下一层中的节点数,以正确地定位θ值。

逻辑回归的成本函数:

神经网络中逻辑回归的成本函数;

反向传播

“反向传播”是神经网络术语,用于最小化我们的成本函数,就像我们在逻辑和线性回归中使用梯度下降一样。

前向传播(节点的激活)接收前一层中每个节点的θ参数,而反向传播基本上相反。通过将激活节点的输出与该节点的计算输出进行比较来计算每个节点的误差。之后,通过调整所使用的参数θ,该误差逐渐最小化。

计算误差的公式为:

展开参数

因为一些更高级的算法需要计算的矢量化版本。将矩阵展开成向量是计算成本函数、获取计算参数的向量并将结果重新成形为矩阵的一种很好的方式。

梯度检查

为了确保你的反向传播按预期工作,你应该检查你的梯度。这是通过用下面的公式计算θ的近似值来完成的:

如果结果类似于梯度向量,则实现工作正常。

随机初始化

为了在神经网络中使用梯度下降,θ的初始值不能是对称的,必须随机初始化。使用对称初始化总是导致相同的学习结果,因为没有提供多样性。

训练神经网络的清单

  1. 随机初始化权重
  2. 实现前向传播以获得假设
  3. 计算成本函数以获得误差
  4. 实施反向传播以计算偏导数(通过误差优化参数)
  5. 应用梯度检查(将反向传播与数值估计进行比较)
  6. 禁用渐变检查
  7. 使用优化方法最小化具有相应参数的成本函数

调试学习算法

有时候学习的算法会产生很大的误差。以下策略有助于您进行调试。

评估假设

你总是可以采取的第一步是获得更多的测试数据,增加或减少特性或你的正则化λ。

之后,将数据分成一个训练集(~70%)和一个测试集(~30%)。这种技术给你即时反馈,告诉你你的假设执行的有多好。

型号选择

仅仅因为一个学习算法非常适合一个训练集,并不意味着它是一个好的假设。它可能会过度拟合,结果你对测试集的预测会很差。在用于训练参数的数据集上测量的假设误差将低于任何其他数据集上的误差。

给定许多具有不同多项式次数的模型,我们可以使用系统的方法来确定“最佳”函数。为了选择你的假设的模型,你可以测试多项式的每一次,看看误差结果。

因此,数据可以分为 3 组:

  1. 训练集
  2. 交叉验证集
  3. 测试装置

这允许我们 1。计算最佳参数,2。应用于不同的多项式模型,找出误差最小的一个,3。估计最佳模型的一般误差。

偏差和方差

偏差与方差问题描述了假设对数据集拟合不足或拟合过度的问题。高偏差会使数据欠拟合,而高方差会使数据过拟合。

对于诊断,可以比较各组的误差。如果交叉验证和测试集的误差很大,则假设存在很大的偏差。如果交叉验证集显示比训练集高得多的误差,则问题很可能是方差问题。

这些问题可以使用不同的正则化λ参数来解决。

请记住,值为 1 的λ等于完全有偏的假设(欠拟合),而值为 0 的λ本质上是高方差假设(过拟合)。

为了在实践中应用这一点,创建一个 lambdas 列表(例如,0,0.01,0.02,0.04,0.08,0.16,0.32,0.64,1.28,2.56,5.12,10.24)是有用的,并且当在训练集中的不同多项式模型上工作时提供它们,并且挑选具有最小误差的一个。需要注意的是,在计算交叉验证的误差时,不要再次使用正则化,因为它会扭曲结果。

学习曲线和集合的大小

随着集合大小的增加,误差将增加,直到某一点达到稳定。

如果算法受到高偏差的困扰,那么获得更多的数据将不会有所帮助,因为它已经不足。然而,如果问题是一个具有高方差的过拟合问题,获得更多的数据可能会改进算法。

摘要

高偏差可以通过以下方式解决

  • 添加功能
  • 添加多项式要素
  • 减小正则化参数λ

高差异可以通过以下方式解决

  • 获取更多培训数据
  • 减少特征
  • 增加正则化参数λ

实际上,我们希望选择一个介于两者之间的模型,既能很好地概括,又能合理地拟合数据。

设计机器学习系统

人们必须问自己的重要问题:

  • 马赫数据应该如何收集?
  • 如何开发复杂的功能?什么特征实际上对目标起作用?
  • 如何开发有助于减少误解的算法?

设计机器学习系统的推荐方法是

  1. 从一个简单的算法开始,在交叉验证数据上进行测试
  2. 绘制学习曲线,对下一步要改进的地方做出正确的决定
  3. 手动检查错误,看看是什么类型的错误,以及如何改进以避免这些错误

倾斜类和分类

当一个类在数据集中出现过多时,就会出现偏斜类。

要测试您的数据是否存在此问题,请实施精度和召回测试。您实际上是在测试所有预测阳性(精度)的真阳性,并将其与所有实际阳性的真阳性进行比较。

根据分类问题的目标,衡量精度和召回率的方式会有所不同。当假设返回 0 或 1 之间的概率时,设定的边界阈值决定是否将结果分类为正面或负面。

往往起点是 0.5,即。低于 0.5 的一切都被归类为负面。根据您是希望非常自信地预测,还是希望避免错过许多情况,测试 0 和 1 的不同值(例如 0.3、0.5、0.7、0.9)并比较结果算法是有意义的。因为您将有 2 个值(一个用于精度,一个用于召回),所以可以随后使用 F-Score 公式计算所需的阈值:

高准确度

为了获得尽可能高的精度,最好使用尽可能多的有用(!)数据(低方差),但也要有一个具有许多特征或参数的算法(低偏差)。

这就结束了第二部分。下一篇将介绍支持向量机和无监督学习。敬请期待!

关于

丹尼尔是一名企业家、软件开发人员和商业法毕业生。他曾在各种 IT 公司、税务咨询、管理咨询和奥地利法院工作。

他的知识和兴趣目前围绕着编程机器学习应用程序及其所有相关方面。从本质上说,他认为自己是复杂环境的问题解决者,这在他的各种项目中都有所体现。

如果您有想法、项目或问题,请不要犹豫与我们联系。

你可以在 https://www.buymeacoffee.com/createdd 支持我

连接到:

机器学习基础—第 3 部分—向量机、无监督学习和主成分分析

原文:https://towardsdatascience.com/machine-learning-basics-part-3-vector-machines-unsupervised-learning-and-principal-component-5b51aac6dd0c?source=collection_archive---------6-----------------------

Photo by Anders Jildén on Unsplash — https://unsplash.com/photos/cYrMQA7a3Wc

在这篇文章中,我重温了 Andre Ng 在 Coursera 上的《神奇的机器学习课程》中的学习材料,并对这些概念做了一个概述。这篇文章的目的不是作为一个教程,而是更新基本思想。

除非另有明确说明,否则所有引用都是指本课程的材料。

目录

支持向量机

数学定义

不是像我们在原始成本函数中那样用λ正则化第二项:

现在,我们希望用参数 C 正则化第一项,并为转置θ添加新的成本函数(成本 1 和成本 0 ):

绘制成本 1 和成本 0 函数看起来像这样:

因此,如果我们想要一个结果 y = 1,转置 X 必须大于 1,如果 y = 0,转置 X 必须小于-1。

本质上,我们只是简化了成本函数,以便在后续步骤中使用几何图形。

大间距分类器

对于可线性分离的数据,SVM 算法会选择具有最大间隔的线来分离这些类。

使用微积分,参数的长度可以很容易地从初始公式中检索出来。

By Martin Thoma — Own work, CC BY 3.0, https://commons.wikimedia.org/w/index.php?curid=20159892

基本上,向量 X 的投影乘以参数θ的长度,并优化为最大值/最小值。这导致总是返回一条线,看起来将两个类平均分开。

请注意,为了忽略异常值,降低 C 值(正则化)会有所帮助。

由于多项式特征的计算代价很高,所以通常的做法是引入内核。为此,计算依赖于特征和实例的相似性的新特征。这就像把地标放在地块上,用高斯核公式计算相似度。如果相似度为 1,则训练示例接近所挑选的地标。

对参数σ的值的选择确定了相似性的边界。

引入地标相似性系统允许对非线性数据进行分类。

如何选择地标

为了计算界标,我们将成本函数调整为如下:

请记住,对于正则化部分,应该使用 m(训练示例)而不是 n(特征数量)。这是有意义的,因为我们想要计算与示例相关的界标。

还要注意,您也可以在逻辑回归上实现核的概念,但是 SVM 的数学优势不能被正确利用,并且实现可能会更慢。

内核的另一个术语是“相似性函数”。

SVM 参数

为了解决过拟合和欠拟合问题,可以使用参数λ(单位为 C)和σ。

增加 C(本质上是最小化λ)或减小σ平方可以改善欠拟合(高 C 导致更高的方差)。

实践技巧以及如何选择正确的系统

  • 使用 SVM 软件包,而不是尝试编写自己的 SVM 计算
  • 最常见的核函数是线性核(不使用核)或高斯核
  • 还有其他的内核,但是要检查它们是否能够满足“默瑟定理”
  • 如果 n 远大于 m,使用逻辑回归或线性核的 SVM
  • 如果 n 在 m 的适当范围内,则使用高斯核
  • 如果 n 小于 m,则使用具有线性核的逻辑回归或 SVM,或者添加更多特征
  • 神经网络对所有这些设置都很有效,但训练起来可能会比较慢

聚类和无监督学习

在一个监督学习问题中,给定一组标签来拟合一个假设。相比之下,在无监督学习问题中,我们得到的数据没有任何与之相关的标签。

该算法的目标是在数据集中找到结构(聚类)。

k-均值算法

简单地说,这个算法是:

  • 随机初始化“质心”(数据中间的标记)
  • 将最接近数据点的数据点分配给每个质心
  • 将质心移动到数据点的中心(平均值)
  • 重复前面的 2 个步骤,直到簇中没有变化

优化目标

成本函数试图最小化示例点和相应聚类质心位置之间的平方距离的平均值,如下所示:

为了避免局部最优,应多次执行以下步骤:

  1. 随机初始化 K-均值
  2. 运行 K-means 算法来获得分类的索引和分类质心
  3. 计算成本函数

为了选择簇的数量 k,可以使用“肘形方法”,该方法将成本函数绘制成簇的数量,并且在曲线显示“肘形”的地方使用该数量。然而,由于这种方法可能难以在某些图表上使用,另一种方法是根据后续/下游目的(如所需的产品尺寸——小、中、大)简单地选择数字。

降维和主成分分析

通过数据压缩将数据从多维减少到二维或三维,可以绘制数据并提供有价值的额外见解。简单地减少数据可以加快学习算法的运行时间,并减少存储所需的空间。

主成分分析

最常见的算法是主成分分析。其背后的思想是通过寻找将数据投影到其上的方向(向量)来减少维度,以最小化投影误差。绘制时,该算法可能看起来类似于线性回归模型。然而,重要的是要注意,在线性回归中,变量 y 由变量 x 预测,而在 PCA 中,不同的变量 x 被同等对待。

要实现 PCA 算法,通常需要

  1. 执行均值归一化和特征缩放
  2. 使用以下公式计算协方差矩阵(sigma)
  3. 对 sigma 使用奇异值分解(svd)
  4. 将得到的 U 矩阵的前 k 列的转置与应该减少的特征向量 x 相乘,并返回得到的 z 特征向量

为了解压缩数据并利用这一概念的真正力量,可以通过简单地将 U 矩阵再次乘以 z 向量来重构(近似)原始数据。

为了选择变量 k(主成分的数量),可以使用下面的公式:

这个想法是将平均平方投影误差(我们试图将其最小化)除以数据的总变化。

实际的实现是在 k = 1 的情况下尝试 PCA 算法,并测试保留方差的条件是否满足,如果不满足,则应该继续增加 k 的过程。或者取 S 矩阵,它是通过对 sigma 使用奇异值分解并对其进行如下测试而得到的:

(本质上相当于前面的公式)

实用技巧

要加速监督学习案例,您应该

  1. 仅提取输入(如果为您提供了一个已标记的训练集,则需要一个未标记的训练集)
  2. 执行 PCA 算法
  3. 通过用新的输入 z 替换先前的 x 来创建新的训练集
  4. 用新的数据集训练你的算法

请注意,PCA 应该只用于训练集,而不是交叉验证或测试集。之后,从 x 到 z 的映射结果也可以应用于交叉验证和测试集。

当你的模型有过度拟合的问题时,注意不要使用 PCA。虽然减少特征有助于解决问题,但是 PCA 的概念在不知道 y 值的情况下丢弃了一些信息。这可能导致不好的结果。不如用正则化来代替。

最后,总是尝试用原始数据来训练你的算法。只有在正常的机器学习架构不充分的情况下,才应该应用 PCA!

这就结束了第三部分。在下一篇文章中,将描述异常检测、推荐系统和扩展问题。敬请期待!

关于

我认为自己是一个解决问题的人。我的强项是在复杂的环境中导航,提供解决方案并分解它们。我的知识和兴趣围绕商业法和编程机器学习应用发展。我在构建数据分析和评估业务相关概念方面提供服务。

连接到:

支持和邮件

机器学习基础—第 4 部分—异常检测、推荐系统和扩展

原文:https://towardsdatascience.com/machine-learning-basics-part-4-anomaly-detection-recommender-systems-and-scaling-b8bbf0413aa9?source=collection_archive---------1-----------------------

Photo by Fahrul Azmi on Unsplash — https://unsplash.com/photos/vR-Nb0bncOY

在这篇文章中,我重温了 Andre Ng 在 Coursera 上的《神奇的机器学习课程》中的学习材料,并对这些概念做了一个概述。这篇文章的目的不是作为一个教程,而是更新基本思想。

除非另有明确说明,否则所有引用都是指本课程的材料。

目录

异常检测

异常检测针对该范围内其他示例的行为测试一个新示例。这种想法通常用于欺诈检测、机器制造或监控。如果目标是检测某些异常值,它总是有用的。

使用高斯分布算法意味着示例 x 分布有均值μ和方差适马平方。

μ和适马平方的公式为:

计算概率的公式是:

构建算法的步骤如下

  1. 选择可能代表异常示例的特征 x
  2. 计算参数μ和适马
  3. 计算 x 的概率 p
  4. 根据您设定的概率边界ε进行测试

开发一个异常检测系统

当实现该算法时,引入实数评估度量是很重要的。

与往常一样,建议将数据集分为训练集、交叉验证集和测试集(60–20–20)。

建立该系统的步骤如下:

  1. 在训练集上拟合模型 p(x)
  2. 根据交叉验证和测试集的结果概率预测 y
  3. 使用列联表(真阳性、假阳性等)、精确度/召回方法或 F1 分数评估结果
  4. 改变ε的值(如有必要)

监督学习系统的实用技巧和区别

在以下情况下,应使用异常检测系统

  • 有大量的反面例子,但也有少量正面例子
  • 异常本身不能被分类,并且在将来的例子中可能变化
  • 例如,欺诈检测、监控机器等。

如果分类可以很容易地完成,即有大量的正面和负面的例子,未来的例子将是相似的,建议使用监督学习算法。(例如垃圾邮件、癌症分类)

为了分析误差,有必要绘制特征图,看看它们是否表现为高斯分布。如果没有,可以添加常数(如 log(x)),以尽量使其看起来像高斯分布。

使用异常检测系统的基本假设是异常实例少,正常实例多。如果不满足这一点,则应检查错误分类的示例的行为是否允许提出新的特征。

多元高斯分布

在某些情况下,正态高斯分布不足以准确标记异常。多元高斯分布会立即计算 x 的概率模型,而不是单独为每个要素建立概率模型。它使用协方差矩阵,而不是适马平方。

该公式如下所示:

鉴于:

当样本数远大于特征数时,多元高斯模型是值得考虑的。它捕捉特征之间的相关性,但是计算量很大。当很明显什么特征组合可以捕获异常时,建议首先使用原始高斯模型实现这些特征组合。

推荐系统

推荐系统是在现实生活中应用机器学习算法的最常见和最成功的实例之一。

假设你有一个基于内容的推荐系统。首先,一个问题必须被公式化。这可能类似于预测某个用户对某个产品的评价。

给定电影的评级,为了学习某个用户的参数θ,优化算法可以看起来像这样:

  • 参数θ表示某个用户的向量
  • 特征 x 表示电影的向量
  • y 表示某个用户对某部电影的评价
  • n 表示用户的数量

这是为不同用户(θj)总结的具有正则化的平方误差的基本成本函数。

并且使用梯度下降(将学习率α乘以关于优化目标的参数的偏导数)来逐渐最小化结果。注意,k = 0 时的θ0 不应被正则化(如线性回归中所解释的)。

基于协同过滤的特征学习

给定特定电影的每个用户的参数θ,电影的特征向量可以用优化算法来估计:

解决首先计算哪个向量(电影的特征向量或用户的参数向量)的问题的一种方法是猜测用户的参数向量,然后使用该估计来定义电影的(更好的)特征向量。

这种实现被称为协同过滤,因为对于用户的每个评级,该算法能够定义更好的电影特征向量,并改善所有用户的输出。

为了同时使用协同过滤(同时更新θ和 x),可以使用以下公式:

这导致以下梯度下降实现:

要实现这个公式,您必须

  1. 用小的随机值初始化所有的θ和 x
  2. 使用提供的梯度下降公式最小化成本函数
  3. 用参数θ和学习到的特征 x 预测用户的电影评级。

进一步使用

在实现协同过滤系统之后,另一个步骤可以是推荐相关的电影/产品。

这很容易做到,因为我们已经计算了特征向量 x。现在要找到相关的电影/产品,我们只需找到距离最小的,比如:

请注意,如果您的用户或电影/产品根本没有评级,您应该在实现学习算法之前执行均值归一化。要实现这一点,首先应该从结果矩阵中减去平均值,然后在预测评级时重新相加。但是你应该经常问自己,向一个完全不确定的单位推荐某样东西是否有意义。

扩展机器学习系统

当一个案例有非常多的例子时(大约 1 亿个),总是问自己是否有可能在保留结果的情况下减少数据集。

一种方法是绘制 m 值范围的学习曲线,并验证当 m 小时算法具有高方差。当 th 算法已经具有高偏差时,增加数据集没有帮助。

随机梯度下降

在大的训练集上,梯度下降变得非常计算昂贵。解决这个问题的一个方法是使用随机梯度下降。

不是一次迭代所有训练示例,而是随机打乱数据集,并对单个示例执行梯度下降,如下所示:

这允许改进每个单个示例的参数,因此比一次改进所有示例的参数花费更少的时间。(代价是它可能根本不会收敛,但对于大多数实际用例来说,最终会足够接近)。

小批量梯度下降

作为在每次梯度下降迭代中遍历所有示例或仅遍历 1 个示例的中间方式,小批量允许在每次迭代中设置一定数量 b 的示例。调整后的循环可能如下所示:

收敛性测试

为了测试小批量或随机梯度下降是否收敛,可以绘制并检查成本函数。

对于小批量梯度下降,迭代次数的成本函数可以直接绘制,而对于随机梯度下降,成本函数(在某个例子上)必须根据多个例子的平均值绘制。

如果算法未能收敛,尝试缓慢降低学习速率α。

在线学习

在网上学习的观念中,数据被认为是无穷无尽和免费的。例如在网站上获取用户数据流。在这种情况下,每次可以对一个示例执行梯度下降,次数不限。随着每个输入的例子,算法被改进,并且这样算法也可以根据用户偏好的改变而适应。

映射减少和数据并行

另一种处理大型数据集的方法是使用批量梯度下降,但将其分成不同的子集,允许多台机器处理自己的数据集。之后,可以简单地将结果相加,以符合原始公式(基本上使用函数和)。

在应用程序上使用的技巧

为你的问题创建一个管道

例如

  • 检测文本
  • 分段字符
  • 分类字符

获取更多数据

  • 尝试通过在你已有的数据集上添加变形来创建额外的数据(人工数据合成)
  • 尝试自己收集/标记数据
  • 人群来源数据

上限分析

通过比较准确度的提高,分析管道中哪些部分值得花费时间进行改进。

第四部分到此结束。多么不可思议的课程!:)

感谢阅读我的文章!欢迎留下任何反馈!

丹尼尔是一名商业法的法学硕士学生,在维也纳担任软件工程师和技术相关活动的组织者。他目前的个人学习努力集中在机器学习上。

连接到:

You can support me on https://www.buymeacoffee.com/createdd

基于 K-最近邻算法的机器学习基础

原文:https://towardsdatascience.com/machine-learning-basics-with-the-k-nearest-neighbors-algorithm-6a6e71d01761?source=collection_archive---------0-----------------------

k-最近邻(KNN)算法是一种简单、易于实现的监督机器学习算法,可用于解决分类和回归问题。暂停!让我们打开它。

ABC. We are keeping it super simple!

分解它

有监督的机器学习算法(与无监督的机器学习算法相反)是一种依靠有标签的输入数据来学习一个函数的算法,当给定新的无标签数据时,该函数产生适当的输出。

想象一台计算机是一个孩子,我们是它的监管人(例如父母、监护人或老师),我们希望这个孩子(计算机)学习猪的样子。我们将向孩子展示几种不同的图片,其中一些是猪,其余的可以是任何东西的图片(猫、狗等)。

当我们看到猪时,我们会喊“猪!”当它不是猪的时候,我们就喊“不,不是猪!”对孩子这样做几次后,我们给他们看一张图片,问“猪?”而且他们会正确地(大部分时间)说“猪!”或者“不,不是猪!”取决于图片是什么。那就是监督机器学习。

“Pig!”

监督机器学习算法用于解决分类或回归问题。

一个分类问题有一个离散值作为它的输出。例如,“喜欢比萨饼上的菠萝”和“不喜欢比萨饼上的菠萝”是不连续的。没有中间地带。上面教孩子识别猪的类比是分类问题的另一个例子。

Image showing randomly generated data

此图显示了分类数据的基本示例。我们有一个预测器(或一组预测器)和一个标签。在图中,我们可能试图根据某人的年龄(预测值)来预测他是否喜欢在披萨上放菠萝(1)或不喜欢(0)。

标准做法是将分类算法的输出(标签)表示为整数,如 1、-1 或 0。在这种情况下,这些数字纯粹是代表性的。不应该对它们进行数学运算,因为这样做没有意义。想一想。什么是“喜欢菠萝”+“不喜欢菠萝”?没错。我们不能将它们相加,所以我们不应该将它们的数值表示相加。

一个回归问题的输出是一个实数(一个带小数点的数)。例如,我们可以使用下表中的数据,在给定身高的情况下估计某人的体重。

Image showing a portion of the SOCR height and weights data set

回归分析中使用的数据看起来与上图中显示的数据相似。我们有一个独立变量(或一组独立变量)和一个因变量(给定我们的独立变量,我们试图猜测的东西)。例如,我们可以说身高是自变量,体重是因变量。

此外,每行通常称为示例、观察值或数据点,而每列(不包括标签/因变量)通常称为预测值、维度、自变量或特征。

一种无监督机器学习算法利用没有任何标签的输入数据——换句话说,没有老师(标签)告诉孩子(计算机)什么时候是正确的,什么时候它犯了错误,以便它可以自我纠正。

监督学习试图学习一个函数,该函数将允许我们在给定一些新的未标记数据的情况下进行预测,而非监督学习则不同,它试图学习数据的基本结构,以便让我们对数据有更多的了解。

k-最近邻

KNN 算法假设相似的事物存在于附近。换句话说,相似的事物彼此靠近。

"物以类聚,人以群分."

Image showing how similar data points typically exist close to each other

请注意上图中,大多数时候,相似的数据点彼此接近。KNN 算法取决于这个假设是否足够真实,以使该算法有用。KNN 捕捉到了相似性(有时称为距离、接近度或紧密度)的概念,这与我们童年时可能学过的一些数学有关——计算图表上各点之间的距离。

注: 在继续之前,了解我们如何计算图上点之间的距离是必要的。如果您不熟悉或需要复习如何计算,请通读“ 两点间距离 ”的全文,然后回来。

还有其他计算距离的方法,根据我们要解决的问题,有一种方法可能更好。然而,直线距离(也称为欧几里德距离)是一个流行和熟悉的选择。

KNN 算法

  1. 加载数据
  2. 将 K 初始化为您选择的邻居数量

3.对于数据中的每个例子

3.1 根据数据计算查询示例和当前示例之间的距离。

3.2 将示例的距离和索引添加到有序集合中

4.按距离从小到大(按升序)对距离和索引的有序集合进行排序

5.从排序的集合中挑选前 K 个条目

6.获取所选 K 个条目的标签

7.如果是回归,返回 K 个标签的平均值

8.如果分类,返回 K 标签的模式

KNN 实现(从头开始)

选择正确的 K 值

为了选择最适合您的数据的 K,我们使用不同的 K 值运行 KNN 算法几次,并选择减少我们遇到的错误数量的 K,同时保持算法在给定以前从未见过的数据时准确做出预测的能力。

以下是一些需要记住的事情:

  1. 当我们把 K 值减小到 1 时,我们的预测变得不稳定。只需思考一分钟,想象 K=1,我们有一个由几个红色和一个绿色包围的查询点(我在想上面彩色图的左上角),但绿色是单个最近邻。合理地说,我们会认为查询点最有可能是红色的,但是因为 K=1,KNN 错误地预测查询点是绿色的。
  2. 相反,当我们增加 K 的值时,由于多数投票/平均,我们的预测变得更加稳定,因此,更有可能做出更准确的预测(直到某一点)。最终,我们开始看到越来越多的错误。在这一点上,我们知道我们把 K 值推得太远了。
  3. 如果我们在标签中采取多数投票(例如,在分类问题中选择模式),我们通常将 K 设为奇数,以进行平局决胜。

优势

  1. 该算法简单,易于实现。
  2. 没有必要建立一个模型,调整几个参数,或作出额外的假设。
  3. 算法是通用的。它可以用于分类、回归和搜索(我们将在下一节中看到)。

不足之处

  1. 随着示例和/或预测器/独立变量的数量增加,算法变得明显更慢。

实践中的 KNN

随着数据量的增加,KNN 的主要缺点是速度明显变慢,这使得它在需要快速做出预测的环境中是不切实际的选择。此外,还有更快的算法可以产生更准确的分类和回归结果。

然而,如果你有足够的计算资源来快速处理你用来做预测的数据,KNN 仍然可以用来解决那些依赖于识别相似物体的问题。这方面的一个例子是在推荐系统中使用 KNN 算法,这是 KNN 搜索的一个应用。

推荐系统

从规模上看,这就像在亚马逊上推荐产品,在 Medium 上推荐文章,在网飞上推荐电影,或者在 YouTube 上推荐视频。不过,我们可以肯定的是,由于他们处理的数据量巨大,他们都使用了更有效的方式来提出建议。

然而,我们可以使用我们在本文中学到的知识,在较小的规模上复制这些推荐系统中的一个。让我们来构建一个电影推荐系统的核心。

我们试图回答什么问题?

给定我们的电影数据集,与电影查询最相似的 5 部电影是什么?

收集电影数据

如果我们在网飞、Hulu 或 IMDb 工作,我们可以从他们的数据仓库中获取数据。因为我们不在任何一家公司工作,所以我们必须通过其他途径获取数据。我们可以使用来自 UCI 机器学习库、 IMDb 数据集、的一些电影数据,或者煞费苦心地创建我们自己的数据。

探索、清理和准备数据

无论我们从哪里获得数据,都可能有一些问题需要我们去纠正,以便为 KNN 算法做准备。例如,数据可能不是算法预期的格式,或者可能有我们应该在将数据传送到算法之前填充或删除的缺失值。

我们上面的 KNN 实现依赖于结构化数据。它需要以表格的形式。此外,该实现假设所有列都包含数字数据,并且数据的最后一列有标签,我们可以对其执行一些功能。因此,无论我们从哪里获得数据,我们都需要使它符合这些约束。

下面的数据是我们清理后的数据的一个例子。该数据包含三十部电影,包括七个流派的每部电影的数据及其 IMDB 评级。labels 列全是零,因为我们没有使用这个数据集进行分类或回归。

Self-made movies recommendation data set

此外,当使用 KNN 算法时,电影之间存在不被考虑的关系(例如,演员、导演和主题),这仅仅是因为捕获这些关系的数据从数据集中缺失。因此,当我们对我们的数据运行 KNN 算法时,相似性将只基于所包含的电影类型和 IMDB 评级。

使用算法

想象一下。我们正在浏览电影 Xb 网站,这是一个虚构的 IMDb 衍生网站,我们遇到了 《邮报》。我们不确定是否想看,但它的类型吸引了我们;我们对其他类似的电影很好奇。我们向下滚动到“更像这样”部分,看看 MoviesXb 会做出什么推荐,算法齿轮开始转动。

MoviesXb 网站向其后端发送与帖子最相似的 5 部电影的请求。后端有一个和我们一模一样的推荐数据集。它首先为帖子创建行表示(更好地称为特征向量),然后运行一个类似于下面的程序来搜索与帖子最相似的 5 部电影,最后将结果发送回 MoviesXb 网站。

当我们运行这个程序时,我们看到 MoviesXb 推荐了 12 年的奴隶钢锯岭卡特威女王风起美丽心灵。既然我们完全理解了 KNN 算法是如何工作的,我们就能够准确地解释 KNN 算法是如何提出这些建议的。恭喜你!

摘要

k-最近邻(KNN)算法是一种简单的监督机器学习算法,可用于解决分类和回归问题。它易于实现和理解,但有一个主要缺点,即随着所用数据的增长,速度会明显变慢。

KNN 的工作方式是找出查询和数据中所有示例之间的距离,选择最接近查询的指定数量的示例(K),然后投票选择最频繁的标签(在分类的情况下)或平均标签(在回归的情况下)。

在分类和回归的情况下,我们看到为我们的数据选择正确的 K 是通过尝试几个 K 并挑选一个最有效的来完成的。

最后,我们看了一个 KNN 算法如何用于推荐系统的例子,这是 KNN 搜索的一个应用。

KNN Be Like… ”Show me your friends, and I’ll tell you who you are.”

补遗

[1]为了简单起见,本文中实现的 KNN 电影推荐器不处理电影查询可能是推荐数据集的一部分的情况。这在生产系统中可能是不合理的,应该适当地处理。

如果你学到了新的东西或者喜欢阅读这篇文章,请鼓掌👏并分享给其他人看。也可以随意发表评论。

直觉(还有数学!)在多元梯度下降后面

原文:https://towardsdatascience.com/machine-learning-bit-by-bit-multivariate-gradient-descent-e198fdd0df85?source=collection_archive---------3-----------------------

一点一点的机器学习:关于机器学习的小文章

Photo by Dominik Scythe on Unsplash

又见面了!

机器学习一点一滴旨在分享我自己在机器学习方面的探索和实验。

在我的上一篇中,我们讨论了:

  1. 什么是梯度下降。
  2. 它如何在线性回归中有用。
  3. 它实际上是如何处理一个简单的一元函数的。

在这篇文章中,我们将扩展我们对梯度下降的理解,并将其应用于一个多元函数

在我看来,这为将梯度下降应用于更复杂的函数提供了一个平滑的过渡,并帮助您巩固梯度下降的知识,这在本系列的下一个主题—线性回归中是必不可少的。

好吧,我们开始吧。

多元梯度下降—直觉

首先,让我们谈谈直觉。对多元函数应用梯度下降实际上意味着什么?

我将试着通过想象来解释这一点:

  1. 目标多元函数
  2. 梯度下降如何使用它

请记住,梯度下降是一种算法找到一个函数的最小值。因此,我们的目标是找到一个函数的最小值,这个函数有多个变量。

在我的上一篇文章中,我们以一元二次函数为例:

这里是我们今天要看的二元(两个变量)二次函数J(θ1,θ2),:

下面的图 1 以各种方式显示了 J(θ1,θ2)——左边的 3D 图(图 1a )和中间的图 1b) 以及右边的等高线图(图 1c) 。等高线图是在 2D 平面上表示 3D 函数的一种方式。这就好像你从顶部俯视 3D 图形,并沿着 z 轴挤压它。图 1b ,是图 1a 的旋转版,应该能给你一些视觉上的直观。

对该函数应用梯度下降时,我们的目标仍然保持不变,只是现在我们有两个参数 θ1θ2 来优化:

到目前为止一切顺利…

更新规则

梯度下降的另一个特点是,它是一个迭代算法。因此,它使用更新规则在每次迭代之后系统地和有效地更新参数值。

这是单变量梯度下降的更新规则:

其中 α学习率,而 dJ(θ)/dθ 是 J(θ) 的导数——即在给定 θ 处与 J(θ) 相切的切线的斜率。

现在我们有了两个变量,我们需要为每个变量提供一个更新规则:

这些方程看起来几乎和一元函数的方程一样。这里唯一的变化是衍生术语,θ2)/∂θ1 ∂j(θ1θ2)/∂θ2 ∂j(θ1。但不要被它们吓到。符号 而不是 d 仅仅意味着它是偏导数

偏导数

在偏导数中,就像在正态导数中一样,我们仍然对在给定的 θ1θ2 处接触 J(θ1,θ2) 的切线的斜率感兴趣……但是这里的是至关重要的。

本质上,当查看切线时,我们不能同时移动 θ1θ2 。因此,我们一次只关注一个变量,同时保持其他变量不变。因此,得名

我将借助一个图表来更好地解释这一点。让我们把 θ1 看成一个变量,保持 θ2 不变,换句话说,就是 θ1 的一个偏导数。

保持θ2 不变视觉上翻译过来就是一个 θ1 - J(θ1,θ2) 平面(图 2 蓝色方块)以 *θ2 的特定值穿过图形。*图 2 红线代表 θ1 - J(θ1,θ2) 平面与 J(θ1,θ2) 图的交点,成为偏导数中感兴趣的函数。

现在,如果我们沿着红线提取蓝色平面,我们得到的是一个以θ1 为参数的古老的一元函数*,在 2D 平面,就像我们在上一篇文章中看到的一样!*

因此,当 ∂θ1 向零收缩时,我们可以如下计算更新函数中的偏导数项:

偏导数公式的证明(可选)

上面的等式利用了一个众所周知的偏导数公式,所以它省略了你如何实际计算偏导数以达到 2θ1 的证明。如果你没有兴趣证明,请跳过这一节。

现在,这是给你的——你有点像我,有一种强迫性的冲动想看看幕后发生了什么…

瞧吧!

同步更新

将相同的逻辑应用于 θ2 的部分推导,我们可以将更新规则简化如下:

最后但同样重要的是,要提到的是同时更新的概念——也就是说,当梯度下降应用于多元函数时,对每个参数的更新必须同时发生,而不是顺序发生。

我发现了一个非常直观的描述:

一个简单的类比就是走路。你通常不会先走东西向,再走南北向。你走最短的方向,即同时在两个坐标上移动。( StackExchange )

这实际上意味着,在每次迭代中,我们必须将每个新计算的参数赋给一个临时变量,直到我们计算完所有的参数。使用我们的示例,它看起来像这样:

然后,

太好了,我们有了拼图的每一部分。

动作中的梯度下降

时候到了!

我们现在可以看到多元梯度下降在起作用,使用 J(θ1,θ2) = θ1 + θ2 。我们将使用学习率 α = 0.2 和起始值 θ1 = 0.75θ2 = 0.75

图 3a 显示了梯度下降如何接近等高线图上 J(θ1,θ2) 的最小值。图 3bJ(θ1,θ2) 相对于迭代次数的曲线图,用于监控收敛。

在图图例中可以看到,从第七次迭代到第八次迭代, J(θ1,θ2) 减少 0.00056 ,小于 10^(-3) 的阈值,此时我们可以宣告收敛。

因此,我们找到了满足我们目标的参数组合 θ1 = 0.013θ2 = 0.013

总结

好的,这次我们看了梯度下降在多元函数中的应用。下一次,我们将最后看看梯度下降在线性回归中的应用。敬请期待!

请发表任何反馈、问题或主题请求。我也希望👏如果你喜欢这篇文章,那么其他人也可以找到这篇文章。

谢谢!

机器学习一点一滴系列

  1. 单变量梯度下降
  2. 多元梯度下降

资源

[## 可汗学院

免费学习数学、艺术、计算机编程、经济学、物理学、化学、生物学、医学、金融…

www.khanacademy.org](https://www.khanacademy.org/math/multivariable-calculus/multivariable-derivatives/partial-derivative-and-gradient-articles/a/introduction-to-partial-derivatives) [## Matplotlib 中的三维绘图

现在,根据这个参数化,我们必须确定嵌入条带的(x,y,z)位置。想想看,我们…

jakevdp.github.io](https://jakevdp.github.io/PythonDataScienceHandbook/04.12-three-dimensional-plotting.html) [## NumPy mgrid 与 meshgrid

meshgrid 函数对于创建坐标数组以在网格上对函数求值进行矢量化非常有用…

louistiao.me](http://louistiao.me/posts/numpy-mgrid-vs-meshgrid/) [## 如何把传说从剧情中剔除

我有一系列的 20 个情节(不是次要情节)要在一个单一的数字。我希望图例在盒子外面…

stackoverflow.com](https://stackoverflow.com/questions/4700614/how-to-put-the-legend-out-of-the-plot/43439132#43439132) [## 为什么我们要同时更新梯度下降中的所有变量

在经典的梯度下降算法中,在每一步迭代中,我们同时更新所有的变量,即

math.stackexchange.com](https://math.stackexchange.com/questions/2419301/why-should-we-update-simultaneously-all-the-variables-in-gradient-descent/2419310) [## 机器学习-黑客正午

在黑客正午阅读关于机器学习的文章。黑客如何开始他们的下午?

hackernoon.com](https://hackernoon.com/tagged/machine-learning)

直觉(还有数学!)在单变量梯度下降之后

原文:https://towardsdatascience.com/machine-learning-bit-by-bit-univariate-gradient-descent-9155731a9e30?source=collection_archive---------1-----------------------

一点一点的机器学习:关于机器学习的小文章

Photo by Dominik Scythe on Unsplash

欢迎光临!

机器学习一点一滴旨在分享我自己在机器学习方面的探索和实验。

理解并能够玩转背后的数学是理解机器学习的关键。它允许我们选择最合适的算法,并根据我们想要解决的问题对其进行量身定制。

然而,我遇到过许多教程和讲座,其中使用的方程是根本无法理解的。所有的符号看起来都很神秘,在被解释的东西和那些方程式之间似乎有一个巨大的鸿沟。我只是不能把所有的点联系起来。不幸的是,当一些知识被假定,重要的步骤被跳过时,数学往往会妨碍理解。

因此,只要有可能,我将展开方程式并避免走捷径,这样每个人都可以跟随我们如何从方程式的左边到达右边。

让我们直接进入有趣的事情吧!

什么是梯度下降?

第一个主题是梯度下降——寻找目标函数最小值的迭代算法。

它通常用于线性回归中,以找到给定数据的最佳拟合线。通过这样做,我们可以更好地了解数据集的输入和输出之间的关系,更有趣的是,我们能够在给定新输入的情况下以一定的信心预测输出。

在本文中,我们将探索:

  1. 什么是线性回归
  2. 如何使用成本函数找到最佳拟合线
  3. 为什么梯度下降在线性回归中很重要
  4. 梯度下降到底是如何工作的

线性回归

监督学习中最常用的模型之一是线性回归

线性回归模型允许你在给定自变量 x(输入)的情况下预测因变量 y(输出),假设两个变量之间存在线性关系。

这里有一些现实生活中的例子,线性回归可以用来找出两个变量之间的关系:

身高对体重的影响

教育水平对财富的影响

降雨量对水果产量的影响

血液酒精含量对身体协调性的影响

用更实际的话来说,线性回归的目标是找到一条线(称为假设),即最能代表(符合)数据点

但真正的问题是——我们如何知道这种契合有多“好”?

成本函数

事实上,我们用一个成本函数来衡量一个假设的适合度。

本质上,成本函数是一个均方误差(MSE) —真实值(标签)和从假设中得出的估计值(预测)之间偏差的集合度量。成本函数的越小,线和数据点之间的偏差越小,因此的假设越好。

因此,我们的目标是找到一个最小化成本函数的假设,因为它给了我们一条最佳拟合线。

现在,还记得梯度下降的描述吗?

梯度下降是一种寻找函数最小值的迭代算法。

没错,这就是梯度下降在机器学习中发挥作用的地方。我们用它来最小化线性回归中的成本函数,以拟合数据集的直线。

­­­­­­­­

梯度下降算法

话虽如此,梯度下降法并不是专门用来解决线性回归问题的。它是一个通用算法,可以应用于任何一个可微函数求其最小值。

为了更好的理解直觉,我们从最简单的例子开始:单变量梯度下降。也就是说,梯度下降适用于单变量函数。

单变量梯度下降

让我们定义θ的一元函数 J, J(θ) ,如下:

当相对于 θ 作图时,函数 J(θ) 看起来像图 1

我们希望找到一个使 J(θ) 最小的 θ 值:

为了实现这一点,我们需要尝试不同的 θ 值,直到 J(θ) 达到最小值。通常情况下,我们从 θ = 0 开始,但由于在这种情况下,这产生了 J(θ) 的最小值,所以假设我们从 θ = 6 开始。

在详细研究该算法之前,这里有两个关键问题:

  1. 我们如何确定 J(θ) 何时达到最小值?
  2. 如果 J(θ) 不在最小值,我们怎么知道接下来要尝试的 θ 的值是多少?

这些问题可以通过对 J(θ) 进行求导来回答——换句话说,计算出在给定 θ 处与 J(θ) 相交的切线的斜率。如果斜率为正,这意味着 θ 的值需要在下一次迭代中减小,以接近最小值,而如果斜率为负,则 θ 需要增大。

考虑图 2 。由于在 θ = 6 处切线的斜率是正的 (12) ,我们知道 θ 需要减小以接近使 J(θ) (θ = 0) 最小的值。另一方面,一条切线在 θ = -2 处的斜率为负 (-4) ,所以我们知道在下一次迭代中需要增加 θ 的值。

同样重要的是,当我们达到最小值 J(θ) 时,斜率变为 0 。这就是我们如何知道梯度下降何时收敛,即 J(θ) 的值接近足够接近的最小值。在实践中,如果在一次迭代中 J(θ)的下降小于 10^(-3(= 0.001),我们宣布收敛*。*

更新规则

现在,我们需要一种系统有效的方法来更新 θ ,同时我们寻找一个使 J(θ)最小的 θ 值。

在梯度下降中,它是通过在每次迭代后自动应用更新规则来完成的,因此 θ 越来越接近我们的目标值。

单变量函数的更新规则如下:

这里, α 称为学习率dJ(θ)/dθJ(θ)导数——即切线的斜率。

学习速率决定 θ 移动的快慢。选择一个好的学习速率是至关重要的,如果它太大,我们可能会跳过它而错过最佳值,甚至可能不会收敛。另一方面,如果它太小,算法收敛将需要太多的迭代。稍后我会用一些视觉辅助来解释这一点。

对于 J(θ) = θ ,随着 向零收缩, J(θ)导数计算如下:

由此, J(θ) = θ 的更新规则可以简化为θ:=(1–2α)θ

梯度下降在行动

让我们最后看看梯度下降的作用。

我们将对 J(θ) = θ 进行梯度下降,其中 α = 0.3 ,初始值为 θ = 6 ( 图 3 )。

第一次迭代后, θ 更新为θ:=(1–2α)θ= 0.4 * 6 = 2.4 第二次迭代后:θ:=(1–2α)θ= 0.4 * 2.4 = 0.96
第三次迭代后:θ:=(1–2α)θ= 0.4 * 0.96 = 0

诸如此类…

Fig.3a — Steps of gradient descent as it approaches minimum of J(θ). Fig.3b — A plot of J(θ) against the number of iteration, useful to visually monitor convergence.

最后,从第六次迭代到第七次迭代, J(θ) 减少 0.0005 ,小于 10^(-3) 的阈值,此时我们可以宣告收敛。

调整学习速度

正如我所承诺的,这里有一些学习率过大或过小的例子,这将帮助你直观地理解为什么选择正确的学习率是至关重要的。

图 4 是学习率过大时。 θ 的值来回振荡跳过最小值,而不是逐渐接近最小值。即使在第十次迭代之后, θ 仍然离零很远,并且我们预计 θ 会经历更多不必要的曲折,以最终接近 J(θ) 的最小值。事实上,在这种情况下,它需要 23 次迭代才能达到收敛。

相反,图 5 显示了过小的学习率如何显著减缓收敛。在这个极端的例子中,即使经过 100 次迭代,仍然远离收敛。

希望这证明了监控收敛和相应调整学习速率的重要性。

总结

好了,我们讨论了梯度下降的基本应用,使用一元函数作为目标函数。下次讲它在多元函数和线性回归中的应用。

请发表任何反馈、问题或主题请求。我也希望👏如果你喜欢这篇文章,那么其他人也可以找到这篇文章。

谢谢!

机器学习一点一滴系列

  1. 单变量梯度下降
  2. 多元梯度下降

资源

[## 梯度下降和线性回归导论

梯度下降算法是那些“最成功”的算法之一,可以为解决问题提供一个新的视角…

spin.atomicobject.com](https://spin.atomicobject.com/2014/06/24/gradient-descent-linear-regression/) [## 梯度下降求导克里斯麦考密克

对于线性回归,我们有一个线性假设函数,h(x)= ѳ0+ѳ1*x.我们要找出ѳ0 和ѳ1…的值

mccormickml.com](http://mccormickml.com/2014/03/04/gradient-descent-derivation/) [## 机器学习的线性回归-机器学习掌握

线性回归也许是统计学和机器中最著名和最容易理解的算法之一

machinelearningmastery.com](https://machinelearningmastery.com/linear-regression-for-machine-learning/) [## 如何在介质上写数学

技术作者简明指南

medium.com](https://medium.com/@tylerneylon/how-to-write-mathematics-on-medium-f89aa45c42a0)

修正

【2018 年 12 月 9 日—*“梯度下降在行动”*一节学习率出现错别字。最初写为 α = 3 ,而正确的值是 α = 0.3 。感谢阿尼班·杜塔指出这一点。

使用 XGBoost 和 clj-boost 在 Clojure 中进行机器学习

原文:https://towardsdatascience.com/machine-learning-clojure-xgboost-clj-boost-e0d1339df1e1?source=collection_archive---------13-----------------------

机器学习+ REPL = ❤

Clojure 这是一个 LISP 。所以作为一个 LISP,它有很多括号。既然我们已经把那件事一吐为快,我们可以继续谈论更严肃的事情了。

Obligatory xkcd comic

为什么是 Clojure?

你可能从来没有听说过 Clojure ,更不用说数据科学和机器学习了。那么,为什么您会对使用它来做这些事情感兴趣呢?我来告诉你为什么:要让要紧的事(数据)一流

在 Clojure 中我们不处理类、对象等等,一切都只是数据。而那个数据是不可变的。这意味着,如果您搞砸了您的转换,数据将是好的,您不必从头再来。

前一个只是我想到的原因之一,另一个可能是 JVM 。是的,我们都在某种程度上讨厌它,但不要搞错:它自 1991 年开发以来,一直是生产级。这就是为什么全世界的企业仍然在 JVM 上运行和开发软件。考虑到这一点,Clojure 甚至可以被最保守的公司所接受,因为从根本上说,它是他们已经知道的东西。

我想说的第二点是 REPL。这不像通常的语言外壳(例如 Python REPL ),通常非常基础和烦人,但是它有超能力!去现场看看该服务在生产中发生了什么会很好吗?搞定!你想要一个既能用于生产又能用于实验的绘图服务吗?搞定!您是否碰巧有嵌套的数据结构,并且可视化地探索它们以更好地理解它们会很好?搞定!

这意味着你并不真的需要像 jupyter 笔记本这样的东西,尽管如果你在这样的环境中感觉更舒服,有一些选项可以无缝地工作: clojupyter 是用于 Jupyter 笔记本的 Clojure 内核,而大猩猩 REPL 是本地 Clojure 笔记本解决方案。

数据读取

如果你从未看过 Clojure 代码,或者如果你刚刚开始,我的建议是看一看在 Y 分钟内学会 clo jure以便能够跟上这一点,那么当我开始学习时,我最喜欢的来源之一是clo jure for the Brave and True。无论如何,我会仔细解释代码中的每一步,这样每个人都可以很容易地理解。

这只是一个介绍,所以我们将使用臭名昭著的虹膜数据集。如果你还没有 Leiningen 获取并安装它,它真的很容易使用,并且是 Clojure 事实上的构建工具。现在,您可以通过启动以下命令从命令行创建一个新的项目框架:

lein new clj-boost-demo
cd clj-boost-demo

您应该具有如下所示的目录结构:

.
├── CHANGELOG.md
├── doc
│   └── intro.md
├── LICENSE
├── project.clj
├── README.md
├── resources
├── src
│   └── clj_boost_demo
│       └── core.clj
└── test
└── clj_boost_demo
└── core_test.clj

我们最关心的文件是project.clj,它是 Leiningen 正确准备和构建项目的基础,src是我们放置应用程序或库的代码的地方,resources是我们放置 Iris csv 文件的地方,您可以从这里的获得。现在我们可以定义project.clj文件,这是 Clojure 的另一个“明智”之处:你必须显式声明库和版本,这总是一件好事。

(defproject clj-boost-demo "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.9.0"]
                 [org.clojure/data.csv "0.1.4"]
                 [clj-boost "0.0.3"]])

如果我们保存project.clj并在 shell 中启动lein run,Leiningen 将获得所有需要的依赖项并启动一个 REPL。我们可以通过打开和修改src/clj-boost-demo/core.clj文件进入数据加载和传输。我们会在那里找到一些占位符代码,我们可以去掉它,开始写我们的代码。

在 Clojure 中,我们使用名称空间,通常一个文件包含一个定义导入的名称空间:

(ns clj-boost-demo.core
  (:require [clj-boost.core :as boost]
            [clojure.java.io :as io]
            [clojure.data.csv :as csv]))(def iris-path "resources/iris.csv")

定义一个新的名称空间,从名称空间定义导入库是一个好的实践,就像我们在这里做的一样。:require这是一个关键字,它本身就是 Clojure 中的一个类型,我们稍后会看到它们为什么重要,[clj-boost.core :as boost]意味着我们想要使用clj-boost库中的core名称空间,但是我们想要用名称boost引用它下面的所有名称。如果你懂 Python,这和做import library as lbr是一样的。

使用def,我们在当前名称空间中全局创建新的变量。在这种情况下,我们指向一个表示数据集所在路径的字符串。通常在 Clojure 中我们不会定义很多全局名,除了函数名。事实上,iris-path将是我们在本演示中使用的唯一全球名称!

为了读取 Iris csv,我们使用以下代码:

(defn generate-iris
  [iris-path]
  (with-open [reader (io/reader iris-path)]
    (into []
          (comp (drop 1) (map #(split-at 4 %)))
          (csv/read-csv reader))))

这段代码定义了(defn)一个名为generate-iris的函数,它将 Iris csv 的路径作为参数。然后我们在给定的路径下打开一个到文件的连接,当我们完成时这个连接将被关闭(with-open)。当你在一个函数调用之后看到一个向量,它带有一个符号,后面跟着一些代码——[reader (io/reader iris-path)]——这就是局部绑定。

本地绑定有助于避免混淆全局名称空间,并将代码执行分成微小的部分。在这种情况下,我们使用一个 Java 阅读器,确切地说是一个BufferedReader,来打开和读取文件。如您所见,我们通过执行io/reader来使用导入的clojure.java.io名称空间,而name/是访问驻留在导入的名称空间中的名称的语法。

下面的代码可能看起来有点深奥,但这只是习惯问题。让我们从 REPL 开始分解所有的步骤。

(with-open [reader (io/reader iris-path)] 
  (csv/read-csv reader)) 
;IOException Stream closed java.io.BufferedReader.ensureOpen

上面的代码抛出一个错误,那是因为csv/read-csv。默认懒惰是 Clojure 的另一个特性:大部分 Clojure 函数不会返回任何东西,直到你需要那些值。如果你考虑一下,这很好:如果我们有一个非常大的文件,我们不必将它全部加载到内存中来处理它,但是我们可以逐行读取和处理它,同时将结果写入另一个文件。

为了使函数变得更有吸引力,我们可以使用doall:

(with-open [reader (io/reader iris-path)] 
  (doall (csv/read-csv reader))) 
;(["sepal_length" "sepal_width" "petal_length" "petal_width" "species"] 
; ["5.1" "3.5" "1.4" "0.2" "setosa"] 
; ["4.9" "3" "1.4" "0.2" "setosa"]...)

结果是包含字符串的向量序列。序列是 Clojure 中最重要的数据结构之一:它们是懒惰的、不可变的,可以由任何其他 Clojure 数据结构产生。更多关于他们的信息,请查看官方 Clojure 文件。向量非常类似于 Python 列表,区别在于它们是持久的。

为了更好地理解不变性持久性让我们尝试一个小实验:

(def a [1 2 3]) 
(println a) 
;[1 2 3] (conj a 4) 
;[1 2 3 4] (println a) 
;[1 2 3]

正如你所看到的,我们创建了一个向量a,然后conj(向向量追加元素)4 到a,结果是一个全新的数据结构,事实上a仍然有初始值。

数据处理

在这种情况下,我们不再关心标题,因为"species"列是我们想要预测的类,也是最后一个,所以我们可以立即开始处理原始数据。为了简化这个过程,我们定义了一个在 REPL 中使用的demo-reader函数,并开始处理结果数据:

(defn demo-reader [] 
  (with-open [reader (io/reader iris-path)] 
    (doall (csv/read-csv reader))))

然后,我们将使用线程宏来逐步试验和应用转换:

(->> (demo-reader) (take 3)) 
;(["sepal_length" "sepal_width" "petal_length" "petal_width" "species"] 
; ["5.1" "3.5" "1.4" "0.2" "setosa"] 
; ["4.9" "3" "1.4" "0.2" "setosa"])

让我们将一个值作为后续函数的最后一个参数:你肯定还记得在学校时他们教过你,要求解 f(g(x)),你应该从求解 g(x)= x’开始,然后 f(x’)= x”。线程宏它只是语法糖,使代码更可读。

这里有一个简单的例子:

(inc 1) 
;2 (dec (inc 1)) 
;1 (-> 1 inc dec) 
;1

我们inc1加 1,然后(dec (inc 1))表示inc1,然后dec将结果-2-加 1,得到 1。基本上,我们从右到左阅读来理解函数的应用顺序。使用(-> 1 inc dec)我们可以从左至右阅读操作。有关线程宏的更多信息,请查看官方 Clojure 文档

回到(->> (demo-reader) (take 3))正如你看到的结果,我们只从 csv 中获得前 3 个向量。take完全按照您的想法去做:它懒洋洋地从给定的集合中获取n值。这在实验时非常有用,否则我们将不得不处理整个序列。

要从序列中删除标题,我们可以从结果中drop第一行:

(->> (demo-reader) (take 3) (drop 1)) 
;(["5.1" "3.5" "1.4" "0.2" "setosa"] 
; ["4.9" "3" "1.4" "0.2" "setosa"])

现在,因为我们想把 X 值从 Y 值(我们想预测的类)中分离出来,所以最好一次完成。如果您来自 Python 或其他类似 C 语言的语言,您可能会尝试使用循环来做这件事,但是在 Clojure 中,我们做的事情不同。

使用map,我们可以对集合中的所有值应用一个函数:

(map inc [1 2 3]) 
;(2 3 4)

在这种情况下,我们想要分割值,猜猜看,有一个split-at函数在等着我们!

(split-at 2 [1 2 3])
*;[(1 2) (3)]*

这正是我们所需要的,所以我们将定义一个匿名函数并在我们的向量上使用它:

(->> (demo-reader) 
     (take 3) 
     (drop 1) 
     (map #(split-at 4 %))) 
;([("5.1" "3.5" "1.4" "0.2") ("setosa")] 
; [("4.9" "3" "1.4" "0.2") ("setosa")])

为了定义命名函数,我们使用defn,它是一个,让我们避免每次都输入(def my-func (fn [arg] "do something")),所以通过简单的(fn [arg] "I have no name"),我们得到一个匿名函数。

#(split-at 4 %)是另一个和(fn [x] (split-at 4 x))解析一样的简写,所以只是省打字的一种方式。

现在让我们通过使用传感器将所有东西放在一起。如同带有传感器的线程宏一样,我们将函数组合在一起,但是传感器返回一个只传递一次数据的函数。如果它们一开始看起来有点晦涩,不要担心,我也花了一些时间来理解这个概念,我建议你仔细阅读这个写得非常好的关于传感器的系列文章。

(def xf (comp (drop 1) (map #(split-at 4 %)))) (into [] xf [[1 2 3 4 5] [1 2 3 4 5]]) 
;[[(1 2 3 4) (5)]]

使用comp我们将函数组合在一起,只返回一个函数,而使用into我们循环遍历一个集合,并将结果放入作为第一个参数给出的集合中。我喜欢这样来思考这个过程:这就像我们从一个集合中把个值拉到另一个集合中,但是当我们这么做的时候,我们对所有的值都应用了一个函数xf

结果是我们开始的generate-iris函数:

(defn generate-iris
  [iris-path]
  (with-open [reader (io/reader iris-path)]
    (into []
          (comp (drop 1) (map #(split-at 4 %)))
          (csv/read-csv reader))))

现在我们想从这个([("5.1" "3.5" "1.4" "0.2") ("setosa")] [("4.9" "3" "1.4" "0.2") ("setosa")])转到我们能以更简单的方式处理的东西:([5.1 3.5 1.4 0.2 0] [4.9 3.0 1.4 0.2 0])。基本上,我们将字符串解析成数字,并将类( setosavirginicaversicolor )转换成整数。

让我们从抽象出所需的转换开始:

(defn parse-float
  [s]
  (Float/parseFloat s))(->> (generate-iris iris-path) 
     (take 2) 
     (map first)) ; first returns the first element of a collection ;(("5.1" "3.5" "1.4" "0.2") ("4.9" "3" "1.4" "0.2")) (->> (generate-iris iris-path) 
     (take 2) 
     (map first) 
     (map #(map parse-float %))) 
; ((5.1 3.5 1.4 0.2) (4.9 3.0 1.4 0.2)) (->> (generate-iris iris-path) 
     (take 2) 
     (map first) 
     (map #(map parse-float %)) 
     (map vec)) 
; ([5.1 3.5 1.4 0.2] [4.9 3.0 1.4 0.2])

通过这些变换,我们可以为我们的模型构建 X。让我们建造一个名为的变压器:

(def transform-x
  (comp
   (map first)
   (map #(map parse-float %))
   (map vec)))

取而代之的是 Y:

(->> (generate-iris iris-path) 
     (take 2) 
     (map last)) ; last takes the last item from a collection 
;(("setosa") ("setosa")) (let [l (first '("setosa"))] 
  (case l "setosa" 0 "versicolor" 1 "virginica" 2)) 
;0

停一下,用let我们可以创建本地绑定,比如给只存在于本地空间而非全局的数据或函数命名。case这是避免嵌套(if condition "this" "else this")的一种方式。我们说的是:如果l="setosa"那么返回0,如果是="versicolor"返回1,而如果是="virginica"返回 2。

这样,如果给定值与三种情况都不匹配,我们就会得到一个错误。这也有助于检查数据质量。

(->> (generate-iris iris-path) 
     (take 2) 
     (map last) 
     (map (fn [label] 
       (let [l (first label)] 
         (case l "setosa" 0 "versicolor" 1 "virginica" 2))))) 
;(0 0)(def transform-y
  (comp
   (map last)
   (map (fn [label]
          (let [l (first label)]
            (case l
              "setosa"     0
              "versicolor" 1
              "virginica"  2))))))(defn munge-data
  [iris-data]
  (let [x (into [] transform-x iris-data)
        y (into [] transform-y iris-data)]
    (map conj x y)))

列车-测试分离

当进行机器学习时,要做的最重要的事情之一是在一个训练和一个测试集合上分割数据。一个好的分割需要随机采样,所以我们将从头实现一个非常简单的采样器。

(defn train-test-split
  [n dataset]
  (let [shuffled (shuffle dataset)]
    (split-at n shuffled)))

train-test-split在训练集中获取一个集合和一些你想要的实例。shuffle函数只是简单地打乱了集合,所以我们每次都会得到一个随机的结果,并且可以很容易地避免重复。

如果您有一个相当大的数据集,这种解决方案并不是最佳的,在这种情况下,您可能想要看一下采样,这是一个非常好的库,可以处理关于采样的所有事情。

(defn train-set
  [split-set]
  (let [set (first split-set)]
    {:x (mapv drop-last set)
     :y (mapv last set)}))

(defn test-set
  [split-set]
  (let [set (last split-set)]
    {:x (mapv drop-last set)
     :y (mapv last set)}))

利用上述函数,我们生成训练集和测试集,作为带有 2 个 : :x:y的 2 个映射。Clojure 中的地图是一等公民,具有非常好的属性:

; Create a map with mixed types 
{:a 1 "key" "string" 2 1/3}

; Maps are functions 
({:a 1} :a) 
;1 ; Keywords are functions as well 
(:a {:a 1}) 
;1 ; Access other kinds of keys by using the map... 
({1 2} 1) 
;2 ; ...or the get function 
(get {"key" 1} "key") 
;1

地图远不止这些,如果你不知道它们,你应该看看这里的。

训练和预测

XGBoost 是一个集合模型,它使用梯度增强来最小化损失函数。如果你不能理解这些单词,我的建议是查看这个非常好的算法解释(有图片和公式)。

clj-boost 给你一个 Clojure 接口到底层 Java 实现的库,这样我们可以避免 Java 互操作,得到同样的结果。为了训练一个模型,我们必须从数据中创建一个 DMatrix ,我们希望将这些数据提供给算法进行学习。这不是我的选择,我可以将数据转换隐藏在 API 实现的后面,但是有一个问题:一旦你将数据放入一个 DMatrix 中,你就不能再触摸或查看它们了。

(defn train-model
  [train-set]
  (let [data   (boost/dmatrix train-set)
        params {:params         {:eta       0.00001
                                 :objective "multi:softmax"
                                 :num_class 3}
                :rounds         2
                :watches        {:train data}
                :early-stopping 10}]
    (boost/fit data params)))

dmatrix我们序列化我们的训练集,有各种方法生成一个 DMatrix ,所以我建议你看一下文档自述文件:params映射的作用就像是 XGBoost 的配置,这是我们可以用它做什么的一个非常小的例子,要知道所有可能的选项总是参考官方文档

这里我们说 XGBoost 应该以 0.00001 的学习率:eta进行训练,因为我们正在对 3 个类进行分类—setosa、versicolor 和*virginica—*我们将:objective设置为 multi:softmax ,并告诉 XGBoost 我们与:num_class有多少个类。

XGBoost 将进行 2 次:rounds的增强,将通过将训练集传递给:watches图来评估其准确性(这不是一个好的实践,但这只是一个例子),如果准确性将开始连续 10 次迭代增加,它将由于:early-stopping参数而停止训练。

对定义的数据参数调用fit从头训练一个 XGBoost 模型,并返回一个 Booster 实例。我们可以使用 Booster 进行预测,我们可以将它持久化到磁盘上,或者将其作为基线提供给另一个 XGBoost 模型。

(defn predict-model
  [model test-set]
  (boost/predict model (boost/dmatrix test-set)))

(defn accuracy
  [predicted real]
  (let [right (map #(compare %1 %2) predicted real)]
    (/ (count (filter zero? right))
       (count real))))

虽然我们通过训练装置本身来检查训练性能,但我们将在之前准备的测试装置上检查准确性。predict需要一个模型和数据作为我们想要预测的 DMatrix 并返回一个预测向量。

让我们把一切都打包成一个-main函数,这样我们就可以从 REPL 和命令行运行整个分析。

(defn -main
  []
  (let [split-set    (->> iris-path
                          generate-iris
                          munge-data
                          (train-test-split 120))
        [train test] (map #(% split-set) [train-set test-set])
        model     (train-model train)
        result    (predict-model model test)]
    (println "Prediction:" (mapv int result))
    (println "Real:      " (:y test))
    (println "Accuracy:  " (accuracy result (:y test)))))

我们生成分裂集,然后我们使用一个小技巧:我们将多个函数映射到一个集合上,而不是相反。然后我们训练 XGBoost 模型并得到预测。

(-main) 
Prediction: [1 1 2 0 2 2 2 2 2 1 1 0 1 2 0 1 1 1 0 1 0 2 1 1 0 0 1 2 1 1] 
Real: [1 1 2 0 2 2 2 2 2 1 1 0 1 2 0 1 1 1 0 1 0 2 1 1 0 0 1 2 2 1]
Accuracy: 29/30

灵活性与生产

您可能没有注意到,尽管我们编写的代码足够简单灵活,可以用于分析和实验,但这也是生产就绪代码。如果您在命令行中从项目的根目录执行lein run,您将获得与从 REPL 执行(-main)相同的结果。因此,向程序添加功能是微不足道的,例如,当程序发生变化时,您可能希望向它输入新数据,并且您希望重新训练您的模型。

如果我们现在在 Jupyter 笔记本上用 Python 做类似的事情,我们可能会到处都是任务,命令式代码必须从头开始重写,以使它在某种程度上为生产做好准备,我不会谈论这样一个事实,即如果数据管理性能可能是一个问题,通过组成转换器,我们几乎可以获得免费的并行化。

现在你可以用 clj-boost 玩一会儿了,不要忘了还有文档可用,这仍然是一项正在进行的工作,所以如果有问题、想法、改进方法或者只是你正在使用它并且你对它感到满意,请让我知道。

你可以在 clj-boost repo 上找到完整的脚本,不要忘记 clj-boost 是自由/开源软件,任何形式的贡献都是可以接受的!

这篇文章最初发表在 rDisorder 上(请特别查看更好的代码片段)

机器学习:外行使用 Spark 的决策树

原文:https://towardsdatascience.com/machine-learning-decision-tree-using-spark-for-layman-8eca054c8843?source=collection_archive---------2-----------------------

目标

在本文中,我们将回顾决策树的定义、直觉和算法。

然后,我们将编写自己的代码,而不使用任何 ML 库(如 tensorflow 等)。这将为实施决策树提供很好的理解和实践经验。

什么是决策树

study.com 的定义

决策树是基于特定条件的决策的可能解决方案的图形表示。它被称为决策树,因为它从单个框(或根)开始,然后分支成许多解决方案,就像树一样。

直觉

让我们考虑一些访问 ecom 网站的用户的数据。让我们假设我们知道访问网站的用户的概况,如他们的年龄、工作、信用额度等。

该表包含一些销售记录,数据的模式是

  • 第一列是购买者来自的城市。
  • 第二列“工作”表示采购员正在做的工作。
  • 第三列是该人的信用额度
  • 第四栏是购买者的年龄

最后一个最重要的列表示用户最终是否购买了任何商品。“是”表示用户购买了商品,“否”表示用户没有购买。

我们想要做的是,基于这些数据,我们想要建立一个决策树来进一步预测任何新用户是否会在网站上购买任何商品。

怎么

让我们看看数据,看看四个因素(城市、职业、cc_limit 和年龄)中的哪一个可能会影响用户购买或不购买的决定。

考虑到“年龄”,该属性对于每一行都有不同值。即使对于唯一的输出——“是”和“否”,该属性的值也是随机的。所以我们可以说,年龄肯定不是用户购买产品的决定因素。

但是我们如何从数学上证明年龄不是一个因素,至少不是决定结果的主要因素?让我们看看熵。

熵是随机性(或杂质)的量度。在上面的例子中,年龄是最随机的属性。

但是我们如何测量熵呢?测量熵的公式是。这也被称为香农熵

  • n 是值的数量,并且
  • p 是类中的元素数除以总元素数。

让我们深入了解细节。考虑我们上面的样本数据列有结果值

该属性(即 y)的“是”(“是”类)的数量= 4

‘否’的数目(‘否’类)都= 3

元素总数= 7

  • p(0) is =是类中的元素数/元素总数= 4/7
  • p(1)is = no 类中的元素数/元素总数= 3/7

熵=(-4/7 * log2(4/7)-3/7 * log2(3/7))=(-0.57 *-0.81–0.43 *-1.22)=(0.4617+0.5246)= 0.9863

0.9863 是数据的熵。

属性的可变性

现在我们知道了基于结果的数据集的熵,我们如何从数学上找出对决策有贡献的最有影响力的顶级属性。这将是我们试图构建的决策树的根。

如上所述,“年龄”不能成为任何顾客做出购买决定的因素,因为我们看到人们的年龄几乎随着每个记录而变化。年龄的太多变化使其成为决策中最不重要的因素,因此反过来,变化最小的属性将是最有影响的属性,或者更确切地说是随着结果而变化的属性?提示,是后者。让我看看。

我们已经有了数据集的熵(杂质),对于上面的例子是 0.9863。所以,我们做下面的工作来获得一个属性的信息增益

  • 求每个属性中每个类的熵。在我们的示例中,Eg city 有 2 个班,即班加罗尔和钦奈
  • 按比例分配每个类的熵 wrt 数据集类。

对于城市属性

(班加罗尔市的记录总数/记录总数)*班加罗尔熵

(钦奈市的总记录数/总记录数)*钦奈熵

对每个类的上述值求和,并从数据集的熵中减去它

让我们找出班加罗尔城市熵。查一下班加罗尔的记录。其中 2 个有“是”输出,1 个有“否”输出。所以,班加罗尔熵就是

班加罗尔熵=-2/3log2(⅔)—1/3log2(⅓)= 0.39+0.53 = 0.92

同样,Chennai 熵= -2/2log2(2/2) — 2/2log2(2/2) = 0(其完全一致的性质,相等数量的它属于‘是’和‘否’的结果)

因此,城市的信息增益将如上所述= 0.9863 — { (3/7)*0.92 + 0 } = 0.592

其他属性

“工作”的信息增益— 0.9863 — { 4/7 *就业熵+ 2/7 *失业熵+ }

类似地,我们也得到“信用额度”的信息增益。

特例

让我们添加另一个名为“ownshouse”的属性,它的值随着输出的变化而变化。所以数据集现在看起来像

“拥有房屋”表示客户是否拥有房屋。它与结果属性“y”具有相同的值。让我们调整这个属性的信息增益。

它有两类'是'和'否'。

“是”的熵= — 4/4log2(4/4) — 0(没有属于“否”类的项目)= 0

“否”的熵=—0–3/3 log2(3/3)= 0

“ownshouse”属性的信息增益= 0.9863–0 = 9.9863

刚刚发生了什么?由于该属性的“ownshouse”值的变化与结果完全相同,因此其信息增益与数据集的熵相同。

计算了属性的信息增益,接下来呢?

一旦我们有了属性的信息增益

  • 我们得到具有最大信息增益的属性
  • 将该属性作为树的头
  • 获取该属性的值,并创建该标题的这些分支,例如,假设“城市”具有最大信息增益(实际上,在我们的示例中它没有最大增益,但为了讨论起见,假设它)。

总部设在城市,分支机构设在班加罗尔和钦奈

  • 在下一次迭代中-从属性列表中移除城市。
  • 对于待定属性,获取属于 Bangalore 下分支的每个属性的 city = Bangalore 的记录。
  • 计算 Bangalore city 下属性的信息增益,得到增益最大的属性,成为 Bangalore 下的节点。
  • 继续这样做,直到我们用尽所有属性或者熵为零。

我还有另一个例子,在最后有代码,它为其他数据集实现了这个逻辑,所以你可以看一下它是如何实现的。

我们什么时候停止构建决策树

如上所述,我们在下列情况下停止

  • 我们已经经历了所有的属性或
  • 找到熵为零的属性。

实际上在我们的特例中,我们在第一次迭代中遇到了熵为零的属性。该属性是“ownshouse”。

带代码的完整示例

我们从这里开始动手练习。如果您对编码不感兴趣,那么本文将在这里为您总结。

使用的工具——pySpark、networkx python lib 来可视化决策树

代码也在 github 上,网址是https://github . com/skhurana 333/ml/blob/master/decision _ tree/decision _ tree _ model _ complex . py

基本上,这个数据集列出了影响网球比赛是否可以在室外进行的条件。描述了前景、温度、湿度和风的值,以及在这些条件下是否玩游戏的结果。我们现在将构建决策树。

outlook;temp;humidity;wind;y
Sunny;Hot;High;Weak;no
Sunny;Hot;High;Strong;no
Overcast;Hot;High;Weak;yes
Rain;Mild;High;Weak;yes
Rain;Cool;Normal;Weak;yes
Rain;Cool;Normal;Strong;no
Overcast;Cool;Normal;Strong;yes
Sunny;Mild;High;Weak;no
Sunny;Cool;Normal;Weak;yes
Rain;Mild;Normal;Weak;yes
Sunny;Mild;Normal;Strong;yes
Overcast;Mild;High;Strong;yes
Overcast;Hot;Normal;Weak;yes
Rain;Mild;High;Strong;no

假设具有上述数据的文件保存在位置=/home/me/ml/practice/decision _ tree/datasets/simple _ dataset

我们将讨论流程和算法

让我们加载数据集。

data = sqlContext.read.format('com.databricks.spark.csv').option('header', 'true')\
 .option('delimiter', ';') \ .load("/home/me/ml/practice/decision_tree/datasets/simple_dataset")
  • 因为它包含 header,所以我们在选项中将 header 设置为 true。
  • 分隔符是;
  • 它是 csv 格式的。

我们将把它注册为表,因为我们需要用不同的 where 条件查询这个数据集。

data.registerTempTable('data')

计算数据集的熵

获取结果为“是”和“否”的行数。下面是 pyspark 查询

played = sqlContext.sql("select * from data WHERE y like '%y%' ").count()notplayed = sqlContext.sql("select * from data WHERE y like '%n%' ").count()

因为我们需要获得每个属性的信息增益,并找到具有最大信息增益的属性,所以我们将对所有属性的信息增益计算应用相同的逻辑。创建“流程 _ 数据集”函数。

def process_dataset(excludedAttrs, data, played, notplayed, where_condition):
  • excludedAtttts 将包含已经处理过的属性列表,因此我们不需要再次处理。
  • 数据是该文件的 spark 数据帧
  • 比赛时间——计算比赛时间
  • 未播放—当比赛未播放时计数
  • Where_condition —用于选择数据的条件,在处理属性时,我们会不断更改此条件

让我们从主函数中调用这个函数,

def main(): data = sqlContext.read.format('com.databricks.spark.csv').option('header', 'true')\ .option('delimiter', ';').load("/home/me/ml/practice/decision_tree/datasets/simple_dataset") data.registerTempTable('data') played = sqlContext.sql("select * from data WHERE y like  '%y%' ").count() notplayed = sqlContext.sql("select * from data WHERE y like  '%n%' ").count() process_dataset([], data, played, notplayed, '')

2)加工数据

Process_dataset 将首先计算数据集的熵,然后获得每个属性的信息增益。

我们将声明全局级变量来存储属性的信息增益。并且还会创建有向图来可视化决策树。

attr_name_info_gain = {}G = nx.DiGraph()

让我们也声明数据集的模式。我创建了两个变量来存储模式和类型。如果愿意,您可以创建一个并相应地修改后续代码。

attrs = ["outlook","temp","humidity","wind"]attrs_type = {"outlook":"string","temp":"string","humidity":"string","wind":"string"}

流程 _ 数据集函数

def process_dataset(excludedAttrs, data, played, notplayed, where_condition): total_elements = played + notplayed subs_info = {"played" : played, "notplayed" : notplayed} entropy = calculate_entropy(total_elements, subs_info) print "entropy is " + str(entropy) global attr_name_info_gain attr_name_info_gain = dict() for attr in attrs: if attr not in excludedAttrs: get_attr_info_gain_data_prep(attr, data, entropy, total_elements, where_condition)

它调用 calculate_entropy 函数,然后为每个属性调用 get_attr_info_gain 函数。

3)计算 _ 熵函数

def calculate_entropy(total_elements, elements_in_each_class): *# for target set S having 2 class 0 and 1, the entropy is -p0logp0 -p1logp1* *# here the log is of base 2* *# elements_in_each_class is a dictionary where the key is class label and the* *# value is number of elements in that class* keysInMap = list(elements_in_each_class.keys()) entropy = 0.0 for aKey in keysInMap: number_of_elements_in_class = elements_in_each_class.get(aKey) if number_of_elements_in_class == 0: continue ratio = number_of_elements_in_class/total_elements entropy = entropy - ratio * np.log2(ratio) return entropy

4)属性信息增益数据准备功能

def get_attr_info_gain_data_prep(attr_name, data, entropy, total_elements, where_condition): if not where_condition:
       attr_grp_y = data.where(col('y') == 'yes').groupBy(attr_name).agg({"y": 'count'})\
           .withColumnRenamed('count(y)','played_count')
   else:
       attr_grp_y = data.where(" y like '%yes%'  " + where_condition).groupBy(attr_name).agg({"y": 'count'})\
           .withColumnRenamed('count(y)','played_count') if not where_condition:
       attr_grp_n = data.where(col('y') == 'no').groupBy(attr_name).agg({"y": 'count'})\
           .withColumnRenamed(attr_name,'n_' + attr_name)\
           .withColumnRenamed('count(y)','not_played_count')
   else:
       attr_grp_n = data.where(" y like '%no%'  " + where_condition).groupBy(attr_name).agg({"y": 'count'})\
           .withColumnRenamed(attr_name,'n_' + attr_name)\
           .withColumnRenamed('count(y)','not_played_count') joined_df = attr_grp_y.join(attr_grp_n, on = [col(attr_grp_y.columns[0]) == col(attr_grp_n.columns[0])], how='outer' )\
       .withColumn("total", col(attr_grp_y.columns[0]) + col(attr_grp_n.columns[0]))\
       .select(attr_grp_y.columns[0], attr_grp_y.columns[1],\
                attr_grp_n.columns[1]) \ gain_for_attribute = calculate_info_gain(entropy, joined_df, total_elements)
   attr_name_info_gain[attr_name] = gain_for_attribute

功能说明

它从文件中读取数据。当我们构建树时,我们将只需要获得对应于树的那个分支的数据。“where_condition”属性将包含这些谓词。

对于传递的属性名称,我们将文件中结果为“是”的记录分组

  • 第一次,where_condition 将为空,
  • 第二次迭代之后,在找到树根之后,我们将得到 where_condition
if not where_condition:
   attr_grp_y = data.where(col('y') == 'yes').groupBy(attr_name).agg({"y": 'count'})\
       .withColumnRenamed('count(y)','played_count')
else:
   attr_grp_y = data.where(" y like '%yes%'  " + where_condition).groupBy(attr_name).agg({"y": 'count'})\
       .withColumnRenamed('count(y)','played_count')
  • 类似地,它将文件中结果为“否”的记录分组为传递的属性名。
if not where_condition:
   attr_grp_n = data.where(col('y') == 'no').groupBy(attr_name).agg({"y": 'count'})\
       .withColumnRenamed(attr_name,'n_' + attr_name)\
       .withColumnRenamed('count(y)','not_played_count')
else:
   attr_grp_n = data.where(" y like '%no%'  " + where_condition).groupBy(attr_name).agg({"y": 'count'})\
       .withColumnRenamed(attr_name,'n_' + attr_name)\
       .withColumnRenamed('count(y)','not_played_count')
  • 我们将列 count(y) 重命名为 played_count,将 count(n) 重命名为 not_played_count
  • 将 attr_name 列重命名为 n
.withColumnRenamed(attr_name,'n_' + attr_name)\
  • 现在,我们将这两个数据帧连接起来,一个具有该属性“是”结果的计数,另一个具有同一属性“否”结果的计数
joined_df = attr_grp_y.join(attr_grp_n, on = [col(attr_grp_y.columns[0]) == col(attr_grp_n.columns[0])], how='outer' )\

我们在属性名上连接。我们需要外部连接,如果一个属性没有“是”或“否”结果的记录,那么我们仍然需要当前的“是”或“否”计数。

此外,由于我们有是和否结果的计数,我们还需要总计数(有是和否的记录总数)来计算熵。因此,我们添加了一个新列,其中包含总数

.withColumn("total", col(attr_grp_y.columns[0]) + col(attr_grp_n.columns[0]))\

我们不会选择连接列两次

.select(attr_grp_y.columns[0], attr_grp_y.columns[1],\
        attr_grp_n.columns[1])

我们做了所有这些练习来计算这个特定属性的信息增益,所以让我们来计算一下

gain_for_attribute = calculate_info_gain(entropy, joined_df, total_elements)

我们将在全局变量 attr_name_info_gain 中保存该属性**的信息增益。**我们稍后将对该字典进行排序,以获得具有最大信息增益的属性。接下来描述调用的 Calculate_info_gain 函数。

gain_for_attribute = calculate_info_gain(entropy, joined_df, total_elements)  *#*
 attr_name_info_gain[attr_name] = gain_for_attribute

5)信息增益功能

def calculate_info_gain(entropy, joined_df, total_elements):
   attr_entropy = 0.0
   for anAttributeData in joined_df.rdd.collect():
       yes_class_count = anAttributeData[1]
       no_class_count = anAttributeData[2]
       if yes_class_count is None:
           yes_class_count = 0
       elif no_class_count is None:
           no_class_count = 0 count_of_class = yes_class_count + no_class_count
       *# do the summation part e.g. if age is 56, 60, 45 then its sum of entropy for each of these element*
       classmap = {'y' : yes_class_count, 'n' : no_class_count}
       attr_entropy = attr_entropy + ((count_of_class / total_elements) *\
                                      calculate_entropy(count_of_class, classmap)) gain = entropy - attr_entropy return gain

如果您已经阅读了前面的章节,那么这个函数是不言自明的

6)再次返回主功能

我们一直处理到这个代码行—->“process _ dataset([],data,played,notplayed, '' )”

def main():
   data = sqlContext.read.format('com.databricks.spark.csv').option('header', 'true')\
       .option('delimiter', ';').load("/home/me/ml/practice/decision_tree/datasets/simple_dataset") data.registerTempTable('data')
   played = sqlContext.sql("select * from data WHERE y like  '%y%' ").count()
   notplayed = sqlContext.sql("select * from data WHERE y like  '%n%' ").count()
   process_dataset([], data, played, notplayed, '')
   *# sort by info gain*
   sorted_by_info_gain = sorted(attr_name_info_gain.items(), key=operator.itemgetter(1), reverse=True) processed_attrs = []
   max_gain_attr = sorted_by_info_gain[0][0]
   processed_attrs.append(max_gain_attr)
   build_tree(max_gain_attr, processed_attrs, data, '') nx.draw(G, with_labels=True)
   plt.show()

对信息增益函数进行排序,得到增益最大的属性,将其作为根节点。现在我们调用构建树函数。这是最后一个也是最重要的功能。

此方法的输入是具有最大信息增益的属性的名称。这将成为树的根节点。我们希望获得该属性的不同值。这些值将成为该节点的分支。

这个函数将递归地构建完整的树。

def build_tree(max_gain_attr, processed_attrs, data, where_condition):
   attrValues = sqlContext.sql("select distinct " + max_gain_attr + " from data  where 1==1 " + where_condition)
   orig_where_condition = where_condition for aValueForMaxGainAttr in attrValues.rdd.collect():
       adistinct_value_for_attr = aValueForMaxGainAttr[0]
       G.add_edges_from([(max_gain_attr, adistinct_value_for_attr)]) if attrs_type[max_gain_attr] == "string":
           where_condition = str(orig_where_condition + " and " + max_gain_attr + "=='" + adistinct_value_for_attr + "'")
       else:
           where_condition = str(orig_where_condition + " and " + max_gain_attr + "==" + adistinct_value_for_attr) played_for_attr = sqlContext.sql("select * from data where y like '%yes%' " + where_condition).count()
       notplayed_for_attr = sqlContext.sql("select * from data where y like '%no%' " + where_condition).count()
       *# if either has zero value then entropy for this attr will be zero and its the last attr in the tree*
       leaf_values = []
       if played_for_attr == 0 or notplayed_for_attr == 0:
           leaf_node = sqlContext.sql("select distinct y from data where 1==1 " + where_condition)
           for leaf_node_data in leaf_node.rdd.collect():
               G.add_edges_from([(adistinct_value_for_attr, str(leaf_node_data[0]))])
           continue process_dataset(processed_attrs, data, played_for_attr, notplayed_for_attr, where_condition)
       if not attr_name_info_gain: *# we processed all attributes*
           *# attach leaf node*
           leaf_node = sqlContext.sql("select distinct y from data where 1==1 " + where_condition)
           for leaf_node_data in leaf_node.rdd.collect():
               G.add_edges_from([(adistinct_value_for_attr, str(leaf_node_data[0]))])
           continue *# we are done for this branch of tree* *# get the attr with max info gain under aValueForMaxGainAttr*
       *# sort by info gain*
       sorted_by_info_gain = sorted(attr_name_info_gain.items(), key=operator.itemgetter(1), reverse=True)
       new_max_gain_attr = sorted_by_info_gain[0][0]
       if sorted_by_info_gain[0][1] == 0:
           *# under this where condition, records dont have entropy*
           leaf_node = sqlContext.sql("select distinct y from data where 1==1 " + where_condition)
           *# there might be more than one leaf node*
           for leaf_node_data in leaf_node.rdd.collect():
               G.add_edges_from([(adistinct_value_for_attr, str(leaf_node_data[0]))])
           continue *# we are done for this branch of tree* G.add_edges_from([(adistinct_value_for_attr, new_max_gain_attr)])
       processed_attrs.append(new_max_gain_attr)
       build_tree(new_max_gain_attr, processed_attrs, data, where_condition)

解释

我们希望节点有不同的值。

attrValues = sqlContext.sql("select distinct " + max_gain_attr + " from data  where 1==1 " + where_condition)

对于该节点的每个值

for aValueForMaxGainAttr in attrValues.rdd.collect():

获取该迭代下的属性值

adistinct_value_for_attr = aValueForMaxGainAttr[0]

将此值添加为节点的分支

G.add_edges_from([(max_gain_attr, adistinct_value_for_attr)])

我们需要得到这个属性值下的数据。如果树是

我们正在处理父节点的“Sunny”值,然后在同一个分支(outlook → sunny)下继续,我们需要获得 outlook = sunny 的数据。所以我们把它作为新的 where 条件添加进来。

此外,如果我们需要在引号下添加值时属性类型是 string,而它是 int 类型,那么我们不添加引号。

if attrs_type[max_gain_attr] == "string":
           where_condition = str(orig_where_condition + " and " + max_gain_attr + "=='" + adistinct_value_for_attr + "'")
       else:
           where_condition = str(orig_where_condition + " and " + max_gain_attr + "==" + adistinct_value_for_attr)

我们将再次从属性列表中找出具有最大信息增益的属性,不包括已经被处理的属性。因此,对于父属性的这个值,我们想知道有多少记录的结果为“是”和“否”

played_for_attr = sqlContext.sql("select * from data where y like '%yes%' " + where_condition).count()
notplayed_for_attr = sqlContext.sql("select * from data where y like '%no%' " + where_condition).count()

如注释所述,如果我们得到的熵值为零,那么我们就到达了这个分支的叶节点,我们只需将结果添加到这个节点下的树中。

*# if either has zero value then entropy for this attr will be zero and its the last attr in the tree*
       leaf_values = []
       if played_for_attr == 0 or notplayed_for_attr == 0:
           leaf_node = sqlContext.sql("select distinct y from data where 1==1 " + where_condition)
           for leaf_node_data in leaf_node.rdd.collect():
               G.add_edges_from([(adistinct_value_for_attr, str(leaf_node_data[0]))])
           continue

如果没有,那么我们继续处理。类似下面的代码已经在主函数中处理并解释过了。也许我们应该把这一次迭代也作为这个递归的一部分,让这成为你的练习。

process_dataset(processed_attrs, data, subscribed_for_attr, unsubscribed_for_attr, where_condition)
if not attr_name_info_gain: *# we processed all attributes*
   *# attach leaf node*
   leaf_node = sqlContext.sql("select distinct y from data where 1==1 " + where_condition)
   for leaf_node_data in leaf_node.rdd.collect():
       G.add_edges_from([(adistinct_value_for_attr, str(leaf_node_data[0]))])
   continue *# we are done for this branch of tree**# get the attr with max info gain under aValueForMaxGainAttr*
*# sort by info gain*
sorted_by_info_gain = sorted(attr_name_info_gain.items(), key=operator.itemgetter(1), reverse=True)
new_max_gain_attr = sorted_by_info_gain[0][0]
if sorted_by_info_gain[0][1] == 0:
   *# under this where condition, records dont have entropy*
   leaf_node = sqlContext.sql("select distinct y from data where 1==1 " + where_condition)
   *# there might be more than one leaf node*
   for leaf_node_data in leaf_node.rdd.collect():
       G.add_edges_from([(adistinct_value_for_attr, str(leaf_node_data[0]))])
   continue *# we are done for this branch of tree*G.add_edges_from([(adistinct_value_for_attr, new_max_gain_attr)])
processed_attrs.append(new_max_gain_attr)
build_tree(new_max_gain_attr, processed_attrs, data, where_condition)

现在,如果我们执行了 main 函数的最后两行,那么您可以直观地看到构建的决策树:-)

nx.draw(G, with_labels=True)
plt.show()

尽情享受吧!!!如果可能的话,提供关于拼写错误或任何其他此类编辑(没有做任何审查或校对),关于算法,优化等的反馈。

机器学习-新兴技术简讯-2017 年 9 月 19 日

原文:https://towardsdatascience.com/machine-learning-emerging-technologies-newsletter-september-19-2017-b5c8d2f73764?source=collection_archive---------10-----------------------

那么是什么让这些新兴技术如此引人注目呢?几乎很难说。毕竟他们还在不断涌现。我妻子喜欢说,我们人类保留了很多动物本能。我们能感觉到一些东西:危险、变化、敌意、积极的振动等等。我认为新兴技术也有一些这样的东西。我们认为他们将会是有影响力的、决定性的、游戏改变者、生活改变者,但我们几乎不知道具体是如何以及为什么。我们已经习惯了自然语言处理,使用谷歌搜索或 siri,我们习惯了无人机在战区、足球比赛、玉米地和冲浪点上空盘旋。我们每天都生活在网络安全之中。
我创办这份时事通讯是为了填补我发现的一个空白。工程师、开发人员、博士、技术人员的机会很多,但非技术人员、普通业务经理的机会不多。最终,他们将使一项技术成功,一旦他们得到它,一旦他们知道用特定的技术制造哪种产品,事情就会好转。因此,这里我们将重点放在业务应用上。希望有帮助!

机器学习
一切关于我们如何教算法变得更聪明

谷歌于 2016 年推出的移动通讯应用Allo 是该公司试图使用机器学习来进行聊天,如果不是更智能,那么至少更有用和更有表现力。你使用 Allo 越多,它的算法就越能确定你听起来像什么,并产生听起来不固定的预先写好的反应。此外,Allo 可以学习你如何与不同的收件人发短信,因此它可以提供一个“好伙计”来回复你最好的朋友,但不是在你给妈妈发短信时。智能回复还有一个隐秘的目的:向用户介绍谷歌助手,Allo 内部的真正大脑,以及该公司新的谷歌 Home 智能音箱

Amperity 是一家曾经默默无闻的初创公司,它正在为品牌推出一个机器学习平台。诀窍在于: Amperity 不是使用算法将现有规则应用于数据集,而是根据实时上传的信息,在没有人工干预的情况下,教会其算法开发自己的规则。“这个系统正在自我训练,”沙哈尼说。“这使得整个模型更加有效。”那又怎样;有什么大不了的?品牌与 Amperity 的集成方式与它们与数据管理平台的集成方式相同。随着不断吸收原始数据,Amperity 将机器学习应用于重复数据删除记录、创建身份匹配和开发客户资料,这些资料可以被激活用于目标定位、细分、创建相似的受众、媒体购买——所有常见的东西。不同寻常的是 Amperity 在开放生态系统中对身份的处理方式。“像脸书、谷歌或 GitHub 这样的系统首先通过认证建立一个通用身份,为该身份打开一个工具生态系统,”Amperity 的工程副总裁和脸书的前移动工程高管戴夫·费特曼说。Fetterman 说,相比之下, Amperity 在一个组织内“跨不同的数据库”创建身份匹配。在某种意义上,这与围墙花园接近身份的方式相反。

零售中,机器学习可以对供应链产生重大影响。由于物联网,各种传感器、信标、远程访问数据收集器都可以用来建立数据清单。这些数据可以跟踪起点、路线、接触点、条目,机器将开始从这些数据点中学习。然后,分析工具可以预测延迟,以天、小时、周为单位,并发送通知

Broadcast 中,BBC 新闻实验室的一名高级广播系统开发人员表示,该广播公司希望使用机器学习来帮助其记者应对他们在报道重大事件时面临的“内容海啸”。比万说:“想想英国 6 月份的大选,一系列外部消息来源都会参与进来。我们如何使用丰富的元数据并将机器学习技术应用于我们伦敦新闻编辑室中试图在我们的系统中找到内容的数千名记者?

**那么,机器学习泡沫何时会破裂?**根据回答 Coursera 联合创始人吴恩达;斯坦福大学的兼职教授在 Quora 上说:“大约 100 年前,这里有很多关于电力的宣传。这个特殊的泡沫还没有破裂,我们发现电非常有用!更严重的是,因为深度学习已经创造了大量的价值——它被用于网络搜索、广告、语音识别、推荐系统等等— 它显然会继续存在。深度学习,加上更广泛的其他人工智能工具(图形模型,规划,KR 等。),现在已经有了一个清晰的行业转型路径。它的影响将远远超出技术领域。”新闻不断证实安德鲁的观点。脸书将在蒙特娄开设一个研究中心实验室。亚马逊正在巴塞罗纳开设一个机器学习实验室。
本周机器学习:

  • 移动支付公司 iZettle 为 R&D 筹集了 3600 万美元的债务,用于人工智能、机器学习等领域链接
  • 总部位于里士满的机器学习公司 Notch 正在将城市放到地图上链接
  • 机器学习正在释放 3D 打印的潜力链接
  • 严肃对待研究伦理:人工智能和机器学习链接
  • 关于机器学习你应该知道的 10 件事链接
  • 机器学习可用于阻止欺诈链接
  • 计算机科学家正在寻找将好奇心编码到智能机器中的方法。链接

那么,你认为机器学习在你的行业中应用于何处?
您是否看到了在贵公司使用机器学习的商业案例?
你认为你已经准备好使用机器学习了吗?

请在评论中告诉我们你的想法。

谢谢

Melvin Manchau 是一名管理顾问,专门从事金融机构的业务运营、技术和战略。此处表达的观点是他个人的观点,不代表预委会的观点。

机器学习工程 1:房屋销售估算。

原文:https://towardsdatascience.com/machine-learning-engineering-1-custom-loss-function-for-house-sales-estimation-95eec6b12457?source=collection_archive---------10-----------------------

Visualization of a Custom Loss Function

这篇博客文章将是如何作为机器学习(ML)工程师思考的第一课。我们将研究一个监督学习问题,重点是设计一个定制的损失函数。用这样的技巧思考,你会自信地获得一个入门级的 ML 工程师角色。

这篇博文假设你对现代 ML 有一个基本的了解。

非技术性的序言,请阅读https://medium . com/@ leetandata/machine-learning-preamble-ba 69 BCA 4701d

关于数学和数字代码的详细解释,从https://medium . com/@ leetandata/neural-network-introduction-for-software-engineers-1611d 382 C6 aa开始

有关在 Windows 上安装 Python 进行机器学习的说明,请阅读:https://medium . com/@ leetandata/basic-Python-setup-for-ml-for-Windows-users-aaadb 2 be 534 c

问题介绍

眼下的问题是从模拟数据集中估算出售一套公寓所需的时间。

数据是上市日期、销售日期(如果公寓已经售出)、价格和公寓的数字特征。

回归快速回顾

回归将要素数据作为向量。每个数据点被定义为一些输入特征,例如关于房子的特征。回归模型使用这些特征来预测目标(它猜测 Yhat,这意味着从数据集中逼近真实的 Y 或目标)。该模型通过从数据集学习来训练自己,以最小化损失函数。

回到我们的具体问题

对于简单的回归问题,您的数据以包含要素 X 和目标值 y 的数据集的形式提供给您。您将数据集分为训练集和验证集,在训练集上训练模型,并在验证集上验证其性能。

公寓销售估算类似于简单的回归问题,但提出了 ML 必须考虑的四个错综复杂的问题:

  • 首先,我们需要划分数据。我们将使用一些数据(称为训练数据)来训练我们的模型,并使用一些数据来验证我们训练的模型的性能。对于一般数据集,我们可以随机划分数据集。对于时间序列数据,我们可以将数据切碎,在截止日期之前对数据进行训练,并在截止日期之后对数据进行验证。这模拟了如果我们对过去进行训练,并发布它来实时预测未来,模型会做得有多好。与大多数时间序列问题相比,这对于该数据集来说很困难,因为每个样本都有两个时间戳,即上市日期和销售日期。
  • 其次,我们并不总是知道正确的销售日期。对于尚未售出的公寓,我们知道它们的销售日期发生在数据集中的最后一次销售之后,但我们不知道最后一次销售是什么时候。如果有时我们只知道一个最小值而不知道真实值,我们如何创建我们的损失函数。
  • 第三,我们注意到输入要素数据有缺失值。我们该怎么办?有人可能只是忘记列出卧室或浴室的数量或公寓的平方英尺。我们将探索处理这种复杂性的几种选择。
  • 最后,用来评估我们模型的许多性能的最有意义的评估指标是什么?我们想使用一些标准的东西,如均方差或 T2 R2 系数,但是我们怎么能计算更大的值而不关心小的差异呢?例如,1 天和 5 天看起来差别很大,但是 81 天和 85 天应该被认为是非常准确的。在不知道还没卖出去的房子的真实价值的情况下,我们该怎么做呢?

1:培训/验证/测试步行前进优化

通常情况下,在机器学习中,我们会随机划分(具体数字会因问题而异)70%的数据用于训练模型,20%的数据用于验证性能,10%的数据用于测试发布性能。

我们反复地改变模型、训练和验证,直到我们的验证准确性达到最大。我们相信推广到新的看不见的数据的模型表现最好,所以我们利用在验证集上表现最好的模型。

最后,我们在测试集上评估一次,以估计我们的模型在现实世界中的推广程度。通过这种方式,我们可以构建复杂的模型来表示我们的数据,然后计算不会高估我们对其性能的估计的指标。

Walk Forward Optimization

在时间序列建模中,我们使用前推优化,将时间序列分成许多时间截止点 T1、T2、T3 等。我们首先对 T1 之前的数据进行训练,并在 T1 和 T2 之间的时间段验证我们的性能。然后,我们将我们的训练数据集扩展到 T2,然后在 T2 和 T3 之间的时间段进行验证。因此,我们的整体验证性能指标是来自不同数据切片的平均验证性能,我们的测试集可以是数据的最后一个时间片,或者是从验证数据点中排除的不同时间片中的一些数据点。

但是,我们注意到每个时间步都有两个数据点:上市日期和销售日期。所以,如果我们训练到 T1,那么到那时我们实际上已经知道了什么?

在培训期间,我们将了解 T1 之前的所有列表。在这些公寓中,我们将隐藏 T1 之后的所有销售日期。

在验证过程中,我们需要验证在 T1 和 T2 之间售出的所有公寓,以及在 T2 之前上市但在 T1 之后才售出的所有房源。为了简化我们的验证集,我们验证了在 T1 之后销售、在 T2 之前上市的产品的性能。

以上是至关重要的,因为它允许我们使用所有可用的数据来训练和验证,但不要过于乐观,不允许我们自己欺骗和预见未来。避免数据泄露或作弊在机器学习中非常重要,因为数据泄露让我们相信我们的模型不切实际地准确。然后,我们可以发布我们的模型,并对它在新数据上的表现感到非常惊讶。

2:有意义的损失函数

让我们为问题提出一个合理的基线损失函数。我们关心出售公寓的时间和预测时间之间的差异,我们越是偏离,就越需要修正我们的预测。因此,我们可以提出均方误差(MSE)。但在某种程度上,如果一套公寓在 1 天内售出,而我们预测是 10 天,那么我们就比公寓在 81 年售出,而我们预测是 90 天的情况要差得多。因此,也许我们应该使用均方差百分比误差(MSPE),其中我们根据我们预测的百分比来惩罚模型。这两者似乎都有道理,但既然我们都关心,就让我们取两者的几何平均值,并将其作为我们的损失函数,将两者都考虑在内。这不是业务可解释,但它是我们的损失函数,并不一定是我们的评估度量。我们稍后会谈到这一点。

那么,如果一套公寓卖不出去会怎么样呢?假设一套公寓在 T0 时上市,训练集截止到 T1,但该公寓在 T2 售出(或者从未售出)。在 T1,公寓仍未售出,我们假装看不到 T1 之后的未来,因此我们需要将公寓标记为“尚未售出”。那么我们如何利用这个数据点来改进我们的模型呢?

假设我们的模型预测公寓将在 T0 和 T1 之间出售。在这种情况下,我们知道模型是错误的,并且模型应该预测更大的数字,所以让我们假设在这种情况下真实值是定型数据集的结尾。

但是如果我们的模型预测的值大于 T1 呢?我们不知道这是太大还是太小,因为它正确地在我们的训练数据集结束后,所以我们不要在这种情况下给我们的模型一个损失函数。

通过这种方式,我们使用所有可用的数据,并使用有意义的损失函数优化我们的模型,以获得有商业价值的近似值,从而最小化百分比误差!

3:数据插补

有人忘了在我们的一些数据点上列出卧室或浴室的数量或公寓的平方英尺数。但我们是那些被随意遗忘或被有意忽略的人吗?

我们为每个特征创建额外的标志,来表示数据是否丢失,我们将这些标志输入到模型中,并填充丢失的值。

为了填充缺失的值,我们可以有一个独立的网络来学习预测值或其他自定义解决方案(这对于语言、图像或音频等结构化数据非常流行),但对于我们的情况,让我们只手动输入日期。两种流行的方法是用所在字段的平均值替换缺失值,或者找到一些非常相似的公寓并用相似公寓的平均值替换缺失值。

我们称寻找相似的数据点为插补K-最近邻(KNN) 插补。其工作方式是,我们找到 K 个数据点,这些数据点最接近具有缺失特征的数据点。对于缺失的特征,我们取该特征的 K 个最近点值的平均值。

使用欧几里德距离来测量“最近邻”听起来很合理,但是如果一个要素的值在 0-1000 之间,而另一个要素的值在 0-1 之间呢?在这种情况下,具有大尺度的特征将比小特征更大地影响欧几里德距离。例如,x1,x2 = [600,0.1]可能比[580,0.2]更接近[590,0.9],即使两者具有非常相似的 x1 值,而它们的 x2 值完全在范围的两端。

我们如何使所有特征对“最近邻”插补产生相似的影响?让我们通过首先缩放特征来标准化它们的影响,这样它们都具有均值 0 和标准差 1,这样每个特征对插补都有相同的影响!

4:评估指标

设计有意义的评估指标是任何 ML 项目最重要的任务之一。最能代表“这种模式学点商业有意义的东西”的数字有哪些?

一些工程师有一个坏习惯,坚持使用现成的指标,如均方差,或他们的预测和真实值之间的相关性。然后,他们将这些数字呈现给商业成员,这些商业成员会对这些毫无意义(理所当然)的技术术语感到沮丧。在我们的例子中,我们可以使用许多度量标准,比如时间对数的皮尔逊相关系数,但是这很难解释。

相反,让我们使用业务最简单的基线,平均绝对百分比误差(MAPE) ,它告诉我们您的预测和真实值之间的比率的平均绝对值。为了解释这一指标,0.1 的值平均表示与真实值相差 10%。值 0.2 表示与真实值的平均值相差 20%,例如与正确值的平均值相差 80%或 120%。这个度量不能是负数,0 代表完美。

但是未知的值呢?让我们用 MAPE 来表示我们知道其真实价值的值,让我们用另一个指标来表示未售出公寓中被正确归类为未售出公寓的百分比(销售日期预计超过数据集的末尾)。我们还可以通过假装在数据集的最后一天售出的公寓来替换未售出的公寓,并以此计算 MAPE,这将更容易解释,但不太准确。

对于评估指标,像业务人员一样思考

所以作为一个数学家,我们写了一个优化函数。接下来,我们编写了一个评估函数来构建可解释的结果。但这是理解我们表现的最有意义的方式吗?在这种情况下,答案是否定的,因为我们真的没有尝试去思考什么对我们的问题有意义。

我们计算了一个总结模型性能的指标。很棒?但是我们不应该总结的太全面!我们的数据给我们带来了影响我们性能的重要特性复杂性。一些公寓在一周后售出,一些在一年后售出。此外,一些公寓的价格高达数万,一些高达数千万。特别是因为我们的评估指标是误差除以实际销售时间,我们建议按实际销售时间区域对我们的准确度进行分组,并绘制这些值的平均值和四分位间距

这样,我们可以问这样的问题“对于快速销售的房屋,我们大约打了 X1 折,但是对于我们将在市场上停留更长时间的房屋,我们大约打了 X2 折”。有了这些,商业人士和数学家都应该更乐意了解他们的模型是如何运行的。

转换点:从想法到代码

哇!以上内容很多。我们覆盖了

  • 有意义的 train/val 前向优化循环
  • 自定义损失函数
  • 如何处理缺失的功能
  • 有意义的评估指标和图形表示

我们现在已经完成了概念的提出,所以现在我们只需要实现上面的想法!

履行

让我们从一些导入开始,为评估指标的图像创建一个目录,并读入我们的数据集。

我们的数据在 Pandas 数据框架中,这很像 SQL 表。它的顶部如下图所示:

Pandas DataFrame Data Table

数据准备

现在我们都准备好了。现在让我们构建一个函数,让我们为我们的训练/测试分割切割数据。我们需要接受数据切片的可选开始日期和可选结束日期。

该函数分割整个数据集,只保留开始日期之后或结束日期之前的数据。这将有助于建立训练和验证数据集。

现在我们需要一个定标器来标准化我们的数据,为插补做准备。定标器从训练数据中学习如何归一化,并将这些归一化参数(平均值和标准偏差)应用于验证数据集。

我们还需要从我们的训练数据构建一个估算器,学习估算缺失值,并且我们需要能够将它应用于训练数据集和验证数据集。

上面的代码准备了我们模型的输入数据。

现在来说说我们的目标变量!我们的目标变量是公寓上市和售出之间的天数。当公寓尚未售出时,销售日期设置为当天,我们有一个已售出标志来表示公寓是否已经售出(我们稍后将使用这两个标志)

使用 Tensorflow 建模

我们的模型接受一些输入特征。它有占位符来接受每个数据点的值,售出(公寓是否售出)、x(输入要素)和 y(公寓售出前的天数)。

该模型使用神经网络(简单解释详细解释)来预测公寓需要多长时间才能出售。然后,It 计算损失函数和评估指标,并构建优化器来最小化损失函数。

我们还创建列表来跟踪我们在整个训练过程中的表现,并计算其他损失函数,只是为了在教程中演示。

这里,我们为一个时期训练模型,这是为了将每个数据点看一次并最小化损失函数

我们通过在验证数据集上检查 MAPE 来验证我们的性能。

培训是一个时期的培训和验证我们表现的过程。我们多次调用这个过程来从数据集学习并跟踪我们的表现。

最后,让我们通过跟踪训练和验证损失,以及预测和实际情况之间的 r2 分数来可视化模型的性能。

上面生成了类似下面的图,x 轴是训练的时期,y 轴是损失和 r2 分数:

Sample of what our validation function creates

训练模型

太好了!现在,最后,让我们在一个训练集上进行训练,并在接下来的时间里进行验证。我们将使用上面定义的代码来分割数据集和训练模型。最后,让我们返回我们的最终性能,以便我们可以在向前优化过程中进行跟踪。

总结:我们做了什么?

  1. 我们分割数据,

2.学会了根据训练集缩放和估算数据,

3.将缩放和估算应用于验证数据集,

4.定义我们的模型,训练我们的模型,然后

5.可视化的训练表现。

所有这些都是通过调用我们之前定义的函数来实现的。

向前优化

既然我们已经进行了培训和验证,让我们继续浏览数据集,在后续阶段进行培训和验证。

最后,让我们直观地了解一下整个过程中的前进优化性能。

这产生了关于前推优化切割的最终验证性能的曲线。

最后,下面是从第一个到最后一个截止点运行完整模型的代码,如代码部分开头所定义的。

按组标绘性能

现在我们选择按销售持续时间分组,看看我们的误差百分比在组内如何变化。为了说明我们想要的最终输出(我们将在下面得到),我们提供了下面的图表:

这些图像是通过以下函数调用绘制的,每行一个图像

最后,在下面,我们给出了生成上述图像的代码。

总结

我们做到了!我们使用训练/验证分割来准备数据集,标准化输入数据,输入缺失值,将模型拟合到训练数据集,在验证数据集上进行验证,并在向前优化循环中完成整个结构!呜!

因此,现在我们已经准备好并且可行,我们可以在我们的完整数据集上训练我们的模型,并将其发布到世界上,我们对它在未来分类中的表现有一个预期(根据上述曲线,它的平均绝对百分比误差约为 30%)。

前言如果你有点迷路了,浏览了这篇文章,忘记了我们为什么要用机器学习以及我们在说什么:https://medium . com/@ leetandata/Machine-Learning-前言-ba69bca4701d

数学重磅跟进:https://medium . com/@ leetandata/neural-network-introduction-for-software-engineers-1611d 382 C6 aa

本帖综合来源:https://github . com/leedtan/LeeTanData/blob/master/SimpleML _ house sales/house predictions . ipynb

机器学习,快与慢

原文:https://towardsdatascience.com/machine-learning-fast-and-slow-eb16b732fb5f?source=collection_archive---------6-----------------------

模型的记忆和概括

假设你经营一家名为米其林人的餐厅点评网站。你从用户那里收集了大量评论,并想分析它们是否连贯

一位刚刚在意大利餐厅用餐的用户写道:

我喜欢这种调料。

解决这个问题的一个常见方法是在单词级别查看消息。

["i", "like", "the", "dressing", "."]

一般化

你可以从理解每个单词的意思开始,通过在大量文本数据上训练一个模型来生成单词表示有很多技术可以做到这一点,但本质上,一个单词最终将由一个数字向量来表示。

like = [.03, -1.45, ..., 0.45, 0.74]

因为这些单词表示是在一大组文本(比如整个互联网)中学习的,所以它们是可概括的。换句话说,你可以把单词“like”的意思编码出来,并把它们放在各种其他的上下文中(例如 SMS 文本、短文写作等)。)而且总体来说,它们会非常合适。

如果您在向量空间中可视化这些表示,您将看到相似的单词将聚集在一起。

Word representations (hence, words) that are similar should be close in vector space. Credit: Colah and Turian.

假设另一个人写道:

我喜欢这种调料。

["i", "admire", "the", "dressing", "."]

现在,“钦佩”和“喜欢”被认为是同义词。因此,各自的单词表示应该相似。

word_similarity("like", "admire") = high

太好了!假设单词表示或多或少是自动学习的,这种学习单词之间关系的方法是可扩展的和有用的。

词语表征的概括能力可以扩展到连贯。定义连贯性的一种方法是看一对词在同一语境中是否搭配得很好。一个简单的计算方法是比较一个句子中两个单词的相似度。

因此,从上面的例子中,你可以分离出单词“dressing ”,并检查它是否与单词“like”和“appraise”兼容。

word_similarity("like", "dressing") = somewhat highword_similarity("admire", "dressing") = somewhat low

这也有道理,“喜欢”比“佩服”更相似。

然而,从上面看不出“钦佩”和“穿着”是否一致。尽管人们赞美一件“衣服”并不是完全不可思议的,但更有可能的是,用户要么是有创意,要么是弄错了。

一般化的弱点是,它经常在一般情况之外失败,即平均而言。尽管“表示”这个词有很多含义,但它认为将“钦佩”和“穿着”放在句子中是合理的,因为“喜欢”与“钦佩”和“穿着”都很接近。在当前的设置下,即使是从未出现过的单词也只会显示出些许相似。

记住

显示连贯性的一个简单方法是计数。通过统计上面的词对,可以清楚地看出它们以前是否存在过。

在谷歌 Ngram 语料库上快速扫描显示“赞美着装”在之前从未发生过。

counts_in_the_same_sentence("like", "dressing") = somecounts_in_the_same_sentence("admire", "dressing") = none

计数基本上没有普遍性,因为你必须记住每一个可能的组合,这需要大量的记忆。但是这一信息是对从单词表示中得出的概括的补充。

从视觉上看,这两种方法的分布非常明显。使用计数方法,绝大多数单词对将为零,而少数单词对将具有指数级的更高计数。相似性一词更为正态分布,尽管通常是右偏的,所以高相似性聚集在一起。

Counts will approximately be an exponential distribution and word similarities will approximately be a normal distribution. Credit: Gunther.

直观地说,这两种方法在其分布斜率最大的地方具有最强的区分能力。计数在低计数时表现良好,而单词表示在高相似度时表现良好。

将不同的模型混合在一起并不是什么新鲜事。如果你想赢得单人游戏比赛,组装几乎是必不可少的。

谷歌最近建立了一个“广度”和“深度”模型,将记忆和归纳模型动态地结合起来。这只是将模型混合在一起的一种方式,但这是向用户展示他们喜欢什么(记忆)和他们可能喜欢什么(概括)的好方法。

面向初学者的机器学习

原文:https://towardsdatascience.com/machine-learning-for-beginners-d247a9420dab?source=collection_archive---------1-----------------------

M 机器学习在 90 年代由 亚瑟·塞缪尔 定义为,“ 这是一个研究领域,它赋予计算机自我学习的能力,而无需显式编程 ”,这意味着将知识灌输给机器,而无需硬编码。

机器学习主要专注于开发计算机程序,这些程序可以在接触到新数据时教会自己成长和变化。机器学习研究自我学习做事情的算法。通过学习算法,可以更快地处理海量数据。例如,它会对学习完成一项任务、做出准确的预测或表现得聪明感兴趣。

为什么我们需要机器学习

数据每天都在增长,不可能以更高的速度和更高的准确性理解所有的数据。超过 80%的数据是非结构化的,即音频、视频、照片、文档、图表等。对于人类大脑来说,在地球上的数据中寻找模式是不可能的。数据非常庞大,计算所需的时间会增加,这就是机器学习发挥作用的地方,以帮助人们在最短的时间内处理大量数据。

机器学习是人工智能的一个子领域。通过应用人工智能,我们想要建造更好更智能的机器。这听起来就像一个新生的孩子在自我学习。所以在机器学习中,计算机的一种新能力被开发出来。现在,机器学习出现在如此多的技术领域,以至于我们在使用它时甚至没有意识到它。

机器学习的类型

机器学习主要分为三类,如下所示

Types of Machine Learning

1.监督学习:-

监督学习 是第一种机器学习,其中 标注为 的数据用来训练算法。在监督学习中,使用标记的数据训练算法,其中输入和输出是已知的。我们将数据作为一组输入输入到学习算法中,这些输入被称为特征,由 X 表示,相应的输出由 Y 表示,该算法通过将其实际结果与正确的输出进行比较来发现错误。然后它相应地修改模型。原始数据分为两部分。第一部分用于训练算法,另一部分用于测试训练好的算法。

Supervised Machine Learning

监督学习使用数据模式来预测标签的附加数据的值。这种方法通常用于历史数据预测可能即将发生的事件的应用中。例如:它可以预测何时交易可能是欺诈性的,或者哪个保险客户会提出索赔。

监督学习的类型:-

监督学习主要分为以下两个部分

Types of Supervised Learning

1.1 .回归:-

回归 是监督学习的类型,其中使用标记数据,并且该数据用于以连续的形式进行预测。输入的输出总是持续的,图形是线性的。回归是预测建模技术的一种形式,它调查因变量[ 输出 ]和自变量[ 输入 ]之间的关系。这种技术用于天气预报、时间序列建模、过程优化。例如:回归技术的一个例子是房价预测,房价将根据输入值进行预测,如房间数量、位置、交通便利程度、房龄、住宅面积。

回归算法类型:-

机器学习中有许多回归算法,它们将用于不同的回归应用。一些主要的回归算法如下-

1.1.1 .简单线性回归

在简单的线性回归中,我们根据第二个变量的评分来预测一个变量的得分。我们预测的变量称为标准变量,记为 y。我们预测的变量称为预测变量,记为 x。

1.1.2 .多元线性回归

多元线性回归是回归技术的算法之一,是线性回归分析最常见的形式。作为一种预测分析,多元线性回归用于解释一个因变量与两个或两个以上自变量之间的关系。自变量可以是连续的,也可以是分类的。

1.1.3 多项式回归

多项式回归是另一种形式的回归,其中自变量的最大幂大于 1。在这种回归技术中,最佳拟合线不是直线,而是曲线。

1.1.4 .支持向量回归

支持向量回归不仅可以应用于回归问题,还可以用于分类的情况。它包含了最大间隔算法的所有特征。线性学习机映射将非线性函数倾斜到高维核诱导特征空间中。系统容量由不依赖于特征空间维数的参数控制。

1.1.5 .岭回归:-

岭回归是回归技术中的一种算法。这是一种用于分析多重共线性数据的技术。通过在回归计算中增加一定程度的偏差,可以减少标准误差。净效应将是给出更可靠的计算。

1.1.6 .拉索回归:-

套索回归是一种使用收缩的线性回归。收缩是指数据值向中心点收缩,如平均值。lasso 程序鼓励简单、稀疏的模型(即参数较少的模型)。这种特殊类型的回归非常适合于显示高度多重共线性的模型,或者当您想要自动执行模型选择的某些部分时,如变量选择/参数消除。

1.1.7 .弹性网回归:-

弹性网回归将 L1 范数(LASSO)和 L2 范数(ridge regression)结合到广义线性回归的惩罚模型中,并赋予其稀疏性(L1)和稳健性(L2)特性。

贝叶斯回归:-

贝叶斯回归允许一种合理的自然机制在数据不足或分布不良的情况下生存。它将使您能够将系数放在先验和噪声上,以便先验可以在缺少数据的情况下接管。更重要的是,你可以问贝叶斯回归,它对数据拟合的哪些部分(如果有的话)是有信心的,哪些部分是非常不确定的。

1.1.9 .决策树回归

决策树从回归模型中构建一个类似树结构的表单。它将数据分解成更小的子集,同时相关的决策树也在逐步发展。结果是一个有决策节点和叶节点的树。

1.1.10 .随机森林回归

随机森林也是回归技术中使用的算法之一,它非常灵活,易于使用机器学习算法,即使没有超参数调整。此外,该算法由于其简单性以及可用于回归和分类任务的事实而被广泛使用。它构建的森林是决策树的集合,大部分时间是用“打包”方法训练的。

1.2 .分类:-

分类是一种监督学习类型,其中标记的数据可以使用,并且该数据用于以非连续的形式进行预测。信息的输出并不总是连续的,图形也是非线性的。在分类技术中,算法从提供给它的数据输入中学习,然后使用这种学习来分类新的观察。这个数据集可能仅仅是两类,也可能是多类。分类问题的一个例子是通过训练不同的垃圾邮件单词或电子邮件的算法来检查电子邮件是否是垃圾邮件。

分类算法类型:-

机器学习中有许多分类算法,用于不同的分类应用。一些主要的分类算法如下-

1.2.1 .逻辑回归/分类:-

逻辑回归属于监督学习的范畴;它通过使用逻辑/sigmoid 函数估计概率来测量与一个或多个自变量分类的因变量之间的关系。逻辑回归一般可以用在因变量是二元或二元的地方。这意味着因变量只能取两个可能的值,如“是或否”、“活的或死的”。

1 . 2 . 2 . k-最近的邻居:-

KNN 算法是分类中最简单的算法之一,也是最常用的学习算法之一。一个对象的多数表决通过它的邻居来分类,目的是分配给它的 k 个最近邻居中最常见的类。它还可以用于回归-输出是对象的值(预测连续值)。该值是其 k 个最近邻居的收益的平均值(或中值)。

1.2.3 .支持向量机

支持向量机是一种分类器,其中的判别分类器由分离超平面形式定义。该算法输出对新例子进行分类的最佳超平面。在二维空间中,该超平面是将平面分成两部分的线,其中每一类位于两侧。

1.2.4 .核心支持向量机:-

核 SVM 算法是用于分类技术的算法之一,它是定义为核的数学函数集。核心的目的是将数据作为输入,并将其转换为所需的形式。不同的 SVM 算法使用不同类型的核函数。这些函数可以是不同的类型。例如线性和非线性函数、多项式函数、径向基函数和 sigmoid 函数。

1.2.5 .朴素贝叶斯

朴素贝叶斯是一种分类技术,它基于贝叶斯定理,假设预测器之间是独立的。简而言之,朴素贝叶斯分类器假定一个类中某个特定特征的存在与任何其他函数的存在无关。朴素贝叶斯模型易于构建,对于大规模数据集尤其有用。

1.2.6 .决策树分类

决策树以树结构的形式建立分类模型。一个相关的决策树逐渐发展,同时它将一个大的数据集分解成更小的子集。最终结果是一个有决策节点和叶节点的树。决策节点(例如,根)具有两个或更多分支。叶节点代表一个分类或决策。树中对应于最佳预测器的第一个决策节点,称为根节点。决策树可以处理分类数据和数值数据。

1.2.7 .随机森林分类:-

随机森林是一种监督学习算法。它创造了一个森林,让它看起来很随意。它构建的木头是一个决策树的集合,它大部分时间用“bagging”方法训练决策树算法,这是一个学习模型的组合,增加了整体结果。

2.无监督学习:-

无监督学习是第二种类型的机器学习,其中未标记的数据用于训练算法,这意味着它用于没有历史标签的数据。显示的内容必须由算法计算出来。目的是探索数据并找到其中的一些结构。在无监督学习中,数据是未标记的,原始信息直接输入到算法中,而无需对数据进行预处理,也无需知道数据的输出,并且数据不能分成训练或测试数据。该算法计算出数据,并根据数据段,用新的标签对数据进行聚类。

Unsupervised Machine Learning

这种学习技术对事务性数据非常有效。例如,它可以识别具有相似属性的客户群,然后在营销活动中以相似的方式对待他们。或者它可以找到区分不同客户群的主要品质。这些算法还用于分割文本主题、推荐项目和识别数据异常值。

无监督学习的类型:-

无监督学习主要分为以下两个部分

2.1 .聚类:-

聚类是一种使用未标记数据的无监督学习,它是将相似的实体分组在一起,然后使用分组的数据进行聚类的过程。这种无监督机器学习技术的目标是找到数据点中的相似性,并将相似的数据点分组在一起,并计算出新数据应该属于哪个聚类。

聚类算法的类型:-

机器学习中有许多聚类算法,用于不同的聚类应用。一些主要的聚类算法如下-

2 . 1 . 1 . k-均值聚类:-

K-Means 聚类是聚类技术中的一种算法,将相似的数据聚在一个类中。K-means 是一种迭代聚类算法,旨在每次迭代中找到局部最大值。它以 K 作为输入开始,这是您想要看到的组数。在你的空间中的任意位置输入 k 个质心。现在,使用欧几里德距离方法计算数据点和质心之间的距离,并将数据点分配到靠近它的聚类中。重新计算聚类中心,作为附属于它的数据点的平均值。重复,直到没有进一步的变化发生。

K-Means Clustering showing 3 clusters

2.1.2 .分层聚类:-

层次聚类是聚类技术中的一种算法,将相似的数据聚集在一个簇中。这是一种建立聚类层次的算法。这种算法首先将所有数据点分配给它们自己的一组。然后将两个最近的组合并到同一个群中。最后,当只剩下一个簇时,该算法终止。首先将每个数据点分配到其束中。现在,使用欧几里德距离找到该组中最近的一对,并将它们合并到单个聚类中。然后计算两个最近的聚类之间的距离,并进行组合,直到所有项目都聚集成一个聚类。

2.2 .降维:-

降维是一种无监督学习,通过降低数据的维度来去除输入中不需要的数据。该技术用于移除数据中不需要的特征。它涉及将一组具有大尺寸的数据转换成具有相同数据和小尺寸的数据的过程。这些技术在解决机器学习问题时使用,以获得更好的特征。

降维算法的类型:-

机器学习中有许多降维算法,适用于不同的降维应用。一些主要的降维算法如下-

2.2.1 .主成分分析

主成分分析是降维算法之一,在这种技术中,它将旧变量转化为一组新变量,这些变量是实变量的线性组合。一组特定的新变量被称为主成分。作为变换的结果,第一个主成分具有最显著的可能方差,并且每个随后的元素在与上述成分正交的约束下具有最高的电势差。仅保留前 m < n 个分量减少了数据维数,同时保留了大部分数据信息,

2.2.2 .线性判别分析

线性判别分析是一种降维算法,它也可以创建原始特征的线性组合。然而,与主成分分析不同,LDA 不能最大化解释方差。相反,它优化了类之间的可分性。LDA 可以提高提取特征的预测性能。此外,LDA 还提供了解决特定障碍的变体。

2.2.3 .核心主成分分析:-

核主成分分析是降维算法之一,被转换为新集合变量的变量是原始变量的非线性组合,这意味着非线性版本的主成分分析,称为核主成分分析(KPCA)。它能够捕捉部分高阶统计量,从而从原始数据集中提供更多的信息。

3.强化学习:-

强化学习是第三种类型的机器学习,其中没有原始数据作为输入,而是强化学习算法必须自己找出情况。强化学习常用于机器人、游戏和导航。通过强化学习,算法通过反复试验发现哪些行为产生了最大的回报。这种类型的培训有三个主要组成部分,即可以描述为学习者或决策者的代理,描述为代理交互的一切的环境,以及代表代理可以做什么的动作。

Reinforcement Learning

目标是让代理采取行动,在给定的时间内最大化预期回报。遵循一个好的策略,代理将更快地达到目标。所以强化学习的目的是学习最佳方案。

强化学习算法的类型:-

机器学习中有许多强化学习算法,适用于不同的强化学习应用。一些主要的算法如下-

3.1 . q-学习:-

Q-learning 是强化学习的算法之一,其中代理试图从其与环境的通信历史中学习最优策略。一个代理人的记录是一个状态-行动-回报的序列。Q-learning 学习到一个最优策略,不管代理遵循哪个过程,只要它在任何状态下尝试一个动作的次数没有限制。因为无论执行哪种策略,它都会学习到一个最优策略,所以它被称为非策略方法。

3.2 . sarsa[州行动奖励州行动]:-

SARSA 是强化学习的算法之一,其中它确定它刷新到动作值。这是 SARSA 和 Q-learning 实现之间的微小差异,但它会产生深远的影响。SARSA 方法采用另一个参数 action2,这是代理从第二个状态执行的操作。它允许代理显式地找到未来的奖励值。接下来,随之而来的,而不是假设最优行动将使用和最显着的奖励。

3.3 .深度 Q-网络:-

深度 Q 网络是强化学习的算法之一,虽然 Q 学习是一种非常健壮的算法,但它的主要缺陷是缺乏通用性。如果你把 Q-learning 看作一个二维数组(动作空间*状态空间)中的更新数,实际上,它遵循动态编程。它表明对于 Q 学习代理以前没有见过的状态,它不知道采取哪种动作。换句话说,Q-learning agent 不能估计看不见的状态的值。为了解决这个问题,DQN 通过引入神经网络摆脱了二维数组。

3.4 .马尔可夫决策过程:-

**马尔可夫决策过程是强化学习的算法之一,其中包含*一组可能的世界状态 S. *一组模型。*一组可能的动作 A. 一个实值奖励函数 R(s,A)。一个策略马尔可夫决策过程的解。为了实现一个目标,使用了马尔可夫决策过程,这是一个从交互中学习的简单框架。代理人选择动作和对这些动作作出反应的环境,代理人和环境不断地相互作用,并向代理人呈现新的情况。

3.5 . ddpg[深度确定性策略梯度]:-

深度确定性策略梯度是强化学习的算法之一,其中它依赖于具有两个同名组件 actor 和 critic 的 actor-critic 设计。参与者用于调整策略功能的参数𝜽,即决定特定状态的最佳操作。还借鉴了 DQN 的分目标网络和经验回放的思想。对于 DDPG 来说,很少进行勘探作业是另一个问题。对此的解决方案是向参数空间或动作空间添加噪声。

4.半监督学习:-

半监督学习是第四种类型的机器学习,其中两种类型的原始数据都使用。半监督学习是监督和非监督机器学习的混合。半监督学习用于与监督学习相同的目的,其中它采用标记和未标记数据来训练,通常是少量的标记数据和大量的未标记数据。这种类型的学习可以使用分类、回归和预测等方法。

Semi-supervised machine learning

这种技术很有用,原因有几个。首先,为监督学习标记大量数据的过程通常非常耗时和昂贵。此外,过多的标签会给模型带来人为偏见。这意味着在训练过程中包含大量未标记的数据有助于提高最终模型的准确性,同时减少构建模型所需的时间和成本。

机器学习的应用

机器学习在各个领域都有很多用途,其中一些领域包括医疗、国防、技术、金融、安全等。这些领域涉及监督学习、非监督学习和强化学习的不同应用。这些最大似然算法使用的一些领域如下-

这个博客是为那些想在机器学习领域起步的初学者而写的,他们需要学习机器学习的所有知识或基础知识,比如什么是机器学习,它的类型,一些重要的算法以及它是如何工作的。

网络罪犯的机器学习 101

原文:https://towardsdatascience.com/machine-learning-for-cybercriminals-a46798a8c268?source=collection_archive---------4-----------------------

ID 78201212 © Juan Moyano | Dreamstime.com

机器学习(ML)和人工智能(AI)正在网络安全和其他技术领域掀起风暴,你可以很容易地找到大量关于防御和网络攻击两个阵营使用 ML 的信息。

更重要的是,AI 也不能免疫攻击,你可以在这里阅读我的新文章。

将机器学习用于网络攻击仍不明确。然而,2016 年,美国情报界对人工智能的部署提出了担忧,对网络安全构成了潜在威胁。最近的发现证明了机器学习如何被网络犯罪分子用于更高级、更快和更便宜的攻击。

虽然我以前的文章“网络安全的机器学习 101 ”详细介绍了防御的人工智能,但现在是时候轮到网络罪犯的机器学习了。在这里,我对恶意网络空间中机器学习部署的可能或现有方法的信息进行了系统化。本文旨在帮助信息安全团队为即将到来的威胁做好准备。

网络罪犯的任务

攻击者的活动分为 5 组机器学习可以解决的高级任务。

  1. 信息收集——为攻击做准备;
  2. 模仿——试图模仿知己;
  3. 未经授权的访问—绕过限制获得对某些资源或用户帐户的访问权;
  4. 攻击——执行恶意软件或 DDoS 等实际攻击;
  5. 自动化—自动化开发和后期开发。

用于信息收集的机器学习

无论受害者人数多少,信息收集都是每一次网络攻击的第一步。你收集的信息越多,你成功的前景就越好。

信息可以按科目分组整理,可以线上收集,也可以线下收集。信息可以指人或资产。让我们看看所有这些类别。

ML 用于收集网上人们的信息

在网络钓鱼或感染准备的情况下,黑客可以使用分类算法将潜在受害者描述为属于相关组。这意味着在收集了数千封电子邮件后,黑客只向那些点击链接的人发送恶意软件。因此,攻击者减少了及早发现计划攻击的机会。许多因素可能有助于此。例如,黑客可以将写博客的社交网站用户与关注“食物和猫”话题的用户区分开来。后一组人可能没有意识到威胁。

在这种情况下,除了 NLP 分析之外,还可以使用从 K-means 和随机森林到神经网络的各种聚类和分类方法,这些方法应该应用于受害者在社交网络上的帖子。

其他类型的分类可以与受害者的偿付能力有关。第一个受害者检测算法将针对穿着品牌服装的用户,例如,穿着巴黎世家鞋和最新古驰包在私人飞机上拍照的孩子。

这是网络罪犯没有特定目标的信息收集的一个例子。如果攻击者认识受害者并有他或她的照片,ML 可以进一步协助。通过应用图像识别工具,很容易检测社交媒体账户。Trustwave 已经通过其名为 Social Mapper 的工具迈出了自动化的第一步,该工具旨在不同的社交媒体平台中搜索一个人。这个解决方案使用谷歌图片搜索。

我敢打赌,类似于真实图像识别的功能很快就会被开发出来。

ML 用于收集有关在线 IT 资产的信息

有针对性的攻击的信息收集处理一个受害者和复杂的基础设施。目标是收集尽可能多的关于这个基础设施的信息。

这个想法是自动检查,包括收集有关网络的信息。虽然网络扫描器和嗅探器等现有工具能够分析传统网络,但基于软件定义网络(SDN)的新一代网络过于复杂。这就是机器学习可以帮助对手的地方。一个鲜为人知但很有用的了解你的敌人 (KYE)攻击允许秘密收集关于目标 SDN 网络配置的情报,这是将机器学习应用于信息收集任务的一个相关示例。黑客可以收集这些信息,范围从安全工具和网络虚拟化参数的配置到服务质量(QoS)等一般网络策略。攻击者可以通过分析来自一个网络设备的规则被推入网络的条件以及规则的类型,推断出关于网络配置的敏感信息。

在探测阶段,攻击者试图在特定交换机上触发流量规则的安装。探测流量的具体特征取决于黑客想要接收的信息。

在下一阶段,攻击者将分析探测阶段生成的探测流量与安装的相应流量规则之间的相关性。他或她可以从该分析中推断出针对特定类型的网络流实施了什么网络策略。例如,如果攻击者在探测阶段使用网络扫描工具,他或她就可以发现防御策略是通过过滤网络流量来实现的。手动工作可能需要数周来收集数据,并且仍然需要具有预配置参数的算法,例如,需要多少特定分组来做出决定,因为数量取决于各种因素。在机器学习的帮助下,黑客可以自动完成这一过程。

通常,所有需要大量时间的信息收集任务也可以自动化。举个例子,

DirBuster ,一个用于扫描可用目录和文件的工具,可以通过添加一种遗传算法,LSTMs 或 GANs 来改进,以生成与现有目录更相似的目录名。

ML 用于收集离线用户的信息

如果网络犯罪活动涉及任何身体活动,如进入受保护的建筑物,那么网络攻击者最好能够跟踪保安人员。他们足够幸运,因为现在有了解决办法。

研究人员发现了一种在医院或家中监测患者生命体征的方法,无需可穿戴设备或笨重的哔哔声设备。更重要的是,这种方法可以用来看穿墙壁。在激动人心的 TED 演讲中,他们展示了这个系统。

它捕捉无线信号(如 Wi-Fi)从人体反射回来的反射,为医护人员和患者创建可靠的生命体征记录。它给出了详细的跟踪数据,不仅显示了人是睡着还是醒着,还显示了睡眠的一个阶段。像大多数伟大的发明一样,这种设备也可以用于恶意的目的。想象一下,网络罪犯如何能够使用这种设备来检查安全警卫。

ML 用于收集关于离线资产的信息

当想到离线收集有关 IT 资产的信息时,首先想到的是在建筑物内找到摄像机和其他检测设备。所有这些设备都会产生信号,如果我们用这些符号的例子训练某种算法,就有可能检测到它们。

保护

如何保护自己不成为受害者?不言而喻,您的个人信息不得公开。所以不要在社交网络上发布太多关于你自己的信息。这是一件很琐碎但很重要的事情。至于人身攻击,不幸的是,measuresю.没有保护措施目前,攻击的类型只是理论上的。

模仿机器学习

冒充允许网络罪犯根据通信渠道和需要以不同的方式攻击受害者。攻击者能够在发送电子邮件或使用社交工程后,说服受害者点击带有漏洞或恶意软件的链接。因此,即使是打个电话也被认为是一种冒充的手段。假冒分为 3 种类型的网络活动:垃圾邮件,网络钓鱼和欺骗。

垃圾邮件中的机器学习假冒

垃圾邮件是机器学习用于网络安全服务的最古老的领域之一。然而,这可能是最先涉及到 ML 传播网络攻击的领域之一。网络罪犯可以训练一个神经网络来创建垃圾邮件,而不是手动生成垃圾邮件,这不会引起怀疑。

然而,在处理电子邮件垃圾邮件时,很难模仿用户。如果你在电子邮件中代表公司的管理员要求员工更改密码或下载更新,你可能无法以完全相同的方式书写。除非你看到这位管理员写的一堆邮件,否则你无法复制这种风格。至于今天越来越受欢迎的信使,模仿人类甚至更容易。

网络钓鱼中用于冒充的机器学习

与电子邮件网络钓鱼相比,社交媒体网络钓鱼的最大优势是公开性或容易获取个人信息。你可以通过阅读用户的帖子来监控和了解用户的行为。这一想法在最新的研究“将数据科学武器化用于社会工程自动化 Twitter 上的 E2E 鱼叉式网络钓鱼 —自动化e2eT4Twitter 上的鱼叉式网络钓鱼中得到证明,该研究提出了 SNAP_R ,这是一种显著增加网络钓鱼活动的自动化工具。而传统的自动网络钓鱼的准确率为 5%-14%,手动鱼叉式网络钓鱼的准确率为 45%。该方法的准确率在 30%左右,在某些情况下高达 66%,与自动化方法一样。研究人员使用马尔可夫模型根据用户以前的推文生成推文,并将结果与递归神经网络进行比较,特别是 LSTM。LSTM 氏症提供了更高的准确性,但需要更多的时间进行训练。

欺骗中的机器学习模仿

在人工智能的新时代,公司不仅可以创建假文本,还可以创建假声音或视频。专门从事媒体和视频模仿语音的初创公司 Lyrebird 展示了他们可以制造一个和你说话一模一样的机器人。随着数据量的增长和网络的发展,黑客可以展示更好的结果。我们不知道 Lyrebird 是如何工作的,黑客可能无法根据自己的需要使用这项服务,但他们可以发现更多的开放平台,如谷歌的 WaveNet ,它们也能做到这一点。他们应用生成性对抗网络(GANs)。

照片也可以伪造。最近 Nvidia 的一篇论文介绍了一个工具,可以生成高质量的名人图片。

就在几年前,神经网络生成的视频和图像质量很差,只对研究文章有用。现在,几乎每个人都可以制作一个假视频,上面有名人或世界知名的政治家说他们从未说过的话或做他们从未做过的事(例如,你不会相信奥巴马在这个视频中说了什么)。它可以在公开可用的工具的帮助下实现,如 DeepFake

假货无处不在,这个问题越来越严重。下一步是什么?假公司?我们已经看过《T4》的第五集了。一个家伙用猫途鹰的假评论创建了一个假餐馆。手动操作并不容易,但人工智能可以帮助生成假账户。你所需要的只是训练人工智能,以便自动创建虚假资产和公司。想象一下,假城市及其新闻机构使用人工智能来创建新闻挂钩,以维持这个或那个议程。

保护

虽然听起来有争议,但假货是真正的问题。幸运的是,有一些有前途的举措。国防部展示了第一个工具,它能够检测深度伪造。有个有趣的特点——假视频里人脸不眨眼。

AI 基金会在这一领域采取了另一项举措。这个名为 Reality Defender 的项目旨在通过使用一个浏览器插件来保护用户免受假新闻的侵害。

至于网络钓鱼,对于社交媒体账户中的网络钓鱼,最可行的建议是检查并记录通过其他渠道和信使发送可疑消息的用户。他们的几个账户同时受损的可能性很小。

针对未授权访问的机器学习

获得未经授权的访问是一个广泛的话题,但机器学习至少可以在两个最常见的领域发挥作用。这些是验证码旁路和密码暴力。

验证码旁路的机器学习

模拟之后的下一个阶段是获取对用户帐户的未授权访问。

如果网络罪犯需要获得对用户会话的未授权访问,显而易见的方法是破坏帐户。对于大规模黑客攻击来说,令人讨厌的事情之一就是绕过验证码。许多计算机程序可以解决简单的验证码测试,但最复杂的部分是对象分割。

有许多研究论文描述了验证码旁路方法。2012 年 6 月 27 日,Claudia Cruz、Fernando Uceda 和 Leobardo Reyes 发表了机器学习的第一个例子。他们使用支持向量机(SVM)方法破解了运行在 reCAPTCHA 图像上的系统,准确率达到 82%。所有的验证码机制都得到了显著的改进。然而,随后出现了一波论文,他们利用深度学习方法破解 CAPTCHA。

2016 年,发表了一篇文章,详细介绍了如何使用深度学习以 92%的准确率破解 simple-captcha。

另一项研究使用了图像识别的最新进展之一——具有 34 层的深度残差网络来破解印度流行网站 IRCTC 的验证码,准确率也达到 95–98%。这些文章大多采用基于字符的验证码。

一篇最鼓舞人心的论文在黑帽会议上发表。该研究论文名为“我是机器人”。他们曾经破解过最新的语义图像验证码,比较过各种机器学习算法。该论文承诺破解谷歌 reCAPTCHA 的准确率为 98%。

更糟糕的是,一篇新文章指出,科学家警告即将出现的 100%验证码旁路方法。

针对密码暴力的机器学习

网络犯罪分子可能在机器学习的帮助下发现优势的另一个领域是密码暴力。

马尔可夫模型在 2005 年首次被用于生成密码“猜测”,远在深度学习成为热门话题之前。如果你熟悉当前的神经网络和 LSTM,你可能听说过基于训练文本生成文本的网络。如果你给网络一个莎士比亚的作品,它会基于它创建一个新的文本,新生成的文本看起来就像是莎士比亚写的。同样的想法也可以用于生成密码。如果你可以用最常见的密码训练一个网络,它就会产生很多类似的密码。研究人员采用了这种方法,应用于密码,并收到了积极的结果,这比传统的突变更好地创建了密码列表,如将字母改为符号,例如从“s”改为“$”。

另一种方法在论文“ PassGAN:密码猜测的深度学习方法中提到,研究人员使用 GAN 来生成密码。gan 是由两个网络组成的特殊类型的神经网络。一个通常被称为生成性的,另一个是歧视性的。一个是生成对立的例子,另一个是测试这个例子是否真实。其核心思想是训练基于真实密码数据的网络,这些数据来自最近的数据泄露事件。在公布了由 14 亿密码组成的最大数据库之后,这个想法看起来对网络罪犯很有希望。

保护

你如何保护自己?物体识别验证码已经死了。如果你为你的网站选择一个验证码,最好试试 MathCaptcha 或者它的替代品。其次,使用复杂的密码,排除简单的。避免数据库中的那些。唯一安全的随机密码是那些建立在短句基础上并混合了特殊字符的密码,或者是保存在密码管理工具中的完全随机的字符串。

针对攻击的机器学习

网络罪犯想要使用机器学习的下一个领域是攻击本身。总的来说,有 3 个目标:间谍,破坏和欺诈。大多数情况下,它们都是通过恶意软件、间谍软件、勒索软件或任何其他类型的恶意程序来执行的,用户会因网络钓鱼而下载这些程序。攻击者也因为漏洞而上传。除了 DoS 攻击,还有一些不太常见的攻击,比如 crowdturfing。这些攻击比传统攻击更能从 ML 中获益。

用于漏洞发现的机器学习

最常见的漏洞发现方法之一是模糊化。这意味着在应用程序中放入一个随机输入,并监视它是否会崩溃。有 2 个步骤需要自动化和人工智能的帮助。首先是实例的生成。通常如果你拿一个 PDF 文档,研究人员会通过随机改变一些字段来编辑这个文档。使用更智能的方法来产生突变,可以大大加快寻找会使应用程序崩溃的新文档示例的过程。

也可以实现类似 AlphaGo 使用的强化学习方法。如果 AlphaGO 模型在游戏中发现了故障,它也可以帮助发现安全问题。漏洞发现之后是崩溃分析。每一项分析都需要大量的人工工作。如果有可能训练一个模型来选择更相关的崩溃,将会节省时间和精力。此外,它使漏洞发现的成本大大降低。

在这里你可以找到更多关于机器学习的模糊化

针对恶意软件/间谍软件/勒索软件的机器学习

用于恶意软件保护的机器学习可能是网络安全领域第一个商业上成功的 ML 实现。有几十篇科学论文描述了如何利用人工智能(AI)检测恶意软件的不同技术。

网络罪犯如何部署机器学习来创建恶意软件?人们可以尝试使用强化学习。网络罪犯可以获取恶意软件示例,对其进行更改,发送到 VirusTotal,检查结果,进行其他更改,等等。

或者,面部识别可用于执行有针对性的攻击。DeepLocker 是恶意软件的一个例子,它隐藏自己,直到特定事件发生,例如,识别系统检测到目标人脸。

拒绝服务攻击的机器学习

检测 DDoS 攻击最常用的方法是什么?在实施这种攻击的网络数据包中寻找常见模式。DDoS 防护总是像一场猫捉老鼠的游戏。攻击者试图通过伪造每个字段来使 DDoS 数据包与众不同,而防御者试图在欺骗的请求中找出共同的模式。在 AI 的帮助下,攻击者可以生成非常接近真实用户动作的 DDoS 数据包。它们可以嗅探正常流量,然后训练神经网络(如 GAN)发送合法数据包。在 DDoS 攻击中使用 AI 可以给这个领域带来显著的改变。

面向人群漫游的机器学习

大众追随,产生包括假新闻在内的假信息。在机器学习的帮助下,网络犯罪分子可以降低这些攻击的成本,并使其自动化。

在 2017 年 9 月发表的“在线评论系统中的自动众筹攻击和防御”研究中,介绍了该系统在 Yelp 上生成虚假评论的例子。优势不仅仅是无法检测到的 5 星评论,而是比人类写的评论得分更高的评论。

简单来说,众筹就是对众包服务的恶意使用。例如,攻击者为竞争对手的负面在线评论付费。这些评论经常未被发现,因为是真人写的,自动化工具在寻找软件攻击者。

假新闻只是众筹的一个例子。Max Tagmark 的书《生活 3.0 》提到了另一个例子。有一个虚构的故事,一组黑客创造了人工智能,它能够在亚马逊土耳其机器人执行简单的工作任务。最重要的是,在亚马逊网络服务上购买这种人工智能硬件的成本比它在亚马逊 Mturk 上赚的钱要少。他们用了很短的时间就几乎让亚马逊破产了。

用于网络犯罪自动化的机器学习

有经验的黑客可以使用机器学习来自动化各个领域的任务。几乎不可能预测什么时候和什么东西会被自动化,但是要知道网络犯罪组织有数百名成员,这需要不同类型的软件,如支持门户或支持机器人。

至于具体的网络犯罪任务,有一个新术语——Hivenet——代表智能僵尸网络。这个想法是,如果网络罪犯手动管理僵尸网络,艾滋病毒可以有一种大脑来达到特定的事件,并根据它们改变行为。多个机器人将坐在设备中,并根据任务决定谁将使用受害者的资源。这就像是生活在有机体中的一系列寄生虫。

结论

上面的想法只是黑客可以使用机器学习的一些例子。

除了使用更安全的密码和在跟踪第三方网站时更加小心之外,我只能建议关注基于 ML 的安全系统,以便领先于犯罪者。

一两年前,每个人都对机器学习的使用持怀疑态度。今天的研究发现和它在产品中的实现证明了 ML 实际上是有效的,并且它会一直存在下去。否则,黑客将开始向前看,并从 ML 中受益。

如果你喜欢我的文章,请鼓掌,并订阅以了解更多关于机器学习和网络安全的不同方面。干杯。

网络安全的机器学习 101

原文:https://towardsdatascience.com/machine-learning-for-cybersecurity-101-7822b802790b?source=collection_archive---------1-----------------------

ID 52033957 © Everett Collection Inc. | Dreamstime.com

大量的文章涵盖了用于网络安全的机器学习以及保护我们免受网络攻击的能力。尽管如此,仔细研究人工智能(AI)、机器学习(ML)和深度学习(DL)现在如何帮助网络安全,以及这种炒作到底是怎么回事,仍然很重要。

首先,我要让你失望了。不幸的是,与图像识别或自然语言处理这两个机器学习蓬勃发展的领域相比,机器学习永远不会成为网络安全的银弹。总会有人试图找到系统或 ML 算法的弱点,并绕过安全机制。更糟糕的是,现在黑客能够使用机器学习来实现他们所有的邪恶企图。

更重要的是,AI 也不能免疫攻击,你可以在这里阅读我的新文章。

幸运的是,机器学习可以帮助解决最常见的任务,包括回归、预测和分类。在数据量极大,网络安全人才匮乏的时代,ML 似乎是唯一的解决方案。

本文是一篇介绍性文章,旨在从技术上理解应用于网络安全的 ML 研究的当前进展和未来方向。

机器学习术语

不要把任何东西都叫做“人工智能”——学习术语。

  • AI(人工智能)——一个宽泛的概念。一门使事物变得智能的科学,或者换句话说,由机器执行的人工任务(例如,视觉识别、NLP 等)。).最主要的一点是,AI 不完全是机器学习或智能的东西。它可以是像边缘检测一样安装在你的机器人吸尘器中的经典程序。粗略地说,人工智能是一种以某种方式执行人类任务的东西。
  • ML(机器学习)——人工智能的一种方法*(只是许多方法中的一种),它使用一个能够从经验中学习的系统。它不仅旨在实现人工智能目标(例如,复制人类行为),而且还可以减少简单和困难任务(如股票价格预测)的工作量和/或时间。换句话说,ML 是一个通过使用例子而不是通过编程来识别模式的系统。如果你的系统不断学习,基于数据而不是算法做出决策,并改变其行为,这就是机器学习。*
  • DL(深度学习)——一套技术用于实现机器学习,识别模式的模式——类似图像识别。该系统主要识别物体边缘、结构、物体类型,然后识别物体本身。关键是深度学习并不完全是深度神经网络。还有其他算法,它们被改进以学习模式的模式,例如强化任务中的深度 Q 学习。

这些定义表明,网络安全领域主要是指机器学习(而不是人工智能)。很大一部分任务与人类无关。

机器学习意味着根据你所拥有的数据,使用一种方法和特定的方法来解决某些任务。

大多数任务都是最常见任务的子类,如下所述。

  • 回归(或预测)-根据以前的值预测下一个值的任务。
  • 分类——将事物分成不同类别的任务。
  • 聚类-类似于分类,但类别未知,根据相似性对事物进行分组。
  • 关联规则学习(或推荐)——基于以前的经验推荐某些东西的任务。
  • 降维——或概括,在多个例子中搜索共同的和最重要的特征的任务。
  • 生成模型——基于先前的分布知识创建某物的任务。

除了这些任务之外,还有不同的方法。某些任务只能使用一种方法,但其他任务可以有多种方法。

解决 ML 任务的方法

过去的趋势:

  • 监督学习。任务驱动法。首先,你应该给数据贴上标签,就像给一个模型提供可执行文件的例子,然后说这个文件是不是恶意软件。基于这些标记的数据,模型可以对新数据做出决策。缺点是标记数据的限制。
  • ***汇编学习。*这是监督学习的扩展,同时混合不同的简单模型来解决任务。组合简单模型有不同的方法。

当前趋势

  • ***无监督学习。*数据驱动方法。当没有带标签的数据时,可以使用该方法,并且模型应该基于属性以某种方式自己标记它。通常,它旨在发现数据中的异常,通常被认为是更强大的,因为几乎不可能标记所有数据。目前,它的工作不如监督方法精确。
  • ***半监督学习。*顾名思义,当有一些标记数据时,半监督学习试图结合监督和非监督方法的优点。

未来趋势(嗯,可能)

  • 强化学习。当行为应该以某种方式对变化的环境做出反应时,可以使用环境驱动的方法。这就像一个孩子在通过试错来学习环境。
  • 主动学习。它更像是强化学习的一个子类,可能会成长为一个独立的类。主动学习就像一个老师,除了环境变化之外,还可以帮助纠正错误和行为。

机器学习任务和网络安全

让我们看看可用于解决机器学习任务的不同方法的示例,以及它们如何与网络安全任务相关联。

回归

回归(或预测)很简单。利用关于现有数据的知识来了解新数据。以房价预测为例。在网络安全中,它可以应用于欺诈检测。特征(例如,可疑交易的总量、位置等。)确定欺诈行为的可能性。

关于回归的技术方面,所有的方法都可以分为两大类:机器学习和深度学习。其他任务也是如此。

对于每个任务,都有 ML 和 DL 方法的例子。

回归的机器学习

下面是可用于回归任务的机器学习方法的简短列表(各有优缺点)。

  • 线性回归
  • 多项式回归
  • 里脊回归
  • 决策树
  • 支持向量回归机
  • 随机森林

你可以在这里找到每种方法的详细解释。

用于回归的深度学习

对于回归任务,可以使用以下深度学习模型:

  • 人工神经网络
  • 递归神经网络(RNN)
  • 神经图灵机(NTM)
  • 可微分神经计算机

分类

分类也很简单。想象你有两堆按类型分类的图片(例如,狗和猫)。在网络安全方面,一个将垃圾邮件与其他消息分开的垃圾邮件过滤器可以作为一个例子。垃圾邮件过滤器可能是应用于网络安全任务的第一个 ML 方法。

监督学习方法通常用于分类,其中某些组的例子是已知的。所有的类都应该在开始时定义。

下面是与算法相关的列表。

分类的机器学习

  • 物流回收
  • K-最近邻
  • 支持向量机(SVM)
  • KernelSVM
  • 朴素贝叶斯
  • 决策树分类
  • 随机森林分类

人们认为像 SVM 和随机森林这样的方法效果最好。请记住,没有放之四海而皆准的规则,它们可能不适合您的任务。

用于分类的深度学习

  • 人工神经网络
  • 卷积神经网络

如果你有更多的数据,深度学习方法会更好地工作。但是它们会消耗更多的资源,尤其是当您计划在生产中使用它并定期重新训练系统的时候。

使聚集

聚类类似于分类,唯一但主要的区别是。关于数据类别的信息是未知的。不知道这些数据是否可以分类。这就是无监督学习。

据称,聚类的最佳任务是取证分析。事件的原因、过程和后果是模糊的。需要对所有活动进行分类以发现异常。恶意软件分析的解决方案(即恶意软件防护安全电子邮件网关)可以实现它来将合法文件与离群值分开。

另一个可以应用聚类的有趣领域是用户行为分析。在这种情况下,应用程序用户聚集在一起,以便可以查看他们是否应该属于特定的组。

通常,聚类并不用于解决网络安全中的特定任务,因为它更像是管道中的子任务之一(例如,将用户分组到不同的组中以调整风险值)。

用于聚类的机器学习

  • k-最近邻(KNN)
  • k 均值
  • 混合模型
  • DBSCn
  • 贝叶斯定理的
  • 高斯混合模型
  • 结块的
  • 均值漂移

用于聚类的深度学习

  • 自组织映射(SOM)或 Kohonen 网络

关联规则学习(推荐系统)

网飞和 SoundCloud 根据你的电影或音乐偏好推荐电影或歌曲。在网络安全中,这一原则可主要用于事件响应。如果公司面临一波事故并提供各种类型的响应,则系统会学习特定事故的响应类型(例如,将其标记为误报、更改风险值、运行调查)。风险管理解决方案也可以带来好处,如果它们自动为新的漏洞或基于其描述的错误配置分配风险值。

有用于解决推荐任务的算法。

用于关联规则学习的机器学习

  • 推测的
  • 尤克拉特
  • FP-增长

用于关联规则学习的深度学习

  • 深度受限玻尔兹曼机(RBM)
  • 深度信仰网络(DBN)
  • 堆叠自动编码器

最新的推荐系统基于受限玻尔兹曼机器及其更新版本,如有前途的深度信念网络。

降维

降维或概化没有分类流行,但是如果你处理具有未标记数据和许多潜在特征的复杂系统,降维或概化是必要的。您不能应用聚类,因为典型方法会限制要素的数量或者不起作用。降维可以帮助处理它,削减不必要的特征。与聚类一样,降维通常是更复杂模型中的任务之一。至于网络安全任务,降维在人脸检测解决方案中很常见——你在 IPhone 中使用的那种。

机器学习降维

  • 主成分分析
  • 奇异值分解
  • T 分布随机邻居嵌入(T-SNE)
  • 线性判别分析(LDA)
  • 潜在语义分析(LSA)
  • 因素分析
  • 独立成分分析
  • 非负矩阵分解(NMF)

你可以在这里找到更多关于降维的信息(包括对这些方法及其特性的一般描述)。

生成模型

生成模型的任务与上述不同。虽然这些任务处理现有的信息和相关的决策,但是生成模型被设计成基于先前的决策来模拟实际数据(而不是决策)。

攻击性网络安全的简单任务是生成输入参数列表,以测试特定应用程序的注入漏洞。

或者,您可以拥有一个用于 web 应用程序的漏洞扫描工具。它的一个模块是测试文件的未授权访问。这些测试能够改变现有的文件名来识别新的文件名。例如,如果一个爬虫程序检测到一个名为 login.php 的文件,最好通过尝试类似 login_1.php、login_backup.php、login.php.2017 的名称来检查任何备份的存在或测试其副本。生成模型擅长于此。

机器学习生成模型

  • 马尔可夫链
  • 遗传算法

深度学习生成模型

  • 可变自动编码器
  • 生成对抗网络
  • 玻尔兹曼机器

最近,GANs 展示了令人印象深刻的成果。他们成功模仿了一段视频。想象一下它是如何被用来生成模糊化的例子的。

网络安全任务和机器学习

与其看 ML 任务并试图将其应用于网络安全,不如看看常见的网络安全任务和机器学习机会。有三个维度(为什么、做什么、怎么做)。

第一个维度是目标或任务(例如,检测威胁、预测攻击等。).根据 Gartner 的 PPDR 模型,所有安全任务可以分为五类:

  • 预测;
  • 预防;
  • 检测;
  • 回应;
  • 监控。

第二个维度是技术层和“什么”问题的答案(例如,在哪个级别监控问题)。以下是该维度的层列表:

  • 网络(网络流量分析和入侵检测);
  • 端点(反恶意软件);
  • 应用程序(WAF 或数据库防火墙);
  • 用户(UBA);
  • 流程(反欺诈)。

每一层都有不同的子类别。例如,网络安全可以是有线的、无线的或云的。假设你不能用相同的超参数在两个领域应用相同的算法,至少在不久的将来。原因是缺乏数据和算法来找到三个领域更好的依赖关系,以便有可能将一种算法改变为不同的色调。

第三个维度是“如何”的问题(例如,如何检查特定区域的安全性):

  • 实时传输中;
  • 休息时;
  • 历史上;
  • 等等。

例如,如果您关注端点保护,寻找入侵,您可以监控可执行文件的进程,进行静态二进制分析,分析该端点中的操作历史,等等。

有些任务应该在三维空间中解决。有时,某些任务的某些维度没有值。方法在一个维度上可以是相同的。尽管如此,网络安全任务这一三维空间的每一个特定点都有其复杂性。

很难一一详述,所以让我们把重点放在最重要的方面——技术层。从这个角度看网络安全解决方案。

用于网络保护的机器学习

网络保护不是一个单一的领域,而是一套不同的解决方案,侧重于一种协议,如以太网、无线、SCADA,甚至虚拟网络,如 SDNs。

网络保护是指众所周知的入侵检测系统(IDS)解决方案。他们中的一些人在几年前使用了一种 ML,主要处理基于签名的方法。

网络安全中的 ML 意味着称为网络流量分析(NTA)的新解决方案,旨在深入分析每一层的所有流量,并检测攻击和异常。

ML 在这里能帮上什么忙?有一些例子:

  • 回归预测网络数据包参数,并与正常参数进行比较;
  • 分类以识别不同类别的网络攻击,例如扫描和欺骗;
  • 用于法庭分析的聚类。

你可以在学术研究论文中找到至少 10 篇描述不同方法的论文。

更多资源:

用于端点保护的机器学习

新一代反病毒是端点检测和响应。最好了解可执行文件或流程行为中的特性。请记住,如果您在端点层处理机器学习,您的解决方案可能会因端点的类型而异(例如,工作站、服务器、容器、云实例、移动设备、PLC、物联网设备)。每个端点都有自己的特点,但任务是共同的:

  • 回归预测可执行过程的下一次系统调用,并与实际调用进行比较;
  • 分类将程序分为恶意软件、间谍软件和勒索软件等类别;
  • 安全电子邮件网关上的恶意软件防护群集(例如,将合法文件附件与异常值分开)。

关于终端防护和恶意软件的学术论文越来越受欢迎。这里有几个例子:

面向应用安全的机器学习

顺便说一下,应用程序安全性是我最喜欢的领域,尤其是 ERP 安全性。

在 app 安全中 ML 用在哪里?— WAFs 或静态和动态代码分析。提醒您,应用程序安全性可能会有所不同。有 web 应用、数据库、ERP 系统、SaaS 应用、微服务等。在不久的将来,几乎不可能建立一个通用的 ML 模型来有效地应对所有威胁。然而,你可以尝试解决一些任务。

以下是您可以利用机器学习实现应用安全的示例:

  • 回归以检测 HTTP 请求中的异常(例如,XXE 和 SSRF 攻击以及 auth bypass);
  • 分类检测已知类型的攻击,如注射(SQLi、XSS、RCE 等。);
  • 聚类用户活动以检测 DDOS 攻击和大规模利用。

更多资源提供使用 ML 实现应用安全的想法 :

针对用户行为的机器学习

这一领域始于安全信息和事件管理(SIEM)。

如果配置得当,SIEM 能够解决许多任务,包括用户行为搜索和 ML。然后,UEBA 解决方案宣布 SIEM 无法处理新的、更高级的攻击类型和持续的行为变化。

市场已经接受了这一观点,即如果从用户层面考虑威胁,就需要一个特殊的解决方案。

然而,即使是 UEBA 工具也不能涵盖与不同用户行为相关的所有事情。有域用户、应用程序用户、SaaS 用户、社交网络、信使和其他应该被监控的帐户。

与侧重于普通攻击和训练分类器的可能性的恶意软件检测不同,用户行为是复杂层和无监督学习问题之一。一般来说,没有带标签的数据集,也不知道要找什么。因此,在用户行为领域,为所有类型的用户创建一个通用算法的任务是棘手的。以下是公司在 ML 的帮助下解决的任务:

  • 回归以检测用户动作中的异常(例如,在异常时间登录);
  • 分类以将不同用户分组用于对等组分析;
  • 聚类以分离用户组并检测异常值。

更多资源:

过程行为的机器学习

过程区域是最后的,但也是最重要的。在处理它时,有必要了解一个业务流程,以便发现一些异常。业务流程可能会有很大的不同。你可以在银行和零售系统中寻找欺诈,或者在制造业中寻找工厂车间。两者完全不同,需要大量的领域知识。在机器学习中,特征工程(你向你的算法表示数据的方式)对于获得结果是至关重要的。同样,所有过程中的特征也不同。

一般来说,流程领域中有一些任务示例:

  • 回归预测下一个用户操作,并检测异常值,如信用卡欺诈;
  • 检测已知欺诈类型的分类;
  • 聚类以比较业务流程并检测异常值。

您可以找到与银行欺诈相关的研究论文,因为 ICS 和 SCADA 系统安全性很少被提及。

更多资源

机器学习网络安全书籍

如果你想了解更多关于网络安全中的机器学习,这里有一些书可以帮助你:

  • 机器学习和安全O ' Reilly 著(2018 年 1 月)——目前为止关于这个主题的最好的书,但深度学习的例子很少,大多是一般的机器学习

  • 恶意软件数据科学:攻击检测和归因(2018 年 9 月)——正如标题所示,这本书专注于恶意软件。在我写这篇文章的时候它刚刚发布,所以到目前为止我还不能给出任何反馈。但我敢打赌,这是终端保护团队每个人的必备技能。

结论

还剩下更多的区域。我已经概述了基本情况。一方面,如果你想保护你的系统,机器学习绝对不是一个万全之策。毫无疑问,可解释性存在许多问题(尤其是深度学习算法),但人类也无法解释自己的决定,对吗?

另一方面,随着数据量的增长和专家数量的减少,ML 是唯一的补救方法。它现在起作用了,很快就会强制执行。最好现在就开始。

请记住,黑客也开始在他们的攻击中使用 ML。我的下一篇文章将揭示攻击者究竟如何利用 ML。

糖尿病的机器学习

原文:https://towardsdatascience.com/machine-learning-for-diabetes-562dd7df4d42?source=collection_archive---------1-----------------------

Photo credit: Pixabay

根据疾病控制和预防中心的数据,现在大约七分之一的美国成年人患有糖尿病。但到 2050 年,这一比例可能会飙升至三分之一。考虑到这一点,这就是我们今天要做的事情:学习如何使用机器学习来帮助我们预测糖尿病。我们开始吧!

数据

糖尿病数据集源自 UCI 机器学习库,可以从这里下载。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inlinediabetes = pd.read_csv('diabetes.csv')
print(diabetes.columns)

指数(['妊娠','血糖','血压','皮肤厚度','胰岛素','身体质量指数','糖尿病血糖','年龄','结果'],dtype= '对象')

diabetes.head()

Figure 1

糖尿病数据集由 768 个数据点组成,每个数据点有 9 个特征:

print("dimension of diabetes data: {}".format(diabetes.shape))

糖尿病数据的维度:(768,9)

“结局”是我们要预测的特征,0 表示没有糖尿病,1 表示有糖尿病。在这 768 个数据点中,500 个被标记为 0,268 个被标记为 1:

print(diabetes.groupby('Outcome').size())

Figure 2

import seaborn as snssns.countplot(diabetes['Outcome'],label="Count")

Figure 3

diabetes.info()

Figure 4

k-最近邻

k-NN 算法可以说是最简单的机器学习算法。构建模型仅包括存储训练数据集。为了对新的数据点进行预测,该算法会在训练数据集中查找最近的数据点,即它的“最近邻居”

首先,让我们调查一下我们是否能够确认模型复杂性和准确性之间的联系:

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(diabetes.loc[:, diabetes.columns != 'Outcome'], diabetes['Outcome'], stratify=diabetes['Outcome'], random_state=66)from sklearn.neighbors import KNeighborsClassifiertraining_accuracy = []
test_accuracy = []
# try n_neighbors from 1 to 10
neighbors_settings = range(1, 11)for n_neighbors in neighbors_settings:
    # build the model
    knn = KNeighborsClassifier(n_neighbors=n_neighbors)
    knn.fit(X_train, y_train)
    # record training set accuracy
    training_accuracy.append(knn.score(X_train, y_train))
    # record test set accuracy
    test_accuracy.append(knn.score(X_test, y_test))plt.plot(neighbors_settings, training_accuracy, label="training accuracy")
plt.plot(neighbors_settings, test_accuracy, label="test accuracy")
plt.ylabel("Accuracy")
plt.xlabel("n_neighbors")
plt.legend()
plt.savefig('knn_compare_model')

Figure 5

上图显示了 y 轴上的训练集和测试集精度与 x 轴上的 n_neighbors 设置的对比。考虑到如果我们选择一个单一的最近邻,对训练集的预测是完美的。但是当考虑更多的邻居时,训练精度下降,这表明使用单个最近邻居会导致模型过于复杂。最好的表现是大约 9 个邻居。

该图建议我们应该选择 n_neighbors=9。我们到了:

knn = KNeighborsClassifier(n_neighbors=9)
knn.fit(X_train, y_train)print('Accuracy of K-NN classifier on training set: {:.2f}'.format(knn.score(X_train, y_train)))
print('Accuracy of K-NN classifier on test set: {:.2f}'.format(knn.score(X_test, y_test)))

K-NN 分类器在训练集上的准确率:0.79

K-NN 分类器在测试集上的准确率:0.78

逻辑回归

逻辑回归是最常见的分类算法之一。

from sklearn.linear_model import LogisticRegressionlogreg = LogisticRegression().fit(X_train, y_train)
print("Training set score: {:.3f}".format(logreg.score(X_train, y_train)))
print("Test set score: {:.3f}".format(logreg.score(X_test, y_test)))

训练集精度:0.781

测试设定精度:0.771

C=1 的默认值提供了 78%的训练准确率和 77%的测试准确率。

logreg001 = LogisticRegression(C=0.01).fit(X_train, y_train)
print("Training set accuracy: {:.3f}".format(logreg001.score(X_train, y_train)))
print("Test set accuracy: {:.3f}".format(logreg001.score(X_test, y_test)))

训练设定精度:0.700

测试设定精度:0.703

使用 C=0.01 会导致训练集和测试集的精确度都较低。

logreg100 = LogisticRegression(C=100).fit(X_train, y_train)
print("Training set accuracy: {:.3f}".format(logreg100.score(X_train, y_train)))
print("Test set accuracy: {:.3f}".format(logreg100.score(X_test, y_test)))

训练集精度:0.785

测试设定精度:0.766

使用 C=100 会导致训练集的精度稍微高一点,而测试集的精度稍微低一点,这证实了正则化程度较低且更复杂的模型可能不会比默认设置概括得更好。

因此,我们应该选择默认值 C=1。

让我们用正则化参数 c 的三种不同设置来可视化模型学习的系数。

更强的正则化(C=0.001)将系数越来越推向零。更仔细地观察该图,我们还可以看到特征“DiabetesPedigreeFunction”,对于 C=100、C=1 和 C=0.001,系数为正。这表明高“糖尿病”特征与样本是“糖尿病”相关,不管我们看的是哪种模型。

diabetes_features = [x for i,x in enumerate(diabetes.columns) if i!=8]plt.figure(figsize=(8,6))
plt.plot(logreg.coef_.T, 'o', label="C=1")
plt.plot(logreg100.coef_.T, '^', label="C=100")
plt.plot(logreg001.coef_.T, 'v', label="C=0.001")
plt.xticks(range(diabetes.shape[1]), diabetes_features, rotation=90)
plt.hlines(0, 0, diabetes.shape[1])
plt.ylim(-5, 5)
plt.xlabel("Feature")
plt.ylabel("Coefficient magnitude")
plt.legend()
plt.savefig('log_coef')

Figure 6

决策图表

from sklearn.tree import DecisionTreeClassifiertree = DecisionTreeClassifier(random_state=0)
tree.fit(X_train, y_train)
print("Accuracy on training set: {:.3f}".format(tree.score(X_train, y_train)))
print("Accuracy on test set: {:.3f}".format(tree.score(X_test, y_test)))

训练集上的精度:1.000

测试集上的精度:0.714

训练集的准确率为 100%,而测试集的准确率要差得多。这表明该树过拟合,不能很好地推广到新数据。因此,我们需要对树进行预修剪。

我们设置 max_depth=3,限制树的深度可以减少过度拟合。这导致训练集的精确度较低,但测试集的精确度有所提高。

tree = DecisionTreeClassifier(max_depth=3, random_state=0)
tree.fit(X_train, y_train)print("Accuracy on training set: {:.3f}".format(tree.score(X_train, y_train)))
print("Accuracy on test set: {:.3f}".format(tree.score(X_test, y_test)))

训练集上的准确率:0.773

测试集精度:0.740

决策树中的特征重要性

特征重要性评定每个特征对于树所做决策的重要性。对于每个特征,它是一个介于 0 和 1 之间的数字,其中 0 表示“完全没有使用”,1 表示“完美地预测了目标”。特征重要性的总和总是 1:

print("Feature importances:\n{}".format(tree.feature_importances_))

特征重要度:[ 0.04554275 0.6830362 0。0.0.0.27142106 0.0.】

然后,我们可以将特性的重要性可视化:

def plot_feature_importances_diabetes(model):
    plt.figure(figsize=(8,6))
    n_features = 8
    plt.barh(range(n_features), model.feature_importances_, align='center')
    plt.yticks(np.arange(n_features), diabetes_features)
    plt.xlabel("Feature importance")
    plt.ylabel("Feature")
    plt.ylim(-1, n_features)plot_feature_importances_diabetes(tree)
plt.savefig('feature_importance')

Figure 7

特征“葡萄糖”是迄今为止最重要的特征。

随机森林

让我们对糖尿病数据集应用一个由 100 棵树组成的随机森林:

from sklearn.ensemble import RandomForestClassifierrf = RandomForestClassifier(n_estimators=100, random_state=0)
rf.fit(X_train, y_train)
print("Accuracy on training set: {:.3f}".format(rf.score(X_train, y_train)))
print("Accuracy on test set: {:.3f}".format(rf.score(X_test, y_test)))

训练集上的精度:1.000

测试集上的精度:0.786

在不调整任何参数的情况下,随机森林给我们提供了 78.6%的准确性,优于逻辑回归模型或单个决策树。但是,我们可以调整 max_features 设置,看看结果是否可以改进。

rf1 = RandomForestClassifier(max_depth=3, n_estimators=100, random_state=0)
rf1.fit(X_train, y_train)
print("Accuracy on training set: {:.3f}".format(rf1.score(X_train, y_train)))
print("Accuracy on test set: {:.3f}".format(rf1.score(X_test, y_test)))

训练集上的精度:0.800

测试集精度:0.755

它没有,这表明随机森林的默认参数工作良好。

随机森林中的特征重要性

plot_feature_importances_diabetes(rf)

Figure 8

与单一决策树类似,随机森林也非常重视“葡萄糖”特征,但它也选择“身体质量指数”作为第二大信息特征。构建随机森林的随机性迫使算法考虑许多可能的解释,结果是随机森林比单棵树捕捉到更广泛的数据图像。

梯度推进

from sklearn.ensemble import GradientBoostingClassifiergb = GradientBoostingClassifier(random_state=0)
gb.fit(X_train, y_train)print("Accuracy on training set: {:.3f}".format(gb.score(X_train, y_train)))
print("Accuracy on test set: {:.3f}".format(gb.score(X_test, y_test)))

在训练集上的精度:0.917

测试集上的精度:0.792

我们可能会过度适应。为了减少过度拟合,我们可以通过限制最大深度来应用更强的预修剪,或者降低学习速率:

gb1 = GradientBoostingClassifier(random_state=0, max_depth=1)
gb1.fit(X_train, y_train)print("Accuracy on training set: {:.3f}".format(gb1.score(X_train, y_train)))
print("Accuracy on test set: {:.3f}".format(gb1.score(X_test, y_test)))

训练集上的精度:0.804

测试集上的精度:0.781

gb2 = GradientBoostingClassifier(random_state=0, learning_rate=0.01)
gb2.fit(X_train, y_train)print("Accuracy on training set: {:.3f}".format(gb2.score(X_train, y_train)))
print("Accuracy on test set: {:.3f}".format(gb2.score(X_test, y_test)))

训练集上的精度:0.802

测试集上的精度:0.776

正如所料,降低模型复杂性的两种方法都降低了训练集的准确性。然而,在这种情况下,这些方法都没有提高测试集的泛化性能。

即使我们对模型并不满意,我们也可以将特性的重要性可视化,以便更深入地了解我们的模型:

plot_feature_importances_diabetes(gb1)

Figure 9

我们可以看到,梯度增强树的特征重要性有点类似于随机森林的特征重要性,在这种情况下,它对所有特征进行加权。

支持向量机

from sklearn.svm import SVCsvc = SVC()
svc.fit(X_train, y_train)print("Accuracy on training set: {:.2f}".format(svc.score(X_train, y_train)))
print("Accuracy on test set: {:.2f}".format(svc.score(X_test, y_test)))

训练集上的精度:1.00

测试集精度:0.65

该模型在很大程度上过度拟合,在训练集上得到满分,而在测试集上只有 65%的准确率。

SVM 要求所有的特征在相似的尺度上变化。我们需要重新调整我们的数据,使所有要素的比例大致相同:

from sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.fit_transform(X_test)svc = SVC()
svc.fit(X_train_scaled, y_train)print("Accuracy on training set: {:.2f}".format(svc.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.2f}".format(svc.score(X_test_scaled, y_test)))

训练集上的精度:0.77

测试集上的精度:0.77

缩放数据产生了巨大的差异!现在,我们实际上是欠拟合的,训练集和测试集的性能非常相似,但不太接近 100%的准确性。从这里开始,我们可以尝试增加 C 或 gamma 来适应更复杂的模型。

svc = SVC(C=1000)
svc.fit(X_train_scaled, y_train)print("Accuracy on training set: {:.3f}".format(
    svc.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.3f}".format(svc.score(X_test_scaled, y_test)))

训练集上的精度:0.790

测试集精度:0.797

这里,增加 C 允许我们改进模型,导致 79.7%的测试集准确性。

深度学习

from sklearn.neural_network import MLPClassifiermlp = MLPClassifier(random_state=42)
mlp.fit(X_train, y_train)print("Accuracy on training set: {:.2f}".format(mlp.score(X_train, y_train)))
print("Accuracy on test set: {:.2f}".format(mlp.score(X_test, y_test)))

训练集上的精度:0.71

测试集精度:0.67

多层感知器(MLP)的准确性不如其他模型,这可能是由于数据的缩放。深度学习算法还期望所有输入特征以相似的方式变化,并且理想情况下具有 0 的均值和 1 的方差。我们必须重新调整我们的数据,以满足这些要求。

from sklearn.preprocessing import StandardScalerscaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.fit_transform(X_test)mlp = MLPClassifier(random_state=0)
mlp.fit(X_train_scaled, y_train)print("Accuracy on training set: {:.3f}".format(
    mlp.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))

训练集上的准确率:0.823

测试集精度:0.802

让我们增加迭代次数:

mlp = MLPClassifier(max_iter=1000, random_state=0)
mlp.fit(X_train_scaled, y_train)print("Accuracy on training set: {:.3f}".format(
    mlp.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))

训练集上的准确率:0.877

测试集上的精度:0.755

增加迭代次数只会提高训练集的性能,而不会提高测试集的性能。

让我们增加 alpha 参数并增加权重的更强正则化:

mlp = MLPClassifier(max_iter=1000, alpha=1, random_state=0)
mlp.fit(X_train_scaled, y_train)print("Accuracy on training set: {:.3f}".format(
    mlp.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))

训练集上的准确率:0.795

测试集精度:0.792

结果是好的,但是我们不能进一步提高测试精度。

因此,我们目前为止最好的模型是缩放后的默认深度学习模型。

最后,我们绘制了在糖尿病数据集上学习的神经网络中第一层权重的热图。

plt.figure(figsize=(20, 5))
plt.imshow(mlp.coefs_[0], interpolation='none', cmap='viridis')
plt.yticks(range(8), diabetes_features)
plt.xlabel("Columns in weight matrix")
plt.ylabel("Input feature")
plt.colorbar()

Figure 10

从热点图中,很难快速指出哪些要素与其他要素相比权重相对较低。

总结

我们练习了一系列用于分类和回归的机器学习模型,它们的优点和缺点是什么,以及如何控制每个模型的复杂性。我们看到,对于许多算法来说,设置正确的参数对于良好的性能非常重要。

我们应该能够知道如何应用、调整和分析我们上面实践的模型。现在轮到你了!尝试将这些算法应用于 scikit-learn 中的内置数据集或您选择的任何数据集。机器学习快乐!

创建这篇文章的源代码可以在这里找到。我将很高兴收到关于上述任何反馈或问题。

参考:用 Python 进行机器学习的介绍

面向所有人的机器学习

原文:https://towardsdatascience.com/machine-learning-for-everyone-46731056d0e6?source=collection_archive---------10-----------------------

What does that mean ?

这个标题回避了问题"那是什么意思?”。好吧,机器学习这个术语可能对你来说很陌生,但是人工智能怎么样,我打赌你听说过。首先,我们只能说机器学习是人工智能的一个子集,它已经在人工智能领域取得了很多进展。用关键词“机器学习”在谷歌上快速搜索会得到以下建议

machine learning for …

我就开门见山了。这是一系列的帖子,涵盖了机器学习最基本的算法之一,即决策树。现在,在你认为这是一个点击诱饵之前,让我告诉你这篇文章根本不会涉及任何数学

管他呢,我为什么要看?

人工智能已经开始改变人类的日常生活方式。我们在网上出现的每一点都与一个人工智能元素有关。智能手机,智能手表,智能家居设备,语音助手(谷歌助手SiriCortana 等)都写满了 AI。

Alexa 这样的语音助手可以在你说话时理解句子,并做出智能回答,并不断适应你的需求。现在,如果你对它们是如何工作的一点也不好奇,那么老实说,你不必跟着读下去。然而,如果你是,这是一个完美的开始。

人工智能是一个更广泛的目标,而机器学习是实现这一目标的手段。它是使用数据来学习行为和做出决策的方法的设计和研究。决策树是一种基本的 ML 算法。

这篇文章试图让你怀疑你在日常生活中一直在使用 ML 概念,尽管是潜意识的。

如何最好地阅读这篇文章

只是坐下来放松一下。这篇文章非常轻松,完全不涉及数学。事实上,我讲了一个 8 岁小孩想要更多巧克力的故事。感兴趣吗?跟着读。

Enough said, let’s get to it.

简的日记

简只是另一个聪明的 8 岁孩子,她喜欢''海绵宝宝',更重要的是 巧克力。 她每天都去她妈妈玛丽那里要巧克力,有时要不止一块。她母亲有时给她巧克力,有时不给*【没有人应该被拒绝巧克力* ☹️】。

简是一个好奇的女孩。她想提前知道她妈妈是否会答应她要巧克力的请求,甚至在问她之前。不知道该怎么办,她去找她的父亲**‘汤姆’**描述她的情况。汤姆被他宝贝女儿的好奇心所激发,想了一会儿。过了一段时间,他打电话给简,并送给她一本日记。他让简写下她向母亲要巧克力时的观察。

汤姆说“简,把你 10 天的观察记录在日记里,然后我们再进一步讨论”

Let’s do it!

第十一天

第十一天,简带着她的小日记本跑来找汤姆。她坐在她父亲旁边的床上说

我做到了,爸爸

“太好了”,汤姆回答道,然后开始打开日记本。

让我们看看你这里有什么

  1. 早上我问妈妈要一块巧克力,她说不要。
  2. 当我得到一块巧克力时,已经是晚上了。她似乎心情很好。
  3. 梅姨走过来时,我要了一块巧克力。明白了。小菜一碟。
  4. 甚至在我今天要巧克力之前,她就说不要。她很刻薄
  5. 我牙痛,所以妈妈带我去看牙医。今天没有巧克力。
  6. 由于牙痛,我甚至没有要巧克力。没有巧克力
  7. 她希望她能给我巧克力。但是我的牙齿会疼,所以不能吃巧克力。不过她很开心。
  8. 大卫叔叔今天来了。尽管牙疼,我今天还是吃了一块巧克力。我猜是小狗脸起了作用。
  9. 我早上又要了一块巧克力。为什么妈妈这么严格。不凉
  10. 过了这么多天,我今天看到妈妈唱歌了。我认为要一块巧克力是个好主意。明白了,耶。

“日记写得很好,简”,汤姆说。

汤姆翻看日记,做了一个小表格,让简更清楚地查看数据。

汤姆:我看了你的日记,并根据你的观察做了一个简单的表格。你觉得我做的表对吗?

简:是的,爸爸。我觉得不错。

汤姆:现在让我们根据你的观察,试着想一想我们是否能预测得到巧克力的可能性。

简:好的,爸爸。

汤姆:那么告诉我,你认为你妈妈什么时候很有可能给你糖果。

**简:**爸爸,这很简单。每当有客人来家里,妈妈会按要求给我一块巧克力。

汤姆:太棒了。你的观察是正确的。现在让我们制作一个新的表格,去掉那些观察值。

汤姆:现在告诉我,她什么时候可能不给你巧克力?

简:我不确定爸爸,但是我想每次我牙痛的时候她都不会给我巧克力。

汤姆:你说得对,简,虽然有一次她在你牙痛的时候给了你一块巧克力,但是在这种情况下,她很可能不会给你任何巧克力。

汤姆:现在我们来看看更新后的表格。我将删除您牙疼并且没有吃巧克力时的所有观察结果。

简:这个看起来不错。哦,等等,我想到了。现在我得看看妈妈的情绪对她给我一块巧克力的影响。

汤姆:很好,继续努力。

简:所以看起来每当妈妈心情好的时候,她都会给我一块巧克力。

汤姆:太棒了,简,太棒了。现在,如果你能总结出你所学到的东西,我会给你一块巧克力。

简:当有客人来访时,我可能会得到一块巧克力。但是,如果没有客人,那就要看两件事了。首先,如果我牙痛,我很可能得不到任何巧克力。第二,如果我有一颗快乐的牙齿,那么就看妈妈给我一块巧克力的心情了。对不对,爸爸。

汤姆:来,拿着你的巧克力!

所以简是吃着巧克力长大的,因为她从 8 岁起就知道什么时候向妈妈要巧克力,而且成功率很高。

但是决策树在哪里呢?

好吧好吧,让我们用简的总结做一个决策树。

摘要

如果你一直读下去,你会发现决策树并没有那么糟糕。考虑到我们有一些数据,它们很容易建立。

我倾向于认为,人类的很多决策都是由这样的决策树或经验法则来决定的,这些决策树或经验法则是我们多年来根据各种经验建立起来的。例如,我们有一个经验法则,不要把手放在火里,因为我们很可能会受伤。

所以你看,机器学习只是在更大范围内玩。这是从更大的数据中挖掘意义,有更多的变量,解决的问题比“简会得到巧克力吗”复杂得多

你仍然不相信机器学习吗?

黑客的机器学习

原文:https://towardsdatascience.com/machine-learning-for-hackers-b60bfb9bbade?source=collection_archive---------2-----------------------

本周,我在 Dev-ES meetup 上做了题为“黑客机器学习入门”的演讲。

机器学习是一个超级酷的学科,其应用范围从语音识别和识别图片中的对象到建造无人驾驶汽车。深度学习是机器学习的一个子领域,在谷歌、脸书和微软等科技公司的商业模式中发挥着至关重要的作用。

我的主要目标是提出一种研究机器学习的方法,这种方法主要是动手操作,并为初学者抽象出大部分数学知识。

许多人对那些尽快告诉他们多元微积分、推断统计学和线性代数是先决条件的书籍和课程感到气馁。即使这些事情(非常)重要,我们也可以通过让他们尽早接触高级代码,然后再向他们展示幕后发生的事情,来让更多的机器学习工程师参与进来。

我们试图通过使用 Python notebooksscikit-learn 作为前几个例子,然后在 TensorFlow 之上使用 TFLearn 来识别手写数字,从而使它尽可能简单。

下面是 GitHub 上的代码*(警告:有些东西可能是葡萄牙语的)*:

[## gabrielcs/机器学习简介

intro-machine-learning -代码来自我在 Dev-ES Meetup #1 上发表的演讲“黑客机器学习入门”

github.com](https://github.com/gabrielcs/intro-machine-learning)

为了吸引更多的人,我确保跟进一些很酷的东西,比如迁移学习、生成模型和敌对网络。

同样,如果您懂葡萄牙语,请随意浏览演示文稿:

如果你也想让我浏览一下博客上的一些代码,请告诉我。

这篇帖子的葡萄牙语版本已经在 Dev-ES 社区博客上 发表

NIPS 的医疗保健机器学习

原文:https://towardsdatascience.com/machine-learning-for-healthcare-at-nips-c96127bbbae?source=collection_archive---------10-----------------------

今年 NIPS 举办了两次医疗保健/医药相关的研讨会。医疗保健的机器学习 (ML4H)和医学成像符合 NIPS。自然,有些人可能会想知道这两者之间的区别。ML4H 专注于将机器学习应用于医疗保健的许多不同领域,包括药物研发、医院运营、精准医疗等。这涉及多种技术,包括计算机视觉、NLP 和时间序列预测。正如我上个月所描述的,MedNIPs 专注于机器学习在医学成像方面的具体应用。换句话说,ML4H 更通用。有一些重叠,但是因为我在上一篇文章中详细介绍了成像,所以我将把重点放在 ML4H 涉及的所有其他领域。

有趣的是,尽管两个研讨会的演讲者处理了机器学习和医学的不同领域,但似乎有一个普遍的潜在主题:有限和/或混乱数据的问题。同样,研讨会上展示的技术,如多任务学习、用 GANs 生成合成数据以及将人类反馈纳入培训,都旨在解决这一基本问题。

[不幸的是,与 MedNIPs 不同,ML4H 的演讲(据我所知)没有一个是在线的,只有一些摘要是在线的。此外,周五的大部分时间,我都在跑来跑去,试图把自己的海报印出来。因此,我可能遗漏了一些重要的部分。因此,如果其中一位演示者或其他与会者想要添加一些东西,请随时留下评论,我会确保将它包括在内]。

医院运营

机器学习有可能改善医院运营和护理。几位特邀发言人和专题演讲人讨论了这个问题。在许多领域,机器学习都有可能提高医院的护理质量。费·李非在斯坦福大学发表了关于减少医院获得性感染和改善护理的最新研究的主题演讲。费飞讨论了大多数研究如何专注于寻找新药或更好地解释放射学报告。然而,医疗保健的很大一部分不仅仅发生在实验室,而是与医疗保健专业人员和他们的病人之间的互动。她认为,通过研究和增强机器学习的日常互动,我们可能会拯救更多的生命。这些领域包括减少医院获得性感染、监控 ICU 活动和预测人员配备水平。

米歇尔·郭(Michelle Guo)等人去年夏天在波士顿发表了一篇关于识别违反手部卫生协议的文章,在这篇文章的扩展中,他们发表了一篇关于使用“视点不变卷积神经网络”自动检测医院中潜在风险手部卫生场景的海报。他们使用深度图像,并将其输入卷积网络,以对照片中采取的行动类型进行分类。在这里,他们感兴趣的是将照片归类为接触病人或环境中的无菌区。

Classification of surgical instruments from page 2 of Jin et al.

本次研讨会的最佳论文是 Amy Jin 等人(也来自菲菲的研究小组)的论文使用基于区域的卷积神经网络在手术视频中进行工具检测和手术技能评估,描述了如何使用基于区域的 CNN,如 F-RCNN,来评估外科医生的技能。他们概述了一种跟踪和分析手术视频中工具使用的方法。这种方法可以为外科医生提供有价值的反馈,告诉他们手术效果如何以及需要改进哪些地方。特别是,他们跟踪工具的切换和手术的长度,以评估外科医生的技能。这种类型的监测可能会减少手术失误的数量。

Classifying patient actions in an ICU Ward. Taken from Bianconi et al. poster.

加布里埃尔·比安科尼等人(也来自菲菲的研究小组)的另一篇聚焦文章描述了使用 RNNs 对 ICU 移动护理活动的基于视觉的预测。这项工作试图分类病人的行为在 ICU 病房的医院使用 HIPPA 投诉深度传感器。解释这些活动有多重好处;例如,它可用于衡量医院对协议的遵守情况,以及遵守协议与总体患者结果之间的关系。

南加州大学的 David Kale 介绍了如何创建 MIMIC-III 数据的公共基准。他的团队训练了一个多任务 LSTM 来预测四个相关指标,包括总死亡率、住院时间、疾病表型和生理衰退。他们在网上发布了他们的模型以及生成他们所使用的特定训练和测试集所必需的代码。总之,这是多任务学习在医疗保健中的一个有趣的应用,它提供了一些有价值的基准来比较未来的结果。

ML 支持的治疗

几篇论文描述了强化学习在治疗败血症和预测某人是否患有疟疾方面的应用,我认为这很有趣。在此之前,我曾设想 RL 是一个小众主题,只研究像 PacMan 或 Alpha Go 这样有明确规则的问题。

Figure from page 7 Futoma et al.

Futoma 等人的“学习用多输出高斯过程深度递归 Q 网络治疗脓毒症”描述了强化学习和高斯过程的应用。他们的论文采用了两个主要部分协同工作 MGP 或多高斯过程和循环 Q 网络。MGP 过程处理时间序列患者生理数据,这通常是草率的,因为它是在不同的时间间隔记录的,而递归 q 网络学习临床策略。细节有些复杂,但总的来说,这是一个非常有趣的许多不同主题的综合。总的来说,作者估计他们的方法可以减少 8.2%的总患者死亡率(从 13.2%的总基线)。

Rajpurkar 等人的一篇题为“通过使用深度强化学习有效调查家庭进行疟疾可能性预测”的健康政策导向论文描述了训练一个 RL 代理问一系列问题来预测某人是否患有疟疾。具体来说,作者写道“RL 代理学习确定接下来要问哪个调查问题以及何时停止,以根据他们迄今为止的回答来预测他们患疟疾的可能性”(Rajpurkar 等人的摘要)。

另一篇专注于治疗的论文是“大型决策空间中相关决斗强盗与临床治疗的应用”在这篇论文中,作者将探索临床决策空间表述为一个有趣的 K 臂土匪问题。然而,这带来了问题,因为决策空间非常大,这意味着在传统方法收敛到最佳 arm 之前可能需要很长时间。为了克服这一点,他们开发了一种名为 CorrDuel 的算法,该算法利用了臂之间的相关性,以便更快地收敛。然后,他们将此应用于帮助找到最佳的电刺激,以帮助截瘫患者重新控制他们的运动(通过这些脊髓刺激),甚至站立。

最后,陈等人的混合梯度推进树和神经网络预测手术室数据也提出了一种预测缺氧的方法。

药物发现和个性化医疗

几位演讲者谈到了使用机器学习进行药物发现。例如,Atul Butte 在他的聚光灯下,讨论了从临床试验数据中挖掘数据,并将其输入机器学习算法,以发现新药。此外,他描述了数据可视化技术,用于绘制患者最可能的预后。(Butte 的幻灯片可以在 slideshare 上找到,如果你有时间,非常值得一读)。其他几位演讲者详细介绍了个性化医疗可能影响的具体领域。

Jennifer Chayes 介绍了“癌症免疫治疗中机器学习的挑战和机遇”Chayes 描述了预测新抗原的免疫原性和患者对特定类型免疫疗法的反应的挑战。通过更好地预测新抗原的免疫原性,更容易发现实际上具有抗肿瘤特性的新抗原。第二,通过预测患者对治疗的具体反应,可以在免疫系统没有被化疗拖垮时更早地引入治疗。然而,像医学研究中的许多其他领域一样,这受到小数据集的限制。除了很小之外,数据集还是非常高维的。

另一个亮点是“问医生——通过积极的专家知识启发改善药物敏感性预测”,描述了如何通过询问“专家”来改善衡量癌细胞对药物的特定疗效的模型。这种技术有点类似于主动学习(我在以前的文章中谈到过)。在这种情况下,专家是治疗血癌的专家。通常情况下,专家征集算法会随机向专家发送药物特征,并指出这些特征是否相关。作者的主要贡献是设计了一种算法,该算法通过仅向专家发送他们的反馈提供最大效用的对(而不是随机对)来减少发送给专家的查询的数量,并且除了相关和非相关反馈之外还包括方向性反馈。

综合数据

几篇论文讨论了使用 GANs 生成合成数据。这是一项有用的技术,因为 HIPPA 合规性导致获取真实医疗数据的复杂性。论文“来自双生成对抗网络的合成医学图像”,作者 JT·吉巴斯描述了如何使用一对 GANs 生成逼真的视网膜图像。研究人员为合成生成的医学影像照片引入了一个名为 SynthMed 的在线储存库。

Diagram from Synthetic Medical Images from Dual Generative Adversarial Networks

另一篇论文,用递归条件 gan生成实值(医学)时间序列(这也是一篇专题演讲),描述了如何用 R-gan 生成合成 ICU 时间序列数据。然后他们进行了几个有趣的实验来验证他们的结果;例如,他们观察重构误差的分布,定性地比较生成的样本,以及插值。总之,这篇论文展示了一个非常好的 GANs 用例,可以帮助解决困扰研究人员的许多数据访问问题。如果你喜欢 GANs,这绝对是一个值得一看的作品。

其他的

我发现其他几篇论文很难归入上述类别,但还是觉得很有趣。简而言之:

Kalyanam 等人撰写的“在 Twitter 上非法营销和推广处方药的检测和特征描述”。

用于流式细胞术分析的蒙德里安过程由纪等人完成。

最后,研讨会上总共有 97 篇论文,因此我肯定会错过一些好的。因此,我鼓励你去看看工作坊网站。此外,如果任何人对其他主题演讲有任何信息,请告诉我们,我会添加它。

公告

我将在 2 月 7 日星期三做一个关于使用小数据集的演讲,重点是医疗保健应用。演讲将于美国东部时间晚 7 点至 9 点在奥罗诺举行,并将通过 Zoomhttp://zoom.us/j/794523352的以下链接进行直播。

CurativeAI Slack 频道现在有 40 多个成员,并且还在继续。所以如果你还没有加入讨论,就来加入吧。

面向营销的机器学习

原文:https://towardsdatascience.com/machine-learning-for-marketing-25e26efbcefe?source=collection_archive---------18-----------------------

2018 年 AI 在营销方面有哪些最好的应用?

在过去的 10 年里,没有哪个领域比数字营销领域更加持续地应用人工智能。这是因为,与其他行业相比,互联网公司:

  • 收集更大、更结构化的数据集
  • 雇佣了更多的数据工程师
  • 更注重技术的文化。

但是,尽管大型科技巨头(谷歌、脸书、亚马逊……)正在大量使用机器学习来优化营销,许多组织仍然刚刚起步。

如果你想知道如何最好地在营销中使用机器学习/人工智能,这里有一个当今顶级应用的概述:

预测目标

你如何确保营销信息只传递给正确的用户?

预测目标定位是对基于细分甚至基于触发的目标定位的一大改进。这是个性化目标的层次结构:

0 级 : 无针对性营销。

  • 街上的传单。(但是谁会这么做呢?)

一级 : 细分目标定位。

  • 确定典型客户的特征,并针对该角色进行营销。

二级: 触发瞄准。

  • 使用关键行为来确定你的客户什么时候准备购买——就像他们刚买了一辆车。并且只针对那些顾客。

三级: 预测瞄准。

  • 利用你掌握的关于顾客的所有行为和人口统计线索,对他们现在购买的可能性做出个人预测。

在触发瞄准中,您手动选择触发器,而在预测瞄准中,您使用机器学习算法自动学习正确的触发器

机器学习模型可以通过这种方式捕捉到更多的复杂性,从而显著提高性能,因为它们在识别理想客户时更加准确。

我见过客户通过从触发目标转向预测目标,将营销收入提高了 200–300%。

预测销售线索评分

线索不再仅仅是电话号码和名字。现在,您可以轻松捕捉线索中的 50-100 个其他因素:

  • 采集渠道;
  • 与网站的互动(每次访问、文章阅读、下载或参加网上研讨会);
  • 账户信息(规模、投资轮次、新闻、员工波动)。

每条信息都包含一条线索,表明该销售线索是否准备购买。但是除了设置一些明显的过滤器之外,很难有效地使用这些信息。

“关于下载白皮书后直接观看网上研讨会的潜在客户比中间浏览 10 页的潜在客户更感兴趣?”

很难说——这只是你可能会问的数千个问题中的一个。

机器学习是进行这种分析的理想工具: 算法从过去的销售中学习创造良好销售线索的模式,然后用它们来预测你管道中每条线索的准确转化概率。然后你的销售团队就更清楚该关注谁了。

为了让算法能够找到可靠的模式,你的客户关系管理中至少需要 300 名已经购买的客户,以及至少 300 名没有购买的客户。

客户终身价值预测

你的客户群价值多少?谁会是你最好的客户?

估计一个多样化的 B2C SaaS 客户群的未来价值有点像一门黑色艺术——很多时候,你只需为每个客户选择一个平均值。

然而,与预测目标和线索评分类似,你可以使用机器学习来学习客户行为之间的联系(他们购买了什么和多少,登录等。)及其总终身价值。

如果你有足够多的客户,足够多的关于他们的数据,并且你的产品已经存在足够长的时间,那么这是一个很好的方式:

  • 找出哪种类型的客户更有价值;
  • 决定更关注哪些客户;
  • 估计客户群的总价值(一次一个用户)。

建议

我们不想再没完没了地浏览类别了。我们期望更相关的电影或书籍首先出现。推荐算法变得越来越好——如此之好,以至于对许多 Spotify 或网飞用户来说,自动推荐已经完全取代了手动发现。

推荐算法确保你的顾客看到更多他们想要的东西,最终这意味着他们会买更多。但是有很多不同的推荐算法——你需要哪一个取决于你的情况。以下是三个最重要的类别:

1.基于内容

基于内容的算法向你的用户推荐与他们以前喜欢的东西相似的东西。想想同类型的电影,或者同价位的酒店。

2.合作的

协同过滤算法找到有相似品味的用户,然后向对方推荐对方喜欢的东西。这就像让你所有品味相似的朋友给你推荐一样。在某种程度上,这些算法利用了你所有用户的智能,可以在不知道他们推荐什么的情况下做出准确的推荐。

3.混合物

混合推荐器以某种方式结合了前两种方法。许多正在使用的最强大的算法是混合推荐器(如网飞)。

适合您具体情况的最佳推荐方案还取决于:

  • 你对你的用户了解多少;
  • 你有多少新用户和回头客;
  • 你每个月增加多少新产品(像电影或书籍);
  • 产品与用户的比率。

一旦你建立了你的推荐算法,你可以用很多方法来应用它:

  • 对搜索结果进行排序;
  • 寻找相似的产品(电影、酒店、书籍);
  • 为每个用户提供个性化推荐(比如 Spotify Weekly)。

流失预测

客户流失是一个杀手。了解哪些客户将很快取消他们的会员资格,为什么他们打算离开,然后做出改变以留住他们可以拯救一家公司

但是经常没有一个明确的原因导致客户流失。而是很多不同的原因和组合。

一个简单的分析只会给你一个简单的答案——你最终会怀疑许多快乐的顾客在鼓捣。所以你因为给了错误的用户折扣而损失了收入。

再说一次,机器学习是微妙区分会流失和不会流失的用户的理想工具。它发现了隐藏在用户行为中的过多模式。

有了一个良好的模型,你可以将用户从最有可能流失到最不可能流失进行排序,并关注那些最需要关注的用户。

流失模型还可以帮助你了解导致流失的因素,并在必要时调整你的产品。

我是柏林一家精品机器学习咨询公司 Data Revenue 的创始人。如果你需要机器学习营销方面的帮助,请联系

原载于www.datarevenue.com

面向产品经理的机器学习第一部分——问题映射

原文:https://towardsdatascience.com/machine-learning-for-product-managers-part-i-problem-mapping-5436132c3a6e?source=collection_archive---------3-----------------------

机器学习和人工智能是最近的热门话题。因此,我发现许多产品经理和潜在的产品经理找到我,问我他们如何才能成为更好的 ML 项目经理。由于机器学习和产品管理的交叉是一个相当全面的话题,一篇文章无法公正地描述它。因此,我打算把它分成三部分

第一部分——问题映射:什么类型的问题最适合机器学习

第二部分——ML 技能:在构建利用机器学习的产品时,项目经理还需要哪些额外的技能组合

第三部分——警告:在构建使用机器学习 的产品时,有哪些常见的错误

这篇文章将重点讨论如何确定你试图解决的问题是否需要机器学习。

关注用户

使用机器学习构建伟大产品的首要原则是关注用户需求。我发现的一个常见误解是,人们认为机器学习在某种程度上从根本上改变了项目经理的技能。机器学习本身并不是目的。机器学习是解决真实用户需求的工具。我发现许多人(和公司)有一项很酷的人工智能技术,并且认为这项技术本身就证明了它的用途。如果你有一项很酷的技术可以应用,想想通过这项技术可以解决什么问题,或者增强什么体验。

话虽如此,有很多初创公司利用机器学习提出了很酷的创新,但并不总是专注于解决用户的问题/需求。它们在生态系统中起着非常重要的作用——它们推动技术前沿。这些初创公司往往会被收购,很少能够自己找到适合市场的产品。然而,作为一个项目经理,如果你试图建立一个服务于用户的产品,你的用户所面临的问题,而不是技术,需要成为你的关注点。

这给我们带来了挑战— 如何判断 ML 可以帮助解决哪些用户/业务问题。就其核心而言,ML 最适合于需要某种模式识别的问题。通常这些问题可以分为几种不同的类型

用户被过多的数据淹没

如果用户必须筛选大量数据来完成任务,ML/AI 是一个很好的工具。谷歌和必应等搜索技术使用各种机器学习算法为用户呈现最佳结果。例如,当你搜索菜谱时,哪个菜谱会排在你的第一个搜索结果的前面,这是基于对你自己的搜索模式以及与你相似的人的搜索和点击行为模式的了解。分类问题也能够利用机器学习。如果你想对数百万个关于教育的帖子进行聚类,机器学习可以帮助对它们进行分组,假设你已经通过提供已知关于教育的类似文档的合理样本来训练模型。

需要复杂认知能力的问题

自动驾驶汽车需要能够理解周围的环境。自动分类照片的图库应用程序需要能够检测地点、人和事物。这需要复杂的认知技能,建造这种智能机器的唯一方法是向它提供大量数据,并通过模式识别进行学习。

预测和预报

最常见的问题之一是预测用户是否喜欢某个商品。用户会喜欢新闻订阅中的故事吗?购买了 Dropbox 订阅的用户会流失吗?如果您的问题需要您预测用户是否会执行某个动作,ML 是一个很好的选择。

同样,如果你想预测 2018 年 12 月的销售情况(并且你的业务基本面没有发生巨大变化),你可以输入过去所有年份的历史数据,ML 模型可以在考虑季节性的同时进行预测。销售预测、库存使用——所有这些都可以从 ML 中受益。

异常检测

ML 的一大好处是发现数据中的异常。由于 ML 擅长模式识别,任何不符合被认为是规范的行为模式的东西都可以很容易地被检测出来。欺诈检测是一个主要的应用。如果我的用卡模式不同于我的常规行为,这可能表明我的卡已经被破坏。类似地,如果黑客试图访问企业内部网,查看入侵者的访问模式,人们可以使用机器学习轻松标记这种行为。

通过建议帮助决策

如果你想帮助你的用户做决定,比如说,提供购买、参观、观看等方面的建议。机器学习是一个很好的工具。通过观察人们观看类似事物、购买类似产品、访问类似网站的模式,机器学习可以减轻做出决定的认知负担。通过浏览建议,可能没有浏览整个视频目录或搜索所有项目的用户能够找到与他们的兴趣相似的项目。

与人类互动的体验

如果你正在寻找建立一个与人类交流的服务,因此需要理解自然语言,ML 是需要的。所有正在开发的助手技术——Alexa、Siri、谷歌助手——都是通过能够将人类语言翻译成可操作的任务来工作的。教机器理解人类语言需要向它们提供大量关于语言、语音语调的数据,然后让机器开始将语音映射到语言、指令和任务。

增加/创造新的体验

增加/创造新的体验是 ML 最令人兴奋的领域。有没有一种体验,因为上面提到的所有能力,现在成为可能?SnapChat 过滤器是如何使用 ML 增强体验的一个很好的例子。通过使用面部识别算法,SnapChat 滤镜能够检测面部轮廓,从而将创意滤镜覆盖在面部,从而使照片分享更加有趣。你能想到更多可以通过 ML/AI 改进的体验吗?

产品经理的机器学习第二部分——ML 技能

原文:https://towardsdatascience.com/machine-learning-for-product-managers-part-ii-ml-skills-ce7c3cee3246?source=collection_archive---------1-----------------------

这是面向产品经理的机器学习系列的三个部分的继续。

的第一个注解关注的是什么问题最适合应用机器学习技术。这篇笔记将深入探讨在构建利用机器学习的产品时,项目经理需要哪些额外技能

正如我在第一部分中提到的,无论你是否在机器学习驱动的解决方案领域工作,项目经理所需的核心技能集都不会改变。产品经理通常使用五种核心技能——客户同理心/设计印章、沟通、协作、商业战略和技术理解。从事 ML 工作将继续利用这些技能。一个确实得到更多延伸的领域是技术理解,特别是机器学习领域。这并不是说,除非你有深厚的技术功底,否则你就不能成为 ML 项目经理。但是你确实需要了解机器学习系统是如何运作的,以便做出好的产品决策。你可以依靠你的工程师,或者通过书籍和课程巩固你的知识,但是如果你对系统没有很好的理解,你的产品可能会导致不好的结果。

算法有局限性

机器学习中使用的每种算法或技术都是针对某项任务进行优化的,并不总是能够考虑到现实世界情况所需要的各种细微差别。 B 能够理解算法的影响和局限性,有助于你理解客户体验中存在的差距,并通过产品设计或选择其他 ML 技术来解决这些差距 。如果你是这个领域的项目经理,这是绝对必要的技能。 我举几个例子吧。

数据偏差

机器学习算法从数据中学习模式。因此,输入算法的数据质量决定了产品的成功。构建机器学习产品的首要挑战之一是确保数据代表将使用该产品的用户。

还记得谷歌把黑人的照片贴上大猩猩的标签吗?

确保在数据中代表所有用户是产品成功的基础。

有时,这些偏差可能存在,不是因为数据收集的错误,也是因为数据可用性的偏差。例如,当 IBM Watson 被训练学习语言时,它被输入了城市字典,它学会了说脏话。预期的结果是学习“礼貌”的人类语言,但相反,因为数据也有脏话,所以机器也学习了。因此,在重新训练 Watson 之前,需要清理数据。

再比如。与发展中国家相比,发达国家接入互联网的用户可能更多。因此,如果你建立模型,比如说基于互联网搜索的搜索行为,来自发达经济体的用户分布会更高。因此,当你对搜索模式进行建模时,对于那些不经常搜索的用户来说,比如说印度的首次上网用户,它可能不是很准确。认识到数据中的偏差将有助于你意识到这些算法可能对用户体验产生的意想不到的影响。

精确度和召回率的权衡

最近,我和一个团队进行了交谈,这个团队和我的团队使用完全相同的预测产品,但是两个团队的目标不同。该产品提供了对不良行为的预测。我的团队关心的是确保只有坏演员,而没有好演员被系统过滤掉。我们希望每个优秀的演员都能使用这个功能。所以,我们关心精确度。另一个团队关心的是不允许坏演员使用该产品,即使这意味着一些好演员也被限制使用该产品。所以,他们关心回忆。精确和召回总是相互权衡。如果你提高精确度,你的回忆就会降低,反之亦然。

弄清楚你的用例是否需要更强调精确性或回忆性,会改变工程师选择的模型的调整。因此,仔细考虑需要什么来解决用户问题是很重要的。类似于下图的权衡曲线用于检查与您正在使用的模型相关的指标。

Precision-Recall curve

根据问题的要求,模型可以调整到这个前沿的任何地方。有时,如果你需要改变边界本身,那么你可能需要选择不同的机器学习模型(这可能会带来其他限制)

冷启动问题

机器学习算法需要数据才能进行模式识别。冷启动是一个用于汽车的术语,指发动机处于冷态,汽车可能无法发挥最佳功能。然而,一旦引擎启动并运行,你就可以开始了。类似地,当算法没有关于用户或物品的任何数据时,会出现冷启动问题,导致次优体验。

冷启动问题有两种类型

基于用户的 :这是用户第一次使用你的产品,机型对用户没有信号。以网飞为例。网飞根据您的观看历史向您推荐要观看的节目和电影。但是,你第一次使用网飞时,它没有关于你观看行为的数据,因此,算法很难预测你的观看偏好。

这个问题可以用几种方法解决。几个常见的是

  1. 你提示用户从随机选择中选择几部最喜欢的电影来给你数据
  2. 您可以使用关于用户的一些基本信号来提供最佳推荐,比如查看用户从哪里登录,并假设用户可能喜欢该位置的其他用户喜欢的电影。例如,如果您从加州登录,您可能会显示其他加州用户观看的前 10 个节目
  3. 策展。你可能有一个手动策划的黄金集,比方说有史以来最受欢迎的电影,你可以作为一个开始体验来展示。

基于项目的 :这是当一个项目第一次被提供给你的用户,很难挑选给哪些用户看的时候。例如,当一部新电影进入网飞目录时,决定向谁推荐这部电影是很困难的,尤其是在这部电影的元数据很少的情况下。类似于基于用户的冷启动问题,这可以通过许多技术来解决。

  1. 人工注释:你可以让人工用元数据来注释这个项目,给你关于它是什么的信号。例如,你可以把一部新电影添加到目录中,然后由一个专家小组对其进行分类。根据分类,您可以决定这部电影应该向哪一组用户播放。

2.算法上:通俗地说,算法技术的工作原理是向许多用户展示新项目,以了解他们的偏好,从而获得更多关于谁更喜欢这个项目的信号,并缩小用户群。如果你有兴趣深入这个话题,你可以看看这本关于多臂强盗算法的入门书。

在异常检测中,冷启动问题会引发许多错误警报。例如,当一名新员工正在访问数据库系统时,ML 系统可能会认为他/她是入侵者,并可能发出假警报。当您在国外旅行或进行大额购物时,可能会遇到这种情况。渡过这一难关的方法是创建收集反馈(在行动之前或之后)的机制,以纠正误报,这将我带到下一节。

反馈回路

由于算法并不完美,它们可能会做出错误的预测和模式识别。您需要在您的产品中创建一些机制来为算法提供反馈,这样它们就可以随着时间的推移提高准确性。这些反馈循环可能就像记录负面信号一样简单,例如,用户浏览新闻标题的速度与阅读时间。当算法出错时,你甚至可以通过让用户介入来提供更明确的反馈循环——拇指向下、划掉等等。或者当算法做得很好,允许用户竖起大拇指,分享,保存等。

探索 vs 利用

让我们以上面网飞的例子来说明这个挑战。比方说,网飞的算法已经计算出我喜欢看足球。所以,我在我的推荐中看到与足球相关的电影、节目和纪录片。我看了一些,现在网飞向我展示了更多与足球相关的内容,这种循环还在继续。这里的算法是利用他们可用的信号——我喜欢足球,因此优化了它。然而,我对足球之外的许多内容很感兴趣。我也喜欢技术,但是网飞没有给我看任何与技术相关的内容。这被称为过滤泡沫,最近在媒体中。

为了给用户提供一个平衡的内容视图,系统应该定期向用户介绍那些偏好信号较少的项目,允许用户探索。新内容的引入可以是随机的(给我看几个瑜伽、美食、野生动物、科技节目),也可以是习得的(比如其他更喜欢足球的用户,更喜欢美食纪录片)。

以上并不是算法所有局限性的详尽列表,因为随着新算法的出现,可能会有新的漏洞暴露出来。你可能会问——我怎么可能理解算法之间的差距,尤其是如果你不理解算法本身。这里是你戴上首相帽的地方。

  1. 向您的工程团队提供清晰的用例。与您的工程团队一起浏览这些用例,解释这些用例的预期体验。这些用例应该包括产品的主要、次要和负面人物角色。一旦您的模型准备就绪,评估模型输出是否与这些用例的预期体验相匹配。
  2. 注重数据收集。询问有关如何清理和组织数据的问题。这些数据能代表你的用户群吗?
  3. **使用产品解决方案填补空白。**如果模型输出不符合您的预期,找出您可以做什么来提高模型解释这些用例的能力,或者这些用例是否扩展了模型的机器学习能力,然后创建产品解决方案、过滤器等。来填补这些空白。

产品经理的机器学习第三部分——注意事项

原文:https://towardsdatascience.com/machine-learning-for-product-managers-part-iii-caveats-79803a7548ef?source=collection_archive---------4-----------------------

这是面向产品经理的机器学习系列的三个部分的继续。

的第一个注解关注的是什么问题最适合应用机器学习技术。的第二个注解谈到了当构建机器学习产品时,一个项目经理需要哪些额外的技能。本笔记将重点讨论在构建 ML 产品时有哪些常见错误。

这篇笔记的目的是向 ML 水平有限的人提供对常见陷阱的一般理解,以便您可以就这些问题与您的数据科学家和工程师进行对话。我不会在本说明中深入探讨这些问题。但是,如果你有问题,请评论。如果对这些领域中的一个更感兴趣,我可能会写一个单独的说明。

数据问题

无数据:这似乎是显而易见的(甚至可能很好笑,我在一个关于 ML 的博客上提到了它)。然而,当我经营我的公司 PatternEQ 时,我们在那里向公司销售 ML 解决方案,我惊讶地发现有这么多公司想要使用 ML,并建立了“智能软件”战略,但没有任何数据。*没有数据就无法使用机器学习。*您要么需要贵公司收集的数据,要么可以通过与拥有数据的其他公司合作来获取公共数据或积累数据。没有数据,就没有 ML。句号。(在评估许多人工智能初创公司声称的工作时,这也是一个很好的过滤器。这些初创公司声称他们有一项很酷的人工智能技术,但没有数据来运行这些技术。)

小数据:今天发布的大多数 ML 技术都专注于大数据,并且倾向于在大数据集上工作良好。您也可以在小数据集上应用 ML,但是您必须非常小心,以便模型不受离群值的影响,并且您不依赖于过于复杂的模型。将 ML 应用于小数据可能会带来更多的开销。因此,应用统计技术而不是最大似然法来分析小数据集是非常好的。例如,大多数临床试验往往样本量较小,并通过统计技术进行分析,这些见解完全有效。

稀疏数据:有时候即使你有很多数据,你实际可用的数据可能还是稀疏的。比方说,在亚马逊上,你有数以亿计的购物者和数以千万计的商品可以购买。每个购物者只购买几百万种产品中的几百种,因此,你对大多数产品没有反馈。如果没有人或很少用户购买,这就使得推荐一个产品变得更加困难。当使用稀疏数据集时,您必须仔细考虑您所使用的模型和工具,因为现成的技术将提供低于标准的结果。此外,稀疏数据集的计算效率较低,因为大部分数据集是空的。

**高维数据:**如果你的数据有很多属性,即使是这些属性,模型也很难消费,它们也会占用更多的计算和存储资源。高维数据将需要被转换到小维空间,以便能够用于大多数 ML 模型。此外,在丢弃维度时,您需要小心,以确保您没有丢弃信号,而只是丢弃了冗余的维度。这就是特性选择非常重要的地方。

知道哪些维度对你想要的结果真正重要,这既是直觉的问题,也是统计学的问题。项目经理应该参与到与工程师/数据科学家的特性选择讨论中。这就是产品直觉发挥作用的地方。例如,假设我们试图预测一个视频有多好,虽然你可以通过查看用户观看了多少视频来了解视频的参与度,但你通过 UX 研究发现,用户可能会在视频播放时打开一个标签并切换到另一个标签。因此,观看时间与质量并不完全相关。因此,我们可能希望包括其他功能,如在播放视频时标签中是否有任何活动,以真正了解视频的质量。

数据清洗:你不能只是使用现成的数据,然后应用一个模型。ML 的成功很大程度上取决于数据的质量。就质量而言,我不仅仅指它的功能有多丰富,还指它清理得有多好。是否移除了所有异常值,是否对所有字段进行了规范化,数据中是否存在坏字段和损坏的字段-所有这些都可能决定模型的成败。就像他们说的,垃圾进垃圾出。

配合问题

过拟合

为了解释过度拟合,我要讲一个有趣的故事。在 2007 年金融危机期间,出现了一次量化宽松崩盘。本来不应该关联的事件,结果却关联了,很多被认为不可侵犯的假设都被违背了。算法出了问题,三天之内,量化基金积累了巨大的损失。

2007 年金融危机期间,我在一家名为 D.E.Shaw 的量化对冲基金担任工程师。当时,D.E. Shaw 遭受的损失相对低于其他量化基金。为什么?其他量化基金较新,它们的算法是根据 2007 年之前的数据训练的,这些数据从未出现过下跌。因此,当价格开始暴跌时,模型不知道如何反应。另一方面,D.E. Shaw 在 1998 年曾面临俄罗斯卢布的类似暴跌。D.E. Shaw 也遭受了损失,但自那以后,它的算法一直在进行校准,以预测这种情况。因此,它的算法不会像其他公司那样崩溃。

这是一个过度拟合的极端情况。通俗地说,这些模型是针对后见之明而优化的,而不是针对远见。竞争对手的量化模型是基于只有在股市表现良好时才成立的假设进行训练的,因此,当崩盘发生时,他们无法预测正确的结果,最终做出错误的决定,从而导致更多的损失。

如何避免这种情况?确保您可以在各种数据上测试您的模型。此外,仔细看看你的假设。如果经济发生变化,用户行为发生变化,它们还会成立吗?这是我不久前写的一篇文章,它更多地讨论了管理假设的话题。

欠适

当您的模型对于它试图学习的数据来说过于简单时,会导致拟合不足。比方说,你试图预测购物者是否会购买蛋糕粉。蛋糕粉是可以自由购买的。诸如可支配收入、蛋糕粉价格、附近的竞争对手等因素。会影响预测。但是,如果您不考虑这些经济因素,如就业率、通货膨胀率以及其他杂货店的增长,而只关注 Safeway 内的购物行为,您的模型将无法准确预测销售额。

如何避免这种情况?这就是产品/客户直觉和市场理解派上用场的地方。如果你的模型表现不好,问问你是否已经收集了准确理解问题所需的所有数据。您能否从其他来源添加更多数据,以帮助更好地了解您试图建模的潜在行为?

计算成本

构建 ML 产品时,一个被忽视的领域是机器学习的计算开销有多大。通过 AWS 和 Azure 等服务,你可以引导和建立机器学习能力。然而,在规模上,你需要做艰苦的数学计算,你愿意承担多少计算成本来为你的用户提供机器学习功能。基于成本,您可能需要权衡预测的质量。例如,您可能无法存储关于您的产品的所有数据。或者您可能无法提供最新的建议,不得不提前预计算,等等。了解您的工程团队如何权衡计算成本与 ML 精度/召回率等。将帮助您了解产品质量是否受到影响。

如何使用机器学习进行生产优化

原文:https://towardsdatascience.com/machine-learning-for-production-optimization-e460a0b82237?source=collection_archive---------6-----------------------

利用数据提高性能

在我的其他帖子中,我已经涉及了一些主题,如:用于异常检测和状态监控的机器学习,h 如何结合机器学习和基于物理的建模,以及如何避免机器学习用于时间序列预测的常见陷阱。但在这篇文章中,我将讨论机器学习如何用于生产优化。

在不久的将来,完全自主的生产设备将会出现。但即使在今天,机器学习也可以对生产优化产生巨大影响。在这里,我将仔细看看一个具体的例子,如何利用机器学习和分析来解决现实生活中遇到的复杂问题。

什么是生产优化?

产品优化是很多行业普遍存在的问题。在我们的上下文中,优化是指任何使某样东西——如设计、系统或决策——尽可能好、实用或有效的行为、过程或方法。最低成本、最佳质量、性能和能耗的决策过程就是这种优化的例子。

为了进一步具体化这一点,我将重点关注我们一直在与一家全球石油和天然气公司合作的一个案例。目前,该行业主要关注数字化和分析。这种关注是由每天从多达数千个传感器积累的大量数据推动的,即使是在单个生产设施上。直到最近,由于能力的限制以及缺乏必要的技术和数据管道来从传感器和系统收集数据以供进一步分析,这些数据的利用受到限制。

在石油和天然气行业的背景下,生产优化本质上是“生产控制”:您最小化、最大化或以石油、天然气,或许还有水的生产为目标。你的目标可能是最大化产油量,同时最小化产水量。或者可以将石油产量和气油比(GOR)运行到指定的设定点,以维持期望的储层条件。

生产优化有多复杂?

石油和天然气的生产是一个复杂的过程,为了满足短期、中期和长期目标,必须做出许多决策,从规划和资产管理到小的纠正措施。短期决策必须在几个小时内做出,通常被描述为日常生产优化。他们通常试图通过优化控制生产过程的各种参数来最大化油气产量。

在今天的大多数情况下,日常生产优化是由控制海上生产设施的操作者执行的。这种优化是一项非常复杂的任务,其中大量的可控参数都会以某种方式影响生产。必须调整大约 100 个不同的控制参数,以找到所有变量的最佳组合。考虑下图所示的非常简单的优化问题。

在这种情况下,只有两个可控参数影响你的生产率:“变量 1”和“变量 2”。优化问题是找到这些参数的最优组合,以最大化生产率。解决这个二维优化问题并不复杂,但想象一下这个问题扩展到 100 维。那是另一个故事了。从本质上来说,这就是操作人员在优化生产时试图做的事情。今天,这一点执行得如何在很大程度上取决于操作人员以前的经验,以及他们对所控制的过程的理解程度。

机器学习算法可以积累无限的数据集

这就是基于机器学习的方法变得非常有趣的地方。操作员执行的优化主要基于他们自己的经验,随着时间的推移,随着他们对过程设备的控制越来越熟悉,这些经验也在不断积累。这种从以前的经验中学习的能力正是机器学习中如此吸引人的地方。通过分析来自平台传感器的大量历史数据,算法可以学习理解各种参数之间的复杂关系及其对生产的影响。

算法从经验中学习的事实,原则上类似于操作员学习控制过程的方式。然而,与人类操作员不同,机器学习算法在几年的时间内分析数百个传感器的完整历史数据集没有任何问题。与人脑相比,它们可以积累无限的经验。

优化算法如何工作

拥有一个能够根据你调整的控制参数预测生产率的机器学习算法,是一个非常有价值的工具。回头参考上图中的简化图,基于机器学习的预测模型为我们提供了“生产率景观”,其波峰和波谷代表高产量和低产量。多维优化算法随后在该场景中移动,寻找代表最高可能生产率的最高峰。
通过在这个“生产率景观”中移动,该算法可以给出如何最好地达到这个峰值的建议,即调整哪些控制变量以及调整多少。因此,这种基于机器学习的生产优化包括三个主要部分:

1.预测算法:

你的第一步,也是最重要的一步,是确保你有一个机器学习算法,能够在给定所有操作员可控变量设置的情况下,成功预测正确的生产率。

2.多维优化:

您可以使用预测算法作为优化算法的基础,该算法探索调整哪些控制变量以最大限度地提高产量。

3.可操作的输出:

作为优化算法的输出,您可以获得关于调整哪些控制变量以及这些调整可能带来的生产率提高的建议。

基于机器学习的优化算法可以在来自生产设施的实时数据流上运行,当它识别出提高产量的潜力时,向操作者提供建议。算法的典型可操作输出如上图所示:调整某些控制器设定值和阀门开度的建议。它还估计了生产率的潜在增长,在这种情况下大约为 2 %。

这种基于机器学习的优化算法可以作为操作人员控制过程的支持工具,帮助他们做出更明智的决策,以最大限度地提高产量。

生产设备的完全自主运行离未来还有一段距离。在此之前,基于机器学习的支持工具可以对生产优化的执行方式产生重大影响

在未来,我相信机器学习将会被用在比我们今天所能想象的更多的地方。你认为它会对各个行业产生什么影响?我很想在下面的评论中听到你的想法。

如果你有兴趣了解更多与人工智能/机器学习和数据科学相关的主题,你也可以看看我写的其他一些文章。你会发现他们都列在我的中型作者简介,你可以在这里找到。

而且,如果你想成为一个媒体会员,免费访问平台上的所有资料,你也可以使用下面我的推荐链接。(注意:如果您使用此链接注册,我也会收到一部分会员费)

[## 通过我的推荐链接加入媒体- Vegard Flovik

作为一个媒体会员,你的会员费的一部分会给你阅读的作家,你可以完全接触到每一个故事…

medium.com](https://medium.com/@vflovik/membership)

更多来自 Vegard Flovik 媒体:

  1. 蒙特卡洛方法简介
  2. 从物理学到数据科学的转变
  3. 什么是图论,你为什么要关心它?
  4. 用于图像分类的深度迁移学习
  5. ‘建造一个能读懂你思想的人工智能
  6. 机器学习:从炒作到现实应用
  7. 人工智能和大数据隐藏的风险
  8. 用于供应链管理的人工智能:预测分析和需求预测
  9. 如何(不)使用机器学习进行时间序列预测:避免陷阱
  10. 如何使用机器学习进行异常检测和状态监控
  11. 你如何向人工智能系统教授物理学?
  12. 我们能使用纳米级磁铁建立人工大脑网络吗?

人工智能研讨会——从宣传到现实应用

用 Python 实现零售价格推荐的机器学习

原文:https://towardsdatascience.com/machine-learning-for-retail-price-suggestion-with-python-64531e64186d?source=collection_archive---------0-----------------------

Photo credit: Pexels

日本最大的社区购物应用 Mercari 深刻地认识到一个问题。他们希望向卖家提供定价建议,但这很难,因为他们的卖家可以在 Mercari 的市场上出售任何东西或任何一捆东西。

在这个机器学习项目中,我们将建立一个自动建议正确产品价格的模型。我们收到以下信息:

train_id —列表的 id

名称—列表的标题

item_condition_id —卖家提供的物品的状况

类别名称—列表的类别

品牌名称—品牌的名称

价格——物件的销售价格。这是我们将要预测的目标变量

运费—如果运费由卖方支付,则为 1,由买方支付,则为 0

item_description —项目的完整描述

电子设计自动化(Electronic Design Automation)

数据集可以从 Kaggle 下载。为了验证结果,我只需要 train.tsv。让我们开始吧!

import gc
import time
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.sparse import csr_matrix, hstack
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import mean_squared_error
import lightgbm as lgbdf = pd.read_csv('train.tsv', sep = '\t')

将数据随机分为训练集和测试集。我们只为 EDA 使用训练集。

msk = np.random.rand(len(df)) < 0.8
train = df[msk]
test = df[~msk]train.shape, test.shape

((1185866,8),(296669,8))

train.head()

Figure 1

train.info()

Figure 2

价格

train.price.describe()

Figure 3

项目的价格是右偏的,绝大多数项目的价格在 10-20 英镑。然而,2009 年定价最贵的项目。所以我们将对价格进行对数变换。

plt.subplot(1, 2, 1)
(train['price']).plot.hist(bins=50, figsize=(12, 6), edgecolor = 'white', range = [0, 250])
plt.xlabel('price', fontsize=12)
plt.title('Price Distribution', fontsize=12)plt.subplot(1, 2, 2)
np.log(train['price']+1).plot.hist(bins=50, figsize=(12,6), edgecolor='white')
plt.xlabel('log(price+1)', fontsize=12)
plt.title('Price Distribution', fontsize=12)

Figure 4

船舶

超过 55%的项目运费由买家支付。

train['shipping'].value_counts() / len(train)

Figure 5

运费和价格有什么关系?

shipping_fee_by_buyer = train.loc[df['shipping'] == 0, 'price']
shipping_fee_by_seller = train.loc[df['shipping'] == 1, 'price']fig, ax = plt.subplots(figsize=(18,8))
ax.hist(shipping_fee_by_seller, color='#8CB4E1', alpha=1.0, bins=50, range = [0, 100],
       label='Price when Seller pays Shipping')
ax.hist(shipping_fee_by_buyer, color='#007D00', alpha=0.7, bins=50, range = [0, 100],
       label='Price when Buyer pays Shipping')
plt.xlabel('price', fontsize=12)
plt.ylabel('frequency', fontsize=12)
plt.title('Price Distribution by Shipping Type', fontsize=15)
plt.tick_params(labelsize=12)
plt.legend()
plt.show()

Figure 6

print('The average price is {}'.format(round(shipping_fee_by_seller.mean(), 2)), 'if seller pays shipping');
print('The average price is {}'.format(round(shipping_fee_by_buyer.mean(), 2)), 'if buyer pays shipping')

卖家支付运费的平均价格为 22.58

如果买家支付运费平均价格为 30.11

我们在价格上进行对数变换后再进行比较。

fig, ax = plt.subplots(figsize=(18,8))
ax.hist(np.log(shipping_fee_by_seller+1), color='#8CB4E1', alpha=1.0, bins=50,
       label='Price when Seller pays Shipping')
ax.hist(np.log(shipping_fee_by_buyer+1), color='#007D00', alpha=0.7, bins=50,
       label='Price when Buyer pays Shipping')
plt.xlabel('log(price+1)', fontsize=12)
plt.ylabel('frequency', fontsize=12)
plt.title('Price Distribution by Shipping Type', fontsize=15)
plt.tick_params(labelsize=12)
plt.legend()
plt.show()

Figure 7

很明显,当买家支付运费时,平均价格会更高。

类别名称

print('There are', train['category_name'].nunique(), 'unique values in category name column')

类别名称列中有 1265 个唯一值

十大最常见的类别名称:

train['category_name'].value_counts()[:10]

Figure 8

项目条件与价格

sns.boxplot(x = 'item_condition_id', y = np.log(train['price']+1), data = train, palette = sns.color_palette('RdBu',5))

Figure 8

每个项目条件 id 之间的平均价格似乎各不相同。

经过上述探索性的数据分析,我决定使用所有的功能来建立我们的模型。

LightGBM

在微软DMTK 项目的保护下, LightGBM 是一个使用基于树的学习算法的梯度推进框架。它被设计为分布式和高效的,具有以下优点:

  • 训练速度更快,效率更高
  • 更低的内存使用率
  • 更高的精确度
  • 支持并行和 GPU 学习
  • 能够处理大规模数据

因此,我们打算试一试。

常规设置:

NUM_BRANDS = 4000
NUM_CATEGORIES = 1000
NAME_MIN_DF = 10
MAX_FEATURES_ITEM_DESCRIPTION = 50000

我们必须修复列中缺少的值:

print('There are %d items that do not have a category name.' %train['category_name'].isnull().sum())

有 5083 个项目没有类别名称。

print('There are %d items that do not have a brand name.' %train['brand_name'].isnull().sum())

有 506370 件商品没有品牌名称

print('There are %d items that do not have a description.' %train['item_description'].isnull().sum())

有 3 项没有描述。

LightGBM 的帮助函数:

def handle_missing_inplace(dataset): 
    dataset['category_name'].fillna(value='missing', inplace=True) 
    dataset['brand_name'].fillna(value='missing', inplace=True) 
    dataset['item_description'].replace('No description yet,''missing', inplace=True) 
    dataset['item_description'].fillna(value='missing', inplace=True)def cutting(dataset):
    pop_brand = dataset['brand_name'].value_counts().loc[lambda x: x.index != 'missing'].index[:NUM_BRANDS]
    dataset.loc[~dataset['brand_name'].isin(pop_brand), 'brand_name'] = 'missing'
    pop_category = dataset['category_name'].value_counts().loc[lambda x: x.index != 'missing'].index[:NUM_CATEGORIES]def to_categorical(dataset):
    dataset['category_name'] = dataset['category_name'].astype('category')
    dataset['brand_name'] = dataset['brand_name'].astype('category')
    dataset['item_condition_id'] = dataset['item_condition_id'].astype('category')

删除价格= 0 的行

df = pd.read_csv('train.tsv', sep = '\t')
msk = np.random.rand(len(df)) < 0.8
train = df[msk]
test = df[~msk]
test_new = test.drop('price', axis=1)
y_test = np.log1p(test["price"])train = train[train.price != 0].reset_index(drop=True)

合并训练和新测试数据。

nrow_train = train.shape[0]
y = np.log1p(train["price"])
merge: pd.DataFrame = pd.concat([train, test_new])

培训准备

handle_missing_inplace(merge)
cutting(merge)
to_categorical(merge)

计数矢量化名称和类别名称列。

cv = CountVectorizer(min_df=NAME_MIN_DF)
X_name = cv.fit_transform(merge['name'])cv = CountVectorizer()
X_category = cv.fit_transform(merge['category_name'])

TF-IDF 矢量化 item_description 列。

tv = TfidfVectorizer(max_features=MAX_FEATURES_ITEM_DESCRIPTION, ngram_range=(1, 3), stop_words='english')
X_description = tv.fit_transform(merge['item_description'])

标签二进制 brand_name 列。

lb = LabelBinarizer(sparse_output=True)
X_brand = lb.fit_transform(merge['brand_name'])

为 item_condition_id 和 shipping 列创建虚拟变量。

X_dummies = csr_matrix(pd.get_dummies(merge[['item_condition_id', 'shipping']], sparse=True).values)

创建稀疏合并。

sparse_merge = hstack((X_dummies, X_description, X_brand, X_category, X_name)).tocsr()

去除文档频率为<=1.

mask = np.array(np.clip(sparse_merge.getnnz(axis=0) - 1, 0, 1), dtype=bool)
sparse_merge = sparse_merge[:, mask]

Separate train and test data from sparse merge.

X = sparse_merge[:nrow_train]
X_test = sparse_merge[nrow_train:]

Create dataset for lightgbm.

train_X = lgb.Dataset(X, label=y)

Specify our parameters as a dict.

params = {
        'learning_rate': 0.75,
        'application': 'regression',
        'max_depth': 3,
        'num_leaves': 100,
        'verbosity': -1,
        'metric': 'RMSE',
    }
  • Use ‘regression’ as application as we are dealing with a regression problem.
  • Use ‘RMSE’ as metric because this is a regression problem.
  • “num_leaves”=100 as our data is relative big.
  • Use “max_depth” to avoid overfitting.
  • Use “verbosity” to control the level of LightGBM’s verbosity (<0: Fatal).
  • “learning_rate” determines the impact of each tree on the final outcome.

Training Start

Training a model requires a parameter list and data set. And training will take a while.

gbm = lgb.train(params, train_set=train_X, num_boost_round=3200, verbose_eval=100)

Predict

y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration)

Evaluation

from sklearn.metrics import mean_squared_error
print('The rmse of prediction is:', mean_squared_error(y_test, y_pred) ** 0.5)

的特征,预测的 rmse 为:0.46164222941613137

源代码可以在 Github 上找到。祝你一周工作顺利!

参考:卡格尔

Python 中基于空间的文本分类机器学习

原文:https://towardsdatascience.com/machine-learning-for-text-classification-using-spacy-in-python-b276b4051a49?source=collection_archive---------1-----------------------

Photo Credit: Pixabay

spaCy 是 Python 中流行且易于使用的自然语言处理库。它提供当前最先进的精度和速度水平,并有一个活跃的开源社区。然而,由于 SpaCy 是一个相对较新的 NLP 库,它不像 NLTK 那样被广泛采用。还没有足够的教程可用。

在这篇文章中,我们将演示如何在没有任何深度学习经验的情况下使用 spaCy 实现文本分类。

数据

对于一个年轻的研究人员来说,寻找和选择一个合适的学术会议来提交他(或她)的学术论文常常是一件既费时又令人沮丧的事情。我们定义“合适的会议”,意思是会议与研究人员的工作一致,并有良好的学术排名。

使用会议进程数据集,我们将按照会议对研究论文进行分类。让我们开始吧。数据集可以在这里找到。

探索

快速浏览一下:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import base64
import string
import re
from collections import Counter
from nltk.corpus import stopwords
stopwords = stopwords.words('english')df = pd.read_csv('research_paper.csv')
df.head()

Figure 1

没有缺失值。

df.isnull().sum()

标题 0
会议 0
dtype:int 64

将数据拆分为定型集和测试集:

from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.33, random_state=42)print('Research title sample:', train['Title'].iloc[0])
print('Conference of this paper:', train['Conference'].iloc[0])
print('Training Data Shape:', train.shape)
print('Testing Data Shape:', test.shape)

研究题目样本:配合 Smartness:在 Ad-Hoc 网络中使用异构智能天线。
本文发布会:INFOCOM
训练数据形态:(1679,2)
测试数据形态:(828,2)

该数据集由 2507 篇简短的研究论文标题组成,已被分为 5 类(按会议)。下图总结了不同会议的研究论文分布情况。

fig = plt.figure(figsize=(8,4))
sns.barplot(x = train['Conference'].unique(), y=train['Conference'].value_counts())
plt.show()

Figure 2

以下是在 SpaCy 中进行文本预处理的一种方法。之后,我们试图找出提交给第一类和第二类(会议)的论文中使用的热门词汇——INFOCOM & ISCAS

import spacynlp = spacy.load('en_core_web_sm')
punctuations = string.punctuationdef cleanup_text(docs, logging=False):
    texts = []
    counter = 1
    for doc in docs:
        if counter % 1000 == 0 and logging:
            print("Processed %d out of %d documents." % (counter, len(docs)))
        counter += 1
        doc = nlp(doc, disable=['parser', 'ner'])
        tokens = [tok.lemma_.lower().strip() for tok in doc if tok.lemma_ != '-PRON-']
        tokens = [tok for tok in tokens if tok not in stopwords and tok not in punctuations]
        tokens = ' '.join(tokens)
        texts.append(tokens)
    return pd.Series(texts)INFO_text = [text for text in train[train['Conference'] == 'INFOCOM']['Title']]IS_text = [text for text in train[train['Conference'] == 'ISCAS']['Title']]INFO_clean = cleanup_text(INFO_text)
INFO_clean = ' '.join(INFO_clean).split()IS_clean = cleanup_text(IS_text)
IS_clean = ' '.join(IS_clean).split()INFO_counts = Counter(INFO_clean)
IS_counts = Counter(IS_clean)INFO_common_words = [word[0] for word in INFO_counts.most_common(20)]
INFO_common_counts = [word[1] for word in INFO_counts.most_common(20)]fig = plt.figure(figsize=(18,6))
sns.barplot(x=INFO_common_words, y=INFO_common_counts)
plt.title('Most Common Words used in the research papers for conference INFOCOM')
plt.show()

Figure 3

IS_common_words = [word[0] for word in IS_counts.most_common(20)]
IS_common_counts = [word[1] for word in IS_counts.most_common(20)]fig = plt.figure(figsize=(18,6))
sns.barplot(x=IS_common_words, y=IS_common_counts)
plt.title('Most Common Words used in the research papers for conference ISCAS')
plt.show()

Figure 4

INFOCOM 的热门词汇是“网络”和“网络”。显而易见,INFOCOM 是网络领域和密切相关领域的会议。

ISCAS 排名靠前的词是“基础”和“设计”。它表明 ISCAS 是一个关于数据库、系统设计和相关主题的会议。

带空间的机器学习

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.base import TransformerMixin
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
from sklearn.feature_extraction.stop_words import ENGLISH_STOP_WORDS
from sklearn.metrics import accuracy_score
from nltk.corpus import stopwords
import string
import re
import spacy
spacy.load('en')
from spacy.lang.en import English
parser = English()

下面是使用空间清理文本的另一种方法:

STOPLIST = set(stopwords.words('english') + list(ENGLISH_STOP_WORDS))
SYMBOLS = " ".join(string.punctuation).split(" ") + ["-", "...", "”", "”"]class CleanTextTransformer(TransformerMixin): def transform(self, X, **transform_params):
        return [cleanText(text) for text in X] def fit(self, X, y=None, **fit_params):
        return selfdef get_params(self, deep=True):
        return {}

def cleanText(text):
    text = text.strip().replace("\n", " ").replace("\r", " ")
    text = text.lower()
    return textdef tokenizeText(sample):
    tokens = parser(sample)
    lemmas = []
    for tok in tokens:
        lemmas.append(tok.lemma_.lower().strip() if tok.lemma_ != "-PRON-" else tok.lower_)
    tokens = lemmas
    tokens = [tok for tok in tokens if tok not in STOPLIST]
    tokens = [tok for tok in tokens if tok not in SYMBOLS]
    return tokens

定义一个函数来打印出最重要的特征,即具有最高系数的特征:

def printNMostInformative(vectorizer, clf, N):
    feature_names = vectorizer.get_feature_names()
    coefs_with_fns = sorted(zip(clf.coef_[0], feature_names))
    topClass1 = coefs_with_fns[:N]
    topClass2 = coefs_with_fns[:-(N + 1):-1]
    print("Class 1 best: ")
    for feat in topClass1:
        print(feat)
    print("Class 2 best: ")
    for feat in topClass2:
        print(feat)vectorizer = CountVectorizer(tokenizer=tokenizeText, ngram_range=(1,1))
clf = LinearSVC()

pipe = Pipeline([('cleanText', CleanTextTransformer()), ('vectorizer', vectorizer), ('clf', clf)])# data
train1 = train['Title'].tolist()
labelsTrain1 = train['Conference'].tolist()test1 = test['Title'].tolist()
labelsTest1 = test['Conference'].tolist()
# train
pipe.fit(train1, labelsTrain1)# test
preds = pipe.predict(test1)
print("accuracy:", accuracy_score(labelsTest1, preds))
print("Top 10 features used to predict: ")

printNMostInformative(vectorizer, clf, 10)
pipe = Pipeline([('cleanText', CleanTextTransformer()), ('vectorizer', vectorizer)])
transform = pipe.fit_transform(train1, labelsTrain1)vocab = vectorizer.get_feature_names()
for i in range(len(train1)):
    s = ""
    indexIntoVocab = transform.indices[transform.indptr[i]:transform.indptr[i+1]]
    numOccurences = transform.data[transform.indptr[i]:transform.indptr[i+1]]
    for idx, num in zip(indexIntoVocab, numOccurences):
        s += str((vocab[idx], num))

精度:0.7463768115942029
用于预测的前 10 个特征:
第 1 类最佳:
(-0.9286024231429632,'数据库')
(-0.8479561292796286,'芯片')
(-0.7675978546440636,' wimax')
(。

from sklearn import metrics
print(metrics.classification_report(labelsTest1, preds, 
                                    target_names=df['Conference'].unique()))precision    recall  f1-score   support

       VLDB       0.75      0.77      0.76       159
      ISCAS       0.90      0.84      0.87       299
   SIGGRAPH       0.67      0.66      0.66       106
    INFOCOM       0.62      0.69      0.65       139
        WWW       0.62      0.62      0.62       125

avg / total       0.75      0.75      0.75       828

给你。我们现在已经在 SpaCy 的帮助下完成了文本分类的机器学习。

源代码可以在 Github 上找到。过一个学习周末!

参考:卡格尔

面向编程障碍者的机器学习

原文:https://towardsdatascience.com/machine-learning-for-the-programmatically-handicapped-4a786fe43f47?source=collection_archive---------8-----------------------

机器学习是什么,如何和为什么:解释…

所以你已经听过几次 20 世纪最常用的术语“机器学习”,你真的很想尝试一下。能有多糟呢?有时候,当你上网在 **Github、**上搜索一些知识库时,你会看到长长的先决条件列表:高级数值计算学位、机器学习博士学位、工程学位、独角兽的血和龙的角。

!你成为深度学习专家的梦想和愿望比 Chicxulub 下降得还快。

使用机器学习算法不一定要成为工程师

了解一些基本的 Python 语法?完美!这就是你所需要的。嗯,网上看起来没那么简单吧?编码基础知识和和钢铁意志是你需要的唯一先决条件,这将使你成为你一直梦想的机器学习摇滚明星!

学习数学

为了完全成为一名 ML 专家,你需要精通 ML 的概念。在不知道基本背景过程的情况下编写 ML 算法就像把一只海龟放在障碍赛中并期望它跳跃。所以不可能!

Coursera、Udemy 和 Udacity 教授初学者著名的 ML 算法背后的概念和数学。关于他们的应用实现的内容和资源也可以在网上找到。研究它们,了解是什么让它们如此通用、实用和用户友好。

神经网络是如何工作的?

你可能会想,看似如此复杂的事情,怎么会如此顺利地给出对你的公司最重要的预测。

简单来说,神经网络是一个受人类大脑启发的 ML 模型。你大脑中的神经元或脑细胞从一端向另一端反复发射小电脉冲,使信息从一个区域发送到另一个区域。这让你在被要求时想到大猩猩,或者在数学考试时进行逻辑思考和处理信息。

整个神经网络结构是一个连续的管道,其中一个计算隐藏层的输出是下一个的输入,直到它到达最终输出层来传递预测。这个新生成的预测数据通过称为**反向传播、**的过程通过隐藏层返回到输入节点,同时更新其权重。

数据陷入这种恶性循环,直到偶然发现最准确的答案。每层都有几个输入节点,对数据进行多重计算。它操纵数据,到处扔和拉伸数据,以得到可能的最佳答案。在直觉上,这就像用一堆不同的方法拧湿毛巾,看看哪一种方法能让最多的水滴掉出来。

这些数据被发送到它前面的隐藏层,对前一层生成的数据执行更复杂的计算。

这个循环一直持续到最后一层,即输出层。这一层中的节点包含整个神经结构的最终预测。最精彩的部分?所有这些都可以在 100 行代码内实现!

这可能看起来令人生畏。然而,我向你保证,我会尽可能简单。有了一步一步的指导,你注定会成为机器学习大师

我看得出你脸上已经有了笑容。“没我想象的那么差!”,你可能会惊呼!

使用 Python 制作人工神经网络(ANN)

我通常使用 Octave GUI 来实现 ML 算法,因为它的语法易于阅读,而且学习起来耗时最短。然而,Python 是一种新兴的 ML 语言,我们现在将使用它。

我们将构建一个具有两个隐藏层的人工神经网络,它将对我们给它的数字执行功能,以最少的时间和最少的错误预测 XOR 值

我们的 Python 模块和框架

我们将使用的包和模块将会非常少。我们需要的是接受一组值并将其压缩成一个向量(n*1 维矩阵)的东西。为什么 NumPy ?它很轻,用途广泛,足以用作我们的基础包,帮助我们塑造矢量,并对其中的元素进行数学和科学计算。

接下来,我们导入时间。时间是一个完美的模块,可以让我们知道自从上次体重更新以来已经过去了多长时间。

我们的超参数

超参数是调谐旋钮,它控制着我们的神经网络的行为和表现。这些超参数可以根据您的数据集包含的训练示例的数量或者您的 ML 算法的复杂性而改变。

所以,如果你输入了错误的数字,把你的屏幕炸了,也不用担心。它们可以随时重新调整!

我们现在选择隐藏层中节点数的值 n_hidden ,输入节点数 n_in ,输出节点数 n_outputs ,批量大小 n_sample ,我们的学习速率learning _ rate,以及

设置 n_hidden10n_in10n_outputs10n_sample300learning _ learn

(这些数字已经过测试,到目前为止,它们给出了最好的结果。)

请记住,迭代次数越高,人工神经网络就越精确。然而,计算最佳统计输出所需的总时间会增加

(你可以随便摆弄这些值。然而,有些可能会损害程序的结果;所以要警惕。)

播种我们的进步

我们希望我们所有的结果都是从同一基线计算出来的。当该算法在一次迭代中计算完几个值后,它会返回到最初的起始点 0 ,用存储器中的新值重新进行整个计算。这个过程叫做播种

激活函数 Sigmoid

激活功能是激活并调用下一层以开始对前一层中的节点的输出执行大量操作和计算的功能。在这种情况下,我们的输入节点是第一层的一部分。因此,自然地,我们从第一层的输出是在训练例子中使用的数字。

Sigmoid 函数是我们的主要激活函数g(z)werez是接受我们第一个向量中的特征值的参数,即我们的 X 值(我们的特征向量)。我们来写这个函数吧!

激活函数 tanh_prime

我们的第二个激活函数帮助激活我们的第二个隐藏层,并使它能够对s 形层的输出执行计算。让我们继续以同样的方式写作。py 文档。

我们的培训职能

函数 train() 将获取第二个隐藏层产生的值,并将训练我们的 ML 算法来正确地识别我们的测试数据,这将在本文稍后介绍。下面的代码帮助我们的算法从错误中学习,以最少的时间和错误完全预测事件的可能性或概率

通过交叉熵,我们检查并验证一个事件发生的概率,在这种情况下,一个数字的概率要么是 1,要么是 0。这消除了所有关于事件在我们的输入数据集中发生的非自然概率或可能性(异常)的疑问。

圣杯:预测()函数

这是神经网络的缩影。我们期待已久的时刻。到目前为止,我们编写的所有函数都是这个最终函数。 predict() 函数返回由人工神经网络计算的最终预测值,以及花费的时间和误差。花费的时间和损失(误差)应该是减少的。与实际预期输出相比,这些值确实非常准确。我们开始吧,好吗!

这段代码看起来很小,也不吓人。但是不要被它的外表所迷惑。这几行代码会影响算法如何预测整个问题的结果。

创建图层并生成输入数据

我们离想要实现的目标只有几步之遥!现在,我们创建我们的隐藏层。这些层接收输入数据,并将它们输入到我们的节点,节点对它们进行计算,并调整和更新它们的权重。

为了生成新的数据,我们简单地调用一个 NumPy 函数,使用我们的样本/批量大小和输入节点维度随机得出几个值(1 或 0)。这些数字成为我们输入向量的元素。

训练我们的算法

我们现在运行一个 for 循环来更新训练过程中的权重。准确度应该随着我们的历元计数而增加。我们还启动计时器来计算自更新过程开始以来经过的毫秒数。同时,我们运行另一个嵌套循环来预测每次迭代后最佳拟合预测线的损失和梯度。

程序运行 100 次迭代。

我们将在终端打印历元计数、损失和时间,以观察和检查我们的进展和准确性。当历元计数增加时,损失和花费的时间应该有下降的趋势(花费的时间可能在增加和减少之间波动。就可以了)。

预测输出概率

我们现在已经完成了我们的人工神经网络算法的编写!现在,剩下要做的就是调用我们之前写的预测函数。

我们终于完成了!恭喜你!让我们在终端中运行程序,看看我们珍贵的创造的结果。

运行程序

我们已经写完了我们的 ANN!此外,这一切都在 100 行简单的“可解读的”Python 代码之内!除了经营我们的劳动果实还剩下什么!终端运行我们在 testin 训练函数中编写的循环的**。控制台上打印出损耗耗时历元计数。精确度应该随着我们拥有的历元/迭代的数量而增加。**

简单地

你不需要有任何机器学习的相关经验来构建算法。通过构建人工神经网络,了解计算机科学基础知识足以让你在这个神奇、复杂的机器学习世界中成为一名雄心勃勃的人。

人工神经网络被广泛应用于整个企业领域,因为它们是最可靠和准确的。无论是苹果的 Siri ,谷歌的搜索还是脸书的新闻推送,机器学习都被广泛使用。洗钱正在以难以想象的速度增长和扩散,我们如何利用它,取决于我们自己。在那之前,下一集再见!

原创文章作者,里沙卜·阿南德

交易的机器学习

原文:https://towardsdatascience.com/machine-learning-for-trading-e2a5275b6fe?source=collection_archive---------8-----------------------

人工智能如何帮助交易者做出更好的决策&提高高频交易

交易是一个竞争激烈的世界。随着人工智能被描绘成万物的新神奇武器,人们对如何使用人工智能进行交易有着巨大的兴趣是可以理解的。

放弃

人工智能确实在交易中发挥了重要作用——但可能不是以你预期的方式。不幸的是,人工智能不能用于驱动一台在每个市场窃取人类交易者午餐的超人交易机器。即使是文艺复兴科技公司也没有这个能力。至少还没有

有何不可?

简短的回答:人类竞争——下面会有更多的介绍。

与此同时,人工智能实际上赢得的战斗要多得多——但仍然意义重大。人工智能与其说是交易者的替代者,不如说是交易者的助手。

以下是当今人工智能应用于交易的四大方式:

分析情绪

人类无法处理所有的信息——但是机器可以接近。有了人工智能,机器现在可以做更多的事情——包括分析和总结文本。

它们可以总结情绪之类的事情:抓取器收集关于特定主题的每日新闻、推文和其他社交媒体帖子,然后人工智能算法(特别是自然语言处理)总结积极或消极观点是否更强。他们甚至可以将文本分类成主题,并自动构建人类可读的文本摘要。

这对交易者来说是非常有价值的信息,他们必须尽快了解最新的动态。

预测真实世界的数据

交易员还使用人工智能来提高输入数据预测的可靠性——这是现实世界中帮助交易员成功的要素。

就像预测的那样:

  • 未来两周东北部的天气模式;
  • 欧洲的太阳能供应;
  • 政治选举的结果。

这些预测是基于其他公司开发的其他算法——但这并不意味着这些预测不能改进。

一个简便的技巧是训练一个算法来将多个专家预测组合成另一个预测——然后这个预测比它所基于的任何预测都更准确。这叫做组装,它工作得很好。

寻找模式

交易是关于识别局部模式——通常在时间和空间上是有限的——然后猜测如何利用它们。寻找模式的过程既费力又耗时。

但是 AI 算法基本上是模式发现机器。如果分析师怀疑特定数据集中的不规则性,他们可以通过使用人工智能来找到它们,从而节省时间。

因此,人工智能可以找到有用的模式,只要有经验丰富的分析师指导,他知道应该寻找什么。这些模式然后被交易者使用,他们把它们和他们的经验和直觉混合在一起,然后应用它们。或者你可以用它们来设计自动交易机——见下一节。

调谐高频交易机器

在高频交易中——顾名思义——机器每天执行数千或数百万笔交易,试图利用只存在于极短时间跨度内的低效率。

人类无法进行这些交易——交易太多了——但人类定义了这些机器运行的规则。

但是,由于市场不断变化,这些机器需要不断调整。那需要很多时间和努力。

人工智能可以自动进行这些重新校准——并做许多重复的统计工作,否则分析师需要做这些工作。

!3 个警告标志!—需要注意的事项

找到一种能够真正印钞的奇迹算法的承诺是如此诱人,许多聪明人都相信了这一点。以下是需要警惕的最重要的陷阱:

1.今天的人工智能并不比人类“聪明”

事实上,与人脑相比,即使是今天最先进的人工智能算法也非常幼稚。

当一种算法在国际象棋或围棋中击败人类时,就像一辆汽车在四分之一英里比赛中击败人类赛跑者一样:是的,机器更快,但这并不意味着它更优越。这只是意味着我们建造了一台机器,它可以在特定的条件下很好地完成非常狭窄的任务。

一开始看起来是这样,但是交易并不是一个狭义的任务。为什么?因为在交易中,你是在和其他人竞争——他们会用尽所有的脑力试图比你聪明。

2.公布的交易策略在现实生活中往往行不通

有很多研究和博客文章承诺基于人工智能的交易算法是有利可图的。但是这些模型在现实生活中并不适用,原因有几个。

**错误的设置。**数量惊人的论文实际上在如何建立他们的训练和测试框架上犯了错误。他们使用在人工智能需要做出决定(数据泄露)或根据当前价格而不是未来价格评估预测时不可用的变量。令人惊讶的错误——但是时间序列数据集对于人脑来说是一件复杂的事情。

选择偏差。基金经理经常被批评将他们更好的回报归因于高超的技能而不是运气。但如果许多基金经理进行大量随机猜测,那么最终会有一些人做出一些不错的猜测。输家倒闭了,我们从来没有听说过他们——所以看起来有很多基金经理拥有战胜市场的技能。

然而在现实中,跑赢市场的基金经理数量与你根据随机猜测所预期的完全一致。

研究论文也是如此。如果你尝试了很多算法,你最终会找到一个似乎能产生一定利润的算法。如果你不告诉每个人你做了多少实验才达到目的,这看起来就像你偶然发现了一个更好的方法。

但是,绝对不能保证这个策略在您测试的特定数据之外也能工作。

**交易费用和滑点。**事实上,建立一个超越市场的交易策略通常很简单——如果你忘记了交易的真实成本。交易费(你为每笔交易支付的费用)和滑点(在你下单和交易之间价格可能会变化的事实)吞噬了很多利润。而且几乎在每一种情况下,这都足以删除你在模拟中看到的利润。

**模式随着时间而变化。**机器学习中最重要的概念之一是在过去的数据中找到模式,并使用它们对未来做出正确的预测。

然而,这在交易中是行不通的。其他交易者竞相寻找相同的模式——所以模式被发现,被利用,然后消失。这意味着模式很少会长期存在,你必须不断发现新的模式。

这需要巨大的适应性——这是人类目前比机器更擅长的。

3.单靠算法永远不会给你带来优势

人们很容易忘乎所以,把算法作为一种交易策略和另一种交易策略之间的主要竞争优势。

这基本上就是像numeric这样的公司所提议的:

  1. 把很多好的模型组合成一个超级模型。
  2. 战胜股市。

但是这个不行。为什么?因为数据击败算法。你给你的算法的数据对你的模型性能的影响比算法有多好要大得多。数字给你的数据是固定的,你不能添加。因此,他们做出的预测总是比交易者的预测差,交易者可以使用的数据没有限制——交易者可以访问开放的数据池,可以不断尝试、测试和添加新的数据点到他们的算法中。

一点希望——低效的市场可能仍然是沃土

交易参与者少、进入壁垒高、交易量有限以及很少有玩家能够使用机器学习的市场可能为纯人工智能交易的成功提供一些机会。

在这些市场中,自动化交易——尤其是机器学习的使用——仍然刚刚开始,构建自动化交易引擎的交易员可以获得足够的优势,从而产生丰厚的利润。

注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章,但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语

我是德国柏林机器学习咨询公司 Data Revenue 的首席执行官。如果你想了解更多关于人工智能的交易或我们的工作,请联系我们。

原载于www.datarevenue.com

用于车辆检测的机器学习

原文:https://towardsdatascience.com/machine-learning-for-vehicle-detection-fd0f968995cf?source=collection_archive---------4-----------------------

我训练了一个支持向量机(SVM)模型来检测道路上的移动车辆。这是 udacity 自动驾驶汽车工程师课程的第五个项目。

这个项目的代码可以在: Github 上找到。
这篇文章也可以在我的网站这里找到。

该项目包括以下几个阶段:

  1. 对数据集执行要素工程。
  2. 在提取的特征上训练 SVM 分类器。
  3. 实现滑动窗口技术来检测图像中车辆。
  4. 使用热图过滤非车辆窗口,并在车辆周围绘制边界框。
  5. 产生一个管道,并生成结果的视频。

本项目的训练数据集由以下样本中的车辆和非车辆图像组成:

Figure 1. Sample vehicle and non-vehicle images from training dataset

总的来说,训练集包含 8,793 幅车辆图像和 8,968 幅非车辆图像。

特征工程

项目的第一步是对训练数据集执行特征工程,以确定要使用的理想特征描述符。考虑了三个特征描述符:方向梯度直方图(HOG) 特征、空间宁滨特征和颜色直方图特征。

研究人员 Navneet Dalal 和 Bill Triggs 在他们的论文《人类检测的梯度方向直方图》中普及了 HOG 特征描述符。HOG 计算图像局部的梯度方向分布。以下是图像三个颜色通道中每一个的图像样本上的 HOG 特征的可视化:

Figure 2. Visualization of HOG features for different colour channels.

如何计算 HOG 的详细描述可以在这篇文章中找到。

使用的第二个特征描述符是空间宁滨;为了计算这个特征描述符,使用了 OpenCV 的 resize 函数。缩小图像时,resize 函数执行线性插值空间宁滨运算。

使用的第三个特征描述符是颜色分布(直方图)。计算图像中每个颜色通道的直方图,然后将三个直方图组合起来产生一个特征向量。

实验表明,图像最初被转换到 YCbCr 色彩空间,这是在预测过程中获得最高准确度的理想色彩空间。然后,从三个特征描述符中的每一个构建每幅图像的组合特征向量。该组合的特征向量是用于训练预测模型的特征向量。

SVM 培训

随着我们的特征工程的完成,下一步是实现一个预测模型,该模型能够计算出特征向量是属于车辆还是非车辆。

选择线性支持向量机(SVM) 模型作为预测算法。我摆弄了一下模型的超参数;C 值为 0.001,最大迭代次数为 10,000,可获得约 98%的高精度。以下是用于实现该模型的代码:

该模型需要大约 12 分钟来训练,这对于机器学习模型来说是相对较短的时间。

滑动窗口搜索

为了在视频源上使用我们的预测模型,我们需要提出一种合适且一致的分割算法,让我们能够搜索我们的视频源图像。搜索算法应该从图像中返回子图像,然后将这些子图像输入到我们的模型中进行预测。一种这样的搜索算法是滑动窗口搜索技术。

滑动窗口搜索根据预先选择的比例将搜索区域分割成较小的相同大小的重叠区域。在我们的例子中,我们需要不同比例的滑动窗口区域来说明这样一个事实,即远处的汽车看起来较小,而近处的汽车看起来较大。以下是滑动窗口搜索的四种不同组合,最后一幅图像中的最终组合窗口:

Figure 3. Sliding-window search technique with different scale combinations. Final image is of all sliding-window search areas combined.

上述滑动窗口搜索被应用于视频帧中的每个图像。总共有 697 个窗口被输入到每个图像的模型中。

热图阈值

当我们将提取的窗口输入预测模型时,结果是检测到车辆的窗口列表(各种比例),如下图所示:

Figure 4. Sample image with positive windows identified as containing a vehicle.

现在考虑到 SVM 模型的简单性,我们预计有些检测是假阳性的。为了过滤掉这些不正确的检测,一种方法是对我们的正窗口进行阈值处理,使得我们只挑选多于一个窗口重叠的区域。本质上,我们正在生成正窗口的热图。

下图显示了应用于搜索图像的热图阈值:

Figure 5. Heatmap thresholding applied to images with positive detections.

此外,使用生成的热图,我们可以使用距离热图中心最远的像素位置来计算检测到的对象上的边界框。这些边界框用于根据上图最后一列中的一组图像直观地识别我们检测到的汽车。

下图显示了显示在检测到的车辆顶部的边界框:

Figure 6. Display of bounding boxes around positively detected vehicles.

最终管道

最终结果是,对于提要中的每个图像,管道如下所示:

  1. 从图像中提取所有搜索窗口。
  2. 将每个窗口图像转换到 YCbCr 颜色空间并提取特征。
  3. 将每个特征输入 SVM 模型,过滤掉非正匹配(非车辆)。
  4. 将热图阈值应用于正匹配并绘制边界框。

管道是在汽车行驶的录像上运行的。下面是一段演示管道运行的视频:

从零开始的机器学习:第 1 部分

原文:https://towardsdatascience.com/machine-learning-from-scratch-part-1-76603dececa6?source=collection_archive---------5-----------------------

属性和模式

目录

这是关于机器学习的全新系列的第一篇文章。每篇文章都将基于五个核心原则:

  1. 我的主要目标是让读者对应用机器学习的基础有一个深入的了解。如果你想建立一个坚实的基础来分析人工智能对你的行业和个人生活的影响,那么这个系列就是为你准备的。
  2. 该计划将涵盖最成功的机器学习模型以及一些最新验证的研究趋势。我不会讨论任何失败的方法,也不会讨论任何尚未得到实证支持的推测性想法。
  3. 该材料是独立的,一步一步地发展了应用机器学习的基础。说高中数学是先决条件是言过其实了。有些文章将涵盖集合、导数和线性模型等基本主题。
  4. 每一个概念都会用至少一个例子来解释。我认为处理一个抽象话题的最有效的策略之一是将其提炼为一个简单的案例,用生动的例子使其具体化,并最终重建整体图景。当它看起来有用的时候,文本会用视觉来完成。
  5. 其他一切都取决于反馈、实验和学习。欢迎随时提问和建设性反馈!

让我们开始吧。

什么是机器学习?

机器学习使用计算机通过识别数据中的模式来预测未知的对象属性。

机器学习兴起的最重要原因是它在广泛的不同领域取得了成功,包括图像、声音、视频、文本、软件代码、粒子碰撞、化学描述符、DNA、社交网络和金融数据。

有趣的是,构成大多数机器学习系统的积木数量比人们想象的要少。对于许多深度神经网络来说尤其如此,这些将在后面的章节中详细介绍。

换句话说,我们可以将少量的基本元素组合成系统,这些系统对于图像分类、问题回答和自然语音合成等各种应用都有巨大的价值。

虽然机器学习可以应用于许多不同的领域,但生产中的大多数系统都是针对单一目的和特定类型的过程对象进行优化的。

例如,计算机视觉系统专门从事与图像或视频相关的任务,如交通标志识别[1]和医学图像分类[2]。

目标

既然机器学习处理的是未知的对象属性,那么一个自然的起点就是谈论对象。

出于本教程的目的,对象是任何具有属性的东西。

我承诺过我会将抽象的概念具体化,并在适当的地方使用视觉效果。这张照片展示了三个典型的(欲望)对象:

Fig. 1: Image by Rawan Hussein

在其他属性中,每一勺冰淇淋都有独特的味道、呈现的颜色范围、受欢迎程度、售价等等。

(三三勺冰淇淋共有的一个属性是,它们比华夫饼干筒有更多有趣的属性。)

属性

一个属性是表征一个对象的东西。

让我提前警告你。我喜欢概念树。因此,在本系列的课程中,您将会看到其中的许多内容。这是第一个:

Fig. 2

在高层次上,我们可以区分可度量的属性和不可度量的属性。

许多属性是可测量的。简单的例子包括一勺冰淇淋的重量和在特定地点和时间单位的销售价格。在可测量的属性中,只有一小部分会在项目期间作为数据收集活动的一部分被实际测量。

其他属性将不会被衡量,因为它们要么是不相关的,超出了我们目前的理解或超出了我们的预算。据推测,大脑具有我们可以测量的属性,从而创造出完美的新冰淇淋口味。然而,在实践中,这种努力受到我们对大脑如何产生品尝美味冰淇淋的主观体验以及所需扫描设备上的价格标签的不完善理解的限制。

测量属性

让我们进一步将测量的属性分成两个子类型:

  • 目标
  • 特征

目标是我们关心并希望预测的属性。

一些基本上同义的术语是因变量未观察变量解释变量输出变量结果测量

[我应该指出,机器学习中使用的一些概念在其他社区中以不同的名称为人所知。在许多方面,机器学习是统计学的后代,这两个领域之间有很强的重叠。因此,当你深入研究文献时,你可能会遇到统计学家喜欢的变体。

当引入一个新术语时,我会提到一些常用的同义词,然后始终使用机器学习社区中最流行的变体,并且最符合整体情况。]

通常情况下,目标对于某些物体来说是已知的,而对于其他物体来说是未知的。例如,我们可能希望在某种程度上根据已知的历史销售数据来预测未知的未来销售数据。

特征是与目标(潜在)相关的属性。

例如,产品的价格与对该产品的需求有关。这种关系可能很强,也可能很弱,取决于具体情况[3],但是价格肯定是首先应该想到的特征之一。

在其他社区中,特性通常被称为自变量观察变量解释变量输入变量

属性值

属性值是关于特定对象的属性值。

如果目标是下一季度的销售数字,那么目标值的一个例子可以是 8000 台。

类似于目标,我们可以使用术语特征值来指代关于特定对象的特定特征的值。以美元表示的价格特征的值可能是 99.99。

模式识别

机器学习基于这样的前提,即特征和目标之间存在以可预测的方式重复的关系。让我们把这些关系称为模式

如果我们生活在一个没有模式的世界,机器学习就没有任何用处,本教程也不会被编写或阅读。幸运的是,我们所处的宇宙是高度结构化的。经验科学的成功[4]证明了模式是存在的,而且是可以被发现的。

在不太遥远的过去,人们付出了巨大的努力来设计特定任务的功能。例如,有大量关于为某些计算机视觉问题开发的功能的文献,例如机器人识别房间中物体的能力。[5]

在过去的十年中,机器学习的进步使得在某种程度上自动搜索特征成为可能。[6]

计算机视觉的一个例子

为了总结这篇文章,让我们用一个具体的例子来更深入地了解特性和目标之间的关系。

Fig. 3: Photo by Patrick Berry / CC BY-SA 2.0

假设你刚开始开发一个系统,目标是自动识别照片中的动物。

上面的照片显示了一个猩猩妈妈和她的婴儿,这个事实对我们来说是显而易见的。

然而,对于计算机视觉系统来说,这远非显而易见。在发展初期,它没有任何关于猩猩、母亲或婴儿的知识。

在我描述我们能做些什么来改变这种情况之前,我想问你一个问题。

你如何解决这个任务?也就是你怎么理解上面的照片是两只猩猩?

人类的视觉(一般来说是灵长类的视觉)是如此高效,而且几乎不需要有意识的努力,以至于可能需要一段时间才能得出一个精确而令人信服的答案。

我建议你停下来想一想。在这样做的时候,你可能会预料到下面描述的一些想法,并最终意识到至少某些形式的机器学习比它们看起来更直观。

部分答案是,我们过去见过类似的猩猩照片。

在某些情况下,我们看到了相关的图像,但没有太多的描述或背景。例如,我们可能在浏览电视频道或脸书频道时短暂地看过这些类人猿。

在其他情况下,猩猩的图像与某些信息一起呈现,这让我们很容易识别模式。这可能是在纪录片,参观动物园,学校课程或其他学习机会。

其中一种模式是猩猩有橙红色的棕色头发。这一显著特征的存在使得许多其他可能性大大降低。

另一个相关的方面是他们半孤独的生活方式。除了它们形成的强烈的母子关系,猩猩通常是单独出现的。在其他条件相同的情况下,同一张照片上出现许多个体可能是猩猩缺席的一个特征。

我们可以关注的另一个信息来源是背景。作为最大的树栖动物,猩猩经常出现在显示它们生活的森林树冠的照片上。

这是对一些高级特征的直观描述,我们可以用这些特征在图像中检测我们的进化亲属。后面的教程将描述机器学习模型如何学习特征的层次结构来分类图像。值得注意的是,这些特征中的一些将被证明是容易解释的,并且与灵长类动物视觉中使用的特征有一定程度的相似性。

监督机器学习

收集相关数据和识别模式以生成预测的工作流是所谓的监督(机器)学习的本质。在该设置中,目标值(例如,特定内容的存在与否)对于一些对象(例如,图像)是已知的,而对于其他对象是未知的。

在计算机视觉的背景下,我们作为教师向学习者(计算机/机器人)展示示例图像,提供内容的简要描述,强调某些特征,并选择帮助学习者“看到”数据中的模式的策略。

只要稍加调整,同样的过程就可以用在开头提到的许多不同领域,从文本和声音到化学结构和社会网络。

我们将逐渐使这种直觉变得精确,并将其整合到一个概念网络中,让你能够理解机器学习应用。

本文的重点是属性、模式和计算机视觉。第二部分用自然语言处理的例子来观察数据的收集。

感谢您的阅读!如果您喜欢这篇文章,请点击“鼓掌”按钮并跟随我阅读本系列的下一篇文章。

参考

[1]cire An d .,Meier u .,Masci j .和 schmid Huber j .,2012 年。用于交通标志分类的多列深度神经网络。神经网络32 ,第 333–338 页。

[2] Esteva,a .,Kuprel,b .,Novoa,R.A .,Ko,j .,Swetter,S.M .,Blau,H.M .和 Thrun,s .,2017。用深度神经网络对皮肤癌进行皮肤科医生级别的分类。性质542 (7639),第 115 页。

https://en.wikipedia.org/wiki/Price_elasticity_of_demand

https://en.wikipedia.org/wiki/List_of_equations

[5] Lowe 博士,1999 年。基于局部尺度不变特征的物体识别。《计算机视觉》, 1999 年。第七届 IEEE 国际会议论文集(第 2 卷,第 1150-1157 页)。Ieee。

[6] Krizhevsky,a .,Sutskever,I .和 Hinton,G.E .,2012 年。基于深度卷积神经网络的图像网分类。在神经信息处理系统的进展(第 1097-1105 页)。

从零开始的机器学习:第 2 部分

原文:https://towardsdatascience.com/machine-learning-from-scratch-part-2-99ce4c78a3cc?source=collection_archive---------4-----------------------

集合和数据

目录

非常感谢您的关注和积极反馈!我很高兴看到你们许多人认为这些材料很有用。这个系列正在逐渐发展成为一个关于应用机器学习中最重要主题的全面和独立的教程。

上次,我们重点讲了属性和模式。本文的第一部分通过对数据集和集合的讨论扩展了我们的概念工具箱。第二部分将介绍自然语言处理并应用新概念。

数据

数据点

当您听到术语“数据”时,首先想到的一些联想是收集、计数、评估、记录、测量、量化、评级、测量、跟踪和称重。这些活动为机器学习提供了宝贵的原材料。

数据是测量属性值的任意集合。生物标记、财务数据、销售数据、网络连接、调查反馈、用户活动、视频记录、字数和你最喜欢的冰淇淋店的口味数量都属于数据范畴。

一个数据是一个属性值的单一测量。一个数据是这篇文章的字数(2268)。

假设我们对一组特定的属性感兴趣,并在多个场合测量它们的值——可能是在不同的时间、不同的位置或针对不同的对象。在这些场合中的任何一个进行的这种测量的集合是一个数据点

例如,健身追踪器可以测量心血管表现、活动水平和睡眠质量。在特定时间为特定人收集的数据构成一个数据点。

例子

示例是为了解决机器学习问题而收集的数据点。

如果我们想预测在线广告的表现,每个例子都将描述过去发生的广告的特定显示。这包括关于广告的位置、格式和设计的特征,以及关于向其呈现的用户的某些词语和人口统计数据的存在或不存在。

一个例子是当包括目标值时被标记为,而当目标值不存在时未被标记为

在广告示例中,当示例包括性能测量时,例如指示广告是否被点击的是/否值,则该示例被标记。

数据集

一个数据集是例子的集合。

监督学习使用带有标记示例的数据集。无监督学习是一种学习类型,将在后面的章节中介绍,它试图在未标记的例子中识别模式。

Fig. 1

在开发过程中,数据集被用作模式识别的来源,并用于评估机器学习系统的性能。

在生产中,系统会显示新的数据点。这些数据点通常相似,但很少与开发过程中可用的示例相同。

收集

数据排列在集合中。

下面的树显示了将在本系列中使用的集合类型:

Fig. 2

两种基本的集合类型是集合和列表。

设置

一个集合是不同对象的集合。换句话说,没有一个对象可以出现一次以上。属于一个集合的对象称为成员元素。集合中元素的数量被称为它的基数或集合的大小。

特定集合用大写字母表示。集合的成员用小写字母书写。

花括号表示集合中对象的集合。一组基本的冰淇淋口味可以是这样的: S = {香草、巧克力、草莓}。

元素 x 属于集合 S 的事实被写成 x ∈ S 。集合 S 的大小用竖线表示: |S|

在上例中,我们有 vanilla ∈ S|S|=3

列表

相反,列表是一个集合,其中的对象可以出现不止一次。属于列表的对象被称为或元素。一个列表包含的项目数被称为列表的大小长度

我将使用方括号来表示列表。客户在我们的基本冰淇淋店订购两勺草莓冰淇淋和一勺香草冰淇淋,可以通过下面的列表表示:【草莓,草莓,香草】。

注意,在这种情况下,列表是正确的选择。使用集合表示订单的企业将无法提供正确数量的冰淇淋。

可变长度的元组和列表

列表可以进一步分为两个子类型:

  • 元组(固定长度的列表)
  • 可变长度列表

元组是固定长度的列表。换句话说,您既不能添加其他项目,也不能删除任何现有项目。

长度为 2 和 3 的元组分别被称为三元组。在这个系列中,长度为 1 的元组不太可能很快被使用。(为了完整起见,我将他们称为*单身族。)*长度为 4 或更长的元组使用两种不同的命名方案。有些人更喜欢拉丁前缀,称这些列表为四元组、五元组、六元组等。其他人更喜欢称它们为 4 元组、5 元组、6 元组等等。

元组用括号表示,可以用来表示数据。

假设您正在运营一个电子商务网站,该网站提供单一产品并允许客户发布评级。在这种情况下,评级的基本表示形式是一对:(客户 id,评级)。一旦您向站点添加第二个产品,格式需要从一对扩展到三对:(客户 id,产品 id,评级)。当您提供多种产品并允许客户随时更改他们的评分时,第四项是必需的:(客户 id、产品 id、日期和时间、评分)

换句话说,元组的长度通常取决于您想要编码多少上下文信息。

当项目数量变化或无法预先预测时,使用可变长度列表。可以添加新项目,也可以删除现有项目。除非另有说明,术语列表总是指可变长度的列表。

为了结束我们对基本集合的讨论,我将概述我们已经讨论过的三种类型:

Fig. 3

高阶集合

在我忘记之前,关于这个主题还有最后一件事:集合可以被组织在集合中。

换句话说,我们可以有集合的集合、列表的集合、元组的集合、集合的列表、列表的列表、元组的列表、集合的元组、列表的元组和元组的元组。我将这些对象称为高阶集合

例如,图像可以通过红/绿/蓝像素强度来表示。对于这三个颜色通道中的每一个,我们都有一个强度列表。图像整体可以看作是三个列表的列表。几个图像依次形成三个列表的列表。

有人提到,一个数据可以被认为是一个元组,一个数据点是一个属性值的集合(为特定目的和在特定场合测量)。有了高阶集合的概念,我们现在可以将数据点理解为一组元组。最后,监督学习中的数据集可以描述为一系列标记的示例,这些示例依次是对,由一组元组(数据点)和一个目标值组成。

正如你所看到的,我们可以很容易地从基本集合中构建越来越复杂的高阶集合。

大文本数据

既然我们已经讨论了数据集和集合,我们可以先来看看最近机器学习最有成效的应用之一:自然语言分析。

在本系列中,我们将探索适用于文本数据和图像的方法。这是由两个事实驱动的:

  1. 计算机视觉和自然语言处理的大多数最新成果都是通过机器学习实现的。[1, 2]
  2. 我们文明的很大一部分输出是以文本或图像的形式编码的。

Fig. 4: The Long Room of the Old Library at Trinity College Dublin (Photo by David Iliff / CC BY-SA 4.0)

2010 年,谷歌图书搜索项目报告了近 1.3 亿本不同的图书[3],而科学文章的数量估计到 2009 年已超过 5000 万篇[4]。

仅美国专利商标局 2011 年发布的专利数量就达到了 800 万件。[5]要获得专利,发明者必须披露技术信息。无论专利的经济影响可能是什么,它们显然包含有价值的见解,并受到机器学习分析的影响。

语音识别将语音翻译成文本,从而进一步扩大了文本分析的范围。平均来说,人类每天大约说 16000 个单词。从全球来看,这相当于在 24 小时内说了超过 100 万亿个单词。此外,据报道,每分钟有 400 小时的视频内容上传到 YouTube。[7]

大量文本数据的存在,加上机器的学习能力,催生了机器阅读。搜索引擎和虚拟助手每天提供给我们的答案,在很大程度上是通过阅读了数百万文本文档的系统获得的。

我们希望我们的人工智能助手能够涵盖广泛的主题,并提供准确的答案。在所有其他条件相同的情况下,更大的数据可用性有助于满足这两个要求:它增加了覆盖范围,并导致模式识别能力的提高。

词汇多样性

我们可以使用列表和集合之间的差异来计算我们的第一个自然语言处理特征。

词汇表是文本文档中的一组单词。换句话说,这是在文档中至少出现一次的单词的集合。另一方面,实际的文本可以被认为是一个单词列表(和一些其他符号)。

假设你的目标是确定一本书是否适合初级语言学习者。您可以用于此任务的一个特性是词汇大小(集合大小)和文本长度(列表大小)之间的比率。这被认为是词汇多样性的几个措施之一。

对于儿童书籍和针对外语学习者的教科书来说,该特征的价值相对较低。在这种情况下,词汇的规模很小,文本的长度(相对)很大,以提供充足的学习机会。

另一方面,我们有赫尔曼·梅尔维尔的小说《白鲸》。《T2》中 44%的单词只出现一次,75%的单词出现不超过四次。粗略地说,这本书的每一行都引入了一个新词,因此,这本书更适合高级学生和热心读者。

字数

术语字数是自我描述的缩影。它表示由一个单词和一个计数组成的一对。

一个例子是,在梅尔维尔的小说中,单词灵巧出现了两次。

一个单词计数并不能真正告诉我们什么。要开始执行文本分析,我们必须获得词汇表中每个单词的计数。

Fig. 5: Word counts in Melville’s “Moby-Dick”: Each circle represents a word. Words that occur once (hapax logemena) are shown in red. Words that occur twice (dis legomena) are shown in blue.

冠词、介词和代词往往位于频率排名的首位。在白鲸中出现频率最高的词是定冠词 the 。[8]

更有趣的是,单词 hiswhale 分别排在#9 和#21。即使我们不知道内容的其他任何事情,仅仅通过看这两个统计数据,这本书似乎很可能与一个人和一条鲸鱼有关。

获取字数是自然语言处理工作流程中的首要步骤之一。计数可能会以复杂的方式进行处理并增加其他功能,但它们至少总会发挥一些作用。

在本系列的课程中,我们将扩展字数统计,并系统地使用它们作为有效文本分析的基础。

本系列的下一部分将讨论如何精确地表述你在机器学习方面面临的问题。它将结合到目前为止已经介绍过的所有概念来介绍函数并探索模型的概念。

感谢您的阅读!如果您喜欢这篇文章,请点击“鼓掌”按钮并跟随我阅读本系列的下一篇文章。

参考

[1] LeCun,y .,Bengio,y .和 Hinton,g .,2015 年。深度学习。性质521 (7553),第 436 页

[2]坎布里亚和怀特,2014 年。自然语言处理研究综述。 IEEE 计算智能杂志9 (2),第 48–57 页。

[3]http://book search . blogspot . de/2010/08/books-of-world-stand-up-and-be-counted . html

[4]金哈,A.E .,2010。5000 万篇:对现存学术文章数量的估计。博学出版23 (3),第 263—258 页。

[5]https://www . USPTO . gov/learning-and-resources/IP-motion/millions-patents

[6] Mehl,M.R .,Vazire,s .,Ramírez-Esparza,n .,Slatcher,R.B .和 Pennebaker,J.W .,2007 年。女人真的比男人更健谈吗?。科学317 (5834),第 82–82 页。

[7]https://www . Forbes . com/sites/stevenrosenbaum/2015/07/24/fans-self ie-and-the-future-of-TV/# 757 de 7435 ffd

[8]例如,见李,w .,p .和科乔,g .,2010 年。用双参数函数拟合排序语言数据。12 (7),第 1743–1764 页。

从零开始的机器学习:第 3 部分

原文:https://towardsdatascience.com/machine-learning-from-scratch-part-3-ed572330367d?source=collection_archive---------5-----------------------

数组和表示

目录

第 3 部分介绍了数组。这一系列高阶集合允许我们以机器学习算法可以处理的格式描述图像和文本文档。

在这个过程中,我们将讨论情感分析,这是自然语言处理的一个重要应用,用于市场研究和声誉管理。

数组

上一次,我们介绍了高阶集合的概念:在集合中组织的集合。

数组是机器学习中最重要的高阶集合族。它们用于表示图像、文本文档和许多其他类型的数据。

数组有三个重要的属性。我将首先列举它们,然后更详细地讨论:

  1. 数组是一维或多维的列表。
  2. 特定级别上的所有列表都具有相同的格式。
  3. 我们假设数组中的所有元素都是数字。

向量、矩阵和 3D 阵列

一维数组就是一个列表。一个二维数组是一个列表的列表。而三维数组是列表的列表的列表。在本文中,我们不会使用任何三维以上的数组。

一维数组称为向量。二维数组称为矩阵。我们将不介绍三维数组的特殊术语,而简单地称它们为 3D 数组

相同的级别,相同的格式

在数组中,给定级别上的所有列表都具有相同的格式。

考虑下面这个例子: [ [ 1,2 ],[ 3,4 ],[ 5,6 ] ] 。这是一个包含三个列表的列表。三个内部列表中的每一个都有相同数量的元素:2。因此,这个集合可以作为一个数组。

相比之下,集合 [ [ 1,2,3],[ 4 ],[ 5,6 ] ] 不符合数组的条件,因为内部列表的长度不同:分别为 3、1 和 2。

仅限数字

数组中的单个元素被称为它的条目(我将使用这个术语)或元素

所有条目都被假定为数字。

图像表示

我们将首先讨论如何使用矩阵来表示灰度图像。后面一节将把我们的讨论扩展到彩色图像。名副其实,我们将一步一步来。

图像是排列在网格上的像素集合。

像素是屏幕上呈现的最小元素,也是计算机视觉中最低层次的分析。像素的特征在于以下属性:

  1. 网格上的位置
  2. 与光强度相关的一个或多个测量值

表示灰度图像

考虑以下数字 3 的例子:

Fig. 1

为了将该图像分解成像素,我们可以施加一个网格,将图像分割成单元:

Fig. 2

该网格中的每个单元将被视为一个像素。

像素的光强度不同,我们可以用 0 到 255 的灰度来衡量。值 0 对应黑色,值 255 对应白色。中间的值是不同的灰度。

使用这种尺度的测量,我们可以从视觉表示切换到数字表示:

Fig. 3

推广到其他图像

到目前为止,我们看到了一个高 7 像素、宽 6 像素的特定图像。

为了将这种表示推广到这种格式的所有图像,可以用变量替换特定值:

Fig. 4

我们可以用字母 m 表示图像的高度,用字母 n 表示图像的宽度。在前面的例子中,我们有 m = 7n = 6

使用这个符号,我们现在可以从一个 7 x 6 图像推广到一个 m x n 图像。

Fig. 5

如果去掉灰色边框,在网格周围加上方括号,我们就得到一个矩阵表示。

作为数字表格的矩阵

Fig. 6

矩阵是一个或多个内部列表的外部列表。

图 6 示出了矩阵形式的条目为 m 行和 n 列。有两种方式来看待这个问题:我们可以把行看作内部列表,把矩阵看作行的列表,或者我们可以把重点放在列上,把矩阵看作列的列表。

从第一个角度来看,内部列表相互堆叠。例如,在矩阵 [ [ 1,2 ],[3,4] ] 中,可以将列表 [ 1,2 ] 堆叠在列表 [ 3,4 ] 之上,形成一个表格。或者,我们可以将这两个列表视为表的列。

矩阵中的单个条目表示为 a_ij 。[我用下划线“_”表示下标。]

字母 i 代表行的索引,字母 j 对应列。例如,第 3 行第 2 列中的条目表示为 a_32。图 3 中,我们有 a_32 = 255

RGB 图像的 3D 阵列

彩色图像最常通过 RGB 模型来描述,其中每个像素的颜色表示为三元组 (r,g,b) ,这三项分别对应红光、绿光和蓝光的强度。

为了用数字表示 RGB 图像,我们使用 3D 数组。二维数组形成一个表格,而三维数组可以被视为一个立方体:

Fig. 7

这涵盖了计算机视觉的机器学习方法的图像表示的基础。

接下来,我们将讨论向量如何与矩阵相关联,以及为什么它们适合于文本文档的表示。

向量作为矩阵的特殊情况

回想以下两个事实:

  • 向量是一系列数字。
  • 矩阵可以被认为是一个表格,按行和列排列。

结合这两个事实,向量可以被视为矩阵中的特定行或列。

一个行向量是一个单行的矩阵( m = 1 )。一个列向量是一个单列的矩阵( n = 1 )。

行向量、列向量和矩阵可以用方括号或圆括号括起来。逗号通常被省略。

图 3 中的矩阵由 7 个行向量和 6 个列向量组成。例如,我们可以从这个矩阵的第二行中提取以下行向量:【255 0 0 0 0 255】。

我们用 x_i 表示单个向量条目,用 d 表示条目数量。

向量和矩阵可以说是机器学习中最重要的两种数据结构。下面是一个快速对比:

Fig. 8

情感分析

当你在网上发表对一个品牌的看法时,计算系统可能会分析你的陈述,找出它表达的是积极还是消极的观点,并将结果用于市场研究和声誉管理目的。自然语言处理(NLP)的这种应用被称为情感分析

一个重要的经验发现是,情绪分析的简单方法可以实现出色的性能,并且很难超越。[1,2]毕竟,许多顾客都强调要让任何愿意阅读的人都能理解。

我将使用情感分析来解释如何使用向量来表示文档。

文档表示

电影中的 NLP

电影评论是情感分析研究中一个流行的数据源。[3]它们很容易大量获得,提出了有趣的挑战,这将在后面的文章中讨论,并可以帮助预测票房收入[4]。

Copyright: nyul / 123RF Stock Photo

虽然本节中概述的方法可以有效地应用于成千上万不同长度的综述,但我们将只使用一小部分表达明确意见的综述。这里的重点是概念。这些机器可以搬运重物。

计划是从一个初始词汇表开始,通过一系列操作传递词汇表中的单词,这些操作产生一组相关的特征。为语料库中的每个文档生成一个向量,并且文档向量中的每个条目将对应于所选特征之一。但首先我们应该澄清一些术语。

语料库、文档和单词

一个文集是文档的集合。

在 NLP 中,文档是任何具有我们感兴趣的属性的单词的集合。

一个文档可以短到一个单词或句子,也可以长到一整本书或一个网站。

在情感分析的情况下,我们对文档中表达的观点的极性感兴趣。它表达的是积极的还是消极的观点?

顺便说一下,我将使用术语单词来指代符号序列。根据这一定义,数字和标点符号也算作单词。

初始词汇

以下是我们将使用的语料库:

  • 我喜欢这部电影。
  • 我讨厌这部电影。
  • 我看过的最好的电影。
  • 多么令人失望的电影。

该语料库中按字母顺序排序的词汇包含以下单词:

{ a,最好,失望,曾经,讨厌,我,我曾经,爱,电影,看过,这个,什么,。}

在我们继续之前,我建议你停下来想一想下面的问题:你会使用这个词汇表中的每个单词来进行情感分析吗?或者我们可以删除或更改一些单词来提高模式识别?

管道

在许多 NLP 项目中,初始词汇表是通过管道传递的:一系列操作,其中一个步骤的输出是下一个步骤的输入。

本节中描述的特定操作序列简化了数据并消除了不相关的单词。

警告!小心行事!虽然下面提到的许多步骤在不同的任务和领域中相当可靠地工作,但是当应用得过于激进时,它们会过滤掉相关的单词。

代词等虚词就是一个很好的例子。这些词主要构成句子的句法。在大多数应用中,我们可以删除虚词,而不会造成信息的重大损失。然而,对于一些心理语言学的应用,这些词可以提供有用的特征。[5]例如,一项研究发现,虚词使用的相似性预示着浪漫的兴趣和关系的稳定性。[6]

强制性的警告已经过时,下面是整个过程的概述:

Fig. 9

我们应用的第一步可以称为归一化。缩略形式(如我有)展开(我有),而拉长的词(如loove)则缩略为其常规形式()。就我个人而言,我并不反对爱情。只是当所有爱的表达都有相同数量的 o 时,模式更容易识别。规范化的词汇表如下所示:

{ a,最好,不争气,曾经,讨厌,有,我,爱,电影,看过,这个,什么,。}

下一步是转换成小写。单词 bestwhat 的第一个字母是否大写对情感分析有影响吗?—不,不是真的:

{ a,最好,不争气,曾经,讨厌,有,我,爱,电影,看,这个,什么,。}

另一个常见的步骤是删除非字母单词。例如,句号携带的相关信息很少。让我们摆脱它:

{ a,最好,不争气,曾经,讨厌,有,我,爱,电影,看,这个,什么}

第 2 部分提到,一些词,包括冠词、限定词、介词和基本动词,几乎出现在每篇文章中:在正面评论和负面评论中,在电影评论和非电影评论中,在前一句中,在这一句中,在下一句中……你明白了。这些字叫做停用字。让我们删除它们:

{最佳,失望,有史以来,恨,爱,电影,看}

在特定的领域中,有一些词的行为类似于停用词,尽管它们通常不被认为是停用词。例如,单词 moviesee 出现在电影评论的很大一部分中,而没有提供关于观点极性的线索。我将这些词称为特定领域停用词。删除这些单词是管道中的最后一步,会产生以下结果:

{最好的,令人失望的,有史以来,恨,爱}

总的来说,我们已经排除了 13 个词汇中的 8 个,并且得到了我认为是一组直觉上似乎合理的词,这些词与情感分析相关。

二元文档向量

使用剩余的五个单词*(最好的、令人失望的、曾经的、讨厌的、喜欢的)*作为特征,我们现在可以将每个文档表示为具有五个条目的向量。对于每个特征,都有相应的向量条目。

二元向量是短文档的合适选择。这些向量的条目都是 0 或 1。

如果文档中存在该特征(单词),我们将特征值指定为 1,如果该特征不存在,则将值指定为 0。

以第三个文件为例(我看过的最好的电影。)。五个特性中的两个在本文档中出现:第一个特性(最佳)和第三个特性(最佳)。因此,我们将第一个和第三个条目设置为 1,将其他条目设置为 0。这给了我们矢量*【10100】*。

对语料库中的每个文档应用相同的过程,我们获得以下向量表示:

  • 我喜欢这部电影。【0 0 0 1】
  • 我讨厌这部电影。【0 0 1 0】
  • 我看过的最好的电影。【1 0 1 0 0】
  • 多么令人失望的电影。【0 1 0 0】

恭喜你!如果你正在阅读这篇文章,你已经学会了如何用机器学习算法可以处理的格式来表示图像和文本文档。

下一次,我们将讨论函数——我希望你们能像我一样对这个主题充满热情。

机器学习中用来预测未知属性的模型都有函数的形式。神经网络,包括您可能经常读到的深度神经网络,本质上是应用于数字数组的函数序列。

感谢您的阅读!如果您喜欢这篇文章,请点击“鼓掌”按钮并跟随我阅读本系列的下一篇文章。

参考

[1]王,s .和曼宁,C.D .,2012 年 7 月.基线和二元模型:简单,良好的情绪和主题分类。在计算语言学协会第 50 届年会会议录:短文-第 2 卷(第 90-94 页)。计算语言学协会。

[2]李,李,赵,赵,刘,王,杜,谢,2016 .加权神经 n-grams 模型:文本分类的新基线。在colling 2016 年会议录,第 26 届计算语言学国际会议:技术论文(第 1591-1600 页)。

[3] Maas,A.L .,Daly,R.E .,Pham,P.T .,黄,d .,ng,A.Y .和 Potts,c .,2011 年 6 月。学习用于情感分析的词向量。计算语言学协会第 49 届年会会议录:人类语言技术-第 1 卷(第 142-150 页)。计算语言学协会。

[4]阿苏尔和胡伯尔曼,文学学士,2010 年 8 月。用社交媒体预测未来。2010 年 IEEE/WIC/ACM 网络智能和智能代理技术国际会议论文集-第 01 卷(第 492–499 页)。IEEE 计算机学会。

[5] Pennebaker,J.W .,Francis,M.E .和 Booth,R.J .,2001 年。语言学调查与字数统计:LIWC 2001。马赫威:劳伦斯·厄尔鲍姆协会71 (2001 年),第 2001 页。

[6]爱尔兰,M.E .,Slatcher,R.B .,Eastwick,P.W .,Scissors,L.E .,Finkel,E.J .和 Pennebaker,J.W .,2011 年。语言风格匹配预测关系的开始和稳定。《心理科学》,第 22 卷第 1 期,第 39-44 页。

从零开始的机器学习:第 4 部分

原文:https://towardsdatascience.com/machine-learning-from-scratch-part-4-10117c005a28?source=collection_archive---------9-----------------------

功能和分类

目录

Changelog:我在第 2 部分关于集合的讨论中添加了一些句子。

修改后的文本提到集合用大写字母表示,尤其是 S ,而小写字母用于集合成员。比如我们可以把冰淇淋基本口味的集合, {香草、草莓、巧克力} 称为 S

此外,更新后的部分引入了集合成员和集合大小的表示法。元素 x 属于集合 S 的事实被写成 x ∈ S 。比如我们有:香草∈ S 。器械组名称周围的竖线表示其大小。对于基本口味的设置,我们有 |S| = 3

功能

函数是机器学习的核心。

在项目开始时,业务目标是根据功能来指定的。

在项目过程中,几乎每一步都要用到函数来处理数据、发现模式和评估系统的性能。

在项目结束时,最终交付给客户的是另一个功能。可交付物可以用编程语言编码,或者采用几个低级功能组合的形式,但它仍然是一个功能。

函数将输入映射到输出

许多读者将熟悉数学和/或编程中的函数。

数学上,函数指定一个集合中的元素如何与另一个集合中的元素相关联。

程序化,一个函数处理一个输入生成一个输出。

下图结合了两种定义的各个方面:

Fig. 4.1: Edited version of a graphic released into the public domain by Wvbailey

这两个定义是一致的。[1]函数的可接受输入属于一个集合,而函数生成的输出属于另一个集合。函数定义了我们如何从一个到另一个。

这就是关于函数本质的所有知识。

作为未来的预览,我将提到机器学习中心功能的输入是上次讨论的对象的表示(例如,像素强度和某些单词的存在或不存在)。函数的输出是我们感兴趣的目标的预测值。

注释

为了从数学上定义一个函数,我们需要指定两件事:

  1. 涉及到的集合
  2. 一个集合中的元素映射到另一个集合中的元素的规则。

函数中的集合

函数 f 将集合 A 中的元素映射到集合 B 中的元素的事实被写成 f: A → B

A 和 B 这两组分别称为共域。在许多情况下,它们可以引用同一个集合。

本符号中使用的字母( fAB) 可以理解为占位符。我们会经常使用不同的名字。

绘图

功能 f 的输入通常用字母 x 表示。在机器学习的上下文中, x 通常指代表一个对象的数组。

字母 y 表示功能的输出。我们将使用字母 y 来表示预测。

将这些积木组合起来,下面的等式简单地陈述了 y 是函数 f 对输入 x 的应用的输出: f(x) = y

功能名称

在许多情况下,我们需要引用不止一个函数。为了将它们分开,可以采用以下命名策略之一:

  • 字母表中的其他字母,尤其是 gh
  • 下标(或上标),如 f_1f_2 等。
  • 单词或单词缩写:如增量inc

简单的例子

考虑名为 fahrenheit_to_celsius 的函数的自我描述示例。

鉴于在实验室中已经达到了数万亿华氏度的温度[2],我认为用这组实数来表示这个函数是公平的。在集合的层次上,我们可以写:

在单个元素的层次上,我们有:

使用强调数学和编程之间等价的风格,这个函数对应于下面的 Python 代码[3]:

实值函数

为了我们的目的,一个标量是一个实数【4】,或者换句话说,是实数ℝ.集合的一个成员或者,我们可以把标量想象成一个只有一个条目的向量,或者一个只有一行一列的矩阵。

一个实值向量由 d 实数组成,类似地属于集合ℝd.,一个实值矩阵有m×n实数项,属于ℝ(m×n)。最后,实值 3D 数组属于 R^(m x n x o)[5]。

Fig. 4.2

本系列中使用的所有数组和函数都是实值的。这包括第 3 部分提到的二进制向量。当然,0 和 1 也是实数。为了强调它们是实数,我们可以把它们写成 0.0 和 1.0。

监督学习问题

现在我们已经介绍了实值函数,我们可以开始讨论使用监督机器学习可以解决的问题。

在高层次上,分类和回归是有区别的。

Fig. 4.3

分类

分类任务中,我们试图预测的目标是离散的。它可以采用 n 值之一,或者换句话说,属于 n 类之一。

当感兴趣的对象被认为是类别的成员而不是的成员时,术语分类被用来代替分类。例如,一些作者更喜欢术语文档分类而不是文档分类

对于 n = 2 ,预测正确类别的任务称为二元分类。这两类通常被称为正类负类

n > 2 的术语为多级分类n 级分类。

Fig. 4

将电子邮件归类为值得或不值得放在收件箱中是一项二元分类任务。给来自朋友、同事、服务、广告商和其他团体的电子邮件分配几个可能的标签之一涉及多个类别。

区分良性和恶性皮肤病变是一项二元分类任务。另一方面,癌症的分期是一个多类分类问题。

可能性

一个区间*【a,b】是一组实数,包括 ab 之间的每一个数,包括端点。区间【0,1】*包含从 0 到 1 的所有实数。

A 概率p 是区间*【0,1】*的成员。

术语反概率是指 1-p 。显然,概率和反概率加起来是 1。

一个概率分布是一个向量,其 d 条目是总和为 1 的概率。我会把概率分布写成*【0,1]^d* 。

向量*【0.2,0.4,0.3,0.1】*是概率分布的一个例子。

Fig. 5

概率输出

分类输出是概率性的。

在二元分类中,输出是物体属于正类的概率 p 。反概率 1-p 是对象是否定类成员的概率。

高概率表明该对象很可能是正类的实例。

输出为零意味着不可能属于正类,而属于负类是确定的。相反,如果概率为 1,则一个对象必然属于正类。

比如假设输出为 p = 0.85 。这意味着有 85%的可能性该对象属于正类,有 15%的可能性(1–0.85 = 0.15)该对象是负类的成员。

在多类分类中,输出是一个概率分布。

分类器是函数

分类器是一个被设计用来执行分类的功能。

分类器的输入是对象的表示。生成的输出是一个预测。

如果输入是向量,则分类器的域和余域可以表述如下:

A function that maps a vector representation to a probability

类似地,如果物体用矩阵表示,我们写 :

A function that maps a matrix to a probability

假设 |C| 是类的数量,分类器将矩阵映射到适当长度的概率分布的事实被写成:

A function that maps a matrix to a probability distribution

MNIST

如果不提到数字识别和 MNIST 数据集,任何关于机器学习本质的教程都是不完整的。

识别数字是机器学习中具有历史意义的重要任务。分类器接收图像的表示,并返回从 0 到 9 的十个可能数字的概率分布。然后,系统选择类别概率最高的数字。

MNIST 可以说是所有机器学习中最著名的数据集,包含 70,000 张 28x28 像素的灰度图像。这种标记图像集合的最广泛使用的形式已经在二十年前出版了。[7]

Fig. 6: A few samples from the MNIST data set (Image by Josef Steppan / CC BY-SA 4.0)

应用于 MNIST 数据的数字识别器是将 28 行 28 列的矩阵映射到 10 类概率分布的函数:

最初,这项任务有直接和明显的应用,例如在手写信件和支票的时代,邮政服务和金融服务的效率提高。

随着时间的推移,研究人员在数字识别任务中取得了接近人类的表现,并转向更雄心勃勃的目标。

与此同时,MNIST 数据集已经被重新用于测试机器学习的新想法。如果一个分类算法不能在 MNIST 上给出很好的结果,它很可能对更具挑战性的问题没有多大用处。

由于多年来对 MNIST 数据集的严格使用,实验结果可以很容易地与数百项同行评议的研究进行比较。这是标准化测试的一个重要好处。

回归

另一个监督学习的问题是回归。我想在本文中提供一个简要的概述,然后在第 5 部分中更详细地讨论这个主题。

回归任务中,目标是连续的。换句话说,它可以取某个范围内的任何值。

根据上下文,术语回归变量指独立变量(输入)或设计用于执行回归的函数(类似于分类器)。

回归的一个经典应用是预测价格。在这种情况下,范围将是一组正实数(或介于 0 和最高价格之间的区间)。

回归的其他应用包括预测生物标记、需求、环境测量、性能、受欢迎程度、评级、风险、分数和产量。

基线

在这篇文章的结尾,我想讨论一下使用常量函数作为基线。

常量函数对每个输入返回相同的输出。它们被写成 f(x) = c ( 其中 c 是一个常量值)并且可以作为基线。

在机器学习中,基线是生成预测的简单规则:可以用几句话描述的东西,没有任何复杂性。

可以说,最重要的基线是总是预测最频繁出现的目标值。(另一种方法是随机生成预测。如果没有关于目标值分布的可靠信息,后者可能是正确的选择。)

当您评估机器学习系统时,以下问题应该是首先想到的:

  1. 我试图解决的问题的基线是什么?
  2. 机器学习系统是否显著优于基线?

情感分析的基线

假设你委托一个机器学习专家开发一个定制的情感分析解决方案。要求是收集相关网站上对贵公司的提及,并在发现公开表达的意见时发送通知。

快进到第一次迭代,您会收到一份关于初始测试结果的报告:系统达到了 90%的准确率。这是好事还是坏事?嗯,看情况。

考虑两种情况:在第一种情况下,一个代表性的样本表明,超过 90%的公开表达的对你的公司的看法是积极的。好消息是顾客喜欢你。坏消息是,机器学习项目正在失败,因为系统没有超越总是预测最频繁目标的基线。如果正面评价由目标值 1 表示,则基线将是常数函数 f(x) = 1

在第二种情况下,你的公司是有争议的,公众舆论在粉丝和批评者之间平分秋色。在这种情况下,90%的准确率是项目成功的第一个迹象。

因此,基线提供了对系统性能预期的下限。

到目前为止,我们将分类器和回归器视为一个黑盒。

从下一篇文章开始,我们将打开这个盒子,描述应用机器学习中最常用的函数。

感谢您的阅读!如果你喜欢这篇文章,请点击“鼓掌”按钮,跟我来阅读这个系列的下一部分。

笔记

[1]这假设编程的函数对于给定的输入总是返回相同的输出,并且不会引起任何副作用。

[2]http://blogs . nature . com/news/2012/08/hot-stuff-CERN-physicians-create-record-breaking-subatomic-soup . html

[3]当然,计算机使用的浮点数并不完全对应于一组实数。它们的范围有限,而且不够精确。

[4]更确切地说,标量是场的一个元素。字段是一组定义了特定规则的数字。实数是一个字段。

[5]不同的作者对 3D 阵列的维度使用不同的符号,尤其是最后一个。我与之交谈过的一位数学家更喜欢使用字母 p ,因为 o 在外观上与 0 很接近。最终,我决定选择字母 o 。用三个连续的字母很直观,字母 p 是留给概率的。

[6]缩写 MNIST 数据集代表经修改的国家标准与技术研究所数据集。

[7] LeCun,y .,Bottou,l .,Bengio,y .和 Haffner,p .,1998 年。基于梯度的学习在文档识别中的应用。IEEE 会议录86 (11),第 2278–2324 页。

机器学习基础(二):神经网络

原文:https://towardsdatascience.com/machine-learning-fundamentals-ii-neural-networks-f1e7b2cb3eef?source=collection_archive---------3-----------------------

在我之前的文章中,我通过展示成本函数和梯度下降在学习过程中的核心作用,概述了机器学习的工作原理。这篇文章通过探索神经网络和深度学习如何工作来建立这些概念。这篇文章很少解释,很多代码。原因是,我想不出任何方式能比三个蓝色一个棕色的不可思议的视频放在一起更清楚地阐明神经网络的内部工作方式——见完整播放列表这里

这些视频展示了如何向神经网络输入原始数据——如数字图像——并以惊人的精度输出这些图像的标签。这些视频以一种非常容易理解的方式强调了神经网络的基础数学,这意味着即使那些没有深厚数学背景的人也可以开始理解深度学习的本质。

这篇文章旨在作为这些视频的“代码”补充(完整的 Tensorflow 和 Keras 脚本可在文章末尾获得)。目的是演示如何在 Tensorflow 中定义和执行神经网络,使其能够识别如上所示的数字。

TensorFlow(对于那些不知道的人来说)是谷歌的深度学习库,虽然它很低级(我通常在我的深度学习项目中使用更高级的 Keras 库),但我认为它是一种很好的学习方式。这仅仅是因为,尽管它在幕后做了大量不可思议的事情,但它需要你(是的,你!)来明确定义 NN 的架构。这样你会更好地理解这些网络是如何工作的。

神经网络

神经网络是大脑中发生的生物过程的数学和计算抽象。具体来说,它们粗略地模拟了相互连接的中子对刺激的反应——例如新的输入信息。我没有发现生物学类比对理解神经网络特别有帮助,所以我不会继续沿着这条路走下去。

神经网络通过计算输入向量的加权总和来工作,然后输入向量通过非线性激活函数,从而通过非线性转换层创建从输入到输出的映射。变换层或隐藏层中的权重(由中子表示)被反复调整,以表示输入到输出的数据关系。

定义层和激活

第一步,我们定义网络的架构。我们将创建一个四层网络,包括一个输入层,两个隐藏层和一个输出层。请注意一层的输出如何成为下一层的输入。就神经网络而言,这个模型非常简单,它由密集的完全连接的层组成,但仍然非常强大。

输入层——有时也被称为可见层——是以原始形式表示数据的模型层。例如,对于数字分类任务,可见图层由对应于像素值的数字表示。

在 TensorFlow *(所有代码如下)*中我们需要创建一个占位符变量来表示这个输入数据,我们还将为每个输入对应的正确标签创建一个占位符变量。这有效地设置了训练数据——我们将用于训练神经网络的 X 值和 y 标签。

隐藏层使神经网络能够创建输入数据的新表示,模型使用它来学习数据和标签之间的复杂和抽象关系。每个隐藏层由神经元组成,每个神经元代表一个标量值。此标量值用于计算输入加上偏差的加权和(本质上是 y1 ~ wX + b),从而创建线性(或更具体地说是仿射)变换。

在 Tensorflow 中,您必须明确定义构成该层的权重和偏差的变量。我们通过将它们包装在 tf 中来做到这一点。变量函数——这些被包装为变量,因为参数会随着模型学习最能代表数据关系的权重和偏差而更新。我们用方差非常低的随机值来实例化权重,并用零填充偏差变量。然后,我们定义发生在该层的矩阵乘法。

这个变换然后通过一个激活函数,(这里我使用 ReLU 或整流线性单元)使线性变换的输出变成非线性。这使得神经网络能够模拟输入和输出之间复杂的非线性 T21 关系——点击这里查看 Siraj Raval 关于激活函数的精彩视频讲解。

输出层是模型中的最后一层,在这种情况下,大小为 10,每个标签一个节点。我们将一个 softmax 激活应用到这一层,以便它跨最终层节点输出介于 0 和 1 之间的值——代表跨标签的概率。

成本函数和优化

既然定义了神经网络架构,我们就设置成本函数优化器。对于这个任务,我使用分类交叉熵。我还定义了一个准确性度量,可以用来评估模型的性能。最后,我将优化器设置为随机梯度下降,并在实例化后调用它的 minimise 方法。

最后,可以运行模型——这里运行 1000 次迭代。在每次迭代中,一个小批量的数据被输入到模型中,它进行预测,计算损失,并通过反向传播,更新权重,重复这个过程。

** 摘自三蓝一棕的《但是,什么是神经网络视频**

这个简单的模型在测试集上达到了大约 95.5%的准确率,这还不算太差,但是还可以更好。在下面的图中,您可以看到模型每次迭代的准确性和成本,有一点非常明显,即训练集和测试集的性能之间存在差异。

这表明过度拟合——也就是说,模型学习训练数据太好,这限制了它的泛化能力。我们可以使用正则化方法来处理过度拟合,这将是我下一篇文章的主题。

感谢您的阅读🙂

页(page 的缩写)完整的 Tensorflow 脚本可以在这里找到,相同的模型在 Keras 这里定义。

原载于 2017 年 12 月 21 日 dataflume.wordpress.com**的

机器学习基础(一):成本函数和梯度下降

原文:https://towardsdatascience.com/machine-learning-fundamentals-via-linear-regression-41a5d11f5220?source=collection_archive---------0-----------------------

* 这是机器学习基础系列的第一部分。ML 基础(二):神经网络可以在https://towards data science . com/machine-learning-fundamentals-II-Neural-Networks-f1 e 7 b 2 CB 3 eef *

在这篇文章中,我将使用一个简单的线性回归模型来解释两个机器学习 (ML)基础;(1)成本函数和;(2)梯度下降。线性回归不是 ML 工具包中最强大的模型,但由于它的熟悉性和可解释性,它仍然在研究和行业中广泛使用。简单地说,线性回归用于估计连续的或/和分类数据与连续的输出变量之间的线性关系——你可以在我以前的帖子中看到这样的例子https://conors datablog . WordPress . com/2017/09/02/a-quick-and-tidy-data-analysis/

在这篇文章中,我将使用 Xy 来指代变量。如果你喜欢更具体的东西(就像我经常做的那样),你可以想象 y 是销售额, X 是广告支出,我们想要估计广告支出如何影响销售额。从视觉上,我将展示线性回归如何学习拟合这些数据的最佳直线:

机器学习什么?

人们在开始学习 ML 时经常遇到的一个问题是:

“机器(即统计模型)实际学习的是什么?”

这将因模型而异,但简单来说,模型学习函数 f ,使得 f ( X )映射到 y 。换成不同的 yy,模型学习如何取 X (即特征,或者更传统的说法,自变量),以便预测 y (目标,响应或者更传统的说法,因变量)。

在简单线性回归(**y~ B0+B1 X*其中 X 是一列/变量)的情况下,模型“学习”(读取:估计)两个参数;

  • b0:偏差(或者更传统的说法是 T42 y 截距);而且,
  • b1:坡度

偏差是当 X 为 0 时 y 的水平(即广告支出为 0 时的销售额),斜率是 yX 中每单位增加的预计增加或减少的比率(即广告支出每磅增加多少销售额)。两个参数都是标量(单值)。

一旦模型学习了这些参数,它们就可以被用于在给定新的 X 值的情况下计算 y 的估计值。换句话说,当你不知道什么是 y 时,你可以使用这些学习到的参数来预测 y 的值——嘿,一个预测模型!

学习参数:成本函数

学习 LR 模型的参数有几种方法,我将集中讨论最能说明统计学习的方法;最小化一个成本函数

记住,在 ML 中,重点是从数据中学习**。用一个简单的类比也许能更好地说明这一点。作为孩子,我们通常通过被告知不要做某事或因做了不该做的事而受到惩罚来学习什么是“正确的”或“好的”行为。例如,你可以想象一个四岁的孩子坐在火旁取暖,但不知道火的危险,她把手指放进去烧伤了。下一次她坐在火边,她没有被烧伤,但是她坐得太近,太热了,不得不离开。第三次她坐在火边时,她找到了既能保暖又不会有任何危险的距离。换句话说,通过经验和反馈(烧伤,然后变得太热),孩子学会了坐在离火的最佳距离。在这个例子中,火的热量充当了**成本函数——它帮助学习者纠正/改变行为,以最大限度地减少错误。****

在最大似然法中,成本函数用于估计模型的表现有多差。简而言之, 成本函数是衡量模型在估计 X 和 y 之间关系的能力方面有多差的标准。 这通常表示为预测值和实际值之间的差异或距离。成本函数(你也可以看到这被称为损失误差。)可以通过迭代运行模型来估计,以将估计的预测与“基本事实”(已知的 y 值)进行比较。

因此,ML 模型的目标是找到使成本函数最小化的参数、权重或结构。

最小化成本函数:梯度下降

既然我们知道模型通过最小化成本函数来学习,您可能自然会想知道成本函数是如何最小化的—输入梯度下降。梯度下降是一种有效的优化算法,试图找到一个函数的局部或全局最小值。

梯度下降使模型能够学习模型应该采用的梯度或方向,以减少误差(实际 y 和预测 y 之间的差异)。简单线性回归示例中的方向指的是应该如何调整或校正模型参数 b0 和 b1 以进一步降低成本函数。随着模型的迭代,它逐渐向最小值收敛,在该最小值处,对参数的进一步调整产生很少或零损失变化,这也称为收敛。

在这一点上,模型已经优化了权重,使得它们最小化成本函数。这个过程是积分(没有微积分双关语的意思!)到 ML 过程中,因为它极大地加速了学习过程——你可以把它看作是一种接受纠正性反馈的方式,以改进你以前的表现。梯度下降过程的替代方案将是强力强制参数的潜在无限组合,直到最小化成本的集合被识别。很明显,这是不可行的。因此, 梯度下降使得学习过程能够对所学习的估计进行校正更新,从而将模型移向参数的最佳组合。

在线性回归模型中观察学习

为了观察线性回归中的学习,我将设置参数 b0 和 b1,并使用模型从数据中学习这些参数。换句话说,我们知道 Xy 之间关系的基本事实,并且可以通过响应于成本的参数的迭代校正来观察学习这种关系的模型(注意:下面的代码是用 R 编写的)。

这里我定义了偏差和斜率(分别等于 4 和 3.5)。我还向 X 添加一列 1(为了实现矩阵乘法)。我还添加了一些高斯噪声到 y 中,以掩盖真实的参数——即产生纯粹随机的误差。现在我们有了一个带有两个变量的数据框架, X 和 *y,*看起来具有正的线性趋势(随着 X 增加, y 的值增加)。

接下来,我定义学习率——它控制每个梯度的步长。如果这个值太大,模型可能会错过函数的局部最小值。如果太小,模型将需要很长时间才能收敛(复制代码并亲自尝试一下!).Theta 存储参数 b0 和 b1,它们用随机值初始化(我已经将它们都设置为 20,这适当地远离真实参数)。n_iterations 值控制模型迭代和更新值的次数。也就是说,模型将进行多少次预测、计算成本和梯度以及更新权重。最后,我创建了一些占位符来捕捉模型每次迭代时的 b0、b1 和均方误差(MSE)的值(创建这些占位符可以避免向量的迭代增长,这在 R 中是非常低效的)。

这种情况下的 MSE 就是代价函数。它仅仅是预测 y 和实际 y 之间的平方差的 平均值 (即残差)

现在,我们运行循环。在每次迭代中,模型将根据θ值预测 y ,计算残差,然后应用梯度下降来估计校正梯度,然后使用这些梯度更新θ值——该过程重复 100 次。当循环结束时,我创建一个数据帧来存储学习到的参数和每次迭代的损失。

当迭代完成后,我们可以绘制出比模型估计的线条。

首先要注意的是粗粗的红线。这是从 b0 和 b1 的初始值估计的线。可以看到,这与数据点完全不符,因此它具有最高的误差(MSE)。但是,您可以看到这些线逐渐向数据点移动,直到确定最佳拟合线(蓝色粗线)。换句话说,在每次迭代时,模型已经学习了 b0 和 b1 的更好的值,直到它找到最小化成本函数的值。模型学习到的 b0 和 b1 的最终值分别为 3.96 和 3.51,非常接近我们设置的参数 4 和 3.5!

瞧啊。我们的机器!它学会了!!

我们还可以看到模型迭代中 SSE 的减少。在收敛和稳定之前,这在早期迭代中需要急剧下降。

我们现在可以使用存储在 theta 中的 b0 和 b1 的学习值来预测新的值 X 的值 y

摘要

这篇文章介绍了一种非常简单的理解机器学习的方法。不言而喻,ML 还有很多内容,但是获得对“引擎盖下”正在发生的事情的基本原理的初步直觉可以大大有助于提高您对更复杂模型的理解。

如何从零开始开发机器学习模型

原文:https://towardsdatascience.com/machine-learning-general-process-8f1b510bd8af?source=collection_archive---------0-----------------------

在本文中,我们将深入研究开发机器学习模型的过程是如何完成的。将会有很多概念被解释,我们将会把其他更具体的概念留到以后的文章中。

具体来说,本文将讨论如何:

  • 充分定义我们的问题(目标、期望的产出……)。
  • 收集数据。
  • 选择衡量成功的标准。
  • 设置评估协议和可用的不同协议。
  • 准备数据(处理缺失值、类别值……)。
  • 正确分配数据。
  • 区分过度适配和适配不足,定义它们并解释避免它们的最佳方法。
  • 模型如何学习的概述。
  • 什么是正则化,什么时候使用正则化比较合适。
  • 开发一个基准模型。
  • 选择一个合适的型号,并调整它以获得最佳性能。

Picture from Unsplash

解决机器学习问题的通用工作流

1。恰当地定义问题

首先,也是要做的最重要的事情之一,是找出什么是输入和预期输出。必须回答以下问题:

  • 主要目标是什么?我们试图预测什么?
  • 目标特征是什么?
  • 输入数据是什么?有吗?
  • 我们面临着什么样的问题?二元分类?聚类?
  • 预期的改善是什么?
  • 目标特征的当前状态是什么?
  • 如何测量目标特征?

不是每个问题都可以解决,直到我们有了一个工作模型我们才可以做出某些假设:

  • 给定输入,可以预测我们的输出。
  • 我们现有的数据足以了解投入和产出之间的关系

请记住,机器学习只能用于记忆训练数据中存在的模式,因此我们只能识别我们以前见过的模式。当使用机器学习时,我们假设未来会像过去一样,但这并不总是正确的。

2.收集数据

这是机器学习模型真正发展的第一步,收集数据。这是一个关键的步骤,将级联模型有多好,我们得到的数据越多越好,我们的模型将表现得越好。

有几种收集数据的技术,比如 web 抓取,但是它们超出了本文的范围。

典型地,我们的数据将具有以下形状:

Table by Author

注意:上表对应的是著名的 boston housing 数据集,这是一个经典的数据集,经常用于开发 siemple 机器学习模型。每行代表一个不同的波士顿社区,每列表示该社区的一些特征(犯罪率、平均年龄等)。最后一列表示该社区的房价中值,它是目标值,是将其他值考虑在内进行预测的值。

3.选择衡量成功的标准:

彼得·德鲁克是哈佛大学的老师,也是《高效的管理者和自我管理》一书的作者,他有一句名言:

“如果你不能衡量它,你就不能改进它”。

如果你想控制某样东西,它应该是可以观察到的,为了取得成功,有必要定义什么是成功:也许是精确?准确性?客户保持率?

这个衡量标准应该与手头业务的更高层次目标直接一致。这也与我们面临的问题直接相关:

  • 回归问题使用某些评估指标,如均方差(MSE)。
  • 分类问题使用精度、准确度和召回率等评估指标。

在接下来的文章中,我们将深入探讨这些指标,考虑到所面临的问题,什么是最适合使用的,并学习如何设置它们。

4.设置评估协议

一旦目标明确,就应该决定如何衡量实现目标的进展。最常见的评估协议有:

4.1 维护延期验证集

这种方法是将数据的一部分分离出来作为测试集。

该过程将是用剩余部分的数据训练模型,用验证集调整其参数,最后在测试集上评估其性能。

将数据分成三部分的原因是为了避免信息泄露。这种方法的主要不便之处在于,如果可用数据很少,验证和测试集将包含很少的样本,以至于模型的调整和评估过程将无效。

Figure by Author

4.2 K 倍验证

K-Fold 包括将数据分成 K 个大小相等的分区。对于每个分区 I,用剩余的 K-1 个分区训练模型,并在分区 I 上对其进行评估

最终得分是获得的 K 分的平均值。当模型的性能明显不同于训练测试分割时,这种技术特别有用。

Figure by Author

4.3 带洗牌的迭代 K 倍验证

当可用数据很少,并且需要尽可能精确地评估模型时,这种技术特别有用(这是 Kaggle 竞赛的标准方法)。

它包括多次应用 K-Fold 验证,并且每次在将数据分成 K 个分区之前对其进行洗牌。最终分数是每次 K 倍验证结束时获得的分数的平均值。

这种方法在计算上非常昂贵,因为训练和评估模型的数量将是 1x K 倍。其中 I 是迭代次数,K 是分区数。

注:在选择评估协议时,谨记以下几点至关重要:

  • 在分类问题中,训练和测试数据都应该是具有代表性的数据,所以我们应该在分割数据之前对其进行洗牌,以确保它覆盖了数据集的整个范围。
  • 当试图根据过去预测未来时(天气预测、股票价格预测……),数据不应该被打乱,因为数据的顺序是一个至关重要的特征,这样做会造成时间上的泄露。
  • 我们应该经常检查我们的数据中是否有重复,以便删除它们。否则,冗余数据可能会同时出现在训练集和测试集中,导致我们的模型学习不准确。

5.准备数据

在开始训练模型之前,我们应该以一种可以输入机器学习模型的方式转换我们的数据。最常见的技术有:

5.1 处理缺失数据

在现实世界的问题中,丢失数据样本的某些值是很常见的。这可能是由于数据收集的错误、调查中的空白、测量不适用等等

缺失值通常用“NaN”或“Null”指示器表示。问题是大多数算法不能处理那些丢失的值,所以我们需要在将数据输入模型之前处理它们。一旦确定了它们,有几种方法可以处理它们:

  1. 排除具有缺失值的样本或特征。(我们冒着删除相关信息或过多样本的风险)
  2. 输入缺失值,使用一些预建的估计器,如 scikit learn 的 import 类。我们将拟合我们的数据,然后转换它来估计它们。一种常见的方法是将缺失值设置为其余样本的平均值。

5.2 处理分类数据

当处理分类数据时,我们使用序数和名词特征。有序特征是可以排序的分类特征(布料尺寸:L < M < S )。而名义特征并不暗示任何顺序(布料的颜色:黄色、绿色、红色)。

处理序数和名词性特征的方法有:

  • 映射顺序特征:为了确保算法正确解释顺序特征,我们需要将分类字符串值转换成整数。我们经常会手动进行这种映射。例如:L:2,M:1,S:0。
  • 编码名义类别标签:最常见的方法是执行一键编码,包括为名义特征列中的每个唯一值创建一个新的虚拟特征。示例:在颜色列中,如果我们有三个类:黄色、红色、绿色,并执行一次性编码,我们将得到三个新列,每个唯一的类一个。那么,如果我们有一件黄色衬衫,它将被采样为:黄色= 1,绿色= 0,红色= 0。这样做是为了确保算法的良好性能,因为它们在处理稀疏矩阵(低密度矩阵,具有许多 0 值)时更有效。

Figure by Author

5.3 特征缩放

这是预处理阶段的关键步骤,因为大多数机器学习算法在处理相同比例的特征时表现得更好。最常见的技术有:

  • 归一化:是指将要素重新缩放到范围[0,1],这是最小-最大缩放的一种特殊情况。为了标准化我们的数据,我们只需对每个要素列应用最小-最大缩放方法。

Figure by Author

  • 标准化:它包括使特征列以平均值 0 为中心,标准偏差为 1,以便特征列具有与标准正态分布相同的参数(零平均值和单位方差)。这使得学习算法更容易学习参数的权重。此外,它保留了关于离群值的有用信息,并使算法对它们不太敏感。

Figure by Author

5.4 选择有意义的特征

正如我们将在后面看到的,导致机器学习模型过度拟合的主要原因之一是因为我们的数据中存在冗余,这使得模型对于给定的训练数据来说过于复杂,并且无法对看不见的数据进行很好的概括。

避免过度拟合的一个最常见的解决方案是降低数据的维数。这通常是通过主成分分析(PCA)减少数据集的特征数量来实现的,PCA 是一种无监督的机器学习算法。

PCA 根据特征之间的相关性识别数据中的模式。这种相关性意味着我们的数据中存在冗余,换句话说,数据的某些部分可以用其他部分来解释。

这种相关数据对于模型恰当地学习其权重并不重要,因此可以将其移除。可以通过直接删除某些列(特征)或者通过合并一些列并获得保存大部分信息的新列来删除它。我们将在以后的文章中更深入地探讨这种技术。

Figure by Author

5.5 将数据分成子集

一般来说,我们将把数据分成三部分:训练集、测试集和验证集。我们用训练数据训练我们的模型,用验证数据评估它,最后,一旦它可以使用,就用测试数据最后一次测试它。

现在,提出以下问题是合理的:为什么不只有两套,培训和测试?那样的话,过程就简单多了,只需要在训练数据上训练模型,在测试数据上测试就可以了。

答案是,开发一个模型包括调整它的配置,换句话说,为它们的超参数(不同于模型的参数——网络的权重)选择某些值。这种调整是通过从验证集得到的反馈来完成的,本质上是一种学习形式。

最终目标是该模型可以很好地对未见过的数据进行归纳,换句话说,根据在训练和验证时调整的内部参数,从新数据中预测准确的结果。

a)学习过程

通过研究一种最简单的算法:线性回归,我们可以更深入地了解学习过程是如何完成的。

在线性回归中,我们被给定一些预测变量(解释变量)和一个连续的响应变量(结果),我们试图找到这些变量之间的关系,使我们能够预测一个连续的结果。

线性回归的一个例子:给定 X 和 Y,我们拟合一条直线,使用一些方法估计样本点和拟合直线之间的系数(如普通最小二乘法和梯度下降),使距离最小化。然后,我们将使用学习到的截距和斜率(形成拟合线)来预测新数据的结果。

Figure by Author

直线的公式为 y = B0 + B1x +u 。其中 x 为输入, B1 为斜率, B0 为 y 截距, u 为残差, y 为位置 x 处的线值。

可用于训练的值是 B0B1 ,它们是影响线位置的值,因为仅有的其他变量是 x(输入)和 y,即输出(不考虑残差)。这些值( B0B1 )是预测函数的“权重”。

这些权重和其他称为偏差的参数将作为矩阵排列在一起(权重为 W ,偏差为 b )。

训练过程包括为每个训练矩阵初始化一些随机值,并尝试使用初始随机值预测输入数据的输出。开始时,误差会很大,但是将模型的预测与正确的输出进行比较,模型能够调整权重和偏差值,直到有一个好的预测模型。

Figure by Author

重复该过程,一次一个迭代(或步骤)。在每次迭代中,初始的随机线向理想的和更精确的线移动。

b)过度装配和装配不足

当考虑模型的训练时,最重要的问题之一是优化和推广之间的紧张关系。

  • 优化是调整模型以在训练数据上获得最佳性能的过程(学习过程)。
  • 概化是模型在看不见的数据上表现得有多好。目标是获得最佳的泛化能力。

在训练开始时,这两个问题是相关的,训练数据的损失越低,测试数据的损失就越低。这发生在模型仍然不足的时候:仍然有学习要做,还没有对模型的所有相关参数建模。

但是,在对训练数据进行多次迭代之后,泛化能力停止提高,验证指标首先冻结,然后开始下降。该模型开始过度拟合:它已经很好地学习了训练数据,学习了过于特定于训练数据而与新数据无关的模式。

Figure by Author

有两种方法可以避免这种过拟合,获得更多的数据和正则化。

  • 获得更多的数据通常是最好的解决方案,根据更多数据训练的模型自然会概括得更好。
  • 当后者不可行时,就进行正则化,正则化是对模型可以存储的信息量进行调制的过程,或者是对允许保留的信息进行约束的过程。如果模型只能记住少量的模式,优化将使它专注于最相关的模式,从而提高泛化能力。

正则化主要通过以下技术完成:

  1. 减少模型的规模:减少模型中可学习参数的数量,从而减少其学习能力。目标是在学习能力过多和不足之间找到一个平衡点。不幸的是,没有任何神奇的公式来确定这种平衡,它必须通过设置不同数量的参数和观察其性能来测试和评估。
  2. 添加权重正则化:一般来说,模型越简单越好。只要它能很好地学习,一个更简单的模型就不太可能过度拟合。实现这一点的一种常见方法是通过强制其权重仅取小值来限制网络的复杂性,从而使权重值的分布规律化。这是通过向网络的损失函数添加与具有大权重相关联的成本来实现的。成本来自两个方面:
  • L1 正则化:代价与权重系数的绝对值(权重的 L1 范数)成比例。
  • l2 正则化:成本与权重系数(权重的 L2 范数)的值的平方成比例

Figure by Author

要决定哪一个应用于我们的模型,建议牢记以下信息并考虑我们问题的性质:

6.开发基准模型

这一步的目标是开发一个 benchamark 模型,作为我们的基线,在此基础上,我们将衡量一个更好、更协调的算法的性能。

基准测试要求实验具有可比性、可测量性和可重复性。强调最后一句话的可再现部分是很重要的。现在的数据科学库执行数据的随机分割,这种随机性必须在所有运行中保持一致。大多数随机生成器支持为此目的设置种子。在 Python 中,我们将使用随机包中的 random.seed 方法。

如在“https://blog . dominodatalab . com/benchmarking-predictive-models/”上找到的

“将模型改进与简化的基线模型(如分类数据的 kNN 或朴素贝叶斯,或时间序列数据中某个值的 EWMA)进行比较通常很有价值。这些基线提供了对数据集可能的预测能力的理解。

这些模型通常需要少得多的时间和计算能力来训练和预测,这使它们成为一个有用的交叉检查答案的可行性。kNN 和朴素贝叶斯模型都不可能捕捉复杂的交互。然而,它们将提供对基准模型预测能力的最小界限的合理估计。

此外,本练习还提供了测试基准管道的机会。重要的是,基准管线为具有已知性能特征的模型提供稳定的结果。原始数据集上的 kNN 或朴素贝叶斯,或通过列居中或缩放进行的最低程度的操作,通常会提供弱但足够的学习器,其特征对于比较的目的是有用的。更复杂模型的特征可能不太为人所知,并被证明是具有挑战性的。"

7.开发更好的模型并调整其超参数

7.1 寻找好的模式

寻找一个好模型的最常见的方法之一是交叉验证。在交叉验证中,我们将设置:

  • 我们将拆分数据的若干折叠。
  • 评分方法(根据问题的性质而有所不同——回归、分类……)。
  • 我们想检查一些合适的算法。

我们将把数据集传递给我们的交叉验证得分函数,并获得产生最佳得分的模型。这将是我们要优化的一个,相应地调整它的超参数。

**# Test Options and Evaluation Metrics**
num_folds = 10
scoring = "neg_mean_squared_error"**# Spot Check Algorithms**
models = []
models.append(('LR', LinearRegression()))
models.append(('LASSO', Lasso()))
models.append(('EN', ElasticNet()))
models.append(('KNN', KNeighborsRegressor()))
models.append(('CART', DecisionTreeRegressor()))
models.append(('SVR', SVR()))

results = []
names = []
for name, model in models:
    kfold = KFold(n_splits=num_folds, random_state=seed)
    cv_results = cross_val_score(model, X_train, y_train, cv=kfold,    scoring=scoring)
    results.append(cv_results)
    names.append(name)
    msg = "%s: %f (%f)" % (name, cv_results.mean(),   cv_results.std())
    print(msg)

***# Compare Algorithms***
fig = pyplot.figure()
fig.suptitle('Algorithm Comparison')
ax = fig.add_subplot(111)
pyplot.boxplot(results)
ax.set_xticklabels(names)
pyplot.show()

7.2 调整模型的超参数

机器学习算法有两种类型的参数。第一种类型是通过训练阶段学习的参数,第二种类型是我们传递给机器学习模型的超参数。

一旦确定了我们将使用的模型,下一步就是调整它的超参数,以获得可能的最佳预测能力。寻找超参数最佳组合的最常见方法称为网格搜索交叉验证。

该过程如下:

  • 设置我们将评估的参数网格。为此,我们将创建一个字典,其中包含您想要测试的所有参数及其相应的一组值,以获得最佳性能
  • 设置折叠数和随机状态以及计分方法。
  • 使用选定的折叠数构建 K 折叠对象。
  • 用选择的模型构建一个网格搜索对象,并对其进行拟合。
**# Build a scaler**
scaler = StandardScaler().fit(X_train)
rescaledX = scaler.transform(X_train)**# Build parameter grid**
c_values = [0.1, 0.3, 0.5, 0.7, 0.9, 1.0, 1.3, 1.5, 1.7, 2.0]
kernel_values = ['linear', 'poly', 'rbf', 'sigmoid']
param_grid = dict(C=c_values, kernel=kernel_values)**# Build the model**
model = SVC()
kfold = KFold(n_splits=num_folds, random_state=seed)
grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)
grid_result = grid.fit(rescaledX, y_train)**# Show the results**
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))

该方法返回一组最适合当前问题的超参数。一旦它们被确定,我们的模型就可以使用了。因此,我们将对验证数据集进行适当的预测,并保存模型以备后用。

8.结论

通过这篇文章,我们已经讨论了很多重要的概念。虽然已经提供了它们的高层次概述,但是这对于获得关于如何以及何时应用所解释的方法的良好直觉是必要的。

我们将更深入地探索这些方法,因为它们将在下一篇文章中不断出现,以及它的 python 实现。

在下一篇文章中,我们将从第一种也是最常见的机器学习问题开始:回归。

如果你喜欢这篇文章,那么你可以看看我关于数据科学和机器学习的其他文章 这里

如果你想了解更多关于机器学习、数据科学和人工智能的知识 请在 Medium 上关注我,敬请关注我的下一篇帖子!

机器学习走向元

原文:https://towardsdatascience.com/machine-learning-going-meta-514dd5027817?source=collection_archive---------13-----------------------

反思 2018 年 ML 的一些最大趋势

机器学习有自己的三条法则:为了使用它,你需要三个必不可少的成分,即 1)标记的数据;2)一个模型架构你可以优化;以及 3)明确定义的目标函数。许多关于应用 ML 解决问题的讨论被简单地打断了,因为这三者中没有一个是可用的。达到这种神奇的结合越来越容易:“大数据”趋势使数据访问在行业中更加普遍,深度学习使找到适用于广泛问题的良好模型架构变得更加简单。有趣的是,大部分困难仍然存在于定义正确的目标:一个有商业意义的目标,提供足够的监督,并包含问题固有的所有目标,例如公平性、安全性或可解释性。

我今年观察到的主要趋势是,我们可能最终会打破这种“数据、模型、目标:选择三个”的局面,变成看起来更像是:数据、模型、目标:选择两个。许多人会说,真正的“一般智力”是当我们不需要这些成分中的任何成分时:没有标签,没有专门的学习架构,没有精细的目标,因此从三个减少到两个确实感觉是一些进步。

我最感兴趣的是我们打破这三条规则的方式:我们采用监督学习,并把它本身作为研究的主题。

Credit: Andre Mouton on Unsplash

本质上,我们在机器学习上正在走向元

模型架构来说:如果没有会怎么样?学着点!这是“学会学习”方法背后的基本理念,又名 AutoML 方法。令人惊讶的是,计算机已经基本上自动化了我三年前的工作:那时我正努力为谷歌网找出最好的模型架构。当今最好的架构都是由机器学习系统自己设计的,并且正在迅速找到 自己的 方式进入工业应用。这也适用于模型训练的所有其他方面,例如数据增强设备放置优化器。这条研究路线的大部分仍然依赖于人们作为构建模块提出的大型建筑动物园,这没关系——问问你的邻居 Redditor,如果没有相当数量的模因循环,这就不是“元”了。

取标有的数据。如果你没有呢?大量的文献正在围绕少量/一次/零次学习而发展,其中目标标签只被观察几次,恰好一次,或者根本不被观察。正如你所猜测的,解决这些问题的一些最有前途的方法是关于“去元化”:元学习将重新学习一些东西的问题定义为要解决的实际学习问题,从而优化了“少数镜头”任务,而不是传统的大数据集问题设置。并且可以自然的扩展到无监督 设置

对我来说,元学习越来越像是对我们集体痴迷于强化学习的完美治疗,强化学习是通向终身学习的道路。它提供了一个不同但同样自然的问题框架,从找出如何随着时间的推移从单个例子中更好地学习的角度。我希望有一天,我们不再把这称为元学习,而只是简单地称为“学习”:使用非常稀疏的信号捕捉新奇体验的本质,同时利用一个人的整个存在作为如何更好地学习的背景,这才是真正的概括。

最后,当您有数据和模型,但没有定义明确的目标函数时会发生什么?这通常是一种“当你看到它时你就知道”的情况:你想要一个好看的图像,或者你想要听起来不错的音频,但是写下这些概念的适当损失几乎是不可能的。这就是生成性对抗网络完全改变了现状的地方,它拒绝回答什么是好的目标函数的问题,而是将问题交给各种有学问的批评家,试图区分好的解决方案和坏的解决方案。还有什么比训练一个机器学习系统来判断你的机器学习系统做得有多好更‘元’的呢?可以说,gan 并不特别新,但它们在过去几年里真的蓬勃发展,现在越来越多地找到进入(sur-) 现实世界的方式

当然,这回避了一个问题,为什么还没有人发表题为“生成对立模型不可知的元神经架构搜索”的论文。来吧,我谅你也不敢。

因为我们在元列车上:这也是对 ML 社区本身反思的一年。几十年来,我们一直默默无闻,研究的问题要么太小而不重要,要么太深奥而不为世人所关注,我们的社区终于发现了几乎所有其他工程学科长期以来都必须努力解决的问题:我们的工作确实很重要。我们做什么,我们如何做,为谁的利益而做,真的很重要,并能实质性地影响我们生活的世界的未来。这对我们的责任观念和道德观念意味着什么?我们能否帮助解决当今地球面临的一些重大问题——并且确保 我们不会成为问题的一部分?我们能否努力成为一个更加包容多样化的社区,更好地代表我们服务的用户?

我期待 2019 年,期待更多的学习,更多的自省,更多的对世界的积极影响。我个人很高兴看到明年会有更多的 ML 进入物理世界。我的一些同事似乎领先了一步。我等不及了。我们很可能需要所有我们能够聚集的“元”来真正取得进展:物理世界将 ML 三重问题带到了最前沿:访问数据,如何设计有效的实时模型,以及如何处理模糊且往往相互冲突的目标。

机器学习:这个漂亮的黑匣子有多黑

原文:https://towardsdatascience.com/machine-learning-how-black-is-this-black-box-f11e4031fdf?source=collection_archive---------0-----------------------

Kazimir Malevich Black Square 1915

现在的软件比几十年前好得多。机器学习比以前更好了。机器学习软件库现在已经成熟,并且经过了很好的测试。围绕它的技术也要好得多。作为一名工程师,我已经习惯了使用更高级和抽象的库、框架来掩盖底层操作,并且经常使用完全的黑盒。我说的黑盒指的是工具,我很少关心里面发生了什么。

人工神经网络(ann)有一个很大的优势,因为在对系统建模之前不需要物理先验信息。当一个新的计算在网络上运行时,它以一个不同的新权重矩阵结束。这是从小的随机值开始,然后随着程序的运行进行调整的结果。这就是为什么安的是黑盒。

除了随机起点这一至少从数学上难以描述网络行为的原因之外;网络处于变化之中,而数学实际上是无状态的。那是我们可以用数学来描述的;一个开始,一个结束,一个过程中的一个点,但学习过程是许多操作的结果序列,不是无状态的。

具有很少层的简单网络中的几个步骤可以由触发的函数和由此产生的权重调整来表示。添加更多的层,需要不同类型和比例的表示。在少量液体中表现能量波是可以的,但这不是描述海洋的方式。

除了人工神经网络的密度,这些系统允许随机变量和任意黑盒确定性函数的结合。它们支持推理算法和嵌套优化的智能初始化。

[## 张量流-神经网络游乐场

这是一种构建从数据中学习的计算机程序的技术。它非常松散地基于我们如何思考…

playground.tensorflow.org](http://playground.tensorflow.org/#activation=sigmoid&batchSize=4&dataset=gauss&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=4,1&seed=0.12353&showTestData=false&discretize=false&percTrainData=50&x=true&y=true&xTimesY=false&xSquared=true&ySquared=true&cosX=false&sinX=false&cosY=false&sinY=false&collectStats=false&problem=classification&initZero=false&hideText=false)

人工神经网络通过从示例中学习来生成规则。为了学习,他们使用调整重量和测量的过程来匹配已知的结果。他们在运行中创建自己的基于示例的规则。它们的操作方式没有详细说明它们如何使用诸如反向传播之类的东西来评估和调整权重。

A backpropogation function adjusting a weight within a network

The backpropagation formula

神经网络是能得出复杂答案的系统。为此,他们会生成自己的问题和规则。一些人认为,这些规则的出台缺乏透明度是一个问题。一些人认为,缺乏透明度,即黑箱问题,可能会妨碍人工神经网络的实用性。人们认为,如果我们依靠人工神经网络来寻找答案,它们需要能够解释自己,并告诉我们它们是如何得出答案的。

我仍然很乐意在手机上使用计算器来计算一个数的平方根,或者使用我当时使用的任何编程语言的内置数学函数。所有这些都使用不同的近似方法来解决平方根问题。然而事实是,在大多数情况下,如果我用来求平方根的方法得到了一个接近的估计值,我会很高兴。我们应该放心地相信黑盒吗?

把光线照进盒子里。

了解神经网络工作情况的一种方法是使用测试输入来探测网络,并在已知预期结果的情况下测量输入变量对输出的影响。有点像审问技巧,问一个你知道答案的问题来测试这个问题的真实性。对于使用反向传播的人工神经网络,这可以通过在反向传播步骤中跟踪误差项,然后测量每个输入影响输出的量来实现。

另一种学习信任网络衍生知识的方法是提取网络使用的规则。权重来自沿着输入和输出之间的非线性路径的变换。构成知识的所有值只是一系列数值。提取规则的另一个过程是通过启动学习过程来提取规则,从而将数值转化为符号形式。

查看规则不需要直接检查权重矩阵,而是象征性地呈现规则。通过比较输入/输出映射和形成决策树来提取规则。基于分类器搜索的决策树,寻找一系列智能组织给定数据集的规则。

神经网络接受输入并输出知识。网络使用一系列输入,然后创建输出,它们一起提供新的数据集。有可能形成该过程的符号和视觉表示。通过将输入和新输出传递给决策树分类器,我们可以揭示网络是如何获得其知识的。除了揭示网络使用的规则,它还给我们一种可视化这些规则的方式。

我们需要了解电才能开灯吗

机器学习的经典观点基于简约的理念。几乎在任何公式中,学习都可以归结为从数据中提取低复杂度的模式。

为什么要寻找网络建立规则的方式呢?如果一开始就对网络进行了适当的训练,这是一种多余的努力吗?然而,提取符号知识的能力有一些潜在的优势。从网络中获得的知识可以导致对数据中的模式和相关性的新见解。从符号知识中,更容易看出数据的哪些特征对结果是重要的。

给一个机器学习模型编程,把它正在做的事情表示成另一个模型,并不太难。这样做的问题是,它可能存在于平凡或琐碎的层面。这可能很耗时,而且不太适合理解大型复杂结构。还有一个问题是,导出的模型不能提供更清晰的理解。如果它减少了目标网络创建的规则,它可能过于简洁或给出不完整的描述,但可疑的危险是它会放大规则并进一步模糊所寻求的理解。

一种不同的方法是使用黑盒函数,并查看输入对该函数的重要性。应用它来量化算法超参数优化的效应

有一个软件库可以解决黑盒优化问题。这些方法使用基于序列模型的优化(贝叶斯优化),这是一种解决此类问题的迭代方法。 AutoWeka 是一个设计用于在 Weka 中提供自动模型选择和超参数优化的例子,WEKA 是一个易于使用的通常可用的机器学习算法的集合,用于使用机器学习的数据挖掘任务。

让盒子不断告诉我们我们所知道的

处理黑盒的另一种方法是通过增加更多的层来使网络更加密集。这是进入深层网络驻留的地方。深度网络的各种架构的土地,包括:卷积神经网络 (CNN 的)、递归神经网络 (RNN)、递归神经网络,以及解耦神经接口 (DNI)和可微分神经计算机 (DNCs)的更新模型。

深度学习背后的一个关键思想是从给定的数据集中提取高级特征。因此,深度学习旨在克服通常繁琐的特征工程任务的挑战,并帮助参数化具有许多层的传统神经网络。塞巴斯蒂安·拉什卡

深度网络与其传统的人工神经网络亲戚非常不同。形象化深层网络有多么不同的一个方法是,就其本质而言,它们过度适应它们从中学习的数据。这与更传统的人工神经网络相反,后者的目标是更接近拟合曲线。

当没有太多参数时,获得良好的拟合是可行的。深度学习可以接受多个输入,并通过多个层进行计算。即使使用随机权重,深层网络的隐藏层也非常强大,能够表示高度非线性的函数。

大多数深度学习算法采用某种形式的优化,通过调整 x 的值来最小化或最大化函数 f(x) 。要调整的函数称为目标函数、损失函数、误差函数或成本函数。深度学习利用这些功能来衡量和调整结果(预测、分类等)与输入的接近程度。目标是最小化损失函数。

函数的导数

给出了点 xf(x) 的斜率,该斜率指定了输入微小变化的比例,以匹配输出的相应变化。

当大量重复和层可用时,减少损失函数的简单解决方案工作良好。一个反复出现的问题是,需要大的训练集来提供可靠的概括,因此需要大量的计算资源。

随机梯度下降

梯度下降法不是查看网络中的所有权重并重新计算它们,而是一种缩小相关权重空间的寻路方法,因此减少了更新和所需计算的次数。

随机梯度下降(SGD)方法用于许多机器学习模型,并且是用于 ANN 的主要算法,它还提供了一种在深度网络中产生精确结果的简单方法。随机梯度下降能够使用一小组样本给出损失的近似估计,从而减少所需的计算量。

The Stochastic Gradient Descent Algorithm

其中 X 是 Xi 的输入值集合,W 是每个 Xi 值的重要性因子(权重)集合。正权重意味着该风险因素增加了结果的概率,而负权重意味着该风险因素降低了结果的概率。目标输出值η是学习率(学习率的作用是控制每次迭代时权重被修改到的水平。在这种情况下,f(z)是将一个大的输入域映射到一小组输出值的函数所生成的输出。

函数 f(z)是逻辑函数:

在损失函数中

期望估计使 Q(w)最小的参数 w

梯度下降是

其中η是学习率。

任意单点的随机梯度下降近似为

因此,以学习速率η的初始向量 w 随着训练数据的随机洗牌而被迭代 i次。通过使连接随机,由于不需要训练隐藏层的权重,所以训练时间更快是可能的。

虽然对收敛如何发生或合理的概括如何得出的理解水平是模糊的,但深度学习最适合应用于我们知道期待什么答案但很难找到它们的任务。此类任务的常见示例有:语音识别、图像分类、异常检测和字符识别都不是在处理未知数。

将黑盒视为给出正确答案的机器

[## 快,画!

神经网络可以学习识别涂鸦吗?看看它与你的画配合得有多好,并帮助教它,只要…

quickdraw.withgoogle.com](https://quickdraw.withgoogle.com/)

如果一个网络识别出一个字符是一个‘a’或者一个画成一条鱼,我们可以立即评估它的潜在正确性。如果网络将随机的灰色纹理识别为鹦鹉,我们可以很快看出它被愚弄了,而且很愚蠢。我们不需要知道它是如何被愚弄的,因为我们使用经验主义来测试网络的准确性。知道了这一点,我们就可以想办法增加体重调整等功能。

知道隐藏层如何工作的保证可以被另一种知识所取代。深度学习模型的性能及其范围替代;了解内脏的需要;语用评价。能够查看使用深度强化学习所获得的结果和性能,提供了一种实用的方式来查看正在发生的事情。

“我们需要想办法打开深度学习黑匣子。一个强有力的方法是可视化表达。”克里斯托弗·奥拉

还有另一种方式来查看黑盒。当使用神经网络来承担诸如翻译和自然语言处理的语言任务时,使用单词甚至短语的向量表示,这些被称为单词嵌入。

向量空间模型(VSM)表示(嵌入)连续向量空间中的单词,其中语义相似的单词被映射到附近的点(“彼此邻近嵌入”)。这些源于这样一种理论,即出现在相同语境中的单词共享语义。这是像 Word2Vec 这样的程序使用两层神经网络在多维向量空间内重建单词的语言上下文的方式;给出了一个字的矢量表示法

网络的隐层学习对输入数据进行变换,并以多维方式表示。它给出了空间中一个词与另一个词的接近程度的值。很难将这个空间可视化,但是使用降维来可视化高维表示的技术也将提供一种检查网络所使用的模型的方法。

Word2Vec 以数学方式检测单词与输入语料库中与之接近的其他单词的相似性。它给出单词特征的数字表示,例如上下文。它根据输入的其他单词训练单词。有两种方法可以做到这一点。一种是使用上下文来预测目标单词(一种称为连续单词包的方法)。另一种使用一个单词来预测目标上下文(称为跳格)。

该程序是一个神经网络的例子,它传递定义为向量的单词之间的关系,这些可以在空间中映射。这意味着深度学习过程有一个代表性的输出,即使很难可视化。谷歌开源的嵌入式投影仪在一定程度上克服了这个困难。

[## 嵌入式投影仪-高维数据的可视化

最合适的困惑值取决于数据的密度。不严格地说,更大的…

projector.tensorflow.org](http://projector.tensorflow.org/)

Christopher Colah 写道“不可思议的想法,不可理解的数据”以及如何“作为一名机器学习研究人员(他的工作)基本上是与不可理解的数据斗争——人类思维几乎不可能理解——并试图建立工具来思考和使用它”。然后,可视化成为理解深度学习网络实际上在做什么的理想工具。

反省

另一个克服对未知事物的黑箱恐惧的解决方案是开发一个具有自我知识的模型,一个能够回忆、叙述、推理、反思和自我分析的模型;有记忆的模型。一个有自我意识并从历史中学习的人。一种模型,能够表示变量和数据结构,并在长时间范围内存储数据。几种神经网络模型(注意力和增强递归神经网络)提供了一种将网络连接在一起的方式,允许一个网络探索另一个网络。

黑盒问题的一个方面是,迄今为止,大多数网络忽略了它们在每个学习周期中获得的知识。通过允许持有相同过程的多个副本,一种形式的递归神经网络(RNN)架构使用长短期 - 短期记忆 (LSTM)允许学习周期持续足够长的时间以改进下一个周期。网络之间的接口将允许网络之间相互通信。

向网络中添加读写存储器使得能够存储知识的学习机器成为可能,可微分神经计算机(DNC)就是这样。虽然通过为模型提供独立的可读写内存在架构上构建更加复杂,但 DNC将能够揭示更多关于它们黑暗部分的信息。所以对付黑盒的方法就是让它们黑一点,给它们学习黑魔法的方法。

就这么干吧

科学有着从实践中学习的悠久传统,即利用实验来形成理论。这也是一个提出命题或提出论文进行测试的领域。本文引用的很多材料都是机器学习的前沿。正如《机器如何学习》一书的作者瑞恩·洛威在最近的一篇评论文章中评论的那样,“我们认为,在等待‘完美’的时候,不发表‘好’的东西并不是科学前进的有效途径。”。

访问数据是另一种打开窥视黑匣子正在做什么的方法,能够使用相同的数据复制实验。一个重要的举措是开源,不仅是算法的设计,还有他们用来训练和喂养它们的数据集。谷歌、微软、脸书、阿帕奇、科学界、政府机构和许多其他公司不仅开源了软件,还开源了训练数据和 T2 实验室。

深度学习和物理学之间的相似性被用来描述为什么深度神经网络如此有效。共享可追溯到物理定律的简化属性,并使用两者都通用的某些层次形式的数据,这表明主题的结构与学习过程被要求执行的任务非常匹配。

考虑亚分子物理规范理论和大型强子对撞机的两端。两者都是用来寻求发现相似的启示的。科学家利用 LHC 发现了令人惊讶的结果,弦理论学家预测了令人惊讶的粒子。两者有时会汇聚到一起寻求,有时会展示联合起来的洞察力,一方告知另一方。有时令人震惊的理论,如理论认为引力是一种熵力,而不是爱因斯坦建议的基本相互作用,在理论建议的测试完成后,这些理论会被证明是可信的。

理论理解和实际应用是不总是相同的道路,但它们可能会导致相同的地方。机器学习的架构、算法和模型遵循类似的路径。一方面,理论知识遵循从实验中获得的知识,另一方面,理论表明实验需要去哪里。

参考资料:

人工神经网络——如何打开黑匣子?https://www . tu-braunschweig . de/Medien-DB/IGP/heinert _ 2008 . pdf

概率程序的贝叶斯优化https://papers . nips . cc/paper/6421-概率程序的贝叶斯优化. pdf

一种评估超参数重要性的有效方法【http://jmlr.org/proceedings/papers/v32/hutter14.pdfT4
汽车https://github.com/automl/autoweka

auto-WEKA 2.0:WEKA 中的自动模型选择和超参数优化http://www . cs . UBC . ca/labs/beta/Projects/auto WEKA/papers/16-599 . pdf

多层神经网络深度学习教程http://ufldl . Stanford . edu/Tutorial/supervised/MultiLayerNeuralNetworks/

卷积神经网络https://www . tensor flow . org/versions/r 0.12/tutorials/deep _ CNN/index . html #卷积神经网络

递归神经网络https://www . tensor flow . org/versions/r 0.12/tutorials/recurrent/index . html

递归(非递归!)TensorFlow 中的神经网络https://pseudo essential . WordPress . com/2016/06/20/recursive-not-recursive-Neural-Nets-in-tensor flow/

使用合成梯度解耦神经接口https://deep mind . com/blog/decoupled-Neural-networks-Using-Synthetic-Gradients/

可微分神经计算机【https://deepmind.com/blog/differentiable-neural-computers/

Python 机器学习书籍 ISBN-13:978–1783555130https://github.com/rasbt/python-machine-learning-book

递归神经网络的不合理有效性【http://karpathy.github.io/2015/05/21/rnn-effectiveness/

介绍人工智能实验【https://aiexperiments.withgoogle.com/

重新思考计算机视觉的初始架构http://static . Google user content . com/media/research . Google . com/en//pubs/archive/44903 . pdf

用深度强化学习玩雅达利https://arxiv.org/pdf/1312.5602.pdf

理解深度学习需要重新思考一般化https://openreview.net/pdf?id=Sy8gdB9xx

声波化的希格斯数据显示了一个令人惊讶的结果http://home . CERN/about/updates/2016/04/sonified-Higgs-data-show-surprise-result

单词的矢量表示法https://www.tensorflow.org/tutorials/word2vec/

如何有效地使用 t-http://distill.pub/2016/misread-tsne/SNE

可视化表示:深度学习和人类https://colah . github . io/posts/2015-01-Visualizing-presentations/

深度学习开放数据https://deeplearning4j.org/opendata

开源 DeepMind 实验室https://deepmind.com/blog/open-sourcing-deepmind-lab/

为什么深度廉价学习效果这么好?https://arxiv.org/pdf/1608.08225v2.pdf

弦理论可以检验吗?http://www . PBS . org/wgbh/nova/blogs/physics/2012/09/can-string-theory-be-tested/

超对称预测标准模型中每个粒子的伙伴粒子,以帮助解释为什么粒子有质量【https://home.cern/about/physics/supersymmetry

紧急引力和黑暗宇宙【https://arxiv.org/pdf/1611.02269v1.pdf

利用弱引力透镜测量首次测试弗林德的紧急引力理论https://arxiv.org/pdf/1612.03034v2.pdf

机器学习 I:一般观点

原文:https://towardsdatascience.com/machine-learning-i-a-general-perspective-dee207dba335?source=collection_archive---------0-----------------------

一年多来,我一直在研究机器学习,我决定把我的知识放到互联网上,以帮助非计算机科学家了解这个热门领域的基础知识。我计划写一系列的帖子,这些将是关于算法背后的故事,而不是数学计算。通过这种方式,我的目标是给人以直觉。

让我们从它的定义和它与其他科学领域的关系开始。机器学习的目标是以一般方式识别数据集中的模式。在您识别出模式之后,您可以使用这些信息来建模数据、解释数据或者预测以前没有见过的新数据的结果。机器学习是人工智能的一个子领域,机器学习算法用于其他相关领域,如自然语言处理和计算机视觉。

一般来说,有三种类型的学习,它们是监督学习、非监督学习和强化学习。他们的名字实际上告诉了他们背后的主要思想。

在监督学习中,系统在数据输出的监督下进行学习,因此如果数据集包含输出信息,则首选监督算法。让我给你举个例子。让我们假设你有一家医疗统计公司,你有一个数据集,其中包含患者的特征,如血压、血糖、每分钟心率等。你还可以了解他们一生中是否经历过心脏病。通过训练机器学习算法,你的系统可以找到特征和患心脏病概率之间的模式。因此,您的算法可以预测新患者是否有患心脏病的风险,这样医生就可以采取预防措施,挽救一个人的生命。

A Decision Tree from one of my projects. x’s are features which are medical tests in this case and the 0,1 values in boxes represents existance of heart disease. As you can see, algorithm produced an interpretable tree.

如果您的数据不包含输出,并且您希望发现数据集中的聚类,则您更喜欢使用无监督算法。无监督学习的一个很好的例子是手写数字识别。在这个应用程序中,您知道应该有 10 个簇{0,1,2,3,4,5,6,7,8,9},但是手写数字的问题是手写数字有无数种方法,每个人写数字的方式都不同。计算机如何理解手写的东西?在那里,你应该使用无监督的算法,如 K-means 或 EM 算法。你用这些算法所做的是,你从初始随机聚类均值开始,迭代地这些均值点收敛到真实的聚类均值。完成训练后,如果你将聚类的平均值可视化,你会发现它们看起来真的像数字。然后你用相应的数字标记这些簇,当计算机遇到一个新的手写数字时,算法用最接近它的平均值标记这个数字。

Visualized means for 8 and 6, from one of my projects

最后,我们来谈谈强化学习。让我们假设你想创造一个下棋的智能代理。在国际象棋中,你不能一个接一个地处理动作。你的代理应该考虑一系列的动作,然后决定采取一个行动,使效用最大化。因此,你的代理应该对自己下几盘棋,然后决定最好的行动。我们称这种类型的学习为强化学习,它通常用在游戏中。

这是非计算机科学家对机器学习的快速介绍,我想继续发表关于模式识别、人工神经网络、概率模型等的文章。当我有时间的时候。

认知科学中的机器学习及其在网络安全中的应用

原文:https://towardsdatascience.com/machine-learning-in-cognitive-science-and-application-in-cyber-security-fb0a81e0f045?source=collection_archive---------16-----------------------

世界正以更快的速度增长。政府、行业和经济体对网络基础设施的依赖越来越大,这使得它们更加脆弱,也增加了网络攻击的机会。

Machine Learning in Cognitive Science and application in Cyber Security

在最具破坏性的形式中,网络攻击的目标是企业、军队、政府或其他国家和公民的基础设施资源。

认知安全可能特别有助于防止操纵人类感知的网络攻击。这种攻击有时被称为认知黑客,旨在以服务于攻击者目的的方式影响人们的行为。认知黑客是一种网络攻击,旨在通过利用人们的心理脆弱性来操纵人们的感知。攻击的目的改变了行为,通常是由于接触了错误的信息。因此,认知黑客是社会工程的一种形式,尽管它可能针对广泛的受众,而不是特定的个人。这一领域的认知安全工作包括使个人不那么容易受到操纵的非技术方法,以及旨在检测误导性数据和虚假信息并防止其传播的技术解决方案。

[## 网络安全非营利组织帮助中小企业打击网络犯罪|数据驱动的投资者

一个名为全球网络联盟(GCA)的非营利组织发誓要改善…

www.datadriveninvestor.com](https://www.datadriveninvestor.com/2019/02/22/cybersecurity-non-profit-to-help-smes-fight-against-cybercrime/)

像其他认知计算应用一样,自学式安全系统使用数据挖掘、模式识别和自然语言处理来模拟人脑,尽管是在高性能的计算机模型中。这种自动安全系统被设计成不需要人力资源就能解决问题。

增强的 SOC 运行

成熟的网络安全计划的一个支柱是检测攻击何时发生的能力。如今,已经有工具可以帮助一级和二级支持部门检测攻击和事件。然而,随着 IT 系统和攻击者越来越复杂,维护系统安全所需的人力成本可能会增加到难以承受的水平。这里进入了认知计算,自动摄取、加权、辨别和评估海量数据的能力有望成为现代威胁检测的核心。虽然人类的注意力可能会失败,更简单的算法可能会误诊威胁,但认知计算机有望强大到足以立刻看到整个系统,并且足够聪明,能够看穿微妙的异常和攻击模式。此外,它不仅可以自动识别威胁,还可以主动扫描系统配置中的漏洞,并提出纠正措施。所有这些都是决定网络攻击成败的速度。例如,通过使用基于认知计算的平台,安全运营中心(SOC)提供商已经能够将威胁调查和根本原因确定的平均时间从 3 小时减少到 3 分钟 4 。这可能有助于增加组织 SOC 的覆盖范围,也有助于弥合许多 SOC 目前面临的技能和人才差距,因为需要更少的安全工程师来进行分类和第一反应。

自动化威胁情报

到目前为止,网络安全在很大程度上依赖于反应策略,在威胁出现时做出反应。虽然认知技术可以实现这一点,但它们也有可能通过将其大规模并行信息分析技能转向当今存在的巨大网络安全信息库来主动保护其所有者的系统。认知技术的供应商承诺能够从数百万不同的信息源获取数据,以便识别对单个公司有意义的可操作的威胁情报,使他们能够主动做好准备。这种情报包括威胁行动者的意图、目标和使用方法的暗示和早期迹象。当您的响应速度和准确性决定了攻击的影响时,认知计算挖掘数百万信息源以寻找早期指标的承诺可能是无价的。

硬币的另一面——应用网络安全保护认知计算

作为认知计算的促成因素,安全性扮演着同样重要但往往被忽视的角色。为了充分利用认知计算,建立和维护预防和检测网络安全的能力以确保底层系统和数据的机密性、完整性和可用性至关重要。医疗诊断是认知计算能力的另一个强有力的例子,在这种情况下,被处理的信息(私人医疗数据)的安全性至关重要。此外,解决更复杂的问题可能需要额外的计算能力,这需要由外部分布式系统(如公共云)提供。此外,基于神经网络和相关见解的预测分析的有效性和准确性将依赖于既未被破坏也未被操纵的正确数据源的可用性。在所有这些情况下,实施和增强众所周知的网络安全能力,如严格和精细的身份和访问控制、数据泄漏预防机制、强大的加密技术以及系统健康监控能力,仍然与认知计算技术本身的任何投资同等重要。

认知观

在这个阶段,认知计算仍然通过建议策略和计算结果的概率来补充人类安全专家。然而,主要行业参与者已经推出了基于认知的威胁检测和安全分析服务。瑞士金融市场基础设施的运营商 SIX 就是一个很好的例子,该公司正在一个新的“认知安全运营中心”部署 IBM Watson 以实现网络安全

随着人类和计算机正在学习以过去不可能的方式进行协作,预计随着时间的推移,更多基于认知计算的安全功能将会发展。有朝一日,这类系统甚至有能力保护自己免受威胁,从而满足认知计算的安全需求。虽然这可能还需要几年时间,但旅程已经明确开始。

金融中的机器学习

原文:https://towardsdatascience.com/machine-learning-in-finance-2074bc6bf3da?source=collection_archive---------11-----------------------

应用人工智能对金融企业来说有很多好处。事实上,很多人已经成功做到了这一点。为了让你有一个想法——这里有一个人工智能在金融领域的顶级应用的总结。

人工智能交易

谈金融不能不谈交易的机器学习。事实上,有太多的东西值得讨论,我们用了一整篇文章来讨论交易的机器学习

让我们看看最重要的几点:

人工智能不会取代交易员,而是帮助他们

交易者需要处理大量的信息——及时了解最新情况,并对事情的发展趋势有一个清晰的预感。

他们还进行严格的统计分析,以找出他们怀疑的小型市场低效的细节。

所有这些都需要时间——因为交易是一个竞争性的游戏——你越快,你得到的馅饼就越多。

人工智能帮助交易者更快、更准确地进行分析,通过发布新闻(例如情绪分析);提高对外部因素(如降雨、货物供应或选举结果)的预测,并为交易者自动微调高频交易机器

自动化且有利可图的人工智能交易基本上是一种幻想

在与其他人竞争的复杂系统中(如股票市场),人工智能仍然比人类弱得多,所以要警惕任何承诺从纯人工智能系统中获利的东西。

你犯了很多错误,让它看起来是可能的,但实际上却不是。

关于为什么会这样,以及如何使用人工智能的更多细节,请查看关于交易的机器学习的深度文章

让投资组合管理更好更便宜

投资组合经理会告诉你把钱投资到哪里——这取决于你的财务目标是什么,以及你能应对多大的市场波动(你的风险承受能力)。

他们挑选不同类型的投资,并安排一个投资组合(一份资产清单,加上你应该投入其中的资金比例)。如果市场发生变化(这种情况经常发生),就需要通过在不同资产之间转移资金来重新调整投资组合。

对一个人来说,这份工作是一个时间密集型的过程——因此银行收取很高的费用,并且只提供给他们富有的客户。但是好的投资建议对每个人都有帮助,不管你的存款有多少。

这就是“机器人顾问”迅速崛起的原因。他们不仅非常便宜,而且实际上比昂贵的人力投资组合经理做得更好。

为什么?因为许多人类顾问无法帮助自己,并通过“秘密提示”向他们的客户承诺高额回报——这在有效的市场中总是一种幻觉,因此是一个坏主意。这些“建议”最终会给你的投资组合增加很多风险——可能会让你的大部分积蓄化为乌有(我见过几次这种情况——这可不太妙)。

人工智能在投资组合管理中如此有用的秘密在于,决定你的理想资产组合(投资组合)的每一个因素都可以很容易地用数字表示:你的年龄、收入、家庭状况、何时需要钱(买房子、孩子、教育等等)。)和你的风险承受能力——这些都很容易,但都是数据库中的数字。

从这个数据库中,人工智能可以预测你的偏好(比如你什么时候可能需要多少钱)。一旦你有了这些信息,那么正确分配你的钱就是简单地解决一个数学公式——这对任何计算机来说都是小菜一碟。

想了解更多?深入了解现代投资组合理论背后的细节

使欺诈检测更加强大

随着数字商务(通过信用卡和在线支付)的发展,欺诈的动机也在不断增加。

传统的欺诈模式依赖于简单的规则系统——旨在抓捕欺诈者的清单。这些发现欺诈的简单方法的最大缺点是它们会产生很多假警报。这意味着一个合法的顾客会被拒绝购买——然后他理所当然地感到不安,会去别的地方购买。

机器学习可以产生更准确的欺诈检测清单——同时也减少了错误警报。为什么 AI 模型更好?以下是三大原因:

  • 数据驱动:机器学习模型检查所有欺诈性购买的例子,并在没有人类偏见的情况下,找到将欺诈者与正常客户区分开来的确切模式。
  • 更复杂:机器学习模型可以轻松捕捉成千上万的小模式,并在检查交易时使用它们。手写清单时不太现实的东西。这使得模型更加准确,并产生更少的错误警报。
  • 持续更新:诈骗者很有创意,不断尝试新事物来欺骗系统。一旦你发现了你的系统还没有发现的欺诈,只需要几分钟就可以更新模型,并让它从现在开始学习如何识别新的伎俩。—伟大的事情是:无论你是在与 1 个还是数千个有创造力的欺诈者作战,人工智能系统都可以轻松地学习所有人的模式,无需抄近路和一概而论。

欺诈系统也大多是副作用,就像交易中的算法:仍然需要有人对被标记为欺诈的交易进行最终检查。为什么?因为一对一人类仍然更擅长阅读人类的行动——机器学习只是让我们的工作变得更容易。

想了解更多?我们写了一篇关于如何使用人工智能更好地检测移动点击欺诈的文章。

使保险承保更加准确和个性化

与投资组合管理(上文)类似,保险承保是一项具有一组清晰的量化因素(输入)、量化目标和固定输出的工作:保险价格及其随时间推移的保费。

这是自动化统计决策的理想环境*——意思是:机器学习。

多年来,承保人已经使用更简单的统计模型来估计承保风险,并决定合适的保费应该是多少。

机器学习模型可以走得更远——让几乎整个核保工作变得廉价和可扩展。这个问题的关键在于一家保险公司的数据:他们已经计算出的数千份合同——在人类输入的情况下——是训练机器学习模型学习自己撰写合同的理想基础。

像这样的 Machin learning 模型为廉价的个性化承保打开了大门。这在 B2C 领域尤其有用(如人寿保险)。

但这只是开始——保险业务是如此彻底的统计数据,以至于人工智能还有更多应用。这里有两个例子:

好的司机支付较少的汽车保险

一些保险公司已经从你驾驶的方式(你的远程信息签名)中预测出你发生事故的风险。他们使用算法来学习哪种驾驶行为是安全驾驶员的标志,然后向他们提供更便宜的费率。

这使得保险从竞争中脱颖而出,吸引那些不想为危险司机的错误买单的安全司机。

预测你会选择哪种保险

机器学习让保险公司的生活变得更容易的另一种方式是预测你最终会选择哪种保险。这让你的顾问的工作变得容易多了,因为他可以马上向你提出对你来说最有意义的选择。

这只是冰山一角

还有很多应用,比如:预测你是否会成为忠实客户,未来是否会拖欠保险或者提出索赔

银行服务的目标销售

银行有很多关于你的非常有价值的数据——除了知道你的年龄、收入和住址——他们还知道你的确切消费行为。委婉地说,这揭示了你的许多情况。也许比你的网上浏览行为更多。

如果一家银行使用了隐藏在数据中的所有信息,它可以了解你的很多信息,包括:你现在对哪些服务感兴趣

银行雇佣顾问,他们可以给 soma 个人建议——但是他们只有时间给大客户,而且顾问需要很多经验才能正确解读迹象。

机器学习可以找到您数据中的信息,并预测哪种银行产品符合您当前的兴趣:

  • 新信用卡还是更高的信用卡额度?
  • 临时贷款?或者也许
  • 一个房贷,因为你表现的像是马上要买房的人。

不仅如此,他们还可以使用机器学习来预测你偿还信贷、贷款或抵押贷款的可能性,从而预测他们应该向你收取的利息。

这将日益导致**主动放贷。**得益于算法分析,银行不再等待你申请贷款,而是为你和他们数百万的其他客户提供量身定制的贷款。

流失预测:预测你是否会换银行

一旦你决定换银行,并让你的顾问知道,通常要说服你留下来就太晚了。如果他们能早点看到预警信号,并在你决定离开之前有机会让你更开心,那就更好了*。*

银行可以使用与上述相同的资料——根据你的数据和交易历史建立——来预测你是否有可能离开并转投另一家银行。这给顾问们提供了早期预警,让他们知道应该关注谁,并让银行挽救了许多原本会流失的客户。

那么为什么 AI 在金融领域如此有用呢?

简单来说就是因为金融是一个用数据和统计玩的游戏。金融产品大多是数学赌注:平均而言,应该获利的统计方程式。

在这个游戏的更简单和更重复的部分,我们可以用我们的大脑代替机器学习,并自动化许多决策。

除非我们直接和其他人竞争——比如在交易或欺诈中——人类让游戏变得更加复杂。那我们最好使用我们最强的武器:我们自己的大脑。

原载于www.datarevenue.com

金融中的机器学习:为什么、什么和如何

原文:https://towardsdatascience.com/machine-learning-in-finance-why-what-how-d524a2357b56?source=collection_archive---------0-----------------------

金融领域的机器学习可能会产生神奇的效果,尽管它的背后并没有什么神奇之处(嗯,可能只有一点)。尽管如此,机器学习项目的成功更多地取决于建立有效的基础设施,收集合适的数据集,以及应用正确的算法。

机器学习正在金融服务业取得重大进展。让我们看看为什么金融公司应该关心,他们可以用 AI 和机器学习实现什么解决方案,以及他们究竟如何应用这项技术。

定义

我们可以将机器学习(ML)定义为数据科学的一个子集,它使用统计模型来获得洞察力并做出预测。下图解释了人工智能、数据科学和机器学习之间的关系。为了简单起见,我们在这篇文章中主要关注机器学习。

机器学习解决方案的神奇之处在于,它们从经验中学习**,而不是被明确编程**。简单地说,您需要选择模型并向它们提供数据。然后,该模型会自动调整其参数以改善结果。

数据科学家用现有数据集训练机器学习模型,然后将训练有素的模型应用到现实生活中。

该模型作为后台进程运行,并根据其训练方式自动提供结果。数据科学家可以根据需要频繁地重新训练模型,以保持它们的最新和有效。例如,我们的客户 Mercanto 每天都在重新训练机器学习模型。

一般来说,你输入的数据越多,结果就越准确。巧合的是,巨大的数据集在金融服务行业非常普遍。有数十亿字节的交易、客户、账单、资金转账等数据。这非常适合机器学习

随着技术的发展,最好的算法是开源的,很难想象没有机器学习的金融服务的未来。

也就是说,大多数金融服务公司仍然没有准备好从这项技术中获取真正的价值,原因如下:

  1. 企业通常对机器学习及其对组织的价值抱有完全不切实际的期望。
  2. 机器学习中的 R&D 成本很高。
  3. DS/ML 工程师的短缺是另一个主要问题。下图说明了对人工智能和机器学习技能需求的爆炸式增长。
  4. 在更新数据基础设施方面,财务主管不够灵活。

我们将在这篇文章的后面讨论如何克服这些问题。首先,让我们看看为什么金融服务公司不能忽视机器学习。

为什么要考虑金融领域的机器学习?

尽管面临挑战,许多金融公司已经开始利用这项技术。下图显示,金融服务公司的高管们非常重视机器学习,他们这样做有很多理由:

  1. 流程自动化降低了运营成本。
  2. 由于更高的生产力和增强的用户体验而增加了收入。
  3. 更好的合规性和增强的安全性。

有各种各样的开源机器学习算法和工具,非常适合金融数据。此外,成熟的金融服务公司拥有雄厚的资金,可以购买最先进的计算硬件。

由于金融领域的定量性质和大量历史数据,机器学习有望增强金融生态系统的许多方面。

这就是为什么如此多的金融公司正在大力投资机器学习研发。至于落后者,忽视人工智能和人工智能可能会被证明是代价高昂的。

金融领域有哪些机器学习用例?

让我们来看看金融领域一些很有前景的机器学习应用。

工序自动化

流程自动化是机器学习在金融领域最常见的应用之一。该技术允许取代手工作业,自动化重复性任务,并提高生产率。

因此,机器学习使公司能够优化成本、改善客户体验和扩大服务。以下是机器学习在金融领域的自动化应用案例:

  • 聊天机器人
  • 呼叫中心自动化。
  • 文书自动化。
  • 员工培训游戏化,等等。

以下是银行业流程自动化的一些示例:

摩根大通推出了一个合同智能(COiN)平台,该平台利用了机器学习技术之一的自然语言处理。该解决方案处理法律文档并从中提取重要数据。手动审查 12,000 份年度商业信贷协议通常需要大约 360,000 个工时。然而,机器学习允许在几个小时内审查相同数量的合同。

BNY·梅洛将流程自动化集成到他们的银行生态系统中。这项创新每年节省了30 万美元,并带来了大范围的运营改进

富国银行通过 Facebook Messenger 平台使用一个人工智能驱动的聊天机器人与用户交流,并提供密码和账户方面的帮助。

Privatbank 是一家乌克兰银行,在其移动和网络平台上实现了聊天机器人助手。聊天机器人加快了一般客户查询的解决,并允许减少人工助理的数量。

安全性

随着交易、用户和第三方集成数量的增加,金融领域的安全威胁也在增加。而机器学习算法在检测欺诈方面非常出色。

例如,银行可以利用这项技术实时监控每个账户的数千个交易参数。该算法检查持卡人采取的每个行动,并评估试图进行的活动是否是该特定用户的特征。这种模型可以高精度地发现欺诈行为。

如果系统识别出可疑账户行为,它可以要求用户提供额外的身份证明来验证交易。或者甚至完全阻止该交易,如果该交易有至少 95%的可能性是欺诈的话。机器学习算法只需要几秒钟(甚至几秒钟)就可以评估一项交易。这种速度有助于实时防止欺诈,而不仅仅是在犯罪发生后发现它们。

金融监控是金融领域机器学习的另一个安全用例。数据科学家可以训练系统来检测大量的小额支付,并将此类洗钱技术标记为 smurfing。

机器学习算法也能显著增强网络安全。数据科学家训练一个系统来发现和隔离网络威胁,因为机器学习在分析数以千计的参数和实时性方面首屈一指。在不久的将来,这项技术很有可能会为最先进的网络安全网络提供动力。

AdyenPayoneerPaypalStripeSkrill 是一些在安全机器学习领域投入巨资的著名金融科技公司。

承销和信用评分

机器学习算法非常适合金融和保险领域常见的承保任务

数据科学家在数千个客户资料上训练模型,每个客户有数百个数据条目。然后,一个训练有素的系统可以在现实生活环境中执行相同的承保和信用评分任务。这种评分引擎帮助人类员工更快更准确地工作。

银行和保险公司拥有大量的历史消费者数据,因此可以使用这些条目来训练机器学习模型。或者,他们可以利用大型电信或公用事业公司生成的数据集。

例如, BBVA 银行与另一个信用评分平台 Destacame 合作。该银行旨在为拉丁美洲信用记录不佳的客户增加信贷渠道。Destacame 通过开放 API 访问公用事业公司的账单支付信息。使用账单支付行为,Destacame 为客户生成一个信用评分,并将结果发送给银行。

算法交易

在算法交易中,机器学习帮助做出更好的交易 决策。一个数学模型实时监控新闻和交易结果,并检测可能迫使股价上涨或下跌的模式。然后,它可以根据自己的预测,主动卖出、持有或买入股票。

**机器学习算法可以同时分析成千上万的数据源,**这是人类交易员不可能实现的。

机器学习算法有助于人类交易员获得相对于市场平均水平的微弱优势。此外,鉴于交易量巨大,这一小小的优势往往会转化为可观的利润。

机器人顾问

机器人顾问现在在金融领域很常见。目前,机器学习在咨询领域有两个主要应用。

投资组合管理是一项在线财富管理服务,利用算法和统计数据来分配、管理和优化客户的资产。用户输入他们目前的金融资产和目标,比如说,在 50 岁时存下 100 万美元。然后,机器人顾问根据风险偏好和预期目标,在投资机会中分配当前资产。

理财产品推荐。许多在线保险服务使用机器人顾问向特定用户推荐个性化的保险计划。由于费用较低,以及个性化和标准化的建议,客户选择机器人顾问而不是个人理财顾问。

如何在金融中利用机器学习?

尽管人工智能和机器学习有诸多优势,但即使是财大气粗的公司也很难从这项技术中挖掘出真正的价值。金融服务业的在职者希望利用机器学习的独特机会,但实际上,他们对数据科学如何工作以及如何使用它有一个模糊的想法。

他们一次又一次地遇到类似的挑战,比如缺乏业务关键绩效指标。这反过来导致不切实际的估计和耗尽预算。仅仅有一个合适的软件基础设施是不够的(尽管这将是一个好的开始)。交付有价值的机器学习开发项目需要清晰的愿景、扎实的技术天赋和决心。

一旦你很好地理解了这项技术将如何帮助实现业务目标,就开始进行想法验证。这是数据科学家的任务。他们调查这个想法,并帮助你制定可行的 KPI 和做出现实的估计。

注意此时你需要收集所有的数据。否则,您将需要一名数据工程师来收集和清理这些数据。

根据特定的使用案例和业务条件,金融公司可以遵循不同的路径来采用机器学习。我们去看看。

放弃机器学习,转而关注大数据工程

通常,金融公司开始他们的机器学习项目只是为了意识到他们只需要适当的数据工程。 Max NechepurenkoN-iX 的高级数据科学家,评论道:

在开发[数据科学]解决方案时,我建议使用 奥卡姆剃刀 原则,这意味着不要过于复杂。大多数以机器学习为目标的公司实际上需要专注于可靠的数据工程,将统计数据应用于聚合数据,并将这些数据可视化。

仅仅将统计模型应用于经过处理且结构良好的数据,就足以让银行隔离其运营中的各种瓶颈和低效。

这些瓶颈的例子有哪些?这可能是特定分行的排队、可以消除的重复任务、低效的人力资源活动、移动银行应用程序的缺陷等等。

此外,任何数据科学项目的最大部分都可以归结为构建一个协调的平台生态系统,从数百个来源(如 CRM、报告软件、电子表格等)收集孤岛数据。

在应用任何算法之前,您需要对数据进行适当的结构化和清理。只有这样,你才能进一步将数据转化为洞察力。事实上,ETL(提取、转换和加载)和进一步清理数据占了机器学习项目时间的 80%左右。

使用第三方机器学习解决方案

即使你的公司决定在即将到来的项目中利用机器学习,你也不一定需要开发新的算法和模型。

大多数机器学习项目处理的都是已经解决的问题。谷歌、微软、亚马逊和 IBM 等科技巨头将机器学习软件作为服务出售。

这些开箱即用的解决方案已经被训练来解决各种业务任务。如果你的项目覆盖相同的用例,你相信你的团队能胜过这些拥有巨大 R&D 中心的科技巨头的算法吗?

一个很好的例子是谷歌的多种即插即用推荐解决方案。该软件适用于各种领域,检查它们是否适合您的业务案例是合乎逻辑的。

机器学习工程师可以实现专注于您的特定数据和业务领域的系统。专家需要从不同的来源提取数据,转换数据以适应特定的系统,接收结果,并可视化结果。

代价是缺乏对第三方系统的控制和有限的解决方案灵活性。此外,机器学习算法并不适合每个用例。 Ihar RubanauN-iX 的高级数据科学家评论:

目前还不存在通用的机器学习算法。在将算法应用于不同领域的不同业务案例之前,数据科学家需要调整和微调算法。

因此,如果谷歌的现有解决方案解决了你特定领域的特定任务,你可能应该使用它。如果没有,那么就以定制开发和集成为目标

创新和整合

从头开始开发机器学习解决方案是风险最大、成本最高、最耗时的选择之一。尽管如此,这可能是将 ML 技术应用于某些商业案例的唯一方法。

机器学习的研究和开发针对特定领域的独特需求,需要进行深入的调查。如果没有现成的解决方案来解决这些具体问题,第三方机器学习软件很可能会产生不准确的结果。

尽管如此,你可能还是需要大量依赖谷歌等公司的开源机器学习库。当前的机器学习项目主要是将现有的最先进的库应用于特定的领域和用例。

在 N-iX,我们已经确定了成功的企业研发项目在机器学习中的七个共同特征。他们在这里:

  1. 明确的目标。在收集数据之前,你至少需要对你想要用人工智能和机器学习实现的结果有一些大致的了解。在项目的早期阶段,数据科学家将帮助您将想法转化为实际的 KPI。
  2. 机器学习解决方案的健壮架构设计。你需要一个有经验的软件架构师来执行这项任务。
  3. 合适的大数据工程生态系统(基于 Apache Hadoop 或 Spark)是必备的。它允许收集、集成、存储和处理来自金融服务公司众多孤立数据源的大量数据。大数据架构师和大数据工程师负责构建生态系统。
  4. 在新创建的生态系统上运行 ETL 过程(提取、转换和加载)。大数据架构师或机器学习工程师执行这项任务。
  5. 最后的数据准备。除了数据转换和技术清理之外,数据科学家可能需要进一步细化数据,以使其适合特定的业务案例。
  6. 应用适当的算法,基于这些算法创建模型,微调模型,并用新数据重新训练模型。数据科学家和机器学习工程师执行这些任务。
  7. 洞察力的清晰可视化。商业智能专家对此负责。此外,您可能需要前端开发人员使用易于使用的 UI 来创建仪表板。

小项目可能需要更少的努力和更小的团队。例如,一些 R&D 项目处理小数据集,因此它们可能不需要复杂的大数据工程。在其他情况下,根本不需要复杂的仪表板或任何数据可视化。

关键要点

  • 金融从业者最常使用机器学习来实现流程自动化和安全性。
  • 在收集数据之前,您需要对数据科学的预期结果有一个清晰的认识。在项目开始之前,有必要设置可行的 KPI 并做出现实的估计。
  • 许多金融服务公司需要数据工程、统计和数据可视化,而不是数据科学和机器学习。
  • 训练数据集越大、越干净,机器学习解决方案产生的结果就越准确。
  • 您可以根据需要频繁地重新训练您的模型,而无需停止机器学习算法。
  • 没有适用于不同商业案例的通用机器学习解决方案。
  • 机器学习中的 R&D 代价高昂。
  • 像谷歌这样的科技巨头创造了机器学习解决方案。如果你的项目关注这样的用例,你不能期望胜过 Google、Amazon 或 IBM 的算法。

最初发表于www.n-ix.com

尼日利亚的机器学习,今天?

原文:https://towardsdatascience.com/machine-learning-in-nigeria-today-b2a953145c1f?source=collection_archive---------4-----------------------

拉各斯 2017 女性科技创客峰会是其他 14 个全球峰会之一,但也是唯一一个在非洲举办的峰会,于 4 月在拉各斯商学院成功举办。

这是丰富多彩的,引人入胜的,充满了许多时刻,我相信 300 多名与会者还没有忘记。

主题为“讲述你的故事”,由来自 Google、silences、Andela、SheLeadsAfrica 的摇滚明星演讲者和来自尼日利亚各地的许多知名女性在科技组织/倡议中进行了精彩的演讲和会议。

我喜欢下午有两个研讨会。一个是在公共演讲上无语,标记为“开发你的故事”,另一个是在tensor flow——谷歌的开源机器学习 API。

当然,两个研讨会都很成功...

这是我作为 SSA 社区经理最后一次参与谷歌开发者关系

在活动的筹备过程中,当我准备共同主持 Tensorflow 研讨会时,我一直在思考如何让机器学习(简称 ML)对今天的非洲企业和初创公司有价值,以及是否有我可以开发的核心用例,让 ML 与与会者更相关。

当然,在当今一些最引人注目的应用程序中,我们喜欢并认为理所当然的许多伟大特性都是 ML 驱动的;就像 GMail 中良好的垃圾邮件过滤和智能回复,Google Photos 中的自动图像识别和分类,甚至是上传到脸书的图像中便于标记的人脸识别。

我思考最多的问题是,非洲的企业如何利用机器学习来实现很酷的功能和服务,或者为现有的功能和服务创造更好的用户体验?

我决定引用常见的疑点——电子商务和娱乐——作为非洲人可以从 ML 中获得快速成功和巨大支持的垂直行业。我与导师分享了我的想法,她在 Tensorflow 研习班的课程中将这些想法作为伟大的 ML 范例呈现出来。

一切都很顺利——除了我没有按计划发表这篇文章。从那时起我就把它留在草稿里,到现在已经快 3 个月了!

最近拉各斯洪水的启示

这篇文章不发表,这个周末就不会过去。想到这里,我不禁想起了许多拉各斯居民的日常琐事、挣扎和现实——疯狂的交通、拥堵、不分青红皂白的垃圾处理、鲁莽的驾驶和停车、需要一年(或更长时间)预付的昂贵租金、兜售(或者你也可以称之为粗人)、糟糕的道路、维护不善的下水道、洪水等等

今年,我亲身经历了一年一度的拉各斯洪水。曾经有一段时间,水涨到了我的腰带以下。不要相信我的话,看下面几张照片..

今天的尼日利亚,机器学习能解决这些吗?这值得探索,我很高兴我不是唯一一个朝这个方向思考的人

最近拉各斯的洪水让我想到了威尼斯..甚至像 T2 威尼斯 T3 一样设计和建造的拉各斯。然后我突然想起机器学习可以帮助我通过威尼斯的眼睛想象我被洪水淹没的拉各斯。

使用 https://deepart.io ,我用一幅威尼斯的画转换了一些最近拉各斯洪水的照片。一个威尼斯主题但没有独木舟的拉各斯看起来可能是这样的:

有人也一直忙着为尼日利亚的机器学习出疯狂的随机想法。

玩笑归玩笑,机器学习拯救世界

好的。除了威尼斯主题的洪水淹没的拉各斯和优化自动驾驶汽车的算法的新奇之外,对于每年洪水淹没的拉各斯,我们今天可以从非洲的机器学习中受益吗?

图像识别和分类

许多以图像为主的非洲应用程序可以通过图像识别、分类和标记来改善功能和用户体验。

在 Konga 上搜索*“智能手机”,仅显示名称中带有“智能手机”*(包括空格)*的项目。“智能手机”也一样。*没有一个结果包括 iPhone,一款 Konga 目录中的智能手机?

电子商务平台可以通过使用来自商品图像的元数据自动标记商品目录中的商品来优化这种用户体验。谷歌云视觉 API 可以通过分析 iPhone 的照片来自动识别 iPhone 是否为智能手机。然后可以用它来标记商品,并建立一个索引,以便在搜索过程中识别它。

我也喜欢搜索只有游泳池的酒店。有高尔夫球场的酒店怎么样?分析他们的图像库可以揭示这些。

视频标记、标签和编目

我是一个爸爸,我的儿子刚满一岁。我们关系很好,我妻子有时会嫉妒。他喜欢卡通片,当卡通人物唱歌或跳舞时,他喜欢跳舞。他对电影也是如此。 iROKOtv 如何帮我在尼日利亚电影中加入唱歌或跳舞的场景?

我有一个肯尼亚朋友,她第一次去拉各斯,当她乘坐的一辆汽车被拿着枪的尼日利亚警察拦下时,她吓了一跳。虽然对许多尼日利亚人来说,这是相对正常的,但这是她第一次近距离使用这种武器。在她下一次访问之前, iROKOtv 能否通过在尼日利亚电影中加入警察或枪战场景来帮助她更好地适应尼日利亚的警察现实?

在 iROKOtv 上搜索“警察”或“交通”什么也没有,我想这是因为没有电影或演员的名字中有这些词。

对于 2018 年的情人节广告活动,iROKOtv将如何从其目录中创建最佳接吻场景的精彩视频?如果 iROKOtv 的目录中有婚礼派对,搜索“舞蹈”会出现它吗,因为它是尼日利亚电影中最好的舞蹈场景之一?

Google 的云视频智能 API 可以帮助解决这些用例。像视觉 API 一样,它分析视频和表面元数据,这些元数据可用于识别、分类和搜索它们

行动呼吁

今天,机器学习在非洲有着巨大的潜力!大型科技公司(谷歌、苹果、微软 e.t.c)已经将人工智能命名为未来——不是应用程序,不是移动设备,也不是操作系统——而是我们赋予计算机学习、做事和做人的能力,以及它所蕴含的潜力。这是实现变革体验的能力。

借助 Tensorflow、Cloud Vision API 和 Video Intelligence API 等工具,我们不必等到我们可以实现算法,让自动驾驶汽车在我们的地形中工作。我们可以马上开始获得价值

我们的用户使用谷歌照片、脸书等获得了很好的体验,并有很高的期望。再说,就是看 ..

我想收到你的来信。请在下面的评论区分享你的想法,或者发推文 @chaluwa 提出任何问题或建议。另外,如果你觉得这篇文章有用,别忘了推荐和分享它。

搜索引擎广告中的机器学习

原文:https://towardsdatascience.com/machine-learning-in-sponsored-search-6c9ab18e6c67?source=collection_archive---------4-----------------------

这篇文章旨在介绍一些与搜索引擎广告(赞助搜索)中的机器学习挑战相关的关键论文。这篇文章假设读者熟悉维基百科层面的搜索引擎广告。

拉哈文和伊耶。评估用于查询到广告匹配的向量空间和概率模型。

比较了传统的信息检索方法——BM25、改进的 TFIDF、语言模型和翻译模型与广告查询的相关性。本文进一步修改了翻译模型,通过混合模型增加了查询-广告对中广告被点击的概率。

索尔多尼、本吉奥、瓦哈比、利奥马、格鲁尔·西蒙森和聂。用于生成上下文感知查询建议的分层递归编解码器

作者采用深度学习来获得查询建议。该论文声称,虽然过去的方法只能将以前看到的查询作为查询建议,但所提出的方法能够根据需要生成综合建议。他们的工作对于长尾查询特别重要,因为这些查询很少出现,甚至是唯一的,因此,将这样的查询匹配到头部查询并不总是成功的。作者将递归神经网络(RNNs)改进为分层递归编解码器。查询被一个字一个字地馈送给 RNN,而查询会话被使用另一组 rnn 并行地一个查询一个查询地馈送。该方法的训练目标是在看到前一个查询之后,在预测会话中的下一个查询时最大化会话的对数似然。

D .希拉德,s .施罗德,e .马纳沃格卢,h .拉加万,c .莱格特。提高赞助搜索中的广告相关性。

作者将广告-查询相关性建模为机器学习问题。作者建议使用 19 个初始特征,包括广告副本和查询之间的公共 n 元语法以及广告和查询之间的余弦相似性。作者通过添加“点击”功能(如点击频率和广告被点击时的位置)进一步改进了模型。对于新广告,作者建议利用更高阶的点击聚合,如广告活动、广告类别等

A .梅塔。在线匹配和广告分配。理论计算机科学,8(4):265–368,2012

赞助搜索也从收入最大化的角度进行了研究。它通常被建模为在线二分图,其中一组图(广告)是已知的,而另一组是在线的(查询)。收入最大化的目标是将传入的查询与现有的广告相匹配,以实现收入最大化。作者构建了一个算法,考虑到相同的二分模型,即有“n”个投标人,每个人都有一个每日预算,“b”,搜索引擎只有在用户点击广告时才会付费。

这与其说是一篇 ML 论文,不如说是一篇优化论文,但对于想从事搜索广告和机器学习的人来说,这是一篇非常重要的论文。

T. Graepel,J. Q. Candela,T. Borchert 和 R. Herbrich。微软必应搜索引擎中赞助搜索广告的网络规模贝叶斯点击率预测。

这篇论文是关于 CTR 预测的,在 ICML 发表。所提出的算法基于将输入特征映射到概率的回归。它在模型的权重上保持高斯信念,并执行从近似消息传递中导出的高斯在线更新。作者根据经验表明,该算法在 Bing 广告上的表现优于考虑的基线。

M .理查森、e .多明我会斯卡和 r .拉格诺。预测点击:估计新广告的点击率。

这是另一篇关于 CTR 预测的论文。作者试图将新广告的点击率估计问题建模为机器学习问题。作者选择和设计特征来训练逻辑回归模型。模型中使用的特征包括广告的术语点击率和相关广告的点击率

X .李,m .张,y .刘,s .马,y .金,l .茹。基于二分图传播的搜索引擎点击垃圾邮件检测。

本文讨论的是在线广告中(可能)最具威胁性的点击欺诈。。在分析欺诈点击特征的基础上,提出了一种新的垃圾点击自动检测方法,该方法通过建立用户会话图和点击模式会话图来识别欺诈行为。

*就这些了,伙计们!*基于对这篇文章的回应,我计划写更多关于赞助搜索中 ML 特定领域的文章,如 CTR 预测或尾部查询大写等。

与此同时,我将在 github 上保持这个知识库的更新,更新赞助搜索中与 ML 相关的最新论文。

机器学习导论:综合指南

原文:https://towardsdatascience.com/machine-learning-introduction-a-comprehensive-guide-af6712cf68a3?source=collection_archive---------5-----------------------

Picture from Unsplash

这是我将描述机器学习概念、类型、算法和 python 实现的系列文章的第一篇。

该系列的主要目标是:

  1. 创建机器学习理论和直觉的综合指南。
  2. 分享和解释用 python 开发的机器学习项目,以实用的方式展示所解释的概念和算法,以及它们如何应用于现实世界的问题。
  3. 在主题中留下我的知识的数字足迹,并激励其他人在自己的领域中学习和应用机器学习。

本系列中公开的信息有几个来源,主要有:

  • 机器学习工程师纳米学位(Udacity)
  • Python 机器学习书籍(Sebastian rasch ka & va hid Mirjalili)
  • 用 Python 书深度学习(Francois Chollet)
  • 用 Python 书精通机器学习(Jason Brownlee)
  • 何塞·波尔蒂利亚教授的 Python 数据科学和机器学习课程(Udemy)
  • 曼努埃尔·加里多的机器学习和数据科学与 Python 课程

什么是机器学习?

由于技术和传感器价格的大幅下降,我们现在可以创建、存储和发送比历史上任何时候都多的数据。仅在过去两年中,全球就有高达 90%的数据被创建。以我们目前的速度,每天有 250 亿字节的数据被创建,而且这一速度还会继续增长。这些数据提供给机器学习模型,并且是这门科学近年来经历的繁荣的主要驱动力。

机器学习是人工智能的一个子领域,可以描述为:

“机器学习是一门让计算机像人类一样学习和行动的科学,通过以观察和现实世界互动的形式向它们提供数据和信息,以自主的方式随着时间的推移改善它们的学习。”—丹·法盖拉

机器学习提供了一种有效的方法来捕获数据中的知识,以逐步提高预测模型的性能,并做出数据驱动的决策。它已经成为一项无处不在的技术,我们享受着它的好处:垃圾邮件过滤器、无人驾驶汽车、图像和语音识别以及世界级围棋选手

下一个视频展示了视频监控机器学习应用的实时事件检测。

基本术语和符号

通常在机器学习中,使用矩阵和向量符号来表示数据。该数据通常以矩阵形式使用,其中:

  • 矩阵中的每一行都是一个样本、观察值或数据点。
  • 每一列都是观察特征(或属性)。
  • 通常有一个列(或特征),我们称之为目标、标签或响应,它是我们试图预测的值或类。

Table By Author

训练一个机器学习模型,就是给机器学习算法提供训练数据,从中学习。

关于机器学习算法,它们通常有一些内部参数。ie:在决策树中,有深度、节点数、叶子数等参数……这些内部参数被称为超参数。

泛化是模型对新数据进行预测的能力。

机器学习的类型

本系列将学习的机器学习类型有:

  • 监督学习
  • 无监督学习
  • 深度学习。

在这个系列中,我们将探索和研究所有提到的机器学习类型,我们还将更深入地挖掘一种叫做“强化学习”的深度学习技术。

监督学习

监督学习是指一种用一组样本训练的机器学习模型,其中期望的输出信号(或标签)是已知的。模型从这些已知的结果中学习,并调整其内部参数以适应输入数据。一旦模型经过适当的训练,它就可以对未知的或未来的数据做出准确的预测。

一般流程概述:

Figure by Author

监督学习有两个主要应用:分类和回归。

  1. 分类:

分类是监督学习的一个子类,其目标是基于过去的观察来预测新实例的分类类别标签(离散的、无序的值、组成员)。典型的例子是电子邮件垃圾邮件检测,这是一种二元分类(电子邮件要么是-1-垃圾邮件,要么不是-0-垃圾邮件)。还有多类分类,如手写字符识别(类别从 0 到 9)。

二进制分类的一个例子:有两个类别,圆和十字,以及两个特征,X1 和 X2。该模型能够找到每个数据点的特征与其类别之间的关系,并在它们之间设置边界线,因此当提供新数据时,它可以估计其所属的类别,给定其特征。

Figure by Author

在这种情况下,新数据点落入圆形子空间,因此,模型将预测其类别为圆形。

2。回归:

回归也用于将类别分配给未标记的数据。在这种类型的学习中,我们被给予一些预测(解释)变量和一个连续的反应变量(结果),我们试图找到这些变量之间的关系,使我们能够预测一个连续的结果。

线性回归的一个例子:给定 X 和 Y,我们拟合一条直线,使样本点和拟合直线之间的距离最小化(使用一些标准,如平均平方距离(SSE))。然后,我们将使用拟合线的截距和斜率来预测新数据的结果。

Figure by Author

无监督学习

在无监督学习中,我们处理未知结构的未标记数据,目标是探索数据的结构以提取有意义的信息,而无需参考已知的结果变量。

主要有两类:聚类和降维。

  1. 聚类:

聚类是一种探索性的数据分析技术,用于将信息组织成有意义的群或子群,而无需事先了解其结构。每个群集是一组相似的对象,它们与其他群集的对象不同。

Figure by Author

2。降维:

通常情况下,处理的数据中的每个观察值都带有大量的特征,换句话说,这些特征具有很高的维数。这对机器学习算法的计算性能来说是一个挑战,因此降维是用于处理这个问题的技术之一。

降维方法通过发现特征之间的相关性来工作,这意味着存在冗余信息,因为一些特征可以用其他特征来部分解释。它从数据中去除噪声(噪声也会降低模型的性能),并将数据压缩到一个更小的子空间,同时保留大部分相关信息。

深度学习

深度学习是机器学习的一个子领域,它使用人工神经网络的分层结构,人工神经网络以类似于人脑的方式构建,神经元节点连接成一个网络。该架构允许以非线性方式处理数据分析。

神经网络的第一层将原始数据作为输入,对其进行处理,提取一些信息,并将其作为输出传递给下一层。然后每一层处理前一层给出的信息并重复,直到数据到达最后一层,最后一层进行预测。

该预测与已知结果进行比较,然后通过一种称为反向传播的方法,该模型能够学习产生准确输出的权重。

Figure by Author

强化学习

强化学习是深度学习最重要的分支之一。目标是建立一个模型,其中有一个代理采取行动,目的是提高其性能。这种改进是通过在代理每次执行属于开发人员希望代理执行的一组动作中的一个动作时给予特定的奖励来实现的。

奖励是对行动达到预定目标的程度的衡量。然后,代理使用这个反馈来调整它未来的行为,目的是获得最大的回报。

一个常见的例子是象棋引擎,其中代理从一系列可能的行动中做出决定,这取决于棋盘的部署(这是环境的状态)以及在赢得或输掉游戏时给出的奖励。

Figure by Author

构建机器学习模型的一般方法

Figure by Author

预处理:

这是任何机器学习应用程序中最关键的步骤之一。通常数据的格式对于模型来说不是最佳的(甚至是不合适的)。在这种情况下,预处理是一项必须完成的任务。

许多算法要求特征在相同的尺度上(例如:在[0,1]范围内)以优化其性能,这通常通过对数据应用归一化或标准化技术来实现。

我们还可以发现,在某些情况下,所选择的特征是相关的,因此对于从中提取有意义的信息来说是冗余的。然后,我们必须使用降维技术将特征压缩到更小的维度子空间。

最后,我们将把原始数据集随机分成训练和测试子集。

训练和选择模型

为了训练和选择性能最好的算法,有必要对一系列不同的算法进行比较。为此,有必要选择一个度量标准来衡量模型的性能。分类问题中一个常用的是分类精度,即正确分类实例的比例。在回归问题中,最受欢迎的是均方误差(MSE ),它测量估计值和真实值之间的平均平方差。

Figure bu Author

最后,在使用测试子集对模型进行最终评估之前,我们将使用一种称为交叉验证的技术来确保我们的模型在真实世界数据中表现良好。

这种技术将训练数据集划分为更小的训练和验证子集,然后估计模型的泛化能力,换句话说,估计当提供新数据时它可以预测结果的程度。然后,它重复这个过程, K 次,并通过除以在 K 次迭代之间获得的度量的总和来计算模型的平均性能。

Figure by Author

一般来说,库提供的机器学习算法的默认参数不是与我们的数据一起使用的最佳参数,因此我们将使用超参数优化技术来帮助我们对模型的性能进行微调。

评估模型并使用新数据进行预测

一旦我们为我们的训练数据集选择并拟合了一个模型,我们就可以使用测试数据集来估计这个未知数据的性能,因此我们可以估计模型的泛化误差。或者使用其他度量来评估它。

如果我们对获得的度量值感到满意,那么我们可以使用该模型对未来数据进行预测。

包裹

在这篇文章中,我们学习了什么是机器学习,描绘了它的本质、动机和应用的大画面。

我们还学习了一些基本的符号和术语,以及不同种类的机器学习算法:

  • 监督学习,有分类和回归问题。
  • 无监督学习,带聚类和降维。
  • 强化学习,代理从它的环境中学习。
  • 深度学习及其人工神经元网络。

最后,我们介绍了构建机器学习模型的典型方法,并解释了其主要任务:

  • 预处理。
  • 培训和测试。
  • 选择模型。
  • 评估中。

如果你喜欢这篇文章,那么你可以看看我关于数据科学和机器学习的其他文章 这里

如果你想了解更多关于机器学习、数据科学和人工智能的知识 请在 Medium 上关注我,敬请关注我的下一篇帖子!

机器学习正在颠覆会计行业

原文:https://towardsdatascience.com/machine-learning-is-disrupting-the-accounting-industry-dadca0daed5f?source=collection_archive---------2-----------------------

“机器学习”一词在过去一年左右已经成为一个时髦词汇。每年都有数十亿美元投资于人工智能(AI)技术——根据麦肯锡全球研究所的研究,2016 年的投资在 260 亿至 390 亿美元之间——其中近 60%投入了机器学习。

金融服务以及高科技和电信是领先的早期采用者。麦肯锡预测,这三个行业将在未来三年继续引领 AI 的采用。

这项技术变得非常复杂,早期采用者开始看到明显的好处。在金融服务行业,采用主动战略的人工智能采用者的利润率比不采用者高出约 12.5%。

Xero 是一个面向小企业的云会计平台,今年早些时候在他们的软件中引入了机器学习。

什么是机器学习?

机器学习是人工智能的一个子领域。人工智能领域的先驱阿瑟·塞缪尔(Arthur Samuel)在 1959 年创造了“机器学习”一词,根据他的说法,机器学习赋予了“计算机无需明确编程就能学习的能力”。

机器学习使用神经网络,其功能设计与人脑相同。当算法处理和分析足够多的数据时,它们开始识别模式,建立联系,并根据数据包含的元素对其进行分类。

计算机不如人类聪明,但因为它们处理数据的速度比人快得多,所以它们的速度非常快,而且得出的结论通常非常准确。

机器学习如何影响金融

会计软件变得越来越智能,它已经在执行以前需要人工干预的任务。重复、手动和繁琐的任务被消除,因此簿记员和企业主现在可以花更少的时间来更新他们的帐户,而将更多的时间用于其他重要的任务。

以下是这项技术已经影响到的一些具体任务的示例:

  • 会计应用程序学习发票编码行为,并建议交易应分配到哪里。例如,如果销售人员通常将产品分配到特定的销售帐户,下次销售人员将该项目添加到发票时,会计应用程序会自动将其分配到正确的帐户。它还关注簿记员和会计师纠正的错误。例如,如果企业所有者将一些东西分配到错误的账户,而会计纠正了错误,会计应用程序将把会计的选择作为正确的选择。
  • 银行对账是自动化的。同样,技术从以前的分配和账户选择中学习,然后为新的银行交易提供正确的建议。
  • 银行使用人工智能聊天机器人来帮助客户解决常见的查询。来自会计程序的聊天机器人,如 Xero ,可以让你查询最新的财务数据,如银行里有多少钱,某个账单何时到期,谁欠你钱,它甚至可以将用户与他们目录中的 Xero advisors 联系起来。

此外,这项技术也将在不久的将来影响审计人员的工作。目前,审计员只研究交易的精选样本。他们雇佣了大量的会计团队,加班加点在截止日期前完成审计。流经公司的大量交易限制了审计人员可以手动检查的交易数量。

据普华永道称,未来审计师将能够审计 100%的公司财务交易。机器学习算法将处理和审查数据,识别异常,并编制异常值列表,供审计人员检查。审计人员可以将他们的技能用于调查和推断模式或异常背后的原因,而不是花大部分时间检查数据。

为什么这对行业来说是好消息

在与不懂会计的小企业主一起工作时,你可能已经看到他们发现让他们的账簿保持最新并记住在哪里分配交易很有挑战性。这会造成时间损失和不必要的错误,作为他们的会计,你必须在以后纠正这些错误。这也意味着他们的账目从来都不准确,让他们对自己的财务表现一无所知。自动建议或完成会计代码的机器学习技术消除了错误,节省了大量时间。

除了节省时间之外,如果审计师能够检查一家公司的每一笔交易,他们的财务信息将更加准确,审计师可以花更多的时间分析财务数据,为客户提供更好的建议。

技术可以做繁重的工作,数字运算和报告编辑,而会计师专注于判断密集型任务。机器不能像人类一样思考。他们也没有我们的情商。技术使会计师更有效率和生产力,以便会计师可以解释数据,为他们的客户提供更好的见解和商业建议。

会计行业的未来如何?

根据总部设在香港的投资公司 CLSA 的说法,人工智能创造的就业机会将多于它“摧毁”的就业机会,但这种转变将是痛苦的。在接下来的五到十年里,我们可以期待看到财务领域的重大变化,会计师将需要学会快速适应。

据埃森哲称,到 2020 年,超过 80%的传统金融服务将由包括人工智能在内的跨职能团队提供。人工智能将处理数据,寻找异常,并编制报告,而人类会计师将分析数据,并根据他们的经验和知识向客户提供明智的建议。

如果你不是一个精通技术的会计师,不要被这个吓到。这只是一种不同的思考方式,一种容易学习的方式。从 Xero 这样的云会计程序开始尝试吧。一旦你习惯了这一点,你会发现很容易采用其他智能技术,并利用它们为你服务。

观看国际象棋传奇人物加里·卡斯帕罗夫的有趣的 Ted 演讲,关于我们如何不应该害怕智能机器,而是应该与它们合作。

来源:

麦肯锡全球研究院,人工智能,下一个数字前沿:http://www . McKinsey . com/business-functions/McKinsey-analytics/our-insights/how-Artificial-Intelligence-can-deliver-real-value-to-companies

本文原载于thecreativeaccountant.net

机器学习是癌症预测的未来

原文:https://towardsdatascience.com/machine-learning-is-the-future-of-cancer-prediction-e4d28e7e6dfa?source=collection_archive---------3-----------------------

在准确预测癌症的发展方面,机器学习模型比病理学家更好。

Photo by Ken Treloar on Unsplash

每年,病理学家在全世界诊断出 1400 万新的癌症患者。这意味着数百万人将面临多年的不确定性。

几十年来,病理学家一直在进行癌症诊断和预测。大多数病理学家诊断癌症的成功率为 96-98%。他们很擅长这部分。

问题出现在下一部分。根据奥斯陆大学医院的数据,病理学家的预后准确率只有 60%。预后是在癌症被诊断后进行的活组织检查的一部分,它预测疾病的发展。

是时候进行病理学的下一步了。

机器学习简介

病理学的下一步是机器学习。

机器学习是人工智能的核心分支之一。这是一个接收数据、发现模式、使用数据训练自己并输出结果的系统。

那么是什么让一台 机器 比一名训练有素的专业人员更优秀呢?

与病理学家相比,ML 具有关键优势。

首先,机器可以比人工作得快得多。活检通常需要病理学家 10 天的时间。一台计算机可以在几秒钟内完成数千次活检。

机器可以做一些人类不擅长的事情。他们可以重复数千次而不会感到疲惫。每次迭代后,机器都会重复该过程,以便做得更好。人类也这样做,我们称之为练习。虽然熟能生巧,但是再多的练习也无法使人接近计算机的计算速度。

另一个优点是机器的精确度很高。随着物联网技术的出现,世界上有如此多的数据,人类不可能全部查看。这就是机器帮助我们的地方。他们可以比我们做得更快,进行精确的计算,发现数据中的模式。这就是它们被称为计算机的原因。

机器学习的简要技术说明

首先,有两大类机器学习,

  1. 监督学习
  2. 无监督学习

监督学习被输入标记数据

监督学习也许用它自己的名字来描述是最好的。监督学习算法是一种由给定数据“教授”的算法。

模型使用标记的数据训练自己,然后测试自己。重复这一过程,直到获得最佳结果。一旦完成,它就可以对未来的实例进行预测。

无监督学习从未标记的数据中得出结论

在无监督学习中**数据集没有被标记。**相反,模型的工作是通过寻找模式(如分组和聚类)来创建适合数据的结构

把无监督学习想象成婴儿。婴儿出生在这个世界上,除了本能之外,不知道什么是“对”或“错”。随着他们的成长,他们会看、摸、听、感觉(输入数据)并尝试一些东西(测试数据),直到他们知道是什么。

好的,你知道 ML 的两个主要类别。酷毙了。现在让我们更深入地研究一下 ML 使用的一些技术。

回归使结果更加准确

回归的主要目标是最小化模型的成本函数。

什么是成本函数?

成本函数是计算值 x 的假设和实际值 x 之间的距离的函数。基本上,它告诉你结果离实际答案有多远。

回归的全部意义在于找到一个超平面(多维线的花哨说法),该超平面使成本函数最小化,以创建数据点之间的最佳可能关系。

Linear regression making the relationship more accurate

它从一条没有相关性的随机线开始,重复使用梯度下降成为最佳关系。

使用一种叫做**梯度下降的算法进行回归。**在该算法中,通过模型调整其参数来降低成本函数。

Think of descent as you running down a hill, trying to get to the lowest point.

同时,随着梯度下降使代价函数越来越低,结果也变得更加精确。

这就是通过使用回归来更好地拟合给定数据,从而使您的模型变得更加准确的方法。

分类将数据点分类成组

监督学习模型不仅仅可以做回归。ML 最有用的任务之一是分类。

分类算法在数据点之间建立边界,根据它们与模型参数匹配的特征,将它们分类为某一组。

In this model, data points are classified as either being sheep or goat. This is conditional on their steps per day depending on average daily temperature.

使用称为逻辑回归的过程来创建类别之间的界限。

需要记住的一个重要事实是边界不依赖于数据

还记得成本函数吗?惊喜!它也用于分类。

In classification, it is used similarly to regression to find the best possible fit to the data.

支持向量机

SVM 算法是用于分类和回归的监督学习算法。

SVM 算法的目标是通过创建一个边界来对数据进行分类,该边界在其自身和数据之间具有最大可能的余量

决策树缩小到一个结果

决策树是一个树状模型(i *f 树长倒了)*用 ML 表示概率和决策。

The process of deciding what you’ll be eating

如上图所示,DT 使用条件语句来缩小某个值在某个实例中出现的概率。它使用 DT 模型来预测某个实例具有某个结果的概率。

DT 继续分裂成更多的节点,直到每个输入都有结果。

Basically, internal nodes split further while external nodes are like a stop sign.

贝叶斯网络估计概率

BN 是一个类似于决策树的分类器。不同的是, BN 分类器显示概率估计而不是预测。

变量的数据集和它们的条件依赖关系以一种叫做有向无环图的可视化形式显示出来。

在上面的例子中,草地潮湿的两个原因要么是因为下雨,要么是因为洒水器。使用 BN 模型,可以找到每种可能情况的概率。

人工神经网络从数据中学习

安从给定的数据中学习。它从我们自己的神经系统中获得灵感,尽管它们的工作方式不尽相同。

ANN 模型在我们称之为输入层的一层中输入大量数据。从这些数据中,进行比较,模型自动识别数据的特征并给其贴上标签。

They’re kind of similar I guess?

在 ANN 中有三种层类型。

  • 输入层
  • 隐藏层
  • 输出层

这就是人工神经网络的工作方式——首先,输入层的每个神经元都被赋予一个值,称为激活函数。然后,它被分配一个随机权重,而隐藏层神经元被分配一个随机偏差值。在隐藏层中,一种称为激活函数的算法为隐藏层神经元分配一个新的权重,该权重乘以输出层中的随机偏差值。

The first model with random bias and weights. The network is essentially guessing at this point.

这个激活函数乘以一个随机权重,通过称为反向传播的过程,随着迭代次数的增加而变得更好。

通过这种方式,模型对给定实例的输出进行随机预测。使用反向传播,人工神经网络模型调整其参数,使答案更准确。

Machines think this cat is pretty adorable too.

例如,如果一个模型要从一个大型图像数据库中对猫进行分类,它将通过识别构成眼睛和尾巴等特征的边缘来学习,并最终扩大到识别整只猫。把这个过程想象成搭建乐高。你确定不同的部分,把不同的部分放在一起,最后把所有不同的部分放在一起,就成了你的杰作。

回到机器学习癌症预测

好了,现在你对机器学习有了一定的了解。

现在,到了精彩的部分。现在,您将了解一些用于癌症活检和预后的模型。

预测癌症易感性的模型

我要展示的第一个模型是用来区分乳腺癌患者的肿瘤是恶性还是良性的。

在这个模型中,人工神经网络被用来完成任务。该模型使用大量隐藏层构建,以更好地概括数据。成千上万的乳房 x 线照片记录被输入该模型,以便它能够学习区分良性和恶性肿瘤。在输入之前,所有的数据都经过了放射科医生的审核。

An example of what a cancer prediction neural network’s inputs could be.

该模型在很大程度上是成功的,AUC 的准确度为 0.965 (AUC,或曲线下面积是检验模型成功的一种方法)。尽管这种模型是准确的,但它相对于病理学家的主要优势是更加一致、有效和不容易出错。

预测癌症复发的模型

好吧,预测癌症很简单。但是对人类来说,预测癌症的 T2 复发是一项更加复杂的任务。幸运的是,机器越来越擅长这个。让我来解释一下。

该模型使用多种 ML 技术来学习如何预测癌症患者完全缓解后口腔癌的复发。为该模型从 86 名患者中收集了临床、影像和基因组来源的数据。特征选择算法将模型的特征从 110 个以上减少到 30 个以下。这使得模型更加有效,并大大减少了偏差。该模型使用 BN、ANN、SVM、DT 和 RF 进行测试,将患者数据分类为癌症复发和未复发的患者。

This BNN model predicts the recurrence of breast cancer.

最后,该模型使用特征选择数据和 BN 正确地预测了所有患者。尽管这是一个非常精确的模型,但它的数据集非常小,只有 86 名患者。

在另一项类似的研究中,研究人员制作了一个 ML 模型,使用 SVM 氏、ANN 和回归来测试,以将患者分为癌症复发的低风险和高风险组。SVM 模型优于其他两个模型,准确率为 84%。这是开创性的,因为它比病理学家要精确得多。

预测癌症存活率的模型

该模型采用了 162,500 条记录和 16 个关键特征的数据集。利用肿瘤的大小和患者的年龄等特征,该模型为患者是否存活创建了一个分类模型。该模型使用 SVM、人工神经网络和半监督学习(SSL:监督和非监督学习的混合)进行了测试。它发现 SSL 是最成功的,准确率为 71%。

另一项研究使用人工神经网络来预测肺癌患者的存活率。它有 83%的准确率。这项研究被认为在很大程度上是准确的,尽管它没有考虑其他与死亡相关的因素,如血凝块。

癌症预后的未来是什么样子的?

人工智能将在未来几十年内改变医疗行业——如果病理学没有被打乱,那就没有意义了。

目前,ML 模型仍处于癌症预后的测试和实验阶段。随着数据集越来越大,质量越来越高,研究人员正在建立越来越精确的模型。

未来的癌症活检可能是这样的:
你在诊所或家里进行临床测试。数据被输入病理 ML 系统。几分钟后,您收到一封电子邮件,其中有一份详细的报告,对您的癌症发展进行了准确的预测。

虽然你今天可能看不到人工智能做病理学家的工作,但你可以期待在未来几十年里人工智能取代当地的病理学家,这非常令人兴奋!

最大似然模型还有很长的路要走,大多数模型仍然缺乏足够的数据,并遭受偏见。然而,我们可以肯定的是 ML 是病理学的下一步,而它将颠覆这个行业。

“肯定会有工作中断。因为将要发生的是机器人将能够做得比我们更好。……我指的是我们所有人,”—埃隆·马斯克

关键要点

  • 机器学习是人工智能的一个分支,它使用许多技术来完成任务,在每次迭代后自我完善。
  • 病理学家在诊断癌症方面很准确,但在预测癌症发展时,准确率只有 60%。
  • 机器学习是我们克服这一障碍并创建高精度病理学系统的下一步。

感谢阅读!如果你喜欢这篇文章:

  • 确保通过分享来表示支持
  • 通过 Linkedin 与我保持联系
  • 关注我在媒体上更多这样的文章!

机器学习 Kaggle 竞赛第一部分:入门

原文:https://towardsdatascience.com/machine-learning-kaggle-competition-part-one-getting-started-32fb9ff47426?source=collection_archive---------1-----------------------

学习 Kaggle 环境和入门笔记本

在数据科学领域,可用的资源几乎太多了:从 Datacamp 到 Udacity 到 KDnuggets,网上有成千上万的地方可以学习数据科学。然而,如果你喜欢一头扎进去,边干边学,Kaggle 可能是通过动手数据科学项目拓展你技能的最佳地点。

虽然它最初被称为机器学习竞赛的地方,但自称为“数据科学之家”的 Kaggle ,现在提供了一系列数据科学资源。尽管这一系列文章将关注一场竞赛,但有必要指出 Kaggle 的主要方面:

  • 数据集: 数以万计的各种不同类型和大小的数据集,你可以免费下载使用。如果您正在寻找有趣的数据来探索或测试您的建模技能,这是一个很好的去处。
  • 机器学习竞赛: 这些建模技能测试曾经是 Kaggle 的核心,是学习前沿机器学习技术和使用真实数据磨练您在有趣问题上的能力的绝佳方式。
  • 学习**:**Jupyter 笔记本中教授的一系列涵盖 SQL 到深度学习的数据科学学习曲目。
  • 讨论: 一个向 Kaggle 社区成千上万的数据科学家提问并获得建议的地方。
  • 内核: 运行在 Kaggle 的服务器上的在线编程环境,在这里你可以编写 Python/R 脚本,或者 Jupyter 笔记本。这些内核完全免费运行(你甚至可以添加一个 GPU ),并且是一个很好的资源,因为你不必担心在自己的计算机上设置数据科学环境。内核可用于分析任何数据集,参加机器学习竞赛,或完成学习轨迹。您可以从其他用户那里复制并构建现有的内核,并与社区共享您的内核以获得反馈。

The main aspects of Kaggle

总的来说,Kaggle 是一个学习的好地方,无论是通过更传统的学习途径还是通过比赛。当我想了解最新的机器学习方法时,我可以去看书,或者,我可以去 Kaggle,找到一个竞赛,看看人们在实践中如何使用它。就我个人而言,我觉得这更有趣,也是更有效的教学方法。此外,社区非常支持,总是愿意回答问题或提供项目反馈。

在这篇文章中,我们将重点关注一个 Kaggle 机器学习竞赛的开始:家庭信用违约风险问题。这是一场相当简单的比赛,有一个合理大小的数据集(不能对所有比赛都这样说),这意味着我们可以完全使用 Kaggle 的内核进行比赛。这大大降低了准入门槛,因为你不必担心你电脑上的任何软件,你甚至不必下载数据!只要你有一个 Kaggle 帐户和一个互联网连接,你就可以连接到一个内核并运行代码。

我计划在 Kaggle 和内核(一个 Python Jupyter 笔记本)上做整个比赛,这篇文章的在这里可以找到。为了从本文中获得最大收益,创建一个 Kaggle 帐户来复制内核,然后点击 blue Fork Notebook 按钮。这将打开笔记本进行编辑,并在内核环境中运行。

竞争描述

家庭信用违约风险竞赛是一项标准的监督机器学习任务,目标是使用历史贷款申请数据来预测申请人是否会偿还贷款。在训练期间,我们为我们的模型提供特征(描述贷款申请的变量)和标签(如果贷款已偿还,则为二进制 0,如果贷款未偿还,则为 1),模型学习从特征到标签的映射。然后,在测试期间,我们向模型提供新一批应用程序的功能,并要求它预测标签。

本次比赛的所有数据都是结构化的,这意味着它们存在于整齐的行和列中——想象一个电子表格。这意味着我们不需要使用任何卷积神经网络(擅长处理图像数据),这将给我们在真实世界数据集上的巨大实践。

竞赛主办方 Home Credit ,是一家专注于服务无银行账户人群的金融提供商。预测应用程序是否会偿还贷款是一项至关重要的业务需求,Home Credit 开发了这项竞赛,希望 Kaggle 社区可以为这项任务开发一种有效的算法。这个比赛遵循大多数 Kaggle 比赛的一般想法:一家公司有数据和问题要解决,而不是(或除此之外)雇佣内部数据科学家来建立模型,他们设立一个适度的奖项,吸引整个世界贡献解决方案。一个由数千名技术娴熟的数据科学家(Kagglers)组成的社区然后免费研究这个问题,以得出最佳解决方案。就成本效益商业计划而言,这似乎是一个绝妙的主意!

Kaggle 竞争环境

当你进入比赛主页时,你会看到这个:

下面是选项卡的快速浏览

  • **概述:**问题的简要描述、评估标准、奖品和时间表
  • **数据:**比赛所需的所有数据都不允许作为外部数据。你可以下载所有的数据,但我们不需要这样做,因为我们将使用一个可以连接到数据的 Kaggle 内核。
  • **内核:**你和其他竞争对手以前做过的工作。在我看来,这是竞赛最有价值的资源。您可以通读其他脚本和笔记本,然后复制代码(称为“分叉”)进行编辑和运行。
  • **讨论:**另一个有用的资源,你可以在这里找到来自竞赛主持人和其他参赛者的对话。这是一个提问和学习他人答案的好地方。
  • **排行榜:**谁在榜首,你站在哪里
  • **规则:**不是很有趣,但是很好理解
  • 如果你决定组建一个团队,管理你的团队成员
  • **我的作品:**查看您之前提交的作品,并选择最终参赛作品

向他人学习的重要性

虽然它们被称为竞赛,但 Kaggle 机器学习活动实际上应该被称为“合作项目”,因为主要目标不一定是获胜,而是练习和向数据科学家同事学习。一旦你意识到与其说是打败别人,不如说是拓展自己的技能,你会从比赛中获得更多。当你注册 Kaggle 时,你不仅可以获得所有的资源,还可以成为拥有数千年集体经验的数据科学家社区的一员。

通过努力成为社区的积极分子来利用这些经历吧!这意味着从共享内核到在论坛上提问的任何事情。虽然公开你的工作可能会令人生畏,但我们通过犯错误、接受反馈和改进来学习,这样我们就不会再犯同样的错误。每个人都是初学者,社区非常支持所有技能水平的数据科学家。

在这种心态下,我想强调的是,与他人讨论并基于他人的代码进行构建不仅是可以接受的,而且是受到鼓励的!在学校,与他人合作被称为作弊,会让你得零分,但在现实世界中,这被称为合作,是一项极其重要的技能。

让你自己投入到比赛中的一个很好的方法是找到一个有人分享了一个很好的排行榜分数的内核,分叉这个内核,编辑它以尝试提高分数,然后运行它以查看结果。然后,将内核公开,这样其他人就可以使用你的工作。数据科学家不是站在巨人的肩膀上,而是站在成千上万为了所有人的利益而公开其工作的个人的背上。(抱歉说得太哲学了,但这就是我热爱数据科学的原因!)

通过第一个笔记本工作

一旦你对 Kaggle 的工作方式和如何在比赛中获得最大收益的哲学有了基本的了解,是时候开始了。在这里,我将简要概述我在一个内核中为家庭信用违约风险问题整理的一个 Python Jupyter 笔记本,但是为了获得充分的好处,你会想要把这个笔记本放到 Kaggle 上并自己运行它(你不需要下载或设置任何东西,所以我强烈建议你去看看)。

当您在内核中打开笔记本时,您会看到这样的环境:

Kernel Notebook Environment

把这当成一个标准的 Jupyter 笔记本,审美略有不同。你可以像在 Jupyter 中一样编写 Python 代码和文本(使用 Markdown 语法),并在 Kaggle 的服务器上完全在云端运行代码。然而,Kaggle 内核有一些 Jupyter Notebook 中没有的独特功能。点击右上角向左的箭头,展开内核控制面板,弹出三个选项卡(如果笔记本不是全屏的,那么这三个选项卡可能已经在代码旁边可见)。

在 data 选项卡中,我们可以查看内核所连接的数据集。在这种情况下,我们有完整的比赛数据,但我们也可以连接到 Kaggle 上的任何其他数据集,或者上传我们自己的数据并在内核中访问它。数据文件位于代码内的../input/目录中:

import os# List data files that are connected to the kernel
os.listdir('../input/')

Files connected to the kernel available in ../input/

设置选项卡让我们控制内核的不同技术方面。在这里,我们可以将 GPU 添加到我们的会话中,更改可见性,并安装环境中还没有的任何 Python 包。

最后,Versions 选项卡让我们看到代码的任何以前提交的运行。我们可以查看代码的变更,查看运行的日志文件,查看运行生成的笔记本,以及下载运行输出的文件。

Versions Tab

要运行整个笔记本并记录一个新版本,点击内核右上角的蓝色 Commit & Run 按钮。这将执行所有代码,向我们显示完整的笔记本(或者任何错误,如果有错误的话),并保存运行期间创建的任何文件。当我们提交笔记本时,我们可以访问我们的模型做出的任何预测,并提交它们进行评分。

介绍性笔记本大纲

第一个笔记本是为了让你熟悉这个问题。我们以与任何数据科学问题相同的方式开始:理解数据和任务。对于这个问题,有 1 个主训练数据文件(包括标签)、1 个主测试数据文件和 6 个附加数据文件。在这第一个笔记本中,我们只使用主要数据,这将使我们得到一个体面的分数,但后来的工作将不得不纳入所有的数据,以便具有竞争力。

为了理解数据,最好离开键盘几分钟,通读问题文档,例如每个数据文件的列描述。因为有多个文件,我们需要知道它们是如何链接在一起的,尽管对于第一个笔记本,为了简单起见,我们只使用主文件。通读其他内核也可以帮助我们熟悉数据以及哪些变量是重要的。

一旦我们理解了数据和问题,我们就可以开始为机器学习任务构建数据,这意味着处理分类变量(通过一键编码),填充缺失值(插补),并将变量缩放到一个范围。我们可以进行探索性的数据分析,比如找到与标签的相关性,并绘制这些关系。

Correlation Heatmap of Variables

我们可以在以后使用这些关系进行建模决策,例如包括使用哪些变量。(实现见笔记本)。

Distribution of Ages Colored by Label (left) and Rates of Default by Age Group (right)

当然,没有我最喜欢的图,即对图,任何探索性的数据分析都是不完整的。

Pairs Plot of Features (red indicates loans that were not repaid in the kde and scatter plots)

在彻底探索数据并确保它可以被机器学习接受后,我们继续创建基线模型。然而,在我们进入建模阶段之前,我们必须了解竞争对手的性能指标。在 Kaggle 竞赛中,一切都归结为一个数字,即测试数据的度量。

虽然使用二进制分类任务的准确性可能有直观的意义,这是一个糟糕的选择,因为我们正在处理一个不平衡的类问题。根据 ROC AUC 或曲线下的受试者操作特征曲线面积来判断提交的数据,而不是准确性。我让你对这一个研究,或者看笔记本上的解释。只知道越高越好,随机模型 0.5 分,完美模型 1.0 分。为了计算 ROC AUC,我们需要根据概率而不是二进制 0 或 1 进行预测。ROC 随后将真阳性率与假阳性率显示为阈值的函数,根据该阈值我们将实例分类为阳性。

通常我们喜欢做一个天真的基线预测,但是在这种情况下,我们已经知道随机猜测任务将得到 0.5 的 ROC AUC。因此,对于我们的基线模型,我们将使用稍微复杂一点的方法,逻辑回归。对于二元分类问题,这是一个流行的简单算法,它将为未来的模型设置一个较低的标准。

在实现逻辑回归之后,我们可以将结果保存到 csv 文件中以供提交。提交笔记本后,我们写入的任何结果都将显示在“版本”选项卡上的“输出”子选项卡中:

Output from running the complete notebook

在此选项卡中,我们可以将提交的内容下载到我们的计算机上,然后上传到竞赛中。在本笔记本中,我们制作了四种不同的模型,得分如下:

  • 逻辑回归:0.671
  • 随机森林:0.678
  • 具有构造特征的随机森林:0.678
  • 光梯度推进机:0.729

这些分数并没有让我们接近排行榜的顶端,但它们为未来的改进留下了足够的空间!我们还可以了解仅使用单一数据源时的预期性能。

(不出意外,非凡的渐变助推机(使用 LightGBM 库)表现最好。这个模型赢得了几乎所有的结构化 Kaggle 竞赛(其中数据是表格格式的),如果我们想要认真竞争,我们可能需要使用这种模型的某种形式!)

结论

这篇文章和介绍性内核演示了 Kaggle 竞赛的基本开始。它并不意味着获胜,而是向您展示如何进行机器学习竞赛的基本知识,以及一些让您起步的模型(尽管 LightGBM 模型就像是从深水区跳下来)。

此外,我为机器学习竞赛阐述了我的哲学,即通过参与讨论、基于他人的代码构建和分享自己的工作来尽可能多地学习。刷新你过去的成绩是令人愉快的,但我认为做得好不是主要的焦点,而是学习新的数据科学技术的积极副作用。虽然这些被称为竞赛,但它们是真正的合作项目,欢迎每个人参与并磨练他们的能力。

还有大量的工作要做,但谢天谢地,我们不必独自去做。在后面的文章和笔记中,我们将看到如何在其他人的工作基础上构建更好的模型。我希望这篇文章(以及笔记本内核)给了你信心,让你可以开始在 Kaggle 上竞争,或者接手任何数据科学项目。

一如既往,我欢迎建设性的批评和讨论,可以通过 Twitter @koehrsen_will 联系。

机器学习竞赛:第三部分优化

原文:https://towardsdatascience.com/machine-learning-kaggle-competition-part-three-optimization-db04ea415507?source=collection_archive---------9-----------------------

充分利用机器学习模型

如何最好地描述一场 Kaggle 比赛?是伪装成比赛的机器学习教育!尽管有对 Kaggle有效的批评,但总体而言,这是一个伟大的社区,提供了有趣的问题,数千名数据科学家愿意分享他们的知识,以及探索新想法的理想环境。作为证据,如果不是因为 Kaggle 家庭信贷竞赛,我永远也不会知道梯度推进机器,或者,这篇文章的主题之一,自动化模型优化。

在本文中,系列文章的第三部分(第一部分:入门第二部分:改进)记录我为这次竞赛所做的工作,我们将关注机器学习管道的一个关键方面:通过超参数调整进行模型优化。在第二篇文章中,我们决定选择梯度推进机作为我们的模型,现在我们必须通过优化来充分利用它。我们将主要通过两种方法来实现这一点:随机搜索和使用贝叶斯优化的自动调优。

这里介绍的所有工作都可以在 Kaggle 上运行。文章本身将突出关键思想,但代码细节都在笔记本中(无需安装即可免费运行!)

  1. 随机和网格搜索
  2. 自动超参数调整
  3. 调谐结果

对于这篇文章,我们将跳过背景,所以如果你在任何时候感到迷茫,我鼓励你去以前的文章和笔记本。所有的笔记本都可以在 Kaggle 上运行,而不需要下载任何东西,所以我强烈推荐你去看看它们或者参加比赛!

概述

在本系列的第部分,我们熟悉了数据集,执行了探索性数据分析,尝试了功能工程,并构建了一些基线模型。我们这一轮的公开排行榜得分是 0.678 (目前我们在排行榜上的排名低于 4000)。

第二部分涉及深入的手工特征工程,接着是特征选择和更多建模。使用扩展(然后收缩)的功能集,我们最终得到了 0.779 的分数**,比基线有了很大的提高,但还不到竞争对手的前 50%。在这篇文章中,我们将再次提高我们的分数,并在排行榜上上升 1000 位。**

机器学习优化

机器学习环境中的优化意味着找到一组模型超参数值,该组模型超参数值对于给定的数据集产生最高的交叉验证分数。与在训练期间学习的模型参数相反,模型超参数由数据科学家在训练之前设置。深度神经网络中的层数是模型超参数,而决策树中的分裂是模型参数。我喜欢把模型超参数看作是我们需要为数据集调整的设置:对于每个问题来说,理想的值组合都是不同的

A machine learning model has to be tuned like a radio — if anyone remembers what a radio was!

有几种方法可以调整机器学习模型:

  1. 手动:用直觉/经验/猜测选择超参数,用数值训练模型,寻找验证分数重复过程,直到你失去耐心或者对结果满意。
  2. 网格搜索:设置一个超参数网格,对于每个数值组合,训练一个模型,找到验证分数。在这种方法中,尝试了超参数值的每个组合,这是非常低效的!
  3. 随机搜索:设置超参数网格,选择随机数值组合,训练模型,寻找验证分数。搜索迭代的次数基于时间/资源。
  4. 自动超参数调整:使用梯度下降、贝叶斯优化或进化算法等方法引导搜索最佳超参数。与随机或网格非知情方法相比,这些方法使用先前的结果在知情搜索中选择下一个超参数值。

这些是按照效率增加的顺序排列的,手动搜索花费的时间最多(通常产生的结果最差),而自动方法最快地收敛到最佳值,尽管与机器学习中的许多主题一样,情况并不总是如此!正如这篇伟大的论文所示,随机搜索做得出奇的好(我们很快就会看到)。

(还有其他超参数调谐方法,如进化基于梯度。不断有更好的方法被开发出来,所以一定要跟上当前的最佳实践!)

在本系列的第二部分中,我们决定使用 Gradient Boosting Machine (GBM)模型,因为它在具有许多特性的结构化数据上具有卓越的性能。GBM 非常强大(但是很容易用 Python 实现),但是它有几十个超参数,这些参数会显著影响性能,必须针对问题进行优化。如果您想感到不知所措,请查看 LightGBM 库上的文档:

LightGBM Documentation

我不认为世界上有任何人能够看到所有这些并挑选出最佳的价值观!因此,我们需要实现选择超参数的四种方法之一。

对于这个问题,我甚至没有尝试手动调优,因为这是我第一次使用 GBM,也因为我不想浪费任何时间。我们将直接跳到使用贝叶斯优化的随机搜索和自动化技术。

实现网格和随机搜索

在第一本笔记本中,我们介绍了网格和随机搜索的实现,涵盖了优化问题的四个部分:

  1. ****目标函数:接受超参数并返回我们试图最小化或最大化的分数的函数
  2. ****域:我们要搜索的超参数值的集合。
  3. ****算法:选择目标函数中要评估的下一组超参数的方法。
  4. ****结果历史:包含每组超参数和目标函数的结果分数的数据结构。

这四个部分也构成了贝叶斯优化的基础,所以在这里列出它们将有助于实现。关于代码的细节,请参考笔记本,但这里我们将简要地触及每个概念。

目标函数

目标函数接受一组输入,并返回一个我们希望最大化的分数。在这种情况下,输入是模型超参数,得分是对训练数据的 5 重交叉验证 ROC AUC。伪代码中的目标函数是:

def objective(hyperparameters):
    """Returns validation score from hyperparameters"""

    model = Classifier(hyperparameters) validation_loss = cross_validation(model, training_data, 
                                       nfolds = 5) return validation_loss

超参数优化的目标是找到传递给objective函数时返回最佳值的hyperparameters。这似乎很简单,但问题是评估目标函数在时间和计算资源方面非常昂贵。我们无法尝试超参数值的每个组合,因为我们的时间有限,因此需要随机搜索和自动化方法。

领域

定义域是我们搜索的一组值。对于 GBM 的这个问题,域如下:

我们可以看到其中的两种分布,学习率是对数正态分布,叶子的数量是均匀正态分布:

****

算法

虽然我们通常不这样认为,但网格和随机搜索都是算法。在网格搜索的情况下,我们输入域,算法为有序序列中的每个超参数选择下一个值。网格搜索的惟一要求是,它对网格中的每种组合都尝试一次(且只尝试一次)。对于随机搜索,我们输入域,每次算法给我们一个超参数值的随机组合来尝试。除了随机选择下一个值之外,对随机搜索没有任何要求。

随机搜索可以按如下方式实现:

import random *# Randomly sample from dictionary of hyperparameters*
random_params = {k: random.sample(v, 1)[0] for k, v **in**          
                    param_grid.items()} **{'boosting_type': 'goss',
 'colsample_bytree': 0.8222222222222222,
 'is_unbalance': False,
 'learning_rate': 0.027778881111994384,
 'min_child_samples': 175,
 'num_leaves': 88,
 'reg_alpha': 0.8979591836734693,
 'reg_lambda': 0.6122448979591836,
 'subsample': 1.0,
 'subsample_for_bin': 220000}**

这实际上是一个非常简单的算法!

结果历史

结果历史是包含超参数组合和目标函数的结果分数的数据结构。当我们进行贝叶斯优化时,模型实际上使用过去的结果来决定下一个要评估的超参数。随机和网格搜索是不了解情况的方法,不使用过去的历史,但是我们仍然需要历史,以便我们可以找出哪个超参数工作得最好!

在这种情况下,结果历史只是一个数据框架。

贝叶斯超参数优化

使用贝叶斯优化的自动超参数调整听起来很复杂,但事实上它使用了与随机搜索相同的四个部分,唯一的区别是使用了算法**。对于这次比赛,我使用了 Hyperopt 库和 Tree Parzen Estimator (TPE)算法,并在的笔记本中做了展示。对于概念性的解释,请参考这篇文章,对于 Python 的实现,请查看笔记本或这篇文章。**

贝叶斯优化的基本概念是使用之前的评估结果来推理哪些超参数表现更好,并使用该推理来选择下一个值。因此,该方法应该花费较少的迭代次数来评估具有较差值的目标函数。理论上,贝叶斯优化比随机搜索能以更少的迭代收敛到理想值(虽然随机搜索还是能侥幸成功)!贝叶斯优化的目标是:

  1. 为了找到由性能测量的更好的超参数值
  2. 使用比网格或随机搜索更少的迭代次数进行优化

这是一个强大的方法,有望带来巨大的成果。问题是,实践中的证据表明情况是这样的吗?为了回答这个问题,我们转向最终笔记本,深入了解模型调整结果!

超参数优化结果

在实现随机搜索和贝叶斯优化的艰苦工作之后,第三个笔记本是一个有趣的和揭示性的探索结果。有超过 35 个情节,所以如果你喜欢视觉效果,那就去看看吧。

虽然我试图在 Kaggle 上完成整个比赛,但对于这些搜索,我在一台 64 GB 内存的计算机上进行了 500 次随机搜索和 400 次贝叶斯优化迭代,每次耗时约 5 天(感谢亚马逊 AWS)。所有的结果都是可用的,但是你需要一些真正的硬件来重做实验!

首先:哪种方法做得更好?下图总结了随机搜索的 501 次迭代和贝叶斯优化的 402 次迭代的结果(在数据框中称为opt):

Random Search and Bayesian Optimization ( opt) results

按最高分计算,随机搜索略胜一筹,但如果我们按平均分衡量,贝叶斯优化胜出。

**好消息是,这几乎正是我们所期望的:**随机搜索可以在一组很大的值上发生,因为它彻底探索了搜索空间,但贝叶斯优化将通过从以前的结果进行推理来“关注”最高得分的超参数值。让我们来看一个非常有启发性的图表,交叉验证分数的值与迭代次数的关系:

我们绝对没有看到随机搜索的趋势,而贝叶斯优化(再次由opt显示)在试验中有所改善。如果你能理解这个图表,那么你可以看到这两种方法的好处:随机搜索探索搜索领域,但贝叶斯优化随着时间的推移变得更好。我们还可以看到,贝叶斯优化似乎达到了一个平台,表明进一步试验的回报递减。

第二个主要问题:什么是最佳超参数值?以下是贝叶斯优化的最佳结果:

**boosting_type             gbdt
colsample_bytree      0.614938
is_unbalance              True
learning_rate        0.0126347
metric                     auc
min_child_samples          390
n_estimators              1327
num_leaves                 106
reg_alpha             0.512999
reg_lambda            0.382688
subsample             0.717756
subsample_for_bin        80000
verbose                      1
iteration                  323
score                 0.788793**

我们可以使用这些结果来建立一个模型并将预测提交给竞争对手,或者通过允许我们围绕最佳值定义一个集中的搜索空间,它们可以用于通知进一步的搜索。

超参数图

要考虑的一个有趣的方面是每个超参数的每个搜索方法尝试的值。下图显示了每种搜索方法的核密度估计(KDE)函数以及采样分布(超参数网格)。垂直虚线表示每种方法的最佳值。首先是学习率:

尽管学习率分布跨越了几个数量级,但两种方法都发现最优值在该域中相当低。通过将我们的搜索集中在这个区域,我们可以使用这个知识来通知进一步的超参数搜索。在大多数情况下,较低的学习率会提高交叉验证的性能,但代价是增加运行时间,这是我们必须做出的权衡。

让我们看看其他一些图表。对于大多数超参数,两种方法得出的最佳值相当接近,但对于colsample_bytree却不是这样:

这是指在 GBM 中构建每个树时使用的列的分数,随机搜索发现最优值高于贝叶斯优化。同样,这些结果可以用于进一步的搜索,因为我们看到贝叶斯方法倾向于集中在 0.65 左右的值。

我们将展示该分析中的另外两个图,因为它们相当有趣,涉及两个正则化参数:

****

这里值得注意的是,这两个超参数似乎是相互补充的:如果一个正则化值高,那么我们希望另一个正则化值低,反之亦然。也许这有助于模型在偏差/方差之间取得平衡,这是机器学习中最常见的问题。

超参数与迭代

虽然随机搜索不会改变值在搜索中的分布,但贝叶斯优化会改变,因为它会专注于搜索域中它认为最佳的值。我们可以通过绘制迭代的超参数值来看到这一点:

****

趋势最明显的超参数是colsample_bytreelearning_rate,这两个参数在试验中持续下降。reg_lambdareg_alpha正在背离,这证实了我们之前的假设,即我们应该减少其中一个,同时增加另一个。

我们要小心不要把太多的值放在这些结果中,因为贝叶斯优化可能已经找到了它正在利用的交叉验证损失的局部最小值。这里的趋势很小,但令人鼓舞的是,在接近搜索结束时发现了最佳值,表明交叉验证分数在继续提高。

超参数与交叉验证分数

接下来的这些图显示了单个超参数的值与分数的关系。我们希望避免过于强调这些图表,因为我们不会一次改变一个超参数,而且多个超参数之间可能存在复杂的相互作用。一个真正精确的图表应该是 10 维的,显示所有超参数的值和结果分数。如果我们能够理解一个 10 维的图,那么我们也许能够计算出超参数的最佳组合!****

这里随机搜索是蓝色的,贝叶斯搜索是绿色的:

****唯一明显的区别是分数随着学习率的增加而降低。我们不能说这是由于学习率本身,还是其他因素(我们将很快研究学习率和估计数之间的相互作用)。

这里没有任何强劲的趋势。由于boosting_type = 'goss'不能使用subsample(必须设置为等于 1.0),所以相对于子样本的分数有点偏差。虽然我们不能一次查看所有 10 个超参数,但如果我们转向 3D 图,我们可以一次查看两个!

三维绘图

为了尝试和检验超参数的同时效应,我们可以用 2 个超参数和分数制作 3D 图。真正精确的图应该是 10 维的(每个超参数一个),但在这种情况下,我们将坚持 3 维。(详见代码,Python 中的 3D 绘图非常简单)。首先,我们可以显示reg_alphareg_lambda,正则化超参数与分数的关系(针对贝叶斯选择):

这有点难以理解,但如果我们记得最好的分数出现在reg_alpha的 0.5 分和reg_lambda的 0.4 分左右,我们可以看到该地区的分数普遍较高。

接下来是learning_raten_estimators(集合中训练的决策树数量)。虽然学习率是网格中的一个超参数,但决策树的数量(也称为推进轮数)是通过 5 重交叉验证的早期停止来发现的:

这一次有一个明显的趋势:较低的学习率和较高的估计数会增加分数。这种关系是预期的,因为较低的学习率意味着每棵树的贡献减少,这需要训练更多的树。扩展的树数量增加了模型适应训练数据的能力(同时也增加了运行时间)。此外,只要我们使用足够折叠的早期停止,我们就不必担心与更多的树过度拟合。当结果与我们的理解一致时,感觉真好(尽管当结果与我们的理解不一致时,我们可能会学到更多!)

关联热图

对于最后的图,我想显示每个超参数之间的相互关系和分数。这些图不能证明因果关系,但它们可以告诉我们哪些变量是相关的:

Correlation Heatmap for Bayesian Optimization

我们已经从图表中找到了大部分信息,但是我们可以看到学习率和分数之间的负相关,以及估计数和分数之间的正相关

测试最佳超参数

探索的最后一步是在一个完整的数据集上实现随机搜索最佳超参数和贝叶斯优化最佳超参数(数据集来自这个内核,我要感谢作者将其公之于众)。我们训练模型,在测试集上进行预测,最后上传到比赛中,看看我们在公共排行榜上的表现如何。努力了这么久,成绩还撑得住吗?

  • 随机搜索结果得分 0.790
  • 贝叶斯优化结果得分 0.791

**如果我们按照公共排行榜上的最佳分数,贝叶斯优化胜出!然而,公共排行榜仅基于 10%的测试数据,因此这可能是过度拟合测试数据的特定子集的结果。**总的来说,我认为完整的结果——包括交叉验证和公共排行榜——表明当运行足够多的迭代时,两种方法产生相似的结果。我们可以确定的是,这两种方法都比手动调优!与我们之前的工作相比,我们最终的模型足以让我们在排行榜上上升 1000 位。

最后,以另一个图结束,我们可以看看来自训练过的 GBM 的特征重要性:

NEW_CREDIT_TO_ANNUITY_RATIONEW_EXT_SOURCES_MEAN是 Kaggle 上的数据科学社区导出的特征,而不是原始数据中的特征。看到这些重要性如此之高令人欣慰,因为它显示了特性工程的价值。

结论和后续步骤

这项工作的主要收获是:

  • 使用贝叶斯优化的随机搜索和自动超参数调整是模型调整的有效方法
  • 贝叶斯优化倾向于“集中”在更高的得分值上,而随机搜索更好地探索可能性
  • 当给定足够的迭代次数时,两种方法在交叉验证和测试分数方面产生相似的结果
  • 优化超参数对性能有显著影响,可与特征工程相比拟

从这里去哪里?嗯,总有很多其他方法可以尝试,比如自动化特征工程或者将问题作为时间序列来处理。我已经写了一本关于自动化特征工程的笔记本,所以这可能是我下一步的重点。我们还可以尝试其他模型,甚至进入深度学习领域!

我乐于接受建议,所以请在 Kaggle 或 Twitter 上告诉我。感谢阅读,如果你想看看我在这个问题上的其他作品,这里有一整套笔记本:

那里应该有足够的内容让任何人忙碌一会儿。现在可以开始为下一篇文章做更多的学习/探索了!数据科学最棒的地方在于,你一直在移动,寻找下一个需要征服的技术。每当我发现那是什么,我一定会分享它!

一如既往,我欢迎反馈和建设性的批评。我可以在 Twitter @koehrsen_will 上找到。

机器学习卡格竞赛第二部分:提高

原文:https://towardsdatascience.com/machine-learning-kaggle-competition-part-two-improving-e5b4d61ab4b8?source=collection_archive---------0-----------------------

特征工程、特征选择和模型评估

像生活中的大多数问题一样,有几种潜在的方法来进行 Kaggle 竞赛:

  1. 把自己锁起来,远离外面的世界,孤立地工作

我建议不要走“孤独的天才”之路,不仅因为它非常孤独,还因为你会错过竞争中最重要的部分:向其他数据科学家学习的 T2。如果你独自工作,你最终会依赖同样的老方法,而世界上的其他人会采用更有效和准确的技术。

作为一个具体的例子,我最近依赖于随机森林模型,自动将其应用于任何监督的机器学习任务。这场比赛终于让我意识到,虽然随机森林是一个体面的起步模式,但其他人都已经转移到更高级的渐变助推机

另一种极端的方法也有局限性:

2.复制一个领导者的脚本(在 Kaggle 上被称为“内核”),运行它,无需编写一行代码就能冲上排行榜

我也不推荐“复制粘贴”的方法,不是因为我反对使用别人的代码(有适当的归属),而是因为你仍然在限制你学习的机会。相反,我推荐的是一种混合方法:阅读他人所做的工作,理解甚至使用他们的代码,用你自己的想法建立在他人的工作之上。然后,向公众发布您的代码,这样其他人也可以做同样的过程,扩大社区的集体知识。

在这个关于参加 Kaggle 机器学习竞赛的系列的第二部分中,我们将对我们在第一部分中开发的初始提交进行改进。

本文记录的主要结果是:

  • ROC AUC 从基线 0.678 增加至 0.779
  • 在排行榜上获得超过 1000 个名次
  • 功能工程从 122 个功能增加到 1465 个
  • 特征选择将最终特征数量减少到 342 个
  • 决定使用梯度推进机器学习模型

我们将介绍我们是如何实现这些结果的——涵盖机器学习中的许多主要思想,并在适用的情况下建立在他人的代码上。我们将关注任何机器学习项目的三个关键步骤:

  1. 特色工程
  2. 功能选择
  3. 车型评测

为了从这篇文章中获得最大的收获,你会想要关注 Kaggle 上的 Python 笔记(当它们出现时会链接到)。这些笔记本可以在 Kaggle 上运行,无需在您的计算机上下载任何内容,因此几乎没有准入门槛!在这篇文章中,我将在较高的层次上触及要点,并在笔记本中提供完整的细节。

简要概述

如果你是新手,我强烈推荐你从这篇文章这款笔记本开始了解。

Kaggle 上的房屋信用违约风险竞赛是一个标准的机器学习分类问题。给定一个历史贷款数据集,以及客户的社会经济和财务信息,我们的任务是建立一个模型,可以预测客户拖欠贷款的概率。

在本系列的第一部分,我们研究了问题的基础,探索了数据,尝试了一些特性工程,并建立了一个基线模型。使用随机森林和七个数据表中的一个,我们在公共排行榜上得到了一个 0.678 ROC AUC ( 曲线下的接收器操作特征面积)。(公共排行榜仅根据 20%的测试数据计算得出,最终排名通常会发生显著变化。)

为了提高我们的分数,在这篇文章和一系列关于 Kaggle 的附带笔记本中,我们将主要关注特征工程,然后关注特征选择。一般来说,相对于在机器学习问题上投入的时间而言,最大的收益将出现在特征工程阶段。在我们开始尝试构建一个更好的模型之前,我们需要专注于以最有效的方式使用所有的数据!

关于机器学习现状的说明

这篇文章的大部分内容看起来是探索性的(或者甚至是武断的),我并不声称我已经做出了最好的决定!在机器学习中有很多旋钮需要调整,通常唯一的方法是尝试不同的组合,直到我们找到最有效的组合。机器学习更多的是经验性的,而不是理论性的,它依赖于测试,而不是从基本原则或一套硬性规则出发。

在一篇很棒的博文中,皮特·沃顿解释说,机器学习有点像敲打电视机的侧面,直到它工作为止。这是完全可以接受的,只要我们写下我们在电视上做的准确的“爆炸”和每次的结果。然后,我们可以分析我们做出的选择,寻找任何影响未来决策的模式,并找到哪种方法最有效。

我这个系列的目标是让其他人参与到机器学习中来,将我的方法放在那里以获得反馈,并记录我的工作,以便我下次可以记得我做了什么!任何评论或问题,无论是在这里还是在 Kaggle 上,都非常感谢。

特征工程

特征工程是从现有数据中创建新特征的过程。目标是构建有用的特征,帮助我们的模型了解数据集中的信息和给定目标之间的关系。在许多情况下——包括这个问题——数据分布在多个表中。因为机器学习模型必须用单个表来训练,所以特征工程要求我们在一个表中总结所有的数据。

本次比赛共有 7 个数据文件。在第一部分中,我们只使用了单一数据源,即包含每个客户的社会经济信息和贷款申请特征的主文件。我们将这个表称为app。(对于看惯了熊猫的人来说,一张桌子只是一个dataframe)。

Main training dataframe

我们可以看出这是训练数据,因为它包含标签TARGET。值为 1 的TARGET表示未偿还的贷款。

app数据框架是整齐的结构化数据:每个观察值都有一行——客户的贷款申请——列包含特征(也称为解释变量或预测变量)。每个客户端的应用程序(我们称之为“客户端”)在这个数据帧中都有一行,由SK_ID_CURR标识。因为每个客户端在此数据帧中都有一个唯一的行,所以它是数据集中所有其他表的父级,如下图所示,图中显示了这些表之间的关系:

Relationship of data files (Source)

当我们制作特征时,我们希望将它们添加到这个主数据框架中。在特征工程结束时,每个客户端仍然只有一行,但是有更多的列从其他数据表中获取信息。

其他六个表格包含了客户以前的贷款信息,既有家庭信贷(举办竞赛的机构),也有其他信贷机构。例如,这里是bureau数据框架,包含客户以前在其他金融机构的贷款:

bureau dataframe, a child of app

该数据帧是 app表:对于父表中的每个客户端(由SK_ID_CURR标识),子表中可能有许多观察值。这些行对应于单个客户的多项先前贷款。bureau数据框又是bureau_balance数据框的父数据框,在那里我们有以前每笔贷款的每月信息。

让我们来看一个从子数据帧创建新特性的例子:每个客户在其他机构的先前贷款数量的计数。尽管我写了一篇关于自动化特征工程的文章,但是在这篇文章中,我们将坚持手工操作。第一本 Kaggle 笔记本要看的 就在这里;是一本全面指导 特征工程的手册。

计算这一特性需要按照客户端 id 对bureau数据帧进行分组(使用groupby),计算一个聚合统计(使用aggcount),然后将结果表与主数据帧合并(使用merge)。这意味着,对于每个客户,我们收集他们以前的所有贷款,并计算总数。这是用 Python 写的:

app dataframe with new feature in second column

现在,我们的模型可以使用以前贷款数量的信息作为客户是否会偿还贷款的预测因素。为了检查这个新变量,我们可以制作一个内核密度估计(kde)图。这显示了单个变量的分布,可以认为是一个平滑的直方图。为了查看这个特性的分布是否根据客户是否偿还了贷款而变化,我们可以用TARGET的值来给 kde 着色:

虽然TARGET==1分布的峰值稍微在TARGET==0分布的左侧,但是在分布上似乎没有太大的差异。这可能表明,没有偿还贷款的客户以前在其他机构的贷款较少。基于我极其有限的领域知识,这种关系是有意义的!

一般来说,我们不知道一个特性在一个模型中是否有用,直到我们构建并测试这个模型。因此,我们的方法是构建尽可能多的特性,然后只保留那些最相关的特性。“最相关”没有严格的定义,但在“特性选择”部分,我们会看到一些衡量方法。

现在,让我们看看如何从app数据帧的子数据帧获取信息,而不是从app数据帧的子数据帧获取信息!bureau_balance数据帧包含关于每笔先前贷款的每月信息。这是bureau数据框架的一个子框架,因此要将该信息放入主数据框架,我们必须进行两次分组和聚合:首先通过贷款 id ( SK_ID_BUREAU),然后通过客户 id。

例如,如果我们想为每个客户计算在bureau_balance数据框架中每笔先前贷款的MONTHS_BALANCE最大数量的平均值,我们可以这样做:

app dataframe with new feature in second column

Distribution of new feature

对于单个特性来说,这是一个很大的代码量,你可以很容易地想象,在几个特性之后,手工的特性工程过程会变得很乏味!这就是为什么我们要编写这样的函数,它采取这些单独的步骤,并在每个数据帧上重复这些步骤。

我们不是一遍又一遍地重复代码,而是将它放入一个名为重构的函数中,然后每当我们想要执行相同的操作时就调用这个函数。编写函数可以节省我们的时间,并允许更具重复性的工作流,因为它每次都会以完全相同的方式执行相同的操作。

下面是一个基于上述步骤的函数,可以在任何子数据帧上使用该函数来计算数字列的聚合统计信息。它首先通过一个分组变量(比如客户机 id)对列进行分组,计算每一列的mean, max, min, sum ,重命名这些列,并返回结果 dataframe。然后,我们可以将这个数据帧与主app数据合并。

(这个函数在很大程度上借鉴了 Kaggle 上 olivier这个内核)。

(这个函数的一半代码行是文档。编写正确的 docstrings 不仅对其他人理解我们的代码至关重要,而且当我们回头看自己的代码时也能理解它!)

要查看这一过程,请参考笔记本,但是我们可以清楚地看到这将节省我们大量的工作,尤其是要处理 6 个子数据帧。

这个函数处理数值变量,但是仍然留下分类变量。分类变量通常表示为字符串,只能取有限数量的值(与连续变量相反,连续变量可以是任何数值)。机器学习模型无法处理string数据类型,所以我们必须找到一种方法,以numeric的形式捕捉这些变量中的信息。

作为分类变量的一个例子,bureau表中有一个名为CREDIT_ACTIVE的列,它记录了以前每笔贷款的状态:

Two columns of the bureau dataframe showing a categorical variable (CREDIT_ACTIVE)

我们可以通过计算每个客户拥有的每种类型贷款的数量来用数字形式表示这些数据。此外,我们可以通过将某一特定贷款类型的计数除以总计数来计算每种贷款类型的标准化计数。我们以此结束:

Categorical CREDIT_ACTIVE features after processing

现在,这些分类特征可以传递到机器学习模型中。这个想法是,我们不仅要获取每种贷款的数量,还要获取这种贷款的相对频率。像以前一样,我们实际上不知道这些新功能是否有用,唯一确定的方法是制作这些功能,然后在模型中测试它们!

我们可以再次编写一个函数来为我们计算分类变量的计数,而不是为每个子数据帧手动执行此操作。最初,我开发了一个非常复杂的方法来完成这项工作,包括数据透视表和各种聚合,但后来我看到其他代码中有人使用 one-hot 编码在大约两行代码中完成了同样的事情。我立即放弃了我的工作时间,转而使用这个版本的功能!

该功能再次为我们节省了大量时间,并允许我们对每个数据帧应用完全相同的步骤。

一旦我们编写了这两个函数,我们就可以使用它们将七个独立文件中的所有数据提取到一个单独的训练(和一个测试数据帧)中。如果你想看到这个实现,你可以看看第一第二手动工程笔记本。以下是最终数据的示例:

使用所有七个表中的信息,我们最终得到总共 1465 个特征!(摘自某原 122)。

我们如何知道这些特性是否有帮助呢?一种方法是计算变量与TARGET之间的皮尔逊相关系数。这是一个相对粗略的重要性衡量标准,但它可以作为与客户还贷能力相关的变量的近似值。以下是与TARGET最相关的变量:

Most Positive (left) and Negative (right) correlated variables with the TARGET

EXT_SOURCE_变量来自原始特征,但是我们创建的一些变量是最相关的。然而,我们希望避免过度解读这些数字。每当我们制作大量特征时,我们都会遇到多重比较问题:我们做的比较越多——在这种情况下是与目标的相关性——它们中的一些就越有可能由于随机噪声而变大。由于相关性如此之小,我们在解读数字时需要特别小心。

我们制作的最负相关变量client_bureau_balance_counts_mean,代表每个客户在bureau_balance数据中出现贷款次数的平均值。换句话说,它是每个客户以前每笔贷款的平均月记录数。kde 图如下:

现在我们有了 1465 个特性,我们遇到了特性太多的问题!更危险的是,这被称为维度的诅咒,它通过特征选择的关键步骤来解决。

特征选择

太多的特征会降低训练速度,降低模型的可解释性,最重要的是,会降低模型在测试集上的泛化性能。当我们有不相关的特征时,这些特征淹没了重要的变量,并且随着特征数量的增加,模型学习数据和目标之间的关系所需的数据点的数量呈指数增长(维度诅咒解释)。

在完成了制作这些特征的所有工作之后,我们现在必须只选择那些“最重要”的,或者说,丢弃那些不相关的。

下一个要浏览的笔记本 在这里:功能选择指南 n 它相当全面,尽管它仍然没有涵盖所有可能的方法!

有许多方法可以减少功能的数量,这里我们将介绍三种方法:

  1. 移除共线变量
  2. 删除有许多缺失值的变量
  3. 使用特性重要性只保留“重要的”变量

移除共线变量

共线变量是彼此高度相关的变量。这些变量是多余的,因为我们只需要保留每对共线要素中的一个,就可以保留两个要素中的大部分信息。高度相关的定义可以变化,这是另一个没有固定规则的数字!作为共线变量的一个例子,以下是中值公寓面积与平均公寓面积的关系图:

为了识别高度相关的变量,我们可以计算数据中每个变量与其他变量的相关性(这是一个计算量相当大的过程)!然后,我们选择相关矩阵的上部三角形,并基于阈值从每对高度相关的变量中移除一个变量。这在下面的代码中实现:

(这段代码改编自这篇博文。)

在这个实现中,我使用 0.9 的相关系数阈值来删除共线变量。因此,对于相关性大于 0.9 的每对特征,我们移除该对特征中的一个。**在总共 1465 个特征中,这移除了 583 个,**表明我们创建的许多变量是多余的。

删除缺少的列

在所有的特征选择方法中,这似乎是最简单的:只需消除任何超过一定百分比的缺失值的列。然而,即使这个操作也会带来另一个选择,即删除一列的缺失值的阈值百分比。

此外,一些模型,如 LightGBM 中的梯度增强机器,可以处理缺失值而无需插补,然后我们可能根本不想删除任何列!但是,因为我们最终将测试几个需要估算缺失值的模型,所以我们将删除定型集或测试集中缺失值超过 75%的任何列。

这个阈值不是基于任何理论或经验法则,而是基于尝试几种选择,看哪种在实践中效果最好。做这些选择时要记住的最重要的一点是,它们不必做了一次就忘记了。如果模型的表现不如预期,可以在以后再次访问它们。请务必记录下您采取的步骤和性能指标,这样您就可以看到哪个效果最好!

删除缺失值超过 75%的列会从数据中删除 19 列,剩下 863 个特征。

使用特征重要性的特征选择

我们将使用的最后一种选择特征的方法是基于机器学习模型的结果。利用基于决策树的分类器,例如决策树的集合(随机森林、额外的树、梯度提升机器),我们可以提取并使用称为特征重要性的度量。

这方面的技术细节很复杂(它与在模型中包含特征减少杂质有关),但是我们可以使用相对重要性来确定哪些特征对模型最有帮助。我们还可以使用特性重要性来识别和删除对模型帮助最小的特性,包括任何重要性为 0 的特性。

为了找到特征的重要性,我们将使用来自 LightGBM 库的梯度增强机器(GBM)。使用具有两次训练迭代的早期停止来训练该模型,并且在训练运行中对特征重要性进行平均以减小方差。

在特征上运行这个识别出重要性为 0.0 的 308 个特征。

删除重要性为 0 的特征是一个非常安全的选择,因为这些特征在任何决策树中都不会用于分割节点。因此,移除这些特征不会对模型结果产生影响(至少对于这个特定的模型来说)。

这对于特性选择来说不是必须的,但是因为我们有特性的重要性,我们可以看到哪些是最相关的。为了尝试了解模型在进行预测时会考虑哪些因素,我们可以设想 15 个最重要的特征:

Top 15 most important features

我们看到我们构建的一些特性进入了前 15 名,这应该给我们一些信心,我们所有的努力都是值得的!我们的一个功能甚至进入了前五名。这个特性,client_installments_AMT_PAYMENT_min_sum表示每个客户以前在 Home Credit 贷款的最低分期付款总额。也就是说,对每个客户来说,这是他们以前每笔贷款的最低还款额的总和。

特性重要性并没有告诉我们这个变量的较低值是否对应于较低的默认率,它只是让我们知道这个特性对于进行决策树节点的分割是有用的。特性重要性是有用的,但是它们不能提供对模型的完全清晰的解释!

在移除 0 个重要特征之后,我们有 536 个特征和另一个选择要做。如果我们认为我们仍然有太多的功能,我们可以开始删除那些最不重要的功能。在这种情况下,我继续进行特性选择,因为我想测试除 gbm 之外的模型,这些模型不能很好地处理大量的特性。

我们做的最后一个特征选择步骤是只保留占 95%重要性的特征。根据梯度推进机,342 个特征足以覆盖 95%的重要性。下图显示了累积重要性与特征数量的关系。

Cumulative feature importance from the gradient boosting machine

我们还可以使用其他一些降维技术,比如主成分分析(PCA) 。该方法在减少维数方面是有效的,但是它也将特征变换到低维特征空间,在该空间中它们没有物理表示,这意味着 PCA 特征不能被解释。此外,PCA 假设数据是正态分布的,这对于人工生成的数据可能不是有效的假设。在笔记本中,我展示了如何使用 pca,但实际上并没有将它应用于数据。

然而,我们可以使用 pca 进行可视化。如果我们将前两个主成分用TARGET的值着色,我们会得到如下图像:

First two principal components of the data

这两个类别并没有完全分开,只有两个主要部分,显然我们需要两个以上的特征来识别哪些客户将偿还贷款,哪些不会。

在继续之前,我们应该记录我们采取的功能选择步骤,以便我们记住它们以供将来使用:

  1. 移除相关系数大于 0.9 的共线变量:移除 583 个特征
  2. 删除缺失值超过 75%的列:删除了 19 个特征
  3. 根据 GBM 删除 0.0 重要性特征: 308 删除特征
  4. 仅保留 95%特征重要性所需的特征: 193 个特征被删除

最终数据集有 342 个要素。

如果看起来在特性选择过程中有一些任意的选择,那是因为确实有!稍后,如果我们对自己的表现不满意,我们可能会重新考虑这些选择。幸运的是,因为我们编写了函数并记录了我们的决策,所以我们可以很容易地更改一些参数,然后重新评估性能。

型号选择

一般来说,在机器学习问题的这一点上,我们将继续评估许多模型。没有一个模型在每项任务上都比其他模型更好(T2,“没有免费的午餐定理”,T3),因此我们需要尝试一系列模型来决定使用哪一个。然而,近年来,有一个模型在处理中等规模的结构化数据问题上变得越来越成功:梯度推进机。(这个模型如此有效有很多原因,作为一个全面的指南,这篇硕士论文是一个很好的读物。)

模型选择是我非常依赖他人工作的一个领域。正如本文开头提到的,在这场比赛之前,我的首选模型是随机森林。虽然在这个比赛的早期,从阅读其他人的笔记本中可以清楚地看到,为了参加比赛,我需要实现一些版本的梯度推进机器。Kaggle 上几乎每个排行榜顶部的提交内容都使用了渐变增强机器的一些变体(或多个版本)。(您可能会看到使用的一些库是 LightGBMCatBoostXGBoost 。)

在过去的几周里,我已经通读了许多内核(参见这里的和这里的),现在对使用 LightGBM 库部署梯度增强机器非常有信心(Scikit-Learn 确实有一个 GBM,但它不如其他库那样高效或准确)。尽管如此,主要出于好奇,我想尝试其他几种方法,看看从 GBM 中获得了多少。这个测试的代码可以在 Kaggle 上的这里找到。

这并不完全是一个公平的比较,因为我在 Scikit-Learn 中主要使用默认的超参数,但是它应该给我们几个不同模型的能力的第一近似值。在应用了所有特征工程和特征选择之后,使用数据集,下面是带有公共排行榜分数的建模结果。除 LightGBM 之外的所有型号都内置于 Scikit-Learn:

  • 逻辑回归= 0.768
  • 【1000 棵树随机森林= 0.708
  • 【1000 棵多余的树= 0.725
  • sci kit 中的梯度增强机器-学习 1000 棵树= 0.761
  • light GBM 中的梯度推进机,1000 棵树= 0.779
  • 所有模型的平均值= 0.771

事实证明,其他人都是对的:梯度推进机是正确的选择。它提供了开箱即用的最佳性能,并且有许多超参数,我们可以调整它们以获得更好的分数。这并不意味着我们应该忘记其他模型,因为有时将多个模型的预测加在一起(称为集成)会比单个模型本身表现得更好。事实上,许多 Kaggle 竞赛的获胜者在他们的最终模型中使用了某种形式的组装。

我们没有在模型上花太多时间,但这是我们在接下来的笔记本和文章中要转移的重点。接下来,我们可以使用超参数优化来优化最佳模型,即梯度推进机。我们也可以将模型平均在一起,甚至将多个模型叠加起来进行预测。我们甚至可能回去重做特征工程!最重要的一点是,我们需要不断试验,找出最有效的方法,我们可以阅读其他人所做的尝试,并以他们的工作为基础。

结论

作为一名数据科学家,重要的性格特征是好奇心和承认自己并非无所不知!从我在排行榜上的位置来看,我显然不知道解决这个问题的最佳方法,但我愿意不断尝试不同的东西,并向他人学习。 Kaggle 竞赛只是玩具问题,但这并不妨碍我们用它来学习和实践概念,以应用到真实的项目中。

在本文中,我们讨论了许多重要的机器学习主题:

  1. 使用特征工程从多个相关信息表中构建新特征
  2. 应用特征选择移除不相关的特征
  3. 评估几种机器学习模型对任务的适用性

在完成所有这些工作后,我们能够将排行榜分数从 0.678 提高到 0.779,并在排行榜上上升了 1000 多位。接下来,我们的重点将转移到优化我们选择的算法,但我们也会毫不犹豫地重新审视特征工程/选择。

如果你想了解我在机器学习方面的最新进展,你可以查看我在 Kaggle 上的工作:笔记本的速度比文章快一点!请随意使用这些笔记本开始使用 Kaggle,并开始为社区做出贡献。我将利用这次 Kaggle 比赛来探索一些有趣的机器学习想法,如自动化特征工程贝叶斯超参数优化。我计划尽可能多地从这次比赛中学习,我期待着探索和分享这些新技术!

一如既往,我欢迎建设性的批评和反馈,可以通过 Twitter @koehrsen_will 联系。

机器学习的疯狂:预测每一场 NCAA 锦标赛

原文:https://towardsdatascience.com/machine-learning-madness-predicting-every-ncaa-tournament-matchup-7d9ce7d5fc6d?source=collection_archive---------8-----------------------

大舞蹈的概率模型、可视化和结果

又到了一年中的这个时候。三月疯狂来了,这意味着是时候填写你的括号了,当它不可避免地被你所有的朋友和家人看到时,你会很失望。

不过,也不全是坏消息。NCAA 级男子篮球锦标赛是本年度最激动人心的体育赛事之一,因为它伴随着冷门、灰姑娘和不可预测性。每年三月,数以百万计的篮球迷和非篮球迷都拿着他们的虚拟锐器参与这一现象,希望获得一个不可能的完美支架。有多不可能?鉴于你对篮球略知一二,教授们保守地认为你的胜算是 1280 亿分之一。

动机

感谢我的成长经历和在体育中心的成长经历,从我记事起,我就是一个狂热的大学篮球迷。每年我都期待着进行研究,有条不紊地填写一个括号。

然而,今年在收到一封关于即将到来的 Kaggle 比赛的电子邮件后,我决定第一次尝试模拟比赛,标题是:谷歌云& NCAA 机器学习比赛。如果你不熟悉 Kaggle,它被称为“数据科学&机器学习之家”。 Kaggle 举办机器学习比赛,收集有趣的数据集,并提供指南来帮助你成长为一名数据科学家。

竞争

比赛的目标是利用过去的锦标赛结果来建立和测试模型,以便预测 2018 年 NCAA 第一组男子篮球锦标赛中所有可能比赛的结果。这些结果是通过概率计算得出的,例如,A 队有 55%的机会击败 b 队。然后,我们会对每个最终提交的作品进行评估,并使用一种称为对数损失的指标在公共排行榜上进行排名。如果您不熟悉日志损失,只需知道越小越好。对数的使用为自信和错误提供了极端的惩罚,如下面的公式所示:

方法

进入这个项目,我有一个大概的想法,我想用它做什么。话虽如此,我对前几年的类似项目做了一些研究,从中我发现了一些对我有用的见解。

首先,似乎很多模型都将逻辑回归作为它们的主要算法,这是因为它的概率性质和有效而简单的实现。第二,许多模型利用了其他广受好评的排名和评分系统,如肯·波默罗伊和 T2 的杰夫·萨格林。

利用以前的领域知识,以及这些来自研究的见解,我决定对其他模型采取类似的方法,同时做一些有趣的改变。我的高级方法可以分为几个步骤:

  1. 收集旨在衡量给定团队质量的高绩效排名、分数和评级
  2. 将这些指标汇编成一个综合得分,提供可靠的能力度量
  3. 计算每场比赛中各队综合得分的差异
  4. 对综合得分差异进行训练和测试逻辑回归,以预测未来的比赛

模型分解

按照这种方法,我的模型由两个不同的部分组成。每个部分都有独特的权重,用于生成每个团队的综合得分。查看以下可视化内容,了解各种输入的概述:

这些重量是在相互测试了几个变量之后选择的。在本文的其余部分,在最终模拟今年的锦标赛结果之前,我将更详细地介绍模型的每个部分。

平均选择排名分数

我发现最有用的资源之一是一个数据集,其中包含随着时间推移的梅西综合排名。梅西排名是检查所有其他排名系统的目的地。我决定选择可用的最高性能系统,并平均计算分数。在为每个持续更新的系统拟合和测试单独的逻辑回归模型后,我发现表现最好的指标是Sagarin(SAG)Pomeroy(POM)Moore(MOR)和 Whitlock (WLK)。

在编辑了这些排名的平均分数后,我单独对这个特征进行了拟合和测试,得到了-0.543 的对数损失,这比我的基线基于种子的模型和整体平均排名实现都有所改进。

标准化 Elo 评级

如果你曾经研究过体育预测背后的方法论,你可能会遇到一两次 Elo。Nate Silver 和他的团队是 Elo 的大力支持者,所以当我在 Kaggle 上看到 Liam Kirwin 的实现后,我不得不考虑以某种方式将它融入我的模型中。

如果你不熟悉 Elo 评级系统,这是一种计算零和游戏中玩家相对技能水平的迭代方法。你可能听说过它被用于国际象棋或其他棋盘/视频游戏,但只知道应用程序是无止境的。Elo 通常使用以下公式计算:

计算每支球队的 Elo 分数需要一些时间,因为该程序必须迭代每场比赛并调整相应球队的评级。一旦计算出来,基于 Elo 的逻辑回归模型也表现得相当好,其对数损失为-0.543,与选择排名模型的先前结果持平。

模型评估

一旦之前的两个分数都被收集,它们被重新调整到介于 0 和 1 之间。然后使用上述方法对他们进行加权,并随后汇编成每个团队的最终综合得分,最终用于我们的逻辑回归模型。使用交叉验证,该模型在训练数据上获得了-0.540 的对数损失,这比其自身的任何一部分都略有改善!

为了更好地了解综合得分,请根据以下指标查看今年锦标赛中排名前十的球队:

锦标赛模拟

所有这些都是好东西,但我们真正想看到的是所有这些分数和概率如何应用于今年的数据!多亏了扎克·梅尔令人敬畏的名为 kaggleNCAA 的 R 包,这个任务相当容易完成。在用 1000 次模拟运行我的模型后,我得到了以下结果:

如你所见,从长远来看,我的模型预测最有可能的赢家是弗吉尼亚,有 16%的机会。一些有趣的选择还包括杜克大学(2)和冈萨加大学(4)作为进入四强的热门,很可能第一轮就被佛罗里达大学(9)和洛约拉-芝加哥大学(11)击败。

包扎

恭喜你能走到这一步!总的来说,我很高兴地说,承担这个项目使我成为一个更有能力的数据科学家。我也很兴奋能参加今年的比赛,最重要的是,我渴望为明年调整和改进我的模型!

代码及完整 Jupyter 笔记本见我的 Github

感谢阅读,并祝所有参加今年三月疯狂的有抱负的支架学家好运!

感谢阅读!如果你喜欢这篇文章,请继续向鼓掌按钮展示你的爱。对更多的帖子感兴趣吗?请务必关注我并订阅下面的我的简讯以接收任何新内容。想了解更多关于我和我在做什么,请查看我的网站。

机器学习,遇见海洋

原文:https://towardsdatascience.com/machine-learning-meet-the-ocean-e1b957e4dc61?source=collection_archive---------1-----------------------

Lubec, ME — the easternmost town in the US. This photo was a winner of NOAA’s 2015 World Ocean Day contest.

马萨诸塞州的梅德福德今天气温 20 度,当我过河时,昨天的雪正刮过马路。我飞过整个国家,和一小群工程师、渔业科学家以及以晚餐和能量饮料的承诺招募的朋友们聚集在一个小小的地下室办公室里。在接下来的五个小时里,我们将观看新英格兰的渔民从亮橙色的塑料袋子里捞出鱼,把它们放在一个测量条上,然后迅速把手拿开,让它们越过船的一侧。当我们扫描数字镜头时,我们标记鱼出现的时间,记录鱼的种类,并在屏幕上通过从嘴到尾巴画一条线来测量。这就像一个缓慢,细致的水果忍者游戏。

所有这些工作和小吃都是为了准备我们计划在今年夏天举办的训练计算机识别鱼类的比赛。我们正在努力实现这样一个未来,即可以实时监控渔民捕获的东西和他们释放的东西,让渔民和管理者以及任何想要跟踪海洋捕捞量的人更容易、更实惠地做到这一点。这是高科技、复杂的计算机科学和世界上最古老的职业之一的结合。

Today’s wheelhouse has multiple screens to let you track your catch. Or your dog. Photo ©Heather Perry

这是即将到来的保护革命,是认识和理解我们周围世界的革命。自然界充满了不可思议且往往难以观察到的现象。研究雨林的科学家过去常常在野外露营几天,希望观察到罕见的美洲豹,但现在他们可以设置相机不断记录,并在世界任何地方从他们的笔记本电脑上查看这些镜头。保护技术的进步正在产生比以往更多的数据,关于什么生活在哪里,谁吃谁,什么正在消失以及消失的速度,但仍然需要人类时间来观看视频片段。我们需要将新的传感器系统与分析工具结合起来,让我们能够将数据转化为信息和知识。

这是大型盈利性公司擅长解决的问题,人们也乐于为之开发工具,因为解决一个大公司的问题可以让你获得一大笔公司薪水。如果你能成为一名亿万富翁,编写一个算法来处理银行数据,你会花部分时间调整同样的算法来模拟鱼类种群吗?数据竞赛的世界表明,对一些人来说,答案是。我们的地下室小组给了我希望,越来越多的工程师、数据科学家、UX 设计师和其他好奇的创新者被不寻常的挑战性问题所吸引,他们的解决方案以超越利润的影响来衡量。

这里涉及到利润。在许多沿海小社区,捕鱼是最大的生意。在美国,咸水捕鱼——包括商业捕鱼和体育捕鱼——是一项价值 3000 亿美元的产业,提供了 180 万个工作岗位。越来越多的人想知道他们的海鲜来自哪里,他们不是在吃海里的最后一条鱼。这意味着准确计算鱼的数量变得更加重要,一些渔民急切地采用新技术来证明他们的生意是多么可持续。他们的目标是最大限度地增加渔业收入,同时在海洋中留下足够的鱼来繁殖新的鱼供明年捕捞。有了更有效的电子工具,渔民就可以更容易地跟踪渔获,管理人员也可以更容易地监控对鱼类种群的整体影响。我们的项目得到了国家鱼类和野生动物基金会的资助,但是我们 20 万美元的预算仅仅相当于一个硅谷软件工程师的年薪。因此,我们的团队包括那些愿意以很低的折扣工作的人,为了解决复杂问题的刺激,为了一些美味的猪肉。

人们似乎对为鱼创建算法感到兴奋的一个原因是,捕鱼给计算机带来了一系列新的挑战。船甲板或水下的光线不足会扭曲颜色,模糊鱼的边缘。在明亮的阳光下,闪闪发光的鱼的眩光对数码相机来说是没有数据的。如果鱼在网里或滑槽里游来游去,你必须很聪明,确保你能区分不同的鱼,而不是重复计算。即使在最好的条件下,有些鱼也很难区分。本周六早上,一个我们称之为“鱼老板”的人加入了我们,他是一名渔业科学家,也是一名多年的观察员,在渔民将鱼拖上船时,他骑着马一起去捕鱼,数着鱼的数量。我们弓着腰在屏幕上一帧一帧地移动,给视频中的鱼做注解,偶尔会叫鱼老板过来,以确保我们没有把一条比目鱼和另一条弄混。

Matching verified Fish IDs to footage.

如果我们成功了,不仅在新英格兰,而且在整个美国和全世界,渔民和管理人员都可以更容易地计算鱼的数量。我们将我们的产品设计成开源的,以使其他渔场更有可能采用和实施我们帮助开发的产品。其中一些工具,如视频注释软件,非常简单,任何人都可以使用,为日益发展的公民科学运动做出了贡献。是时候将物联网带到外面,利用我们不断增长的技术能力来支持我们周围的自然世界,以及它所支持的商业和生活质量。

机器学习遇上时尚

原文:https://towardsdatascience.com/machine-learning-meets-fashion-48ee8f6541ad?source=collection_archive---------3-----------------------

在《人工智能历险记》的这一集中,我们将尝试把整个机器学习工作流程整合成一个流程,从我们之前的剧集中汲取最佳实践。这是一个很大的材料,但我认为我们可以做到这一点!

MNIST 数据集训练一个模型通常被认为是机器学习的“Hello world”。这已经做过很多次了,但不幸的是,仅仅因为一个模型在 MNIST 上表现良好,并不一定意味着它在其他数据集上的高性能预测,尤其是因为我们今天拥有的大多数图像数据都比手写数字复杂得多。

时髦的机器学习

Zalando 决定是时候让 MNIST 再次流行起来,最近发布了一个名为fashion-mnist的数据集。这是与“常规”MNIST 完全相同的格式,除了数据是以各种服装类型、鞋子和包包的图片的形式。它仍然跨越 10 个类别,图像仍然是 28×28 像素。

让我们训练一个模型来检测正在展示哪种类型的服装!

线性分类器

我们将从构建一个线性分类器开始,看看我们是如何做的。像往常一样,我们将使用 TensorFlow 的评估框架来使我们的代码易于编写和维护。提醒一下,我们将加载数据,创建分类器,然后运行训练和评估。我们也将直接从本地模型中做出一些预测。

让我们从创建模型开始。我们将把数据集从 28x28 像素展平到 1x784 像素,并创建一个名为pixels的特征列。这类似于我们第三集的flower_features简单明了的评估者

接下来,让我们创建我们的线性分类器。我们有 10 个不同的可能的类别来标记,而不是我们之前使用的鸢尾花的 3 个类别。

为了运行我们的训练,我们需要设置数据集和输入函数。TensorFlow 有一个内置的实用程序来接受一个numpy数组来生成一个输入函数,所以我们将利用它。

我们将使用input_data模块加载我们的数据集。将函数指向下载数据集的文件夹。

现在我们可以调用classifier.train()来集合我们的分类器、输入函数和数据集。

最后,我们运行一个评估步骤,看看我们的模型做得如何。当我们使用经典的 MNIST 数据集时,这个模型通常可以达到 91%的准确率。然而,fashion-mnist 是一个相当复杂的数据集,我们只能达到 80%左右的精度,有时甚至更低。

我们怎样才能做得更好?正如我们在第六集看到的,让我们深入

深入

换入 DNNClassifier 只是一行的变化,我们现在可以重新运行我们的训练和评估,看看深度神经网络是否能比线性神经网络表现得更好。

正如我们在第 5 集中所讨论的,我们现在应该打开 TensorBoard 来并排看看这两个模型!

$ tensorboard --logdir=models/fashion_mnist/

(浏览至 http://localhost:6006 )

张量板

看看 tensorboard,看起来我的深度模型并不比我的线性模型表现得更好!这也许是一个调整我的一些超参数的机会,就像在第 2 集中讨论的那样。

Looks like a race to the bottom…

也许我的模型需要更大,以适应这个数据集中的复杂性?或者也许我的学习速度需要降低?让我们试试看。稍微试验一下这些参数,我们就可以突破,获得比线性模型更高的精度。

The deep model (in blue/red) achieves a consistently lower loss

要达到这种精度需要更多的训练步骤,但最终对于更高精度的数字来说,这是值得的。

还要注意,线性模型比深度网络更早达到稳定状态。因为深度模型通常比线性模型更复杂,所以它们需要更长的训练时间。

在这个阶段,假设我们对我们的模型很满意。我们将能够导出它并产生一个可伸缩的时尚分类器 API。你可以看第 4 集了解更多关于如何做的细节。

做预测

让我们快速浏览一下如何使用估计器进行预测。在很大程度上,它看起来就像我们如何调用培训和评估;这是评估者的伟大之处之一——一致的界面。

注意,这一次我们指定了 1 的batch_size、1 的num_epochs和假的shuffle。这是因为我们希望预测一个接一个地进行,一次对所有数据进行预测,保持顺序。我从评估数据集的中间提取了 5 幅图像,供我们尝试预测。

我选择这 5 个不仅仅是因为它们在中间,而是因为模型得到了其中的 2 个错误。这两个例子都应该是衬衫,但是模型认为第三个例子是一个包,第五个例子是一件外套。你可以看到这些例子比手写数字更具挑战性,如果没有其他原因,只是图像的颗粒感。

后续步骤

你可以在这里找到我用来训练这个模型并生成图像的全部代码。你的模特表现如何?你最终使用了什么参数来达到这个精度?请在评论中告诉我!

我们的下一集将关注机器学习生态系统的一些工具,以帮助您构建工作流和工具链,并展示更多可以用来解决机器学习问题的架构。我期待在那里见到你!在那之前,继续机器学习!

感谢阅读本集云 AI 冒险。如果你喜欢这个系列,请为这篇文章鼓掌让我知道。如果你想要更多的机器学习动作,一定要关注 Medium 上的 me 或者订阅 YouTube 频道来观看未来的剧集。更多剧集即将推出!

机器学习模因:粥分析

原文:https://towardsdatascience.com/machine-learning-memes-a-porridge-analysis-208d30bce57e?source=collection_archive---------0-----------------------

在本帖中,我来看看一个 2016 Imgur 现象:366 天的粥。单个 Imgur 用户 only wheagle 在 2016 年每天都发布了不同的粥图。我在圣诞假期开始做这个分析,当时我以为粥会在 12/31/16 停止。值得庆幸的是,这位英雄在 2017 年继续发布他们每天吃粥的照片。

Porridge. Source: http://imgur.com/gallery/kZXXCto

我会在一年中随机看到这些帖子,通常我会一笑置之,但一年后我决定深入挖掘。我登录了 only wheage 的账户,发现尽管每天的图片基本上都是一样的,但每篇帖子的上传票数/浏览量/评论量却大相径庭。

作为一个数据迷,这引起了我的兴趣。如果我们比较一周中的几天,一天中的几个小时,一年中的几个月等等,会怎么样呢?看看什么时候在 Imgur 上发布一个湿漉漉的迷因最合适。

结果

直截了当地说,没有细节或解释,这里有一个热图,显示了 2016 年基于图像发布时间的得分总和,其中粥帖子的得分越高,颜色越深:

Data Viz created with Seaborn in Python (Notebook link at the end)

看着这张热图,你可以清楚地看到一个更暗的光带在一天的中间,以及一些围绕着早晨和晚上的暗点。第 5 天(星期六)显然在格林威治标准时间凌晨 2 点和 10 点得分最高。把这些时间转换成你的时区,然后贴一张你早餐吃的任何东西的照片到 Imgur 的首页!(编辑:这应该重做-我每次都为帖子添加分数,而不是获得每个日期/时间的平均分数)

我所有的代码和输出都可以从我的 IBM 数据科学体验笔记本上查看或下载。

我的分析

所以我展示了 1 个可视化,但我还为这些数据创建了许多其他的和一个预测模型。在这一部分,我将详细介绍我在这个项目中的工作。我不会进入技术细节,因为 Jupyter 笔记本的链接在文章的末尾(如果你不喜欢阅读,向下滚动)。

数据收集:

没有 Imgur 出色的 API,这篇文章是不可能发表的。除了这个 API,他们还提供了一个非常容易使用的 Python 模块。我利用这个模块收集我的数据。更具体地说,get_account_submissions()方法让我可以轻松地获取 only 粥帖子的所有数据。

数据清理:

这部分很简单。API 返回一些非常适合熊猫数据帧的 JSON。我收集了 only 粥的所有帖子但只是可视化,并为 2016 的帖子建立了一个模型。我决定将 2017 年作为我的模型的测试集。令人惊讶的是,当检查 2016 年数据的形状时,它有 366 个条目:只有麦片粥没有休息一天。大多数元数据对分析没有太大帮助。我确实为每个帖子设想了不同的指标,比如分数、投票数、评论数和浏览量。我把剩下的都拿走了。

探索性可视化:

当我处理这些数据时,我正在试验 Python 中不同的数据可视化库。我发现 Seaborn 是我最喜欢的开箱即用的美学。

这是一个 Seaborn 图,显示周六是观看、评分和评论的最佳时间:

我真的很喜欢这个可视化,但它并没有告诉我们太多。这是我最喜欢的来自 Seaborn 的情节:

对于这个可视化,我已经创建了一个二进制目标变量,其中如果一篇文章高于中值,则为 1,如果低于中值,则为 0。我真的很喜欢这个可视化,因为它显示只有麦片粥在今年的前 6 个月没有得到太多的爱,但在年底,有更多的帖子超过了中值分数阈值。

Seaborn 很美,但不互动。对于交互性,Plotly 是我的最爱。

下面是一个时间序列图,显示了 2016 年全年评论、评分和浏览量之间的关系。(我猜 Medium 不喜欢 Plotly iframes?如果您知道如何修复这种嵌入,请进行评论)

[## comment_count,score,views |由 Gfilla 制作的散点图| plotly

Gfilla 的“评论 _ 计数,得分,浏览量”的交互图和数据是散点图,显示评论 _ 计数,得分…

plot.ly](https://plot.ly/~gfilla/62.embed)

在 Jupyter 笔记本中,还有其他有趣的可视化效果,我只想在这里分享几个我最喜欢的。

模型构建:

好了,viz 的东西说够了,该上数学课了。统计学家可以在这里停止阅读,这样他们就不会感到不安:)。

由于我们在样本和特征方面非常有限,统计建模对于这个数据集来说有点牵强。但这有什么理由阻止我们呢?

如前一节所述,我为这个数据集创建了一个二元目标特征,基于帖子的分数是高于还是低于中位数。我知道为原始分数创建预测会非常困难,因为所有有用的元数据只有在图像发布后才知道(例如评论计数)。我只知道邮件发出的时间。所以我把帖子的时间戳分成了尽可能多的特征(甚至分钟)。我进一步将这些特性扩展为虚拟变量,因为我将每个日期/时间视为一个分类值。这给我留下了一个包含 132 个特征的数据集。

我决定用一个基本的决策树作为我的模型。我保留了 10%进行测试,结果是低于中位数的帖子精度为 0.74,高于中位数的帖子精度为 0.56。该模型的 F1 平均得分为 0.65。这个模型没有什么真正令人印象深刻的,请随意构建一个理解粥的复杂性的深度 NN;)

预测 2017 年粥:

2016 年后的粥帖子需要遵循与我训练模型的数据相同的数据准备管道。这一开始看起来很简单,但是如果不仔细考虑的话会变得有点复杂。在单个数据集上训练和测试模型与在新数据出现时对其进行评分相比,具有不同的测试要求。

这是一个有趣的挑战,在我可视化地探索数据并创建不同版本的数据框架时,我没有想到这一点。归根结底,我对数据进行的任何操作都是为了进入模型的原始训练数据,需要与对测试数据进行的转换保持一致。列的顺序。虚拟变量。删除功能。等等。

因为这不是我工作的初衷,所以如果人们感兴趣的话,我会把这篇文章作为后续文章。如果我继续这部分的工作,我将会致力于构建一个好的分类器(如果可能的话),而不是数据可视化。你可以在这里查看和下载我的笔记本。

预测酒店在线排名点击量的机器学习模型

原文:https://towardsdatascience.com/machine-learning-model-for-predicting-click-through-in-hotel-online-ranking-d55fc18c8516?source=collection_archive---------10-----------------------

Photo credit: pexels

如何应用机器学习技术来最大化呈现选项的点击率

酒店个性化和排名的核心是将一组酒店与一组品味各异、有时难以察觉的游客相匹配。匹配的准确性取决于在线旅行社(OTA)如何利用他们的可用信息,如给定的酒店特征、酒店的位置吸引力、用户的总购买历史和竞争对手的信息等,来推断旅行者对酒店的偏好。例如,Hotels.com 通过编辑客户的搜索标准,当他们进行旅游查询时,在结果列表的顶部呈现最具竞争力的产品来满足他们的需求

这是我们今天的目标:应用机器学习技术来最大化所呈现选择的点击率,其中点击表明访问者的兴趣,并可能决定预订。

最终,这就是我们想要实现的:当用户将他(或她)的搜索标准输入到酒店搜索引擎中时,会根据上述排名算法向他(或她)显示一个经过筛选的个性化排序的可用酒店列表,从而使列表顶部的酒店成为用户点击概率最高的酒店。我们一步一步来。

数据描述

数据集包含以下信息,可以从 Kaggle 下载,我们将使用 train.csv

Figure 1

让我们试着让列名更直观。

Figure 2

Figure 3

Figure 4

数据预处理

import pandas as pddf = pd.read_csv('train.csv')
df.shape

(9917530,54)

这是一个包含近 1000 万个观测值和 54 个特征的大型数据集。因此,我正在寻找一种方法使它更易于管理。

import matplotlib.pyplot as plt
n, bins, patches = plt.hist(df.prop_country_id, 100, density = 1, facecolor='blue', alpha=0.75)
plt.xlabel('Property country Id')
plt.title('Histogram of prop_country_id')
plt.show();

Figure 5

df.groupby('prop_country_id').size().nlargest(5)

Figure 6

n, bins, patches = plt.hist(df.visitor_location_country_id, 100, density = 1, facecolor='blue', alpha=0.75)
plt.xlabel('Visitor location country Id')
plt.title('Histogram of visitor_location_country_id')
plt.show();

Figure 7

df.groupby('visitor_location_country_id').size().nlargest(5)

Figure 8

这些数据是匿名的,因此无法确定消费者计划前往的确切国家或城市。然而,很明显,最大的国家(标为 219)是美国。最大的国家有 61%的观测值。其中,58%的搜索是由也在这个国家的消费者进行的,这表明该国幅员辽阔,国内旅游占很大一部分。价格货币也表明最大的国家是美国。

因此,为了提高计算效率,我们将在美国游客身上训练独立模型。这种方法大大减少了训练时间。

us = df.loc[df['visitor_location_country_id'] == 219]
us = us.sample(frac=0.6, random_state=99)
del us['visitor_location_country_id']

受限于计算能力,我们随机取美国数据集的 60%。然后删除“访问者 _ 位置 _ 国家 _id”列。

us.isnull().sum()

Figure 9

如您所见,我们在许多功能中有许多缺失的数据。我们将删除 NaN 值超过 90%的特征,还将删除“日期时间”、“位置标识”和“属性标识”,并估算包含 NaN 值不到 30%的三个特征,它们是:“属性查看得分”、“属性位置得分 2”和“原始目的地距离”。

cols_to_drop = ['date_time', 'visitor_hist_starrating', 'visitor_hist_adr_usd', 'srch_query_affinity_score', 'comp1_rate', 'comp1_inv', 'comp1_rate_percent_diff', 'comp2_rate_percent_diff', 'comp3_rate_percent_diff', 'comp4_rate_percent_diff', 'comp5_rate_percent_diff', 'comp6_rate_percent_diff', 'comp7_rate_percent_diff', 'comp8_rate_percent_diff', 'comp2_rate', 'comp3_rate', 'comp4_rate', 'comp5_rate', 'comp6_rate', 'comp7_rate', 'comp8_rate', 'comp2_inv', 'comp3_inv', 'comp4_inv', 'comp5_inv', 'comp6_inv', 'comp7_inv', 'comp8_inv', 'gross_bookings_usd', 'srch_id', 'prop_id']
us.drop(cols_to_drop, axis=1, inplace=True)

随机估算“prop _ review _ score”

random_impute

这种方法消除了平均数或总数估计量的插补方差,同时保持了项目值的分布。

用平均值估算“道具位置得分 2”

us['prop_location_score2'].fillna((us['prop_location_score2'].mean()), inplace=True)

用中间值估算“起点 _ 终点 _ 距离”

us['orig_destination_distance'].fillna((us['orig_destination_distance'].median()), inplace=True)

我们受够了指责!

电子设计自动化(Electronic Design Automation)

us.shape

(3467283,22)

经过基本的数据清理后,我们的美国数据集包含超过 340 万个观测值和 22 个特征。让我们来探索这些特性。

点击并预订

我们的目标变量是“click_bool”,而不是“booking_bool”。因为哪里有预订,哪里就一定有点击,我们要优化点击。

import matplotlib.pyplot as plt
import seaborn as sns
sns.countplot(x='booking_bool',data=us, palette='hls')
plt.show();us['booking_bool'].value_counts()

Figure 10

Figure 11

sns.countplot(x='click_bool',data=us, palette='hls')
plt.show();us['click_bool'].value_counts()

Figure 12

Figure 13

由于在线旅游业务的性质,预订率(2.8%)和点击率(4.3%)都非常低,非点击印象非常严重,类别非常不平衡。

搜索停留时间

n, bins, patches = plt.hist(us.srch_length_of_stay, 50, density = 1, facecolor='blue', alpha=0.75)
plt.xlabel('Search length of stay')
plt.title('Histogram of search_length_of_stay')
plt.axis([0, 30, 0, 0.65])
plt.show();

Figure 14

us.groupby('srch_length_of_stay').size().nlargest(5)

Figure 15

搜索最多的停留时间是 1 天,然后是 2 天、3 天……没有异常值。

搜索成年人数量

n, bins, patches = plt.hist(us.srch_adults_count, 20, density = 1, facecolor='blue', alpha=0.75)
plt.xlabel('Search adults count')
plt.title('Histogram of search_adults_count')
plt.show();

Figure 16

df.groupby('srch_adults_count').size().nlargest(5)

Figure 17

最常见的搜索成人计数是 2-成人,然后 1-成人,有意义。

房产星级评定

n, bins, patches = plt.hist(us.prop_starrating, 20, density = 1, facecolor='blue', alpha=0.75)
plt.xlabel('Property star rating')
plt.title('Histogram of prop_star_rating')
plt.show();

Figure 18

最常见的搜索属性星级是 3 星。很高兴知道,我会想得更高。

物业是不是品牌

us.groupby('prop_brand_bool').size()

Figure 19

73%以上的物业是品牌物业。这很有意义,因为我们谈论的是美国酒店和美国游客。

周六是否留下

us.groupby('srch_saturday_night_bool').size()

Figure 20

价格美元

sns.set(style="ticks", palette="pastel")ax = sns.boxplot(x="click_bool", y="price_usd", hue="click_bool", data=us)
ax.set_ylim([0, 200]);

Figure 21

us.groupby('click_bool')['price_usd'].describe()

Figure 22

平均而言,获得点击的 price_usd 总是低于没有获得点击的 price _ USD。

平衡等级

对于快速学习,我们的平衡策略是向下采样负面实例。

down_sampling

Figure 23

模型训练和评估

用集成模型进行点进预测

ensemble_models

Figure 24

用朴素贝叶斯模型进行点进预测

naive_bayes_models

Figure 25

用神经网络进行点进预测

neural_network

Figure 26

基于这种基线方法,在未来的帖子中,我们将构建一个学习排名模型,为每个印象个性化酒店排名。但在那之前,享受点击吧!

Jupyter 笔记本可以在 Github 上找到。周末愉快!

机器学习——不平衡数据集下的多类分类

原文:https://towardsdatascience.com/machine-learning-multiclass-classification-with-imbalanced-data-set-29f6a177c1a?source=collection_archive---------0-----------------------

分类和提高性能的技术方面的挑战

source [Unsplash]

具有不平衡数据集的多个类的分类问题比二元分类问题提出了不同的挑战。偏斜分布使得许多传统的机器学习算法效率较低,尤其是在预测少数类示例时。为了做到这一点,让我们首先理解手头的问题,然后讨论克服这些问题的方法。

  1. **多类分类:**两个以上类的分类任务;例如对一组水果图像进行分类,这些水果可以是橙子、苹果或梨。多类分类假设每个样本被赋予一个且仅一个标签:水果可以是苹果或梨,但不能同时是两者。
  2. **不平衡数据集:**不平衡数据通常指的是分类问题,其中类没有被平等地表示。例如,您可能有一个 3 类分类问题,将一组水果分类为总共有 100 个实例的橙子、苹果或梨。共有 80 个实例被标记为 1 类(橙子),10 个实例被标记为 2 类(苹果),其余 10 个实例被标记为 3 类(梨)。这是一个不平衡的数据集,比例为 8:1:1。大多数分类数据集在每个类中的实例数量并不完全相等,但是微小的差异通常并不重要。在一些问题中,阶层失衡不仅是普遍现象,也是意料之中的。例如,在描述欺诈交易的数据集中,数据是不平衡的。绝大多数交易属于“非欺诈”类,极少数属于“欺诈”类。

资料组

我们将在这个例子中使用的数据集是著名的“20 个新闻组”数据集。20 个新闻组数据集是大约 20,000 个新闻组文档的集合,平均分布在 20 个不同的新闻组中。20 个新闻组集合已经成为机器学习技术的文本应用实验的流行数据集,例如文本分类和文本聚类。

scikit-learn 提供了预处理数据集的工具,更多详情请参考此处的。下面给出的每个新闻组的文章数量大致相同。

从一些组中删除一些新闻文章,以使整个数据集不平衡,如下所示。

现在,我们有 20 个类的不平衡数据集可以做进一步的分析了。

建立模型

由于这是一个分类问题,我们将使用我之前的文章中描述的相似方法进行情感分析。唯一的区别是这里我们处理的是多类分类问题。

模型中最后一层是 *Dense(num_labels, activation =’softmax')* ,用 *num_labels=20* 类,用‘soft max’代替‘sigmoid’。模型中的另一个变化是将损失函数改为适用于多类问题的 *loss = ‘categorical_crossentropy’,*

列车型号

使用 20%验证集validation_split=20训练模型,并使用verbose=2,,我们可以看到每个时期后的验证准确性。仅仅在 10 个时期之后,我们就达到了 90%的验证准确度。

评估模型

这看起来是一个非常好的精确度,但是这个模型真的做得很好吗?

**如何衡量模型表现?**让我们考虑一下,我们在水果的早期示例的不平衡数据上训练我们的模型,由于数据严重偏向 1 类(橙子),模型过度拟合 1 类标签,并在大多数情况下预测它,我们实现了 80%的准确度,乍一看似乎非常好,但仔细观察,它可能永远无法正确分类苹果或梨。现在的问题是,在这种情况下,如果准确性不是选择的正确指标,那么使用什么指标来衡量模型的性能呢?

混淆矩阵

对于不平衡的类,很容易获得高精度,而实际上没有做出有用的预测。所以,精度作为一个评价指标只有在类标签均匀分布的情况下才有意义。在不平衡类别的情况下,混淆矩阵是总结分类算法性能的好技术。

混淆矩阵是分类算法的性能度量,其中输出可以是两个或多个类别。

x-axis=Predicted label, y-axis, True label

当我们仔细观察混淆矩阵时,我们会发现,与样本数量较多的类别[rec . sport . hockey、rec.motorcycles ]相比,样本数量较少的类别[alt . athiesm、talk.politics.misc、soc.religion.christian ]的得分[0.42、0.56、0.65]确实很低。因此,查看混淆矩阵,可以清楚地看到模型如何对各种类别进行分类。

如何提高性能?

有各种各样的技术可以提高不平衡数据集的性能。

重采样数据集

要使我们的数据集平衡,有两种方法:

  1. **欠采样:**从过度表示的类中移除样本;如果您有大量数据集,请使用此选项
  2. **过采样:**从代表性不足的类别中添加更多样本;如果数据集很小,请使用此选项

合成少数过采样技术

SMOTE 是一种过采样方法。它创造了少数民族的合成样本。我们使用imb learnpython 包对少数类进行过采样。

我们在应用 SMOTE 之前有 4197 个样本,在应用 SMOTE 之后有 4646 个样本,看起来 SMOTE 增加了少数类的样本。我们将使用新数据集检查模型的性能。

验证准确性从 90%提高到 94%。让我们测试一下这个模型:

测试准确率比以前提高很少(从 87%提高到 88%)。现在让我们来看看混淆矩阵。

我们看到[ alt.athiesmtalk.politics.miscsci.electronicsSOC . religion . Christian]这几门课比之前提高了分数【0.76,0.58,0.75,0.72】。因此,在对类别进行分类时,即使精确度相似,该模型的性能也比以前更好。

另一招:

既然阶层不均衡,那给少数阶层提供一些偏向怎么样?在训练模型时,我们可以通过使用compute_class_weight和使用参数‘class_weight’来估计 scikit_learn 中的类权重。这有助于在训练模型时提供对少数类的一些偏向,从而有助于在对各种类进行分类时提高模型的性能。

精确召回曲线

当类别非常不平衡时,精确召回是预测成功的有用度量。精度是对分类模型仅识别相关数据点的能力的度量,回忆 i s 是对模型在数据集内找到所有相关案例的能力的度量。

精确度-召回率曲线显示了不同阈值的精确度和召回率之间的折衷。曲线下的高区域表示高召回率和高精度,其中高精度与低假阳性率相关,高召回率与低假阴性率相关。

精度 召回 的高分表明分类器正在返回准确的结果(精度),以及返回所有肯定结果(召回)的大部分。一个高精度、高召回率的理想系统会返回很多结果,所有结果都标注正确。

下面是使用 scikit-learn20 个新闻组数据集的精确召回图。

Precision-Recall Curve

我们希望每一类的 P-R 曲线面积接近 1。除了 0 级、3 级和 18 级,其余级别的面积都在 0.75 以上。您可以尝试使用不同的分类模型和超参数调整技术来进一步改善结果。

结论

我们讨论了与不平衡数据集中的多类分类相关的问题。我们还展示了使用正确的工具和技术如何帮助我们开发更好的分类模型。

感谢阅读。代码可以在 Github 上找到。

参考文献

* [## 应对机器学习数据集中不平衡类别的 8 种策略

你遇到过这种情况吗?您正在处理数据集。您创建了一个分类模型,并获得了 90%的准确率…

machinelearningmastery.com](https://machinelearningmastery.com/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/) [## 如何处理机器学习中的不平衡分类问题?

如果你在机器学习和数据科学上花了一些时间,你肯定会遇到…

www.analyticsvidhya.com](https://www.analyticsvidhya.com/blog/2017/03/imbalanced-classification-problem/) [## 利用不平衡数据集提高机器学习模型性能的三种技术

这个项目是我最近“机器学习工程师”职位面试技能测试的一部分。我不得不…

towardsdatascience.com](/working-with-highly-imbalanced-datasets-in-machine-learning-projects-c70c5f2a7b16) [## 理解混淆矩阵

当我们得到数据,经过数据清洗,预处理和争论,我们做的第一步是把它提供给一个…

towardsdatascience.com](/understanding-confusion-matrix-a9ad42dcfd62) [## 使用 Keras 深度学习 Python 库 opencodez 进行简单的文本分类

深度学习无处不在。所有组织,无论大小,都试图利用技术,发明一些很酷的…

www.opencodez.com](https://www.opencodez.com/python/text-classification-using-keras.htm)*

机器学习,NLP:使用 scikit-learn,python 和 NLTK 的文本分类。

原文:https://towardsdatascience.com/machine-learning-nlp-text-classification-using-scikit-learn-python-and-nltk-c52b92a7c73a?source=collection_archive---------0-----------------------

Text Classification

最新更新:
我已经把完整的代码(Python 和 Jupyter 笔记本)上传到 GitHub 上:https://github.com/javedsha/text-classification

文档/文本分类监督的机器学习(ML)中重要而典型的任务之一。为文档分配类别,文档可以是网页、图书馆书籍、媒体文章、图库等。有许多应用,例如垃圾邮件过滤、电子邮件路由、情感分析等。在这篇文章中,我想演示我们如何使用 python、scikit-learn 和一点 NLTK 来进行文本分类。

**免责声明 😗* 我是机器学习新手,也是博客新手(第一次)。因此,如果有任何错误,请让我知道。感谢所有反馈。

让我们将分类问题分成以下步骤:

  1. 先决条件和设置环境。
  2. 在 jupyter 中加载数据集。
  3. 从文本文件中提取特征。
  4. 运行 ML 算法。
  5. 参数调整的网格搜索。
  6. 有用的提示和一点 NLTK。

步骤 1:先决条件和设置环境

遵循这个例子的先决条件是 python 版本 2.7.3 和 jupyter notebook。你可以安装anaconda它会为你得到一切。此外,还需要一点 python 和 ML 基础知识,包括文本分类。在我们的例子中,我们将使用 scikit-learn (python)库。

**第二步:**在 jupyter 中加载数据集。

本例中使用的数据集是著名的“20 新闻组”数据集。关于来自原网站的数据:

20 个新闻组数据集是大约 20,000 个新闻组文档的集合,平均分布在 20 个不同的新闻组中。据我所知,它最初是由 Ken Lang 收集的,可能是为了他的news weaver:Learning to filter net newspaper,尽管他没有明确提到这个收集。20 个新闻组集合已经成为机器学习技术的文本应用实验的流行数据集,例如文本分类和文本聚类。

这个数据集内置在 scikit 中,所以我们不需要显式下载它。

I .在 windows 中打开命令提示符,键入“jupyter notebook”。这将在浏览器中打开笔记本,并为您启动一个会话。

二。选择新建> Python 2。你可以给笔记本起个名字- 文本分类演示 1

三。加载数据集:(这可能需要几分钟,请耐心等待)

from sklearn.datasets import fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle=True)

注:以上,我们只是加载了 训练 数据。我们将在后面的例子中单独加载测试数据。

四。您可以通过以下命令检查目标名称(类别)和一些数据文件。

twenty_train.target_names #prints all the categories
print("\n".join(twenty_train.data[0].split("\n")[:3])) #prints first line of the first data file

第三步:从文本文件中提取特征。

文本文件实际上是一系列单词(有序的)。为了运行机器学习算法,我们需要将文本文件转换成数字特征向量。我们将以使用 袋字 模型为例。简而言之,我们将每个文本文件分割成单词(英文按空格分割),并计算每个单词在每个文档中出现的次数,最后给每个单词分配一个整数 id。我们字典中的每个唯一的单词都会对应一个特征(描述性特征)。

Scikit-learn 有一个高级组件,它将为用户“计数矢量器”创建特征矢量。更多关于它的这里

from sklearn.feature_extraction.text import CountVectorizer
count_vect = CountVectorizer()
X_train_counts = count_vect.fit_transform(twenty_train.data)
X_train_counts.shape

这里通过做'count _ vect . fit _ transform(twenty _ train . data)',我们正在学习词汇词典,它返回一个文档-术语矩阵。[n 个样本,n 个特征]。

仅仅统计每个文档的字数有一个问题:它会给较长的文档比较短的文档更多的权重。为了避免这种情况,我们可以在每个文档中使用频率(TF-Term frequency),即#count(word) / #Total words。

TF-IDF: 最后,我们甚至可以降低更常见单词的权重,如(the,is,an 等。)出现在所有文档中。这被称为 TF-IDF,即术语频率乘以逆文档频率。

我们可以使用下面一行代码实现这两个目标:

from sklearn.feature_extraction.text import TfidfTransformer
tfidf_transformer = TfidfTransformer()
X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)
X_train_tfidf.shape

最后一行将输出文档-术语矩阵的维度-> (11314,130107)。

步骤四。运行 ML 算法。

有各种算法可用于文本分类。我们就从最简单的一个'朴素贝叶斯 (NB)' ( *不要觉得太幼稚!*😃)

您可以使用下面两行代码在 scikit 中轻松构建一个 NBclassifier:(注意——NB 有许多变体,但关于它们的讨论超出了范围)

from sklearn.naive_bayes import MultinomialNB
clf = MultinomialNB().fit(X_train_tfidf, twenty_train.target)

这将在我们提供的训练数据上训练 NB 分类器。

**构建管道:**我们可以编写更少的代码,通过如下方式构建管道来完成上述所有工作:

**>>> from** **sklearn.pipeline** **import** Pipeline
**>>>** text_clf = Pipeline([('vect', CountVectorizer()),
**... **                     ('tfidf', TfidfTransformer()),
**... **                     ('clf', MultinomialNB()),
**...** ])text_clf = text_clf.fit(twenty_train.data, twenty_train.target)

‘vect’、‘tfi df’和‘clf’这几个名字是随意取的,但以后会用到。

NB 分类器的性能:现在我们将在测试集上测试 NB 分类器的性能。

import numpy as np
twenty_test = fetch_20newsgroups(subset='test', shuffle=True)
predicted = text_clf.predict(twenty_test.data)
np.mean(predicted == twenty_test.target)

我们得到的准确率是 ~77.38% ,对于 start 和一个幼稚的分类器来说已经不错了。还有,恭喜你!!!您现在已经成功地编写了一个文本分类算法👍

支持向量机(SVM): 让我们尝试使用不同的算法 SVM,看看我们是否能获得更好的性能。更多关于它的在这里

>>> from sklearn.linear_model import SGDClassifier>>> text_clf_svm = Pipeline([('vect', CountVectorizer()),
...                      ('tfidf', TfidfTransformer()),
...                      ('clf-svm', SGDClassifier(loss='hinge', penalty='l2',
...                                            alpha=1e-3, n_iter=5, random_state=42)),
... ])>>> _ = text_clf_svm.fit(twenty_train.data, twenty_train.target)>>> predicted_svm = text_clf_svm.predict(twenty_test.data)
>>> np.mean(predicted_svm == twenty_test.target)

我们得到的准确率是 **~82.38%。**咦,好一点了👌

第五步。网格搜索

几乎所有的分类器都有各种参数,可以调整这些参数以获得最佳性能。Scikit 提供了一个非常有用的工具‘GridSearchCV’。

>>> from sklearn.model_selection import GridSearchCV
>>> parameters = {'vect__ngram_range': [(1, 1), (1, 2)],
...               'tfidf__use_idf': (True, False),
...               'clf__alpha': (1e-2, 1e-3),
... }

这里,我们创建了一个参数列表,我们希望对这些参数进行性能调优。所有参数名称都以分类器名称开始(记住我们给出的任意名称)。如 vect _ _ ngram _ range 在这里,我们告诉使用一元和二元,并选择一个是最佳的。

接下来,我们通过传递分类器、参数和 n_jobs=-1 来创建网格搜索的实例,n _ jobs =-1 告诉使用来自用户机器的多个内核。

gs_clf = GridSearchCV(text_clf, parameters, n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

这可能需要几分钟的时间,具体取决于机器配置。

最后,要查看最佳平均分数和参数,请运行以下代码:

gs_clf.best_score_
gs_clf.best_params_

NB 分类器的准确率现在已经提高到 ~90.6% (不再那么幼稚了!😄)和对应的参数是{'clf__alpha': 0.01,' tfidf__use_idf': True,' vect__ngram_range': (1,2)}。

类似地,对于 SVM 分类器,我们使用下面的代码获得了提高的准确率 ~89.79%注意:您可以通过调整其他参数来进一步优化 SVM 分类器。这是留给你去探索更多。

>>> from sklearn.model_selection import GridSearchCV
>>> parameters_svm = {'vect__ngram_range': [(1, 1), (1, 2)],
...               'tfidf__use_idf': (True, False),
...               'clf-svm__alpha': (1e-2, 1e-3),
... }
gs_clf_svm = GridSearchCV(text_clf_svm, parameters_svm, n_jobs=-1)
gs_clf_svm = gs_clf_svm.fit(twenty_train.data, twenty_train.target)
gs_clf_svm.best_score_
gs_clf_svm.best_params_

**第六步:**有用的小技巧和一点 NLTK。

  1. 从数据中删除 停止字 : (the,then etc)。只有当停用词对潜在问题没有用时,才应该这样做。在大多数的文本分类问题中,这确实是没有用的。让我们看看删除停用词是否会提高准确性。按如下方式更新用于创建 CountVectorizer 对象的代码:
>>> from sklearn.pipeline import Pipeline
>>> text_clf = Pipeline([('vect', CountVectorizer(**stop_words='english**')),
...                      ('tfidf', TfidfTransformer()),
...                      ('clf', MultinomialNB()),
... ])

这是我们为 NB 分类器构建的管道。像以前一样运行剩余的步骤。这就把准确率从 77.38%提高到了 81.69% (那太好了)。你可以对 SVM 做同样的尝试,同时进行网格搜索。

  1. FitPrior=False:多项式 B 设置为 False 时,将使用统一的先验。这并没有多大帮助,但将准确率从 81.69%提高到了 82.14%(没有太大的提高)。试着看看这是否适用于你的数据集。

3。词干化:词干化是将词形变化(有时是派生的)的单词简化为词干、词根或词根形式的过程。例如,词干算法将单词“fishing”、“fished”和“fisher”简化为词根单词“fish”。

我们需要 NLTK,它可以从安装到这里。NLTK 附带了各种词干分析器(关于词干分析器如何工作的细节超出了本文的范围),它们可以帮助将单词简化为它们的根形式。再次使用这个,如果它对你问题有意义的话。

下面我用了雪球词干分析器,它对英语非常有效。

import nltk
nltk.download()from nltk.stem.snowball import SnowballStemmer
stemmer = SnowballStemmer("english", ignore_stopwords=True)class StemmedCountVectorizer(CountVectorizer):
    def build_analyzer(self):
        analyzer = super(StemmedCountVectorizer, self).build_analyzer()
        return lambda doc: ([stemmer.stem(w) for w in analyzer(doc)])stemmed_count_vect = StemmedCountVectorizer(stop_words='english')text_mnb_stemmed = Pipeline([('vect', stemmed_count_vect),
...                      ('tfidf', TfidfTransformer()),
...                      ('mnb', MultinomialNB(fit_prior=False)),
... ])text_mnb_stemmed = text_mnb_stemmed.fit(twenty_train.data, twenty_train.target)predicted_mnb_stemmed = text_mnb_stemmed.predict(twenty_test.data)np.mean(predicted_mnb_stemmed == twenty_test.target)

我们得到的词干准确率约为 81.67%。在我们使用 NB 分类器的情况下,边际改进。你也可以尝试 SVM 和其他算法。

**结论:**我们已经学习了 NLP 中的经典问题,文本分类。我们学习了一些重要的概念,如单词袋、TF-IDF 和两个重要的算法 NB 和 SVM。我们看到,对于我们的数据集,两种算法在优化时几乎相等。有时,如果我们有足够的数据集,算法的选择几乎不会有什么不同。我们还了解了如何执行网格搜索以进行性能调优,并使用了 NLTK 词干法。您可以在数据集上使用这些代码,看看哪些算法最适合您。

**更新:**如果有人尝试了不同的算法,请在评论区分享结果,对大家都会有用。

请让我知道是否有任何错误和反馈是受欢迎的✌️

推荐,评论,分享如果你喜欢这篇文章。

参考文献:

http://scikit-learn.org/(代码

【http://qwone.com/~jason/20Newsgroups/ (数据集)

人脑的机器学习

原文:https://towardsdatascience.com/machine-learning-of-human-brain-739ab0419612?source=collection_archive---------11-----------------------

最高层次的学习

问)为什么算法飞跃可以比硬件飞跃更好?

Ans) 随着小尺度(纳米及更小)的物理不确定性开始发挥作用(电子开始四处跳跃),硬件限制造成了难以解决的瓶颈。

在这一点上,想法(算法)可以用来释放可行硬件的全部潜力。

问)为什么这些改进对机器学习如此有益?

Ans) 机器学习(ML)程序可以轻松涉及:

  • 十亿次计算
  • 类似方程的百至百万次幂
  • 大多数计算是相互独立的(可以并行或分布式)

因此,即使是一个小的优化也能产生非常明显的效果,为您节省几个小时到几个月的时间!

问)为什么要参考大脑来进行优化?

Ans) 简而言之,如果没有下面提到的人类大脑的进化,我们可能会变成这样:

记忆预测框架

问)什么是新大脑皮层?

Ans)新皮层 是大脑皮层最大的部分,是大脑的外层

问)为什么新大脑皮层很重要?

Ans)新皮层,也叫等皮层,是哺乳动物大脑中参与高级脑功能的部分,如感觉感知认知产生运动指令空间推理语言 ( 部分)。

额外:新皮层进一步细分为真皮层前皮层。更多关于大脑皮层工作的信息可以在这里,这里这里这里 ( 好奇心可能会让你打开链接)。

问)新大脑皮层与机器学习有什么关系?

Ans)分层时间记忆 ( HTM )是基于人脑新皮层中锥体 神经元 相互作用。****

HTM 的核心:

  • 能够存储、学习、推断和回忆高阶序列的学习算法
  • 连续学习未标记数据中基于时间的模式
  • 对噪声的鲁棒性和高容量,意味着它可以同时学习多个模式

当应用于计算机时, HTM 非常适合于预测、异常检测、分类以及最终的感觉运动应用。

由于在一些自然发生的神经网络中观察到的层级,例如在大脑中观察到的,HTM 具有层级拓扑。

人类的记忆层次真的非常非常复杂!

示例:

或者以简化的形式:

随着层级的上升,代表也增加了:

  • 范围:例如更大面积的视野,或者更广泛的触觉区域。
  • 时间稳定性:较低层次的实体变化很快,而较高层次的感知(心理概念)往往更稳定。
  • 抽象:通过连续提取不变特征的过程,越来越抽象的实体被识别。
  • 资源密集度更低:需要更少的资源,尤其是内存。

人脑的算法效率几乎高到石化!

哲学的宝藏,内省

问:什么是内省?

Asn)内省元认知,是关于一个人思维的自我意识或‘思考思维的能力’。一个高层次的心智过程(非常高)。

准确的内省能够区分正确的决定和错误的决定。

基本上,一个学习者正在发展一种意识。在培训期间,能够自我拒绝或鼓励模式。 因此,成为一个自我优化的学习者,是普通学习的必要条件。

示例:

双稳态刺激(双目视觉中的两张图片,每只眼睛一张)是研究有意识视觉感知的神经机制的最流行的方法之一。

这种刺激包含相互矛盾的信息,视觉系统无法将其整合成一个统一的感知。

这导致观察者的感知(解释能力)状态每隔几秒钟就发生变化,试图找出正确的解释。所有这些都是在物理刺激保持不变的情况下发生的。

在这种情况下,大脑的额叶作出自我意识(内省)的决定,拒绝任何信息或修改每个信息以消除冲突。

这方面的细节可以在 Natalia Zaretskaya 和 Marine Narinyan 的论文中找到

问:什么是灰质?

Ans) 中枢神经系统内部被组织成灰质和白质

灰质由嵌入 神经胶质 (由大量神经细胞组成的神经组织);它是灰色的。

问)为什么灰质很重要?

对人类来说,灰质体积可能有助于阐明一个人对其自省能力的信心在多大程度上得到了支持。他的自省能力有多准确。

更多的灰质通常意味着更多的智力。

正如爱因斯坦曾经说过的“灰质婊子!”…..不,他实际上没有。

问)那我们为什么不直接实现灰质的工作呢?

仅仅是因为灰质的工作非常非常复杂。我们不知道“的信心”和“自我反省能力的准确性”之间的确切关系。

那么我们知道些什么呢?

自省(经过数百万年的进化)仍然是一种罕见的能力,即使对于复杂的生物来说也是如此,大多数生物完全缺乏这种能力。这是进化的最新发展之一。

问)大脑的哪一部分负责内省?

Ans) 大脑中的前额皮质

前额叶皮层 ( PFC )是覆盖额叶前部的大脑皮层。

该区域的两个部分非常有趣:

  • 前额叶前皮质
  • 内侧前额叶皮质

问)前额叶前皮层有什么特别之处?

前前额叶皮层与顶级处理能力有关,这种能力被认为是人类区别于其他动物的标志。

大部分起内省作用的灰质存在于这个区域(准确的说是右前前额叶皮层)。邻近白质的结构在自省能力中也扮演了一些(不清楚的)角色。

这个大脑区域与计划复杂的认知行为个性表达决策调节社会行为有关。这个大脑区域的基本活动被认为是根据内部目标协调思想和行动。

问)这对机器学习来说意味着什么?

我会简短地回答这个问题

  • 知道自己的决定的学习者
  • 学习适应它的环境
  • 能够随时设定目标的学习者
  • 能够用几种模式概括大量信息的学习者

问)而内侧前额叶皮层有什么特别之处?

Ans)内侧前额叶皮层 (mPFC) 被认为是大脑的奖赏系统的一部分。

mPFC 是中皮质边缘多巴胺能系统的一部分( 基本上它产生多巴胺,即‘快乐酶’)。

mPFC 参与奖励相关机制的证据主要来自三类研究:

  • 条件位置偏好(CPP) :测量物体或经历的动机效果
  • 颅内自我刺激(ICSS) :什么条件触发大脑奖赏系统
  • 自我给药:大脑需要哪种外部药物(如治疗糖尿病的胰岛素)

这个奖励系统的有趣之处在于:

  • mPFC 的不同分区似乎不同地参与了不同药物的“奖励作用”。这表明多重奖励系统的存在。
  • *有些药物可以在 mPFC 内直接产生奖赏效应,而有些药物即使在 mPFC 内没有直接的奖赏效应,也依赖 mPFC 的功能来介导其奖赏效应。*可以表示为多级奖励流程

从机器学习的角度来看,这意味着什么?

Ans) 更简短的回答:

  • 整体强化学习

问:什么是强化学习?

Ans) 一种机器学习的类型,涉及:

  • 无监督(基于奖励的试错)
  • 好与坏是在几步之后决定的,而不是瞬间决定的
  • 动态系统所以时间很重要,步骤顺序也很重要
  • 代理采取行动并改变/影响其环境
  • 对于每一个行动,代理人都会得到一个奖励而它的工作就是最大化它

它是这样工作的:

问)迷茫?

Ans)*’*奖励是能够让一个决定优先于其他决定的东西。

这是一个标量反馈,量化代理如何适应环境/与环境互动。

就像你给你的狗零食,如果它先坐下,否则就不给它零食(为什么你不坐下?!).

强化学习者只是简单地遵循最大化累积回报的步骤。

多重奖励系统本质上意味着大脑内置了多重 优评 强化学习机制。

简而言之,演员-评论家学习包括演员采取行动评论家在该行动中发现利弊(批评)。

问)奖励系统的作用听起来很像自省??

嗯,那是因为奖励系统确实在一个人的自省能力中扮演了重要的角色。然而,这种关系真的很复杂。

“强化学习是简单的决策科学。这就是它如此普遍的原因。”—大卫·西尔弗

所以前额叶是普通智力领域的前沿!

用于数据分析的机器学习平台

原文:https://towardsdatascience.com/machine-learning-platform-for-data-analysis-b7603dc3049?source=collection_archive---------3-----------------------

Akvelon 的机器学习项目

问题陈述

如今,快速发展的机器学习技术让我们能够解决越来越多的现实生活问题。在这种情况下,可以通过创建一个系统来减少例行操作,该系统允许算法开发人员专注于他们的任务,而不是提供执行环境。我们创建了这样一个平台,并在一个最有趣的问题——市场价值预测上进行测试。为了让事情变得更有趣,我们使用比特币价格变化作为数据源。

如果你在 2012 年 12 月购买了一枚比特币作为圣诞礼物,那么你的 13 美元今天将价值 8000 美元左右。

你可以从世界各地的人们那里听到许多类似的故事。没有人确切知道比特币或任何其他加密货币在未来一小时、一天、一周、一月等的价格会是多少。,但有可能根据新闻进行预测。

新闻通常是市场的驱动力,它们的缺乏或低水平的重要性可能导致市场可以简单地静止不动。

这篇文章旨在展示如何使用大数据技术建立一个机器学习平台,该平台可以帮助根据来自世界各地的新闻预测特定市场的价值。

数据源

为了使我们能够进行任何分析,我们必须获得这项任务所需的数据集。我们至少需要两个数据源:一个是比特币的市场价值,另一个是与比特币相关的大众媒体提及的信息。

寻找比特币市场价值的数据源是一件相对简单的事情。周围有各种各样的选择,我们只需要选择其中之一。我们的选择在这里并不重要,所以我们不要太关注这个。我们使用了 雅虎财经 ,因为它是免费的,可靠的,并且有多个程序库可以使用。

处理来自大众媒体的信息要复杂得多。为了获得客观的信息,我们应该从各种渠道收集信息。在把这样的新闻来源罗列出来之后,我们肯定会面临一系列的困难,比如不同的语言,数据源的稳定性,信息的存储。但事实上,与主要挑战相比,所有这些问题都不是什么大问题——通过一组参数估计新闻效果。这个挑战是计算机科学和人工智能的一部分,称为自然语言处理。如今,它是一个快速发展的领域,重点是机器学习。

幸运的是, GDELT 项目 可以帮助我们获得新闻数据来源。GDELT 是一个事件、语言和语调的全球数据库;由谷歌拼图支持。引用自官方网站:“GDELT 项目以 100 多种语言监测来自每个国家几乎每个角落的广播、印刷和网络新闻,并识别每天每一秒推动我们全球社会的人、地点、组织、主题、来源、情感、计数、引用、图像和事件”。这正是我们正在寻找的。现在我们已经有了开始工作所需的一切。

解决方案设计

使用上面列出的数据源,我们可以讨论我们的解决方案设计。首先,让我们创建一个我们希望在解决方案中看到的功能列表,并解释我们如何支持这些功能:

  1. **易于运行的算法执行。**在寻找最佳算法的过程中,开发人员应该能够通过多次迭代轻松访问数据、源代码和以前的尝试,而无需关心除算法本身之外的任何事情。这由应用程序模板支持,该模板封装了数据访问和执行的所有逻辑。叫做 ml-template
  2. **有效数据处理。**为了高效地处理大量数据,我们将使用 Apache Spark,它通过 Spark ML 提供了强大的机器学习算法实现工具。
  3. 添加新数据源的能力 可以通过单独的微服务进行数据管理来实现。数据服务将负责下载带有相关股市数据(雅虎财经)的新闻(GDELT 数据)并保存到数据库中。
  4. 使用不同编程语言进行算法开发 的能力由 Executor Service 提供——一种用于下载和编译算法源、模型训练、在 Spark 集群上运行算法的微服务。它不依赖于特定的技术,可以运行任何可以从命令行执行的东西。
  5. **结果比较。**还有另一个名为结果评估服务的微服务,用于接收来自 ml 模板的结果,并为每个算法执行结果计算分数。
  6. 执行管理的网络界面。 用户界面将使用 WebSocket 与我们的微服务进行通信。

点睛之笔——这个项目选择了名称 Midas 。神话中的迈达斯国王把东西变成了金子,我们的系统就是为了把数据变成“金子”而设计的。

解决方案的基础设施

为了获得完整且可用的产品,我们应该确定要使用的基础设施。由于我们需要在解决方案中使用多个节点(微服务、数据存储、Spark 节点),因此合理的做法是为每个节点使用映像,而不是真实或虚拟机。

作为容器管理平台,我们将使用牧场主。这个平台包括RancherOS——专门为容器管理准备的简化 Linux 发行版。出于容器编排的目的,它默认使用,但也允许使用其他工具,如 Docker Swarm 或 Kubernetes。

对于 Apache Spark 集群管理,我们将使用 Apache Mesos 。这是一个强大的资源共享工具,专为 Spark 等基于集群的程序解决方案而设计。你可以在加州大学的这篇文章中了解更多关于我们选择的福利的信息。

此外,我们将需要一些日志处理的程序解决方案。为此,管道将由 3 个工具组成:fluent 和用于日志收集;弹性搜索用于存储和搜索;基巴纳用于可视化。

我们基础架构的最后一个组件是持续交付工具。为此,我们使用了最流行的工具之一——詹金斯。

Infrastructure diagram

工作流程

Workflow diagram

标准工作流程如上图所示。图表上的数字具有以下含义:

  1. 用户访问前端(web 应用程序,又名 Midas Eyes )以获取关于现有模型和先前执行的信息。此外,用户可以创建和训练新模型,或者通过 UI 应用现有模型作为新的输入数据。
  2. 前端通过 WebSocket 从 Executor 服务请求有关执行和模型的信息。
  3. 模型和执行的元数据存储在 PostgreSQL 数据库中。
  4. 前端通过 WebSocket 向结果评估服务请求结果及其评估。
  5. 结果和估计值存储在 PostgreSQL 数据库中。
  6. 当“train”执行开始时,Executor 服务从 GitLab 下载源代码。对于“应用”执行,它们已经被存储并可以立即运行。然后,Executor 服务使用某种算法运行开发人员扩展的 ml 模板。
  7. 在 Spark 集群上启动一个作业之前,ml-template 通过 REST API 检查数据服务中是否存在用户指定的输入数据。
  8. 如果执行所需的数据丢失,数据服务将从外部资源下载数据——在我们的例子中,是 GDELT 和 Yahoo。
  9. 数据服务将下载的数据存储在 Mongo 数据库中。
  10. 当数据准备好时,ml-template 将任务提交给 Spark 集群。
  11. 在执行过程中,Spark 从 Mongo 数据库中请求必要的数据。
  12. 当执行完成时,结果被提交给结果评估服务。该服务进行必要的评估,包括与地面实况的比较(火花术语的“标签”)。

另外,关于微服务的技术堆栈说几句话。数据、执行和结果评估服务由 Java、Spring Boot、Hibernate 和 Gradle 提供支持。ml-template 是使用 Scala 编写的,但也可以在 Python、R 或 Java 上创建。前端基于 React.js 和 Bootstrap。

算法应用示例

作为热身,让我们试试线性回归算法。我们最初的假设是,从新闻的平均基调来看,比特币价格和衍生品之间的相关性。平均语气是事件被提及次数的衡量标准。它的范围在-100 到+100 之间,其中 0 是中间值。这个参数是一个很大的值数组,通常大约有几千个数字。但是根据数量和正/负值的分布,它可以变成几个权重。经过简单的计算,我们得到平均色调和总量。

关于新闻和市场数据之间的线性相关性的假设非常天真,但这是一个很好的起点。使用它,我们可以检查一切都按计划进行。正如所料,在这一点上的结果并不令人鼓舞,如下图所示。

这只是许多尝试中的一个,没有一个能产生好于数百美元的平均偏差。更相关的算法,如梯度推进树回归,也显示出不可靠的结果。

这意味着我们需要使用诸如交叉验证之类的技术来改进当前的算法,或者尝试新的算法。例如,将深度学习(尤其是深度神经网络)与 Apache Spark 结合使用是一种有趣的方法。此外,我们可能需要更改我们的输入参数集。这样,我们就有了广泛的可能改进方向。

结论

我们在这个项目上的工作仍在进行中。开发人员正在开发他们的算法版本,试图获得更好的结果。在开发这个系统的过程中,许多想法出现在我们的脑海中,我们也在努力让它们活跃起来。

货币预测不是唯一可能的应用领域。例如,让它在市场股票上工作也很容易。这类股票有更多的新闻参数可以操作,因为它们与特定的国家或公司相关,并取决于与这些国家和公司相关的事件。

我们在这个项目中使用的技术都是开源的。在本文中,我们向您展示了如何轻松构建复杂的机器学习解决方案,而不是使用市场上现有的解决方案。我们希望我们的经验能激励你去做自己感兴趣的项目。

关于我们

我们在Akvelon Inc .爱等前沿技术,如区块链、大数据、机器学习、人工智能、计算机视觉等等。这是我们在 Office 战略实验室开发的众多项目之一。

Akvelon company official logo

如果你有兴趣为一个项目做贡献,或者有一个有趣的想法——联系我们 。或者如果你想和我们强大的 Akvelon 团队**——请 查看我们的空缺职位 。**

阿图尔 合著

面向现代商业领袖的机器学习驱动的流失分析

原文:https://towardsdatascience.com/machine-learning-powered-churn-analysis-for-modern-day-business-leaders-ad2177e1cb0d?source=collection_archive---------2-----------------------

Original image from www.desktopbackground.org. Recolored and rebranded by the author. For images, unless the source is specifically mentioned, are created by the author: All copyright reserved. Please attribute during sharing.

阿奴勒哈维尔马 合著。Anulekha 和我是在一次聚会上认识的。她是这里包含的示例实现的贡献者。

简介

最近,在帕洛阿尔托的一次创始人聚会上,我遇到了一家成功的 SaaS 公司的首席执行官,他正在开发客户参与工具。当我们在讨论机器学习在 SaaS 企业中的应用时,话题很快转向了(客户)流失管理。消费者市场和企业部门的所有业务都必须处理客户流失问题,因为它可能最终会影响公司的收入数字,从而影响政策决策。

根据*《在混乱的边缘领先》*的作者,客户保持率增加 2%(或流失率降低)相当于成本降低 10%。难怪 SaaS 的公司(以及关心客户的公司)非常重视客户流失分析。此外,根据白宫消费者事务办公室的调查,获得一个新客户的成本是留住一个老客户的 6-7 倍。

这家公司的首席执行官一直在使用基于简单统计模型的传统追溯流失管理。他的团队已经列出了高消费倾向的顾客,并通过特殊的礼宾服务来满足他们的需求。这在应用程序的工作流程中引入了新的步骤,并影响了所有部门的整体生产力,尤其是涉及 UX 设计、A/B 测试和市场信息的团队。业务团队意识到,这种对流失客户的特殊处理不是一个可持续的过程,他们需要一个全面的流失管理策略,该策略考虑到风险(和相关的风险容忍度)、针对不同客户群的保留干预的水平和成本,更加系统和持续。

“竞争优势只有两种来源,比竞争对手更快地了解我们的客户的能力,以及比竞争对手更快地将这种了解转化为行动的能力”

——通用电气前董事长兼首席执行官杰克·韦尔奇

**客户流失率指的是一家公司的客户流失率,或者更简单地说,客户离开你的公司或服务的速度。**客户流失的例子包括

  • 订阅的取消
  • 关闭账户
  • 不续签合同或服务协议
  • 在另一家商店购物的决定
  • 使用其他服务提供商

许多不同的原因都可能导致客户流失,客户流失分析有助于确定客户流失的原因(和时机),为实施有效的客户保留策略创造机会。这里有 6 个经过时间考验的步骤,确保你专注于留住你的客户——在本文中,我们将只关注第 2 步和第 3 步的部分内容。此时,请记住,这并不是要将客户流失归咎于产品或客户成功团队,而是要制定一个策略来提高客户保持率。

  1. 收集可用的客户行为、交易、人口统计数据和使用模式
  2. 利用这些数据点来预测可能流失的客户群
  3. 创建一个模型,根据客户流失概率来确定业务的风险承受能力。
  4. 设计一个干预模型,考虑干预水平如何影响流失率和客户终身价值(CLV)
  5. 在多个客户群中实施有效的实验,以减少客户流失并提高客户保留率。
  6. 冲洗并重复第 1 步*(认知流失管理是一个持续的过程,不是一年一次的练习)*。

我们还认为,风险分析-决策-市场细分的方法是一个足够通用的结构,可以用于许多业务问题,而不仅仅是流失分析。

等等,这到底是什么?

预测性流失模型是一种简单明了的分类工具:查看过去的用户活动,并检查特定时间后谁是活跃的,然后创建一个模型,从概率上确定客户(或细分市场)离开你的服务或产品的步骤和阶段。

拥有一个预测性的客户流失模型,可以让你在留住客户的过程中获得认知和可量化的指标。这让你有能力了解离开的顾客的习惯,并在他们做出决定之前介入。如果没有这个工具,您将根据广泛的假设行事,而不是根据反映客户真实行为的数据驱动模型行事。

如果没有对客户及其行为的深入了解,就很难留住他们,因此创建该模型的第一步是从客户数据点了解您的客户行为。让我们看看我们需要什么样的数据来评估导致他们最终离开你公司的诱因。

客户信息

  • 邮政区码
  • 收入阶层
  • 性别
  • 职业
  • 他们家里有孩子吗?
  • 他们如何找到你的网站/产品?
  • 他们会打开你的简讯和其他触发邮件或者点击任何链接吗?

产品

  • 产品类型
  • 各种产品
  • 优惠券用法
  • 产品偏好或组合

购买历史

  • 购买频率
  • 上次购买日期
  • 购买的时间/季节
  • 采购价值
  • 支付方式
  • 余额/商店信用

客户互动

  • 服务问题
  • 商店访问/在线
  • 投诉解决方案
  • 投诉优先级
  • 他们如何抱怨——电子邮件、电话还是推特?
  • 投诉频率

**这些只是一些样本领域开始,我们更喜欢。重要的是尽可能多地了解我们的客户,了解是什么事件导致他们离开并寻找下一个竞争对手。**您收集的相关数据越多,您的模型就越精确。如果你使用机器学习支持的客户流失模型,你可以使用比人类可能计算和处理的更多的变量。一旦你在一个地方有了这些不同但相关的客户数据,以便于操作和查询,你就会看到趋势浮现在你的眼前,这将使你对客户流失有所了解。所有被搅动的客户的综合数据也将帮助你对行为进行分组并建立模式。

数据准备

一旦你为你的分析收集了足够的数据,下一步就是数据准备。这是数据分析中最耗时但最重要的一步。就像那句著名的格言所说的那样- “垃圾进来,垃圾出去”。你的分析将和它所基于的数据一样好。

您可以使用这三个标准来确保高质量的数据:

  • 完成
  • 干净的
  • 精确的

完成- 你是否有所有相关的尺寸?有多少百分比的数据缺少值或为空?您可以通过数据探索来填充一些缺失的值,例如,基于客户地址的“州”值;基于产品项目等的“产品类别”。

清除- 同一个维度是否有多个值?例如 CA/Calif/California;医疗保健/医院/提供商;产品名称等的不同缩写。如果是的话,你可以做一些数据清洗来保证一致性。

准确- 某些交易是否存在负收入值或 0 美元收入?;日期冲突;“无”或“不适用”值等。在与风险承担者讨论之后,您可以决定是否在分析中包含或排除这些不良数据。

在预测+诊断分析中,在数据准备中还涉及一个步骤——创建目标变量。在流失分析的情况下,它可以是一个二元列,如*“会流失吗?”*。您可以通过分析历史数据来填写此变量的值。例如,对于取消订阅的客户,值为 1/TRUE,对于续订的客户,值为 0/FALSE。

探索性分析

文末示例实现为技术上倾斜

与传统的统计建模不同,基于机器学习的预测模型是由计算机算法生成的,而不是由统计学家基于他们对线性回归和相关技术的结果的解释来生成的。构建客户流失模型的一个关键技能是能够提出尽可能多的问题。通过这种方式,您可以在实现模型之前测试、重新测试和验证您的假设和数据。以下是一些基本的入门问题。

1。可用数据点与流失之间的相关程度如何?

从这个问题中,可能会找到这样的答案:“在上个季度离开的所有客户中,80%的人在周末提出了投诉”,或者“在上两个季度离开的所有客户中,56%的人从未使用过我们软件中的报告工具”。您的目标是使用这个探索性问题来揭示特定数据点与流失之间的一种或多种关联模式。与此同时,也向当前客户提出同样的问题,看看你的总体假设是否成立,或者它们只是散点图上的随机点:如果你的假设是真实的,那么你已经发现了一个需要关注的趋势,如果不是,继续问更多的问题。

使用机器学习模型还可以向您展示一些人类分析师通常看不到的相关性。

2。他们离开了产品生命周期的哪个阶段?**

这些顾客是什么时候离开的?在第一次试用结束时,当订阅过期时,或者某些功能太难使用,或者它是一个外部事件?他们离开前用了我们的软件多久?他们是不是打电话给客服,不满意就走了?对于没有离开并续订订阅的客户来说,有哪些关键趋势?

继续探索每一个数据点及其比率——机器学习模型通常比人类做得好得多,并发现意想不到的模式。

3。不同客户群对终身价值(LTV)有什么影响?

一个好的模型的结果是找到等同于提高或增加保留率和降低流失率的触发因素和行为。您的每个属性都可以映射到提升或下降商。例如,如果特定细分市场中的每个客户都有 100 美元的 LTV,而您的模型显示其中有 X 人正在离开,那么您可以轻松地突出这种流失对顶线的负面影响,帮助业务领导量化并优先考虑保留策略。

接下来会发生什么..

我们希望您将探索得筋疲力尽,并发现一些有趣的客户流失模式。您可能还发现了一两个高度相关的数据点,或者可能是一个较大的存储桶,其差异不如您预期的那样大。

如果你找不到至少三个高度相关的属性,你就没有对你的数据提出正确的问题,或者也许你一开始就没有正确的数据集。

一旦您确定了导致客户流失的客户群及其行为,您就可以为您的团队提出提高客户保留率的建议。设计、实现和推断智能实验的结果是另一篇文章的主题,但这里有一些快速的想法。

对于一家正在经历低收入人群流失的电信公司来说,他们使用的短信比实际电话更多,这可能是为了建立一个针对该细分市场的利基“计划”,以防止用户转向下一个提供商。

对于一个在线项目管理工具服务来说,在试用期内客户会迅速减少,可以在新客户入职时提供明确的培训课程,使试用期更有吸引力。

示例实现(Kaggle 电信数据集)

为了本文的简单起见,我们将假设数据已经准备好输入预测引擎,并从简单的线性回归模型或逻辑回归模型开始做一些探索性分析。线性回归模型有助于找出哪组独立维度/预测因子擅长预测目标变量。此外,挑选出具有特别强影响力的变量。

这里有一个基于电信 Kaggle 数据集的简单线性回归模型:

lm(Churn ~ International _ Plan+Voice _ Mail _ Plan+Total _ Day _ Charge+Total _ Eve _ Charge+Total _ Night _ Charge+Total _ Intl _ Calls+No _ CS _ Calls+Total _ Intl _ Charge,data = telecom)

客户流失是因变量。自变量后接“~”符号。“电信”是所用数据集的名称。你可以添加/删除自变量,这取决于它如何改变调整后的 R2 值——如果它增加了,它就是一个重要的预测指标;如果它降低了值,您可以将其排除。

输出:

Output of Linear Regression model in R for the dataset analyzed

为了解释哪些属性有很强的影响,我们看一下末尾星号的数量。' —非常显著;'-显著;”重要;'.'没那么重要

我们看到,对于电信业务,像*“客户服务呼叫数量”“国际计划优惠”【国际通话费率】*等在被检查数据集的客户流失中扮演着重要角色。从商业角度来看,这需要进一步调查客户服务信息分析和/或提供有竞争力的计划来保持客户忠诚度。

使用逻辑回归模型也会产生类似的结果:

glm(Churn ~ International _ Plan+Voice _ Mail _ Plan+Total _ Day _ Charge+Total _ Eve _ Charge+Total _ Night _ Charge+Total _ Intl _ Calls+No _ CS _ Calls+Total _ Intl _ Charge+,数据=电信,家庭=二项式)

输出:

Output of Logistic Regression model in R for dataset analyzed

该模型将相同的预测因素视为对“流失”变量的强大影响。当我们使用混淆矩阵计算模型的准确性时,结果是 86.3%。

Confusion Matrix in R

准确率=(真阴性+真阳性)/总记录数

0.8632=(2773+104)/3333

该模型现在已经准备好在测试数据上实现了。在逻辑回归的情况下,这是使用*预测()*函数完成的:

预测(telecomLog,type= "response ",newdata=telecomTest)

在哪里

“telecomLog”是逻辑回归模型。

“远程测试”是测试数据集。

“响应”告诉预测引擎根据概率产生输出,在我们的情况下这是有意义的,因为我们想知道哪些客户具有高流失概率。

Tableau visualization of insights derived from Logistic Regression Model implementation in R. The charts highlight a positive correlation between no. of customer service calls and churn probability as well as a stronger correlation influence of international plans and churn.

现在,我们已经完成了探索性分析,并了解了具有影响的变量,我们可以深入研究基于集合模型的方法。如今,数据科学家正在使用多模型或集成方法来解决预测分析中的复杂业务问题,如客户流失。在这种方法中,在同一数据集上使用两种或更多种算法,比较结果以获得更高的准确性并防止过度拟合。

Ensemble Modeling in Microsoft Azure Machine Learning

在这里,我们已经使用微软 Azure 机器学习在电信 Kaggle 数据集上使用两种算法预测流失:增强决策树和逻辑回归。

集成建模方法的更高精度降低了 误分类率总体错误率

错误分类率是指被识别为高风险客户的客户中有多少人实际上进行了而不是客户流失。通过避免向低风险客户发送特别促销/套餐,并专注于对高风险客户的干预,这可以为企业节省大量资金。下面是集合模型的精度比较:

The ROC curves of Boosted Decision Tree and Logistic Regression models

比较两个模型的 AUC(曲线下面积)值,我们看到两类提升决策树在识别错误分类方面比传统的逻辑回归模型表现得更好。增强决策树模型的错误分类率较低,为 5%,而逻辑回归模型的错误分类率为 16%。因此,通过集成方法,我们可以利用两种模型的优势——逻辑回归模型识别对目标变量有强烈影响的预测因素,而增强决策树更准确地识别高风险搅动者。

总之,预测复杂商业现象的整体方法是传统统计建模和整体建模等前瞻性方法的良好结合。

最后…

如果你真的想做出高质量的、风险可控的、以客户为中心的决策,而这些决策需要依赖于关于世界的结论,而不仅仅是可用的数据,那么你的团队中就需要决策科学家和工程师。客户流失管理对于任何业务都是必不可少的,基于机器学习的算法使其更加准确。如果你正在经营一家企业,但你对自己的流失分析没有信心,也许是时候联系一下决策科学专家 (这是对 电子邮件 美国)

机器学习:预测客户流失

原文:https://towardsdatascience.com/machine-learning-predicting-customer-churn-dd38a42774cf?source=collection_archive---------0-----------------------

这个模型的数据就是从这里得到的。这是一家身份不明的电信公司的客户数据。

用于预测流失的模型是 K 近邻。总体准确率为 90%。根据该模型预测会留下的 10 个客户中有 9 个最终留下,而根据该模型预测会流失的 10 个客户中有 9 个最终流失。

模型

KNN 是一个简单的算法。当出现新客户时,算法会在数据库中查找与目标客户最相似的客户。然后,它会根据那些相似的客户是否会流失来预测客户是否会流失。

其中包括一家电信公司的 976 名客户。其中 125 人被解雇,851 人留下。

为了制作模型,我将数据分成两部分。70%被放入训练集并用于创建模型。然后,该模型被用来预测另外 30%的人是否搅拌。

用于预测客户是否可获得的变量有:

  1. 状态
  2. 账户长度
  3. 电话地区号
  4. 电话
  5. 国际计划
  6. Vmail 计划
  7. 邮件信息
  8. 日分钟
  9. 日间通话
  10. 日间费用
  11. 前夕分钟前夕电话
  12. 前夕费用
  13. 夜晚分钟
  14. 夜间通话
  15. 夜间收费
  16. 国际分钟
  17. 国际呼叫
  18. 国际收费
  19. 客户服务器调用

KNN 只处理数字变量,所以对于这个模型,我将删除所有非数字变量。(有一些使用分类变量的技术,比如一键编码,但是我们在这里忽略它们)。

模特表现如何?结果如下:

Accuracy = 89%

优化模型

89%的初始准确性是不错的,但是如果我们仔细选择 k 值和用于进行预测的变量,模型可以变得更准确。

我最初用的是三的 K。这意味着该模型将寻找三个最相似的客户,并使用它们来预测客户是否会流失。

如果 K 太小,模型会“过拟合”。这意味着该模型将在您用来创建它的数据上表现良好,但当它遇到新的观察结果时,它将表现不佳。如果 K 太高,模型的表现也会很差。K 的最佳值是通过选择一个不太高也不太低的值来选择的。

The Accuracy is highest when k = 5

如上图所示,模型精度稳步增加,直到在 5 处达到峰值,然后开始下降。因此,k 的最佳值为 5。

使用 k = 5 后,模型性能提高到 90%

变量选择

并非所有变量都有助于预测客户是否会流失。例如,客户的电话号码在预测中完全没有用,因为它对每个客户都是唯一的。

一种被称为信息增益的技术被用来观察哪些变量在预测客户流失方面最重要。Information gains 单独查看每个变量,并询问“如果我们单独按该变量分割数据集,预测结果会容易多少”。

这表明客户服务呼叫、呼叫分钟数和使用的信用是最能提供信息的变量。这是可以理解的,一个经常给客服打电话的客户可能对服务不满意,所以更有可能流失。而打很多电话的人可能对服务很满意,因此不太可能流失。所以这三个变量告诉我们很多关于客户流失的可能性。

概率阈值

KNN 给出了特定客户流失的概率。默认情况下,阈值通常设置为 0.5。这意味着任何概率超过 0.5 的人都有可能流失。如果你降低概率阈值,更多的人将被预测流失,这给你更多的“风险客户”的目标。然而,这增加了没有风险的客户通过门槛并被预测为流失的可能性。

概率阈值的选择将基于业务环境,如果公司想要以大量客户为目标,则将设置低阈值。然而,如果公司想更有效地支出,就要设定更高的门槛,以更少的顾客为目标。

业务影响。

有了这个模型,人们可以预测哪些客户有流失的风险。然后,公司可以采取措施留住这些客户,例如:

  1. 客户满意度调查可以发送给“风险客户”,以了解他们对公司的看法以及可能的投诉。
  2. 可以向有风险的客户提供折扣或其他激励措施,以试图留住他们。
  3. 保留营销:处于风险中的客户可以被特别添加到保留营销列表中,以便谷歌广告、脸书、Twitter 或电子邮件活动可以专门针对他们。
  4. 客户流失的可能性低,可以从重新定位名单中删除,这可以节省营销成本。

如果公司对其客户进行了细分,并了解具有最高终身价值的客户类型。那么最有价值的处于风险中的客户就可以用上述技术来专门锁定。

结论。

信息很多,但洞察力很少。一个收集数据并知道如何从这些数据中获得洞察力的公司可以更深入地了解客户。

公司的生死取决于他们的客户,真正以客户为中心意味着了解你的客户,并以独特的方式对待每一个客户,尤其是最有价值的客户。关于你的客户的大量可用数据。没有理由以一刀切的方式对待所有顾客。

如果你在经营一家新公司,你想更多地了解你的客户。了解你最有价值的客户的特征,找出你的风险客户,或者学习如何正确地收集和分析关于你的客户的数据。在 sayhello@techinnover.com 打电话给我,或者在这里拜访我们

P.p.s 模型是在 R 中构建的,如果你想要一个包含所有代码的脚本,你可以在 twitter 上 DM 我 德林·阿德巴约

机器学习快速参考卡

原文:https://towardsdatascience.com/machine-learning-quick-reference-card-cf92f6accd08?source=collection_archive---------4-----------------------

监督和非监督机器学习

在我最近的几篇帖子中,我讨论了一些我在工作中经常使用的算法。然而,最重要的问题是何时使用这些算法。做事没有唯一正确的方法。您可以尝试不同的算法,通过模型比较来看看哪种算法最适合您的情况。

然而,拥有一张快速参考卡有助于缩小选择范围和做出决定。这也意味着这张参考卡做了一些概括/简化,但它为你指明了正确的方向。

你可以在这里下载这张参考卡。

希望你喜欢这篇文章。敬请关注下一篇文章,了解更多机器学习基础知识。

快乐学习!

机器学习:岭回归详解

原文:https://towardsdatascience.com/machine-learning-ridge-regression-in-detail-76787a2f8e2d?source=collection_archive---------9-----------------------

因为这里已经有足够多的关于线性回归的文章了,我就不再写了。相反,我将写一种标准化的回归类型——岭回归——它解决了数据过度拟合的问题。

岭回归的动机

线性回归模型由以下等式给出:

**Y = Σ WⱼHⱼ(Xᵢ)**Here, 
**Σ** runs from *j = 0* to *j = D* where D is the total number of features.
**Wⱼ** is the *jᵗʰ* coefficient 
**Hⱼ** is the *jᵗʰ* feature function which takes **Xᵢ** observation
**Xᵢ** is the *iᵗʰ* observation

假设我们知道 W 系数的值,上面的等式给出了预测值。为了简化,让我们用𝔽( X 来表示上面的方程,其中 x 是观测值。

线性回归模型的成本函数由以下等式给出:

Cost Function = **RSS(W) = Σ [Yᵢ — 𝔽(Xᵢ)]²**
Here,
**Σ** runs from *i=0* to *i = N* where *N* is the total number of observations.
**Yᵢ** is the known value of *iᵗʰ* observation.
**𝔽(Xᵢ)** gives the predicted value of *iᵗʰ* observation.RSS stands for Residual Sum of Squares

代价函数总是作用于训练数据集。

线性回归模型的整个思想围绕着最小化上述成本函数值。成本函数值越低,线性回归模型越好。

通常,为了降低成本函数,我们增加模型中的特征数量。随着我们不断增加模型中的特征,模型开始很好地拟合训练数据集,并且成本函数值开始降低。

但是,随着特征数量的增加;我们的方程变成了一个高阶多项式方程;这导致了数据的过度拟合。

为什么数据过度拟合不好? 在过度拟合的模型中,训练误差几乎为零,这意味着模型在训练数据集上运行良好。但是,除了像真实的外部世界数据那样的训练数据集之外,这个模型在其他数据集上也能很好地工作吗?
通常可以看出,过度拟合的模型在测试数据集上表现较差,并且还观察到过度拟合的模型在额外的新测试数据集上表现较差。

Overfitted data & performing worse on test data set. Source

从上面的图表中,我们可以看到过拟合模型在训练数据集上表现良好,并且训练数据集的成本函数为零。

但是当我们用上图中的测试数据集测试这个模型时,模型的表现一点也不好。对于测试数据,模型预测错误值与实际正确值相差甚远。这足以说明这种型号不适合在工业上使用。

如何抓过拟合? 通过可视化模型(如上),可以很容易地看到模型中的过度拟合(观察模型如何很好地拟合训练数据集)。但是,随着我们的模型的复杂性增加,它进入了更高维度,这使得它很难在图表(或其他工具)上可视化。

除了总是试图可视化模型,我们还可以通过查看系数的值( W )来查看过拟合。通常当过拟合发生时,这些系数的值变得非常大。

岭回归用于通过测量系数的大小来量化数据的过度拟合。

要修复过度拟合的问题,我们需要平衡两件事:
1。函数/模型符合数据的程度。
2。系数的大小。

So,
Total Cost Function = Measure of fit of model + Measure of magnitude                    of coefficientHere,
Measure of fit of model = RSS(W)
Measure of magnitude of coefficient = ||W||²If Measure of fit of the model is a small value that means model is well fit to the data.
If Measure of magnitude of coefficient is a small value that means model is not overfit.**Total Cost Function = RSS(W) + λ*||W||²**We have added **λ** in total cost function as a tuning parameter to balance the fit of data and magnitude of coefficients.

计算岭回归的梯度下降

岭回归成本= RSS(W)+λ* | | W | | =(Y-WH)*(Y-WH)+WW

在矩阵符号中,它将被写成:
岭回归成本= (Y - HW)ᵗ (Y - HW) + WᵗW

取上述方程的梯度(微分):

Δ[RSS(W) + λ||W||]²
= Δ{(Y - HW)ᵗ(Y - HW)} + λ Δ{WᵗW}= -2Hᵗ(Y - HW)+2λW

设置上面的梯度为 0,我们得到

**W = (HᵗH + λI)-¹HᵗY**

因此,我们知道了 W 系数的值。

λ值怎么选?

给定的数据集分为三组:
1。训练装置
2。验证集
3。测试装置

Division of data into three different sets

训练集 该数据集将用于获取λ的每个值的 W 系数的值。让我们假设λ值的每个值的 W 系数的值为 W λ。

验证集 将在验证集上评估 W λ的不同值。具有较低误差值的那个将被选择。

测试集 测试数据集将再次评估 W 系数的选定值。

上述方法仅在存在足够数量的数据时使用。

这就是最终选择λ值的方法。这个过程有点暴力。但是利用聪明的猜测和经验,可以减少猜测λ值的迭代。

结论

我们已经看到为什么过拟合在机器学习中是不好的,以及如何通过查看模型的 W 系数的值在模型中识别它。然后,我们看到了线性回归的新成本函数,它考虑了带有调整参数λ的数据的过度拟合。

然后,我们看到了关于新成本函数的计算公式 W 以及如何选择λ的值。

简而言之,机器学习规则

原文:https://towardsdatascience.com/machine-learning-rules-in-a-nutshell-dfc3e6839163?source=collection_archive---------11-----------------------

几天前,谷歌工程师发布了一本关于如何构建伟大的 ML 产品的巨大手册(顺便说一下,还有 great】的 tensor flowcoursera 的专业化)。这些人在生产中开发大规模项目方面有很多经验,他们已经写下了他们的最佳实践。唯一的问题是——这份文件实在庞大,所以我决定在这里总结一下要点。共有 43 条规则,大致按照发展阶段的顺序,分为 3 个阶段。我们开始吧。

0.不谈人工通用智能。ML 工程师可能会误解你,认为你有精神分裂症。开玩笑的。

第一阶段:第一条管道

  1. 毫不犹豫地推出没有 ML 的产品。如果一个简单的启发式或手工工作可以完成这项工作——把 ML 放在一边,直到你得到足够的数据。
  2. 添加指标。然后添加更多指标。跟踪一切,了解应用程序的各个部分是如何工作的。当您有问题或不确定时,添加一个指标。
  3. 不要在启发式上投入太多时间。一旦它变得复杂——切换到 ML 模型。以后开发和维护会更容易。
  4. 先关注基础设施。用一个简单的模型建立一个管道,并确保整个系统运行良好。
  5. **为你的每一个管道添加测试。**测试您的基础设施,测试您的数据,测试您的模型。
  6. 当您为新项目复制现有管道时,确保您没有丢弃潜在有用的数据
  7. 不要简单地抛弃你的启发法。它们可能会为您的 ML 模型生成有用的特性。
  8. 保持模型新鲜。跟踪模型的性能随着时间的推移下降了多少,并确保它不会在生产中变得糟糕。
  9. 在投产前跟踪你的模型的性能。尤其是当它是面向用户的模型时。
  10. 再次测试你的数据。确保所有特征都已收集,数据完好无损。
  11. 创建特征文档。它们从哪里来,为什么有用。
  12. 选择正确的目标。它必须反映你项目主要目标的表现。
  13. 选择正确的目标可能很难,所以选择一个易于衡量并且代表“真实”目标的指标。
  14. 简单的模型更容易调试。线性或逻辑回归可能是一个不错的选择。
  15. **将垃圾邮件过滤和质量排名分开。**此类模型通常以不同的方式使用。

阶段 2:特征工程

  1. **计划迭代。**您的功能和模型会随着时间的推移而发展,所以请确保您准备好更新它。
  2. **从直接观察到的特征开始。**并将学到的功能留给未来更新。
  3. 尝试跨环境通用的功能。像点赞数这样的指标可能在推荐、质量排名和其他模型中有用。
  4. 不要忘记添加非常具体的功能。即使没有很好地概括,它们仍然有价值。如果它们只适用于一小部分例子,正则化会把它们过滤掉。
  5. 以人类可理解的方式从现有功能中手工制作新功能。试着不要想太多。
  6. 在线性模型中可以学习的特征权重的数量大致与你拥有的数据量成正比。只有大约 1000 个例子——使用几十个特征。拥有超过 10 亿个功能,1000 万个就足够了。
  7. **从管道中移除不使用的特征。**如果你发现某个特性不能改善你的模型,那就去掉它。
  8. 不要让工程师做 UX 测试。通过众包平台,或者通过真实用户的现场实验来做。
  9. **追踪不同型号之间的差异。**在进一步测试一个新模型之前,计算一下它的输出与以前的有多大的不同。
  10. 关注你的模型的效用,而不是预测能力。一个新的模型可能有更高的准确性,但它在实践中有多有用更重要。
  11. 查看模型的错误,并创建新的特征来修复它们。尝试在错误中寻找模式,并添加各自的特征。
  12. 创建指标来跟踪这些错误。有了要优化的指标,优化就变得更容易了。
  13. 模型在长期中可能会有非常不同的行为。即使在短期内,它看起来完全符合你的预期。
  14. **实时收集数据,并在培训期间使用它来测试模型。**通过这种方式,您可以确保模型在部署后运行良好。
  15. 重要性-权重采样数据,不要随意丢弃。
  16. 不要忘记,在培训和服务期间,数据本身可能会发生变化。然而,有时你可以使用每小时/每天/每周的快照来处理它。
  17. 在培训和生产管道之间共享代码。尽可能多。
  18. 使用早期数据进行训练,使用后期数据进行测试。这将有助于您粗略估计您的模型在未来的表现。
  19. **在二分类任务中拿出一小部分例子,得到干净的训练数据。**向用户展示其中的 1%或 0.1%,以获得新的训练数据。
  20. **更严格地规范一般特征,在任务排名中只允许正权重。**不要让你的排名系统变得太偏。
  21. **避免带有位置特征的反馈循环。**训练时分开,发球时避开。
  22. 衡量您的模型在训练、验证、测试和实时数据方面的表现。跟踪它们之间的差异,并尝试进一步调整模型以减少差异。

阶段 3:细化和复杂模型

  1. 重新审视你的目标。确保它符合您的产品目标。
  2. **发布决策代表长期产品目标。**通常一个决策会影响多个指标,所以不要急于做出快速决策。
  3. **将你的基本款和套装款分开。**基本模型仅获取原始输入,集合仅获取基本模型的输出。
  4. **当你的性能停止增长时,寻找新的特性来源。**不要太长时间专注于现有的。
  5. 多样性、个性化和相关性非常重要。但没有受欢迎程度高。
  6. 在不同的产品中,你的朋友往往是一样的。你的兴趣不是。我们倾向于拥有相同的联系,但是我们的目标不同。

我认为在从事 ML 项目时有这些指导方针是很好的。因为如果你不会,你就很有可能陷入技术债。所以,别忘了把它们收藏起来,在工作中不时重温。

机器学习——一些骨骼

原文:https://towardsdatascience.com/machine-learning-some-bones-dc5987c81cd2?source=collection_archive---------1-----------------------

机器学习是一个松散的术语,它涵盖了许多活动。从软件工程的角度来看,它可以被看作是从模式识别发展而来的活动。它甚至可以更狭义地理解为给定输入值分配一个标签。一个被设计成从例子中学习的系统将包含一个分类器,该分类器将数据作为输入,并将一个标签分配给它作为输出。

X = np.array([[1,2],[5,8],[1.5,1.8],[8,8],[1,0.6],[9,11]])
y = [0,1,0,1,0,1]
clf = svm.SVC(kernel='linear', C = 1.0)
clf.fit(X,y)
**print**(clf.predict([0.58,0.76]))

以上是使用 SciKit-Learn 库用 python 编写的机器学习程序的源代码。其实没什么大不了的!下面是计算一个数的平方根的 python 函数。

math.sqrt( x )

像所有的工具集一样,SciKit-learn 为开发人员、程序员和数据分析师提供了多种功能的组合。它是一种综合性的机器学习技术,旨在进行数据挖掘和数据分析。它自己工作得很好。它与张量流等其他技术配合得很好。它在其他程序中运行良好。

作为开发人员,我们经常使用许多工具,上面显示的例子是 python 内置的数学函数。我们可以在不知道它是如何工作的情况下使用该工具进行数学运算。我举的计算一个数的平方根的例子比我们想象的要复杂,但我们经常认为这是理所当然的,这并不妨碍我们胜任地使用它。剥一只猫的皮有许多方法,计算机程序和计算器也有许多方法找到一个数的平方根

在开发软件时,了解您所使用的技术工具的基本框架确实会有所帮助。看到功能背后的内部结构,了解输入和输出之间的关系,了解正在发生的事情。我可以通过观察、代码片段、图表、公式和数学来理解这些复杂的东西。这篇文章虽然本质上是技术性的,却以轻浮的方式掠过了机器学习的表面。更全面的解释是存在的,我推荐三个:

神经网络黑客指南作者安德烈·卡帕西

大脑 vs 深度学习第一部分:计算复杂性——或者为什么奇点离很远

神经网络和深度学习作者迈克尔·尼尔森

为什么要使用机器学习?

有些事情计算机程序做得很好,但对人类来说很难。从简单的计算,如平方一个数字;

**static** **void** main(String[] args) {
      **int** x = 5;
      x = x*x;
      System.out.println("x = " + x);
 }
}
x = 25

…稍微难一点的计算;

**public** **class** Main {
   **public** **static** **void** main(String[] args) {
      **double** x = 38.75645;
      x = x*x;
      System.out.println("x = " + x);
   }
}
x = 1502.0624166025

…到更复杂的过程,例如求一个数的平方。

虽然求一个数的平方很简单,但是求一个数的平方根的问题涉及更复杂的数学。

如同

可以用下面的等式来表示

有许多算法可以用来寻找答案。牛顿发现的巴比伦方法就是一个例子;

在 Javascript 中调用诸如 Math 函数这样的编程函数要容易得多;

var y = Math.sqrt(16);      // Returns the square root of 16, y = 4

编程语言使计算机能够很好地完成计算和数学等工作。然而,有些事情人类做得很好,而计算机却不擅长。计算机做得不太好的一个例子可能是基于不同的输入或理解语音做出决定。

机器很难像我们自然说话和打字那样理解语音和文本。人工神经网络(ANN)是克服这个问题的一种方法。为了理解他们如何克服这个问题,看看人工神经网络与传统的计算机程序有何不同是很有用的。

传统的程序通过使用中央处理器、读取指令和使用存储在特定地址的数据来遵循预定的程序而工作。不管它是否被写入;过程的、面向对象的或任何其他类型的语言。

运行一位代码,例如一个函数,会产生一个输出。编程语言倾向于运行一个进程,然后继续下一个进程。一个函数的结果导致另一个函数被调用。虽然一些程序允许并行过程同时运行,并且大体上重复过程,但是有一个逻辑流程,一件事情接着另一件事情。

大多数程序遵循相当复杂的指令,由许多相互联系的子程序组成,它们遵循一个可能有许多路径的逻辑流程。每一个岔路口和每一条路径都必须明确地写下来,复杂的决策需要复杂的指令。

The UML CI

神经网络的工作方式与当前大多数计算机程序不同。顾名思义,它们由神经元组成。

神经元的输出可以表示为

或者

在这些等式中,W 是神经节点的权重向量,定义为

X 是输入向量,定义为

它们不通过使用中央处理器运行代码分支系统来处理一组复杂的编程指令。相反,它们使用输入的加权和来执行大量非常简单的程序,通常跨越大量处理器。

这些简单程序的网络提供了一个结果,可以适应微妙的变化,并对不太确定的信息做出反应。网络可以归纳并发现可能隐藏的模式。从这个意义上来说,它的工作方式与以其命名的生物模型相似。

计算过程

感知器

为了开始说明计算过程,我们将看一个非常简单的神经网络的例子。它是 60 多年前首次发明的,是一种感知机。它是一个“前馈”模型;输入被送入神经元,经过处理,然后输出。感知器从计算其输入的加权和开始

Activation function

感知器有五个部分:

  1. 输入:X1,X2
  2. 重量:W1 W2
  3. 潜力:

其中,μ为偏置。

4.激活函数: f(z)

5.输出:y = f(z)

我们可以让感知机给我们一个问题的答案,这个问题有三个影响结果的因素。比如“这是美食吗?”。决定好坏的因素有:

“对你有好处吗?”
“好吃吗?”
“好看吗?”

我们给所有的问题和答案一个数值。我们给每个问题一个值,在这个例子中是一个布尔值,是或否,1 或 0。我们给答案取相同的值,好吃的= 1,不好吃的=-1。

我们收集一些数据,并把它们转换成数字。

现在我们假设“对你有益”是最重要的因素,但是味道和外观也会影响答案。我们会考虑每个因素的重要性,并给予相应的权重。

让我们向我们的感知器传递三个输入

Input_0: x1 = 0
Input_1: x2 = 1
Input_2: x3 = 1

我们要做的下一件事是给这些问题一些权重,我们假设它们在重要性上是不一样的。我们猜测它们有多重要。

Weight_0: x1 = 6
Weight_1: x2 = 4 
Weight_2: x3 = 2

输入乘以权重

Input_0 * weight 0: 0 * 6 = 0
Input_1 * weight 1: 1 * 4 = 4
Input_1 * weight 1: 1 * 2 = 2

下一步是对所有输入和权重求和

output = sum(0+4+2) = 6

神经元的输出由加权和是否

小于或大于阈值。就像权重一样,阈值是一个实数,它是神经元的一个参数。

下面是用于计算神经元输出的等式;

阈值用于确定神经元是否激活。

因此,将所有输入值和权重相加,我们的单细胞感知机会告诉我们什么是“好食物”。因为我们知道问题的答案,所以我们可以用答案来调整

现在所有这些都是非常基本的,很容易编写几行代码来计算出我们有三个条件,它们有一个值并经过加权,根据我们的阈值测量输出,然后它可以决定是真还是假。

人工神经网络的力量来自于大量神经元的联网。添加更多的输入和使用更多的层,我们可以为影响决策的因素添加微妙的值。更好的是,我们可以让网络学会调整这些因素。

人工神经网络

使用线性回归训练网络。

单层单神经元网络(使用线性激活函数)接收具有两个特征 x1 和 x2 的输入;每个都有重量。网络将输入和权重相加,然后输出预测。计算差值以测量误差,显示它在所有训练数据上的表现如何。

首先让我们看一个简单的问题。

我们使用一个网络来改变输出,因为我们想要一个比-6 稍大的数字。我们在网络中前进,猜测 x 和 y 的值会给我们一个很好的拟合。

当我们试图回答少量数据中的几个问题时,这种方法非常有效。

数字梯度

我们可以不简单地调整单个输入的权重,而是着眼于输出的导数来改变两个或多个输入。通过使用导数,我们可以用输出来降低一个输入,增加另一个输入。导数的数学表示可以是

激活

人工神经网络通过神经元网络并行地集体处理信息。每个神经元本身就是一台简单的机器。它读取输入,处理输入,并生成输出。它通过获取一组加权输入,用一个函数计算它们的总和来激活神经元

以及将激活功能的输出传递给网络中的其他节点。

因为激活函数采用两个(相同长度的)数字序列(向量)来返回一个数字。该运算可以表示为(代数形式)。

下面是线性激活函数的表达式

具有产生单一输出的线性特征的系统的模型表示为

神经网络的一个特征是它的学习能力,所以它们可以很舒服地放在机器学习的标题下。该网络可以形成一个灵活且能适应的复杂系统。它可以根据得到的信息修改其内部结构。换句话说,它从接收到的信息中学习,并将其作为输出进行处理。在人工神经网络中,分类器试图识别网络中的错误,然后调整网络以减少这些错误。

一般来说,一个网络从一个输入和一个已知的输出中学习,所以我们可以给出成对的值(x,y ),其中 x 是输入,y 是已知的输出

pairs = ((x=5,y=13),(x=1,y=3),(x=3,y=8)),…,((x= < em > n < /em >,y =N2))

目的是找到最接近训练数据的权重(w)。一种测量拟合度的方法是通过将 M(w) 的值减小到最小值来计算数据集上的最小误差。

在本系列的下一篇文章中,我将更深入地探讨反向传播,以及为什么通过查询函数对数据进行分类可以产生自然语言界面,从而彻底改变分析和商业智能。

首次发布【2016 年 5 月 30 日

机器学习解决假新闻问题

原文:https://towardsdatascience.com/machine-learning-tackles-the-fake-news-problem-c3fa75549e52?source=collection_archive---------14-----------------------

我最近有机会使用机器学习来解决美国媒体最前沿的一个问题,即识别假新闻的困难。具体来说,我的同学 David Masse 和我应用了两种 ML 方法来识别故意误导的新闻文章:逻辑回归和朴素贝叶斯分类器。使用包含 20,000 篇带标签文章的 kaggle 数据集,我们在预测测试集的标签时达到了 93%的准确率。这是练习自然语言处理以及构建强大分类模型的一些有效技术的绝佳机会。

自然语言处理是计算机科学领域,致力于处理和分析任何形式的自然人类语言(书面、口头或其他)。简单来说,计算机理解 0 和 1,而人类使用广泛的语言进行交流。NLP 旨在弥合这两个世界之间的差距,以便数据科学家和机器学习工程师可以分析大量的人类通信数据。

在假新闻问题的背景下,NLP 允许我们将文章分解成它们的组成部分,并选择重要的特征。然后,我们构建并训练模型来识别不可靠的文档。

清理时间!

对于许多数据驱动的项目来说,探索之后的首要任务是清理数据。我们正在处理来自各种来源的数千篇文章,有些文章比其他文章干净得多。正则表达式提供了一种限制我们允许包含在分析中的字符串类型的方法。例如,这行代码使用了 re python 模块:

clean _ article = re.sub("[^a-za-z0–9']",' ',文章)

用空格替换所有非字母数字字符。^表示我们要替换的是指定集合的补集。一旦我们删除了不需要的字符,我们就可以进行标记化和矢量化了!

Scikit-learn 是一个令人难以置信的 python 机器学习包,它完成了大量繁重的工作。特别是,计数矢量器创建一个包含所有被分析文本的完整词汇表,并将每个文档转换成一个表示每个单词总计数的矢量。这将以稀疏矩阵的形式返回向量,因为大多数文章不包含大多数单词。矢量器允许集成预处理函数,以及您的首选标记器。

An example of vectorized articles, each row contains the occurrences of our initial 1000 feature words

在新闻分析的情况下,单独考虑每个单词过于简单,因此我们的矢量化允许双词或两个单词的短语。我们将特征的数量限制为 1000,因此我们只考虑将文档分类为真实或伪造的最重要的特征。

特征工程

特征工程与其说是简单的技术,不如说是一种复杂的艺术形式。它包括考虑数据集和属性域、决定最适合您的模型的功能以及最终测试您的功能以优化您的选择的过程。Scikit-learn 的矢量器提取了我们的 1000 个基本 n-gram 特征,我们开始添加元特征来完善我们的分类。我们决定计算每个文档中的平均单词长度和数值数量,这提高了我们的模型的准确性。

Left: Aggregate features, Right: Sentiment scores

情感分析代表了 NLP 的另一种分析工具,为文本主体中表达的一般情感分配数值。我们使用了两个软件包,TextBlob 和自然语言工具包的 Vader。这些都是对文本文档进行开箱即用情感分析的好工具。Vader 产生了衡量极性和中性的各种分数,而 TextBlob 提供了总体主观性以及它自己的极性衡量标准。我们原本希望,当计算误导性和真实的文章时,这些情绪的分布会非常不同,但是我们发现情况并非如此。

The distribution of neutral article sentiment via Vader, where 0 is fully neutral

TextBlob Sentiment Scores (left: -1 polarity is negative and 1 is positive, right: 0 is very objective and 1 is very subjective)

从上面可以看出,仅仅从情感得分上看,很少有洞察力。然而,我们决定将它们保留在我们的模型中,因为当与我们的分类器结合时,它们会增加准确性。

逻辑回归

我们在这里考虑的系统是二进制的,其中只有类是真的和假的。考虑到文章的相关特征,我们需要对文章不可靠的概率进行建模。这是多项式逻辑回归的完美候选,我们的模型依赖于 logit 变换和最大似然估计来模拟与预测变量相关的不可靠性概率。

换句话说,LR 直接计算后验 p(x|y ),学习将哪些标签分配给哪些特征输入。这是一个判别方法的例子,虽然这在技术上不是一个统计分类,但它给出了我们用来赋值的类成员的条件概率。SciKit-Learn 的逻辑回归模型提供了一种简单的方法来实现这一点。

Left: ROC curve for the logistic regression. Right: 20 of the top features for the regression.

朴素贝叶斯分类器

我们的第二种方法是使用朴素贝叶斯(NB)算法,尽管它很简单,但对于这个应用程序来说效果很好。假设特征之间独立,NB 从每个标记的文章中学习联合概率 p(x,y)的模型。然后使用贝叶斯规则计算条件概率,根据最大概率分配标签,从而进行预测。相比之下,这是一个生成分类器的例子。

Bayes Classifier, using MAP decision rule

在这种情况下,我们考虑一个多项式事件模型,它最准确地代表了我们的特征的分布。正如预期的那样,结果与逻辑拟合获得的结果非常接近。

Left: ROC curve for the Multinomial Naïve Bayes. Right: 20 of the top features for the Naïve Bayes Classifier.

最后

使用机器学习可以有效地识别假新闻形式的错误信息的存在。即使没有上下文信息,如标题或来源,正文也足以做到这一点。因此,这些策略可以很容易地应用于其他没有附加描述符的文档。虽然情感特征本身不足以用于假新闻分类,但当与其他特征结合时,它们确实提高了我们的分类器性能。未来的工作可以与其他流行的模型进行比较,如支持向量机。

关于这两种方法之间关系的进一步阅读要感谢吴恩达和迈克尔·乔丹博士:

[## 判别型与生成型量词的比较——逻辑回归和朴素贝叶斯的比较

神经信息处理系统电子会议录

papers.nips.cc](http://papers.nips.cc/paper/2020-on-discriminative-vs-generative-classifiers-a-comparison-of-logistic-regression-and-naive-bayes)

机器学习—文本处理

原文:https://towardsdatascience.com/machine-learning-text-processing-1d5a2d638958?source=collection_archive---------0-----------------------

文本处理是许多 ML 应用程序中最常见的任务之一。下面是这种应用的一些例子。

• **Language Translation: Translation of a sentence from one language to another.**• **Sentiment Analysis: To determine, from a text corpus, whether the  sentiment towards any topic or product etc. is positive, negative, or neutral.**• **Spam Filtering:  Detect unsolicited and unwanted email/messages.**

Courtesy (sigmoidal)

这些应用程序处理大量文本来执行分类或翻译,并且涉及大量后端工作。将文本转换成算法可以消化的东西是一个复杂的过程。在本文中,我们将讨论文本处理中涉及的步骤。

步骤 1:数据预处理

  • 标记化—将句子转换成单词
  • 删除不必要的标点、标签
  • 删除停用词—常用词,如“the”、“is”等。它们没有特定的语义
  • 词干—通过删除不必要的字符(通常是后缀)来消除词形变化,从而将单词简化为词根。
  • 词汇化——通过确定词类和利用语言的详细数据库来消除屈折的另一种方法。
The stemmed form of studies is: studi
The stemmed form of studying is: studyThe lemmatized form of studies is: study
The lemmatized form of studying is: study

因此,词干化和词元化有助于将像“研究”、“学习”这样的词简化为普通的基本形式或词根“学习”。关于词干化和词汇化的详细讨论,请参考这里的。请注意,并非所有步骤都是强制性的,这取决于应用程序的使用情形。对于垃圾邮件过滤,我们可能会遵循上述所有步骤,但可能不会考虑语言翻译问题。

我们可以用 python 做很多文本预处理操作。

  • NLTK——自然语言工具包是最著名和最常用的 NLP 库之一,可用于从标记化、词干提取、标记、解析等各种任务
  • BeautifulSoup —用于从 HTML 和 XML 文档中提取数据的库
#using NLTK library, we can do lot of text preprocesing
**import nltk
from nltk.tokenize import word_tokenize**
#function to split text into word
**tokens = word_tokenize("The quick brown fox jumps over the lazy dog")
nltk.download('stopwords')
print(tokens)**

OUT: ['The ',' quick ',' brown ',' fox ',' jumps ',' over ',' The ',' lazy ',' dog']

**from nltk.corpus import stopwords
stop_words = set(stopwords.words(‘english’))
tokens = [w for w in tokens if not w in stop_words]
print(tokens)**

OUT: ['The ',' quick ',' brown ',' fox ',' jumps ',' lazy ',' dog']

#NLTK provides several stemmer interfaces like Porter stemmer, #Lancaster Stemmer, Snowball Stemmer
**from nltk.stem.porter import PorterStemmer
porter = PorterStemmer()
stems = []
for t in tokens:    
    stems.append(porter.stem(t))
print(stems)**

OUT: ['the ',' quick ',' brown ',' fox ',' jump ',' lazi ',' dog']

步骤 2:特征提取

在文本处理中,文本中的词代表离散的、分类的特征。我们如何以一种算法可以使用的方式对这些数据进行编码?从文本数据到实值向量的映射称为特征提取。用数字表示文本的最简单的技术之一是单词包。

单词包(BOW): 我们在称为词汇的文本语料库中制作唯一单词的列表。然后,我们可以将每个句子或文档表示为一个向量,每个单词用 1 表示存在,用 0 表示不在词汇表中。另一种表示可以是计算每个单词在文档中出现的次数。最流行的方法是使用术语频率-逆文档频率(TF-IDF) 技术。

  • 术语频率(TF) =(术语 t 在文档中出现的次数)/(文档中的术语数)
  • 逆文档频率(IDF) = log(N/n),其中,N 是文档的数量,N 是术语 t 出现过的文档的数量。罕见词的 IDF 很高,而常用词的 IDF 可能很低。从而具有突出不同单词的效果。
  • 我们计算一项的 TF-IDF 值为= TF * IDF

让我们举一个例子来计算文档中一个术语的 TF-IDF。

Example text corpus

**TF('beautiful',Document1) = 2/10, IDF('beautiful')=log(2/2) = 0
TF(‘day’,Document1) = 5/10,  IDF(‘day’)=log(2/1) = 0.30

TF-IDF(‘beautiful’, Document1) = (2/10)*0 = 0
TF-IDF(‘day’, Document1) = (5/10)*0.30 = 0.15**

正如你在文献 1 中看到的,TF-IDF 方法对“美丽”一词进行了严重的惩罚,但对“天”赋予了更大的权重。这是由于 IDF 部分,它赋予不同的单词更大的权重。换句话说,从整个语料库的上下文来看,“day”是 Document1 的一个重要单词。Python scikit-learn 库为文本数据挖掘提供了高效的工具,并提供了在给定文本语料库的情况下计算文本词汇 TF-IDF 的函数。

使用 BOW 的一个主要缺点是它放弃了单词顺序,从而忽略了上下文,进而忽略了文档中单词的含义。对于自然语言处理(NLP ),保持单词的上下文是最重要的。为了解决这个问题,我们使用另一种叫做单词嵌入的方法。

**单词嵌入:**它是一种文本表示,其中具有相同含义的单词具有相似的表示。换句话说,它在一个坐标系统中表示单词,在该坐标系统中,基于关系语料库的相关单词被放置得更靠近。

让我们讨论一些众所周知的单词嵌入模型:

Word2Vec

Word2vec 将大量文本作为其输入,并产生一个向量空间,每个唯一的单词在该空间中被分配一个相应的向量。单词向量被定位在向量空间中,使得语料库中共享共同上下文的单词在空间中彼此非常接近。Word2Vec 非常擅长捕捉意思并在任务中展示它,如计算类比问题,形式为 ab 如同 c 对*?。比如之于如同之于?* ( 大妈)使用基于余弦距离的简单矢量偏移方法。例如,以下是说明性别关系的三个单词对的向量偏移量:

vector offsets for gender relation

这种矢量构图也让我们回答“国王—男人+女人=?”提问并得出结果“女王”!当你想到所有这些知识仅仅来自于在上下文中查看大量单词,而没有提供关于它们的语义的其他信息时,所有这些都是非常了不起的。更多详情请参考这里

手套

单词表示的全局向量或 GloVe 算法是对 word2vec 方法的扩展,用于有效地学习单词向量。GloVe 使用跨整个文本语料库的统计来构建显式的单词上下文或单词共现矩阵。结果是一个学习模型,它通常可以产生更好的单词嵌入。

考虑下面的例子:

*目标词:*冰、
蒸汽、*探测词:*固体、气体、水、时尚

P(k|w) 为单词 k 在单词 w 的上下文中出现的概率。考虑一个与强相关,而与不相关的词,比如P(固|冰)会比较高, P(固|汽)会比较低。因此 P(固体|冰)/ P(固体|蒸汽)的比值将会很大。如果我们取一个与蒸汽相关而与不相关的词,比如气体,那么 P(气体|冰)/ P(气体|蒸汽)的比值反而会很小。对于一个既与又与蒸汽相关的词,比如我们预计比率接近 1。更多详情请参考此处的

单词嵌入将每个单词编码到一个向量中,该向量捕获文本语料库中单词之间的某种关系和相似性。这意味着甚至像大小写、拼写、标点符号等单词的变化都会被自动学习。反过来,这可能意味着可能不再需要上述的一些文本清理步骤。

步骤 3:选择 ML 算法

根据问题空间和可用数据,有多种方法为各种基于文本的应用程序构建 ML 模型。

用于垃圾邮件过滤的经典 ML 方法,如“朴素贝叶斯”或“支持向量机”已被广泛使用。深度学习技术正在为情感分析和语言翻译等 NLP 问题提供更好的结果。深度学习模型的训练非常慢,并且已经看到,对于简单的文本分类问题,经典的 ML 方法也以更快的训练时间给出类似的结果。

让我们使用到目前为止讨论的技术,在 IMDB 电影评论数据集上构建一个情感分析器

下载 IMDb 电影评论数据

IMDB 电影评论集可以从这里下载。这个用于二元情感分类的数据集包含用于训练的 25,000 条高度极性的电影评论,以及用于测试的 25,000 条评论。这个数据集被用于非常受欢迎的论文‘学习用于情感分析的词向量’

预处理

数据集被结构化为测试集和训练集,每个都有 25000 个文件。让我们首先将文件读入 python 数据帧,以便进一步处理和可视化。测试和训练集被进一步分成 12500 个“正面”和“负面”评论。我们阅读每个文件,并将负面评价标记为“0 ”,正面评价标记为“1”

#convert the dataset from files to a python DataFrame**import pandas as pd
import os****folder = 'aclImdb'****labels = {'pos': 1, 'neg': 0}****df = pd.DataFrame()****for f in ('test', 'train'):    
    for l in ('pos', 'neg'):
        path = os.path.join(folder, f, l)
        for file in os.listdir (path) :
            with open(os.path.join(path, file),'r', encoding='utf-8') as infile:
                txt = infile.read()
            df = df.append([[txt, labels[l]]],ignore_index=True)****df.columns = ['review', 'sentiment']**

让我们将收集的数据保存为。csv 文件供进一步使用。

Five reviews and the corresponding sentiment

要获得文本中单词的频率分布,我们可以利用nltk.FreqDist()函数,该函数列出了文本中使用最多的单词,提供了文本数据中主要主题的大致概念,如以下代码所示:

**import nltk
from nltk.tokenize import word_tokenize****reviews = df.review.str.cat(sep=' ')****#function to split text into word
tokens = word_tokenize(reviews)****vocabulary = set(tokens)
print(len(vocabulary))****frequency_dist = nltk.FreqDist(tokens)
sorted(frequency_dist,key=frequency_dist.__getitem__, reverse=True)[0:50]**

这给出了文本中使用的前 50 个单词,尽管很明显,一些停用词,如the,在英语中频繁出现。

Top 50 words

仔细看,你会发现许多不必要的标点符号和标签。通过排除单个和两个字母的单词,像thethisandthat这样的停用词在下面所示的词频分布图中占据顶部位置。

让我们删除停用词,以进一步清理文本语料库。

**from nltk.corpus import stopwords****stop_words = set(stopwords.words('english'))
tokens = [w for w in tokens if not w in stop_words]**

Top 50 words

这看起来像一个干净的文本语料库,像wentsawmovie 等等。如预期的那样占据了前几名。

另一个有用的可视化工具wordcloud包通过在画布上随机放置单词来帮助创建单词云,大小与它们在文本中的频率成比例。

**from wordcloud import WordCloud
import matplotlib.pyplot as plt****wordcloud = WordCloud().
generate_from_frequencies(frequency_dist)****plt.imshow(wordcloud)
plt.axis("off")
plt.show()**

构建分类器

在清理之后,是时候构建分类器来识别每个电影评论的情感。从 IMDb 数据集中,划分 25000 个测试集和训练集:

X_train = df.loc[:24999, 'review'].values
y_train = df.loc[:24999, 'sentiment'].values
X_test = df.loc[25000:, 'review'].values
y_test = df.loc[25000:, 'sentiment'].values

**scikit-learn**提供一些很酷的工具对文本做预处理。我们使用TfidTransformer将文本语料库转换为特征向量,我们将最大特征限制为 10000 个。有关如何使用TfidTransformer的更多详情,请参考此处的。

**from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import TfidfVectorizer****vectorizer = TfidfVectorizer()
train_vectors = vectorizer.fit_transform(X_train)
test_vectors = vectorizer.transform(X_test)
print(train_vectors.shape, test_vectors.shape)**

Training and Test set: 25K with 10K Features

有许多算法可供选择,我们将使用一个基本的朴素贝叶斯分类器,并在训练集上训练模型。

**from sklearn.naive_bayes import MultinomialNB****clf = MultinomialNB().fit(train_vectors, y_train)**

我们的情感分析仪已经准备好并接受过训练。现在,让我们在测试集上测试我们的模型的性能,以预测情感标签。

**from  sklearn.metrics  import accuracy_score****predicted = clf.predict(test_vectors)****print(accuracy_score(y_test,predicted))*****Output 0.791***

哇!!!基于基本 NB 分类器的情感分析器做得很好,给出大约 79%的准确度。您可以尝试改变特征向量长度和改变TfidTransformer的参数,以查看对模型精度的影响。

**结论:**我们已经详细讨论了 NLP 中使用的文本处理技术。我们还演示了使用文本处理和构建情感分析器,用经典的 ML 方法取得了相当好的效果。

感谢阅读本文,喜欢就推荐分享。

延伸阅读:

[## 对单词嵌入的直观理解:从计数向量到 Word2Vec

在我们开始之前,看看下面的例子。你打开谷歌搜索一篇关于……

www.analyticsvidhya.com](https://www.analyticsvidhya.com/blog/2017/06/word-embeddings-count-word2veec/) [## 什么是文本的单词嵌入?

词嵌入是一种词的表征类型,它允许具有相似意义的词具有相似的…

machinelearningmastery.com](https://machinelearningmastery.com/what-are-word-embeddings/)

机器学习:解释你的模型的重要性

原文:https://towardsdatascience.com/machine-learning-the-importance-of-explaining-your-model-29261677b0f4?source=collection_archive---------4-----------------------

以及为什么它可以提高精度!

一个月前,在做另一个有趣的个人项目时,我写了一篇关于葡萄酒评级分类的文章。结论非常简单:这个模型达到了 97%的精确度,非常好。

在阅读了更多关于 ML 的文章后,我发现了这个名为 Lime 的解释库,超级好用,非常有帮助。让我们回顾一下使用这种工具的步骤和优点。

模型解释

解释该模型最简单的方法是用矢量器和 RandomForestClassifier 创建一个管道。这样,可以用几行代码运行新文本的解释:

Notebook code: From pipeline to explanation

现在,运行它将会得到以下输出:

Lime Text Explanation output

G reat,解释超级简单易懂,你可以看到哪些词影响了决定,以哪种方式等等…
但是等等,什么???我们可以看到像“在”、“的”、“在”等常用词的例子…

TfidfVectorizer 应该会降低这些常用词的权重。一种猜测是,对于小文本,这是不够的,他们仍然在决策中的权重。即使只有百分之几,这些单词也不应该被计算在内。

有什么常用词?

L 在对矢量化进行实际分类之前,让我们改进模型并删除常用词。为此,我们将使用 nltk.corpus,这是一个流行的格式库:

Getting rid of common words (stopword)

N ew 解释:

Explanation after training the model without common words

结束注释

在中,除了提高模型的总体准确性之外,解释您的模型还有助于:

  • 为您的模型编写自动化测试:
    您想要控制您的模型的精度- >只需安排一个运行解释和一些健全性检查的日常任务
  • 证明你的模型/产品正在工作:
    在投入生产之前,或者在筹集资金之前,证明你的机器学习模型正在按预期工作,这可能会有所不同。尤其是当你的产品很大程度上依赖于它的时候。

以下是本文中描述的笔记本:

机器学习提示:使用旋转数据

原文:https://towardsdatascience.com/machine-learning-tip-using-rotational-data-b67ded0a33ad?source=collection_archive---------6-----------------------

可能会出现需要使用旋转数据进行预测的情况,无论是作为特征还是作为目标。将学位直接插入到你的模型中似乎可行,但是要小心,这不是你想要的。

为什么机器学习算法讨厌学位

**简单来说,他们不顺利!**我的意思是度数刻度随着它的进行从 359 度瞬移到 0 度。看:

在这种格式中,梯度下降算法不知道 350 度与 0 度相距 10 度,因此永远不会产生鲁棒的模型。

拯救罪恶与罪恶!

为了克服这些问题,我们只需将度数转换成 SINCOS 并使用它们作为我们的特征。现在没有传送,距离被适当地测量:

重要的是要记住,我们可以返回到我们的度数值,因为对于每组 SIN 和 COS 值,只有一个等价的度数值。在下一节中,我将向您展示神奇的 atan2 函数,它将为您完成这种转换。

抓到一个。

一个缺点是,现在如果你想预测一个方向(即方向是你的目标特征),你必须创建两个预测器:一个预测 SIN,一个预测 COS,然后使用**atan2函数将它们组合起来。**

import numpy as npdegrees_array = np.arctan2(sin_array, cos_array) * 180 / np.pi# will be in the range -180 : 180, 
# use modulo to wrap it to the range 0 : 360degrees_array_fixed_range = np.mod(degrees_array, 360)

查看使用两个预测器预测旋转值的完整示例:

https://github . com/ZackAkil/optimizing-training-data-meetup/blob/master/CL-DS-PN % 20 optimizing % 20 data % 20-% 20 my % 20 solution . ipynb

机器学习类型#2

原文:https://towardsdatascience.com/machine-learning-types-2-c1291d4f04b1?source=collection_archive---------4-----------------------

Machine Learning Type : reference

  1. 监督学习

Supervised Learning

在监督学习中,我们得到了数据集,并且已经知道我们的正确输出应该是什么样子。监督学习问题分为分类和回归。

  • 回归:-在回归中,我们将训练数据拟合到连续函数中,并尝试在连续输出中预测结果,这意味着我们尝试将输入变量映射到某个连续函数。根据面积预测房价。这里价格是房子大小的函数,房子是连续产出。所以这是一个回归问题。
  • 分类:-在分类输出中,预测离散值,如是或否、真或假、0 或 1、糖尿病与否、男性或女性、阳性或阴性等。例如在给定的健康数据中预测人是否患有糖尿病是分类的。

2。无监督学习

Unsupervised Learning : reference

与监督学习不同,我们提供数据集而不告诉数据的标签是什么(数据实际上是什么?)并要求从给定的数据集中找出结构。

聚类和鸡尾酒会算法用于发现给定数据集之间的结构。

举例:

聚类:

  • Google news 使用聚类算法对与同一主题相关的新闻进行分类。
  • 根据在电子商务应用中购买的物品对人进行分割是聚类算法的另一个例子。
  • 以 1,000,000 个不同基因的集合为例,找到一种方法来自动将这些基因分组为在某种程度上相似或通过不同变量(如寿命、位置、角色等)相关的组。

非聚类:

  • “鸡尾酒会算法”,让你在混乱的环境中找到结构。(即在鸡尾酒会上从声音网格中识别个人声音和音乐)。

3。 半监督学习

半监督学习类型利用标记和未标记的数据进行训练。半监督学习介于无监督学习和监督学习之间。

4。强化学习

强化学习是让一个主体在世界中行动以最大化其回报的问题。例如,考虑教一只狗一个新把戏:你不能告诉它做什么,但如果它做对/错的事情,你可以奖励/惩罚它。它必须弄清楚它做了什么使它得到了奖励/惩罚,这就是众所周知的信用分配问题。我们可以使用类似的方法来训练计算机完成许多任务,例如玩双陆棋或象棋,调度作业,以及控制机器人肢体。

Reinforcement Learning :- reference

机器学习中使用的算法类型

reference

机器学习类型和算法

原文:https://towardsdatascience.com/machine-learning-types-and-algorithms-d8b79545a6ec?source=collection_archive---------3-----------------------

不同类型的机器学习类型和算法,以及何时何地使用它们。

先决条件: 需要进行机器学习? ( 便于理解 )

Machine Learning

常用术语:

  1. 带标签的数据: 它由一组数据组成,一个例子将包括一个文件夹中所有带标签的猫或狗的图像,所有基于大小的房屋价格等。
  2. 分类: 分成有确定值的组,例如 0 或 1,猫或狗或橙等。
  3. 回归: 估计变量间最可能的值或关系。根据面积对房子价格的估计。
  4. 关联: 在大型数据库中发现变量间有趣的关系,其中发现的关联至关重要。

有四种类型的机器学习*(有些人可能会说三种,但在这里我们将使用四种 越多越好,对吗!!! ”)。*

  1. 监督学习:"给定输入的结果或输出在它本身" 之前是已知的 ,机器必须能够将给定输入映射或分配到输出。一只猫,狗,桔子,苹果等的多个图像,这些图像都有标签。它被输入到机器中用于训练,并且机器必须识别它。就像一个人类小孩看到一只猫并被告知如此,当他在其他猫中看到一只完全不同的猫时,仍然把它识别为一只猫,同样的方法在这里被使用。

Supervised learning examples

关键点:

  • 回归和分类 问题主要在这里解决。
  • 标注的数据 在这里用于训练。
  • 流行算法: 线性回归、支持向量机(SVM)、神经网络、决策树、朴素贝叶斯、最近邻。
  • 它主要用于 预测建模

2。无监督学习:“给定输入的结果或输出未知”,* 这里输入数据给定,模型在其上运行。给定的图像或输入在这里被组合在一起,关于输入的见解可以在这里找到(这是最真实的可用数据)。主要算法有 聚类算法( )和 学习算法。*

grouping of similar data

关键点:

  • 它用于 聚类问题( 分组 )、异常检测(银行中的异常交易) 需要找到给定数据之间的关系。
  • 无标签数据 用于无监督学习。
  • *流行算法: *k-means 聚类,关联规则。
  • 它主要用于 描述性建模。

***3。半监督学习:*介于 监督和非监督学习 之间。其中组合用于产生期望的结果,并且在所有可用数据都是 标记和未标记数据 的组合的真实世界场景中是最重要的。

***4。强化学习:*机器被暴露在一个 环境中,在那里它通过试错法 得到训练,在这里它被训练做出一个更加具体的决定。机器从过去的经验中学习,并试图捕捉最好的可能知识,以根据收到的反馈做出 准确的决策

Reinforced Learning workflow

关键点:

  • 基本强化被模拟为 马尔可夫决策过程
  • 这里最常用的算法是 Q-Learning深度对抗网络。
  • 其实际应用包括电脑玩棋类游戏如 象棋围棋自动驾驶汽车也使用这种学习。

简而言之,请查看下图

Machine Learning Types

更多参考文献:

  1. 人工智能是真实存在的还是只是这十年的炒作??
  2. 人工智能:定义、类型、实例、技术学名
  3. 人工智能 vs 机器学习
  4. 机器学习为什么要实现人工智能?

接下来我有 机器学习实现示例 5 分钟后 接下来请务必关注我的 LinkedIn*Twitter如果你喜欢这篇文章,请鼓掌并分享它。***

在这里加入我们的 WhatsApp 社区。

机器学习:使用小词

原文:https://towardsdatascience.com/machine-learning-use-small-words-5cc8f34a5964?source=collection_archive---------7-----------------------

我喜欢异端这个词。这是一种很酷的说法“跳出框框思考,反对主流”。它很好地描述了当很少有研究人员相信这种方法时,Hinton 和其他人如何推进深度学习研究。像异端邪说这样的大词让我想到用更小的词和更简单的词来描述我们所做的事情。

我们在深度学习人工智能方面做的,和人们认为我们做的,差距很大。在最近的一次机器学习活动中,另一家公司的一名高级研究科学家让我很不爽,因为他不相信马文·明斯基和他那一代人在几十年前开创了人工智能领域。客户不关心这些东西。就我个人而言,我更喜欢艾伦·图灵,但他的观点很公平。从 20 世纪 90 年代开始,我通常会想到辛顿、本吉奥和勒村等等。我钦佩的人是那些在失去所有希望时仍有梦想的人;像辛顿、尼克·博斯特伦和埃隆·马斯克这样默默无闻的人。我们这些技术型的人倾向于带着一种技术来参加舞会,直奔有刺的潘趣酒,然后立刻抛弃我们的约会,去找房间里最热门的技术。以这种方式经营有正当的理由,但可能有点残酷。在学术界之外,如果你过于怀旧和忠于旧技术,你很快就会变得无关紧要。问问你的铁匠就知道了。

在机器学习时代,历史发展得太快,几乎无法跟上,我们的客户依赖我们作为顾问来提取关键信息和能力,而不是给他们一个历史背景。我花了很多时间学习最新的东西。

过去几年来,我一直非常关注深度学习的进展,现在,在被深度学习超越所有其他技术的意外成功击败和血洗之后,正统数学和统计学的“旧”智慧正在悄悄回归主流。“真正的”数学家正在夺回汽车的控制权。我认为从现在开始机器学习的改进将遵循类似于软件编译器的分布模型。数学专家将制作新的魔盒,我们可以在像 Keras 这样的框架中使用,类似于 gcc 编译器的贡献者如何将接口暴露给高级语言并抽象掉所有低级的东西。

事实证明,进步不止朝着一个方向发展。有新类型的神经架构(例如 Hinton 的胶囊网络与 s .卷积网络),但也出现了最先进的“旧”模型,用作我们现有模型的升级。例如,新的贝叶斯 BNN 通过网络传播不确定性,而不仅仅依赖于网络输出的梯度损失。这比 DNN 模型强大得多,因为我们可以对事情的概率做出断言,而不是谈论模型与数据的吻合程度。在 DNN 中测量损失的问题在于,它会导致对训练数据的过度拟合,而不是对数据集进行概化。数据科学已经发明了对抗过度拟合的方法,但基本思想是,反向传播标量输出上的梯度是不足以谈论我们对深度学习系统的答案有多确定的信息。这留下了仍然真实存在的大错误的可能性,例如对深度学习系统的像素攻击

Examples of a good model with some error (left) and an overfitting model with lower error (right). Credit: https://www.cse.unsw.edu.au/~cs9417ml/MLP2/BackPropagation.html

像甘一样,是对的改进,因为它模拟了真实世界的东西,这是不确定的,并遵循概率密度曲线:概率分布。与较新的深度学习材料相比,变量的联合概率是旧的,然而通过提供不确定性测量,BNN 提供了比简单地最小化/观察模型误差更好的模型。我猜深度学习的异端邪说有它的局限性,钟摆现在摆回到有利于纯数学的家伙(和女孩)身上,他们将应用一个巨大的经典数学方法库来击败深度学习,使其从它所占据的霸道地位上退下来。我认为,从大的方面来看,新方法将会增强,而不是削弱现有的深度学习技术。这是一个激动人心的时刻。

从基础 R&D 的飞速发展中退一步,想想我们如何用不那么复杂的语言来表达这些来自研究界的简单想法。作为一名研究深度学习技术的工程师,我认为大型组织是时候将深度学习视为认知计算策略的一个组成部分,而不是一种数据建模工具。这种全面的数据方法包括融合内部企业数据和外部开源数据,然后使用工作流和深度机器学习生成见解。要做到这一切,你不需要华丽的词藻。相反,你需要从数据中获得洞察力。我在 LinkedIn 上看到一个很好的引用,称之为“自我意识数据”。不知何故,许多公司都忘记了,尽管机器学习在从数据中学习方面非常出色,但公司仍然需要理解并利用数据来洞察和采取行动,而不是数字。

采用机器学习的企业应该考虑 ML 是更大的企业工具箱的一小部分。BNNs 之类的“东西”代表工具箱 ML 隔间里的新扳手。但是不要被工具箱里闪亮的扳手分心。你关心的是用工具箱来修补漏洞和制造高速汽车。没人在乎你冲过终点线时用的是什么扳手。

当你开发了一个新的模型,可以综合你不知道的信息,这总是很棒的。不只是拟合数据,你会学到一些新的和意想不到的东西。我计划写更多关于认知计算以及它如何改变做生意的方式。

在那之前,编码快乐!

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

机器学习 vs .人工智能

原文:https://towardsdatascience.com/machine-learning-vs-artificial-intelligence-192391ce6caf?source=collection_archive---------10-----------------------

它们并不相同,但通常可以互换使用

Photo by Joshua Sortino on Unsplash

在实践中:机器学习和 AI 互换使用**。**通常这两个词都用来表示 监督学习

理论上:机器学习是 AI 的一个子领域:一种实现 AI* 的*方式。

机器学习和人工智能:对不同的人有不同的意义

很大一部分困惑是——取决于你和谁交谈——机器学习和人工智能对不同的用户有不同的含义。

现在,人工智能是一个比机器学习更性感的术语,所以在媒体和市场营销中,人工智能(AI)是最常用的术语。但是媒体所指的人工智能的范围非常广泛:

  • 专家系统
  • 工序自动化
  • 机器学习
  • 深度学习
  • 强化学习
  • …以及更多

有趣的一面:媒体上关于人工智能的话题越热,它在商业中的实际应用就越少。

媒体上最热门的话题往往对企业最没有价值。这些通常仍是研究案例,很少用于日常应用。

学术界

对于学者和研究数据科学的人来说,机器学习是更大的人工智能领域的一个子领域。

人工智能指的是一个非常大的研究领域,包括许多旨在开发能够学习和解决问题的计算机的技术:

  • 计算机视觉
  • 监督和非监督学习
  • 强化学习和遗传算法
  • 自然语言处理
  • 机器人技术(运动)

机器学习是人工智能领域,涉及自行从数据中学习

商业

在商业上,人工智能和机器学习通常指同一个东西。为什么?因为 AI 的大部分商业应用相当于监督学习,是机器学习的一个子领域。

“如今,人工智能创造的 99%的经济价值都是通过一种人工智能来实现的,那就是学习 A 到 B 或输入到输出的映射。”

所以实际上,商业中的AI和商业中的机器学习基本是一回事。

所以…这取决于你问谁

  • 机器学习是人工智能的一个子领域。
  • 然而,在实践中,使用这两个术语的人往往表示同一个意思。
  • 特别是在商业环境中,你可以使用这两个术语来指代能够自己从数据中学习的机器。**

最初发表于T5【www.datarevenue.com】。**

机器学习与深度学习

原文:https://towardsdatascience.com/machine-learning-vs-deep-learning-62137a1c9842?source=collection_archive---------5-----------------------

人工智能包含非常广泛的范围。你甚至可以将 Dijkstra 的最短路径算法视为人工智能。然而,有两类人工智能经常被混淆:机器学习和深度学习。这两者都是指数据的统计建模,以提取有用的信息或进行预测。在本文中,我们将列出这两种统计建模技术不同的原因,并帮助您进一步构建对这些数据建模范例的理解。

概观

机器学习是一种统计学习方法,其中数据集中的每个实例都由一组特征或属性来描述。相比之下,术语“深度学习”是一种从原始数据中提取特征或属性的统计学习方法。深度学习通过利用具有许多隐藏层的神经网络、大数据和强大的计算资源来实现这一点。这些术语似乎有些可互换,但是,使用深度学习方法,算法会自动构建数据的表示。相比之下,数据表示在机器学习算法中被硬编码为一组特征,需要进一步的处理,如特征选择和提取(如 PCA)。

这两个术语与另一类被称为基于规则的系统的经典人工智能算法形成了鲜明对比,在基于规则的系统中,每个决策都是以类似于统计模型的方式手动编程的。

在机器学习和深度学习中,有许多不同的模型,分为两个不同的类别,有监督的和无监督的。在无监督学习中,k-Means、层次聚类和高斯混合模型等算法试图学习数据中有意义的结构。监督学习涉及与数据集中的每个实例相关联的输出标签。该输出可以是离散的/分类的或实值的。回归模型估计实值输出,而分类模型估计离散值输出。简单的二元分类模型只有两个输出标签,1(正)和 0(负)。被认为是**机器学习的一些流行的监督学习算法:**有线性回归、logistic 回归、决策树、支持向量机、神经网络,还有 k 近邻等非参数模型。

数据量

机器学习和深度学习都能够处理大规模的数据集,然而,机器学习方法对小数据集更有意义。例如,如果你只有 100 个数据点,决策树、k 近邻和其他机器学习模型对你来说将比在数据上拟合深度神经网络更有价值。这是由于下一个话题的差异,可解释性。

可解释性

对深度学习方法和机器学习算法的许多批评,如支持向量机或(也许,因为你至少可以可视化组成输出的成分概率),朴素贝叶斯,是因为它们难以解释。例如,当卷积神经网络在狗与猫的问题中输出“猫”时,似乎没有人知道它为什么这样做。相比之下,当您使用机器学习技术对电子健康记录或银行贷款数据集等数据进行建模时,理解模型预测的推理要容易得多。

可解释性的一个最好的例子是决策树,你可以沿着树的节点进行逻辑测试,直到你做出一个决定。另一种具有高解释性的机器学习算法是 k-最近邻算法。这不是参数学习算法,但仍然属于机器学习算法的范畴。这是非常有可解释性的,因为你很容易为自己推理类似的例子。

结论

总之,上图是对深度学习和机器学习区别的最好概括。一个具体的例子是考虑原始数据形式,如图像中的像素或音频中的正弦波。机器学习方法很难从这些数据中构建语义特征。因此,深度学习方法在这些模型中占主导地位。深度学习还带来了比经典机器学习方法更多的细微差别和无法解释的现象。请告诉我这篇文章是否有助于框定你对机器学习相比深度学习的理解,谢谢你的阅读!

CShorten

Connor Shorten 是佛罗里达大西洋大学计算机科学专业的学生。对人工智能、计算机视觉、软件工程和生物信息学感兴趣。

机器学习-什么,为什么,何时和如何?

原文:https://towardsdatascience.com/machine-learning-what-why-when-and-how-9a2f244647a4?source=collection_archive---------4-----------------------

最近,很多人开始问我机器学习是怎么回事。今天,我正在写我和我姐姐帕里关于机器学习的最令人恼火的聊天记录之一。Parry 在信息领域有 8 年的经验,而我有 4 年的行业经验。

什么?

帕里:那你最近在忙什么?
我:没事就练机器学习。

帕里:嗯,这是每个人都在谈论的时髦词。你能让我知道这是怎么回事吗?
我:机器学习就是从数据中学习。

帕里:从数据中学习?我不明白。你在和一个门外汉说话,所以请用简单的术语说。我:假设你要去打保龄球,这是你的第一天,那么你认为你会如何表现呢?

Source

帕里:我觉得很糟糕,我记得第一次打保龄球时,我把所有的球都扔到了沟里。我:那今天呢?

帕里:嗯,今天我想我可以轻松地一杆拿下至少 7 分。但是这和机器学习有什么关系呢?
我:我来解释,但是你是怎么提高你的游戏的?

帕里:嗯,很简单。我练习,随着时间的推移,我获得了经验,我知道我需要调整我投球的角度。此外,我需要选择一个更轻的球,以提高精确度。我:嗯,所以随着时间的推移,你通过调整一些参数获得了经验,你的比赛也得到了提高。对吗?这是机器学习。

就某类任务 T 和性能测量 P 而言,如果由 P 测量的计算机程序在 T 任务中的性能随着经验 E 而提高,则称该计算机程序从经验 E 中学习。

帕里:嗯,好!但是机器是如何体验的呢?他们不是人类!
我:对,数据:)经验 E 对应历史数据。任务 T 是一次击中靶心,P 是一次掉落的瓶数!

帕里:嗯,但是你说学习是什么意思?机器也没有大脑。我:没错,这就是数学的用武之地!机器通过一些复杂的数学概念来学习,它们的每个数据都是 0 和 1 的形式。我们不想为我们的程序编写逻辑代码,相反,我们希望机器能够自己从数据中找出逻辑。

Parry:你说我们不需要编写逻辑代码是什么意思?
我:我们不需要像用其他编程语言那样编写硬编码规则。例如:假设我有这个关于公司员工工资的小数据:

Figure 1. Experience-Salary Dataset

现在如果你需要从这些数据中发现什么,你能推断出什么?

帕里:我可以观察到,当经验少于等于 10 年时,这个人的工资是经验的 1.5 倍,当经验从 10 年增加时,这个系数增加到 2。
我:正确你将如何编码?比如你需要预测一个有 8 年 16 年经验的人的工资?

招架:

 if (experience < = 10)
{ salary = experience * 1.5 * 100000} 
else if(experience >10)
{ salary = experience * 2 * 100000}

我:我们这里不这样!我们不用 ML 写 if,else,因为我们不专注于写算法。

Parry:但是这很简单,甚至我都能找出数据中的关系。
我:嗯当问题的规模增大时,现在说:

Figure 2. Complex Dataset with more Features

现在,你能找到经验、工作级别、稀有技能和薪水之间的关系吗?

帕里:现在有点困难!我:这就是机器出现的地方!您在前面的示例中刚刚计算的 1.5 或 2 的因数称为重量

Figure 3. Features(In Yellow) and Label (in Red)

黄色栏称为特性,红色栏称为标签。因此,我们计算决定标签的特征的权重。

所以我们使用机器学习来找出一个员工的工资多少取决于经验、工作级别和技能。基本上:

Salary = Experience * Magic_Number_1 + JobLevel * Magic_Number_2 + Skill * Magic_Number_3 + Magic_Number_4

因此,ML 将根据您使用的算法计算幻数!

帕里:但是你刚才说我们不编码算法,我们关注的是数据。
我:其实数据+算法=见解。算法已经为我们开发出来,我们需要知道何时使用哪种算法。这只是机器学习的一种类型,这个领域太大了,有很多数学:)

帕里:好吧,但是再见!我数学零分。这对我没用!我为什么要担心?我已经是 8 年经验丰富的 Informatica 开发人员,对此我很高兴!

为什么?

我:你每天用脸书多少小时?

招架:每日 1 小时左右。我:你知道脸书在用机器学习给你上传的照片中的朋友加标签吗?你知道脸书会根据你的兴趣历史显示定制的视频推荐吗?

Figure 4. Face Tagging in Photos Source

帕里:哦!这是不是所有的新闻提要都不一样的原因?
我:没错,脸书根据历史资料和 ML 当然知道你的好恶:)。你用的是哪个邮箱?

帕里:我正在使用 GMail。我:你知道 gmail 是如何知道某封邮件必须发送到优先邮件、社交邮件、推广邮件或垃圾邮件箱的吗?

帕里:明明是你的机器学习!我:阿雅,它有数百万封被用户标记为特定类别的邮件。因此通过使用 ML,他们观察模式并相应地分类。就连你今天用的键盘都是用 ML 来预测你的下一个单词。

帕里:是吗?我们是否在每次输入时都向谷歌提供数据?
我:是的,谷歌正在做一些令人惊讶的事情!一个这样的例子是在谷歌 IO 2018。看一看。

帕里:太好了!因此,谷歌将莫尔斯电码整合到谷歌键盘中,由于大量翻译数据的存在,它知道现在的转换。
我:是啊!你使用哪个网站购物?

帕里:亚马逊!太神奇了!
我:它神奇但最神奇的是亚马逊的推荐!

Parry:就像我们有视频推荐一样,我们有使用机器学习的产品推荐?我:没错,但是这里的转换率很重要。亚马逊的推荐引擎为它带来了近 350 亿美元的收入!

帕里:哦,天哪!这还不到我现在工作的公司的年收入。
我:你看这就是机器学习的魔力。听说过我们在超市购物不用再排队了吗

帕里:是吗?怎么会?
我:亚马逊 Go!

帕里:太好了!这解决了我大部分的购物问题!!我:那么我们现在在哪里看这个视频呢?

帕里:当然是 YouTube 了!你是在 youtube 上给我推荐的例子吗?
我:没有这次有点困难!你知道 1 分钟内 youtube 上传了多少小时的内容吗?大胆猜测一下

招架:嗯!10?
我:已经接近 500 小时了!你认为 YouTube 有这么多员工,他们可以审查这么多内容的裸体、暴力和版权吗?

帕里:Omg!不,一点也不!我:当问题的规模增加,我们有更多的数据时,机器是我们最后的希望,这就是为什么我们需要人工智能!

帕里:太好了!但所有这些公司都是四大,我的公司永远不会使用这项技术,所以为什么这是更重要的!
我:机器学习不仅仅是一个时髦词,而是一种神奇的技术,可以看到肉眼看不到的东西。你认识这个人吗?

Figure 5. Omar Bin Sultan, Minister of AI, UAE. Source

帕里:不,他是谁?
我:他是阿联酋人工智能部长奥马尔·本·苏丹!

帕里:什么?艾部长?我:他们现在是世界石油供应的领导者,而且石油至少可以使用 100 年,所以为什么他们需要一个 AI 部长?

帕里:也许人工智能是新的石油?
我:哈哈。如果到 2030 年,埃隆·马斯克的愿景成为现实会怎样?如果到 2030 年我们有了电动汽车、电动轮船和电动飞机会怎么样?

帕里:石油需求将会下降!我:没错,这就是他们投资未来技术的原因,所以如果明天石油需求下降,他们有比石油更大的东西来供应整个世界:)

什么时候?

帕里:太好了!告诉我更多关于这项新技术的信息。
我:新技术?这项技术出现于 1959 年。

帕里:什么?这么老的技术?那它为什么不早点长出来呢?
我:若干局限。一个是缺乏数据,另一个是存储数据的成本,另一个是缺乏计算能力。

招架:算力?所以你的意思是我们没有硬件来执行这些机器学习程序?我:没错,机器学习程序是硬件密集型的,因为它们包括大量密集的数学计算,如矩阵乘法等等。随着 GPU 的出现,TPU 和更快的处理器计算不再那么耗时。

Figure 6. GPU computing by NVIDIA has added new power to computational capabilities. Source

帕里:好!你提到缺乏数据?
Me:从 20 世纪 90 年代开始,数据以指数级的速度增长。随着像摄像头这样的传感器的使用增加,数据每天都在增长,数据越多,我们就能从数据中学到越多。

帕里:太好了!显然,海量数据带来了存储问题,对吗?
我:以前是,现在不是了。当云出现时,它解决了许多问题,其中最重要的是数据的存储成本。如今,如果你想在 AWS 上存储 50TB 的数据,大约需要 1200 美元,而在 20 年前,这一成本可能高达近百万美元。

Figure 7. Cloud Computing for storing data. Source

帕里:好!现在我明白了为什么它没有早点长出来。但既然是现在市场上的流行语,那你觉得这项技术的未来会怎样?
我:就回答我 3 个问题!

帕里:我?当然去吧!我:你认为在未来的时间里,数据会增加还是减少?

招架:增幅,很明显!
我:好!你认为在未来的时代,计算能力会增加还是减少?

招架:明显增加,机器一天天变好。
我:爽!你认为在未来的时间里,数据的存储成本会增加还是减少?

招架:明显减少!
我:那么结论是什么?

帕里:好!有了更多的数据、更强的计算能力和更低的数据存储成本,我们将能够推动构建数据驱动型产品。我想你只想听这个?
我:没错,未来是属于那些把数据变成产品的公司或者人的:D

怎么会?

帕里:我超级兴奋!说说这方面怎么入门?我擅长编程,我会在一个月内涵盖一切!
我:一个月内?回去继续你的信息。

帕里:等等!发生了什么事?
我:一个月不够机器学习。我不是打击你的积极性,但这是事实。在当今世界,我们试图快速学习一切,但这需要时间,因为这是一个研究领域,这不是 Java。net,你可以在一个月内学会,这是纯粹的数学和科学的结合,它需要你潜入海洋深处未被探索的领域。

帕里:所以你的意思是说我太老了,现在不能开始了?
我:一点也不,这是开始机器学习职业生涯的绝佳时机,即使你是大一新生,10 年经验或 20 年经验。我想向你解释的一点是,感受你正在做的事情,并有耐心。在做机器学习的时候,你觉得最重要的是什么?

帕里:当然是数据!
我:错!这是问题陈述。专注于你试图解决的问题,而不是算法或数据

帕里:如果你的说教结束了,请你告诉我该如何开始,否则我会打断你的牙齿。我:对不起,我得去看世界杯了。有志者事竟成!

帕里:你这样是不行的!告诉我!
我:好的,搜索吴恩达,从他的机器学习课程开始。但请先刷新一下你对概率、统计、线性代数的概念。

我有一个关于如何在不到 100 美元的时间内过渡到 ML 领域的计划,我将很快与大家分享(在即将到来的帖子中)。

帕里:我应该现在就开始还是等到你告诉我完整的计划?
我:

冬天来了!别等了,不然就来不及了!现在就开始!!

那都是乡亲们!请留下您宝贵的评论/掌声,或者在 LinkedIn 上与我联系,对本文提出改进/建议。

[## HARVEEN SINGH——专业程序员——Infosys | LinkedIn

查看 HARVEEN SINGH 在全球最大的职业社区 LinkedIn 上的个人资料。哈文有 4 份工作列在…

linkedin.com](http://linkedin.com/in/harveenchadha)

机器学习:从哪里开始…

原文:https://towardsdatascience.com/machine-learning-where-to-begin-772667260529?source=collection_archive---------9-----------------------

简介

在谷歌上搜索任何跟有“机器学习”一词的东西,都会得到一个庞大而令人生畏的资源列表,尤其是当你是从商业角度出发或者刚进入这个领域的时候。

我经常看到一页纸的机器学习“备忘单”,上面有选择算法的流程图。我喜欢这个概念,但他们假设先验知识,迎合那些已经精通可能的算法。

这就是这个工具的灵感来源。它不是直接一头扎进数学和算法的世界,而是从询问你试图解决什么样的问题开始。通过首先确定你想要达到的目标,你可以缩小寻找解决方案的范围。

一旦做出选择,该工具将介绍您可能希望在概述最常用算法之前探索的技术类型。

它并不完整,而是向读者介绍概念和术语的起点。我希望这是对好奇的头脑的欢迎,并可以在那些对该领域感兴趣的人和他们的数据科学同事或朋友之间架起一座桥梁。

网上有很多很好的资源,可以提供更多的细节。这个工具的目标是激励,甚至是授权,让你继续探索数据科学这个不可思议的世界!

框架—算法浏览器

所以在这里,享受吧!

点击这里访问算法浏览器

注意:这也是一个正在进行的项目,我们希望根据社区的反馈进行迭代。请在这里分享想法或者报告 bug:算法浏览器 github repo

静态页面

如果你想在框架之外参考这个工具的内容,下面的文章会介绍这些内容

机器学习:试图预测一个数值

机器学习:试图对你的数据进行分类

机器学习:试图在你的数据中发现结构

机器学习:试图提出建议

机器学习:尝试检测异常值或异常行为

非常感谢

尽管我喜欢使用数据科学领域之外的各种技术和工具,但对我来说,寻求前端开发方面的帮助无疑是明智的。我想感谢山姆·罗斯的伟大工作(和耐心!)将我的原始想法转化为更易消费、更精简、更美观的东西。同样,我的绘画技巧还有很多地方需要改进,所以感谢玛丽·金给这部作品增添了艺术魅力!

使用 IBM PowerAI 的机器学习中的图像分类基础(第 1 部分)

原文:https://towardsdatascience.com/machine-learning-with-ibm-powerai-getting-started-with-image-classification-part-1-6219e3c6a9fa?source=collection_archive---------4-----------------------

IBM Power Systems

介绍

图像分类已经成为展示机器学习的关键试点用例之一。在这篇短文中,我试图描述如何使用 IBM PowerAI 实现这样一个解决方案,并在 IBM Power 系统上运行时比较 GPU 和 CPU 的性能。

人工智能

人工智能目前被视为计算机科学的一个分支,它处理让计算机执行像视觉识别、语音识别、认知决策、语言翻译等传统上被认为是人类智能的任务。

机器学习

机器学习通常被视为人工智能的一种应用,它致力于赋予系统学习和根据经验改进的能力,而无需显式编码所有任务。

深度学习

深度学习是机器学习的一个子集,其中系统可以利用带标签的训练数据(有监督的)或无标签的训练数据(无监督的)进行学习。深度学习通常使用分层的人工神经网络来执行任务。

人工神经网络

人工神经网络是受生物神经网络启发的系统,可以以惊人的精度执行某些任务,如图像分类。例如,对于图像分类,给动物的一组图像提供标记。这是训练数据。人工神经网络通过一系列步骤(或层),帮助系统学习将未标记的图像(本文所示示例中的猩猩图像)分类为属于某个群体的能力,同时得出准确度分数。

深度学习在你的业务中有几个应用,从手机个人助理到自动驾驶汽车,快速变化的模式被用于实时分类物体。

什么是 IBM PowerAI?

IBM PowerAI 软件让您可以在包含 GPU 的 IBM POWER9 服务器上轻松运行所有流行的机器学习框架。CPU 是为串行处理而设计和构建的,包含少量内核,而 GPU 可以包含数千个更小的内核,并依赖于任务的并行处理。用于机器学习的任务是 GPU 的关键应用。看看 IBM Power System AC922 服务器,它被吹捧为市场上运行企业人工智能任务的最佳服务器之一。IBM PowerAI 目前包括以下框架;

Source: https://www.ibm.com/us-en/marketplace/deep-learning-platform

当前设置

对于这个演示,我在一个运行 Ubuntu on Power 的虚拟机上使用了一个容器( ppc64le ),托管在 Nimbix Cloud 上。

容器是图像的运行实例。映像是包含操作系统、软件和应用程序代码的模板,所有这些都打包在一个文件中。使用 Dockerfile 定义映像,docker file 是配置映像的步骤列表。构建 Dockerfile 是为了创建一个映像,运行这个映像是为了获得一个运行容器。要运行映像,您需要在虚拟机上安装和配置 Docker 引擎。

这是我用过的 Dockerfile ,由 Indrajit Poddar 编写。这摘自 this Github 页面。

这用 Jupyter Notebook、iTorch 内核(我们将在第二部分讨论)和一些基本 TensorFlow 示例构建了一个映像。

TensorFlow 是一个面向机器学习应用的开源、可扩展库,基于可以构建和执行的数据流图的概念。一个图可以包含两个部分,节点和边(或张量)。它附带了一个 Python API,很容易组装网络、分配参数和运行训练模型。

以下步骤由英德拉吉特·波德达尔演示。他在 Nimbix Cloud 上构建了一个测试映像,该映像将在部署后几分钟内运行上述服务。

以下命令用于验证 GPU 是否连接到容器。

root@JARVICENAE-0A0A1841:/usr/lib/nvidia-384# **nvidia-smi**Thu Feb 1 23:45:11 2018+ — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -+| NVIDIA-SMI 384.111 Driver Version: 384.111 || — — — — — — — — — — — — — — — -+ — — — — — — — — — — — + — — — — — — — — — — — +| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC || Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. ||===============================+======================+======================|| 0 Tesla P100-SXM2… Off | 00000003:01:00.0 Off | 0 || N/A 40C P0 42W / 300W | 299MiB / 16276MiB | 0% Default |+ — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -+| Processes: GPU Memory || GPU PID Type Process name Usage ||=============================================================================|+ — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -+

我看到一个英伟达特斯拉 P100 图形处理器连接。以下命令显示了已安装的 Jupyter Notebook 实例以及稍后将用于身份验证的相关令牌。

root@JARVICENAE-0A0A1841:/usr/lib/nvidia-384# jupyter notebook list
Currently running servers:
[http://0.0.0.0:8889/?token=d0f34d33acc9febe500354a9604462e8af2578f338981ad1](http://0.0.0.0:8889/?token=d0f34d33acc9febe500354a9604462e8af2578f338981ad1) :: /opt/DL/torch
[http://0.0.0.0:8888/?token=befd7faf9b806b6918f0618a28341923fb9a1e77d410b669](http://0.0.0.0:8888/?token=befd7faf9b806b6918f0618a28341923fb9a1e77d410b669) :: /opt/DL/caffe-ibm
[http://0.0.0.0:8890/?token=a9448c725c4ce2af597a61c47dcdb4d1582344d494bd132f](http://0.0.0.0:8890/?token=a9448c725c4ce2af597a61c47dcdb4d1582344d494bd132f) :: /opt/DL/tensorflow
root@JARVICENAE-0A0A1841:/usr/lib/nvidia-384#

开始图像分类

什么是咖啡?

Caffe (用于快速特征嵌入的卷积架构)是在伯克利视觉和学习中心开发的。它是一个用于执行图像分类等任务的开源框架。它支持 CUDA ,卷积神经网络,具有预训练的模型,因此是这个演示的一个好选择。

我们将使用 Python 来执行所有的任务。以下步骤是通过 Jupyter 笔记本完成的。首先,让我们设置 Python、 NumpyMatplotlib

import numpy as npimport matplotlib.pyplot as plt# display plots in this notebook%matplotlib inline# set display defaultsplt.rcParams[‘figure.figsize’] = (10, 10) # large imagesplt.rcParams[‘image.interpolation’] = ‘nearest’ # don’t interpolate: show square pixelsplt.rcParams[‘image.cmap’] = ‘gray’ # use grayscale output rather than a (potentially misleading) color heatmap# Then, we load Caffe. The caffe module needs to be on the Python path;# we’ll add it here explicitly.import syscaffe_root = ‘../’ # this file should be run from {caffe_root}/examples (otherwise change this line)sys.path.insert(0, caffe_root + ‘python’)import caffe

什么是咖啡因?

Caffenet 是一个卷积神经网络,用来与 CUDA 接口,主要目的是对图像进行分类。Caffenet 是 Alexnet 的变种。Alexnet 的创建者在 2015 年做了一个展示,这里是。在下面的代码中,我们下载了一个预先训练好的模型。

import osif os.path.isfile(caffe_root + ‘models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel’):print ‘CaffeNet found.’else:print ‘Downloading pre-trained CaffeNet model…’!../scripts/download_model_binary.py ../models/bvlc_reference_caffenet

这是输出。

CaffeNet found.
Downloading pre-trained CaffeNet model... 
…100%, 232 MB, 42746 KB/s, 5 seconds passed

然后,我们在 CPU 模式下加载 Caffe,并进行输入预处理。

caffe.set_mode_cpu()model_def = caffe_root + ‘models/bvlc_reference_caffenet/deploy.prototxt’model_weights = caffe_root + ‘models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel’net = caffe.Net(model_def, # defines the structure of the modelmodel_weights, # contains the trained weightscaffe.TEST) # use test mode (e.g., don’t perform dropout)

用的是 Caffenet 的‘caffe . io . transformer’。这是所有示例中使用的默认转换器。它根据提供的输入为图像创建一个变换的平均值。Caffenet 被设置为获取 BGR 格式的输入图像,其值在 0 到 255 的范围内。执行转换以加载 RGB 格式的值在 0 到 1 范围内的图像,作为 Matplotlib 所需的输入。

# load the mean ImageNet image (as distributed with Caffe) for subtractionmu = np.load(caffe_root + ‘python/caffe/imagenet/ilsvrc_2012_mean.npy’)mu = mu.mean(1).mean(1) # average over pixels to obtain the mean (BGR) pixel valuesprint ‘mean-subtracted values:’, zip(‘BGR’, mu)# create transformer for the input called ‘data’transformer = caffe.io.Transformer({‘data’: net.blobs[‘data’].data.shape})transformer.set_transpose(‘data’, (2,0,1)) # move image channels to outermost dimensiontransformer.set_mean(‘data’, mu) # subtract the dataset-mean value in each channeltransformer.set_raw_scale(‘data’, 255) # rescale from [0, 1] to [0, 255]transformer.set_channel_swap(‘data’, (2,1,0)) # swap channels from RGB to BGR

换句话说,计算机现在可以通过首先将图像转换为 RGB 值的数组来学习对图像进行分类。然后,扫描这些值以寻找已经与预训练模型中的另一个图像相匹配的值的模式。在比较时,会生成置信度度量,显示分类的准确程度。

这是输出。

mean-subtracted values: [(‘B’, 104.0069879317889), (‘G’, 116.66876761696767), (‘R’, 122.6789143406786)]

分类

这里,我们设置图像的默认大小。这可以根据您的输入进行更改。

net.blobs[‘data’].reshape(50, # batch size3, # 3-channel (BGR) images720, 720) # image size is 720x720

接下来,我们从 Wiki Commons 库中加载一只猩猩的图像。

# download the imagemy_image_url = “https://upload.wikimedia.org/wikipedia/commons/b/be/Orang_Utan%2C_Semenggok_Forest_Reserve%2C_Sarawak%2C_Borneo%2C_Malaysia.JPG" # paste your URL here!wget -O image.jpg $my_image_url# transform it and copy it into the netimage = caffe.io.load_image(‘image.jpg’)transformed_image = transformer.preprocess(‘data’, image)plt.imshow(image)

这是输出。

--2018-02-02 00:27:52--  [https://upload.wikimedia.org/wikipedia/commons/b/be/Orang_Utan%2C_Semenggok_Forest_Reserve%2C_Sarawak%2C_Borneo%2C_Malaysia.JPG](https://upload.wikimedia.org/wikipedia/commons/b/be/Orang_Utan%2C_Semenggok_Forest_Reserve%2C_Sarawak%2C_Borneo%2C_Malaysia.JPG)Resolving upload.wikimedia.org (upload.wikimedia.org)... 198.35.26.112, 2620:0:863:ed1a::2:bConnecting to upload.wikimedia.org (upload.wikimedia.org)|198.35.26.112|:443... connected.HTTP request sent, awaiting response... 200 OKLength: 1443340 (1.4M) [image/jpeg]Saving to: 'image.jpg'image.jpg           100%[===================>]   1.38M  5.25MB/s    in 0.3s2018-02-02 00:27:54 (5.25 MB/s) - 'image.jpg' saved [1443340/1443340]

现在,让我们对图像进行分类。

# copy the image data into the memory allocated for the netnet.blobs[‘data’].data[…] = transformed_image# perform classificationoutput = net.forward()​output_prob = output[‘prob’][0] # the output probability vector for the first image in the batch​print ‘predicted class is:’, output_prob.argmax()

输出为'预测类为:365 '。

上面的输出将图像分类为类别 365。让我们加载 ImageNet 标签并查看输出。

# load ImageNet labelslabels_file = caffe_root + ‘data/ilsvrc12/synset_words.txt’if not os.path.exists(labels_file):!../data/ilsvrc12/get_ilsvrc_aux.shlabels = np.loadtxt(labels_file, str, delimiter=’\t’)print ‘output label:’, labels[output_prob.argmax()]

这是输出。上课是对的!

output label: n02480495 orangutan, orang, orangutang, Pongo pygmaeus

下面的代码可以帮助你找到其他的顶级类。

# sort top five predictions from softmax outputtop_inds = output_prob.argsort()[::-1][:5] # reverse sort and take five largest itemsprint ‘probabilities and labels:’zip(output_prob[top_inds], labels[top_inds])

这是输出。

probabilities and labels:
[(0.96807814, 'n02480495 orangutan, orang, orangutang, Pongo pygmaeus'),(0.030588957, 'n02492660 howler monkey, howler'),(0.00085891742, 'n02493509 titi, titi monkey'),(0.00015429058, 'n02493793 spider monkey, Ateles geoffroyi'),(7.259626e-05, 'n02488291 langur')]

分析 GPU 性能

这是在纯 CPU 模式下执行分类所花费的时间。

%timeit net.forward()

这是输出。

OUTPUT: 1 loop, best of 3: 3.06 s per loop

每个循环三秒钟相当长。让我们切换到 GPU 模式,执行同样的操作。

caffe.set_device(0) # if we have multiple GPUs, pick the first onecaffe.set_mode_gpu()net.forward() # run once before timing to set up memory%timeit net.forward()

这是输出。

OUTPUT: 1 loop, best of 3: 11.4 ms per loop

这是 3048.6 毫秒的改进!这篇博客的第一部分到此结束。我为语法错误道歉,如果有的话。

在下一部分中,我们将了解如何使用 NVIDIA Digits 训练您自己的模型,以及如何使用 Torch。

如果你喜欢这首曲子,那就鼓掌吧👏🏻(可以不止一次鼓掌)!你也可以在网上的某个地方分享,这样其他人也可以阅读。

免责声明:本网站上的帖子是我自己的,不一定代表 IBM 的立场、策略或观点。

作者:乌彭德拉·拉詹

基于 PySpark 和 MLlib 的机器学习——解决二元分类问题

原文:https://towardsdatascience.com/machine-learning-with-pyspark-and-mllib-solving-a-binary-classification-problem-96396065d2aa?source=collection_archive---------0-----------------------

Photo Credit: Pixabay

Apache Spark ,曾经是 Hadoop 生态系统的一个组成部分,现在正成为企业首选的大数据平台。它是一个强大的开源引擎,提供实时流处理、交互式处理、图形处理、内存处理以及批处理,速度非常快,易于使用,接口标准。

在这个行业中,有一个强大的引擎,可以做到以上所有的需求很大。你的公司或客户迟早会使用 Spark 开发复杂的模型,让你发现新的机会或规避风险。Spark 并不难学,如果你已经了解 Python 和 SQL,入门非常容易。今天就来试试吧!

探索数据

当我们用 Python 构建逻辑回归时,我们将使用相同的数据集,它与一家葡萄牙银行机构的直接营销活动(电话)相关。分类的目标是预测客户是否会认购(是/否)定期存款。数据集可以从 Kaggle 下载。

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('ml-bank').getOrCreate()
df = spark.read.csv('bank.csv', header = True, inferSchema = True)
df.printSchema()

Figure 1

输入变量:年龄、工作、婚姻、教育、违约、余额、住房、贷款、联系人、日、月、持续时间、活动、pdays、先前、poutcome。

产出变量:存款

先看一下前五个观察结果。熊猫数据框比 Spark DataFrame.show()好看。

import pandas as pd
pd.DataFrame(df.take(5), columns=df.columns).transpose()

Figure 2

我们的班级非常平衡。

import pandas as pd
pd.DataFrame(df.take(5), columns=df.columns).transpose()

Figure 3

数字变量的汇总统计

numeric_features = [t[0] for t in df.dtypes if t[1] == 'int']
df.select(numeric_features).describe().toPandas().transpose()

Figure 4

自变量之间的相关性

numeric_data = df.select(numeric_features).toPandas()axs = pd.scatter_matrix(numeric_data, figsize=(8, 8));n = len(numeric_data.columns)
for i in range(n):
    v = axs[i, 0]
    v.yaxis.label.set_rotation(0)
    v.yaxis.label.set_ha('right')
    v.set_yticks(())
    h = axs[n-1, i]
    h.xaxis.label.set_rotation(90)
    h.set_xticks(())

Figure 5

很明显,没有高度相关的数值变量。因此,我们将为模型保留它们。然而,日和月列并不真正有用,我们将删除这两列。

df = df.select('age', 'job', 'marital', 'education', 'default', 'balance', 'housing', 'loan', 'contact', 'duration', 'campaign', 'pdays', 'previous', 'poutcome', 'deposit')
cols = df.columns
df.printSchema()

Figure 6

为机器学习准备数据

该过程包括类别索引、一键编码和 vector assembler——一种将多个列合并为一个向量列的特征转换器。

from pyspark.ml.feature import OneHotEncoderEstimator, StringIndexer, VectorAssemblercategoricalColumns = ['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'poutcome']
stages = []for categoricalCol in categoricalColumns:
    stringIndexer = StringIndexer(inputCol = categoricalCol, outputCol = categoricalCol + 'Index')
    encoder = OneHotEncoderEstimator(inputCols=[stringIndexer.getOutputCol()], outputCols=[categoricalCol + "classVec"])
    stages += [stringIndexer, encoder]label_stringIdx = StringIndexer(inputCol = 'deposit', outputCol = 'label')
stages += [label_stringIdx]numericCols = ['age', 'balance', 'duration', 'campaign', 'pdays', 'previous']
assemblerInputs = [c + "classVec" for c in categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="features")
stages += [assembler]

上面的代码取自 databricks 的官方网站,它使用 StringIndexer 对每个分类列进行索引,然后将索引的类别转换为 one-hot 编码变量。结果输出将二进制向量附加到每一行的末尾。我们再次使用 StringIndexer 将标签编码为标签索引。接下来,我们使用 VectorAssembler 将所有的特性列合并成一个向量列。

管道

我们使用管道将多个转换器和估计器链接在一起,以指定我们的机器学习工作流程。管道的阶段被指定为有序数组。

from pyspark.ml import Pipeline
pipeline = Pipeline(stages = stages)
pipelineModel = pipeline.fit(df)
df = pipelineModel.transform(df)
selectedCols = ['label', 'features'] + cols
df = df.select(selectedCols)
df.printSchema()

Figure 7

pd.DataFrame(df.take(5), columns=df.columns).transpose()

Figure 8

如您所见,我们现在有“功能”列和“标签”列。

将数据随机分为训练集和测试集,并为可重复性设置种子。

train, test = df.randomSplit([0.7, 0.3], seed = 2018)
print("Training Dataset Count: " + str(train.count()))
print("Test Dataset Count: " + str(test.count()))

训练数据集计数:7764
测试数据集计数:3398

逻辑回归模型

from pyspark.ml.classification import LogisticRegressionlr = LogisticRegression(featuresCol = 'features', labelCol = 'label', maxIter=10)
lrModel = lr.fit(train)

我们可以通过使用 LogisticRegressionModel 的属性获得系数

import matplotlib.pyplot as plt
import numpy as npbeta = np.sort(lrModel.coefficients)plt.plot(beta)
plt.ylabel('Beta Coefficients')
plt.show()

Figure 9

在训练集上总结模型,我们还可以得到接收机操作特性和 areaUnderROC

trainingSummary = lrModel.summaryroc = trainingSummary.roc.toPandas()
plt.plot(roc['FPR'],roc['TPR'])
plt.ylabel('False Positive Rate')
plt.xlabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()print('Training set areaUnderROC: ' + str(trainingSummary.areaUnderROC))

Figure 10

精度和召回

pr = trainingSummary.pr.toPandas()
plt.plot(pr['recall'],pr['precision'])
plt.ylabel('Precision')
plt.xlabel('Recall')
plt.show()

Figure 11

对测试集进行预测。

predictions = lrModel.transform(test)
predictions.select('age', 'job', 'label', 'rawPrediction', 'prediction', 'probability').show(10)

Figure 12

评估我们的逻辑回归模型

from pyspark.ml.evaluation import BinaryClassificationEvaluatorevaluator = BinaryClassificationEvaluator()
print('Test Area Under ROC', evaluator.evaluate(predictions))

ROC 0.88324614449619下的测试区域

决策树分类器

决策树被广泛使用,因为它们易于解释、处理分类特征、扩展到多类分类、不需要特征缩放,并且能够捕捉非线性和特征交互。

from pyspark.ml.classification import DecisionTreeClassifierdt = DecisionTreeClassifier(featuresCol = 'features', labelCol = 'label', maxDepth = 3)
dtModel = dt.fit(train)
predictions = dtModel.transform(test)
predictions.select('age', 'job', 'label', 'rawPrediction', 'prediction', 'probability').show(10)

Figure 13

评估我们的决策树模型

evaluator = BinaryClassificationEvaluator()
print("Test Area Under ROC: " + str(evaluator.evaluate(predictions, {evaluator.metricName: "areaUnderROC"})))

ROC 下的测试区域:0.7807240050065357

一个简单的决策树表现不佳,因为它在不同特征的范围内太弱。集成方法可以提高决策树的预测精度,如随机森林和梯度提升树。

随机森林分类器

from pyspark.ml.classification import RandomForestClassifierrf = RandomForestClassifier(featuresCol = 'features', labelCol = 'label')
rfModel = rf.fit(train)
predictions = rfModel.transform(test)
predictions.select('age', 'job', 'label', 'rawPrediction', 'prediction', 'probability').show(10)

Figure 14

评估我们的随机森林分类器。

evaluator = BinaryClassificationEvaluator()
print("Test Area Under ROC: " + str(evaluator.evaluate(predictions, {evaluator.metricName: "areaUnderROC"})))

ROC 下的测试区域:0.8846453518867426

梯度增强树分类器

from pyspark.ml.classification import GBTClassifiergbt = GBTClassifier(maxIter=10)
gbtModel = gbt.fit(train)
predictions = gbtModel.transform(test)
predictions.select('age', 'job', 'label', 'rawPrediction', 'prediction', 'probability').show(10)

Figure 15

评估我们的梯度增强树分类器。

evaluator = BinaryClassificationEvaluator()
print("Test Area Under ROC: " + str(evaluator.evaluate(predictions, {evaluator.metricName: "areaUnderROC"})))

ROC 下的测试区域:0.8940728473145346

梯度提升树取得了最好的结果,我们将尝试用 ParamGridBuilder 和 CrossValidator 调整这个模型。在此之前,我们可以使用 explainParams()打印所有参数及其定义的列表,以了解哪些参数可用于调优。

print(gbt.explainParams())

Figure 16

from pyspark.ml.tuning import ParamGridBuilder, CrossValidatorparamGrid = (ParamGridBuilder()
             .addGrid(gbt.maxDepth, [2, 4, 6])
             .addGrid(gbt.maxBins, [20, 60])
             .addGrid(gbt.maxIter, [10, 20])
             .build())cv = CrossValidator(estimator=gbt, estimatorParamMaps=paramGrid, evaluator=evaluator, numFolds=5)# Run cross validations.  This can take about 6 minutes since it is training over 20 trees!
cvModel = cv.fit(train)
predictions = cvModel.transform(test)
evaluator.evaluate(predictions)

0.8981050997838095

综上所述,我们已经学习了如何使用 PySpark 和 MLlib Pipelines API 构建二进制分类应用程序。我们尝试了四种算法,梯度提升在我们的数据集上表现最好。

源代码可以在 Github 上找到。我期待听到反馈或问题。

参考:阿帕奇 Spark 2.1.0

用 Python 进行机器学习:拟合非线性数据的简单而稳健的方法

原文:https://towardsdatascience.com/machine-learning-with-python-easy-and-robust-method-to-fit-nonlinear-data-19e8a1ddbd49?source=collection_archive---------2-----------------------

使用 Python 库、管道特性和正则化进行非线性数据建模的简单而可靠的方法。

非线性数据建模是数据科学和分析领域的一项常规任务。很难找到一个结果随自变量线性变化的自然过程。因此,我们需要一种简单而可靠的方法来快速拟合一组测量数据和一组变量,假设测量数据可能是一个复杂的非线性函数。这应该是数据科学家或机器学习工程师的常用工具

有几个相关的问题需要考虑:

  • 我如何决定尝试拟合什么阶的多项式?多元回归需要包含交叉耦合项吗?有没有一种简单的方法来自动化这个过程**?**
  • 如何确保我不会过度适应数据?
  • 我的机器学习模型对测量噪声是否鲁棒?
  • 我的模型容易扩展到更高维度和/或更大的数据集吗?

如何确定多项式的阶次及相关难题

"我可以绘制数据并快速浏览一下吗?"

只有当一个人能够清楚地可视化数据时(特征维数是 1 或 2),这才是可以的。对于特征尺寸为 3 或更大的尺寸,这要困难得多。如果影响结果的特性之间存在交叉耦合,这完全是浪费时间。让我用图表展示一下,

显而易见,策划只能让你到此为止。对于一个高维的相互作用的数据集,如果你试图一次查看一个输出与一个输入变量的关系图,你会得出完全错误的结论。而且,没有一种简单的方法可以一次可视化两个以上的变量。因此,我们必须借助某种机器学习技术来生成多维数据集。

事实上,有很多好的解决方案。

线性回归应该是第一个要查的工具,在你尖叫之前“……但是这些是高度非线性的数据集……”,让我们记住,线性回归模型中的‘线性’是指系数,而不是指特征的程度。特征(或独立变量)可以是任何次数,甚至是超越函数,如指数、对数、正弦。而且,使用这些变换和线性模型可以(近似地)模拟大量的自然现象。

因此,假设我们得到以下数据集,它有一个输出和 3 个特征。我们再次展示了这些情节,但是,不出所料,它们没有多大帮助。

因此,我们决定学习具有高达一些高次多项式项的线性模型来拟合数据集。很少有问题会立即浮现出来:

—如何决定什么样的多项式是必要的

—如果我们开始逐个合并一级、二级、三级术语,什么时候停止?

—如何确定任何交叉耦合项是否重要,即我们是否只需要 X 1、 X 2 或 X 1。 X 2 和 X 1 .X3 项也?

—最后,我们是否必须为所有这些多项式变换手动编写方程/函数,并将它们添加到数据集中?

牛逼的 Python 机器学习库来帮忙

幸运的是, scikit-learn ,这个令人敬畏的机器学习库,提供了现成的类/对象来以一种简单而健壮的方式回答上述所有问题。

这里有一个简单的使用 scikit-learn 的线性回归概述视频,这里有一篇不错的中型文章供您审阅。但是在本文中,我们将涵盖比简单的线性拟合更多的内容,所以请继续阅读**。在我的 GitHub repo 上可以找到这篇文章的全部样板代码**

我们首先从 scikit-learn 导入几个相关的类,

# **Import function to create training and test set splits**
from sklearn.cross_validation import train_test_split# **Import function to automatically create polynomial features!** 
from sklearn.preprocessing import PolynomialFeatures# **Import Linear Regression and a regularized regression function**
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import LassoCV# **Finally, import function to make a machine learning pipeline**
from sklearn.pipeline import make_pipeline

让我们快速定义/概括一下我们接下来要使用/实现的必要概念。

训练/测试分割 :这意味着从我们拥有的单个数据集创建两个数据集。其中一个(训练集)将用于构建模型,另一个(测试集)将仅用于测试模型的准确性和稳健性。这对于任何机器学习任务来说都是必不可少的,因此我们不会用我们所有的数据创建模型,并认为模型高度准确(因为它已经‘看到’了所有的数据,并且拟合得很好),但当面对现实世界中新的(“看不见”)数据时,它表现很差**。测试集的准确性比训练集的准确性重要得多。这里有一篇关于这个主题的很好的中间文章供你参考。下面你可以看到谷歌汽车先驱巴斯蒂安·特龙谈论这个概念。**

自动多项式特征生成 : Scikit-learn 为从一组线性特征生成多项式特征提供了一种简洁的方法。您所要做的就是传递一个列表中的线性要素,并指定要生成多项式次数项的最大次数。它还让您可以选择生成所有的交叉耦合交互项,或者只生成主要特征的多项式次数。下面是一个示例 Python 代码描述

正则化回归 :正则化的重要性不能被夸大,因为它是机器学习中的一个核心概念。在线性回归设置中,基本思想是惩罚模型系数,使其不会变得太大而过度拟合数据,即,使模型对数据中的噪声极其敏感。有两种广泛使用的正则化方法,其中我们正在使用一种叫做套索的方法。这里有一个关于这两种正则化方法的很好的概述。

机器学习管道 :一个机器学习项目(几乎)绝不是单一的建模任务。在最常见的形式中,它包括数据生成/接收、数据清理和转换、模型拟合、交叉验证、模型准确性测试和最终部署**。这里有一个 Quora 答案很好地总结了这个概念。或者,这里有一篇相关的媒介文章。或者,另一篇讨论管道实践重要性的好文章。Scikit-learn 提供了一个管道特性,它可以将多个模型和数据预处理类堆叠在一起,并将原始数据转化为可用的模型。**

如果您有时间,请观看 PyData conference(2015 年,达拉斯)上的这段长视频(1 小时以上),了解所有相关内容。

如何通过将所有这些放在一起建立一个健壮的模型?

这是样板代码快照。您必须对其进行修改,以便为您的数据集正确运行。

**# Alpha (regularization strength) of LASSO regression**
lasso_eps = 0.0001
lasso_nalpha=20
lasso_iter=5000**# Min and max degree of polynomials features to consider**
degree_min = 2
degree_max = 8**# Test/train split**
X_train, X_test, y_train, y_test = train_test_split(df['X'], df['y'],test_size=test_set_fraction)**# Make a pipeline model with polynomial transformation and LASSO regression with cross-validation, run it for increasing degree of polynomial (complexity of the model)**for degree in range(degree_min,degree_max+1):
    model = make_pipeline(PolynomialFeatures(degree, interaction_only=False), LassoCV(eps=lasso_eps,n_alphas=lasso_nalpha,max_iter=lasso_iter,
normalize=True,cv=5))
    model.fit(X_train,y_train)
    test_pred = np.array(model.predict(X_test))
    RMSE=np.sqrt(np.sum(np.square(test_pred-y_test)))
    test_score = model.score(X_test,y_test)

但是嘿,代码是给机器用的!对于普通人来说,我们需要便利贴。因此,这是相同的注释版本,带有注释和评论:)

为了进一步提炼,下面是更正式的流程…

让我们讨论结果!

对于所有的模型,我们还捕获测试误差、训练误差(均方根)和惯用的 R 系数作为模型精度的度量。这是我们绘图后它们的样子,

****

这些图回答了我们之前的两个问题:

  • 我们确实需要 4 次或 5 次多项式来模拟这种现象。线性、二次甚至三次模型对于拟合数据来说都不够复杂。
  • 但是,我们不应该需要超越第五度和过于复杂的模型。想一想这个 奥卡姆剃刀边界 为我们的模型。

但是,嘿,这条曲线中熟悉的偏差/方差权衡(又名欠拟合/过拟合)形状在哪里呢?对于过于复杂的模型,为什么测试误差不会急剧上升?

答案在于这样一个事实:使用 LASSO 回归,我们基本上消除了更复杂模型中的高阶项。要了解更多细节,以及为什么会发生这种情况的一些奇妙的直觉推理,请阅读这篇文章或观看下面的视频。事实上,这是套索回归或 L1 范数惩罚的主要优点之一,它将一些模型系数精确地设置为零,而不是仅仅缩小它们。实际上,这会为您执行“自动特征选择”,即让您自动忽略不重要的特征,即使您开始使用高度复杂的模型来拟合数据。

我们可以通过不进行正则化并使用来自 scikit-learn 的简单的线性回归模型类来轻松测试这一点。这是那种情况下的结果。熟悉的偏差-方差形状出现在模型复杂度与误差图中。

那么,有噪声的数据会怎么样呢?

您可以下载我的代码并尝试更改*noise_magnitude*参数,以查看向数据集添加噪声的影响。噪声使得模型很难无偏差,并且它还将模型推向过拟合,因为模型试图理解有噪声的数据模式,而不是发现真正的模式,它使自己适应噪声。基本上,简单的线性回归模型(w/o 正则化)在这种情况下会惨败。正则化模型仍然表现良好,但是即使正则化模型性能也开始出现偏差-方差权衡。这是总结,

收场白

因此,简而言之,我们讨论了在存在噪声的情况下,将多变量回归模型拟合到具有高度非线性和相互耦合项的数据集的系统方法。我们看到了如何利用 Python 机器学习库来生成多项式要素、归一化数据、拟合模型、防止系数变得过大从而保持偏差-方差平衡,以及绘制回归分数来判断模型的准确性和稳健性。

对于具有非多项式特征的更高级类型的模型,您可以检查 scikit-learn's stable 的内核回归支持向量回归机模型。还有,看看这篇关于高斯核回归的漂亮文章。

** [## Tirthajyoti Sarkar - Sr .首席工程师-半导体、人工智能、机器学习- ON…

佐治亚理工学院理学硕士- MS,分析这一 MS 计划传授理论和实践…

www.linkedin.com](https://www.linkedin.com/in/tirthajyoti-sarkar-2127aa7/)

如果您有任何问题或想法可以分享,请通过tirthajyoti[AT]Gmail[DOT]com联系作者。你可以查看作者的 GitHub 资源库 中其他有趣的 Python、R 或 MATLAB 代码片段和机器学习资源。此外,如果你像我一样对机器学习/数据科学/半导体充满热情,请随时在 LinkedIn 上添加我在 Twitter 上关注我。**

了解面向 TensorFlow 的 Swift

原文:https://towardsdatascience.com/machine-learning-with-swift-for-tensorflow-9167df128912?source=collection_archive---------4-----------------------

S 用于 TensorFlow 的 wift 由克里斯·拉特纳在 2018 年 TensorFlow 开发峰会上推出。2018 年 4 月 27 日,谷歌团队在他们的 GitHub 知识库上首次向公众社区发布。但 Swift for TensorFlow 仍处于起步阶段。而且开发人员/研究人员在项目中使用它似乎还为时过早。如果您仍有兴趣试用,请从 Swift 官网为 TensorFlow 的快照安装 Swift。

Swift for TensorFlow (Image Source)

在本文中,我将重点解释以下主题:

  • 访问 Python APIs 和PyValue (Python 的 Swift 动态系统)
  • Swift 中的自动区分系统
  • 对 TensorFlow 的 Swift 中的Tensor s 执行计算
  • 训练神经网络

Swift for TensorFlow 很可能会像 Swift 和 TensorFlow 独立完成的那样,与开源社区一起快速发展。因此,这可能是一个值得努力去了解它的东西。

注意 :关于 TensorFlow 的 Swift 需要注意的一个主要问题是,它是一个由运行定义的框架。这意味着,尽管 Swift for TensorFlow 在后台创建图表(如 TensorFlow ),但您不必为执行这些图表创建会话。这种方法类似于 TensorFlow 中的急切执行。

1.主要特点

  • 自动反向微分(正向尚未实现)
  • 运行定义设计(不需要会议)
  • Swift 经过优化,包含机器学习特定功能
  • 允许 Python APIs 以 Python 方式访问
  • 包括用于 Python 的动态系统行为的PyValue类型

2.Python 互操作性

借助 Swift for TensorFlow,我们可以以最 Python 化的方式使用 Python APIs。要访问 Python APIs,必须进入程序,如下面的示例代码片段所示。

import Pythonlet np = Python.import("numpy")  // akin to `import numpy as np`
let pickle = Python.import("pickle")
let gzip = Python.import("gzip")

而用于 TensorFlow 的 Swift 也有一个名为PyValue的新类型,它展示了 Python 在 Swift 中的完整动态类型系统行为,而不影响 Swift 中其他类型的行为。

var x: PyValue = 3.14159
print(x * 2)  // Prints "6.28318"
x = "string"
print("now a " + x)  // Prints "now a string"

更多信息请参考官方的 Python 互操作性文档。

3.自动微分

Swift for TensorFlow 内置了对计算函数相对于其他变量的梯度的支持。该功能已被直接整合到 Swift 的编译器中,以优化行为。它支持两种差分功能:#gradient(of:withRespectTo:)#valueAndGradient(of:)。虽然它对我不起作用😩(还为时过早)但是文档中说要遵循下面的语法。这段代码片段来自官方的 d 文档。

@differentiable(reverse, adjoint: dTanh)
func tanh(_ x: Float) -> Float {
  // ... some super low-level assembly tanh implementation ...
}
func dTanh(x: Float, y: Float, seed: Float) -> Float {
  return (1.0 - (y * y)) * seed
}// Get the gradient function of tanh.
let dtanh_dx = #gradient(of: tanh)
dtanh_dx(2)
// Get the gradient function of foo with respect to the first parameter.
let dfoo_dx = #gradient(of: foo, withRespectTo: .0)
dfoo_dx(3, 4)

目前仅允许自动反向微分,正向微分正在讨论中。

4.使用张量

作为一个简单的例子,我们将创建一个Tensor实例,在其上我们使用 TensorFlow 应用一些操作。

import TensorFlowvar x = Tensor([[1, 2], [3, 4]])
for _ in 1...5 {
  x += x
}
print(x)  // Prints "[[32.0, 64.0], [96.0, 128.0]]"

在上面的代码中使用了基本的+操作符,它在一个循环中将Tensor添加到自身中。这之所以成为可能,是因为 Swift 的高级操作符功能为Tensor实例提供了过载功能。

5.训练一个简单的前馈神经网络

转向神经网络——机器学习在这个时代流行的真正原因。在本节中,我们将教授我们的 3 层完全连接的前馈神经网络来预测来自 MNIST 数据集的图像中的数字。从 Swift 文件中的 tensor flowimport TensorFlow开始。

** 😗* 训练代码可以在这里找到如果有人不耐烦的话。

我们的神经网络将有 3 层:

  • 输入层:它将输入数据(在我们的例子中是像素值)呈现给神经网络。在我们的例子中,每个图像有 784 个值。
  • 隐藏层:它用权重和偏差计算我们输入数据的仿射变换。然后将一个 sigmoid 激活函数应用于变换。我们示例中的隐藏层将有 30 个单元(神经元)。
  • 输出层:隐藏层的数据再次经过仿射变换和一个 sigmoid 函数的应用,就像形成输出层之前一样。这是预测发生的地方。我们在这一层有 10 个单元,每个单元代表在图像中成为特定数字的概率。还要注意,我们在该层中使用one-hot/1-of-k编码,其中在一维张量中,除了所有其他值为 0 之外,单个值为 1。例如,[0,0,1,0,0,0,0,0,0,0]表示输出[预测]层图像中的两位数。

仿射变换基本上是数据与权重的点积,然后是偏差的增加,随后是激活函数的逐元素应用。以下是输入数据的仿射变换的方程式 x.

o(x;W,b)= f(wx+b)

在这里, *O(。)*是输出函数, *f(。)*是激活函数(我们这里是 sigmoid), W 是权重矩阵, b 是偏置向量,代表点积。

我们使用 sigmoid 激活函数,因为它将值压缩到限制输出范围的范围[0,1],从而提供输出层图像中可能数字的概率。

5.1 读取 MNIST 数据

让我们读取数据集并构建这些图像和标签的Tensor实例。我们必须创建Tensor对象,因为这是 TensorFlow 模型(神经网络)允许流经的对象,因此得名。

let (images, numericLabels) = readMnist(imagesFile: imagesFile,labelsFile: labelsFile)
let labels = Tensor<Float>(oneHotAtIndices: numericLabels, depth: 10)

5.2 超参数

我们定义了 3 个超参数:学习率、训练损失和迭代步骤。

let iterationCount: Int32 = 20
let learningRate: Float = 0.2
var loss = Float.infinity

5.3 可训练参数

接下来,我们根据张量流的Tensor类型创建 2 个权重矩阵、2 个偏置向量,如下所示。

var w1 = Tensor<Float>(randomUniform: [784, 30])
var w2 = Tensor<Float>(randomUniform: [30, 10])
var b1 = Tensor<Float>(zeros: [1, 30])
var b2 = Tensor<Float>(zeros: [1, 10])

5.4 训练循环

训练循环是神经网络进行学习的代码块。我们通过网络传递图像和标签Tensor(正向传递)。然后计算预测中的误差,然后将它们反向传播以计算可训练参数的梯度。接下来,我们在学习率的帮助下,使用相应的梯度来降低这些参数。最后计算损失,给出我们离图像的真实标签有多远的概念。每个步骤描述如下。

5.4.1 向前传球

如上所述,输入图像像素值经过仿射变换。这里的值是带权重的点积,然后加上偏差,偏差进一步通过 s 形激活函数(按元素方式应用)。

let z1 = images ⊗ w1 + b1
let h1 = sigmoid(z1)
let z2 = h1 ⊗ w2 + b2
let predictions = sigmoid(z2)

这里需要注意的一点是 Swift 使用⊗ unicode 来表示点积,这表明 Swift 语言实际上是多么酷!坦白说,我真的很喜欢♥️这种编程语言。

5.4.2 反向传递(计算梯度)

反向传递计算预测和真实标签之间的误差。这些误差然后通过网络反向传播,计算可学习参数的梯度。

let dz2 = predictions - labels
let dw2 = h1.transposed(withPermutations: 1, 0) ⊗ dz2
let db2 = dz2.sum(squeezingAxes: 0)
let dz1 = dz2.dot(w2.transposed(withPermutations: 1, 0)) * h1 * (1 - h1)
let dw1 = images.transposed(withPermutations: 1, 0) ⊗ dz1
let db1 = dz1.sum(squeezingAxes: 0)

5.4.3 下降参数

现在,我们用它们的梯度和决定神经网络学习它的参数的速度的学习速率来降低参数,以便在下一次输入图像被馈送给它时预测真实值。

w1 -= dw1 * learningRate
b1 -= db1 * learningRate
w2 -= dw2 * learningRate
b2 -= db2 * learningRate

5.4.4 更新损失

我们更新损失值以查看我们与真实标签的接近程度,以便下次更正确地预测数字图像。

loss = dz2.squared().mean(squeezingAxes: 1, 0).scalarized()

让我们现在打印我们的损失,它告诉我们如何从我们的训练集中学习识别数字图像。越低的损失越好是我们网络识别的任务。

print("Loss: \(loss)")  // Prints "0.1"

6.摘要

在本文中,我们了解了用于 TensorFlow 的 Swift,以及它的易用性,因为 Swift 与 Python 非常相似,看起来像脚本语言,但速度非常快。我们看到 Swift for TensorFlow 允许我们使用 Python APIs,而且 Swift 的编译器已经过深度优化,内置了对自动微分的支持,这对机器学习任务非常重要。我们还看到了如何在 Swift 中使用 TensorFlow,我们创建了自己的Tensor实例,并对它们进行了一些处理(使用基本操作符+)。最后,我们训练了三层神经网络来解决传统的数字图像识别问题。

7.讨论

似乎 Swift 的名称应该是tensor flow,而不是 TensorFlow 的 Swift。事实并非如此,因为实际上 Swift 的编译器已被修改为支持 TensorFlow,因此 Swift 不仅充当 Python 库和 TensorFlow 的包装器,现在更像是机器学习语言。为了在整个机器学习和数据科学社区中保持工作流的一致性(因为 Python 被大量使用),它还允许以 Python 的方式访问 Python APIs,并且还为 Python 的动态系统类型行为实例提供了一种新的类型。

最后一句话,用于 TensorFlow 的 Swift 是由 Google 开发的,因此它很有可能在未来的时代变得著名。它还试图利用原始 TensorFlow 实现的最佳功能,如 eager-execution。

8.参考

[1] Swift for TensorFlow ,谷歌

Swift.org,苹果

[3] Python 的互操作性

[4]Swift 中的自动微分

[5]Swift 编程语言(Swift 4.1):高级操作员

[6]Swift for tensor flow:MNIST 示例

如果你觉得这篇文章有用/有见识,请鼓掌👏这样其他人也可以找到它,或者你也可以在社交网络上分享它。如果你在我的解释中发现了一些错误(也许我解释错了),或者你从这篇文章中有什么不清楚的地方,你也可以在下面发表评论。

保持【机器】学习,直到你化石燃料!🤘🤖

Google 云平台上 TensorFlow 的机器学习:代码示例

原文:https://towardsdatascience.com/machine-learning-with-tensorflow-on-google-cloud-platform-code-samples-7c1bc07cd265?source=collection_archive---------4-----------------------

在过去的几个月里,我的团队一直致力于在 Coursera 上创建两个 5 门课程的专业,名为“谷歌云平台上的机器学习”和“GCP 上的高级机器学习”。完整的 10 个课程的旅程将带你从一个战略概述为什么 ML 的重要性,所有的方式来建立定制序列模型和推荐引擎。

The first course in our 10-course specialization on Coursera launched this week, but the labs for all 10 courses are already available for you to use as a starting point for your models.

这些课程提供了一个互动的,实用的,务实的方法来快速有效地开始做 ML。虽然有许多理论上的机器学习课程,但我这个专业的目标是提供实践培训,以便你可以立即投入运行。为了让你快速起步,课程附带了大量的开源示例 TensorFlow 应用,你可以立即学习、培训/部署。

GCP 系列机器学习第一课。 谷歌如何做到 ML ,现已在 Coursera 上直播。请去参加课程,并参加剩余的课程,因为它们每隔几周出现一次。

但是,即使你在等待令人敬畏的演示者团队来教授课程,专业化实验室的源代码已经可用。在这篇博文中,我将列出 GitHub repo 的每个文件夹中的可用内容:

01.谷歌如何做 ML

data_analysis.ipynb 向您展示如何对大型数据集进行数据分析:

mlapis.ipynb 向您展示如何调用预先训练的 ML 模型:

02.启动到 ML

repeatable _ splitting . ipynb说明了数据可重复拆分的重要性

create_datasets.ipynb 向您展示如何使用 Pandas 和 BigQuery 探索和创建数据集

03.张量流简介

a_tfstart.ipynb 向您展示如何使用 TensorFlow 作为数值软件包

b_estimator.ipynb 向您展示如何在 TensorFlow 中编写简单的 ML 模型

c_batched.ipynb 向您展示如何在 TensorFlow 中处理大型数据集

d_traineval.ipynb 向您展示如何使用 TensorFlow 进行分布式训练

debug_demo.ipynb 向您展示如何调试 TensorFlow 程序

e_cloudmle.ipynb 向您展示如何部署 TensorFlow 模型,并使用云 ML 引擎以无服务器的方式进行预测

04.特征工程

a_features.ipynb 说明了正确表示特征的重要性

数据流展示了如何使用 Apache Beam on Cloud 数据流进行预处理

taxifeateng 向您展示如何在 TensorFlow 模型中实现特征工程

05.ML 的艺术与科学

a_handtuning.ipynb 向您展示如何更改与 TensorFlow 模型相关的各种参数,以获得更高的精度

b_hyperparam.ipynb 向您展示如何在 Cloud ML Engine 上自动调优 TensorFlow 模型,这样您就不必进行手动调优。

c_neuralnetwork.ipynb 向您展示如何以最简单的方式在 TensorFlow 中使用分布式神经网络模型进行训练和预测。

d_customestimator.ipynb 向您展示如何采用您在论文中找到的模型,并以分布式和可扩展的方式实现。

06.结构化数据上的端到端机器学习

这套笔记本:

1_explore.ipynb 向您展示了如何使用 Pandas 和 BigQuery 来浏览数据

2_sample.ipynb 向您展示如何重复分割数据

3_tensorflow.ipynb 向您展示如何在数据上构建一个估计器模型

4_preproc.ipynb 向您展示如何使用数据流大规模预处理数据

4_preproc_tft.ipynb 向您展示如何使用 TF 大规模预处理数据。改变

5_train.ipynb 向您展示如何在云 ML 引擎上训练 TensorFlow 模型

6_deploy.ipynb 向您展示如何将训练好的模型部署到云 ML 引擎

服务向您展示如何从 web 应用程序和数据管道中访问 ML 预测。

以上 7 个实验总结了前六个课程在一个现实问题上的经验,带您从数据探索到部署和预测。

07.生产 ML 模型

这一个没有实验—这是关于 ML 模型的设计和架构考虑。

08.图像分类模型

mnist_estimator.ipynb 向您展示如何使用 Estimator API 构建图像分类器

向您展示如何使用所有技巧(卷积层、扩充、批量标准化等)构建一个定制的评估器。)进入一个好的图像分类模型

flowers _ from scratch . ipynb向您展示如何将之前笔记本中的图像模型应用于“真实”图像。

迁移学习和 AutoML 的实验不在 GitHub 中,因为它们不涉及任何编码——只需点击!

09.时间序列和文本序列模型

sinewaves.ipynb 向您展示如何使用包括 CNN 和 LSTMs 在内的各种技术在 TensorFlow 中构建时间序列预测模型。

temperature.ipynb 说明了 LSTMs 有多难做对

txtcls1.ipynb 向您展示了如何使用各种技术(包括 CNN 和 LSTMs)从头开始构建文本分类模型

txtcls2.ipynb 向您展示如何在文本分类模型中使用预训练的单词嵌入。

word2vec.ipynb 向你展示了如何从你自己的数据集中创建一个单词嵌入。

poem . ipynb向您展示如何使用 Tensor2Tensor 解决您自己的文本问题,无论是文本摘要还是文本生成

10.推荐引擎

显示了一个基于内容的推荐系统的例子

wals.ipynb 向您展示如何在 TensorFlow 中构建协同过滤推荐系统

wals_tft.ipynb 通过添加 tf.transform 管道来自动映射唯一的用户标识和项目标识,使协作过滤模型可以投入生产。

随着 ML 的成熟,当然会有更多的实验室,上面的一些实验室可能是不必要的。GitHub repo 是一个动态存储库,我们计划保持它的最新状态,并反映建议的 TensorFlow 实践。因此,如果您正在构建自己的 ML 模型,笔记本(及其相应的模型目录)是一个很好的起点。

探索愉快!

机器学习—使用 Keras 进行单词嵌入和情感分类

原文:https://towardsdatascience.com/machine-learning-word-embedding-sentiment-classification-using-keras-b83c28087456?source=collection_archive---------0-----------------------

的上一篇文章中,我们讨论了自然语言处理(NLP)中文本处理的各个步骤,并且使用一些经典的 ML 技术实现了一个基本的情感分析器。

深度学习已经在包括 NLP、计算机视觉和游戏在内的各种任务上表现出优异的性能。为了进一步探索,我们将讨论和使用一些基于深度学习的高级 NLP 技术,来创建一个改进的情感分类器。

Courtesy (KDnuggets)

情感分类问题

情感分类的任务是查看一段文本,并判断某人是否喜欢或不喜欢他们正在谈论的事情。

输入 X 是一段文本,输出 Y 是我们想要预测的情感,比如电影评论的星级。

如果我们可以训练一个系统根据上面的标签数据集从 X 映射到 Y,那么这样的系统可以用来预测一个评论者在看完电影后的情绪。

在本帖中,我们将重点关注以下任务:

  • 构建深度神经网络进行情感分类。
  • 学习单词嵌入:一边训练网络,一边使用 Word2Vec。

体系结构

深度学习文本分类模型架构通常由以下顺序连接的组件组成:

Deep Learning Architecture

  • 嵌入层
***Word Embedding*** *is a representation of text where words that have the same meaning have a similar representation. In other words it represents words in a coordinate system where related words, based on a corpus of relationships, are placed closer together.* In the deep learning frameworks such as TensorFlow, Keras, this part is usually handled by an **embedding layer** which stores a lookup table to map the words represented by numeric indexes to their dense vector representations.
  • 深层网络
Deep network takes the sequence of embedding vectors as input and converts them to a compressed representation. The compressed representation effectively captures all the information in the sequence of words in the text. The deep neywrok part is usually an RNN or some forms of it like LSTM/GRU. The dropout is added to overcome the tendency to overfit, a very common problem with RNN based networks. Please refer [here](/illustrated-guide-to-lstms-and-gru-s-a-step-by-step-explanation-44e9eb85bf21) for detailed discussion on LSTM,GRU.
  • 全连接层
The **fully connected layer** takes the deep representation from the RNN/LSTM/GRU and transforms it into the final output classes or class scores. This component is comprised of fully connected layers along with batch normalization and optionally dropout layers for regularization.
  • 输出层
Based on the problem at hand, this layer can have either **Sigmoid** for binary classification or **Softmax** for both binary and multi classification output.

数据集

IMDB 电影评论集可以从这里下载。这个用于二元情感分类的数据集包含用于训练的 25,000 条高度极性的电影评论,以及用于测试的 25,000 条评论。初始预处理后的数据集保存到movie_data.csv文件。首先,我们加载 IMDb 数据集,文本评论分别被标记为正面和负面情绪的 1 或 0。

IMDb movie review dataset

学习单词嵌入

我们数据集的单词嵌入可以在训练关于分类问题的神经网络时学习。在将文本数据呈现给网络之前,首先对其进行编码,以便每个单词由一个唯一的整数表示。这个数据准备步骤可以使用 Keras 提供的 Tokenizer API 来执行。我们添加填充,使所有的向量长度相同(*max_length*)。下面的代码将文本转换为整数索引,现在可以在 Keras 嵌入层中使用。

嵌入层需要词汇表大小(vocab_size)、实值向量空间大小EMBEDDING_DIM = 100和输入文档最大长度max_length的规范。

建立模型

我们现在准备定义我们的神经网络模型。该模型将使用一个嵌入层作为第一个隐藏层。嵌入层用随机权重初始化,并将在模型训练期间学习训练数据集中所有单词的嵌入。

该模式的总结是:

出于演示目的,我们使用了一个简单的深层网络配置。您可以尝试不同的网络配置并比较性能。嵌入参数计数12560200 = (vocab_size * EMBEDDING_DIM)。最大输入长度max_length = 2678。训练期间的模型将从输入文本中学习单词嵌入。可训练参数总数为 12,573,001。

火车模型

现在让我们在训练集上训练模型,并在测试集上交叉验证。我们可以从下面的训练时期看到,每个时期之后的模型都在提高精度。几个时期之后,我们达到了大约 84%的验证准确度。还不错:)

试验模型

我们可以用一些样本评论来测试我们的模型,以检查它是如何预测每个评论的情绪的。首先,我们必须将文本审查转换为令牌,并使用模型预测如下。

输出给出单词的预测是 1(正面情绪)或 0(负面情绪)。

接近 1 的值是强烈的积极情绪,接近 0 的值是强烈的消极情绪。我可以清楚地看到,模型预测对于 test_sample_7 是错误的,而对于其余的样本却表现得相当好。

在上述方法中,我们学习单词嵌入作为拟合神经网络模型的一部分。

训练 word2vec 嵌入

还有另一种方法来构建情感澄清模型。我们可以先单独学习单词嵌入,然后传递到嵌入层,而不是训练嵌入层。这种方法还允许使用任何预先训练的单词嵌入,并且还节省了训练分类模型的时间。

我们将使用 Word2Vec 的 Gensim 实现。第一步是通过创建单词标记、去除标点符号、去除停用词等来准备用于学习嵌入的文本语料库。word2vec 算法逐句处理文档。

我们的文本语料库中有 50000 条评论。Gensim 的 Word2Vec API 需要一些参数进行初始化。

一.sentences–句子列表;这里我们通过复习句子列表。

二。我们希望用多少维度来表达我们的话语。这是单词向量的大小。

三。min_count–只有频率大于min_count的词才会被纳入模型。通常,你的文本越大越广泛,这个数字就越高。

四。window–只有出现在窗口-一个句子中某个术语的邻近区域内的术语,才会在训练过程中与之相关联。通常的值是 4 或 5。

动词 (verb 的缩写)workers–训练并行化中使用的线程数量,以加快训练速度

测试 Word2Vec 模型

在我们在 IMDb 数据集上训练模型之后,它建立了一个词汇表size = 134156。让我们尝试一些从电影评论数据集学习的单词嵌入模型。

与单词horrible 最相似的单词是:

most similar words

试着对单词 vectors 做些数学计算— woman+king-man=?

让我们找到那个奇怪的单词woman, king, queen, movie = ?

看到我们的 word2vec 模型从文本语料库中学习到的单词嵌入是非常有趣的。下一步是在我们的情感分类模型的嵌入层中直接使用单词嵌入。我们可以保存模型以备后用。

使用预先训练的嵌入

因为我们已经用 IMDb 数据集训练了 word2vec 模型,所以我们已经准备好使用单词嵌入了。下一步是将单词 embedding 作为单词目录加载到 vectors 中。单词 embedding 保存在文件imdb_embedding_word2vec.txt中。让我们从存储的文件中提取单词 embeddings。

下一步是将单词 embedding 转换成标记化的向量。回想一下,评审文档在传递到嵌入层之前是整数编码的。整数映射到嵌入层中特定向量的索引。因此,重要的是我们在嵌入层中布置矢量,使得编码的字映射到正确的矢量。

现在,我们将把每个单词的嵌入从加载的 word2vec 模型映射到 tokenizer_obj.word_index词汇表,并创建一个单词向量矩阵。

我们现在已经准备好将训练好的嵌入向量直接用于嵌入层。在下面的代码中,与先前模型的唯一变化是使用embedding_matrix作为嵌入层的输入并设置trainable = False,因为嵌入已经被学习。

Model summary with pre- trained Embedding

仔细看,你可以看到型号total params = 13,428,501而不是trainable params = 12801。由于该模型使用预训练的单词嵌入,它具有非常少的可训练参数,因此应该训练得更快。

为了训练情感分类模型,我们使用VALIDATION_SPLIT= 0.2,你可以改变它来观察对模型准确性的影响。

最后,在训练和验证测试集上训练分类模型,我们随着每个历元的运行而获得准确度的提高。我们仅用大约 5 个时期就达到了 88%的准确率。

你可以尝试通过改变超参数、运行更多的历元等来提高模型的准确性。此外,您可以使用其他一些预先训练好的嵌入,这些嵌入是在非常大的文本数据语料库上准备的,您可以直接下载

结论

在这篇文章中,我们详细讨论了用于情感分类的深度学习模型的架构。我们还训练了一个 word2vec 模型,并将其用作情感分类的预训练嵌入。

感谢阅读,如果你喜欢,请为它鼓掌。

进一步阅读

http://ruder.io/deep-learning-nlp-best-practices

[## 功能 API - Keras 文档指南

让我们考虑下面的模型。我们试图预测一个新闻标题在……上会有多少转发和点赞

keras.io](https://keras.io/getting-started/functional-api-guide/) [## 如何开发预测电影评论情感的单词嵌入模型

单词嵌入是一种表示文本的技术,其中具有相似含义的不同单词具有相似的…

machinelearningmastery.com](https://machinelearningmastery.com/develop-word-embedding-model-predicting-movie-review-sentiment/)

Rajesh Arumugam 的 Python 自然语言处理实践,Rajalingappaa Shanmugamani,2018 年 7 月

糖尿病数据的机器学习工作流程:第 1 部分

原文:https://towardsdatascience.com/machine-learning-workflow-on-diabetes-data-part-01-573864fcc6b8?source=collection_archive---------1-----------------------

“医疗环境中的机器学习可以帮助显著增强医疗诊断。”

本文将描述如何利用与糖尿病相关的数据来预测一个人是否患有糖尿病。更具体地说,本文将重点关注如何利用机器学习来预测糖尿病等疾病。在本系列文章结束时,您将能够理解数据探索、数据清理、特性选择、模型选择、模型评估等概念,并以实际的方式应用它们。

什么是糖尿病?

糖尿病是一种当血糖水平变高时发生的疾病,最终会导致其他健康问题,如心脏病、肾病等。糖尿病主要是由于食用高度加工食品、不良消费习惯等引起的。据世卫组织报道,这些年来糖尿病患者的数量一直在增加。

先决条件

  • Python 3。+
  • 蟒蛇(Scikit Learn,Numpy,Pandas,Matplotlib,Seaborn)
  • 朱庇特笔记本。
  • 对监督机器学习方法的基本理解:特别是分类。

第 0 阶段—数据准备

作为一名数据科学家,我们遇到的最乏味的任务是获取和准备数据集。即使这个时代有大量的数据,仍然很难找到一个合适的数据集来解决你试图解决的问题。如果找不到任何合适的数据集,您可能需要创建自己的数据集。

在本教程中,我们不会创建自己的数据集,相反,我们将使用由 UCI 机器学习资源库(著名的机器学习数据集资源库)提供的名为“ 皮马印第安人糖尿病数据库 ”的现有数据集。我们将使用上面提供的糖尿病数据集执行机器学习工作流。

第一阶段—数据探索

当遇到一个数据集时,首先我们应该分析并"了解"这个数据集。这一步对于熟悉数据、了解潜在特征以及确定是否需要清理数据是必要的。

首先,我们将导入必要的库,并将数据集导入 Jupyter 笔记本。我们可以观察数据集中提到的列。

%matplotlib inline
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as snsdiabetes = pd.read_csv('datasets/diabetes.csv')
diabetes.columns 

指数(['妊娠','血糖','血压','皮肤厚度','胰岛素',
,'身体质量指数','糖尿病患者血糖','年龄','结果'],
dtype= '对象')

重要提示:需要注意的是,上述数据集仅包含有限的特征,而实际上有许多特征在起作用。

我们可以使用熊猫的 head() 方法来检查数据集。

diabetes.head()

Fig — Diabetes data set

我们可以使用 panda Dataframes 的“shape”属性找到数据集的维度。

print("Diabetes data set dimensions : {}".format(diabetes.shape))

糖尿病数据集维度:(768,9)

我们可以观察到数据集包含 768 行和 9 列。结果是我们将要预测的列,表示患者是否患有糖尿病。1 表示该人是糖尿病患者,0 表示该人不是。我们可以确定,在 768 人中,500 人被标记为 0(非糖尿病),268 人被标记为 1(糖尿病)

diabetes.groupby('Outcome').size()

Fig— Class distribution

数据可视化是数据科学的一个重要方面。这有助于理解数据,也有助于向他人解释数据。Python 有几个有趣的可视化库比如 Matplotlib,Seaborn 等。

在本教程中,我们将使用构建在 matplotlib 之上的 pandas 可视化工具来查找要素的数据分布。

Fig— Data distribution

我们可以使用下面的代码分别为这两个响应绘制直方图。(此处未显示图像。)

diabetes.groupby(‘Outcome’).hist(figsize=(9, 9))

阶段 2—数据清理

机器学习工作流程的下一个阶段是数据清理。被认为是工作流程的关键步骤之一,因为它可以决定模型的成败。机器学习中有一句谚语**“更好的数据胜过更好的算法”**,这表明更好的数据会给你带来更好的结果模型。

在数据清理过程中,有几个因素需要考虑。

  1. 重复或不相关的观察。
  2. 数据标签错误,同一类别出现多次。
  3. 数据点缺失或为空。
  4. 意外的异常值。

在本教程中,我们不会详细讨论数据清理过程。

由于我们使用的是标准数据集,我们可以有把握地假设因素 1、2 已经处理过了。意外的异常值要么有用,要么有潜在的危害。

缺失或空数据点

我们可以使用下面的 pandas 函数找到数据集的任何缺失或空数据点(如果有的话)。

diabetes.isnull().sum()
diabetes.isna().sum()

我们可以观察到数据集中没有数据点丢失。如果有,我们应该相应地处理它们。

Fig — Observe missing data

意外异常值

当分析直方图时,我们可以发现在一些列中有一些异常值。我们将进一步分析这些异常值,并确定我们可以做些什么。

**血压:**通过观察数据我们可以看到,血压有 0 个值。很明显,数据集的读数似乎是错误的,因为一个活人的舒张压不可能为零。通过观察数据,我们可以看到值为 0 的 35 个计数。

print("Total : ", diabetes[diabetes.BloodPressure == 0].shape[0])Total :  35print(diabetes[diabetes.BloodPressure == 0].groupby('Outcome')['Age'].count())Outcome
0    19
1    16
Name: Age, dtype: int64

**血浆葡萄糖水平:**即使空腹后血糖水平也不会低至零。因此,零是无效的读数。通过观察数据,我们可以看到值为 0 的 5 个计数。

print("Total : ", diabetes[diabetes.Glucose == 0].shape[0])Total :  5print(diabetes[diabetes.Glucose == 0].groupby('Outcome')['Age'].count())Total :  5
Outcome
0    3
1    2
Name: Age, dtype: int64

**皮褶厚度:**对于正常人来说,皮褶厚度不可能小于 10 mm 最好为零。值为 0: 227 的总计数。

print("Total : ", diabetes[diabetes.SkinThickness == 0].shape[0])Total :  227print(diabetes[diabetes.SkinThickness == 0].groupby('Outcome')['Age'].count())Outcome
0    139
1     88
Name: Age, dtype: int64

身体质量指数:不应该是零或接近零,除非这个人真的体重不足,这可能会危及生命。

print("Total : ", diabetes[diabetes.BMI == 0].shape[0])Total :  11print(diabetes[diabetes.BMI == 0].groupby('Outcome')['Age'].count())Outcome
0    9
1    2
Name: Age, dtype: int64

**胰岛素:**在极少数情况下,一个人可以没有胰岛素,但通过观察数据,我们可以发现总共有 374 个计数。

print("Total : ", diabetes[diabetes.Insulin == 0].shape[0])Total :  374print(diabetes[diabetes.Insulin == 0].groupby('Outcome')['Age'].count())Outcome
0    236
1    138
Name: Age, dtype: int64

以下是处理无效数据值的几种方法:

  1. 忽略/删除这些情况:这在大多数情况下实际上是不可能的,因为这将意味着丢失有价值的信息。在这种情况下,“皮肤厚度”和“胰岛素”列意味着有许多无效点。但它可能适用于“身体质量指数”、“葡萄糖”和“血压”数据点。
  2. 放入平均值:这可能对一些数据集有效,但是在我们的例子中,把平均值放入血压列会给模型发送一个错误的信号。
  3. 避免使用特性:对于模型来说,不使用具有大量无效值的特性是可能的。这可能对“皮肤厚度”有效,但很难预测。

在数据清理过程结束时,我们得出结论,这个给定的数据集是不完整的。由于这是机器学习的演示,我们将对给定的数据进行一些小的调整。

我们将删除“血压”、“身体质量指数”和“葡萄糖”为零的行。

diabetes_mod = diabetes[(diabetes.BloodPressure != 0) & (diabetes.BMI != 0) & (diabetes.Glucose != 0)]print(diabetes_mod.shape)(724, 9)

第 3 阶段—特征工程

特征工程是将收集的数据转换为更好地代表我们试图解决的模型问题的特征的过程,以提高模型的性能和准确性。

特征工程从现有特征中创建更多的输入特征,并组合多个特征以生成更直观的特征来输入模型。

“特征工程使我们能够突出重要的特征,并便于将问题领域的专业知识带到桌面上来。尽管提供了许多输入特征,它还允许避免过度拟合模型”。

我们试图解决的问题领域需要许多相关的特性。由于数据集已经提供,并且通过检查数据,我们不能在这一点上进一步创建或删除任何数据。在数据集中,我们有以下特征。

怀孕','葡萄糖','血压','皮肤厚度','胰岛素','身体质量指数','糖尿病谱系功能','年龄'

通过粗略的观察,我们可以说“皮肤厚度”不是糖尿病的指标。但是我们不能否认在这一点上它是不可用的。

因此,我们将使用所有可用的功能。我们将数据集分成特征和我们将要预测的响应。我们将把特征分配给 X 变量的**,把响应分配给 y 变量。**

feature_names = ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age']X = diabetes_mod[feature_names]
y = diabetes_mod.Outcome

通常,特征工程在选择模型之前执行。然而,对于本教程,我们遵循不同的方法。最初,我们将利用数据集中提供给模型的所有功能,我们将再次讨论功能工程,以讨论所选模型的功能重要性。

这篇文章很好地解释了特征工程

阶段 4—型号选择

模型选择或算法选择阶段是最令人兴奋的,也是机器学习的核心。在这个阶段,我们选择最适合手头数据集的模型。

首先,我们将使用默认参数计算一组给定分类模型的**“分类准确度(测试准确度)”**,以确定哪个模型在糖尿病数据集上表现更好。

我们将为笔记本导入必要的库。我们导入 7 个分类器,即K-最近邻、支持向量分类器、逻辑回归、高斯朴素贝叶斯、随机森林和梯度提升作为最佳分类器的竞争者。

from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier

我们将使用默认参数初始化分类器模型,并将它们添加到模型列表中。

models = []models.append(('KNN', KNeighborsClassifier()))
models.append(('SVC', SVC()))
models.append(('LR', LogisticRegression()))
models.append(('DT', DecisionTreeClassifier()))
models.append(('GNB', GaussianNB()))
models.append(('RF', RandomForestClassifier()))
models.append(('GB', GradientBoostingClassifier()))

例:通常用 Scikit learn 训练模型如下。

KNN = KNeighborsClassifier()
KNN . fit(X _ train,y_train)

评估方法

通常的做法是避免对相同的数据进行训练和测试。原因是模型的目标是预测样本外数据,模型可能过于复杂,导致过度拟合。为了避免上述问题,有两个预防措施。

  1. 训练/测试分割
  2. k 倍交叉验证

我们将为训练/测试拆分导入*“train _ test _ split”*,为 导入“cross _ val _ score】k 倍交叉验证** *。【accuracy _ score】*是评估训练/测试拆分方法中模型的准确性。

from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

我们将执行上述方法,以找到性能最佳的基础模型。

训练/测试分割

这种方法将数据集分成两部分:一个训练集和一个测试集训练集用于训练模型。测试装置用于测试模型,评估精度。

优点:但是,训练/测试分割仍然有用,因为它的灵活性和速度

缺点:提供样本外精度的高方差估计

Fig — Train/Test Split

用 Scikit 学习进行训练/测试分割:

接下来,我们可以将特征和响应分成训练和测试部分。我们对样本进行分层(在此过程中,每个响应类别在每个部分中的比例应该相等)。

X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = diabetes_mod.Outcome, random_state=0)

然后,我们在一个循环中拟合每个模型,并使用*“accuracy _ score”*计算各个模型的精确度。

names = []
scores = []for name, model in models:
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    scores.append(accuracy_score(y_test, y_pred))
    names.append(name)tr_split = pd.DataFrame({'Name': names, 'Score': scores})
print(tr_split)

Fig — Train/Test Split Accuracy Scores

K 倍交叉验证

这种方法将数据集分成 K 个等分(“折叠”),然后使用 1 个折叠作为测试集,其他折叠的并集作为训练集。然后测试模型的准确性。该过程将遵循上述步骤 K 次,每次使用不同的折叠作为测试集。该工序的平均测试精度为测试精度。

**优点:**更精确的样本外精度估计。更“有效”地使用数据(每个观察结果都用于训练和测试)

**缺点:**比训练/测试分割慢得多。

Fig— 5-Fold cross validation process

在计算能力不匮乏的情况下,最好使用这种方法。从现在开始我们将使用这种方法。

使用 Scikit Learn 进行 K 倍交叉验证:

我们将继续进行 K-Fold 交叉验证,因为它更准确,并能更有效地利用数据。我们将使用 10 倍交叉验证来训练模型,并计算模型的平均准确度。“cross_val_score”提供了自己的训练和精度计算接口。

names = []
scores = []for name, model in models:

    kfold = KFold(n_splits=10, random_state=10) 
    score = cross_val_score(model, X, y, cv=kfold, scoring='accuracy').mean()

    names.append(name)
    scores.append(score)kf_cross_val = pd.DataFrame({'Name': names, 'Score': scores})
print(kf_cross_val)

Fig — K-Fold Cross Validation Accuracy Scores

我们可以使用 seaborn 来绘制准确度分数

axis = sns.barplot(x = 'Name', y = 'Score', data = kf_cross_val)
axis.set(xlabel='Classifier', ylabel='Accuracy')for p in axis.patches:
    height = p.get_height()
    axis.text(p.get_x() + p.get_width()/2, height + 0.005, '{:1.4f}'.format(height), ha="center") 

plt.show()

Fig — Accuracy of Classifiers

我们可以看到逻辑回归、高斯朴素贝叶斯、随机森林和梯度推进比其他方法表现得更好。从基础水平上,我们可以观察到逻辑回归比其他算法表现更好。

在基线时,逻辑回归设法实现了 77.64 %的分类准确度。这将被选为下一阶段的主要候选项目。

摘要

在本文中,我们讨论了基本的机器学习工作流程步骤,如使用 Scikit Learn 库进行数据探索、数据清理步骤、特征工程基础知识和模型选择。在下一篇文章中,我将更多地讨论特征工程和超参数调整。

更新

您可以在下面的链接中找到本系列的第 2 部分。

[## 糖尿病数据的机器学习工作流程:第 2 部分

在本系列的上一篇文章中,我们讨论了关于糖尿病数据集的机器学习工作流。还有…

towardsdatascience.com](/machine-learning-workflow-on-diabetes-data-part-02-11262b7f7a5c)

创建这篇文章的源代码可以在下面找到。

[## LahiruTjay/用 Python 学习机器

这个库包含了各种用 Python 完成的机器学习的例子。

github.com](https://github.com/LahiruTjay/Machine-Learning-With-Python/blob/master/Machine%20Learning%20Workflow%20on%20Diabetes%20Data.ipynb)

如果你对这篇文章有任何问题,请不要犹豫,在下面留言或者给我发电子邮件:lahiru.tjay@gmail.com

希望你喜欢这篇文章。干杯!!!

posted @ 2024-10-13 15:15  绝不原创的飞龙  阅读(41)  评论(0编辑  收藏  举报