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

龙哥盟 / 2024-10-13 / 原文

TowardsDataScience 博客中文翻译 2016~2018（二十七）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

数据科学的模型跟踪工具(mlflow)

原文：https://towardsdatascience.com/model-tracking-tools-for-data-science-mlflow-51b681f8452e?source=collection_archive---------7-----------------------

Source: https://www.recordedfuture.com/machine-learning-cybersecurity-applications/

在数据科学工作中，Jupyter 笔记本是一个众所周知的工具。除此之外，我们可能会使用 databricks 的笔记本或 Colab(由谷歌)。产品化怎么样？

如何将我们的模型部署到生产中？如果你使用 TensorFlow 库来建立模型，我们可以使用 tensorflow 服务。使用 Azure 平台的话可以用 Data Science Workbench。如果我们真的使用上面的解决方案呢？一些公司建立了内部系统，如米开朗基罗(优步)、 FBLearner Flow(脸书)。然而，那些平台是为它们的内部系统设计的。

我们有开源吗？在此之前，我们有 modeldb 。我们有了新的选择，mlflow，它刚刚在上周(2018 年 6 月 5 日)发布了 alpha 版本。让我们参观一下这个产品。

Source: https://sdtimes.com/ai/databricks-releases-mlflow-runtime-for-ml-and-databricks-delta-at-spark-ai-summit/

首先，您必须安装 mlflow，然后在命令行中执行以下命令来启动 UI 服务

mlflow ui

并执行以下命令将数据传递给服务器

lr = LogisticRegression(max_iter=param['max_iter'], penalty=param['penalty'], solver=param['solver'])
        lr.fit(x_train, y_train)
        y_pred = lr.predict(x_test)(rmse, mae, r2) = eval_metrics(y_test, y_pred)mlflow.log_metric("rmse", rmse)
        mlflow.log_metric("r2", r2)
        mlflow.log_metric("mae", mae)
        mlflow.log_param("max_iter", param['max_iter'])
        mlflow.log_param("penalty", param['penalty'])
        mlflow.log_param("solver", param['solver'])mlflow.sklearn.log_model(lr, "model")

稍后，转到 http://localhost:5000/

默认情况下，它会显示“日期”、“用户”、“源”、“版本”、“参数”和“指标”。

如需源代码，请访问 github 获取完整版本

估价

用户

系统将使用 pwd (linux 命令)来获取用户 ID。如果操作系统是 Window，它将使用“未知”的默认用户 ID。我相信他们对审计目的有所顾虑，这就是为什么他们不允许将用户 ID 作为参数传递。

# Copy from mlflow source code_DEFAULT_USER_ID = "unknown"def _get_user_id():
    *""" Gets the ID of the user for the current run. """* try:
        import pwd
        return **pwd.getpwuid(os.getuid())[0]**
    except ImportError:
        return _DEFAULT_USER_ID

那么我们能在 Window 中做些什么来“劫持”它呢？:)我们可以覆盖全局值(在 alpha 版本中有效)。但是，不建议这样做，因为这会破坏审计/安全考虑。

mlflow.tracking._DEFAULT_USER_ID = '[https://github.com/makcedward/](https://github.com/makcedward/)'

来源

默认情况下，带有路径的文件名将被用作源文件。强烈建议提供源代码，以便更好地使用 UI 搜索。

# Copy from mlflow source codedef _get_main_file():
    if len(sys.argv) > 0:
        return **sys.argv[0]**
    return None

版本

一般来说，版本号可能是“1.0.0”就可以了。但是，如果您定义的版本号是“123.456.789”或“测试”。你会有麻烦，因为用户界面显示多达 6 个字符。从源代码来看，它将版本简化为“shortVersion ”,允许最多 6 个字符。

# Copy from mlflow source codestatic renderVersion(run) {
  if (run.source_version) {
    **const shortVersion = run.source_version.substring(0, 6);**
    if (run.source_type === "PROJECT") {
      const GITHUB_RE = /[:@]github.com[:/]([^/.]+)\/([^/.]+)/;
      const match = run.source_name.match(GITHUB_RE);
      if (match) {
        const url = "https://github.com/" + match[1] + "/" + match[2] + "/tree/" + run.source_version;
        return <a href={url}>{shortVersion}</a>;
      }
    } else {
      return shortVersion;
    }
  }
  return null;
}

储存

记录将保存在文件系统中。换句话说，它不将数据持久化到 DB 中，并且它可能在 UI 搜索和其他系统问题中具有潜在的查询性能。相信将记录保存到数据库应该在路线图中。

API

API 接口由单线程的 Flask 构建。因此，它不能同时处理大量的请求。似乎在投入生产之前，必须先解决这个问题。

关于我

我是湾区的数据科学家。专注于数据科学、人工智能，尤其是 NLP 和平台相关领域的最新发展。

中:【http://medium.com/@makcedward/】T2

领英:【https://www.linkedin.com/in/edwardma1026

github:https://github.com/makcedward

https://www.kaggle.com/makcedward

使用 Python 和 Pyomo 对每周劳动力进行建模和优化

原文：https://towardsdatascience.com/modeling-and-optimization-of-a-weekly-workforce-with-python-and-pyomo-29484ba065bb?source=collection_archive---------5-----------------------

Credit: https://unsplash.com/@rawpixel

使用 Python 和 Pyomo 逐步建模和优化劳动力设计和分配问题。

在本帖中，我们将对一个调度问题进行建模和求解，在这个问题中，工人必须被分配到不同的班次，以优化给定的标准，满足不同的工作条件约束。

当开始一个新项目，计划开一家新商店，甚至准备大学的课程表时，负责任务的人有两种选择:手工求解或建模并作为优化问题求解。

即使有一个优秀的劳动力规划者，使用优化框架来处理这个问题也有很多好处:

扩展:问题可能会变得和适当的环境一样大，这可能会超出一个人的能力。
不平衡:在很多情况下，员工之间的不平衡是不可避免的。在这种情况下，决定将不是个人的。

Pyomo 作为优化建模环境

为了解决这个问题，我们将使用 Pyomo，用他们自己的话说，这是一种“基于 Python 的开源优化建模语言，具有多种优化功能”。对于那些已经使用 Python 的人来说，用 Pyomo 建模和解决问题会很简单。

[## 主页

Pyomo 的主页，这是一种用于线性编程的基于 Python 的可扩展开源优化建模语言…

www.pyomo.org](http://www.pyomo.org/)

Pyomo 允许在各种解决方案中进行选择，包括开源和商业解决方案。此外，用户可以选择在 Neos 服务器上解决问题，这是一个免费的基于互联网的解决方案，可以直接从 Pyomo 使用。这让我们不用在机器上下载和安装不同的解算器，也允许免费使用商业解算器。更多信息在https://neos-server.org/neos。

我已经在我的机器上安装了带有 conda 的 Pyomo，但也可以用 pip 来完成。可以在 http://www.pyomo.org/installation 的阅读安装说明。

在这篇文章中，我们将利用硬币或项目 Cbc，【https://projects.coin-or.org/Cbc】T4，来解决一个混合整数规划问题。

问题描述

大学校园里新开了一家食品店，一周 7 天，一天 24 小时营业。每天有三次八小时轮班。早班为 6 时至 14 时，晚班为 14 时至 22 时，夜班为 22 时至次日 6 时。

晚上只有一个工人，而白天有两个，除了星期天，每班只有一个。每个工人每周最多不超过 40 小时，并且在两班之间必须休息 12 小时。

至于每周的休息日，一个周日休息的员工也会喜欢在周六也休息。

原则上，有 10 名员工可用，这显然超出了规模。需要的工人越少，其他商店的资源就越多。

模型组成

为了使用 Pyomo 并解决这个问题，需要导入一些包。

第一步是输入数据，这意味着提供模型，在这种情况下，我们正在考虑的日子，工人，班次…我们不能明确地定义它们，稍后通过使用 AbstractModel() 输入数据，但对于这个帖子，继续使用 ConcreteModel() ，因此所有数据必须在建模步骤中可用。

我们已经添加了模型所需的所有数据。我们将能够在定义约束时调用这些元素，而不需要手动插入每个元素或考虑 if、else 子句。

为了构建模型，我们需要初始化模型并创建决策变量。

将模型初始化为对象后，将变量、约束和目标函数等元素作为属性添加。正如前面所解释的，我们创建了一个混凝土模型()，因为此时数据正在被提供。我们用 Var() 变量添加到模型中，用列表索引。

works:由工人、天数和班次索引的二元变量。1 如果工人必须在那天轮班工作。
需要:由工人索引的二进制变量。1 员工是否必须包括在员工队伍中。
no_pref:由 workers 索引的二进制变量。1 如果它在周日不工作，但在周六工作。

定义完所有变量后，我们就可以添加目标函数了。

目标是找到一个最大限度地减少工人数量的时间表，一旦实现了这个目标，也是最大限度地减少在星期天工作但在星期六不工作的工人数量。我们将工人数量部分乘以一个足够大的常数，这样只有在决定了最佳工人数量后，才考虑最小化周末偏好。

我们还需要添加约束，首先创建一个调用 ConstraintList() 的约束容器，然后用函数 add 将我们想要的任何约束添加到容器中。约束的代码如下，每个约束的解释都是行内注释:

现在，创建的模型可以求解了。一个模型可以用 model.pprint() 来可视化。这个问题是由二进制变量组成的，所以一个混合整数规划求解器适合我们的要求，CBC 从 COIN-OR 将被选中，【https://projects.coin-or.org/Cbc】T2。

这需要在本地安装求解器(不要忘记将它添加到路径中，以便 Pyomo 识别它)。然而，在 neos-server 中运行它将我们从这一过程中解放出来。

提取溶液

我们这样做是为了得到一个问题的解决方案，所以这是下一步。问题的解决方案是稀疏的，从这个意义上说，我们只是想知道它们中哪些是非零的，为了可视化，我们必须处理给定的解决方案。

我们现在可以检查所获得的解，并验证所有提出的约束条件是否得到满足。以 JSON 格式保存最佳时间表的字典，解决方案如下:

最佳解决方案需要激活 7 个工人。然后，有 7 名工人，他们不满意的人数是 2 (W6，W9)，因为他们在星期天不工作，但在星期六必须工作。观察问题公式，由于周日有 3 个班次，周六有 5 个班次，人们不能期望少于 2 个周六工人在周日不工作。

结论

在这篇文章中，我们已经完成了以下目标:

解释 Pyomo 作为 Python 中优化建模框架的基础知识。
学习如何建立一个特定问题的模型，在这个问题中，劳动力计划者必须在各种限制下优化每周时间表。

这篇文章旨在友好地介绍 Pyomo 的使用和优化问题的建模，因此，解决由于问题的规模或难以制定一个好的模型(是的，建模可以被认为是一门艺术)而导致的更困难的问题可能需要更深入地了解这些主题。

感谢您的阅读。玩得开心！

最新代码可在https://github . com/ccarballozano/blog-post-codes/tree/master/Modeling-and-optimization-of-weekly-work force-with Python-and-py Omo获得。

为 MLB 2018 年季后赛球队建模

原文：https://towardsdatascience.com/modeling-mlbs-2018-playoff-teams-b3c67481edb2?source=collection_archive---------15-----------------------

Source

随着十月的到来，季后赛终于开始了。在 162 场棒球赛季的整个过程中，球队会生成数据，而且是大量的数据，因为他们努力进入季后赛，有机会赢得世界职业棒球大赛。越来越多的这种数据被逐场使用，以优化防守排列、场地选择和情况调整。

对于这个项目，我想收集更多的宏观赛季数据，看看我们是否可以预测——以合理的准确度——哪些球队将根据他们的年终统计数据进入季后赛。在建立了截至 2017 年的数据模型后，我们可以引入未经测试的 2018 年数据，看看模型的表现如何。

我们的高级流程是:

数据收集和清理
数据准备
模型测试和调整
2018 年季后赛球队预测

所有网页抓取和建模的项目代码都可以在 我的 GitHub 这里 找到。

数据收集和清理

我想要一个项目，将工作在网络抓取，棒球统计提供了充分的机会，与来自网络的数据工作。经过一番搜索，我发现 baseball-reference.com 有一套强大的可废弃的数据，并使用该网站收集信息。

为了从击球和投球的角度来处理这个问题，我决定收集每一个方面的代表性数据。Baseball-reference 有非常有用的汇总详细统计数据的表格:

Example of annual batting statistics

Example of annual pitching statistics

在检查他们的 robots.txt 页面时，我发现我想访问的页面被允许抓取，并且要求 3 秒钟的延迟，以免服务器过载。

下一步是确定分析中包括多少年。事实证明，1969 年是在网站上包含更详细的团队统计数据的转折点，因此这成为选择的自然年份，以便使用的数据既全面又一致。

击球和投球数据的 URL 格式也被证明是有益的，年份是唯一可以改变的变量。这允许我们用每个目标年份编写一个简单的for循环来捕获每个页面上的 HTML。

for i in range(1969, 2019):

    site = requests.get('[https://www.baseball-reference.com/leagues/MLB/{}.shtml'.format(i))](https://www.baseball-reference.com/leagues/MLB/{}.shtml'.format(i))) soup = BeautifulSoup(site.text, 'html.parser')
    .
    .
    .
    # Rest of code

实际的数据抓取需要检查 HTML 代码，以找到在我们的抓取中调用的正确标签。同样，数据结构很有帮助，因为它在我们的目标特性中是标准化的:

很明显，我们想要捕获的大部分数据都包含在 data-stat 属性下的一个标记中。因此，我们可以定义一个函数，它接收 class 和 data-stat 并返回该标签的内容。对于任何不遵循这种模式的，我们可以只写一次性代码。

def get_attribute(class_side, data_stat):

   all_instances = soup.find_all('td', attrs = {'class': 
   class_side , 'data-stat' : data_stat})

   all_instances = [i.text for i in all_instances][:-2] 
   # [:-2] eliminates league total and average return all_instances# Example call to the function:batters_used = get_attribute('right', 'batters_used')

一旦获得各个数据点的正确代码就绪，每年的数据就会迭代地添加到 for 循环之外的数据框中，这样，到刮擦结束时，数据框中就有了 1969 年至 2018 年的所有联盟信息。

在这一点上，数据没有丢失值，并且相当干净。最后一步是简单地合并击球和投球数据集，为每支球队每年创建一个单独的观察。

df_all = df_pitching.merge(df_batting, on=['year','team'], how='left', suffixes=('_pitching', '_batting'))

最后，球队进入季后赛的年份取自维基百科。

数据准备

作为准备数据的第一步，我们将通过查看季后赛球队与非季后赛球队在数字列平均值方面的不同来给出变量的上下文:

我们看到季后赛球队在三振出局和跑垒(以及与全垒打和三垒打相关的变量)方面的出色表现，更少的得分/更低的 ERA，以及更稳定的投手阵容(使用更少的投手)——这不是革命性的，但对上下文有帮助。

接下来，数据准备需要两个主要步骤:标准化和缩放数据。

标准化是指变量中的某些幅度差异可能是由于所玩游戏数量的轻微变化(即 163 比 161)造成的。同样地，对于投球统计，有些是每九局报告一次，而有些则是全部。

因此，任何不在预定义范围内的变量(例如，每九局)，我们将标准化为每场比赛的统计数据。

Are differences in variables a result of different number of games played? Or actual differences?

Per-game standardization allows for valid comparisons across teams.

在这个项目中，缩放数据有一个有趣的变化。因为每个赛季都会重置一个球队的统计数据，而季后赛是由单个赛季的表现决定的，所以简单地从整体上缩放数据是行不通的。相反，我们必须在每个季节内单独扩展。

我选择的定标器是最小最大定标器。这将获取数据，并根据每列的最大值和最小值将其放在 0 到 1 的范围内。选择这一比例的原因是这种方法很容易解释——可以看出谁在某一年表现最好，并比较不同年份的相对表现。

为了实现逐季缩放的变量，我们可以创建一个空的数据框，遍历每一年，将 MinMaxScaler 应用于该年的数据，并将其附加到新创建的数据框。

df_scaled = pd.DataFrame()for yr in list(set(df_all.year)):

    df = df_all[df_all.year == yr]

    df = df.select_dtypes(include=['float','int'])

    scaler = MinMaxScaler()

    df_transformed = scaler.fit_transform(df)

    df_scaled = df_scaled.append(pd.DataFrame(df_transformed))

A sample of the MinMaxScaler transformed data. 0 indicates bottom of the league for a given year while 1 indicates the best performing team in that category.

型号选择和测试

这个项目很好地解决了分类问题——如果球队在某一年进入了季后赛，那么季后赛一栏标记为 1，否则标记为 0。因此，我们可以测试一系列分类模型，看看结果如何比较。

为了评估我们模型的成功，我们将查看几个不同的指标:精度、回忆、 F-1 分数，以及曲线下接收器操作特征面积 (ROC AUC)。要更深入地阅读分类指标，这是一篇由威廉·科尔森撰写的好文章。

我们的数据是不平衡的，因为我们的样本中只有约 22%被标记为进入了季后赛，这意味着(1)当我们分成训练集和测试集时，我们应该对样本进行分层，以及(2) 22%是我们希望改进的原始基线值，如果随机选择，预计会被猜到。

分层是一种确保我们的测试集有足够的目标变量表示的方法，通过在 sklearn train_test_split函数中指定分层选项来实现。

X_train, X_test, y_train, y_test = train_test_split(df_features, df_targets, random_state = 60, stratify=df_targets, train_size = 0.7, test_size=0.3)

车型

我们将测试五种不同的分类模型，每种模型都采用不同的方法来预测数据(我还尝试了一种带有投票分类器的元估计器，但这并没有改善结果)。

我们将经历两次模型测试迭代——首先是开箱即用的模型，然后是网格搜索以优化超参数。

我们将测试的模型是逻辑回归、随机森林、KNeighbors 分类器、支持向量分类器(SVC)和 XGBoost 分类器(XGB)。

逻辑回归使用误差最小化来创建分隔数据的线性边界，随机森林构建一系列决策树来进行预测，KNeighbors 计算一个点与其“n”个邻居之间的距离，然后汇总邻居的预测。

SVC 使用超平面划分数据，并根据点相对于超平面的位置进行预测，XGBoost 使用迭代残差调整来改善预测。

既然已经收集、清理和准备好了数据(包括分成训练集和测试集)，运行和测试开箱即用模型的实际操作就只有几行代码:

from sklearn.neighbors import KNeighborsClassifierknc = KNeighborsClassifier()knc.fit(X_train, y_train)print(classification_report(y_test, knc.predict(X_test)))
print(roc_auc_score(y_test, knc.predict(X_test)))

解释精确度的方法是，对于这个模型，在预测进入季后赛的球队中，61%是准确的(精确度)。在应该被标记为进入季后赛的球队中，42%被正确识别(回忆)。F-1 分数是两者的混合平均值。ROC 绘制假阳性率对真阳性率，然后 AUC 使用微积分和积分来确定曲线下的面积(越高=越好)。

对于这五个模型中的每一个，我首先拟合和预测现成模型的概率。SVC 和逻辑回归模型实现了测试数据的最高精度(0.65)，最高的召回率和 ROC AUC 分数是 XGBoost 分类器(分别为 0.57 和 0.74)。

提高车型性能

接下来，我们将看看是否可以通过调整超参数来改进模型。因为总的数据集不是太大，我们可以用一系列不同的超参数选项进行全面的网格搜索。

网格搜索的基本前提是，它用参数的每种排列来拟合模型，然后返回得分最高的那个。我们通过传入超参数选项的字典来初始化和拟合模型，然后使用标准的 sklearn fit方法。

params_knc = {'n_neighbors':[3, 5, 7, 9, 11], 'weights':['uniform', 'distance'], 'metric':['euclidean','minkowski']}gs_knc = GridSearchCV(KNeighborsClassifier(), params_knc, cv = 5)gs_knc.fit(X_train, y_train)

为了得到最佳参数，我们可以简单地在我们拟合的模型上调用.best_estimator_，我们可以用与前面模型相同的调用得到分类报告和 ROC AUC 得分。

print(gs_knc.best_params_)

print(classification_report(y_test, gs_knc.predict(X_test)))

print(gs_knc.best_params_)print(classification_report(y_test, gs_knc.best_estimator_.predict(X_test)))print('ROC AUC Score: %.2f' % roc_auc_score(y_test, gs_knc.best_estimator_.predict(X_test)))

KNeighbors Classifier Grid Search Results

最终，超参数调整略微改进了模型，最高精度提高了 0.05 到 0.70(随机森林)，而召回没有看到任何改进。

调整后的 SVC 和逻辑回归在曲线下面积上得分最高:

预测 2018 年 MLB 季后赛球队

该项目的目标是根据年终统计数据预测哪些球队将进入 2018 年季后赛。由于季后赛正在进行，我们可以在这个看不见的数据上测试数据的表现(2018 年的数据没有在任何模型测试中使用)。

我们可以从两个角度来处理这个问题。首先，我们将让模型预测现状，看看哪些球队通过了季后赛预测的门槛。接下来，使用我们的领域知识，即 10 支球队将进入季后赛(包括外卡)，我们可以选择预测概率最高的 10 支球队，看看其中有多少是正确的。

模型预测

使用我们优化的模型，最好的结果来自 XGBoost Classsifier，其精度为 1.00(所有预测都进入了季后赛)，召回率为 0.80(在进入季后赛的 10 支球队中，模型正确识别了 8 支)。

XGB 分类器错误识别的球队是密尔沃基队和科罗拉多队，其中一支球队——科罗拉多队——是 NL 的外卡参与者，这意味着他们不会在模型适用的一些过去季后赛球队的结构下进入季后赛。

用概率预测

在模型上使用predict_proba方法，我们可以利用我们对 10 支季后赛球队的领域知识，来看看预测的前 10 支球队与进入季后赛的 10 支球队相比如何。

事实上，这种方法为优化的 SVC 模型产生了 10 个正确预测球队中的 9 个的结果，唯一的错误是模型预测华盛顿将进入季后赛，而科罗拉多不会。

最终想法

一个简单的模型在大约 22%的情况下随机做出了正确的预测，而我们最好的模型在这个数字上提高了近 160%,预测准确率为大约 57%。

此外，当将模型应用于看不见的数据时，在领域知识的帮助下，我们将正确预测的百分比提高到了 90%。

虽然调整并没有显著改善模型，但使用不同的模型确实改变了预测能力和最终结果的准确性。在性能最差和最好的分类模型之间，召回率提高了 40%以上。

改善结果的后续步骤可能包括:

将数据分成不同的时间段，并优化每个独特时间段的超参数，以查看季后赛因素是否变化
将预测概率方法应用于每年，并观察它捕捉季后赛球队的准确性
整合其他数据源(成功率可能是一个很高的预测值，但我想在本次分析中排除它)
测试神经网络或更复杂的模型
当前数据集中更深层次的特征工程

对我来说，这一点的一个有趣的未来应用将在明年投入生产，在整个赛季中实时跟踪球队的预测季后赛概率，并查看从开始到结束的赛季如何利用这一模型改变季后赛预测。

如果您有任何反馈或想法要分享，可以通过 jordan@jordanbean.com 联系我或在 LinkedIn 上给我发消息。

建模:教授机器学习算法以交付商业价值

原文：https://towardsdatascience.com/modeling-teaching-a-machine-learning-algorithm-to-deliver-business-value-ad0205ca4c86?source=collection_archive---------5-----------------------

如何训练、调整和验证机器学习模型

这是关于我们如何在功能实验室进行机器学习的四部分系列中的第四部分。完整的文章集可以在下面找到:

概述:机器学习的通用框架
预测工程:如何设置你的机器学习问题
特征工程:机器学习的动力
建模:教授算法(本文)

这些文章涵盖了应用于预测客户流失的概念和完整实现。project Jupyter 笔记本在 GitHub 上都有。(充分披露:我在 Feature Labs 工作，这是一家初创公司开发工具，包括 Featuretools ，用于解决机器学习的问题。这里记录的所有工作都是用开源工具和数据完成的。)

机器学习建模过程

预测和特征工程的输出是一组标签时间，我们想要预测的历史实例，以及特征，用于训练模型以预测标签的预测变量。建模的过程意味着训练机器学习算法来根据特征预测标签，根据业务需求对其进行调整，并根据维持数据对其进行验证。

Inputs and outputs of the modeling process.

建模的输出是经过训练的模型，可用于推理，对新数据点进行预测。

机器学习的目标不是一个在训练数据上做得很好的模型，而是一个证明它满足业务需求并且可以在实时数据上部署的模型。

与特征工程类似，建模与机器学习过程中的先前步骤无关，并且具有标准化输入，这意味着我们可以改变预测问题，而无需重写我们的所有代码。如果业务需求发生变化，我们可以生成新的标签时间，构建相应的特征，并将其输入到模型中。

客户流失建模的实现

在这个系列中，我们使用机器学习来解决客户流失问题。有几种方法来制定任务，但我们的定义是:

在每个月的第一天预测这个月哪些客户会流失。使用一个月的提前期，客户流失率为 31 天，没有订阅。提前期为 1 个月，这意味着我们提前 1 个月进行预测:1 月 1 日，我们预测 2 月份的客户流失。

尽管机器学习算法听起来在技术上可能很复杂，但用 Python 实现它们很简单，这要感谢像 Scikit-Learn 这样的标准机器学习库。作为一点实用的建议，经验结果已经表明机器学习模型和超参数的选择很重要，但是不如特征工程重要。

因此，理性的决定是将大部分精力放在预测和特征工程上，并插入一个预先构建的机器学习解决方案。

在这个项目中，我和 Scikit-Learn 一起快速实现了一些模型。为了让数据为机器学习做好准备，我们必须采取一些基本步骤:缺失值插补、分类变量编码，如果输入维度过大，还可以选择特征选择(详细信息参见笔记本)。然后，我们可以用标准建模语法创建一个模型:

指标和基线结果

在应用机器学习之前，最好建立一个幼稚基线来确定机器学习是否真的有帮助。对于分类问题，这可以简单到猜测保留测试数据中所有示例的训练数据中的多数标签。对于客户流失数据，猜测每个测试标签不是流失产生 96.5%的**。**

这种高精度听起来可能令人印象深刻，但是对于不平衡的分类问题——一个类比另一个类表示得多——精度不是一个足够的度量。相反，我们希望使用召回率、精确度、或 F1 分数。

回忆表示数据中实际搅动的百分比，我们的模型用天真的猜测记录 3.5%来识别。Precision 测量由我们的模型预测的和实际的的百分比，简单的分数是 1.0%。F1 分数是这些测量值的调和平均值。

由于这是一个分类问题，对于机器学习基线，我尝试了一个表现不佳的逻辑回归*。这表明问题可能是非线性的，所以我的第二次尝试使用了随机森林分类器，结果更好。随机森林训练速度快，相对可解释，高度准确，通常是可靠的模型选择。*

无机器学习、逻辑回归和具有默认超参数的随机森林的指标如下所示:

Metrics recorded by baseline models

基于时间序列分割*，使用约 30%的数据对每个模型进行了评估。(在评估时序问题中的模型时，这一点至关重要，因为它可以防止训练数据泄漏，并可以对新数据的实际模型性能提供良好的估计。)*

使模型与业务需求保持一致

尽管 ml 模型的指标比没有机器学习的要好，但我们希望根据业务需求优化给定指标的模型。在这个例子中，我们将关注召回率和精确度。我们将调整模型，通过调整阈值来实现一定的召回率，阈值是一个观察结果被分类为正面的概率——客户流失。

精度和召回调整

在机器学习中，在召回率和精确度之间有一个基本的权衡，这意味着我们只能以减少另一个为代价来增加一个。例如，如果我们想要找到客户流失的每一个实例——100%的召回率——那么我们将不得不接受低精度——许多误报。相反，如果我们通过提高精确度来限制假阳性，那么我们将识别出更少的降低召回率的实际搅动。

通过调整模型的阈值来改变这两者之间的平衡。我们可以在模型的 精确回忆曲线 中形象化这一点。

Precision-recall curve tuned for 75% recall.

这显示了不同阈值下的精度与召回率。Scikit-Learn 中的默认阈值是 0.5，但是根据业务需求，我们可以调整这个阈值以实现所需的性能。**

对于客户流失，我们将调整阈值以实现 75%的召回率。通过检查预测的概率(实际值)，我们确定阈值应该是 0.39，以达到这个标准。在阈值为 0.39 时，我们的召回率为 75%，准确率为 8.31%。

选择召回还是精确在于商业领域。这需要确定哪种成本更高，假阳性——预测客户会流失，而事实上他们不会——或者假阴性——预测客户不会流失，而事实上他们会——并进行适当的调整。

选择 75%的召回率作为优化示例，但这是可以改变的。在这个值上，与原始基线相比，我们在召回率上实现了20 倍的提升，在精确度上实现了8 倍的提升。

模型验证

一旦我们选择了对流失进行分类的阈值，我们就可以从维持测试集中绘制出混淆矩阵来检查预测。

Confusion Matrix for Tuned Random Forest

在这个阈值，我们识别了超过一半的搅动(75%)，尽管有大量的假阳性(右上)。根据假阴性和假阳性的相对成本，我们的模型实际上可能不是一个改进！

为了确保我们的模型解决了问题，我们需要使用维持结果来计算实现模型的回报。

验证业务价值

使用模型在保留测试集上的度量作为对新数据的性能评估，我们可以在部署这个模型之前计算部署它的价值。使用历史数据，我们首先计算流失造成的典型收入损失*，然后使用实现 75%召回率和 8%精确度的模型计算流失造成的减少的收入损失。*

对客户转化做一些假设(详见笔记本)我们得出以下结论:

机器学习增加了每月活跃订户的数量，并从客户流失中挽回了 13.5%的每月损失。

考虑到订阅成本，这相当于每月 130，000 美元。

通过这些数字，我们得出结论，机器学习已经解决了每月用户增加的业务需求，并提供了一个积极的解决方案。

作为模型解释的最后一部分，我们可以查看最重要的特征，以了解与问题最相关的变量。随机森林模型中 10 个最重要的变量如下所示:

Most important features from random forest model.

最重要的变量符合我们对问题的直觉。例如，最重要的特征是截止时间前一个月的总支出。因为我们使用 1 个月的提前期，这代表了预测月份前两个月的支出。客户在此期间消费越多，他们流失的可能性就越小。我们还看到了一些顶级功能，如平均交易间隔时间或支付方式 id ，这对我们的业务监控非常重要。**

进行预测和部署

随着我们的机器学习管道的完成和模型的验证，我们已经准备好预测未来的客户流失。我们没有这个项目的实时数据，但如果有，我们可以做出如下预测:

Predictions for new data based on threshold.

这些预测和功能重要性可以交给客户参与团队，在那里他们将努力留住成员。

除了在每次获得新数据时进行预测，我们还希望继续* 验证 我们的解决方案是否已经部署。这意味着将模型预测与实际结果进行比较，并查看数据以检查概念漂移。如果性能下降到提供价值的水平以下，我们可以收集更多的数据并对其进行训练，改变预测问题，优化模型设置，或者调整调整的阈值。*

建模注释

**与预测和特征工程一样，建模阶段适用于新的预测问题，并使用数据科学中的常用工具。我们使用的机器学习框架中的每一步都是分段的，这意味着我们能够实现众多问题的解决方案，而无需重写所有代码。此外， API s — 熊猫、功能工具和 Scikit-Learn —都是用户友好的，有很棒的文档，并且抽象掉了繁琐的细节。

机器学习过程的结论

机器学习的未来不在于一次性解决方案*，而在于 通用框架 允许数据科学家快速开发解决他们面临的所有问题的解决方案。这种脚手架的功能与网站模板非常相似:每次我们建立一个网站时，我们不会从头开始，我们使用现有的模板并填充细节。*

同样的方法应该适用于解决机器学习的问题:不是为每个问题建立一个新的解决方案，而是调整现有的脚手架，并用用户友好的工具填充细节。

在这一系列文章中，我们介绍了用于解决现实世界机器学习问题的通用框架的概念和用法。

该过程总结为三个步骤:

***预测工程:*定义业务需求，将需求转化为有监督的机器学习问题，并创建带标签的示例
***特征工程:*使用标签时间和原始历史数据为每个标签构建预测变量
***建模:*训练、调整业务需求、验证解决方案的价值，并使用机器学习算法进行预测

A general purpose framework for solving problems with machine learning.

*虽然机器学习不是只对少数人开放的神圣艺术，但由于缺乏标准化的流程，它仍然远离许多组织。该框架的目标是使机器学习解决方案更容易**开发和部署，*这将让更多的组织看到利用这一强大技术的好处。

如果构建有意义的高性能预测模型是您关心的事情，那么请联系我们的功能实验室。虽然这个项目是用开源的 Featuretools 完成的，但是商业产品为创建机器学习解决方案提供了额外的工具和支持。

模拟纽约芬格湖国家森林的树高和断面积

原文：https://towardsdatascience.com/modeling-tree-height-and-basal-area-in-the-finger-lakes-national-forest-ny-567b763615c6?source=collection_archive---------19-----------------------

我尝试使用 R 包 randomForest 来创建两个树高和断面积的回归模型，这两个模型是基于一些激光雷达和在纽约手指湖国家森林中实地收集的数据。

声明:这个项目是我对 R 的第一次真正体验。在这个学期的早些时候，我对 R 如何工作，如何上传数据做了一些简单的学习，试图熟悉 R 的行话，等等。我还有很多东西要学，有时也非常依赖我那位出色的 GIS 教授，但我认为我对使用 R 的感觉肯定比几个月前要好。

下面我将试着概述一下我是如何完成这个项目的。关于背景和上下文，我将简单介绍一下我在 arcGIS 和 FUSION 中所做的工作，但这篇文章的重点将是使用 R 包 randomForest 来测试变量的重要性并建立回归模型。

开始了。

我开始用的数据(这部分和我在 R 里做的无关):

因此，我最初用的是一个 Excel 文件，其中包含实地收集的数据变量，其中包括每个地块的测量平均树高和断面积(这两个变量我决定用 R 建模)。对于激光雷达数据，我有一堆 LAS 格式的激光雷达文件，覆盖了整个手指湖国家森林。为了从激光雷达数据中获取我需要的度量值以用于在 randomForest 中创建模型，我必须使用激光雷达查看/处理软件工具 FUSION。通过使用 FUSION 的 grid metrics 功能，我获得了整个激光雷达数据集输出的一系列大约 60 个描述性统计数据，这些数据以栅格(grid)的形式存储在一个巨大的 CSV 文件中。我不打算尝试在我的模型中使用所有这些统计值。对于这个项目，我正在研究一些已经发表的关于该主题的科学论文的方法，这些论文的共同主题是只选择几个网格度量变量用于随机森林模型生成过程。所以，我最终保留了 Brubaker 等人论文中的五个变量的值。al 2018 使用:每个单元的平均值(每个单元是一个 15 x 15m 米的区域)，每个单元的第 30、90 和 99 百分位值，以及每个单元的覆盖百分比。这被保存为 CSV 文件，下面谈到的“grid.csv”。

然后，我将“grid.csv”加载到 arcGIS 中，将其转换为所有像元的 shapefile，然后在空间上将它连接到我收集的关于地块的野外数据，这就生成了下面将要讨论的文件“FieldandLidarData.csv”。

我实际上最终在 R 中使用的数据(R 代码中出现的文件的名称在引号中):

“grid . csv”-一个 CSV 文件，其值超过 900，000(！！)15 x 15m 米激光雷达像元。关键值包括:每个 15 x 15m 米激光雷达像元的 UTM 坐标，以及我选择用于我的模型的 5 个格网度量统计数据:每个像元的平均值、每个像元的第 30、90 和 99 百分位值，以及每个像元的覆盖百分比。来源:我在 FUSION 中基于最初为 Brubaker 等人 2018 年的研究收集的激光雷达数据创建了这个文件。
“fieldandlidardata . csv”-一个 CSV 文件，其中包含手指湖国家森林中约 100 个场地地块的值。关键值包括:田间收集的每块地的平均树高和断面积，以及与“grid.csv”文件中相同的 5 个网格度量统计的每块地的值。来源:这是我通过将“grid.csv”中的信息与 arcGIS 中的绘图数据进行空间连接而生成的文件。

因此，基本上这两个文件包含几乎完全相同的属性，除了覆盖不同区域的值:“grid.csv”具有整个国家森林的值，而“FieldandLidarData.csv”仅覆盖整个森林中随机放置的 100 个小研究地块的区域。这两个文件之间的另一个关键区别是,“FieldandLidarData.csv”文件包含野外采集的每个地块的平均树高和断面积值，而“grid.csv”文件不包含整个研究区域的这些值……这些是我试图使用 randomForest 获得的值！

我试图回答的关键问题是:

整个手指湖国家森林的树高和断面积是什么样的？

R 中的角色进展如何:

我把上面提到的两个文件保存到我电脑上的一个文件夹中，所以我只是在那里设置了目录，安装了 randomForest 包，然后去了镇上。注意:我将只显示断面积或树高中的一个的代码和图表，因为我实际上对它们两个都做了完全相同的步骤。

我做的第一件事是查看我用来计算断面积和树高的 5 个变量的重要性。我一次运行一个模型。我首先用我的第 21 行代码种植森林，见下文。数据“thetrees”是“FieldandLidarData.csv”文件的列，其中包含我的 5 个网格度量变量的值。然后我打印了结果，显示我种植了 500 棵树的回归森林，模型解释的变异百分比是树高 48.02%，断面积 26.61%，百分比不是很大，但也不错。然后，我用我的第 23-25 行代码生成了一个变量重要性图，以查看 5 个变量中哪个比其他变量更重要，下面显示了树高变量的图片。

Code for the variable importance bit for both basal area and height.

The variable importance plot I got for tree height. Clearly the 30th percentile variable didn’t matter…

接下来的议程是查看一些模拟值与每个地块的基础面积和高度的实际值的快速图。肯定有很多分散的情况，但是直观地看到模型中的东西与实际收集到的东西相比有多好是很好的。

The plot I made for tree height (it looks better than the basal area one did so I’m using it).

The code I used to generate my modeled vs. actual height plot.

最后，我进去把我的树高和断面积模型应用到整个手指湖国家森林！因此，我调用了一个巨大的“grid.csv”文件，其中包含整个森林的 UTM 坐标和网格度量数据，然后使用我之前生成的模型来预测研究区域中每个 15 x 15 m 地块的高度和断面积值。然后我将这些数据保存在一个 CSV 文件中，耶！我说完了。

My code for making my height model for the entire study area. I used the head function a few times just to see how things were going before I generated another massive CSV file.

在能够查看我的模型后，我的一些模式和想法:

如果你好奇的话，下面是一些在 arcGIS 中制作的小面积森林的地图。我想调查手指湖国家森林周围的树高和断面积值，通过显示我在 R 中得到的预测值，我能够做到这一点，看起来真的很酷。

is satellite imagery, b) shows how old the forest is in the area, c) shows the predicted tree height values per cell and d) shows basal area.

一般来说，树高不会超过 25 米，而断面积在 2 米/公顷以下。总的来说，模型似乎与我们在卫星图像中看到的高大/古老的树木非常匹配，而且看起来高度和断面积彼此之间以及与林龄呈正相关——我最终也研究了断面积和高度如何随林龄变化，因为手指湖国家森林的一些部分比其他部分的森林覆盖时间更长。

如果我有更多的时间，我想我会更深入地研究树高和断面积是否真的与林龄有关。我还会更多地考虑我使用了哪些变量以及使用了多少变量，以便尝试在数据中获得更多的解释变量，特别是对于基底面积，因为我们看到的变量中只有四分之一多一点被模型解释。

参考资料:

布鲁贝克，K. M .，Q. K .约翰逊和 M.W .凯耶。(2018)."用离叶和开叶激光雷达研究落叶林中乔木和灌木生物量的空间格局."加拿大森林研究杂志。48(9): 1020–1033.

墨菲，P. W. (2018)。未公布数据。

用卷积神经网络建模视觉神经元

原文：https://towardsdatascience.com/modeling-visual-neurons-with-convolutional-neural-networks-e9c01ddfdfa7?source=collection_archive---------11-----------------------

(针对非技术人员)

我们的大脑很奇怪。这个奇怪的器官已经进化了数百万年，不断变化和调整，以处理他们会遇到的新刺激和条件，看起来像一袋黏糊糊的物质，以各种方式折叠在我们的大脑中。然而，这个器官和由它组成的数十亿个神经元是我们理解什么是智能以及它是如何出现的最佳赌注。另一个很好的赌注是我们自己创造(人工)智能，然后解释我们自己的创造。

近年来，我们离创造智能机器又近了一步。至少在视觉方面，我们现在拥有可以从数千个类别中准确分类图像的系统。这要归功于卷积神经网络(CNN)和用于训练它们的图形处理单元的效率。给定每个类别足够数量的图像来训练这些网络，CNN 可以学习调整它们的人工神经元的连接强度(“权重”)，这样，在训练后，它们能够对它们从未见过的图像进行分类。

Fig1. How a typical CNN looks (source)

有趣的是，为了做到这一点，CNN 受到了我们大脑视觉系统的松散启发。视觉信息通过我们的眼睛进入我们的大脑，通过大脑区域的神经元传播，并在越来越复杂的阶段被消费，从简单的视觉表示如边缘、线条、曲线等开始。并且继续更复杂的表示，例如面部或全身。这导致一个人理解关于被观察物体的越来越复杂的信息。事实上，这种在日益复杂的阶段中对信息的解构似乎也是 CNN 所复制的。这个概念对于旧的视觉计算方法来说并不陌生。在更古老的、受生物学启发的 HMAX 模型中也可以看到这一点，该模型试图将大脑皮层中的视觉处理解释为“越来越复杂的表示层次”(更多信息请参见这里的、这里的和这里的)。

我们如何使用 CNN 层中的人工神经元来创建大脑视觉区域神经元的模型？“模型”是一个数学函数，给定与生物神经元相同的输入，可以产生类似的输出。为了创建它，首先需要理解和定义输入。

在这里，我们来看看我和我的同事在鲁汶大学神经生理学小组进行的一项研究。这项研究专门研究了下颞叶皮层，这是我们视觉系统的“晚期”处理阶段之一(腹侧流)，更具体地说，是从一部分细胞中进行的，这些细胞对包含身体的图像比对其他类别的图像(如面部)更敏感。当图像中出现一具尸体时，即使是无头的，他们也会很兴奋！

示例输入是空白背景上的轮廓图像(见下文)

Fig2. Example image shown to biological neurons (without the green frame) (source).

生物神经元对图像的反应是这样的(图 2)，科学家可以通过电生理学实验收集神经元的反应。在这样的实验中，一只猴子在监视器上看到图像，一个插入大脑的电极记录神经元对图像的活动或反应。
一些形状是随机的，一些形状像动物或人体，而其他形状像其他类别的轮廓。这项研究的目标是什么？为了找出 1)我们是否可以使用 CNN 层的人工神经元来预测该神经元对剪影图像的实际生物反应，以及 2)发现 CNN 的哪一层(早期、中期或晚期)对这些反应的建模最好。

Fig3. Body patch neurons would be excited looking at this…

卷积神经网络

CNN 的作用是接收输入图像，并为其训练识别的每个类别返回多个概率。

常见的 CNN 架构通常在早期层中包括数百个特征地图，并且该数字在接下来的更深层中逐渐减少。这些特征图(如示例 CNN 架构图所示)是整个层的切片，每个都由数千个神经元组成。

在谈论 CNN 时，“功能”这个词经常出现，要准确理解它的意思可能会令人困惑。所谓“特征”，我们指的是我们神经元的输出；术语“激活”也可以与特征互换使用，因为从神经科学的角度来看，t 更容易理解，因为它指的是在给定输入刺激的情况下神经元“激活”的程度。对于那些感兴趣的人来说，网上有很好的资源，它们很好地解释了 CNN 如何更详细地工作(例如卡帕西的课程， C .奥拉的博客，阿迪特·德什潘德的博客，这篇黑客文章等)。).让我们看看我们的神经元在做什么。

特征图中的每个神经元只能“窥视”输入的一小部分区域。因此，特征图左上角的神经元可以看到输入图像左上角的小窗口。同一个特征图中紧邻它的相邻神经元可以看到与第一个神经元的窗口相邻的小窗口。这意味着特征图可以通过用它的神经元“扫描”它来看到整个输入图像。那么为什么我们需要这么多的特征地图呢？所有这些神经元实际上是做什么的？

每个神经元根据其所属的层被分配一个数学运算来执行。这个操作涉及神经元的权重(连接强度)和它能看到的小窗口。

你可能想知道如何在权重和图像之间执行任何种类的数学运算。这是可能的，因为在数字世界里，一切都是数字。权重是指示神经元与构成图像(或该图像的小窗口)的像素的连接强度的数字。像素也是数字，在黑白图像中，黑色像素用数字 0 表示，白色像素用数字 1 表示。在灰度图像中，一个像素可以取一个范围内的值(我们通常定义为 0–255；见为什么表示其亮度。范围的一端是黑色(最暗)，另一端是白色(最亮)。彩色图像有点复杂，因为它们的每个像素都有三个值来表示其在颜色通道中的亮度。我们使用红色、绿色和蓝色通道进行显示，因此我们将彩色图像称为 RGB 图像。

正如我们前面所说的，每个神经元根据其所属的层被分配一个数学运算作为其任务。例如，第一卷积层中的神经元在其权重和输入图像中的小窗口之间执行卷积运算。该卷积运算是权重和像素值之间的逐元素乘法，然后是结果的总和。这个想法是，如果神经元检测到一个看起来像它的权重模式的模式，它将输出一个很大的数字。通过训练网络，这些权重实际上会发生变化，看起来像输入的模式。因此，你可以把一个神经元想象成一个模式检测器，检查它正在观察的区域是否包含一些熟悉其权重模式的东西，并输出这种熟悉程度的“分数”。有趣的是，相同特征图的神经元被设置为具有相同的权重，因此每个特征图基本上扫描整个输入图像以寻找特定的模式。因此，我们拥有的特征地图越多，我们检测到的模式就越多。

任何子采样层或池层中的神经元取前一层中的小窗口的单个值。因此，最大池层的神经元简单地取那个小窗口的最大值。这里的想法是，即使你将输入图像移动到一边，甚至旋转，或缩放，池层中的神经元仍然会检测到类似的模式。这使得 CNN 能够容忍这些图像变换。

卷积和子采样层通过收集关于图像的信息并输出他们发现的重要点的更压缩的摘要，尺寸逐渐变小。请注意，在经典的 CNN 架构中，这些层接收来自它们之前的层的输入信息。还有更多体系结构，信息“跳过”各层，创建循环连接，但这里不讨论这些。

图像内容信息将最终出现在完全连接的图层中，这有助于我们进行最终分类。全连接层中的神经元连接到前一层的所有神经元。完全连接图层的作用是创建先前图层收集的关于输入图像的所有信息的展平表示。它是扁平的，因为这些层中的神经元的结构不像特征图，人们可以将它们视为一维数字阵列。这种扁平化的表示比以前的层包含更少的神经元，这有助于达到我们正在训练 CNN 识别的类别数量的最终目标。最终，我们将得到每个类的分数列表作为输出，最高分将指示最可能的类。

数学建模

研究中使用的网络是“预先训练的”。这意味着他们已经接受了使用一个非常大的数据集对图像进行分类的训练，然后他们的网络权重被保存下来，供下载公开使用。因此，为了获得每一层的激活，向这个预先训练的网络提供输入图像，然后获取每一层的输出。人们可以想象图像在网络中“流动”，就像信息在我们的大脑中流动一样，然后我们可以在每个处理阶段(层)捕捉它。这些捕获的信息是我们用来创建模型的。

这里的数学建模任务是测量生物神经元的响应与相应的人工神经元激活值之间的关系。这项任务被统计学家称为“回归分析”，即在给定其他变量(人工神经元激活)的值的情况下，试图预测一个变量(生物神经元的反应)的值。

在每一个回归分析中，都涉及到两个数值矩阵:预测变量的 X 矩阵和目标变量的 Y 矩阵。在目前的场景中，人们可以考虑整个 CNN 的神经元，并建立一个巨大的 X 矩阵作为预测器，但即使对于现代的计算机来说，这也是非常计算密集型的，并且它不会给我们任何关于层内差异的想法。因此，我们为每个 CNN 图层建立了一个单独的回归设置，下图显示了一个示例。

Fig4. X and Y matrices for our Regression problem. Note that the images are black-n-white (binary), but to pass them as input to a CNN, we replicate them twice to end up with a 3D volume (the bnw image 3 times). The trained weights are also 3D volumes and to understand how they interact with the input, check this incredible visualization from Karpathy’s CS231n course (and also read the rest of the blog for more details).

通过建立这些回归分析设置，我们本质上是试图用 CNN 层中存在的所有人工神经元来取代猴子的生物神经元( X )。最终，这项研究发现，较深的 CNN 层被证明是身体贴片神经元的强大模型，这些神经元在我们大脑的视觉处理阶段也更深。虽然预训练网络是使用自然图像训练的，但这并不妨碍使用剪影图像的研究结果。因此，深层 CNN 层可以接收图像作为输入，并产生非常接近实际神经元产生的响应。更重要的是，来自这些深层之一的最佳模型，平均可以解释真实神经元对轮廓反应的 80%的可变性。

为了建立一种人工方法来表示与神经元 C65b 相同的功能，我们需要使用一种有效的数学方法来获得给定 x 的 Y。我们将在更多技术部分(即将推出)中介绍这一点。在那里，我们将回顾我们的建模选项，以及为什么它不是一个可以用简单的线性多元回归解决的简单问题。

剧终

(更多关于数学建模的技术部分将在后面介绍)

声明:我是 eNeuro 的出版物 这里 的作者。此处展示的所有数据(示例图片)均属于鲁汶大学，有关该主题的更多详细信息，您可以参考 eNeuro journal 或鲁汶大学。

扬尼斯

当没有明确观察到客户流失时，用 R

原文：https://towardsdatascience.com/modelling-customer-churn-when-churns-are-not-explicitly-observed-with-r-a768a1c919d5?source=collection_archive---------0-----------------------

Photo credit: Pexels

客户流失可以分为契约性或非契约性。根据取消机制的不同，它还可以分为自愿或非自愿。

我们今天只讨论非契约性和自愿性流失。

非合同

顾客可以随时自由购买或不购买
未明确观察到流失事件

自愿

客户选择离开该服务

一般来说，客户流失是一个分类问题。然而，在包括亚马逊(非 prime 会员)在内非合同业务中，每一次购买都可能是顾客的最后一次，或者是一长串购买中的一次。因此，非合同业务中的客户流失建模不是一个分类问题，而是一个异常检测问题。为了确定客户何时会流失或可能流失，我们需要知道他们在购买时间间隔内何时表现出异常大的变化。

异常检测

异常检测是一种用于识别不符合预期行为的异常模式(称为异常值)的技术。它在商业中有许多应用，从信用卡欺诈检测(基于“消费金额”)到系统健康监控。

现在，我们使用异常检测来模拟非合同业务的客户流失。我们希望能够做出这样的声明:“十有八九，顾客 X 会在 Y 天内进行下一次购买”。如果顾客 X 在 Y 天内没有再次购买，我们知道发生这种情况的概率只有 1/10，并且这种行为是异常的。

为了做到这一点，我们将需要每个客户的购买时间之间的分布。这可能很难估计，特别是如果分布是多模态的或不规则的。为了避免这一困难，我们将采用非参数方法，并使用经验累积分布函数 (ECDF)来近似每个客户的购买间隔时间分布的分位数。一旦我们有了 ECDF，我们就可以接近第 90 个百分位数，并获得我们上面描述的性质的估计值。我们开始吧！

数据

我们将使用来自 UCI 机器学习库的在线零售数据集。

加载库并读取数据:

library(tidyverse)
library(lubridate)
library(XLConnect)
library(dplyr)
library(ggplot2)
theme_set(theme_minimal())raw.data <- readWorksheet(loadWorkbook("Online_Retail.xlsx"), sheet=1)
data <- raw.data

创建一个“总计”栏，显示每位顾客每次购物的花费。然后，我们可以为每位顾客每天的总支出创建一个新的数据框架。

data$Total <- data$Quantity * data$UnitPricetxns <- data %>% 
  mutate(CustomerID = as.factor(CustomerID),
         InvoiceDate = InvoiceDate) %>%
  group_by(CustomerID, InvoiceNo, InvoiceDate) %>% 
  summarise(Spend = sum(Total)) %>%
  ungroup() %>% 
  filter(Spend>0)

接下来，我们可以计算每个客户的购物间隔时间。

time_between <- txns %>% 
  arrange(CustomerID, InvoiceDate) %>% 
  group_by(CustomerID) %>% 
  mutate(dt = as.numeric(InvoiceDate - lag(InvoiceDate), unit=  'days')) %>% 
  ungroup() %>% 
  na.omit()

此时，我们只对数据中至少购买了 20 次的客户感兴趣。

Ntrans = txns %>% 
  group_by(CustomerID) %>% 
  summarise(N = n()) %>%
  filter(N>20)

创建一个随机抽样客户的小函数。

sample_n_groups = function(tbl, size, replace = FALSE, weight = NULL) {
  grps = tbl %>% groups %>% lapply(as.character) %>% unlist
  keep = tbl %>% summarise() %>% ungroup() %>% sample_n(size, replace, weight)
  tbl %>% right_join(keep, by=grps) %>% group_by_(.dots = grps)
}

在一系列数据争论之后，我们现在可以可视化随机选择的 20 个客户的购买天数分布。

ecdf_df <- time_between %>% group_by(CustomerID) %>% arrange(dt) %>% mutate(e_cdf = 1:length(dt)/length(dt))
sample_users <- ecdf_df %>% inner_join(Ntrans) %>% sample_n_groups(20)ggplot(data = time_between %>% inner_join(Ntrans) %>% filter(CustomerID %in% sample_users$CustomerID), aes(dt)) + 
  geom_histogram(aes(y = ..count../sum(..count..)), bins = 15) + 
  facet_wrap(~CustomerID) +
  labs(x = 'Time Since Last Purchase (Days)',y = 'Frequency')

Figure 1

解释:

大多数 CustomerID 12748 的购买间隔少于 5 天，偶尔，他(或她)的购买间隔超过 5 天甚至 10 天。
CustomerID 13102 是一个不经常购买的客户，他(或她)的大部分购买间隔期为 5 到 30 天。

在计算了每个客户的 ECDF 后，我们将上述客户的 ECDF 可视化。红线代表大约 90%的百分比。因此，如果 ECDF 在 20 天内越过红线，这意味着 10 次中有 9 次顾客会在 20 天内再次购买。

ggplot(data = ecdf_df %>% inner_join(Ntrans) %>% filter(CustomerID %in% sample_users$CustomerID), aes(dt,e_cdf) ) + 
  geom_point(size =0.5) +
  geom_line() + 
  geom_hline(yintercept = 0.9, color = 'red') + 
  facet_wrap(~CustomerID) +
  labs(x = 'Time Since Last Purchase (Days)')

Figure 2

创建一个函数来计算第 90 个百分位数。

getq <- function(x,a = 0.9){
  if(a>1|a<0){
    print('Check your quantile')
  }
  X <- sort(x)
  e_cdf <- 1:length(X) / length(X)
  aprx = approx(e_cdf, X, xout = c(0.9))
  return(aprx$y)
}percentiles = time_between %>% 
  inner_join(Ntrans) %>% 
  filter(N>5) %>% 
  group_by(CustomerID) %>% 
  summarise(percentile.90= getq(dt)) %>% 
  arrange(percentile.90)

查看 CustomerID 12748:

percentiles[ which(percentiles$CustomerID==12748), ]

Figure 3

该模型告诉我们:10 次中有 9 次，CustomerID 12748 将在 4.74 天内进行另一次购买，如果 CustomerID 12748 在 4.74 天内没有进行另一次购买，我们知道这种情况发生的概率只有 1/10，并且这种行为是异常的。此时，我们知道 CustomerID 12748 开始“反常地”行动。

让我们快速浏览一下 CustomerID 12748 的购买历史，看看我们的模型是否有意义:

txns[ which(txns$CustomerID==12748), ]

Figure 4

CustomerID 12748 的大部分购买发生在 1 到 4 天内。如果他(或她)在 4.74 天内没有再次购买，我们应该担心，这是有道理的。

查看 CustomerID 13102:

percentiles[ which(percentiles$CustomerID==13102), ]

Figure 5

该模型告诉我们:10 次中有 9 次，CustomerID 13102 将在 31.6 天内进行另一次购买，如果 CustomerID 13102 在 31.6 天内没有进行另一次购买，我们知道这种情况发生的概率只有 1/10，并且这种行为是异常的。此时，我们知道 CustomerID 13102 开始“反常地”行动。

同样，我们快速浏览了 CustomerID 13102 的购买历史，以了解我们的模型是否有意义:

txns[ which(txns$CustomerID==13102), ]

Figure 6

通过查看 CustomerID 13102 的购买历史，我们同意该模型！

给你！我们现在知道了每个客户开始“反常”行为的时间点。

非合同业务的客户流失非常不同。挑战在于定义一个清晰的客户流失事件，这意味着采用不同的方法来模拟客户流失。当一个顾客有所动摇时，他(或她)的购买间隔时间是异常的长，所以我们应该知道“异常”对每个顾客意味着什么。使用 ECDF，我们已经以非参数的方式估计了每个顾客在购买时间分布之间的 90 个百分点。通过检查客户最后一次购买的时间，如果从那时到现在的时间接近第 90 个百分点，那么我们可以称他们为“有流失风险”,并采取适当的措施来防止他们流失。最重要的是，随着更多的数据，我们的方法将变得越来越好，因为ECDF 将收敛于人口的基本累积分布函数(CDF)。

此外，当我们实现上述模型时，我们可能要考虑季节性。

源代码可以在 Github 上找到。我期待听到任何问题。

参考资料:

探索性数据分析:经验累积分布函数的概念基础

使大学橄榄球决赛现代化

原文：https://towardsdatascience.com/modernize-the-college-football-playoff-d24d690f1435?source=collection_archive---------10-----------------------

在一个由分析驱动的时代，大学足球使用数字而不是意见来选择季后赛球队。

Photo by Alex Korolkoff on Unsplash

随着大学橄榄球赛季最后一周(通常称为竞争周)的临近，大学橄榄球季后赛的 4 支球队似乎一如既往地清晰可见。尽管我们认为我们知道最好的 4 支球队，但由大学橄榄球季后赛委员会提供的第 13 周排名再次令人惊讶。5 队 4 负排名，创历史新高。UCF 的排名高于俄亥俄州。路易斯安那州立大学，尽管输了两场(包括一场 29-0 的井喷)，仍然排在第 7 位。也许这些决定都有可取之处，但是没有委员会的解释或透明度，目前的系统对许多人来说是不完善的。要了解大学足球季后赛的目的，以及如何修复这个系统，我们必须看看大学足球排名系统的历史。

排名简史

1936-1997:投票时代

大学足球(CFB)冠军是由预先确定的一组选民组成的不同投票选出的。引用最多的两项民意调查是美联社民意调查，由媒体成员投票选出，以及《今日美国》教练民意调查，由 62 名精选的 CFB 教练投票选出。在这个时代，这些民意调查偶尔会发生冲突，在赛季结束时产生两个不同的冠军。最好的两个队也不能保证互相比赛，这导致了关于谁将在第一和第二队之间赢得比赛的假设。随着其他投票开始流行(CNN 投票等)，很明显最好的球队应该在球场上解决争论。

1998 年至 2013 年:波士顿咨询公司

BCS 旨在通过在赛季末选择最好的两支球队争夺冠军来解决投票时代的问题。使用计算机化的分数，BCS 考虑了几个因素来对团队进行排名。该分数由 3 个因素组成，所有因素的权重相等:教练投票、哈里斯投票和 6 个计算机排名的平均值，去掉最高和最低的排名以说明异常值。哈里斯民意调查是由专门从事互联网研究的市场调查公司进行的，在美联社决定他们不想被纳入 BCS 公式后，该公司取代了美联社的民意调查。哈里斯民意调查在 2013 年赛季结束后结束。提到的 6 个计算机排名是:

萨加林: 各队使用国际象棋常用的 ELO 评分系统进行排名。输赢是主要标准，获胜的队伍比他们的对手得分高。每个团队最初是根据他们的预期获胜次数来评分的，如果一个团队的获胜次数超过了他们的预期值，他们的评分就会提高。该模型还考虑了游戏地点的因素，以说明难度。
Wolfe: 每支队伍都使用最大似然估计量(MLE)进行评分，A 队击败 B 队的概率简单描述为(ARating)/(ARating + BRating)。这被描述为布拉德利·特里模型。
梅西: 根据他的网站:每场比赛都通过一个等式“连接”两支球队。随着游戏越来越多，最终每个团队都通过某种游戏链与其他团队联系在一起。当这种情况发生时，方程组是耦合的，需要用计算机来同时求解。收视率是完全相互依赖的，所以一个球队的收视率会受到它没有参加的比赛的影响。因此，解决方案实际上依赖于对手、对手的对手、对手的对手的对手等等的无限链条。最终评级代表一种平衡状态，在这种状态下，每个团队的评级与其良好和不良表现完全平衡。
科利: 赛程和胜率的强弱最重要，比分差距或对手胜率则无关紧要。没有任何修正的简单统计模型。
安德森:再次强调，赛程的强度至关重要。各队因安排优质对手并获胜而获得奖励，分数差异无关紧要。球队会进一步受到对手的对手和整个赛季中联盟整体表现的影响。
比林斯利: 季前赛投票开始的唯一投票，根据比赛时各队的快照来奖励各队。例如，如果华盛顿队与第五名俄勒冈队比赛，并且华盛顿队赢了，而俄勒冈队在本赛季剩余的比赛中打了坦克，则华盛顿队仍然被认为赢了第五名队。亏损会受到重罚，因此在这个模型中保持不败会得到很多奖励。

BCS 排名选出赛季末的前 2 名球队，1 号打 2 号争夺全国冠军。虽然排名比投票时代更准确地代表了球队的表现，但许多大学足球社区的人认为两队太少了。许多年来，非常有资格的球队落后于第二名仅仅十分之几的分数，然而却被淘汰出冠军争夺。是时候扩展领域了。

2014 年至今:大学橄榄球决赛

NCAA 通过在 2014 年成立 CFP 委员会解决了 BCS 问题，该委员会由来自 CFB 社群的 13 名轮流成员组成。这个委员会选出最好的 4 支队伍参加冠军决赛。尽管该领域从 2 个团队扩大到 4 个团队，但委员会的决策在其存在的 4 年中不断受到质疑，2018 年的任何混乱都将提供另一个具有挑战性的选择。总结委员会以前有问题的决定:

2014 年:俄亥俄州对 TCU 和贝勒。OSU 赢得了 10 大冠军，而 TCU 和贝勒被排除在外，因为一个感知“较弱”的时间表。
2016: 俄亥俄州对宾州。PSU 以 27 比 24 的比分击败了 OSU，宾夕法尼亚州立大学赢得了十大冠军。然而，OSU 被选中是因为一个被认为“更强大”的时间表。
2017: 阿拉巴马州对俄亥俄州。阿拉巴马州是第二支进入季后赛的 SEC 球队(排名第一的是佐治亚州)。只有 1 次失败，但没有分区或联盟冠军，阿拉巴马州被选中超过 10 大冠军 OSU，因为人们认为失败的质量较低。

在委员会存在的 4 年中的 3 年里，围绕所做的决定存在严重的争议。这场季后赛的内在结构是排除至少一个 5 强冠军。如果在选择全国锦标赛的最佳球队时不考虑联盟锦标赛，那么目前的选择过程是有缺陷的，并且充满了委员会成员影响的可能性。在每个主要运动都接受数据和分析的时代，大学足球应该接受基于优点的排名模型，并致力于消除 13 人董事会可能带来的偏见，特别是在决策没有任何透明度的情况下。BCS 投票成功了，只需要扩展到 4 个团队就可以解决 BCS 的紧迫问题。

然而，要修复这个系统，需要解决两个问题:意见和数据应该如何平衡？而我们是否应该每年至少排除 1 次 Power 5 大会？

现代化的碗季后赛(MBP)

在一个理想的系统中，排名将捕捉到大学足球世界的完整画面。这个新系统，我们称之为现代化的碗季后赛(MBP)，建立在 BCS 模型之上。首先，AP 调查和教练调查将各占 1/6 的分数，或总分数的 1/3。这确保了人类的感知影响排名，但不是驱动力。第二，平均 7 次民调会占 2/3 的分数，同时保留每个队的最高分和最低分。这将确保没有单一模型比另一个模型具有更大的权重，并且如上所述，将允许包括诸如快照胜利(击败当时排名第二的团队等)的因素。随着更新、更先进的计算机模型的出现，MBP 将 、ESPN FPI 作为第七个计算机排名加入到它的等式中。FPI 衡量团队实力，以最佳方式预测团队在本赛季剩余时间的表现，基于本赛季剩余时间的 10，000 次模拟。

为了解决是否应该排除 5 强联盟冠军，或者是否应该从一个给定的联盟中选择几个球队，季后赛必须扩大到 8 个球队。前 5 名大会的大会冠军将自动获得一个席位，排名前 3 位的未参加大会的团队将获得大额投标。这确保了 5 个团队或来自 Power 5 会议的第二个团队有机会竞争，如果他们值得的话。这 8 支队伍将根据他们的排名被列为种子队。这个新的 MBP 排名系统将在第 13 周产生前 25 名…

在我的网站查看新的排名和假设的 8 支球队季后赛。也可以在 Twitter 关注我。

学术数据科学的现代化

原文：https://towardsdatascience.com/modernizing-academic-data-science-4213794a278e?source=collection_archive---------19-----------------------

软件工程提高科学再现性的四个原则

摘要

再现性对科学进步至关重要，然而大多数结果是无法复制的。今天的研究论文严重依赖编程分析管道和统计模型。几十年来，软件工程在如何实现高质量、可复制的代码方面已经发展出了最佳实践。然而，科学家通常没有接受过这些最佳实践的培训。这篇文章涵盖了在科学研究中促进更大的可重复性的四个基本原则: c ode review 、 t esting 、版本控制和ddocumentation。

Photo by Conner Baker on Unsplash

不可复制的研究问题

在我研究生生涯的末期，我把研究再现性危机作为一个兼职项目，这对于一个越来越失望的博士生来说，就像往火上浇汽油一样聪明。一些已发表的研究发现是虚假的这一事实并不新鲜，也不特别令人担忧。然而，令人担忧的是越来越多的证据表明大多数发表的研究发现是错误的。

心理学首当其冲受到负面压力，但是危机影响了大多数领域。例如，整个神经科学的统计能力大约是的 20%。虽然最新的力量姿势或超感知觉的后验概率可能不会让你晚上睡不着觉，但在癌症生物学、遗传学或药理学中持续失败的重复发现可能会引起关注。

by KC Green

学术界扭曲的激励结构是许多统计滥用的核心。有意义的结果会带来金钱和名声，而无意义的结果则什么都不会。证据的二分法使得选择性报告变得更加容易，在专业上也更加方便。

这个问题不仅仅是显性的黑客攻击，而且更隐蔽的是，隐性的黑客攻击来自于丰富的研究人员自由度和我们对正面结果的偏好。这就是为什么再现性在如此多的领域受到关注，包括机器学习和 AI 。

走向可复制的研究

越来越多的人意识到缺乏再现性，这导致了许多最近的提议，例如移动显著性阈值，用效应大小和置信区间补充分析，或者切换到贝叶斯因子。这些都是统计学上的原则性建议，但却非常不令人满意。为什么？因为这些充其量只是权宜之计，持久的解决方案需要文化转型。

从这个转变开始的一个地方是软件开发，它是许多学术研究项目的核心。因此，从软件行业借用促进可复制性、透明性和健壮性的原则是合乎逻辑的。

代码评审测试版本控制文档

为什么这些实践在学术界几乎不存在？一个原因是研究生院没有跟上数据的指数增长。例如，即使在排名最高的神经科学博士项目中，定量方法和编程基础的课程也是可选的或过时的。哈佛大学为即将入学的研究生开设的定量方法训练营仍然只专注于 Matlab。封闭源代码和昂贵的许可证不太可能成为可复制科学的良方。

结果是学生必须自己发现现代数据科学和开发的最佳实践。但是实验室已经采用了没有支持机器的编程语言。学术实验室不是工业软件开发团队，也不应该是。但是工业中使用的确保可再现性、功能性和透明性的工具与学术界高度相关，并将培育更多可再现的科学。

提高科学再现性的核心原则

1)代码审查

想一想，与对产生结果的代码关注甚少相比，一份手稿在出版前受到了多么严密的审查。除了原作者之外，有多少人曾经看过这些代码？

在开发团队中，代码通常由多人进行同行评审。这有助于确保预期的功能、缺陷的识别以及对标准的遵守。

你是怎么做到的？逐行阅读代码，并问自己:

我能容易地理解代码吗？
代码做了它应该做的事情了吗？运行它。
代码遵循标准吗？ Python 风格指南， R 风格指南
代码是模块化的吗？

审查者应熟悉编程语言，但可能不具备生理或统计模型方面的专业知识。因此，纳入防弹测试方案是一个好主意。

2)测试

第一个原则是你不能欺骗自己——而你是最容易被欺骗的人。— 理查德·费曼

软件测试有很多种，有手工的，也有自动的，覆盖了不同程度的粒度。它们通常分为三类，针对单个功能或类的单元测试，针对多个组件的集成测试，以及针对整个项目的端到端测试。测试的目的是验证一个软件的行为符合预期，并预测它会如何崩溃(就像这个癌症研究被一行代码搞垮一样)。

在学术界，最常见的担忧之一是虚假的发现。测试将有助于防止虚假的发现。

例如，线性判别分析通常在许多研究项目中用作分类器。然而，如果不满足模型的假设，分类结果很容易被误解。最关键的假设之一是特征不在共线。下面是一个测试示例，如果违反了这个假设，它将停止执行并引发错误。

测试可以加快调试速度。当依赖于依赖于快速发展的库的复杂代码库时，这个事实尤其突出，这些库可能与来自另一个实验室的遗留代码集成在一起。

好的测试需要仔细考虑数据和可能的故障点。这使得编写测试本身成为一项有用的练习。这里的是更详细的 Python 测试入门指南。

3)版本控制

版本控制系统回答了这个问题:“谁在什么时候做了什么？”通过记录和维护可以随时比较的代码版本。它已经存在大约 50 年了，但我们不知何故找到了一种方法来保持命名文件version _ final-edits _ December _ 2018。如果你不熟悉版本控制，你正在为你的同事和你未来的自己创造更多的工作。

目前最流行的版本控制系统之一是 Git，它与 Github(Git 托管服务)一起使用。

[## 新开发者？你昨天就应该学会 Git。

我给新开发人员的第一条建议是:学习 Git。

codeburst.io](https://codeburst.io/number-one-piece-of-advice-for-new-developers-ddd08abc8bfa)

学习 git 是一项可以立即收回成本的投资。它将防止丢失您的工作，不记得昨天工作了什么，没有您的代码的功能版本来共享，等等。

不要让成千上万的“简易 Git 指南”使你相信这是软件工作流程中每个人都非常了解的琐碎方面。就连 Git 的开发者 Linus Torvalds 也称之为“该死的白痴的一卡车 sh*t:当它坏掉的时候”。有效使用 Git 需要时间，这里有一些资源可以帮助。

4)文件

你可能已经发现了强 AI 缺失的关键，但没人能说得清是不是不可能理解你的代码。虽然有少数优秀的可以手动修补二进制代码，但编辑带有文本字符串的代码可能更容易，它会告诉你代码做了什么。这些有用的字符串称为文档字符串。以下是用 Python 编写的函数的文档字符串示例:

Sphinx docstrings

三重引号"""之间的文本解释了这个函数做什么，预期的输入和输出以及它们相关的类型。在 Python 中，包含文档字符串的约定是将它们作为每个模块、函数、类和方法的第一条语句。

在编写文档时，您没有义务遵循任何规则，但是使用一个标准，比如 Python 中 NumPy 库的这个，可以自动生成有用的参考指南。经验法则是使用你加入的团队已经习惯的东西，因为细节没有坚持和一致性重要。

文档也不是可读性的唯一方面，但它是一个非常强大的起点。

经过审查、测试、版本控制和记录的软件将极大地提高结果的健壮性和可重复性。

如果有兴趣进一步优化，可以考虑集装箱化带码头、打包，以及持续集成。值得记住的是，再现性是一个光谱，小的变化会产生大的影响。

感谢刘冉和克里斯·霍布森的有用的评论，删除了许多不必要的段落，并感谢德克斯特·杜克沃斯提高了例子的质量。

如果你想聊天，请联系我，你可以在这里找到我。

利用生物技术的分子系统学。菲洛

原文：https://towardsdatascience.com/molecular-phylogenetics-using-bio-phylo-57ce27492ee9?source=collection_archive---------6-----------------------

你有没有想过生命是如何从原始汤形成并进化成现在可以看到的不同生命形式的？不同的物种是如何从它们的祖先进化而来的，它们之间有什么关系？这些问题可以通过对种系发生学的研究来解答。

本文将带您了解以下主题。

什么是种系发生学？
系统进化树
用于系统发育推断的算法
带代码的示例练习任务

什么是种系发生学？

根据维基百科，

系统发育学是对生物个体或群体之间的进化历史和关系的研究。

通过系统发育推断方法发现生物之间的关系，其中可遗传的特征，如 DNA 序列或形态，可以在特定的进化模型下观察到。这些分析的结果是一个系统发育(也称为系统发育树)。它是描述一组生物或一个基因家族进化关系历史的假说的图表。

分子系统发生学是系统发生学的一个分支，分析某些分子，主要是 DNA 序列和蛋白质如何随时间变化，以确定一组生物或一个基因家族的进化关系。

Primates with books

系统进化树

系统进化树代表生物或基因之间的进化关系。进化树中的分支模式反映了物种或其他群体是如何从一系列共同的祖先进化而来的。进化树的一个例子是 生命树 ，它表示自地球诞生以来各种生物物种是如何进化的。

在系统发育树中，感兴趣的物种或类群位于被称为分支的线的顶端。分支的点称为分支点。

Image Source: Khan Academy

如果两个物种有更近的共同祖先，那么它们就更相关；如果它们有更近的共同祖先，那么它们就更不相关。

Image Source: Khan Academy

这里给出的是基于基因数据的灵长类动物的系统进化树。大猩猩和猩猩比其他灵长类动物分化得更早。人血统(人类)沿着一条道路前进，而潘血统则沿着另一条道路前进。后来，潘的血统发生了分裂，产生了黑猩猩和倭黑猩猩。

用于系统发育推断的算法

有三种主要类别的算法用于从任何类型的生物数据进行系统发育推断。他们是，

基于距离的方法
最大简约法
概率方法

1.基于距离的方法

基于距离的方法计算出一个进化距离，这是两个被认为从一个共同祖先分化出来的物种所发生的变化的数量。然而，当涉及到处理具有非常遥远关系的大量数据时，这些方法面临准确性问题。

2。最大简约(MP)方法

MP 方法推断出一棵最小化变化总数的树，这种变化被称为解释数据所需的突变。在最大简约准则下，解释数据的最短可能树被认为是最佳树。这棵最好的树被称为最节俭的树。执行启发式搜索以快速生成最节省的树。由于这种方法认为最短的可能树是最好的树，实际发生的进化变化可能被低估。

3.概率方法

概率方法，如最大似然(ML) 和贝叶斯推断 *、*试图找到一棵最大化观察数据的条件或后验概率的树。目前，系统发育研究广泛使用贝叶斯框架，因为它可以解释系统发育的不确定性、有效算法的可用性及其作为各种计算机程序的实现。

生物。phylo——练习的时间到了

既然我们对系统进化树有了一个基本的概念，现在是时候尝试一些编码了。我在之前的文章中介绍过一套名为 Biopython 的 Python 工具，可以用来分析生物数据。如果你还没有浏览过，也一定要去看看。

我将使用简历。Phylo 模块，提供类、函数和 I/O 支持，用于处理系统进化树。你可以通过官方文档来获得更多关于这个模块的细节。

任务—为给定的 DNA 序列构建系统发生树

假设你有五个 DNA 序列，它们的标签在每一行的开头。你可以在官方 biopython 测试材料中名为 msa.phy 的文件中找到这些序列。考虑的顺序如下。

阿尔法 AACGTGGCCACAT
测试版 AAGGTCGCCACAC
伽玛 CAGTTCGCCACAA
增量gagatttcgcct
艾司隆 GAGATCTCCGCCC

我们的任务是基于基于距离的系统发育推断方法构建系统发育树来表示这些序列。

目前，生物。Phylo 模块有两种类型的树构造器:DistanceTreeConstructor和ParsimonyTreeConstructor。我们将使用**DistanceTreeConstructor**来完成这个任务。

此外，DistanceTreeConstructor支持两种启发式算法:UPGMA(算术平均的不加权对组方法)和NJ(邻居加入)。我们将使用**UPGMA**算法。你可以从这个链接中读到更多关于 UPGMA 算法的内容。

解决办法

首先，确保您已经下载了包含输入序列的 msa.phy 文件，并将其包含在您当前的工作目录中。

下面给出的是为给定的 DNA 序列创建系统发生树的 python 代码。注意我们是如何使用 Bio 的。Phylo 模块及其功能。

通过运行代码，我们可以得到可视化的系统进化树，并在终端中打印出来，如下所示。

Graphical visualization of the phylogenetic tree using UPGMA

The phylogenetic tree using UPGMA printed in the terminal at the end

如果使用 NJ 算法而不是 UPGMA 算法，那么得到的树会有如下变化。

Graphical visualization of the phylogenetic tree using NJ

The phylogenetic tree using NJ printed in the terminal at the end

希望您喜欢阅读这篇文章，并了解到关于分子遗传学以及如何使用 Biopython 从一组给定的序列构建系统进化树的有用和有趣的东西。我很想听听你的想法和主意。

感谢阅读…😊

现代艺术博物馆及其数据艺术品

原文：https://towardsdatascience.com/moma-and-its-artwork-in-data-60925c8acb7a?source=collection_archive---------7-----------------------

今天我将用 MoMA 的数据来描绘一幅 MoMA 现当代艺术收藏的图画。

为了了解艺术品的大小，我将它们绘制成上下重叠的矩形，其中 88.8%在 500 厘米 x 500 厘米(197 英寸 x 197 英寸)范围内，而平均高度和宽度约为 25 厘米(10 英寸)。

size of artwork by overlapping their actual size in rectangles

虽然大多数艺术品都小于 50 厘米 x 50 厘米，但大小各不相同，建筑收藏中一些较大的异常值达到 10 米。

我们还可以调查最具代表性的艺术家、摄影师和建筑师的作品规模。高宽比表示肖像模式或风景模式。我们可以看到法国画家和雕塑家让·杜布菲创作了许多高大的艺术品，而德裔美国建筑师路德维希·密斯·凡·德罗的作品则更为广泛。

artists and size of their canvas

对于 MoMA 收藏最多绘画作品的艺术家，我们也了解到他们对画布尺寸的不同偏好。像奈良美智这样的艺术家创作较小的波普艺术，而像吉姆·戴恩这样的艺术家创作较大和较宽的绘画。

这是我关于数据科学和视觉故事的# 100 日项目的第 36 天。我的 github 上的全部代码。感谢阅读，欢迎反馈。

房地产摇钱树

原文：https://towardsdatascience.com/moneyball-for-real-estate-3bca252bc2a5?source=collection_archive---------0-----------------------

投资房地产？开餐馆？发起营销活动？你以前听说过——这都是关于位置、位置、位置的。它有可能成就你的事业，也有可能毁掉你的事业，然而这个关键的决定仍然常常是由直觉和直觉驱动的。

有了 Easy Atlas ，我们正在改变这一切。在过去的一年里，我们一直在开发一种新技术，可以为您的投资和业务确定最佳位置。不用再猜了。

怎么会？

**数据。**如今，我们可以访问大量的位置数据，而这些数据在十年前根本不存在。这也不仅仅局限于地理位置。我们可以看到我们如何移动，停留多久，付出多少，以及我们的感受。地理位置数据无处不在，无所不在，挖掘这些数据源可以揭示一种洞察力，这种洞察力可能会对我们的决策产生重大影响。

那么，如果我们分析所有数据并跟踪随时间的变化，会发生什么呢？

当人们搬家时，价格就会变化。新事物出现，旧事物消失。我们可以从数字中看到这一切。数据是解决位置问题的工具，我们已经组装了一个工具箱，能够回答最复杂的基于位置的查询。

Easy Atlas 是一个实时系统，允许您插入我们的任何或所有数据源，以便您可以为您选择的一个或多个城市绘制数据图层。

让我们来看看 Easy Atlas 的运行情况。我们打算 1) 在巴黎开一家咖啡馆 ，2)在上海投资 住宅房地产 ，3)在纽约 开一家夜总会 。

1.在巴黎我应该在哪里开一家新的咖啡馆？

巴黎是一个咖啡馆林立的城市。为了确保我们的新咖啡馆成功，我们想找一个人流量大、咖啡馆少或档次低的地方。

高客户需求+不满意的客户=我们的机会

这里是目前巴黎咖啡馆的分布

Least dense (light blue) to most dense (dark blue)

下面是顾客对他们的评价

Red (below city average) to green (above city average)

这里是城市中最繁华的地方

当我们将所有数据层层叠加时，我们得到了巴黎新咖啡馆最佳位置的两个明确候选人。与巴黎其他地方相比，这两个地方的咖啡馆表现不佳，数量也较少，但与巴黎其他地方相比，这里的交通和活动要多得多。

你知道吗？

星巴克在巴黎有 59 家分店。平均位置每周开放 6.87/7 天，每天开放 12.82 小时。

一般人走进巴黎咖啡馆的时间是下午 2 点 52 分。这是比纽约晚25 分钟，比多伦多晚28 分钟比多伦多晚，比伦敦晚 1 小时 21 分钟**，比香港早 12 分钟**。****

2.在上海投资住宅地产应该去哪里？

上海人口在最近十年增长了近 40%(涌入 1000 万+人)。随着越来越多的人涌入城市生活和工作，住宅区将继续涌现。为了准确定位我们应该在这个城市火热的房地产市场上投资哪里，我们将分析整个城市的增长趋势和价值。

****增长趋势:通过查看所有类别流量的增长情况(如社交媒体、酒店、餐厅、Airbnb)，找出哪些社区正在崛起。
****价值差异:通过比较 Airbnb 的 8000+房源与房地产中介的 7000+房源的价格点，定位被低估的区域。我们想揭示 Airbnb 的高价格和低房价之间的最大差异。

高增长领域+被低估的领域=我们的机会

以下是 2016 年末上海最繁忙的地方

Least active (light blue) to most active (dark blue)

这里是今天上海最繁忙的地方

Least active (light blue) to most active (dark blue)

这里是已经发生的流量变化

Red (below city average growth rates) to green (above city average growth rates)

这里是上海目前的房价

Least expensive (light blue) to most expensive (dark blue)

当我们综合这些数据时，我们发现上海有两个明显的新兴社区值得我们考虑投资。这两个城市的客流量增长都超过了纽约，而且房地产市场和 Airbnb 之间的价格差异为负。

你知道吗？

上海平均建筑高度 110.6 米。与首尔的 130 米、东京的 109.5 米、香港的 125.6 米相比。

如果你把所有的建筑一个接一个的堆叠起来，上海将会有一个 119.9 公里长的建筑。那远远长于首尔的 35.6 公里和东京的 85.5 公里，但短于香港的 122.6 公里。

3.我应该把我的新夜总会设在纽约市的什么地方？

纽约市的夜总会竞争激烈。为了确保我们的新夜店从 18-35 岁的目标人群中获得大量客流量，我们需要找到他们经常出没的地方，以及举办大量社交活动的区域。

以自行车份额衡量的千禧年活动:今年 3 月，纽约市使用花旗自行车系统的出行次数超过 717，300 次；其中 46%是由 18-35 岁的人拍摄的。让我们看看他们去了哪里。
以脸书活动衡量的活动:目前有 4550 多项脸书活动计划于下个月在纽约市地区举行。689，382，475 人表示将参加。让我们看看这些事件发生在哪里。

千禧一代流量+活动密度=我们的机会

这里是纽约千禧一代使用花旗自行车的地方

Least active (light blue) to most active (dark blue)

这里是脸书事件发生的地方

Fewest events (light blue) to most events (dark blue)

当我们对数据进行分层时，这两个区域最有希望成为新的夜总会。两者都获得了大量的千禧一代流量，并举办许多社交活动。

你知道吗？

纽约市自行车共享出行的平均时间是 12:57 分钟。与此同时，他们在蒙特利尔比在伦敦多了 0:13 分钟和 5:21 分钟。****

在纽约市，千禧一代完成一次旅行的平均时间比 35 岁以上的人快 38 秒。

谈到 Easy Atlas 的潜力，这些例子只是冰山一角。我们的系统以前所未有的方式了解城市的位置和动态特性，并实现了前所未有的发现和分析。利用 Easy Atlas 的可能性，确保您未来的所有投资和商业决策都植根于最新的数据和机器学习。

如果您有兴趣与我们合作，将您的位置战略提升到一个新的水平，请给我们发消息，地址是info@easyatlas.com。

MongoDB——引领 NoSQL 的潮流

原文：https://towardsdatascience.com/mongodb-world-18-leading-the-nosql-charge-b6032116f31f?source=collection_archive---------13-----------------------

MongoDB World’18 向我们展示了数据库技术的未来

CTO Eliot Horowitz introduced many of the novel features of MongoDB 4.0.

你好。我是 Sohan。欢迎来到我的第一篇博客。我的目标是利用这个空间，通过我自己作为计算机科学本科生的成长来探索科技世界。我决定从 MongoDB 开始，这是因为它给这个行业带来了创新，也是因为我接触了这个产品。

6 月 27 日星期三，我有机会前往纽约参加 MongoDB World 2018。在该公司的旗舰年度会议上，MongoDB 4.0 被公布，同时还有许多功能可以帮助公司永远转向非关系数据库。

Example of a collection of JSON documents. (source)

那么，什么是非关系(或 NoSQL)数据库呢？嗯，它们与关系数据库有很大的不同，这是一个很好的复习，可以在这里找到。MySQL 等传统数据库利用基于表的结构来存储数据，而在非关系型数据库中，一切都是基于文档的。文档以无序的方式存储在一个集合中，通常没有什么层次结构。每个文档都代表一个对象—无论是客户还是待售商品—并且具有任何和所有相应的信息—从名称和年龄到价格和剩余库存。这为数据存储提供了更大的灵活性，并减少了手动构建数据所花费的时间和精力。

越来越多的公司决定转向非关系数据库，尽管 MongoDB 在 2009 年才推出，但它在最受欢迎的数据库中排名第五。街区里新来的孩子正在获得大量的街头信誉，这并不奇怪为什么。凭借更快的数据访问速度、出色的可伸缩性和熟悉的 JSON 风格文档(更不用说专业的 MongoDB 支持)，这些优势在大数据时代显而易见。我在 Everbridge 的暑期实习中一直在使用 MongoDB，我可以证明它的易用性和快速查询。

目前，MongoDB 面临的最大挑战包括扩大客户群和让用户为优质服务付费。作为一个开源产品，MongoDB 的商业模式建立在开发者和支持特性的基础上，这使得客户获取和保持对其成功至关重要。这一重点在首席执行官 Dev Ittycheria 上台的会议主基调上非常明显。在谈到该公司最近的快速增长(以及 2017 年 10 月 IPO 后股价飙升)后，他将注意力转移到了客户故事上。Travelers Insurance、Braze 和比特币基地等公司的高管和开发人员走上舞台，讨论如何使用 MongoDB，特别是该公司的优质云服务产品 Atlas，通过满足业务需求来帮助支持快速增长。

Hyman explained how MongoDB’s scalability has helped Braze send billions of notifications to customers.

对客户故事的巨大关注绝对让我大吃一惊。总而言之，Ittycheria 在很大程度上充当了一个主持人的角色，他很好地设计了各种各样的评价。从房间的气氛来看，这种方法显然是合格的。几乎每个我在会议上交谈过的人似乎都对这个产品感到由衷的兴奋。顾客故事无处不在——itty cheria 只是选择了最有影响力的故事。从初创公司的创始人到辉瑞或 IBM 等传统公司的员工，很明显，MongoDB 是一股不断增长的受欢迎的颠覆力量。

随着 MongoDB 4.0 的现场发布，这种兴奋感更加强烈了。在主题演讲的这一部分，首席技术官兼联合创始人艾略特·霍洛维茨率先发言，没有让大家失望。他将矛头直接指向传统数据库，开玩笑地将 SQL 称为“低劣的查询语言”，并公开了显然旨在处理关系数据库优势的特性。

MongoDB’s evolution has been driven towards Multi-Documented Transactions with the goal of improving data integrity. (source)

有什么新鲜事吗？4.0 的主要好处是它为 MongoDB 带来了 ACID(原子的、一致的、隔离的、持久的)事务，并且以一种非关系数据库闻所未闻的方式。为什么这很重要？我将借用霍洛维茨提供的一个案例，并做一些修改。

假设你有一个网上商店，在那里你出售纪念品来支持你最喜欢的当地足球队。有了 MongoDB 4.0 的交易，你所有的库存都会随着订单的到来而被准确跟踪。例如，如果一个客户从您的网站订购了一件 35 美元的运动衫，在一次交易中，客户的总额将增加 35 美元，而您的该运动衫的可用库存将减少一件。以前，事务中的故障(通常由网络故障或服务器崩溃引起)会导致重大问题，而多文档 ACID 可以防止这种情况。

在欧洲有铁杆支持者，只需要得到那些个性化的帽子？Atlas 的全球集群允许您将他们的数据放在您需要的地理位置，然后您可以在那里读取和写入，从而有助于 GDPR 合规性。通过 AWS、微软 Azure 和谷歌云平台的可用性，有丰富多样的服务器位置可供选择。

对于我们的案例来说，这就足够了。这一切对你来说意味着什么？

早些时候，我将 MongoDB 描述为一股受欢迎的不断增长的颠覆力量。那是有条件的真实。为了真正欢迎这些变化，必须了解非关系技术及其在塑造数据使用和存储的未来方面的进步。在这个不断变化的行业中保持最新。资源就在那里！

MongoDB 已经在教育领域取得了长足的进步——查看 MongoDB 大学的官方在线课程和来源认证。对于定期的技术博客帖子，你知道在哪里可以找到我。谢谢你的来访！

蒙特卡洛魔术搜索:聚会

原文：https://towardsdatascience.com/monte-carlo-search-for-magic-the-gathering-6ca60750fcc6?source=collection_archive---------2-----------------------

探索卡牌游戏与人工智能的交集

我们最近看到了强人工智能(AI)在高难度棋盘游戏(如围棋和扑克)中的出现。还有一个超人的魔术:聚集(MTG)球员，但我相信这只是一个时间问题。一旦我们有了这样的球员，会有一些特别有趣的后果。

强大的游戏技巧将能够指导甲板建设。我们应该能够将一个强大的 MTG 玩家放在一张牌池上，允许它与自己进行数千次或数百万次游戏，并自己“破解 meta”(从可用的牌中构建最好的牌组)。

监控这些人工智能玩家将极大地有利于游戏设计者和玩家。想象一下这样一个世界，每一套都或多或少完美平衡，没有必要禁止……但是，不幸的是，这种技术对信用卡价格投机者也是有利的。

在这篇文章中，我简要描述了游戏人工智能的基础，并考虑了 MTG 最近的一种决策方法。我描述了一些测试这种方法的实验，并讨论了令人兴奋的未来工作。这些实验是在一个简单的 Python 模块 OpenMTG 中实现的，我希望它能够作为 AI MTG 玩家的基础。

魔法:在最小的果壳里聚集

MTG 是一种至少有两个人相互竞争的游戏。游戏的目标是通过各种手段获胜，最常见的是通过将对手的生命总数减少到 0。玩家开始游戏时除了带一叠卡片什么都没有，然后轮流抽取和使用不同类型的卡片。现在，我将集中在三种类型的牌上:地、魔法和生物。

Magic cards: A land, sorcery, and creature.

土地为玩家生产货币。每回合你可以将一个地放入游戏区(战场)，它可以用来产生*法力，*可以用来执行其他动作。这些包括使用生物或魔法。

巫术执行一个动作，然后被丢弃。例如，减少对手的总生命值或摧毁对手的土地。

生物是进入战场的牌，被允许攻击你的对手或阻挡敌方攻击者。游戏不可或缺的一部分是生物之间的战斗。游戏中一些最困难的决定是关于如何用你的生物攻击你的对手，以及你如何分配你的生物去阻挡你对手的生物。

如果你仍然好奇的话，这里有更详细的规则解释:https://magic.wizards.com/en/gameplay/how-to-play

一点博弈论

MTG 是一个零和游戏，这意味着一个玩家输了，另一个玩家赢了。在这种游戏中采取最优决策的算法是极小极大 算法。

使用极大极小算法，在游戏中的每一个状态，你都要考虑你能走的每一步，并选择最有价值的一步。如果一步棋能让你赢得比赛，它就有最高的价值。如果它导致你的损失，那它的价值可能是最低的。

如果一个移动没有导致游戏结束，你递归地考虑下一个游戏状态和与合法移动相关的值。请注意，你通常假设你的对手会采取对他们最有利的行动。

探索所有可能的游戏轨迹可能需要一段时间，因此通常会对我们希望搜索的深度设置一个限制，并构建一个衡量游戏状态承诺的函数，称为启发式函数或价值函数。这个函数在你赢的时候取最高值，在你输的时候取最低值。对于其他游戏状态，它介于两者之间，取决于你认为自己赢或输的可能性有多大。

考虑一个简单的场景，轮到你了，你有两个合格的攻击者。你的对手只剩下 1 点生命值，他们的资源也耗尽了(他们*耗尽了)，*除了一个合格的阻挡者。你对手的生物可以阻挡一个攻击者，但如果攻击者未被阻挡，那么它会对你的对手造成致命伤害。

A minimax decision tree of depth 2: For this scenario, the value of winning is +1, losing -1 and states where the game isn’t over yet have a value of 0.

最小最大算法建议用这两种生物攻击，因为这保证了你的胜利。你可以通过攻击一个生物来获胜，但是你假设你的对手做了对他们最有利的事情，所以用一个生物攻击的价值和根本不攻击是一样的。

极大极小的问题是

即使上面的场景是在游戏结束时，也要考虑八种状态。此外，我们已经知道了做出完全知情的决定所需的一切。如果我们想在游戏早期做出最小最大决策，那么我们必须考虑所有潜在的隐藏信息。也就是说，对手可能持有不同的牌，我们的牌组(牌库)可能有各种不同的排列方式，我们对手的牌库也可能有各种不同的排列方式。即使知道我们对手的甲板列表，我们也可能处于超过十亿种不同的游戏状态中的一种。

这使得寻找游戏的完全极大极小解在物理上是不可能的。有一些方法可以减少在极大极小中要考虑的博弈状态的数量，例如阿尔法-贝塔剪枝。然而，这些方法已经被证明对于有太多游戏状态需要考虑的游戏来说是困难的。

全副武装的匪徒前来救援

既然为你想做的每一步棋评估游戏的每一个可能结果是一场计算噩梦，那么最好做一个概率估计。在概率论中，多臂强盗问题是一个玩家有几个选择的问题，每个选择给出一个随机奖励。这个比喻指的是吃角子老丨虎丨机，有时被称为独臂强盗。

One-Armed Bandits: The gang’s getting back together for one last heist. Photograph by Yamaguchi 先生 / CC BY-SA 3.0

每个强盗都有自己的内部参数，即平均给予多少奖励。有了关于所有参数的完美信息，玩家可以选择只与有最高预期奖励输出的强盗互动。然而，玩家得到的唯一信息是他们互动的随机奖励。根据大数法则，玩家可以更好地估计他们在每一次互动中能从强盗那里得到多少。

蒙特卡罗搜索

我们会考虑在多兵种的土匪问题中，我们作为土匪可以做出的每一个潜在的举动。内部奖励参数是如果我们选择一步棋，我们获胜的可能性。对于每一个合法的行动，我们想象游戏的其余部分在完成后会如何发展。这可以做任意次数，给我们很好的估计每个动作的力度。这就是为什么一个方法 Monte-Carlo: 做一些随机的事情很多次来得到一个有用的集合结果。

缓解上述问题的一个很好的切入点是 一文中描述的方法蒙特卡洛搜索应用于魔术中的选卡:聚会 。他们只在主要阶段使用它，但是它可以在游戏中的任何时候使用

算法如下，在可以做出决定的每个点:

列举所有合法的移动
对于每个合法的移动，在执行该移动后模拟一个完整的游戏，并记录您是赢了还是输了。这种模拟被称为卷展栏。
重复大量的步骤:选择一个随机的合法移动，并支持获胜的移动。执行所选的移动并执行卷展栏。
将上面最常选择的棋步返回为最佳棋步。
在真实的游戏中表演最好的动作。

关于算法的注记

在每次推出之前，未知信息(即牌库中牌的顺序，对手手中的牌)被随机化。这需要很好地猜测对手的牌。

如何在 2 中模拟游戏。很重要。现在，我们会让两个玩家每次执行一个随机动作。我不认为这是最佳的，但这将给我们一个快速原型。

三分钟后。，我们可以控制选择一个好的行动而不是再次尝试一个明显错误的行动的可能性有多大。这就是所谓的探索-开发权衡:选择尝试更多的选择以获得更好的感觉，选择哪一个是最好的，或者“耕种”看起来最好的选择。对我来说，这本质上和决定晚餐再吃披萨还是最终尝试新事物的两难境地是一样的。

一些实验

那么，蒙特卡罗搜索的表现如何呢？我用必要的游戏机制实现了来自第八版 核心游戏和的基本金银牌。

Ready-to-play decks: It makes it much easier not to have to worry too much about instant-speed actions and the stack — for now!

让我们允许黄金和白银玩家用不同的决策规则进行一百场比赛。每场比赛前，我们掷硬币决定谁先开始。如果我们让他们执行随机的动作，两个玩家看起来是平等的，尽管金牌可能会稍微占优势。

The win rates from the perspective of the gold player: In each column, we fix one search method for the Silver player and vary the number of rollouts for the Gold player— and similarly for the Gold player, per row. If there are 0 rollouts, we let the player choose any legal move at random.

请注意，在表格中，随着我们从左到右，百分比变得越来越低，从上到下，百分比变得越来越高。

增加蒙特卡洛决策会使银卡玩家更受欢迎，每次移动增加更多的滚屏会使银卡玩家更受欢迎。然而，如果允许黄金玩家执行等量的转出，则黄金玩家变得更受青睐。白银玩家在执行随机动作时，与拥有 50 甚至 10 个翻滚的黄金玩家相比，机会非常小。

结果不是决定性的，但实验表明黄金甲板更好。无论如何，蒙特卡罗搜索比随机行动要好，做更多的铺开更好。

下一步是什么？

在经典的人工智能方法中，这是一个有趣的练习，但是还可以做得更多！拥有一个完全开放的 MTG 是最理想的——至少包括玩家之间的即时速度互动，以及更复杂的触发和效果。我的代码可以在 github 上找到，我喜欢合作，把强大的人工智能带到 https://github.com/hlynurd/open-mtg 的 MTG:

实际上，改进不完全信息下的博弈树搜索是必要的。在上面的实验中，我们允许玩家互相认识对方的行李箱盖，但这通常不是事实。

探索不同的方式将先前的知识结合到搜索中会让玩家变得更强大，而不会给他们不公平的信息。如果你的对手玩的是山，那么你更有可能准备敌对的红色牌，而不是其他颜色的牌。根据格式或元，你可能想在游戏开始前立即考虑或放弃某些牌。

强大的围棋人工智能 AlphaGo ，结合了关于游戏状态的手工或常识知识，以及原始游戏状态，作为神经网络的输入。这允许自动学习一种启发式函数来引导他们在游戏中寻找好的移动。一个类似的功能，衡量“什么是好的，什么时候”对 MTG 来说也很重要。

通过结合所有这些，我想象一种强化学习方法将帮助我们建立一个在构建和限制格式方面都非常优秀的代理。

作为一个成熟的人工智能 MTG 玩家，在未来的某个地方观看一些高调的人机对抗比赛会很有趣。

致谢:感谢 Haukur Rósinkranz 对本文的建设性反馈。

蒙特卡罗树搜索

原文：https://towardsdatascience.com/monte-carlo-tree-search-158a917a8baa?source=collection_archive---------0-----------------------

每个数据科学爱好者的 MCTS

像井字游戏、魔方游戏、数独游戏、国际象棋、围棋和许多其他游戏都有一个共同的属性，那就是可以玩的动作数量呈指数增长。随着游戏的进行，这些可能的步骤会成倍增加。理想情况下，如果你能预测未来可能发生的每一个可能的举动及其结果。可以增加自己的胜算。

但是，由于移动呈指数增长，计算移动所需的计算能力也达到了顶点。

蒙特卡洛树搜索是一种通常在游戏中使用的方法，用于预测策略应该采取的路径(移动)以达到最终的获胜解决方案。

Final output could be any one of these

在我们发现引导我们走向胜利的正确道路(步骤)之前。我们首先需要安排游戏当前状态的移动。这些动作连接在一起会看起来像一棵树。因此得名树搜索。请参见下图，了解移动的突然指数增长。

树形搜索算法

这是一种用于搜索游戏回合后可能存在的每一步棋的方法。例如:在井字游戏中，玩家有许多不同的选择，可以用树形图来表示。在下一轮将图表演变成树时，移动可以进一步增加。

Source

通过考虑每个子移动/节点来强制指数增长树找到问题的最终解决方案需要大量的计算能力。导致极慢的输出。

💡通过制定策略可以实现更快的树搜索——给予一些节点比其他节点更大的重要性&允许首先搜索它们的子节点以获得正确的解决方案。

而是如何找到最有利于在它们子节点中具有正确解的节点。让我们来看看…

什么是蒙特卡罗树搜索？

MCTS 是一种算法，它通过选择→扩展→模拟→更新树中的节点来找出一组移动中的最佳移动，以找到最终的解决方案。这个方法一直重复，直到达到解，学习到博弈的策略。

蒙特卡洛树搜索是如何工作的？

让我们逐一查看循环的各个部分。

SELECTION

选择👆 |此过程用于选择树上最有可能获胜的节点。例如—考虑有获胜可能性的棋2/3, 0/1 & 1/2在第一步4/6之后，节点**2/3**获胜的可能性最高。

从树的当前状态中搜索选定的节点，并且选定的节点位于分支的末端。由于所选节点获胜的可能性最高，因此该路径也最有可能比树中的其他路径更快地到达解决方案。

EXPANSION

展开— 选择正确的节点后。扩展用于在游戏中进一步增加选项，方法是扩展选中的节点并创建许多子节点。在这种情况下，我们只使用一个子节点。这些子节点是游戏中可以玩的未来招式。

暂时没有进一步展开的节点称为叶子。

SIMULATION

模拟|探索🚀因为没有人知道哪个节点是组中最好的孩子/叶子。这一步将表现最好，并导致正确的答案。但是，

我们如何找到最优秀的孩子，从而引导我们找到正确的解决方案？

我们使用强化学习在游戏中从每一个孩子节点往下随机决策。然后，奖励被给予每个子节点——通过计算他们随机决策的输出与我们赢得游戏所需的最终输出有多接近。

**比如:**井字游戏中。随机决定在游戏中的前一个十字(X)旁边做十字(X)会导致赢得游戏所需的三个连续十字(X-X-X)吗？

仅供参考:这可以认为是 RL 算法的策略π。了解有关政策&价值网络的更多信息…

[## 强化学习中的政策网络与价值网络

在强化学习中，代理在他们的环境中采取随机决策，并学习选择正确的决策…

towardsdatascience.com](/policy-networks-vs-value-networks-in-reinforcement-learning-da2776056ad2)

对每个孩子节点进行模拟，然后是他们各自的奖励。

UPDATING | BACK-PROPAGATION

假设节点的模拟对其未来给出了乐观的结果，并得到了 1/1 的正分数。

更新|反向传播— 由于环境中的新节点及其正或负分数。它们的父节点的总分数必须通过一个接一个地回到树上来更新。新的更新分数改变了树的状态，并且还可以改变选择过程的新的未来节点。

在更新所有节点之后，通过选择树中的最佳节点→ 扩展所选节点的→使用 RL 进行模拟探索→ 反向传播更新的分数→然后最终选择树中更靠下的新节点，这实际上是所需的最终获胜结果。

比如:解决了魔方，数独的正确解法，象棋中的杀王或者

Final Required Solution of TIC-TAC-TOE

结论

而不是从数百万种可能的方式中蛮力寻找正确的路径。

蒙特卡洛树搜索算法在强化学习的帮助下，从游戏树的当前状态中选择最佳可能的移动。

感谢您阅读这篇文章。如果你有任何疑问或者只是想谈谈数据科学，请写在下面的评论中。

鼓掌吧！分享一下！跟我来。

关注我的中和推特获取更多类似内容。

你会喜欢的以前的故事:

[## 激活函数:神经网络

Sigmoid，tanh，Softmax，ReLU，Leaky ReLU 解释！！！

towardsdatascience.com](/activation-functions-neural-networks-1cbd9f8d91d6) [## 纪元与批量大小与迭代次数

了解您的代码…

towardsdatascience.com](/epoch-vs-iterations-vs-batch-size-4dfb9c7ce9c9) [## 50 tensor flow . js API 5 分钟讲解| TensorFlow.js Cheetsheet

TensorFlow API Cheetsheet

towardsdatascience.com](/50-tensorflow-js-api-explained-in-5-minutes-tensorflow-js-cheetsheet-4f8c7f9cc8b2) [## 手机上的 TensorFlow:教程

在 Android 和 iOS 上

towardsdatascience.com](/tensorflow-on-mobile-tutorial-1-744703297267) [## 用 6 个神经元玩雅达利|开源代码

#2 研究论文解释

towardsdatascience.com](/playing-atari-with-6-neurons-open-source-code-b94c764452ac)

黄画的蒙特利尔:神经风格的网络

原文：https://towardsdatascience.com/montreal-painted-by-huang-gongwang-neural-style-networks-ec1697b2ac54?source=collection_archive---------9-----------------------

最近，CNN(卷积神经网络)的一个非常酷的应用是设计神经网络；这些包括分离一幅图像的风格和另一幅图像的内容，然后将它们组合起来:

An example of style transfer, from the first paper to describe it, ‘A Neural Algorithm of Artistic Style’, by Gatys et. al

这里使用的风格转换方法是基于图像迭代。这意味着算法将多次改变图像(即“迭代”)以获得输出图像。

因此，主要的挑战是描述一个损失函数，它可以告诉算法它正在创建的图像是更接近还是更远离我们想要的。

这是一个不小的问题；你如何告诉一个算法，你想要图像 A 中的房子的形状，但你想把它画成约瑟夫·特纳的《牛头怪的沉船》？

突破来自于使用卷积神经网络进行图像识别；当 CNN 学习识别一幅图像是否包含一所房子时，它会学习房子的形状，但它的颜色并不重要。CNN 隐藏层的输出因此可以用来定义神经类型网络的损失函数。

我将探索风格神经网络，并赶上自 Gatys 的 2014 年论文首次介绍这一想法以来，基于图像迭代的描述性风格转移的其他发展。

这篇文章附带的代码在这里:https://github . com/Gabriel Tseng/learning data science/tree/master/computer _ vision/style _ neural _ network

内容:

目录中的每个部分都基于一篇论文(每个部分下面有链接)。我的方法基本上是尝试在 Keras(和 Tensorflow)中实现每篇论文。

得到风格神经网络的直觉，以及基本风格神经网络
和艺术风格神经网络
在整个图像中添加更一致的纹理
在基于 CNN 的纹理生成中加入长距离一致性
添加直方图，消除 Gram 矩阵的可变性
使用直方图损失实现稳定可控的神经纹理合成和风格转换
结合这一切

基本型神经网络

论文，代码(对于一个风格神经网络的基本实现，我用了这个帖子)

考虑一下传统的神经网络是如何学习的:它会对它接收到的一些数据做出一些结论，然后根据它是对还是错来调整它的权重。

风格神经网络的工作方式完全不同。CNN 的权重是固定的。相反，会产生一个输出图像，网络会调整图像上的像素。

Starting from a random image, the pixels are gradually improved to resemble an image of the Montreal skyline painted in the style of Huang Gongwang’s Dwelling in the Fuchun Mountains.

我使用 VGG 图像识别模型创建了上面的图像(我在这里探究)。风格神经网络利用了 VGG 模型的不同层擅长识别不同事物的事实。后面的层善于识别形状和形式(内容)，而前面的层识别图案和纹理(风格)。

因此，如果生成的图像在 VGG 的后续图层中具有与图像 A 相似的输出，那么它可能具有与图像 A 相似的内容

另一方面，如果生成的图像在通过 VGG 早期的图层时具有与图像 B 相似的输出，那么它们可能具有相似的风格。

有了风格，还有一个额外的转折；计算格拉米矩阵，并以此作为比较，而不是纯粹的输出，更有效地传达风格。

通过量化生成图像的输出与输入“目标”图像(图像 A 和 B)之间的差异，我生成了一个函数。这给了我一个梯度，然后我可以用它来调整我生成的图像的像素(使用梯度下降)。

我可以将差异量化为生成图像和目标图像的 VGG 模型输出之间的均方误差:

Creating a loss function. The loss function, and gradient, are recalculated at every iteration. The gradient is a matrix of the same size as the generated image (with two additional dimensions, for the RGB channels), so that each pixel is changed according to the gradient value for that pixel.

注意:从现在开始，当我说我在比较图像时(例如，比较生成的图像和样式图像)，我的意思是我在比较 VGG 输出。

神经网络的内容和风格方面的实际目标是什么？我可以通过从随机噪声开始，仅使用内容或损失函数来观察神经网络的每一侧试图生成什么图像，来对此进行可视化:

Starting from random noise, only using the content loss function with the Montreal skyline as content input yields the bottom left image. Only using the style loss function with the Fuchun mountains as style input yields the image on the bottom right. In both cases, the network was run for 10 iterations.

然后，将风格和损失函数结合在一起得到:

A combination of style and content, after 10 iterations. Note: as per Novak and Nikulin’s recommendations, I used the content image as the starting image, instead of random noise.

这是一个超级酷的组合图像的开始，但也有一些缺点。幸运的是，后来的研究人员已经做了大量的工作来解决这些问题。我现在将尝试实现这些解决方案中的一些，以获得一个很好的蒙特利尔图像，如黄所画。

包含长期一致性

论文

X 的克矩阵是其自身与其转置的点积:X(X 转置)。这将 X 的每个元素与其自身进行比较，并且擅长于获得图像中正在发生的事情的全局理解。

然而，这不能捕捉图像内的局部结构。比较局部结构的一种方法是，不仅将每个元素与其自身进行比较，还将其相邻元素进行比较。有一个简单的方法来实现这一点；在计算 gram 矩阵时，只需将输出向侧面平移一点:

Credit to the original paper for this figure.

对风格损失函数进行这种微小的改变会对输出产生显著的影响:

With the same input as before (Dwelling in Fuchun Mountains), the simple act of shifting the gram matrices leads to a very different style output; the shape of the mountain is nearly visible, showing the extent to which local image structure is conserved.

直方图损失

论文

使用 Gramian 矩阵来衡量风格有一个很大的问题，这就是不同的图像可以产生相同的 Gram 矩阵。因此，我的神经网络可能会以不同于我想要的风格为目标，而碰巧会生成相同的 Gram 矩阵。

这是一个问题。

幸运的是，有一个解决方案:直方图匹配。这是目前在图像处理中使用的技术；我获取了源图像中像素颜色的直方图，并将它们与模板图像进行匹配:

An example of grayscale histogram matching with two images. Credit to ali_m for this image.

同样的原理也可以应用到我的图像输出中。通过将我生成的图像用作源图像，将目标样式图像用作模板图像，我可以将我的损失定义为生成的图像和目标样式图像之间的差异。

Histogram matching with the target outputs. The jitteriness of the matched histogram can be attributed to the number of histogram bins; I plotted this using 255 bins. Using every unique output layer value as a bin would have been desirable, but computationally impossible (there were about 5 million unique values). This jitteriness was therefore the tradeoff for reasonable computation times.

现在，给定我的生成图像和匹配图像，我可以将我的损失定义为两者之间的均方误差。然后，可以将这个新的直方图损失添加到 Gramian 矩阵产生的损失中，以使其稳定。

将所有这些结合起来，并进行额外的改进

将这两个损失与原始内容和样式损失相结合(并调整 hyper 参数),得到以下结果:

Montreal, as painted by Huang Gongwang. The input images were ‘Dwelling in the Fuchun Mountains’ and this image of the biosphere.

天空中有一点噪音，但是考虑到我只运行了 10 次迭代(相比于一些论文中的 1000 次)，这是一个相当酷的结果！

外卖:

放过网络！当生成最后一个图像时，我倾向于“微观管理”我的网络，一旦损耗停止下降就改变参数。仅仅让网络运行就能产生最好的结果，因为它往往会脱离那些常规。
调整风格神经网络的参数尤其困难，因为这最终是一种主观判断，即一幅图像看起来是否比下一幅好。此外，一些图像会比其他图像做得更好。
张量流很棘手。特别是，评估一个张量是确保一切正常的唯一方法；tensorflow 可能会说一个操作很好，只是在评估时抛出一个错误。

请采取代码，并作出冷静的形象！

使用 Python 的 Monty Hall 问题

原文：https://towardsdatascience.com/monty-hall-problem-using-python-ccd5aadc5921?source=collection_archive---------8-----------------------

借助编程理解数学证明

我们都听说过三门游戏节目的概率脑筋急转弯。每位参赛者猜猜门后是什么，节目主持人会展示三扇门中没有奖品的一扇门，并给参赛者一个换门的机会。假设并且事实上使用条件概率证明，换门会将你的机会增加到惊人的 66%。但是等等，当我进入游戏，不知道哪扇门有奖品时，我有 33%的机会获胜，当主持人揭示其中一扇门没有奖品时，这难道不意味着还有两扇门，有 50%的机会获胜吗？我为什么要换？如果你是那种不相信你在电视上听到的或者你在杂志有趣的事实专栏中读到的，但是对数学证明有好奇心的人，这里有你的答案。

证明来源:https://www3.nd.edu/~jstiver/Exec_Micro/Monty%20Hall.pdf

以下是你走进游戏节目时的最初概率。

现在到了棘手的部分，这是数学开始变得非常混乱的地方。假设参赛者选择了第一扇门，现在假设奖品在第一、第二或第三扇门后，主人打开第三扇门的概率是多少？这是一个需要理解的重要概念，因为稍后会使用它来推导概率。

from left 1)Probability of choosing door 3 given the prize is in 1 and your initial choice was 1. 2)Probability of choosing door 3 given 2 has the prize and you start with 1. 3) Probability of choosing door 3 given door 3 has the prize and your initial choice was 1.

第一个概率(左)回答问题:如果你选了 1 号门，奖品在 1 后面，主持人露出 3 号门的概率是多少？答案是 50%，主持人可以打开 3 号门或 2 号门，因为他们都没有奖品。但这里的关键概念是，概率是存在的，因为你从 1 号门开始。

如果你选择 1 号门，而奖品在 2 号门(中间)，主持人很可能会打开 3 号门，因为 1 号门已经被参赛者选中，2 号门有奖品，所以主持人只能打开剩下的没有奖品的 3 号门。

现在，如果奖品在 3 号门，在参赛者选择 1 号门后，主持人没有机会打开 3 号门。像前面的场景一样，在这种情况下，主机将总是打开门 2。假设我们从 1 号门开始，如果 3 号门有奖，打开 3 号门的概率是 0。

现在我们已经理解了原因，让我们假设在这个例子中，主人打开门 3。3 号门没有奖品，现在我们怎么能确定 2 号门有奖品呢？

概率基于贝叶斯定理。到目前为止，我们的逻辑和推理已经创造了信息，我们将插入到这个等式中，以获得条件事件的概率。

这里要理解的主要概念是最左边的概率陈述。假设门 3 显示为没有奖品，我们最初的选择是门 1，它计算门 2 成功的概率。所以我们切换的时候成功的几率是 2/3！另一种选择；如果我们在这种情况下仍然选择 1 号门，获胜的机会将如下。

不管你从哪个门开始，同样的概率应该随之而来。条件是以这样一种方式创造的，即总是产生给定的结果。

现在是有趣的部分。让我们看看这是不是真的！

%matplotlib inline
import matplotlib
import numpy as np
import matplotlib.pyplot as plt
from time import time as TT
from random import choice as ch
import numpy as npac = []
tc = []
N = []
st = TT()
for M in range(1,10000): #Outer loop from 1 to 10000
    st1 = TT()
    score = []
    runs = 0
    cards = [1,2,3]
    for K in range(1,M): # sub loop that simulates 1 to M(outerloop) games
        aset = []
        host = cards.copy()
        hbk = ch(host) #Randomly choose as answer which host knows
        aset.append(hbk)
        #print("The host knows the answer",hbk)
        player = cards.copy()
        px = ch(player) # Contestanrs random guess
        aset.append(px)
        #print ("Players first choice",px)
        chance = 0
        for i in host: # The computation....host will eliminate P(X|DOOR) = 0
            if i not in aset:
                chance = i
        #print ("The elimination",chance)
        #print (player)
        player.pop(player.index(chance))
        player.pop(player.index(px))
        #print ("final answe",player)
        if player[0] == hbk:
            score.append(1)
        else:
            score.append(0)
        runs = K
        #print ("\n\n")
    ac.append(np.mean(score))
    N.append(M)
    en1 = TT()
    tc.append(en1-st1)
en = TT()    
print ("Total time for Loop  ", en - st )

上面的代码模拟游戏 10，000 次，其中每一次重复都是游戏数量增加的循环。这个过程可以用不同的方式来完成，但是结果应该是相同的，但是使用上面描述的循环来获得正在玩的游戏的数量的变化是很有趣的，这确实会影响最终的结果。

这个节目中的主要逻辑是，在参赛者选择第一扇门后，主持人将消除参赛者没有选择的门或正确答案的门。如果参赛者的第一个猜测是正确的，选择显示的门是一个随机过程。但是我的计算方法是，如果元素不是正确答案，它将是列表(1，2，3)的最后一个元素。 这样做之后，出于模拟的目的，参赛者在揭示之后总是会改变他的答案。 所以这样通过这个模拟我们就有了下面的结果。

X 轴是玩的子游戏的数量。Y 轴是赢得的子游戏的平均数。在 0-100 个子游戏之间，你可以看到有很大的变化，但在 2000 个标记和接近 10，000 个标记之后，子游戏的平均获胜数集中在 64%-68%左右(最多 70)。这支持了我们最初通过贝叶斯定理得出的推论。

如果我们有 3 个以上或更少的选项，这个理论可能会有不同的规模。

code:https://github . com/siddharthapachhai/python samples/blob/master/monty hall . py

领英:https://www.linkedin.com/in/siddhartha-pachhai-0a1889b9/

摩尔定律正在消亡。这就是人工智能如何让它复活的！

原文：https://towardsdatascience.com/moores-law-is-dying-here-s-how-ai-is-bringing-it-back-to-life-c9a469bc7a5a?source=collection_archive---------4-----------------------

摩尔定律是表明科技行业(尤其是电子工程)指数级进步的基本定律之一，最近(更准确地说，是从 2005 年开始)放缓了，这让该行业的许多人认为这条定律不再适用。那是，直到人工智能加入了竞技场！从那以后，游戏变了，摩尔定律正在慢慢复活。

Image by author

让我们来看看人工智能是如何逆势而上的。

什么是摩尔定律？

Image by author

英特尔的联合创始人之一戈登·摩尔在 1965 年注意到，集成电路上每平方英寸的晶体管数量每年翻一番，而在几乎相同的速度下，成本却下降了一半。因此，他预测这种趋势将持续到可预见的未来。

我知道，我们中的一些人可能会想“仅此而已？好吧，不如我注意到下雨了，然后制定我自己的法律说每年都会下雨？?"。但是摩尔定律不仅仅是一个模糊的猜测:它也符合一个叫做丹纳德缩放的技术缩放规则，即“随着晶体管尺寸的减小，它们的功率密度保持不变”。呃……什么？好了，翻译成英语，这就意味着:单位面积的晶体管数量会增加。芯片(现在有更多的晶体管)单位面积的功率需求将保持不变，而电压和电流将随着长度的增加而降低。预言果然实现了:电子行业一直在蓬勃发展！

晶体管不仅变得更小，而且速度更快，更节能，因此芯片现在可以在大约相同的美元和功率预算下提供至少两倍的性能。

摩尔定律成立…直到它不成立。

摩尔定律为什么会消亡？

正如 NovuMind 公司的陆建平在他的论文中简明扼要地指出的:

转折点发生在 2005 年，当时晶体管的数量继续翻倍，但速度和以前一样，既没有更快也没有更节能。

原因如下:21 世纪是电子行业将技术带给人们的时代。商业繁荣，三星和高通分别是手机和处理器的典范。但是在这个时代，科技行业的竞争对手是真实存在的！因此，一家公司提供的硬件必须继承其遗产:它必须符合规格，为每个新版本提供更好的用户体验，因此不能为了节能而进行大规模修改。

丹纳德标度方面出现了故障，因此从那时起就偏离了摩尔定律的趋势。进入人工智能，以及它如何修复情况。

人工智能是如何修改摩尔定律的

(Sourced from https://artificialintelligenceimpacts.wordpress.com/2019/01/27/ai-artificial-intelligence-chip/)

我们都知道媒体和电影业如何用机器人和过度智能的系统过度宣传人工智能。一些计算机先驱，艾伦·图灵(你可能想看模仿游戏来欣赏他的传奇)站在最前沿，开始着手一些项目，以期制造会思考的机器。然而，图灵确实意识到这将极其困难，并在 1950 年提出:

与其试图制作一个模拟成人思维的程序，为什么不试着制作一个模拟儿童思维的程序呢？如果这种大脑接受适当的教育，就可以获得成人的大脑。

这个想法发展成为深度学习。快进到 2018 年:我们已经并仍在收集海量数据。我们已经并仍在开发越来越多的高级算法(生成式对抗网络和胶囊网络就是很好的例子。)但是我们有硬件在合理的时间内处理所有这些计算吗？如果我们这样做了，我们能做到这一点，而不会让所有这些图形处理器因处理过程升温而导致另一场全球变暖吗？

azeem’s diagram explains this trend perfectly in his article

就在这里，人工智能施加了一个约束:保持功率恒定或降低功率，但提高性能……这听起来是不是有点熟悉我们刚刚看到的一些缩放规则？确切地说，通过迫使科技行业推出能够在单位时间内执行更多计算的新处理器，同时保持功耗和价格，人工智能再次强加了 Dennard 缩放，从而迫使摩尔定律复活！

如果你喜欢这篇文章，请给它一个掌声，这样其他人也可以找到它。在数据科学社区中互相帮助总是好的:)

Hans A. Gunnoo 是一名数据科学家，他的职业生涯始于电子工程，后来专攻机器学习。他还在业余时间为开源人工智能项目和关于数据科学领域最新趋势的博客做出贡献。

关于渐变的更多信息

原文：https://towardsdatascience.com/more-about-the-gradient-bf97e4d9c1c5?source=collection_archive---------6-----------------------

在与 Eugene 的交谈中，我列举了一些具体的例子，这些例子可能对我最近的一页“克服消失梯度问题”有所帮助。

考虑玩迷宫游戏的递归神经网络。给出了连续的选择，要么走“右边的路”要么走“左边的路”,只有在选择少于一定数量的情况下才给予奖励。假设在所有成功的剧里，网络选择了‘右侧路径’，而失败的剧有很大一部分是从‘左侧路径’*开始的。“左”是一个错误的决定。而且是第个第个决定。这是典型梯度下降失败的地方；损失函数仅“拉动”网络的最顶层的，因此它没有“力”来改变这些早期错误**。*

随着递归变得更深(更大的迷宫，需要更长的时间来完成)，梯度下降更难识别早期的错误。然而，该错误仅出现在失败的案例中。基于协方差的方法可以立即捕捉到这类误差。

现在，考虑协方差提醒我们有问题的另一个实例，不同于从输出层传播的损失函数:图像分类器，它通常(> 0.95)正确识别“猫”…然而，它失败的时间集中在一些特征的缺失周围。通常活跃的神经元反而变得沉默。(“两只耳朵”举例？)我们希望将我们的“拉力”施加到错误的神经元上，鼓励它们像正确的神经元一样放电(即使双耳并不完全可见)。

一点数学:

作为对反馈的回应，我将深入研究负协方差的一个玩具示例。除了训练中的任何其他图像之外，您的“猫”分类器在训练集中有七幅真实猫的图像(称它们为 A、B、C、D、E、F、G)。你通过你的网络发送每一张“猫”的图像，并勤勉地为你的计算保存每一个神经元的活动。根据正确或错误的分类对它们进行分类——假设，在我们的例子中，所有的 A、B、C、D 都被正确地分类为“cat ”,而 E、F、G 被标记为其他东西。只看我们的第一个神经元 x1，我们可以问:“在{A，B，C，D}中，平均激活是多少？同 for {E，F，G}？”以下是第一个神经元激活的一些样本值:

x1[A]: 0.7 __________ 精确激活值的平均值

x1[B]: 0.8

x1[C]: 1.1

x1[D]:1.0 _ _ _ _ _ _ _ _ _ _ _ _

x1[E]:0.2 _ _ _ _ _ _ _ _ _ _ 错误激活值的平均值

x1[F]: 0.3

x1[G]: 0.0_________

准确批次的平均值为 S=0.9，而错误批次的平均活化值为 R = 0.16666……它们表现不同，这可能是分类错误的原因。

现在，我们求这两个平均数的平均值:(0.9+0.16666)/2 = T = 0.53333。注意这是如何平等地对待平均值的，不管每批中图像的数量(如果有 5 个以上的错误图像，但是它们的平均值仍然是 0.16666，那么它们之间的平均值仍然是 0.53333)。

下一步是随机(替换)挑选一对，每批一对。画出这样一对的例子:x1[ C 和 x1[ F 。从它们中的每一个中减去组合平均值 T。然后，将它们相乘。即，(x1[C]-T)*(x1[F]-T)= U(C，F)。继续画线对，计算它们的 U(v，w ),一边画一边将每个结果相加。有了足够的样本后，将你的总和除以你尝试的配对数。如果和是负的，就保留它，这是围绕 t 的负协方差。

协方差值可以加到你的梯度上，当它接近每个神经元的时候。(您可以尝试使用一个非常小的因子来加权协方差，在添加到梯度之前将其乘以 0.01，并将该行为与具有更强协方差力的网络进行比较，比如 0.1…)

希望这能清晰地勾勒出一个粗略的实现！

正如 Eugene 提到的，可能仍然存在问题:

如果只有一个少数例子是误分类，而有许多神经元，那么每个神经元都有很小的“偶然协方差”机会，这仅仅是因为批量小。这可能会将网络参数推向错误的方向，并使网络处于不良振荡状态。一个有用的统计视角，只有通过探索才能得到验证！

然而，似乎在一小批错误中观察到的协方差(统计上可能，有许多神经元)将仍然在应该施加“拉力”的地方，考虑到这是错误中的共性，而不是成功。协方差不会出现在许多神经元中，就好像它们是随机样本一样；这是一个结构化的环境。我仍在试图想象一种情况:观察到负协方差，而我们不想消除它？直觉上，我们应该总是喜欢让我们错误的网络信号更像正确的，不是吗？

另一个简单的人工智能基础指南。

原文：https://towardsdatascience.com/more-machine-learning-for-people-who-know-nothing-about-machine-learning-e53174a8bdc?source=collection_archive---------22-----------------------

揭开机器学习领域复杂行话神秘面纱的系列文章的第 2 部分

Photo by James Pond on Unsplash

他的文章上接第一部分，在第一部分中，我采用了基于直觉的方法来介绍机器学习的基础。如果你还没有读过那篇文章，那么你会想先读一读。

[## 人工智能基础的简单指南。

机器学习背后的行话听起来可能很复杂，但概念惊人地直观

medium.com](https://medium.com/@danharris293/machine-learning-for-people-who-know-nothing-about-machine-learning-fcc312a53f12)

本系列的目的是揭开讨论或教授机器学习时通常出现的许多技术细节和术语的神秘面纱。我们很多人都容易成为这种谬论的受害者，因为一个话题对我们来说是新的和不熟悉的，那么它一定很难。这是一个问题，因为它立即给理解设置了障碍。

例如，如果你先发制人地认为你不会理解多项式回归，仅仅是因为“多项式回归”这个词看起来很可怕，那么很可能你要花比应该花的时间更长的时间来完全理解多项式回归。另一方面，如果当你听到“多项式回归”时，你对自己说，“好吧，我不知道那是什么意思，但我会假设给出的解释是在我能理解的水平上，我将能够理解它”，那么你可能会更容易地理解这些材料。

这就是为什么我在介绍事物的名称和沉重的行话之前解释机器学习概念背后的直觉。这与顺序解释独立算法如何工作的典型路线形成鲜明对比。

此外，事物的名称一般意义不大。如果你对一个概念有一个直观的理解，那么这比知道这个概念的名字要有用得多。理查德·费曼用褐喉画眉做了一个很好的类比…

你可以用世界上所有的语言知道那只鸟的名字，但是当你完成的时候，你会对那只鸟一无所知。你只会知道不同地方的人类，以及他们怎么称呼这种鸟。…我很早就知道知道一件事的名字和知道一件事之间的区别。

因此，考虑到这一点，我们将继续理解机器学习中的一些新概念。

模型的准确性

记住，模型这个词在这里指的是一个机器学习程序，它已经“学习”了一些关于特定数据集的东西。它不是指凯特·阿普顿！

上次，我们了解到机器学习背后的基本思想是分析一组数据点，了解数据的形状，然后使用学习到的形状来回答关于新数据的问题。

我们问的问题可以是量化的，这意味着答案应该是一个数字。一些例子是:

假设爱丽丝穿六码的鞋，她有多高？
假设我的房子有两个浴室和三个卧室，需要多少天才能卖掉？

问题也可以是定性的，这意味着答案应该是一个数字以外的东西。这些类型的问题可以进一步分为简单的是或否风格的问题和更复杂的问题。一些是或否问题的例子是:

根据这封邮件的内容，它是垃圾邮件吗？
鉴于这个肿瘤有 2 厘米长，它是恶性的吗？
鉴于今天下雨，明天会下雨吗？

更复杂问题的一些例子有:

给定这张照片中像素的颜色值，这是什么物体的照片？
考虑到棋盘的当前状态，我在这盘棋中的下一步应该是什么？
根据这条推文的内容，表达的主要情绪是什么？

现在，很有希望清楚的是，我们可以向我们的机器学习模型提出的问题的复杂性可以有很大的不同。有的比较直白，有的不直白；大多数人的一个共同点是他们很少是 100%准确的。通常，如果我们可以找到一种获得 100%成功率的方法，那么数据就有一些潜在的模式，这意味着机器学习不是真正必要的。

以上面的爱丽丝和她六码的鞋子为例。正如我们上次看到的，我们都有一个直观的认识，即高个子的人一般比矮个子的人脚大，而机器学习模型将有效地“学习”正是这个概念。然而，这条规则并不完美。一些矮的人比其他高的人有更大的脚。人类是杂乱的，尽管我们可以利用数据的明确模式，但我们的模型永远不会 100%正确。

看一下上面的其他一些例子，我们可以看到它们也有同样的特性:

即使是房地产经纪人也不能保证房子卖出的确切天数，因为这取决于许多外部因素。
甚至人类有时也很难分辨一封邮件是否是垃圾邮件。例如，看看网络钓鱼诈骗。
人类有时很难识别照片中的物体。视错觉可以欺骗我们的大脑，或者我们可能认为这件衣服是白色和金色的，而实际上它是黑色和蓝色的！
甚至人类也可能误解某人在推文中表达的情绪，因此期望计算机完美似乎不现实。

就像有些人会比其他人更擅长回答这些问题一样，一些机器学习模型也会比其他人更好。定义一个模型是否好的最重要的指标之一是它的准确性。

当数据科学家谈论模型的准确性时，他们谈论的是模型正确回答模型设计要回答的问题的频率。

但是等等！我们如何计算一个模型有多精确？如果我们能够验证一个模型是否答对了一个问题，那么这一定意味着我们已经有办法知道正确的答案是什么，这意味着使用机器来回答这个问题似乎是多余的！

这看起来有点像第 22 条军规，但事实并非如此。

确定准确性

在继续之前，我先简单解释两个新的技术术语:有监督的和无监督的学习。

到目前为止，我们在这个系列中看到的所有例子都是我们使用监督学习来训练模型的例子。这意味着我们已经有了一些数据，我们知道问题的答案是什么，我们用这些数据来训练我们的模型。

例如，为了训练一个模型，在给定鞋码的情况下预测某人的身高，我们将收集一些我们已经知道每个人的身高和鞋码的数据。这样，我们可以通过这样的方式训练这个模型，“这里有一个人穿 6 码的鞋，身高 170 厘米。”

另一个例子是训练一个可以识别垃圾邮件的模型。我们会收集一组电子邮件，我们已经知道它们是否是垃圾邮件。然后，对于每一封邮件，我们可以向模型显示电子邮件，并告诉它是否应该回答“是的，这是垃圾邮件”或“不，这不是垃圾邮件”。

这叫做监督学习。我们通过给出例子并引导它找到正确的答案来训练这个模型。

无监督学习的工作方式不同，我将在以后的文章中介绍它，所以现在不要担心它。

现在你知道什么是监督学习，我可以更容易地解释我们如何确定一个模型的准确性。方法很简单。

我们不是使用所有的数据来训练模型，而是只使用其中的一部分，比如说 80%。然后，我们可以用剩下的东西来测试我们的模型工作得有多好。因为模型以前从未见过那些额外的数据点，所以我们可以像使用全新的数据点一样使用它们，除非我们知道答案应该是什么。

然后你要做的就是将模型给出的答案与实际答案进行比较，正确的百分比就是模型的准确性。简单！

让我给你看一个简单的例子来巩固这一点。

假设你有 100 封你知道是不是垃圾邮件的电子邮件。你可以选取其中的 80 封，训练一个机器学习模型来识别垃圾邮件。如果电子邮件是垃圾邮件，该模型将回答“是”，如果不是，则回答“否”。

然后，你拿出剩余的 20 封邮件，询问模型对它们的看法。如果模型只得到其中十个正确，那么模型的准确率为 50%。如果它答对了 15 个，那么它的准确率是 75%。

了解模型的准确性是件好事，但这不是衡量模型好坏的唯一标准…

精确度和召回率

说到一个模型有多好，准确性并不是最重要的。除了准确性，还有两个不太为人所知的术语非常重要:精确度和召回率。

与准确性不同，准确性和召回率可能更难记忆和直观理解——这可能是准确性通常是首选指标的原因——但通过几个例子，它们都有意义。

为了将这些概念放到上下文中，让我们从上面看下面:根据这封邮件的内容，它是垃圾邮件吗？

如果你的收件箱和我的一样，我收到的垃圾邮件的数量远远超过非垃圾邮件的数量。如果我选择我的电子邮件，并训练一个机器学习模型来将它们分类为垃圾邮件或非垃圾邮件，那么我可能会得到以下模型:

Results for spam classifier

该表显示，模型确定 70 封垃圾邮件实际上是垃圾邮件，但其中 5 封不是，20 封非垃圾邮件实际上不是垃圾邮件，但其中 5 封是。

该模型的准确度是它得到的正确数字——绿色的比特——除以电子邮件总数:90/100，即 90%。现实生活中的垃圾邮件检测器比这好得多，但 90%听起来没那么糟糕。

所以，精度很容易计算，也很直观，但是精度呢？不像 accuracy，我们使用上表中的所有数字进行计算，precision 只使用其中的两个数字，所以应该更简单！

精确度的公式是(相当令人困惑的)真阳性的数量除以阳性总数。这里的“肯定”一词指的是模型认为是垃圾邮件的电子邮件，也就是模型回答“是”的电子邮件。

Precision of spam classifier

这实际上意味着，在上表中，我们只考虑顶行中的两个值(模型回答“是”)，我们将 70 除以 75(该行的总和)— 93%。稍后我会进一步澄清这一点，但首先，关于回忆。

召回类似于精确。它也只使用两个值，但与 precision 不同。召回的公式是真阳性的数量，除以真阳性的数量加上假阴性的数量。

Recall of spam classifier

这实际上意味着，在上表中，我们只考虑左列中的两个值，我们将 70 除以 75(该列的总和)— 93%。

那么，现在我们知道了如何计算这两个值，它们直观地意味着什么？

模型的精度是一种描述有多少被模型认为是垃圾邮件的电子邮件实际上是垃圾邮件的方式。93%的值意味着每 100 封模型认为是垃圾邮件的邮件中，有 7 封实际上不是。很容易想象这会有多烦人。尽管准确率似乎高达 90%，精确度似乎高达 93%，但这个模型并没有那么好。

为了看到这一点，不要发送垃圾邮件，考虑一个决定患者是否患有癌症的模型。在这种情况下，上面的七封电子邮件实际上是七名健康的患者，他们被告知患有癌症。这 93%精度的成本最终给人们带来了很多痛苦。

该模型的召回是描述有多少实际垃圾邮件被检测为垃圾邮件的一种方式。值为 93%意味着每 100 封垃圾邮件中，模型会认为其中 7 封不是垃圾邮件。这将导致垃圾邮件慢慢进入你的收件箱。还有，烦。

同样，在检测患者癌症的模型的情况下，这一次的结果甚至更糟。这七封邮件实际上是七个患有癌症的病人，但被告知他们没有！

简而言之，当误报的成本很高时，精度是一个很好的值，即当答案实际上是“否”时回答“是”的成本。当假阴性的成本很高时，即当答案实际上是“是”时回答“否”的成本，召回是一个很好的值。

包扎

就像上一篇文章一样，我将涵盖我们在这里学到的新东西，希望能在你的脑海中巩固它们。

**量化模型:**这些是机器学习模型，用数字回答问题，例如 150cm、42 天、20 辆车等。

**定性模型:**这些是机器学习模型，它们用非数字的答案来回答问题，例如“是和不是”、“下雨、下雪或晴天”、“高兴、悲伤、兴奋或生气”等。

**准确性:**模型的准确性描述了模型正确回答问题的频率。

**监督学习:**这是指我们使用已经知道答案的数据来训练模型，以便我们可以在训练中指导模型。

**精度:**模型的精度描述了有多少模型的“是”答案实际上是正确的。

**召回:**模型的召回描述了模型得到了多少应该是“是”的答案。

最后两个可能需要一些时间让你理解，所以我建议你先做几个例子，直到你理解为止。

我还想介绍更多的内容，但那要等到下一篇文章了。感谢阅读！

如果你喜欢这篇文章和它的格式，你可能想看看我的系列…

[## 一系列简单的指南

“一系列简单指南”正是它所说的。

medium.com](https://medium.com/series/a-series-of-simple-guides-db0328a443f6)

更多的钱，更多的问题:分析 PAC 资金对美国国会的影响

原文：https://towardsdatascience.com/more-money-more-problems-analyzing-the-effects-of-pac-money-on-u-s-congress-74843bef12a8?source=collection_archive---------9-----------------------

总结

2010 年，美国最高法院裁定，宪法不能禁止公司和工会宣传一名候选人胜于另一名候选人，这实际上解除了对竞选资金的管制。公民联盟诉联邦选举委员会案中的这一决定备受争议，不得人心；80%接受民意调查的美国人反对这项裁决。公民联盟的结果和 2014 年麦卡琴诉联邦选举委员会案的裁决导致了美国目前的状况，越来越多的资金涌入国会选举。2018 年中期选举的预计总成本 近 52 亿美元，成为有史以来最昂贵的 。

这种情况激发了一个项目，在这个项目中，我使用自然语言处理和机器学习技术对美国国会现任成员的推文主题进行建模，然后分析他们收到的 PAC(政治行动委员会)资金数额如何影响他们的推文内容。我发现，国会议员从政治行动委员会获得的竞选资金越多，他们就越不可能在推特上谈论有争议的政治问题。下面这篇博客文章介绍了这一努力的背景，提供了该项目的概述，并指出了选民可以用来在 11 月 6 日投票日之前了解现任国会议员的资源。

快速事实

即将到来的中期选举预计总成本为 52 亿美元。
2018 年，一小部分美国人(0.42%)贡献了大部分竞选捐款(70.8%)。
2015 年，76%的美国人认为金钱对政治的影响比以前更大。
国会议员花 50%的时间筹款。
盖洛普民意调查显示，美国人目前认为美国面临的最重要的问题是对政府的不满和糟糕的领导。

重点项目调查结果

在最后一次竞选活动中，美国参议员平均从政治行动委员会获得 250 万美元。
在 2018 年中期选举中，美国众议院的普通成员从政治行动委员会手中接管了$600,000⁴。
从 2007 年开始，Congress⁵的现有成员已经发了超过 180 万条 times⁶微博。
在最近的竞选活动中，推特上没有政治争议的国会议员平均从政治行动委员会多拿了 8 万美元。

项目链接

GitHub 库
互动地图显示 PAC 在 2018 年中期选举活动期间对众议院现任议员的贡献

推特上的国会

鉴于越来越多的钱被用于政治竞选，以及美国人对金钱在政治中的影响力的担忧，国会不受欢迎也就不足为奇了；只有 21%的美国人赞同国会正在做的工作。国会议员有什么要为自己辩护的？他们越来越多地使用 twitter 与他们的基地直接沟通。参议员卡玛拉·哈里斯、马尔科·卢比奥和伊丽莎白·沃伦每个人在推特上都有数百万粉丝，并且已经发了数千次推特。像许多其他国会议员一样，他们使用自己的 Twitter 账户作为媒介来展示自己的个性和政策立场。

社交媒体在阿拉伯之春和黑人的命也是命的跟风运动中所扮演的角色，提供了大量证据，证明社交媒体上的政治话语具有真实的、切实的影响。此外，越来越多的学术界关注美国政客的推文。这些努力包括分析州政府成员在推特上的政策议程；国会在推特上做什么；以及政治家讨论的话题和其追随者讨论的话题之间的关系。这些努力为我的分析提供了部分信息和灵感。

分析国会的推文

为了开始这项工作，我使用 Jefferson Henrique 的 GitHub 知识库“获取旧推文”来收集来自第 115 届国会所有活跃成员的官方推特账户⁷的所有推文。Henrique 用 Python 编写了“获取旧推文”项目，它使我能够绕过 Twitter API 的一些限制。我总共从第 115 届国会的 522 名议员那里收集了超过 180 万条推文。⁸ 然后，我使用熊猫进行探索性数据分析并清理数据，采取的措施包括调查国会议员的推文数量以及这些推文的参与度(如转发、点赞)，并删除太短而没有太多意义的推文。

(The Tweet in the Dataset with the Most Likes and Retweets)

下图显示了各州和高音喇叭所属党派的数据概况。圆圈的大小反映了推文的数量，颜色代表了推文者的政党。圆圈的大小与每个州的人口数量大致相关。例如，加利福尼亚州、纽约州和得克萨斯州的国会议员的推文数量相对较多。然而，这种相关性也有例外。佛蒙特州参议员伯尼·桑德斯发送了相对较多的推文，因此他的家乡被过度代表。

在清理和探索数据之后，我使用一个名为自然语言工具包的 Python 库对数据进行了预处理。我对文本进行预处理的步骤包括删除标点符号和格式(例如，单词的首字母大写)，对每条推文进行标记(即，将每条推文的文本分成单个单词的列表)，删除停用词(即，像这样的单词，这些和只有出现频率高，语义意义不大)，以及词干。此外，我使用自定义函数来删除链接、标签和提及。

(Example Tweets Before and After Preprocessing)

在对 Tweets 执行主题建模之前的最后一步是转换预处理文本语料库的形状。为此，我使用了 scikit-learn 的计数矢量器，它输出一个矩阵，其列对应于文本语料库中的唯一单词，其行对应于每个单独的 Tweet。这个过程可以将每条推文与整组推文进行比较。然后我转置了矩阵，使其成为术语文档格式，并为主题建模做好了准备。

主题建模是一种机器学习/自然语言处理方法，它依赖于统计手段，基于文档和语料库级别的单词出现频率，从文本中获取含义。有多种方法对文本的主题进行建模，包括机器学习的监督和非监督方法。

为了对国会推文的主题进行建模，我使用了一个名为 gensim 的 Python 包来执行潜在的狄利克雷分配(LDA)。LDA 是一种无监督学习方法，由大卫·比尔、安德鲁·乔丹和吴恩达(前谷歌员工，现任百度首席科学家)创建。 **LDA 是一种生成概率模型，其假设文本语料库可以由给定数量的主题来表示，并且其中的每个文档可以由全部主题的子集来表示。**LDA 识别的主题由大量在文档中频繁出现的单词表示(在本例中为 Tweet)。

在我上面提到的努力中，LDA 是为美国政治官员的推文主题建模的首选方法。Gensim 的 LDA 允许轻松调整模型超参数，包括它应该从文本中提取的主题数量以及模型应该对文本进行学习的次数。国会推文最明智的表现包括 50 个主题，我调整了模型，对文本进行了 20 遍学习；训练时间大约花了八个小时。然后，为了便于解释，我缩写了每个主题的原始组成词。

(View the full list of topics in this GitHub repository)

介绍活动财务信息

接下来，我从响应政治中心(Center for Responsive Politics)的网站opensecrets.org上收集了竞选财务数据，该网站被描述为**“联邦竞选捐款、游说数据和分析的最全面资源。”**响应政治中心(Center for Responsive Politics)的数据来自联邦选举委员会(Federal Election Commission)，我使用公开秘密应用编程接口(Open Secrets API)收集了所有现任国会议员的竞选财务信息，并观察了他们在推特上谈论的话题如何随着他们在上次竞选活动中接受了多少 PAC 资金而变化。

最初，我把分析的重点放在相关主题和部门之间的关系上。我的假设是，某个国会议员从某个部门拿走的越多，他们就越会(或者可能更少)在推特上谈论它。然而，这种类型的分析证明是不确定的，因为没有出现明确的趋势。

但是当我看着从政治行动委员会拿钱最多和最少的国会议员时，我注意到一些有趣的事情。例如，参议员 Pat Toomey、Rob Portman 和 Tim Scott 在他们最近的竞选中分别从政治行动委员会获得了近 600 万美元，他们推特上最常见的话题完全没有政治争议。

(Common Topics Include Meetings, Receiving Honors, and Congress itself)

另一方面，在上次选举中没有从政治行动委员会拿任何钱的国会议员的推文的主题表明了明显的差异。虽然这两个群体之间最常见的话题有所重叠，但众议员 Jared Polis、John Sarbanes 和 Francis Rooney 更多地在推特上谈论政治上有争议的问题。他们在推特上最常谈论的话题是医疗保健、罗伯特·穆勒的特别调查和经济。这种实质性的话题在前一组中是缺乏的。****

我进一步探究了这种关系，发现不幸的是，这些国会议员代表了一种模式。为了得出这个结论，我根据推文是否涉及政治争议话题对推文作者进行了分类，并计算了每个群体成员收到的 PAC 资金的平均金额，我发现国会议员拿的钱越多，他们就越少在推文中谈论政治争议问题。平均而言，在推特上谈论非政治争议话题的国会议员每次竞选都会从政治行动委员会多拿走 8 万美元。我推测这是由于有意识或无意识的努力，使他们看起来更适合他们的捐助者。

结论

这项努力是为了调查政治行动委员会的资金对美国国会的影响。不幸的是，PAC 资金似乎与国会议员谈论(或至少在推特上)重要政治问题的倾向负相关，这些问题对他们的选民最重要。

这一结论加入了声称我们的当选官员过于依赖竞选捐款的声音。例如，剑桥大学的一项分析“表明代表商业利益的经济精英和有组织的团体对美国政府政策有实质性的独立影响，而普通公民和基于大众的利益团体则很少或没有独立影响。”此外，最近的媒体报道都集中在那些公开拒绝接受 PAC 资金的国会候选人身上。

11 月 6 日是中期选举，还有两天就要举行了，美国人能够影响国会言行的一个可靠方法是批判性地思考对他们来说重要的问题，并投票给那些不依赖政治行动委员会捐赠者，而是关心美国人民的候选人。

后记

非常感谢 Jefferson Henrique，他写了一个如此优秀、强大的仓库来获取旧推文。没有他，这一努力是不可能的。

虽然我在分析中关注的是政治行动委员会的捐款，但我并不是说个人竞选捐款不重要。在这次中期选举周期中，个人捐款超过 16 亿美元。

作为这项工作的补充，我创建了一个互动地图，显示了众议院每位现任议员在 2018 年中期选举前的竞选活动中收到的 PAC 资金数额。

(Link to Interactive Map)

脚注

这个总数包括政治行动委员会和个人直接捐赠给国会竞选活动的资金，以及支持候选人但与候选人无关的支出。
政治上有争议的话题在这里被定义为有共同的，也许是党派的政治分歧。有争议的话题包括“人权”和“共和党废除奥巴马医改”没有政治争议的话题包括“竞选途中的停留”和“参观景点”。
考虑的竞选周期包括 2014 年、2016 年和 2018 年结束的竞选周期——取决于参议院的级别。美国参议员任期 6 年，其中三分之一每两年开始
竞选资金总额截至 2018 年 10 月；最终数字可能会更高。
由于辞职，死亡，特别选举和其他情有可原的情况，第 115 届国会的完整名单是一个移动的目标。在可能的情况下，我使用最新的在职人员名单。
推文总数截至 2018 年 9 月。
在可能的情况下，我使用国会议员的官方推特账户。一些国会议员(如伯尼·桑德斯、科里·布克)有多个 Twitter 账户。
并非所有国会议员都发了推特。

作者联系信息

如果你想谈论数据科学或政治，请在 LinkedIn上添加我，或者在 edmunchitwood@gmail.com 给我发电子邮件。

不仅仅是算法——在工业中建立模型

原文：https://towardsdatascience.com/more-than-algorithms-building-models-in-industry-109badf5318a?source=collection_archive---------13-----------------------

本文原载于【blog.zakjost.com】

由于数据科学博客圈几乎完全专注于机器学习算法的本质细节，你会被原谅认为这是作为一名 ML 从业者最重要的方面。但是那些在行业中建立模型来解决实际商业问题的人知道这只是工作的一小部分。学术人员可能在本地构建模型，并根据基准数据对其进行评估，以获得可发布的结果，而工业界的人员正在将模型集成到一个更大的系统中，这有很多失败的机会。这篇文章是关于在这种环境下你需要做的其他重要的事情。

垃圾进，垃圾出

在工业界，当有人问一个模型表现如何时，得到的回答往往是:让我做一些分析。如果这是您的情况，您将面临不必要痛苦的风险。

有一天，一些人将审查业务度量，并且不可避免地发现一个主要问题。他们会说，“你的模型说所有这些东西都是 X，但实际上它们是 y。这没有任何意义，而且每天要花费我们数十亿美元！”

当事实证明基于某个模型的决策是糟糕的时，就会引出几个明显的问题:我的模型坏了吗？我的数据管道坏了吗？我建模的东西变了吗？回答这些问题应该不比看仪表盘难。这给我们带来了重要的事情 1。

重要的事情 1:除非你有实时的性能监控，否则你还没有完成

(“实时”的定义将取决于您的业务问题，并受到标签成熟度的限制)。这听起来可能真的很难，但是除非你在一个有极端数据孤岛的组织中，否则你可以在几个小时内构建一些东西。你只需要:

访问模型分数和标签
可以运行 cron 作业的机器
一台可以托管仪表板堆栈的机器，如Grafana+influx db

使用 Docker 图像，我在大约 3 个小时内构建了整个堆栈，尽管以前从未使用过这些工具。即使您是唯一可以访问它的人，这个练习仍然值得您花费时间，因为这是一项时间投资，当出现问题时，它会在早期向您提供可操作的信号。您不仅能够更快地排除故障，而且通过观察模型的时间行为，您将对模型有更多的了解。

结果可能是你的模型是好的，但是进入你的模型的数据才是问题所在。好消息:这也很容易测量，你只需将其连接到你的新仪表板解决方案。一旦有了用于性能监控的监控仪表板/数据库设置，添加这样的新视图就变得容易多了。这是重要的事情。

重要的事情 2:监控你的模型输入和输出

太好了！您可以监控模型的输入、输出和性能。现在你可以在东西坏了的时候检查它！或者每隔一分钟检查一次，确保一切正常。*对吗？*错了。

重要的事情 3:在你的显示器上设置闹钟

如果你费了很大的劲来构建将所有重要指标放在一个地方的东西，为什么不构建一些简单的规则来在事情变得不可靠时提醒你呢？得到一个关于你的一个重要输入变量突然丢失的警报，远比从这个问题给企业带来的所有痛苦中间接地发现它要好得多。警报将允许您联系企业并说，“注意:有丢失的数据，它导致我的模型行为怪异，这将导致错误的决策和数十亿美元的损失，所以让我们暂停事情，直到数据问题得到解决。我已经将此事上报给负责数据的团队。”

保持新鲜

由于各种原因，模型几乎总是随着时间而退化。最终，您可能会希望使用最新的数据来重新训练您的模型。既然你有一个奇特的仪表板可视化性能，至少这应该是预期和计划的，而不是对紧急问题的反应。但是有一个更好的方法，这是下一个重要的事情。

重要的事情 4:自动化模型再训练和部署

这不仅使你的模型保持新鲜和高性能，而且这是一项应该在年内获得回报的投资，即使在你离开团队之后。

它如何节省您的时间？因为技术债务会引发更多的技术债务。当一个团队在运营痛苦中溺水时，他们倾向于反动，去扑灭紧急的大火。这意味着他们可能不知道模型降级了，直到它引起了问题，然后他们尽可能快地修复这个问题。而“尽快”这一部分导致了额外的技术债务。

与自动刷新的模型形成对比。如果您从一开始就知道这是一个需求，那么您会做出设计决策，并在整个过程中支持它。因此，与其用一个大的 Jupyter 笔记本从您的笔记本电脑中取出一个 csv 文件，然后吐出一个模型工件，您可以用一些黑魔法将其部署到生产中，不如将您的数据提取过程从您的模型构建过程中模块化，并自动跟踪和部署模型。有了这一点，模型再培训项目从几周/几个月变成了每天或每周进行，没有人参与。

这是另一个非常强大的原因:人们倾向于从头开始重建，而不是逆向工程。如果您不自动化一个过程来保持模型的新鲜，那么您的工作很可能在您不积极维护它的时候就被丢弃了。如果你的解决方案在你离开后继续增值，你的影响力会被放大。

当我们谈到这个话题时，你可以做最后一件重要的事情，让你的工作不至于很快变得无关紧要:

重要的事情 5:文件，文件，文件

不同的公司有不同的文化规范来保存信息。不管是什么，做好，做好。早点开始，不要让它成为你会回来做的事情之一，因为你可能永远不会回来。撰写正式的白皮书，记录您的设计决策和分析。还要创建一个更容易访问的 wiki 页面，或者其他面向下一个可能需要维护的人的页面。从头开始重建系统的主要原因之一是因为原始系统没有很好的文档记录。

摘要

因此，这里有 5 件重要的事情，它们将使您的工作保持稳健和相关，同时为您节省大量时间，否则这些时间会浪费在不必要的操作消防上:

实时监控您的模型
监控您的模型输入和输出
监视器上的警报
自动化模型再训练和部署
记录你的工作

【blog.zakjost.com】您可以在 找到我所有的内容并订阅

早上，下午，还是晚上？使用数据驱动方法对一周中的时间进行聚类。

原文：https://towardsdatascience.com/morning-afternoon-or-night-clustering-hours-of-the-week-using-a-data-driven-approach-6cb5404d4f3a?source=collection_archive---------2-----------------------

在律师事务所，我们的主要目标是利用我们广告预算的最佳分配，将相关案例导向我们的合作律师事务所。数据科学团队通过优化我们的 Adwords 竞价，在不超出预算的情况下最大限度地增加我们收到的查询数量，从而为这项任务做出了贡献。在这篇文章中，我将简要介绍这个问题，并详细讨论解决方案的一部分:为什么我们使用历史数据对一天/一周的时间进行聚类。

数据科学团队的中心项目之一是构建最佳模型，以预测广告支出作为出价的函数。出价是我们在这个模型中可以控制的最重要的自变量之一。出价定得太高，我们会很快花光我们的月度预算，错过本月晚些时候的潜在商机。出价定得太低，我们的广告可能无法充分展示，从而无法获得足够多的询盘发送给我们的合作伙伴公司。

当设置出价，我们这样做在每周每小时的水平。因此，在构建模型时，模型中将有额外的 168 个分类变量来解释一周中的每个小时。由于多种原因，这是不希望的。在一个模型中有这么多的变量使得它更难解释。在一个模型中有这么多分类变量意味着训练的设计矩阵将有大量的零，这些零必须用于计算。此外，每个类别中必须有足够的数据来训练和验证模型。当我在 USF 大学学习时，我有一位教授，他在建立回归模型时更喜欢“简约”而不是复杂。在这一点上，让我们讨论一下 Lawfty 的数据科学团队为降低我们的投标模型的复杂性所采取的方法。

我将首先概述我们用来训练和验证模型的数据格式。然后我将讨论我们如何使用 KMeans 聚类算法来减少我们在模型中使用的分类变量的数量。作为这篇文章的总结，我将展示一些聚类前后的标准化数据图，以直观地说明为什么这样做。

我们训练模型的主要数字特征是成本、点击和印象。数据的粒度是每小时一次。我们获取这些原始数据，并使用公式day _ of _ week * 24+hour _ of _ day为一周中的 168 个小时之一添加一个标签。现在把时间组合在一起，为什么不按照“早上”、“下午”、“晚上”来组合呢？这似乎是一个自然的分组，但是基于的分析，我们知道一周中的某些时间在成本、点击和印象方面有相似的行为。因此，我们使用 KMeans 聚类算法来寻找将一周中的小时分组的最佳方式，这样我们就可以将分类变量的数量从 168 减少到更小的数字 k 。注意，为了确定聚类数 k ，我们对照实际发生的每周成本交叉验证一组 k 值的每周预测成本，并选择给出最小平均绝对误差的 k 。我们使用这种方法，而不是理论方法，如肘和差距，因为这为我们提供了一种更加以业务为中心的方法来衡量模型的成功。

现在，我们已经介绍了如何使用 KMeans 通过对一周中表现相似的时间进行分组来减少模型中的分类变量的数量，让我们来看看这种方法的一些实际应用，以直观地了解正在发生的事情。

考虑以下情节。

这是我们按一周中的小时汇总的数字数据，总共 168 个数据点。使用上面提到的方法，我们发现对于这个特定的市场，12 个聚类给出了最小的平均绝对预测成本误差。

现在，一周中的每一个小时都有潜在的周期性。可以说，它们是环绕的。周日中午 12 点和周六晚上 11 点“接近”。因此，假设我们也在单位圆中加入一周中的小时的映射。参见本或本帖子。结果给了我们下面的情节。

我们可以看到，一周中有几个小时的成本较高，同样，一周中有几个小时的成本较低。用 z 轴上的点击和印象产生类似的图给出类似的结果。一周中有几个小时的行为与其他时间不同。这就是我们希望通过时间的聚类来捕捉的内容。

现在我们有了小时的聚类，然后我们可以使用这些小时聚类作为模型中的分类变量来生成回归模型。我们已经将特征空间的维度从 167+(一周中的小时加上包括的任何其他数字/分类特征)减少到 3+(小时聚类标签和其他特征)。这为我们提供了更强大的模型，因为当聚合到 3 个小时的聚类时，我们现在有了更多的数据点，而不是将一周中的每个小时都放在自己的类别中。

目前，我们仍在运行基于上述基于容量的指标的算法。但是，我们进行的分析让我们相信，添加更多基于价值的指标。当我们实现了这些新的添加时，请继续关注更新的帖子。

与此同时，请随时在脸书、 LinkedIn 和我们的主页上找到我们。

Lawfty 开发技术，将律师和律师事务所的数字广告变成一门科学。使用搜索引擎营销和社交媒体，我们的技术平台为下一代成功的人身伤害和大规模侵权律师铺平了道路。

镶嵌图和卡方检验

原文：https://towardsdatascience.com/mosaic-plot-and-chi-square-test-c41b1a527ce4?source=collection_archive---------8-----------------------

在数据科学项目中，从数据中获得更多见解非常重要。有一个特定的阶段，即项目的第一个阶段，以数据分析为目标:数据探索阶段。在其他种类的分析中，最有趣的是双变量分析，它找出两个变量之间的关系。如果这两个变量是分类，那么用于分析它们之间关系的最常见的图是镶嵌图。乍一看，它可能会显得有点混乱。不了解一些统计概念的人可能会错过这个图能给我们的重要信息。因此，在这篇文章中，我们将会更深入地探讨这些概念。

马赛克图

本帖中使用的数据集可以从这里下载。每一行都是在汉堡店完成的交易。正在分析的两个变量如下:

SELL_CATEGORY :分类变量，标识所售产品的类别。类别“0”标识单一产品；类别“2”标识组合的
COKE :一个分类变量，标识销售的组合产品中是否存在 COKE。因此值“1”标识焦炭的存在；“0”表示缺席

以下简单的 R 代码将为变量 SELL_CATEGORY 和 COKE 生成镶嵌图。打开 RStudio (或 R Tools for Visual Studio )并运行它:

下面是由此产生的情节:

fig. 1 — Mosaic plot for SELL_CATEGORY vs COKE

镶嵌图基于条件概率。为了得到前面图背后的数字，需要一个列联表。它也被称为交叉表或双向表，用于总结几个分类变量之间的关系。只需运行下面的代码来获取我们案例的列联表:

结果就是这张漂亮的桌子:

fig. 2 — Contingency table for SELL_CATEGORY vs COKE

镶嵌图从行开始递归计算边际比例。在我们的例子中，我们从销售类别开始。单元的宽度分别与单一产品和组合产品的百分比(焦炭中的总百分比，在图 2 中以深蓝色表示)成比例。事实上,“0”和“2”的 SELL_CATEGORY 的总数是 1355 和 4065(总观察值),所以 25%的产品是单品，75%是组合品。

现在在销售类别中(绿色)，它计算属于每个可乐类别的比例(“0”、“1”)。所以盒子的高度与销售类别中可乐的百分比成正比。事实上，如果卖出类别是“0”，则不包含可乐(COKE =“0”)的交易是 1355；含焦炭(COKE = "1 ")的为 0。因此，对于单一产品，100%的交易不包含可乐，0%的交易包含可乐。相反，如果卖出类别是“2”，1355 交易不包含可乐；2710 交易包含它。因此，对于组合产品，33.3%的交易不包含可乐，其中 66.7%包含可乐。

为了理解颜色是如何分配的，我们需要引入标准化残差，如图 1 中的图例所示。

关于人口的推论

镶嵌图按原样表示数据，并不试图概括全部人口。为了对总体进行推断，我们需要提供统计显著性的度量来证明发现的结果不是偶然的。

皮尔逊标准化残差

关系的强度可以被认为是观察值偏离独立情况下的值的程度(独立=变量之间任何类型关系的完全缺失)。 Pearson 标准化残差测量每个细胞偏离独立性的程度，它们可以计算如下:

其中 O ij 是观察到的频率(在我们的样本中找到的), E ij 是期望的频率( i = i 行； j = j 列列联表)。后者是在独立变量的情况下，我们根据理论概率预测事件将发生的次数。在我们的例子中，独立情况下的期望频率计算如下:

在哪里

E ij =第 i 行/ j 列的预期频率。
T i =第 i 行合计
T j =第 j 列的合计
T tot =表格总计(实验中的项目总数)

更简单的把前面的等式想成*(行合计*列合计)/总计。*皮尔逊残差显示了协会的实力和方向。强度由残差的绝对值给出；通过它的标志来辨别方向。在我们的例子中，皮尔逊标准化残差可以在 R 中计算如下:

单位在标准差中，因此大于 2 或小于-2 的残差代表显著偏离独立性。

现在，回到我们的镶嵌图，我们可以轻松地将标准化残差(下图中以绿色突出显示)映射到像元，记住正号表示蓝色阴影，负号表示红色阴影。

fig. 3 — Mapping of standardized residuals to colors and percent values to sizes of the mosaic plot

蓝色表示单元格中的观察值比零模型(独立性)下的预期值多。红色表示观测值比预期的要少。

换句话说，可以很自信地说，combo 产品(SELL_CATEGORY = 2)将几乎总是包含可乐(COKE = 1)。事实上，不含可乐(可乐= 0)的组合产品(SELL_CATEGORY = 2)与它们之间独立的情况(红色)相比，较少出现在交易中。与此同时，可以肯定地说，单一产品(SELL_CATEGORY = 0)不含可乐。

有关镶嵌图的更多信息，请参考此链接。

在图 2 中可以看到，桌子底部还有其他符号: χ (卡方)、 df (自由度)和 φ (克莱姆氏φ，也称克莱姆氏 V)。让我们看看他们是什么意思。

卡方检验

χ的值由所有标准化残差的总和给出:

该值是所谓的*卡方检验的结果。*它测试样本中的证据是否足够强，足以概括更大人群的关联。卡方独立性检验的 零假设 是两个分类变量在某个总体中是独立的。

在我们的例子中，χ的值是 1804.001。这个数字总结了我们的数据和我们的独立性假设之间的差异。但这意味着什么呢？我们可以从它的采样分布开始了解它的价值。

在某些假设下，我们可以说我们的χ检验统计量遵循χ分布。在这种情况下，我们可以确定χ检验值对应的p-值。为了确定我们分布的确切形状，我们需要自由度 ( df )。一旦我们有了这两个值，就很容易计算相应的p-值，这要感谢这个在线计算器。

一般情况下，p-值由χ检验值后右尾下的面积给出:

fig. 4 — Value of χ² corresponding to a p-value of 0.05

在我们的例子中，图形结果如下:

fig. 5 — The p-value corresponding to χ²=1804.001

说p-值为 0.0000，是指在变量独立(关联强度= 0)的情况下，有 0.0000 的概率偶然发现这个关联。换句话说，似乎 SELL_CATEGORY 和可乐在我们的人群中是相关的。通常，如果p-值< 0.01(有时p-值< 0.05 也被认为具有统计显著性)，我们可以说两个变量是相关的(我们拒绝独立性的零假设)。p-值越低，结果越有意义，因为不太可能是噪声造成的。

有可能有一个对应于弱关联的p-值= 0.0000。如果我们处理大样本，就会发生这种情况。那么，我们如何确定这种关系的强度？我们可以通过效应的大小来测量它。因为在我们的例子中，我们有两个标称变量，所以可以使用克拉默 V (图 2 中的 φ )。对于两个顺序变量，Spearman 相关性或 Kendall 的 tau 是更好的测量方法。对于定量变量，皮尔逊相关是最好的选择。请注意，即使克莱姆的 V 有时用 φ 表示，相同的 φ 也可以用于另一种统计测量(更多细节此处为)。在我们的例子中， *φ = 0.577。*根据这些指南，克莱姆的 V 取 0 到 1 之间的值，所以值 0.577 表示非常好的关联。那么我们确信我们的变量是紧密相关的。

结论

通常，数据探索中使用的图很容易理解。有时他们中很少有人需要了解一些统计学的概念。一旦这些得到澄清，这些图会给每个分析师带来第一眼就很强的洞察力。

数据科学家最基本的技能，以及如何为未来进行教育

原文：https://towardsdatascience.com/most-essential-skills-for-data-scientists-and-how-do-we-educate-for-the-future-adc8a4bca0bb?source=collection_archive---------6-----------------------

昨天我参加了 SJSU 跨学科课程发展的小组讨论(回到学校感觉又回到了家！).最受欢迎的话题是数据科学家最重要的技能是什么，以及教育工作者如何适应行业的快速变化，更好地为未来的劳动力做准备。这是一场非常有见地的讨论，不出所料，虽然许多教师专注于技术能力，如教授哪些编程语言以及涵盖多少深度学习，但行业专家小组在没有任何事先协调的情况下，更多地强调了基础知识(如数学和统计)、领域知识(某一行业的专家)、软技能(沟通和协作)，以及接受反馈、适应、学习、发展和茁壮成长的能力。学校教授的知识和市场需求之间显然存在差距，这导致了一种矛盾的供需不平衡——公司正在努力寻找最优秀的人才，而许多新毕业生无法找到第一份技术工作。那么，我们如何才能缩小差距呢？(另一方面，缩小差距将意味着更多合格的供应，并可能减少对自己的需求，但我认为从长远来看，这将更好，并迫使我走出舒适区，为明天的更好生存发展——就像 达拉·科斯罗萨西说的 :让我们自相残杀(在我们的竞争对手自相残杀之前)。

学术界和工业界之间的这种脱节在工程领域显然没有那么严重。各大 techs 频繁组织校园招聘活动；问题被更清晰地定义和约束(前端/后端开发、数据仓库、分布式系统等)。)进行课程开发。具有血统技术能力的应届毕业生从一开始就可以非常成功。相反，数据科学的范围非常广泛，不同行业在不同阶段的要求也有很大差异——早期公司可能需要开发人员/数据工程师的混合来启动业务，而大型公司可能更喜欢统计人员/实验人员来获取见解并推动产品开发。自动驾驶等专注于利基市场的公司寻求信号/图像处理和高级机器学习方面的专家，而运营密集型公司希望获得预测和优化专家。任何两个数据科学家角色，即使是在同一机构内，也可能非常不同，这使得开发一个包含所有这些主题并具有足够深度的课程非常具有挑战性。更不用说领域知识了，与在线市场的数据科学家相比，医疗保健领域的数据科学家面临着完全不同的挑战。啊！

更糟糕的是，数据科学被视为一个有利可图的职业，许多训练营让它看起来很容易开始(不要怀疑所有训练营，其中一些，特别是声誉良好的 MOOCs，确实极大地帮助了人们学习和开始新的职业生涯，特别是在少数族裔和代表性不足的群体中)。去年，我参加了几次 1 小时的会议，在会上，讲师会简单地展示用 python 构建深度学习模型是多么容易，只需在 Jupyter 笔记本上写几行字就可以对猫和狗进行分类。激发热情是非常容易的，有些人可能会进一步投资几个月的项目，有时用所有的积蓄甚至贷款，却发现他们后来仍然无法找到工作-技术发展使数据科学民主化，使其比以往任何时候都更容易获得，但也出人意料地将具有基础知识和丰富经验的专家从单调乏味的工作中解放出来，使他们能够在该领域中探索得更远更深，使他们比市场上快速培训的更同质的群体更有价值。此外，技术堆栈发展迅速；仅仅精通某个特定的库是一种有有效期的技能；也许很快谷歌的 AutoML 将起飞，使所有的超级参数调整专业知识变得一文不值。

所以，作为教育者和学生，谁愿意投资到这个行业，游戏计划是什么？也让我思考——我应该怎么做才能保持相关性和竞争力？以下是几点想法。

关注基本面。在一支篮球队中，那些持续时间很长的人是那些基础扎实的人——不是令人瞠目结舌的扣篮或狡猾的传球，而是跳投、步法和无懈可击的传球。对于数据科学，它是数学和统计学，以及对编程、数据结构等的基本理解。虽然现在运行一个 ML 模型可能只需要一行代码，但是理解它在幕后是如何工作的不仅会在事情不工作时给你提供直觉，还会帮助你选择最佳的分析策略，甚至开发新的方法。技术的前沿每天都会遇到新的挑战，只知道进口 sklearn 或图书馆(caret) 不会让你走得很远。无论如何，从书上而不是从网上视频中学习，用传统的方式手工计算。随着不愿意走捷径的人越来越少，对基金会的这种投资变得前所未有的重要。对于教育工作者来说，应该更多地关注数学、统计和概率，而不是机器学习 101，这可以通过使用大量免费的在线资源进行自学。至于编程和数据结构，你可能不需要每天实现一个新的算法，但你应该知道更多关于 Array.sort 的知识，而不是简单地调用函数。
成为专家，然后成为多面手。我曾与之共事并钦佩的超级明星数据科学家都是领域专家——物理、数学、经济、金融、政治科学、医疗保健，应有尽有。他们通过训练确实很擅长自己所做的事情，能够非常迅速地吸收看似不相关的新知识。我还有很长的路要走，但是我已经在不同的领域中跳跃，这些年来我开始意识到许多问题，当从上下文中抽象出来时，本质上是非常相似的。此外，应用于不同领域的方法通常是相似的，尽管名称不同。因此，一旦你成为某个领域的专家，并建立了一个坚实的知识框架，将所学知识转移到一个全新的领域并不困难(仍然需要付出很多努力)，这种转移可以继续下去，知识覆盖面将成倍增长。为了到达那里，你需要一个非常非常坚实的根来长成一棵树，这远远超出了几个月的工作。我也很喜欢智力运动员这个称呼:很多职业运动员真的可以擅长多项运动。最牛逼的数据科学家可以应对任何挑战；他们是快速的学习者，善于将不熟悉的挑战映射到他们的专业领域，然后轻松解决。对于教育工作者或新生来说，在学习了 DS/ML 中的一般概念后，你需要找到一个重点领域并全力以赴。深度优先。
软技能和人文素质。沟通、判断、优先排序、协作—所有这些软技能对于数据科学家的成功至关重要。与工程师不同，数据科学家经常在职能交叉的团队中工作，他们需要以各种方式与各种利益相关者沟通。有一个臭名昭著的面试问题——*解释 p 值背后的数学，然后向工程师、设计师、产品经理解释，你能向一个 3 岁的孩子解释吗？*在课堂环境中教授软技能很难，但一位教授提出了一个非常好的观点——通常学生只需要在学期结束时向一位听众(教授)写一份报告，但我们可以将来自不同背景的学生聚集在一起，让他们练习不同层次的沟通。对于任何分析，你都可以在家里练习:我能向技术观众、半技术人员和高中生解释吗？另一方面，许多这样的问题没有最佳答案，通常这是艺术而不是科学的选择。人文学科在科学和工程课程中一直被忽视，对于数据科学来说，人文学科可能是非常重要的一部分。是时候让他们回来了！
**解决问题训练。**归根结底，最好的数据科学家是最好的问题解决者。解决一个结构良好的问题很容易(我应该如何建立一个模型？)，提出问题很难(为什么要建立模型？)你可以很容易地获得针对第一类问题的培训，比如向你提出问题的 Kaggle，但针对后一种挑战的培训没有多少好地方，后者需要大量的自我启动。一个简单的思维练习，就是偶尔挑一个题目，试着想出一个解决方案。例如，当你在网上冲浪或浏览应用程序时，你可能会问自己一个问题:如果我想改进网站/应用程序 Y 中的功能 X，我应该收集什么数据，我应该监控什么指标，如何建立一个模型来预测/分类，以及我应该如何设计一个实验来衡量成功？有哪些权衡？这类似于健身房的例行公事，即使你在健身房，你也可以一天做几次。我发现它非常有用，让我对这个世界更加好奇，当它不可避免地变老时，让我的思维保持活跃。

最后，也是最重要的(许多人都同意)，你必须对数据科学和业务充满热情。你必须完全买入并投资。这是一个快速变化的领域，你必须不断适应和改进。你必须接受不确定性，这是数据科学家应该享受的。

附:这是我的上一篇文章的后续。随着我的学习，我可能会再次更新。

你读到的关于增加 Instagram 受众的大部分内容要么不相关，要么不够

原文：https://towardsdatascience.com/most-of-what-you-read-about-growing-an-instagram-audience-is-either-irrelevant-or-not-enough-53e597654155?source=collection_archive---------8-----------------------

“帖子始终如一。使用标签。加入一个约定舱。冲洗。重复。”

这基本上就是咒语，对吧？我在互联网上阅读或观看的每一篇博文、YouTube 视频或在线课程，要么是同时谈论所有这些事情，要么是非常垂直地谈论其中一个(类似于:“2018 年 Instagram 标签权威指南”)。

我决定用数据分析来检验它们的有效性。

我用我公司的 Instagram 账户[**@uniwhere**](https://www.instagram.com/uniwhere)和我自己的 Instagram 账户[**@giansegato**](https://www.instagram.com/giansegato)有条不紊地遵守了这些规则。Uniwhere 是一款面向大学生的 app，所以社区建设对我们来说是关键。
以下分析仅基于 Uniwhere 的账户。

我在过程中改变了活动——比如停止做某件事，同时引入另一件事；这样，我就有了进行比较分析所需的必要程度的变化。

然后，我将一个 Python 笔记本连接到 Instagram Graph APIs 和我们自己的数据库，并试图得出一些结论。

TL；DR 版本:帖子一致性、标签曝光率和参与度与追随者增长完全不相关。你可以从中受益，但不是在受众发展方面。

让我们来看看细节。

数据

首先，我想指出我能够分析哪种数据。这是我最后的数据框架:

如你所见，我有一组标准化的指标，这些指标要么直接来自 Instagram，要么来自我们自己的内部 ETL 系统。
每行代表一天，从 2018 年 1 月 1 日开始，到 2018 年 6 月 10 日结束。

为了便于分析，我将数据分为三类:

行动

这些是跟踪为发展客户而采取的明确行动的指标:

did_post:是否在某一天我们贴了一张照片；它也有一个滞后版本，consistency:一个尾随值，代表当天之前一周的帖子一致性程度。
vgm:那一天，帖子后面有没有用交战吊舱推过。
参与豆荚推动特定图片的参与度飙升(数百个赞)，通常它们会让你的照片出现在标签的top post部分。他们的工作非常简单:有一群人在某个约定的时间互相喜欢对方的照片。所以，大量的参与和潜在的曝光。
这个特性也有一个滞后变量，vgm_effect:同样，一个 5 天的拖尾值，以考虑到在推送后的几天内接合荚有一个转移效应的可能性。
engagement:在某一天，我们对相关图片的喜爱程度，使用我们在平台上找到的用户标签。另一个常见但耗时的活动是:你试图在一系列与你的喜好相关的图片中发现有趣的图片，并且你喜欢它们；希望有喜欢的人访问你的个人资料，喜欢它，并关注你。

达到目的的手段

这些是间接结果:

profile_views:一天内有多少用户访问了账户页面
reach:有多少独立用户以任何方式接触到我们的页面
在给定的一天内，我们的一张照片被浏览了多少次

小剧透:impressions 和 reach 是完全相关的(1.0)，所以我们有可能将这两个术语作为同义词使用，尽管它们意味着两个不同的东西。

目标

最后，我们感兴趣的真正的、最终的KPI:

followers_count:某一天我们有多少新用户
website_clicks:我们在账户页面上展示的网站链接被点击了多少次

最后，它看起来像这样:

好吧，没那么有用，我懂了。

Divide et imper:在拼凑出全貌之前，让我们先考虑一些小的比较。

后期一致性

以我的愚见，我认为“持续发帖并获得新追随者”这一永恒的大法则非常具有误导性。坚持发帖子有用吗？嗯，不疼。对于你的 现有的 观众来说肯定很关键。但是，看看确凿的证据，很难说它有助于 增长它 。
让我们来看看这个情节:

红色竖线表示我们发布图片的日期(did_post = 1)。黑色的竖线表示我们不仅发布了一张图片，还使用了一个参与 pod ( vgm = 1)来推送它。

看起来这两件事之间没有任何规律可言。然而，很难从这幅图像中推断出一些有趣的东西，除了非常清楚的“接合吊舱无助于”(这仍然非常有趣)。

让我们绘制相同的数据，但这次使用后一致性(我提醒你，这是一个移动窗口总和，因此可以绘制为一条连续的线):

正如你在 3 月和 4 月之间看到的(红色区域)，关注者增长和帖子一致性之间似乎有一个有趣的关联:我发的越多(蓝线)，我的关注者就越多(绿线)。

然而，后来，在 4 月和 5 月之间(黑色区域)，新追随者的增长停滞不前，而一致性却创下新高。所以… 看起来发帖越多，或者越持续，越不会直接影响追随者的成长，使用互动豆荚也不会。

行动 2:成为热门帖子的趋势

有时候，我们的页面已经成为大量标签流的趋势。我们有一些照片登上了 2000 万左右的热门帖子。然而，它并没有给我们带来多少参与，而且，可能更糟糕的是，因为它，基本上没有新的追随者。

看看下面的情节。它显示了印象数和关注数之间的关系。

正如你所看到的，一般来说，它们都朝同一个方向移动(我猜)。然而，你完全可以在没有印象的情况下获得观众增长(两个红色区域)，也可以在没有增长的情况下获得良好的印象(黑色区域)。

所以… 没有。你的照片经常被人看到与粉丝的增长没有太大关系。

行动 3:疯狂地四处活动

我就给你看这个。

参与度的新关注者(小提示:engagement定义为一个介于 0 和 1 之间的参数，用于量化平台中其他用户的点赞会话强度——我们在某一天与其他用户互动的次数):

网站点击参与度:

参与的个人资料视图:

轰。订婚。
差不多就是这样。

当你使用正确的标签喜欢周围的图片时，你的个人资料浏览量会上升，因此你的关注者数量也会随着网站点击量的增加而增加。

这是唯一一个一直被证明是成功增加 Instagram 受众的策略。

我们能不能别绕圈子了？

现在我们来看看数据帧相关矩阵，它基本上是我可能向您展示的每一个可能的图的总结:

这张照片非常有趣。我需要一些来自不同账户和不同领域的信息，以便进行真正的概括，但据我所知，这是一张关于 2018 年 Instagram 游戏如何运作的非常生动的图片。
换句话说，你可能想到的每一个可能的策略都应该包含在这里，至少从相关性的角度来看是这样的。

我最感兴趣的是这个紫色的小家伙:

vgm_effect 与无关。就像，真的，任何事。这几乎与profile_views无关，这是显而易见的，因为你的订婚豆荚中的那些人实际上必须访问你的个人资料才能喜欢你的上一张照片。
did_post与impressions和reach密切相关，这也是显而易见的:当你发帖时，你留下了印象，当你不发帖时，你就没有了印象。但是和follower_count没有关联的迹象。
而follower_count则与engagement和profile_views高度相关，与website_clicks略有相关。正如我们在之前的情节中已经看到的，投入时间喜欢周围的图片是真正吸引新粉丝的唯一方法:你喜欢图片，因此你的个人资料会被浏览，人们会接触到你的图库，然后他们会决定是否值得关注你。在决定是否关注你的过程中，他们可能会访问你的网站。
公平地说，在profile_views和impressions之间存在某种形式的关联。然而，我怀疑那些在印象高峰之后出现的部分个人资料视图(因此伴随着did_post)是你自己的追随者因为你发布了一些东西而访问你的页面。因此，没有新的追随者，但现有的观众参与。

外卖(即。我从这里学到了什么)

最后，我认为这里要提出的主要观点如下:

1。只为你在现有的受众发帖:不要指望你的帖子会吸引更多的关注者；即使他们在网上疯传也不行

2。使用互动平台只是为了增加你对照片的喜欢，并有一些社会证明:不要指望互动平台是增加你的观众的魔杖

3。喜欢，喜欢，喜欢，喜欢。
冲洗干净。
重复。

追踪

如果你喜欢这篇文章，我会非常感激你给我一个掌声:这是我第一次写这种东西，我想知道人们是否对此感兴趣。
如果你想得到这篇文章更新的通知，或者关于创业、成长和数据科学的新文章，你可以订阅我的时事通讯:
如果您对本文有任何意见、问题或批评，请告诉我！

最后一个音符

为什么不考虑后续跟进策略(我四处跟踪人们，希望他们中的一部分人也能跟踪我)？嗯:我从来没有做过，所以我没有关于这种策略的数据。

我相信它在短期内非常成功，但我讨厌它，主要是因为它传达了一个非常明确的绝望信息，而且你无法扩大它:要么你保留你建立的每个联系，因此 a .你很快就达到了 7500 的限制，b .你看起来真的超级绝望，要么你不时地随机取消关注你的一些粉丝，这是非常不诚实的事情，依我看。所以，没有，没有相关数据。

使用面部动作控制鼠标光标——一个人机交互应用程序

原文：https://towardsdatascience.com/mouse-control-facial-movements-hci-app-c16b0494a971?source=collection_archive---------3-----------------------

这个用 Python(3.6)编写的 HCI(人机交互)应用程序可以让你通过面部动作控制鼠标光标，只需普通的网络摄像头就能工作。它是免提的，不需要可穿戴的硬件或传感器。

特别感谢阿德里安·罗斯布鲁克令人惊叹的博客帖子【2】【3】、代码片段和他的 imutils 库【7】，它们在实现我的想法中发挥了重要作用。

工作示例

使用

现在，我完全理解这些面部动作做起来可能有点奇怪，尤其是当你在人群中的时候。作为一名良性位置性眩晕的患者，我讨厌自己做这些动作。但我希望随着时间的推移，它们会变得更容易，不那么怪异。请随意建议一些我可以纳入该项目的公共友好行动。

密码

您可以在以下位置找到代码文件:

[## ACL 21/Mouse _ Cursor _ Control _ 免提

Python(3.6)中的这个 HCI(人机交互)应用程序将允许你用你的…

github.com](https://github.com/acl21/Mouse_Cursor_Control_Handsfree)

使用的库

Numpy — 1.13.3
OpenCV — 3.2.0
PyAutoGUI — 0.9.36
Dlib — 19.4.0
Imutils — 0.4.6

repo 的 README.md 中提到了执行步骤。如果有任何错误，请随时提出问题。

它是如何工作的

这个项目的核心是预测给定人脸的面部标志。我们可以利用这些地标完成很多事情。从检测视频中的眨眼到预测受试者的情绪。面部标志的应用、结果和可能性是巨大而有趣的。

Dlib 的预建模型，本质上是【4】的实现，不仅可以进行快速人脸检测，还可以让我们准确预测 68 个 2D 面部标志。非常方便。

使用这些预测的面部标志，我们可以建立适当的特征，这将进一步允许我们检测某些行为，如使用眼睛纵横比(下面将详细介绍)来检测眨眼或眨眼，使用嘴巴纵横比来检测打哈欠等，甚至可能是噘嘴。在这个项目中，这些动作被编程为控制鼠标光标的触发器。 PyAutoGUI 库用于移动光标。

眼睛长宽比(耳朵)

你会发现眼睛长宽比[1]是最简单也是最优雅的特征，它很好地利用了面部标志。耳朵帮助我们发现眨眼和眨眼等动作。

你可以看到，每当眼睛闭上时，耳朵值就会下降。我们可以训练一个简单的分类器来检测下落。然而，正常的 if 条件工作正常。大概是这样的:

if EAR <= SOME_THRESHOLD:
      EYE_STATUS = 'CLOSE'

嘴部长宽比

受到耳朵功能的高度启发，我稍微调整了一下公式，以获得一个可以检测张开/闭合嘴的度量。没有创意，但很管用。

与耳朵类似，当嘴张开时，MAR 值上升。类似的直觉也适用于这一指标。

预建模型详细信息

该模型提供了两个重要的功能。检测面部的检测器和预测界标的预测器。所使用的面部检测器是使用结合了线性分类器、图像金字塔和滑动窗口检测方案的经典梯度方向直方图(HOG)特征制成的。

面部标志估计器是通过使用 Dlib 的论文实现来创建的: 一毫秒面部对齐与瓦希德·卡泽米和约瑟芬·沙利文 的回归树集合，CVPR 2014。并在 iBUG 300-W 人脸地标数据集上进行训练:C. Sagonas，E. Antonakos，G，Tzimiropoulos，S. Zafeiriou，M. Pantic。300 人面临野外挑战:数据库和结果。 图像与视觉计算(IMAVIS)，面部地标定位“野外”特刊。2016 。

你可以从http://dlib.net/files,点击shape _ predictor _ 68 _ face _ landmarks . dat . bz2获得训练好的模型文件。模型，。dat 文件必须在项目文件夹中。

**注意:**iBUG 300-W 数据集的许可不包括商业用途。因此，您应该联系伦敦帝国理工学院，了解您是否可以在商业产品中使用该模型文件。

参考

【1】。Tereza Soukupova 和 Jan Cˇ ech。 利用面部标志点进行实时眨眼检测 。2016 年 2 月，第 21 届计算机视觉冬季研讨会。
【2】。艾德里安·罗斯布鲁克。 用 dlib、OpenCV、Python 检测眼睛、鼻子、嘴唇、下巴。
【3】。艾德里安·罗斯布鲁克。 用 OpenCV、Python 和 dlib 进行眨眼检测。
【4】。瓦希德·卡泽米约瑟芬·苏利文。 一毫秒人脸对齐与回归树 系综。2014 年在 CVPR。
【5】。S. Zafeiriou、G. Tzimiropoulos 和 M. Pantic。 野外 300 视频(300-VW)面部标志追踪野外挑战 。在 2015 年 ICCV 研讨会上。
。c .萨戈纳斯、G. Tzimiropoulos、S. Zafeiriou、M. Pantic。 野外 300 张人脸挑战赛:首届人脸地标定位挑战赛 。IEEE 国际会议论文集。在计算机视觉(ICCV-W)，300 面临野外挑战(300-W)。澳大利亚悉尼，2013 年 12 月
【7】。艾德里安·罗斯布鲁克。 Imutils 。https://github.com/jrosebr1/imutils。

Photo by Orysya Dibrova on Unsplash

使用 Tensorflow 对象检测 API 通过网络摄像头移动光标

原文：https://towardsdatascience.com/move-cursor-with-tensorflow-3727ed5e2795?source=collection_archive---------4-----------------------

Tensorflow 最近发布了用于对象检测的对象检测 API ，能够从图像中定位和识别对象。其快速检测图允许从视频帧甚至网络摄像头馈送中进行连续检测。它也可以用来制作鼠标。张量鼠。一个用摄像头移动光标的应用程序。

你是不是一直想用香蕉移动光标，却做不到？未来就是现在。

TensorMouse 是一个小型开源 Python 应用程序，允许你通过在网络摄像头前移动随机的家用物体(如杯子、苹果或香蕉)来移动光标，并作为电脑鼠标或触控板的替代品。

TensorMouse allows you to play games… with bananas

它是如何工作的？

TensorMouse 从网络摄像头记录图像序列。然后，这些被输入 Tensorflow 对象检测 API 图形，该图形返回对象的概率和位置。然后移动鼠标光标，使光标位置与图像上对象的位置相对应。
例如，如果在图像的左上角检测到物体，光标将移动到屏幕的左上角。

应用程序的主要部分依次重复以下步骤:

使用 OpenCV 从网络摄像头获取单帧图像
使用 Tensorflow 对象检测 API 进行对象检测
基于检测到的对象位置移动鼠标光标

1.帧采集

使用 Python OpenCV 模块捕获来自网络摄像头的帧。它为快速图像采集和缩放提供了一个跨平台的工具。然后将图像缩放至360p以提高性能。

2.目标检测

对象检测用于确定所需对象在网络摄像机帧中的相对位置。它使用 Tensorflow 对象检测 API 的冻结 Mobilenet 神经网络图，在 COCO 数据集上进行训练。该数据集由 80 种不同的物品组成，大部分包括杯子、苹果、餐具等家用物品。

Detected objects with corresponding probabilities

如果检测到的对象概率超过指定的阈值(当前为 85%)，TensorMouse 会将该对象视为已检测到，并计算检测到的对象的框的中心。

3.移动鼠标光标

Python 包 pynput 为执行鼠标光标移动提供了跨平台支持。光标移动到基于检测到的对象的相对位置的位置。这意味着如果在图像的左上角检测到物体，光标将移动到屏幕的左上角。

然后，应用程序返回到步骤 1，从网络摄像头中检索下一张图像，并重复这些步骤。

怎么用？

该应用程序的源代码发布在 my Github repo 中。

TensorMouse 可以在任何主流(Windows、Linux 或 MacOS)平台和几乎任何机器上运行，但要实现良好的帧速率，它需要一个像样的 CPU 或支持 CUDA 的显卡。

装置

安装确保安装了软件包依赖项。

安装 Anaconda(我推荐缩小版的 Miniconda )
从 Gitlab 克隆tensor mouse
打开终端并导航到项目根目录
conda env create -f environment.yml (Linux/MacOS)或conda env create -f environment-win.yml (Windows)
source activate tensormouse (Linux/MacOS)或activate tensormouse (Windows)

跑步张量鼠标

一旦安装了依赖项并激活了环境(参见第 4 步和第 5 步)，我们就可以简单地运行 TensorMouse:

python tensormouse.py

然后等待大约 10-20 秒，等待绿色消息指示 Tensormouse 已成功启动。

这将运行 Tensormouse 跟踪它的默认对象-杯子。但是您可以通过提供可选参数--obect="OBJECTNAME"使它与 80 个 COCO 数据集对象中的任何一个一起工作

您也可以使用CTRL进行点击，使用ALT按钮进行拖动。

使用说明

确保物体光线充足(Tensormouse 在光线不好的情况下表现不佳)
确保物体足够远，不会占据整个网络摄像头画面，但足够近，仍然可以被检测到(需要一些尝试和错误)
如果你遇到物体检测性能差，尝试运行应用程序设置它来检测杯子，因为他们表现得相当好

如何下载电影海报作为深度学习数据集

原文：https://towardsdatascience.com/movie-posters-81af5707e69a?source=collection_archive---------6-----------------------

如果你对神经网络感兴趣，你可能和我在同一个地方。在某些时候，通常的数据集开始变得无聊(看看你，MNIST)。它们是开始旅程的完美之选，但在那里只有这么多东西可以发现。这就是为什么我很兴奋地在 Kaggle 上发现了一系列电影海报的链接。

在这篇文章中，你可以找到我用来收集这些海报的代码，以便对它们进行多分类实验。我以一种很容易根据你的需要进行调整的方式来编写代码。你还可以在我的 Github 页面上找到一个完整的 Jupyter 笔记本。

一些背景:我收集这些数据的动机是建立一个神经网络，能够对艺术家设计电影海报的十年进行分类。当有人给你看一张电影海报时，你可能会知道它来自哪个时期。所以如果人类能做到，神经网络应该也能做到，对吧？这听起来不是比识别数字更令人兴奋吗？诚然，对电影海报进行分类的现实应用较少。但是……无论如何。

介绍够了。我们开始工作吧！作为对每一个读到最后的人的奖励:我找到的七十年代最差的三张电影海报在这篇文章的最后等着你。

Three more recent examples of movie posters. One of these movies was excellent.

数据准备和取样

Kaggle 数据集列出了 40，108 部电影，并有四个我感兴趣的字段:imdbID作为索引(以及稍后的文件名)，Title包含年份，Genre列出了一部电影所属的所有流派，Poster是带有相应电影海报链接的字段。有一些电影缺少值(845 部电影)和一些重复的链接(1，413)。清理完这些之后，我的数据集中还剩下 37，850 部电影。

电影的年份是Title字符串的一部分，例如，“朱曼吉(1995)”。我使用了一个正则表达式来提取这些信息。最老的电影是 1874 年的(！)，最近的都是 2018 年的。

由“|”划分的长字符串，例如“动作|冒险”，存储所有适用的类型。我将每个字符串拆分成一个列表，构建一个集合来获取所有唯一的值(all_genres)，并对其进行循环以创建每个流派的布尔变量，例如is_action。

我的主要目标是建立一个预测海报十年的多类分类网络。因此，我决定把重点放在 1970 年或以后制作的动作片上。这种方法有两个优点:

电影海报的风格是由时期和类型决定的。对正确的十年进行分类而不保持类型不变，将使任何网络架构都很难获得正确的信号。
1970 年及以后的过滤器是一个很好的平衡，在这种情况下，有足够多的十年可以看，也有足够多的海报可以建立一个网络。我一会儿会回到这一点。

这样的选择逻辑给我留下了 4614 张动作片海报。

最后，是时候添加十年作为目标变量了。因为这是一个分类问题，所以我选择将这个信息编码为一个字符串值。看了几十年来可用电影的分布，我意识到这些数据是多么不平衡:

不平衡数据集以及如何处理它们是许多真实世界机器学习应用程序的关键主题。然而，我不希望这成为我实验中的潜在问题。因此，我从每十年的海报中抽取了相同数量的样本。因为最低金额是 70 年代的 469 英镑，所以我选择了这个。

在所有这些步骤之后，我还剩下 2345 个(4 x 469)电影海报链接，我想用它们来做我的实验。

I think the second movie takes place in an airport. Please correct me if I’m wrong.

海报下载

我决定使用 80%的图像进行训练，20%的图像进行测试。根据目标变量对数据集进行分层始终是一种好的做法。在这种情况下，通过decade进行分层以保持数据集平衡至关重要。

也有例外(例如来自autokeras的load_image_dataset方法)，但是作为一个规则，你的文件夹结构应该反映训练和测试集的划分以及你想要预测的不同类:

我使用set(df.decade)作为classes 的值，但是这很容易调整，取决于你想做什么。文件夹结构就绪后，我可以开始下载电影海报了:

这些是我使用的函数的主要组成部分。在Jupyter 笔记本中，代码还包括检查先前下载的海报和一些诊断输出。

当我开始建立一个网络时，我意识到的最后一个问题是，一些电影海报不是 RGB 而是黑白的。下面是我写的代码，在它们干扰我的网络之前，我会删除它们:

在这最后的清理之后，我的数据被下载并准备好了。正如我所承诺的，这里是我发现的 70 年代最糟糕的三张海报:

I wonder whether people would celebrate or burn these posters today. I’m pretty sure about two of them.

感谢阅读！如果你喜欢这篇文章，留下一些吧👏🏻这样其他人就可以找到它，并在 LinkedIn 或 Twitter 上分享。让我知道你在评论和推特上的想法。再次感谢，继续学习！

向前看，向后看

原文：https://towardsdatascience.com/moving-forward-looking-backward-c77fad0d6c73?source=collection_archive---------4-----------------------

马后炮偏差

从过去重建伟大事物的愿望总是带有一些后见之明的偏见。

当我还小的时候，我和我的兄弟姐妹玩一种我们边玩边编的游戏(太详细了，无法解释)，这太棒了。几年后，出于一种怀旧情绪，我们试图重建它，但它太糟糕了。足够多的小细节已经改变，它不起作用。改变的一个重要细节是完全缺乏自发性。我们都知道结果应该是什么样的，这让我们的行为有所不同。

回顾过去时，很难了解自那以后发生了哪些变化。这意味着反过来很难推断因果关系。

实验

因果关系的黄金标准是实验。这是一个非常棒的工具。但是这种方法在复杂的环境中受到很大的限制，比如商业环境。

我们大多数人都读过这样的书，作者收集了一组例子，并利用它们之间的共性来暗示因果关系。论点是这样的:“看看所有这些成功的企业，他们都做了同样的事情！这一定意味着这是成功的一个重要因素。”

但是等等。这是一条很有问题的推理路线。我可以很容易地说:“有史以来排名前十的篮球运动员的球衣上都有数字。编号球衣一定是成功的关键决定因素。”

当然，我们从来没有听到过这样的陈述，因为它不符合我们的直觉。那么，真正阴险的陈述是那些直觉上吸引人的、虚假的、不可能反驳的陈述。

我最喜欢的例子是史蒂夫·乔布斯。我听过很多关于苹果真正伟大的原因的说法，从“史蒂夫·乔布斯天生就是一个有创造力的天才”到“史蒂夫·乔布斯为自己创造了他真正想要的东西”，再到“史蒂夫·乔布斯非常善于利用他人的想法”，甚至“史蒂夫·乔布斯真的很了解女性消费者。”每一种说法都很有吸引力，是苹果成功的合理原因(除了最后一种)，几乎不可能反驳。我们不能让史蒂夫·乔布斯起死回生，修改每一个属性，然后看看每次苹果会发生什么。

因此，在许多最具启发性的情况下，实验是不可能的。

辉煌的日子

回到再创造。施乐 PARC，另一个虚构的历史实体，激发了人们渴望再创造的欲望。贝尔实验室和 IBM Almaden 是类似的例子。如果我们可以有意识地再造这样的实体，难道我们不会喜欢吗？

再创造是的天性不是创新。它是尝试去做已经发生的事情。这可能是一个吹毛求疵的观点，但是我认为它让再创造者在开发新的、伟大的解决方案时处于不利的地位。

我是 PARC、贝尔实验室和艾伦·凯的超级粉丝(他们可能会帮助 YCombinator 试图重现 PARC 精神)。我认为我们可以从他们身上学到很多，并产生很多假设。问题是大多数人只是相信艾伦·凯的话。恕我直言，我认为没有人能够确切知道 PARC 为什么会成功。

归根结底，我们没有可靠的数据来告诉我们。样本太小，变量太多。

回顾过去并非毫无意义，这也是我一直在做的事情。事实上，我推荐任何人阅读所有关于 R&D 大实验室的书籍(创意工厂、梦想机器、闪电经销商)。然而，在这样做的时候，认识到不稳定的立足点确实很重要。我们看到“透过玻璃黑暗”，抄袭保罗。

更好的数据

为了避免写一篇纯粹的评论，我将大胆提出一些如何做得更好的想法。

一个主要的方法是，我们应该研究最近的创新例子，甚至是同时代的例子。现在正在发生的真正创新的事情是什么？硅谷是一个开始的好地方。

即使是最新的例子，也存在这样的风险，即事物变化太快，以至于降低了研究它们的价值。然而，我认为研究最近一批来自 YC 的创业公司及其创始人会比研究 PARC 或史蒂夫·乔布斯产生更多有用的数据。

自发性

人脑有点像联想机器。当图式和概念被同时刺激时，它们会互相桥接(“神经元一起放电，连接在一起。”)这些强关联超级有帮助，效率超高，但是在很多很多方面会让我们产生偏见。

我们可以通过允许生活中的随机性，并从传统结构中解放出来，在一定程度上减少这种偏见。简而言之，我们可以停止向后看，看那些我们认为已经被证实的事情，而开始看我们周围正在发生的任何事情。

虽然上面的部分认为我们应该学习更好的东西，但这一部分更像是根本不要学习。只是生活，体验，尝试事物，享受乐趣，做一些你想做的事情，即使它们看起来很愚蠢。

接受成功的罕见

最后，我认为承认巨大的成功不会经常出现是很重要的。重大的新进展不仅难以制造，总体来说也很难。

也许我没有说太多的用处，但我希望至少我已经说服了一些读者，当他们向前看过去的时候，要多加小心。

将数据科学作为职业(数据和 IT 管理)

原文：https://towardsdatascience.com/moving-into-data-science-as-a-career-data-it-management-8de5360cb06c?source=collection_archive---------7-----------------------

之前，我已经对数据科学家所需的技能和知识给出了一个总体的看法，还就数据科学家应该知道的数学知识进行了一次 T2 式的讨论。接下来，我将谈谈数据科学家应该了解的数据和 IT 管理知识。

1-数据治理&管理

由于数据是数据科学的命脉，因此需要像公司的所有其他战略资产一样小心管理。因此，数据科学家必须具备数据治理和管理方面的知识，以确保数据尽可能达到最高质量。这就相当于厨师尽可能保持食材新鲜，从而做出最美味的菜肴。

那么什么是数据治理呢？在 Wikipedia 中定义，它是一套正式管理数据的流程，以便数据可以信任并与责任一起，将不利的数据事件(如数据丢失、数据质量差、数据泄漏)降至最低。

数据科学家需要注意，甚至应该对数据治理流程进行反馈，以确保数据具有最高的质量和类似的优先级，确保数据隐私和安全，确保只有需要访问数据的人才能访问数据。

向不熟悉数据科学的读者介绍什么是数据治理。以新雇员对数据的访问为例。数据治理将阐明为新员工提供数据访问权限所需遵循的流程。例如，决定授予访问权限所需的信息是什么，授予哪种访问权限，需要访问多长时间，谁有权授予访问权限，在做出决定后，谁影响该决定等。当然，这只是“数据治理”的冰山一角。

在这一过程中，随着组织沿着学习曲线前进，数据科学家还需要提出数据收集策略、正确的数据粒度级别、支持策略的技术和基础架构，以及相关的数据治理流程，以便更好地管理收集的新数据。

数据管理&数据质量

我不认为我需要强调数据质量的重要性。那么，数据科学家应该注意哪些数据质量维度，并能够提出可能的维护解决方案呢？它们是:

准确性——它在多大程度上反映了现实？

完整性——我们是否获得了所有可能的数据？

及时性—当我需要时，数据是否可用？

有效性—它是否符合定义的格式？

一致性—不同表格之间的格式是否相同？

独一无二——没有重复？

在学习的过程中，数据科学家必然会遇到数据质量的更多方面。数据科学家可以在这个过程中建立自己的列表。更重要的是，数据科学家能够并且应该对可以创建并用于衡量数据质量的指标类型进行反馈。除了衡量数据质量的指标之外，能够设置正确的警报级别(例如，当缺失值的百分比超过 1.0 时发出警报)对于确保“脏”数据不会渗入也很重要。

数据质量只是数据管理的一个方面。数据管理的其他方面可以是例如自动化、验证、ETL 过程、备份、访问权限等。

企业数据仓库(EDW)

数据科学家不需要构建整个企业数据仓库，但对他们来说，了解如何构建数据仓库是有好处的，因为数据仓库的结构会影响数据的质量，尤其是数据的及时性和唯一性。构建 EDW 时，数据科学家可以通过牢记极端时期的业务连续性需求以及牢记 ETL(提取、转换和加载)流程来增加价值。

2-计算机架构

在我的大学时代，我修了一门“计算机导论”课程，学到的知识对我的工作帮助很大，帮助我理解了计算机是如何工作的，以及计算机是如何进行计算的。像内存总线、缓存、内存、硬盘、CPU 等东西都是在那个模块里教授的。它让我对计算的硬件方面以及它如何限制/增强处理能力有了更多的了解。这些知识为我理解技术是如何在幕后工作的打下了良好的基础。因此，我必须说，对计算机体系结构的良好理解使数据科学家能够提出可行的解决方案来捕获和维护数据，在 IT 系统中实现模型和算法。

企业 IT 架构设计

除了了解计算机如何工作，数据科学家还应该了解 it 架构在组织中是如何规划、设计和构建的。

原因在于，数据科学家可能需要将最终/选择的模型实施到企业 it 架构中，而良好的理解有助于数据科学家在数据收集策略或模型实施中提出可行的想法，并且在模型培训期间，能够注意到将这些模型嵌入到架构中时 IT 架构的约束和可能性(即，模型与现有 IT 系统和业务流程的良好集成，确保数据和数字的平稳流动)。例如，一些传统系统无法考虑复合变量(即 X1X2)，因此数据科学家将无法构建具有复合变量的机器学习模型，而只能使用简单的特征(X1 和/或 X2)。

3 种编程语言

考虑到大多数数据科学家需要利用计算机巨大的计算能力，数据科学家无法逃避编码，除非他/她想把职业机会限制在使用大量点击式软件的公司环境中。此外，精通编码允许数据科学家在设置模型的超参数、损失函数时有更大的灵活性，允许在构建的模型中有更多的“创造力”。

我可以理解为什么人们会反对编程，因为这就像试图用一个外国人的母语和他交谈，而我们对他们的母语却一点都不熟悉，并且希望这个外国人能够完全理解我们想要表达的意思。我的第一门编程语言是 Java，当我在大学里学习它的一个模块时，我对它一窍不通。随着我职业生涯的继续，我意识到如果我不处理编程，我将限制我的机会，并决定重新开始。谢天谢地，我学的下一门“编程”语言是 SAS，由于受控的环境，学这门语言是一种更愉快的经历。这给了我信心，让我可以继续前进，继续学习 R 和 Python(开源)。

鉴于许多 [IDEs](http://integrated development environment (IDE)) 已经使学习编程变得更加容易(通过建议&颜色编码)以及大量可用的资源，如 YouTube、开放课程软件、博客、StackOverflow 等，学习编程变得更加容易。一个人可以自己学习编程，或者如果他们在学习中需要结构，可以去编程训练营，这是最近很流行的。

如果我可以提出学习编程的另一个角度，我发现编程就像解决一个逻辑难题。解决 bug 需要一个人进行逻辑思考，并且很好地理解语言在幕后是如何工作的。因此，能够解决一个 bug(尽管这个过程极其令人沮丧)，实际上确实提供了一种成就感。至少对我来说，这感觉就像在努力解决一个难题很长一段时间后，当答案显而易见时，一种奇妙的感觉(以及成就感)就出现了。

此外，有许多方法可以通过编程达到目的或目标。足够熟练地编写代码，使代码能够高效地运行，也会给人一种成就感。对于任何开始学习数据科学的人来说，我强烈鼓励他们探索编程，数据科学家目前常用的语言是 R 和 Python，但请不要问我选择哪一种。

对于一个数据科学家来说，我相信首先要获得正确的概念，然后再想出要使用的工具，因为有了正确的概念，就有了“正确的”训练轮来高效地学习语言。所有这些关于哪个工具更好的文章仅仅是点击诱饵文章，唯一从中获益的人是文章的作者(以最昂贵的货币支付，称为时间)。

4-软件和硬件工具

作为一名数据科学家，我们必须让自己(尽可能)了解可用的最新工具，包括企业工具和开源工具。这是因为组织将依赖数据科学家来提出在每个数据科学项目中使用的正确工具。

打个比方，说给你一个工具箱，里面有各种各样的工具。着眼于眼前的挑战，你只会使用你熟悉的工具(锤子、钳子、螺丝刀),并且知道它能有效地解决挑战。我们知道，我们熟悉的工具越多，挑战就越容易解决。

同样，数据科学家应该尝试熟悉所有不同种类的工具，包括软件和硬件，并对其工作原理有所了解，使用它的利弊是什么，它在什么样的情况下有效，维护成本是多少，与当前工具集的可能集成问题等。对现有工具有一个很好的了解会给数据科学家带来附加值，这对组织挖掘他们的数据以获得更多见解是很重要的。

数据科学家不需要深入阅读(直到文档级别)就能提出工具，而是从最基本的层面理解它的工作方式及其优缺点。如果有时间和资源进行试验，那么也请进行试验，以便数据科学家能够很好地了解实施挑战。

数据科学家应该熟悉的一些建议工具是可视化和仪表板工具、机器学习工具、数据仓库和处理工具以及计算工具。

结论

为了让数据科学发挥作用，数据科学家必须非常小心地对待数据，确保数据是可信的，并且在质量上能够获得有意义的见解。如果数据科学家也参与 IT 基础架构的构建和维护，这是可以实现的。能够提出可行的解决方案有助于建立数据科学家的可信度，使数据科学团队成为具有高度内部信任的紧密团结的团队，鉴于数据科学需要组织中的团队努力，这一点非常重要。

这些是我认为数据科学家应该至少了解的数据和 IT 管理知识。在下一篇博文中，我将讨论数据科学家应该知道的有效的领域专业知识。

祝您的数据科学学习之旅愉快，请务必访问我的其他博客文章和 LinkedIn 个人资料来了解数据科学的重要信息。

**补充说明:**我已经建立了自己的网站，作为我 2020 年新年计划的一部分，最新消息请访问这里。感谢支持！

将数据科学作为职业(领域专长)

原文：https://towardsdatascience.com/moving-into-data-science-as-a-career-domain-expertise-3e36cafad1e7?source=collection_archive---------9-----------------------

在几篇讨论有兴趣从事数据科学职业的人应该具备哪些知识的帖子(总体、数学、数据& IT 管理)之后，我现在将更多地讨论数据科学家应该具备哪些业务知识(领域知识)。

1 —业务流程

如今，每个企业或组织都有流程。这些流程始终保持高效和有效是至关重要的，尤其是那些面向客户的流程。

重要的是，数据科学家要从总体上理解这些过程以及它们是如何工作的。为什么这很重要？原因是，作为一家在数据科学方面成熟的公司，数据收集和模型实现通常会添加到业务流程中。数据科学家需要很好地理解这些业务流程是如何工作的，以便能够建议何时可以捕获某个数据元素以获得更好的质量，其次能够建议应该在业务流程中的何处放置模型，以便将模型需要的数据元素提供给模型，并且模型在流程的正确阶段生成“决策”。

例如，大多数信用记分卡需要信用局的数据。因此，在信贷申请过程中，必须将模型置于模型所需的申请人数据(尤其是申请人的信用局数据)可用于模型的阶段。该模型还应在决策阶段之前生成信用评分，因为它是一个关键的决策因素(即在决定是否授予信用时)。

由于这涉及到模型的实现，因此数据科学家必须对业务流程有很好的理解，以便为数据收集和模型实现提出可信的建议。

2 —战略管理

通常，数据科学家的见解需要转化为业务战略。例如，来自营销活动响应模型的洞察可用于确定哪些客户特征可能会对营销活动做出响应，并由此设计出能够触及这些客户群的合理活动。

因此，对于希望为组织提供价值的数据科学家来说，能够提供“可操作”的见解至关重要。对战略管理有很好的理解，有助于数据科学家了解什么样的见解会受到公司的高度重视，什么样的见解是可行的(也许是考虑到组织中可用的资源)，能够在提出可行的见解后思考接下来的步骤。能够战略性地思考有助于数据科学家通过提供可以采取行动的见解来持续提供价值。能够持续提供可操作且有价值的见解有助于建立可信度，因为人们更倾向于听取数据科学家提供的有用见解，而不是无法付诸行动的见解(即空话和可行的行动)。

业务和收入模式

商业模式是一个组织如何服务于一个选定的市场，其竞争优势超过其他类似的竞争对手，而收入模式将说明该组织如何继续从商业模式中获取价值/利润。

对于要为组织增加价值的数据科学家来说，了解组织的业务和收入模式(包括现在和未来)是至关重要的。有了一些了解，数据科学家就可以确定哪些业务目标是重要的，并能够提供支持重要业务目标的见解。这与为战略制定和执行提供相关见解的能力密切相关，以便组织能够继续运营、服务于所选市场并从中获取利润。

通过了解战略管理、业务模式和收入模式，数据科学家可以了解每个项目提供的价值量，从而能够提供可以采取行动的相关见解，因为这些见解是根据业务和收入模式改编的，所以它允许公司继续从他们的数据中提取价值，为推动组织中更多的数据科学或分析创造可持续的动力。

3 —变更管理

许多刚开始学习数据科学的人没有意识到数据科学家也是变革的推动者，因为我们提供的见解，变革是必要的，让我们面对它，人类不喜欢变革，但如果企业要在比几十年前更具活力的动态环境中生存，变革是必要的。

作为变革推动者的数据科学家，需要了解如何通过提供见解的过程来创造可持续的变革(即不会回到旧习惯)。数据科学家不能只是创建大量的信息/见解，然后将它们倾倒到组织中。有时，需要有一种有分寸的方法来发布见解和信息，以便能够做出有效的改变。

对于那些对变革管理感兴趣的人，我发现约翰·科特设计的流程是最好的流程之一。你可以在这里阅读维基百科关于变革管理的文章。

4 —特定领域

随后，数据科学家需要具备的业务知识将与项目/分析所在的领域相关。例如，如果数据科学家在风险管理部门工作，则需要了解特定的业务定义、法规(尤其是银行、医疗保健、制药、航空)、会计政策和国际标准( GAAP 或 IFRS )、流程等。这是数据科学家所在组织所特有的部分。

我在招聘实践中注意到的一件事是对拥有领域相关知识的员工的巨大偏好。这可能会严重限制组织能够获得的数据科学人才的供应。着眼于前景和劳动力，雇主将有更好的机会从数据科学中获得更多价值，方法是寻找那些数学能力强、能够将业务目标转换为数学模型的数据科学。根据我的观察，与编程和领域知识相比，这是一个更难找到或训练的技能。

结论

我的结论是，在我看来和观察中，数据科学新手应该知道、学习和理解的关键技能和知识是什么。

随着技术的变化，数据科学家的工作也将不断发展，知识和技能可能也需要相应更新，所以请继续学习！！

请务必访问我的其他博客文章和 LinkedIn 个人资料以获取更多数据科学知识。

**补充说明:**作为我 2020 年新年计划的一部分，我已经建立了自己的网站，最新消息请访问这里。感谢支持！

将数据科学作为职业(数学模型)

原文：https://towardsdatascience.com/moving-into-data-science-as-a-career-mathematical-models-e13f30690b00?source=collection_archive---------3-----------------------

我写了一篇关于成为一名数据科学家所需的技能和知识的概述。在这篇文章中，我将写更多的细节，我的维恩图中的一个领域，那就是数学模型。

简介

如果你看看数据科学，我们实际上正在使用数学模型来建模(并希望通过模型来解释我们看到的一些事情)业务情况、环境等，通过这些模型，我们可以获得更多的见解，例如我们所做决策的结果，我们接下来应该做什么，或者我们应该如何做才能提高胜算。因此，数学模型非常重要，选择正确的模型来回答业务问题可以为组织带来巨大的价值。

1 —线性代数&微积分

是的，首先也是最重要的，就像你见过的大多数回归的功夫电影(主角被一个大坏老板打败，当他穷困潦倒时，找到一个聪明的老师教他功夫，学习功夫，然后打败大坏老板)，老师总是从基础开始。

线性代数和微积分被认为是最基础的。鉴于我们所处的“深度学习”环境，这一点尤其正确。深度学习要求我们理解线性代数和微积分，理解它是如何工作的，例如向前传播、向后传播、参数设置等。有一个好的基础有助于我们理解这些模型是如何工作的，做了哪些假设，参数是如何得出的。早在我的大学时代，我学习线性代数和微积分，但直到现在才发现这与我的工作有关联。真希望我在这上面花了更多的时间。

那么，潜在的数据科学家应该学习什么呢？

对于线性代数，有矩阵运算(加、减、乘、除)、标量积、点积、特征向量和特征值。

对于微积分，数据科学家需要理解各种微分(对二阶导数)、积分、偏导数。在浏览一些材料时，他们确实会触及数学级数，如泰勒级数。如果你有兴趣了解更多关于数学级数的知识，维基百科相当全面。检查连杆。

当我们考虑设计机器学习/统计模型的损失函数、正则化和学习速率时，大量使用微积分和线性代数。

2 —统计数据

嗯，在做分析的时候，一个人怎么能逃避统计呢，这就不需要进一步介绍了。根据经验，当我们打算做实验和测试时，需要了解统计数据，例如在市场营销中，我们有 A/B 测试。我们通常希望了解两个样本之间是否有任何统计差异，或者在某些“处理”之后，它是否产生了统计上显著的效果。

因此，统计学的领域是简单的统计学，如中心性、分布和不同概率分布(威布尔、泊松等)的测量，贝耶定理(以后学习人工智能时会非常强调)，假设检验等。

3 —机器学习/统计模型

我本科的时候学的是计量经济学，是最接近机器学习/统计模型的一门学科。在那项研究中，我遇到了线性回归和逻辑回归。该模块涵盖了非常多的回归模型假设，即异方差、自相关、E(e) = 0 和多重共线性。这些假设之所以重要，是因为在训练模型时，我们试图获得所谓的 BLUE(最佳线性无偏估计)参数，即包括截距在内的系数。

但是当我转到机器学习模型时，对于回归模型的课程，不再强调这些假设，而是非常强调建立损失函数，这是正则化、梯度下降和学习速率背后的基本原理。

回来，学习机器学习模型是任何数据科学家都必须要做的事情，因为他们需要提出可以帮助为组织提供见解的机器学习模型。数据科学家需要转换给定的业务目标，并将它们转化为机器学习模型，以获得答案和见解。

通常有两种类型的机器学习模型，监督和非监督学习模型。

监督学习模型

假设你有两组数据。集合 A 具有周期 1 中的行为数据和周期 2 中的结果。集合 B 只有周期 3(或 2)中的行为数据，但在周期 4(或 3)中没有任何结果。

使用集合 A，你将训练一个模型，仅仅通过观察行为，就能够“预测”(或给出概率)结果。训练出模型后，您将对行为数据进行“评分”，并尝试“预测”(或有一个概率)可能的结果。

可以使用的模型称为监督学习模型。它是受监督的，因为 Set 的结果“监督”了模型，以得出好的预测值。

无监督学习模型

所以你可能已经猜到，对于无监督学习模型，集合 A 数据上没有“结果”,它通常不与集合 B 数据一起使用。事实上，无监督学习模型只是试图找出集合 A 中的模式，这些模式是由模型的训练算法识别的。

从业务目标转移到建模目标

对监督和非监督模型有了很好的理解，数据科学家将需要知道在每个给定的业务目标中，使用哪些机器学习模型，如何使用它们，以什么顺序使用它们，以便实现给定的业务目标。我见过的许多培训项目通常使用单一模型来实现业务目标，例如，在创建电子邮件营销响应模型时，要么选择逻辑回归，要么选择决策树或支持向量机来构建。这就造成了一个盲点，即每个业务目标都有一个机器学习模型，而实际情况并非如此。

推荐使用哪些模型以及基于业务目标构建建模目标的能力来自于经验。因此，对于任何潜在的数据科学家来说，一定要开始研究它。

模特培训

在机器学习中，你遇到的每个机器学习模型都有许多“旋钮”和“开关”，供你在模型训练过程中调整或翻转。这些“旋钮”和“开关”被称为超参数。具有良好数学背景的数据科学家对于如何转动这些“旋钮”和“开关”以获得“最佳”模型有很高的理解能力。事实上，如果他们有良好的背景，他们可能会提出自己的损失函数并建立自己的随机梯度下降方法，这是训练不同机器学习模型(主要是监督的)的两个关键组成部分。

型号选择指标

大多数情况下，我们可以训练几个不同的模型(给定目标和超参数)，然后我们需要了解模型选择指标是如何计算的，以及它们喜欢哪种模型。

选择最佳模型并不总是仅仅基于准确性，因为在现实生活中，错误预测正面的成本可能与错误预测负面的成本大不相同。例如，在一种流行病中，可以减少假阴性的测试比高度准确的测试更需要，因为它会得到很多真阴性。

4 —运筹学

我们都在一个需要不断做出决策的环境中工作。能够部署数学模型来帮助做出更好的决策是运营研究的目的。运筹学的一些例子是什么？分别是最优化、博弈论、预测、排队论、模拟、图论等。当然，运筹学还包括统计/机器学习模型，以帮助对商业环境进行建模，以便做出合理的决策。这完全是一个数学领域，需要大量非统计学的研究。

我相信数据科学家应该能够使用这些模型，使用数据支持的参数，以便做出“更好”的决策，帮助业务组织实现其业务目标。

结论

最终，数据科学家应该精通数学和统计学，为他/她建立数据科学职业生涯打下最好的基础。我认为，数据科学家最基本的技能是数学知识，能够将业务目标或挑战转化为数学模型，并使用这些模型作为做出最佳决策的基础。

还有人认为编程是一项基本技能，我不否认这一点，但我认为编程是必要的，因为我们现在使用计算机来处理我们拥有的大量数据。想象一下，如果没有数学知识来理解如何对环境建模，那么编程技能对数据科学家有多大用处？

我希望这能让任何考虑从事数据科学职业的人了解，为了成为一名数据科学家，他们需要知道哪些数学知识。在我的下一篇文章中，我将会谈到数据& IT 管理和领域知识。

**边注:**我想既然你们中的一些人正在阅读这篇文章，你们可能会有兴趣知道吴恩达认为在人工智能和机器学习中强大所需的数学是什么。这里是链接。

祝您的数据科学学习之旅愉快，请务必访问我的其他博客文章和 LinkedIn 个人资料。

**补充说明:**作为我 2020 年新年计划的一部分，我已经建立了自己的网站，最新消息请访问这里。感谢支持！

从 Python 迁移到 Go

原文：https://towardsdatascience.com/moving-to-go-from-python-9ebbd9a8aec4?source=collection_archive---------5-----------------------

过去两年我一直在使用 Python，它在很多方面都是一种非常方便的语言。它可以用于 web 开发(使用 Flask 或 Django)、机器学习(使用 nltk 或 scikit-learn)、数据可视化(使用 seaborn 或 matplotlib)和深度学习(使用 TensorFlow、keras)。Python 是一种非常适合初学者的简洁的书面语言。然而，它也有局限性——例如速度不够快、GIL、动态类型和非内置并发支持。最近，我被要求拿起 Go 进行一个查询理解项目(我已经在我的其他博客中写了这个)。

Moving from Python to Go

我对 Go 的第一印象是它有多罗嗦。铅字散落一地，没有课。已经掌握了一些 Python 语言，在 Go 中从头开始被证明是一个挑战。一些博客比较了 Python 和 Go，我将只关注语法部分。我听说过很多关于静态类型的东西，但我不知道我实际上是在做什么。事不宜迟，我们继续吧。

1.静态打字

令人惊讶的是 Python 对你隐藏了多少类型。你基本上是这样开始编写函数的:

def add_numbers(num1, num2):
     return num1 + num2

现在你会期望这个函数的用户会给你发送两个整数，你可以把它们相加。但是，如果他们发送字符串呢？或者字典？对于字符串，这段代码仍然有效，但是“1”、“2”将返回“12”而不是 3。这可能会导致更复杂的程序出现许多令人痛苦的错误，这些程序可能很难调试 esp。因为 Python 只会在运行时告诉你这些。
在围棋中同样的程序是:

func add_numbers(num1 int, num2 int)int{
     return num1 + num2
}

我们不能向该函数发送两个字符串或其他数据类型。如果 Go 需要两个整数，它将确保调用这个函数的每一行都发送两个整数。当 Go 的二进制文件被编译时，这些问题就可以被捕捉到，而不是等到生产中的运行时——因此节省了很多问题！欢迎来到静态打字的魔力！

2.结构和 JSON 解析

对于任何数据科学项目来说，JSON 解析都是非常重要的。围棋没有课。它的传播方式是使用结构以及接口和方法。对于像 Go 这样的静态类型语言来说，结构非常有用，因为结构预先明确了我们可以使用什么类型。让我们举一个例子:

{ "John" : {"id": 12345, "department": "Human Resources"},
  "Sarah": {"id": 3, "department": "Software Engineering"},
  "Omar": {"id": 145, "department": "Marketing"}
}

要从上面的 JSON 中获取所有雇员的姓名，Python 中的代码将是:

# Code in Python
import jsondef find_names():
   with open("example.json", "r") as outfile:
       data = json.load(outfile)
       names = [name for name, details in data.items()]
   return names

围棋中同样的代码是:

package mainimport (
     "fmt"
     "io/ioutil"
     "json"
)func find_names()[]string{
   type EmployeeDetails struct{
      Id string `json:"id"`
      Department string `json:"department"`
   } var employee_data map[string]EmployeeDetails // Go's dictionary
   data, _ := ioutil.ReadFile("example.json")
   err := json.Unmarshal(data, &employee_data) // Use of pointer
   if err!=nil{
      fmt.Println("error:", err) // Easy handling of errors
   } var names []string
   for name, _ := range employee_data{
     names = append(names, name)
   }
   return names
}

Python 和 Go 在解析 JSON 方面的一些关键区别:

在 Go 中，您需要知道您在 JSON 中解析的每个字段的数据类型。如果数据类型被混淆，Python 代码将保持不变，但是 Go 的代码将随着interface{}和类型断言等的使用发生相当大的变化。Go 是一种强类型语言，在设计 API 时最好记住这一点。
Go 提供了开箱即用的错误处理。如果 json 中的Unmarshal函数有问题，就会创建上面的err。在 Python 中，错误或异常处理更加谨慎，很容易被忽略。
围棋中没有列表理解。Python 在这方面很容易使用，但是在 Go 中，每个片段都需要显式分配数据类型，代码也更加冗长。
在 Go 中，指针允许用户明确控制是否要修改底层对象。在 Python 中，不清楚函数是就地修改传入的数据，还是使用数据的副本。在 Go 中，使用&employee_data可以清楚地表明我们想要修改底层变量。
在 Go 中，未使用的变量和未使用的导入是不行的——不像 Python。它们需要被替换为_(下划线)。我觉得这使得代码可读性更好。

对于混合数据类型，您需要接口。此外，如果您不想使用 structs 来自动让 JSON 的Unmarshal遵循数据类型，您将需要几个类型断言，这两个我们将在接下来研究。

3.接口和类型断言

对于来自 Python 的我来说，接口是最棘手的部分。实际上，我更害怕指针，但是令人惊讶的是，到目前为止它们还可以，因为 Go 只是使用指针来给用户更多的变量控制。

虽然 Go 是一种强类型语言，但接口允许 Go 在数据类型上有一些模糊性。接口既可以是type也可以是set of methods。当你写一个以interface{}作为参数的函数时，你可以给这个函数提供任何值——这很棘手，因为这并不意味着任何类型。interface{}本身就是一个类型。阅读该堆栈溢出讨论以全面理解这一点。

func add_numbers(num1 interface{}, num2 interface{})interface{}{
    // num1 and num2 are of interface{} type only (not any type)
    // but any type can be converted to interface{} type
    // This is really tricky, esp. coming from Python world // Need type assertion to ensure types are as expected
    m := num1.(int)
    n := num2.(int)
    return m + n    // returns an integer
}

上面是一个使用interface作为类型的例子。Interface也可以作为set of methods为不同结构的变量提供方法。《以身作则》有一个很好的例子。简而言之，interface可以用来收集与某些结构相关联的方法，比如针对rect或circle结构的area()或perim()。这就像 Python 中的类方法。

这些是我发现的 Python 和 Go 之间的一些主要区别。写 Go 代码让我重新思考如何写 Python，尤其是。我如何设计函数来接受类型和处理错误。

为了更好地学习围棋，很多人向我推荐了这本书围棋编程语言书:

Go Programming Language Book

我可能会在未来的博客文章中涉及机器学习、自然语言处理和围棋数据可视化等主题。
更新2019 年 2 月:在一个新的视频课程中，我在 Go 中涵盖了机器学习、NLP、决策树、推荐系统等所有上述主题！[ Udemy Link ， Packt Link ]请随意查看 Github 上的公共代码库，其中涵盖了 Golang 中的 tweet bot、文本分类、推荐引擎等主题。

附:看看我的新播客！我最近开始了一个名为“数据生活播客的新播客。如果你已经在工作中处理数据，或者想在机器学习、自然语言处理或信息检索方面做得更好，这就是适合你的播客。你可以在苹果播客、 Spotify 或 Anchor.fm 上听，或者在我最喜欢的播客应用之一:阴天上听。

My New Podcast: The Data Life Podcast

祝你写 Go 代码一切顺利！

MSE 和偏差-方差分解

原文：https://towardsdatascience.com/mse-and-bias-variance-decomposition-77449dd2ff55?source=collection_archive---------0-----------------------

当我翻阅一些伟大的机器学习书籍时，如 ISL 、 ESL 、 DL ，我对他们如何解释 MSE(均方误差)及其偏差-方差分解感到非常困惑。如果您想真正很好地掌握像过度拟合、欠拟合和模型容量这样的事情，偏差-方差分解是极其重要的。不幸的是，这些书要么放弃推导，要么在不同的上下文中给出，这令人困惑。在这里，我将给出两种最常见情况下的偏差-方差分解的完整推导:估计量的 MSE 和预测量的 MSE。

估计量的 MSE

估计器是数据样本上的任何函数，通常试图估计从中抽取样本的原始数据的一些有用质量。形式上，估计量是一个关于样本 S 的函数:

其中 x(i) 是从分布 D 中抽取的随机变量，即 x(i) ~ D 。

在统计学书籍中，通常可以方便地想象我们正在处理的数据是从某种分布中抽取的样本。想想股票市场，实际上我们只能每隔大约 10 毫秒监测一次股票价格，但实际上有一个隐藏的经济机器产生这些数据，由于其巨大的复杂性，我们无法观察到。这个机器描述了分布，我们观察到的数据是一个样本。

例子

我们想用这个样本来估计原始数据的一些有用的质量。例如，我们可能想知道 AAPL 股票的平均值，但由于我们无法掌握产生 AAPL 价格的整个经济机制，我们只能计算观察到的价格的平均值:

将是 AAPL 股票的估计值 均值和 AAPL 股票的真实均值。注意估计均值是依赖于样本的随机变量，样本也是随机变量，而**真实均值是标量。**

另一个例子是 AAPL 股票的估计方差:

其中 σ 是 APPL 股票的真实方差。

估计器属性

现在我们想知道我们的估计量有多好。有两个性质我们可以考虑: 估计量偏差 和 估计量方差 。

估计偏差 衡量我们的估计器在估计真实值时有多好。这是一个简单的区别:

估计量方差 衡量我们的估计量对采样的“跳动”程度，例如，如果我们每 100 毫秒而不是每 10 毫秒观察一次股票价格，估计量会有很大变化吗？

例子

如果我们假设 AAPL 股票价格的实际分布是一个高斯分布，那么估计量的偏差为零，意味着它是无偏的:

可惜 σ 的估计量的偏差不为零，是有偏差的:

顺便说一下，这就是为什么下面的无偏估计量在文献中更常用:

这些公式的证明见 DL 书中的第 5 章。

估计量的偏差-方差分解

偏差-方差分解只是将我们最喜欢的两个属性统一在一个公式中:

其中期望值是相对于 S 随机变量取的。

这就是证据:

这里我们使用了这样一个事实，即 θ 不是一个随机变量，因此它对于任何分布都等于它自己的期望。

预测值的 MSE

这个统计说够了，我们来谈谈机器学习吧！:)在上一节中，我们看到了如何使用估计器来估计数据的一些有用质量。在一个例子中，我们能够通过仅每 10ms 观察其值来估计 APPL 股票的均值和方差。

现在我们想赚点钱，在股票市场交易！我们需要建立一个模型，让从现有数据 x 中预测这只股票的未来价值 y 。这些可用的数据可以是销售数字、过去 5 天的股票价值、公告、产品发布等。所以我们建立了一个模型来描述我们的股票价格:

我们假设 f 是对我们隐藏的决定股票价格的真实模型， ϵ 是一些讨厌的观察噪声。我们想得出一个尽可能接近 f 的预测器*。预测器在训练数据的一些样本 S 上被训练，但是我们希望它在我们还没有观察到的数据上表现良好。因此，我们希望以下内容尽可能小:*

其中 (x，y) 是代表未观测数据的随机变量。 S 是我们训练预测器的数据， ϵ 是遵循某种分布 E 的噪声。注意，我们未观察到的(通常称为测试数据)与训练数据 S 中的点具有相同的分布。在 ML 中，让训练和测试数据来自同一个分布通常是非常重要的。

因为预测器的 MSE 也有偏差-方差分解。我们在这里推导一下。我们将使用以下公式:

下面所有的期望、方差和协方差都是通过 (x，y) 、 S 、和 ϵ 随机变量计算的。

这里我们假设我们的噪声是独立于s**【x，y】的随机变量。

现在我们将假设噪声 ϵ 具有零均值。如果平均值不是零，而是某个常数 c ，那么我们可以将该常数包含在我们的模型中的 f(x) 中，并认为该噪声具有零平均值。

第一项通常称为方差。它显示了真实模型和预测模型之间的差距是如何“跳动”的，这取决于训练数据和测试数据 (x，y) 。容量大的模型(如极多层的神经网络)方差高，容量小的模型(如想线性回归)方差*低。***

第二个名词是噪音。它显示了观测噪声的影响。它不依赖于任何东西，只依赖于噪声的基本分布。我们无法减少这种噪音，它是不可减少的。

第三项是平方偏差。它显示了我们的预测器是否很好地逼近真实模型。高容量机型偏置低容量机型偏置。

既然偏差和方差都对 MSE 有贡献，好的模型就尽量减少这两者。这被称为偏差-方差权衡。

这其实是一回事

正如你可能从公式中注意到的，估算器的 MSE 和预测器的 MSE 非常相似。估计量的 MSE 测量我们的 估计量 与期望量 θ 的接近程度。预测器的 MSE 测量我们的函数 预测器 在某些函数空间中与期望的函数 f 有多接近，其中我们测量两个函数之间的距离作为 L2 距离，这实际上是人们可以在函数空间中定义两个函数之间的距离的许多方法之一。

在预测器的 MSE部分，我们也引入了误差，但是在 MSE 中，估计器的 MSE部分也会有误差。在我们的股票例子中，这相当于我们对股票的观察被一些噪音扭曲了。

在 DL 书中找估计量被称为点估计，因为 θ 是正则空间中的一个点。而寻找预测器被称为函数估计是因为 f 是函数空间中的函数。**

P.S .混淆的来源

对于试图理解偏差-方差分解的人来说，基本上有两个混淆的来源。

第一个是，书籍喜欢修正一些随机变量，只计算关于或 ϵ 的期望。它允许他们写出更短的公式。

第二个原因来自于这样一个事实，即从高层次的观点来看，MSE 估计量和预测量的 MSE 在技术上是一样的，在解释偏差-方差分解时，书籍喜欢将它们交替混合。

我实现了一个人脸检测模型。我是这样做的。

原文：https://towardsdatascience.com/mtcnn-face-detection-cdcb20448ce0?source=collection_archive---------1-----------------------

上周，我开始在 Augentix Inc .实习，旨在了解更多关于神经网络的知识。在那里，我遇到了一个面部检测模型，它在保持实时性能的同时实现了高精度(链接此处)。该模型使用多任务级联卷积网络(MTCNN)，它本质上是几个卷积网络串在一起，给出几条信息。

从 github(链接这里)下载模型后，我打开并运行 example.py，它生成了这个图像:

Image 1: Output image from example.py // Source

如上图所示，神经网络检测各个面部，定位面部标志(即两只眼睛、鼻子和嘴的端点)，并在面部周围绘制一个边界框。example.py 中的代码支持这一点。

首先，他们导入 OpenCV(打开、读取、写入和显示图像)和 MTCNN。正在检查。/mtcnn/mtcnn.py 显示了执行面部检测的 mtcnn 类。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-import cv2
from mtcnn.mtcnn import MTCNN

然后，创建一个 MTCNN 类的检测器，用 cv2.imread 读入图像。调用 MTCNN 类中的 detect_faces 函数，在我们传入的图像中“检测人脸”，并在“结果”中输出人脸。

detector = MTCNN()image = cv2.imread("ivan.jpg")
result = detector.detect_faces(image)

为了检查“结果”中有什么，我打印出来得到:

[{'box': [277, 90, 48, 63], 'confidence': 0.9985162615776062, 'keypoints': {'left_eye': (291, 117), 'right_eye': (314, 114), 'nose': (303, 131), 'mouth_left': (296, 143), 'mouth_right': (313, 141)}}]

结果似乎是一个字典，其中包括边界框和面部标志的坐标，以及网络将该区域分类为面部的信心。

我们现在可以分离坐标，将边界框坐标传递给 bounding_box，将面部标志坐标传递给关键点。

bounding_box = result[0]['box']
keypoints = result[0]['keypoints']

现在，我们通过传入坐标、颜色(RGB)和边框轮廓的厚度来绘制边框的矩形。这里，bounding_box[0]和 bounding_box[1]表示左上角的 x 和 y 坐标，bounding_box[2]和 bounding_box[3]分别表示框的宽度和高度。

类似地，我们可以通过传递坐标、圆的半径和线条的粗细来绘制面部标志的点。

cv2.rectangle(image,
              (bounding_box[0], bounding_box[1]),
              (bounding_box[0]+bounding_box[2], bounding_box[1] + bounding_box[3]),
              (0,155,255),
              2)cv2.circle(image,(keypoints['left_eye']), 2, (0,155,255), 2)
cv2.circle(image,(keypoints['right_eye']), 2, (0,155,255), 2)
cv2.circle(image,(keypoints['nose']), 2, (0,155,255), 2)
cv2.circle(image,(keypoints['mouth_left']), 2, (0,155,255), 2)
cv2.circle(image,(keypoints['mouth_right']), 2, (0,155,255), 2)

最后，我们创建另一个名为“ivan_drawn.jpg”的文件并显示图像。

cv2.imwrite("ivan_drawn.jpg", image)
cv2.namedWindow("image")
cv2.imshow("image",image)
cv2.waitKey(0)

这很好，但如果我们只能通过图像，面部检测是一个很大的用处。我想修改它，这样我就可以用我的网络摄像头。通过这样做，我还可以测试该报声称的能够实时定位人脸的说法。

我再次导入了 OpenCV 和 MTCNN，然后创建了一个检测器:

import cv2
from mtcnn.mtcnn import MTCNN
detector = MTCNN()

为了使用我的网络摄像头，我创建了一个视频捕捉对象。由于我只有 1 个摄像头，所以我传入了 0 个。

cap.read()返回一个布尔值(True/False ),该值表明帧是否被正确读入。如果一个错误发生并且一个帧没有被读取，它将返回 False 并且 while 循环将被中断。

然后，类似于 example.py，我在每一帧上调用 detect_faces。由于有时一张脸可能不在帧中(结果将是空的)，我添加了“如果结果！= []"使程序即使在帧中没有人脸时也能继续运行。

此外，帧中可能有不止一个面。在这种情况下，result 将返回多组坐标，每个面一组。因此，我在 result 中运行了一个 for 循环来遍历每个单独的面。对于每一张脸，我画出边界框，并点上 5 个面部标志。

最后，我展示了每一个单独的画面。每一帧将为键“q”等待 1 毫秒，然后移动到下一帧。要关闭窗口，我只要按“q”就行了。一旦我这样做了，我就释放视频捕获并关闭窗口。

cap = cv2.VideoCapture(0)
while True: 
    #Capture frame-by-frame
    __, frame = cap.read()

    #Use MTCNN to detect faces
    result = detector.detect_faces(frame)
    if result != []:
        for person in result:
            bounding_box = person['box']
            keypoints = person['keypoints']

            cv2.rectangle(frame,
                          (bounding_box[0], bounding_box[1]),
                          (bounding_box[0]+bounding_box[2], bounding_box[1] + bounding_box[3]),
                          (0,155,255),
                          2)

            cv2.circle(frame,(keypoints['left_eye']), 2, (0,155,255), 2)
            cv2.circle(frame,(keypoints['right_eye']), 2, (0,155,255), 2)
            cv2.circle(frame,(keypoints['nose']), 2, (0,155,255), 2)
            cv2.circle(frame,(keypoints['mouth_left']), 2, (0,155,255), 2)
            cv2.circle(frame,(keypoints['mouth_right']), 2, (0,155,255), 2)
    #display resulting frame
    cv2.imshow('frame',frame)
    if cv2.waitKey(1) &0xFF == ord('q'):
        break#When everything's done, release capture
cap.release()
cv2.destroyAllWindows()

运行这个新文件，我看到 MTCNN 网络确实可以实时运行。拳击我的脸，标出我的特征。如果我把脸移出相框，网络摄像头也会继续运行。

点击这里阅读 MTCNN 模型的结构！

点击这里阅读 MTCNN 如何做人脸检测！

点击此处下载 MTCNN 论文和资源:

Github 下载:【https://github.com/ipazc/mtcnn
研究文章:http://arxiv.org/abs/1604.02878

基于 R 的文本多类分类

原文：https://towardsdatascience.com/multi-class-classification-in-text-using-r-e6cf72ef1da3?source=collection_archive---------5-----------------------

预测 Ted 演讲的收视率

Photo by Hermes Rivera on Unsplash

这个博客是我的 NLP 博客系列的延续。在之前的博客中，我讨论了 R 中的数据预处理步骤和识别 ted 演讲中的情绪。在这个博客中，我将预测观众对 ted 演讲的评价。这将需要多类分类和相当多的数据清理和预处理。我们将在下面详细讨论每个步骤。

所以，让我们开始吧！

A way to visualize text classification

数据清理和解析

ted 演讲数据集中的评级栏看起来像Figure 1。

Figure 1

上面这个栏目的截图，Figure 1表示有多少人认为一个特定的演讲是“鼓舞人心的”、“漂亮的”、“有创意的”、“有说服力的”等等。JSON 中的 count 键表示给予谈话的评分值。例如，这个演讲被 385 个人评为“鼓舞人心”，只有 2 个人认为这个演讲“有趣”。在这里，我们的目标是获得每次谈话的最高评分。

其中一个主要问题是解析 ratings 列。我已经使用了 gsub 函数来用双引号替换单引号。我在这里找到了关于gsub的细节和解释。

library(jsonlite)formatted_ted_ratings <- gsub(“‘“,’”’,ted_talks$ratings)

下一步是解析 JSON 以获得 id、评级名称和评级计数的列表。R 中的 jsonlite 库提供了流、验证和美化 JSON 数据的功能。 fromJSON 函数用于将 JSON 对象反序列化为 R 对象。最后， purrr::map 函数将一个函数(在我们的例子中是 fromJSON)应用于列表中的每个元素。文档和实现可以在这里阅读。

ted_ratings <- purrr::map(formatted_ted_ratings, jsonlite::fromJSON)

上面的代码块为我们提供了一个经过解析的评级列的简洁列表。看起来像Figure 2。

Figure 2: Parsed rating column

在下一步中，我将创建一个新的列“highest_rating ”,在其中我将存储每次谈话的最高评分。发布后，我会将该列转换为因子，这将有效地给我们 13 个独特的因素(评级)来处理。我希望，到目前为止，您一定已经得到了一个提示，这个具有 13 个因子变量的最高评级列将用于多类分类。在这种意义上，二元分类问题有两个类别来分类数据点，例如真和假。然而，在这个问题中，我们必须将数据点分类到 13 个类别中的一个，因此，这是一个多类别分类问题。

for (i in (1:length(ted_ratings))) {
 ted_ratings_df <- ted_ratings[[i]]
 highest_rating_count <- ted_ratings_df[which(ted_ratings_df$count == max(ted_ratings_df$count)), ]
 ted_talks$highest_rating[i] <- highest_rating_count$name
}ted_talks$highest_rating = as.factor(ted_talks$highest_rating)

完成以上步骤后，我们的数据集准备工作就完成了。

数据建模

我们现在将数据集分为训练和测试。我以 60:40 的比例划分了我的数据集。

trainObs <- sample(nrow(ted_talks), .6 * nrow(ted_talks), replace = FALSE)
testObs <- sample(nrow(ted_talks), .4 * nrow(ted_talks), replace = FALSE)train_dat <- ted_talks[trainObs,]
test_dat <- ted_talks[testObs,]

我现在将所有预处理步骤应用于我的训练和测试数据(分别)。不知何故，我处于双重心态:是将 DTM 分成训练和测试，还是分割数据集，然后分别准备他们的 DTM。不知何故，我选择了后者。你可以试试前一种选择，如果它对你合适，请告诉我。

我还处理了稀疏性，我在我的博客中详细讨论了这个问题。为了更直观，我还将目标变量重命名为“y ”,而不是 highest_rating。

train_corpus <- VCorpus(VectorSource(train_dat$transcript))##Removing Punctuation
train_corpus <- tm_map(train_corpus, content_transformer(removePunctuation))##Removing numbers
train_corpus <- tm_map(train_corpus, removeNumbers)##Converting to lower case
train_corpus <- tm_map(train_corpus, content_transformer(tolower))##Removing stop words
train_corpus <- tm_map(train_corpus, content_transformer(removeWords), stopwords(“english”))##Stemming
train_corpus <- tm_map(train_corpus, stemDocument)##Whitespace
train_corpus <- tm_map(train_corpus, stripWhitespace)# Create Document Term Matrix
dtm_train <- DocumentTermMatrix(train_corpus)train_corpus <- removeSparseTerms(dtm_train, 0.4)dtm_train_matrix <- as.matrix(train_corpus)
dtm_train_matrix <- cbind(dtm_train_matrix, train_dat$highest_rating)colnames(dtm_train_matrix)[ncol(dtm_train_matrix)] <- “y”training_set_ted_talk <- as.data.frame(dtm_train_matrix)
training_set_ted_talk$y <- as.factor(training_set_ted_talk$y)

现在我们已经准备好了训练数据集，我们可以训练我们的模型了。我在 caret 中使用了 caret 包和 svmLinear3 方法。 svmLinear3 为 SVM 的 L2 正则化提供线性核。同意，这是很多技术术语，我故意不在这里解释，因为这完全是另一个博客。同时，我会留下一些链接让你们了解 L2 正则化 ，以及 带线性核的 SVM。

library(caret)review_ted_model <- train(y ~., data = training_set_ted_talk, method = ‘svmLinear3’)Preparing our test data. It’s the same repetitive procedure.test_corpus <- VCorpus(VectorSource(test_dat$transcript))##Removing Punctuation
test_corpus <- tm_map(test_corpus, content_transformer(removePunctuation))##Removing numbers
test_corpus <- tm_map(test_corpus, removeNumbers)##Converting to lower case
test_corpus <- tm_map(test_corpus, content_transformer(tolower))##Removing stop words
test_corpus <- tm_map(test_corpus, content_transformer(removeWords), stopwords(“english”))##Stemming
test_corpus <- tm_map(test_corpus, stemDocument)##Whitespace
test_corpus <- tm_map(test_corpus, stripWhitespace)# Create Document Term Matrix
dtm_test <- DocumentTermMatrix(test_corpus)test_corpus <- removeSparseTerms(dtm_test, 0.4)dtm_test_matrix <- as.matrix(test_corpus)

模型准确性和其他指标

现在，我将根据测试数据检查我们的模型的准确性/性能。

#Build the prediction 
model_ted_talk_result <- predict(review_ted_model, newdata = dtm_test_matrix)check_accuracy <- as.data.frame(cbind(prediction = model_ted_talk_result, rating = test_dat$highest_rating))library(dplyr)
check_accuracy <- check_accuracy %>% mutate(prediction = as.integer(prediction) — 1)check_accuracy$accuracy <- if_else(check_accuracy$prediction == check_accuracy$rating, 1, 0)
round(prop.table(table(check_accuracy$accuracy)), 3)library(performanceEstimation)
classificationMetrics(as.integer(test_dat$highest_rating), model_ted_talk_result)most_common_misclassified_ratings = check_accuracy %>% filter(check_accuracy$accuracy == 0) %>%
 group_by(rating) %>%
 summarise(Count = n()) %>%
 arrange(desc(Count)) %>%
 head(3)##Most commong missclassified rating
levels(train_dat$highest_rating)[most_common_misclassified_ratings$rating]

模型指标包括:

Model metrics

前三个最常见的错误分类评级是:“鼓舞人心的”、“信息丰富的”、“引人入胜的”。你可以从这里和这里阅读更多关于微观和宏观 F1 分数。

结束语

在本文中，我们讨论了文本的多类分类。对我来说，解决这个数据问题相当具有挑战性，主要是因为:

我现在只处理二元分类问题
数据操作步骤导致每个单独的评级列的 13 个类。单引号破坏了看起来完美的 JSON 专栏。在没有任何直觉的情况下，找出单引号引起的问题是非常困难的。我最终设法用 gsub 解析了它。

最后，上面的模型分数严重依赖于我们在训练方法中使用的方法。我使用线性核 SVM 和 L2 正则化，这本身是计算量很大。您可以尝试其他方法，但是计算资源可能是一个问题。请让我知道你用的其他方法和你得到的分数(准确性和 F1)。

目前就这些。我将在下一篇博客中讨论一个与 NLP 相关的新任务。我也写过其他与软件工程相关的帖子。你可能想在这里查看它们。

多类文本分类模型的比较与选择

原文：https://towardsdatascience.com/multi-class-text-classification-model-comparison-and-selection-5eb066197568?source=collection_archive---------0-----------------------

Photo credit: Pixabay

自然语言处理，word2vec，支持向量机，词袋，深度学习

当使用给定的数据集处理监督机器学习问题时，我们尝试不同的算法和技术来搜索模型以产生一般假设，然后对未来实例做出最准确的预测。相同的原理适用于文本(或文档)分类，其中有许多模型可用于训练文本分类器。问题“我应该用什么机器学习模型”的答案总是“视情况而定”即使是最有经验的数据科学家也无法在试验之前判断哪种算法的性能最佳。

这就是我们今天要做的:使用我们在以前的文章(以及更多)中介绍的关于文本分类的所有内容，并在我们训练的文本分类模型之间进行比较，以便为我们的问题选择最准确的模型。

数据

我们使用的是堆栈溢出问题和标签的相对较大的数据集。这些数据可以在的 Google BigQuery 中找到，也可以在这个云存储 URL 上公开获得:https://Storage . Google APIs . com/tensor flow-workshop-examples/stack-overflow-data . CSV。

探索数据

explore

Figure 1

10276752

我们的数据中有超过 1000 万个单词。

my_tags = ['java','html','asp.net','c#','ruby-on-rails','jquery','mysql','php','ios','javascript','python','c','css','android','iphone','sql','objective-c','c++','angularjs','.net']
plt.figure(figsize=(10,4))
df.tags.value_counts().plot(kind='bar');

Figure 2

班级非常平衡。

我们想看看一些帖子和标签对。

def print_plot(index):
    example = df[df.index == index][['post', 'tags']].values[0]
    if len(example) > 0:
        print(example[0])
        print('Tag:', example[1])print_plot(10)

Figure 3

print_plot(30)

Figure 4

如你所见，文本需要清理。

文本预处理

到目前为止，我们看到的文本清理技术在实践中非常有效。根据您可能遇到的文本类型，可能需要包括更复杂的文本清理步骤。但是请记住，我们添加的步骤越多，文本清理需要的时间就越长。

对于这个特定的数据集，我们的文本清理步骤包括 HTML 解码、删除停用词、将文本改为小写、删除标点符号、删除不良字符等等。

clean_text

现在我们可以看看一个干净的帖子:

Figure 5

好多了。

df['post'].apply(lambda x: len(x.split(' '))).sum()

3421180

在文本清理和删除停用词后，我们只有 300 多万个单词可以使用！

分割数据集后，接下来的步骤包括特征工程。我们将把文本文档转换成令牌计数矩阵(CountVectorizer)，然后将计数矩阵转换成规范化的 tf-idf 表示(tf-idf transformer)。之后，我们从 Scikit-Learn 库中训练几个分类器。

X = df.post
y = df.tags
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state = 42)

多项式模型的朴素贝叶斯分类器

有了我们的特征之后，我们可以训练一个分类器来预测一篇文章的标签。我们将从一个朴素贝叶斯分类器开始，它为这个任务提供了一个很好的基线。scikit-learn包括该分类器的几种变体；最适合文本的是多项式变量。

为了使矢量器= >转换器= >分类器更容易使用，我们将在 Scilkit-Learn 中使用Pipeline类，它的行为类似于一个复合分类器。

Figure 6

我们达到了 74%的准确率。

线性支持向量机

线性支持向量机被广泛认为是最好的文本分类算法之一。

svm

Figure 7

我们获得了 79%的更高准确率，比朴素贝叶斯提高了 5%。

逻辑回归

Logistic 回归是一种简单易懂的分类算法，可以很容易地推广到多个类。

logreg

Figure 8

我们达到了 78%的准确率，比朴素贝叶斯高 4%，比 SVM 低 1%。

正如你所看到的，遵循一些非常基本的步骤并使用一个简单的线性模型，我们能够在这个多类文本分类数据集上达到高达 79%的准确率。

使用相同的数据集，我们将尝试一些高级技术，如单词嵌入和神经网络。

现在，让我们尝试一些复杂的功能，而不仅仅是简单地计算单词。

Word2vec 和逻辑回归

Word2vec 和 doc2vec 一样，属于文本预处理阶段。特别是将文本转换成一行数字的部分。Word2vec 是一种映射类型，它允许具有相似含义的单词具有相似的向量表示。

Word2vec 背后的想法相当简单:我们希望使用周围的单词，用神经网络来表示目标单词，神经网络的隐藏层对单词表示进行编码。

首先，我们加载一个 word2vec 模型。它已经由谷歌在一个1000 亿字的谷歌新闻语料库上进行了预训练。

from gensim.models import Word2Vecwv = gensim.models.KeyedVectors.load_word2vec_format("GoogleNews-vectors-negative300.bin.gz", binary=True)
wv.init_sims(replace=True)

我们可能想要探索一些词汇。

from itertools import islice
list(islice(wv.vocab, 13030, 13050))

Figure 9

基于 BOW 的方法，包括平均、求和、加权加法。常见的方法是对两个字向量进行平均。因此，我们将遵循最常见的方式。

word_averaging

我们将对文本进行标记化，并将标记化应用于“post”列，并将单词向量平均应用于标记化的文本。

w2v_tokenize_text

是时候看看逻辑回归分类器在这些单词平均文档特征上的表现了。

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression(n_jobs=1, C=1e5)
logreg = logreg.fit(X_train_word_average, train['tags'])
y_pred = logreg.predict(X_test_word_average)
print('accuracy %s' % accuracy_score(y_pred, test.tags))
print(classification_report(test.tags, y_pred,target_names=my_tags))

Figure 10

这很令人失望，是我们迄今为止看到的最糟糕的一次。

Doc2vec 和 Logistic 回归

word2vec 的相同想法可以扩展到文档，我们不是学习单词的特征表示，而是学习句子或文档的特征表示。为了对一个 word2vec 有个大概的了解，可以把它想象成文档中所有单词的单词向量表示的数学平均值。 Doc2Vec 扩展了 word2vec 的概念，然而单词只能捕捉这么多，有时我们需要文档之间的关系，而不仅仅是单词。

为我们的堆栈溢出问题和标签数据训练 doc2vec 模型的方式与我们用 Doc2vec 和逻辑回归训练多类文本分类时非常相似。

首先，我们给句子贴上标签。 Gensim 的 Doc2Vec 实现要求每个文档/段落都有一个与之关联的标签。我们通过使用TaggedDocument方法来做到这一点。格式为“TRAIN_i”或“TEST_i ”,其中“I”是帖子的虚拟索引。

label_sentences

根据 Gensim doc2vec 教程，它的 doc2vec 类是针对整个数据进行训练的，我们也会这样做。让我们看看带标签的文档是什么样子的:

all_data[:2]

Figure 11

当训练 doc2vec 时，我们将改变以下参数:

dm=0，使用分布式单词包(DBOW)。
vector_size=300，300 个向量维特征向量。
negative=5，指定要抽取多少个“干扰词”。
min_count=1，忽略总频率低于此的所有单词。
alpha=0.065，初始学习率。

我们初始化模型并训练 30 个时期。

train_doc2vec

接下来，我们从训练好的 doc2vec 模型中获取向量。

get_vectors

最后，我们得到一个由 doc2vec 特征训练的逻辑回归模型。

logreg = LogisticRegression(n_jobs=1, C=1e5)
logreg.fit(train_vectors_dbow, y_train)
logreg = logreg.fit(train_vectors_dbow, y_train)
y_pred = logreg.predict(test_vectors_dbow)
print('accuracy %s' % accuracy_score(y_pred, y_test))
print(classification_report(y_test, y_pred,target_names=my_tags))

Figure 12

我们达到了 80%的准确率，比 SVM 高出 1%。

用 Keras 鞠躬

最后，我们将使用 Python 深度学习库 Keras 进行文本分类。

下面的代码很大程度上取自谷歌的一个研讨会。过程是这样的:

将数据分成训练集和测试集。
使用tokenizer方法来统计我们词汇中的独特单词，并给每个单词分配索引。
调用fit_on_texts()自动创建我们词汇表的单词索引查找。
我们通过向记号赋予器传递一个num_words参数来限制我们的词汇到顶部的单词。
有了我们的标记器，我们现在可以使用texts_to_matrix方法来创建训练数据，我们将通过我们的模型。
我们给我们的模型输入一个热点向量。
将我们的特征和标签转换成 Keras 可以读取的格式后，我们就可以构建我们的文本分类模型了。
当我们构建模型时，我们需要做的就是告诉 Keras 我们的输入数据、输出数据的形状，以及每一层的类型。keras 会照看剩下的。
在训练模型时，我们将调用fit()方法，向它传递我们的训练数据和标签、批量大小和时期。

keras_training

Figure 13

精确度为:

score = model.evaluate(x_test, y_test,
                       batch_size=batch_size, verbose=1)
print('Test accuracy:', score[1])

Figure 14

那么，哪个模型最适合这个特定的数据集呢？我将让你来决定。

Jupyter 笔记本可以在 Github 上找到。祝你有丰富的一天！

参考资料:

https://github . com/RaRe-Technologies/movie-plots-by-genre/blob/master/ipynb _ with _ output/Document % 20 class ification % 20 with % 20 word % 20 embedding % 20 tutorial % 20-% 20 with % 20 output . ipynb

https://github . com/tensor flow/workshop/blob/master/extras/keras-bag-of-words/keras-bow-model . ipynb

https://data science . stack exchange . com/questions/20076/word 2 vec-vs-sentence 2 vec-vs-doc 2 vec

基于 Doc2Vec 和 Logistic 回归的多类文本分类

原文：https://towardsdatascience.com/multi-class-text-classification-with-doc2vec-logistic-regression-9da9947b43f4?source=collection_archive---------1-----------------------

Photo credit: Pexels

目标是使用 Doc2Vec 和逻辑回归将消费者金融投诉分为 12 个预定义的类别

Doc2vec 是一个 NLP 工具，用于将文档表示为一个向量，并且是 word2vec 方法的推广。

为了理解 doc2vec，最好理解 word2vec 方法。然而，完整的数学细节超出了本文的范围。如果您不熟悉 word2vec 和 doc2vec，以下资源可以帮助您入门:

单词和短语的分布式表示及其组合性
句子和文档的分布式表示
对 Doc2Vec 的温和介绍
关于 IMDB 情感数据集的 Gensim Doc2Vec 教程
带单词嵌入的文档分类教程

当我们使用 Scikit-Learn 进行多类文本分类时，使用相同的数据集，在本文中，我们将使用 Gensim 中的 doc2vec 技术按产品对投诉叙述进行分类。我们开始吧！

数据

目标是将消费者金融投诉分为 12 个预定义的类别。数据可以从 data.gov 下载。

import pandas as pd
import numpy as np
from tqdm import tqdm
tqdm.pandas(desc="progress-bar")
from gensim.models import Doc2Vec
from sklearn import utils
from sklearn.model_selection import train_test_split
import gensim
from sklearn.linear_model import LogisticRegression
from gensim.models.doc2vec import TaggedDocument
import re
import seaborn as sns
import matplotlib.pyplot as pltdf = pd.read_csv('Consumer_Complaints.csv')
df = df[['Consumer complaint narrative','Product']]
df = df[pd.notnull(df['Consumer complaint narrative'])]
df.rename(columns = {'Consumer complaint narrative':'narrative'}, inplace = True)
df.head(10)

Figure 1

在删除叙述列中的空值后，我们将需要重新索引数据框。

df.shape

(318718，2)

df.index = range(318718)df['narrative'].apply(lambda x: len(x.split(' '))).sum()

63420212

我们有超过 6300 万个单词，这是一个相对较大的数据集。

探索

cnt_pro = df['Product'].value_counts()plt.figure(figsize=(12,4))
sns.barplot(cnt_pro.index, cnt_pro.values, alpha=0.8)
plt.ylabel('Number of Occurrences', fontsize=12)
plt.xlabel('Product', fontsize=12)
plt.xticks(rotation=90)
plt.show();

Figure 2

这些分类是不平衡的，然而，一个简单的分类器预测所有的事情都是债务收集只会达到超过 20%的准确率。

让我们看几个投诉叙述及其相关产品的例子。

def print_complaint(index):
    example = df[df.index == index][['narrative', 'Product']].values[0]
    if len(example) > 0:
        print(example[0])
        print('Product:', example[1])print_complaint(12)

Figure 3

print_complaint(20)

Figure 4

文本预处理

下面我们定义一个函数来将文本转换成小写，并从单词中去掉标点/符号等等。

from bs4 import BeautifulSoup
def cleanText(text):
    text = BeautifulSoup(text, "lxml").text
    text = re.sub(r'\|\|\|', r' ', text) 
    text = re.sub(r'http\S+', r'<URL>', text)
    text = text.lower()
    text = text.replace('x', '')
    return text
df['narrative'] = df['narrative'].apply(cleanText)

以下步骤包括 70/30 的训练/测试分割，删除停用词并使用 NLTK 标记器标记文本。在我们的第一次尝试中，我们将每个投诉叙述都贴上了产品标签。

train, test = train_test_split(df, test_size=0.3, random_state=42)import nltk
from nltk.corpus import stopwords
def tokenize_text(text):
    tokens = []
    for sent in nltk.sent_tokenize(text):
        for word in nltk.word_tokenize(sent):
            if len(word) < 2:
                continue
            tokens.append(word.lower())
    return tokenstrain_tagged = train.apply(
    lambda r: TaggedDocument(words=tokenize_text(r['narrative']), tags=[r.Product]), axis=1)
test_tagged = test.apply(
    lambda r: TaggedDocument(words=tokenize_text(r['narrative']), tags=[r.Product]), axis=1)

这就是培训条目的样子——一个带有“信用报告”标签的投诉叙述示例。

train_tagged.values[30]

Figure 5

建立 Doc2Vec 培训和评估模型

首先，我们实例化一个 doc2vec 模型——分布式单词包(DBOW)。在 word2vec 架构中，两个算法名分别是“连续字包”(CBOW)和“skip-gram”(SG)；在 doc2vec 架构中，对应的算法是“分布式内存”(DM)和“分布式单词包”(DBOW)。

分布式单词包(DBOW)

DBOW 是 doc2vec 模型，类似于 word2vec 中的 Skip-gram 模型。段落向量是通过训练神经网络来获得的，该神经网络的任务是在给定从段落中随机采样的单词的情况下，预测段落中单词的概率分布。

我们将改变以下参数:

如果dm=0，使用分布式单词包(PV-DBOW)；如果dm=1，则使用‘分布式内存’(PV-DM)。
300 维特征向量。
min_count=2，忽略总频率低于此的所有单词。
negative=5，指定需要抽取多少个“干扰词”。
hs=0，且负数为非零，将使用负数采样。
sample=0，用于配置哪些高频词被随机下采样的阈值。
使用这些工作线程来训练模型。

import multiprocessingcores = multiprocessing.cpu_count()

积累词汇

model_dbow = Doc2Vec(dm=0, vector_size=300, negative=5, hs=0, min_count=2, sample = 0, workers=cores)
model_dbow.build_vocab([x for x in tqdm(train_tagged.values)])

Figure 6

在 Gensim 中训练 doc2vec 模型相当简单，我们初始化模型并训练 30 个时期。

%%time
for epoch in range(30):
    model_dbow.train(utils.shuffle([x for x in tqdm(train_tagged.values)]), total_examples=len(train_tagged.values), epochs=1)
    model_dbow.alpha -= 0.002
    model_dbow.min_alpha = model_dbow.alpha

Figure 7

为分类器构建最终矢量特征

def vec_for_learning(model, tagged_docs):
    sents = tagged_docs.values
    targets, regressors = zip(*[(doc.tags[0], model.infer_vector(doc.words, steps=20)) for doc in sents])
    return targets, regressorsdef vec_for_learning(model, tagged_docs):
    sents = tagged_docs.values
    targets, regressors = zip(*[(doc.tags[0], model.infer_vector(doc.words, steps=20)) for doc in sents])
    return targets, regressors

训练逻辑回归分类器。

y_train, X_train = vec_for_learning(model_dbow, train_tagged)
y_test, X_test = vec_for_learning(model_dbow, test_tagged)logreg = LogisticRegression(n_jobs=1, C=1e5)
logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)from sklearn.metrics import accuracy_score, f1_scoreprint('Testing accuracy %s' % accuracy_score(y_test, y_pred))
print('Testing F1 score: {}'.format(f1_score(y_test, y_pred, average='weighted')))

检测精度 0.6683609437751004

测试 F1 分数:0.651646431211616

分布式内存(DM)

分布式记忆(DM)作为一种记忆，可以记住当前上下文中缺少的内容，或者段落的主题。虽然单词向量表示单词的概念，但是文档向量旨在表示文档的概念。我们再次实例化具有 300 个单词的向量大小的 Doc2Vec 模型，并且在训练语料库上迭代 30 次。

model_dmm = Doc2Vec(dm=1, dm_mean=1, vector_size=300, window=10, negative=5, min_count=1, workers=5, alpha=0.065, min_alpha=0.065)
model_dmm.build_vocab([x for x in tqdm(train_tagged.values)])

Figure 8

%%time
for epoch in range(30):
    model_dmm.train(utils.shuffle([x for x in tqdm(train_tagged.values)]), total_examples=len(train_tagged.values), epochs=1)
    model_dmm.alpha -= 0.002
    model_dmm.min_alpha = model_dmm.alpha

Figure 9

训练逻辑回归分类器

y_train, X_train = vec_for_learning(model_dmm, train_tagged)
y_test, X_test = vec_for_learning(model_dmm, test_tagged)logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)print('Testing accuracy %s' % accuracy_score(y_test, y_pred))
print('Testing F1 score: {}'.format(f1_score(y_test, y_pred, average='weighted')))

检测精度 0.47498326639892907

测试 F1 分数:0.4445833078167434

模型配对

根据关于 IMDB 情感数据集的 Gensim doc2vec 教程，将来自分布式单词包(DBOW)和分布式内存(DM)的段落向量相结合可以提高性能。我们将随后将模型配对在一起进行评估。

首先，我们删除临时训练数据来释放 RAM。

model_dbow.delete_temporary_training_data(keep_doctags_vectors=True, keep_inference=True)
model_dmm.delete_temporary_training_data(keep_doctags_vectors=True, keep_inference=True)

连接两个模型。

from gensim.test.test_doc2vec import ConcatenatedDoc2Vec
new_model = ConcatenatedDoc2Vec([model_dbow, model_dmm])

构建特征向量。

def get_vectors(model, tagged_docs):
    sents = tagged_docs.values
    targets, regressors = zip(*[(doc.tags[0], model.infer_vector(doc.words, steps=20)) for doc in sents])
    return targets, regressors

训练逻辑回归

y_train, X_train = get_vectors(new_model, train_tagged)
y_test, X_test = get_vectors(new_model, test_tagged)logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)print('Testing accuracy %s' % accuracy_score(y_test, y_pred))
print('Testing F1 score: {}'.format(f1_score(y_test, y_pred, average='weighted')))

检测精度 0.6778572623828648

测试 F1 分数:0.664561533967402

结果提高了 1%。

对于本文，我使用训练集来训练 doc2vec，然而，在 Gensim 的教程中，整个数据集用于训练，我尝试了这种方法，使用整个数据集来训练 doc2vec 分类器，用于我们的消费者投诉分类，我能够达到 70%的准确率。你可以在这里找到那个笔记本，它的做法有点不同。

用于上述分析的 Jupyter 笔记本可以在 Github 上找到。我期待听到任何问题。

基于 PySpark 的多类文本分类

原文：https://towardsdatascience.com/multi-class-text-classification-with-pyspark-7d78d022ed35?source=collection_archive---------2-----------------------

Photo credit: Pixabay

Apache Spark 在头条新闻和现实世界中的采用率都迅速上升，这主要是因为它处理流媒体数据的能力。由于每天都有如此多的数据需要处理，因此对我们来说，实时传输和分析这些数据变得至关重要。此外，Apache Spark 足够快，无需采样就可以执行探索性查询。许多行业专家提供了所有的理由为什么你应该使用 Spark 进行机器学习？

所以，我们现在在这里，使用 Spark 机器学习库来解决一个多类文本分类问题，特别是 PySpark。

如果你想看看用 Scikit-Learn 的实现，请阅读以前的文章。

数据

我们的任务是将旧金山的犯罪描述分为 33 个预定义的类别。数据可以从 Kaggle 下载。

给定一个新的犯罪描述，我们希望将其分配到 33 个类别中的一个。分类器假设每个新的犯罪描述被分配到一个且仅一个类别。这是多类文本分类问题。

输入:描述

例如:“被盗汽车”

输出:类别

示例:车辆盗窃

为了解决这个问题，我们将在 Spark 中使用各种特征提取技术以及不同的监督机器学习算法。我们开始吧！

数据摄取和提取

使用 Spark csv 包加载 CSV 文件非常简单。

from pyspark.sql import SQLContext
from pyspark import SparkContext
sc =SparkContext()
sqlContext = SQLContext(sc)data = sqlContext.read.format('com.databricks.spark.csv').options(header='true', inferschema='true').load('train.csv')

就是这样！我们已经加载了数据集。我们开始探索吧。

删除我们不需要的列，看看前五行:

drop_list = ['Dates', 'DayOfWeek', 'PdDistrict', 'Resolution', 'Address', 'X', 'Y']data = data.select([column for column in data.columns if column not in drop_list])
data.show(5)

Figure 1

对数据应用 printSchema()，这将以树格式打印模式:

data.printSchema()

Figure 2

20 大犯罪类别:

from pyspark.sql.functions import coldata.groupBy("Category") \
    .count() \
    .orderBy(col("count").desc()) \
    .show()

Figure 3

20 大犯罪描述:

data.groupBy("Descript") \
    .count() \
    .orderBy(col("count").desc()) \
    .show()

Figure 4

模型管道

Spark 机器学习管道 API 类似于 Scikit-Learn 。我们的渠道包括三个步骤:

regexTokenizer:标记化(使用正则表达式)
stopwordsRemover:删除停用词
countVectors:计数向量(“文档术语向量”)

from pyspark.ml.feature import RegexTokenizer, StopWordsRemover, CountVectorizer
from pyspark.ml.classification import LogisticRegression# regular expression tokenizer
regexTokenizer = RegexTokenizer(inputCol="Descript", outputCol="words", pattern="\\W")# stop words
add_stopwords = ["http","https","amp","rt","t","c","the"] stopwordsRemover = StopWordsRemover(inputCol="words", outputCol="filtered").setStopWords(add_stopwords)# bag of words count
countVectors = CountVectorizer(inputCol="filtered", outputCol="features", vocabSize=10000, minDF=5)

StringIndexer

StringIndexer将一列标签编码成一列标签索引。索引在[0, numLabels)中，按照标签频率排序，因此最频繁的标签得到索引0。

在我们的例子中，标签列(类别)将被编码为标签索引，从 0 到 32；最频繁的标签(盗窃/偷窃)将被索引为 0。

from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoder, StringIndexer, VectorAssembler
label_stringIdx = StringIndexer(inputCol = "Category", outputCol = "label")pipeline = Pipeline(stages=[regexTokenizer, stopwordsRemover, countVectors, label_stringIdx])# Fit the pipeline to training documents.
pipelineFit = pipeline.fit(data)
dataset = pipelineFit.transform(data)
dataset.show(5)

Figure 5

分区训练&测试集

# set seed for reproducibility
(trainingData, testData) = dataset.randomSplit([0.7, 0.3], seed = 100)
print("Training Dataset Count: " + str(trainingData.count()))
print("Test Dataset Count: " + str(testData.count()))

训练数据集计数:5185
测试数据集计数:2104

模型训练和评估

使用计数向量特征的逻辑回归

我们的模型将在测试集上进行预测和评分；然后，我们从最高概率的角度来看前 10 个预测。

lr = LogisticRegression(maxIter=20, regParam=0.3, elasticNetParam=0)
lrModel = lr.fit(trainingData)predictions = lrModel.transform(testData)predictions.filter(predictions['prediction'] == 0) \
    .select("Descript","Category","probability","label","prediction") \
    .orderBy("probability", ascending=False) \
    .show(n = 10, truncate = 30)

Figure 6

from pyspark.ml.evaluation import MulticlassClassificationEvaluator
evaluator = MulticlassClassificationEvaluator(predictionCol="prediction")
evaluator.evaluate(predictions)

0.9610787444388802

准确度极好！

使用 TF-IDF 特征的逻辑回归

from pyspark.ml.feature import HashingTF, IDFhashingTF = HashingTF(inputCol="filtered", outputCol="rawFeatures", numFeatures=10000)
idf = IDF(inputCol="rawFeatures", outputCol="features", minDocFreq=5) #minDocFreq: remove sparse terms
pipeline = Pipeline(stages=[regexTokenizer, stopwordsRemover, hashingTF, idf, label_stringIdx])pipelineFit = pipeline.fit(data)
dataset = pipelineFit.transform(data)(trainingData, testData) = dataset.randomSplit([0.7, 0.3], seed = 100)
lr = LogisticRegression(maxIter=20, regParam=0.3, elasticNetParam=0)
lrModel = lr.fit(trainingData)predictions = lrModel.transform(testData)predictions.filter(predictions['prediction'] == 0) \
    .select("Descript","Category","probability","label","prediction") \
    .orderBy("probability", ascending=False) \
    .show(n = 10, truncate = 30)

Figure 7

evaluator = MulticlassClassificationEvaluator(predictionCol="prediction")
evaluator.evaluate(predictions)

0.9616202660247297

结果是一样的。

交叉验证

现在让我们尝试交叉验证来调整我们的超参数，我们将只调整计数向量逻辑回归。

pipeline = Pipeline(stages=[regexTokenizer, stopwordsRemover, countVectors, label_stringIdx])pipelineFit = pipeline.fit(data)
dataset = pipelineFit.transform(data)
(trainingData, testData) = dataset.randomSplit([0.7, 0.3], seed = 100)lr = LogisticRegression(maxIter=20, regParam=0.3, elasticNetParam=0)from pyspark.ml.tuning import ParamGridBuilder, CrossValidator# Create ParamGrid for Cross Validation
paramGrid = (ParamGridBuilder()
             .addGrid(lr.regParam, [0.1, 0.3, 0.5]) # regularization parameter
             .addGrid(lr.elasticNetParam, [0.0, 0.1, 0.2]) # Elastic Net Parameter (Ridge = 0)
#            .addGrid(model.maxIter, [10, 20, 50]) #Number of iterations
#            .addGrid(idf.numFeatures, [10, 100, 1000]) # Number of features
             .build())# Create 5-fold CrossValidator
cv = CrossValidator(estimator=lr, \
                    estimatorParamMaps=paramGrid, \
                    evaluator=evaluator, \
                    numFolds=5)cvModel = cv.fit(trainingData)

predictions = cvModel.transform(testData)
# Evaluate best model
evaluator = MulticlassClassificationEvaluator(predictionCol="prediction")
evaluator.evaluate(predictions)

0.9851796929217101

性能提高了。

朴素贝叶斯

from pyspark.ml.classification import NaiveBayesnb = NaiveBayes(smoothing=1)
model = nb.fit(trainingData)predictions = model.transform(testData)
predictions.filter(predictions['prediction'] == 0) \
    .select("Descript","Category","probability","label","prediction") \
    .orderBy("probability", ascending=False) \
    .show(n = 10, truncate = 30)

Figure 8

evaluator = MulticlassClassificationEvaluator(predictionCol="prediction")
evaluator.evaluate(predictions)

0.962541462988848

随机森林

from pyspark.ml.classification import RandomForestClassifierrf = RandomForestClassifier(labelCol="label", \
                            featuresCol="features", \
                            numTrees = 100, \
                            maxDepth = 4, \
                            maxBins = 32)# Train model with Training Data
rfModel = rf.fit(trainingData)predictions = rfModel.transform(testData)predictions.filter(predictions['prediction'] == 0) \
    .select("Descript","Category","probability","label","prediction") \
    .orderBy("probability", ascending=False) \
    .show(n = 10, truncate = 30)

Figure 9

evaluator = MulticlassClassificationEvaluator(predictionCol="prediction")
evaluator.evaluate(predictions)

0.6600326922344301

随机森林是一种非常好的、健壮的和通用的方法，但是对于高维稀疏数据来说，它不是最佳选择，这并不奇怪。

显然，逻辑回归将是我们在这个实验中的模型，具有交叉验证。

这就把我们带到了文章的结尾。创建这篇文章的源代码可以在 Github 上找到。我期待听到任何反馈或问题。

使用 Scikit-Learn 进行多类文本分类

原文：https://towardsdatascience.com/multi-class-text-classification-with-scikit-learn-12f1e60e0a9f?source=collection_archive---------0-----------------------

Image credit: pexels

文本分类在商业领域有很多应用。例如，新闻故事通常是按主题组织的；内容或产品通常按类别进行标记；用户可以根据他们在网上谈论产品或品牌的方式进行分类…

但是网上绝大多数的文本分类文章和教程都是邮件垃圾过滤(spam vs. ham)、情感分析(正面 vs .负面)等二元文本分类。在大多数情况下，我们现实世界的问题要比这复杂得多。因此，这就是我们今天要做的事情:将消费金融投诉分为 12 个预定义的类别。数据可以从data.gov下载。

我们使用 Python 和 Jupyter Notebook 来开发我们的系统，依靠 Scikit-Learn 作为机器学习组件。如果您想在 PySpark 中看到实现，请阅读下一篇文章。

问题定式化

该问题是有监督的文本分类问题，我们的目标是调查哪些有监督的机器学习方法最适合解决它。

假设有新的投诉进来，我们希望将其分配到 12 个类别中的一个。分类器假设每个新投诉被分配到一个且仅一个类别。这是多类文本分类问题。我迫不及待地想看看我们能实现什么！

数据探索

在开始训练机器学习模型之前，我们应该先看看一些例子和每个类中的投诉数量:

import pandas as pd
df = pd.read_csv('Consumer_Complaints.csv')
df.head()

Figure 1

对于这个项目，我们只需要两列—“产品”和“消费者投诉叙述”。

输入:消费者 _ 投诉 _ 叙述

例如:“我的信用报告中有过时的信息，我以前质疑过这些信息，但现在还没有删除。这些信息已经存在了七年多，不符合信用报告要求”

输出:产品

例如:信用报告

我们将删除“消费者投诉叙述”列中缺少的值，并添加一个将产品编码为整数的列，因为分类变量通常用整数表示比用字符串表示更好。

我们还创建了几个字典供将来使用。

清理之后，这是我们将要处理的前五行数据:

from io import StringIOcol = ['Product', 'Consumer complaint narrative']
df = df[col]
df = df[pd.notnull(df['Consumer complaint narrative'])]df.columns = ['Product', 'Consumer_complaint_narrative']df['category_id'] = df['Product'].factorize()[0]
category_id_df = df[['Product', 'category_id']].drop_duplicates().sort_values('category_id')
category_to_id = dict(category_id_df.values)
id_to_category = dict(category_id_df[['category_id', 'Product']].values)
df.head()

Figure 2

不平衡的班级

我们看到每个产品的投诉数量不平衡。消费者的投诉更偏向于催债、征信、房贷。

import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
df.groupby('Product').Consumer_complaint_narrative.count().plot.bar(ylim=0)
plt.show()

Figure 3

当我们遇到这样的问题时，我们必然很难用标准算法来解决它们。传统算法往往偏向于多数类，没有考虑数据分布。在最坏的情况下，少数类被视为离群值并被忽略。对于某些情况，如欺诈检测或癌症预测，我们需要仔细配置我们的模型或人工平衡数据集，例如通过对每个类进行欠采样或过采样。

然而，在我们学习不平衡数据的情况下，多数类可能是我们最感兴趣的。希望有一种对多数类给出高预测精度，同时对少数类保持合理精度的分类器。因此，我们将保持原样。

文本表示

分类器和学习算法不能直接处理原始形式的文本文档，因为它们中的大多数期望具有固定大小的数字特征向量，而不是具有可变长度的原始文本文档。因此，在预处理步骤中，文本被转换成更易于管理的表示。

从文本中提取特征的一种常见方法是使用单词袋模型:在该模型中，对于每个文档(在我们的情况下是投诉叙述)，考虑单词的存在(通常是频率)，但忽略它们出现的顺序。

具体来说，对于数据集中的每个术语，我们将计算一个称为术语频率的度量，即逆文档频率，缩写为 tf-idf。我们将使用sklearn.feature_extraction.text.TfidfVectorizer 来计算每个消费者投诉叙述的tf-idf向量:

sublinear_df设置为True以使用对数形式的频率。
min_df是一个单词必须存在的最小文档数。
norm被设置为l2，以确保我们所有的特征向量具有 1 的欧几里德范数。
ngram_range被设置为(1, 2),表示我们既要考虑单元组，也要考虑二元组。
stop_words设置为"english"删除所有常用代词("a"，"the"，...)以减少噪声特征的数量。

from sklearn.feature_extraction.text import TfidfVectorizertfidf = TfidfVectorizer(sublinear_tf=True, min_df=5, norm='l2', encoding='latin-1', ngram_range=(1, 2), stop_words='english')features = tfidf.fit_transform(df.Consumer_complaint_narrative).toarray()
labels = df.category_id
features.shape

(4569, 12633)

现在，4569 个消费者投诉叙述中的每一个都由 12633 个特征表示，代表不同单字和双字的 tf-idf 得分。

我们可以使用sklearn.feature_selection.chi2找到与每种产品最相关的术语:

from sklearn.feature_selection import chi2
import numpy as npN = 2
for Product, category_id in sorted(category_to_id.items()):
  features_chi2 = chi2(features, labels == category_id)
  indices = np.argsort(features_chi2[0])
  feature_names = np.array(tfidf.get_feature_names())[indices]
  unigrams = [v for v in feature_names if len(v.split(' ')) == 1]
  bigrams = [v for v in feature_names if len(v.split(' ')) == 2]
  print("# '{}':".format(Product))
  print("  . Most correlated unigrams:\n. {}".format('\n. '.join(unigrams[-N:])))
  print("  . Most correlated bigrams:\n. {}".format('\n. '.join(bigrams[-N:])))

' 银行账户或服务 ':

。最相关的单字:
。银行
。透支
。最相关的二元模型:
。透支费
。支票账户

' 消费贷款 ':

。最相关的单字:
。汽车
。车辆
。最相关的二元模型:
。车辆 xxxx
。丰田金融

' 信用卡 ':

。最相关的单字:
。花旗
。卡片
。最相关的二元模型:
。年费
。信用卡

' 征信 ':

。最相关的单字:
。experian
。equifax
。最相关的二元模型:
。跨联
。征信报告
#’讨债:
。最相关的单字:
。收藏
。债务
。最相关的二元模型:
。讨债
。代收机构
#’汇款’:
。最相关的单字:
。吴
。贝宝
。最相关的二元模型:
。西联
。转账

' 抵押 ':

。最相关的单字:
。修改
。抵押
。最相关二元模型:
。抵押公司
。贷款修改

' 其他金融服务 ':

。最相关的单字:
。牙科
。护照
。最相关二元模型:
。帮付
。声明支付

' 发薪日贷款 ':

。最相关的单字:
。借来的
。发薪日
。最相关二元模型:
。大图
。发薪日贷款

' 预付卡 ':

。最相关的单字:
。上菜
。预付
。最相关二元模型:
。存取款
。预付卡

' 助学贷款 ':

。最相关的单字:
。学生
。导航
。最相关的二元模型:
。助学贷款
。助学贷款
#‘虚拟货币‘:
。最相关的单字:
。手柄
。https
。最相关二元模型:
。xxxx 供应商
。缺钱

他们都有道理，你不这样认为吗？

多类分类器:特征与设计

为了训练监督分类器，我们首先将“消费者投诉叙述”转换成数字向量。我们研究了向量表示，如 TF-IDF 加权向量。
有了这种文本的向量表示后，我们可以训练监督分类器来训练看不见的“消费者投诉叙述”，并预测它们所涉及的“产品”。

在所有上述数据转换之后，现在我们已经有了所有的特征和标签，是时候训练分类器了。对于这类问题，我们可以使用许多算法。

朴素贝叶斯分类器:最适合字数统计的一个是多项式变量:

from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.naive_bayes import MultinomialNBX_train, X_test, y_train, y_test = train_test_split(df['Consumer_complaint_narrative'], df['Product'], random_state = 0)
count_vect = CountVectorizer()
X_train_counts = count_vect.fit_transform(X_train)
tfidf_transformer = TfidfTransformer()
X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)clf = MultinomialNB().fit(X_train_tfidf, y_train)

拟合完训练集之后，我们来做一些预测。

print(clf.predict(count_vect.transform(["This company refuses to provide me verification and validation of debt per my right under the FDCPA. I do not believe this debt is mine."])))

['讨债']

df[df['Consumer_complaint_narrative'] == "This company refuses to provide me verification and validation of debt per my right under the FDCPA. I do not believe this debt is mine."]

Figure 4

print(clf.predict(count_vect.transform(["I am disputing the inaccurate information the Chex-Systems has on my credit report. I initially submitted a police report on XXXX/XXXX/16 and Chex Systems only deleted the items that I mentioned in the letter and not all the items that were actually listed on the police report. In other words they wanted me to say word for word to them what items were fraudulent. The total disregard of the police report and what accounts that it states that are fraudulent. If they just had paid a little closer attention to the police report I would not been in this position now and they would n't have to research once again. I would like the reported information to be removed : XXXX XXXX XXXX"])))

['信用报告']

df[df['Consumer_complaint_narrative'] == "I am disputing the inaccurate information the Chex-Systems has on my credit report. I initially submitted a police report on XXXX/XXXX/16 and Chex Systems only deleted the items that I mentioned in the letter and not all the items that were actually listed on the police report. In other words they wanted me to say word for word to them what items were fraudulent. The total disregard of the police report and what accounts that it states that are fraudulent. If they just had paid a little closer attention to the police report I would not been in this position now and they would n't have to research once again. I would like the reported information to be removed : XXXX XXXX XXXX"]

Figure 5

不算太寒酸！

型号选择

我们现在准备用不同的机器学习模型进行实验，评估它们的准确性，并找到任何潜在问题的来源。

我们将对以下四个模型进行基准测试:

逻辑回归
(多项式)朴素贝叶斯
线性支持向量机
随机森林

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import LinearSVCfrom sklearn.model_selection import cross_val_scoremodels = [
    RandomForestClassifier(n_estimators=200, max_depth=3, random_state=0),
    LinearSVC(),
    MultinomialNB(),
    LogisticRegression(random_state=0),
]
CV = 5
cv_df = pd.DataFrame(index=range(CV * len(models)))
entries = []
for model in models:
  model_name = model.__class__.__name__
  accuracies = cross_val_score(model, features, labels, scoring='accuracy', cv=CV)
  for fold_idx, accuracy in enumerate(accuracies):
    entries.append((model_name, fold_idx, accuracy))
cv_df = pd.DataFrame(entries, columns=['model_name', 'fold_idx', 'accuracy'])import seaborn as snssns.boxplot(x='model_name', y='accuracy', data=cv_df)
sns.stripplot(x='model_name', y='accuracy', data=cv_df, 
              size=8, jitter=True, edgecolor="gray", linewidth=2)
plt.show()

Figure 6

cv_df.groupby('model_name').accuracy.mean()

model _ Name
**linear SVC:**0.822890
**logistic regression:**0.792927
**MultinomialNB:**0.688519
**RandomForestClassifier:**0.443826
Name:accuracy，dtype: float64

LinearSVC 和逻辑回归比其他两个分类器表现得更好，LinearSVC 以大约 82%的中值精度略微占优。

模型评估

继续我们的最佳模型(LinearSVC)，我们将查看混淆矩阵，并显示预测和实际标签之间的差异。

model = LinearSVC()X_train, X_test, y_train, y_test, indices_train, indices_test = train_test_split(features, labels, df.index, test_size=0.33, random_state=0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)from sklearn.metrics import confusion_matrixconf_mat = confusion_matrix(y_test, y_pred)
fig, ax = plt.subplots(figsize=(10,10))
sns.heatmap(conf_mat, annot=True, fmt='d',
            xticklabels=category_id_df.Product.values, yticklabels=category_id_df.Product.values)
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()

Figure 7

绝大多数预测最终出现在对角线上(预测标签=实际标签)，这是我们希望它们出现的位置。但是，存在许多错误分类，看看这些错误分类是由什么引起的可能会很有意思:

from IPython.display import displayfor predicted in category_id_df.category_id:
  for actual in category_id_df.category_id:
    if predicted != actual and conf_mat[actual, predicted] >= 10:
      print("'{}' predicted as '{}' : {} examples.".format(id_to_category[actual], id_to_category[predicted], conf_mat[actual, predicted]))
      display(df.loc[indices_test[(y_test == actual) & (y_pred == predicted)]][['Product', 'Consumer_complaint_narrative']])
      print('')

Figure 8

Figure 9

如您所见，一些错误分类的投诉涉及多个主题(例如，涉及信用卡和信用报告的投诉)。这种错误总是会发生。

同样，我们使用卡方检验来查找与每个类别最相关的术语:

model.fit(features, labels)N = 2
for Product, category_id in sorted(category_to_id.items()):
  indices = np.argsort(model.coef_[category_id])
  feature_names = np.array(tfidf.get_feature_names())[indices]
  unigrams = [v for v in reversed(feature_names) if len(v.split(' ')) == 1][:N]
  bigrams = [v for v in reversed(feature_names) if len(v.split(' ')) == 2][:N]
  print("# '{}':".format(Product))
  print("  . Top unigrams:\n       . {}".format('\n       . '.join(unigrams)))
  print("  . Top bigrams:\n       . {}".format('\n       . '.join(bigrams)))

' 银行账户或服务 ':

。Top unigrams:
。银行
。账户
。Top bigrams:
。借记卡
。透支费

' 消费贷款 ':

。顶级单字:
。车辆
。汽车
。热门二元模型:
。个人贷款
。历史 xxxx

' 信用卡 ':

。顶级单字:
。卡片
。发现
。顶级双元:
。信用卡
。发现卡

' 征信 ':

。Top unigrams:
。equifax
。跨联
。Top bigrams:
。xxxx 账户
。跨联

' 讨债 ':

。Top unigrams:
。债务
。收藏
。顶级名人:
。账户贷记
。提供时间
#’汇款’:
。Top unigrams:
。贝宝
。传送
。Top bigrams:
。汇款
。送钱
#‘抵押‘:
。Top unigrams:
。抵押
。托管
。Top bigrams:
。贷款修改
。抵押公司

' 其他金融服务 ':

。Top unigrams:
。护照
。牙科
。Top bigrams:
。规定薪酬
。帮助支付

' 发薪日贷款 ':

。Top unigrams:
。发薪日
。贷款
。Top bigrams:
。发薪日贷款
。发薪日
#‘预付卡‘:
。Top unigrams:
。预付
。上菜
。顶级双面人物:
。预付卡
。用卡
#‘助学贷款‘:
。Top unigrams:
。导航
。贷款
。Top bigrams:
。助学贷款
。莎莉美

' 虚拟货币 ':

。Top unigrams:
。https
。tx
。顶级双元:
。钱要
。xxxx 提供商

它们符合我们的预期。

最后，我们打印出每个类别的分类报告:

from sklearn import metrics
print(metrics.classification_report(y_test, y_pred, target_names=df['Product'].unique()))

Figure 9

源代码可以在 Github 上找到。我期待听到任何反馈或问题。

用 python 中的 SKlearn 和 NLTK 实现多类文本分类|一个软件工程用例

原文：https://towardsdatascience.com/multi-class-text-classification-with-sklearn-and-nltk-in-python-a-software-engineering-use-case-779d4a28ba5?source=collection_archive---------1-----------------------

photo credit: unsplash

最近，我从事一个软件工程研究项目。该项目的主要目标之一是了解开发团队的工作重点。当软件项目的规模变大时，管理工作流和开发过程变得更具挑战性。因此，对于管理团队和主要开发人员来说，理解软件开发人员执行的工作类型是非常重要的。

更简单地说，在项目的不同阶段，任何开发人员都可以随时编写代码来实现以下目标之一:

添加新功能
设计改进
错误修复
改进非功能性需求

现在有人可能会问，以上四个类别是开发人员完成的软件开发活动的唯一类型吗？答案是:不。这里的目标是提出一些包含大部分开发任务的通用工作类别。

了解开发团队的工作是如何根据上述四个类别进行分配的，可以帮助管理层在持续开发软件功能的同时，在管理软件增长方面做出更好的决策。例如，如果开发团队的大部分工作都是为了修复 bug，那么管理层可以采取必要的措施来防止软件中的错误和缺陷，并为主要开发人员提供指导方针，让他们更加关注质量。

问题是:

所以主要问题是:我们如何通过查看源代码来对开发人员的工作进行分类？

答案是:我们可以查看提交消息；开发人员提供一个提交消息以及他们对存储库的每一次提交。这些提交消息通常使用自然语言编写，并且通常传达一些关于它们所表示的提交的信息。我们可以使用一些标记的数据构建一个分类器，然后自动对未来的提交进行分类。

if I had a dollar for every commit … !!!

数据工程:

我们从 github 上的几个开源 Java 项目中收集了大约 4000 条提交消息。我们使用基于每个类别的特定关键字的高级搜索标准来挑选提交消息。然后，我们将每一类提交消息分配给有经验的开发人员，让他们逐一检查提交是否属于他们的类别。之后，我们通过在开发人员之间交换提交消息的类别来交叉检查流程，以减轻手动标记带来的主观性。最后，我们得到了将近 3400 条提交消息，包括 282 条不属于任何类别的提交；我们决定在分类任务中添加一个标签，这样以后我们就可以检测到类似的提交消息。

分类:

让我们来看看数据:

import pandas as pd
import re
import numpy as np
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.pipeline import Pipeline
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.feature_selection import SelectKBest, chi2
from sqlite3 import Error
from sklearn.ensemble import RandomForestClassifier
import sqlite3
import pickle
%matplotlib inlinetry:
    conn = sqlite3.connect("training_V2.db")
except Error as e:
    print(e)#reading the data from the table that contains the labels 
df = pd.read_sql_query('SELECT * FROM filtered', conn)
df.drop(['id'], 1, inplace=True)
df.head()

如你所见，我们导入了如此多的包，我们将使用它们来实现我们的目标。查看数据帧的前五行，我们可以看到它只有两列:文本(提交消息)和类(标签)。

1 表示用于修复错误的提交消息。
2 表示不属于任何类别的提交。
3 代表设计改进的提交消息。
4 表示用于添加新特征的提交消息。
5 表示用于改进非功能性需求的提交消息。

让我们看看它们的分布情况:

df.groupby('class').text.count().plot.bar(ylim=0)
plt.show()

数据集中有一点不平衡是很自然的，因为提交是从随机的开源项目中随机收集的。

现在让我们建立我们的分类器。但是等等……我们的数据是自然文本，但是需要格式化成列结构，以便作为分类算法的输入。

它是这样工作的:

文本预处理:

首先，我们从每个提交消息中删除标点、数字和停用词。
其次，所有的单词都被转换成小写，然后使用 NLTK 包中的斯特梅尔进行词干分析。词干提取的目标是减少提交中出现的单词的屈折形式的数量；它将通过将诸如“performance”和“performing”这样的词简化为它们的基本词“perform”来使它们在句法上相互匹配。这有助于减少词汇空间的大小，并提高语料库中特征空间的容量。
最后，使用 Python 的 SKlearn 包中的 tf-idf 矢量器将每个语料库转换为向量空间模型(VSM)来提取特征。

所有这些都是用几行代码完成的，这就是 python 的魅力所在。

stemmer = PorterStemmer()
words = stopwords.words("english")df['cleaned'] = df['text'].apply(lambda x: " ".join([stemmer.stem(i) for i in re.sub("[^a-zA-Z]", " ", x).split() if i not in words]).lower())

vectorizer = TfidfVectorizer(min_df= 3, stop_words="english", sublinear_tf=True, norm='l2', ngram_range=(1, 2))
final_features = vectorizer.fit_transform(df['cleaned']).toarray()
final_features.shape(3377, 2389)

因此，在将文本转换成向量后，我们最终得到了 2389 个特征。现在，我们继续构建我们的模型，并用我们的数据拟合模型。这里我们应该问的另一个重要问题是**我们真的需要使用所有的 2389 特性吗？**当处理非常长的向量时，有时选择你的最佳特征可能比使用所有特征更好。为此，我们使用 SKlearn.feature_selection 包中的 SelectKbest 方法。然后，我们使用 Chi2 分数来选择具有最高值的 n_features 特征，以进行卡方检验。 " **卡方检验测量随机变量之间的相关性，因此使用此函数“剔除”最有可能与类别无关的特征，因此与分类无关。**引自 sklearn 文档。

在构建模型时，我们可以从广泛的分类算法中进行选择。我们测试了四种不同的算法: KNN、多项式朴素贝叶斯、线性 SVC 和随机福里斯特。我研究了每个分类器，并使用分类性能的常用统计方法(精确度和召回率)来比较每个分类器，得出结论，Random Forrest 似乎比其他分类器表现得更好。根据我自己的经验，当你有一个多类问题时，Random Forrest 做得更好。您可以测试其他分类算法，如果您发现一些提供更好结果的算法，请告诉我。

overall workflow

现在让我们把所有东西都放到一个管道里。这里我们执行一系列转换:首先我们转换 tfidf 矢量器，然后我们选择 K 个最佳特征，最后我们使用分类器来拟合数据。所以我们使用一个管道同时完成所有这些任务:

#first we split our dataset into testing and training set:
# this block is to split the dataset into training and testing set 
X = df['cleaned']
Y = df['class']
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.25)# instead of doing these steps one at a time, we can use a pipeline to complete them all at once
pipeline = Pipeline([('vect', vectorizer),
                     ('chi',  SelectKBest(chi2, k=1200)),
                     ('clf', RandomForestClassifier())])# fitting our model and save it in a pickle for later use
model = pipeline.fit(X_train, y_train)
with open('RandomForest.pickle', 'wb') as f:
    pickle.dump(model, f)ytest = np.array(y_test)# confusion matrix and classification report(precision, recall, F1-score)
print(classification_report(ytest, model.predict(X_test)))
print(confusion_matrix(ytest, model.predict(X_test))) precision    recall  f1-score   support

          1       0.99      0.98      0.99       271
          2       0.91      0.91      0.91        47
          3       0.98      1.00      0.99       116
          4       0.99      0.99      0.99       143
          5       0.98      0.99      0.98       268

avg / total       0.98      0.98      0.98       845Confusion Matrix: 1    2   3   4   5
1[[266   1   0   0   4]
 2[  2  43   0   1   1]
 3[  0   0 116   0   0]
 4[  0   2   0 141   0]
 5[  0   1   2   1 264]]

0.98 精度和召回…！！！嗯……这是我的第一反应。但是后来我查看了混淆矩阵，发现每个类都没有太多的错误分类，我认为我们的情况不错。我们甚至没有对分类算法进行任何参数调整就实现了高精度和高召回率！

现在我真的想看看这是否适用于另一个数据集。此外，我想使用其他指标对此进行评估，如:AUC 得分，并查看 ROC 曲线，因为数据有点不平衡。为了有一个更完整的理解，还有两件事要做:首先是使用 gridsearch 来调整参数，看看它是否真的有助于改善结果。第二，每个类别最好有 5 个最重要的关键词，这样以后我们可以用这些关键词来进行搜索。但是这篇文章已经够长了，所以我将在下一篇文章中回答这些问题。敬请期待！

非常感谢您的反馈和问题。

我的github上有这个项目的源代码、python 笔记本和数据集。

时尚 MNIST 的多标签分类和类别激活图

原文：https://towardsdatascience.com/multi-label-classification-and-class-activation-map-on-fashion-mnist-1454f09f5925?source=collection_archive---------2-----------------------

时尚-MNIST 是一个时尚产品图像数据集，用于对计算机视觉的机器学习算法进行基准测试。该数据集包括 60，000 幅 28x28 的训练图像和 10，000 幅 28x28 的测试图像，包括 10 类时尚产品。图 1 显示了所有的标签和一些图像在时尚-MNIST 。

Figure 1. Fashion-MNIST dataset. [github and arxiv]

有很多关于时尚的文章——MNIST[ref]。然而，这篇文章的目标是在多标签分类的背景下，而不是在多类分类的背景下，提出一项关于时尚 MNIST 的深度学习的研究。此外，这篇文章还研究了我们是否可以可视化卷积神经网络如何看待图像，并识别激活特定标签的区域。

1.可视化，可视化，可视化

在进入所有细节之前，让我们想象一下我们能达到的一些结果。

Figure 2. (a) A multi-label image, (b) The predicted probabilities over labels, (c) The class activation maps for the labels with higher probabilities.

让我们逐一分解图 2 中的图表。

第一个图显示了一个多标签图像，由来自时尚-MNIST 的四个时尚产品图像组成:一条裤子、一双运动鞋、一个包和一件衣服。与该多标签图像相关联的标签是 1 、7、8 和 3。请注意，实际上我们在这项研究中考虑的是标签的存在(例如 1/3/7/8)而不是标签的顺序(例如 1/7/8/3)。如果一个图像只包含两类时尚产品，那么只有两个标签会被分配给该图像。
给出了多标签图像，第二张图显示了由我们训练的卷积神经网络计算的所有标签的预测概率。请注意，标签 1 、标签 3 、标签 7 和标签 8 的概率都接近 1，这表明我们训练的卷积神经网络在给定图像上标记正确标签方面做得很好。
第三张图显示了与前四个预测标签相关的热图，即以较高概率激活标签的区域。突出显示热图(也称为类激活图)的目的是打开我们的卷积神经网络的黑盒，看看它是否真的精确定位了进行预测的关键区域。

再举两个例子:一个有 3 个标签(图 3)，一个有 2 个标签(图 4)。

Figure 3. An image with 3 labels: 2, 3, and 8.

Figure 4. An image with 2 labels: 3 and 9.

图 5 给出了超过 9000 幅用于训练的图像和 1000 幅用于验证的图像的总体训练历史。在 1000 张测试图像上的准确率在 95% ~ 96%左右。该程序是在 Keras 中实现的，后台是 Theano。

Figure 5. Training history on accuracy and loss.

2.多标签时尚-MNIST

以下是我们用于多标签分类的新数据集的简介:

10000 幅 646×184 的训练图像和 1000 幅 646×184 的测试图像；
每张图片有四张从时尚-MNIST 中随机选取的时尚产品图片；
元数据文件保存了图像的有序标签，以及它的单主机编码方案。

图 6 显示了我们数据集中的一些图像，图 7 显示了元数据文件中的一些信息。

Figure 6. Sample images in Multi-Label Fashion-MNIST.

Figure 7. Sample meta-data in Multi-Label Fashion-MNIST.

3.神经网络体系结构

我们神经网络的重点是将执行多标签分类和生成类激活图的基本机制集成在一起。我们将遍历执行多标签分类的基本框架，然后检查生成类激活图所需的增强。

首先，让我们比较实现多类分类(其中一个图像仅属于一个类)和多标签分类(其中一个图像可以与多个标签相关联)的常见做法。)

用于图像分类的基本神经网络架构通常由用于特征提取的卷积层和最大池层的堆叠组成，随后是用于类别/标签预测的一些全连接层。
对于多类分类，模型中的最后一层使用 softmax 函数进行类预测，训练过程使用category _ cross entropy函数作为损失函数。
对于多标签分类，模型中的最后一层使用 sigmoid 函数进行标签预测，训练过程使用 binary_crossentropy 函数作为损失函数。

上述实践基于在深度学习中实现最后一层激活函数和损失函数的传统智慧，如图 8 所示。

Figure 8. Summary of last-layer activation function and loss function. [Deep Learning with Python, Ch4/Ch9**]**

现在，让我们考虑生成类激活映射的机制。有许多不同的方法来创建类激活映射。我们的想法和代码基于用于对象本地化的全局平均池层。这种方法有两个要点。首先，给定类的类激活图被视为最后一个卷积层的特征图的加权和。其次，全局平均池图层用于将要素地图转换为单个值，并作为计算相关权重的粘合剂。原始论文中的图 9 展示了完整的过程。

Figure 9. Class Activation Mapping. [ref]

图 10 显示了 Keras 中用于构建和训练深度神经网络的代码。图 11 显示了整个模型的概要。

Figure 10. The code for building and training the deep neural network.

Figure 11. The summary of the whole model.

图 12 显示了创建类激活映射的代码。

Figure 12. The code for creating a class activation map.

4.结论

这篇文章介绍了在多标签分类的背景下为时尚-MNIST 进行的深度学习研究。我们还试图打开我们的卷积神经网络的黑盒，以查看预测标签的类激活图。这项研究中最有趣但最具挑战性的问题是用全局平均池函数实现和验证类激活映射，特别是当一个映射看起来不正确时。最后，让我用两个数字来说明今后工作的方向。

Ref-1. DeepFashion

Ref-2. Grad-CAM

还有一件事…你喜欢 MNIST 吗？

Ref-3. DO YOU MNIST from anztee.com and teezily.com

基于初始网的多标签图像分类

原文：https://towardsdatascience.com/multi-label-image-classification-with-inception-net-cbb2ee538e30?source=collection_archive---------0-----------------------

Inception v3 architecture. (source)

**更新:**本文已更新，修复了特里萨·巴顿指出的精度计算可能存在的问题。 git 回购也已经更新，你可以在那里找到所有的变化。

Inception v3 是一个深度卷积神经网络，在 ImageNet 数据集上训练用于单标签图像分类。TensorFlow 团队已经准备了一个教程来重新训练它，根据我们自己的例子来区分一些类。我们将修改教程中的再训练脚本 retrain.py ，将网络改为多标签分类器。

如果你只是想跳转到结果代码，这里的是所有必要的文件和信息，需要让它工作。从现在开始，我将假设您已经克隆了提到的存储库并引用了它的文件。

那么需要做些什么呢？首先，我们必须以某种方式告诉网络哪一个是每个图像的正确标签。然后，我们必须修改正在重新训练的最后一层和评估生成的预测的方法，以便实际上能够针对每个图像的多个可能的正确类别来训练它。

要求

张量流 0.12.0-rc1
JPEG 格式的训练图像
修改后的源代码与示例

数据预处理

准备训练图像

将所有训练图像放入图像目录下的一个文件夹中。
尽量去掉所有重复的图像，它们可能会人为地夸大测试和验证的准确性。文件夹的名称并不重要。我用的是多标。

为每个训练图像准备标签

我们需要为每个图像准备带有正确标签的文件。将文件命名为**<image _ file _ name . jpg>。txt** =如果你有一张图片【car.jpg.txt】，附带的文件应该命名为 car.jpg.txt 。

将每个标签放在文件中的一个新行上，不要做其他事情。

现在将所有创建的文件复制到项目根目录下的 image_labels_dir 目录中。您可以通过编辑 retrain.py 中的全局变量 IMAGE_LABELS_DIR 来更改该文件夹的路径。

创建包含所有标签的文件

最初的 Inception net 使用一个文件夹结构来导出类的列表。在我们的例子中，所有的训练图像都在一个文件夹中，因此我们需要在一个外部文件中列出这些类。

在项目根目录下创建文件 labels.txt ，并用所有可能的标签填充它。每个标签在一个新的行上，没有别的。就像所有可能的类中的图像的 image_label 文件一样。

修改总管

main()方法最初将包含每个标签的图像的目录结构加载到单独的文件夹中，并通过以下方式为每个类创建了验证、测试和训练集合:

image_lists = create_image_lists(FLAGS.image_dir, FLAGS.testing_percentage,cFLAGS.validation_percentage)

我们现在在一个目录中有所有的图像，因此 image_lists.keys() 只包含一个元素，那就是我们所有图像的文件夹(例如多标签)。所有的训练图像被分成验证、测试和训练组，通过该键可以进入。

现在我们已经正确地分割了数据，我们只需要加载标签列表并计算类计数:

**with** open(ALL_LABELS_FILE) **as** f:
    labels = f.read().splitlines()
class_count = len(labels)

创建地面真实向量

添加get _ image _ labels _ path()方法，该方法只是稍微编辑了一下 get_image_path() 方法返回包含正确图像标签的文件的路径=例如image _ labels _ dir/car . jpg . txt对于car.jpg。
编辑**get _ random _ cached _ 瓶颈()**方法:

该方法创建包含每个返回图像的正确标签的 ground_truth 向量。最初它只是创建了一个零向量:

ground_truth = np.zeros(class_count, dtype=np.float32)

然后在正确的标签位置放一个 1.0，这是我们知道的，因为这是我们从中获取图像的文件夹的名称:

ground_truth[label_index] = 1.0

多标签分类没那么简单。我们需要从 image_label_file 中为给定的图像加载所有正确的标签。

获取带有正确标签的文件路径:

labels_file = get_image_labels_path(image_lists,label_name,image_index, IMAGE_LABELS_DIR, category)

从文件中读取所有行=标签，并保存到数组 true_labels :

**with** open(labels_file) **as** f:
   true_labels = f.read().splitlines()

用零初始化 ground_truth 向量:

ground_truth = np.zeros(class_count, dtype=np.float32)

用 1.0 表示 ground_truth 向量中的正确标签:

idx = 0
**for** label **in** labels:
   **if** label **in** true_labels:
      ground_truth[idx] = 1.0
   idx += 1

标签列表是添加到**get _ random _ cached _ bottoms()**方法的参数，包含所有可能的类的名称。

就是这样！我们可以通过缓存创建的地面真相来改进这个解决方案。这防止了每次我们为相同的图像请求时创建地面真实向量，如果我们为多个时期训练，这是必然发生的。这就是全局字典 CACHED_GROUND_TRUTH_VECTORS 的用途。

修改培训

add_final_training_ops() 方法最初添加了一个新的 softmax 和全连接层用于训练。我们只需要用一个不同的函数替换 softmax 函数。

为什么？

softmax 函数将向量的所有值压缩到[0，1]范围内，总和为 1。这正是我们在单一标签分类中想要的。但是对于我们的多标签情况，我们希望我们得到的类别概率能够表示汽车的图像属于类别汽车的概率为 90%,属于类别事故的概率为 30%,等等。

我们将通过使用例如 sigmoid 函数来实现这一点。

具体来说，我们将替换:

final_tensor = tf.nn.softmax(logits, name=final_tensor_name)

使用:

final_tensor = tf.nn.sigmoid(logits, name=final_tensor_name)

我们还必须更新交叉熵的计算方法，以正确训练我们的网络:

同样，只需将 softmax 替换为 sigmoid:

cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(logits,ground_truth_input)

修改评估

方法 add_evaluation_step() 插入我们需要评估预测标签准确性的操作。最初看起来是这样的:

correct_prediction = tf.equal(tf.argmax(result_tensor, 1), tf.argmax(ground_truth_tensor, 1))

好吧，这是怎么回事？

result_tensor 和 ground_truth_tensor 都可以想象成 2D 数组:

|        | label1  | label2 | label3  |
| image1 |    0    |    1   |    0    |
| image2 |    1    |    0   |    0    |

因此这一行:

tf.argmax(result_tensor, 1)

返回每个行中最大值的索引。每一行因为(axis = 1 参数。

我们将获得具有最高值的索引并比较它们，同时知道因为只有一个标签是正确的，所以地面 _ 真相 _ 张量在每行中只包含一个 1 。

为了使这种方法适应我们的多标签情况，我们简单地用 round() 替换 argmax() ，这将概率变成 0 和 1。然后，我们将结果张量与已经只包含 0 和 1 的基础张量进行比较:

correct_prediction = tf.equal(tf.round(result_tensor), ground_truth_tensor)

这就是我们为正确分类带有多个标签的图像所需要做的所有更改。

运行再培训

只需从项目根目录运行以下命令:

python retrain.py \
--bottleneck_dir=bottlenecks \
--how_many_training_steps 500 \
--model_dir=model_dir \
--output_graph=retrained_graph.pb \
--output_labels=retrained_labels.txt \
--summaries_dir=retrain_logs \
--image_dir=images

我建议调整训练步骤的数量，以防止过度适应你的模型。

测试重新训练的模型

运行:

python label_image.py <image_name>

我稍微修改了一下 label_image.py ，将得到的类百分比写入 results.txt 。

可视化培训

重新训练完成后，您可以通过运行以下命令来查看日志:

tensorboard --logdir retrain_logs

并在浏览器中导航至 http://127.0.0.1:6006/ 。

结束了

我希望我尽可能清楚地解释了所有的变化及其背后的原因，希望你今天学到了一些新东西:)

如果你有进一步的问题，你可以在 linkedin 上找到我或者直接发邮件给我。

多标签意图分类

原文：https://towardsdatascience.com/multi-label-intent-classification-1cdd4859b93?source=collection_archive---------5-----------------------

有很多应用需要文本分类，或者我们可以说意图分类。现在，所有的东西都需要分类，就像内容一样，产品也经常被分类。

但是网上绝大多数的文本分类文章和教程都是邮件垃圾过滤(spam vs. ham)、情感分析(正面 vs .负面)等二元文本分类。我们现实世界的问题要比这复杂得多。因此，这就是我要在这篇博客中解释的。将文本分类成多个类别。

问题陈述:

我为我的 GSoC 项目(Owasp SKF 聊天机器人)开发了这个分类器。问题陈述是针对不同漏洞的安全知识框架知识库。它提供了针对不同漏洞的描述、解决方案和代码示例。所以，我需要对用户的查询进行分类，无论他是要求描述、解决方案还是代码示例。

我使用了 Python 和 Jupyter Notebook 来开发我们的系统，依靠 Scikit-Learn 作为机器学习组件。

数据集的准备:

对于任何与分类或机器学习相关的问题，我们首先需要的是格式过于正确的数据。因此，首先我将解释我如何准备意图分类的数据集。

import json
import csv
with open("data.json",encoding='utf-8') as read_file:
        data = json.load(read_file)

可以在这里查看 data.json 。我将准备 CSV 格式的数据集，因为它很容易训练模型。

#For parsing the Json
a=data['items']
#Declaration of liststitle=[]
ques=[]
sol=[]
code=[]#For accessing the title from Json and storing it in the list.
for d in a: 
   title.append((d['title']))

我的文本分类是针对问答类系统的。因此，我需要生成问题，因为我提取了列表中的所有标题。

for t in title:
	ques.append("What is "+ t + " ?")
	ques.append("What does "+ t + " mean ?")
	ques.append("Tell me something about "+ t + " ?")
	ques.append(t)
	ques.append("Explain " + t +" ?")
	ques.append("Elaborate " + t +" ?")
	ques.append("Can you tell me about " + t + " ?")
	ques.append("What do you know about " + t + " ?")
	ques.append("What can you tell me about " + t + " ?")
	ques.append("I want to know about XSS " + t )
	ques.append("Do you have information about " + t + " ?")for t in title:
        sol.append("How to solve "+ t + " ?")
        sol.append("How to resolve "+ t + " ?")
        sol.append("How to mitigate "+ t + " ?")
        sol.append("Solution for "+ t)
        sol.append("Provide me some Solution for "+ t)
        sol.append("mitigation for "+ t)
        sol.append("How to stop "+ t + " ?")
        sol.append("How to defend "+ t + " ?")
        sol.append("How to get secured against "+ t + " ?")
        sol.append("Solution, "+t)

for t in title:
        code.append("Give me some sample code of "+ t )
        code.append("Code example of "+ t + " ?")
        code.append("Code of "+ t )

因此，问题需要根据描述、解决方案和代码进行分类。所以，我做了三个列表，每个列表存储一个问题。

file=open("intent_data.csv","x")
file.write('class,question\n')
for x in ques:
		x=x.replace(",","")
		file.write('Description, '+x+"\n")	 
for y in sol:
		y=y.replace(",","")
		file.write('Solution, '+y+"\n")

for z in code:
		z=z.replace(",","")
		file.write('Code, '+z+"\n")

file.close()

所以，现在数据准备好了。你可以在这里查看完整数据。

为了更好地理解如何准备数据集，您也可以查看这个 jupyter 笔记本示例。

现在，我们已经准备好数据😄...是时候用它变变魔术了。让我们看看如何对意图进行分类。

让我们导入一些库:

import pandas as pd
from io import StringIO
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.naive_bayes import MultinomialNB

首先，我们将从 CSV 文件中提取数据，并将其存储在数据帧中。

def get_data():
    df = pd.read_csv('datasets/intent_data.csv')
    return df

在这一步中，我们将准备好数据以将其输入算法。首先，我们在**‘y’**中获得完整的数据，并使用

**y=[col]**

之后，使用' pd.notnull' 来检查问题列中的数据是否为空，如果为空，则将删除整行。

这一步对于获得高质量的干净数据非常重要。因为，如果我们有好的数据，我们就会有好的结果。😃

我们将创建一个新的列**‘category _ id’**，它将给出一个班级编号。类似于描述，它将是 0，解决方案 1 和代码 2。

删除重复后，我们将得到类似这样的东西

category_id_df = y[['classs', 'category_id']].**drop_duplicates()**.sort_values('category_id')
**print(category_id_df)****classs                category_id**
0       Description         0
2       Solution            1
5081    Code                2

可以查看下面 data_prepare 的代码片段。

def data_prepare():
    col = ['classs', 'question']
    y=get_data()
    y = y[col]
    y = y[pd.notnull(y['question'])]
    y.columns = ['classs', 'question']
    y['category_id'] = y['classs'].factorize()[0]
    category_id_df = y[['classs', 'category_id']].drop_duplicates().sort_values('category_id')
    category_to_id = dict(category_id_df.values)
    id_to_category = dict(category_id_df[['category_id', 'classs']].values) **#This will add the column in our dataframe**
    return y

我使用了多项式朴素贝叶斯算法进行预测，因为我发现它易于实现并且具有很高的准确性。

OneVsRest 策略可用于多标签学习，例如，使用分类器来预测多个标签。朴素贝叶斯支持多类，但我们处于多标签场景中，因此，我们将朴素贝叶斯包装在 OneVsRestClassifier 中。

OneVsRest 多标签策略

多标签算法接受多个标签上的二进制掩码。每个预测的结果将是一个由 0 和 1 组成的数组，用于标记哪些类标签适用于每个行输入样本。

为了更好地理解下面的代码片段和多项式 Naive_bayes，请尝试这个。

一个简短的概述是:在这里，我将我的数据分为测试数据和训练数据，然后将这些数据输入到模型中。

def naive_algo():
    tfidf = TfidfVectorizer(sublinear_tf=True, min_df=5, norm='l2', encoding='latin-1', ngram_range=(1, 2), stop_words='english')
    df=data_prepare()
    features = tfidf.fit_transform(df.question).toarray()
    labels = df.category_id
    features.shape
    X_train, X_test, y_train, y_test = train_test_split(df['question'], df['classs'], random_state = 0)
    count_vect = CountVectorizer()
    X_train_counts = count_vect.fit_transform(X_train)
    tfidf_transformer = TfidfTransformer()
    X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)
    clf = MultinomialNB().fit(X_train_tfidf, y_train)
    return clf,count_vect

我还尝试了其他算法或模型，如线性 SVC、逻辑回归和随机森林。你可以看看这里的那个。

这将给我们最终的预测。

def predict(question):
    clf,count_vect=naive_algo()
    intent=clf.predict(count_vect.transform([question]))
    intent=str(intent).strip("['']")
    return intent

最后，我们输入问题，并将其传递给 predict 函数，然后等待变魔术。😝

ques=input("Enter your question ")
x=predict(ques)

漂亮，准确，不是吗？

您可以查看本笔记本以更好地了解意图分类。

感谢阅读！如果你喜欢它，请鼓掌，评论(评论或质疑)并分享它😄

你可以在 Github 、 Linkedin 、 Twitter 上和我联系😄

更多内容，请点击下面的“给我买杯咖啡”图标支持我。

使用 Scikit-Learn 进行多标签文本分类

原文：https://towardsdatascience.com/multi-label-text-classification-with-scikit-learn-30714b7819c5?source=collection_archive---------0-----------------------

Photo credit: Pexels

多类分类指两个以上类的分类任务；每个标签都是互斥的。分类假设每个样本被分配给一个且仅一个标签。

另一方面，多标签分类给每个样本分配一组目标标签。这可以被认为是预测数据点的属性，这些属性并不相互排斥，例如 Tim Horton 经常被归类为面包店和咖啡店。多标签文本分类在现实世界中有很多应用，比如对 Yelp 上的企业进行分类，或者将电影分为一个或多个类型。

问题定式化

任何在网上成为辱骂或骚扰目标的人都会知道，当你注销或关掉手机时，这种情况不会消失。谷歌的研究人员正致力于研究在线有毒评论的工具。在这篇文章中，我们将建立一个多标签模型，能够检测不同类型的毒性，如严重中毒，威胁，淫秽，侮辱，等等。我们将使用监督分类器和文本表示。毒性评论可能是关于毒性、严重毒性、淫秽、威胁、侮辱或身份仇恨中的任何一种，也可能不是以上任何一种。数据集可以在卡格尔找到。

(来自数据源的免责声明:数据集包含可能被视为亵渎、粗俗或冒犯的文本。)

探索

%matplotlib inline
import re
import matplotlib
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score
from sklearn.multiclass import OneVsRestClassifier
from nltk.corpus import stopwords
stop_words = set(stopwords.words('english'))
from sklearn.svm import LinearSVC
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
import seaborn as snsdf = pd.read_csv("train 2.csv", encoding = "ISO-8859-1")
df.head()

每个类别中的评论数量

df_toxic = df.drop(['id', 'comment_text'], axis=1)
counts = []
categories = list(df_toxic.columns.values)
for i in categories:
    counts.append((i, df_toxic[i].sum()))
df_stats = pd.DataFrame(counts, columns=['category', 'number_of_comments'])
df_stats

Figure 1

df_stats.plot(x='category', y='number_of_comments', kind='bar', legend=False, grid=True, figsize=(8, 5))
plt.title("Number of comments per category")
plt.ylabel('# of Occurrences', fontsize=12)
plt.xlabel('category', fontsize=12)

Figure 2

多标签

有多少评论有多重标签？

rowsums = df.iloc[:,2:].sum(axis=1)
x=rowsums.value_counts()#plot
plt.figure(figsize=(8,5))
ax = sns.barplot(x.index, x.values)
plt.title("Multiple categories per comment")
plt.ylabel('# of Occurrences', fontsize=12)
plt.xlabel('# of categories', fontsize=12)

Figure 3

绝大多数评论文字都没有标注。

print('Percentage of comments that are not labelled:')
print(len(df[(df['toxic']==0) & (df['severe_toxic']==0) & (df['obscene']==0) & (df['threat']== 0) & (df['insult']==0) & (df['identity_hate']==0)]) / len(df))

未标注评论的百分比:
0.8983211235124177

评论文本字数分布。

lens = df.comment_text.str.len()
lens.hist(bins = np.arange(0,5000,50))

Figure 4

大多数评论文本长度在 500 个字符以内，有些异常值长达 5000 个字符。

注释文本列中没有缺失的注释。

print('Number of missing comments in comment text:')
df['comment_text'].isnull().sum()

注释文本中缺失的注释数:

先偷看一下第一条评论，文字需要清理。

df['comment_text'][0]

" 解释\ r 为什么在我的用户名 Hardcore Metallica Fan 下所做的编辑被恢复？他们不是故意破坏，只是我在纽约娃娃 FAC 投票后关闭了一些煤气。请不要把模板从对话页面上删除，因为我现在退休了。89.205.38.27 ”

数据预处理

创建一个函数来清理文本

def clean_text(text):
    text = text.lower()
    text = re.sub(r"what's", "what is ", text)
    text = re.sub(r"\'s", " ", text)
    text = re.sub(r"\'ve", " have ", text)
    text = re.sub(r"can't", "can not ", text)
    text = re.sub(r"n't", " not ", text)
    text = re.sub(r"i'm", "i am ", text)
    text = re.sub(r"\'re", " are ", text)
    text = re.sub(r"\'d", " would ", text)
    text = re.sub(r"\'ll", " will ", text)
    text = re.sub(r"\'scuse", " excuse ", text)
    text = re.sub('\W', ' ', text)
    text = re.sub('\s+', ' ', text)
    text = text.strip(' ')
    return text

清理 comment_text 列:

df['comment_text'] = df['comment_text'].map(lambda com : clean_text(com))df['comment_text'][0]

解释为什么我的用户名 hardcore metallica fan 下所做的编辑被恢复，他们不是故意破坏，只是在我在纽约娃娃 fac 投票后关闭了一些气体，请不要从对话页面删除模板，因为我现在退休了 89 205 38 27

好多了！

将数据拆分为定型集和测试集:

categories = ['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']train, test = train_test_split(df, random_state=42, test_size=0.33, shuffle=True)X_train = train.comment_text
X_test = test.comment_text
print(X_train.shape)
print(X_test.shape)

(106912，)
(52659，)

分类器训练

管道

Scikit-learn 提供了一个管道实用程序来帮助自动化机器学习工作流。管道在机器学习系统中非常常见，因为有大量数据要操作，并且有许多数据转换要应用。因此，我们将利用流水线来训练每个分类器。

OneVsRest 多标签策略

多标签算法接受多个标签上的二进制掩码。每个预测的结果将是一个由 0 和 1 组成的数组，用于标记哪些类标签适用于每个行输入样本。

朴素贝叶斯

# Define a pipeline combining a text feature extractor with multi lable classifier
NB_pipeline = Pipeline([
                ('tfidf', TfidfVectorizer(stop_words=stop_words)),
                ('clf', OneVsRestClassifier(MultinomialNB(
                    fit_prior=True, class_prior=None))),
            ])for category in categories:
    print('... Processing {}'.format(category))
    # train the model using X_dtm & y
    NB_pipeline.fit(X_train, train[category])
    # compute the testing accuracy
    prediction = NB_pipeline.predict(X_test)
    print('Test accuracy is {}'.format(accuracy_score(test[category], prediction)))

…处理有毒
测试精度为 0.9191401279933155
…处理严重 _ 有毒
测试精度为 0.9900112041626312
…处理淫秽
测试精度为 0.95148027877747584
…处理威胁
测试精度为 0.9971135033

线性 SVC

SVC_pipeline = Pipeline([
                ('tfidf', TfidfVectorizer(stop_words=stop_words)),
                ('clf', OneVsRestClassifier(LinearSVC(), n_jobs=1)),
            ])for category in categories:
    print('... Processing {}'.format(category))
    # train the model using X_dtm & y
    SVC_pipeline.fit(X_train, train[category])
    # compute the testing accuracy
    prediction = SVC_pipeline.predict(X_test)
    print('Test accuracy is {}'.format(accuracy_score(test[category], prediction)))

…处理有毒
测试精度为 0.9599498661197516
…处理严重 _ 有毒
测试精度为 0.9906948479842003
…处理淫秽
测试精度为 0.9789019920621356
…处理威胁
测试精度为 0.997417334

逻辑回归

LogReg_pipeline = Pipeline([
                ('tfidf', TfidfVectorizer(stop_words=stop_words)),
                ('clf', OneVsRestClassifier(LogisticRegression(solver='sag'), n_jobs=1)),
            ])for category in categories:
    print('... Processing {}'.format(category))
    # train the model using X_dtm & y
    LogReg_pipeline.fit(X_train, train[category])
    # compute the testing accuracy
    prediction = LogReg_pipeline.predict(X_test)
    print('Test accuracy is {}'.format(accuracy_score(test[category], prediction)))

…处理有毒的
测试精度为 0.9548415275641391
…处理严重 _ 有毒的
测试精度为 0.9910556600011394
…处理淫秽的
测试精度为 0.9761104464573956
…处理威胁的
测试精度为 0.999779395

三个分类器产生了相似的结果。我们已经为有毒评论多标签文本分类问题创建了一个强大的基线。

这篇文章的完整代码可以在 Github 上找到。我期待听到任何反馈或意见。

具有 Sigmoid 函数的多层神经网络——新手的深度学习(2)

原文：https://towardsdatascience.com/multi-layer-neural-networks-with-sigmoid-function-deep-learning-for-rookies-2-bf464f09eb7f?source=collection_archive---------0-----------------------

第 1 章:介绍深度学习和神经网络

第二章:具有 Sigmoid 函数的多层神经网络

关注我的 推特 了解更多关于深度学习创业公司的生活。

大家好。欢迎回到我的第二篇系列文章菜鸟深度学习(DLFR) ，作者是你忠实的菜鸟；)如果你觉得难以理解的话，请随意参考我在这里的第一篇文章。或者在本页用备注高亮显示或者在下方留下评论！我们也非常感谢您的反馈。

这次我们将更深入地研究神经网络，这篇文章将比上一次更具技术性。但是不用担心，我会让你在没有 CS/数学背景的情况下，尽可能简单直观地学习基础知识。你很快就能吹嘘你的理解了；)

来自 DLFR 1 的评论

上次，我们介绍了深度学习领域，并检查了一个简单的神经网络——感知器……或恐龙……好吧，说真的，单层感知器。我们还研究了感知器网络如何处理我们输入的输入数据并返回输出。

关键概念:输入数据，权重，求和加偏，激活函数(具体是阶跃函数)，然后输出。厌倦了吗？别担心:)我保证会有……更多的术语出现！但是你很快就会习惯的。我保证。

Graph 1: Procedures of a Single-layer Perceptron Network

回到 20 世纪 50 年代和 60 年代，人们没有单层感知器的有效学习算法来学习和识别非线性模式(还记得 XOR 门问题吗？).公众对感知器失去了兴趣。毕竟，现实世界中的大多数问题都是非线性的，作为个体人类，你和我都非常擅长线性或二元问题的决策，如 我是否应该研究深度学习 而不需要感知机。好吧，“好”在这里是一个棘手的词，因为我们的大脑真的不是那么理性。但我会把这个问题留给行为经济学家和心理学家。

突破:多层感知器

快进近 20 年，到 1986 年，Geoffrey Hinton、David Rumelhart 和 Ronald Williams 发表了一篇论文“通过反向传播错误学习表征”，其中介绍了:

反向传播，到的一个过程，反复调整权重到以使实际输出和期望输出之间的差异最小化
隐藏层，是堆叠在输入和输出之间的 神经元节点，允许神经网络学习更复杂的特性(如异或逻辑)

如果你对 DL 完全陌生，你应该还记得杰弗里·辛顿(Geoffrey Hinton)，他在 DL 的发展过程中起着举足轻重的作用。这是一些重大新闻:我们 20 年来一直认为神经网络没有解决现实世界问题的前景。现在我们看到岸上灯塔发出的光了！让我们来看看这两个新的介绍。

嗯，第一个，反向传播，上一篇帖子提到过。还记得我们反复强调设计神经网络的重要性，以便网络可以从 期望输出 (事实是什么)和 实际输出 (网络返回什么)之间的差异中学习，然后向权重发回信号并要求权重进行自我调整吗？这将使网络的输出在下次运行时更接近于期望的输出。

第二个呢，隐藏层？什么是隐藏层？一个隐藏层就把单层感知器变成了多层感知器！计划是这样的，由于技术原因， 我将在这篇文章中重点讨论隐藏层，然后在下一篇文章 中讨论反向传播。

这里只是一个随机的有趣事实:我怀疑 Geoffrey Hinton 保持着谷歌:D 最年长实习生的记录。不管怎样，如果你已经熟悉机器学习，我相信他在 Coursera 上的课程会很适合你。

Geoffrey Hinton, one of the most important figures in Deep Learning. Source: thestar.com

具有隐藏层的神经网络

神经网络的隐藏层实际上就是在输入和输出层之间增加更多的神经元。

Graph 2: Left: Single-Layer Perceptron; Right: Perceptron with Hidden Layer

输入层中的数据用下标 1，2，3，…，m 标记为 x 。隐藏层中的神经元用下标 1，2，3，…，n 标记为 h 。注意隐藏层是 n 而不是 m ，因为隐藏层神经元的数量可能与输入数据中的数量不同。并且如下图所示，隐藏层神经元也标有上标 1 。这是为了当你有几个隐藏层时，你可以识别它是哪个隐藏层:第一个隐藏层有上标 1，第二个隐藏层有上标 2，以此类推，像在 图 3 中。输出用一个帽子标注为 y 。

Graph 3: We label input layer as x with subscripts 1, 2, …, m; hidden layer as h with subscripts 1, 2, …, n; output layer with a hat

为了使生活更容易，我们将使用一些术语来使事情变得清晰一些。我知道，术语可能很烦人但是你会习惯的:)首先，如果我们有 m 输入数据( x1，x2，…，xm )，我们称这个 m 特性 。特征只是我们认为对特定结果有影响的一个变量。就像我们关于 结果的例子如果你决定学不学 DL， 我们有 3 个特点:1。学了 DL，2 以后会赚更多的钱吗？数学/编程难吗，3。你需要一个 GPU 来开始吗？

其次，当我们将 m 个特征中的每一个乘以一个权重( w1，w2，…，wm )并将它们加在一起时，这就是一个点积:

Definition of a Dot Product

所以现在我们来看看几点:

用 m 特性 在输入X 时，需要用m 权重来执行点积**
用 n 隐层中的隐神经元，你需要 n 套权值( W1，W2，… Wn )来进行点积
有了 1 个隐藏层，你执行 n 点积得到隐藏输出h:(h1，h2，…，hn )
**然后就像单层感知器一样，我们用隐藏输出 h: ( h1，h2，…，hn )作为具有 **n 个特征的输入数据，用 1 组权重( w1，w2，…，wn )执行点积，得到你的最终输出

输入值如何前向传播到隐含层，然后从隐含层到输出的过程与图 1** 相同。下面我提供了如何做到这一点的描述，在图 4 中使用了下面的神经网络。****

Graph 4: Example

********

Graph 5: Procedure to Hidden Layer Outputs

现在隐藏层的输出被计算出来了，我们用它们作为输入来计算最终的输出。

Graph 6: Procedure to Final Output

耶！现在你完全理解多层感知器是如何工作的了:)它就像一个单层感知器，除了在这个过程中你有更多的权重。当你在具有更多更多特征的大型数据集上训练神经网络时(比如自然语言处理中的 word2vec)，这个过程会耗尽你计算机中的大量内存。这就是为什么深度学习直到过去几年才起飞的一个原因，当时我们开始生产更好的硬件，可以处理消耗内存的深度神经网络。

乙状结肠神经元:介绍

所以现在我们有了一个更复杂的带有隐藏层的神经网络。但是我们还没有用阶跃函数解决激活问题。

在上一篇文章中，我们谈到了阶跃函数线性的局限性。需要记住的一点是:如果激活函数是线性的，那么你可以在神经网络中任意堆叠多个隐层，最终输出的仍然是原始输入数据的一个 线性组合 。如果概念难以理解，请 务必阅读此链接 以获得的解释。这种线性意味着它不能真正掌握非线性问题的复杂性，如 XOR 逻辑或由曲线或圆分隔的模式。

同时，阶跃函数也没有有用的导数(它的导数在 x 轴上的 0 点处处处为 0 或未定义)。对于反向传播不起作用，这个我们在下一篇帖子里一定会讲到！

Graph 7: Step Function

好吧，这里有另一个问题:具有阶跃函数的感知器作为神经网络的“关系候选者”不是很“稳定”。想想看:这个女孩(或男孩)有严重的躁郁症！有一天(对于 z < 0 )，(s)他都是“安静”“下来”，给你零反应。然后又过了一天(对于 z ≥ 0 )，他突然“健谈”“活泼”，跟你说个不停。巨大的变化！她/他的心情是没有过渡的，你不知道什么时候是下降还是上升。是的…那是阶梯函数。

因此，基本上，我们感知机网络输入层中任何权重的微小变化都可能导致一个神经元突然从 0 翻转到 1，这可能再次影响隐藏层的行为，然后影响最终结果。就像我们已经说过的，我们想要一种学习算法，它可以通过逐渐改变权重来改善我们的神经网络，而不是通过平坦的无响应或突然的跳跃。如果我们不能使用阶跃函数来逐渐改变权重，那么它就不应该是选择。

Graph 8: We Want Gradual Change in Weights to Gradually Change Outputs

现在告别带阶跃函数的感知器。我们正在为我们的神经网络寻找一个新的合作伙伴， sigmoid 神经元，它具有 sigmoid 功能(duh)。但是不要担心:唯一会改变的是激活函数，到目前为止我们所了解的关于神经网络的一切仍然适用于这种新型神经元！

Sigmoid Function

Graph 9: Sigmoid Function using Matplotlib

如果函数对你来说看起来很抽象或者很奇怪，那么不要太在意像欧拉数 e 之类的细节或者最初是怎么有人想出这个疯狂的函数的。对于那些不精通数学的人来说，关于图 9 中的 sigmoid 函数，唯一重要的事情首先是它的曲线，其次是它的导数。以下是一些更多的细节:

Sigmoid 函数产生与阶跃函数相似的结果，输出介于 0 和 1 之间。曲线在 z=0 处过 0.5，我们可以为激活函数设置规则，比如:如果乙状结肠神经元的输出大于等于 0.5，则输出 1；如果输出小于 0.5，则输出 0。
Sigmoid 函数的曲线上没有加加速度。它是光滑的，它有一个非常好的简单的导数【σ(z)(1-σ(z)】,****，在曲线上处处可微。导数的微积分推导可以在栈溢出这里找到如果你想看的话。但是不一定要知道怎么推导。这里没有压力。*****
如果 z 非常负，那么输出大约为 0；如果 z 非常正，则输出约为 1；但在 z=0 左右，其中 z 既不太大也不太小(在图 9 中两条外侧垂直网格虚线之间)，随着的变化，我们会有相对更多的偏差。******

现在，这似乎是我们神经网络的测年材料:)Sigmoid 函数，不同于阶跃函数，将非线性引入到我们的神经网络模型中。非线性只是指我们从神经元得到的输出，是一些输入 x (x1，x2，…，xm) 和权重 w (w1，w2，…，wm) 加偏置然后放入一个 sigmoid 函数的点积，不能用输入【x(x1，x2，…，XM)的一个线性组合来表示****

当被多层神经网络中的每个神经元使用时，该非线性激活函数产生原始数据的新的“表示，并且最终允许非线性判定边界，例如 XOR。因此，在 XOR 的情况下，如果我们在隐藏层中添加两个 sigmoid 神经元，我们可以在另一个空间中，将原始 2D 图重塑为类似下面图 10 左侧的 3D 图像。因此，该脊允许对异或门进行分类，它代表了图 10 右侧 2D 异或门的浅黄色区域。所以如果我们的输出值在山脊较高的区域上，那么应该是真或者 1(就像天气冷但不热，或者天气热但不冷)；如果我们的输出值在两个角上较低的平坦区域，那么它为假或 0，因为说天气既热又冷或既不热也不冷是不对的(好吧，我想天气可能既不热也不冷…你明白我的意思吧…对吗？).

Graph 10. Representation of Neural Networks with Hidden Layers to Classify XOR Gate. Source: http://colinfahey.com/

我知道这些关于非线性的谈话可能会令人困惑，所以请在这里阅读更多关于线性和非线性的内容(Christopher Olah 的一个很棒的博客中的动画直观的帖子)，在这里阅读(由 Vivek Yadav 带 ReLU 激活功能)，在这里阅读(由 Sebastian Raschka)。希望你已经意识到为什么非线性激活函数是重要的，如果没有，放轻松，给自己一些时间来消化它。

问题解决了……暂时的；)我们将在不久的将来看到一些不同类型的激活函数，因为 sigmoid 函数也有自己的问题！比较流行的有 tanh 和 ReLU 。然而，这是另一篇文章。

多层神经网络:直观的方法

好吧。因此，我们在神经网络中引入了隐藏层，并用 sigmoid 神经元取代了感知器。我们还介绍了非线性激活函数允许对我们的数据中的非线性决策边界或模式进行分类的思想。你可以记住这些要点，因为它们是事实，但我鼓励你在互联网上搜索一下，看看你是否能更好地理解这个概念(我们自然需要一些时间来理解这些概念)。

现在，我们从未讨论过一个非常重要的问题:首先，我们究竟为什么要在神经网络中设置隐藏层？隐藏层如何神奇地帮助我们解决单层神经元无法解决的复杂问题？

从上面的 XOR 示例中，您已经看到了在 1 个隐藏层中添加两个隐藏神经元可以将我们的问题重新塑造到一个不同的空间中，这神奇地为我们创建了一种用脊对 XOR 进行分类的方法。因此，隐藏层以某种方式扭曲了问题，使神经网络很容易对问题或模式进行分类。现在，我们将使用一个经典的教科书示例:手写数字的识别，来帮助您直观地理解隐藏层的作用。

Graph 11. MNIST dataset of Hand-written Digits. Source: http://neuralnetworksanddeeplearning.com/

图 11 中的数字**属于一个名为 MNIST 的数据集。它包含了 70，000 个人手书写的数字的例子。这些数字中的每一个都是 28x28 像素的图片。所以一个数字的每个图像总共有 2828=784 个像素。每个像素取 0 到 255 之间的值(RGB 颜色代码)。0 表示颜色是白色，255 表示颜色是黑色。***

Graph 12. MNIST digit 5, which consist of 28x28 pixel values between 0 and 255. Source: http://neuralnetworksanddeeplearning.com/

现在，计算机无法像我们人类一样真正“看到”一个数字，但如果我们将图像分解为一个由 784 个数字组成的数组，如[0，0，180，16，230，…，4，77，0，0，0，0]，那么我们可以将这个数组输入到我们的神经网络中。计算机不能通过“看”来理解图像，但它可以理解和分析代表图像的像素数量。

Graph 13: Multi-Layer Sigmoid Neural Network with 784 input neurons, 16 hidden neurons, and 10 output neurons

所以，让我们建立一个类似上面图 13 中的神经网络。它有 784 个 28×28 像素值的输入神经元。假设它有 16 个隐藏神经元和 10 个输出神经元。10 个输出神经元以数组的形式返回给我们，每个神经元负责对一个数字从 0 到 9 进行分类。所以如果神经网络认为手写数字是零，那么我们应该得到一个输出数组[1，0，0，0，0，0，0，0，0，0]，这个数组中第一个感觉数字是零的输出被我们的神经网络“激发”为 1，其余的都是 0。如果神经网络认为手写数字是 5，那么我们应该得到[0，0，0，0，0，1，0，0，0，0，0，0]。负责分类 5 的第 6 个元素被触发，而其他元素没有被触发。如此等等。

还记得我们提到过，神经网络通过对数据进行重复训练来变得更好，这样它们就可以调整网络每一层的权重，以使最终结果/实际输出更接近所需输出吗？因此，当我们实际上用 MNIST 数据集中的所有训练样本训练这个神经网络时，我们不知道应该给每一层分配什么权重。所以我们只是随机要求计算机在每一层分配权重。(我们不希望所有的权重都是 0，如果空间允许，我会在下一篇文章中解释)。

这种随机初始化权重的概念很重要，因为每次训练深度学习神经网络时，你都在为权重初始化不同的数字。所以本质上，在网络被训练之前，你和我都不知道神经网络中发生了什么。一个经过训练的神经网络具有在特定值优化的权重，这些权重对我们的问题做出最佳预测或分类。从字面上看，这是一个黑匣子。并且每次经过训练的网络将具有不同的权重集。

为了便于论证，让我们想象一下图 14 中的以下情况，这是我从迈克尔·尼尔森的在线书籍中借来的:

Graph 14. An Intuitive Example to Understand Hidden Layers

在监督学习中用一轮又一轮的标记数据训练神经网络后，假设前 4 个隐藏神经元学会识别上面图 14 左侧的模式。然后，如果我们向神经网络输入一个手写数字 0 的数组，网络应该正确地触发隐藏层中的前 4 个隐藏神经元，而其他隐藏神经元保持沉默，然后再次触发第一个输出神经元，而其余的神经元保持沉默。

Graph 15. Neural Networks are Black Boxes. Each Time is Different.

如果你用一组新的随机权重来训练神经网络，它可能会产生下面的网络(比较图 15 和图 14 )，因为权重是随机的，我们永远不知道哪个会学习哪个或什么模式。但是，如果训练得当，网络仍然应该触发正确的隐藏神经元，然后产生正确的输出。

Our quote this week 😉

最后要提一点:在多层神经网络中，第一个隐藏层将能够学习一些非常简单的模式。每增加一层隐藏层，就能逐渐学习更复杂的模式。请看来自《科学美国人》的图 16 中的人脸识别示例:)

Graph 16: Each Hidden Layer Learns More Complex Features. Source: Scientific American

一些很棒的人制作了下面的网站，让你玩玩神经网络，看看隐藏层是如何工作的。试试看。真的很好玩！

**** [## 张量流-神经网络游乐场

这是一种构建从数据中学习的计算机程序的技术。它非常松散地基于我们如何思考…

playground.tensorflow.org](http://playground.tensorflow.org/)

Ophir Samson 写了一篇很好的文章，也解释了什么是神经网络，有很好的可视化效果，而且很简洁！

[## 深度学习周刊:什么是神经网络？

对于本周的文章，我想通过我收集的一个简单的例子来阐明什么是神经网络…

medium.com](https://medium.com/towards-data-science/deep-learning-weekly-piece-whats-a-neural-network-aa0df888d8a2)

概述

在这篇文章中，我们回顾了感知器的局限性，介绍了具有新激活函数的 sigmoid 神经元，称为 sigmoid function。我们还讨论了多层神经网络如何工作，以及神经网络中隐藏层背后的直觉。

我们现在几乎完成了理解基本神经网络的全部课程；)呵呵，还没完呢！在下一篇文章中，我将会谈到一种叫做损失函数的东西，以及这种神秘的反向传播，我们只提到过，但从来没有访问过！如果你等得不耐烦，请查看以下链接:

[## 用于视觉识别的 CS231n 卷积神经网络

斯坦福 CS231n 课程材料和笔记:视觉识别的卷积神经网络。

cs231n.github.io](http://cs231n.github.io/optimization-2/) [## 一个逐步反向传播的例子

背景技术反向传播是训练神经网络的常用方法。网上不缺论文说…

mattmazur.com](https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/)

敬请关注，最重要的是，享受学习:D 的乐趣

你喜欢这次阅读吗？别忘了关注我的推特！****

使用张量流的多层感知器

原文：https://towardsdatascience.com/multi-layer-perceptron-using-tensorflow-9f3e218a4809?source=collection_archive---------4-----------------------

构建多层感知器和张量流的入门指南，用于构建数字识别系统。

在这篇博客中，我们将使用 TensorFlow 构建一个神经网络(多层感知器)，并成功训练它识别图像中的数字。Tensorflow 是由发布的非常受欢迎的深度学习框架，本笔记本将指导使用该库构建神经网络。如果你想了解什么是多层感知器，你可以看看我之前的博客，在那里我用 Numpy 从头构建了一个多层感知器。

让我们从导入数据开始。作为 Keras，一个高级深度学习库已经将 MNIST 数据作为其默认数据的一部分，我们只是从那里导入数据集，并将其分为训练集和测试集。

*## Loading MNIST dataset from keras*
**import** **keras**
**from** **sklearn.preprocessing** **import** LabelBinarizer
**import** **matplotlib.pyplot** **as** **plt**
%matplotlib inline**def** load_dataset(flatten=**False**):
    (X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data() *# normalize x*
    X_train = X_train.astype(float) / 255.
    X_test = X_test.astype(float) / 255. *# we reserve the last 10000 training examples for validation*
    X_train, X_val = X_train[:-10000], X_train[-10000:]
    y_train, y_val = y_train[:-10000], y_train[-10000:] **if** flatten:
        X_train = X_train.reshape([X_train.shape[0], -1])
        X_val = X_val.reshape([X_val.shape[0], -1])
        X_test = X_test.reshape([X_test.shape[0], -1]) **return** X_train, y_train, X_val, y_val, X_test, y_testX_train, y_train, X_val, y_val, X_test, y_test = load_dataset()
*## Printing dimensions*
print(X_train.shape, y_train.shape)
*## Visualizing the first digit*
plt.imshow(X_train[0], cmap="Greys");

正如我们所看到的，我们当前的数据的维数为 N 28* 28，我们将从展平 N*784 中的图像开始，并对我们的目标变量进行一次性编码。

*## Changing dimension of input images from N*28*28 to  N*784*
X_train = X_train.reshape((X_train.shape[0],X_train.shape[1]*X_train.shape[2]))
X_test = X_test.reshape((X_test.shape[0],X_test.shape[1]*X_test.shape[2]))print('Train dimension:');print(X_train.shape)
print('Test dimension:');print(X_test.shape)*## Changing labels to one-hot encoded vector*
lb = LabelBinarizer()
y_train = lb.fit_transform(y_train)
y_test = lb.transform(y_test)
print('Train labels dimension:');print(y_train.shape)
print('Test labels dimension:');print(y_test.shape)

现在我们已经处理了数据，让我们开始使用 tensorflow 构建我们的多层感知器。我们将从导入所需的库开始。

*## Importing required libraries*
**import** **numpy** **as** **np**
**import** **tensorflow** **as** **tf**
**from** **sklearn.metrics** **import** roc_auc_score, accuracy_score
s = tf.InteractiveSession()

tf。InteractiveSession() 是一种无论何时我们想要运行一个模型，都可以直接运行 tensorflow 模型而无需实例化一个图的方法。我们将建立 784(输入)-512(隐藏层 1)-256(隐藏层 2)-10(输出)神经网络模型。让我们从定义初始化变量开始我们的模型构建。

*## Defining various initialization parameters for 784-512-256-10 MLP model*
num_classes = y_train.shape[1]
num_features = X_train.shape[1]
num_output = y_train.shape[1]
num_layers_0 = 512
num_layers_1 = 256
starter_learning_rate = 0.001
regularizer_rate = 0.1

在 tensorflow 中，我们为输入变量和输出变量以及任何我们想要跟踪的变量定义了一个占位符。

*# Placeholders for the input data*
input_X = tf.placeholder('float32',shape =(**None**,num_features),name="input_X")
input_y = tf.placeholder('float32',shape = (**None**,num_classes),name='input_Y')
*## for dropout layer*
keep_prob = tf.placeholder(tf.float32)

因为密集图层需要权重和偏差，并且需要使用零均值和小方差(1/要素数量的平方根)的随机正态分布进行初始化。

*## Weights initialized by random normal function with std_dev = 1/sqrt(number of input features)*
weights_0 = tf.Variable(tf.random_normal([num_features,num_layers_0], stddev=(1/tf.sqrt(float(num_features)))))
bias_0 = tf.Variable(tf.random_normal([num_layers_0]))weights_1 = tf.Variable(tf.random_normal([num_layers_0,num_layers_1], stddev=(1/tf.sqrt(float(num_layers_0)))))
bias_1 = tf.Variable(tf.random_normal([num_layers_1]))weights_2 = tf.Variable(tf.random_normal([num_layers_1,num_output], stddev=(1/tf.sqrt(float(num_layers_1)))))
bias_2 = tf.Variable(tf.random_normal([num_output]))

现在我们将开始编写图形计算来开发我们的 784(输入)-512(隐藏层 1)-256(隐藏层 2)-10(输出)模型。我们将把每一层的输入乘以其各自的权重，并添加偏差项。在权重和偏差之后，我们需要添加一个激活；我们将对隐藏层使用 ReLU activation，对最终输出层使用 softmax 来获得类概率分数。也是为了防止过度拟合；让我们在每个隐藏层后添加一些 drop out。辍学是在我们的网络中产生冗余的一个基本概念，这导致了更好的泛化。

*## Initializing weigths and biases*
hidden_output_0 = tf.nn.relu(tf.matmul(input_X,weights_0)+bias_0)
hidden_output_0_0 = tf.nn.dropout(hidden_output_0, keep_prob)hidden_output_1 = tf.nn.relu(tf.matmul(hidden_output_0_0,weights_1)+bias_1)
hidden_output_1_1 = tf.nn.dropout(hidden_output_1, keep_prob)predicted_y = tf.sigmoid(tf.matmul(hidden_output_1_1,weights_2) + bias_2)

现在，我们需要定义一个损失函数来优化我们的权重和偏差，我们将使用 softmax 交叉熵和 logits 来预测和正确的标签。我们也将增加一些 L2 正则化到我们的网络。

*## Defining the loss function*
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=predicted_y,labels=input_y)) \
        + regularizer_rate*(tf.reduce_sum(tf.square(bias_0)) + tf.reduce_sum(tf.square(bias_1)))

现在，我们需要为我们的网络定义一个优化器和学习率，以优化给定损失函数的权重和偏差。我们将每五个时期对我们的学习速率使用指数衰减，以减少 15%的学习。对于优化器，我们将使用 Adam 优化器。

*## Variable learning rate*
learning_rate = tf.train.exponential_decay(starter_learning_rate, 0, 5, 0.85, staircase=**True**)
*## Adam optimzer for finding the right weight*
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss,var_list=[weights_0,weights_1,weights_2,
                                                                         bias_0,bias_1,bias_2])

我们已经完成了模型构建。让我们定义准确性度量来评估我们的模型性能，因为损失函数是非直观的。

*## Metrics definition*
correct_prediction = tf.equal(tf.argmax(y_train,1), tf.argmax(predicted_y,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

我们现在将开始在训练数据上训练我们的网络，同时在测试数据集上评估我们的网络。我们将使用大小为 128 的批处理优化，并训练它 14 个时期，以获得 98%以上的准确性。

*## Training parameters*
batch_size = 128
epochs=14
dropout_prob = 0.6training_accuracy = []
training_loss = []
testing_accuracy = []s.run(tf.global_variables_initializer())
**for** epoch **in** range(epochs):    
    arr = np.arange(X_train.shape[0])
    np.random.shuffle(arr)
    **for** index **in** range(0,X_train.shape[0],batch_size):
        s.run(optimizer, {input_X: X_train[arr[index:index+batch_size]],
                          input_y: y_train[arr[index:index+batch_size]],
                        keep_prob:dropout_prob})
    training_accuracy.append(s.run(accuracy, feed_dict= {input_X:X_train, 
                                                         input_y: y_train,keep_prob:1}))
    training_loss.append(s.run(loss, {input_X: X_train, 
                                      input_y: y_train,keep_prob:1}))

    *## Evaluation of model*
    testing_accuracy.append(accuracy_score(y_test.argmax(1), 
                            s.run(predicted_y, {input_X: X_test,keep_prob:1}).argmax(1)))
    print("Epoch:**{0}**, Train loss: **{1:.2f}** Train acc: **{2:.3f}**, Test acc:**{3:.3f}**".format(epoch,
                                                                    training_loss[epoch],
                                                                    training_accuracy[epoch],
                                                                   testing_accuracy[epoch]))

让我们可视化训练并测试作为历元数的函数的准确性。

*## Plotting chart of training and testing accuracy as a function of iterations*
iterations = list(range(epochs))
plt.plot(iterations, training_accuracy, label='Train')
plt.plot(iterations, testing_accuracy, label='Test')
plt.ylabel('Accuracy')
plt.xlabel('iterations')
plt.show()
print("Train Accuracy: **{0:.2f}**".format(training_accuracy[-1]))
print("Test Accuracy:**{0:.2f}**".format(testing_accuracy[-1]))

正如我们所看到的，我们已经成功训练了一个多层感知器，它是用 tensorflow 编写的，具有很高的验证准确性！

我希望你喜欢阅读，并随时使用我的代码(也可以在 jupyter 笔记本中找到)来为你的目的进行测试。此外，如果对代码或博客有任何反馈，请随时联系 aayushmnit@gmail.com 的 LinkedIn 或给我发电子邮件。

分类特征的多态 LSTMs

原文：https://towardsdatascience.com/multi-state-lstms-for-categorical-features-66cc974df1dc?source=collection_archive---------2-----------------------

语境

神经网络现在在很多方面都有广泛的应用。从图像标题生成到乳房癌症预测，这种巨大的应用多样性是各种重要的神经架构 ( 前馈神经网络、卷积神经网络等)的自然结果。在所有这些架构中，长短期记忆(LSTM)——递归神经网络的一个特例——已经被证明在诸如机器翻译、时间序列预测或任何数据为顺序的任务上非常成功。这主要是由于他们能够记忆相对的长期相关性，这是通过考虑先前的信息以进行进一步预测来实现的。

但是仅靠 LSTMs 是不够的。有时我们需要调整这些层，使它们适应手头的任务。

在 Kwyk ，我们提供在线数学练习。每次回答一个练习，我们都会收集一些数据，然后使用网站为每个学生量身定制作业。为了确定哪些练习最有可能让学生进步，我们需要知道他/她在任何给定的时间点上成功完成每个练习的可能性有多大。通过正确预测这些成功概率，我们可以选择最大化整体进度的作业。

这篇文章旨在介绍我们改进的 LSTM 单元“多态 LSTM ”，我们的模型就是基于它来尝试解决这个问题的。

快速数据概述

当一个练习被回答时，我们保存关于学生(或“用户”)和练习的信息，以及一个额外的分数值，该值是(0)还是(1)取决于用户的成功。我们收集的信息以分类特征的形式告诉我们:“是哪个练习？“，”是哪一章？、、、是什么学生？、、、他/她是哪个年级的？“…这会产生具有几十到几千种形态的特征，我们用它们来预测“得分”变量并获得成功概率。

A sample of our data

基于 LSTM 的模型

选择 LSTM 模式背后有两个主要动机。

第一个原因是我们使用的所有特征都是绝对的。这就是我们想要学习的真正信息来源。通过手动烹饪特征，如之前得分的移动平均值，我们会因自己的主观选择而引入偏差。因此，我们选择依靠神经网络，直接反馈我们的数据，让特征自动形成****客观形成。

第二个动机是在所有可用的架构中选择 LSTM。这仅仅是因为我们相信，对于每个学生来说，每次练习成功的概率取决于所有之前的时间结果**，因此是连续的。**

考虑到这一点，我们想到了一种架构，其中对于每个分类特征，共享的 LSTM 将保存每个模态的先前结果的历史。

让我们以“ user_id ”特性为例。在这种情况下，我们需要改编一个 LSTM 细胞来即时记忆每个学生过去如何成功的历史。这是通过在基本的 LSTM 单元中添加我们称之为“T42”的多状态“T43”来实现的:

Left : Basic LSTM cell / Right : Multi-state LSTM cell. Note : If you are not familiar with LSTMs you can refer to this great post by Christopher Olah.

每次一个学生的标签被馈送到多状态 LSTM 单元，它就开始查找相应的状态和以前的分数**。然后，学生的状态被发送到更新一个共享 LSTM 单元。同时，先前的分数被馈送到这个 LSTM 单元，该单元产生一个输出。接下来，产生的状态返回到更新多状态中的学生数据。最后，一旦我们观察到实际的分数，这个值又被发送到更新学生在多状态中的先前分数。**

这个基本 LSTM 单元的修改版本工作方式类似，但有一个额外的优势:它现在可以直接接受一系列学生标签作为输入:

An unrolled Multi-state LSTM.

在前面的例子中，我们考虑了“user_id”分类特性，但这实际上可以应用于我们所有的分类特性。事实上，举例来说，在“ exercise_id ”功能上使用多状态 LSTM 将导致它学习每个练习的历史成功率**。从这里开始，我们使用的完整网络非常简单:**

The complete graph we used to solve our problem.

总而言之，这种架构试图学习每个分类特征的每个模态的单独历史，然后使用 LSTM 的输出来预测给定学生在给定练习中的成功概率。

结果

基线

为了评估我们基于 LSTM 的模型，我们需要一个基准。在尝试任何深度学习方法之前，我们曾经有一个 boosting 算法( 梯度 Boosting )使用了一些手工特征。从所有的分类特征中，我们为每个特征的每个模态编造了一些先前得分的快** 移动平均值 。然后，我们将这些特征输入到梯度推进分类器中，让奇迹发生。**

比较

两个分类器都有相同的方法。事实上，基线模型使用手工移动平均线作为特征，基于 LSTM 的方法自动学习这些历史来预测分数。果不其然，两种算法得到了相近的准确率分数(基线:74.61%，LSTM 基网络: 75.34% )。但预测的分布却大不相同:

We can see that the LSTM-based model is much better at segregating students.

事实上，基于 LSTM 的模型似乎将分成了 3 到 4 个不同的人群:

一个给不应该能答对的学生(概率<10%)
One for those who have a moderate to good chance to succeed (50
One for those who have a very important chance of succeeding (probability> 90%)。

相反，基线只预测了总体平均成功率周围的偏斜正态分布，没有特别的歧视。

但是，为了进一步研究这两种模型之间的差异，我们需要更详细地了解 MSE。事实上，单从 MSE 来看，这两种模型具有相似的性能:

基线:0.17
LSTM 网络: 0.16

但是正如我们在之前的帖子中所讨论的，当真正的随机性与目标相关联时(这里，预测人类行为)，我们可以通过查看其可靠性度量(REL)** 来更好地评估分类器的性能。**

通过将数据分类到相似预测概率的箱中来计算可靠性。然后，我们针对箱中的平均目标计算每个箱的 MSE。最后，我们取一个总平均值来得到我们的 REL 值。

为每个模型获得的指标是:

基线:3.86 e-3
LSTM 网络: 2.86 e-4

事实上，我们看到基于 LSTM 的网络比梯度推进基线精确 10 倍以上，这可以解释我们在比较两种分布时观察到的更好的分离。

结论

总而言之，我们已经在一个真实的例子上看到了 LSTM s 对于序列数据分类是如何有效的。但是我们也看到了我们的LSTM 的修改版本**—多态 LSTM—如何能够在没有任何预处理或特征工程的情况下达到更好的性能。事实上，这种新的 LSTM 细胞可以直接接受一系列标签作为输入，这意味着它只能用于分类特征并且仍然产生良好的结果。**

为了进一步改进多状态 LSTM 的 T1，下一步将会考虑多个标签之间的 T2 相关性。事实上，当预测一个学生在给定的一对相似练习中的表现时，预测的概率应该非常相似。尝试确保这种行为的一种方法是将一个嵌入到网络中的的练习集成起来，让它学习依赖关系。

作者:

多流 RNN，串联 RNN，内部 Conv RNN，在 Tensorflow 中落后 2 RNN

原文：https://towardsdatascience.com/multi-stream-rnn-concat-rnn-internal-conv-rnn-lag-2-rnn-in-tensorflow-f4f17189a208?source=collection_archive---------8-----------------------

GIF from this website

在过去的两周里，我一直渴望实现不同种类的递归神经网络 (RNN)，最终我有时间实现它们。以下是我想尝试的不同 RNN 案例列表。

案例 a:香草递归神经网络
案例 b:多流递归神经网络
案例 c:级联递归神经网络
案例 d:内部卷积递归神经网络
案例 e:滞后 2 递归神经网络

请注意，所有这些模型只是为了好玩和表达我的创意。还有，我要在这篇文章中使用的基础代码来自我的旧文章“OCR 的门控递归卷积 NN”。

香草递归神经网络

Image from this website

总共有 5 个不同的 RNN 案例我想执行。然而，为了完全理解所有的实现，最好对普通 RNN 有一个很好的理解(案例 a 是普通 RNN，所以如果你理解案例 a 的代码，你就可以开始了。)

如果有人想回顾简单的 RNN，请访问我的旧博客文章“ Only Numpy:香草递归神经网络通过时间实践推导反向传播 ”。

案例 a:普通递归神经网络(结果)

红框 → 3 卷积层
→橙色 →全局平均池化和 SoftMax
绿圈 →时间为 0 的隐藏单元
蓝圈 →输入 4 个时间戳
黑框 →带 4 个时间戳的递归神经网络

如上所述，基本网络是简单的 RNN 结合卷积神经网络用于分类。RNN 的时间戳为 4，这意味着我们将在每个时间戳向网络提供 4 种不同的输入。为此，我将在原始图像中添加一些噪声。

蓝线 →一段时间内的训练成本
橙线 →一段时间内的训练精度
绿线 →一段时间内的测试成本
红线 →一段时间内的测试精度

如上所述，我们的基础网络已经运行良好。现在的问题是其他方法表现如何，它是否能够比我们的基础网络更好地正规化。

案例 b:多流递归神经网络(想法/结果)

红框 → 3 卷积层
橙框 →全局平均池化和 SoftMax
绿框 →时间为 0 的隐藏单元
蓝框 →卷积输入流
黄框 →全连通网络流
黑框 →带 4 时间戳的递归神经网络

这种 RNN 背后的想法只是为 RNN 提供不同的数据表示。在我们的基本网络中，我们有原始图像或添加了一些噪声的图像。

红框 →增加四个 CNN/FNN 层来“处理”输入
蓝框 →在每个不同的时间戳创建输入

如下图所示，我们的 RNN 使用[batch_size，26，26，1]将宽度和高度减少了 2 倍。我希望数据的不同表示可以作为一种正则化。(类似于数据扩充)

蓝线 →一段时间内的训练成本
橙线 →一段时间内的训练精度
绿线 →一段时间内的测试成本
红线 →一段时间内的测试精度

正如上面所看到的，网络做得很好，在测试图像上比我们的基础网络高出 1%。

情况 c:级联递归神经网络(想法/结果)

红框 → 3 卷积层
→橙色 →全局平均池化和 SoftMax
绿圈 →时间为 0 的隐藏单元
蓝圈 →输入 4 个时间戳
→黑框 →带 4 个时间戳的递归神经网络
黑弯箭头 →级联输入每个时间戳

这种方法非常简单，其思想是在每个时间戳上提取不同的特征，随着时间的推移，网络具有更多的特征可能是有用的。(对于循环层。)

蓝线 →一段时间内的训练成本
橙线 →一段时间内的训练精度
绿线 →一段时间内的测试成本
红线 →一段时间内的测试精度

可悲的是，这是一个巨大的失败。我猜空的隐藏值对网络的良好运行没有任何帮助。

案例 d:内部卷积递归神经网络(想法/结果)

红框 → 3 卷积层
橙框 →全局平均池和 SoftMax
绿圈 →时间为 0 的隐藏单元
蓝圈 →输入 4 个时间戳
黑框 →带 4 个时间戳的递归神经网络
灰色箭头 →在传递到下一个时间戳之前执行内部卷积

如上所述，这个网络与我们的基础网络接收完全相同的输入。然而，这次我们将在数据的内部表示中执行额外的卷积运算。

右图 →声明 3 个新的卷积层
左图(红框) →如果当前内层不为无，我们将进行额外的卷积操作。

我实际上并没有在这个实现背后的理论原因，我只是想看看它是否工作 LOL。

蓝线 →一段时间内的训练成本
橙线 →一段时间内的训练精度
绿线 →一段时间内的测试成本
红线 →一段时间内的测试精度

如上所述，网络在融合方面做得很好，但是它无法超越我们的基础网络。(可悲)。

情况 e:滞后 2 递归神经网络(想法/结果)

红框 → 3 卷积层
→橙框 →全局平均池化和 SoftMax
绿圈 →时间为 0(或滞后 1)的隐藏单元
→蓝圈 →输入 4 个时间戳
黑框 →带有 4 个时间戳的递归神经网络
紫圈 →隐藏状态滞后 2

在传统的 RNN 设置中，我们仅依靠最早的值来确定当前值。有一段时间我在想，我们没有理由把回看时间(或滞后)限制为 1。我们可以将这个想法扩展到滞后 3 或滞后 4 等。(为了简单起见，我采用了滞后 2)

蓝线 →一段时间内的训练成本
橙线 →一段时间内的训练精度
绿线 →一段时间内的测试成本
红线 →一段时间内的测试精度

谢天谢地，这个网络比基础网络做得更好。(但是具有非常小的余量)，然而这种类型的网络将最适合于时间序列数据。

交互式代码/透明度

对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上复制一份。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！同样为了透明，我在 github 上上传了所有的训练日志。

要访问案例的代码，请点击这里，要查看日志，请点击这里。
点击此处查看案例 b 的代码，点击此处查看日志。
要访问案例 c 的代码，请点击此处，要查看日志，请点击此处。
要访问案例 c 的代码，请点击此处，要查看日志，请点击此处。
点击此处查看案例 c 的代码，点击此处查看日志。

最后的话

我想回顾 RNN 已经很久了，现在我终于可以这样做了。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有的写作清单，请在这里查看我的网站。

同时，在我的 twitter 上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 t。

参考

【NIPS 2017/Part 1】用于 OCR 的带交互码的门控递归卷积 NN【手动反推…(2018).走向数据科学。检索于 2018 年 6 月 6 日，来自https://towards data science . com/nips-2017-tensor flow-gated-recurrent-convolution-neural-network-for-ocr-part-1-with-47 bb 2 A8 a7 ab 3
带 Tensorflow 的软签激活功能【带 TF 的手动背道具】。(2018).走向数据科学。检索于 2018 年 6 月 6 日，来自https://towards data science . com/soft-sign-activation-function-with-tensor flow-manual-back-prop-with-TF-5a 04 F3 c8 e9 c 1
东格斯，V. (2018)。递归神经网络。machinelearning-blog.com。检索于 2018 年 6 月 6 日，来自https://machine learning-blog . com/2018/02/21/recurrent-neural-networks/
唯一 Numpy:香草递归神经网络通过时间实践推导反向传播-部分…(2017).中等。检索于 2018 年 6 月 6 日，来自https://medium . com/@ SeoJaeDuk/only-numpy-vanilla-recurrent-neural-network-back-propagation-practice-math-956 fbea 32704
递归神经网络。(2018).En.wikipedia.org。检索于 2018 年 6 月 6 日，来自https://en.wikipedia.org/wiki/Recurrent_neural_network

多模态深度学习

原文：https://towardsdatascience.com/multimodal-deep-learning-ce7d1d994f4?source=collection_archive---------3-----------------------

使用深度学习的多模态融合

由于对深度学习的研究充满热情，我一直在寻找该领域未被探索的领域(尽管很难找到)。我之前做过 数学应用题 等许多类似的题目。

使用深度神经网络作为黑盒的挑战激起了我的兴趣。我决定更深入地研究“多模态深度学习中的可解释性”这个话题。以下是一些结果。

多模态数据

我们对世界的体验是多模态的——我们看到物体，听到声音，感受纹理，闻到气味，品尝味道。模态是指事情发生或经历的方式，当一个研究问题包括多个这样的模态时，它就被称为多模态。为了让人工智能在理解我们周围的世界方面取得进展，它需要能够一起解释这种多模态信号。

比如 图片通常会关联标签和文字说明；文本包含图像，以更清楚地表达文章的主要思想。 不同的模态以非常不同的统计特性为特征。

多模态深度学习

虽然组合不同模态或类型的信息以提高性能看起来是直观上吸引人的任务，但是在实践中，组合不同水平的噪声和模态之间的冲突是具有挑战性的。此外，模态对预测输出具有不同的定量影响。实践中最常见的方法是将不同输入的高级嵌入连接起来，然后应用 softmax。

Example of Multimodal deep learning where different types of NN are used to extract features

这种方法的问题在于，它会对所有子网络/模态给予同等的重视，这在现实生活中是极不可能的。

All Modalities have an equal contribution towards prediction

网络的加权组合

我们采用子网络的加权组合，使得每个输入模态可以对输出预测具有学习贡献(θ)。

我们的优化问题变成了-

Loss Function after Theta weight is given to each sub-network.

The output is predicted after attaching weights to the subnetworks.

但是这一切的用处！！

言归正传，我开始吹嘘成果了。

准确性和可解释性

我们在两个真实的多模态数据集上取得了最先进的结果

多模态情感强度语料库(MOSI)数据集— 每毫秒视频注释音频特征的注释数据集 417。总共有 2199 个带注释的数据点，其中情绪强度被定义为从强负到强正，线性标度从 3 到+3。

模式是-

文本

2.声音的

3.演讲

Amount of contribution of each modality on sentiment prediction

转录起始位点预测(TSS)数据集— 转录是基因表达的第一步，其中 DNA 的特定片段被复制成 RNA (mRNA)。转录起始位点是转录开始的位置。DNA 片段的不同部分具有影响其存在的不同特性。我们把 TSS 分成三部分-

上游 DNA
下游 DNA
TSS 区域

我们取得了前所未有的 3%的进步，超过了之前的最高水平。具有 TATA 盒的下游 DNA 区域对该过程影响最大。

我们还对合成生成的数据进行了实验，以验证我们的理论。

现在，我们正在起草一篇论文，准备提交给一本 ML 期刊。

如果你有兴趣了解多模态学习的数学细节或范围，一般来说，在 purvanshi.mehta11@gmail.com 上 ping 我。欢迎对作品提出意见。

多模态图像到图像翻译

原文：https://towardsdatascience.com/multimodal-image-to-image-translation-c1ffaa5d5928?source=collection_archive---------3-----------------------

在这篇博客中，我将解释图像到图像的翻译，这就是通常所说的bicle gan。图像到图像转换的任务可以被认为是每个像素的回归或分类。但是可以用来解决这个问题的更有趣的方法是生成对抗网络。通过使用 GANs 获得的结果更健壮并且在感知上更真实。

在论文“走向多模态图像到图像翻译”中，目的是在给定输入图像的情况下生成输出图像的分布。基本上，它是使用条件生成对抗网络的图像到图像翻译模型的扩展。在 pix2pix 之前，许多人试图使用 GAN 无条件地解决这个问题，并且使用 L2 回归以输入为条件输出。除了变分自动编码器之外，我已经在我以前的博客中解释了条件 GAN。

在模型的第一部分，我们使用了一个条件变分自动编码器 GAN。想法是使用编码器网络学习目标图像的低维潜在表示，即，已经生成所有目标图像的概率分布，并且我们尝试该分布接近正态分布，以便在推断时间期间容易采样。接下来，我们使用一个生成器，使用编码表示 z 将输入图像映射到输出图像。

在图像的第二部分，我们使用了条件隐回归子 GAN。在这种情况下，从正态分布 N(z)中采样 z，除了输入图像 A 之外，该正态分布 N(z)还被馈送到生成器以获得输出图像。这个输出图像然后被馈送到编码器网络以输出 z ’,我们试图使它接近 N(z)。经过这两步，我们计算损失函数。最终损失函数如下所示:

其中 G、D 和 E 代表发生器、鉴别器和编码器。

在该模型中，从潜在向量(z)到输出图像以及输出图像到潜在向量的映射是双射的。整体架构由两个循环组成，B-> z-> B’和 z-> B’--> z’，因此得名 BicycleGAN。该图清楚地总结了该架构。

要点:-

我们有 3 个不同的网络:a)鉴别器，b)编码器，和 c)发生器。
cVAE-GAN(条件变分自动编码器-生成对抗网络)被用于将地面真实输出图像 B 编码为潜在向量 z，然后潜在向量 z 被用于重构输出图像 B’，即，B-> z-> B’。
对于逆映射(z-> B’--> z’)，我们使用 LR-GAN(潜在回归生成对抗网络)，其中使用生成器从输入图像 A 和 z 生成 B’
结合这两个模型，我们得到了自行车根。
发生器的架构与 U-net 相同，其中存在具有对称跳跃连接的编码器和解码器网络。
对于编码器，我们使用几个残差块对输入图像进行有效编码。
使用批次大小为 1 的批次规范化，使用 Adam optimizer 来训练该模型。
泄漏 ReLU 激活功能用于所有类型的网络。

履行

我在 TensorFlow 中实现了 BicycleGAN，你可以在我的 GitHub 个人资料中找到它。

[## prakashpendey 9/自行车

NIPS 论文“多模态图像到图像翻译”的 BicycleGAN - Tensorflow 实现

github.com](https://github.com/prakashpandey9/BicycleGAN)

参考

https://arxiv.org/pdf/1711.11586.pdf

用于文本分析的多项式朴素贝叶斯分类器

原文：https://towardsdatascience.com/multinomial-naive-bayes-classifier-for-text-analysis-python-8dd6825ece67?source=collection_archive---------1-----------------------

机器学习最流行的应用之一是分类数据的分析，特别是文本数据。问题是，有很多关于数字数据的教程，但是关于文本的很少。考虑到我过去关于机器学习的大多数博客都是基于 Scikit-Learn 的，我决定通过自己实现整个事情来玩玩这个。

在这篇博客中，我将介绍如何为 20 个新闻组数据集实现多项式朴素贝叶斯分类器。20 个新闻组数据集包含大约 18000 个关于 20 个主题的新闻组帖子，分为两个子集:一个用于培训(或开发)，另一个用于测试(或性能评估)。训练集和测试集之间的划分基于在特定日期之前和之后发布的消息。

图书馆

首先，让我们导入编写实现所需的库:

**import** **numpy** **as** **np**
**import** **pandas** **as** **pd**
**import** **matplotlib.pyplot** **as** **plt**
**import** **operator**

阶级分布

首先，我们计算每个类中文档的比例:

*#Training label*
train_label = open('20news-bydate/matlab/train.label')

*#pi is the fraction of each class*
pi = {}

*#Set a class index for each document as key*
**for** i **in** range(1,21):
    pi[i] = 0

*#Extract values from training labels*
lines = train_label.readlines()

*#Get total number of documents*
total = len(lines)

*#Count the occurence of each class*
**for** line **in** lines:
    val = int(line.split()[0])
    pi[val] += 1

*#Divide the count of each class by total documents* 
**for** key **in** pi:
    pi[key] /= total

print("Probability of each class:")
print("**\n**".join("**{}**: **{}**".format(k, v) **for** k, v **in** pi.items()))

词汇的概率分布

让我们首先创建熊猫数据框架

*#Training data*
train_data = open('20news-bydate/matlab/train.data')
df = pd.read_csv(train_data, delimiter=' ', names=['docIdx', 'wordIdx', 'count'])

*#Training label*
label = []
train_label = open('/home/sadat/Downloads/HW2_210/20news-bydate/matlab/train.label')
lines = train_label.readlines()
**for** line **in** lines:
    label.append(int(line.split()[0]))

*#Increase label length to match docIdx*
docIdx = df['docIdx'].values
i = 0
new_label = []
**for** index **in** range(len(docIdx)-1):
    new_label.append(label[i])
    **if** docIdx[index] != docIdx[index+1]:
        i += 1
new_label.append(label[i]) *#for-loop ignores last value*

*#Add label column*
df['classIdx'] = new_label

df.head()

每类每个单词的概率

为了计算我们的概率，我们将找到给定类别中每个单词的平均值。

对于 j 类和单词 I，平均值由下式给出:

但是，由于一些单词的计数为 0，我们将使用 low 执行拉普拉斯平滑:

其中 V 是词汇表中所有单词的数组

*#Alpha value for smoothing*
a = 0.001

*#Calculate probability of each word based on class*
pb_ij = df.groupby(['classIdx','wordIdx'])
pb_j = df.groupby(['classIdx'])
Pr =  (pb_ij['count'].sum() + a) / (pb_j['count'].sum() + 16689)    

*#Unstack series*
Pr = Pr.unstack()

*#Replace NaN or columns with 0 as word count with a/(count+|V|+1)*
**for** c **in** range(1,21):
    Pr.loc[c,:] = Pr.loc[c,:].fillna(a/(pb_j['count'].sum()[c] + 16689))

*#Convert to dictionary for greater speed*
Pr_dict = Pr.to_dict()

Pr

停止言语

停用词是在每个文档中出现很多的词(例如介词和代词)。

*#Common stop words from online*
stop_words = [
"a", "about", "above", "across", "after", "afterwards", 
"again", "all", "almost", "alone", "along", "already", "also",    
"although", "always", "am", "among", "amongst", "amoungst", "amount", "an", "and", "another", "any", "anyhow", "anyone", "anything", "anyway", "anywhere", "are", "as", "at", "be", "became", "because", "become","becomes", "becoming", "been", "before", "behind", "being", "beside", "besides", "between", "beyond", "both", "but", "by","can", "cannot", "cant", "could", "couldnt", "de", "describe", "do", "done", "each", "eg", "either", "else", "enough", "etc", "even", "ever", "every", "everyone", "everything", "everywhere", "except", "few", "find","for","found", "four", "from", "further", "get", "give", "go", "had", "has", "hasnt", "have", "he", "hence", "her", "here", "hereafter", "hereby", "herein", "hereupon", "hers", "herself", "him", "himself", "his", "how", "however", "i", "ie", "if", "in", "indeed", "is", "it", "its", "itself", "keep", "least", "less", "ltd", "made", "many", "may", "me", "meanwhile", "might", "mine", "more", "moreover", "most", "mostly", "much", "must", "my", "myself", "name", "namely", "neither", "never", "nevertheless", "next","no", "nobody", "none", "noone", "nor", "not", "nothing", "now", "nowhere", "of", "off", "often", "on", "once", "one", "only", "onto", "or", "other", "others", "otherwise", "our", "ours", "ourselves", "out", "over", "own", "part","perhaps", "please", "put", "rather", "re", "same", "see", "seem", "seemed", "seeming", "seems", "she", "should","since", "sincere","so", "some", "somehow", "someone", "something", "sometime", "sometimes", "somewhere", "still", "such", "take","than", "that", "the", "their", "them", "themselves", "then", "thence", "there", "thereafter", "thereby", "therefore", "therein", "thereupon", "these", "they",
"this", "those", "though", "through", "throughout",
"thru", "thus", "to", "together", "too", "toward", "towards",
"under", "until", "up", "upon", "us",
"very", "was", "we", "well", "were", "what", "whatever", "when",
"whence", "whenever", "where", "whereafter", "whereas", "whereby",
"wherein", "whereupon", "wherever", "whether", "which", "while", 
"who", "whoever", "whom", "whose", "why", "will", "with",
"within", "without", "would", "yet", "you", "your", "yours", "yourself", "yourselves"
]

现在，让我们创建词汇数据框架

vocab = open('vocabulary.txt') 
vocab_df = pd.read_csv(vocab, names = ['word']) 
vocab_df = vocab_df.reset_index() 
vocab_df['index'] = vocab_df['index'].apply(**lambda** x: x+1) vocab_df.head()

获取词汇表中每个单词的计数并将停用词设置为 0:

*#Index of all words*
tot_list = set(vocab_df['index'])

*#Index of good words*
vocab_df = vocab_df[~vocab_df['word'].isin(stop_words)]
good_list = vocab_df['index'].tolist()
good_list = set(good_list)

*#Index of stop words*
bad_list = tot_list - good_list

*#Set all stop words to 0*
**for** bad **in** bad_list:
    **for** j **in** range(1,21):
        Pr_dict[j][bad] = a/(pb_j['count'].sum()[j] + 16689)

多项式朴素贝叶斯分类器

将 P 的概率分布与属于每个类别的文档的分数相结合。

对于类 j ，字频为 f 的字 i :

为了避免下溢，我们将使用对数总和:

一个问题是，如果一个词再次出现，它再次出现的概率会上升。为了平滑这一点，我们取频率的对数:

此外，为了将停用词考虑在内，我们将为每个词添加逆文档频率(IDF)权重:

尽管对于这个特定的用例，停用词已经被设置为 0，但还是添加了 IDF 实现来一般化该函数。

*#Calculate IDF* 
tot = len(df['docIdx'].unique()) 
pb_ij = df.groupby(['wordIdx']) 
IDF = np.log(tot/pb_ij['docIdx'].count()) 
IDF_dict = IDF.to_dict()**def** MNB(df, smooth = **False**, IDF = **False**):
    *'''*
 *Multinomial Naive Bayes classifier*
 *:param df [Pandas Dataframe]: Dataframe of data*
 *:param smooth [bool]: Apply Smoothing if True*
 *:param IDF [bool]: Apply Inverse Document Frequency if True*
 *:return predict [list]: Predicted class ID*
 *'''*
    *#Using dictionaries for greater speed*
    df_dict = df.to_dict()
    new_dict = {}
    prediction = []

    *#new_dict = {docIdx : {wordIdx: count},....}*
    **for** idx **in** range(len(df_dict['docIdx'])):
        docIdx = df_dict['docIdx'][idx]
        wordIdx = df_dict['wordIdx'][idx]
        count = df_dict['count'][idx]
        **try**: 
            new_dict[docIdx][wordIdx] = count 
        **except**:
            new_dict[df_dict['docIdx'][idx]] = {}
            new_dict[docIdx][wordIdx] = count

    *#Calculating the scores for each doc*
    **for** docIdx **in** range(1, len(new_dict)+1):
        score_dict = {}
        *#Creating a probability row for each class*
        **for** classIdx **in** range(1,21):
            score_dict[classIdx] = 1
            *#For each word:*
            **for** wordIdx **in** new_dict[docIdx]:
                *#Check for frequency smoothing*
                *#log(1+f)*log(Pr(i|j))*
                **if** smooth: 
                    **try**:
                        probability=Pr_dict[wordIdx][classIdx]         
                        power = np.log(1+ new_dict[docIdx][wordIdx])     
                        *#Check for IDF*
                        **if** IDF:
                            score_dict[classIdx]+=(
                               power*np.log(
                               probability*IDF_dict[wordIdx]))
                        **else**:
                            score_dict[classIdx]+=power*np.log(
                                                   probability)
                    **except**:
                        *#Missing V will have log(1+0)*log(a/16689)=0* 
                        score_dict[classIdx] += 0                        
                *#f*log(Pr(i|j))*
                **else**: 
                    **try**:
                        probability = Pr_dict[wordIdx][classIdx]        
                        power = new_dict[docIdx][wordIdx]               
                        score_dict[classIdx]+=power*np.log(
                                           probability) 
                        *#Check for IDF*
                        **if** IDF:
                            score_dict[classIdx]+= power*np.log(
                                   probability*IDF_dict[wordIdx]) 
                    **except**:
                        *#Missing V will have 0*log(a/16689) = 0*
                        score_dict[classIdx] += 0      
            *#Multiply final with pi* 
            score_dict[classIdx] +=  np.log(pi[classIdx])                          

        *#Get class with max probabilty for the given docIdx* 
        max_score = max(score_dict, key=score_dict.get)
        prediction.append(max_score)

    **return** prediction

比较平滑和 IDF 的效果:

regular_predict = MNB(df, smooth=**False**, IDF=**False**)
smooth_predict  = MNB(df, smooth=**True**, IDF=**False**)
tfidf_predict   = MNB(df, smooth=**False**, IDF=**True**)
all_predict     = MNB(df, smooth=**True**, IDF=**True**)*#Get list of labels*
train_label = pd.read_csv('20news-bydate/matlab/train.label',
                          names=['t'])
train_label= train_label['t'].tolist()total = len(train_label) 
models = [regular_predict, smooth_predict, 
          tfidf_predict, all_predict] 
strings = ['Regular', 'Smooth', 'IDF', 'Both'] 

**for** m,s **in** zip(models,strings):
    val = 0
    **for** i,j **in** zip(m, train_label):
        **if** i != j:
            val +=1
        **else**:
            **pass**   
    print(s,"Error:**\t\t**",val/total * 100, "%")

正如我们所看到的，IDF 几乎没有影响，因为我们删除了停用词。
然而，平滑使模型更加精确。

因此，我们的最佳模型是:

测试数据

现在我们有了模型，让我们用它来预测我们的测试数据。

*#Get test data*
test_data = open('20news-bydate/matlab/test.data')
df = pd.read_csv(test_data, delimiter=' ', names=['docIdx', 'wordIdx', 'count'])

*#Get list of labels*
test_label = pd.read_csv('/home/sadat/Downloads/HW2_210/20news-bydate/matlab/test.label', names=['t'])
test_label= test_label['t'].tolist()

*#MNB Calculation*
predict = MNB(df, smooth = **True**, IDF = **False**)

total = len(test_label)
val = 0
**for** i,j **in** zip(predict, test_label):
    **if** i == j:
        val +=1
    **else**:
        **pass**print("Error:**\t**",(1-(val/total)) * 100, "%")

使用 Clustal Omega 和 T-Coffee 的多序列比对

原文：https://towardsdatascience.com/multiple-sequence-alignment-using-clustal-omega-and-t-coffee-3cc662b1ea82?source=collection_archive---------1-----------------------

3 个或更多生物序列的序列比对

你想知道科学家如何识别三个或更多生物序列中的相似区域吗？正如我在上一篇文章中所描述的，序列比对是一种排列 DNA、RNA 或蛋白质序列以识别相似区域的方法。在我最近一篇关于生物信息学的文章中，我已经讨论了关于 两两序列比对 。一定要检查他们。多序列比对与成对序列比对非常相似，但它使用三个或更多个序列，而不是只有两个序列。

在本文中，我将带您完成多重序列比对。此外，我们将使用 Clustal Omega 和 T-Coffee 测试一些示例，这些示例将使用 Biopython 测试一些编码示例。

Figure 1: Results from T-Coffee

什么是多序列比对？

在多序列比对(MSA) 中，我们试图比对 三个或三个以上相关序列 ，以达到它们之间的最大匹配。MSA 的目标是排列一组序列，使每个序列中尽可能多的字符根据某种评分函数进行匹配。

Figure 2: Image Source: https://openi.nlm.nih.gov/detailedresult.php?img=PMC2921379_1756-0500-3-199-1&req=4

得分

MSA 的评分过程是根据某个评分矩阵，基于多重比对中所有可能的序列对的得分之和。你可以参考我的上一篇文章来了解不同的评分矩阵以及如何匹配。

多重比对得分= ∑得分(A，B)

其中 score(A，B)= A，B 的成对比对分数。

例子

Sequence 1:    **G   K   N**
Sequence 2:    **T   R   N**
Sequence 3:    **S   H   E**
Sum of pairs: **-1 + 1 + 6 = 6**

第二列的和= score (K，R) + score (R，H) + score (K，H) = 2+0+-1 = 1

MSA 的目标是达到对的最大和。

多序列比对的类型

比对三个或更多个序列可能很困难，手动比对几乎总是很耗时。因此，使用计算算法来产生和分析这些比对。大多数 MSA 算法采用动态规划和启发式方法。

下面给出了使用启发式方法的 MSA 技术。

渐进式排列结构
迭代比对构建
基于块的对齐

这些方法可以在所有可能的解决方案中找到解决方案，但它们不能保证找到最佳解决方案。因此它们被认为是近似值，但是我们可以很容易地在短时间内找到接近实际值的解。

渐进式线形施工

这种方法也被称为分层或树形方法，是由 Paulien Hogeweg 和 Ben Hesper 于 1984 年开发的。它通过组合从最相似的配对开始并前进到最远相关的配对的成对比对来构建最终的 MSA 。

目前使用的两种流行的渐进对准方法是，

Clustal Omega
T-Coffee

迭代线形施工

该方法由一组产生MSA的方法组成，同时减少了渐进方法中固有的误差。它们的工作方式类似于渐进式方法，但会反复重新排列初始序列，并向不断增长的 MSA 添加新序列。

软件包 PRRN/PRRP 基于爬山算法优化其 MSA 比对分数。

基于块的对齐

这种方法将序列分成块，并试图识别许多序列共有的无缺口比对的块。

DIALIGN2 是一种流行的基于块的比对方法。

练习时间到了

你期待的时刻到了。是时候尝试一些工具和例子了。我将用 Clustal Omega 和 T-Coffee 向大家展示几个 MSA 的例子。你可以在网上试用这些工具。

Clustal 欧米茄

转到http://www.ebi.ac.uk/Tools/msa/clustalo/。

Figure 3: Clustal Omega

您将看到一个页面，选择数据类型(蛋白质、DNA 或 RNA)，输入序列(或上传支持格式的文件)并设置输出格式。

我将用下面的 10 个棘冠海星**(俗称 棘冠海星 )的基因组序列(DNA)来做这个演示。你可以从这里下载一个生物体的完整基因组。fsa 格式。**

一个 FSA 文件(。fsa) 是由 DNA 测序仪和分析仪创建的片段分析数据文件。

10 sequences from the genome of Acanthaster planci (commonly known as Crown-of-thorns starfish)

输入序列并选择参数后，您可以提交任务。可以按如下方式查看作业的结果。您可以从点击查看该示例的结果。

Figure 4: Results of the job on Clustal Omega

您可以使用下载结果作为校准文件。aln 扩展名通过点击下载对齐文件按钮。

t-咖啡

去 http://tcoffee.crg.cat/apps/tcoffee/index.html。

Figure 5: T-Coffee

在本次演示中，我选择了 DNA 部分下的联合收割机常用对齐器(M-Coffee) 。然后你会看到一个页面来输入序列(或者上传一个支持格式的文件)。

Figure 6: M-Coffee input page

我将使用我用来演示 Clustal Omega 的同一个文件。输入序列后，您可以提交作业。可以按如下方式查看作业的结果。你可以从这里查看这个例子的结果。

Figure 7: Results for the job on T-Coffee

Clustal Omega 和 T-Coffee 的 Biopython 包装

Biopython ，我曾在我的上一篇文章中介绍过，它由用于 Clustal Omega 、 T-Coffee 和许多其他工具的命令行包装器组成，如 ClustalW 和diaign**。您可以在这里查看 中的所有包装器和示例代码。在下一个例子中，我将展示如何使用 Clustal Omega 包装器。**

要运行 Clustal Omega 包装器，首先您应该下载它的预编译二进制文件。你可以从这里下载。将下载一个二进制文件。您可以使用下面给出的命令使其成为可执行文件。根据您下载的二进制文件版本，二进制文件的名称可能会有所不同。在我的机器上，它被下载为clus tal-omega-1 . 2 . 3-ma cosx**。**

**chmod 777 clustal-omega-1.2.3-macosx**

我将使用相同的。以前使用的 fsa** 文件，对于这个例子也是如此。**

以下代码使用 Clustal Omega 包装器为给定输入开发 MSA 。fsa 文件。如果你有这种能力，那就容易了。fsa 文件，。py 文件和可执行二进制文件放在同一个位置。

运行完这段 python 代码后，您将得到一个命令作为输出。路径可能会根据您放置文件的位置而变化。

**clustalo -i /Users/vijinimallawaarachchi/Documents/Python/Acanthaster_planci_Gnomon.fsa -o aligned.fasta — auto -v**

Figure 8: Output command

现在用如下所示的命令执行下载的二进制文件。确保用替换离合器。/clus tal-omega-1 . 2 . 3-ma cosx****

**./clustal-omega-1.2.3-macosx -i /Users/vijinimallawaarachchi/Documents/Python/Acanthaster_planci_Gnomon.fsa -o aligned.fasta --auto -v**

您将会得到以下结果，表明已经进行了渐进式比对。

Figure 9: Final result

现在你可以看到一个名为 aligned.fasta 的文件已经在与你的文件相同的位置形成。一旦你打开它，你可以看到 FASTA 格式的排列。

****FASTA 格式是一种基于文本的格式，用于表示核苷酸序列或肽序列，其中核苷酸或氨基酸用单字母代码表示。该格式还允许序列名称和注释位于序列之前。该格式起源于 FASTA 软件包，但现在已经成为生物信息学领域的标准。

Figure 10: Output file in FASTA format

希望你喜欢读这篇文章，并学到一些有用和有趣的东西。

因为我对这个领域还很陌生，所以我想听听你的建议。😇

感谢阅读…😃

多任务学习:教你的人工智能更多，使之更好

原文：https://towardsdatascience.com/multitask-learning-teach-your-ai-more-to-make-it-better-dde116c2cd40?source=collection_archive---------4-----------------------

https://bitesizebio.com/27766/multitasking-lab-not-multitasking/

大家好！今天，我想告诉你关于机器学习的话题，一方面，这是非常面向研究的，应该把机器学习算法带到更像人类的推理中，另一方面，这是我们从机器学习的基础中非常熟悉的，但很少被解释为我今天想要展示的。这被称为多任务学习，它(几乎)与上图中的多任务无关。在这篇文章中，我将展示什么是人类和算法的多任务学习，今天的研究人员如何应用这一概念，你如何用它来解决你的任何问题以提高你的模型的性能。最重要的是，我将为您提供源代码和 4 个用例的解释(从照片中识别情感，用加速度计数据识别运动，暹罗网络助推和解决数字挑战:全部使用多任务学习！)，你可以用它作为你自己项目的模板(我希望是灵感)!

这篇文章的灵感来自于 Sebastian Ruder 和丰富的卡鲁阿纳资料。

如果想直接跳转到 Keras 中的代码，这里的就是对应的 GitHub repo。我也在数据科学 UA 会议上做了一个关于这个话题的演讲，幻灯片也即将上传。

我们的多任务处理

“一心多用”这个词本身通常意味着一些负面的东西——一个人试图做很多事情，但没有一件成功就是最好的例子。但在这里我想谈谈有点不同的“多任务处理”。我想想象一下，我们生物大脑的所有功能都是某种深度神经网络，它也经过反向传播训练，并给出一些标签作为输出。如果我这样想我的视觉系统，当我看东西时，它会输出什么？我不仅能识别物体，分割它们，还能理解场景。我还可以估计街上人们的情绪，他们的穿着，根据他们的穿着判断天气，我可以估计这是哪个国家甚至是哪个城市，以及许多其他重要的细节，这些都让我从视觉渠道获得了非常丰富的理解。

好吧，那听呢？如果我听到任何人的声音，我会立即理解一个人的性别、音调，我理解单词、整个句子和意思，我知道语言，我理解所有的实体，甚至能够回答我听到的。

我可以用我的任何感觉系统做同样的练习——我总是从一个单一的“测试”例子中感受到很多东西，不管它是什么——一张图片、一个声音、一段文字甚至一种感觉。

机器的多任务处理

另一方面，现代神经网络(和其他机器学习算法)通常从单个例子中解决单个问题——它可以是分类、回归、结构化预测、异常检测甚至是对象生成，但通常，我们期望最终是单个事情。在这篇博客中，我想谈谈并展示我们如何让我们的模型学习更多的东西，我将从一个我们已经知道多年的多任务学习的例子开始:

Well-known L2 regularization for a loss function

你说得对，我们都知道这个著名的 L2 正则化公式。为什么我说是多任务学习的例子？因为我们同时解决了两个优化问题:损失函数最小化和使我们的参数 w 的范数更小。我们通常不会深入思考这个问题，但选择这个特定的第二优化函数背后有很多理论:

Different explanations of a regularization effect

例如，安德烈 吉洪诺夫主要对解决逆不适定问题感兴趣，通过参数范数添加正则化帮助他实现问题的平滑和良好调节。波兰数学家 Zaremba 将它引入统计学习理论，因为模型的复杂性非常小，因此我们将其最小化。从 Bayes 的的观点来看，这样我们就把我们的权重设定为某种特定的分布——这些是我们对参数的先验。当然，我们大多数人在一些课程中学习过它，我们并不真正担心它，但我们知道它可以防止我们的模型过度拟合:)

如你所见，在这些解释中，我们只考虑模型本身的参数。但是从我的直觉角度(以及我大脑中的神经网络)我想从推理的角度更具体地解释它。我可以添加一些考虑到问题的“真实的”、“类似人类的”背景的“正则化”吗？如果我想从照片中识别情绪，我应该限制权重以“知道”鼻子和嘴唇的运动吗？很可能是的。如果我想翻译一篇文章，知道给定单词的词性能对我的参数有帮助吗？我想会的。如果我正在处理信号处理问题，我是否希望我的模型能够对给定时间序列的过去和未来有一些直觉？可能会很有帮助！

http://ruder.io/multi-task/

所有这些“知道”，“调节”我可以作为一个额外的输入纳入机器学习算法，但自从我在这里开始谈论多任务学习…你现在明白我在领导什么了。如果算法参数的正则化这样的额外损失有助于更好的性能，为什么我们不尝试从人类逻辑的角度来看应该有助于性能的额外损失？然后，我们的算法将看起来像上面的图片:一个单一的输入，几个层(在神经网络的情况下)和许多输出，可以发挥一些超参数λ的正则化作用，或一个独立的目标，也希望优化和解决。

是的，除了多任务学习的“正规化”动机之外，我们只能承认，学习一个神经网络来同时解决 X 个问题，而不是拥有 X 个独立的神经网络，从简单的工程角度来看，这要酷得多。更好的性能、规范化和通用化是额外的收获。

动机用例

在开始深入细节之前，我想展示一些激励人心的例子。第一个是计算机视觉方面的惊人研究，他们不仅展示了单个神经网络如何同时解决 20 多项任务，而且还自动建立了 2D 和 3D 空间中不同任务的层次结构(这就是为什么它被称为 Taskonomy ),并显示了与将一项任务的学习转移到另一项任务相比，性能有所提高。这项工作是一个惊人的灵感，关于如何把一个单一图像的复杂理解纳入一个单一的算法。

[## 斯坦福大学

Taskonomy:解开任务迁移学习，CVPR 2018(最佳论文)。斯坦福大学伯克利分校。我们提议完全…

taskonomy.stanford.edu](http://taskonomy.stanford.edu/)

第二个很好的例子是自然语言处理:为什么我们不使用一个神经网络来解决情感分析、语义解析、翻译、回答问题、翻译单个句子呢？Salesforce 的研究人员也这么认为，并开发了他们自己的创造性解决方案。

[## decaNLP

深度学习显著提高了自然语言处理(NLP)任务的最新性能，但…

decanlp.com](http://decanlp.com)

在我负责机器学习的 Mawi Solutions 中，我们还将多任务学习的概念应用于实时心电图分析。在测量 ECG 期间，我们需要标记其形态结构以供进一步分析，估计信号质量，并在每秒相同的时间解决异常检测任务。我们可以在一部手机上同时运行三种不同的算法(不一定是机器学习算法)，但我们成功地用一个单一的神经网络解决了它们，与不同方法的组合相比，这个神经网络明显更快、更准确。

Multitask learning for live ECG analysis in Mawi Solutions

作为“类人”行为的一个重要概念，多任务学习对于强化学习也非常重要。一个很好的例子可以是 DeepMind 的工作发狂:我们建议共享一个“提炼”的策略，捕捉跨任务的共同行为，而不是共享不同损失之间的参数。

Distral: Robust Multitask Reinforcement Learning

工作的理由

好吧，这一切都很酷，但仍然不太清楚它为什么工作。为什么添加不同的，甚至相近的任务可以帮助学习主要任务，或者为什么他们可以一起学习？

**正则化:**附加损失原则上与不同研究者从正则化中得到的结果是一样的:它平滑了损失函数，最小化了模型的复杂性，并为模型提供了非常有用的先验信息。
**表示偏差:**当你在几个任务的交集上训练你的模型时，你推动你的学习算法在交集上的较小表示区域而不是单个任务的较大区域上寻找解决方案。它导致更快更好的收敛。
**特性选择仔细检查:**如果一个特性对于不止一个任务是重要的，那么很可能这个特性对于您的数据来说确实是非常重要和有代表性的
**迁移学习:**机器学习已经从学习几项任务中受益，但顺序使用迁移学习:在一项任务的大型数据集上预先训练一个模型，然后使用获得的模型在其上训练另一项任务。经验结果表明，联合学习这些任务会更有益处，而且肯定会更快。
**不能成为输入的输出:**这一刻对我个人来说是最有趣的。有一些特殊类型的数据，由于它们的顺序性质，受到过去观察的制约，通常我们需要处理它们:句子中的单词(必须预测下一个单词、帧和视频，必须预测下一帧，等等)。我们希望这些过去时刻的表示能够模拟未来的时刻——在这里，辅助任务如此自然地出现——过去的帧必须预测下一帧，而我们不能将这些帧用作输入！其他很好的例子是那些在测试/生产阶段很难或者很长而无法计算的特性，但是我们可以使用它们作为辅助损失函数来规范我们的模型，以便“了解”它们。

Predicting next frame in a video cant be a very informative prior: https://coxlab.github.io/prednet/

每个人的辅助任务

好吧，也许现在你或多或少地相信多任务学习很酷，对研究人员有用，背后有一些理论和经验动机。但是你可能会回答我，在你的项目中你并不真的需要它，因为你不需要同时解决几个任务，或者你只是没有数据集的额外标签，或者没有可能得到它们。在这一部分，我想展示一些辅助损失的例子，你们中的每一个人都可以在任何项目中使用，作为一个额外的正则项，这将提高你们的绩效。

自然语言处理您可以预测句子中的下一个单词，作为您希望模型拥有的先验知识。
- NLTK:词性、句子树、NER——你确定你的深度学习不会从它们那里受益？如前所述，尝试来自 NLTK 或 spacy 的基本 NLP 功能。
  -de clalp:清晰的灵感:)
计算机视觉你在 OpenCV 、 scikit-image 或者 dlib 里都有。
- 任务经济:清晰灵感:)
信号处理
一般建议
-自动编码器/生成式建模，因为模型推动任何表示尽可能最有用和最具描述性
-提示(预测重要特征，如计算机视觉中的 HOG、NLP 中的 NER 和 DSP 中的熵)

关于可重复性研究的一个注记

在展示如何实现多任务学习之前，我想展示我必须做些什么来使我在 Keras 中的代码至少在某种程度上可以在另一台计算机上重现(但这仍然不够，正如我在基辅的工作室所展示的那样)。首先，我必须修复所有随机种子:

random.seed(42)
np.random.seed(42)
tf.set_random_seed(42)

修复神经网络层的初始化器并运行会话:

my_init = initializers.glorot_uniform(seed=42)session_conf = tf.ConfigProto(intra_op_parallelism_threads=1,
                              inter_op_parallelism_threads=1)
sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)
K.set_session(sess)

并在创建数据集时修复随机种子:

train_test_split(X, Y1, Y2, Y3, random_state = 42)

甚至在训练一个模型时设置“shuffle = False”。此外，我将模型和训练条件的所有超参数固定为时期数、优化器和批量大小。但是这还不够。在某些电脑上(我在 MacBook Air 上运行我的代码),结果与我的略有不同。我只能这样解释(感谢听觉的提示):不同的硬件导致不同的浮点数错误，从而导致不同 CPU 上的优化过程略有不同。我想知道是否有办法克服这一点(我正在考虑在每个训练过程之前重新初始化随机种子)，并非常感谢任何提示。

练习 1:情绪识别

正如我所承诺的，本文将有几个代码示例，因此您可以尝试自己进行多任务学习(主要集中在使用附加任务作为正则项)。第一个例子与计算机视觉有关，特别是与数据集有关(数据集不是免费分发的，但您可以出于研究目的请求访问):

[## 匹兹堡的情感分析小组

编辑描述

www.pitt.edu](http://www.pitt.edu/~emotion/ck-spread.htm)

我的完整代码在这里:

[## 拉赫诺格/教育

我的讲座和机器学习自学材料- Rachnog/education

github.com](https://github.com/Rachnog/education/tree/master/multitask_dsua_2018/emotion_detection)

该数据集由不同人的图像和相应的标签组成:

他们脸上表达的情感
面部动作单元(后来的 FAU，见更多信息这里
面部关键点

我们将使用一个非常简单的神经网络(与最先进的网络相比)作为主要任务的情感识别，并将尝试调整 FAU 和关键点检测作为正则化。这是一个我们将尝试用多任务学习来增强的神经网络。如你所见，2018 深度学习时代我们很容易称之为“浅”:

visible = Input(shape=input_shape)
x = Conv2D(10, kernel_size=3, activation='elu', padding='same', kernel_initializer=my_init)(visible)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Conv2D(20, kernel_size=3, activation='elu', padding='same', kernel_initializer=my_init)(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Conv2D(30, kernel_size=3, activation='elu', padding='same', kernel_initializer=my_init)(x)
x = GlobalMaxPooling2D()(x)
output = Dense(Y_train.shape[1], activation='softmax', kernel_initializer=my_init)(x)
model = Model(inputs=visible, outputs=output)

它显示了以下结果(当然这并不令人满意):

precision    recall  f1-score   support

          0       0.39      0.56      0.46       149
          1       0.00      0.00      0.00        10
          2       0.00      0.00      0.00        71
          3       0.32      0.11      0.16        74
          4       0.47      0.64      0.54       163
          5       0.44      0.11      0.17        64
          6       0.38      0.54      0.44       130

avg / total       0.36      0.41      0.36       661

接下来，我为一个必须预测面部动作单元和情绪的模型添加了第二个输出:

output2 = Dense(Y_train2.shape[1], activation='sigmoid', name = 'facs', kernel_initializer=my_init)(x)

而且成绩变得稍微好一点！

precision    recall  f1-score   support

          0       0.58      0.36      0.44       149
          1       0.00      0.00      0.00        10
          2       0.47      0.27      0.34        71
          3       0.36      0.65      0.46        74
          4       0.56      0.83      0.67       163
          5       0.56      0.08      0.14        64
          6       0.62      0.68      0.65       130

avg / total       0.53      0.53      0.49       661

好吧，如果这个辅助损失有帮助，也许预测关键点也可以很好？至少它的表现也比基线要好:

precision    recall  f1-score   support

          0       0.69      0.34      0.45       149
          1       0.00      0.00      0.00        10
          2       0.71      0.07      0.13        71
          3       0.38      0.65      0.48        74
          4       0.52      0.88      0.65       163
          5       0.50      0.05      0.09        64
          6       0.53      0.72      0.61       130

avg / total       0.56      0.52      0.46       661

好的，看起来现在我有两个辅助损失，它们都很好地规范了我的基线解，所以我想把它们结合起来，我希望得到更好的结果。我会用一种“聪明”的方式来做这件事。我知道，当我(作为一个人)分解我自己的情绪识别时，我首先看到关键点，在我将它们组合成行动单元之后，只有在最后，我才能从这个特征层次中理解情绪。就神经网络而言，这可能意味着我应该将 FAU 损失附加到第一卷积层，将关键点损失附加到第二卷积层，并将主要损失留在最后:

visible = Input(shape=input_shape)
x1 = Conv2D(10, kernel_size=3, activation='elu', padding='same', kernel_initializer=my_init)(visible)
x1 = MaxPooling2D(pool_size=(2, 2))(x1)
x2 = Conv2D(20, kernel_size=3, activation='elu', padding='same', kernel_initializer=my_init)(x1)
x2 = MaxPooling2D(pool_size=(2, 2))(x2)
x3 = Conv2D(30, kernel_size=3, activation='elu', padding='same', kernel_initializer=my_init)(x2)
x = GlobalMaxPooling2D()(x3)output = Dense(Y_train.shape[1], activation='softmax', name = 'emotion', kernel_initializer=my_init)(x)
output2 = Dense(Y_train2.shape[1], activation='sigmoid', kernel_initializer=my_init)(GlobalMaxPooling2D()(x2))
output3 = Dense(Y_train3.shape[1], activation='linear', kernel_initializer=my_init)(GlobalMaxPooling2D()(x1))model = Model(inputs=visible, outputs=[output, output2, output3])

为了避免“杀死”较低层主损失函数的梯度，我为第二层和第一层的损失 0.1 添加了λs:

model.compile(loss=['categorical_crossentropy', 'binary_crossentropy', 'mse'],
              optimizer=Adam(clipnorm = 1.), metrics = {'emotion': 'accuracy'}, loss_weights = [1, 1e-1, 1e-1])

我们为同样的 10 个纪元训练…然后…瞧！

precision    recall  f1-score   support

          0       0.75      0.56      0.64       149
          1       0.00      0.00      0.00        10
          2       0.79      0.27      0.40        71
          3       0.45      0.80      0.58        74
          4       0.67      0.88      0.76       163
          5       0.64      0.14      0.23        64
          6       0.61      0.78      0.68       130

avg / total       0.65      0.63      0.60       661

我们可以将我们的结果从 0.36 F1 分提高到 0.60 F1 分，只需以一种巧妙的方式使用额外的损失函数。同样的简单 convnet，同样的初始化器，同样的数据，同样的训练过程。看起来像魔术？那么让我们检查下一个例子。

练习 2:加速度计运动分析

你可以告诉我，通常情况下，除了主要损失之外，你没有像面部动作单位这样好的附加功能。没关系，现在我给你看一个任务的例子，你可以自己创造这些损失。该数据集是关于通过腕戴式加速度计对活动进行分类的:

https://archive . ics . UCI . edu/ml/datasets/Dataset+for+ADL+Recognition+with+腕式+加速度计

这是我解决这个问题的完整代码:

[## 拉赫诺格/教育

我的讲座和机器学习自学材料- Rachnog/education

github.com](https://github.com/Rachnog/education/tree/master/multitask_dsua_2018/accelerometer)

我的输入是加速度计的三个轴的多元时间序列，输出是 21 个活动类之一。没有附加额外的损失。我现在该怎么办？当然，创造一些！我选择了我认为合理的损失:

给定时间序列的标准偏差
时间序列的绝对变化之和
傅立叶系数。

我有一个假设，如果我的神经网络知道这些特征中的一个，它会比没有表现得更好。我首先用一个简单的 1D 卷积神经网络检查基线解决方案:

inn = Input(shape = (X_train.shape[1], X_train.shape[2], ))

x = Conv1D(16, 5, activation='relu', kernel_initializer=my_init)(inn)
x = MaxPooling1D(5)(x)
x = Conv1D(32, 5, activation='relu', kernel_initializer=my_init)(x)
x = MaxPooling1D(5)(x)
x = Conv1D(64, 5, activation='relu', kernel_initializer=my_init)(x)
x = GlobalMaxPooling1D()(x)
out = Dense(Y_test.shape[1], activation = 'softmax', kernel_initializer=my_init)(x)

model = Model(inputs=[inn], outputs=[out])

model.compile(loss='categorical_crossentropy',
              metrics = ['accuracy'], optimizer = Adam(clipnorm = 1.))

并得到如下精确回忆 F1:

avg / total       0.61      0.57      0.54       245

加上标准差损失怎么样？

avg / total       0.61      0.60      0.57       245

又用了一个的变化总和？

avg / total       0.57      0.60      0.57       245

好吧，他们都没多大帮助，但是傅立叶肯定是一个强有力的镜头…

avg / total       0.60      0.62      0.59       245

似乎我们可以将基线提高 5% ，但这也是一个不错的结果！我们经常使用不同的巧妙方法来争取这 5%的份额，所以现在你又多了一个

练习 3:加强暹罗网络

暹罗神经网络是一类特殊的模型，旨在在一个新的嵌入空间中比较对象:相似的对象必须彼此靠近(距离小)并且不同——远离(距离大)。为两幅 64x64 的图像计算欧几里德距离(在 MNIST 数据集的情况下)并不是一个明智的想法，但是我们可以将这些图像嵌入到一些向量空间中，这样做是有意义的。这一系列模型的主要特点是具有两个输入和在这些输入之间共享的层权重，以允许交换性(因为我们基本上计算两个对象之间的距离)。在本例中，我将展示向这些图层“袖子”中的每一个添加额外损失将如何提高 MNIST 数据集的性能。完整代码在这里:

[## 拉赫诺格/教育

我的讲座和机器学习自学材料- Rachnog/education

github.com](https://github.com/Rachnog/education/tree/master/multitask_dsua_2018/siamese_mt)

首先，我们为每个输入设置了一个编码器，如下所示:

input = Input(shape=input_shape)
x = Flatten()(input)
x = Dense(64, activation='relu')(x)
x = Dropout(0.1)(x)
m = Model(input, x)

如您所见，我们将输入图像嵌入某个 64 维空间，在那里我们可以比较它们，损失旨在最小化相同数量图像之间的距离，最大化不同数量图像之间的距离:

def contrastive_loss(y_true, y_pred):
    margin = 1
    sqaure_pred = K.square(y_pred)
    margin_square = K.square(K.maximum(margin - y_pred, 0))
    return K.mean(y_true * sqaure_pred + (1 - y_true) * margin_square)

我有一个假设，在这个 64 维嵌入空间中，我不仅可以比较图像，还可以对它们进行分类。**所以我的第二个损失将被简单分类成 10 位数的类别。**训练基线暹罗网络并将其作为分类器进行测试，结果如下:

* Accuracy on training set: 85.47%
* Accuracy on test set: 85.61%

伴随着一个附加损失:

* Accuracy on training set: 88.49%
* Accuracy on test set: 88.54%

就是这样。:)

练习 4:数字财务预测

我觉得这个博客已经太长了，但是不加上最后一个和财务预测有关的例子太有诱惑力了。numeri是一项关于加密金融数据的数据科学挑战，你已经为自己准备好了一切，剩下的就是——预测五个独立变量的 0 或 1，并且不要过度拟合训练数据。因为这里有几个目标是从数据中自然产生的(我知道多任务学习可以防止过度适应)，所以我决定尝试一下多任务。你可以在这里查看全部代码:

[## 拉赫诺格/教育

我的讲座和机器学习自学材料- Rachnog/education

github.com](https://github.com/Rachnog/education/tree/master/multitask_dsua_2018/numerai)

在这种情况下，我的额外损失不是辅助的，但它们都是重要的。所以，我像下面这样建立我的神经网络:

inputs = Input(shape=(50,))
c = Dense(100, activation='relu')(inputs)
c = Dropout(0.1)(c) predictions_target_bernie = Dense(1, activation='sigmoid', name = 'target_bernie')(c)
predictions_target_charles = Dense(1, activation='sigmoid', name = 'target_charles')(c)
predictions_target_elizabeth = Dense(1, activation='sigmoid', name = 'target_elizabeth')(c)
predictions_target_jordan = Dense(1, activation='sigmoid', name = 'target_jordan')(c)
predictions_target_ken = Dense(1, activation='sigmoid', name = 'target_ken')(c)

用相等的λs:

model.compile(loss='binary_crossentropy',               optimizer=Adam(lr = 0.0001), 
loss_weights = [0.2, 0.2, 0.2, 0.2, 0.2])

这种模型允许在实时财务数据上超过基准15 次，并且仍在计算。我认为这是一个不错的结果，我很高兴与你们分享。

9/15 on Numerai with multitask learning

结论

我知道所有这些材料可能有点让人不知所措，但别担心。我试图展示的一切可以被压缩成三个主要结论:

多任务学习对人类来说是正常的
多任务学习对于机器学习来说是正常的，而且，我们已经做了几十年了
下次你看到你过度拟合或没有从你的机器学习模型中获得最大收益，是时候思考了——也许你不需要更多的数据，但你需要更多的损失？

此外，我们回顾了一些关于多任务学习的实际用例，并学习了如何在 Keras 中对其进行编码，如何使用辅助损失并为其选择权重(至少在某些情况下)。我希望这篇博文对你有用，并且你会使用多任务学习的概念在你当前的项目中获得更好的结果！

附言
如果你觉得这个内容很有用，很有观点，你可以在 Bitclout 上支持我。关注我还可以在脸书上看到太短的人工智能文章，在 Instagram 上看到个人资料，在 Linkedin 上看到！

基于 ipyvolume 的 Jupyter 多体绘制:跨语言三维可视化

原文：https://towardsdatascience.com/multivolume-rendering-in-jupyter-with-ipyvolume-cross-language-3d-visualization-64389047634a?source=collection_archive---------3-----------------------

Jupyter 笔记本正在成为许多领域中数据科学的标准环境，随之而来的是可视化的需求。二维可视化可以说是最重要的，并且有丰富的库可供选择。其中许多都建立在 Python 世界中可视化的主力工具之上:Matplotlib。其他一些，如 plotly 、散景和 bqplot 通过提供完全交互式的情节更好地利用浏览器，能够以高帧率和平滑过渡进行缩放、平移和选择。

尽管 3D 可视化不经常使用，但有时理解内在的 3D 数据集(例如，脑部扫描)或 2D 投影难以理解的复杂结构是必不可少的。

Transparency in 2d, not a problem. Here showing a million points in bqplot (an open PR).

然而，三维可视化是困难的。虽然 2D 的透明度微不足道；它只需要混合操作，几乎不可能以可接受的帧率在 3D 中正确完成。事实上，这是一个活跃的研究领域。

对于 2D 的大型数据集，绘制每个单独的点没有意义。相反，使用数据的统计更有意义。datashader 和 vaex 采用的方法是将数据简化为 2d 直方图(或任何其他统计数据),并将其可视化为热图。

Showing 150 million taxi pickup locations in NYC by showing a heat map instead of individual points, using vaex with bqplot

体绘制

同样的技术可以用在 3D 中，除了 3D 立方体的渲染技术更加困难:它使用体积渲染，更具体地说是 v 体积光线投射。使用这种技术，光线会针对场景中的每个像素投射到场景中，并累积 3d 体积立方体中每个像素的 RGB 和 alpha 值，然后将它们混合在一起。

(left) Big data: exploring 100+ million rows by volume rendering a 3d histogram. (middle) Astronomical data cube: Radio observations. (right): Medical data cube: Scan of a male head.

一些数据集本质上是体积立方体。在射电天文学中，两个轴是天空坐标，第三个轴是频率轴，形成(通常)发射的 3d 强度立方体。在医学成像中，三个轴通常只是空间维度。

多体绘制

有时，需要在同一个场景中渲染多个大型数据集或多个数据立方体。它们可以重叠、完全重叠、部分重叠或完全不重叠。让事情变得更加复杂的是，一种称为最大强度投影的不同体绘制技术以不同的方式工作，这使得在同一场景中组合它们变得不同。事实上，我认为这使得多体积渲染至少和 3D 透明技术一样困难。

Glue-Jupyter uses ipyvolume for 3D rendering and also provides a richer UI and higher level data bookkeeping.

胶水对胶水-Jupyter

Glue 是一个用于多维链接数据探索的桌面应用程序，并在其 3D 可视化中使用多体积渲染，例如，可视化 3D 选择(如上面的截屏所示)。 Glue-jupyter (我正在进行的一个项目)旨在将 glue 引入 jupyter 笔记本。因此，它需要一个在 Jupyter 笔记本中进行多体积渲染的解决方案。Glue-jupyter 仍处于早期开发阶段，但已经提供了一种简单的现代方法来交互式地探索(多个)数据集，同时提供了从笔记本进行编程访问的功能。

Ipyvolume

Ipyvolume 是 Jupyter 笔记本最好的 3D 可视化软件包(免责声明:我是主要作者；).使用 ipyvolume，您可以在一个场景中进行散点图、颤动图和多体积渲染，只需几行代码，这并不容易！

Simple example showing volshow, scatter and quiver.

此外，ipyvolume 构建在 ipywidgets (前端部分的 Jupyter 小部件)之上，为您提供它开箱即用的所有功能。示例渲染 live 在文档中，绘图很容易嵌入到静态 HTML 文件中，能够在前端(浏览器)或内核端(Python 进程)轻松地将属性链接在一起，并监听属性的任何更改(双向通信的副产品)。此外，ipyvolume 重用了pytreejs，免费公开了大部分的 threejs API！使用 ipywebrtc ，我们可以录制电影，将它们传输到远程计算机或拍摄快照。

Multivolume rendering: male head scan and dark matter particle simulation in one scene.

从版本 0.5 开始， ipyvolume 支持多体积渲染，允许您可视化两个相互叠加的数据集。在左边的例子中，我们展示了一个人头部的扫描，同时展示了暗物质模拟中粒子的 3D 直方图。任意数量的数据立方体可以放在同一个场景中，这是 Jupyter 生态系统中可视化的一大壮举！据我所知，它是第一个为 Jupyter 做多体渲染的包。

大型数据立方体呢？

如果您正在使用远程 Jupyter 笔记本，可能使用 Jupyter Hub ，您将拥有两个世界的优势:您的代码接近数据，可视化在您的笔记本电脑/台式机上是本地的。然而，这意味着数据需要传输到客户机/浏览器，对于大型数据立方体来说，这可能相当大(是的，任何 3 次方的东西通常都很大)。为了解决这个问题，ipyvolume 将在默认情况下向浏览器发送低分辨率数据立方体。如果放大，会检测到边界框坐标的变化(yay ipywidgets！)，并且放大的更高分辨率剪切版本将被发送到浏览器。

After zooming in, a new high-resolution cutout will be sent to the browser.

跨语言

乐趣还不止于此，因为 ipyvolume 的大部分代码都是在浏览器中运行的前端代码(JavaScript ),所以我们可以将它用于其他语言。两个适马的 BeakerX 团队已经展示了它可以在所有 JVM 语言中使用(Java，Clojure，Groovy，Scala 等等)。

现在和 QuantStack 团队一起，我们正在构建 xvolume ，一个绑定到 ipyvolume 前端代码的 C++程序(是的，我应该把它重命名为 jupyter-volume，对吗？).

这意味着，通过一个单一的代码库(加上一些每种语言的胶水)，我们可以在 Jupyter 笔记本上为许多语言提供一个严肃的 3D 可视化包( ipyvolume )。

TL；灾难恢复版本/结论

从 ipyvolume 0.5 开始，我们为 Jupyter 生态系统提供了一个严肃的 3D 可视化包，它甚至可以使用混合渲染技术进行多体渲染，结合常规网格、散点和颤动图。重用前端代码，作为一个 Jupyter 小部件，我们可以在所有 JVM 语言和 C++中重用这个库。

特别感谢Casper van leeuw en以及所有其他为此 0.5 版本做出贡献的人！

一个可怕的数据故事的成分是什么？

原文：https://towardsdatascience.com/murdering-a-legendary-data-story-what-can-we-learn-from-a-grammar-of-graphics-ad6ca42f5e30?source=collection_archive---------5-----------------------

Photo by Caleb Woods on Unsplash

忽视图形的语法甚至会破坏传说中的数据可视化

“狮子是属于猫科的哺乳动物”“吃是摄取食物为一个有机体提供能量”“长颈鹿是现存最高的动物”。

上面这句话有什么意义吗？写狮子的饮食习惯时，我强迫自己使用短语或句子，而不是传统的方式。同一个句子自然会变成:

“狮子吃长颈鹿”

这很简洁，也更有意义。我们对任何语言的这种造句方式都习以为常，以至于在日常交流中，我们认为这是理所当然的。但是，为什么数据消费应该有所不同呢？

为什么我们要人为地使用单片图表来限制交流呢？在展示分析见解时，数据科学从业者会想到模板化的仪表盘和现成的图表。销售趋势变成顶部的*‘KPI 部分’*中的条形图，而产品组合是下面的饼图，以此类推。

这就像使用预设的句子，而不是将正确的单词串在一起，来传达一个优雅的信息。不幸的是，这种做法在今天太普遍了。每次出现这种情况，一个信息设计师的心都在滴血。

还不信服？

以防你还在疑惑，让我们来做一个有趣的实验。我们将选择一个优雅的视觉，被广泛认为是有史以来最好的。然后我们会发现如果我们使用模板化的方法来呈现完全相同的数据会发生什么。

让我们以查尔斯·密纳德创作的《T2 拿破仑的俄罗斯战役》来做这个测试。这是一个经典的，永恒的可视化，被爱德华·塔夫特认为是有史以来最好的可视化。这张 1869 年手绘的图是通过自由地让数据讲述自己的故事，以正确的方式组成的。有了这次审判，我希望密纳德在九泉之下也不会翻身！

我首先选择了下面提供的数据。这是利兰·威尔金森从视觉上重新创造的，并发表在他的书中。下面有三个数据集:第一个显示了拿破仑军队走过的城市，以及它们的纬度。

第二组显示了引用日期的经度和温度。这突出了军队撤退期间的严冬。第三个数据集显示了每个纬度上的士兵数量，他们行进的方向(前进或后退)，以及这是主要的队伍，还是分散的队伍。

现在，让我们假设这些数据是从竞选前线用电子邮件发给我们的。然后，我们的经理给我们布置了一项任务，要求我们连夜创建一个可视化效果。一个直接的冲动是将它输入公司的仪表板装配线。数据从传送带的一端传入，机器人手臂使用预设的仪表盘布局模型和现成的图表来强制调整它们。从另一端出来一个闪亮的，互动的，彩色的垃圾。嗯，差不多了。

我试着用一种类似上面的粗糙的模板化方法来处理“*拿破仑的进行曲”。*让我们看看同样的数据是如何失去所有的优雅，并以使用预建图表的企业风格的仪表板结束的。以下是最终结果:

How we killed Charles Minard’s storytelling using the modern dashboarding assembly line

我们已经成功地摧毁了叙事，传奇的数据故事已经沦为一个琐碎的，无效的仪表板。我使用 Tableau public 将这些放在一起，但作为一个强烈的免责声明，问题不在于工具。Tableau 是一个很好的工具，市场上的许多其他工具也是如此。问题总是在于采用的方法和创作者缺乏想象力的处理。

图形的语法？

是的，图形确实有语法。选择合适的底层元素来构成优雅的视觉效果是可能的。我们不需要摸索僵化的、预先构建的图表。当我们拥抱这些信息设计的关键实体时，它赋予我们构建任何视觉的能力。

依靠 Leland Wilkinson 在他的书《图形的语法》中建立的优秀基础，我们将理解优雅图形的流体结构。通过一个简单的例子，我们将看到如何用数据元素一层一层地构建一个优秀的视觉效果。我们还将证明并非所有图表都需要标准名称。

语法使语言富有表现力。一种只有单词而没有语法的语言只能表达和单词一样多的思想。—利兰·威尔金森

英语语法什么管用？

为了快速了解上下文，让我们看看我们是如何在英语中直观地构造句子的。约翰在操场上的动作是通过引入不同的词类并把它们串在一起来传达的。

任何简单的措辞都会完全改变结构。例如，如果我们把最后两个单词和第一个互换，这个句子就变成了*“球击中了约翰”*。一个化妆品的变化，但结果是不太一样了！

介绍图形的语法

为了使图形或视觉表现具有表现力，我们必须理解它们的基本语法结构。《图形语法》提供了一套标准的指导方针，用于将数据转换成讲述其故事的有效可视化形式。

让我们假设我们有下面的数据要呈现。它显示了美国 6 个城市的销售业绩。

图形语法中有 7 种语法成分。让我们从底层开始逐一查看，并向上移动。这个概念最好用例子来说明。我们将使用 ggplot2 ，这是 R 上的一个高级图表包，也是受同一本书的启发。

如果你不懂代码，不用担心。下面显示的代码片段仅用于说明目的。一个人不需要知道编程就能跟上。只要扫一眼标签，就可以看到当每个单词被递增添加时，视觉效果是如何变化的。这只需要简单的英语理解。

组件 1–2–3:数据-美学-几何

数据是基础组件，带有要绘制的元素。美学为数据提供轴和编码元素，而几何保存可用于表示数据的形状。

下面是一个简单的命令，使用上面显示的 3 个组件绘制每个城市的销售额和价格。注意每一个是如何被显式调用的，数据被映射到输入数据帧，美学将列关联到 x-y 轴，而几何要求将形状显示为点。

ggplot( 数据，AES(x =价格，y =销售额))+ geom _point()

不，这不是创建散点图的语法。我们将看到如何通过编码更多的元素来处理这 3 个组件。现在让我们根据城市所属的区域给点着色(左图)。然后，我们通过将销售量显示为点的大小来区分城市(右图)。请注意，该命令只添加了两项内容，如下所述。

ggplot(data，AES(x =价格，y =销售额，color =地区，size =体积)+geom _ point()

构成部分 4:方面

我们现在添加第四个组件，称为“刻面”。顾名思义，这是用来通过创建支线剧情将刻面出来的。有时，并排拆分和比较图是有帮助的，以便更清楚地突出差异。

对于上面的同一条命令，我们要求根据*‘区域’*拆分视觉效果，而不是在单个图表中显示所有内容。这需要一个简单的加法，如下所示:

ggplot(data，aes(x=Price，y=Sales，color=Region，size = Volume))+geom _ point()+facet _ wrap(~ Region)

构成部分 5:统计

第五个组成部分是“统计”，它提供了一种引入统计模型和汇总的方法，如均值、中值、分布。显示基本的统计数据通常很有用。

假设我们想要计算每个价格点的平均销售额。我们可以通过在命令中再添加一个参数来动态地添加这一点。这导致具有相同价格点的城市被聚合。

ggplot(data，AES(x =价格，y =销售额))+stat _ summary _ bin(fun . y =" mean "，geom = "bar ")

构成部分 6:坐标

我们可能需要改变绘图的坐标系统。可以修改上面显示的默认笛卡尔坐标或 x-y 坐标图。我们可以将其转换为极坐标，这是(不)流行的饼图或圆环图的基础。

一个带有直观命名的命令的一个单独的添加就转换了整个视觉，而不必修改任何基本组件。尽管这种视觉效果不太适合我们的数据，但它展示了如何做到这一点。下图是*“蜘蛛或雷达图”或“圆形图上的气泡”*的变体吗？我们已经在发明表象了！

ggplot(data，aes(x=Price，y=Sales，color=Region，size = Volume))+geom _ point()+facet _ wrap(~ Region)+coord _ polar()

构成部分 7:主题

语法中的最后一个组件是“主题”,它可用于任何非数据墨迹。示例包括图表或轴标题、标签、背景颜色方案等。在这一层，可以通过混合非数据墨水和数据墨水来对故事进行注释。

与其他组件一样，在下面添加一个参数*‘theme _ bw’*会将前景-背景从之前的默认灰度转换为白底黑字主题。添加标题、标签、页边距或线条也有同样简单的方法。

ggplot(data，AES(x =价格，y =销售额，color =地区，size =体积))+geom _ point()+theme _ bw()

因此，我们已经看到了图形语法如何帮助无缝地将数据组合到最合适的元素上。这些组件一起形成一个层，一个地块可能有多个层交织在一起。

如果意图是比较两个产品的销售，将它们绘制为条形几何的长度美观。如果你想看看这些产品的增长如何变化，把这个作为宽度美观带进来。不，请不要想条形图！相反，想象一下你如何能让数据发光。

想看看这些产品的利润吗？将它们编码为**。想比较不同公司的产品吗？ Facet 剧情将视图并排拆分，轻松对比两家公司。在与用户共享之前，使用主题组件添加必要的文本。**

思考图表的问题是，随着需求的增加，思考过程总是停滞不前。一个只用僵硬的图表工作的头脑很快就会耗尽多才多艺的表现。

摘要

Grammar of Graphics: A layered approach to elegant visuals

我们已经了解了灵活表示数据的基本构件。这个概念的真正力量在于将数据从单一图表的局限中解放出来。给他们自由，让他们讲述自己富有表现力的故事。

尽管今天的许多可视化工具没有完全采用图形方法的语法，但这似乎是前进的方向。与此同时，人们有机会开始将此付诸实践。这一点非常重要，必须成为所有数据工作者的必修课，无论是数据翻译、分析师、设计师、数据科学家还是记者。

你使用一套固定图表的经验是什么？

如果你觉得这很有趣，你会喜欢我写的这些相关文章

让你在数据科学职业生涯中不可或缺的 4 种超能力
数据可视化项目失败的 6 个原因？

对数据科学充满热情？随意在LinkedIn上加我，订阅我的 简讯。

文章参考:

利兰·威尔金森的《图形语法》
Jacques Bertin 的书名为“图形符号学:图表、网络、地图
ggplot2 上的 Wilke 实验室课程:讲座 3-2017 年春季
用于 R 中交互图形的 GGPlot2 包
Bret Victor 在斯坦福大学举办的名为“绘制动态可视化的人机交互研讨会，讨论了如何设计一个使用数据驱动可视化的系统。

通过人类选择的音乐

原文：https://towardsdatascience.com/music-by-means-of-natural-selection-11934d7e89a3?source=collection_archive---------8-----------------------

深度学习遇上交互式进化计算

One of the examples from the paper discussed (shoe photos on this post are from the UT Zappos50K dataset)

深度生成模型的一个更有趣的问题是，模型如何在生成过程中考虑用户偏好？控制一个模型的输出可以通过输入一个条件来完成，但是样本本身目前并没有通过考虑用户的主观偏好并产生用户特别喜欢的样本而在任何有意义的意义上有机地“进化”。

能够做到这一点的模型将在广泛的创造性应用中非常有用，从产品设计和资产生成到绘画和音乐。一月份发布的一篇论文“深度互动进化”很好地解决了这个问题，这也是这篇文章将要讨论的内容。

遗传算法

我们理想中想要的系统，是一个从一批完全随机的样本开始，并要求用户选择他们喜欢的样本，一个带有他们最终想要的输出的一些属性的样本。基于所选样本，该模型生成更多样本，这些样本具有与所选样本相似的特征。重复该过程，直到产生具有所有期望属性的样本。

很明显，我们正在执行一个优化过程，在每个时间步生成更新、更好的样本。有趣的是，奖励/适应度函数(衡量一个样本有多“好”的函数)不是一个可微的数学函数。是你。您选择的选项可以简单地表示为 1 和 0 的向量，分别代表好的和坏的样本。

这种适合度函数的公式非常有用，因为它使我们不必定义(难以处理的)适合度函数来预测用户喜欢哪些样本。我们只是直接把控制权交给用户。然而，由于输出离散数字向量的函数显然是不可微的，所以我们不能在这里使用反向传播。

一类自然适用的优化方法是 遗传算法【2】。目前，我们需要知道的是，它们的工作原理是将最佳样本的与的特征相结合，以产生更好的样本(交叉)，同时向特征添加一点随机噪声，以探索特征的变化(突变)。

样本不断“进化”以具有更好的特征，直到找到一个具有所有期望特征的样本。这种使用遗传优化来响应用户输入的方法被称为交互式进化计算(IEC)【3】。

什么是特色？

所以我们现在有一种方法可以进化我们的样本，但我们仍然有一个问题:什么是特征？我们可以简单地将照片中的每一个像素定义为独一无二的特征。现在，我们要做的就是运行遗传算法，我们应该会得到很好的结果，对吗？

正如您所看到的，这种幼稚的方法几乎马上就会遇到问题。随机选取像素而不是不仅不能给我们想要的真实图像，而且也不能给我们真实图像。

优化潜在向量

遗传算法的一个基本要求是用来表示信息的特征是独立的，或者至多是弱相关的。这使得特征可以被独立地组合和变异，并且仍然有希望获得离原始数据分布不太远的输出，也就是说，不太不切实际。

然而，对于大多数数据类型来说，不管领域(图像、文本、声音)， raw 特征往往彼此之间有很强的相关性。你不能随意优化一个特征，因为它是否真实强烈地依赖于它的邻居。

例如，拍摄一张树叶的照片，并从中选取任意三个相邻的像素。几乎可以肯定，三个像素的颜色都非常接近。毕竟，如果周围的像素都是绿色的，你不会期望只是随机看到一个红色的像素。事实上，如果您随机选取许多这样的像素三元组，并绘制其绿色通道的强度，您会发现几乎所有的三元组都位于整个 3D 空间的一个非常小的子集上，位于从 x，y，z = 0 到 x，y，z = 1 的对角线上，其中 x，y，z 是三个像素的绿色通道强度。这是因为，对于任何三重态，绿色强度彼此强烈相关。任何不在线上的三联体都不太可能是任何真实图像的一部分。

虽然上面的例子只使用了三个像素，但图像位于真实空间的一个小子集的核心思想适用于任何大小的图像。对于更大的空间，关系变得非线性，但是事实仍然是许多特征彼此高度相关。这个想法也适用于文本和音乐，句子中的单词显然依赖于它们的邻居，大多数随机产生的音乐听起来很糟糕，一点也不和谐。不考虑领域，大多数数据位于总空间的一个小的子空间中，用于表示数据，我们称之为流形*。只有在这个流形上，数据才代表了人们认为现实的东西。*

遗传算法本质上是随机优化算法，随机地探索搜索空间。在流形上，它们的收敛很慢，因为它们生成的大多数样本一开始就不现实。你让碰运气通过时不时地生成一些像样的样本，沿着正确的方向缓慢前进，从而取得缓慢的进展。人类没有在真实的样本中给打分，他们被迫给样本是否真实打分。这种方法几乎肯定不会在任何合理的时间内收敛。

因此，通常还有其他的表现形式，比如 picbreeder.com 所使用的不断变化的函数组合，或者用几何形状来近似图像，等等。虽然这些方法确实极大地减少了搜索空间，其中局部结构保持了颜色的相似性，即没有随机噪声，但是从全局来看，大多数结构组合可能仍然没有意义或者不够真实。

While the pixel triplets here are realistic, the image at large is not (source: picbreeder.com)

搜索空间仍然太大，收敛太慢，因为即使在 picbreeder 上，你也需要数千次迭代才能生成一幅图像。

这个想法

这就是这篇论文的发现所在，它真的可以总结为一句话:让我们优化生成模型的潜在向量而不是原始数据，以快速找到用户喜欢的样本。

这是一个非常通用的解决方案，无缝融合了 IEC 方法和深度生成模型。许多生成模型通过使用潜在向量并将其传递通过解码器/生成器网络来创建真实样本。最重要的是，潜在向量通常是从 N (0 ，I )分布中采样的，也就是说，每个分量是从随机正态分布中采样的，这些分量彼此独立(或者在 VAEs 的情况下，一个分量被迫非常接近它)。

解码器然后学习将潜在空间的特定区域与特定种类的输出相关联。由于空间在较低维度的潜在空间中非常珍贵，解码器仅将潜在空间的区域“分配”给接近流形的相当真实的样本。简而言之，创建这些潜在向量是为了让生成真实的样本。在训练过程中，潜在向量的分量相互独立，解码器/生成器必须学会通过将所有这些向量与实际输出相关联来克服这一点。

Sampling in latent vector space vs in input space (image on left from Fig 6. Karras et. al. (2017))

通过随机采样并将潜在向量传递给生成器网络，您可以得到看起来稍微“不像”的样本，但它们仍然比真实输入空间上的随机采样更有可能接近真实，其中大部分只是纯粹的噪声。

由于潜在向量的分量在训练期间基本上彼此独立，现在人们可以自由地重新组合特征，同时在任何方向上随机添加噪声，并且仍然得到生成器“熟悉”的向量，从而产生真实的图像。

这确保了更快的收敛速度，因为我们可以更有效地探索低维空间的子集，而不是随机探索高维空间。换句话说，我们不是探索每一个可能的像素组合，而是探索产生真实图像的像素组合。

该算法

最终的遗传算法适用于任何潜在向量生成模型。它假设您首先训练了一个创成式模型，然后继续执行以下操作:

A.样本:样本 n (为了便于说明，n=8) 与潜在变量的先验分布相同的随机向量(通常为(0*，I** ))***

8 randomly generated latent vectors

***B *。生成:不断重复下面的步骤，直到用户找到一个拥有他想要的所有属性的样本，然后，终止这个过程。

选择:要求用户选择样品，样品具有他们想要的一些属性。这些拟合样本的潜在向量被保留，而所有其余的被丢弃。

2。交叉:对于每批允许的 n 个总样本，除了分配给所选的和预定义数量的外来样本外，剩余部分用交叉样本填充。每个交叉潜在向量是通过选择任意两个所选潜在向量，并组合它们的向量分量而生成的，其中每个分量有 50%的机会来自任一父项。

****3。突变:所有被选择和交叉的潜在向量现在都经历突变。每个潜在向量有 50%的机会经历突变，如果发生突变，向量的每个分量还有 50%的机会添加随机正态噪声，用户在每个时间步长设置标准偏差(σ) ϵ [0，1]，即突变的“强度”。σ = 0 对应于完全没有突变，而σ = 1 对应于矢量分量本身数量级的噪声。

****4。外来向量:可能会出现没有一个样本具有用户想要的属性的情况。这可以通过突变慢慢收敛，但如果它是一个相当不同的属性，引入随机向量(与潜在变量先验分布相同)会更快，从而引入遗传多样性。用户可以将这些新样本与以前的样本进行交叉，以更接近所需的属性。

在一次优化的最后，我们得到一批这样的向量:

向量的总数在每次迭代中都保持不变(在我们的例子中是 8)，并且这批新的向量作为输入被传递回遗传优化过程的下一步，直到用户停止它。

这就是整个算法。收敛性要好得多，因为在论文中，当生成简单的图像时，用户通常只需 10 个生成步骤就可以获得他们喜欢的图像。

音乐一代

完成所有这些后，现在我们剩下要做的就是在音乐数据上训练一个生成模型，并执行上述进化过程。出于我们的目的，我们使用来自谷歌 Magenta 项目的预训练 VAE，music vae【4】2 小节旋律模型，并在其上测试潜在向量优化过程。

这个模型是一个 VAE，其中编码器是一个双向 LSTM，中间是一个采样层，末端是一个基于 LSTM 的解码器，产生单独的第 16 个音符事件。

Structure of the 2-bar MusicVAE, linear layers omitted, modified from original paper

我们从 512 维的分布 N (0， I )中采样一些潜在向量，将其通过解码器，并对潜在向量不断执行遗传优化过程，直到我们得到我们所期望的结果。

我们从随机采样和解码潜在向量开始:

然后我们优化它。经过 8 代优化后，我们得到了这个:

没有人会认为这是一个突破，但仍然非常迷人。更重要的一点是，即使是音乐作品(尽管最初的领域是图像)的核心思想。对于更健壮的模型，仍然可以应用相同的方法来获得更好的结果。

另外，出于好奇，还有一本合作笔记本可供选择。

结论

我发现论文中概述的方法非常有趣，因为它最终似乎弥合了考虑人类偏好和深度生成模型之间的差距。深度学习不太可能完全取代人类在艺术领域的创造力，相反，它可能成为增强人类创造力的有力工具。关于插值已经取得了巨大的进步，本文也为探索方法提供了一种简洁的方法。随着每天都有更好的生成模型被发现，它必然会改进。

如果你在这篇文章中发现任何重大错误，请告诉我们，我会立即改正。如果你喜欢这篇文章，你可以在 Twitter 这里 找到我。

参考

1.深度互动进化

2.遗传算法简介

3.交互式进化计算

4.分级变分音乐自动编码器

用 Python 进行音乐流派分类

原文：https://towardsdatascience.com/music-genre-classification-with-python-c714d032f0d8?source=collection_archive---------1-----------------------

Python 中的音频/音乐信号分析指南

Photo by Jean on Unsplash

音乐就像一面镜子，它告诉人们你是谁，你关心什么，不管你喜欢与否。我们喜欢说“你就是你流的东西”:Spotify

拥有260 亿美元净资产的 Spotify ，如今统治着音乐流媒体平台。目前，它的数据库中有数百万首歌曲，并声称拥有适合每个人的音乐配乐。Spotify 的 Discover Weekly 服务在千禧一代中大受欢迎。不用说，Spotify 在研究方面投入了大量资金，以改善用户查找和收听音乐的方式。机器学习是他们研究的核心。从 NLP 到协同过滤再到深度学习，Spotify 都用上了。歌曲基于它们的数字签名被分析一些因素，包括速度、声学、能量、可跳舞性等。来回答第一次约会时那个不可能回答的问题:你喜欢哪种音乐？

目标

公司如今使用音乐分类，要么是为了能够向他们的客户进行推荐(如 Spotify、Soundcloud)，要么只是作为一种产品(如 Shazam)。确定音乐流派是朝着这个方向迈出的第一步。机器学习技术已被证明在从大型数据池中提取趋势和模式方面相当成功。同样的原理也适用于音乐分析。

在本文中，我们将学习如何用 Python 分析音频/音乐信号。然后，我们将利用学到的技能 将音乐片段分类成不同的流派。

使用 Python 进行音频处理

声音以一种音频信号的形式呈现，该信号具有诸如频率、带宽、分贝等参数。典型的音频信号可以表示为幅度和时间的函数。

source

这些声音有多种格式，使得计算机能够读取和分析它们。一些例子是:

mp3 格式
WMA (Windows Media Audio)格式
wav(波形音频文件)格式

音频库

Python 有一些很棒的库用于音频处理，比如 Librosa 和 PyAudio。还有一些基本音频功能的内置模块。

我们将主要使用两个库进行音频采集和回放:

1.利布罗萨

这是一个 Python 模块，用于分析一般的音频信号，但更适合音乐。它包括建立一个 MIR(音乐信息检索)系统的具体细节。它已经被很好地记录了，还有很多例子和教程。

关于描述包装设计原理的更高级介绍，请参考 librosa 论文atSciPy 2015。

安装

pip install librosa
or
conda install -c conda-forge librosa

为了提供更多的音频解码能力，你可以安装许多音频解码器附带的 FFmpeg、。

2.IPython.display .音频

[**IPython.display.Audio**](https://ipython.org/ipython-doc/stable/api/generated/IPython.display.html#IPython.display.Audio)让您直接在 jupyter 笔记本上播放音频。

载入音频文件

import librosaaudio_path = '../[T08-violin](https://github.com/parulnith/Data-Science-Articles/blob/main/Music-Genre-Classification-with-Python-master/T08-violin.wav).wav'
x , sr = librosa.load(audio_path)print(type(x), type(sr))
<class 'numpy.ndarray'> <class 'int'>print(x.shape, sr)
(396688,) 22050

这会以 numpy 数组的形式返回音频时间序列，默认采样速率(sr)为 22KHZ 单声道。我们可以这样改变这种行为:

librosa.load(audio_path, sr=44100)

以 44.1KHz 的频率重新采样，或者

librosa.load(audio_path, sr=None)

禁用重采样。

采样率是每秒传送的音频样本数，以赫兹或千赫兹为单位。

播放音频

使用，**IPython.display.Audio**来播放音频

import IPython.display as ipd
ipd.Audio(audio_path)

这将在 jupyter 笔记本中返回一个音频小部件，如下所示:

screenshot of the Ipython audio widget

这个小工具在这里不能用，但是可以用在你的笔记本上。我已经把它上传到了 SoundCloud，这样我们就可以听了。

对于音频示例，您甚至可以使用 mp3 或 WMA 格式。

可视化音频

波形

我们可以使用[**librosa.display.waveplot**](https://librosa.github.io/librosa/generated/librosa.display.waveplot.html#librosa.display.waveplot)来绘制音频数组:

%matplotlib inline
import matplotlib.pyplot as plt
import librosa.displayplt.figure(figsize=(14, 5))
librosa.display.waveplot(x, sr=sr)

这是波形的幅度包络图。

光谱图

声谱图 是声音或其他信号的频率的频谱随时间变化的直观表示。声谱图有时被称为声谱图、声纹或声谱图。当数据以 3D 图表示时，它们可以被称为瀑布。在二维数组中，第一个轴是频率，而第二个轴是时间。

我们可以用。[**librosa.display.specshow**](https://librosa.github.io/librosa/generated/librosa.display.specshow.html)**.**

X = librosa.stft(x)
Xdb = librosa.amplitude_to_db(abs(X))
plt.figure(figsize=(14, 5))
librosa.display.specshow(Xdb, sr=sr, x_axis='time', y_axis='hz')
plt.colorbar()

纵轴显示频率(从 0 到 10kHz)，横轴显示剪辑的时间。因为所有的行为都发生在光谱的底部，我们可以把频率轴转换成对数轴。

librosa.display.specshow(Xdb, sr=sr, x_axis='time', y_axis='log')
plt.colorbar()

编写音频

[**librosa.output.write_wav**](https://librosa.github.io/librosa/generated/librosa.output.write_wav.html#librosa.output.write_wav)将 NumPy 数组保存到 WAV 文件。

librosa.output.write_wav('example.wav', x, sr)

创建音频信号

现在让我们创建一个 220 赫兹的音频信号。一个音频信号是一个 numpy 数组，所以我们应该创建一个并把它传递给 audio 函数。

import numpy as np
sr = 22050 *# sample rate*
T = 5.0    *# seconds*
t = np.linspace(0, T, int(T*sr), endpoint=**False**) *# time variable*
x = 0.5*np.sin(2*np.pi*220*t)*# pure sine wave at 220 Hz***Playing the audio**
ipd.Audio(x, rate=sr) *# load a NumPy array***Saving the audio**
librosa.output.write_wav('tone_220.wav', x, sr)

这是你创造的第一个声音信号。🙌

特征抽出

每个音频信号都包含许多特征。然而，我们必须提取与我们试图解决的问题相关的特征。提取特征以用于分析的过程称为特征提取。让我们详细研究几个特征。

过零率

过零率是信号随符号变化的速率，即信号从正变到负或反变的速率。这个功能在语音识别和音乐信息检索中都被大量使用。它通常具有较高的值，适用于像金属和摇滚这样的高敲击声。

让我们计算示例音频剪辑的过零率。

# Load the signal
x, sr = librosa.load('../T08-violin.wav')#Plot the signal:
plt.figure(figsize=(14, 5))
librosa.display.waveplot(x, sr=sr)

# Zooming in
n0 = 9000
n1 = 9100
plt.figure(figsize=(14, 5))
plt.plot(x[n0:n1])
plt.grid()

似乎有 6 个过零点。让我们向 librosa 核实一下。

zero_crossings = librosa.zero_crossings(x[n0:n1], pad=False)
print(sum(zero_crossings))**6**

光谱质心

它表示声音的“质量中心”所在的位置，计算方法是声音中频率的加权平均值。考虑两首歌曲，一首来自蓝调流派，另一首属于金属。现在，与布鲁斯流派歌曲相比，它的长度是一样的，金属歌曲在结尾有更多的频率。因此蓝调歌曲的频谱质心将位于其频谱的中间附近，而金属歌曲的频谱质心将接近其末端。

[**librosa.feature.spectral_centroid**](https://librosa.github.io/librosa/generated/librosa.feature.spectral_centroid.html#librosa.feature.spectral_centroid)计算信号中每一帧的频谱质心:

spectral_centroids = librosa.feature.spectral_centroid(x, sr=sr)[0]
spectral_centroids.shape
(775,)# Computing the time variable for visualization
frames = range(len(spectral_centroids))
t = librosa.frames_to_time(frames)# Normalising the spectral centroid for visualisation
def normalize(x, axis=0):
    return sklearn.preprocessing.minmax_scale(x, axis=axis)#Plotting the Spectral Centroid along the waveform
librosa.display.waveplot(x, sr=sr, alpha=0.4)
plt.plot(t, normalize(spectral_centroids), color='r')

光谱质心在接近末端时上升。

光谱衰减

它是信号形状的度量。它表示总频谱能量的特定百分比(例如 85%)低于的频率。

[**librosa.feature.spectral_rolloff**](https://librosa.github.io/librosa/generated/librosa.feature.spectral_rolloff.html#librosa.feature.spectral_rolloff)计算信号中每一帧的滚降频率:

spectral_rolloff = librosa.feature.spectral_rolloff(x+0.01, sr=sr)[0]
librosa.display.waveplot(x, sr=sr, alpha=0.4)
plt.plot(t, normalize(spectral_rolloff), color='r')

梅尔倒谱系数

信号的 Mel 频率倒谱系数(MFCCs)是一小组特征(通常约为 10–20)，它们简明地描述了频谱包络的整体形状。它模拟了人类声音的特征。

这次让我们用一个简单循环波来工作。

x, fs = librosa.load('../simple_loop.wav')
librosa.display.waveplot(x, sr=sr)

[**librosa.feature.mfcc**](https://bmcfee.github.io/librosa/generated/librosa.feature.mfcc.html#librosa.feature.mfcc)计算音频信号的 MFCCs:

mfccs = librosa.feature.mfcc(x, sr=fs)
**print** mfccs.shape
(20, 97)#Displaying  the MFCCs:
librosa.display.specshow(mfccs, sr=sr, x_axis='time')

这里 mfcc 计算了 97 帧中的 20 个 MFCC。

我们还可以执行特征缩放，使得每个系数维度具有零均值和单位方差:

import sklearn
mfccs = sklearn.preprocessing.scale(mfccs, axis=1)
print(mfccs.mean(axis=1))
print(mfccs.var(axis=1))librosa.display.specshow(mfccs, sr=sr, x_axis='time')

色度频率

色度特征是音乐音频的一种有趣而强大的表示，其中整个频谱被投影到表示音乐八度音阶的 12 个不同半音(或色度)的 12 个箱上。

[librosa.feature.chroma_stft](https://librosa.github.io/librosa/generated/librosa.feature.chroma_stft.html#librosa.feature.chroma_stft) 用于计算

# Loadign the file
x, sr = librosa.load('../simple_piano.wav')hop_length = 512
chromagram = librosa.feature.chroma_stft(x, sr=sr, hop_length=hop_length)
plt.figure(figsize=(15, 5))
librosa.display.specshow(chromagram, x_axis='time', y_axis='chroma', hop_length=hop_length, cmap='coolwarm')

案例分析:将歌曲分为不同的类型。

在概述了声音信号、其特征及其特征提取过程之后，是时候利用我们新开发的技能来解决机器学习问题了。

目标

在他的章节中，我们将尝试建立一个分类器来将歌曲分类成不同的流派。让我们假设一个场景，由于某种原因，我们在硬盘上发现了一堆随机命名的 MP3 文件，这些文件被认为包含音乐。我们的任务是根据音乐类型将它们分类到不同的文件夹中，如爵士、古典、乡村、流行、摇滚和金属。

资料组

我们将使用著名的 GITZAN 数据集进行案例研究。该数据集用于 G. Tzanetakis 和 P. Cook 在 2002 年 IEEE 音频和语音处理汇刊中的著名论文“音频信号的流派分类”音乐流派分类。

该数据集由 1000 首音轨组成，每首音轨时长 30 秒。它包含十种风格:布鲁斯、古典、乡村、迪斯科、嘻哈、爵士、雷鬼、摇滚、金属和流行。每种体裁由 100 个声音片段组成。

预处理数据

在训练分类模型之前，我们必须将来自音频样本的原始数据转换成更有意义的表示。音频剪辑需要从。au 格式到。wav 格式，使其与 python 的 wave 模块兼容，用于读取音频文件。我使用开源的 SoX 模块进行转换。这里有一个方便的关于 SoX 转换的备忘单。

sox input.au output.wav

后续步骤

音乐流派分类是音乐信息检索的众多分支之一。从这里，您可以对音乐数据执行其他任务，如节拍跟踪、音乐生成、推荐系统、音轨分离和乐器识别等。音乐分析是一个多样化的领域，也是一个有趣的领域。音乐会话在某种程度上代表了用户的某个时刻。在数据科学领域，找到并描述这些时刻是一个有趣的挑战。

音乐定位:品牌的新 Eldorado？

原文：https://towardsdatascience.com/music-targeting-the-new-eldorado-for-brands-48590a0b7108?source=collection_archive---------8-----------------------

虽然关于如何收集和使用私人数据的争议正在激烈进行，虽然《GDPR》的应用正在临近，但替代的数据管理方法非常受欢迎。充分理解这些问题的新演员正在广告业涌现，并带来创新的解决方案来满足广告商的需求。他们的方法与通常使用的方法截然不同，本质上是基于数据科学，分析从未被利用过的数据。

“原始数据”，有史以来最大的黑金矿床，却几乎无人问津。

今天，广告市场是围绕用户的个人数据组织的。大多数情况下，这些数据是通过数据交换平台收集和出售的，在这些平台上，人们可以找到关于特定用户的几乎任何类型的信息，或者更具体地说，关于广告 ID 的信息(IDFA、AAID、cookies 等等)。人们可以访问用户的所有个人数据，如年龄、性别、婚姻状况、购买力等。鉴于数据量巨大，获取这些信息的成本已经低得离谱:每 1000 条信息的购买价格从 0.10 美元到 5 美元不等，换句话说，每条信息从 0.0001 美元到 0.05 美元不等。此外，这些平台中的绝大多数明显缺乏透明度，这使得追踪这些数据的来源成为不可能，并引发了隐私和用户同意的担忧:这些数据是如何收集的？用户同意了吗？

一方面，2018 年 5 月 GDPR 的引入应有助于清理这些不可接受的做法，并规范数据的收集、处理和交易。另一方面，苹果应用商店已经在优步的最新滥用或者 Teemo 丑闻之后做出了回应。例如，考虑到即将发布的 iOS 11，苹果更新了指导方针。根据第5 . 1 . 1 和 5.1.2 条，公司将不再被授权收集数据，除非该应用的主要功能之一的性能需要。此外，禁止将这些数据传输给第三方或广告公司。甚至关于网络上的广告定位，苹果已经更新了 Safari，使得未经用户同意几乎不可能通过 cookies 进行跟踪。

“一流数据”的终结？

有了这些限制，品牌如何成功地锁定他们的受众？我们需要立即为这一重大变化做好准备，并开始寻找符合法规的新解决方案。

还有另一种不太为人所知的数据:我喜欢称之为“原始数据”。这类数据就像石油一样:如果不首先处理和提炼，就完全无法使用。我在这里指的是关于一个人日常应用使用的数据，一旦经过分析，就可以非常准确地描述用户的行为和偏好:例如，每天走的步数，安装的应用数量，甚至每天听的音乐类型。

这些数据是由用户生成的，数量巨大，但实际上毫无用处。数据科学提供了新的视角，使得提取用户的行为和习惯成为可能，以便实际绘制他们的品味、偏好和消费模式。

让我们以 SportHeroes 为例，这是一家欧洲初创公司，开发促进和鼓励体育活动的应用程序。这家公司围绕用户的体育活动数据开发了一项业务:他们每天走多少步？他们步行或跑步的距离是多少？他们一周跑几次？多久了？这些信息一旦经过处理，SportHeroes 就能极其精确地理解用户的运动行为。这实际上是耐克(Nike)或阿迪达斯(Adidas)等运动品牌的一个千载难逢的机会，它们可以通过在 SportHeroes network 上开展广告活动，接触到这些充满潜在买家的受众。这种定位不是基于人们是否宣称喜欢体育运动(社交网络上的声明性数据)，而是基于人们实际从事体育运动的方式(SportHeroes 跟踪的行为数据)，这显然是一个对体育品牌更强大、更相关的信号。

另一个例子——也许是最引人注目的——是音乐。你不认为你喜欢的音乐反映了你是谁吗？你不是倾向于根据一个人听的音乐风格马上对他/她形成看法吗？

音乐定位:一场革命。

几十年来，来自世界各地的研究人员一直试图了解音乐对人类的影响。新发现不断涌现:每个人都知道音乐的治疗作用。事实上，俄勒冈大学最近展示了其在阿尔茨海默病治疗中的有效性。来自宾夕法尼亚州乌尔西努斯学院的南希·贝克尔和她的同事强调了音乐在体力活动中的掺杂剂效应，表现惊人地提高了 30%。最后但并非最不重要的一点是，事实证明，音乐在我们的购买行为中扮演着重要角色，甚至可以显著增加商店销售额。美国 Hollister 公司充分理解音乐的这一作用:该服装品牌在其所有商店中将其作为一种强有力的营销工具，以优化顾客流量和促进销售。

但该领域的最新进展之一来自大数据。从今以后，大数据使得通过音乐解读用户的行为和习惯成为可能。

如果没有音乐产业的数字化和音乐流媒体的民主化，这一突破是不可能实现的。由于后者，现在有可能收集数量惊人的收听数据，使品牌能够分析数百万人每天是如何与音乐互动的。

某些流媒体巨头已经开始注意到，他们用户的音乐行为可能是一个额外的、甚至是重要的收入来源。如今，Spotify 销售基于播放列表的定向活动，该公司在短短 3 年内成功创造了近 3 亿美元的广告收入(来源:全球音乐商业)。这完美地说明了这些基于“原始数据”的新目标工具的效率及其几乎未开发的潜力。

不仅流媒体服务对音乐数据感兴趣，广告公司也是如此。哈瓦斯公关北美公司首席执行官 Maria Salzman 甚至向《卫报》 : “在未来十年内，播放列表将成为有史以来最强大的消费者行为预测工具”。然而，我们才刚刚开始探索原始数据的潜力，今天，Spotify 提供了一个简单的目标，仅限于其 7000 万免费客户的受众。

这场代表着通过音乐进行行为定位的革命，远远超出了俘虏听众的货币化，而是在音乐流媒体和许可活动之外建立了一个额外的收入流。它代表了一种全新的数字营销方式，更加感性和不断变化，让品牌真正了解自己与社区的亲和力。这种方法利用了与最普遍的行为之一——听音乐——相关的不断更新的大量数据。

部署这种革命性的方法是 MWM 的雄心和专业知识的核心。短短几年间，全球八大移动音乐应用发行商之一、下载量超过 1 亿次的 MWM 已经成为“音乐数据科学”的先驱。我们积累的数十亿数据使我们能够通过音乐对任何类型的行为进行深入分析。

例如，我们最近的研究表明，一个人对电子游戏的兴趣与你正在听的音乐风格密切相关。通过对 15 万用户进行抽样调查，并通过算法分析他们的行为，我们可以断言，听摇滚和另类摇滚(声音花园乐队、杀手、法兰兹·费迪南、帕帕·罗奇和黑键等乐队)的人对电子游戏感兴趣的可能性是听流行音乐的人(Lady Gaga、玛丽亚·凯莉、卢安、席琳·狄翁、鲍勃·辛克莱等艺术家)的三倍。更一般地说，只要知道他们的音乐习惯，我们就能够明确地识别出一群有超过 95%的机会成为视频游戏爱好者的用户。

这只是一个例子。我们的数据科学家每天都在构建新的模型，使我们能够探索音乐数据分析的非凡可能性。在我们的“MWM 网络”平台内，品牌现在可以从这些发展中受益，以便以一种新的和创新的方式改变他们的混合媒体。

结论

由于智能手机的开发和“原始数据”的出现，广告定位领域正在发生一场革命。它为品牌提供了一个全新的平台，同时加入了以人为本的营销运动，并尊重即将到来的新法规…

音乐到我的耳朵:一种无监督的用户特定歌曲推荐方法

原文：https://towardsdatascience.com/music-to-my-ears-an-unsupervised-approach-to-user-specific-song-recommendation-6c291acc2c12?source=collection_archive---------13-----------------------

作者:Sameer Bibikar，Aimun Khan，Nimay Kumar，Jason Nguyen，Shrey Sachdeva

Photo by Jefferson Santos on Unsplash

摘要

各种音乐流服务所采用的当前音乐推荐算法是完全相关的，并且在向用户推荐新歌时不考虑歌曲本身的音乐特征。我们的团队希望开发一种算法，在推荐新歌时，它会强调用户喜欢听的音乐质量，而不是演唱这首歌的艺术家。这篇博文讨论了我们使用百万首歌曲数据集来构建一个更强大的音乐推荐系统的努力。许多数据收集得很差，无法使用，需要大量的数据预处理和特征工程。一些特征工程方法包括将百万首歌曲数据集与另外两个数据集相结合，以包括用户的收听历史和歌曲流派，并使用结合置信度的一键编码来转换分类变量。

流派似乎是确定用户喜欢的歌曲种类的一个很好的指标。为了评估给定流派标签与特征的关联程度，我们使用流派特征作为因变量来训练各种监督模型。不幸的是，即使是我们表现最好的模型也没有表现得足够好，让我们接受给定的流派标签为真正的标签。我们将我们的方法转变为使用无监督学习方法，使用均值漂移聚类将相似的歌曲分组在一起，以模拟流派类别。对于我们的推荐，我们使用最近邻方法来开发一种算法，该算法使用我们新创建的流派聚类来建议与给定用户的收听历史中的歌曲最接近的新音乐。通过使用来自用户收听历史的维持集，我们能够得出结论，我们的模型表现良好，因为它始终推荐来自维持集的歌曲。

导言和背景

通常，音乐流媒体服务上的音乐推荐并不表示用户实际喜欢的音乐种类。相反，许多音乐流媒体服务主要使用关系算法，它只是从相似用户的播放列表中推荐歌曲。这种方法不能为用户提供个性化的建议，因此我们决定探索一种分析音乐特征的替代方法。我们的目标是设计我们自己的歌曲推荐算法，根据用户喜欢的音乐特征来推荐歌曲。

有许多音乐流媒体服务，如 Spotify 和 Apple Music，也在努力优化他们的音乐推荐算法。此外，还有各种要求参赛者解决类似问题的 Kaggle 比赛，包括百万歌曲数据集(MSD)挑战赛和 KKBox 音乐推荐挑战赛。我们的问题是推荐用户可能欣赏的新歌，提供他们的收听历史，这类似于正在进行的其他挑战。我们从数据探索开始理解数据，然后是特性选择和工程。一旦我们的数据是有意义的，我们使用一种监督的方法来预测流派，以便我们可以替换数据集中收集得不好的流派标签。最后，我们总结了一个无监督的聚类方法，利用我们新创建的流派。我们的项目包括几个新颖的特征，例如创建一次性编码特征，将特征的置信度融入编码中，并对数据集中的歌曲进行聚类，以分析用户收听历史中的可能趋势。

数据收集

在浏览相关 Kaggle 比赛时，我们偶然发现了一个使用了百万歌曲数据集(MSD) 的比赛。280 GB 的数据集对我们的项目来说似乎很有希望，因为它包括 53 个特征，正如其名称所暗示的，一百万首样本歌曲。这些功能提供了大量关于歌曲的信息，包括我们认为与理解用户为什么喜欢某首特定歌曲相关的特征。这些特征包括调、速度和模式，并为每种特征提供了置信度。此外，我们可以访问相关的数据集，这些数据集提供了用户的收听历史和流派/风格标签。有了这些数据集，一旦我们充分探索、理解和修改了我们所掌握的数据，我们就觉得已经为解决我们的问题做好了充分的准备。

数据采集

首先，我们试图从 OSDC 下载 MSD 的子集和整个数据集，但是，在撰写本文时，OSDC 的网站只将我们重定向到其主页。因为这两种方法都不起作用，所以我们采用了最后一种方法来获得 MSD: Amazon 弹性块存储。我们按照 MSD 页面上的说明启动了一个 Amazon EC2 实例。在这个实例中，我们安装了 Python 3、scikit-learn、pandas、numpy、scipy 和 Jupyter Notebook，使我们能够远程工作。然后，我们挂载数据集 EBS 实例，发现每首歌曲都存储在一个单独的 HDF5 文件中，从而产生了一个数百 GB 大小的数据集。

数据预处理和探索

起初，由于其巨大的规模和过多的特征，该数据集似乎非常有前途。例如，我们认为可跳舞性、艺术家熟悉度和歌曲热度对于理解用户喜欢的音乐类型至关重要。不幸的是，当我们更深入地研究这些特性时，我们发现许多数据没有信息，而且收集得很差；许多有前景的功能包含主要为 0 或 NaNs 的条目，差异很小。为了克服这个障碍，我们使用领域知识来执行特征选择和提取以清理数据。我们排除了绝大多数样本都忽略了值的特征，并将分类值转换为连续的数值。

我们的第二个数据集与用户历史信息相关，由三元组(user_id、song_id、count)组成。然而，我们的 MSD 样本只有 track_id 可用，这使得我们无法将 MSD 中的歌曲直接映射到每个(user_id，song_id，count)三元组。因此，我们必须利用将 song_id 映射到 track_id 的第三个数据集。在此操作之后，我们发现一些歌曲在 MSD 中没有 track_id，所以我们丢弃了这些值。然后，我们通过 track_id 合并数据集，并开始项目的建模阶段。

Box Plots of all features in our data

特征工程和选择

由于 MSD 的大小，我们必须要么对数据集的子集进行操作，要么对数据集的要素缩减版本进行操作。我们决定查看 MSD 数据的样本，看看是否所有要素都有有用的价值。如上所述，许多看似有用的特性没有被填充。利用音乐领域的知识，我们将数据缩小到 21 个有用的特征。我们移除了具有低方差、许多缺失值和字符串的要素，以减小数据集的大小，同时保留大部分有用信息。这个特性选择将我们的工作数据集的大小减少到了 2 GB。此外，我们通过写入单个 HDF5 文件节省了空间，成功地将文件大小从 2 GB 降至 117 MB。

基于置信区间一键编码的特征提取

Echo Nest API 提供了一个置信度值特性，它描述了一些分类特性。例如，每个数据条目包括歌曲的预测模式，以及模式预测正确的[0，1]的置信水平。这些特征高度相关，但不应该是独立的。为了将这些特征合成为一个有用的特征，我们对类别“模式”特征进行了一次性编码，并将每个特征乘以置信度。我们对其他几对高度相关的特征进行了同样的处理。

On left: Dataframe before one-hot encoding. On right: Dataframe after one-hot onecoding

学习和建模

因为流派是对相似歌曲进行分组的有效工具，我们决定预测歌曲的给定流派标签，以评估其准确性。我们使用了一些简单的模型，包括 SVM、XGBoost 和随机森林，因为它们在处理高维监督问题时具有鲁棒性。尽管对这些方法进行了调整，我们仍然得到了很差的准确性分数。这意味着数据集中给定的流派标签与歌曲的实际特征相关性很差，可能是因为艺术家自我识别他们音乐的流派。我们对这个问题的解决方案是使用聚类方法，纯粹基于歌曲的音乐元素来创建我们自己的流派标签。我们开始使用 K 均值聚类，后来选择使用均值漂移聚类。最后，为了向用户推荐歌曲，我们在生成的聚类上实现了多输入最近邻算法，以基于用户输入推荐歌曲。

初始监督方法

我们最初试图预测一首歌曲的给定流派标签，结果得分低于 0.01。这个分数很低，很大程度上是因为当类的基数很高时，很难达到高精度。虽然有 21 个不同的流派标签给了我们详细的类别，但类别之间没有距离:预测一个相似但不同的流派会像预测一个非常不同的流派一样严重地影响准确性。为了解决这个问题，我们将类型标签归纳为 8 个标签。

On left: original genre labels. On right: Generalized genre labels.

我们随后试图预测一首歌曲的广义流派标签，随机森林的得分为 0.33。我们在训练模型时通过交叉验证并使用网格搜索来调整随机森林的参数，从而获得了这个分数。这让我们轻松进入了 MSD 类型游戏 Kaggle 竞赛的前十名排行榜。不幸的是，这个分数不足以达到我们推荐歌曲的目的。我们决定利用歌曲的特点从头开始创建自己的流派标签，引导我们探索无人监管的方法。

使聚集

接下来，我们决定通过对数据集中的歌曲进行聚类来创建我们自己的风格，从而推荐与用户的收听历史“相似”的歌曲。我们尝试的第一种方法是 K-Means 聚类，因为它简单且训练时间短。然而，我们最终使用均值漂移聚类来解决这个问题，因为它不需要预先定义聚类的数量，因此非常灵活。改变流派的数量可以极大地改变推荐，Mean-Shift 根据密度自动确定最佳的流派数量。尽管 Mean-Shift 比 K-means 在计算上更昂贵，但我们仍然选择使用 Mean-Shift 聚类，因为它具有灵活性，并且只需运行一次算法就能提供非常宝贵的信息。

用户的最近邻居

为了将用户历史记录整合到我们的模型中，我们决定基于与一组输入歌曲的接近度来推荐歌曲。对于每个用户，我们使用基于球树的算法从均值漂移聚类中有效地创建最近邻，推荐与输入集具有最低 MSE 距离的歌曲。这种方法还优雅地定义了一个评估我们的无监督模型的指标:如果模型返回的歌曲已经在用户的收听历史中，我们就可以自信地说，这种方法成功地概括了用户的口味。

Scatterplot of User Recommendations

定义指标和结果评估

为了评估我们最初的监督方法，我们衡量成功的标准只是检查模型预测的准确性。按照这个标准，我们的随机森林模型做得最好。相比之下，当我们开始我们的聚类方法时，我们不得不修改我们衡量成功的标准，因为这些方法本质上是无监督的。为了评估我们的最近邻模型，我们为每个用户保留了一首测试歌曲，并将它在最近邻模型中的最小距离与 MSD 中所有点的平均最小距离进行了比较。如果测试歌曲的最小距离小于 MSD 最小距离的平均值，我们比随机模型做得更好。因此，我们定义了一个类似于 sigmoid 函数的评分函数:

调整后的聚类得分= 0.5+NP . tanh((dist[' average ']—dist[' test '])/10)/2

这使得分数在范围[0，1]内。关于这个指标需要注意的一点是，孤立的低精度并不意味着模型的性能不好。例如，如果两首歌曲在聚类内具有大的均方距离(也许用户喜欢两种风格)，即使用户喜欢这两首非常不同的歌曲，一首歌曲也不太可能返回另一首。通过最近邻球树模型和我们的度量，我们发现大多数用户模型表现良好，尤其是与随机模型相比。下面是得分和歌曲间平均距离的方框图。

On left: Box plot of dist[‘average’] — dist[‘test’]. On right: Box plot of adjusted cluster score.

On left: Average Distance (MSE) between songs in MSD. On right: Average Distance (MSE) between songs in test set (user history).

结论

许多人抱怨说，他们不喜欢音乐流媒体服务推荐的歌曲。我们小组决定通过设计和实现一种基于歌曲特征向用户推荐音乐的算法来探索这个问题。我们从百万首歌曲数据集中提取数据，从其他数据集中添加新特征，删除收集不良的特征，并从相关特征中合成新特征。因为艺术家给定的流派标签与音乐的特点不太一致，所以我们根据歌曲的特点创造了自己的流派。我们的最终推荐采用了用户的收听历史，并从最接近这些历史中歌曲最集中区域的聚类中返回歌曲。我们通过从输入到模型的用户收听历史中排除一些歌曲，并确定模型是否推荐了来自维持集的歌曲，来评估我们的推荐的准确性。最终，根据我们定义的衡量成功的标准，我们的最终模型相当准确。

你可以在这里找到我们 Github 知识库的链接。

经验教训

我们团队学到的一个主要经验就是在使用数据集之前要充分探索它。最初看起来信息量巨大的数据集最终包含了大量方差较低的垃圾要素。数据集需要大量的预处理和特征工程，然后才能达到 1%的精度。数据集的庞大并不能转化为高质量的特征。我们学到的另一个教训是不要忽视更简单的模型，尤其是在组合时。对于这个项目，最近邻在开发我们的最终模型中至关重要，并且只需要很少的计算能力。每种模式都有优点和缺点。关键是使用正确的模型，其优势与问题和可用数据相一致。

未来的工作

为了继续和改进这个项目，我们可以收集更多关于歌曲的信息数据，如乐器，形式和傅立叶变换频谱。此外，使用 Echo Nest API 向 MSD 添加更多的“当前”歌曲将有助于使项目的最终模型与当今的趋势和流行歌曲更加相关。知道用户听了一首歌多长时间或者他们是否重播了这首歌将提供关于加权输入歌曲的非常有用的信息。例如，如果用户在决定他们不喜欢某首歌曲之前只听了 30 秒，该歌曲仍然以与他们喜爱的歌曲相同的容量出现在他们的收听历史中。最后，添加一个前端接口或 API 来发出推荐请求，将使我们的项目可供用户和开发人员使用。

参考

https://static . Google user content . com/media/research . Google . com/en//pubs/archive/45530 . pdf

https://qz . com/571007/the-magic-that-makes-spotifys-discover-weekly-playlists-so-damn-good/

【https://labrosa.ee.columbia.edu/millionsong/

https://www . opensciencedatacloud . org/public data/million-song-dataset/

https://www.kaggle.com/c/msdchallenge

https://www . ka ggle . com/c/kkbox-music-recommendation-challenge

http://www.ifs.tuwien.ac.at/mir/msd/

https://www.kaggle.com/c/mlp2016-7-msd-genre

数据科学和公共政策交汇处的思考

原文：https://towardsdatascience.com/musings-at-the-intersection-of-data-science-and-public-policy-cf0bb2fadc01?source=collection_archive---------1-----------------------

“有意思……数据科学与公共政策有什么关系？”

当我告诉别人我是计算分析和公共政策的硕士生时，这是一个普遍的反应。我仍在努力为这个问题寻找完美、简洁的答案。与此同时，这里有一些关于这个主题的想法和观察，是我在迄今为止的冒险中收集到的。

注意:我将从最广泛的意义上提及“数据科学”，涵盖从大量数据中提取有意义的见解的实践的所有方面。

数据在政策领域发挥了巨大作用

看看数据科学造福社会 (DSSG)，这是由芝加哥大学数据科学和公共政策中心的杰出人士举办的暑期奖学金。DSSG 项目团队与政府和非营利组织合作，将数据科学方法应用于教育、公共卫生和社会服务等政策领域。

尽管存在重大挑战，如数据质量问题和孤立部门的存在，但实践者已经找到了将数据科学融入政策领域的方法。市政府扩大了其分析团队的范围，纳入了更多数据科学功能。纽约、芝加哥和波士顿处于领先地位，其他城市紧随其后，这些数据团队正在帮助城市机构集中精力更有效地为选民服务。年轻的公司，如 Civis Analytics 和 BlueLabs ，为政府、宣传和政治领域的客户提供数据科学咨询服务。公民技术社区的成员(例如 Chi Hack Night )正在利用越来越容易获得的开放政府数据，在他们的空闲时间为项目做出贡献。公民数据使用案例的清单非常广泛，但简而言之，数据正在帮助我们以一种前所未有的方式解决紧迫的政策问题。

但是数据科学并不是解决所有问题的方法

在最近的一次数据科学会议上，主题演讲似乎决定了房间的气氛——数据科学是一个组织有史以来最好的事情，其他“过时”的分析方法只是碍手碍脚。尽管我相信大数据和机器学习的优点，但我拒绝相信数据科学是解决世界所有问题的灵丹妙药，尤其是在政策领域。

数据科学试图解决的政策问题是跨学科和复杂的。几代人以来，人们一直在研究这些问题，在提出数据科学解决方案之前，我们应该致力于了解相关政策领域的历史、法律和社会经济基础。现实中的细微差别很难用语言来捕捉，更不用说模型了，所以我们所能做的就是尝试从定性和定量的角度来理解这个主题。

让我们记住，在解决代码中的细节之前，要考虑全局。“那又怎样”的问题通常是最难回答的:在这种情况下，数据科学有什么帮助？什么样的内在假设和偏见将被纳入模型？谁会使用它，他们会用它做什么？谁的生活会受到结果的影响？只有到那时，我们才能决定数据科学是否是正确的工具，以及如何最好地利用它。

模型只是第一步

尽管这很诱人，但我们不能把自己埋在数字中，然后把产出交给组织的决策者。准确有效地交流模型与构建强大的分析产品同样重要。模型可解释性是一个棘手的话题，随着数据科学能力变得越来越先进，这个话题会变得更加棘手。然而，如果我们要对公共政策产生任何有意义的影响，非技术合作者需要对我们的模型的方法和结论有一个基本的理解。我们不能指望人们盲目购买他们不信任或不理解的东西。

我们还必须能够与统计学家、经济学家和其他社会科学家说同样的语言，他们现在是并将继续是政策组织的重要组成部分。我们应该探索数据科学如何与因果推理、项目评估和更传统的政策分析方法相结合。这样做将有助于数据科学在公共政策领域获得更大的可信度。

数据科学是一种特权

先说数据科学领域的代表性。数据科学帮助我们以一种前所未有的方式来衡量人类的心理模型和决策。这些算法模型在公共政策中实施时，可能会影响数百万选民的生计。因此，至关重要的是，设计它们的个人能够代表并同情受影响的人。

女性和少数民族在数据科学领域的更多代表将有助于识别和克服算法中的无意偏差。随着我们进入一个技术占主导地位、创新蓬勃发展的世界，我们需要更多的代表性，以确保数字时代不会将整个群体抛在后面。

我听说数据科学是一个不断发展的领域，我很荣幸能够研究它，作为我影响公共政策和社会变革的追求的一部分。正如他们所说，伴随着巨大的特权而来的是巨大的责任。因此，让我们继续学习、分享、提问和编码，不要忘记屏幕上数字背后的人类。

必须了解深度学习(AI)中的信息论概念

原文：https://towardsdatascience.com/must-know-information-theory-concepts-in-deep-learning-ai-e54a5da9769d?source=collection_archive---------2-----------------------

信息论是一个重要的领域，对深度学习和人工智能做出了重大贡献，但对许多人来说却是未知的。信息论可以被视为深度学习的基本构建模块的复杂融合:微积分、概率和统计。人工智能中来自信息论或相关领域的一些概念的例子:

流行的交叉熵损失函数
基于最大信息增益构建决策树
维特比算法广泛应用于自然语言处理和语音中
在机器翻译 rnn 和各种其他类型的模型中普遍使用的编码器-解码器的概念

信息论历史简介

Claude Shannon, the Father of Information Age.

在 20 世纪早期，科学家和工程师一直在为这个问题而努力:“如何量化信息？有没有一种分析的方式或者一种数学的衡量方法可以告诉我们信息的内容？”。例如，考虑下面两句话:

布鲁诺是一只狗。
布鲁诺是一只棕色的大狗。

不难看出，第二句话给了我们更多的信息，因为它还告诉我们，布鲁诺除了是一只“狗”之外，还是一只“大”和“棕色”的狗。如何量化两句话的区别？我们能有一个数学方法来告诉我们第二句话比第一句话有多少信息吗？

科学家们正在努力解决这些问题。数据的语义、领域和形式只是增加了问题的复杂性。然后，数学家兼工程师克劳德·香农提出了“熵”的概念，这一概念永远改变了我们的世界，标志着“数字信息时代”的开始。

Shannon introduced the term “bit” in 1948, that he humbly credited to his colleague John Tukey.

Shannon 提出“数据的语义方面是不相关的”，当涉及到信息内容时，数据的性质和意义并不重要。相反，他用概率分布和“不确定性”来量化信息。香农还引入了“比特”这个术语，他谦逊地称之为他的同事约翰·图基。这一革命性的想法不仅奠定了信息论的基础，也为人工智能等领域的进步开辟了新的途径。

下面我们讨论深度学习和数据科学中四个流行、广泛使用且必须知道的信息理论概念:

熵

也称为信息熵或香农熵。

Entropy is a measure of randomness or uncertainty in an experiment.

直觉

熵给出了实验中不确定性的度量。让我们考虑两个实验:

扔一枚硬币(P(H)=0.5)，观察其输出，比如 H
扔一枚有偏向的硬币(P(H)=0.99)，观察它的输出，比如说 H

如果我们比较这两个实验，实验 2 比实验 1 更容易预测结果。因此，我们可以说实验 1 比实验 2 更不确定/不可预测。实验中的不确定性是用熵来衡量的。

因此，如果实验中有更多的内在不确定性，那么它就有更高的熵。或者实验越不可预测，熵就越大。实验的概率分布用于计算熵。

一个确定性的实验，是完全可预测的，比如扔一个 P(H)=1 的硬币，熵为零。一个完全随机的实验，比如说掷骰子，是最不可预测的，具有最大的不确定性，并且在这样的实验中具有最高的熵。

Experiment of tossing a fair coin has more entropy than tossing a biased coin.

看待熵的另一种方式是我们观察随机实验结果时获得的平均信息。从实验结果中获得的信息被定义为该结果发生概率的函数。结果越罕见，从观察中获得的信息就越多。

例如，在一个确定性实验中，我们总是知道结果，所以没有从观察结果中获得新的信息，因此熵为零。

数学

对于离散随机变量 X ，可能的结果(状态)为 x_1，…，x_n，以比特为单位的熵定义为:

其中 p(x_i)是 X 的 i^th 结果的概率。

应用

熵用于自动决策树构造。在树构建的每一步，使用熵标准进行特征选择。
模型选择基于最大熵原则，即从竞争模型中选择熵最高的模型为最佳模型。

交叉熵

直觉

交叉熵用于比较两种概率分布。它告诉我们两个分布是多么相似。

数学

在同一组结果上定义的两个概率分布 p 和 q 之间的交叉熵由下式给出:

应用

Convolutional Neural Network based classifiers often uses softmax layer as final layer that is trained using a cross-entropy loss function.

交叉熵损失函数广泛用于分类模型，如逻辑回归。交叉熵损失函数随着预测偏离真实输出而增加。
在像卷积神经网络这样的深度学习架构中，最终输出“softmax”层经常使用交叉熵损失函数。

交互信息

直觉

互信息是两个概率分布或随机变量之间相互依赖性的度量。它告诉我们一个变量携带了多少关于另一个变量的信息。

互信息捕捉随机变量之间的依赖性，并且比仅捕捉线性关系的普通相关系数更一般化。

数学

两个离散随机变量 X 和 Y 的互信息定义为:

其中 p(x，y) 为 X 和 Y 的联合概率分布， p(x) 和 p(y) 分别为 X 和 Y 的边际概率分布。

应用

In a Bayesian Network, the relationship structure between variables can be determined using mutual information.

特征选择:不使用相关性，可以使用互信息。相关性只捕获线性相关性，而遗漏了非线性相关性，但是互信息没有。零的相互独立性保证了随机变量是独立的，而零相关性则不然。
在贝叶斯网络中，互信息用于学习随机变量之间的关系结构，并定义这些关系的强度。

Kullback Leibler 散度

也称为相对熵。

KL divergence is used to compare two probability distributions

直觉

KL 散度是发现两个概率分布之间相似性的另一个度量。它衡量一个分布与另一个分布的偏离程度。

假设，我们有一些数据，它的真实分布是“P”。但是我们不知道这个‘P’，所以我们选择一个新的分布‘Q’来近似这个数据。因为“Q”只是一个近似值，所以它不能像“P”那样很好地逼近数据，并且会发生一些信息丢失。这种信息损失是由 KL 散度给出的。

“P”和“Q”之间的 KL 散度告诉我们，当我们试图用“Q”近似“P”给出的数据时，我们丢失了多少信息。

数学

一个概率分布 Q 与另一个概率分布 P 的 KL 散度定义为:

应用

KL 散度通常用于无监督机器学习技术变分自动编码器。

信息论最初是由数学家和电气工程师克劳德·香农在 1948 年发表的开创性论文《通信的数学理论》中提出的。

注意:实验、随机变量和人工智能、机器学习、深度学习、数据科学等术语在上面已经被松散地使用，但在技术上有不同的含义。

如果你喜欢这篇文章，请关注我 Abhishek Parbhakar 获取更多关于人工智能、哲学和经济学的文章。

我的第一个机器学习项目 PT1

原文：https://towardsdatascience.com/my-1st-machine-learning-project-pt1-2f4368f63f52?source=collection_archive---------11-----------------------

这一刻终于到来了

WOCinTechChat

大家好！希望你们都过得好。我正在兑现我在上一篇文章中的承诺。今天我们将关注线性回归。数据集是关于国王郡地区 2014 年 5 月至 2015 年 5 月间出售的房屋。你可以在 Kaggle 上自己下载。这是一个寻找数据集和练习机器学习的好地方。如果你和我一样兴奋，让我们开始吧。

线性回归

线性回归是一种使用变量(或机器学习的特征)来预测定量变量(目标变量)的算法。更具体地说，它试图拟合一条穿过数据的直线，该直线最好地表示预测变量和目标变量之间的关系。

想起我在上一篇帖子里举的工资例子。你试图根据某人多年的工作经验来预测你的薪水。工资是目标变量，工作年限是预测变量。这个数据集的目标变量是房屋的价格。我们的预测者呢？我们把这个装进去，看看有什么发现。他们所代表的东西可以在这里找到。

Housing_df <- read.csv("kc_house_data.csv")
str(Housing_df)
'data.frame': 21613 obs. of  21 variables:

$ id           : num  7.13e+09 6.41e+09 5.63e+09 2.49e+09 1.95e+09 ...

$ date         : Factor w/ 372 levels "20140502T000000",..: 165 221 291 221 284 11 57 252 340 306 ...

$ price        : num  221900 538000 180000 604000 510000 ...
 $ bedrooms     : int  3 3 2 4 3 4 3 3 3 3 ...
 $ bathrooms    : num  1 2.25 1 3 2 4.5 2.25 1.5 1 2.5 ...

$ sqft_living  : int  1180 2570 770 1960 1680 5420 1715 1060 1780 1890 ...

$ sqft_lot     : int  5650 7242 10000 5000 8080 101930 6819 9711   7470 6560 ...

 $ floors       : num  1 2 1 1 1 1 2 1 1 2 ...
 $ waterfront   : int  0 0 0 0 0 0 0 0 0 0 ...
 $ view         : int  0 0 0 0 0 0 0 0 0 0 ...
 $ condition    : int  3 3 3 5 3 3 3 3 3 3 ...
 $ grade        : int  7 7 6 7 8 11 7 7 7 7 ...
 $ sqft_above   : int  1180 2170 770 1050 1680 3890 1715 1060 1050 1890 ...

$ sqft_basement: int  0 400 0 910 0 1530 0 0 730 0 ...

$ yr_built     : int  1955 1951 1933 1965 1987 2001 1995 1963 1960 2003 ...

$ yr_renovated : int  0 1991 0 0 0 0 0 0 0 0 ...

$ zipcode      : int  98178 98125 98028 98136 98074 98053 98003 98198 98146 98038 ...

$ lat          : num  47.5 47.7 47.7 47.5 47.6 ...

$ long         : num  -122 -122 -122 -122 -122 ...

$ sqft_living15: int  1340 1690 2720 1360 1800 4760 2238 1650 1780 2390 ...

$ sqft_lot15   : int  5650 7639 8062 5000 7503 101930 6819 9711 8113 7570 ...

不算价格，我们总共有 20 个可能的预测变量。如果只选一个，那就叫简单线性回归。如果我们选择 1 以上，多元线性回归。很简单，不是吗？现在我们如何选择我们应该使用的变量呢？一种方法是使用所有的东西来建立一个模型，根据一个特定的标准来评估这个模型，然后一个接一个地移除每个预测因子。我们将执行的另一个方法是对每个预测值进行逻辑思考，看看创建模型和做出好的预测是否有统计学意义。更具体地说，我们将保留本质上是有序的变量。

所以现在让我们开始移除一些。ID & zipcode 可以走了。它们都是标签，不会从数字上告诉你一个数字是否比另一个好。id 2346 并不比 2342 好。所以现在我们只剩 18 个了。接下来，我们将删除纬度和经度。这些只是地图上房子的坐标。对于线性回归模型，它们是不需要的。

其他 16 个暂时可以接受。尽管我们需要做些调整。如果您查看日期变量，您会注意到它不是最易读的。最重要的是，它也不是定量的。所以我们将它转换成数字:

#Converting to regular text first
Housing_df$date<- as.Date(as.Date(as.character(Housing_df$date),"%Y%m%d"))#Now converting to number
Housing_df$date <- as.numeric(Housing_df$date)

太棒了。我们现在准备进入机器学习的下一步。

训练和测试集

在机器学习中，你将数据分成两组:训练集和测试集。定型集是您的模型从中学习的数据部分。测试集用于查看您的模型对以前没有见过的数据的预测效果。为什么不用整个数据集来代替呢？如果你这样做了，你的模型在预测新值方面就不会做得很好，因为它捕捉了特定数据集的模式。这么看吧。你通过模拟考试来准备考试。你只研究你在课堂上得到的答案和问题出现的顺序，而不理解概念。当真正的考试以随机顺序出现问题时，你不会做得很好。

我们要做的第一件事是考虑有多少数据将进入训练集，哪些数据将留给测试集。通常越多越好，所以我会把数据分成 80-20 份训练测试。

#Split data into training and test setslibrary(caTools)set.seed(1234)
split <- sample.split(Housing_df$price, SplitRatio = 0.8)
training_set <- subset(Housing_df, split == T)
test_set <- subset(Housing_df, split == F)

已经完成了。训练集包含 17，839 个观察值，测试集将包含 3，774 个观察值。如果你对布景有疑问，seed 是为团队工作准备的。当一个数据集被分割时，最终出现在一个数据集和另一个数据集之间的观察值是随机的。由于一个随机数发生器。当你设置了一个种子，你就说明了 rng 从哪里开始。这使得您的工作具有可重复性，这在数据科学中非常重要。所以如果你的同事想评价你的工作，或者想看看你哪里出了问题，只要输入相同的种子，他们就可以下载相同的数据集，得到和你一样的观察结果。

现在我们开始做好事了。我们要建立一个线性回归模型！终于！

模型结构

线性回归模型基本上是一个数学公式的表示。不要担心，我们不会在第 1 部分得到超级数学；只是想给你提个醒。这就是我们将如何建立这个模型。

model1 <- lm(formula = price ~ date + bedrooms + bathrooms + sqft_living + sqft_lot + floors + waterfront + view + condition + grade + sqft_above + sqft_basement + yr_built + yr_renovated + sqft_living15 +  sqft_lot15, data = training_set )

首先，我们使用 lm 函数让我们知道我们在构建什么样的算法。价格是我们的目标变量，所以我们首先列出它。在~之后，我们列出所有我们想用来预测的变量。最后，让我们陈述我们用来构建模型的数据集。如果我们想看看它是什么样子:

Call:
lm(formula = price ~ date + bedrooms + bathrooms + sqft_living + 
    sqft_lot + floors + waterfront + view + condition + grade + 
    sqft_above + sqft_basement + yr_built + yr_renovated + sqft_living15 + 
    sqft_lot15, data = trainig_set)Residuals:
     Min       1Q   Median       3Q      Max 
-1415203  -110571   -10066    92170  4203618Coefficients: (1 not defined because of singularities)
                Estimate Std. Error t value Pr(>|t|)    
(Intercept)    4.687e+06  2.860e+05  16.384  < 2e-16 ***
date           1.027e+02  1.463e+01   7.017 2.34e-12 ***
bedrooms      -4.568e+04  2.354e+03 -19.406  < 2e-16 ***
bathrooms      4.805e+04  3.893e+03  12.342  < 2e-16 ***
sqft_living    1.707e+02  5.195e+00  32.859  < 2e-16 ***
sqft_lot      -6.375e-03  5.472e-02  -0.117  0.90725    
floors         2.323e+04  4.246e+03   5.470 4.56e-08 ***
waterfront     6.149e+05  2.042e+04  30.116  < 2e-16 ***
view           4.267e+04  2.534e+03  16.840  < 2e-16 ***
condition      1.979e+04  2.824e+03   7.009 2.49e-12 ***
grade          1.226e+05  2.515e+03  48.748  < 2e-16 ***
sqft_above    -1.207e+00  5.074e+00  -0.238  0.81199    
sqft_basement         NA         NA      NA       NA    
yr_built      -3.663e+03  7.966e+01 -45.989  < 2e-16 ***
yr_renovated   1.346e+01  4.408e+00   3.053  0.00227 ** 
sqft_living15  2.293e+01  4.045e+00   5.669 1.46e-08 ***
sqft_lot15    -6.312e-01  8.790e-02  -7.181 7.22e-13 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1Residual standard error: 220400 on 17823 degrees of freedom
Multiple R-squared:  0.6607, Adjusted R-squared:  0.6604 
F-statistic:  2314 on 15 and 17823 DF,  p-value: < 2.2e-16

呜！我们的模型建成了！但是这些数字是怎么回事？星星呢？模型有多好？这些是我们将在第 2 部分中回答的问题。我现在不想打击你们。

如果你学到了新的东西，并准备好第 2 部分，点击推荐按钮！

给有抱负的数据科学家的建议。

原文：https://towardsdatascience.com/my-advice-to-an-aspiring-data-scientist-2ace6bd5cbe6?source=collection_archive---------4-----------------------

简介

在本文中，我将谈论我进入数据科学领域几个月来所信奉的价值观，任何有抱负的数据科学家都可以从中获得宝贵的见解。成功是一个旅程，而不是目的地，从成为伟大的人的过程中学到的价值观、经验和挑战才是这个过程值得的。

许多人专注于成为一名成功的数据科学家的技术层面，抛弃了非技术价值，这些价值不仅为成为一名伟大的数据科学家奠定了坚实的基础，也为成为一名全面的数据科学家奠定了坚实的基础。

那么，谁是数据科学家呢？数据科学家是使用统计、数学和数据技术解决业务问题的人。他必须通过提出正确的问题来了解业务领域，具备统计和数学技术的基本知识，如线性代数、微积分、优化和算法、概率等。对 OSEMN(获取、清理/清理、探索/可视化、建模、解释)等数据技术的扎实理解非常重要。

为了理解简单线性模型的工作原理，你需要耐心、学习新事物的欲望、好奇心(即使它杀死了猫)、结构性思维等，这些是你需要学会接受的价值观，也是我们将要关注的。

心态决定一切。

成为一名数据科学家既有趣又令人兴奋，也可能困难又无聊，这取决于你的心态。这一切都始于头脑！你如何让成为一名数据科学家变得有趣和令人兴奋？

你是你周围人的总和。如果你周围都是鼓励和积极的人，你很可能也会一样。LinkedIn 是社交工具之一，在数据科学的指导和激励方面拥有非常强大的社区支持。有伟大的数据专家，如凯尔·麦基乌、兰迪·劳，他们有网站、课程和网络研讨会，致力于帮助有抱负的数据科学家。我从这些伟大的人身上获得了灵感和指导。没有人一开始就是专家，如果他们已经在他们所做的事情上取得了成功，你也可以取得成功，只是要有正确的心态。

一致性是关键，即使进展缓慢也要坚持下去，突破界限，被拒绝，这是你知道你真的在做一些伟大的事情的时候。参加漫长而无聊的 MOOCs 课程，最终你会学到新的东西。

结构化思维。

真正让数据科学家脱颖而出的是解决问题和结构化思维技能，工具只是实现这一点的一种方式。客户和利益相关者会告诉你一个业务问题，你需要制定策略并使用数据科学来解决。

你如何用结构化思维技巧解决问题？

理解问题。大多数难题之所以难，是因为我们没有花时间去理解它们。这包括问正确的问题。不要急于解决问题，要对问题有一个清晰的定义，不管是业务上的还是技术上的。“如果你不能用简单的术语解释它，那么你就没有理解它。”
**计划。**这包括规划您的解决方案。从基本问题开始，到问题的复杂部分。
分。大事是小事的总和。把你的问题分解成子问题，它会变得更容易解决。一旦你想通了每一个子问题，就把这些点连接起来，因为这将给你原问题的解决方案。
卡住了？？当你陷入解决问题的困境时，学会休息而不是放弃。你找到解决办法只是时间问题。现在用不同的方法回到问题上，重复上面的步骤。
练习！！我们通过做来学习。练习，练习，练习。

提高技能的资源:

结构化思维的艺术。

提高结构化思维的工具。

学习基础知识。

当谈到理解数据科学的基础知识时，你必须咬紧牙关。获取统计和数学概念，因为它们有助于为您正在构建的模型打下坚实的基础。

重要性的突破:

资源:

想统计数据。
推理和描述统计
可汗学院概率

论编程语言，从 PYTHON 开始，擅长就行了。把它作为一个整体来学习，因为它能让你更好地理解每一个概念。由于模型易于部署并能快速投入生产，大多数公司现在都在转向 python。

资源:

data camp 上的 Python 课程

用于数据分析的 Python

Python 数据科学

数据存在于数据库中，知道如何检索它很重要。首先学习 SQL，许多有抱负的数据科学家忘记掌握这一基本技能。一点 SQL 就能走很长的路。学习内连接和左连接分组，理解空、更新、插入、删除等。

资源:

SQL 简介

SQL 命令

边做边学。

成为数据科学家的最佳方式是从事数据科学。你必须把手弄脏。没有目标的学习是遗忘的秘诀。找到你感兴趣的任何项目或领域，获取数据集并开始工作。如果你陷入了一个给定的概念，学习和探索它，然后回去用获得的知识完成任务。

拥有一份优秀的作品集对于招聘者轻松雇佣你来说是非常重要的。

伟大的投资组合需要什么？

拥有至少两个解决现有业务问题的项目。这证明你了解公司面临的问题和挑战，因此可以用你的数据技能影响一个组织。
投资组合中的项目应该专注于提升你的个人技能，如探索性分析、特征工程等。
专注于在给定的技能组合中变得有能力，足够胜任一份工作。
概述项目中的挑战、失败和成功，最好是如何改进以有效解决手头的问题。

就实际工作经验而言，你可以在一个 NGO 或任何组织中做志愿者，提出数据驱动的解决方案，或者参加 Kaggle 竞赛，仅仅是为了让自己的手和脚沾湿。

分组学习。三个臭皮匠顶个诸葛亮。小组学习使你能够互相学习，分享不同的观点，共同成长。Linkedln 提供了这样一个伟大的社区，有杰出的个人，如兰迪·劳、凯尔·麦基乌、凯特·斯特拉赫妮。

教导和帮助他人。

“如果你不能向一个六岁的孩子解释清楚，那你自己也不明白。”—阿尔伯特·爱因斯坦

学习新东西的最好方法是教别人，因为这能激励你通过积极的研究更好地理解你所学的东西。努力分享你的知识、经验和所有失败中的精华，这样别人就能从你的错误中吸取教训，完善自己。你能提供的最好的服务是给别人。

我进入数据科学领域的核心动机之一是通过数据驱动的明智决策来改善人们的生活，我努力在日常生活中实现这一目标。

不要把你的技能局限于你使用的工具，包括有效沟通、与他人合作和共同创新的能力。

教育他人需要通过创建自己的博客、在 LinkedIn、Medium、Reddit、Github 等网站上分享想法和文章来保持强大的在线影响力。

找个导师。

导师通过建议、网络和支持强调长期发展。您可以从导师的错误和失败中学习，这是攀登数据科学成功阶梯的一种更简单、更快速的方式。从他们那里获得关于你的进展和项目的持续的、诚实的反馈，对于评估你的表现和知道你做的事情是否正确是非常重要的。

一个导师不一定是一个人，但是你可以从书籍、LinkedIn 帖子、文章、Github、Kaggle 内核等中学到很多东西。只要挑一个适合你的就行了。

通过建立关系建立人脉。

与公司中有影响力的潜在招聘人员建立个人关系是每个有抱负的数据科学家都应该长期掌握的一门艺术。你会面临很多拒绝，但坚持不懈地提高这项技能，你最终会得到你梦想的工作。

努力与招聘人员建立私人关系，而不是职业关系。这包括了解他们的爱好是什么，是什么激发了他们的工作，计划一次喝酒聚会或虚拟聚会，你能做些什么来帮助他们实现目标等等。

与一家有着远大目标、你渴望成为其中一员的合适公司合作是非常重要的。对公司、他们的技术、他们使用的工具、他们正在做的项目做一些研究，向他们展示你对他们的价值。

你不一定要做到最好，只要想好如何低效地展现你所擅长的领域就行了。你越早意识到你不可能成为所有事情的大师，你就会成为越好的数据科学家。记住你的经验在你的技能、心态和态度中。

结论。

我最大的满足是和一个在数据科学方面有相似兴趣的人一起学习、支持和成长。我总是渴望向我遇到的任何其他数据专家学习，因为我相信我们总是可以从彼此身上学到一些东西。我希望您能从这篇关于成为更好的数据科学家的文章中获得有价值的见解。

如果你想给这篇文章添加任何提示，请随时留言。感谢任何形式的反馈！不要忘记分享和帮助某人成为更好的数据科学家！！我们可以通过我的 LinkedIn 继续讨论，或者你可以发电子邮件给我你的意见brynmwangy@gmail.com。干杯！！

我的网络克隆:数字化自我

原文：https://towardsdatascience.com/my-cyberclone-digitized-self-847782641c5c?source=collection_archive---------2-----------------------

#TBT 我的网络克隆#试用版 1。正在预加载…

#TBT to cyberlone MK1. A lot of mock data is used.

我是在一年前作为个人夜间爱好开始钻研这个项目的(https://TechCrunch . com/2016/01/09/virtual-reality-and-a-parallel-universe-of-cyber clones/罗斯·芬曼本杰明·莱因哈特)。并不是说我在攻读博士学位、创业、指导学生和抱怨生活之间没有任何事情可做。但是，不像你们大多数人，我不擅长采取积极的措施来保持健康。去年一整年，健康对我来说都很糟糕，所以我只是想预测任何即将袭击我的健康灾难——让我远离编码、机器人和其他美好的生活。换句话说，我开始建立我自己的网络克隆——我的身体、情绪和行为的预测模型——我自己的数字印记。最终有一天，使用可植入的可穿戴设备/放电单元，自动调节(闭环系统)重要变量到一个名义参考值。这些可能是很多东西——一些例子可能是——葡萄糖、维生素甚至多巴胺——它当然会让你了解牙齿蛀牙的传播(是的，也有数学模型！)这样你就不会因为牙痛进两次急诊室(在美国，更换一颗牙齿要花掉我 4 个月的研究生津贴！！！这是一个巨大的动力。)

似乎体育界已经尝试了所有优化性能的方法——最终我们都将拥有自己的参数模型，使用可植入的可穿戴和放电单元进行优化。也许在遥远的未来，我们还会用实验室定制的神经元来取代我们的神经元，以增强我们的聪明度。

虽然我在先进的神经网络方面越来越好，但首先，我发现大量的人类行为是相当确定的，可以基于具有某些不确定性界限(也可以有条件地变化)的数据驱动的统计模型。我应用的大部分数学是从我博士学位的一部分借来的，在那里我编写了一个软件来处理多达 400 万个模糊的数据点，以估计未知的非线性(对于我简化的博士问题来说，这是不错的数据量，但在许多情况下，你可以处理 1000 倍以上的数据；你要学会什么是适量的样本)。我学到了很多关于数据采样，偏见，为什么太多的数据并不总是好的-然后归结为你在用它做什么。很多都是基于大型数据集的降维，建立变量之间的相关性(对于无法实时测量的事物和找出正确的生物标志函数尤为重要)，并确定足以描述问题模型的关键组件。最近，我开始编写非常简单的算法(通常是在我弄坏了无人机，需要分散注意力，或者只是生生活的气的时候)——来代表一个代理人应该如何应对与最初的预测模型相矛盾的失败、拒绝和心碎。在这个过程中，我对人类的身体和大脑有了相当多的了解——我对此知之甚少！

与生物人类的传统建模不同，我的工作可能有些简化——基于这样的假设，即我不需要按照科学在任何粒度级别匹配生物/化学过程。我最关心的是，主模块的输出是否与你在普通生物过程中看到的相匹配。原因是，无论如何，这个世界真的看不到你内心发生了什么。所以在多智能体交互问题中，我所关心的是仿真智能体在任何情况下的输出。我是按照生物学来模拟心脏还是大脑与我的问题无关，只要——比方说——让“真实的我”哭泣的外部刺激也让我的数字自我或“网络克隆”哭泣。新型号比我开始时的要好得多。不过进展很慢——没有足够的时间做副业。但是，我认为一旦我自动化持续的数据上传和模型更新，它会好得多。

仍然非常初步，但几天前就想把它加载到 Github 上。作为一名机器人专家，我必须更加负责任:)所以这将是一个个人的激情项目——尽管我总是很高兴在休息的时候和任何从事这方面工作的人交谈:)

一个困扰着我的人有时会感觉很糟糕——因为我认为我只是把我的生活经历、情绪甚至牙痛归结为数据和样本观察。

我的数据和设计道德宣言

原文：https://towardsdatascience.com/my-data-and-design-ethics-manifesto-e9a2374345b7?source=collection_archive---------11-----------------------

本帖原载于LinkedIn 2018 年 5 月 30 日

作为一名设计研究负责人，我参与了许多数据驱动的项目，我一直在思考很多关于“大数据”的伦理问题。

尽管基于数学和统计学，但数据驱动的模型丝毫不受偏见、成见和人类彻头彻尾的恶意本性的影响。无论这些不道德的价值观是由它们的创造者传递给数学模型的，还是它们使用(或滥用)的函数，没有观点的数学在大数据世界中是不存在的。因为每一个数据点、每一个二元表达式、每一个公式、函数、统计模型的背后，都是实际的人。有时我们会忘记这一点。

要想找到证据证明事情可能会变得非常糟糕，你可以从这种反乌托邦式的科学出错小说中得到启示，比如赫胥黎的《美丽新世界》，或者阿西莫夫的《我是机器人》系列，或者你也可以看看我们最近的数学被用作武器的历史，在凯茜·奥尼尔的书《数学毁灭的武器》中有如此直白的描述。

奥尼尔写得像一个痛苦的离婚女人，发现她曾经深爱的伴侣欺骗她，描绘了一幅道德和大数据的惨淡画面。她抨击算法的仲裁者，这些算法用扭曲的半生不熟的代理预测模型将美丽优雅的数学变成“数学毁灭武器”，用真实数据代替观点和半真半假的事实。

奥尼尔编造了大量的故事，讲述了推动算法引发的纸牌屋住房危机的邪恶，以及坏演员致富所使用的糟糕数学，让我们其余的人感到震惊。她揭穿了标准化测试(它既不是标准的，也不符合公平测试)作为评估教师工具的隐含公平性。她指出，在刑事司法系统中，预测性量刑模型中使用的算法工具存在固有的偏见。她的清单还在继续。

对于我们这些深知人类有能力将最温和的工具变成邪恶的仲裁者的人来说，奥尼尔的案例研究并不令人惊讶。

十多年来，大数据占据了中心舞台，人工智能、有知觉的生物和机器人等领域被推入主流，我们越来越善于识别利用数据力量的坏人。然而，下一个挑战从危险信号转移到了一个明显灰色的领域。

对全世界的脸书人、亚马逊人和谷歌人来说，当然，对我们来说，当我们设计以数据为燃料的系统时，这就是我们真正开始看到棘手的伦理问题甚至不需要尝试就迅速变成膝盖深的危机的地方。

数据驱动的问题从看似无害到完全令人不快——事实上，谷歌的一个搜索算法向男性而不是女性显示了更高报酬的招聘广告，或者声称亚马逊的搜索算法似乎倾向于自己的产品，拒绝给客户最好的东西，或者脸书玩弄你的新闻提要，从只向你显示悲伤的消息以衡量你的反应(令人讨厌)到压制保守或其他意识形态的消息(不确定)。给你看所有的假新闻(悲伤)。更不用说我称之为机器学习的“一上效应”了。虽然上面提到的怪癖经常发生在有偏见的数据驱动模型中，但是完全缺乏对人性的理解，再加上对编程代码优点的盲目相信，这可能是一种危险的民主崩溃的组合。

算法的扩展

脸书俄罗斯选举丑闻将很快成为《法律与秩序》的一集，但让我们重温一下十年来科技领域最大的故事之一。如果你已经看到了大量的数据和道德博客帖子，煤矿中的许多金丝雀哭诉科技缺乏同理心及其危险，这可能是因为世界上最大的科技公司之一被少数购买广告的俄罗斯人操纵，他们利用该公司的产品影响国家总统选举。我们现在知道这是真的，而不仅仅是猜测。

当你这样写的时候，听起来很奇怪。世界上最大的平台之一，拥有这个星球上最聪明的工程师，怎么会被如此愚弄？却不知道吗？却不去阻止？

从某种意义上说，脸书在不知不觉中成为了一个经典案例，说明为什么你需要的不仅仅是工程师，而是创造一个几乎无害的数据驱动产品。

为了理解为什么，让我们看看智能系统是如何构建的。

关于算法的简短入门(如果你以前听过，跳过)

首先，事情第一——像脸书创建的帮助用户创建和定位信息的智能系统中有什么？主要成分是算法。

算法是智能系统模型的组成部分。简单来说，算法就是一个解决问题的过程。构成智能编程或人工智能主干的大多数算法都是学习返回结果的决策模型。

它们被编程为筛选信息并返回结果，就像谷歌的搜索引擎一样。这些结果有标准，允许他们选择超过其他信息。这是由人，通常是计算机工程师或数据科学家编写的。

如果它们是有机物，我会给算法贴上病毒的标签。算法一旦被编程，在完成任务时会非常高效，尤其是一旦它们学会了基本的任务。让我们看一个例子。

假设你想在你遇到的每一篇文学作品中找到“种子”这个词。你可以做 CTRL+F 一百万次，但更有效的方法是让计算机解决这个问题。因此，您可以创建一个算法来梳理信息，找到单词“seed”

但是一个算法怎么知道什么是种子呢？比如 seed 和 meed 有什么不同？他们都很亲近。好吧，你可以训练它，所以机器，你的电脑，学会识别“种子”，但避免像“杂草”、“需要”和“meed”这样的词

你训练它，给它一堆信息，包括很多单词，包括“种子”，你训练它识别单词“种子”是什么。然后你告诉它不断重复，直到它停留在单词“seed”上，足够多次而不会把它误认为另一个单词。这就是图像处理、自然语言处理和其他基于算法的机器学习模型所发生的事情。

但是，一旦算法学习了一项任务，一旦学习曲线跳跃，程序就可以更快地识别，并猛烈攻击这些新发现的知识。

算法可以增长知识，你可以教它的知识，或者它可以自己学习的知识。现在，它可以将图像与单词“seed”进行匹配接下来，它可以匹配几乎没有提到“seed”但与该单词相关的整个段落。它可以快速且全面准确地做到这一点。然后，在“深度学习”中，它可以开始自己决定与“种子”这个词的相关性它已经超越了你的训练和解释，给你和其他人的不是他们要求的，而是它认为你想要的。

好了，回到我们定期安排的媒体文章

但是一个失控和被操纵的算法是脸书首席执行官马克·扎克伯格在国会作证的原因。再加上几个糟糕的演员——呆在家里的俄罗斯黑客——你就有了滥用和灾难的配方。仅仅通过几个“训练”广告，俄罗斯黑客就利用脸书的算法，用虚假的、未经证实的、耸人听闻的、但受欢迎的内容来攻击共和党人和右倾观众。其他坏人利用脸书的 PageRank 算法对喜欢、分享和评论的偏好，在社交媒体上像野火一样传播虚假、阴谋的内容。

但是脸书不是唯一的一个。通过向消费其内容的眼球销售来赚钱的社交媒体平台使用基于量化的指标来增加收入。算法的量化追求焦点导致这些平台分发嵌入了种族主义、性别歧视和几乎所有人类已知的其他主义偏见的内容。

脸书的 PageRank 系统追逐喜欢、评论和分享，创造了一个字面上和比喻上的“过滤泡沫”，提供主流新闻无法渗透的单音符精彩内容。

将人工智能模型武器化以创造新的现实

前奥巴马特工伊莱·帕里泽在 2011 年警告说，在线平台正在为个人生活在另一个现实中创造条件，在这个现实中，只有他们的观点和信仰得到加强。2016 年的选举不仅仅是帕里泽的威胁成真。事实上，情况要糟糕得多。

威斯康辛大学新闻学教授杨·米金(Young Mie Kim)在 2016 年选举期间，对脸书平台上制作和分发的有针对性的俄罗斯广告做了广泛的研究。她的研究既有启发性又令人沮丧，用赤裸裸的黑暗结果展示了算法模型的放大。

她发现俄罗斯支持的互联网研究机构在脸书大量购买和分发包含极端、煽动性和未经证实的右倾指控的广告。据《连线》杂志报道，这里有一个例子:

多个可疑团体共享的一则广告写道:“老兵优先于非法移民。300，000 退伍军人死于等待退伍军人管理局的检查。非法移民每年的医疗费用为 11 亿美元。

俄罗斯的广告购买额约为 10 万美元，结果只有 3000 个广告。但同样，我们在谈论数据驱动工具的放大。由于脸书算法，这些广告得到了喜欢和分享，因此比实际的新闻内容更受欢迎。

事实上，哥伦比亚大学 Tow 数字新闻中心的研究主任 Jonathan Albright 发表了一份令人惊讶的研究报告，研究了脸书平台上有多少俄罗斯广告被分享。

使用脸书自己的分析工具和俄罗斯广告购买账户的名称，奥尔布赖特估计他们的内容在平台上被分享了 3.4 亿次。这超出了过滤气泡的范围，是尼亚加拉大瀑布大小的洪水。

下个月，我将写一篇文章，分析由于数据驱动平台，仅仅 3000 个广告如何影响数百万人及其选举决定。我将在今年年底结束我的关于对抗和击败 AI 武器化的方法的系列文章。

但除了俄罗斯的坏演员之外，如果该平台的数据模型没有被设计成篡夺人类行为，那么在我们上次选举中主导社交媒体平台的俄罗斯广告、虚假和阴谋内容的野火蔓延就永远不会发生。这不是偶然。*这些模型的设计是基于一些最普遍的、激励人类行为的偏见。*他们被设计成利用我们的偏见来对付我们。

如果没有一个名为可用性级联的非常真实的认知偏差，俄罗斯的广告可能会失败。简而言之，可用性级联是人们仅仅因为看到重复而相信某件事的倾向。谚语“重复某事足够长的时间，它就会成真，”描述了人们仅仅因为听到很多就不得不相信他们所听到的倾向。

前脸书工程师 Antonio Garcia Martinez 对 Buzzfeed 谈到脸书在 2016 年选举中的共谋时，放大了 Pariser 的金丝雀叫声，w :

“我认为，民主是否能在脸书和所有其他类似脸书的平台上生存下来，这是一个真正的问题，”他说。“在脸书这样的平台出现之前，人们通常认为你有权保留自己的观点。现在，它更像是对自己现实的权利。”Buzzfeed 前脸书工程师。

你可以说这些都是利用工具做坏事的坏演员。事实上，这是脸书一开始反复说的。

雪莉·桑德伯格，首席运营官脸书公司说，直到 2017 年 10 月，“在我们的内心，我们是一家科技公司，我们雇佣工程师。我们不雇佣记者，没有人是记者，我们不报道新闻。”

但是越来越清楚的是，不仅仅是坏演员搞乱了脸书的模式。它远不止如此。

脸书坚称自己是一个平台，而不是内容出版商，这显然是错误的。一旦平台决定选择人们消费的内容，它就成了出版商。内容是否由平台创建并不重要。脸书创造了它的消费渠道。该公司使用数据驱动模型来决定哪些内容更好地提供给用户。

正是人们消费内容的欲望，大概是为了让他们留在平台上，并帮助他们赚取广告费，让该公司陷入了未知的道德困境，纠结于如何在保持平台纯净但受欢迎的同时，停止向他人传播仇恨言论、种族主义内容甚至辱骂性语言。

脸书现在正在创建程序来防止滥用其平台，但要解决这个问题，还需要发展一些基本信念。

一个信念的改变是根本性的:使用这些数据驱动工具的公司必须将自己视为世界和现实的设计师、创造者。

作为设计师，我们必须看到我们在这一切中的积极作用，不要再认为自己是一个被动的平台。

另一个需要发生的范式转变是更深入地理解人性，以及人类如何互动、使用数据驱动的工具以及受其影响。

当然，这也是需要道德准则的地方。

专家表示，科技公司及其“以量化为中心”的文化让社交媒体巨头对其数据驱动模式的后果视而不见。但是也有一种危险的想法，认为数据驱动的工具本身是无害的。坦率地说，这不是真的。这个工具并不比创造它的人更无害。正如我所展示的，这些模型是由人类创造、设计、训练和测试的。这意味着所有制造它们的东西都带有人类的特征。以不同的方式断言，就是无视事实。

但是，除了过滤泡沫和被操纵的产品，数据驱动的模型本身也可能造成大破坏。他们对效率的关注导致一些决策数据驱动模型将极端主义直接注入未知的地方。这里的关键是它是工具本身的一个公开动作。不是什么意外的后果。当然，这是真正的危险。

人工思维创造真正的行动

以谷歌的 YouTube 算法为例。嗯，它是专有的，所以你必须根据专家认为它是如何工作的来使用它。数据驱动模型不仅仅是根据用户的请求向他们分发内容。而是一旦算法学会了。它决定胜过用户。YouTube 的算法开始推荐与搜索请求相关的视频，但让直到几年前还被留在上午电台黑暗角落的内容浮出水面。

正如《纽约时报》、《T2》、《财富》杂志和《华尔街日报》、所详述的，谷歌的 YouTube 算法产生的内容结果远远超出了用户的要求。由于无法辨别推荐内容的类型，这种数据驱动的模式提供了用户原始搜索请求的极端版本。

它不再只是返回你所要求的，而是开始“推荐”它认为是内容的东西。《华尔街日报》的一项调查发现，这些内容比用户要求的要极端得多。

因此，像亚历克斯·琼斯、迈克尔·萨维奇、迈克·德拉吉这样的人，这些只被小部分听众所知的人，通过早上的广播和电视购物节目，突然开始在 YouTube 上显示足球妈妈的推荐列表，寻找当天的新闻信息。

例如，《华尔街日报》的工作人员进行了一项搜索“联邦调查局备忘录”的实验，当天的新闻都是关于共和党发布一份关于特朗普竞选期间情报官员行为的备忘录。结果是:

在 YouTube 上，在主流新闻来源的小缩略图之后，最热门的结果来自 BPEarthWatch，它自称“致力于观看导致我们的主耶稣基督回归的末日事件。彗星、小行星、地震、太阳耀斑和末日力量。”

他们还指出:

还有来自 Styxhexenhammer666 的视频，其信息页面上简单地写着，“我是上帝”，还有来自经常宣传阴谋论的网站 Infowars 的创始人亚历克斯·琼斯的视频。

如果我错了，请纠正我，但我从未听说过 BPEarthWatch，它们听起来肯定不像有人在键入“FBI 备忘录”时要找的东西。

脸书、推特和谷歌并没有恶意构建这些算法。但是他们忽视潜在危害的能力是一个重大错误。那么，我们究竟如何防止这种情况发生呢？

防止 AI“不可知无害”

除非你坚定地在军事、炮兵、轰炸或其他以死亡为中心的行业工作，否则你设计一个故意伤害人类、以数据为燃料的工具的可能性很小，但并非完全不可能。

这是无意的，无意的后果，对我们这些没有生活在边缘的人来说是危险的。这就是一套共享的道德准则最有用的地方。

如果没有一个有意的伦理讨论，无论是项目还是设计，技术人员、工程师和设计师都有落入狂妄自大的人性陷阱的风险，我把艾称为“不可知论无害”

不可知论无害是这种信念，因为模型使用数据，它免除了人类的弱点。在这篇我写的关于人类理想为中心的设计的中间文章中，阅读更多关于不可知论无害以及如何设计我们摆脱这种哲学的方法。

在这个领域工作多年后，首先作为一名记者做数据驱动的报道，现在作为一名设计研究员研究数据驱动的系统，我发现要想设计对人类的伤害最小，必须将道德准则融入创造过程。

伦理，即控制创造的是非观念，必须尽快解决。整个创作过程，然后把我的作品展示给一个伦理小组是不好的。一旦项目、想法、平台或产品实现，需要一个对人类行为有深刻理解的人在房间里，卷起袖子，准备与工程师、技术专家和数据科学家一起创造。

对一些人来说，答案是教会算法如何应对伦理困境。对我来说，这没有抓住重点。设计这些数据驱动模型的人必须首先进行伦理讨论。机器向我们学习。(至少目前如此……)

我研究这些模型已经四年多了，我发现有一些实用的、具体的道德准则，我试图遵循这些准则来确保无意的行为不会从无害变成有害。

从完全自愿但绝对有效的《新闻道德颂》(感谢职业记者协会)中得到启示，我精心制作了一个类似的道德框架，帮助我穿越大数据和设计的雷区。

这些道德准则并不意味着涵盖所有可能的情况。事实上，它们根本不是严格的指导方针。它们更像是谈话的引子和开始探索的话题，让你和你的设计团队走上无害的道路。

这些指导原则旨在当你抓住一个数据驱动的设计项目时充当煤矿中的金丝雀。

它们源于一个基础的地方，在那里善意是假定的，而故意消除有目的的坏行为者的愿望是你的核心。换句话说，我假设你从一个善良的地方开始。

如果数据挖掘收入数据的想法试图将穷人从获得房屋贷款中划出来，这让你想“嗨”，那么你就是我们这种数据设计师。其他人都寻求心理咨询。

让我们开始吧。

什么是伦理，什么不是伦理

要发展伦理原则，最好对什么是伦理原则有一个很好的理解。简单来说，伦理原则就是一个群体、文化、组织、行业或职业普遍认同的行为规则。它们是有共同点的人同意遵守的规则。(关于“伦理简介”，请查阅西蒙·布莱克本的《做好人》。"

谈到道德，人们喜欢用的最著名的例子之一是希波克拉底誓言。但那甚至是有问题的。因为它犯了一个常见的错误:混淆伦理和道德。(旁注:你读过经典的希波克拉底誓言？这是一个相当有趣的使命宣言。)

Wikipedia.com

该誓言以希波克拉底命名，希波克拉底是一位生活在公元前 460-370 年的希腊医生，其中蕴含了一些有趣的原则。当想到誓言时，大多数人会想起“首先，不要伤害”这句话，但当然它并没有确切地说“不要伤害”更像是，“让[病人]远离伤害和不公。”听起来不错。继续读。

如果你想了解伦理和道德原则之间的区别，那么看看医学誓言的经典版本和 1964 年由塔夫茨大学医学院院长路易斯·拉萨纳写的新的现代版本。(美国医学协会已经提出了一个更长的道德准则，在道德上不那么说教。)

经典的誓言将道德融入到既定的行为准则中。它说，宣誓者“既不会给任何索要致命药物的人，也不会提出这方面的建议。”

等等什么？禁止医生协助的自杀被写进了誓言。这是一种道德立场。一种偏见认为，即使人们要求结束生命，医生也不应该结束生命，尽管他们可以这样做。请继续阅读。

下一句经典的誓言说，“同样，我不会给一个女人流产的补救措施。我将保持我的生命和艺术的纯洁和神圣。”

说什么？是的，最初的希波克拉底誓言禁止医生辅助堕胎。甚至更偏向。

多年来，人们对誓言中的这两句话争议颇多。学者们说，大多数医学院和医生甚至没有意识到誓言中蕴含了多少道德；包括反复提到上帝、神和女神。20 世纪 60 年代，一个更加现代的誓言版本诞生了，它淡化了宗教含义，转而使用了更具思想性的语言。它包含了像“在生死问题上我必须小心行事”这样的短语。

正如你所看到的，创建伦理原则是一门艺术，既要提倡不伤害他人的最佳实践，又要忽略特定的道德标准和依赖于不具普遍性的尖锐观点的行为。你必须清楚，但不要太具体。你必须包容一切；但仍然具有普遍性。

从设计伦理到数据设计伦理

考虑到这一点，我们如何才能设计出对社会利大于弊的道德数据驱动产品呢？

好吧，让我们从作为以人为中心的设计师的原则开始。我们作为以人为中心的设计师最看重的是什么？

在 IDEO，我们说我们希望通过设计创造积极的影响。我们通过以人为中心的设计方法做到这一点，我们的首席执行官蒂姆·布朗称之为“设计思维”这种方法产生了一些设计的原则，包括:

透明度
参与性
上下文的
可持续的
改变的
鼓舞人心的

我认为，当处理由智能数据系统的创建或使用支持的设计项目时，这些设计原则不会改变。

有了这些作为指引，我就有了我所谓的“数据设计原则”这些是开始广泛探索主题的特定桶，将帮助您得出关于是设计数据引擎还是放弃的结论。

如果这些类别提出的问题的答案不是你想要的，让你觉得恶心，或者违背了你作为设计师的职业道德，那么你可能不应该设计这个数据引擎。

如果你这样做了，你需要制定协议，故障保险和调整，以确保你创造的东西，当规模扩大时，不会回来困扰你或其他任何人。在这些必须探索的类别中，有一些是我在涉及智能系统及其与人类的交集的项目中必须问的问题。这些类别和问题是:

以人为本

我创造的东西是以人类需求为中心的吗？它会为人类服务吗？它会让人类做得更好，成为更好，变得更好吗？简而言之，是以人为中心吗？如果不是，重新思考解决方案，使之成为现实。

保护隐私

我创造的东西会侵犯他人的隐私权吗？如果会，他们是如何被通知的，会受到什么影响？他们可以使用该产品并维护其个人隐私权吗？如果没有，他们知道他们牺牲了什么吗？获得的东西真的和基本的隐私权一样有价值吗？或者是给予和获得的交换是不平衡的。

保留身份选择

我创造的东西会剥夺一个人的匿名性吗，如果会，为什么，如何，会有什么后果，这是可以接受的吗，如果不可以，有什么方法可以防止吗？

创造安全

我创造的东西会伤害别人吗？如果是，如何以什么方式，为什么？有人能轻易地利用我创造的东西去伤害别人吗？有办法防止这种情况吗？我如何建立制衡机制来防止滥用和误用？

交付股权

我构建的东西可以用来伤害一个受保护的类吗？以什么方式？我建造的东西不包括人吗？为什么？我的设计公平吗？它是否以特权为出发点，永不偏离？我的模型能同样适用于不同种族、民族、背景和收入的人吗？

从良好的预期用途开始

该工具是否有预期的无害用途？即便如此，它最终会造成伤害吗？对谁，以什么方式？你如何防范虐待？我是否有检查点和里程碑来迭代和检查嵌入在设计中的模型？五年后我的模型会被如何使用？10?我怎么知道？

强调透明度

别人能追踪到我是如何创造这个数据驱动的产品的吗？我的过程听得见吗？有没有人可以追溯一下，了解一下我的模型是怎么创建的？如果不是为什么？所有相关人员都知道我创造了什么吗？如果是为什么不呢？

坚持法律的精神

我的工具合法吗？它是否违反了法律的条文甚至精神？除隐私之外，它是否遵守其他国家、州、联邦和国际法律？

将伦理融入人工智能和智能系统设计还有很多工作要做。这是一个复杂的问题。但是我们不能再假装数据是无偏见的。是人创造的。它有它的问题。任何根据数据创建的模型都可能存在这些问题。

我的深度学习求职面试经验分享

原文：https://towardsdatascience.com/my-deep-learning-job-interview-experience-sharing-4f47dd77f57d?source=collection_archive---------2-----------------------

最近，我正在寻找一份关于机器学习或深度学习的工作，直到今天，我已经面试了 6 家公司，也许还有更多(希望不需要更多)。也许我的经历可以帮助到像我这样的人，所以我决定写下来和大家分享。

让我简单介绍一下自己，我叫 Justin，来自中国广州，正在面试一些中国公司。我不是 CS 的学生，2015 年毕业，但是我自己直到今天才开始学习机器学习和深度学习。我认为我已经准备好进入人工智能行业，所以我在 2017 年 2 月辞去了之前的工作。好了，来看看我的经历吧。

第一家公司:以市场调研和信息处理为目标

这家公司还没有深度学习团队，他们想建立一个团队来做一些信息处理，但他们不拥有这些数据，他们只是购买数据或从互联网上下载。在访问这些数据后，使用机器学习对其进行处理，并将结果出售给其他公司。

我不认为他们会做得很好，因为 MLaaS 没有未来，更糟糕的是他们不创造自己的数据，所以我对这家公司不感兴趣。

面试官是 CTO，他一开始问了我之前工作的一些情况，然后问我会不会用 tensorflow。他没有测试我在机器学习或深度学习方面的能力，只是给出了一张关于他们要用深度学习做什么的图片。我觉得 CTO 不是很懂 ML 或者 DL，只是想建立一个团队。但是通过交谈，他给了我一个信号，公司不能支付太多的工资来雇用我，而且，两天后，他打电话给我说:哦，你的能力和我们的工作不太匹配，只是匹配一部分，让我们面对面地讨论你的工作和工资，如果你这几天很忙，慢慢来，我们不急着雇用你！

说实话，听到这个消息后我并不怎么舒服。

第二家公司:利用计算机视觉瞄准农作物病害检测

这家公司有一大片稻田，他们的员工每天都检查庄稼，看看庄稼是否有病虫害。我对他们将要做的很感兴趣，因为人工智能在农业上的应用很少。而且，他们有自己的数据(paddy)。他们想做的是用相机给庄稼拍照，用 CV 检测庄稼上是否有害虫，或者庄稼是否变黄。

但最大的问题是，他们没有任何技术团队！甚至他们都没有网站工程师！因此，面试官不能问我任何技术问题，她只是征求我对如何实现他们的目标的意见，并真正欣赏我能做什么。

但是她没有再打回来。

第三家公司:自动化创意

该公司是一家 SaaS 公司，他们的服务之一是为用户提供大量的图片元素，以创建自己的新海报或网站横幅。最棒的功能是，系统可以根据用户提供的一条描述语句生成一张新的图片！这是图像字幕的另一面，采访者说他们已经创建了一个演示版本，但不知何故，根据我们的整个对话，我不这样认为。

面试官是一个女孩，她的年龄和我差不多，我能看出她是 CS 专业的，那是因为她总是测试我关于数据结构和算法的知识！也没有问任何关于 CNN 或者计算机视觉的问题！关于机器学习的唯一一个问题是关于 k-means 的算法原理(感谢上帝她终于测试了我的 ML 知识)，我不能很好地回答她的数据结构和算法问题，因为我不是 CS 学生，但也许我以后会学习那个。

最后，她说他们想要一个简历深度学习方面的专家，最好有 5 年工作经验和博士学位。也许他们正在寻找谷歌，脸书工程师？

第四家公司:瞄准互联网和大数据安全

这家公司我不太了解，但我想他们为政府或其他公司提供网络安全服务。经理说每秒大约有 6T 数据通过他们的设备！有了这么大的数据量，他们想从中挖掘有用的东西，所以他们需要机器学习团队来做这件事。

有三个面试官，一个是经理，他只是坐在那里听我们的谈话。另外两个面试官是 ML 团队成员，基本上我和他们交谈。跟我聊的最多的女生是 CS 方面的高手，她问我一些机器学习的算法，比如 k-means，random-forest，决策树，但是很少问我深度学习。她说，该团队目前不使用深度学习，但他们以后会考虑应用深度学习。

实际上我们当时谈得很好，我展示了我在深度学习方面的知识，我们就他们所做的事情交换了一些看法。遗憾的是，后来我没有接到他们的电话，也许他们需要传统的 ML 工程师，或者也许我没有记住一些 ML 算法的细节，让他们认为我不擅长这个。但是它提醒我复习那些 ML 算法。

第五公司:融资公司

这家金融公司想招聘 NLP 工程师，尽管我是 CV 专业的，他们还是邀请我去做了一次演讲。面试官是专业的，大概是 CS 高手，他在数学上考我很多，让我做一些公式推导，比如给我一个简单的线性模型，让我写下 W 和 b 的显式解，原谅我我暂时不知道怎么做，但是我还在学习公式推导。

然后，他问了一些问题，有些很有趣:

我们都知道不应该把初始权重设置为零，但是在什么情况下，可以把它们设置为零呢？
动量、RMSprop 和 Adam 的数学原理是什么？
那些 imagenet 赢家机型有什么区别？
你渴望实现论文中的技术吗？如果你做了，你认为你的数学水平能应付吗？
嵌入层有什么用？为什么我们需要这一层？

总之，面试官想测试我的数学知识，我承认我现在做得不太好，但我会继续学习。

第六家公司:像亚马逊这样的电子商务公司

这家公司有大量的数据，如电子邮件，图片，卖家每天上传到他们的服务器。他们的人工智能部门希望自动检测图片并进行一些图片处理，以便公司可以节省大量的人力成本来进行图片处理。

面试官是实用主义者，他让我介绍一些我最熟悉的算法细节，没问题。然后，他问我对 CNN，backprop，SGD 的直觉，以及 keras 和 theano 之间的区别，我可以处理这些。

他让我印象深刻的一点是，他不会要求我只用一两个工具来建立模型，只要我能解决问题，不管你用哪个框架，不管你用什么编码语言，那都 ok！

总之，我认为这是我经历过的最好的一次面试，看来面试官对我的表现很满意，也许那天我会有好运。

以上是我所有的采访经验，如果我有后续的采访，我会和大家分享，如果你有什么想谈谈你的经验，我们很乐意听，希望我们的经验可以互相帮助！这是我在 medium 的第一篇博客，我会在接下来的日子里写更多，请给我一个赞或关注！

我的深度学习求职面试经验分享(二)

原文：https://towardsdatascience.com/my-deep-learning-job-interview-experience-sharing-part-2-d8ea1cb4861e?source=collection_archive---------4-----------------------

面试了 6 家公司之后，我拿到了第 6 家公司的 offer(你可以在这里回顾我的面试经历)，之后就再也没有其他面试了。实际上我应该在 2 周前发表这篇文章，但是我想在正式接受邀请之前分享更多的细节。

这次我不打算谈论我的面试经历，因为我没有更多的面试机会。但是我要分享一些其他人的经验，因为上一篇文章引起了一些讨论，有人在 fast.ai 论坛上分享了他们的经验(可以查看原帖)，我觉得真的很有帮助，我们来看看吧。

Benedikt S:

我觉得工作要求比他们找的要高。有 5 年工作经验的博士生没那么多。他们可能会查看脸书、亚马逊、谷歌等公司的职位描述。并且抄袭了要求。
在我的面试中，有人问我不知道的机器学习算法。我的回答是“我不知道——有这么多算法，如果你给我定义，我可以向你解释它是如何工作的”。和/或提出了另一种算法，它解决了同样的问题(有许多分类算法)。当然你应该知道像 k-means 这样的基本方法，但是我相信诚实比猜测要好。就我而言，我得到了这次面试的工作
如果他们没有深度学习团队/没有这方面的知识——我向他们解释了巨大的优势。谷歌在两年内从大约 10 个项目发展到超过 2000 个深度学习项目。优势在于，全世界都在谈论深度学习。我向他们展示了我的兴趣+关于社区的额外知识。我向他们解释了如何使用深度学习来解决他们的问题，例如基于隐藏层的图像相似性。
我知道，我的简历只包括项目/主题。我尽量把对话保持在我擅长的这些领域，而不是让他们问任何关于机器学习/计算机科学的问题。我试图向他们解释，这项工作是将理论应用于现实世界的问题，而不是重新发明轮子……许多问题可以用当前的框架解决，而不必从头开始实现一切。

我的回答是:

“我特别同意你的最后一点，我们应该把话题控制在我们擅长或熟悉的领域，你知道吗，我只是回答他们问的问题，所以他们总是找到更多不同的话题，因此我被困在我不太熟悉的领域。”

刘志军:

谢谢大家分享经验。我看了你的博客文章，想分享一些见解。我经营一家小型数据智能公司，最近我在中国上海为一家物联网公司部署了一个深度学习原型。

看了你的博文，我觉得这不是一个“框架”与“无框架”的问题。中国的招聘人员自然对千篇一律的投资组合项目持怀疑和警惕态度。尤其是因为深度学习仍然非常新，没有多少公司拥有成熟的基础设施和流程。

如果有的话，你的招聘人员可能会惊讶于你能从 fast.ai 中学到多少东西！

我的回答是:

“的确，fast.ai 拥有我们在深度学习中需要知道的一切！”

其实我从 fast.ai 学到的知识，对我现在的工作真的很有帮助。例如，我的一个新项目是检测照片中是否有人，这是一个经典的图像检测问题(或分类问题，1 代表是，0 代表否)，我可以使用 keras 进行快速建模来测试这个想法，你可以简单地微调 VGG\ inceptionV3\resnet 模型来获得一个不错的结果，然后你可以尝试不同的方法来获得更好的结果。

fast.ai 课程还教会了我们在文本分类问题中使用 CNN，这样我就可以用 CNN 来解决我的第二个任务——邮件分类。我不得不说 fast.ai 在我的新工作中帮了我很多，这是一个很好的“深度学习在行动”课程，如果你感兴趣，你可以查看 fast.ai 网站。

我作为数据科学妈妈的经历——数据让我感动

原文：https://towardsdatascience.com/my-experience-as-a-mom-in-data-science-data-moves-me-6987dcf5e150?source=collection_archive---------9-----------------------

我最近在霍特国际商学院(Hult International Business School)的首届科技大会(Boston)的一个小组中发言，有人问我作为一名女性在数据科学领域的经历。的确，如果每次有人说:

你获得了数学和统计学的学位？奇怪，女人通常不擅长数学。”

我有足够的钱去买至少几杯咖啡，但是我跑题了。关于我作为一名女性的个人经历，我有很多话要说，但我想把这篇文章的重点放在作为数据科学领域的家长的积极方面。

总的来说，我认为我很幸运处于我的位置，我们正朝着正确的方向前进，让父母更容易平衡工作与生活，尽管速度很慢。

有时候，我确实觉得自己已经“拥有了一切”，而另一些时候，我很确定自己只是勉强支撑着。当然，这是我的经验，对每个人来说都不一样。但这里有一些作为父母在数据科学方面积极体验的亮点。

工作弹性:

我有一定的灵活性，可以提前离开去参加(比如)我女儿的舞蹈表演彩排，或者如果我需要换油或跑腿，可以延长午餐时间。如果需要的话，我可以在家工作(因为我的儿子已经感染了这个季节的第一百万次耳部感染)，这不会给我带来压力。我并不担心人们对我的看法会因为我在某一天在家工作而减少。

在我职业生涯的这一点上，我对一个项目需要多长时间有一个相当好的想法，并且我可以清楚地设定期望。我知道我需要多少时间来自信地满足最后期限，或者我可能需要多少时间来研究方法，我对此很坦率。还有，我不是医生，所以没有人的生命危在旦夕。我不在一个像财务部一样在月末或某个季节忙得不可开交的部门。这一切都保持压力相对较低。

带薪产假:

当我怀上我的第一个孩子时，我加入了一群 facebook 群，这些群中的女性也在同一时间怀孕，所以我们可以谈论怀孕的一切。当我意识到有多少妇女没有带薪产假时，我震惊了。大多数休产假的女性都不在美国，在这些群体中，只有少数来自美国的女性休产假时有工资。

如果出现一些并发症，导致女性提前失业，她们会担心自己的工作，因为 FMLA 只为你提供 12 周的服务(无薪)。我知道，根据公司的政策，我将获得 10 周假期，如果我想在假期结束时增加休假时间，我的老板绝对不会质疑。

我也不担心因为怀孕/分娩相关的原因丢掉工作。部分原因也是因为目前对分析和数据科学的需求如此之高。如果我丢了工作，我可以再找一份工作。

吸引顶尖人才的大型科技公司正在提供产假(这是今年早些时候写的一篇文章的链接: link )，这鼓励了其他想要争夺人才的公司也提供某种形式的产假。很明显，小公司不太可能(也不太有能力)提供假期，这取决于公司/行业的具体情况。我很幸运，有两次带薪产假(我只有两个孩子)，我在这个领域的工作部分归功于这个*。*

兼职:

有了第一个孩子后，有一段时间我选择把作息时间减少到每周 4 天，老板(和公司)都很支持。当我一周工作 4 天的时候，我甚至得到了提升。当然，我争取了晋升，但我没有被忽视，因为我是一个兼职工作的新妈妈。我再次将部分归因于为一家非常进步的公司工作，该公司正试图与一些顶级科技公司争夺人才，而市场对具有这种技能的人的总体需求正是如此。我也完全理解其他工作/领域可能会提供同样的经历。

总结:

我一直在学习，并被鼓励继续学习。这对我的灵魂有好处。让这一切成为可能的一个重要因素是，我在面试中提出的问题会让我深入了解公司文化，我真的在寻找适合我的父母。我希望你和我一样热爱你的工作。做父母和全职工作对任何职业来说都是挑战，但我发现这种灵活性为我自己和我的家庭带来了巨大的平衡。如果你是一个女人，而且你数学很棒，不要让任何人告诉你不是这样。

如果你想订阅我未来的文章，你可以在这里订阅。

原载于 2018 年 7 月 3 日 datamovesme.com。

我参加 Kaggle 数据科学碗 2017(肺癌检测)的经历

原文：https://towardsdatascience.com/my-experience-participating-in-kaggle-data-science-bowl-2017-lung-cancer-detection-4705032052ec?source=collection_archive---------4-----------------------

3D reconstruction in all three axes

简介

我参加了 Kaggle 一年一度的数据科学碗(DSB) 2017 ，很想和大家分享我激动人心的经历。首先，我想强调一下我对这场比赛的技术方法。这是我们面临的问题:我们必须从高风险患者的低剂量 ct 扫描中检测肺癌。本质上，我们需要预测患者在接受扫描后的一年内是否会被诊断为肺癌。

我认为竞争尤其具有挑战性，因为与一个患者(单个训练样本)相关的数据量非常大。因此，这使得很难将 3D CT 扫描数据输入到任何深度学习算法中。由于最近的流行，我真的想应用最新的深度学习技术。然而，我很快意识到，我们只是没有足够的数据来从头训练大型深度学习模型。所以，唯一能让我训练深度学习模型的方法就是把这个问题进一步分解成更小的子问题。

肺分割

所以首先要做的是。我想用传统的图像处理算法从 CT 扫描中剔除肺部。使用阈值和聚类，我想检测肺部的 3D 结节。发现肺部的恶性结节是至关重要的，因为这是放射科医生为患者检测肺癌的主要指标。按照这些 Kaggle 内核中的代码(圭多·祖德霍夫和阿纳夫·贾恩)，我很快就能够预处理并从 CT 扫描中分割出肺部。看看下面的图片。

Segmented lung and its internal structure

在进一步分析数据后，我意识到使用简单的阈值来检测结节并将其用于特征提取是不够的。在我们从这些候选结节中提取特征之前，我需要一种方法来减少假阳性。

使用 LUNA 数据的结节检测

这个竞赛允许我们使用外部数据，只要这些数据是免费提供给公众的。因此，我决定探索在 Kaggle 论坛上提到的LUngNodeAanalysis(LUNA)Grand Challenge数据集。该数据集提供了由多名放射科医师注释的 CT 扫描中的结节位置。了解结节的位置使我能够建立一个可以检测图像中结节的模型。为了简单起见，我决定建立一个 2D 卷积神经网络(CNN)来预测图像是否包含结节。我遵循了与这里的Sweta subra manian记录的完全相同的方法。

CNN architecture of the nodule detector

该 CNN 模型的输入是 64×64 灰度图像，它生成包含结节的图像的概率。使用这个 CNN 模型，我能够在 LUNA 验证数据集上实现 85.38%的精确度和 78.72%的召回率。以下是一些从 LUNA CT 扫描数据中截取的样本图像。

True Positive (Top) and False Positive (Bottom) sample images of the LUNA validation set

最终 XGBoost 模型

我从初始分割方法中生成的每个候选结节，我能够从其中心裁剪出一个 2D 补丁。

通过将训练好的 CNN 模型应用于这个 2D 斑块，我能够排除没有产生高概率的候选结节。所有剩余的结节用于生成特征。最终的功能集包括:

结节面积、直径、像素密度和结节数量
来自已训练 CNN 模型的最后全连接层的聚集特征
预训练 ResNet 模型的最后一个全连接层的聚合特征(此处描述的迁移学习方法)
与 CT 扫描相关的简单特征(即分辨率、切片数量、切片厚度)

利用这些特性，我能够建立一个 XGBoost 模型，预测患者被诊断为肺癌的概率。使用我的最佳模型，我在 stage2 私人排行榜上获得了 0.59715 的对数亏损分数。作为参考，我想强调的是，获胜团队的对数损失分数为 0.39975(分数越低越好)。

结束语

有几个方法我真的很想尝试，但是由于时间限制，没有时间去实现。具体来说，在使用 2D CNN 看到有希望的结果后，训练 3D CNN 来检测结节将是我的下一个方法。看起来许多获奖的解决方案成功地利用 3D CNN 利用 LUNA 数据检测结节。我对结果很满意，因为我能投入比赛的时间有限。总的来说，我试图尽可能地利用现有的工作，以便我可以专注于挖掘更高层次的功能。这是一种在短时间内学习最新机器学习技术和工具的极好方式。源代码和 python 笔记请参考获取我的 GitHub 页面。

Udacity 人工智能工程师纳米学位概述，术语 1

原文：https://towardsdatascience.com/my-experience-with-udacity-artificial-intelligence-engineer-nanodegree-term-1-928cbea4894e?source=collection_archive---------1-----------------------

完完 Udacity 深度学习基础我感觉深度学习入门很好，但是要理解事物，必须深入挖掘。除此之外，我还获得了自动驾驶汽车工程师、人工智能或机器人纳米学位项目的保送。

退后…

在我转到 Udacity 高级课程之前，我想在开头提到一件事。如果可以给自己提建议，我会选择另一门关于深度学习的入门课程——吴恩达的深度学习专业化。首先，他的指导方式是独特的，他能以最清晰易懂的方式解释复杂的事情。第二——它比 Udactiy 便宜，而且我有一个印象，你花同样的钱可以得到更多。

另一个非常好的选择是杰瑞米·霍华德的《程序员实用深度学习》。这是免费的，它涵盖了与 Udacity 深度学习基金会相同的方面。

…让我们继续

我决定留在 Udacity 学习平台，学习它的一门高级课程。对我来说，最有趣的课程是人工智能和自动驾驶汽车工程师。

自动驾驶汽车工程师

我发现了很多关于这个项目的好博客和帖子。我最喜欢的是来自 Mithi 的——查看这个帖子，它真的很棒。

我的印象是这门课程非常有趣，要求也很高，但在完成这门课程后，我在德国找不到一份“自动驾驶汽车工程师”的工作。是的，有宝马、戴姆勒、大众和奥迪，但是，据我所知，它们要么需要强大的工作经验，要么更喜欢“真正”大学的应届毕业生。他们不承认在线课程——它们(还)没有建立。

其他想法——从我的工作经验来看，我知道一个软件在模拟器和真实的硬件上可以有不同的表现。对我来说，开发一个汽车软件而不进行广泛的测试是有问题的。

人工智能

令人惊讶的是，我发现关于人工智能程序的评论很少，这让我有点害怕。从另一方面来说，内容对我来说非常有前途——我不仅想学习现代神经网络和深度学习技术以及它们的工具，还想学习基础知识。最终，人工智能不仅仅是一种深度学习，它更古老，并能提供真正好的结果，而不像神经网络那样需要那么多数据。所以我决定报名参加这个课程。

人工智能工程程序、结构

Udacity 人工智能工程师 Nanodegree 由 2 个学期组成，每个学期需要 3 个月才能完成。它不是自定进度的，你有完成项目的最后期限。这并不适合每个人，但对我来说，这是一个学习和保持动力的完美方式。

你可以只选第一项，跳过第二项，但不能反过来。只有在成功完成第一学期后，您才能注册第二学期。只有学完两个学期，你才能拿到证书。每个学期 800 美金，绝对不便宜。

你有一个专门的导师，在你遇到困难时为你提供支持，或者在你迷路时给你指明方向。社区真的很棒！无论是在 Slack 还是论坛上，你澄清任何你需要的东西，你永远不会卡住:-)

作为一名纳米学位学生，你还可以访问 Udactiy 职业门户网站，在那里你可以获得有价值的信息、资源链接、建议以及检查你的在线简介和简历。

术语 1，人工智能的基础

第一学期称为“人工智能的基础”，教你在深度学习和神经网络普及之前就已经知道的基础知识和技术。不包括常用材料(设置、介绍等。)，它由 3 个部分组成，每个部分的结尾都有一个期末专题。每个部分依次由 4 到 5 个主题组成。

视频讲座结构和导师

视频讲座的结构与 Udacity 一样，每个主题都有许多简短的视频，其中有解释，中间有小测验，最后有支持资源的链接。有些主题在结尾也有可选的迷你项目。我强烈建议完成它们，尽管这需要时间。

大多数课程都是由佐治亚理工学院的萨德·斯塔纳和谷歌的彼得·诺维格教授的。他们很擅长解释，但不如吴恩达——这是我的个人观点。

第一节。游戏代理

在第一部分中，您将学习到一些算法和技术，如 Minimax 、迭代深化、 Alpha-Beta 剪枝来玩游戏，以及构建 2 个 AI 智能体来解决数独和玩隔离棋盘游戏。

我发现这些材料解释得不好，而且没有支持资源，很难理解。

第二节。搜索和规划

在第二节，首先，你学习不同的搜索算法，如深度优先搜索，广度优先搜索，A 星搜索。接下来的主题是空间探索和避免局部最优，接着是约束传播和逻辑推理。最后一个主题是用以前学过的材料解决一个规划问题。在最后一个项目中，您将创建一个计划员，将货物从始发地机场运送到目的地机场。

在这一部分，解释得相当好，我主要使用了辅助材料来根据需要进行更深入的挖掘。

第三节。概率逻辑

最后一部分是关于概率，贝叶斯网络和隐马尔可夫模型。在我看来，这是三个部分中最有趣的部分。隐马尔可夫模型是萨德·斯塔纳的专长，这反映在解释质量上——它是完美的。我非常喜欢做最后一个项目，手势识别。这一部分对我来说，是作为一个弱势游戏玩家的补偿。

辅助材料

视频讲座基于“人工智能:现代方法”一书，但你不会看到这么多公式，而是导师给你一个直觉，事情是如何工作的。无论如何，我强烈推荐购买或下载它——它很有帮助。

时间消耗

我每周花 10 到 15 个小时浏览视频资料、阅读辅助材料、解决问题和做项目。在我开始第一学期之前，我害怕每周花 20 个小时在材料上，幸运的是时间消耗是可以接受的。

印象

通过讲座，我有一种良好的感觉，我真的在研究人工智能的基础。材料结构良好，总体质量良好。我确实了解了我最初想要的。

第一学期是学习神经网络的良好准备，神经网络是第二学期的主题，我对下一学期相当乐观。

这些知识会有助于在机器学习领域开始职业生涯吗——我不确定。项目很有趣，要求也很高，但这还不够。你需要用学到的技术和算法来解决现实世界的问题，或者你可以开始在你目前的工作中应用它们:-)

第一学期要花 800 美元，这可不便宜。我仍然不确定，这是否值得。这是真的，你获得了实践经验和良好的感觉，基本算法和技术是如何工作的。但是如果你不把这些知识应用到工作中，那就是浪费金钱。

在我故事的结尾——你可以在我的 GitHub 找到所有完成的项目(从 aind- 开始)。在这里你可以找到更多关于人工智能的资源。

更新 16。2018 年 2 月

我已经完成了人工智能纳米学位的第二学期，并在这里总结了我的经验。如果你感兴趣，请看看。

我在 Udacity 深度学习基金会的经历

原文：https://towardsdatascience.com/my-experience-with-udacity-deep-learning-foundations-nanodegree-a42a010f7b58?source=collection_archive---------1-----------------------

我最近从 Udacity 深度学习基金会纳米学位毕业，想分享一下我在这个项目中的经历。

动机

经过 20 年在不同领域的纯软件开发，从图像处理到网络应用，在不同规模的公司，从初创企业(其中一家是我共同创立的)到传统的德国企业，我寻找一些新的东西。近年来，我们看到机器学习，特别是人工智能及其实际应用取得了巨大进展。有许多迷人的产品和研究应用了这些技术。因为我不知道它是如何工作的，但我想知道，我决定开始一次进入这个仙境的旅程。

通往 Udacity 的路

我是一个务实的人，对我来说，学习一些东西而不把它应用到实际问题中是很困难的。我在 Coursera 上了数据科学课程，但是对我来说太学术性了。

接下来我参加了著名的机器学习课程，由吴恩达教授。这是进入机器学习世界的一个极好的切入点，我强烈推荐给每个想研究这个领域的人。吴恩达给了我另一个重要的想法——我开始认为机器学习不仅是一个研究领域，也是解决现实世界问题的工具包。

我听说 Udacity 开设了以实践为导向的课程，决定试一试。基本上我想报读 Udacity 人工智能课程，但我觉得自己没有做好充分的准备。幸运的是 Udacity 开设了深度学习基金会，并宣传它是人工智能课程的准备步骤，所以我在 2017 年 1 月申请了(第一批)。

工具作业

作为一名学生，你主要使用 Python 、 NumPy 和 TensorFlow 。我强烈推荐安装Anaconda——它让生活变得容易多了。不要担心——uda city 向您很好地介绍了工具和开发环境。

对我来说，作为一名专业开发人员，很容易就能掌握这些库，我以前没有工作过。

五金器具

我主要在我用了 6 年的笔记本电脑上工作，联想 Thinkpad T510 安装了 Ubuntu。它有英特尔 i5 处理器，8 GB 内存，没有可训练的 GPU。开发模型和修复 bug 已经足够了，但是对于培训来说，它真的很慢。Udacity 为 AWS 提供 100 美元信用，并指导如何设置。我使用 GPU 驱动的 EC2 实例，并在那里训练我的模型。最近，Udacity 正在与 FloydHub 紧密合作，你可以选择使用它来代替 AWS。

课程内容

深度学习基础是关于神经网络，它们的背景和概念。作为一名学生，你只使用 NumPy 从头开始实现简单的神经网络，然后前进到(更)复杂的架构，并使用更智能的库，如 TensorFlow。本课程基本上由 4 个主要部分组成:

神经网络介绍，在那里你被教导，什么是神经网络(输入，输出，隐藏层，权重等。)，前向和反向传播等基本概念，以及如何构建神经网络。
卷积神经网络(CNN)。在这里你会有一个想法，是什么让 CNN 如此特别，他们能够解决什么样的问题(图像分类，图像识别)。
递归神经网络(RNNs)和长短期记忆(LSTM)。在这里，您会对 rnn 和 LSTMs 的不同架构有一个印象，并知道可以用它们解决哪些问题(文本生成、语言翻译、自动编码器)。
生成对抗网络。甘是相当新的，但他们产生非常令人印象深刻的结果，从字面上看，噪音产生合理的东西。

每个部分都有自己的程序，所以不要期望很深，而是一个广泛的能力概述。然后确定一个最感兴趣的话题(对我来说是 CNN ),并开始研究关于它的更多细节。

学生是如何被教育的

与大多数 Udacity 课程不同，深度学习基础不是自定进度的。你有完成工作的最后期限。课程材料每周分份发布——每周 1 到 2 节课，外加来自 Siraj Raval 的视频短片，此外，你还可以参加他每周的直播课程。Siraj 的内容是免费的，你可以在 YouTube 上查看。

这种教学方式正适合我——我有点懒，需要一些鞭策；-)来自 Siraj 的内容我一点也不喜欢，最后，我放弃了观看他的视频。我知道，有很多人喜欢他的课，但就我个人而言，我做不到。

结构化课程是一种方法，你可以得到某个主题的解释，然后自己解决问题。如果你被卡住了，讲师会提供他自己的解决方案，并解释它是如何工作的。在 GitHub 有练习和解答的源码。

这些课的质量不同。Andrew Trask、Vincent Vanhoucke 和 Ian Goodfellow 提供了最好的课程。主要教练马特·伦纳德已经尽力了，我真的很感激。

作为第一批学生，我运气不好，因为课程材料不成熟，而 Udacity 自那以后取得了很大的进步。我想作为后一批学生，你会享受到更好的质量:-)

附加材料

在每一课中，Udacity 都提供了大量的链接，如果你想深入了解，可以阅读和观看更多的材料。我发现这些链接很有帮助，我读了很多，看了很多，因为我想知道这些东西在引擎盖下是如何工作的。

坦白地说，我期望得到更详细的解释。但是仔细想想——比如说，一个讲师不可能比安德烈·卡帕西更好地解释 CNN。因此，为什么不给出一个粗略的想法，让人们阅读和观看专家提供的额外材料呢？

项目

我总共实施了 5 个项目:

预测每日自行车租赁客流量的简单神经网络
使用 CNN 在 CIFAR-10 数据集上进行图像分类
使用 LSTM 的语言翻译
使用 LSTM 生成电视脚本
使用 GAN 的人脸生成

这些项目要求很高。作为一名学生，你得到一个准备好的 Python 笔记本和必要的助手函数，并且应该实现神经网络的核心部分。所以你不需要从头开始实现所有的东西，你可以从课程中的练习中吸取很多东西。项目一经提交就得到审查。通常在 1-2 小时后，我会从一个评论者那里得到非常有价值的个人反馈。

唯一令人失望的是第二个项目——在教学大纲中，Udacity 宣传“图像识别”,但随后将其改为更简单的“图像分类”:-(

你可以在 GitHub 查看我的解决方案。

社区

除了论坛，Udacity 还设立了一个 slack 频道，在这里你可以寻求帮助，分享你的成功，给出反馈，报告问题等等。我真的很欣赏和重视这种做法。这个社区真的很棒，你永远不会被问题困住。

Udacity 员工积极参与，他们非常重视您的反馈。这就是材料质量显著提高的原因之一。

需求时间

我花了 4 个月的时间，每周 8-12 个小时完成并毕业。我可以跳过额外的材料，每周花 5-6 个小时。我强烈建议投入时间，多读书，深入研究，并尝试自己创建模型——看到自己的工作如何产生合理的结果，感觉真好！

费用

这门课要 400 美元，这可不便宜。它是否物有所值？对我来说，答案肯定是“是”。我喜欢这门课程，在过去的 4 个月里，我学到了很多东西。此外，如果我为 AWS 计算 100 美元信用，为提交人工智能、自动驾驶汽车或机器人纳米学位项目计算 100 美元信用，那么它的成本不到 400 美元:-)，所以这笔钱是很好的投资。

后续步骤

我认为深度学习基础是更高要求的人工智能工程师纳米学位课程的准备步骤。我实现了我的目标。现在我休息一下，很有可能，会申请那门课。最后，我想从纯软件开发转向成为一名机器学习/人工智能工程师，并希望 Udacity Nanodegree 项目能帮助我。

结论

过去的 4 个月非常有趣也很有压力(我有一份全职工作和一个家庭)，我享受了很多学习材料、练习、项目和社区，并且肯定会再做一次。

我热情地向初学者和经验不多的人推荐这个基础课程，他们想了解你可以用神经网络解决什么问题，以及如何实际创建解决方案。另一方面，有经验的人可能会觉得这个项目无聊或者要求不够高。

在申请之前，你不仅要准备好阅读/观看课程材料和做练习。相反，如果你想从学习中获得最大的收获，你应该计划时间进行额外的阅读并亲自尝试。

我要感谢 Udacity 团队，让我在深度学习基础项目上有了一次美好的经历。

我在意大利罗马 Pi 学校做人工智能学者的经历

原文：https://towardsdatascience.com/my-experiences-as-an-ai-scholar-at-pi-school-in-rome-italy-1f0641ce6538?source=collection_archive---------2-----------------------

Altare della Patria (Image courtesy: Pixabay.com)

我将从这篇文章的概述开始。在这篇文章中，我将回顾我在意大利罗马 Pi 学校参加为期 8 周的人工智能学习项目时的学习经历和愉快时刻。

这是一个关于激情和努力的故事:)

在 2018 年的黎明，我对自己说，我将超级认真地对待全栈软件工程和数据科学。在数据科学中，我特别选择机器学习和深度学习，因为我已经在这些领域研究了一段时间。你可能会疑惑是什么让我选择了两条路。一个主要原因是，到目前为止，我作为全栈软件工程师和研究工程师在这个行业只有两年多的时间，这意味着我的职业生涯还有很长的路要走。所以在研究和产业之间取得平衡是好的。是啊，这是一个个人偏见的意见，我似乎同意:)

现在我的日常编程语言是 Node.js 和 Python(感谢我毕业后马上工作的公司)。我伸出手指，开始用 Node.js 和 Python 做宠物项目，我在 Coursera 上完成了吴恩达的机器学习课程，我开始学习杰瑞米·霍华德和瑞秋·托马斯的 fast.ai，我开始向卡格勒学习(我复制了相同的代码，并向同行学习:)。有几天，我早上 4 点就去睡觉，第二天早上 8:30 醒来，然后去上班。我不觉得累，因为我对我正在做的事情充满热情(我现在仍然在做，以一种优化的方式；) ).

一个晴朗的夜晚，在工作的时候，我看到了一封来自 Kaggle 的电子邮件，是关于这个迷人的奖学金项目的。这是一个关于在强大的罗马进行的为期 8 周的人工智能研究项目。我的第一反应是，“哇，这太酷了！！!"。首先，这是一个奖学金，你可以免费学习人工智能。第二，它发生在罗马古城:D。我马上查看了链接，并开始阅读网页"皮学校人工智能计划"[1]。

仔细阅读本页后，我对这个项目有一个正面的印象。在我在这一页发现的几个事实中，很少有东西真正引起我的兴趣。

这是一个全额资助的项目，包括你的全部课程费用
涵盖 8 周期间的生活费用(包括旅行、住宿、食物和基本需求)
项目负责人简介Sebastian bratièRES【2】
——我注意到这个项目的负责人拥有著名的剑桥大学的博士学位，他在人工智能方面有 15 年以上的经验。
与行业和大学的合作
—思科、亚马逊、谷歌、卡内基梅隆大学、苏塞克斯大学++
我满足:D 的所有最低要求(以及一些优先要求)

我总是寻找新的机会。我总是想扩大我的关系网，我想边做边学。我向同龄人学习，这是一个绝佳的机会。

申请奖学金

在这一点上，我很确定我会申请这个项目。我在网页上填了申请奖学金的表格。然后，项目经理联系了我，向我询问了我的简历和求职信，以推进选拔过程。

我在同一天收到了确认我的申请的回复。我必须回答的一个特别的问题是，“我是否能在这 8 周内都有空”。作为一名全职员工，这是具有挑战性的。然而，我说服自己，如果我有这个机会，我会参加。

面试准备

下一步是准备。申请并不意味着被选中参加最初的面试，但我满怀希望:)坦率地说，尽管我对这个项目有着积极的印象，但我还想了解更多。我看过很多关于新兵训练营的文章/广告，参与者必须付费的研讨会。但这完全不同。这引起了我的好奇心，想多了解一下 Pi 派。

在搜索的时候，我在 Pi School 脸书页面【3】上发现了一个相当有趣的视频。从这个视频中，我了解了很多关于 Pi 学校的愿景和创始人(如果你打算申请这个项目，这是一个明确的观看；)).

在圆周率派的创始人之一马可·特龙贝蒂的几个有趣的陈述中，有一个陈述真正引起了我的注意。这是我爱上的说法之一。*** 重要 ***

“你一生中最重要的会议、你的结婚对象、你的商业伙伴通常都发生在学校里。如果我们需要一所学校来创建世界上最大的有创造力的优秀公司，我们就要建一所”

这就是为什么我们仍然想回到我们的学生时代和大学生活的记忆里的确切原因。我们在学校和大学都有很好的人际网络。我们在学校/大学期间遇到的人在我们的生活中发挥了重要作用。他们以积极的方式塑造了我们。

我继续看完整的视频(花了大约 100 分钟，完全值得)。看完这个视频，我已经成为了 Pi 派的一员。我非常想被选中参加这个项目，我知道现在是我复习线性代数、统计和概率知识的时候了(这些领域在最低要求中有提及)。

几天后，我收到了项目经理的邮件，说我已经进入了第一轮面试的候选名单。我感到很高兴，我想确保我有充分的准备来面对这次面试。项目经理特别要求找到一个合适的地方进行有效的对话(即一个有合适的亮度、稳定的互联网连接且没有噪音的地方)

在面试那天，我确保在面试时间前 10 分钟让自己有时间。我设法为我的采访找到了一个合适的环境。我发邮件给我的面试官说我已经准备好了，在 3-5 分钟内我收到了继续面试的确认。

面试期间

我的第一次采访是与 Pi School 的人工智能和机器人顾问(他参加了 Pi School AI 2017 计划)，他目前正在机器人领域攻读硕士学位。问我的第一个问题是，我是否能让自己整整 8 周都有空，我将如何做到这一点。我已经下定决心参加整个 8 周，所以我说服了我的面试官，从我的角度来说，这在技术上是可能的。这次面试检查了我对线性代数、概率和统计以及机器学习概念的整体理解。我被要求解释我的背景，我做过的项目等。我特别强调了我一直在做的 ML 项目。有人问我，我是如何保持自己与 ML 同步的。我大致解释了自 2018 年黎明以来我一直在做的事情。在面试过程中，你可能会面临的一个非常重要的问题是，“为什么你想成为其中的一员？”。我已经为这个问题做好了准备；).我说我渴望成为数据科学专业的人才(我想这在这类面试中很常见:P)。然后我说，我看了脸书大学开学典礼的视频，也看了上一期人工智能项目的视频。我特别强调了 Marco 的这句话，这显然是我成为这个项目一部分的原因。“我一直在寻找机会，而 Pi 学校似乎是一项有利可图的投资”。我向我的面试官传达了这个信息。我可以说这次面试有 80%-85%是成功的。有些问题我本可以回答得更好。反正我是满怀希望的:)

大约 5-7 天之后(如果我没记错的话)，我收到了项目经理的另一封电子邮件，称我已被列入 Pi School 人工智能项目的项目总监 Sebastian Bratières 的第二轮面试候选名单。第二天我参加了面试。在准备第二轮的时候，我解决了第一轮面试时卡住的问题。我坚信这是任何面试准备中非常重要的一步。我觉得面试会像第一次面试一样，我们可能会深入线性代数，概率和统计以及机器学习的概念。

我设法找到了一个类似的会议环境，做了和会议前第一次面试差不多的事情。我让自己准时出现。正如我所想的那样，我提出的问题基于线性代数、统计/概率和机器学习概念。在面试中，我被要求写一些公式，还有一点编码。有一个问题会导致偏差/方差以及过拟合和欠拟合，这个问题基于一个真实的 ML 项目。在第一次面试时，我被问了一些贝叶斯定理和贝叶斯网络的问题，我觉得我在第一次面试中会回答得更好。这些是我在准备复试时特别关注的问题。你猜怎么着，它成功了！:D。这就是为什么在最初的面试步骤中练习那些你不能回答的问题是非常重要的。这次采访也很顺利。我再次充满希望:)

大约 3-5 天后，我收到了那封我从一开始就一直在等待的邮件。这是一封来自项目经理的电子邮件，确认我被 Pi 学校人工智能项目选中。我非常兴奋和高兴，因为到目前为止，这是我在 2018 年赚到的最大一笔钱。我签署了最初的合同，并确认我参加这个可怕的计划:D

申请签证

一旦你被选中，下一步就是准备搬迁到罗马 8 周。这个过程取决于你的国籍。也许你不想签证进入意大利。就我而言，我需要签证。大多数时候，这是基于你的国籍。

我想对我的签证过程中给予我巨大支持的项目经理表示诚挚的感谢。我知道这个过程背后有很多 Pi 学校的人。我直接与项目经理联系，他给了我尽可能好的支持来帮助我办理签证(特别是给大使馆的官员写信和在早上 5 点接听电话)。如果你被选中并需要去罗马的签证，请随时写信给 Pi 学校的项目经理，他/她会全程陪伴你。

Pi 学校 8 周

Group picture of the School of AI 18 (courtesy: Pi School media)

我可以在 8 周内写很多东西。我精心挑选了几个，这样你就能知道 Pi 学校在这 8 周里做了什么，参与者做了什么。

Pi School 从一开始就确保向所有参与者提供所有必要的材料。在正式毕业典礼之前(即。6 月 11 日)，组织者共享了一个包含学习材料、管理材料和其他相关文档的 Google Drive 文件夹，授予了对 GitHub 存储库的访问权限，为所有参与者创建了 AWS 实例，创建了一个专用的 Slack 实例来促进交流和开放交流，并在“Basecamp”上创建了一个项目管理实例。

在正式开学的前一天，举行了一个隆重的欢迎会，那是一个平静的星期天。来自世界各地的 26 名与会者，即斯里兰卡、意大利、巴西、法国、德国、伊朗、哥伦比亚、希腊、冰岛和哈萨克斯坦。我总是很好奇，想了解更多不同的文化，这种氛围让我很兴奋。

该计划于 2018 年 6 月 11 日正式开始。所有参与者都有所需的基础设施、桌子、椅子、大屏幕、AWS 实例和 GitHub 访问。Pi School 创建了 13 个组，每组有 2 名参与者。每个小组都被分配到一个项目中，这个项目得到了工业界优雅的赞助者的资助。有几个行业合作伙伴。我想强调几个，这样你就可以对 Pi 校园与技术行业的合作有一个总体的了解。几个合伙人分别是思科、亚马逊、索尔多、意大利邮政、 Xriba 和翻译。

我非常荣幸有核心深度学习实践者作为我的工作伙伴。他来自巴西，在巴西一家顶级石油公司工作。他知道深度学习概念的来龙去脉。作为一名人工智能新手，我的工作伙伴是金矿:D。所有参与者都有一项独特的技能，使他们与众不同。这种独特性给了每个团队一个很好的平衡。惊喜不止于此。后来我和我的合伙人知道我们被分配到思科系统公司赞助的项目。我付出了全部的灵魂和努力来获得这笔奖学金，每天我都得到巨大的惊喜:D。这就是为什么我总是相信努力和态度:D 😛。态度和努力战胜一切。相信我，:D

从第一天开始，参与者就知道他/她的同伴、项目和预期的交付成果，团队配备了基础设施和讲座指导。

我玩 AI，ML 已经有一段时间了。Pi 学校给我布置的项目和我一直在做的宠物项目完全不一样。大多数时候，我们从 MOOCs、书籍和论文中学习的项目，我们可以找到一个标记良好的数据集(可能是 CSV 或任何其他非常方便的格式)。与这些类型的项目相反，我们都参与的项目有一个显著的独特性。参与者有责任确定/生成他们需要的数据集。所以对于大多数项目(可能是所有项目)，没有 CSV 或类似的东西。

我喜欢列出几个项目。

设计和开发深度学习工作流来分析加密网络流量(Cisco)——这是我和我的合作伙伴做的项目。帖子的更多信息:)
ICD 分类(Noovle) —协助卫生当局按代码付费(医疗编码行业)
根据用户数据打开电子邮件(回报)—根据用户配置文件预测电子邮件收件人是否可能会打开电子邮件
呼叫中心活动 KPI 的异常检测(Covisian)
关注无预约顾客(意大利邮报)——预测无预约顾客的年龄和性别

为了保证每个项目的顺利进行，每个人都必须完成一些管理任务。

维护项目日志——这是一个谷歌文档，团队维护它来报告他们的日常活动，特别是他们做了什么，结果，挑战和克服挑战的步骤。当准备与项目发起人和导师的周会时，这些日志文件变得非常方便。
与利益相关者/导师的周会——根据可用性，安排与利益相关者和导师的会议。在我们的项目中，我们每周与项目发起人 Cisco:)举行会议。在这些会议期间，团队提供了关于他们的项目、他们所面临的挑战以及他们为克服挑战所采取的措施的最新情况。利益相关者和导师通常会提供积极的反馈，并在必要时提出建设性的改变。这些会议非常有助于发展每个公司在人工智能领域的技术目标的亲和力。此外，这是一个亲自了解利益相关者和导师的好机会，因为他们将在参与者生活中的某个时刻发挥巨大作用，可能是作为推荐人、导师或未来的潜在雇主。这些会议持续约 1 小时左右，取决于导师/利益相关者的可用性。Pi School 与每位与会者分享了一份指南清单，其中包含准备这些会议时要遵循的步骤/流程。例如，当展示每周的进展时，分享代码(伪代码)、绘图、图表、公式、模型图、学习曲线、特性使用、模型/任务的基线、模型配置等等。作为一名数据科学从业者，我在准备会议时仍然遵循这些指导方针:)此外，为了避免会议期间出现任何技术问题，Pi School 分享了一份清单，这样就不会有任何延迟，也不会比预定时间要求更多的时间。会议结束后，团队在所有利益相关者之间共享会议记录，以便每个人都知道已经做了什么和将要做什么。
“全体会议”——这是每周一次的会议。每周四上午 10 点整，Sébastien Bratières 邀请所有参与者分享他们的每周更新。每个团队有大约 5-7 分钟的时间来分享他们的进展、挑战以及他们采取的缓解挑战的措施。由于这是一次公开会议，每个人都有机会了解其同事的状况。

Pi School AI 学者的一天通常从上午 9 点开始。我们享用了免费早餐，然后马上开始项目，在下午 5:30 或 6 点左右结束一天的工作。

白天，我们将 80%以上的时间投入到项目中。在剩下的时间里，我们与其他队友讨论了项目事宜，讨论了人工智能、人工智能初创公司等方面的最新研究工作/论文。几天来，我们有关于人工智能主题的辅导课，强调了最先进的技术和实践方面。Pi 学校的组织者非常鼓励参与者展示他们感兴趣的领域。我的同事们也参加了与 GPU 计算、使用 Python 的最佳机制、GitHub 实践、AWS 和安全漏洞相关的会议。这些会议非常有助于我们学习新的东西，加深我们对已知事物的理解。

我注意到的关于 Pi 学校工作人员的一个特别的事实是，他们是罗马(也许也是意大利)的 AI/ML 积极分子。在罗马，有两个团体(据我所知)在学生、行业合作伙伴和其他爱好者中创造 AI/ML 的意识。这些小组是“TensorFlow X Rome”和“机器学习/数据科学会议”小组。在项目期间，我们有幸参加了由这两个团体组织的活动。此次活动的特邀演讲者来自 Twitter(加州办公室)和 H2O。这次活动给我的收获是免费啤酒和披萨:P .哈哈哈，我只是开玩笑。来自 Twitter 的演讲者做了一个关于情绪分析的会议，并强调了在某些情况下 AI 可能会表现出种族主义，研究人员热衷于纠正这个问题。来自 H2O 的演讲者介绍了 H2O 平台提供的 ML 生态系统，以及他们未来扩展到 GPU 支持平台的计划。

(Image courtesy: Pixabay.com)

“成为一名企业家”，“用人工智能制造产品”肯定是我们大多数人心中的想法。因此，了解它的最佳方式是直接与他们互动(或听成功的故事)。通常这类成功案例的样本量非常小。只有极少数人有故事可以分享，让你从中学习。在 Pi School，我能够与其他参与者交流，他们目前是自由 AI 开发人员，但对建立自己的初创企业有着巨大的热情。我从他们那里学到了很多。Pi 学校时期帮助大多数参与者向他们的同龄人学习。而且不仅仅是来自同行，有时候也来自受邀的演讲者。在我们逗留期间，我们与 Illia Polosukhin 进行了一次会谈，她是 near.ai 的联合创始人(也是 TensorFlow 的主要贡献者)。Polosukhin 分享了他对成为一名连续创业者的个人看法。是的，他确实谈到了 near.ai，但我发现他让自己的产品变得伟大的热情相当有趣。他分享了他个人对不读博士的偏见，这是我至今仍在思考的问题。还有一场会议(这一次是虚拟会议)，由一位来自奥地利的企业家主持(遗憾的是我不记得他的名字了)。他强调了为什么他在攻读博士学位后从学术职业转向工业。他非常坦率地分享了他在创业初期必须面对的所有障碍。他明确表示，尽管他在技术上多才多艺，但他仍在不断提高自己的人员管理技能，这是任何初创公司的关键因素。这对于任何希望创办自己公司的人来说都非常重要，因为最终我们将与人类和他们的个人价值观打交道。

我相信我们每个人在生活中都会经历一次“做决定”的情绪起伏。我们不知道该走哪条路，不知道如何从多个选项中做出选择。大多数时候，我们的直觉帮助我们做出决定。一天晚上，在我们享用了免费午餐后，Pi School 的首席执行官 Jamshid Alamuti(我们称他为 Jam)进行了一次会议，以提高我们的软技能，特别是在决策领域。尽管如此，我还是会凭直觉行事，因为我知道，通过利用“六顶思考帽”,给这个过程一个更符合逻辑的方法。当然，当我需要衡量自己行为的利弊时，这在我的职业生涯中至关重要，尤其是在“攻读博士学位”的时候。

AI 学校是 Pi 学校开展的众多项目之一。如果你仔细观察他们的项目，你会发现有关于领导力、创意孵化、设计、展示等更多方面的项目。除了 AI 学校项目，在我们逗留期间，Pi 学校也发生了一些事情。在其中一次活动中，有来自以色列的非常成功的投资者。这显然暗示了关于圆周率派领导层的远见卓识。对于这个事件，参与者是在最后一刻被邀请的。但是我们大多数人都高度专注于我们的项目工作。去过那里的几个人说，这是一个很棒的演讲，投资者谈论了他们打算通过人工智能的方式前进的方向。此外，在我们项目的中期，项目的利益相关者来到 Pi 学校，学者们有机会更多地讨论项目，并更好地了解导师和利益相关者。这是一个非常美好的夜晚，有啤酒和食物。(我和那位来自 Noovle 的先生交谈过)。

Networks (Image courtesy: Pixabay.com)

我应该说一点我和我的同伴做的项目(简单地说:)。如你所知，我们都被分配到思科赞助的项目。我们的任务是开发一个“分析加密网络流量的深度学习工作流”，从数据获取的角度，通过可视化来推断深度学习的结果。该项目由思科系统公司的“领导，公司战略人工智能项目”直接监督和指导。该问题被定义为分类问题(分析恶意软件和良性流量)。在搜索公开可用的恶意软件库时，我的同伴提出了一个想法，因为这是一个分类问题，我们可以根据网站的类型进行自己的实验来对网络流量进行分类。我们选择的网站类型有新闻网站(如华尔街日报)、流媒体网站(YouTube)和社交媒体(脸书)。我们使用 Cisco Joy 工具捕获数据(网络流量)，该工具可以捕获和分析网络流量。捕获的数据作为 JSON 对象存储在. gz 文件中。每个 JSON 对象都有许多与网络相关的属性。有些是包输出、字节输出、包输入、字节输入、网络头特定数据(TLS、DNS、HTTP)等等。在我们的工作中，我们利用了网络属性中的手工设计功能，因为以前的工作也严重依赖于特定任务的手工设计功能。网络数据结构是一个复杂的分层嵌套字典列表，编写一个统一的函数来从网络属性中提取特征并不是一种通用的方法。我的朋友想出了一个独特的主意，写一个自定义的递归函数来分析输入数据的结构。在我们的工作中，我们提出了一种使用数据结构来识别和提取有意义特征的自动化方法。网络数据是嵌套字典的复杂层次结构。我们介绍了能够处理这种特定类型数据的神经网络架构(FF、RNN 和 Conv1D ),并提出了能够适应数据结构的模型。另一个非常重要的任务是，模型调整和选择。我们开发的功能允许测试多个模型和调整超参数，只需改变一个 YAML 配置文件。简而言之，这是我们所做工作的概述。(如果时间允许的话，我会在以后就这个项目写一篇单独的文章)

在项目的最后两周，所有的团队都忙于项目工作。我们必须在 Pi 学校作为 AI 学者的最后一天前 4 天左右提交最终报告。也要在期末日期前 2 天提交期末报告。尽管这种安排起初看起来很艰难，但每个团队都相信这是一个好策略，就好像我们都坚持到最后一天提交所有东西，这将是一个巨大的痛苦。每个人都设法按时交付所有项目可交付成果。

最后一周的一个晚上，Sébastien Bratières 邀请我们所有人参加他的最后一次会议。他准备了几个话题与我们讨论，一些话题是关于高等教育、企业家精神、剑桥、准备从事数据科学等。

如果我没记错的话，在期末考试的前一天晚上，我们决定去附近的一家餐馆享用一顿丰盛的晚餐。我的一个朋友深深地陷入了沉思。我问他为什么。他说，他找到了一种方法来优化他的结果，甚至比以前的结果更好，这是在完成最终报告后，他下定决心要做最后一搏。第二天我和他谈话时，他已经完成了:D，不仅是最终模型，而且他用最新的结果修改了最终报告和最终演示文稿。你会在:D Pi 学校遇到这样的人，他们追求卓越。

Pitching session with Marco Trombetti (courtesy: Pi School media)

所有 Pi 学校学者的最后工作是在最后一天向所有将出席最后活动的杰出赞助商展示他们的作品。Marco Trombetti、Jamshid Alamuti 和 Sébastien Bratières 对这项活动非常认真。因此，Marco 为我们所有人安排了一次会议，分享他对“投球艺术”的看法。Marco 分享了他如何向投资者进行令人信服的推介的经验。我们的赞助商是我们的投资者，因为他们投资了我们的项目。Marco 陈述了成功推销时需要遵循的 5 个步骤。

理解问题——你的创业想法应该解决一个普遍的痛点
定义解决方案——清楚地展示您如何解决棘手问题
了解市场 — 总目标市场
表明你的用户群随着时间的推移而增长(牵引力)
团队- 为什么你们是最棒的

团队被给予充分的自由来利用这些要点，提出一个持续约 5 分钟的可靠演示。在最后一天的前一天，所有团队都向 Marco、Jamshid 和 Sebastian 提交了他们准备好的演示文稿。每个人都收到了反馈，每个人都准备好迎接最后的重要时刻:D

最后一天的安排非常平和，有专业的活动氛围。每个人都热切地期待着展示他们的作品。在晚上最后一场活动正式开始之前，我和我的同伴有幸与我们来自思科的赞助商/导师进行了交谈。在正式活动之前，我们已经安排了一个舒适的转换。我们讨论了我们做的项目和总体项目。我们更加了解自己，这是一个很好的机会。想象一下，几周前你还在做普通的编码工作，而现在你正在和思科的高层领导谈话。我和我的同伴为我们的最后陈述排练。在完全陌生的观众面前，我往往会有点紧张，直到我在演讲中获得动力。因此，在最后的推介/演示中，准备工作非常方便。

最后的活动以 Marco、Sebastian 和 Jamshid 的发言开始。然后是我们展示的时候了。13 个团队展示了他们的作品，每个杰出的参与者似乎都被他们的展示深深吸引。一旦每个人都做了，塞巴斯蒂安交给我们的证书。我们享用了食物和饮料，度过了作为人工智能学者的最后一夜。(第二天凌晨 1 点左右，我和我的朋友们决定打破这个夜晚，所以我们去了:D 罗马的一个聚会区)。

我们在 Pi 学校的最后一天，我的朋友告诉“这不是结束，这是我们所有人新的开始… ”。那是完全正确的。在我看来，我建立了一个真正的高质量的网络，见证了古罗马的辉煌，对不同的文化和人民变得更加开放。有很多。我们大多数人仍然拥有从圆周率学校获得的动力。我知道很少有人一起参加高尔夫比赛。我和我的朋友们参与了几个项目。希望我们将来能一起做伟大的事情。

我想以此结束这篇文章。你会觉得我很欣赏，偏向 Pi 派。那是因为我真的是。我在各方面获得的东西是无法用言语表达的。这就是为什么我想表达我衷心的感谢。这是一张免费票。我们生命中最美好的东西永远都是免费的:)。我在罗马过得很愉快。

尽你最大的努力去参加这个项目，我们中的很多人都会成为:D

Closing Event of the 2nd Edition of the School of Artificial Intelligence. (courtesy : Pi School media)

参考资料:
【1】https://picampus-school.com/programme/school-of-ai/
【2】http://mlg.eng.cam.ac.uk/sebastien/
【3】https://www . Facebook . com/picampusrome/videos/1721109364597481/？HC _ ref = arrzucafb 4 w 4 njksowsl 89 fjdvrhgb 9 wdun 8 wulnlkrcxzykit 9 exlggw 7g _ Ckn-Z9A
【4】https://www.crunchbase.com/person/marco-trombetti
【5】https://picampus-school.com/programmes/

我的第一次数据科学面试[更新]

原文：https://towardsdatascience.com/my-first-data-science-interview-bccc006ba2c8?source=collection_archive---------5-----------------------

今天，我将分享我第一次参加数据科学面试的经历，这次面试发生在印度最重要的学院之一，IIT 学院(印度理工学院)。这次面试是为“数据科学硕士”学位和数据科学的先决知识是强制性的。有两个回合，一个是 MCQ 回合，接着是 3 个问题陈述。

第一轮:MCQ

MCQ 是基于一般编程和 DS 技能。这次测试的水平一般，但它是棘手的，因为它有负面的标记。也许这是出于筛选的目的。主题如下:

概率与统计
结石
数据结构和算法
回归和类型
决策树
C/Java 编程

由于这是一轮筛选，我回答了大部分问题，并把注意力集中在下一轮，也就是主轮。

第 2 轮:问题陈述(主观轮)

这是主要的一轮，这一轮被赋予了更多的权重。这一轮的形式是，他们将提供一份问题陈述，我们将针对该问题用不少于 300 字的篇幅写出我们的解决方案。因此，为了不浪费更多的时间，我将快速跳转到问题陈述。注:请完整阅读文章:)

问题陈述 1

你有一个像 StackOverflow 这样的网站，你有超过 50k 个标签。给定一个问题，你将如何找到这个问题的前 5 个相关标签？

利用这些信息，你如何根据问题标签的重要性、意义和详细陈述对问题进行排序？给你一个包含 1000 万个带标签的问题的数据集。

还有你会用哪种机器学习方法，为什么，如果有重复的问题，你必须放弃这个问题。

问题陈述 2

给你一个特定用户的手机日志，其中包含崩溃报告、应用使用时间、应用何时被发送到后台、用户在应用中点击了多少广告等数据。

根据这些信息，定义你能想到的两个产品特性和两个安全特性。

你将如何向消费者和应用公司推销你发现的产品特性？

问题陈述 3(最难)

给你病人的病史。您拥有包含数字数据(血压、血糖、心率、血脂等)的所有测试报告，包含图像+文本报告(医生根据图像得出的结果)的放射报告，以及包含有关患者健康的主观和客观信息的护理报告。患者数据以报告的形式出现，即时间序列数据。根据这些报告，你必须计算 3 样东西:

病人存活的几率有多大，他要在医院呆多少天。你将使用哪种算法，为什么？

b)死亡率是多少，即一个人在接下来的一周内是否会死在重症监护室。你会选择哪种算法，为什么？

c)定义一些问题中遗漏的对你的问题有用的额外特征。如果这是一个人工智能驱动的医生，它将如何向病人的家人传达当前的状况？

加分题

我很喜欢 MCQ 的一个问题是:

给你一个问题，你必须决定偏差和方差的权衡。您使用 决策树 来解决一个特定的问题，但是数据集非常大(以 TB 为单位)。因此，您决定分割数据集，并对每个片段分别应用决策树。当你平均偏差和方差时，与单一决策树的结果相比，肯定会发生什么？

i)增加偏差
ii)减少偏差
iii)增加方差
iv)减少方差

我的背景

我已经在 2014 年完成了计算机科学的学士学位。我在 4 个月内完成了 Udacity 的自动驾驶汽车纳米学位(当时这个学位原本是 9 个月)后，决定申请这个课程。在我申请的时候，我只知道深度学习，并且正在从吴恩达的课程中学习机器学习。我在一家跨国公司全职工作，参与他们最新的自动驾驶汽车项目。

更新 1:答案是这里。

答案和结果

结果:我被选中是因为即使在客观上粗心的时候，我的主观得分也很高。但是当我发现 IIT 的课程时，我决定不加入 IIT，继续我目前正在做的关于自动驾驶汽车的工作。35 人被选中，34 人参加了这个课程，因为很难得到一个有你名字的 IIT 标签，我只是想要知识，所以我跳过了。

答案:我想促进你的思维，即使你不知道答案也不要难过。试着找出答案。我决定下周在另一篇文章中提供答案。在那之前，试着找出答案，尤其是第三个问题。

请在 LinkedIn 上联系我，或者在评论区留下你的电子邮箱。一旦我写了包含答案的帖子，我会给你发一封邮件。

阅读我在 Medium 上的其他文章:

AI for everyone:总结
机器学习:什么、何时和如何？
卡尔曼滤波面试

关于我:我是一名机器学习工程师，专注于使用深度学习为车辆提供智能。

我的第一份数据科学家实习

原文：https://towardsdatascience.com/my-first-data-scientist-internship-7f7aa2ee4040?source=collection_archive---------3-----------------------

在写作的时候，是我在量子发明的数据科学家实习的最后一天的前一天。现在，坐在笔记本电脑屏幕前，回想过去几个月的学习历程，真的很难，但也很充实。

在一天结束的时候，问题在旅程结束后仍然存在——你学到了什么？这是你想要的吗？

原谅我，作为一个物理学家，我相信总是要问正确的问题，通过合理的推理来寻求真理。事实上，作为一名数据科学家，提出正确的问题无疑是重要的(后面会解释……)。

为了给你一个概述，这篇文章主要致力于三个部分——实习前，实习中，实习后给你一个我骑行旅程的概述。根据您目前的学习阶段，可以随意跳到这一部分。让旅程开始吧！

谢谢大家！当我的第一篇文章在 Medium 上收到了来自不同人的巨大支持，甚至被向数据科学推荐和发表时，我的情绪非常激动。

这真的成了我继续与更多人分享我的学习经验的动力，因为，学习如果有趣，帮助别人更好！

实习开始前

我还清楚地记得，我在 2017 年 11 月期末考试卷子的第二天，就开始阅读 R 中的应用的教材——《统计学习导论》。这是我第一次在非常基础和统计的层面上接触机器学习。

一旦我掌握了这些概念，我就开始转向 Coursera 上的一门热门课程——吴恩达教授的 机器学习 。事情并不像一开始看起来那么简单，但吴恩达总是有一种自然的能力来吸引人们的注意力，尽管任何概念都很复杂，但他能像其他人一样简化概念以便消化。我想这就是我真正迷上机器学习的原因。只要试一试，你就会发现这个 流行语 真的没有听起来那么复杂。我敢打赌。

同时，我也在学习人工智能的另一个重点领域——深度学习。为了后知后觉地了解这个看似外来的术语是什么，请看看对神经网络的解释，以及神经网络是如何用于计算 any 函数的。好的，如果在阅读了推荐的文章后，你像我一样总是需要某种可视化来理解事情是如何工作的，那么点击这里。按下“播放”按钮，坐下来，放松，观察神经网络如何用于分类和回归。很酷不是吗？请在下面的评论中告诉我，以便讨论和澄清。

所有的读、做、学，在我 2017 年 12 月开始实习之前，已经让我自己(希望)做好了准备。

实习期间

量子发明通过利用其集成的移动应用套件，专门为消费者、企业和政府提供移动智能。企业物流和分析平台。我是第一个加入研发和分析团队的数据科学家实习生。

在最初的几天内，我被介绍给了令人惊叹的同事，行业内的各种交通术语，以及正在进行的令人兴奋的项目。我实习期间最喜欢的一件事是给予我的信任和自由，让我可以选择自己感兴趣的项目并全力以赴！

令我惊讶的是，我意识到我是这个项目的先驱，因为以前没有人做过。当以前没有人做过一些事情时，研究就出现了，这是我感激的地方，尽管有不确定性和困难。为什么？很简单，因为我有机会从头开始体验真正的数据科学工作流程(如果不是全部的话)。

请允许我简单地列出我所经历的工作流程，因为这些工作流程奠定了我在数据科学领域的基础。我希望你会发现它在某些方面是有用的。😊

1.理解业务问题

选择的项目是关于短期高速公路行程时间预测。然而，就像我说的，问正确的问题对于数据科学家来说非常重要。A 在项目最终确定之前，为了真正了解真正的业务问题，提出了很多问题，比如可用的数据源、项目的最终目标(甚至在我离开之后)等等。本质上，我们的目标是预测新加坡高速公路提前 N 分钟的行驶时间，比当前的基线估计更加准确。

2.收集数据源

对新项目感到兴奋，我开始从数据库和同事那里收集数据源(基本上是在办公室里走来走去，询问关于数据源的问题)。收集正确的数据源类似于您从不同的网站收集数据以便稍后进行数据预处理。这一点非常重要，它可能会影响到您在后期构建的模型的准确性。

3.数据预处理

真实世界的数据是肮脏的。我们不能期待一个像 Kaggle 提供的格式良好且干净的数据。因此，数据预处理(其他人可能称之为数据管理或数据清理)是如此重要，我怎么强调它的重要性都不为过。这是最重要的阶段，因为它可能占据整个工作流程的 40%-70%，仅仅是清理要提供给模型的数据。

垃圾进，垃圾出

我喜欢数据科学的一点是，你必须对自己诚实。当你不知道什么是你不知道的，并且你认为预处理的数据已经足够干净，可以输入到你的模型中时，这就存在着用错误的数据建立正确的模型的风险。换句话说，总是试着用你所拥有的领域知识来质疑数据在技术上是否正确，用严格的阈值来仔细检查数据，以检查整个数据集中的任何其他异常值、缺失或不一致的数据。

在我犯了向模型提供错误数据的错误之后，我对此特别小心，仅仅是因为预处理步骤中的一个简单缺陷。

4.建筑模型

经过一些研究，我提出了四个模型用于我们的项目，它们是支持向量回归(SVR) 、多层感知器(MLP) 、长短期记忆(LSTM) 和状态空间神经网络(SSNN) 。为了简洁起见，你可以在各种网站上找到每个模型的详细解释。

作为一个仍在从 MOOCs 和教科书中学习的人，从零开始构建不同的模型对我来说是一个陡峭的学习曲线。幸运的是， Scikit-learn 和 Keras (带有 Tensorflow 后端)帮助了我，因为它们很容易学习，可以在 Python 中进行快速模型原型化和实现。此外，我还学习了如何使用多种技术优化模型和微调每个模型的超参数。

5.模型评估

为了评估每个模型的性能，我主要使用了一些指标:

【平均绝对误差】
均方误差
决定系数(R2)

在此阶段，重复步骤 3-5(可互换),直到确定了优于基线估计的最佳模型。

实习结束后

嗯，实习肯定重申了我对数据科学的热情，我很感激我的工作确实为未来的工作留下了一些动力。研发阶段，与不同利益相关者交谈所需的沟通技巧，使用数据解决业务问题的好奇心和热情(仅举几例)都促成了我对这一领域的兴趣。

数据科学行业仍然非常年轻，对于像我们这样的求职者来说，它的工作描述可能看起来模糊不清。不具备所需的所有技能是完全正常的，因为大多数职位描述都是理想化的，以符合他们的最佳期望。

当有疑问时，只需从 MOOCs、书籍和文章(我仍在做)中学习基本面，并通过自己的个人项目或实习应用所学。耐心点。学习之旅确实需要时间。津津有味地从你的旅程中学习。因为…

在一天结束的时候，这些问题在旅程结束后依然存在——你学到了什么？这是你想要的吗？

感谢您的阅读。我希望这篇文章能给你一些简要的(不是详尽的)数据科学工作流程和我的旅程的文档。

如果您有任何问题，请添加我，我们在 LinkedIn 上聊天，或者访问我的个人网站了解更多信息:

关于作者

Admond Lee 目前是东南亚排名第一的商业银行 API 平台Staq**—**的联合创始人/首席技术官。

想要获得免费的每周数据科学和创业见解吗？

你可以在 LinkedIn 、 Medium 、 Twitter 、脸书上和他联系。

[## 阿德蒙德·李

让每个人都能接触到数据科学。Admond 正在通过先进的社交分析和机器学习，利用可操作的见解帮助公司和数字营销机构实现营销投资回报。

www.admondlee.com](https://www.admondlee.com/)

我的第一次卡格尔比赛

原文：https://towardsdatascience.com/my-first-kaggle-competition-9d56d4773607?source=collection_archive---------6-----------------------

因此，我参加了我的第一个 Kaggle 比赛— 星球:从太空了解亚马逊。我的目标是:
——找出我作为深度学习实践者所缺少的东西。
-从技术和战略上吸取经验教训。
——给我的简历/作品集加点东西。

实际上，在比赛截止日期前的一个月，我是一名全职 Kaggler。第一周是学习 PyTorch，让自己熟悉 Python。第一周结束时，我提交了第一份材料。

Learning curves for first submission.

我用非常标准的多标签交叉熵损失从零开始训练 ResNet18。从上图中可以看出，在 30 个时期后出现了经典的过度拟合。从学习曲线来看，我的训练似乎是正确的。在损失值为 0.35 时似乎也有一条渐近线，这大致相当于正面例子的概率解释为 0.75(基本事实是 1)。粗略地说，这给出了训练和交叉验证分布之间的差异的估计，即训练和交叉验证集之间由我们的神经网络感知的最大差异是这样的，即训练阳性将被赋予 1 的高概率，而交叉验证阳性被赋予平均 0.75 的概率。我认为这种解释提供了独特的视角，即神经网络可以用来测量两种不同分布中数据的内在差异。

在第一周，我只用 Python 解释器和 Ubuntu 中默认的 Gedit 编辑器编写了我的 PyTorch 程序/脚本。整个想法是利用这些初级工具的低效率，在 Python 中建立一个强大的工作流/透视图。没有调试器迫使我频繁地测试我的代码(尽管有单元测试会更好)。多频繁？就像你不想调试一样频繁，也就是说，从表面上看，如果你认为你不能快速调试超过 10 行代码，那么你应该每 10 行代码测试一次。我还遵循了“如果不理解就不要输入命令”的原则，并结合了最少的工作示例。使用这个解释器，我会花几个小时玩某些库函数，理解各种数据结构。这一切都很怀旧，因为我在大学里学到的软件工程的一切都回来了。最终，这种低效率会影响到我未来更大的项目，在这个阶段之后，我最好使用高效的 IDE。

第二周，我做了增强的实验。这种增强会对训练产生巨大的影响。

左边的图是基本增强，这意味着标准的 8 倍增强(水平和垂直翻转，旋转 90，180 和 270 度，以及关于图像的主对角线和次对角线的反射)。右图包括基本增强之上的高级增强，如任意旋转、缩放、平移。旋转后的正方形图像的空白区域被原始图像的倒影填充，如下所示:

Note reflected cap and hair at top left and bottom of the image.

这两个图之间的主要区别是:

交叉验证损失不会随着增强而快速增加。
交叉验证损失更稳定(波动更小)。
列车之间的间隔更小，交叉验证损失更少。

这意味着更强的增强会减少过度拟合。虽然交叉验证损失的最低点对于两个图表来说是相同的，但是我仍然继续对我的模型的其余部分使用更强的增强。随着网络越来越深，过度拟合将变得越来越严重，保持对过度拟合的控制应该是更明智的。

一个两难的问题是，是用 OpenCV 还是用 PIL 来编写增强代码。似乎每个人都在使用 OpenCV，如果我遇到问题，寻求帮助更容易。然而，我决定使用 PIL，因为 PyTorch 明确支持它而不是 OpenCV，而且 PIL 更 Pythonic 化。我认为我也有更好的机会向 PyTorch 的当前不足的(我认为是)vision 库(也称为 TorchVision)提交一个 pull 请求。为开源项目做贡献也是我提升简历的策略之一；如果别人接受了你的拉请求，这表明你的代码有一定的水准，你能够写出有用的东西。

我还尝试对学习率进行退火，每当我的交叉验证损失达到稳定水平时，就把它降低 10 倍。在此之前，我想使用更强大的自动优化算法，如共轭梯度下降。有人建议我不要这样做，显然是因为损失曲面是非凸的；手动改变学习率以找到足够好的局部最小值就足够了，并且稍微简单一些。我接受了他的建议，我想通过手动操作来感受一下损失面。下图显示了当 ResNet34 的学习率降低时，交叉验证损失突然降低的程度(直到第三周左右，我才编写程序来继续绘制来自早期快照的学习曲线)。

Learning rate reduced by 10 times at epochs 25 and 29. Graph shown is for ResNet34.

诚然，下降似乎微不足道，但在这样的比赛中，每一个微小的进步都很重要。

此外，我试验了不同的阈值，用于将我的神经网络的概率输出转换为二元预测(无论它是否属于这一类)。这场比赛的衡量标准是所有样本的平均 F2 分数，这有利于回忆。当然，找到每个类别的阈值优于固定阈值，但是为了直观起见，这里是所有类别的 F2 分数相对于固定阈值的图表:

F2 score vs fixed threshold for ResNet18.

正如预期的那样，最佳阈值预测图像是正面的(对于一个类别),即使它不是非常有把握。虽然这以牺牲精度为代价增加了误报的数量，但会捕捉到更多的真阳性，降低误报的比例，从而提高召回率。

在确定每个类的阈值时，我面临两个问题。首先，我的交叉验证集(8K 交叉验证图像、32K 训练图像、60K 测试图像)可能太小，无法确定阈值。使用训练集将导致过度拟合，因为训练集的概率输出与交叉验证或测试集明显不同(当然更好分离)。在使用训练集时，应对这种过度拟合的一些策略是使用具有稍高训练损失的模型的较早快照(以模仿交叉验证和测试集中正负样本的不完全分离)，或者不同于训练时间地增加训练样本。我决定使用的策略是 5 重交叉验证，这意味着基于非重叠交叉验证集训练 5 个不同的模型。每个模型将在其自己的交叉验证集上进行预测，并且 5 个不重叠的交叉验证集被连接以重建所有 40K 标记的示例，这些示例又被用于找到每类阈值。这个标准相当标准和保守，因为它应该防止过度拟合。然而，我只是在后来才实现了这种 5 重交叉验证。第二个问题是，我必须假设测试集，尤其是私有排行榜，具有与训练集和交叉验证集相似的分布。我不认为仅仅使用 0.5 的简单阈值对于 F2 度量来说是最佳的，我也没有忘记我通过直接在标记的例子上优化阈值而进行的赌博。然而，我决定这是一个我必须做出的假设，我将通过其他方法减少过度拟合。

在第三周，我尝试了测试时间增加(TTA)。TTA 对我来说很有趣也很新鲜，因为我一直认为增强只适用于训练图像。人类做 TTA 的直观等价物是我们拍摄图像，旋转它，从我们眼睛的不同距离检查，等等。对于那些怀疑 TTA 对人类有多大影响的人来说，看看这个视错觉吧。(这个男孩实际上是皱着眉头，但我们不知何故倾向于觉得他在微笑。)

类似的事情正在我们的神经网络中发生。简而言之，我们的神经网络不是旋转和镜像不变的。如果是的话，高级增强在训练中不会有任何效果。我对 TTA 使用了基本的 8 倍扩增，从我的神经网络中获得了 8 个不同的概率输出，然后在 8 个不同的扩增中平均这些概率。然后，平均概率将通过一组预先确定的阈值，以形成提交的最终预测。我不知道这是如何工作的，但我的直觉是，TTA 通过与其他观点进行平均来降低异常预测，从而减少了方差。不太反常的预测意味着更好的准确性。

此外，我开始使用预先训练好的模型。预训练模型的交叉验证损失曲线更平滑。

Left graph is trained from scratch; right graph is fine-tune from pre-trained model. Both graphs are for ResNet18.

从上面两个图中可以看出，左图(从头开始训练)的交叉验证损失波动较小，而右图(预训练)的训练损失波动较大，更接近交叉验证损失。后一种观察结果可能归因于微调所涉及的较低的学习率(小 10 倍，从零开始训练为 0.01，微调为 0.001)。正如预期的那样，交叉验证损失下降得更快，并稳定在预训练模型的较低值。

我还转移到 ResNet34 架构，并着手实现前面提到的 5 重交叉验证。下面是详细流程:

选择前 8K 个图像用于交叉验证，其余 32K 个图像用于训练。
通过首先选择 8 倍基本增强中的一个来增强训练图像，然后应用高级增强(随机旋转、缩放、平移)。将增强扩展到各个时期，即，在下一个时期中增强它们之前，遍历所有 32K 训练图像。
基于交叉验证损失最低的快照选择模型。
使用所选模型对 8 折 TTA 的交叉验证集进行预测。通过在增强中求平均来组合 TTA。保存交叉验证预测。
选择接下来的 8K 图像用于交叉验证，并选择其他图像用于训练，并重复步骤 2 至 4，直到获得对应于 5 个非重叠交叉验证集的所有 5 个模型。
堆叠来自步骤 4 的 5 个不同的交叉验证预测，以重建所有 40K 图像的交叉验证，然后优化阈值(17 个类别的 17 个阈值)以获得最大 F2 分数。
对于从步骤 3 中选择的 5 个模型中的每一个，使用 TTA 在测试集上进行预测，这意味着 5 个模型乘以 8 倍 TTA。如前所述，通过平均来组合每个模型的 TTA，并且 5 个模型的预测最终被平均以形成 60K 测试图像的概率输出。
使用步骤 6 中找到的阈值，将概率输出转换为二元预测，并生成提交文件。

所有这些实现起来都很乏味，我不得不不断地测试和检查错误。我认识一些人，他们为一个提交模型投入了所有的 40K 图像，并根据他们的 32K-8K 训练验证分割来决定在哪里停止。与这样的策略相比，5 重交叉验证方法更难实现，并且需要长得多的时间来训练(对于 5 个模型，时间长 5 倍)。然而，五重交叉验证方法在防止过度拟合方面更安全，因为我们总是有交叉验证曲线来指导我们。此外，打包 5 个模型几乎总是比单个模型更准确。

上周，我面临着另一个困境。与竞争论坛上分享的一些结果相比，我在 ResNet34 上的 5 个型号的包在公共排行榜(LB)上没有返回足够高的 F2。别人好像得了 0.930，而我只能得 0.927。我可以用最后一周的时间来尝试找出哪里出了问题，或者继续训练不同的模型，通过组装来提高 F2。如果我选择前者，我可以学习如何更有效地训练单个神经网络。发现哪里出了问题，并因此学习交易的技巧，将对无法负担集成的实时应用程序(在我未来的工作中)更有益。然而，细节决定成败，发现这些技巧需要时间。重新训练模型需要更多的时间。阅读其他人在论坛上做的事情，在最后一周全职合奏会给我一个更高的分数。此外，许多人会在比赛后公开他们的代码，我可以花所有时间逐行比较我们的代码，并找到魔术。

我决定妥协。我从这个讨论帖快速看了一下恒的代码，他的代码和我的代码最明显的区别就是他的增强方法。这个变化对我的代码来说很简单，真正的瓶颈是训练时间。由于我可以使用 4 个 GPU，重新训练的成本不会太低，我决定继续探索训练增强的细微差别。然后，我将在一个简单的投票集合中回收我从这次探索中生成的任何模型。

恒的和我的增强术的主要区别是我一直在使用高级增强术。在选择(随机且一致地)应用 8 倍增强中的哪一个后，我将一直应用第二个，高级增强*。恒有这些特殊的概率值来决定是否增加，我的直觉是这些值是故意选择的。所以我改变了我的第二次增强，只应用了一半的时间:*

Left graph applies 0.5 probability advanced augmentation, right graph applies advanced augmentation all the time.

正如你从上面的图表中所看到的，一旦我减少了增强，或者更确切地说，应用了一半的高级增强，就有了巨大的改进。下面增加太少，

Left graph has 0.5 chance of advanced augmentation, right graph has 0.25 chance.

或者这里放大太多，

Left graph has 0.5 chance of advanced augmentation, right graph has 0.75 chance.

导致次优损失。增加太少会导致过度拟合，而增加太多会导致拟合不足，所以我选择了 0.5 的高级增加几率。我仍然保留了基本的、潜在的 8 倍增强，因为我相信与高级增强相比，8 倍增强是非破坏性的。通过镜像来填充空白空间会给增强图像带来一种虚假感，更糟糕的是，缩放可能会排除图像边界处的地标/特征，例如，如果我们放大太多，图像边缘可能会被移除一条河流。我相信高级增强的破坏性引入了太多的噪音，使我的神经网络无法有效学习。因此，在破坏性与非破坏性增强的框架中，我只关注降低应用高级但破坏性增强的可能性。经过进一步考虑，这可能是一个更简单的问题，即过度拟合或欠拟合正则化增强带来的数量。我也应该试着改变基本的 8 倍增加量。

最后，我通过投票将几个 ResNet34 和 ResNet50 模型随机组合在一起，结果很差。

总之，下面是我尝试过的方法以及它们对公众 LB 的 F2 分数的影响:

8K-32K 列车-验证分离，单 ResNet18 模型从零开始:0.90018
添加基本的 8 倍扩增:0.90530
将 0.5 固定阈值更改为多个阈值:0.91587
添加高级增强(对 ResNet18 的损失没有太大影响)和退火学习率:0.91879
微调预训练 ResNet18: 0.92443
TTA 地址:0.92619
切换到预先训练的 ResNet34: 0.927646
将高级增强减少到只有一半时间发生:0.92801
5 折交叉验证的 5 款包:0.92942
来自 6 个提交的集合:0.92983

然而，F2 从公共 LB 到私有 LB 有一个巨大的下降，我的最终提交从 0.92983 下降到 0.92685。其他人也有相当大的变动。我不知道为什么，因为我一直相当保守；连我 5 款的包包也从 0.92942 降到了 0.92676。我只能推测:

我对私有 LB、公共 LB 和训练验证分布相似的假设是无效的，这使得我的每类阈值搜索是致命的。
我的套装不够大，不能防止过度合身。我必须更彻底地调查是什么导致了公共 LB 的过度适应。

这个比赛最令人满意的部分是我可以做我喜欢做的事情(深度学习废话)，以及我的公共 LB 分数的稳步增长。当然，一路上也有失败的实验，但我认为我的旅程相比其他人是顺利的。感谢那些在论坛上分享他们的方法和源代码的人的慷慨，我决定尝试的方法在很大程度上经过了测试并被证明是可行的，它们确实可行。

我会做些不同的事情吗？大概不会。我不断地制定策略，优先考虑下一步要做的事情，并最大限度地利用我的时间。然而，如果我有更多的时间，还有许多事情要做，在这次比赛之后，我将继续做这些事情:

我的单一模型仍然是次优的，其他人可以在公共 LB 上使用单一模型而不装袋达到 0.93。我将不得不一行一行地把我的代码和其他代码进行比较，以找出我的训练出了什么问题。
训练不同的更深层次的架构。我还必须在不同层之间采用不同的学习速率。我没有冻结更接近输入的层，也没有减慢它们的学习速度，因为我觉得 ResNet34 是一个相当浅的网络。不必过分依赖保留初始权重来达到良好的局部最优。深层网络更难训练，因为损失面是非凸的，更难找到一个好的最优值。
尝试不同的输入图像大小。从论坛来看，似乎很多人都使用了这样的策略，而且对他们有效，特别是减少了他们的私有和公有 LBs 之间的差异..这相当于人类为了更好地检查而将某物拉近或远离眼睛。
使用从第 2 点和第 3 点生成的模型以获得更好的整体效果。此外，尝试除了投票以外的其他集合方法。也许看一下 StackNet 会给我一些线索，加速我的学习。
更加熟悉 PyTorch。我觉得掌握一个流行的深度学习框架很重要。这样，任何新想法的实施都可以很快完成。效率是关键；你越快验证你的想法，你学得越快，你的进步就越快。顺便对 D 开头的粉丝说一句，这就是藤原拓海所说的拥有一个家庭课程的重要性，以及为什么他仍然坚持在阿基纳山上送豆腐。
少写代码，充分利用库，同样是为了效率。对于我要写的代码，看看对别人有没有用，对深度学习框架有没有贡献。修改 Git 以提交 pull 请求。此外，手动改变学习速度是一件痛苦的事情。我会尝试使用更先进的自动优化器。
训练效率更高。我在这次比赛中错过的一件事是通过观察前几个时期的学习曲线来学习如何拒绝失败的实验。这部分是因为我滥用了对多个 GPU 的访问，也部分是因为我在编写其他代码时让我的模型去训练。我相信这是区分熟练教练和初级教练的重要技能。我想我还可以进一步优化我的工作流程，例如，让打印输出不那么冗长，只留下相关信息，等等。

我观察和学到的主要经验是:

知道的足够多和知道的太多之间的平衡。了解足够多，以便能够按照自己的方式修改他人的代码，但不要太多，以免完全陷入其中。对我来说，了解足够多很大程度上意味着从概念上知道一个函数做什么，以及输入和输出数据结构是什么。这也意味着知道在哪里可以找到更多关于如何操作所述数据结构的信息。有时候，理解一个概念需要时间，甚至可能需要一些先决知识。不要通过随意和过快地阅读这些知识来欺骗自己。花时间去阅读它们。通常情况下，15 分钟的阅读可以防止你犯一些奇怪的错误，从而挽救你的生命(除了重读你试图节省的 15 分钟之外，这可能还要花费几个小时)。
保持代码整洁和过度重构之间的平衡。对我来说，保持代码重构让一切都更容易管理。干净的代码更容易操作，从而防止引入一些错误。更重要的是，干净的代码激励着我。我变得更愿意审视我的代码，做出激烈但必要的改变，例如，编写自动化我的工作流的代码。然而，过多的重构可能会浪费太多的时间，尤其是当你想尝试一种新的训练方法，花时间组织你的代码，却发现方法本身根本不起作用的时候。我遵循的经验法则是，编写新的实验代码要稍微混乱一些，一旦你发现它可以工作，就重构它。
深度和广度的平衡。作为初学者，广度更重要。对我来说，更重要的是了解不同的技术在不同的场景下是如何工作的。这样我就能知道将来如何应用它们。例如，我了解到，如果你的神经网络不够深或不够复杂，高级增强就没有必要；高级增强只在训练 ResNet34 时生效，而不是 ResNet18。如果我没有离开 ResNet18，并坚持尝试获得最好的单一 ResNet18 型号，我可能会错过这样有价值的见解。继续调查情况，找到你的最佳策略。一旦你对如何做事情和你应该采取的总体方向有了感觉，专注于深度和执行好你的策略。
过度拟合和欠拟合之间的平衡。这是我参加这个比赛时的感受；训练一个模特总是一场永无休止的斗争，不要过度训练或训练不足。是的，说起来容易做起来难，我相信许多深度学习从业者都知道，当你的数据有限时，这就是游戏。

特别感谢那些在论坛上慷慨分享他们的代码和方法的人。我站在巨人的肩膀上。

我的第一次卡格尔比赛

原文：https://towardsdatascience.com/my-first-kaggle-competition-using-random-forests-to-predict-housing-prices-76efee28d42f?source=collection_archive---------10-----------------------

使用随机森林预测房价

介绍

我最近偶然发现了由雷切尔·托马斯写的这篇文章，描述了博客的各种优势，瞧，我的第一篇文章就在这里。

在这篇文章中，我将分享我第一次参加 kaggle 比赛的经历。我完成了 fast.ai 的面向程序员的机器学习 MOOC ，我希望在这次 kaggle 比赛中应用从这门课程中学到的知识。

概观

我们将参加房价预测比赛。
描述说:

对于已经完成机器学习在线课程并希望在尝试特色比赛之前扩展技能集的数据科学学生来说，这是一场完美的比赛。

问题很简单，我们必须预测爱荷华州埃姆斯的住宅价格(因变量)。我们被提供了 79 个解释特征(独立变量)来描述(几乎)房子的每一个方面。

对于这个问题，我们将使用随机森林，它是决策树的集合。随机森林建立多个决策树，并将它们合并在一起，以获得更准确和稳定的预测。

看着这些数据

for full image visit https://i.imgur.com/BEtQD00.png

这些列和它们的字段大部分对我们来说没有太大意义，但是 kaggle 已经在竞赛的数据部分为我们提供了一些简要的描述。您可以进一步查找 data_description.txt 资源，以获得每一列及其数据字段的详细描述。

评估指标

评估指标是 RMSLE (均方根对数误差)，因此在这种情况下，取因变量(即销售价格)的对数是有意义的。

df_raw.SalePrice = np.log(df_raw.SalePrice)

数据解释

您可能已经注意到,“Alley”列的前六行都是 NaN 值(描述了各行的缺失数据)。因此，让我们找出所有要素在整个数据集中缺失值的百分比。

Columns with missing data

我们有 5 个 Nan%大于 50 的特征。这些特征很可能不会为我们提供任何关于数据集的有用信息，因此我们可以考虑现在删除它们，但我们很快就会看到特征的重要性，所以我们现在保留它们，让随机森林为我们做出这个决策。

数据清理

为了将这个数据集提供给随机森林，我们必须将所有非数字数据转换成数字数据。所有非数字数据列代表两种类型的分类数据:

序数:类别的顺序很重要。
名义上的:顺序不重要的地方。

有两种方法将这些转换成数值:

标签编码: -用整数标签替换类别，范围从 0 到(类别数-1)。它使得分类数据在本质上是有序的。

One-Hot encoding: -将包含分类数据的一列拆分为多列(等于类别数)。数字由 1 和 0 代替，这取决于哪一列有什么值。

有关标签 vs 一键编码的更多信息，您可以访问这篇文章。

无论如何，大多数列都是有序的，所以我们将对这个数据集使用标签编码(我后来也尝试了一次热编码，它使我的 RMSLE 增加了 0.01)。“*train _ cats”*和“*proc _ df”*取自 Github 上的 fastai repo 。如果你愿意，你可以查看源代码和文档。

我们还用相应列的中值替换了数字数据列的缺失值，并添加了一个_na 列
，用于指定数据是否缺失。

查看数据时，我发现没有为我们提供房屋的年龄的特征，所以我添加了这个特征以及另一个给出总居住面积的特征。

分成训练集和验证集

在构建我们的随机森林之前，最后一件事是将我们的数据集分成两部分:训练集和验证集。机器学习中最重要的想法可能是拥有独立的训练和验证数据集。作为动机，假设你没有分割你的数据，而是全部使用。假设你有很多参数:

最右边的模型(蓝色曲线几乎完美地穿过红色点)的图片数据点的误差最低，但这不是最佳选择。这是为什么呢？如果您要收集一些新的数据点，它们很可能更接近中间图表中的曲线。

splitting our raw data set to a training and a validation set

这说明了使用我们所有的数据会导致过度拟合。验证集有助于诊断这个问题。你的模型在验证集上的分数将代表你的模型在真实世界中，在它从未见过的数据上的表现。所以，验证集只是你的数据集的子集，它告诉你你的模型有多一般化。

训练模型

我们终于准备好建立随机森林了。我们将使用 Parfit 来优化我们的超参数。

最佳超参数为:
min_samples_leaf : 1，

max_features : 0.4，

使用随机森林的优化参数，我们在验证集上得到的 RMSLE 为 0.1258 。

可视化随机森林

让我们来看看随机森林中的一棵树(估计值)。

One tree from our forest

这棵树已经被可视化到深度= 2。树的每个节点将我们的数据分成两半，这样 MSE 的加权平均值是最好的。随着我们继续向下，MSE 在减小，因为树基本上在为每个节点寻找最佳可能分裂点。
该树首先根据 TotalLivingSf 划分数据，然后分别根据 AgeSold 和 TotalLivingSf 划分其子代，以此类推。
我们的森林中有 300 个估算者，我们取所有这些估算者的平均值来进行预测。

特征选择

接下来，我们将深入研究要素的重要性，以移除冗余要素，并找出哪些要素负责为我们的数据提供最深入的见解。

函数' rf_feat_importance' 将返回一个熊猫数据帧，其中包含列名及其各自的特征重要性。我们使用*‘plot _ fi’*函数绘制一个水平条形图，描述所有列的特性重要性。

def rf_feat_importance(m**,** df)**:** return pd.DataFrame({'cols': df.columns,'imp' :
    m.feature_importances_}).sort_values('imp',ascending = False)fi = rf_feat_importance(m,df)def plot_fi(fi):
      return fi.plot('cols', 'imp', 
      'barh' figsize(20,12), legend=False)plot_fi(fi[:50])

Feature Importance Bar graph.

该图显示，重要性以指数方式下降，因此没有必要考虑那些几乎无法洞察我们数据集的特性。我们将删除 imp < 0.005 的所有功能，然后根据新数据重新训练我们的模型，并检查 RMSLE。

tokeep = fi[fi.imp >= 0.005].cols
dfToKeep = df[tokeep]X_train,X_val,y_train,y_val = train_test_split(dfToKeep,y,
                              test_size = 0.25,random_state = 11)
m.fit(X_train,y_train)

此后的 RMSLE 为 0.12506 ，比之前的 0.1258 略有提高。特征的数量已经从的 79 个减少到 25 个。一般来说，删除冗余列应该不会使情况变得更糟。如果这让 RMSLE 变得更糟，那么它们终究不是多余的。

删除多余的列可能会使我们的模型更好一点。如果你想想这些树是如何建立的，当算法决定在什么上分裂时，它会有更少的事情需要担心。

很有可能用更少的数据创建一个更好的树，但是它不会改变结果太多。这将让我们专注于最重要的功能。

基于相关性的特征选择

现在我们将使用 S pearman 的等级相关系数 来找出特征之间的相关性。如果两个特征为我们提供了相同的洞察力，去掉其中一个是明智的，因为它基本上是多余的。这项技术有助于找到多个特征之间的联系。

我们将绘制的东西称为 树状图 ，这是一种层次聚类。

from scipy.cluster import hierarchy as hc
corr = np.round(scipy.stats.spearmanr(dfToKeep).correlation, 4)
corr_condensed = hc.distance.squareform(1-corr)
z = hc.linkage(corr_condensed, method='average')
fig = plt.figure(figsize=(16,15))
dendrogram = hc.dendrogram(z, labels=dfToKeep.columns, orientation='left', leaf_font_size=16)
plt.show()

dendrogram showing the correlation between all the features.

两个特征碰撞得越早，它们的相关性就越强。基于此，我们可以看到五对彼此高度相关的特征。

这些是:
1。)GrLivArea 和 TotalLivingSF。
2。)GarageArea 和 GarageCars。
3。)1stFlrSF 和 TotalBsmtSF。
4。)GarageYrBlt 和 YearBuilt。
5。)壁炉 Qu 和壁炉。

每对中的两个特征都为我们提供了相似的洞察力，所以从每对中去掉一个特征是明智的。但是这两者中的哪一个将被删除？让我们找出答案。

现在为了找出(每对中的)两个特征中的哪一个要被移除，首先，我计算了一个基线分数(包括所有的 25 个特征)，然后开始逐一移除这十个特征。在移除每个特征之后，我们将再次计算分数(在重新训练模型之后),并将其与基线进行比较，以查看特定特征的移除如何影响我们的分数。

def get_oob(df,y):
    m = RandomForestRegressor(bootstrap=True,
           criterion='mse',max_depth=None,
           max_features=0.4,max_leaf_nodes=None,
           min_impurity_decrease=0.0, min_impurity_split=None,
           min_samples_leaf=1, min_samples_split=2,
           min_weight_fraction_leaf=0.0, 
           n_estimators=300,n_jobs=-1,
           oob_score=False,random_state=11,
           verbose=0,warm_start=False)X_train,X_val,y_train,y_val = train_test_split(df,y,
                     test_size =  0.25,random_state = 11)
    m.fit(X_train, y_train)
    return [rmse(m.predict(X_val),y_val)]get_oob(dfToKeep,y)

我们得到的基线分数是 0.12506 。

现在，我们将开始删除这 10 个特征，并重新计算分数。
下面代码的每个输出告诉我们在新数据上重新训练模型后的 RMSLE。第一个标记告诉我们被删除的特征(或列),第二个标记告诉我们从数据中删除特定特征后的 RMSLE。

for c in ['GrLivArea','TotalLivingSF','1stFlrSF','TotalBsmtSF','GarageYrBlt','YearBuilt','GarageArea','GarageCars','Fireplaces','FireplaceQu']:
    print(c, get_oob(dfToKeep.drop(c, axis=1), y))GrLivArea [0.12407075391075345]
TotalLivingSF [0.12487110485019964]
1stFlrSF [0.12658563342527962]
TotalBsmtSF [0.12518884830074287]
GarageYrBlt [0.12475983278616651]
YearBuilt [0.12672934344370876]
GarageArea [0.12412925519107317]
GarageCars [0.12538764179293327]
Fireplaces [0.1258181905119676]
FireplaceQu [0.12630040930065195]

我们可以看到，去掉 GrLivArea、TotalBsmtSF、GarageYrBlt 和 GarageArea 减少了我们的错误。所以，我们可以去掉所有这些多余的特征。

to_drop = ['GrLivArea','GarageYrBlt','TotalBsmtSF','GarageArea']
get_oob(dfToKeep.drop(to_drop,axis=1),y)[0.12341214604541835]

我们的 RMSLE 在去掉所有冗余特征后，将从 0.1258 减少到 0.12341 。

dfToKeep.drop(to_drop,inplace=True,axis=1)
len(dfToKeep.columns)21

从 79 个特性开始，我们现在只剩下 21 个特性。这是我们的最终模型。
我们现在应该合并我们的训练和验证集，并在这个合并的数据集上重新训练我们的模型。

dfTrainAndVal = df[columns]
print(len(dfTrainAndVal.columns))
m.fit(dfTrainAndVal,y)

提交预测

现在，我们将为测试集生成预测，但在此之前，我们需要对测试集进行类似的转换。

df_test = pd.read_csv('data/test.csv')
transform(df_test) # add "ageSold" and "TotalLivingSF" to the set.
train_cats(df_test) 
df_test,_,_ = proc_df(df_test,na_dict = nas)
Id = df_test.Id
df_test = df_test[columns]
ans = np.stack((Id,np.exp(m.predict(df_test))),axis= 1)

该模型在 Kaggle 测试集上给我们的分数是 0.12480 ，这对应于排行榜上 4052 中的排名 1338，这使我们进入了前 34 %** 。**

结束语

我目前正在学习第二种类型的决策树集成，即 boosting。在这篇文章之后，我将围绕梯度推进回归器而不是随机森林进行实现，看看这如何影响我们的特征重要性和最终得分。

任何意见和建议将不胜感激。

我要感谢和 雷切尔·托马斯；制作这些非凡的网络公开课。我会推荐大家去看看 fast.ai ，他们也有深度学习和计算线性代数以及机器学习的课程。****

我与 Udacity 和 Coursera 进行深度学习冒险的第一步

原文：https://towardsdatascience.com/my-first-step-for-deep-learning-adventure-with-udacity-and-coursera-ee135042ac1e?source=collection_archive---------8-----------------------

为什么是深度学习——吴恩达，他对为什么深度学习正在兴起的解释可以用下图来总结。

在报名参加来自 Udacity 和 Coursera 的在线深度学习课程之前，我决定在家里构建自己的 GPU 实例。Udacity 向亚马逊 AWS 提供 100 美元信用来剥离 GPU 实例，而 Coursera 没有。在花费之前拥有用于训练模型的内部 GPU 实例总是好的💰在云上。我用的 GPU 是英伟达 GTX 1070

我把这些部件用于我自己的 CPU 实例，下面是结果。

花费大部分时间💸在 GPU 上而不是 CPU 上。

我正在使用 Xbuntu 17.04 但它可能太前沿了，但我猜尝试更多最新的内核没有坏处。

在设置以下内容之前，我做了标准的路由器设置来启用我的 gpu 实例的 SSH 和 https，并使用 letsencrypt 通过 SSL 证书保护它。除此之外，我使用 NGINX 作为网络服务器。

日常活动的 SSH 设置

安装 ssh 服务器

sudo apt-get install openssh-server

2.配置无密码登录

在本地 PC 上生成一个 SSH 密钥，在这个上有一个来自数字海洋的优秀的教程

完成后，我们需要通过以下方式将我们的公钥添加到我们的登录名中

cat ~/.ssh/id_rsa.pub | ssh [login]@[your.ip.address.here] "cat >> ~/.ssh/authorized_keys"

然后编辑/etc/ssh/sshd_config，这将强制只使用密钥登录，从而更加安全

# To disable tunneled clear text passwords, change to no here!
#PasswordAuthentication yes
#PermitEmptyPasswords no
PasswordAuthentication no

除此之外，我们还需要在/etc/ssh/sshd_config 中添加 X11Forwarding，如果我们希望在本地显示 X11，稍后会用到它

Match User [login]
        X11Forwarding yes
        AllowTcpForwarding yes
        X11DisplayOffset 10

重启 SSH 服务器

sudo systemctl restart sshd

最后，我们可以不用输入密码就可以登录，这对于稍后为 VNC 创建 SSH 隧道的下一个设置非常重要

运行长期运行流程的 VNC 设置

Digital Ocean 有一个关于使用 xfce4 设置 VNC 的极好的教程,这就是为什么我选择使用 Xbuntu 发行版，它没有额外的软件包。这就是我们可以进行长期训练的环境

Anaconda 设置准备编码环境

在我们安装 anaconda 之前，我们需要在我们的服务器上安装 nvidia 驱动程序、CUDA 和 cuDNN。这个来自 floydhub 的指南非常有用，但仍然适用于 Xbuntu 17.04 版本。一旦一切就绪，我们就可以使用命令进行验证

nvidia-smi

它应该看起来像这样

Udacity 对建立蟒蛇环境有很好的介绍。我发现在培训/开发期间维护 tensorflow gpu 和 tensorflow cpu 环境进行比较非常有用

用于监控 GPU 的 Zabbix 设置

我正在使用 zabbix 来监控 GPU，并为此使用了优秀的数字海洋教程。

一旦 zabbix 被相应地安装和配置，我们就可以为 zabbix 获得 Nvidia 模板。有了它，我们可以在利用率方面(温度、风扇和处理)密切关注我们 GPU

最后，使用来自 Udacity 简介的 style-transfer 和以下命令比较了 GPU 和 CPU 的一些统计数据:-

time python evaluate.py — checkpoint ./rain-princess.ckpt — in-path lesu-0596.jpg — out-path lesu-0596-style.jpg

GPU vs CPU

我的图像分辨率是 4242 × 2828，大约是 7.9MB 的文件大小，有趣的是看到 tensorflow CPU 与 GPU 相比有一个核心转储。我还注意到有一个巨大的速度提升，我猜这就是深度学习所依赖的，用 GPU 进行实验和获得反馈的速度！关于内部部署与云比较的更多详细信息请点击此处

我对艾的解读

原文：https://towardsdatascience.com/my-interpretation-of-ai-a6eed63e4cb9?source=collection_archive---------16-----------------------

人工智能是现在的热门词汇，作为一个对数据科学感兴趣的人，我已经做了很多实验。这些天来，这个词在许多上下文中被频繁使用，鉴于它在许多领域的应用潜力，我想后退一步，真正理解这个术语“人工智能”在直觉层面上的含义。这是我目前收集到的信息。

人工智能(AI)的普遍定义是计算机系统表现出来的类似于智能人类的智能。那么，什么是人类智能？以下是一些有助于定义智能的特征:

推理和解决问题
学习、改进和概括的能力
语言
视觉识别
感知、随机性和创造性
常识

现在，让我们在计算机可以被编程执行的几个任务的上下文中理解上述内容(当然，具有不同程度的成功):

1.**一盘棋:**计算机在国际象棋上取得了非常高的成功。众所周知，1997 年，IBM 的国际象棋计算机“深蓝”击败了世界冠军加里·卡斯帕罗夫。国际象棋是一种具有挑战性的游戏，但它可以用一组走法来描述，并且可以通过搜索所有可能的走法来玩。移动的次数可能真的很多，但它们仍然可以被定义，这就是具有强大处理能力的计算机如何战胜人类对手的原因。那么，下棋的电脑能叫 AI 吗？是的，在推理、解决问题和学习能力等非常有限的方面。

2.**预测贷款申请人是否有信用:**在这种情况下，计算机取得了很大的成功。使用机器学习算法，并通过提供许多特征(信息)，例如在这种情况下，申请人的收入、债务水平、过去的信贷行为，计算机可以被编程来预测贷款申请人拖欠贷款的可能性。在这个过程中，计算机程序显示出智能的迹象，如推理、寻找模式和解决问题。随着我们根据更多的数据和证据训练计算机，它将从错误中学习，并进一步提高其预测的准确性。此外，它还通过为新的贷款申请人生成高精度预测来学习归纳。所以，如你所见，这个人工智能比下棋的人工智能更进化。与正式的、规则定义的任务(如国际象棋)相比，这个人工智能正在完成一项有点不正式和不确定的任务。

3.视觉上区分猫和狗:识别狗和猫的图像对我们来说太容易了，我们甚至不需要花时间去思考。对于计算机来说，这就不那么简单了。人类从小就能看到狗和猫。在我们的大脑中，我们创造了一种机制，在这种机制中，我们定义了一套与狗和猫相关的特征。这些特征在我们的潜意识中根深蒂固，如果有人问这些特征是什么，我们可能无法拼写出来。换句话说，由于我们从小就在看很多猫狗，所以我们的大脑现在有了区分猫狗的“经验”。当我们想让计算机具有视觉智能时，我们必须为它提供这种体验，即在大量猫和狗的图像上训练它，并提供有助于它区分的功能。然而，我们自己无法在我们的脑海中拼写出区分猫和狗的特征，因此，我们很难创建并向计算机提供这些特征。深度学习算法是机器学习的一个特殊分支，它通过查看数百万张猫和狗的图像，帮助计算机程序自行创建那些抽象特征。因此，深度学习算法正在使计算机获得更像人类的智能，包括视觉、随机性和归纳性。

深度学习算法通过对大量数据进行训练，自行得出特征，这就是它们与传统机器学习算法不同的地方，传统机器学习算法必须预先定义特征。

4.自动驾驶汽车:这是人工智能的最新领域，人们对此有很多兴趣和研究。这些人工智能系统与上述系统的真正区别在于，它们需要更加**进化，具有应对不可预见的随机情况的能力。一个自动驾驶的人工智能必须理解前面汽车明显的左右信号，还必须解释其他司机不那么明显的意图。例如，如果前面的车正在减速，前面可能会有一些不可预见的障碍(事故，交通堵塞等。)而 AI 系统需要自己做好准备。**这要求机器拥有常识，就像人类利用常识与世界互动一样。当然，人类从经验中获得这一点，但要设计具有这种常识性经验的算法，需要在所有可能的驾驶场景中训练这些算法，这是不可能的。这些是一些需要解决的严重问题，从一些自动驾驶汽车的致命事故中可以看出这一点。2016 年 5 月，特斯拉 Model S 撞上了一辆拖拉机拖车，因为它没有注意到拖车的白色一侧映衬着明亮的天空。深度学习模型(经过大量场景的训练)有助于自动驾驶人工智能理解物理世界，但它们需要与其他方法结合起来，通过注入人类水平的常识来处理现实世界中驾驶的不确定性和随机性。

5.写一首诗:一个有能力写一首诗或一首歌的人工智能肯定拥有更进化的类似人类的智能，包括语言技能和创造力。当然，创造力的程度是有争议的，但是在这个领域取得的进步至少指出了这种创造性人工智能的开始。

下图总结了上述观点:

强 AI 和弱 AI

上述所有例子都是弱人工智能的例子，其中人工智能在任务的背景下进化。这些人工智能系统在完成特定任务方面已经进化到接近人类水平的智能。然而，我们在开发强大的人工智能方面仍有很长的路要走——这些系统可以在各种背景下学习和应用，例如，在美国的城市道路上学习驾驶汽车，并应用这些学习在中国的高速公路上驾驶卡车。强人工智能就像一个人类孩子，从不同的背景和经历中学习，进化成一个类似于完全形成的人类思维的系统，然后可以在没有人类干预的情况下执行任务。一旦发生这种情况，科幻电影的世界就有很大的可能性成为现实。嗯！这一天可能不远了。

即将上线！！一门关于深度学习的课程，将深入讨论上述内容以及算法和应用。

我从物理学到数据科学的旅程

原文：https://towardsdatascience.com/my-journey-from-physics-into-data-science-5d578d0f9aa6?source=collection_archive---------1-----------------------

随着我对数据科学领域的热情不断增长，我每天都在学习新知识。作为一名即将毕业的物理系学生，要追求不同的职业轨迹，必须要回答**‘为什么’和‘如何’个问题。被许多人问到我从学术界——物理学到数据科学的转变，我希望我的故事可以回答关于为什么我决定成为一名数据科学家和我如何追求目标的问题，并最终鼓励和激励更多的人追求他们的激情**。我们开始吧！

这一切都始于在欧洲核子研究中心的暑期学生生活

CERN Summer Student Programme 2017

欧洲粒子物理研究所暑期学生项目为物理、计算和工程专业的本科生提供了千载难逢的机会，让他们在瑞士日内瓦的欧洲粒子物理研究所与多文化团队中的顶尖科学家一起参与他们的研究项目。

2017 年 6 月，我非常幸运地被接受加入该计划。我简直欣喜若狂，因为粒子物理一直是我的研究兴趣，能够在欧洲粒子物理研究所进行研究对我来说简直是梦想成真的经历！在 2 个月的实习期间，我通过全球 LHC 计算网格&云计算为小型μ介子螺线管(CMS) 实验做了一些万亿字节数据的事件重构的分析和模拟。

Compact Muon Solenoid (CMS) in the cavern

此外，暑期学生还参加了一系列讲座、研讨会，并参观了欧洲粒子物理研究所的设施，涵盖了理论和实验粒子物理以及 计算领域的广泛主题。

在此期间，我通过讲座、研讨会甚至我的项目本身接触到了机器学习和大数据分析。这些机器学习技术如何在如此庞大的数据量下以非凡的精度分类和检测各种微观粒子，这让我特别震惊。百思不得其解，我毫不犹豫地深入研究了机器学习和云计算主题，仅仅是因为我热爱它！

谁会想到这次曝光会成为我人生的转折点。是的，我用数据找到了我的婚姻。

然而，尽管我渴望学习这些主题，我仍然对数据科学有模糊的概念。虽然听起来很模糊，但我知道在发现我的 真正的激情 后，我必须发现更多。

深入研究数据科学领域

当我结束实习回到新加坡后，我做了一些研究来了解更多关于数据科学的知识，令我惊讶的是，这个领域并没有一个明确的定义。但总的来说， 数据科学 可以概括为编程技能、数学统计知识、领域知识的结合。这里的解释绝不是详尽的，而是为了从总体上阐明这个定义(欢迎任何评论！😄).

尽管如此，我对数据如何被用来产生洞察力和推动公司的商业价值感到惊讶。从了解业务问题，到收集和可视化数据，直到原型制作、微调和将模型部署到现实世界应用程序的阶段，我发现了利用数据解决复杂问题的挑战的成就感。渐渐地，我的激情开始形成…

“没有数据，你只是另一个有观点的人”

爱德华·戴明

我的起点—数据可视化

Tableau Dashboard

2017 年 8 月，作为迈向数据科学的第一步，我参加了由 Tableau 和 Infocomm Media Development Authority(IMDA)共同举办的 NIC Face-Off 数据竞赛 ，这是我第一次接触数据可视化。

这次经历让我有机会使用 Tableau Public 可视化各种调查东南亚雾霾起源的公开数据源，以提供可操作的见解。我很高兴能与您分享简单的 [Tableau 仪表盘](https://public.tableau.com/views/Haze/Storyline?:embed=y&:display_count=yes\)(欢迎在下面留下您的评论！).

我在 SMRT 的第一份兼职数据分析实习

同月，我偶然发现了一个机会，在 SMRT 种子基金资助的初创公司 mobilityX 做兼职数据分析实习生。我使用 Python 进行编码主要是因为它的高级编程语言、可读性和广泛的社区支持。

老实说，当我在大学第一年开始学习编程时，我真的想过放弃编码。运行一个简单的 for 循环可能会让我挂几天(甚至几周！).更糟糕的是，“我就是没有天赋”的消极想法给了我沉重的打击…

我对编程的兴趣始于我在第三年学习期间与我系里的一位教授一起着手一个研究项目，该项目要求开发数据分析工具。正如你可能已经预料到的，我开始拿起 Python 来构建工具，并且我爱上了它！

我告诉自己——“我就是没有天赋 ”的日子一去不复返了，取而代之的是以下学习编程的步骤(至少对我来说):

理解编程的基本逻辑
选择一种编程语言，并学习如何使用它(语法等。)
练习，练习，练习
重复步骤 1–3

抱歉，在写作的时候，我太激动了，无法与你分享我的学习之路…

兼职实习持续到 2018 年 3 月，学习之旅卓有成效。我使用 PostgreSQL 和 Python 学习并执行了数据清理和操作、web 抓取和数据提取。

我提前一个学期毕业去做数据科学实习

所有之前的经历进一步增强了我的热情，并为数据科学奠定了基础。下定决心，我计划了我的学习时间表，并设法提前毕业，于 2017 年 12 月在量子发明从事我目前的全职数据科学实习。

在这个阶段，你可能会问——为什么我去实习而不是全职的数据科学职位？简而言之是——在申请全职工作之前，通过处理真实世界的数据，获得更多的技术接触，并从零开始体验数据科学流的完整周期。

这是我真正的数据科学之旅开始的整个故事的核心部分。下面的列表简要总结了我在许多伟人和不同在线资源的帮助下的学习之路。

1.教科书

我读的第一本教科书是统计学习导论——R中的应用。我向初学者强烈推荐这本教科书，因为这本书侧重于统计建模和机器学习的基本概念，并附有详细而直观的解释。如果你是一个数学铁杆，你会喜欢这本书:统计学习的要素。

其他值得一提的教材有绝对初学者的机器学习、Sebastian Raschka 的 Python 机器学习和 Jake VanderPlas 的 Python 数据科学手册。

2.在线课程

Coursera。Coursera 联合创始人吴恩达教授的机器学习 。我一直着迷于他将复杂的概念分解成简单的学习信息的能力。为期 11 周的课程重点关注监督学习、非监督学习和机器学习的最佳实践，以及在现实世界中的实际应用。我有时仍然会参考课堂笔记，以解决建立机器学习模型时的欠拟合或过拟合问题。

Udemy。 何塞·波尔蒂利亚教授的数据科学与机器学习训练营Python。本课程从讲授 Python 的基础知识开始，逐步指导您如何使用 scikit-learn 和 tensorflow 实现各种机器学习和深度学习代码。这个课程让我对 Python 中实现机器学习模型的各种可用库有了一个很好的概述。另外，我强烈推荐我个人最喜欢的课程: 深度学习 A-Z:基里尔·叶列缅科和哈德林·德·庞特维斯教授的动手操作人工神经网络 。这是我第一次接触深度学习，相信我，他们的课程真的是独一无二的，非常强调本能的理解水平，有监督和无监督深度学习的动手编码教程。

琳达。 Python 对于数据科学的基本训练 由 Lillian Pierson 教授。本课程讲授数据管理和数据可视化以及其他统计分析的基础知识。

3.商务化人际关系网

好吧。你对数据科学/分析领域感兴趣？如果你没有 LinkedIn 账户，那就创建一个。

LinkedIn 是一个强大的平台，拥有紧密联系的数据科学社区。分享学习的环境简直令人惊奇，人们愿意分享他们的经验、思想和知识来帮助他人。事实上，LinkedIn 是我学习最多的地方，无论是技术知识、职业建议等等。受到启发，我现在开始通过在我的 LinkedIn 上分享我的想法和经历来回馈社区。😃

一些数据科学家甚至聚在一起开展每周一次的网络研讨会— 数据科学办公时间 ，讨论数据科学的基础知识并发表见解(数据准备、特征提取、数据可视化等)。).一定要去看看！

4.其他资源

大多数数据科学领域的初学者经常被浩瀚的资源淹没(像我一样)，人们可能会对选择哪一个感到困惑。我在 LinkedIn 上的一个朋友 Randy Lao 分享了一个非常全面的数据科学资源列表，这些资源会定期更新。

我认为有用的其他学习平台或资源包括:面向数据科学的QuoraDZoneKD nuggetsAnalytics vid hyaDataTau

建立投资组合

有一个文件夹来展示你的经验和能力，特别是当你没有成为数据科学家的博士学位的时候。

由于我拥有物理学学士学位，没有任何计算机科学学位，我在大学的前三年也没有任何相关的接触，所以除了从 MOOCs 学习广度主题之外，建立我的投资组合是必要的。这很重要，因为归根结底，公司想知道你学到了什么，以及你如何为他们的业务做出贡献和增加价值。

这也是我一边杂耍兼职实习，一边向 MOOCs 学习的原因之一。此外，我也是数据组织的志愿者，通过帮助其他非政府组织解决他们的问题来最大化社会影响。

我一直想参加 Kaggle 比赛，不久前，我有机会和我的朋友在 Kaggle 上参加了由 Shopee 和工程技术学院(IET)组织的机器学习挑战赛。我真的很感激成为这个团队的一员，我确实从他们身上学到了很多。一定要查看一下他们的简介——【低伟鸿】钟可欣凌薇！

这是我第一次参加 Kaggle 比赛，学习如何使用卷积神经网络(CNN)和转移学习进行图像识别。学习曲线很陡，但这个过程绝对是值得的！期待在下一篇文章中与你分享更多关于我们比赛的项目！

如果时间允许，我也希望在我未来的帖子中与大家分享我的一些实习项目，代码将上传到 GitHub 上。

最后的想法…

选择一份你热爱的工作，你这辈子一天都不用工作

目前就这些。我希望我确实给数据科学行业带来了一些启示，并使对数据科学的学习不那么可怕，而是更有趣、更平易近人！我从来没有发现“ 我学得越多，我就越需要学习 ”的感觉，直到我遇到了给我挑战和成就感的数据科学。

我希望通过记录我的学习旅程，这篇文章可以在某种程度上激励你去追求你的激情，尽管有挑战和困难的环境。

感谢你阅读这篇文章。这是我的第一篇文章，如果您能留下您的反馈和意见，告诉我如何进一步改进内容，我将不胜感激。我将在未来创造更多关于我的经历和项目的帖子。

如果您有任何问题，请添加我，我们在 LinkedIn 上聊天，或者访问我的个人网站了解更多信息:

关于作者

****Admond Lee 目前是东南亚排名第一的商业银行 API 平台Staq—的联合创始人/首席技术官。

想要获得免费的每周数据科学和创业见解吗？

你可以在 LinkedIn 、 Medium 、 Twitter 、脸书上和他联系。

**** [## 阿德蒙德·李

让每个人都能接触到数据科学。Admond 正在通过先进的社交分析和机器学习，利用可操作的见解帮助公司和数字营销机构实现营销投资回报。

www.admondlee.com](https://www.admondlee.com/)****

我的数据科学之旅

原文：https://towardsdatascience.com/my-journey-into-data-science-39e9bbbbf452?source=collection_archive---------2-----------------------

很多人问我关于我从化学工程转到数据科学的问题。我是怎么做到的？我什么时候做的？我为什么要这么做？我觉得今天(2018 年 1 月 6 日)是回答这些问题的合适日子，因为这是我报名参加第一门编程课程以来的第三个年头。我希望分享我的故事会让我对成为一名数据科学家有所了解，并鼓励各地崭露头角的“任何事情”去强烈追求他们的激情。

我第一次接触数据科学是从一本与数据科学毫无关系的书中

2014 年 3 月，我偶然发现了一本名为《习惯的力量:为什么我们在生活和商业中做我们所做的事情》的书，作者是 Charles Duhigg。在名为组织的习惯的书中，Charles 写道，一家大型零售连锁店利用女性顾客购买的数据来预测她怀孕的可能性。说得轻一点，我很震惊，我必须了解更多。

我到处寻找这个魔法的名字。几个月后，在朋友的帮助下，我偶然发现了一些与我在*习惯的力量中读到的非常相似的东西。*它被称为商业分析。

这个发现对我来说是一个转折点，因为那时，我正处于大学的最后一年，刚刚结束在一家石油和天然气公司的实习。我在那里的经历让我厌倦了把化学工程作为职业，因为我觉得它不适合我。这种认识也让我对新的挑战和职业方向持开放态度。商业分析似乎正好符合这一点。

我从 Quora 上的一个回答中创建了我的第一个数据科学学习路径

到了 2014 年，我已经毕业，开始了我的国家青年服务团。在我的 NYSC 期间，我在 Twitter 的推荐下偶然发现了 Quora，我很喜欢它。

如果你想知道，理想情况下，NYSC 是尼日利亚为期一年的强制性项目，你被部署到一个你不隶属的州，以政府工作人员、教师或其他任何身份服务。

在 Quora 上，我发现商业分析有很多名字，其中一个是数据科学。我还找到了一个非常有帮助的答案，我今天推荐给任何希望成为数据科学家的人: 我如何才能成为一名数据科学家 ？

这个答案帮助我在 2015 年 1 月走上了第一条数据科学的学习之路(请原谅我糟糕的书写)。

Written January 2015. Other courses on the left side of the page are The Analytics Edge and Google Analytics

我在一年内完成了 15 门数据科学的 MOOCs 课程

我主要通过在线课程学习数据科学。我从来没用过书(我试过)。所有的课程都是免费的(因为我不在乎证书),在不像 Coursera 那样免费的地方，我得到了 100%的经济资助。

当谈到在线课程时，我吻了很多青蛙，所以如果你正在寻找一个关于如何开始数据科学的松散指南，我会帮你减轻压力，只关注有价值的课程。

1。学习编程

这是我学习道路上的第一件事，也是最可怕的一件事。这很可怕，因为我没有计算机科学背景，我在大学唯一一次接触编程，我绝对讨厌它。然而，这一次我觉得我拥有世界上所有的时间，没有什么可失去的，所以我报名参加了 Codecademy 的 学习 Python 课程。

这门课太难了，很多内容对我来说没有意义。我可能花了两周的时间试图让 while 循环工作，我不知道文件 I/O 是什么意思，但完全靠蛮力，我完成了课程。

这是我第一次完成一门在线课程，之前我已经尝试过无数次了。这给了我继续学习的信心。

2.学习核心数据科学

很多人问我为什么选择使用 R 而不是 Python。纯属巧合的是，我第一次接触数据科学是在 R 上 edX 上麻省理工学院的一门名为The Analytics Edge的课程。

为期 10 周的课程采用案例研究的方法来教授数据科学的不同部分，从机器学习到可视化，再到使用 r 进行优化。这非常费事，也非常值得。我在这门课程上的奇妙经历让我比 Python 更倾向于 R。这门课程给了我很好的基础，我有时仍会参考 2015 年的笔记。

3.其他有用的课程

我喜欢的另一门课是 2015 年底上的，是 Coursera 上杜克大学的 数据可视化与 Tableau 沟通。这是一门为期五周的课程，为使用 Tableau 打下了良好的基础。导师很厉害，也是我目前接触过的最好的。

我名单上的下一个是杜克大学 Coursera 上的 用 MySQL 管理大数据。这是一个为期四周的课程，与 Tableau 课程有着相同的令人惊叹的导师，教授 MySQL 和 Teradata。

其他值得一提的还有:UCBerkeley on edX 上的用 Apache SparkT5【四门课程系列】介绍 BigData 以及微软 on edX 上的 Excel 进行数据分析和可视化 。

我如何开始我的博客——真正的学习从哪里开始

如果你读了很多 Quora 上关于如何成为更好的软件工程师/数据科学家/设计师之类的回答或文章，你会看到一个反复出现的建议:做个人项目来深化你的技能。2015 年，我曾几次试图这样做，但我没能做任何合理的事情，因为坦率地说，我还没有准备好。

到 2016 年，我已经放慢了在线课程的速度，因为 90%的课程都有相同的内容，并且假设你是初学者，所以它变得有点重复。这时，我觉得我已经准备好开始用博客做个人项目了。写作部分不是问题，因为我以前在高中时写作。然而，我的问题是关于一致性和创造性。我有足够的创造力来组织有趣的项目吗？我能坚持不懈地做下去吗？你不试就永远不知道，对吗？这就是我如何在 2016 年 6 月开始我的博客数据的艺术和科学。在为我的博客撰写内容的过程中，我的知识成倍增长。

我在一个月内写完了前两篇文章，然后中断了一年

我的第一篇帖子是 2016 年 9 月发布的 预测英超积分榜 以及 2016 年 10 月发布的Twitter 对尼日利亚网络提供商的看法。积极回应的数量绝对令我震惊。我在这两个帖子上得到了大约 1500 次浏览和无数回复，这是我第一次对自己的技能感到自信。

这段经历让我明白，创造力不是你要么有要么没有的天赋。创造力来源于经验和对技能的信心，因为你知道的越多，能做的事情的可能性就越大。

然后我在博客上停了一年。发生这种情况有很多原因。

我曾试图在 2016 年 12 月写一篇博文，那是一片混乱。我后来清理了它，并在名为 数据科学的 ABC-XYZ的机器学习和数据科学研讨会上为我的女性使用。
在那之后，我遇到了我称之为“数据科学家的障碍”。我真的没有想法，想不出任何有用或有趣的东西。
我的博客与大多数数据科学博客有所不同，因为我的博客包含了大量的研究和迭代。也让我的出版周期比别人长很多。
工作很累人，成年也在折磨着我，所以我成了一个电视迷。

2017 年 6 月，我终于有了一个关于亿万富翁的想法，在我朋友的帮助下，我于 2017 年 10 月出版了 ，这是一个数据驱动的指南，旨在成为一个持续的亿万富翁 (是的，我花了四个月才完成)。

发布三天之内，它就有了 3 万的浏览量。到处都是。相当多的网站抄袭了这篇文章，但我不在乎。我的作品好到可以被抄袭！

目前为止我的小胜利

**除了我的帖子 (一个关于成为持续亿万富翁的数据驱动指南 ，到目前为止已经获得了 4 万次浏览，2017 年对我来说是有趣的一年。第一次，我过去三年的工作得到了认可。

我赢得了一个联合国数据可视化竞赛，我的可视化表格是“可视化疟疾:黑仔病杀死非洲”，看起来像这样。

One of the dashboards from the visualization story

2.我受邀在 T21 举行的斯坦福大学数据科学女性大会上发言，主题与本文完全相同。

3.我在伦敦找到了一份工作，在安永(Ernst & Young)担任数据科学家，最近搬到了世界各地。

4.2017 年 11 月，我在机器学习和数据科学领域的女性组织了一场研讨会。

老实说，我有点惊讶我能走到这一步。我记得在我的记事本上写道“玫瑰花蕾，你永远都配不上这个”，但我现在在这里。我还有很多东西要学，但我也很感激我今天所处的位置。

我给你的建议

我不是专家，我也不是约翰·麦克斯韦尔，他给了我一些自助建议，但这里有几件事真的帮了我。

不要害怕放弃那些没有成功的事情。直到 2016 年，我才完全放弃了石油和天然气的梦想，尽管我知道自己并不热衷于此。
不要害怕被称为疯子。我数不清有多少次人们微妙地或不那么微妙地告诉我，我离开化学工程是疯狂的，尤其是当数据科学在尼日利亚相对较新的时候。它曾经打动过我，但现在我微笑着对自己说“当我吹的时候，你会明白的”。
****阅读。阅读。阅读。给我打开这个领域的书，和数据科学一点关系都没有。阅读拓展了你的可能性领域。
****爱学习。每年都有学习目标，坚持一种最适合自己的媒介(书籍/音频/视频/教室)。
永远，永远把你最好的一面展现出来。让你的工作成为最好的工作。它会替你说话。我今天得到的 99%的机会，部分是因为我的博客。
最重要的是，你不是一个孤岛。拥有一个紧密团结的支持系统，即使受伤也会告诉你真相。你会更好的。

祝你好运:)

我要特别感谢我出色的支持系统和所有让我来到这里的人。不胜枚举，但我非常爱你们。我要特别感谢鸢、迪顿和奇迹，感谢他们的支持、严厉的爱、残酷的反馈，并告诉我应该在哪里加撇号。你从第一天起就在那里。你知道我所有的挣扎。你从一开始就看到了我，并且仍然相信我能做到。感谢你让我成为了一个更好的数据科学家，一个更好的人。我不会拿你来交换这个世界。

我的数据科学之旅

原文：https://towardsdatascience.com/my-journey-into-data-science-ac1d2e09ed03?source=collection_archive---------4-----------------------

欢迎来到我的博客！

在这里，我将发布一些我一直在从事的数据科学和机器学习项目。写这个博客的主要动机是，我很快就要开始快速人工智能深度学习课程了。在讲课的同时写博客对我来说似乎是一个很好的机会，让我可以真正接触到材料，并结识其他学生。首先，让我简单介绍一下我进入数据科学之旅的背景。

大约一年前，我开始写我的工商管理硕士论文。除了这个硕士学位，我还开设了第二个营销传播硕士学位。此时，我已经完成了所有的课程，最后不得不开始写这两篇我一直拖延的硕士论文。我的学士学位论文的出发点是音乐行业的社交媒体策略。我在界定研究范围方面遇到了一些问题，也不太确定我到底想研究什么，直到我看到一篇改变了我论文方向的论文。

那篇论文是 Asur 和胡伯尔曼(2010)的《用社交媒体预测未来》。作者使用了一个简单的线性回归模型，其中包含推文数量和情绪的时间序列(以及电影播放的影院数量)。有了这个简单的模型，他们能够比好莱坞证券交易所更准确地预测电影在第一个周末的票房收入。我发现对 Twitter 数据的简单分析具有如此强大的预测能力，这非常令人着迷。读完这篇论文后，我终于有了研究的方向:社交媒体的预测能力。

Entering the Data Science journey

我很快意识到我需要更复杂的工具来执行分析，尤其是我想要做的情感分析。我的导师建议我去见一位计算机科学老师，所以我去了。然后这位老师问我最喜欢的语言是什么…我回答是英语。是的……这可能是你能给这个问题的最痛苦的答案了。虽然回过头来看我可以嘲笑它。这个例子显示了我是多么的无知。我不知道我要面对的是什么。

在接下来的对话中，这位老师给了我一种非常消极和批判的感觉。他显然认为我永远不会编程，更不用说做我的 Twitter 分析了。我总是被那些认为我做不到的人激励着，这次也不例外。我在 R 里面找到了一个做情感分析的包，于是，我做了我该做的事情:我开始学习 R，让我惊讶的是(当时)我认识的计算机专业的学生都没有和 R 一起工作过，我找到了一个有 R 课程的网站，开始尝试。这个网站是 DataCamp，如果你想学习数据科学的 R 或 Python，这是一个非常棒的平台。令我自己惊讶的是，我对编程的喜爱远远超过了我的预期。更令人惊讶的是，我有这方面的天赋！

接下来的几周，我花了很多业余时间参加 DataCamp 的课程，为论文的数据分析部分做准备。在编程、导入、清理、可视化和统计课程之后，我觉得自己已经准备好了。在我哥哥的帮助下，我们建立了 Twitter 流媒体 API，并开始在 MySQL 数据库中收集推文。当然，与课程中呈现给你的数据集相比，在使用“真实”数据集时，你会遇到许多问题。因此，这篇论文成为我的第一个数据科学项目，也是一次非常宝贵的学习经历。去年 12 月，我完成了这项研究。这是最后一篇硕士论文的链接(我可能也会写一篇关于这项研究的博客):http://essay.utwente.nl/71482/

这项研究的重点是使用 Twitter 来预测 Spotify 新发布专辑的流量。我的一位老师在一次会议上认识了 Spotify 的一位大数据工程师(目前是 Spotify 的数据工程总监)。他非常友好地询问了多名 Spotify 员工的反馈，我收到了来自 Spotify 的巨大回应！这些机会是你除了万分感激之外什么都不能争取的。这只发生在我的第一个数据科学项目之后！不幸的是，我还不能在 Spotify 开始工作，因为我还必须为我的另一项研究写第二篇硕士论文。我决定将这篇硕士论文与我目前正在做的毕业实习结合起来。

在写第一篇硕士论文期间和之后，我参加了更多的在线课程，我想提供一些概述。也许他们可以给其他一些有抱负的数据科学家一些启发。我在第一篇论文中遇到的主要问题之一是无法使用机器学习算法。我一直在阅读他们如何在情感分析上比“词典”方法表现得更好，但我还没准备好使用它们。这为我的数据科学之旅提供了下一步:机器学习！以下是我参加过的数据科学/机器学习课程的概述:

机器学习 (Coursera —斯坦福大学)【https://www.coursera.org/learn/machine-learning】T4

每个人都会向你推荐的机器学习入门课程。这门课的确很棒，它对主要的最大似然算法及其背后的数学原理提供了很好的概述。对我来说，唯一的缺点是在练习中使用了 Octave/MATLAB。

用于数据科学和机器学习的 Python(Udemy)https://www . Udemy . com/Python-for-Data-Science-and-Machine-Learning-boot camp/learn/v4/overview

真正让我开始接触 Python 的课程。非常清晰地解释了数据科学和机器学习的不同概念。本课程将使您掌握流行的用于机器学习的 scikit-learn 库。还包括对 Spark 和 TensorFlow 的介绍。

完成 SQL boot camp(Udemy)https://www . Udemy . com/the-Complete-SQL-boot camp/learn/v4/overview

一个数据科学家需要有更多的工具，而不仅仅是 R 和 Python 编程。SQL 是另一种重要的语言，您将经常使用它与数据库进行交互。这门课程帮助我获得了目前的实习机会，并在两天内教会了我所有需要了解的 SQL 知识。

Tableau(Udemy)https://www.udemy.com/mastertableau/learn/v4/overview

Tableau 是另一个你会经常在数据科学相关的职位空缺中看到的工具。它与我习惯的编程语言非常不同，而是使用拖放界面。Tableau 非常适合可视化您的数据和构建交互式仪表板。

数据营(www.datacamp.com)

DataCamp 提供 4-6 小时的短期课程。这些课程以简短的解释视频为特色，之后你将通过练习应用视频中的原则。DataCamp 的伟大之处在于一切都发生在你的浏览器中，所以你不需要安装任何东西。这使得 DataCamp 成为 R 和 Python 编程的完美入门。当我开始使用 DataCamp 时，他们几乎只提供 R 课程，但他们一直在以非常高的速度增加 Python 课程。以下是我在 DataCamp 上完成的所有课程的概述。

R 课程(共 15 门):

R 简介
中级 R +中级 R 实践
用 R 编写函数
将数据导入 R
正在清除 R 中的数据
用 dplyr 实现 R 中的数据操作
使用 ggplot2 实现数据可视化
统计学导论:导论，学生的 T 检验和方差分析
用 R Markdown 报告
机器学习导论
文本挖掘:词汇袋
使用 RStudio IDE

Python 课程:

面向数据科学的 Python 简介
面向数据科学的中级 Python
Python 数据科学工具箱
Python 中的深度学习

最后，我非常兴奋即将开始深度学习的快速人工智能课程(http://course.fast.ai/index.html)。本课程最初是在旧金山大学数据研究所开设的。令人欣慰的是，作者们也非常好心地创建了该课程的 MOOC 版本。深度学习一直在现有数据集上不断突破其他 ML 算法的性能天花板。对于像图像识别、语音识别、自然语言处理和时间序列预测这样的任务，我已经迫不及待地开始深度学习了！

希望我的故事也能给其他人最后一次推动，让他们去研究数据科学。你目前所学的或者你是否有“阿尔法”背景并不能决定你能走多远。我花了四年多的时间在我的大学里学习，最终找到了我真正受到启发的东西。MOOCs 和不同的在线资源提供了学习和使用它们的绝佳机会！如果你努力工作，并愿意为此付出时间，你就能取得伟大的成就。数据科学需要大量的实践和拥有许多不同技能的大型工具集。你什么都不做是不会掌握这些的。然而，如果你想得到它，你应该全力以赴，永远不要因为你“需要一个计算机科学学位”而让自己止步不前！

好了，今天对我来说这是足够的鼓舞人心的谈话。不要害怕关注我或给我发消息。回头见:)

你也可以在这里找到我:

领英:【www.linkedin.com/in/rutger-ruizendaal

【2017 年 9 月更新

这里有一个快速更新:我现在已经结束了我的实习，我的第二个硕士毕业了！10 月份，我将开始成为一名数据科学家。终于有了正式的‘头衔’感觉太棒了。有趣的是，作为一名数据科学家，我现在已经获得了工商管理和通信研究两个硕士学位。你真的永远不知道生活会带你去哪里。我也完成了 fast.ai 深度学习课程的第 1 部分。第 2 部分最近已经上传，我迫不及待地想开始了:)

参考文献

阿苏尔和胡伯尔曼，文学学士(2010 年 8 月)。用社交媒体预测未来。在Web Intelligence and Intelligent Agent Technology(WI-IAT)，2010 IEEE/WIC/ACM 国际会议上 (Vol. 1，PP . 492–499)。IEEE。

我的数据科学和生物信息学之旅—第 1 部分:编程

原文：https://towardsdatascience.com/my-journey-into-data-science-and-bio-informatics-749ece4d8860?source=collection_archive---------2-----------------------

"算法是新药，医生是新技术的处方者." — 休·哈维，放射科医师

根据 IBM 的调查，每天产生 250 万兆字节(10 ⁸)的数据(平均每台电脑只能容纳 1 兆字节)。现有数据的 90%是在过去两年中生成的。此外，预计这一增长将继续加速。这导致了数据处理和解释滞后的瓶颈。面临这些问题的不仅仅是推特、脸书、谷歌和网飞。生物医学、生物学、物理学、制药……也面临这个问题。

为了进一步说明这个问题，单个全基因组测序的大小可能是数百千兆字节(外显子组和 RNA 大约是 100 千兆字节)。小 100 倍)。处理如此大量的数据需要一套特定的技能。这就是生物信息学的用武之地。

背景

整整一年前，我从未执行过一行代码。因此，我绝不是数据科学家或生物信息学专家，但我也不是一个完全的初学者。

去年我在做关于全基因组测序的硕士论文时熟悉了数据科学和生物信息学，突然面临一个问题:我必须打开一个 3 300 000 行 40 列的. csv(逗号分隔值)文件。不用说，Excel 过得并不愉快。在尝试使用 Excel 或其他程序但毫无结果之后，我意识到我必须使用命令行，这是我从其他领域的朋友那里听说的。从那以后，事情自然就演变到了我今天的位置。

我学到的几乎所有东西都要感谢朋友、同事和导师建议的探索主题。实际的学习是通过辅导课、博客帖子、互联网上的大规模开放在线课程(MOOCs)的帮助，或者通过谷歌搜索我遇到的具体问题，因为我没有时间获得额外的硕士学位。

但我面临的问题是，几乎每个主题都有数百门课程。这将是一篇由 2 或 3 部分组成的博客，第一部分是关于编程的，侧重于资源和我参加的推荐课程(免费或以很低的价格)，考虑的是绝对的初学者。第二部分将更加面向生物信息学(DNA 和 RNA 测序)，重点是关键的期刊文章，但也有其他在线资源和常用工具。

Bash 和 Linux

安装 Linux

如果你有一台 Mac，你可以打开终端，运行任何 bash 命令，没有任何问题。对于 Windows 用户来说，这并不容易。你必须安装 Linux，一个不同于 Windows 的操作系统。Linux 有许多版本，其中 Ubuntu 是最流行的发行版。

对于想要尝试 Linux 的绝对初学者，建议使用虚拟机。虚拟机不会有太大的问题，它在 Windows 中运行 Ubuntu。查看这本指南了解更多信息。
双引导有点复杂，你把 Ubuntu 安装在 Windows 旁边。小心，你可以用这种方法删除你所有的数据。如果对电脑了解多一点的话推荐。查看这份指南。
Windows 10 上的 Ubuntu 是大约一年前的新特性。与虚拟机或双引导相比，这似乎是一个更优雅的解决方案，但我没有尝试过，我不知道它在更高级的工作中表现如何。

尝试

一旦启动并运行 Linux，打开终端(或者直接在 macOS 上打开终端)，就可以在 Bash 命令语言/shell 中输入命令。

The terminal on macOS

Bash 是一种通用编程语言，在其上可以完成基本任务，在高性能计算(HPC)集群上运行程序。它也使得重复的任务变得更加容易和快速。这是一项基本技能，因为生物信息学社区开发的大多数工具都是由命令行控制的。

data camp 上的 shell for data science 简介从零开始，但是有非常好的例子说明 Bash 为什么如此有用。它也只有 4 个小时长。在进一步阅读之前，先从这里开始。

Python 和 R

在生物信息学中，几乎每个任务都可以用两种编程语言中的一种来完成:R 和 Python。Python 是一种通用的编程语言，在过去的几年里广受欢迎:

Source: stackoverflow blog

这种大规模增长的原因是 Python 易于学习&易于阅读，但它非常通用。Youtube 上有一个关于为什么 Python 是如此受欢迎的语言的精彩演讲，作者是杰克·范德普拉斯。简而言之，Python 可以做任何事情，从任务自动化的基本脚本，基本和高级统计，高级绘图到机器和深度学习&等等。有些人不喜欢 Python，但是我认为它不应该受到如此的讨厌。特别是对于初学者来说，Python 做了它需要做的事情，而不会让事情变得过于复杂。

r 是一种专门为统计和数据处理而构建的编程语言，这与 Python 形成了鲜明的对比，Python 在其基础上构建了数据科学库。在过去的几年中，R 被生物信息学社区采用为发布新包的头号编程语言，部分原因是因为 bioconductor (用于下一代测序分析的成熟库集合)和用于高级绘图的 ggplot2 库。有些人喜欢用 Python 进行数据清理，用 R 进行数据操作，但是 R 几乎可以做 Python 能做的任何事情，比如统计，甚至更多。我对 R 的唯一问题是有时不直观的语法。 Tidyverse (dplyr、tidyr、ggplot2、…)中的包提供了一个优雅的 R 工作流，明确关注数据清理、探索和可视化。

计算机编程语言

因为 Python 是如此多才多艺，当你第一次接触它时很容易被淹没。推荐的资源和课程:

Charles Severance 的《Python 为 Coursera 上的每个人》。课程材料也可以在 py4e.com 的找到(如果你按照的手册一直到第 11 章，你就为接下来的内容打下了坚实的基础)。如果你阅读编程方面的书籍，请确保你的笔记本电脑就在你身边，以便键入和执行书中的命令！我再怎么强调这一点也不为过，仅仅读一本书是不够的。最重要的是，做运动。你通过失败和搜索解决方案来学习编程。
Wes McKinney 的《用于数据分析的 Python》是一本很好的参考书，但我个人更喜欢通过讲座/视频来学习。
这让我想到了这篇博文，推荐何塞·波尔蒂利亚/Udemy 的 Python 用于数据科学和机器学习训练营。这是一门很棒的课程，我怎么推荐都不为过。它的星级为 4.6，拥有 80，0 00 多名学生。这本书基本上是由韦斯·麦金尼(Wes McKinney)编写的，包含 21 个小时的视频讲座和真实世界的练习。不要支付超过 15 欧元，Udemy 有频繁(如果不总是)的折扣。
Enki 是一款用于智能手机的应用程序，每天花 10-15 分钟修改 Python 和其他编程语言，这有助于将最常用的代码保持在记忆中。

稀有

我犯了一个错误，试图把 R 作为我的第一门编程语言来学习。如果你以前从未编程过，先学习 Python，R 作为编程语言会更有意义。

Roger Peng 在 Coursera 上的 R-programming 是我上的第一堂关于 R 和编程的课程。一门非常好的入门课程。然而，在第二周之后，难度会急剧增加，这也是我建议从 Python 作为你的第一语言开始的主要原因。本课程也没有很好地涵盖绘图，也没有关注清理数据/数据科学。它也可以作为好书使用，可以与之前提到的 Python For Everybody 手册相媲美，涵盖了 dplyr。花点时间仔细阅读，你就会对 R 是什么以及它的核心是如何工作的有一个坚实的基础。
漩涡是一个在运行 R/R-studio 时学习 R 的 R 包。没有视频的，纯文字的。在写这篇博文的时候，我重新发现了它。强烈建议您掌握基本概念，这也是 R 编程 Coursera 课程的一部分。几乎涵盖了一切。
数据科学和机器学习训练营是何塞·波尔蒂利亚的数据科学课程的 R 版本。我更喜欢 Python 课程，因为该课程更详细地介绍了这些主题。然而，它值得一读，因为它涵盖了 ggplot2、dplyr、tidyr，并且对如何使用 R 进行机器学习有一个总体介绍。如果你觉得太容易(特别是如果你学了 Coursera 课程)，在 Python 课程之后再学，以 2 倍的速度浏览前几章。

乳液

你花了多少时间来调整 Word 文档的布局，直到它变得完美，才注意到你做了一个小调整，然后一切又都错了？这就是乳胶的用武之地。来自官方文档:“LaTeX 基于这样一种理念，即最好将文档设计留给文档设计者，让作者继续编写文档”。

LaTeX in a nutshell

缺点是 LaTeX 的学习曲线几乎是垂直的。但是一旦你掌握了基础知识(在 ShareLaTeX 上有很好的介绍)，这实际上比用 Word 写文档要有趣得多。对于非常短的文档，我仍然更喜欢 Word，但是对于超过几页的文档，LaTeX 是无与伦比的，尤其是与作为参考管理器的 JabRef 结合使用时。

一个缺点是，一个包含所有包的完整的 LaTeX 安装会变得非常复杂和耗费资源。与多个人合作写作也不容易。背页(以及之前提到的 ShareLaTeX )是这两个缺点的解决方案:这是一种类似谷歌文档的协作写作方法，它在云中运行 LaTeX，使跨平台和跨机器写作变得轻而易举。多个日志(bioRxiv！)甚至支持直接通过背页提交。它是免费增值，高级版起价 12 欧元/月(学生减半)。

虽然 LaTeX 知识对于数据科学来说并不重要，它也不是真正的编程语言，但是如果您有几个小时的空闲时间，可以尝试一下。你以后会感谢我的。

未来展望

可复制软件

我注意到我花了相当多的时间让我的脚本恰到好处，但我在这里和那里做了一些小的调整。有些变化很难跟踪，例如，如果我想重新运行 3 个月前的东西。未来，我希望通过强调再现性来改进我的工作流程。

饭桶

Git 是一个版本控制系统，它使得在多人之间协调文件和版本变化成为可能。如果你犯了一个错误，导致整个程序崩溃，那么很容易回到以前的版本。我将使用数据营的课程作为指导。参见《公共科学图书馆计算生物学》中的利用 git 和 GitHub 的十个简单规则，了解为什么使用 Git 是个好主意的更多信息。

码头工人

Docker 是另一个迅速获得成功和流行的软件包。它是一种在计算机和服务器之间分发应用程序或其他程序的方法。它由类似于虚拟机的“容器”组成，但具有更好的可移植性和更轻的重量。容器映像是一个轻量级的、独立的、可执行的软件包，包含了运行它所需的一切:代码、运行时、系统工具、系统库、设置。

为什么学习这个是必要的或者有用的？嗯，如果你想与同事、朋友或在你的出版物中分享你制作的工具或程序，你会遇到这样的问题:你的程序依赖于不同的程序(例如特定的 Python 模块)，甚至依赖于特定的版本(例如 Python 3.5.2)。Docker 将您的应用程序与正确的依赖项捆绑在一起，这样最终用户就不需要担心安装特定版本的特定软件，可能会使他们计算机上已经存在的版本崩溃，并导致许多挫折和/或您的程序的不良采用。Docker 官方文档和关于 GitHub 的教程是一个很好的起点。

管道

管道是程序或脚本执行的特定顺序，将输出从第一个脚本“管道化”到第二个脚本。在下一代测序(NGS)中，这包括下载原始数据文件、质量控制、预处理、绘制参考基因组图谱和后处理，但在关于生物信息学的第 2 部分中对此有更多介绍。为了使这个过程自动化，可以编写一个“主脚本”,将所有这些不同的步骤组合在一个脚本中。在 Bash 中，这是可能的，但是对于复杂的管道，它的伸缩性不是很好。工作流管理软件有助于使您的管道具有可重复性和可扩展性。选项是无穷无尽的:

Luigi ，基于 Python 和 Spotify 开发的(！)，但现在也被 NGS 社区所采用(开源软件的力量)。SciLuigi 是 Luigi 的包装器，用于优化科学工作流程。
Snakemake ，也是基于开源和 Python 的。
下一个流程
WDL ，由远大研究所开发
鲁弗斯
b 管道

正如你所料，它们都有优点和缺点。浏览文档，在 Google 或 Stack Overflow 上搜索，找到最适合您需求的工作流管理软件。关于 bash、make Nextflow、snakemake 的详细介绍请点击。

结论

这篇相对较短的博文中的内容会让你忙碌 200 多个小时。它为你需求领域的进一步专业化打下了坚实的基础。如果你不得不做一个重复的特定任务，有一种方法可以用 Python/Bash 或 r 来实现自动化。从快速的 Google 搜索开始，99%的情况下有人试图做类似的事情，并且会在 Stack Overflow 或另一个论坛上询问。借助本页链接中的技能和知识，您将能够理解语法并根据您的要求修改和调试它。也有其他的编程语言，比如 NCBI 作为通用语言使用的 perl ，以及用于文本处理的 awk / sed 。然而，对于 Python/R 组合，您应该已经准备好了，以后如果您真的需要它们，您可以探索它们。

请记住，除了这里列出的，还有很多非常好的编程和数据科学课程(例如data camp 上的这个 67 小时 Python 课程看起来很有前途)。帖子里的只是我拍的，我个人喜欢和推荐的。大多数也是免费的，只是尝试一些，如果不适合你的个人需求，就转移到下一个。

祝你好运！

我想感谢我在这篇博文中提到的每一个人，以及以各种方式帮助我的导师、朋友、同事和其他人。

如果你喜欢读这本书，如果你把它推荐给你的朋友和同事，或者在脸书的推特上分享，那会很有帮助。

关于作者:

我是 Ruben Van Paemel 博士，2017 年从医学院毕业后，开始在根特大学(医学遗传学中心)担任博士研究员，由研究基金会 Flanders 资助。我也是根特大学医院的儿科住院医师。可以在 Twitter 关注我:@ RubenVanPaemel

我从事神经母细胞瘤的研究，这是一种罕见但极具破坏性的肿瘤，最常见于非常年幼的儿童。我们的团队试图了解潜在的基因改变，以提高神经母细胞瘤儿童的诊断、治疗和最终存活率。大数据和现代测序技术让我对编程、生物信息学、统计学和人工智能产生了兴趣。

我的数据科学和生物信息学之旅:第 2 部分——测序速成班

原文：https://towardsdatascience.com/my-journey-into-data-science-and-bioinformatics-part-2-34e55d8594d7?source=collection_archive---------2-----------------------

这部分需要一些分子生物学和遗传学的基础知识。这篇文章主要是关于测序技术的基础知识，面向具有生物医学背景的人，医学学生和临床医生。如果你对 DNA 知之甚少或者想更详细地了解基因组和 DNA 测序的历史，我推荐你阅读悉达多慕克吉 。

人类基因组是一件非常不可思议的事情。想象走进一个巨大的图书馆。这里有成千上万个书柜，每个书柜总共可以容纳大约 130 本书。你打开一本书，你看到的只是四个字母:A、C、G 和 t。所有这些书中的信息足以建造一个最复杂的生物，一个人。

当这些书中的字母被弄混，或者当章节或书籍在书架中被打乱时，遗传病就开始了。有时只有一个或几个字母是错误的或丢失的，但这可以对那本书的故事产生重大影响。

要知道书柜中的错误在哪里，你可以将它与你认为没有错误的其他书柜(“参考基因组”)进行比较(这里有点棘手:什么被定义为“正常”？).用手找到这些字母是不可能的。幸运的是，我们发明的电脑在比较这两个书柜时要好得多。生物信息学处理与处理所有这些信息相关的一切，因此我们可以从中得出结论。

正如我在关于编程的第一部分中解释的那样，我在做关于全基因组测序的硕士论文时了解了所有这些(就复杂性而言，我非常低估了这一点)。这篇文章将简要介绍不同的测序技术。下一部分将深入探究其背后的实际生物信息学。

一点历史

“实验进展缓慢，”孟德尔写道。“起初需要一定的耐心，但我很快发现，当我同时进行几个实验时，事情会变得更好。随着多个交叉并行，数据生产加速。”悉达多·慕克吉引用了孟德尔在 19 世纪关于植物的实验。

自从大规模并行测序(MPS，也称为下一代测序，NGS 或高通量测序，HTS)的出现，由于新的和指数级增长的需求，生物信息学领域发生了彻底的变革。

但是首先，先回顾一下测序的历史。我们如何阅读书中的字母？

桑格测序

弗雷德·桑格和他的同事在 1977 年开发了一种 DNA 测序方法，后来被称为“桑格测序”或“链终止测序”。这个视频把题目解释的非常清楚。

与书柜类似，桑格排序将是一页接一页地复制每本书。

Sanger 测序是 40 多年来最流行的测序方法，直到它被大规模平行测序(MPS)和本世纪初超越。Sanger 测序的缺点是速度慢(每次运行 96kb，而 MPS 每次运行 1–150 Gb 以上)且成本高。今天，它仍被用于某些领域，以验证多磺酸粘多糖或以非常高的精确度对非常小的 DNA 片段进行测序(遗传病中的基因)。

大规模并行测序

然后，在 2003 年，人类基因组计划完成。这项艰巨的任务历时 15 年，耗资数十亿美元。今天，我们可以在一天多一点的时间内，花费不到 1000 美元，完成一个完整的人类基因组测序。那么发生了什么？

Cost per genome. The sharp decline around 2007 is due to the rise of massively parallel sequencing. Source: genome.gov

2005 年，第一台用于“大规模并行测序”的机器由 454 推向市场，称为焦磷酸测序。我不会详细说明确切的机制，但主要思想是 DNA 被分裂成数百万个小片段。所有这些小片段同时被测序，这比一个接一个地对所有这些小片段进行测序快得多。

再把这个和我们的书柜比较一下。你很快就会意识到，一页一页地复制所有的书将会花费很长时间。于是你决定带几个朋友，把书分好，这样每个人都有自己的书架可以抄。大规模并行测序就是这样，但你带来的不是几个朋友，而是整个村庄。

焦磷酸测序法仍然没有足够的通量来进行常规的全基因组测序。如今，最广泛使用的测序技术是 Illumina 的“合成测序”(见下面的视频)。Illumina HiSeq 4000 可以在 3.5 天内对多达 12 个人类基因组进行测序！

Sequencing-by-synthesis by Illumina

下一步是什么？

很难预测未来，但对我来说，最近的一项发展正接近科幻小说:

Picture by my colleague, Celine Everaert on Twitter (@celine_everaert)

这个设备被称为小程序。这是一个 1000 美元，比 u 盘大一点(它甚至可以通过 USB 连接到你的笔记本电脑)，可以序列读取> 200 000 bp 长。相比之下:Illumina 测序仪的最大读取长度为 300 bp 长。Illumina MiSeq 是一台具有类似生产能力的笨重机器，而的价格为 99 000 美元。

有了 MinION，就有可能在没有 PCR 扩增的情况下，用一种称为“纳米孔测序”的技术实时对 DNA 和 RNA 进行测序(视频介绍其工作原理)。实时长阅读测序也被称为“第三代测序”，大规模平行测序的继承者。

然而，这是一项早期技术，所以它不像 Illumina 系统那样得到广泛支持。我们目前正在实验室进行测试，结果看起来很有希望。床边基因组分析的路还很长，但这是一大进步！

覆盖率和阅读深度

高通量测序中的一个重要术语是“覆盖”或“阅读深度”(有时也称为“深度”)。这是一个重要的术语，用来理解为什么有些实验是好的或坏的(永远不要在 30 倍覆盖率下进行全外显子组测序)，以及为什么有些技术比其他技术更贵或更便宜。

DNA 测序

单个核苷酸的覆盖范围或阅读深度(例如 30X)是该核苷酸在测序运行中被有效调用的次数。人类基因组的平均覆盖率为 30 倍，这意味着平均每个核苷酸被测序了 30 次。为什么这很重要？假设你只调用每个核苷酸一次。这样，你将永远无法说出这个位点是纯合子还是杂合子。如果你调用每个核苷酸两次，你可能会偶然得到两次相同的核苷酸(例如一个 T)。你会认为这是一个纯合位点(T/T)，而实际上它是一个杂合位点(例如 T/C)。增加你调用该碱基的次数会增加以该碱基的真实频率结束的几率(在种系杂合子的情况下为 50–50%，在嵌合体或癌症中的较小亚克隆的情况下为< 1–99%)。

增加覆盖率需要测序仪进行更多的读取，因此增加了你实验的价格。一个 60 倍平均覆盖率的全基因组测序实验的测序成本大约是 30 倍覆盖率的两倍。

RNA 测序

RNA 测序是不同的。在 RNA 测序中，通常使用总阅读深度(每个样品的阅读次数)来代替核苷酸水平的覆盖率。这是因为在 RNA 测序中，你最感兴趣的是基因表达。基因表达与该基因的阅读次数相关(RPKM，FPKM，TPM: 参见此处的解释)。

期望的读取深度取决于实验目标的 T2。对于高表达基因的快速快照，500-2500 万的总读取深度就足够了，而对于更全面的基因表达视图，需要 3000-6000 万次读取(高达 2 亿次读取)。

应用

大规模平行测序在全基因组测序后产生了一系列广泛的子技术，原因有两个:(1)降低实验成本和(2)不仅研究基因组，而且研究转录组、甲基组和其他“-组”。

2017 年是外显子组和靶向测序进入常规遗传诊断的一年。Wright 及其同事关于诊断罕见儿科遗传疾病的顶级综述可在此处获得，关于下一代测序的综述可在此处获得。两者都强烈推荐！

外显子组测序

虽然“垃圾 DNA”的概念已经被放弃，但大多数已知的遗传疾病仍然与外显子突变有关。仅对这些“相关”部分进行排序，可以大幅降低成本，并简化数据解释。基因组长 3 Gb，外显子组仅占总基因组的约 1% (30Mb)。

Probe-based capture of DNA. Image source.

****工作原理。在 DNA 测序之前，它被分割成小段。市售试剂盒含有数千个捕获探针(在 Illumina Nextera 试剂盒中为 429，826 个)，它们是与外显子或其他感兴趣区域互补的寡核苷酸。这些探针可以连接到(磁性)珠上。

当您将含有未捕获的 DNA 和与磁性探针杂交的 DNA 的混合物的试管放入磁场中并进行清洗步骤时，所有未结合到珠子上的 DNA 都会被洗掉。这样，只有外显子 DNA 保留在样本中。

与全基因组测序(WGS)相比，这有一些缺点。DNA 的捕获并不是百分之百有效的。它在外显子边缘的效率特别低，这就是为什么需要更高的平均覆盖率来可靠地检测变体(100-150 倍覆盖率而不是 30 倍)。结构变体、监管变体等将被遗漏。

也就是说，根据你对实验的期望，全外显子组测序(WES)可能是 WGS 的一种经济有效的替代方法。

靶向测序

靶向测序基本上是外显子组测序的精简版本(在 WES 中，你的外显子组是你的“目标”，在靶向测序中，目标是一个或几个基因)。它也是基于与你感兴趣的区域互补的探针的扩增或设计。

它允许以可承受的价格对基因组的小区域进行非常深入的测序(覆盖 1000-20000 倍)。

靶向测序在单基因疾病中可能是有用的(如罕见的囊性纤维化突变)，但对于这种桑格测序，或其他技术仍然很受欢迎。

RNA 测序

我在医学院上分子生物学的课是在 2010 年。那时候，很容易。有三种 RNA 以某种方式参与翻译:信使 RNA (mRNA)、核糖体 RNA (rRNA)和转移 RNA (tRNA)。如今，这个名单上有了更多的非编码 RNA(完整的名单在这里和在这里)。

****RNA 的富集。大多数时候，你对占总 RNA 80%的核糖体 RNA 不感兴趣。为了富集您感兴趣的 RNA，已经开发了一系列方法。在翻译之前，通过在 mRNA 的起始处添加一个 5’帽，在 mRNA 的末端添加一个 3’聚腺苷酸尾，并通过剪切掉内含子，将前 mRNA 加工成 mRNA。

mRNA processing. Source: Khan Academy.

Poly(A) selection 用 Poly(A)尾捕获 mRNA，耗尽样品中你不感兴趣的其他 RNA。然而，这也去除了没有 poly(A)尾的其它非编码 RNA 或 mRNA。另一种方法是 rRNA 去除，即在样品中留下非编码 RNA。

RNA 测序是如何工作的。你不能直接测序 RNA(实际上你可以，但这还不是主流)。这就是为什么如果你想进行 RNA 测序(也称为转录组测序)，你首先必须用逆转录酶(rt)步骤将 RNA 转化为互补 DNA (cDNA)。一旦你有了 cDNA，文库制备和测序就可以开始了。RNA 测序方法的广泛概述(超过 110！)可在 Illumina 网站上获得。

RNA-Seq. Two basic variations use either random primers or oligo(dT) primers for this reaction. Oligo(dT) primers are highly 3’ biased and mostly suitable for mRNA abundance (expression) analysis. Source: Illumina.

逆转录酶步骤并不是 100%有效的(像探针捕获一样),可能会给结果带来假象和偏差。此外，寡(T)引发偏向 3’端，随机引发会导致引物偏向。

RNA 测序正稳步增加其临床相关性。韦斯和 WGS 只能在高达 50%的情况下识别出罕见的孟德尔遗传疾病，而 DNA 某处变异的影响很难评估。将 WES/WGS 与 RNA 测序结合可以揭示异常剪接、表达减少和其他功能暗示甚至遗传性疾病或癌症中的基因融合。

甲基化测序

在过去的 10 年里，表观遗传学领域也有一个巨大的受欢迎程度激增。在基因启动子区域的胞嘧啶(5-甲基胞嘧啶)上添加甲基(CH3)基团可以导致 RNA 或蛋白质的表达减少，而不改变 DNA 的结构。如果 DNA 的结构没有改变，经典的 DNA 测序就不会发现。

Bisulfite sequencing. Image source.

一种解决方法是在测序前用亚硫酸氢钠处理 DNA。甲基化的胞嘧啶有一个“帽”来保护它们免受亚硫酸氢钠的伤害。未甲基化胞嘧啶缺少这个保护帽，被转化为尿嘧啶。所得产物的扩增将尿嘧啶转化为胸腺嘧啶。测序并与参考测序进行比较后，有可能鉴定哪些胞嘧啶最初是甲基化的，哪些不是。

结论

这是对测序历史和目前正在使用的测序方法的一个温和的介绍(还有很多，但我把这篇文章限制在最流行的)。正如我自己所经历的，在没有对测序如何工作有非常基本的理解的情况下，钻研使用高通量测序的综述论文或研究文章可能是令人生畏的。我希望这篇文章能为你提供进一步钻研文献的基础。如果你想进一步阅读，我在正文和下面的参考资料中提供了一些关键的论文。如果你正在寻找一个非常具体的测序方法的信息，最好是寻找原始出版物，看看在 Illumina 网站上是否有任何关于它的信息(例如芯片测序:这里和这里)。

我想感谢我在这篇博文中提到的每一个人，以及以各种方式帮助我的导师、朋友、同事和其他人。我与我提到的任何公司都没有任何关系。

如果你喜欢读这本书，如果你把它推荐给你的朋友和同事，或者在脸书的推特上分享，那会很有帮助。

关于作者:

我的名字是 Ruben Van Paemel 博士，我于 2017 年从医学院毕业后开始在根特大学(医学遗传学中心)担任博士研究员，由弗兰德斯研究基金会资助。我也是根特大学医院的儿科住院医师。可以在 Twitter 关注我:@ RubenVanPaemel

进一步阅读

一般

悉达多·慕克吉。基因:一段亲密的历史。在亚马逊上有售。

希瑟·JM，链 B. 测序仪的序列:DNA 测序的历史。基因组学。2016;107(1):1–8.doi:10.1016/j . ygeno . 2015 . 11 . 003

40 岁时的 DNA 测序:过去、现在和未来。天性。2017.doi:10.1038/nature24286

桑格测序法。 Youtube 。

大规模并行测序

Illumina。合成测序。 Youtube 。

Goodwin S .等时代来临:下一代测序技术的十年。 自然评论遗传学。 2016 年。doi:10.1038/人民币 2016.49

Illumina。RNA 序列阅读长度和覆盖范围的考虑。在Illumina.com有售

RNA-Seq 编码指南和最佳实践:2016 年 12 月修订。可用此处或此处。

纳米孔

牛津纳米孔技术。纳米孔 DNA 测序。视频。

Jain et al. 纳米孔测序和超长读数的人类基因组组装。 自然生物技术。2018.doi:10.1038/nbt.4060

Garald DR 等人在纳米孔阵列上进行高度平行的直接 RNA 测序。 自然战法。 2018。多元指数:10.1038

临床翻译

Wright CF 等儿科基因组学:诊断儿童罕见疾病。 《自然评论遗传学》。 2018。doi:10.1038/nrg.2017.116

基因测试:RNA-seq 的诊断能力。 《自然评论遗传学》。2017.doi:10.1038/nrg.2017.39

邱，陈，高 Y，等.通过母体血浆 DNA 大规模平行基因组测序对胎儿染色体非整倍体进行无创性产前诊断。 美国国家科学院院刊。2008;105(51):20458–20463.doi:10.1073/pnas

RNA 测序

可汗学院。真核前 mRNA 加工:5’帽和 poly-A 尾。剪接、内含子和外显子。

Illumina。RNA 序列阅读长度和覆盖范围的考虑。在Illumina.com有售

RNA-Seq 编码指南和最佳实践:2016 年 12 月修订。此处可用或此处可用。

RNA-seq 博客。RPKM，FPKM 和 TPM，解释清楚。在RNA-seqblog.com上可用。

RNA-Seq:转录组学的革命性工具。 自然评论遗传学。2009;10(1):57–63.doi:10.1038/nrg2484。

将 RNA 测序转化为临床诊断:机遇与挑战。 自然评论遗传学。2017.doi:10.1038/nrg.2016.10

基因家族:非编码 RNA。在GeneNames.org有售。

赖特兆瓦，布鲁福德 EA。命名“垃圾”:人类非蛋白编码 RNA (ncRNA)基因命名法。 人类基因组学。2011;5(2):90–98.doi:10.1186/1479–7364–5–2–90

Illumina。RNA 测序方法集:以 Illumina 技术为特色的近期 RNA-Seq 出版物概述。可在Illumina.com买到。

基因检测:RNA-seq 的诊断能力。 《自然评论遗传学》。2017.doi:10.1038/nrg.2017.39

我的深度学习之旅

原文：https://towardsdatascience.com/my-journey-into-deep-learning-c66e6ef2a317?source=collection_archive---------4-----------------------

在这篇文章中，我将分享我如何研究深度学习并使用它来解决数据科学问题。这是一个非正式的帖子，但内容有趣(我希望如此)。

一点关于我和深度学习

我来自物理和计算机工程。我在委内瑞拉学习了这两个专业，然后在墨西哥攻读了物理学硕士。但我认为自己是一名数据科学家。有趣吧？因此，尽管我在数学、微积分和统计学方面有着良好而广泛的背景，但开始机器学习和深度学习并不容易。

这个主题并不新鲜，但是我们研究它们的方式，我们如何构建使用它们的软件和解决方案，以及我们编程或与它们交互的方式都发生了巨大的变化。

我之前写了一篇文章，其中我谈到了深度学习的一些理论以及为什么它现在如此重要，但要再次说的是，使深度学习成为当前“炒作”的因素是几个简单但重要的算法改进的发展，硬件(主要是 GPU)的进步，以及过去十年中数据的指数级生成和积累。

我从哪里开始？

2012 年左右，当我在学习计算机工程时，我上了一堂关于人工智能的课(这是课程的名字)。当时我真的被这个题目弄糊涂了。我的意思是，我知道这很重要(当时“有原因”)，但这很奇怪。

我研究了专家系统、神经网络、遗传算法，并阅读了一些论文，其中两个我发现非常有趣的是:

计算机械与智能 艾伦·图灵著
创造力与人工智能 作者玛格丽特·博登

当我阅读这些论文时(我不知道机器学习的进展，甚至不知道它的存在)，我认为我们离实现真正的人工智能真的真的很远。我仍然认为我们并不像我们想象的那样亲密，有些事情我们必须弄清楚，但以后会有更多的。

所以，因为那时(22 岁)人工智能对我来说是一个失去的希望，我开始研究量子计算，对我来说它是人工智能之前的事情，当然我错了:

但是它对我来说真的很有趣，因为它融合了很多科学和工程。

我对人工智能的兴趣

那么回到人工智能和所有这些，发生了什么？为什么我现在对人工智能、机器学习、深度学习如此热情，而我确信我们离所有这些都很远？

发生在我身上的是阿帕奇火花和吴恩达。什么？

于是，2014 年(24 岁)，刚从物理专业毕业，正在做工程中黑洞模拟的论文，然后，嘣！我发现了 Coursera、机器学习、吴恩达和 Apache Spark。

我对严肃的在线学习感到非常惊讶，这是我以前没有尝试过的事情(我仍然不知道为什么)，我开始学习各种课程，从基因组学到天文学，从 scala 到 python，从机器学习到索伦·克尔凯郭尔的哲学理论(顺便说一句，他很棒)。

我没有路，也没有导师，所以我只是在探索这个世界，试图弄清楚我这一生想做什么。

与此同时(2014 年底)，我发现了吴恩达的机器学习课程和 Apache Spark 项目。我在两周内完成了这个课程，我简直不敢相信这个领域有多神奇。然后我开始编写我在 Scala 和 Apache Spark 中学到的东西，所以我开始了解分布式计算、Hadoop、HDFS 和所有这些伟大的东西。

我早期的一些关于机器学习和 spark 的项目(不是很好)你可以在我的 GitHub 中找到它们。去我最后的回复！

[## 法维奥·巴斯克斯(法维奥·安德烈·巴斯克斯)

FavioVazquez 有 111 个存储库。在 GitHub 上关注他们的代码。

github.com](https://github.com/FavioVazquez)

我的第一份数据科学工作

我的第一份工作是 2014 年结束的数据科学工作，我是公司里唯一一个试图弄清楚你可以用数据做什么的数据科学家。我很困惑，事情并不像课程中那样！我不再在 R 中导入虹膜数据集，我在处理奇怪的数据，我不知道数据在现实生活中是“脏”的。

但是我一直在学习。有趣的是，我一点也不确定！)当时的数据科学是什么。

我构建了一些简单的模型，以及更复杂的模型，主要是用 Scala 和 Python。Scala 是我 2015 年的生活。

然后我意识到我喜欢开源。我开始在简单的项目中合作，一些是我自己的，然后是一些大的项目，比如 Apache Spark。我在 Spark 项目上接受了一些委托，感觉自己像个英雄。有些很简单，有些更先进，但我觉得我在为社会做贡献。我仍然不知道怎么做，但我知道我在做贡献。

宇宙冒险

Roger Penrose theory of Conformal Cyclic Cosmology

数据科学是我继物理学和宇宙学之后的第二个爱好(我想现在它们是同一个地方)，所以我来到墨西哥攻读物理学硕士。这是一次令人惊奇的经历，但是仍然缺少了一些东西。我需要编码！我爱上了编程！

我学习了基础物理课程，比如经典力学、量子力学，还有数值方法、高性能计算，然后是贝叶斯推理和机器学习。

所以最终我的主人被我的两种激情所分裂。而且我在论文里用 Python 写了很多代码，真的很开心。

成为数据科学家

当我完成我的硕士学位(2017 年)时，我决定我想做的是成为一名数据科学家，帮助社会。是的，我花了点时间。

如果你想知道我是如何在这个领域找到一份令人惊叹的工作的，看看我几周前写的这篇博客吧:如何找到一份数据科学家的工作？

我也开始在我的 LinkedIn 上分享我的经历、想法和知识，这是非常重要的事情。我认识了很多了不起的人，他们帮了我很多，现在我在帮助别人，回报别人:)。

我每天都在学习、编码、为开源项目做贡献，同时也帮助人们，所以我对自己所做的事情非常满意。

深度学习呢？

这不是一个关于深度学习的帖子吗？

是的，但是我需要告诉你为什么深度学习现在对我很重要。我采取的所有这些步骤让我走到了这一步。

作为一名数据科学家，以及大多数职业，你需要了解最新的理论、技术和框架；所以去年我们看到了深度学习的爆发，就在我对机器学习感到舒服的时候，这是一个全新的学习内容。令人惊讶但压力很大。

你知道我从哪里开始的吗？猜猜…

是啊！又是吴恩达！

https://www.deeplearning.ai

我真对他感到惊讶。当我开始一个领域时，他已经在教了。

但是，我仍然在学习这些课程。但我没有就此止步。我也需要更多的实用信息。于是我开始学习 TensorFlow 然后是 Keras 。

对于那些不知道 Keras 的人来说，它是一个高级神经网络 API，用 Python 编写，能够在 TensorFlow 、 CNTK 或 Theano 之上运行。它是由 Franç ois Chollet 开发的，专注于实现快速实验。能够以尽可能少的延迟从想法到结果是做好研究的关键。

有很多学习实用深度学习的资源，比如 GitHub repos 和书籍。现在我正在读这本书，它已经成为我的图书馆的一个惊人的补充:

[## 使用 Python 进行深度学习

我见过的对深度学习最清晰的解释...阅读是一种乐趣。

www.manning.com](https://www.manning.com/books/deep-learning-with-python)

深度学习的未来

"预言是一种艺术，它先说将会发生什么，然后解释为什么没有发生！"

我不知道如何预测未来。但我能说的是我看到正在发生的和可能发生的。

我去年看到的深度学习最好的东西之一是深度认知。这是一个创建和部署人工智能的解决方案。简单的 drag & drop 界面帮助你轻松设计深度学习模型。深度学习工作室可以自动为你的定制数据集设计深度学习模型，这要归功于他们先进的 AutoML 功能。

我认为 GUI 和 AutoML 可以成为深度学习的不远的将来。不要误解我，我喜欢编码，你也可以在那里编码。但是我认为我们明年要写的代码数量将会减少。我们不能在世界范围内花费这么多时间一遍又一遍地编写相同的东西，所以我认为这两个特性(GUI 和 AutoML)将帮助数据科学家提高生产率和解决更多的问题。

我将在未来发表一些关于如何用代码和深度认知平台创建一些简单的深度学习解决方案的帖子，所以我们很快会再见。

如果您有任何问题，请添加我，我们可以在这里聊天:

[## 法维奥·巴斯克斯|职业简介| LinkedIn

查看 Favio Vázquez 在世界上最大的职业社区 LinkedIn 上的个人资料。Favio 有 10 个工作列在他们的…

www.linkedin.com](https://www.linkedin.com/in/faviovazquez/)

我使用 Keras 的深度学习之旅

原文：https://towardsdatascience.com/my-journey-into-deeplearning-using-keras-part-1-67cbb50f65e6?source=collection_archive---------13-----------------------

介绍如何在 Keras 中从头开始构建和训练神经网络。

PC: Felipe Lopez on Unsplash

“不要相信短期炒作，但要相信长期愿景。人工智能可能需要一段时间才能发挥其真正的潜力——这种潜力的全部程度还没有人敢梦想——但人工智能正在到来，它将以一种奇妙的方式改变我们的世界”——Francois Chollet

深度学习是机器学习的一个迷人领域，也是一个有前途的领域。它表现得非常好，尤其是在视觉和听觉等感知问题领域，这些问题曾经是机器无法解决的。我第一次接触深度学习发生在几年前，当时我正在 Kaggle 解决问题。正是在这里，我被介绍给 Keras，我想探索它的细节。在我遇到的所有其他深度学习库中，我发现 Keras 非常容易、灵活和简单易用。文档和示例也很方便，容易理解。

为了对这个主题有更强的理解，我一直在看一本名为《Francois Chollet用 Python 进行深度学习》的书，他也是 Keras 的作者。这已经成为我最喜欢的关于这个话题的书之一，我从中学到了很多。就像我常说的，我有在阅读任何书籍时创建笔记的习惯，所以这里是我从使用 Python 的深度学习一书中获得的笔记。我试图总结基本概念，并以一篇文章的形式呈现出来。对于任何想开始或刚刚开始进入深度学习世界的人来说，这些笔记会很有用。****

目标

本文的目标是熟悉 Keras 的世界、它的安装、部署以及如何用它来解决机器学习问题。本文不涉及像 LSTM、康维兹等先进的深度学习概念。我打算在我的下一系列文章中讨论这些主题。

你应该知道什么

由于你已经涉足深度学习领域，并且对 Keras 特别感兴趣，所以假设你:

有基本的编程经验
有一个在 Python 和
都知道基本的机器学习概念。

1.深度学习:初级读本

深度学习是机器学习的一个特定子领域。深度学习强调学习越来越有意义的表示的连续层。深度学习中的深度代表使用连续层表示的思想。这些分层表示是通过被称为神经网络的模型来学习的，这些神经网络被构造成堆叠在彼此顶部的文字层。

为什么现在要深度学习？

总的来说，今天有三种技术力量正在推动机器学习的重大进步

五金器具
数据集和基准以及
算法进步

正是由于今天所有这三个领域的丰富和改进，深度学习获得了动力。

深度学习到目前为止取得了哪些成果

深度学习已经取得的一些主要成功是:

接近人类水平的图像分类和语音识别。
接近人类水平的手写转录
改进的机器翻译
改进的文本到语音转换
Google Now 和亚马逊 Alexa 等数字助手
回答自然语言问题的能力

2.keras:Python 深度学习库

source

Keras (κέρας)在希腊语中是号角的意思。这是指古希腊和拉丁文学中的一个文学形象，最早见于《奥德赛》。 Keras 最初是作为 ONEIROS 项目(开放式神经电子智能机器人操作系统)研究工作的一部分而开发的。Keras 是一个用 Python 构建深度神经网络的框架。Keras 使我们能够建立最先进的深度学习系统，就像在谷歌和脸书使用的那些系统一样，没有什么复杂性，也只有几行代码。其的一些主要特征是:

用户友好的 API
内置对卷积网络(用于计算机视觉)、递归网络(用于序列处理)以及两者任意组合的支持。
支持任意网络架构:多输入或多输出模型、层共享、模型共享等等。

Keras 是用 Python 编写的前端层，运行在其他流行的深度学习工具包之上，如 TensorFlow、Theano 和微软认知工具包(CNTK)** 。您用 Keras 编写的任何代码都可以在这些后端中的任何一个上运行，而无需对代码做任何修改。通过 TensorFlow/Theano /CNTK，Keras 可以在 CPU 和 GPU 上无缝运行。**

The deep-learning software and hardware stack

装置

在安装 Keras 之前，我们需要安装它的一个后端引擎，即 TensorFlow、Theano 或 CNTK 中的任意一个。在本文中，我们将使用 TensorFlow 后端。阅读详细说明这里安装 Tensorflow。

安装 Keras 有两种方式:

从 PyPI 安装 Keras(推荐):

sudo pip install keras

如果您使用的是 virtualenv，您可能希望避免使用 sudo:

pip install keras

或者:从 GitHub 源安装 Keras】

首先，使用git克隆 Keras:

git clone [https://github.com/keras-team/keras.git](https://github.com/keras-team/keras.git)

然后，cd到 Keras 文件夹并运行安装命令:

cd keras
sudo python setup.py install

如有任何安装相关的疑问，请参考 Keras 官方文件。

硬件要求:设置工作站。

作者建议(尽管不是绝对必要的)在现代 NVIDIA GPU 上运行深度学习代码。或者，您可以考虑在 AWS EC2 GPU 实例或 Google 云平台上运行您的实验(随着时间的推移，这将变得非常昂贵)。

在本文中，我将使用 Jupyter notebooks 来开始使用 Keras，尽管这不是必需的:您也可以运行独立的 Python 脚本，或者从 PyCharm 之类的 IDE 中运行代码。

3.Keras 工作流程

典型的机器学习工作流程如下:

一个 Keras 工作流没有什么不同，要完全理解它；我们将在中使用一个神经网络的例子，这个神经网络使用 Keras 对手写数字进行分类。它就是著名的 MNIST 数据库问题也叫深度学习的“ Hello World ”。问题是将手写数字(28 × 28 像素)的灰度图像分为十类(0 到 9)。

**[## MNIST 手写数字数据库，Yann LeCun，Corinna Cortes 和 Chris Burges

MNIST 数据库是由 NIST 专题数据库 3 和专题数据库 1 构成的

yann.lecun.com](http://yann.lecun.com/exdb/mnist/)**

MNIST 数据集以一组四个 Numpy 数组的形式预加载到 Keras 中。

步伐

让我们强调我们将采取的步骤，利用 Keras 解决这一问题。

I)在 Keras 中加载 MNIST 数据集

**from keras.datasets import mnist****(train_images, train_labels), (test_images, test_labels) = mnist.load_data()**

图像被编码为 Numpy 数组，标签是一个数字数组，范围从 0 到 9。存储数据的多维数组称为张量**。你可以把张量想象成数据的容器。更具体地说，张量是矩阵到任意维数的推广。张量可以由三个关键特征来定义:**

我们来看看训练和测试数据。

**#Training Data
train_images.shape**
(60000, 28, 28)
**len(train_labels) #** Total no. of training images
60000
**train_labels**
array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)**#Testing Data
test_images.shape**
(10000, 28, 28)
**len(test_labels)**
10000
**test_labels**
array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)

所以我们这里有一个 8 位整数的 3D 张量。更准确地说，它是一个由 60，000 个 28 × 28 整数矩阵组成的数组。每个这样的矩阵都是灰度图像，系数在 0 到 255 之间。

ii)预处理数据

i) 准备图像数据

在输入之前，我们需要对数据进行预处理。这是通过将其重新整形为网络所期望的形状来实现的。我们还将缩放范围(0，1)之间的所有值。

train_images = train_images.reshape((60000, 28 * 28))
train_images = train_images.astype('float32') / 255test_images = test_images.reshape((10000, 28 * 28))
test_images = test_images.astype('float32') / 255

因此，我们将形状为(6000, 28, 28), type — uint8的数组中的训练图像转换为形状为(60000, 28 * 28)的float32数组，其值介于 0 和 1 之间。

ii) 对标签进行编码

标签也需要被分类编码，因为我们不能将整数列表输入神经网络。

from keras.utils import to_categoricaltrain_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

iii)构建网络架构

深度学习网络本质上由模型和层组成。

层

****层是神经网络的核心构建模块。它充当一种数据处理模块。各层从输入数据中提取出表示，并输入其中。本质上，深度学习包括堆叠这些层以形成模型。

层是深度学习的乐高积木

模型

模型是层的线性堆叠。它就像一个数据处理的筛子，由一系列不断增加的称为层的精细数据过滤器组成。Keras 中最简单的模型是 sequential ，由层顺序堆叠而成。

模型结构

我们将在 Keras 建立我们的第一个模型，只有两层。这里，我们将输入数据的预期形状传递给第一层。

**from keras import models
from keras import layers****network = models.Sequential()
network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))
network.add(layers.Dense(10, activation='softmax'))**

我们的网络由一系列两个层组成，它们是密集连接的**(也叫全连接的)神经层。**

第一层由 512 个单元组成，接受从 28×28 图像转换的 784 维阵列的输入。使用的激活函数是 ReLU(整流线性单位)。一个 整流线性单元 如果输入小于 0 则输出 0，否则为原始输出。也就是说，如果输入大于 0，则输出等于输入。
第二层(也是这里的最后一层)是 10 路 softmax 层，这意味着它将返回 10 个概率分数的数组(总和为 1)。每个分数将是当前数字图像属于我们的 10 个数字类之一的概率。你可以在下面阅读更多关于 softmax 函数的信息。

** [## 多类神经网络:Softmax

例如，假设您的例子是只包含一个项目的图像——一片水果。Softmax 可以确定…

developers.google.com](https://developers.google.com/machine-learning/crash-course/multi-class-neural-networks/softmax)

不同的层最适合不同类型的数据处理。一般规则(不是经验法则)是:

iv)网络编译

我们现在知道，我们的网络由两个密集层组成，每一层都对输入数据应用一些张量运算。这些操作涉及权重张量，并且网络的知识出现在这些权重上。

模型构建完成后，我们进入编译阶段，该阶段主要包括三个基本要素:

损失函数(目标函数) : 损失【预测—实际值】是我们在训练一个神经网络的过程中试图最小化的量。因此，测量损失函数是我们试图解决的任务成功的度量。为一个问题选择正确的目标函数是非常必要的。常用损失函数见下图。

Commonly used Loss functions

优化器:指定损耗梯度用于更新参数的确切方式。换句话说，它决定了如何根据损失函数更新网络。优化器可以是 RMSProp 优化器、SGD with momentum 等等。
度量:衡量模型的准确性。在这种情况下，我们将使用准确性。

**network.compile(optimizer='rmsprop', loss='categorical_crossentropy',****metrics=['accuracy'])**

本质上，损失的减少是通过小批量随机梯度下降实现的。管理梯度下降的具体使用的确切规则由作为第一个参数传递的 rmsprop 优化器定义。

五)培训网络

我们现在准备训练网络，这在 Keras 中是通过调用网络的拟合方法来完成的——我们将模型拟合到它的训练数据:

**network.fit(train_images, train_labels, epochs=5,batch_size=128)**Epoch 1/5
60000/60000 [==============================] - 5s 90us/step - loss: 0.2567 - acc: 0.9264
Epoch 2/5
60000/60000 [==============================] - 5s 88us/step - loss: 0.1032 - acc: 0.9694
Epoch 3/5
60000/60000 [==============================] - 5s 89us/step - loss: 0.0679 - acc: 0.9798
Epoch 4/5
60000/60000 [==============================] - 6s 92us/step - loss: 0.0490 - acc: 0.9856
Epoch 5/5
60000/60000 [==============================] - 5s 89us/step - loss: 0.0375 - acc: 0.9885

网络将开始以 128 个样本的小批量迭代训练数据 5 次(所有训练数据的每次迭代称为一个时期 )。在每次迭代中，网络将计算关于批次损失的权重梯度，并更新权重

训练期间显示两个量:

训练数据的网络丢失，以及
网络对训练数据的准确度。

训练数据的准确性大约在98.9%左右。现在让我们检查一下模型在测试集上的表现。

vi)测试数据测试

test_loss, test_acc = network.evaluate(test_images, test_labels)
10000/10000 [==============================] - 1s 66us/stepprint('test_acc:', test_acc)
test_acc: 0.9783

测试集的准确度是 97.8%——比训练集的准确度低很多。但这就是 ML 术语中著名的 过度拟合 的问题。通过从原始训练数据中创建大约 10，000 个图像的验证样本并将其放在一边，可以避免这种情况。测试可以在这个样本上进行，因为它以前没有暴露于训练。整个代码可以从这里的访问。**

结论

差不多就是这样了。在 Keras 的帮助下，我们详细解决了整个 MNIST 数字分类问题。我们刚刚从零开始建立并训练了一个神经网络。但是，理论是学习的一个方面，实际应用又是另一个方面。所以起来出发吧。通过处理一些真实的数据集来利用你新发现的知识。我们将在下一部分看到，我们将学习利用 Keras 解决一些高级问题。在那之前，祝你阅读愉快。

我的机器学习之旅:第一课

原文：https://towardsdatascience.com/my-journey-into-machine-learning-class-1-43a003f69666?source=collection_archive---------7-----------------------

我是纽约大学研究生一年级学生，攻读计算机科学。我已经决定在我的研究生课程“机器学习”中保留笔记。我相信它是最强大的媒介(无意双关！)来分享，可能会帮助很多感兴趣的读者进入 ML。它也提供了一个如何构建研究生课程的洞察力。我将根据每周课堂上所教授的内容来写文章。

课程和讲师简介

CS-GY 6923“机器学习”是纽约大学坦登工程学院教授的核心课程。研究生需要完成四门核心课程，本课程是其中之一。本课程介绍机器学习领域，涵盖标准的机器学习技术，如决策树、最近邻法、贝叶斯方法、支持向量机和逻辑回归。

丽莎·赫勒斯坦博士是 2018 年春季这门课程的讲师。她于 1984 年在哈佛大学获得了应用数学/计算机科学学士学位。然后，她于 1989 年在加州大学伯克利分校获得了计算机科学博士学位。她在期刊论文、书籍文章和会议上发表了超过 55 篇论文/文章。她的研究领域包括计算学习理论、机器学习算法、复杂性理论和离散数学。

来源

这些笔记的灵感来自各种材料，包括但不限于:

Alpaydin 的机器学习入门
汤姆·米切尔的机器学习
Andrew NG 的机器学习课程
赫勒斯坦教授的讲座、笔记和幻灯片
互联网

机器学习简介

机器学习是当今计算机科学中最具爆炸性的领域之一。这是一个令人兴奋的领域，其重点是让计算机有能力做出自己的决定。这是一个遍及商业、工业、科学和所有人类日常生活的领域。让我们从它的定义开始我们进入这个广阔领域的旅程。

根据亚瑟·塞缪尔的说法，*“机器学习是一个研究领域，它赋予计算机无需明确编程就能学习的能力。”Tom Mitchell 最近的另一个定义是，“据说一个计算机程序可以学习它在任务 T 中的性能，用性能 P 来衡量，是否随着经验 e 而提高”*我从上面的定义中理解的是，机器学习是让计算机通过处理数据来思考和决策。

如果机器不能学习，就很难称之为智能的。我们知道，要让计算机解决问题，需要算法。算法是将输入转换为输出的一系列指令。例如，要对一个数字进行排序，机器需要一个算法(如合并排序)将输入(未排序的数组)转换为输出(排序的数组)。

但是，对于某些任务，很难拿出一个算法。例如，检测垃圾邮件。在垃圾邮件中，输入通常是由字符序列组成的文件。这里期望的输出是决定电子邮件是否是垃圾邮件(是)或不是(否)。这里，我们不知道如何将输入转换为输出，因为:

被视为垃圾邮件的内容会随着时间而变化
垃圾邮件对不同的人有不同的含义

我们不知道将电子邮件分类为垃圾邮件的算法。但是我们在知识上的不足，我们用数据来弥补。计算机自动提取任务的算法。我们可能无法完全确定这一过程，但我们相信我们可以构建一个良好而有用的近似值，即我们可以检测某些模式或规律。这是机器学习的利基。这些模式可能:

帮助我们理解这个过程，或者
用于预测

与机器学习相关的另一个常见术语是数据挖掘。这两个过程是相互关联的。事实上，将机器学习方法应用于大型数据库被称为数据挖掘。在数据挖掘中，大量的数据被处理以构建一个简单的模型，该模型具有有价值的用途，例如，高预测准确性。

机器学习的应用

以下是机器学习正在积极应用的一些领域:

**零售:**零售商使用机器学习来了解客户的购买习惯，以便他们能够有效地锁定他们，增加他们的收入
**金融:**银行分析过去的数据，为信用卡申请、欺诈检测和股票市场建立模型
**制造业:**学习模型在制造业中用于提高生产能力、降低材料消耗和优化供应链
**医学:**机器学习用于医学诊断、个性化治疗、预测疫情爆发、发现药物
**电信:**分析呼叫模式，以实现网络优化和服务质量最大化
**科学:**机器学习使物理、化学、天文学中的大量数据得到更快的处理和分析
**互联网:**更快地在网上搜索相关信息(想想谷歌)
**视觉:**机器学习帮助识别人脸的模式，如对称性、眼睛的位置、耳朵等。从样本数据和使用这种模式，识别脸(想想苹果的脸锁)

机器学习也可以定义为使用示例数据或过去的经验对计算机进行编程，以优化性能标准。我们有一个定义了一些参数的模型。学习是使用训练数据/过去的经验来执行计算机程序以优化模型的参数。型号可以是:

预测:对未来做出预测
**描述性:**从数据中获取知识
或两者都有

机器学习在建立数学模型时使用统计理论，因为核心任务是从样本中进行推断。计算机的作用是双重的:

在训练中，我们需要高效的算法来解决优化问题，以及存储和处理我们拥有的大量数据
一旦学习了一个模型，确保它的表示和推理的算法解决方案是有效的

在一些应用中，学习或推理算法的效率，即空间和时间复杂度，可能与其预测准确性一样重要。

机器学习方法的应用

1.学习协会

就零售业而言，机器学习的一个流行应用是购物篮分析。购物篮分析的目的是发现顾客购买的产品之间的关联。例如，如果通常购买产品 X 的人 A 也购买产品 Y，并且如果另一个人 B 购买产品 X 而不购买产品 Y，则人 B 是潜在的 Y 客户。一旦我们找到这样的客户，我们就可以针对他们进行交叉销售。

在寻找关联规则时，我们感兴趣的是学习 P(Y|X)的条件概率，其中:

y:以 X 为条件的产品
x:购买的产品/产品组

2.分类

分类是一种监督学习方法，其输出是离散值(即 0 或 1)。

监督学习方法是一种已经给出“正确答案”的机器学习方法。目标是产生更多这样的正确答案。

在金融应用中，分类是指机器学习系统将模型与过去的数据进行拟合，以便能够预测(例如，计算风险)新的应用，并决定归类为{低风险，高风险}中的任一种。有关客户的信息作为分类器的输入，分类器的任务是将输入分配给两个类中的一个。在用过去的数据训练之后，分类规则可以是以下形式:

如果收入> x1 和储蓄> x2，那么风险低；其他高风险

上述规则是判别式的一个例子。判别式是将不同类别的样本分开的函数。

一旦我们有了符合过去数据的规则，并且如果未来与过去相似，我们就可以对新的实例做出正确的预测。

在某些情况下，我们可能希望计算一个名为 P(Y|X)的概率，而不是做出 0/1(低风险、高风险)类型的决策，其中:

x:客户属性
Y : 0/1(低风险、高风险)

从这个角度来看，我们把分类看作是学习从 X 到 y 的联想。

P(Y=1|X=x) = 0.8

从上面的等式，我们可以说:

客户有 80%的可能性是高风险客户
客户有 20%的可能性是低风险客户

分类的另一个应用是在光学字符识别(OCR)中。这里的任务是从图像中识别字符代码。这是一个多分类的例子，其中输入是手写数字的图像，输出是实际的数字(即，机器应该能够识别出您手写的“8”是实际的“8”)。

分类也用于人脸识别。这里，输入是图像，输出是被识别的人。学习程序学习将面部图像与身份相关联。在这里应用分类有点问题，因为类别太多，输入图像往往非常大，并且姿势和光照的某些差异可能导致图像中的显著变化。

分类还用于医疗诊断(识别疾病)、语音识别、自然语言处理(垃圾邮件检测、大型文档汇总)和异常值检测等。

一旦进行了分类，我们就可以从数据中学习规则。这就是所谓的知识提取。这个规则是一个解释数据的简单模型，通过这个模型，我们可以解释数据背后的过程。学习还执行压缩，因为通过使规则适合数据，我们得到比数据更简单的解释，即，需要更少的存储器来存储和更少的计算来处理。

例如，一旦我们有了加法规则，我们就不需要记住每一对可能数字的总和。

3.回归

回归是一种监督学习方法，其输出为连续值。

例如，预测二手车的价格是一个回归问题。输入是汽车属性，输出是汽车的价格。回归通常具有以下形式:

y = wx + w1 其中

w =直线的斜率，

w1 =常数

典型地，在监督学习中，任务是学习从输入到输出的映射。机器学习的一个标准方法是，我们假设一个定义了一组参数的模型:

y = g(x / w)其中

y 是输出，

x 是属性，

w 是参数，

g(x/w)可以是回归函数，也可以是判别函数

机器学习优化“w ”,以使近似误差最小化，即我们的估计尽可能接近训练集中给定的正确值。

回归的一些例子包括:

**机器人汽车导航:**输入是传感器，比如摄像机，GPS，输出是方向盘应该转动的角度。通过监控和记录人类驾驶员的动作来收集训练数据。
**咖啡烘焙:**输入的是咖啡的属性，如温度、时间、咖啡豆种类等。进行了许多实验，对于这些输入的不同设置，我们测量咖啡的质量作为顾客满意度(比方说)。为了找到最佳设置，我们拟合了一个回归模型，将这些输入与咖啡质量联系起来，并在当前模型的最佳值附近选择新的采样点，以寻找更好的配置。我们对这些点进行采样，检查质量，并将其添加到数据中，以适应新的模型。这通常被称为响应面设计。

有时，我们希望能够学习相对位置，而不是估计绝对数值。例如，在推荐系统中，我们部署了一个排名函数，其中输入是电影属性和用户评级，输出是已排名电影的列表。

4。无监督学习

无监督学习方法是一种不给出“正确答案”的机器学习方法。目标是找到数据的结构。

通过找到数据中的某些模式，我们可以找到数据的结构。在统计学中，这被称为密度估计。

密度估计的一种方法是聚类。聚类是一种旨在发现输入数据分组的聚类的技术。

例如，基于客户的人口统计、过去的交易(即，客户数据)找到客户的分组。该公司希望了解经常出现的客户类型。聚类模型将属性相似的客户分配到同一组。这叫做*客户细分。*这将有助于公司针对不同的客户群体提供服务和产品。

另一个例子是图像压缩。在图像压缩中，输入是表示为 RGB 值的图像像素。聚类程序将具有相似颜色的像素分组在同一组中，并且这样的组对应于图像中频繁出现的颜色。

文档聚类是聚类的另一个例子。目的是将类似的文档，如新闻、宗教话题、体育等进行分组。文档被表示为单词包，即我们预定义了一个由 N 个单词组成的词典。每个文档都是一个 N- 维二元向量，如果 i 出现在文档中，则其元素 i 为 1。后缀' s '，'-ing '和' of '，' in '等单词被删除。然后根据共享单词的数量对文档进行分组。如何选择词汇至关重要。

5.强化学习

强化学习是让一个主体在世界中行动以最大化其回报的问题。例如，考虑教一只狗一个新把戏:你不能告诉它做什么，但如果它做对/错的事情，你可以奖励/惩罚它。它必须弄清楚它做了什么使它得到了奖励/惩罚，这就是众所周知的信用分配问题。我们可以使用类似的方法来训练计算机完成许多任务，例如玩双陆棋或象棋，调度作业，以及控制机器人肢体。

教授的重要建议

我们将在本课程中使用一些基本术语:

例数: N

培训示例:

应该使用随机分布生成训练样本
假设有一个分布，但是你对这个分布不做任何事情
PAC 模型:PAC(大概正确近似学习)模型是一个框架，学习者接收样本，必须从某一类可能的函数中选择一个泛化函数(称为假设)。目标是，以高概率(“可能”部分)，所选函数将具有低泛化误差(“近似正确”部分)。总是假设数据来自未知分布
**直觉:**简单的规则会比复杂的规则概括得更好，前提是训练误差低。
VC-Dimension:VC-Dimension(Vapnik-Chervonenkis Dimension)是一种衡量一组假设简单性的方法。如果存在具有低训练误差的简单假设，并且存在“足够”的训练数据，则该假设很可能具有低预测误差。
奥卡姆剃刀定律: 奥卡姆剃刀定律指出，如果一件事有两种解释，越简单的解释越好(或者)你必须做出的假设越多，解释就越不可能。给出两种解释来解释数据，你应该选择更简单的一种。只有在绝对必要的情况下，你才应该有一个复杂的规则。
你并不总是希望选择训练误差较低的假设。它可能不会很好地“学习”或概括。

这就是本周的全部内容。敬请期待下节课！

我的机器学习之旅:第四课

原文：https://towardsdatascience.com/my-journey-into-machine-learning-class-4-eb0f681cec65?source=collection_archive---------5-----------------------

大家好！感谢你和我一起踏上机器学习之旅！这是该系列的第四篇文章；如果你还没有看过第一篇、第二篇和第三篇的文章，请查看一下。

上周，我们学习了线性回归的核心概念。我们一直从贝叶斯的角度思考，研究朴素贝叶斯算法。我们还简要地了解了模型是如何被评估的。

本周，我们将:

讨论验证集的必要性
继续研究交叉验证
讨论引导
直观和数学地理解偏差和方差

请注意，上周，尽管我提到我们将从头实现一个朴素贝叶斯算法，但我不会在本文中这样做(我们将在接下来的文章中讨论它，所以不要担心！).

来源

这些笔记的灵感来自各种材料，包括但不限于:

Alpaydin 的机器学习入门
汤姆·米切尔的机器学习
Andrew NG 的机器学习课程
加州大学伯克利分校的机器学习博客
赫勒斯坦教授的讲座、笔记和幻灯片
互联网

模型评估(续)

上周，我们讨论了交叉验证，以及它如何成为评估模型的一种强有力的方式，尤其是在数据较少的情况下。我们还讨论了数据科学家通常如何将数据集分为两组:训练集和测试集。但在实践中，大多数数据科学家将数据集分为三组:

训练集，
测试集，以及
验证集

人们经常问的一个常见问题是:

"测试集和验证集之间有什么区别？"

验证集主要用于调整学习算法的参数，而测试集仅用于评估算法的性能。

所以你有一个学习算法，你想评估它的表现。的确，您可以将数据集划分为训练集和测试集，并通过对训练数据进行训练和对测试数据进行评估来评估您的模型有多准确(好)。但是像多项式回归这样的学习算法有许多参数，我们想要测试参数的每一个设置。因此，通过在验证集上评估学习算法，我们可以得到一个学习算法的最佳参数设置。然后使用学习算法的这个最佳设置，我们在测试集上评估它的性能。这通常能创造奇迹！

要点是:

更新学习算法的参数以获得数据的最佳算法设置所必需的验证集
测试集对于评估我们从验证集中得到的算法的最佳设置的性能是必不可少的

现在你会问，

“但是等等易勒雅斯！高次多项式(在回归中)的性能通常不会比低次多项式好吗？”

是的，这是真的。高次多项式有过度拟合数据的趋势。我们得到的精度可能很高，但在推广方面做得很差。因此，如果您在不同的数据集上使用相同的模型(比方说具有相同的属性)，它的性能会大大降低。

图 1 是低次多项式，而图 2 是高次多项式。正如我们可以清楚地看到，高次多项式试图执行太难，甚至适合离群值。

反之亦然:多项式次数过少可能无法很好地推广。

图 1 是低次多项式，而图 2 是高次多项式。可以清楚地看到，在这种情况下，高次多项式更适合数据。

那么，当我们考虑一个验证集时，我们如何处理这个问题呢？我们如何选择多项式的最佳次数，使模型既不欠拟合也不过拟合？

嗯，我们使用交叉验证！

如果我们只记录总体数据的误差，显然高次多项式会表现得更好。因此，我们使用交叉验证(回收数据)，以便数据中的每个集合都可以作为训练集和验证集重用。这样，在一个验证集中起作用的高次多项式不太可能在另一个验证集中起同样的作用。这样，我们可以得到我们一直在寻找的多项式的最佳次数！

一般程序如下:

让

D1 —培训套件
D2 —验证(调谐)装置
D3 —测试集

执行 k 重交叉验证时，保持 D3 独立，不要接触它

对于每个 k:(其中 k = 1，2，3，4，…..多项式的次数)

使用设置为 k 的学习算法训练假设

2.计算 D2 假设的误差

3.对所有折叠重复此操作

4.选择 k，它给出了所有褶皱的 D2 平均误差的最小值

5.现在，在测试集 D3 上用 k 的这个设置运行学习算法。如果它表现良好(即准确性值得称赞)，就保留它。

另一个可能被问到的问题是:

“如果学习算法在 D2 上跨所有折叠都执行得很好，但在 D3 上(从未见过的测试集)却不行，会怎么样？”

这意味着三者之一:

学习算法是不能够的
怀疑过度拟合
出了问题，比如 D1、D2 非常小或者 D3 非常小(可能不适用于交叉验证场景)

如果我们遭受类不平衡问题，我们应该使用分层 k-fold 交叉验证。分层是一个重新排列数据的过程，以确保每个折叠都是整体的良好代表。例如，如果我们有两个类，分层确保每个折叠都有两个类的 50%。

另一个关键问题是:

我们如何选择交叉验证中折叠数“k”的值？

没有金科玉律来定义训练、验证和测试集应该有多大。我们希望每个数据集足够大，以减少方差(方差衡量数据集分布的程度；我们很快就会谈到它！)的估计。估计方差有两种形式:

适合训练数据的假设(学习算法)的方差
验证/测试风险估计值的方差

好的启发法(通常)是:

50%/25%/25%用于培训/val/测试分割，以及
k = 5 或 k = 10
随机拆分数据，集合之间的实例没有重叠

我们应该总是设法减少验证/测试风险估计的方差以及学习算法估计的方差。

所以差异是由两个因素驱动的:

训练/拟合:
-随着模型的复杂度与训练数据大小之比的增加，模型可能会过度拟合，这增加了模型的方差。
小型测试/验证集:
——测试/验证风险是整个数据集中每个样本风险的平均值。均值估计值的标准误差与 sqrt(数据集的大小)成比例减少

交叉验证的替代方法是引导。

Bootstrapping 是一种通过从原始样本中抽取实例并替换来生成新样本的方法。这类似于从单个样本生成多个样本。原始样本在这里被当作一个“群体”。

更具体地说:

训练数据集—从总共 N 个数据实例中随机选择 N 个替换样本
验证数据集-原始数据集(不属于训练数据集的实例)

bootstrap 样本可能比交叉验证样本重叠更多(因为我们是用替换样本进行采样的)，因此它们的估计更具依赖性；但是它被认为是对非常小的数据集进行重采样的最佳方式。

现在:

我们选择一个实例的概率= 1/N

我们不选择实例的概率= 1 - 1/N

在 N 个实例后我们不挑选的概率

= (1 - 1/N)^N

=(大约。)e^-1

= 0.368

这意味着训练数据包含大约 63.2%的实例；即，系统将不会对 36.8%的数据进行训练。因此，误差估计将是悲观的。为了使我们的误差估计更准确，我们复制；即多次重复该过程并观察平均行为。

在某种程度上，我们使用 bootstrap 程序根据经验计算估计量的方差，并将方差估计纳入我们的选择机制。

关于引导要记住的要点:

是一种非参数方法(即，不假设任何关于基础分布的事情)，不需要假设人口分布的参数形式
用替代品取样
将原始样本视为“总体”
潜在的假设是，从大小为 N 的原始样本中进行替换的抽样模拟了从更大的总体中抽取大小为 N 的样本
适用于各种各样的问题，如非线性回归，分类，置信区间估计，偏差估计，调整 p 值，和时间序列分析
必须记住，它并不真正代表原始人口

自举不仅仅是我们讨论的内容。我推荐你通读以下文章，以便更好地理解它:

要获得自举的置信区间，请参考这个
关于为什么自举运行得非常好，请参考这个

偏见和差异:两难

偏差-方差困境是机器学习和数据科学领域中最流行的困境之一。理解它也很重要。为了理解偏差和方差，我将用两种方式来解释它:

直观的方式(你可以很容易地跟随)
一种更数学化的方式

对偏差和方差的直观理解

偏差-方差困境具有现实世界的意义。它导致成千上万人死亡。流行的 【福岛核电站灾难】 就是过度拟合的结果。让我们回过头来看看欠拟合和过拟合与偏差和方差有什么关系。

我们希望我们的学习算法能够非常接近地模拟训练数据，即捕捉相关的属性和趋势。然而，如果我们过于接近我们的学习算法，我们可能会高估离群值。这是机器学习算法试图踩在预测上的微妙平衡。

事情是这样的:

我们希望避免过度拟合，以停止重视离群值
但是在我们尝试这样做的时候，我们可能会适得其反:忽略训练数据中的重要特征

你可能拥有宇宙中最快的计算机、最先进的算法、计算密集型 GPU，但如果你的模型过拟合/欠拟合，你的学习算法的预测能力将仍然很糟糕。

偏差和方差是统计领域的术语。偏差是一个定义非常松散的术语，但它通常被定义为*“实际参数和计算统计值之间的差异”。如果您不知道统计数据和参数之间的区别，请参考这个。另一方面，方差被定义为“对数据分布程度的度量”*。

偏差对应于欠拟合，而方差对应于过拟合。看这个图:

在这里，我们看到线性模型表现出高偏差，即它欠拟合。这个模型不够复杂，无法捕捉信息的潜在趋势。我们的模型是有偏差的，因为它隐含地假设数据以某种方式运行(在这个例子中，是线性的),即使这个假设不是真的。需要记住的一个关键点是，我们的线性模型没有任何问题；它正尽力而为。问题出在模型本身，也就是说，它不够复杂，无法从数据中获取足够的信息。

看一下这个例子:

从图中可以看出，模型过拟合。这也叫高方差。数据表明，曲线对于捕捉信息可能是必不可少的，但我们的模型选择了复杂的曲线来做到这一点。在这种情况下，它表现出高方差和非常低的偏差(低偏差，因为它不对数据做任何假设)。事实上，它对数据的适应性太强了。

需要记住的一个关键点是，模型本身没有任何问题；它适应每一个数据点。对上述数据使用这种模型存在问题。我们的模型想要考虑每一个数据点，因此过度概括。过度概括的模型具有很高的方差，因为它基于无关紧要的数据细节而变化太多。

太好了！但是现在你问:

“嘿，易勒雅斯！我明白你说的偏差和差异是什么意思。但是为什么它们的背后会有取舍呢？为什么我们不能利用两者的优点，即低偏差和低方差？”

碰巧偏差和方差是一个因素的副作用:我们模型的复杂性。

当我们的模型的复杂性低，我们有高偏差和低方差。另一方面，当我们的模型的复杂性很高时，我们有低偏差和高方差。

我们能做的最好的事情就是在两者之间找到一个平衡点，也就是说，选择一个既不太复杂也不太简单的模型。

还有一件事我想让你记住:

训练误差总是会随着模型复杂度的增加而减少(从上图中的绿线可以看出)
测试误差会降低到某一点，然后增加(从上图中的红线可以看出)
因此，这些误差是确定您的模型是否欠拟合/过拟合的良好度量

扩展上述观点:

低复杂度模型导致训练和测试数据的精度差和误差大 。这是因为模型本质上缺乏足够的复杂性来描述数据。
高复杂度模型导致高精度和高测试误差。这是因为该模型将能够很好地描述训练数据，因此不能推广到测试数据。

参数方法

别再凭直觉了！让我们试着从数学上理解偏差和方差！在具体谈论偏差和方差之前，让我们先了解什么是参数方法。

在参数方法中，我们假设样本来自服从已知模型的某种分布，例如高斯(正态)。参数化方法的优点是模型被定义为少量的参数(例如，均值和方差)。这些被称为分布的充分统计量。这意味着一旦从样本中估计出参数，整个分布就是已知的。

我们:

根据给定的样本估计分布的参数，
将这些估计值代入假设模型，
得到一个估计的分布，然后
用它来做决定

我们用来估计分布参数的方法是最大似然估计(MLE)(如果你读过以前的文章，现在应该知道了)。

让我们将样本定义为独立同分布。这意味着我们样本中的每个随机变量都具有与其他变量相同的概率分布，并且相互独立。它表示如下:

我们假设 x^t 是从一些已知的概率密度函数 p(x |θ)中提取的实例，定义为参数θ:

我们想找到θ，使得从 p(x |θ)采样 x^{t 尽可能的可能。因为 x}t 是独立的，给定样本 x 的参数θ的可能性是各个点的可能性的乘积:

在最大似然估计中，我们感兴趣的是找到使 X 最有可能被画出的θ。因此，我们寻找最大化上述可能性的θ。我们可以最大化可能性的对数，而不改变取最大值的地方的值。应用对数技巧(对数将乘积转换为总和)，我们将对数似然性定义为:

对于高斯(正常)密度:

x 是高斯分布，具有:

如果你在想上面的 E 是什么，那就是随机变量 x 的期望值，对于连续型随机变量，期望值一般是均值。更多信息，请参考本。

密度函数如下所示:

现在，考虑到:

对数可能性是:

现在，我们通过对上述导出的对数似然进行偏导数(w.r.t mu 和 sigma 以获得估计值)并将其设置为 0 来找到 MLE。我们得到:

评估一个估计量:偏差和方差

我们终于准备好讨论偏差和方差了！

让:

为了评估该估计量的质量，我们可以测量它与θ的差异，即，

但是由于估计量是一个随机变量(它取决于样本 X)，我们需要在所有可能的 X 上平均，并考虑 r(d，θ)，估计量 d 的均方误差定义为:

估计量的偏差是估计量的平均值和实际参数θ之间的差值:

如果上述 bias 值等于 0(零)，我们说 d 是θ的无偏估计量。如果 x^t 是从具有实际均值 mu 的某个密度中抽取的，则样本平均值 m 是实际均值 mu 的无偏估计量，因为:

请注意， m 是样本的估计平均值， mu 是总体的实际平均值。所以上面基本上说的是，如果我们从很多这样的样本中取很多这样的 m ，所有这样的 m 的平均值就会接近实际平均值(mu)。因此，随着样本数量的增加，样本均值将(几乎)等于实际均值。

m 也是一致估计量，这意味着 Var(m)—>0 为 N—>无穷大。

随着样本中的点数 N 变大， m 偏离 mu 越小。

现在让我们检查 s，实际方差σ的 MLE(最大似然估计):

鉴于:

如果你对上面的证明感到好奇，可以参考这个。

从(4)中，我们可以写出:

将上述值代入(3)，我们得到:

上式表明 s 是*μ的有偏估计量。*如果我们将 N 项从 R.H.S 移动到 L.H.S，我们得到(N/(N-1))s，这是一个无偏估计量(即，它等于实际σ)。但是，当 N 变大时，差别可以忽略不计。这是一个渐近无偏估计量的例子，当 N 趋于无穷大时，其偏差趋于 0。

最后，回到我们的均方差:

Fig. Analogy by my friend, Rakshit Sareen

E[(d - E[d]) ]是公式中的方差。它衡量特定 di 在期望值(即估计平均值)附近的平均变化程度(即期望值 E)。

为了记住这一点，想想地球和月球之间的类比。地球的位置是估计的平均值(E[d])。月球在任何给定时间的位置都是 D1。方差就是两者的平均差。

因此，具有实际参数θ的模型的误差(均方误差)为:

注意，如果偏差= 0，即估计平均值(E[d]) =实际平均值(θ):

你有它！偏差和方差的数学分解！现在你在直觉上和数学上已经准备好处理偏差和方差了。

这就是本周的全部内容，各位！下周见！

我的机器学习之旅:第五课(回归)

原文：https://towardsdatascience.com/my-journey-into-machine-learning-class-5-regression-cb6f04006b29?source=collection_archive---------11-----------------------

欢迎回来，伙计们！机器学习巡航继续！这是该系列的第五篇文章；请务必阅读以前的职位，因为我从那里建立了很多。

上周，我们讨论了对验证集的需求。我们继续讨论了交叉验证，并讨论了作为交叉验证替代方法的自举。我们也试图直观和数学地理解偏差和方差。

在本帖中，我们将讨论:

回归模型—单变量、多变量和多项式
正规方程方法
梯度下降算法
正规化

来源

这些笔记的灵感来自各种材料，包括但不限于:

Alpaydin 的机器学习入门
统计学习的要素
吴恩达的机器学习课程
艾琳金姆🙏的文章
赫勒斯坦教授的讲座、笔记和幻灯片
互联网

一元线性回归模型

在第三篇文章中，我介绍了线性回归的核心概念。概括地说，我们希望有一个函数 f 来模拟我们的数据。我们建立一个函数 f 的近似器，称为g，表示为:

我们使用误差函数来衡量函数对数据的逼近程度。误差函数有许多变体，但我们将利用:

例如，假设我们的数据如下:

上述的误差函数为:

我们的误差函数值不是很大。值越接近 0，我们的模型就越好。如您所见，我们的误差函数取决于:

属性/特征 X
参数 w1 和 w0

我们不能改变属性 X 的值，因为它代表实际的数据(我们可以对它进行规范化，但不能随意改变它的值)。然而，我们可以改变参数 w1 和 w0 的值。一元线性线中的 w1 和 w0 表示:

w1 -斜率或梯度(我们的线有多陡)
w0 - y 轴截距(直线与 y 轴相交的位置)

如果我们能够控制 w1 和 w0 的值，我们可以使上面的线准确地穿过我们的数据！

在我们讨论如何精确地优化 w1 和 w0 的值之前，我想用矩阵来表示上述误差函数。

让:

请注意 X_0 = 1。这是因为 X_0 不是一个真正的属性，但我们用它来简化我们的矩阵符号。这只是一个培训示例。如果我们有一个以上的训练示例(比如 3 个)，我们的矩阵符号就变成:

产生的向量(向量是具有单行/列的矩阵)是我们预测值的集合(g(X)的值)。

现在我们已经定义了矩阵术语，让我们看看如何优化参数 w1 和 w0 的值。

有两种方法可以获得 w1 和 w0 的优化值:

正规方程法，以及
梯度下降算法

1。正规方程法

正规方程方法是一种非迭代方法，它帮助我们确定 W(带有我们希望优化的参数的矩阵)的优化值。

在我们继续之前，我想定义一些术语:

**残差:**观测值(r)和估计值之间的差值(在我们的例子中是 g(X))

误差:观察值(r)与 r 的真值(不可观察)之差

**RSS(残差平方和):**表示为

最小二乘法:最小化 RSS 的方法。它测量模型的平均拟合缺失。它分为两类:普通(线性)最小二乘法和非线性最小二乘法

**闭型表达式:**可以在有限次运算中求值并有解的数学表达式。

**普通最小二乘法:**有一个封闭形式的解(我们这里的正规方程组方法)

**非线性最小二乘法:**一般来说，没有封闭形式的解

我们这里考虑的正规方程组方法是普通最小二乘法。在这种方法中，我们通过明确地对 w 求导并将它们设置为 0 来最小化误差函数。它由以下公式给出:

如果你对这个等式是如何推导出来的感兴趣，那么 Aerin Kim 将是一个很好的起点🙏笔下的文章。我还推荐你浏览一下维基百科的页面和博客。

关于正规方程，需要记住几个要点:

正规方程只需一步即可解析求解 W
不需要要素缩放(将要素/属性的值转换为相同的比例，通常为-1 比 1)
计算(X^T X)的倒数的时间复杂度为 O(n ),其中 n =特征的数量
如果我们有非常多的特征，法线方程将会很慢
实际上，当 n > 10，000 时，可能是从常规解决方案进入迭代过程的好时机
法线方程非常适用于线性模型，尤其是当要素数量较少时
它不适用于其他模型，如逻辑回归(我们将在后面介绍！)
有时，(X^{T X)的逆可能不存在，即(X}T X)是不可逆的(它的行列式是 0)
如果(X^T X)是不可逆的，常见原因可能是:

冗余特征，其中两个或多个特征非常相关(即，它们是线性相关的)

例如，如果我们有以米为单位的 X1 -尺寸，以厘米为单位的 X2 -尺寸，X1 = 100X2，那么 X1/X2 是一个多余的特征，应该被删除

2.功能太多。在这种情况下，删除一些特征或使用正则化

现在让我们来看看获得优化参数的迭代解决方案。

2.梯度下降算法

梯度下降是一种迭代算法，可以最小化我们的误差函数。这是一个非常强大的通用算法，广泛用于机器学习，而不仅仅是线性回归。

让我们试着直观地理解我们的误差函数和参数的目的是什么。我们将画出 g(X)和误差函数 e。

在我们的例子中，我们得到 E = 1.165。理想情况下，我们应该得到 E = 0。为此，我们不断改变 w1 的值，以使该点位于 x 轴上。然后，我们的 E(w)将是 0，我们将有一个模型，完美地描述我们的数据。

上图是我们假设只有一个参数的时候。让我们考虑参数 w0 和 w1，并想象我们的 E(w)。

我为我糟糕的绘画技巧道歉。当我们考虑参数 w0 和 w1 时，我们得到 3D 表面图。当我们对 w0 和 w1 取不同值时，弓形表面就是我们的误差函数。这个弓形表面的底部点是我们得到误差函数最低的地方。同样的图形可以用等高线图绘制在二维平面上，但我们不会在这里深究。

因此，我们可以手动绘制如上图，找到 w1 和 w0 的值，并查看我们的误差函数如何响应这些值。但这是一个极其繁琐的过程。更不用说，当我们有两个以上的参数时，我们会得到更高维度的图形，这些图形不容易绘制，也更难可视化。

我们希望有一种有效的算法，能够自动找到 w1 和 w0 的值，使我们的误差函数最小。这个算法就是梯度下降。

通过一个例子可以更好地理解梯度下降。

想象你和你的爱人去爬山。经过艰苦的努力和时间，你终于到达了山顶！(万岁！).当你沉浸在荣耀中时，你突然意识到你的爱人不在你身边。惊慌失措中，你呼唤着爱人的名字。幸运的是，你的爱人回应说他/她在山的最低点(山很小！).

你想尽快到达这座山的最低点。你可以随意往任何方向走，希望你能找到你的爱人。但是你的爱人可能会有危险(有凶猛的野兽在附近徘徊！).你不想拿你爱人的安全冒险。

你深吸一口气，开始分析你的环境。从你站的地方，你环顾四周，选择最陡下降的方向。你推理说，如果在每一步，你都选择最陡的下坡路，你会比盲目地朝一个随机的方向走更快地到达你的爱人。这需要你一些时间，但是按照上面的策略，你最终会找到你的爱人(干杯！).

根据上面的类比:

您的位置 -当前故障点功能
你女朋友的位置——误差函数最低的点
最陡下降 -误差函数的导数(该点切线的斜率)

这可以想象如下:

从图中可以看出，我们的目标是到达图表中的最底部，也就是说，当它的值最小时。

方法是将误差函数 w.r.t 对参数 w0 和 w1 求导。我们在下降速度最快的方向上逐步降低误差函数。

每一步的大小由参数 alpha ，决定，称为学习率。较小的α会导致较小的步长，而较大的α会导致较大的步长。采取步骤的方向由 E(w0，w1)的偏导数决定。根据一个人在图上的起点，他可能会在不同的点结束。

在上图中，我们注意到对于两个不同的起点，我们到达不同的最低点(局部最小值)。我们稍后将详细讨论这一点。

梯度下降算法可以封装在一个公式中:

可能会出现一个问题:

为什么取导数的负值，而不取正值？

任何函数的导数的方向都是该函数最大增加的方向。因为我们的目标是 E(w0，w1)(我们的函数)的最小化，我们选择函数的负导数，因为它给出了函数的最大减少的方向。

为了直观地理解它，考虑下面的例子:

你可以清楚地看到:

当我们考虑正斜率时，w1 减小，因此误差函数也减小
当我们考虑负斜率时，w1 增加，因此误差函数也增加

另一个重要的问题是:

梯度下降如何以固定步长大小 alpha 收敛？

收敛背后的直觉是，当我们接近凸函数的底部时，导数接近 0。在最小值点，导数将始终为 0，因此，我们得到:

当我们接近局部最小值时，梯度下降将自动采取较小的步骤。偏导数的值会随着我们向下移动到局部最小值而减小。这就是为什么，我们确实需要改变学习速度。

当梯度下降专门应用于线性回归的情况时，可以导出一种新形式的梯度下降方程:

所有这些的要点是，如果我们从估计量(g(X))的猜测开始，然后重复应用梯度下降算法，我们的估计量将变得越来越精确。

上述梯度下降算法被称为批量梯度下降，因为它查看整个训练集中的每个示例(求和部分)。它对凸函数非常有效，因为凸函数只有一个全局最小值(即只有一个局部最小值)。然而，当我们有凹函数(凹函数有不止一个局部极小值)时，这在计算上极其昂贵并且根本不可行。

因此，为了减轻计算，使用梯度下降的另一个变体，称为随机梯度下降。在随机梯度下降中，我们不是查看每步的整个训练集(求和部分)，而是只查看每步的一个样本。单个样本可能有噪声，因此随机梯度下降的许多变体使用小批量(每步几个样本，而不是每步一个样本)。

如果你想看看批量梯度下降与随机梯度下降，我强烈推荐 Aerin Kim🙏的文章和这个 StackExchange 回答。

要了解凸凹函数的区别，看一下这篇文章。

关于梯度下降需要记住的几点:

梯度下降需要特征缩放，因为如果缩放不均匀，梯度可能会花费很长时间，并在最终找到全局最小值之前来回振荡
在特征缩放中，每个特征(即 X)大约在-1 ≤ X ≤ 1 的范围内
特征缩放将使梯度下降运行得更快和在更少的迭代中收敛
要素缩放包括将输入值除以范围(即最大值-最小值)或标准差
另一个称为均值归一化的变量，包括用相同变量的平均值减去输入变量的值
结合特征缩放和均值归一化，我们得到:

为了确保梯度下降能够正常工作，我们可以绘制一个如下图:

我们可以在每 100 次迭代中评估 E(W)的值。要点是 E(W)应该在每次迭代后减小
对于特定应用，梯度下降收敛所需的迭代次数可能会有很大变化。可能需要 30、3000、300000 次迭代
很难预先知道梯度下降需要多少次迭代才能收敛。通常通过绘制如上图，我们可以发现梯度下降是否收敛。
也有可能提出一个自动收敛测试:如果 E(W)减少小于ε(比如 10^-3)in 一次迭代),则宣布收敛
ε是一个很小的值，是一个阈值。一般来说，选择阈值的值是非常困难的。因此，依靠图表是更可取的
有时，你的 E(W)可能在每次迭代中增加而不是减少

发生这种情况是因为:

梯度下降可能不起作用
阿尔法太大了
你的代码中有一个错误

选择α值是梯度下降算法的一个重要部分
如果α太小:收敛速度慢
如果α太大:E(W)可能不会在每次迭代中减少，也可能不会收敛
Andrew NG 提出的一个很好的启发是:

最初，设置 alpha = 0.001(或任何小值)
将后续 alphas 设置为大约是其先前值的 3 倍，即 0.001、0.003、0.01、0.03 等等
对于每个α值，绘制 E(W)作为迭代次数的函数
选择看起来能使 E(W)迅速减小的α值

当特征数较少时，最好使用正规方程组方法
如果数据集太大，使用小批量随机梯度下降比批量梯度下降更好

多元线性回归

多元意味着我们有不止一个变量(特征)。它的工作方式与一元线性回归完全相同。我们只需要推广多元线性回归的上述方程。

1.正规方程方法

矩阵的维数变了，但我们的正规方程保持不变。

2.梯度下降

梯度下降方程本身一般也是这种形式；我们只需要对 k 个特性重复这个过程。

多项式回归

多项式回归是回归分析的一种形式，其中自变量(在我们的例子中是 X)和因变量(r)之间的关系被建模为次数≥ 2 的多项式。

次数= 1 的多项式是线性方程。我们上面看到的例子都是次数= 1 的多项式。

多项式回归允许您使用线性回归的机制来拟合非常复杂的非线性函数。

将多项式模型表示为线性模型的一个小技巧是通过替换。内容如下:

如果我们像这样选择我们的特征，那么特征缩放对于梯度下降算法变得越来越重要。

高次多项式有过度拟合的趋势。因此，高次多项式的精度将优于低次多项式的精度。

为了解决过度拟合的问题并实现良好的通用模型，我们有两种选择:

减少功能的数量:这是通过只选择最重要的功能，扔掉那些不太有用的功能来实现的。为了自动选择重要的特征，我们使用了模型选择方法，例如最佳子集选择、逐步选择(正向和反向)、以及逐步回归等等(我们将在后面介绍这些方法！)

上述方法的问题是它导致信息的删除(特征或者被保留或者被丢弃)。因此，它通常表现出很高的方差

**正则化(或收缩方法):**正则化是引入惩罚项(称为 lambda)的过程。该λ确保惩罚高复杂度模型(更高阶多项式)，即，它平滑系数(w0，w1，…，wK)。为了说明正则化如何帮助我们获得更好的拟合，考虑这个例子:

有两种常用的正则化类型:

L2 正则化(岭回归)
L1 正则化(拉索回归)

1.L2 正则化(岭回归)

L2 正则化由以下公式给出:

请注意，我们在正则化项中不考虑 w0。为什么？因为这是一种惯例，在实践中，我们是否包括 w0 关系不大。

2.L1 正则化(拉索回归)

LASSO(最小绝对收缩和选择运算符)由以下公式给出:

这里唯一的区别是我们考虑参数 w 的模，而不是它们的平方。

比脊和套索更好的正则化方法是弹性网正则化。

弹性网络正则化结合了脊和套索，由以下公式给出:

为了理解为什么这更好的直觉，我推荐你阅读提出这种方法的原始论文。但是简而言之，当你有高度相关的特性时，那么弹性网就是你要走的路！

正则化的一个问题是选择λ的值:

如果 lambda 太高，模型就会太简单，从而导致拟合不足
如果 lambda 太低，你实际上没有受到惩罚，因此，你的模型仍然很复杂

为了选择最佳的λ，在不同的λ值上使用交叉验证，选择产生最低 E(W)的λ。

另一个要注意的要点:在使用正则化时，鼓励特征缩放，因此参数的惩罚是基于它们的预测能力，而不是它们的比例。

我希望这篇文章能够帮助您更好地理解回归。伙计们，这几周就到这里吧！下一篇帖子再见！

我的编程和生物信息学之旅:第 3 部分

原文：https://towardsdatascience.com/my-journey-into-programming-and-bioinformatics-part-3-224ea62e92e0?source=collection_archive---------10-----------------------

生物信息学是一个非常广阔的领域，甚至还有专门的生物信息学硕士学位。在 10 分钟左右的阅读时间内涵盖所有方面是不可能的。如果你刚刚起步，对专业术语感到困惑，请阅读这篇文章。如果你想深入研究，Github 上有免费开放的 生物信息学课程。

既然我们可以(在某种程度上)编程(第 1 部分)并对大规模并行测序(第 2 部分)的一些概念有所了解，我们可以继续并将这些应用于我们面临的任何问题。

更类似于第 1 部分，这篇文章将是一个教程、指南和期刊文章的集合，可以帮助您找到进一步研究的正确方向。这里的很多信息在 Illumina 测序介绍中也有涉及。

在我们开始之前，了解常用术语是很重要的。我也将只涉及基于 Illumina 的测序，因为它是最广泛使用的测序类型。

词汇表

**覆盖面或阅读深度。**单个核苷酸的覆盖率或阅读深度(例如 30X)是该核苷酸被测序运行有效调用的次数。人类基因组 30 倍的平均覆盖率意味着平均每个核苷酸被测序 30 次。为什么这很重要？假设你只调用每个核苷酸一次。这样，你永远也不能说出这个位点是纯合的还是杂合的。如果你调用每个核苷酸两次，你可能会碰巧得到两次相同的核苷酸(例如一个 T)。你会认为这是一个纯合位点，而实际上，它是一个杂合位点(例如 A/C)。增加你调用该碱基的次数会增加以该碱基的真实频率结束的几率(50-50%，在蚊子或癌症中非常小的亚克隆的情况下为 1-99%)。

**成对末端读取。**成对末端测序能够对 DNA 片段的两端进行测序。因为每对读数之间的距离是已知的，比对算法可以使用该信息更精确地绘制重复区域的读数。这导致更好的读数比对，特别是在基因组的难以测序的重复区域，并允许检测结构变异。[更多信息请点击这里](http://www.illumina. com/technology/next-generation-sequencing/paired-end-sequencing_assay.html)。

**Phred (Q)质量评分。**Q = 10 log(10)P，其中 P =不良碱基或变异呼叫的概率。例如，如果 Phred 给碱基分配 30 (Q30)的 Q 分数，这相当于 1000 次中不正确碱基呼叫 1 的概率。这意味着碱基调用的准确性(即，正确碱基调用的概率)是 99.9%。更多信息点击这里。

**FASTA 和 FASTQ 文件。**FASTA 格式用于存储生物序列(如核苷酸:“AGTCGGCTATTGCGAG”或氨基酸:“LIAEAYPEDSNATST”)。FASTQ 格式是 FASTA 格式的扩展，包含相应核苷酸的 Phred 质量分数，以显示测序仪对该核苷酸的“确信”程度。更多信息请点击此处。

**参考基因组。**当测序仪显示读数时(FASTQ 格式)，您需要将它们与参考基因组进行比对，以查看它们来自哪里。更简单的是，目前有三个参考基因组在使用。2009 年:GRCh37 和 hg192013 年:GRCh38。GRCh37 和 hg19 的染色体位置相同，但 GRCh使用“chr”前缀表示染色体，而 hg不使用。虽然这似乎是一个微不足道的问题，但如果你决定交换参考基因组，这可能会给你带来很多麻烦。挑一个坚持下去，除非真的要改。这里是关于差异的更多信息。阅读如何选择参考基因组。虽然如果每个人都改用 GRCh38 会更好，但许多工具仍然依赖于 2009 版本，这使得转换很困难。

**SAM/BAM/CRAM-files。**SAM 格式是用于与参考序列比对的生物序列的格式，支持短和长读取(高达 128 Mb)。BAM 与 SAM 完全相同，但采用二进制格式以实现高效压缩(BAM 可由计算机读取，而 SAM 可由人类读取),因为 SAM 文件可能会变得非常、非常、非常大。CRAM 是 BAM 的更压缩版本。更多信息可在 SAMtools 文档中找到。

**变体呼叫格式(VCF)。**VCF 格式是包含元信息行、标题行和数据行的文本文件，每一行都包含关于基因组中位置的信息。标题行命名了 8 个固定的强制列。这些列是:CHROM(染色体)、POS(位置)、ID(如 rsID)、REF(参考)、ALT(替代)、QUAL
(质量)、FILTER(通过或失败)、INFO(附加信息)。SAMtools 文档中提供了更多信息。

图书馆准备

在您开始处理数据之前，显然您首先需要数据。将“原始”DNA 或 RNA 转化为可以测序的东西的过程被称为文库制备或简称为文库制备。它包括将 DNA 片段化成短序列(~300bp)并添加衔接子、索引和尾部。测序引物需要衔接子来结合。后面的解复用需要索引(见下文),最后，尾使 DNA 片段结合流动细胞成为可能。如果您对此感到困惑，请阅读第 2 部分了解更多信息。

Illustration by Fimm

我不会在这里涉及湿实验室方面，让湿实验室的人在你开始做这些类型的分析时施展他们的魔法。但是，每个实验都是不同的，您需要了解您的样品使用的是哪种文库制备。如果你不这样做，你会有解释 QC 图的问题。

定序

在大多数情况下，当你刚刚开始时，你的工作将在测序运行结束时开始。看看测序的质量。我怎么强调都不为过。如果你有坏的数据开始，因为，例如，你的文库制备或测序运行出错，你的下游分析也将是坏的。垃圾进=垃圾出。

如果你的跑步记录被上传到 Basespace，你需要在https://basespace.illumina.com/建立账户。

第一次打开 Basespace 时，你会被一系列你不理解的 QC 参数击中。为了更好地了解在 Basespace QC 中发生的事情，最好了解 Illumina 测序实际上是如何工作的。为此，我们需要深入研究流动池。根据您使用的机器，有两种流动池:模式化流动池和随机流动池。

Fastq 产生和解复用

你的测序给了你。bcl 文件(基本调用文件)。对于下游分析，我们需要。fastq 文件，用 bcl2fastq 生成。如果您使用的是 Basespace，这是自动完成的。大多数情况下，您会希望每次测序运行对多个样品进行测序，因为(a)每个样品不需要那么多读数，(b)这样更便宜，(c)这样更快。

这就是为什么对于每个样本，你的 DNA 片段会有不同的索引。将读数合并回原始样本的过程称为解复用。Basespace 会自动为您完成这项工作。如果出于某种原因，你需要手动操作，Gavin Wilkie 的是一个很好的指南。

Illustration by Illumina

使用 FastQC 进行质量评估

更多质量控制！耶！请注意，我们仍然没有做任何事情来解释我们测序运行的生物学结果。

FastQC 是一个很好的工具，可以让你先看看你的数据。它可以给你一个印象，如果你的数据中有某些偏差，或者如果你的文库准备或测序运行中出现了问题。这真的很容易运行，只需在命令行中键入以下内容(安装后):

fastqc sample1.fastq.gz --outdir=/some/other/dir/

您将收到一个包含不同情节的. html。更多信息，一如既往，在文档中。不要依赖于 FastQC 上的通过/警告/失败，这真的取决于你的库准备。例如，在亚硫酸氢盐测序中，每个碱基序列中几乎没有胞嘧啶，但这是意料之中的(因为它们几乎都转化为胸腺嘧啶)。FastQC 将这些错误标记为“失败”。像 Basespace 一样，在解释 FastQC 图时，经验也很重要。如果你对某事感到困惑，问问同事。

大多数情况下，您会分析多个样本，并且会生成相当多的日志文件。 MultiQC 是一款非常棒的软件，只有一个命令:

multiqc .

您可以将所有日志文件汇总到一个报告中。我一直在用，怎么推荐都不够。

如果您对编写处理 fastq 文件的最佳实践管道感兴趣，您可能会对 bcbio 感兴趣。但是你仍然需要知道在 bcbio 管道的引擎盖下发生了什么，或者你可能想要自己开发一个。

绘图

将产生的读数与参考序列进行比对的过程被称为“作图”。组装就是在没有参考序列的情况下生成基因组。这种方法的优点是检测结构变异、复杂的重排和重复序列。然而，精确的从头组装需要相对长的读数，这在 Illumina 测序中是不可能的。但是更长的阅读测序技术(纳米孔和 PacBio)即将出现，所以我们可能很快就会看到一些变化。然而，在 RNA 测序中，转录组的从头组装已经被用于检测新的转录物。

对于 DNA 图谱，最受欢迎的图谱绘制者是BWA-记忆和鲍蒂 2 。

对于 RNA 测序来说，最受欢迎的图谱绘制者是 STAR 、 HISAT2 和 TopHat。只有在 STAR 遇到内存问题时才使用 TopHat。总的来说，对于 RNA 测序，我喜欢参考 Conesa 及其同事的这篇论文和 Sahraeian 及其同事的这篇论文。

为了绘制 DNA 甲基化图谱(亚硫酸氢盐转化的 DNA)，我使用 Bismark 。

映射后，您的。fastq 通常被转换成. bam 文件。同样，查看日志文件。如果只有 35%的读数被唯一定位，那么你的文库准备、测序或数据分析可能出了问题。

重复读取

通常，您还会对样品中重复的数量感兴趣。如果> 99.9%是重复的，你将只是在你的文库制备中看到一些独特的片段。除非你在处理扩增子测序，否则你不会想要这个。

重复读取可能源于测序(见上文；流动细胞的类型)或从文库制备中的 PCR 获得。这些可以用皮卡德识别(用 MultiQC 可视化):

java -jar picard.jar MarkDuplicates \
      I=input.bam \
      O=marked_duplicates.bam \
      M=marked_dup_metrics.txt

如果一切看起来都很好，你可以继续进行下游分析，这取决于你的输入:DNA，RNA 或 DNA 甲基化。

例子:DNA 测序

变体调用

变异体调用是识别与参考序列(单核苷酸变异体、SNVs 和插入/缺失、indels)不同的核苷酸的过程，在这种情况下是您选择的参考基因组。根据你的输入材料，你可能对种系变异或体细胞变异感兴趣。

变体调用很难。非常辛苦。对我们来说幸运的是，布罗德研究所开发了一个工具包，名为基因组分析工具包(简称 GATK)，它附带了【最佳实践】关于如何从全基因组测序、外显子组测序和靶向测序中为种系和体细胞变异调用进行变异调用。

GATK workflow for germline short variant discovery —June 2018

GATK 附带了大量的文档和教程。如果你有问题，而且你是在非常罕见的情况下，你不能在文档或谷歌上找到它，开发者会非常迅速地在论坛上回答问题。留意你附近的 GATK 工作室。我有幸参加了 2017 年在比利时鲁汶举行的一次研讨会，这是我参加过的最有用的研讨会之一。GATK 进化的速度也很惊人。去年，体细胞 CNV 呼叫(见下文)仍处于早期测试阶段，现在已经有了经过验证的最佳实践指南。

虽然 GATK 是一个很棒的软件，但它对你放进去的东西也很挑剔。如果你正在用 GATK 开发一个管道，不要偷工减料。如果你在想“哦，我不需要按坐标排序我的 bam 文件，它可能会运行”。

剧透:不会的。

或者“我用的是 GRCh37，这个参考集在 hg19 中，这可能不成问题”。相信我，会的。我想我已经从 GATK 那里得到了所有存在的错误信息。但是过一会儿你就知道陷阱在哪里了。

成功运行 GATK 后，您将拥有一个. vcf 文件。然而，这是一个很长的变体列表。你如何从生物学角度理解这一点？首先，您可以从注释. vcf 开始。

VCF 注释

答。没有任何注释的 vcf 看起来有点像:

[HEADER]
#CHROM  POS     ID      REF    ALT      QUAL    FILTER  INFO                    
1	889455	.	G	A	100.0	PASS	AF=0.0005
1	897062	.	C	T	100.0	PASS	AF=0.0005

SnpEff 就是一个注释这个的工具。带有功能信息的 vcf。它用基因名称、错义/无意义变体、编码或非编码等信息更新 INFO 字段，结果如下所示:

#CHROM POS     ID        REF    ALT     QUAL FILTER INFO                    
1	889455	.	G	A	100.0	PASS	AF=0.0005;EFF=STOP_GAINED(HIGH|NONSENSE|Cag/Tag|Q236*|749|NOC2L||CODING|NM_015658|)
1	897062	.	C	T	100.0	PASS	AF=0.0005;EFF=STOP_GAINED(HIGH|NONSENSE|Cag/Tag|Q141*|642|KLHL17||CODING|NM_198317|

接下来，SnpSift(不要与 SIFT 混淆)允许您基于您选择的参数过滤带注释的 VCF(例如，过滤掉质量分数低于 30 的变体):

cat variants.vcf | java -jar SnpSift.jar filter " ( QUAL >= 30 )" > filtered.vcf

这是一个非常强大的工具，可以做更多的事情，一定要看看文档。

ANNOVAR 是另一个为注释. vcf 而设计的工具，与 SnpSift 不同，ANNOVAR 的输出是. csv 或。tsv(逗号或制表符分隔的文件)。这些文件可以很容易地在 Excel 或其他电子表格程序中打开(只要确保基因名称没有被转换成日期，因为 Excel 是出了名的)。《T4》快速入门指南让你一切顺利。最后，你会得到这种格式，对于非生物信息学领域的人来说也很容易使用:

Source: ANNOVAR quick start guide

使用 Excel，您可以基于群体频率、内含子/外显子进一步筛选，以进一步探索数据。

复制号码变体(CNV)呼叫

拷贝数变异是大于 1000bp 的 DNA 片段的增加或减少。CNV 打电话也是辛苦的，这体现在许多刊物上 CNV 打电话。

没有黄金标准，不同的工具针对非常不同的场景进行了优化。一些工具需要匹配的法线。一些使用法线池来更好的覆盖归一化。有些支持不使用平铺探针的检测的脱靶读数。有些是肿瘤纯度和倍性意识，并提供整数拷贝数。有些工具在高吞吐量环境中比其他工具工作得更好。有些在临床样品(例如低纯度 FFPE 样品)中比其他样品效果更好。— 马库斯·里斯特

本质上看你想做什么。如果你想看看种系 CNVs，那就看看 CNVkit 。CNVKit 可以处理靶向测序、外显子组测序和全基因组测序数据，是 bcbio 推荐的。也很好用。Illumina 还有一个工具， Canvas ，可以处理 WGS 数据。另一方面，如果你对体细胞 CNVs 感兴趣，今天是你的幸运日:GATK4 有最佳实践。如果你想看看等离子体中的 CNVs，看看 WISECONDOR。

现在去哪里？

最后，基于最初的临床问题或假设，你会想要做一些生物学上的解释。你可能会对家庭成员之间共享的变体感兴趣(或缺乏变体，从头开始变体)。还有一个工具可以完成这个任务。或者，你可能对癌症中的体细胞热点突变感兴趣。或者是易患癌症的种系突变。或者完全不同的东西(那样的话，谷歌就是你的朋友。在写你自己的脚本之前，记住某人在某个时候也可能想做同样的事情。

在从原始读取到变量调用的每一步过程中，保持你最初的假设是头脑。当与最初的问题(一个极端的例子:进行拷贝数变异呼叫以发现肺癌中的 EGFR T790M 突变)结合时，您的工作流程有意义吗？如果答案是“我不知道”或“可能”，你应该再次咨询做文库准备的湿实验室科学家和/或启动测序运行或项目的临床医生或研究人员。

为了简洁起见，我在这里只关注 DNA。我可以继续下去，用 RNA 和甲基化测序的类似资源填充另外 4 个段落。但是一旦你对以上有了一些经验，你就能自己找到你需要的。然而，如果你对一个关于 RNA 或甲基化的帖子感兴趣，请给我留言！

我想感谢我在这篇博文中提到的每一个人，以及导师、朋友、同事和其他以各种方式帮助我的人。我与我提到的任何公司都没有任何关系。

如果你喜欢读这本书，如果你把它推荐给你的朋友和同事，或者在推特或脸书上分享，那会很有帮助。

关于作者:

我是 Ruben Van Paemel 博士，2017 年从医学院毕业后，我开始在根特大学(医学遗传学中心)担任博士研究员，由研究基金会 Flanders 资助。我也是根特大学医院的儿科住院医师。可以在 Twitter 关注我:@ RubenVanPaemel

我的贝叶斯统计之旅

原文：https://towardsdatascience.com/my-journey-to-bayesian-statistics-4097d432a853?source=collection_archive---------6-----------------------

Photo by Guillermo Velarde on Unsplash

2018 年夏天，我有一个极好的机会，加入了马萨诸塞大学阿默斯特分校 Leontine Alkema 教授的实验室。我们用贝叶斯模型做了一个生物统计学研究。在这篇文章中，我将分享一些在我的研究中一直帮助我的资源。如果你也在学习贝叶斯统计的话，希望这能对你有所帮助！

一些关于我背景的信息

我是美国第一所女子学院 Mount Holyoke 学院的计算机科学专业学生。我 10 岁的时候开始了我的第一堂编程课。我对 Java、R、Python 和版本控制都很得心应手。而且，我对统计学和艺术史很感兴趣。在此研究之前，我对数据科学中的机器学习算法有基本的了解和项目经验。我每年还参加当地的数据科学竞赛。

我想分享的资源

基本概率 :概率是贝叶斯统计的前提。如果你没有任何概率方面的背景知识，请点击链接。
做贝叶斯数据分析，与 R，JAGS，斯坦的教程作者:约翰·克鲁施克 :这是我刚开始学习贝叶斯统计时的入门书。有了所有的例子和情节，很容易理解一些必须的想法。
麻省理工学院电子讲座 :这门课完全免费。菲利普·里戈莱教授很容易理解。他有两节关于贝叶斯统计的课。你也可以利用这些讲座来概括一些统计学的基础知识。

3.Bradley p . Carlin 和 Thomas A. Louis 的数据分析贝叶斯方法 :这本书有很多例子和 R 代码。与 Kruschke 的书不同，这本书用大量的细节来解释贝叶斯模型。

4.彼得·d·霍夫的《贝叶斯统计方法初级教程》 :这本书解释了贝叶斯统计为什么以及如何工作。它被选为许多贝叶斯统计课的教科书。

MCMC 和 Metropolis 算法
置信区间和可信区间 : Keith Winstein 的回答是我迄今为止见过的最直白的解释之一。我把这个推荐给大家。
时间序列 :将时间序列添加到你的贝叶斯模型中总是很有趣:这是一个关于时间序列的简单易懂的入门教程。

【周期性和季节性时间序列:Rob J hynd man 的精彩解释

8.使用贝叶斯统计的更多示例:

[## 经验贝叶斯方法的模拟(使用棒球统计)

我们即将结束关于经验贝叶斯方法的这个系列，并且已经触及了许多统计方法…

varianceexplained.org](http://varianceexplained.org/r/simulation-bayes-baseball/)

我喜欢大卫·罗宾逊的博客！他们太棒了，真的让我在贝叶斯世界大开眼界。因为我的研究都是关于计划生育的，所以很高兴看到贝叶斯统计如何应用于其他现实生活场景。大卫还写了一本书，名为经验贝叶斯导论:棒球统计的例子。如果你正在学习贝叶斯统计，你不想错过它！

[## 贝叶斯统计如何说服我去健身房

一个有趣的旅程到线性回归理论与贝叶斯触摸(嘘嘘:我用公制测量在这…

towardsdatascience.com](/how-bayesian-statistics-convinced-me-to-hit-the-gym-fa737b0a7ac)

读到 Tuan Doan Nguyen 的这篇文章，我真的很兴奋。很励志！我真的很期待在中国建立一个案例模型。

9.其他检查列表

[## 数据科学的贝叶斯统计

这是博客文章系列“数据科学的概率与统计”的第五篇，这篇文章涵盖了这些主题…

towardsdatascience.com](/bayesian-statistics-for-data-science-45397ec79c94)

安基特·拉希写了这个惊人的博客系列，其中还包括许多有用的链接！我从他们身上学到了很多。非常感谢！

我要感谢实验室里的每一个人，让我们度过了这个美妙的夏天:Leontine Alkema、Krzysztof Sakrejda、Emily Peterson、Greg Guranich、Chuchu Wei、Wang 和 Remy Wang。

感谢您阅读我的博客，希望对您有所帮助。如果你想关注我未来的更新，请随时通过 LinkedIn 和 Medium 与我联系。加油贝叶斯！

(credit: https://en.wikipedia.org/wiki/Bayes%27_theorem)

我的图书推荐系统建设之旅。。。

原文：https://towardsdatascience.com/my-journey-to-building-book-recommendation-system-5ec959c41847?source=collection_archive---------2-----------------------

推荐系统已经占据了我很长一段时间，由于我喜欢看书，探索图书交叉数据集非常有吸引力。

在线推荐系统是许多电子商务网站要做的事情。推荐系统广泛地向顾客推荐最适合他们口味和特点的产品。关于推荐系统的更多细节，请阅读我关于推荐系统的介绍性文章和一些使用 Python 的插图。

当我遇到图书穿越数据集时，我开始了构建图书推荐系统的旅程。该数据集由 Cai-Nicolas Ziegler 于 2004 年编制，由用户、图书和评分三个表组成。显性评分用 1-10 分表示(数值越高表示欣赏程度越高)，隐性评分用 0 分表示。

在建立任何机器学习模型之前，了解数据是什么以及我们试图实现什么是至关重要的。数据探索揭示了隐藏的趋势和见解，数据预处理使数据准备好供 ML 算法使用。

那么，我们开始吧。。。

首先，我们加载数据集并检查图书、用户和评级数据集的形状，如下所示:

书

逐一研究这些数据集，从 books 数据集开始，我们可以看到 image URLs 列似乎不是分析所必需的，因此可以删除它们。

我们现在检查每一列的数据类型，并纠正缺失和不一致的条目。我还调整了列宽，以显示各列的全文。

出版年份

现在我们检查这个属性的唯一值。

yearOfPublication 中有一些不正确的条目。由于 csv 文件中的一些错误，出版商名称“DK Publishing Inc”和“Gallimard”似乎被错误地加载为数据集中的 yearOfPublication。此外，一些值是字符串，在某些地方相同的年份被输入为数字。我们将对这些行进行必要的更正，并将 yearOfPublication 的数据类型设置为 int。

现在可以看到 yearOfPublication 的类型是 int，其值的范围是 0–2050。由于这个数据集是在 2004 年构建的，我假设 2006 年以后的所有年份都是无效的，保留两年的余量，以防数据集可能已经更新。对于所有无效条目(包括 0)，我会将这些转换为 NaNs，然后用剩余年份的平均值替换。

出版者

来到“publisher”列，我已经处理了两个 NaN 值，将它们替换为“other ”,因为经过一些调查后无法推断出 publisher 的名称(检查 jupyter 笔记本嵌入)。

用户数据集

现在，我们研究用户数据集，首先检查它的形状、前几列和数据类型。

年龄

在检查唯一值时，userID 看起来是正确的。但是，年龄列有一个 NaN 和一些非常高的值。在我看来，5 岁以下和 90 岁以上没有太大的意义，因此，这些正被 NaNs 所取代。然后，所有的 NaNs 都被替换为年龄的平均值，其数据类型被设置为 int。

我在这里没有对 Location 列进行任何处理。但是，如果您愿意，您可以进一步将其分为城市、州、国家，并使用文本处理模型进行一些处理。

评级数据集

我们检查评级数据集的形状和前几行。它揭示了我们的用户-图书评分矩阵将非常稀疏，因为实际评分与评分矩阵的大小(用户数×图书数)相比非常小。

现在评级数据集应该有 userID 和 ISBN，它们存在于各自的表中，即。用户和书籍。

很明显，用户已经对一些书籍进行了评级，这些书籍不是原始书籍数据集的一部分。数据集的稀疏度可以计算如下:

由 1-10 表示的明确评级和由 0 表示的隐含评级现在必须分开。我们将只使用明确的评级来建立我们的图书推荐系统。类似地，用户也被分为那些明确评级的用户和那些隐含行为被记录的用户。

bookRating 的计数图表明，较高的评分在用户中更常见，评分 8 被评为最高次数。

简单的基于流行度的推荐系统

在这一点上，一个简单的基于流行度的推荐系统可以基于不同书籍的用户评级计数来构建。很明显，J.K .罗琳写的书很受欢迎。

基于协同过滤的推荐系统

为了应对我的机器拥有的计算能力并减少数据集的大小，我正在考虑对至少 100 本书评分的用户和至少有 100 个评分的书。

构建基于 CF 的推荐系统的下一个关键步骤是从评分表中生成用户项目评分矩阵。

请注意，评级矩阵中的大部分值都是 nan，表示缺少评级，因此数据稀疏。另外，请注意，这里只考虑了显式评级。由于大多数机器学习算法不能处理 nan，我们用 0 来代替它们，这现在表示没有评级。

基于用户的 CF

我将重用我的文章中的功能，例如基于 CF 的推荐系统。函数findksimilarrusers输入 userID 和评级矩阵，并返回 k 个相似用户的相似度和索引。(阅读我以前的故事，了解基于用户/项目的 CF 方法的概念和公式)

函数 predict_userbased 基于基于用户的方法预测指定用户-项目组合的评分。

函数 recommendItem 使用上述函数为基于用户或基于项目的方法(基于选定的方法和指标组合)推荐图书。如果一本书的预测评级大于或等于 6，并且该书还没有被评级，则进行推荐。调用此功能时，您可以选择相似性度量(余弦/相关性)。

瞧啊。！！基于基于用户的 CF 方法，检查用户 4385 的前 10 本书推荐。

基于项目的 CF

已经为基于条目的 CF 编写了类似的函数来查找 k 本相似的书，并预测用户对每本书的评分。相同的功能recommende item可用于根据基于项目的方法和所选指标推荐书籍。如果一本书的预测评级大于或等于 6，并且该书还没有被评级，则进行推荐。

哇！！！根据基于条目的 CF 方法，检查为用户 4385 推荐的前 10 本书。这些与基于用户的方法所建议的显著不同。

在这篇文章中，像交叉验证、测试序列分割和推荐系统的评估这样的领域还没有被讨论，这些领域值得探索。下面嵌入了 Jupyter 笔记本的这个代码。

[## csaluja/JupyterNotebooks-中号

在 GitHub 上创建一个帐户，为 JupyterNotebooks-Medium 开发做出贡献。

github.com](https://github.com/csaluja/JupyterNotebooks-Medium/blob/master/Book%20Recommendation%20System.ipynb)

感谢阅读！我希望你喜欢这篇文章。请在下面的评论区分享你的观点。同时，我会去为自己查一些书籍推荐。

参考资料:

1.https://towards data science . com/how-do-we-build-book-recommender-systems-in-hour-the-fundamentals-dfee 054 f 978 e

2.https://Cambridge spark . com/content/tutorials/implementing-your-own-recommender-systems-in-Python/index . html

我的数据科学之旅(面向零编码经验的初学者)

原文：https://towardsdatascience.com/my-journey-to-data-science-for-beginner-with-zero-coding-experience-1e7896b564d3?source=collection_archive---------1-----------------------

正如我在上一篇博客文章中所说，自从我在大会上开始数据科学沉浸式课程以来，已经过去了三周。只是给你一个视角，让你了解我现在的学习进度。我想说，我学到了很多关于 python(我们在课堂上使用的主要语言)和一些基本的统计算法(t 检验、p 值、z 得分)。然而，我还没有自信到可以教人的程度。但是我认为如果我继续努力，这是可行的。今天，我想与你分享我采取的步骤和我使用的一些好的资源。

供您参考，在本课程之前，我的编码经验非常有限。我在大学时学过 HTML 和 CSS，但仅此而已。好像是五年前。GA 的要求之一是在参加课程之前完成课前准备工作，旨在帮助我们快速学习数据科学沉浸式课程。课前工作是一个基于网络的学习工具，名为 DataCamp(链接:https://www.datacamp.com/home)。它提供了各种各样的计算机科学相关的课程，你可以从初级水平到高级水平。

以下是我喜欢它的地方:

非常有活力的教学风格。编码有时会被解释和混淆。它提供了一段视频，由一名教师演示材料并解释编码背后的逻辑，如果你能通过观看更好地学习，这将非常有帮助。此外，它使整个学习过程变得直观，并允许用户返回视频进行任何参考。
实践。很多练习。通常看完视频后，他们会围绕这个话题做几个练习。练习也有不同的形式，通常坚持多项选择题和在给出指令的界面上编写代码。
提供演示幻灯片的 PDF 版本，您可以下载到您的本地资源进行查看。
它保存了你的进步。如果你有一个繁忙的时间表，它允许你跳回到你上次离开的地方。

以下是我推荐给初学者参加的 DataCamp 的一些课程:

Screenshot of DataCamp interactive platform with instructor teaching

面向数据科学的 python 简介-涵盖了您需要了解的关于 Python 的所有基本资料。共有 4 个不同主题的章节。不要继续下一章，直到你有一个坚实的理解，因为每一章通常是建立在前一章的基础上。如果有必要的话，多做几次。

2.面向数据科学的中级 Python 一旦您掌握了基础知识，这就是您应用知识和进行案例研究的地方。它涵盖了更深入的课程，如可视化工具，数据结构和其他软件包的实施。这可能是你想花更多时间关注每一章的地方，因为随着时间的推移，你会在案例研究中用到本课程的大部分工具。

所以我在 DataCamp 一共上了 8 门不同的课程。我不会说我记得所有的事情，但它确实让我开始编码并在案例研究中应用逻辑。请记住，如果 DataCamp 不适合你的学习风格，有很多资源可以帮助初学者。

我为初学者推荐的其他资源:

Hard cover of the book

艰难地学 Python 数字&书 —这本书是为没有编码经验的初学者设计的。作者用非技术人员也能理解的方式解释了一切，做得非常好。此外，他一步一步地解释练习，很容易跟上。你可以购买这本书或者阅读免费的 html 版本。

链接:【https://learnpythonthehardway.org/book/

DataQuest —另一个类似 DataCamp 的学习平台。它允许你根据你想要完成的目标来选择学习路径。尽管这种学习方式更多的是基于文本的。对那些通过阅读学得更好的人来说很棒。你将阅读概念，然后做练习。此外，它提供的指令不如 DataCamp 具体。所以你不能猜测答案，而在 DataCamp 中，你可以通过阅读说明来推断答案。我所做的是，我将学习 DataCamp 的基本形式，并从 DataQuest 进行更多的练习。有限的课程是免费的，但是如果你想打开所有的课程以及其他的额外津贴，你可以选择按月订阅。

链接:https://www.dataquest.io/home

如果你有其他好的资源想要分享，请在帖子里留下评论。我确信有人能从中受益。记住，当你学习新的东西时，它必然会有一个学习曲线。一旦你投入了足够的时间和精力，这些点将开始连接起来，你会有更多的学习乐趣。

我的强化学习之旅——第 0 部分:简介

原文：https://towardsdatascience.com/my-journey-to-reinforcement-learning-part-0-introduction-1e3aec1ee5bf?source=collection_archive---------3-----------------------

Gif from website

目前，我对强化学习知之甚少，我想改变这一点，所以这是我学习强化学习的第一步。作为第一步，我希望先介绍高层次的概述。

请注意，这篇文章是为我未来的自己写的，我的学习过程可能会很慢，或者与你的不同。

加州大学伯克利分校彼得·博迪克的强化学习教程

从这个讲座中，我了解到，强化学习相对于有监督或无监督来说，更具有一般性。然而，似乎仍然有一个目标的概念，因此我假设将有一个特定的成本函数来衡量我们离实现目标有多近。下面是对强化学习的一个很好的总结。

右图 →最优解(每步无奖励)
中图 →每步奖励为-0.1 时的解
左图 →每步奖励为 0.01 时的解

上面，图片是一个完美的例子(对我来说),展示了强化学习是多么复杂。如果我们制造一个机器人，它的目标是得到最多的点，最优解将是最正确的图像。然而，根据不同的政策(这一次，每一步都有奖励)，机器人学习的解决方案是完全不同的。从这里开始，ppt 解释了相当多的数学，所以我不会把它作为一个高层次的概述，但是 ppt 有一个非常好的总结页面。

从上文中，我了解到当使用强化学习时，强化学习最具挑战性的部分实际上是设计特征、状态和奖励。

机器学习国际会议(ICML 2007)教程

从之前的演示中，我们已经了解到，具有挑战性的部分是设计状态和奖励。底部的缩写代表马尔可夫决策过程和部分可观测马尔可夫决策过程。

上面显示了状态、行动和奖励的完美示例。我们可以看到，这个设置可以很容易地应用于任何游戏。(国际象棋，开始工艺甚至真实世界的设置。)

不同类型的学习算法，从这里我了解到有不同的类似于分类算法集的算法集，SVM，NN，或者 k 近邻。

强化学习简易入门&其实现(analyticsvidhya)

Image from this website

当我们谷歌强化学习时，我们可以一遍又一遍地看到如上图。因此，与其看到一个代理人或环境，不如把它想象成一个婴儿学习如何走路的过程。

Image from this website

这个例子的“问题陈述”是 行走 ，其中 这个孩子是一个代理人 试图操纵 环境(它行走的表面) 通过 采取行动(即行走) 和他/她当他/她完成任务的一个子模块(即采取几个步骤)时，孩子得到一个 奖励而当他/她完成任务的一个子模块时，将不会得到任何巧克力* (也就是说这是一个强化学习问题的简化描述。——法赞·谢赫***

Image from this website

作者实际上对这些算法的不同之处做了很长的解释，如果你想看的话，请点击这里。不过短短的一/两句话。

监督 vs RL :两者都映射了输入和输出之间的关系，但在 RL 中有一个奖励函数来衡量代理采取的行动，另外还有一个成本函数来衡量我们是否达到了最终目标。(例如赢得一盘棋→赢得比赛很重要，但赢得一盘棋有多种方式)
无监督 vs RL :无监督学习(大多)是在底层数据中发现模式，并对其进行聚类。

最后的话

还有一个帖子，“各种强化学习算法介绍。第一部分(Q-Learning，SARSA，DQN，DDPG) ”是一篇了解不同类型学习算法的优秀文章。总的来说，互联网上有数以百万计的资源，所以任何想学习 RL 的人都不会有时间去寻找资源。

参考

(2018).cs . uwaterloo . ca 2018 年 4 月 6 日检索，来自https://cs . uwaterloo . ca/~ ppou part/ICML-07-tutorial-slides/icml 07-brl-tutorial-part 2-intro-ghavamzadeh . pdf
2018 年People.eecs.berkeley.edu。【在线】。可用:https://people . eecs . Berkeley . edu/~ Jordan/ml short course/reinforcement-learning . PPT .【访问时间:2018 年 4 月 6 日】。
部分可观测马尔可夫决策过程。(2018).En.wikipedia.org。检索于 2018 年 4 月 6 日，来自https://en . Wikipedia . org/wiki/Partially _ observable _ Markov _ decision _ process
马尔可夫决策过程。(2018).En.wikipedia.org。于 2018 年 4 月 6 日检索，来自https://en.wikipedia.org/wiki/Markov_decision_process
各种强化学习算法介绍。第一部分(Q-Learning，SARSA，DQN，DDPG)。(2018).走向数据科学。2018 年 4 月 6 日检索，来自https://towards data science . com/introduction-to-variable-reinforcement-learning-algorithms-I-q-learning-sarsa-dqn-ddpg-72 a5 E0 CB 6287

我的强化学习之旅——第 1.5 部分:使用 Q 学习的简单二进制图像转换

原文：https://towardsdatascience.com/my-journey-to-reinforcement-learning-part-1-5-57f334189655?source=collection_archive---------8-----------------------

GIF from this website

所以今天，我想用 Q-learning 解决一个非常简单的问题，希望能让我的理解更加具体。

警告我还在学习 RL，我学习东西的方式是通过给自己解释概念，而这篇帖子正是如此。注意，我还在学习这个话题，所以如果你是来学习 RL 的，我推荐你不要看我的帖子，而是来自 UCLA 博士生的这个帖子: 深度强化学习去神秘化(第 0 集)

实验设置

左侧图像 →原始图像
→右侧图像 →变换图像
→红色数字 →添加黑色块，共有 4 个

所以整个实验非常简单，我们想从左边的图像到右边的图像。我们只想在给定的图像中增加 4 个黑色块。

Q-学习设置(状态，动作)

黑色数字/线条 →将图像分成 10 个小状态

首先，让我们制作状态，因为我们的原始图像的尺寸是 10 * 100，让我们把图像分成小方块(10 * 10)，这样我们就有 10 个方块。

Modified Image from here

所以我们的 Q-Learning 表看起来会像上面这样。它是一个一维数组，数组的索引是状态，数组中的值是阈值。这意味着我们将有一个阈值过滤器，只让特定的像素强度通过，其他的将被过滤掉。

上面我们可以看到手工制作的地面真值表，我们可以看到零号的索引对准了图像中有黑色块的地方。但是我们想学习这些阈值，而不是手工制作。因此，让我们首先初始化我们的 Q 表如下，所有的 1。

最后，让我们定义奖励可以是什么，因为这让我们简单地对我们有阈值的图像和地面真实图像进行逐位 XOR 运算。

Q-学习设置(奖励-异或不同值)

Image from this website

红框 →图像中的异或运算

在两幅图像之间进行 XOR 运算，将会给出这两幅图像之间有多少差异。因此，如果两个图像相同，XOR 差值将为 0，因为没有差异。否则，如果图像完全不同，我们将获得 XOR 运算的正值，因为存在巨大的差异。

create_data →阈值运算后创建的图像
奖励→create _ data 与地面真值之间的异或运算

因为我们的目标是用正确的值填充 Q 表，所以我们应该减去 1 并除以最大像素强度，即 100。如果阈值是正确的，则奖励 1，如果阈值是错误的，则奖励 0。

电子贪婪探索

我们将创建一个名为 epsilon 的变量，根据这个值，我们将更改阈值或保持不变。此外，随着事件数量的增加，我们将采用较小的数量级，为了数值稳定性，我们将添加 1e-8。

结果

左上 →原始图像
右上 →地面真实图像
左下 →由学习的 Q 表值生成的图像
右下 →由手工制作的 Q 表值生成的图像

我们的 Q 表已经错过了一个块，这是第二个黑色块。但是让我们看看原始的 Q 表结果。

红框 →阈值 1 的值不正确

交互代码

对于谷歌 Colab，你需要一个谷歌帐户来查看代码，而且你不能在谷歌 Colab 中运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要获取这篇文章的代码，请点击这里。

最后的话

滑铁卢大学的一位教授已经给出了使用 RL 来执行分割的示例“ 增强学习在经直肠超声图像分割中的应用 ”我也希望尽快实现该论文。

如果发现任何错误(因为我仍在学习，会有很多)，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你希望看到我所有写作的列表，请在这里查看我的网站。

同时，在我的 twitter 上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。如果你感兴趣的话，我还做了解耦神经网络的比较。

参考

构建 Java 程序第 7 章— ppt 下载。(2018).Slideplayer.com。检索于 2018 年 4 月 10 日，来自http://slideplayer.com/slide/8688800/
drawBitmap，clipPath，UNION，DIFFERENCE，INTERSECT，REPLACE，XOR Android 示例|面向开发者的软件和源代码。(2018).Android . ok help . cz . 2018 年 4 月 10 日检索，来自http://Android . ok help . cz/draw bitmap-clip path-union-difference-intersect-replace-xor-Android-example/
f .萨赫巴、h .提祖什和 m .萨拉马(2008 年)。强化学习在经直肠超声图像分割中的应用。BMC 医学影像，8(1)。doi:10.1186/1471–2342–8–8

我的强化学习之旅——第 1 部分:Q-用表格学习

原文：https://towardsdatascience.com/my-journey-to-reinforcement-learning-part-1-q-learning-with-table-35540020bcf9?source=collection_archive---------2-----------------------

Gif from this website

目前，我对强化学习知之甚少，我想改变这一点，所以这是我学习强化学习的第二步。第二步，我想谈谈 Q——用表格学习。

请注意，这篇文章是为我未来的自己写的，我的学习过程可能会很慢，或者与你的不同。

我学习的方式是向自己解释概念，这篇文章就是这样。注意我还在学习这个话题，所以如果你来这里是为了学习 Q-Learning with table，我建议你不要看我的帖子，而是来自加州大学洛杉矶分校博士生的这篇帖子: 深度强化学习揭秘(第 0 集)

Q 学习理论

Image from wiki

通过谷歌搜索，我了解到 Q-learning 是开始学习 RL 的一个很好的地方，因为我们让代理学习处于给定状态的价值以及从给定状态采取特定行动的回报，这个概念似乎很简单。

与试图学习将观察直接映射到行动的函数的策略梯度方法不同，Q-Learning 试图学习处于给定状态并在那里采取特定行动的价值。”——亚瑟·朱利安尼

Q-学习方程

红框 →更新当前状态 St
蓝框 →当前状态 St 的原始值

现在，让我们只关注这两件事。对于我来说，我喜欢用具体的例子来学习，所以让我们使用 OpenAI Gym 的“frozen lake-v 0”作为例子。(请注意，我不会深入解释这是什么，什么是 Open AI。)

就像上面一样，我们有 4*4 的矩形，在每个状态(或坐标)上，我们要么死，掉进一个洞，要么通过进入目标而获胜，或者只是在冰冻的湖中再走一步，现在让我们实际看看可用状态和动作的表格。

Printed out values

红色数字 →每个状态
蓝色数字 →每个状态下我们可以做的每个动作

现在我们可以看到我们制作的 Q-learning 表有 16 列 4 行。现在让我们回顾一下我们的环境。

红色数字 →在 Q 学习表中代表相关的每个状态

现在，我不能 100%确定这些数字是水平增加还是垂直增加(意味着第一列的数字可能是 1 5 9 13)。我认为这取决于实现，但我们仍然可以得到大致的想法。在每个状态下，我们可以做四个动作，(上图中蓝色数字代表的是什么)，这些动作是上、下、左、右(同样，不确定这是否是准确的顺序，可以是右、左、下、上等等)。但是我们肯定能知道事情的大致方向。所以现在让我们回到 Q 学习方程。

从这里我们可以估计，上面的等式将更新每一行中的某个值(即状态)。选择采取什么行动。

确认和实验

红线 →分排以便于观察
蓝线 →洞内左、下、右、上动作
紫线 →球门内左、下、右、上动作
粉线/开始 →可疑值

我们可以看到，洞内或目标内的动作值都是零，这非常合理，因为游戏在该点结束，我们没有更多的动作可以采取。

注，有一些值值得商榷，比如粉色值。在这个坐标中，我们要么向上走，要么向下走，以求生存。但是在 Q 表中代理似乎向右走，这是自杀。这里我们需要解决不确定性的概念！

这意味着，我们会向右移动，但我们可能根本不会向右移动，我们可能会向上或向下移动一个百分比。我相信，这就是为什么我们的 Q 表已经学会了在粉红色坐标中向右走。

我们可以通过两种方式来确认这些动作的顺序。从源代码中，或者通过我们自己运行代码。

From the source code

现在我们知道了，让我们给我们的代理一个完美的地图，来达到目标。我会用路径**【下，下，右，右，下，右】。**

此外，为了使这个实验具有确定性，我将关闭滑动设置。(请看这篇关于如何做到这一点的 stackoverflow 帖子。)

红线 →上下左右的数组值。

很好，我们可以看到我们的代理完全按照我们想要的方式移动，现在让我们实际应用 Q-learning 来学习这个表，而不是手工绘制路径。通过使用下面的等式。

红框 →实现方程
蓝框 →由于我们是用全零初始化 Q-Learning 表，所以我们要添加一些噪声来得到 random max 自变量。

实验结果(无不确定性)

红线 →每个数字代表每个状态
绿线 →每个状态下的左、下、右、上动作

通过学习到的 Q 表，我们可以清楚地看到我们的代理在每个状态下将采取什么行动，这是**【下右下右下右】。**

我们可以想象代理人采取的每一步，它完全按照我们的预期进行。

实验结果(不确定度)

在存在某种不确定性的情况下，代理人无法学习实现目标的正确路径。一旦我更深入地研究了这个话题，我将在以后回到这个问题上来。

对于希望了解更多折扣系数的人

以上，视频做得非常出色，我们为什么把折扣值。此外，它本身就是一个令人惊叹的视频系列。

交互代码

对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要获取这篇文章的代码，请点击这里。

最后的话

强化学习是非常有趣但又很难的话题。我很高兴能了解更多！

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你希望看到我所有写作的列表，请在这里查看我的网站。

与此同时，在我的 twitter 上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。如果你感兴趣，我还在这里做了解耦神经网络的比较。

参考

使用 Tensorflow 的简单强化学习第 0 部分:使用表格和神经网络的 Q 学习。(2016).中等。检索于 2018 年 4 月 7 日，来自https://medium . com/emergent-future/simple-reinforcement-learning-with-tensor flow-part-0-q-learning-with-tables-and-neural-networks-d 195264329d 0
q-学习。(2018).En.wikipedia.org。2018 年 4 月 7 日检索，来自 https://en.wikipedia.org/wiki/Q-learning
开放/健身房。(2018).GitHub。2018 年 4 月 8 日检索，来自https://github . com/open ai/gym/blob/master/gym/envs/toy _ text/frozen _ lake . py
FrozenLake-v0，O. (2018)。open ai-gym:frozen lake-v 0 中设置 is _ slick = False。Stackoverflow.com。检索于 2018 年 4 月 8 日，来自https://stack overflow . com/questions/43556245/open ai-gym-setting-is-slippy-false-in-frozen lake-v 0
奖励测试序列-佐治亚理工学院-机器学习。(2018).YouTube。2018 年 4 月 8 日检索，来自https://www.youtube.com/watch?v=HhLsIxKq_1s&list = plawxtw 4 sypnidwo 9 e 2c 7 ixisu _ pdSNp&index = 17
深度强化学习去神秘化(第 0 集)。(2017).中等。检索于 2018 年 4 月 8 日，来自https://medium . com/@ m . alzantot/deep-reinforcement-learning-demystized-episode-0-2198 c05a 6124

我的强化学习之旅——第二部分:多臂强盗问题

原文：https://towardsdatascience.com/my-journey-to-reinforcement-learning-part-2-multi-armed-bandit-problem-eefe1afab73c?source=collection_archive---------7-----------------------

GIF from this website

目前，我正在研究强化学习，我想解决著名的多臂强盗问题。(既然这个问题已经非常有名，我就不详细解释了，希望你没问题！).下面是我们将用来解决这个问题的不同类型的解决方案。

请注意，这篇文章是关于我的学习过程的，因为我学习的方式是向自己解释概念，这篇文章就是这样。

问题介绍(多臂土匪)

Image from this website

现在这个问题已经很出名了，因为我不擅长英语(lol)，我已经链接了我朋友(Michael)关于这个问题的解释。如果你想阅读它，请点击这里，或者如果你想阅读更多内容，请点击这里。然而，我将集中讨论解决这个问题的不同方法。(因为我在研究中发现，确实有多种方法可以解决这个部分信息序贯决策问题。)

解决方案 1)ε-贪婪代理

Image from this website

上面的等式是行动-价值函数，它衡量在某个状态下有多好，采取什么行动。然而，在我们的问题中，我们只有一个国家，我们选择哪个国家武装土匪拉，因此我们可以删除符号 s。(这就是为什么我们看不到它的原因。)

如上所述，经过一些扩展和替换，我们可以得到一个更简单的方程。等式的另一种格式可以在下面看到…

Image from this website

我们现在可以将动作函数写入 python，如下所示。

如果我们运行代码，我们可以得到如下所示的结果。

如上所述，一些百分比是关闭的，然而谢天谢地，我们的代理人正确地预测，土匪# 9 有最高的概率。(归功于这个解决方案 michaelpacheco 和 Anson Wong )

解决方案 2)政策梯度

Image from this website

这种方法非常简单，在我们进入更深层次的神经网络之前，让我们只使用简单的对数似然及其导数来选择最佳水平。(有关该解决方案的更多深入解释，请点击此处。)

实验的设置与前一个完全相同，但是现在我们要更新代理的权重。正如上面所看到的，当在 numpy 中实现时，我们将需要执行衍生我们自己。下面是结果…..

如上所述，代理对每个概率的猜测与实际的真实概率有些接近。(归功于这个解决方案亚瑟·朱利安尼

解决方案 3)政策梯度(多层网络)

如上所述，我们可以很容易地创建两个完全连接的网络，使用这种方法，我们可以扩展解决方案 2)，而不是直接获得我们想要拉的土匪，我们可以训练一个神经网络来计算最佳土匪。(使用反向传播)

如上所述，在摆弄网络本身的时候，我不得不剪切梯度以防止它增加 log()的无效输入。(log(0)未定义)。下面是结果……

如上所述，代理能够猜测每个强盗相似的概率，然而，出于某种原因，它从来没有想要拉最左边的强盗。

解 4)线性奖励无为

Image from this website

这种方法比使用神经网络更简单，我们只是要增加在给定的概率分布中选择最佳 bandit 的概率。

如上所述，我们只有在收到强盗的奖励时才会更新。当我们没有任何奖励时，我们不会更新任何东西。

代理人对每个杠杆的最终概率实际上是相当准确的。(归功于这个解决方案迈克尔·帕切科)

解 5)线性奖励惩罚

Image from this website

现在，让我们简单地扩展前面的解决方案，如上所述，当我们没有得到某些土匪的奖励。我们只是要降低那个强盗在下一轮被选中的概率。

添加一条 else 语句，增加几行代码来降低概率，可以得到如下结果。

几乎完美地预测了每一个强盗的概率。(归功于这个解决方案迈克尔·帕切科)

交互代码

对于 Google Colab，您需要一个 Google 帐户来查看代码，而且您不能在 Google Colab 中运行只读脚本，因此请在您的游戏场上制作一份副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要访问解决方案 1 的代码，请点击此处。
要访问解决方案 2 的代码，请点击此处。要访问解决方案 3 的代码，请点击此处。
要访问解决方案 4 的代码，请点击此处。
要访问解决方案 5 的代码，请点击此处。

最后的话

我想把下面的幻灯片/论文包括进来，作为一个例子来说明这个问题有多么复杂和基本…..

Image from this website

Paper from this website

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的推特上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 pos t。

参考

NumPy . random . uniform—NumPy v 1.14 手册。(2018).Docs.scipy.org。检索于 2018 年 6 月 28 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . random . uniform . html
NumPy . set _ print options—NumPy v 1.13 手册。(2018).Docs.scipy.org。检索于 2018 年 6 月 28 日，来自https://docs . scipy . org/doc/numpy-1 . 13 . 0/reference/generated/numpy . set _ print options . html
百分比，R. (2018)。真实 Python 随机百分比。堆栈溢出。检索于 2018 年 6 月 28 日，来自https://stack overflow . com/questions/15613041/real-python-random-percentage
分布，G. (2018)。生成具有给定(数字)分布的随机数。堆栈溢出。检索于 2018 年 6 月 28 日，来自https://stack overflow . com/questions/4265988/generate-random-numbers-with-a-given-numerical-distribution
迈克尔·帕切科。(2018).Michaelpacheco.net。检索于 2018 年 6 月 28 日，来自 https://www.michaelpacheco.net/blog/RL-multi-armed-bandit
反正切函数。(2018).Rapidtables.com。检索于 2018 年 6 月 28 日，来自https://www.rapidtables.com/math/trigonometry/arctan.html
NumPy . arctan—NumPy 1.14 版手册。(2018).Docs.scipy.org。检索于 2018 年 6 月 28 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . arctan . html
导数表。(2018).Math.com。检索于 2018 年 6 月 28 日，来自http://www.math.com/tables/derivatives/tableof.htm
@，D. (2018)。numpy dot()和 Python 3.5+矩阵乘法@的区别。堆栈溢出。检索于 2018 年 6 月 28 日，来自https://stack overflow . com/questions/34142485/difference-between-numpy-dot-and-python-3-5-matrix-乘法
Atan(反正切)函数。(2018).Communityviz.city-explained.com。检索于 2018 年 6 月 28 日，来自http://community viz . city-explained . com/community viz/s 360 web help 4-2/formulas/function _ library/atan _ function . htm
学习率。(2018).Users.ics.aalto.fi 于 2018 年 6 月 28 日检索，来自http://users.ics.aalto.fi/jhollmen/dippa/node22.html
“1E+09”是什么意思？—使用修改过的库存零件。(2013).克巴尔空间计划论坛。检索于 2018 年 6 月 28 日，来自https://forum.kerbalspaceprogram.com/index.php?/topic/36897-what-quote 1e 09 quot-mean-playing-a-moded-stock-part/
自然对数的导数。(2018).Oregonstate.edu。检索于 2018 年 6 月 28 日，来自https://oregonstate . edu/instruct/mth 251/CQ/stage 6/Lesson/log . html
对数的导数—log(x)’。(2018).Rapidtables.com。检索于 2018 年 6 月 28 日，来自https://www . rapid tables . com/math/algebra/logarity/logarity _ derivative . html
[在线]请访问:https://www . quora . com/What-is-the-multi-arm-bandit-problem-What-is-some-of-its-implications[2018 年 6 月 28 日访问]。
解决多臂强盗问题-走向数据科学。(2017).走向数据科学。检索于 2018 年 6 月 28 日，来自https://towards data science . com/solving-the-multi-armed-bandit-problem-b 72 de 40 db 97 c
迈克尔·帕切科。(2018).Michaelpacheco.net。检索于 2018 年 6 月 28 日，来自https://michaelpacheco.net/
解决多臂强盗问题-走向数据科学。(2017).走向数据科学。检索于 2018 年 6 月 28 日，来自https://towards data science . com/solving-the-multi-armed-bandit-problem-b 72 de 40 db 97 c
NumPy . clip—NumPy 1.14 版手册。(2018).Docs.scipy.org。检索于 2018 年 6 月 29 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . clip . html
(2018).Cs.cornell.edu。检索于 2018 年 6 月 29 日，来自https://www . cs . Cornell . edu/people/TJ/publications/yue _ joachims _ 09a . pdf
兰福德，j .，，张，T. (2008)。带边信息的多武装匪徒的历元贪婪算法。papers . nips . cc . 2018 年 6 月 29 日检索，来自https://papers . nips . cc/paper/3178-the-epoch-greedy-algorithm-for-multi-armed-bottoms-with-side-information
交叉熵和对数似然。(2018).Awebb.info .检索于 2018 年 6 月 29 日，来自 http://www.awebb.info/blog/cross_entropy
Tensorflow 中的简单强化学习:第 1 部分—双臂土匪。(2016).中等。检索 2018 年 6 月 29 日，来自https://medium . com/@ awjuliani/super-simple-reinforcement-learning-tutorial-part-1-FD 544 fab 149

我与 TensorFlow 的旅程

原文：https://towardsdatascience.com/my-journey-with-tensorflow-371bc31c2dbf?source=collection_archive---------6-----------------------

是的，不要读这个

TL；速度三角形定位法(dead reckoning)

对 OpenAI 健身房的环境有一个基本的了解。值得注意的是，env.observation_space.shape和env.action_space.n。
理解 Q-Learning 是一个马尔可夫决策过程。你有状态，这对于有连续输入空间的东西来说很棘手。
实际上，要明白几乎每个强化学习问题都是一个 MDP。甚至那些或多或少具有无限状态/动作空间的仍然被视为 MDP。您可以将这些空间转换为功能空间，使它们更易于管理。

老实说，我对过去几年的整个神经网络运动非常感兴趣。我尤其对强化学习及其在游戏中的应用感兴趣(参见 OpenAI Gym )。凭借我在大学时对机器学习和微积分的基本了解，我现在正走在一条构建一些很酷的东西的道路上。

卑微的开始

“好艺术家借，大艺术家偷”
~ 链接

我想我会把下面这篇文章和 OpenAI 健身房的 CartPole-v0 结合起来。这个想法是从一个“更简单”的算法(Q-Learning)开始，然后转移到神经网络进行一些比较。

[## 使用 Tensorflow 的简单强化学习第 0 部分:使用表格和神经网络的 Q 学习

在我的强化学习系列的这个教程中，我们将探索一个叫做 Q……

medium.com](https://medium.com/emergent-future/simple-reinforcement-learning-with-tensorflow-part-0-q-learning-with-tables-and-neural-networks-d195264329d0)

在对观察空间的大小和一些被否决的函数有一点困惑之后，我意识到 Q-Learning 不适合 CartPole，因为观察是连续空间而不是离散空间。幸运的是，TensorFlow 有一个 很棒的初学者指南使用 MNIST 数据集！

这给了我们代码，但是我们仍然需要把这个分类算法变成一个学习算法。Github gist为 CartPole 示例的“奖励模型”提供了一些背景。Github gist提供了一种非统计方法来“解决”问题。这很好，因为我们基本上想要“学习”手动方法。这个来自 tflearn 的 Github repo 的例子很好地模拟了我们正在做的事情，只是我们没有这么大的输入空间。

因此，过一段时间后，您可能会看到以下内容:

inputs = tf.placeholder(tf.float32, [
  **None**,
  action_repeat,
  env.observation_space.shape[0]    ])
net = tflearn.fully_connected(inputs, 4, activation='relu')
q_values = tflearn.fully_connected(net, env.action_space.n)

基本上，我们在我们的网络中存储了历史的样本。理想情况下，我们的网络将能够根据连续的帧来判断杆子朝哪个方向落下。

如果我们记录直到失败的迭代次数，我们可以看到如下结果:

took 51 iterations
took 46 iterations
took 51 iterations
took 29 iterations
took 33 iterations
took 38 iterations
took 73 iterations

没有明确的迹象表明我们的算法正在收敛到一个解。:(

后退几百步

在这一点上，很明显，即使对强化学习有很高的理解，也不足以构建一个算法。我把这比作使用网络浏览器和构建网络服务器。

我花了一点时间看了大卫·西尔弗的强化学习课程。我从第三课开始，虽然我真的应该从头开始。直到第七讲，演员批评的方法才被提出来。(此外，看起来还有另一个参考大卫·西尔弗讲座的综合信息这里)。

这篇博客文章我已经读过一百万遍了。它有很多有用的信息，但我认为如果没有基本面，大部分信息都没有意义。

以下是我收集的一些信息:

你可以把一个强化学习问题分解成两个步骤:奖励函数和策略函数。
有两种类型的问题:预测和控制。参见本讲座中的第 21/22 张幻灯片。一方面，我们可以专注于建立预测

我还发现了这篇关于 CartPole-v0 的一些非常简单的策略的博文。我认为这在建立政策梯度方面做得最好。如果你理解了随机搜索和爬山是怎么做的，你就会对政策如何运作有一个直觉。

Sample Rewards for my implementation of Hill Climbing

爬山很容易实现。如果您想获得 TensorFlow 构建模块(摘要、占位符、会话、随机初始化)的经验，这是一个可靠的算法。我犯了一个错误，在“step”循环中添加了占位符。基本上，我们在我们的会话图中增加了新的操作(矩阵乘法),这(我认为)使得图的评估更加复杂。因此，性能会降低并最终停止。

未来几周，我将深入探讨政策梯度。请在这里随意查看我的一些示例代码:

[## jgensler 8/my-tensor flow-journey

我的张量流之旅——开放健身房的一些实验

github.com](https://github.com/jgensler8/my-tensorflow-journey)

我在大会数据科学训练营的最后一周

原文：https://towardsdatascience.com/my-last-week-of-general-assemblys-data-science-boot-camp-67342686e7d3?source=collection_archive---------5-----------------------

我余生的第一周

“如果我们有数据，让我们看看数据。如果我们只有意见，那就用我的吧。”

网景公司前首席执行官吉姆·巴克斯代尔

如果你看过我的第一篇博文，你就知道我上过总会的数据科学训练营，被称为数据科学沉浸式。这是一个为期 12 周的项目，主要是为那些想在数据科学领域迈出第一步的人设计的；但它的构建方式也是为了让你为任何(入门级和初级)数据科学工作做好准备。在这个项目中，我们有超过 100 个小时的讲座，被要求做 40 个关于我们刚刚学到的内容的练习\作业(也称为实验)，做五个项目和一个顶点项目，在非技术要求中，写十篇博客文章(九篇博客文章和另一篇关于期末项目的文章，那篇文章很快就会出现😊 ).这是我“不得不”(或被要求)在项目博文之前写的最后一篇博文。

但是，正如我在这个项目中学到的，仅仅因为我不“必须”做某事，并不意味着我不应该做这件事！起初，我害怕每周写一篇博客，尤其是当英语不是我的第一语言时，但我最终真的很喜欢它(我当然希望你也喜欢我的帖子！)—这给了我一个机会来复习我在课堂上学到的东西，并尝试向世界解释它，从而巩固我对材料的掌握。它开始只是一个额外的任务，最终对我来说成了一个很好的学习(也有人会说是教学)工具。这绝对是我要继续做的事情！

虽然在过去的 12 周里我学到了很多，但我主要是学会了如何学习和如何不断获取新工具。我的一位导师将我们项目中的学习定义为“用消防水管喝水”大多数时候，这就是我的感觉。但随着时间的推移，感觉更容易控制了。这让我更加好奇，更加渴望了解更多。我学到了很多，但我意识到我是多么需要(和想要)学习更多。作为一个没有任何数据科学背景的人，我知道这个程序基本上只是在试探我的脚趾(好吧，可能不仅仅是我的脚趾！)在数据科学的世界中——我真的很兴奋能继续沉浸在这个领域中！

It’s still drinking from the firehose — but it’s a little more manageable!

这是我第一篇博文中的一段话:

现在，我在华盛顿特区的 General Assembly 启动了一个数据科学项目。这可能是我一生中做过的最困难的事情，而且这只是项目的头几周。有些时候，我真的很兴奋，因为我想到要学习某些主题，而有些时候，我会想，“我在这里做什么？”

在那篇文章之后的几周里，这个项目并没有变得更容易，实际上变得更难了，但我想这有点像那句名言(或陈词滥调，取决于你如何看待它)“生活不会变得更容易，你只会变得更强大。”我并不总是感觉更强壮，但是我就要完成这个项目了，所以我想我会的。“我在这里做什么？”我肯定有答案了这正是我应该做的！我现在知道这是我职业生涯的一个伟大方向，来到大会是一个伟大的选择，我不后悔。尽管我对未知有点紧张，但我对即将到来的伟大事情感到兴奋。

行为克隆:让汽车自动驾驶…

原文：https://towardsdatascience.com/my-learning-from-udacity-sdc-nanodegree-do-we-really-need-a-complex-cnn-and-hours-of-training-4f80e28af90b?source=collection_archive---------5-----------------------

Driving Car on Simulator Provided By Udacity

是的，像往常一样，我从几十个卷积层和六个密集层的复杂 CNN 架构开始，因为 Keras(感谢 Keras 团队让 tensorflow 变得如此简单)使创建神经网络变得更容易。我是开玩笑的:-)我刚开始使用类似于 NVIDIA 的架构，它有五个卷积层和三个完全连接的层，以及大量的训练数据，通过放大左、右相机拍摄的每幅图像等。顺便说一下，我已经使用 Udacity 提供的数据集来训练我的模型。

是啊，看起来像是我完成了一件大事，对吧？但是，我们需要像 NVIDIA CNN 架构这样的复杂 CNN 架构吗？NVIDIA CNN 架构用于现实生活场景、数小时的培训时间和大量数据，以便在 Udacity 为该项目提供的模拟器上运行我们的汽车？

我们来讨论一下…

我们需要什么来确定可驾驶区域和预测转向角度，以便我们的车辆在模拟器上平稳行驶而不会出现任何故障？

对于识别转向角度的汽车，我们需要像道路边缘这样的特征。在 CNN 中，这样的高级特征是在初始层提取的。

记住这一点，我开始减少我的 NVIDIA CNN 模型的层数。我尝试了三个卷积层和三个致密层。然后我尝试了两个卷积层和两个致密层，最后一次尝试是一个卷积层和一个致密层。使用最后一种配置，我能够在大约五分钟的较短训练时间内达到与我以前的试验相似的性能。

我这个项目的最终模型由单一卷积层，然后是下降层，最大池层和单一密集层组成，如下所示

Model used for training CNN for project 3

正在生成数据集:-

为了生成这个模型的数据集，我通过使中心图像的原始转向角的转向角为-ve，拍摄了所有的中心摄像机图像及其翻转的对应物。翻转图像是为了平衡数据集，以便模型不会偏向任何特定条件。为了将恢复数据添加到我的数据集，我通过将左相机图像的转向角偏移 0.4 并将右相机图像的转向角偏移-0.3 来拍摄所有的右和左相机图像。我生成的数据集的分布如下所示

Steering angle distribution of generated dataset

我们可以看到数据集几乎是平衡的。由于我们的大部分赛道是直的，我保留了更多 0°转向角的样本。

处理图像:-

下图包含了每台相机拍摄的一些图像样本

Image samples from each camera

为了训练我们的模型，我们不需要上面图像中的所有细节，比如自然风景，天空，环境等等。我遵循的第一条基本原则是向网络提供你想让它看到的细节。为了去掉多余的细节，我从顶部裁剪了 80 像素，从底部裁剪了 20 像素。

裁剪后的图像示例如下

Cropped Images

然后我把图片的大小调整到 32 X 32，因为这将使模型更快，我们在这个场景中不需要低层次的细节。在对调整过大小的图像进行标准化之后，这些图像被作为输入传递给 CNN。

过度拟合:-

在训练模型时，我发现该模型在训练集上具有低的均方误差，但是在验证集上具有高的均方误差。这意味着模型过度拟合。

为了克服过度拟合，我添加了 dropout 层和 maxpooling 层，然后是卷积层，并将 epoches 数减少到 2。

有了这个模型，我可以在一号赛道和二号赛道上驾驶车辆。

我在模型中使用的参数

历元数= 2
使用的优化器- Adam
学习率-默认值为 0.001
验证数据分割- 0.2
生成器批量= 32
修正系数- 0.4 和-0.3
使用的损失函数- MSE(均方差，因为它对于回归问题是有效的)。
激活函数- RELU
下降- 40%(在第一个激活层之后，以 combact 过度拟合)
使用的数据集-由 Udacity 提供(除原始数据集外无其他图像)。

自主模式下的轨道 1 视频:-

Track 1

自动模式下的轨道 2 视频:-

Track 2

该模型能够在第二条赛道上驾驶，而无需为第二条赛道重新训练。因此，我们可以说，这是足够普遍的，而不是过度拟合。

链接到该项目的 github 库。

我和 JSON 的恋情

原文：https://towardsdatascience.com/my-love-affair-with-json-edaca39e8320?source=collection_archive---------0-----------------------

Photo by Glenn Carstens-Peters on Unsplash

对我来说， JSON (JavaScript 对象符号)是一种令人愉快的数据共享/传输格式。使用和阅读都很简单。处理起来非常快。它也是更容易阅读的 YAML 的子集。

我已经发展了个人的最佳实践，用于处理以 JSON 为核心的数据，我将在下面分享。这些最佳实践是我从他人那里学到的，也是我在处理生物制药数据时的个人经验，这些数据虽然一般不是很大，但往往是非常异构的，数据格式也不是很稳定。我不想建议您对所有事情都使用 JSON。例如，出于性能原因，有时需要二进制格式。

对于大多数语言来说，它的序列化和反序列化速度非常快，这意味着它可以轻松快速地发送到另一个进程，保存到磁盘/文件和检索。您可以将数据对象作为 JSON 保存到磁盘，然后将该文件发送给使用不同语言的其他人，通常他们选择的编程语言中有一个库/包，可以轻松地将它从 JSON 数据对象反序列化为数据结构变量。

序列化意味着转换为磁盘上的文件，例如，将变量(数据对象、列表或字典/哈希)从应用程序转储到磁盘。反序列化则相反，将文件读入应用程序变量。

javascript 对象、python 字典、perl 散列或关联数组基本上是相同的概念，尽管我用 javascript 对象扩展了一下。任何使用键、值格式的数组，如 fruit_colors['apple'] = 'red '。此后，我将把这个数据结构称为散列。

最佳实践 1——JSON 适用于所有事情

尽可能使用 JSON 在应用程序和数据科学家之间共享结构化数据。为了以最大的通用性轻松做到这一点，在使用 ISO 日期格式保存到 JSON 之前，请始终将日期转换为字符串。我没有在我的 JSON 包中添加定制的 JSON 格式化程序来处理日期和其他非 JSON 的简单格式(例如，字符串、数字、数组、散列)，我通常只是将其转换为字符串表示，并在反序列化时将其从字符串转换回日期。

JSON hash and array example:{
  "key": "value",
  "example_array": [
    "one",
    "two"
  ]
}

我通常将 JSON 序列化到带有缩进和换行的数据文件中，以使其更容易阅读，但您不必这样做。您可以将所有内容都放在一行中，没有多余的空格或换行符，以使其更小，尽管我发现这通常没有什么影响，因为如果 JSON 数据非常大，在存储或传输到另一个服务器时，您总是希望对其进行压缩。对于 REST API 服务器传输 JSON，你总要在 webserver 上开启 压缩。

最佳实践 2 — JSONSchema

使用 JSONSchema 来描述你的数据集。即使您只是自己使用它，它也可以帮助您思考您存储的内容，并提供描述属性，以便于记录您的格式。这是描述易于共享的 JSON 数据的最佳标准方式，大多数编程语言都可以用它来验证数据集。

在 JSONSchema 中，并不是数据集验证的每个方面都可以被捕获，有些东西需要放到代码中，但是它可以捕获数据结构定义的大多数方面。

我将经常构造我的 JSONSchema 定义，以使用 JSON 数组和 JSONLines(下面解释)格式——这里的例子是。

如果您认为 JSONSchema 文件具有更广泛的公共利益，那么 JSON Schema Store 是发布 JSON Schema 文件的好地方。

我已经开始在我的 JSON 数据中添加 JSONSchema 定义的 url，这样我就有了用于该数据的模式定义的引用——特别是如果它是一个长期演化的数据集。

最佳实践 3——YAML 是

使用 YAML 进行 JSONSchema 定义。是的，JSONSchema 定义的 YAML。一般来说，要使用 JSONSchema 验证 JSON，您必须首先将 JSONSchema 定义文件加载/反序列化到您的应用程序中进行验证，因此使用什么格式并不重要。YAML 允许评论(JSON 不允许)，对人类来说更容易阅读。

# You can have comments in the YAML file like this
key: value
example_array:
  - one
  - two

有一个很好的 python 包叫做 json2yaml ，它很好地完成了 json 和 yaml 文件之间的来回转换，同时保持了散列的顺序。如果您将 YAML/JSON 用于配置或者有标准的数据顺序，那么保持它的自然顺序会很方便。大多数 JSON/YAML 转换器将按字母数字顺序对数据进行排序。当来回转换时，你会丢失 YAML 的评论，所以我倾向于使用 YAML 作为真实的原始来源，并根据需要转换成 JSON。

我更喜欢将 YAML 用于人类可读的、可维护的配置文件。这种模式的一个例子是使用 YAML 编写 BEL 语言规范文件，然后将它转换成一个增强的 JSON 文件，为了方便起见，还以编程方式生成了附加部分。

最佳实践 4 — YAML 第一

除非您已经检查了 YAML 解析器的性能，否则不要将 YAML 用于与性能相关的任务。我没有意识到 Python 中的 YAML 解析器比 JSON 慢这么多。在 Python 3.4+中， JSON 的执行速度几乎与任何内置序列化格式(例如 pickle) 一样快。

读入大约 1000 行长的 BEL 规范 YAML 文件大约需要 150 毫秒。读入该文件的增强 JSON 版本大约需要 6 毫秒，这个版本大约长了 50%。YAML 是一种比 JSON 更复杂的解析结构，而且它也没有那么受欢迎，所以性能调整较少。

因此，YAML 非常适合在需要大量人工交互和编辑的地方使用，并且不会造成瓶颈，因为它必须在高吞吐量的数据管道中反复解析。

最佳实践 5 — JSONLines

JSONLines 是一种将较小的 JSON 数据一起存储到单个数据集的好方法，当您想要减少处理的内存开销或能够处理流数据时。JSONLines 的概念是数据文件的每一行都是一个单独的 JSON 对象，如下所示。

JSONLines - each line below is a separate JSON object{"key": "value1", "key2": "key2value"}
{"key": "value2", "example_list": [1, 3]}
[1, 5, 10]

我处理术语数据集中的术语(BEL 名称空间),这些术语可能有数百万个条目。如果我使用一个像下面这样的顶级数组，我必须将所有这些项读入内存来处理它们。因为我一次只需要处理一个术语，所以我可以使用 JSONLines 格式一次读取一行(一次读取一个术语),并使我的内存开销降低几百万倍。

JSON array of objects:[
  {
    "key": "value1"
  },
  {
    "key": "value2"
  }
]

如果我在一个 JSONLines 文件中有多种类型的数据对象，我将添加一个顶级键来标识每种类型。一个例子是:

{"metadata": {"author": "William Hayes", "date": "20180101", ...}
{"nanopub": {"id": 1, "citation": {...}, "assertions": {...} }
{"nanopub": {"id": 2, "citation": {...}, "assertions": {...} }

处理 JSONLines (*)的一些小技巧。jsonl)文件。我将较大的 JSONLines 文件进行了 gzip 压缩，并使用了基于以下内容的自定义 bash 函数:

gunzip -c $1 | jq . | more;

要 gunzip 到 STDOUT，使用 jq 使用缩进/换行格式化每个 line/JSON 对象，并一次查看一页。我个人发现 gzip/gunzip 在速度/压缩方面是一个很好的平衡。Bzip2 压缩效果更好，但速度慢得多。你的需要可能与我的不同。

最后的想法

谢谢你，谢谢你，谢谢你道格拉斯·克洛克福特指定 JSON 并帮助它取得今天的成功。我经历过 CSV、ASN.1、SGML、XML 和各种风格的定制数据格式，无法在这里充分表达我对 JSON 的热爱。各种语言的 JSON 解析器、JSONSchema、YAML 等的创建者对 API、数据科学和信息学产生了巨大的影响，但这种影响还没有得到充分的认识。

我的大脑只是一个神经网络

原文：https://towardsdatascience.com/my-mind-is-just-a-neural-net-769fb82f39c1?source=collection_archive---------9-----------------------

Photo by Drew Graham on Unsplash

但是什么是神经网络……我的思想是什么？

哲学应该和数据科学成为更好的朋友。需要明确的是，数据科学也应该更好地与哲学合作。当分析大数据引发的伦理困境时，很明显，道德哲学对于改善数据科学至关重要。不过这是另一天的讨论。今天，是时候讨论相反的情况了；数据科学如何改善哲学？

本文将解决的问题:

什么是神经网络？
人的心灵是什么，我的思想是什么？
自由意志存在吗？
我的思维可以分解成数学算法吗？
强 AI 真的可能吗？
看起来像人类的机器人能像我们一样感受情感吗？
明天的中奖号码是多少？

好吧，也许不是最后一个。但你的关注给了我一个+分。

为了讨论大脑与神经网络的关系，我想确保每个人都在同一页上。不需要成为专业的数据科学家或者哲学家国王才能参与。我将在高层次上解释神经网络和身心问题，这样概念就不会掩盖潜在的顿悟。系好安全带，打开你的思想，坚持你的倾向；我向你呈现:身心问题。

我是我的思想吗？我是我的身体吗？它们是一样的吗？

二元论对一元论

有两种选择。要么我们的身体和我们的思想是两个不同的实体[二元论]，要么它们是同一的[一元论]。自从宗教创立以来，哲学家们就一直在争论这个问题。如果思想和身体是分离的，那么有可能存在一个永恒的灵魂能够比腐朽的尘世自我活得更久。如果思想是身体，我们的思想、信仰和记忆将和我们的碳生命同时死亡。

你的一分钟心灵哲学速成班

二元论认为我们的头脑是由一个独立的东西组成的，而不是大脑。问问勒内·笛卡尔、基督徒或任何相信灵魂不朽的人。
消除主义是一种理论，认为任何精神状态实际上都是它的科学对应物。例如，如果我感到疼痛，消除师会说我只是在体验我的 c 纤维燃烧。
行为主义暗示精神状态=在特定环境下以特定方式行事的倾向。(又名:我们只不过是刺激和反应的生物)。
功能主义是行为主义和二元论的伪结合。功能主义者认为，人类的思想是刺激、反应和某种介于和之间的东西。
大脑的计算理论(CTM) 是一种认为人类大脑是一台计算机的理论。想想图灵机。
连接主义认为 CTM 没有准确地捕捉到人类的思想。相反，连接主义者认为人类的大脑是一个神经网络。这将是一个重要的理论焦点。

你的神经网络速成课程

为了将神经网络从一个时髦词汇变成可理解的词汇，考虑一下这个煎饼比喻。假设我是一个假设的煎饼鉴赏家。每个星期天，我都会拿出酪乳和煎锅，试图做出完美的令人垂涎欲滴、黄油融化、感官超负荷的烙饼。但是，经过多年的练习，我似乎还是做不出比脆饼更好的东西。

我决定唯一合理的解决方案是外包我的煎饼制作能力；我要训练一个神经网络来帮我做这件事。我需要一些东西:

**训练数据集:**指定输入特征及其相关结果的表格。对于我的煎饼，桌子可能看起来像这样:

(Real training data usually consists of MANY more trials than this example)

神经网络层:神经网络由三层组成。输入层、隐藏层和输出层。对于我的第一个煎饼创作试验，它看起来像这样:

暂时不要过于关注隐藏的东西，我们会仔细研究的。注意红线的意义。一层中的每个单元都连接到下一层中的每个单元。

**重量:**每条红线都有一个相关的重量。首先，这些权重是任意的，通常只是随机数。这些将向前传播到隐藏层，给隐藏层中的每个单元一个权重。请看下面的视觉帮助:

The numbers in the hidden stuff aren’t exactly correct yet, but we’ll go over that next.

通常最简单的连接权重是介于-1 和 1 之间的数字，但是对于这个例子，连接权重被随机选择为 8、2 和 1。这是“第二面上的分钟”功能的首次试用输入。

激活函数:这个函数告诉我们可以在隐藏层中放置什么。对于上图，激活函数将是连接权重乘以单位权重的和。∑( 连接权重 x 单位权重)。让我们称之为 x。通常，激活函数只是使用 x 作为它的输入。

例如，假设激活函数= f，那么 f(x)会告诉我们在“隐藏的东西”中放入什么数字(记住 x 是所有输入权重的总和)。文字令人困惑，所以看一下这个视频来澄清一下:

This is our pancake neural net with two input units. [f is our activation function]

神经网络各层的工作方式是，这个过程将贯穿所有隐藏层。这被称为正向传播。最后，输出单元的激活函数将导致神经网络吐出“好煎饼”。

为了让视觉效果更容易理解，我把“好煎饼”放在了输出单元的内部。实际上，输出单位看起来更像 f(5.4)。然后，基于一些算法( ReLU 是常见的)f(5.4)=‘好煎饼’。

请记住，可能有更多的输出单元。也许是 f(5.4)，f(1.2)，f(3)，等等…然后算法会考虑所有这些输出单位，并吐出“好煎饼”。为了简单起见，我们现在坚持使用一个输出单元。

**训练我的神经网络:**在第一个视觉中，神经网络猜测六个提供的输入导致“好煎饼”输出。但是如果它猜错了呢？神经网络最显著的特征之一是它能够学习。比方说，我的第一次煎饼试验实际上是一个可怕的，干燥的，烧焦的烙饼。然后神经网络猜错了。

那么我们如何解决这个问题呢？通过称为反向传播的过程，神经网络能够修改连接权重，以便它在未来更有可能猜出正确答案。理论上，随着我提供更多的训练数据，神经网络应该从它的错误中学习，直到它变得尽可能准确。

唷，那是许多技术术语。现在我们明白了我们的思维可能是什么，以及神经网络是如何工作的……但是我的思维是如何工作的呢？

连接主义

仔细想想上面的例子。基于许多试验，神经网络最终将能够非常准确地确定哪些因素导致了“好煎饼”，哪些因素导致了“坏煎饼”。

人类不就是这样学习的吗？如果我决定不把我的烹饪技能外包给神经网络会怎么样？下面是将会发生的情况:

根据我的第一次试验，我用锅上的黄油做一个薄饼，在第一面放一分钟，翻转一下，在另一面放 30 秒。我咬了一口。这煎饼不错。正向传播。

在第二次试验中，我感觉有点冒险。我锅里不加黄油，煎饼第一面放两分钟，翻面，另一面放一分钟，用锅铲压平，咬一口。不需要火箭科学家就能发现我咬了一口难吃的煎饼。焦了，平了，干了。

现在我知道了，从试验一到试验二，我至少改变了一件事，导致我的煎饼从好变坏。也许在我的第三次试验中，我会做和第一次试验一样的事情，但是我只会改变其中一个制作煎饼的属性。反向传播。我又做了一个好吃的煎饼。

最终，如果我做得足够多，理论上我会成为一名煎饼制作专家。我将创建一个非正式的心理算法，它能理解热量、每一面的烹饪时间和抹刀展平的哪一个可变性会带来好的煎饼；哪种组合会导致糟糕的煎饼。也许我的朋友会开始信任我的厨艺。看起来我的大脑就像神经网络一样工作。或者更确切地说，我的大脑像一个联结主义网络一样工作。

除了煎饼混合物，还有其他一些支持连接主义的引人注目的论点。其中一个最大的论点是神经网络擅长我们擅长的事情，而不擅长我们不擅长的事情。我说的是面部识别、心算、记忆等。神经网络和我们的大脑一样面临着同样的问题。他们也非常擅长从人群中识别熟悉的面孔。

在这一点上，连接主义者的论点看起来有点前途。但是，如果我的思想可以被演绎成一个算法…我甚至能对自己的决定负责吗？自由意志存在吗？

生命的意义

为了回答关于自由意志的问题，我们必须回到我们的老朋友笛卡尔那里。对于二元论的支持者来说，自由意志的存在是因为我们的思想(灵魂)与我们的大脑(身体)是分离的。对于几乎所有其他事物的支持者来说……我们的思维只是一种行为，一种计算，或者是加权特征的组合。

对一个联结主义者来说，如果我相信天空是蓝色的，我的思想可以被推导为一个输入的特征，它引导我去相信它。我对蓝色和天空的知识与我的视觉皮层相结合，通过我的神经递质(类似于上面的图表)并行发送，直到我达到 f(5.7)。或者说，f(5.7) =我对天空是蓝色的信念。

还有两个问题需要解决:

强 AI 真的可能吗？
看起来像人类的机器人能像我们一样感受情感吗？

理论上，随着神经网络变得越来越高效和精确，它们变得越来越像人脑。尽管联结主义似乎是逻辑上最有前途的身心理论，但上述问题只有在与心灵的计算理论(CTM)相关时才能得到回答。弱人工智能每天都围绕着我们，但强人工智能还没有被制造出来。

记住 CTM 类似于图灵机。它解释了人类的思维是如何缩小到 0 和 1 的微小集合的。有了 CTM，世界的句法(就像煎饼煎到一边的时间)与我们的神经递质结合，创造了世界的语义(我的烤焦的煎饼味道很差)。语法是可观察的信息，语义是这些信息对我们的实际意义。

过去，人类认为强人工智能和人工智能中的情感理解将源于语义理解。现在，机器人、聊天机器人和人工智能代理只能处理信息。没有任何迹象表明更高层次的理解正在形成。

为了进一步解释，想象一下这个思想实验(被称为中文室)。在这个实验中，有一个人在一个堆满文件柜的房间里。从理论上讲，这些柜子里堆满了如何用中文回答问题的英文说明。当房间里的人得到一个塞在门下的中文短语时，他们会查找如何回答给定问题的说明，写下新的汉字，然后塞回门下。

在旁观者看来，这个房间里的人中文很流利。他们能够看到中文问题，并提供中文回答。这个人会通过图灵测试。但是，房间里的人真的懂中文吗？他们已经学会了如何根据书面汉字的语法做出反应，但他们对教室外的语言一无所知。这里不涉及任何语义。

同样的论点也适用于人工智能。即使机器人很可能会通过图灵测试，看起来好像它们能理解我们，但它们的机器人大脑真的能理解我们吗？如果人工智能是使用基于指令的解决方案创造的，那么机器人的理解能力将会和中国房间里的人一样差。虽然人工智能代理可能会告诉我它“感到悲伤”，但这种说法只是一种编码反应，还是它真的感到悲伤？真正的强人工智能似乎更适合像神经网络这样的东西。

在这一点上，消除主义者会认为语义学根本不存在。人类被我们自己的大脑欺骗了，就像我们在炎热的日子里在沙漠中看到海市蜃楼一样。我们认为我们在比语法更高的层次上理解世界，但是我们没有。我们的大脑实际上只不过是一组指令，或者说是一个连接网络。

等一下

哇…所以根据 CTM 和联结主义，心灵只是一些科学上可观察的实体。我的思想不存在形而上学的、神圣的维度。人生毫无意义。哲学和数据科学终于在沙盒里一起玩了，但我不知道我是否还想让它们玩下去！

别担心。现在还不到否认自由意志的存在并屈从于悲观的、决定论的人生观的时候。是的，神经网络正在变得更好，但这并不一定意味着连接主义是强人工智能的一站式商店。

反对连接主义的论点

首先，神经网络的学习时间比人类长得多。长度在这里不一定指时间，而是指审判。虽然网络通常需要数十万个样本才能有效学习，但人类可以在明显更少的试验中学习类似的任务；而且通常更准确。

二、神经网络纠结于 合理性、系统性、和结构 。基本上，这意味着人类在语言方面更擅长逻辑和结构。以这句话为例:

“如果丹尼尔剪了头发，约翰会哭的。丹尼尔剪头发。”

作为人类，我们可以从逻辑上推断出约翰现在会哭。然而有趣的是，神经网络与这个概念有冲突。同样，如果丹尼尔不理发，神经网络倾向于认为约翰会而不是哭。正如命题逻辑已经证明的那样，不一定是真的。

现在怎么办？

这取决于你。哲学家们就这个问题争论了数百年是有原因的。神经网络和弱人工智能正在慢慢填补一些有前途的理论中的漏洞。这并不意味着它们是唯一的答案。

二元论和决定论将永远处于战争状态。不能被观察到的事物(比如:思想)提供了科学知识的空白(比如:“什么是思想？”).在历史上，宗教充当了一个“神的缺口”。它填补了科学知识的空白。随着科学的进步，越来越少需要宗教来解释。在人工智能领域，科学的空白在历史上一直被哲学填补。正如宗教的情况一样；似乎随着科学越来越好，某些哲学理论陷入了困境。

我的建议？尽量不要想太多。我们的语义就是我们对它们的理解。也许我的心灵是一个无意识的存在，可以自己做决定，有自己的信仰。也许我的脑子里只有 0 和 1。不管我的想法是真实的还是海市蜃楼，我要继续过我的生活；我只能做到这样了。

我叫伊尼戈·蒙托亚。一个与语音识别应用共情的案例。

原文：https://towardsdatascience.com/my-name-is-inigo-montoya-a-case-for-empathizing-with-speech-recognition-apps-622a4b8c4ea1?source=collection_archive---------3-----------------------

你好。我的名字叫蒙古朋友。叹气。靛蓝拉托亚。Grrrr。伊尼戈蒙托亚。

有时候，在使用语音识别应用程序时，你需要竭尽全力保持冷静。对我们许多人来说，名字是最糟糕的压力源。

credit: rabbittooth

我住在旧金山湾区，所以我在一个大熔炉里工作和玩耍，这里的多样性是一个美妙的现实。涉及到人名的时候更是如此。事实上，没有比湾区更好的名字识别试验场了。

作为一名听写超级用户，我每天都在滥用谷歌、苹果和亚马逊的助手。在过去几年中，我发现语音识别引擎准确识别姓名的能力差别很大:

☀️ 完美无瑕。苹果和谷歌在听写过程中都能很好地识别我朋友的名字。他们总是毫不费力地“得到”像乔纳森、多琳、乔斯和迈克这样的名字。

🌤**适中。*一大堆名字被认出来了 iff 我努力把名字念得太多了:Siobhán，Valeriu，Cynan，Margot，Rajeev，等等。如果这不起作用，我绝对必须过度“英国化”或过度“美国化”他们的发音，以加快名字识别的速度。像这样的名字足够独特，即使我的发音不完美(事实并非如此)，将它们与我的地址簿中的条目进行匹配也应该相当简单。

🌧惨不忍睹。此外，还有“其他”的名字，如 Ritesh、Andrei、Karuna、Jernej、Tudor、薛、Rohit，当然还有我自己的名字:Lucian。后者是荒谬的，因为所有这些服务在任何时候都知道用户是谁。即使我/我们每天都提供数量惊人的个性化训练数据，这些名字还是被屠杀、变形或完全遗漏了。有时这样的打嗝很好笑，但绝对不是当你试图完成工作的时候。

自动语音识别(ASR)算法一直在改进，虽然我毫不怀疑这些打嗝会消失，但与此同时，这让我们用户感到非常沮丧。为什么 speech2text 应用程序会犯这些错误并不明显，所以我认为有必要探究一下导致这些错误的一些因素。如果你想深入了解 ASR 的工作原理，请阅读我的《懒狗入门》:

[## 语音识别:懒狗初级读本

我和一个好朋友最近在吃饭时聊起了语音识别应用。是的，我们就是那些人。的…

medium.com](https://medium.com/towards-data-science/speech-recognition-a-lazy-dog-primer-6504ab4dccaf)

从大卫到 Uvuvwevwevwe

作为数据科学家和软件工程师，我们的第一直觉是改进系统、发展架构和创建更好的算法。这不是一个愚蠢的努力:提出精细的语言模型、聪明的深度学习算法和花哨的优化技术有重大的好处。

然而，我是一个大风扇追求低挂水果第一。我们都这么说。在这种情况下，唾手可得的成果就是理解你的用户:他们是谁，他们的交流模式是什么，他们的背景是什么，等等。所有这些必须告知您如何收集和使用训练数据，如何个性化您的应用程序，以及如何通过上下文调整语音识别。

考虑到这一点，让我们来看看在姓名的准确语音识别中可能产生影响的关键因素。

credit: Roy Jones

1.口音

英语口语变化很大。取决于你在哪里长大，你会强调不同的音节，强化某些辅音，偏向某些元音，并且经常使用不同的单词和表达。仅在美国就有大量的方言:从新奥尔良的 Yat 方言到波士顿特有的说话方式。我在匹兹堡的时候，我喜欢它的地区语言特色:“尹兹来了吗？

如果你缩小视野，听听来自世界各地的母语人士，比如英国、加拿大、新西兰和印度，英语语音模式的差异会更大。然后，进一步扩展，考虑非英语母语者和他们无数的口音——我应该知道！

2.发音

人类既古怪又有缺陷。当我们的大脑失灵时，我们经常或偶尔发错单词的音。我们希望语音识别应用程序能够处理轻微的语言障碍，但这并不容易。根据美国国家卫生研究院的数据，每 12 名 3-17 岁的美国儿童中就有 1 名患有与语言相关的疾病。最后，这是一个统计和收集足够的训练数据来覆盖角落情况的游戏。

疲劳是你发音不佳的另一个原因。我不知道你是怎么想的，但是当我连续 48 小时不睡觉时，我的语言能力会大大下降——我评估这个事实的能力也是如此。

最后，你可能是全国拼字比赛冠军，但有时你会被难念的名字绊倒。你见过 Uvuvwevwevwe 吗？

3.名称频率

常用名字对于语音识别 app 来说很容易。他们看到的有这个名字的人越多，他们积累的训练数据就越多，从而有助于更好的机器学习识别模型。然而，近几十年来，父母们已经对现有的名字池产生了明显的不满，并开始为他们的孩子引入新的、独特的名字。

当人工智能助手第一次遇到像 Finola、Pippa 和 Tanaquil 这样的名字时，他们只能做这么多。低频名字很难准确识别，但我希望应用程序集成和深度个性化能让我们做到这一点。例如，如果我一天和 Finola 说两次话，一天和 Tanaquil 发 20 次短信，那么期望这两个名字的识别是完美的，这并不是不合理的。

4.姓名拼写

在给孩子起名时，数百万父母也想出了极具创意的拼写方法，这无疑是为了欺骗语音识别应用程序。

有些名字与现有的名字或它们的近邻在语音上完全相同，但拼写却完全不同。你只需看看 Alexzandre、Braedyn 或 Izobel 就能感受到虚拟助手的痛苦。

5.多语言环境

随着全球流动性的增加，世界变得更加多样化。毫不奇怪，人们倾向于混合多种语言:例如他们的母语和他们居住国家的语言。

My kids are comfortable with a mixture of English, Romanian, and a smidge of beginner Chinese peppered in for good measure. “What do you think of the supă cu găluște? 好吃吗?“ They won’t bat an eye if they hear that, but for now virtual assistants still have trouble with “can you play 听妈妈的话”

这种现象在名字上最为明显，人们使用英语等主要语言，但用他们的母语正确地读出他们家人和朋友的名字。

试试这个:告诉你的虚拟助理给你的朋友里卡多发短信。发出命令时使用清晰的英语，但随后改用你最好的葡萄牙口音，发出“里卡多”的音。我会等的。

回到移情

我们生活在一个混乱的世界。我们随时都在应对不确定性，我们与身边的每个人和每件事谈判，以把事情做好。我们相互交流和沟通的方式就是如此。演讲是一个完美的不完美交流的例子，它只拥有足够的信号来传达预期的意思。知道了这一点，语音识别领域已经达到这种质量水平，真是不可思议。

每当我抱怨听写质量有多差时，我都会后退一步，看看我现实生活中的星际旅行通讯器、三录仪和通用翻译一体机，迫不及待地想看看明天会带来什么。

如果你喜欢这个涂鸦，点击👏在下面，所以其他人可以在媒体上阅读并享受它。

卢西恩·利塔 是 Yoyo Labs 的创始人，之前是 BlueKai、Intuit 和西门子医疗保健公司 Level Up Analytics 和 data leader 的创始人。

如果你喜欢这篇文章，点击💚以便其他人可以在媒体上看到它。

我的侄子 vs 曼梯·里

原文：https://towardsdatascience.com/my-nephew-vs-ml-9e4519af499a?source=collection_archive---------1-----------------------

我 4 岁的侄子 Yali 现在非常喜欢口袋妖怪。他有多个口袋妖怪玩具和一些 TCG(训练卡游戏)卡。

前几天，亚力发现了我藏起来的恶心的 TCG 牌，现在他的牌多得数不清了。

问题是雅丽太小了，还不知道如何玩真正的游戏，所以现在他发明了自己的游戏。游戏的目的是根据卡片的类型(口袋妖怪、能量和教练卡)对卡片进行分类。

他没有问我怎么知道卡是什么类型的，他拿了几张卡，问我是什么类型的。在我回答了几个问题后，他能够根据卡片的类型(有多个错误)来区分它们。

那一刻我意识到，我的侄子基本上是一个机器学习算法，我作为叔叔的任务是为他标记数据。

作为一个极客大叔和机器学习爱好者，我开始编写一个将与 Yali 竞争的程序。

这是典型的口袋妖怪卡片的样子:

source: pkmncards

对于一个知道如何阅读的成年人来说，辨别卡片的类型是很容易的，因为它就写在卡片的顶部。但是亚力才 4 岁，他不知道怎么读书。简单的 OCR 会很快解决我的问题，但我不想做任何假设。所以我照原样拿着这张卡，用 MLP 算法把它扔给一个神经网络。

获取数据非常简单。多亏了 pkmncards ，我可以下载多张卡片的图片，这些图片已经被分成了 Yali 的类别。

机器学习算法需要特征，而我的特征就是图像像素。使用 RGB 彩色图像，我将三种颜色转换成一个整数。

由于图像大小不同，我不得不将它们标准化。在找到数据的最大宽度和高度后，我给小图片添加了零填充。

真正交易前的快速质量保证周期。我随机抽取每种类型的两张卡片，然后进行预测。每一类只用了 100 张卡片，拟合速度惊人的快，预测也很糟糕。然后，我为每个类别抽取了 500 个样本(不包括能源类型，它只有 130 个样本)，并让拟合运行。

内存不足异常。在云中运行拟合代码应该可行，但我想找到一种使用更少空间的方法。最大的图像尺寸是 800x635，这太大了。调整图像大小解决了我的问题。

对于真正的测试，除了常规的卡片，我还添加了我在上面画画、剪成两半、画上形状、从我的手机(它的相机很差)上拍一张照片以及其他特殊效果的卡片。重要的是，我没有用这些卡片训练网络。

我试过一千多种型号(准确的说是 1533 种)。不同的图像尺寸、隐藏层数(最多 3 层)和层长度(最多 100 层)、图像颜色、读取类型(全图、上半部分、每隔一个像素等)。

在对所有模型进行了几个小时的拟合后，最好的分数是 25 张卡中的 2 个错误(少数模型有这个分数，但每个模型在不同的卡上都失败了。所有这些都是图像的灰度版本)。

1533 个模型中有 9 个出现了 2 个错误。

如果我将我的阈值设置为高于 44%的一致，模型的组合将给我 1 个错误的分数。对于测试，我将使用 50%的阈值。

让雅丽玩了一个月，我回来测试。

赢了！23 个给机器，21 个给人类。

如你所见，错误只发生在能量卡上。pkmncards 只有 130 张能量卡，而不是其他类型的数千张。可供学习的样本更少。

问雅丽他是怎么认出一些卡片的，他告诉我他在电视节目或书中看到过一些口袋妖怪。这就是他如何认出雷丘的耳朵或者知道蒸汽是水的原因。我的程序没有那种数据，我仅有的数据是卡片。

当我们的英雄在口袋妖怪挑战赛中击败雅丽并获得 ML 徽章时，他开始了他的下一次冒险。

从 webdev 到计算机视觉和机器学习

原文：https://towardsdatascience.com/my-next-two-years-de448d3141a?source=collection_archive---------6-----------------------

在过去的四年里，我一直有一个想法，那就是我要创办一家公司。潜在的感觉是，我想做一些我能热情地承担全部责任的事情。虽然这一直是我的愿望，但我还没有采取具体措施来实现它。相反，我开发了一个职业写作软件，并学习承包市场。我没有制定商业计划和试图筹集资金，而是建立并发布了许多副业项目。每个项目都让我对感兴趣的技术或领域有了更多的了解。

我已经积极地投入到任何摆在我面前的任务和机会中。因此，我能够在媒体、艺术、技术和社会公益领域遇到无数才华横溢、令人惊叹的人。

大约在移动开发变得重要的时候，我开始了 web 开发。我看到 JavaScript 从与 html 和 css 互补的技能组合，发展成为理解似乎永无止境的框架融合所需的主要语言。

我所听到的有趣的项目都与建立新的社交网络或建立现有的社交网络有关。移动定位技术风靡一时，但尚未完全成熟，照片共享服务的影响力也在不断增长。我甚至自己制作了一个基于照片的 iOS 应用程序，同时非常有意识地努力避免不必要的重新创建 Instagram。

下一步是什么

最近，我对地图技术和更多实时相关应用的出现感到非常兴奋。当我注意到 Hadoop 和 Spark 等“大数据”开源项目的流行时，我并不觉得自己有什么可以尝试的。我尝试创建一个在线市场平台网站。我看到了 X 月箱服务的兴起，并考虑到创建一个有价值的物流服务有多难，这种服务可能属于 X 月箱或更有吸引力的 uber-for-X。我甚至玩起了物联网设备的可能性，以及如果我验证了一个值得制造的想法，我可能会如何着手生产一些东西。我研究了蓝牙规范、能量传输机制，并想知道我能把哪些有趣的艺术导向的应用程序拼凑起来。总的来说，我从来没有投入足够的精力去充分看到我探索的成果。然而，所有的过程对我自己的成长都是有价值的。

现在，感觉好像有更多的东西需要探索，虽然我不知道如何探索，但我可以清楚地感觉到前进的道路将会更大。

我对区块链、机器学习和新的增强/虚拟现实感到兴奋。在所有新兴技术中，我花了最多的时间试图理解和利用机器学习的实际用途。虽然我在理论上理解区块链，但我对该产品没有任何深厚的感情。我没有被反体制/支持主权的意识形态所驱使，这些意识形态助长了加密文化。我也不觉得 AR 或 VR 领域像我认识的那些“全押”进去的人那样有趣。我喜欢用虚拟层补充物理空间的想法，但还没有任何“啊哈！”关于如何执行流程的时刻。

计算机视觉

图像分析和可以通过机器学习提取的看似有趣的数据继续激起我的兴趣。此外，交通领域的变化让我确信，实时位置相关图像分析数据将变得越来越重要。

学术界

我觉得学术界和私营部门在这两个领域都做了有趣的工作。在学术领域，我以前看到一些著名的大学做了很多形象导向的工作，但并没有立即引起人们的兴趣。围绕压缩、颜色等高度理论化的工作对我没有吸引力。围绕医学图像分析的工作似乎是一个很大的领域，但在我看来完全没有吸引力。我看到了许多围绕 2D 图像到 3D 空间转换领域的研究项目。在一项孤立的研究中，这些 image-to-X 项目并不有趣，但这些研究在现实世界中的应用似乎值得探索。

我想花大量的时间来充分了解正在进行的图像相关研究的学术前景。我认为回顾美国和世界各地的顶尖大学对我自己和我可能做的任何事情都有很大的启发。

我试图确定回学校继续深造攻读硕士学位是否值得。从我有限的接触来看，我还没有找到为什么这很重要的原因，但是我可以想象固定的时间专注于一个孤立的话题会非常有益。和志同道合的人在一起的机会似乎是值得的。

私营部门

我一直着迷于将相机用作多用途传感器的想法。现有的面向软件的计算机视觉任务似乎很少被探索。这是我想花更多时间为自己规划的事情。较新的有趣应用，如自动驾驶汽车，以及围绕物体识别的改进令人着迷。我知道还有很多其他领域的兴趣让这个领域值得探索。我想了解一切，从卫星到安全摄像头，从广告到房地产，从自动驾驶车队到增强现实摄像头。

从“看看 20 年后可能存在的东西，问问自己如何把它应用到今天”的角度来看，这似乎是我最感兴趣的领域。我希望投入大量时间来了解未来的机会、生态系统以及应用于现实世界问题时该领域的优势/劣势。

除了技术曝光，一个没有隐私的社会的哲学含义是可怕的。实际的商业价值感觉像是一个将继续发展到未来的领域，随着它，公众的理解。正如加里·周(Gary Chou)简明扼要地指出的那样，与其等待爱德华·斯诺登(Edward Snowden)相机技术的大数据时代，还不如消除社会理解和监管界限。也就是说，摄像头将不可避免地无处不在，来自摄像头的数据将被私营公司挖掘。我想站在决定这里能创造的积极价值的一边。

位置

测绘技术继续激起我的兴趣。当我在涂鸦时，我开始想了解更多，并想知道如何避免被抓住。“作家”会谈论警察如何使用地图技术来锁定艺术家。流传的笑话是，一个艺术家最大的粉丝是警察。他们有最多的照片和一个人所做的所有工作的最大记录。我记得城市是如何通过从一个人身上找到所有被报道的“标签”来抓住艺术家的。通过绘制位置图，通常可以推断出艺术家的家附近，整体调查范围明显缩小。这是 15 年前。我不知道这种数据分析的官方流程叫什么，但我肯定从那以后它有所改进。

我可以想象将同样的分析模式应用于任何其他数据集的价值，无论是社交媒体数据还是商业行为。我想加深对这一领域的了解。我想，围绕自然资源勘探中常用的地理空间分析，有很多东西需要学习。我想更多地了解如何利用卫星。这是一个在过去永远无法接触到的超级大国，除非你是一个民族国家。对冲基金现在通过分析世界各地的停车场和运输车辆，使用卫星图像来分析零售业的供求关系。这里与其他行业的相似之处似乎同样无穷无尽且尚未开发。随着地面上到处都采用摄像机，我想象随着时间的推移，同样的分析手段将非常有价值。

我想投入更多的时间来理解随着时间的推移围绕地理空间数据的整体问题。我想象，随着时间的推移，当这与实时图像分析相结合时，会有很多机会。我想进一步了解私营部门的应用和最适合实施这些技术的学术领域。

全部的

我滑入编程的时候，让我有可能比当时的在职者领先一步。我觉得现在，再一次，我在一个地方，我过去的经验给了我独特的见解，我可以进一步探索。特别感兴趣的领域，影像分析和地理空间数据，似乎值得理解，而且现在和以前一样容易接近。鉴于我的个人生活和事业在经济上有保障，我将在接下来的两年里亲自探索和了解这些领域。我的目标是加深我的能力，看看这些领域如何被用于商业收益。我将把我的视野深化到学术研究的前沿，私营部门的实践。理想情况下，通过这一探索过程，我可以为那些也发现自己感兴趣但不确定如何进一步探索这些领域的人记录我的发现。

感谢 Gary Chou 建议写这篇文章并帮助综合想法。感谢 Jihii Jolly 修复了剪辑噩梦。

我对带有交互式代码的奇异值分解的笔记(彼得·米尔斯)

原文：https://towardsdatascience.com/my-notes-for-singular-value-decomposition-with-interactive-code-feat-peter-mills-7584f4f2930a?source=collection_archive---------2-----------------------

GIF from this website

我想更深入地了解奇异值分解，它是如何完成的，以及我们如何用 python 来实现。

请注意，这篇帖子是为了帮助我理解机器学习背景下的线性代数。具体来说就是奇异值分解。

线性代数简单概述/Numpy/Scipy 用户警告

Image from this website

如果有人想重温线性代数的知识，请点击这里阅读一篇的博文。这篇文章的作者在解释线性代数的基本机制方面做了大量工作。

Paper from this website

对于 Numpy / Scipy 用户，请注意我上面链接的 pdf。那篇论文的作者在为什么使用 Numpy 计算特征值可能不稳定的原因上做得很好。(我将在这篇文章的后面部分讨论这个问题，但是使用 Numpy 的结果可能不稳定。)

奇异值分解理论综述

Image from this website

对于奇异值分解的理论解释，请查看这篇博文的，它实际上是关于奇异值分解的最好的博文之一。在这些博客文章中，我想尝试解决一些彼得给我们例子。(但首先我们需要看一些给定的等式，彼得把 SVD 表示为 A = USV。t)

Image from this website

虽然我不能 100 %确定这些答案是否正确，但下面是我解决给定问题的尝试。

S 之所以是正数，是因为它是平方的。在继续之前，我想谈一谈一个领域。就是这个问题"表明如果 m < n 最多会有 m 个非零奇异值。”。在实践中，我发现情况并非总是如此，因为在 python 实现中，我能够获得比矩阵 a 中较小维数更多的非零特征值。(下面是一个例子。)

作为上面的例子，对于给定的数据，当我计算每个矩阵(dot(A.T，A)和 dot(A，A.T))的非零元素的数量时，我能够观察到在某些情况下非零特征值的数量并不完全匹配。然而，非常小的值确实匹配成相同的数字。我怀疑这是由于 numpy 如何计算特征值。目前，我将 SVD 理解为在一个坐标系中表示原始数据 A，其中 U 矩阵度量每一行如何与其他行相关，V 矩阵度量每一列如何与其他列相关，而 S 度量这种相关的强度。最后，我想提一个真正帮助我的额外材料。

Paper from this website

请注意，我将遵循上述论文以及 Peter 博客文章中介绍的方法。

小矩阵奇异值分解

简单地说，我已经创建了一个(2，3)矩阵，如上所示，使用 numpy 线性代数库，我们可以很容易地计算矩阵 dot(A，A.T)和 dot(A.T，A)的特征向量。

下一步是按降序排列特征值，并相应地改变特征向量矩阵。同样，我们可以注意到非零特征值的数量彼此不匹配。然而，-2e-15 是一个很小的数字，我们可以丢弃它。

最后，使用创建的矩阵 U S 和 V，我们可以通过点积重建原始数据。我们可以将重构的矩阵缩放(减 1)以匹配原始数据，当我们创建一个相关矩阵时，我们可以看到如下所示。

通过查看前两行，我们可以观察到我们已经成功地重构了原始矩阵。

此外，我们可以采用 Peter 博客文章中介绍的方法，得到相同的结果。

大矩阵奇异值分解

接下来让我们在一个更大的矩阵上应用 SVD，特别是来自 load_boston 的数据。乍一看，我们可以看到我们有 506 个例子，每个例子有 14 列。

上面是生成的相关矩阵以及目标与 LSTAT(具有最高相关值的属性)的散点图。)

按照同样的模式，我们可以计算给定矩阵 a 的特征向量和值。

一个不幸的事实是非零特征值的不匹配，这似乎是使用 numpy 时重复出现的问题。

最后，我们可以计算重构矩阵，但是有一个问题。

重建的矩阵丢失了很多信息，如上所述，相关矩阵与原始数据集以及散点图不匹配。

然而，当我们使用彼得在他的博客中介绍的方法时，我们可以得到如下结果。

与原始值完全相同的相关矩阵和散点图。所以到目前为止，我认为通过 Peter 的方法执行 SVD 是一个更好的主意。

交互代码

对于 Google Colab，您需要一个 Google 帐户来查看代码，并且您不能在 Google Colab 中运行只读脚本，因此请在您的操场上创建一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

有关小型矩阵的代码，请点击此处。
关于大型矩阵的代码请点击此处。

遗言

线性代数确实是一个很好的研究课题。

参考

线性代数直观指南-更好的解释。(2018).Betterexplained.com。检索于 2018 年 7 月 5 日，来自https://betterexplained.com/articles/linear-algebra-guide/
奇异值分解。(2018).YouTube。检索于 2018 年 7 月 5 日，来自https://www.youtube.com/watch?v=mBcLRGuAFUk
模块:数据—浏览 v0.15.dev0 文档。(2018).Scikit-image.org。检索于 2018 年 7 月 15 日，来自http://scikit-image.org/docs/dev/api/skimage.data.html
sk learn . datasets . load _ Boston-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。检索于 2018 年 7 月 15 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . datasets . load _ Boston . html # sk learn . datasets . load _ Boston
绘制交叉验证预测-sci kit-学习 0.19.1 文档。(2018).Scikit-learn.org。检索于 2018 年 7 月 15 日，来自http://sci kit-learn . org/stable/auto _ examples/plot _ cv _ predict . html # sphx-glr-auto-examples-plot-cv-predict-py
Faces 数据集分解-sci kit-学习 0.19.1 文档。(2018).Scikit-learn.org。检索于 2018 年 7 月 15 日，来自http://sci kit-learn . org/stable/auto _ examples/decomposition/plot _ faces _ decomposition . html # sphx-glr-auto-examples-decomposition-plot-faces-decomposition-py
框架，N. (2018)。规范化熊猫数据框的列。堆栈溢出。检索于 2018 年 7 月 15 日，来自https://stack overflow . com/questions/26414913/normalize-columns-of-pandas-data-frame
seaborn . heat map-seaborn 0 . 8 . 1 文档。(2018).Seaborn.pydata.org。检索于 2018 年 7 月 15 日，来自 https://seaborn.pydata.org/generated/seaborn.heatmap.html
matplotlib？，H. (2018)。如何改变用 matplotlib 绘制的图形的大小？。堆栈溢出。检索于 2018 年 7 月 15 日，来自https://stack overflow . com/questions/332289/how-do-you-change-the-size-of-figures-drawn-with-matplotlib
Python，H. (2018)。如何在 Python 中指定绘制数据帧的 x 轴和 y 轴？堆栈溢出。检索于 2018 年 7 月 15 日，来自https://stack overflow . com/questions/45738773/how-to-specify-x-y-axis-for-plotting-data frame-in-python
法，一.(2018)。使用 pandas plot 方法设置图形大小时不一致。堆栈溢出。检索于 2018 年 7 月 15 日，来自https://stack overflow . com/questions/42215252/consistency-when-setting-figure-size-using-pandas-plot-method
熊猫。data frame . plot-pandas 0 . 23 . 1 文档。(2018).Pandas.pydata.org。检索于 2018 年 7 月 15 日，来自http://pandas . pydata . org/pandas-docs/version/0.23/generated/pandas。DataFrame.plot.html
NumPy . linalg . EIG—NumPy 1.14 版手册。(2018).Docs.scipy.org。检索于 2018 年 7 月 15 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . Lina LG . EIG . html
NumPy . sort—NumPy 1.14 版手册。(2018).Docs.scipy.org。检索于 2018 年 7 月 15 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . sort . html
新泽西州 python(2018 年)。Python，numpy 排序数组。堆栈溢出。检索于 2018 年 7 月 15 日，来自https://stack overflow . com/questions/14875248/python-numpy-sort-array/14875366
订单？，E. (2018)。高效地对 numpy 数组进行降序排序？。堆栈溢出。检索于 2018 年 7 月 15 日，来自https://stack overflow . com/questions/26984414/efficiency-sorting-a-numpy-array-in-descending-order
VanderPlas，J. (2018)。排序数组| Python 数据科学手册。jakevdp . github . io . 2018 年 7 月 15 日检索，来自https://jakevdp . github . io/python datascience handbook/02.08-sorting . html
NumPy . diag—NumPy 1.14 版手册。(2018).Docs.scipy.org。检索于 2018 年 7 月 15 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . diag . html
复杂？，H. (2018)。如何让特征值和特征向量保持实数而不是复数？。堆栈溢出。检索于 2018 年 7 月 15 日，来自https://stack overflow . com/questions/48695430/how-to-make-the-features-and-features vectors-stay-real-that-of-complex
矩阵特征向量计算器。(2018).Symbolab.com。检索于 2018 年 7 月 15 日，来自https://www . symbol ab . com/solver/matrix-特征向量-计算器/特征向量% 20% 5C begin % 7bp matrix % 7D 10% 260% 262% 5C % 5C % 200% 2610% 264% 5C % 5C % 202% 264% 262% 5C cend % 7bp matrix % 7D
[仅适用于 Numpy ]在 Numpy 中使用交互式代码体验特征值/向量的乐趣。(2018).走向数据科学。检索于 2018 年 7 月 15 日，来自https://towards data science . com/only-numpy-having-fun-with-eigen-value-s-vectors-with-interactive-code-in-numpy-80d 3443 DFD 22
在 Numpy 和 Tensorflow 中使用交互式代码通过梯度上升进行独立分量分析。(2018).走向数据科学。检索于 2018 年 7 月 15 日，来自https://towards data science . com/independent-component-analysis-via-gradient-ascent-in-numpy-and-tensor flow-with-interactive-code-98 B9 a73 e5d 19
谷歌合作实验室。(2018).Colab.research.google.com。检索于 2018 年 7 月 15 日，来自https://colab . research . Google . com/drive/1 vdozsx 3 ckcgmywmutmiutr 4 phfjkaz 2 # scroll to = w5 nfpzyb 6 jfs
Anon，(2018)。[在线]可在:https://www . research gate . net/publication/281455336 _ NumPy _ SciPy _ Recipes _ for _ Data _ Science _ eigen values eigen vectors _ of _ 协方差 _ matrics查阅【2018 年 7 月 15 日】。
奇异值分解教程。(2018).Web.mit.edu。检索于 2018 年 7 月 15 日，来自http://web . MIT . edu/be . 400/www/SVD/Singular _ Value _ decomposition . htm
sk learn . datasets . load _ Boston-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。检索于 2018 年 7 月 15 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . datasets . load _ Boston . html
(2018).Datajobs.com。检索于 2018 年 7 月 15 日，来自https://data jobs . com/data-science-repo/SVD-Tutorial-[Kirk-Baker]。pdf

我的数据科学之路

原文：https://towardsdatascience.com/my-path-to-data-science-b66c1538bb7e?source=collection_archive---------9-----------------------

(以及给任何刚开始学习的人的一些建议)

首先简单介绍一下我自己:
嫁给 Yonit&Yahav&Arbel
的父亲作为一名数据科学研究员 @Grid4C
与 Shlomo Kashani
共同创立了“深度学习训练营”【巅峰时期】在超过 80，000 名活跃的 Kaggle 竞争者中排名第 175
【自学成才并且非常(！)好奇
·拥有 BGU 大学经济学学士学位和企业家研究 MBA 学位

每天驾驶 230 公里，我寻找利用时间的最佳方式…
一路上开始听讲座
决定每天投入 1 小时来实践我所学的
(很快发现自己投入了更多……)

然后我认识了 ka ggle……(这只是我参加过的比赛的一部分)

Kaggle 是我实践学习的最重要的枢纽，实践知识比理论知识更稀缺，这是获得经验和展示你所学知识的好方法——更多关于我对 Kaggle 为什么如此伟大的想法，你可以在这里找到这里和稍微不同的更通用的更新版本这里

我从与我领域相关的 kaggle 竞赛开始，我甚至成功地将我的一些解决方案应用到日常工作过程中的竞赛中。但是，很快我就尝试了大部分提供的竞赛，不管它们来自哪个领域

我多年来开发的一个数据科学项目的总体方案如下所示:

在我的旅程中，我发现有几件事要么推动我们前进，要么拉动我们前进

人我们不断地与互动与
挑战那我们就激情去解决/应对
内容我们读 /听/(观？)
行动我们T42【采取
思想我们关心

我们经常交往的人:
是我们生活中的人在挑战我们，在我们需要时提供帮助，在我们能给予帮助时寻求帮助。他们激励我们，帮助我们以自己独特的方式发光。他们在那里倾听&如果我们幸运的话，我们也会在那里支持他们。
这些是在我的人生道路上帮助过我的人，我非常感谢在我的生命中拥有他们！

The main people who took part in my journey to data science

作为团队的一员，伟大的目标更容易实现:

我们热衷于解决/应对的挑战:

所以我们已经在 上看到了一些，但是还有更多…
工作挑战(大部分都是我自己想出来的)
关于这类挑战，我的最佳建议是“找一个除了你之外的人，他也会致力于挑战
数据黑客马拉松——对我来说是作为参与者的数据黑客，以及作为发起者和共同组织者的 BGU 黑客。黑客马拉松是展示你所学技能和个性的好方法。它们也是结识其他优秀专业人士的好地方
其他比赛 —查看本次回购了解一些想法
医疗挑战、商业挑战、技术挑战，以及其他…

我们读/听/看的内容——好奇心是我们最好的朋友:

我们采取的行动:

养成一个习惯，交付比你承诺的更多的东西
在一切事物中寻找机会——问"为什么这很棒？
对机会说“是”——这很难，但是值得！
为他人做好事，不求回报
承担你能承受的风险——不承担风险会更糟糕
寻找别人在你身上看到的、你自己还看不到的东西，并据此采取行动

我们关心的想法:

我所关心的事情过去是，现在仍然是我的动力— 热爱你所做的事情
始终回馈的重要性
教别人——双重受益每个人都学得更多
什么是我们独特的贡献 —我们都是特别的，但如何特别？

就是这样。正是这些东西&这些人让我的数据科学之旅成为迄今为止最伟大的旅程(现在依然如此)。我希望你喜欢读它，并且它帮助一些读者。

我很乐意阅读关于其他人道路的相似和不同之处，并加入你的建议和你一路上学到的东西。

https://github.com/nathanie

https://www.linkedin.com/in/nathaniel-shimoni-16b11081

【https://www.kaggle.com/interesting

https://www.facebook.com/nathaniel.shimoni

我的手机使用数字和图形

原文：https://towardsdatascience.com/my-phone-use-in-numbers-and-graphs-886d040519f8?source=collection_archive---------1-----------------------

Moment 应用数据的洞察力和可视化

Image credit.

在过去的几个月里，我一直对注意力经济感兴趣，现代技术如何劫持我们的思想来获取更多的利润。我还就这个话题写了一篇十页的文章，作为我的教员科目成绩的一部分。在研究过程中，我遇到了一个名为花好时间的运动，它希望“改变注意力竞赛，使其符合我们的最佳利益”。他们的网站还提供帮助你节省时间而不是浪费时间的应用程序。其中之一就是时刻。

Moment app.

Moment 应用

Moment 是一个自动跟踪并帮助您管理手机使用时间的应用程序。Moment 的免费版本显示您每天使用手机的时长。付费版帮你打，限制使用。还有一款家庭版。

它可以选择导出 GPS 位置(纬度和经度)、日期、时间和会话持续时间。我使用这些数据进行了以下段落中的分析。

概观

我在 12 月初开始使用 Moment，直到最近才忘记它。当然，这个应用程序是独立运行的。下图显示了我每天和每个位置的手机使用情况。我计算了纬度和经度的加权平均值。让我提醒你，你可以点击图片或图表下方的超链接来获得互动图。

See the interactive plot.

最近的一项研究显示，年轻人使用手机的时间略多于 5 小时，平均每天查看 85 次。让我们把这个和我的结果比较一下。我平均用了 3 小时 10 分钟，每天检查 60 次。我仍然觉得我在这上面浪费时间…

平均日

这就是我平常的一天，用我每分钟打电话的概率表示的样子。

See the interactive plot.

每一分钟的概率都很嘈杂，所以我应用了中值滤波器来减少噪音。不幸的是，由于我‘自由’的生活方式(记住，我是在伊拉斯谟交易所)，你无法从剧情中学到很多东西。

平均会话

现在是时候更仔细地看看这些会议了——它们的持续时间——并将它们与之前提到的研究结果进行比较。

See the interactive plot.

我的 中位数 **会话时长 95 秒。**他们的，不到半分钟。我认为这是由于两个原因:

我一般会关掉移动数据或者 wifi。因此，每次我想在网上查看一些东西时，我都必须再次打开它，这需要一些时间。
我通常不使用推送通知。当我想查看社交媒体通知时，这需要额外的时间——尤其是当我沉迷于永不停息的新闻提要时。

最喜欢的地点

你可以从手机数据中获得比电话使用更多东西。例如，最喜欢的位置(用于使用我的手机)。我将这些限制在格但斯克，并决定将它们聚集在一起，组成前七名。标记区域与花在手机上的时间成正比。

My top 7 places (for using phone) in Gdansk.

最大的标记(93 小时)代表交换期间我的家。上面的点，我的大学。右边的标记，美丽的古镇。索波特，一个聚会的地方…

编码和编写

我想让这篇文章尽可能的简短有趣——不要讲太多细节(这篇文章是面向大众的)。让数字和图表自己说话。最初的计划还包括 t 测试，以比较我在清醒时使用和不使用特定社交媒体应用程序和分发的情况。最后，由于上面提到的原因，我决定不考虑他们。

我使用 Jupyter Notebook 用 Python 编程语言实现了代码。对于数据可视化(不包括地图)，我用了 plotly 。

我的数据科学快速入门 Docker 图片

原文：https://towardsdatascience.com/my-quick-start-docker-image-for-data-science-6bffb5dbac31?source=collection_archive---------2-----------------------

TL；DR:设置是通用的，但是本教程的目标读者是那些有兴趣将数据分析从笔记本电脑转移到云中的读者。只需在数字海洋上点击几下，在终端上输入几个命令，您就可以拥有 RStudio 服务器、具有多个内核的 Jupyter 笔记本和 Neo4j 数据库。

更多的数据库后端即将到来。

本·哈默最近在 Quora 上写了一篇关于可复制性的文章。我鼓励你阅读他的文章，因为它是这篇文章背后的基本原理。这些见解如下:

https://www . quora . com/What-is-best-practices-for-cooperation-between-data-scientists。

可重复的行动让我们节省时间，并讨论真正重要的事情，即我们工作的产出。在这种情况下，当我有空闲时间时，我一直在玩docker，因为在分析项目中复制我们的发现的能力将过程从讨论中移除，并允许我们专注于输出。

虽然我对容器的概念非常陌生，但我确信我的设置反映了我所知甚少。无论如何，它确实允许我们在远程机器上开始一个良好的数据科学设置，只收取每小时几分钱的费用。

如果您有一个您认为涵盖核心基础的数据科学设置，请随时联系。这是拼凑起来的，但却激发了我在任务中解析、管理、存储/组织和建模数据所需的工具集。

在数字海洋上创建个人分析服务器

首先，如果您没有数字海洋帐户，您可以使用下面的链接创建您的帐户并开始使用。注意，这是一个推荐链接，如果你最终在网站上开发，我会得到信贷。

[## 数字海洋:为开发者设计的云计算

DigitalOcean 是一个简单而强大的云计算平台，专为开发人员设计。

m.do.co](https://m.do.co/c/d5dcbcabc6d3)

一旦您创建了您的帐户，您将需要创建您的 droplet，或者我们可以控制的远程服务器。选择One-click Apps选项卡，并选择显示的 docker 的最新图像。截至 4 月 2 日，这是我看到的情况:

向下滚动并选择标准实例和每小时花费 1.5 便士的服务器。

以这个价格，你可以获得 1 GB 的内存、30GB 的固态硬盘和 2 TB 的数据传输。这对我们的任务来说绰绰有余。还值得注意的是，你应该货比三家其他供应商。

我更喜欢 Digital Ocean 的易用性和不断增加的功能，但我相信您可能会找到一个能为您的需求提供更好价格的提供商。

就我而言，我在东北，所以我将选择纽约的数据中心。

现在不要担心其他的选择。向下滚动到“完成并创建”部分。

我们只想启动一台服务器，所以将设置保留为 1 droplet，然后单击 Create。

您应该会看到一个屏幕，显示您的个人服务器的创建进度。

完成后，将鼠标悬停在您的个人数据科学服务器的 IP 地址上，以复制远程机器的 IP 地址。

**最后，**检查您用来设置试用帐户的电子邮件帐户。

数字海洋将向您发送一封电子邮件，告知您服务器的最终详细信息。您应该会看到一封类似以下内容的电子邮件…

此时，您将在此电子邮件中看到服务器的临时密码。

因为我假设你在 Macbook 或类似的 UNIX 机器上，你可以简单地使用终端ssh进入你的个人服务器。

在我的情况下…

对您将看到的类似屏幕说是。

此时，将提示您输入通过电子邮件发送给您的临时密码，之后您将创建一个新的 root 密码。

在这一步中设置root密码是没有意义的。如果您打算启动机器来分析公开可用的数据，然后立即销毁它们，这通常是可以的。

如果您打算在未与您的 IT 和安全团队沟通的情况下将个人或公司数据存储在远程服务器上，请不要使用这种方法。

完成密码提示后，您现在已登录到您自己的个人数据科学服务器！

快速回顾一下我们所拥有的

在上面，我键入了ls命令，以确保在我的~目录中没有文件或目录。

你现在拥有的是一张白纸:

具有root访问权限的 Linux 服务器使用不受笔记本电脑限制的资源。也就是说，启动一台可以变得相当大的服务器很简单，只需按小时为这些资源付费。
我们使用ssh远程访问服务器，并直接在那台机器上发出命令。
已经预先配置好运行 Docker 的 Ubuntu Linux 服务器
git是预装的，它允许我们使用版本控制来处理项目

在收集我们的工具集之前，我们应该用下面两个命令更新我们的服务器。

$ apt-get update
$ apt-get install

最后，让我们来设置数据科学

首先，通过在远程服务器的终端会话中键入以下命令来克隆我的基本设置。

git clone https://github.com/Btibert3/datasci-docker.git

您应该会看到类似这样的内容

切换到远程服务器上新创建的目录

cd datasci-docker/

并使用ls -l 命令确认您有这样的东西

你都准备好了。

使用以下命令启动您的分析堆栈。

docker-compose up

通过运行上面的命令，我们将使用 repo 中的docker-compose.yml文件来构建各种容器，这些容器通常用于各种数据科学任务。这些文件将被下载到服务器(第一次运行该命令时),并设置一些配置选项，以确保各种工具可以共享相同的数据。

重要！当你完成你的工作后，在你正在使用的终端会话中键入ctrl+c，以终止正在运行的设置。键入exit终止远程ssh会话。在数字海洋网络应用程序中，从感兴趣的液滴的更多菜单选项中点击销毁，这样您就不会为您的一次性分析堆栈产生额外的每小时费用。

在此阶段，我鼓励您探索其他可用的选项，包括远程连接到服务器以及数字海洋提供的大量选项。如果不为别的，设置 SSH 密钥，这样你就可以ssh root@<machine-ip-here>认证进入你的机器，避免使用电子邮件步骤来共享密码。

快速确认你所有的工具都准备好了

如果您接触过 Jupyter、RStudio Server 或 Neo4j，您就会知道这些工具会暴露给定机器上的各种端口。在本地使用这些工具时，您将使用localhost连接到这些工具。

过程与**完全相同，**但是我们只是提供一个 ip 地址，而不是连接到localhost,。

让我们运行一些基本命令来确保您的工具集启动并运行。

创建新的终端会话

打开第二个终端会话，并再次进入您的远程机器。我们这样做是因为我们的第一个会话允许我们监视正在运行的 docker 会话。

登录 RStudio 服务器

在新的终端会话中，只需访问浏览器窗口中的ip-address:8787查看登录屏幕，即可登录远程 RStudio 服务器。

您可以在这两个字段中使用rstudio登录您的 R 设置。

您现在使用的是云中的 RStudio IDE，而不是在笔记本电脑上进行本地开发。

点燃一台 Juptyer 笔记本

使用通过ssh连接到远程机器的原始会话返回到您的终端。作为输出的一部分，您应该会看到如下所示的部分。

请注意，NotebookApp 为您的会话输出一个令牌。要访问您的笔记本，只需导航至ip-address:8888?token=<your-token-here>。

这样做时，您应该会看到一个类似的屏幕，其中突出显示了您可以使用的各种内核，包括 Julia、Python 2/3 和 r。

选择 Python 3 试用笔记本。

访问 Neo4j 浏览器工具

只需在浏览器中转至ip-address:7474，您应该会看到以下内容:

我还没有看到一个工具能为他们的数据库后端提供更好的现成的 web 界面。

通过在 webapp 内的内置终端中输入命令call apoc.help('apoc')来确认您已经安装了apoc。

值得注意的是，docker 允许您在启动 neo4j 数据库栈之前设置变量和选项。有关更多信息，请查看以下 url:

[## 2.5.码头工人-第 2 章。装置

本文涵盖了在 Docker 容器中运行 Neo4j。Docker 不能在 OS X 或 Windows 上运行。对于跑步…

neo4j.com](http://neo4j.com/docs/operations-manual/current/installation/docker/)

在设置过程中，我将 neo4j 的一些卷映射到主机上，特别是 neo4j 的import文件夹映射到我们主机的datasets directory.

让我们将一个数据集保存到我们的个人分析服务器上的/datasets目录中(该服务器现在运行 docker containers ),并确认 neo4j 可以访问它。

cd ~/neo4j/import
wget [https://vincentarelbundock.github.io/Rdatasets/csv/datasets/iris.csv](https://vincentarelbundock.github.io/Rdatasets/csv/datasets/iris.csv)

这应该揭示了

直观证明这是一个数据集

cat iris.csv | head -5

退一步说，我们所做的是将数据保存到主机上的~/neo4j/import路径，但是这个卷也被映射到 docker 容器中，允许我们快速引用文件，如下所示。

LOAD CSV WITH HEADERS FROM "file:///iris.csv" as row 
WITH row
LIMIT 1
RETURN row

生产

摘要

这是一篇相当长的文章，但是使用 Digital Ocean 和 docker 容器让机器启动并运行起来真的很简单。这篇文章的目的是作为一个视觉指南，帮助你旋转我倾向于使用的堆栈。正如开始时提到的，我将在未来包括更多的数据库后端。

我的秘方是在卡格尔比赛中名列前 2%

原文：https://towardsdatascience.com/my-secret-sauce-to-be-in-top-2-of-a-kaggle-competition-57cff0677d3c?source=collection_archive---------1-----------------------

实践教程

在 kaggle 比赛中竞争是有趣和令人上瘾的！在过去的几年里，我开发了一些标准的方法来探索功能并建立更好的机器学习模型。这些简单但强大的技术帮助我在 Instacart 市场篮子分析比赛中获得了前 2%的排名，我也在 kaggle 之外使用它们。所以，让我们开始吧！

在数字数据上构建任何监督学习模型的最重要的一个方面是很好地理解特征。查看模型的部分相关图有助于理解模型的输出如何随任何特征而变化。

source

但是，这些图的问题在于，它们是使用经过训练的模型创建的。如果我们可以直接从训练数据中创建这些图，它可以帮助我们更好地理解基础数据。事实上，它可以帮助你做以下事情:

特征理解
识别嘈杂的特征(最有趣的部分！)
特征工程
特征重要性
功能调试
泄漏检测和理解
模型监控

为了使它更容易访问，我决定将这些技术放入 python 包 featexp 中，在本文中，我们将看到它如何用于特性探索。我们将使用 Kaggle 上家庭信用违约风险竞赛的应用数据集。比赛的任务是利用给定的数据预测违约者。

功能理解

Scatter plot of feature vs. target doesn’t help

如果因变量(目标)是二进制的，散点图不起作用，因为所有点不是在 0 就是在 1。对于连续目标，太多的数据点使得难以理解目标与特征的趋势。Featexp 创建了更好的图来帮助解决这个问题。我们来试试吧！

Feature vs. target plot of DAYS_BIRTH (age)

Featexp 创建数值要素的相等人口箱(X 轴)。然后，它计算每个箱中目标的平均值，并将其绘制在上面的左侧图中。在我们的例子中，target 的平均值只不过是违约率。该图告诉我们，DAYS_BIRTH 负值高(年龄较大)的客户违约率较低。这是有道理的，因为年轻人通常更有可能违约。这些图有助于我们了解该功能告诉客户什么，以及它将如何影响模型。右边的图显示了每个箱中的客户数量。

2。识别噪声特征

噪声特征导致过度拟合，识别它们并不容易。在 featexp 中，您可以通过一个测试集，并在训练/测试中比较特性趋势，以识别有噪声的特性。这个测试集不是实际的测试集。这是您的本地测试集/验证集，您知道目标。

Comparison of feature trends in train and test

Featexp 计算两个指标，显示在这些图上，有助于测量噪声:

趋势相关性(在测试图中可见):如果一个特性在训练集和评估集之间不具有相同的趋势 w.r.t .目标，则可能导致过度拟合。发生这种情况是因为模型正在学习一些在测试数据中不适用的东西。趋势相关性有助于了解训练/测试趋势的相似程度，并使用训练&测试中箱的平均目标值进行计算。上述特征具有 99%的相关性。好像不吵！
趋势变化:趋势方向的突然和重复变化可能意味着噪音。但是，这种趋势变化也可能发生，因为该仓位在其他特征方面具有非常不同的总体，因此，其违约率实际上不能与其他仓位相比较。

以下特征未保持相同的趋势，因此趋势相关性较低，为 85%。这两个度量可以用来丢弃噪声特征。

Example of noisy feature

当有许多要素并且它们彼此相关时，丢弃低趋势相关性要素效果很好。它导致较少的过拟合，并且其他相关特征避免了信息损失。同样重要的是不要放弃太多重要的特性，因为这可能会导致性能下降。此外，你不能使用特征重要性来识别这些噪声特征，因为它们可能相当重要，但仍然非常嘈杂！

使用不同时期的测试数据会更好，因为这样你就可以确定特性趋势是否会随着时间的推移而保持。

featexp 中的***get _ trend _ stats()***函数返回一个数据帧，其中包含每个特征的趋势相关性和变化。

Dataframe returned by get_trend_stats()

让我们实际尝试删除数据中趋势相关性较低的特征，看看结果如何改善。

AUC for different feature selections using trend-correlation

***我们可以看到，下降特征的趋势相关性阈值越高，排行榜(LB) AUC 越高。*不丢弃重要特征进一步将 LB AUC 提高至 0.74。同样有趣和令人担忧的是，测试 AUC 的变化没有 LB AUC 那么大。获得正确的验证策略，使本地测试 AUC 遵循 LB AUC 也很重要。完整的代码可以在 featexp_demo 笔记本中找到。

3。特征工程

通过查看这些图获得的见解有助于创建更好的功能。仅仅对数据有更好的理解就能带来更好的特性工程。但是，除此之外，它还可以帮助您改进现有的功能。我们来看另一个特性 EXT_SOURCE_1:

Feature vs. target plot of EXT_SOURCE_1

EXT_SOURCE_1 值高的客户违约率低。但是，第一个仓位(约 8%的违约率)并没有跟随特征趋势(先涨后跌)。它只有-99.985 左右的负值，人口众多。这可能意味着这些是特殊值，因此不要遵循特征趋势。幸运的是，非线性模型在学习这种关系时不会有问题。但是，对于像逻辑回归这样的线性模型，此类特殊值和空值(将显示为一个单独的条柱)应使用具有类似违约率的条柱中的值进行估算，而不是简单地使用特征均值进行估算。

4。特征重要性

Featexp 还可以帮助您评估特性的重要性。DAYS_BIRTH 和 EXT_SOURCE_1 都有不错的走势。但是，EXT_SOURCE_1 的人口集中在特殊值箱中，这意味着大多数客户的特征具有相同的信息，因此不能很好地区分他们。这说明它可能没有 DAYS_BIRTH 重要。基于 XGBoost 模型的特征重要性，DAYS_BIRTH 实际上比 EXT_SOURCE_1 更重要。

5。功能调试

查看 Featexp 的图有助于您通过做以下两件事来捕获复杂特征工程代码中的错误:

Zero variation features show only a single bin

检查要素的人口分布是否正确。我个人曾无数次因小错误而遇到类似上述的极端情况。
在看这些图之前，总是假设特征趋势会是什么样子。特征趋势看起来不像你所期望的，可能暗示着一些问题。坦白地说，这种假设趋势的过程让构建 ML 模型变得有趣多了！

6。泄漏检测

从目标到特征的数据泄漏导致过度拟合。泄漏特征具有很高的特征重要性。但是，理解特征中为什么会发生泄漏是困难的。查看 featexp 图可以帮助您解决这个问题。

下面的功能在“空值”箱中的默认率为 0%，在所有其他箱中的默认率为 100%。显然，这是一个极端的泄漏案例。只有当客户违约时，此功能才有价值。根据该特性是什么，这可能是因为一个 bug，或者该特性实际上只是为默认者填充的(在这种情况下，应该将其删除)。了解泄漏特性的问题所在有助于更快地调试。

Understanding why a feature is leaky

为了更精确地检测泄漏，我发布了另一个 python 包‘leak-detect ’,它实现了一个使用 NANs 和复数来完成这项任务的新技巧。看看我在最后链接的另一篇文章。

7 .。模型监控

因为 featexp 计算两个数据集之间的趋势相关性，所以它可以很容易地用于模型监控。每次重新训练模型时，可以将新的训练数据与经过充分测试的训练数据(通常是第一次构建模型时的训练数据)进行比较。趋势相关性可以帮助您监控特征及其与目标关系是否发生了变化。

做这些简单的事情总是帮助我在现实生活中和 kaggle 上建立更好的模型。使用 featexp 只需 15 分钟就能看到这些图，绝对值得，因为之后你就不会盲目飞行了。

您还发现了哪些对探索特性有用的技巧和提示？我总是在寻找反馈。请在评论中告诉我，或者通过 abhayspawar@gmail.com 联系我。如果你想继续收到我的消息，请在推特上关注我(【https://twitter.com/abhayspawar】T2)

如果你喜欢这个，你可能会喜欢我关于使用 ML 进行算法交易的系列文章。它讲述了我如何能够获得比基准高出 100%的回报:

* [## 战胜市场的交易策略的机器学习模型

如何看待训练和利用 ML 模型进行算法交易？

abhayspawar.medium.com](https://abhayspawar.medium.com/machine-learning-models-for-market-beating-trading-strategies-c773ba46db66)*

我自创的人工智能硕士学位

原文：https://towardsdatascience.com/my-self-created-ai-masters-degree-ddc7aae92d0e?source=collection_archive---------1-----------------------

大学之路太贵了，所以我决定自己开一条。

Who’s teaching who?

本文的上半部分是更新。真正的事始于一两卷卷轴。

注: 本文是一项进行中的永久性工作，截至 2019 年 5 月 17 日。

2019 年更新 2: 有很多关于机器学习、数据科学和人工智能的伟大资源。我把一些我最喜欢的放在一个容易导航的位置。点击查看。

Some of the best machine learning, AI and data science resources in one neat little package.

**2019 更新:**我增加了一些更多的课程和其他资源(学习如何学习课程和 100 页的机器学习书籍)。他们都还在按顺序完成。

**2018 更新:**进入我的课程 9 个月后，我被布里斯班的一家科技公司 Max Kelsen 聘为机器学习工程师！

15 秒后见

我住在澳大利亚的布里斯班。

我是 2015 年毕业的，食品科学与营养学双学位。我花了五年时间读了三年本科。

我以为我想成为一名医生。可能是因为我在追随我朋友的做法，而不是创造自己的道路。

我是一个健身迷。我喜欢食物。将我对食物和健康的热爱与我的学习结合起来是我做过的最好的事情之一。

我在大学五年里学到的最有价值的一课是，如果你真的对你所学的东西感兴趣，学习就不再是一件苦差事。

我学会了如何学习。

如果你在开始上大学之前告诉我这个智慧，我会听，会理解，但不会付诸行动。我仍然认为学习永远是一项痛苦的任务。智慧必须学习而不是教授。

为什么要研究人工智能？

人工智能(AI)的整个革命让我着迷。人工智能，加上其他技术，有能力让世界变得更美好。它也有力量把世界变得更糟。我支持好的一面。

人工智能的进步已经发生了几十年。计算能力只是在最近才达到这样一个阶段，它足以让像我这样的人在我的卧室里研究这些技术。

2017 年初，我决定开始了解这种范式转变，而不是袖手旁观，看着它发生而不完全理解它。

我的目标

**足够危险，把 AI 作为给世界带来价值的工具。**我不是为了学习而学习这些技术。我要用我所学到的去建造一些史诗般的东西。
**将人工智能与我的健身和营养知识结合起来，帮助世界动起来，吃得更好。**我知道我永远不会成为人工智能、健身或营养这三个单一学科的世界领先专家，但我可以成为这三个学科交叉的领导者。
激励他人踏上自己的学习之旅。通过写下我的旅程并分享我所学到的东西，我想鼓励其他人选择自己并创造自己的道路。

我的课程

当我开始学习时，我走的是相反的方向。我一头扎进了深水区(真的)，报名参加了一个深度学习课程，却从未写过一行 Python 代码。

我把自己吓得够呛我给支持部门发了电子邮件询问我是否有资格获得退款。幸运的是，我没有接受退款。

在对这个领域有了更多的了解后，我变得成熟了一点，并开始对我想在哪里学习有了一个想法。更多的想法开始进入我花时间的地方。

我不想成为最好的人工智能工程师或最受欢迎的人。我关注的是我可以用来建造东西的知识基础。

我的课程不像它应该的那样强大，相反，它是在飞行中建立的，学习我需要知道的东西以进入下一步。

如果你对我有任何建议，包括我应该看的课程或我应该努力的技能，请随时在评论中告诉我，我的电子邮件或推特。

键

✅ =课程全部完成
✳️ =课程部分完成或正在进行
没有数学或书籍的符号

基础课程

✅uda city python 编程基础【免费】
✅ CS50 【免费】
✅ 树屋巨蟒赛道费用
✅ Udacity 数据科学简介[免费]
✅ DataCamp 的数据科学课程 Python 简介 [Cost]

Two incredible resources for starting to learn Computer Science and programming. Sources: Treehouse, Harvard CS50

为什么是这些？

2017 年初，我对数据科学是什么一无所知，更别说 AI 了。我在二月份写了我的第一行 Python 代码。这些课程将为我提供 Python 编程、计算机科学和数据科学方面的基础。

高级课程

✅ Andrew Ng 在 Coursera 上的机器学习[免费]
✅ Udacity 深度学习纳米学位基础[成本]
✅ Andrew Ng 在 Coursera 上的 deeplearning.ai 课程 [Cost]
✅ Udacity 人工智能纳米学位费用
✅ Fast.ai 深度学习课程(第一部分)【免费】
✳️ Fast.ai 深度学习课程(第二部分)【免费】
✳️ 在 coursera【cost】上用 Python 应用数据科学
✳️ Fast.ai 机器学习课程【免费】

Three of the best resources to learn AI online. Sources: Udacity, deeplearning.ai, fast.ai

为什么是这些？

我偶然发现了 Udacity 的深度学习纳米学位基金会(DLND)，并被 Siraj Raval 争取了过来。我对人工智能和机器学习有点兴趣，但他在 YouTube 上的介绍视频让我着迷。这是我开始学的第一门课程。

从 DLND 开始，我的学习之旅随着关注人工智能和健康的交叉而增长。

书

费了九牛二虎之力才学会 Python作者 Zed Shaw [Cost]
赤裸裸的统计查尔斯·惠兰著【成本】
人工智能:一种现代的方法
深度学习用 Python 作者弗朗索瓦·乔莱【成本】

当前正在阅读

使用 Scikit-Learn 和 TensorFlow 进行机器实践学习作者 Aurélien Géron [Cost]
安德烈·布尔科夫的《百页机器学习书》

If you’re starting out, put these two books in your library and read them cover to cover.

为什么是这些？

有时需要更传统的路线，而不是总是在屏幕前。Zed 关于 Python 的书极大地帮助了 Treehouse Python track。

上一次上统计学课是本科第一学期。我失败了。 赤裸裸的统计 帮助我开始用更多的统计思维来思考。它的写作方式去掉了术语，给出了复杂统计概念的真实例子。

没有人工智能教科书中的圣杯来学习人工智能——人工智能:一种现代方法——不会真的是学习人工智能。

用 Python 进行深度学习 也许是迄今为止对 AI、深度学习和 Python 最好的介绍。其作者 Franç ois Chollet 是流行的深度学习框架 Keras 的作者，目前在谷歌从事深度学习工作。

动手机器学习 是另一个不可思议的资源。这本书最符合我作为机器学习工程师的日常工作。

这本百页的机器学习书 是 2019 年的新版本。我希望我开始的时候有这本书。一天就能看完。我们正在为办公室准备一个，并打算把它作为一个首选资源。

数学

可汗学院矩阵简介[免费]
可汗学院线性代数【免费】
可汗学院多变量微积分【免费】
可汗学院统计与概率【免费】
3blue1brown YouTube 频道【免费】
Coursera 上用于机器学习的数学【成本】

Source: Khan Academy

为什么是这些？

一旦我开始学习机器学习和深度学习，我的高中数学技能需要一些完善。多亏了各种框架和库，许多数学工作都是在幕后完成的。

对这些技术中的数学有一个大致的了解对我有很大的帮助。

临时演员

布里斯班 AI Meetup 【免费】
Siraj Raval 的 YouTube 频道【免费】
免费代码营【免费】
✅在 Coursera 上学习如何学习课程
✅coursera 上的谷歌云数据专业专精【成本】

Sources: freeCodeCamp.com, Meetup.com, Siraj Raval YouTube Channel

为什么是这些？

我的性格类型是 ENFP 。从本质上来说，我更外向而不是内向(只有一点点)。在电脑屏幕前呆太久，我会变得很奇怪。如前所述，我正在使用 Meetup 寻找和结识对我感兴趣的人。

Siraj Raval 是个巫师。他的 YouTube 频道是我学习人工智能并最终创建自己的人工智能硕士学位的主要灵感。观看他的视频让我在 YouTube 上记录了我的学习历程。如果你想了解更多关于人工智能的知识，我强烈推荐他的频道。

如果我需要温习当前正在学习的 Python 堆栈之外的 web 技术，FreeCodeCamp 是我要去的地方。毕竟，如果你用人工智能建造了什么东西，你将需要一种方式把它交付给世界。他们有我见过的最好的在线社区之一。如果你想从事 web 开发，这是你的起点。

我已经提到过，我在大学五年后学到的最有价值的技能是学会如何学习。但我想出了一个艰难的方法。Coursera 上的学习如何学习课程应该是每个学生的必修课。学会如何学习是终极技能，因为你可以把它应用到其他任何事情上。

任何机器学习工程师或数据科学家都需要使用云技术。如果你想让人们使用你制造的东西，你必须分发它们。云计算可以帮助你做到这一点。我已经选择谷歌云作为我目前的云供应商。我利用 Coursera 上的谷歌云数据工程专业来提升自己的技能。要了解更多，请参见文章我如何通过谷歌云数据专业认证考试。

我该如何掌控一切？

我正在使用一个公开的特雷罗板跟踪这一切。我发现保持事物的直观性和尽可能简单是我工作的最佳方式。请随时关注我的进展。

What my Trello board looks like as of 13 September 2017 (it gets updated as I learn/add more to the curriculum).

为什么要创造我自己的道路？

在大学学习期间，我经常问讲师和教授，

这个会出现在试卷上吗？

我真正的意思是，

除非是期末考试，否则我是不会学这个的。

Seth Godin 的这篇文章一针见血。

这十年来，我在大学里度过了足够多的时间。

然而，当我决定如何学习时，我使用了两个主要标准。

成本
灵活性

就费用而言，我所在地区大学的计算机科学研究生学位每年在 20，000 澳元到 30，000 澳元之间(至少两年)。为了以后对比，我就用低端的。

根据我以前在大学的经验，它一点也不灵活。严格的截止日期，基本上任何缺席的医疗证明，严格的上课时间，一次性讲座，从我住的地方到我最近的校园往返 70 分钟，等等。这些都不是坏事，但当你把它与在线学习的替代方式相比时，情况就开始有点不同了。

就灵活性而言，在线学习显然是赢家。能够按照自己的进度学习是一大优势。我对我有困难的概念放慢速度，对其他所有事情都很快。因为不可预见的事件，我错过了最后期限？我请客。没有别人。

在线学习并不总是一帆风顺。你在灵活性中获得的东西，会在实际的人际交往中失去。在电脑前学习了一天后，我变成了一个内向的僵尸。我用当地的聚会来弥补这一点。

在线学习也没有大学的声望高。我完成的一些课程不提供验证证书。我不担心那个。我的目标是获得足够的知识，将这些技术付诸实践，为世界带来价值。

我将使用我构建的东西作为我能力的证明，而不是证书。

支付课程费用

我没有积累更多的学生债务，而是选择用我本打算花两年时间攻读计算机科学硕士学位的钱来资助我自己的学习之旅。

我预先支付所有课程的费用。为了做到这一点，当我开始学习这门课程时，我会在周末开车去优步。在被聘为机器学习工程师后，我仍然会提前支付费用。

下一步是什么？

你可以把这篇文章看作是我自创的人工智能硕士学位课程的半成品。随着我学习的课程和从事的项目的进展，我会保持更新。

我正在通过 YouTube 视频和博客帖子分享我的旅程。

我的硅砂数据冒险

原文：https://towardsdatascience.com/my-silica-sand-data-adventure-3b9231e6ba08?source=collection_archive---------5-----------------------

我的两个叔叔经营一家清洁用品公司。他们中的一个给我发电子邮件，问我如何研究香烟烟灰缸砂的总市场，这只是硅砂。尽管所有的沙子都是二氧化硅，但短语“硅砂”通常是指某种商业用途的预处理过的沙子(如烟灰缸)。

总可用市场泛指市场需求的上限。没有多少数据库可以涵盖香烟烟灰缸沙子的市场，所以，我决定继续寻找。

我最近读了super forecasts,它让我稍微开阔了一下眼界，让我了解到如何用一种快速、准确的方法将评估分解成子问题。我决定用它来估算美国一年的硅砂总需求。

我是这样把问题分解的:找出吸烟者的总数，然后算出每个吸烟者使用的烟灰缸沙子的数量。

吸烟者总数

第一部分(吸烟者的数量)很简单，因为疾病预防控制中心有数据:

2015 年，每 100 名 18 岁或以上的美国成年人中约有 15 人(15.1%)目前*吸烟。这意味着美国目前估计有 3650 万成年人吸烟。

每个吸烟者有多少硅砂？

下一步，计算出一个普通吸烟者使用多少烟灰缸的精确估计，有点困难，因为这是一个如此狭窄的市场。我将这个问题进一步分解为一组 3 个问题。

1。 一般烟民用多少支烟？疾控中心称每天 14.2 人=每年 5183 人。(这让我非常惊讶。一包烟通常有 20 支。)

2。 吸烟者在烟灰缸里处理香烟的时间占多大比例？这是我非常非常感兴趣的地方。

事实证明，香烟垃圾是一个非常非常大的问题，所以在这个问题上有相当多的研究。就我的目的而言，我发现的最有用的研究是关于垃圾的观察研究，但有一个关于吸烟者的特殊部分。研究人员实际上观察了数千名吸烟者，看看他们吸烟后会做什么。在他们的样本中，57%的时间里吸烟者乱扔烟头。他们还注意到，在他们观察的地点中，只有 61%有烟灰缸。

在寻找第二个估计时，我发现了一个说法(这个说法没有根据),大约有 30%的时间香烟最终成为垃圾。我取了观察研究的估计值和 30% 的平均值，最终确定了我的估计值，即 43% 的吸烟者乱扔烟头的时间。这意味着吸烟者其余的时间使用烟灰缸，或者说 57%的时间使用烟灰缸。

3。平均处理一支香烟要用多少沙子？这是最难的，我不得不使用一些非常粗略的数字。我从网上的供应商那里看到，大多数香烟瓮需要大约 3-5 磅的沙子，可以容纳大约 3000-4000 个烟头。这意味着每 1000 个烟头中大约有 1 磅沙子。

最后，所有的部分都准备好了，我终于可以做计算了:每年 5183 支香烟* 3650 万吸烟者* 57%被丢弃在烟灰缸里_{一年有 1078 亿支香烟被丢弃在烟灰缸里。除以 1000 得到烟灰缸沙的磅数} 美国每年有 1.078 亿磅烟灰缸沙。

随着我的深入调查，我发现硅砂也用于泳池过滤器和壁炉，这可能会增加总的可用市场。然而，我上面的估计是保守的。

我学到了什么

在我寻找数据的过程中，有一些经验教训可能是通用的。

1。将问题分解成子问题的力量。用这种方法可以解决的问题范围很广。我认为，这对于商人来说是一个强大的洞察力，因为在很多情况下，你没有时间，但需要给出一些具体的数字。通常在这种情况下，没有人有现成的数据库等着你。

2。 **在二级数据中发现问题。**商业创新成功的关键在于发现人们愿意花钱解决的重要问题。在为了一个不相关的原因挖掘一项观察性研究时，我发现了一个没有很好解决的大问题:香烟垃圾。也许这个问题会随着无烟香烟而消失，谁知道呢。我的观点不是关于这个特定的案例，而是二手数据可能包含有待解决的未开发的重要问题。

我希望你和我一样喜欢这次冒险。

卡格尔星球挑战:解决方案概述

原文：https://towardsdatascience.com/my-solution-to-kaggle-planet-challenge-fa554ec16c8c?source=collection_archive---------7-----------------------

一个好的理由和一个浏览一些最令人惊叹的航拍照片的机会足以让我加入这个竞赛；当然，这也是一个尝试各种 convnet 架构的重要场所。

“每一分钟，世界都会失去 48 个足球场大小的森林面积。亚马逊盆地的森林砍伐占了最大的份额，导致了生物多样性减少、栖息地丧失、气候变化和其他灾难性影响。但是，关于森林砍伐和人类对森林的侵犯的位置的更好的数据可以帮助政府和当地利益相关者更快和更有效地做出反应。

在这场比赛中，Planet 和它的巴西合作伙伴 SCCON 正在挑战 Kagglers，以大气条件和各种土地覆盖/土地利用类别来标记卫星图像芯片。由此产生的算法将帮助全球社会更好地理解世界各地发生森林砍伐的地点、方式和原因，以及最终如何应对。"

A large city in the Amazon basin (from competition website)

你可以在这里找到更多关于比赛的信息。

数据

大约 40k 个 255x255 jpeg 图片及其相应的带有 NIR 通道的 Tif 文件。测试集在 61k 左右，结构相同。更多详情。

训练数据中的每个区块具有一个或多个类别标签，例如“多云”、“水”、“道路”等。

天气标签是互斥的，而其他标签可以一起出现在某个标签中。目标基本上是预测每个图块的类别标签。

解决方案大纲

我的解决方案的要点是微调和集成许多 convnet 架构:VGG、inception v3、resnet50 和 xception。其中，resnet50 运行得最好，因为它需要的运行时间相对较少，所以我花了大部分时间对它进行优化和微调。

我从数据的小子集(50%)和非常小的照片(50x50)开始，以找到正确的建筑结构和参数搜索(例如，用于数据扩充)。最终的网络使用了 224x224 像素的 jpeg 图像。

有趣的是，Tif 文件并没有帮助改善结果。起初，这听起来可能毫无启发性；例如，我们可以用 NIR“看穿”雾霾，并提供更准确的标记。一个常见的假设是，由于标记是由不能利用 NIR 通道的人类完成的，利用 NIR 通道实际上会使我们偏离那些“真正的标签”。

An agricultural area that showing the end state of “fishbone” deforestation

网络架构

输出:17 级输出，二进制日志丢失，adam 优化器。我尝试了几种变体；其中一个具有两种输出类型:用于天气类别的 4x 输出(softmax +分类交叉熵，因为天气标签是互斥的)和用于其他标签的 13x 二进制输出(sigmoid +二进制对数损失，因为它们可以同时出现)。

然而，与统一的 17x 级输出相比，它们都给出了较差的 f2 分数。我甚至尝试了两种不同的天气和非天气网络，尽管精确度上升了，回忆下降了，这实际上伤害了对比赛很重要的 f2 分数。

以 Resnet50 为例，我去掉了顶层，用大小为 1024 的隐藏层进行扩展，后面是大小为 17 的预测层。中途退出是为了避免过度适应。

我开始以较高的学习速率(从 1e-3 一直到 1e-6)微调顶层，随着我在网络中的深入，在确保我不能从未冻结的层中榨取更多之后，不断解冻更多的 conv 块。我的最好成绩一直保持到 conv 50 分的 5a 区。

阈值处理

除了训练一个好的模型，找到合适的阈值在这场比赛中也很关键。基本上，预期的预测是类别标签，如“多云”或“道路”，而不是每个类别的概率。因此，您必须找到正确的阈值来决定某个预测的类别概率是否足够高，以分配该标签。我通过强力优化每个通道的阈值获得了最佳结果。

简而言之，我在 0 到 0.99 的范围内搜索了每个类别的所有可能的阈值，以获得最佳 f2 验证集。进一步改进我的结果(~0.001)的是在验证集上进行 10 倍的数据扩充，并在进行阈值搜索之前取模型预测的平均值。

组装

由于我使用的是相对较慢的 AWS 机器(p2.xlarge)，我负担不起为每个型号进行 k-folding。因此，对于每个模型，我留出 20%的数据作为验证集，并针对相应的训练/测试分割优化每个模型。每个模型还使用了不同的输入大小和非常细微的数据扩充差异。我相信这有助于增加合奏的多样性。做测试时间增加(TTA)也被证明是对每个模型的一个很好的促进，特别是因为我在基于 k 倍的方法中没有测试预测平均的优势。

最后，我根据每个模型的输出进行了“多数投票”。虽然我没有进行 k 折叠，因此不能进行堆叠，但我的结果与我的队友秦相当，他花了相当多的时间对每个模型进行 k 折叠和堆叠。

最后，我们的最佳解决方案是基于我的 resnet 和他的 resnet 的平均值，然后叠加他的模型。Densenet 的后期添加也被证明是有帮助的，因为它具有与我们的最佳性能 resnets 相当的结果。

最后，不幸的是，由于合并中的一个错误，我们失去了我们的位置。事情是，公共和私人排行榜的文件名是不同的，我们的合并算法只在私人 LB 文件名上失败；因此，虽然我们在公共 LB 上没有看到任何异常，但我们混合了私人 LB 提交的结果。我不会 100%地责怪我们，因为这是一个超级难抓的漏洞，特别是在最后几个比赛日的抢劫期间，也因为我不认为训练和测试集应该这样划分。这一问题以及许多与数据相关的问题(tif 文件中的数据泄漏、比赛期间数据集的重新发布、tif 和 jpegs 之间的不匹配)使我对这场比赛及其组织失去了信心。令人欣慰的是，我们不是唯一因为文件名问题而失去阵地的人。

除了抱怨之外，我们学到了一个很好的教训来避免将来出现这种情况:利用提交之间的相关性。结果是，我和秦的最佳提交结果的相关系数为 0.88，合并结果将会显著提高分数。然而，这并没有发生，合并的结果是微不足道的；这是一个强烈的信号，表明有猫腻。在修复了这个错误之后，事实证明实际的相关性是 0.98，这是更容易接受的。这是我的第一次团队合作，团队合作的所有动力和兴奋实际上都超过了这个小小的挫折:D

不起作用的事情

XGB 和 ETR 模型对图像汇总统计和基于近红外的指数，应该是有助于检测水和绿色植物。除了 tif 在总体上没有帮助的事实之外，我已经得出结论，convnet 架构在提取特征方面要强大得多
循环池:我是从之前比赛的 Sander 的解决方案分享中得到的想法；试了几次后，我没有观察到多少收获；这可能是由于我的实现，但也可能是当前的架构比当时可用的架构强大得多，数据增强有助于使网络旋转不变。

Approximately 25,000 acres of untouched primary rainforest.

特技

我之前提到过这一点，但从一小组小照片开始是在合理的时间内用不同的架构、超参数和数据扩充进行实验的关键。
伪标记:所以训练集的大小大约是 40k 图像和 60k 测试集。这是一个相当大的差异，在训练中有很多看不见的照片。根据杰瑞米·霍华德在 fast.ai 上分享的笔记，我利用伪标签/知识提炼将我的模型暴露给更多数据。基本上，在从微调中挤出最后一点梯度后，我继续在每批 75%的训练数据和 25%的测试数据上训练模型。测试集标签将是(增强的)模型预测。这帮我减少了大约 0.002 的损失。
到最后，我意识到多云标签与所有其他标签是相互排斥的。这是因为对于多云的瓷砖，人类贴标签机看不到其他任何东西。我很确定我可以利用这个观察来对我们的结果进行后处理。我用了我最好的 resnet 模型，并将其作为单一模型进行微调，以检测多云或非多云(使用样本加权)。然后，我根据模型的输出整理了最终的预测:如果我们非常确信是多云，就去掉其他标签；如果我们确信不是多云，就去掉多云标签。虽然去除浑浊标签效果很好，但去除其他标签更敏感，我必须更有选择性地选择要去除的标签。最后，我可以观察到私人银行的一些显著收益。
AWS p2 实例众所周知的慢；虽然我可以坐在那里等待，但我决定利用 spot 实例的灵活性。在通过运行 spot 实例和安装丢失的 nvidia 驱动程序的设置曲线后(我真的长出了白头发)，我设法轻松地生成新的 p2 实例并同时训练不同的模型。这大大提高了我的运行时间。

结论

巴西球迷在 2014 年世界杯上的感受可能最能描述我的感受:你充满了激情和希望，但你却被排除在这个特殊的派对之外。如果在脖子上挂一块金属不是你唯一的目标，那也没什么大不了的。虽然有时会让我筋疲力尽，但对我来说，这是另一次尝试新方法的宝贵经历，也是我第一次享受在 kaggle 比赛中作为一个团队工作的乐趣。

代号:【https://github.com/olix20/kaggle-planet

我关于深度学习和神经网络的故事——第一部分

原文：https://towardsdatascience.com/my-story-with-deep-learning-and-neural-networks-part-i-a751c7d148c?source=collection_archive---------5-----------------------

注:最初发表于 2015 年 11 月 25 日的博客上。

我从 2008 年开始研究深度学习，大概是每年的这个时候。我很幸运有 Yann LeCun 作为导师，还有他的一个天才学生: Clement Farabet 。我们一起着手制作卷积神经网络加速器。就在这个领域被称为深度学习之前。但是让我们再放大一点:

从我的博士学位开始，在 1998-2004 年间，我一直在神经形态工程领域工作。我得到了该领域一些顶尖人士的建议: Andreas Andreou ，我的超级天才博士顾问，Ralph-Etienne-Cummings——也是一位亲密的顾问，Gert Cauwenberghs——第三位亲密的同事，还有kwa bena bo ahen——最著名的“神经形态”之一。我基本上是站在巨人的肩膀上。我欠他们一辈子，利息。你读这本书是因为他们！

无论如何，神经形态工程是从生物学中获得灵感来创建工程系统的领域，该系统可以执行生物学最擅长的所有任务，如理解复杂数据:图像、视频、学习等。

生物学，或者也许只是“神经网络”。

再往前追溯，在意大利的里雅斯特大学攻读学士学位期间，我正在研究人类视觉系统的模型。后来，我了解到人类大脑是多么复杂，我开始热衷于将我的生命投入到将人类大脑复制成合成系统的想法。这是一个很好的人生目标，再加上通过复制一些东西，一个人真的必须了解它是如何工作的！在我 1998 年至 2004 年的博士研究期间，理解神经网络成了我的人生目标。当时，我与来自神经形态工程国际研究小组的电气工程、机器人学、神经科学、心理学领域的各种杰出人物建立了联系。这真的拓宽了我的兴趣，能够倾听所有这些看似不相关领域的科学问题。

但是后来我越来越明白，一切都是有联系的。它就像一个巨大的大脑。就像一个巨大的神经网络！关于这一点的更多内容将在后面讨论。

一些神经形态工程的目标是复制人类理解环境的能力。人类主要通过视觉做到这一点，毕竟视觉可以将你的“感知范围”延伸到最远，比触摸或你的身体更远，甚至比你的耳朵可以感知的声音更远。但是我们所有的感官赋予了我们在环境中生存的不可思议的能力。仅仅几千年前，人类生活的世界还远没有现在安全……在 1998 年至 2004 年期间，在我攻读博士学位期间，我研究了许多人造眼睛，或者能够在正确的时间获得正确的视觉信息的特殊图像传感器，可能会压缩大量的视觉数据。

当时我对与这个行业合作很感兴趣，但这一切似乎离我的目标和我正在创造的设备太远了。当时的工业生产和图像传感器研究都是为了推出更好的手机摄像头。不像今天。只考虑增加更多像素和提高速度似乎是渐进的。但是，是的，这是一场革命。我很高兴能与世界上最优秀的图像传感器创新研究人员联系，例如 Eric Fossum 和 Gunhee Han 、 Jun Ohta 等等。

当时，最好的神经形态图像传感器和视觉系统是由我在约翰霍普金斯大学的一些同学和顾问创造的:才华横溢的雅各布·沃格斯泰因、维克多·格鲁夫和最著名的施-刘炽、鸢·德尔吕克。例如，鸢的高动态视觉传感器和硅视网膜是设计最好的传感器之一。

但是大约从 2003 年开始，我对“照片里是什么”越来越感兴趣，而不仅仅是拍出漂亮的照片，即使是用我们花哨的神经形态相机！原因是很难真正将更多的计算能力压缩到图像传感器中。2D 芯片制造的必然性使我们被限制在 2D 的世界里。像我的顾问 Andreas 这样的远见者知道我们需要 3D，这是传感器和存储器的最新趋势！

当时，如果你想在视觉方面做得更多，设计更好的图像传感器真的不是办法。总的来说，我对计算机视觉也没什么印象。我不喜欢也不欣赏试图手工设计所有视觉问题的解决方案，并试图将其分解成几个部分，就像完形心理学和数学导向的计算机科学家在历史上所做的那样。在我看来，这一切都可以概括为 1966 年麻省理工学院论文中的著名目标，即在一个夏季项目中完全复制人类的视觉。这样的目标，到目前为止，已经被证明是一项艰巨的任务！

我反而被人类大脑解决问题的方式所吸引。

在我看来，人类的视觉系统是宇宙中最好的视觉系统！至少在我的人类眼中是最好的，因为它能够执行如此多的任务，并以我们大脑的智慧为食。我经常认为我们的大脑如此发达的原因主要是因为我们的视觉系统，或者两者的共同进化。这里！辩论的食物。人类的视觉系统让我们可以轻松地在环境中移动。我真的想复制它，用在机器人和机器上，让计算机看东西的方式和人类看东西的方式相似。

这是我现在的人生目标。为了做到这一点，我们要深入研究智力、语言和技术进化的问题。所有这些话题现在似乎都融合在一起了。我不知道细节，但一些未来的画面在我脑海中清晰可见。更多将被告知。

回到 2006 年 7 月，我的研究目标之一是创造一个神经系统，它可以复制我们的视觉识别物体的能力。然后，我真正受到了托马斯·塞尔(Thomas Serre)的工作和论文的启发，他是由著名的托马斯·波吉奥(Tomaso Poggio)领导的。他们在麻省理工学院的作品是一个真正的灵感，我们和陈寿顺一起努力在硬件上复制他们的一些模型。

然后，在 2008 年初的一天，我和我们杰出的同事 Bernabe Linares-Barranco 聊天，他不经意地提到了 Yann LeCun 的工作。Yann 刚搬到 NYU，那时我在耶鲁大学，他友好地同意来主持一个研讨会。他是多么令人鼓舞的 T2 啊。他拥有硬件开发人员所要求的最简单的神经元模型！以及训练大型系统的方法！它有“学习”，这是我博士经历中没有的概念，尽管我的密友和同事 Roman Genov 和 Shantanu Chakrabartty 早在 1998-2005 年就在研究支持向量机和神经网络。我马上就明白了。

学习，简单神经元模型，可扩展系统，生物启发，人类视觉系统模型！

自 2008 年以来，我们开始致力于基于可编程逻辑器件(Xilinx FPGA)的人工硬件，以在硬件上实现深度神经网络。我们非常幸运地与 Clement Farabet 一起工作，他向我们介绍了 Torch，并使我们的实验室后来成为工具开发人员之一。Torch 使得创建神经网络和在软件中训练它们变得容易。与以前的 CNN 图书馆相比，这是一个很大的进步，以前的图书馆不太容易被黑客攻击和理解。

在接下来的几年里，从 2008 年到 2011 年，我们与 Clement Farabet 合作定制硬件，直到他跳槽到自己的软件公司工作，然后在 2014 年被 Twitter 收购(恭喜！).2011 年，我们的实验室(电子实验室)搬到了普渡大学，我们开始培养新一代的机器学习专家:Jonghoon Jin、Aysegul Dundar、Alfredo Canziani 和更多的硬件专家，如 Vinayak Gokhale。Berin Martini 在过去几年中不断完善硬件系统，直到 Vinayak Gokhale 在 2014-2015 年发明了一种全新的架构。我们的机器学习专家和我本人致力于视觉跟踪，然后是聚类学习和 k-means 聚类技术的无监督学习，以及我们定制硬件机器的编译器。我们为 Torch7 写了很多软件，在 Caffe 和其他工具出现之前，我们维护了演示代码和软件。在 2013 年夏天，所有电子实验室共同努力，将我们的硬件系统移植到 Xilinx Zynq 设备中，这是一种结合了 AMR 内核和 FPGA 结构的真正嵌入式系统。我们在 Linux 设备驱动程序中开发了与设备对话的底层代码，然后实现了一个完整的硬件系统和软件编译器。我们将这一系统称为 nn-X，并在 NIPS 2014 上首次展示，在那里我们的硬件演示受到了媒体的关注和认可。

与此同时，很明显我们是未来一项关键技术的专家，深度学习，我决定资助公司 Teradeep ，以便将我们在可编程设备中的硬件设备商业化，并将它们转变为定制的微芯片。宏伟的目标是让所有设备都能够像人类一样看到和感知世界。

目标是创造一种特殊的微芯片，在电池供电的设备上运行神经网络，比如手机。数据中心服务器和自动驾驶汽车系统。

在早期，大多数行业都不知道深度学习是什么，对他们来说，这只是“那些算法中的另一种”。这一愿景在我们心中很活跃，但很难被许多公司高管接受。他们错过发令枪会让他们后来感到沮丧。—第一部分结尾—脚注:1:这是我的故事。我希望它能帮助其他人获得视角。如果可能的话，通过别人的经历。

他说:非常感谢海军研究办公室，ONR 和 T4 的托马斯·麦肯纳，他们资助了我们的许多研究活动。

最初发表于 2015 年 11 月 25 日的 Blogger。更多最新评论见:https://medium . com/forward-data-science/can-we-copy-the-brain-9 ddbff 5 E0 DDE

关于作者

我在硬件和软件方面都有将近 20 年的神经网络经验(一个罕见的组合)。在这里看关于我:传媒、网页、学者、 LinkedIn 等等…

捐款

如果你觉得这篇文章有用，请考虑捐赠来支持更多的教程和博客。任何贡献都能有所作为！

我用 25 个问题来测试一个数据科学家关于交互式代码的图像处理-第 1 部分

原文：https://towardsdatascience.com/my-take-on-25-questions-to-test-a-data-scientist-on-image-processing-with-interactive-code-part-1-a6196f535008?source=collection_archive---------3-----------------------

GIF from this website

所以我找到了这个了不起的博主 Faizan Shaikh ，他的博客上有一些令人惊奇的东西！所以请你查一查他，也就是他是“ 25 题测试一个数据科学家对图像处理的 ”的创作者。所以我会试着挑战自己去解决它们。请注意，我的解决方案不会优化。

此外，对于每个问题，我会截屏正确的答案(原作者张贴的答案)。然而， 我总是乐于学习和成长 ，所以如果你知道一个更好的解决方案，请在下面评论。

还有，这是我用来做演示的两张图片。
1。 脑 MRI 来自 pixabay 2。 自然图像来自 pixabay

1。将以下图像格式与其正确的通道数相匹配

我的答案是 C，因为 RGB 图像有红色、绿色和蓝色，而灰度图像只有二进制值。我们甚至可以用 python 来证实这一点。

红线 →通道大小为 3 的彩色图像
蓝线 →通道大小为 1 的灰色图像(因为是二进制值，所以这里没有显示。)

2。图像翻译

我的答案是 B，C 和 D，我们可以看到两个给定的坐标是(1，0)和(0，1)，所以要回答的基本问题是我们需要什么变换矩阵？如果我们真的做矩阵乘法，我们可以看到，除了 A，我们可以把原来的坐标转换到新的坐标。

3。[对或错]要模糊图像，您可以使用线性滤镜

我对此的回答是正确的，因为我们可以使用均值滤波器(或平均滤波器)来平滑图像，同时保持线性。首先，让我们看看什么是线性滤波器……

Image from this website

好了，现在我们知道了线性滤波器的定义，让我们看看线性滤波器和非线性滤波器的区别。

Image from this website

好，现在我们知道均值滤波器可以用于求平均值。让我们实际看看它的作用。

左图像 →原始图像
右图像 →均值滤波图像

我们可以清楚地看到，图像更加平滑。我认为作者弄错了。(如果我说错了，请告诉我。)

4。处理计算机视觉问题时，以下哪一项是一项挑战？

这肯定是 D，因为当涉及到计算机视觉时，上述所有问题都是要处理的巨大痛苦。以下是来自斯坦福远景集团网站的挑战列表。

Image from this website

5。k 均值聚类

对于这个问题，我费了好大劲才弄明白。但是从逻辑上来说，我们需要三样东西。圆形、正方形和背景。我们可以看到，圆形具有最黑的像素强度(因此这将是一个聚类)，正方形具有灰色的像素强度(另一个聚类)，最后背景大部分是白色的(最终聚类)。所以我认为我们需要 3 个集群。

6。图像不连续

为了这个问题，我不得不回顾所有的不连续性，并找到了斯坦福大学和研究之门的一个很好的演示。

因此，从上面每个不连续的例子来看，我们需要得出结论，边缘是由于深度而被检测到的。椅子在墙的前面。

7。去除噪声

我们已经从上面的例子中看到我们如何使用均值滤波器平滑图像，这意味着如果图像中有噪声，我们需要平滑图像以减少噪声。让我们使用[我的旧代码](http://"Jaedukseo/Python_Basic_Image_Processing". 2018. Github. Accessed April 11 2018. https://github.com/JaeDukSeo/Python_Basic_Image_Processing/blob/master/4_Add_noise/four.py.)给图像添加一些噪声。

左图像 →原始图像
右图像 →平滑后的结果图像

因此答案是 c。

8。我们需要多少尺寸的灰度级

为此，我们可以肯定地知道我们需要做的第一个操作是 100*100，现在我们需要选择我们需要乘以什么值。为此，我们可以看看 scipy 中的 imread 函数。

如上所示，黑白图像需要 8 位，但是我们也可以将它读入 32 位，因此答案可以是 E 或 3，200，00。

9。图像的量化

我不知道什么是量化过程，所以我必须去查一下。

图像处理中涉及的量化是一种有损压缩技术，通过将一系列值压缩为单个量子值— 维基

仅从这一陈述，我们可以得出结论，量化一幅图像涉及压缩，这意味着减少存储空间量，因此是正确的。

10。具有重复值的图像

这当然是因为，我们可以将 x 和 y 坐标值存储在一个字典中(键值为像素强度),这将大大减少所需的大小。

交互代码

请注意，我不想滥用任何数据政策。所以对于谷歌 Colab，我找到了下面的图片，它被标记为重复使用。要访问在线代码，请点击此处。

Image from this website

遗言

还有 15 个问题，但这些都是很好的问题。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的推特这里关注我，访问我的网站，或者我的 Youtube 频道了解更多内容。如果你感兴趣的话，我还做了解耦神经网络的比较。

参考

处理，2。，处理，2。，&谢赫，F. (2017)。测试数据科学家图像处理能力的 25 个问题。分析 Vidhya。检索于 2018 年 4 月 11 日，来自https://www . analyticsvidhya . com/blog/2017/10/image-skilltest/
线性滤波和滤波器设计(图像处理工具箱)。(2018).Edoras.sdsu.edu。检索于 2018 年 4 月 11 日，来自https://edoras . sdsu . edu/doc/MATLAB/toolbox/images/Lin filt 3 . html
过滤器，D. (2018)。线性和非线性滤波器的区别。Dsp.stackexchange.com。检索于 2018 年 4 月 11 日，来自https://DSP . stack exchange . com/questions/14241/difference-between-linear-and-non-linear-filter
OpenCV:平滑图像。(2018).Docs.opencv.org。检索于 2018 年 4 月 11 日，来自https://docs . opencv . org/3 . 1 . 0/D4/d13/tutorial _ py _ filtering . html
用于视觉识别的 CS231n 卷积神经网络。(2018).cs 231n . github . io . 2018 年 4 月 11 日检索，来自http://cs231n.github.io/classification/
(2018).Vision.stanford.edu。检索于 2018 年 4 月 11 日，来自http://vision . Stanford . edu/teaching/cs 131 _ fall 1516/lections/lectures 5 _ edges _ cs 131 . pdf
[3]2018.【在线】。可用:https://www . researchgate . net/figure/Factors-is-likely-to-corresponse-the-discontinuity-in-image-brightness-2 _ fig 5 _ 310301668。【访问时间:2018 年 4 月 11 日】。
“Jaedukseo/Python _ Basic _ Image _ Processing”。2018.Github。2018 年 4 月 11 日访问。https://github . com/JaeDukSeo/Python _ Basic _ Image _ Processing/blob/master/4 _ Add _ noise/four . py。
“西皮。杂项 Imread — Scipy V0.18.1 参考指南”。2018.Docs.Scipy.Org。2018 年 4 月 11 日访问。https://docs . scipy . org/doc/scipy-0 . 18 . 1/reference/generated/scipy . misc . im read . html。
Pixabay 上的免费图像——核磁共振成像，磁性，x 光，头骨，头部。(2018).Pixabay.com。检索于 2018 年 4 月 9 日，来自https://pix abay . com/en/MRI-magnetic-x-ray-skull-head-782457/
Pixabay 上的免费图像——日落、灯塔、黎明、黄昏、太阳。(2018).Pixabay.com。检索于 2018 年 4 月 9 日，来自https://pix abay . com/en/sunset-light house-dawn-dusk-sun-3120484/
Pixabay 上的免费图像——核磁共振成像，磁性，x 光，头骨，头部。(2018).Pixabay.com。检索于 2018 年 4 月 9 日，来自https://pix abay . com/en/MRI-magnetic-x-ray-skull-head-782459/

我用 25 个问题来测试一个数据科学家对交互式代码的图像处理-第 2 部分

原文：https://towardsdatascience.com/my-take-on-25-questions-to-test-a-data-scientist-on-image-processing-with-interactive-code-part-2-77eacfd96cf9?source=collection_archive---------4-----------------------

GIF from this website

所以我找到了这个了不起的博主 Faizan Shaikh ，他的博客上有一些令人惊奇的东西！所以请你查一查他，也就是他是“ 25 题测试一个数据科学家对图像处理的 ”的创作者。所以我会试着挑战自己去解决它们，这是第二部分！请注意，我的解决方案不会优化。

还有，这是我用来做演示的两张图片。
1。 脑 MRI 来自 pixabay 2。 自然图像来自 pixabay

如果你想看第一部分，请点击这里。

11)【是非】JPEG 是一种有损图像压缩技术

对于这个问题，我不仅好奇 JPEG 是什么，也好奇 PNG 图像格式是什么，所以我决定去查一下。

Image from this website

所以从上面的图片，我们可以得出两个结论。JPEG 是有损压缩，PNG 是无损压缩。因此答案是正确的。

12)给定一幅只有 2 个像素，每个像素有 3 个可能值的图像，可以形成多少个可能的图像直方图？

我真的不知道这个问题，但从逻辑上来说。我们有 2 个像素，每个像素都有 RGB 通道。因此，我们已经知道有 3 * 3 = 9 种可能配置组合。但是顺序对于直方图来说并不重要，重要的是像素强度的频率。因此 3 + 3 = 6。(作者和我不同意这一条，如果我错了请告诉我。)

13) 1D 平均卷积

假设上面的 1D 图像没有填充，我们可以简单地计算一下。(8+5+2)/3 = 15/3 = 5.因此倒数第二个像素值将保持不变。

14) FMRI 问题(脑部核磁共振)

首先，我需要知道什么是 FMRI，所以我做了一个简单的谷歌搜索。

Image from this website

FMRI 似乎是一种测量大脑活动的简单技术。现在让我们看看这个 FMRI 的输出。

Image from this website

我试图找到对 FMRI 输出的解释，但是我不能找到确切的答案。但我找到了一个实验对象的功能磁共振成像结果。它似乎产生了 2D 输出。(然而我的答案是错的。)

15)以下哪种方法被用作边缘检测的模型拟合方法？

为了这个问题，我必须复习很多东西。从什么是模型拟合算法开始。

GIF from this website

从简单的谷歌搜索我们已经可以知道模型拟合算法做什么，在大多数情况下，它看起来像函数逼近。现在让我们回到这个问题，SIFT 是一个特征检测器，Gaussain 检测器可以理解为斑点检测。因此，答案必须是 RANSAC。

16)中值滤波器

我不会说中值滤波是最好的方法，因为这要视情况而定，但是正如我们在下面看到的，它确实可以做到。让我们使用来自栈溢出帖子的这段代码来添加一些 s alt 和 pepper 噪声并使用中值滤波器去噪。

左图 →有椒盐噪声的图像
右图 →中值滤波后的图像

我们可以清楚地看到中值滤波器的出色表现。

17)卷积运算

对于这个问题我们需要回顾一下，卷积运算之前内核发生了什么。

Image from this website

从这个网站上，我们可以清楚地看到一个卷积运算会发生什么。在应用卷积运算之前，我们将内核翻转 180 度。因此，我们可以得出结论，图像将向右移动，而不是向左。

18)图像锐化

对于这个问题，我们可以清楚地知道选项 A 不是这种情况，因为从应用身份图像中减去结果图像将导致黑色图像。但是让我们试一试。

左图 →原图
中图 →中间结果图
右图 →结果图

上面的图像是按照选项 A 的步骤生成的，正如我们所看到的，没有任何区别。

左图像 →原始图像
中间图像 →中间结果图像
右图像 →结果图像

上面的图像是按照选项 B 的步骤生成的，我们可以看到图像中有一些奇怪的伪像，但是从中间生成的图像中，我们可以看到我们正在给原始图像添加边缘。

左图 →原图
右图 →结果图

上面的图像是按照选项 C 的步骤生成的，我们可以看到图像中有一些奇怪的伪像，结果图像看起来没有那么清晰。所以答案会是选项 b。

19)信号卷积

对于这个问题，维基页面实际上在首页有直接的答案。

Image from this website

因此，从上图中，我们可以得出结论，运算 1 是卷积运算，运算 2 是互相关运算。因此答案是 b。

Video from this website

上面是一个视频，真实的例子。(然而，作者和我似乎又不同意，如果我错了，请让我知道。)

交互代码

对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的游戏场地上复制一份。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

请注意，我不想滥用任何数据政策。所以对于谷歌 Colab，我找到了下面的图片，它被标记为重复使用。要访问在线代码，请点击此处。

Image from this website

最后的话

在我的下一篇文章中，我会回答所有的问题。敬请关注！

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

与此同时，请在我的推特这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。如果你感兴趣的话，我还做了解耦神经网络的比较。

参考

“JPEG”。2018.En.Wikipedia.Org。2018 年 4 月 11 日访问。https://en.wikipedia.org/wiki/JPEG
“便携式网络图形”。2018.En.Wikipedia.Org。2018 年 4 月 11 日访问。https://en.wikipedia.org/wiki/Portable_Network_Graphics。
Pixabay 上的免费图像——核磁共振成像，磁性，x 光，头骨，头部。(2018).Pixabay.com。检索于 2018 年 4 月 9 日，来自https://pix abay . com/en/MRI-magnetic-x-ray-skull-head-782457/
Pixabay 上的免费图像——日落、灯塔、黎明、黄昏、太阳。(2018).Pixabay.com。检索于 2018 年 4 月 9 日，来自https://pix abay . com/en/sunset-light house-dawn-dusk-sun-3120484/
Pixabay 上的免费图像——核磁共振成像，磁性，x 光，头骨，头部。(2018).Pixabay.com。检索于 2018 年 4 月 9 日，来自https://pix abay . com/en/MRI-magnetic-x-ray-skull-head-782459/
功能磁共振成像(fMRI)——NYU 认知神经生理学实验室。(2018).NYU 认知神经生理学实验室。检索于 2018 年 4 月 11 日，来自https://med . NYU . edu/thesenlab/research-0/research-functional-magnetic-resonance-imaging-fmri/
[复本]，H. (2018)。如何用 OpenCV 在 Python 中给图像添加噪声(高斯/椒盐等)。Stackoverflow.com。检索于 2018 年 4 月 11 日，来自https://stack overflow . com/questions/22937589/how-to-add-noise-Gaussian-salt-and-pepper-etc-to-image-in-python-with-opencv？rq=1
椒盐噪声。(2018).En.wikipedia.org。检索于 2018 年 4 月 11 日，来自https://en.wikipedia.org/wiki/Salt-and-pepper_noise
我用 25 个问题来测试一个数据科学家关于交互式代码的图像处理-第 1 部分。(2018).走向数据科学。检索于 2018 年 4 月 11 日，来自https://towards data science . com/my-take-on-25-questions-to-test-a-data-scientist-on-image-processing-with-interactive-code-part-1-a 6196 f 535008
安，S. (2018)。2D 卷积的例子。Songho.ca 于 2018 年 4 月 11 日检索，来自http://www . song ho . ca/DSP/convolution/convolution 2d _ example . html
OpenCV:平滑图像。(2018).Docs.opencv.org。检索于 2018 年 4 月 11 日，来自https://docs . opencv . org/3 . 1 . 0/D4/d13/tutorial _ py _ filtering . html
用 Matlab 实现互相关和卷积的可视化(已编辑)。(2018).YouTube。检索于 2018 年 4 月 11 日，来自 https://www.youtube.com/watch?v=O9-HN-yzsFQ
交叉相关。(2018).En.wikipedia.org。检索于 2018 年 4 月 11 日，来自https://en.wikipedia.org/wiki/Cross-correlation
曲线拟合。(2018).En.wikipedia.org。检索于 2018 年 4 月 11 日，来自https://en.wikipedia.org/wiki/Curve_fitting

我用 30 个问题来测试一个数据科学家关于自然语言处理和交互式代码的能力—第 1 部分

原文：https://towardsdatascience.com/my-take-on-30-questions-to-test-a-data-scientist-on-natural-language-processing-with-interactive-b8664c53be13?source=collection_archive---------3-----------------------

GIF from this website

Shivam Bansal 是一名数据科学家，在自然语言处理和机器学习方面拥有丰富的经验。他有一篇关于自然语言处理的惊人博文。因此，如果有人感兴趣，请检查他的工作，他们是超级有益的。今天，我将试着回答他的 30 个自然语言处理问题中的一些问题。

此外，我不会按数字顺序回答问题。对于每一个问题，我会努力找到正确的答案并把它们联系起来。然而， 我总是乐于学习和成长 ，所以如果你知道一个更好的解决方案，请在下面评论。

Q1)以下哪种技术可用于关键字规范化，即将关键字转换为其基本形式的过程？

所以关键词规范化就是把一个词(关键词)处理成最基本的形式。这方面的一个例子是，将 sadden、saddest 或 sadly 转换成 sad 这个词。(因为这是最基本的形式)知道了这一点，现在让我们看看我们可以选择的选项。

Image from this website

所以从上图我们可以直接看到词干化和词汇化都是用来将单词转换成最基本形式的技术。(而且他们甚至举了一个汽车的例子，car 的→ car)。最后，让我们看看其他两个选择意味着什么。(这篇文章也很好地解释了词干化和词汇化之间的区别。)

Image from this website

如上所述，我们知道 Levenshtein 用于测量不同句子之间的相似性，Soundex 用于根据单词的发音对其进行索引。因此，它们不是用于关键字规范化的合适工具。最后，让我们看看这在 python 中是什么样子的。

红框 →原词归一化关键字

如上所述，我们知道单词 studies/学习在词干化/词汇化之后已经变成了 studi 或 study。我们可以确认我们的解决方案是正确的。

Q2) N 元文法被定义为 N 个关键字的组合。从给定的句子中可以产生多少个二元语法:

我首先需要回答什么是 N 元文法的问题，我发现一个堆栈溢出问题很好地回答了 N 元文法到底是什么。

Image from this website

因此，假设我们没有使用#(单词边界)，下面是我们可以从句子“Analytics Vidhya 是学习数据科学的一个很好的来源”中生成的所有双字母组合。

【《分析 Vidhya》、《Vidhya 是》、《是一个》、《一个伟大的》、《伟大的来源》、《来源于》、《学习》、《学习数据》、《数据科学》】。意思是一共有 9 个双字母组合。现在让我们看看实现。

最后，我们可以确认我们的解决方案是正确的。

Q3)在执行下面的文本清理步骤之后，从下面的句子中可以生成多少个三元组短语

我们已经知道什么是三元组(从问题 2)。现在让我们更深入地看看什么是停用词删除以及取代标点符号。

Image from this website

从一个简单的谷歌搜索中，我们知道停用词删除是指删除诸如“是”、“一个”和“该”等词的过程。现在，我们需要将每个标点符号替换为单个空格。为此，我们需要知道 python 字符串库中有哪些标点符号。我们可以这样做来得到它，就像…

知道了所有这些，我们可以首先从句子中删除所有的停用词……(要查看停用词列表，请点击此处)

“# Analytics-vid hya great source learn @ data _ science。”

现在让我们用一个空格代替所有的标点符号，给我们…

Analytics vidhya 大源码学习数据科学

最后，让我们创建三元语法，它给出了单词列表["Analytics vidhya great "，" vidhya great source "，" great source learn "，" learn data science"]，长度为 5。(给了我们答案 c)。现在让我们看一下实现。

从上面我们可以看到，我们得到了相同的句子"分析 vidhya 伟大的来源学习数据科学"。

Q4)以下哪个正则表达式可用于识别文本对象中的日期:

这是一个棘手的问题(至少对我来说)，但是通过简单的实现，我们可以看到没有一个正则表达式匹配日期。

从那里我们知道一个解正则表达式可以是(' \d{4}-\d{2}-\d{2}|\d{2}/\d{2}，\d{4} ')，它不作为一个选项存在，因此答案是 D)

Q5)以下哪种模型可以根据上述上下文对推文进行分类？

在深入这个问题之前，让我们简单回顾一下什么是 SVM /朴素贝叶斯。

Image from this website

无需深入每个分类器的细节，我们已经可以看出它们是在监督学习环境中使用的相似算法。然而，我们的问题表明，我们只收集了推文，仅此而已(我会假设这些是标签数据。).因此，没有一个，但如果标签包括在内，我想我们可以两个都用。答案应该是他们两个。

Q6)您已经创建了数据的文档术语矩阵，将每条推文视为一个文档。关于文档术语矩阵，以下哪一项是正确的？

目前，所有这些选项对我来说似乎都是正确的，但是让我们更深入地了解什么是文档术语矩阵。

Image from this website

Example from this website

从上面的两张图片中，我们可以了解什么是文档矩阵。我会简单地称它为一种更简单的表示文本或句子的方法。(以向量形式)现在，让我们来看一下选项，删除停用词意味着删除“是”这样的词，因此它将被视为降维。我把规范化理解为关键词规范化，把学习转化为学习等等。因此，如果我们有两个包含单词“学习”和“研究”的句子，它们都将被表示为“学习”,因此是降维。最后，我认为将所有的单词转换成小写仍然是一种降维，因为它减少了我们需要表示所有句子的单词数量。因此，我认为答案是 D)。

互动码

对于谷歌实验室，你需要一个谷歌帐户来查看代码，你也不能在谷歌实验室运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要访问这篇文章中使用的代码，请点击此处。

遗言

这些问题确实是开始 NLP 的好地方。我不仅能够实践实施，还获得了一些理论知识。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

与此同时，请在我的 twitter 这里关注我，并访问我的网站或我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 pos t。

参考

NLP]，3。，& NLP]，3。(2017).测试数据科学家自然语言处理的 30 个问题[解决方案:Skilltest — NLP] — Analytics Vidhya。分析 Vidhya。检索于 2018 年 5 月 24 日，来自https://www . analyticsvidhya . com/blog/2017/07/30-questions-test-data-scientist-natural-language-processing-solution-skilltest-NLP/
Shivam Bansal，分析 Vidhya 的作者。(2018).分析 Vidhya。检索于 2018 年 5 月 24 日，来自 https://www.analyticsvidhya.com/blog/author/shivam5992/
词汇化——谷歌搜索。(2018).Google.ca .检索 2018 年 5 月 24 日，发自https://www.google.ca/search?q=lemmatization&rlz = 1c 1 chbf _ enca 771 ca 771&OQ = lemma tization&aqs = chrome . 0.0l 6.308 j0 j 7&sourceid = chrome&ie = UTF-8
莱文斯坦距离。(2018).En.wikipedia.org。检索于 2018 年 5 月 24 日，来自https://en.wikipedia.org/wiki/Levenshtein_distance
Soundex。(2018).En.wikipedia.org。检索于 2018 年 5 月 24 日，来自https://en.wikipedia.org/wiki/Soundex
克？，W. (2018)。n Gram 到底是什么？。堆栈溢出。检索于 2018 年 5 月 24 日，来自https://stack overflow . com/questions/18193253/what-exact-is-a-n-gram
NLTK，G. (2018)。用 NLTK 生成二元模型。堆栈溢出。检索于 2018 年 5 月 24 日，来自https://stack overflow . com/questions/37651057/generate-bigrams-with-nltk
停用词。(2018).ranks . nl . 2018 年 5 月 25 日检索，来自https://www.ranks.nl/stopwords
j . brown lee(2017 年)。如何用 Python 清理机器学习的文本？机器学习精通。检索于 2018 年 5 月 25 日，来自https://machine learning mastery . com/clean-text-machine-learning-python/
python？，h. (2018)。字符串 python 中如何替换标点符号？。堆栈溢出。检索于 2018 年 5 月 25 日，来自https://stack overflow . com/questions/12437667/how-to-replace-punctuation-in-a-string-python/12437721
[在线]可在:https://www . quora . com/How-do-I-remove-stop words-from-a-file-using-python[2018 年 5 月 25 日访问]。
Python 正则表达式。(2018).【www.tutorialspoint.com】T4。检索于 2018 年 5 月 25 日，来自https://www . tutorialspoint . com/python/python _ reg _ expressions . htm
表情？，P. (2018)。Python/Regex —如何使用正则表达式从文件名中提取日期？。堆栈溢出。检索于 2018 年 5 月 25 日，来自https://stack overflow . com/questions/7728694/python-regex-how-to-extract-date-from-filename-using-regular-expression
运营商，P. (2018)。Python 正则表达式匹配或运算符。堆栈溢出。检索于 2018 年 5 月 25 日，来自https://stack overflow . com/questions/19821487/python-regex-match-or-operator
支持向量机。(2018).En.wikipedia.org。检索于 2018 年 5 月 25 日，来自https://en.wikipedia.org/wiki/Support_vector_machine
朴素贝叶斯分类器。(2018).En.wikipedia.org。检索于 2018 年 5 月 25 日，来自https://en.wikipedia.org/wiki/Naive_Bayes_classifier
文档术语矩阵。(2018).En.wikipedia.org。检索于 2018 年 5 月 25 日，来自https://en.wikipedia.org/wiki/Document-term_matrix

我对数据科学面试问题的看法[第一部分]

原文：https://towardsdatascience.com/my-take-on-data-scientist-interview-questions-part-1-6df22252b2e8?source=collection_archive---------3-----------------------

GIF from this website

我的一个朋友为进入数据科学的人编制了一个问题列表。我想回答他们，请注意我不知道这些问题的来源，如果有人知道这些问题来自哪里，请在下面评论。

此外，我会尽力为每个问题提供正确的答案。然而， 我总是乐于学习和成长 ，所以如果你知道一个更好的解决方案，请在下面评论。

什么是特征向量？

我目前对特征向量的理解非常有限。假设我们正在使用标准卷积神经网络(CNN)和全连接神经网络(FNN)构建一个分类器。其中 CNN 负责从图像中提取高级特征(从边缘和角落开始到面部等)。在从 CNN 到 FNN 的转换中，我们最有可能对图像进行矢量化，这就是我称之为特征向量的地方。

WiKi def

Research Gate Comment

我很惊讶，甚至原始像素值也可以被认为是一个特征向量。但确实有道理。现在让我们实际做一些编码，让我们使用 MNIST 数据集创建一个猪特征向量。(如果有人对什么是猪的特征感兴趣，请阅读这个博客，它是惊人的。)

左图 →图像 3 的可视化 HOG 特征
右图 →图像 6 的可视化 HOG 特征

正如所看到的，我们可以知道每个图像的 HOG 特征向量长度为 2048，当我们可视化这些向量时，它看起来像右边的东西。

2。解释制作决策树的步骤

我最近了解了二叉查找树，但我不知道如何解决这个问题，但我来了。从不同类型的用户那里收集关于许多不同结果的信息，开始绘制他们的二元答案(以树形方式),继续这个过程，直到我们绘制出所有内容？

Image from smartdraw

我对我搜索到的答案并不是 100%满意，然而，谢天谢地，YouTube 上有一个关于如何在商业环境中绘制决策树的教程。这是一个老视频，但它确实有帮助。

This video is from MBAbullshitDotCom

3。什么是根本原因分析？

我的英语有限，但我会试试看。根:我认为这是一些基本的东西，当我想指出一些东西的核心时，我会说这个词。所以我认为根本原因分析是找出问题核心原因的过程。

Image from this website

Image from wiki

看起来我对这个定义是一清二楚，但是我忘了说根本原因分析不仅仅是识别核心原因，它还用于防止类似的问题再次发生。最后，我发现实际上有一篇论文写的是“ 根本原因分析的技巧 ”如果有人感兴趣请阅读下面。

4。什么是逻辑回归？

我对回归这个术语的理解是预测。所以用我的话来说，线性回归就是得到一条最佳的线性线来预测未来的结果，比如房价。对于逻辑，我只能想到逻辑 sigmoid 函数，所以结合这两个术语，我认为逻辑回归是对离散值的预测，而不是对连续值的预测。

Image from this website

Image from Wiki

一般来说，逻辑回归预测分类值。它可以是简单的二进制值，也可以是复杂的多类预测。最后让我们看看指数函数和逻辑函数之间的区别。(如果有人对这个话题更感兴趣，请点击这里。)

Image from this website

5。什么是推荐系统？

推荐系统的一个很好的例子是 You-tube 的推荐视频部分。这里有一个算法(很多人会称之为 AI)接收用户在过去 2 或 4 周观看的视频列表。并搜索相似内容的视频推荐给用户。因此，在某种程度上，这可以是一种逻辑回归，其中一种算法试图预测用户最有可能观看的下一类视频。

Image from Wiki

哇，我从来不知道信息过滤系统这个术语的存在，更不知道推荐系统只是这个系统的一部分。现在让我们试着建立一个简单的推荐系统。

紫色、绿色、黄色斑点 →三种口味的冰淇淋某些用户喜欢
红点 →我们之前没有任何信息的新用户

假设我们有一家冰淇淋店，我们的每一位顾客都被表示为 2D 网格中的一个坐标。因此，x 值在[0–6]和 y 值在[0–7.5]范围内的人喜欢紫色冰淇淋等。现在，一个新用户带着坐标[2，7.5]、[8，15.5]和[20，11]进来。我们应该向我们的新顾客推荐什么口味的冰淇淋？我使用的一个简单方法是建立一个 KNN(邻居值为 3 ),让算法为我们预测味道。

6。梯度下降法总是收敛到同一点吗？

不，它可以收敛到局部最小点，为了防止这种情况经常发生，激活函数必须是单调的。(我在这篇博文中对此做了更多解释。)

Amazing answer from this website

在我看来，上面的图片是这个问题的最佳答案。

7。A/B 测试的目的是什么？

每当我试图解决面试问题时，似乎总有一个问题与 A/B 测试有关。我简单地说，A/B 测试的目标是弄清楚当给定环境中有一个差异时，受试者的态度是如何变化的。

Image from Wiki

Image from this website

上面的图片是网站 A/B 测试的具体定义，但我认为它可以推广到不同的行业，如医药，或物流等…

8。线性模型的缺点是什么？

线性模型的一个明显的好处是简单。Y = aX + b，如果我们试着用这个等式建立一个模型，我们已经知道它有多简单了。然而，我认为简单性也是线性模型的一个缺点。由于它的简单性，我们不能用线性模型来模拟复杂的情况。

Image from this website

我忽略了很多要点，比如它们对异常值很敏感，而且容易过度拟合。此外，我认为我的答案是错误的，因为我们可以使用更高的多元名义回归来预测更复杂的情况，所以这不是线性回归的倒退。

交互代码

要访问这篇文章中使用的代码，请点击这里。

遗言

Unsplash.com by artist 😛hoto by Štefan Štefančík.

每当我“试图”解决面试问题时，我都会变得更加谦逊。这恰恰说明了我对数据科学的不了解。同时也让我兴奋。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的 twitter 上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 t。

参考

特征(机器学习)。(2018).En.wikipedia.org。检索于 2018 年 5 月 6 日，来自https://en . Wikipedia . org/wiki/Feature _(machine _ learning)
Anon，(2018)。【在线】可在:https://www . research gate . net/post/in _ simple _ words _ what _ do _ you _ mean _ by _ feature _ vector _ in _ image _ processing【2018 年 5 月 6 日访问】。
'可视化'，h. (2018)。hog()获得了意外的关键字参数“visualize”。堆栈溢出。检索于 2018 年 5 月 6 日，来自https://stack overflow . com/questions/46516571/hog-got-an-unexpected-keyword-argument-visualize
方向梯度直方图—浏览 0.14 版开发文档。(2018).Scikit-image.org。2018 年 5 月 6 日检索，来自http://scikit-image . org/docs/dev/auto _ examples/features _ detection/plot _ hog . html
Mallick，S. (2016 年)。方向渐变直方图|学习 OpenCV。Learnopencv.com。检索于 2018 年 5 月 6 日，来自https://www . learnopencv . com/histogram-of-oriented-gradients/
威廉姆斯，下午(2001 年 4 月)。根本原因分析技术。贝勒大学医学中心学报(第 14 卷，第 2 期，第 154-157 页)。泰勒&弗朗西斯。
根本原因分析。(2018).En.wikipedia.org。2018 年 5 月 6 日检索，来自https://en.wikipedia.org/wiki/Root_cause_analysis
根本原因分析。(2016).企业服务部。2018 年 5 月 6 日检索，来自https://des . wa . gov/services/risk-management/about-risk-management/enterprise-risk-management/root-cause-analysis
什么是逻辑回归？—统计解决方案。(2018).统计解决方案。检索于 2018 年 5 月 6 日，来自https://www . statistics solutions . com/what-is-logistic-regression/
逻辑回归。(2018).En.wikipedia.org。检索于 2018 年 5 月 6 日，来自 https://en.wikipedia.org/wiki/Logistic_regression
后勤职能。(2018).Xaktly.com。检索于 2018 年 5 月 6 日，来自http://xaktly.com/LogisticFunctions.html
信息过滤系统。(2018).En.wikipedia.org。检索于 2018 年 5 月 6 日，来自https://en.wikipedia.org/wiki/Information_filtering_system
分类器的概率校准-sci kit-学习 0.19.1 文档。(2018).Scikit-learn.org。2018 年 5 月 6 日检索，来自http://sci kit-learn . org/stable/auto _ examples/calibration/plot _ calibration . html # sphx-glr-auto-examples-calibration-plot-calibration-py
python，G. (2018)。用 python 从列表中获取唯一值。堆栈溢出。2018 年 5 月 6 日检索，来自https://stack overflow . com/questions/12897374/get-unique-values-from-a-list-in-python
plots，P. (2018 年)。Python matplotlib 叠加散点图。堆栈溢出。检索于 2018 年 5 月 6 日，来自https://stack overflow . com/questions/11190735/python-matplotlib-supplease-scatter-plots
sk learn . datasets . make _ blobs-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。2018 年 5 月 6 日检索，来自http://sci kit-learn . org/stable/modules/generated/sk learn . datasets . make _ blobs . html # sk learn . datasets . make _ blobs
二叉查找树。(2018).En.wikipedia.org。检索于 2018 年 5 月 6 日，来自 https://en.wikipedia.org/wiki/Binary_search_tree
决策树——了解关于决策树的一切。(2018).Smartdraw.com。检索于 2018 年 5 月 6 日，来自 https://www.smartdraw.com/decision-tree/
7 分钟决策树教程，包含决策树分析和决策树示例(基础)。(2018).YouTube。检索于 2018 年 5 月 6 日，来自https://www.youtube.com/watch?v=a5yWr1hr6QY
【Google Deep mind】—利用交互代码进行医学图像分割的深度学习。(2018).走向数据科学。检索于 2018 年 5 月 6 日，来自https://towards data science . com/Google-deep mind-deep-learning-for-medical-image-segmentation-with-interactive-code-4634 b 6 FD 6a 3a
A/B 测试。(2018).En.wikipedia.org。检索于 2018 年 5 月 6 日，来自https://en.wikipedia.org/wiki/A/B_testing
AB 测试-完全指南。(2018).网站。于 2018 年 5 月 6 日检索，来自https://vwo.com/ab-testing/
最优？，D. (2018)。梯度下降总是收敛到一个最优值吗？。数据科学堆栈交换。2018 年 5 月 6 日检索，来自https://data science . stack exchange . com/questions/24534/does-gradient-descent-always-converge-to-a-optimum
)你的参考书目:Anon，(2018)。[在线]见:https://www . quora . com/What-is-the-limits-of-linear-regression-modeling-in-data-analysis【2018 年 5 月 6 日获取】。
(2018).Sciencing.com。检索于 2018 年 5 月 6 日，来自https://science . com/advantages-linear-regression-8562780 . html

我对谷歌人工智能交互式代码面试问题的看法——第一部分

原文：https://towardsdatascience.com/my-take-on-google-ai-interview-question-with-interactive-code-part-1-db2e33a26f10?source=collection_archive---------3-----------------------

Gif from this website

所以我找到了这个了不起的博客作者维马什·卡巴里，他的博客上有一些了不起的东西！所以请看看他，他也是人工智能的创造者。今天，我将尝试从这个博客回答他的谷歌人工智能采访问题。请注意，我的解决方案不会优化。

另外，我不会按数字顺序回答问题。对于每一个问题，我会努力找到正确的答案并把它们联系起来。然而， 我总是乐于学习和成长 ，所以如果你知道一个更好的解决方案，请在下面评论。

1/x 的导数是多少？

谢天谢地，这个有点简单，它是(- 1 / (x))

Image from this website

Graphed in Python

绘制曲线 log(x+10)

幸运的是这也是可行的，我已经知道 log()函数看起来像一个 L，但水平翻转，所以可以把这个函数想象成它的翻译。

Image from this website

Graphed in Python

为什么不是 logistic 回归，为什么是 GBM？

****更新感谢Mikael Huss和Adrien Lucas Ecoffet指出错误。GBM 代表梯度推进机器，而不是几何布朗运动。请注意我的答案是错误的！

我不知道“GBM”是什么意思，直到我研究了它。我想是指几何布朗运动下面是维基答案定义。

Image from Wiki

从那以后，我需要思考选择 GBM 比选择逻辑回归更好的情况。(问题是，我甚至不知道 GBM 存在 LOL，但我们还是可以估计一下)。让我们首先看看 GBM 实际使用的情况。

Answer from quora

Answer from Wiki, for the link please see above

因此，GBM 似乎被广泛用于股票市场定价。我通常将逻辑回归与一个分类问题的解决方案联系起来，(或者对离散值的回归)然而，这似乎是我们想要预测连续值的情况(我不是 100%确定股市预测是否只能被视为连续回归，如果我错了请纠正我。)所以我想，答案之一可能是，由于逻辑回归不能预测连续值，所以我们最好使用 GBM。(但我真的认为这是一个后续问题，对我来说没有多大意义。)

Image from my blog post

抛硬币十次，结果是八个正面和两个反面。你会如何分析一枚硬币是否公平？p 值是多少？

****更新感谢 扬扎瓦日基 关于 p 值的精彩讲解！要查看它们，请向下滚动到评论区！

所以正面的概率是 80%，反面的概率是 20%。对于这个问题，我认为取期望值，并与我们得到的值进行比较，可能是一个答案。( 然而，我不擅长统计学或数学，所以如果任何统计学家或数学家知道答案，请在下面评论。 )

因此，期望值的等式是 E[x] = n * p(x)，如果我们插入数字，我们可以看到获得正面的期望值是
E[x] = 10 * 0.5 = 5，所以当我们投掷硬币 10 次时，我们可以预期看到 5 次是正面。(尾巴也一样)。但是我们只看到了两个尾巴，所以我想我们可以说这枚硬币偏向正面。对于 p 值，我实际上忘了怎么做了。

Image from this website

因此，期望值的等式和计算是正确的，对于 p 值，我按照这个 WikiHow 页面上的逐步指南，在显著性水平为 0.05 的情况下，我得到了 0.05 到 0.1 之间的 p 值。(如果我说错了，请告诉我。)

Image from Wikihow

你有一个谷歌应用程序，你做出了改变。如何测试一个指标是否增加了？

我从我的前一篇博文中学到了什么是 A/B 测试，所以我认为这是一个完美的用例，A/B 测试可以帮助我们了解指标是否增加了。我会随机将用户重定向到我的应用程序的两个版本，一个有变化，另一个没有变化(假设两个版本之间只有一个不同)，然后观察它们的表现。

Image from this website

通过简单的谷歌搜索，我找到了上面的帖子，所以从某种意义上来说，A/B 测试是正确的。(希望如此)。

每年有多少人申请谷歌？

嗯，很多，但我真的很好奇，一个谷歌搜索做到了这一点。

Image from this website

交互代码

对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上复制一份。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要访问 Google Colab 上的代码，请点击此处。

最后的话

在这篇文章中，当我试图解决这些问题时，我变得更加谦虚，意识到我知道的很少。要成为数据科学专家，我还有很多工作要做。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你希望看到我所有写作的列表，请在这里查看我的网站。

同时，在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。如果你感兴趣的话，我还做了解耦神经网络的比较。

参考

谷歌人工智能面试问题——应对人工智能面试。(2018).中等。检索于 2018 年 4 月 7 日，来自https://medium . com/acing-ai/Google-interview-questions-acing-the-ai-interview-1791 ad 7 DC 3 AE
德斯莫斯图表。(2018).德斯莫斯图形计算器。于 2018 年 4 月 7 日检索，来自https://www.desmos.com/calculator
几何布朗运动。(2018).En.wikipedia.org。于 2018 年 4 月 7 日检索，来自https://en.wikipedia.org/wiki/Geometric_Brownian_motion
[2]2018.【在线】。可用:https://www . quora . com/Why-is-Geometric-Brownian-Motion-used-so-wide-the-stock-markets。[访问时间:2018 年 4 月 7 日]。
"我对优步人工智能面试问题的互动代码——第一部分."走向数据科学。n . p . 2018。网络。2018 年 4 月 7 日。
每年有多少人申请谷歌？—谷歌搜索。(2018).Google.ca 检索 2018 年 4 月 7 日，来自https://www.google.ca/search?q = How+many+people+apply+to+Google+每年% 3F&rlz = 1c 1 oclt _ enca 772 ca 772&OQ = How+many+people+apply+to+Google+每年%3F & aqs=chrome..69i 57.586 j0j 7&sourceid = chrome&ie = UTF-8
统计学中的期望值:定义和计算。(2018).统计学如何？2018 年 4 月 7 日检索，来自http://www . statistics show to . com/probability-and-statistics/expected-value/
如何计算 P 值？(2018).维基百科。检索于 2018 年 4 月 7 日，来自 https://www.wikihow.com/Calculate-P-Value
应用内 A/B 测试介绍——Google Play 应用和游戏——中级。(2017).中等。检索于 2018 年 4 月 7 日，来自https://medium . com/Google play dev/an-introduction-to-in-app-a-b-testing-C5 a9 a 69 a 3791

我对微软人工智能交互式代码面试问题的看法——第一部分

原文：https://towardsdatascience.com/my-take-on-microsoft-ai-interview-questions-with-interactive-code-part-1-c271388af633?source=collection_archive---------1-----------------------

Gif from this website

所以我找到了这个了不起的博客作者维马什·卡巴里，他的博客上有一些了不起的东西！所以请看看他，他也是人工智能的创造者。今天，我将尝试从这个博客回答他的微软人工智能采访问题。请注意，我的解决方案不会优化，而且 我总是乐于学习和成长 ，所以如果你知道一个更好的解决方案，请在下面评论。

另外，我不会按数字顺序回答问题。

合并 k(本例中 k=2)个数组并排序。

为此我会使用冒泡排序，我知道这不是最有效的排序算法，但它很容易描述和实现。

L1 和 L2 有哪些不同的成本函数/正则化指标？

Image from Chioka’s blog

我会说，L1 是预测值和地面真实值之间的绝对差值。对于 L2，我会说是均方差。我在本帖中使用正则化实现并比较了 L1 和 L2 成本函数的各种组合。此外，L1 正则化是权重的绝对值之和，L2 是所有权重的平方值之和。

Image from Chioka’s blog

如何找到百分位数？为它写代码。

Image from MathisFun

为此，让我们做一个简单的数学有趣的问题。根据上面的表格，让我们得到 30%的人参观商场的时间。

我会先得到 30%的百分比，然后得到平均时间值，显然这不是最准确的答案，如下所示。但是我们可以得到一个大概的感觉。

好的和坏的数据可视化有什么区别？

好吧，对于这个问题，我们可以有许多不同的答案，我的答案是，当我们没有正确处理异常值并将其可视化时。

假设我们有一个数字数组，我们可以看到在较小的数字中有一个很大的数字(7777)。当我们一起想象这个数组时，它看起来像下面这样。

右图 →原图
中图 →标准化值
左图 →标准化值

如上所述，即使我们将这些值标准化或规范化，创建的图也是非常倾斜的。我在这篇文章中谈到了规范化、标准化和批量规范化。

如何通过玩弄一些计算技巧来更快地计算逆矩阵？

我其实不知道确切的答案是什么，但经过研究，我发现了一种叫做高斯-乔丹法的方法，然而它非常复杂。(要查看 python 的实现，请点击这里。我设法找到了一个更简单解决方案，如下所示，并实现了这个方法。

Image from this website

定义差异

用我的话来说，我会把方差描述为每个数据点的平方差之和，尊重所有数据的平均值。换句话说，数据是否有很大的变化。实际上，数学很有趣有一个惊人的图表来描述这一点。

Image from this website

交互代码

对于 Google Colab，您需要一个 Google 帐户来查看代码，而且您不能在 Google Colab 中运行只读脚本，因此请在您的操场上创建一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要访问 Google Colab 上的代码，请点击此处。

遗言

我总是乐于接受新的、更好的、更有效的想法和答案，如果你知道它们，请在下面评论！

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

与此同时，在我的 twitter 上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。如果你感兴趣，我还在这里做了解耦神经网络的比较。

参考

维马什·卡巴里—中等。(2015).Medium.com。2018 年 4 月 5 日检索，来自https://medium.com/@vimarshk
微软人工智能面试问题——应对人工智能面试。(2018).中等。检索于 2018 年 4 月 5 日，来自https://medium . com/acing-ai/Microsoft-ai-interview-questions-acing-the-ai-interview-be 6972 f 790 ea
https://www.geeksforGeeks.org/bubble-sortBubble 的排序——极客 forgeeks。(2014).极客之福。检索于 2018 年 4 月 5 日，来自 https://www.geeksforgeeks.org/bubble-sort/
Only Numpy:对深度神经网络实施 L1 /L2 范数/正则化的不同组合…(2018).走向数据科学。2018 年 4 月 5 日检索，来自https://towards data science . com/only-numpy-implementing-different-combination-of-L1-norm-L2-norm-L1-regularity-and-14b 01a 9773 b
L1 和 L2 作为损失函数和正则化的区别。(2018).chioka . in . 2018 年 4 月 5 日检索，来自http://www . chioka . in/differences-between-L1-and-L2-as-loss-function-and-regulation/
通过 Numpy 和 Tensorflow 中的示例和交互式代码理解批处理规范化。(2018).走向数据科学。2018 年 4 月 5 日检索，来自https://towardsdatascience . com/understanding-batch-normalization-with-examples-in-numpy-and-tensor flow-with-interactive-code-7f 59 bb 126642
正态分布。(2018).Mathsisfun.com。检索于 2018 年 4 月 5 日，来自https://www . mathsisfun . com/data/standard-normal-distribution . html
numpy.linalg.inv — NumPy v1.12 手册。(2018).Docs.scipy.org。2018 年 4 月 5 日检索，来自https://docs . scipy . org/doc/numpy-1 . 12 . 0/reference/generated/numpy . Lina LG . inv . html
高斯消去法。(2018).En.wikipedia.org。2018 年 4 月 5 日检索，来自https://en . Wikipedia . org/wiki/Gaussian _ elimination # Finding _ the _ inverse _ of _ a _ matrix
托马斯，M. (2013 年)。用高斯消元法解线性方程组。马丁·托马斯。检索于 2018 年 4 月 5 日，来自https://Martin-thoma . com/solving-linear-equations-with-Gaussian-elimination/
matrix，s. (2018)。求矩阵逆矩阵的捷径。Math.stackexchange.com。检索于 2018 年 4 月 5 日，来自https://math . stack exchange . com/questions/21533/shortcut-for-finding-a-inverse-of-matrix
标准差和方差。(2018).Mathsisfun.com。检索于 2018 年 4 月 5 日，来自 http://www.mathsisfun.com/data/standard-deviation.html

我对优步人工智能交互式代码面试问题的看法——第一部分

原文：https://towardsdatascience.com/my-take-on-uber-ai-interview-question-with-interactive-code-part-1-40d6d795a566?source=collection_archive---------5-----------------------

所以我找到了这个了不起的博客作者维马什·卡巴里，他的博客上有一些了不起的东西！所以请看看他，他也是人工智能的创造者。今天，我将尝试从这个博客回答他的优步人工智能采访问题。请注意，我的解决方案不会优化。

描述二进制分类

我将这描述为当我们有两类标记数据时，例如类 Z 和非 Z。我们希望预测给定的数据是否属于某个类。(在本例中为 Z 类)

Wiki 回答:“二元或二项式分类是根据一个分类规则将给定集合的元素分为两组(预测每个元素属于哪个组)的任务。”

解释逻辑回归、假设和数学方程

我不知道这个问题解释假设是什么意思。但我会试着做另外两个。对我来说，我会将逻辑回归描述为对离散值的预测(如猫对狗)，而不是对连续值的预测(如房屋定价)。通过数学方程，我认为这个问题是问逻辑回归的方程。

Screen Shot from CMU Stats

Example of Linear Regression

Wiki 回答:“在统计、逻辑回归，或 logit 回归，或 logit 模型【1】是回归模型，其中因变量(DV) 是范畴
关于逻辑回归的假设，请查看本网站。

缓存是如何工作的，您如何在数据科学中使用它？

我对缓存的理解是为了更快的访问而临时存储数据。但是，这些数据没有被保留，而是被删除了。我不确定这项技术是如何在引擎盖下工作的，我只知道高层次的观点。对于它如何应用于数据科学，我认为这篇来自网飞的博客可以给出答案。

基本上，在网飞，他们可以预测什么内容会最受欢迎(或最受欢迎)，从而优化流媒体。对优步来说，这可能是对汽车需求最高的地方，以优化客户满意度。

什么是异常检测方法？

我认为聚类给定的数据集可以揭示异常值，或者只是简单的方法，采取标准偏差，看看哪些数据点在范围之外也可以工作。

来自网络的回答:这篇博客在解释这些问题上做得非常出色。

Image from this website.

你如何使用 A/B 测试？

我对 A/B 测试的了解非常有限，因为我只能想到医疗环境。其中一组病人服用药物，而另一组不服用。然后我们试图在让他们参与一些活动的时候看到他们之间的一些不同。

Image from this website

Wiki 回答:“在 web analytics 中，A/B 测试(bucket tests 或 split-run testing)是一个有 A 和 B 两个变量的受控实验”(不过，我相信 A/B 测试在每个行业都有使用。)

这篇博文，是对 A/B 测试逐步解释的一个极好的回答。

交互代码

要访问 Google Colab 上的代码，请点击此处。

最后的话

当我做这些问题时，我变得更加谦虚，意识到我知道的很少。要成为数据科学专家，我还有很多工作要做。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请点击这里查看我的网站。

同时，在我的推特这里关注我，访问我的网站，或者我的 Youtube 频道了解更多内容。如果你感兴趣，我还在这里做了解耦神经网络的比较。

参考

二元分类。(2018).En.wikipedia.org。于 2018 年 4 月 6 日检索，来自https://en.wikipedia.org/wiki/Binary_classification
线性回归示例—sci kit—了解 0.19.1 文档。(2018).Scikit-learn.org。2018 年 4 月 6 日检索，来自http://sci kit-learn . org/stable/auto _ examples/linear _ model/plot _ ols . html
逻辑回归。(2018).En.wikipedia.org。于 2018 年 4 月 6 日检索，来自https://en.wikipedia.org/wiki/Logistic_regression
(2018).Stat.cmu.edu。于 2018 年 4 月 6 日检索，来自http://www.stat.cmu.edu/~cshalizi/uADA/12/lectures/ch12.pdf
(2018).Statisticssolutions.com。2018 年 4 月 6 日检索，来自http://www . statistics solutions . com/WP-content/uploads/WP-post-to-pdf-enhanced-cache/1/assumptions-of-logistic-regression . pdf
数据科学如何帮助推动网飞内容的全球交付。(2017).中等。2018 年 4 月 6 日检索，来自https://medium . com/网飞-tech blog/how-data-science-helps-power-world wide-delivery-of-网飞-content-bac55800f9a7
什么是缓存(计算)？—来自 WhatIs.com 的定义。(2018).搜索存储。检索于 2018 年 4 月 6 日，来自https://searchstorage.techtarget.com/definition/cache
A/B 测试。(2018).En.wikipedia.org。检索于 2018 年 4 月 6 日，来自 https://en.wikipedia.org/wiki/A/B_testing
AB 测试-完全指南。(2018).网站。检索于 2018 年 4 月 6 日，来自 https://vwo.com/ab-testing/

我对 2018 年数据科学的五大阅读

原文：https://towardsdatascience.com/my-top-five-data-science-reads-of-2018-687afadcbe29?source=collection_archive---------16-----------------------

"对于那些寻求超越平凡的人来说，阅读是必不可少的。"—吉米·罗恩

数据科学是一个新兴领域，每个人都试图磨练自己的技能来掌握它。人们对成为一名优秀的数据科学家所需的重要因素感到好奇。我相信对统计学的良好理解，对 R/Python 等工具的良好掌握，能够发现数据中的模式，能够应用准确的模型，这些只是所需的众多特征中的一部分。然而，优秀是一回事，成功是另一回事。一个**“成功的**”数据科学家不仅关注必要的工具和概念，还紧跟行业的当前趋势。

书籍是建立更好的视角和拓展想象力的绝佳方式。尽管互联网上有大量的数据科学资源，但书籍有助于加深对该主题的理解，并可以在需要时随时用作参考。

我对书籍和数据都有热情。因此，今年，我挑选了五本书，它们不是“典型的”数据科学类型，但却“有益于数据科学领域”。他们不仅增加了我的知识，还给了我很多关于数据领域的思考。如果你是一名有抱负的数据科学家，正在为慵懒的下午寻找一些读物，我推荐以下列表。

游戏中的皮肤:日常生活中隐藏的不对称

纳西姆·尼古拉斯·塔勒布是我们这个时代最重要的思想家之一。短语“游戏中的皮肤”是风险管理的支柱，但适用于包括数据科学在内的所有领域。如果你在游戏中有皮肤，你更有可能利用你的本地知识，使用重要的东西，丢弃不相关的东西。

如何适用于数据科学？这本书论述了公平、商业效率和应对风险的必要性，所有这些特征都是数据科学生态系统的重要组成部分。

赤裸裸的统计——从数据中剥离恐惧

查尔斯·惠兰的《赤裸裸的统计学》是对统计学及其如何被使用、误用和歪曲的极好介绍。这本书通过剥去表面的争论和揭示主题的潜在价值强调统计学的真实世界的应用。

许多人把这本书比作没有数学的“统计 101 课程”。因此，如果你害怕统计，这本书试图解释直觉，从基本概率到中心极限定理，从描述性统计到回归分析，所有这些都以一种简单直观的方式，带着一点幽默。

真实度

这本书是由有远见的 汉斯·罗斯林 (以及他的儿子和儿媳)写的，既鼓舞人心又富有启示性，充满了生动的轶事和感人的故事。

汉斯·罗斯林用数据、统计和简洁的视觉化表达了对世界及其问题的不同观点。事实证明，尽管这个世界并不完美，但它比我们想象的要好得多。这本书强调需要用事实来衡量世界的进步和发展，以对抗全球的无知。

数据科学教育非常注重数据争论和假设检验。汉斯·罗斯林通过这本书巧妙地提醒我们，形成错误的假设是代价高昂的

信号和噪音:为什么如此多的预测失败了——但有些却没有

[内特·西尔弗](http://Nate Silver) 是一个无需介绍的名字。他是著名的统计学家、作家，也是获奖网站FiveThirtyEight.com的创始人。这本书帮助我们理解预测的局限性和它可以被证明是成功的领域。通过他的书，Nate 带领我们进入了预测的世界，在这个世界里，大量的数据都存在于噪音之中。

如果一个人有兴趣了解现实世界中预测是如何进行的，以及预测者如何克服偏见以揭示准确和有意义的预测，这是一个有用的阅读。

大数据:洞察时代工作、生活和学习的必备指南

多年来，已经有很多关于“大数据”的书籍问世。然而，这本书的重点主要是大数据的应用，这些应用正在重新定义我们周围的业务和流程。

本书由世界上最受尊敬的两位数据专家 【维克托·迈尔·舍恩伯格】 和 肯尼斯·库基尔 撰写。他们谈论什么是大数据、大数据的好处以及如何有效利用大数据。通过本书分享的例子和现实生活中的经历，堪称典范。这本书不仅强调了大数据对从商业到政府，从科学到医学的几乎所有事物的日益增长的影响，而且还对大数据的黑暗面留下了深刻印象。

总的来说，这本书为大数据革命提供了强有力的介绍，对于探索该领域的有抱负的数据科学家来说，这是一本好书。

我很高兴我能读这些书，我希望你也能从中受益。虽然阅读一本书不会让你一夜之间成为一名成功的数据科学家，但它肯定会给你一个更好、更广阔的视角来看待和分析事物。毕竟，从数据中寻找意义是我们的工作。

我对当今优秀数据科学家的两点看法？

原文：https://towardsdatascience.com/my-two-cents-on-what-makes-a-good-data-scientist-nowadays-fea67931766a?source=collection_archive---------5-----------------------

Source: Data Product Development Approaches (Industry 4.0 Series — Part 4) — Sravan Ankaraju

我的父母最近问我，我为了重新生活做些什么。过去，这并不容易解释，因为数据科学不是一个定义明确的领域。甚至当我在埃森哲开始我的第一份工作时，我几乎不知道我到底在做什么。当然有一些定义，比如:

或者著名的德鲁·康威的《数据科学维恩图》。

因此，在这个时候，我对什么是数据科学有了一些线索，但从我的角度来看，我所在领域的每个人，包括我在内，仍然在弄清楚什么是数据科学，以及它如何能够带来价值。至少，大多数人是这么做的。当然，谷歌或亚马逊的一些人马上就理解了我今天所说的现代数据科学，但其他人只是在试验它。例如，当我在埃森哲工作时，我的大多数客户“都希望利用他们的大数据”——不管这意味着什么。我相信你们很多人以前都听过这句话，尤其是如果你在这个领域工作的话。这个目标非常模糊，以至于我做的大部分项目都是一些 powerpoint 演示文稿中的概念证明。

现在，在工作了几年后，我对自己的工作有了更好的理解，我的工作只是创建智能和数据驱动的数据产品——至少，这是我现在告诉我父母的，他们似乎理解这一点。现在可能会出现的一个问题是，如今对于一名优秀的数据科学家来说，什么样的品质是脱颖而出的重要因素？

优秀的数据科学家也是优秀的产品经理

许多众所周知的数字产品直接由数据科学和机器学习驱动。举个例子，

谷歌在其搜索算法中使用机器学习来提高搜索质量
Spotify、网飞或亚马逊使用推荐引擎来推荐新音乐、电影或产品
脸书使用计算机视觉技术自动标记你照片中的朋友，即使它看不到他们的脸
优步利用机器学习创造无人驾驶汽车和许多其他东西。

从这些例子中可以看出，颠覆性技术很好地利用了数据，它们是整体产品的一部分。

如今，仅仅摆弄数据、创建最终出现在 powerpoint 演示文稿中的模型是不够的，它们还需要成为产品的一部分！这就是为什么优秀的数据科学家也需要成为优秀的产品经理。优秀的数据科学家需要了解他们的工作如何在产品中结束，以及如何被消费。他们还需要能够创造一个产品，即使没有数据。我遇到过一些数据科学家，他们告诉我，只有在有数据的情况下，他们才能做数据科学。当然，这是有道理的，但并不是每个产品都是从大量数据开始的。或者也没有数据，特别是如果你还在弄清楚那个产品是什么的话。思考数据很快会带来什么是一项非常重要的技能。 Trey Causey 最近也发表了一篇关于这个话题的文章《数据产品经理的崛起》。你应该看看他的文章。这个课题我也研究过一段时间。去年，我写了一篇名为“数据科学的 API 优先”的文章，文章基本上认为数据科学模型应该尽早包装成 API，以便它们可以无缝地用于产品中。

优秀的数据科学家也是优秀的足球运动员

在足球比赛中，你有 11 名队员。一名球员担任守门员，其他十名球员担任前锋、中场或后卫。虽然有像克里斯蒂亚诺罗纳尔多或莱昂内尔梅西这样的球员脱颖而出，但没有他们的球队，他们什么都不是。例如，梅西在他的俱乐部巴塞罗那做得非常好，但当谈到国家队时，一切都落在他的肩上，他的球队通常在比赛中表现不佳。

这也适用于创造惊人的产品。虽然有那些超级惊人的独角兽，也就是数据科学家，但如果没有他们的同行，如产品经理、设计师、软件工程师、数据工程师、功能专家或创造成功产品所需的任何角色，他们就什么都不是。

例如，让我们把 Spotify 作为设计+数据科学之间合作的一个很好的用例(当然，产品经理、软件工程师等其他角色也参与其中，但在这种情况下，设计和数据科学更明显)。这是他们的产品在多种设备上的图像:

Source: FileHippo

我只是喜欢它们光滑、深色、干净的设计，在我使用的每一个设备上看起来都很完美。但我使用 Spotify 的主要原因是因为他们的“每周发现”功能，他们根据我过去听过的内容编辑每周个性化播放列表。我必须承认它工作得很好。

Source: The Verge

等等——其他品质呢，比如数据科学家也是优秀的黑客、优秀的统计学家、优秀的沟通者、优秀的问题解决者等等…

事实上，我们每个人都同意，如今一名优秀的数据科学家需要具备良好的编程、统计、数学、沟通和解决问题的技能。还有更多的技巧，但我故意不谈论这些，因为有太多的文章在讨论这个问题。我只提到了我认为数据科学将会发展的两个领域。例如，我们看到许多数据产品经理的角色即将出现，因为许多公司意识到许多成功的产品都是数据驱动的。

此外，数据科学领域也将出现更多的跨学科合作。谷歌启动了一个名为“以人为中心的机器学习”的新项目，它基本上应该为与人工智能合作的设计师创造一些指南。还会有更多的合作。我期待着这种发展。

我的 Python 工作秘书

原文：https://towardsdatascience.com/my-upwork-secretary-in-python-ebb4bb56253c?source=collection_archive---------3-----------------------

在 Upwork 工作和找工作既不容易也不困难。招聘人员发布职位，自由职业者前来投标。根据招聘者的需求，他们可以选择一名自由职业者，游戏继续进行。这并不像听起来那么简单。许多自由职业者试图在竞标中杀出一条血路，要么让他们太便宜，要么失去被选中的可能性。自由职业者会明白我在说什么。

因此，作为一名自由职业者，我也曾向资深人士咨询如何成功获得一份体面的工作。我曾经从不同的人那里得到不同的指示。我想到的一个主意是——尝试对工作/项目进行第一次投标。这增加了你被招聘人员注意到的机会。然后试着和他交谈，让他(招聘人员)对你感到舒服，并对选择你充满信心，问一些与工作/项目相关的问题，我指的是好问题。

我想到的一个主意是——尝试对工作/项目进行第一次投标。这增加了你被招聘人员注意到的机会。

当然，为了执行第二个任务，我必须执行第一个。

方案 A:整天坐在传送门上，每分钟按 F-5。

选项 B:利用你唯一拥有的技能(编程),运行一个脚本，在每个定义的时间间隔获取与你的技能相关的报价，并播放通知声音，随后显示具体报价的简要信息和链接。

运行一个脚本，在每个定义的时间间隔获取与您的技能相关的报价，并播放通知声音，随后显示具体报价的简要信息和链接。

我非常幸运，因为 Upwork 确实提供了用于开发目的的 API。我很高兴用我最喜欢的语言——Python 实现了这个想法。简而言之，我把程序分成了许多子任务；它们是:

获取 API 密钥并初始化客户端
在浏览器中打开身份验证 URL
读取令牌并在当天剩余时间存储客户端
按定义的时间间隔获取作业
为每个作业对象生成一个散列字符串(在 JSON BTW 中)
简单:检查历史作业中是否存在哈希；如果是-忽略，如果不是，这是一个新的提议

源代码是开源的——我希望每个人都受益，如果有改进，我会接受拉请求。

[## Raman SAH/upwork-秘书

在 GitHub 上创建一个帐户，为 upwork-secretary 的发展做出贡献。

github.com](https://github.com/ramansah/upwork-secretary)

我作为数据科学家的愿景和使命

原文：https://towardsdatascience.com/my-vision-and-mission-as-a-data-scientist-670d2406639?source=collection_archive---------7-----------------------

我教会的一位年轻弟兄组织了一个使用 SPSS 进行数据分析的能力建设班。因为我总是故意不去上他的课，所以他鼓励我去参加，哪怕只是一次。我最后参加的唯一一堂课激发了我的好奇心。“数据分析到底是什么？”。为了解决我好奇的想法，我在谷歌上跳转，直到我发现自己在
Quora(一个问&智能问题并由智能头脑回答的平台)上。我对
数据分析所能提供的不满意，因为我想要更多。幸运的是，我偶然发现了数据科学，并且一见钟情。从那时到现在，对我来说，
数据科学家被认为是 21 世纪开创性的工作之一。哇，我开始下载大量资料，并在
youtube 上观看视频，以了解它是什么。

Prof J.Widom ShortCourse, University of Ibadan

在我自学期间，我被选中参加伊巴丹大学 J.Widom 教授(加州斯坦福大学工程学院院长)主持的为期 5 天的大数据和机器学习领域的短期课程。那年年底，我也进入了尼日利亚第二届数据科学训练营的最终名单。在那里，我们接受了来自美国、加拿大、南非甚至尼日利亚的专业数据科学家的辅导和指导。这的确是一次改变人生的经历。

Data Science Bootcamp, Lagos

作为回报，我不仅要提高自己的技能，还要尽我所能帮助更多的人进入这个光荣的领域。为了实现我的目标，我组建了一个团队，目标是从 meetup 培训开始，在学校建立一个数据科学社区。在发布注册表格的 3 天内，仅 25 个位置就收到了超过 55 份申请(这是我们场地可以方便容纳的参与者数量，感谢 @CmapIT )。该团队筛选出了 25 名成功申请者，他们的回答都是有目的的。
聚会是一个通宵会议，因为大多数学生白天都会很忙，结果令人惊讶。我们进行了两次
现场介绍性会谈( @idowu_adelek 和 @iamopetunde )，我参加了一个端到端机器
学习项目的实践会议( Daniel Ajisafe )。他们理解新概念的速度和步伐是惊人的。我不能要求更多了。

我们的愿景是培养该国下一代年轻的数据从业者，并将
机器学习的可能性传播给尽可能多的人。LAUTECH 的第一次，尼日利亚所有大学的第一次学生数据科学/机器
学习聚会。这只是开始…………@ lautechDataSci

加速您数据科学学习的双重方法

原文：https://towardsdatascience.com/my-way-of-learning-mathematics-for-data-science-407a5a7f2f4a?source=collection_archive---------8-----------------------

介绍

所以，这篇文章是关于通过我在过去几个月里开发的方法/技术来学习数学。我称之为双折法。数学不仅是数据科学的重要组成部分，也是模拟现实世界问题的重要组成部分。我开始学习是因为我无法理解几乎每本关于数据科学的书籍或文章中出现的任何概率分布、统计概念、微积分符号和矩阵。截至 2018 年 11 月，我已经开始理解和舒适地使用数据科学书籍、帖子、文章和期刊，无论它们包含什么水平的数学。是的，就连深度神经网络的数学也不再让我害怕。我想是时候分享我的学习方法了。我之前写过关于我的数据科学之旅。

Source: Wikipedia

背景

在我继续讲下去之前，我想重申几件已经确立了我的学习和工作方式的事情。每当我想学习新的东西时，我总是想先学习基础知识，然后在基础知识上再有所发展。死记硬背或忽略某些基本概念和想法是没有意义的，因为这不仅会导致沮丧，而且会浪费大量时间学习，然后因为忽略了基础知识而重新学习 100 遍同样的东西。这是我个人的学习方式，然后是专业方式，受商业方式和生活实用性的影响。从专业角度来说(以前是软件开发，现在是数据科学)，如果我需要学习一些非常新的主题/子主题/概念，我会快速浏览并阅读一些基础知识，然后找到正确和既定的方法来应用这些概念解决问题。Aim 更多的是应用方面的东西。

世界正在高速发展，技术已经震撼了世界，随着这一第四次工业革命已经到来。它模糊了你的职业(工作)和生意之间的界限。现在你可能会问，什么是第四次工业革命。根据维基百科，第四次工业革命也称为工业 4.0 包括这些想法:

智能制造
智能工厂
熄灯制造(全自动工厂，不需要人在现场)
工业物联网(制造业物联网)

Image by Christoph Roser at http://AllAboutLean.com

本质上，在智能工厂中，信息物理系统监控物理过程，创建物理世界的虚拟副本，并做出分散的决策。通过物联网，信息-物理系统在内部以及由价值链的参与者提供和使用的组织服务之间实时地相互通信和合作

这对你的职业生涯有什么影响？你必须尽快给出结果，否则不仅会让你丢掉工作，还会给你的雇主带来巨大的损失，如果你不明白这一点，如果你继续忽视这一点，那么从长远来看，你也会失去你的职业生涯。

职业需求

实际上，一个交付的问题解决方案比一个花费 10 倍时间的伟大解决方案更好，也比一个花费一年时间的完美解决方案更好，更有益。以领域为例，它在数据科学中的重要性已经确立。数据科学和领域专业知识密切相关。现在，如果你是一名数据科学家，从来没有学过生物学，但你的雇主有一个客户，主要是一家从事生物学的公司，那么，你要么让它成为一次痛苦的经历，要么成为一次快乐的经历，你必须学会这两种方式。在你认为我在瞎编之前，先看看计算生物学。没有生物学背景，你可以从零开始学习几种方法:

买一本厚重的生物学基础/入门书，需要几个月的时间来完成
参加为期 6 周多的生物学和数据科学 MOOCs
学习第四次工业革命的方式

前两个选项需要 1-2 个月或更长时间(理想情况下是 4 个月)才能开始你的项目工作，而你的雇主却因为你什么都没做而付给你钱。这既不公平又愚蠢，对你的雇主不公平，对你也愚蠢，因为你可以更有效地利用时间。你需要学会区分雇主的直接需求和你生产优秀产品的需求。

Source: Wikipedia

第四次工业革命的方式说你可以在一两周内完成，你不需要马上花两个月。将你的关注点从生物学缩小到你客户的当前需求，学习基本的术语和足够的基础知识，以便开始用 Python 和库来处理生物学中的问题(例如 PySB 和 Biopython )。如果你想完成有期限的工作，这就是你的态度。即使没有最后期限，我还是会说你走第四次工业革命的道路，因为这不仅会帮助你更快地解决问题，还会让你免于陷入“我学得不够多”的恶性循环。这并不意味着，你创造了一个糟糕的解决方案，因为你不是你学校的生物学生。如果你这样做，那么你解决问题的方法就不系统，这意味着你需要学习很多关于生产力、效率和情商的知识。这也意味着，你无法提供一个真正好的解决方案，这种能力已经超越了你的工作，延伸到了你的个人、财务和职业生活的另一个层面，你需要非常认真地对待这个问题，并立即开始着手解决自己的问题。你的日常常规思维需要改变。你可以看看吉米·罗恩教你如何掌控自己的人生

https://youtu.be/DGIjuVbGP_A

数学

你可能认为这一切都与数据科学的数学无关。确实如此。数学是一种对世界建模的方法，它是一种在问题中发现模式并使用经过试验和测试的模型来解决它们的方法。这既是一门艺术也是一门科学。数学给了我们解决问题的工具，比我们想象的要快得多，在事情失去控制之前处理混乱也是惊人的准确。这如何适用于我们的情况呢？我一会儿会谈到这一点。

我完成了代数和微积分的学习，参加了几门 MOOCs 课程，阅读了大量自学材料，包括书籍、文章和博客。我现在开始学习概率。概率、统计和线性代数是与数据科学重叠的数学领域。我观察到的是，就像代数和微积分一样，这些主题非常广泛，你可以花将近一年的时间来学习它们的基础知识。那我们该怎么办？我们变得聪明而实际。

双重方法

第一重: 使用第四次工业革命我上面描述的解决问题的方式，这意味着我记得我的主要工作是数据分析和机器学习，我的目标是获得数据科学所必需的基础数学，这样我就不会盯着空白或看数学术语和公式时精神崩溃，每当我在数据分析和机器学习文章、博客和库文档中遇到数学时，我都知道基本的公理和理论基础。如果我遇到我不知道的东西，我就能弄清楚，因为我掌握了基本原理。

**第二重 😗* 终身学习数学，这与第一重相反，每当我有空的时候，我会打开一本书，看几个自定进度 MOOC 的视频(我不再订阅非数据科学工作的基于时间的 MOOC)或解决一些数学问题( Schaum 的系列非常有名，如果你知道什么更好的，请告诉我)。从更广泛的意义上来说，我把数学作为我的爱好，而不是在 YouTube 上看视频。像数学家一样思考问题，花尽可能多的时间找出答案。我从约翰·艾伦·保罗斯的《数学盲及其后果》开始了这段旅程。从狭义上来说，看一个数学公式并找出它被创造的原因，阅读它的历史，它被应用在哪些领域，它的应用范围以及它从一个领域到另一个领域的演变，尽可能详细地阅读它，或者阅读不同数学家和书籍中的一个概念的简介，如果你有编程背景，可以阅读埃文·米勒的数学黑客。另一篇关于如何正确学习数学的非常好的文章是史蒂夫·耶格写的。如果你只做第一次，那么你的数学知识将会很少，几年后，当你决定用什么模型来解决什么问题时，你将没有足够的信息。如果你只是做第二遍，那么你将永远没有足够的时间来完成任何事情。你必须混合使用这两种方法，这就是为什么我称之为双重方法。事实上，它不仅适用于数学，也适用于几乎任何一种学习。如果你知道任何更好的学习数学的方法，我将非常乐意知道。

灵感

由于我的概率、统计和线性代数知识几乎为零，最近我从普渡大学开始了 one，它也有它的第二部分。最后一件事，我上过的最好的 MOOC 是在 Coursera 学习如何学习。是的，这与数学或数据科学无关，但这就是生活，你在任何领域/学科的技能和成就很大程度上取决于你的个人思维，但这完全是另一回事，在另一篇博客文章中讨论。终身学习，无论遇到多大的挫折都不要放弃。

最初发表于我的博客。

我作为数据科学家的弱点

原文：https://towardsdatascience.com/my-weaknesses-as-a-data-scientist-1310dab9f566?source=collection_archive---------2-----------------------

(Source)

不认识到我们的弱点，我们将永远无法克服它们

如果现代求职面试教会了我们什么，那就是“你最大的缺点是什么？”这个问题的正确答案就是“我工作太辛苦了。”显然，实际上谈论我们的弱点是可笑的，对吗？为什么我们要提到我们还不能做的事情？虽然工作申请和 LinkedIn 个人资料页面并不鼓励我们披露自己的弱点，如果我们从不承认自己的不足，那么我们就无法采取措施来解决它们。

努力变得更好的方法很简单:

确定你现在的位置:找出弱点
弄清楚你想去哪里:制定一个到达那里的计划
执行计划:一次做一件小事

我们很少走过第一步:特别是在技术领域，我们低着头继续工作，使用我们已经拥有的技能，而不是获得新的技能，使我们的工作更容易或为我们打开新的机会。自我反省——客观地评价自己——可能看起来像一个陌生的概念，但是能够后退一步，找出我们可以做得更好或更有效的地方，对于任何领域的进步都是至关重要的。

考虑到这一点，我试图客观地审视我现在的状况，并确定了 3 个方面来使我成为更好的数据科学家:

软件工程
缩放数据科学
深度学习

我写这篇关于我在数据科学方面的弱点的文章有三个目的。首先，我真的关心变得更好，所以我需要承认我的弱点。通过概述我的不足以及如何解决它们，我的目标是让我自己有动力去完成我的学习目标。

其次，我希望鼓励其他人思考他们可能不知道的技能，以及他们如何努力获得这些技能。你不必写自己的文章来披露你所不知道的，但是花一些时间来考虑这个问题会有回报的，如果你发现了一项需要努力的技能的话。

最后，我想告诉大家，要成为一名成功的数据科学家，你不需要知道所有的事情。数据科学/机器学习主题的数量几乎是无限的，但你实际上可以知道的数量是有限的。不管不切实际的工作申请宣称什么，你不需要完全了解每种算法(或 5-10 年的经验)就能成为一名实践数据科学家。我经常听到初学者被他们认为必须学习的大量主题所淹没，我的建议总是相同的:从基础开始，明白你不需要知道所有！

Even this is probably an exaggeration! (Source)

对于每一个缺点，我都列出了问题和我目前正在努力做的事情。发现自己的弱点很重要，但制定解决它们的计划也很重要。学习一项新技能需要时间，但是计划一系列小而具体的步骤会大大增加你成功的机会。

1.软件工程

在学术环境中获得了第一次真正的数据科学经验后，我试图避免染上一些反映数据科学学术方式的坏习惯。其中有编写只运行一次的代码的倾向，缺乏文档，没有一致风格的代码难以阅读，**硬编码 具体值。所有这些实践都反映了一个主要目标:开发一个数据科学解决方案，该方案只对特定数据集有效，以便撰写论文。

作为一个典型的例子，我们的项目处理最初以 15 分钟为间隔的建筑能源数据。当我们开始以 5 分钟为增量获取数据时，我们发现我们的管道完全崩溃了，因为有数百个地方的间隔被明确编码为 15 分钟。我们无法进行简单的查找和替换，因为该参数被多个名称引用，如electricity_interval、timeBetweenMeasurements或dataFreq。没有一个研究人员想过让代码易于阅读或灵活地改变输入*。*

相比之下，从软件工程的角度来看，代码必须用许多不同的输入进行广泛的测试，有良好的文档记录，在现有的框架内工作，并遵守编码标准，以便其他开发人员能够理解。尽管我的初衷是好的，但我仍然偶尔像数据科学家而不是软件工程师一样编写代码。我开始认为，将普通数据科学家与伟大的数据科学家区分开来的是使用软件工程最佳实践编写代码——如果你的模型不健壮或不适合某个架构，它就不会被部署——现在我正试图训练自己像计算机科学家一样思考。

我在做什么

像往常一样，没有比实践更好的学习技能的方法了。幸运的是，在我目前的工作中，我能够为我们的内部工具和开源库做出贡献。这迫使我学习了许多实践，包括:

编写单元测试
遵循编码风格指南
编写接受变化参数的函数
彻底记录代码
让他人审查代码
重构代码使其更简单易读

即使对于那些还没有进入公司的数据科学家来说，你也可以通过参与合作性的开源项目来获得这方面的经验。找出可靠编码实践的另一个好方法是通读 GitHub 上流行库的源代码( Scikit-Learn 是我的最爱之一)。获得他人的反馈至关重要，所以找一个社区，向那些比你更有经验的人寻求建议。

像软件工程师一样思考需要思维方式的改变，但是如果你能够放慢速度并记住它们，采用这些实践并不困难。例如，每当我发现自己在 Jupyter 笔记本上复制和粘贴代码并更改一些值时，我会尝试停下来，并意识到使用一个从长远来看会使我更高效的函数会更好。虽然我在这些实践上并不完美，但我发现它们不仅让其他人更容易阅读我的代码，也让我更容易构建我的工作。代码被阅读的次数将会比它被编写的次数多，这包括你未来的自己，他会欣赏文档和一致的风格。

当我不编写被设计为更大的库的一部分的代码时，我仍然尝试使用这些方法中的一些。对于数据科学家来说，为数据分析编写单元测试可能看起来很奇怪，但是当您实际需要开发测试来确保代码按预期工作时，这是一个很好的实践。此外，有许多林挺工具检查你的代码是否遵循一种编码风格(我仍然纠结于关键字参数周围没有空格)。

Always things to improve (using pylint in Sublime Text 3).

我还想在计算机科学的许多其他方面努力，比如编写高效的实现而不是暴力方法(比如使用矢量化而不是循环)。然而，同样重要的是要意识到你不能一下子改变所有的事情，这就是为什么我专注于一些实践，并把它们习惯融入我的工作流程。

虽然数据科学现在是它自己的领域，但从业者可以通过采用现有领域(如软件工程)的最佳实践而受益。

2.扩展数据科学

虽然你可以自学数据科学中的所有知识，但你可以付诸实践的东西是有一些限制的。一个是难以将分析或预测模型扩展到大型数据集。我们大多数人都没有机会接触到计算集群，也不想花钱购买个人超级计算机。这意味着，当我们学习新方法时，我们倾向于将它们应用于小型的、性能良好的数据集。

不幸的是，在现实世界中，数据集并不遵循严格的大小或清洁度限制，您将需要不同的方法来解决问题。首先，你可能需要打破个人电脑的安全限制，使用一个远程实例——比如通过AWS EC2——甚至多台机器。这意味着学习如何连接到远程机器和掌握命令行——你将无法在 EC2 实例上使用鼠标和 gui。

在学习数据科学时，我尝试在 EC2 机器上工作，要么使用免费层，要么使用免费配额(如果您管理所有的电子邮件和密码，您可以创建多个帐户)。这有助于我熟悉命令行，但是，我仍然没有解决第二个问题:大于机器内存的数据集。最近，我意识到这是一个阻碍我前进的限制，是时候学习如何处理更大的数据集了。

我在做什么

即使没有在计算资源上花费数千美元，也有可能实践处理不适合内存的数据集的方法。其中一些包括一次遍历一个数据集的一个块，将一个大数据集分成许多小块，或者使用 Dask 等工具为您处理大数据的细节。

我目前的方法，无论是在内部项目上还是在开源数据集上，都是将数据集划分为子集，开发一个可以处理一个分区的管道，然后使用 Dask 或 Spark 和 PySpark 通过管道并行运行子集。这种方法不需要超级计算机或集群，您可以使用多个内核在个人计算机上并行化操作。然后，当您可以访问更多资源时，您可以调整相同的工作流以进行扩展。

此外，感谢 Kaggle 等数据仓库，我已经能够找到一些非常大的数据集，通读其他数据科学家的方法来处理它们。我收集了一些有用的技巧，比如通过改变数据帧中的数据类型来减少内存消耗。这些方法有助于我更有效地处理任何规模的数据集。

虽然我还没有处理大规模的 TB 级数据集，但是这些方法已经帮助我学会了处理大数据的基本策略。对于最近的一些项目，我能够应用到目前为止我所学到的技能来对运行在 AWS 上的集群进行分析。在接下来的几个月里，我希望逐渐增加我能轻松分析的数据集的大小。很有可能数据集的大小不会减少，我知道我需要继续提高处理大量数据的技能。

The US Library of Congress “only” has about 3 Petabytes of material. (Image source)

3.深度学习

虽然人工智能在过去经历了繁荣和萧条的时期，但最近在计算机视觉、自然语言处理和深度强化学习等领域的成功让我相信，深度学习——使用多层神经网络——并不是又一个短暂的时尚。

与软件工程或扩展数据科学不同，我目前的职位不需要任何深度学习:传统的机器学习技术(例如 Random Forest )已经能够解决我们客户的所有问题。然而，我认识到，并不是每个数据集都是整齐的行列结构，神经网络是(目前)处理文本或图像项目的最佳选择。我可以继续利用我目前的技能解决我已经解决的问题，但是，尤其是在我职业生涯的早期，探索话题是一项具有巨大潜在价值的工作。

The Explore/Exploit Tradeoff applies to reinforcement learning and your life! (Source)

深度学习中有许多不同的子领域，很难找出哪些方法或库最终会胜出。尽管如此，我认为对该领域的熟悉和对实现一些技术的信心将允许一个人处理更广泛的问题。鉴于解决问题是驱使我从事数据科学的原因，将深度学习的工具添加到我的工具箱中是一项值得的投资。

我在做什么

我研究深度学习的计划与我将自己转变为数据科学家的方法相同:

阅读强调实现的书籍和教程
在实际项目中练习这些技术和方法
通过写作分享和解释我的项目

当研究一个技术课题时，一个有效的方法是边做边学。对我来说，这意味着不是从潜在的基本理论开始，而是通过找出如何实现解决问题的方法。这种自上而下的方法意味着我非常看重那些有动手风格的书，也就是那些有很多代码示例的书。在我看到技术是如何工作的之后，我会回到理论上来，这样我就可以更有效地使用这些方法。

虽然我可能是独自一人，因为我没有机会在工作中从其他人那里学习神经网络，但在数据科学中，由于丰富的资源和广泛的社区，你永远不会真正依靠自己。对于深度学习，我主要依靠三本书:

深度学习食谱作者 Douwe Osinga
用 Python 进行深度学习Francois Chollet
伊恩·古德菲勒、约舒阿·本吉奥和亚伦·库维尔的《深度学习》

前两者强调用神经网络构建实际的解决方案，而第三个则深入讨论理论。当阅读关于技术主题的内容时，让它成为一种积极的体验:只要有可能，把你的手放在键盘编码和你所阅读的内容上。像前两本书这样提供代码示例的书非常棒:我通常会在 Jupyter 笔记本上一行一行地输入一个示例，以弄清楚它是如何工作的，并在进行过程中写下详细的笔记。

此外，我不仅尝试复制代码示例，还尝试对它们进行实验，或者使它们适应我自己的项目。这方面的一个应用是我最近与合作建立一个图书推荐系统，这个项目改编自深度学习食谱中的一个类似代码练习。试图从头开始自己的项目可能会令人生畏，而且，当你需要激励时，在别人已经做的基础上进行建设也没什么错。

最后，学习一个话题的最有效的方法之一是把它教给别人*。根据经验，我不会完全理解一个概念，直到我试图用简单的术语向别人解释它。对于我在深度学习中涉及的每个新主题，我将继续写作，分享技术实现细节以及概念解释。*

教学是最好的学习方式之一，我计划让它成为我研究深度学习的一个组成部分。

From personal experience, this looks accurate (Source)

结论

宣扬你的弱点可能感觉有点奇怪。我知道写这篇文章让我不舒服，但我把它放出来，因为它最终会让我成为一名更好的数据科学家。此外，我发现，如果你有自知之明，承认自己的缺点，并讨论如何解决这些问题，那么包括雇主在内的许多人都会对你印象深刻。

缺乏技能并不是缺点——真正的缺点是假装你什么都知道，并且不需要变得更好。

通过确定我的数据科学弱点(软件工程、扩展分析/建模、深度学习)，我旨在提高自己，鼓励他人思考他们的弱点，并表明要成为一名成功的数据科学家，你不需要学习所有东西。虽然反思自己的弱点可能是痛苦的，但学习是令人愉快的:最有收获的经历之一是在持续学习一段时间后回顾过去，并意识到自己比开始学习前知道的更多。

一如既往，我欢迎反馈和建设性的批评。可以通过推特 @koehrsen_will 或者通过我的个人网站 willk.online 找到我。

我妻子睡不着

原文：https://towardsdatascience.com/my-wife-couldnt-sleep-550e206cd80a?source=collection_archive---------0-----------------------

她没有忽视瘙痒，你也不应该忽视

她又痒又累。她也怀了 29 周我们的第二个孩子。当然不是一场独特的斗争。不舒服和精疲力尽几乎是妊娠晚期的定义。

但是伊芙知道有些事情不对劲。当瘙痒开始时，睡觉让位于夜间抓痒——和谷歌搜索。起初，她在网上找到的东西令人放心——怀孕确实会因为皮肤血流量增加而让你发痒——但她的瘙痒似乎有所不同。更加强烈和广泛。然后她读到了一种相对罕见的肝脏疾病，这种疾病会导致怀孕期间的严重瘙痒*。这种疾病与婴儿的一些非常糟糕的结果有关，所以伊芙决定问问她的产科医生。医生认为这是很严重的可能性很小，但为了安全起见，她还是安排了检查。*

肝功能结果最先出来，因为样本是在本地进行的。该国只有少数实验室评估胆汁酸水平，因此 Eve 的样本必须运出，这一过程需要 3 到 7 天。作为对我们耐心的回报，我们被告知她的数据看起来不错。似乎没什么可担心的。

又过了两周。为了工作，我去了肯尼亚和利比里亚。伊芙去 DC 参加一个会议。她的痒尾随而来，并分享一个房间。但是在那些深夜的狂欢中，她无法摆脱出问题的感觉。

她重复了这些测试，并于 6 月 8 日(第 31 周)收到了她的诊断结果: 妊娠期肝内胆汁淤积症 ，或 ICP。

什么是 ICP？

肝脏(希腊文 hepato )是一个相当整洁的器官。当你在五人餐厅狼吞虎咽地吃下一个汉堡时，你的肝脏会产生胆汁来分解脂肪。由于尚未完全了解的原因，ICP 中断了这一过程，并在血液中产生胆汁酸堆积()。如果不加以控制，ICP 会增加死胎和出生时呼吸问题的风险。血液中过量的胆汁酸是导致这些问题的原因，还是仅仅是一些其他疾病过程的标志还不清楚。**

ICP 的唯一“治疗”是分娩；大多数女性在不再怀孕时，肝功能会恢复正常。怀孕期间的“管理”ICP 通常涉及规划早期分娩和使用药物熊去氧胆酸(又名 UDCA、熊去氧胆酸、Actigall)，这可能会缓解瘙痒并减少血液中有毒胆汁酸的量。血清胆汁酸水平大于 10 mol/L 标志着 ICP 的发作，40 mol/L 是“重度”ICP 的阈值。

研究最佳交货周

当伊芙的结果显示是颅内压增高时，我们试图尽可能地了解病情。我于 6 月 9 日登陆 ICP 关爱网站，那天正好是 ICP 宣传日的前一天。以下是引起我注意的事情:

**如果不积极处理，妊娠期肝内胆汁淤积症期间死产的风险可高达 15%。然而，通过积极的管理，包括药物熊去氧胆酸和早期分娩(通常在妊娠 36-37 周)，风险被认为与无并发症妊娠大致相同，即低于 1%。**导致死胎的机制尚未完全了解，也不可能预测哪些妊娠存在风险。虽然研究发现较高的胆汁酸水平似乎会带来较高的某些并发症风险，如呼吸窘迫和胎儿窘迫，但研究未能确定死产的相同关系。因此，所有 ICP 妊娠都建议提前分娩。

我们相信死产的总体风险应该很低，因为伊芙正在接受 UDCA 的“积极管理”,并初步计划在 37 周分娩，但两个问题促使我们开始深入研究:

37 周是分娩的最佳时间吗？
Eve 诊断时的胆汁酸水平是 25 mol/L，如果开始升高怎么办？有没有一个门槛可以促使我们更早地交付产品？

按周来看死胎的风险是什么样的？

就 ICP 而言，分娩的“最佳时机”是做某事的风险小于什么都不做的风险的点(T21)。等太久才生，就有死胎的风险。行动太快，你就有婴儿死亡或活产并发症的风险。

这应该让你对我们的风险计算有所了解，我们通过寻找按周估计死产风险的研究开始了我们的研究之旅。我们发现的关于死胎率的最大研究是加利福尼亚州 160 万妊娠妇女的回顾性队列研究。

在一项队列研究中，研究人员找出符合特定标准的人，并跟踪他们一段时间，看看谁产生了感兴趣的结果。在这项特殊的研究中， 普尔吉奇和他的同事们 根据妇女的暴露程度——ICP 或无 ICP——从生命统计登记中选择妇女，并提取关于产妇、胎儿和婴儿结局的相关数据。这被认为是回顾性(或非同期或历史性*)队列设计，因为在作者开始他们的研究时，怀孕和结果已经发生。***

在他们 160 万例妊娠的数据集中，研究人员发现了 5545 例 ICP，发病率为 0.35%。这比其他研究发现的要低，这意味着有可能某些比例的实际 ICP 妊娠没有被正确编码。或者其他研究高估了 ICP 的发病率，而这项研究是正确的。很难知道。

作者以表格形式展示了一些结果，我认为用数字来表示更好，所以我尝试了一些图表(代码在这里是)。下图显示了患有和未患有 ICP 的妇女每周的死产风险。它表明，与没有 ICP 的妇女相比，患有 ICP 的妇女每周的死产风险更高，但 ICP 组的每周数字如此之小，以至于估计值非常不确定(黄色带是 ICP 的 95%置信区间，它包括所有非常精确估计的紫色对照值)。最明显的发现是患有 ICP 的妇女在期末死产的风险显著增加。根据定义，这些案例没有得到提前分娩的完全“管理”,因为它们没有在 38 周之前分娩，但是我们从数据中不知道服用 UDCA 的百分比。

Data for this plot come from Table 2 in Puljic et al. (2015). The risk of infant and fetal death by each additional week of expectant management in intrahepatic cholestasis of pregnancy by gestational age. American Journal of Obstetrics and Gynecology, 212(5), 667-e1. Plot code here.

另一方面呢——过早交付的风险？

由普尔吉奇和他的同事进行的回顾性队列研究也提供了关于早产风险的部分数据。在患有 ICP 的女性群体中，作者计算了与分娩相关的婴儿死亡的每周风险——也就是做一些事情——并将其与他们所谓的期待治疗——也就是等待和不做任何事情——的复合死亡风险进行比较。复合风险是给定一周内死产的综合风险加上下一周分娩时婴儿死亡的风险。换句话说，他们比较了在给定的一周内分娩的风险和多等一周的风险。

这是我试图绘制他们的数据。作者在论文中也画了点估计，但没有画不确定性，我认为我们需要看到这两个元素。这两条线在第 36 周交叉，表明这可能是最佳点，此时行动的风险低于等待的风险。

Data for this plot come from Table 3in Puljic et al. (2015). The risk of infant and fetal death by each additional week of expectant management in intrahepatic cholestasis of pregnancy by gestational age. American Journal of Obstetrics and Gynecology, 212(5), 667-e1. Plot code here.

***当然，这份风险档案中遗漏了围产期发病率——母亲和婴儿的不良后果，导致死亡。*这可能包括脑瘫和呼吸窘迫综合征等情况，这些情况更有可能是早产的结果。如果不考虑发病率，就不可能对早期分娩的风险进行真正的评估。

Lo 和他的同事 用他们的决策分析模型在这方面帮了我们。在这项研究中，作者模拟了一个假设的 10，000 名 ICP 妇女队列的结果，基于(a)产妇和新生儿的预期寿命，(b)文献中发现的几种不良结果的产妇和新生儿效用值，以及(c)四种不同分娩策略的新生儿和产妇发病率、ICP 死产和 35-38 周新生儿死亡的公布概率:

服用类固醇(促进肺部发育)后 48 小时分娩，无需羊膜穿刺术
使用类固醇后 48 小时分娩，羊膜穿刺术
羊膜穿刺术和复检，没有类固醇
立即分娩(无羊膜穿刺术，无类固醇)

Data for this plot come from Lo et al. (2015). Intrahepatic cholestasis of pregnancy and timing of delivery. Journal of Maternal-Fetal & Neonatal Medicine, 28(18), 2254–2258. Plot code here. This plot shows additional QALYs relative to the minimum QALY value, which is delivery at 38 weeks following amniocentesis and steroids. This minimum value is set to 0 in the figure.

主要结果是总的 质量调整生命年 ，或质量生命年。一年的健康相当于 1 QALY，所以人均预期生活质量越好。这里显示了模拟的主要结果。与所有其他策略相比，在 36 周立即分娩而不使用羊膜穿刺术或类固醇似乎能最大限度地提高质量生活质量。

作者总结道:

当考虑权衡因素时，虽然与妊娠 37 周或更晚分娩相比，36 周分娩的新生儿发病率更高，但[死产]的风险降低。

以下图表显示了 QALY 计算和这一结论背后的趋势。像脑瘫和呼吸窘迫综合征的风险在 37 周前最高，但这被 37 周和 38 周死产风险的增加所抵消。

Data for this plot come from Lo et al. (2015). Intrahepatic cholestasis of pregnancy and timing of delivery. Journal of Maternal-Fetal & Neonatal Medicine, 28(18), 2254–2258. Plot code here. These plots show the patterns of risk for three specific outcomes according to the model: the risks of cerebral palsy and respiratory distress syndrome decrease as babies mature in the womb, while the risk of stillbirth among women with ICP increases every week.

虽然不是绝对的，但这两项研究使我们倾向于在 36 周而不是计划的 37 周分娩。当 Eve 的下一次胆汁酸测试在接下来的一周回到 85 mol/L 时，我们进一步确信了这一点。

当我们得到这个结果时，我正在阅读一篇新发表的 2018 年 ICP 护理综述，该综述由杜克大学产科/GYN 部门母体胎儿医学部门的 Elizabeth Livingston 博士和她的同事发表。在这篇评论中， 利文斯顿和他的同事 写道:

考虑到 ICP 患者死产风险增加，通常建议在妊娠 37 周时进行引产，以平衡医源性早产风险和胎儿死亡风险。当胆汁酸水平达到 100 μmol/L 或更高时，死产的风险显著增加，在这些情况下，可考虑在更早的孕龄分娩，如 35 至 37 周；然而，这些决定应该通过仔细的患者咨询来个体化。

伊芙是杜克卫生系统的一名病人，所以我们会见了利文斯顿医生，讨论我们的选择。考虑到伊芙的良好表现，利文斯顿对 36 周的分娩感到满意。但如果她的水平越过了 100 mol/L 大关呢？

胆汁酸水平和死胎有什么关系？

利文斯顿及其同事的论文回顾了关于这种关系的最新证据，并总结了胆汁酸可能导致死产的主要假设。一种观点认为过量的胆汁酸会收缩胎盘中的血管。这可能是为什么 ICP 中的死产似乎是导致缺氧和死亡的急性事件的结果，而不是胎儿健康的慢性恶化的一个原因。如果是这样，这有助于解释为什么胎儿监测 Eve 每周进行两次——不能降低 ICP 中死产的风险(但仍被推荐)。

目前，高胆汁酸水平可能是死产风险增加的最佳诊断指标，但这仍然是一个有争议的问题。一个关键的证据来自一项在英国进行的对患有严重 ICP 的女性的前瞻性队列研究，该研究于 2014 年发表在期刊*上。在这项研究中，队列由多达 669 名患有重度 ICP** (定义为妊娠期间任何时间胆汁酸水平≥ 40 mol/L)的妇女组成，感兴趣的结局是死产。***

以下是来自重度 ICP 队列的一些值得注意的发现:

这些妇女中的大多数接受了 UDCA 治疗(72%)，平均分娩时间为 37.5 周。因此，你可以说“主动管理”相当普遍，但肯定不是普遍的。
669 名妇女中有 10 名经历了死产，发生率为 1.5%。(在下图中用红色加号表示)
10 例死胎中有 6 例发生在前 37 周。
死产似乎聚集在胆汁酸水平高于 100 mol/L 的女性中。

Source: Geenes, V. et al. (2014). Association of severe intrahepatic cholestasis of pregnancy with adverse pregnancy outcomes: a prospective population‐based case‐control study. Hepatology, 59(4), 1482–1491. Figure 4(C). The estimated probability and 95% CIs of stillbirth in relation to the maternal serum bile acid level, based on simple logistic regression.

作者还观察了两组没有 ICP 的妇女的死产结果。重度 ICP 队列中死胎发生率为 1.5%，是非 ICP 对照组死胎发生率的 3 倍。

夏娃的轨迹

最终，伊芙的胆汁酸水平永远不会超过 100 摩尔/升。她的峰值是 85.6 mol/L，分娩前的最终检测结果是 38.4 mol/L

Plot code here.

我们的小痒来了

经过紧张的几个星期，安妮·格雷斯在 7 月 9 日，也就是夏娃的生日那天出生了。36 周零 1 天。我们感到无比幸运。如果你被诊断患有 ICP，现有的证据表明，你也有很大的机会获得良好的结果，特别是如果你的医生开了 UDCA，并将你的分娩时间安排在 36 周或 37 周(或者更早，如果考虑到你的情况有意义的话)。

Annie Grace

不幸的是，并不是每个人都这么幸运。在我们旅行的早期，我读了唐娜·贝纳维德斯的故事《T21》。她在 36 周时被诊断为 ICP，并计划在 38 周时引产。

我感到困惑和害怕，这是我第一次怀孕。我在网上阅读了更多关于妊娠胆汁淤积症的信息，并打印了一些信息与我丈夫讨论，因为我阅读的文章中的统计数据显示，ICP 导致婴儿流产的比例很小。在我的反应性(非压力测试)后的第二天——离被诱导只有两天——我们失去了儿子乔丹。

唐娜继续创立了 T2 ICP 护理中心，并帮助无数家庭理解这个可怕的诊断。现在，她告诉其他女性去止痒。

唐娜的医生不知道开 UDCA。虽然今天人们对 ICP 有了更好的理解，但仍经常会读到 ICP Care 的 发痒的妈妈们 脸书妇女团体的故事，这些妇女努力让她们的提供者检测 ICP 并认真对待她们的症状。

被授权接受测试。用这份博士讨论指南为你的预约做准备，并与你的提供者分享这些资源。

不要忽视痒。

[1] Eve 的第一次胆汁酸水平实际上为 11.5 mol/L，高于 Wood et al. (2018) 推荐的诊断 ICP 的临界值。她的结果被归类为“正常”，可能是因为杜克 MyChart 中 15 至 45 岁孕妇的参考范围是 3.7–14.5mol/l。

与 Simon Greiner 一起打破数据科学的神话

原文：https://towardsdatascience.com/myth-busting-about-data-science-with-simon-greiner-7a84c578d12d?source=collection_archive---------15-----------------------

Cesar Viteri on www.unsplash.com

在她的第一个博客中，安妮塔·拉克霍迪亚问了一个问题:一个数据科学家整天都在做什么？这是非数据科学家最常问她的问题。想想她在聚会、黑客马拉松或博客中亲自遇到的数据科学家，很难给出一个答案。

因此，她今天与我，西蒙·格雷纳，一位有抱负的数据科学家和经验丰富的 IT 顾问交谈，做一些真正的神话打破。我们想要打破的关于数据科学家的神话是，他们仍然阅读书籍，书籍仍然是灵感的伟大来源！

安妮塔:数据科学似乎是一门瞬息万变的科学。你是如何跟上时代的？你去哪里获取信息和与同龄人交流想法/思想？

Simon :首先， Medium 是一个非常棒的平台，有非常有趣的文章，也不同于其他博客，因为你会觉得你在阅读真实的内幕信息/观点，而且非常真实。不是通常的高层次的东西，而是数据科学家做什么和他们真正面临的问题。

二、书籍书籍书籍！起初，这听起来可能有些奇怪和过时，但一些最好的算法是在 70 年代和 80 年代创建的。当时，数据科学家没有足够的计算能力来实现/允许他们发挥全部潜力。

第三，论文有助于跟上数据科学特定领域的最新进展。第四，像“世界人工智能峰会”这样的同事和会议是灵感的来源，也是交流思想的平台。

如果有时间，我也会参加聚会。此外，Kaggle 比赛也是我的一大爱好。和大学的同事一起。Kaggle 比赛占用了很多时间，但这是值得的，因为它非常有趣。这是我的朋友约书亚·戈尔纳关于“媒介”的总结的链接，我们来到了前 2% 。

安妮塔:你认为自己是数据科学家吗？

西蒙:等我拿到硕士学位后，我会成为一名数据科学家。但我认为自己更像是商业和技术数据科学之间的桥梁。今天，许多人自称为数据科学家，因为这很流行，但他们实际上并不从事数据科学工作。

安妮塔:典型的数据科学家是做什么的？

西蒙:数据科学家处理大量数据。在数据科学家开始研究数据之前，通常会有一个业务案例的假设。然后是经典的数据准备、清理和分析。然后应用机器学习将数据转化为商业案例。但这实际上是团队的努力。

在开发模型和分析数据的统计学家和收集所有输入来为模型提供信息的数据科学家之间，对基础设施进行基准测试，然后构建实际的机器学习算法来应用这些数据。

安妮塔:那么数据科学家和统计学家之间有什么区别呢？

西蒙:数据科学家清理数据，分析数据，建立模型。但实际上这些工作是分开的。传统的统计学家只做数据清理、准备和运行模型。他们是没有 IT 背景的数学家。

我认为自己更全面:首先是统计分析；然后检查数据的可用性；清理数据，构建算法，并亲自展示研究结果。为了能够完成 E2E 过程，我去攻读我的硕士学位。

你必须基本上知道算法应该传递什么，以便为它提供正确的数据来学习。对于这一点，我的经济学背景真的很有用。由于我的商业知识，我能够更快、甚至更好地理解商业问题。但是也有人比我更擅长编程和编码。对来自客户的非结构化数据可能产生的结果有一个愿景，是数据科学家的实际任务。为此，我的经济学背景非常有用。

安妮塔:是什么让你决定攻读数据科学硕士学位？是什么引发了这个决定？

西蒙:我是我的硕士班里唯一没有 IT 背景的人。我必须参加额外的入学考试，才能获准攻读硕士学位。一开始真的很难，因为你从一开始就要深入编程和编码。但是我的商业背景会在现实世界中帮助我。因为要正确解释数据，领域知识是必需的。

我一直热爱统计学，并对借助技术人类可以预测非常复杂的结果这一想法着迷。此外，我一直对心理学和人类为什么会这样做感兴趣——数据科学为你提供了分析工具集，并在完全不同的层面和更大的规模上进行分析。

最后，我订购了一本关于数据科学用例的书，第一本是基于过去 3 个美式足球赛季的数据预测超级碗冠军…从那时起，我就 100%投入了。两周后，福布斯写道，数据科学将是 21 世纪的工作，所以这是一个非常好的选择。

安妮塔:在你看来，要让一名数据科学家成功并为未来做好准备，还需要哪些技能？有兴趣的人可以从哪里入手？

西蒙:我认为即使有硕士学位，你也必须不断跟上时代，因为这是一个快速变化的环境。如果你没有读硕士，但你对统计学真的很感兴趣，相信人类现在还没有达到巅峰，在技术的帮助下，我们可以完成比我们想象的更多的事情，你可以通过阅读现实世界问题的数据科学解决方案，用一点点努力做大事。此外，网上有很多很棒的课程，这是一个很好的开始，如果你已经精通编程，你可以用很小的努力获得很多。

安妮塔:“传统统计学家”和“新数据科学家”之间有差距吗？还是数据科学家是现代统计学家？他们能一起工作吗？

西蒙:数据科学是一项团队工作。你总是需要两个世界。要有一个成功的数据科学项目，你需要:开发人员、领域专家和统计学家。现代数据科学家有一点点以上的东西。但是仅仅是为了让你看到真相和验证，你仍然需要每个领域的专家。作为一名数据科学家，你可以在短时间内取得很大成就，有时这足以让一个项目取得成功。有时候这已经足够专业了。这就是 DS 吸引许多公司的原因。但是当然，我不想暗示所有的数据科学家都“只是”全能，因为有太多的人拥有不同的技能。所以没有一个是一样的。你所不具备的技能将由 DS 项目团队的其他成员来补充。

除了上面提到的，你还需要那些软件架构师，他们为分析提供基础设施。没有它们，如果数据量和计算量越来越大，你会很快陷入困境。

安妮塔:你在科学领域的专长是什么？你为什么选择这个领域？

西蒙:我对数据挖掘和统计分析以及更高级的机器学习感兴趣。

安妮塔:你最喜欢哪种编程语言？你知道哪个？

西蒙:皮顿！！我也懂 R 和一点 Java。

安妮塔:现在数据科学正在快速发展。比方说，在 5 到 10 年后，数据科学家的未来技能是什么？

Simon :数据科学家的未来是自动化机器学习。清理数据，让机器完成剩下的工作(特征工程、训练、模型拟合)。但是仍然需要数据科学家来解释分析的结果。因此，在这个过程的开始和结束阶段，都需要数据科学家。

数据科学家不再构建特征，而只是准备数据。汽车特征工程是未来。

在我看来，我们必须开始说服没有伴随着人工智能成长起来的一代管理者，AI 是正确的，是未来。如果我们做不到这一点，不了解全局的高级管理人员往往会阻碍进步。

安妮塔:你如何向家人解释数据科学家的工作？

西蒙:我告诉他们我试图根据大量的数据来预测事情。或者，我创造了学习算法，可以越来越好地预测事物。但大多数时候，我妈妈只是告诉人们我用电脑做一些事情

安妮塔:西蒙，非常感谢你的这些见解。如果你想和西蒙联系，在这里找到他的 LinkedIn 个人资料。https://www.linkedin.com/in/simonjuliangreiner/

我想给你看另一个我对米歇尔·霍斯的采访。打破关于 SAS 社区的神话。可在此查阅:https://www . LinkedIn . com/pulse/myth-busting-SAS-communities-Anita-lakhotia/

打破神话的梦幻英超联赛:形式胜于赛程

原文：https://towardsdatascience.com/mythbusting-fantasy-premier-league-form-over-fixtures-eecf9022e834?source=collection_archive---------19-----------------------

数据科学教程

使用足球数据和机器学习来测试在预测不失球、进球和助攻方面，形式是否比固定比赛更重要

Form vs fixtures discussions on Reddit

超过 600 万人参加了梦幻超级联赛(FPL) 的比赛，试图组建最好的 11 名球员阵容，以获得英格兰超级联赛 38 周以来的最高分。每个球员的得分由他们在实际比赛中的表现决定，守门员和后卫在没有失球的情况下完成一场比赛可以获得 4 分，进球得分者根据他们的位置，每个进球或助攻可以获得 3 到 6 分。为了最大限度地提高球队的得分，经理们必须做出明智的决定，选择最有可能保持零失球或每周进球的球员。

经理们经常讨论的两个流行指标是球员的状态和即将到来的比赛难度。根据状态选择球员意味着更喜欢在最近的比赛中得分好或者保持零失球的球员。然而，考虑比赛难度也很重要，因为一名球员在对阵较弱的对手时得分，可能不会在对阵更强的球队时得分。

在决定这两个指标时，我注意到经理们经常在梦幻英超社区上称赞“形式胜于固定”，但几乎没有发现在预测不失球或进攻得分(即助攻或进球)方面比较这两个指标的分析。彼得·布雷克已经分析了固定难度的影响，但它只考虑了固定难度，而没有考虑球员的状态。因此，为了测试形式是否确实比夹具更重要，我使用了 2016 年以来的 FPL 数据来比较他们在预测 FPL 不失球和进攻点方面的贡献。

Sample screen of Fantasy Premier League

1.查找数据并定义形状和夹具

我能够通过 FPL 的 API 收集到瓦斯塔夫阿南德过去两个赛季的数据。在获得过去两个赛季(2016-17 和 2017-18)的数据后，我将球员的“状态”定义为他们前 6 周的平均表现，与 FPL 官方网站上的定义一致。比赛难度确定如下:前 2 名球队的比赛难度排名为 5，排名第 3 至第 6 的球队排名为 4，排名第 7 至第 12 的球队排名为 3，排名第 12 至第 20 的球队排名为 2。这并不完全是在官方 FPL 网站上定义的，该网站声称使用了“FPL 专家开发的复杂算法”，但看起来是足够接近的近似值。

Fixture Difficulty Ranking Chart

我将跳转到结果，但是所有用于分析的数据和代码都可以在这里获得，笔记本也嵌入在文章的底部。

2.估计夹具和模板对清洁板材的贡献

首先，我评估了夹具难度如何影响零失球的概率。在图 1 的左图中，我们可以看到对手的比赛难度降低了球队零失球的概率。大约 15%的球队在对阵比赛难度为 5 的球队时保持不失球(例如，上赛季的曼城和曼联)，而大约 30%的球队在对阵比赛难度为 2 的球队时保持不失球(例如，上赛季的西布罗姆维奇或斯托克城)。我们也看到了主场优势，当球队在主场比赛时，不失球的可能性更大。

Figure 1. Fixture difficulty on clean sheet probability. Left panel uses the opponent’s fixture difficulty. Right panel uses the difference between the playing team and the opponent team’s fixture difficulty ranking such that higher difference suggests that a high caliber team is playing a low caliber team. Error bars are 95% confidence intervals

此外，我们还可以考虑两队之间的比赛难度差异。例如，曼城很难排在第 5 位，这表明他们是一支困难的球队，但如果他们与一支类似的球队比赛，两者之间的差异可以更好地预测不失球的可能性。差值的计算方法是比赛队的比赛难度减去对手的比赛难度，因此数值越高表示优势越大。正如所料，我们可以从图 1 的右图中看到，当一个更强的球队对阵一个更弱的球队时，不失球的可能性更大。

现在，为了测试球员的形式或固定难度是否可以预测不失球，我们可以训练一个以形式和固定为特征的机器学习模型。通过标准化特征，我们可以比较一个特征是否比另一个特征更有助于预测干净的纸张。我在个人玩家身上训练了一个逻辑回归模型，反复进行 K 倍交叉验证。通过这种方式，我们还可以看到不同数据折叠的系数有多稳定。

Figure 2. Form vs fixture on clean sheets. Left panel shows average coefficient weights of fixture difficulty difference and form in predicting clean sheets. Middle panel shows average accuracy in predicting clean sheets which was 58%. Right panel shows the confusion matrix in accurately predicting clean sheets (coded as 1). Error bars are 95% confidence intervals

在这个分析中，我只包括了在比赛中打了 60 分钟以上的后卫和守门员，因为他们是那些如果不失球就会获得零失球分数的人。图 2 的左图清楚地显示了两队之间的比赛难度差异是比球员状态更强的不失球预测因素。虽然该模型的准确性不高，只有 58%,但我们仍然可以得出这样的结论:当选择那些在不失球的情况下获得大部分分数的守门员和后卫时，经理们应该考虑的是固定而不是形式。

对于守门员和后卫来说，在预测不失球方面，比赛比球员的状态更重要

3.估计固定物和形态对攻击点的贡献

比赛中的进球也会受到比赛难度的影响。在球队层面，我们可以从图 3 左图中看到，与实力更强的球队比赛(即比赛难度为 5)比与更轻松的对手比赛(比赛难度为 2)进球略少。从图 3 的右图中，我们还可以推断出，当排名靠前的球队与排名垫底的球队比赛时，我们可以看到大约两个进球，但在大多数其他比赛中，我们可以看到大约一个进球。

Figure 3. Fixture difficulty on attacking expected goals. Left panel uses the opponent’s fixture difficulty. Right panel uses the difference between the playing team and the opponent team’s fixture difficulty ranking such that higher difference suggests that a high ranked team is playing a lower rank team. Error bars are 95% confidence intervals

然而在 FPL，球员不仅因为进球得分，还因为助攻得分。因此，我决定使用进攻得分作为因变量，进攻得分定义为比赛中的进球或助攻。类似于零失球分析，我只包括了在比赛中出场超过 60 分钟的中场和前锋，因为他们需要获得进攻分。现在，我们再次运行逻辑回归模型来预测球员状态和设备难度差异的攻击点。

Figure 4. Form vs fixture on attacking points. Left panel shows average coefficient weights on fixture difficulty difference and form. Middle panel shows average accuracy in predicting clean sheets which was 62%. Right panel shows the confusion matrix in accurately predicting attacking points (coded as True). Error bars are 95% confidence intervals

在这里，我们发现形式和比赛的差异都有助于球员进球或助攻的概率，但形式比比赛更重要(图 4 的左图)。预测准确度为 62%,并且它比获得攻击点(灵敏度；图 4 右侧面板中的混淆矩阵)。由此我们可以得出结论，主教练应该考虑中场和前锋的状态而不是赛程。

在预测进攻点时，球员的状态比中场和前锋的固定位置更重要。

我们学到了什么

在这里，我们验证了在 FPL 流行的神话，球员的状态比比赛更重要。事实证明，至少对防守者来说，固定比赛比形式更重要。他们更有可能在与较弱的对手比赛时不失球，不管他们的状态如何。相比之下，对于中场和前锋来说，这个神话被证明是真实的，那种形式确实比固定难度更能预测进攻点，尽管它仍然是预测进攻点的一个重要因素。

结论

在分析中，有几个重要的假设和警告需要记住。例如，夹具难度差异应该更多地被认为是一个顺序变量，其中差异之间的间距在现实中可能不是线性的。此外，为了简单起见，我使用了逻辑回归，但是泊松分布可能更适合这样的数据。此外，如果模型被置换，预测精度很差，可能接近噪声水平(见我以前关于置换模型的重要性的帖子)。这就留下了一种可能性，其他变量可能比状态和比赛更好地预测不失球和进攻得分，但这将是另一个问题。感谢您的阅读，并随时留下任何意见或建议。

原载于 2018 年 12 月 26 日【jinhyuncheong.com。

对用户生成内容进行知识提取和大数据分析的误区

原文：https://towardsdatascience.com/myths-in-knowledge-extraction-and-big-data-analysis-16084913203?source=collection_archive---------7-----------------------

探索和研究数据和内容为
了解不断发展的现代社会提供了一个很好的机会，包括感兴趣的话题、事件、人际关系和行为。

S 基于所谓大数据范式的多种数据科学方法已经分析了各种各样的来源，包括科学实验的定量测量、用户在网络和社交媒体上生成的内容、移动电话使用数据、物联网传感器和许多其他来源，目的是描述和/或预测行为、密度、问题以及人们感兴趣的话题或位置。

如果你把不同的来源合并在一起分析，影响会更大。

当来自多个不同来源的信息融合在一起时，分析的潜在影响甚至会更大。这也包括数据格式的多样性:在分析文本内容和数量信息时，可以提取更大的价值。当考虑多媒体内容时更是如此，尤其是因为照片、视频和音频在人与人之间的交流中扮演着越来越重要的角色。

机器学习和数据科学的重新构建增加了人们的期望。

T 大数据范式正在推动人们感知到
大规模存储的广泛可用性、强大的计算能力以及灵活易用的统计和机器学习工具。

这在中反映了(对个人和企业而言)期望能够始终快速地从现有数据中获得我们可能需要的任何种类的洞察力。

这意味着人们期望被执行的分析将总是被证明对他们的需求是相关和有用的。特别是，结果总是预期的:

*综合结果:

始终为提供一幅清晰完整的现实图景，包括所有相关方面、所有细节层次，从非常精细的结果到有弹性且可靠的综合结果。

*一致的结果:

在所有版本和维度上自洽，无论数据源、分析粒度和考虑的时间/空间是什么。

*凝聚的结果:

能够传达对现实的统一、客观和深刻的理解，这可以带来明智和适当的决策过程。

B ut，是这样吗？或者更好的说法是:这是我们从任何分析中期待的自动结果吗？

不幸的是，许多数据分析和数据科学的经验表明，情况恰恰相反。人们没有意识到，数据分析工具的广泛可用性和可访问性并不意味着你可以简单地使用它们并获得可靠的结果。

这是大数据、人工智能和机器学习民主化的挑战。

在大部分分析中，如果工作没有正确进行，没有考虑风险和偏差，没有正确应用统计数据，结果会受到许多关键方面的影响，以至于对任何目标都没有帮助。

仅使用 Python 从零开始的朴素贝叶斯——没有花哨的框架

原文：https://towardsdatascience.com/na%C3%AFve-bayes-from-scratch-using-python-only-no-fancy-frameworks-a1904b37222d?source=collection_archive---------4-----------------------

对于 ML 初学者

从零开始展开朴素贝叶斯！Take-2🎬

所以在我之前的博文 中从头开始展开了朴素贝叶斯！ 取-1🎬，我试图解码朴素贝叶斯(NB) ML 算法背后的火箭科学，在经历了它的算法见解后，你一定也意识到它是一个相当无痛的算法。在这篇博文中，我们将一步一步地完成 python 的实现(仅使用基本的 python ),并且很明显从头开始编写 NB 代码是多么容易并且 NB 在分类方面并不幼稚！

目标受众是谁？🗣 🗣 🗣 ML 初学者

因为我一直想为绝对的初学者解读 ML，而且据说如果你不能解释它，你可能没有理解它，所以这篇博客也是特别为 ML 初学者写的。

本教程的成果——NB 的实际 Pythonic 实现

正如我上面提到的，NB pythonic 实现的完整演示

定义路线图…..🚵

里程碑# 1: 数据预处理功能

里程碑# 2: 实现 NaiveBayes 类——定义用于训练的函数&测试

里程碑# 3: 在训练数据集 上训练 NB 模型

里程碑# 4: 使用经过训练的 NB 模型 进行测试

里程碑# 5: 证明 NaiveBayes 类的代码是绝对通用的！

在我们开始用 python 编写朴素贝叶斯的代码之前，我假设您熟悉:

Python 列表
Numpy &只是一点点矢量化代码
字典
正则表达式

让我们从 Pythonic 实现开始吧！

定义数据预处理功能

让我们从实现朴素贝叶斯时需要的一些导入开始

达到里程碑# 1👍

实现 NaiveBayes 类定义函数用于训练&测试

:我们将为 NB 分类器编写一个完全通用的代码！不管训练数据集中有多少类，也不管给定了什么文本数据集，它仍然能够训练一个完全工作的模型。

NaiveBayes 的代码只是一个的小扩展—* ，但是我们只需要花费最多 10-15 分钟来掌握它！之后，你会对所有重要的概念有一个很好的理解。*

这段代码在做什么？？

NaiveBayes 类中总共定义了四个函数:

*1\. **def** addToBow(self,example,dict_index)
2\. **def** train(self,dataset,labels)
3\. **def** getExampleProb(self,test_example)
4\. **def** test(self,test_set)*

代码分为两个主要功能，即训练和测试功能。一旦您理解了这两个函数中定义的语句，您就一定会知道代码实际上在做什么，以及其他两个函数被调用的顺序。

*1**.** Training function that trains NB Model : **def** train(self,dataset,labels)2\. Testing function that is used to predict class labels 
   for the given test examples :
   **def** test(self,test_set)*

另外两个函数被定义来补充这两个主要函数

*1\. BoW function that supplements training function 
   It is called by the train function.
   It simply splits the given example using space as a tokenizer 
   and adds every tokenized word to its corresponding BoW : 
   **def** addToBow(self,example,dict_index)2\. Probability function that supplements test function. 
   It is called by the test function.
   It estimates probability of the given test example so that 
   it can be classified for a class label :
   **def** getExampleProb(self,test_example)*

您可以在本 Jupyter 笔记本 中查看以上代码太

如果我们定义一个 NB 类，比使用传统的结构化编程方法更容易组织和重用代码。这就是定义 NB 类及其内部所有相关函数的原因。

我们不只是想写代码，而是想写漂亮、整洁、方便、可重用的代码。是的，没错——我们希望拥有一个优秀的数据科学家可能拥有的所有特征！

你猜怎么着？每当我们将要处理一个我们打算用 NB 来解决的文本分类问题时，我们将简单地实例化它的对象，并且通过使用相同的编程接口，我们将能够训练一个 NB 分类器。另外，作为面向对象编程的一般原则，我们只定义与该类中的某个类相关的函数，所以所有与 NB 类无关的函数都将被单独定义

里程碑# 2 实现 👍 👍

在训练数据集上训练 NB 模型

是的，就是这样！只需要四个函数，我们就可以在任何文本数据集和任何数量的类标签上训练我们的 NB 模型了！

Ready — Set — Go!

如果你很想知道训练数据实际上是什么样的…..这是一个新闻组数据集，由 20 个主题的新闻组帖子组成。它有 20 个类别，但目前，我们将只在四个类别上训练我们的 NB 模型——[' alt .无神论'，' comp.graphics '，' sci.med '，' soc.religion.christian']，但代码对于所有 20 个类别的训练都非常有效。

Training Dataset

您可能想知道为什么“Training Labels”列是数字形式，而不是它们原来的字符串文本形式。只是每个字符串标签都被映射到其唯一的数字整数形式。即使你现在还不清楚这一点，只要考虑已经提供了一个数据集，并且它有数字形式的标签。简单！

因此，在我们开始训练 NB 模型之前，让我们加载这个数据集……
我们将从 sklearn ( python 的 ML 框架)加载一个数据集——但我们仍然从头开始编写 NB 代码！

让我们开始训练吧！

训练完成！！！

里程碑# 3 达成👍 👍 👍

使用经过训练的 NB 模型进行测试

既然我们已经训练了我们的 NB 模型，让我们开始测试吧！
加载测试集…..

使用我们训练过的 NB 模型对上面加载的测试示例进行测试…

哇！相当不错的准确率~ 93% ✌️
看现在你意识到 NB 不是那么天真！

里程碑# 4 实现 👍 👍 👍👍

证明 NaiveBayes 类的代码是绝对通用的！

正如我在开头提到的，我们编写的代码是泛型的，所以让我们在不同的数据集上使用相同的代码，并使用不同的类标签来证明它的"泛型"！

另一个文本数据集由电影评论和他们的观点组成&看起来像下面这样:

Here is the link to this dataset from Kaggle

为此数据集训练一个 NB 模型并测试其准确性…

请注意，看看相同的 NaiveBayes 代码如何在不同的数据集上工作，并且具有相同的编程接口！

让我们在 Kaggle 测试集上测试，并上传我们在 kaggle 上的预测，看看我们的 NB 在 Kaggle 测试集上的表现如何！

kaggle 结果的屏幕截图——相当好的 80%的准确率👌

Kaggle Prediction Results

里程碑# 5 实现 👍 👍 👍👍👍

这就是这篇博文的全部内容，现在你都知道了！

即将发布的帖子将包括:

从头开始展开朴素贝叶斯！Take-3🎬使用 scikit-learn 实现朴素贝叶斯( Python 的机器学习框架)

在此之前，敬请关注📻 📻 📻

如果您有任何想法、意见或问题，欢迎在下面评论或联系📞跟我上 LinkedIn

朴素贝叶斯分类器

原文：https://towardsdatascience.com/naive-bayes-classifier-81d512f50a7c?source=collection_archive---------0-----------------------

什么是量词？

分类器是一种机器学习模型，用于根据某些特征区分不同的对象。

朴素贝叶斯分类器的原理:

朴素贝叶斯分类器是一种用于分类任务的概率机器学习模型。分类器的关键是基于贝叶斯定理。

贝叶斯定理:

利用贝叶斯定理，我们可以求出 A 发生的概率，假设 B 已经发生。这里， B 是证据， A 是假设。这里的假设是预测器/特征是独立的。也就是说，一个特定特征的存在不会影响另一个特征。因此它被称为天真。

示例:

让我们举个例子来获得一些更好的直觉。考虑打高尔夫的问题。数据集表示如下。

鉴于当天的特点，我们对当天是否适合打高尔夫球进行分类。列代表这些功能，行代表各个条目。如果我们取数据集的第一行，我们可以观察到，如果天气多雨、温度高、湿度大且没有风，则不适合打高尔夫球。我们在这里做两个假设，一个如上所述，我们认为这些预测是独立的。也就是说，温度热，不一定意味着湿度高。这里做的另一个假设是所有的预测因素对结果有相同的影响。也就是说，刮风的那一天对决定是否打高尔夫球没有更大的重要性。

根据这个例子，贝叶斯定理可以改写为:

变量 y 是类变量(play golf)，代表是否适合打高尔夫球，是否给定条件。变量 X 代表参数/特征。

X 给定为:

这里 x_1，x_2…x_n 代表特征，即它们可以映射到前景、温度、湿度和风力。通过替换 X 并用我们得到的链式法则展开，

现在，您可以通过查看数据集获得每个值，并将它们代入等式。对于数据集中的所有条目，分母不变，保持不变。因此，可以去掉分母，引入比例。

在我们的例子中，类变量( y )只有两个结果，是或否。可能存在分类是多元的情况。所以我们需要找到概率最大的类 y 。

使用上面的函数，我们可以得到类，给定预测。

朴素贝叶斯分类器的类型:

多项式朴素贝叶斯；

这主要用于文档分类问题，即文档是否属于体育、政治、技术等类别。分类器使用的特征/预测值是文档中出现的单词的频率。

伯努利朴素贝叶斯；

这类似于多项式朴素贝叶斯，但预测因子是布尔变量。我们用来预测类变量的参数只取值 yes 或 no，例如一个单词是否出现在文本中。

高斯朴素贝叶斯:

当预测值取连续值且不是离散值时，我们假设这些值是从高斯分布中采样的。

Gaussian Distribution(Normal Distribution)

由于数据集中值的显示方式发生了变化，条件概率的公式也发生了变化，

结论:

朴素贝叶斯算法主要用于情感分析、垃圾邮件过滤、推荐系统等。它们快速且易于实现，但是它们最大的缺点是要求预测器是独立的。在大多数实际情况下，预测器是相关的，这阻碍了分类器的性能。

朴素贝叶斯分类器:朴素贝叶斯的几何分析。第一部分

原文：https://towardsdatascience.com/naive-bayes-classifier-a-geometric-analysis-of-the-naivete-part-1-51f462a858bb?source=collection_archive---------9-----------------------

当类被线性和非线性真决策边界分开时，为朴素贝叶斯预测导出封闭形式的解…

维数灾难是所有分类问题的祸根。什么是维度的诅咒？随着特征(维度)数量的线性增长，分类所需的训练数据量也呈指数增长。如果分类是由单个特征确定的，我们需要该特征的一系列值的先验分类数据，因此我们可以预测新数据点的类别。对于具有 100 个可能值的特征 x ，所需的训练数据的数量级为 O(100)。但是，如果还需要第二个特征 y 来确定类别，并且 y 具有 50 个可能值，那么我们将需要 O(5000)阶的训练数据，即在对“ *x，y”*的可能值的网格上。因此，所需数据的度量是特征空间的体积，并且随着更多特征的添加，它呈指数增长。

但这总是这么糟糕吗？我们是否可以做一些简化的假设来减少所需的数据量，同时保留所有的特性？在上面的例子中，我们说我们需要 O(5000)阶的训练度量。但是朴素贝叶斯分类器只需要 O(150)阶的测量值——即只是线性增加，而不是指数增加！这太棒了，但是我们知道没有免费的午餐，朴素贝叶斯分类器应该做一些简化(朴素？)假设。这就是这篇文章的目的——检查天真在朴素贝叶斯分类器中的影响，该分类器允许它避开维数灾难。实际上，我们不希望代数分散我们对我们所追求的东西的欣赏，所以我们坚持二维 x，y 和两类 C_1 和 C _ 2 T21。

决定边界

决策边界是我们的二维特征空间中的一条曲线，它将两个类别C1和C2分开。在图 1 中， y-f(x) > 0 表示等级C1和 y -f(x) < 0 表示C2的区域。沿着决策边界 *y = f(x)，*并且属于任一类的概率相等。任一类的等概率是获得决策边界的准则。

Figure 1. The decision boundary separates the two classes C_1 and C_2 in the feature space. For points on the decision boundary, the probability of belonging to either class is the same.

这篇文章的目的是分析非线性对决策边界的影响，以及由不平衡的班级规模引起的相关问题。这个职位的总体轮廓如下。

选择一个精确的函数形式 y = f(x) 作为真正的决策边界。
获得由朴素贝叶斯分类器预测的决策边界的封闭形式的解
分析班级规模对预测的影响
当一个类压倒另一个类时，获得渐近行为
当 f(x) 为线性和非线性时，重复 1 至 4。

帖子的内容有些学术性，因为对于真实数据，我们不知道真正的决策边界，必须处理数据噪声，并且不知道哪些特征实际上负责我们所寻求的分类等。但这里的要点是理解在理想化设置中天真假设的影响，以便我们能够更好地应用和解释真实数据的朴素贝叶斯分类器。

1.朴素贝叶斯分类

朴素贝叶斯分类基于关联条件概率和边际概率的贝叶斯规则。这在文献中有很好的描述，因此我们简单地写下具有 2 个特征 x，y 的 2 类(C1和C2)情况的方程。

(1)

对于任何新的测量值 x，y ，我们将根据等式 1 计算 P(C_1|x，y) 和 P(C_2|x，y) ，并选择具有较大值的类。因为分母是相同的，所以计算它们的比值更容易，所以我们不需要计算 P(x，y) 。

P(C_i) 是任何测量值落入 C_i 类的概率。作为 C_i 样本的相对丰度，它很容易从训练数据中计算出来。正是 P(x，y|C_i) 的计算充满了我们谈到的数据需求的挑战。为了做到这一点，我们需要估计每一类 C_i 中 x，y 的联合概率分布，这需要在 x，y 值的网格上的训练数据。这就是朴素贝叶斯的朴素部分缓解维数灾难的地方。

1.1 天真的假设

如果特征 x，y 是不相关的，给定类别 C_i ，那么联合概率分布将简单地是个体概率的乘积。即

(2)

如果我们做这个假设，那么我们只需要分别估计 P(x|C_i) 和 P(y|C_i) 。并且这只需要在范围 x 和范围 y 上的训练数据，而不是在 x，y 值的网格上。使用方程1中的方程 2 ，我们得到新的 x，y 测量值及其类别分配的类别概率的比率如下

(3)

虽然不相关特征的天真假设简化了事情，但它的有效性值得商榷。例如，如果 xy < 1 在一个类中，那么当 y 较小时，找到大的 x 值的概率较高，当 y 较大时，找到大的x值的概率较低。事实上，在这个类中找到测量值[x=0.9，y=1.1]的概率将是 1，而对于测量值[x=0.9，y=1.2]来说，它将是 0。显然， x 和 y 的概率分布通常不会相互独立，并且对独立性的天真假设会导致新数据的错误分类。

1.2 推导 P(x|C_i)和 P(y|C_i)

如果我们可以获得作为 x，y 的函数的 P(x|C_i) 和 P(y|C_i) ，那么我们可以得到作为 x，y 的函数的公式 3 中的比值。

Figure 2. Deriving the naive bayes probabilities, given a true decision boundary y = f(x). To keep the algebra simple, the function f(x) is taken to have a simple inverse x = f^-1(y). The fractional areas of the rectangular strips in a class are indicative of the probability.

考虑图 2，其中真实判定边界*y = f(x)*将特征空间分成两类。为了避免代数问题，我们进一步假设 f 是显式可逆的，因此我们可以写成 *x = f^-1(y).*一个类的先验概率与它的整体大小成正比——在这种情况下是面积。

(4)

为了计算 *P(x|C_i)，*假设我们将 x 轴离散化，并在 x 周围选取一个宽度为δx 的小矩形条，如图 2 所示。类别 C_i 中的条带面积除以类别面积 A_i 将是概率 *P (x|C_i)。*同样对于概率 P (y|C_i)

(5)

x1越长，*P(y | C1)*的概率就越高。同样，更大的 y_2 意味着更高的概率用于 P(x|C_2) 等等。一旦我们理解了这一点，剩下的就是简单的几何和代数了。将等式 4 和 5 与等式 3 中的朴素贝叶斯分类相结合，我们得到:

(6)

上述比率等于 1 的 x，y 的轨迹是朴素贝叶斯分类器预测的决策边界。

(7)

Figure 3. For a point on a linear decision boundary, a geometric proof that: (a) x_1 y_1 = x_2 y_2 in case of balanced classes and (b) x_1 y_1 ≠ x_2 y_2 when classes are unbalanced.

为了直观理解等式 7 ，考虑图 3 中具有相等/不相等班级规模的线性决策边界的情况。如图 3.1 所示，当班级规模相等时，决策边界将是对角线，对于对角线上的每一点，矩形 ABOC 的面积等于矩形 ODEF 的面积。但那不过是关于对角线上任意一点的 x_1 y_1 和 x_2 y_2 相等的陈述。因此，根据等式 7 ，由朴素贝叶斯预测的决策边界将匹配对角线——真正的决策边界。然而，在图 3.2 中，类的大小是不一样的，并且这两个矩形的面积不必对分离边界上的每一点都相等。因此，即使在线性情况下，当类别大小不同时，我们也不能期望朴素贝叶斯产生真实的决策边界。我们将在下一节通过分析再次验证这一点。

这就完成了我们推导朴素贝叶斯预测的决策边界的一般方法。在这篇文章的剩余部分，我们为真正的决策边界选择不同的函数形式 f(x) ，并与我们从朴素贝叶斯得到的进行对比。

2.线性决策边界

我们从图 4 中的线性情况开始，其中直线 y = qx/a 在矩形特征空间中将两个类分开。当 q 等于 b 时，我们得到平衡类。

Figure 4. Evaluating x_1 , y_1 , x_2 and y_2 for a linear decision boundary y=qx/a

类面积a1，a2和长度x1，x2，y1，和y2直接从几何图形中得出。在等式 7 中使用它们并进行简化，我们得到朴素贝叶斯预测的决策边界是一条双曲线。

(8)

有了预测分离边界的闭合解，我们可以看看当 A_1 类的规模保持增加而 A_2 保持不变时，类规模的影响及其渐近性。这是通过增加 b 同时保持 a 和 q 不变来实现的。

2.1 均衡类。A_1 = A_2

当 b = q 时，类别大小将相等，并且分离边界减少到:

(9)

这是真正的决策界限。也就是说，当类由直线分隔并且大小相同时，朴素贝叶斯分类不会有错误。这是对图 3 中相同几何论证的严格证明。

2.2 不平衡的阶层。增加 a1 和常数 a2

图 5 显示了当 b 增加时的预测决策边界(即，我们拖动特征空间的顶部边界)，从而增加 A_1，同时保持 A_2 不变。在所有情况下，对于较小的 x ，朴素贝叶斯预测开始偏向于类别 C_2 (预测的边界在真实边界之上——意味着将真实 C_1 测量分类为 C_2 的偏好),并且随着 x 的增加，切换到偏好类别 C_1 。然而，有趣的是，它们都在真实决策边界的同一点上切换。

2.2.1 切换点

切换点 (x，y*)* 是真实决策边界和预测决策边界的交点。利用方程 8 中的 y = qx/a 并简化得到:

(10)

Figure 5. Linear decision boundary. Naive bayes classifier predicts a hyperbola as the class boundary. Only when the classes are balanced does the prediction match the prescribed boundary y = x

该点的坐标独立于 *b，*不同曲线上的唯一变量。因此它们都与真实边界相交于同一点。

2.2.2 渐近边界:a1→∞

随着 b 增加，比率 A_1/A_2 增加。当 b 趋于无穷大时，我们得到渐近预测边界 y_s(x)。

(11)

3.非线性决策边界

我们现在考虑图 6 中的情况，其中抛物线判决边界 y=x^2 将两个类别分开。

Figure 6. Evaluating x_1 , y_1 , x_2 and y_2 for a nonlinear decision boundary y=x²

再次，x_1，y_1，x_2 和 y_2 作为 x，y 的函数的表达式直接来自几何。应用等式 7 并进行简化，我们得到 y 作为预测决策边界的 x 的四阶函数

(12)

3.1 增加 A_2 和常数 A_1 的影响

Figure 7. Nonlinear decision boundary. The naive bayes prediction does not match the true boundary even in the case of balanced classes.

图 7 显示了当类大小 A_2 变化而保持 A_1 不变时，预测的决策边界与真实边界的对比。这可以简单地通过拖动特征空间的右边界来完成，即改变为。

这里有一些与线性情况相反的快速观察。

即使在平衡类的情况下(A_1/A_2 = 1 即 a = 4q/3)，预测的边界也与真实的边界不匹配。这不同于我们前面看到的线性情况。使用等式 12 中的 q = 3a/4，我们得到:

(13)

对于小的 x ，预测倾向于 C_1 而不是 C_2 (在所有情况下，预测边界在真实边界以下开始)，但是对于较大的 x 则切换到偏好 C_2 。
当 a2 较小时，预测边界在 x 范围内大部分在真实边界之下。对于较大的 A_2，预测边界变得更陡，越来越早地与真实边界相交。因此，与线性情况不同，它们与真实边界相交于不同的点。
即使它们在不同的点上与真实边界相交，有趣的是它们都在一个点上相交。那当然可以证明。不同曲线上的唯一变量是和。所以我们要做的就是找到两个预测边界的交点，并证明它独立于 a 。考虑 a_ 1 和 a_2 的两个边界。使用方程 12 在它们的交点处并简化我们得到，

产生独立于 a 的交点，从而证明观察结果。

(14)

3.2 渐近边界:a2→∞

随着 a 增加，面积 A_2 增加。当 a 趋于无穷大时，我们得到渐近预测边界 y_s(x)。

(15)

4.后续步骤

当真实的决策边界在具有两个特征的两个类之间已知时，我们已经导出了由朴素贝叶斯分类器预测的决策边界的封闭形式的解决方案。我们挑选了简单的线性和非线性边界，并评估了当一个类别压倒另一个类别时，类别大小及其渐近性的影响。接下来的步骤如下。

在总规模保持不变的情况下，获得作为班级规模比率的函数的混淆矩阵。例如，当我们在图 4 中将 q 从 0 变到 1 时，比率 A_1/A_2 从∞变到 0，而 A_1 + A_2 保持恒定在 ab 。在这种情况下，通过混淆矩阵测量的朴素贝叶斯分类器的性能是令人感兴趣的。
模拟在 SciKit 中实现的高斯朴素贝叶斯算法，以评估高斯近似概率引入的额外误差。
评估朴素贝叶斯预测相对于其他竞争分类器，如逻辑回归，神经网络等…

由于这篇文章太长了，所以我将在这个系列的下一篇文章中讨论以上内容。

原载于 2018 年 8 月 6 日xplordat.com。

朴素贝叶斯分类器:第 2 部分。表征和评估

原文：https://towardsdatascience.com/naive-bayes-classifier-part-2-characterization-and-evaluation-96b37f781c7c?source=collection_archive---------15-----------------------

封闭形式的解决方案是甜蜜的。不需要绞手/挥手来表达观点。给定假设，模型预测是精确的，因此我们可以很容易地评估假设的影响。并且，我们获得了评估应用于这些具有精确解的相同极限情况的替代(例如，数值)方法的方法。我们当然是在讨论之前的文章，其中我们获得了朴素贝叶斯预测决策边界的闭合形式解，而真正的决策边界是已知的线性或非线性形式。由于已经有了很好的基础，我们将认真地开始我们在前一篇文章中概述的“下一步”。如果需要的话，请回顾一下，因为我的文章往往有 2000 多字，几乎没有重复的空间。这个帖子实际上有点长，但主要是因为图表和模拟结果，所以应该不会太差。

1.混乱矩阵

对于我们的 2 类(C1和“而不是 C1或C2)和 2 特征([ x，y】【T9])情况，一个很好的表征任何分类器性能的方法是计算下面图 1 所示的混淆矩阵。真实边界和预测边界相交，并将特征空间分为四个区域。这些区域中的数据点已经被正确地(即真*)或不正确地(即假)识别为属于(即正)或不属于C1(即负)。例如，右上角区域被标记为假阴性，因为预测假阳性将其归类为'而非**C1 '。其他区域的命名也是如此。*

Figure 1. Evaluating the confusion matrix in the assignment of a class C_1 to a data point. The areas of intersection FP and FN are the key variables determining the quality of the classifier

相交面积 FP 和 FN 以及由此计算的任何度量产生对分类器有效性的重要洞察。例如，用于C1的高度特定的分类器永远不会将真正的“not C1”数据点放置在“C1”区域中。同样，如果分类器对C1高度敏感，它将永远不会将真正的C1放置在“*not C1”*区域中。分类器的整体准确度当然是正确预测的分数。所有这些导致了通常使用的以下定义。

(1)

每个分类练习都会为这些指标中的每一个产生一个值。运行一系列这样的练习并从每次运行中收集这些度量，我们可以表征分类器对于该特征空间中的数据有多好。高灵敏度(小 FN 区)&高特异性(小 FP 区)自然是分类器的理想特征。

2.相交的区域

随着初步问题的解决，我们准备量化朴素贝叶斯分类器对于我们在上一篇文章中考虑的线性和非线性边界的表现。如下图 2 所示， k 的每个值在 A_1 和 A_2 之间分割特征空间，而 A_1 + A_2 保持不变。预测边界自然是这个参数 k 的函数，并且每个这样的预测边界产生一个值用于 FN 和 FP 我们感兴趣的相交区域。

Figure 2. As the point P moves, the feature space gets split between the classes. FP and FN are the areas of interest that meet at the intersection point of the true and predicted boundaries. (A) Point P moves vertically from 0 through b. The true and predicted boundaries always intersect at (a/2, k/2) (B) Point P moves horizontally from 0 through a . The intersection point x* for the true and predicted boundaries is a root of the quadratic given in Equation 6.

在非线性抛物线边界的情况下，我们用 y = kx^2 而不是 y = x^2 来工作，就像我们在之前的文章中那样。导出更新的决策边界是前面详述的相同几何过程的直接应用。为了便于参考，我们简单地写下线性和抛物线情况下的结果。 y_p 代表下面的预测边界，我们用 y_t 代表真实边界。

(2)

(3)

Figure 3. Varying k is a means to change the relative class sizes while holding the total size constant. In all the cases above a = b = 1.0, so A_1 + A_2 = 1.0. When one of the class sizes goes to zero i.e. A_1/A_2 → ∞ for the linear case, and A_1/A_2 → 0 for the parabolic case we expect better predictions in either case as indicated by vanishing FP and FN. (A) For linear case, naive bayes prediction is exact, i.e FP = FN = 0 for A_1/A_2 = 1 (B) For the nonlinear case has FN = 0, but FP is at maximum when A_1/A_2 = 2.

图 3 说明了 FP 和 FN 之间的动态相互作用和权衡，因为 k 在任一情况下都是变化的。交点 FP 和 FN 的面积就是我们所追求的，因为我们有 y_p 和 y_t 的显式方程，所以可以直接积分。

2.1 线性情况下的 FP 和 FN

在线性情况下，我们知道真实边界和预测边界相交于点 (a/2，k/2) 。

(4)

从方程 2 中代入 y_t = kx/a 和 y_p ，积分简化得到:

(5)

抛物线情况下的 2.2 FP 和 FN

这里的交点是方程 y_p=k x^2 的解，其中 y_p 由方程 3 给出。不幸的是，没有显式的解决方案，但整个事情简化为一个二次，需要解决一个有意义的根。

(6)

参照图 2B，面积 FP 和 FN 的计算公式如下

(7)

被积函数和极限是确切已知的，因此可以使用如下代码片段对积分进行精确的数值计算:

import numpy as np from scipy.integrate
import quaddef integrand (x, k):
   yt = min (k * x * x, b)
   temp = 1.0/k**0.5 + (1.0/k**0.5) * (3*a/(2*(b/k)**0.5) — 1.0) *   (b/(k*x*x) — 1.0)
   yp = min ((a/temp)**2, b)
   return abs(yt — yp)def findIntersectionX (k):
   c2 = 4 * (b*k)**0.5 - 3*a*k
   c1 = -2 * a * (b*k)**0.5
   c0 = b * (3 * a - 2 * (b/k)**0.5) x1 = (-c1 + (c1**2 - 4 * c2 * c0)**0.5) / (2*c2)
   x2 = (-c1 - (c1**2 - 4 * c2 * c0)**0.5) / (2*c2) if ( (x1 >= xmin) and (x1 <= xmax) ):
      return x1
   elif ( (x2 >= xmin) and (x2 <= xmax) ):
      return x2
   else:
      print ("ERROR!") # should not happen!a = 1.0
b = 1.0
k = 10.0
xmin = 0.0
xmax = (b/k)**0.5xIntersection = findIntersectionX (k)
fp_area = quad(integrand, xmin, xIntersection, args=(k),epsabs=1.0e-8)
fn_area = quad(integrand, xIntersection, xmax, args=(k), epsabs=1.0e-8)

3.特征

有了获取任何 k 的 FP 和 FN 的方法，我们就可以对分类器的灵敏度、特异性等进行评估了……我们在第 1 节中讨论过了。 TP 和 TN 直接从几何图形中得出。

(8)

图 4 示出了作为 A_1/A_2 的函数的相交面积及其获得的度量。 FP 和 FN 面积是整体面积的一小部分，精度极好。毫无疑问，这两种情况下的度量都很好，即使线性情况似乎有优势。由于导出解的设计，这些结果中的a1/a2的范围在两种情况下都有所限制(抛物线情况下 0 → 2 ，线性情况下 1 → ∞ )。

Figure 4. In all the cases above a = b = 1.0, so A_1 + A_2 = 1.0. (A) Both the intersection areas FP, FN go to zero for the linear case when A_1/A_2 = 1 and when A_1/A_2 → ∞ as expected. Only FN is zero in the parabolic case when A_1/A_2 = 2 confirming our assessment from Figure 3. (B) The naive bayes classifier is more sensitive than specific in either case.

在图 4B 中观察到的敏感性、特异性和准确性通过一个点并不是偶然的。当灵敏度和特异性相等时，

其中最后一个表达式是精度的定义。

4.用 SciKit 进行数值模拟

SciKit 拥有优秀的算法实现，包括用于分类的朴素贝叶斯。高斯朴素贝叶斯从训练数据中逼近高斯分布，以估计新数据点 x，y 的 P(x|C_1) 和 P(y|C_1) 。当这个新的数据点 x，y 远离决策边界时，这是好的，但是否则显然会有一些误差。这种误差对分类的影响是什么，这是我们试图通过一些数值模拟来探索的问题。此外，我们应用了两种竞争分类技术，即逻辑回归和MLP 分类器，同样在 SciKit 中实现。对这些技术中的假设进行分析是另一篇文章的主题。在这里我们简单地使用它们——sci kit 使尝试变得非常容易。

生成训练和测试数据轻而易举，因为我们知道确切的决策界限。

from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import *
import numpy as nptrain = np.array(np.loadtxt(open('./train.csv', "rb"),              delimiter=",",skiprows=1))
trainX = train[:,0:2] # x, y locations
trainY = train[:,2] # Class label 1 (i.e. C1) or 0 (i.e. Not C1)
test = np.array(np.loadtxt(open('./test.csv', "rb"), delimiter=",",skiprows=1))
testX = test[:,0:2]
testY = test[:,2]gnb = GaussianNB()
lr = LogisticRegression()
mlp = MLPClassifier(hidden_layer_sizes=(4,))stats = []
for id, clf, name in [(0,lr, 'lr'),(1,gnb, 'gnb'),(2,mlp, 'mlp')]:
    clf.fit(trainX, trainY)
    predictions = clf.predict (testX) sk_tn, sk_fp, sk_fn, sk_tp = confusion_matrix (testY, predictions).ravel()
    sk_accuracy = accuracy_score(testY, predictions)
    sk_precision = precision_score(testY, predictions)
    sk_sensitivity = recall_score(testY, predictions)
    sk_specificity = sk_tn / (sk_tn + sk_fp)

我们对三个分类器的大部分参数使用默认值。默认情况下，MLPClassifier 使用 100 个神经元和一个隐藏层。一个隐藏层很好，但是考虑到我们只有 2 个输入神经元(一个用于 x ，另一个用于 y ),使用 100 个隐藏神经元是大材小用。我们选了 4 个，我们可能会做得更少。在训练模型之后，我们得到混淆矩阵。当然，所有其他的指标都可以通过计算得出。

4.1 sci kit 中高斯近似的误差

Figure 5. In all the cases above a = b = 1.0 so A_1 + A_2 = 1.0. MLP uses a single hidden layer with 4 neurons. (A) & ( C ) The mispredictions from gaussian naive bayes overlap and extend beyond the analytic results (B) Both logistic regression and MLP have essentially no mispredictions in the linear case (D) Logistic regression (in red) does worse than MLP for the nonlinear case.

图 5A 和 5C 显示了 SciKit 的高斯朴素贝叶斯模拟对于线性情况的结果，其中 k = 0.6 (即 A_1/A_2 = 2.33 )。红色的预测失误区域比用分析朴素贝叶斯预测获得的预测失误区域更大。众所周知，逻辑回归是一种线性分类器，因此预计图 5B 中的预测接近完美。在所有情况下，MLP 当然是最好的，即使在一个隐藏层中只有 4 个神经元。但是我们将在后面看到，这种快乐的情景不适用于具有更严重非线性的边界。

4.2 分类指标

图 6 比较了三个分类器在多个仿真中的性能，其中比率 A_1/A_2 在保持 A_1 + A_2 为 1 的同时发生变化。这非常类似于图 4，其中我们比较了分析性朴素贝叶斯预测和事实。一些简单的观察如下。

Figure 6. In all the cases above a = b = 1.0, so A_1 + A_2 = 1.0. All three classifiers can be considered quite good even while MLP does beat out the rest in general.

朴素贝叶斯具有最大的误差区域( FP 和 FN )。即使在线性情况下，逻辑回归的 FP 也随着a1/a2增加。鉴于逻辑回归是一个线性分类器，这将需要一些进一步的分析，为什么。
就错误表征的总面积(即 FP + FN )而言，我们看到 MLP、逻辑回归和朴素贝叶斯的优秀程度依次递减。
根据需求，人们可以选择在该标准方面表现优异的分类器。例如，MLP 在这一点上非常突出。

5.神经网络更擅长分类吗？

从第 3 节和第 4 节的结果来看，神经网络似乎更善于对具有线性或非线性分离边界的数据进行分类。但是这样的概括可能是错误的。当我们知道真相时，就像这里的情况一样，我们可以对隐藏层的数量、内部神经元的数量、激活函数等进行调整，以获得与真相更好的匹配。但这一结果可能不具有超出这一具体实践范围的普遍有效性。为了在实践中看到这一点，让我们考虑正弦波作为分离边界的情况，并尝试用同样的三种方案进行分类。

(9)

随着 k 的增加，特征空间被分割成越来越多的不连续区域，分类变得更加困难。使用 SciKit 获得分类结果的机制与第 4 节中的相同，因此我们直接查看结果。

图 7A 绘制了当不连续区域的数量通过改变 k 而变化时，相交区域的大小。很明显，当我们使用单一隐藏层时，MLP 对任何 k 都没有好处。MLP。 FP 和 FP 加起来大约占总面积的 20-30 %,所以有很多数据会被错误分类。这反映在图 7B 中较小的特异性值中。对于 6 个隐藏层，MLP 对于所有的 k 值具有小得多的误差区域，从而具有更好的特异性，如图 7B 所示。

Figure 7. The upshot from the results here is that MLP can do better but careful experimentation is required before generalizing the applicability of the model. When k = 4, in Equation 9, there would be 4 non-contiguous zones for the two classes. (A) MLP with a single hidden layer yields no improvement over naive bayes or logistic regression for any k. Six hidden layers with ten neurons each yields better classification but there could be other combinations that can do equally well or better. (B) Much better specificity with 6 hidden layers for all values of k. (C — E): Increasing the number of layers is not guaranteed to improve performance for MLP. It starts to get better as we add more hidden layers but worsens after 6 layers.

图 7C-7E 显示了当 k = 4 时所有情况下获得的误差区域。误差区域随着隐藏层的增加而减少，产生 6 层的最佳分类。但不幸的是，7 层的效果更差，有点出乎意料…所谓的炼金术在起作用。显然，这里还有更多的事情需要更深入的分析。

6.后续步骤

至此，我们结束了这篇有点长但简单明了的帖子。对于线性和抛物线分离边界，我们已经表明，这里测试的所有三个分类器都很好，MLP 挤掉了逻辑回归和朴素贝叶斯。MLP 的出色表现很有趣，但目前还不清楚它究竟如何做得更好。对于更严重的非线性，MLP 可能工作得很好，但是可能需要仔细的实验来概括所获得的结果。尽管如此，这里的结果是足够令人鼓舞的，我们希望在未来的帖子中尝试使用神经网络来解决文本分类问题。

原载于 2018 年 8 月 25 日【xplordat.com】。

机器学习中的朴素贝叶斯

原文：https://towardsdatascience.com/naive-bayes-in-machine-learning-f49cc8f831b4?source=collection_archive---------1-----------------------

贝叶斯定理在概率论和统计学中有许多用途。你有极小的可能从未听说过这个定理。原来这个定理已经找到了进入机器学习世界的方法，形成了一个高度修饰的算法。在本文中，我们将学习所有关于朴素贝叶斯算法的知识，以及它在机器学习中用于不同目的的变体。

你可能已经猜到了，这需要我们从概率的角度来看待事物。就像在机器学习中，我们有属性、反应变量和预测或分类。使用该算法，我们将处理数据集中变量的概率分布，并在给定新实例的属性的情况下，预测响应变量属于特定值的概率。让我们从回顾贝叶斯定理开始。

贝叶斯定理

这使我们能够根据与前一事件相关的任何事件的先验知识来检查事件的概率。因此，举例来说，如果我们知道房子周围的设施，与不知道房子的位置相比，我们可以更好地评估房子价格高的可能性。贝叶斯定理就是这么做的。

Image taken from Wikipedia

上面的等式给出了贝叶斯定理的基本表示。这里 A 和 B 是两个事件,

P(A|B):假设 B 已经发生，事件 A 发生的条件概率。这也被称为后验概率。

P(A)和 P(B):A 和 B 互不考虑的概率。

P(B|A):假设 A 已经发生，事件 B 发生的条件概率。

现在，让我们看看这如何很好地适应机器学习的目的。

以一个简单的机器学习问题为例，我们需要从一组给定的属性(在训练示例中)中学习我们的模型，然后形成一个假设或与一个响应变量的关系。然后，给定新实例的属性，我们使用这个关系来预测响应。使用贝叶斯定理，在给定一组新属性的情况下，可以构建一个预测响应变量属于某类的概率的学习器。

再次考虑前面的等式。现在，假设 A 是响应变量，B 是输入属性。所以根据等式，我们有

P(A|B) :给定输入属性，响应变量属于特定值的条件概率。这也被称为后验概率。

P(A) : 响应变量的先验概率。

P(B):训练数据或证据的概率。

P(B|A):这就是训练数据的似然性。

因此，上述等式可以改写为

Image taken from Wikipedia

让我们来看一个问题，其中属性的数量等于 n，响应是一个布尔值，即它可以是两个类中的一个。此外，属性是分类的(我们的例子中有两个类别)。现在，为了训练分类器，我们需要为实例和响应空间中的所有值计算 P(B|A)。 这意味着，我们将需要计算 2(2^n -1)，用于学习这个模型的参数。在大多数实际的学习领域，这显然是不现实的。例如，如果有 30 个布尔属性，那么我们将需要估计超过 30 亿个参数。*

朴素贝叶斯算法

为了实用，需要降低上述贝叶斯分类器的复杂性。 朴素贝叶斯算法通过对训练数据集做出条件独立性的假设来做到这一点。这大大降低了上述问题的复杂性，只有 2n。

条件独立性假设说明，给定随机变量 X，Y，Z，我们说 X 是条件独立于 Y 给定 Z 的，当且仅当支配 X 的概率分布独立于 Y 给定 Z 的值

换句话说，给定 Z ，X 和 Y 是有条件独立的当且仅当，给定 Z 发生的知识，关于 X 是否发生的知识不提供关于 Y 发生的可能性的信息，并且关于 Y 是否发生的知识不提供关于 X 发生的可能性的信息。

这种假设使得贝叶斯算法显得幼稚。

给定 n 个不同的属性值，可能性现在可以写成

这里，X 代表属性或特征，Y 是响应变量。现在，P(X|Y)等于给定 Y 的每个属性 X 的概率分布的乘积。

最大化后验概率

我们感兴趣的是找到后验概率或 P(Y|X)。现在，对于 Y 的多个值，我们需要计算每个值的表达式。

给定一个新的实例 Xnew，我们需要计算 Y 取任何给定值的概率，给定 Xnew 的观察属性值，给定从训练数据估计的分布 P(Y)和 P(X|Y)。

那么，我们如何预测响应变量的类别，基于我们得到的 P(Y|X)的不同值。我们简单地取这些值中最可能的或最大的。因此，这个过程也被称为最大化后验概率。

最大化可能性

如果我们假设响应变量是均匀分布的 ，也就是说它同样有可能得到任何响应，那么我们可以进一步简化算法。在这种假设下，先验或 P(Y)变成一个常数值，即 1/响应的类别。

由于，先验和证据现在都独立于响应变量，这些可以从方程中去掉。因此，最大化后验概率就归结为最大化似然问题。

特征分布

如上所述，我们需要从训练集中估计响应变量的分布，或者假设均匀分布。类似地， 为了估计特征分布的参数，必须假设分布或从训练集 生成特征的非参数模型。这种假设被称为事件模型。这些假设的变化产生了用于不同目的的不同算法。对于连续分布，高斯朴素贝叶斯是首选算法。 为离散特征，多项式和伯努利分布为流行。对这些变化的详细讨论超出了本文的范围。

朴素贝叶斯分类器在复杂的情况下工作得非常好，尽管有简化的假设和天真。 这些分类器的优点在于，它们需要少量的训练数据来估计分类所需的参数。 这是文本分类的算法选择。 这是朴素贝叶斯分类器背后的基本思想，你需要开始实验算法。

如果你喜欢这篇文章，一定要为下面的这篇文章鼓掌以示支持，如果你有任何问题，请留言，我会尽力回答。

为了更加了解机器学习的世界，跟我来。这是最好的办法，等我多写点这样的文章就知道了。

也可以在 Twitter ， 直接发邮件给我 或者 在 linkedin 上找我。我很乐意收到你的来信。

乡亲们，祝你们有美好的一天:)

朴素贝叶斯推文极性预测马来西亚第 14 届大选

原文：https://towardsdatascience.com/naive-bayes-tweet-polarity-predictor-on-malaysias-14th-general-election-3a3679094b5e?source=collection_archive---------12-----------------------

马来西亚最具标志性选举的初级数据科学任务

当我第一次在 Udacity 上了解朴素贝叶斯分类器时，我想到了这个迷你项目。NB 上有很多在线教程，但我不知道他们为什么主要做垃圾邮件分类(比如，10 个博客中有 9 个都在写 NB 垃圾邮件过滤)。

那时，我的祖国马来西亚正在迎来她历史上最重要的选举，所以我想出了这个主意，说——我们为什么不在选举前做一个推特分析，使用 NB 作为极性预测器？

由于其简单性，NB 在文本分类和情感分析中是众所周知的算法，但是对于 NLP 上下文中的 NB 来说，最大的缺点是它只对单词的出现感兴趣，而忽略了单词之间的相关性(因此得名“naive”)。因此，通过使用 NB，我们只能从“词汇袋”的角度来看待我们的上下文，考虑发生超过相关性。

NB 在做什么？

简单来说，我想把 NB 解释为一个“向前-向后”的过程。

“向前”的过程——给定这句话在 C1 类中，一个单词 w1 出现的次数是多少？
“逆向”过程— 给定一个单词 w1 包含在句子中，这个句子在 C1 类中的概率是多少？

Naive-Bayes tutorial on Udacity’s course.

这就是为什么出现在 NB 中很重要——某个类中某个单词出现的次数越多，它在我们进行预测时的影响就越大。

Udacity 的本课程中的 NB 教程给出了关于 NB 的简短、简明、清晰的解释。

收集推文

首先，我们需要准备我们的原材料——在这种情况下，我们自己收集 tweets。所以我有一个用于抓取推文的 twitter_scraper.py 脚本。

我使用 tweepy 进行抓取部分，所以需要一个 API 密匙进行授权和设置。在这个项目中，我只是收集了与我最亲爱的总理(哦，对不起，现在是前总理)相关的推文，所以极性分析主要针对我们亲爱的前总理。

你还需要一个听众来倾听收集到的推文流，并决定你想要如何处理它们。在我的例子中，我获取 tweet 并将其传递给 TextBlob 进行极性和主观性评分，并将其写入一个. csv 文件。

最后，把你的听众连接到信息流上，让它为你抓取推文！一旦你收集了足够多的推文，简单地停止这个过程(我只收集了 300 条推文，哈哈)。

经验教训:推文主要是马来语，极性得分只是做得不好。所以最后我决定自己在训练和测试数据上手动标注每条推文的类别——这就是为什么我只收集了 300 条推文。

构建 NB 模型

在进入测试部分之前，我构建了一些东西:

字典——在抓取的推文中出现的所有单词。我只是使用 TextBlob 来标记我的每条 tweet，并收集它们。
频率表——统计每个单词在给定类别中的出现次数，w i 。用每个类别中出现的次数除以单词 w i 的总出现次数，我们得到先验概率——给定一个单词，它在某个类别中出现的概率。或者，P(C|w i )。

我们在数据集中进行了预计算，我们知道:

P(C=0) = 182/300 = 0.6067

P(C=1) = 118/300 = 0.3933

对于 tweet 中的每个单词，从表中检索其频率，并在列表中附加每个类别中每个单词的先验概率:

取所有先验概率的乘积(numpy 在这里通过 prod() 方法做得很好)。你得到两个概率， p0 和 p1 。

将 pk 乘以 P(C=k)就得到后验概率。比较它们，较高的概率决定了推文的类别。

对每条推文重复这个过程，你就可以使用 NB 分类器预测推文的极性了！

调查的结果

Results for my test set

我隔离了 20 条推文作为测试集，NB 分类器达到了 90%的准确率 (18/20 正确)。

让我们看看分类器犯了哪两条推文的错误。

tgok video tu aku tak kesian dkat tun m TP kesian dkat Najib。kesian nampak desperito Sgt nak jatuhkan tun m .

看着视频，我不同情敦·马哈蒂尔，但我同情纳吉布，看到他如此不顾一切地想扳倒敦·马哈蒂尔。

对于理解上下文的我们来说，这条推文很明显属于 0 类，即反纳吉布类，但我们的分类器却相反。

让我们看看哪些词决定了这条推文在分类器中的类别:

视频+ tu + aku + tak + tun + m +纳吉+ nak + tun + m

显然，术语“Tun M”应该组合在一起而不是分开，因为分开它可能传达不同的结果。此外，tweet 中决定的最重要的词应该是“kesian”(怜悯)，我们在决定词中没有看到这个词。

对于我们失败的另一条推文:

国民阵线

对我们来说，这应该属于支持纳吉布的阶层，因为纳吉布的政党国民阵线的标签。然而，在我们的实现中，hashtags 是被清理的，所以在这里要学习的另一课是选择哪些内容要清理，哪些不要清理。

单词“lahanat”(诅咒的一个粗鲁的单词)是我们的分类器将此归类为反纳吉类的主要原因。然而，我将得出结论，这条推文很难分类，因为我们只有两个有意义的词，每个代表一个类别，我们没有任何额外的信息。

结论

总的来说，我应该说 NB 分类器仍然做得相当好，前提是我们只有 300 条人工注释的训练推文。

当然，还有很大的改进空间——首先是增加训练集的大小，但是我现在想不出这个领域有任何其他方法可以自动化注释过程。

令人震惊的是，在选举前，大多数推文都是反纳吉布的。毫无疑问，我们一直认为马来社群仍然会支持纳吉和国阵，但事实证明，推特上的马来网民告诉我们一个不同的故事。

我要说的是，这是我工作和学习的一个有趣而简单的迷你项目，它与我和我的祖国非常相关。此外，写这篇文章有助于澄清我所学到的 NB 的概念，并迫使我用简单的语言来表达它们，就像费曼技巧中建议的那样。所以，让我们期待更多的到来！

对代码感兴趣？通过我的 GitHub 回购结账。

在 Numpy 中使用矩阵点积/具有交互代码的基变化的简单分类

原文：https://towardsdatascience.com/naive-classification-using-matrix-dot-product-change-of-basis-with-interactive-code-in-numpy-4808e5aa955e?source=collection_archive---------5-----------------------

GIF from this website

昨天我研究了标量投影和点积，现在我希望进一步研究矩阵点积/基的变化，再次使用 sklearn 乳腺癌数据集进行简单分类。

请注意，这篇帖子是为了我对线性代数更深入的理解。

矩阵点积的简单/快速复习

Image from this website

因此，上面的图像捕捉到了矩阵点积的数学运算，然而它没有覆盖点积的直觉，这是非常强大的。更多关于点产品背后的直觉的阅读，请访问我以前的博客。

基础变更

Image from this website

在二维情况下，我们的大多数坐标系都是在[1，0]和[0，1]的基矢中。然而，并不总是这样，我们可以用一个简单的基变换来转换矢量的参考点。在数据领域，我将此理解为属性的组合。

分类虚假数据集

假设我们有如上所示的数据聚类，有多种方法来执行分类，但我将只使用两个矢量和矩阵点积来执行分类。现在，我们可以看到，当我们有一个向量[1，0]来捕获每个数据有多少分量轴 y 时(在数据域中，这可以是任何属性，如心跳或血压等)，我们可以使用向量[0，1]来捕获每个数据点如何包含轴 x，这也可以是任何属性。

如上所述，我们可以简单地取每个数据点的结果矩阵的最大自变量。具有更多[1，0]的数据点的最大参数为 0，而另一个数据点的最大参数为 1。(反之亦然，我没有检查，但逻辑保持不变。)

当我们绘制散点图时，使用捕获的 max 参数作为颜色，我们可以看到它已经被很好地分类了。

天真地对乳腺癌数据集进行分类

现在让我们来看一个真实世界的数据使用案例，上面是在获取与乳腺癌结果高度相关的 2 个属性时生成的散点图。(分别是“最差凹点”、“最差周长”，相关矩阵如下所示。)

Target is the outcome

现在，当我们采用完全相同的方法，用一个分类向量来捕捉一个数据点有多少关于最差凹点的信息，用另一个分类向量来捕捉最差周长的信息。以最大值为参数，我们得到如下结果。

之所以创建这个图表，是因为我们制作的边界线如下图所示。

我们可以观察我们选择的两个粉色分类向量。

围绕 1 对乳腺癌数据集进行分类

解决这一问题并获得更好结果的一种方法(尽管不完美)是使用单个矢量点，执行标量投影，并设置一个阈值来制作边界线。

这不是最好的解决方案，但却是更好的解决方案。

在乳腺癌数据集分类上做了大约 2 个工作

第二种方法是简单地改变基向量，正如上面看到的，当我们相对于 y 轴翻转所有的数据点时，我们可以得到类似上面的结果。换句话说，我们将基向量改为[-1，0]和[1，0]。x 轴现在被求反。(使用下面的代码。)

现在，我们可以简单地采用与第一步完全相同的方法。

如上所述，通过取两个向量[0，0.5]和[1，0]的点积，并取最大自变量，我们可以得到更好的结果。

互动码

要访问这篇文章的代码，请点击这里。

遗言

这么多这些强大的东西被隐藏在机器学习这个术语之外，用高级 API 工作很有趣。但是他们没有给你洞察力。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

与此同时，请在我的 twitter 这里关注我，并访问我的网站或我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 pos t。

参考

如何乘矩阵？(2018).Mathsisfun.com。检索于 2018 年 7 月 5 日，来自https://www.mathsisfun.com/algebra/matrix-multiplying.html
sk learn . datasets . load _ breast _ cancer-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。检索于 2018 年 7 月 5 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . datasets . load _ breast _ cancer . html # sk learn . datasets . load _ breast _ cancer
标题？，C. (2018)。从 Numpy 数组创建 Pandas DataFrame:如何指定索引列和列标题？。堆栈溢出。2018 年 7 月 5 日检索，来自https://stack overflow . com/questions/20763012/creating-a-pandas-data frame-from-a-numpy-array-how-do-I-specify-the-index-column
控制图形美学-seaborn 0 . 8 . 1 文档。(2018).Seaborn.pydata.org。检索于 2018 年 7 月 5 日，来自 https://seaborn.pydata.org/tutorial/aesthetics.html
绘制对角线相关矩阵——seaborn 0 . 8 . 1 文档。(2018).Seaborn.pydata.org。检索于 2018 年 7 月 5 日，来自https://seaborn . pydata . org/examples/many _ pairwise _ correlations . html
matplotlib？，H. (2018)。如何改变用 matplotlib 绘制的图形的大小？。堆栈溢出。检索于 2018 年 7 月 5 日，来自https://stack overflow . com/questions/332289/how-do-you-change-the-size-of-figures-drawn-with-matplotlib
熊猫。data frame . plot . scatter—pandas 0 . 23 . 1 文档。(2018).Pandas.pydata.org。检索于 2018 年 7 月 5 日，来自https://pandas . py data . org/pandas-docs/stable/generated/pandas。DataFrame.plot.scatter.html
法，一.(2018)。使用 pandas plot 方法设置图形大小时不一致。堆栈溢出。检索于 2018 年 7 月 5 日，来自https://stack overflow . com/questions/42215252/consistency-when-setting-figure-size-using-pandas-plot-method
可视化-pandas 0 . 23 . 1 文档。(2018).Pandas.pydata.org。检索于 2018 年 7 月 5 日，来自https://pandas . pydata . org/pandas-docs/stable/visualization . html
可能吗？，P. (2018)。Python 使用 lambda 应用 pd。DataFrame 代替 for 嵌套循环可能吗？。堆栈溢出。2018 年 7 月 5 日检索，来自https://stack overflow . com/questions/19178762/python-using-lambda-to-apply-PD-data frame-instead-for-nested-loop-is-possible
使用标量投影和交互式编码的朴素分类。(2018).走向数据科学。检索于 2018 年 7 月 5 日，来自https://towards data science . com/naive-class ification-using-scalar-projection-with-interactive-code-298279 AFB 11 f
mplot3d 示例代码:scatter 3d _ demo . py—Matplotlib 2 . 0 . 0 文档。(2018).Matplotlib.org。检索于 2018 年 7 月 5 日，来自https://matplotlib . org/2 . 0 . 0/examples/mplot 3d/scatter 3d _ demo . html
调色板？]，H. (2018)。如何使用连续值给散点图着色？].堆栈溢出。2018 年 7 月 5 日检索，来自https://stack overflow . com/questions/39735147/how-to-color-matplotlib-scatter plot-using-a-continuous-value-seaborn-color
numpy.dot()。(2018).www.tutorialspoint.com。检索于 2018 年 7 月 5 日，来自https://www.tutorialspoint.com/numpy/numpy_dot.htm
git add，c. (2018)。git 添加、提交和推送命令合二为一？。堆栈溢出。2018 年 7 月 5 日检索，来自https://stack overflow . com/questions/19595067/git-add-commit-and-push-commands-in-one
标记— Matplotlib 2.2.2 文档。(2018).Matplotlib.org。检索于 2018 年 7 月 5 日，来自https://matplotlib.org/api/markers_api.html
绘制随机生成的分类数据集-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。2018 年 7 月 5 日检索，来自http://sci kit-learn . org/stable/auto _ examples/datasets/plot _ random _ dataset . html
基的变化-HMC 微积分教程。(2018).Math.hmc.edu。检索于 2018 年 7 月 5 日，来自 https://www.math.hmc.edu/calculus/tutorials/changebasis/

使用具有交互式代码的标量投影的朴素分类

原文：https://towardsdatascience.com/naive-classification-using-scalar-projection-with-interactive-code-298279afb11f?source=collection_archive---------8-----------------------

GIF from this website

今天，我想用线性代数中的一个简单概念来进行非常简单的分类。

请注意，这篇帖子是在对线性代数有更深入了解的同时，给我自己的。

点积

Image from this website

这个网站做得非常好，详细描述了什么是点积。如上所述，我把它理解为向量之间每个分量的乘积的总和，相对于它们的方向。因此，如果向量彼此垂直(正交)。乘法是零，数学上的理解应该是余弦法则，但我简单的理解为不同的方向。

标量/矢量投影

Video from calculuscoaches

现在，如果点积测量的是每个矢量分量的大小相乘值的总和。我们可以用这个值除以我们想要投影的向量的长度。这个词可以叫做标量投影，我知道我在解释这个东西时做得很糟糕，所以这是另一个视频。

Video from george soilis

对生成数据的分类

现在让我们把它带到现场，如上所示，让我们想象我们有两个数据点。第一个在左上角，第二个在右下角。现在让我们插入一个新的向量(显示为数据点)到平面中。

现在我们可以观察到两件事情，1)在平面的中心有一个新的数据点，2)左上角的斑点改变了颜色。我们接下来要做的事情非常简单。我们将使用我们拥有的每个数据点对中间的黄色点执行标量投影，根据得到的标量，我们将把数据分成两组。

如上所示，我们设置的阈值是 2.5

有了清晰分离的数据点，我们可以看到，即使“仔细”选择数据点，我们也可以达到很高的精度。但是让我们看看更多的东西，让我们看看我们在哪里划定了界限。

黄点 →选择的分类向量
黑点 →坐标(0，0)的基向量

如上所述，我们可以看到通过给定平面的线性线切割，现在让我们看看当我们设置阈值为 0 时的结果。

当我们将阈值设置为零时，我们可以观察到类似的模式。

真实数据分类

现在让我们使用皮马印第安人糖尿病数据库的数据，当我们绘制属性之间的相关矩阵时。我们可以观察如上所述创建的矩阵。我们将使用两个最高的属性，即葡萄糖和身体质量指数。

当绘制在 2D 平面上时，我们可以观察到类似上面的东西。现在让我们插入分类向量。

同样，我们可以观察到其中一个斑点的颜色变化以及插入的黄点。

最后，对我们的标量阈值进行较小的调整，我们可以得到如上所示的结果。我们已经知道，对每个数据点进行分类是一项非常可怕的工作。

互动码

要获取这篇文章的代码，请点击这里。

最后的话

直到现在，我从未真正体会到点积的力量和全部潜力。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 pos t。

参考

笔记本，P. (2018)。Python & Matplotlib:在 Jupyter Notebook 中进行 3D 绘图交互。堆栈溢出。检索于 2018 年 7 月 4 日，来自https://stack overflow . com/questions/38364435/python-matplotlib-make-3d-plot-interactive-in-jupyter-notebook
mplot3d 教程— Matplotlib 2.0.2 文档。(2018).Matplotlib.org。检索于 2018 年 7 月 4 日，来自https://matplotlib.org/mpl_toolkits/mplot3d/tutorial.html
matplotlib，p. (2018 年)。使用 matplotlib 为不同的分类级别绘制不同的颜色。堆栈溢出。检索于 2018 年 7 月 4 日，来自https://stack overflow . com/questions/26139423/plot-different-color-for-different-category-levels-using-matplotlib
dataframe，S. (2018)。在熊猫数据框架中选择列。堆栈溢出。检索于 2018 年 7 月 4 日，来自https://stack overflow . com/questions/11285613/selecting-columns-in-a-pandas-data frame
matplotlib？，H. (2018)。如何改变用 matplotlib 绘制的图形的大小？。堆栈溢出。检索于 2018 年 7 月 4 日，来自https://stack overflow . com/questions/332289/how-do-you-change-the-size-of-figures-drawn-with-matplotlib
绘制对角线相关矩阵——seaborn 0 . 8 . 1 文档。(2018).Seaborn.pydata.org。检索于 2018 年 7 月 4 日，来自https://seaborn . pydata . org/examples/many _ pairwise _ correlations . html
sk learn . datasets . make _ blobs-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。2018 年 7 月 4 日检索，来自http://sci kit-learn . org/stable/modules/generated/sk learn . datasets . make _ blobs . html # sk learn . datasets . make _ blobs
[已关闭]，H. (2018)。如何用 Python 在一个地块上画一个网格？。堆栈溢出。检索于 2018 年 7 月 4 日，来自https://stack overflow . com/questions/8209568/how-do-I-draw-a-grid-on-a-plot-in-python
NumPy . expand _ dims—NumPy 1.14 版手册。(2018).Docs.scipy.org。2018 年 7 月 4 日检索，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . expand _ dims . html
NumPy . insert—NumPy 1.14 版手册。(2018).Docs.scipy.org。检索于 2018 年 7 月 4 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . insert . html
Numpy？，H. (2018)。如何在 Numpy 中得到向量的大小？。堆栈溢出。检索于 2018 年 7 月 4 日，来自https://stack overflow . com/questions/9171158/how-do-you-get-the-magnitude-of-a-vector-in-numpy
NumPy . mesh grid—NumPy 1.14 版手册。(2018).Docs.scipy.org。检索于 2018 年 7 月 4 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . mesh grid . html
Python？，W. (2018)。Python 中 meshgrid 的用途是什么？。堆栈溢出。检索于 2018 年 7 月 4 日，来自https://stack overflow . com/questions/36013063/what-of-purpose-of-mesh grid-in-python
皮马印第安人糖尿病数据库。(2018).Kaggle.com。检索于 2018 年 7 月 4 日，来自https://www.kaggle.com/uciml/pima-indians-diabetes-database
calculuscoaches.com:理解标量投影的概念。(2018).YouTube。检索于 2018 年 7 月 4 日，来自https://www.youtube.com/watch?v=ziPGBFRSijk
向量微积分:理解点积-更好的解释。(2018).Betterexplained.com。检索于 2018 年 7 月 4 日，来自https://better explained . com/articles/vector-calculus-understanding-the-dot-product/
9 投影。(2018).YouTube。2018 年 7 月 4 日检索，来自https://www.youtube.com/watch?v=0bS5_k86id8&list = plznyisit 9am 7 aclo abca 1 stjz 41 ffwam&index = 9

从多国名字中的字符序列推断性别

原文：https://towardsdatascience.com/name2gender-introduction-626d89378fb0?source=collection_archive---------3-----------------------

Gender Inference from Character Sequences in Multinational First Names using Naïve Bayes and PyTorch Char-RNN

考虑到“约翰”和“辛迪”这两个名字，大多数人会立刻认为约翰是男性名字，而辛迪是女性名字。是这样吗主要是因为我们看到了太多男嫖客和女嫖客的例子，以至于我们的大脑在特定的名字和相应的性别之间建立了潜在的联系？大概吧。

但是名字本身的某些组成部分(它的拼写/字母组合)也在很大程度上决定了它的性别。想想“安迪”和“安迪”这两个名字。他们在发音上是一样的(/ˇn . di/)，但是大多数人在看到拼写时会把“安迪”归类为男性，而“安迪”归类为女性。名字的后缀可以表明名字的性别；然而，规则并不是一成不变的。例如，以 -yn 结尾的名字似乎主要是女性，尽管事实上以 -n 结尾的名字往往是男性；而以 -ch 结尾的名字通常是男性，即使以 -h 结尾的名字往往是女性【1】。不仅仅是后缀，还有更多的字符模式对应着特定的性别分类——这个任务并不简单。

当你考虑到来自世界各地的所有名字的空间时，名字的性别分类变得越来越困难——我到目前为止给出的例子都是从一个标准的美国人的角度来看的。现在让我们来考虑两个印度名字(我几乎没有接触过这种文化):当我看到“Priyanka”和“Srikanth”这两个名字时，我立刻认为 Priyanka 是女性，Srikanth 是男性。这是为什么呢？我们的大脑是如何提取编码在组成一个名字的字符序列中的揭示性别的信息的？

谁在乎呢。

在市场营销、社会科学以及学术界和工业界的许多其他应用中，需要对未知个体的性别进行准确预测。也许一个人的性别最明显、最能说明问题的标志是他们的名字。在通过名字对性别进行分类方面，大多数先前的工作涉及使用已知姓名的大型语料库来给出已知姓名的概率预测。这篇文章试图通过研究名字的方方面面来探索未知名字的空间，特别关注名字中的字符序列，这些方面包含了重要的性别信息。这也是将 ML/DL 应用于实际问题的一次练习。

这个性别分类问题类似于自然语言理解中的一大类问题，但有着本质的不同。对于“猫”和“狗”这两个词，几乎所有人都会把猫归为雌性，把狗归为雄性。

source: https://goo.gl/YZPEjm

这里的核心区别是，当我们阅读“狗”这个词时，我们的大脑将字符序列“d-o-g”翻译成抽象实体的高维表示，即是我们对狗的理解。我们大脑中这种高维表征的一些特征组合，与我们对男性的抽象表征相比，与女性的抽象表征更密切相关；包含性别揭示信息的不是字符序列本身(至少在大部分情况下)。**

当你把性别分类问题从名字抽象到所有的单词时，这个问题就变得更加有趣了。从语言学上来说，许多语言都是用语法性别的概念来构建的，其中语言中的名词类别在形式上与一组离散的性别相关联。在这种语言中，一个单词中的某些字符序列几乎可以确定该单词的语法性别。学习这些字符序列——无论是显式的还是隐式的——是学习语言的固有部分。此外，对这种字符模式的理解可以帮助理解未见过的单词。出于这些原因，研究嵌入字符序列中的信息似乎是语言学和 NLU 的一个有趣且不可或缺的话题，这超出了本文的范围。

方法学

该项目的所有代码可在GitHub://Ellis brown/name 2 gender获得。

** [## ellisbrown/name2gender

在 GitHub 上创建一个帐户，为 name2gender 开发做出贡献。

github.com](https://github.com/ellisbrown/name2gender/)

作为该主题的初始方法，我探索了一种普通的机器学习技术，使用已知与姓名的相关性别高度相关的姓名的硬编码特征(如前面提到的后缀)。这种快速而肮脏的实现实际上能够以最少的工作获得相当好的结果。

这种方法中使用的特性直接取自 NLTK 书籍:

以-a、-e 和-i 结尾的名字很可能是女性，而以-k、-o、-r、-s 和-t 结尾的名字很可能是男性……以-yn 结尾的名字似乎主要是女性，尽管以-n 结尾的名字往往是男性；以-ch 结尾的名字通常是男性，尽管以-h 结尾的名字往往是女性。【1】

Naïve-Bayes features of first name

这些特性被插入到 NLTK naive Bayes 分类器中，以便于训练和测试。

结果

我用 70/30 的训练-测试分割(大约 95k 训练名称，大约 40.6k 测试名称)来训练这个模型。测试精度大约在 85% 左右，对于这个任务来说可以说是相当不错了。

代码使用示例可在naive _ Bayes/demo . ipynb获得。

夏尔-RNN

当然，一个名字中有很多很多的字符模式可能包含性别暗示——尤其是当考虑到我们的全球(世界)名字空间时；当我们有深度学习的时候，试图硬编码每一个可能的模式似乎是荒谬的。在这种情况下，我使用 PyTorch 探索了一种字符级递归神经网络方法，该方法试图学习各种揭示性别的序列，而不必明确指定它们。

张量表示

这里的第一步是弄清楚如何将一个名字表示为一个张量。因为我们的目标是找出组成名字的字母序列中的所有细微差别，所以我们希望分解名字，逐个字符地看。为了表示每个字符，我们创建一个大小为<1 x N_LETTERS> 的一键向量(一个一键向量除了在当前字母的索引处填充 1 之外都填充 0，例如"**c**" = <0 0 **1** 0 0 ... 0>)。

Name/Tensor conversion

另一种方法可能是通过字符在字母表"**c**" = 3中的位置来存储字符的值；然而，这可能导致模型学习我们不希望的字符值中的一些模式(例如，它可能学习到“c”与“a”比与“x”更相似，因为它们在字母顺序上更接近，而实际上没有相似性差异)。

模型定义

然后，我们定义网络模块本身的结构:

source: https://goo.gl/BB7h2A

按照 PyTorch name nationality 分类示例的指导，我们创建了一个简单的网络，其中 2 个线性层在输入和隐藏状态上操作，一个 LogSoftmax 层在输出上操作。我用 128 个隐藏单位【4】。

这是一个非常简单的网络定义，可以通过添加更多的线性图层或更好地塑造网络来进行改进。

RNN Module definition

结果

我再次用 70/30 的训练测试分割法分割数据集(约 95k 个训练名称，约 40.6k 个测试名称)。我能达到的最好的测试精度大约是 75.4%精度。我没有花太多时间调整超参数以获得更好的结果。

数据集— 名称 2 性别/数据/

我扩展了 NLTK 的姓名语料库，增加了更多代表各种文化的数据集，形成了一个大数据集(约 135 万个实例)，包含按性别分类的名字，可以在我的存储库中找到。请参见data/dataset . ipynb了解更多关于我如何将它整合在一起的信息。*注意:*我没有花太多的时间来检查和整理这个数据集，所以它可能并不令人惊讶或特别干净(如果有人关心或有时间，我将非常感谢任何公关！).

改进/清理该数据集可能是最初最有效的改进。此外，使用只包含来自单一文化特性的名称的资料集，在预测该文化特性中的名称方面可能会好得多。**

放弃

值得承认的是，有许多名字，比如我自己的名字(埃利斯)，在两性中几乎一样常见。与世界上出现的频率相反，包含离散标签的数据集更容易遇到，因此我只考虑了这些数据集给出的名称的二进制分类。一个更可靠的方法是结合人群中出现的频率，给出一个更有概率的性别预测。刘的“性别-姓名关联分数”方法可能是一个好方法【3】。性别不明确的名字的存在也限制了性别分类系统所能达到的最好的真实世界的准确性。

此外，在我们的社会中，越来越多的运动开始认可传统的二元男性和女性性别。由于这些努力仍处于起步阶段，包含这些扩大的性别分类的数据很少(如果有的话)，我没有试图将它们纳入这一分析。

我也只考虑用拉丁字母写的名字。对于这篇文章来说，抽象成完全语言不可知的分类是一个非常艰巨的任务。

未来的工作

正如我上面提到的，改进数据集绝对是改进的最佳起点。

对发现名字分类有用的人来说，将这个名字应用到名字的变体的性别分类将是非常有用的。正如刘所说:

昵称、缩写、混乱的名字和用户名经常包含不小的性别暗示。确定提取和使用这些线索来更准确地推断性别的策略是未来工作的一个有希望的方向。”

也有可能精心设计测试方案来更好地代表真实世界的用例。在我的分析中，我认为每个名字出现的可能性都是一样的。一个更好的真实世界数据集可能包括某个名字在世界上出现频率的某种表示。例如，“约翰”的频率比“埃利斯”高得多这种变化会影响测试结果的计算方式，以及整个系统。理想情况下，我们的数据集中应该包含大多数常见的名字。

Name Frequency scheme

对于这样的名字，我们可以简单地查找我们的数据存储中有哪些名字的性别。我们的预测系统将只适用于不常见的名称集。为了测试这个系统设置，我们可以按照频率等级对名字进行排序，并保留 30%最不常用的名字。

参考

****伯德，s .，克莱因，e .和洛珀，e .“6 . 1 . 1 性别鉴定”用 Python 进行自然语言处理:用自然语言工具包分析文本，O'Reilly，2009，【www.nltk.org/book/ch06.html. ****
“语法性别。”维基百科，维基媒体基金会，2017 年 12 月 21 日，en.wikipedia.org/wiki/Grammatical_gender。
刘，w .和露丝，D 名字里有什么？在 Twitter 中使用名字作为性别推断的特征" AAAI 春季研讨会系列 (2013)，2017 年 12 月 21 日https://www . aaai . org/OCS/index . PHP/SSS/SSS 13/paper/view/5744/5908。
用字符级 RNN 对名字进行分类用字符级 RNN 对姓名进行分类，PyTorch Docs，2017，http://py torch . org/tutorials/intermediate/char _ rnn _ classification _ tutorial . html。**

命名实体识别对自然语言处理中的信息抽取有什么帮助？

原文：https://towardsdatascience.com/named-entity-recognition-3fad3f53c91e?source=collection_archive---------4-----------------------

Source: https://hackernoon.com/named-entity-recognition-applications-and-use-cases-c2ef0904e9fe

在阅读这个故事和比较几个著名的图书馆之后，你可以学习如何得到位置和组织。

在自然语言处理中，命名实体识别是提取相关信息的重要方法。对于特定领域的实体，我们必须花费大量的时间进行标注，以便能够识别这些实体。对于一般实体，如名称、位置和组织，我们可以使用预先训练的库，如斯坦福 NER、spaCy 和 NLTK NE_Chunk 来处理它。

使用以下两个脚本进行测试:

从维基百科中截取了斯坦福大学的部分描述

article = "The university was founded in 1885 by Leland and Jane Stanford in memory of \
their only child, Leland Stanford Jr., who had died of typhoid fever at age 15 the previous \
year. Stanford was a former Governor of California and U.S. Senator; he made his fortune as a railroad tycoon. \
The school admitted its first students on October 1, 1891,[2][3] as a coeducational and non-denominational institution."

自建语句检查提取位置实体的行为

article2 = "New York, New York , NY N.Y. new york"

Source : https://nlp.stanford.edu/software/CRF-NER.shtml

斯坦福 NER

斯坦福 NER 是用 Java 实现的。幸运的是，我们可以使用 python 接口来实现我们所需要的。

步骤 1:环境设置

安装 NLTK 库(使用 3.2.5)

pip install nltk==3.2.5

下载斯坦福 NER 图书馆

去 https://nlp.stanford.edu/software/CRF-NER.html[下载最新版本或者这里](https://nlp.stanford.edu/software/CRF-NER.html)[下载](https://nlp.stanford.edu/software/stanford-ner-2018-02-27.zip)(版本:3.9.1)

解压缩下载的 zip 文件，并获得“stanford-ner-3.9.1.jar”(或“stanford-ner.jar”)和分类器文件夹

放到一个特定的目录中(我使用 ner_dir 进行演示)

步骤 2:导入库

import nltkprint('NTLK Version: %s' % nltk.__version__)from nltk.tag import StanfordNERTaggerstanford_ner_tagger = StanfordNERTagger(
    ner_dir + 'classifiers/english.all.3class.distsim.crf.ser.gz',
    ner_dir + 'stanford-ner-3.9.1.jar'
)

第三步:第一次测试

results = stanford_ner_tagger.tag(article.split())print('Original Sentence: %s' % (article))
for result in results:
    tag_value = result[0]
    tag_type = result[1]
    if tag_type != 'O':
        print('Type: %s, Value: %s' % (tag_type, tag_value))

结果:

Original Sentence: The university was founded in 1885 by Leland and Jane Stanford in memory of their only child, Leland Stanford Jr., who had died of typhoid fever at age 15 the previous year. Stanford was a former Governor of California and U.S. Senator; he made his fortune as a railroad tycoon. The school admitted its first students on October 1, 1891,[2][3] as a coeducational and non-denominational institution.Type: PERSON, Value: Leland
Type: PERSON, Value: Jane
Type: PERSON, Value: Stanford
Type: PERSON, Value: Leland
Type: PERSON, Value: Stanford
Type: PERSON, Value: Jr.,
Type: ORGANIZATION, Value: Stanford
Type: LOCATION, Value: California
Type: LOCATION, Value: U.S.

第四步:第二次测试

results = stanford_ner_tagger.tag(article2.split())print('Original Sentence: %s' % (article2))
for result in results:
    tag_value = result[0]
    tag_type = result[1]
    if tag_type != 'O':
        print('Type: %s, Value: %s' % (tag_type, tag_value))

结果:

Original Sentence: New York, New York , NY N.Y. new york
Type: LOCATION, Value: New
Type: LOCATION, Value: York
Type: LOCATION, Value: NY
Type: LOCATION, Value: N.Y.

“纽约”无法标记为位置，因为“，”
第二个“纽约”可以被标记。
“纽约”分别标记为“新”和“纽约”。我们需要自己合并它。
“纽约”不能被标记为位置，因为它是小写字母。

Source: https://spacy.io/

宽大的

第二个图书馆是空间。这是一个非常强大的图书馆，有一个很大的社区。它还支持 GPU 和深度学习实现。

步骤 1:环境设置

安装空间(2.0.11)

pip install spacy==2.0.11

步骤 2:导入库

spacy_nlp = spacy.load('en')

第三步:第一次测试

document = spacy_nlp(article)print('Original Sentence: %s' % (article))
for element in document.ents:
    print('Type: %s, Value: %s' % (element.label_, element))

结果:

Original Sentence: The university was founded in 1885 by Leland and Jane Stanford in memory of their only child, Leland Stanford Jr., who had died of typhoid fever at age 15 the previous year. Stanford was a former Governor of California and U.S. Senator; he made his fortune as a railroad tycoon. The school admitted its first students on October 1, 1891,[2][3] as a coeducational and non-denominational institution.Type: DATE, Value: 1885
Type: GPE, Value: Leland
Type: PERSON, Value: Jane Stanford
Type: PERSON, Value: Leland Stanford Jr.
Type: DATE, Value: age 15 the previous year
Type: ORG, Value: Stanford
Type: GPE, Value: California
Type: GPE, Value: U.S.
Type: ORDINAL, Value: first
Type: DATE, Value: October 1, 1891,[2][3

第四步:第二次测试

document = spacy_nlp(article2)print('Original Sentence: %s' % (article2))
print()
for element in document.ents:
    print('Type: %s, Value: %s' % (element.label_, element))

结果

Original Sentence: New York, New York , NY N.Y. new york

Type: GPE, Value: New York
Type: GPE, Value: New York
Type: GPE, Value: NY N.Y.

既能认出“纽约”
将“纽约”标记为单一位置
无法标记“纽约”

Source: https://geonaut.co.uk/projects/programming/

NLTK 东北 _ 块

NLTK 是另一个著名的 NLP 库。我使用这个库来处理我的第一个 NLP 相关的项目。它包括了许多与自然语言处理相关的方法，如词性标注、句子分词等。

步骤 1:环境设置

pip install nltk=3.2.5

步骤 2:导入库

加载相应的包

import nltkprint('NTLK version: %s' % (nltk.__version__))from nltk import word_tokenize, pos_tag, ne_chunknltk.download('words')
nltk.download('averaged_perceptron_tagger')
nltk.download('punkt')
nltk.download('maxent_ne_chunker')

第三步:第一次测试

NLTK 将单词标记化、词性(POS)标注和命名实体识别分开。因此，我们需要为命名实体识别执行三个函数。

results = ne_chunk(pos_tag(word_tokenize(article)))print('Original Sentence: %s' % (article))
print()
for x in str(results).split('\n'):
    if '/NNP' in x:
        print(x)

结果:

(GPE Leland/NNP)
  (PERSON Jane/NNP Stanford/NNP)
  (GPE Leland/NNP)
  Stanford/NNP
  Jr./NNP
  (PERSON Stanford/NNP)
  Governor/NNP
  (GPE California/NNP)
  (GPE U.S/NNP)
  Senator/NNP
  October/NNP
  ]/NNP

第四步:第二次测试

results = ne_chunk(pos_tag(word_tokenize(article2)))print('Original Sentence: %s' % (article2))
print()
for x in str(results).split('\n'):
    if '/NNP' in x:
        print(x)

结果:

Original Sentence: New York, New York , NY N.Y. new york

  (GPE New/NNP York/NNP)
  (GPE New/NNP York/NNP)
  (ORGANIZATION NY/NNP)
  N.Y./NNP

结论

演示可以在 Jupyter 笔记本中找到。

斯坦福 NER 需要额外的实现来获得实体，如果它包括一个以上的单词。另外，与其他两个库相比，标记的性能是最慢的。

spaCy 似乎是更容易获得实体的库，并且不需要额外的设置。除了 NER，它还支持 GPU 和深度学习方法

NLTK NE_Chunk 需要更多的设置(下载预训练文件)，但这只是一次性的。通过比较其他两个库，结果似乎并不好。

TL；博士

斯坦福 NER

我们在前面的演示中加载了“English . all . 3 class . dist sim . CRF . ser . gz”分类器。可以替换为“English . con ll . 4 class . dist sim . CRF . ser . gz”或“English . muc . 7 class . dist sim . CRF . ser . gz”。如果使用“English . muc . 7 class . dist sim . CRF . ser . gz”，也可以标记日期和时间。

English . all . 3 class . dist sim . CRF . ser . gz:地点、人员和组织
English . con ll . 4 class . dist sim . CRF . ser . gz:地点、人员、组织和杂项
English . muc . 7 class . dist sim . CRF . ser . gz:地点、人员、组织、资金、百分比、日期、时间

空间

如果机器没有 GPU 但安装了 cupy。会抛出错误，提交 bug (spaCy 版本为(2.0.11)。如果计算机没有 GPU，当前的解决方法是卸载 cupy

NLTK NE 组块

通过与斯坦福 NER 和 spaCy 的比较，性能和代码效率不如这些库。

关于我

我是湾区的数据科学家。专注于数据科学、人工智能，尤其是 NLP 和平台相关领域的最新发展。你可以通过媒体博客、 LinkedIn 或 Github 联系我。

用 Scikit-Learn 进行命名实体识别和分类

原文：https://towardsdatascience.com/named-entity-recognition-and-classification-with-scikit-learn-f05372f07ba2?source=collection_archive---------0-----------------------

如何使用 Scikit-Learn 的库为 NER 训练机器学习模型

命名实体识别和分类 (NERC)是一个从非结构化文本中识别信息单元的过程，如名称，包括人、组织和位置名称，以及数字表达式，包括时间、日期、金钱和百分比表达式。目标是开发实用的和独立于领域的技术，以自动检测高精度的命名实体。

上周，我们给介绍了 NLTK 和 SpaCy 中的命名实体识别(NER)。今天，我们更进一步——使用 Scikit-Learn 的一些库为 NER 训练机器学习模型。我们开始吧！

数据

这些数据是特征工程语料库，标注有 IOB 和 POS 标签，可以在 Kaggle 找到。我们可以快速浏览一下前几行数据。

Figure 1

实体基本信息:

地理=地理实体
org =组织
per =人
地缘政治实体
tim =时间指示器
艺术=艺术品
eve =事件
自然现象

内部-外部-开始(标记)

IOB(内、外、始的简称)是标记令牌的常用标记格式。

标签前的 I 前缀表示标签在块中。
标签前的 b 前缀表示标签是块的开始。
O 标记表示令牌不属于任何块(外部)。

import pandas as pd
import numpy as np
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import HashingVectorizer
from sklearn.linear_model import Perceptron
from sklearn.model_selection import train_test_split
from sklearn.linear_model import SGDClassifier
from sklearn.linear_model import PassiveAggressiveClassifier
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report

单个计算机的内存无法容纳整个数据集，因此我们选择前 100，000 条记录，并使用核外学习算法来有效地获取和处理数据。

df = pd.read_csv('ner_dataset.csv', encoding = "ISO-8859-1")
df = df[:100000]
df.head()

Figure 2

df.isnull().sum()

Figure 3

数据预处理

我们注意到在“句子#”列中有许多 NaN 值，我们用前面的值填充 NaN。

df = df.fillna(method='ffill')df['Sentence #'].nunique(), df.Word.nunique(), df.Tag.nunique()

(4544，10922，17)

我们有 4544 个句子，包含 10922 个独特的单词，由 17 个标签标记。

标签分布不均匀。

df.groupby('Tag').size().reset_index(name='counts')

Figure 4

以下代码使用[**DictVectorizer**](http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.DictVectorizer.html#sklearn.feature_extraction.DictVectorizer) 将文本日期转换为向量，然后拆分为训练集和测试集。

X = df.drop('Tag', axis=1)
v = DictVectorizer(sparse=False)
X = v.fit_transform(X.to_dict('records'))
y = df.Tag.valuesclasses = np.unique(y)
classes = classes.tolist()X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.33, random_state=0)
X_train.shape, y_train.shape

((67000，15507)，(67000)，)

核外算法

我们将尝试一些核外算法，这些算法旨在处理太大而无法放入支持**partial_fit** 方法的单个计算机内存中的数据。

感知器

per = Perceptron(verbose=10, n_jobs=-1, max_iter=5)
per.partial_fit(X_train, y_train, classes)

Figure 5

因为标签“O”(外部)是最常见的标签，它会使我们的结果看起来比实际好得多。因此，在评估分类指标时，我们删除了标签“O”。

new_classes = classes.copy()
new_classes.pop()
new_classes

Figure 6

print(classification_report(y_pred=per.predict(X_test), y_true=y_test, labels=new_classes))

Figure 7

带 SGD 训练的线性分类器

sgd = SGDClassifier()
sgd.partial_fit(X_train, y_train, classes)

Figure 8

print(classification_report(y_pred=sgd.predict(X_test), y_true=y_test, labels=new_classes))

Figure 9

多项式模型的朴素贝叶斯分类器

nb = MultinomialNB(alpha=0.01)
nb.partial_fit(X_train, y_train, classes)

Figure 10

print(classification_report(y_pred=nb.predict(X_test), y_true=y_test, labels = new_classes))

Figure 11

被动攻击分类器

pa =PassiveAggressiveClassifier()
pa.partial_fit(X_train, y_train, classes)

Figure 12

print(classification_report(y_pred=pa.predict(X_test), y_true=y_test, labels=new_classes))

Figure 13

上述分类器都没有产生令人满意的结果。很明显，使用常规分类器对命名实体进行分类并不容易。

条件随机字段

CRFs 通常用于标记或解析序列数据，例如自然语言处理和 CRFs 在词性标记、命名实体识别等方面的应用。

sklearn-crfsuite

我们将在数据集上使用 sklearn-crfsuite 训练一个用于命名实体识别的 CRF 模型。

import sklearn_crfsuite
from sklearn_crfsuite import scorers
from sklearn_crfsuite import metrics
from collections import Counter

下面的代码将检索带有词性和标签的句子。感谢托拜厄斯的提示。

class SentenceGetter(object):

    def __init__(self, data):
        self.n_sent = 1
        self.data = data
        self.empty = False
        agg_func = lambda s: [(w, p, t) for w, p, t in zip(s['Word'].values.tolist(), 
                                                           s['POS'].values.tolist(), 
                                                           s['Tag'].values.tolist())]
        self.grouped = self.data.groupby('Sentence #').apply(agg_func)
        self.sentences = [s for s in self.grouped]

    def get_next(self):
        try: 
            s = self.grouped['Sentence: {}'.format(self.n_sent)]
            self.n_sent += 1
            return s 
        except:
            return Nonegetter = SentenceGetter(df)
sentences = getter.sentences

特征提取

接下来，我们提取更多的特征(单词部分、简化的 POS 标签、下方/标题/上方标志、附近单词的特征)，并将其转换为**sklearn-crfsuite**格式——每个句子都应转换为一个字典列表。以下代码摘自 sklearn-crfsuites 官方网站。

def word2features(sent, i):
    word = sent[i][0]
    postag = sent[i][1]

    features = {
        'bias': 1.0, 
        'word.lower()': word.lower(), 
        'word[-3:]': word[-3:],
        'word[-2:]': word[-2:],
        'word.isupper()': word.isupper(),
        'word.istitle()': word.istitle(),
        'word.isdigit()': word.isdigit(),
        'postag': postag,
        'postag[:2]': postag[:2],
    }
    if i > 0:
        word1 = sent[i-1][0]
        postag1 = sent[i-1][1]
        features.update({
            '-1:word.lower()': word1.lower(),
            '-1:word.istitle()': word1.istitle(),
            '-1:word.isupper()': word1.isupper(),
            '-1:postag': postag1,
            '-1:postag[:2]': postag1[:2],
        })
    else:
        features['BOS'] = True
    if i < len(sent)-1:
        word1 = sent[i+1][0]
        postag1 = sent[i+1][1]
        features.update({
            '+1:word.lower()': word1.lower(),
            '+1:word.istitle()': word1.istitle(),
            '+1:word.isupper()': word1.isupper(),
            '+1:postag': postag1,
            '+1:postag[:2]': postag1[:2],
        })
    else:
        features['EOS'] = Truereturn featuresdef sent2features(sent):
    return [word2features(sent, i) for i in range(len(sent))]def sent2labels(sent):
    return [label for token, postag, label in sent]def sent2tokens(sent):
    return [token for token, postag, label in sent]

拆分训练和测试集

X = [sent2features(s) for s in sentences]
y = [sent2labels(s) for s in sentences]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=0)

训练一个 CRF 模型

crf = sklearn_crfsuite.CRF(
    algorithm='lbfgs',
    c1=0.1,
    c2=0.1,
    max_iterations=100,
    all_possible_transitions=True
)
crf.fit(X_train, y_train)

Figure 14

评估

y_pred = crf.predict(X_test)
print(metrics.flat_classification_report(y_test, y_pred, labels = new_classes))

Figure 15

好多了。我们会坚持 sklearn-crfsuite，探索更多！

我们的分类器学到了什么？

def print_transitions(trans_features):
    for (label_from, label_to), weight in trans_features:
        print("%-6s -> %-7s %0.6f" % (label_from, label_to, weight))print("Top likely transitions:")
print_transitions(Counter(crf.transition_features_).most_common(20))print("\nTop unlikely transitions:")
print_transitions(Counter(crf.transition_features_).most_common()[-20:])

Figure 16

解释:地理实体(B-geo)的开头很可能会跟随着地理实体(I-geo)内部的令牌，但是从带有其他标签的令牌过渡到组织名称(I-org)内部会受到巨大的惩罚。

检查状态特性

def print_state_features(state_features):
    for (attr, label), weight in state_features:
        print("%0.6f %-8s %s" % (weight, label, attr))print("Top positive:")
print_state_features(Counter(crf.state_features_).most_common(30))print("\nTop negative:")
print_state_features(Counter(crf.state_features_).most_common()[-30:])

****

Figure 17

观察结果:

1).该模型了解到，如果附近的单词是“day ”,那么该令牌很可能是时间指示符的一部分。

2).**3.370614 B-per word.lower():president**模型了解到令牌“president”可能在人名的开头。

3).**-3.521244 O postag:NNP**该模型了解到专有名词通常是实体。

4).**-3.087828 O word.isdigit()**数字可能是实体。

5).**-3.233526 O word.istitle()**带标题的单词可能是实体。

ELI5

ELI5 是一个 Python 包，允许检查 sklearn_crfsuite 的重量。CRF 模型。

检查模型重量

import eli5
eli5.show_weights(crf, top=10)

****

Figure 18

观察结果:

I-entity 必须跟随 B-entity 确实有道理，比如 I-geo 跟随 B-geo，I-org 跟随 B-org，I-per 跟随 B-per，等等。
我们还可以看到，在这个数据集中，一个组织名称后面紧跟着一个人的情况并不常见(B-org → I-per 具有很大的负权重)。
该模型学习了像 O → I-geo、O → I-org 和 O → I-tim 等不可能转换的大的负权重。

为了便于阅读，我们只能检查标签的子集。

eli5.show_weights(crf, top=10, targets=['O', 'B-org', 'I-per'])

Figure 19

或者只检查所有标签的一些特征。

eli5.show_weights(crf, top=10, feature_re='^word\.is',
                  horizontal_layout=False, show=['targets'])

Figure 20

暂时就这样了。我喜欢在 sklearn-crfsuite 和 ELI5 上动手动脚，希望你也是。源代码可以在 Github 找到。祝你一周愉快！

参考资料:

sklearn-crfsuite

ELI5

命名实体识别:应用和用例

原文：https://towardsdatascience.com/named-entity-recognition-applications-and-use-cases-acdbf57d595e?source=collection_archive---------2-----------------------

命名实体识别是一个过程，其中算法将一串文本(句子或段落)作为输入，并识别该串中提到的相关名词(人、地点和组织)。在我们之前的博客中，我们给了你一瞥我们的命名实体识别 API 是如何工作的。在这篇文章中，我们列出了命名实体识别技术的一些场景和用例。

命名实体识别的用例

为新闻提供商分类内容

新闻和出版社每天都会生成大量在线内容，正确管理这些内容对于充分利用每篇文章非常重要。命名实体识别可以自动扫描整篇文章，并揭示其中讨论的主要人物、组织和地点。了解每篇文章的相关标签有助于在定义的层次结构中自动对文章进行分类，并实现顺畅的内容发现。下面的例子说明了这种工作方式。

命名实体识别 API 已经成功地识别了文章的所有相关标签，并且这可以用于分类。

高效搜索算法

假设您正在为一家拥有数百万篇文章的在线出版商设计一个内部搜索算法。如果对于每一个搜索查询，算法最终都要搜索数百万篇文章中的所有单词，那么这个过程将会花费很多时间。相反，如果命名实体识别可以在所有文章上运行一次，并且与这些文章中的每一个相关联的相关实体(标签)被分开存储，这可以大大加快搜索过程。使用这种方法，搜索词将只与每篇文章中讨论的少量实体匹配，从而加快搜索执行速度。

支持内容推荐

命名实体识别的一个主要用例涉及推荐过程的自动化。推荐系统主导着我们在当今世界发现新内容和新想法的方式。网飞的例子表明，开发一个有效的推荐系统可以为媒体公司创造奇迹，让他们的平台更有吸引力，更容易吸引人。对于新闻出版商来说，使用命名实体识别来推荐类似的文章是一种行之有效的方法。BBC 新闻下面的例子展示了类似文章的推荐在现实生活中是如何实现的。这可以通过从特定的文章中提取实体并推荐其他文章来完成，这些文章中提到了最相似的实体。这是一种方法，我们已经有效地用于为媒体行业客户开发内容推荐。

客户支持

有许多方法可以使客户反馈处理过程顺利进行，命名实体识别可能是其中之一。我们举个例子来了解一下过程。如果您正在处理一家在全球有多个分支机构的电子商店的客户支持部门，您会在客户反馈中看到许多提及。比如像这样，

现在，如果您通过命名实体识别 API 传递它，它会提取出实体 Bandra(位置)和 Fitbit(产品)。这可以用来对投诉进行分类，并将其分配给组织内应该处理该投诉的相关部门。

同样，也可能有其他反馈推文，你可以根据它们的位置和提到的产品对它们进行分类。您可以创建一个按不同部门分类的反馈数据库，并运行分析来评估每个部门的能力。

研究论文

在线期刊或出版网站拥有数百万篇研究论文和学术文章。一个主题可能有数百篇论文，只需稍加修改。以结构良好的方式组织所有这些数据会变得非常复杂。在网上“浏览”那么多数据，寻找一个特定的信息可能不是最好的选择。根据相关实体对论文进行分类可以省去浏览大量主题信息的麻烦。例如，可能有大约 20 万篇关于机器学习的论文。如果你根据提取的实体给它们加上标签，你会很快找到讨论使用卷积神经网络进行人脸检测的文章。

非结构化的文本内容富含信息，但是找到相关的内容总是一项具有挑战性的任务。随着来自社交媒体、电子邮件、博客、新闻和学术文章的大量数据，从这些信息中提取、分类和学习变得越来越困难，也越来越重要。对于流程发现，可能有其他 NLP 技术，但是当您希望您的分类数据结构良好时，命名实体识别 API 是您的最佳选择。尝试我们的命名实体识别 API 并亲自检查。如果您对命名实体识别的用例有其他想法，请在下面的评论部分分享。你也可以注册获得一个免费的 API 密匙。

parallel dots AI API，是由 ParallelDots Inc 提供的深度学习支持的 web 服务，可以理解大量的非结构化文本和视觉内容，为您的产品提供支持。您可以查看我们的一些文本分析&视觉智能API并通过填写此处的表格或在 apis@paralleldots.com 给我们写信来联系我们。

基于 keras 和 tensorflow 的命名实体识别(NER)

原文：https://towardsdatascience.com/named-entity-recognition-ner-meeting-industrys-requirement-by-applying-state-of-the-art-deep-698d2b3b4ede?source=collection_archive---------1-----------------------

通过应用最先进的深度学习方法满足行业需求

photo credit: pexels

几年前，当我在一家初创公司做软件工程实习生时，我在一个招聘网站上看到了一个新功能。该应用程序能够识别和解析简历中的重要信息，如电子邮件地址、电话号码、学位头衔等。我开始和我们的团队讨论可能的方法，我们决定用 python 建立一个基于规则的解析器来解析简历的不同部分。在花了一些时间开发解析器之后，我们意识到答案可能不是基于规则的工具。我们开始在谷歌上搜索这是如何做到的，我们遇到了术语自然语言处理(NLP) 以及更具体的与机器学习相关的命名实体识别(NER)** 。**

photo credit: meenavyas

NER 是一种信息提取技术，用于识别和分类文本中的命名实体。这些实体可以是预定义的和通用的，如地点名称、组织、时间等，也可以是非常具体的，如简历中的例子。 NER 在业务中有各种各样的使用案例。我认为 gmail 应用了 NER，当你写邮件时，如果你在邮件中提到时间或附上文件，gmail 会设置日历通知或提醒你附上文件，以防你发送没有附件的邮件。NER 的其他应用包括:从法律、金融和医疗文档中提取重要的命名实体，为新闻提供者分类内容，改进搜索算法等等。在本文的其余部分，我们将简短介绍解决 NER 问题的不同方法，然后我们将开始编写最先进的方法。下面是苏沃洛对 NER 更详细的介绍。

photo credit: pexels

接近 NER

经典方法:大多基于规则。这里有一个链接，链接到 Sentdex 的一个很短很棒的视频，它在 python 中为 NER 使用了 NLTK 包。
机器学习方法:这一类主要有两种方法: A- 把问题当做多类分类，其中命名实体就是我们的标签，这样我们就可以应用不同的分类算法。这里的问题是识别和标注命名实体需要彻底理解句子的上下文和其中单词标签的序列，而这种方法忽略了这一点。 B- 这一类的另一种方法是条件随机场(CRF)模型。它是一个概率图形模型，可用于模拟顺序数据，如句子中单词的标签。关于 CRF 在 python 中的更多细节和完整实现，请参见 Tobias 的 文章。CRF 模型能够捕获序列中当前和先前标签的特征，但是它不能理解前向标签的上下文；这个缺点加上与训练 CRF 模型相关的额外的特征工程，使得它不太适合于工业应用。

photo credit: abajournal

深度学习方法:

在讨论 NER 的深度学习方法(最先进的)的细节之前，我们需要分析适当和清晰的指标来评估我们模型的性能。在不同迭代(时期)中训练神经网络时，通常使用准确度作为评估度量。但是，在 NER 案例中，我们可能会处理重要的金融、医疗或法律文档，准确识别这些文档中的命名实体决定了模型的成功与否。换句话说，**在 NER 任务中，误报和漏报都有商业成本。**因此，我们评估模型的主要指标将是 F1 分数，因为我们需要在精确度和召回率之间取得平衡。

建立高性能深度学习方法的另一个重要策略是，考虑到文本是一种序列数据格式，了解哪种类型的神经网络最适合处理 NER 问题。是的，你猜对了…长短期记忆(LSTM)。此链接中关于 LSTMs 的更多详情。但不是任何类型的 LSTM，我们需要使用双向 LSTM，因为使用标准 LSTM 进行预测只会考虑文本序列中的“过去”信息。对 NER 来说，由于上下文在序列中涵盖了过去和未来的标签，我们需要将过去和未来的信息都考虑在内。双向 LSTM 是两个 lstm 的组合——一个从“右到左”向前运行，一个从“左到右”向后运行。

我们将通过参考实际的研究论文来快速浏览四种不同的最新方法的架构，然后我们将继续实施精度最高的方法。

双向 LSTM-CRFT7**:**

更多细节和 keras 中的实现。

from the paper(Bidirectional LSTM-CRF Models for Sequence Tagging)

2。双向 LSTM-CNN:

更多细节和 keras 中的实现。

from the paper( Named Entity Recognition with Bidirectional LSTM-CNNs)

3。双向 LSTM-CNN-CRF:

from the paper (End-to-end Sequence Labeling via Bi-directional LSTM-CNNs-CRF)

4.ELMo(从语言模型嵌入):

Jay Alammar

最近的一篇论文(深度语境化单词表示)介绍了一种新类型的深度语境化单词表示，它模拟了单词使用的复杂特征(例如，句法和语义)，以及这些使用如何在语言语境中变化(例如，模拟一词多义)。新方法(ELMo)有三个重要的代表:

1.上下文:每个单词的表示取决于使用它的整个上下文。

2。深度:单词表示结合了深度预训练神经网络的所有层。

3。基于字符的 : ELMo 表示完全基于字符，允许网络使用形态学线索为训练中看不到的词汇外标记形成健壮的表示。

ELMo 对语言有很好的理解，因为它是在大规模数据集上训练的，ELMo 嵌入是在 10 亿词基准上训练的。这种训练被称为双向语言模型(biLM)，它可以从过去学习，并预测像句子一样的单词序列中的下一个单词。让我们看看如何实现这种方法。我们将使用来自 kaggle 的数据集。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
plt.style.use("ggplot")data = pd.read_csv("ner_dataset.csv", encoding="latin1")
data = data.drop(['POS'], axis =1)
data = data.fillna(method="ffill")
data.tail(12)words = set(list(data['Word'].values))
words.add('PADword')
n_words = len(words)
n_words**35179**tags = list(set(data["Tag"].values))
n_tags = len(tags)
n_tags**17**

我们的数据集中有 47958 个句子，35179 个不同的单词和 17 个不同的命名实体(标签)。

让我们来看看句子长度在数据集中的分布:

class SentenceGetter(object):

    def __init__(self, data):
        self.n_sent = 1
        self.data = data
        self.empty = False
        agg_func = lambda s: [(w, t) for w, t in zip(s["Word"].values.tolist(),s["Tag"].values.tolist())]
        self.grouped = self.data.groupby("Sentence #").apply(agg_func)
        self.sentences = [s for s in self.grouped]

    def get_next(self):
        try:
            s = self.grouped["Sentence: {}".format(self.n_sent)]
            self.n_sent += 1
            return s
        except:
            return None

这个类负责将每个带有命名实体(标签)的句子转换成一个元组列表[(单词，命名实体)，…]

getter = SentenceGetter(data)
sent = getter.get_next()
print(sent)**[('Thousands', 'O'), ('of', 'O'), ('demonstrators', 'O'), ('have', 'O'), ('marched', 'O'), ('through', 'O'), ('London', 'B-geo'), ('to', 'O'), ('protest', 'O'), ('the', 'O'), ('war', 'O'), ('in', 'O'), ('Iraq', 'B-geo'), ('and', 'O'), ('demand', 'O'), ('the', 'O'), ('withdrawal', 'O'), ('of', 'O'), ('British', 'B-gpe'), ('troops', 'O'), ('from', 'O'), ('that', 'O'), ('country', 'O'), ('.', 'O')]**sentences = getter.sentences
print(len(sentences))**47959**largest_sen = max(len(sen) for sen in sentences)
print('biggest sentence has {} words'.format(largest_sen))**biggest sentence has 104 words**

所以最长的句子有 140 个单词，我们可以看到几乎所有的句子都少于 60 个单词。

这种方法最大的好处之一是我们不需要任何特征工程；我们所需要的是句子和它的标记词，剩下的工作由 ELMo embeddeds 继续进行。为了将我们的句子输入到 LSTM 网络中，它们都需要一样大。看分布图，我们可以把所有句子的长度设置为 50 并为空格添加一个通用词；这个过程叫做填充。(50 是个好数字的另一个原因是我的笔记本电脑无法处理更长的句子)。

max_len = 50
X = [[w[0]for w in s] for s in sentences]
new_X = []
for seq in X:
    new_seq = []
    for i in range(max_len):
        try:
            new_seq.append(seq[i])
        except:
            new_seq.append("PADword")
    new_X.append(new_seq)
new_X[15]**['Israeli','officials','say','Prime','Minister','Ariel',
 'Sharon', 'will','undergo','a', 'medical','procedure','Thursday',
 'to','close','a','tiny','hole','in','his','heart','discovered',
 'during','treatment', 'for','a', 'minor', 'stroke', 'suffered', 'last', 'month', '.', 'PADword', 'PADword', 'PADword', 'PADword', 'PADword', 'PADword', 'PADword', 'PADword', 'PADword', 'PADword',
 'PADword', 'PADword', 'PADword', 'PADword', 'PADword', 'PADword',
 'PADword', 'PADword']**

这同样适用于命名实体，但我们这次需要将标签映射到数字:

from keras.preprocessing.sequence import pad_sequencestags2index = {t:i for i,t in enumerate(tags)}
y = [[tags2index[w[1]] for w in s] for s in sentences]
y = pad_sequences(maxlen=max_len, sequences=y, padding="post", value=tags2index["O"])
y[15]**array([4, 7, 7, 0, 1, 1, 1, 7, 7, 7, 7, 7, 9, 7, 7, 7, 7, 7, 7, 7, 7, 7,7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,7, 7, 7, 7, 7, 7])**

接下来，我们将数据分为训练集和测试集，然后导入 tensorflow Hub(一个用于发布、发现和消费机器学习模型的可重用部分的库)来加载 ELMo 嵌入功能和 keras，以开始构建我们的网络。

from sklearn.model_selection import train_test_split
import tensorflow as tf
import tensorflow_hub as hub
from keras import backend as KX_tr, X_te, y_tr, y_te = train_test_split(new_X, y, test_size=0.1, random_state=2018)sess = tf.Session()
K.set_session(sess)
elmo_model = hub.Module("[https://tfhub.dev/google/elmo/2](https://tfhub.dev/google/elmo/2)", trainable=True)
sess.run(tf.global_variables_initializer())
sess.run(tf.tables_initializer())

第一次在代码块上运行需要一些时间，因为 ELMo 差不多有 400 MB。接下来，我们使用一个函数将我们的句子转换为 ELMo 嵌入:

batch_size = 32
def ElmoEmbedding(x):
    return elmo_model(inputs={"tokens": tf.squeeze(tf.cast(x,    tf.string)),"sequence_len": tf.constant(batch_size*[max_len])
                     },
                      signature="tokens",
                      as_dict=True)["elmo"]

现在让我们建立我们的神经网络:

from keras.models import Model, Input
from keras.layers.merge import add
from keras.layers import LSTM, Embedding, Dense, TimeDistributed, Dropout, Bidirectional, Lambdainput_text = Input(shape=(max_len,), dtype=tf.string)
embedding = Lambda(ElmoEmbedding, output_shape=(max_len, 1024))(input_text)
x = Bidirectional(LSTM(units=512, return_sequences=True,
                       recurrent_dropout=0.2, dropout=0.2))(embedding)
x_rnn = Bidirectional(LSTM(units=512, return_sequences=True,
                           recurrent_dropout=0.2, dropout=0.2))(x)
x = add([x, x_rnn])  # residual connection to the first biLSTM
out = TimeDistributed(Dense(n_tags, activation="softmax"))(x)model = Model(input_text, out)
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

由于我们的批处理大小为 32，因此必须以 32 的倍数为单位向网络提供数据:

X_tr, X_val = X_tr[:1213*batch_size], X_tr[-135*batch_size:]
y_tr, y_val = y_tr[:1213*batch_size], y_tr[-135*batch_size:]
y_tr = y_tr.reshape(y_tr.shape[0], y_tr.shape[1], 1)
y_val = y_val.reshape(y_val.shape[0], y_val.shape[1], 1)history = model.fit(np.array(X_tr), y_tr, validation_data=(np.array(X_val), y_val),batch_size=batch_size, epochs=3, verbose=1)**Train on 38816 samples, validate on 4320 samples
Epoch 1/3
38816/38816 [==============================] - 834s 21ms/step - loss: 0.0625 - acc: 0.9818 - val_loss: 0.0449 - val_acc: 0.9861
Epoch 2/3
38816/38816 [==============================] - 833s 21ms/step - loss: 0.0405 - acc: 0.9869 - val_loss: 0.0417 - val_acc: 0.9868
Epoch 3/3
38816/38816 [==============================] - 831s 21ms/step - loss: 0.0336 - acc: 0.9886 - val_loss: 0.0406 - val_acc: 0.9873**

最初的目标是调整参数以实现更高的精度，但我的笔记本电脑无法处理超过 3 个时期和大于 32 的批量或增加测试规模。我在 Geforce GTX 1060 上运行 keras，花了将近 45 分钟来训练这 3 个纪元，如果你有更好的 GPU，可以通过改变一些参数来尝试一下。

0.9873 的验证准确性是一个很好的分数，但是我们没有兴趣用准确性指标来评估我们的模型。让我们看看如何获得精确度、召回率和 F1 分数:

from seqeval.metrics import precision_score, recall_score, f1_score, classification_reportX_te = X_te[:149*batch_size]
test_pred = model.predict(np.array(X_te), verbose=1)**4768/4768 [==============================] - 64s 13ms/step**idx2tag = {i: w for w, i in tags2index.items()}def pred2label(pred):
    out = []
    for pred_i in pred:
        out_i = []
        for p in pred_i:
            p_i = np.argmax(p)
            out_i.append(idx2tag[p_i].replace("PADword", "O"))
        out.append(out_i)
    return outdef test2label(pred):
    out = []
    for pred_i in pred:
        out_i = []
        for p in pred_i:
            out_i.append(idx2tag[p].replace("PADword", "O"))
        out.append(out_i)
    return out

pred_labels = pred2label(test_pred)
test_labels = test2label(y_te[:149*32])print(classification_report(test_labels, pred_labels)) **precision   recall  f1-score   support

        org       0.69      0.66      0.68      2061
        tim       0.88      0.84      0.86      2148
        gpe       0.95      0.93      0.94      1591
        per       0.75      0.80      0.77      1677
        geo       0.85      0.89      0.87      3720
        art       0.23      0.14      0.18        49
        eve       0.33      0.33      0.33        33
        nat       0.47      0.36      0.41        22

avg / total       0.82      0.82      0.82     11301**

0.82 的 F1 成绩是一个很突出的成绩。它击败了本节开始时提到的所有其他三种深度学习方法，并且它可以很容易地被业界采用。

最后，让我们看看我们的预测是什么样的:

i = 390
p = model.predict(np.array(X_te[i:i+batch_size]))[0]
p = np.argmax(p, axis=-1)
print("{:15} {:5}: ({})".format("Word", "Pred", "True"))
print("="*30)
for w, true, pred in zip(X_te[i], y_te[i], p):
    if w != "__PAD__":
        print("{:15}:{:5} ({})".format(w, tags[pred], tags[true]))**Word            Pred : (True)
==============================
Citing         :O     (O)
a              :O     (O)
draft          :O     (O)
report         :O     (O)
from           :O     (O)
the            :O     (O)
U.S.           :B-org (B-org)
Government     :I-org (I-org)
Accountability :I-org (O)
office         :O     (O)
,              :O     (O)
The            :B-org (B-org)
New            :I-org (I-org)
York           :I-org (I-org)
Times          :I-org (I-org)
said           :O     (O)
Saturday       :B-tim (B-tim)
the            :O     (O)
losses         :O     (O)
amount         :O     (O)
to             :O     (O)
between        :O     (O)
1,00,000       :O     (O)
and            :O     (O)
3,00,000       :O     (O)
barrels        :O     (O)
a              :O     (O)
day            :O     (O)
of             :O     (O)
Iraq           :B-geo (B-geo)
's             :O     (O)
declared       :O     (O)
oil            :O     (O)
production     :O     (O)
over           :O     (O)
the            :O     (O)
past           :B-tim (B-tim)
four           :I-tim (I-tim)
years          :O     (O)
.              :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)
PADword        :O     (O)**

像往常一样，代码和 jupyter 笔记本在我的 Github 上可用。

非常感谢您的提问和评论。

参考资料:

https://www . depends-on-the-definition . com/named-entity-recognition-with-residual-lstm-and-elmo/
http://www . wild ml . com/2016/08/rnns-in-tensor flow-a-practical-guide-and-documentated-features/
https://allennlp.org/elmo
https://jalammar.github.io/illustrated-bert/

使用 Python 中的 Enron 电子邮件数据集识别命名实体:第 2 部分

原文：https://towardsdatascience.com/named-entity-recognition-using-the-enron-email-dataset-in-python-part-2-fb7ce69bc473?source=collection_archive---------13-----------------------

上一次，我们从安然电子邮件数据集中选出了前 20 个最多发邮件的人。

他们是谁？在这份 20 人名单中，至少有两人(约翰·阿诺德和埃里克巴斯)曾经或已经成为对冲基金经理。对于一家破产公司的校友来说，这并不坏，因为有一篇关于这家公司的文章。我个人也曾和安然的前雇员一起工作过，我只和他们有过顶级的经历。

别管历史，让我们进入数据科学。

分散文本

https://github.com/JasonKessler/scattertext

分散文本最初是通过将一个类别与另一个类别进行比较(如共和党人与民主党人)，来找到“非常常见”的单词。相反，我在自己的案例中使用它来比较每个电子邮件发件人与所有其他发件人；一个对所有，而不是一个对一个。

This is from the github readme, that gives just one example of the visualization power of this tool.

为此，我选择不使用可视化工具，而只使用 Pythonic API，它公开了每个类别(在我们的例子中是电子邮件发件人)的 F 分数的计算。

F-scores for each email sender, sorted by top F-scores from “other” category

代码如下:

nlp = spacy.load('en')corpus = st.CorpusFromPandas(df_parsed.sample(10000), 
                              category_col='FromCat', 
                              text_col='Body',
                              nlp=nlp).build()scaled_f_scores_vs_background = corpus.get_scaled_f_scores_vs_background()term_freq_df = corpus.get_term_freq_df()for c in term_freq_df:
    f = c[:c.find(' freq')]
    term_freq_df[f+' fscore'] = corpus.get_scaled_f_scores(f)columns = pd.Series([x[:x.find(' ')] for x in term_freq_df.columns]).drop_duplicates()term_freq_df.columns = pd.MultiIndex.from_product([['freq','fscore'],columns])term_freq_df.loc[:,'fscore'].sort_values('other',ascending=False).iloc[:200].to_excel('fscores.xlsx')

嗯，你可以种开始看到人们之间的关系，通过他们的“不寻常的共同”的话，但它不是那么漂亮或有用。因此，我们将尝试通过从每封电子邮件中提取命名实体来总结电子邮件，然后使用网络图将顶级实体链接在一起。

命名实体识别

至少有三个流行的 python 库具有 NER 功能:1)spaCy2)polyglot和 3) Stanford 的 CoreNLP 。

我在这个项目中尝试使用 spaCy 和 polyglot，但最终选择了 polyglot，因为它的结果更直观。Polyglot 只将实体分为 I-LOC、I-ORG 和 I-PER，而 spaCy 有更多的类别，如数字、日期等。

该代码使用 dask 进行多重处理，在数据帧中添加了一个新的“实体”列。

最后，我们按照前 20 名电子邮件发件人(FromCat)进行分组，并找到他们最常见的实体。下面是一个输出示例:

网络图可视化

好吧。我们真的很亲密。网络图需要节点和边。我们有一个流行实体表，按前 20 名电子邮件发件人分组。因此，在我们的例子中，节点(或者图上的气泡)将是和实体以及电子邮件发送者。为了区分它们，我们将发件人涂成黄色。边将是从每个发送者到他们各自实体的连接。比如上面的克里斯德国，像安然、加州、杰夫、德州等词。会和他联系在一起。

Nodes.json 示例

[{"id":0,"label":"[chris.germany@enron.com](mailto:chris.germany@enron.com)","group":"person"},{"id":1,"label":"[debra.perlingiere@enron.com](mailto:debra.perlingiere@enron.com)","group":"person"},{"id":2,"label":"[drew.fossum@enron.com](mailto:drew.fossum@enron.com)","group":"person"},{"id":3,"label":"[enron.announcements@enron.com](mailto:enron.announcements@enron.com)","group":"person"},{"id":4,"label":"[eric.bass@enron.com](mailto:eric.bass@enron.com)","group":"person"},{"id":5,"label":"[gerald.nemec@enron.com](mailto:gerald.nemec@enron.com)","group":"person"},...]

Edges.json 示例

[{"from":0,"to":21},{"from":1,"to":21},{"from":2,"to":21},{"from":4,"to":21},{"from":5,"to":21},{"from":6,"to":21},{"from":7,"to":21},{"from":8,"to":21},{"from":9,"to":21},{"from":10,"to":21},{"from":11,"to":21},{"from":13,"to":21},{"from":15,"to":21},{"from":16,"to":21},{"from":17,"to":21},{"from":18,"to":21},{"from":19,"to":21},{"from":20,"to":21},...]

Visjs

对于网络图可视化，我们使用了构建在 d3 之上的名为 Visjs 的 javascript 库。它实际上有一个 python 包装器，但是我无法在笔记本中找到或让它工作，所以我只是处理了样本 javascript 代码，并嵌入了来自 pandas 节点和边的数据帧的 json 输出。

现在，如果我们打开静态 html 文件，将会出现如下所示的交互式可视化效果:

由于 Visjs 使用了 d3 物理学，最终发生的情况是最常见的单词(有许多联系的单词)聚集在中间，而“非常常见”的单词成为外围。

例如，Pete Davis 似乎是一名加州电力调度人员，他在电子邮件中使用特定于其调度工作的术语。

通过浏览实体网络，你可以真正开始注意到谁在做什么。马特·伦哈特负责佛罗里达州的业务，而约翰·阿诺德和萨拉·沙克尔顿则谈论涉及巴西的潜在交易。几乎每个人都在谈论 FERC(联邦能源监管委员会)，它负责监管州际贸易。等等，等等…

我们可以利用安然电子邮件数据集做更多的事情，例如训练单词嵌入、对电子邮件进行分类、欺诈交易的异常检测等。然而，在这篇文章中，我想向你展示一个简单的实体网络图在总结一个大的文本语料库时是多么的有用。

你可以在这里找到这个项目的 Github 库:https://github.com/raymondmyu/enron-email-dataset

想看更多请留下评论鼓掌！

基于 NLTK 和 SpaCy 的命名实体识别

原文：https://towardsdatascience.com/named-entity-recognition-with-nltk-and-spacy-8c4a7d88e7da?source=collection_archive---------0-----------------------

Photo credit: Pixabay

NER 在自然语言处理的许多领域都有应用

命名实体识别 (NER)可能是信息提取的第一步，它试图定位文本中的命名实体并将其分类成预定义的类别，如人名、组织、位置、时间表达式、数量、货币值、百分比等。NER 在自然语言处理 (NLP)的很多领域都有应用，它可以帮助回答很多现实世界的问题，比如:

新闻中提到了哪些公司？
投诉或评论中是否提到了特定产品？
推文包含人名吗？推文包含这个人的位置吗？

本文描述了如何使用 NLTK 和 SpaCy 构建命名实体识别器，以识别事物的名称，例如原始文本中的人员、组织或位置。我们开始吧！

NLTK

import nltk
from nltk.tokenize import word_tokenize
from nltk.tag import pos_tag

信息提取

我引用了《纽约时报》的一句话:“欧洲当局周三对谷歌处以创纪录的 51 亿美元罚款，原因是谷歌在手机市场滥用权力，并责令该公司改变做法。”

ex = 'European authorities fined Google a record $5.1 billion on Wednesday for abusing its power in the mobile phone market and ordered the company to alter its practices'

然后，我们对句子应用单词标记化和词性标注。

def preprocess(sent):
    sent = nltk.word_tokenize(sent)
    sent = nltk.pos_tag(sent)
    return sent

让我们看看我们得到了什么:

sent = preprocess(ex)
sent

Figure 1

我们得到一个元组列表，其中包含句子中的单个单词及其相关的词性。

现在，我们将实现名词短语分块，以使用由规则组成的正则表达式来识别命名实体，这些规则指示句子应该如何分块。

我们的组块模式由一个规则组成，即每当组块者找到可选的限定词 DT，后跟任意数量的形容词 JJ，然后是名词 NN 时，就应该形成名词短语 NP。

pattern = 'NP: {<DT>?<JJ>*<NN>}'

组块

使用这个模式，我们创建了一个组块解析器，并在我们的句子上测试它。

cp = nltk.RegexpParser(pattern)
cs = cp.parse(sent)
print(cs)

Figure 2

输出可以读作树或层次结构，S 是第一级，表示句子。我们也可以用图形显示出来。

Figure 3

IOB 标签已经成为在文件中表示块结构的标准方式，我们也将使用这种格式。

from nltk.chunk import conlltags2tree, tree2conlltags
from pprint import pprintiob_tagged = tree2conlltags(cs)
pprint(iob_tagged)

Figure 4

在这个表示中，每行有一个标记，每个标记都有其词性标记和命名实体标记。基于这个训练语料，我们可以构建一个可以用来标注新句子的 tagger 并使用 nltk.chunk.conlltags2tree()函数将标记序列转换成块树。

通过函数 nltk.ne_chunk()，我们可以使用分类器识别命名实体，分类器添加了类别标签，如个人、组织和 GPE。

ne_tree = ne_chunk(pos_tag(word_tokenize(ex)))
print(ne_tree)

Figure 5

谷歌是公认的人。挺让人失望的，你不觉得吗？

空间

SpaCy 的命名实体识别已经在 OntoNotes 5 语料库上进行训练，它支持以下实体类型:

Figure 6 (Source: SpaCy)

实体

import spacy
from spacy import displacy
from collections import Counter
import en_core_web_sm
nlp = en_core_web_sm.load()

我们用的是同一句话，“欧洲当局周三对谷歌处以创纪录的 51 亿美元罚款，原因是其在手机市场滥用权力，并责令该公司改变做法。”

Spacy 的一个好处是我们只需要应用 nlp 一次，整个后台管道将返回对象。

doc = nlp('European authorities fined Google a record $5.1 billion on Wednesday for abusing its power in the mobile phone market and ordered the company to alter its practices')
pprint([(X.text, X.label_) for X in doc.ents])

Figure 7

European 是 NORD(国籍或宗教或政治团体)，Google 是一个组织，51 亿美元是货币值，星期三是日期对象。都是对的。

代币

在上面的例子中，我们在实体级别上工作，在下面的例子中，我们演示了使用罗比标记方案来描述实体边界的令牌级实体注释。

Figure 8 (Source: SpaCy)

pprint([(X, X.ent_iob_, X.ent_type_) for X in doc])

Figure 9

"B"表示令牌开始于实体，"I"表示令牌在实体内部，"O"表示令牌在实体外部，""表示没有设置实体标签。

从文章中提取命名实体

现在，让我们认真对待空间问题，从《纽约时报》的一篇文章中提取命名实体——“在短信中批评特朗普的联邦调查局特工彼得·斯特佐克被解雇了”

from bs4 import BeautifulSoup
import requests
import redef url_to_string(url):
    res = requests.get(url)
    html = res.text
    soup = BeautifulSoup(html, 'html5lib')
    for script in soup(["script", "style", 'aside']):
        script.extract()
    return " ".join(re.split(r'[\n\t]+', soup.get_text()))ny_bb = url_to_string('https://www.nytimes.com/2018/08/13/us/politics/peter-strzok-fired-fbi.html?hp&action=click&pgtype=Homepage&clickSource=story-heading&module=first-column-region&region=top-news&WT.nav=top-news')
article = nlp(ny_bb)
len(article.ents)

188

文章中有 188 个实体，它们被表示为 10 个独特的标签:

labels = [x.label_ for x in article.ents]
Counter(labels)

Figure 10

以下是三个最常见的令牌。

items = [x.text for x in article.ents]
Counter(items).most_common(3)

Figure 11

让我们随机选择一句话来了解更多。

sentences = [x for x in article.sents]
print(sentences[20])

Figure 12

让我们运行[displacy.render](https://spacy.io/api/top-level#displacy.render) 来生成原始标记。

displacy.render(nlp(str(sentences[20])), jupyter=True, style='ent')

Figure 13

一个错误的分类是联邦调查局。这很难，不是吗？

使用 spaCy 的内置 displaCy visualizer ，上面的句子及其依赖项看起来是这样的:

displacy.render(nlp(str(sentences[20])), style='dep', jupyter = True, options = {'distance': 120})

Figure 14

接下来我们逐字逐句，提取词性，把这个句子词条化。

[(x.orth_,x.pos_, x.lemma_) for x in [y 
                                      for y
                                      in nlp(str(sentences[20])) 
                                      if not y.is_stop and y.pos_ != 'PUNCT']]

Figure 15

dict([(str(x), x.label_) for x in nlp(str(sentences[20])).ents])

Figure 16

命名实体提取是正确的，除了“F.B.I”。

print([(x, x.ent_iob_, x.ent_type_) for x in sentences[20]])

Figure 17

最后，我们将整篇文章的实体形象化。

Figure 18

你自己试试。很有趣！源代码可以在 Github 上找到。星期五快乐！

TowardsDataScience-博客中文翻译-2016-2018-二十七-更多相关文章

今日报告-66

设置Windows10暂停更新3000天

AQS公平锁的流程

AMD锐龙7 7800X3D网游专项测试：竟比i9-13900KS强了15%

常用总线技术基本参数对比

探索图像数据中的隐藏信息：语义实体识别和关系抽取的奇妙之旅

设置Chrome浏览器自动升级

JavaScript – 小技巧 Tips

postgresql在插入数据后怎么获取自增id

EF Core 的基本使用

error: failed to push some refs to 'https://github.com/*******/********.github.io.git'

欧拉降幂

编程语言能力对比

基于机器视觉的小车轨迹控制软件界面展示

随机推荐

【游记】CCPC 济南 2024 游记

AJAX & AXIOS-2024/11/1

验证码处理在自动化测试中的应用

一些学科笑话

NOIP2024模拟赛20 & 11.1 小记

20241101 数据结构与算法期中机试收获

Java，启动！

什么是IT技术

即将到来！

2024/11/1日日志关于JavaScript简介&引入方式以及基础语法的学习

舍得-时间-工作是人的一生最重要的事情-自己要有私房钱-人的一生最重要的事情是书写自己的人生

2.TiUP 部署 DM 集群

原型模式的C++实现

python bytecode解析

09-XSS键盘监听、cookie窃取&文件上传绕过

ubuntu 24.04 部署 mysql 8.4.3 LTS

国标GB28181公网平台LiteGBS国标GB28181视频平台建筑工地无线视频联网监控系统方案

imes完工下线

android 13 更改手机信号调整

BFS(Breath First Search 广度优先搜索)