TowardsDataScience-博客中文翻译-2020-八十五-
TowardsDataScience 博客中文翻译 2020（八十五）
电影推荐系统:第一部分
了解如何使用惊喜库构建推荐系统
查尔斯·德鲁维奥在 Unsplash 上拍摄的照片
简介:
所有的娱乐网站或网店都有几百万/几十亿的商品。对于客户来说，选择正确的产品变得非常困难。在这种情况下，推荐系统进入画面，并通过减少选项来帮助用户找到正确的项目。
什么是推荐系统？
它通过建议一个可能的项目列表来帮助用户选择正确的项目，因此它已经成为电子商务、电影和音乐呈现网站的一个不可或缺的部分，并且这个列表还在继续。它们正在成为近年来变得越来越重要的机器学习的最流行的应用之一。两种最受欢迎的方法是:
1- 基于内容的过滤
2- 协同过滤
在这篇文章中，我们将关注矩阵分解，这是一种协同过滤的方法。
矩阵分解
在协同过滤中，矩阵分解是解决稀疏数据问题的最先进的解决方案，尽管它是从 Netflix 奖挑战赛 开始广为人知的。
图片来自本网站
在协同过滤的情况下，矩阵分解算法通过将用户-项目交互矩阵分解成两个低维度矩形矩阵的乘积来工作。一个矩阵可以被视为用户矩阵，其中行代表用户，列是潜在因素。另一个矩阵是项目矩阵，其中行是潜在因素，列代表项目。”——维基百科
我们将与电影分级数据集 MoiveLens 数据集合作，使用Surprise库“用于推荐系统的 Python scikit”开发一个推荐系统。我们开始吧！
数据
ratings = pd.read_csv('data/ratings.csv')ratings.head()
评分表的屏幕截图
为了从上面的 pandas 数据框加载数据集，我们将使用 load_from_df() 方法，我们还需要一个 Reader 对象，并且必须指定 rating_scale 参数。
数据框必须有三列，依次对应于用户 id、项目 id 和等级。
reader = Reader(rating_scale=(0.5, 5.0))data = Dataset.load_from_df(df[['userID', 'itemID', 'rating']], reader)
评级分布
图 1
项目评级分布
图 2
按用户的评分分布
图 3
惊喜——型号选择
Surprise 是一个 Python scikit，用于构建和分析处理显式评级数据的推荐系统。由 Nicolas Hug 维护。
使用 pip(你需要 NumPy 和一个 C 编译器。Windows 用户可能更喜欢使用 conda):
!pip install numpy!pip install scikit-surprise#For Windows users
conda install -c conda-forge scikit-surprise
我们将比较奇异值分解、NMF、正常预测值、KNN 基本值，并将使用具有最小 RMSE 值的一个。
在我们开始应用之前对算法有一些了解。
1:正态预测器:它根据训练集的分布预测一个随机的评级，假设它是正态的。这是一个基本的算法，不需要做太多的工作，但对于比较精度仍然很有用。
2: SVD: 它是由西蒙·芬克在网飞奖期间推广的，是一种矩阵分解算法。如果不使用基线，它相当于 PMF。
3: NMF: 基于非负矩阵分解，类似于 SVD。
4: KNN 基本:这是一种基本的协同过滤算法方法。
**benchmark = []# Iterate over all algorithms
for algorithm in [SVD(), NMF(), NormalPredictor(), KNNBasic()]:# Perform cross validation
results = cross_validate(algorithm, data, measures=['RMSE'], cv=3, verbose=False)# Get results & append algorithm name
tmp = pd.DataFrame.from_dict(results).mean(axis=0)tmp = tmp.append(pd.Series([str(algorithm).split(' ')[0].split('.')[-1]],index=['Algorithm']))benchmark.append(tmp)**
结果截图
由于奇异值分解具有最小的 RMSE 值，我们将调整奇异值分解的超参数。
使用 GridSearchCV 调整算法参数，找到算法的最佳参数。
SVD 的默认值为:
n _ factors—100 |n _ epochs—20 |lr _ all—0.005 |reg _ all—0.02****
**param_grid = {'n_factors': [25, 30, 35, 40, 100], 'n_epochs': [15, 20, 25], 'lr_all': [0.001, 0.003, 0.005, 0.008], 'reg_all': [0.08, 0.1, 0.15, 0.02]}gs = GridSearchCV(SVD, param_grid, measures=['rmse', 'mae'], cv=3)
gs.fit(data) algo = gs.best_estimator['rmse']print(gs.best_score['rmse'])
print(gs.best_params['rmse'])*#Assigning values* t = gs.best_params factors = t['rmse']['n_factors']
epochs = t['rmse']['n_epochs']
lr_value = t['rmse']['lr_all']
reg_value = t['rmse']['reg_all']**
输出 : 0.8682 {'n_factors': 35，' n_epochs': 25，' lr_all': 0.008，' reg_all': 0.08}
现在，我们有了一组正确的超参数值，让我们将数据分成训练:测试和拟合模型。
**trainset, testset = train_test_split(data, test_size=0.25)algo = SVD(n_factors=factors, n_epochs=epochs, lr_all=lr_value, reg_all=reg_value)predictions = algo.fit(trainset).test(testset)
accuracy.rmse(predictions)**
产量: RMSE: 0.8662
让我们来看看我们的预测是好是坏:
以下函数将创建一个包含以下列的 pandas 数据框:
UID: 用户标识
iid: 项目 id
芮:用户给出的评分
预计:由模型估计的评级
Iu: 用户评分的项目数
UI: 对此项目评分的用户数
err: abs 预测评级与实际评级之间的差异。
**def get_Iu(uid):"""
args:
uid: the id of the userreturns:
the number of items rated by the user
"""try:
return len(trainset.ur[trainset.to_inner_uid(uid)])
except ValueError: # user was not part of the trainset
return 0def get_Ui(iid):"""
args:
iid: the raw id of the itemreturns:
the number of users that have rated the item.
"""try:
return len(trainset.ir[trainset.to_inner_iid(iid)])
except ValueError:
return 0df_predictions = pd.DataFrame(predictions, columns=['uid', 'iid', 'rui', 'est', 'details'])df_predictions['Iu'] = df_predictions.uid.apply(get_Iu)df_predictions['Ui'] = df_predictions.iid.apply(get_Ui)df_predictions['err'] = abs(df_predictions.est - df_predictions.rui)**
最佳预测:
**best_predictions = df_predictions.sort_values(by='err')[:10]**
最佳预测的屏幕截图
最坏的预测:
**worst_predictions = df_predictions.sort_values(by='err')[-10:]**
最差预测截图
最糟糕的预测看起来相当令人惊讶。让我们来看看“3996”项的更多细节，它的评分为 0.5，我们的 SVD 算法预测为 4.4
**df.loc[df['itemID'] == 3996]['rating'].describe()temp = df.loc[df['itemID'] == 3996]['rating']# Create trace
trace = go.Histogram(x = temp.values, name = 'Ratings', xbins = dict(start = 0, end = 5, size=.3))# Create layout
layout = go.Layout(title = 'Number of ratings item 3996 has received', xaxis = dict(title = 'Number of Ratings Per Item'), yaxis = dict(title = 'Count'), bargap = 0.2)# Create plot
fig = go.Figure(data=[trace], layout=layout)
iplot(fig)**
图 4
事实证明，该商品获得的大多数评级都在“3 到 5”之间，只有 1% 的用户评级为“0.5”，有一个用户的评级低于 3。似乎对于每一个预测，用户都是某种离群值并且这个项目被评价的次数很少。
看起来你很喜欢这篇文章！
- 您刚刚阅读了第 1 部分，其中介绍了如何使用 Surprise library 在显式数据上构建模型。
- Part 2 将通过计算 K 处的精度和召回率，然后推荐 K 部电影，来涵盖我们应该推荐多少部电影。
完整的代码，你可以在这里找到 Jupyter 笔记本。
如果你有任何想法或建议，请不吝赐教。你也可以通过 LinkedIn 联系我
编码快乐！
参考资料:
[1]https://surprise.readthedocs.io/en/stable/
[4]https://en . Wikipedia . org/wiki/Matrix _ factorization _(recommender _ systems)
电影观众——通过让他们看电影来教授人工智能情感的案例
电影观众
每一帧都有戏剧性(图片由作者提供)
在不久的将来，我们将被行为和人类一样的人工智能实体所包围。他们将能够用完美的犹豫、俚语和抑扬顿挫来保持对话，与人区别开来。他们将能够与我们互动，准确地知道我们的感受，分析我们的面部表情、肢体语言、用词、语调和眼球运动。这就是今天存在的所有技术，但它缺乏给他们这种个人联系的关键组件。幸运的是，我们已经找到了缺失的部分。我们将通过让机器人看电影来教会它们情感。
电影观众项目的目标是释放电影院内巨大的情感数据财富，以推进情感计算(情感人工智能)。然而，电影对于机器来说难以置信地难以理解。不管我们是否意识到，有许多电影制作惯例是我们认为理所当然的(例如，场景之间的时间推移，对话中的戏剧音乐，蒙太奇)。我们人类可以理解这些如何影响一部电影，但机器人能吗？
Moviegoer(以及任何数据科学项目)的第一步是将电影及其所有的艺术细微差别和潜规则转化为结构化数据。我已经建立了一个原型，它将电影分解成机器可以理解的组件。然后，它可以使用这些结构化数据来定位特定类型的场景，跟踪电影中角色的情绪，并识别重要的对话节奏。我稍后将进入更多细节，但让我们更多地讨论为什么电影是训练情感人工智能模型的理想选择。
作为情感资料的电影
每一帧都有戏剧性(图片由作者提供)
所有机器学习和人工智能模型都是通过在大量数据上接受训练来“学习”的。给一个图像识别模型展示一百万张猫的图像，和一百万张非猫的图像，它将能够看到一张新的图像并告诉你这是不是一只猫。模型准确性在很大程度上依赖于拥有大量高质量的训练数据。为了训练一个情感人工智能模型，我们需要大量的情感数据。
电影是 20 世纪最伟大的艺术形式，它通过使用情节和人物来传达心理体验和情感转化。人物是建立起来的，那些人物出了事，那些人物就变了。电影在时间上是线性的:我们可以看到情绪前因(或行为刺激)的直接因果关系。例如，如果我们看到一个角色微笑，然后两秒钟后我们看到他们皱眉，我们想知道在那两秒钟里发生了什么让他们皱眉。我们看对话，看到有人对这个角色说，“我恨你”。我们刚刚了解到这个短语对情绪有负面影响。
但是我们可以更进一步:如果我们看几十万部电影，寻找我们遇到“我恨你”的所有时间，会怎么样？该模型可以分析面部表情的变化，以了解典型人类对这句话的反应。通常是负面的，但如果角色乐在其中呢？也许接下来我们会看到台词是如何传达的，说话者微笑着，大笑着，并保持着愉快的语调？我们刚刚了解了这个短语的表达方式，它并不总是在生气的时候说出来。然后我们可以看看周围的环境，也许这是为了回应一个老掉牙的爸爸笑话。情感模型知道这些都是对“我恨你”这句话的有效应用和反应。
人文拟态
每一帧都有戏剧性(图片由作者提供)
如果这个论题看起来太专业了，让我们试试一个更抽象的例子。假设我们有一个拥有人类身体的机器人，它想要融入社会。要做到这一点，它可以看一堆电影，学习基本的人类习惯。走，不要跑。在交谈中进行眼神交流。别忘了眨眼。电影，即使没有情节或人物发展，也是人类习性的镜头。机器人只需要观察这些就能模仿人类的行为。
在某种程度上，这难道不是我们学会做人和参与社会的一部分吗？想想电影对你自己童年发展的影响。你有没有假装自己是电影中的某个角色，重复他们的俏皮话？想象自己从恐怖分子手中拯救世界，或者在雪花飘落时爱上一个完全陌生的人？当然，电影有助于我们对世界的理解(尽管可能没有我们希望的那么激动人心)。
四类理解
每一帧都有戏剧性(图片由作者提供)
电影是为人类制作的。它们不是设计来被机器观看的。也就是说，要“看电影”，计算机必须理解四种理解。
- 结构——尽管观众完全认为电影是理所当然的，但电影是由称为“场景”的精细、独立的单元组成的，这些单元通常发生在固定的地点，涉及一个或多个角色。机器必须能够识别单个场景的开始和结束。这种类型的分析可以扩展到其他单元，从形成整部电影的三个行为，一直到单个镜头。
- 角色——每个角色都有一张独特的脸和声音，可以在整部电影中追踪。这些有助于预测角色的人口统计数据(年龄、种族、性别)。为了理解角色的动机，口语对话必须归因于单个角色，以确定对他们来说什么是重要的。
- 情节和事件——一部电影由许多不同的事件和事件组成。机器人必须理解特定事件的重要性(例如，恋爱对象得到了另一半，竞争对手得到了升职，女儿受伤)以及它们如何影响角色目标。
- 风格特征——这些是艺术选择，如镜头长度或配色方案，用来引发观众的特定情绪。乐谱是最突出的例子——虽然我们知道这种音乐实际上并不存在于场景中，但它被分层放在它的上面，以使观众感到悲伤、兴奋、紧张或其他多种情绪。这使我想到…
董事决定
现在，你明白我在寻找非常细微的线索，知道它们对情绪反应很重要。但这些细节并不是偶然进入最终剪辑的。它们是导演最大化其电影情感反应的结果。虽然观众几乎看不到，但导演有意识地决定加入这些细节。
识别这些线索(并将它们编码到项目中)在很大程度上依赖于电影制作领域的知识。这些经验法则是从一个多世纪的风格和技术进步中发展而来的，需要对这门手艺有深刻的理解。
这篇文章中的所有电影画面都来自我制作和导演的一部完整长度的电影——10 点开始(一部 90 分钟的喜剧，你可以免费观看)。这个项目本质上是对电影进行逆向工程的一次尝试，了解电影是如何制作的对这项工作有很大帮助。
(图片由作者提供)
现在我们已经回顾了这个项目背后的动机和方法，我们可以看看电影观众原型的运行情况。使用下面的链接浏览原型发布的三篇文章。
电影观众原型发布
将人工智能移至现实世界
了解人工智能应用的整个生命周期，从构思到部署。
罗伯特·北原惠子·桑塔纳在 Unsplash 上拍摄的照片
如果你符合这些条件之一，这篇文章就是为你准备的:
● 你是一名数据科学经理。你想通过一些最佳实践来提高团队的工作效率。
● 你是数据科学家。你想知道下游发生了什么:你的模型如何变成产品。
● 你是一名软件架构师。您正在设计或扩展一个支持数据科学用例的平台。
我最近完成了一个在线课程，我想你应该看看。叫做全栈深度学习。它涵盖了人工智能应用的整个生命周期，从构思到部署，但不包括理论或模型拟合。如果你是一名中级数据科学家，想要从你的领域“缩小范围”，本课程将向你展示香肠是如何制作的，从一个站点到下一个站点进行跟踪。
该课程最初是 2018 年基于旧金山的昂贵训练营，但现在免费提供。一些业界重量级人物也在其中，包括特斯拉的安德烈·卡尔帕希(Andrej Karpahy)和 fast.ai 的杰瑞米·霍华德。我拿它是因为我想把我自己的做法和名人的做法进行比较。作为背景介绍，我是咨询公司 Genpact 的合伙人。我帮助客户使用人工智能改造他们的流程，有时甚至改造他们的业务。在实践中，这意味着我创建一个概念证明(POC)来展示潜在价值，然后运行实施该解决方案的团队来获取该价值。
“全栈深度学习”超出了我的预期。它分为六个内容领域，以及人工智能名人的实践实验室和客座讲座。以下是我发现的最新颖、最有用的内容:
1.设置 ML 项目
斯文·米克在 Unsplash 上拍摄的照片
这是一个“执行”模块，讨论人工智能项目的规划、优先排序、人员配备和时间安排。
我在这里没有发现太多新的东西，但这是一个很好的、简明的执行概述。由于该课程侧重于深度学习，而不是传统的 ML，因此它提出了三个要点:
●深度学习(DL)与更传统的机器学习不同，“仍在研究中”。你不应该计划 100%的成功率
●如果你正从“经典”ML“毕业”到 DL，计划在标签上花费比你习惯的更多的时间和金钱…
●…但是不要扔掉你的剧本。在这两种情况下，你都在寻找廉价预测将产生巨大商业影响的环境
2.基础设施和工具
这是我发现最有帮助的模块。它为开发 AI/ML 应用程序建立了一个全面的框架，从实验室到生产。在每一层或每一类别中，它都涵盖了关键功能、它如何与其他层相适应以及主要的工具选择。
让我强调一下:这门课的不同之处在于框架的全面程度。大多数公开的 AI/ML 内容都集中在模型开发上。有些资料只涉及数据管理或部署。商业供应商经常低估过程的复杂性并跳过一些步骤。如果你试图理解从阿尔法到欧米茄的 AI/ML 管道，这是我见过的最“全景”的图片。
这个课程是“自以为是的”——它有时称之为“类别赢家”，这在你下注时很有帮助。例如，它将 Kubernetes 称为“资源管理”类别的获胜者。我同意这些呼吁中的大部分，但不是全部。例如，在云提供商中，它认为 AWS 和 pans Azure 有“糟糕的用户体验”。虽然 AWS 很优秀，但我们的一些客户(正确地)选择了 Azure，尤其是那些已经拥有微软堆栈(Excel、MS SQL 等)的客户。)
在建立了总体框架之后，本模块将深入探讨发展和培训/评估。我发现三个领域特别有趣:
● 原型制作:我一直在寻找快速简单的方法为客户创建概念证明(POCs)。我需要制作一个视觉上有吸引力的，交互式的概念验证，易于通过公共或半公共的网址访问。我的理想解决方案是给我对模型的代码级控制，而不是让我编写大量的 HTML 或 Javascript 代码。一键式部署是一个优势。我一直在使用 Shiny，但想用 Python 做类似的事情。该课程向我介绍了 streamlit ，我将进一步研究它。同样有意思的还有破折号，奇怪的是没有盖。
● 实验管理是一个有趣的类别:它跟踪你的模型在各种配置选项(实验)下的表现。我为在 Kaggle 上的比赛编写了自己的版本。我不知道这是一个有名字的类别。我将检查本课程推荐的一些工具，包括权重和偏差。
● 一体机:在所有可用的一体机平台之间进行了一次很好的信息比较。AWS SageMaker 和 GCP AI 看起来是目前最好的选择。如果被追问，我敢打赌其他人将被云提供商收购或抄袭。
3.数据管理
文斯·维拉斯在 Unsplash 上的照片
本模块讨论如何存储和管理与管道相关的数据集。我在这里没发现多少新东西。关于数据增强的材料很有趣，但主要应用于计算机视觉，这方面我做得不多。
4.机器学习团队
照片由 Matteo Vistocco 在 Unsplash 上拍摄
本模块讨论项目的人力资源部分:角色、团队结构、管理项目等。在我看来，这些内容属于上面的模块 1——建立 ML 项目。
对于招聘经理和应聘者来说，如何在这个领域找到工作有一些有趣的地方。对于 ML 项目中的典型角色也有一个很好的总结:
5.培训和调试
史蒂文·勒勒姆在 Unsplash 拍摄的照片
本模块讨论让模型在实验室中工作的过程。它应该是每个数据科学家的必读之作，类似于我用来赢得几场 Kaggle 竞赛的工作流。您还可以在许多其他地方获得此内容，但这是一个组织良好且简洁的演示文稿:
围绕调试 DL 模型的讨论尤其精彩:让您的模型运行起来，对单个批处理进行过度拟合，并与已知结果进行比较。为了说明深度，下面是关于单批过量灌装的小节:
关于过度拟合的更多提示在文章末尾。
6.测试和部署
本模块讨论如何将您的模型从实验室带到现实世界。这是我上课时最初寻找的模块。我在这里找到了几个有用的金块:
测试 ML 系统与测试传统软件非常不同，因为它的行为是由数据和算法驱动的:
您需要相应地调整您的测试套件。这门课程提供了一个很好的清单，摘自现在很有名的论文机器学习系统中隐藏的技术债务。
本课程建议您检查培训时间和生产时间变量是否具有近似一致的分布(上面的监控测试 3)。这是一次关键的考验。它可以帮助您检测运行时错误，例如数据馈送中的空白。它还可以告诉您，可能是时候重新训练模型了，因为输入与您预期的不同。实现这一点的一个简单方法是逐个变量地绘制培训数据与生产时间数据。Domino 数据实验室工具可以做到这一点。
一个更好的方法是使用 对抗验证 :训练一个辅助模型(在生产中)，该模型试图将一个观察分类为属于训练或生产数据。如果这个模型成功地区分了这两者，你就有了一个显著的分布转移。然后，您可以检查模型，找出推动这种转变的最重要的变量。
对 Kubernetes 和 Docker 以及基于 GPU 的模型服务的介绍很好地涵盖了部署。
客座演讲
该课程包括来自行业重量级人物的客座演讲。质量变化很大。有些演讲者是经过打磨和准备的，其他的……就没那么多了。我印象最深的是两位客人:
●fast . ai的杰瑞米·霍华德 :这个演讲在提高模型性能方面提供了很多“你可以利用的消息”。
Fast.ai 库旨在使用更少的资源(人力和机器)来获得良好的结果。例如，花 25 美元在 3 小时内训练 ImageNet。这种对效率的关注非常符合我们客户的需求。
o Howard 问道“为什么人们试图让机器学习自动化？”我们的想法是一起工作可以得到更好的结果。他称之为“AugmentML”对“AutoML” Platform.ai 就是一个例子。它是一种标签产品，允许贴标机与神经网络进行交互式“对话”。每次迭代都会改进标签和模型。我从来没见过这样的，而且好像很管用，至少在他分享的视频上是这样的。
o Howard 分享了一些提高模型性能的技巧，尤其是对于计算机视觉任务。我发现测试时间增加 (TTA)特别令人大开眼界。我将不得不在我的下一个项目中尝试它。
● 特斯拉的安德烈·卡帕西:这个演讲也很有趣，尽管音频不是很好。卡帕西讨论了他的软件 2.0 概念，即我们将越来越多地使用梯度下降等优化方法来概率地解决问题，而不是设计固定的软件规则或启发式方法来解决问题。像许多其他人一样，我发现这个心理模型很有吸引力。
离别的思绪
课程并不完美。很多这种材料是在 2018 年创作的，开始显示出它的年龄。三个例子:
●Salesforce.com 大学的首席科学家 Richard Socher 主张建立一个统一的 NLP 模型，叫做 decaNLP。 BERT 已经接管了这个利基市场，而 GPT3 是一个令人兴奋的最新发展。
● 模型可解释性在过去的几年中发展迅速，但是没有得到很好的体现
●如上所述，微软 Azure 一直在大步前进，在我看来并没有得到公平的对待
尽管有这些小问题，我认为这门课程在一个紧凑和组织良好的框架中包含了很多价值。价格合适，我推荐给任何有兴趣了解 AI/ML 应用程序是如何构建的人。
最后，没有特别的原因，我希望你会喜欢这个激动人心的结论:
用 Python 进行移动平均线技术分析
使用 Python 计算和绘制移动平均值
移动平均线通常用于技术分析，以预测未来的价格趋势。在本帖中，我们将使用 Python 构建一个脚本来执行移动平均线技术分析。
克里斯·利维拉尼在 Unsplash 上的照片
什么是均线？
移动平均线是 n 最后收盘价的平均值。要选择的最后收盘价 n 的数量取决于进行分析的投资者或分析师。一种常见的方法是取 20 天，这基本上是一个月的交易天数。
天数越短，移动平均线对价格变化越敏感。也就是说，如果我们选择更大的天数，短期波动将不会反映在指标中。然而，通过选择大量的日期，我们可能会由于忽略短期波动而错过一些即将到来的价格变化。
下面我们可以看到简单移动平均线是如何计算的 (source Investopedia )。
移动平均公式
如何解读均线和交叉
金融分析师和投资者可以使用移动平均线来分析价格趋势，并预测未来的趋势变化。在价格上升趋势中，价格高于移动平均线。在价格下降趋势中，价格低于移动平均线。当收盘价穿过移动平均线时，投资者可以将其视为价格趋势的潜在变化。
我们可以在不同的时间段使用多个移动平均线。例如，我们可能有 20 天的短期移动平均线和 250 天的长期移动平均线。当短期移动平均线穿过长期移动平均线时，可能是价格趋势变化的标志:
- 当短期移动平均线穿越长期移动平均线上方时，这可能表明一个 买入 信号。这就是所谓的黄金交叉。
- 相反，当短期移动平均线低于长期移动平均线时，可能是卖出的好时机。这就是所谓的死叉。
使用 Python 进行移动平均线技术分析
现在我们已经了解了如何计算和解释移动平均线，我们准备用 Python 构建这个技术分析工具。我们的目标是有一个脚本，我们将通过任何公司，我们想分析和我们的功能将:
- 首先，从名为financialmodeliongprep的免费 API 金融源下载股票价格信息。
- 第二，我们将解析来自 API 的结果，并将其转换为包含最近 1200 个交易日的日期和收盘价的 Pandas DataFrame 。
- 第三，我们将计算 20 和 250 日移动平均线。
- 最后，我们将通过 在 matplotlib 图中将收盘价和均线绘制在一起，来结束我们的均线技术分析 。
我们需要做的第一件事是导入所有需要的包，创建我们的 stockpriceanalysis 函数，并向 API 端点发出 http 请求，以获取过去几年的收盘价。
我们就以苹果为例。请注意，API 端点 url 将我们想要获取数据的公司的股票代码作为参数。在我们的例子中，它将是我们传递给函数的参数(例如 Apple 的 aapl)。
然后，我们可以解析响应，只保留最近 1200 天的价格如果您想更详细地了解如何解析和处理 API 响应，请查看下面的文章。
现在，我们在 stockprices 变量中有一个字典，包含 1200 个数据点以及日期和收盘价。我们使用 pd 将其转换成熊猫数据帧。data frame . from _ dict()方法，并将日期设置为索引。
*import requests
import pandas as pd
import matplotlib.pyplot as plt
def stockpriceanalysis(stock):
stockprices = requests.get(f"https://financialmodelingprep.com/api/v3/historical-price-full/{stock}?serietype=line")
stockprices = stockprices.json()
#Parse the API response and select only last 1200 days of prices
stockprices = stockprices['historical'][-1200:]
#Convert from dict to pandas datafram
stockprices = pd.DataFrame.from_dict(stockprices)
stockprices = stockprices.set_index('date')*
如果现在我们打印我们的股票价格数据帧，我们得到下面的响应:
苹果股票价格
很好，我们现在可以计算 20 天和 250 天的移动平均线了。我选择 20 天作为短期移动平均线，因为 20 个交易日或多或少代表一个月。而 250 个交易日大约代表一年。您可以随意更改分析的天数。
使用滚动方法并通过窗口(即天数)作为参数，使用 Pandas 很容易计算移动平均值:
*import requests
import pandas as pd
import matplotlib.pyplot as plt
def stockpriceanalysis(stock):
stockprices = requests.get(f"https://financialmodelingprep.com/api/v3/historical-price-full/{stock}?serietype=line")
stockprices = stockprices.json()
#Parse the API response and select only last 1200 days of prices
stockprices = stockprices['historical'][-1200:]
#Convert from dict to pandas datafram
stockprices = pd.DataFrame.from_dict(stockprices)
stockprices = stockprices.set_index('date')
#20 days to represent the 22 trading days in a month
stockprices['20d'] = stockprices['close'].rolling(20).mean()
stockprices['250d'] = stockprices['close'].rolling(250).mean()*
绘制移动平均线
现在我们已经计算了收盘价、 20 日和 250 日移动平均线、我们可以使用 matplotlib 将它们绘制在一个图表中。然后，我们添加一个标题，并使轴紧密，以加强情节布局。
*import requests
import pandas as pd
import matplotlib.pyplot as plt
def stockpriceanalysis(stock):
stockprices = requests.get(f"https://financialmodelingprep.com/api/v3/historical-price-full/{stock}?serietype=line")
stockprices = stockprices.json()
#Parse the API response and select only last 1200 days of prices
stockprices = stockprices['historical'][-1200:]
#Convert from dict to pandas datafram
stockprices = pd.DataFrame.from_dict(stockprices)
stockprices = stockprices.set_index('date')
#20 days to represent the 22 trading days in a month
stockprices['20d'] = stockprices['close'].rolling(20).mean()
stockprices['250d'] = stockprices['close'].rolling(250).mean()
stockprices[['close','20d','250d']].plot(figsize=(10,4))
plt.grid(True)
plt.title(stock + ' Moving Averages')
plt.axis('tight')
plt.ylabel('Price')*
如果我们运行股票价格分析函数并传递 苹果 股票报价作为参数，我们将得到一个图表，其中显示了苹果过去几个月的移动平均价格和收盘价:
*stockpriceanalysis('aapl')*
通过观察图表，我们可以看到我们对苹果的移动平均线技术分析的结果。
我们可以观察到 20 天移动平均线和最新收盘价之间的交叉。这是一个很好的迹象，表明上升趋势已经结束，价格下降趋势正在开始。
应使用基本工具进行进一步分析，以证实这种潜在的价格趋势变化。在我以前的一些帖子中，你可以找到一些使用 Python 的基本金融分析工具。
包扎
我们构建了一个非常强大的工具，使用 20 天和 250 天的移动平均线用 Python 执行简单的技术分析。该脚本可以用于为其他公司执行分析，只需将公司股票作为我们函数的参数进行传递。
很高兴通过我的 Twitter 账户获得您的反馈。
你也可以看看下面的视频教程，我一步一步地解释代码:
原载于 2020 年 2 月 29 日 https://codingandfun.com*。***
Python 中的移动平均线
熊猫的简单、累积和指数移动平均线
在 Unsplash 上由 Austin Distel 拍摄的照片
移动平均线通常与时间序列一起使用，以平滑随机的短期变化，并突出显示数据中的其他成分(趋势、季节或周期)。移动平均值也称为滚动平均值，通过对 k 个时间段内的时间序列数据进行平均计算得出。移动平均线在金融中广泛用于确定市场趋势，在环境工程中广泛用于评估污染物浓度等环境质量标准。
在本文中，我们简单解释一下最常见的均线类型:(1)简单均线 (SMA)，(2)累积均线 (CMA)，(3)指数均线 (EMA)。此外，我们展示了如何用 Python 来实现它们。为此，我们使用了来自公开数据巴塞罗那的两个数据集，包含巴塞罗那从 1786 到 2019 的降雨量和气温。
我们开始吧！💪
数据预处理
在本文中，我们将使用开放数据巴塞罗那中的两个数据集:(1) 巴塞罗那市自 1780 年以来的月平均气温；以及(2) 巴塞罗那市自 1786 年以来的月累计降雨量。你可以通过以下链接轻松下载。
[## 巴塞罗那市自 1780 年以来的月平均气温-巴塞罗那公开数据
巴塞罗那市自 1780 年以来的月平均气温。温度以摄氏度(°C)为单位。
open data-a jument . Barcelona . cat](https://opendata-ajuntament.barcelona.cat/data/en/dataset/temperatures-hist-bcn) [## 巴塞罗那市自 1786 年以来的月累积降雨量-巴塞罗那公开数据
巴塞罗那市自 1786 年以来的月累积降雨量。降水量以毫米为单位。
open data-a jument . Barcelona . cat](https://opendata-ajuntament.barcelona.cat/data/en/dataset/precipitacio-hist-bcn)
从 Open Data Barcelona 下载两个 CSV 文件后，我们可以使用 pandas.read_csv 函数将它们加载到 Pandas 数据框中，并使用 pandas 可视化前 5 行。data frame . head方法。
****
如上所示，两个数据集都包含月度数据。
数据集最常见的问题是错误的数据类型和缺失值。我们可以使用 熊猫轻松分析这两者。DataFrame.info 方法。此方法打印数据框的简明摘要，包括列名及其数据类型、非空值的数量、数据框使用的内存量。
****
如上所示，数据集不包含空值，数据类型是预期的类型，因此不需要重要的清理任务；但是，它们包含月度数据，而不是年度值。我们计算年平均气温和年累积降雨量如下。
****
如您所见，我们将 year 列设置为数据框的索引。此外，我们已经删除了月度数据，因为我们将在可视化中仅使用年度值。因此，我们有两个数据框，包含(1)巴塞罗那的年平均气温和(2)年累积降雨量。
现在，我们用线图来显示这两个时间序列。
- 巴塞罗那的年平均气温
- 巴塞罗那的年累积降雨量
正如您所观察到的，可视化中有许多波动和噪声，但是我们有一个解决方案来平滑这两个时间序列:移动平均线👐
让我们深入了解💜
简单移动平均线
****简单移动平均是前 M 个数据点的未加权平均值。M(滑动窗口)的选择取决于所需的平滑量，因为增加 M 的值以精度为代价改善了平滑。
对于一系列值，我们计算时间段 t 的简单移动平均值如下:
时间段 t 的简单移动平均线
计算简单移动平均线最简单的方法是使用 熊猫。 法连载。该方法提供了数据上的滚动窗口。在生成的窗口中，我们可以使用统计函数(在这种情况下是平均值)进行计算。窗口的大小(周期数)在参数窗口中指定。
返回序列的第一行包含空值，因为滚动至少需要 n 个值(在 window 参数中指定的值)才能返回平均值。我们可以通过修改参数 min_periods 来改变这种行为，如下所示。
接下来，我们计算在 10 年和 20 年期间的简单移动平均值(窗口大小)，在所有情况下选择最小周期数 1。如下图所示，我们将移动平均值添加到现有数据帧中( df_temperature 和df _ rain)。
将移动平均值添加到数据帧后，我们使用线图绘制结果。以下图表显示了平均气温和累积降雨量以及 10 年和20 年移动平均值。请注意移动平均线是如何平滑数据的，让我们可以正确地看到趋势方向。
****
正如你所观察到的，气温呈现上升趋势，自 1975 年以来尤其高。相反，自 1850 年以来，累积降雨量一直保持不变。
最后，我想指出的是，您可以将滚动方法与其他统计功能一起使用。下表显示了您可以使用滚动方法来计算滚动窗口计算的一些函数。
累积移动平均线
累积移动平均值是到当前时间 t 之前的值的未加权平均值
简单移动平均线有一个恒定尺寸 M 的滑动窗口。相反，当计算累积移动平均值时，窗口大小随着时间的推移而变大。****
我们可以使用 熊猫来计算 Python 中的累积移动平均值。编法。这个方法给出了聚合函数的累积值(在这个例子中是平均值)。和以前一样，我们可以用参数 min_periods 指定返回值所需的最小观察次数(默认值为 1)。
下图显示了扩展方法的工作原理。
正如您所观察到的，扩展方法包括计算中当前行之前的所有行。
现在，我们用熊猫计算累积移动平均值，将结果添加到现有数据帧中。
下面的图显示了气温和累积降雨量的累积移动平均值。
****
****累积移动平均值在计算平均值时会考虑所有之前的值。因此，它们不是分析趋势的好选择，尤其是对于长时间序列。简单移动平均线更适合此目的。但是，所有数据点的权重相等。为了突出显示最近的观察结果，我们可以使用指数移动平均线，它将更多权重应用于最近的数据点，对变化做出更快的反应。
指数移动平均线
指数移动平均线是一种广泛使用的过滤噪音和识别趋势的方法。每个元素的权重随着时间的推移而逐渐降低，这意味着指数移动平均给予最近的数据点更大的权重。这是在最近的数据比旧数据更相关的想法下完成的。与简单移动平均线相比，指数移动平均线对变化反应更快，因为对最近的变动更敏感。
计算时间段 t 的指数移动平均线的代数公式为:
其中:
- xₜ 是在时间段 t. 的观测值
- EMAₜ 是时间段 t. 的**指数移动平均线**
- α 是平滑因子。平滑因子的值介于 0 和 1 之间，表示应用于最近时段的权重。
对于指数平滑，Pandas 提供了 pandas。series . ewm方法。我们可以在 alpha 参数中直接指定平滑因子。或者，我们可以用质心、跨度或半衰期来表示。
下图显示了 ewm 方法如何计算指数移动平均。在这种情况下，我们设置参数 alpha 等于 0.1 ，参数 adjust 等于 False 。如您所见，计算中使用了时间段 t-1 的均线，这意味着在计算时间段 t 的均线时，包括了截至当前时间的所有数据点。但是，最早的数据点对计算的影响最小。
现在，我们用平滑因子 0.1 和 0.3 计算指数移动平均线。如前所述，我们将移动平均值添加到现有数据帧中( df_temperature 和 df _ rain)。
下图显示了平均气温和累积降雨量以及指数移动平均值。
****
如上所示，小的加权因子 α 导致高度平滑，而较大的值提供对最近变化的更快响应。
下图显示了 15 个数据点的简单移动平均值和指数移动平均值的权重(alpha=0.3，adjust=False)。
正如您所观察到的，简单移动平均线对所有数据点的权重相等。
相反，指数移动平均线给予最近的数据点更大的权重。
然而，最后一个重量 w₁₄ 比 w₁₃ 高。原因是用于计算最后重量的公式不同，如下所述。
熊猫。Series.ewm 方法提供了指数权重的两种变体。如果我们设置参数 adjust=False ，我们将使用代数公式计算指数移动平均线。
对于时间步长 0、1、2 和 3，我们得到以下结果:
如上所示，这相当于使用权重:
如您所见，最后的权重 i=t 是使用不同的公式计算的，其中 (1-α)^i 没有乘以 α。
或者，如果我们设置 adjust=True (默认值)，我们使用权重 wᵢ=(1-α)^i 来计算指数移动平均，如下所示:
在这种情况下，使用相同的公式计算所有权重。
最后，我想指出的是，指数移动平均线不仅用于过滤噪音和识别趋势，也是处理时间序列时的一种预测方法。用于预测的最佳平滑因子 α 是最小化 MSE (均方误差)的因子。
如您所见， Pandas 提供了多个内置方法来计算移动平均值🙌。滚动法提供了数据的滚动窗口，让我们很容易获得简单移动平均线。我们可以使用展开法计算累积移动平均值。扩展窗口将包括计算中当前行之前的所有行。最后，我们可以用 ewm 方法计算指数移动平均线**。要计算其他类型的移动平均线，我们可以只使用 Python 编程，或者使用第三方库，如 Alpha Vantage。**
我希望你喜欢这篇文章✋
阿曼达💜
在大都市之间移动:数据故事和分析仪表板
关于美国主要城市和大都市区之间流动的研究
我们多年来一直听说旧金山和纽约等大城市的房价过高，导致居民奔向经济发展中更实惠的地区。然而，这些新兴城市的大规模增长给现有居民带来了压力，迫使他们也搬到其他地方。这项研究利用了来自美国社区调查的最新地铁到地铁迁移流量数据，并将提供对以下问题的见解:
-大多数居民留在原地不动的大都市地区
-在同一大都市区内迁移的居民最多的大都市区
-迁入或迁出该地区的居民最多的大都市地区，以及他们来自或去往的地方
-国际居民迁入最多的大都市地区
虽然这份报告将提供一些高层次的见解，但我已经建立了一个免费的 Tableau 仪表板，使您能够查看特定的迁移指标，并按大都市地区、人口以及州内与州外迁移进行筛选。点击这里，查看免费的迁移模式仪表盘。
来自美国以外的新移民占大都市人口的比例是多少？
硅谷(圣何塞、桑尼维尔和圣克拉拉)由最高比例的国际移民组成，占所有现有居民的 2%。排在硅谷之后的是迈阿密(占总人口的 1.6%)和华盛顿州 DC (1.3%)。另一方面，扬斯敦-沃伦-博德曼都会区只有 0.1%的居民来自国外。田纳西州的查塔努加和阿拉巴马州的伯明翰紧随其后，有 0.2%的人口来自海外。除了犹他州的普罗沃和科罗拉多州的科罗拉多斯普林斯，大多数人口比例最高的城市都位于沿海各州或靠近国际边界。
这张图表显示了哪些地区的当前居民在过去一年中搬家的比例最高，但仍留在同一个大都市区内。
亚利桑那州的 Tuscon 有 15%的人住在 Tuscon。紧随 Tuscon 之后的是内华达州的拉斯维加斯(14%)和俄克拉荷马市(13%)。第四，凤凰城(13%)是排名第二的亚利桑那州大都会区。佛罗里达州的代托纳比奇是该地区内迁居比例最小的(7%)，其次是德克萨斯州的麦卡伦(7.2%)和康涅狄格州的斯坦福(7.2%)。纽约市的地区内搬家率排名第五，为 7.3%。
哪些城市和大都市地区的大多数居民都呆在原地不动，选择呆在自己的家里？
纽约有 90.6%的居民留在他们的居住地。德克萨斯州的麦卡伦(90.2%)和俄亥俄州的扬斯敦(88.6%)紧随其后。另一方面，科罗拉多斯普林斯去年只有 77.7%的居民留在原地。Tuscon (79%)和 Provo (79%)的居民比例也相对较低。
现在，让我们看看一些主要城市，了解居民来自哪里，前往哪里。就像今天看到的一切一样，你可以在 Tableau Public 上查看完全免费的仪表盘。
从纽约、纽约和旧金山、洛杉矶、圣何塞等加州大都市地区迁入奥斯汀的居民基本上是迁入这些地区的前奥斯汀居民的两倍。
奥斯汀的居民正在流失到西雅图(1.5 名前奥斯汀居民迁出，1 名居民迁入)、丹佛(1.4)和亚特兰大(1.2)。
洛杉矶正在输给爱达荷州(每来一个博伊西市居民，就有 7 个前洛杉矶居民搬到博伊西市)。同样，洛杉矶的净移动电话正在流失到俄勒冈州尤金市(5.7)。就原始数据而言，洛杉矶的大量净居民正在流失到拉斯维加斯(-10，042 人)、凤凰城(-6，642 人)和达拉斯(-5，628 人)。洛杉矶市仍在从东海岸的主要城市大幅增加(来自纽约的+5，942 人，来自芝加哥的+2，157 人，来自波士顿的+821 人，来自华盛顿 DC 的+792 人)。
硅谷居民正涌向俄勒冈州波特兰市(每 1 名波特兰居民搬到圣何塞，就有 2.1 名圣何塞居民搬到波特兰)、奥斯汀(每 1 名奥斯汀居民搬到圣何塞，就有 1.95 名圣何塞居民搬到奥斯汀)和德克萨斯州达拉斯市(比例为 1.4)。硅谷仍然从中西部的大城市获得正的净迁移率，如芝加哥(每有一名圣何塞居民搬到芝加哥，就有 3 名芝加哥居民搬到圣何塞)，以及东海岸，如华盛顿、DC 和纽约，在这些地方，搬到圣何塞的居民比搬到相应地区的圣何塞居民多两个以上。
如前所述，大凤凰城地区已经成为洛杉矶等大城市的前居民搬迁的目的地，但腓尼基人选择搬到哪里呢？圣安东尼奥名列榜首，从菲尼克斯到圣安东尼奥的人数是反之的两倍。犹他州的普罗沃紧随其后，每一个普罗沃到菲尼克斯的搬运工就有 1.9 个菲尼克斯到普罗沃的搬运工。排在前五位的城市还有奥斯汀(1.44)、迈阿密(1.4)和纳什维尔(1.35)。
感谢你阅读我最新的数据贴。你可能有兴趣阅读我之前关于 大都市地区各行业就业增长趋势 的帖子。作为一名产品营销和数据分析专业人士，我对数据支持的讲故事充满热情。这些数据新闻帖子是我将真实数据与我个人的不同兴趣整合起来的方式，这些兴趣包括从旅行和娱乐到经济和社会问题的任何事情。
如果您有任何评论、故事想法或预期的数据项目，请随时发送电子邮件至 dwpwriting <邮箱至> gmail < dot > com 或通过LinkedIn联系我。
图片来自Pexels.com
从 Python 迁移到 Java，将您的机器学习模型部署到生产中
当您将 Python 原型迁移到 Java 堆栈时，需要考虑的选项。
Python 是 Python 软件基金会的商标。Java 是 Oracle 和/或其附属公司的注册商标。
我们已经开发了一个系统原型，它在Informatica Mapping Designer中推荐转换。现在，我们想转向生产。原型完全是用 Python 开发的，使用了 scikit-learn 库，这是一个用于开发机器学习模型的流行库，我们也使用了其他 Python 库进行特征提取。另一方面，我们的生产栈是基于 Java 的。此外，其他限制因素有:
- 我们希望快速进入生产阶段，但我们没有时间和资源来进行重大的基础设施开发
- 系统响应时间短，用户界面响应快。
文章的其余部分描述了我们已经考虑过的选项。
我们考虑的第一个选择是通过使用 Jep 或 Jpy 将 Python 代码直接嵌入 Java。虽然 Jython 是一个流行的选项，但这对我们并不适用，因为 scikit-learn 依赖于本机 CPython 扩展，而 Jython 并不支持。此外，我们已经考虑将 Python 代码集成为 web 服务，例如使用 Flask ，但是这将需要维护两个独立的代码库，并引入额外的通信开销。
另一个选择是将模型转换成 Java 代码。模型转换文件(或 transcompile)是一个生成编程代码的过程，其行为方式与输入模型相同，通常是通过在生成的代码中捕获模型参数。我们已经考虑了 sklearn-porter 和 m2cgen ，它们支持多种分类算法，并且可以将 scikit-learn 模型转换成 Java 代码。然而，我们无法成功地移植我们的模型，这可能是因为它们的复杂性，所以我们没有进一步考虑这个选项。
我们考虑的第三个选择是用 H2O 或 Spark 的 MLib 重新开发 sckit-learn 模型，这些流行的机器学习库具有与 sckit-learn 相似的编程接口，并生成可以在 Python 和 Java 中使用的模型。由于 Spark 之前已经在 Informatica 中成功使用过，我们采取了那个方向，使用 Python 的 Spark 库 PySpark 在 Python 中训练模型，然后将它们导出到 Java 中。此外，我们用 Java 重新实现了特征提取代码，并将模型和代码一起部署，然后加载模型并使用它们来提出建议。最后，我们考虑了在嵌入式模式下使用 Spark(仅使用 JAR 依赖项)或建立 Spark 集群之间的选择。我们的测试结果表明，在嵌入式模式下，我们的模型的响应时间是可以接受的，我们将继续这样做。
下表总结了所考虑的方法:
在未来，我们计划利用 Spark 集群并扩大训练环境，以便在更大的数据集上训练模型。此外，我们正在考虑建立一个服务于机器学习模型的基础设施，这可以简化新模型的交付以及现有模型的更新。
谢谢大家！
将我们本地的 Jupyter 笔记本电脑迁移到云上的 GPU——AWS 上的深度学习
不再受本地系统资源的限制，将深度学习工作负载迁移到云 GPU
从 AWS 获取 GPU
让我们为深度学习工作负载创建一个 GPU 实例。为此，我们需要一个 AWS EC2 实例。登录 AWS web 控制台，查找 EC2 服务，点击启动实例。
寻找深度学习 AMI 的。这些是更好的，因为它们预装了 Python3、Jupyter 和许多其他库。选择可能适合您的实例类型。
安全细节
Jupyter 笔记本有两种访问方式:
- 方法 1 —隧道到 EC2 实例(推荐)
- 方法 2 —暴露 HTTP 和 TCP 端口与 Jupyter 对话
对于方法 1，我们只需要安全组中的 SSH 配置。默认情况下，它应该存在，不需要任何更改。
不太推荐方法 2，因为它将实例进一步开放给了互联网。然而，这可以通过 HTTPS 端口 443 和自定义 TCP 端口 8888 来完成。
密钥对/ pem 文件
另一个需要注意的重要步骤是访问用于创建实例的密钥对。如果您没有密钥对，可以在创建时生成一个。如果您决定创建一个密钥，AWS 将为您下载该密钥。
注意:如果有多个团队成员在这个盒子上工作，那么通过 Last pass 或其他密码共享服务来共享密钥对(pem)文件是非常重要的。不要使用电子邮件/ slack 来交换密码/密钥文件。
创建实例
以上是所有的配置，创建实例。这将需要 2-3 分钟。获取创建的机器的 IP 地址。
登录到机器
我们现在可以登录这个盒子-
# The downloaded key-pair (pem) file is more permissive.
# Fix permissions.
# chmod 400 <path to pem file> chmod 400 ~/path/to/key.pem # Get in the box
# ssh -i <path to pem file> -L <local box:port>:<remote box:port> ubuntu@<ec2 ip address> ssh -i ~/path/to/key.pem -L localhost:9999:localhost:8888 ubuntu@11.11.11.11
注意:我建议对上面的命令localhost:9999:localhost:8888使用端口 9999，因为您本地安装的 Jupyter 可能会干扰这个设置。
让 Jupyter 开始
在远程盒(EC2 盒)的端子上启动 Jupyter。建议在屏幕会话中启动 Jupyter，这样您可以关闭终端，Jupyter 服务器仍然保持活动状态。
# Create a new screen session
screen -S jupyter_session # Start Jupyter
jupyter notebook
这应该为我们的 Jupyter 笔记本— [http://localhost:8888/?token=thisisalongsecrettoken](http://localhost:8888/?token=thisisalongsecrettoken.) 提供一个 URL 和一个密码(令牌)。
跑起来
你现在应该可以在你的本地机器上访问 Jupyter 了 http://localhost:9999
我的数据在哪里
你可以从你的终端或通过 python 从 S3(亚马逊推荐的存储)下载你的数据。我在 Google drive 上有我的数据，所以我正在使用这个很酷的实用程序库 googledrivedownloader 将我的数据放入这个盒子。您需要为这个库创建一个 sharabele 链接，链接到 G-Drive 中的数据。lib 也为我们创建子目录和解压数据。
! pip3 install "googledrivedownloader==0.4" from google_drive_downloader import GoogleDriveDownloader as gdd# file_id - id of the sharable link of the file
# from Google Drive. gdd.download_file_from_google_drive(
file_id='1jgSl1thisisafakekeyRleIGpIO3Q',
dest_path='./data/Flikr8k_text.zip',
unzip=True)
清理很重要$$$
确保在不使用时停止/终止实例。否则亚马逊得到$$$。停止实例时，数据将保留在节点存储上，不会向您收费。请阅读官方文件了解更多信息。
重要提示:您的笔记本和下载的数据将在终止实例时被删除，您必须再次完成上述所有步骤。
那是一个包裹
在未来的帖子中，我们将关注亚马逊 Sagemaker，它为数据科学笔记本提供了更加统一的体验。
这就是这篇文章的全部内容。希望对你有用。让模型运行起来。
原载于 2020 年 6 月 13 日https://confusedcoders.com。
MR-隆升:隆升模型中的多重响应
一个建立提升(或异质治疗效果)模型的包，该模型建立并评估多种反应的权衡
简介
原贴于 大楼 Ibotta
在过去几年里，我们在伊博塔建造并部署了多种提升模型。我们以前在博客中描述过一些理论基础和实践建议。在这些文章中，我们讨论了如何评估它们，如何使用特定损失函数来估计它们，以及如何评估几个响应变量之间的权衡。
有了这些来之不易的知识和评估方面的进步，我们决定开源一个 Python 包，名为MR-upgrade。
这篇文章将介绍这个包能做什么，以及它如何成为现有包的有用补充。提供了一个示例和更多资源。
套餐缴费
提升建模(也称为异质或个体治疗效果)是机器学习的一个分支，它学习治疗t和个体x的特定反应y之间的因果关系。一个例子可以是接收特定广告的特定个人的未来活动。
虽然有几个软件包可以建立隆起模型(见【GRF】和因果树)，但它们通常依赖于单一处理和单一响应案例。他们通常不会给出模型在生产中表现如何的估计。此外，没有支持估计几个响应变量之间的权衡。
该软件包试图构建一个用于隆起建模的自动化解决方案，该解决方案通过以下特性来满足 Ibotta 用例的需求:
- MR-Uplift 允许多种治疗。这意味着用户可以在模型中输入任意数量的治疗(不仅仅是通常的二元变量)。此外，可以为每种治疗加入元特征。例如，一种特定的治疗可能与其他治疗有几个共同的特征。用户可以创建分类或连续变量的向量来表示治疗，而不是为每个治疗创建虚拟指标。以这种方式指定治疗变量允许模型考虑治疗之间的相似性。
- 如果模型被部署到生产中，很少有当前的软件包给出关于模型的预期性能的样本外(OOS)估计。MR-Uplift 包括使用爆发度量来估计这一点的功能。此指标计算模型提供给普通用户时的预期反应。
- 支持多重响应。这可能是这个包最独特的特性(也是它现在名字的原因)。该模型有能力建立一个多输出模型，而不是只有一个响应。有了这个，人们可以估计响应变量之间的权衡。我们发现这是一个有用的工具，可以确定我们有哪些可能性，以及在生产中使用哪个目标函数。
MR-Uplift 使用具有均方误差损失的多输出神经网络。虽然可以使用任何类型的多输出模型，但是我发现神经网络可以比基于树的方法更可靠地估计治疗和解释变量的交互作用。
这项工作的一个特别的缺点是它不像因果树那样直接测量治疗效果。扩展模型以包含更具体的损失函数可能会导致性能的提高。此外，由于目前不支持从观察数据中估计治疗效果，因此假设存在针对治疗数据的随机对照试验。
快速示例
如果您不熟悉提升模型，我建议浏览回购中提供的示例。下面是一个生成数据、构建模型和评估权衡的示例。请参见本笔记本了解这个假设示例的更多细节。
假设我们是一家企业的营销人员，希望通过广告增加用户收入(称为治疗)。该数据由随机分配的治疗变量组成，每个用户有四个响应变量:收入、成本、利润和随机噪声变量。这种处理增加了用户收入，但也付出了代价，两者都是解释变量的函数。我们感兴趣的是估计企业可用的响应变量的权衡。下面是生成数据和构建模型的代码。
y、x和t分别是反应、解释和处理变量。注意，每个都被假定为数字类型(分类变量需要一键编码)，但是可以是多列宽。
import numpy as np
import pandas as pdfrom dataset.data_simulation import get_simple_uplift_data
from mr_uplift.mr_uplift import MRUplift#Generate Data
y, x, t = get_simple_uplift_data(10000)
y = pd.DataFrame(y)
y.columns = ['revenue','cost', 'noise']
y['profit'] = y['revenue'] - y['cost']#Build / Gridsearch model
uplift_model = MRUplift()
param_grid = dict(num_nodes=[8],
dropout=[.1, .5],
activation=['relu'],
num_layers=[1, 2],
epochs=[25],
batch_size=[30])uplift_model.fit(x, y, t.reshape(-1,1), param_grid = param_grid, n_jobs = 1)
这将自动应用训练/测试分割，对所有变量应用 z 标度，并构建一个形式为y~f(t,x)的多输出神经网络。
为了查看模型如何执行以及业务可用的权衡，建模者可以应用get_erupt_curves()函数来获得样本外爆发曲线。这些方法通过将各种权重应用于每个预测响应并计算相应的预期响应来估计权衡。
例如，假设我们有一个权重β和目标函数β*revenue-(1-β)*costs。权重β=1对应于收入最大化，β=0对应于成本最小化，β=.5对应于利润最大化。下面显示了在β的各种权重下，预期响应的代码和标绘输出。
erupt_curves, dists = uplift_model.get_erupt_curves()
以上是在成本最小化和收益最大化之间改变目标函数的爆发曲线。随着重量β的增加，成本和收入也会增加。
请注意，噪声响应大约保持在零附近，这是有意义的，因为处理对其没有影响。另请注意，利润响应如预期的那样在β=.5出现最大值。
还有一个“随机”分配曲线。这“打乱”了最佳治疗，然后计算出爆发。比较“模型”线和“随机”线可以看出模型在个体水平上分配治疗的效果。
在实践中，我发现这些图表有助于决定应该如何权衡。涉众可能不知道在更模糊的响应度量之间应该预先进行什么样的相对权衡。这些图表向利益相关者显示了可用的选项，并设置了模型在生产中能够实现和不能实现的预期。
入门
要开始使用 MR-Uplift，请查看 github 回购和示例或pip install mr_uplift。如果您发现任何问题，请提交。更好的是，如果你有希望实现的想法，你可以贡献。
探索性数据分析 Data 十字转门街道交通分析
Metis 数据科学训练营的一个简单的探索性数据分析项目。
保罗·席尔瓦在 Unsplash 上的照片
在 Metis 数据科学训练营的项目 1(新加坡第 5 批)中，我们的任务是对 MTA 十字转门数据进行探索性数据分析(EDA ),为一个虚构的非营利组织 WomenTechWomenYes (WTWY)提供关于社交活动街道团队(在纽约市地铁站入口处)最佳位置的建议。WTWY 希望邀请感兴趣的个人参加其年度晚会，以提高女性对科技的认识和参与度，街头团队的议程是收集尽可能多的电子邮件，并发放晚会的免费门票。在我的分析中，我做了以下假设:
假设
- WTWY 受到时间和人力资源的限制，因此从我的分析中得到的见解应该通过流量来识别顶级站点，以及这些站点中的高峰时段。
- 对科技感兴趣的人更有可能在科技公司办公室密集的市中心遇到。
- WTWY 联欢晚会即将来临，一周的 MTA 十字转门数据被分析作为联欢晚会前几周的样本。
数据探索和清理
MTA 十字转门数据是从 2020 年 8 月 22 日到 2020 年 8 月 28 日这一周收集的。取数据的前几行，我们观察到以下数据框:
为了找到进出每个十字转门的人数，我首先根据以下顺序对数据框中的列进行排序:['UNIT '，' SCP '，' DATE '，' TIME']，然后使用 diff()方法对序列进行排序，我分别对' ENTRIES '和' EXITS '取连续行之间的差值，以形成新列。新的列(命名为“入口 _ 增量”和“出口 _ 增量”)将表示在特定的 4 小时期间通过每个十字转门的入口和出口的实际数量。尽管如此，有些进/出的值要么是负数，要么是天文数字。
进一步的分析表明，这是由于数据帧中 2 个不同十字转门之间的行转换，或者特定十字转门中序列号计数器的重置。为了进行校正，这些异常值随后被替换为进/出的前一个和后一个值的平均值。这种干预是合理的，因为进入/退出可以近似为连续时间段之间的插值。
此后，通过将入口和出口值相加来计算每个时间段内每个十字转门的总交通量。我把这个专栏命名为‘ENTRY _ EXIT’。
结果
现在，我们已经为数据可视化做好了准备，以便为 WTWY 的街道团队的潜在布局获得洞察力！使用 Panda 的 groupby、Matplotlib 和 Seaborn，我接着绘制了一个直方图、条形图和一些热图。
绘制直方图显示纽约市所有 MTA 站的流量分布严重右偏，流量排名前 10 位的站是分布中的异常值。因此，这更清楚地表明 WTWY 可以将他们的参与努力集中在前 10 个电台。
放大，绘制前 10 个车站的条形图显示，34 St-Penn 和 34 St-Herald Square 车站的流量明显高于其他车站，应该优先考虑。
添加一天的维度，绘制一周内前 10 个车站的热图，揭示了与周末相比，人们在工作日更频繁地乘坐地铁旅行的趋势。这一趋势适用于所有 10 个站。
进一步将热图分解为每个站点的白天和时间，揭示了另一个有趣的事实——站点通常在下午晚些时候和晚上更忙，即使在工作日也是如此。这并不奇怪，因为在 Covid 疫情期间，纽约市的许多公司都采用了在家工作的安排，从而避免了早高峰人群。此外，在工作日上午雇用街道小组可能会适得其反，因为其余的重要工作人员将忙于报道工作，不太可能成功接触到他们。
使用另一幅热图，当我们分析每个车站中通勤者的净出入(红色区域表示净出入，蓝色区域表示净出入)时，我们可以确定位于更密集的住宅/酒店区域的车站-Flushing-Main 和 42 St-Port Auth 车站。这一点从他们在晚上的净出口可以看出，这意味着人们正在返回家园。由于这些车站不靠近公司办公室，对技术感兴趣的个人不太可能出现在这些通勤者中。
结论
从我们的分析中，我们可以得出结论，WTWY 应该将他们的街头参与工作集中在排名前 10 位的电视台，最好是在工作日的下午晚些时候到晚上。此外，如果有进一步的人力限制，可以避免 Flushing-Main 和 42 St-Port Auth 站，因为它们是潜在的住宅和旅游区，技术公司办公室不在那里。
最后，我希望我对 MTA 十字转门数据的探索性数据分析产生了有趣的见解，并期待展示 Metis 数据科学训练营即将开展的其他数据项目。敬请期待！
在 GitHub 的这里找到我所有的代码和这个项目的演示幻灯片！
支持我！——如果你是而不是订阅 Medium，并且喜欢我的内容，请考虑通过我的推荐链接加入 Medium 来支持我。
阅读谭·师鹏·阿尔文(以及媒体上成千上万其他作家)的每一个故事。您的会员费直接…
tanpengshi.medium.com](https://tanpengshi.medium.com/membership)
MTA 十字转门数据:探索性数据分析
埃迪·阿吉雷在 Unsplash 上拍摄的照片
Metis 数据科学训练营(新加坡第四批)的第一周刚刚结束，到目前为止，这是一次有趣的经历。下面我将详细介绍我们在那段时间做的第一个项目，这是一个探索性的数据分析，使用 Python 与熊猫和海牛配对来分析 MTA 十字转门数据集。
TL；博士:
- 准备了 2019 年2 月和 3 月的 MTA 十字转门数据，用于一个为夏季晚会报名的活动。
- 通过重命名列、添加计算字段、删除错误数据和按站点和日期聚集来清除数据。
- 发现工作日有最高的流量，但这是一些车站的情况较少；某些日子也有异常交通流量。
- 建议活动集中在工作日客流量高而周末客流量低的车站
- 异常、一天中的时间和应考虑人口统计数据的其他来源，以便进一步分析
这里是到 GitHub 库的链接。
一.背景
女性科技女性是(WTWY)每年初夏都会在纽约市举办一年一度的盛会。他们试图在这个盛会上发挥双重作用，一方面让那些热衷于增加女性在科技领域参与度的人来充实他们的活动空间，另一方面也提高人们的认识和影响力。
为此，他们在纽约地铁站的入口处安排了街头小组。街头团队收集电子邮件地址，注册的人会收到免费的晚会门票。
我们的任务是使用纽约市大都会运输管理局(MTA)的地铁数据来帮助 WTWY 优化他们街道团队的位置，以便他们可以收集最多的签名，最理想的是从那些将参加晚会并为他们的事业做出贡献的人那里收集签名。
二。设置
我们使用了来自 MTA 十字转门的历史数据，决定专注于 2019 年 2 月和 3 月的数据。
- 二月(T0)、二月(T1)和三月(T2)、三月(T3)这两个月似乎是夏季来临前的充足准备时间，让人们能够将春晚安排到他们的日程表中。
- 在 2020 年的这个时候，新冠肺炎疫情正在肆虐，纽约市是世界上最大的热点之一。结果，它被封锁了，这严重扰乱了交通模式，T4 的街道空无一人。这是非常不寻常的情况。如果这是一项真实的研究，我给组织者的建议是完全避免安排街头团队，要么推迟/取消晚会，要么完全转移到网上。出于这个练习的目的，我们假设春晚将发生在 2019 年的夏天。
具体来说，我们从 2019 年 2 月 2 日结束的一周到 2019 年 3 月 5 日结束的一周的十周时间内获取数据，如以下代码片段所示:
我们还决定专注于收集每个站点每天的总流量，忽略条目的时间。可以想象，在数据分析的后续迭代中会添加时间。
三。准备数据
a)列重命名
检查MTA _ test . columns . values，我们注意到数据集的 EXITS 列有一大堆尾随空格:
array(['C/A', 'UNIT', 'SCP', 'STATION', 'LINENAME', 'DIVISION', 'DATE', 'TIME', 'DESC', 'ENTRIES',
'EXITS '],
dtype=object)
所以为了让我们的生活更轻松，我们把它重新命名为:
mta_test.rename(columns={'EXITS ':'EXITS'}, inplace=True)
b)添加计算字段
基于来自 MTA 的字段描述，我们知道入口和出口分别是给定入口和出口点的累积入口和出口寄存器值。因为我们是按天而不是按时间段聚合，所以我们决定分别减去入口和出口的第一个(也就是最小的)和最后一个(也就是最大的)计数器值。
我们还将入口和出口聚合到一个单独的列中，即 TRAFFIC，以及附加的工作日属性，以便于以后按工作日分析数据。我们的结果被放入 mta_entries_exits 中。
这一切的代码片段如下:
c)删除错误数据
当我们按流量对 mta_entries_exits 排序时，我们发现奇怪的大值似乎会打乱数据集:
对数据的进一步分析显示，在 MTA 数据的某些行中，计数器值以无法解释的数量跳跃(如下例所示):
查看入口和出口的分布可以发现，这些值中的大多数都在 20，000 以下:
条目数量的分布
出口数量分布
因此，我们删除了所有大于 20，000 的入口和出口值:
mta_entries_exits = mta_entries_exits[(mta_entries_exits.ENTRIES < 20000) & (mta_entries_exits.ENTRIES < 20000)]
请注意，这将删除特定十字转门一整天的数据。出于初步分析的目的，我们认为这是可以接受的，因为车站的每个入口点都有许多十字转门，通常不止一个入口点；然而，进一步的分析需要数据移除更有针对性。
d)按站点和日期汇总数据
最后，我们按车站和日期汇总了数据，因为我们不是在看单个的十字转门。
mta_bystation = mta_entries_exits.groupby(['STATION','DATE','WEEKDAY', 'WEEKDAY_INDEX']).sum().reset_index()
四。来自数据的见解
a)关注排名前五的电视台
我们发现总流量排名前 5 的站点如下:
- 宾州车站
- 大中央车站
- 先驱广场
- 第 23 街
- 时代广场
我们的建议是将重点放在这 5 个车站。
b)关注工作日
我们发现周末的交通流量比平日少(最多是平时的一半)。总的来说是这样的:
排名前五的电视台也是如此:
我们的建议是在工作日关注。
异常情况
我们注意到并非所有的站点都遵循相同的模式。例如，第 3 至第 5 级车站的工作日交通量更接近周末交通量:
顶部 2 站已移除。注意这些车站的工作日和周末交通有多接近。
这可能是因为这些车站位于旅游区，时代广场就是一个突出的例子。退一步说，这样的短期游客不太可能参加夏季晚会。我们的建议是关注工作日客流量高而周末客流量低的车站。
我们还发现，在排名前五的站点中，至少有一个站点的流量出现了无法解释的下降:
请注意 2019 年 2 月 18 日至 25 日这一周中间的流量下降。
这种下降(或峰值)需要隔离和调查，因为它们可能是由于特殊情况，如公共假期或紧急情况。这也可能是由于之前的数据清理丢失了数据。
动词 （verb 的缩写）进一步的步骤
为了获得进一步的见解，我们可以做以下事情:
- 包括时间栏，以便: a)确定高峰时间，以便 WTWY 知道何时是安排其团队的最佳时间；和 b)通过丢弃特定时间的坏数据而不是一整天的坏数据来减少数据丢失。
- 纳入人口和地理数据以确定通勤者的构成、任何地理相关性等。
不及物动词外卖食品
探索性数据分析的这一练习教会了我们以下内容:
- 检查列名值的重要性；我们花了一段时间才意识到为什么从数据集中提取出口值有困难。
- 使用分布图和过滤器剔除数据中异常值的重要性。
你还有很多要学的
来源:维基百科
我从数据科学优秀竞争的前 5%参与者身上学到的三个教训。
本周末是 2015 年尼泊尔大地震五周年纪念日，那次地震造成约 9000 人死亡。死亡人数如此之高的部分原因是，该国近 2/3 的人住在用泥土、石头、砂浆或木材建造的房子里，而不是钢筋混凝土——这在大多数发达国家是常态。
资料来源:驱动数据，尼泊尔统计局，加德满都生活实验室
这些数字来自尼泊尔统计局和加德满都生活实验室汇编的近 30 万个家庭的数据集，显然是有史以来收集的最大的灾后数据集之一。驱动数据公司(https://www.drivendata.org/)是一家组织类似 Kaggle 的比赛的公司，致力于利用数据科学产生社会影响，该公司已经将数据集作为比赛的一部分。该任务是一个多类分类问题(评估指标= F1 分),根据几个特征(位置、结构、使用等)预测房屋的脆弱性(每栋房屋，1-3 级，3 级为完全破坏)。)
我决定在比赛中试试我的数据科学知识(到目前为止),因为地震发生时我在国外，远离遭受事故的朋友和家人，所以这样做是为了减少对当时未能提供帮助的愧疚感(如果这还不够清楚的话，我是尼泊尔人)。
这篇文章是我学到的三个关键数据科学相关课程的大杂烩，因为我最终成为了比赛中(到目前为止)前 5%的参与者。我只关注了建模部分，并使用了相当多的技术术语，假设如果你正在阅读这篇文章，你对这个行业很熟悉，知道探索性数据分析的重要性，或者例如什么是 f1 分数。
第一课:建立基线
当你开始做模特的时候，你做的第一件事是什么？如果你像我一样，你已经花了很多时间探索数据，创建或选择你认为重要的特征，所以你在你的模型中使用这些特征。这就是我在学校学到的，所以这就是我在比赛中所做的。
问题是，当我使用我创建的功能时，我使用 LightGBM 模型得到了 0.6832 的 F1 分数，这比 Driven Data 的基准 0.58(使用随机森林)要好，但远远低于竞争对手 0.7558 的分数。我知道我甚至不是一个优秀的数据科学家，但我甚至不在排名的前一半！
在尝试了一堆不同的特征选择方法(PCA，Chi2)之后，由于纯粹的挫败感，我干脆扔进了整个数据集(没有任何特征工程或选择)。令我惊讶的是，我的测试分数是 0.7452，使我进入了分数的前四分之一。
因此，我学到的第一课是无意中意识到，如果我简单地通过使用提供的数据集建立了一个基线模型，我将为自己节省许多无济于事的切片和切块的精神折磨。
第二课:承认你的领域知识有限
未篡改数据集给出的分数让我思考为什么我的特征创建和选择不起作用。我的特征不仅是不相关的，因为 LGBM 自己做特征选择，我主动加入了偏见。简单地说，我的特征积极地使分数变得更糟。
这让我开始思考为什么我投入到这些功能中的所有工作都没有带来任何结果。我了解地震吗？不。我了解建筑吗？不。那是什么让我觉得我可以创造特色呢？我被一个有锤子问题的人折磨着…
…让我解释一下。如果我给你一个包含建筑物高度和面积的数据集(大多数情况下是一个矩形)，你能创建什么特征？如果你像我一样天真，你会计算体积，因为 a)你知道它在数学上是合理的，所以你对自己说“我在组合特征，所以它一定有一些相关性”和 b)使用你所知道的感觉很好。
自然地，仅仅因为你知道某件事在数学上是正确的，它并不像变魔术般地与问题相关。数学是世界背后的基础，但控制形状的数学不一定是控制形状如何随着构造板块的运动而变化的数学(另一种数学现象)。
我学到的第二个教训是，在进入任何数据科学项目之前，一个人应该诚实地面对自己对问题领域了解多少。如果时间不是一个因素，那么我们都应该在着手解决问题之前努力去了解这个领域，如果是，在工作中不要试图把我们以前的(可能有偏见的)知识强加给这个问题，要知道结果不会像了解问题领域的人的结果那样准确。
第三课:考虑挤出最后一滴准确性的后果
作为数据科学家，或者更一般地说，作为人类，我们受到必须解决某些问题的时间的限制。您可能正在构建一个推荐引擎，就像您还必须准备一个客户流失模型一样。你如何决定什么样的准确度或 roc 或其他指标对你的客户流失模型来说足够好，这样你就可以转向你的推荐引擎了？
对于 Kaggle 或 Driven Data 这样的竞争，原则上，答案很简单——排名最好的那个。为了便于讨论，让我们认为那是真的。在比赛中给我最高分的过程是这样的:
- 将 3 类预测问题分成 3 个二元问题，例如，如果目标标签是 3(最高伤害),则为 1，如果不是，则为 0。
- 将每个二进制数据集划分为给定的 30 个地理区域，知道一些区域(靠近震中)在地震中总是遭受更多的破坏。因此，如果我想预测地理位置 17 中房屋 x 的潜在损害，我需要一个专门针对该地区的模型。
- 因为每个地理模型被分成 3 类，所以我有 3 * 30 = 90 个不同的模型。对于这 90 个模型中的每一个，都优化了超参数。
- 对于最终预测，我根据预测最大概率的模型选择了类。因此，对于房屋 x，如果类别 1 的模型预测相应的概率为 0%，而模型 2 预测为 30%，模型 3 预测为 70%，则选择的类别为 3。
做了这么多工作，我最终站在了这里:
来源:驱动数据个人主页
我设法以低于领先者 0.0087 的分数进入竞争对手的前 5%。将 0.0087 视为我的模型相对于 leader 模型的预期误差。由于测试集中有 86，868 个家庭，这意味着我的模型平均不到 1%的时间会出现分类错误(与领先模型相比)。
所以，我问你，这是一个好成绩吗？你可能会说是的，但我不敢苟同，原因如下:根据数据集，由于一个中等家庭至少有一个家庭住在里面，我的模型基本上会使 756 个家庭的生活面临风险！现在可以接受了吗？一百万年后也不会。
我的观点是，在这种情况下，0.0087 的分数差异会危及 756 个家庭的生命，在这种情况下，最后一点准确性非常重要。现在考虑一下，如果问题不是预测房屋，而是预测货币收益。当做出价值 86，868 美元的预测时，平均损失 756 美元可以接受吗？我会这么说。
我学到的最后一课是永远考虑追求最后一点准确性的后果。更好的是，考虑后果而不是绝对分数来定义你的模型是否好。
如果你有类似的经验想要分享，请在评论中留下。
对于感兴趣的人，这里有关于驱动数据的比赛链接:
https://www . Driven Data . org/competitions/57/Nepal-seismic/page/134/
多智能体强化学习与人工智能的未来
苹果 | 谷歌 | SPOTIFY | 其他
雅各布·福斯特在 TDS 播客
本杰明·戴维斯的背景图片
编者按:迈向数据科学播客的“攀登数据科学阶梯”系列由 Jeremie Harris 主持。Jeremie 帮助运营一家名为sharpes minds的数据科学导师初创公司。可以听下面的播客:
强化学习最近受到了很多关注，这在很大程度上要归功于 AlphaGo 和 AlphaZero 等系统，这些系统以引人注目的方式凸显了它的巨大潜力。虽然我们开发的 RL 系统已经完成了一些令人印象深刻的壮举，但它们是以一种相当幼稚的方式完成的。具体来说，他们还没有倾向于面对多主体问题，这需要合作和竞争。但是，即使解决了多智能体问题，它们也是使用智能体来解决的，这些智能体只是假设其他智能体是环境中不可控制的一部分，而不是具有丰富内部结构的实体，可以进行推理和交流。
这一切终于改变了，多智能体 RL 领域的新研究，部分由 OpenAI、牛津大学和谷歌校友以及现任公平研究科学家 Jakob Foerster 领导。Jakob 的研究特别旨在了解强化学习代理如何学习更好地合作，并在包括其他代理的复杂环境中导航，他们试图模拟其他代理的行为。实质上，Jakob 正致力于给 RL 代理一个思维理论。
我们的谈话涵盖了一些基础和哲学话题，但这里有一些我最喜欢的话题:
- 当我问 Jakob 他对“学习”的基本定义是什么时，他回答说是样本复杂性——训练一个机器学习模型所需的样本数量。他认为，学习的真正目标是“学会如何学习”——找到最快降低样本复杂性的算法和策略。从这个意义上来说，进化出人类的进化过程是一个比人类用来理解世界和进行预测的认知过程更糟糕的“学习者”:尽管一个物种的基因组需要数百万人的死亡才能“学习”一些东西，但人脑只需要极少量的数据点(有时甚至一点也不需要)就能做到。
- Jakob 认为，RL 代理可以从明确识别其他代理中受益，这些代理不是他们无法控制的环境的一部分，而是代理——完全具有自己的思维过程。在所有代理都相同的情况下，任何给定的代理都可以构建其伙伴代理的相当准确的模型，该模型可以作为代理组之间有效协作和协调的基础。
- 当以这种方式建模代理时，出现的一个挑战是通信。为了让代理进行交流，他们必须开发一种共同的语言，但这并不像看起来那么容易:一个代理可能会开发一种表达自己的方法，但如果另一个代理碰巧没有开发出完全相同的方法，那么交流将是徒劳的。因此，Jakob 认为，一个重要的制约因素是代理人需要一起学习语言——这样，如果他们决定尝试改善他们的沟通方法，他们就可以一起保持他们相互理解的能力。
- 当我问雅各布，他是否认为我们已经拥有的概念工具——如深度学习和强化学习——足以建立一个完全通用的人工智能时，他说不。事实上，他是我遇到的最悲观的客人之一:在他看来，这种发展可能需要一个世纪。
纳什均衡介绍:朋友还是敌人 Q 学习
让机器人打破平衡
在 Unsplash 上由 Toa Heftiba 拍摄的照片
不管出于什么原因，人类天生拥有合作的能力。它变得如此平常，以至于它的细微差别就在我们眼皮底下溜走了。我们如何知道在移动一个沉重的沙发时如何协调？我们如何推理在杂货店分头行动以尽量减少时间？我们如何能够观察他人的行动并且理解如何最好地回应？
这里有一个解释:我们达到了平衡。一个均衡。每个人采取的行动不仅能最好地补充他人的行动，而且能最有效地完成手头的任务。这种均衡的应用在博弈论中经常出现，并扩展到多代理 RL (MARL)。在本文中，我们探索了两种算法，Nash Q-Learning 和 Friend or Foe Q-Learning，这两种算法都试图找到满足这种“平衡”思想的多主体策略。我们假设单代理公式和 Q 学习的基本知识。要了解更多关于 MARL 的背景知识和与之相关的基本原则，请查看我以前的文章:
好像一个机器人学习一切还不够
medium.com](https://medium.com/swlh/the-gist-multi-agent-reinforcement-learning-767b367b395f) 
埃里克·麦克林在 Unsplash 上拍摄的照片
什么使得一个最优的政策…最优？
多主体学习环境通常用随机博弈来表示。每个代理人的目标是找到一个政策，最大化他们自己的预期折扣奖励。总的目标是找到一个联合的政策，为每个代理聚集最多的报酬。这种联合奖励以价值函数的形式定义如下:
这个目标适用于竞争和协作两种情况。代理可以找到最好的反或补充其他策略。我们称这个最优策略为纳什均衡。更正式地说，它是一种具有以下属性的策略:
起初，我们似乎是在白费力气。最好的政策聚集了最多的回报，那又怎样？
在所有花哨的希腊字母和符号之下，纳什均衡告诉我们更多。它认为纳什均衡中每个代理人的策略是对其他代理人最优策略的最佳回应。没有代理人会因为任何调整带来的回报减少而改变他们的政策。换句话说，所有的代理都处于静止状态。内陆。在某种意义上被困住了。
举个例子，想象两个小机器人:C3PO 和 Wall-E 进行一场竞技游戏，在每一轮中，他们各自选择一个一到十的数字，谁选择的数字高谁就赢。不出所料，两个机器人每次都选择数字 10，因为两个机器人都不想冒输的风险。如果 C3PO 选择任何其他数字，他可能会输给 Wall-E 的最优策略，即总是选择 10，反之亦然。换句话说，两者处于均衡状态。
纳什 Q 学习
因此，我们定义了一个术语叫做纳什 Q 值:
与它的单代理对应物非常相似，纳什 Q 值表示当选择特定的联合行动后，所有代理遵循联合纳什均衡政策时，代理的预期未来累积报酬。这可以被视为一个国家行动对的“最佳情况”的奖励收益。这个定义有助于 Q 学习的多代理版本:Nash Q 学习。
乔恩·弗洛布兰特在 Unsplash 上的照片
在单代理 Q 学习中，我们使用时间差(TD)更新 Q 值，公式如下:
其中，gamma 表示折扣系数，alpha 表示学习率。下面是有点无聊的部分:Nash Q-learning 简化为 Q-learning。更明确地说，纳什 Q 学习的更新方程是:
我们通过在行动空间内最大化来计算纳什 Q 值。交换几个术语，你会得到一个几乎相同的更新方程，唯一的区别是一个联合行动空间。那么，这一切的目的是什么？
照片由 Riho Kroll 在 Unsplash 上拍摄
要点是:我们不能总是假设单代理逻辑适用于多代理设置。换句话说，适用于 MDPs(单代理 RL)的算法并不总是适用于随机博弈(多代理 RL)。纳什 Q-Learning 恰好是一个有点特殊的案例。胡和 Wellman [1]在论文中证明了纳什 Q 学习总是收敛的。它的更新方程看起来与 Q-learning 相同的事实是直观的，但并不总是可以预先假定的。
整个纳什 Q 学习算法类似于单代理 Q 学习，如下所示:
朋友或敌人 Q-学习
q 值有一个自然的解释。他们代表了一个国家行动对的预期累积贴现回报，但这如何激励我们的更新方程？我们再来看一下。
这是一个加权和，其中 alpha 是学习率，是区间(0，1)中的一个值。第一项是前一时间步的 Q 值乘以某个分数。让我们剖析一下第二项，我们的学习率乘以其他两项之和。
第二项的第一部分是我们在执行一个行动后得到的奖励，而另一部分是下一个状态行动的贴现纳什 Q 值最大化。记住，这个纳什 Q 值等于给定状态后的预期、最佳情况、累积回报。把这两部分放在一起，我们有一个预期回报总和，其中我们假设在下一个状态的最佳情况。这是对当前 Q 值的另一种定义，只是一个更新的版本！更正式地说，这个总和代表实际 Q 值的更接近的估计值。缩小并查看整个更新方程，我们可以将其解释为“推动”当前 Q 值更接近这个更好的估计值。
在《非友即敌 Q-Learning 》( FFQ)中，Littman [2]使用这种解释为多智能体系统创建了一种直观的算法。与纳什 Q 学习相反，FFQ 首先让每个代理保持他们自己的 Q 函数。我们假设代理知道其他人的行动空间，但不知道其他人在任何给定时刻会选择什么行动。
此外，Littman 将系统概括为合作者和对手的组合，因此命名为朋友或敌人。我们再以 C3PO(特工 1)和 Wall-E(特工 2)为例，站在 C3PO 的角度看待事情。如果两者一起工作，C3PO 的 Nash-Q 值将替换为:
正如预期的那样，两个代理都试图最大化他们的“奖励流”,类似于之前的 Q 更新功能。然而，如果两个机器人相互竞争，C3PO 的 Nash-Q 将被替换为:
请注意，在最大化 C3PO 的动作之前，我们如何首先最小化 over Wall-E 的动作。换句话说，当 Wall-E 试图最小化 C3PO 的回报流时，C3PO 学习如何对 Wall-E 的反作用作出最佳反应，相应地更新他的 Q 值。这是一个纳什均衡显示其色彩的例子:代理人学习最佳的方式来互补。
更一般地，这可以适用于更大的代理系统。纳什-Q 值变成如下:
其中 X 代表所有合作者的集合，而 Y 代表所有对手的集合。与 Nash Q-learning 类似，Littman[2]表明朋友或敌人 Q-learning 也会收敛。通过适当替换这些纳什 Q 值，一个分布式代理系统可以学习一个达到均衡的策略，如果存在的话。
第一步
一些人认为这些算法是进入多智能体学习场景的“第一步”。虽然这些想法相对简单，但结果却是强有力的。下一次，我们将研究更新颖的现代方法来解决复杂的多代理环境！要更深入地了解纳什 Q 学习和朋友或敌人 Q 学习，请随意看看下面列出的两篇论文。
参考
[1]胡军，M. Wellman，一般和随机博弈的 Nash Q-学习 (2003)，机器学习研究杂志 4
[2] M. Littman，普通和博弈中的敌友 Q 学习 (2001)，ICML
从经典到最新，这里有讨论多代理和单代理强化学习的相关文章:
因为 1+1=3
towardsdatascience.com](/stigmergic-reinforcement-learning-why-it-tells-us-1-1-3-4d50dfa9cb19) [## 分层强化学习:封建网络
让电脑看到更大的画面
towardsdatascience.com](/hierarchical-reinforcement-learning-feudal-networks-44e2657526d7)
多种武器的强盗:第一部分
入门，一个婴儿机器人的强化学习指南
数学框架和术语
概述
当面对各种选项的选择时，每个选项给你不同程度的回报，你如何找到哪个是最好的？
这类问题通常被称为多臂强盗。在这一系列文章中，我们将看看用于解决这一难题的理论和算法。
多臂土匪问题是全面强化学习道路上的第一步。
这是一个六集系列的第一集，讲述了多种武装的强盗。要涵盖的内容相当多，因此需要将所有内容分成六个部分。即便如此，我们真的只打算看看多臂强盗的主要算法和理论。刚好够充当强化学习的垫脚石。
在第 1 部分中，我们将涵盖 Bandit 问题的所有细节，定义将在后续部分中使用的术语和基本方程。这大部分也直接适用于一般的强化学习。然而，如果你已经熟悉了基础知识，那么你可能会想要跳到真正涉及到 Bandit 算法的部分。
索引
本系列中关于多武装匪徒的全套文章如下:
- 第一部分:数学框架和术语——入门所需的全部基础信息
- 第二部分:土匪框架
- 代码和测试框架的描述 - 第三部分:土匪算法
- 贪婪算法 -乐观-贪婪算法 -ε-贪婪算法 -后悔 - 第四部分:置信上限(UCB) Bandit 算法
- 第五部分:汤普森采样-伯努利汤普森采样
-高斯汤普森采样 - 第六部分:土匪算法比较
bandit 算法和测试框架的所有代码都可以在 github 上找到: Multi_Armed_Bandits
从前有一个婴儿机器人。一天，他和妈妈出去购物，一只机器狗跑了过去。机器人宝宝的妈妈正忙着买新的火花塞，所以没注意到他什么时候转身开始跟着狗。
他追着狗穿过拥挤的购物中心，穿过几条过道，下了自动扶梯，上了自动扶梯，最后，狗躲进了墙上的服务舱口，不见了。不仅服务舱太小，机器人宝宝进不去，而且他还意识到自己迷路了。完全迷失了。
电源插座问题
更糟糕的是，机器人宝宝意识到自己快没电了。如果他想再找到他的妈妈，他需要充电。而且要快。
幸运的是，正对面有一个充电站。他走过去，发现房间里有 5 个独立的电源插座。
他走到第一个电源插座前，插上电源。令人失望的是，他只收到了一股能让他运行 2 秒钟的能量。按照这种速度，他将永远无法完全充电。也许其他电源点会更好？
考虑到这一点，他移动到下一个插座，在那里他获得了 3 秒钟的充电时间。这个插座似乎并不比第一个好多少，所以他转而尝试第三个插座。这一次他获得了 6 秒的价值。这似乎是给他充电最多的电源插座，尽管完全充电仍需要很长时间，但似乎比他试过的其他插座要好。所以，决定留在这个电源点，他再次插入。这一次，他收到了少得可怜的 2 秒钟的费用。
他必须找到一种更好的方法来发现哪个是最好的，并让他以最快的速度达到最大电量，而不是沿着插座随意移动。
多兵种土匪问题
这个电源插座问题类似于标准的、多臂的、土匪问题，用来说明如何孤立地检查探索。
在多臂强盗游戏中，你试图通过玩一组单臂强盗(也称为吃角子老丨虎丨机或水果机)赢得尽可能多的钱，每个强盗都可以给出不同的支付。你需要找到哪台机器支付的金额最大，这样你就可以在分配的时间内赚尽可能多的钱。
机器的每一次游戏(或强盗手臂的拉动)对应一个时间段，你只能玩固定数量的时间段。
探索与开发的困境
婴儿机器人面临着不知道哪个电源插座给他充电最多的问题。因此他需要 探索 可能的选择，以寻找最好的一个。
然而，因为他时间紧迫，他不能花太多时间来决定哪一个是最好的，也不能测试每个电源插座来准确知道它平均会给多少电荷。他需要 利用 他获得的知识，这样他就不会浪费时间去尝试不好的电源插座，让他在最短的时间内获得最大的电量。
这是一个经典的探索-开发困境的例子，在这种情况下，你想探索可能的选项以寻找最佳选项，同时又想利用已经获得的信息，以便获得最大可能的总体回报。
数学框架和术语
为了帮助机器人宝宝充电，并让他回来找妈妈，我们首先需要熟悉一些强化学习中使用的常用术语和数学符号。
使用的符号很大程度上遵循萨顿和巴尔托的，来自他们的强化学习圣经，“ 强化学习:介绍 ”。
动作
在强化学习中，在可用选项之间做出选择，并选择该选项，被称为采取 动作 。例如，在电源插座问题中，一个操作是选择一个可用的电源插座。在多臂强盗问题中，它是选择和玩一套吃角子老丨虎丨机。
在简单的电源插座和 bandit 问题中，在离散的时间步骤中采取行动。换句话说，一个动作接一个动作，在这些问题中，有固定数量的总动作。
- 在时间步' t '采取的行动表示为' Aₜ
奖励
每采取一个动作就获得一个 奖励 。在电源插座问题中，奖励是一定数量的电荷；然而，在强盗问题中，它是从机器中赢得的一笔钱。
采取特定行动所获得的奖励是一个随机值，从特定于该行动的潜在概率分布中提取。因此，每次采取行动时，返回的奖励可能会有不同的值。如果同一个动作重复多次，那么就可以计算出一个更准确的真实回报平均值。
采取特定行动获得奖励可能是强化学习的主要定义特征。正是这种奖励被用来指导学习，试图找到最好的行动，从而最大限度地提高总的整体奖励。这与监督学习形成对比，在监督学习中，最佳动作将作为训练数据的一部分提供。
- 在采取行动' Aₜ '之后，在时间步' t '获得的奖励表示为' Rₜ
动作次数
可用动作的数量由字母' k 表示。因此，在电源插座示例中，' k '将是可供选择的电源插座数量。因为，在这种情况下，有 5 个不同的套接字，' k '将是 5。在多臂土匪问题中，它是可供选择的吃角子老丨虎丨机的总数(实际上这个问题经常被称为' k 臂土匪问题')。
- 可用动作的数量由字母' k 表示
预期奖励
每个可用的' k '动作都有一个 预期 奖励，其中术语“预期”是指如果该动作重复多次将获得的平均值。因此，例如，如果投掷一枚公平的硬币，获得正面的预期概率将是 0.5，因为平均而言，当投掷总数很大时，正面应该出现在所有硬币投掷的一半中。
- 财产的预期价值用符号'𝔼'表示
值
一个行动的期望回报被称为该行动的 值 ，并被表示为“ q(a) ”，其中“ a ”是在时间步长“ t ”选择的具体行动(即 Aₜ = a)。
- 因此，动作' a '的值由下式给出:
这可以理解为:假设在时间步长‘t’选择的行动是行动‘a’，行动‘a’的值等于预期(平均)奖励值。
(注意:任何时候你在概率方程中看到符号“|”，就把它理解为‘给定’)。
实际上，这意味着，如果你不断重复动作' a '，然后对你得到的奖励值进行平均，最终，你会知道'q(a)【T29]'的真实值，即' a '的平均奖励。因此，如果小机器人继续尝试同一个电源插座，他将获得该插座真实平均功率输出的越来越准确的估计，直到最终，如果他重复该动作足够长的时间，他将知道该插座输出的真实值。
样本平均估计值
显然，我们不知道行为回报的真正价值。如果我们这样做了，事情就简单了。我们只是利用现有的知识，而不必做任何探索。我们只要玩最好的吃角子老丨虎丨机，赢得最多的钱，机器人宝宝就会插上充电最多的插座。
然而，事实并非如此。我们不知道真正的回报，因此必须做一些探索，从每一个可能的行动中找到回报的比较。因此，为了跟踪哪一个动作是最好的，当我们探索一组可能的动作时，我们需要估计每个动作的价值。随着时间的推移，这种估计应该会越来越准确，并向真正的回报值靠拢。
因为一个行为的真实价值是该行为的平均回报，一个简单而有效的估计可以通过取该行为迄今为止回报的平均值来计算。
因此，在时间步长‘t’处，动作 a 的估计值 Qₜ(a)' 由下式给出:
其中' n' 是在时间' t '之前采取行动' a 的次数，而' Rᵢ '是采取行动' a 时在每个时间步获得的奖励。
计算样本平均值
对任何行为来说，形成所有奖励总和的最简单的方法是存储每个奖励，然后在需要时添加它们。然而，从实际的角度来看，这不是很有效，无论是在存储和计算时间方面。有可能记录总的回报，但随着时间的推移，即使是这个值也会变得难以管理。
- 一个更好的解决方案是根据上一次的估计来计算新的估计奖励。
对于一个行动' a '，行动价值的 n ᵗʰ估计值' Qₙ '，由该行动以前获得的所有奖励的总和除以该行动被选择的次数(即，它只是平均值)得出:
因此，交换一下东西，在' n '之前，奖励的总和由下式给出:
当获得下一个奖励“rₙ”时，可以通过将该奖励加到先前的奖励总和上并增加已经采取的行动的次数的计数来计算新的估计值。所以新的估计是:
**
由于我们已经知道如何写奖励的总和，在' n '之前，就最后的估计而言，我们可以简单地将它代入等式:
重新整理后，我们最终得到了新评估的可用形式，用上次评估' Qₙ 和新奖励' Rₙ '来表示:
公式 1:新的估计值，根据上次的估计值和新的奖励值计算得出。
虽然对某些人来说，这些等式可能有点令人生畏，但它们基本上可以归结为公式 1 中给出的最后一个等式，它让我们在给定行为的先前值和新奖励的情况下，计算行为的值。
这个公式很容易在代码中实现(我们将在下一部分中实现)，让我们监视在采取这些动作时，动作的估计值是如何变化的。然后，这些值可用于比较这些操作的相对性能，以找到最佳操作和选择这些操作的最佳方式。
摘要
在这里，我们对多武器匪徒调查的第一部分，我们已经定义了描述匪徒问题所需的所有基本术语和方程。
然而，到目前为止，我们只给出了土匪问题的一个高层次的概述，没有真正进入问题本身。我们将在接下来的部分中纠正这一点，届时我们将全面检查一些可用于解决这一问题的主要策略。
更重要的是，我们将使用这些策略让机器人宝宝充电，然后回到妈妈身边！
接下来:第二部分:强盗框架
参考
[1]《强化学习:导论 》，萨顿&巴尔托(2018)
强盗框架
婴儿机器人强化学习指南
多种武器的强盗:第二部分
概观
机器人宝宝在商场走失。利用强化学习，我们想帮助他找到回到妈妈身边的路。然而，在他开始寻找她之前，他需要从一组电源插座充电，每个插座的电量略有不同。
使用多臂强盗问题中的策略，我们需要在最短的时间内找到最好的插座，让机器人宝宝充电上路。
这是第二个，在一个六部分系列，对多武装匪徒。在第 1 部分中，我们涵盖了描述 bandit 问题所需的所有基本术语和数学知识。
在这一部分中，我们将看看我们将在接下来的文章中解决的问题，确切地描述电源插座问题将如何设置。这涵盖了用于创建基本套接字模拟器和用于评估这些套接字的测试框架的所有代码。
因此，尽管我们还不能实现真正的强盗算法，但我们会做好所有必要的基础工作，这样我们就可以在随后的部分开始研究各种强盗策略。
bandit 算法和测试框架的所有代码都可以在 github 上找到: Multi_Armed_Bandits
概述
机器人宝宝进入了一个充电室，里面有 5 个不同的电源插座。每个插座返回的电荷数量略有不同。我们希望在最短的时间内给机器人宝宝充电，所以我们需要找到最好的插座，然后使用它，直到充电完成。
这和多臂强盗问题是一样的，除了我们不是在找一个能给出最好回报的吃角子老丨虎丨机，而是在找一个能给出最多电量的电源插座。
测试选择策略
现在我们已经有了所有需要的符号和术语，我们可以构建一个测试系统了。这将让我们检查不同的策略在寻找和利用最佳电源插座时的表现。
实现电源插座
我们将测试几种不同的策略来寻找最佳电源插座，作为其中的一部分，我们需要创建几种不同类型的插座。但是，所有套接字都具有相同的基本功能，并且需要能够执行以下操作:
- 供给一些电荷。其中返回的费用金额取决于插座的真实奖励值。
- 更新对插座的奖励值的估计。主要通过计算样本平均值来完成，如第 1 部分所述。每个套接字都会记录自己的估计值和尝试的次数。它还将存储其真实的奖励值，但这只是为了实现的目的。因为这是我们试图估计的值，在套接字初始化之后，我们将假装我们实际上不知道这个值。
- 返回公制。这个用来评估和选择插座。默认情况下，这只是套接字奖励值的当前估计值。
下面显示了一个基本电源插座的 python 实现。它充当基类，所有其他更专业的套接字都将从这个基类派生出来。
基本电源插座跟踪以下值，这些值与我们目前看到的等式相匹配:
- q =插座输出的真实平均值
- Q =套接字输出的运行估计(即其回报)
- n =套接字被尝试的次数
Q 和 n 在单独的 initialize 函数中被初始化，以允许套接字被重置，而不必创建一个全新的套接字。
当估计套接字输出时，真正的输出' q '是我们试图收敛的值。虽然设置套接字需要' q '，但是它的值没有在其他地方使用，因为这是我们试图寻找的值。
函数' charge '返回插座的输出奖励。这由正态(高斯)分布给出，平均值为' q '(设置期间提供的值)。
' update '函数使用新的奖励值和先前的估计值计算样本平均估计值，如第 1 部分的公式 1 所述。在代码中，这直接翻译为:
最后' sample '函数返回将用于选择下一个套接字的度量。在这种情况下，它只是值“Q”，当前奖励的估计值。
实施充电室
我们想要设置一个有 5 个插座的房间，每个插座都会返回一个平均持续时间不同于其他插座的能量脉冲。
为了简单起见，我们将对每个插座的功率输出使用固定的顺序。因此，在下面的代码中，' socket_order '参数定义了 socket 2 将是最差的，socket 4 将是最好的，这将在我们的整个实验中保持不变。
每个插座返回的平均电荷量的计算方法是，将其插座顺序值乘以 2，然后加上 2 以抵消该值并使其大于零。因此，按顺序，插座有以下平均奖励:6，4，8，12，10。
按照这种方式设置套接字，我们可以从每个套接字获得以下输出:
在上面的“小提琴”图中，每个套接字的线条显示了作为每个套接字的奖励而返回的值的范围。因此，1 号插座返回了大约 2 到 10 秒的充电时间。线下的阴影区域代表了每个奖励被返还的频率。对于插座 1，最常返回的奖励是 6 秒钟的充电。这是这个插座的平均奖励，也是它的真实奖励值。
在密度图中，我们可以看到每个插座的奖励概率是如何变化的。4 号插座最好，平均充电时间为 12 秒，而 2 号插座最差，充电时间仅为 4 秒。Socket 4 是我们试图寻找和利用的最佳插座。
插座测试仪
我们还需要一种方法，在每个时间步从一组套接字中进行采样和选择。这由 SocketTester 类处理，如下所示:
如前所述， SocketTester 类创建一组电源插座，按照提供的插座顺序。运行时，套接字测试器循环指定数量的时间步长，并在每个时间步长执行以下操作:
-
选择一个套接字:
为每个套接字调用' sample '函数，然后选择返回值最大的套接字。如前所述，默认情况下，返回的样本值将只是套接字对其平均回报的当前估计。
当有多个具有最高样本值的套接字时，‘random _ arg max’函数(如下所示)任意选择一个具有最大值的套接字。这优先于 Numpy 的 argmax 函数使用，该函数在出现平局时简单地选择第一个项目。 -
收费和更新: 一旦选择了一个插座，我们就从那个插座收费以获得奖励。然后我们更新这个套接字，增加它被尝试的次数，并使用新的奖励值改进它的奖励估计值。
注意，上面显示的' SocketTester' '类的代码是实际类的简化版本，只显示了主要功能。在完整版的类中，套接字的属性在运行过程中被跟踪。此外，该类只执行一次运行。因为我们处理的是随机变量，所以一次运行可能不足以确定套接字选择策略的真实行为。因此，第二个类“ SocketExperiment ”用于设置和运行重复的套接字测试，并生成这些测试的平均结果。这两个类的完整代码可以在 Github 库的文件 PowerSocketSystem.py 中找到。
摘要
这部分我们看多武装匪徒根本没有真正看他们！然而，它确实涵盖了我们在后续文章中创建和评估多兵种强盗战略所需的所有基本框架。
在以后的文章中，我们将把在第 1 部分中学到的理论与这个测试框架结合起来，开始研究如何应用各种强盗策略来探索和利用电源插座集。
**<** [**Part 1: Multi-Armed Bandits**](/multi-armed-bandits-part-1-b8d33ab80697) [**Part 3: Bandit Algorithms**](/bandit-algorithms-34fd7890cb18) >
多武装匪徒:UCB 算法
基于置信界限优化动作
乔纳森·克洛克在 Unsplash 上拍摄的照片
想象一下，你在一个赌场，在一堆(k 个)有不同回报概率的独臂强盗(也叫吃角子老丨虎丨机)中进行选择，并且想要选择最好的一个。你使用什么策略来帮助你走出最大数量的季度？
这就是多兵种土匪问题的本质，是一个简化强化学习任务。当你在网站上寻求最大化的参与度，或者搞清楚临床试验，或者试图优化你的电脑性能时，这些都可能发生。
它们不仅仅是一个有用的框架，解决起来也很有趣！
TL；速度三角形定位法(dead reckoning)
我们用 Python 中的例子来教授置信上限 bandit 算法，以便让您快速熟悉这种方法。
你的第一个策略
强盗问题需要在探索和开发之间取得平衡。因为问题始于对奖励的无先验知识，一旦缩小了选择范围，它需要探索(尝试许多吃角子老丨虎丨机)然后利用(反复拉动最佳杠杆)。
最简单的强盗采用ϵ-greedy 策略，这意味着它会选择它认为大多数时候最好的老丨虎丨机，但有一个小的ϵ%概率，它会选择随机的老丨虎丨机。这是一个简单的策略，可以产生良好的结果(如果你想看到这种方法被实施，请看这篇文章)，但是我们可以做得更好。
置信上限 Bandit
ϵ-greedy 可能会花很长时间来决定选择合适的独臂强盗，因为这是基于小概率的探索。置信上限 (UCB)方法有所不同，因为我们基于对给定选择的不确定性来做出选择。
我会向你展示数学，然后解释:
上述等式为我们的模型提供了选择标准。Q_n(a)是我们对给定老丨虎丨机 a. 的当前估计值，平方根下的值是我们尝试过的老丨虎丨机总数的对数， n 除以我们尝试每台老丨虎丨机的次数 a ( k_n )，而 c 只是一个常数。我们通过选择在每一步 n 中给出最大值的强盗来选择下一台吃角子老丨虎丨机。
平方根项是对每个动作和的方差的估计。如果我们还没有选择一个土匪，方差是无限的(我们将除以 0)，这意味着这将是我们的下一个选择。这迫使算法快速探索那些未知值。一旦它选择了它，在其他条件相同的情况下，它的价值就会下降，相对于其他选择来说，可能性变得更小。因为 log(n)在分子中，每次我们不选择一个动作，它的值变得更有可能，尽管分子增长得更慢(即对数)，所以你收集的数据越多，这种影响变得越小。最终结果是一种算法，在锁定最有利可图的机器之前，可以非常快速地采样，以减少未知的不确定性。
一些实际的警告
在我们深入实现之前，我们将初始化我们的值，k_n(a) = 1 而不是 0，以确保我们不会在 Python 中弹出任何nan值。此外，我们将模拟很多强盗拉，所以我们需要有效率地计算我们的一些值。Q_n(a)只是该动作的平均值，我们可以使用一个方便的公式来计算平均值，而不是为每个动作保留数千个值，只需为每个动作存储两条信息，即我们为该给定动作做出了多少次选择(k_n(a))和我们的当前平均值(m_n)。
其中 R_n 是我们刚刚从采取一项行动中获得的回报(为简洁起见，我省略了 a)。
UCB 电码
# import modules
import numpy as np
import matplotlib.pyplot as plt
import pandas as pdclass ucb_bandit:
'''
Upper Confidence Bound Bandit
Inputs
============================================
k: number of arms (int)
c:
iters: number of steps (int)
mu: set the average rewards for each of the k-arms.
Set to "random" for the rewards to be selected from
a normal distribution with mean = 0\.
Set to "sequence" for the means to be ordered from
0 to k-1.
Pass a list or array of length = k for user-defined
values.
'''
def __init__(self, k, c, iters, mu='random'):
# Number of arms
self.k = k
# Exploration parameter
self.c = c
# Number of iterations
self.iters = iters
# Step count
self.n = 1
# Step count for each arm
self.k_n = np.ones(k)
# Total mean reward
self.mean_reward = 0
self.reward = np.zeros(iters)
# Mean reward for each arm
self.k_reward = np.zeros(k)
if type(mu) == list or type(mu).__module__ == np.__name__:
# User-defined averages
self.mu = np.array(mu)
elif mu == 'random':
# Draw means from probability distribution
self.mu = np.random.normal(0, 1, k)
elif mu == 'sequence':
# Increase the mean for each arm by one
self.mu = np.linspace(0, k-1, k)
def pull(self):
# Select action according to UCB Criteria
a = np.argmax(self.k_reward + self.c * np.sqrt(
(np.log(self.n)) / self.k_n))
reward = np.random.normal(self.mu[a], 1)
# Update counts
self.n += 1
self.k_n[a] += 1
# Update total
self.mean_reward = self.mean_reward + (
reward - self.mean_reward) / self.n
# Update results for a_k
self.k_reward[a] = self.k_reward[a] + (
reward - self.k_reward[a]) / self.k_n[a]
def run(self):
for i in range(self.iters):
self.pull()
self.reward[i] = self.mean_reward
def reset(self, mu=None):
# Resets results while keeping settings
self.n = 1
self.k_n = np.ones(self.k)
self.mean_reward = 0
self.reward = np.zeros(iters)
self.k_reward = np.zeros(self.k)
if mu == 'random':
self.mu = np.random.normal(0, 1, self.k)
上面的代码定义了我们的ucb_bandit类，使我们能够模拟这个问题。运行它需要三个参数:要拉的臂数(k)、探索参数(c)和迭代次数(iters)。
我们可以通过设置mu来定义奖励(默认情况下，奖励均值来自正态分布)。我们对此运行 1000 集，并平均每集 1000 步的回报，以了解该算法的执行情况。
k = 10 # number of arms
iters = 1000ucb_rewards = np.zeros(iters)
# Initialize bandits
ucb = ucb_bandit(k, 2, iters)episodes = 1000
# Run experiments
for i in range(episodes):
ucb.reset('random')
# Run experiments
ucb.run()
# Update long-term averages
ucb_rewards = ucb_rewards + (
ucb.reward - ucb_rewards) / (i + 1)
plt.figure(figsize=(12,8))
plt.plot(ucb_rewards, label="UCB")
plt.legend(bbox_to_anchor=(1.2, 0.5))
plt.xlabel("Iterations")
plt.ylabel("Average Reward")
plt.title("Average UCB Rewards after "
+ str(episodes) + " Episodes")
plt.show()
目前看来还不错！强盗通过稳步增长的平均奖励来学习。为了了解它的工作情况，我们将它与标准的ϵ-greedy 方法进行比较(代码可以在这里找到)。
k = 10
iters = 1000eps_rewards = np.zeros(iters)
ucb_rewards = np.zeros(iters)# Initialize bandits
ucb = ucb_bandit(k, 2, iters)
eps_greedy = eps_bandit(k, 0.1, iters, ucb.mu.copy())episodes = 1000
# Run experiments
for i in range(episodes):
ucb.reset()
eps_greedy.reset()# Run experiments
ucb.run()
eps_greedy.run()
# Update long-term averages
ucb_rewards += (ucb.reward - ucb_rewards) / (i + 1)
eps_rewards += (eps_greedy.reward - eps_rewards) / (i + 1)
plt.figure(figsize=(12,8))
plt.plot(ucb_rewards, label='UCB Bandit')
plt.plot(eps_rewards, label="$\epsilon={}$".format(
eps_greedy.eps))
plt.legend(bbox_to_anchor=(1.3, 0.5))
plt.xlabel("Iterations")
plt.ylabel("Average Reward")
plt.title("Average rewards for UCB and $\epsilon$-Greedy Bandits")
plt.show()
UCB 方法快速找到最佳动作，并在大部分剧集中利用它，而贪婪算法尽管也能相对快速地找到最佳动作，但随机性太大。我们也可以通过观察动作选择和比较每个算法选择的最优动作来观察这一点。
width = 0.45
bins = np.linspace(0, k-1, k) - width/2plt.figure(figsize=(12,8))
plt.bar(bins, eps_greedy.k_n,
width=width,
label="$\epsilon$={}".format(eps_greedy.eps))
plt.bar(bins+0.45, ucb.k_n,
width=width,
label="UCB")
plt.legend(bbox_to_anchor=(1.3, 0.5))
plt.title("Number of Actions Selected by Each Algorithm")
plt.xlabel("Action")
plt.ylabel("Number of Actions Taken")
plt.show()opt_per = np.array([eps_greedy.k_n, ucb.k_n]) / iters * 100
df = pd.DataFrame(np.vstack(
[opt_per.round(1),
eps_greedy.mu.reshape(-1, 1).T.round(2)]),
index=["Greedy", "UCB", "Expected Reward"],
columns=["a = " + str(x) for x in range(0, k)])
print("Percentage of actions selected:")
df
在这种情况下，我们的最优行动是 a=6，平均回报为 1.54。ϵ-greedy 算法选择它的概率是 83.4%，而 UCB 算法选择它的概率是 89.7%。此外，您将看到贪婪算法选择负值的频率比 UCB 算法高得多，这也是因为每次选择都有 10%的机会选择随机行动。
有几十个其他多臂土匪方法在那里学习。这是一个简单的优化框架，但是功能非常强大，玩起来也很有趣！
马尔可夫营销归因
Cloudera 如何使用马尔可夫模型解决多渠道归因问题
克莱门斯·范·雷趴在的 Unsplash 上
这篇文章的编辑版本首先发表在 ClickZ: 数据驱动营销归因营销人员指南。
营销归因是一种衡量活动和渠道对潜在客户的价值的方法。潜在客户与营销活动互动的时间点称为接触点，接触点的集合构成了购买者的旅程。营销人员使用归因模型的结果来了解哪些接触点对成功的购买者旅程影响最大，以便他们能够就如何优化未来营销资源的投资做出更明智的决策。
买家之旅很少是直截了当的，成功之路可能是漫长而曲折的。由于要考虑的接触点太多，很难区分真正的高影响互动和低影响互动，这可能导致不准确的信用划分和营销绩效的虚假表现。这就是为什么为你的企业选择最佳归因模式如此重要。
在这篇文章中，我提供了一些关于 Cloudera 如何使用 Cloudera 产品构建一个定制的、数据驱动的归因模型来衡量我们全球营销活动的绩效的见解。
传统模型的局限性
所有的归因模型都有其优点和缺点，但传统模型的一个共同缺点是它们是基于规则的。用户必须预先决定如何在接触点之间分配销售活动的积分。传统模型包括:
幸运的是，有更复杂的数据驱动方法，能够通过模拟接触点实际上如何与买家互动，以及如何相互影响预期的销售结果，来捕捉买家旅程的复杂性。数据驱动模型让营销人员能够更深入地了解营销活动和渠道的重要性，从而提高营销责任和效率。
Cloudera 的数据驱动方法
我们评估的第一个归因模型是基于合作博弈理论的 Shapley 值。我在之前的一篇文章中介绍了这个模型的细节。这种流行的(获得诺贝尔奖)模型提供了比传统方法更深入的渠道绩效，但在其最基本的实现中，它不能扩展到处理我们想要包括的接触点数量。Shapley 模型在数量相对较少的渠道上表现良好，但我们的要求是对所有活动进行归因，这相当于买家旅程中的数百个接触点。
在投入时间扩展 Shapley 算法之前，我们研究了替代方法，并决定评估使用马尔可夫模型来解决归因问题。我们使用channel attributeR 包进行实施，发现它产生了与 Shapley 模型类似的结果，它可以扩展到大量接触点，并且易于在 Cloudera 数据科学工作台(CDSW) 中设置和使用。
马尔可夫归因模型
Markov 是一个概率模型，它将购买者的旅程表示为一个图形，图形的节点是接触点或“状态”，图形的连接边是观察到的这些状态之间的转换。例如，购买者观看产品网络研讨会(第一状态)，然后浏览 LinkedIn(过渡)，在那里他们点击同一产品的广告印象(第二状态)。
该模型的关键要素是转移概率(在不同状态之间移动的可能性)。购买者在两种状态之间转换的次数被转换成概率，并且完整的图可以用于测量每个状态的重要性和最可能的成功路径。
例如，在买家旅程数据样本中，我们观察到网上研讨会接触点出现了 8 次，买家观看网上研讨会后点击 LinkedIn 广告仅 3 次，因此两种状态之间的转换概率为 3 / 8 = 0.375 (37.5%)。为每个转换计算一个概率以完成该图。
在我们开始计算活动归因之前，马尔可夫图可以告诉我们一些关于我们购买者旅程的有用信息。从上面的例子可以看出，成功概率最高的路径是“开始>网络研讨会>活动 Z >成功”，总概率为 42.5% (1.0 * 0.425 * 1.0)。
马尔可夫图也能告诉我们整体的成功率；也就是说，给定所有买家旅程的历史，买家旅程成功的可能性。成功率是整体营销绩效的基线，也是衡量任何变革有效性的指针。上面的例子马尔可夫图有 67.5%的成功率:
活动归因
通过计算所谓的移除效应，马尔可夫图可以用来衡量每个活动的重要性。一项活动的有效性是通过将其从图表中移除并模拟买家旅程来衡量没有它时成功率的变化来确定的。移除效应是权重的一个代理，它是为马尔可夫图中的每个活动计算的。
利用移除效应进行营销归因是拼图的最后一块。为了计算每个活动的属性值，我们可以使用下面的公式: A = V * (Rt / Rv)
- A =战役的属性值
- V =要除的总值。例如，用作马尔可夫模型输入的所有成功买家旅程的总美元值
- Rt =战役的移除效果
- Rv =所有移除效果值之和
让我们看一个例子。假设在财年的第一季度，所有成功买家旅行的总美元价值为100 万美元。相同的买家旅程用于构建马尔可夫模型，它计算出我们的广告活动的移除效应为 0.7 (即，当广告活动从马尔可夫图中移除时，买家旅程成功率下降了 70%)。我们知道输入数据中观察到的每个活动的移除效应值，对于本例，假设它们的总和为 2.8 。将这些数字代入公式，我们计算出我们广告活动的归属价值为 $25 万:
【25 万美元= 100 万美元 (0.7 / 2.8)*
除此之外，我们还通过从归因价值中减去同期开展活动的成本来计算活动投资回报率。
关于channel attributeR 包的好处在于，它为您完成了所有这些工作，甚至包括三种传统的基于规则的比较算法的实现(首次触摸、最后触摸和线性触摸)。还有一个新的 Python 实现。
Cloudera on Cloudera
我们为我们在 Cloudera 的数据实践感到自豪。营销归因应用程序由 Cloudera 的营销和数据卓越中心业务部门开发。它建立在我们内部的企业数据中心和运行在 Cloudera 数据科学工作台(CDSW) 中的马尔可夫模型之上。
通过利用数据驱动的归因模型，我们消除了与传统归因机制相关的偏见。我们已经能够了解各种信息如何影响我们的潜在客户，以及地理位置和收入类型的差异。现在我们有了可靠的数据支持归因，我们有信心使用结果来通知和推动我们的营销组合战略和投资决策。当我们与销售团队合作时，我们可以依靠这些数字来推动我们的营销战略向前发展。
多类分类:从混淆矩阵中提取性能度量
在这篇文章中，我解释了如何阅读混淆矩阵，以及如何从混淆矩阵中提取多类分类问题的 FP、FN、TP、TN、TPR、TNR、FPR、FNR &准确度值。
使用 scikit-learn 的文档中的代码生成的图。
介绍
在我之前的一篇帖子中，ROC 曲线用一个新冠肺炎假设的例子解释:二进制&多类分类教程 ，我很清楚地解释了什么是 ROC 曲线以及它是如何与著名的混淆 矩阵联系在一起的。如果你不熟悉术语混淆矩阵和真阳性、真阴性等。，参考上述文章，在 6 分钟内学会所有内容或继续阅读，快速回顾两分钟。
2 分钟回顾:TP、TN、FP、FN 是什么意思
让我们想象一下，我们有一个测试，它能够在几秒钟内告诉我们一个人是被病毒感染还是而不是。因此测试的输出可以是正(受影响)或负(不受影响)。所以，在这个假设的例子中，我们有一个二元分类的例子。****
作者做的手工素描。假设我们真的知道真相，两个人群的例子，一个受新冠肺炎影响，另一个不受影响。此外，基于测试的输出，我们可以将一个人表示为受影响的(蓝色人群)或不受影响的(红色人群)。
- 真阳性 ( TP ，蓝色分布)是真正拥有病毒的人。**
- 真阴性(TN，红色分布 ) 是真正没有病毒的人。**
- 假阳性(FP) 是根据检测得知确实没有生病而是的人，他们被假* ( 假)表示为生病 ( 阳性)。***
- 假阴性(FN) 是指确实患病但根据检测判断，他们被假* ( 假)表示为非 患病 ( 阴性)。*
为了存储所有这些性能指标，通常使用混淆矩阵。
混乱矩阵:获得 TPR，TNR，FPR，FNR。
分类器的混淆矩阵总结了我们的模型的性能的 TP、TN、FP、FN 度量。混淆矩阵可以进一步用于提取更多的性能指标，例如:TPR、TNR、FPR、FNR 和准确性。
使用上述所有术语，我们还可以构建由这些度量组成的著名的混淆矩阵，然后我们可以计算真阳性率和假阳性率，如下图所示，针对二进制分类情况。
图来自维基百科。
如果你想在交互式路线图和活跃的学习社区的支持下自学数据科学，看看这个资源:https://aigents.co/learn
处理多类分类问题
对于任何 N 类分类问题，混淆矩阵都可以很好地定义。然而，如果我们有 2 个以上的类(N > 2)，那么上述等式(在混淆矩阵图中)不再成立。
在这篇文章中，我展示了如何对任意数量的类(N)估计所有这些度量。
多类 Python 工作示例
-分类模型
在之前的帖子中，我解释了什么是 SVC 模型，所以这里我们将使用它作为我们的分类器。
-数据集
在虹膜数据集中，我们有花的 3 个类别和 4 个特征。所以分类问题不再是二元的了，因为我们有了 3 个类。
让我们加载 数据并检查每个 类有多少类和样本 :
*import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import plot_confusion_matrix
from sklearn.metrics import confusion_matrix# import some data to play with
iris = [datasets.load_iris](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html#sklearn.datasets.load_iris)()
X = iris.data
y = iris.target
class_names = iris.target_nameslabels, counts = np.unique(y, return_counts=True)
plt.bar(labels, counts, align='center')
plt.gca().set_xticks(labels)
plt.show()*
我们可以看到，我们有 3 个类/组(标签:0，1，2)，每个类/组中有 50 个(即条形的高度)样本(示例/观察)。
接下来，我们将在模型拟合之前将数据分成训练集和测试集:
*# Split the data into a training set and a test set
X_train, X_test, y_train, y_test = [train_test_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html#sklearn.model_selection.train_test_split)(X, y, random_state=0)*
接下来，让我们使用训练集合创建分类模型(线性 SVC)和拟合模型:
*# Fit the classifier
classifier = [svm.SVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC)(kernel='linear').fit(X_train, y_train)*
现在，我们将**预测**测试集样本的标签，并且我们将建立我们的三级分类问题的混淆矩阵**:
*# Predict the labels of the test set samples
predicted_labels = classifier.predict(X_test)# Build the confusion matrix of our 3-class classification problemcnf_matrix = confusion_matrix(y_test, predicted_labels)print(cnf_matrix)
#array([[13, 0, 0],
# [ 0, 15, 1],
# [ 0, 0, 9]])*
为了更好地阅读/理解混淆矩阵，让我们用来描绘和吧:
*disp = [plot_confusion_matrix](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_confusion_matrix.html#sklearn.metrics.plot_confusion_matrix)(classifier, X_test, y_test,
display_labels=class_names,
cmap=plt.cm.Blues)
plt.show()*
使用我们的线性 SVC 模型的 3 类分类混淆矩阵。
怎么读
- 在 x 轴上，我们有预测 标签，在 y 轴上，我们有真实 标签来自测试集的样本(记住预测仅使用**测试集)。
- 理想情况下，完美的* 分类器会导致混淆 矩阵，其中我们只有对角线上的值，也就是说，在这种情况下，我们对所有 3 个类别/组的所有测试样本进行了正确分类。***
- 方框中的数值只是计数。例如，在我们的例子中，左上角的盒子里面有一个值 13，接下来的两个盒子有 0 和 0。这意味着我们能够对所有 13 个 setosa 测试样本进行正确分类。
- 另一方面，通过查看第二个* 行即所指的到杂色 组，我们可以看到我们正确地将分类为 15 个杂色测试样本(在测试集中总共有 16 个)和遗漏了 1 个杂色测试样本即错误地***
最后，这里是魔法。****
我们将估计 FP、FN、TP、TN、TPR(灵敏度、命中率、召回率或真阳性率)、TNR(特异性或真阴性率)、PPV(精确度或阳性预测值)、NPV(阴性预测值)、FPR(脱落或假阳性率)、FNR(假阴性率)、FDR(假发现率)和 ACC(准确度)。
多类混淆矩阵。
*****FP = cnf_matrix.sum(axis=0) - np.diag(cnf_matrix)
FN = cnf_matrix.sum(axis=1) - np.diag(cnf_matrix)
TP = np.diag(cnf_matrix)
TN = cnf_matrix.sum() - (FP + FN + TP)FP = FP.astype(float)
FN = FN.astype(float)
TP = TP.astype(float)
TN = TN.astype(float)# Sensitivity, hit rate, recall, or true positive rate
TPR = TP/(TP+FN)
# Specificity or true negative rate
TNR = TN/(TN+FP)
# Precision or positive predictive value
PPV = TP/(TP+FP)
# Negative predictive value
NPV = TN/(TN+FN)
# Fall out or false positive rate
FPR = FP/(FP+TN)
# False negative rate
FNR = FN/(TP+FN)
# False discovery rate
FDR = FP/(TP+FP)
# Overall accuracy for each class
ACC = (TP+TN)/(TP+FP+FN+TN)*****
那都是乡亲们！希望你喜欢这篇文章！
参考
[1]https://en.wikipedia.org/wiki/Confusion_matrix
[2]https://sci kit-learn . org/stable/modules/generated/sk learn . metrics . confusion _ matrix . html
敬请关注并支持这一努力
如果你喜欢这篇文章并觉得它有用，请关注我，这样你就可以看到我所有的新帖子。
有问题吗？把它们作为评论贴出来，我会尽快回复。
最新帖子
***** [## 时间序列预测:用脸书的先知模型预测股票价格
使用可从《先知脸书》公开获得的预测模型预测股票价格
towardsdatascience.com](/time-series-forecasting-predicting-stock-prices-using-facebooks-prophet-model-9ee1657132b5) [## 用新冠肺炎假设的例子解释 ROC 曲线:二分类和多分类…
在这篇文章中，我清楚地解释了什么是 ROC 曲线以及如何阅读它。我用一个新冠肺炎的例子来说明我的观点，我…
towardsdatascience.com](/roc-curve-explained-using-a-covid-19-hypothetical-example-binary-multi-class-classification-bab188ea869c) [## 支持向量机(SVM)解释清楚:分类问题的 python 教程…
在这篇文章中，我解释了支持向量机的核心，为什么以及如何使用它们。此外，我还展示了如何绘制支持…
towardsdatascience.com](/support-vector-machines-svm-clearly-explained-a-python-tutorial-for-classification-problems-29c539f3ad8) [## PCA 清楚地解释了——如何、何时、为什么使用它以及特性的重要性:Python 指南
在这篇文章中，我解释了什么是 PCA，何时以及为什么使用它，以及如何使用 scikit-learn 在 Python 中实现它。还有…
towardsdatascience.com](/pca-clearly-explained-how-when-why-to-use-it-and-feature-importance-a-guide-in-python-7c274582c37e) [## 关于 Python 中的最小-最大规范化，您需要知道的一切
在这篇文章中，我将解释什么是最小-最大缩放，什么时候使用它，以及如何使用 scikit 在 Python 中实现它
towardsdatascience.com](/everything-you-need-to-know-about-min-max-normalization-in-python-b79592732b79) [## Scikit-Learn 的标准定标器如何工作
在这篇文章中，我将解释为什么以及如何使用 scikit-learn 应用标准化
towardsdatascience.com](/how-and-why-to-standardize-your-data-996926c2c832)
和我联系
- LinkedIn:【https://www.linkedin.com/in/serafeim-loukas/
- https://www.researchgate.net/profile/Serafeim_Loukas研究之门:
- https://people.epfl.ch/serafeim.loukasEPFL简介:
- 堆栈 溢出:https://stackoverflow.com/users/5025009/seralouk*****
多类分类—一对一和一对一
图 1:通过krishijagran.com拍摄的照片
介绍
机器学习主要有三种类型:
- 监督
- 无人监督的
- 加强
监督机器学习分为回归和分类。我们使用回归技术来预测连续变量的目标值，就像预测雇员的工资一样。相反，我们使用分类技术来预测给定输入数据的类别标签。
在分类中，我们设计分类器模型，然后使用输入训练数据对其进行训练，然后将测试数据分类到数据集中存在的多个类别标签中。
目录
- 什么是多类分类？
- 二元分类与多类分类
- 一个对所有
- 一对一
- 结论
让我们深入理解这个概念，
1.什么是多类分类？
图 2:通过learn-ml.com拍摄的照片
当我们解决一个只有两个类别标签的分类问题时，过滤数据、应用任何分类算法、用过滤后的数据训练模型以及预测结果都变得很容易。但是，当我们在输入训练数据中有两个以上的类实例时，分析数据、训练模型和预测相对准确的结果可能会变得复杂。为了处理这些多类实例，我们使用多类分类。
多类分类是一种分类技术，它允许我们将测试数据分类到训练数据中的多个类标签中，作为模型预测。
主要有两种类型的多类分类技术
- 一个对全部(一个对其余部分)
- 一对一
2.二元分类与多类分类
图 3:照片经由utkuufuk.com
二元分类
- 数据集中只有两个类实例。
- 它只需要一个分类器模型。
- 混淆矩阵易于推导和理解。
- 例如:-检查电子邮件是否是垃圾邮件，根据身高和体重预测性别。
多类分类
- 数据集中存在多个类标签。
- 分类器模型的数量取决于我们应用的分类技术。
- 一个对所有:- N 类实例然后 N 个二元分类器模型
- 一对一:- N 类实例然后 N (N-1)/2 二元分类器模型*
- 混淆矩阵很容易推导，但理解起来很复杂。
- 示例:-检查水果是苹果、香蕉还是橘子。
3.一对所有(一对其余)
在一对一分类中，对于 N 类实例数据集，我们必须生成 N-二元分类器模型。数据集中存在的类标签的数量和生成的二元分类器的数量必须相同。
图 4:cc.gatech.edu 通过的照片
如上图所示，假设我们有三个类，例如，类型 1 代表绿色，类型 2 代表蓝色，类型 3 代表红色。
现在，正如我之前告诉您的，我们必须生成与数据集中存在的类标签相同数量的分类器，因此我们必须在这里为三个相应的类创建三个分类器。
- 分类器 1:-[绿色]vs[红色、蓝色]
- 分类器 2:-【蓝色】vs【绿色，红色】
- 分类器 3:-[红色]vs[蓝色，绿色]
现在，为了训练这三个分类器，我们需要创建三个训练数据集。让我们考虑一下我们的主要数据集如下:
图 5: 主数据集
您可以看到数据集中有三个类别标签绿色、蓝色、和红色。现在我们必须为每个类创建一个训练数据集。
在这里，我们通过在该特征值的类列中放置+1 来创建训练数据集，该特征值仅与特定的类对齐。对于其余特性的开销，我们在 class 列中放-1。
图 6:绿色类训练数据集
图 7:蓝色类和红色类的训练数据集
让我们通过一个例子来理解它，
- 考虑第一行中的主数据集；我们有 x1，x2，x3 特征值，对应的类值是 G，也就是说这些特征值属于 G 类。所以我们在绿色类型对应的类列中放入+1 值。然后，我们对 x10、x11、x12 输入序列数据应用相同的方法。
- 对于与绿色类别不一致的特征的其余值，我们在它们的类别列中放置-1。
我希望你理解了训练数据集的创建。
现在，在为每个分类器创建训练数据集之后，我们将其提供给我们的分类器模型，并通过应用算法来训练该模型。
图 8:通过researchgate.net的照片
在训练模型之后，当我们将输入测试数据传递给模型时，该数据被认为是所有生成的分类器的输入。如果我们输入的测试数据有任何可能属于某个特定的类别，那么为该类别创建的分类器以 +1 的形式给出肯定的反应，所有其他分类器模型以 -1 的方式提供不良反应。类似地，二元分类器模型预测与相关类别对应的概率。
通过分析概率得分，我们预测结果为具有最大概率得分的类别索引。
图 9:SlidePlayer.com 通过的照片
- 让我们通过一个例子来理解，分别取三个测试特征值 y1、y2 和 y3。
- 我们将测试数据传递给分类器模型。我们以正面评级的形式获得了结果，该正面评级来自概率得分为( 0.9) 的绿色类分类器。
- 我们再次从蓝色类获得了正面评级，概率分数为 (0.4) ，从剩余的红色分类器获得了负面分类分数。
- 因此，基于正面响应和决定性概率得分，我们可以说我们的测试输入属于绿色类。
看下面的例子，使用内置的 one vs. rest (OvR) 技术拟合多类逻辑回归模型。
**#Import LogisticRegression() model from scikit_learn
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression#define dataset
X_train, y_train = make_classification(n_samples=500, n_features=8, n_informative=5, n_redundant=5, n_classes=4, random_state=1)#define classification model
Multiclass_model = LogisticRegression(multi_class='ovr')#fit model
Multiclass_model.fit(X_train, y_train)#make final predictions
y_pred = model.predict(X_train)**
4.一对一(卵)
图 10:通过ScienceDirect.com拍摄的照片
在一对一分类中，对于 N 类实例数据集，我们需要生成 N (N-1)/2 二元分类器模型。使用这种分类方法，我们将主数据集拆分为每个类的一个数据集，与每个其他类相对。*
以上面的例子为例，我们的分类问题有三种类型:绿色、蓝色和红色(N=3)。
我们把这个问题分成 N (N-1)/2 = 3 二元分类器问题:*
- 分类器 1:绿色对蓝色
- 分类器 2:绿色对红色
- 分类器 3:蓝色对红色
每个二元分类器预测一个类别标签。当我们将测试数据输入到分类器中时，具有多数计数的模型作为结果被推断出来。
5.结论
- 正如您所了解的 One vs. All 多类分类的工作原理，处理具有大量类实例的大型数据集是一项挑战。
- 因为我们生成了那么多分类器模型并对这些模型进行训练，所以我们从主数据集创建了那么多输入训练数据集。
- 在一对一多类分类中，我们为每对类将主数据集分割成一个二元分类数据集。
那都是民间的！！
在我的下一篇文章中再见！！
你好👋我希望你能从我的文章中获得知识。如果你愿意支持我，请随意给我买些咖啡🙏☕
https://www.buymeacoffee.com/amey23
或通过 ameypband23@gmail.com 联系我
乐意为您效劳。
基于 BERT 的多类别情感分析
基于 BERT 的 Yelp 评论多类别文本情感分析的简单快速实现
在本文中，我们将使用 BERT 对 Yelp 评论进行多类文本分类。
先决条件:
从这里克隆或下载 BERT Github 库
BERT 概述
BERT 是一个深度双向表示模型，用于通用“语言理解”从左到右和从右到左学习信息。 BERT 是根据从图书语料库(800 万字)和英语维基百科(2500 万字)中提取的未标注数据进行预训练的
伯特有两种型号
- BERT-base: 12 个编码器，带 12 个双向自关注头
- BERT-large: 24 个编码器，带 24 个双向自聚焦头
BERT-base 和 BERT-large 都有有壳和无壳版本。
- BERT 不区分大小写，其中文本在单词块标记化之前已经小写。例如，“詹姆斯·邦德”变成了“詹姆斯·邦德”。它还会删除重音标记。
- 带大小写的保留真实大小写和重音标记。
大多数情况下，我们将使用 BERT-Uncased，除非用例要求保留对于 NLP 任务至关重要的案例信息。
BERT 的基本设置
我们需要 Tensorflow 版本 1.11 或更高版本来运行 BERT 代码。
下载预训练权重和数据集后，我们需要对多类分类进行一些更改。
我们克隆或下载的代码会有一个文件run _ classifier . py。我们需要更新 类 ColaProcessor 中的方法 get_labels ()，如下所示，用于多类文本分类
二元分类的原始代码
**def get_labels(self):
return [“0”, “1”]**
修改了多类文本分类的代码
**def get_labels(self):
return [“0”, “1”, “2”, “3”, “4”]**
为 BERT 构建数据集
导入数据处理所需的库
***import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split***
读取从文件中提取的 Yelp 审查训练和测试数据
***data_train= pd.read_csv(“yelp_review_full_csv\\train.csv”, header=None)******data_test= pd.read_csv("yelp_review_full_csv\\test.csv", header=None)******data_train.head(5)***
查找类别标签的唯一值
**data_train[0].unique()**
值为 1 表示差评，值为 5 表示优评。
您可能希望类标签从 0 开始，所以我们从当前标签值中减去 1。现在，值为 0 表示差评，值为 4 表示差评
**data_train[0] = (data_train[0] -1)
data_test[0] = (data_test[0] -1)
data_train[0].unique()**
更新多类文本分类的 BERT 码
在文件 run_classifier.py、 中修改方法get _ labels()类 ColaProcessor 并更新标签以匹配我们在训练数据中的内容
**def get_labels(self):
return [“0”, “1”, “2”, “3”, “4”]**
在 BERT 中处理不同 NLP 任务的类要求数据采用. tsv(制表符分隔值)文件格式的特定格式。
- 列 0: GUID: 该行的 ID。训练和测试数据都需要
- 第 1 列:第行的分类标签。该列的值应该与方法get _ labels(cola processor文件run _ classifier . py中指定的值相匹配。仅训练数据需要。**
- 列 2: alpha: 这是用于文本分类的虚拟列，但是对于 BERT 的训练数据是需要的
- 第 3 列:文本:这是要分类的文本。训练和测试数据都需要此列
为培训、开发和测试构建 BERT 数据集
BERT 需要三个不同的数据集:用于训练的 train 和 dev 以及用于预测的 test
*# Creating dataframe according to BERT data requirements by adding the required columns in the right order***df_bert = pd.DataFrame({
‘id’:range(len(data_train)),
‘label’:data_train[0],
‘alpha’:[‘a’]*data_train.shape[0],
‘text’: data_train[1].replace(r’\n’, ‘ ‘, regex=True)
})******df_bert.head()****
符合 BERT 要求格式的数据
将数据分为训练和开发或评估数据集
*# Splitting training data file into *train* and *test*
***df_bert_train, df_bert_dev = train_test_split(df_bert, test_size=0.01)****
构建测试数据集
我们在测试数据集中只需要两列
- 列 0: GUID: 行的 ID。
- 第 1 列:文本:这是要分类的文本。
*# Creating test dataframe according to BERT
**df_bert_test = pd.DataFrame({
‘id’:range(len(data_test)),
‘text’: data_test[1].replace(r’\n’, ‘ ‘, regex=True)
})****df_bert_test.tail()***
根据 BERT 测试数据集
将数据帧保存到不带标题的. tsv 文件，用于培训和开发，但文件 test.tsv 文件需要标题
*# Saving dataframes to .tsv format as required by BERT
**df_bert_train.to_csv(‘yelp_review_full_csv\\train.tsv’, sep=’\t’, index=False, header=False)****df_bert_dev.to_csv(‘yelp_review_full_csv\\dev.tsv’, sep=’\t’, index=False, header=False)****df_bert_test.to_csv(‘yelp_review_full_csv\\test.tsv’, sep=’\t’, index=False, header=True)***
训练 BERT 模型
我们将加载预训练的基于 BERT 的无案例模型权重，并在 Yelp 评论数据集上训练该模型。让我们了解一下我们需要为培训设置的参数。
我们需要训练多类文本分类，因此我们将使用 run_classifier.py 文件。
- task_name :这是我们计划用于培训的任务。选项有
- CoLA :语言可接受性的语料库是一个二元单句分类任务，是 ColaProcessor 类。目标是预测一个英语句子在语言学上是否“可接受”**
- MNLI : 多体裁自然语言推理是一项大规模、众包的蕴涵分类任务。给定一对句子，目标是预测第二个句子相对于第一个句子是蕴涵、矛盾还是中性的
- MRPC:微软研究院释义语料库由从在线新闻来源自动提取的句子对组成。目标是检查句子对中的句子是否语义等价
- XNLI:跨语言自然语言推理使用了 15 种语言的跨语言句子分类。
2. do_train :设置为 True 进行训练。这将使用 train.tsv 文件进行训练
3. do_eval :设置为 True 进行评估。这将使用 dev.tsv 文件进行评估
4. data_dir :包含数据的目录。tsv 文件
5. vocab_file :指定 vocab.txt 文件。Vocab.txt 使用 BERT 提供的 Vocab 文件将单词映射到索引。词汇表有 119，547 个单词块标记
6. bert_config_file :包含 bert 模型的参数值。伯特预训练模型有这个文件
7. init_checkpoint :初始检查点，通常从预先训练好的检查点开始。如果您是从中断的地方恢复训练过程，或者训练被中断，则提到最后一个检查点文件名。
8. max_seq_length :已发布的模型使用最长 512 的序列长度进行训练，但是您可以使用更短的最大序列长度进行微调，以节省大量内存。更长的序列非常昂贵，因为注意力与序列长度成二次关系。短于指定长度的序列被填充
9. train_batch_size :训练的总批量。内存使用量也与批处理大小成正比。默认值为 32。仅为培训指定此参数。
10.learning _ rate:Adam 的初始学习速率。默认学习率为 0.00005。仅为培训指定此参数。
11. num_train_epochs :要执行的训练总次数。仅为培训指定此参数。
12. output_dir :输出目录，其中将写入模型检查点以及评估数据集的细节。您需要在为训练或推理指定该目录之前创建它。
13. do_lower_case :是否对输入文本进行小写处理。对于无套管模型应为真，对于有套管模型应为假。指定仅用于培训。
14. save_checkpoints_steps :指定保存模型检查点的频率。指定仅用于培训。
对于培训，请在命令提示符下使用以下命令
***python run_classifier.py**
--**task_name=cola**
--**do_train=true**
--**do_eval=true**
--**data_dir=\yelp_review_full_csv\**
--**vocab_file=\BERT\uncased_L-12_H-768_A-12\uncased_L-12_H-768_A-12\vocab.txt**
--**bert_config_file=\BERT\uncased_L-12_H-768_A-12\uncased_L-12_H-768_A-12\bert_config.json**
--**init_checkpoint=\BERT\uncased_L-12_H-768_A-12\uncased_L-12_H-768_A-12\bert_model.ckpt**
--**max_seq_length=64**
--**train_batch_size=2**
--**learning_rate=2e-5**
--**num_train_epochs=3.0**
--**output_dir=\BERT\bert_output\**
--**do_lower_case=True**
--**save_checkpoints_steps 10000***
训练完成后，您可以看到包含开发数据集摘要的检查点文件和 eval_results.txt 文件
***eval_accuracy = 0.71553844
eval_loss = 1.035305
global_step = 1287000
loss = 1.0362284***
预测情绪
为了预测情绪，我们设置以下参数并将 — do_predict 参数设置为 True。
- 任务名称:应该与用于训练数据集的任务名称相匹配
- data_dir :指定包含 test.tsv 文件中数据的目录
- vocab_file :指定 vocab.txt 文件。Vocab.txt 使用 BERT 提供的 Vocab 文件将单词映射到索引。
- bert_config_file :包含 bert 模型的参数值。伯特预训练模型有这个文件
- init_checkpoint :初始检查点。这是输出目录中模型检查点文件的最大数量。
- 最大序列长度:指定最大序列长度。
- output_dir :将测试结果写入 test_results.tsv 文件的输出目录
***python run_classifier.py**
**--task_name=cola
--do_predict=true
--data_dir=\yelp_review_full_csv\
--vocab_file=\BERT\uncased_L-12_H-768_A-12\uncased_L-12_H-768_A-12\vocab.txt **
**--bert_config_file=\BERT\uncased_L-12_H-768_A-12\uncased_L-12_H-768_A-12\bert_config.json**
**--init_checkpoint=\BERT\bert_output\model.ckpt-1085250
--max_seq_length=128
--output_dir=\BERT\bert_output\***
评估测试结果
测试结果在文件 test_results.tsv 的输出目录中，您可以将它与测试标签进行比较，并评估我们的多类文本分类的性能
阅读并解释结果
每个文本的结果在 test_results.tsv 文件中都有一行，其中包含五个标记类中每一个的概率。
我们需要找到概率最高的类，这将是 Yelp 评论的观点
***import csv
label_results=[]
pd.DataFrame()
with open('\BERT\bert_outout\test_results.tsv') as file:
rd = csv.reader(file, delimiter="\t")
for row in rd:
data_1=[float(i) for i in row]
label_results.append(data_1.index(max(data_1)))
df_results=pd.DataFrame()
df_results=pd.DataFrame(label_results)
df_results[0]***
现在我们为从 0 到 4 的情感范围生成混淆矩阵
***from sklearn.metrics import confusion_matrix
confusion_matrix(data_test[0], df_results[0])***
混淆矩阵
我已经在一个时期训练了 BERT 模型，你可以看到对于多类文本分类来说结果看起来不错
*from sklearn import metrics
print("Accuracy",metrics.accuracy_score(data_test[0], df_results[0]))
print("F1-Score",metrics.f1_score(data_test[0], df_results[0],average='weighted'))*
参考资料:
这是一个 24 个较小的 BERT 模型的版本(只有英语，未封装，用单词屏蔽训练),参考…
github.com](https://github.com/google-research/bert)
https://MC . ai/a-guide-to-simple-text-class ification-with-Bert/*
基于 BERT 深度学习的多类文本分类
图片来源:Pexels
自然语言处理，自然语言处理，拥抱脸
大多数研究人员将他们的研究论文提交给学术会议，因为这是一种更快捷的公布结果的方式。寻找和选择一个合适的会议一直具有挑战性，尤其是对年轻的研究人员来说。
然而，根据以前的会议进展数据，研究人员可以增加论文被接受和发表的机会。我们将尝试使用 BERT 用深度学习解决这个文本分类问题。
几乎所有的代码都取自这个教程，唯一的区别就是数据。
数据
数据集包含 2507 篇研究论文标题，已被人工分类为 5 类(即会议)，可从此处下载。
探索和预处理
conf _ explorer . py
表 1
df['Conference'].value_counts()
图 1
你可能已经注意到了我们的班级不平衡，我们将在稍后解决这个问题。
给标签编码
标签 _ 编码. py
df['label'] = df.Conference.replace(label_dict)
培训和验证分割
因为标签是不平衡的，我们以分层的方式分割数据集，用它作为类别标签。
拆分后，我们的标签分布将如下所示。
训练 _ 测试 _ 拆分. py
图 2
BertTokenizer 和编码数据
记号化是将原始文本分割成记号的过程，记号是表示单词的数字数据。
- 构造一个 BERT 记号化器。基于文字部分。
- 实例化一个预训练的 BERT 模型配置来编码我们的数据。
- 为了将所有的标题从文本转换成编码形式，我们使用了一个名为
batch_encode_plus的函数，我们将分别处理训练和验证数据。 - 上述函数中的第一个参数是标题文本。
add_special_tokens=True表示序列将使用与其模型相关的特殊标记进行编码。- 当将序列批处理在一起时，我们设置了
return_attention_mask=True，因此它将根据由max_length属性定义的特定标记器返回注意掩码。 - 我们还想填充所有的标题到一定的最大长度。
- 我们实际上不需要设置
max_length=256，只是为了安全起见。 return_tensors='pt'返回 PyTorch。- 然后我们需要将数据拆分成
input_ids、attention_masks和labels。 - 最后，在我们得到编码数据集之后，我们可以创建训练数据和验证数据。
tokenizer_encoding.py
BERT 预训练模型
我们将每个标题视为其唯一的序列，因此一个序列将被归类到五个标签之一(即会议)。
bert-base-uncased是一个较小的预训练模型。- 用
num_labels表示输出标签的数量。 - 我们其实并不关心
output_attentions。 - 我们也不需要
output_hidden_states。
BERT_pretrained_model.py
数据加载器
DataLoader组合数据集和采样器，并在给定的数据集上提供可迭代的。- 我们使用
RandomSampler进行训练，使用SequentialSampler进行验证。 - 鉴于我的环境内存有限，我设置了
batch_size=3。
data_loaders.py
优化器和调度器
- 要构建一个优化器，我们必须给它一个包含要优化的参数的 iterable。然后，我们可以指定特定于优化器的选项，如学习率、ε等。
- 我发现
epochs=5很适合这个数据集。 - 创建一个学习率从优化程序中设置的初始学习率线性降低到 0 的调度，在此期间，学习率从 0 线性增加到优化程序中设置的初始学习率。
优化程序 _ 调度程序. py
性能指标
我们将使用 f1 分数和每节课的准确度作为性能指标。
performance_metrics.py
训练循环
培训 _loop.py
图 3
加载和评估模型
loading_evaluating.py
图 4
Jupyter 笔记本可以在 Github 上找到。享受余下的周末吧！
回归中的多重共线性
为什么这是个问题？如何检查和修理
来源:by @jjying 来自 unsplash
当回归模型中的独立变量彼此高度相关时，会发生多重共线性。这使得很难解释模型，并且还产生过拟合问题。人们在选择回归模型中的变量之前会进行测试，这是一个常见的假设。
我以前在为时间序列数据构建回归模型时遇到过严重的多重共线性问题。我根据不同的时间段创建了多个特征，如 1 个月的总回报、6 个月的总回报和 1 年的总回报，以获得更多的输入变量。然而，这些特征彼此高度相关。例如，如果一只股票在过去一年表现良好，那么它很可能在最近一个月表现良好。我需要放弃这些变量中的一些，或者找到一种方法使它们不那么相关。我将在文章的后面解释解决这个问题的不同方法。
为什么多重共线性是一个问题？
当独立变量高度相关时，一个变量的变化会引起另一个变量的变化，因此模型结果波动很大。如果数据或模型发生微小变化，模型结果将会不稳定且变化很大。这将产生以下问题:
- 如果模型每次给你不同的结果，你将很难选择模型的重要变量列表。
- 系数估计不稳定，你很难解释这个模型。换句话说，如果你的一个预测因子改变了 1 个单位，你就无法判断输出的变化程度。
- 模型的不稳定性可能导致过度拟合。如果将该模型应用于另一个数据样本，则与训练数据集的准确性相比，准确性会显著下降。
根据具体情况，如果仅出现轻微或中等程度的共线性问题，则对于您的模型来说可能不是问题。但是，如果存在严重的共线性问题(例如，两个变量之间的相关性> 0.8 或方差膨胀因子(VIF) >20)，强烈建议解决该问题
如何检查是否出现多重共线性？
第一个简单的方法是画出所有自变量的相关矩阵。
我用了 Kaggle 竞赛的住房数据。竞赛的目标是使用房屋数据输入来正确预测销售价格。我在这里选择了一些数值变量来包含在我的模型中。
#plot color scaled correlation matrix
corr=house_selected.corr()
corr.style.background_gradient(cmap='coolwarm')
住房数据的彩色标度相关矩阵
在绘制相关矩阵并对背景进行颜色缩放后，我们可以看到所有变量之间的成对相关性。我还在这里加入了因变量“销售价格”。这是因为当我试图选择包含在模型中的独立变量时，这是我的一个秘密技巧。
当你不知道模型中包含哪些变量时，只需做一个相关矩阵，选择那些与因变量高度相关的自变量。
回到多重共线性问题，我们可以看到，从相关矩阵中，有相当多的变量是相互关联的。有一对相关系数大于 0.8 的自变量是地下室总表面积和一层表面积。具有较大地下室面积的房屋往往也具有较大的一楼面积，因此高相关性是可以预期的。
检查多重共线性的第二种方法是对每个自变量使用方差膨胀因子(VIF)。它是多重回归变量集合中多重共线性的度量。VIF 值越高，该变量与其他变量的相关性越高。
#Compute VIF data for each independent variable
from statsmodels.stats.outliers_influence import variance_inflation_factor
vif = pd.DataFrame()
vif["features"] = house_selected.columns
vif["vif_Factor"] = [variance_inflation_factor(house_selected.values, i) for i in range(house_selected.shape[1])]
vif
住房模型数据的 VIF 结果-原始
如果 VIF 值高于 10，通常被认为与其他自变量有很高的相关性。然而，接受范围受到要求和约束。从结果中，我们可以看到大多数特征与其他自变量高度相关，只有两个特征可以通过低于 10 的阈值。
如何修复多重共线性问题？
- 变量选择
最直接的方法是删除一些与其他变量高度相关的变量，将更重要的变量留在集合中。例如，当我们绘制包含“销售价格”的相关矩阵时，我们可以看到整体质量和地面居住面积与因变量“销售价格”的相关性最高，因此我将尝试将它们包含在模型中。
住房模型数据的 VIF 结果-选择后
我们可以看到，使用简单的消去法，我们能够显著降低 VIF 值，同时保留重要的变量。然而，一些变量如整体质量和建造年限仍然有很高的 VIF 值，它们在预测房价时很重要。如何？有时我们可以使用第二种方法中描述的小技巧来转换变量。
2.变量转换
第二种方法是转换一些变量，使它们不那么相关，但仍然保持它们的特征。我这么说是什么意思？在房屋模型示例中，我可以通过用建造年份减去当前年份，将“建造年份”转换为“房屋年龄”。例如，如果建筑年份是 1994 年，那么房子的年龄是 2020–1994 = 26 年。
住房模型数据的 VIF 结果-转换为 house_age 后
在我将建筑年限转换为房龄后，新的“房龄”因子的 VIF 下降到一个可接受的范围，整体质量的 VIF 值也下降了。
在我开始提到的时间序列分析的例子中，我也转换了变量，使它们不那么相关。例如，过去 1 个月的总回报与过去 6 个月的总回报高度相关。我从过去 6 个月的回报中减去过去 1 个月的回报，得到不包括过去一个月的前 5 个月回报的新变量。相关性结果更容易接受，我能够将这两个变量作为我的模型特征。
3.主成分分析
主成分分析(PCA)通常用于通过将数据分解成多个独立的因子来降低数据的维度。它有许多应用，如通过减少预测因子的数量来简化模型计算。然而，在我们的例子中，我们将只使用 PCA 的变量独立性来消除模型中的多重共线性问题。
#Create the new data frame by transforming data using PCA
import numpy as np
from sklearn.decomposition import PCA
pca = PCA(n_components=6)
components=pca.fit_transform(house_adjusted)
componentsDf=pd.DataFrame(data=components,columns=['component 1','component 2','component 3','component 4','component 5','component 6'])#Calculate VIF for each variable in the new data frame
vif = pd.DataFrame()
vif["features"] = componentsDf.columns
vif["vif_value"] = [variance_inflation_factor(componentsDf.values, i) for i in range(componentsDf.shape[1])]
vif
住宅模型数据的 VIF 结果 PCA 转换后
与原始数据相比，我仍然保留相同数量的变量，我们可以看到，现在这 6 个变量彼此完全不相关。我们可以用新的 6 个变量作为自变量来预测房价。
这种方法的弊端也非常明显。在 PCA 变换之后，我们没有每个变量的同一性，并且将很难解释结果。
结论和建议
在建立回归模型之前，我们每次都应该检查多重共线性的问题。VIF 是一种简单的方法，可以观察每个独立变量，看它们是否与其他变量高度相关。当您不确定为模型选择哪些变量时，相关矩阵将有助于选择重要的因素。相关矩阵还有助于理解为什么某些变量具有高 VIF 值。
就修复多重共线性问题的方法而言，我个人不喜欢这里的 PCA，因为模型解释将会丢失，当您想要将模型应用于另一组数据时，您需要再次进行 PCA 转换。因此，我们应该尽最大努力通过选择正确的变量来减少相关性，并在需要时进行转换。当变量具有相对较高的 VIF 值，而且对预测结果也很重要时，您可以决定是否保留该变量。试错法总是包括不同的变量集，建立模型并根据测试数据进行测试，以查看是否有任何过度拟合。
你认为在构建模型之前，你已经完成了所有的统计假设检查了吗？不，你不是！如果你想了解更多关于回归模型中的其他统计假设，请参考我下面的另一篇关于回归模型中的正态假设的文章。
博克斯-考克斯变换，夏皮罗-维尔克检验，QQ 图
towardsdatascience.com](/is-normal-distribution-necessary-in-regression-how-to-track-and-fix-it-494105bc50dd)
基于标签的多领域文本分类
Labelur 允许你通过 REST API 对多领域文本进行分类。Labelur 使用现代零镜头学习技术进行多领域文本分类，无需训练定制模型。
什么是 Labelur？
Labelur 是一个执行多领域文本分类的在线服务。上手毫不费力！只需使用您选择的任何编程语言，如 Python、Java、Node 或 PHP(谁还在使用 PHP？)用您的文本数据向 Labelur 的 API 服务器发送 POST 请求。Labelur 将回复给定文本的标签。
Labelur 与其他文本分类有何不同
大多数文本分类服务只处理特定领域的数据，如情感分析、法律文档分类或通用主题的通用文本分类。如果你想为一个特定的领域做一个分类器，比如房地产，你需要有一个训练数据，创建一个分类器。传统上，如果没有数据来训练自定义模型，就无法产生好的文本分类器。
Labelur 使用 NLP 中的现代进步来分类大多数通用领域中的文本。它利用知识提炼和零炮学习对文本进行分类。如果您没有自己的数据或者不想训练和部署自己的 ML 模型，这是一个极好的起点。
让我们对一些文本进行分类！
我将用 Python 做一个演示，但是同样的，你可以使用任何你选择的语言。首先，创建一个帐户并获得您的 API 密钥。
API 密钥已被编辑
我将使用 Python 的请求库向 Labelur 的服务器发送 POST 请求。JSON 库将用于 JSON 化我们的文本负载，Matplot 将用于绘制最终结果。
在这里，我们必须遵循有效载荷模式。有效载荷需要有文本和 标签作为键。标签的值将由一列字符串组成，文本的值也将是一个字符串。在选择可能的标签类别时，我们必须选择一个尽可能描述该类别的词。
例如，在文本“了解美国的邮寄投票”中，我们提供的标签是“体育”、“政治”和“选举”。下面是 Labelur 返回的结果。
Labelur 的结果
总之
我们只用了 3 分钟就创建了一个帐户，并开始使用 Labelur 对文本进行分类。如果您没有数据来训练自己的模型，或者不想处理部署 ML 模型的麻烦，Labelur 可能是您的一个很好的解决方案。
注意:Labelur 目前处于测试版，API 仅通过邀请提供。
使用传单和 amCharts 在浏览器中进行多方面的数据探索
在浏览器中创建一个数据探索仪表板，从 Google Sheets 加载实时记录，并将地理空间信息与时间数据交叉。
演示:https://smarques.github.io/mufa-leaf/
(演示中的数据是随机的，真正的研究还没有发表。)
在这个充满挑战的 CoVid 时代，我被要求对我居住的意大利地区进行数据可视化。
这些数据由大约 20k 条记录组成，按照子行业、主题类型、数据来源和活动开始的年份进行地理参考和标记。
例如:
subsector =>sub C1，
subject =>subject 2，
year = > 1985，
position =>【45.375302，11.727905】
source =>gov . Census
我的目标是以不同的方式探索这些数据:
- 作为地图上的标记和聚类-
-作为可导航的树形图-
-通过过滤器和时间轴选择器
理想情况下，这种可视化应该应用于整个数据集或选定的数据子集，以便您可以应用过滤器，查看特定年份的分布情况，也可能仅针对给定省份的特定子行业。
想法是将数据作为 JSON 结构加载到浏览器中，并保存在内存中，根据用户与过滤器的交互加载子集，并将子集数据提供给每个可视化。
我在这里将会介绍一些流程，具体的实现请参考 GitHub repo:https://github.com/smarques/mufa-leaf
准备数据
由于数据仍在修改和重新分类中，我想从一个共享的谷歌表单中加载它。我还用谷歌工作表对地址进行地理编码，使用的是这个漂亮的谷歌工作表宏。
因为人们仍在使用 google sheet，所以我决定在将数据导入我的 JS 应用程序时直接进行数据检查和数据清理。
要从 Google 工作表中加载数据，我找到的最佳选项是 Papa Parse 。它可以让你把 CSV 解析成 JSON，从任何地方加载，处理大文件，所有的事情，而且它有一个有趣的名字。
让我们试一试。
首先，您需要在 Google 表单上执行两个操作:
- 发布到 web:文件->发布到 web，复制网址，会是这样的:https://docs.google.com/spreadsheets/d/e/<哈希>/pub html
- 分享:点击右上方的分享按钮，然后点击获取可分享链接。这将打开按链接共享，任何有链接的人都可以看到数据。
你需要提供给 Papa Parse 的 url(呀，这个名字真有趣)是 https://docs.google.com/spreadsheets/d/e/T4<哈希> /pub？输出= CSV
你也可以直接从 google sheets 导出 JSON 格式的数据，但是我们的朋友 Papa 给了我们更多的类型转换、数据清理等选项。
完成后，您只需通过以下方式导入数据:
https://gist . github . com/smarques/3d bfaaae 4 B3 D8 a 204 D2 AC 280 f 488528 e
processData 函数负责清理和提炼我们从 Google Sheets 收到的数据。有时你需要应用一些正则表达式，删除奇怪字符，修复输入错误。
创建聚类地图
现在的目标是让这些家伙在地图上，可能在三个不同的层和不同的标记颜色层。我们还希望标记有一个不同的主题类型的图标。因为我们有将近 30k 个标记，所以设置一些聚类可能是个好主意。
我选择的地图库是传单。它有很棒的代码和文档，非常灵活，有一个很好的插件生态系统。
我添加了几个插件，如:
传单全屏控制因为我只是喜欢让地图全屏
传单轻松打印:有几个打印插件，但这似乎对我最有效
传单提供者:要轻松混合和匹配不同来源的瓷砖，我必须提到雄蕊水彩瓷砖因为它们真的很赏心悦目。
传单牛逼标记让你在地图标记上使用牛逼字体图标
现在，如果您只需显示并最终过滤传单地图上的标记，通常的做法是将标记添加到相应的图层，然后调用地图上的函数来隐藏或显示整个图层或特定标记。我的想法有点不同，我想将所有数据保存在应用程序级别，这样我不仅可以将它用于地图，还可以用于其他图形和小部件。当我们应用过滤器时，我希望在应用程序级别过滤数据，随后重新绘制地图，以及应用程序中任何其他数据相关的小部件。
此时的问题是:地图和图形的重绘速度是否足够快，以提供良好的用户体验和数据探索？
让我们来了解一下。(剧透:yayyy 他们做)
因此，我们在应用程序中有一个名为 currentData 的变量，它保存当前显示的完整记录集的子集。每次用户改变选择过滤器时，我们从 App.data 开始创建一个新的数据选择，保存到 App.currentData 中，并触发每个小部件的重绘。
updateCurrentData(App.data);
即使我们只是在清理数据后初始化应用程序，我们也可以调用 update 函数来填充应用程序 currentData ，因为用户没有机会过滤记录集，函数将只选择每一条记录，我们就可以开始了。
现在让我们看看如何使用地图小部件。
没有聚类，地图会有点拥挤:不是很有用，而且在你的浏览器上也很沉重。
因此，让我们使用传单添加一个聚类级别。标记集群。
我根据标记所属的子部门来构造标记，这里只有 4 个可能的值，所以让每个子部门在不同的层上会使每个组的开关变得非常容易。此外，这将使每个子行业有可能有单独的集群，使显示更有趣，并为数据分布提供更好的线索。
MarkerCluster 允许您自定义显示聚类标记的功能(因此得名..)因此，根据集群的大小，我有稍微不同的标记。(例如，参见 9 对 325 红色星团)。
对于四个扇区中的每一个，我们实例化一个标记集群组，给出一个 iconCreateFunction，如前所述。我还在集群图标上添加了一个鼠标悬停功能，这样你就可以通过将鼠标悬停在一个层上来向上浮动(改变它的 z 索引)。
我还想强调这项研究涉及的领域。传单让你加载 GeoJSON 所以我所要做的就是在 GitHub 中搜索带有该区域形状的 GeoJSON，并将其加载到自己的图层上。(感谢斯特凡诺·库迪尼)
L.geoJson(venetoData).addTo(App.mainMap);
过滤器！
我希望所有的过滤器都集成到地图中，所以我在地图的右侧添加了一个侧面板，让您可以打开不同的过滤器控制面板。
我为整个子行业或某个行业内的单个主题创建了过滤器。然后过滤每个省
并且对于每个数据源
我不会深入讨论所有过滤器 gui 的实现细节，您可以在 GitHub repo 上查找，基本上是为了避免回调地狱每个 gui 元素都使用 bacon.js (一个反应函数库)连接到一个事件流。这样，任何过滤器中的任何更改都会导致调用相同的更新函数，传递完整的过滤器值集，以便我们可以将所有需要的条件应用到完整的数据集，并为每个要显示的小部件加载新的 currentData 子集。
更新功能
因为我希望将数据过滤保持在主应用程序级别，所以每次过滤器发生变化时，我都会调用一个更新函数来从整个集合中提取相关数据。
我使用一个名为 的 js 库 alasql 根据用户选择的过滤器处理 15k 记录数组。其中，alasql 允许您对任何对象数组运行 sql 查询。这使得处理您的数据变得非常容易，并且使您的代码可读，易于调试和维护。
我可以运行如下查询:
var res = alasql(`SELECT MIN(${App.field_names.year}) AS minYear, MAX(${App.field_names.year}) AS maxYear FROM ? WHERE ${App.field_names.year} > 1900`, [App.currentData]);
至此，我在 update 函数中所要做的就是构建一个条件数组来添加到我的 SELECT 语句中。
事实证明，如果您删除所有图层标记并重新添加它们，MarkerCluster 的更新速度非常快，所以当我有一个新的 currentData 对象时，我只需运行它并重新分配它。
时间轴选择器
接下来，我们希望能够根据年间隔选择记录。
传单控件只是 html 元素，所以我使用了 Ion。RangeSlider 并将其值添加到触发新查询和后续重绘的反应流中。
当我第一次从 Google Sheet 接收数据时，我只获得了 year 列的最小值和最大值，所以我可以用它来显示时间选择器的合理范围。
树形图
作为最后一个元素，我们添加了一个树形图，这样我们就可以可视化所选子集的结构。我包含了 amCharts 库，并在我的更新函数中设置了一个调用来重绘图表。我选择按省份开始分解。
然后，您可以点击树形图块，在可视化视图中向下钻取。
包装它
因此，现在我们有了一个主应用程序层，它负责加载完整的数据，根据不同的过滤器和用户行为进行子选择，然后触发不同图形和小部件的更新。这是一个很好的框架，可以让用户在浏览器中探索数据，并且很容易添加更多的可视化。关键是它们都引用相同的数据子集。
例如，当您更改 year 参数时，查看位置和数据结构如何变化非常有用。您可以添加一个播放按钮，并创建一个显示每年变化的动画。
另一个改进是通过 IndexedDb (alasql 支持它)同步本地存储上的数据，以便您有完整的离线体验。
如果你想添加元素或进行实验，请随意在 GitHub 上提出请求！
Pytorch 中的多 GPU 培训
数据和模型并行性
安娜·安彻的《收割机》。链接:维基百科。
这篇文章将概述 Pytorch 中的多 GPU 培训，包括:
- 在一个 GPU 上训练；
- 多 GPU 上的训练；
- 通过一次处理更多的例子，使用数据并行性来加速训练；
- 使用模型并行性来支持需要比一个 GPU 上可用的内存更多的内存的训练模型；
- 使用 num_workers > 0 的数据加载器来支持多进程数据加载；
- 仅在可用设备的子集上训练。
在一个 GPU 上训练
假设您有 3 个可用的 GPU，并且您想在其中一个上训练一个模型。您可以通过指定设备来告诉 Pytorch 使用哪个 GPU:
device = torch.device('cuda:0') for GPU 0device = torch.device('cuda:1') for GPU 1device = torch.device('cuda:2') for GPU 2
在多个 GPU 上训练
要允许 Pytorch“查看”所有可用的 GPU，请使用:
device = torch.device('cuda')
使用多个 GPU 有几种不同的方式，包括数据并行和模型并行。
数据并行度
数据并行是指使用多个 GPU 来增加同时处理的实例数量。例如，如果 256 的批处理大小适合一个 GPU，您可以通过使用两个 GPU 使用数据并行性将批处理大小增加到 512，Pytorch 会自动将大约 256 个示例分配给一个 GPU，将大约 256 个示例分配给另一个 GPU。
使用数据并行可以通过数据并行轻松实现。例如，假设您有一个名为“custom_net”的模型，该模型当前初始化如下:
import torch, torch.nn as nnmodel = custom_net(**custom_net_args).to(device)
现在，使用数据并行性所要做的就是将 custom_net 包装在 DataParallel 中:
model = nn.DataParallel(custom_net(**custom_net_args)).to(device)
您还需要增加批量大小，以最大限度地利用所有可用设备。
有关数据并行性的更多信息，请参见本文。
模型并行度
您可以使用模型并行性来训练需要比一个 GPU 上可用的内存更多的内存的模型。模型并行性允许您将模型的不同部分分布在不同的设备上。
使用模型并行有两个步骤。第一步是在模型定义中指定模型的哪些部分应该在哪个设备上运行。这里有一个来自 Pytorch 文档的例子:
**import** torch
**import** torch.nn **as** nn
**import** torch.optim **as** optim
**class** **ToyModel**(nn**.**Module):
**def** __init__(self):
super(ToyModel, self)**.**__init__()
self**.**net1 **=** torch**.**nn**.**Linear(10, 10)**.**to('cuda:0')
self**.**relu **=** torch**.**nn**.**ReLU()
self**.**net2 **=** torch**.**nn**.**Linear(10, 5)**.**to('cuda:1')
**def** **forward**(self, x):
x **=** self**.**relu(self**.**net1(x**.**to('cuda:0')))
**return** self**.**net2(x**.**to('cuda:1'))
第二步是确保在调用 loss 函数时，标签与模型的输出在同一个设备上。
例如，您可能希望从将标签移动到设备“cuda:1”并将数据移动到设备“cuda:0”开始。然后，您可以在“cuda:0”上用模型的一部分处理您的数据，然后将中间表示移动到“cuda:1”，并在“cuda:1”上生成最终预测。因为您的标签已经在“cuda:1”上，Pytorch 将能够计算损失并执行反向传播，而无需任何进一步的修改。
有关模型并行性的更多信息，请参见本文。
使用 Num_Workers 加快数据加载速度
Pytorch 的数据加载器提供了一种自动加载和批处理数据的有效方法。您可以将它用于任何数据集，不管它有多复杂。您需要做的就是首先定义您自己的数据集，该数据集继承自 Pytorch 的 Dataset 类:
from torch.utils.data import DataLoaderclass MyComplicatedCustomDataset(Dataset):
def __init__(self, some_arg, some_other_arg):
"""Documentation"""
self.some_arg = some_arg
self.some_other_arg = some_other_arg
# Pytorch Required Methods # — — — — — — — — — — — — — — —
def __len__(self):
"""Return an integer representing the total number of
examples in your data set"""
return len(self.my_list_of_examples)
def __getitem__(self, idx):
"""Return a single sample at index <idx>. The sample is any
kind of Python object you want. It could be a numpy array.
It could be a dictionary with strings for keys and
numpy arrays for values. It could be a list — really
whatever you want."""
return self._a_custom_method(self.my_list_of_examples[idx])
# Whatever Custom Stuff You Want # — — — — — — — — — — — -
def _a_custom_method(self, example_name):
#processing step 1
#processing step 2
#etc.
return processed_example
对数据集的唯一要求是它定义了 len 和 getitem 方法。
len 方法必须返回数据集中示例的总数。
getitem 方法必须返回基于整数索引的单个示例。
你实际上如何准备例子和例子是什么完全取决于你。
一旦创建了数据集，就需要将该数据集包装在 Pytorch 的数据加载器中，如下所示:
from torch.utils.data import Dataset, DataLoaderdataset_train = MyComplicatedCustomDataset(**dataset_args)train_dataloader = DataLoader(dataset_train, batch_size=256, shuffle=True, num_workers = 4)
为了获得批处理，您只需遍历数据加载器:
for batch_idx, batch in enumerate(train_dataloader): do stuff
如果希望加快数据加载，可以使用多个工作线程。请注意，在对 DataLoader 的调用中，您指定了一些工作线程:
train_dataloader = DataLoader(dataset_train, batch_size=256, shuffle=True, **num_workers = 4**)
默认情况下，num_workers 设置为 0。将 num_workers 设置为正整数将启用多进程数据加载，在这种情况下，将使用指定数量的加载器工作进程来加载数据。(注意，这并不是真正的多 GPU，因为这些加载器工作进程是 CPU 上的不同进程，但是因为它与加速模型训练有关，所以我决定将它放在同一篇文章中)。
请注意，工作进程越多并不总是越好。如果将 num_workers 设置得太高，实际上会降低数据加载速度。关于如何选择最佳工人数量，也没有很大的规则。网上有很多关于它的讨论(例如这里的)，但没有结论性的答案。关于如何选择工作人员的数量，没有什么很好的规则，原因是最佳的工作人员数量取决于您正在使用的机器类型、您正在使用的数据集类型以及您的数据需要多少即时预处理。
选择工人数量的一个好方法是在数据集上运行一些小实验，在这些实验中，您计算使用不同数量的工人加载固定数量的示例需要多长时间。随着 num_workers 从 0 开始增加，您将首先看到数据加载速度的增加，随后当您遇到“太多 workers”时，数据加载速度将会降低
有关更多信息，请参见本页的中的“多进程数据加载”。
模型并行和数据并行同时进行
如果您想同时使用模型并行和数据并行，那么数据并行必须以稍微不同的方式实现，使用 DistributedDataParallel 而不是 DataParallel。更多信息，请参见“分布式数据并行入门”
对可用设备子集的培训
如果您想使用模型并行性或数据并行性，但不想占用单个模型的所有可用设备，该怎么办？在这种情况下，您可以限制 Pytorch 可以看到每个型号的哪些设备。在您的代码中，您将设置设备，好像您想要使用所有的 GPU(即使用 device = torch.device('cuda '))，但是当您运行代码时，您将限制哪些 GPU 可以被看到。
假设您有 6 个 GPU，您想在其中的 2 个上训练模型 A，在其中的 4 个上训练模型 B。您可以这样做:
CUDA_VISIBLE_DEVICES=0,1 python model_A.pyCUDA_VISIBLE_DEVICES=2,3,4,5 python model_B.py
或者，如果您有 3 个 GPU，并且希望在其中一个上训练模型 A，在其中两个上训练模型 B，您可以这样做:
CUDA_VISIBLE_DEVICES=1 python model_A.pyCUDA_VISIBLE_DEVICES=0,2 python model_B.py
多 GPU 训练快乐！
原载于 2020 年 3 月 4 日 http://glassboxmedicine.com**的 。
使用词袋和 TF-IDF 的多标签分类
该项目遵循传统技术，如单词袋和 tf-idf，以数字格式表示语料库中的单词，用于多标签分类。
Wordcloud 摘录自 Jigsaw 有毒评论。免责声明:该数据集包含被视为亵渎、粗俗或冒犯的文本。文章最后给出了构建这个词云的代码。
1.加载数据
在这项研究中，我们使用 Kaggle 数据进行有毒评论分类挑战。让我们加载并检查数据。这是一个多标签分类问题，其中注释按照毒性级别进行分类:toxic / severe_toxic / obscene / threat / insult / identity_hate
import pandas as pd
data = pd.read_csv('train.csv')
print('Shape of the data: ', data.shape)
data.head()
数据集的快照
y_cols = list(data.columns[2:])
is_multilabel = (data[y_cols].sum(axis=1) >1).count()
print('is_multilabel count: ', is_multilabel)
- 从上面的数据可以观察到，并不是所有的评论都有标签。
- 其次，它是多标签数据，意味着每个评论可以有一个或多个标签。
首先，让我们为没有标签的评论添加一个标签“无毒”。此外，探索如何平衡的类。
# Add a label, ‘non_toxic’ for comments with no label
data['non_toxic'] = 1-data[y_cols].max(axis=1)
y_cols += ['non_toxic']# Inspect the class balance
def get_class_weight(data):
class_weight = {}
for num,col in enumerate(y_cols):
if num not in class_weight:
class_weight[col] = round((data[data[col] == 1][col].sum())/data.shape[0]*100,2)
return class_weight
class_weight = get_class_weight(data)print('Total class weight: ', sum(class_weight.values()), '%\n\n', class_weight)
我们可以看到数据是高度不平衡的。不平衡数据指的是分类问题，例如，89%的评论被归类到新建的“无毒”标签下。
任何给定的线性模型如果使用平方损失进行二进制分类，将会非常糟糕地处理类别不平衡。在这个项目中，我们将不讨论解决不平衡问题的技术。如果你想了解更多关于处理不平衡数据的知识，请参考这篇博客。
让我们在使用 BoW(单词包)和 tf-idf(术语频率和逆文档频率)将文本数据转换为数字数据之前，重点关注预处理。
2.将数据集分为训练、验证和测试
from sklearn.model_selection import train_test_splitX, X_test, y, y_test = train_test_split(X_data, y_data, test_size=0.2, train_size=0.8)
X_train, X_val, y_train, y_val = train_test_split(X,y,test_size = 0.25,train_size =0.75)X_train[:1]
让我们仔细看看其中一条评论。请注意，由于数据集是随机分割的，因此文本会因您而异。如果你的目标是复制结果，请在分割中使用种子。
3.预处理文本
从上面的例子中，我们可以看到，文本需要预处理，即将其转换为相同的大小写(小写)，在将文本转换为标记之前，删除符号、数字和停用词。为了预处理文本，您需要下载特定的库。
import re
import numpy as n
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
nltk.download('punkt')
要点学分: Coursera
预处理文本
4.将文本转换为矢量
对于机器学习模型，文本数据必须转换为数字数据。这可以通过各种方式实现，如 BoW、tf-idf、单词嵌入等。在这个项目中，我们将关注 BoW 和 tf-idf。
词汇袋
在 BoW 模型中，一个文本(如一个句子或一个文档)被表示为其单词的包(多集合),不考虑语法甚至词序，但保持多样性。
-通过排名建立一个前 N 个流行词的字典。
BoW 表示两个评论，“hello world”和“How are you”
我们将把自己限制在 N 个流行词，以限制矩阵的大小。而且包含冷门词只会引入稀疏，不会增加太多信息。对于这个项目，让我们用 10000 个流行词。
# Lets take a look at top 10 popular words
POPULAR_WORDS[:10]
-建造船首
对于语料库中的每个评论，创建具有 N 维的零向量，并且对于在评论中找到的单词，将向量中的值增加 1，例如，如果一个单词出现两次，则向量中的索引将得到 2。
为了有效存储，我们将把这个向量转换成一个稀疏向量，一个利用稀疏性并且实际上只存储非零条目的向量。
from scipy import sparse as sp_sparse
TF-IDF
在信息检索中，TF–IDF或 TFIDF ，是词频-逆文档频率的简称，是一种数值统计，意在反映一个词对集合或语料库中的文档有多重要。
这种方法是单词袋的扩展，其中单词的总频率除以文档中的总单词数。这通过在整个文档中规范化过于频繁的单词来惩罚它们。
from sklearn.feature_extraction.text import TfidfVectorizer
5.多标签分类
我们使用两种不同的技术 BoW 和 tf-idf 准备了数据集。我们可以在两个数据集上运行分类器。由于这是一个多标签分类问题，我们将使用一个简单的 OneVsRestClassfier 逻辑回归。
from sklearn.multiclass import OneVsRestClassifier
from sklearn.linear_model import LogisticRegression
你可以尝试不同的正则化技术，L1 和 L2 与不同的系数(例如，C 等于 0.1，1，10，100)，直到你满意的结果，这被称为超参数调整。这可以通过 cv 网格搜索、随机搜索和贝叶斯优化来实现。我们不打算在本文中讨论这个话题。如果你想了解更多这方面的信息，请参考这个帖子。
6.估价
我们将使用准确性分数和 f1 分数等指标进行评估。
- 准确度分数:在多标签分类中，该函数计算子集准确度:为样本预测的标签集必须与 y_true 中的相应标签集完全匹配。
- F1 分数:F1 分数可以解释为精确度和召回率的加权平均值，其中 F1 分数在 1 时达到其最佳值，在 0 时达到其最差分数。精确度和召回率对 F1 分数的相对贡献是相等的。F1 得分= 2 (精确度召回率)/(精确度+召回率)
'F1 score micro':通过计算总的真阳性、假阴性和假阳性来计算全局指标。
'F1 score macro':计算每个标签的指标，求其未加权平均值。这没有考虑标签不平衡。
'F1 score weighted':计算每个标签的度量，并根据支持度(每个标签真实实例的数量)计算它们的平均值。这改变了“宏”以解决标签不平衡；它会导致 F 值不在精确度和召回率之间。
from sklearn.metrics import accuracy_score
from sklearn.metrics import f1_score
from sklearn.metrics import roc_auc_score
from sklearn.metrics import average_precision_score
from sklearn.metrics import recall_score
F1 分数加权和说明数据不平衡的宏看起来不错。让我们检查输出、预测标签和实际标签。我们需要用实际的标签替换一次性编码的标签来进行解释。接下来让我们对 tf-idf 模型进行预测。
test_predictions = classifier_tfidf.predict(X_test_tfidf)
for i in range(90,97):
print('\ny_label: ', test_labels[i], '\ny_pred: ', test_pred_labels[i])print('\ny_label: ', test_labels[i], '\ny_pred: ', test_pred_labels[i])
成绩不算太差，但还可以做得更好。请尝试使用超参数调整和不同的分类器来检查模型的性能。希望你喜欢阅读。
如果你感兴趣，我留下了构建单词云图像的代码。
带 Twitter 掩码的词云
comments_join = ' '.join(POPULAR_WORDS)from scipy.misc import imread
from wordcloud import WordCloud, STOPWORDStwitter_mask = imread('twitter.png', flatten=True)
wordcloud = WordCloud(
stopwords=STOPWORDS,
background_color='white',
width=1800,
height=1400,
mask=twitter_mask
).generate(comments_join)plt.figure(figsize = (12, 12), facecolor = None)
plt.imshow(wordcloud)
plt.axis("off")
plt.savefig('twitter_comments.png', dpi=300)
plt.show()
带代码的 jupyter 笔记本，请点击此处。
参考资料:
https://www.coursera.org/learn/language-processing/home
使用 Vowpal Wabbit 的多标签分类:从为什么到如何！
如何制定多标签分类任务并使用 Vowpal Wabbit 求解
什么是多标签分类？
想想你最近读的一篇文章/推文，如果你被要求标记它！
大概你会想出科技、政治、时尚等标签。考虑这条推文，自己尝试一下。
来源:https://twitter.com/orangebook_
它可以被标上自助，沉思，凌晨 3 点的想法！和许多其他人。不能说其中有一个是最好的。他们每个人都是对的，你只需要一个视角！
一个标签可能比其他的更合适，但是你不能只有一个标签。我们稍后将回到这个话题。
现在这样的问题在我们的生活中经常出现，更多的例子有:
- 根据图像的内容给图像加标签:(天空、房子、草地)
- 电影的类型分类:(动作、冒险、犯罪)
- 标记堆栈溢出中提出的问题。
那么多类和多标签分类有什么区别呢？
当有多个类别，但每个实例只分配了其中一个类别，或者类别是互斥的，这就是多类别分类。
当每个实例可以被分配多个类别或者类别彼此相关时，这就是多标签分类。
解决多标签分类问题的标准实践
Scikit-Learn 为多标签分类提供了单独的库 Scikit-Multilabel 。我不会深入本库提供的标准算法的细节，因为那样会分散我对博客目标的注意力。
您可以看看下面的文章来方便地使用这个库:
- https://www . analyticsvidhya . com/blog/2017/08/introduction-to-multi-label-class ification/
- http://scikit.ml/multilabeldnn.html基于 DL 的多标签分类
- https://towards data science . com/journey-to-the-center-of-multi-label-class ification-384 c 40229 BFF
什么是 Vowpal Wabbit，为什么我们需要它？
它是由微软研究院(之前由雅虎公司)开发的一个库，用于解决机器学习问题。
Vowpal Wabbit 提供了一种快速、灵活、在线和主动的学习解决方案，使您能够解决复杂的交互式机器学习问题。
从我的经历来看，这个图书馆与众不同的两点是速度和在线学习。
在计算机科学中，在线机器学习是一种机器学习方法，其中数据以连续的顺序变得可用，并用于在每一步更新我们对未来数据的最佳预测，这与批量学习技术相反，批量学习技术通过一次性学习整个训练数据集来生成最佳预测。
让我们深入研究我们的问题
为了更好地理解 Vowpal Wabbit 和多标签分类，让我们解决将标签分配给简短文本描述的问题。
我们将使用来自极限分类库的 Bibtex 数据集，该分类库为单个文本提供了 1836 个二进制特征和 159 个可能的标签。
使用 Vowpal Wabbit 的多标签分类代码
为了获得更广泛的视图，你可以前往 Github 链接。
正如你可能已经看到的，只要对每个例子迭代一次，也是以在线的方式和极快的速度，模型收敛到很好的精度。
让我们了解一下这里使用的算法(请在继续下一步之前阅读代码)。
成本敏感的多类分类
这里，不是只有一个正确的标签(而所有其他的都不正确)，而是 K 个不同标签中的每一个都有不同的成本。对于每个例子，你也可以有不同的“允许”标签。与上述相同的成本敏感训练集是:
1\. 1:0 2:1 3:1 4:1 | a b c
2\. 1:1 2:1 3:0 4:1 | b c d
第一行意味着标签 1 的成本为零，标签 2、3 和 4 的成本都为一。“a、b、c”是与示例相关联的二元特征。你可以只陈述存在的特征，而忽略不存在的特征。
在内部， csoaa 做了一些与你想象不同的事情。这个问题归结为回归问题。如果有 K 个可能的标签，它将构建 K 个回归问题，其中输入是要素的(基于标签的)版本，输出是该标签的成本。
然后在测试时，选择回归量给出最低值(预测成本)的标签。
这篇博客的目的不是寻找提高准确率的方法，而是介绍这个不同的机器学习世界(多标签分类)以及如何有效地使用 Vowpal Wabbit 来解决这个问题。
在上述解决方案中有许多可能的修改/改进，例如:改变损失函数、通过数据的次数、优化策略、改变每个标签的成本等。
要了解更多信息，您可以点击下面的链接:
- http://users.umiacs.umd.edu/~hal/tmp/multiclassVW.html
- https://github . com/VowpalWabbit/vowpal _ wabbit/wiki/Cost-Sensitive-One-again-All-(csoaa)-multi-class-example
- http://manikvarma.org/downloads/XC/XMLRepository.html
- https://vail lab . blogspot . com/2014/06/mutlti-label-class ification-using . html
如有任何疑问或建议，欢迎随时 ping 我😃。还有，在Twitter和Linkedin上找我。再见！！
使用 BERT、Transformers 和 Keras 的多标签、多类别文本分类
在本文中，我将展示如何使用 Huggingface Transformers 库和 Tensorflow Keras API 完成多标签、多类别的文本分类任务。这样，您将了解如何使用 Transformer 中的 BERT 模型作为使用 Keras API 构建的 Tensorflow 模型中的一个层。
使用 BERT、Transformers 和 Keras 的多标签、多类别文本分类
互联网上充满了文本分类的文章，其中大多数是 BoW 模型与某种 ML 模型的结合，通常解决二进制文本分类问题。随着 NLP 的兴起，特别是 BERT(如果你不熟悉 BERT，请看这里的)和其他基于多语言转换器的模型，越来越多的文本分类问题现在可以得到解决。
然而，当涉及到使用 Huggingface Transformers 、 BERT 和 Tensorflow Keras 解决多标签、多类别文本分类问题时，文章的数量确实非常有限，就我个人而言，我还没有找到任何…还没有！
因此，在大量与 BERT、Keras 中的多标签分类或其他有用信息相关的博客帖子、教程和 GitHub 代码片段的帮助和启发下，我将向您展示如何构建一个工作模型，解决这个问题。
为什么使用拥抱脸变形金刚而不是谷歌自己的 BERT 解决方案？因为使用变压器很容易在不同型号之间切换，如伯特、阿尔伯特、XLnet、GPT-2 等。这意味着，您或多或少地“只是”在代码中用一个模型替换另一个模型。
从哪里开始
用数据。在寻找可以用于多标签多类别文本分类任务的文本数据时，我偶然发现了来自 data.gov 的“消费者投诉数据库】。看起来很管用，所以我们就用这个。
接下来是探索性数据分析。显然，这对于正确理解数据的样子、可能存在的缺陷、数据的质量等等至关重要。但是我现在跳过这一步，只是因为这篇文章的目的纯粹是如何建立一个模型。
如果你不喜欢四处搜索，可以看看这两篇关于这个主题的文章: NLP 第 3 部分|文本数据的探索性数据分析和一个完整的文本数据的探索性数据分析和可视化。
继续吧
我们有了数据，现在是编码部分。
首先，我们将加载所需的库。
#######################################
### -------- Load libraries ------- #### Load Huggingface transformers
from transformers import TFBertModel, BertConfig, BertTokenizerFast# Then what you need from tensorflow.keras
from tensorflow.keras.layers import Input, Dropout, Dense
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.initializers import TruncatedNormal
from tensorflow.keras.losses import CategoricalCrossentropy
from tensorflow.keras.metrics import CategoricalAccuracy
from tensorflow.keras.utils import to_categorical# And pandas for data import + sklearn because you allways need sklearn
import pandas as pd
from sklearn.model_selection import train_test_split
然后，我们将导入我们的数据，并围绕它展开讨论，使其符合我们的需求。没什么特别的。请注意，我们将仅使用数据集中的“消费者投诉叙述”、“产品”和“问题”列。“消费者投诉叙述”将作为我们模型的输入，“产品”和“问题”将作为我们的两个输出。
#######################################
### --------- Import data --------- #### Import data from csv
data = pd.read_csv('dev/Fun with BERT/complaints.csv')# Select required columns
data = data[['Consumer complaint narrative', 'Product', 'Issue']]# Remove a row if any of the three remaining columns are missing
data = data.dropna()# Remove rows, where the label is present only ones (can't be split)
data = data.groupby('Issue').filter(lambda x : len(x) > 1)
data = data.groupby('Product').filter(lambda x : len(x) > 1)# Set your model output as categorical and save in new label col
data['Issue_label'] = pd.Categorical(data['Issue'])
data['Product_label'] = pd.Categorical(data['Product'])# Transform your output to numeric
data['Issue'] = data['Issue_label'].cat.codes
data['Product'] = data['Product_label'].cat.codes# Split into train and test - stratify over Issue
data, data_test = train_test_split(data, test_size = 0.2, stratify = data[['Issue']])
接下来，我们将加载一些不同的变压器类。
#######################################
### --------- Setup BERT ---------- #### Name of the BERT model to use
model_name = 'bert-base-uncased'# Max length of tokens
max_length = 100# Load transformers config and set output_hidden_states to False
config = BertConfig.from_pretrained(model_name)
config.output_hidden_states = False# Load BERT tokenizer
tokenizer = BertTokenizerFast.from_pretrained(pretrained_model_name_or_path = model_name, config = config)# Load the Transformers BERT model
transformer_model = TFBertModel.from_pretrained(model_name, config = config)
在这里，我们首先加载一个控制模型、记号赋予器等的 BERT 配置对象。
然后，我们将在稍后的脚本中使用一个记号赋予器，将我们的文本输入转换成 BERT 记号，然后填充并截断到我们的最大长度。记号赋予器已经被很好地记录了，所以我不会在这里深入讨论。
最后，我们将加载 BERT 模型本身作为 BERT Transformers TF 2.0 Keras 模型(这里我们使用12 层 bert-base-uncased )。
现在是有趣的部分
我们准备好建立我们的模型。在变形金刚库中，有许多不同的 BERT 分类模型可以使用。所有模型的母亲是简单地称为“BertModel”(py torch)或“TFBertModel”(tensor flow)的模型，因此也是我们想要的模型。
Transformers 库还附带了一个预构建的用于序列分类的 BERT 模型，称为“TFBertForSequenceClassification”。如果你看一下这里的代码你会发现，他们从加载一个干净的 BERT 模型开始，然后简单地添加一个漏失层和一个密集层。因此，我们要做的只是简单地添加两个密集层，而不是只有一个。
这是我们模型的样子:
基于 BERT、Transformer 和 Keras 模型的多标签多类别文本分类
更详细的模型视图:
Model: "BERT_MultiLabel_MultiClass"
___________________________________________________________________
Layer (type) Output Shape Param # Connected to
===================================================================
input_ids [(None, 100)] 0
(InputLayer)
___________________________________________________________________
bert ( 109482240 input_ids[0][0]
(TFBertMainLayer) (None, 100, 768),
(None, 768)
)
___________________________________________________________________
pooled_output (None, 768) 0 bert[1][1]
(Dropout)
___________________________________________________________________
issue (None, 159) 122271 pooled_output[0][0]
(Dense)
___________________________________________________________________
product (None, 18) 13842 pooled_output[0][0]
(Dense)
===================================================================
Total params: 109,618,353
Trainable params: 109,618,353
Non-trainable params: 0
___________________________________________________________________
如果你想更多地了解 BERTs 建筑本身，看看这里。
现在我们有了模型架构，我们需要做的就是用代码编写它。
#######################################
### ------- Build the model ------- #### TF Keras documentation: [https://www.tensorflow.org/api_docs/python/tf/keras/Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)# Load the MainLayer
bert = transformer_model.layers[0]# Build your model input
input_ids = Input(shape=(max_length,), name='input_ids', dtype='int32')
inputs = {'input_ids': input_ids}# Load the Transformers BERT model as a layer in a Keras model
bert_model = bert(inputs)[1]
dropout = Dropout(config.hidden_dropout_prob, name='pooled_output')
pooled_output = dropout(bert_model, training=False)# Then build your model output
issue = Dense(units=len(data.Issue_label.value_counts()), kernel_initializer=TruncatedNormal(stddev=config.initializer_range), name='issue')(pooled_output)
product = Dense(units=len(data.Product_label.value_counts()), kernel_initializer=TruncatedNormal(stddev=config.initializer_range), name='product')(pooled_output)
outputs = {'issue': issue, 'product': product}# And combine it all in a model object
model = Model(inputs=inputs, outputs=outputs, name='BERT_MultiLabel_MultiClass')# Take a look at the model
model.summary()
让魔法开始吧
然后剩下要做的就是编译我们的新模型，并根据我们的数据进行拟合。
#######################################
### ------- Train the model ------- #### Set an optimizer
optimizer = Adam(
learning_rate=5e-05,
epsilon=1e-08,
decay=0.01,
clipnorm=1.0)# Set loss and metrics
loss = {'issue': CategoricalCrossentropy(from_logits = True), 'product': CategoricalCrossentropy(from_logits = True)}
metric = {'issue': CategoricalAccuracy('accuracy'), 'product': CategoricalAccuracy('accuracy')}# Compile the model
model.compile(
optimizer = optimizer,
loss = loss,
metrics = metric)# Ready output data for the model
y_issue = to_categorical(data['Issue'])
y_product = to_categorical(data['Product'])# Tokenize the input (takes some time)
x = tokenizer(
text=data['Consumer complaint narrative'].to_list(),
add_special_tokens=True,
max_length=max_length,
truncation=True,
padding=True,
return_tensors='tf',
return_token_type_ids = False,
return_attention_mask = False,
verbose = True)# Fit the model
history = model.fit(
x={'input_ids': x['input_ids']},
y={'issue': y_issue, 'product': y_product},
validation_split=0.2,
batch_size=64,
epochs=10)
一旦模型被拟合，我们就可以根据我们的测试数据对它进行评估，看看它的表现如何。
#######################################
### ----- Evaluate the model ------ #### Ready test data
test_y_issue = to_categorical(data_test['Issue'])
test_y_product = to_categorical(data_test['Product'])
test_x = tokenizer(
text=data_test['Consumer complaint narrative'].to_list(),
add_special_tokens=True,
max_length=max_length,
truncation=True,
padding=True,
return_tensors='tf',
return_token_type_ids = False,
return_attention_mask = False,
verbose = True)# Run evaluation
model_eval = model.evaluate(
x={'input_ids': test_x['input_ids']},
y={'issue': test_y_issue, 'product': test_y_product}
)
事实证明，我们的模型表现得相当好，具有相对较好的准确性。尤其是考虑到我们的输出“产品”由 18 个标签组成，而“问题”由 159 个不同的标签组成。
####################################################################
Classification metrics for Product precision recall f1-score support
Bank account or service 0.63 0.36 0.46 2977
Checking or savings account 0.60 0.75 0.67 4685
Consumer Loan 0.48 0.29 0.36 1876
Credit card 0.56 0.42 0.48 3765
Credit card or prepaid card 0.63 0.71 0.67 8123
Credit reporting 0.64 0.37 0.47 6318
Credit reporting, credit
repair services, or other
personal consumer reports 0.81 0.85 0.83 38529
Debt collection 0.80 0.85 0.82 23848
Money transfer, virtual
currency, or money service 0.59 0.65 0.62 1966
Money transfers 0.50 0.01 0.01 305
Mortgage 0.89 0.93 0.91 13502
Other financial service 0.00 0.00 0.00 60
Payday loan 0.57 0.01 0.02 355
Payday loan, title loan, or
personal loan 0.46 0.40 0.43 1523
Prepaid card 0.82 0.14 0.24 294
Student loan 0.83 0.87 0.85 5332
Vehicle loan or lease 0.49 0.51 0.50 1963
Virtual currency 0.00 0.00 0.00 3 accuracy 0.76 115424
macro avg 0.57 0.45 0.46 115424
weighted avg 0.75 0.76 0.75 115424####################################################################
Classification metrics for Issue (only showing summarized metrics)precision recall f1-score support
accuracy 0.41 115424
macro avg 0.09 0.08 0.06 115424
下一步做什么？
但是，您可以做很多事情来提高这个模型的性能。在这里，我尽量做到简单，但如果您希望获得更好的性能，请考虑以下几点:
- 摆弄优化器中设置的超参数，或者改变优化器本身
- 使用消费者投诉数据库数据训练一个语言模型——要么从头开始，要么通过微调现有的 BERT 模型(在这里看看)。然后加载该模型，而不是这里使用的“bert-base-uncased”。
- 使用多个输入。在我们当前的设置中，我们只使用令牌 id 作为输入。然而，如果我们在输入中加入注意力屏蔽，我们可能会获得一些性能提升。它非常简单，看起来像这样:
# Build your model inputinput_ids = Input(shape=(max_length,), name='input_ids', dtype='int32')attention_mask = Input(shape=(max_length,), name='attention_mask', dtype='int32')inputs = {'input_ids': input_ids, 'attention_mask': attention_mask}
(记得在拟合你的模型时添加 attention_mask，并在你的 tokenizer 中设置 return_attention_mask 为 True。更多关于注意力面具的信息， 看这里 。此外，我在下面的要点中添加了注意力面具，并将其注释掉，以供你的灵感。)
- 尝试另一个模型，如艾伯特、罗伯塔、XLM，甚至是自回归模型，如 GPT-2 或 XLNet——所有这些都可以通过 Transformers 库轻松导入到您的框架中。您可以在此处找到所有直接可用型号的概述。
就是这样——希望你喜欢这个如何用 BERT、Transformer 和 Keras 进行“多标签、多类文本分类”的小演示。如果你有任何反馈或问题，请在下面的评论中提出。
多目标车辆路径优化
遵循从完整的基础到先进的路线优化解决方案的学习路径。
作者图片
路线优化是运输规划中最重要的方面之一，因为它确保货物总是准时到达，并以尽可能低的成本和能耗执行。然而，对于现实生活中的场景，我们需要考虑很多变量。
来源:一个路线优化软件能提供什么？
在这个不幸的 COVID 期间，我们要处理来自分散在一个城市、一个国家甚至整个世界的各种客户的大量电子商务订单，然后出现了大量的变量，这些变量根本无法在实际时间内使用传统方法解决。随着人工智能、机器学习和云数据的最新发展，路线优化的整个游戏已经开始改变。人工智能不断检索数据，从中学习，并寻找改进的方法，以确保司机的最佳路线。
在这个系列中，我们将经历一个学习多目标路线优化的奇妙旅程，从线性方法到高级深度强化学习:
1.车辆路径问题及多目标优化
2.遗传算法
3.蚁群优化
4.迭代局部搜索
5.使用 CPLEX-python 的基于 MILP 的方法
6.深度强化学习
在这篇博客中，我们将深入探讨带有一些附加约束的车辆路径问题的详细描述、多目标优化的概念以及本系列将介绍的方法的简要概述。
介绍
V 车辆路径问题(VRP)可以定义为在满足一些约束条件的情况下，寻找从一个或几个仓库到多个客户的最优运送或收集路线的问题。这个问题可以推广到社会垃圾的收集、汽油运输车、货物和邮件的运送等，应用是无限的。
来源:为什么要进行路线优化？
车辆路径问题
在传统的 VRP 中，顾客和仓库的位置是预先知道的，这有助于我们在上述路线中确定路线。为了简化问题的定义，让我们考虑一个图 G=(V，A) ，其中 V={1……n} 是一组顶点(客户)，仓库位于顶点 1，而 A 是一组弧线(路线)。除此之外，我们假设停车场有一定数量的可用车辆，并为每辆车分配初始成本。这些车辆通过以下方式覆盖客户之间的路线:
(I)每个城市只被一辆车访问一次
(ii)所有车辆路线的起点和终点都在停车场
来源:上述配方的图示
然而，平心而论，上述问题虽然包括几个变量和指令，但仍然缺乏直接应用于任何地方的现实感，因此我们转向一种更一般化形式的 VRP，称为车辆路线安排和调度问题或 VRPTW (带时间窗的车辆路线安排问题)。我们的目标是优化车队的使用，车队必须多次停车为一组客户提供服务，并指定每辆车应该为哪些客户提供服务以及以何种顺序提供服务，以使成本最小化，同时遵守车辆容量和服务时间限制。
因此，上述定义可以修改为有向图 G=(V，E) ，由一组 n 个客户+ 1 个仓库组成，每个客户只能在指定的时间间隔或时间窗口内到达，以及一组具有非负权重的弧 E 代表行程距离。每辆车的最大载客量为 Q，所有客户的请求服务规模为 qi
多目标方法
在确定问题之后，现在的任务是优化车辆行驶的路线，以获得最低的成本。然而，在我们开始之前，让我们先熟悉一下多目标优化的概念。这是一个多准则决策的领域，涉及数学优化问题，涉及一个以上的目标函数同时优化。它主要用于当我们的目标相互冲突，并且最优决策位于它们的折衷之间时。与单目标相比，多目标优化的另一个结果是我们获得一组最优解，而不是单个解，所有这些融合在一起，使多目标方法更适合现实世界的情况。
作者图片:多目标优化是必要的！
我们将在场景中考虑的目标是分配给任务的车辆数量和穿越路线所需的总成本。时间延迟将在成本函数中用额外的延迟成本来处理。上图将整个过程概括为两个部分，即初始随机解的生成，将这些随机解收敛以获得一组非支配解。重复这个过程，直到获得帕累托最优集合。
作者的图像:多目标解决方案的表示
各种方法概述
乍看之下，VRP 似乎并不难解决，因为人们总是可以通过确定所有可能的路线并选择最便宜的路线来遵循蛮力方法来解决问题。那么这种方法有什么问题呢？原来这个过程叫做枚举，只对非常小的问题可行。据报道，VRP 是一个 NP-hard 问题，这意味着求解时间随着规模的增加而呈天文数字增长。对于 VRP 来说，可能的解决方案有 n 个！，这种阶乘的增长是时间的巨大增长的原因。下表显示了每秒处理十亿次计算的计算机求解 VRP 的预计时间。
作者图片
大多数现实世界的问题涉及大量的客户，因此我们需要转向其他方法，比如元启发式方法来解决问题。这些都是从‘启发式’和‘元’——一个更高层次或更高层次的意思中衍生出来的。这些方法在生成随机化和局部搜索之间进行权衡。解决方案的质量在更短的时间内得到保证。此外，也不能保证这种方法会给我们提供一个最优解。元启发式算法的两个主要组成部分是探索和利用。前者处理不同解的生成，以在全局范围内探索搜索空间，而后者负责搜索局部区域，知道该区域中存在好的解。在这两者之间找到一个好的平衡会导致一个好的算法收敛，并给出最接近全局最优的解
作者图片:这里使用的元启发式方法
另一种可以解决这个 NP 难题的方法是强化学习。近来，这个领域有了巨大的发展，尤其是在 Deepmind 通过 AlphaZero 计划取得成功之后。一个通用的 RL 模型由三个主要部分组成，即:- 状态、主体和环境。该模型使用一系列的奖励和惩罚作为在特定环境中给定状态下主体所采取行动的积极或消极行为的信号。代理人的主要目标是最大化总的累积报酬。下图说明了 RL 模型的动作反馈回路:
来源:通用 RL 模型
资料组
整个教程是使用 Solomon 数据集进行的，它由三种不同的客户分布组成；
(一)随机化或 R 型
来源:红点代表单个车厂，其他为客户
客户随机分布在整个城市，车辆从仓库出发。这相当于在一个城市中的不同商店需要交付货物。
(二)集群或 C 型
来源:红点代表单个仓库，其他为客户
这是一个有趣的案例，其中特定的数据群随机分布在整个城市中，就像城市中有组织的地区和社会，用于送货上门或垃圾收集等基本服务。
(iii)随机和群集或 RC 类型。
来源:红点代表单个仓库，其他为客户
这种特殊类型是上述两种方法的组合，其中地理位置以聚类和随机的形式分布。
根据它们的时间窗口的长度，它们被进一步分成两个子类别:短调度和长调度
摘要
在详细描述了我们在 VRP 问题上所面临的问题，并简要概述了本系列将采用的方法之后，我们将进入本系列的下一部分，深入讨论我们的第一个元启发式方法:遗传算法。在这里，我们将详细阐述应用框架的细节，并详细解释选择、变异和交叉的各个步骤。
真诚感谢萨纳特·K、斯巴纳·拉纳和拉维·兰詹对这个项目的指导，特别感谢拉维·兰詹在这个系列中的灵感。
多视角神经网络——一种无监督的深度度量学习算法
一种学习生成嵌入的无监督深度度量学习算法。
链接: 演示视频 & Github 资源库
想象你是一个刚刚睁开眼睛看世界的婴儿。想象一下缺乏意识，想象一下什么都不知道。你连怎么看东西都不知道，更别说怎么识别东西了。现在，回到你的意识中来。你可以看到，你可以认出你周围的任何物体，这些物体甚至会让你想起你的记忆。
克里斯蒂安·鲍文在 Unsplash 上拍摄的照片
但是，你是如何获得这些技能的呢？这是多视角神经网络(MPNN)的起点。
在我之前的文章中，我已经谈到了一种无监督学习算法，它可以学习创建有意义的特征作为输出的过滤器。帖子链接:无监督学习的学习过滤器。这篇文章是上一篇文章的延续。在这篇文章中将有三个部分，如逻辑和哲学，代码，测试。
逻辑和哲学
由 sergio souza 在 Unsplash 上拍摄的照片
该算法基本上学会了将卷积层的输出彼此分解。当我们对图像应用卷积运算时，我们得到 NxRxC 矩阵，其中 N 是滤波器的数量，R 和 C 是行大小和列大小。在 MPNNs 中，卷积运算的输出中的 N 个层试图彼此分解。当最大相似性值低于预定阈值时，该级别的学习过程完成。之后，对下一级重复这一过程。最后，神经网络生成具有有意义特征的嵌入。
显示分解管道的图表(按作者)
我开始思考这次行动的哲学。我想到了与这个层分解操作相匹配的概念。我一直在寻找的概念是 视角。 人类试图学会用不同的视角看待事件、物体和其他一切，以便他们能够分析正在发生的事情。这不仅发生在高级抽象中，也发生在低级学习中。MPNN 试图做的是将这种视角生成应用于视觉中的低级学习过程。
密码
我在以前的帖子中分享了代码。但是，我已经做了一些改变，所以我想在这个帖子里再次分享。完整的代码仍然可以在的 GitHub 库中找到。
一个单独的卷积图层类。
class ConvLayer(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride):
super(ConvLayer, self).__init__()
self.conv2d = torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride)def forward(self, x):
out = self.conv2d(x)
return out
一个单一的卷积级类。级别是分解发生的地方。
class SSNet(torch.nn.Module):
def __init__(self,in_filters, out_filters):
super(SSNet, self).__init__()
self.conv1 = ConvLayer(in_filters, 64, kernel_size = 5, stride = 1)
self.conv2 = ConvLayer(64, out_filters, kernel_size = 1, stride = 1)
self.pool = nn.AvgPool2d(2, stride=2)
self.relu = torch.nn.ReLU()
def forward(self, x):
out = self.pool(self.conv2(self.relu(self.conv1(x))))
return out
包含几级 SSNet 类的 MPNN 类。
class SSNetMultiple(torch.nn.Module):
def __init__(self,levels = 5):
super(SSNetMultiple, self).__init__()
self.children = []
for cnt in range(levels):
if cnt == 0:
in_filters, out_filters = 3,16
elif cnt == levels-1:
in_filters, out_filters = 16,16
else:
in_filters, out_filters = 16,16
self.children.append(SSNet(in_filters, out_filters))
self.main = nn.Sequential(*self.children)
def forward(self, x, queue = 1):
outs = [x]
for cnt,child in enumerate(self.main):
if cnt<queue:
outs.append(child(outs[-1]))
return outs[-1]
规范化操作。如果我们想要获得相似性值 1 作为最大相似性，归一化是必要的。
def normalize(vector):
norm = vector.norm(p=2, dim=0, keepdim=True)
vector_normalized = vector.div(norm.expand_as(vector))
return vector_normalized
相似性函数用于提取和组合层的相似性，以便我们可以计算损失。
def sim_func(layers):
combinations = list(itertools.combinations(np.arange(0,layers.shape[1]), 2))
similarity_vector = torch.empty(len(combinations))
for cnt,comb in enumerate(combinations):
first = layers[0][comb[0]].flatten()
second = layers[0][comb[1]].flatten()
first_norm = normalize(first)
second_norm = normalize(second)
similarity_vector[cnt] = torch.matmul(first_norm,second_norm.T)
return similarity_vector
用分解层数定义 MPNN 实例。
model = SSNetMultiple(levels = 4)
对于数据集，我在上一篇文章中使用了 MNIST。这一次，我们将使用从 YouTube 下载的视频。
视频可在链接中找到:西班牙伊比沙岛的诱惑
为了从视频中捕捉帧，我使用了 OpenCV。我们需要捕捉帧，应用中心裁剪，调整大小，并转换到 PyTorch 张量。
def cam_to_tensor(cam):
if cam.isOpened():
ret, frame_ = cam.read()
else:
cam.release()
cam = cv2.VideoCapture(video_source)
ret, frame_ = cam.read()
frame = cv2.cvtColor(frame_, cv2.COLOR_BGR2RGB)
frame_pil = Image.fromarray(frame)
image = transform(frame_pil)
return image, frame_, camtransform=transforms.Compose([
transforms.CenterCrop((360,360)),
transforms.Resize((224,224)),
transforms.ToTensor()
])
现在，所有的训练脚本。对于评论行，请检查我在以前的职位解释。链接可以在这篇文章的顶部找到。
首先，我们从视频中捕捉一帧。然后，我们准备好要提供给模型的帧。之后，模型训练分解的第一级。当最大相似值低于 0.3 时，我们开始训练下一级，以此类推。别忘了，视频中捕捉到的画面是城市旅游的场景。
lr = 0.02
optimizer = optim.SGD(model.parameters(), lr=lr)
lossfunc = nn.MSELoss()video_source = "./videoplayback.mp4"
cam = cv2.VideoCapture(video_source)loss_obs = 0
epoch = 0while epoch<4:
# if epoch>0:
# for cc,param in enumerate(model.main[epoch-1].parameters()):
# print(epoch-1,"grad is deactivated")
# param.requires_grad = True
for cnt in range(0,120000):
image, _, cam = cam_to_tensor(cam)
optimizer.zero_grad()
out = model(image.unsqueeze(0), queue = epoch+1)
sim_vec = sim_func(out)
loss = lossfunc(sim_vec, torch.zeros(sim_vec.shape))
loss_obs_ = torch.max(torch.abs(sim_vec-torch.zeros(sim_vec.shape)))
loss_obs += loss_obs_
loss.backward()
optimizer.step()
print("Epoch: {}\tSample: {}\tLoss: {}\tLR: {}".format(epoch,cnt,loss_obs_,optimizer.param_groups[0]["lr"]))if cnt%20 == 0 and cnt!=0:
loss_obs = loss_obs/20
print("Epoch: {}\tSample: {}\tLoss: {}\tLR: {}".format(epoch,cnt,loss_obs,optimizer.param_groups[0]["lr"]))
if loss_obs<0.30:
epoch += 1
break
loss_obs = 0
试验
我们的模特学会了欣赏城市风景。我们如何观察它学到了什么？我们可以捕捉随机帧，并将这些帧与后面的帧进行比较。通过这样做，我们可以观察帧的相似性值，并看到帧中每个场景出现的效果。例如:如果有一个特定的对象，如人、窗户等。在锚定帧中，并且如果在随后的帧中存在该对象，即使场景已经改变，并且如果相似性值有点高，那么我们理解模型可以提取特征来帮助它识别场景中的该对象。
def generate_embedding(model,cam,queue = 3):
image, frame, _ = cam_to_tensor(cam)
embedding = model(image.unsqueeze(0), queue = queue).flatten()
return embedding, framedef compare_samples(e1,e2):
first_norm = normalize(e1.flatten())
second_norm = normalize(e2.flatten())
return torch.matmul(first_norm,second_norm.T).detach().numpy()embedding_list = []
def compare_continuous(model,cam,queue):
min_sim = 1
max_diff = 0
font = cv2.FONT_HERSHEY_SIMPLEX
bottomLeftCornerOfText = (10,100)
fontScale = 1
fontColor = (255,255,255)
lineType = 2
last_sim_list = []
cnt_f = 0
while True:
if cnt_f%300==0:
e1, f1 = generate_embedding(model,cam,queue = queue)
cv2.imshow('frame 1', f1)
e2, f2 = generate_embedding(model,cam,queue = queue)
embedding_list.append(e2.detach().numpy())
embedding_list_np = np.array(embedding_list)
std = np.std(embedding_list_np, axis=0)
pca_idx = std.argsort()[-64:][::-1]
e1_pca = e1[pca_idx.tolist()]
e2_pca = e2[pca_idx.tolist()]
sim = compare_samples(e1_pca,e2_pca)
print(sim)
cv2.putText(f2,'Similarity: {}'.format(sim),
bottomLeftCornerOfText,
font,
fontScale,
fontColor,
lineType)
cv2.imshow('frame 2', f2)
if cv2.waitKey(25) & 0xFF == ord('q'):
break
cnt_f += 1
还有播放按钮。
compare_continuous(model,cam,queue=5)
演示视频可以在链接中找到。
Keras 中的多样本丢失
加速训练和更好地推广你的神经网络
安布尔·沃尔夫在 Unsplash 上拍摄的照片
Dropout 是一种有效的正则化工具，用于避免深度神经网络的过拟合。它的工作非常简单，在训练过程中随机丢弃一部分神经元；结果，泛化发生了，因为以这种方式神经元不再相互依赖。Dropout 很容易适用于每一个神经网络结构，它也可以用于各种目的:例如，我在的前一篇文章中用它来估计神经网络的不确定性。
在这篇文章中，我试图重现在这篇文章中的结果；引入了一种叫做多样本丢失的技术。正如作者所声明的，其范围是:
- 加快培训，提高对原有辍学学生的概括能力；
- 降低计算成本，因为大部分计算时间消耗在下面的层中(通常是卷积的或递归的),并且共享顶部层中的权重；
- 实现更低的错误率和损失。
数据
我想在一个 NLP 问题中应用论文中介绍的程序。我在 Kaggle 上发现了一个有价值的数据集。提供了新闻标题数据集来进行句子中的讽刺检测。这个数据集中的文本是从网上收集的，带有讽刺或不讽刺的相关注释。
标签分发
模型
我选择 NLP 任务是因为它允许我们用一致的训练时间来尝试一个循环的模型结构。此外，在网络末端附近使用 dropout 和全连接层使得执行时间不显著。
基本想法很简单:创建多个漏失样本，而不是只有一个，如下图所示。对于每个漏失样本，重复漏失层和漏失之后的几个层。“dropout”、“fully connected”和“softmax + loss func”层被复制。不同的掩模用于漏失层中的每个漏失样本，使得不同的神经元子集用于每个漏失样本。相反，参数(即，连接权重)在复制的完全连接的层之间共享。使用相同的损失函数(例如交叉熵)为每个丢失样本计算损失，并且通过对所有丢失样本的损失值求平均来获得最终损失值。该最终损失值用作训练期间优化的目标函数。将最后一个完全连接的层的输出平均值中具有最高值的类标签作为预测。
原始漏失与多样本漏失(来源)
在 Keras 语言中，所有的概念都可以用简单的代码实现:
def get_model(num):inp = Input(shape=(max_len,))
emb = Embedding(len(tokenizer.word_index) + 1, 64)(inp)
x = SpatialDropout1D(0.2)(emb)
x = GRU(128, return_sequences=True, activation='relu')(x)
out = GRU(32, activation='relu')(x)
dense = []
FC = Dense(32, activation='relu')
for p in np.linspace(0.1,0.5, num):
x = Dropout(p)(out)
x = FC(x)
x = Dense(y_train.shape[1], activation='softmax')(x)
dense.append(x)
out = Average()(dense)
model = Model(inp, out)
model.compile(loss='categorical_crossentropy',
optimizer='adam', metrics=['accuracy'])
return model
作为一个循环块，在模型的底部，我使用了 GRU 层。当模型被初始化时，丢失样本的数量被定义为参数。顶部完全连接的层共享每个漏失样本的权重。我用不同的掩码和不同的概率(从 0.1 到 0.5，不总是 0.5)构建了每个辍学样本(这是我允许自己采用的一个小变化)。网络有多个输出层，其数量与丢弃样本一样多。我们的网络的最后一步是一个平均层，它将前面的全连接层输出组合成一个简单的平均值。通过这种方式，最终损耗值计算为我们的丢失样本输出的平均值。
在训练阶段结束时，我们能够在测试集上实现大约 0.85%的最终准确度。
摘要
在这篇文章中，我试图重现一种叫做多样本丢失的技术。这是传统辍学的升级。它可以简单地应用于每一个神经网络结构(也可以应用于深度神经网络结构),并提供一种低成本的方式来更好地概括和改进结果，尤其是在分类任务中。
保持联系: Linkedin
参考文献
加速训练和更好推广的多样本辍学:井上浩，IBM 研究，东京
多表刮！
当你想从多篇文章中获取信息时该怎么做
克林特·王茂林在 Unsplash 上拍摄的照片
在过去的几个星期里，我一直在写如何从维基百科页面上抓取不同的东西。三周前，我写了一篇关于如何从维基百科文章中抓取一张表格的文章。两周前，我写了关于如何使用一个脚本从维基百科的多个页面中抓取数据的文章。最后，上周我写了一篇关于 s 使用颜色而不是文本来显示数据的文章。本周，我将讨论如何从多个表中抓取数据。
正如我们过去三周所做的那样，我们将继续研究关于英国烘焙大赛第一季的文章。本周，我们的目标是了解面包师如何应对技术挑战。对于那些不熟悉节目形式的人来说，每一集面包师都要经历三个挑战，签名，技术和节目主持人。技术上的挑战是，所有的面包师根据其中一位评委写的食谱烘焙相同的东西，这些面包师被匿名评判，并从最差到最好排序。在文章中，技术挑战结果显示在一个表格中，如下所示:
从一个图表中获取信息非常容易，您可以回到我的第一篇文章来回顾一下它是如何工作的。但是，当你想获得所有剧集的技术挑战信息时，你会怎么做呢？这将在下面讨论
正如我们一直在做的，我们将从导入包和使用 BeautifulSoup 访问网站开始
import requests
from bs4 import BeautifulSoup
import pandas as pd
import re
import numpy as npurl='https://en.wikipedia.org/wiki/The_Great_British_Bake_Off_(series_1)'page = requests.get(url)soup = BeautifulSoup(page.content)
此外，为了获得我们的面包师名单，我们将首先隔离排除图(上周我们使用的那张)。
然后，我们将通过执行以下操作从图表中获取面包师的姓名:
我不会过多地讨论我是如何得到这个列表的，因为这不是本文的重点，但本质上，如果排除表中的一个项目具有属性“align”，那么该项目的文本就是一个参赛者姓名。此外，如果“align”在项目的样式部分，文本也是参赛者姓名。这些名字被添加到一个列表中，在名字被刮掉之后，它们都通过。rstrip()去掉任何换行符。这给我们留下了一个参赛者名单，如下所示:
['Edd', 'Ruth', 'Miranda', 'Jasminder', 'David', 'Jonathan', 'Annetha', 'Louise', 'Lea', 'Mark']
现在我们要做的就是拿到所有的烘焙技术结果。下面是我们将要浏览的完整代码:
下面是上面代码的最终输出:
{1: {'Edd': 0,
'Ruth': 0,
'Miranda': 0,
'Jasminder': 0,
'David': 0,
'Jonathan': 0,
'Annetha': 0,
'Louise': 0,
'Lea': 0,
'Mark': 0},
2: {'Annetha': 2.0,
'David': 3.0,
'Edd': 1.0,
'Jasminder': 5.5,
'Jonathan': 9.0,
'Lea': 10.0,
'Louise': 5.5,
'Mark': 5.5,
'Miranda': 8.0,
'Ruth': 5.5},
3: {'Annetha': 7.0,
'David': 8.0,
'Edd': 6.0,
'Jasminder': 2.0,
'Jonathan': 1.0,
'Louise': 4.0,
'Miranda': 3.0,
'Ruth': 5.0},
4: {'David': 4.0,
'Edd': 1.0,
'Jasminder': 5.0,
'Jonathan': 6.0,
'Miranda': 3.0,
'Ruth': 2.0},
5: {'David': 5.0, 'Edd': 3.0, 'Jasminder': 2.0, 'Miranda': 1.0, 'Ruth': 4.0},
6: {'Edd': 2.0, 'Jasminder': 4.0, 'Miranda': 1.0, 'Ruth': 3.0}}
现在让我们进入上面的代码。前三行表示三个变量，“ep_counter”、“tech_results_list”和“ep_tech”，分别是零、空列表和字典。字典以键 1 开始，值是一个字典，其中键是参赛者的名字，值都是零。这样做是因为如果你使用这些数据来创建一个预测模型，你想从最近的前一集得到技术排名，而不是你正在分析的当前一集。显然，在第一集里，选手们没有进行技术烘焙，也没有被排名，因此他们都被分配了零分。
从这里，我们开始刮。前两行(5-6)查找所有包含“情节”的标题。然后我们创建两个空列表，名字和地点。名字将有来自一个给定的事件的选手名字，并且地点将有在所说的事件中选手如何被放置在技术烘焙中。在这里，我们执行以下操作:
本质上，我们正在做的是找到具有技术烘焙的剧集(上面的第 2 行)，然后我们获取整个表并将其命名为“result_tables ”,并向剧集计数器添加 1。最后，我们创建“ep_list”，这是一个从 2 开始到最后一集结束的数字列表(本例中为 6)。然后我们深入研究结果表:
我们首先找到包含参赛者姓名的列，我们这样做，“如果一个条目的文本中的一个单词与参赛者姓名列表中的一个条目匹配，则将该条目的文本添加到姓名列表中。”然后我们再看两栏，看看他们在技术上的排名。但是，您可能已经在文章中注意到了一个小问题:
在第一集中，只有前三名和后三名获得排名，所以我们不知道谁获得了第 4，第 5，第 6 和第 7 名。因此，当我将一个条目的文本追加到位置列表中时，我告诉 regex split 要么获取数字(可能有一个或两个数字)，要么获取“N/A”
考虑到这一点，我们如何处理像上面这样的缺失值呢？我选择的方法是取上述值的平均值，并将该平均值赋给缺失值，我使用下面的代码做到了这一点:
在这一点上，我将处理一个完整的位置列表，所以我首先说如果在位置列表中有一个“N/A ”,那么执行以下操作。然后我创建一个数字列表(num_list ),隔离列表中的所有数字，并使它们都是整数。然后，我取该列表的平均值(ave ),并用该平均值替换 place 列表中的所有“N/A”值。
现在我们有了一个名称列表，并且所有这些名称都有与之对应的位置编号，我们可以使用以下方法将它们放在一起:
place = [float(x) for x in place]episode_placement = dict(zip(names,place))tech_results_list.append(episode_placement)
首先，我们使位置列表中的所有项成为浮点型，因为它们以前是字符串，除非它们是代替“N/A”的平均值。然后，我们创建我们的字典(episode_placement ),其中键是参赛者的名字，值是它们在技术中的位置。然后，我们将该词典添加到我们一开始创建的技术结果列表中。
最后，我们能够更新我们开始时使用的 ep_tech 字典。如果您还记得，该字典以一个键和一个包含所有参赛者姓名的字典值 0 开始。现在我们有了以下剧集的所有信息，我们可以做以下事情:
ep_tech.update(dict(zip(ep_list,tech_results_list)))
通过这样做，我们获得了 ep_list，它计算了所有具有技术挑战的剧集，并使列表中的项目成为键，而值则是每集的名称和位置的字典。这导致了上面显示的输出:
{1: {'Edd': 0,
'Ruth': 0,
'Miranda': 0,
'Jasminder': 0,
'David': 0,
'Jonathan': 0,
'Annetha': 0,
'Louise': 0,
'Lea': 0,
'Mark': 0},
2: {'Annetha': 2.0,
'David': 3.0,
'Edd': 1.0,
'Jasminder': 5.5,
'Jonathan': 9.0,
'Lea': 10.0,
'Louise': 5.5,
'Mark': 5.5,
'Miranda': 8.0,
'Ruth': 5.5},
3: {'Annetha': 7.0,
'David': 8.0,
'Edd': 6.0,
'Jasminder': 2.0,
'Jonathan': 1.0,
'Louise': 4.0,
'Miranda': 3.0,
'Ruth': 5.0},
4: {'David': 4.0,
'Edd': 1.0,
'Jasminder': 5.0,
'Jonathan': 6.0,
'Miranda': 3.0,
'Ruth': 2.0},
5: {'David': 5.0, 'Edd': 3.0, 'Jasminder': 2.0, 'Miranda': 1.0, 'Ruth': 4.0},
6: {'Edd': 2.0, 'Jasminder': 4.0, 'Miranda': 1.0, 'Ruth': 3.0}}
现在，假设您有一个预先存在的数据帧，其中有关于这一集的其他数据，例如参赛者的年龄和家乡信息，以及他们在之前几集的表现。我之前创建了这个数据帧，下面是它的快照:
下面是我如何用那本字典创建一个技术安置专栏:
浏览代码时，我首先创建了一个字典，其中的关键字是带有名称和剧集的元组，值是参赛者如何放置该剧集(第 1-4 行)。然后我创建一个空列表 placement_list，它将成为技术栏。然后，我创建了一个元组列表，其中每个元组都是上面所示数据帧(第 6–7 行)中每行的参赛者姓名和剧集编号。从那里，我说对于元组列表中的每一项，在 tech_tuple 字典中查找它的值，并将该值添加到位置列表中。现在我已经有了一个完整的技术职位列表，我只需创建一个新的列“technical”并将其分配给职位列表。这就是我们如何得到以下结果的:
在本文中，我展示了如何查看页面的许多不同区域，而不仅仅是页面的一个图表或部分。维基百科页面的格式一般来说是可读的，并且便于用户理解，但这也意味着你可能正在寻找的数据需要被格式化和压缩。通过这样做，您可以获取可读信息并使其可处理。
使用 Pytorch 和 FastAI 进行多任务学习
使用相同的模型预测年龄、性别和种族。
阿纳斯塔西娅·舒拉耶娃在像素上拍摄的照片
根据我在名为的帖子中提出的概念，你应该使用 FastAI 吗？，我想在这里展示如何使用混合 Pytorch-FastAI 方法来训练多任务深度学习模型。Pytorch-FastAI 方法的基本思想是使用 Pytorch 代码定义数据集和模型，然后使用 FastAI 来拟合您的模型。这种方法为您提供了构建复杂数据集和模型的灵活性，但仍然能够使用高级 FastAI 功能。
多任务学习(MTL)模型是一种能够完成多项任务的模型。就这么简单。一般来说，一旦你发现自己在优化不止一个损失函数，你就有效地在做 MTL。
在这次演示中，我将使用 UTKFace 数据集。该数据集由超过 30k 张带有年龄、性别和种族标签的图像组成。
年龄:61 岁，性别:女性，民族:印度人
如果你想跳过所有的谈话，直接跳到代码，这里有链接。
1.为什么要多任务学习？
当你看着某人的照片并试图预测年龄、性别和种族时，你没有使用完全不同的大脑区域，对吗？我想说的是，你不要试图用 3 种不同的方式去理解这幅图像，每一种方式都是针对每一项任务的。你所做的是利用大脑对图像的单一理解，然后试图将这种理解解码成年龄、性别和种族。除此之外，来自性别估计的知识可能有助于年龄估计，来自种族估计的知识可能有助于性别估计等等。
那么，为什么是 MTL？我们相信，训练一个模型来完成我们感兴趣的所有任务，会比训练一个模型来完成每项任务产生更好的结果。里奇·卡鲁阿纳很好地总结了 MTL 的目标:“MTL 通过利用相关任务的训练信号中包含的特定领域信息来提高概括能力”。
由于这是一个训练 MTL 模型的实用教程，我不会深入理论和直觉，但如果你想阅读更多，请查看 Sebastian Ruder 的这篇惊人的帖子。
2.创建数据集、数据加载器和数据绑定
编辑:有些人报告了代码中的一个错误，看起来像是一个图像正在破坏它。好像删除图片“61_3_20170109150557335.jpg”就解决问题了。(谢谢 Stonelive ！)
当你在处理深度学习问题时，通常首先要关心的是如何向你的模型提供数据，以便它能够学习。对于这个特定的 MTL 问题，Pytorch 数据集的定义非常简单。
数据集类定义
你可能会问，为什么我取年龄的对数，然后除以 4.75。取对数意味着预测高年龄和低年龄的误差将同样影响结果。稍后我会解释为什么除以 4.75。另外要提的是，我这里用的是 FastAI 的数据增强(我觉得比 torchvision.transforms 的要好)。
一旦定义了 dataset 类，创建 dataloaders 和 databunch 就非常容易了。
创建数据集、数据加载器和数据绑定。
3.创建模型
请记住，我们的目标是根据给定的图像，预测年龄、性别和种族。回想一下，预测年龄是单输出的回归问题，预测性别是双输出的分类问题，种族是 5 输出的分类问题(在这个特定的数据集中)。考虑到这一点，我们可以创建我们的 MTL 模型。
您可以看到该模型只使用了一个编码器(一个特征提取器),并将编码(特征)提供给特定于任务的头部。每个头有适当数量的输出，以便它可以学习它的任务。
为什么我要对来自 ages head 的结果应用一个 sigmoid？这与我之前提到的除以 4.75 有关，我会在下节课讲。
4.损失函数呢？
损失函数是指导训练的，对吗？如果你的损失函数不好，你的模型也不会好。在 MTL 问题中，通常你要做的是将每项任务的损失结合起来。例如，在我们的问题中，损失可能是预测年龄的均方误差和预测性别和种族的交叉熵。对于 MTL 问题，有一些组合任务特定损失的常用方法。我就说其中的三个。
第一步是计算每项任务的损失，然后将它们加在一起，或者取平均值。尽管我在一些论坛上读到过这种方法很有效，但这并不是我从实验中得出的结论。由于损失可能有不同的大小，其中一个损失可以控制训练，你不会得到好的结果。
第二步是试着用手称量损失，然后将它们相加/平均。事实证明，这种方法相当复杂，需要太多时间，我也无法让它工作。
另一方面，第三次拍摄给我带来了不错的结果。它包括让模型学习如何衡量特定任务的损失。在论文多任务学习使用不确定性来衡量场景几何和语义的损失中，作者提出了这样的损失函数。下面是我对论文中针对这个具体问题的建议的实现。
我们提出了一种多任务深度学习的原则性方法，该方法通过考虑每个任务的同方差不确定性来权衡多个损失函数。这允许我们在分类和回归设置中同时学习不同单位或标度的各种量。
现在我应该解释一下为什么我选择将年龄的对数除以 4.75(在 dataset 类的 getitem 方法上)以及为什么我将 sigmoid 应用于年龄头部的输出(在模型定义上)。
理论上，损失函数应该能够学习权重并衡量每个任务的损失。但事实上，在我的实验中，我得出结论，保持特定任务的损失在相同的范围内对拟合过程有很大帮助。所以我用年龄的对数除以 4.75，因为这是对数(年龄)的最大值。所以 log(age)/4.75 的结果应该是 0 到 1 之间的一个数，这样 MSE 损失就不会比其他损失大很多。我在年龄的头部后应用了一个 sigmoid，这样我可以强制我的模型总是输出一个在可接受范围内的预测。
5.创造学习者和培训
通过数据分组，模型和损失函数定义了创建学习器的时间。我将添加一些指标来帮助我跟踪模型在验证集上的性能。
定义了学习者之后，现在我们可以使用 FastAI 功能来训练我们的模型。我们可以使用学习率查找器、fit_one_cycle 方法、判别学习率训练等。
由于我使用的是在 Imagenet 上预训练的 resnet34 编码器，首先我将只训练编码器上的头部和批次规范层。经过 15 个纪元的训练，我得到了年龄预测的 0.087 RMSE，性别预测的 89.84% 准确率和种族预测的 84.15% 准确率。
之后，我解冻编码器，并用 100 个时期的判别学习率训练整个模型，这使我得到了年龄预测的 0.058 RMSE，性别预测的 99.42% 准确度和种族预测的 99.19% 准确度。
6.结论
在这篇文章中，我介绍了使用 Pytorch/FastAI 混合方法训练 MTL 模型所需的基础知识。我想我再次展示了 FastAI 的高级功能非常有用，让我的生活变得更加轻松。如此轻松地使用高级深度学习功能作为区分性学习速率和一个周期调度，在我看来是 FastAI 的大拇指。
值得一提的是，在本教程中，我的重点是帮助你解决一个 MTL 问题。UTKFace 数据集非常偏向于白人和年龄在 20 到 40 岁之间的人，所以你应该记住这一点。在我的最终实现中，我对损失函数做了一些小的调整，使得模型的性能偏差更小。
如果你喜欢这篇文章，请给它一些掌声。你可以通过访问我的 github 查看更多关于我正在做的事情，并通过 LinkedIn 取得联系。
感谢您的阅读！
Google Cloud AI 平台上的 Tensorflow 多工培训
理解大数据
图片由作者在 CC BY-NC 4.0 下
几乎在每个深度学习项目中，都有一个决定性的时刻，海量的训练数据或缺乏处理能力成为在适当的时间完成训练的限制因素。因此，应用适当的缩放是不可避免的。虽然纵向扩展，即升级到更强大的硬件，可能会提供暂时的补救措施，但它很少提供正确的可扩展性，因为纵向扩展会很快达到其物理极限。因此，我们没有其他选择，只能扩大模型训练，即使用额外的机器。幸运的是，在云时代，横向扩展不再是一个障碍。
谈到向外扩展神经网络训练，有两种主要方法。有一种叫做模型并行的策略，在这种策略中，神经网络本身被分割到多个设备上。这种类型的分布主要用于模型由大量参数组成并且不适合特定设备的情况，或者输入样本的大小甚至会妨碍计算激活的情况。对于那些对 Tensorflow 的模型并行感兴趣的人，有一个官方的解决方案叫做 Mesh 。
另一种分布策略称为数据并行，其中模型在每个节点上复制。然后，数据以这样的方式分布，每个副本看到它的不同部分。这种分布策略对于具有大量训练数据的情况特别有用。
由于每个副本在每一步都接收到不同的训练数据片段，因此工作人员必须有序地传达梯度更新。有两种沟通方式。有异步训练、、工人独立训练自己的复制品。异步训练通常使用离散参数服务器来报告梯度更新。
另一种是同步训练，在每一个训练步骤之后，工人们分享参数更新。同步训练经常实现全归约算法，这意味着所有副本存储归约(更新)的参数，而不是将它们传递到中央位置。
异步训练的主要好处体现在避免最慢的工人空闲，以及稍微好一点的机器容错能力。主要缺点是参数服务器需要大量的网络带宽来与工作人员进行有效的通信。运行多个参数服务器可能会解决这个问题，但也会增加培训成本。
同步训练的权衡正好相反。不需要使用额外的机器来存储更新的模型参数。另一方面，等待最慢的工人肯定会拖延进程。选择业绩相似的员工可能会减少闲置时间。采用高效的网络拓扑来共享梯度更新同样至关重要。工人之间多余的交流会抵消同步培训的好处。
多工人分布式张量流
Tensorflow 通过tf.distribute.Strategy API 在他们的标准库中实现数据并行策略。它们支持同步和异步多工人培训，尽管后者支持有限。截至撰写本文时，异步的ParameterServerStrategy只支持原始的tf.estimator.Estimator API。然而，从 2.4 版本开始，人们开始努力使异步培训变得更加可用。
自从 Tensorflow 2.0 发布以来，tf.keras.Model API 已经成为构建神经网络的主要方式，尤其是那些不需要定制训练循环的神经网络。新开发的分布式培训策略同样主要集中在 Keras 模型上。尽管已经为 Keras 模型实现了几种分布式培训策略，但是在撰写本文时，当前可用的多工人培训仅仅是同步的MultiWorkerMirroredStrategy。
这个策略为我们增加了很多负担。它会根据所用的硬件和网络拓扑来优化选择合适的 all-reduce 实现。目前，可用的选项有 ring all-reduce 和 NVidia 的 NCLL 。在训练 Keras 模型的情况下，该策略还自动在工人中分发训练数据集。通过文件或数据对数据集进行分片，可以进行分发。按文件分片是首选，因为每个副本只加载分配的文件。例如，它可用于 TFRecord 数据集。在其中存储训练样本是高效处理大型数据集的最有效方式。另一方面，如果没有办法按文件进行分片，那么所有的工作人员都会读取所有可用的数据，但是他们只处理分配给他们的分片。例如，在直接从 BigQuery 中读取数据的情况下，或者文件数量少于 workers 的情况下，可能会发生日期分片。验证和测试数据集也是如此。
该策略还可以通过名为BackupAndRestore的 Keras 回调提供容错。该回调在每个时期结束时备份模型。如果发生工人中断，所有其他工人也将重新开始，并且训练从最后完成的训练时期继续。模型训练成功后，存储的检查点将被删除。
多工人配置
在 Tensorflow 中配置多工人培训最简单的方法是通过名为TF_CONFIG的环境变量。它是一个 JSON 字符串，包含两个键，cluster和task。前者描述拓扑结构，包括节点的地址。它的值在所有节点上都是相同的。后者对于每个节点都是唯一的，并定义了它们在集群中各自的角色。一旦 Tensorflow 解析了环境变量，它就会根据配置启动 gRPC 服务器。
以下示例描述了一个包含两个节点的集群，一个主节点和一个工作节点。
TF_CONIFG
在这个集群中有一个指定的节点具有额外的职责，称为主节点。它可以满足诸如保存训练检查点、为 TensorBoard 编写摘要以及序列化训练模型等任务的需要。如果在配置中没有明确指定负责人，则索引为 0 的工作人员将担任该角色。当然，主节点也执行相同的代码。
多工人模型
将MultiWorkerMirroredStrategy与 Keras 模型集成很简单。只有几个要求。首先，模型的构建和编译必须在分销策略的范围内进行。其次，批量大小必须反映节点的数量。通常，批量大小通过乘以节点数来调整。保持原来的批量大小也是可行的。但是，在这种情况下，工人收到的批次较少。这些方法分别被称为弱缩放和强缩放。
多员工战略范围
与常规 Keras 训练相反的另一个区别是需要指定steps_per_epoch参数，否则这是可选的。每个时期的步骤数很容易计算，并且是训练实例数除以调整后的全局批量的比率。函数create_model包含了定义一个包含模型编译的模型的常用方法。
创建模型助手方法
保存一个多工人模型有点复杂。所有节点都必须保存模型，尽管保存到不同的位置。最后，除了主节点之外的所有节点都必须删除它们保存的版本。采取这些步骤的原因是所有-减少通信仍然可能发生。
多工人模型保存
人工智能平台上的多人培训
Google Cloud 和 Tensorflow 和谐地协同工作。Tensorflow 在 AI 平台中一直享有突出的地位。此外，谷歌云也一直在努力开发 Tensorflow 的新产品。例如，他们最近推出了带有补充支持和托管服务的 Tensorflow Enterprise 。
正如我们所见，正确设置TF_CONFIG是 Tensorflow 多员工培训的重要组成部分。对于 Tensorflow 来说，在运行模型训练之前，环境变量必须存在。幸运的是，AI 平台会根据给定的培训作业配置来负责设置。
有两种方式提供作业配置。功能是设置提交命令的各个选项。但是，对于不常改变的属性，将它们存储在 YAML 配置文件中更方便。对于成功的多人培训，需要的选项有runtimVersion、pythonVersion、scaleTier、masterType、worketType、workerCount。
培训配置
上面的配置文件将创建一个由三个节点组成的集群，包括一个首领和两个工人。机器的类型可以不同，但最好是在整个培训集群中保持相同。也有预定义的机器层级，但是它们都带有参数服务器。因此，将 scale-tier 设置为 custom 是当前的当务之急。
配置还指定了 Tensorflow 版本，它等于runtimeVersion属性。运行时会定期更新，但支持更高版本的 Tensorflow 需要一些时间。需要注意的是，2.1 版之前的运行时没有正确设置主节点。因此，AI 平台上的多工人培训仅适用于运行时 2.1 和更高版本。
另一方面，在某些情况下，能够使用尚不支持的 Tensorflow 版本是至关重要的。例如，有相关的新特性，或者它们需要在投入生产之前进行适当的测试。对于这种情况，Google AI 平台提供了使用自定义容器进行训练的选项。提交定制容器进行培训与使用所提供的运行时非常相似。不过，还有一些小细节需要考虑。为了拥有正确的TF_CONFIG，容器化张量流模型需要将选项useChiefInTfConfig设置为true。此外，培训配置必须为主管和工人指定图像 URIs。当然，两种情况下的容器是相同的。
自定义容器配置
在官方运行时和自定义容器中，AI 平台训练都自动使用云 ML 服务代理凭证。
本地测试
在向 AI 平台提交作业之前，在本地测试培训配置的正确性是可行的，因为失败的作业也会被计费。幸运的是，官方运行时在本地运行、执行
gcloud ai-platform local train --distributed --worker-count $N ...
命令为我们设置了一个正确的TF_CONFIG。唉，它还在配置中添加了一个参数服务器。Tensorflow 会发出警告，但拥有参数服务器不会妨碍训练。
对于容器，设置一个正确的TF_CONFIG并运行容器稍微复杂一点，但并非不可行。实现本地测试的最简单的方法是使用 docker-compose 来运行主容器和工作容器以及设置环境变量。
docker-编写用于本地测试的配置
COMMAND变量是一个字符串，包含训练任务的所有参数。一旦 docker-compose 配置完成，只需点击
docker-compose up
在这两种情况下，如果培训需要访问其他 Google 云服务，例如云存储，那么必须在运行本地培训之前定义指向正确的服务帐户密钥 JSON 文件的GOOGLE_APPLICATION_CREDENTIALS。
后续步骤
构建神经网络本身并不是一项简单的任务。在此基础上处理分布式计算最终会严重阻碍这一过程。幸运的是，现代深度学习框架是在考虑可扩展性的情况下构建的，因此能够实现更快的开发。此外，由于 Tensorflow 和 Google Cloud 之间的顺利兼容，开发这种可扩展性从未像现在这样容易。
简单的例子
事实上，这种平稳性乍看起来可能并非如此。为此，我在 Github 上创建了一个简单的工作示例。查看实际细节。记住，最好的学习方法是实践。
在 Google Cloud AI 平台上设置和运行 Tensorflow 多工人培训模型的简单示例。这个…
github.com](https://github.com/kalosisz/tf-gcp-multi-worker-example)
资源
RoboCup 救援模拟器的多智能体强化学习
RoboCup 救援模拟器
多智能体，强化学习，RoboCup 救援模拟器。标题中已经使用了相当多的术语。但是不用担心。读完这篇文章，你会明白其中的每一点。我将首先构建一些关于机器学习的背景，机器学习技术的类型，然后深入研究强化学习领域。这是事情开始变得稍微技术性的地方，但我会尽量保持简单，并尽可能提供例子。然后，我将解释我如何应用强化学习来训练一群消防队，以找到着火的建筑并扑灭这些建筑中的火。全靠自己！所以，为这次激动人心的旅程做好准备吧。
什么是机器学习？
我们正处于这样一个时代，我们可以教机器如何学习，一些机器甚至可以自己学习。这种神奇的现象叫做机器学习。但是机器是怎么学习的呢？他们通过在相似的数据中寻找模式来学习。把数据想象成你从世界上获得的信息。给机器的数据越多，它就越“聪明”。
机器学习算法的类型
机器学习算法有哪些类型？
从广义上讲，有三种类型:监督学习、非监督学习和强化学习。
1.监督学习
机器从标记的数据中学习。标记数据由未标记数据组成，带有数据中特征的描述、标签或名称。例如，在标记的图像数据集中，图像被标记为它是猫的照片并且它是狗的照片。
2.无监督学习
机器从未标记的数据中学习。未标记数据由取自自然或人类创造的数据组成，以探索其背后的科学模式。未标记数据的一些例子可能包括照片、录音、视频、新闻文章、推文、x 光片等。主要概念是数据中的特征没有解释、标签、标记、类或名称。
3.强化学习
它是一种机器学习技术，使代理能够在交互式环境中使用来自其自身行为和经验的反馈，通过反复试验来学习。
虽然监督学习和强化学习都使用输入和输出之间的映射，但与监督学习不同，监督学习向代理提供的反馈是执行任务的一组正确的动作，强化学习使用奖励和惩罚作为积极和消极行为的信号。
与无监督学习相比，强化学习在目标方面是不同的。虽然无监督学习的目标是找到数据点之间的相似性和差异，但在强化学习的情况下，目标是找到一个合适的动作模型，使代理的总累积报酬最大化。下图说明了通用 RL 模型的行动-奖励反馈回路。
强化学习模型的抽象描述
如何公式化一个基本的强化学习问题？
描述 RL 问题基本要素的一些关键术语是:
- 环境— 代理运行的物理世界
- 状态— 代理的当前状态
- 奖励— 环境的反馈
- 策略— 将代理的状态映射到动作的方法
- 价值— 代理在特定状态下采取行动将获得的未来回报
一个 RL 的问题可以通过游戏得到最好的解释。就拿 吃豆人 这个游戏来说，代理人(吃豆人)的目标是吃掉格子里的食物，同时避开途中的幽灵。在这种情况下，网格世界对于代理来说是一个交互环境。代理人会因为吃了食物而得到奖励，如果被鬼魂杀死(输掉游戏)则会受到惩罚。状态是代理在网格世界中的位置，总的累积奖励是代理赢得游戏。
强化学习应用于 PacMan 的例子
为了建立一个最优策略，代理人面临着探索新状态，同时最大化其整体报酬的困境。这叫做勘探与开发权衡。为了平衡这两者，最好的整体策略可能需要短期的牺牲。因此，代理应该收集足够的信息，以便在未来做出最佳的整体决策。
马尔可夫决策过程【MDPs】是描述 RL 中环境的数学框架，几乎所有的 RL 问题都可以用 MDPs 来表述。一个 MDP 由一组有限的环境状态 S，一组在每个状态下的可能动作 A(s)，一个实值报酬函数 R(s)和一个转移模型 P(s '，s | a)组成。然而，真实世界的环境更有可能缺乏任何环境动力学的先验知识。在这种情况下，无模型 RL 方法就派上了用场。
Q-learning是一种常用的无模型方法，可用于构建自玩 PacMan 代理。它围绕着更新 Q 值的概念，Q 值表示在状态 s 中执行动作 a 的值。下面的值更新规则是 Q 学习算法的核心。
q 学习算法
策略梯度 是另一种流行的无模型 RL 方法，但它不计算 Q 值，而是使用策略。政策学习从每个状态到行动的映射，它的目标是发现哪些行动导致更高的回报并增加它们的概率。政策梯度观察环境并在其中采取行动，并根据其获得的回报不断更新其政策。经过多次迭代后，策略收敛到最大值。策略梯度方法的缺点可能是，它有时会陷入局部最大值，而无法达到全局最大值。
最常用的强化学习算法有哪些？
在有大的状态和动作空间的情况下，学习每个状态和动作对的 Q 值或策略是不可行的。这是使用深度强化学习(DRL)** 的时候，其中利用神经网络对 RL 的组件进行建模。**
深度强化学习架构
我们考虑两种基于 DRL 模型的算法:深度 Q 学习和 ProximalPolicy 优化，主要是因为 DQN 在 Atari 游戏上表现出了很好的结果，并帮助团队实现了人类水平的表现，而使用 PPO，OpenAI 的 DOTA 2 团队能够在公开比赛中击败 99.4%的玩家。
深度 Q 网(DQN)
DQN 是 Q 学习和深度神经网络的结合。DQN 通过使用两种观点解决了使用非线性逼近器来表示 Q 值所导致的不稳定性:经验重放和目标网络。
****体验回放:例如，我们将最后一百万个转场(或视频帧)放入一个缓冲区，并从该缓冲区中抽取一个 32 大小的小批量样本来训练深度网络。这就形成了一个足够稳定的输入数据集用于训练。当我们从重放缓冲区随机取样时，数据更加相互独立，更接近于同分异址。
****目标网络:我们创建两个深度网络 θ- 和 θ。我们使用第一个来检索 Q 值，而第二个包括训练中的所有更新。比如说 100，000 次更新之后，我们将 θ- 与 θ 同步。目的是暂时固定 Q 值目标，这样我们就没有一个移动的目标可以追逐。此外，参数变化不会立即影响 θ- ，因此即使输入可能不是 100% i.i.d .，也不会错误地放大其效果，如之前的所述。
有了经验重放和目标网络，我们有了更稳定的输入和输出来训练网络，并且表现得更像监督训练。要了解更多关于 DQN 是如何运作的，请阅读乔纳森·许的这篇令人惊叹的文章。
近似策略优化(PPO)
PPO 是一种政策梯度方法，其表现相当于或优于最先进的方法，但实施和调整要简单得多。为了用策略梯度算法获得好的结果，需要仔细调整步长。此外，大多数策略梯度方法对每个采样轨迹执行一次梯度更新，并且具有高样本复杂度。PPO 算法解决了这两个问题。它使用了一个替代目标，该目标被最大化，同时惩罚对策略的大的改变。他们定义了一个可能性比率
PPO 然后优化目标:
其中 A_t 是广义优势估计，clip (l_t(θ)，1ε，1+ε)在区间[1-ε，1+ε]内 clips l_t(θ)。该算法在从策略中采样多个轨迹和在采样的数据集上执行 SGD 的几个时期之间交替，以优化该替代目标。由于状态值函数也被同时近似，所以值函数近似的误差也被添加到替代目标以计算完整的目标函数。要了解更多关于 PPO 如何工作的信息，请阅读 Jonathan Hui 的这篇令人惊叹的文章。
RoboCup 救援模拟器
现在理论到位了，让我们把重点放在一些应用上。1995 年 1 月 17 日，日本港口城市神户发生里氏 6.8 级地震，造成大规模破坏，约 7000 人丧生。1999 年 4 月 30 日，RoboCup 救援联盟成立，旨在促进国际研究，开发更好的救援能力。多年来，许多团队都参加了一年一度的机器人世界杯救援联盟，该联盟包括三个竞赛:机器人竞赛、虚拟机器人竞赛和模拟代理人竞赛。我们将重点关注被称为机器人世界杯救援模拟(RCRS)的模拟智能体竞赛，这是多智能体系统的一个完美例子。我们将把强化学习应用到 RCRS，以训练这些代理完成他们各自的任务。
RoboCup 救援模拟环境
以下是分配给代理的任务:
- ****消防队:灭火
- ****警察:清除碎片
- ****救护车:运送平民到安全避难所
在这篇文章中，我们将关注消防队，并训练他们学会如何在城市中灭火。
RoboCup 救援模拟器(RCRS)的强化学习
正如我们上面所讨论的，为了制定任何 RL 模型，我们需要定义状态空间、动作空间和奖励函数。让我们讨论一下 RCRS 的这些属性。
状态空间 :状态空间有三部分。第一部分是建筑物信息，包括温度和热度。注意，火热度是衡量程度的一个参数。一栋大楼着火了。第二部分是代理信息，它给出了每个时间步的位置((X，Y)坐标)、消防水箱中的水和消防队的健康点。第三部分是忙/闲信息，它是一个二进制变量。消防队在每个时间点都会收到一个建筑物 id 作为他们的目标位置。但是有时它们需要一个以上的时间间隔才能到达建筑物。与此同时，动作不断被发送。因此，消防队必须忽略这些动作，直到他们访问在先前时间步中被告知要访问的建筑物。该信息作为状态信息被传递，这对于我们的算法更好地执行是非常有价值的。每当由算法发送的动作在模拟器中被使用时(忙)，1 作为状态信息被发送回来，否则 0 被发送(空闲)。
状态空间参数范围
动作空间: 我们的代理唯一可用的动作是移动到着火的建筑物，因此动作空间由建筑物的 ID 组成。请注意，灭火和补水是我们的代理的默认特征，即，每当我们的代理靠近着火的建筑物时，它将尝试灭火，每当它离开水时，它将移动到避难所来给水箱补水。因此，这些动作不包括在动作空间中。
奖励功能 :由于消防队的最终目标是尽可能快地灭火，我们创建了一个奖励功能，对将火势控制在最低限度的特工给予更高的奖励，如果火势增大则对他们进行惩罚。火热度是衡量建筑物燃烧程度的一个参数，因此将整体火热度值保持在最低会导致更高的累积奖励。
奖励计算
根据火热程度值的火热程度
模型架构
我们使用 DQN 和 PPO 架构，做了一些修改。我们没有卷积层的集合，因为神经网络的输入不是图像。网络的输入是状态表示，每个可能的动作有一个单独的输出单元。稳定基线可以选择使用不同的架构，我们可以改变隐藏层的数量，使用 LSTM，使用 CNN 或结合 CNN 和 LSTM。我们在训练模型时尝试了不同的架构。作为我们尝试的一种架构的示例，请参考下图。
模型架构
超参数搜索
该表显示了我尝试训练模型的不同超参数。
PPO 超参数
DQN 超参数
结果
理论太多！让我们言归正传。结果如何？
以下是训练有素的特工对 DQN 和 PPO 的一些模拟。这些视频是在特定的时间间隔拍摄的，即在 5 集、150 集和 250 集之后。每集 100 个时间步长。
这里红色的移动点代表消防队，右下角是避难所，消防队正在那里重新装满他们的水箱。
不同的颜色阴影代表了这些建筑的火灾强度:
- 淡黄色:建筑物起火
- 橙色:楼内火势加剧
- 红色:建筑燃烧严重
- 黑色:建筑被烧毁
- 蓝色:消防队将大楼内的火扑灭
- 灰色:建筑未燃烧
这里是一个可视化的模拟器在未经训练时的样子，以及它如何开始学习最终扑灭城市中的所有火灾。
学习曲线
两种算法的学习曲线
从上面的曲线和 gif 可以看出，这两种算法都在这个模拟器上成功地学习，并且能够成功地完成它们的任务。从学习曲线中，我们还可以看到，DQN 在这种情况下比 PPO 表现得更好，并且能够快速学习。尽管如此，结果并不比贪婪算法更好(在贪婪算法中，所有的代理将熄灭温度最高的建筑)。目前，我正在一张有更多建筑的地图上训练这些代理，并将很快分享结果。
我要感谢我的导师皮特·斯通、加勒特·沃内尔和子超，他们给了我参与这个项目的机会。
这是我的 GitHub 回购协议的链接。
学习强化学习的要领！
towardsdatascience.com](/reinforcement-learning-101-e24b50e1d292) [## 机器学习初学者指南
我应该现在学…还是以后学？学习是一种普遍的技能/特性，是任何生物在这方面获得的…
medium.com](https://medium.com/@randylaosat/a-beginners-guide-to-machine-learning-dfadc19f6caf) [## 多智能体强化学习
在目前人工智能(AI)研究的各个领域中，有一个领域已经…
medium.com](https://medium.com/@RemiStudios/multi-agent-reinforcement-learning-3f00b561f5f0) [## 我在深度学习方面的文章列表
包括物体检测、自动驾驶汽车、元学习等
medium.com](https://medium.com/@jonathan_hui/index-page-for-my-articles-in-deep-learning-19821810a14)**
Python 中从头开始使用逻辑回归的多类分类:分步指南
Tj·霍洛韦丘克在 Unsplash 上拍摄的照片
逻辑回归的两种方法:梯度下降法和优化函数
逻辑回归是一种非常流行的机器学习技术。当因变量是分类变量时，我们使用逻辑回归。本文将集中讨论多类分类问题的逻辑回归的实现。我假设您已经知道如何用逻辑回归实现二元分类。
如果你还没有用逻辑回归研究过二元分类，我建议你在深入研究这篇文章之前先浏览一下这篇文章。
因为多类分类是建立在二类分类之上的。
在本文中，您将学习二进制分类的概念、公式和工作示例:
发展逻辑回归演算法的重要方程式和如何发展逻辑回归演算法…
towardsdatascience.com](/logistic-regression-in-python-to-detect-heart-disease-2892b138d0c0)
多类分类
多类分类的实现遵循与二类分类相同的思想。如你所知，在二元分类中，我们解决一个是或否的问题。与上述文章中的示例一样，输出回答了一个人是否患有心脏病的问题。我们只有两节课:心脏病和非心脏病。
如果输出为 1，则此人患有心脏病，如果输出为 0，则此人没有心脏病。
在多类分类中，我们有两个以上的类。这里有一个例子。比方说，我们将汽车、卡车、自行车和船只的不同功能和特征作为输入功能。我们的工作是预测标签(汽车、卡车、自行车或船)。
这怎么解决？
我们将把每一个类当作一个二元分类问题，就像我们解决一个心脏病或没有心脏病的问题一样。
这种方法被称为一对一方法
在 one vs all 方法中，当我们处理一个类时，这个类用 1 表示，其余的类变成 0。
例如，如果我们有四类:汽车、卡车、自行车和船。当我们处理汽车时，我们将汽车作为 1，其余的类作为 0。同样，当我们在卡车上工作时，卡车的元素将是 1，其余的类将是 0。
等你落实了就更好理解了。我建议你在阅读的时候继续编码和运行代码。
在这里，我将用两种不同的方式实现这个算法:
- 梯度下降法。
2.优化函数方法。
重要方程式及其工作原理:
逻辑回归使用 sigmoid 函数来预测输出。sigmoid 函数返回一个从 0 到 1 的值。一般我们取一个阈值，比如 0.5。如果 sigmoid 函数返回大于等于 0.5 的值，我们将其视为 1，如果 sigmoid 函数返回小于 0.5 的值，我们将其视为 0。
z 是输入特征乘以表示为θ的随机初始值。
这里，X 是输入特征。在大多数情况下，有几个输入特征。所以，这个公式变大了:
X1、X2 和 X3 是输入要素，将为每个输入要素随机初始化一个θ。开始时的θ0 是偏置项。
该算法的目标是在每次迭代中更新该θ，以便能够建立输入要素和输出标注之间的关系。
成本函数和梯度下降
成本函数给出了我们的预测与原始输出有多远的想法。这是它的公式:
这里，
m 是训练样本的数量或训练数据的数量，
y 是原始输出标签，
h 是假设或预测输出。
这是梯度下降的方程式。使用这个公式，我们将在每次迭代中更新θ值:
用梯度下降法实现
先决条件:
a.您需要能够舒适地读写 python 代码。
b.基本数字图书馆和熊猫图书馆。
在这里，我将一步一步地展示实现过程。
- 导入必要的包和数据集。我从 Coursera 的吴恩达的机器学习课程中获取了数据集。这是一个手写识别数据集。有从 1 到 10 的数字。
从像素数据集中，我们需要识别数字。在该数据集中，输入变量和输出变量被组织在 Excel 文件的不同表格中。请随意从本页末尾的链接下载数据集。
如果你正在阅读这篇文章来学习这个算法，请运行每一段代码。
让我们导入必要的包和数据集，
import pandas as pd
import numpy as np
xl = pd.ExcelFile('ex3d1.xlsx')
df = pd.read_excel(xl, 'X', header=None)
2.导入 y，这是输出变量
y = pd.read_excel(xl, 'y', header = None)
3.定义采用输入变量和θ的假设。它返回计算出的输出变量。
def hypothesis(theta, X):
return 1 / (1 + np.exp(-(np.dot(theta, X.T)))) - 0.0000001
4.构建采用输入变量、输出变量和θ的成本函数。它返回假设的成本。这意味着它给出了预测与原始输出之间的距离。
def cost(X, y, theta):
y1 = hypothesis(X, theta)
return -(1/len(X)) * np.sum(y*np.log(y1) + (1-y)*np.log(1-y1))
5.现在，是数据预处理的时候了。
数据是干净的。不需要太多的预处理。我们需要在输入变量中添加一个偏差列。请检查 df 和 y 的长度。如果长度不同，模型将不起作用。
print(len(df))
print(len(y))
X = pd.concat([pd.Series(1, index=df.index, name='00'), df], axis=1)
6.y 列有从 1 到 10 的数字。这意味着我们有 10 节课。
y 是一个不必要的数据帧。我将只把列作为包含值的序列。
y = y.iloc[:, 0]
我们将为每个类创建一个长度与 y 相同的列。当类为 5 时，为包含 5 和 0 的行创建一个包含 1 的列，否则为 0。
看看，我们有多少节课，
y.unique()
输出:
array([10, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int64)
所以，我们有 10 节课。启动一个有 10 列和 df.shape[0]行的 DataFrame。
y1 = np.zeros([df.shape[0], len(y.unique())])
y1 = pd.DataFrame(y1)
我们将用一些简单的代码以编程的方式实现它:
for i in range(0, len(y.unique())):
for j in range(0, len(y1)):
if y[j] == y.unique()[i]:
y1.iloc[j, i] = 1
else:
y1.iloc[j, i] = 0
y1.head()
7.现在定义函数‘gradient _ descent’。该函数将输入变量、输出变量、theta、alpha 和历元数作为参数。这里，α是学习率。
你应该根据你的要求来选择它。学习率太小或太大都会使你的算法变慢。我喜欢针对不同的学习速率运行算法，并获得正确学习速率的想法。可能需要几次迭代来选择正确的学习速率。
对于 y1 中的每一列，我们将实现一个二元分类。
例如，当我考虑数字 2 时，它应该为数字 2 返回 1，为其余的数字返回 0。因此，由于我们有 10 个类，我们已经运行了每个时期(迭代)10 次。这里有一个嵌套的 for 循环。
def gradient_descent(X, y, theta, alpha, epochs):
m = len(X)
for i in range(0, epochs):
for j in range(0, 10):
theta = pd.DataFrame(theta)
h = hypothesis(theta.iloc[:,j], X)
for k in range(0, theta.shape[0]):
theta.iloc[k, j] -= (alpha/m) * np.sum((h-y.iloc[:, j])*X.iloc[:, k])
theta = pd.DataFrame(theta)
return theta, cost
7.初始化θ。记住，我们将为每个类实现逻辑回归。每堂课也会有一系列的θ。
我已经运行了 1500 个纪元了。我相信随着时代的增加，准确率会更高。
theta = np.zeros([df.shape[1]+1, y1.shape[1]])
theta = gradient_descent(X, y1, theta, 0.02, 1500)
8.使用更新后的θ，计算输出变量。
output = []
for i in range(0, 10):
theta1 = pd.DataFrame(theta)
h = hypothesis(theta1.iloc[:,i], X)
output.append(h)
output=pd.DataFrame(output)
9.将计算的输出与原始输出变量进行比较，以计算模型的准确性。
accuracy = 0
for col in range(0, 10):
for row in range(len(y1)):
if y1.iloc[row, col] == 1 and output.iloc[col, row] >= 0.5:
accuracy += 1
accuracy = accuracy/len(X)
准确率为 72%。我确信，更多时代的准确性会更好。因为花了太多时间，我没有重新运行算法。
如果你正在运行这个，请随意尝试更多的纪元，并在评论部分让我知道，你有多少准确性。
除了梯度下降法，你还可以使用内置的优化函数。
在这种方法中，使用优化函数来优化算法的θ。这是一个更快的方法。
用优化函数实现
1.我们将使用与之前相同的数据集。如果使用相同的笔记本，请使用不同的名称导入数据集:
xls = pd.ExcelFile('ex3d1.xlsx')
df = pd.read_excel(xls, 'X', header=None)
2.我们仍然需要为 df 中的偏差项添加一列全 1。
X = np.c_[np.ones((df.shape[0], 1)), df]
3.导入“y”的数据。
y = pd.read_excel(xls, 'y', header=None)
由于这是一个数据帧，只需将列 0 作为一个系列，并使其二维，以匹配 x 的维度。
y = y[0]
y = y[:, np.newaxis]
这里，“y”只有一列。10 节课 10 栏。每个专栏将处理一个类。例如，当我们将处理类 10 时，我们将把 10 保留在它的位置，并用零替换其余的值。下面是函数 y_change，它将接受 y 本身和一个类(比如 3)。然后，它会用 1 替换 3，用所有其他类替换 0。在后面的步骤中很快就会用到这个函数。
def y_change(y, cl):
y_pr=[]
for i in range(0, len(y)):
if y[i] == cl:
y_pr.append(1)
else:
y_pr.append(0)
return y_pr
数据准备完成。现在开发模型:
4.定义假设函数。这与前面的方法相同。
def hypothesis(X, theta):
z = np.dot(X, theta)
return 1/(1+np.exp(-(z)))
5.开发成本函数。这一个也和前面的方法一样:
def cost_function(theta, X, y):
m = X.shape[0]
y1 = hypothesis(X, theta)
return -(1/len(X)) * np.sum(y*np.log(y1) + (1-y)*np.log(1-y1))
6.定义渐变。这个不一样。该函数定义了如何更新θ。
def gradient(theta, X, y):
m = X.shape[0]
y1 = hypothesis(X, theta)
return (1/m) * np.dot(X.T, y1 - y)
7.现在，导入优化函数并初始化θ。我取零作为初始θ值。任何其他值应该也可以。
from scipy.optimize import minimize, fmin_tnc
theta = np.zeros((X.shape[1], 1))
8.让我们创建一个拟合函数，它将 X，y 和θ作为输入。它将使用一个优化函数并为我们输出优化后的θ。
它需要这三个参数:
I .需要最小化的功能，
二。待优化的参数，
三。用于优化的参数。
在本例中，成本函数应最小化，θ需要为此进行优化。输入和输出变量 X 和 y 是要使用的参数。
这个优化函数采用另一个参数，即梯度。但这是可选的。这里，我们有一个关于梯度的公式或函数。所以我们正在通过它。
def fit(X, y, theta):
opt_weigths = fmin_tnc(func=cost_function, x0=theta,
fprime=gradient, args=(X, y.flatten()))
return opt_weigths[0]
9.使用这种拟合方法找到优化的θ。我们必须分别优化每个类的θ。让我们开发一个函数，其中对于每个类，将使用步骤 3 中的 y_change 方法相应地修改“y”。
def find_param(X, y, theta):
y_uniq = list(set(y.flatten()))
theta_list = []
for i in y_uniq:
y_tr = pd.Series(y_change(y, i))
y_tr = y_tr[:, np.newaxis]
theta1 = fit(X, y, theta)
theta_list.append(theta1)
return theta_list
用这种方法找到最终的θ
theta_list = find_param(X, y, theta)
10.是时候预测产量了。我们还必须单独预测各个类别。
def predict(theta_list, x, y):
y_uniq = list(set(y.flatten()))
y_hat = [0]*len(y)
for i in range(0, len(y_uniq)):
y_tr = y_change(y, y_uniq[i])
y1 = hypothesis(X, theta_list[i])
for k in range(0, len(y)):
if y_tr[k] == 1 and y1[k] >= 0.5:
y_hat[k] = y_uniq[i]
return y_hat
使用上述预测方法，计算预测输出 y_hat:
y_hat = predict(theta_list, X, y)
11.计算准确度
accuracy=0
for i in range(0, len(y)):
if y_hat[i] == y.flatten()[i]:
accuracy += 1
print(accuracy/len(df)*100)
这个过程给出了 100%的准确率。现在。你可以自己决定，你想在你的项目中使用哪种逻辑回归方法。
在本文中，使用神经网络解决了同样的问题，展示了如何从头开始开发神经网络:
神经网络的详细说明和逐步实现
medium.com](https://medium.com/towards-artificial-intelligence/build-a-neural-network-from-scratch-in-python-f23848b5a7c6)
如果你有任何问题，请在评论区问我。查看 GitHub 页面获取数据集:
[## rashida 048/用 Python 进行机器学习
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/rashida048/Machine-Learning-With-Python/blob/master/ex3d1.xlsx)
这是梯度下降法代码的链接
[## rashida 048/用 Python 进行机器学习
permalink dissolve GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码，管理…
下面是优化函数方法 Github 链接的链接:
[## rashida 048/用 Python 进行机器学习
permalink dissolve GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码，管理…
github.com](https://github.com/rashida048/Machine-Learning-With-Python/blob/master/multiclass_classification_with_fmin_tnc.ipynb)
推荐阅读:
学习线性回归的概念，并使用 python 从头开始开发一个完整的线性回归算法
towardsdatascience.com](/basic-linear-regression-algorithm-in-python-for-beginners-c519a808b5f8) [## Python 中多元线性回归的逐步实现
学习用 Python 从头开始开发任意数量变量的多元线性回归。
towardsdatascience.com](/multivariate-linear-regression-in-python-step-by-step-128c2b127171) [## Python 中从头开始的多项式回归
学习用一些简单的 python 代码从头开始实现多项式回归
towardsdatascience.com](/polynomial-regression-from-scratch-in-python-1f34a3a5f373) [## Python 中从头开始的完整异常检测算法:分步指南
基于概率的异常检测算法
towardsdatascience.com](/a-complete-anomaly-detection-algorithm-from-scratch-in-python-step-by-step-guide-e1daf870336e) [## 置信区间的完整指南，以及 Python 中的示例
对统计学中一个非常流行的参数——置信区间及其计算的深入理解
towardsdatascience.com](/a-complete-guide-to-confidence-interval-and-examples-in-python-ff417c5cb593)
多类分类和信息瓶颈——以 Keras 为例
使用 Keras 对路透社数据集中的新闻进行分类，看看神经网络如何杀死你的数据。
多类 分类 是对两类以上样本的分类。将样本精确地分为两类，通俗地称为二元分类。
这篇文章将设计一个神经网络，使用 Python 库 Keras 将路透社 1986 年发布的路透社数据集中的新闻影片分类为 46 个互斥类。这个问题是一个典型的单标签、多类分类问题。
由absolute vision在 Unsplash 上拍摄的照片
信息瓶颈
神经网络由许多层组成。每一层都对数据执行某种转换，将输入映射到网络的输出。但是，需要注意的是，这些层不会生成任何额外的数据，它们只处理从前面的层接收到的数据。
比方说，如果一个层丢失了一些相关数据，那么所有后续层都无法访问这些信息。这些信息将永久丢失，并且无法恢复。丢弃该信息的层现在充当了瓶颈，抑制了模型的准确性和性能的提高，从而充当了信息瓶颈。
稍后我们将看到这一点。
路透社的数据集
路透社数据集是一组简短的新闻报道，分为 46 个互斥的话题。路透社在 1986 年发表了它。这个数据集被广泛用于文本分类。共有 46 个主题，其中一些主题比其他主题出现得多。但是，在训练集中，每个主题至少包含十个示例。
路透社数据集预装了 Keras，包含 8982 个训练样本和 2246 个测试样本。
加载数据
从 Keras 中预先打包的模块加载数据。我们将把数据限制在 10，000 个最频繁出现的单词。为此，我们将num_words=10000参数传递给load_data函数。
代码由 rakshitraj 托管在 GitHub 上
一些探索性数据分析
我们将在数据集上执行一些老式的 EDA。这样做可以让我们对数据的广度和范围有一个大致的了解。
代码由 rakshitraj 托管在 GitHub 上
解读一个故事
让我们继续解码一个故事。解码帮助我们获得数据的组织和编码的要点。
代码由 rakshitraj 托管在 GitHub 上
准备数据
我们不能向神经网络输入整数序列；因此，我们将对每个序列进行矢量化，并将其转换为张量。我们通过对每个序列进行一键编码来做到这一点。
我们的训练和测试数据中有 10，000 个独特的元素。对我们的输入数据进行矢量化将产生两个 2D 张量；形状的训练输入张量(8982，10000)和形状的测试输入张量(2246，10000)。
由 rakshitraj 托管在 GitHub 上的代码
这个问题的标签包括 46 个不同的类。标签用 1 到 46 范围内的整数表示。为了对标签进行矢量化，我们可以，
- 将标签转换为整数张量
- 对标签数据进行一次性编码
我们将对标签数据进行一键编码。这将给我们张量，它的第二轴有 46 维。这可以使用 Keras 中的to_categorical函数轻松完成。
为了更加清晰，我们将手动执行。
代码由 rakshitraj 托管在 GitHub 上
执行标签的一次性分类编码的另一种方法是使用内置函数，如上面的要点所示。为了清楚起见，这里又是:
from keras.utils.np_utils import to_categorical
Y_train = to_categorical(train_labels)
Y_test = to_categorical(test_labels)
构建神经网络
主题分类的问题(单标签多类分类 _)类似于文本字段的 _ 二元分类。这两个问题都遵循类似的数据处理和预处理方法。实现神经网络的教学方法保持不变。然而，有一个新的限制:类的数量从 2 个增加到 46 个。输出空间的维度要高得多。
因此，每一层都必须处理更多的数据，这就出现了真正的信息瓶颈。
信息瓶颈
给定一个多类分类问题，与二进制分类问题相比，我们需要对数据执行的处理量显著增加。
在密集层的堆栈中，就像我们所使用的，每一层只能访问前一层输出中的信息。如果一个层丢弃了相关信息，该信息对于所有后续层都是永久不可访问的。信息一旦丢失，就永远不能被后面的层恢复。在像多类分类这样的情况下，数据是有限且关键的，每一层都可能成为信息瓶颈。
如果一个层丢失了相关的信息，这可能是一个信息瓶颈。
这些层很容易成为我们网络性能的瓶颈。为了确保关键数据不会被丢弃，我们将使用具有更多隐藏单元的层，即更大的层。为了比较，我们在 IMDB 评论的情感分析的两类分类示例中，使用具有 16 个隐藏单元 *Dense(16)* 的层。在这种情况下，输出维度是 46，我们将使用 64 个隐藏单元的层，Dense(64)。
模型定义
我们将用两个全连接的 ReLU 激活层来定义我们的网络，每个层有 64 个隐藏单元。第三和最后一层将是尺寸为 46 的致密层。该层将使用一个 softmax 激活，并将输出一个 46 维矢量。每一维都是属于该类的输入的概率。
代码由 rakshitraj 托管在 GitHub 上
编译模型
对于我们的网络，我们将使用优化器 rmsprop、loss function、categorical_crossentropy，并将监控模型的accuracy (metrics)。
代码由 rakshitraj 托管在 GitHub 上
设置验证集
由 rakshitraj 托管在 GitHub 上的代码
训练我们的模型
最初，我们将在 512 个样本的小批量中为 20 个时期训练我们的模型。我们还将把我们的验证集传递给fit方法。
由 rakshitraj 托管在 GitHub 上的代码
调用fit方法返回一个History对象。这个对象包含一个成员history，它存储了关于训练过程的所有数据，包括随着时间的推移可观察到的或监控到的量的值。我们将保存该对象，因为它包含的信息将帮助我们确定更好地应用于训练步骤的微调。
在训练结束时，我们达到了 95%的训练准确率和 80.9%的验证准确率
既然我们已经训练了我们的网络，我们将观察存储在History对象中的性能指标。
调用fit方法返回一个History对象。这个对象有一个属性history，它是一个包含四个条目的字典:每个被监控的指标一个条目。
由 rakshitraj 托管在 GitHub 上的代码
history_dict包含以下值
- 培训损失
- 训练准确性
- 验证损失
- 验证准确性
在每个时期结束时。
让我们使用 Matplotlib 并排绘制训练和验证损失以及训练和验证准确性。
培训和验证损失
损失与时代
代码由 rakshitraj 托管在 GitHub 上
培训和验证准确性
模型与时代的准确性
代码由 rakshitraj 托管在 GitHub 上
过度拟合:损失和精度数据的趋势
我们观察到最小验证损失和最大验证准确度在大约 9-10 个时期达到。之后，我们观察到两个趋势:
- 验证损失增加，培训损失减少
- 验证准确性降低，培训准确性提高
这意味着该模型在对训练数据的情绪进行分类方面越来越好，但当它遇到新的、以前从未见过的数据时，会做出持续更差的预测，这是过度拟合的标志。在第 10 个时期之后，模型开始过于接近训练数据。
为了解决过度拟合的问题，我们将把历元的数量减少到 9。这些结果可能会因您的机器以及不同型号的随机重量分配的本质而异。
在我们的情况下，我们将在九个纪元后停止训练。
从头开始重新训练我们的模型
既然我们知道过多的时期导致我们的模型过度拟合，我们将限制时期的数量并从头重新训练我们的模型。
代码由 rakshitraj 托管在 GitHub 上
预测结果和评估
代码由 rakshitraj 托管在 GitHub 上
我们的方法产生了大约 80%的效率
如果这是一个平衡的数据集，使用简单的概率，标签的随机属性将导致 50%的准确性。但是由于这个数据集是不平衡的，随机分类器的准确性可能会更低。
随机分类器随机给样本分配标签。客观地说，你当地动物园的黑猩猩会用随机分类器来分类这些新闻短片。
让我们确定这个随机基线:
代码由 rakshitraj 托管在 GitHub 上
考虑到随机基线约为 19%，我们的模型以约 80%的准确度表现得相当好。
一个信息瓶颈模型
这次我们在模型中引入了一个信息瓶颈。我们的一个图层将会丢失数据，我们将会看到它对模型性能的影响，即其准确性的下降。
由 rakshitraj 托管在 GitHub 上的代码
存在瓶颈时，测试精度会下降 10%
结论
至此，您已经成功地将路透社数据集中的新闻短片按照各自的主题进行了分类。您还将看到隐藏单元数量不足的层如何通过杀死宝贵的数据来破坏模型的性能。
信息瓶颈的影响是显而易见的，因为预测准确性大大降低。
我建议你配合这篇文章。您可以使用类似的策略解决大多数多类分类问题。如果你解决了这个问题，试着修改网络及其层的设计和参数。这样做将帮助您更好地理解您所选择的模型的属性和架构。
我在每篇文章中都详细讨论了一个话题。在这一篇中，我们探索了信息瓶颈。对任何特定主题的详尽解释从来不在我的写作范围之内；然而，你会发现大量的快速旁白。
我假设读者不是机器学习领域的完全新手。我在这篇文章之前和之前的更多工作链接如下；
使用 Keras 根据情感对评论进行分类。
towardsdatascience.com](/binary-classification-of-imdb-movie-reviews-648342bc70dd) [## 解决 MNIST 图像分类问题
“你好，世界！”深度学习和 Keras
towardsdatascience.com](/solve-the-mnist-image-classification-problem-9a2865bcf52a)
想了解更多，请查看我发誓的书——Francois Chollet 的《用 Python 进行深度学习》。
感谢阅读！
使用 K 近邻的多类分类
在本文中，了解什么是多类分类以及它是如何工作的
马库斯·斯皮斯克在 Unsplash 上的照片
简介:
分类是一个经典的机器学习应用。分类基本上将你的产出分为两类，也就是说，你的产出可以是两种情况之一。例如，一家银行想知道客户是否能够支付他/她的每月投资？我们可以使用机器学习算法来确定这个问题的输出，这个输出要么是，要么不是(两个类)。但是，如果你想对有两个以上类别的东西进行分类，并且不是一个简单的是/否问题，该怎么办呢？
这就是多类分类的用武之地。多类分类可以定义为将实例分类为三个或更多类中的一个。在本文中，我们将使用 K 个最近邻进行多类分类。KNN 是一个超级简单的算法，它假设相似的事物彼此非常接近。因此，如果一个数据点靠近另一个数据点，它假设它们都属于相似的类。要更深入地了解 KNN 算法，我建议你去看看这篇文章:
k-最近邻(KNN)算法是一个简单，易于实现的监督机器学习算法，可以…
towardsdatascience.com](/machine-learning-basics-with-the-k-nearest-neighbors-algorithm-6a6e71d01761)
现在，我们已经完成了所有的基础工作，让我们开始一些实现工作。我们将使用多个 python 库，如 pandas(读取我们的数据集)、Sklearn(训练我们的数据集并实现我们的模型)和 Seaborn 和 Matplotlib(可视化我们的数据)。如果您还没有安装这个库，您可以在您的 PC/笔记本电脑上使用 pip 或 Anaconda 安装它们。或者另一种方式，我个人建议，使用 google colab 在线执行实验，并预装所有的库。我们将使用的数据集称为鸢尾花数据集，它基本上有 4 个特征，共 150 个数据点，分为 3 个不同的物种，即每个物种 50 朵花。该数据集可从以下链接下载:
用于多类分类的鸢尾花数据集。
www.kaggle.com](https://www.kaggle.com/arshid/iris-flower-dataset)
现在，当我们开始编写代码时，要做的第一步是导入代码中的所有库。
**from** sklearn **import** preprocessing**from** sklearn.model_selection **import** train_test_split**from** sklearn.neighbors **import** KNeighborsClassifier**import** matplotlib.pyplot **as** plt**import** seaborn **as** sns**import** pandas **as** pd
一旦导入了库，下一步就是读取数据。我们将使用熊猫图书馆来实现这一功能。在阅读时，我们还会检查数据中是否有空值以及不同物种的数量。(应该是 3，因为我们的数据集有 3 个物种)。我们还将为所有三个物种类别分配一个特定的数字，0、1 和 2。
df = pd.read_csv(‘IRIS.csv’)
df.head()
按作者分类的图像(原始数据集的前 5 列)
df[‘species’].unique()
输出:数组(['Iris-setosa '，' Iris-versicolor '，' Iris-virginica']，dtype=object)
df.isnull().values.any()
输出:假
df[‘species’] = df[‘species’].map({‘Iris-setosa’ :0, ‘Iris-versicolor’ :1, ‘Iris-virginica’ :2}).astype(int) #mapping numbersdf.head()
按作者分类的图像(带有输出映射数字的新表格)
一旦我们完成了库和 CSV 文件的导入，下一步就是探索性数据分析(EDA)。EDA 对于任何问题都是必要的，因为它帮助我们可视化数据，并通过查看数据而不是执行任何算法来推断一些结论。我们使用库 seaborn 执行所有特征之间的关联，并使用相同的库绘制所有数据集的散点图。
plt.close();sns.set_style(“whitegrid”);sns.pairplot(df, hue=”species”, height=3);plt.show()
输出:
按作者分类的图像(所有 4 个特征之间的相关性)
sns.set_style(“whitegrid”);sns.FacetGrid(df, hue=’species’, size=5) \.map(plt.scatter, “sepal_length”, “sepal_width”) \.add_legend();plt.show()
输出:
作者图片
EDA 的推论:
- 虽然 Setosa 很容易识别，但 Virnica 和 Versicolor 有一些重叠。
- 长度和宽度是识别各种花型最重要的特征。
在 EDA 之后，在数据集上训练我们的模型之前，剩下要做的最后一件事是归一化。标准化基本上是将不同特征的所有值放在同一尺度上。由于不同的特征具有不同的尺度，归一化有助于我们和模型更有效地优化其参数。我们将所有输入标准化，范围从 0 到 1。这里，X 是我们的输入(因此去掉了分类的物种)，Y 是我们的输出(3 个类)。
x_data = df.drop([‘species’],axis=1)y_data = df[‘species’]MinMaxScaler = preprocessing.MinMaxScaler()X_data_minmax = MinMaxScaler.fit_transform(x_data)data = pd.DataFrame(X_data_minmax,columns=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'])df.head()
按作者分类的图像(标准化数据集)
最后，我们已经达到了训练数据集的程度。我们使用 sci-kit learn 内置的 KNN 算法。我们将输入输出数据分为训练数据和测试数据，在训练数据上训练模型，在测试模型上测试模型的准确性。对于我们的培训和测试数据，我们选择 80%–20%的分割。
X_train, X_test, y_train, y_test = train_test_split(data, y_data,test_size=0.2, random_state = 1)knn_clf=KNeighborsClassifier()knn_clf.fit(X_train,y_train)ypred=knn_clf.predict(X_test) #These are the predicted output values
输出:
KNeighborsClassifier(algorithm = ' auto '，leaf_size=30，metric='minkowski '，metric_params=None，n_jobs=None，n_neighbors=5，p=2，weights='uniform ')
在这里，我们看到分类器选择 5 作为最近邻的最佳数量，以对数据进行最佳分类。现在我们已经建立了模型，我们的最后一步是可视化的结果。我们计算了混淆矩阵、精确召回参数和模型的整体准确度。
from sklearn.metrics import classification_report, confusion_matrix, accuracy_scoreresult = confusion_matrix(y_test, ypred)print(“Confusion Matrix:”)print(result)result1 = classification_report(y_test, ypred)print(“Classification Report:”,)print (result1)result2 = accuracy_score(y_test,ypred)print(“Accuracy:”,result2)
输出:
作者提供的图片(我们模型的结果)
总结/结论:
我们成功地实现了虹膜数据集的 KNN 算法。我们通过 EDA 找出了最具影响力的特征，并对我们的数据集进行了标准化，以提高准确性。我们用我们的算法得到了 96.67%的准确率，并且得到了混淆矩阵和分类报告。从分类报告和混淆矩阵中我们可以看到，它把云芝误认为是海滨锦葵。
这就是如何使用 KNN 算法进行多类分类。希望你今天学到了新的有意义的东西。
谢谢你。
用支持向量机(SVM)、对偶问题和核函数进行多类分类
最后，通过 scikit-learn 了解 Python 中 SVM +实现背后的概念
来源: unsplash (Bekky Bekks)
支持向量机(SVM) 不是新的，但仍然是一个强大的分类工具，因为它们不会过度拟合，但在许多情况下表现良好。如果你只对某个话题感兴趣，就滚动话题。这些是按时间顺序排列的主题:
- 支持向量机背后的 数学概念 是什么？
- 什么是内核，什么是 内核函数 ？
- 什么是 内核绝招 ？
- 什么是 SVM 的 对偶问题 ？
- 多类分类 是如何发生的？
- 通过 Python 和 scikit-learn 实现
如果你只对如何使用 Python 和 scikit-learn 实现感兴趣，向下滚动到最后！
让我们开始吧。
目标是在 n 维空间中找到一个超平面，该超平面将数据点分成它们的潜在类别。超平面应该定位在距离数据点最远的位置。到超平面距离最小的数据点称为支持向量。由于它们的位置接近，它们对超平面的确切位置的影响比其他数据点大。在下图中，支持向量是位于直线上的 3 个点(2 个蓝色，1 个绿色)。
来源:维基百科 (Larhmam)
支持向量机也被称为内核化 SVM* ，因为它们的内核将输入数据空间转换到一个更高维的空间。*
输入空间 X 由 X 和 X’组成。
代表内核函数将输入空间变成一个更高维的空间，这样并不是每个数据点都被显式映射。
内核函数也可以写成
如何定义该函数以及该函数如何用于铺设超平面取决于数据:
内核函数
在 scikit-learn 中也可用的最流行的内核函数是线性、多项式、径向基函数和 sigmoid 。更多功能请访问数据文件夹。在下面你可以看到这四个内核函数的样子:
- 线性函数
2。多项式函数
3。径向基函数(RBF)
4。Sigmoid 函数
内核技巧
内核函数是做什么的？
它取两个数据点 x_n 和 x_m，并计算它们的距离分数。数据点越近，得分越高，反之亦然。使用该分数有助于将数据点转换为更高维的映射，这减少了计算工作量和时间，并且对于大量数据特别有用。它避免了更复杂转换的需要。
这就是为什么这一步通常被称为内核技巧的原因。
从下图可以看出，数据点的映射是使用核函数(φ(( a ，b)=(a， b ， a 2 + b 2))从 2D 转到三维空间的。当变成 3D 空间时，先前居中的红点现在也位于垂直下方。不明显可分的数据点现在可以通过使用核来更好地划分。
来源:维基百科(、纪)
此外，不同的核可以帮助通过数据点的云铺设不同形状的超平面。显然，由于线性超平面对不同形状的适应性有限，它们的极限很快就被超过了。基于这一事实，不同的核函数被开发出来。
请继续关注 Marius Hucker 的新文章。如果您还没有注册，您将创建一个中型帐户…
medium.com](https://medium.com/subscribe/@hucker.marius)*
为了更好地理解不同超平面的分离，不同种类的核函数在下图中被可视化。
不同内核函数的可视化。
SVM 背后的数学概念
下面的公式提出了由支持向量机解决的优化问题。下面将进一步解释(scikit-learn，未注明日期):
目标是通过最大化从支持向量到超平面的裕度，同时最小化该项，来正确分类尽可能多的数据点
换句话说，目标也可以解释为找到大多数样本被正确预测的最优 w 和 b 。
大多数情况下，并不是所有的数据点都能完美分配，因此到正确边距的距离由下式表示
**法向量创建一条穿过坐标原点的线。超平面在一定距离处正交切割这条直线
从原点出发。
对于理想情况(毕晓普，第 325 页起。, 2006)
会≥ 1，然后被完美预测。现在有了到它们理想位置的距离的数据点，让我们修正≥ 1 到的理想情况
同时在最小化公式中引入了惩罚项。c 充当正则化参数并控制关于有多少数据点被错误地分配了总距离
对偶问题
优化任务可以被称为对偶问题，试图最小化参数，同时最大化余量。为了解决对偶问题，利用拉格朗日乘子(α≥0)。
这导致了一个拉格朗日函数(毕晓普，第 325 页 ff。, 2006):
利用以下两个条件(毕晓普，第 325 页起。, 2006):
w 和 b 可以从 L(w，b，a) 中消去。这导致下面的拉格朗日函数最大化为(Bishop，p.325 ff。, 2006):
解决优化问题时，可以使用(Bishop，第 325 页及以下)对新的数据点进行分类。, 2006):
对于核函数 k(x_n，x_m) 可以填入之前解释的核函数(sigmoid、线性、多项式、rbf)。
就这样！如果你能理解数学，你现在就能理解支持向量机背后的原理。很容易理解如何将一群数据点分成两类，但是对于多个类是如何做到的呢？让我们看看这是如何工作的。
想看更多这样的故事？
开始
基于支持向量机的多类分类
在其最简单的类型中，SVM 应用于二元分类，将数据点分为 1 或 0。对于多类分类，利用相同的原理。多类问题被分解为多个二元分类情况，也称为一对一。在 scikit 中，一对一学习不是默认的，需要显式选择(如下面的代码所示)。一对多设置为默认。它基本上把 x 类和 rest 中的数据点进行了划分。连续地，某一类与所有其他类相区别。
**一对一多类分类所需的分类器数量可通过以下公式得到(n 为类的数量):
在一对一方法中，每个分类器分离两个不同类别的点，并且包括所有一对一分类器导致多类别分类器。
把手举起来。如何使用 scikit-learn 在 Python 中应用它
您可能已经对 iris 数据集感到厌烦了，但这是演示它的最简单的方式，所以让我们来看看一些代码。你也可以在 scikit-learn 下找到部分代码。
***#Importing the necessary packages and libaries**from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn import svm, datasets
import matplotlib.pyplot as plt
import numpy as np*
让我们将 iris 数据集作为 iris 加载，并存储目标和特征变量:
*iris = datasets.load_iris()**#Store variables as target y and the first two features as X (sepal length and sepal width of the iris flowers)**
X = iris.data[:, :2]
y = iris.target*
现在，让我们在训练和测试集中拆分数据集，以进行以下训练和预测:
*X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, random_state = 0)*
在这一步，我们来看看不同的内核函数。对于所有分类器，惩罚项 C 被设置为 1。对于多类分类，指定一对一类型，如在 decision_function_shape='ovo '中可以看到的。对于多项式函数，选择 3 次，这对于其他核函数是不必要的。
所有其他参数都设置为默认值。在这里你可以阅读更多关于 scikit-learn 的 SVC 功能。
*linear = svm.SVC(kernel='linear', C=1, decision_function_shape='ovo').fit(X_train, y_train)rbf = svm.SVC(kernel='rbf', gamma=1, C=1, decision_function_shape='ovo').fit(X_train, y_train)poly = svm.SVC(kernel='poly', degree=3, C=1, decision_function_shape='ovo').fit(X_train, y_train)sig = svm.SVC(kernel='sigmoid', C=1, decision_function_shape='ovo').fit(X_train, y_train)*
现在让我们指定网格，我们将在其中绘制结果。
***#stepsize in the mesh, it alters the accuracy of the plotprint
#to better understand it, just play with the value, change it and print it**
h = .01**#create the mesh**
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),np.arange(y_min, y_max, h))**# create the title that will be shown on the plot** titles = ['Linear kernel','RBF kernel','Polynomial kernel','Sigmoid kernel']*
现在我们将使用一个 for 循环来绘制所有 4 个内核函数:
*for i, clf in enumerate((linear, rbf, poly, sig)):
**#defines how many plots: 2 rows, 2columns=> leading to 4 plots**
plt.subplot(2, 2, i + 1) **#i+1 is the index
#space between plots**
plt.subplots_adjust(wspace=0.4, hspace=0.4) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) **# Put the result into a color plot**
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.PuBuGn, alpha=0.7) **# Plot also the training points**
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.PuBuGn, edgecolors='grey') plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.xticks(())
plt.yticks(())
plt.title(titles[i]) plt.show()*
正如您可能已经认识到的，结果就是文章中上面的图片:
下一步，我们使用 4 个不同的核函数对测试数据集进行预测:
*linear_pred = linear.predict(X_test)
poly_pred = poly.predict(X_test)
rbf_pred = rbf.predict(X_test)
sig_pred = sig.predict(X_test)*
为了了解它们的表现如何，我们使用了一个性能指标——准确性。
***# retrieve the accuracy and print it for all 4 kernel functions**
accuracy_lin = linear.score(X_test, y_test)
accuracy_poly = poly.score(X_test, y_test)
accuracy_rbf = rbf.score(X_test, y_test)
accuracy_sig = sig.score(X_test, y_test)print(“Accuracy Linear Kernel:”, accuracy_lin)
print(“Accuracy Polynomial Kernel:”, accuracy_poly)
print(“Accuracy Radial Basis Kernel:”, accuracy_rbf)
print(“Accuracy Sigmoid Kernel:”, accuracy_sig*
正如精度所揭示的，根据数据的不同，一些核函数比其他的更有用。显然，更多的数据也有助于改善结果(虹膜数据的大小并不大，只有 50 个样本:-)。
让我们进入最后一步——打印 4 个内核函数的混淆矩阵，以了解预测的方式和内容:
***# creating a confusion matrix** cm_lin = confusion_matrix(y_test, linear_pred)
cm_poly = confusion_matrix(y_test, poly_pred)
cm_rbf = confusion_matrix(y_test, rbf_pred)
cm_sig = confusion_matrix(y_test, sig_pred)print(cm_lin)
print(cm_poly)
print(cm_rbf)
print(cm_sig)*
4 个混淆矩阵
就是这样。我希望它有助于更好地理解支持向量机，数学概念，核心技巧和主题多类分类通过 SVM。
感谢阅读，感谢反馈！
请继续关注 Marius Hucker 的新文章。如果您还没有注册，您将创建一个中型帐户…
medium.com](https://medium.com/subscribe/@hucker.marius)*
来源
- 毕晓普，2006，模式识别与机器学习，第 325 页起。
- Vapnik 和 Cortes，1995 年，支持向量网络
- Scikit-learn，支持向量机
- Scikit-learn，在虹膜数据集中绘制不同的 SVM 分类器
- Dataflair，内核函数—SVM 内核简介&示例
整个代码
***#Importing the necessary packages and libaries**from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn import svm, datasets
import matplotlib.pyplot as plt
import numpy as npiris = datasets.load_iris()**#Store variables as target y and the first two features as X (sepal length and sepal width of the iris flowers)**
X = iris.data[:, :2]
y = iris.targetlinear = svm.SVC(kernel='linear', C=1, decision_function_shape='ovo').fit(X_train, y_train)rbf = svm.SVC(kernel='rbf', gamma=1, C=1, decision_function_shape='ovo').fit(X_train, y_train)poly = svm.SVC(kernel='poly', degree=3, C=1, decision_function_shape='ovo').fit(X_train, y_train)sig = svm.SVC(kernel='sigmoid', C=1, decision_function_shape='ovo').fit(X_train, y_train)**#stepsize in the mesh, it alters the accuracy of the plotprint
#to better understand it, just play with the value, change it and print it**
h = .01**#create the mesh**
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),np.arange(y_min, y_max, h))**# create the title that will be shown on the plot** titles = ['Linear kernel','RBF kernel','Polynomial kernel','Sigmoid kernel']for i, clf in enumerate((linear, rbf, poly, sig)):
**#defines how many plots: 2 rows, 2columns=> leading to 4 plots**
plt.subplot(2, 2, i + 1) **#i+1 is the index
#space between plots**
plt.subplots_adjust(wspace=0.4, hspace=0.4)Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])**# Put the result into a color plot**
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.PuBuGn, alpha=0.7)**# Plot also the training points**
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.PuBuGn, edgecolors='grey')plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.xticks(())
plt.yticks(())
plt.title(titles[i])plt.show()linear_pred = linear.predict(X_test)
poly_pred = poly.predict(X_test)
rbf_pred = rbf.predict(X_test)
sig_pred = sig.predict(X_test)**# retrieve the accuracy and print it for all 4 kernel functions**
accuracy_lin = linear.score(X_test, y_test)
accuracy_poly = poly.score(X_test, y_test)
accuracy_rbf = rbf.score(X_test, y_test)
accuracy_sig = sig.score(X_test, y_test)print(“Accuracy Linear Kernel:”, accuracy_lin)
print(“Accuracy Polynomial Kernel:”, accuracy_poly)
print(“Accuracy Radial Basis Kernel:”, accuracy_rbf)
print(“Accuracy Sigmoid Kernel:”, accuracy_sig**# creating a confusion matrix** cm_lin = confusion_matrix(y_test, linear_pred)
cm_poly = confusion_matrix(y_test, poly_pred)
cm_rbf = confusion_matrix(y_test, rbf_pred)
cm_sig = confusion_matrix(y_test, sig_pred)print(cm_lin)
print(cm_poly)
print(cm_rbf)
print(cm_sig)*
Pytorch 中使用 LSTM 的多类文本分类
基于客户评论预测项目评级
作者图片
人类的语言充满了歧义，很多时候，同一个短语可以根据上下文有多种解释，甚至会让人感到困惑。这些挑战使得自然语言处理成为一个有趣但难以解决的问题。然而，在过去的几年中，我们已经看到了 NLP 的许多进步，探索所使用的各种技术是非常令人着迷的。本文旨在使用 Pytorch 涵盖深度学习中的一种技术:长短期记忆(LSTM)模型。
这里有一个笔记本的链接，其中包含了我在本文中使用的所有代码:https://jovian . ml/aakanksha-ns/lstm-multi class-text-classification
如果您是 NLP 新手，或者需要深入了解预处理和单词嵌入，可以阅读下面的文章:
使用简单的 Python 库
towardsdatascience.com](/getting-started-with-natural-language-processing-nlp-2c482420cc05)
rnn 和 LSTMs 简介:
使语言模型不同于传统神经网络的是它们对上下文的依赖性。传统的前馈网络假设输入彼此独立。对于 NLP，我们需要一种机制，能够使用来自先前输入的顺序信息来确定当前输出。递归神经网络(RNNs)通过拥有循环来解决这个问题，允许信息在网络中持续存在。
展开的递归神经网络(图片由作者提供)
然而，传统的 rnn 有爆炸和消失梯度的问题，并且不擅长处理长序列，因为它们遭受短期记忆。
长短期记忆网络(LSTM)是一种特殊的 RNN，能够学习长期依赖关系。它们通过维持一种称为“细胞状态”的内部记忆状态来实现这一点，并通过称为“门”的调节器来控制每个 LSTM 单元内部的信息流。这里有一个很好的解释 LSTMs 细节的来源:
[## 了解 LSTM 网络
2015 年 8 月 27 日发布人类不是每秒钟都从零开始思考。当你读这篇文章时，你…
colah.github.io](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) 
LSTM 细胞的结构。(来源:瓦萨莫普洛斯、萨瓦斯&贝特尔斯、科恩&阿尔穆德韦、卡门。(2018).设计基于神经网络的表面码解码器。)
Pytorch 的基本 LSTM
在我们进入主要问题之前，让我们看看 Pytorch 中使用随机输入的 LSTM 的基本结构。在进入复杂的输入之前，这是一个有用的步骤，因为它帮助我们学习如何更好地调试模型，检查维度是否增加，并确保我们的模型按预期工作。
尽管我们将处理文本，但由于我们的模型只能处理数字，我们将输入转换成数字序列，其中每个数字代表一个特定的单词(下一节将详细介绍)。
我们首先将输入(3×8)通过一个嵌入层，因为单词嵌入在捕捉上下文方面更好，并且在空间上比一键向量表示更有效。
在 Pytorch 中，我们可以使用nn.Embedding模块来创建这一层，它将词汇大小和期望的单词向量长度作为输入。您可以选择提供填充索引，以指示嵌入矩阵中填充元素的索引。
在下面的例子中，我们的词汇表由 100 个单词组成，所以我们对嵌入层的输入只能是从 0 到 100，它返回给我们一个 100x7 的嵌入矩阵，第 0 个索引代表我们的填充元素。
我们将嵌入层的输出传递到 LSTM 层(使用nn.LSTM创建)，它将单词向量长度、隐藏状态向量长度和层数作为输入。此外，如果我们的输入形状中的第一个元素具有批量大小，我们可以指定batch_first = True
LSTM 层输出三样东西:
- 序列中所有隐藏状态的合并输出
- 最后一个 LSTM 单元的隐藏状态—最终输出
- 细胞状态
我们可以验证在通过所有层之后，我们的输出具有预期的尺寸:
3x8 ->嵌入-> 3x8x7 -> LSTM(隐藏大小=3)-> 3x3
多类文本分类—根据评论预测评级
现在让我们来看看 LSTMs 的一个应用。
问题陈述:给定一个商品的评论，预测评分(取 1 到 5 的整数值，1 为最差，5 为最好)
数据集:我使用了以下来自 Kaggle 的数据集:
23，000 条客户评论和评级
www.kaggle.com](https://www.kaggle.com/nicapotato/womens-ecommerce-clothing-reviews)
公制的
对于大多数分类问题，我们通常以准确性作为衡量标准，然而，评级是有序的。如果实际值为 5，但模型预测值为 4，则不认为它与预测值 1 一样差。因此，我们选择RMSE——均方根误差作为我们的北极星度量标准，而不是精确。此外，评级预测是一个相当困难的问题，即使对人类来说也是如此，所以预测误差不超过 1 分就已经很不错了。
预处理
如前所述，我们需要将文本转换成数字形式，作为输入提供给模型。在删除标点符号、特殊字符和小写文本后，我使用了spacy进行标记化:
我们统计每个单词在语料库中出现的次数，并去掉不经常出现的单词:
我们丢了 6000 字左右！这是意料之中的，因为我们的语料库很小，不到 25k 条评论，出现重复单词的机会很小。
然后，我们创建一个词汇索引映射，并使用该映射对我们的评论文本进行编码。我选择任何评论的最大长度为 70 个字，因为评论的平均长度约为 60 个字。
Pytorch 数据集
数据集非常简单，因为我们已经将编码存储在输入数据帧中。我们还输出每种情况下输入序列的长度，因为我们可以有接受可变长度序列的 LSTMs。
Pytorch 训练循环
训练循环相当标准。我用过亚当优化器和交叉熵损失。
LSTM 模型
我在模型中使用了三种变体:
- 固定输入大小的 LSTM:
这与我们之前看到的基本 LSTM 的结构非常相似，只是增加了一个漏失层来防止过度拟合。由于我们有一个分类问题，我们有一个最终的线性层有 5 个输出。这种实现实际上在分类 LSTMs 中工作得最好，精确度约为 64%,均方根误差仅为 0.817
2。可变输入尺寸的 LSTM:
我们可以稍微修改一下我们的模型，让它接受可变长度的输入。这最终增加了训练时间，因为pack_padded_sequence函数调用返回一批填充的可变长度序列。
3。具有固定输入大小和固定预训练手套词向量的 LSTM:
代替训练我们自己的单词嵌入，我们可以使用预先训练的手套单词向量，其已经在大规模语料库上被训练并且可能具有更好的上下文捕获。然而对于我们的问题来说，这似乎帮助不大。
使用回归而不是分类来预测评级
由于评级是有顺序的，并且在许多情况下，3.6 的预测可能比四舍五入到 4 更好，因此将此作为回归问题进行探讨是有帮助的。不足为奇的是，这种方法给了我们最低的误差，仅仅是0.799，因为我们不再只有整数预测了。
我们的模型的唯一变化是，最终层没有 5 个输出，而是只有一个。训练循环也有点变化，我们使用MSE损失，我们不再需要使用argmax来获得最终预测。
结论:
理论上 LSTM 似乎参与其中，但是它的 Pytorch 实现非常简单。此外，在研究任何问题时，选择正确的指标非常重要，在我们的案例中，如果我们追求准确性，模型似乎做得非常糟糕，但 RMSE 显示它相差不到 1 个评分点，这与人类的表现相当！
参考文献:
- https://www . usfca . edu/data-institute/certificates/deep-learning-part-one
- 【https://colah.github.io/posts/2015-08-Understanding-LSTMs/
- http://web.stanford.edu/class/cs224n/
多重共线性
厨师多了烧坏汤
M 多重共线性是一个很容易出现在任何现实生活数据科学问题中的问题。在这篇短文中，我想说明什么是多重共线性，为什么它是一个问题，如何测量它以及一旦发现如何处理它。
是什么？
当一个或多个自变量彼此高度相关时，存在多重共线性。这当然违反了多元线性回归(MLR)问题中必须满足的假设之一。影响回归系数标准误差的因素之一是 MLR 问题中自变量之间的相互依赖性。
钻石数据集
假设我们有一个数据集来预测圆形切割钻石的价格。目标变量是价格。预测因素包括克拉、切割、颜色、净度、x、y 和 z。变量 x、y 和 z 代表钻石直径的内部尺寸。
钻石数据集的前 10 条记录。
有序分类变量 cut、color 和 clarity 经过标签编码，因此可用于线性回归模型。相关矩阵允许我们看到数据集中每个变量之间的 皮尔逊相关系数 。有趣的是，我们能够看到在 克拉 和 x ， y 和 z 之间存在着很强的线性关系。该数据集高度怀疑这些变量之间存在多重共线性。
钻石数据集的相关矩阵。
为什么是问题？
当变量之间的相关性变得更高时，这就产生了问题。随着共线性程度的增加，回归系数的大小和波动性也会增加。这导致更高的样品间可变性。这使得所讨论的变量作为回归方程中的预测值是不可靠的。所讨论的系数的置信区间变得非常大，这使得拒绝任何无效假设几乎是不可能的。由于研究问题是在交替假设中，我们得到它的机会受到回归系数缺乏统计意义的阻碍。
我们如何测试它？
如果怀疑存在多重共线性，可以使用方差膨胀因子(VIF)进行检查。有一会儿，因变量被从图片中删除。每个独立变量相对于所有其他独立变量进行回归。得到的 R 值用于数学上表示 VIF，如下式所示:
【VIF = 1/(1-R)
这意味着，当变量真正相互独立时，R 将非常小，方程趋向于 1。VIF 为 1 表示完全独立于任何其他变量。这是多元回归模型中的假设之一。介于 5 和 10 之间的 VIF 表示共线性非常高。这分别对应于 0.8 和 0.9 的 R 值。一般惯例规定，任何得分大于 10 的都必须排除在外。越接近 1，预测建模的场景越理想。
在 python 中，我们只差几个模块就能轻松评估这一点。考虑到钻石数据集，我们有一个多元线性回归问题，有 7 个自变量 和 1 个因变量 。我们对每个自变量进行相互回归，并确定一个 VIF 分数 。我们使用d 矩阵功能 创建设计矩阵。
为了便于可视化，我将 VIF 放在一个 dataframe 对象中。
如此高的 VIF 分数证实了这种怀疑！变量 x、y 和 z 与克拉高度相关。在这种情况下，这些变量从 MLR 模型中删除。但是，我们可以通过多种方式来处理多重共线性。
我们如何对待它？
最终，必须进行某种形式的降维来解决多重共线性问题。
- 有问题的变量可以从回归模型中删除。在上面的示例中，删除 x、y 和 z 是一个显而易见的选择，因为 VIF 值远高于 10，表明高度多重共线性。模型的最终性能具有 97.7%的 R 值。在较弱的模型中，即使 VIF 较低，也可能发生多重共线性。因此，重要的是要注意，没有硬性规定。除了统计数据之外，领域知识使得选择要消除的变量变得更加容易。选择可能不像示例中的数据那样明显。
- 另一种可以考虑的方法是使用其他回归方法，如偏最小二乘法(PLS ),因为这不会在多重共线性面前崩溃。如果能够报告关于原始变量的发现很重要，这可能是一个好的选择。
- 最后，您可以考虑主成分分析(PCA ),它将数据投影到新的成分中。作为警告，如果你的任务是深入解释变量如何影响目标，这可能不是最好的选择。
如您所见，多重共线性不一定是问题。一旦确定，你就有能力去管理它并控制它。
本文中的数据基于一个 github 仓库。
请在链接的上与我连线！
多重共线性对您的数据科学项目的影响超乎您的想象
来源: Unsplash
以下是识别和预防的方法
多重共线性很可能在要检查的事物的心理列表中处于很低的位置，如果它确实在列表中的话。然而，这种情况几乎总是出现在现实生活的数据集中，知道如何解决它很重要。
顾名思义，多重共线性是指两个(或多个)要素相互关联，或“共线”。这在真实数据集中经常发生，因为一个测量(例如家庭收入)可能与另一个测量(例如学校表现)相关。您可能没有意识到，许多算法和分析方法都依赖于没有多重共线性的假设。
让我们以这个数据集为例，它试图在给定各种因素的情况下预测学生的录取机会。
我们想达到一个静态的效果，比如“做研究能让你的录取几率增加 x 个百分点”或者“托福每增加一分，录取几率增加 y 个百分点”。第一个想法是训练线性回归模型并解释系数。
多元回归模型的平均绝对误差约为 4.5%，这是相当准确的。这些系数分析起来很有趣，我们可以做出这样的陈述:“GRE 上的每一分都会增加你 0.2%的录取机会，而 CGPA 上的每一分都会增加 11.4%的机会。”
由作者创建。
让我们看一下相关性矩阵，以确定哪些特征是相互关联的。通常，该数据集充满了高度相关的要素，但 CGPA 通常与其他要素高度相关。
由作者创建。
由于托福成绩与 GRE 成绩高度相关，所以我们去掉这个特征，重新训练一个线性回归模型。(也许)令人惊讶的是，平均绝对误差减少到 4.3%。系数的变化也很有趣——值得注意的是，大学排名的重要性下降了近一半，研究的重要性增加了一倍，等等。
由作者创建。
我们可以从中得出以下结论:
- 托福成绩，像任何其他特征一样，可以被认为有两个组成部分:信息和噪音。
- 它的信息成分已经在其他变量中表现出来了(也许在 GRE 考试中表现好需要在托福考试中表现好的技能，等等。)，所以没有提供任何新的信息。
- 它有足够的噪声，以至于为了最小的信息增益而保留该特征不值得将噪声量引入到模型中。
换句话说，托福成绩与许多其他特征是共线的。在基本层面上，模型的性能受到了损害，但此外，对线性模型的更复杂的分析(这可能非常有见地)需要进行调整，如系数的解释。
回归模型的系数是什么意思，值得探讨。例如，如果 GRE 分数的系数是 0.2%，这意味着保持所有其他变量不变，GRE 分数增加一个单位就意味着录取率增加 0.2%。然而，如果我们包括托福成绩(和其他高度相关的特征)，我们不能假设这些变量将保持不变。
因此，系数变得杂乱无章，完全无法解释，因为有大量的信息重叠。当这种情况出现时，建模能力也会受到限制。因为有如此多的重叠，一切都被放大了——如果一个部分有错误，它很可能通过重叠传播到其他几个部分。
通常，记住算法或技术是否能很好地处理多重共线性是不切实际的，但通常情况下，任何将要素视为“相同”(对要素关系做出假设)或不测量信息内容的模型都容易受到多重共线性的影响。
这是什么意思？
以决策树为例，它不容易受到多重共线性的影响，因为它明确地测量信息内容(与熵相反)，并且不对特征之间的关系进行其他假设或测量。如果 A 列和 B 列相互关联，决策树将简单地选择一个并丢弃另一个(或者将其放在很低的位置)。在这种情况下，要素按其信息内容来考虑。
另一方面，K-最近邻是受多重共线性影响的，因为它假设每个点可以在多维空间中表示为某个坐标(例如，在具有四维的x训练集上的(3, 2.5, 6.7, 9.8))。它不测量信息内容，并且对特征一视同仁。因此，可以想象两个高度相关的特征之间的数据点会沿着一条线聚集在一起，这将如何干扰跨维距离。
主成分分析是一种无监督的方法，但我们仍然可以沿着这些标准来评价它！PCA 的目标是显式保留缩减数据集的方差或结构(信息)，这就是为什么它不仅通常不受多重共线性的影响，而且通常用于减少数据集中的多重共线性。
最有效的算法求解方法依赖于矩阵数学和线性代数系统——本质上是高维空间的表示，很容易被多重共线性干扰。
常见的技术，如重码编码(虚拟变量)，其中分类变量表示为 0 和 1，也可能是有害的，因为它们形成了完美的线性关系。假设我们有三个二进制列 A、B 和 C，表示一行是否属于其中一个类别。这些列的总和必须加到 1，因此建立了完美的线性关系A+B+C=1。
如何识别多重共线性？
- 使用回归模型上的 VIF(方差膨胀因子)得分来识别数据集中是否存在多重共线性。
- 如果标准误差太高，这可能表明由于信息重叠，一个误差正在重复传播。
- 添加或删除新功能时参数的较大变化表明存在大量重复信息。
- 创建相关矩阵。值始终高于 0.4 的要素表示多重共线性。
多重共线性有多种解决方案:
- 如果多重共线性是数据的固有特征，并且其他转换不可行，请使用不受多重共线性影响的算法。岭回归、主成分回归或偏最小二乘回归都是很好的回归选择。
- 使用 PCA 降低数据集的维数，只保留对保持数据结构重要的变量。如果数据集总体上非常多重共线性，这是有益的。
- 使用特征选择方法移除高度相关的特征。
- 获取更多数据—这是首选方法。更多的数据可以让模型保留当前的信息量，同时为噪声提供上下文和视角。
不使用术语，把定理拆开
towardsdatascience.com](/bayes-theorem-is-actually-an-intuitive-fraction-5f2803998006)
感谢您的阅读，请在回复中告诉我您的想法！
如果你对最新的文章感兴趣，可以考虑订阅。如果你想支持我的写作，通过我的推荐链接加入 Medium 是一个很好的方式。干杯！
多维标度布朗桥——性质与模拟
随机模拟
由佩德罗·麦克在 Unsplash 上拍摄的照片
在期货市场，通常可以观察到期货价格可能偏离标的资产的现货价格。如前面的文章所示，期货和现货价格之间的差价，称为，可以是正的，也可以是负的，但预计在期货合约到期时会收敛到零或接近零。
对于每种基础资产，都有多种不同期限的期货(从 1 个月到一年多不等)。对于每份期货合约，都有一个基本过程。因此，当我们考虑所有不同的现货资产及其相关期货时，有大量的基础过程。
此外，这些随机过程显然是相关的。首先，现货资产，如白银和黄金，可能(可能高度)相关。其次，在其他因素中，同一基础资产的期货显然是由一个共同的随机性来源驱动的。对于任何从事期货交易的人来说(基于相同或不同的资产)，理解这些过程之间的相关性是至关重要的。
多维标度布朗桥
这促使我们开发一种新的模型来捕捉不同基础和不同期货合约的随机基础的联合动态。一旦这个模型建立起来，我们就把它应用到动态期货交易中，正如这篇论文中所研究的。
多维标度布朗桥(MSBB) 是由以下多维随机微分方程(SDE)描述的连续时间随机模型:
在哪里
****
而 W 由布朗运动组成。
事实上， Z 是一个 N 维的过程，其中每个组件都是一个一维的标度的布朗桥:
一维标度布朗桥的随机微分方程。注意标度布朗桥 Zᵢ是相关的。
多维标度布朗桥的 SDE 有唯一的解
这里，我们使用对角矩阵的简写符号:diag (aᵢ ) = diag(a₁。。。，a_N)。
Z 的均值函数由下式给出
在哪里
κᵢ是缩放参数。
并且协方差函数是
图 1 显示了两对期货和标的资产(即 N = 2)的 Z 、 S 和 F 的模拟路径。这里，每个 Z 是相应资产和期货合同的对数基础(即 log(F/S))。(Zt，1)和(Zt，2)的曲线也显示了对数基数的 95%置信区间。
图 1:两对期货和现货(即 N = 2)的 S 和 F 的模拟样本路径，以及相应的二维基本过程 z .来源:https://arxiv.org/pdf/1910.04943.pdf
这些图显示了对数基础的两个特征。首先，它们是均值回复，因为任何偏离其均值的情况都被纠正。第二，它们在交易期限结束时(T = 0.25)部分收敛到零，这从置信区间变窄可以明显看出。事实上，(Zt，1)和(Zt，2)是布朗桥，分别在 T₁ = 0.27 和 T₂ = 0.254 时收敛到零。这种收敛没有实现，因为在这个特定的例子中，交易在 T = 0.25 停止。
由于，Zt |Z₀是一个多元正态随机变量，这意味着
具有卡方分布和 N 自由度。该关系用于获得由蓝色虚线椭圆表示的 Zt 的 95%置信区域。这些图还显示了在时间范围结束时对数基础的部分收敛。
(z₂z₁)的模拟值基于在三个不同时间观察到的 400 条模拟路径:t = 0.05(左)、t = 0.15(中)和 t = 0.25(右)。虚线代表(Z₁，Z₂)的 95%置信区域的边界，条件是 Z₀ = (0，0)。来源:https://arxiv.org/pdf/1910.04943.pdf
模拟
多维标度布朗桥的 SDE 解实际上有助于模拟算法。我们参考论文了解详细信息，但主要思想是将时间范围离散为 M 个时间步长，模拟独立的高斯随机变量，并将其放在正确的位置，如下所示:
来源:https://arxiv.org/pdf/1910.04943.pdf
对于这里没有解释的任何符号，请参考下面的文件。
外卖食品
对于涉及多种期货和资产的交易系统来说，恰当地捕捉价格过程之间的相关性是必要的。这里描述的 MSBB** 是为期货和现货资产之间的联合动力学建模而设计的。通过对随机微分问题的求解，该模型易于模拟。通过模拟样本路径，人们可以测试交易策略的表现。**
参考
T.Leung 和 B. Angoshtari，一篮子期货合约的最优交易[pdf；链接，财政年报，2020
Linkedin 页面 // 主页
多语言文档分类
作者图片
如何构建语言无关的 NLP 应用程序？
利用非结构化数据正成为在基于数据的业务中维持和超越的必要条件。开发能够提高 NLP 模型性能的文本特性需要语言学、数据科学和商业领域专业知识的结合。
这对一家初创企业来说已经足够了，但如果你的产品成为病毒，你走向全球，那该怎么办？
影响
想象一下，一家医疗保健服务机构根据英语临床研究为患者提供量身定制的剂量计划，从而提供最佳的医疗服务。如果你能添加其他语言，并利用中国或日本的最新研究成果，会怎么样？
挑战
对于数据科学家来说，开发一个成功的 NLP 模型意味着拥有带有文档标签的高质量语料库。不幸的是，大部分都是英文版本。当然，人们可以收集和标记其他语言的训练数据，但这将是昂贵和耗时的。
幸运的是，有一种有趣的替代方法叫做跨语言文档分类。
它的目的是在一种语言的数据集上训练一个文档分类器，并将其预测能力推广到其他语言，而不需要其他语言的数据集。
这个想法是使用独立于语言的单词或整个句子的表示。
使用案例
不要再拖延了，让我们立即行动起来，构建一个多语言新闻标题分类器。
该数据集包括来自 35 种不同语言的各种媒体公司的 72000 篇文章标题。它们被分为 4 个互斥的主题标签。任务是预测给定任何语言标题的标签。
关于标签的高度不平衡的数据集
NLP 管道
如何解决如此复杂的问题？我们分阶段一步一步分解吧。
NLP 管道
第一步。解析和清理 HTML
语料库似乎是从 HTML 代码中刮出来的，因为它包含许多 HTML 字符代码；有些坏了。已经创建了一个小型解析器来清理标题。
第二步。语言检测
似乎语言类型将是标题分类的一个极好的预测器。从卡方检验的结果来看，文字新闻大部分是用英语写的，而体育和科技文章则是非英语语言写的。
现在让我们使用脸书的快速文本库来检测语言。
import fastext
import pandas as pddef predict_language(text, language_classifier):
language = language_classifier.predict(text)
return languagelanguage_classifier = fasttext.load_model('lid.176.ftz')
df = pd.read_csv('headlines.csv').to_frame()df['language'] = (df['headline']
.apply(predict_language,
args=(language_classifer)))
步骤 3–4。通用多语言句子编码(MUSE)
进一步的管道设计需要很好地理解 MUSE 模型以及它是如何被训练的。
简单明了的 MUSE 将句子转换成一个数字向量。不同语言中具有相似意义的句子向量之间有着密切的几何距离。
该模型已在 16 种语言中进行了训练，因此有必要应用过滤器来删除管道中的其他语言。这是可行的，因为只有 3%的数据集超出了 MUSE 的范围。
重要的是执行与在模型训练期间已经完成的相同的文本预处理步骤。好消息是它们已经嵌入到 TensorFlow 的 model *predict*函数中。因此，除了删除下面的特殊字符之外，不需要额外的预处理。
special_chars = [
',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '/',
'[', ']', '>', '%', '=', '#', '*', '+', '\\', '•', '~', '·',
'_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '™', '›','♥',
'←', '×', '§', '″', '′', '█', '½', '…', '“', '★', '”','–', '●',
'►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾','═', '¦',
'║', '―', '¥', '▓', '—', '‹', '─', '▒', '：', '⊕', '▼', '▪',
'†', '■', '’', '▀', '¨', '▄', '♫', '☆', '¯', '♦', '¤', '▲', '∞',
'∙', '）', '↓', '、', '│', '（', '»', '，', '♪', '╩', '╚', '³',
'・', '╦', '╣', '╔', '╗', '▬','❤', 'ï', 'Ø', '¹', '≤', '‡', '√'
]
TensorFlow 完成了这项工作，将句子嵌入为长度为 512 的数字向量变得毫不费力。
import tensorflow_hub as hub
import numpy as np
import tensorflow_textembed = hub.load("https://tfhub.dev/google/universal-sentence-encoder-multilingual-large/3")X_embeded = embed(df['filtered_cleaned_headline'].values)
第五步。定性和定量特征的融合。
寻找合适的特性来提高模型性能是商业经验、科学和艺术的结合。所以，让我们看看除了嵌入和语言特性之外我们还能做些什么。
从这三组平均值之间的差异来看，标题文本长度可能是区分“体育”、“商业+技术”和“世界”相关标题的良好预测指标。
方差分析(ANOVA)
第六步。编码的降维
拥有 512 个特征是一个相当大的数字，会导致很长的训练时间，它的内存和计算开销很大，并且容易导致模型过度拟合。
过度拟合意味着模型不学习。它只是记忆训练数据，但它无法准确预测尚未看到的数据。
考虑到嵌入/编码的维数减少，有几种选择:
t-SNE 保持嵌入之间的相对距离，这是很大的，但它在计算上是昂贵的。PCA 用于快速原型制作，因为它快速且完全集成到 scikit-learn 管道中。但我会建议尝试选项 3，它在这篇论文中被证明更优越。
第七步。分类器筛选
NLP 管道内置于 scikit-learn 中，支持测试不同类型的模型。
*# Design NLP pipeline*
pipeline = Pipeline([
*# Fusion of features*
('fuser', ColumnTransformer(
[
*# Transform MUSE encodings*
('embedings', Pipeline([ # Standardize MUSE encodings
('emb_scaler', StandardScaler()),
# Dimensionality reduction of encodings
('emb_reducer', PCA(
n_components=0.75,
random_state=random_state))]), # Apply to only encodings columns
emb_idx),
*# Standardize title length feature*
('title_length', StandardScaler(), ['title_length']), *# One-hot encode language feature*
('language', OneHotEncoder(drop='first'), ['language'])
]
)), *# Determine classification model in the GridSearchCV*
('classifier', None)
])
由于不平衡的标签，[f1_weigted](https://en.wikipedia.org/wiki/F1_score)和[f1_macro](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)分数用于模型评估。前者考虑了标签在数据集中的分布，而后者侧重于类之间的模型判别能力，给予每个标签相同的权重。
将选定的模型与以下参考资料进行比较:
- 考虑数据集中标签分布的随机分类器生成器
- 最频繁分类器总是选择最频繁的标签。
最佳选择是逻辑回归。支持向量分类器(SVC)和 K-最近邻分类器(KNN)试图记忆数据集。尽管调整会改善过度拟合，但由于他们长期的训练和预测，这并不明智。所有模型的表现明显优于参考。
行动呼吁
就是这样！多语言文档分类在实践中。仍然有很多工作要做，以微调模型并使其为生产做好准备，但这是另一篇要讨论的文章。如果你想亲自尝试一下，我推荐以下资源:
- 多语种通用句子编码器(MUSE) 作者:大卫·萨尔瓦吉奥
- 八种语言的多语言文档分类语料库由李贤的 Holger Schwenk 开发
- 谷歌的 TensorFlow 嵌入文档
- 简单有效的单词嵌入降维Vikas Raunak
多语言变压器
为什么 BERT 不是多语言任务的最佳选择
使用https://translatr.varunmalhotra.xyz/和https://www.wordclouds.com/翻译“多语言变形金刚”获得的图像
去年，我们看到了变压器架构的快速改进。作为最先进的语言理解任务的主要参考点，大多数研究工作都集中在英语数据上。 BERT、RoBERTa、DistilBERT、XLNet——使用哪一个？概述了最近的变压器架构及其优缺点。
跟踪 GLUE leader 板是一项挑战，因为语言理解任务的进度非常快。每个月都有不同的团队占据榜首。
胶水导板快照(2020 年 1 月初)https://gluebenchmark.com/leaderboard/
与此同时，transformer 架构已经应用于多语言任务。为了评估这些任务，这里讨论的方法使用由 15 种语言的带标签句子组成的 跨语言自然语言推理(XNLI)语料库 。每个数据点由一个前提和一个假设组成。前提和假设已经被标记为文本蕴涵:即假设如何与前提相关。
XNLI 论文中的例子
其他一些标签的例子是“矛盾的，中性的”。
目前，没有关于多语言理解任务的商定基准。XNLI 数据集似乎是跟踪多语言模型发展的主要参考。在本笔记中，简要概述了用于多语言理解的多语言转换器的发展。
多语种伯特语
在提出 BERT 之后不久，Google research 就推出了一个多语言版本的 BERT，能够支持 100 多种语言。
参考资料:
- 来自谷歌的多语言 BERT，链接。
- 多语伯特的多语水平如何？
- 多语 BERT 跨语言能力实证研究(ICLR 2020 接受)。
亮点:
- 110k 跨所有 104 种语言共享单词表。低资源语言被上采样。
- 它提供了跨不同语言的某种共享表示。
此图是一个代理，用于估计两种不同语言的表示之间的相似程度。例如，EN-DE 上的 100%将意味着英语和德语被映射到相同的表示。更多详情在多语 BERT 到底有多多语言？
- 然而，该模型没有被明确地训练成具有跨语言的共享表示。因此，上面的结果有点令人惊讶。
- 最新的结果表明，语言之间的词汇重叠在跨语言表现中几乎不起作用。
- 相反，更深的网络提供了更好的跨语言性能。
所需资源:
预先接受了 4 到 16 个云 TPU 的培训。
许可证:
XLM (croX 语言模型)
这个模型是由脸书的研究人员在 2019 年初提出的。
参考资料:
- 跨语言语言模型预训练(neur IPS 2019 受理)。
- 脸书代码库，链接
亮点:
- 使用定义翻译语言建模方法(TLM)进行平行语料库培训
英语和法语中的并列句举例。来自跨语言语言模型预训练
- 在 95k 词汇表上训练的 80k BPE (字节对编码)令牌。BPE 非常类似于词块标记化的方法，链接。BPE 的工作方式是以一种层次化的方式对人物进行聚类，似乎更普遍地应用于跨语言模型。
- 在 XNLI 基准测试上，它在零拍上取得了非常好的性能。如果在训练期间使用翻译的数据，性能会更好。
所需资源:
- 在 64 个 GPU 上进行了预培训
许可证:
XLM-R(XLM-罗伯塔)
脸书的研究人员在 2019 年底跟随罗伯塔的脚步提出了这个模型。至于罗伯塔，主要的贡献是关于选择一个更好的训练设置。(作为 RoBERTa 的补充说明，即使这推动了性能的提高，也被认为没有提供足够的技术贡献，无法在 2020 年 ICLR 奥运会上被接受。
参考资料:
亮点:
- 更多的数据和更强的计算能力！
XLM 只在维基百科数据上接受训练，而 XLM-R 只在普通抓取数据上接受训练。来自无监督的跨语言表征大规模学习
- 句子片段250k 词汇上的标记化。他们也使用单语法语言模型而不是 BPE。
- 没有语言嵌入来更好地处理代码转换(即不同语言交替的文本)
- 实现最先进的结果(2019 年底)。
所需资源:
- 在 500 个 GPU 上进行了预培训
许可证:
总结与展望
XLM-R 似乎是迄今为止最好的解决方案。训练多语种变形金刚的 TLM (翻译语言模型)方法很有可能会与其他技术相结合。特别是，很容易预见的技术组合在顶部胶水董事会和 TLM。在机器学习社区中，对变形金刚还是很感兴趣的。比如 阿尔伯特 和 爱丽丝 最近已经在 ICLR 2020 接受了。
这里讨论的多语言转换器可以分别在谷歌和脸书的库中找到预先训练好的:
使用hugging face Transformers code可以非常容易地测试出所有的模型。用 PyTorch 写的。许可证: Apache 许可证 2.0
多模态深度学习预测电影类型
多模态深度学习模型的 PyTorch 实现。它使用电影海报和概述来尝试和预测电影的类型。
黑暗骑士。图片来自 TMDB 。
“蝙蝠侠提高了他打击犯罪的赌注。在中尉吉姆·戈登和地方检察官哈维·登特的帮助下，蝙蝠侠着手摧毁困扰街头的剩余犯罪组织。这种伙伴关系被证明是有效的，但他们很快发现自己陷入了混乱的统治，这种混乱是由一个崛起的犯罪主谋引发的，这个犯罪主谋被惊恐的哥谭市民称为小丑。”——TMDB
《黑暗骑士》——我最喜欢的电影之一。 TMDB 将这部电影分为四类——剧情片、动作片、犯罪片、惊悚片。我训练的一个多模态深度学习模型将这部电影分类为——动作片、剧情片、惊悚片。让我们来看看这个模型是如何做到这一点的。
什么是多模态深度学习？
情态是做或经历某事的一种特殊方式。我们生活在一个多模态的环境中。我们看到东西，听到声音，闻到气味，感觉纹理。与此类似，多模态深度学习涉及一起使用的多个模态来预测一些输出。在这个项目中，我分别使用卷积神经网络(CNN)和长短期记忆(LSTM)网络连接从图像和文本序列中提取的特征。这些特征被用来尝试和预测电影类型。
数据集
为了这个项目，我使用了 Kaggle 的电影数据集。它包括 40，000 多部电影的概述，TMDB 的海报链接和来自 TMDB 网站的流派。拆分数据集后，训练集由 26864 个例子组成；测试集包括 7463 个样本，验证集包括 2986 个案例。
探索性数据分析
在对数据进行预处理之前，有必要了解每种体裁的类别分布情况。诸如“Aniplex”、“BROSTA TV”的一些类型似乎在整个数据集中只出现一次。因此，我删除了这些。除此之外，一些类似“电视电影”和“外国”的流派，海报和电影摘要也不容易让人察觉。因此，这些也被删除。下面的片段显示了从数据集中删除的流派列表。
invalid_genres = ['Aniplex', 'BROSTA TV', 'Carousel Productions', 'GoHands', 'Mardock Scramble Production Committee', 'Odyssey Media', 'Pulser Productions', 'Rogue State', 'Sentai Filmworks', 'Telescene Film Group Productions', 'The Cartel', 'Vision View Entertainment', 'TV Movie', 'Foreign']
我还扫描了数据集中没有指定流派的行。超过 2471 行在 genre_list 列中没有任何值。所以这些行被删除了。
除此之外，从流派标签的角度来看，了解数据集的平衡程度也很重要。从下图中可以清楚地看出，数据集中存在阶级不平衡。
作者图片
文本清洗和预处理
数据清理和预处理允许我们从数据中移除不相关的信息，比如 URL。这些熟悉的单词出现得非常频繁，但没有添加太多的语义，如英语中的冠词。文本处理包括以下步骤:
- 从文本中删除所有标点符号。
- 将文本转换为小写，删除非字母输入和所有 NLTK 停用词。
- 使用 NLTK 的单词词汇化。变元化的目标是将一个词的屈折形式，有时是派生相关形式简化为一个共同的基本形式。例如，“查找”可以替换为“查找”。
使用 Keras Tokenizer API 对清理后的文本进行标记化。这个记号赋予器用于将所有文本转换成要输入到 LSTM 网络中的序列。通过用零填充，所有的序列都具有相同的长度。这样做是为了确保所有输入具有相同的尺寸。
下载和预处理海报
模型的输入之一是电影海报。因此，我必须下载对应于数据集中每部电影的一张海报。原始数据集还包含一个存储在 TMDB 的海报的 URL。然而，大多数链接似乎过时了，所以我不得不临时利用 TMDB API。我使用了 python 的 tmdbv3api ，它包装了 TMDB API。使用原始数据集中的电影 id，我找到了对应于一部电影的单个海报。需要注意的一点是，有些电影可能没有 TMDB 的海报。
“电影”对象允许我们根据 TMDB ID 搜索电影。通过一个简单的 GET 请求下载海报，并保存到我的 Google Drive 中。对应于电影海报的路径保存在列表中，该列表作为列添加到数据集中。
如果下载海报时出现任何错误或电影的 poster_path 不存在，则该电影将从数据集中删除。
这是最终数据集的一瞥。
作者图片
最后的预处理步骤是调整海报的大小，并将它们附加到一个 NumPy 数组中。保存这个 NumPy 数组是为了更容易以有效的输入格式访问海报。这个过程需要很长时间，输出的 NumPy 数组大约为 2–3gb。需要大量的 RAM 来保存这个数组。我建议在整个过程中使用 Google colab。下面是将图像转换成 NumPy 数组的代码片段。如果在数据集中的指定路径找不到任何海报，则会删除相应的行。
所以我最终预处理了文本输入和图像输入。现在，开始训练模型。
预处理标签
每部电影都与数据集中一定数量的流派相关联。然而，这需要被制成一个独热编码向量，其中每个对应于一个流派标签。为此，我使用了 scikit-learn 库的 MultilabelBinarizer 类。它产生一个稀疏矩阵，其中每个行向量是一位热编码的。这意味着行向量在与其被分类的标签相关联的索引中具有 1，而在所有其他地方具有 0。因此，这是一个多标签分类问题。如下所示，数据集中总共有 18 个类。
模型架构
该模型由两个网络组成——一个堆叠的 LSTM 和一个 CNN。文本序列被输入到嵌入层。我用的是谷歌预先训练好的 Word2Vec 嵌入。然而，为了微调模型，我允许嵌入层是可训练的。嵌入层之后是两个堆叠的 LSTMs，其输出馈入全连接层。
这些图像被输入到 CNN。CNN 由连续的 2D 卷积层和最大池层组成。最后一个 max-pooling 层的输出被展平并馈入完全连接的层。
LSTM 和 CNN 的全连接层然后被连接并被前馈，直到最后的全连接层。最后一层的输出大小为 18，每个层对应一个流派。
模型的架构。图片由作者提供。
训练模型
DataLoader 对象初始化时的批处理大小为 64，它将输入传递给模型。TensorDataset 对象用于包装数据集输入和标签。然后，将每个 TensorDataset 提供给 DataLoader 对象。这将允许我们将数据集批量发送到模型进行训练、验证和测试。
我使用的损失是二元交叉熵和亚当优化器。梯度剪辑也被用来防止爆炸梯度。该模型被训练了 20 个时期。在训练期间，我计算了每个时期的准确度和损失，作为所有批次的准确度和损失的平均值。
最终历元的精度和损失如下:
Epoch 20: train_loss: 0.1340 train_acc: 0.9200 | val_loss: 0.3431 val_acc: 0.8726
在训练和保存模型之后，我在测试集上评估了准确性和损失:
acc: 0.8737 loss: 0.3406
评估指标
准确性和损失似乎表明该模型表现得相当好。然而，由于数据集中的类别不平衡，一些更好的评估指标将是精确度、召回率、 F1 得分和受试者操作特征曲线下的计算面积(ROC AUC)得分。由属于一个流派的电影的非阈值概率组成的输出被转换成具有独热编码行向量的稀疏矩阵，以计算精确度、召回率和 F1 分数。这是使用 0.5 的任意阈值完成的。这个值可以通过使用马修的相关系数进一步提高。还可以通过绘制每个类别的 ROC 曲线来增强。
Precision on test set: 0.5732
Recall on test set: 0.5210
F1 score on test set: 0.5080
使用模型的非阈值输出计算 ROC AUC 得分。
roc auc macro score: 0.8021
使用的另一个评估指标是汉明损耗。汉明损失给出了标签总数中错误标签的一部分。
Hamming loss on the test set: 0.1078
从上面的评估指标可以明显看出，该模型在测试集上表现良好。通过为每个标签取一个优化的阈值而不是 0.5 的任意值，可以进一步提高精确度、召回率和 f1 值。改进模型的另一个方法是分别评估 CNN 和 LSTM，以判断两者的改进范围。
结论
- 该项目探索了一种多模态深度学习方法，以解决从电影海报和概述中预测电影类型的多标签分类问题。
- 测试集上的模型精度和损失都很好。然而，对于这个问题有更适合的评估指标——精确度、召回率、f1 分数和 ROC AUC 分数。
- 这种模型可能能够区分喜剧电影的海报和概述的特征与恐怖电影的海报和摘要的特征。
感谢阅读这篇文章！这个项目的完整代码可以在https://github . com/DH 1105/Multi-modal-movie-genre-prediction找到。
参考文献
- https://towards data science . com/multimodal-deep-learning-ce 7d 1d 994 f 4
- https://www.kaggle.com/rounakbanik/the-movies-dataset
- https://towards data science . com/understanding-AUC-roc-curve-68b 2303 cc9 C5
- https://medium . com/@ kunalgupta 4595/predicting-movie-genders-based-on-plot-summaries-BAE 646 e 70 e 04
超市购物者细分的多项式混合模型
完整的教程
彼得·邦德在 Unsplash 上的照片
在我的上一篇文章中，我写了高斯混合模型(GMM)以及使用期望最大化(EM)算法训练它的方式的详细解释。这一次，我想展示混合模型不一定是高斯密度的混合。它可以是任何分布的混合。在这个例子中，我们将使用混合多项式分布。
此外，这一次的想法是，不要只关注数据科学项目的数学和计算机科学方面，还要关注业务方面。因此，我们将使用一个真实世界的数据集，并在营销领域进行具体应用。它有望让读者更好地理解我们为什么要做这些事情:-)。此外，我们将介绍一些关于描绘多项式分布的数据可视化。
这项工作主要受到 Cadez 等人的一篇研究论文 的启发，该论文题为“使用有限混合模型 预测交易数据的概况”。很大一部分功劳归于他们。
构建业务环境
在这个超级计算机、机器学习和数据科学的时代，几乎每个企业都在收集关于其活动不同方面的数据，并试图利用这些数据为自己谋利。零售业，尤其是超级市场也不例外。超市收集购买数据或通常所说的交易数据。可以对其进行挖掘，以提取洞察力并提高整体运营的效率。
提取相关模式的一种方法是从聚类过程开始。这个想法是将相似的项目组合在一起。它可以被认为是以这样的方式将数据集分成聚类，使得聚类内的数据点具有高相似性，而聚类外的数据点具有低相似性。
在传统的营销应用中，这种聚类过程最重要的用途是探索性数据分析。为了更好地描述、解释和独立研究它们，我们希望将观察结果分成少量的组。常见的用法是进行客户细分。每个细分市场都有自己的一套特征。例如，在线电子商务网站的输出细分可以描述为“30 岁以下的价格敏感型客户，主要通过数字渠道参与”。由于其战略重要性，此类项目是营销分析中最常执行的项目之一。它允许围绕客户群及其典型需求和属性建立企业营销战略。
这个项目的目标是执行超市交易数据集的聚类，以建立个人的预测性档案。这样的配置文件支持许多不同类型的进一步分析。其中，我们发现为目标营销策略建立客户群、提取隐藏的产品关联、预测个人购买行为、变化检测、交叉销售、个性化等等…
在本文中，我们将:
- 快速浏览数据集
- 解释使用混合多项式随机变量的模型化
- 推导期望最大化的数学更新规则
- 描述选择最佳集群数量的方法
- 用普通 Python 实现一切
- 分析结果并得出一些见解
- 探索问题的第二种表述方式，以更好地描述个人特征
数据集探索
这个项目的数据集是在 Kaggle 上找到的:“dunhumby——全程”。引用 Kaggle 的话来说，它:“包含了一个由 2500 个家庭组成的小组在两年内的家庭级交易，这些家庭是一家零售商的常客。对于某些家庭，人口统计信息以及直接营销联系历史也包括在内”。
在这项工作中，我们将把重点放在交易数据和相关产品上。因此，让我们看看最初的几个事务是什么样子的:
作者图片
每一行对应于给定家庭在特定购物篮中购买的一定数量的产品(一个购物篮对应于一个特定的收银台)。该数据集包含 276484 个购物篮中的 2595732 笔交易。这些交易是由 2500 个家庭在 44 家百货商店的 308 个类别和 2383 个子类别中的 92339 种不同产品进行的。
有很多有用的信息，但是我们没有兴趣使用所有的信息。本练习是关于使用多项式混合模型对交易数据集进行无监督聚类。正如我们将看到的，多项式混合模型仅用于分类数据。因此，我们不会考虑价格或零售折扣等连续估值的预测指标。
现在，为了理解我们将要执行的数据选择和准备过程，我们需要确保您正确理解了多项式分布(如果您已经精通多项式，可以跳过这一节)。
多项式分布的表述
多项分布是二项分布的推广，后者本身是伯努利分布的推广。让我们从伯努利方程开始。
伯努利随机变量 X 描述了具有两种可能结果的单次试验的结果，1 或 0，分别具有概率θ和 1-θ。
例如，我们可以描绘 Ber(0.3)的概率质量函数:
作者图片
在 frequentist 的观点中，参数的真实值是通过测量无数次实验中感兴趣的统计数据而获得的。在伯努利试验的情况下，如果我们无限次重复我们的单个实验，记录结果并平均阳性结果的数量，我们得到θ的真实参数值(在上面的例子中，我们有 30%的时间得到阳性结果)。
现在，如果我们不仅要计算一次伯努利试验的阳性结果数，还要计算一系列 n 次伯努利试验的阳性结果数。这就是二项式试验的目的。例如，将一枚硬币抛 10 次，我们想要测量硬币正面落地的次数。这一次，二项式试验的输出可以是 0 到 10 之间的任何离散值。概率质量函数的精确公式为:
让我们看看如何从伯努利分布推导出这个公式。为了简单起见，我们假设想要记录两次抛硬币(即两次伯努利试验)得到的人头数。有哪些可能性:
从这个枚举中，我们得到:
公式中的二项式系数抓住了这样一个事实:在一系列 n 次试验中，有不同的方式来分配 k 次成功。在上面的例子中，有两种方法在两次试验中分配一次成功。如果我们增加试验的次数，获得中心值的可能方法的数量比获得极值的可能方法的数量增加得更快。这就是为什么分布得到一个漂亮的钟形。
因此，在 20 次独立伯努利试验的概率θ = 0.3 的二项式试验中，概率质量函数可以用下面的条形图表示:
作者图片
对于有 20 个概率为 0.3 的独立伯努利试验的二项式试验，最可能的阳性结果数是 6。那就是上面分布的模式。
现在我们如何进一步推广这个分布呢？那么，如果我们考虑一系列 n 次试验，但这次有两种以上的可能结果，会怎么样呢？例如，我们有一个装有 3 种不同类型球(蓝色、红色和黄色)的袋子，我们想测量每种颜色在 2 次抽奖中得到的球数(替换)。让我们列举各种可能性:
从这个计数中，并且给定我们可支配的蓝色、红色和黄色球的比例，分别为θ_1、θ_2 和θ_3，我们可以测量概率:
我们可以继续，但我希望你们明白，我们如何推导出多项式的概率质量函数的解析公式:
关于多项式的可视化
好，那么现在，如果我们想要画出概率质量函数，用一些柱状图，就像我们上面做的那样？嗯，这次会有点棘手。
这是一种表达，但重要的是你要理解多项式的这种表示，因为我们以后会用到它。
为了描绘一个分布图，我们需要一种方法将可能的结果放在图上，并且能够显示它们的相对重要性。这就是我们用于伯努利分布和二项式分布的柱状图的目的。在 x 轴上，我们放置有序的可能结果值，在 y 轴上放置相关的概率。
那么，多项式呢？这里的问题是，我们不能再用单一的随机变量来描述不同的可能性。在伯努利和二项式中，我们使用一个随机变量 X 来计算成功的次数。我们不使用第二个随机变量来表示失败次数，因为它显然是从 x 中推导出来的。但是在多项式的情况下，我们需要为单次试验的 C 个可能结果引入至少 C-1 个随机变量。注意，一般来说，我们甚至使用 C 个随机变量(X_1，X_2，…，X_C ),就像上述公式中的 PMF 一样，因为这样写起来不太麻烦(即使可以推导出最后的随机变量值)。
我们只对描绘至少有两个或更多可能结果的分布感兴趣(否则我们会回到二项式)。让我们首先考虑 3 种可能结果的情况。我说过，我们可以只用两个随机变量 x1 和 x2(x3 可以推导出来)。然后我们将需要 3 个维度(对于 X_1，X_2，联合概率 P(X_1，X_2)=P(X_1，X_2，X3))。好的，我们可以用一个三维条形图来实现这个目的:
作者图片
好吧，那么这种视觉化有什么问题呢？首先，我们看不出 X3 的不同价值。我们可以推断出它们。例如，对于 X1=0 且 X2=0 的第一个箱，我们知道 X3=20。但是我们没有把它形象化。此外，该图一半的专用空间是无用的。例如，当 X2=20 时，我们肯定知道 X1 不会取除 0 以外的任何值。因此，该 3d 直方图底部一半的三角形将永远不会显示任何密度，因为概率为零。
那么怎样才能做得更好呢？首先，我们可以将直方图的底部简化为一个三角形，更准确地说是一个等边三角形。我们使用等边三角形，这样从顶点到重心的距离是相等的。这个三角形中任何一点的确切位置决定了 3 个随机变量的相对比例。这被称为单形，显示 3 个值的离散概率向量非常有用:
作者图片
此外，如果我们画出三角形边的每条平行线，也就是说，我们离散化整个三角形空间，每个交点可以用来描绘 3 值元组的相对比例。在下面的示例中，我们描绘了具有 16 个抽奖和 3 个概率为 0.25、0.5 和 0.25 的可能值的多项式:
作者图片
最后，我将在这里停止这种表述，不可能将这种逻辑扩展到额外的维度来描绘阶数高于 3 的多项式。例如，我们可以尝试使用一个 4 维的正方形，但它不会工作，因为正方形中的一个点仅在 2 条线的交叉点上，并且我们需要 4 条线的交叉点作为这个位置的 4 值元组的比例的容器。
回到数据
正如我之前所说的，因为我们想要使用多项式混合模型来执行聚类，所以我们不考虑连续变量。在这个练习中，我们只考虑产品、家庭和篮子。因此，要考虑的列如下:
作者图片
有 4 列描述在特定交易中购买的产品(PRODUCT_ID、DEPARTMENT、COMMODITY_DESC 和 SUB_COMMODITY_DESC)。我们希望对交易进行分组，并对每个组计算产品的数量。
模型组成
那么我们为什么要统计产品的数量呢？这将允许我们应用以下通用模型:
这代表观察完整数据集的联合概率。它是个体概率的乘积(因为观察值是独立数据收集的)。观测到一个观测值 x_i 的概率是一个多项分布的混合。x 表示所购买产品的计数矩阵。矩阵的每一行 x_i 对应于一个特定的购物篮(例如，一个购物者在超市结账)。每个多项式分布表示获得我们在特定篮子中看到的计数的概率，假设它是由特定的聚类 k 生成的:
在上面的公式中，n_i 表示在给定的篮子中购买的产品总数。c 表示不同产品的总数，因此多项式 k 和产品 c 有一个参数β_kc。这意味着β是 k 维参数乘以 c 的矩阵，β_k 是 c 维向量。n_ic 表示在给定篮子 I 中购买的特定产品 c 的数量。
我们的模型使用了多项式分布的混合。它基本上假设存在 K 个簇。这意味着在任何给定的篮子里，商品被购买的概率是 K 个典型篮子的组合。这个项目的目标是提取那些典型的篮子。
回到数据
因此，我们需要按篮子对交易进行分组，并对每个篮子计算不同产品的数量。但正如我们刚刚看到的，我们将用于该模型的参数数量高度依赖于不同产品的数量。我们的产品越多，参数的数量就越多。这意味着，如果我们有太多的产品，我们可能会在优化过程中遇到麻烦，无法找到参数或集群数量的最佳值。但是我们没有义务按不同的产品来计数(有 92339 种)。我们可以按百货商店(44)、类别(308)或子类别(2383)来计数。这一选择将决定上述公式中的数字 C。
显然，理想的场景是对数据建模，一直到产品级别。事实上，我已经试过了，我的笔记本电脑内存不够了。更不用说多项式有这么多不同的组成部分，我们在选择正确的聚类数时可能面临的问题会大大增加(我们将在后面看到)。因此，为了区分产品，我们必须在百货商店、类别和子类别之间进行选择。让我们看看每个部门的交易数量的分配情况:
作者图片
如我们所见，绝大多数的交易都是在食品部完成的。因为这是一个练习，所以我决定不去管杂货店以外的交易。现在让我们看看杂货店的交易是如何分布在不同类别中的:
作者图片
作者图片
共有 94 个类别，尽管类别之间的交易数量不一致，但提供最少的类别仍有 51 笔交易。现在，让我们看看子类别有哪些内容:
作者图片
作者图片
我们有相同的递减模式。但是现在子类目那么多，交易最少的也只有 1 笔交易。单次交易显然不足以准确估计参数。
因此，我们将按类别(而不是子类别)区分产品，并生成计数 X 的矩阵，我们将使用它来解决聚类问题。让我们看看前 10 行是什么样子的:
作者图片
如你所见，矩阵非常稀疏。但这对于多项式混合模型来说不是问题。
数学推导
如前所述，观察数据集的完全可能性由下式定义:
为了理解这一部分，你需要熟悉期望值最大化算法(如果没有，我强烈建议你阅读我的文章。对于 EM，我们首先需要定义一个潜在变量 t，它通过定义一个观察值是从哪个集群生成的来描述这个观察值。
作者图片
潜在变量 t_i 定义了观察值 x_i 是由哪个聚类生成的。此外，变分分布 q 用于描述潜在变量的后验分布，取可能值的范围(从 1 到 K)。所以我们可以写:
回想一下，EM 算法定义了对数似然的下限:
EM 算法交替进行以下两个步骤，直到收敛:
期待步骤:
我们最大化关于 q 的下限，以更新潜在变量的后验分布:
如您所见，期望步骤的形式与混合高斯分布的情况相同，只是给定聚类 k，即 P(x_i | β_k)的观测值的可能性现在具有多项式密度:
最大化步骤:
我们将α和β的下界最大化。我们尝试解决以下优化问题:
下限定义为:
为了解决这个优化问题，我们将偏导数设置为 0，并求解方程。注意，上面减法中的第二项不依赖于α或β，所以我们可以用一个常数来代替它。同样，我们将使我们的拉格朗日乘数摆脱约束。所以我们需要解下面的方程组:
使用:
让我们从多项式参数β_kc 开始:
现在混合物的重量为αk:
好了，现在我们有了 E 步中变分分布的更新规则和 M 步中参数的更新规则。让我们来看看具体的材料。
履行
期望最大化算法不能保证我们在第一次运行时会找到似然函数的全局最大值。为了增加我们的机会，建议用不同的随机初始化多次启动算法。每次，我们将把我们的最大值与前一个进行比较，并保留与最佳损失相关的参数。让我们实现这个例程:
所以我为这个模型创建了一个类，它需要用我们想要尝试的集群数量来实例化。我还添加了一些参数:
- rtol:将在比较当前损失和先前损失时使用，以决定我们是否应该停止算法(从一个周期到下一个周期的改进变得很小，因此没有必要继续)
- max_iter:为了保证算法不会永远运行，我们可以告诉它在一定次数的迭代后停止
- 重新启动:我们希望使用不同的初始化重新启动完整 EM 程序的次数
接下来，我们需要实现 _train_once 方法，顾名思义，该方法将为 EM 算法运行一个完整的迭代周期。
算法的形状没有什么大的惊喜。我们从随机初始化参数开始。我们迭代到 max_iter 迭代，并且每次我们在计算潜在变量 t(γ)的后验分布的 e 步骤和更新混合物参数(α和β)的 m 步骤之间交替。
注意，β参数使用与多项式分布共轭的狄利克雷分布进行初始化。我不会在这里深入讨论细节，但是您只需要知道 Dirichlet 将根据需要产生一组总计为 1(对于每个集群)的参数。
现在还有一件事我们还没有谈到。这是损失。记住，在每次迭代中，EM 算法都试图最大化下界。所以我们将使用的跟踪算法收敛的损失函数是下限:
这为我们提供了以下实现:
请注意，计算并没有完全矢量化。我们仍然遍历不同的 K 个集群。这是因为我们使用了 scipy.stats 中多项式的实现。该实现接受计数的观察值矩阵，但不接受参数的观察值矩阵。所以你可以计算所有观测值的多项式概率，但只是针对一个特定的集群，而不是一次全部。
现在是电子步骤:
这就是我们在上一节中数学推导出的更新规则的矢量化实现。不过要注意的一点是，当计算观察计数向量的多项式概率(即可能性)时，概率有时非常接近于 0，以至于我们会得到数字下溢，并且值被舍入到 0。这是不好的，因为我们必须归一化这些值来得到后验概率。为了避免被 0 除，我们用 Python 中允许的最小浮点值替换空值。
现在是 m 步:
没什么大不了的。这些是我们数学推导的更新规则的矢量化实现。
在模拟数据集上运行
我们将运行该算法，看看它在各种值下的表现如何。好的做法是首先使用模拟数据集，以便我们控制数据生成过程。然后，我们可以看到当我们修改参数的真值(即，聚类的数量、混合权重、多项式参数和数据集的大小)时，算法是如何执行的。数据集通过以下程序生成:
所以我们首先要做一个简单的测试。数据集是由 10000 个观察值混合而成的，这些观察值来自 3 个分离得很好的多项式，可以取多达 16 个不同的值。此外，我们将生成的数据集分成 80 %用于训练，20 %用于测试。然后我们计算测试数据的可能性:
作者图片
正如我们所看到的，估计的参数非常接近真实的参数。此外，现在我们看到了关于多项式可视化的工作的价值。从上面的图中可以很明显地看出，这些簇被很好地分开了。因此，该算法在估计真实的聚类数方面应该没有问题。如果我们观察当我们增加集群数量时的可能性演变，我们可以清楚地看到肘形模式。当我们从 2 个集群到 3 个集群时，匹配的可能性更大。但是一旦我们到达 3 个集群，可能性就达到了一个平台。这清楚地表明聚类的最佳数量是 3。为什么？嗯，因为当我们增加聚类的数量时，我们增加了模型的复杂性，但对可能性没有额外的好处。
现在，当我们修改混合物重量时会发生什么:
作者图片
再次，混合权重被很好地估计，这证实了更新规则是正确的。
现在，当集群没有很好的分离时会发生什么？让我们看看:
作者图片
这一次，混合物重量的推断不太正确。不过多项式分量权重更好。此外，我们仍然可以在似然值中看到肘形模式，但是它们的分布更加嘈杂。从可能性的分布中，我们可以清楚地看到，从 2 到 3 个聚类的跳跃是在拟合优度方面获得最大值的一个。所以我们还是选择 3 个集群。
现在，如果我们用 10 个不同的多项式来填充参数空间呢？
作者图片
好了，这一次，仅仅基于可能性的提高来选择最佳的聚类数目要复杂得多。可能是 3 个集群，也可能是 7 个……这显然是不正确的。好的，那么我们如何做得更好呢？我们将使用另一个选择标准。它被称为贝叶斯信息准则(或简称 BIC)。其计算公式如下:
d 表示由模型估计的参数的数量，N 表示观察值的总数，L_hat 表示模型的似然性。它引入了一个与观察数量和参数数量成比例的惩罚。我们想要做的是最小化 BIC 值，从而使可能性最大化，但同时保持参数的数量尽可能少。在多项式的混合的情况下，对于 C 个分量的 K 个多项式，参数的数目 D 等于(K-1)+K*(C-1)。知道混合物重量和组分重量加起来都是 1，我们可以推导出最后的参数。
将这一新的选择标准应用于具有 10 个多项式的生成数据集，我们得到:
作者图片
通过 BIC 标准正确地选择了 10 个簇的最佳数量。但是我们看到这是一场势均力敌的比赛。事实上，再次运行相同的程序，我们可能会得到不同数量的集群。这表明选择正确的数字是非常困难的，没有灵丹妙药。最后，没有什么能打败业务分析师的判断。因此，检查集群并尝试查看是否应该合并其中的一些集群是一件好事(因为它们彼此非常接近，并且具有非常相似的属性)。
对百货商店数据集进行拟合
好了，现在我们有了执行杂货店交易数据集聚类的要素。回想一下，我们已经为按篮子分组的不同产品类别的交易计数准备了一个矩阵:
作者图片
在按 80/20 规则(按购物篮交易时间排序)拆分该矩阵后，我们将模型拟合到训练数据，并记录测试数据上从 2 到 100 的一组可能聚类值的可能性和 BIC 值。我们得到以下结果:
作者图片
从上面的图中，我们理解了为什么对于真实世界的数据集，仅仅基于可能性来选择最佳聚类数是不太可靠的，以及为什么我们需要对模型的复杂性进行惩罚。这是因为集群通常没有很好的分离。使用贝叶斯信息标准，我们选择 30 个集群。
结果
聚类分析
首先，我们可以根据产品类别的概率分布来可视化集群。我们绘制了 6 个第一组:
作者图片
重要的是要理解上面的分布代表了典型的篮子。他们可以帮助我们预测产品的购买量。
此外，我们可以注意到，一些典型的购物篮由一个或少数几个类别主导，而其他一些典型的购物篮由更多样化的类别组成。这突出了购物行为。有时候，一个人会很快去一趟商店，为某个特定的场合(周六早午餐、周日晚餐、和朋友喝酒……)购买食材，或者可能是每周购物的较长时间。
接下来，我们希望通过可视化它们的相对距离来评估聚类质量。考虑到有 30 个集群，看不出它们彼此之间有很好的分离。为了可视化它们之间的距离，理想的场景是建立一个 30 维的空间，我们可以在其中放置观察结果。当然，这是不可行的，所以我们将依靠一种降维技术。我们使用的技术叫做多维缩放。像 PCA 一样，它依赖于输入矩阵的特征分解。但是这次，输入矩阵将是聚类参数的成对距离矩阵(使用曼哈顿距离)。我们得到以下结果:
作者图片
聚类大小在混合权重上同步，这突出了它们的不平等性。尽管由于降维技术丢失了一些信息，我们仍然可以得出结论，聚类被很好地分开了。
高升程项目
描述聚类的一个好方法是计算购买量高的单个产品的提升率。产品和集群的提升率被定义为以集群为条件的购买概率与总购买概率之间的比率。因此，首先我们需要计算每个产品的购买概率，可以定义为:
它是特定产品的总数量与所有产品的总数量之比。它可以被定义为在数据集的所有篮子中随机选择的篮子中找到产品的概率。让我们看看所有产品的概率分布:
作者图片
如您所见，非常低的值高度集中。此外，很大一部分概率非常低，以至于他们的计算受到数值下溢的影响(这基本上导致概率为 0)。我们只想考虑经常购买的商品，因为它们最具特色。所以我们将把这个分析限制在购买概率高于 0.0001 的产品(2019 年产品)。
作者图片
接下来，为了计算提升率，我们需要计算这些物品的购买概率，但是对于特定的集群。这意味着我们希望获得在特定分类 k 的篮子中随机选择的篮子中找到产品的概率(而不是在所有篮子中):
这个计算的问题是，严格地说，谈论一个集群的篮子是不正确的。事实上，在当前的模型化中，一个篮子同时属于几个集群。请记住，我们执行的软聚类是由参数上的潜在变量的后验概率分布定义的，即 P(t_i|x_i，α，β)。例如，让我们设想前 6 个篮子的潜在变量的后验分布:
作者图片
聚类过程的目标是通过将最典型的购物篮分组在一起来提取它们。一些篮子将位于集群的核心(在分配概率空间中)。然后，该分布显示特定分类的单个高值(就像上面左上的篮子)。但是一些篮子将位于分配有点模糊的区域。因此，为了准确地计算基于一个分类的购买概率，我们首先要在不同的分类中分配篮子产品的数量。因此，我们使用以下规则计算一个新的大小为 N 乘以 K 乘以 C 的浮点矩阵:
最后，我们可以计算升力比，即:
显示提升比大于 10 的项目，我们可以开始描述具有特定产品的集群。例如，第一组的高升程项目如下:
作者图片
第一类提升最高的项目是罐装豆类和番茄。
此外，为了更直观地描述聚类，我们可以根据高提升项目的类别(也考虑购买频率)来制作单词云。让我们看看前 6 个集群的结果:
作者图片
从上面的单词 clouds 我们可以描述星团。第一组是一个很好的组合，虽然主要话题是蔬菜。第二和第三类主要是烘焙食品，第四类是与晚餐相关的产品，第五类是小吃，第六类是乳制品。
产品关联
现在，通过计算高升力项目对，高升力项目分析可以更进一步。概率的计算是一样的，只是这次我们是针对成对的项目来计算的。例如，从群集 1 的随机篮子中找到“杂种豆-肾平托”和“番茄酱”的可能性是从一般随机篮子中找到的可能性的 17.2 倍。
通过首先将数据集缩小到特定聚类的交易，然后检查成对产品的购买概率，我们发现了原本不相关的关联！
个人预测简档
到目前为止，我们一直在使用的模型将观察值的可能性描述为多项分布的混合:
完整数据可能性写为:
正如我之前所说，这个模型独立考虑每个篮子，不同个人的篮子没有区别。我们以相同的方式考虑每一个人，这意味着他们具有相同的预测特征，由模型参数的估计产生。在我们的例子中，这给了我们以下一般概况(通过采样模拟):
作者图片
一般来说，这种描述更准确地描述了购买概率。现在，它可能非常适合一些人，但在大多数情况下，它是一个糟糕的预测。那么如何才能做得更好呢？首先，我们将通过重写完整的数据可能性来介绍个人篮子之间的区别:
指数 I 指的是一个特定的个体。指数 j 指的是那个人的当前篮子(从 1 到篮子总数 n_i)。我们没有对模型做任何修改。上面这个模型已经是我们实现的了。我们刚刚介绍了个人篮子之间的区别。请记住，我们正在使用一个潜在变量模型。潜在变量的每个实例描述了来自个体 I 的篮子 j 由聚类 k 生成的概率。因此，我们可以考虑分类似然性而不是似然性，这是混合模型的 EM 框架内的完全数据似然性:
因此，对于特定的个人，完整数据的可能性计算如下:
现在，我们可以做的是，通过从测试集和从上面的预测分布中抽样获得的预测中面对他们的购买，来检查特定个人的实现。
为了构建给定个体的预测分布，我们迭代通过该个体的训练集的所有篮子，对于每个篮子，我们迭代通过每个混合成分 k，并且每次我们从相应的多项式采样。然后用混合权重和属于该聚类的观察值的潜在概率对样本进行加权。最后，将所有样本相加，并通过总计数进行归一化，以得到合适的概率分布。此外，为了对预测进行评分，我们计算预测和测试集的标准化购买计数之间的 L1 距离。这里有两个例子:
作者图片
作者图片
我们可以看到，结果并不总是对每个人都好。对于经常购物的人来说，这个预测显然比不经常购物的人要好。
个体重量
好吧，那么有没有更好的方法呢？答案是肯定的，可以在我在本文开头提到的研究论文中找到:“使用有限混合模型 预测交易数据的 ”。
其思想是用个性化的权重代替全局混合权重。然后，完整数据可能性变为:
这一次，我不会讨论更新规则的数学推导。您唯一需要知道的是，除了在 m 步骤中混合物重量的更新之外，它们保持不变，即:
如果我们用全局模型与以前的更新规则进行比较，不同的是，现在我们只对个体的篮子而不是所有的篮子使用潜在变量的后验分布。
在训练该模型之后，我们可以将新的训练结果(在可能性和 BIC 值方面)与先前的结果进行比较:
作者图片
我们看到，使用这个新模型，测试集上的可能性对于任何数量的聚类都是更好的，这意味着更有可能适合。我们现在的问题是，BIC 标准建议只选择两个集群。鉴于这些数据的性质，这似乎真的不合适。这就是我们触及 BIC 标准极限的地方。在这种模型化中，我们用 K 乘以 N 个单独的混合权重来代替 K 个全局混合权重。这意味着参数数量的惩罚现在在公式中的权重要大得多。
存在大量不同的标准来评估要选择的集群的数量。以下是我找到的一些:
- 似然比检测
- 阿凯克信息准则
- 基于自举的信息准则
- 基于交叉验证的信息准则
- 最小信息比率标准
- 信息复杂性标准
- 拉普拉斯近似法
- 贝叶斯信息标准(我们使用的)
- 拉普拉斯-大都会准则
- 拉普拉斯-经验准则
- 可逆跳跃法
- 最小消息长度原则
- 分类似然准则
- 归一化熵准则
- 综合分类标准
我确信还有其他的标准，它仍然是一个活跃的研究课题。选择最佳聚类数的新方法仍在出现。所以我们看到了这个主题的广度和复杂性。但是正如我之前所说的，没有什么能打败领域专家的判断。
无论如何，通过这种新的模型化，我们获得了上一节中选择的 2 个人的以下结果:
作者图片
作者图片
在 L1，892 户家庭的距离从 1.625 增加到 1.564，72 户家庭的距离从 0.647 增加到 0.530。现在对每个家庭进行同样的练习，我们可以记录获得的距离，并在散点图上进行对比:
作者图片
对角线下方的每个点对应于使用个性化模型预测距离较小的家庭。从上面的图中不一定明显，但我们对 61.57%的家庭进行了更好的预测。
所以最后，我们认为第二种模型化是一种更好的模型，因为它在测试集上给出了更好的预测性能。我们只是还没有找到正确评估集群数量的方法(虽然我可能会选择 30 个集群，就像我们对全局模型所做的那样)，我把它留给有兴趣的读者做练习。
关于这最后一点，你可以使用我的 github 上的代码(以及用于数据探索、模型选择和结果分析的笔记本)= >https://github.com/biarne-a/MNMM
关于模型的最终想法
这个模型可以预测一个人可能会购买哪些产品，但不能预测会购买多少或何时购买。多项式分布给出已购买商品的计数，但需要输入购物篮中已购买商品的总数。因此，理想情况下，我们需要另一个模型来预测个人在某一天会购买的商品总数。此外，为了对商店的访问率建模，我们可以使用泊松过程，我们还必须考虑季节性模式。
重要的一点是，在启发本文的论文中，作者使用 EM 算法来找到模型参数的最大后验概率 (MAP)估计，而我们找到的是 MLE 估计。这更符合贝叶斯哲学。这意味着他们声明了模型的参数α和β的先验(都是 Dirchlet 先验)。这种方法更好，因为它允许正则化模型。我们可以把它看作是，从对参数的合理猜测开始，我们根据我们所掌握的数据量来提炼这些值。对于个性化模型，我们从模型的全局估计开始。如果我们没有太多关于个人的数据，那么它的估计值将接近全球的估计值。为了这篇文章，我不想采用这种方法，因为它会使事情变得更加复杂(而且我还必须介绍 Dirichlet 分布和其他一些东西)。
最后的话
这是一段不平凡的旅程！如果你读到这里，这可能意味着你已经发现这很有趣，也许你在这个过程中学到了一些东西(至少我希望如此)。
无论如何，照顾好你自己和你爱的人！
名义数据的多项式模型
广义线性模型
在多项式建模之前，再看一下你的反应变量。
斯特凡诺·阿莱马尼在 Unsplash 上拍摄的照片
T 流行的多项逻辑回归被认为是二项式逻辑回归模型的扩展，以处理两个以上可能的离散结果。
然而，多项式逻辑回归并不是设计成一个通用的多类分类器，而是专门为名义多项式数据设计的。
注意，名义数据和序数数据是多项数据的两个主要类别。不同之处在于，名义多项式数据中的类别没有顺序，而有序多项式数据中的类别有顺序。
例如，如果我们的目标是区分 IRIS 数据集中的三类植物，我们需要将植物类别视为名义结果，因为植物类别中没有特定的顺序。然而，如果我们想将 NBA 决赛上半场结束时的比分预测为三类，“赢”、“输”或“平”，我们需要将其视为有序结果，因为这三类之间的成对距离不相同。
(a)名义数据和(b)顺序数据的例子
因此，在多项式建模之前，有必要弄清楚结果的类型。
在这篇文章中，我将简要地谈谈名义数据的多项式回归模型。希望对你的现实工作有所帮助。
多项式逻辑回归模型
如上所述，多项式逻辑回归是专门为名义数据设计的。这个想法与二进制数据的逻辑回归非常相似，即把属于某个类别的概率与预测值联系起来。
对于那些努力理解链接功能的人，你可以参考我以前的一个帖子了解一下。
设 Yi 是一个随机变量，可以落在类 1，2，…，J 中的一个。我们将 pij 定义为第 j 个类中的第 I 个变量。
所以，我们有
上面的公式是针对一般情况的，所以当 J=2 时，就变成了二进制数据的情况。
如果我们的观察总数为 ni ，那么多项式分布可以描述如下。
在多项式逻辑回归中，链接函数被定义为
在哪里
这样，我们将 J 类概率和1T8类概率之间的对数优势比与预测因子的线性组合联系起来。现在让我们看看多项式逻辑回归的真实数据和编码。
这个例子来自远方的书，描述了 1996 年美国大选的研究。响应变量包括三个类别，民主党、共和党和无党派。预测因素包括受访者的年龄、教育程度和收入群体。
# R code
> head(nes96)
## popul TVnews selfLR ClinLR DoleLR PID age educ income vote
## 1 0 7 extCon extLib Con strRep 36 HS $3Kminus Dole
## 2 190 1 sliLib sliLib sliCon weakDem 20 Coll $3Kminus Clinton
## 3 31 7 Lib Lib Con weakDem 24 BAdeg $3Kminus Clinton
## 4 83 4 sliLib Mod sliCon weakDem 28 BAdeg $3Kminus Clinton
## 5 640 7 sliCon Con Mod strDem 68 BAdeg $3Kminus Clinton
## 6 110 3 sliLib Mod Con weakDem 21 Coll $3Kminus Clinton
在对数据集进行一些预处理后，我们建立 R 中的多项式逻辑回归，如下所示。
# R codelibrary(nnet)
mulmod = multinom(sPID ~ age + educ + nincome, nes96)
其中“sPID”是响应变量，“年龄”、“教育程度”和“收入”分别对应于受访者的年龄、教育水平和收入。nes96 只是数据集名称。
然后我们检查拟合模型的概要。
# R codesummary(mulmod)
这产生了，
## Call:
## multinom(formula = sPID ~ age + educ + nincome, data = nes96)
##
## Coefficients:
## (Intercept) age educ.L educ.Q educ.C
## Independent -1.197260 0.0001534525 0.06351451 -0.1217038 0.1119542
## Republican -1.642656 0.0081943691 1.19413345 -1.2292869 0.1544575
## educ^4 educ^5 educ^6 nincome
## Independent -0.07657336 0.1360851 0.15427826 0.01623911
## Republican -0.02827297 -0.1221176 -0.03741389 0.01724679
##
## Std. Errors:
## (Intercept) age educ.L educ.Q educ.C educ^4
## Independent 0.3265951 0.005374592 0.4571884 0.4142859 0.3498491 0.2883031
## Republican 0.3312877 0.004902668 0.6502670 0.6041924 0.4866432 0.3605620
## educ^5 educ^6 nincome
## Independent 0.2494706 0.2171578 0.003108585
## Republican 0.2696036 0.2031859 0.002881745
##
## Residual Deviance: 1968.333
## AIC: 2004.333
模型摘要报告了估计的系数以及标准误差。输出与线性模型中的输出略有不同。
摘要中仅列出了“独立”和“共和党”的统计数据，因为此处“民主党”被用作基线类别，并且回归正在针对该基线类别对对数优势比进行建模。
您可能会注意到，模型中没有显示预测值显著性的指标。我们可以从两个方面来评价它们。
首先，我们可以用流行的 Z-score 来评估预测器的重要性。
# R code
z = summary(mulmod)$coefficients/summary(mulmod)$standard.errors
p = (1 - pnorm(abs(z), 0, 1))*2
这个过程易于实现，因为它有一个简化的正态分布假设，该假设适用于粗略估计。让我们看看 p 值。
## (Intercept) age educ.L educ.Q educ.C educ^4
## Independent 2.464850e-04 0.97722232 0.88951010 0.76893540 0.7489628 0.7905471
## Republican 7.107723e-07 0.09464069 0.06630235 0.04189165 0.7509449 0.9374990
## educ^5 educ^6 nincome
## Independent 0.5854128 0.4774294 1.751402e-07
## Republican 0.6505832 0.8539066 2.165977e-09
毫无疑问，收入似乎是一个强有力的预测因素，但并不是所有的教育变量都有意义。这也是使用 Z 分布来评估系数的缺点，这使得它很难解释。
更精确的方法是建立一个新的模型，减少预测因子的数量，然后检查可能性的变化。首先，让我们建立没有变量教育的模型。
# R code
mulmod_noedu = multinom(sPID ~ age + nincome, nes96)
然后，我们使用卡方分布来评估两个多项式模型之间的可能性变化。p 值可以计算如下。
# R code
pchisq(deviance(mulmod_noedu)-deviance(mulmod),mulmod$edf - mulmod_noedu$edf, lower.tail = F)
这产生了，
0.1819634
这表明变量'教育'相对于完整模型不显著。如果我们对变量' income '做同样的事情，我们会得到下面的结果。
# R code
mulmod_noinc = multinom(sPID ~ age + educ, nes96)
pchisq(deviance(mulmod_noinc)-deviance(mulmod),mulmod$edf - mulmod_noinc$edf, lower.tail = F)
这产生了，
1.267249e-10
这些结果表明，“收入”是完整模型中的一个重要预测因素。
该系数的解释应该是这样的:某个预测值的一个单位变化将导致目标类别与基线类别之间的对数优势比的 k 个单位变化(本例中为“民主党”)。这部分的细节我就不探讨了。
等级制还是非等级制？
在多项式建模之前，对响应变量的另一个非常重要的检查是响应结果是否具有层次性。
让我们看一个来自farage 的书的中枢神经系统疾病数据的例子。
data(cns)
head(cns)
产量，
## Area NoCNS An Sp Other Water Work
## 1 Cardiff 4091 5 9 5 110 NonManual
## 2 Newport 1515 1 7 0 100 NonManual
## 3 Swansea 2394 9 5 0 95 NonManual
## 4 GlamorganE 3163 9 14 3 42 NonManual
## 5 GlamorganW 1979 5 10 1 39 NonManual
## 6 GlamorganC 4838 11 12 2 161 NonManual
在这里，“NoCNS”是指没有中枢神经系统疾病，“An”是指无脑畸形，“Sp”是指脊柱裂，“其他”是指其他类型的中枢神经系统。“面积”、“水”和“工作”描述了家庭的特征。
如果我们想要使用家族的特征来模拟 CNS 状态，我们可以简单地对四个类别实施多项逻辑回归。
然而，我们可以看到，“an”、“Sp”和“其他”只是 CNS 的亚型，反应变量由健康个体(NoCNS)主导。在这种情况下，我们最好将响应变量视为分层变量，其中“CNS”和“NoCNS”形成二项式分布，“An”、“Sp”和“其他”在“CNS”类别内形成多项式分布。
让我们比较代码和结果。
让我们首先在“CNS”和“NoCNS”之间建立一个二项式逻辑回归。
# R code
cns$CNS = cns$An + cns$Sp + cns$Other
binom_mod = glm(cbind(CNS,NoCNS) ~ Water + Work, cns, family=binomial)
summary(binom_mod)
这产生了，
##
## Call:
## glm(formula = cbind(CNS, NoCNS) ~ Water + Work, family = binomial,
## data = cns)
##
## Deviance Residuals:
## Min 1Q Median 3Q Max
## -2.65570 -0.30179 -0.03131 0.57213 1.32998
##
## Coefficients:
## Estimate Std. Error z value Pr(>|z|)
## (Intercept) -4.4325803 0.0897889 -49.367 < 2e-16 ***
## Water -0.0032644 0.0009684 -3.371 0.000749 ***
## WorkNonManual -0.3390577 0.0970943 -3.492 0.000479 ***
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## (Dispersion parameter for binomial family taken to be 1)
##
## Null deviance: 41.047 on 15 degrees of freedom
## Residual deviance: 12.363 on 13 degrees of freedom
## AIC: 102.49
##
## Number of Fisher Scoring iterations: 4
我们可以发现“水”和“非体力劳动”都是预测中枢神经系统与否的重要变量。
然后，我们对中枢神经系统的亚型进行多项逻辑回归。
# R code
cns_mod = multinom(cbind(An,Sp,Other) ~ Water + Work, cns)
z = summary(cns_mod)$coefficients/summary(cns_mod)$standard.errors
p= (1 - pnorm(abs(z), 0, 1))*2
p
这产生了，
## (Intercept) Water WorkNonManual
## Sp 4.833577e-02 0.5234640 0.5791105
## Other 5.935107e-05 0.4511663 0.4052210
我们可以看到，无论是“水”还是“非人工”对于区分中枢神经系统的不同亚型都没有意义。
这些结果表明，水质和体力劳动确实对新生儿的中枢神经系统状况有影响，但它们都不能解释中枢神经系统的亚型。
但是，如果把所有东西都扔给一个四品类全模型，结果就不一样了。
# R code
full_mod = multinom(cbind(NoCNS, An, Sp, Other) ~ Water + Work, cns)
z = summary(full_mod)$coefficients/summary(full_mod)$standard.errors
p= (1 - pnorm(abs(z), 0, 1))*2
p
这表明，
## (Intercept) Water WorkNonManual
## An 0 0.066695285 0.02338312
## Sp 0 0.001835095 0.07077816
## Other 0 0.840643368 0.02348335
这一次，预测者在解释具有不同 p 值的 CNSs 亚型时显示出一些混合的结果。这两个变量不能预测中枢神经系统亚型的事实在完整模型中没有披露。
外卖食品
总之，我介绍了多项式回归模型及其应用场合。最重要的一点是在建模之前检查响应变量。
- 多项式逻辑回归只能应用于名义数据，而不能应用于有序数据。
- 具有潜在等级结构的响应变量应谨慎对待。将所有内容汇集到一个完整的模型中有时并不是最佳的。
参考
[## R 中如何使用多项式和序数 Logistic 回归？
引言我们大多数人对回归的了解有限。其中，线性回归和逻辑回归是我们的最爱…
www.analyticsvidhya.com](https://www.analyticsvidhya.com/blog/2016/02/multinomial-ordinal-logistic-regression/)
遥远的 Julian J. 用 R 扩展线性模型:广义线性、混合效应和非参数回归模型。CRC 出版社，2016。
https://archive.ics.uci.edu/ml/datasets/iris
Python 中 lightgbm 的多重插补
戴维·科瓦连科在 Unsplash 上拍摄的照片
缺失数据是数据科学中的一个常见问题，这往往会导致很多令人头疼的问题。有些算法根本处理不了。线性回归、支持向量机和神经网络都是算法的例子，这些算法需要巧妙的解决方法来使丢失的值变得可消化。其他算法，如梯度推进，对缺失值有很好的解决方案。然而，这并不意味着它们不会造成问题。
在几种情况下，缺失数据会导致预测偏差，即使在对缺失值进行了本机处理的模型中也是如此:
- 丢失的数据被覆盖，并且仅在推断时有时可用。这在漏斗建模中尤其常见，随着他们在漏斗中的深入，对客户的了解也越来越多。
- 导致丢失数据更改的机制—例如网站上的新问题、新供应商等。如果机制与您最终想要建模的目标相关，这尤其是一个问题。
如果我们能知道那些丢失的值实际上是什么，并使用它们就好了。我们不能。但是我们可以做下一个最好的事情:通过链式方程(小鼠)用多重插补来估计它们的值:
图片来自 miceforest Github
MICE 算法
链式方程的多重插补，也称为“完全条件说明”，定义如下:
作者上传
对所需数量的数据集重复这一过程。第 8 行提到的方法，均值匹配，用于产生更像原始数据的插补。这个想法在 Stef van Buuren 的在线书籍中有深入的探讨。在 miceforest Github 页面上也可以找到均值匹配影响的可再现示例。
插补收敛有时需要多次迭代。有几个因素会影响实现收敛所需的迭代次数，例如缺失数据的类型、数据集中的信息密度以及用于估算数据的模型。
从技术上讲，任何能够进行推理的预测模型都可以用于小鼠。在本文中，我们用 miceforest Python 库估算一个数据集，该库默认使用 lightgbm 随机森林(尽管这是可以改变的)。随机森林很适合 MICE 算法，原因有几个:
- 不需要太多的超参数调整
- 轻松处理数据中的非线性关系
- 能便宜地回报 OOB 的表现
- 是可以并行化的
- 可以返回特征对诊断的重要性
实际例子
让我们加载我们的包和数据。我们使用从 sklearn 导入的虹膜数据集:
import miceforest as mf
from sklearn.datasets import load_iris
import pandas as pd
# Load and format data
iris = pd.concat(load_iris(as_frame=True,return_X_y=True),axis=1)
iris.rename(columns = {'target':'species'}, inplace = True)
iris['species'] = iris['species'].astype('category')
# Introduce missing values
iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991)
我们只需要创建一个 MultipleImputedKernel 并执行几次鼠标迭代:
# Create kernels.
kernel = mf.ImputationKernel(
data=iris_amp,
save_all_iterations=True,
random_state=1991
)
# Run the MICE algorithm for 3 iterations on each of the datasets
kernel.mice(3,verbose=True)
我们所做的是用不同的估算值创建 5 个独立的数据集。我们永远无法确定原始数据是什么，但是如果我们不同的数据集都得出相似的估算值，我们可以说我们对估算很有信心。让我们来看看数据集之间估算值的相关性:
kernel.plot_correlations(wspace=0.4,hspace=0.5)
作者上传
每个点代表两个数据集之间估算值的相关性。数据集的每个组合都包含在图表中。如果估算值之间的相关性很低，这意味着我们没有很大的信心估算值。看起来我们的模型在花瓣长度和花瓣宽度的插补上非常一致。如果我们运行更多的迭代，我们也许能够得到更好的萼片长度和萼片宽度的结果。
输入新数据
链式随机森林的多重插补可能需要很长时间，尤其是如果我们要插补的数据集很大。如果我们想在生产中使用这种方法呢？事实证明，我们可以保存在原始 MICE 过程中拟合的模型，并使用它们来估算新的数据集:
# Our new dataset
new_data = iris_amp.iloc[range(50)]# Make a multiple imputed dataset with our new data
new_data_imputed = kernel.impute_new_data(new_data)# Return a completed dataset
new_completed_data = new_data_imputed.complete_data(0)
miceforest 在新数据上重新创建原始过程的流程，而无需在每次迭代时更新模型。这节省了大量时间。我们还可以查询这个新数据集，以查看相关性是否收敛，甚至绘制插补的分布:
new_data_imputed.plot_imputed_distributions(wspace=0.35,hspace=0.4)
作者上传
建立置信区间
现在我们已经有了 5 个数据集，您可能会尝试使用平均估算值来创建一个单一的最终数据集，并完成它。如果您正在执行传统的统计分析，不建议这样做——具有更多方差的插补将趋向于向平均值回归，并且总体插补的方差将降低，导致最终数据集的行为与原始数据集不同。最好执行多重分析，并跟踪这些多重分析产生的差异。
由于我们有 5 个不同的数据集，我们现在可以训练多个模型，并根据结果建立置信区间。这里，我们在“萼片长度(cm)”上训练 5 个不同的线性回归模型，并使用从我们的 5 个模型获得的截距的平均值和方差建立截距项分布的假设:
from sklearn.linear_model import LinearRegression
# For each imputed dataset, train a linear regression
# on 'sepal length (cm)'
intercepts = []
target = 'sepal length (cm)'
for d in range(kernel.dataset_count()):
comp_dat = kernel.complete_data(d)
comp_dat = pd.get_dummies(comp_dat)
X, y = comp_dat.drop(target,1), comp_dat[target]
model = LinearRegression()
model.fit(X,y)
intercepts.append(model.intercept_)
# Load packages for plotting
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
# Make plot.
avg_intercept = round(np.mean(intercepts),2)
var_intercept = round(np.var(intercepts),4)
x_axis = np.arange(
avg_intercept - 3 * var_intercept,
avg_intercept + 3 * var_intercept,
0.0001
)
plt.plot(
x_axis,
norm.pdf(x_axis,avg_intercept,var_intercept)
)
plt.title(f"""
Assumed Distribution of Intercept Term
n=5, mean = {avg_intercept}, variance = {var_intercept}
"""
)
作者上传
如果我们没有丢失值，我们不知道真正的截距项是什么，但是我们现在可以(弱)声明如果我们没有丢失数据，截距可能是什么。如果我们想在这种情况下增加 n，我们需要添加更多的数据集。
可以对线性模型中的系数以及每个样本的实际预测运行类似的置信区间。缺失数据越多的样本在最终模型中的预测偏差越大，因为数据集之间的估算值差异越大。
最后
我们已经看到了 MICE 算法是如何工作的，以及它如何与随机森林相结合来精确地估算缺失数据。我们还通过一个简单的例子说明了如何使用多个估算数据集来帮助我们建立一个关于模型参数分布的假设。
多元线性回归
线性回归模型开发过程概述。
介绍
本文的目的是总结使用基本示例数据集创建多元线性回归模型所需采取的步骤。根据解释性和描述性分析，流程中可能包括许多不同的步骤。因此，本文可能不会通过示例详细介绍线性回归的某些方面，例如使用山脊、套索或弹性网或对数变换进行正则化。说到这里，我会尽我所能的解释从数据转换、探索到模型选择和评估的所有可能的步骤。这个想法是，当我们有一个可以通过创建线性回归模型来解决的业务问题时，我们可以参考这篇文章来涵盖这个过程中的大多数步骤。
我们将要使用的数据集是众所周知的，并且已经在统计学和数据科学的学术项目中被引用。对这个数据集最流行的引用来自电影《摇钱树》。它为我们提供了棒球队在给定年份的表现。用于分析的问题陈述是“我们能否用团队表现的每个记录的给定属性来预测团队的获胜次数？”
每个变量的简短描述如下:
- *索引:标识变量(不使用)
**TARGET_WINS:获胜次数
**TEAM_BATTING_H:击球手的安打数(1B、2B、3B、HR)
-
*击球队:击球手双打(2B)
-
*队:击球手的三连击(3B)
**TEAM_BATTING_HR:击球手的本垒打(4B)
**TEAM_BATTING_BB:击球手保送
**TEAM_BATTING_HBP:击球手投球命中(获得免费垒位)
**TEAM_BATTING_SO:击球手三振出局
**TEAM_BASERUN_SB:盗垒
**TEAM_BASERUN_CS:偷窃被抓
**TEAM_FIELDING_E:错误
**TEAM_FIELDING_DP:双杀
- *团队 _ 投球 _BB:允许保送
**TEAM_PITCHING_H:允许击中
**TEAM_PITCHING_HR:允许本垒打
**TEAM_PITCHING_SO:投手三振出局
让我们从导入开始，加载数据集、包和一些描述性分析。
基本的描述性统计数据让我们对每个团队的表现有了一些了解。然而，我们需要从数据集中获得的最重要的统计信息是:缺失值、每个变量的分布、变量之间的相关性、每个分布的偏斜度以及每个变量中的异常值。有了这些认识，我们将转换数据集，并确保满足线性回归的条件。
首先，让我们删除索引列，并查找每个变量的 missing_values。
每个变量的数据类型看起来很准确，不需要修改。当我们查看每个变量的缺失值的百分比时，前两个变量是 TEAM_BASERUN_CS 和 TEAM_BATTING_HBP。当我们有超过 80%的缺失数据时，处理缺失值的最常见方法是丢弃，并且不将该特定变量包括到模型中。因此，我们将在数据清理阶段删除 TEAM_BATTING_HBP。至于其余的变量有缺失值，我们将用该特定变量的平均值来代替它们。
让我们看看解释变量和响应变量之间的相关性。
基于相关矩阵，我们可以看到棒球队与我们的响应变量 TARGET_WINS 相关的最高属性是击球手的安打和击球手的保送。(球队 _ 击球 _H，球队 _ 击球 _2B)
我们还看到，Team_Batting_H 和 Team_Batting_2B、Team_Pitching_B 和 TEAM_FIELDING_E 之间有很强的相关性。我们将在模型创建时考虑这些发现，因为共线性可能会使模型估计变得复杂。我们希望解释变量相互独立。我们将尽量避免添加相互之间高度相关的解释变量。
如果我们是一个棒球迷，我们可以做的一件有趣的事情是根据变量的动作将变量分成不同的类别。所有击球相关变量可被捆绑在“击球”下，跑垒变量被捆绑在“跑垒”下，投球相关变量被捆绑在“投球”下，场相关变量如错误被捆绑在“防守”下。话虽如此，这并不是线性回归的一个必要步骤，但在这种情况下，这是适用的，也是有趣的。
让我们看看每个变量的分布。
我们可以看到，变量 TARGET_WINS、TEAM_BATTING_H、TEAM_BATTING_2B、TEAM_BATTING_BB 和 TEAM_BASERUN_CS 是正态分布的。TEAM_BATTING_HR 则是双峰的。
TEAM_BASERUN_SB 右偏，TEAM_BATTING_SO 双峰。
TEAM_BATTING_HBP 似乎是正态分布的，但是我们不应该忘记我们在这个变量中有很多缺失值。
我们可以从分布中看到每个变量的偏斜度，但是让我们用一个数字来看变量的偏斜度。
基于此，我们可以看到最偏斜的变量是 TEAM_PITCHING_SO。我们将在数据准备部分纠正有偏差的变量。
当我们创建线性回归模型时，我们寻找具有最小平方和的拟合线，即具有最小残差平方和的小残差。在不涉及计算数学的情况下，残差是预测值和实际值之间的差值。
我们还可以从分布的角度单独观察每个变量，并查看异常值。
如方框图所示，“TEAM_BASERUN_SB”、“TEAM_BASERUN_CS”、“TEAM_PITCHING_H”、“TEAM_PITCHING_BB”、“TEAM_PITCHING_SO”和“TEAM_FIELDING_E”都具有大量异常值。我们将在数据清理和准备部分删除这些异常值。
创建线性回归线和模型的想法很简单。我们创建一个线性模型，给出每个变量的截距和斜率。我们进一步查看和解释模型摘要，以评估和改进模型。在我看来，具有挑战性的部分是确保收集的数据集满足最小二乘法(线性回归)的条件。这些条件是线性、接近正态残差和恒定可变性。尽管我们将着眼于这些条件来进行分析，但我们不会单独详细讨论这些条件。
让我们看看残差，以确保满足线性、正态分布和恒定可变性条件。
当我们看残差图时，我们看到即使残差不是完全正态分布，它们也接近正态分布。解释变量和响应变量之间存在线性关系。
让我们通过创建一个简单的模型来详细了解这一点。
我们创建的简单模型可以解释 96%的可变性。击球手每多击一次垒打，该队获胜，该队获胜次数预计增加 0.0549 次。
由于与 python 相比，R 更多地用于线性建模中的统计分析，因此通过使用 R，我们可以绘制摘要、绘图(模型)并获得我们需要的所有残差图，以便检查条件，但是在 python 中，我们需要创建自己的函数和对象来创建相同的残差图。
让我们看看我们是否能做到。
基于解释变量 TEAM_BATTING_H 和响应变量 TARGET_WINS，残差接近正态分布，它们之间存在线性关系，最小二乘线周围的可变性大致恒定。(又名同质性)。
当我们观察每个变量的分布时，有些点远离点云。这些都是离群值。水平远离中心的异常值是影响回归斜率的高杠杆点。这些都是有影响的点。
我们可以进一步开始清理和准备我们的数据集。
数据清理和准备
让我们从处理缺失值开始，然后我们可以移除数据集中的异常值以进行模型开发。
模型开发和评估
我们观察了每个变量的分布、偏斜度和缺失值。我们假设观察值是随机的。我们还检查了线性回归条件，确保误差项(e)或又称残差呈正态分布，变量之间线性独立，方差恒定(无异方差)且残差独立。我们处理了训练数据的缺失值和偏斜度。
在我们开始构建模型之前，我想简单提一下特征选择过程。在我们的分析和数据集的性质，我们可能会处理许多不同的解释变量。我们可能不希望使用所有这些变量，而是希望选择观察的某些特征来获得最佳模型。在这种情况下，我们可以使用向前的步骤和向后的特征选择方法。本质上，我们正在寻找能够为目标变量提供最佳 p 值的特征。
在 R 中，我们可以简单地使用逐步函数，这将为我们提供最有效的功能。在 python 中，我们可以定义一个函数，这个函数可以给我们提供使用前进和后退的特性。下面是一个使用当前数据集的示例。
让我们开始创建一个使用所有变量的模型。
在此模型中，R 平方较低(0.969)。我们还可以看到标准误差增加了。
在这个模型中，我们有 5 个 p 值非常低的重要变量。r 平方较小，但几乎与第一个模型一样高。我们还看到，与第一个模型相比，标准误差要合理得多。
该模型在标准误差和 F 统计方面类似于模型 3，但是它具有更小的 r 平方。
尽管我们只使用了模型 3 中的 5 个重要变量，但 r 平方值低于模型 3。
当我们评估模型时，我们必须考虑线性模型的偏差和方差。如果我们用数据完美地(或接近完美地)拟合线性线，用复杂的线性模型，我们在增加方差(过度拟合)。如果我们反其道而行之，用一个非常简单的模型，线性线勉强符合数据，我们就增加了偏差(拟合不足)。我们希望创建并选择一个模型，在该模型中，预测可以被一般化，并与测试数据集一起工作。
如果我们的模型中有很高的方差，我们可以应用一些减少方差的策略。例如，在我们的模型 1 中，R 平方非常高，这表明接近完美拟合和高方差。
为了减少差异，我们可以使用交叉验证将数据集分成测试和训练数据集。在我们的例子中，我们被提供了两个独立的数据集(训练和测试),这是不适用的。然而，在一些用例中，我们需要分成训练和测试数据集。交叉验证所做的是，它不是按我们定义的比例(例如 80%和 20%)分割数据集，而是创建大小相等的数据子集，并在所有子集上迭代训练和测试，保留一个子集作为测试数据。我们可以使用 10 折、5 折、3 折或省去一个交叉验证。
另一个减少方差的策略是收缩(又名)惩罚。有 3 种主要的已知调节方法。岭回归、套索和弹性网回归。我们不会深入讨论这些方法的细节，但我们的想法是对模型应用一个惩罚，在偏差和方差之间进行权衡。
基于我们创建的五个模型和我们的评估，模型 3 似乎是最有效的模型。我们当然可以应用正则化(弹性网或岭回归)并减少方差，但是我们现在将保持原样。
模型预测法
最后，我们可以将我们的线性回归模型应用于测试数据集，以查看我们的预测。
结论
总结创建线性回归模型的步骤，
1-查看描述性统计数据
2-查看缺失值。
3-看看变量的分布。
4-查看变量的相关性。
5-查看变量的偏斜度。
6-检查线性回归假设(查看残差)。
7-看看异常值。
8-移除异常值并进行必要的数据转换。(我们不需要做任何变换来获得正态残差分布，但是在一些用例中，我们可能需要对解释变量和响应变量进行变换(如对数变换)。如果有分类变量，我们需要把它们转换成数值变量作为哑变量。
9-创建多个模型(我们可以使用反向消除进行特征选择，或者在每个模型中尝试不同的特征。特征选择的一个重要方面是，我们需要从最大数量的特征开始，以便每个模型中使用的特征相互嵌套。)
10-查看偏差和方差(过拟合和欠拟合)
11-如果需要，应用方差减少策略。(脊线、弹性网、套索、CV)
12-评估、选择模型并应用预测。
当我们比较模型的 r 平方和标准误差时，模型 3 是最好的模型。这个模型将比其他模型更好地预测棒球队的目标胜率。我们肯定可以应用正则化(又名收缩、惩罚)来使它更稳定，更不容易过度拟合和高方差。
选择的模型是 OLS 模型-3，由于改进的 F-统计，正可变系数和低标准误差。
对于模型 3 和 4，选择变量仅仅是为了测试仅进攻型变量如何影响模型，以及仅防守型变量如何影响模型。基于每个模型的系数，第三个模型从每个类别模型中取最高的系数。
进攻方面，两个最高的是 HR 和 Triples。这在直觉上是有意义的，因为 HR 和三分是击球手击球时可以达到的两个最高目标，因此这些类别中的总分越高，得分越高，帮助球队获胜。在防守方面，两个最高的系数是安打和保送。这也是有道理的，因为作为一名投手，我们想要做的是限制击球手上垒的次数，无论是击球还是保送。除非这是一个失误，如果击球手没有击中或保送，那么结果将是出局，这实质上限制了对方球队得分的数量。
多元线性回归
一个完整的研究—模型解释→假设检验→特征选择
线性回归是最受欢迎和讨论最多的模型之一，当然是深入机器学习(ML)的门户。这种简单、直接的建模方法值得作为您进入 ML 的第一步来学习。
在继续之前，让我们回忆一下，线性回归可以大致分为两类。
- 简单线性回归:这是线性回归的最简单形式，当输出变量只有一个输入变量时使用。
如果你是回归的新手，那么我强烈建议你首先从下面的链接中阅读简单的线性回归，在那里你会理解背后的数学原理以及使用有趣的数据和亲自动手编码的方法。
关于简单线性回归你需要知道的一切
towardsdatascience.com](/simple-linear-regression-35b3d940950e)
- 多元线性回归:是线性回归的一种形式，当有两个或两个以上的预测因子时使用。
我们将看到多个输入变量如何一起影响输出变量，同时也了解计算如何不同于简单的 LR 模型。我们还将使用 Python 构建一个回归模型。
最后，我们将更深入地学习线性回归，并将学习诸如共线性、假设检验、特征选择等等。
现在有人可能会想，我们也可以使用简单的线性回归来分别研究所有独立变量的输出。那会让生活变得容易得多，对吗？
不，不会的。
为什么要多元线性回归？
“从多个输入变量中预测结果。咄！”。但是，就这样吗？好吧，保持这种想法。
考虑一下这个，假设你要估算你想买的某套房子的价格。你知道建筑面积，房子的年龄，离你工作地点的距离，这个地方的犯罪率等等。
现在，这些因素中的一些会积极地影响房价。例如面积越大，价格越高。另一方面，距离工作场所的距离和犯罪率等因素会对你对房子的估计产生负面影响(除非你是一个对机器学习感兴趣的有钱罪犯，正在寻找藏身之处，是的，我不这么认为)。
简单线性回归的缺点 →当我们只对一个感兴趣时，运行单独的简单线性回归会导致不同的结果。除此之外，可能还有一个输入变量本身与其他一些预测因素相关或依赖于其他一些预测因素。这会导致错误的预测和不令人满意的结果。
这就是多元线性回归发挥作用的地方。
数学上…
这里， Y 为输出变量， X 项为对应的输入变量。注意，这个方程只是简单线性回归的扩展，每个预测因子都有一个对应的斜率系数(【β】)。
第一个 β 项( βo )是截距常数，是没有所有预测值时 Y 的值(即当所有 X 项都为 0 时)。在给定的回归问题中，它可能有意义，也可能没有意义。它通常在那里给回归的线/平面一个相关的推动。
现在让我们借助一些数据来理解这一点。
可视化数据
我们将使用南加州大学马歇尔商学院网站上的广告数据。你可以在这里下载。
如果你看过我关于简单线性回归的帖子，那么你对这个数据已经很熟悉了。如果你没有，让我给你一个简短的介绍。
广告数据集包括一种产品在 200 个不同市场的销售额，以及三种不同媒体的广告预算:电视、广播和报纸。它看起来是这样的:
销售额(1000 台)与广告预算(1000 美元)
数据的第一行表示电视、广播和报纸的广告预算分别为 230.1k 美元、37.8k 美元和 69.2k 美元，相应的售出数量为 22.1k(或 22，100)。
在简单的线性回归中，我们可以看到在没有其他两种媒体的情况下，每种广告媒体是如何影响销售的。然而，在实践中，这三者可能会共同影响净销售额。我们没有考虑这些媒体对销售的综合影响。
多元线性回归通过在一个表达式中考虑所有变量来解决这个问题。因此，我们的线性回归模型现在可以表示为:
求这些常数的值(β))就是回归模型通过最小化误差函数，拟合最佳直线或超平面(取决于输入变量的数量)所做的事情。
这是通过最小化残差平方和 (RSS)来实现的，残差平方和是通过对实际结果和预测结果之间的差求平方来获得的。
普通最小二乘法
因为这种方法求最小平方和，所以也被称为普通最小二乘法(OLS 法)。在 Python 中，有两种实现 OLS 算法的主要方法。
- SciKit Learn: 只需从 Sklearn 包中导入线性回归模块，并在数据上拟合模型。这个方法非常简单，你可以在下面看到如何使用它。
from sklearn.linear_model import LinearRegressionmodel = LinearRegression()
model.fit(data.drop('sales', axis=1), data.sales)
- StatsModels: 另一种方法是使用 StatsModels 包来实现 OLS。Statsmodels 是一个 Python 包，允许对数据执行各种统计测试。我们将在这里使用它，以便您可以了解这个伟大的 Python 库，因为它将在后面的章节中对我们有所帮助。
建立模型并解释系数
**# Importing required libraries** import pandas as pdimport statsmodels.formula.api as sm**# Loading data - You can give the complete path to your data here**
ad = pd.read_csv("Advertising.csv")**# Fitting the OLS on data**
model = sm.ols('sales ~ TV + radio + newspaper', ad).fit()
print(model.params)
您应该得到以下输出。
Intercept 2.938889
TV 0.045765
radio 0.188530
newspaper -0.001037
我鼓励您也使用 Scikit Learn 运行回归模型，并使用model . coef _&model . intercept _ 找到上述参数。你看到了同样的结果吗？
既然有了这些价值观，又该如何解读呢？方法如下:
- 如果我们固定电视和报纸的预算，那么增加 1000 美元的广播预算将导致销售额增加约 189 台(0.189*1000)。
- 类似地，通过修正广播和报纸，我们推断电视预算每增加 1000 美元，大约会增加 46 个产品单位。
- 然而，对于报纸预算来说，由于这个系数可以忽略不计(接近于零)，很明显报纸没有影响销售。事实上，它在零的负侧(-0.001)，如果幅度足够大，可能意味着该代理导致销售下降。但是我们不能用如此微不足道的价值来做这样的推论。
我在这里告诉你一件有趣的事。如果我们运行简单线性回归，仅使用报纸预算对比销售额，我们将观察到约为 0.055 的系数值，这与我们在上面看到的相比非常显著。这是为什么呢？
共线性
为了理解这一点，让我们看看这些变量是如何相互关联的。
ad.corr()
广告数据的相关矩阵
让我们用热图来形象化这些数字。
import matplotlib.pyplot as plt
%matplotlib inline> plt.imshow(ad.corr(), cmap=plt.cm.GnBu, interpolation='nearest',data=True)
> plt.colorbar()
> tick_marks = [i for i in range(len(ad.columns))]
> plt.xticks(tick_marks, data.columns, rotation=45)
> plt.yticks(tick_marks, data.columns, rotation=45)
广告数据的关联热图
这里，深色方块代表强相关性(接近 1)，而浅色方块代表弱相关性(接近 0)。就是这个原因，所有的对角线都是深蓝色的，作为一个变量与自身完全相关。
这里值得注意的是报纸和广播的相关性是 0.35。这表明了报纸和广播预算之间的公平关系。因此，可以推断出，当一种产品的广播预算增加时，也有在报纸上花更多钱的趋势。
这被称为 共线性 ，是指两个或多个输入变量线性相关的情况。
因此，即使多元回归模型显示对报纸的销售没有影响，简单回归模型仍然有影响，因为多重共线性和其他输入变量的缺乏。
销售和广播→可能的原因
报纸和广播→多重共线性
销售和报纸→传递相关性
好吧！我们理解线性回归，我们建立模型，甚至解释结果。到目前为止，我们所学的是线性回归的基础。然而，在处理现实世界的问题时，我们通常会超越这一点，对我们的模型进行统计分析，并在需要时进行必要的更改。
预测值的假设检验
运行多元线性回归时应该回答的一个基本问题是，是否至少有一个预测因子对预测输出有用。
我们看到电视、广播和报纸这三个预测因素与销售有不同程度的线性关系。但是，如果这种关系只是偶然的，并且由于任何预测因素而对销售没有实际影响，那该怎么办呢？
该模型只能给我们一些数字，以便在响应变量和预测变量之间建立足够密切的线性关系。但是，它不能证明这些关系的可信度。
为了获得一些信心，我们从统计学中获得帮助，做一些被称为 假设检验的事情。 我们首先形成一个 零假设 和一个相应的 替代假设 。
由于我们的目标是找出是否至少有一个预测因子对预测输出有用，所以我们希望至少有一个系数(不是截距)非零，这不仅仅是随机的，而是由于实际原因。
为了做到这一点，我们首先形成一个零假设:所有的系数都等于零。
多元线性回归的一般零假设
广告数据的零假设
因此，另一个假设是:至少有一个系数不为零。通过寻找强有力的统计证据来拒绝零假设，从而证明了这一点。
替代假设
使用 F 统计量进行假设检验。 这个统计量的公式包含残差平方和(RSS)和总平方和(TSS)，我们不必担心，因为 Statsmodels 包会处理这些。上面我们拟合的 OLS 模型摘要包含了所有此类统计信息的摘要，可以通过下面简单的代码行获得:
print(model.summary2())
如果 F 统计量的值等于或非常接近 1，那么结果是有利于零假设的，我们无法拒绝它。
但是正如我们可以看到的，F 统计量比 1 大很多倍，因此提供了反对零假设(所有系数都为零)的有力证据。因此，我们拒绝零假设，并且确信至少有一个预测因子在预测输出时是有用的。
注意，当预测值( p )的数量很大时，或者如果 p 大于数据样本的数量( n )时，F 统计量不适用。
因此，我们可以说，三个广告代理商中至少有一个对预测销售是有用的。
但是哪一个或者哪两个重要呢？它们都很重要吗？为此，我们将执行 特征选择或变量选择。 现在，一种方法是尝试所有可能的组合，即
- 只有电视
- 只有收音机
- 只有报纸
- 电视和广播
- 电视和报纸
- 广播和报纸
- 电视、广播和报纸
在这里，尝试所有 7 种组合看起来仍然可行，但如果有更多的预测因素，组合的数量将呈指数增长。例如，在我们的案例研究中只增加一个预测因子，总的组合将变成 15 个。想象一下有十几个预测者。
因此，我们需要更有效的方法来执行特征选择。
特征选择
进行特征选择的两种最流行的方法是:
- 正向选择:我们从一个没有任何预测器，只有截距项的模型开始。然后，我们对每个预测值进行简单的线性回归，以找到最佳表现(最低 RSS)。然后，我们向它添加另一个变量，并通过计算最低 RSS(残差平方和)再次检查最佳的 2 变量组合。之后，检查最佳的三变量组合，依此类推。当满足某个停止规则时，停止该方法。
- 反向选择:我们从模型中的所有变量开始，去掉统计意义最小的变量(更大的 p 值:查看上面的模型摘要，找出变量的 p 值)。重复这一过程，直到达到停止规则。例如，当模型分数没有进一步提高时，我们可以停止。
在这篇文章中，我将带你了解正向选择方法。首先，让我们了解如何选择或拒绝添加的变量。
在每次添加之后，我们将使用 2 个度量来评估我们的新模型: RSS 和 R 。
我们已经熟悉了 RSS，它是残差平方和，通过对实际输出和预测结果之间的差值求平方来计算。这应该是模型性能良好的最低要求。
r 是模型解释数据差异的程度的量度。从数学上讲，它是实际结果和预测结果之间相关性的平方。r 接近 1 表明模型是好的，并且很好地解释了数据中的差异。接近零的值表示模型不佳。
幸运的是，它是由 Statsmodels 中的 OLS 模块为我们计算出来的。让我们开始吧。
**# Defining a function to evaluate a model**
def evaluateModel(model):
print("RSS = ", ((ad.sales - model.predict())**2).sum())
print("R2 = ", model.rsquared)
我们先从电视开始，一个一个的评估单个预测器的模型。
**# For TV**
model_TV = sm.ols('sales ~ TV', ad).fit()
evaluateModel(model_TV)
r^2 = 0.605831313512
19986.866686666667
**# For radio**
model_radio = sm.ols('sales ~ radio', ad).fit()
evaluateModel(model_radio)
r^2 = 0。46860 . 86686868686
**# For newspaper**
model_newspaper = sm.ols('sales ~ newspaper', ad).fit()
evaluateModel(model_newspaper)
r^2 = 0.00000000001
我们发现，在所有模型中，model_TV 的 RSS 最小，R 值最大。因此，我们选择 model_TV 作为我们前进的基础模型。
现在，我们将逐个添加收音机和报纸，并检查新值。
**# For TV & radio** model_TV_radio = sm.ols('sales ~ TV + radio', ad).fit()
evaluateModel(model_TV_radio)
rss =，76184。18667 . 868686868667
我们可以看到，我们的价值观有了巨大的提高。与 model_TV 相比，RSS 下降，R 进一步增加。这是个好兆头。现在让我们看看电视和报纸也是如此。
**# For TV & newspaper** model_TV_radio = sm.ols('sales ~ TV + newspaper', ad).fit()
evaluateModel(model_TV_newspaper)
r^2 = 0。19860 . 9868275。19867 . 888686868667
通过增加报纸，价值也有所提高，但没有收音机提高得多。因此，在这一步，我们将继续使用电视和广播模型，并在将报纸添加到该模型时观察差异。
**# For TV, radio & newspaper** model_all = sm.ols('sales ~ TV + radio + newspaper', ad).fit()
evaluateModel(model_all)
r^2 = 0。18960 . 866868686867
这些值没有任何显著的提高。因此，当务之急是不要添加报纸，并最终确定以电视和广播为选择功能的模式。
因此，我们的最终模型可以表示如下:
在 3D 图中绘制变量 TV、radio 和 sales，我们可以直观地看到我们的模型如何将回归平面拟合到数据中。
3D 绘图了解回归平面。图片由 Sangeet Aggarwal 提供
多元线性回归就是这样。你可以在这里找到这篇文章后面的完整代码。我希望你在阅读和学习中过得愉快。欲知详情，敬请关注。
如果你是数据科学和机器学习的新手，不知道从哪里开始你的旅程，请查看下面的链接，在那里我提到了学习数据科学的一步一步的方法，有很多资源可供你选择。
作为一个完全的初学者如何步入数据科学
towardsdatascience.com](/data-science-from-scratch-4343d63c1c66)
等不及了？如果你想一头扎进一门课程，请点击下面的链接查看适合你的数据科学职业轨迹。
使用 DataCamp 的视频教程&编码，按照您自己的步调，在您的浏览器中舒适地学习数据科学
www.datacamp.com](https://www.datacamp.com/?tap_a=5644-dce66f&tap_s=910084-843f05&utm_medium=affiliate&utm_source=sangeetaggarwal)
用于制造分析的多元线性回归
安特·罗泽茨基在 Unsplash 上的照片
关于如何找到生产流程中最重要因素的案例研究
回归是测量自变量/预测变量与其因变量/目标变量之间关系的数学方法之一。
回归广泛用于至少两个主要目的。首先，回归通常被用作预测或预报工具。其次，在某些情况下，回归可以用作数据分析中的分析方法。在本文中，我们将使用回归作为次要目的，并深入了解回归模型如何用于分析过去的事件，而不是预测未来的事件。
多元线性回归是最简单的工具之一，可用于分析因变量和多个自变量/预测变量。这种回归经常被使用，因为现实中的一些过程不仅仅是由一个因素建立的，而是其他几个因素也参与到每一个活动中。
图一。多元线性回归公式
线性回归公式的斜率也可以解释为自变量 与其因变量之间的线性关系强度。基于这个定义，我们可以轻松地说，自变量的斜率值越高，这个变量对因变量的影响就越显著。
这将是我们分析和确定哪个因素在我们的制造业案例中影响最大的基础。
案例研究:
分析原材料对生产质量的影响
案例定义:
公司“P”生产一种需要满足某些质量要求的产品；基本要求之一是它应该具有小于 30 的缺陷值。为了生产这种产品，公司“P”使用三种原料；材料 A、材料 B 和材料 C。这些材料之间的成分为 0-10 % A、0-10% B 和 80-100% C 。
根据理论，由于这些原材料的清洁度，缺陷值总是存在的。公司唯一能做的就是把缺陷值压制在最大限值以下。
与 2019 年相比，2020 年每件产品的平均缺陷值有所增加，并开始接近我们的最大限制(30)，这是我们不希望发生的。公司不确定是哪种材料导致了这个问题。为了回答这个问题，我们将进行回归分析，以了解哪种材料对这个问题负有最大责任。
图二。2020 缺陷值条件
数据准备
图二。生产数据集
功能解释:
- 月份:制造物料的期间
- Production_No:产品的批号
- a、B、C:原材料投入(吨)
- 缺陷值:质量状态，应低于 30
利用这些数据，我们将进行回归计算，找出每种材料的斜率。考虑到原材料成分(10:10:80)，斜率值将作为加权值重新计算。该加权值用于查找哪种材料对该问题负有最大责任。
回归建模
我们将使用多元线性回归方法，并使用以下公式作为我们的数学线性模型:
图三。生产数据的数学模型
这种情况下的数学模型与其他回归模型的不同之处在于，我们假设“没有其他因素影响缺陷值”，这就是为什么我们从我们的模型中移除截距变量，并且仅从原材料中预期缺陷值。
图 4。斜率回归结果
这些代码将返回每个时间段的斜率，在本例中，2019 年全年和 2020 年 1 月至 5 月。
由于我们需要将这些值重新计算为它们的加权值，并且我们还希望获得数据框，以便更容易地可视化和分析结果，为此，我们需要添加以下代码，并获得我们想要的结果:
图五。结果数据帧
可视化与分析
图五。加权斜率值图表
那么，如果我们看到上面的图表，哪种材料的影响最大？根据图表，可以说材料 C 对缺陷值的影响大大增加了。2020 年五分之四的材料 A 加权值高于 2019 年，其峰值位于 2020 年 4 月。
有了这些信息，公司就可以准备对策。
此问题对策的一些示例如下:
- 由于责任最大的是物料 C，公司可以在 2020 年评估采购物料 C 的质量。
- 努力减少材料 C 的用量，并增加材料 B 的用量。
- 在生产开始前严格监控材料质量。
本案例研究到此结束，本案例是基于一个制造业的实际问题编写的，使用回归来支持决策也是解决问题的真正方法。每个人和每个公司都可以有自己的方法来找到每个问题的解决方案，只要能解决问题就好。使用回归斜率的方法仅来自解决现实世界中的工业案例的许多方法。
使用 Python 的多元线性回归模型:机器学习
学习如何使用 python 中的 Jupyter notebook 在机器学习中构建基本的多元线性回归模型
图片由来自 Pixabay 的 Gordon Johnson 拍摄
线性回归根据给定数据中的独立变量对目标变量执行回归任务。它是一种机器学习算法，通常用于查找目标和独立变量之间的关系。
简单线性回归 模型是用一个自变量来预测目标变量。
当数据集中的一个变量/列不足以创建好的模型并做出更准确的预测时，我们将使用多元线性回归模型，而不是简单的线性回归模型。
多元线性回归模型的直线方程为:
y = β0 + β1X1 + β2X2 + β3X3 + .... + βpXp + e
在继续使用 python 构建模型之前，我们需要考虑一些事情:
- 添加更多的变量并不总是有用的，因为模型可能会“过度拟合”，而且会太复杂。经过训练的模型不会使用新数据进行归纳。它只对训练好的数据起作用。
- 数据集中的所有变量/列可能都不是独立的。这种情况称为
**multicollinearity**，其中预测变量之间存在关联。 - 我们必须选择合适的变量来构建最佳模型。这个选择变量的过程叫做
**Feature selection**。
我们将使用 python 代码讨论第 2 点和第 3 点。
现在，让我们深入到Jupyter notebook中，看看我们如何构建 Python 模型。
阅读和理解数据集
我们将数据读入我们的系统，了解数据是否有任何异常。
对于本文的其余部分，我们将使用数据集，可以从这里的下载。
数据集中的目标变量/列是Price。
我们将导入必要的库来读取数据并将其转换成 pandas 数据帧。
样本数据帧看起来像这样，
按作者分类的图像-样本数据集
让我们使用.info()查看数据集中的任何空值，并且我们必须使用.describe()检查任何异常值。
输出是，
按作者分类的图像-检查空值和异常值
请注意，数据中没有空值，数据中也没有异常值。
数据准备
如果我们观察数据集，会发现有数值和值为“是”或“否”的列。但是为了拟合回归线，我们需要数值，因此我们将“是”和“否”转换为 1 和 0。
现在让我们看看数据集，
按作者分类的图像—将类别变量转换为数字变量
furnishingstatus列有三个级别furnished、semi_furnished和unfurnished。
我们还需要将这个列转换成数字。为此，我们将使用dummy变量。
当您有一个带有n-levels的分类变量时，创建虚拟变量的想法是构建‘n-1’ variables，指示级别。
我们可以在 pandas 中使用get_dummies方法创建一个虚拟变量。
让我们看看furnishstatus列在数据集中是什么样子。
作者图片—提供状态 column into dataset
现在，我们不需要三列。我们可以删除furnished列，因为它可以用最后两列值来标识，其中:
00将对应于furnished01将对应于unfurnished10将对应于semi-furnished
让我们删除furnished列，并将状态数据集添加到原始数据集中。之后，我们将从数据集中删除furnishstatus列。
修改后的数据集看起来像，
按作者分类的图像-添加虚拟变量后的样本数据集
现在让我们建立模型。正如我们在 简单线性回归 模型文章中看到的，第一步是将数据集拆分成训练和测试数据。
将数据分成两个不同的集合
我们将以 7:3 的比例将数据分成两个数据集。
重新缩放特征
我们可以看到，除了area列之外，数据集中的所有列都具有较小的整数值。因此，重要的是重新调整变量，使它们都有一个可比较的范围。如果我们没有相对比例，那么与其他系数相比，一些回归模型系数将具有不同的单位。
为此，我们使用MinMax缩放方法。
训练数据集看起来像这样，
按作者分类的图像-重新缩放后的训练数据集
构建线性模型
在建立模型之前，我们需要将数据分为 X 和 Y 两个集合。
首先，我们将除目标变量之外的变量添加到模型中。
将所有变量添加到模型中
该模型的总结是，
按作者分类的图片-模型摘要
如果我们观察一些变量的p-values，这些值似乎很高，这意味着它们并不重要。这意味着我们可以从模型中去掉这些变量。
在丢弃变量之前，如上所述，我们必须看到变量之间的multicollinearity。我们通过计算 VIF 值来实现。
方差膨胀因子或 VIF 是一个量化值，表示特征变量之间的相关程度。这是检验我们的线性模型的一个极其重要的参数。VIF的公式为:
VIF = 1/(1-Ri²)
在 python 中，我们可以通过从statsmodels导入variance_inflation_factor来计算 VIF 值
每列的 VIF 值是，
按作者分类的图片-每个变量的 VIF 值
我们认为变量通常有一个值<5. If we observe the above image clearly, there are some variables we need to drop.
While dropping the variables, the first preference will go to the 【 . Also, we have to drop one variable at a time.
丢弃变量并更新模型从总结和 VIF 中可以看出，一些变量仍然是无关紧要的。其中一个变量是semi-furnished，因为它具有非常高的 p 值0.938。让我们继续下去，放弃这个变量。
新创建的模型的概要是，
作者图片—删除semi-furnished变量后的模型摘要
现在，让我们计算新模型的 VIF 值。
新模型的 VIF 值是，
作者提供的图片—丢弃半装配色谱柱后的新 VIFs
现在，变量bedroom具有高 VIF (6.6)和 p 值(0.206)。因此，它没有多大用处，应该从模型中删除。我们将重复和以前一样的过程。
模型的总结，
按作者分类的图片-模型摘要
下一步是计算 VIF，
VIF 值如下所示，
作者图片-删除卧室栏后的 VIF 值
我们将重复这个过程，直到每一列的p-value is <0.005和VIF is <5
在一个接一个地去掉所有必要的变量之后，最终的模型将会是，
最终模型的概要看起来像，
作者提供的图片——删除所有必要变量后的最终模型
最终模型的 VIFs 是，
VIF 值如下所示，
作者图片—最终模型的 VIF 值
我们可以看到，p-value和VIF都在可接受的范围内。现在是我们继续使用最终模型进行预测的时候了。这就是我们选择Feature variables的方式，我们之前已经讨论过了。
现在，在进行预测之前，我们必须看看error terms是否正态分布。我们将通过使用Residual Analysis来做到这一点。
Error-terms = y_actual - y_predicted
实际 y 值与使用该特定 x 值的模型预测的 y 值之间的差异就是误差项。
训练数据的残差分析
我们要检查误差项是否正态分布(这是线性回归的主要假设之一)；让我们画出误差项的直方图。
直方图如下所示，
按作者分类的图像-错误术语直方图
正如我们所见，误差项非常接近正态分布。因此，我们可以继续使用测试数据集中的模型进行预测。
使用最终模型进行预测
我们拟合了模型并检验了误差项的正态性。让我们使用最终模型进行预测。
类似于训练数据集。首先，我们必须缩放测试数据。
测试数据集看起来像这样，
按作者分类的图像-测试数据集
将测试数据分为 X 和 Y，之后，我们将根据我们的模型从测试数据中删除不必要的变量。
现在，我们必须看看最终预测的模型是否是最佳拟合的。为此，我们将计算预期测试模型的 R 值。
我们通过从sklearn导入r2_score库来做到这一点
测试数据的 R 值= 0.660134403021964，
训练数据的 R 值= 0.667；我们可以从上面的最终模型总结中看到价值。
因为训练和测试数据的 R 值几乎相等，所以我们建立的模型是最适合的模型。
这是一种建立多元线性回归模型的过程，我们手动选择和删除变量。还有一个过程叫做递归特征消除(RFE)。
递归特征消除(RFE)
RFE 是一个自动过程，我们不需要手动选择变量。我们遵循与之前相同的步骤，直到重新缩放特征和将数据分成 X 和 y。
我们将使用来自**sklearn**的**LinearRegression** 函数用于 RFE(这是来自sklearn的一个实用程序)
我们必须跑 RFE。在代码中，我们必须提供 RFE 在构建模型时必须考虑的变量数量。
上面代码的输出是，
按作者分类的图像-所有变量的 RFE 值
正如我们所看到的，显示True的变量对于模型是必不可少的，而False变量是不需要的。如果我们想将False变量添加到模型中，那么也有一个与它们相关联的等级来按照这个顺序添加变量。
建筑模型
现在，我们使用statsmodel建立模型，进行详细的统计。
该模型的总结是，
作者图片—初始模型摘要
由于bedrooms列对于其他变量来说无关紧要，因此可以将其从模型中删除。
删除bedroom变量后的模型摘要
作者图片-删除卧室栏后的模型摘要
现在，我们计算模型的 Vif。
上述代码的 VIF 值是，
作者图片— VIF 价值观
由于 p 值和 VIF 在理想范围内，我们将继续进行分析。
下一步是误差项的残差分析。
残差分析
因此，让我们使用直方图来检查误差项是否也呈正态分布。
直方图看起来像，
作者图片
根据测试数据评估模型
对测试集应用缩放并将数据分成 X 和 y。
之后，我们来评估模型，
测试数据的 R 值= 0.6481740917926483，这与训练数据非常相似。
因为训练和测试数据的 R 值几乎相等，所以我们建立的模型是最适合的模型。
结论
我们在机器学习中手动建立了一个基本的多元线性回归模型，并使用了自动 RFE 方法。大多数时候，我们使用多元线性回归而不是简单的线性回归模型，因为目标变量总是依赖于多个变量。
因此，了解多元线性回归在机器学习中的工作方式至关重要，如果不知道简单的线性回归，理解多元线性回归模型是很有挑战性的。
感谢您阅读和快乐编码！！！
点击这里查看我以前的文章
- 使用 Python 的简单线性回归模型:机器学习
- 线性回归模型:机器学习
- 探索性数据分析(EDA): Python
- 中心极限定理(CLT):数据科学
- 推断统计:数据分析
- Seaborn:Python
- 熊猫:蟒蛇
- Matplotlib:Python
- NumPy: Python
参考
- 多元线性回归:【https://acadgild.com/blog/multiple-linear-regression】T42
- ML |多元线性回归:https://www . geeks forgeeks . org/ML-Multiple-Linear-Regression-using-python/
- 多元线性回归:https://www . coursera . org/lecture/machine-learning-with-python/Multiple-Linear-Regression-0y8Cq
- 多元线性回归:https://www . tutorialspoint . com/machine _ learning _ with _ python/machine _ learning _ with _ python _ Multiple _ Linear _ Regression . htm
遗传编程揭示的多重线性回归与交互作用
当有更多的变量和变量之间的交互时，如何使用最常见的 python 库处理线性回归，以及使用遗传编程的新方法，这极大地改善了结果。
约翰·莫塞斯·鲍恩在 Unsplash 上拍摄的照片
我们都有一些线性回归的经验。这是最常用的回归技术之一。为什么？因为它很容易解释，也很容易实现。但是当你有不止一个变量时会发生什么呢？你如何处理这种增加的复杂性，并且仍然像这样使用一个容易理解的回归？如果系统更加复杂，会发生什么？让我们想象一下当两个变量相互作用时。
这就是多元线性回归发挥作用的地方，我们将看到如何使用 python 中一些方便的库来处理交互。最后，我们将尝试用符号回归来处理同样的问题，我们将享受随之而来的好处！
如果你想重温一下线性回归，有很多可用的资源，我还写了一个简介和代码。符号回归呢？在本文中，我们将使用 gplearn 。查看它的文档以获得更多信息，或者，如果你喜欢，查看我的另一篇关于如何在 python 中使用复杂函数的文章这里。
数据准备
我们将探索回归的两个用例。在第一种情况下，我们只有四个变量(x1 到 x4 ),加上一些预定的相互作用:x1x2，x3x2 和 x4*x2。
注意，在我们的数据集“out_df”中，我们没有交互项。我们要做的是尝试用我们的工具发现这些关系。这是我们用 seaborn 绘制变量时的样子，使用 x4 作为色调(图 1):
图 1:一阶相互作用:数据框架变量对绘图
图 2:二阶相互作用:数据帧对绘图；
第二种情况(图 2)的 y 由下式给出:
y_true = x1+x2+x3+x4+ (x1*x2)*x2 - x3*x2 + x4*x2*x3*x2 + x1**2
相当复杂的场景！
案例 1:多元线性回归
第一步是更好地理解这些关系，因此我们将尝试我们的标准方法，并对此数据集进行多元线性回归。我们将为此使用统计模型。在图 3 中，我们有 OLS 回归的结果。
import statsmodels.api as sm Xb = sm.add_constant(out_df[['x1','x2','x3','x4']])
mod = sm.OLS(y_true, Xb)
res = mod.fit()
res.summary()
图 3:统计模型的拟合总结。
哎哟，这显然不是我们希望的结果。r 仅为 0.567，此外，我惊讶地发现 x1 和 x4 的 P 值高得令人难以置信。我们需要一些不同的策略。
多项式特征
我们可以做的是从 sklearn 导入一个名为多项式特征的 python 库，它将生成多项式和交互特征。例如，如果输入样本是二维的并且形式为[a，b ]，则 2 次多项式特征为[1，a，b，a，ab，b]。
from sklearn.preprocessing import PolynomialFeatures
import scipy.specialpoly = PolynomialFeatures(interaction_only=True)
X_tr = poly.fit_transform(Xb)
Xt = pd.concat([Xb,pd.DataFrame(X_tr,columns=poly.get_feature_names()).drop([‘1’,’x0',’x1',’x2',’x3',’x4'],1)],1)
当“interaction_only=True”时，仅产生交互特征:最多为degree 个不同的个输入特征的乘积的特征(因此不是x[1] ** 2、x[0] * x[2] ** 3等)。).默认的度数参数是 2。
使用和以前一样的代码，但是现在使用 Xt ，产生下面的结果。
mod = sm.OLS(y_true, Xt)
res = mod.fit()
res.summary()
图 4:带插值的 statsmodels 回归结果。
现在图 4 中的 R 是 1，这是完美的。太完美而不完美？事实上，在汇总统计数据中有很多交互术语。有些我们甚至不知道。我们的方程是这样的:
y = x₁+05x₂+2x₃+x₄+x₁x₂—x₃x₂+x₄*x₂
所以我们的拟合引入了我们在函数中没有明确使用的相互作用。即使我们除去那些高 p 值的国家(x₁ x₄)，我们还是会有一个复杂的情况。这可能是一个一般化的问题。我们可以利用基因编程给我们一些建议。
遗传编程:GPlearn
通过遗传编程，我们基本上是在告诉系统尽最大努力以分析的形式在我们的数据中找到关系。如果你读了另一个教程，我在这里调用的一些函数会更清楚。然而，我们主要想做的是从 gplearn.genetic 导入 SymbolicRegressor，我们将使用 sympy 来格式化我们的方程。
既然我们已经完成了，我们还将导入 RandomForest 和 DecisionTree 回归器，以便稍后比较所有这些工具的结果。下面的代码来让它工作:
转换器字典可以帮助我们用相应的 python 函数映射方程，让 simpy 完成它的工作。我们还对我们的数据进行 train_test 分割，这样我们就可以单独比较我们对测试数据的预测。我们定义了一个函数集，其中使用了 gplearn 集合中的标准函数。
在第 40 代，代码停止，我们看到 R 几乎是 1，而生成的公式现在非常容易阅读。
图 5: gplearn 结果
如果你将它与我们实际使用的公式进行比较，你会发现它非常匹配，重构我们的公式变成:
y =-x₃(x₂–2)+x₂(x₁+x₄+0.5)+x₁+x₄
所有算法在这项工作中都表现良好。
statsmodels OLS with polynomial features 1.0,
random forest 0.9964436147653762,
decision tree 0.9939005077996459,
gplearn regression 0.9999946996993035
案例 2:二阶相互作用
在这种情况下，随着交互顺序的增加，关系变得更加复杂:
X = np.column_stack((x1, x2, x3, x4))y_true = x1+x2+x3+x4+ (x1*x2)*x2 - x3*x2 + x4*x2*x3*x2 + x1**2out_df['y'] = y_true
我们的步骤与第一种情况基本相同，但这里我们已经从多项式特征开始:
poly = PolynomialFeatures(interaction_only=True)
X_tr = poly.fit_transform(out_df.drop('y',1))
Xt = pd.concat([out_df.drop('y',1),pd.DataFrame(X_tr,columns=poly.get_feature_names()).drop(['1','x0','x1','x2','x3'],1)],1)Xt = sm.add_constant(Xt)
mod = sm.OLS(y_true, Xt)
res = mod.fit()
res.summary()
图 6:案例 2 的 statsmodels 总结
在这种情况下，我们的方法不再有回报。很明显，我们的数据集中没有正确的预测值。我们可以使用多项式特征来研究更高阶的相互作用，但维数可能会增加太多，我们将不会获得比以前更多的知识。此外，如果你有一个真实的数据集，你不知道目标的公式，你会增加相互作用的顺序吗？我猜不是！
在下面的代码中，我们再次使用决策树和随机森林算法来拟合和预测数据集，但也使用了 gplearn。
X_train, X_test, y_train, y_test = train_test_split(out_df.drop('y',1), y, test_size=0.30, random_state=42)est_tree = DecisionTreeRegressor(max_depth=5)
est_tree.fit(X_train, y_train)
est_rf = RandomForestRegressor(n_estimators=100,max_depth=5)
est_rf.fit(X_train, y_train)y_gp = est_gp.predict(X_test)
score_gp = est_gp.score(X_test, y_test)
y_tree = est_tree.predict(X_test)
score_tree = est_tree.score(X_test, y_test)
y_rf = est_rf.predict(X_test)
score_rf = est_rf.score(X_test, y_test)
y_sm = res.predict(Xt) est_gp.fit(X_train, y_train)
print('R2:',est_gp.score(X_test,y_test))
next_e = sympify((est_gp._program), locals=converter)
next_e
结果是不可思议的:40 代之后，我们又一次得到了令人难以置信的高 R，甚至更好的是一个简单的解析方程。
图 7:上一代，R 和解析公式。
原来的公式是这样的:
所以我们看到，在涉及 x1 及其相互作用的术语上，确实存在差异。而不依赖于它的项则完全存在。然而，如果与多项式特征方法相比，我们在这里处理的是一个简单得多的公式。
不同系统的误差是多少？嗯，对于 gplearn 来说，如果和其他公司相比，这个数字低得令人难以置信。图 8 显示了 y 坐标相对于实际 y 坐标的误差。当 x 轴被共享时，你可以注意到 y 轴变得多么不同。GPlearn 的最大误差约为 4，而其他方法可以显示高达 1000 的峰值。
图 8:用作 y 函数的不同方法的误差图。图例显示了方法。
结论
在本文的第一部分，我们看到了如何处理存在交互的多元线性回归。我们使用 statsmodels OLS 进行多元线性回归，使用 sklearn 多项式特征生成交互作用。然后，我们用一种不同的算法来处理同一问题，即遗传编程，它易于导入和实现，并给出了一个解析表达式。
在第二部分中，我们看到当事情变得混乱时，我们在使用标准工具时会有一些不确定性，即使是那些来自传统机器学习的工具。然而，使用 gplearn 更容易面对这类问题。有了这个库，我们可以直接得到问题的解析公式。
参考
[1]stats models
【2】sk learn 多项式特性
【3】gp learn
学习多元回归:平行斜率模型入门
图片由 Elias Sch 提供。来自 Pixabay
介绍
不管你对数据科学和统计世界有多了解，在某个时候，你可能至少听说过回归。作为多元回归快速课程的前奏，您应该对简单线性回归有所了解。如果不是，可以从这里开始！否则，让我们开始多元线性回归。
我们在简单线性回归和多元线性回归之间的区别仅仅是帮助我们理解因变量的解释变量的数量。
多元线性回归是数据科学家非常流行的统计技术，也是数据科学家使用的许多更复杂方法的基础。
多元线性回归
在我关于简单线性回归的帖子中，我举了一个用一个数字变量——平方英尺来预测房价的例子。
让我们在已有成果的基础上继续努力。我们将构建相同的模型，只是这一次，我们将包括一个额外的变量。
fit <- lm(price ~ sqft_living + waterfront,
data = housing)
summary(fit)
与您之前看到的类似，我们通过平方饲料居住空间来预测价格，只是现在我们还包括一个滨水变量，请注意我们新变量的数据类型。
平行斜坡模型
我们刚刚创建了一个平行斜坡模型。平行斜率模型是多元线性回归模型的结果，该模型同时具有一个数字解释变量和一个分类解释变量。
由线性回归导出的公式是一条直线的方程。
y = mx + b
y是我们的因变量m是分配给我们的解释变量的系数x是解释变量的值b是 y 轴截距
记住与直线方程的相似性；当我们试图仅根据卧室的数量来模拟房价时，我们推导出一个与x相关的系数和一个 y 截距，该截距通过最小化误差来最接近价格。
留给我们的问题是……当我们在回归公式中引入当前数值预测值之外的分类变量时，它是如何被处理或反映在模型的输出中的？
如果您曾经仅使用分类解释变量构建了一个简单的线性回归模型，您可能会对分类的不同级别上的组平均值的概念很熟悉，这些组平均值通知了分配的系数。你可以在这里阅读关于那个更详细的解释。
在平行坡度模型中，分类变量的包含现在反映在 y 截距值的变化中。
你可能会问自己，为什么这些多元回归模型被称为平行斜率模型。
让我们建立一个模型
让我们创建一个模型的可视化，然后分解其含义！
首先，让我们建立我们的平行斜坡模型
fit <- lm(price ~ sqft_living + waterfront,
data = housing)
summary(fit)
然后，我们将在住房数据集中添加一个字段来表示我们的拟合值。
housing$pred_price <- predict(fit, housing)
现在我们可以想象了！
ggplot(housing, aes(x = sqft_living, y = price, col = waterfront)) +
geom_point()+
geom_line(aes(y = price_pred))
请注意以下视觉效果。我们看到两条线分别代表我们对有无滨水区情况下sqft_living的每个值的预测。
我想在这里强调的关键点是，每个数据点都有相同的分配给sqft_living的系数，或者换句话说，相同的斜率。基于每条预测线的斜率，这是显而易见的，它们是平行的，因此我们知道斜率是相同的。
我们所看到的是，滨水区为正的情况比没有滨水区的情况要高。
让我们看一下模型摘要，以获得一些额外的背景信息。
summary(fit)
为了理解这里发生了什么，让我们首先考虑没有滨水部分的模型。所有记录都有相同的 y 截距，21，522，所有记录的sqft_living值都将乘以系数 246。
然后，将进一步区分滨水区值为“1”的记录的是，它们的 y 截距将增加滨水区 1 估计值的量-575，954。同样，两条记录具有相同的sqft_living，但是waterfront的值不同，只是 y 轴截距的增量值不同。
结论
在过去的几分钟里，我们讲述了以下内容:
- 多元回归的定义
- 多元回归和简单线性回归的区别
- 平行边坡模型的定义
- 如何建立自己的平行斜坡模型
- 平行斜坡模型是如何形成的
我希望这篇关于多元回归和平行斜率模型的文章对你有所帮助。
祝数据科学快乐！
多元回归作为机器学习算法
使用 Sci-kit 学习模块在 Python 中完全实现
诺贝特·昆德拉在 Unsplash 上的照片
介绍
以前我写过几篇关于多元建模的文章，但它们都专注于时间序列预测。如果好奇，可以去看看向量自回归和面板数据建模上的帖子。写多元回归(即多元线性回归)一直在我的清单上，但其他事情正在进行中——我开始了一个关于异常检测技术的系列！一旦开始那个系列，我就停不下来，直到我连续写了 11 个帖子。
今天我带着多元回归回来了，计划是这样的——首先我将从广义上定义什么是多元回归，然后列出一些真实世界的用例作为例子。第二部分是用 Python 快速实现多元回归，只是给出一个大概的直觉。在第三部分，我将按照典型的机器学习工作流程进行更深入的探讨。最后，在实现线性回归时，我要记住一些额外的要点
什么是多元回归？
在说多元回归之前先说一下简单线性回归。
简单线性回归有一个因变量，只有一个自变量。如果“收入”可以用个人的“教育”来解释，那么回归可以用简单的线性回归来表示，如下所示:
*收入= B0+B1 学历+ e
多元回归更进一步，不再是一个，会有两个或更多的自变量。如果我们在上面的等式中有一个额外的变量(假设“经验”)，那么它就变成了一个多元回归:
*收入= B0+B1 *学历+B2 经验+ e
用例
那么为什么多元回归有用，它们是如何在现实世界的数据科学中使用的呢？
基于回归的机器学习应用程序可以分为(至少)三个不同的问题领域:
- 量化关系:我们知道，通过相关性，我们可以发现两个变量之间关系的强度(用 0-1 之间的数字表示)和方向(正或负)。但是多元回归更进一步，实际上量化了这种关系。
2)预测:机器学习就是预测。由于回归具有量化关系的能力，我们可以将这种能力转化为解决预测问题。这意味着，如果我们知道一个人的教育水平和经验年限，我们应该能够使用回归方程(如上式)预测该个人的工资水平。
3)预测:多元回归的第三个问题域是用时间序列分析进行预测。向量自回归和面板数据回归是两种使用多元回归原理的强大预测技术。
下面是多元回归的一些实际应用案例:
- 根据品牌、型号、年份、档位、mpg 和颜色预测二手车价格
【品牌、型号、年份、档位、mpg】→汽车价格
- 根据位置、地段大小、床位数量、浴室数量、社区特征等对市场上房屋价格的预测。
【位置、地段大小、床位数量、浴室数量、犯罪率、学校评级】→房价
- 根据历史数据预测未来收入，如广告支出、营销、客户特征等。
[过去的广告支出美元、营销美元、订阅率] →时间 T 的收入
现在是时候在数据科学家的笔记本上展示多元回归是如何工作的了。首先，我将通过消防演习给出一个直觉，然后再深入一点。如果你想跟进，你可以从 UCI 机器学习库下载汽车数据集。
机器学习 目标 这里是根据二手车的特征来预测价格。
消防演习
1。导入库
import pandas as pd
import numpy as np
from sklearn import linear_model
2。加载数据&选择功能
# import data
df = pd.read_csv("../automobile.csv")# select features
X = df[["horsepower", "highway-mpg"]]
y = df["price"]
3.建模
# instantiate model
model = linear_model.LinearRegression()# fit model
model.fit(X, y)
4.预言；预测；预告
# predicting price based 90 horsepower and 30 mpg
model.predict([[90, 30]])# predicted price
>> 11454.03
深潜
通过一个简单的例子，你可以直观地了解多元回归是如何根据两个特征预测二手车的价格的:马力和高速行驶的英里数。
但是我们生活的世界是复杂而混乱的。我上面展示的每个步骤都需要进一步扩展。例如，在步骤 2 中，我们导入数据并将特征分配给 X，y 变量，而没有做任何进一步的分析。但是谁不知道在任何机器学习项目中，光是数据争论就可以占据所有任务的 80%以上？
作为一名数据科学家，我不会详细介绍你在现实世界中遇到的每一种情况，但我会谈谈一些不可避免的基本问题。
1。导入库
我将使用一些库和模块来完成一些强制性的任务。
- 数据角力:
pandas和numpy - 多元回归模型:
linear_model来自sklearn - 拆分培训和测试数据:
train_test_split - 型号评估:
r2_score
import pandas as pd
import numpy as np
from sklearn import linear_model
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
2。数据争论
首先，我在我的环境中读取数据集(顺便说一句，我使用的是 Jupyter notebook ),作为一种惯例，偷看前几行。
# import data
data = pd.read_csv("../automobile.csv")
data.head(2)
如您所见，有许多列勉强适合窗口。所以我要得到所有列的列表。
# all column name
data.columns>> 'symboling', 'normalized-losses', 'make', 'fuel-type', 'aspiration', 'num-of-doors', 'body-style', 'drive-wheels', 'engine-location', 'wheel-base', 'length', 'width', 'height', 'curb-weight', 'engine-type', 'num-of-cylinders', 'engine-size', 'fuel-system', 'bore', 'stroke', 'compression-ratio', 'horsepower', 'peak-rpm', 'city-mpg', 'highway-mpg', 'price'
(我不是汽车专家，所以我真的不知道其中一些列代表什么，但在现实世界的数据科学中，这不是一个好的借口，一些领域知识是必不可少的)。
作为数据探索和准备的一部分，我做了一些其他的事情(比如检查和转换数据类型，删除几行像“？”这样的符号)等等。)，但重申我之前的观点就足够了，即以正确的格式获取数据可能是一件非常棘手的事情。
3。准备输入数据
我们想预测价格，所以因变量已经设定。接下来是使用哪些特征进行预测。理想情况下，我会包括初始模型中的所有功能，但对于这个演示，我选择 1 个分类功能(即品牌)和 2 个数字功能(即马力和公路里程),我认为大多数人在选择汽车时都会关心这些功能。
遵循 ML 惯例，我将自变量指定为 X ，因变量指定为 y.
# select data subset
df = data[["make", "horsepower", "highway-mpg", "price"]]# select data for modeling
X = df[["make", "horsepower", "highway-mpg"]]
y = df["price"]
我特意选择了一个分类变量(即 make)来强调您需要做一些额外的工作来将其转换成机器可读的格式(也就是数字！).有几种方法可以做到这一点，例如使用标签编码器或一个热编码器——两者都可以在sklearn模块中获得。但是我将使用经典的“虚拟变量”方法，这种方法将分类特征转换为数值二分变量(0 和 1)。
在这个阶段，我还将数据分为训练集和测试集，用于模型评估。
# create dummy variables
make_dummy = pd.get_dummies(X["make"], drop_first = True)
X = X.drop("make", axis = 1)
X = pd.concat([X, make_dummy], axis = 1)# split data into train and test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0)
4.模型结构
想到在整个复杂的机器学习管道中最简单的部分是(在我看来当然是！)实际指定型号。和大多数 ML 算法一样，这只是三个简单的步骤实例化—拟合—预测。当然，您必须对模型进行参数化，并对其进行多次迭代，直到您得到满足您的标准的模型，但是，模型构建过程的这一步仍然是最让我头疼的。
# instantiate
model = LinearRegression()
# fit
model.fit(X_train, y_train)
# predict
y_pred = model.predict(X_test)
5.模型评估
现在到了关键时刻——这个模型表现如何？评估模型性能的方法有很多，但在经典统计学中，线性回归模型的性能是用 R 来评估的，R 的值介于 0 和 1 之间，R 越高，模型越好。
# model evaluation
score = r2_score(y_test, y_pred)
print(score)# score
>> 0.8135478081839133
在我们的演示中，我们得到的 R 值为 0.81，这意味着因变量(即二手车价格)的 81%的变化可以由三个自变量(即品牌、马力和公路里程)来解释。当然，可以通过包含更多变量、尝试不同的变量组合以及调整模型参数来改进这一指标——这是单独讨论的主题。
附加清单
我觉得我可以永远写多元回归，有这么多领域要涵盖，但我必须在某个地方停下来。在为现实世界的应用程序开发构建线性回归模型时，需要记住以下几点:
- 选择特征时，分别检查因变量和每个自变量之间的相关性。如果它们不相关，则从模型中移除该特征；
- 检查多重共线性，独立变量之间的关系。移除相关特征以避免模型过度拟合；
- 有几种方法可以为模型选择变量。正向选择和反向淘汰就是其中的两种。顾名思义，在这个过程中，您一次添加或删除一个变量，并检查模式性能；
- 我使用 R 进行模型性能评估，但有些人选择其他指标，如 AIC、BIC、p 值等。
总结和最后的思考
概括一下:
- 多元回归是一种机器学习算法，通过两个或多个预测器来预测因变量。
- 多元回归在三个问题领域中有许多实际应用:检查变量之间的关系，进行数值预测和时间序列预测。
- 如果您已经为模型构建做好了一切准备，那么它的实现就像“防火练习”中演示的 4 个简单步骤一样简单。然而，真正艰苦的工作是与数据争论，并通过迭代过程找到正确的模型。
我希望这是一个有用的职位。如果你有意见，请随意写在下面。你可以在 Medium 、 Twitter 或 LinkedIn 上关注我。
用神经网络预测多个时间序列
多股票指数单神经网络
利用 LSTM 进行时间序列预测
作者图片
https://sarit-maitra.medium.com/membership
S 股票预测是一项艰巨的任务，因为产生的数据量巨大且高度非线性。建模这样的动态数据需要有效的建模技术，可以分析隐藏的模式和潜在的动态。神经网络是一种深度学习算法，能够通过自我学习过程识别和利用数据中存在的相互作用和模式。
我们将集中讨论一个简单的预测模型，该模型使用包含多个时间序列的长短期记忆结构。为了便于说明和更好地理解，我们将把整个练习保持为一个简单的过程。
让我们考虑四个不同的系列标准普尔 500 指数(GSPC)、道琼斯工业平均指数(DJI)、纳斯达克综合指数(^IXIC)和罗素 2000 指数(^RUT)，也就是芝加哥期权。我们的数据是从 1990 年至今。从 yahoo finance 检索到的数据被格式化为 Pandas DataFrame 对象。
stock = ['^RUT', '^GSPC', '^DJI', '^IXIC' ]
start = pd.to_datetime('1990-01-03')
df = web.DataReader(stock, data_source = 'yahoo', start = start )
print(df.head())
让我们在一个神经网络结构中拟合该系列的所有收盘价，并从那里预测一个系列。
X = data.copy()
X = X.drop(columns = [‘Date’])
print(X.shape)
print(X.tail())
如果我们看到相关性分析，我们就会知道为什么选择这 4 个系列。
数据分割:
该时间序列分为训练集(80%)和测试集(20%)，如下所示。
split_ratio = 0.2
X = X.values # Convert to NumPy array
split = int(len(X) * (1-split_ratio))
train_set = X[: split]
test_set = X[split:]
print(train_set.shape, test_set.shape)
监督学习:
让我们以这样的方式格式化，监督学习可以应用于 ML 模型。这里，训练集和测试集将经历相同的转换。我们将实现以下功能的目标。
def supvervisedSeries(data, n, h):
x, y = list (), list ()
for i in range (len(data)-n-h+1):
x.append(data[i:(i+n)])
y.append(data[i+h+n-1])
return np.array(x), np.array(y)h = 1
n = 4
trainX, trainY = supvervisedSeries(training_set, n, h)
testX, testY = supvervisedSeries(test_set, n, h)
print("trainX: ", trainX.shape)
print("trainY: ", trainY.shape)
print("testX: ", testX.shape)
print("testY: ", testY.shape)
h =时间范围& n =特征数量；这些参数是在转换之前选择的。
现在，trainY 和 testY 必须按照所需的特征预测进行修改，因为默认情况下它包含所有 4 个特征。
testY = np.reshape(testY[:, 0], (testY [:, 0].shape[0], 1))
trainY = np.reshape(trainY[:, 0], (trainY[:, 0].shape[0], 1))
print(“trainY: “, trainY.shape)
print(“testY: “, testY.shape)
在这里，我们选择了指数[0]，这是^RUT 每日调整收盘价格。
数据缩放:
ML 模型要求数据位于范围(0，1)内。我们使用了最小最大缩放器，它重新缩放数据集，使得所有特征值都在范围[0，1]内。它通常保持数据集的形状。
scalers = {}
for i in range (trainX.shape[2]):
scalers[i] = MinMaxScaler()
trainX[:, :, i] = scalers[i].fit_transform(trainX[:, :, i])for i in range(testX.shape[2]):
testX[:, :, i] = scalers[i].transform(testX[:, :, i])# The target values are 2D arrays, which is easy to scale
scalerY = MinMaxScaler()
trainY = scalerY.fit_transform(trainY)
testY = scalerY.transform(testY)
前馈神经网络；
在下面，每层只有 100 个神经元用于处理我们的小数据集。此外，辍学作为一种正规化技术被用来减少过度拟合。密集类表示完全连接的图层。
# Flatten input (to support multivariate input)
n_input = trainX.shape[1] * trainX.shape[2]
trainX = trainX.reshape((trainX.shape[0], n_input))n_input = testX.shape[1] * testX.shape[2]testX = testX.reshape((testX.shape[0], n_input))# Create multilayered FFNN model
model = Sequential()
model.add(Dense(100, activation='relu', input_dim=trainX.shape[1]))
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu'))
model.add(Dense(trainY.shape[1]))
model.compile(loss='mean_squared_error', optimizer='adam')
model.summary()# Fit model
history = model.fit(trainX, trainY, epochs =60, verbose =1)# Predict the test set
predictions = model.predict(testX)
模型评估:
我们必须使用最初用于缩放数据的同一缩放器来缩放数据，以恢复原始值。
# Descale
predictions = scalerY.inverse_transform(predictions)
testY = scalerY.inverse_transform(testY)# Mean absolute error
mae = mean_absolute_error(testY, predictions)
print("Test MAE: %.6f" % mae)
图预测值与实际值:
plt.figure(figsize=(15,6))
plt.plot(predictions, label="Test set predictions" )
plt.plot(testY, label="Real data")
plt.legend()
plt.ylabel('Price Index')
plt.xlabel('time step' )
plt.title ("Russell 2000 Adj close Price prediction- with MAE {:10.4f}".format(mae))
plt.show()
这里可以看出，我们的网络架构能够提取数据中隐藏的趋势；同样，其他系列也可以通过选择合适的尺度来预测所选的系列。
结论
我们可以看到，深度神经网络架构能够捕捉隐藏的动态，并能够做出预测。为了简单起见，我们只是拟合了一个简单的 LSTM 网络，没有优化网络的任何参数。为了建立一个健壮的网络，我们必须研究正确的参数，如时期数、批量、神经元数、隐藏层数等。
基于连续小波变换的多时间序列分类
希法兹·沙蒙在 Unsplash 上拍摄的照片
这篇文章的目的是展示为什么连续小波变换如此强大，以及如何使用它来分类多个非平稳信号和时间序列。
1 简介:连续小波变换的重要性
在数字化和第四次工业革命的时代，公司越来越重视开发数据驱动的应用程序来创建新的商业模式。通常，产生新服务的先决条件是记录非平稳数据或信号(随时间动态变化的数据)和时间序列，如金融趋势或声音、振动、电、加速度计或其他类型的传感器信号。为了产生期望的商业价值，通常必须通过这些数据来检测和理解事件。
这就是机器和深度学习的用武之地。这些数学模型能够以非常高效的方式对物联网设备的状态进行分类和预测。不幸的是，经常需要多个非平稳信号(时间序列)，这些信号非常复杂，容易产生噪声和误导值。为了提高模型的预测精度，使用数字信号处理技术通常是有帮助的。一种非常有效的技术是连续小波变换。
连续小波变换(CWT)在确定振荡信号的阻尼比方面非常有效(例如，识别动态系统中的阻尼)。CWT 对信号中的噪声也有很强的抵抗力
卡门·赫尔利&贾登·麦克林:小波、分析和方法(2018)。第 73 页
赞美诗除了 CWT 之外，还有离散小波变换 (DWT)，在这篇文章中我就不再详细解释了。
不可思议的是，CWT 在数据科学中并不是很受欢迎。出于这个原因，在下面的帖子中，我想展示 CWT 可以多么容易地用于机器和深度学习(第 3 节)。首先，我想概述一些关于连续小波变换的基本理论(第 2 节)。
2 使用连续小波变换的信号处理
在本节中，我将简要概述小波变换为何对分析非平稳信号如此有用(2.1 节)，例如其背后的概念(2.2 节)。
2.1 傅立叶变换的局限性
傅立叶变换(FT)通过使用一系列正弦波将信号分解成频率。它有助于在时域和频域之间转换。为了更好的了解 FT，我推荐这个有用的视频。
为了说明 FT 的局限性，我们需要一个非常简单的平稳和非平稳信号。与动态非平稳信号不同，平稳信号不随时间改变其均值、方差和协方差。在 FT 中，我们必须考虑时域和频域。时域显示信号幅度/强度与时间的函数关系，可以表示为傅立叶变换后频域中的独立频率(图 1)。
图一。使用傅立叶变换分析非平稳信号无法获得其时域和频域的完整图像
如您所见(图 1)，FT 非常适合正弦波，正弦波是由稳定过程产生的，因为信号始终包含其所有频率(本例中只有一个频率)。现在让我们关注非平稳信号中的突发，它可能是一种异常或特征模式。与静态过程一样，您也可以使用 FT 来识别频率，尽管您无法识别哪些频率代表信号中的突发。FT 的问题在于，它只在频域分解信号，而没有任何关于时域的信息。这解释了为什么不可能在特定时刻确定哪些频率是信号的一部分，反之亦然。总的来说，非平稳信号与傅立叶变换相结合，会被限制在时域或频域内，但你永远无法了解信号的全貌。为了以智能的方式处理这个问题，让我们在下一节中更仔细地研究连续小波变换。
2.2 连续小波变换(CWT)的功能
小波是数学函数，通常被称为迷你小波。与用于 FT 的无穷大(-无穷大至+无穷大)正弦函数相比，WT 包含:
- 具有不同紧性和光滑性的不同族和类型的小波
- 其均值为零且时间有限
不同的小波形状使我们能够选择最适合我们在信号中寻找的特征的一个。CWT 最常见的小波是“墨西哥、莫尔莱特和高斯”小波(图 2)。他们也被称为“小波妈妈”。
图 2:墨西哥帽、Morlet 和高斯母小波的形状。
Ps:使用的 Python 包“PyWavelets”提供了更多与 CWT 兼容的母小波。因此，请阅读py waveletAPI 参考资料。
图 2 还展示了母小波的零均值和时间限制。这两个条件都允许同时从时间和频率进行定位。此外，它们使得必要的可积和逆小波变换成为可能。CWT 可以用下面的等式来描述:
因此，小波变换使用母小波将 1D 到 ND 时间序列或图像划分成缩放的分量。在这方面，转换是基于缩放和移位的概念。
- 缩放:通过缩放因子在时间上拉伸或收缩信号。
- 移位:将不同尺度的小波从信号的开头移动到结尾。
比例因子对应于信号在时间上的缩放程度，并且与频率成反比。这意味着标度越高，标度精度越好(图 3)。
图 3:演示了一个收缩和一个拉伸的 Morlet 母小波。比例因子与频率成反比。
因此，这有助于:
- 拉伸小波以捕捉缓慢变化；和
- 收缩小波以捕捉信号中的突变。
尺度和时间上的不同小波沿着整个信号移动，并乘以其采样间隔，以获得物理意义，从而得到作为小波尺度和移位参数的函数的系数。例如，100 个时间步长乘以 32(在 1 到 33 的范围内)的信号会产生 3，200 个系数。这使得能够用 CWT 更好地表征信号中的振荡行为。
如果我们将 CWT 应用于非平稳信号示例，并在标量图中显示结果系数，我们将获得以下结果。
图 4:具有突发的非平稳信号(时域)和其 CWT(时域和频域)之间的比较
图 4 中的比例图显示了原始信号的大部分能量(见比例图右侧的颜色条)包含在时间和频率中的位置。此外，我们可以看到，信号的特征现在显示在高分辨率的细节。因此，您可以看到尺度为 1 和 2 的收缩小波检测到的突发的突然变化，以及尺度为 15 到 25 的拉伸小波检测到的正弦波的缓慢变化。
Ps:突然的变化通常是数据中最重要的部分，无论是从感觉上还是从它们所提供的信息来看。
像 2D 尺度图这样的 CWT 系数的可视化可以用来改善不同类型信号之间的区别。在工业环境中，这有助于区分机器中的不同生产过程(过程监控)，识别轴承等组件以及机器或工具故障(状态监控),例如基于非平稳振动传感器信号的质量问题(质量监控)。我希望这能让您更好地理解 CWT 在数据分析方面有多么强大。现在相关的是看你如何在机器和深度学习中使用这项技术。
3 通过连续小波变换分类
在 2.2 节中，我们已经看到连续小波变换将 1D 时间序列转换成 2D 系数。因此，系数代表信号的时间、频率和特征，因此比时间序列或 FT(图 4)包含更多信息。本节的目标是通过使用模式识别(3.3 节)或特征提取(3.4 节)，将生成的信息用作分类的基础。之前，我已经提供了所选示例数据集的简要概述(3.1 节)以及如何对该数据应用 CWT(3.2 节)。
3.1 使用的人类活动识别(HAR)数据集
开放 HAR 数据集包含一个智能手机传感器(加速度计和陀螺仪),用于测量正在进行以下活动的不同人员:
有 7，532 个训练样本和 2，947 个测试样本(测量)，每个样本之间有 50%的重叠。每个样本包括 9 个固定大小的信号，有 128 个读数和时间步长。
您可以在 this 链接下载并阅读更多关于数据集的信息。
我们正在加载几乎原始的惯性信号，其中只有重力效应被过滤掉了。
有用信息:X_train: (7352，128，9)和 X_test: (2947，128，9)的形状(n_samples，n_steps，n_signals)所有 X 的平均值为:0.10，标准偏差为:0.40
如你所见，信号几乎是正常的。
如果绘制两种不同活动的身体加速度计和身体陀螺仪信号，您将看到每个样本的动态变化(非平稳)信号(图 5)。为了更清楚起见，我们将不绘制总加速度计值。
图 5:HAR 数据集中人体加速度计和人体陀螺仪智能手机信号的活动可视化示例
根据信号的动态行为(图 5)，该数据集似乎非常适合应用小波变换。
3.2 CWT 在 Python 中的应用
正如已经提到的(2.2 节)，我们可以通过 CWT 系数的可视化手动区分不同的事件。这对于 HAR 数据集也是可能的吗？
为了找出这个问题，我们必须首先安装 Python 包py wavelet和“pip install PyWavelets”或“conda install pywavelets”，我们可以使用它们在我们的数据集上应用小波变换。
其次，我们必须为连续小波函数 pywt.cwt 定义一个方便的母小波和尺度大小。对于这种信号(图 5)，我们根据其最合适的形状选择 Morlet 母小波(图 2)。为了选择合适的比例范围，让我们考虑三个不同范围 32、64 和 128 的 CWT 系数，用比例图表示(图 6)。
图 6:随着尺度范围的扩大，关于信号行为的信息越来越多。
一般来说，规模较小的规模(在我们的例子 32)使更多的突然变化的焦点。如前所述，这些突然的变化往往是最重要的特征。否则，大范围的标度(在我们的例子中，64 或 128)提供了更多的信息(关于缓慢变化)，这可以提供更好的分类精度。然而，对于第二个选项，你需要一个更深入的 CNN。
对于下一个示例，64 的比例似乎是达到良好预测精度的一个有用的折衷方案。
图 7:基于通过尺度图的连续小波变换传感器数据的可视化来区分不同的 HAR 活动
正如您所看到的(图 7)，通过 scalogram 可视化 CWT 系数，手动区分不同的活动是可行的。请随意选择其他信号或样本，然后你会看到每个信号或多或少方便区分六个活动。例如，对于坐着、站着和躺着等非移动活动，仅使用 x、y 和 z 方向上的总加速度传感器数据，您将达不到良好的分类精度。
我敢肯定，你不愿意考虑和手动比较成千上万的标量图来确定每个样品的活性。为此，我们首先使用传统的神经元网络(3.3 节)，其次使用特征提取技术加上分类器(3.4 节)来自动分类 HAR 数据集的不同活动。
3.3 使用传统神经元网络(CNN)的模式检测
CNN 对于学习图像中标签的特征模式是非常有效的。这种神经元网络还可以像处理图像像素一样处理 2D 连续小波变换系数，以预测相应的活动。让我们看看这个组合是如何工作的。
但是，在我们开始向 CNN 提供信息之前，我们必须:
- 使用 pywt.cwt 函数转换 HAR 数据集的信号；和
- 将得到的系数转换成合适的格式。
在这种情况下，我们也将为 pywt.cwt 函数选择 Morlet 母小波和尺度大小 64，就像在 3.2 节中一样。此外，我们将所有系数矩阵(64x128)调整为正方形(64x64)。这个步骤不是绝对必要的，但是可以节省许多参数和计算资源，同时我们不应该丢失太多的图像细节(图 8)。
图 8:使用标量图对连续小波变换的 2D 系数进行下采样的影响的描述
作为第二点，我们仍然必须澄清如何将得到的 CWT 系数矩阵馈送到 CNN。这里，最好的方法是将九个信号的 2D 系数(图像)相互叠加，就像彩色图像的三个通道红、绿、蓝(RGB)一样。因此，可以同时考虑不同传感器数据之间的所有相关性，这是非常重要的。这里请注意:如果你把 9 个不同信号的 CWT 系数连接成一个 Numpy 数组(图像)，它们之间会有突变。这可能导致这样的效果，即由于突变，CNN 聚焦于边界，而不是每个信号的重要特征模式。因此，你需要一个更深入的 CNN 来忽略这种噪音。
为了便于说明，我们使用 LeNet-5 架构构建了一个简单的 CNN(图 9 ),并进行了两项改进:
图 9:具有最大池化和 ReLU 激活的传统神经元网络(CNN) LeNet-5 架构
- 最大池而不是平均池，因为当您想要提取极端特征(突变)以及当图像具有高像素密度(由于九个通道)时，最大池可能会达到更好的性能。
- 用修正线性单元(ReLU)激活函数代替双曲正切(Tanh)来克服消失梯度问题，加速训练并获得更好的性能。
让我们对模型进行训练和评估！
培训…
评估…
Accuracy: 94.91%
还不错！对于这个数据集来说，几乎 95%的准确性是非常好的，因为对于一个简单的模型来说，不同的人进行的类似的非运动(停留、躺下和坐着)和类似的运动(走路、上楼和下楼)之间的区别是不容易的。这个结果应该被认为是 CWT 和 CNN 的组合对于非平稳多时间序列/信号的分类是一个有用的选择的证据。我确信，通过 CNN 的改进(增加正则化、更多神经元等等)，其他 CNN 架构、超参数调谐或其他尺度大小(有或没有下采样)可以达到更好的结果。所以，让我们尝试另一种方法。
3.4 使用主成分分析(PCA)的特征提取
虽然我们在上一节中使用了所有 2D CWT 系数，如 CNN 的图像，但这次我们将选择每个尺度中最重要的系数来输入分类器。因此，我们应用 PCA 来提取具有最高变化的特征。如果你不熟悉 PCA 背后的逻辑，我向你推荐这个来源。
要选择每个标度变化最大的系数，我们必须:
- 像以前一样应用 pywt.cwt 函数；和
- 仅对单个分量应用 PCA，以获得每个尺度的最重要系数。
这样，我们对每个信号使用 64 个特征，而不是 64128。生成的新要素数据集的 2D 形状为(n_samples，576 (= 64 个要素 9 个信号)。
对于分类，我选择 XGBoost(eXtremeGradientBoosting)，这是目前最成功的 Kaggle 竞争分类器之一。 XGBoost 是一种针对速度和性能而设计的梯度推进、基于决策树的集成机器学习算法。想知道 XGBosst 为什么表现这么好，你可以看看这篇帖子。
在 HAR 数据集的背景下，重要的是选择目标“multi:softmax ”,以便能够对不止二进制类进行分类。此外，我们应用子采样(也称为 bagging)来减少方差和过度拟合。由此，子采样部分随机选择用于拟合每棵树的训练样本。
Accuracy: 92.67%
几乎 93%的准确率也是不错的结果。显然，这种方法在非运动活动(如坐着和站着)之间的分离稍好，因此在不同的行走活动之间的分离明显较差。与每个机器学习模型一样，您可以通过超参数调整来提高性能，在这种情况下，可以通过增加规模大小来获得更多输入特征。XGBoost 分类器足够强大，可以处理 576 个输入特征。大多数分类器可以独立地确定哪些特征是有用的，哪些是无用的。但是，当使用高得多的比例时，您应该考虑选择重要性最高的要素。
4 结论
在本文中，您已经看到了为什么以及如何使用强大的 CWT 来处理非平稳信号。CWT 与 CNN 或 PCA 以及分类器相结合的良好结果证明了这些方法是对每个事件的多个时间序列进行分类的极好选择。有如此多的不同算法和模型的可调配置会影响输出结果，以至于无法为此目的命名任何普遍有效的过程。根据我的经验，对于非平稳信号，连续(也包括离散)小波变换的性能大多优于其他信号处理技术，并且优于其他类型的模型(如使用原始 HAR 数据的简单递归神经元网络)的分类精度。
最后，我希望这篇文章让(连续)小波变换在数据科学中更受欢迎，就像在机器和深度学习中一样，并鼓励你尝试一下。
面向金融的 Python 多线程技术
并行计算及其在金融中的应用快速指南
并行计算
想象一下，一台计算机试图画四面墙，每面墙要花 30 分钟。如果计算机按顺序绘制所有四面墙，按照正常执行代码的方式，绘制所有四面墙需要(30 米)*(4 面墙)或 120 米。下面的代码用 Python 演示了这一点。
如果我们能同时粉刷所有四面墙会怎么样？这种想法被称为并行计算，在各自的线程上同时异步运行代码。如果计算机是多线程的(在它自己的线程上同时运行每个 paint_wall 函数),这个过程只需要 30 分钟就可以完成四面墙的绘制。下面的代码说明了用 Python 多线程处理这个过程。
这在金融领域对我们有什么帮助？算法交易系统负责在不同的时间框架内执行各种资产类别的交易。交易系统可以高频交易订单簿不平衡策略，同时分析指数中的头寸大小以对冲该策略。在这个系统中，两个过程同时发生，但需要不同时间范围的数据。在本文中，我的目标是给出一个简单的面向对象的方法来支持财务分析系统中的多线程。
线程化抽象类
考虑一个抽象类交易系统。抽象类维护了作为子类创建的所有交易系统的基本要求。也就是说，它包含一个驻留在定时无限循环中的函数。这是一个抽象交易系统的简化版本，用来说明多线程，但是你可以期待一个更实用的抽象类，包括交易数量、利润/损失和未结/已结/已结订单。
在这种情况下，抽象类接受两个参数，一个 ticker 和一个 timeframe。TradingSystem 类的每个实例将为自己分配 ticker 和时间框架，并创建一个线程无限循环，在时间框架期间休眠。这实际上允许我们管理每个子类中的什么和什么时候。
抽象类实现
下面是一个 NVIDIA 的交易系统，作为抽象 trading system 类的实现而创建。将 TradingSystem 类构造为一个超类使我们能够灵活地跨不同的时间框架开发特定的交易规则集。NVIDIA 交易系统每十秒钟从 yahoo finance 的 API 请求一个期权链(即 what )(即 when )。
量化发展和交易
如果你想在真实的交易环境中实现这一点，你可以看看我其他的关于用 Java 和 Python 开发算法交易系统和策略的文章。
Python 中的多线程与多处理
劳尔·卡乔·奥斯在 Unsplash 上的照片
入门
两者之间的区别，以及如何和何时使用它们
Python 通常被认为是一种近乎淫秽的编程语言。一个自由主义的地方，在这里一切都被允许，我们最狂野的梦想都得以实现。忘记标签和定义，尤其是括号。这是一种欢迎所有人的语言，从最有经验的程序员(那个因为某些你不想知道的原因仍然使用 Fortran 的古怪家伙)到自负的千禧一代新手。嗯，除非你和multiprocessing或multithreading一起工作。
在 Python 中处理并行性和并发性的挑战始于这样一个事实，即使是互联网也不太了解它是如何工作的。事实上，我在 stackoverflow 回复上发现了多个错误的陈述(有些有很高的向上票数)，甚至是看起来非常严肃的博客。因此，不同于其他情况，其中编程也可能被称为堆栈溢出，在开始使用 Python 中的multiprocessing或multithreading之前，你最好至少知道你正在做的事情的基础。
否则，你可能会过得不好。
基础知识
当寻找 python multiprocessing和multithreading之间的区别时，人们可能会有这样的印象:它们的工作方式非常相似。这真是大错特错。主要区别在于:
- 进程是在处理器内核中执行的独立实例。线程是进程的组件，并发运行(在该进程内部)。
- 进程不共享同一个内存空间，而线程共享(它们妈妈的内存，诗意吧？).
- 线程更轻，导致的开销更少。此外，因为它们在一个进程中共享相同的内存，所以共享数据更容易、更快、更安全。
- 只有使用
multiprocessing才能实现真正的平行。这是因为在一个进程时间空间内，一个给定的时间只能执行一个线程。这是由 Python 的全局解释器锁(GIL)保证的(见 Python GIL 在 RealPython )。 - 进程的执行由操作系统调度，而线程由 GIL 调度。
我们还应该理解并发和并行的区别。
- 并发执行是指两个或两个以上的任务同时进行。
- 并行执行意味着两个或更多的任务同时被执行。
现在记住:multithreading实现并发，multiprocessing实现并行。流程在独立的处理节点上运行。
流程并行运行。线程并发执行。作者图片
使用案例
那么我们如何在multiprocessing和multithreading之间做出选择呢？简短的回答是:
- 用于 I/O 密集型任务的多线程技术；
- 针对 CPU 密集型任务的多处理(如果您有多个内核可用)
但是为什么呢？
多线程:I/O 绑定任务
假设你有一个任务，它依赖于系统的另一部分或者用户的输入。
没有理由为那项工作指定一个进程，因为它会花费大部分时间等待刺激开始工作。如果将一个计算节点专用于此，那将是一种资源浪费，而且不会带来任何加速，因为瓶颈不在执行上，而在第三方调用上。在这种情况下，multithreading就是要走的路。
的确，multithreading通常被实现来处理 GUI。例如，在文本编辑器程序中，一个线程将负责从键盘获取输入，而另一个线程将检查拼写，第三个线程可以处理格式配置。
I/O 密集型程序也可以直接从multithreading中受益，因为它们的瓶颈通常是读或写操作(例如，在 web scrappers 中是下载)。查看以下示例:
这个函数将一些 URL 地址加载到内存中，并将它们写入一个本地文本文件(50 次，总是覆盖同一个文件)。这是相当愚蠢的，但它的目的只是强调 I/O 绑定的执行。你可以在这个笔记本里查看这段代码并自己执行。
让我们在 16 个地址的列表上运行该方法，并检查一些不同线程数的执行时间。这将为我们带来以下图表(在 MacBook Air 2019 上执行)。
作者图片
其中一个线程的结果代表代码的串行执行。从图中我们可以看出,multithreading能够大大减少算法的执行时间。我们可以继续增加线程的数量，但是一旦达到每个地址都由一个线程处理的程度，这种增加就会停止。
多重处理:CPU 限制的任务
现在想象一下，你在内存中加载了大量的数据，这些数据都需要处理。受计算限制的程序将从多重处理中受益，因为它们的瓶颈是时间和资源。图像和图形处理就是一个很好的例子。它们由大量的数学运算组成，因为它们的数据是独立的，所以通常可以分成单独的任务。在这方面，GPU 是最先进的硬件，旨在并行处理大块数据。
为了模拟计算密集型算法，我们将使用以下代码:
同样，你可以在这个笔记本中检查这个代码，然后自己执行它(我 强烈 建议你看一下，因为我们必须做一些变通办法才能在 windows 上正确执行它)。
我的 MacBook 采用了带超线程的双核处理器，因此没有必要强制在其上运行 4 个以上的进程。以下是该基准测试的性能测试结果:
作者图片
multithreading没有提供加速(执行时间实际上是相同的)。然而，当使用multiprocessing时，我们有了显著的加速。由于流程管理花费的时间，将执行时间减少到原来的四分之一是不够的。请记住，进程比线程重得多。
I/O 密集型任务的多重处理
即使这不是他们的最佳用例，也没有理由期望multiprocessing在 I/O 密集型任务上表现不佳。这是一种资源浪费:想象一下，将一个处理器内核专用于一个函数，该函数在执行的很大一部分时间里，只是等待输入。一个处理器，即使是一个集群，也只有这么多的处理节点。我们最好将它们用于真正的应用并行化，只有通过这些方法才能加速。
但是为了科学起见，如果我们使用multiprocessing执行第一个 I/O 绑定代码，会发生什么呢？下图显示了这一点。
作者图片
正如所料，multiprocessing也能够加速 I/O 限制的计算。同样值得注意的是，我们保持了 8 个进程的加速。原因是在这种情况下，进程开始像线程一样执行。加速不是来自并行性，而是来自并发性。
数据科学示例
现在，让我们更深入地了解如何在 Python 中实现多处理和多线程，以及数据科学家如何从中获益。有许多不同的方法可以做到这一点，我鼓励您从文档中获得一些想法(这里、这里、和这里)，并在我在本笔记本中作为练习提供的示例模型上尝试它们。
从广义上讲，数据科学项目遵循四个步骤:
- 获取数据；
- 处理数据；
- 对数据做点什么；
- 存储其他数据
现在，你可能会说:“不，我的项目完全不同”。嗯，恕我不敢苟同，但我相信你可以通过这篇博文获得一些关于如何加速你自己与众不同的项目的想法。
记住黄金法则:
multithreading用于 I/O 绑定任务，而multiprocessing用于 CPU 绑定任务。
现在，不难理解“获取数据”和“存储其他数据”步骤可能是我们应该使用multithreading的步骤。所有其他的(“处理数据”和“用数据做点什么”)使用multiprocessing可能会更好。您可能认为处理大量数据可能会出现 I/O 瓶颈，在某些情况下，您可能是对的。如果是这种情况，您应该尝试将这种处理分成“获取数据”和“处理数据”两部分，以便可以将最佳策略应用于每一部分。
文本分类
让我们看看如何在一个经典的自然语言处理(NLP)问题中应用我们所学的知识:文本分类。这个想法是通过文本找出一篇新闻文章的类别(例如:它是否应该被分类为“体育”、“金融”、“经济”等)。
如果您只是想了解如何在实际项目中使用多重处理和多线程，就跟着做吧，您不需要了解 NLP 的任何知识就能理解这个例子。但是，如果你对主题感兴趣，你应该从研究什么是单词向量开始。喜欢这篇文章。你也可以关注这个 GitHub 库,我和我的一个同事正在那里开发一些文本分类模型(那里有一些很酷的笔记本)。
我们的项目非常简单，我们将:
- 从路透社获取一些包含新闻及其各自标签的数据(定义它们是什么类型的新闻)(数据源)；
- 使用
GloVe预训练的单词向量(从维基百科训练而来)对它们进行矢量化(GloVe project page)； - 使用带有
scikit-learn的随机森林训练一个模型，在给定的标签下对文本进行分类。
到目前为止，应该很容易看出在 Python 中使用multithreading可以加速步骤 1，而步骤 3 应该使用multiprocessing。
加载数据
让我们从预训练的手套单词向量加载开始。你可以在这个笔记本里查看完整代码并自己执行。加载这个预先训练好的单词向量文件会花费很多时间。这个文件相当长，我们必须逐行处理。每行包含一个单词，然后是单词向量的每个维度的值列表。
GloveVectorizer()在其__init__函数中加载预训练向量，可以异步或串行完成。这是它执行基本的逐行文件读取的方式:
下面是multithread的实现:
我再次强烈建议你检查一下它是如何在完整代码中实现的。
ThreadPoolExecutor异步运行它的线程。最后一个for循环用于保证只有在提交给执行器的所有线程完成后，执行才会继续。查看 Python 文档了解更多关于ThreadPoolExecutor如何工作的细节。
但是用multithreading加载向量的速度有多快呢？在我的 MacBook Air 中，第一个串行版本在大约269.19898986816406s处加载了 40 万个单词向量。异步方法在27.559515953063965s中加载 400000 个字向量，使用 10 个工人(它可能用更少的工人达到相同的执行时间，因为瓶颈是读取行，而不是处理)。
训练模型
现在酷的部分:培训和测试。
对我们来说幸运的是，scikit-learn本身就提供了multiprocessing，只需在模型的参数上进行设置。下面的两个代码示例用相同的数据串行地或使用一组jobs(映射到scikit-learn中的流程)训练一个相同的模型。
在scikit-learn中使用多重处理就像设置n_jobs模型参数一样简单。在这里，我们将它设置为两个:
这太简单了，你可能会怀疑它是否有用。但确实如此。下面的条形图显示了同一型号在不同工作数量下的培训时间:
作者图片
哦，如果你好奇的话，这个模型的准确性(RandomForestClassifier.scoreTrain)一点也不差:
Train score: 0.9992707383773929
Test score: 0.9346733668341709
结论
我认为它涵盖了几乎所有的东西。最后一个例子展示了如何使用 Python 多处理和多线程特性来加速实际项目，有时只需很少甚至不需要修改代码。然而，并非所有闪光的东西都是金子。当期待 python 中更复杂的并行和异步执行时，您很快就会发现，事情会变得相当混乱。
Python 中多元线性回归的逐步实现
迈克尔·泽兹奇在 Unsplash 上的照片
学习用 Python 从头开始开发任意数量变量的多元线性回归。
线性回归可能是最简单的机器学习算法。它对初学者来说非常好，因为它使用简单的公式。所以，这对学习机器学习概念是有好处的。在这篇文章中，我将尝试一步一步地解释多元线性回归。
概念和公式
线性回归使用我们在学校都学过的简单公式:
Y = C + AX
提醒一下，Y 是输出或因变量，X 是输入或自变量，A 是斜率，C 是截距。
对于线性回归，我们遵循相同公式的这些符号:
如果我们有多个独立变量，线性回归的公式将如下所示:
在这里，‘h’被称为假设。这是预测的输出变量。θ0 是偏置项，所有其他θ值是系数。它们在开始时是随机初始化的，然后用算法进行优化，使该公式能更接近地预测因变量。
成本函数和梯度下降
当θ值在开始时被初始化时，该公式不被训练来预测因变量。假设与原始输出变量“Y”相差甚远。这是估计所有训练数据的累积距离的公式:
这被称为成本函数。如果你注意到了，它从假设(预测输出)中减去 y(原始输出)，取平方省略负数，求和除以 2 乘以 m，这里 m 是训练数据的个数。你可能会看到，成本函数是原始产量和预测产量之间的差异。机器学习算法的思想是最小化成本函数，使得原始输出和预测输出之间的差异更接近。为此，我们需要优化θ值。
这是我们更新θ值的方法。我们取成本函数相对于每个θ值的偏导数，并从现有的θ值中减去该值，
这里，α是学习率，它是一个常数。我没有给出所有θ值的相同公式。但是对于所有的θ值，公式都是一样的。微分后，公式为:
这叫做梯度下降。
逐步实现算法
我要用的数据集来自 Andre Ng 在 Coursera 上的机器学习课程。我会在本页底部提供链接。请随意下载数据集并使用本教程进行练习。如果对你来说是新的，我鼓励你在阅读的时候用数据集来练习。这是理解它的唯一方法。
在这个数据集中，只有两个变量。但是我为任意数量的变量开发了算法。如果对 10 个变量或 20 个变量使用相同的算法，应该也可以。我会用 Python 中的 Numpy 和 Pandas 库。所有这些丰富的 Python 库使得机器学习算法变得更加容易。导入包和数据集:
import pandas as pd
import numpy as npdf = pd.read_csv('ex1data2.txt', header = None)
df.head()
- 为偏置项添加一列 1。我选择 1 是因为如果你把 1 乘以任何值，那个值都不会改变。
df = pd.concat([pd.Series(1, index=df.index, name='00'), df], axis=1)
df.head()
2.定义输入变量或自变量 X 和输出变量或因变量 y。在该数据集中，列 0 和 1 是输入变量，列 2 是输出变量。
X = df.drop(columns=2)
y = df.iloc[:, 3]
3.通过将每列除以该列的最大值来规范化输入变量。这样，每列的值将在 0 到 1 之间。这一步不是必需的。但它使算法更快地达到最优。另外，如果您注意到数据集，与列 1 的元素相比，列 0 的元素太大了。如果对数据集进行规范化，就可以防止第一列在算法中过于突出。
for i in range(1, len(X.columns)):
X[i-1] = X[i-1]/np.max(X[i-1])
X.head()
4.初始化θ值。我把它们初始化为 0。但是任何其他数字都可以。
theta = np.array([0]*len(X.columns))#Output: array([0, 0, 0])
5.计算训练数据的数量，在上式中表示为 m:
m = len(df)
6.定义假设函数
def hypothesis(theta, X):
return theta*X
7.使用上面解释的成本函数的公式来定义成本函数
def computeCost(X, y, theta):
y1 = hypothesis(theta, X)
y1=np.sum(y1, axis=1)
return sum(np.sqrt((y1-y)**2))/(2*47)
8.写出梯度下降的函数。该函数将 X，y，theta，学习率(公式中的 alpha)和时期(或迭代次数)作为输入。我们需要不断更新θ值，直到成本函数达到最小值。
def gradientDescent(X, y, theta, alpha, i):
J = [] #cost function in each iterations
k = 0
while k < i:
y1 = hypothesis(theta, X)
y1 = np.sum(y1, axis=1)
for c in range(0, len(X.columns)):
theta[c] = theta[c] - alpha*(sum((y1-y)*X.iloc[:,c])/len(X))
j = computeCost(X, y, theta)
J.append(j)
k += 1
return J, j, theta
9.使用梯度下降函数获得最终成本、每次迭代中的成本列表以及优化的参数θ。我选择α为 0.05。但是你可以尝试使用其他值，比如 0.1，0.01，0.03，0.3，看看会发生什么。我反复运行了 10000 次。请尝试更多或更少的迭代，看看有什么不同。
J, j, theta = gradientDescent(X, y, theta, 0.05, 10000)
10.使用优化的 theta 预测输出
y_hat = hypothesis(theta, X)
y_hat = np.sum(y_hat, axis=1)
11.绘制原始 y 和预测输出“y_hat”
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure()
plt.scatter(x=list(range(0, 47)),y= y, color='blue')
plt.scatter(x=list(range(0, 47)), y=y_hat, color='black')
plt.show()
一些输出点几乎与预测输出重叠。有些接近但不重叠。
12.绘制每次迭代的成本，以观察行为
plt.figure()
plt.scatter(x=list(range(0, 10000)), y=J)
plt.show()
成本随着每次迭代而不断下降。这表明该算法运行良好。
我希望，这是有帮助的，你也在为自己尝试。如果你正在阅读这篇文章以学习机器学习概念，我鼓励你下载数据集并尝试自己运行所有代码。以下是数据集的链接:
[## rashida 048/用 Python 进行机器学习
通过在 GitHub 上创建一个帐户，为 rashida 048/用 Python 进行机器学习开发做出贡献。
github.com](https://github.com/rashida048/Machine-Learning-With-Python/blob/master/ex1data2.txt)
Python 中的多元逻辑回归
用于分类的机器学习技术
你很可能一天用几十次机器学习，甚至都不知道。在谷歌上进行简单的网络搜索效果如此之好，是因为其背后的 ML 软件已经学会了计算出哪些页面应该被排名以及如何排名。同样，你也不用费力地阅读大量的垃圾邮件，因为你的电脑已经学会区分垃圾邮件和非垃圾邮件。
机器学习是分析大量数据的一种聪明的替代方法。根据执行的任务和输出的性质，您可以将机器学习模型分为三种类型:
- 回归:待预测的输出变量为连续变量
- 分类:待预测的输出变量为分类变量
- 聚类:没有预先定义的标签概念分配给所形成的组/聚类。
分类领域中的大量重要问题领域——监督机器学习的一个重要领域。尽管逻辑回归中有“回归”一词，但事实上，它是最基本的分类算法之一。与输出连续数值的线性回归不同，逻辑回归使用逻辑 sigmoid 函数来转换其输出，以返回一个概率值，然后可以将该概率值映射到两个或多个离散类。
逻辑回归的类型:
- 二进制(对/错，是/否)
- 多类(羊、猫、狗)
- 序数(工作满意度——不满意、满意、高度满意)
在我们开始构建多元逻辑回归模型之前，我们需要熟悉一些概念前提。
乙状结肠功能
前面我们谈到了将值映射到概率。这可以通过调用 sigmoid 函数来实现，该函数会将任何实数值映射到 0 和 1 之间的另一个值。机器学习使用这个函数将预测映射到概率。
数学上，
其中，f(x)= 0 和 1 之间的输出(概率估计值)
从图形上看，
代码:
**def** sigmoid(z):
**return** 1.0 / (1 + np.exp(-z))
决定边界
为了更好地理解逻辑回归假设函数所计算的内容，我们需要知道一个叫做“决策边界”的概念。我们使用的预测函数将返回一个介于 0 和 1 之间的概率分数。为了将这个分数映射到一个离散的类(正/负，真/假)，我们选择一个阈值，比如 0.5，高于这个阈值，我们将值分类为类 1，低于这个阈值，值将属于类 2。
例如，假设预测函数返回值 0.8，这将被分类为真/正(因为它高于选定的阈值)。另一方面，值 0.3 将被归类为假/负。在处理多元逻辑回归时，我们选择预测概率最高的类。
赔率和对数赔率
逻辑回归使用的是概率而不是比例。几率简单地计算为两种可能结果的比例之比。设 p 是一个结果的比例，那么 1-p 就是第二个结果的比例。
数学上，
赔率= p/1-p
逻辑回归的统计模型是
log (p/1-p) = β0 + β1x
多元逻辑回归
为了理解多变量逻辑回归的工作原理，我们将考虑一个在线教育平台的问题陈述，在该平台上，我们将查看帮助我们选择最有希望的潜在客户的因素，即最有可能转化为付费客户的潜在客户。
注: 请按照下面给定的链接(GitHub Repo)查找数据集、数据字典和详细的解决这个问题的语句。
[## sowmya20/LeadConversion_LogReg
在 GitHub 上创建一个帐户，为 sowmya20/LeadConversion_LogReg 开发做贡献。
github.com](https://github.com/sowmya20/LeadConversion_LogReg)
数据清理&准备
一旦加载了必要的库和数据集，让我们使用 head()命令来看看前几个条目。
shape 命令告诉我们数据集总共有 9240 个数据点和 37 列。下面列出了该数据集中的列名:
正如您所看到的，列出的大多数特性变量都非常直观。请查阅数据字典，以便更好地理解它们。
进一步的分析揭示了数据集中分类变量的存在，我们需要为其创建虚拟变量。在此之前，我们处理数据集以删除空值列和行以及我们认为对该分析不必要的变量(例如，城市、国家)。快速检查保留行的百分比告诉我们 69%的行已被保留，这看起来足够好了。
测试列车拆分
此数据集的目标变量是“Converted ”,它告诉我们过去的销售线索是否被转换，其中 1 表示它被转换，0 表示它没有被转换。
导入 test_train_split 库，对数据集进行 70%训练和 30%测试分割。
数据集中很少有数值变量具有不同的比例，因此使用最小最大比例缩放器缩放这些变量。变量将以这样的方式缩放，即使用数据中的最大值和最小值，所有值都位于 0 和 1 之间。
模型建立
转到模型构建部分，我们看到这个数据集中有许多我们无法处理的变量。因此，我们将使用 RFE 从该池中选择一小部分要素。下面是相同的代码:
# Import 'LogisticRegression' and create a LogisticRegression objectfrom sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()# Import RFE and select 15 variablesfrom sklearn.feature_selection import RFE
rfe = RFE(logreg, 15)
rfe = rfe.fit(X_train, y_train)
我们现在将使用 statsmodels 来创建基于 p 值和 Vif 的逻辑回归模型。首先，我们将在添加一个常数后在训练集上创建一个模型，并输出摘要。这是广义模型回归结果的样子:
我们还将以类似的方式计算所有要素的 VIF，并删除具有高 p 值和高 VIF 的变量。在用新的特征集重新拟合模型之后，我们将再次检查 p 值和 Vif 所在的范围。如果合适，下一步我们将继续进行模型评估。
车型评测
我们现在将预测训练集上的概率，并创建一个包含实际转换标志和模型预测的概率的新数据帧。添加一个列来捕获条件等于 1(如果支付概率的值大于 0.5)或 0 的预测值。
在开始评估模型之前，需要熟悉一些重要的概念:
混乱矩阵
我们将分类准确度定义为正确预测与总预测的比率。这种方法的一个主要问题是，它常常隐藏了您可能需要更好地理解模型性能的细节。一个很有可能遇到这个问题的例子是当你处理一个超过两个类的数据时。你可以达到 85%的准确率，但是你不知道这是因为你的模型忽略了一些类还是所有的类都预测的一样好。
混乱矩阵解决了这个问题。它告诉你你的模型在做预测时被混淆的确切次数。
它是对分类模型预测结果的总结。
在两类问题中，我们通过将事件行指定为“正”并将非事件行指定为“负”来构建混淆矩阵。预测的事件列被指定为“真”，非事件列被指定为“假”。
该矩阵将由以下要素组成:
(I)真阳性——用于正确预测的事件值
(ii)真阴性-对于正确预测的无事件值
(iii)假阳性——错误预测的事件值
(iv)假阴性——错误预测的无事件值
从混淆矩阵中得出的一些基本性能指标有:
(a) 灵敏度:灵敏度(SN)的计算方法为正确的阳性预测数除以阳性总数。它也被称为回忆(REC)或真阳性率(TPR)。
数学上，
(b) 特异性:特异性(SP)计算为正确阴性预测数除以阴性总数。它也被称为真实负利率(TNR)。
数学上，
(c) 精度:精度(PREC)的计算方法是正确的肯定预测数除以肯定预测总数。它也被称为阳性预测值(PPV)
数学上，
(d) 回忆:这是我们正确预测的所有现有阳性的分数。
数学上，
我们将使用上述矩阵和指标来评估模型。0.5 是随机选择的值，用于测试模型性能。我们需要优化阈值以获得更好的结果，我们将通过绘制和分析 ROC 曲线来做到这一点。
接收器工作特性曲线基本上是位于 0 和 1 之间的多个阈值的假阳性率和真阳性率之间的曲线。
ROC 曲线帮助我们比较具有不同阈值的不同模型的曲线，而 AUC(曲线下面积)为我们提供了模型技巧的总结。
在这里，AUC 是 0.86，这似乎很好。为了找到最佳分界点，让我们也检查不同概率分界点下模型的灵敏度和特异性，并绘制相同的图。
在 0.42 处，三个指标的曲线似乎相交，因此我们将选择它作为临界值。(您可能希望再次使用这一点来计算指标)我们将按照相同的方法对测试集进行预测。
精确召回权衡
在建立分类模型时，我们需要同时考虑精度和召回率。牺牲一个值来增加另一个值总是可能的(侧重于召回的模型/侧重于精度的模型)。在为这两个指标选择最佳值时，我们应该始终牢记我们要解决的问题类型。
让我们检查一下我们选择的临界值(即 0.42)的权衡。
权衡曲线和指标似乎表明我们选择的截止点是最佳的。因此，我们将在测试集上运行最后一次预测，并确认指标。
# Let's check the overall accuracymetrics.accuracy_score(y_pred_final['Converted'], y_pred_final.final_predicted)TP = confusion2[1,1] # true positive
TN = confusion2[0,0] # true negatives
FP = confusion2[0,1] # false positives
FN = confusion2[1,0] # false negatives# Calculate PrecisionTP/(TP+FP)# Calculate RecallTP/(TP+FN)
度量标准似乎适用于测试数据。看起来我们已经创建了一个不错的模型，因为测试和训练数据集的指标都不错。
现在，您已经熟悉了使用 Python 构建和评估逻辑回归模型的基础知识。通常，这是一种简单的方法:
(i) 导入必要的包和库
(二)数据清洗、转换
(三)分类用现有数据创建和训练模型
(四)评估并检查模型性能
(v) 对测试集进行预测
多元正态分布
多元正态分布呢？它们基本上是几个正态分布的变量捆绑在一起吗？让我们来看看。
正态分布，也称为高斯分布，是最常见的分布之一。一个主要原因是，独立随机变量的归一化和趋向于正态分布，而不管单个变量的分布如何(例如，您可以添加一组仅取值为-1 和 1 的随机样本，然而随着样本数量的增加，和本身实际上变成正态分布)。这就是所谓的中心极限定理。但是当你有几个正态分布的时候，情况就变得有点复杂了(别担心，没那么多)。
常态分布
先说单个正态分布。
假设我有一个随机变量(比如我吃完午餐所花的时间…)，我对它进行 10000 次采样(28 年来每天都做记录…)，结果会是什么样？
图一
对我来说，它可能看起来像上面的东西。由于明显的原因，它将高于 0 分钟，并将在 20 分钟左右达到峰值。当我没有太多事情要做的时候，有时我会花更长的时间来完成，有时我可能会在桌子上吃得很快，这样我就可以去工作了。
这是正态分布吗？号码
然而，它的对数(自然对数)是正态分布:
图 2
注意:
- 它是对称的。
- 它的平均值是 3。
- 它的标准差大约是 0.5(相信我，我把它弄糊涂了)
概率密度函数可以表示为:
这就是著名的正态分布，注意钟形！(顺便说一下，图 1 被称为对数正态分布，因为它的对数是正态分布)。
如果你的正态分布的均值是 0，标准差是 1，那么它就叫做标准正态分布。
一些看似随机但实际上定义了正态分布特征的事情:
- 样本有 68.3%的概率在平均值的 1 个标准差之内(或 31.7%的概率在平均值之外)。
- 峰度为 3。
下面是生成它们的 python 代码:
import numpy as np
import pandas as pd
from scipy.stats import normnum_samples = 10000
samples = norm.rvs(loc=3, scale=.5, size=(1, num_samples))[0]
lunch_time = pd.Series(np.exp(samples),
name='lunch time in minutes')
log_lunch_time = pd.Series(samples,
name='log of lunch time in minutes')
不相关正态分布
现在我们已经复习了正态分布，什么是多元正态分布？
首先想到的是两个或更多的正态分布变量，这是真的。假设我生成两个正态分布变量的样本，每个样本 5000 个:
import numpy as np
from scipy.stats import norm
num_samples = 5000
signal01 = norm.rvs(loc=0, scale=.5, size=(1, num_samples))[0]
signal02 = norm.rvs(loc=0, scale=1, size=(1, num_samples))[0]
信号 01 和信号 02 肯定是正态分布的:
不要介意蓝色直方图顶部的怪异，样本数量不够多
但是，还有更多的东西，让我们将它们绘制成散点图来看看:
你看到这两个分布的散点图是如何关于 x 轴和 y 轴对称的了吗？这是因为这两种分布完全不相关:
np.corrcoef(signal01, signal02)
'''
Out[1]:
array([[1\. , 0.00384419],
[0.00384419, 1\. ]])
'''
这是实现多变量正态分布的棘手部分，即使向量中的每个变量本身都是规则的正态分布，它们也可以彼此相关。
多元正态分布
让我们生成一些相关的二元正态分布。
你会问，你如何着手做这件事？
第一步是生成 2 个样本标准法向量:
import numpy as np
from scipy.stats import normnum_samples = 5000
signal01 = norm.rvs(loc=0, scale=1, size=(1, num_samples))[0]
signal02 = norm.rvs(loc=0, scale=1, size=(1, num_samples))[0]
创建所需的方差-协方差(vc)矩阵:
# specify desired std
std01 = 11.2
std02 = 0.5
std_m = np.array([
[std01, 0],
[0, std02]
])
# specify desired correlation
corr_m = np.array([
[1, .75],
[.75, 1]
])
# calc desired covariance (vc matrix)
cov_m = np.dot(std_m, np.dot(corr_m, std_m))
然后用 Cholesky 的算法分解 vc 矩阵:
from scipy.linalg import cholesky
cky = cholesky(cov_m, lower=True)
现在，只需将该矩阵乘以不相关信号，即可获得相关信号:
corr_data = np.dot(cky, [signal01, signal02])
signal01 = corr_data[0]
signal02 = corr_data[1]
np.corrcoef(signal01, signal02)'''
Out[1]:
array([[1\. , 0.75279088],
[0.75279088, 1\. ]])
'''
让我们来看看由此产生的散点图:
看到散点图不再关于 x 轴或 y 轴对称，而是变得更像一条线了吗？这就是关联的效果。
衍生物
这个过程为什么有效？
这实际上是线性协方差定义的一个非常简单的结果:
给定一个随机变量向量:
向量的方差协方差定义为:
如果我们将 X 乘以矩阵 C，则所得向量的方差协方差为:
你看，由于原始 X 向量的分量是不相关的，方差协方差矩阵就等于:
这就是我们使用 Cholesky 分解的原因！我们定义了一个期望的方差协方差矩阵:
# calc desired covariance (vc matrix)
cov_m = np.dot(std_m, np.dot(corr_m, std_m))
它的乔莱斯基分解正好满足上面的等式！
不是多元正态分布吗？
你可能会问:
什么时候随机向量不是多元正态分布的？
嗯，首先，如果向量中的随机变量分量本身不是正态分布的，那么结果肯定不是多元正态分布的。
协方差矩阵也必须是半正定的，这意味着它必须是对称的:
# specify desired correlation
corr_m = np.array([
[1, .75],
[.75, 1]
])
如果你把它改成这样:
# specify desired correlation
corr_m = np.array([
[1, .75],
[.11, 1]
])
那么您得到的结果也肯定不是多元正态分布，因为这将意味着信号 01 和信号 02 的相关性不同于信号 02 和信号 01 的相关性…
哦，是的，你可以使用 numpy 的内置函数:multivariate _ normal:
mean = [0, 0]
cov = [[1, .5], [.5, 1]]
s1, s2 = np.random.multivariate_normal(mean, cov, 5000).T
但是它一点也不酷。
高维光谱数据中的多元异常检测
高维数据对于离群点检测尤其具有挑战性。稳健的 PCA 方法已经被开发来建立不受高维离群点影响的模型。这些异常值通常以它们偏离 PCA 子空间为特征。
图片由 Ricardo Gomez Angel 在 Unsplash 上拍摄
介绍
在激光光谱领域，异常值通常表现为明显偏离其他观察值的值，异常高或异常低——例如，湿度变化、样品表面的空间异质性、仪器参数漂移、人为误差等。或者是以前没有考虑到的光谱特征的细微变化，因为校准模型通常是在具有相对相似化学和物理属性的样品上训练的——我们称之为基质效应。
“异常值是一个与其他观测值相差如此之大的观测值，以至于让人怀疑它是由不同的机制产生的。”戴维·霍金斯
前一种情况的解决方案——被称为总异常值或极端值——通常很简单:我们修复错误并在必要时重复测量。后一种情况通常更复杂，需要先进的统计方法。然而，正如后面讨论的，除了在高维空间中无效之外，这些细微的变化通常很难用传统方法检测到。因此，面临的挑战是找到可靠的方法，既:
●快速
●对异常值或污染鲁棒
●适用于高维数据
在高维空间中，数据点非常稀疏，以至于所有点之间几乎都是等距的。换句话说，欧几里得距离的使用变得毫无意义。结果是数据点的突出程度彼此无法区分。由于这个原因，通过使用低维局部子空间可以最好地检测异常值，在该子空间中只有一个特征子集可能是相关的。
“离群值往往隐藏在低维子空间的异常局部行为中，这种越轨行为被全维分析所掩盖。”阿加尔瓦尔
马氏距离
标准且广泛使用的基于距离的方法包括计算马哈拉诺比斯距离。这类方法仅使用距离空间来标记异常观察值。第 i- 次观察的马氏距离(MD)由下式给出:
马哈拉诺比斯距离。
X 是大小为 n × p、的数据矩阵，其中 p 是变量的个数， n 是观测值的个数。 x ᵢ 是一个观察值(一行 X )， x̄ 是均值向量， C 是样本协方差矩阵，它给出了关于数据的协方差结构的信息——即由协方差矩阵指定的椭球形状。
稳健的 Mahalanobis 距离与样本(观察)数量的关系。
为了识别异常值候选，计算 MD 并与等于卡方分布的 0.975 分位数的截止值进行比较，其中 m 自由度， m 是变量的数量。这是因为多元正态数据的多维度遵循卡方分布。尽管, Hardin 和 Rocke (2005) 已经报告使用 F 分布找到了更好的近似值，特别是对于小样本量。尽管如此，卡方分布对于近似马哈拉诺比斯距离的平方仍然是相当好的。因此，如果出现以下情况，观察值将被视为异常值候选值:
马哈拉诺比斯距离的截止值。
然而，这种方法有两个主要问题:(1)算术平均值和样本协方差矩阵对异常值敏感,( 2)协方差矩阵 X ᵗ X 必须是可逆的——更正式地说是非奇异的。前者通过应用稳健统计学来解决，而后者显然是化学计量学中经常遇到的高维数据的严重限制，其中 p ≫ n. 事实上，即使选择使用稳健版本的 MD，也存在相同的限制，该 MD 源自最小协方差行列式(MCD)估计器，而不是经典的 MD。
稳健主成分分析
在化学计量学中，主成分分析(PCA)广泛用于探索性分析和降维，并可用作离群点检测方法。
事实上，PCA 得分经常与 Mahalanobis 距离(或 95%置信水平下的 Hotelling T)结合使用，以确定一个观测值离包含大多数观测值的椭圆区域的质心有多远。
植物样品的 LIBS 光谱的 PCA 得分，霍特林的 T 的置信限为 95%。数据点的透明度显示了每个样品对第一组分的贡献。最暗的样本是贡献最大的样本。
然而，这种方法并不稳健，因为传统的 PCA 依赖于样本协方差矩阵 C ，因此对异常值观测极为敏感，如上图所示。这样做的后果是双重的:一方面，由主成分解释的方差向异常值方向膨胀，因此掩盖了偏离常规观察值的观察值——所谓的 掩盖效应。另一方面，常规观测可能被错误地标记为异常值——所谓的 淹没效应。
相同的 PCA 分数，但是增加了两种颜色:(红色)和(蓝色)没有测量误差。前者(70 个样本)与无误差测量值(369 个样本)无法区分，尽管它们似乎集中在右上角，这可能指示类似的误差。
因此，为了避免这些影响，在过去的几十年中，已经提出了许多鲁棒版本的 PCA，它们基于协方差矩阵的鲁棒估计(每个都以它们的崩溃点为特征)，借助于 S 估计器、MM 估计器、(快速)MCD 估计器或重新加权的 MCD- (RMCD)估计器。然而，这些方法仅限于小规模或中等规模，因为稳健估计仅适用于观测值数量至少为变量数量两倍的情况(n2p)。
植物样本的稳健 PCA (Fast-MCD)评分。在进行稳健主成分分析之前，进行特征选择以降低维数。在这里，我们可以更好地区分有(红色)和没有(蓝色)误差的测量。结果是前者对第一分量的贡献最大(暗红色)。
植物样本的 3D 得分图。现在我们可以看到红色样本形成了两个独立的集群。第一个明显地与无误差的测量分开，而第二个仍然难以辨别，但是聚集在常规值之上。
已经开发了另一组健壮的 PCA 方法，它们更适合于在样本大小低于维度的情况下处理高维数据( p ≫ n )。这些方法是:
●投影寻踪鲁棒 PCA(PP-PCA)
●球形 PCA (SPCA)
●鲁棒 PCA (ROBPCA)
●鲁棒稀疏 PCA (ROSPCA)
稳健主成分分析的投影寻踪方法最初由李和陈(1985) 提出，其基础是寻找使投影指数最大化的方向。PP-PCA 使用中间绝对偏差(MAD)或 Qn 估计量作为投影指数，而不是方差。SPCA 是由洛坎托雷等人衍生出来的。(1999) 旨在将数据投影到单位球面上以减轻离群点影响。像 PP-PCA 一样，SPCA 使用 MAD 或 Qn-估计量作为对价差的稳健估计。
最近， Hubert 等人引入了 ROBPCA 和 ROSPCA。2005 年和由休伯特等人出版。2015 。ROBPCA 将投影寻踪方法与基于低维空间 RMCD 的稳健协方差估计相结合。有趣的是，ROBPCA 比上述方法快得多，并且具有适用于对称分布数据和偏斜数据的优点。 2009) 。另一方面，ROSPCA 源于 ROBPCA，但使用稀疏 PCA ( 邹等 2006 )代替 PCA。
不同类型的异常值
在简要回顾了基于鲁棒 PCA 的离群点检测方法之后，值得一提的是离群点可以分为两类:杠杆点和正交离群点。如下图所示，杠杆点类别可分为好 杠杆点和坏杠杆点。顾名思义，一个可以有正面效果，而另一个有负面效果。
二维 PCA 子空间上不同类型异常值的图示。图片来源:克里斯蒂安·古吉。
杠杆点和正交异常值通过它们各自的分数和正交距离来区分。这些距离告诉我们一个观察距离常规观察定义的椭圆中心有多远(得分= 0)。得分距离(SD)是属于 k 维 PCA 子空间的观测值和该子空间的原点之间的距离的度量。正交距离(OD)测量来自 k 维 PCA 子空间的观察的偏差，即缺乏拟合。
分数和正交距离的图示。图片来源:克里斯蒂安·古吉。
因此，杠杆点的特征在于高得分距离，而正交异常值的特征在于高正交距离。同样，好的和坏的杠杆点通过它们各自的正交距离来区分。不良杠杆点比良好杠杆点显示更高的正交距离。
在第 k 维 PCA 子空间上第 i- 次观察的得分距离由下式给出
得分距离
其中 l 是 MCD 散布矩阵的特征值，并且 t 是鲁棒分数，对于每个 j = 1，.。。， k 。像马哈拉诺比斯距离一样，远离平方得分距离的截止值是从具有 k 自由度的卡方分布的 0.975 分位数获得的。
得分距离的临界值。
相应的正交距离由下式给出
正交距离。
其中 P 是加载矩阵，③ₓ是中心的稳健估计。使用卡方分布的威尔逊-希尔弗蒂近似法获得正交距离的截止值。因此，正交距离的 2/3 次方近似呈正态分布。因此，异常值观察值的临界值由下式给出
正交距离的截止值。
其中 Z ₀.₉₇₅是标准正态分布的 0.975 分位数。
离群图
离群图提供了一个强大的图形工具，可以直观地识别不同类型的离群值。
异常值地图的插图。
对于数据集中的每个观察，分数距离和正交距离绘制在 x- 和 y 轴上。它们各自的截止值将地图分为四个象限:
—常规观测值在地图的左下角，
—正交异常值在地图的左上角，
—杠杆点在右侧，好的杠杆点在底部，不好的杠杆点在顶部。
使用植物样本的 LIBS 光谱从 ROBPCA 获得的异常值图。
上图是用 ROBPCA 得到的。处理大小为 439×7153 的数据矩阵需要 15.86 秒的执行时间(笔记本电脑，2.80GHz)。我们可以看到，大多数测量值都在常规观测值的象限内，而一些测量值被标记为正交异常值和不良杠杆点。其中一些是很好的杠杆点。另一方面，有误差的测量值大多是正交异常值，尽管有些被认为是常规观测值。
向量自回归(VAR)模型的现实应用
多元时间序列分析与预测的综合研究
维克多·罗德里格兹在 Unsplash 上的照片
多元时间序列分析
单变量时间序列数据只包含一个时间相关变量，而多变量时间序列数据包含多个时间相关变量。我们通常使用多元时间序列分析来建模和解释变量之间有趣的相互依赖和共同运动。在多变量分析中，假设与时间相关的变量不仅依赖于它们过去的值，还显示出它们之间的相关性。多变量时间序列模型利用相关性为特定的给定数据提供更可靠和准确的预测，尽管单变量分析通常优于多变量分析[1]。在本文中，我们应用了一种多变量时间序列方法，称为真实世界数据集上的向量自回归(VAR)。
向量自回归(VAR)
VAR 模型是一个随机过程，它将一组与时间相关的变量表示为它们自己的过去值和该组中所有其他变量的过去值的线性函数。
例如，我们可以考虑双变量时间序列分析，该分析将每小时温度和风速之间的关系描述为过去值的函数[2]:
温度(t) = a1 + w11温度(t-1) + w12风(t-1) + e1(t-1)
风(t) = a2 + w21温度(t-1)+w22 风(t-1) +e2(t-1)
其中 a1 和 a2 是常数；w11、w12、w21 和 w22 是系数；e1 和 e2 是误差项。
数据集
Statmodels 是一个 python API，允许用户探索数据、估计统计模型和执行统计测试[3]。它还包含时间序列数据。我们从 API 下载一个数据集。
要下载数据，我们必须安装一些库，然后加载数据:
import pandas as pd
import statsmodels.api as sm
from statsmodels.tsa.api import VAR
data = sm.datasets.macrodata.load_pandas().data
data.head(2)
输出显示了整个数据集的前两个观察值:
数据集的片段
该数据包含许多时间序列数据，我们仅采用两个时间相关变量“realgdp”和“realdpi”进行实验，并使用“year”列作为数据的索引。
data1 = data[["realgdp", 'realdpi']]
data1.index = data["year"]
输出:
数据片段
让我们将数据可视化:
data1.plot(figsize = (8,5))
随着时间的推移，这两个系列都显示出略有起伏的增长趋势。
静止
在应用 VAR 之前，两个时间序列变量都应该是平稳的。这两个序列都不是稳定的，因为这两个序列都不显示随时间变化的恒定均值和方差。我们也可以执行一个统计测试，如扩展的 Dickey-Fuller 测试(ADF ),使用 AIC 标准来寻找序列的平稳性。
from statsmodels.tsa.stattools import adfuller
adfuller_test = adfuller(data1['realgdp'], autolag= "AIC")
print("ADF test statistic: {}".format(adfuller_test[0]))
print("p-value: {}".format(adfuller_test[1]))
输出:
平稳性的统计测试结果
在这两种情况下，p 值都不够显著，这意味着我们不能拒绝零假设并得出序列是非平稳的结论。
差异
由于两个序列都不是平稳的，我们进行差分，然后检查平稳性。
data_d = data1.diff().dropna()
“实际国内生产总值”序列在对原始序列进行第一次差分后变得稳定，因为测试的 p 值具有统计显著性。
一元差分实际 gdp 数据的 ADF 检验
“real dpi”系列在对原始系列进行第一次差分后变得平稳，因为测试的 p 值具有统计显著性。
一个差分 realdpi 数据的 ADF 测试
型号
在本节中，我们将 VAR 模型应用于一个差分序列。我们对数据进行训练测试分割，并将最近 10 天的数据作为测试数据。
train = data_d.iloc[:-10,:]
test = data_d.iloc[-10:,:]
寻找 VAR 模型的最优阶
在 VAR 建模过程中，我们选择使用 AIC 的信息准则作为模型选择准则来进行最优模型识别。简而言之，我们根据最佳 AIC 分数选择 VAR 的阶数(p)。一般来说，AIC 会因模型过于复杂而对其进行惩罚，尽管复杂的模型在其他一些模型选择标准上可能表现得稍好一些。因此，我们期望在搜索顺序(p)时出现拐点，这意味着，AIC 分数应该随着顺序(p)变大而降低，直到某个顺序，然后分数开始增加。为此，我们执行网格搜索来研究最佳顺序(p)。
forecasting_model = VAR(train)results_aic = []
for p in range(1,10):
results = forecasting_model.fit(p)
results_aic.append(results.aic)
在代码的第一行:我们用训练数据训练 VAR 模型。剩下的代码:执行一个 for 循环，找出从 1 到 10 的拟合顺序的 AIC 分数。我们可以将结果可视化(AIC 相对于订单的得分)以更好地理解拐点:
import seaborn as sns
sns.set()
plt.plot(list(np.arange(1,10,1)), results_aic)
plt.xlabel("Order")
plt.ylabel("AIC")
plt.show()
研究 VAR 模型的最优阶
从图中可以看出，最低的 AIC 分数是在 2 的数量级上获得的，然后 AIC 分数显示出随着数量级 p 变大而增加的趋势。因此，我们选择 2 作为 VAR 模型的最优阶。因此，我们将订单 2 拟合到预测模型中。
让我们检查一下模型的概要:
results = forecasting_model.fit(2)
results.summary()
摘要输出包含很多信息:
预测
我们使用 2 作为拟合 VAR 模型的最佳阶数。因此，我们采用训练数据中的最后两步来预测下一步(即测试数据的第一天)。
预测测试数据
现在，在拟合模型后，我们预测测试数据，其中最后 2 天的训练数据设置为滞后值，步骤设置为 10 天，因为我们希望预测接下来的 10 天。
laaged_values = train.values[-2:]forecast = pd.DataFrame(results.forecast(y= laaged_values, steps=10), index = test.index, columns= ['realgdp_1d', 'realdpi_1d'])forecast
输出:
一阶差分预测
我们必须注意，上述预测是针对一个差分模型的。因此，我们必须将第一个差异预测转换为原始预测值。
forecast["realgdp_forecasted"] = data1["realgdp"].iloc[-10-1] + forecast_1D['realgdp_1d'].cumsum()forecast["realdpi_forecasted"] = data1["realdpi"].iloc[-10-1] + forecast_1D['realdpi_1d'].cumsum()
输出:
1 个差异系列和原始系列的预测值
前两列是 1 个差异系列的预测值，后两列显示原始系列的预测值。
现在，我们通过 VAR 可视化原始测试值和预测值。
realgdp 和 realdpi 的原始值和预测值
原始的 realdpi 和预测的 realdpi 在预测的日子里显示出相似的模式。对于实际 gdp:预测值的前半部分显示出与原始值相似的模式，另一方面，预测值的后半部分不遵循相似的模式。
总之，在本文中，我们讨论了多元时间序列分析，并在真实世界的多元时间序列数据集上应用了 VAR 模型。
也可以阅读文章— 一个真实世界的时间序列数据分析与预测 ，其中我应用了 ARIMA(单变量时间序列分析模型)对单变量时间序列数据进行预测。
参考
[1]https://homepage.univie.ac.at/robert.kunst/prognos4.pdf
[2]https://www . aptech . com/blog/introduction-to-the-fundamentals-of-time-series-data-and-analysis/
[3]https://www.statsmodels.org/stable/index.html
多元时间序列预测
Python 中向量自回归(VAR)的实现
使用时间序列数据来了解过去和预测未来是经济和公共服务的每个部门的商业决策的一个基本部分。零售企业需要了解下个月他们需要多少存货；电力公司需要知道他们是否应该增加容量以跟上未来 10 年的需求；呼叫中心需要知道他们是否应该雇佣新员工来应对更高的呼叫量——所有这些决策都需要进行短期和长期预测，而时间序列数据分析是预测过程的重要组成部分。
单变量时间序列建模是最常用的预测方法。例如，如果您知道历史收入数据的增长率、趋势和季节性，您就可以预测未来一段时间的收入。然而，这一过程背后有一个很大的假设，即影响收入的所有其他因素(如产品需求)将继续以类似的方式产生影响。但是，当影响产品需求的因素发生变化时(例如，新的竞争产品进入市场)，这种假设往往会失效。理解这种复杂的行为需要的不仅仅是简单的单变量时间序列预测，这就是多变量时间序列分析发挥作用的地方。
本文的目的是逐步实现一种叫做向量自回归 (VAR)的多元时间序列预测技术。首先，我会给出一个直觉，并展示它如何在一个简短的 4 步实施中工作，然后我会像一个典型的机器学习算法实施一样稍微深入一点，例如探索性数据分析和可视化，将数据分成训练和测试集，模型构建，性能评估等。
所以让我们开始吧。
简短版
短版真的很短；不应该超过 10 行 Python 代码，我只用 4 个简单的步骤就展示了这些代码
1)导入库
此时只需要两个库:pandas用于处理数据，和statmodels API 用于导入向量自回归模型。
import pandas as pd
import statsmodels.api as sm
from statsmodels.tsa.api import VAR
2)加载数据:
我正在从statsmodels API 加载一个玩具数据集。该数据有几个变量，但我只加载其中的几个进行演示。
macrodata = sm.datasets.macrodata.load_pandas().data
data = macrodata.iloc[:, 2:4]
data.tail(2)
3)合体模特
首先，用VAR()实例化模型，然后用fit()方法拟合模型。
model = VAR(data)
model_fit = model.fit()
4)做一个预测
现在，您可以使用模型提前一步进行预测了。结果打印出两个变量的数组。
pred = model_fit.forecast(model_fit.y, steps=1)
print(pred)
长篇版本
短版本很短，但长版本可能很长，这取决于你想在哪里停下来。您可以从将时间序列数据转换成一个 ts 对象开始，根据项目目标，进行各种各样的时间序列 EDA (探索性数据分析)来调整和评估模型性能。
1)导入库
所需的初始库集与“短”版本相同，但是我们添加了一个绘图库matplotlib来可视化时间序列对象。
# loading essential libraries first
import pandas as pd
import statsmodels.api as sm
from statsmodels.tsa.api import VAR
import matplotlib.pyplot as plt
2)导入、检查和争论数据
导入数据后，您应该经历您通常的数据争论仪式(选择感兴趣的列、重命名、汇总统计等。).但是一个必要的步骤是找出是否有 NA 值，如果有，你需要处理它们(见这里)。作为数据争论的一部分，出于可视化的目的，您可能还想以不同的方式分割/转换数据。
# data
mdata = sm.datasets.macrodata.load_pandas().data
df = mdata.iloc[:, 2:4]
df.head()
3)想象
如果您想对时间序列数据进行 EDA，您还需要做一些额外的工作，比如将数据转换成时间序列对象。但至少，您可能希望将数据可视化，以查看趋势线的样子以及它们之间的比较。它为您提供了模型评估所需的必要直觉。
plt.plot(df)
3)因果关系测试
你会想看看变量之间是否有关联。为此，你可以运行格兰杰因果关系测试。虽然顾名思义，这真的不是一个“因果关系”的测试，你不能说一个是另一个的原因，你只能说变量之间是否有关联。
# import for Granger's Causality Test
from statsmodels.tsa.stattools import grangercausalitytestsgranger_test = sm.tsa.stattools.grangercausalitytests(df, maxlag=2, verbose=True)
granger_test
4)拆分数据
与大多数机器学习算法一样，将数据分成训练集和测试集是一个好主意。
nobs = 4
df_train, df_test = df[0:-nobs], df[-nobs:]
5a)检查稳定性
对于时间序列建模，数据需要是静态的——这意味着如果数据中有趋势，你需要摆脱它。为了检查数据是否是稳定的，有一种测试叫做扩展的 Dickey-Fuller (ADF)测试。
# Augmented Dickey-Fuller Test (ADF Test)/unit root test
from statsmodels.tsa.stattools import adfullerdef adf_test(ts, signif=0.05):
dftest = adfuller(ts, autolag='AIC')
adf = pd.Series(dftest[0:4], index=['Test Statistic','p-value','# Lags','# Observations'])
for key,value in dftest[4].items():
adf['Critical Value (%s)'%key] = value
print (adf)
p = adf['p-value'] if p <= signif:
print(f" Series is Stationary")
else:
print(f" Series is Non-Stationary")#apply adf test on the series
adf_test(df_train["realgdp"])
adf_test(df_train["realcons"])
5b)制作数据文具
如果数据不是稳定的，你可以用几种方法，但最简单的一种是采用一阶差分。在进行第一次差分后，您需要返回到上一步，再次测试数据现在是否是稳定的。如果不是，第二个区别可能是必要的。
# 1st difference
df_differenced = df_train.diff().dropna()# stationarity test again with differenced data
adf_test(df_differenced["realgdp"])
6)建模
现在，您可以用VAR()实例化模型，然后使模型适合第一个差异数据。运行模型后，您可以查看下面的总结结果。
# model fitting
model = VAR(df_differenced)
results = model.fit(maxlags=15, ic='aic')
results.summary()
7)预测
既然你已经建立了你的模型，是时候玩它并做实际的预测了。在这里，我要求模型预测未来 5 步。该模型为这两个变量返回 5 个预测值的数组。
# forecasting
lag_order = results.k_ar
results.forecast(df.values[-lag_order:], 5)
8)绘图
现在可以绘制预测值以及相关的标准误差。
# plotting
results.plot_forecast(20)
9)评估
这是使用fevd()函数的预测误差方差分解(FEVD)方法评估预测模型的额外步骤。
# Evaluation
fevd = results.fevd(5)
fevd.summary()
10)反转
还有最后一步。您没有使模型适合原始数据，因为您必须在步骤 5b 中转换(第一次差分)它以使数据稳定。所以预测结果需要倒回到原来的形式。
# forecasting
pred = results.forecast(results.y, steps=nobs)
df_forecast = pd.DataFrame(pred, index=df.index[-nobs:], columns=df.columns + '_1d')
df_forecast.tail()# inverting transformation
def invert_transformation(df_train, df_forecast, second_diff=False):
"""Revert back the differencing to get the forecast to original scale."""
df_fc = df_forecast.copy()
columns = df_train.columns
for col in columns:
# Roll back 2nd Diff
if second_diff:
df_fc[str(col)+'_1d'] = (df_train[col].iloc[-1]-df_train[col].iloc[-2]) + df_fc[str(col)+'_1d'].cumsum()
# Roll back 1st Diff
df_fc[str(col)+'_forecast'] = df_train[col].iloc[-1] + df_fc[str(col)+'_1d'].cumsum()
return df_fc# show inverted results in a dataframe
df_results = invert_transformation(df_train, df_forecast, second_diff=True)
df_results.loc[:, ['realgdp_forecast', 'realcons_forecast']]
离别笔记
时间序列数据分析是商业决策的基本组成部分，因此决策者和数据科学家/分析师可以从对预测模型机制的某种程度的熟悉中受益。文章首先介绍了多元时间序列的概念及其在不同行业中的应用。然后，我提供了一个简短的 python 实现，作为一种使用机器学习方法为更复杂的实现提供直觉的方式。
如有任何相关问题，可以通过推特联系我。
使用 K-Means 算法的慕尼黑邻域聚类
克里斯托夫·基尔在 Unsplash 上的照片
介绍
这篇博客文章总结了 Coursera 上 IBM 数据科学专业的顶点项目的结果。在本项目中，德国慕尼黑的街区将根据其场馆数据使用 K 均值聚类算法进行聚类。代码是使用 jupyter 笔记本环境用 python 编写的，可以在我位于 https://github.com/patrickbrus/Coursera_Capstone的 Github 仓库中找到。第一部分描述了业务问题以及如何解决它。第二部分描述了用于创建邻域聚类的数据及其来源和方法。第三部分介绍了结果并对其进行了讨论。最后一部分对所有的工作和结果进行了总结。
商业问题
慕尼黑是德国的一个大城市，拥有大约 150 万人口。它是德国联邦州巴伐利亚的首府。慕尼黑以慕尼黑啤酒节而闻名，在巴伐利亚被称为“Wiesn ”,每年九月底举行。现在，让我们假设一个人已经住在慕尼黑，并想搬到一个新的公寓。但是这个人是如此热爱他的邻居，以至于他或她想搬到一个和原来非常相似的邻居家。但是很难找到一个和旧街区相似的街区。应该使用哪个标准来衡量相似性？如何收集数据？应该使用哪些数据？一种想法是使用慕尼黑所有地区的场馆数据，以便为每个街区创建聚类。然后可以使用这些聚类来基于地点数据找到相似的邻域。这项任务对于一些机器学习来说听起来很完美，作为算法，将使用 K-Means 无监督聚类算法。
数据和方法
需要慕尼黑所有区的邮政编码和区名来解决该任务。在https://www.muenchen.de/int/en/living/postal-codes.html发布的数据用于获取必要的数据。使用熊猫库和内置的PD . read _ html()函数获取数据。该函数抓取网站上的可用数据，并将所有表存储在数据框中。在图 1 中可以看到该页面数据的概览，因此可以看到所有地区和相应的邮政编码。
图 1:慕尼黑所有地区及其邮政编码概览
可以看出，每个地区都有不止一个邮政编码。这是因为所有地区都很大，为了更好地定位，需要进一步划分。因此，作为第一步，每个邮政编码在一个新的 pandas 数据框中获得自己的条目，以便获得关于每个邮政编码中心周围小半径范围内的场馆的更详细信息。此外，提取每个邮政编码的纬度和经度值，并将其存储在新的数据框中。稍后需要它们来获取每个地区的场馆数据。python geopy 库用于获取纬度和经度值。这个库只需要一个街区的名称，也接受邮政编码，并返回给定地址的纬度和经度值。图 2 显示了慕尼黑所有唯一邮政编码及其经度和纬度位置的地图。
图 2:按邮政编码划分的慕尼黑地区地图
下一步，为每个邮政编码提取可用的前 100 个地点。对于这个任务，执行对 Foursquare API 的 API 调用。Foursquare API 为商业目的和开发者提供来自世界各地的位置数据。图 3 显示了执行对 Foursquare API 的 API 调用所需的 URL 格式。一个开发者只需要一个免费的开发者账号。
图 3:创建请求 URL 以调用 Foursquare API 的 Python 代码
接收到的每个地区的地点被存储在具有 (3561，7) 形状的新数据帧中。图 4 显示了这个新数据帧的头部。
图 4:包含每个邮政编码区内的场馆的新数据帧的头部
总共有 200 个独特的场地类别可用。作为下一步，必须为聚类算法准备数据。一般来说，K-Means 算法只适用于数字数据，而我们有分类数据。为了能够应用 K-Means 算法，场所类别首先必须得到一个热编码。此外，独热码编码数据帧按区分组，以便每个区有一行和一个簇。当数据被分组时，如果一个场馆类别在一个区内出现不止一次，则一次性编码的类别被汇总。为了获得相同比例且小于 1 的值，每个类别出现频率的平均值将存储在数据框中。为了更深入地了解数据，我们计算了每个地区最常见的 10 个场馆，并将其存储在一个名为“district _ venues _ sorted”的新数据框中。图 5 显示了这个数据帧的摘录。
图 5:每个地区十大最常见的场馆
现在，K-Means 聚类算法得到应用。作为输入，该算法获得包含一次性编码场馆类别的数据帧，其中取类别出现频率的平均值，并按每个地区分组。district 列本身被删除，集群的数量被设置为 5。图 6 显示了相应的 python 代码。作为库，使用 scikit-learn 库。
图 6:K 均值聚类算法的 Python 代码
最后，使用库 Folium 再次创建所有集群的映射。图 7 显示了包含慕尼黑所有聚集街区的结果地图。
图 7:慕尼黑聚集区地图
最后一步，根据最常出现的场馆对每个集群进行检查，并对集群进行相应的命名。
结果和讨论
如图 7 所示，绿色集群是慕尼黑最常见的集群，因此慕尼黑似乎有很多类似的区域。蓝色集群更多地位于慕尼黑的外部边界，而其他集群更多地分布在城市的整个区域。因此，用户现在可以查看各个地区，并可以将他喜欢的地区与其他地区进行比较。这可以帮助他在他喜欢的地区找到一个新的公寓，或者在另一个社区找到活动，这个社区与他喜欢的已经知道的社区相似。
经过对集群的进一步探索，每个集群可以得到一个最常见的场地。因此，集群可以通过其最常见的地点来命名。在我们的例子中，编号为 0 的聚类(绿色聚类)具有最多的咖啡馆，因此是咖啡馆聚类。在第一个集群(红色集群)中，广场和教堂是最常见的场所，因此它被命名为广场+教堂集群。第二个集群(蓝色集群)有许多巴伐利亚餐馆，因此得名巴伐利亚集群。这个集群将是我最喜欢的，因为它也包含了许多爱尔兰酒吧。第三个集群(紫色集群)是最小的一个，包含了很多汤的场地。因此这就是汤串。最后一个集群(黄色集群)是游乐场集群，特别适合有孩子的家庭。
结论
慕尼黑的街区现已聚类，包含结果的地图也已可用。此外，每个聚类值都绘制在相应的 jupyter 笔记本中，以便为用户提供所有聚类的更多详细信息。
介绍..首届机器度量 8 分会场🎵
我们应用数字信号处理技术，在没有任何传感器或麦克风的情况下，从机床的控制中提取声音，这样你就可以听到机器的声音，而无需踏上工厂的地板。这使我们更接近预测加工的可扩展大规模部署。
来源:Monashee 制造公司
简介
在我们的上一篇博客帖子中，我们将机器 PLC(可编程逻辑控制)数据比作能够听到来自机器的完整交响乐。我们最近发现，我们的比喻并不遥远…我们可以通过我们收集的原始 PLC 数据听到机器发出的声音，而无需任何麦克风。使用数字信号处理的方法，这些是我们提取的纯加工声音的一些例子。在这里随便逛逛。
接受更好标题的建议。
这是“值得注意的”🥁，因为我们从机械师那里听到的最常见的重复是，在机器发生故障之前，他们可以听到指示其操作有问题的听觉线索。
在我们公司的早期，我们尝试过使用安装在机床机柜内部的 MEMS 麦克风，结合深度学习方法来复制操作者的耳朵，但我们的实验最终没有成功，因为在一个机械车间里有其他噪音的干扰。一个真实的、活跃的机器车间是一个高度异构的环境，受到各种喧嚣的影响。
为了解决这个问题，我们提出了一种不使用任何外部传感器的方法。我们目前在研究方面的进步已经使我们能够仅利用 PLC 数据创建模拟声音，使我们能够提取没有工厂噪音的纯净、纯正的加工声音。
实质上，我们应用了一种技术，可以提取从 PLC 获得的负载和主轴速度数据中的潜在谐波，结果我们只通过这两个信号就能“听到”机器。在这篇文章中，我们将回顾我们是如何做到这一点的，以及它对行业的一些启示。
为什么从 PLC 加工数据开始？
机器控制必须保持加工过程的准确实时图像，以便正常运行并使其操作者获得适当的信息。为此，控制器不断发送由嵌入(预装)在机器主轴和轴电机中的传感器产生的更新信号。我们以“高频”(1 kHz)收集这些数据，这简单地意味着它代表了一个数字化信号流，这个信号流来得如此之快，以至于对我们人类来说是连续的，就像互联网上的音频或视频流一样。
事实上，这种极其丰富的数据是通过控制手段，这意味着它有可能捕捉到它没有额外的传感器安装。这对可伸缩性有着不可思议的影响，例如:
- 这不再需要安装传感器所涉及的集成开销
- 我们的数据来源是标准化的——不受传感器定位、混淆等因素的影响。
- 通过远程软件推送，我们的算法升级可以在云上实现
可以使用一套现代软件工具和算法来分析高频数据，从而对加工质量进行极其详细的监控。
对于某些控制类型，我们可以使用其现有的即插即用边缘硬件接入高频数据流。高频加工数据可以通过简单的软件升级获得，详见我们上一篇博文。
作为一个说明性的例子，让我们看看加工汽车零件的立式铣床的主轴速度和负载信号:
为了给原始信号添加一些上下文，我们选择了一个有代表性的零件周期，并覆盖了不同工具使用期之间的边界。通过我们的 edge 设备与控制装置的连接，还可以检测到袋内刀具号和 ATC(自动刀具更换器)刀具交换，因此我们可以有意义地跟踪哪个刀具在哪个时间被接合。(原始信号甚至可以根据单独的加工操作进行调查，通过合并我们记录的额外机器数据，但这是未来帖子的主题！)
通过查看主轴和刀库之间的一次刀具交换，我们可以快速了解这些数据有多敏感。虽然上面的速度图涵盖了 80 秒内数千 RPM 的范围，但我们放大到两秒内仅几 RPM 的范围。
我们在这里看到的是，主轴首先完全停止，然后是 T2(垂直线)交换命令，然后随着 T1 的移除，主轴方向有些抖动，最后随着 T2 就位，主轴略微旋转。
上述内容的可视化表示。数控培训中心提供
正是高频数据中的这种精细层次的细节使我们能够探测可能影响加工质量的极其细微的影响。
机器里的音乐
进一步放大主轴速度平稳段可以揭示这样一个微妙的影响。
虽然工厂在这段时间内很好地保持了主轴转速的稳定，但它并不完美。该速度在其编程值 2100 转/分左右摆动，幅度不到 1 转/分。粗略一看，主轴速度信号中的“噪声”似乎包含一些结构。例如，这里最大的摆动周期约为 14 毫秒。
高质量的主轴实际上通过电子反馈机制保持一致的转速，鉴于加工过程中经历的不规则扭矩，这一点至关重要。因此，主轴在努力保持其编程速度时产生的波动也可以作为切割金属所施加力的反映。通过仔细研究这些波动，我们可以获得关于工具面和材料之间时刻相互作用的线索。因为主轴速度可以在高频率下非常稳定地监控，这为我们提供了一个独特的加工条件探头。
为了从控制命令的总体主轴速度趋势中分离出短时间尺度反馈效应，我们首先执行一个数学平滑操作，该操作趋向于平均化波动。让我们看看在一个稍微复杂一点的切入主轴速度信号上是什么样的，其中整体趋势并不完全恒定。原始信号是蓝色的，而我们的平滑拟合是橙色的。
然后，我们获取原始信号和平滑信号之间的差异，并将它们链接在一起，以获得“纯噪声”的新信号
当声音被表示为数字信号时，这些图开始类似于声音的模式。我们可以期待类似的信息密度，但现在有效地代表了主轴电机产生的声音。事实上，这一过程涵盖的频率范围从大约 10 赫兹到 500 赫兹，与人类的听觉有很大的重叠，从三角钢琴上最低的音符到中音以上大约一个八度音。实际上，我们可以将虚拟耳朵放在主轴电机上，听它播放的曲子！
关注加工质量
一个周期接一个周期持续生产的零件会在主轴电机上转换成特定的旋律。就像我们在弹奏熟悉的曲子时很容易听出任何走音一样，刀具磨损或断裂导致的加工问题也可能表现为主轴速度波动模式，与符合规格的加工相比，这听起来很不寻常。
前面例子中使用的特殊铣刀在钻孔时由于工具磨损而经历过不稳定性。一旦操作员发现问题所在，这通常需要报废或返工零件。仅在一个例子中，就有 16 个连续的零件不得不扔掉，损失了数百美元的收入。
在 R&D 阶段，我们通过高频数据收集对这一事件进行了监测。作为其程序的一部分，工厂按顺序制作六个孔，我们在正常和报废零件的加工期间收集了一些声音片段。
你能听出区别吗？
从主轴速度得出的声音模式来看，这是第一个坏周期以及紧接在它之前和之后的这些切削的样子。
你能看出区别吗？
从这个角度回顾发生的事情，我们可以发现有问题的不稳定性出现的确切时刻，在质量保证发现问题之前整整 20 分钟。
自动故障检测
开发自动和通用检测此类事件的算法现在是我们公司正在进行的一个主要项目。通过以这种方式表示数据，我们为在录音中使用来自数字信号处理和模式识别领域的丰富的分析工具集开辟了许多可能性。但是我们已经用一些简单的技巧来测量一个给定模式有多“嘈杂”取得了重大进展。
通过在正常加工过程中监控主轴的噪声水平，可以自动了解其总体趋势和典型工作范围。然后，大量偏离可以立即被标记为有问题。应用这样的程序，我们发现导致损坏事件的几个小时的正常零件周期，随后是一连串明显的异常周期，最终由操作员更换工具。
通过根据各种音调或频率的流行来研究这些声音模式，可以获得进一步的诊断洞察力。这是通过另一种常见的数学运算完成的，即傅立叶变换。对于每个单独的周期，我们可以绘制不同频率的响度，然后检查这个图寻找线索。如果我们想象把一堆这样的图一个接一个地堆叠起来，然后制作一个动画书，我们就可以制作一个小电影，展示不同频率的响度是如何随着周期的变化而变化的。
这里明显的模式是一个信号尖峰，它在损坏事件时突然出现，然后在工具被替换后完全消失。这告诉我们，额外噪声主要以 35 Hz 的频率进入。并非巧合的是，这与主轴旋转的频率相同:35 Hz 转换为 2100 RPM。由于工具受损，主轴正经历越来越不稳定的扭矩，每转一次都会被馈送一个额外的补偿功率脉冲，以保持其速度稳定。跟踪主轴速度和其他指标的频率峰值可能很快成为我们自动化加工质量监控的标准功能——实际上就是留意异常声音。
对行业的影响
在 20 世纪中期之前，机器健康监控几乎完全依靠机器操作员的耳朵。一个好的机械师不仅有非常灵巧和不可思议的灵活的手，而且有敏锐的耳朵的细微差别的机器和伟大的技能学习系统的模式，他往往。
在 20 世纪 60 年代 MEMS 和传感器技术出现后，该系统得到了补充，并且在某些情况下被自动化方法部分取代。加速度计、麦克风和压电传感器有助于检测正常活动的轻微偏差，并帮助机械师更可靠地诊断问题。然而，由于安装的侵入性和跨企业扩展的困难，大规模采用从未站稳脚跟。这种现状是该行业过去 60 年左右的状态。
我们有兴趣开创一个预测加工的新时代，在这个时代，我们的机器预测和健康管理技术与大规模部署密切相关。我们的目标是接近一个真正的民主化，即插即用的解决方案。这种转变早就应该发生了。
我们相信现有的技术可以使这在商业上可行，尽管执行和实施对实现这一愿景仍然至关重要。通过证明我们实际上在数千台机器上拥有“耳朵”,而无需踏足工厂车间，我们相信我们的发现具有潜在的巨大影响，并为实现这一目标做出了巨大贡献。在没有任何传感器安装的情况下，我们可以远程监控机器的声音，并推断其健康状况，就像操作员一样。
如果你听完整个 8 声道你会有什么感觉。
通过深度神经网络生成音乐
阿列克谢·鲁班在 Unsplash 上的照片
动手教程，深度学习
机器学习的创造性应用
深度学习以明显和微妙的方式改善了我们生活的许多方面。深度学习在电影推荐系统、垃圾邮件检测和计算机视觉等过程中发挥着关键作用。尽管围绕深度学习作为黑盒和训练难度的讨论正在进行，但它在包括医学、虚拟助手和电子商务在内的广泛领域中有着巨大的潜力。
深度学习可以发挥作用的一个令人着迷的领域是艺术和技术的交叉点。为了进一步探索这个想法，在本文中，我们将通过深度学习过程来研究机器学习音乐生成，这是一个许多人认为超出机器范围的领域(也是另一个激烈辩论的有趣领域！).
内容
- 机器学习模型的音乐表示
- 音乐数据集
- 数据处理
- 型号选择
- 多-多 RNN
- 时间分布密集层
- 宏伟威严的
- 脱落层
- Softmax 层
- 【计算机】优化程序
- 音乐的一代
- 摘要
机器学习模型的音乐表示
我们将使用 ABC 乐谱。ABC 符号是一种简写形式的音乐符号，它使用字母 A 到 G 来表示音符，并使用其他元素来放置附加值。这些附加值包括升半音、降半音、音符长度、调和装饰音。
这种形式的符号最初是一种 ASCII 字符集代码，用于促进在线音乐共享，为软件开发人员增加了一种新的简单语言，旨在方便使用。图 1 是音乐的 ABC 符号的快照。
音乐的 ABC 符号的插图(来源，由作者编辑)
乐谱第一部分的线条显示了一个字母后跟一个冒号。这些指示曲调的各个方面，例如索引，当文件中有多个曲调时(X:)，标题(T:)，拍号(M:)，默认音符长度(L:)，曲调类型(R:)和音调(K:)。按键符号后面的线条代表曲调本身。
音乐数据集
在本文中，我们将使用诺丁汉音乐数据库的 ABC 版本上可用的开源数据。它包含了 1000 多首民间曲调，其中绝大多数都被转换成 ABC 记谱法。
数据处理
数据目前是基于字符的分类格式。在数据处理阶段，我们需要将数据转换为基于整数的数字格式，为使用神经网络做准备。
数据处理概述(图片由作者创建)
这里每个字符被映射到一个唯一的整数。这可以通过使用一行代码来实现。“文本”变量是输入数据。
char_to_idx = { ch: i for (i, ch) in enumerate(sorted(list(set(text)))) }
为了训练该模型，我们使用 vocab 将整个文本数据转换成数字格式。
T = np.asarray([char_to_idx[c] for c in text], dtype=np.int32)
机器学习音乐生成的模型选择
在传统的机器学习模型中，我们无法存储模型的先前阶段。但是，我们可以用递归神经网络(俗称 RNN)存储之前的阶段。
RNN 有一个重复模块，它接收前一级的输入，并将其输出作为下一级的输入。然而，RNNs 只能保留最近阶段的信息，因此我们的网络需要更多的内存来学习长期依赖关系。这就是长短期记忆网络(LSTMs)的救援之处。
LSTMs 是 RNNs 的特例，具有与 RNNs 相同的链状结构，但具有不同的重复模块结构。
LSTM 结构概述(图片由作者创建)
这里使用 RNN 是因为:
- 数据的长度不需要固定。对于每个输入，数据长度可能不同。
- 存储顺序记忆。
- 可以使用输入和输出序列长度的各种组合。
除了一般的 RNN，我们将通过添加一些调整来定制它以适应我们的用例。我们将使用一个“字符 RNN”。在字符 RNNs 中，输入、输出和转换输出都是以字符的形式出现的。
人物 RNN 概述(作者创造的形象)
多-多 RNN
因为我们需要在每个时间戳生成输出，所以我们将使用多对多 RNN。为了实现多对多 RNN，我们需要将参数' return_sequences '设置为 true，以便在每个时间戳生成每个字符。您可以通过查看下面的图 5 来更好地理解它。
多对多 RNN 概览(图片由作者创建)
在上图中，蓝色单元是输入单元，黄色单元是隐藏单元，绿色单元是输出单元。这是一个多对多 RNN 的简单概述。为了更详细地了解 RNN 序列，这里有一个有用的资源。
时间分布密集层
为了处理每个时间戳的输出，我们创建了一个时间分布的密集层。为了实现这一点，我们在每个时间戳生成的输出之上创建了一个时间分布的密集层。
宏伟威严的
通过将参数 stateful 设置为 true，批处理的输出将作为输入传递给下一个批处理。在组合了所有的特性之后，我们的模型将看起来像下面图 6 中描绘的概述。
了解有状态 RNN(图片由作者创建)
模型架构的代码片段如下:
model = Sequential()
model.add(Embedding(vocab_size, 512, batch_input_shape=(BATCH_SIZE, SEQ_LENGTH)))for i in range(3): model.add(LSTM(256, return_sequences=True, stateful=True))
model.add(Dropout(0.2))model.add(TimeDistributed(Dense(vocab_size)))
model.add(Activation('softmax'))model.summary()
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
我强烈建议尝试使用这些层来提高性能。
脱落层
丢弃层是一种正则化技术，在训练过程中的每次更新中，它将输入单元的一部分归零，以防止过度拟合。该分数由该层使用的参数决定。
Softmax 层
音乐的生成是一个多类分类问题，其中每个类都是来自输入数据的唯一字符。因此，我们在模型上使用 softmax 层，并使用分类交叉熵作为损失函数。
这一层给出了每一类的概率。从概率列表中，我们选择概率最大的一个。
了解 Softmax 图层的输出(由作者创建的图像)
【计算机】优化程序
为了优化我们的模型，我们使用自适应矩估计，也称为亚当，因为它是一个非常好的选择 RNN。
创建的训练模型概述(图片由作者创建)
创作音乐
到目前为止，我们创建了一个 RNN 模型，并根据我们的输入数据对其进行了训练。该模型在训练阶段学习输入数据的模式。让我们称这个模型为“训练模型”。
训练模型中使用的输入大小是批量大小。并且对于通过机器学习生成音乐，输入大小是单个字符。因此，我们创建了一个新的模型，它类似于已训练的模型，但是单个字符的输入大小为(1，1)。对于这个新模型，我们从已训练的模型加载权重，以复制已训练的模型的特征。
model2 = Sequential()model2.add(Embedding(vocab_size, 512, batch_input_shape=(1,1)))for i in range(3):
model2.add(LSTM(256, return_sequences=True, stateful=True))
model2.add(Dropout(0.2))model2.add(TimeDistributed(Dense(vocab_size)))
model2.add(Activation(‘softmax’))
我们将已训练模型的权重加载到新模型中。这可以通过使用一行代码来实现。
model2.load_weights(os.path.join(MODEL_DIR,‘weights.100.h5’.format(epoch)))model2.summary()
生成的音乐模型概述(由作者创建的图像)
在音乐生成的过程中，从唯一的字符集中随机选择第一个字符，使用先前生成的字符生成下一个字符，依此类推。有了这个结构，我们就产生了音乐。
生成的音乐流程概述(由作者创建的图像)
下面是帮助我们实现这一目标的代码片段。
sampled = []for i in range(1024): batch = np.zeros((1, 1)) if sampled: batch[0, 0] = sampled[-1] else: batch[0, 0] = np.random.randint(vocab_size) result = model2.predict_on_batch(batch).ravel() sample = np.random.choice(range(vocab_size), p=result) sampled.append(sample)print("sampled")print(sampled)print(''.join(idx_to_char[c] for c in sampled))
以下是一些生成的音乐片段:
我们使用被称为 LSTMs 的机器学习神经网络生成了这些令人愉快的音乐样本。对于每一代，模式将不同，但与训练数据相似。这些旋律可用于多种用途:
- 通过灵感增强艺术家的创造力
- 作为开发新想法的生产力工具
- 作为艺术家作品的附加曲调
- 完成一件未完成的工作
- 作为一首独立的音乐
但是，这个模型仍然可以改进。我们的训练数据只包含一种乐器，钢琴。我们可以增强训练数据的一种方法是添加来自多种乐器的音乐。另一个方法是增加音乐的类型、节奏和节拍。
目前，我们的模型产生一些假音符，音乐也不例外。我们可以减少这些错误，并通过增加我们的训练数据集来提高我们的音乐质量，如上所述。
摘要
在这篇文章中，我们研究了如何处理音乐以用于神经网络，RNN 和 LSTMs 等深度学习模型的深入工作，我们还探索了调整模型如何导致音乐生成。我们可以将这些概念应用到任何其他生成其他艺术形式的系统中，包括生成风景画或人类肖像。
感谢阅读！本文原帖此处。如果你想自己试验这个自定义数据集，你可以在这里下载带注释的数据，在 Github 查看我的代码。
我也将在未来写更多初学者友好的帖子。请在媒体上关注我，以便了解他们。我欢迎反馈，可以通过 Twitter ramya_vidiyala 和 LinkedIn RamyaVidiyala 联系。快乐学习！
音乐流派分析——理解不同流派中的情感和主题
理解不同音乐流派中的主题，并创建简单的预测和推荐应用程序
供稿人 : Dimple Singhania，Adwait Toro，Sushrut Shendre，Chavi Singal，Anuja Dixit
简介
音乐是连接世界各地人们的东西之一。无论歌词使用何种语言，好的音乐都能得到全球的认可。但是即使音乐没有语言，音乐中的歌词在定义音乐类型中起着重要的作用。理解歌曲背后的主题是至关重要的，这样才能让即将到来的歌唱天才创作出符合当前流行主题的歌曲。
许多音乐平台，如 Spotify、亚马逊音乐(Amazon music)都依靠流派预测来更好地向用户推荐类似的歌曲。Spotify 使用流派定位，允许我们在用户听完特定流派的歌曲后立即发送消息。
因此，我们决定建立一个模型，从歌词中预测歌曲的流派。
数据
我们的数据集由大约 100k 条记录组成，有 4 列:艺术家、歌曲、歌词和流派。
EDA
为了挖掘出一些关于数据的有趣事实，我们做了一些探索性的数据分析。
- 为了查看流派的样本，数据集严重偏向摇滚(52k 歌曲；52%).R&B、独立、民谣和电子音乐仅占数据的 6%，总共有近 6000 首歌曲。
数据中的这种偏差导致我们的模型比其他流派更准确地预测摇滚流派。
2.接下来，我们想看看数据集中的顶级艺术家。令人惊讶的是，尽管摇滚在数据集中占据了主导地位，美国标志性乡村歌手多莉·帕顿却高居榜首。
3.接下来，我们想看看不同体裁的字符和单词的长度有什么不同。Hip-Hop 拥有最高的平均字符数和单词数。这可能是因为 Hip-hop 有说唱歌曲，这些歌曲在很短的时间内唱了很多词。
自定义功能
首先，我们从歌词中提取了一些我们认为有助于流派预测的特征。
- 情绪
我们使用了一个外部数据集，将歌词分为不同的情绪。我们在这个数据集上训练了一个逻辑回归分类器，并预测了给定数据集的情绪。下面是在外部数据上安装分类器并将其下载为的函数。用于预测的 pkl。
https://gist . github . com/chiko Rita 5/7b 70 be 4746 e 54 a 23 BF 4 e 227 a 4 aeed 63 e
在没有外部数据集来训练的情况下，也可以尝试提取情绪的替代方法。IBM watson 音调分析器 API 可用于获取情绪。
https://gist . github . com/chiko Rita 5/359625 Fe 595 DC 0 c 0 e 34 Fe 65 e5d 922 f 58
2.歌词的字数
3.歌词中的行数
分类
首先，我们将数据集分为训练和测试两部分。我们使用 TFIDF 矢量器、定制特性和分类器创建了一个简单的Pipeline对象。我们使用逻辑回归、决策树和朴素贝叶斯进行预测。
如你所见，逻辑具有最高的准确性。决策树的准确率较低，但召回率和 f-1 分数略高于 logistic。
过采样
因为我们的数据有不平衡的流派分类。为了提高模型的准确性，我们对训练数据集中的少数类进行了过采样。我们使用过采样数据再次执行朴素贝叶斯和逻辑回归，性能提高了很多。
混淆矩阵-朴素贝叶斯:准确率 73.5%
经过过采样后，朴素贝叶斯模型的性能显著提高，准确率为 73%，召回率为 74%。在上面的混淆矩阵中，可以看到摇滚流派被错误地预测为流行、乡村、金属好几次。
混淆矩阵—逻辑回归:准确率 80.6%
过采样后，逻辑回归和 CountVectorizer 提供了最高的精度。尽管如此，摇滚和流行音乐之间还是有些混淆。
主题建模
我们还做了一些主题建模，以确定不同体裁中的常见主题。对于主题建模，我们使用 Gensim 包中的潜在 Dirichlet 分配(LDA)以及 Mallet 的实现(通过 Gensim)。Mallet 有一个高效的 LDA 实现。众所周知，它运行速度更快，主题分离更好。
在应用主题建模后，我们发现我们有 6 个主导主题，模型的最佳一致性分数为 53%，困惑分数为-10。困惑是模型在将文档分类为主题时不会混淆的度量。困惑分数越低，模型越好。
在查看了 6 个主题的关键词后，我们决定这些类型有 6 个潜在的主题，如调情、爱情、青春、悲伤、快乐/舞蹈、奉献/死亡。为了以一种更具交互性和用户友好的方式来描述这些，我们创建了一个 Tableau 仪表板，显示主题及其相关的关键字。仪表板还提供了选择您最喜爱的艺术家，他们的流派和歌曲，以查看潜在的主题和相关的关键字，以及改变关键字频率的规定。
主题和相关关键字的概述
例如，我们选择了演唱《爱你更多》的歌手阿肯。它被归类为在其流行类型下有一个悲伤的主题，显示在 tableau 仪表板上。
应用
使用我们的最终分类器，我们使用 Python 的 tkinter 库创建了一个应用程序。任何歌曲的歌词都可以粘贴到应用程序中，以检查其流派。
流派预测应用程序演示
推荐系统
很多时候，我们听了一首歌，非常喜欢，但不知何故，我们错过了它的名字，只有它的一句歌词整天萦绕在我们的脑海里！为了解决这个问题，我们使用了一种距离测量技术来找出与用户输入的歌曲最相似的歌曲。我们提供了一个文本框，用户可以在其中键入歌曲的歌词，系统将根据歌词推荐最接近输入歌曲的前 10 首歌曲。我们使用 Jaccard 相似性设计了这一功能，首先用户输入歌曲，然后将其标记为单词列表，并与数据集中出现的每首歌词进行比较。相似性被计算为两个标记化列表的交集/两个列表的并集，并且相似性接近 1 的歌曲被显示。
推荐系统演示
开源代码库
https://github.com/chikorita5/nlp-genre-classification
参考文献
- Bird，Steven，Edward Loper 和 Ewan Klein (2009)，用 Python 进行自然语言处理。奥莱利媒体公司
- https://towards data science . com/the-triune-pipeline-for-three-major-transformers-in-NLP-18c 14 e 20530
- sci kit-learn:Python 中的机器学习，Pedregosa 等人，JMLR 12，第 2825–2830 页，2011 年
- https://www . machine learning plus . com/NLP/topic-modeling-gensim-python/
音乐流派分类:变形金刚 vs 递归神经网络
在音频分类任务中比较两种架构。
马库斯·斯皮斯克在 Unsplash 上拍摄的照片
这篇文章的目的是通过比较两种流行的序列建模架构来实现一个音乐流派分类模型:递归神经网络和变压器。
rnn 在各种 1D 序列处理任务中很受欢迎，它们在每个时间步重复使用相同的权重，并通过保持内部状态和使用门控机制(LSTM、格鲁什…)将信息从一个时间步传递到下一个时间步。由于它们使用递归，这些模型可能遭受消失/爆炸梯度，这可能使训练和学习长期模式更加困难。
来源:https://en.wikipedia.org/wiki/Recurrent_neural_networkBYfdeloche下 CC BY-SA 4.0
变压器是一种相对较新的架构，它可以处理序列，而无需使用任何递归或卷积[https://arxiv.org/pdf/1706.03762.pdf。变压器层大多是逐点前馈操作和自我关注。这些类型的网络在自然语言处理方面取得了一些巨大的成功，特别是在对大量未标记数据进行预训练时[https://arxiv.org/pdf/1810.04805]。
变形层—作者提供的图像
数据集
我们将使用免费的音乐档案数据集https://github.com/mdeff/fma/，更具体地说是包含 106，574 首 30 秒曲目、161 个不平衡流派的大型版本，总共有 93 Gb 的音乐数据。每首曲目都标有一组最能描述它的流派。
"20": [
"Experimental Pop",
"Singer-Songwriter"
],
"26": [
"Experimental Pop",
"Singer-Songwriter"
],
"30": [
"Experimental Pop",
"Singer-Songwriter"
],
"46": [
"Experimental Pop",
"Singer-Songwriter"
],
"48": [
"Experimental Pop",
"Singer-Songwriter"
],
"134": [
"Hip-Hop"
]
我们在这个项目中的目标是预测这些标签。因为一首歌可以被附加到多个标签，所以它可以被公式化为具有 163 个目标的多标签分类问题，每个类别一个目标。
一些类别非常频繁，例如电子音乐，占数据的 22%，但其他一些类别出现的次数很少，如萨尔萨，占数据集的 0.01%。这在训练和评估中造成了极端的不平衡，导致我们使用精确召回曲线下的微平均面积作为我们的度量。
| | Genre | Frequency | Fraction |
|----:|:-------------------------|------------:|------------:|
| 0 | Experimental | 24912 | 0.233753 |
| 1 | Electronic | 23866 | 0.223938 |
| 2 | Avant-Garde | 8693 | 0.0815677 |
| 3 | Rock | 8038 | 0.0754218 |
| 4 | Noise | 7268 | 0.0681967 |
| 5 | Ambient | 7206 | 0.067615 |
| 6 | Experimental Pop | 7144 | 0.0670332 |
| 7 | Folk | 7105 | 0.0666673 |
| 8 | Pop | 6362 | 0.0596956 |
| 9 | Electroacoustic | 6110 | 0.0573311 |
| 10 | Instrumental | 6055 | 0.056815 |
| 11 | Lo-Fi | 6041 | 0.0566836 |
| 12 | Hip-Hop | 5922 | 0.055567 |
| 13 | Ambient Electronic | 5723 | 0.0536998 |
.
.
.
| 147 | North African | 40 | 0.000375326 |
| 148 | Sound Effects | 36 | 0.000337793 |
| 149 | Tango | 30 | 0.000281495 |
| 150 | Fado | 26 | 0.000243962 |
| 151 | Talk Radio | 26 | 0.000243962 |
| 152 | Symphony | 25 | 0.000234579 |
| 153 | Pacific | 23 | 0.000215812 |
| 154 | Musical Theater | 18 | 0.000168897 |
| 155 | South Indian Traditional | 17 | 0.000159514 |
| 156 | Salsa | 12 | 0.000112598 |
| 157 | Banter | 9 | 8.44484e-05 |
| 158 | Western Swing | 4 | 3.75326e-05 |
| 159 | N. Indian Traditional | 4 | 3.75326e-05 |
| 160 | Deep Funk | 1 | 9.38315e-06 |
音频处理
我们使用 Mel-Spectrograms 作为网络的输入，因为它是音频输入的密集表示，并且它更适合 transformer 架构，因为它将原始音频波转换为向量序列。
**def** pre_process_audio_mel_t(audio, sample_rate=16000):
mel_spec = librosa.feature.melspectrogram(y=audio, sr=sample_rate,
n_mels=n_mels)
mel_db = (librosa.power_to_db(mel_spec, ref=np.max) + 40) / 40**return** mel_db.T
时间轴上的每个 128 维向量被认为是输入序列的一个元素。
加载音频文件并将其子采样到 16kHz，然后计算 Mel 频谱图可能需要大量时间，因此我们使用 NumPy.save 预先计算并将其作为. npy 文件保存在磁盘上。
模型
我选择超参数，使 rnn 和变压器都有类似数量的可训练参数。
Model: "Transformer"
_________________________________________________________________
**Layer** (**type**) **Output Shape Param** *#* =================================================================
**input_1** (**InputLayer**) [(**None**, **None**, **128**)] **0** _________________________________________________________________
**encoder** (**Encoder**) (**None**, **None**, **128**) **529920** _________________________________________________________________
**dropout_9** (**Dropout**) (**None**, **None**, **128**) **0** _________________________________________________________________
**global_average_pooling1d** (**Gl** (**None**, **128**) **0** _________________________________________________________________
**dense_24** (**Dense**) (**None**, **652**) **84108** _________________________________________________________________
**dense_25** (**Dense**) (**None**, **163**) **106439** =================================================================
**Total** params: 720,467
**Trainable** params: 720,467
**Non-trainable** params: 0
_________________________________________________________________Model: "RNN"
_________________________________________________________________
**Layer** (**type**) **Output Shape Param** *#* =================================================================
**input_1** (**InputLayer**) [(**None**, **None**, **128**)] **0** _________________________________________________________________
**bidirectional** (**Bidirectional** (**None**, **None**, **256**) **198144** _________________________________________________________________
**bidirectional_1** (**Bidirection** (**None**, **None**, **256**) **296448** _________________________________________________________________
**dropout** (**Dropout**) (**None**, **None**, **256**) **0** _________________________________________________________________
**global_average_pooling1d** (**Gl** (**None**, **256**) **0** _________________________________________________________________
**dense** (**Dense**) (**None**, **652**) **167564** _________________________________________________________________
**dense_1** (**Dense**) (**None**, **163**) **106439** =================================================================
**Total** params: 768,595
**Trainable** params: 768,595
**Non-trainable** params: 0
_________________________________________________________________
这两种型号之间的唯一区别是编码器部分是变压器或双向 GRU。这两种型号具有 700k 可训练参数。
估价
我们将使用精确回忆曲线下的面积来评估每一种体裁，然后对各个班级进行微观平均。
变形金刚的嘻哈 PR 曲线
**RNN vs Transformer AUC PR =>****transformer micro-average** : **0.20
rnn micro-average** : **0.18**
我们可以看到 transformer 比 GRU 工作得好一点。我们可以通过做一些测试时间增加和平均输入序列的多个作物的预测来提高性能。
**Test-Time Augmentation =>****transformer micro-average** : **0.22
rnn micro-average** : **0.19**
结果总体上看起来有点弱，这可能是由于大量的课程使任务变得更加困难，或者可能是由于课程的不平衡。一个可能的改进是放弃多标签方法，转而采用排序方法，因为它对类别不平衡和大量类别不太敏感。
预测示例:
五大预测:
贾扎的《午睡》
('Folk', 0.7591149806976318)
('**Pop**', **0.7336021065711975**)
('**Indie-Rock**', **0.6384000778198242**)
('Instrumental', 0.5678483843803406)
('Singer-Songwriter', 0.558732271194458)
('Electronic', 0.8624182939529419)
('Experimental', 0.6041183471679688)
('**Hip-Hop**', **0.369397908449173**)
('Glitch', 0.31879115104675293)
('Techno', 0.30013027787208557)
结论
在这篇文章中，我们比较了两种流行的序列建模结构 rnn 和变压器。我们看到 transformers 在性能上略胜 GRUs，这表明 Transformers 甚至可以在自然语言处理之外进行测试。
参考
TF2 变形金刚:https://github . com/tensor flow/docs/blob/master/site/en/tutorials/text/transformer . ipynb
代号:https://github.com/CVxTz/music_genre_classification
基于张量流的音乐流派分类
使用 TensorFlow 比较标准机器学习与深度学习，以找到音频样本的流派
音乐流媒体服务的兴起让音乐无处不在。我们在上下班途中听音乐，在我们锻炼、工作或者只是为了放松的时候。我们日常生活中的持续干扰并没有削弱音乐在引发情感和处理我们思想中的作用，正如“变焦音乐会”的出现所证明的那样。
这些服务的一个关键特征是播放列表，通常按流派分组。这些数据可能来自发布歌曲的人的人工标记。但这种方法的规模并不大，可能会被那些想利用某一特定流派的受欢迎程度的艺术家所利用。更好的选择是依靠自动音乐流派分类。与我的两位合作者 Wilson Cheung 和 Joy Gu ，我们试图比较将音乐样本分类成流派的不同方法。特别是，我们评估了标准机器学习与深度学习方法的性能。我们发现特征工程是至关重要的，领域知识确实可以提高性能。
在描述了所使用的数据源之后，我简要概述了我们使用的方法及其结果。在本文的最后一部分，我将花更多的时间解释 Google Colab 中的 TensorFlow 框架如何通过 TFRecord 格式在 GPU 或 TPU 运行时有效地执行这些任务。所有的代码都在这里可用，我们很高兴与任何感兴趣的人分享我们更详细的报告。
数据源
预测音频样本的流派是一个监督学习问题(对于监督与非监督学习的好入门，我推荐 Devin 关于主题的文章)。换句话说，我们需要包含标记示例的数据。 FreeMusicArchive 是一个带有相关标签和元数据的音频片段库，最初是为 2017 年国际音乐信息检索大会(ISMIR)上的 a 论文收集的。
我们将分析的重点放在所提供的一小部分数据上。它包含 8，000 个音频片段，每个长度为 30 秒，分为八种不同的类型:
- 嘻哈音乐
- 流行音乐
- 民间的
- 实验的
- 岩石
- 国际的
- 电子的
- 仪器的
每个流派都有 1000 个代表性的音频片段。由于采样率为 44，100 Hz，这意味着每个音频样本有超过 100 万个数据点，或超过 10⁹数据点总数。在分类器中使用所有这些数据是一个挑战，我们将在接下来的章节中对此进行更多的讨论。
有关如何下载数据的说明，请参考存储库中包含的自述文件。我们非常感谢Michal Defferrard、 Kirell Benzi 、 Pierre Vandergheynst 、 Xavier Bresson 将这些数据放在一起并免费提供，但我们只能想象 Spotify 或 Pandora Radio 拥有的数据规模所能提供的见解。有了这些数据，我们可以描述各种模型来执行手头的任务。
模型描述
我将尽量减少理论上的细节，但会尽可能地链接相关资源。此外，我们的报告包含了比我在这里所能包括的更多的信息，特别是关于特性工程，所以如果你想让我与你分享，请在评论中告诉我。
标准机器学习
我们使用了逻辑回归、k-最近邻(kNN)、高斯朴素贝叶斯和支持向量机(SVM):
- SVM 试图通过最大化训练数据的余量来找到最佳决策边界。内核技巧通过将数据投影到高维空间来定义非线性边界
- kNN 基于 k 个最接近的训练样本的多数投票来分配标签
- 天真的巴爷 s 根据特征预测不同类别的概率。条件独立性假设大大简化了计算
- 逻辑回归也通过利用逻辑函数直接模拟概率来预测不同类别的概率
深度学习
对于深度学习，我们利用 TensorFlow 框架(详见本文第二部分)。我们根据输入的类型建立了不同的模型。
对于原始音频，每个示例都是 30 秒的音频样本，即大约 130 万个数据点。这些浮点值(正的或负的)表示在某个时间点的波浪位移。为了管理计算资源，可以使用不到 1%的数据。有了这些特征和相关的标签(一位热编码)，我们可以建立一个卷积神经网络。总体架构如下:
原始音频示例
另一方面，频谱图充当音频样本的视觉表示。这启发了将训练数据视为图像，并通过迁移学习利用预训练模型。对于每个例子，我们可以形成 Mel 谱图，它是一个矩阵。如果我们计算的维度正确，这个矩阵可以表示为 224x224x3 的图像。这些都是利用 MobileNetV2 的正确维度，MobileNetV2 在图像分类任务上有着出色的表现。迁移学习的思想是使用预训练模型的基础层来提取特征，并用定制的分类器(在我们的例子中是密集层)替换最后一层。这是可行的，因为基础层通常可以很好地推广到所有图像，甚至是他们没有训练过的图像。
Mel 光谱图示例
模型结果
我们使用 20%的测试集来评估模型的性能。我们可以将结果总结在下表中:
测试集上的模型结果
将迁移学习应用于频谱图的卷积神经网络是最好的表现者，尽管 SVM 和高斯朴素贝叶斯在性能上是相似的(考虑到后者的简化假设，这本身是有趣的)。我们在报告中描述了最好的超参数和模型架构，但是我不会在这里包括它们。
我们对训练和验证曲线的分析突出了过度拟合的问题，如下图所示(我们的大多数模型都有类似的图表)。呈现的特征模式有助于我们识别这个问题。我们为此设计了一些解决方案，可以在这个项目的未来迭代中实现:
- 减少数据的维度:可以使用 PCA 等技术将提取的特征组合在一起，并限制每个示例的特征向量的大小
- 增加训练数据的大小:数据源提供了更大的数据子集。我们将探索限制在整个数据集的 10%以下。如果有更多的计算资源可用，或者数据的维数被成功降低，我们可以考虑使用完整的数据集。这很可能使我们的方法能够隔离更多的模式，并极大地提高性能
- 在寻找功能时要更加小心:FreeMusicArchive 包含了一系列功能。当使用这些特性而不是我们自己的特性时，我们确实看到了性能的提高，这使我们相信我们可以希望通过领域知识和增强的特性集获得更好的结果
使用原始音频输入构建的深度学习模型的训练(橙色)和验证(蓝色)准确性
TensorFlow 实现
TensorFlow 是一个非常强大的大规模构建神经网络的工具，尤其是在与 Google Colab 的免费 GPU/TPU 运行时结合使用时。这个项目的主要启示是识别瓶颈:我最初的实现非常慢，即使使用 GPU 也是如此。我发现问题在于 I/O 过程(来自驱动器，速度非常慢),而不是训练过程。使用 TFrecord 格式可以加快并行化的速度，这使得模型训练和开发更快。
在开始之前，有一点很重要:虽然数据集中的所有歌曲都是 MP3 格式，但我将它们转换为 wav 文件，因为 TensorFlow 对它们有更好的内置支持。请参考 GitHub 上的资源库，查看与这个项目相关的所有代码。代码还假设你有一个谷歌云存储桶，里面有所有的 wav 文件，一个上传了元数据的谷歌硬盘，并且你正在使用谷歌 Colab 。尽管如此，让所有代码适应另一个系统(基于云的或本地的)应该相对简单。
谷歌的这个 codelab 以及 TensorFlow 官方文档对这个项目非常有帮助，其中一些代码仅仅是从这些来源改编而来。
初始设置
这个项目需要大量的库。存储库中的requirements.txt文件为您处理安装，但是您也可以在下面找到详细的列表。
必要的库
第一步是挂载驱动器(元数据已经上传到这里)，并使用存储音频文件的 GCS bucket 进行身份验证。从技术上讲，元数据也可以上传到 GCS，这样就不需要安装驱动器了，但这就是我自己的项目的结构。你可以在这里找到更多关于如何导入文件到 Colab 的细节。
安装驱动器并使用 GCS 进行身份验证:https://colab . sandbox . Google . com/notebooks/io . ipynb # scroll to = S7 c8 wyyqdh 5 I
我们还存储了一些变量以备将来使用，比如数据大小
创建张量流数据集
下一组函数读入必要的元数据信息。我没有写这段代码，只是改编自免费音乐档案。这一部分很可能会在您自己的项目中发生变化，这取决于您正在使用的数据集。
然后我们需要函数来创建一个张量流数据集。这个想法是在文件名列表上循环，在一个管道中应用一系列操作，返回一个 BatchedDataset ，包含一个特征张量和一个标签张量。我们使用 TensorFlow 内置函数和 Python 函数(使用 tf.py_function ，在数据管道中使用 Python 函数非常有用)。在这里，我只包括从原始音频数据创建数据集的函数，但是这个过程非常类似于以声谱图作为特征来创建数据集(更多细节参见库)。您将需要在自己的项目中对这条管道进行轻微的编辑，例如改变数据的形状，但是整体结构将保持不变。
创建张量流数据集的管道
在 GCS 上使用 TFRecord 格式
现在我们有了数据集，我们使用 TFRecord 格式将它存储在 GCS 上。这是 GPU 和 TPU、使用的推荐格式，因为并行化实现了快速 I/O。主要的想法是一本 tf 词典。特性，存储在 tf 中。例。我们将数据集写入这些示例，存储在 GCS 上。除了更改要素类型的潜在例外情况，这部分代码应该只需要对其他项目进行最少的编辑。如果数据已经上传到记录格式一次，这一部分可以跳过。本节大部分代码改编自 TensorFlow 官方文档以及本音频管道教程。
写入 TFRecord 格式
一旦这些记录被存储，我们需要其他函数来读取它们。每个例子都被依次处理，从 TFRecord 中提取相关信息并重建一个 tf.Dataset。数据集→作为 tfRecord 上传到 GCS 将 TFRecord 读入 TF。数据集)，但这实际上通过简化 I/O 过程提供了巨大的速度效率。如果 I/O 是瓶颈，使用 GPU 或 TPU 没有帮助，这种方法允许我们通过优化数据加载来充分利用他们在训练期间的速度增益。如果使用另一个数据集，主要变化将围绕数据维度。
将 TFRecord 数据读入数据集
准备培训、验证和测试集
重要的是将数据适当地分成训练-验证-测试集(64%-16%-20%)，前两个用于调整模型架构，后一个用于评估模型性能。拆分发生在文件名级别，读取 TFRecord 示例的管道应用于适当的名称集。
创建培训、验证和测试集
模型构建和培训
最后，我们可以使用 Keras API 来构建和测试模型。网上有大量关于如何使用 Keras 构建模型的信息，所以我不会深入研究细节，但这里重要的是使用 1D 卷积层结合池层从原始音频中提取特征。
插图 1D 卷积和池层。杨、黄、、王、向、李、薛琼。(2019).一种基于深度学习的盲频谱感知方法。传感器。19.2270.10.3390/s19102270。
训练和测试模型
最后一点相关信息是关于使用 TensorBoard 绘制训练和验证曲线。这些强调了过度拟合的问题，并为结论中指出的未来工作开辟了领域。它也可以用于模型开发期间的迭代。
显示此训练过程的张量板
总之，对同一机器学习任务的不同机器学习方法进行基准测试是有启发性的。这个项目强调了领域知识和特征工程的重要性，以及标准、相对简单的机器学习技术(如朴素贝叶斯)的力量。过度拟合是一个问题，因为与示例数量相比，特征的尺寸很大，但我相信未来的努力可以帮助缓解这个问题。
我很高兴地惊讶于迁移学习在 spectrograms 上的强劲表现，并认为我们可以通过使用音乐理论提供的更多功能来做得更好。然而，如果有更多的数据来提取模式，对原始音频的深度学习技术确实显示出了前景。我们可以设想一种应用，其中分类可以直接在音频样本上发生，而不需要特征工程。我期待着看到您在这篇文章中介绍的工作的基础上所做的一切！
基于卷积神经网络的音乐流派分类
阿德里安·科特在 Unsplash 上拍摄的照片
作为音乐和数据的爱好者，将两者结合起来的想法听起来很诱人。Spotify 和 Shazam 等创新公司已经能够以巧妙的方式利用音乐数据为用户提供令人惊叹的服务！我想尝试处理音频数据，并尝试建立一个模型，可以根据歌曲的流派自动对歌曲进行分类。我的项目代码可以在这里找到。
自动流派分类算法可以大大提高音乐数据库(如 AllMusic)的效率。它还可以帮助 Spotify 和 Pandora 等公司使用的音乐推荐系统和播放列表生成器。如果你热爱音乐和数据，这也是一个非常有趣的问题！
这个问题有两个主要挑战:
- 音乐流派的定义很宽泛。以至于人们经常为歌曲的风格争论不休。
- 从可以输入模型的音频数据中提取区别特征是一项艰巨的任务。
第一个问题我们无法控制。这是音乐类型的本质，也是一种限制。第二个问题已经在音乐信息检索(MIR)领域进行了大量研究，该领域致力于从音频信号中提取有用信息的任务。
如果你花时间认真思考一下，这是一个很难的问题！我们如何将气压振动转化为我们可以从中获得洞察力的信息？
我花了很多时间研究这个问题。为了建立一个模型，可以根据歌曲的流派对其进行分类，我需要找到好的特征。不断出现的一个有趣的特征是 mel 光谱图。
梅尔光谱图
mel 频谱图可以被认为是音频信号视觉表示。具体来说，它代表了频谱如何随时间变化。如果你想了解更多，我写了一篇文章(这里)深入探讨了这个话题。对于 TL；各位博士，这里有一个简短的总结:
傅立叶变换是一种数学公式，允许我们将音频信号转换到频域。它给出了每个频率的振幅，我们称之为频谱。由于频率成分通常会随时间变化，我们对信号的重叠窗口段执行傅里叶变换，以获得频谱随时间的变化情况。这被称为声谱图。最后，由于人类不会在线性标度上感知频率，我们将频率映射到 mel 标度(音高的一种度量)，这使得音高距离相等时，人耳听到的声音距离相等。我们得到的是梅尔的光谱图。
最精彩的部分？只用几行 Python 代码就可以生成。
import librosay, sr = librosa.load('./example_data/blues.00000.wav')mel_spect = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=2048, hop_length=1024)
mel_spect = librosa.power_to_db(spect, ref=np.max)librosa.display.specshow(mel_spect, y_axis='mel', fmax=8000, x_axis='time');
很神奇，是吧？我们现在有了一种视觉上表现歌曲的方法。让我们来看一些不同流派歌曲的梅尔谱图。
这太棒了。mel 声谱图中捕捉到了流派中的一些特质差异，这意味着它们可以制作出色的功能。
我们本质上所做的是将问题转化为图像分类任务。这很棒，因为有一个专门为这项任务制作的模型:卷积神经网络(CNN)。这让我想到了我项目的主要问题:卷积神经网络使用 mel 频谱图识别音乐流派的准确度有多高？
让我们开始吧！
收集和预处理数据
我使用的数据集是 GTZAN 流派集合(在这里找到)。这个数据集在 2002 年的一篇关于体裁分类的著名论文中使用过。该数据集包括 10 种不同的流派(布鲁斯、古典、乡村、迪斯科、嘻哈、爵士、金属、流行、雷鬼和摇滚)，每种流派有 100 首歌曲(每个 30 秒样本)。因为他们都是。wav 文件，我可以使用 librosa 库将它们加载到 Jupyter 笔记本中。
如上所述，使用 librosa 计算 mel 谱图相当简单。我能够编写一个函数来计算每个音频文件的 mel 声谱图，并将它们存储在一个 numpy 数组中。它返回该数组以及带有相应流派标签的数组。
现在我们已经有了我们的特性和目标，我们可以创建一个维持集，或者说验证集。我选择拿出 20%进行测试。
在构建模型之前，必须采取几个步骤:
- 为了计算效率，mel 光谱图的值应该被缩放，使得它们在 0 和 1 之间。
- 数据目前是 1000 行 128 x 660 的 mel 光谱图。我们需要将它调整为 1000 行 128 x 660 x 1，以表示有一个单一的颜色通道。如果我们的图像有三个颜色通道，RGB，我们将需要这个额外的维度为 3。
- 目标值必须进行一次热编码，以便输入神经网络。
重要的是，我们必须在创建维持集后完成这些步骤，以防止数据泄漏。现在我们准备做一些建模！
CNN 做的怎么样？
在运行 CNN 之前，我想训练一个前馈神经网络(FFNN)进行比较。CNN 具有用于边缘检测的附加层，这使得它们非常适合于图像分类问题，但是它们往往比 FFNNs 在计算上更昂贵。如果 FFNN 也能做得一样好，就没有必要使用 CNN 了。由于这篇文章的主要焦点是 CNN，所以我不会在这里详细介绍模型，但最好的 FFNN 模型取得了 45%的测试分数。
正如所怀疑的，CNN 模式做得更好！最好的 CNN 模型(基于测试分数准确度)取得了 68%的分数。这还不算太寒酸，尤其是考虑到问题的难度，但还是不算太大。训练分数为 84%，因此模型过拟合。这意味着它很好地适应了训练数据，但不能很好地推广到新数据。即便如此，这当然是学习。
我尝试了几种不同的架构来尝试改进模型，其中大多数都达到了 55%到 65%之间的精度，但我无法再提高了。大多数模型在大约 15 个时期后变得越来越过拟合，因此增加时期的数量似乎不是一个好的选择。
以下是最终架构的总结:
- 输入层:128 x 660 个神经元(128 个梅尔标度和 660 个时间窗口)
- 卷积层:16 种不同的 3 x 3 滤波器
- 最大池层:2 x 4
- 卷积层:32 种不同的 3 x 3 滤波器
- 最大池层:2 x 4
- 致密层:64 个神经元
- 输出层:10 种不同风格的 10 个神经元
所有隐藏层使用 RELU 激活函数，输出层使用 softmax 函数。使用分类交叉熵函数计算损失。辍学也被用来防止过度拟合。
更深入的观察
为了更深入地了解模型发生了什么，我计算了一个混淆矩阵，以可视化模型对实际值的预测。我发现的真的很有意思！
蓝调还是爵士？
该模型几乎从未预测过蓝调，只正确分类了 35%的蓝调歌曲，但大多数错误分类都是爵士乐和摇滚乐。这很有道理！爵士乐和蓝调是非常相似的音乐风格，摇滚乐深受蓝调音乐的影响，并真正从蓝调音乐中走出来。
雷鬼还是嘻哈？
这个模特也很难区分雷鬼和嘻哈。雷鬼一半的错误分类是 hiphop，反之亦然。再一次，这是有道理的，因为雷鬼音乐对 hiphop 音乐有很大的影响，并且有相似的特征。
这是石头吗？
该模型将几种流派错误地归类为摇滚，尤其是蓝调和乡村音乐。这并不奇怪，因为摇滚音乐有如此多的分支，分成其他流派。布鲁斯摇滚和受乡村音乐影响的南方摇滚都很受欢迎。
这告诉我们什么？
这其实真的是个好消息！我们的模型遇到了和人类一样的困难。很明显，它正在学习音乐流派的一些区别因素，但它在与其他流派有共同特征的流派上遇到了麻烦。这又回到了第一个问题，那就是音乐流派的本质。他们很难区分！
即便如此，我还是要说，对于一台电脑来说，68%的准确率并不算太差，但我确实相信还有改进的空间。我可以自信地说，CNN 比 FFNN 做得更好，它能够相当准确地学习和预测歌曲的风格。
一个自然的问题
如果我们去掉一些和其他流派有共同特征的流派，会发生什么？模型的表现会更好吗？它是如何处理二元分类的？这些是我脑海中仍然挥之不去的一些问题。如果你想深入这些问题，请关注我的下一篇文章。
未完待续……
Python 必备的日期时间函数
从蟒蛇和熊猫
Python 提供了一整套用于处理日期时间数据的函数和库。我经常使用:
- Python 的日期时间
- 熊猫的时间戳
在处理某种数据一段时间后，我们会比其他人更频繁地使用一些函数。虽然功能的选择完全取决于个人的经验和舒适度，但了解自己的选择是有好处的。如果您正在处理带有原始时间戳的时间序列或由各种系统和设备提供的某种形式的 DateTime 对象，那么本文应该复习一下将会派上用场的流行的 DateTime 函数。
1.日期和日期格式的字符串
这里我们讨论一下 python 。strftime() 函数和 pandas date_format 选项在 excel 和 CSV 中编写 pandas。
通常，如果您将 pandas 数据帧保存到 excel 或文本文档中，您会对 pandas 生成的 yyyy-mm-dd hh:mm:ss 默认格式不满意。这是我控制这些输出的方法。
让我们以一个包含随机日期和字符串代码的数据框为例。下面是我们将使用的玩具数据框:
start = datetime.datetime(2020,2,1)end = datetime.datetime(2020,2,10)dates = pd.date_range(start = start, end = end,freq=’D’).to_list()codes = [ "".join(choice(ascii_lowercase) for i in range(10)) for j
in range(10)]df = pd.DataFrame(columns=['date','code'])df.date = datesdf.code = codes
示例数据
Excel 输出
显然，日期列提供了很多信息，但不一定好看。我们不希望我们的输出报告中有这么大的日期，我们只需要知道日期的格式，比如日期/月/年。
战斗支援车
如果 csv 或文本输出是你的目标，这很容易改变。只需在您的 to_csv 函数中用 kwarg date_format 指定输出的格式。
df.to_csv(‘C:/location/slash_dates.txt’,date_format=’%M/%D/%Y’)
用斜线分隔的输出在 CSV 中很容易。
擅长
当使用 excel 时，你必须要小心一点，因为 Excel 在格式化日期时有自己的想法。
当然，您可以右键单击您的格式单元格，将格式更改为您想要的任何格式。但是一提到斜线，excel 就很固执。它不是 excel 必须提供的格式选项之一(可能是因为它看起来很丑，咄！).而且，值得一提的是，当 python 提供这么多功能时，不必每次都干扰 excel 中的输出。
python。strftime()方式:
为了实现与 to_csv 中的 date_format 等效的灵活性，我们“欺骗”excel，使用。strftime()并将其传递给 excel。(因为我们有一个 Series 对象，所以我们需要一个. dt 来访问它的值)
df.date = df.date.dt.strftime(“%d/%m/%y”)
哒哒！
斜线分隔的日期
哒哒！
excel 输出
或者，
熊猫道:
使用 pandas excel writer 并指定格式，如 to_csv(并为您的工作表命名作为额外的奖励。)
writer = pd.ExcelWriter(‘C:/location/writer_datetime.xlsx’,
date_format=”%D/%M/%Y”)df.to_excel(writer, sheet_name=’xl_slashes’)writer.save()
哒哒！
2.字符串中的日期
这里我们讨论一下。strptime( ) 和 to_datetime( ) 函数，基本上是我们前面所做的姊妹函数。
通过上面的步骤，您现在已经将带有一组时间戳属性的 datetime64 对象转换为一个字符串序列。(Pandas 数据类型是字符串或混合序列的“对象”)
之前。strftime():
之后。strftime():
出于某种原因，你想要回你的约会。假设您想要获取日期是几月几号或属于哪个日历周。使用内置的 datetime 函数比解析看起来像 DateTime 的字符串要好。
为此，我们使用了。strftime()，也就是。strptime( ) 或 pandas to_datetime( ) 函数，如果这是您更喜欢的。
熊猫的 to_datetime()方式:
日期对象从日期列中返回
注意它们所表达的意思的格式和相应的简短形式。假设您的日期字符串看起来不同，如下所示:
日期字符串的不同格式
你有没有注意到%B 代表这个月的扩张？
让我们将这个日期字符串转换成一个 DateTime 对象，从中获得日历周。
df['date_month'] = pd.to_datetime(df.date_month, format=’%d-%B-%y’)
现在我们有了 datetime 对象，让我们使用 pandas datetime 函数来获取日历周。周
df['calender_week'] = df.date_month.dt.week
在这里，日历周，熊猫之路。
Python 的 strptime()方式:
Pandas 不赞成使用 Timestamp.strptime()，而是用一个非常有效的 to_datetime()代替，可以使用. dt 访问器将它应用于整个系列。
但是，如果您有单独的时间戳实体需要在系列之外进行格式化。strptime()是一个有效的 python 函数。
import datetimedate_string = “2 March, 2020”dttime_obj = datetime.datetime.strptime(date_string, “%d %B, %Y”)
我们有一个来自字符串的日期、时间对象
datetime 的 isocalendar()方法是一个元组，包含位置 1 处的日历周。
dttime_obj.isocalendar()[1]
日历周，python 方式。
这些是 Python 中熊猫内外的一些有用的日期时间对象函数。希望这有所帮助！
数字分析师必备的 ML 技术:第 2 部分——客户终身价值
介绍可以帮助您优化数字分析价值链的机器学习技术
作者图片
正如我们在第 1 部分中介绍关联分析概念时所指出的，分析正变得越来越增强和相关。作为一名数字分析师，我们最好意识到不同数据源之间的联系，并准备好产生比描述性分析更多的东西。
考虑到这种必要性，我们将讨论另一个智能数字分析概念——客户终身价值。
计算寿命值
客户终身价值(CLV)是归属于客户关系的未来现金流的贴现总和。CLV 估计了一个组织未来将从顾客那里获得的“利润”。CLV 可用于评估可合理用于获取客户的资金量。即使不考虑美元价值，CLV 建模仍然有助于确定最重要的(又名。有利可图的)客户群，这些客户群随后可以在收购策略方面获得不同的待遇。
CLV 模型的分类很大程度上取决于业务的性质。如果企业与客户有合同关系(如订阅模式)，那么在这些情况下最重要的问题是长期留住客户，生存分析模型用于研究客户取消之前的时间。这些模型有时也被称为【一去不复返】模型，因为这些模型假设取消服务的客户不会再回来。
典型的“一去不复返”模型的简单 CLV 公式
CLV 公式将每期现金利润率 $M 乘以一个长期乘数，该乘数代表客户关系预期长度的现值:
CLV = $M [r / 1 + d-r]
其中 r 为每期留存率， d 为每期折现率。
CLV 模式的另一个主要类别叫做“永远分享”这些模型没有假设客户不活动意味着客户永远不会回来。例如，一个本月没有购买的零售客户可能下个月会回来。
正是这些类型的 CLV 模型与在线零售业务设置最相关，在在线零售业务设置中，用户可以随意参与业务，例如在电子商务商店中，用户可以随时进行购买。
在本文中，我详细介绍了一个模型，该模型可用于根据客户与企业的历史交易来预测未来的 CLV。本系列中描述的模型最适用于预测至少有适量交易历史的现有客户的未来价值。
为 CLV 买概率模型直到你死
BTYD 模型捕捉了客户的非合同购买行为，或者更简单地说，这些模型讲述了人们购买直到死亡(作为客户变得不活跃)的故事。
有两种广泛使用的模型-
- 帕累托/NBD
- BG/NBD
BG/NBD (Beta 几何负二项分布)模型比帕累托/NBD 更容易实现，运行速度也更快(我是故意天真的)。这两个模型倾向于产生相似的结果。这些模型假设顾客购买率和退出率的概率分布。建模基于描述这些假设的四个参数。
对假设的统计介绍很重要，但超出了本文的范围。要记住的一个高层次的想法是，这些模型假设客户与您的业务的交互应该是按照他们自己的意愿进行的(换句话说，对于您的解释是随机的)。如果你在获取客户方面有任何影响力(活动或促销优惠)，那么这种历史数据不适合这些模型。
示例实现
让我们考虑下面的场景-
一家零售商正在重新策划他们的 CPC 广告。他们想了解谁是他们最有利可图的客户，以及这个理想客户的人口统计情况。最终，他们希望更好地定位他们的 CPC 广告，以尽可能获得最有利可图的客户。他们为您提供了过去几年的交易数据，并根据三个客户类别(高价值、中价值和低价值)预测和输出。他们希望将这个客户价值标识符反馈到他们的数据湖，并了解更多关于每个桶的相关人口统计。
我们将该模型应用于公共数据集(详见引文)。该数据集包含 2010 年至 2011 年的交易。我们将首先准备数据，使其符合模型的预期“事件日志”格式。事件日志基本上是每个客户购买的日志，记录了相关的收入和时间戳。然后我们将使用一个概率模型来计算 CLV。这些数据足以提取最近、频率和货币(RFM) 值。这里的解决方案使用了 r 中现有的 BTYD 库。
完整代码请参考我的 GitHub
抛开上传和数据清理部分(我们将数据集转换成事件日志格式)，下面是剩余代码的分解
每周交易分析
方法 elog2cum 和 elog2inc 将事件日志作为第一个参数，并计算每个时间单位的累积或增量事务数。如果参数 first 设置为 TRUE，则包括客户的初始交易，否则不包括。
op <- par(mfrow = c(1, 2), mar = c(2.5, 2.5, 2.5, 2.5))
*# incremental*
weekly_inc_total <- elog2inc(elog, by = 7, first = TRUE)
weekly_inc_repeat <- elog2inc(elog, by = 7, first = FALSE)
plot(weekly_inc_total, typ = "l", frame = FALSE, main = "Incremental")
lines(weekly_inc_repeat, col = "red")
*# commualtive*
weekly_cum_total <- elog2cum(elog, by = 7, first = TRUE)
weekly_cum_repeat <- elog2cum(elog, by = 7, first = FALSE)
plot(weekly_cum_total, typ = "l", frame = FALSE, main = "Cumulative")
lines(weekly_cum_repeat, col = "red")
作者图片
此外，我们需要将事件日志转换成customer-by-sufficient-statistic(CBS)格式。elog2cbs 方法是将事件日志转换为 CBS data.frame 的有效实现，每个客户对应一行。这是估计模型参数所需的数据格式。参数 T.cal 允许用户分别计算校准和维持期的汇总统计数据。
我想使用 T.cal 只对 2011 年假日购物前的交易进行采样，而不是进行实际的校准和抵制，在 2011 年假日购物前，会有一个增量高峰。这将使估计的参数对未来的预测保持现实。
calibration_cbs = elog2cbs(elog, units = "week", T.cal = "2011-10-01")
head(calibration_cbs)
作者图片
返回的字段 cust 是唯一的客户标识符，x 是重复交易的次数(即频率)，t.x 是最后记录的交易的时间(即最近)，litt 是对数交互时间的总和(估计规律性所需)，first 是第一次交易的日期，T.cal 是第一次交易和校准周期结束之间的持续时间。用于表示 t.x、T.cal 和 litt 的时间单位是通过参数单位确定的，参数单位传递给方法 difftime，默认为周。仅包含那些在校准期间至少发生过一次事件的客户。
- 客户:客户 id(唯一键)。
- x:校准期间重复事件的数量。
- t.x:校准周期中第一个和最后一个事件之间的时间。
- litt:校准期间对数交互时序的总和。
- 销售额:校准期间的销售额总和，包括初始交易。
- first:校准期间第一笔交易的日期。
- T.cal:第一次事件和校准周期结束之间的时间。
- T.star:维持期的长度。
- x.star:维持期内的事件数。
- sales.star:维持期内的销售额总和。
估计 BG/NBD 过程的参数值。
*# estimate parameters for various models*
params.bgnbd <- BTYD::bgnbd.EstimateParameters(calibration_cbs) *# BG/NBD*
row <- **function**(params, LL) {
names(params) <- c("k", "r", "alpha", "a", "b")
c(round(params, 3), LL = round(LL))
}
rbind(`BG/NBD` = row(c(1, params.bgnbd),
BTYD::bgnbd.cbs.LL(params.bgnbd, calibration_cbs)))## k r alpha a b LL
## BG/NBD 1 0.775 7.661 0.035 0.598 -29637
预测维持期
*# predicting on holdout*
calibration_cbs$xstar.bgnbd <- bgnbd.ConditionalExpectedTransactions(
params = params.bgnbd, T.star = 9,
x = calibration_cbs$x, t.x = calibration_cbs$t.x,
T.cal = calibration_cbs$T.cal)
*# compare predictions with actuals at aggregated level*
rbind(`Actuals` = c(`Holdout` = sum(calibration_cbs$x.star)),
`BG/NBD` = c(`Holdout` = round(sum(calibration_cbs$xstar.bgnbd))))## Holdout
## Actuals 4308
## BG/NBD 2995
在总体水平上比较预测，我们看到 BG/NBD 对数据集“预测不足”。这归因于在坚守期(2011 年 11 月和 12 月)的交易量激增。在 bgcnbd 的帮助下，聚集水平的动态可以被可视化。PlotTrackingInc
nil <- bgnbd.PlotTrackingInc(params.bgnbd,
T.cal = calibration_cbs$T.cal,
T.tot = max(calibration_cbs$T.cal + calibration_cbs$T.star),
actual.inc.tracking = elog2inc(elog))
作者图片
在测试模型的情况下，我们可以使用维持期来计算 MAE
*# mean absolute error (MAE)*
mae <- **function**(act, est) {
stopifnot(length(act)==length(est))
sum(abs(act-est)) / sum(act)
}
mae.bgnbd <- mae(calibration_cbs$x.star, calibration_cbs$xstar.bgnbd)
rbind(
`BG/NBD` = c(`MAE` = round(mae.bgnbd, 3)))## MAE
## BG/NBD 0.769
伽玛支出的参数
现在，我们需要为客户的平均交易价值开发一个模型。我们将使用一个两层的层次模型。平均交易值将按照形状参数 p 进行伽马分布。这个伽玛分布的比例参数也是伽玛分布，形状和比例参数分别为 q 和$$。估计这些参数要求数据的格式与我们用于 BG/NBD 模型的 cbs 格式略有不同。相反，我们只需要每个客户的平均交易值和交易总数。在 elog 对象上使用 dplyr 符号可以很容易地实现这一点。
spend_df = elog %>%
group_by(cust) %>%
summarise(average_spend = mean(sales),
total_transactions = n())## `summarise()` ungrouping output (override with `.groups` argument)spend_df$average_spend <- as.integer(spend_df$average_spend)
spend_df <- filter(spend_df, spend_df$average_spend>0)
head(spend_df)
作者图片
现在让我们将这些格式化的数据插入到支出中。BTYD 包中的 EstimateParameters()函数来获取 Gamma-Gamma 花费模型的参数值。
gg_params = spend.EstimateParameters(spend_df$average_spend,
spend_df$total_transactions)
gg_params## [1] 2.619805 3.346577 313.666656
将模型应用于整个群体
有了理解交易和平均收入行为所需的所有参数，我们现在可以将该模型应用于我们的整个客户群体。为此，我们需要为整个数据集创建一个 cbs 数据框(即无校准周期)。我们可以再次使用 elog2cbs()函数，但是省略 calibration_date 参数。然后，我们可以计算每个客户未来 12 周的预期交易和平均交易值。
customer_cbs = elog2cbs(elog, units = "week")
customer_expected_trans <- data.frame(cust = customer_cbs$cust,
expected_transactions =
bgnbd.ConditionalExpectedTransactions(params = params.bgnbd,
T.star = 12,
x = customer_cbs[,'x'],
t.x = customer_cbs[,'t.x'],
T.cal = customer_cbs[,'T.cal']))
customer_spend = elog %>%
group_by(cust) %>%
summarise(average_spend = mean(sales),
total_transactions = n())## `summarise()` ungrouping output (override with `.groups` argument)customer_spend <- filter(customer_spend, customer_spend$average_spend>0)
customer_expected_spend = data.frame(cust = customer_spend$cust,
average_expected_spend =
spend.expected.value(gg_params,
m.x = customer_spend$average_spend,
x = customer_spend$total_transactions))
将这两个数据框架结合在一起，我们可以得到数据集中每个人未来三个月的客户价值。我们可以进一步把它们分成高、中、低三类。
merged_customer_data = customer_expected_trans %>%
full_join(customer_expected_spend) %>%
mutate(clv = expected_transactions * average_expected_spend,
clv_bin = case_when(clv >= quantile(clv, .9, na.rm = TRUE) ~ "high",
clv >= quantile(clv, .5, na.rm = TRUE) ~ "medium",
TRUE ~ "low"))merged_customer_data %>%
group_by(clv_bin) %>%
summarise(n = n())
作者图片
将历史支出和预测结合在一起，并将其保存为输出 csv —
customer_clv <- left_join(spend_df, merged_customer_data, by ="cust")
head(customer_clv)
write.csv(customer_clv, "clv_output.csv")
作者图片
CLV 星团图
customer_clv %>%
ggplot(aes(x = total_transactions,
y = average_spend,
col = as.factor(clv_bin),
shape = clv_bin))+
geom_point(size = 4,alpha = 0.5)
作者图片
输出 csv 现在可以反馈给客户数据库并与之合并。然后，clv 桶指标将可用于分解其他人口统计或行为信息。
引用
陈大庆、赛梁赛恩和郭昆，“在线零售业的数据挖掘:使用数据挖掘进行基于 RFM 模型的客户细分的案例研究”，《数据库营销和客户战略管理杂志》，第 19 卷第 3 期，第 197-208 页，2012 年(印刷前在线出版:2012 年 8 月 27 日)。doi: 10.1057/dbm.2012.17)。
数字分析师必备的 ML 技术:第 3 部分——推荐引擎
介绍可以帮助您优化数字分析价值链的机器学习技术
作为贵组织的数字分析师，您不应该为推荐引擎编写 ML 代码。然而，即使是编写这些代码的 ML 工程师也会依赖你来了解这些引擎在网站上的表现。此外，数字分析团队还会影响内容放置和内容的 A/B 测试(或不同的 ML 算法)。因此，一些关于推荐引擎如何工作的固有知识对你来说可能是一笔宝贵的财富。
我在浏览某本书的时候亚马逊给我的推荐。你能猜出是哪个吗？作者图片
推荐引擎—简介
推荐引擎优势的典型代表是亚马逊、网飞、Tinder 等公司。你的亚马逊主页是实践推荐的最好例子。在主页上滚动，你可以找到像、【受你购物趋势的启发】、【与你看过的商品相关】等部分。所有这些都由后台的推荐引擎提供支持。推荐引擎不仅仅局限于在电子商务页面上展示类似的产品。这些引擎有一个更深刻的用途，那就是使用右频道在右时间向右客户呈现相关的和个人的(右)内容。
除了一起购买的地图产品之外，推荐器的使用可以扩展到-
- 根据客户统计数据提出建议。
- 基于客户之间的相似性进行推荐。
- 基于产品相似度推荐。
- 基于客户的历史购买档案进行推荐。
推荐系统的用例不仅限于电子商务，还广泛存在于医药、金融和旅游等领域。
推荐引擎类型
作者图片
图中所示的每一种技术都可以用来建立一个推荐系统模型。让我们简单地探讨一下各种推荐引擎类别。
基于内容的过滤，通过比较产品属性和客户档案属性来推荐商品。每个产品的属性都表示为一组标签或术语，通常是产品描述文档中出现的词语。客户简档用相同的术语表示，并通过分析客户看过或评价过的产品的内容来构建。通常，基于内容的过滤方法基于一些相似性得分提供前 N 个推荐的列表。
协同过滤通过使用其他人的推荐来过滤信息。给定产品的用户评级数据库，其中一组用户已经对一组产品进行了评级，协同过滤算法可以对特定用户尚未评级的产品给出评级。这利用了用户的邻居信息来提供这样的推荐。协同过滤算法的潜在前提是，如果两个用户对一大组项目的评级达成一致，他们也可能倾向于对其他项目达成一致。
协同过滤可以进一步分为:
- 基于记忆的:在这种方法中，用户评分信息被用来计算用户或物品之间的相似度。这个计算出的相似度然后被用于提出推荐。这与基于内容的推荐不同，在基于内容的推荐中，项目/用户元数据用于计算相似性得分，而不是它们的反馈(例如评级)。
- 基于模型的:应用数据挖掘方法来识别数据中的模式，然后使用学习到的模式来生成建议。我们已经在第 1 部分的中介绍了一种使用 apriori 算法的流行关联挖掘技术。
- 潜在因素法利用矩阵分解技术来得出建议。最近，这些方法被证明优于基于项目和基于用户的推荐系统。这是著名的网飞推荐竞赛的获奖方案之一。
最后，混合过滤是我们结合多种类型的推荐系统来提出最终推荐的系统。
奇异值分解近似、最受欢迎项目和 SlopeOne 是可以用来建立推荐系统的一些其他受欢迎的技术。对推荐引擎的进一步学习可以是探索和研究这些很少使用的技术，并将它们应用于现实世界的问题。
示例实现
对于独立的实现，Python 和 R 都有包，其中包括捆绑在一起的最流行的推荐技术。re commender labR 中的软件包是用于构建推荐引擎的一站式商店，并提供了将数据集转换为所需格式以及训练/测试模型集合的强大功能。推荐器功能包含包含我们想要选择的不同相似性分数的参数的选项。
作为本文的一个例子，我们将采用一种更加有机的方法，尝试为新闻聚合网站实现基于内容的推荐。
考虑下面的用例-
一个新闻聚合器想要解决以下问题:当一个客户浏览某篇特定的文章时，我们应该向他推荐哪些其他的文章？挑战在于我们没有任何关于客户偏好的信息。我们要么是第一次看到顾客，要么是还没有建立任何机制来捕捉顾客与我们产品/物品的互动。
我们将从 UCI 公共知识库的新闻聚合器数据集中提取数据。
当用户浏览一篇特定的新闻文章时，我们需要向他推荐其他的新闻文章，推荐的依据是:
- 他当前正在阅读的文章标题的文本内容
- 此文档的发布者
- 文档所属的类别
- 文档的极性(我们将根据标题的文本内容来计算)
极性识别算法使用文本挖掘来获得文档的观点。我们将使用一种这样的算法来获得我们文本的极性。
对于这个用例，我们需要多个相似性度量:
- 余弦距离/相似度用于比较两个文档中的单词
- 对于极性，曼哈顿距离测量
- 对于出版商和类别，Jaccard 的距离
参考 GitHub 了解该项目的全部降价情况。
这是代码的分解-
代码的第一部分(直到第 62 行)关注数据争论，然后细化数据集，使其只包含一小部分数据(用于缩小项目规模)，并进一步只关注文章数量最多的前 100 家出版商。
相似指数
我们使用所有文章标题的单词包表示来衡量它们的相似性得分。我们使用余弦距离作为相似性得分度量，因为它对于值的大小的变化不是不变的，并且如果文章中有变化，它也会变化。
该流程包括:
- 使用 R 中的 tm 包，创建所有文章的文档术语矩阵(dtm)。
- 用它来测量文章之间的余弦距离，并返回一个文档矩阵。
# cosine distance
sim.score <- tcrossprod_simple_triplet_matrix(dtm)/(sqrt( row_sums(dtm^2) %*% t(row_sums(dtm^2)) ))sim.score[1:10,1:10]
作者图片
搜索
在这一节中，我们的目标是根据余弦相似性匹配过滤前 30 篇文章。例如，我们当前的文档是路透社题为“更新 1-乌克兰危机担忧打击德国投资者士气”的文章 ID 16947，然后我们根据余弦距离挑选出前 30 篇匹配的文章。
# merge title.df and other.df with match.refined:
match.refined <- inner_join(match.refined, title.df,by = "ID")
match.refined <- inner_join(match.refined, others.df,by = "ID")head(match.refined)
作者图片
极性得分
我们利用 R 中的 sentimentr package 来衡量我们收集的热门文章的观点。分数为-1 表示这个句子的极性非常低。1 分表示这个句子非常肯定。0 分表示句子的中性。
# update the match.refined data frame with the polarity scores:
match.refined$polarity <- sentiment.score$sentiment
head(match.refined)
作者图片
雅克卡德距离
我们还通过 Jaccard 索引来衡量当前文章的出版商和类别相似性。Jaccard 指数衡量两个集合之间的相似性，是参与集合的交集大小和并集大小的比率。这里我们只有两个元素，一个用于 publisher，一个用于 category，所以我们的 union 是 2。分子，通过添加两个布尔变量，我们得到交集。我们还计算搜索结果中的文章和我们的搜索文章之间的极性值的绝对差异(曼哈顿距离)。我们对差异分数进行最小/最大归一化，
# Jaccard's distance
match.refined$jaccard <- (match.refined$is.publisher + match.refined$is.category)/2# Manhattan distance
match.refined$polaritydiff <- abs(target.polarity - match.refined$polarity)range01 <- function(x){(x-min(x))/(max(x)-min(x))}
match.refined$polaritydiff <- range01(unlist(match.refined$polaritydiff))
作者图片
模糊逻辑排序
最后，我们使用这 3 个分数将模糊规则应用于列表，并获得前 30 篇文章的排名。基于语言变量余弦、Jaccard 和极性之间的相互作用，排序语言变量被分配不同的语言值。这些交互被定义为规则。定义了语言变量、语言值和隶属函数后，我们继续写下我们的模糊规则。
# The get.ranks function is applied in each row of match.refined to get the fuzzy ranking. Finally, we sort the results using this ranking.
get.ranks <- function(dataframe){
cosine = as.numeric(dataframe['cosine'])
jaccard = as.numeric(dataframe['jaccard'])
polarity = as.numeric(dataframe['polaritydiff'])
fi <- fuzzy_inference(ranking.system, list(cosine = cosine, jaccard = jaccard, polarity=polarity))
return(gset_defuzzify(fi, "centroid"))
}match.refined$ranking <- apply(match.refined, 1, get.ranks)
match.refined <- match.refined[order(-match.refined$ranking),]
match.refined
作者图片
这样我们就完成了一个简单的模糊诱导的基于内容的推荐系统的设计和实现。
故事还没完—
GitHub 基础知识
数据科学家必须了解的工具
照片由 Richy Great 在 Unsplash 上拍摄
有没有因为无法恢复一个被意外删除的小代码片段而感到沮丧？有没有因为不能重用你的分类模型的旧版本而感到有障碍，旧版本提供了最好的准确度分数？你还在遵循老派的版本控制方法(还记得 V 0.1，V 0.2 V 1.0…)吗？
如果以上任何一个问题的答案是肯定的，那么这个教程就是为你准备的。
假定
本教程假设您已经有了一个 GitHub 帐户并且在您的系统上安装了 Git Bash 应用程序(假设是 Windows 系统)。如果没有，有很多教程可以帮助你。GitBash 屏幕如下所示:
Git Bash 屏幕(图片由作者提供)
带着饭桶离开
Git 是一个免费和开源的版本控制系统，可以在本地跟踪源代码(或者你上传的任何文件)的变化。
为了推广协作开发的概念，像 GitHub(微软的子公司)这样的公司已经在 Git 的基础上建立了一个基于云的平台(GitHub platform)。除了支持版本控制(标准的 Git 特性)，这些平台还支持额外的特性，如 wikis、bug 跟踪、任务管理等。
定义关键字
在学习使用 GitHub 之前，让我们先了解一些你会在本教程中遇到的常见术语:
- 存储库 —通俗地说，这类似于一个包含所有项目文件的项目文件夹。标准实践是每个项目有一个存储库。
- 分支——一般来说，开发人员使用不同的分支来维护项目的不同模块。另一个允许使用分支的常见场景是当团队的多个成员想要处理同一段代码时。这是每个人都可以有自己的分支的时候。默认情况下，每个新创建的存储库都有一个名为“ master ”的中心分支。
- 克隆 —克隆就像将存储库从一个驱动器(GitHub 上的开发者文件夹)复制并粘贴到另一个驱动器(我们的本地文件夹)。
- Stage & Commit —在您的 git 存储库上创建一个新的项目版本，是一个两步过程。第一步是收集所有需要成为新版本一部分的文件。这就是所谓的暂存文件。第二步是创建项目的新版本，称为提交。只有那些暂存的文件才能提交到新版本。
- Push&Pull——鉴于我们对 GitHub 的关注，push and pull 是关于与存储在 GitHub 云上的存储库进行交互。拉就像下载最新版本，推就等同于在 GitHub 上上传你的最新版本
单独工作时的 GitHub 活动
这种场景适用于当你独自在你的存储库上工作时，比如存储你的代码、文件、项目等等。您的存储库没有授权的协作者，或者您不是其他人的存储库的授权协作者。
a.)创建自己的存储库
使用 GitHub 时，首先要做的就是创建一个存储库。该过程非常简单，如下所示:
- 登录 —登录您的 GitHub 账户，点击屏幕左上方的新建。
主页—左上角的新按钮(作者图片)
- 详细信息— 填写一个简单的表单，然后单击创建存储库(示例截图供您参考)。就这样，您的存储库创建完成了。正如前面所定义的，可以把它想象成一个可以保存多个文件的项目文件夹。
存储库表单(图片由作者提供)
b.)在本地系统上克隆云存储库
克隆将您的云(GitHub)存储库的内容下载到您的系统文件夹中。使用这个过程，你不仅可以从你的 GitHub 库下载内容，还可以从其他开发者创建的任何公共库下载内容。这是我们开始使用 Git Bash 的地方:
- 克隆链接 —搜索要克隆的存储库并复制克隆链接
克隆存储库的链接(图片由作者提供)
- Windows 文件夹创建 —在您的 Windows 驱动器中创建文件夹，您希望在其中克隆所有的存储库文件。打开 Git Bash ，使用以下命令导航到所需的文件夹位置。
更改文件夹位置(图片由作者提供)
关键字“ cd ”是变更目录的缩写。其次是文件夹位置或双句点(..)指示控制台将其工作位置从当前目录分别更改为提供的文件夹位置或文件夹层次中的前一个文件夹。
- 克隆 —到达文件夹位置后，使用“git clone”命令克隆存储库
**#### Command**
git clone ***clone_link***
克隆 GitHub 库(图片由作者提供)
上述命令中的克隆链接是我们在步骤 1 中复制的链接。该命令将在您的文件夹位置创建一个新文件夹(与 GitHub 存储库同名)。这个新文件夹将包含我们克隆的云存储库的所有资源。这里需要注意两个要点:
- 上面解释的过程仅仅克隆了存储库的“主”分支。我们已经在定义部分对分支做了简要介绍，但更多细节请见第 2 章
- 用于克隆的克隆链接作为远程链接保存在您的本地存储库中，默认名称为origin
了解以上两点很重要，因为这在我们从 GitHub 库推送或获取最新版本时会很有用。
c.)创建版本(添加和提交)
克隆完成后，我们可以修改云存储库的副本。为了在每个检查点创建版本，我们将采取以下步骤:
- 暂存 —一旦您对文件进行了满意的修改(或创建了一个新文件)，请将它们添加到暂存区
**#### Command**
git add ***file_name***
暂存(作者图片)
- 状态检查 —要检查文件是否成功添加到暂存区，执行以下命令
**#### Command**
git status
检查状态(作者图片)
Git status 将列出您在本地 repo 中修改过的所有文件。添加到暂存区的将为绿色，而未添加到暂存区的将为红色。
- 提交 —一旦您确定您想要进行版本控制的文件在暂存中，通过执行以下命令对它们进行版本控制
**#### Command**
git commit -m "message"
提交(图片由作者提供)
请注意命令行选项“ -m ”，后跟“消息”。这里的消息是一个自由文本注释，解释提交版本中所做的更改。
就是这样，文件的新版本保存在 Git 存储库中(但是在您的本地系统上)。
d.)将本地存储库与云存储库同步
直到最后一步，我们通过将文件提交到我们的本地存储库来创建文件的新版本。在这一步中，我们将把本地存储库(带有更新的文件版本)推送到云存储库。执行此操作的命令如下:
**#### Command**
git push origin master
推送至 GitHub(图片由作者提供)
解码语法:
- 推送命令指示命令行将本地存储库上传到云(Git Hub)
- 正如克隆步骤中所解释的，关键字“origin”包含到被克隆的 GitHub 存储库的链接。当 Git 遇到单词 origin 时，它标识本地存储库需要被推送的云位置。
- 关键字“master”是本地存储库将被推送到的分支的名称。当使用其他分支时，用分支名称替换主分支。
e.)从云储存库下载后续更新
对于首次访问云存储库，我们使用了克隆过程。假设整个社区都可以访问云存储库，那么可能会有多次更新(git 术语中的 commit ),并且您的本地克隆存储库可能不会随着最近的更改而更新。要从云仓库下载最新版本的，请使用以下命令。
**#### Command**
git pull origin master
摘自 GitHub(图片由作者提供)
请注意，该命令与 push 命令相同，唯一的区别是 push 一词被 pull 所取代。
结束语
你知道吗，对于很多技术性的工作角色，雇主现在希望你是一个活跃的 GitHub 成员，拥有多个知识库和贡献者。
在 GitHub 的下一章，我们将学习如何使用 GitHub 与开发者社区合作。与此同时，掌握了这一新工具的知识，就可以开始将你的项目社会化了。
快乐学习！！！！
5 篇必读的数据科学论文(以及如何使用它们)
让你在机器学习游戏中保持领先的基本理念。
Rabie Madaci 在 Unsplash 上拍摄的照片
D 数据科学可能是一个年轻的领域，但这并不意味着你不会面临关于你对某些主题的认识的期望。这篇文章涵盖了几个最重要的最新发展和有影响力的思想作品。
这些论文涵盖的主题从 DS 工作流程的编排到更快神经网络的突破再到对我们用统计数据解决问题的基本方法的反思。对于每篇论文，我都提供了如何将这些想法应用到自己工作中的想法
我们将通过一个 调查 来总结一下，这样您就可以看到社区认为这组论文中最重要的主题是什么。
#1 — 机器学习系统中隐藏的技术债务 🙈
Google Research 的团队提供了关于反模式的清晰说明，以避免在设置数据科学工作流时使用反模式。本文借用软件工程中技术债的比喻，将其应用于数据科学。
通过数据块
正如下一篇论文更详细地探讨的那样，构建机器学习产品是软件工程的一个高度专业化的子集，因此从这个学科中吸取的许多经验教训也适用于数据科学是有意义的。
如何使用:跟随专家的实用提示来精简开发和生产。
#2 — 软件 2.0 💻
Andrej Karpathy 的这篇经典文章阐明了机器学习模型是基于数据的代码的 T2 软件应用的范例。
如果数据科学是软件，那么我们到底在构建什么？Ben Bengfort 在一篇名为“ 数据产品的时代 ”的有影响力的博客文章中探讨了这个问题
数据产品代表了 ML 项目的操作化阶段。诺埃米·马卡韦-卡特茨在 Unsplash 上拍摄的照片。
如何使用:阅读更多关于数据产品如何适应型号选择流程的信息。
#3 — BERT:用于语言理解的深度双向变形金刚预训练 🤖
在这篇论文中，谷歌研究团队提出了自然语言处理(NLP)模型，该模型代表了我们在文本分析能力方面的阶跃函数增长。
尽管关于 BERT 为什么工作得这么好还有一些争议，但这是一个很好的提醒，机器学习领域可能已经发现了成功的方法，但还没有完全理解它们是如何工作的。与自然一样，人工神经网络充满了神秘。
在这个令人愉快的剪辑中，Nordstrom 的数据科学主管解释了人工神经网络如何从自然中获取灵感。
如何使用:
- BERT 文件可读性很强，包含一些建议的默认超参数设置，作为有价值的起点(参见附录 A.3)。
- 不管你是不是 NLP 新手，看看 Jay Alammar 的“第一次使用 BERT 的可视化指南”来了解 BERT 的能力。
- 还可以看看ktrain ，这是一个位于 Keras 之上的包(Keras 又位于 TensorFlow 之上)，它允许您在工作中毫不费力地实现 BERT。 Arun Maiya 开发了这个强大的库，以加速对自然语言处理、图像识别和基于图形的方法的理解。
#4— 彩票假设:寻找稀疏、可训练的神经网络 💰
虽然 NLP 模型变得越来越大(参见 GPT-3 的 1750 亿个参数)，但人们一直在努力寻找更小、更快、更有效的神经网络。这些网络承诺更快的运行时间、更低的培训成本和更少的计算资源需求。
在这篇开创性的论文中，机器学习奇才 kids Jonathan Frankle 和 Michael Carbin 概述了一种修剪方法，以发现稀疏子网络，这些子网络可以获得与原始的、明显更大的神经网络相当的性能。
彩票指的是具有初始权重的连接，这些连接使它们特别有效。该发现在存储、运行时和计算性能方面提供了许多优势，并在 2019 年 ICLR 获得了最佳论文奖。进一步的研究建立在这种技术上，证明了它的适用性和将其应用于一个原本稀疏的网络。
如何使用:
- 在投入生产之前，考虑修剪你的神经网络。修剪网络权重可以将参数数量减少 90%以上，同时仍能实现与原始网络相同的性能水平。
- 还可以看看数据交换播客的这一集，本·洛里卡在这里与神经魔法交谈，这是一家初创公司，它正在寻求利用诸如修剪和量化之类的技术，通过一个灵活的用户界面使实现稀疏变得更容易。
阅读更多:
- 看看这个有趣的侧边栏，它来自《彩票》的作者之一，讲述了机器学习社区评估好想法的缺陷
#5 — 解开零假设统计检验的死结(p【t 30.05】☠️
经典假设检验导致过度确定，并产生错误的想法，即原因已经通过统计方法确定。(阅读更多)
假设检验早于计算机的使用。考虑到与这种方法相关的挑战(例如甚至统计学家都发现几乎不可能解释 p 值)，现在可能是考虑替代方法的时候了，例如有点精确的结果测试(SPOT)。
通过 xkcd 的“重要”
如何使用:
- 看看这篇博客文章，“假设的统计测试之死”，其中一位沮丧的统计学家概述了与经典方法相关的一些挑战，并解释了一种利用置信区间的替代方法
调查时间！
你认为哪些文章对你理解数据科学至关重要？请在评论中留言告诉我。
如果你喜欢阅读这篇文章，请关注我的 Medium 、 LinkedIn 、 YouTube 和 Twitter ，了解更多提升你的数据科学技能的想法。当“ 资源在 2020 年 最后几个月为您的数据科学增压”发布时，请注册以获得通知。
🎥奖励— 为您的数据科学工作流程添加可视化的绝佳指南
必须使用内置工具来调试你的 Python 代码！
python 调试器模块指南，包含有用的代码和命令。利用这个工具，只需一行代码就可以高效地调试 python 代码。
GIF 来自 GIPHY
你写完代码，满怀热情地运行程序！
只是遇到了这样的事情—
错误！
一旦遇到这个错误，你要么沮丧地关闭你的笔记本电脑，继续你的生活，要么回到绘图板，开始调试。
在计算机编程和软件开发中，调试是发现和解决计算机程序、软件或系统中的错误的过程。
在编程中，解决错误并找出错误的确切位置是一项至关重要的任务。然而，这种杂务可能很费时间，而且压力很大。
幸运的是，python 是一种出色的编程语言，为我们提供了多种处理调试问题的方法。
我们今天用来调试程序的一个简单易用的模块是 pdb 库模块。
PDB 代表 Python 调试器。
pdb 库模块为 Python 程序定义了一个交互式源代码调试器。
它支持在源代码行级别设置(条件)断点和单步执行、检查堆栈帧、源代码列表，以及在任何堆栈帧的上下文中评估任意 Python 代码。它还支持事后调试，可以在程序控制下调用。
让我们用一些代码来讨论如何利用这个模块来调试我们的 python 程序！哦，从技术上讲，它可以在一行中完成！😃
照片由 Cookie 在 Unsplash 上的 Pom 拍摄
使用 pdb 模块进行调试:
好了，调试 python 代码只需要这一行代码。命令如下—
**import** **pdb**; pdb.set_trace()
你也可以这样写这个命令——
import pdb***********
Code
pdb.set_trace()
***********
现在，我们将进一步了解如何在我们的程序中利用这一点。让我们从查看 set_trace 命令开始。
**pdb.set_trace**
此命令用于在调用堆栈帧处进入调试器。这对于在程序中的给定点硬编码断点很有用，即使代码没有被调试(例如，当断言失败时)。如果给定，就在调试开始前将标题打印到控制台。
为了更详细地理解这个模块，让我们借助下面的简单代码块来分析它
上面的代码块由一个简单的组成，用于将要运行五次迭代的循环。由于我们使用了 pdb.set_trace 命令，所以每次迭代结束时程序都会有一个断点，让你分析循环。
下面的输出块展示了如何使用 python 调试器模块。pdb.set_trace()函数为用户提供了许多命令选项。我们将很快讨论这些。
> <ipython-input-5-756613cbbf04>(5)<module>()
-> print(i)
(Pdb) c
0
> <ipython-input-5-756613cbbf04>(4)<module>()
-> pdb.set_trace()
(Pdb) h
我在(Pdb)块旁边输入了“c”。这个命令告诉函数继续执行。“h”命令是允许用户查看各种可用命令选项的选项。帮助命令显示以下选项—
作者截图
让我们分析一下这些可供用户选择的选项到底代表了什么。
调试器命令:
下面列出了调试器可以识别的命令。大多数命令可以根据需要缩写成一个或两个字母；例如:h(elp)表示h或help都可以用来输入帮助命令(而不是he或hel，也不是H或Help或HELP)。命令的参数必须用空格(空格或制表符)分隔。在命令语法中，可选参数用方括号([])括起来；不得键入方括号。命令语法中的选项由竖线(|)分隔。
1。w(此处)
打印堆栈跟踪，最新的帧在底部。箭头指示当前帧，它决定了大多数命令的上下文。
2。d(自己的)[计数]
将堆栈跟踪中的当前帧计数(默认为 1)向下移动一级(到一个较新的帧)。
3。
继续执行，仅在遇到断点时停止。
4。h(elp)
不带参数，打印可用命令的列表。使用命令作为参数，打印关于该命令的帮助。帮助 pdb 显示完整的文档(pdb 模块的 docstring)。因为命令参数必须是一个标识符，所以必须输入 help exec 来获得关于!命令的帮助。
5。q(uit)
退出调试器。正在执行的程序被中止。
这些是最重要的命令，可以帮助您更容易地调试代码。更多代码和命令，请访问 python 调试器模块的官方网站。
python 调试器工具是 python 开发人员的资产。然而，它有时会被忽视。我强烈推荐大家去看看这个模块，当你在调试 python 代码时遇到困难时，好好利用它。
结论:
python 调试器 pdb 是一个绝对令人惊叹的库模块，用于分步调试您的代码。
如果您被困在一个问题中，并且不知道潜在的错误到底发生在哪里，那么利用这个模块是一个不错的选择。
调试代码是编程最重要的方面之一。编写代码是计算程序的重要组成部分，但评估和调试也是编码的基本特征。
如果说调试是去除软件 bug 的过程，那么编程一定是把 bug 放进去的过程。
—埃德格·迪杰斯特拉
看看这些你可能喜欢阅读的文章吧！
[## OpenCV:用代码掌握计算机视觉基础的完全初学者指南！
包含代码的教程，用于掌握计算机视觉的所有重要概念，以及如何使用 OpenCV 实现它们
towardsdatascience.com](/opencv-complete-beginners-guide-to-master-the-basics-of-computer-vision-with-code-4a1cd0c687f9) [## 2020 年及以后最受欢迎的 10 种编程语言
讨论当今 10 种最流行的编程语言的范围、优缺点
towardsdatascience.com](/10-most-popular-programming-languages-for-2020-and-beyond-67c512eeea73) [## 带有完整代码片段和有用链接的 5 个最佳 Python 项目创意！
为 Python 和机器学习创建一份令人敬畏的简历的 5 个最佳项目想法的代码片段和示例！
towardsdatascience.com](/5-best-python-project-ideas-with-full-code-snippets-and-useful-links-d9dc2846a0c5) [## Python 从头编码:没有任何机器学习库的矩阵乘法！
从零开始了解如何在没有任何机器学习库的情况下实现矩阵乘法！
towardsdatascience.com](/python-coding-from-scratch-matrix-multiplication-without-any-machine-learning-libraries-463624fe8726) [## 5 个关于 Python、机器学习和深度学习的超棒的计算机视觉项目创意！
讨论 5 个很酷的计算机视觉项目，学习新的技能，增强你的简历
towardsdatascience.com](/5-awesome-computer-vision-project-ideas-with-python-machine-learning-and-deep-learning-721425fa7905)
谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！
我最喜欢的 10 个在线学习数据科学的资源
Ivo Rainha 在 Unsplash 上拍摄的照片
这些网站将帮助您跟上数据科学的最新趋势
当我说数据科学正在成为最受欢迎的工作领域之一时，我想你不会反对我，特别是考虑到《哈佛商业评论》将“数据科学家”评为 21 世纪最性感的工作。在这个领域，我们已经走过了漫长的道路，从数据科学和机器学习这样的术语还不为人知，一切都聚集在统计的保护伞下的时代开始。然而，我们离旅程的终点还很远。
这也可能是数据科学的一个分化方面，该领域发展如此迅速，以至于很难跟上所有新的算法、技术和方法。所以在数据科学领域工作，类似于软件工程，通常需要不断的学习和发展。不要误解我，有些人(包括我自己)非常喜欢那样。其他人更喜欢学习几年，然后从那些知识中剪下优惠券。两种方法都很好——这是个人偏好。
正如我提到的，在数据科学领域工作可能是一段旅程。这就是为什么在本文中，我想分享我最喜欢的 10 个数据科学资源(在线资源)，我经常使用它们来学习并试图跟上当前的发展。这个列表将关注在线资源(博客、视频、播客),不包括 MOOCs 或书籍，因为那里的内容已经足够写一篇单独的文章了。开始吧！
1.走向数据科学
来源:https://towardsdatascience.com/
鉴于你正在阅读发表在走向数据科学上的这篇文章，这并不奇怪。TDS 是 Medium 最大的出版物，涵盖所有数据科学相关主题。你可以在这里找到什么:
- 带代码的初学者友好教程(使用最流行的语言，如 Python、R、Julia、SQL 等)，
- 特定 ML 算法或技术的深入描述，
- 有影响的论文摘要，
- 个人宠物项目描述，
- 来自现场的最新消息，
- 还有更多！
TDS 创建了一个非常好的社区，鼓励每个人分享和参与。此外，我强烈推荐加入时事通讯，在 Twitter 上关注 TDS，了解最新最受欢迎的文章。
最后，我还可以推荐“走向数据科学”播客，它对想知道如何进入数据科学并找到自己理想角色的人特别有帮助。
2.PyData(会议+视频)
PyData 是 NumFOCUS 的教育项目，NumFOCUS 是一家促进研究、数据和科学计算开放实践的非营利慈善机构。他们在世界各地组织会议，鼓励研究人员和从业人员分享他们在工作中的见解。在讲座中，您可以找到一般 Python 最佳实践的组合、数据科学家处理的真实案例的示例(例如，他们如何对客户流失建模，或者他们使用什么工具来提升他们的营销活动)，以及一些新库的介绍。
从我的经验来看，亲自参加会议是非常有趣的，因为你可以积极地参与演示，提出问题，并与和你有共同兴趣的人建立联系。然而，由于这并不总是可能的，而且有太多的会议要参加，你可以在他们的 YouTube 频道上找到所有的记录。通常，这些录音会在每次会议后几个月发表。
PyData 讲座是一个很好的灵感来源，因为你可以看到其他公司如何处理一个特定的主题，也许你可以在你的公司应用类似的方法。
3.机器学习掌握
杰森·布朗利的网站/博客对于数据科学家来说是一座内容的金矿，尤其是那些资历较浅的科学家。你可以找到大量的教程，从经典的统计建模方法(线性回归，ARIMA)，到最新最棒的机器/深度学习解决方案。这些文章总是非常实用，并包含将特定概念应用于玩具数据集的 Python 代码。该网站的真正伟大之处在于，Jason 清楚地解释了这些概念，并为那些想要深入了解理论背景的人提供了进一步的阅读。如果你只对不平衡学习或如何编写你的第一个 LSTM 网络感兴趣，你也可以按主题过滤所有的文章。
4.蒸馏
distilt旨在为机器学习概念提供清晰直观的解释。他们认为，论文往往局限于 PDF 文件，不能总是显示全貌。当 ML 获得越来越多的影响时，很好地理解我们使用的工具实际上是如何工作的是至关重要的。
Distill 使用令人印象深刻的交互式可视化来清楚地解释机器学习算法背后实际发生的事情。我在最喜欢的一篇文章描述了 t-SNE(t-分布式随机邻居嵌入),并展示了生成的图形虽然看起来令人愉快，但可能会产生误导。它还指出了超参数的重要性，提供了一个互动工具来直接观察影响。
如果你需要任何关于内容质量的额外保证，Distill 背后的指导委员会包括 Yoshua Bengio，Ian Goodfellow，Michael Nielsen，Andrej Karpathy 等名字。
5.带代码的文件
代码为的论文是一个伟大的创举，它创建了一个包含 ML 论文的免费开放资源库，以及代码和评估表。您可以轻松浏览可用的论文(包括最先进的)并按主题进行搜索，例如，计算机视觉领域中的图像彩色化。
当你想尝试一些方法或者把它应用到你的数据集上，而不需要实际自己写所有的代码时，这个网站非常方便。虽然这样的练习肯定是有帮助的，并且你会学到很多东西，但是有时你只需要拼凑一个 MVP 来表明某些东西实际上为你的用例工作并且产生增值。在获得所需的批准后，您可以平静地钻研代码，理解特定模型或架构的所有细微差别。
6.卡格尔
Kaggle 成为想要参加机器/深度学习竞赛的人的首选平台。成千上万的人参加比赛来训练最好的模型(通常是大型和复杂的模型集合)，以达到最好的分数并获得认可(和金钱奖励)。
但是，平台本身远不止这些。首先，Kaggle 包含数千个内核/笔记本，展示了 ML 算法的实际实现。通常，创建者还会对模型及其超参数提供深入的理论解释。这个笔记本包含了许多最流行的 ML/DL 算法的链接，这些算法是在 Kaggle 内核(Python 和 R)中为定制数据集实现的。
更重要的是，Kaggle 还包含许多定制的、用户上传的数据集(在撰写本文时，超过 40k)，您可以用于自己的分析。从新冠肺炎的最新数据到所有神奇宝贝的统计数据，你几乎可以找到任何能引起你兴趣的东西。许多 TDS 文章都是使用 Kaggle 的数据集编写的。因此，如果你想在泰坦尼克号或波士顿房子以外的地方练习你的技能，Kaggle 是一个很好的起点。
7.r 博客
我从 R 开始了我的数据科学之旅，即使在将我的主要编程语言切换到 Python 之后，我仍然关注 R-bloggers。它是一个博客聚合器(你也可以通过提交你的博客来加入),涵盖了广泛的主题。虽然大多数都与 R 相关，但是通过阅读数据科学任务的一般方法，您仍然可以学到很多东西。
我确实相信，人们不应该把自己局限于一种编程语言，而忽略其他任何东西。也许你会读到一个有趣的 R 项目/包，并决定将其移植到 Python？或者，您可以使用rpy2从 Python 访问 R 包，让您的生活更轻松。
虽然 Python 目前是数据科学领域的头号语言，但仍有许多包和工具没有从 R 移植到 Python。这就是为什么我认为 R-bloggers 是一个非常有价值的资源，并且可能是将一些 R 功能移植到 Python 的灵感来源。
8.arXiv
arXiv 是康奈尔大学在计算机科学、机器学习等领域的科学论文电子预印本的开放存取资源库。基本上，这是寻找最新研究和最先进算法的地方。但是，现在每天新增的文章非常多，基本上不可能做到面面俱到。这就是为什么 Andrej Karpathy 创建了 ArXiv Sanity Preserver 来试图过滤掉最重要/相关的文件。此外，你可以在 Twitter 上关注 arXiv Daily ，获得每日最重要研究文章的精选列表。友情提示:推文的数量可能会多得令人无法承受。
9.GitHub 超棒的机器学习
这个 GitHub repo 包含了机器学习框架、库和一般软件的精选列表。为了方便起见，它们按语言分组。此外，repo 还包含博客、免费书籍、在线课程、会议、聚会等列表。这个存储库绝对非常有价值，您可以花相当长的时间来探索所有可用的信息。尽情享受吧！
10.推特
这是非常主观的，因为在很多情况下，Twitter 被用作社交网络，就像脸书一样。然而，我试图将它专门用于关注数据科学领域的人，并避免点击诱饵内容。许多研究人员、作者和其他著名的数据科学家都有活跃的 Twitter 账户，他们经常分享有趣/相关的内容。这是了解数据科学最新发展和“热门话题”的好方法。
要关注的人的列表将高度依赖于你的兴趣范围，例如，如果你专注于用于计算机视觉或 NLP 的深度学习。我建议从你最喜欢的作者开始，无论是书籍还是 MOOCs，然后名单会自然增长，因为你会通过转发等方式接触到其他有趣的人。
万一你有兴趣，可以在这里找到我关注的人。
其他有用的资源
上面的列表绝非详尽无遗，因为互联网上充满了非常有用的数据科学资源。下面我列出了一些其他的资源，它们没有进入我的前十名，但也很棒，我经常使用它们:
我会继续更新这个列表，以防我忘记了什么或者我发现了新的东西:)
结论
在本文中，我向您展示了 10 个最受欢迎的资源，用于进一步发展我的数据科学技能。你有没有这里没有提到的最喜欢的来源？请在评论中告诉我，我会很乐意找到更多！
觉得这篇文章有趣？成为一个媒介成员，通过无限制的阅读继续学习。如果你使用这个链接成为会员，你将支持我，不需要你额外付费。提前感谢，再见！
如果您喜欢这篇文章，您可能还会对以下内容感兴趣:
在一个充满指标的世界里，我们需要清楚地认识到那些弊大于利的指标
towardsdatascience.com](/on-the-tyranny-of-metrics-and-metric-fixation-b4c1d44b5f6c) [## 介绍我的书:Python 金融烹饪书
我的短篇小说从中型文章到图书合同
towardsdatascience.com](/introducing-my-book-python-for-finance-cookbook-de219ca0d612) [## Python 统计块中的新成员:pingouin
图书馆的快速参观，以及它是如何从老守卫中脱颖而出的
towardsdatascience.com](/the-new-kid-on-the-statistics-in-python-block-pingouin-6b353a1db57c)
我在 Kaggle 上的两年旅程:我如何成为竞赛大师
描述我的旅程和策略，我遵循成为一个竞赛大师与个人金牌
在 Kaggle 上打印我的个人资料页面的屏幕。
上个月我写了关于我从开始学习 Python 到成为 Kaggle 竞赛大师的旅程。在那个故事中，我非常简要地描述了我在卡格尔的旅程。在这个故事中，我将更详细地描述对我的旅程影响最大的 3 场比赛。然后我会写几个关于如何应对任何竞争的话题。
目录
- TGS 盐鉴定挑战
- 座头鲸识别
- Freesound 音频标记 2019
- 如何应对任何竞争
TGS 盐鉴定挑战赛
地球表面以下的盐沉积出现在地球的几个区域。地震成像使专家能够识别这种盐体。这是一项非常耗时的任务，并且会导致主观结果。在这场比赛中，kagglers 被要求建立一个分割算法，以自动和准确地识别地震图像中的盐体。
部分比赛数据的可视化由 Vicens Gaitan 在 Kaggle 上 。
这是我参加的第一次比赛，我已经有了如何训练模型和做一些实验来提高分数的基本想法——这主要归功于 fastai 课程杰瑞米·霍华德的程序员实用深度学习。
我从一个公共内核开始。在 3 个月的比赛中，我不断尝试越来越多的想法，其中大部分是在 Kaggle 讨论中发现的。那时候，除了尝试尽可能多的想法，我真的没有任何明确的策略。更重要的是，其他竞争对手声称对他们的模型有帮助的想法。
最终，我获得了一枚铜牌(前 10%)，在 3229 名中名列第 186 名，距离银牌(前 5%)不远。我真的为我的成就感到高兴！但最重要的是，通过参加这个比赛和尝试很多想法，我提高了作为深度学习实践者的技能。
真的没有课程或书籍能让你成为实用深度学习的专家。就像学习演奏一种乐器。你可以学习关于乐器的所有知识，但是如果你想精通它，你将需要许多许多小时的练习。
座头鲸识别
科学家们使用照片监控系统来监控鲸鱼数量，以努力保存和保护这些海洋中的巨大生物。鲸鱼尾巴的形状和标记就像指纹，可以唯一地识别每个个体。在过去的几十年里，这项耗时的鉴定工作一直由科学家手工完成。在这场比赛中，卡格勒夫妇被要求建立一种算法，根据尾巴的照片来识别鲸鱼个体。
Kaggle 上的座头鲸识别中同一条鲸鱼的两幅图像示例。
对我来说，这次比赛可能是最有趣的案例研究。当我参加比赛时，我想这只是又一场图像分类比赛。没什么好担心的，对吧？不对。我很快意识到使用基本的图像分类技术会导致非常差的性能。问题在于，对于一些鲸鱼来说，数据集上只有很少的样本。有时候只有一个！数据集中还有许多鲸鱼以前没有被识别出来，应该被标记为新的鲸鱼。我甚至不知道如何开始解决这样的问题。
在比赛的第一个月，我花时间阅读科学文章关于少拍学习、人物再识别等等。有很多新的概念需要学习，比如按集训练。这就是为什么我花了一段时间才理解概念到可以用代码实现它们并开始在竞争中取得进展的程度。
即使理解了基本概念和术语，这也不是在公园散步，更像是攀登珠穆朗玛峰。我用一些标注跟踪了我的进度，这些标注在下图中。
我在驼背鲸识别卡格尔比赛中的进步。图片由作者提供。
如你所见，我花了大约两周的时间才接近最佳公共内核的分数。这意味着我一直在工作并尝试新想法，但我在排行榜上的排名几乎没有变化，因为许多 kagglers 通常会提交最佳公开解决方案。我自己有时也这样做，但这次比赛不是这样。
在我的解决方案中影响较大的一篇文章是“为三重缺失的人重新鉴定辩护”。我觉得写得很好，很有说服力。以至于我决定继续前进，实现这个想法。随着训练的进行，这个想法和从最困难的例子中取样的想法对我的结果产生了很大的影响。随着我实施新的想法并调试我的代码，我能够在排行榜上逐渐上升，最终以 0.92988 的最终分数排在 2129 的第 57 位。离最高分 0.97309 还差得很远，但是，尽管如此，直到比赛的最后两周，我都没想到能达到 0.9。
总的来说，这是迄今为止我学到最多东西的比赛。事实证明，在了解基础知识之后， 3 个月的工作足以接近任何新的深度学习项目。即使这需要学习全新的概念。
Freesound 音频标签 2019
能够在嘈杂的环境中自动准确地识别声音是一项艰巨的挑战。在这场比赛中，kagglers 被要求开发一种算法，将一个或多个标签归属于一组 80 个类别的音频数据。
这场比赛对我来说很不一样。我习惯于在我的音乐项目中使用频谱图，因此我一开始就有很好的动机。我能够在一开始就登上排行榜的榜首。 这给了我更多动力继续工作并改进我的模型。事实上，这一策略非常成功，我得以在两个月的比赛中保持接近榜首的位置，并最终获得 880 分的第六名。当然，这不是一项容易的任务，竞争非常激烈，这在 Kaggle 很常见。在这次比赛中，我真切地感受到了接近巅峰的焦虑，每天都在为保持那个位置而奋斗 2 个月。比赛结束后，我好好休息了一下！
比赛结束后，我写了一个中等的故事来描述我的解决方案。你可以在下面的链接中找到它。
[## 多标签音频分类—2019 年 Freesound 音频标签第六名解决方案…
音频标记是用一个或多个标签或标记来标记音频片段的任务。在这篇文章中，我描述了我的…
现在让我们继续这个故事最重要的部分吧！
如何应对任何竞争
- 仔细阅读比赛和数据说明。有时，在创建良好的验证集时，您应该考虑有关训练和测试数据分割的重要细节。
- 创建一个新的内核并探索数据，查看几个样本，以获得关于数据的良好直觉，以及您将来可能面临的问题。
- 通常需要对数据进行预处理。在该步骤中，当改变数据时，务必小心。有时候有些信息隐藏在你意想不到的地方。
- 花点时间考虑验证集，确保训练集和验证集之间没有信息泄露。稍后，随着您在排行榜中的进步，将验证结果与排行榜中的结果进行比较。如果它们相关性很好，这是一个好的迹象，表明你有一个好的验证集。
- 首先训练一个基线模型。使用验证结果来做决定，并且避免过分依赖公开排行榜分数——否则，当最终分数公布时，你可能会有一个不愉快的惊喜。
- 一旦你有了基线和稳定的验证集，你就可以开始改进了。如果您资源有限，请尝试从较小的图像(以防图像竞赛)或训练数据的子样本开始。这将节省你的时间，让你做更多的实验——增加你找到对你正在处理的特定问题最有效的技巧的机会。
- 总是阅读讨论以确保你不会错过其他竞争者分享的任何重要观点。
- 如果你被卡住了，搜索最新的科学论文寻找新的想法。最终，小小的改进很容易成为银牌或成功解决方案的区别。
- 总是看模型预测。很容易只看验证和排行榜分数而忽略理解。相反，找到模型性能较差的样本。看数据。试着理解为什么这个模型在这样的任务中失败了。如果你找到了原因，你就成功解决了问题。
- 如果一个模型是好的，那么两个更好。集合几个模型是大多数 Kaggle 比赛中必不可少的一步。集合可以包含交叉验证折叠和/或几个模型。在核心竞赛中，时间限制不允许集合中有无限数量的模型。尽管如此，请确保优化您的推理代码，以使用尽可能多的模型。即使单个模特和组合在公共排行榜上的分数相似，通常组合在最终分数上的表现会更好。
如果你将所有这些想法与在几个比赛中工作的经验结合起来，你将准备好成功地面对任何深度学习问题。大多数时候这并不容易。这需要时间和努力。但是它会让你获得好的结果和伟大的学习之旅。
如果你正在努力获得一枚个人金牌(比赛大师排名的要求)，尝试以下方法:选择一个更符合你个人兴趣的比赛，最好是研究比赛，并为此努力。通常，研究竞赛提出的问题需要新的想法和创造性思维。如果你理解了题目，你把工作时间放进去，你更有可能得到高分。在有数千人参加的更传统的比赛中，有时得分最高的队伍之间的差异几乎是残余的。位居前列可能需要一些运气。此外，要意识到你的约束。如果你有 GPU 的限制，选择一个小数据集的竞争，以确保你不处于劣势。
结束语
我希望你喜欢这个故事，并希望它能在你的旅行中帮助和激励你！我正打算写一系列关于使用 Pytorch 开始深度学习的故事，请考虑在这个链接 订阅我的 邮件列表，以防你不想错过任何未来的更新！
进一步阅读
[## 我的 3 年历程:从零 Python 到深度学习竞赛高手
自从 2017 年开始学习 Python 以来，我一直遵循的道路是成为一名独自参加 Kaggle 比赛的大师…
towardsdatascience.com](/my-3-year-journey-from-zero-python-to-deep-learning-competition-master-6605c188eec7) [## 不归路:在过去的 6 个月里使用 nbdev 改变了我在 Jupyter 中编码的方式…
有了 nbdev，Jupyter 笔记本现在是一个有文化的编程环境。有了 nbdev，我的生产力提高了。我的…
towardsdatascience.com](/the-point-of-no-return-using-nbdev-for-the-past-6-months-changed-the-way-i-code-in-jupyter-2c5b0e6d2c4a) [## 最后的倒计时:部署我的深度学习项目
在过去的两周里，我使用 Google can 平台和 Django 将我的深度学习项目转移到生产中，以构建…
towardsdatascience.com](/the-final-countdown-deploying-my-deep-learning-project-29bf970e320b)
感谢阅读！祝您愉快！
我的 3 年历程:从零 Python 到深度学习竞赛高手
自从 2017 年开始学习 Python 以来，我一直遵循的道路是在 2019 年年中成为一名 Kaggle 竞赛大师，并获得一枚单人金牌。一个激励你追求目标，永不放弃的故事。
在 Unsplash 上由 Mantas Hesthaven 拍摄的照片。
目录
- 为什么要开始？
- 学习 Python
- 学习实用深度学习
- 在卡格尔比赛
- 前进的道路
为什么要开始？
近年来，人们对深度学习和人工智能(AI)的兴趣呈指数级增长。这不仅是一个有望取得巨大进展的令人兴奋的话题，也是一个引起重大关注的话题。
好的一面是:
- 人工智能应用将允许自动化过程，否则将需要许多小时的重复劳动，否则在大规模上根本不可能。
- 人工智能将使汽车自动驾驶，并通过减少交通事故来拯救数百万人的生命。
- 人工智能将协助医生准确评估病人的病情。
- 艾将与艺术家一起创造新的艺术形式。
- 人工智能将帮助科学家在科学上取得新的进步。
这些只是让这个话题如此激动人心的应用的几个例子。然而，我们也需要意识到这些问题:
- 自动化会导致越来越多的人类工人失业。
- 使用人脸识别人工智能的大规模监控可能是对自由和民主的一大威胁。
- 人工智能可用于生成假新闻，包括视频和音频，有助于传播错误信息。
- 人工智能模型中的偏见会导致对少数群体的极化和歧视增加。
这些都是需要考虑的威胁的例子。对于其中一些问题，如人工智能模型中的偏见，生产和训练这些模型的数据科学家有评估和打击这种偏见的道德责任。
记住这些重要的考虑事项，让我们进入下一个主题——学习 Python。
学习 Python
2017 年初，我意识到如果我想进入深度学习，我需要先学习 Python。那时候我在大学里用 Matlab 做研究，那是我申请博士学位的前一年。我过渡到 Python 的策略是在我开始的每个新项目中使用 Python。
开始的时候，有点沮丧。我花了很多时间尝试用 Python 做一些我知道如何在 Matlab 中轻松完成的事情。但是几个月后，我开始用 Python 工作得更快，并意识到它的所有潜力。2017 年底，我已经不用 Matlab 了。
当人们问我如何开始使用 Python 时，我给出了同样适用于我的建议——在你开始的每个新项目中使用它。但是，如果你没有任何编程背景，找一些介绍用 Python 编程的在线课程大概会很有帮助。一如既往，熟能生巧。
一个非常重要的额外提示是看看其他人的代码或者征求对你的代码的反馈。通常，有几种方法可以对同一个流程进行编码，其中一种可能更简洁。使代码简洁明了将有助于你随着时间的推移提高生产力。
学习实用深度学习
我尝试了几门在线深度学习课程，比如 YouTube 上的 Nando de Freitas 课程和神经网络以及吴恩达的深度学习课程。这些都非常有趣，是一次很好的经历，但真正让我向前迈进了一大步的课程是 fast.ai 深度学习 for Coders 。这对我改变了游戏规则。自上而下的教学方法非常有助于快速入门并立即加入 Kaggle 竞赛。最重要的是，fastai library 提供了开箱即用的工具来解决几种类型的深度学习问题。您不会因为开箱即用的解决方案而赢得任何竞争，但它会让您起步。之后，将最新的想法整合到 fastai 设置中通常并不困难，特别是在 fastai 版本 2 中。
如果我今天开始学习深度学习，我会从 fastai 课程开始。然后，随着你对这些概念的深入理解，你可以搜索其他学习材料，这些材料可以给你更多的技术见解。它们很有帮助，但是你首先需要动力。尤其是如果你像我一样是自学的话，拥有开始做实验的实用知识是一个巨大的动力。稍后，当你深入了解这些概念时，你也会发现这些信息更有用，更容易理解，因为你已经有了实用的知识。
在卡格尔比赛
在 Kaggle 比赛对我来说是最好的学习方式。竞争精神以及与其他人讨论和分享想法是快速学习和提高的好方法。这并不容易。我记得当我第一次开始做 Kaggle 的时候，我真的不知道我在做什么。当我能够在比赛中获得我的第一枚铜牌(排行榜前 10%)时，感觉就像一个里程碑。这是在 2018 年底。2019 年初，我向前迈了一步，经过两个月的努力，在另一场比赛中获得了银牌(前 5%)。后来在 2019 年年中，我终于获得了一枚金牌(第 6 名)，并成为了一名 Kaggle 竞赛大师。
学习之旅并不轻松而且一帆风顺。在比赛中工作可能会令人沮丧，因为你经常花很长时间尝试新想法，但努力之后却没有任何效果。坚持是关键。如果你每天坚持不懈地尝试，你会发现什么样的技巧在特定的比赛中最有效。即使最终结果并不理想，最重要的还是学习。尝试新想法并评估结果的过程作为一种学习机制总是很好的，这将使你成为一名熟练的深度学习实践者。我喜欢认为在 Kaggle 中，真正的赢家是学得最多的人。
成为 Kaggle 竞赛大师后，我开始加入竞赛团队。与其他人讨论这些想法是很有收获的，团队成员可以学到很多东西。我也开始将深度学习应用到我的大学研究以及个人项目中。我发现致力于一个你想解决的问题是一种非常有趣的经历，而且通常这是你学到最多东西的方式。
从这个话题中得到的启示是，如果你是 Kaggle 的新手，向别人学习，不要担心你的分数。通常有一些不错的入门笔记本，它们可以成为很好的学习资源。但是，您应该尝试理解代码中发生了什么，以便可以改进它或将其应用于其他问题。
前进的道路
很难预测未来。谁会想到 2020 年我们会面对一个疫情？尽管如此，我相信随着技术的不断进步和新思想的不断涌现，深度学习将继续在社会中发挥越来越大的作用。对我来说，我想我会继续把更多的注意力放在个人项目上，如果我发现这些项目令人兴奋的话，最终会参加一些比赛。
从事个人项目是一条有趣的道路。你不仅会从事自己热爱的工作，还会创造出对他人有价值的独特东西。这可能会给你带来新的机会。
展望未来，我还会经常写作。我发现分享我正在研究的想法是跟踪我的进展和帮助其他人的项目的好方法。如果你从未尝试过写一个中型故事，那就试试吧！
结束语
我希望我的旅程可以激励你去追求一条相似的道路，如果那是你正在寻找的！深度学习是非常令人兴奋的，即使你不想成为深度学习的实践者，拥有一些关于它的知识现在非常重要，将来会更加重要。这样，当你阅读人脸检测和人工智能或任何其他有关人工智能的新闻时，你将能够更好地理解幕后发生的事情。这会让你对这件事有一个更明智的看法和意见。这很重要。无论是现在还是在可预见的未来，这都是一项极其重要的技能。
进一步阅读
我正在用 PyTorch 开始一个关于深度学习的系列！请随时关注我的 Twitter ，不要错过任何更新！
[## 我在 Kaggle 上的两年旅程:我如何成为竞赛大师
描述我的旅程和策略，我遵循成为一个竞赛大师与个人金牌
towardsdatascience.com](/my-2-year-journey-on-kaggle-how-i-became-a-competition-master-ef0f0955c35d)
感谢阅读！祝您愉快！
使用 TextBlob 的情感分析
使用 TextBlob 的情感分析及其工作原理！
你说的情绪是什么意思？
情感分析可以帮助我们解读大众的情绪和情感，并收集关于环境的深刻信息。情感分析是根据研究的需要分析数据并对其进行分类的过程。
这些情绪可以用来更好地理解各种事件及其造成的影响。L. Bing [1]强调，在研究文献中可以看到许多不同的名称，例如“情感分析、意见挖掘、意见提取、情感挖掘、主观性分析、情感分析、情感分析、评论挖掘”，然而它们都具有相似的目的，并且属于情感分析或意见挖掘的主题。通过分析这些情绪，我们可以发现人们喜欢什么，他们想要什么，他们主要关心什么。
使用 TextBlob 的情感分析
TextBlob 是一个用于自然语言处理(NLP)的 python 库。TextBlob 积极使用自然语言工具包(NLTK)来完成其任务。NLTK 是一个库，它提供了对大量词汇资源的简单访问，并允许用户进行分类、归类和许多其他任务。TextBlob 是一个简单的库，支持对文本数据的复杂分析和操作。
对于基于词汇的方法，一种情感是由其语义取向和句子中每个词的强度来定义的。这需要一个预定义的字典来对消极和积极的词进行分类。一般来说，一条短信会用一包单词来表示。在给所有的单词分配了单独的分数之后，最终的情感是通过一些汇集操作来计算的，比如取所有情感的平均值。
TextBlob 返回句子的极性和主观性。极性介于[-1，1]之间，-1 表示消极情绪，1 表示积极情绪。否定词颠倒极性。TextBlob 具有语义标签，有助于进行细粒度分析。比如——表情符号、感叹号、表情符号等。主观性介于[0，1]之间。主观性量化了文本中包含的个人观点和事实信息的数量。更高的主观性意味着文本包含个人观点而非事实信息。TextBlob 还有一个参数—强度。TextBlob 通过查看“强度”来计算主观性。强度决定了一个单词是否修饰下一个单词。对于英语来说，副词用作修饰语(“很好”)。
例如:我们计算了“我一点也不喜欢这个例子，它太无聊了”的极性和主观性。对于这个特殊的例子，极性= -1，主观性是 1，这是公平的。
然而，对于句子“这是一个有用的例子，但我更喜欢另一个”。它为主观性和极性都返回了 0.0，这不是我们期望的最好的答案。
如果您的句子不包含任何在 NLTK 训练集中具有极性的单词，或者因为 TextBlob 对每个样本中的所有单词使用加权平均情感得分，则如果库恰好返回 0.0，则可以预期。在我们的例子中，这很容易分散单词之间极性差异很大的句子的影响:“有用的”和“但是”。
大多数情况下，对于简单的情况，TextBlob 工作得很好。
使用 TextBlob 应用情感分析的步骤–
1.导入 textblob
from textblob import TextBlob
2.定义一个计算主观性、极性的函数，并根据您想要设置的阈值给它一个分数。
使用 TextBlob 和分析数据的代码片段
我碰到的另一篇有用的文章是:https://Neptune . ai/blog/情操分析-python-text blob-vs-Vader-vs-flair
参考文献—
- https://www . cs . UIC . edu/~ liub/FBS/sentiment analysis-and-opinion mining . pdf
- https://github.com/sloria/TextBlob/blob/dev/textblob/
智能合同简介
美国宇航局在 Unsplash 拍摄的照片
信任是好的，但是让我们使用区块链
让我们深入了解区块链是如何保持“信任”的:
- 什么是智能合同？
- 智能合同是如何工作的？
- V 星系统的特殊智能合约。
- 哈希时间锁契约
- 不可替代合同
- 支付渠道合同
- 各种智能合同之间的比较
什么是智能合同？
智能合同是一种自动执行的合同，买卖双方之间的协议条款直接写入代码行。该准则和其中包含的协议存在于一个分布式、分散的区块链网络中。代码控制执行，事务是可跟踪和不可逆的。
智能合同允许在不同的匿名方之间执行可信的交易和协议，而不需要中央权威机构、法律系统或外部执行机制。
智能合同如何工作
智能合约最早是由美国计算机科学家尼克·萨伯在 1994 年提出的，他在 1998 年发明了一种叫做“比特黄金”的虚拟货币，比比特币的发明整整早了 10 年。事实上，经常有传言说萨博是真正的中本聪，比特币的匿名发明者，对此他予以否认。
绍博
Szabo 将智能合同定义为执行合同条款的计算机化交易协议。他希望将电子交易方法的功能，如 POS(销售点)扩展到数字领域。
在他的论文中，Szabo 还建议执行一项合成资产合同，如衍生品和债券。Szabo 写道:“这些新的证券是通过多种方式将证券(如债券)和衍生品(期权和期货)结合起来形成的。由于对这些复杂的期限结构进行了计算机化分析，非常复杂的支付期限结构现在可以纳入标准化合约，并以低交易成本进行交易。”
智能合约示例 ft: V 系统
对于这篇特别的文章，我们将研究 V Systems 推出的智能合约，以了解智能合约中的各种新进展。
它是一个开源的区块链平台项目，最近在其版本 2.0 升级中实现了支付通道智能合约。该项目由首席建筑师 Sunny King 领导，他也是 POS(股份证明)的开发者。)
1.哈希时间锁定合同
哈希时间锁定合同(HTLCs)是 P2P 金融未来的基础构件。它们使我们能够建立原子互换和闪电网络——替代现有货币和金融体系的局限性。
资产锁定是区块链系统中的一项有用功能。锁定合同是一种工具，用于在用户定义的时间段内锁定资金，然后才能取回资金。
例子
Alice 将她的 VSYS 硬币或代币存放到链条上的锁契约中。使用“锁定”功能，她提交一个解锁时间戳。一旦设置了时间戳，她只能在解锁时间戳之后提取她的 VSYS 硬币或代币。在解锁时间戳之前，只能从令牌协定中调用存款触发器。在解锁时间戳之前，锁合同只接受押金。
V 系统锁定合同的特殊之处在于:
这个想法就像一个池过程，你可以随时增加池的大小和延长锁的时间。如果你愿意，它也可以被再次使用。
2.不可替代合同
什么是不可替换的令牌？
非同质化通证
不可替换的令牌包含记录在其智能合约中的识别信息。正是这些信息使得每个令牌都不同，因此它们不能被另一个令牌直接替换。它们不能互换，因为没有两个是一样的。相比之下，钞票可以简单地交换，如果它们是相同的价值，对持有者来说没有区别。
不可替换的代币是不可分割的，就像你不能把音乐会门票的一部分送给别人一样。演唱会门票的一部分本身没有任何价值，也不可兑换。
不可替代契约最显著的特征是不可替代令牌的最大值和单位总是 1。它只代表一个独特的不可分的东西。
当不可替换的令牌契约被初始化时，它的常数被设置为零，因为它还没有被发布，因此还不存在。当一个不可替换的令牌被发行后，它就开始存在，并且它的供应量永久固定为 1。这确保了您在契约中所做的每个操作的稳定性和安全性，也确保了令牌是可证明唯一的。
是什么让 NFTs 如此特别？
不可替换的令牌具有独特的属性，它们通常与特定资产相关联。它们可用于证明游戏皮肤等数字物品的所有权，直至实物资产的所有权。
其他代币是可替换的，就像硬币或纸币一样。可替换令牌是相同的，它们在交换时具有相同的属性和值。
在哪里使用它
不可替换的令牌用于创建可验证的唯一数字项目，并证明其所有权。不可替换的令牌允许在多个游戏或应用程序之间无缝地使用独特的资产。
例如，一把独特的剑可以用在十五个不同的游戏中。
比赛
如果游戏玩家在游戏中拥有独特的物品，游戏外所有权和可转让性的明确证明将增加他们物品的价值。游戏的创建者可以在公共区块链上使用不可替换的令牌来代表用户在游戏中拥有的物品，以增加物品在其生态系统中的价值。在公共区块链上证明不可替换代币的所有权是很容易的，这给了玩家额外的所有权保障。这样，不同游戏之间的物品交换也是可能的。
艺术和收藏品
独特物品的所有权和出处可以使用不可替换的令牌来证明。在一双独特的设计师鞋的情况下，制造商可以将仅绑定到那双鞋的不可替换令牌的所有权转让给买方。如果这些鞋子被买家出售，他们可以将代币的所有权转让给新的所有者。这增加了独特的鞋的价值，证明他们不是假冒的。
优惠券
一家公司可能希望分发优惠券，允许用户在唯一的条件下相互转让。不可替换的代币允许该公司发行任意数量的独特优惠券。
是什么让 V 系统的不可替换令牌如此特殊
零开发工作: V System 的不可替代令牌是唯一的、不可分割的令牌，可以通过零软件开发工作来创建。
不可替代代币的未来
- 主要地，不可替换的代币在游戏和加密收藏品中实现。对于游戏来说，不可替代的代币可以用来代表游戏中的物品，如皮肤，这可能允许它们被移植到新游戏或与其他玩家交易。
- 然而，它们的潜力要大得多，可能应用于版权和知识产权、票务以及视频游戏的销售和交易。
- 不可替代的令牌增加了创造安全令牌的潜力，这是数字和现实世界资产的令牌化。像房产这样的实物资产可以被标记为部分或共享所有权。如果这些安全令牌是不可替换的，那么资产所有权是完全可追踪和清晰的，即使只有代表部分所有权的令牌被出售。
- 不可替换令牌的进一步应用可以是资格认证、软件许可、担保，甚至是出生和死亡证明。不可替代令牌的智能合约不可改变地证明了接收者或所有者的身份，并且可以存储在数字钱包中，以便于访问和表示。有一天，我们的数字钱包可以包含我们拥有的每一个证书、许可证和资产的证明。
3.支付渠道合同
区块链创新发誓要鼓励安全、最小努力的通用支付处理服务(和不同的交易)，使用编码的分布式记录，对交易进行可信的实时确认，而不需要中间人，例如银行和清算所。
区块链支付面临的挑战
- 举例:比特币网络每秒处理 7 笔交易，以太坊每秒 15 笔交易，与 VISA 网络达到的每秒 1700 笔交易相比相形见绌。因此，可扩展性仍然是将加密货币用于零售和其他大规模应用的主要障碍。可伸缩性挑战的根源是底层共识协议的低效率:每个事务都必须经过完全共识才能得到确认，这可能需要几分钟到几小时。
解
在众多提高加密货币可扩展性的解决方案中，一个领先的方案依赖于支付渠道。支付通道是一种加密货币交易，它在区块链上保存货币，以便在预定的持续时间内与预先指定的用户进行交换。
- 示例: Alice 可以与 Bob 建立一个支付通道，在该通道中，她每月持有 10 个代币。现在，Alice 可以从托管帐户发送 Bob(只有 Bob)签名的交易，Bob 可以以安全的方式私下验证它们，而无需区块链的中介。如果 Bob 或 Alice 想要在任何时候关闭支付通道，他们可以向区块链广播最近签署的交易消息，以完成资金转移。
- 支付渠道的多功能性源于支付渠道网络(PCN ),其中不共享直接支付渠道的用户可以通过中介进行交易，只收取象征性的费用。
V 系统 :支付渠道
下面提到的几个重要变量存储在 V System 的合同中，这些变量定义了支付渠道功能的行为。
- 累计付款是发送方已经向接收方支付的累计金额。
- 到期时间戳是接收方不能再收款的时间戳，发送方可以将剩余资金卸载回自己。
- 累计负载是发送方加载到信道的累计量。
为了确保安全，这三个变量只能增加⬆️
- 由于累积的负载不能减少，接收者可以确信在信道中至少有一定量的资金，而不必经常检查合同的状态值。在渠道关闭之前，汇款人不可能从渠道中提取资金。
- 由于累计付款不可能减少，收款人可以提取他们已经收集的任何资金，而不必等待通道结束。
- V System 的实施允许发送者通过更新到期时间戳和将额外资金加载到通道中，即使在现有支付通道到期后也可以重新使用它们。
要了解 V 系统的更多信息，请访问此处的。
来源:[4]
支付渠道网络
来源:[4]
支付渠道网络是双向支付渠道的集合。如果 Alice 想要向 Bob 发送三个代币，她首先找到一个到 Bob 的路径，该路径可以支持三个支付代币。路径上的中间节点(Charlie)将把支付中继到它们的目的地。因此，发生了两个事务:Alice 到 Charlie，以及 Charlie 到 Bob。为了激励 Charlie 参与，他收到了一笔路费。为了防止他窃取资金，加密哈希锁确保所有中间交易只有在交易接收者知道 Alice 生成的私钥后才有效。一旦 Alice 准备好付款，她就在带外将密钥交给 Bob 他可以广播它(如果他决定关闭频道)或者把它传给查理。查理受到激励，将密钥向上游传递给爱丽丝，这样他也可以得到报酬。请注意，Charlie 与 Alice 和 Bob 的支付渠道是独立的:Charlie 不通过区块链就不能在他们之间转移资金。
参考文献:
- 美国运通
- 轴行区块链论文
- 支付方式下的高吞吐量
- 频道 走向 _ 比特币 _ 支付 _ 网络
- 五.系统文件
我们是可被黑客攻击的动物，区块链可以增加我们被黑客攻击的安全性。如果人工智能可以黑你，区块链可能会充当你的防火墙。
谢谢，希望你今天学到了新东西！
在 LinkedIn和 YouTube 上关注我。
[## 马尼克索尼-马尼克索尼- YouTube | LinkedIn
查看 Manik Soni 在全球最大的职业社区 LinkedIn 上的个人资料。Manik 有 8 个工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/maniksoni)
我的其他几篇文章:
你好星尘！今天我们将看到消失&爆炸梯度问题背后的数学原因，但首先让我们…
binarykeys.in](https://binarykeys.in/2020/07/vanishing-exploding-gradient-problem-math/) [## LSTM 细胞:用代码从零开始理解架构
LSTMs 是一种特殊的 rnn，具有处理长期依赖关系的能力。他们还提供解决方案…
binarykeys.in](https://binarykeys.in/2020/07/lstm-cell-architecture-scratch-code/)
我学习新数据科学概念的方法
快速有效地获取信息的框架
我在办公桌前学习新东西。出于法律原因:我拥有这张照片的权利。
学习数据科学有时很有挑战性。当你进展甚微或毫无进展时，很有可能会陷入学习的无底洞，感到被打败。这就是为什么有意识地学习新概念是有好处的。
在我的教育和职业生涯中，我不得不应对需要快速掌握新技能或学习新概念的情况。这帮助我想出了一个我至今仍在使用的系统。最近，我一直在学习一个叫做 BERT 的预训练 NLP 模型。感谢这次经历，我能够观察自己，看到我学习的道路。
这是我学习新概念、新想法、新解决方案的方法。
收集先决条件列表
学习一个新概念最大的问题之一就是很多时候你不知道自己不知道什么。反过来，它让学习任务变得不可能和令人畏惧。我发现完全投身于这个问题会让任务看起来更容易。有点像暴露疗法。
我做的第一件事是评估形势。我遗漏了多少信息？
为了解决这个问题，我找到了一些资源和内容，这些资源和内容讲述了我正在努力学习的具体事情。这些可以是 YouTube 上的文章、视频、讲座…任何东西都可以。
我会对他们进行第一遍检查，看看哪些部分我不理解，他们讲了哪些我不知道的技巧。我只是记下所有对我没有意义的东西。此时，我的目标还不是学习概念。我只是想了解一下这个新概念的情况。我做的笔记将包括或指出我学习这个概念的先决条件。
这是至关重要的一步，因为即使有很好的“初学者”和“傻瓜”类的内容，对他们来说，假设一些关于这个主题的基本知识也并不罕见。有了先决条件清单，你就能更好地控制局面。
这一步让你自觉或不知所措是非常自然的。看着看似无穷无尽的你还不知道的东西，会让学习任务看起来很庞大。但这不应该阻止你！它几乎总是比看上去的要好。很可能你列表中的许多概念是高度相关的。这意味着，当你试图学习概念 A 时，你也将学习和理解概念 B、C 和 d。当我学习新东西时，这种情况总是发生在我身上。
找到最适合你的资源
学习数据科学概念有很多选择。有很多人在网上创造关于一切数据科学的优质内容。首先决定，什么类型的内容有助于你更好地学习？有可能存在以下几种选择:
- 关于这个主题的已发表的论文
- 关于这个话题的博客文章
- 关于这个主题的大学讲座的录像
- YouTube 上有人解释这个话题的视频
当然不用只选一个。对我来说，当我从 YouTube 视频中获得高层次的理解，然后观看更深入的讲座时，效果最好。如果我觉得我需要更深入的知识，我会阅读关于这个主题的论文。这就引出了我的下一个观点
决定你想去多深
你应该有一个学习这个新事物的理由。这个具体的原因会帮助你调整你的学习努力。它会帮助你弄清楚该走多深，在哪里停下来。
我知道，当你刚刚开始学习数据科学时，可能很难找到一个可靠的理由。一种选择是想出一个你可以用这些技能的项目。也许是你作品集的一个项目？或者只是打算在某个项目中使用它们，你可以在途中想出这个项目。
如果这些对你不起作用，你可能需要使用你的意识技能来确保你不会在学习概念中不必要的部分时迷失。
所以你可能会:
- 想把这些新知识应用到一个项目中。然后你可能需要知道新算法的基本工作原理(假设它是一个算法)以及如何在实践中实现它。你不需要能够证明与这个概念相关的方程。你只需要使用它，并相信计算的人是正确的。
- 运用这一概念撰写学术论文。然后，你会希望充分了解一个新模型/算法或概念的缺陷和不足。报告研究结果需要你对一个概念的整体运作有更深的理解。
- 想要使用或维护其他人的代码，或者与一个更资深的人一起工作，他将完成大部分工作。那么，也许首先，你只需要在一个高层次上了解代码是如何工作的，以及它背后的一般逻辑，而不需要太多关于它背后的理论。
你自己决定，你想去多深？如果你不阻止自己，你几乎总是可以更深入。确保你有一个非常明确的停止点。不要迷失在学术论文、博客帖子和你在途中学到的有趣闪亮的东西中，它们会分散你对实际目标的注意力。
当然，有时有些与概念相关的东西只是很有趣，你想了解更多。我处理这种情况的基本方法是，当有类似的事情发生时，我会把它记在我的笔记应用程序上。当我有时间的时候，我总是能回去调查它。
查找图书馆、实施指南，了解 there
在你理解了这个理论之后，你还需要知道如何实现它，因为这是你最终想要做的。不缺少操作视频、博客帖子或教程文档。你只需要找到他们。为了找到它们，我的建议是无耻地谷歌一下。
当你刚开始时，很容易认为每个人都有一个固有的知识，知道如何使用每一个关于最新技术的新库。但事实并非如此。许多人在第一次开始使用一个新工具/框架/库时都会经历一个初学者阶段。这就是为什么网上有这么多教程和操作指南的原因。
我通过谷歌搜索“如何为 NER 任务实现 BERT”开始了这部分的学习。这让我意识到有一个 GitHub 资源库，由一家名为 Hugging Face 的公司提供，里面有很多教程和文档，非常有用。他们甚至有我可以立即开始使用的指南笔记本。因此，我的下一步是自己尝试代码，破坏东西并努力修复它们。
我的观点是，用你能想到的最好的查询开始寻找你想要的。它会把你带到某个地方，你挖掘得越深，你学到的就越多。你所做的每件事都将帮助你更好地学习实现。即使是令人沮丧的长达一小时的如何安装这个新库的搜索也会帮助您了解一些您不知道的关于这个库的新东西。
请记住，实现与学习理论是完全不同的技能。尽管你知道算法在理论上是如何工作的，但你可能会觉得你是从零开始。根据不同的库，它可能会让人感到难以理解。但是不要让它阻止你。学习实现的最好方法就是尝试。
正确的路线会带来很大的不同
当学习一个新概念时，更喜欢使用免费资源是正常的，但是一个结构良好的课程可以使你的学习发生最大的变化。就我的目的而言，我意识到我需要复习一下 rnn 是如何工作的，以及一般来说，序列到序列模型。我偶然发现了吴恩达在这方面的短期课程，我很高兴。它为我节省了很多试错和挫折的时间。
特别是如果你是一名忙碌的专业人士，正试图从当前的职业跳到数据科学，那么通过参加结构良好的课程来节省时间是非常值得的。
我发现初学者最大的问题之一是他们很难弄清楚他们所学的东西是如何组合在一起的。你可以在一篇博客文章中学习 ML 模型，在另一个 YouTube 视频中学习数据清理，但是将这些知识结合在一起并学习它们如何相互影响是完全不同的技能。
如果你也在纠结这个，我有一些好消息！我的新课程将是一个自始至终完全指导的数据科学项目构建器。我们将从零开始，从建立数据科学环境、构建项目和收集数据，直到模型培训、调整和准备好项目组合。请继续关注更新和特别发布折扣。
同时，保持轻松愉快的学习。感到失落和不知所措是很正常的。但是即使是最难学的东西也不是不可能的。如果你遵循这些步骤，你将能控制你的学习，并开始有效地取得进步。
👉对数据科学领域以及如何开始学习感到困惑？ 免费参加数据科学入门迷你课程 ！
我职业生涯中最大的错误，在数据科学领域
图片来源:维基共享。错误时有发生。在林肯纪念堂，一位艺术家不小心在应该是 f 的地方刻了一个 E。
一篇关于我在数据科学生涯中犯的最大错误的文章
介绍
在我的职业生涯中，不久前有人在工作中问了我一个问题。这个问题让我意识到我犯了一个巨大的错误。这个错误损害了我已经做了五年多的工作的声誉。
从广义上讲，这是我在攻读博士学位时就开始的工作，并在随后的两家雇主那里延续了下来。以下是对这种互动的基本真实的描述和对经验教训的解释。
问题是什么？
你认为我们什么时候能够开始使用机器学习、人工智能和预测建模？
版权所有 2020 亚当·罗斯·尼尔森 —保留所有权利。一位数据科学家在上班的第一天会见了公司首席执行官。首席执行官请求帮助预测哪些用户将进行购买。数据科学家马上开始工作。
当我的同事问我“你认为我们什么时候能够开始使用机器学习、人工智能和预测建模”时，我已经做了几个月了
我惊呆了。多年来，我们一直在使用机器学习、人工智能和预测建模。我不明白这个问题。
抛开我的困惑，我优雅地指出了我们在近两年前实施的一个著名项目。
我说，“你记得我们去年秋天做的那个项目吗？我们公司一半的人都在会议室呆到深夜？”
同事说:“当然！”这位同事补充道:“那真是太有趣了，我的团队现在还把它当作美好的回忆来谈论。我知道我们做出了巨大的改变。”
我说，“我也喜欢那个项目……事实证明，我们使用了预测模型来确定我们将邀请哪些客户参与那个项目。我们一直在使用预测模型。我们每天都在用！”
问题是
问题是，我的同事，也许是大多数，不知道我们正在(并且已经有很长一段时间)成功地实现机器学习、人工智能和预测建模，这些都是数据科学工作的核心方面。真实的故事，这个问题是我的错。
版权所有 2020 亚当·罗斯·纳尔逊 —保留所有权利。半自传体的故事。在这个故事中，一位首席执行官要求新的数据科学家预测哪些用户将进行购买。在用逻辑回归集成执行了那个任务之后，CEO 问道:“你试过机器学习吗？”
吸取的教训
这幅漫画中的数据科学家和我在数据科学职业生涯的早期，低估和错误描述了这项工作。逻辑回归是一种有监督的机器学习技术。使用集成(多个实施相关模型)也是预测分析中常用的技术。
我认为我避免使用“机器学习”、“人工智能”和“预测建模”等当代、术语、包罗万象、几乎毫无意义的术语是在帮自己和他人的忙。
我用我知道的更具体、更精确的术语和短语来代替包罗万象的流行语。这幅漫画中的数据科学家也犯了类似的错误。
无意中，由于没有明确地将逻辑回归的集合描述为受监督的机器学习算法，很少有人意识到这项工作是数据科学的应用。
如何避免这种错误
从这次经历中，我学到了，并且仍在学习，许多重要的经验。以下是其中的几个。
- 清晰地向他人表达你的努力。向他人清楚表达你的努力意味着花时间以尽可能多的交流方式交流你到底在做什么以及为什么。如果你幸运的话，老板或导师会帮助你，但是不要等待许可。动手吧！为了避免这种错误，找到并使用尽可能多的沟通方式(如面对面、一对一、小组、Slack、电子邮件、状态报告等)。).补充提示:找到你知道会被听到的交流方式。如果不确定，寻求帮助来确定贵公司最有效的模式。
- 言语很重要。在你发现他们的地方遇见他们。就我而言，我没能在同事们所在的地方见到他们，因为当他们期望听到“预测分析”时，我用“监督机器学习逻辑回归集成技术”击中了他们。我错误地认为这将是对我自己和其他人的一种恩惠，将作品去神秘化。我错了，我把工作搞复杂了。为了避免这种错误，在你开始谈论作品之前，先听听你的听众会认识的术语和短语的线索。使用你的听众会认识的术语和短语。带着关心和同情介绍新的术语和短语。
- 历史会重演。回顾我在成为数据科学家之前的工作(通常是作为一名教育工作者或大学管理人员),我发现我之前低估或错误描述了我的工作。这是任何行业的专业人士都会犯的错误——无论是技术性的还是其他的。为了避免这种错误，要从过去吸取教训，否则你将被迫重新经历。
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
adamrossnelson.medium.com](https://adamrossnelson.medium.com/membership)
结论
本文描述了我在数据科学职业生涯中犯的最大错误之一。有一次，一位同事问我“你认为我们什么时候能够开始使用机器学习、人工智能和预测建模”，我意识到自己犯了这个错误
那时，我们已经在那家公司使用机器学习、人工智能和预测建模很长时间了。
让我的同事认为数据科学仍然是一种渴望是错误的。我尽量避免使用术语、无所不包、几乎毫无意义的流行词汇，从而变得更加透明。但这一策略似乎适得其反。
在解释了这是如何发生的故事之后，本文还提供了一个可以从经验中吸取的教训列表。
我的老板和我花了两周时间痴迷地建立一个新冠肺炎数据中心
图片来源:gratisography.com
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
数据在哪里？
这一切都始于我试图回答一个本该简单的问题。
我住在旧金山湾区，这里是新冠肺炎疫情最严重的地区之一，也是这种病毒的早期震中之一。但我不住在圣克拉拉县，那是海湾地区早期曾有过一次巨浪的地方。我住在北边一点，在海湾对面的奥克兰。
因此，尽管圣克拉拉的新病例层出不穷，但我想知道奥克兰和阿拉米达县(奥克兰所在的县)是如何受到影响的。
像其他人一样，我的经历让我想知道在我的城市这种情况有多糟糕。我站在乔氏店里的一条队伍中，这条队伍从收银台绕过商店。我困惑地发现卫生纸成了新的抢手货。就像我的公司一样，我听说越来越多的朋友在家工作。但这仅仅是人们采取预防措施，还是表明情况变得有多糟糕？我需要数据。
我的第一站是每个人都去的地方，约翰霍普金斯仪表板。
这个仪表板在早期确实有地区/县级别的数据，但是在某个时候删除了它。这个仪表板设计得很好，但没有我想要的数据粒度来了解我的本地社区正在发生什么。无法进一步挖掘数据。我还想探索更多的数据可视化，而不仅仅是案例的数量。
我还尝试了纽约时报、世界卫生组织和 ESRI(ArcGIS 的开发者)制作的仪表盘。它们都没有真正给我我想要的数据的特异性。
幸运的是，就在这个时候，我的同事杰伊(Jay)突然给我发了一条短信(好吧，从技术上讲，他是我的老板，但我不擅长处理层级关系，所以我倾向于把每个人都当成合作者)。
"嘿，伙计，你有没有发现什么好的冠状病毒数据来源？"
原来他一直在做同样的搜索。他还对缺乏容易获得的新型冠状病毒数据感到沮丧。
为我们自己建造它
对杰伊和我来说，这篇文章开启了我们两周的构建和重建自己的仪表盘的工作，我们可以在仪表盘上找到任何可信的新冠肺炎信息。我们最初为自己构建它是为了帮助我们理解正在发生的事情，但随着事情的发展，我们不断添加越来越多的仪表板，最终决定我们应该公开分享它。
但是决定公开发布它带来了另一个挑战。我们一直在为自己建造这些。我们没有集中导航或干净的组织。见鬼，我们的大部分图表都缺少标题和轴标签——这会让我的研究生院顾问们畏缩不前。
我的研究生院顾问如果他们看到了早期的数据可视化仪表板(来源:knowyourmeme.com)
但是我们加倍努力，几个不眠之夜后，我们做出了一些值得骄傲的东西。
一些我们不会不好意思给人看的东西
你可以在这里查看最终结果:新冠肺炎数据中心
图片由作者提供。看仪表盘这里。
最终，我们发布了 10 个国家的仪表板，一个按邮政编码搜索的页面，这样人们就可以看到他们所在的地区，一个旧金山湾区的仪表板(我最喜欢的)，以及 10 个美国州的仪表板。
我们最近还增加了一个显示美国测试数据的仪表板，开放了 API，任何人都可以提取我们的数据，以及几个基于搜索的分析页面。
美国的测试地图。见测试仪表板这里(图片由作者提供)
我完全承认它仍然有一些部分需要一点设计和润色。但我很高兴能建立一些东西，希望能帮助人们在这场危机中获得可操作的信息。
我们也很乐意接受关于下一步要做什么的建议或请求。下图是一个新的仪表板，可以方便地比较不同国家的新冠肺炎增长曲线。我们建立它是为了回应人们希望能够监测哪些国家成功地使曲线变平的评论。如果有足够的需求，我们可能会为美国各州建立一个类似的。
这个仪表板的目标是让人们相对容易地看到哪些国家正在拉平曲线(图片由作者提供)
我们也在继续扩建。从我开始写这篇文章到今天，我们发布了一个新的动画形象，展示了新冠肺炎病例在各州的进展情况(见下文)。
作者视频。点击这里查看完整的/当前的新冠肺炎动画时间轴。
持续挑战
当前最大的挑战是数据访问不断变化。约翰·霍普金斯大学的数据集令人惊叹，我们非常感谢他们。也就是说，在过去的几周里，访问它的能力和方法已经发生了几次变化，这要求我们重新设计我们的数据中心。我们的理想是有一个清晰一致的 API 来提取数据。但希望我们的 API 也能为其他人所用。
当数据源改变它们的 API、数据格式或访问方式时，感觉如何。(来源:gratisography.com)
另一个巨大的挑战是获得与冠状病毒爆发相关的更丰富的数据集，以便我们可以创建更具可操作性的可视化和仪表板。在我们的列表中，一些最重要的是医院床位利用率、城市级数据以及与失业救济相关的预测。
我至少见过一个县获得市级数据的案例，但由于这些数据的来源，它可能在一段时间内对其他所有人都不可用。
天上掉馅饼:市一级数据
Contra Costa County 通过从 CalREDIE 手动抓取数据并将其手动放入他们的系统，完成了城市级数据的采集和发布。
对于那些不知道的人，CalREDIE 代表加州可报告疾病信息交换。这是一个由加州公共卫生部门主办的电子疾病报告和监测网站。
你看，有些疾病和情况是州法律强制要求医疗服务提供者和实验室报告的。当医疗服务提供者和实验室报告这些情况时，他们会进入 CalREDIE。新冠肺炎病例就是这样一种情况，所以理论上，加州所有的新冠肺炎病例都将进入加州医院。
问题是:目前，出于完全正当的隐私原因，CalREDIE 中的数据只能由当地卫生部门和加州公共卫生部门访问。没有用于数据匿名版本的 API。这就是为什么康特拉科斯塔县不得不手动收集数据，将其匿名，并将其放入他们的新冠肺炎门户网站。
面向新闻媒体、记者、记者和博客作者
一些新闻媒体已经建立了非常惊人的数据可视化。《旧金山纪事报》是一个页面，即使我们的数据中心已经启动，我仍然会定期访问。但是并不是所有的新闻媒体都有这种能力，即使他们的读者会从疫情数据中受益。如果你为一个需要可视化的组织工作，请联系我。您可以免费将我们的任何可视化添加到您的网站上。
我们的数据中心中的任何可视化都可以用 iframe 或一些 javascript 嵌入到另一个网站中，我很乐意帮助你设置。
我的顶点项目:探索多伦多，寻找开设印度餐馆的最佳地点
我第一次尝试数据科学项目
在 Unsplash 上由 mwangi gatheca 拍摄的照片
简介
尊敬的读者们，你们好，这是我第一次写博客，并把它发布出来让大众仔细阅读。我写这篇博客是作为我的 IBM 数据科学顶点课程的一部分。我的任务是提出一个假设的问题，并提出一个面向数据科学的解决方案，以发掘有意义的见解和结论性的结果。顾名思义，这里的任务是探索美丽的多伦多市，遍历其邻近地区，并最终提出几个有商业潜力的建议，以开设一家新的印度餐厅。
目标受众
在制定问题陈述时，我考虑到了个人在现实世界中可能面临的困境。因此，我想出了一个问题陈述，旨在为多伦多市的一家印度餐馆找到最佳地点。
这将为两种不同的受众群体服务。首先，这将有助于那些打算在酒店行业(如餐馆)开展新业务的人找到一个印度餐馆最少的地方。其次，这可以帮助游客根据他们的个人喜好选择地点(行政区)。例如，一个有很多餐馆的行政区或一个有很多游客可能感兴趣的公园的行政区。
数据集
以下项目所需的数据集来自三个不同的数据源。下面列出了三个数据源，
- 一个维基百科页面获取多伦多市的行政区和社区。
- 答。csv 文件来获取对应于每个邮政编码的纬度和经度。
- foursquare api 获取附近不同的公共场所。
维基百科页面包含了多伦多的邮政编码表，以及多伦多市的行政区和社区。的。csv 文件为我们提供了多伦多地区每个邮政编码的经度和纬度坐标。该数据是有益的，因为这些坐标随后与 four square api 一起使用，以给出每个街区中受欢迎的场所的列表。
这些数据是全面的，并产生了与多伦多市相关的有价值的见解，最终帮助我们挖掘出结论性的结果和观察。在项目开始时，数据源被认为是不干净的，需要密集的预处理，以便将其转换为能够处理机器学习算法和在其上实现的可视化操作的工作集。
表格形式的数据在进入项目的预处理阶段之前看起来是这样的。
不干净的数据集(图片作者
一旦使用数据预处理工具处理了从数据源获取的数据，它看起来就像下面给出的表格。
干净的数据集(图片作者
数据预处理
我执行的第一步是从维基百科页面抓取数据，包括所有的行政区和社区以及它们的邮政编码。我将它转换为数据框，因为在使用可视化技术进行分析时，它们是最好的数据结构。数据框仍由许多可视为缺失值的值组成，因为邮政编码未分配给任何区或邻域。当我们进入项目的后期阶段时，缺失的值会导致结果的差异。因此，我删除了所有缺少值的行。
第二步包括从. csv 文件导入数据。的。csv 文件由每个邮政编码的经度和纬度坐标组成。这个。csv 文件被导入到数据框中，以便于后期分析。随后，我合并了由区和邻域信息组成的数据框和由坐标值组成的数据框。合并是在邮政编码列上实现的，该列后来从最终的表中删除，因为它对进一步的分析没有任何用处。
数据分析
数据分析阶段包括两个重要的任务，为了得到问题陈述的答案，必须完成这两个任务。我们问题陈述的两个方面包括。
- 行政区分析。
- 根据所选地点附近印度餐馆的数量，寻找在多伦多市建立印度餐馆的最佳可能邻近地区，即(选择竞争最小的邻近地区)。
首先，我从区分析开始。为了获得特定行政区不同场馆所需的数据，我使用了 foursquare api。当客户端 id、客户端机密和 Foursquare api 的版本被传递时，foursquare api 被链接到我的代码。这意味着我与 foursquare api 建立了连接，我可以调用 foursquare api 来获取任何所需的场地信息，包括多伦多市的任何一个区。因为该项目是基于逐区分析的。我将最终的、干净的数据框分割成单独的数据集，其中每个表只包含一个区的数据。这是通过保留与我们感兴趣的行政区相关联的行来实现的。完成上述步骤后，我编写了一个函数，该函数将调用 four square api 并访问数据，如场馆名称、场馆类别、场馆纬度、场馆经度等，然后将这些数据与我们在上一步中提取的区表相结合。我还删除了区列，因为它对我们的分析没有必要，最后我根据它在数据集中出现的次数对场馆类别进行了分组。分组场馆类别的样本数据集如下所示。
包含场馆数量的数据集(图片由作者提供)
经过彻底的数据分析阶段后，我提出的数据框架被绘制到一个条形图上，以便于可视化和可读性。下图描绘了斯卡伯勒的条形图。
斯卡伯勒场馆数量条形图(图片由作者提供)
作为我顶点工程的下一步。我开始对整个多伦多市进行分析，目的是找到最适合开设印度餐馆的街区和行政区。解决此问题陈述所遵循的流程与行政区分析所遵循的流程相似。我们再次使用用于区分析的相同函数来调用 foursquare api。但是，我们没有传递根据各个区分开的数据帧，而是传递包含多伦多市所有区和社区信息的数据帧。这给了我们一个大的数据框架，其中包含了多伦多市几乎所有场馆的信息以及这些场馆的类别。然后，我们提取包含印度餐馆信息的行，并丢弃数据框中的其余条目，因为它们对我们没有用。我们现在手头的数据集是一个简洁的数据集，包含了对我们的项目很重要的信息。然后，我们创建一个新的数据框，其中包含每个行政区的印度餐馆数量。下图描述了数据框。
每个区的印度餐馆数量(图片作者
这些数据被绘制在一个条形图上，以便于理解，同时也能吸引阅读本文的读者的注意力。
一张柱状图展示了每个区的印度餐馆数量
此外，我还计划在多伦多地图上标出印度餐馆的位置。地图上将在餐馆的位置有一个标记，这表示附近有一家印度餐馆。此外，当一个人点击标记时，会弹出一个标签，描述附近印度餐馆的数量。这将通过查看地图为观众提供关于印度餐馆的位置的很好的想法，同时它将描述特定社区中印度餐馆的数量。打算开一家印度餐馆的人会避开有大量印度餐馆的地方，而会寻找竞争最小的地方。这可以通过查看地图和仔细研究印度餐馆的位置来实现。下面是描绘多伦多市印度餐馆位置的地图。
描绘多伦多市印度餐馆位置的多伦多地图(图片由作者提供)
结果
下面的表格为读者提供了在某个特定行政区可以找到的不同场馆类别的简要信息。该信息是从 four square api 返回的数据中检索的。
多伦多市行政区的整体分析(作者图片)
如果任何读者对详细的区分析感兴趣，或者对检查为每个区创建的各种条形图感兴趣，或者如果他们对检查为了描绘多伦多市的印度餐馆的位置而创建的地图感兴趣，他们可以通过我的 Github repo。
假设和考虑
在本项目过程中，考虑了一些假设和考虑因素，以帮助成功完成本项目。在浏览我的所有实现步骤时，下面给出的实例被考虑在内，并且在浏览过程步骤时应该牢记在心。
- 在区域分析阶段，foursquare api 调用期间传递的半径被认为是 500 米。
- 在项目的第二阶段，包括寻找建立印度餐馆的最佳地点，foursquare api 调用期间传递的半径被认为是 700 米。这种改变是必要的，因为采取较小的半径会导致错过一些街区。
- foursquare api 返回的结果可能每天都有变化，因此 foursquare api 返回的场地数量可能会略有变化。
- 在确定开设印度餐馆的最佳地点时，只考虑了一个因素，即防止在已经有相当多印度餐馆的社区开设印度餐馆(即寻找竞争最小的地点)。
- 两个区，密西沙加和皇后公园从我们的分析中被排除，因为在上述区搜索场地没有返回大量的结果。
结论
在这个顶点项目的过程中，我能够应用我在 IBM 数据科学课程中学到的不同的数据科学技术和工具。这帮助我从多伦多数据集的数据分析中挖掘出有意义的见解。下面列出了我在数据分析阶段发现的一些方面。
区域分析
- 咖啡店是一个几乎在所有行政区都有很高出现率的场所。
- 如果你是一名游客，密西沙加和皇后公园有很少的场地可以去或选择。
- 公园是下一个在不同行政区中出现最多的场所。
- 多伦多市中心有最多、最多样的场所供游客选择。
多伦多城市分析(建立一家新的印度餐馆)
- 东多伦多和中多伦多是印度餐馆数量最多的两个区。
- 印度集市、索恩克利夫公园和海滩西区是印度餐馆最多的街区。
- 北约克、皇后公园和密西沙加是开设一家新印度餐厅的理想地点，我们的理念是新业务在那里面临的竞争最小。
我从数据分析师到数据科学家的职业转变
我如何坚定不移地追求数据科学
6 个月前，我辞去了数据分析师的工作，去 Metis 数据科学训练营加速学习。3 个月的课程让我以结构化的方式学习，提高我的技术能力，并获得更多关于当今最新技术的专业经验。我实施了五个端到端 DS 项目，这些项目解决了业务挑战并提高了业务价值。其中一个包括一个端到端推荐系统，基于个人的 CLV 和产品评级，提供更有针对性的建议，改善用户体验，确保用户保留。
带着对数据科学高涨的热情，我踏上了作为 DS 的下一个职业旅程。然而，在新冠肺炎疫情寻找下一个机会充满了挑战和挫折。疫情的一个必然结果是不确定的商业环境，招聘冻结，裁员。然而，在这个不确定和困难的时期找工作给了我各种各样的教训。
1.事业是马拉松，不是短跑。
当我进入最后一轮招聘程序时，有一阵阵的兴奋和渴望，也有令人沮丧的拒绝。我没有对结果过于沮丧，而是不断提醒自己专注于过程，每天学习新的东西并应用它。毫无疑问，这并不容易实现，因为我注重结果的个性与缓慢而稳定的方法背道而驰。
2.这让我想到了我的第二课——视角转换。
当我因学习过程中的失败或疲惫而沮丧时，我会提醒自己采取另一种观点。例如，当被更有经验或更强领域知识的申请人取代时，我将这种挫折视为磨练自己技能、获得更多行业知识、为自己的正确工作做准备的机会，只是现在还看不到。
经过 70 多份申请、30 次面试、无数次带回家的作业和现场编码会议，我很荣幸也很感激成为戴尔客户体验团队的数据科学家，很高兴能与才华横溢的 DS 社区一起改善用户体验并确保留住人才。
3.没有家人、朋友和导师的大力支持，这个过程是不可能的。
我也非常感谢我的朋友们坚定不移的支持，以及导师们在此期间宝贵的指导和鼓励。在这个充满挑战和不确定的商业环境中，你的支持和建议帮助我坚持了下来。非常感谢我的朋友们，他们在我找工作的过程中友好地同意推荐我，我真的很感激你们的帮助。
4.当我开始作为一名数据科学家的旅程时，我也被提醒不要满足于现有的成就，要永远对知识充满渴望。
这个数据科学/人工智能行业每天都在快速发展，需要获取大量的新知识。为此，我试图通过参加深度学习课程，成为 AWS 认证，在我的兼职项目中应用最先进的自然语言处理(NLP)技术，如 BERT，来磨练我的技术能力，例如从用户的信息中识别用户的意图，以及从句子中提取最能描述其情感的关键短语。目前，我正在参加 Shopee 在亚洲最大的在线比赛( Shopee 代码联盟)，在比赛中，我应用了最新的计算机视觉技术将 Shopee 的产品图像分类到相应的类别，并应用无监督机器翻译将繁体中文产品标题翻译成英文，而没有使用并行数据。
我渴望发展我的技能组合，以释放数据的力量，让其他人能够做出基于数据的决策并将这些见解传达给他们，并努力成为一名全栈数据科学家，在其中为人们构建自动化和可扩展的应用程序！
有兴趣跟随我的旅程吗？请随时在 LinkedIn 上联系我，交流想法或进行非正式聊天。你也可以在这里查看我为其他数据科学项目撰写的文章:)保重，注意安全！
我对欧盟泄露的人工智能白皮书的评论
人工智能白皮书的“结构-欧洲方法”概述了欧盟人工智能的监管层，并提出了未来监管的几种选择。它在欧盟层面和更大范围内为人工智能制定了现有的政策框架；概述了为什么需要在整个欧洲推广人工智能；提议通过边缘计算更好地访问数据；并深入挖掘未来欧洲人工智能综合立法框架的关键要素；以治理的五个选项结束。
在通读了这篇论文的全部内容，并在日常工作中花了大量时间思考人工智能法规和道德的含义之后，我的评论集中在一些有趣的(令人困扰的？)部分，不深入每一节。我将重点讨论第 5 和第 6 部分，这是本白皮书的核心部分，因为其余大部分都是背景材料。在第 5B 节(欧盟人工智能立法框架)中，该文件讨论了当前立法框架的弱点:
- 基本权利范围的限制:《基本权利宪章》不适用于仅涉及私营部门的情况，并且排除了除获得就业、社会保护、教育、公共服务(住房)以外的权利。人工智能系统的含义远不止这些基本原理。
- 产品范围的限制:迄今为止，欧盟产品安全立法仅适用于将产品投放市场，不适用于基于人工智能的服务。随着新一波公司吹捧“人工智能即服务”，这将成为一个问题。
- 供应链中不同经济运营商之间责任划分的不确定性:根据目前的欧盟立法，人工智能软件现有产品(如自动驾驶汽车)不在覆盖范围内，只有产品才在覆盖范围内，即如果宝马的自动驾驶汽车使用中国的算法，这些汽车出现故障，只有宝马而不是算法开发商需要承担责任。
- 改变产品的性质:例如，如果你的身体机能发生变化，欧盟立法没有考虑动态调整电流的起搏器。它是为那些一旦投放市场就不会发生重大变化(软件升级或不断学习)的产品而设计的。
- 新风险的出现:目前的立法没有充分涵盖网络安全风险、因连接丢失而导致的故障、产品使用过程中的机器学习等。
- 与执行相关的困难:目前的法律没有涵盖提供自动决策的“黑箱”系统，在这种系统中因果关系难以证明，因此责任归属也很困难。
第 5E 节(可能的义务类型)概述了未来监管人工智能系统的可能的事前和事后要求。我的评论只集中在两个看起来有点问题和/或不完整的事前要求上。
作为维护开发人员(我在这里假设是指创建人工智能系统的组织，而不仅仅是编码人员)的问责制和透明度要求的一部分，提出的要求是“披露人工智能系统的设计参数、用于训练的数据集的元数据、进行的审计等。”——虽然这是一个很好的建议，但欧盟需要认真思考它将如何保护知识产权。公司围绕算法保密开展业务，就像制药公司围绕药物配方保密开展业务一样。也就是说，类似的知识产权原则可以应用于人工智能算法，就像应用于药物制造一样。
他们的另一个事前要求是对人工监督的要求，或者人工智能系统对自动决策的可能审查。虽然我原则上同意这一点，但人工智能系统将在我们生活中越来越复杂的领域(例如，人口健康)中实施，没有一个人，甚至一群人，可能能够提供无偏见的监督，除非他们知道人工智能系统为什么会做出这样的决定。然而，由于黑盒算法，知道这一点也不总是可能的，尽管有越来越多的工具使黑盒更容易解释。
欧盟提议的 5 个可能的监管选项都很弱:
- 自愿贴标签——这给人一种负责任行为的错觉，同时让可能的肇事者逍遥法外，或者制造一个打地鼠问题；
- 公共管理和面部识别的部门要求-首先，这不仅仅是面部识别(任何类型的生物识别、步态或运动分析、指纹或视网膜扫描、行为模式识别，所有这些都会带来类似的问题)，其次-这仅涵盖公共部门-我更关心的是私营部门对人工智能系统的使用。最后，它建议在欧盟制定规则的 3-5 年内禁止面部识别等技术——这肯定是一个笑话:世界将在 3-5 年内进步光年(以人工智能为单位),此后，欧盟参与者不仅将在这些类型的技术上远远落后于世界，他们还将完全错过通过更快/现在参与开放和富有成效的讨论来改善监管的机会；
- 针对高风险应用的基于风险的强制性要求——这是最接近潜在解决方案的要求，但是，这为高风险行业和高风险要求留下了相当大的回旋余地(在这里可能会出现偏差)。也就是说，这似乎是 5 个选项中最明智的方法；
- 选项 4(安全和责任)和选项 5(治理)适用于上述所有三个选项，但不在此列表中——编写白皮书的团队在到达这一点时一定已经筋疲力尽了！
文件的结论是“委员会认为”将备选方案 3 与备选方案 4 和 5 结合起来是最好的。那太好了；然而，重要的是在每个现有的监管机构内建立一个部门，以雇用一批人工智能专家，他们能够判断人工智能系统的设计、开发和部署是否符合道德，如果不符合道德，他们可以明智地提供建议或执行决定。
从历史上看，欧盟在保护人权、尊严和尊重等基本原则的开创性法规方面一直非常进步。这通常需要激进的思想领导、大量的资源和对现状的改变。我认为现在是再次进行这种改革的时候了。监管人工智能系统并为其建立正确的治理需要的不是渐进式而是破坏性创新，我宁愿这种创新来自欧盟，而不是谷歌。
我的电脑显示“时间之轮”。
史诗奇幻系列丛书的自然语言处理。
塞德里克·范登堡在 Unsplash 上拍摄的照片
很久很久以前，在一个现在被称为 90 年代的时代，一场关于后《指环王》时代最佳史诗奇幻片头衔的大战正在进行。在一个角落里站着乔治·r·r·马丁(George R. R. Martin)，他的黑暗阴森系列电影《冰与火之歌》(A Song of Ice and Fire)，也就是现在更为人熟知的《权力的游戏》(Game of Thrones)。另一个挑战者是罗伯特·乔丹，他有自己的系列片《时间之轮》。今天，这个宏大的故事不为许多人所知，但当根据这些书改编的电视剧明年上映时，这种情况可能会改变。在写这篇文章的时候，电影正在拍摄中。
随着越来越多的关于拍摄这部新的奇幻剧的公告出来，我对这些书的热爱也被重新点燃了。因此，当我选择我的下一个项目作为 Metis 数据科学训练营的一部分时，我决定让我的计算机作为自然语言处理(NLP)项目来“阅读”这个系列。
那些书
《时间之轮》是一个庞大的故事，跨越 15 本书，共 704 章，多达 440 万字。它以大量的角色和地点为特色，并从 147 个独特的角色的角度讲述，一些角色比另一些角色对故事更重要。故事从一个小村庄开始，以一群人物为中心，从那里开始变得越来越庞大和复杂。它包含了一个丰富详细的世界，充满了文化、魔法和政治。正如在史诗般的幻想中常见的那样，中心主题是光明与黑暗、善与恶之间的古老战争，随着时间的车轮旋转，这场战争一次又一次地进行。
《时间之轮》是一个庞大的故事，跨越 15 本书，共 704 章，多达 440 万字。
不幸的是，罗伯特·乔丹在完成他一生的工作之前就去世了，但他留下了大量的笔记，甚至完成了未来章节的部分内容。他的妻子兼编辑哈丽雅特选择布兰登·桑德森利用现有的材料完成这本书，最终的书于 2013 年 1 月出版。
方法学
在开始实际分析之前，我必须确保能够访问 Python 中的全文。我购买了捆绑系列的电子书版本(ISBN 9780765376862 ),并使用 EBooklib 库来访问 XML 格式的书籍，我使用 BeautifulSoup 解析了这些书籍。令人惊讶的是，这是我的项目中最具挑战性的一步，因为这本电子书是多本书的集合。有几本书的格式与其他书不同，所以我不得不设置例外和规则，以自己的方式解析和提取它们。
这是一个无人监督的学习项目，所以我主要关注主题建模，看看计算机是否能够理解这一大堆文本。我尝试了多种技术来查看不同建模方法可以得出的结果。您可以在我的 Github 这里找到我的完整代码和结果，包括每个被丢弃选项的注释，但是对于本文，可以说我最终的模型使用了 TF-IDF 矢量器和非负矩阵分解。我有一种感觉，我需要使用二元语法来捕捉书中许多虚构的名字和地点，但这被证明是不必要的，并且根本没有提高我的主题建模的质量。
当我尝试上面提到的不同模型时，突破时刻是从标准计数矢量器切换到 TF-IDF。当我尝试的时候，话题开始与我的书本知识相吻合。
结果
我的主题建模的结果比我开始项目时所希望的要清晰。最终的模型非常清晰地区分了 14 本书中的角色弧线。我把最终的主题数量限制在 15 个，除了一个以外，所有的主题都有一个中心人物的名字(或阿朵的人物)作为最重要的特征。增加主题的数量仍然会产生合理的新主题，但情节和人物的重要性会降低。一个不围绕角色的主题围绕着最后一场战斗，这是如此的不同和关键，以至于它有自己的主题是有意义的。
最终的模型非常清晰地区分了 14 本书中的角色弧线
这些角色弧线定义得如此清晰，使得在整本书和整个系列中追踪它们成为可能。我创建了一个热图可视化，显示了 15 个主题以及它们在书中出现的位置。x 轴是章节号，y 轴是主题，红线是不同的书，颜色的强度标志着一章与主题的紧密程度。
贯穿整个《时间之轮》系列的主题热图
对于那些不熟悉这些书的人，我将用一个例子来说明这个结果有多准确。这个系列的一个非常重要的角色是莫伊瑞恩，她在两个主题中出现，与她最强的两个盟友，斯万和兰一起出现。事实上，她是如此重要，以至于在《时间之轮》的中途，她有了自己的前传来探索她的背景故事。这本书是上面热图中的第一本书，你可以看出视觉完全集中在这本书的两个主题上。
类似上面例子的结果很多。我一直在为这个最终模型寻找有趣的应用。我从书迷网站上收集了书籍摘要，并将它们与单本书的热图进行了比较，比如下图中《冬天的心》一书的热图。结果匹配得非常好，就像 Mat 和 Tuon 的角色弧线有重叠的章节。剧透:这两个人在这本书中相遇后最终结婚了。
然后我拿了 Goodreads 上系列评分最低的那本书(第十本书:暮光之城的十字路口)分别对它的主题建模。结果显示了这本书过于政治化的情节，以及粉丝们所熟知的厄运情节。一个特别的情节被拖得太长，而且有一些奇怪的角色行为。我可以举更多的例子，但是你应该明白。
我进行的最后一项测试是为了真正检验这个模型，看看它与人类对书籍的解读相比如何。出版商的网站上有一个名为时间之轮重读的长期系列。它以作者和超级粉丝 Leigh Butler 对每一章的深入总结以及附加的解释和分析为特色。我从网站上搜集了每一章的摘要，在我的模型中运行，发现 86%的章节都有主题匹配。许多无与伦比的也是千钧一发，然而…
限制
除了模型表现之外，与重读的比较显示了一些局限性。随着模型在整个系列上被训练，主题是非常高的水平。一些被重读的摘要所强调的真正关键的时刻没有被计算机提取出来，因为它们可能没有占用该章的许多单词。计算机也没有办法在一个角色弧线内模拟节奏、剧情分辨率或支线剧情，就像前面提到的《毁灭战士》的情节主线。
作为一个热情的读者，我很高兴知道自己仍然有很好的理由去读这些书。作为一名数据科学家，我很高兴我的模型产生了如此有趣的结果。我喜欢用我所获得的数据科学技能，以一种不同的方式钻研我最喜欢的系列丛书之一。我强烈建议任何想在自己最喜欢的书上尝试同样的实验的人，看看我的代码，从中获得一些乐趣。
我的数据科学实习经历
我作为数据科学实习生的三个月经历
在 Unsplash 上由 averie woodard 拍摄的照片
介绍
当我第一次开始我的数据科学实习时，我并不知道我会让自己陷入什么样的境地。
在那之前，我只从事过个人项目，我对工作环境、我必须处理的数据以及我必须使用的工具一点都不熟悉。有人告诉我，这个职位需要很强的 Python 和 SQL 技能，于是我花了几周时间温习我的编程和查询技能。我甚至参加了 Udacity 的免费课程(SQL for Data Analytics)来复习语法和某些重要的概念。
在本文中，我将分解我三个月数据科学实习的经历，并告诉你我在这一过程中学到的一切。
入门指南
头几天，我开始熟悉工作环境、公司文化和我的团队成员。
我了解了我们将要使用的工具——AWS、Pyspark、Excel 和 Tableau。
就我个人而言，我在实习之前从未正确使用过这些工具。我的大部分数据科学和分析项目都围绕着 Python、熊猫和 Jupyter 笔记本。
然而，技术方面的学习曲线并不陡峭。 AWS 用于收集、存储和准备数据。
我以前从未使用过 Pyspark，但是它的语法似乎和 Pandas 库非常相似。Pyspark 也有类似于 Pyspark SQL 的外部库，允许您使用 SQL 查询来操作数据帧。
最后， Excel 用于进一步的数据操作和可视化， Tableau 用于数据可视化。
挑战
Jukan Tateisi 在 Unsplash 上拍摄的照片
我是这个团队的新成员，当我的大多数同事在家工作时，我加入了这个团队。这让我开始使用 AWS 有点困难，我在安装方面很吃力。
事实上，我花了大约三天的时间在我的笔记本电脑上安装好所有的程序，并让所有的东西都能工作。
如果我直接向正确的人寻求帮助，而不是花几个小时自己想办法让一切正常运转，这本来是可以避免的。
在我实习的头几天，我学到了最重要的一课——遇到困难时寻求帮助。
我们从事的项目
我在实习期间学到的另一件非常重要的事情是拥有强大的沟通技巧的重要性。
成为一只查询猴子并拥有强大的技术能力是不够的。重要的是要问这样的问题:
- 我要借助数据解决什么问题？
- 我如何将这些原始数据转化为对客户有用的见解？
- 我如何以客户易于理解的方式传达我的结果？
能够理解端到端的工作流非常重要，您应该能够将业务需求与您正在进行的分析联系起来。
如果他们不能理解您的仪表板，如果它不能让他们更接近解决他们的业务需求，没有人会真正关心您的仪表板有多漂亮。
下面是我们收到的一个日常客户请求的例子:
客户 A 销售巧克力。他们希望更好地了解他们的客户群，以便知道如何定位他们的公司，并针对不同的市场制作有针对性的广告。数据团队有责任提出详细的见解，帮助他们更好地了解客户。
我们做什么:
基于可用的客户数据，我们研究了客户客流量、人口统计数据和客户心理特征。然后我们提出见解，例如:
- 客户 A 通常一个月在 A 公司出现多次。但是，在过去的一个月中，他们经常光顾 A 公司的竞争对手 B 公司。这可能表明 A 公司的一名忠实客户正在流失到他们的竞争对手那里，这可以进一步调查。还可以观察和预测客户流失率。
- 消费者细分通常是这样完成的，根据他们的人口统计数据和行为将顾客分成不同的部分。
数据团队进行这种细分，我们得出对公司 A 有用的见解，以决定如何向不同的客户群做广告。
我们构建图表和可视化，并围绕我们从数据中获得的洞察力讲述一个故事。我们所做的工作将进一步建立在商业智能团队的基础上，他们翻译这些见解，并为公司 A 提出营销活动的想法。
一路上学到的经验教训
我在实习经历中学到了很多。事实上，我在过去三个月里学到的东西比我在大学里过去三年学到的还多。
组织技能
与您需要学习的其他东西相比，这听起来可能很小，但实际上非常重要，尤其是当您处理数据时。
我无法告诉你有多少次我从未将文件保存到正确的路径，而不得不重新运行整个分析。
时间管理技巧
我一边实习一边在大学学习。这意味着我不仅要处理客户的请求，还要完成大学的作业和测试。
我必须非常努力地保持学校和工作之间的平衡，并按时完成所有的最后期限。
领域知识
正如我上面提到的，作为一名数据科学家/分析师，业务领域知识非常重要。您的分析需要提供利益相关者或客户可以用来解决业务问题的见解。
商业领域的知识不一定是你需要阅读或学习的东西(尽管学习它肯定对你有用)。随着时间的推移，随着经验的积累，这是一项可以磨练的技能。
沟通技巧
最后，我认识到拥有良好沟通技巧的重要性。正如我之前提到的，如果没有人理解你的图表，他们不会在意它有多漂亮。
你需要有能力将你的发现分解给非技术和非数据人员。
这意味着你需要用简单易懂的方式来解释你的发现，甚至七岁的孩子也能理解。
就这些，感谢阅读！
我想以我的数据科学实习是一次不可思议的旅程来结束这篇文章。我有机会和一个有才华、有动力的团队一起工作，他们指引我前进的每一步。
不断学习——总有“一件事”要学。
我在微软的数据科学采访
我的微软数据科学实习职位面试之旅
微软是 2021 年夏天在我的大学雇佣实习生的软件公司之一。今年，这是微软首次为即将毕业的本科生提供数据科学实习机会。
微软设定的要求如下:-
- 学生的 CGPA 必须至少达到 8 分。
- 学生应该追求计算机科学或数学专业。
所有符合条件的学生都必须在微软职业网站上填写实习申请表，并附上简历。填写了申请表的学生会在 1-2 天内收到测试链接。
在线测试:
大约 60-70 名学生参加在 mettl 平台上进行的实习测试。测试持续时间为 1 小时。该测试由 62 道选择题组成，几乎触及了机器学习的方方面面。没有关于考试评分方案的信息。
在线测试的要点如下:
- 问题涉及各种主题，如线性回归、逻辑回归、SVM、决策树、随机森林、欠拟合、过拟合、偏差、方差、装袋、提升、聚类、推荐系统、PCA、LDA 和神经网络。有一些概率和统计的基本问题。
- 大多数问题是概念性的，如 SVM 的核函数或中心极限定理。
- 关于神经网络的问题较少，所以学生们应该精通传统的机器学习算法。
- 没有编码问题，也没有使用 sklearn 的算法的正确代码等问题。
我在 1 小时内完成了 62 个问题中的 50 个。
由于我对推荐系统和 LDA 算法了解不多，所以除了关于凸优化的问题(大约 2-3 个)之外，我无法回答这些问题。
微软没有公布测试的确切结果，但公布了 6 名学生入围面试的名单，包括我！
我有大约一天的时间准备面试，对数据科学面试一无所知。我接受了一些学长的帮助，修改了斯坦福 CS229 notes 的在线测试概念(大多是传统的机器学习算法)。除此之外，我还回顾了简历上关于项目的一切。
由于新冠肺炎，面试在微软团队平台上进行，每个候选人总共有 3 轮技术面试。
第一轮:
起初，面试官让我介绍我自己并谈谈我的兴趣，我谈到了我对计算机视觉的兴趣。
有人问了我以下问题
- 解释卷积层的工作原理并设计一个用于图像分类的 CNN？解释一下损失函数，正则化，和它所用的激活函数？
- 解释一下决策树算法？还有，用决策树解释一下 bagging 和 boosting 算法？解释 boosting 算法中使用的加权函数？
- 设计一个垃圾邮件分类系统？此外，解释用于评估的特征提取、算法和指标。
- 解释支持向量机(SVMs)的深入工作原理？此外，解释凸优化，核函数，什么是支持向量。
除了支持向量机的工作之外，我能够回答所有的问题，在支持向量机的工作中，我能够解释高达保证金和核函数，但不能解释凸优化部分。我通过在共享屏幕上演示算法来解释答案。
然后他问我是否有任何问题。然后，我询问了微软的一些数据科学用例。采访结束了。整个面试持续了大约 45 分钟。
三名学生进入了几个小时后举行的第二轮比赛。
我在第一轮和第二轮之间修改了 SVM。
第二轮:
这一轮与第一轮相似，但面试官问了大量 NLP(自然语言处理)问题。
这一轮同样从介绍我自己和我的兴趣开始。
有人问了我以下问题
- 偏倚和方差的区别是什么？
- 使用逻辑回归解释多类分类？此外，解释 softmax 激活，交叉熵损失，并写出相同的方程？
- 解释 rnn、gru 和 LSTMs 的工作原理？还有，解释一下每种网络的优缺点？还有，解释一下为什么基于 transformer 的模型比这些好？
- 解释获得手套嵌入的训练程序？
- 设计一个垃圾邮件分类系统？此外，解释用于评估的特征提取、算法和指标？
- 解释支持向量机(SVMs)的深入工作原理？还有，解释一下内核函数？当不同阶级之间没有线性界限时，SVM 是如何分类的？
- 应该使用哪种算法从搜索引擎查询中提取名词？并解释原因？
- 在线性回归中推导向前和向后传递的方程？
面试的大部分问题我都回答了，除了支持向量机涉及的数学方程。面试官似乎对我的大部分回答都很满意。我通过在共享屏幕上演示算法来解释答案。
然后她问我是否有任何问题。然后，我问了与第一轮相同的问题。整个面试持续了大约 45 分钟。
第三轮:
面试官没有数据科学背景，所以他问了我一些关于数据结构和算法的问题。但他提到这不会很难，因为面试是为了数据科学的角色。
面试从正式介绍开始，他照例让我介绍自己。
有人问了我以下问题
- 给定一个数组 A=[a1，a2，a3…an，b1，b2，b3…bn]，将该数组转换为数组 B=[a1，b1，a2，b2…..an，bn]仅使用 O(1)空间。
- 在前一个问题中，给定一个索引，数组 A，返回它在数组 b 中的索引。
- 您有一个由“N”个偶数元素和“N”个奇数元素组成的“2N”个元素的数组；使用最小数量的交换，确保偶数元素位于奇数索引处，奇数元素位于偶数索引处。
- 在前一个问题中，假设偶数元素的个数等于奇数元素的个数未给定，因此在使用最少数量的交换时验证相同，并且只在数组上进行一次迭代。
我无法正确回答第一个问题，所以面试官将其修改为第二个问题，我正确回答了第二个问题，并在共享屏幕中进行了编码。他似乎对第二个问题的答案感到满意。
然后他问了我第三个问题，我用两点技巧回答了这个问题，在向他解释后，我编写了解决方案。他似乎对答案很满意。
面试官随后将问题修改为第 4 个问题。我改变了循环，并在循环中添加了一些 if-else 语句。在讨论了一些解决方案会失败的边缘情况后，我修改了代码以适应边缘情况。面试官似乎对答案很满意。
然后他问我是否有任何问题，然后我问他关于微软的工作文化和他在公司做的工作。这之后，采访就结束了。整个面试用了 45 分钟。
关键要点:
- 理解算法背后的数学概念，而不是将其视为黑盒算法，这一点至关重要。
- 在简历中加入机器学习项目是一个巨大的加分点，因为其他所有候选人都必须解释他们的项目。彻底检查你的项目。
- 对 DSA 问题有一些像样的练习。这个过程中可能会涉及到一些 DSA 检查。我是六名候选人中唯一通过 DSA 检查的人。
- 阅读一些机器学习在行业中的使用案例，因为大多数数据科学面试都有这些类型的问题。
结论:
我对自己前两轮的表现非常自信，但对第三轮的表现有点不确定，因为我在数据结构和算法方面相当薄弱。
三天后，微软公布了实习职位结果，三名学生收到了 offer，而我就是其中之一！
2021 年 5 月至 2021 年 7 月，我将在微软印度公司的一个办公室实习。
如有任何问题，欢迎随时联系 领英 。
我在 Coursera 上的数据科学在线学习之旅
Coursera 上的课程和专业列表，让我开始了数据科学和机器学习之旅
凯勒·琼斯在 Unsplash 上拍摄的照片
介绍:我的背景
正是在 2016 年，我在完成机械工程学士学位后，立即开始了追求计算力学硕士学位的旅程。当时我的编程知识有限，更不知道什么是数据科学，什么是机器学习。
这件事发生在我硕士学习期间，当时我得到了一个经典的计算机视觉项目，我需要使用 Python、C++和 OpenCV 构建对象检测和对象跟踪算法。那个项目真的迫使我艰难地学习 Python 和 C++以及如何正确地编写干净的代码。
长话短说，后来我发现自己被计算机视觉领域迷住了，这使我着迷:我想成为一名计算机视觉工程师。
但在我阅读了所有空缺职位中计算机视觉工程师的职位要求后，厚望变成了灰尘:他们希望候选人了解机器学习和深度学习，特别是卷积神经网络(CNN)。
计算机视觉工程师常见职位描述
那时候我连机器学习是什么都不知道，更别说 CNN 了。虽然我的学习计划确实触及了编程、数学和统计领域，但我们从未谈论过机器学习。
经过一些研究，我发现如果你想了解 CNN，你需要先了解深度神经网络(DNN)的一般情况。如果你想了解 DNN，你需要先了解经典神经网络。想要了解神经网络，首先需要了解机器学习。如果你想从总体上了解机器学习，你需要首先了解数据科学的基础。
这就像一个电子游戏，我需要一步一步地向上，直到我到达我想要的主题。另外，我非常喜欢自下而上的方法，因此我决定先学习数据科学的基础知识。
当时的问题是:当我的学习计划不提供与它们相关的课程时，我如何才能了解所有这些知识？
我需要自学所有的课程。
那是我第一次知道 Coursera 的存在。
为什么是 Coursera 呢？
首先，我在这篇文章里并没有为 Coursera 背书的意思。我只是发现它们是我最好的在线学习平台，因为有很多来自知名机构的数据科学和机器学习课程。此外，您可以选择免费旁听课程，并且仍然可以访问学习资料。
最重要的是，如果你真的想追求专业化证书，与 Udacity Nanodegree 相比，它的总成本要便宜得多，尤其是如果你还是学生的话。
好了，说够了，让我们进入我的学习之路。
我的数据科学学习途径
我想我们都同意，万事开头难。和我想涉足数据科学的时候一样。我一直在问一个问题:我从哪里开始？
经过一番研究，我终于想出了我的在线学习课程，以下是我在 Coursera 上按时间顺序学习的课程或专业列表。
IBM 数据科学
我决定从非常基础的水平开始学习数据科学，因为我不想错过一些重要的概念。这就是为什么我决定将 IBM 数据科学作为我的第一个专业。
在学习这门课程之前，你不需要有任何关于数据科学、统计学、机器学习或编程的知识。这个专业的第一门课程字面上叫做‘什么是数据科学？’。我的意思是，你不会得到比这更基本的，对不对？
这个专业有 9 门课程。它从数据科学的概念和方法开始，然后深入研究 Python 和 SQL 的编程内容。接下来，它将向您介绍数据科学的核心内容——统计学、数据分析、数据可视化和机器学习。
完成本专业后，你不会成为数据科学专家，因为本专业不会非常详细地教授你每个主题。然而，它给了我一个非常好的数据科学概述，以及我接下来应该学习什么。
由于这个专业，我能够为我的数据科学和机器学习在线学习之旅创建一个路线图，如下所示:
- 结构化查询语言
- 统计数字
- 数据可视化
- 机器学习
- 深度学习
这将引导我进入下一个专业领域。
使用 SQL 进行现代大数据分析
这是 Cloudera 提供的一个专业，专注于利用 SQL 进行大数据分析。这个专业总共有 3 门课程。
众所周知，如今的数据量太大，无法存储在传统的数据库管理系统中，因此在分布式集群中处理数据的知识和实践经验非常重要。这门课会教你这一点。
我真正喜欢这个专业的是它的实践性。借助 Cloudera 的虚拟机，我们有机会应用 SQL 查询来检索或存储 Apache Hive、Apache Impala、MySQL 或 PostgreSQL 中的数据。即使在完成专业化之后，您也可以随时重新访问虚拟机，因此您将始终能够修改您的 SQL 技能并处理数据。
如果您对 SQL 一无所知，请不要担心，因为这个专业将从基础开始教您。
借助谷歌云平台从数据到洞察
我参加这个课程是为了补充我在 Cloudera 之前的专业课程中学到的内容。虽然 Cloudera 的专业化更侧重于在分布式集群中应用 SQL，但这种专业化让我能够在云上应用 SQL。
这个专业将教你如何在 BigQuery 中检索或存储谷歌云平台(GCP)上的数据。您将可以使用 Google analytics 等 Google 公共数据集，并自己实现 SQL 查询。
除此之外，我喜欢这种专业化的原因是，您将学到的不仅仅是 SQL 和 BigQuery。您还将了解如何使用 Google Data Studio 创建交互式数据可视化仪表板，以及如何直接在 BigQuery 中创建简单的回归或分类机器学习模型。
在完成这个专业之后，我进一步学习了数据科学和机器学习背后最重要的概念之一，也就是统计学。
用 R 统计
我们同意统计学是数据科学的核心。因为我以前已经了解统计学，所以我选择了这个专业，期望更新统计学的基础理论。但最后，我得到的比我预期的要多。
专业化真正教会你所有你需要知道的关于统计学的知识，从关于概率的基础理论、推断统计学和从频率主义者和贝叶斯观点的回归理论开始。
这种专业化有两点是我喜欢的:
- 所有的期末项目都是有价值的，这意味着你需要做真正的统计数据分析工作，不要指望在一两个小时内完成。在你完成专业化后，你将有 3 或 4 个有价值的项目放在你的简历中。
- 每门课都需要用 R 来完成项目。这对我很好，因为我以前从未用过 R。我认为学习一门新的编程语言从长远来看是有益的，R 无疑是一个很好的数据科学和统计工具箱，可以添加到你的技能组合中。
完成专业学习后，我觉得我想更深入地研究贝叶斯统计，尤其是马尔可夫链蒙特卡罗。这就是为什么我在这个专业毕业后又上了一门关于统计学的课程，那就是…
贝叶斯统计:技术和模型
如果你想全面了解贝叶斯统计的概念，我认为这将是适合你的课程。在本课程中，您将学习关于马尔可夫链蒙特卡罗的概念，以及如何用贝叶斯概念解决回归问题。
我真正喜欢这门课的是理论和实践之间的平衡。
对于每一个材料，首先会涉及到理论，然后会有一个演示，在这个演示中，讲师会向你展示如何用代码实现你刚刚学到的理论。在本课程中，您将学习如何在 R 和 JAGS 中实现贝叶斯统计。
本课程的期末专题也是有价值的，与上面 R 专业的统计学非常相似。你将被要求在 r 中用贝叶斯概念做统计分析工作。
结束课程后，我决定继续下一个主题，即数据可视化。
带 Tableau 的数据可视化
在可视化数据方面，我通常会使用 Python，或者借助 Matplotlib、Seaborn 或 Plotly。然而，我想学习一些新的东西——我想学习如何使用商业智能工具可视化数据，无论是使用 PowerBI 还是 Tableau。然后我就发现了这个专精。
如果您不熟悉 Tableau，并且想学习用它来可视化数据，我会推荐这个专门化。
这个专业有 5 门课程，包括一个顶点项目。前三门课程将为您提供数据可视化最佳实践的理论理解，以及如何用您的数据讲述故事。第四个课程基本上是您接触 Tableau 的地方，因为您将学习如何使用 Tableau 创建交互式数据可视化仪表板和故事。
我真正喜欢这个专业的是，当你注册了这个专业，你将获得 6 个月的 Tableau 桌面免费使用权。
这意味着您可以在本地机器上探索 Tableau 的许多功能，并用它创建许多有趣的可视化效果。如果许可证在 6 个月后过期，你将有机会再延长 6 个月。
机器学习
至此，我已经了解了数据科学概述、使用 SQL 的大数据分析、统计学和数据可视化最佳实践。接下来，终于到了我学习机器学习的时候了。
作为一个完全的机器学习初学者，我决定参加吴恩达的机器学习课程，因为我知道这个课程是 Coursera 上关于机器学习的最知名的课程。
这是完全正当的。我相信我找不到比这更好的初学者机器学习课程了。
本课程将向您介绍经典的监督和非监督机器学习算法的概念，如线性回归、逻辑回归、SVM、K 均值聚类以及人工神经网络。不仅如此，安德鲁还为我们提供了在实践中应用机器学习系统的技巧和诀窍。
基本上，我喜欢这门课的一切。
我喜欢吴恩达在教我们不同类型的机器学习算法时的热情。我喜欢他向我们解释和简化困难的机器学习概念是多么容易。我也喜欢这个编程作业，以及我们如何有机会从头开始实现神经网络算法。
如果你是机器学习的新手，对我来说，这是你应该开始学习的最好课程。
深度学习
最后，我越来越接近我的最初目标——学习卷积神经网络的概念。
我仍然记得当我发现吴恩达是这个深度学习专业的老师时，我是多么兴奋。在我完成机器学习课程后，选择这个专业对我来说并不是一个困难的决定。
专业化是非常好的结构。第一门课将在你学习了之前机器学习课程中的经典神经网络之后，教你深度神经网络的概念。接下来，它给出了卷积神经网络和序列模型的重要概念。
吴恩达一如既往地在教授深度学习算法的困难概念方面表现完美。编程作业很有趣，这让你可以用 TensorFlow 实现各种深度学习算法，tensor flow 是目前业界最常用的深度学习框架之一。
然而，这个专业中的大多数编程任务仍然在 TensorFlow 1 中实现，而 tensor flow 1 现在已经过时了。
深度学习。AI TensorFlow 开发者职业证书
我相信这个专精在 DeepLearning 之前在实践中叫做tensor flow。AI 更名为 TensorFlow 开发者职业证书。
无论如何，我在完成深度学习专业化后直接选择这个专业化的主要原因是，我想学习如何为各种深度学习算法实现 TensorFlow 2。这种专业化完全实现了这一点。
这个专业化是一个纯粹的动手练习。你在里面找不到任何关于深度学习的理论，因为它的重点是借助 TensorFlow 实现深度学习算法。因此，建议您在参加本专业之前已经了解深度学习的概念。
它为您提供了关于如何为图像分类、情感分析、诗歌生成和时间序列预测构建深度学习模型的实践经验。
作为奖励，如果你将来想参加 TensorFlow 开发者证书，这个专业也将是你准备它的最好来源。我最近参加了认证，我可以说这个专业是最好的准备来源。如果你对我参加认证的经历感兴趣，你可以在下面的链接中阅读。
我参加考试的总体经历，我是如何准备的，如果我必须参加考试，我会做些什么…
towardsdatascience.com](/my-story-of-taking-the-tensorflow-developer-certification-exam-85d4fb777cbb)
结束语
我假设你已经知道，单独参加数据科学和机器学习课程不足以实现你的目标，无论是获得一份数据科学工作还是掌握某些数据科学概念。和我一样，上过 CNN 相关的课程并不代表我已经掌握了。
这些课程为你提供了你感兴趣的任何主题的基础知识。参加课程只是一个起点，接下来会发生什么完全取决于你。
将你从课程中学到的知识运用到实践中，真正巩固你的新技能。在参加这些课程的同时或之后，做一些自己喜欢的项目，将代码上传到 GitHub 上，并通过博客将项目或学习材料分享给其他人。
祝您的数据科学学习之旅一切顺利！
“我的数据科学家不知道如何正确启动 EC2 实例”。
VPC、子网或互联网网关是指任何 AWS 设置的核心组件。然而，数据科学家通常认为它是为他们配置的。让我们介绍一下最重要的概念，并清楚地了解它们的作用。
在我之前的文章中，我们为弹性和数据密集型应用建立了一个云基础设施，如下图所示。如果您对 AWS 区域、AZs 或高可用性区域没有很好的了解，我推荐您阅读这篇文章。
我们上一篇文章中的云架构示例
让我们用这个例子来解释底层的网络和安全概念。请随意访问 AWS 控制台，启动我们提供的资源(大多数都是免费的)。阅读完本文后，您将能够理解在设置 EC2 实例时您实际上在做什么。不仅如此，它还将使您能够配置其他 AWS 服务并将它们链接在一起。此外，各部分都是相当独立的，因此在需要时可以直接跳到概念。
I .隔离您的基础设施
- VPC
- 子网
二。实例和网络之间的通信
- 弹性网络接口
- 互联网网关
- 路由表
三。安全事项
- 安全组
- 氯化钠
我们开始吧！
隔离您的基础设施
首先，请记住，互联网从根本上说是一个巨大的网络，其中的节点由像您这样的服务器或计算机组成，由公共的互联网协议地址或 IP (如 104.16.122.127)标识。这些节点使用互联网协议套件 ( TCP/IP )相互通信。
在继续之前，请务必熟悉这些概念。
当在云中创建一个应用程序时，比如上面提到的，我们可以独占访问由云提供商创建的位于更大的公共网络中的网络。这被称为虚拟私有云 (VPC)，是首先要设置的。这是我们所有的 AWS 资源将在其中运行的网络。
在互联网这个庞大的网络中，你可以通过云提供商获得自己的私有网络。
VPC
默认情况下，VPC 最初会与任何其它网络隔离。它必须位于一个 AWS 区域中。然后，您需要选择一些 IP 地址，这些地址将用于标识在 VPC 中运行的实例。这必须在您开始构建基础设施时完成。例如，使用无类域间路由 ( CIDR )符号，您可以留出这些 IP 地址(或 CIDR 块)供将来使用:176.13.0.0/16。此语法指定了从 176.13.0.0 到 176.13.255.255 的所有 IP 地址。
为了确保这些地址不会与互联网上当前使用的公共 IP 地址重叠(例如像medium.com的地址)，你应该从 RFC1918 范围中选择它们。如果你想连接两者，也不应该与现有的 VPC 重叠！选择您的 IP 地址范围非常重要，因为一旦创建了 VPC，您将无法修改它。所以仔细想想吧！
请注意，我们在示例中使用了 IPv4 地址，类似的概念也适用于较新的(1998…) IPv6 地址。
子网络
现在还不是在我们刚刚创建的 VPC 中开始 EC2 实例的时候:我们需要另一个层。每个实例必须与一个子网相关联，这个子网只是 VPC 内部的一个逻辑子网。它是用 CIDR 块定义的，它必须是 VPC CIDR 块的子集。例如，我们可以使用 CIDR 地址块 176.13.0.0/24 在之前创建的 VPC 中定义一个子网。它确实是 176.13.0.0/16 的子集。
为什么我们需要这样的子网？云架构师在构建应用程序时要牢记三个主要原因:
- 将实例彼此隔离:一个公共子网可用于直接与互联网通信的 web 服务器，而一个私有子网可用于仅与 web 服务器通信。
- 控制实例间的流量:当你有一个分段的架构时，监控你的网络和防止攻击就变得更容易了。它还可以通过允许流量只到达某些子网来提高性能。
- 保持井然有序通过为每个子网分配特定的功能:一个子网可以专用于存储，例如 RDS 之类的服务。
最后但同样重要的是，您应该记住每个子网只能跨越一个可用区域 (AZ)。正如我们在上一篇文章中看到的，这意味着单个子网内的资源容易受到本地故障的影响(因为 AZ 对应于一个物理数据中心)。为了使您的应用程序具有高可用性(HA) ，您需要跨可用性区域复制子网，但仍然在同一个 VPC 内。
因此，让我们看看它在我们之前设计的应用程序中会是什么样子。
基本设置，单个 VPC 覆盖一个 IPv4 数据块和一个 IPv6 数据块，两个子网跨越两个 az。
我们现在有了一个合适的网络设置。现在，我们如何让我们的实例相互通信呢？
实例和网络之间的通信
弹性网络接口
弹性网络接口(ENI)使网络实例之间能够进行通信。因此，任何实例都必须至少有一个:它是您的实例和一个子网之间的链接。IP 地址实际上绑定到 ENI，而不是实例！
大多数时候，我们忽略这些 ENI，因为它们将单个实例链接到单个子网。因此，我们之前的架构实际上应该是这样的(为简单起见，仅查看一个 AZ):
IP 绑定到 ENIs，ENIs 反过来支持与实例的通信。
尽管如此，当一个实例出现故障时，Eni 对于重定向流量还是很有用的。考虑下面有两个实例的情况:
在实例失败的情况下，可以使用相同的 IP 地址，而使用不同的实例来完成处理工作。
如果实例 1 出现故障，其 ENI 可以作为辅助 ENI 连接到实例 2。从外部看，流量仍然到达同一个 IP 地址，但实际上是由幕后的另一个实例处理的。
现在我们可以在子网内进行通信，那么与互联网通信呢？
互联网网关
为此，我们使用互联网网关(IG)作为中间人，连接到子网。它将给出一个实例:
- 一个公共 IP 地址，不同于标识子网内实例的私有 IP 地址(因此实例可以有两个 IP——公共和私有！),
- 到互联网的连接以查询网络客户端，例如，
- 从互联网接收请求的能力
IG 与单个 VPC 相关联。你认出它是因为它在 AWS 上的 ID 以igw-xxx开头。
现在，请注意，我们从未提及实例之间、子网之间、实例和互联网之间的流量应该如何流动，等等。那就是路由表介入的地方。它将指定从您的实例到其他实例和外部世界的路线。
路由表
关于路由表，您应该记住的第一件事是它们链接到一个或多个子网。路由表描述了应该如何重定向来自子网实例的流量。就路线而言，我们指以下两件事:
- 以 CIDR 记法表示为 IP 地址的目的地
- 一个目标，这是一个 AWS 网络资源，如 IG、ENI、本地或 NAT 设备(继续阅读了解这是什么；)
起初，让我感到困惑的是，一条路线只有一个目的地。实际上是因为原点是与路由表相关联的整个子网。
同样令人困惑的是:目的地和目标有什么区别？目的地是您希望数据包(数据)最终到达的最终 IP 地址，而目标是数据包下一步应该到达的地方，以便更接近这个最终目的地。
有两条特别重要的路线，您几乎会一直看到:
- 本地路由允许来自一个子网的实例与 VPC 内不同子网的其他实例通信。
- 默认路由指向互联网网关，允许互联网访问与路由表相关联的子网。
在我们的应用中，我们通常可以为第一个子网配置下表:
----- Example of a Route table for a webserver ----
+-------------------------+------------------------+
| Destination | Target |
+-------------------------+------------------------+
| 2001:db8:1234:1a00::/56 | local |
| 0.0.0.0/0 | igw-0e533011g0frrd318 |
| ::/0 | igw-0e533011g0frrd318 |
+-------------------------+------------------------+
您可以看到，第一条路由将流量从我们创建的第一个子网重定向到第二个子网，第二个子网由 2001:db8🔢1a00::/56 定义。最后两行简单地创建了与我们的第一个子网的互联网连接，允许所有地址("0 . 0 . 0 . 0/0"IP v4 和"::/0"IPv6 中的【】指的是所有地址—公共地址和您的 VPC 内的地址)通过 IG 到达。由于这两条线，子网变成了公共子网。如果没有这些到互联网网关的连接，它将是一个私有子网。
让我们用这些新元素更新我们应用的云架构:
您可以看到上面的子网是公共的，而包含数据库的子网是私有的。请注意，私有子网仍然可以通过公共子网间接访问互联网。
如果现在您想以一种详细的方式控制流向您的实例的流量，该怎么办呢？比如哪个协议被允许到达你的实例，在哪个端口，等等。？
安全事项
主要通过在实例级使用安全组和在子网级使用网络访问控制列表 (NACL)来实现对到达基础设施的内容的细粒度控制。
安全组
安全组基本上是一个防火墙，它控制着与该安全组链接的实例之间的流量。这是通过指定入站和出站规则来实现的，由以下内容组成:
让我们以您想用作 web 服务器的 EC2 实例为例。在这种情况下，你会允许每个 IP 地址作为一个来源，因为你希望你的用户访问你的应用程序，对不对？在这种情况下，用于在互联网用户和实例之间建立连接的协议将是 TCP，而端口范围是 443，通常用于 HTTPS 数据传输。现在，您可能还想从远程终端控制您的实例来做一些维护工作。您将通过 SSH 从一个特定的源(例如在 197.52.101.10)完成这项工作。考虑到这一点，安全组的入站规则如下所示:
- Example of Security group Inbound rules -
+------------------+----------+------------+
| Source | Protocol | Port range |
+------------------+----------+------------+
| 0.0.0.0/0 | TCP | 443 |
| ::/0 | TCP | 443 |
| 197.52.101.10/32 | TCP | 443 |
+------------------+----------+------------+
请注意，默认情况下，所有外部通信都被拒绝。您需要明确地将将要与您的实例通信的源列入白名单。
另一方面，对于出站通信，默认情况下允许所有地址。这意味着您的默认出站规则如下所示:
Default Security Group's Outbound rules
+-------------+----------+------------+
| Destination | Protocol | Port range |
+-------------+----------+------------+
| 0.0.0.0/0 | TCP | 443 |
| ::/0 | TCP | 443 |
+-------------+----------+------------+
最后，关于安全组有一个重要的概念需要记住:据说它是有状态的。这意味着，如果在一个方向上允许一些流量，那么在相反的方向上也允许一些回复流量。这在与互联网客户端通信时很重要:我们的实例可能试图向 web 服务器发送一个包(像 GET 请求)并期待一个应答。我们的安全小组将允许答案通过。
当安全组在实例级控制流量时，另一个服务用于更方便地控制子网间的流量: NACL 。
氯化钠
网络访问控制列表在使用规则控制入站和出站流量的意义上类似于安全组。但是，一个 NACL 连接到一个子网，控制进出整个子网的流量。对于子网实例之间的流量，安全组是首选。
与担保集团类似，NACL 实施以下列要素为特征的规则:
- 规则号:一个整数，用于确定规则应用的顺序。首先应用较低的规则编号。
- 协议:与安全组相同的字段
- 端口范围:与安全组相同的字段
- 入站规则的源(或出站规则的目的地):与安全组的字段相同
- 动作:要么允许要么拒绝与的通信源或目的地
创建子网时，会附加一个默认 NACL，并且可以进一步修改。它的默认入站规则如下所示:
--------------- Default NACL Outbound rules -----------------
+-------------+-----------+------------+-----------+---------+
| Rule Number | Protocol | Port Range | Source | Action |
+-------------+-----------+------------+-----------+---------+
| 100 | All | All | 0.0.0.0/0 | Allow |
| * | All | All | 0.0.0.0/0 | Deny |
+-------------+-----------+------------+-----------+---------+
请注意，默认情况下允许所有入站流量，这与安全组不同！另请注意，最后一行带有星号作为规则编号:这是一个默认规则，不能修改或删除。它会拒绝先前规则未明确允许的任何流量。
NaCl 有一个特性会导致一些错误，因此值得记住:NaCl 是无状态的。这意味着它不会自动返回流量:您需要指定与允许通信发生的入站规则相对应的出站规则。或者你可以使用短暂的港口，但那是另外一个故事了！
NACLs 覆盖整个子网，而安全组在实例级运行(注意，DynamoDB 没有安全组，而是使用 IAM 角色……)
结论
我们讨论了正确启动 AWS 服务所需的基本概念。我们看到了如何根据实例的利用率将实例安排到子网中。我们还支持实例之间的通信以及与互联网的通信(IG，路由表)。最后，我们通过指定应该允许哪些流量到达我们的实例(安全组，NACL)来保护我们的基础设施。
接下来的步骤
请记住，这篇文章仅仅触及了理解云架构的皮毛。下一步，您可能会对 AWS UI 感兴趣，创建自己的免费资源(使用免费层服务)。然后，通过阅读文档或关注 AWS 定期推出的新服务，您可以了解许多微妙之处:
- 例如，在创建 VPC 之后，您仍然可以使用辅助 CIDR 块为 VPC 分配 IP 地址(正如这里所宣布的)。这是为了在您需要更多资源时随时进行扩展。
- 最好使用安全组来限制出站流量，因为随着更新，端口可能会改变，并且 NACLs 不允许对其进行动态改变。
- 您可以使用弹性 IP 地址独占访问和使用一系列公共 IP 地址。
- 只需将流量从私有子网重新路由到 NAT 设备
- 还有更多…
一如既往地感谢您的阅读，请不要犹豫给我提供反馈或意见，以提高我对这个主题的理解。
深度学习的不确定性。如何衡量？
使用 Keras 对认知和任意不确定性进行贝叶斯估计的实践教程。走向人工智能的社会接受。
我的深度学习模型说:“对不起，我不知道答案”。这完全没问题。
苏菲·玛德琳的绘画
动机
虽然深度学习技术有效，但大多数时候不清楚 为什么深度学习有效 。这使得在航空、司法和医学等高风险领域部署人工智能变得棘手。
神经网络识别细胞活检是癌性的——它不告诉为什么。
通常，分类器模型被迫在两个可能的结果之间做出决定，即使它没有任何线索。它刚刚抛了一枚硬币。在现实生活中，医疗诊断模型不仅要关心准确性，还要关心预测的可信度。如果不确定性太高，医生会在决策过程中考虑这一点。
深度学习模型应该能够说:“对不起，我不知道”。
从不够多样化的训练集中学习的自动驾驶汽车模型是另一个有趣的例子。如果汽车不确定路上哪里有行人，我们会希望它让司机来控制。
泛化能力更强的网络更难解释。可解释的网络不能很好地概括。(来源)
有些模型可能不需要解释，因为它们用于低风险应用中，如产品推荐系统。然而，将关键模型整合到我们的日常生活中需要可解释性，以增加人工智能的社会接受度。这是因为人们喜欢把信念、欲望、意图归于事物(来源)。
理解和解释神经网络不知道的东西对最终用户来说至关重要。从业者也寻求更好的可解释性来构建更健壮的模型，这些模型可以抵抗对抗性攻击。
图片由 Goodfellow 等人于 2015 年在 ICLR 拍摄。 解释和治理反面事例 。给熊猫的照片加一点噪点会导致不正确的分类为长臂猿。
在接下来的几节中，我们将更深入地了解不确定性的概念。我们还介绍了如何评估深度学习模型中的不确定性的简单技术。
不确定性的类型
深度学习中有两种主要的不确定性:认知不确定性和任意不确定性。这两个术语都不容易脱口而出。
认知不确定性描述了模型不知道什么，因为训练数据不合适。认知的不确定性是由于有限的数据和知识。给定足够的训练样本，认知不确定性将会降低。认知的不确定性可能出现在训练样本较少的领域。
随机不确定度是观测值的自然随机性产生的不确定度。即使提供了更多的数据，也不能减少任意的不确定性。当谈到测量误差时，我们称之为同方差不确定度，因为它对所有样本都是恒定的。依赖于输入数据的不确定性被称为异方差不确定性。
下图代表了一个真实的线性过程( y=x )，它是在 x=-2.5 和 x=2.5 附近采样的。
在线性回归环境中展示不同种类的不确定性(图片由 Michel Kana 提供)。
一个传感器故障在左侧云层中引入了噪音。底层过程的噪声测量导致左边云中的高随机不确定性。这种不确定性不能通过额外的测量来减少，因为传感器在设计时一直产生大约 x=-2.5 的误差。
高认知不确定性出现在很少或没有训练观察的区域。这是因为可以提出太多似是而非的模型参数来解释潜在的地面真实现象。这就是我们云的左、中、右三部分的情况。这里我们不确定哪个模型参数最能描述数据。给定空间中更多的数据，不确定性将会降低。在高风险应用中，识别这样的空间是很重要的。
如何使用 Dropout 获取不确定性
贝叶斯统计允许我们根据数据和我们对潜在现象的先验知识得出结论。一个关键区别是参数是分布而不是固定权重。
如果我们不学习模型的参数，而是学习它们的分布，我们将能够估计权重的不确定性。
我们怎样才能知道重量的分布呢？深度集成是一项强大的技术，在该技术中，大量模型或模型的多个副本在各自的数据集上进行训练，它们的结果预测共同构建预测分布。
因为集成可能需要大量的计算资源，所以提出了一种替代方法:丢弃作为模型集成的贝叶斯近似。这项技术是由亚林·加尔和邹斌·格拉马尼在他们的 2017 年论文中介绍的。
Dropout 是深度学习中一种常用的正则化方法，以避免过度拟合。它由随机抽样的网络节点组成，并在训练过程中将其删除。丢弃根据伯努利分布随机地将神经元清零。
一般来说，在贝叶斯模型中，正则化和先验分布之间似乎有很强的联系。辍学并不是唯一的例子。经常使用的 L2 正则化本质上是高斯先验。
在他们的论文中，亚林和邹斌表明，在每个权重层之前应用丢失的神经网络在数学上等价于高斯过程的贝叶斯近似。
图片由谭在 yuritan.nl 上提供——在不同的正向传递中，漏失改变了模型架构，从而允许贝叶斯近似。(授权引用的图片来自谭)
使用 droupout，每个未被删除的节点子集定义一个新网络。训练过程可以认为是同时训练 2^m 不同的模型，其中 m 是网络中的节点数。对于每一批，这些模型的随机抽样集被训练。
关键的想法是在培训和测试时都要退出。在测试时，论文建议重复预测几百次，随机剔除。所有预测的平均值就是估计值。对于不确定区间，我们简单计算预测的方差。这给了系综的不确定性。
预测认知不确定性
我们将使用通过向函数 y=x 添加正态分布噪声生成的数据来评估回归问题的认知不确定性，如下所示:
- 在 x=-2 和 x=-3 之间的左侧云中产生 100 个数据点
- 在 x=2 和 x=3 之间的右侧云中产生 100 个数据点。
- 噪声以比右云高 10 倍的方差被添加到左云。
下面我们设计两个简单的神经网络，一个没有漏失层，另一个在隐藏层之间有漏失层。在每个训练和推理批次期间，丢弃层随机禁用 5%的神经元。我们还包括 L2 正则化应用优化期间层参数的惩罚。
没有脱落层的网络
带有脱落层的布局
rmsprop 优化器用于通过最小化均方误差来训练 10 个点的批次。训练成绩如下所示。两种模型的收敛速度都非常快。有退出的模型表现出稍高的损失和更多的随机行为。这是因为网络的随机区域在训练期间被禁用，导致优化器跳过损失函数的局部最小值。
下面，我们展示了模型在测试数据上的表现。没有辍学的模型预测了一条完美的 R2 分数的直线。包括辍学导致了一条非线性预测线，R2 得分为 0.79。虽然漏失过度拟合较少，具有较高的偏差和降低的准确性，但它突出了没有训练样本的区域中预测的不确定性。预测线在这些区域具有较高的方差，这可用于计算认知不确定性。
在没有训练样本的区域中，具有漏失的模型表现出具有高方差的预测。这个性质被用来近似认知的不确定性。
下面，我们在测试数据集上评估两个模型(有和没有脱落)，同时在评估中使用脱落层数百次。这相当于模拟一个高斯过程。我们每次都从测试数据中获得每个输入标量的一系列输出值。这允许我们计算后验分布的标准偏差，并将其显示为认知不确定性的度量。
即使在没有训练样本的区域中，没有丢失的模型也没有 100%确定性地预测固定值。
在没有训练样本的地区，带有退出的模型估计了高认知不确定性。
正如预期的那样， x < -3 和 x > 3 的数据具有很高的认知不确定性，因为在这些点上没有可用的训练数据。
Dropout 允许模型说:“我对 x < -3 和 x > 3 的所有预测只是我的最佳猜测。”
图像由 OpenClipart-Vectors 在 Pixabay 上生成
多项式回归
在这一节中，我们研究如何通过更复杂的任务(如多项式回归)的退出来评估认知不确定性。
为此，我们生成一个从正弦函数中随机采样的合成训练数据集，并添加不同幅度的噪声。
下面的结果表明，包括辍学带来了一种方法，在没有数据的地区，甚至对于非线性数据，访问认知的不确定性。虽然遗漏会影响模型性能，但它清楚地表明，在没有足够训练样本的数据区域中，预测不太确定。
在没有训练数据的区域中进行预测时，没有辍学的模型会过度拟合训练样本并显示出过度自信。
辍学模型有较高的偏差，但在没有训练数据的地区不太可信。在训练样本缺失的情况下，认知的不确定性更高。
预测任意不确定性
认知的不确定性是模型的一个属性，而随机的不确定性是数据的一个属性。任意的不确定性抓住了我们对数据无法解释的信息的不确定性。
当随机不确定性为常数，不依赖于输入数据时，称为同方差不确定性，否则，使用术语异方差不确定性。
异方差不确定性取决于输入数据，因此可以作为模型输出进行预测。同方差不确定性可以作为任务相关的模型参数来估计。
学习异方差不确定性是通过用以下等式代替均方误差损失函数来完成的(来源):
该模型预测了均值 y ^和方差 σ 如果残差非常大，模型将倾向于预测较大的方差。对数项防止方差无限增大。下面提供了这个任意损失函数在 Python 中的实现。
任意损失可用于训练神经网络。下面，我们举例说明一个类似于上一节中用于认知不确定性的架构，有两个不同之处:
- 隐藏层之间没有脱落层，
- 输出是 2D 张量而不是 1D 张量。这允许网络不仅学习响应 y^ ，还学习方差 σ 。
学习到的损耗衰减迫使网络在训练过程中寻找最小化损耗的权重和方差，如下所示。
对任意不确定性的推断是在没有遗漏的情况下完成的。下面的结果证实了我们的预期:左侧数据的随机不确定性高于右侧数据。由于 x=-2.5 附近的传感器误差，左侧区域有噪声数据。添加更多的样本并不能解决问题。噪声仍将存在于该区域中。通过在损失函数中包括任意的不确定性，该模型将对落在训练样本有噪声的区域中的测试数据进行不太可信的预测。
具有丢失的模型检测具有噪声训练数据的区域。这有助于在这些区域预测更高的随机不确定性。
测量任意不确定性在计算机视觉中变得至关重要。图像中的这种不确定性可以归因于当相机不能透过物体看到时的遮挡。图像的过度曝光区域或某些视觉特征的缺乏也可能导致任意的不确定性。
认知的不确定性和任意的不确定性可以相加得到总的不确定性。在自动驾驶汽车的预测中包括总的不确定性水平可能非常有用。
剑桥大学 Alex Kendall 的图像，关于计算机视觉中语义分割的任意和认知不确定性。任意不确定性(d)捕捉由于遮挡或距离而导致标签有噪声的对象边界。认知不确定性(e)突出显示模型不熟悉图像特征的区域，例如中断的人行道。
结论
在这篇文章中，我们展示了如何在推理时间使用 Dropout 等同于使用贝叶斯近似来评估深度学习预测中的不确定性。
在商业环境中，了解一个模型对其预测有多有信心是很重要的。优步一直使用这种技术来评估时间序列预测中的不确定性。
在机器学习中适当地包含不确定性也可以帮助调试模型，使它们在对抗敌对攻击时更加健壮。新的 TensorFlow Probability 提供了概率建模，作为深度学习模型的插件。
你可以进一步阅读我关于负责任的数据科学的文章，看看当我们过于信任我们的机器学习模型时会出现什么问题。这份深度学习综合介绍和贝叶斯推理实用指南可以帮助深化和挑战深度学习的经典方法。
感谢《走向数据科学》的 Anne Bonner 的编辑笔记。
在不确定时期保持安全。
我对专业机器学习的投入
对我做了什么，怎么做的，赚了多少的坦诚回顾
大约一个月前我结束了实习。这一经历本身就非常有价值，我有幸与之共事的团队成员将成为我一生的导师。现在这个项目已经完成了，我想坦率地反思一下这段经历，并揭示一下从业余爱好者修补匠到在专业环境中开发机器学习模型是什么样的。
背景
我的角色是 SPIE 的一名人工智能实习生，这是一家位于华盛顿州贝灵汉的非营利公司，我在那里完成了我的 MIS/Analytics 本科学位。SPIE 出版与光子学研究相关的研究期刊和其他文献，并全年举办学术会议，研究人员在会上展示新的发现。当我加入时，SPIE 刚刚开始尝试使用机器学习来改善他们的业务，并需要了解使用新技术的可能性。除了我自己之外，开发管道的另一个活跃成员是上个季度我的一个文本挖掘班的教授。据我所知，SPIE 主动联系他们，看他们是否知道有学生有兴趣成为最终成为实习的独特项目的一部分。本季度末，我曾写信给我的教授，询问他是否知道毕业后的就业机会，这封信正巧落在了他的手上。
项目目标
SPIE 该项目的目标是预测一名研究人员提交给数字图书馆的论文是否会成功。利用这一预测，他们希望更有效地利用与这些演示相关的服务资源，如翻译论文和录制演示视频。由于内容的复杂性(密集的研究论文)，这些任务必须由具有领域经验的人手工完成。
数据
在这个项目中，我使用了两个数据集:
演示数据—SPIE 图书馆约 200 万篇研究论文的浓缩数据库。该数据集包含 101 个特征，从详细描述论文提交时间的简单日期特征到关于论文在哪个会议/子会议/研讨会上发表的等级信息。该数据集中还包括出席数据，详细说明了参加某一特定演示的参与者人数。数据中的结果集显示了从 2015 年开始的给定年份的下载量。因此，对于每篇论文，从 2015 年到 2019 年有五列数据，以及论文在那一年从 SPIE 的数字图书馆下载了多少次。
分类数据 — SPIE 投资创建了一个分类法，将每篇论文与特定主题联系起来。当一名研究人员将他们的论文发布到数字图书馆时，一个自动化系统会推荐哪些标签应该与论文相关联，以便人们更容易搜索它。如果系统推荐了正确的标签，它将包含在文档中。这一过程也允许研究人员输入他们自己的标签，这些标签也显示在数据中。这份文件只有 5 个特点，其中只有三个是有用的。
工作细节
这个项目被限制在 20 小时/周，但考虑到我修了 19 个学分，而且这是我在大学的最后一个学期，大多数时候我可能在这个项目上工作 12-17 个小时，并相应地按小时计费。至于报酬，我可以选择作为独立承包商工作，每小时 23 美元，或者作为 SPIE 的正式员工，每小时 21.05 美元；我选择了后者，因为我认为“人工智能实习生”的头衔会吸引未来潜在雇主对我简历的关注。该项目从 2020 年 2 月持续到 2020 年 8 月，除了初步的现场访问之外，该项目完全是远程的。我通常更喜欢在办公室环境中工作，但实习的远程性质最终带来了好处，在我开始工作一个月后，新冠肺炎进入了高潮。
工具和技术
我可以深入研究我们在项目的每个部分使用的许多特定的包，但是我认为人们使用的工具并不总是像它们被认为的那样重要。只要你知道你在做什么，你能到达你想去的地方，我总是喜欢阻力最小的道路。
- Python——简单、健壮，并为我们正在尝试做的事情提供了很好的包。
- 清理 —自定义 SQL 和 Python 脚本。
- 包 — Pandas/Numpy 用于操作， Scikit-learn 用于模型的主要特性和探索性分析， Genism 用于潜在的狄利克雷分配工作。
- 可视化: Matplotlib 用于简单的东西， Tableau 用于大的东西。
时间表
第一阶段:相互了解
在项目的第一个月，我获得了数据，并不得不清理它。我的第一个路障实际上是在看它。那时我对熊猫还很陌生，我处理的文件非常大。我花了一整天的时间试图找出哪些参数可以让我使用他们的自定义编码和分隔符，但最终我不得不向我以前的一位教授寻求帮助。一旦我过了这一关，我就开始研究数据。我联系了团队中具有更多领域知识的另一名成员，并真正投入到工作中，以便能够理解数据的底层组织如何有助于实现目标。在这一阶段，我还开发了一个管道，说明我是如何看待项目进展的，以及为什么每一步都需要在链中得到保证。我们还决定了如何对数据进行整理、分割和测试。有一些数据保真度的问题(下载只在一年内给出，而不是每月或每天),以及出席数据的损坏问题，所以我们必须找到一些解决方法。我们决定从原始演示数据集推进约 40 个要素，并决定使用下载数据作为预测的因变量。
阶段 2:特征工程
在第二阶段，主要活动是设计新功能。我们最初的想法之一是使用一种前向链接的方式，看看前几年主题的表现如何可以用来预测后来该主题的其他论文的受欢迎程度。这种方法本质上是试图跟踪某些对象的动量。我们还使用了一种无监督的方法来将分类群聚类到它们的自然领域中，这被证明是成功的最重要的预测因素之一。除此之外，我们使用了基于分类变量和数字变量混合的随机森林方法。
阶段 4:测试
因为初始数据集非常大，我们总是对随机播种的数据子集进行测试。我们使用标准参数进行培训/测试/验证，例如，我们使用 20%进行测试，80%进行培训。这是测试中最令人沮丧的部分之一，因为偏差和方差的问题凸显了我们之前犯的一些错误。在我们对模型的设置方式感到满意，并确信它在最坏的情况下也会表现良好之前，我们必须调整设置大约一周。我们在项目中使用前向链接来训练早期论文的数据，并使用后期的数据作为测试数据。比如 2018 年发表了一篇论文，我们用 2015–2017 年来训练模型，以 2018 年为基准判断准确率。这是有益的一步，但不完全符合预测新报纸业绩的商业问题。我们最终放弃了决策树部分的这种方法，只在 LDA 子模型中使用它。在这一阶段，我们还向执行委员会提交了我们的研究结果，在那里我们回答了他们提出的一些关于使研究论文受欢迎的特征的问题，并向他们展示了我们是如何做到这一点的。
阶段 3:包装和部署
到目前为止，我们一直在分段开发管道。因为有如此多的单个组件以特定的方式被处理，这个模型有点孤立。某些部分需要更多的预处理，而其他部分只是等待它们完成。我认为，如果我们在开始时花更多的时间进行规划，我们可以在这个阶段节省一些精力，但我对专业数据科学工作仍然非常陌生，可能不具备实际实现这一目标的智慧。该模型将部署在 Azure 上，但我们后来发现 Jupyter 笔记本在该平台上的弃用与我们打算使用的流程相冲突。不幸的是，这意味着我没有看到模型得到部署，因为我的实习即将结束，但我相信我们已经做了足够的工作，使模型相当简单，便于团队在未来部署。在这段时间里，将我的代码缝合在一起的一个更有趣的部分是看到我在这个项目过程中的进步。一行一行地回顾我写的所有东西(总共大约 2000 行)让我感到，因为找不到更好的词，怀旧。
外卖食品
我也只是想记录下我在这个过程中学到的新东西，以及项目过程中发生的变化。
什么是正确的
- 如果没有我的团队和高管团队的支持，我不可能取得如此大的成功。开诚布公地交流我们在哪里，我们在做什么可能是这个项目成功的最大因素。举个例子，在我们的探索阶段，关于是否将一篇论文的月发表的特征视为分类变量或数字变量，存在(健康的)冲突。我极力主张明确，这样我们就可以把出版视为一个循环过程，但我最终被动摇了，因为我们团队的沟通方式允许健康的分歧发生。
- 每个人都愿意好奇并探索他们的直觉，这为我们建立模型的方式提供了很大的创造性空间。因为数据是独一无二的，所以我们必须跳出框框思考我们处理数据的方式。此外，我认为模型的子组件是我们能够做出的最佳选择。
我需要改进的地方
- 没有花足够的时间专门规划管道的顺序会导致我的工作流程出现瓶颈。
- 在早期阶段尝试和测试模型的各个部分可能会很有趣，但是过度依赖早期的发现会使我的决策产生偏差，我们最终会消除整个部分，因为它们在更多数据下不稳定。
- 我们花了大约三分之一的时间进行探索性研究，但我认为我们还可以在这上面花更多的时间。理想情况下，我会花一半的时间来熟悉变量之间的关系。
- 处理如此大的数据集的过程非常顺利，希望在这个阶段有更多的挑战。
- 我在上一节中提到，我认为我们以创造性的方式使用了方法(我们确实这样做了)，但我希望我有更多的时间来探索我没有使用过的其他方法，如 transformers 或 PyTorch。
我学到的其他东西
- 许多我认为自己非常了解的包都非常深奥，在我了解它们之前，它们可以完成许多我手工完成的常见任务。阅读文件！
- 在您进入更大的项目之前，数学、计算机科学和数据库管理的广泛知识基础是非常重要的。你可以通过做一些构建在劣质代码上的小项目，而对底层理论却知之甚少，但是你最终会停滞不前。
- 真实世界的数据是混乱的。清洁仅次于虔诚。
总的来说，我认为这个项目是成功的，因为数据准确地预测了论文未来的受欢迎程度。
感谢阅读！
我的数据科学项目端到端流程
我从数据到产品的途径
我为什么要写这个故事？原因很简单，不是每个数据科学项目都是成功的。当然，你可以谷歌一下这个话题，你会找到成千上万的理由。对我来说，没有成功的项目是改进我的过程和技能的最大机会。在这个故事中，我将通过提供我在一个数据科学项目中的当前(并且仍在改进)流程来简要总结我的学习。我不怀疑这个过程不适用于每个人，因为“数据科学项目”没有单一的定义。我的目的是通过总结一个项目的不同步骤来分享我的经验。这并不能保证成功，但至少，作为一名数据科学家，这个过程将尝试解决您可以预防的所有陷阱。我的角色是创建消费数据和提供洞察力的管道(参见我在之前的故事中对管道的定义)。这是我正在使用的过程。
确定解决方案的范围
第一步是确定解决方案的范围。有时很难在期望和定价之间找到平衡。我的建议是，通过审视真正的需求来推动任何决策。这将允许把“最好有”放在一边，优先考虑“强制功能”。
从“为什么”开始(裁判:西蒙·西内克)
要草拟项目的范围，第一步是与客户一起工作，并理解难点和他的动机。在这个故事中，我将使用术语客户来表示为项目付款的人。实际上，客户可能是你公司的董事/副总裁/首席技术官。客户是决定投资这个项目的人。必须了解为什么这个人对这个项目感兴趣。最大化生产？过程的缩放？避免他工厂的失败？任何事情…痛点是什么？这对于下一步非常重要。一个好办法是询问客户目前如何处理他的痛点。如果已经有衡量当前流程效率的指标。
谁会用？
很多时候，我有机会在甚至不知道谁将使用该解决方案的情况下起草一个范围。这是不对的！如果使用了该解决方案，项目就是成功的。我曾经在一些项目中，用户甚至没有被清楚地识别出来。这是创造永远不会被使用的东西的最好方法。一家公司的首席执行官说:“人工智能既时髦又酷，我们应该用它做点什么”。快跑！
我们举个例子。一位主管/副总裁希望使用人工智能来优化工厂的库存管理。太好了！然后我开始谈论解决方案，但未来的用户甚至不在房间里。我们开始着手这个项目，并决定该算法将在每天早上提供一封电子邮件，其中包含需求预测，以帮助库存经理做出最佳决策。我努力工作，我成功地完成了这项任务。我们甚至开发基础设施来支持算法。一切都搞定了，CEO 也开心了！你猜怎么着？这个预测甚至不是经理最关心的。他很难实时弄清楚工厂里哪里有什么产品。太糟糕了，一个简单的交互式仪表板就可以完成这项工作。没有这些信息，预测是没有用的。这个项目失败了。
在另一种情况下，经理需要每周而不是每天的预测，或者预测需要实时可用而不是每天…所有这些情况都会发生。我的最佳建议是在对话中尽可能早地引入未来用户，因为他是定义需求的最佳人选。
什么？
此时，我想要的是一个清晰的成功标准。
客户:“我需要算法来预测我的装配线何时会出现故障”。
我:“好的”，我看着接线员，“你需要提前多长时间预测？”(在这里，我试图定义问题的粒度。)
接线员:“我需要提前 2 天的预测，早上 7 点前需要这些信息”。
我:“很好，但你必须明白，算法可能会产生错误警报，也会错过一些故障。你觉得这样舒服吗？目前情况如何？如果不需要一台机器，请维护团队来修理这台机器会造成多大的成本损失？一天之内你能检查多少台机器？”
我需要所有这些答案来创建一个成功的标准。
…
我:“你现在怎么解决这个问题？”。
操作员:“我们有 1000 台机器，每天至少有一台会出故障。我们无法全部检查，因此，我们优先检查长期未检查的那一个”。
最后一个信息非常重要，因为它告诉我酒吧在哪里。如果我模拟当前的策略，我可以评估我的解决方案有多好。
所有这些信息都有助于我用成功标准来定义一个衡量标准。在这种情况下，我宁愿使用命中率这样的指标。前 N 个最有可能的预测故障中的真阳性数。n 是维护团队一天内可以处理的干预次数。我很少向客户传达 F-Measure 或 AUC 之类的指标，因为他不能用这个指标来决定解决方案是否成功。在对话结束时，我们发现命中率为 2 对于要使用的解决方案来说是足够有价值的。此外，由于我收集的信息，我可以对客户目前浪费的资金以及客户通过成功的解决方案可以节省的资金进行定价。然后，当我向客户展示进度时，我可以将我的指标转换成美元。
一个重要的考虑是，我的解决方案将被集成到现有的系统中。这个系统的存在是有原因的，人们正在使用它。人工智能解决方案将改变这个系统。必须预见到这种中断，否则项目的最后阶段(当人们使用解决方案时)可能会导致意想不到的额外成本。这种干扰可能非常重要，以至于客户最终可能会改变主意，拒绝承担发布解决方案的风险(这发生在我身上)。我的建议是在解决方案的初始范围确定期间，在对话中引入这种潜在的中断。
在讨论结束时，我会询问一些数据片段，一些关于我们收集数据的方式的信息，等等。我会进行数据分析(1-2 天)以检查是否有大的危险信号。数据工程师也将参与对话以起草架构。
现在，我有了范围，我可以进入下一步，即制定解决方案。
概念证明(POC)阶段
这个阶段的目标是证明项目是可行的，并且能够带来价值。为了在这一阶段优化流程，您必须考虑需要哪些约束。
约束三角形
基本上，在 POC 阶段，我无法同时限制时间、资源和准确性。时间是指我能在这个项目上花费的时间。资源是分配给该项目的人数。准确性是指模型的准确性。理论上，你只能约束其中两个。实际上，资源或多或少总是受到限制的。也许一些公司可以在一个项目上分配“无限”数量的资源。我从来没有遇到过这样的情况。如果你放松准确性，它就相当于“黑客马拉松模式”或“尖峰”。当你想在短时间内研究一个想法时，这是很有用的。最现实的选择是放松时间。一些客户很难在这种模式下工作，因为他们需要遵守最后期限，并且他们可能会觉得 POC 永远不会结束。但是，诀窍是以有效的方式向客户传达进展。出于这个原因，我使用敏捷方法。这种范式是为软件开发而发明的，但我将其应用于数据科学项目的环境中。如果你不熟悉措辞，我邀请你读一些关于敏捷的文章。
冲刺 1:
我通常在 2 或 3 周的冲刺阶段工作，这取决于客户。第一次冲刺的目标是建立一个基线。当第一个端到端管道(从数据到指标)传递一个数字时，基线被声明。在最初的冲刺中，我选择最简单的路径。这是唯一重要的事情。尽快得到一个数字。例如，如果一些变量缺少值，最简单的方法是从数据集中删除这些变量。或者，如果我必须选择一个模型，最简单的是线性回归或逻辑回归，因为没有参数化。没有 creasy 预处理，只有简单的步骤。避免任何可能意味着微调或校准的步骤。没有 PCA，没有标准化，什么都没有。基本上，在这个 sprint 中，我设置了 CI/CD、git 存储库，编写了一个解析器，并创建了最简单的管道版本，以一个度量数字结束。我唯一需要注意的是评估策略。如果在 66%训练 33%测试程序和交叉验证程序之间切换，则很难比较两条管道的性能。评估策略需要尽可能接近管道的使用方式。在上面的例子中，我将为训练集使用一个增长窗口，为测试集使用一个滑动窗口。
冲刺 2:
第二个冲刺是将基线产品化。在数据工程师和 DevOps 的帮助下，我们建立了支持管道的架构。有些人更喜欢等到管道达到范围中定义的准确性水平。对我来说，我会尽我所能尽早地让其他团队明白，以便尽快产生一个 MVP。对于我的短跑，我使用标准周期。每天召开一次全体会议，检查是否有阻碍者。我们在 sprint 的开始做计划，在最后做演示。我们也不时做回顾。在冲刺的最后，我们检查新版本的管道是否提供了比基线更好的结果。如果是，它对应于下一个 sprint 的新基线。我在 sprints 中跟踪这些信息，并将其包含在演示中。
短跑中的指标跟踪
在演示过程中，我向客户展示了上面的图。他可以决定 1)继续另一个 sprint，2)宣布我们达到了目标，或者 3)放弃项目，因为当前的解决方案与预期相差太远，并且需要花费大量的时间来完成。这种早期停止对每个人都有好处。对于客户来说，他没有在一个可能过于昂贵的项目上浪费金钱，也没有将团队重新分配到另一个成功概率更高的项目上。演示也是验证新假设的机会。
在每次迭代中，我都会增加管道的复杂性。例如，我收集外部数据来扩充数据集，我改进预处理，添加更多功能，使用不同的算法，等等。这里的危险是过度设计管道。例如，我不会试图在第二次迭代时起草一个新的深度学习架构，或者我不会添加疯狂的复杂功能来确定一两个不会严重影响指标的离群值。为了确定对管道影响最大的改变，我经常查看误差最大的实例，试图找到解释，并得出新的清洁策略和/或新功能。我根据工作量对这些改动进行排序，从最简单的开始。
关于 CI/CD 和笔记本的注意事项:
度量的测量必须是可重复的。因此，我忽略了任何不是由 CI/CD 管道产生的数据点。如果结果是在 Jupyter 笔记本上获得的，我必须说服自己，它可以在另一台机器上重现。笔记本对于数据分析来说很酷，但是它们需要很强的纪律性来确保结果的可重复性。我知道我做不出这样的事。因此，我只相信 CI/CD 中的数字。我曾经遇到过这样一种情况，我向客户声称我们达到了预期，但最终却无法重现结果。这对每个人来说都是非常令人沮丧和昂贵的…我希望你永远不必生活在这种情况下。
产品化
我强烈推荐你看一下“机器学习系统中隐藏的技术债务”这篇文章。机器学习代码是整个解决方案的一小部分。清楚地了解产品化所需的额外步骤非常重要。产品化需要数据工程师和 DevOps 的支持。
但愿 POC 已经完成，我们达到了成功标准。很好！！现在需要把管道产品化。有两种主要的方法:
- 放手。概念验证的结果转化为规格。一组软件开发人员接手，重写整个代码，并将管道产品化。
- 推戳。我的代码“按原样”重用，在数据工程师和开发人员的帮助下，我们围绕它构建了一个基础架构。
这两种方法各有利弊。放手的方法将确保解决方案更加稳定。因为数据科学家并不总是经验丰富的开发人员(这里没有冒犯的意思)，代码的产品化通常掌握在其他人的手中。在大公司里这是常有的事。一个细节，在这种情况下，代码的所有权不再属于数据科学家。所以修复 bug 是由软件开发团队来完成的。
第二种方法是让数据科学家将他的代码打包到一个库中，然后它将在另一个系统中使用。例如，在云中的 lambda 函数中。这种方法更快，因为我们避免了重写代码。代码被“清洗”了，债务也还清了。如果你遵循我在之前的故事中的建议，这一步可以高效完成。最后，代码的所有者仍然是数据科学家，我负责修复 bug。这种方式通常在小公司和初创公司中使用，在这些公司中，每个项目只能有有限的几个人参与。
我更喜欢使用第二种选择。我将在下一节更详细地解释我的理由。简而言之，当使用第一种方法时，如果我想发布解决方案的改进或添加一些功能，我将不得不处理我的代码库，重写规范，等待开发团队更新解决方案，等等。这可能需要几个月的时间。快速周期意味着最大限度地减少干涉。
维护和改善管道
好了，现在我的流水线在生产了。但是，创建一个流程来获取操作员的反馈以持续改进解决方案非常重要。例如，操作员每天都在使用该产品，但他对算法提出了一些改进。例如，他不去预测失败是否会发生，而是希望得到一个分数或者失败的概率。为了从预测中得到一个分数，需要在管道中做一个小的改变。只是返回概率而不是预测类。我试图做的是，一旦管道的第一个版本可用，就建立一个反馈流程(sprint 2–3)。这个反馈循环也可以帮助我在冲刺阶段进行调整，但是当产品发布时，这种持续的改进仍然存在。为了与用户进行良好的互动，我希望改进能尽快发布。出于这个原因，我避免了放手策略，自己去做改进，更快地获得反馈。反馈回路对于捕捉操作员做出的决策也很重要。当决策与管道的预测不匹配时，这意味着我们可以通过纳入运营商做出决策的“原因”来改进管道。随着时间的推移，运营商的角色会发生变化，变得越来越简单。一个结果是能够扩展他的能力。最终，预测性管道可能会变成规范性管道。然后，操作员不再解释预测，而是直接采取行动。这引出了我的最后一点:
公司重组
重要的是要明白，在一家公司引入人工智能解决方案，将会扰乱员工通常的工作方式。有时，员工的角色变化和额外的技能可能是需要的。例如，如果你引入一个聊天机器人来帮助客户支持团队，这个团队可能会减少或重新分配到其他任务。该解决方案还可能导致客户公司的一些业务重新定位。我看到一些公司因为新的解决方案而改变了他们的策略，从销售产品到销售服务。这通常是客户没有预料到的。有时，它会导致项目暂停一段时间。在我看来，该公司会受到算法的严重影响，以至于在他们的系统中重组和集成解决方案需要更多的投资。他们最终决定不使用它。我试图在过程的早期引入这个主题，以确保客户能够预见到这种情况。
我希望你在我描述的这种或那种情况下认识到了自己。如果你同意，或者不同意，请在下面发表评论。
我的 Linkedin: 这里
我作为贝塔斯曼技术和深度学习纳米学位毕业生的经历
很难相信，2020 年即将结束。这是我在其中的一次奇妙经历。
迪米塔尔·贝尔切夫在 Unsplash 上拍摄的照片
当一年即将结束时，要做的一件负责任的事情就是反思。你取得了哪些成就，你面临了哪些挑战，你学到了什么，以及你如何让这一年的剩余时间变得有价值。
我可以肯定地分享的一个经历，希望对读者有益，是获得 2019 年贝塔斯曼技术奖学金，并获得 Udacity 的深度学习纳米学位，完全免费。今年，贝塔斯曼科技公司在开设了另一个奖学金申请项目，如果你对数据和云技术有热情，你绝对应该试试。
许多人在网上询问申请贝塔斯曼技术奖学金、赢得奖学金并完成 Udacity 的纳米学位是什么感觉。此外，一个人能从实现这一切中得到什么好处呢？所以希望这篇文章能帮助回答你可能有的一些问题。
我们开始吧！
1.贝塔斯曼理工奖学金到底是什么
贝塔斯曼是一家媒体、服务和教育公司，在全球约 50 个国家开展业务。他们的首席执行官 Thomas Rabbe 表示，他们的使命是让世界各地越来越多的人获得对数字技能的需求。他们与 Udacity 合作，提供免费的纳米学位课程，否则如果由个人全额支付将会非常昂贵。
2019 年，他们提供了数据分析、人工智能/深度学习和数据科学方面的纳米学位。今年，他们提供了三个新项目。如果你想了解更多，我在下面附上了链接。
2020 年贝塔斯曼理工奖学金项目。来源
2.申请奖学金
去年的申请要求申请者写一篇短文，内容是关于(1)你为什么应该获得奖学金，以及(2)你打算如何利用你将从奖学金中获得的技能，或者你将如何从奖学金中受益。我们还被问及对我们的 Python 技能的信心。
今年，这个应用程序变得更加简单和容易。您只需要回答几个关于您自己以及您当前 Python 和 SQL 技能的问题。
3.选择是如何完成的
为了获得全额奖学金，你必须通过两个主要阶段。
第一个是申请阶段。全世界有成千上万的人申请，只有大约 10000-15000 人被三个项目接受，这意味着每个项目大约有 35000 人被选中通过申请程序。
第二阶段称为第一阶段。第一阶段是给你提供你申请的 ND 项目的基础或基础课程。看看哪些候选人能真正完成整个课程。时长 3 个月左右，与去年持平。在 3-5k 申请者中，只有大约 300-500 人(10%)获得全额奖学金，即第二阶段，获奖者开始全部 ND 计划并完成剩余课程。
就是这样。之后，就看学者们在 6 个月内完成 ND 了。
以下是今年奖学金的时间表
2020 年贝塔斯曼理工奖学金时间表。来源
不要被愚弄，这些时间窗口可能看起来很长，但是参与阶段 1 和阶段 2 并不像看起来那么容易。尤其是和新冠肺炎·疫情。由于新冠肺炎和每个人都必须适应的“新常态”，我花了比预期更长的时间完成了课程。
4.我的经历
现在，我们到了有趣的部分。我跟大家分享一下我从申请一路到毕业的故事。
4.1 申请流程
2019 年，我选择了深度学习计划，因为我相信这些资源(学习资料、论坛、提示和技巧、最佳实践等。)对于深度学习来说，如果我选择在其他在线课程或网站上自学，仍然比其他两个更难达到。
我写了论文，提交了申请。一两个月后，我收到了这个。
我非常高兴，欣喜若狂，我的申请脱颖而出，被第一阶段录取了。
关键是我必须真正知道我想从这个项目中得到什么，以及为什么我(还有贝塔斯曼)会从接受(和给予)奖学金中受益。
所以，如果有另一个申请过程类似的奖学金，这里的关键是你真的真的要把它卖出去。
但是今年有点简单，因此在我看来，更难。为什么？好吧，申请中没有文章，只有几个复选框，这可能会让你在竞争中脱颖而出。
但是，这不应该阻止任何人去尝试，我说的对吗？😃
4.2 第一阶段
这就是贝塔斯曼理工奖学金的乐趣所在。
因此，在每一个 ND 项目中，学生们被分成三个全球松弛小组，每个小组根据他们申请的项目而定。每个学生都可以接触到他们研发项目的基础课程。
这一阶段以及进入第二阶段的说明简单明了。
我们必须及时通过基础课程，并积极参加休闲小组。
听起来很简单，对吗？完成课程并参加为期 3-4 个月的小组放松活动，对吗？
没那么快，
因为这是“容易”和“简单”的，每个人都可以很容易地做到这一点，即竞争也很激烈，很容易出错。人们最常犯的错误是:
- 他们很快就完成了课程，感到厌倦，不再参加小组活动
- 他们及时完成了课程并参加了小组活动，但还不够
第一个错误可能是因为无聊、办公室里有急事等等。关键是他们没有始终如一地参与到懈怠小组中。错误 2 是最危险的。因为许多人确实及时完成了他们的课程，他们确实参加了懈怠小组，但是他们被那些更积极的人淹没了。他们中的一些人甚至向 Udacity 投诉，说他们不同意/抗议他们朋友的选择结果。这些高度活跃的人通常参加学习小组会议(我们称之为学习堵塞)，每天或一周中的几天发布在 Slack 小组中，要么是有用的想法，要么是对其他学生问题的回答，要么是激励性的报价，甚至可能是一个有趣的 meme 来放松。
关键是，那些进入第二阶段的人，是那些“疯狂地”想要这些奖学金的人，他们表现出来了。在第一阶段的所有 3-4 个月中。
第一阶段我做了什么？我在下班后与我的印度尼西亚学者们聚在一起，在课程中一起工作，组织并参加定期会议，并一直致力于它。我甚至发表了一个我用第一阶段获得的技能做的项目。
贝塔斯曼 AI Udacity 奖学金的挑战之一，这是如何分类中国十二生肖的一种方法…
towardsdatascience.com](/chinese-zodiac-sign-classification-challenge-with-pytorch-d89a8897d00b)
经过大量的艰苦工作，那 3-4 个月感觉漫长得多。但这是值得的，尤其是这封邮件。
4.3 第二阶段
现在真正的艰苦工作开始了。
有 5 门主课，5 个项目，我们必须在 9 月 17 日之前提交。如果你觉得非常有动力，再加上一门课外课程。从事这 5 个项目并不是最大的挑战。是新冠肺炎。
世界被扔进了一个巨大的扳手，全球每个人都必须适应“新常态”，包括印度尼西亚。从早上 9 点到下午 6 点在办公室工作变成了在家工作，工作时间更长，也更随意。有时还是一样，有时你不得不从睁开眼睛的那一刻一直工作到晚上 10 点。真的很难预料。我不能合理地计划我的时间。当然，我必须首先确定工作的优先顺序。因为疫情，很多人被解雇了。
我别无选择，只能在深夜和周末全职攻读我的纳米学位。太累人了。
将近六个月过去了。最终，在祈祷、咖啡、谷歌以及 Udacity 的导师和学生中心的帮助下，我设法在大截止日期前完成了它，并毕业了。另外，我在不牺牲健康的情况下做到了这一点。
[## Udacity 纳米学位项目毕业证书
证明你完成了一个职业相关的项目，侧重于技术技能
confirm.udacity.com](https://confirm.udacity.com/P2VR7KDA)
4.4 我得到了什么
这就是 2019 年贝塔斯曼技术奖学金和 Udacity 深度学习 nd 的过程和旅程。也有人问我，我做这一切得到了什么好处。以下是其中的一些
- 在奖学金和纳米学位期间，我遇到了许多有着同样动力和激情的了不起的人，并和他们成为了朋友。我们交流想法和令人敬畏的话题，并激励彼此进步。我仍然和他们中的一些人有联系。谁知道将来我们会如何从这个网络中受益。谁知道你会在 2020 年的贝塔斯曼技术奖学金中遇到谁呢
- 毫无疑问，技能和知识和我想象的一样好。讲师，导师和学生中心是如此惊人。这些讲座相对容易听懂和理解。实践项目也非常直观，它们还提供了解决方案，以防我们被一两行代码或它们背后的概念所困扰。
- 这些项目非常独特。我从纳米学位项目中获得的经验好得令人难以置信。这些问题是独特的。这些案子是真实的。Udacity 还为学生提供了 99 小时的支持 GPU 的工作空间，以比使用我们自己的私人笔记本电脑更快的速度运行我们的代码和模型。他们也给了我们一套清晰的目标，让我们在项目中实现(最小准确性、最大损失、清晰简明地解释我们的逻辑/思维过程)。没有其他在线课程能给我提供同样的体验。
总的来说，这是一次奇妙的经历。Udacity 没有为他们的深度学习 ND 夸大纳米学位这个术语。这几乎就像一个迷你硕士项目。我建议其他人去实现。
临终遗言
希望这篇文章对那些想申请和学习贝塔斯曼技术奖学金和 Udacity ND 的人有所帮助，或者至少激励你继续学习。
“保持饥饿，保持愚蠢”——史蒂夫·乔布斯
“保持安全和健康”——任何有常识的人
我作为数据科学家和数据分析师的经历
我希望从一开始就知道的成功秘诀
威廉·艾文在 Unsplash 上的照片
T 这里有许多关于成为数据科学家和数据分析师所需技能的文章，但很少有人告诉你成功所需的技能——无论是获得出色的绩效评估、管理层的表扬、加薪、升职，还是以上所有这些。今天，我想分享我作为数据科学家与数据分析师的第一手经验，以及我获得成功的经验。
我很幸运，在没有任何数据科学经验的情况下，得到了一个数据科学家的职位。我如何做到这一点是另一个故事，我在这里的观点是，在接受这份工作之前，我对数据科学家的工作只有一个模糊的想法。
我之所以被聘用，是因为我有构建数据管道的经验，因为我之前是一名数据工程师，开发了数据科学团队使用的预测分析数据集市。
我作为数据科学家的第一年涉及建立数据管道来训练机器学习模型，并将其部署到生产中。我保持低调，没有参加很多与作为模型最终用户的市场利益相关者的会议。
在我的第二年，负责营销联络的数据科学经理离开了公司。从那时起，我就成了关键人物，并更多地参与模型开发和项目时间表的讨论。
随着我与利益相关者的互动越来越多，我意识到数据科学是一个模糊的概念，人们听说过但不太理解，尤其是高级管理层。
我建立了一百多个模型，但是因为我不知道如何展示价值，只有三分之一曾经被使用过，即使这些模型在一开始就被市场要求。
我的团队中的一名成员花了几个月的时间开发了一个模型，高层管理人员认为该模型可以展示数据科学团队的价值。这个想法是在这个模型被开发出来之后，在整个组织中推广这个模型，并鼓励营销团队使用它。
这被证明是一个彻底的失败，因为没有人明白什么是机器学习模型，也不明白使用它的价值。结果是几个月的时间浪费在没人想要的东西上。
这让我想起了我从成为一名成功的数据科学家中学到的经验:
1.选择正确的公司，为自己的成功做好准备。
在一家公司面试时，询问他们的数据文化，以及有多少机器学习模型已经被采纳并用于决策。求举例。
了解数据基础设施是否已经为您建立，以便开始建模。如果你花 90%的时间试图提取原始数据并对其进行清理，你将几乎没有时间构建任何模型来展示你作为数据科学家的价值。
如果你是第一个受雇于数据科学的人，请小心。这可能是好的也可能是坏的，取决于数据文化。如果高级管理层只雇佣一名数据科学家，因为他们希望被认为是一家利用数据科学做出更好决策的公司,并且不知道这到底意味着什么，那么你可能会在采用方面遇到更多阻力。或者，如果你发现一家公司是数据驱动的，那么你会随着公司的成长而成长。
2.了解数据和关键绩效指标(KPI)
在开始时，我提到当我还是一名数据工程师时，我已经为数据科学团队构建了分析数据集市。当我过渡到我的数据科学家角色时，我能够找到新的功能来提高模型的准确性，因为我在以前的角色中曾密集地处理过原始数据。
当我展示营销活动结果时，我能够展示这些模型产生了更高的转化率，其中一个 KPI 营销活动就是根据这些结果进行衡量的。这证明了营销模式对企业绩效的价值。
3.通过向利益相关者展示价值来确保模型的采用
如果你的利益相关者从不使用你的模型来做商业决策，你将永远不会成为一名成功的数据科学家。
确保采用的一个方法是找到业务的痛点，并展示模型如何有所帮助。
在与我们的销售团队交谈后，我意识到有 2 名代表全职手动检查公司数据库中的数百万用户，以确定更有可能升级到团队许可证的单许可证用户。在选择过程中使用了一套标准，但这很耗时，因为销售代表必须一次查找一个用户。使用我开发的模型，销售代表现在可以选择最有可能购买的用户，并在更短的时间内增加转化的机会。通过提高销售团队可能涉及的 KPI 的转换率，这转化为更有效地利用时间。
几年过去了，我一直在重复开发相同类型的模型，感觉我不再学习任何新的东西。我决定寻找一种不同的角色，最终得到了一份数据分析师的工作。
尽管我再次支持市场营销，但职责上的差异与我担任数据科学家时相比，已经大不相同了。
这是我第一次分析 A/B 实验，发现所有* 实验可能出错的方式。作为一名数据科学家，我根本没有参与 A/B 测试，因为那是留给实验团队的。*
我做了各种各样的分析，营销对这些分析有影响——从提高保费转化率到用户参与度，再到防止流失。我学会了许多不同的方法来查看数据，并花了大量的时间来汇编结果，并将它们呈现给利益相关者和高层领导。作为一名数据科学家，我主要研究一种类型的模型，很少做演示。
我的数据分析师经历与我作为数据科学家时有很大不同，那时我的重点是开发模型来优化用户转化，而不是我作为数据分析师参与的项目的广度。
几年后，这些是我学会的成为一名成功的数据分析师的技能😗*
1.学习如何用数据讲故事
不要孤立的看 KPI。从整体的角度看待业务，将它们联系在一起。这将允许您确定相互影响的区域。高层领导从 30，000 英尺的高度审视业务，当决定晋升时，表现出这种能力的人会受到关注。
2.提供可行的见解
提供可行的见解，这是一个问题的解决方案。如果你主动提供这个解决方案，而没有被告知这是一个问题，那就更好了。
例如，如果你对市场部说——“我注意到最近网站的月访问量有所下降”。这是他们可能已经在仪表板上注意到的趋势，而作为分析师，你不会提供任何价值，因为你只是陈述观察结果，而不是提供解决方案。
相反，你可以查看数据，找出原因并提供解决方案。营销的一个更好的例子是—“我注意到最近我们网站的访客有所下降。我发现来源是有机搜索，因为我们最近做了一些改变，导致我们在谷歌搜索排名中下降。这表明你在跟踪公司的 KPI，注意到了变化，研究了原因，并提供了问题的解决方案。
3.成为值得信赖的顾问
你需要成为利益相关者就你所支持的业务提出建议或问题的第一个人。
没有捷径可走，因为展示这些能力需要时间。
关键是始终如一地交付高质量的分析，很少出错。计算中的任何错误都会让你失去可信度，因为下次你提交分析时，他们可能会怀疑如果你上次错了，这次你是不是错了。总是仔细检查你的工作。如果你对自己的分析有任何疑问，在陈述之前让你的经理或同事检查一下你的数据也无妨。
4.学习如何以清晰的方式传达复杂的结果
同样，成为一个有效的沟通者没有捷径可走。这需要练习，随着时间的推移你会变得更好。
关键是要找出你想要提出的要点，并根据你的分析结果，向你的利益相关者推荐任何可以改善业务的行动。你在组织中的职位越高，良好的沟通就越重要。传达复杂结果的能力是一项需要展示的重要技能。
作为一名数据科学家和数据分析师，我花了数年时间学习成功的秘诀。我们对成功有多种定义，被描述为“惊人的”和“全明星”分析师在我看来就是成功。现在你知道了这些秘密，我希望你的成功之路，无论你如何定义它，来得越早越好。
你可能也会喜欢…
将数据科学与数据分析相结合
medium.com](https://medium.com/swlh/how-i-used-a-machine-learning-model-to-generate-actionable-insights-3aa1dfe2ddfd) [## 我从数据工程师到数据科学家的不可思议的转变，之前没有任何经验
通过掌握一项基本技能
towardsdatascience.com](/my-unbelievable-move-from-data-engineer-to-data-scientist-without-any-prior-experience-6f76614fe340)**
我参加 TensorFlow 开发人员认证考试的经历
TensorFlow 开发者认证
来自新成立的 TensorFlow 认证工程师的提示和技巧
认证计划徽标
只有 200 多人被列为认证 TensorFlow 开发人员，已经有一些关于考试的帖子了。这个是我的，从一个更实用的角度来看你。在这篇文章中，我将告诉你我是如何准备的，以及你如何获得认证。
我的观点和我认为的大多数考生的观点有点不同。我已经是全职的机器学习实践者，我不是在找工作的学生，也不是自雇顾问。该考试似乎主要是在这两个类别中推广的。因此，我希望我的帖子对那些已经在数据科学或编程方面有良好基础的人非常有用。
张量流不到 100 字
所以你可能想知道张量流到底是什么，为什么你应该关心它。TensorFlow 是 ML 界的巨头。它是由 Google 维护和发布的 Python 框架。它旨在用于深度学习，而不是作为 Sci-kit learn 等经典 ML 库的替代品。从版本 2.0 开始，TensorFlow 实现了 Keras API，这基本上意味着您可以像使用 Keras 一样与 TF 代码进行交互。这一点很重要，因为 Keras 更高级，对初学者来说更容易学习。TensorFlow 是一个在工业和生产级任务中特别流行的框架。
考试会给你带来什么
但是，当然，你已经知道了所有这些。你可能在谷歌搜索中找到了这篇文章，寻找这个考试对你来说是否值得，你是否可以参加。我听到了。这项考试还有一些额外的好处:
- 你可以把它列在简历、Github 或 LinkedIn 个人资料上
- 你在公共认证目录上有一席之地
- 你将获得一枚徽章，可以在社交媒体上分享
- 很有趣
TensorFlow 认证目录具有地图功能，因此招聘人员可以更容易地跟踪你。
缺点:
- 花五个小时，以编码为基础，这是一个需要你做实际工作的考试。有失败的可能。
- 考试本身要花 100 美元，在 Coursera 上浏览课程可能也要花钱
- 它的有效期只有三年
此外，像所有证书一样，考试本身并不是对技能的认可，也不能保证为你打开更多的大门。也没有准入门槛。你可以在没有 TensorFlow 经验的情况下参加考试，但我不建议你这样做。
我的准备
为了准备考试，我按顺序浏览了以下材料:
【pdf】考生手册是你可以从中获取考试信息的主要文件。我读了它，并在任何看起来有趣的地方做了笔记。它还 链接到另一个 pdf，详细说明如何设置您的环境 。由于这两个文件都是活文档，我在考试前检查了一下。
实践专业化张量流(Coursera)
TensorFlow 在实践中的专业化 本质上是课程到考试。劳伦斯·莫罗尼(Laurence Moroney)给出的，是对 TensorFlow 以及如何在 TensorFlow 中编写深度神经网络的官方介绍。这是一个包含四门课程的专业，每门课程包含四周时间。如果你是从零开始，这意味着你可能需要一段时间来解决这个问题。
然而，如果你已经很有经验并且很有能力的话，它会花费很少的时间。对我来说，课程 1 到 3 已经是我工作的一部分，我可以在四天内完成。每门课我都记笔记，并不断补充。只有当我到了第四门关于时间序列的课程时，我才慢了下来，因为我对时间序列只有有限的经验。
PyCharm 2020.1 spash 屏幕
****专业化完成后，最后一站是练习解决方案。我选择在皮查姆学习。考试本身也是由 PyCharm 的一个插件管理的，如果你没有的话，你需要下载它。我不经常在深度学习工作中使用PyCharm，但我对它有些熟悉。我认为这是为任何 GPU 错误等做准备的好方法。为了帮助我确定学习过程的范围，我根据我几乎没有经验的事情列出了一个清单。其中的一些例子包括使用张量流数据集、生成 LSTMs 的诗歌以及一般的时间序列预测。我花了大部分时间在这里，因为我花了几个星期的下班后学习时间来完成所有的事情。
候选人手册中的屏幕截图，显示了您可能被要求实施的项目列表。请查看 TensorFlow.org 最新版本的列表。
最后一步，我设置了模拟测试环境的环境，以确保一切顺利进行。在考试之前，我还运行了一台 Jupyter 笔记本电脑服务器。虽然您应该能够在五个小时内在本地完成所有工作，但是您也可以使用其他环境来构建解决方案的原型——甚至是在云上。
摘要(tl，dr:)
- 阅读候选人手册 (pdf)
- 阅读设置您的环境说明 (pdf)，该说明链接自考生手册
- 在 Coursera 上做 TensorFlow in Practice 课程。
- 研究:解决任何你从手册中不知道的概念，用那个概念建立你自己的解决方案
- 用考试规范建立一个 PyCharm 环境，这样你就知道应该在考试中发挥作用的一切。
- 建立一个后备环境(如笔记本电脑、Collab，甚至在 GCP 或 AWS 虚拟机上)，以防考试期间发生任何事情。
我们信任云。摘自 Sara Robinson 关于 TF 2.0 部署的博客文章，你可以在这里找到。
做检查
我决定我已经准备好了，我想设置一切可能需要一两个小时。我在考试网站上创建了一个账户，并提交了我的 ID 和付款。我下载了插件，接受了条款，并确保我的互联网能够正常运行。万事俱备，只欠东风。
然后我吃了午饭。
一旦我按下那个大的[开始检查]按钮，计时器就开始倒计时。在五个小时的时间内，你需要解决许多问题，而且每个问题都比前一个难。后面的一些模型计算量很大，甚至在 GPU 上也是如此。每当我可以训练出一个解决方案的时候，我就会开始编码下一个。
最终，我遇到了一个 CUDA 问题似乎是由于版本不匹配。随之而来的是轻微的恐慌和漫长的时代。我可以更新考试环境，但不确定这是否会给我带来更多问题。我无法在 10 分钟内解决它(而且我真的不想在压力下做更多)，所以我让我的模型在我的 CPU 上训练。此时，我已经花了 2.5 个小时。****
还有一些小问题，比如插件不能用提交按钮刷新屏幕。我不得不重新启动我的 IDE 几次。这并不十分麻烦，因为修复问题或多或少是正常开发的一部分。
然而，由于这些小问题影响了我排除故障的能力，我切换到我一直运行的 Jupyter 实例，并使用它进行原型开发。这意味着当我的 PyCharm 在后台使用 tensors 时，我仍然可以在那里制作模型原型。
没有给出太多的信息，考试确实给出了一点反馈，这样你就知道你对问题的解决方案什么时候足够好了，你就可以继续了。大约过了四个小时，我对我所有的解决方案都很有信心，并且有点自满。我开始改进一个不能完美得分的模型，由于现在在 CPU 上训练，我花了一段时间在它上面。在这个过程中，我重写了我以前的模型。你可能已经猜到了——新型号的性能更差，甚至降低了以前的分数。对我来说幸运的是，在剩下大约十分钟的时间里，我能够提交另一个型号，它的性能与旧型号相同。
之后不太长的等待
在我提交了考试之后，我马上收到了一封电子邮件，说我通过了！
虽然考试的评分是瞬间完成的，但我花了几天时间才拿到徽章，一周后我的名字才出现在认证目录上。我觉得这反映出这可能不是一个自动化的过程，他们仍然在寻找最好的方法来完成它。
伙计们，这次没有带帽的谷歌毛衣或贴纸了
结束语
这种考试方式比监考更适合我。我发现当有人在你的笔记本电脑上看着你的时候，做一个考试很伤脑筋。我做不到。尽管考试花了五个小时，但这是一次愉快的经历。
TensorFlow 现在获得了认证，这一事实确实激励我对它有了更多的了解。我喜欢在学习时心中有目标。
预计未来会有更多的认证。我当然希望如此。他们可以涵盖许多有趣的高级 NLP 主题，我觉得在更大的 TensorFlow 生态系统中有一些元素非常适合这种类型的考试。未完待续，我猜。😃
即将推出:高级和专家级认证。来源这里。
祝你的 TensorFlow 之旅好运，希望这篇文章对你有用。如果您有任何问题，请告诉我。
我使用 rTweet 使用 Twitter Premium Full Archive API 的体验
从高级 API 访问数据有几个方面不是常识
图片来源:Unsplash
Twitter 的高级存档 API 允许访问超过 30 天的推文，可以追溯到 2006 年。这是一种重要的数据资源，自然也很昂贵。人们应该在开始使用它之前了解某些事情，因为每个请求都是付费的，并且有一个有限的请求配额。
从 premium API 访问数据的整个过程在 Twitter 的开发者页面以及 R 和 Python 库的文档中都有很好的记录，但是有几个方面没有得到很好的解释或者完全被忽略了。
在我的项目中，我需要访问两到三个月前的推文，所以我购买了 Twitter 的高级访问权限以获得完整的存档。我使用了“rtweet”包，这是 R 的库，可以访问 Twitter 的 API。它有很好的文档记录，并且可能是唯一允许访问高级 API 的 R 包(但是它有令人痛苦的缺陷)。
然而，在你开始走这条路之前，有一些要点你应该知道。
- 成本+税— 此处给出的成本表不含税。我每月花 224 美元购买了 250 个请求，并额外支付了 44 美元。也许很多人都知道成本不包括税，但他们应该在某个地方说出来，特别是对于那些可能申请补助金/资金来支付这笔费用的人。
- 最近到以前的推文— 在构建获取推文的查询时，rtweet 函数 search_full archive 允许输入日期范围。该查询如下所示:
tweet <- search_fullarchive("#beyonce or #katyperry)(lang:en or lang:hi)" , n = 3000, fromDate = "201912120000", toDate = "201912120000", env_name = "curate", safedir = NULL, parse = TRUE, token = token)
Twitter 的 premium API 获取用户查询中提到的最近时间，然后一直工作到开始时间。这种方法不允许全天发布更大范围的推文，而只能在很短的时间内发布。
3.推文配额—****Twitter Premium API 允许每个请求访问 500 条推文。而且，你也可以得到 500 的倍数的推文。例如，(这是我的理解)在上面的查询中，我在一个请求中请求了 3000 条推文，这将被计为=3000/500 = 6 个请求。人们需要注意这个数学问题，因为订阅允许一定数量的请求和一定数量的推文，在我的情况下，每月 250 到 125，000 条推文。如果你用完了请求，你将无法消耗你的 tweets 配额。在实验和查询构建中，很有可能一些请求会耗尽。
4. rTweet 消耗更多请求的速度更快— 我最近发现 rTweet 软件包有一个缺陷，它消耗的请求比需要的多。我不确定他们是否已经修好了。但是，由于这个错误，我丢失了大量的推文。你可以在这里阅读关于这个 bug 的。
当我开始使用 Twitter Premium API 时，我没有发现这些要点，因此我付出了惨痛的代价。
希望有帮助。
我最喜欢的(免费)交互式数据可视化工具
构建交互式网络地图的灵感和工具&更多
交互式网络浏览器是我作为斯坦福大学数据科学家工作的重要组成部分，支持决策者为人类和自然做出有针对性的空间规划选择。当教的时候，我被问了很多关于底层工具的问题，所以这里有一个快速的回答。
交互式数据可视化非常有用
在数据时代，我们饱受信息过剩之苦，有效地理解大量数据已经成为一项重要的技能；因此，数据可视化蓬勃发展。的确， 数据即 已经成为探索大型多维数据集必不可少的。交互式数据 viz 特别有助于链接不同的数据视图，过滤大数据集，或可视化跨比例的精细分辨率地图 …
在我从事生态系统管理的工作中，我看到了以一种用户友好的方式向决策者传达复杂的量化结果是项目成功的关键。交互式查看器有助于讨论，并易于吸引用户，让他们直观地研究数据集。除了它们潜在的吸引力，它们还真的有助于从复杂的数据集中获得洞察力，研究显示。
著名的全球观众 监测森林砍伐珊瑚礁健康气候适应能力食物系统资源海平面上升 (…)以及最近的冠状病毒 病例。这些甚至经常作为他们的主题的数据库，收集最新的数据集。在较小的范围内，特定于项目的查看器服务于特定的目标和目标受众，允许协作者共享和可视化数据，在团队迭代时促进跨组讨论。例如，在空间发展计划的背景下，观众帮助合作伙伴调查发展的场景，如新道路或新保护区建设的影响…
我最喜欢的数据可视化工具&库
一个数据可视化工具的流程图，可以让你制作更漂亮的流程图…等等！
那么，最好的数据可视化工具是什么？没有放之四海而皆准的神奇解决方案；像任何好的视觉效果一样，合适的工具取决于你的受众、数据格式和要传达的关键信息。下面，我将列出我喜欢使用的工具，并链接一些例子。
对于网络观众，利用强大的 JavaScript 库
先说最强大的交互标图库:D3 . js是交互数据可视化的猛兽。从用 C3.js 轻松制作的非常简单的互动图表，到最酷的迷幻、艺术、以及富有洞察力的视觉效果。它几乎涵盖了所有类型的地块，从和弦图到单词树。D3.js 不容易，但是有充足的 教程和实例来支撑。****
说到空间数据， 小叶 是交互制图的女王库。它的能力依赖于它的插件，由社区贡献，可以适应最流行的数据类型。我将这些用于，特别是用于shape file、 geoJSONs 的那个，最近，我发现这个用于(相对较小的)栅格 。对于更大的栅格(和最快的显示)，我推荐使用图块。商业解决方案(如 Mapbox 、 ArcGIS Online 或 Carto )让您可以轻松制作和托管切片，但有数据托管限制，并且永远无法 100%定制。我更喜欢创建自己的 tileset，它并不像看起来那么复杂(3 个 GDAL 命令，然后用 GitHub pages 平稳地服务它们)>参见我构建和服务自制 tileset 的神奇技巧！
现在，对于卫星图像， 谷歌地球引擎 (啧啧)大概是你最好的选择。优点:如果你展示的是 GEE 托管的数据集(他们托管了很多！)，你会节省相当多的时间。你也不需要担心托管或服务你的浏览器，因为它是通过 GEE 应用程序托管和服务的。缺点:虽然编码被简化了(感谢谷歌)，但它是沙箱化的，所以你不能完全控制创建你梦想中的漂亮界面。此外，应用程序部署仍处于测试版本。当然，它不是开源的。**
部署您的浏览器
GitHub Pages 让部署你自己的浏览器变得异常简单(设置>选项> GitHub Pages >源>选择你的分支和浏览器文件夹)。您的查看者的 URL 看起来像 . github . io/{ repository-name }，但是如果您拥有一个更酷的域，则可以自定义。**
只需要一个快速原型？如果你不需要部署一个完整的 web 浏览器，你可以节省大量的时间(基本上跳过所有的 web 开发:没有 HTML 也没有 CSS，直接跳到你的 viz 需要的 JavaScript)，通过使用 Observable 的交互式 JavaScript 笔记本，可以在线加载你的数据。
如果你宁愿用 Python 呢？
对 JavaScript 过敏？别再担心了。一些很棒的 Python librairies ( 散景 ， 牛郎星 )让你互动地到处玩(在 Jupyter 笔记本里)。尽管 Javascript 仍然是将在 web 上共享的任何内容的参考，但上面提到的大多数 js librairies 也有 python 版本(例如flower集成了 flower . js 用于 Python 数据)。
如果我不编码呢？
它总是在可定制性和易于实现之间进行权衡。
存在商业解决方案( ArcGIS Storymaps 允许轻松创建结合媒体、文本、地图和图表的交互式故事；Tableau 让你轻松创建仪表板…)，尽管它们在功能和可定制性方面存在固有的局限性。大多数功能都是基于免费增值模式。老实说，我对他们不够了解，无法提供好的建议。
如果你不怕看代码，并且你对 github 有足够的了解，可以试试这个:
在 2 小时内构建您的定制网络浏览器！
掌握这些可视化库，并让一切顺利地协同工作——从数据格式化到在线部署查看器——可能非常耗时。为了简化这个过程，我和出色的 Anna hhgg 为我们的同事制作了一个模板来免费、快速地构建网络浏览器。都是开源的，所以也是你的！
https://charlottegiseleweil.github.io/viewerTemplate/**
viz.naturalcapitalproject.stanford.edu/viewerTemplate(由安娜·哈格设计)
它仍然很新，所以非常欢迎您的反馈——看一看演示,并复制回购以开始使用。
底线:如本文所述，有许多新的库和工具可以用来制作更精致、更漂亮、更丰富多彩的网络地图…我建议在选择工具和设计解决方案时，始终关注要传达的关键信息和受众——有时最简单的就是最有效的！
牢记图形完整性原则，玩得开心！
我最喜欢部署到生产中的 Python 服务器
探索常规生产服务器的替代解决方案，增强您的部署能力！
(图片由作者提供)
介绍
我们都经历过:
您已经构建了完美的 web 应用、终端或应用——所有的按钮都已准备就绪，您终于可以将您的软件部署到生产环境中了！虽然这是一个令人兴奋的努力，但它也提出了许多关于技术栈的问题，你可能想用它来让你的软件被大众使用。在解决 NGINX 配置和设置 Unix 后端的过程中，很容易忘记这个难题中最重要的部分:
服务器本身。
有这么多优秀的 Python 服务器供我们使用！问题是有这么多好的选择，很难计算出哪一个最适合你的具体情况。幸运的是，在某些类别中有一些明显的赢家，在其他类别中有一些明显的输家。
重要提示:
选择下面的服务器部分是因为它们满足作为具有 UDP 或 TDP 协议的 WSGI 服务器的要求。这些服务器的主要目标是部署基于框架的应用程序，而不是服务静态文件。
Gunicorn3
Gunicorn3 是“经典的”和行业标准的 Python 生产服务器。与其竞争对手相比，Gunicorn 作为一个独立实体的最大特点是其管理员工的能力。它还非常节省资源，与工作人员管理相结合，意味着您可以设置某些终端的优先级，并在最需要的地方保持服务器的性能！
使用 Gunicorn 的另一个显著优势是，它是唯一一个兼容几乎所有东西的用于 Python 的 WSGI web 服务器。鉴于它通常被视为生产中 Python 部署的标准，包在开发过程中经常依赖于它，因此在发布时完全兼容。这是您在使用 Flask 和 Django 时可能会用到的典型服务器，这是 Python 中最流行的两个 web 框架。
使用 Gunicorn 的最后一个优点是它天生就相当快。Gunicorn 坚持的很多东西是简单——这不是一件坏事。这意味着它通常可以非常容易地实现，并且运行速度非常快。它也主要是用 C 编程语言编写的，这意味着就速度而言，它可能在任何其他用纯 Python 编写的服务器之上。
Gunicorn 的另一个优势是，我已经有了一个关于如何使用它和 NGINX 部署 Flask 的教程:
应用程序部署通常会带来意想不到的后果和错误。部署可以是制定或…
towardsdatascience.com](/deploying-flask-with-gunicorn-3-9eaacd0f6eea)
女服务员
对于那些寻求真正轻松体验 Python 服务器的人来说，with 是另一个很好的选择。一个显著的区别，也可能是它对 Gunicorn 的优势，是能够在 Windows 和 UNIX 上运行，而 Gunicorn 只能在类似 UNIX 的操作系统上使用。虽然这对于那些希望在 Windows 上部署的人来说可能是一个优势，但我也不记得我上次看到 Windows 服务器是什么时候了，所以如果它适合您，这可能很好，但对于大多数最终用户来说可能不是一个优势。
女服务员在 CPython 上运行并引用
“非常可接受的性能”
我没有测试过这一点，尽管这可能会在未来产生一些有趣的观察结果——所以我不得不相信他们的话。虽然我怀疑性能相当不错，但我也认为 Gunicorn 的表现超过了它，这仅仅是因为他们使用 C 语言作为 Python 代码服务背后的主要驱动力。
关于 last，我想指出的最后一件重要的事情是，它没有标准库中没有的依赖项。这又回到了让东西变得非常轻便的想法。如果您正在寻找一个纯 Pythonic 的、轻量级的、不需要任何依赖就能运行的服务器，那么这可能就是您想要的！
GEvent
GEvent 是另一个伟大的网络服务器，但它离 Gunicorn 或 large 之类的东西有一个相当大的飞跃。虽然这些库主要关注轻量级、简单和快速，但 GEvent 更关注子进程的分段，也称为协程，可以随时停止和恢复。这大大提高了速度，同时保留了一些人可能需要的许多功能。
GEvent 的一个突出特点是 SSL 支持和协作套接字。这使得多个入站连接协同工作以实现相同的目标变得容易得多，从而在多个连接而不是一个连接之间平衡负载。SSL 支持也总是一件好事！
为了解决与某些库的潜在不兼容问题，GEvent 使用了一个他们称之为“猴子补丁”的系统。它实际上工作得出奇地好，而且事实上相当令人印象深刻，可以很容易地自动化。最重要的是，它提供了对线程池的简单支持。虽然它比一些同类产品笨重，但对于许多全栈应用来说，它可能是目前可用的最佳选择。
uWSGI
这个列表中的最后一个选项是一个名为 uWSGI 的 C 库。像 Gunicorn 一样，uWSGI 高度重视 CPU 的使用。这反过来又使得它非常适合与许多不同的端点或可能协同工作的应用程序一起使用。然而，这并不是说 uWSGI 的主要用途将永远是端点，因为其中包含的许多特性也可能使它适用于 fullstack。
首先，uWSGI 包含请求插件。这考虑到了服务器本身的实际可扩展性，使它更适用于大多数解决方案，而不仅仅是少数几个。
此外，uWSGI 非常关注过程控制。流程很容易管理，也非常容易控制。此外，您可以访问竞争对手的库中通常看不到的更低级的选项。
然而，尽管 uWSGI 具有所有的可扩展性和多功能性，但它也有一些缺点。我发现它比 Gunicorn 甚至 GEvent 之类的东西要难用得多。虽然我必须承认，我只是最近才开始使用它，它似乎有一个陡峭的学习曲线和一个比这个列表中的任何其他人更大的进入壁垒。
最后的想法
将与您的模型或全栈应用一起部署的 web 服务器是一个需要考虑的非常重要的事情。无论您的应用程序是轻量级的、需要身份验证的还是仅仅是一个简单的端点，都是决定哪一个服务器最适合您的特定情况的因素。对于我个人来说，我通常会选择 Gunicorn3。这部分是因为它与 Flask 和 NGINX 合作得非常好，但也是因为它的轻量级性质，这是我在使用 Python 进行 web 开发时所寻求的。这当然是因为我的大部分 web 部署是在端点的特定用例中。然而，我也用 GEvent 部署了一些很棒的 web 应用程序，它在那些环境下工作得相当好。通常我会使用 Gunicorn 作为端点，使用 GEvent 作为全栈应用。不管哪个选项适合您的用例，幸运的是大多数部署场景都有不同的选项，这使得讨论起来更有趣！
我最喜欢的数据科学面试问题
雇佣一名数据科学家
一个问题可以引出比一个简单的答案更多的东西。
我最近花了很多时间思考我们在技术领域的招聘方式。我专注于数据科学。我经常在面试过程中问自己，一个好的数据科学家是什么样子的？数据科学技能组合:
- 数据分析
- 数据可视化
- 数据工程
- 机器学习
- 项目管理
- 软件工程
其中软件工程是基础，其他都是支柱。作为一个行业，我们应该分担这些责任，但我们还没有做到。因为我们需要如此广泛的技能组合，所以很难在面试过程中深入涵盖所有支柱。
面试问题的目的是揭示应聘者的工作能力。复述被误解的事实的能力几乎没有用处。面试官需要剖析应聘者的个性和工作方式。一个好的问题应该揭示上述支柱中的技巧。任何技能水平的考生都应该有给出好答案的可能。
克里斯蒂娜@ wocintechchat.com 在 Unsplash 上的照片
对于软件工程和数据操作在其数据科学家中的必要性，业界似乎存在分歧。如果没有软件工程师来实现他们的想法，数据科学家就无法在孤岛中提供价值。
因此，我最喜欢的机器学习和数据科学面试问题是:
“你对林挺有什么看法？”
这个问题将展示一个人作为软件工程师的成熟度。一个不知道林挺是什么的候选人，得到了一个展示学习意愿的机会。
这个问题和数据无关。还是一个很棒的问题，满足以上要求。
你的候选人可能会说
“我对林挺没有看法” —这不是一个好答案，会让我非常担心。
我从来没听说过林挺，但你能告诉我吗面试官有机会分享他们对林挺的看法。如果面试官很好地定义了林挺，应聘者可以继续提问。您可以继续询问更多问题:
- 你认为这对个人有什么好处？
- 你认为这对团队有什么好处？
- 你认为林挺弊大于利吗？
“我知道林挺是什么，我想 X，Y，Z”—这位候选人是一位成熟的软件工程师。在他们知识的一个方面遵循好的实践表明他们会遵循其他方面。
这个问题比大多数技术问题更能揭示个性和编程技巧。在这里，任何表现出好奇心的人都能学到这项工作所需的任何东西。这就是面试的目的。
总而言之，在招聘时，我们寻找的是与团队相适应的文化。这是一个奖金，如果他们已经知道我们需要的技能。如果他们还不知道这些技能，那么他们需要有正确的心态来开放和改进。
Scrapy 中我最喜欢的三个新特性
找出 scrapy 在 2.2 版本中提供的新的网页抓取功能
Scrapy 的新版本上周刚刚发布！在这篇文章中，我将深入探讨 2.2 版本中框架的变化，以及 Scrapy 为您的网络抓取需求提供了哪些很酷的新功能！
有关可用内容的详细信息以及对这些已实现功能的讨论，请参见发布说明此处。
在本文中，您将了解到
- 如何直观地用 scrapy 处理 json
- 你能从一个文件管道中得到什么信息关于你下载的文件。
- 类型提示和 Scrapy
新的零碎功能
去序列化 JSON 响应
Scrapy 现在有能力直接从提供 json 数据的网站上解码 json。在此之前，我们必须使用 python 内置的 json 包。这个新特性受到了请求包方法requests.json()的影响。
Scrapy 现在可以直接从服务器响应中解码 json 作为 python 对象。在幕后，Scrapy 导入标准库 json 包并调用json.loads()方法。该方法将获取一个 json 字符串，并将其转换成 python 字典。有关 json 库的概述，请参见这里的。
让我们看一个 scrapy shell 中的例子
>>> fetch('[https://api.github.com/events'](https://api.github.com/events'))
2020-06-27 07:16:38 [scrapy.core.engine] INFO: Spider opened
2020-06-27 07:16:38 [scrapy.core.engine] DEBUG: Crawled (200) <GET [https://api.github.com/events](https://api.github.com/events)> (referer: None)
>>> data = response.json()
>>> print(data[0])
{'id': '12750675925', 'type': 'CreateEvent', 'actor': {'id': 51508147, 'login': 'LLGLSS', 'display_login': 'LLGLSS', 'gravatar_id': '', 'url': '[https://api.github.com/users/LLGLSS'](https://api.github.com/users/LLGLSS'), 'avatar_url': '[https://avatars.githubusercontent.com/u/51508147?'](https://avatars.githubusercontent.com/u/51508147?')}, 'repo': {'id': 275306349, 'name': 'LLGLSS/hsshoping', 'url': '[https://api.github.com/repos/LLGLSS/hsshoping'](https://api.github.com/repos/LLGLSS/hsshoping')}, 'payload': {'ref': 'llg', 'ref_type': 'branch', 'master_branch': 'master', 'description': None, 'pusher_type': 'user'}, 'public': True, 'created_at': '2020-06-27T06:11:39Z'}
- 在 scrapy shell 中，fetch()类似于 HTTP GET 请求，它获取经过解析的 html。
- 现在，如果这个响应是一个 json 字符串，那么 response.json()方法会将 json 解析到一个字典中
这使得处理 json 比以前更加流畅，太棒了！继续前进，在你的新的网络抓取项目中使用它。
下载文件的状态
当使用 Scrapy 下载一个文件时，你会使用所谓的文件管道。管道只是 http 请求将经历的一系列操作，这些操作要么被处理，要么不被处理。
尝试下载文件或完成下载文件后，文件管道填充包含文件路径、校验和等信息的字典。当文件管道完成时，关于下载的信息存储在一个名为results的变量中，该变量包含一个 2 元素元组列表(success, file_info_or_error)。
success变量要么取真值，要么取假值，而file_info_or_error变量是关于这个文件的信息字典。
如果success变量为真。一个名为status的file_info_or_error字典的新键现在已经被添加，它告诉我们我们的文件是否已经被下载。该状态键可以取三个值之一
- 下载
- 已更新—文件未被下载，因为它最近被下载过
- 缓存—文件已经计划下载
如果success变量为假，这意味着文件还没有被下载，并且file_info_or_error字典会忽略这个错误。
文件管道创建的results变量的一个例子是这样的。
[
(True, {'checksum': '2b00042f7481c7b056c4b410d28f33cf', 'path': 'full/0a79c461a4062ac383dc4fade7bc09f1384a3910.jpg', 'url': 'http://www.example.com/files/product1.pdf'}), 'url': 'http://www.example.com/files/product1.pdf', 'status': 'downloaded'}),
(False, Failure(...))
]
- 第一个元组显示在这种情况下文件被成功下载
success = true - 第一个元组的第二项给了我们
file_info_or_error字典，告诉我们这个下载的文件。 - 第二个元组显示了
success = false，并开始在file_info_or_error变量中提供解释。
当您创建自己的下载管道，并希望检查文件的状态或记录有多少文件没有下载以及具体原因时，这将非常有用。
为了在您想要下载的文件上使用这些信息，有必要创建您自己的管道。为此，我们创建了一个覆盖 pipeline 类 scrapy 提供的文件的函数，这些函数写在 scrapy 项目的 pipeline.py 中。有关如何解决这一问题的更多信息，请参见此处的。
然后你可以覆盖在filepipeline类中找到的名为items_complete()的方法，用 scrapy 下载文件。该方法将results变量作为参数。然后可以访问这些文件，每个文件中的信息可以用于您自己的管道需求。
https://unsplash.com/@kellysikkema
杂乱和类型提示
Scrapy 的新版本要求安装 Python 3.5.2 及以上版本，框架才能运行。你可能会问为什么会这样？Python 3.5 版本引入了一种叫做类型提示的东西，它的意思就是你所认为的意思！类型提示是一种将类型对象信息添加到语言中用于注释目的的方法。
为了理解为什么这很重要，请看这个函数。
def send_request(request_data,'#]
headers,
user_id,
as_json):
DOING SOMETHING
RETURNING SOMETHING
与…相比
def send_request(request_data : Any,
headers: Optional[Dict[str, str]],
user_id: Optional[UserId] = None,
as_json: bool = True):
看看知道输入是什么以及函数中返回内容的可能性是多么容易。为什么发音变得清晰，我们确切地知道输入是什么，输出会是什么。Python 作为一种语言的起源是一种叫做动态类型语言的东西。也就是说，Python 直到运行时才知道对象类型，因此不适合在代码库中注释类型。
类型提示是一种使代码库更容易阅读和维护的方式，有人建议 Scrapy 应该为框架的新贡献者提供这种方式。Scrapy 中的类型提示是为了使代码可维护，因此 Python 3.5.2 版的要求是允许 Scrapy 代码库被类型提示。
请点击此处查看我的博客和其他帖子中关于项目的更多细节。更多技术/编码相关内容，请点击这里订阅我的时事通讯
我将非常感谢任何评论，或者如果你想与 python 合作或需要帮助，请联系我。如果你想和我联系，请在这里或者在推特上联系我。
相关文章
今天如何最大限度地学习 python
towardsdatascience.com](/approach-to-learning-python-f1c9a02024f8) [## 如何从脚本运行 Scrapy
忘记 scrapy 的框架，全部用使用 scrapy 的 python 脚本编写
towardsdatascience.com](/how-to-run-scrapy-from-a-script-ff07fd6b792b) [## 使用 Scrapy 进行有效的网页抓取
Scrapy 的新功能使您的刮削效率
towardsdatascience.com](/efficient-web-scraping-with-scrapy-571694d52a6)
我最后一个数据分析师面试问题:你最喜欢的 Python 包是什么？
这个问题的答案告诉你更多你可能会想到的求职者
在 Unsplash 上由 Adeolu Eletu 拍摄的照片
你是我的独角兽吗？
很难找到合格的数据分析师来担任需要不同技能和专业知识的角色。一个角色需要很强的 A/B 测量背景。另一个角色需要对十亿行数据进行清理、分析和呈现洞察的能力。对于所提供的职位级别，商业、技术、统计和演示人才的最佳组合是什么？即使招聘经理确切知道什么样的技能组合会带来成功，也很难找到符合所有条件的候选人。这就让面试小组去探究候选人的长处和短处。
憎恨秘密数据的人
我面试过从大型机 DB2 到高级分析的数据职位的申请人。早些时候，我发现了一些非常有趣的事情。一些面试这些职位的人实际上并不喜欢数据。作为一个数据极客，我很困惑。作为数据主管，我很担心。简洁的代码和面试问题的正确答案是不够的。我需要弄清楚谁喜欢他们的工作。谁有勇气克服错误以获得工作产品？
P
随着时间的推移，我磨练了自己的面试技巧，包括激情、好奇心和毅力。经过两个小时的面试、案例演示和代码提交，如果候选人展示了适当的编码能力，并且该职位包括 python 编码，我会提出这个问题。
“你最喜欢的 python 包是什么？”
你最喜欢的 python 包是什么？这似乎是一个简单的问题。有些人可能会想一个愚蠢的问题。非数据面试小组成员可能会窃笑。听起来像是一个轻抛的问题，来释放过去两个小时的紧张。对我来说，这是整个面试中最重要的问题。通过一个问题，我不仅了解了他们对 python 的经验水平，还看到了他们的热情和好奇心。
激情与好奇
我的一些最好的候选人没有列出古怪的软件包，但他们可以热情地与那些他们想学习的人交谈。当被问及这个问题时，那些充满激情的人变得兴奋起来，争先恐后地挑选他们最喜欢的。大多数人不仅列出了他们的最爱，还解释了他们为什么喜欢它们。
毫不奇怪，最常被提及的是熊猫。向熊猫致敬。这是一块石头。
轮到你了
那么，你最喜欢的 python 包是什么？
对于数据科学家来说:你的签名种子值是多少？
我关于使用机器学习进行体育博彩的发现:博彩公司总是赢吗？
一个幼稚的金钱至上的想法？
凯文·Ku 在 Unsplash 上的照片
一天下午，在我度假期间，我想到了使用机器学习来预测英超联赛的足球结果。我自己从来没有赌过体育，因为我不喜欢把钱挥霍掉，我就是这样做的。然而，我有这个想法。我想，如果我能设计一种算法，使我的准确率超过 60%，我就可以分散风险，在多个匹配上下注，从而获得持续的收入。
我想了下，如果我以 100 英镑(我住在英国)开始，在 10 场不同的比赛中下注 10 英镑，我可能会在 10 场比赛中赢大约 5 场。如果我确保有一个可靠的算法，我想我可以赚一大笔钱。这里是重要的部分，我从来没有下过赌注，我不知道博彩行业的细节和复杂性。我知道我必须做我的研究，以更好地了解我错过了什么。
我知道我错过了一些东西；我不可能是第一个想到这一点的人，这从来都不容易。我继续做了一个小调查，以更好地理解我能找到的关于这个话题的东西。结果非常有趣，因为我发现了事情的真实运作方式。
首先，我找到了几篇期刊论文，这让我能够收集一篇关于这一领域的小型文献综述。是的，很明显，这是一个完整的研究领域，人工智能领域的专业人员将他们的时间和精力投入到改进他们的机器学习(ML)模型中。根据 Bunker 等人(2019) 的说法，虽然有几项研究考虑了统计体育预测，但使用神经网络范式是一种更近的方法。
在我的研究中，我发现了不同运动的各种算法的准确率:
Purucker (1996) 使用神经网络模型对国家橄榄球联盟(NFL)的结果实现了 61%的预测准确度。
Kahn (2003) 扩展了 Purucker (1996)的工作，在 NFL 第 14 周和第 15 周的比赛中实现了 75%的准确率。为此，收集了 2003 赛季 208 场比赛的数据。
McCabe 和 Trevathan (2008) 使用 2002 年的数据研究了四种不同运动的运动预测，即 NFL(橄榄球联盟)、AFL(澳大利亚规则足球)、Super Rugby(橄榄球联盟)和英格兰超级联赛足球(EPL)。神经网络算法的平均性能为 67.5%。
Davoodi 和 Khanteymoori (2010) 试图利用 2010 年 1 月在纽约州举行的渡槽赛道上的 100 场比赛的数据来预测赛马的结果。虽然 Davoodi 和 Khanteymoori (2010 年)开发的算法需要详尽的训练时间，但它达到了 77%的准确率。
Tax and Joustra (2015) 利用荷兰足球比赛的数据预测未来比赛的结果。在这种情况下，作者还考虑了赌博赔率作为他们机器学习模型的变量。他们的模型达到了 54.7%的准确率，而只使用赔率的模型达到了 55.3%的准确率。这个事实让我意识到一些事情。博彩公司有自己的数据科学团队。如果一个队赢的几率是 10/1，那么这个队可能会输。
作者图片:每项运动 ML 预测模型的准确性——改编自文献综述
在发现之前的研究中算法的准确性在 50%到 70%左右(取决于运动项目)后，我仍然认为如果比赛的赔率至少为 2/1，这将是可行的。
找出为什么没有人用这个成为百万富翁
在写第一行代码之前，我下定决心要弄清楚这是否真的可行。在某种程度上，我认为使用你自己的算法可能是不合法的，一个简单的谷歌搜索回答说这是允许的。然后我想到了博彩公司，以及他们如何监管或限制你可以下注的金额。我找到一篇名为 " 用自己的号码击败庄家——以及网络体育博彩市场如何被操纵2017 "。
这篇论文是我的研究停止的地方。本文解释了作者如何试图使用他们的算法来赚钱，并发现了两个主要障碍。首先:
- 博彩公司使用自己的机器学习算法来生成比赛的赔率。
因此，当你的 ML 模型把你指向更确定的结果时，你可能总是以低收益结束。第二，更重要的是:
- 庄家歧视成功的客户。
因此，当你开始经常赢的时候，庄家会开始歧视你，限制你可以下注的金额。
除了这两个障碍，我发现的论文解释说，在 5 个月的时间里，他们在 672 次下注中赚了 2086 美元，回报率为 6.2%。这很好(相对于你必须投入的努力量来说不是那么好)，但这是一项艰苦的工作。你必须投入大量的时间和精力来下很多注，并承受被庄家标记的风险。
我的结论是，开发体育博彩的 ML 模型只对实践和提高你的数据科学技能有好处。你可以把自己做的代码上传到 GitHub，完善自己的作品集。然而，我不认为这是你可以长期生活方式的一部分。因为最后庄家永远不会输。最终，我在这个项目中没有做一行代码。我希望我的文献综述有助于说明其他人。
跟着我上 LinkenIn
关注我的 LinkenIn 页面: AI Makers
我的第一次数据科学竞赛
从一无所知到成为全国决赛选手
2020 年 2 月中旬，我的朋友 Mario 和我谈到了学士和硕士学位学生最重要的全国数据大赛。那时我大二，他大三，两人都来自巴伦西亚理工大学的计算机科学专业。
更重要的是，我们对数据科学和人工智能一无所知。
于是，我们报名参加了大赛，开始学习 Python，机器学习的基础理论，用在线教程大量练习。
我们选择的挑战是敏赛土地分类。目标是建立一个多类分类器来确定给定楼层面积的类型。检验模型的指标描述如下:
训练数据由 55 个变量组成:
- 标识符:每个区域的唯一 ID。
- 坐标:两个变量，X 和 Y，描述平面上每个区域的位置。
- 颜色变量:红、绿、蓝和红外通道各 11 个变量，描述十分位数。
- 面积:以平方米为单位的延伸。
- 几何变量:给出几何信息的 4 个变量，没有任何说明。
- 小农场建造年份。
- 给定地块中当前建造的最大高度。
- 土地登记标识符:表示区域的质量。它接受范围[A，B，C，1，2，3，4，5，6，7，8，9]内的值；做一个最坏的人，做一个最好的人。
- 类:要预测的目标。有 7 个不同的类别:住宅、工业、公共、办公、其他、零售和农业。
测试数据只包含特性。
为了提交我们的结果，我们必须对测试数据运行我们的模型，并以 AREA_ID | PREDICTED_CLASS 的形式发送预测。
如果两个队在准确性上的差异小于 5%,这将被视为平局。在这种情况下，法官会考虑诸如代码文档和破解代码的演示等因素。
只有前 3 名的队伍才能到达马德里(由于新冠肺炎危机，他们后来不得不取消)，并赢得:
- 第一名，每队 6000€。
- 第二名，每队 2400€。
- 第三名，每队 1200€。
第一个问题很快就出现了。
最大高度和土地登记质量的特征具有一些空值。我们将它们设置为-1。然后，我们检查了训练集上的类分布，发现了以下情况:
图片来自 2020 年 Astralaria.pdf。由阿西尔·塞拉诺·阿兰布鲁和马里奥·坎波斯·莫乔利执笔
非常不平衡！居住类特征占 87.28%，而农业类特征仅占 0.33%。
此外，通过比较训练数据集和测试数据集之间每个特征的平均值，我们发现:
- 训练组的住宅平均面积为 281 平方米，其余组均大于 1000 平方米。总平均值为 4.41 亿英镑。
- 测试集的总平均值为 967 米。
因此，我们可以知道两个数据集之间的类分布是不同的。
这就是我们如何发现两个主要缺点的。
我们花了第一个月的时间阅读机器学习的基本概念、不同类型的学习，特别是监督方式、线性回归、二元分类、多类分类……此外，我们还必须学习 Python，幸运的是这很容易。
一旦我们认为我们已经理解了我们的使命和我们的选择，我们就开始着手解决这个问题。
在尝试了几种分类模型后，我们发现结合 XGBoostClassifier+RandomForestRegressor 会给出最好的结果，并且为了处理随机性，我们进行了各种时间的训练，并最终通过共识分配每个类，同时考虑到模式。我们还必须处理不平衡的问题，所以我们决定只随机挑选 8000 个住宅类样本进行训练。使用 gridsearch 调整一些超参数，我们都准备在 Jupyter 笔记本上发送我们的最终提交。
几天后，最终结果出来了，我们达到了 69.999%的准确率，是当时全国最好的成绩。我们很亲密。
我们成为了大学冠军和西班牙决赛选手！astraria队在比赛中还活着！
是时候抓紧时间了。然后我们意识到我们的对手比我们年长得多，也更有经验。事实上，其余的团队是由数据科学的硕士研究生组成的，甚至他们中的一些人已经在从事这项工作了。
因此，如果我们想获得一个好职位，我们必须开始寻找有趣的数据见解，并尝试新的模型。
我们认为，可视化工具可以帮助我们更容易地找到区分阶级的模式。因此，我们研究了主成分分析和 T-SNE 降维，以及每个特征的小提琴图。这些是我们获得的揭示的结果:
图片来自 2020 年 Astralaria.pdf。由阿西尔·塞拉诺·阿兰布鲁和马里奥·坎波斯·莫乔利执笔
图片来自Astralaria.pdf， 2020。作者:Asier Serrano Aramburu 和 Mario Campos Mochol
所有的类都有很多重叠，我们找不到任何模式或组。
在此之后，我们尝试对数据进行一些小的更改，这似乎对我们的结果有所改善:
- 将土地登记质量特性转换为 12 个热点变量。
- 将建造年份改为古代的年数。
- 将空值更改为 0，而不是-1。
我们仍然有许多事情要尝试，我们只有不到一个月的时间用我们普通的笔记本电脑进行一些实验。
我们就是这样分工的。
Mario 会尝试使用自动编码器来降低维度，用神经网络建立一些奇特的模型，并测试额外的树和支持向量机如何能够有所帮助。
我将致力于过采样和欠采样技术，一个对一个——数据平衡算法，和特征工程。
经过大约两周的研究和实验，我们认为我们找到了一些东西。
我的同事测试并确认了我们可以使用的最好的 ML 模型是我们一直在使用的两个模型。在我身边，我有两个直觉。
- 邻居。如果一个地区是住宅区，它的邻居不会占多数，也是来自同一个阶层吗？根据这个想法，我们构建了一个 K-D 树，它将确定每个区域的 4 个最近邻居(在训练数据集中)，或者某个类的邻居的概率(在测试数据集中)。这个过程增加了 7 个特征的维数，每个类别一个。
- OAA-DB 算法。如上所述，起初它给我们留下了深刻的印象，因为它将结果提高了约 10%，但我们最终放弃了它，因为它导致了巨大的过度拟合。
我们还试验了深度特征合成、和其他一些工具，但是只有邻居技术似乎工作得很好，它似乎提高了大约 1.5%的精确度。
我们只剩下一件事需要确定:用于减少训练集中住宅类样本数量的欠采样技术。我们试验了所有的 imblearn 包方法，然而，我们最终决定进行随机欠采样，减少到 6000 个样本。几乎和我们开始时一样。
任务日。我不会忘记的。截止时间是 13 点。几乎一切都准备好了。我很早就醒了，来结束文档的细节。马里奥稍后会加入我。
我们仍然没有生成结果。
10:30.我已经写完了代码，并把笔记本递给了 Mario。
10:40.后面的 Json 文件出了个 bug，我们没看懂。我的同事试图在 Visual Studio 代码、Google Colab 和 Jupyter 中打开它。但是什么都没用。
11:00.新笔记本。还是同样的问题。
11:35.Python 脚本生成，包含两个部分，并有文档记录。马里奥不能执行它。
12:15.Mario 最终能够运行脚本来训练模型并获得结果。然而，我们不知道它是否会及时结束。但我们无法阻止它。
是时候相信运气了。
12:53.节目结束了！
12:58.结果文件已发送。我们成功了。
两个星期后，最佳的三支队伍揭晓了。我们没能进入前 3 名。我们最终没有赢得任何奖项。
一开始，我们真的很难过。然而，我们认为我们已经走了很远，特别是考虑到我们是从一无所知开始的。
此外，该组织告诉我们，他们稍后会通知我们我们的最终位置，以及上次交付的准确性和一些改进的技巧。
几周后，它来了。
我们获得了第四名！此外，由于其余队伍都是由硕士生组成，我们可以被认为是学士级第一名！
我们感到非常高兴，即使我们没有获得任何现金奖励，我们也能够学到很多东西，玩得开心，并发现了数据科学和人工智能的惊人领域！
就我个人而言，我必须感谢我的队友和比赛的组织者，是他们让一切成为可能。
给这篇文章的读者:如果你仍然对某个领域一无所知，不要担心，付出它应得的努力，学习，即使你是通过参加一个竞赛来做到的。
点击查看我们的最终作品。
感谢阅读！😄
我作为计算机视觉工程师的第一天
剧透:我引起轰动
斯科特·韦伯在 Unsplash 上拍摄的照片
我最近在伦敦的一家初创公司找到了一份计算机视觉工程师的工作。
得到这个角色的过程是令人兴奋的，但那是以后的事了。在这篇文章的最后，我为好奇的读者留下了一篇关于我一次失败面试的文章。
但是今天，我将谈谈我第一天工作的情况。
我会包括一些关于团队介绍的细节，我将从事的计算机视觉领域，以及我是如何让自己难堪的——别担心，我第一天并没有丢掉工作。
我还将包括一些有抱负的机器学习实践者可能会发现有用的技巧和建议。
兴奋/早上好
在 2019 年 9 月完成计算机视觉、机器学习和机器人学硕士学位后，我休了几个月的假，并在 2019 年 12 月开始找工作(12 月不是找工作的好时机，许多公司都在休假)。
现在，我终于得到了一个计算机视觉工程师的职位。
我对我正在工作的初创公司的潜力以及我能给团队带来的贡献感到兴奋。
来自 Tenor.com的 gif
在我开始约会的时候，我醒得特别早，比我应该醒的时间早了两个小时。
是纯粹的兴奋唤醒了我。感觉就像开学第一天。
我的兴奋被伦敦地铁的早晨通勤暂时打断了。
伦敦早晨的通勤很糟糕，我认为我永远也不会习惯。
来自伦敦的读者知道我在说什么(我确信拥堵的早晨通勤是一个全球现象)。
让我们快进到我进办公室的时候。
今天的第一项议程是介绍和问候。
这是一个认识我的新团队成员的机会。认识新的人很可怕；我总是努力给人留下极好的第一印象，尽量不说或不做任何愚蠢或怪异的事情。
我成功地度过了第一天的这一部分。
介绍进行得很顺利，而且我已经在 LinkedIn 上跟踪了公司里的大多数人，知道他们的职业和教育背景，这也很有帮助。
建议:了解你未来同事的网上职业资料。调查他们做过什么项目，或者他们以前在什么公司工作过。这能让你建立起初步的融洽关系。
中午
我工作的新公司在游戏和增强现实行业运营。我的角色是在 AR 环境中实现和集成计算机视觉技术。这与我习惯的用图像文件夹进行任意分类大不相同。
但是潜入未知领域是一种被证明的扩展知识和战胜职业停滞的方法。AR 再次变得很酷也是有帮助的。
【giphy.com AR gif
经过介绍和聊天，我启动了我的机器。
我过去工作过的大多数公司在新员工入职的第一天都没有准备好机器，但谢天谢地这家公司有。
我的机器都准备好了，我开始下载一堆软件和工具。你可以在任何一个 ML 工程师的武器库中找到典型的工具。
常见 ML 工具的校对图像
你懂的钻，安装 Git ， PyCharm ， JupyterLab ， Anaconda ， TensorFlow ， PyTorch ， SciPy ， TensorBoard ， OpenCV 等等。作为一个机器学习从业者，你可能熟悉我刚才提到的百分之九十的工具。
建议:不要害怕走出你的舒适区。机器学习技术适用于各种行业。在选择寻找机器学习工作的行业时要非常开放。
我现在可以回家了吗？
我一天中的这一部分并不有趣。
记住它也不好玩，事实上，写它也不好玩。
但我说过我会提供所有的细节，我会的。
开始了…
午餐时间到了，我出去买了些豆腐、米饭和花生酱(你可能不需要知道我午餐吃了什么 lol ) 。我一般都是一个人吃饭，琢磨宇宙的奥秘，但是第一天，宇宙可以等。
所以我选择和我的新团队在一张共享的桌子上吃饭，桌子上放着每个人的笔记本电脑和电子设备— 你能看出我要说什么吗。
经过 20 分钟的聊天、欢笑和大声咀嚼之后，我终于伸手去拿我那满满一杯水。
当我伸手去拿杯子时，突然，我的手眼协调和大脑计算拿杯子应该用多大的力似乎失灵了，我打翻了那杯水。
我不骗你，但我亲眼目睹了这一事件的缓慢发展。
当水迅速蔓延到整个桌子，到达每个人的笔记本电脑和设备，并找到通往延长线的路时，我的脸上充满了恐惧。
我大叫(说实话我其实是尖叫了)。
每个人都从椅子上跳起来，放下午餐，走到他们能找到的最近的纸巾和毛巾旁。这一切都像一些现实游戏节目活动。
最后，一切都变得很好，笔记本电脑和手机被擦干了，地板被打扫干净了，我们都只是一笑置之。谢天谢地，我的新队友有点宽容。
建议:如果你像我一样笨手笨脚，那就在第一天上班前，先练练吃喝。这里明显是开玩笑。
下午
在午餐的兴奋过后，我的身体从正在发生的事件中获得了肾上腺素的刺激，我准备好回去工作了。
在我的第一天之前，我一直在与该公司的首席执行官/首席技术官沟通，以了解他们对我作为一名计算机视觉工程师的要求。
我知道他们的长期愿景是什么，我也知道我要实现什么。
考虑到公司的目标，我的下午继续探索研究论文和 GitHub 知识库，内容涉及姿势估计、手跟踪和对象检测等技术。我还研究了如何在移动设备和增强现实环境中利用这些 CV 技术。
这是我写的一篇短文，解释了一些你可能在工作环境中遇到的常规简历技巧。
了解如何使用机器和深度学习技术应用和实现对象检测
towardsdatascience.com](/how-does-ai-detect-objects-technical-d8d63fc12881)
人工智能是一个迷人的领域，每天都在推进被认为是可能的事情的边界。作为人工智能爱好者和实践者，我们喜欢阅读和研究人工智能相关的话题。但是在实际环境中，真正重要的是将这些技术设计成商业应用程序的能力，这些应用程序将被数百人甚至数千人使用。
因此，我的第一天让我明白，作为一名计算机视觉工程师，我的工作分为 70%的工程 CV 技术和 30%的研究。我对这种平衡感到满意。
建议:在确定一份长期工作之前，要明白 10 年后你的职业目标是什么。
建议:在实际场景中练习运用 ML 模型。将 ML 模型部署为移动和 web 应用程序，并考虑人们如何使用您的 ML 模型。
建议:了解你即将加入的公司或组织的愿景，知道你和你的技能适合哪里。
建议:在开始工作之前，对你将要从事的工作进行研究是很有帮助的，因为这将向你的同事传达你的奉献精神和动力。
傍晚/一天结束时
由于清楚地了解我的角色需要什么，以及我将使用什么技术，我有了一个坚实的基础。
那天快结束的时候，我做了一些文档和管理工作。没有写代码，也没有阅读研究论文，但这一部分和我一天中的任何部分一样重要。
我观察了一下我想在什么样的环境中工作，我的结论是我想在一个角色的一切(或至少 90%)都有记录的环境中工作。我指的是一切，包括关于硬件和软件规范的文档，关于在应用程序中使用什么机器学习技术的文档，以及关于机器学习工作流程的文档。
所有这些都很重要，因为它让我的队友和未来的我更容易理解和解释我的工作。如果我回顾以前的工作或决策，文档会派上用场。
随着文件夹和文档的创建，我对自己作为计算机视觉工程师的第一天所取得的成就感到满意。
开始第二天！
但是明天我会独自吃午饭，远离所有的电子产品。
获得目前的角色并非一帆风顺。我遇到的一个陷阱的一个很好的例子可以在下面链接的文章中看到。
此外，如果你喜欢这篇文章，并希望更多，给我一个关注。
拒绝是获得数据科学工作的整个过程的一部分。但它并不经常被提起。这是我的账户…
towardsdatascience.com](/rejected-from-my-first-data-science-interview-c9784dd65296)
我和朱莉娅的第一次相遇
带朱莉娅去试驾
抓挠着朱莉娅和冥王星的表面
我开始在网上学习一门课程，是通过朱莉娅教授的。尽管我以前没有使用 Julia 的经验，但对我来说很容易快速学会一些东西——因为我以前有编程经验，而且最重要的是—Julia 被设计成易于编写。
布鲁托:写作《朱丽亚》的审美环境
朱莉娅通过 REPL 在命令行工作。我听说 Visual Studio Code 对 Julia 的扩展也很棒。但是最好使用冥王星来完成像图像分析这样的任务，并且能够获得即时反馈对它非常有帮助。
冥王星接口。来源:作者
Pluto 界面真的很好看，选的字体我也很喜欢。
Pluto 有一个方便的 Live docs 功能。您只需将光标放在一个函数或对象内，如果您单击 Live docs 图标，就会显示该特定函数或对象的文档。
在这里，我将光标放在了rand方法上，我看到了这样的文档
rand()文档，来源:作者
你必须在 Jupyter 笔记本上输入??function()才能获得文档。
Julia 中的表情符号支持
Julia 不仅支持字符串形式的表情符号，还支持命名变量！
从给定列表中生成表情符号的随机组合，来源:作者
用表情符号命名变量，来源:作者
看到了吗？在 Julia 里可以用表情符号给变量命名！
使用图像
在 Julia 中处理图像非常直观。您可以从 web 或本地存储中加载图像，并在 Julia 中使用该图像。
朱莉娅的不同之处在于，在这里，你与图像本身一起工作。在其他语言中，会创建一个图像对象或类似的东西，或者我们必须处理文件的路径。但是这里增加了一个更深层次的抽象，你可以直接处理图像本身。让我展示给你看:
首先，你从本地存储器加载或者下载到本地存储器，然后加载一个图像
从网上下载图片并在 Julia 中使用，来源:作者，原始图片来源
我还下载了一张黑线鳕的图片。让我给你看看我做了什么。
丁丁和黑线鳕的随机排列，来源:作者，黑线鳕原始图片来源
我只用一行代码就用一些图像生成了一个 2D 数组！我对此很着迷。
进一步图像处理
在 Julia 中处理图像非常直观和容易。
您可以像对待其他编程语言中的任何其他元素一样对待图像和图像的一部分。
让我展示给你看。但在此之前，我想让你知道 Julia 附带了一个RGB“颜色空间”,它允许你将一种颜色存储到一个变量中，并在其他地方使用它。
使用 RGB“色彩空间”，来源:作者
我下载了这个人的照片并存储在一个变量中:
将 Good-Boi 存储在变量中，来源:作者，原图来源
你可以通过 Julia 很容易地得到尺寸和裁剪。
这里有趣的是，你可以访问每个像素或一组像素，并随心所欲地操纵它们。
对一组像素的操作，来源:作者
这里，我只是取了一些像素，给它们赋值红色，这是一种颜色。它是如此简单和无缝。
你可以做更多有趣的东西，比如制作蓝光过滤器。
一个减少图片中蓝色量的函数，来源:作者
我写了一个函数，应用到图片上。很简单。像这样的函数也可以应用于一组图像，这使得它在计算机视觉训练集中的数据扩充中非常有用。计算机视觉问题可能还有其他有趣的应用。
像对待变量一样对待图像
你不仅可以毫不费力地在 Julia 中进行像素级操作，还可以用多种方式操纵它们。
堆叠图像，来源:作者
仅仅通过跑步-
[
head reverse(head, dims=2)
reverse(head, dims=1) reverse(reverse(head, dims=1), dims=2)
]
你可以创造这个—
堆叠镜像和反转图像，来源:作者
我再次看到了这在深度学习中神经网络训练的增强变换中的应用。
同步更新
作为 Jupyter 的用户，我不禁注意到
在 Jupyter Notebook 中，直到你运行一个单元格，单元格中的内容(变量、方法、类等)发生变化。)不要被反射。
但是布鲁托和朱莉娅会自动这么做。
GIF 展示同步更新，来源:作者
现在，这是一个更加微妙的问题。对我来说，陪审团仍然不知道这是否会有所帮助。
强大的 PDF 转换支持
您可以将 Pluto 笔记本转换为 PDF，而不会有任何重大损失。Pluto 对 PDF 的支持值得称赞。
如需完整代码(并查看 Julia 创建的完美 PDF 文件)，您可以下载这里涉及的两个笔记本(Dropbox 链接)—
缺少捷径
我可以在木星周围移动而不用碰鼠标，但这在冥王星是不可能的。快捷键很少，鼠标是不可或缺的。我不能说我喜欢冥王星的这一点。但是看起来他们正在努力。
软件包管理器
Julia 有一个简单有效的包管理器，可以从 Pluto 内部和命令行访问。
我更喜欢命令行，任何时候。
从命令行管理包，来源:作者
结论
如您所见，我在这里仅仅触及了皮毛。我只用了茱莉亚和布鲁托一天。并且分享了自己经历过的，喜欢的，不喜欢的。
还有很多(如果不是全部的话)留给我去探索。我很期待！
你可以看看麻省理工学院的 TEDx 演讲，其中一位联合创始人分享了他对这门语言的愿景。
与我联系
和平！
我的第一份谷歌云数据流 ETL 工作
我是如何在没有任何经验的情况下在 Python 和 Google Cloud 函数上使用 Google Cloud Dataflow 编写一个简单的 ETL 作业的。
最近，我被聘为门户网站 Telemedicina 的数据工程师，这是一家帮助每个人提高健康质量的神奇公司。在我学习新职位的过程中，我发现大数据工具实在太多了。因为我从来没有做过数据工程师，所以我在选择大数据工具来运行 ETL(提取转换加载)作业时有些纠结，就像这只可怜的狗一样。
幸运的是，我参加了一个讲座，Resultados Digitais 的数据工程师 Thiago Chiarato 正在谈论无服务器解决方案，以及我们如何通过不必担心服务器维护来提供更多服务。他告诉我们他是如何通过 Google Cloud Dataflow 做到这一点的，这是一个无服务器的 Apache Beam 解决方案。
回到门户网站 Telemedicina， Gabriel ，一位和我一起在研讨会上的同事，说服团队数据流可以解决一些问题。因此，我们决定花一周时间进行概念验证(PoC ),以检查 Google Cloud Dataflow 是否真的符合我们的需求。这并不难，因为我们已经在谷歌平台上了。作为 PoC，我们选择使用数据流将巴西城市及其人口的列表上传到 Big Query。
我们开发的两个代码( pocdataflow.py 和 cloudfn.js )都在一个 Github Gist 里。
谷歌云数据流
为了学习如何使用 Apache Beam，我们找到了一些很好的教程，比如这个使用 cloud pub/sub 作为“Hello Beam”。经过一些艰苦的工作，我们想出了 pocdataflow.py 代码。
当你只是运行代码时，你是在本地运行，但如果你想在谷歌云数据流上运行，你必须添加一些参数，如' staging_location '，' runner '和' temp_location '。一个有用的技巧是在云上运行之前尝试在本地运行它。如果您发送的任务是可并行化的，Dataflow 将分配更多的 CPU 来完成这项工作。
当你的工作在谷歌服务器上运行时，你可以在控制台上监控它。您可以在那里检查错误、当前使用的 CPU 数量以及其他一些信息。
谷歌云数据流的扩展速度有多快！
一旦您的工作正常运行，您就可以为它创建一个模板。该模板允许您从请求或浏览器中触发数据流的作业。我们发现创建模板的最简单方法是在使用终端命令运行 python 脚本时添加选项'—template _ location GS://your-bucket/pathtotemplate/template '。它不会运行作业，但会在您的 bucket 上创建一个包含作业模板的文件。之后你还要在同一个文件夹里添加一个' template_metadata '文件，就完成了。
到目前为止一切顺利，但我们想看看它能自动化到什么程度。Thiago Chiaratto 又一次挽救了局面，他推荐了谷歌云功能。
谷歌云功能
Google Cloud Functions 是一小段代码，可能由 HTTP 请求、云发布/订阅消息或云存储上的一些操作触发。就像以前的工具一样，它完全没有服务器，能够运行 Node.js、Go 或 Python 脚本。
在我们的解决方案中，我们决定使用 Node.js，遵循我们找到的例子。结果就是代码 cloudfn.js 。现在，每当您在存储桶上插入包含城市列表的文件时，它将自动启动您的工作模板。
最终的架构如下所示:
PoC 架构
在概念验证结束时，我们能够分布式处理数据，而无需设置 Hadoop 集群或承担维护成本。很难说我们会花多少时间从头开始学习如何设置整个 Hadoop 和 Apache Beam 结构。
事实上，我有一个在编程方面比我更有经验的犯罪伙伴，这增强了整个 PoC 体验。我认为，与单独行动相比，两人一组能更快地完成任务。值得一提的是，支持这种实验的公司对项目的成功至关重要(我们正在招聘)！
自从那次经历之后，我一直使用 Google Cloud Dataflow 来编写我的数据管道。由于 Dataflow 的可扩展性和简单性，一些需要大约 2 天才能完成的数据管道现在在 Portal Telemedicina 只需 3 小时即可完成。
如果你需要一些关于 Apache Beam/Google Cloud 数据流的帮助，请告诉我，我很乐意帮忙！
我第一次接触到机器学习问题。
解决世界闻名的泰坦尼克号机器学习问题，并向 ML 的世界介绍自己。
美国国家海洋和大气管理局在 Unsplash 拍摄的照片
简介
这个时代的每个人都知道泰坦尼克号。泰坦尼克号是当时最大的船，被称为“永不沉没之船”。以至于该船的工程师和建筑师得出结论，没有必要在船上增加足够数量的救生艇。这意味着这艘船可以容纳更多的乘客，使他们能够在甲板上自由移动。
1912 年 4 月 14 日，泰坦尼克号与一座冰山相撞，灾难降临，造成船只大面积损坏。2 小时 40 分钟后，船沉入海底。由于船舶设计者计划不周，救生艇无法容纳船上所有的乘客。这造成了大量的生命损失。估计死亡人数约为 1517 名乘客。
对于那些正在阅读这篇博客的人来说，你可能很难把我的博客的标题和我到目前为止所做的介绍联系起来。这是可以理解的，我简要介绍整个泰坦尼克号灾难的原因是因为我的第一个机器学习项目是基于完全相同的主题。
问题陈述
Kaggle 上的泰坦尼克号挑战赛是一个开放的比赛，供初学者参加并熟悉 Kaggle 平台。此外，它还为人们开始机器学习之旅提供了一个起点。
问题陈述很简单。给定一个训练集和一个测试集，我必须开发一个机器学习算法来预测泰坦尼克号灾难中幸存的乘客和遇难的乘客。
工作流程
由于这是我第一次接触机器学习问题，我想在数据集上测试所有可能的算法。我最终引入了许多机器学习算法，从简单的如逻辑回归和 K 最近邻算法到复杂的如随机森林分类器和 AdaBoost 分类器。
(图片由作者提供)
在导入库并将数据加载到 pandas 数据框中之后，我开始研究数据，寻找可能的异常值或缺失值，这可能是我们项目后期算法的关注点。
数据探索
作为数据探索的第一步，我使用了 describe 函数来获得训练数据集中的数字数据的概述。描述功能是一个有用的工具，因为它为用户提供了数据的统计概览。它给出了计数、平均值、标准偏差和所有的四分位值。训练数据集具有 891 名乘客的信息。
(图片由作者提供)
在下一步中，我将利用条形图来探索分类变量。条形图是研究要素中存在的各种分类标签的计数的好方法。下图给出了目标标签的条形图，即存活或未存活，其中 1 表示存活，0 表示未存活。
(图片由作者提供)
柱状图也被用来比较事故中幸存的女性和男性的数量。正如柱状图非常清楚地描述的那样(通过下面提供的图片)，事故中幸存的女性人数多于男性。这种模式的例子可以在历史书上找到，其中指出，船长明确地发出命令，让妇女和儿童优先获救。因此，女性的存活率几乎是男性的三倍。
描述幸存女性人数的柱状图(左)描述幸存男性人数的柱状图(右)。(图片由作者提供)
在对训练集中的分类变量有了一个相当不错的想法后，我现在将注意力转移到我们的数据集中存在的缺失值(即训练数据和测试数据)。缺少值会导致算法行为不当和性能不佳，这就是为什么应该适当地处理它们。我使用 pandas isnull 和 sum 函数来获得缺失值的计数。在训练数据中,“年龄”、“客舱”和“登机”列中有缺失值，而在测试数据中,“票价”、“年龄”和“客舱”列中有缺失数据。
训练数据(左)和测试数据(右)中缺失值的摘要。(图片由作者提供)
数据工程(训练集)
在数据探索步骤之后，我对手头的数据集有了一个相当好的想法，因此我决定对数据集进行必要的修改和更改，以适应我们的机器学习算法的需要。
步骤 1:删除丢失数据的行/列。
“已装船”列有两个缺失值。由于缺失值的数量很少，我决定删除包含缺失值的行。删除它们不会导致算法信息的重大损失。另一方面，客舱列有相当数量的缺失值，这些缺失项占“客舱”列中所有数据的 77%。客舱列中缺少的值会阻碍模型达到最佳精度，因此，我决定删除“客舱”列。
步骤 2:填充数据集中缺失的值。
训练集中唯一缺少值的列是“年龄”列。为了填补缺失的值，我使用了箱线图。因为列“Pclass”没有缺失值，所以我将它映射到数据集中存在的年龄值。形成的箱线图给了我船上每个等级的乘客的平均“年龄”值。然后用这些平均值代替缺失值，这样我们就有了一个完整的“年龄”栏。下图中可以看到箱线图。
(图片由作者提供)
步骤 3:分类变量的一次性编码。
一种热编码是将分类变量转换成可解释形式的过程，该可解释形式可以提供给 ML 算法以在预测中做得更好。pandas get_dummies 函数有助于将分类变量转换成独热编码格式。对于这个项目，我将“Sex”列和“apollowed”列转换为 one-hot 编码的特性。下图显示了添加到数据框中的新列。“男性”和“女性”列是在对“性别”列应用一键编码后派生出来的。
(图片由作者提供)
步骤 4:删除不需要的列
在执行了步骤 1、2 和 3 之后，我剩下了一些在项目的后续阶段中不需要的列。首先，我删除了“性别”和“上船”列，因为我有它们的热编码等价物；其次，我删除了“机票”和“姓名”列，因为它们无助于增加机器学习模型的预测能力。
数据工程(测试集)
由于训练集和测试是两个不同的 CSV 文件，在完成训练集的数据工程任务后，我将注意力转向了测试集。我使用了前一节中描述的相同的四个步骤来清理测试集。
总之，删除了“Cabin”列，删除了缺少“Fare”值的一行，并使用用于替换训练集中缺少的“Age”值的方法替换了缺少的“Age”值。最后，使用一次性编码转换分类变量，并从测试集中删除不需要的列。
在训练数据上实现机器学习算法
现在我有了一个干净的数据集，剩下的唯一部分就是将训练集和测试集分配给变量。下图也可以看出同样的情况。
(图片由作者提供)
一旦执行了上述步骤，我就开始在训练数据集上实现机器学习算法。我在训练数据上实现的算法是:
- 逻辑回归
- 支持向量机(核:线性、RBF 和 Sigmoid)
- 决策树
- 脊线分类器
- 随机森林分类器
- XG 增强分类器
- AdaBoost 分类器
- k 近邻分类器
在对训练数据实施了上述算法之后，我计算了模型精度以及拟合模型的交叉验证分数。下表列出了每个模型的准确度分数和交叉验证分数。
(图片由作者提供)
推理
查看上表，SVM(内核:RBF)、决策树和 XG Boost 分类器具有显著的模型准确性，但交叉验证得分较低，这表明对训练数据过度拟合。相反，岭回归分类器具有较高的模型精度和交叉验证分数。因此，我得出结论，岭回归分类器是我的机器学习项目的最佳算法。
关于 Kaggle 的呈件
我在测试集上使用了岭回归分类器，并生成了一个 CSV 文件提交到 Kaggle 上。提交文件由测试集中乘客的预测值组成。该模型达到了 76%的准确率。
结论
我在机器学习项目上的第一次尝试是富有成效的。我遇到了各种用于清理数据和处理缺失值的方法，我能够在数据集上实现各种机器学习算法，并评估它们的准确性。
在未来，我将更多地了解各种机器学习算法的复杂性及其工作原理。这将允许我了解情况，并相应地使用最能满足需要的算法。最后，我将致力于更多有趣的机器学习项目，并与世界上的机器学习爱好者分享。
我做泰坦尼克号项目遵循的流程可以在 Github 上找到。我希望你喜欢看我的博客。
我学习单词嵌入的第一次旅程
我的第一个帖子在这里！
单词嵌入 和 NLP，更一般地说，以一种特殊的方式引起了我的注意。我很惊讶能从推文、评论、评论中提取多少价值；最奇怪的是，我们是一秒又一秒产生的相同数据的用户。
过去，我们已经学会了如何通过 线性回归，等方法找到最符合给定数据的线的参数。我们开发了经典模型，如【ARIMA】来拟合时间序列，以及如何构建帮助我们做出决策的树。
然而，当我考虑这些模型时(也许这是我的一种偏见)，我总是倾向于将建模的数据看作是严格的和结构化的，是在某种测量或底层过程之后收集的数据。
在我们逐渐不再使用口语的时候，书面语也越来越少，自然语言处理以某种方式让它们恢复了价值，让这个词再次变得有价值，这可能会带来很多积极的结果。
当我爱上 NLP 时
我在研究机器学习时发现的第一个文本表示是单词包 (BoW)表示，其中文档被表示为其单词的集合，并且完全不考虑词序。此外，我遇到了 n-gram 模型，其中考虑了 n 个单词的序列，以便在转换过程中保留空间信息。
一把弓可以看成 1 克的模型。
然后，您可以使用 一键编码 或借助于 TF-IDF 表示对单词或单词序列进行编码，并且您可以使用这些生成的特征来训练机器学习分类器，例如 朴素贝叶斯模型 或 支持向量机 ，以便执行正面与负面文本分类。
字云！
深度学习的力量
在机器学习之后，我为我的论文投入了深度学习，我发现了深度神经网络的迷人世界。
深度神经网络是数学模型，在给定足够数量的数据的情况下，由于 反向传播 算法的形式化，深度神经网络有望通过试错法发现输入和输出数据之间的关系，其中网络参数相对于给定损失函数的梯度进行优化，该损失函数根据必须解决的问题进行选择。
跳过剩下的深度学习之旅，我第一次见到了 自动编码器 ，最终我对 递归神经网络 有了更深入的了解，这还要感谢 Andrew NG 在 Coursera 上的 Deeplearning.ai 课程。
递归神经网络是具有内部循环的网络，允许信息持续存在。这使得它们非常适合于建模序列数据，例如时间序列，以及文本和语音。
单词嵌入，我来了
我使用递归神经网络建立的第一个模型是一个字符级模型，它通过 9000 个意大利名字进行训练。具体来说，这是一个序列到序列模型，其中给定第个 i- 个字符作为输入，该模型被训练来预测第个 i+1- 个字符。每一个意大利名字都是用一键编码的字符序列处理的。该模型表现良好，因为生成的名字几乎都以 o 或 a 结尾(这是意大利名字的标准)。后来，我继续进行单词级模型，使用固定长度的句子，其中单词是一个热点编码的，但是我不满意这样的事实，即对于所有的向量对，一个热点向量的余弦相似性是 0，即使是那些表示相似主题的向量。
下一步，我想看看单词嵌入实际上是如何工作的。
来自评论的训练嵌入
我从 Kaggle 下载了 亚马逊美食评论 数据集，由~ 500k 评论组成，我下载了 SQLite 数据库文件。
首先，我导入了 sqlite3 并构建了一个查询来检索 reviews 表，并查看行数和包含的列数，例如 Reviews 以及我在此阶段没有考虑的其他数据:
**import sqlite3
connection = sqlite3.connect('/content/gdrive/My Drive/Colab Notebooks/database.sqlite')
# Number of reviews
c.execute("SELECT COUNT(*) FROM Reviews")
c.fetchall()**
我找到了 568000 条评论。然后，我构建了 helper 函数来获取评论并对其进行处理，以便首先通过利用 NLTK 包将它们拆分成一系列句子，然后将每个句子拆分成一系列单词:
**def fetch(limit):
c.execute(f"SELECT Text FROM Reviews LIMIT {limit};" )
records = c.fetchall()
print(f"The number of fetched records is {len(records)}")
return records****def tokenize(chunk):
from nltk.tokenize import sent_tokenize, word_tokenize
from tqdm import tqdm** **list_of_tokens = []
print("Iterating over all the retrieved rows...")
for row in tqdm(chunk):
sentences_from_reviews = sent_tokenize(row[0])
tokenized_sentences = [word_tokenize(sentence) for sentence in sentences_from_reviews]
list_of_tokens.extend(tokenized_sentences)
print("Completed.")** **return list_of_tokens**
正如你所看到的，我没有过滤停用词或网址或其他任何东西，我想直接有一个最小的单词嵌入的例子。
我验证了数据的结构是一个列表的列表，其中每个内部列表只包含字符串:
**all(isinstance(elem, list) and isinstance(word, str) for elem in test for word in elem)** *#returns True!*
我提取了数据并进行处理:
**data = fetch(limit=-1)
token_data = tokenize(data)**
现在训练数据已经准备好适合一个 Word2Vec 模型。我不会详细介绍 Word2Vec，但是网上有很多资源。
**import multiprocessing # for number of workers
from gensim.models import Word2Vec****model = Word2Vec(token_data, size=300, min_count = 10, workers=multiprocessing.cpu_count(), iter=30, window=5)**
过了一会儿，我准备好了我的模型，我腌制并下载了它(我用的是 Google Colab 笔记本，可以在这里查阅):
**import pickle
from google.colab import files****with open('token_data.pkl','wb') as f:
pickle.dump(token_data,f)****files.download('token_data.pkl')**
然后，我将它导入我的本地 Jupyter 环境:
**import pickle****with open('token_data.pkl','rb') as f:
token_data=pickle.load(f)**
并检查了与【橙子】和【意大利面】的相似性:
**model.wv.most_similar('orange')****Out[16]:****[('lemon', 0.6406726241111755),
('grapefruit', 0.6343103647232056),
('pomegranate', 0.6024238467216492),
('citrus', 0.5851069688796997),
('blackberry', 0.5831919312477112),
('cherry', 0.5785644054412842),
('strawberry', 0.5701724290847778),
('grape', 0.5649375319480896),
('elderberry', 0.5609756708145142),
('guava', 0.5601833462715149)]****model.wv.most_similar('pasta')****Out[17]:****[('spaghetti', 0.7852049469947815),
('couscous', 0.6740388870239258),
('pastas', 0.6413708329200745),
('noodles', 0.6318570971488953),
('linguine', 0.6257054805755615),
('vermicelli', 0.6104354858398438),
('penne', 0.6094731092453003),
('lasagna', 0.5939062833786011),
('macaroni', 0.5886696577072144),
('bread', 0.5816901922225952)]**
所以它似乎抓住了食物的相似之处！接下来，我将使用 t-SNE 来可视化嵌入，但是我将在下一篇文章中保留它。
我作为计算机视觉工程师的第一个月
洞察一个实践机器学习工程师的第一个月。Jupyter 笔记本之外的世界
Avi Richards 在 Unsplash 上拍摄的照片
介绍
大约一个月前，我写了我作为计算机视觉工程师的第一天是怎样的。如果你错过了这个故事，在阅读本文之前，请随意阅读。
剧透:我引起轰动
towardsdatascience.com](/my-first-day-as-a-computer-vision-engineer-8b59750c79a0)
一个月后，我回来提供一些第一个月的细节。
我写这些文章的原因是向个人提供一些知识，而不接触机器学习行业内的人。一些内部消息有利于人们做出重要的职业选择。但是请记住，我的经历并不能反映整个行业。
在这篇文章中，我谈了以下几点:
- 我在第一个月遇到的脆弱情绪
- 角色所需的研究期望
- 为什么研究很重要
- 期望在以 ML 为中心的角色中取得成功的技术能力水平
恐惧和责任
不如我先说说我第一个月有多害怕。这不是我的第一份正式工作，在成为机器学习/计算机视觉工程师之前，我已经做了 3 年半的网页开发员。
但是这次感觉很不一样。我很害怕，原因如下:
- 我负责所有与公司产品相关的计算机视觉
- 团队非常信任我的决定
恐惧不一定是一件坏事，我把它作为一种工具来确保我拿出最好的作品，并在需要的时候付出 100%的努力。
研究
作为该公司第一个专注于机器学习的员工，我被要求列出我认为最适合工作的流程。
它包含了大量的研究。
作为一名机器学习工程师，你必须能够理解发表的研究论文中提出的最先进技术的关键细节。
作为一名工程师，实施技能至关重要，但解释你的机器学习模型是如何工作的，或者解释你为什么选择一种方法而不是另一种方法，可以将你描绘成你所在领域的专家。
第一个月阅读了大量关于标准计算机视觉问题解决方案的研究论文，如姿势估计、语义分割、对象检测等。
研究门 和 代码为 的论文是发现解决特定计算机视觉问题的相关论文的绝佳资源。
技术的
该公司的主要交付成果以 iOS 移动应用的形式出现。
照片由 Roozbeh Eslami 在 Unsplash 上拍摄
我没有接触过开发 iOS 移动应用程序，所以我的第一个月涉及到熟悉 Xcode ，这是一个用于开发移动应用程序的 IDE，还有 Swift，这是一种由 Apple 开发的编程语言。
由 Roozbeh Eslami 在 Unsplash 上拍摄的照片
对于那些可能没有意识到的人来说，一个好的机器学习工程师也应该是一个体面的软件工程师。
这是一个非常高的要求，机器学习工程师不要仅仅将他们的工作局限于 Jupyter 笔记本和 Python 脚本。但相反，你需要能够掌握新的语言来建立网站或移动应用程序。
每天，我交替使用 Swift、Python 和 JavaScript 来完成各种不同的任务。
关键的事情不是要知道数百种编程语言，而是你需要掌握大多数编程语言的基础知识。
一个不错的起点是学习面向对象编程(OOP)。
一般来说，你从一种编程语言中学到的知识可以转移到下一种语言。
五金器具
我利用一台 Nividia Geforce GTX 1650 来训练我的业余爱好项目的大部分 ML 模型。这种 GPU 规格甚至没有接近训练最先进模型所需的硬件规格。
由 Aviv Rachmadian 在 Unsplash 上拍摄的照片
在我的第一个月，我的任务是提出一个合适的 GPU 工作站技术规格，然后公司可以订购。
选择合适的硬件组件需要预见到我将在未来几个月甚至几年训练什么类型的模型。
为了做出准确的决定，我不得不进行大量的研究，研究论文利用什么样的硬件规格来训练他们提出的模型。
此外，还需要对支持稳定工作站所需的其他硬件组件进行研究。
对以下问题进行了考虑:
- 冷却系统
- 主板和处理器
- 电源容量
- GPU 插槽可用性
- 还有更多…
这里有一个 视频 解释了如何构建一个深度学习的机器学习工作站。
即使你不会很快建立一个工作站，了解训练深度学习模型所涉及的硬件组件也是很好的。
证明文件
软件文档冗长、乏味、无聊。但是任何达成一致的技术方法的文档都是至关重要的。
所采取的每一个决定和方法都应该记录下来，以告知团队成员和未来的新成员。
在我的第一个月，我记录了大约 12 个小时的文档。这并不有趣，但却是必要的。
我记录的项目包括以下内容:
- 处理基于机器学习的项目时要采取的已定义流程
- 基本材料快速文摘研究论文的基本摘要
- 关键项目和软件解决方案的实施方法说明
- GPU 工作站硬件比较规格
- 解释围绕实现代码的推理和逻辑的代码内文档。
在您的角色中，您可以记录很多领域。从一周中抽出一些时间，至少 2 个小时用于文档。
这篇 文章 作者Admond Lee进一步探讨了为什么文档对于数据科学家来说是必要的。
偏爱
作为一名正式的计算机视觉工程师，我的第一个月让我对实用的机器学习如何融入公司有了一些了解。
我意识到许多人可能没有意识到的是，ML 模型不是最终产品。机器学习本身是软件工程的一个使能部分；我们产生的结果被嵌入到软件系统中，它们以创造性的方式执行任务。
向前看，我的第一个月让我意识到我喜欢机器学习带来的创造性产出。
朝着一个创造性的目标努力可以让平凡的模型实现、调试和训练任务变得不那么无聊。
结论
在第一个月，我做到了以下几点:
- 设定接近计算机视觉过程的标准
- 学会了一门新的编程语言
- 为构建公司的 GPU 工作站提供硬件规格
- 实现了计算机视觉技术，如姿态估计、手势识别和语义分割
- 选择 TensorFlow 和 TensorFlow Lite ( 我更喜欢 PyTorch 类型的家伙
希望这篇文章对你有用。
要联系我或找到更多类似本文的内容，请执行以下操作:
- 订阅我的 YouTube 频道 视频内容即将发布 这里
- 跟我上 中
- 通过 LinkedIn 联系我
我作为数据科学家的第一个月非常棒
我学到了什么？
更新:嘿！感谢您花时间阅读，但在您开始阅读之前，您可能希望成为一名数据科学家。在这种情况下，我制作了一个关于如何获得第一份数据科学工作的视频，你可能会发现它很有用 这里 。
我学到了什么？很多。
八月初，我找到了第一份数据科学家的工作。像任何新工作一样，有很多信息需要一次吸收。
通过记录和分享我自己的想法，希望那些有志于成为数据科学家(或从事任何与数据相关的工作)的人在未来会发现这很有帮助。当然，每个公司和工作场所都是不同的，但是我认为这些建议对大多数人都有用。
尽可能多的认识一些人
这适用于许多其他角色，但我觉得这在处理数据时尤为重要。
你认识的人越多，你的工作就越容易做。
没有比当你有介绍自己的借口时更好的认识人的时间了。通过扩大你在公司的影响力，你有更多的机会找到你将来可能需要分析的数据。
如果数据管理不善，情况尤其如此。即使您的团队有一个干净且专用的数据仓库，也一定会有您需要某些东西但却找不到的时候。有时你需要比你更熟悉数据的人的帮助。
定期做笔记
JESHOOTS.COM在 Unsplash 上的照片
就个人而言，我认为这是一个值得你在职业生涯中保持的习惯。
通过有规律地做笔记，如果你忘记了什么，你会有东西可以参考。在任何职业生涯的开始，你都会忘记事情。
尽早养成这个习惯意味着当你知道你应该记得的时候，你就不会在将来尴尬的要求什么了。
这也是跟踪人们当前正在做什么或使用什么的好方法(例如，他们使用什么数据等)。).它可以让你记录可能对你未来有用的东西的位置。
说到记笔记，我推荐使用观念。在学生时代，它很好地服务了我，记录了我自己的项目和想法，并很容易地过渡到了我的工作生涯。
提前集思广益
这是上一节的继续:随着你对数据越来越熟悉，开始记下你的想法。即使它们现在看起来不合理，你的大脑还是会创造想法，而不是储存它们。
有时候我有一个解决某个特定问题的想法，但是后来因为没有写下来而忘记了。如果你最终的任务是解决同样的问题，你将不得不花时间再次提出同样的想法！
记录你的想法也能让你随着时间的推移对它们进行改进，因为你对每件事都变得更熟悉了。当有人提出一个新问题要解决时，你可能已经有了一个解决问题的好主意。这使您的工作更容易，并为您节省大量时间。
不要把事情复杂化
照片由 Antoine Dautry 在 Unsplash 拍摄
随着最近围绕机器学习的大肆宣传，很容易陷入过于复杂的陷阱。有时，简单的线性或逻辑回归可能就足够了。
在某些情况下，复杂的机器学习管道所需的基础设施甚至可能不可用。
大多数数据科学问题都是统计问题，需要你像统计学家而不是机器学习工程师一样思考。
这意味着从平常开始:
- 数据的分布是什么样的？
- 哪种模型最适合这种分布？
- 如果是，数据是否满足模型的统计假设？
- 如果数据不符合我的假设，我需要删除它吗？(例如多重共线性)。
从这里开始，如果合理的话，你可以考虑机器学习。然而，解决方案变得越复杂，就越难向决策者解释和证明你的结果。尝试向非数学观众解释神经网络是如何工作的，你会发现这是一件非常困难的事情。
只要它提供了可操作的见解，并能清晰地传达给观众，那么我认为这是一项出色的工作。
不要觉得有压力去解决一切
克里斯蒂安·埃尔富特在 Unsplash 上拍摄的照片
尽管我们是来解决问题的，但总会有无法继续下去的时候。这可能是由于缺少(可用的)数据，或者解决方案的实施时间太长。
不管原因是什么，最好把它放在次要位置，然后继续解决其他事情。很多时候，完成一项任务比什么任务都不完成要好。
最后——犯错并享受学习的乐趣！
冒名顶替综合征是真实存在的，当期望值很高时，它有时会让人感到有点不知所措。
不要害怕犯错，尤其是在职业生涯的初期。相反，随着时间的推移，专注于少犯错误。记住，随着你的进步，别人会期待你犯的错误越来越少。在你有借口的时候充分利用它。
最后——你可能会觉得自己应该知道如何解决每个问题，并在一开始就提供惊人的见解；然而，现在是了解这个行业更多信息的绝佳机会。
尝试通过探索不同的数据科学技术来解决业务问题。我注意到我现在更有动力去阅读和探索其他潜在的解决方案，因为我现在有了一个很好的理由。对我来说，最大的动力是意识到经过这么多年的努力学习，我终于得到了回报！
我作为初级数据科学家的第一个月
像许多从非技术背景过渡到数据科学的人一样，我作为一名初级数据科学家正式开始了我的数据科学生涯…准确地说是在五月份。
老实说，到目前为止我没有遗憾，特别是因为我对这个领域的热情和我加入的令人惊叹的团队，这是一个适合我的良好文化。
出乎我的意料，我在上班的第二天就投入到了一个积极的工作项目中。这意味着我同时接触到了非技术工作流和技术工作流。有几次我感到不知所措，但现在回想起来，我不会改变任何事情。
对我来说，第一个月更多的是一个吸收和验证阶段。从某种意义上说，我对作为一名数据科学家的工作生活有很多假设，我觉得我的第一个月将是一个确认和支持我的假设的机会。
它实际上起了相反的作用。以下是我进入这份工作时的三个假设。
1。我的第一个假设是:
因为我已经完成了一些社会公益项目的数据科学，所以我已经为任何真正的数据问题做好了充分的准备。
哦，天啊，我错了！尽管我的社会公益项目暴露了一些常见的数据问题，但我遇到了很多新问题，促使我停下来多思考一些。
道德教训:每一个真实的数据都有其独特的问题。一直期待着。
2。我的第二个假设是:
大数据被高估了
现在我更清楚了，真的不是。当处理大数据时，明智的做法是找到高效的方法/管道以便扩展(在存储、分析、构建模型和部署方面)。管道工具暴露了我，并促使我将 AWS 这样的云服务作为日常工具。现在，在一个典型的工作日，我接触云服务工具的次数比过去两年都多。每天，我都在学习新的东西。
道德教训:大数据是真实的。如果你还在怀疑，说明你没有见过大数据。
3.我的第三个假设是:
作为一名大三学生，在我的第一个月里，就技术价值而言，我能给团队增加的新东西很少或者没有
现在我知道这不是真的。当我投入到我的第一个工作项目中时，我就发现了从技术角度来说可以给当前项目增加价值的方法。虽然我在一个了不起的团队中，积极实践无等级制度，相信每个人都有发言权，但我认为，一些荣誉应该属于我在获得全职工作之前完成的常规(或不再那么常规的)宠物项目和社会公益项目。这些让我接触到了我在端到端机器学习项目中可能遇到的各种问题，尽管它们只是表面知识。
道德教训:做宠物项目很有意义，但它的好处却被大大低估了
期待…
我每天都在学习并为团队做出贡献，但有一点我可以自信地说:我不会停止学习和应用。
在接下来的几个月里，我的目标是深入机器学习的某些领域，并将一些软件工程实践结合到我的日常工作任务中。
我作为人工智能医疗保健研究员的第一个月
马库斯·弗里乌夫在 Unsplash 上的照片
概述
这篇文章是写给任何像我一样，对在医疗保健领域从事人工智能研究感兴趣的人的。就在不到一个月前，我开始了与当地一家医院合作的硕士项目研究。我想让你们了解一下我的背景，我目前的日常工作，以及我对这个领域的初步想法。
与任何事情一样，我要说的几乎肯定不适用于所有的人工智能医疗研究，但我希望你能带着一些一般概念离开。
我的背景
我是一名 23 岁的俄亥俄州立大学的硕士生，学习…机械工程？而我的本科学历呢？机械工程…那么我是怎么到这里的呢？让我们往回走一点。
大概从 10 岁开始，我就喜欢上了电脑。我仍然记得我告诉我爸爸我想学习如何制作电子游戏，然后从学校回来，我的床上放着一本崭新的《傻瓜 C++》。我不知道整数是什么，变量这个词是什么意思，也不知道这些如何让我更接近于成为《星球大战前线 2》的精神继承者，但这都不重要。因为在花了一个小时在热键盘上挥汗如雨，安装一些古老版本的 Dev-C++之后，我按下了“运行”按钮，神奇的事情发生了…
嘿，你好！
我让我的电脑和我说话。不知何故，这些我不懂的胡言乱语让我的电脑说话了。从那时起，我几乎总是在做一些与计算机相关的事情，无论是尝试修改我最喜欢的游戏还是制作我自己的基本文本冒险。计算机背后的许多神秘对我来说已经消失了，但我一直对它们的能力感到敬畏。
这是我梦寐以求的工作，我实现它完全是巧合。
所以现在我已经彻底摆脱了超级书呆子的身份，你可能会想，如果我如此热爱计算机，为什么我决定学习机械工程。主要原因是我担心如果我成为一名程序员，我将无法解决物理问题。我的视力会因为整天盯着电脑屏幕而变得模糊，我会养成可怕的姿势，我的牙齿会掉光，等等。没有人警告过我，所有这一切也将成为机械工程的现实！
但是在本田的长期实习后意识到这些现实并没有改变我的道路。我的顶点项目是医学性质的，而我满怀希望的硕士项目顾问正在研究校园附近医院的人工智能研究，这两个项目的奇怪交叉将我带到了这里。说白了，这是我梦寐以求的工作，我实现它完全是巧合。再次专注于编程感觉就像回到了家。
我的日常生活
那么现在我已经谈论了我自己，我实际上在做什么？就像大多数工作一样，我没有一个固定的待办事项清单，但是有几件事我每天都在做。下面是我最常见的三种，排名不分先后。
- 摆弄数据
基本上任何机器学习工作都是如此，怎么说都不为过。我大部分时间都在关注清理和处理我自己的数据，或者阅读其他拥有类似数据的研究人员是如何清理和处理他们的数据的。他们是如何处理缺失值的？它们有什么独特的设计特征吗？他们是如何标准化他们的数据的？他们的模型能用他们的方法达到好的结果吗？这些都是你在研究同事的论文时会问的问题。
2.与利益相关方合作
显然，研究的目的是为了取得某种成果并与科学界分享。但是什么结果呢？如果利益相关者 A 和利益相关者 B 对你应该做什么有不同的想法呢？你需要确保每个人都在同一页上，朝着同一个目标前进，最重要的是，你需要确保你明白你要去哪里。虽然名义上您的利益相关者是负责人，但当涉及到您的数据时，您可能是主题专家。将数据集中的任何限制或漏洞告知他们是至关重要的。
所有数据背后都有一个故事，但你必须能够向它提出正确的问题，让这个故事浮出水面。例如，如果您的利益相关者希望能够检测患者的内出血，但尽管您尽了最大努力，您的模型也只能随机应变，那么您有责任与您的利益相关者分享您的担忧。方向的快速改变、对新数据的投资，或者对你认为无法设计的功能的建议，都比用头撞墙有用得多。
3.阅读研究论文
丹·迪莫克在 Unsplash 上拍摄的照片
这真的不应该是一个惊喜！成为一名医疗保健研究员不仅仅意味着研究你自己的问题。阅读您的同行在医疗保健中使用机器学习的研究几乎总是一项不错的投资。虽然不像其他领域的机器学习研究那样普及(还没有！)，其他研究人员的见解，即使他们在处理与我自己完全不同的问题时，也常常可以很容易地应用到我自己的工作中。
如果你真的想成为一名研究人员，那就认真阅读研究报告吧。就时间和精力而言，这可能非常费力，但净收益是值得的。我每天至少看一份报纸。这样想:如果最优解微不足道，为什么会有人去研究它？如果其他人已经研究过并找到了好的解决方案，为什么我需要重新发明轮子呢？
如果你真的想成为一名研究人员，那就认真阅读研究报告吧。
我对球场的最初想法
因为这篇文章已经很长了，我会尽量保持简短！以下是我过去一个月的一些热门镜头。
- 人工智能在医疗保健领域有着光明的前景！它的一些功能才刚刚被认识到，还有许多令人兴奋的领域是健康数据独有的
- 某些问题缺乏公开可用的解决方案可能会令人困惑，但我相信随着时间的推移，这将不再是一个问题
- 领域知识是绝对重要的。拥有一些健康数据不足以成为一名称职的医疗保健研究人员。与卫生专业人员合作是必须的
结论
谢谢你看我的文章！希望将来会有更多。如果你喜欢你所看到的，考虑在 LinkedIn 或者 Medium 上关注我。
请在评论区告诉我你的想法！你有兴趣从事人工智能医疗保健方面的研究吗？你现在是研究员吗？如果是，你对这个领域有什么想法？
我在一家财富 500 强公司从零技能到机器学习工程师的第一步
ky=mx+b
我进入数据科学和工程世界之旅的起源
无耻的自己的照片，因为它符合标题。洛杉矶新奥尔良。
TL；DR——这是一个名为“ky=mx+b”的新个人专栏中的第一篇文章，讲述了我在数据科学方面的职业历程和经验教训。在这里，我谈谈我作为一名分析师实习生对数据的了解，以及我是如何开始成为一名财富 500 强公司的机器学习工程师的。底部的数据科学入门技巧和常见问题。
我收到了相当多的请求，询问我进入数据科学世界的旅程以及我可以提供的建议，以至于我认为我还不如把它作为一个自我放纵的内容专栏的燃料。从 2015 年我在数据方面的卑微开始，到 2019 年我在辉瑞公司担任机器学习工程师的职位，我想告诉你我的经历——我在我的第一篇 TDS 专栏中收集的胜利、挑战和有用的东西: ky=mx+b (我知道很糟糕)。
起源
2015 年，我刚从大学毕业，正在昆尼皮亚克大学攻读分子和细胞生物学硕士学位。房租不便宜，所以我开始在我的领域寻找兼职工作。我被康涅狄格州布兰福德的生物技术公司录用为数据分析师实习生。我的工作非常简单:在新型免疫疗法领域进行研究并输入数据。酷的，我想。在这里肯定不能治愈癌症，但在一家好公司工作是很好的体验。
我毕业了。
然而，随着时间的推移，该公司开始从其新颖的生物分析中产生越来越多的数据。我的老板(公司的首席软件工程师)带着额外的问题来找我:“你学过编程课程吗？我们对使用 R 或 Python 这样的统计编程语言来分析我们的数据很感兴趣。”
我以前学过两门编程课程；一个在 Matlab 中(我很烂)，一个在 Scala 中(很有趣，但不适用于这里)。尽管如此，你不能要求比学习如何编码更好的交易了，所以我想，管它呢…让我们试试这个。
我开始花时间在像Datacamp.com这样的大型开放在线课程(MOOC)网站上，在 r 中的基本命令和统计分析方面取得了缓慢但明显的进展。我开始运行像 Mann-Whitney 和 t-tests 这样的统计测试，甚至开始使用主成分分析(PCA)进行维度缩减，以向我的老板汇报。
现在，请记住——我再怎么强调也不为过——我写的代码非常糟糕。我基本上是把所有这些命令的模板保存在我的电脑上，手动改变变量而不是编写函数，并复制/粘贴到任何我能复制/粘贴的地方。但是，即使对统计学、机器学习和编程有最起码的了解，我也开始培养对基础数据科学的兴趣。
一些丑陋的代码作为例子。这次回购的启示。
随着时间的推移，我开始在 Datacamp 上开发更好的仪式，每天通过越来越多的讲座。当我在一个完全不相关的领域获得硕士学位时，我对数据科学的世界和其中存在的职业机会有了更多的了解。我也开始学习 Python 课程——当我遍历列表、分配变量和打印“你好，世界！”时，我允许我的在线课程成绩膨胀我的自我
大约是在这个时候，我听说了这些叫做“数据科学训练营”的东西的兴起
经过三个月的全日制培训，你可以获得一个证书，证明你在使用 R 和 Python 的数据科学方面的价值。这些训练营甚至通过他们的企业关系提供职业支持，试图平息数据科学热潮后合格行业专业人员的严重缺乏。然而，我有我的保留意见…
1.这些训练营相对较新且昂贵。我想在翻牌圈花那么多钱吗？回想起来，我甚至都不太了解？为什么不赌上外管局的赌注，和另一家认证机构的 MS 一起去呢？
2.我正要完成我的硕士学位，我真的想现在开始更多的学校吗？
3.我的公司知道我的训练营考虑和毕业日期，给了我一份全职数据分析师的工作。我可以立即在一家我在 CT 认识的公司有一个稳定的职位和工作保障。
在仔细考虑了我的选择后，我做了一个决定。当我在 2016 年末完成我的硕士学位时，我开始申请数据科学训练营。虽然我对一些感兴趣，但我最关注的还是纽约市数据科学院。我完成了网上申请，并被邀请到纽约市参加面试。我坐上火车，准备接受训练营教官的面试。
对我来说，这是我数据科学之旅中最值得关注的时刻之一。你不知道很多你不知道的事情，直到你被一个比你知道得多的人面试。当然，我在一些非常特殊的场合使用过 Python 和 R——但是我还没有理解它们。我一直在做机器学习…但是复制和粘贴代码当然不会让我成为专家。当我被问到关于我的工作的问题时，我意识到我还有很长的路要走——我需要某种教育和支持系统才能到达那里。
我在面试中回答了足够好的问题(至少足以被录取)，但我对自己实际所知甚少的认识给人留下了深刻印象——我需要某种形式的正规教育和支持系统来提高我在这里的技能。当我因网上的任意成功而膨胀的自我开始萎缩时(这不是最后一次发生这种情况)，我决定全力以赴——搬到纽约，全职参加训练营。
我被盘问一些我以为我知道的事情。来源
入门提示
- 每天练习，不要因为你完成了在线课程就超越自己。精通需要真正的练习。
- 除非你是天才，或者有能力自学整个学位，否则 MOOCs 可能还不够。正规教育不仅有助于你的简历，还能弥补你的缺点——包括向你展示它们的存在。
- 不要仅仅依靠你的在线课程经验。试着把自己置身于可以用你的技能解决实际商业问题的情境中。这将比任何制造的在线问题更好更快地磨练你的技能。
- 想想你想成为什么样的数据科学家。数据科学是一个定义不清的宽泛领域。你是程序员、数学家、讲故事的人，还是别的？
- 尽早进入良好的编程实践(函数、注释代码、面向对象等……)。保持一个好习惯比改掉一个坏习惯容易得多。查看 Python 的 PEP 8 。
- 参与社区 —这是一个我不常看到的建议，但我认为它很重要。仅仅通过在 Twitter 和 LinkedIn 上关注数据科学家并参与对话，我就学到了很多。
- 不要气馁。和任何学习一样，掌握数据科学需要时间。每个人都会失败，每个人都会沮丧，每个人都会谷歌。
- 只有在你喜欢的时候才追求数据科学，而不仅仅是为了薪水或简历流行语。数据科学是一个竞争激烈的领域，包含大量的信息。如果你没有动力去学习所有的知识，那么找到一份工作并在这个领域有所发展将会更加困难。
关于入门的常见问题
数据科学基础入门网站和课程太多了…我应该选哪一个？
我经常被问到这个问题。在我看来，这没什么大不了的。这些学科的基础是一致的，并且相当标准化。我当时选择了 Datacamp，但这并不意味着它是唯一正确的选择——我只是喜欢 UX。不排除便宜的课程。以一种适合你学习风格的方式开始吧。事实上，为了获得更广阔的视角，最好是去多方寻找资料。
我应该参加训练营还是考虑更高的教育学位？
当时全日制训练营对我很有吸引力，因为我没有耐心，刚刚完成一个 MS，数据科学/机器学习学位没有广泛提供。由于我没有数据科学的硕士学位，所以我无法对那次经历发表看法。如果你没有数据科学背景，认证学位可能会让你的简历更具竞争力，但就内容而言，全日制训练营仍然非常全面(尽管它在 3 个月内覆盖，而不是 2 年)。我也听到过对 ms 项目中真实世界经验的疑虑。他们有理论内容，但较少接触工业。鉴于训练营的规模和使课程适应快速市场和技术变化的能力，训练营在本质上更灵活，更适合企业数据科学角色。
网上有这么多资源，我还需要任何形式的正规教育吗？
从技术上来说，网上可能有足够多的开源和廉价内容，可以让你成为一名成熟的数据科学家，而无需参加任何课程。然而，除非你是那种可以在没有任何帮助的情况下自学整个学位课程的人(我肯定不是)，否则我不会推荐你这么做。如果没有更深入的教育和可以合作的同龄人，你很可能会遇到问题，并误判自己的能力。此外，如果你没有任何工作经验或正规教育，你可能很难找到工作。正如这个人所说的(和我的经历相似)，如果你只依赖 MOOCs，你的第一次面试将是一个真正的警钟。最后，学习数据科学就像去健身房，如果你支付会员费，你更有可能让自己站起来去做。
Python 还是 R？
Python。我喜欢 R 用于统计和可视化，但 Python 用于字面上的其他一切。它是一种更强大的工程语言，拥有更大的社区，可能会成为 21 世纪 20 年代许多工作的必备技能。
除了 Python、R、SQL、机器学习之外，还有我应该学的东西吗？
你可以学到很多东西。 Linux/Unix、Docker、Kubernetes、Spark、各种 Apache 框架……清单还在继续。不要让它压倒你。从基础开始，扩展开来。
外面有那么多，我该从哪里开始呢？
搜索 Python 中的基础知识，观看一些关于机器学习的 Youtube 视频，并查看一些 boiler plate SQL。玩一会儿，看看你是否喜欢。如果你的兴趣被激起，其余的事情会自然发生。
ky=mx+b
下次我写的时候，可能会是关于我的训练营经历和职业旅程。现在，你可以随时在 medium 上关注我或者在 LinkedIn 上联系我！我也试着在推特上多做一点，但是我们会看看事情会如何发展。如果您对数据科学或相关主题有任何疑问，请随时联系我们。我总是很乐意回答。
我作为博士生的第一周:数据科学之旅的开始
感觉像一条巨大池塘里的小鱼
首先，让我自我介绍一下。我叫 Philip Wilkinson，正如标题所示，我刚刚结束了在伦敦大学学院(UCL)攻读博士学位的第一周。我的研究专注于一个非常特殊的主题，即开发空间交互模型，或寻找替代模型，这些模型基本上可以用于根据现有的人口分布和其他因素来了解和预测商店收入。这一特定主题是空间相互作用模型更广泛历史的一部分，空间相互作用模型在以这种方式使用的同时，还被用于理解迁移模式、预测新交通基础设施的影响，以及理解新就业机会的创造如何影响当地的住房需求。由于新的大型数据集的出现，以及计算能力的提高，允许更大和更精确的模型，这也是一个最近获得新生命的主题。这是我主要在 UCL 大学攻读智能城市和城市分析硕士课程时感兴趣的一个领域，我们的一个模块围绕这些模型的历史和发展。这主要侧重于预测伦敦的工作分布将如何随着收入的变化或旅行成本的大幅增加而变化，但我很高兴看到这些模型还能做什么，以及更好的数据和软件如何让我们更好地了解我们周围的建筑环境。
那么我的第一周是什么体验呢？嗯，主要我会说，感觉就像我刚刚被扔进一个非常大的游泳池的深水区(因为我只有 5 英尺 6 英寸，所以深的游泳池不一定要那么深)或者我刚刚从一座非常大的山的底部开始，这将需要我至少三年的时间来攀登(我的资金在三年后用完，所以这是至少的目标)。我会说这主要是因为，当涉水进入这些水域，或者从山脚开始，完成我的博士学位的问题和挑战就在我面前。在这段时间里，我意识到我必须继续发展我的编码技能，使我能够处理非常大的数据集，并有可能创建新的软件来展示和运行开发的模型，阅读数百篇关于零售历史、零售位置、电子商务、空间交互模型和基于代理的模型的论文，有效地吸收和理解所有这些知识，为我的赞助商制作最终产品，并为我的博士论文撰写大约 10 万字的论文。如果这种前景没有吓到任何开始攻读博士学位的人，那么这项任务的艰巨性肯定还没有成为现实。
Mathias Jensen 在 Unsplash 上拍摄的照片
当然，虽然我对如何在未来三年内管理所有这些知识和创造所有这些产出感到害怕、焦虑和担心，但我完全期待着这一挑战，这有几个原因。首先，博士学位一直是我感兴趣的事情，虽然这不是我接受工作邀请后的最初计划(只是为了让 Corona 在这些工作中发挥作用)，但当一个我感兴趣的项目出现时，我很乐意抓住机会。我希望一旦我完成了这件事，我的父母和祖父母会为我感到骄傲，因为他们总是鼓励我尽可能地追求我的教育。其次，它提供了一个在未来三年继续我的学术和个人发展的机会，完成前面提到的所有任务，并在这个过程中学到很多东西，无论是通过我将要做的工作，还是通过我参加的社团或我遇到的人，我相信当我完成时，我会学到更多的知识，这是我可以带着我进入下一步的东西。鉴于我将在我感兴趣的学科内工作，将数据和技术驱动的解决方案应用于我们对建筑环境的理解，这一点尤其如此。第三，虽然工作目前还很遥远，但我真的很喜欢成为我在 UCL 的部门的一部分，因为我已经遇到了一些人(包括许多帮助我完成去年硕士学位并申请博士学位的令人难以置信的讲师和导师)，并期待着未来的见面，以及他们正在从事的世界领先的工作，这为我提供了很多向一些非常聪明和有趣的人学习的机会。这包括成为赞助公司的一员，虽然我还没有完全融入其中，但我期待着在未来这样做。
说了这么多，我在第一周实际上做了什么？这是从空间互动模型领域的一些初步探索性阅读开始的，这无疑会产生焦虑和恐惧的感觉，因为认识到要涵盖的内容太多了。到目前为止，就阅读和笔记而言，我只涉及了大约 14 篇学术论文，这基本上是我尝试了所有我能阅读的内容，比我想在第一周完成的数量少得多，但这是一个开始。这一小部分主要是因为我不得不非常专注于每篇论文，看看他们在模拟什么，他们是如何做的，他们的主要发现是什么，因此我可以从他们那里学到什么，帮助我知道我应该在哪里阅读。随着我阅读越来越多的论文，我希望这变得更容易，我意识到我不需要阅读什么，或者我需要更深入地阅读什么，因为我发现我到底想专注于什么。这也与系内的助教机会相平衡，助教机会将贯穿我的第一个完整学期，涵盖 Python 编程语言，与另外两名助教和两名讲师一起领导该课程。这无疑比我想象的要耗费更多的时间，但它向我表明，我应该同时从中学到很多东西，所以这对发展我的编码技能也非常有益。所以这两个主要的任务占据了我这周大部分的时间来生成我的工作产品。
然而，除了工作之外，到目前为止把它当作一份上午 9 点到下午 5 点的工作(尽管通常是上午 8 点到下午 4 点 30 分，除非工作进一步结束)，还有一个虚拟的部门展示和讲述，展示了部门内发生的一些令人兴奋的工作，以及与其他学者、博士和硕士生见面的机会，以更好地了解他们。我们还为系里的新博士们举行了一个小型的虚拟会议，喝着咖啡/茶，这很好地了解了每个人的相处情况，确保我们保持联系，如果有什么需要，我们会互相帮助，这也将成为一个固定的特征。由于在家工作，见不到很多人，这两个当然是需要的，所以在开始攻读博士学位的同时与人保持联系是很好的。最后，昨晚我设法重新开始玩 Fives，这是一项我这次非常想念的运动，所有的预防措施都到位了，在户外进行一些急需的锻炼，回到更热情的社区，与几个我很久没见到的人聊聊天，这很好。这表明博士不仅仅是工作，还有娱乐的时间(至少到目前为止)！
所以总体来说，在我的第一周，对即将到来的事情既恐惧又兴奋，但这是意料之中的。我同时感觉到很多事情已经完成，但也有很多事情没有完成，所以我会看看下周会怎么样。能够开始这段漫长的旅程很好，我对未来充满期待。下周，我的目标是安定下来，继续做助教，为我的导师创作我的第一件作品，并继续深入了解空间交互模型的世界！
短期目标(1 周)
- 下周完成至少 12 次阅读，并开始绘制该地区关键人物的地图
- 为我的导师写我的第一篇文章
- 完成当助教的第二周
中期目标(6 个月)
- 在 6 个月内完成文献综述的草稿
- 制作一个基本的空间交互模型
- 了解我的数据的格式及其包含的内容
长期目标(3 年)
- 精通管理大型数据集和创建数据管道来处理这种情况
- 参加几个黑客马拉松
- 读完博士！！！
我希望通过每周发表的一系列博客，继续发展我在博士生涯中的这些想法、感受和行动。虽然认识到每个人的博士学位是不同的，但在开始之前，我并不完全确定博士学位将包含什么，所以我希望这些博客系列将为任何未来寻求攻读博士学位的人阐明过程！
感谢您的阅读！
我在亚马逊工作的第一周
Patrick Schneider 在 Unsplash 上拍摄的照片。
在这篇文章中，我将让你一瞥我作为亚马逊 SDE 的第一周。我会让你知道我的第一印象，以及我从世界上最伟大的公司之一学到的一些有趣的经验。注意:这篇文章表达的所有观点都是我的，绝不代表亚马逊。
但是首先…一些背景
当我第一次收到邀请时，我无法接受。我甚至还没从大学毕业，就被这家大公司邀请去工作，而这已经是我日常生活的一部分。澄清一下，我是一名 Prime 会员，Alexa 的头号粉丝，我一直在试图说服我周围的人买一台 Kindle(如果你想知道原因，请查看这篇文章)。
我花了一点时间才意识到这是一个多么好的机会，不仅是在专业层面上(这是显而易见的)，而且就我可能产生的影响而言。我会为改善数百万人的生活做出贡献吗？像我这样的人，我的家人或朋友？我甚至无法想象前方会发生什么。
我最终加入了亚马逊时尚团队，成为马德里的一名前端工程师。
入职流程
当我写这篇文章时，这实际上是我在亚马逊工作的第四周。我将描述我自己的入职经历，每个人的经历可能不同，但步骤基本相同。
第一天。一大早，我和我的经理开了“首次会议”,他向我介绍了我将在未来几周使用的平台。这是一个入职流程的指导平台，包含专为您和您的工作岗位量身定制的内容。例如，在我的情况下，有一个每天都要遵循的学习路径，在其中我可以找到内部教育视频、博客帖子、讲座、分步指南和测验，以确保我已经吸收了重要的知识。我定期学习更多关于亚马逊的内部理念，以及如何在我的团队中使用一些工具。这并不是说你在最初几周做的唯一事情就是完成课程，完全不是，你实际上被期望逐渐开始做一些小任务，并将它们与培训相结合。就我而言，我在第二周的周一接到了第一个任务。
第二天。我开始参加的每日脱口秀，这帮助我了解项目管理动态。
第三天。我有机会见到了我的登机伙伴。入职伙伴帮助解决培训过程中可能出现的任何技术疑问，以及关于工作、工具的问题，以及你脑海中出现的任何问题。就我而言，是一位高级工程师友好地向我介绍了亚马逊的内部工作原理，目前解决了我的许多新手疑问。
在整个第一周期间，我将大部分时间用于在入职平台学习。我花了大部分学习时间试图理解代码变更和部署过程是如何工作的，以及不同的内部技术。
我确实发现一个接一个地学习那么多技术可能会有点混乱。这不一定是一个糟糕的方法，但我是一个非常视觉化的人，所以我真的更喜欢在深入研究之前先有一个更广阔的画面，并看到概念之间的联系。因此，我制作了自己的方案，我的经理鼓励我将其转化为数字形式，以便在内部分享。我喜欢他们支持我们分享知识和寻求改进。
在第二周，在高级工程师的支持下，我已经被分配了一些小任务。
在第三周我正在发送代码进行评审和部署。
到这个星期(第四周)我已经有一些代码投入生产了。(耶🎉)
继续上车。即使在亚马逊工作了一个月，真的感觉不像。我还在上车平台和自己学习。总是第一天。
第一印象和教训
信任
我不知道能从亚马逊这样的公司期待什么。作为一名应届毕业生，我觉得我的意见不会被这么大的公司考虑，因为人们会认为我没有经验。我最终看到了完全相反的情况，每当我或我的同伴提出想法时，他们总是被认真听取，我从不觉得自己被当作新手对待，我经常被鼓励去完成我的提议。
个人成长
每个团队成员每周都要与经理进行 30 分钟的非正式会谈。这一周的时间专门用来谈论任何事情，除了你当前的任务。你有机会向你的经理解释更多个人问题，职业前景，你感兴趣的话题，或者寻求建议。
给我留下非常积极印象的是经理给予的巨大支持，以实现你想要的一切，即使这意味着离开球队。经理的目标是让你尽可能感到快乐，并帮助你达到目标。包括路径、国家或团队的完全改变。
一旦你和经理讨论了你的兴趣，他会试着给你分配那些与你最喜欢的话题相关的任务，或者那些对实现你的目标更有帮助的任务。他还允许你自由地提出与你的偏好相关的项目，这些项目可以让团队受益，即使这些项目不在团队最关心的范围内。
这可能看起来违背直觉，因为它很少发生在更传统的公司，然而，完全有道理。你在一家公司越开心，继续在那里工作并继续向其他团队提供知识和经验的机会就越大。这也提高了员工的绩效和工作积极性。
沟通
当然，这可能会让人不知所措。亚马逊是一家如此大的公司，人们很容易迷失在细节中，感觉自己一无所知。但事实是，没有人知道这一切。关键是专注于沟通，你不需要马上知道事情是如何运作的。就我而言，这几周我问了很多问题，似乎没有人对此感到困扰，相反，我的队友似乎很乐意回答我的疑问，并为我的学习过程做出贡献。
经理还经常检查我们对工作量的感受，并强调如果我们进入恐慌区，就要让我们沟通。这有助于避免精疲力竭，保持团队健康。
承蒙作者好意。
我们都觉得自己是骗子
在与团队的一些高级成员交谈后，我开始意识到我们都觉得自己有点像骗子，大部分时间都不知道发生了什么。这完全正常，亚马逊庞大，不可能全知道。有人告诉我，亚马逊并不真正关心聘请某个主题的专家，它试图聘请冒险家，那些愿意尝试、深入探索并坚持面对未知的人。最后，我们中的许多人，尽管觉得自己不完全胜任这份工作，但最终还是申请了。
包装它
总的来说，我的入职进展顺利。我很高兴能在这样一个友好和充满关怀的环境中工作。还有很长的路要走，我会确保继续写下去。
如果你正在读这篇文章，感谢你的时间，我真的希望你能从这篇文章中得到一些价值。下一集再见！
一些资源
我链接了一些资源，以防你想更深入地了解亚马逊文化。
我帮助初创公司构建和部署数据科学的框架
如何尽快从 idea 变成 MVP
我帮助创业公司从“产品”走向“产品+机器学习”。
这是我实现这一目标的框架，包括每个阶段的建议、警告和例子。
虽然每个公司、问题和数据都不同，但总有许多共同点。
这个框架围绕着尽快构建一个概念验证，然后逐步改进它。这遵循了我在 ML 的经验，你不知道一件事是否会起作用，直到你尝试它。
我主要从事于 自然语言处理 ，但是这个框架同样适用于图像和数字数据。
从问题或数据开始
有并购潜力的公司分为两类:
- 从问题开始(用数据解决)
- 从数据开始(从中提取价值)
有趣的是，科技公司排名第一，非科技公司排名第二。
从一个问题开始
你有一个问题，ML 也许能解决。
例子:一家初创公司想要推荐给定地理和环境条件下可以种植的蔬菜。他们没有与这个空间相关的数据。
第一步是集思广益什么数据是必需的。
然后可以通过战略伙伴关系、网络搜集或开放数据集来获取数据。
从数据开始
您拥有数据(很可能是一家正常运转的企业)，并希望从这些数据中获得额外的价值。
示例:一家制服制造商拥有关于其每个销售代表的粒度移动数据。
第一步是集思广益数据的潜在用例。
在本例中，它可能是检测哪些销售人员在他们的区域内工作效率最低。这样就可以主动鼓励他们改进。
从数据(和现有的业务)开始很好，因为边际改进是有价值的。从一个问题开始只有在解决它是有抱负的和改变游戏规则的时候才有意义。
数据探索
理解你的数据是重要的，但是在数据科学项目中经常得到太多的关注。
数据探索有助于发现您认为的数据和实际数据之间的差距。这不是炫耀你的数据可视化技能的地方。
调查数据类型、值的分布，以及是否有任何东西丢失或损坏。
列出流行的解决方案
无论你打算从头开始编写解决方案，还是在 AWS 上使用 API，都要列出潜在的算法、库和 API。
举例:你的产品检测一张图片是否含有毒蘑菇。
列出如何解决这个问题。选项包括 Fastai，Keras，Sklearn，Amazon Rekognition 和其他一些小众分类提供商。
这是高层次的，并不打算详尽。只需找到您可以使用的流行选项。
将数据分成测试集和训练集
模型在训练集上被训练，并在测试集上被评估。
我有两条建议:
- 不要看测试集中的例子。否则你会倾向于在你的训练集中添加类似的例子。当您的模型在生产环境中的表现比在测试环境中的表现差时，这会给您带来麻烦。
- 确保测试集和训练集之间的类分布相似。这将有助于训练更精确的模型。一些像 sklearn 的分层混洗分裂这样的库就是为此而设计的。
如果非技术同事参与到这个数据科学过程中，你很可能会在第一点上被推后。做好反击的准备。
尽可能简单地解决这个问题
选择您在上面找到的实现最快的解决方案，并使用最简单的可接受的预处理级别运行您的数据。
这意味着，没有特征工程，没有一大堆文字来矢量化你的文本，没有对训练图像进行最小的变换，等等…
如果一个预先训练好的模型可以完成你的任务，那就用它吧！
重点是得到一个结果，即使不是很好。
评估结果
选择衡量成功的标准。
对于分类问题，这些将是 f1、精确度和召回率。当心“准确性”,它在不平衡的数据集上具有误导性。
对于回归或推荐引擎等其他问题，您需要决定其他方法。
在一天结束时，您需要“一些”成功的数字度量来客观地比较不同的解决方案。
这是你的基线
基于以上所述，你就有了一个标记，所有未来的模型都可以用它来衡量。
此时，结果可能是可怕的。但是现在你已经意识到了问题的复杂性，以及你离解决问题有多近了。
如果你还没有，现在是决定最低可接受成功门槛的最后期限。这是您在部署到生产环境之前需要达到的目标。
请记住，模型结果因数据量和预处理类型而异。在前进的过程中，设定自己的目标，进行比较，尝试其他型号和设置。
列出你的杠杆
我们可以提升到什么水平来提升我们的结果？
全部列出来。这个列表应该是详尽的，但是要针对手边的具体问题。
示例:
- 数据清理(从文本中删除奇怪的字符)
- 矢量化(弓形、嵌入等)
- 词干化和词汇化
- 特征工程(手工和复合特征)
- 特征约简(主成分分析，前 n 个特征)
- ngrams
- 型号选择
- 超参数调谐
- 班级加权(某些模型要求培训的班级数量平衡)
通过拉动杠杆超越基线
通过拉动杠杆来改善您的模型结果。
注意拉动每个控制杆对结果的影响。这将为未来的数据科学项目建立你的直觉。
不断拉动杠杆，直到您的结果达到可接受的部署水平。
相反，你可能会发现，鉴于目前的数据、资源和技术，解决这个问题是不可能的。
生产您的模型
在本地运行一个模型和将该模型应用于生产应用程序之间存在巨大的差距。
这包括生产预处理管道和模型——达到生产的请求必须通过与训练数据相同的管道。
Pro 提示:尽可能地解耦你的模型和基础设施组件。如果您更改单个超参数，这允许重新部署小部分而不是整个管道。
正确的生产基础设施是模型大小、库、内存要求、预算和技术专业知识的函数。
深入研究这一点可以写一整本书，但是 AWS 用户应该考虑结合 EC2、Lambda 和 SageMaker 来开始。
如果你想要一些高水平的建议，请在评论中给我留言。
测试生产
你能引起奇怪的行为，或者让它抛出一个错误吗？
此时，我们只关心可伸缩性和健壮性。而不是预测的质量。
可伸缩性是它在负载变化时的表现。
健壮性是它处理意外输入的方式。
让你的整个团队都参与进来，试图让你建立的系统崩溃。最好现在就打破它，而不是在顾客使用它的时候。
如果你已经通过了以上所有步骤，那么恭喜你！您已经准备好向您的客户逐步推广 ML。
结论
这是我应用于多种机器学习和数据科学问题的通用框架。
简而言之，构建一个快速而肮脏的解决方案，然后逐步改进它，直到它足以用于生产。
一个常见的陷阱是在了解成功的可能性之前过度设计。您可能会在预处理阶段花费数年时间而没有构建出任何有用的东西，所以不要落入这个陷阱！动作要快！
这个框架应该既适用于初创企业 ML，也适用于你正在从事的任何业余爱好数据科学项目。希望对你有帮助。
我在 Visual Studio 代码中的 Java 设置
一本入门书，确保您拥有成功开发 Java 应用程序所需的工具
目标
在设置好本地开发环境之后，启动一个简单的 Java 应用程序。
我们将尽可能保持简短。您将能够在不到五分钟的时间内在 VSCode 环境中启动并运行 Java 代码。
这些是我们将要安装的工具:
- Visual Studio 代码
- Java 开发工具包(JDK)
- 增强我们环境的 Java 扩展
我们开始吧！
下载 VS 代码
从 Visual Studio 代码下载稳定版本。
这是一个非常简单的下载。微软在简化这个应用程序的安装过程方面做得很好。
下载 Visual Studio 代码 Java 包安装程序
这个过程已经自动化，你不会相信。
我们将导航到这个站点:https://code.visualstudio.com/docs/languages/java，然后向下滚动到你看到“下载 Visual Studio 代码 Java 包安装程序”的地方
这个安装程序将处理所有 Java 相关的包，这些包是您开始 Java 开发所必需的。
点击“安装”按钮，这将需要几秒钟来完成。
安装 Java 扩展包
一旦安装了 JDK，我们就可以安装扩展包了。这些工具将增强我们的项目。它增加了自动完成、依赖查看器、Maven 支持、调试器、测试运行器等功能。
在我们刚刚访问的 VSCode 站点上，向下滚动直到您看到以下内容:
点击安装 Java 扩展包按钮。
你好世界
成功安装此扩展包后，您将看到如下所示的屏幕:
我们将按照说明创建一个新文件。在这个文件中，我们将放入以下代码:
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World.");
}
}
当您单击“运行”按钮(或按 F5)时，您应该会在控制台中看到以下输出:
注意:如果你在路上的任何地方有一个空格。例如，如果这是我的道路:C:\Users\Ryan Gleason\Documents\…
一个快速的解决方案是将您的默认终端切换到 Powershell。
键入Ctrl + Shift + P打开命令面板，输入终端:选择默认 Shell 并选择 Powershell 选项。
仅此而已。现在，您已经准备好在 VSCode 中使用 Java 构建一些令人惊叹的东西了！
我的数据科学博客之旅
以及在媒体上写博客如何改变了我的长期职业前景。
图片来自 Pixabay 的 Sasin Tipchai
简介
我在 2019 年 10 月开始写关于数据科学和机器学习的博客。现在，10 个月过去了，我想与我的读者和其他考虑开始自己博客的数据科学家分享我的旅程。
在这 10 个月里，我没有靠我的博客谋生，也没有成为一个拥有大量追随者的数据科学影响者，但是，我写了几十篇文章，被媒体读者阅读了超过 18 万次。
更重要的是，通过分享我的知识，我学到了很多。
这一切是如何开始的？
写博客前的时间
2019 年 5 月，我开始在 Thinkful 数据科学训练营担任导师，这就是我如何发现 Medium 的。当我开始指导时，我从我的学生那里收到了很多关于许多数据科学和机器学习概念的额外资源的问题。原来很多时候我都有给他们推荐中等文章。
我注意到 Medium 涵盖了数据科学的不同主题，我发现这些文章对初学数据的科学家特别有用。这时候我才意识到，我自己大概也能写出这样的文章。此外，我每天都和学生打交道，所以我知道他们在纠结什么概念。
第一篇博文
我没有想太多，决定写我的第一篇文章。在此之前，我做了一个关于媒体写作的快速研究，并了解到我应该在我的文章中包含一些照片，并为出版物写作。
我在阅读媒体文章时最常用的出版物是关于数据科学的，所以我决定申请成为它们的作者。令人惊讶的是，他们接受了，我发表了我的第一篇文章:“每个人都可以并且应该学习数据科学的 5 个理由”。
同一天，我获得了 130 次浏览，第二天几乎达到了 500 次。也有一些喜欢的。对一些人来说，这些数字可能看起来不算高，但对我来说，这就足够了。人们在读我写的东西，我被吸引住了。
后续帖子
在我的第一篇博文‘成功’之后，我继续写博客，写了更多关于数据科学的文章。在最初的几个月里，我想写就写，所以我最初的写作时间表有点不一致。有几个月我发表了六篇文章，也有几个月我一篇也没发表。
在过去的几个月里，我决定写博客应该成为我的数据科学家日常生活的一部分。最初的几个月告诉我，我喜欢与他人分享我的知识，我的职业生涯应该朝着包括这一点的方向改变。
这是我开始更经常写博客的时候。我目前试图每周写一篇关于机器学习或数据科学的文章。
中等和统计
每周写几个小时，我已经取得了以下中等统计数据(2020 年 7 月 29 日实际数据)。
发表文章 : 28 篇
关注人数 : 768 人
总浏览量:18 万以上
所有这些数字都令人鼓舞，而且还在继续增长。我希望交付高质量的内容将有助于我在接下来的几个月里增加我的受众。
开自己的博客
这个小小的成功启发了我，我创建了自己的博客:aboutdatablog.com。我希望我的文章能让更多的人知道，包括那些不使用媒体的人。它还将允许我提供不同类型的内容，并对我发布的内容有更多的控制权。
未来计划
我目前的目标是每周在 Medium 和我的博客上发表一次高质量的文章。我没有很多我想联系的观点或追随者。我宁愿专注于写好质量的内容。
这是我到目前为止一直在做的事情，它对我来说似乎很有效。最后，我的文章在世界各地都有读者，我希望它们能帮助一些人应对数据科学挑战。
最终，我希望能够将这个小爱好变成一个更严肃的数据科学学习项目。甚至可能在未来创建一门数据科学相关的课程。
我对如今有这么多人想学习数据科学感到惊讶，我认为作为一个在该领域已经有一些经验的人，我应该能够帮助他们。
给考虑创建自己博客的数据科学家的建议
不要想它，只管去做！
可能你们中有很多人想开自己的博客，但却推迟了，因为他们认为现在还不是时候。
永远不会有‘正确的时间’，所以如果你想写博客，现在就开始写你的第一篇文章并发表。
Medium 让你开始写博客变得如此简单。你不需要自己的域名，也不用担心托管自己的网站。
感谢纸条
我只想留下一封简短的感谢信，感谢数据科学团队发表了我的第一篇媒体文章，从而让我开始了我的博客之旅。
如果没有媒体平台和数据科学出版物的支持，我不认为我有勇气创建自己的博客。
另外，感谢我所有的活跃读者到目前为止的评论和支持。
原载于 aboutdatablog.com: 我作为数据科学博主的旅程，2020 年 7 月 30 日。
PS:我正在 Medium 和aboutdatablog.com上撰写深入浅出地解释基本数据科学概念的文章。你可以订阅我的 邮件列表 在我每次写新文章的时候得到通知。如果你还不是中等会员，你可以在这里加入。
下面还有一些你可能喜欢的帖子
* [## 作为一名有抱负的数据科学家，你应该关注的中型作家
我最喜欢的 10 个数据科学博主，让你的学习之旅更轻松。
towardsdatascience.com](/medium-writers-you-should-follow-as-an-aspiring-data-scientist-13d5a7e6c5dc) [## 熊猫概况和探索性数据分析的第一行代码！
了解如何为自动 EDA 安装和使用 pandas profiling
towardsdatascience.com](/pandas-profiling-and-exploratory-data-analysis-with-line-one-of-code-423111991e58) [## Jupyter 笔记本自动完成
数据科学家的最佳生产力工具，如果您还没有使用它，您应该使用它…
towardsdatascience.com](/jupyter-notebook-autocompletion-f291008c66c) [## 9 大 Jupyter 笔记本扩展
改进笔记本电脑功能，提高您的工作效率
towardsdatascience.com](/top-9-jupyter-notebook-extensions-7a5d30269bc8)*
我作为数据科学家的旅程
我的数据科学之旅，以及这一切是如何开始的
由 Unsplash 上 Mukuko 工作室拍摄的照片
我第一次进入数据科学领域的时候是 16 岁。我依稀记得坐在我父亲的对面，他给了我一份职业选择清单。
大约一个小时后(和他告诉我，攻读新闻专业学位是个糟糕的主意)，我们选定了职业道路。
数据科学。
那时候，我完全不知道自己会陷入什么样的境地。我是我所知道的技术最差的人，完全不知道任何与计算机相关的事情。
几天后，我报名参加了大学的计算机科学项目，并选择了数据科学专业。
时间过得很快，我轻松地度过了大学时光，心中完全没有最终目标。“我所要做的就是学习课本材料，每个学期都取得好成绩，”我想。“那我就能找到一份好工作了。”
叫醒电话？
Julian Hochgesang 在 Unsplash 上拍摄的照片
当我意识到自己完全没有进入就业市场所需的技能时，我的警钟就敲响了。
这是和我的讲师的一次对话，他是我一生中第一次上编程课的老师。她的期望很高，对我来说更是如此——我从来没有安装过 IDE。
对于一个向完全新手教授这门课程的人来说，她的耐心相当少。当我正在努力运行一堆代码时，她说了一句让我至今难忘的话:
“ 有些人就是做不到。”
作为一名在班上总是名列前茅的学生，也是我所做的每一件事情中的佼佼者，我的讲师的话就像一块巨大的砖头一样击中了我。
她的话暗示我不适合编程，这不适合我。这是我一生中第一次有人对我说这样的话。她的话对我的自尊心是一个巨大的打击。
这真的让我想证明她是错的，因为我内心深处知道，如果我真的想学，我是有可能学会的。
我还意识到，不知道如何编码(只有理论上的 CS 知识)在未来试图找工作时不会有太大用处。
这意味着我必须学习，而且必须学得很快。
创建我自己的学习计划
我决定，如果我要自学，我必须制定自己的教学大纲，从零开始学习。
我从学习 Python 开始，每天花大约 7-8 个小时在 LeetCode 和 HackerRank 等网站上编写代码。
我同时上了大学网络课程，自习的时候完全逃课。我会在手机上上课，然后学习我自己的材料。
我花在编码上的时间确实帮助我提高了技能，同时也提高了我的自信心。
我还参加了多门在线课程以获得数据科学和分析的基础知识，并且每天至少花 4 个小时学习数学和理论材料。
超越在线课程
Anna Kolosyuk 在 Unsplash 上的照片
这条建议“做你自己的数据科学项目，”在互联网上到处都是。这正是我在获得该领域的基础知识后所做的。
我内心一直是一个创造者。
事实上，我相信在他们的内心深处，每个人都是创造者。
你一生中有多少新想法？轻松过千？
现在，这些想法中有多少是你真正付诸实施的？
我猜这个数字要小得多。
完成在线课程后，我已经参与了多个小项目。我也有开始自己的项目所需的编程背景。
所以我就这么做了。
我想出了新的项目想法和数据来分析。我通过我的 Jupyter 笔记本把这些想法变成了现实。
这件事花了我好几天的时间。基于一个想法创建项目不是一件容易的事情。有时候，我会半途而废，意识到这个项目不可能完成。
不管结果如何，我总是在创造。
作为一个热衷于讲故事和新闻的人，我把我的想法放在一起。我用笔围绕我的项目写了一些故事，并在互联网上发表。
一切都始于一个想法。我写的每个故事，我参与的每个项目。
我会像没有人阅读一样写作，像没有人观看一样创作。
克服自我怀疑
亚辛·优素福在 Unsplash 上的照片
每次这个行业的新人来找我，通常都是关于项目的开始。
我最常被问到的问题是:“我该如何开始？”
我的回答:“别问了。就开始吧。”
将你的想法付诸实践。
也许这是个糟糕的主意。也许结局会很可怕，你得从头再来。
但那又如何？
每次你创造的东西没有按照你想要的方式运作，你就学到了东西。并重复。重新学习。
学习不是一个线性的过程，所以不要期望它是线性的。每一次犯错，你都会从中成长。
事实上，你会从错误和失败中学到比成功项目更多的东西。
没人看我的作品怎么办？
当我开始创建项目、讲故事和写作时，我完全是从零视角开始的。
没人看我的网站，没人看我的博客，没人看我的 Github 库。
但这并不重要。
我继续做我喜欢的事情，仅仅是因为我热爱它。
你努力工作的回报会到来，但你需要等待。做事情只是因为你喜欢，而不是因为你想获得利益。
结论
截至目前，我在数据科学领域同时学习和工作。
我每天醒来都兴奋地学习新事物，想出点子，创造新项目。
到目前为止，这是一个不可思议的旅程——它的开始是因为我决定克服恐惧，像没有人看一样创造。
创造的欲望是人类灵魂中最深切的渴望之一——老乌奇多夫
我从大型机到数据科学的旅程
“大型机”技能如何直接融入我目前的数据科学家角色。
克里斯蒂娜@ wocintechchat.com 在 Unsplash 上的照片
我的职业目标一直是“做有趣的事情”。
我在 IT 行业工作了无数年。从初学者到技术带头人，我用永不沉没的 Cobol 语言编写代码。我操作 DB2 数据库，然后是它闪亮的快速设备 IDAA。今天，我是一名全职的数据科学家。是的，这是可能的。我在 IT 方面获得的技能可以直接转移到我目前的职位上。如果你正在考虑进行类似的转变，不要忽视你之前的经历。
那些年，我专注于数据。无论是编写代码、设计数据库还是运行分析，数据总是第一位的。如果我遇到一个我不熟悉的问题，我会做的第一件事是运行一个脚本来提取所有相关数据。我专门从事记录批量交易和客户交易的工作。我会把数据拼凑起来，讲述一个正在发生的故事。我把自己想象成那个客户，在系统中蜿蜒前行，留下了这条数据耗尽的痕迹。
数据科学简介
大约六年多前，我开始对数据科学感兴趣。我不记得是如何或为什么，它迷失在午夜呼叫页面(是的，寻呼机)和给家庭增加两个孩子的阴霾中。我从 DS 在线入门课程开始，python，机器学习。吴恩达是我学习期间的向导。
当我开始使用我的新技能时，我开始思考我的工作流程。机器学习能带来什么好处？我曾经考虑过为我们的事故单队列创建一个预测模型。在积压的数百张罚单中，有没有什么无声炸弹在等待引爆？当时，大多数大型非科技公司都没有合适的工具让开发者涉足这个领域。他们还没准备好迎接我。作为一名顾问，我不得不探索我在数据科学方面的兴趣。
创造我自己的机会
与此同时，我在工作中承担了一个大规模的多年数据分析项目。我有机会帮助定义我们想要收集哪些数据以及如何存储这些数据。考虑到未来的机器学习，我们创建了一个强大的历史数据库，已经明确格式化用于分析。这是一个令人难以置信的工作量，有着非常远大的目标，所以我需要变得有创造性，在这个项目上找到足够多的编码人员。我们必须从多个存储库中(Db2、IDAA、Oracle、SQLServer 和 Hive)的数百个表中提取数据。我们举办了内部黑客马拉松，让人们为所有这些数据点编码。时间很长，但一个伟大的跨职能团队完成了它。最终代码正式开启，我们庆祝直到 Ubers 带人回家。这项工作是值得的。该计划继续取得成功，历史数据存储丰富(并带有时间戳),可用于一些令人兴奋的机器学习。
当我开始轮换那个项目时，我评估了。我会做有趣的事情吗？不完全是。在这个项目中，是时候把我的机器学习技能和我的专业知识结合起来了。我为负责这个项目的业务部门的分析部门主管提出了一些设想。我们如何用机器学习来改进这个过程？我做了一个成功的商业案例，并发现自己被邀请到商业领域去“实现它”。
可转移的技能
除了具体的数据科学培训和咨询经验，我的许多“大型机”技能也直接有助于我在当前职位上取得成功。我在下面列出了几个。如果您曾经担任过 IT 数据职位，那么这些对您来说可能非常熟悉。
- 数据摘录。能够创建复杂高效的 SQL 每天都在帮助我。在专为 it 设计的硬件上连接、转换和清理数据的能力让您的生活变得更加轻松。它推翻了经常被引用的导致人们如此悲伤的 80% munging 统计。
- 编程概念。即使是恐龙 Cobol，也有可转移的特质。我在不同版本的 SQL 和语言之间切换的经验使得现在这样做不那么困难了。理解 Java 让 python 感觉很简单。了解 python 让学习 scala 变得更容易。
- 设计。大多数数据科学课程传统上都没有涉及到，设计复杂的端到端系统是有益的。你知道的越多，你对别人的依赖就越少。对未来代码重用和灵活性的规划是从经验中学习的。运行良好的良好数据库设计将使您的过程运行得更快、更便宜。
- 测试。你如何设计你的代码，使其具有弹性和可理解性？你如何设置测试用例来确保它如你所愿的那样工作？当代码被标上你的名字，你就永远拥有了它。当它在凌晨 3 点失败时，你会接到电话。你喜欢凌晨 3 点被叫吗？我不这么认为。经验提供了宝贵的教训，您可以将其应用于数据科学。
- 基于现实的期望。一般来说，不仅仅是数据科学，大多数课程都关注“快乐之路”经验丰富的 IT 人员更了解这一点，他们将代码设计得灵活且可扩展。数据会被破坏，上游流程会改变，客户会出乎意料地行动，而业务发起人希望代码一发布就有新的特性。
两份外卖
第一，如果您正在考虑从大型机过渡到数据科学，您可以实现它。你已经掌握了很多技能。
第二，如果你是一名新的数据科学家，你可以从你的“恐龙”主机同事那里学到很多东西。
我将 PyTorch 转换为 TensorFlow Lite 的历程
有时候一个傻瓜要做一个傻瓜该做的事
摘自维基媒体
介绍
我最近不得不将一个深度学习模型(一个 MobileNetV2 变种)从 PyTorch 转换为 TensorFlow Lite 。这是一个漫长而复杂的旅程，要经历很多磨难才能成功。我发现自己从 Stackoverflow 帖子和 GitHub 问题中收集了一些信息。我的目标是分享我的经历，试图帮助其他像我一样迷失的人。
免责声明:这不是关于如何正确进行转换的指南。我只想分享我的经历。我可能做错了(特别是因为我没有 Tensorflow 的经验)。如果你注意到一些我可以做得更好/不同的地方，请评论，我会相应地更新帖子。
任务
将深度学习模型(一个 MobileNetV2 变体)从 Pytorch 转换为 TensorFlow Lite。转换过程应该是:
py torch→ONNX→tensor flow→TF lite
试验
为了测试转换后的模型，生成了一组大约 1000 个输入张量，并为每个张量计算 PyTorch 模型的输出。该集合随后被用于测试每个转换的模型，通过在整个集合上的平均误差度量，将它们产生的输出与原始输出进行比较。平均误差反映了在相同的输入下，转换后的模型输出与原始 PyTorch 模型输出的差异。
我决定将平均误差小于 1e-6 的模型视为转换成功的模型。
可能还需要注意的是，我在张量中添加了批次维度，尽管它是 1。我这么做没有任何理由，除了我之前将 PyTorch 转换为 DLC 模型的经验所带来的直觉。
将 Pytorch 转换为 ONNX
这绝对是最简单的部分。主要感谢 PyTorch 上优秀的文档，比如这里的这里的和这里的。
要求:
- ONNX ==1.7.0
- PyTorch ==1.5.1。
Pytorch 至 ONNX 转换
新创建的 ONNX 模型在我的示例输入上进行了测试，平均误差为 1.39e-06。
注意，为了在 ONNX 模型中运行它，您必须将torch.tensor示例转换成它们的对等示例np.array。
将 ONNX 转换为张量流
现在我有了我的 ONNX 模型，我使用ONNX-tensorflow(v 1 . 6 . 0)库来转换到 tensor flow。我没有使用 Tensorflow 的经验，所以我知道这是事情变得具有挑战性的地方。
要求:
- tensor flow = = 2 . 2 . 0(onnx-tensor flow 的先决条件。然而，它对我的 tf-nightly build
2.4.0-dev20200923也有效 - 张量流-附加项==0.11.2
- onnx-tensor flow= =1 . 6 . 0
我不知道确切的原因，但这种转换只在 GPU 机器上对我有效。
ONNX 到张量流转换
我在创建的 TensorflowRep 对象上运行了我的测试(用它进行推理的例子在这里)。运行非常慢(大约 1 小时而不是几秒钟！)所以让我很担心。然而，最终，测试产生了 6.29e-07 的平均误差，所以我决定继续前进。
此时最大的问题是——出口了什么？这个.pb文件是什么？在网上做了一番调查后，我意识到这是一个[tf.Graph](https://www.tensorflow.org/api_docs/python/tf/Graph)的例子。现在 剩下的 要做的就是把它转换成 TensorFlow Lite。
将 TensorFlow 转换为 TensorFlow Lite
对我来说，这就是事情变得非常棘手的地方。据我所知， Tensorflow 提供了 3 种将 TF 转换为 TFLite 的方法 : SavedModel、Keras 和 concrete functions。我对这些选项不太熟悉，但是我已经知道 onnx-tensorflow 工具导出的是一个冻结的图形，所以这三个选项对我都没有帮助:(
在网上探索了一段时间后，这个家伙基本上拯救了我的一天。原来在 Tensorflow v1中支持从冻结图转换！我决定对剩下的代码使用v1 API。
当运行转换函数时，出现了一个奇怪的问题，它与protobuf库有关。按照这个用户的建议，我能够继续前进。
TF 冻结图形到 TFLite
您可能会认为，在经历了所有这些麻烦之后，在新创建的tflite模型上运行推理可以平静地完成。但是我的麻烦并没有就此结束，更多的问题出现了。
其中一个与名为“ ops ”(带有“ops that can be supported by the flex.”的错误消息)的东西有关。经过一番挖掘，我意识到我的模型架构需要在转换之前显式启用一些操作符(见上文)。
然后，原来我的网络使用的很多操作还在开发中，所以当时运行的 TensorFlow 版本(2.2.0)无法识别它们。这是通过安装 Tensorflow 的夜间构建，特别是tf-nightly==2.4.0.dev20299923解决的。
我的另一个错误是“The Conv2D op currently only supports the NHWC tensor format on the CPU. The op was given the format: NCHW”。这在这位用户评论的帮助下解决了。
最终，这是用于测试的推理代码—
TFLite 推理
测试的平均误差为 2.66-0.7
我希望我的经验对你有用，祝你好运！
相关链接
官方文件:
- https://pytorch.org/docs/stable/onnx.html
- https://py torch . org/tutorials/advanced/super _ resolution _ with _ onnx runtime . html
- https://github.com/microsoft/onnxruntime
- 【https://github.com/onnx/tutorials
- https://www.tensorflow.org/lite/guide/ops_compatibility
- https://www.tensorflow.org/lite/guide/ops_select
- https://www . tensor flow . org/lite/guide/inference # load _ and _ run _ a _ model _ in _ python
问题和堆栈溢出
- https://stack overflow . com/questions/53182177/how-do-you-convert-a-onnx-to-TF lite/58576060
- https://stack overflow . com/questions/55475551/toco-from-protos-command-not-found
- https://github . com/onnx/onnx-tensor flow/issues/535 # issue comment-683366977
- https://github.com/tensorflow/tensorflow/issues/41012
我的数据之旅
我进入数据世界的道路以及在此过程中我学到的一些经验。
我在雅典耀大学学习计算机科学，并获得了数据科学和分析的专业学位。在那里，我学会了如何编码和如何管理软件项目。我在 RideWave 得到了一份数据分析师的实习工作，这是一家提供上下班班车的初创公司。我写了一篇关于推特用户行为模式的论文并毕业了。我加入了第一圈数据团队，这就是我的旅程。嗯，我撒谎了；事实上并没有那么简单。旅程远非直线。
三年前，如果你问我数据工作是什么样的，我可能会从谷歌或其他人的媒体文章中给你一些一般性的答案，甚至可能是茫然的凝视。两年多以前，我甚至不确定自己是否想从事数据方面的职业。我从来没有想过我会在这个位置上和那些可能比我年长几岁的人谈论我的数据工作之旅，最好的方式就是告诉你我学到的东西以及我是如何学到的。
那么让我们回到我所说的我进入数据之旅的开始，我在计算机科学的第二年快结束的时候，这通常是大多数人最终决定他们是要留下来还是离开这个项目并追求另一个学位的时候。那时，我已经决定留在这个项目中，但我必须找到答案的一个问题是，我是否要专攻，以及我要专攻什么。唯一让我感兴趣的项目是数据科学和分析。
这是我在课堂上。老实说，我绝对不是最好的学生之一。
回想起来，这引发了一连串的事件，因为它为我打开了可能性的领域；作为一个并不特别喜欢软件工程或网络开发的人，这是计算机系的人可能会走的路。我开始学习数据库、计算机模拟、社会计算和基于代理的建模课程。
与此同时，我也开始加入围绕数据使用的黑客马拉松，并在 Kaggle 数据集上进行实验，试图弄清楚数据科学是否适合我，并尽可能多地学习相关知识。Kaggle 和黑客马拉松教会了我机器学习算法，或者至少让我了解了他们做了什么，以及如何实现它们。
关键要点:学校和在线课程对于学习基础知识非常有用。学习是结构化的，我接触了一堆不同的东西，尽管只是表面的。学校让我接触到了网络、容器化、一般编程实践和软件开发实践的基础知识。
快进到第四年年初，我在 RideWave 实习，这是一家早期创业公司，旨在为人们提供每天上下班的方式。
最初，我们在 Google Sheets 上工作和存放数据库，但这严重缺乏我们需要的能力。每张表格都要花几分钟来加载，要么这样，要么 Google Sheets 本身就会崩溃。因此，我和我的合作实习生开始为一个专用数据库的实施做一个案例，这花了我们很长时间，因为我们的经理有太多的问题。
我还开始学习如何使用 Twitter API 和谷歌地理位置 API 来使用 API，我们收集数据来了解对 Grab 和优步等拼车应用的看法，并试图将它们映射到位置，以了解我们可以扩展到哪里。
关键要点:我在这里学到的一件重要事情是，技能比工具更重要。理解数据存储和数据处理的核心概念可以教会你在不同工具之间转换的技能。学习 R 还是 Python 之间的争论总是很有趣，但是在现实中，如果你可以用这两种工具实现同样的事情，那么结果是一样的。了解工具是很好的，但只是在付诸行动之前。
之后，我回到学校，写论文，临近毕业时，我开始寻找可能的工作地点。我申请了很多不同的公司，他们的数据团队成熟度各不相同。有些显然已经建立，而另一些则处于起步阶段。甚至有些人正在寻找他们进入团队的第一份工作。
我收到了一些邀请，但是更多的拒绝或者其他的甚至没有给我回复。拒绝的次数可能至少是提议的两倍。回想起来，许多这样的拒绝可能是为了更好。甚至当时我梦想中的公司拒绝了我。我发现自己在面试一些公司，而我对这些公司的工作一点也不感兴趣。其他时候，我甚至去参加面试，但我对他们提供的角色并不感兴趣。
关键要点:我想指出的真正重要的一点是，你必须弄清楚你想做什么。如果可以的话，你想成为一名数据工程师、数据分析师或数据科学家，并与你未来的经理谈论这些吗？数据工作是一个完整的领域，很难同时兼顾这三个方面，所以你必须明白自己想要什么，看看公司提供的东西是否与此相符。
在我找工作的某个时候，我偶然在脸书集团的一个帖子上看到一个帖子，谈到这个数据团队正在招聘，该公司是一家旨在通过提供金融服务来为中小企业提供支持的初创公司。我看了看这份工作，然后申请了。只是想看看它会走向何方。与团队经理交谈，符合他们对角色的预期，参加测试，并参加面试。
老实说，通过与经理的第一次通话，我对这个团队很感兴趣。他很好地管理了期望，并且对这个角色需要什么很坦率。我仍然记得他在采访中表示的一件事是，最初的工作可能更多地是在工程方面，这一点我完全同意。
我去年 7 月开始在 First Circle 工作，参与了不同的项目，让我接触到业务的不同方面，以及不同背景的不同人。
我在团队中做的第一个项目是建立一个图形数据库。如果你在我写论文之前问我什么是 graph DB，我根本不知道你在说什么，我也不知道我们在讨论这个业务。我们本可以更好地向企业介绍它是什么以及随之而来的可能性。直接利益相关者应该从一开始就参与进来，这可能会使我们在新数据库上的工作协调一致。
我们试图更好地理解现实世界的关系，并描绘出网络效应。听起来很酷，对吧？曾经是，但有一件事是商业必须指导我们做什么和制造什么。不要误解我的意思，我仍然相信该项目会在未来带来更多令人惊叹的工作，但是如果我们将它与企业更具体的目标联系起来，影响会更直接。
另一方面，我从事这个小得多的工作，它在测试后立即被业务使用。这项工作只是试图实现一些信贷限额增长的解决方案，只是几行代码。这是因为从工作的第一天起，直接利益相关者就已经大量参与。事实上，他们提出了这个问题。我们一起试图弄清楚到底发生了什么以及为什么。然后，我们一起集思广益，寻找可能的解决方案。当实现的时候，涉众已经就需要什么样的解决方案达成了一致。
关键要点:业务影响是项目的重中之重。除非你和他们一起建立，否则业务中的人不会理解可能性，所以你必须沟通并理解他们来自哪里。一个数据人员应该深入业务，了解业务是什么以及它是如何工作的。
总的来说，数据工作或技术，甚至生活本身，如果我们是哲学的，肯定是关于不断学习。总会有新的工具和新的新颖算法需要学习和研究，但每个人都需要尽早弄清楚的最大问题是如何学习。
蒙特卡罗方法
强化学习之旅
使用机器学习来表示、探索和解决真实世界的场景。
欢迎来到我的强化学习研究的另一个章节。到目前为止，我们已经奠定了强化学习的基础，使用有限马尔可夫决策过程(MDP)来描述已知的环境。这一切都很好，直到我们遇到一种情况，环境的一切都不为人所知。这更有趣，因为它更真实，更接近真实生活环境(如果事情像 gridworld 一样简单就好了)。像往常一样，我会在这个博客的底部发布资源。让我们开始吧。
蒙特卡罗 (MC)方法不需要知道整个环境才能找到最佳行为。术语“蒙特卡罗”广泛用于任何包含显著随机成分的估计方法。在我们的例子中，他们所依赖的是经验，即状态、行动和奖励的重复序列，来自与环境的互动。我们将这些互动分成集，以便能够定义这些序列的开始和结束。我们可以使用上一篇博客中的相同概念来评估一项政策，但区别是关键:上一次我们是基于对 MDP 的了解来计算价值函数，而这次我们是从 MDP 的样本回报中学习价值函数。正如我们之前所做的，我们将从计算固定的任意策略π的值函数和动作-值函数开始，然后转向策略改进，然后转向控制问题及其通过一般策略迭代的解决方案。
回想一下，一个状态的价值是从该状态开始的预期累积未来贴现回报。根据经验来估计，我们可以简单地平均访问该州后观察到的回报。根据大数定律，当观察到许多回报时，平均值将最终收敛到期望值。现在，这个平均值既可以从第一次访问到特定状态获得，也可以从每次访问的获得。这两种 MC 方法非常相似，但有细微的差别。先来看看初诊 MC 预测。
http://incompleteideas.net/book/RLbook2018.pdf
让我们用一个真实世界的情况来帮助实现这一点。21 点是一种大多数人都熟悉的纸牌游戏，并且简单易学。在每一轮开始时，玩家和庄家都发两张牌。直到回合结束，玩家只能看到一张庄家的牌。游戏的目标是让牌的价值尽可能高，但不超过 21。所有的面牌都算 10，一张 a 可以算 1 或者 11。玩家可以“打”，收到另一张牌，或“坚持”，停止接受牌，开始发牌。庄家按固定的策略出牌:他坚持任何 17 或以上的数目，否则就打。如果庄家“破产”，或超过 21，玩家获胜。否则，结果(赢、输或平)取决于谁更接近 21 岁。
一个重要的注意事项是，如果玩家持有一张可以算作 11 而不会破产的王牌，那么这张王牌被认为是可用的。在这种情况下，它总是被计为 11，因为计为 1 将使和等于或小于 11，这是玩家每次都应该碰到的。因此，玩家根据以下观察做出决定:他当前的总和(12–21)，庄家的出牌(a-10)，以及他是否有可用的 a。这总共有 200 种可能的状态。
我们可以认为这是一个插曲式的有限 MDP，每一轮都是一个插曲。赢、输、抽分别给予+1、-1、0 的奖励。一轮中的所有奖励都是零，这意味着这些最终奖励被视为回报:
在我们的例子中，我们不贴现，所以 γ = 1。
假设我们有一个策略，如果玩家的和是 20 或 21，那么这个策略就有效，否则就无效。为了找到状态值函数，我们可以模拟许多遵循策略的游戏，并对每个状态的回报进行平均。
通过蒙特卡罗策略评估我们给定策略计算机的近似状态值函数
从上面的图表中可以看出，当玩家总数达到或超过 20 时，该值会大幅上升，随着玩的游戏越来越多，其他州的值会变平。有一个可用的 ace 是非常罕见的，所以需要更多的剧集来获得更准确的价值函数，如左边的图表所示。
现在让我们继续使用蒙特卡罗估计进行控制，或者近似最优策略。主要思想与动态编程相同:通用策略迭代(GPI)。策略评估完全如上所述进行，并且通过使策略相对于当前值函数(现在是动作值函数)变得贪婪来进行策略改进。当模型不可用时，就需要行动价值函数，因为我们需要估计每个行动的价值来提出政策建议。因此，我们着眼于估计 q⁎ 。对于动作值函数 q ，对应的贪婪策略是选择具有最大动作值的动作的策略:
在 gridworld 中执行 GPI 时，我们使用了值迭代，在策略改进的每一步之间只迭代一次策略评估。对于蒙特卡罗策略迭代，每集后观察到的回报用于策略评估，然后在该集期间访问的所有州改进策略。
为了确保探索，蒙特卡洛中使用了两种方法:政策内方法和政策外方法。策略上的方法评估或改进用于制定决策的策略，策略外的方法评估或改进不同于用于生成数据的策略。在 on-policy 控制方法中，策略通常是软，这意味着对于所有状态和动作而言
【π(a | s)】>0，但是逐渐向确定性最优策略转变。我们接下来要看的 on-policy 方法将采用一个 ε-greedy 策略，这意味着我们将随机选择一个概率很小的动作 ε 。一项 ε-greedy 政策的美妙之处在于它的概念和实施是多么简单，以及它在保证我们取得进展，变得更好或与我们开始时的政策一样好时是多么有效。这被称为政策改进定理:
因此，事不宜迟，下面是一个基于策略的首次访问无模型蒙特卡罗控制算法的伪代码:
http://incompleteideas.net/book/RLbook2018.pdf
在将该算法实现到我们的 21 点环境中并模拟 500，000 集时，蒙特卡罗算法通过迭代更新的动作值函数为我们找到最优策略，这也收敛到最优；见下图。
既然我们已经讨论了政策上的学习，让我们继续讨论政策外的学习。记住，这意味着我们评估一个目标策略 π(a|s) ，同时遵循一个单独的行为策略 b(a|s) 。代理采用这种学习方式有几个原因。一个是代理可以通过观察其他代理来学习，比如人类。代理可以观察一个人如何执行某项任务，并从该经验中学习/改进它。策略外学习的另一个非常重要的动机是，我们想要找到一个最优的、确定性的策略，它根本不探索，但是我们需要探索行为来找到它。通过非策略学习，我们可以在遵循一个策略的同时学习多个策略。
我们现在要学习的技术是重要抽样，这是一种在给定另一个样本的情况下估计一个分布的期望值的方法。我们通过获得重要性抽样比率将其应用于非策略学习，重要性抽样比率是根据它们在目标和行为策略下出现的轨迹的相对概率的加权回报。它可以表示为
p 是状态转移概率函数。请注意，尽管这些概率通常是未知的(因为我们正在讨论一个未知的环境)，但它们的分子和分母是相同的，因此相互抵消。这一点很重要，因为这意味着重要性抽样比率仅依赖于两个策略和序列，而不依赖于 MDP。
所以，我们试图估计目标政策下的预期收益，但只有来自行为政策的收益 Gₜ ，这就有了错误的预期。通过引入重要性抽样比率，它将收益转换为正确的期望值:
跨剧集边界对时间步长进行编号变得很方便，这意味着如果第一集在时间 10 结束，则下一集在 t=11 开始。也就是说，我们可以使用时间步数作为特定情节中特定步骤的参考。对于每次访问方法，我们可以将访问状态 s 的所有时间步长集合表示为 T(s) ，我们将在下面使用。对于首次访问方法， T(s) 将仅包括在剧集中首次访问 s 的时间步长。我们还将 T(t) 表示为时间 t 之后的第一次终止时间， Gₜ 表示从 t 到 T(t) 之后的返回。使用简单的平均值，重要性抽样通过按重要性抽样比率缩放回报并平均结果来估计价值函数:
即普通重要性抽样，但以下练习将使用加权重要性抽样，它使用加权平均值:
或者如果分母为零，则为零。这两种重要抽样的区别在于它们的偏差和方差。普通重要性抽样是无偏的，但通常具有无限的方差，在实践中，这种方差导致目标和行为策略努力寻找共同点。这就是为什么加权估计量通常是首选的原因。
那么，如果我们能够在一集接一集的基础上实现蒙特卡罗预测方法会怎么样呢？这叫做增量实现。我们通过平均回报来做到这一点，但对于非政策的加权重要性抽样方法，我们如何做到这一点呢？我们必须对收益进行加权平均。
如果我们有一个返回序列 G₁ ， G₂ ，…， Gₙ₋₁ ，它们都从同一个州开始，并且每个都有一个相应的随机权重 Wᵢ ，我们希望估计
并在我们获得额外回报 Gₙ 时更新它。我们还必须维护每个州的第一个 n 个返回的权重的累计和 Cₙ 。 Vₙ 的更新规则是
和
其中 C₀ ≐ 0 。
因此，这篇博客文章的最后伪代码显示了一种基于 GPI 和加权重要性抽样的非政策蒙特卡罗控制方法，估计了 π⁎ 和 q⁎ 。目标策略π是相对于 Q 的贪婪策略，行为策略 b 是ε——软保证每对状态和动作的返回次数无限次。即使根据策略 b、选择动作，策略π在所有遇到的状态下收敛到最优，策略b、b 可以在情节之间/情节内改变。
http://incompleteideas.net/book/RLbook2018.pdf
在将该算法应用于 21 点示例时，最优值函数的图表看起来当然与上面的相同，所以我不会再贴出来。这是蒙特卡罗方法中非常令人兴奋的 GPI，接下来我将使用时间差异学习以及 Q 学习来看预测和控制！
非常感谢你的阅读，我期待冒险继续。
“我只得到这一个我们称之为生活的数据流”——大卫·西尔弗
资源
YouTube 上 David Silver 的 RL 课程
强化学习 GithubbyDenny britz
时差学习
强化学习之旅
通过经验引导优化价值函数。
欢迎来到我的强化学习研究的下一个激动人心的章节，在这一章中，我们将讨论时差学习。和往常一样，我会在文章底部链接到那些教导和指导我的资源。
在我的前两篇帖子中，我们谈到了动态规划 (DP)和蒙特卡洛 (MC)方法。时差学习是这两种思想在几个方面的结合。像 MC 一样，TD 直接从经历事件中学习，不需要环境模型。像 DP 一样，TD 学习可以从不完整的剧集中发生，利用一种叫做 bootstrapping 的方法来估计该剧集的剩余回报。基本上，它是对价值函数进行猜测，采取一些步骤，然后进行另一次猜测，朝着这个新的猜测更新我们的原始猜测。
其中 Gₜ 是返回，而 α 是恒定步长参数。我们查看估计值和回报之间的误差项，并在误差方向上更新我们的价值函数。TD 学习最简单的版本是 TD(0)或一步 TD ，在一步之后向估计收益更新价值函数。这个估计，就像贝尔曼方程一样，由两部分组成:直接回报加上下一步的贴现值。现在，我们可以用这个估计回报代替我们的真实回报 Gₜ ，得出一个估计的、有偏差的算法。
让我们用一个例子来看看 TD 方法是如何证明优于 MC 方法的。这个例子的想法是预测下班回家需要多长时间。这是状态、时间和预测的顺序。
我们如何根据经验的轨迹更新我们的价值函数？下面的可视化说明了 MC 和 TD 方法之间的区别。
蒙特卡罗(左)与时间差分(右)方法
在左边，我们看到 MC 方法推荐的改变。因为我们基于实际结果更新每个预测，所以我们必须等到最后，看到总时间用了 43 分钟，然后返回到那个时间更新每一步。有了 TD learning，如上图右侧所示，在每一步，迈出一步后，我们可以立即更新前一步。
TD 学习的一个主要优点是，它甚至在不知道最终结果的情况下也能学习。毕竟，一个代理完全有可能接收到不完整的序列，甚至在没有最终结果的连续环境中工作。
通过在我们的控制循环中用 TD 代替 MC，我们得到了强化学习中最著名的算法之一。这个想法叫做 Sarsa 。我们从 Q 值开始，将 Q 值稍微移向我们的 TD 目标，即奖励加上下一个状态的贴现 Q 值减去我们开始时的 Q 值。
Sarsa 使用五元组中的每个元素来描述从一个状态-动作对到下一个状态-动作对的转换。开始知道它的名字是从哪里来的了吗？
让我们看一下用于策略 TD 控制的 Sarsa 算法的伪代码:
http://incompleteideas.net/book/RLbook2018.pdf
为了实现这一点，我们来看一个可能很熟悉的例子，Windy Gridworld。Windy Gridworld 与我们在以前的帖子中了解并喜欢的 Gridworld 是一样的，但有一点不同:网格中间有一股侧风！
风的强度因柱子而异，由每根柱子下面的数字表示。强度表示采取行动后向上移动的单元格数量。例如，如果在目标右侧的单元格中，采取向左移动的动作会将您置于目标正上方的空间中。
需要注意的一件重要事情是，蒙特卡罗方法在这里可能不起作用，因为可能会找到一个策略，使代理停留在同一个空间，从而有效地使下一集永不结束。使用 Sarsa 让我们在插曲中了解到这样的政策是糟糕的，并将尝试其他的东西。
下一次，我将深入到非策略 TD 控制的 Q-learning 中，我们将独立于遵循的策略来逼近最优状态值函数，类似于非策略 MC 方法。非常感谢您的阅读，我期待着在这个迷人的机器学习子领域学到更多。
资源
YouTube 上大卫·西尔弗的 RL 课程
强化学习 Github 由 dennybritz
我的数据科学之旅
照片由 Unsplash 上的 Mantas Hesthaven 拍摄
在我辞职去参加编码训练营 12 个月后，是时候回顾一下了
自从我辞去前一份工作参加一个全职的数据科学训练营以来，大约有 12 个月了。一段时间以来，我一直想写一篇“我是如何在这里结束的”的帖子，但随着时间的推移，我想推迟，直到我工作了一段时间。过了一段时间后，回顾会变得更加尖锐和诚实——在这一点上，更容易将信号从噪音和情绪中分离出来。
我为什么辞职？
2019 年 3 月，我离开了 robo-advisor(为个人和 401k 计划参与者提供自动化投资建议)的一份轻松工作，在那里我没有付出多少努力，就能赚到很多钱。我为什么要做这种事？三个原因:
- 缺乏成长:我的工作变得很容易。没有明显的成长和学习的机会。我公司的产品系列稳定，现金流为正，没有尝试新事物的欲望。
- 觉得工资过高:这一开始听起来并不是什么坏事。我的意思是谁不想得到过高的报酬？但随着时间的推移，尤其是当一个行业的竞争压力增加时，薪酬过高的人最先被裁掉。事实上，在我最终辞职前的几个月，我刚刚躲过了一轮裁员。
- 我想重塑品牌:我住在湾区，这里一切都是科技。尽管我可以编写一些代码，并且知道如何处理 SQL 查询，但我被贴上了财务人员的标签，很少引起招聘人员的注意。如果我丢了工作，我将很难在湾区找到另一份类似的工作。
所以我辞职了。当我把这个消息告诉我的老板时，他真的很惊讶。他很友好地提出，如果我想在集训营结束后回来的话，他可以保留我的位置，我几乎接受了。但我想要一个新的开始，所以我最终说不。如果有一份工作让我有可能回去，那么我担心我会被吸引到阻力最小的那条路上。
训练营
2019 年愚人节，我开始了我的训练营。老实说，这是非常有趣的 12 周。那段时间，我交了新朋友，做了各种激情项目，开了博客。
老实说，我从训练营没学到多少东西。在我职业生涯的大部分时间里，我一直在从事各种定量工作，所以我已经相当熟悉统计学和数据处理。
我从训练营学到的主要东西是:
- 自然语言处理(NLP): 虽然我对定量数据很熟悉，但对文本数据进行处理和运行算法对我来说是陌生的。了解到 NLP 的主要目标是将单词(通过词频表达)提取到能够最好地解释文档之间差异的主题(可以认为是趋势)中，这很有趣。因此，就像在线性回归中搜索最能解释目标变量差异的特征集一样，在 NLP 中，您试图确定最能解释文档差异的主题集。当然不同的是线性回归是有监督的，主题建模(使用 NLP)是无监督的。
- 无监督学习:起初，我对无监督学习感到困惑。从金融(我们总是试图预测未来)的角度来看，一个模型没有目标变量似乎有点奇怪。但是如果我们得到的只是一个大的文本文档语料库，那么就真的没有目标变量了。这就是无监督学习的用武之地。它筛选噪音和混乱，并试图确定趋势。这些趋势是主题，一旦发现，可以在其他模型中用作关键输入。无监督学习的另一个很酷的例子是聚类分析。当你对你的数据一无所知时，就开始把它们分成相似的组，研究每组的特征以及各组之间的区别。我意识到，无监督学习产品的主要目的是作为其他机器学习模型的重要输入，而不是作为最终结果。
我还会参加训练营吗？是的，马上。我知道这要花很多钱(12 周 17000 美元)，并且需要你放弃工作几个月。但这很有趣，可能是我最后一次参加类似学校的环境(打出来感觉很难过)。
如果不去训练营，我能得到现在的工作吗？是的，我可能有。与此同时，训练营的结构、同龄人的决心以及没有工作都是我离开、提高面试技巧和找工作的巨大动力。
训练营是否帮助我获得了面试机会并最终找到了工作？不，我自己完成了所有的招募工作。我的一些同学通过我们的职业顾问找到了工作，但总的来说，每个人都是自己招聘的。总的来说，这可能是我对数据科学训练营的主要抱怨——他们使用光鲜的就业统计数据来吸引人，但没有传达的是，这些统计数据更能反映学生自己的动力和努力，而不是训练营对招聘人员的吸引力。不要误会，训练营在教授学生数据科学方面做得很好。但数据科学家的市场远没有他们营销手册上描述的那么深入和受欢迎。
工作
事实上，过去的一年让我对自己有了更多的了解。我以前的工作对我来说变得太容易了，以至于我已经忘记了奋斗和伸展是什么感觉。在怀疑的时刻，我甚至担心我是否还能做到。这就是为什么不管结果如何，我很高兴我能够鼓起勇气抓住机会，尝试一下这段旅程。
训练营结束后，我相对较快地找到了工作。我面试了 3 家公司(都是数据科学职位) :一家银行、一家咨询公司和一家金融科技初创公司。最终，我幸运地收到了这三家公司的邀请(我接受了金融科技初创公司的邀请)。我的面试经历是不典型的(我只完成了一个带回家的，令人惊讶的是从来没有被要求做任何 SQL)，所以我真的没有什么太深刻的见解要说。作为求职建议的替代，我将给出一些择业建议:
- 去最需要你的地方:这是我现在的老板在我试图决定去哪里工作时给我的建议，现在回想起来，它听起来确实是真的。我们倾向于选择最有品牌声望或支付最高的公司。但一旦蜜月期结束，我发现我个人的工作满意度与解决难题(和学习)、打造酷产品和服务以及成为高贡献团队的重要成员联系最紧密——而这只有在你工作的公司非常需要你的技能时才会发生。
- 避开喜欢开会的公司:我喜欢目前工作的一点是会议很少。是的，我偶尔会和队友一起编程序，和老板讨论想法等等。，但当快速聊天就足够了，那么这就是我们要做的。我曾经在一些公司里，每次讨论，不管多么琐碎，都必须在一个有六个与会者的会议室里进行，并且持续至少一个小时。那些经历让我坚信那些不能工作的人，会遇到。的确，我们偶尔会受益于将所有利益相关者聚集在一个房间里，以便敲定一条商定的前进道路。但那是例外；大多数时候，会议是一个放松、上网、假装我们很忙的借口。
最后，我想补充一点，人们认为数据科学家做的和他们实际做的是有差异的。每个人都想谈论的工作的性感方面是机器学习和人工智能。但那只是工作的一小部分。在我不训练和拟合模型的大部分时间里(构建和拟合一个模型真的不需要那么长时间)，我都在寻找和清理数据，或者头脑风暴，思考我需要什么数据以及我应该使用什么方法来解决我的公司面临的问题。对于这些，领域知识和动态学习的能力实际上比机器学习算法的百科知识更有用。最后，我想给大家列出一系列我认为每个优秀的数据科学家都必须具备的品质:
- 建立稳健简单的模型的能力，这些模型能够很好地概括样本数据。
- 识别模型在何种情况下可能会崩溃或表现不佳的直觉。
- 注重细节，保持足够的怀疑态度，以便能够嗅出不良数据(和故障模型)。
- 了解推动企业竞争优势、利润和现金流的杠杆。
- 将看似复杂的问题分解成关键部分的能力。
- 能够并愿意以简单明了的方式交流复杂的话题。
我加速 Python 的旅程:设置 GoLang 开发环境和基准测试
我们的旅程从安装 GoLang 开始。我们用 GoLang IDE，以及一些相关的工具和软件包创建一个开发环境。接下来，我们列出了 19 个“免费”资源和 5 本“非免费”书籍来学习 GoLang 语言。最后、我们对Python sk learn****k means到 GoLang kmeans 实现进行基准测试。我们将一起确定 GoLang kmeans 实现是否有效，以及它是否比Python sk learn****k means 更快。
资料来源:联合国人类住区规划署
我过去的旅程(此部分可选)
开始学习机器学习，在 2011 年，用一种很棒的语言叫做 R 。我在机器学习的理论和实践方面进展顺利。我认为“进展良好”的感觉是相对于过去的四次“重组”而言的
1.在我的第一个实验粒子物理职业生涯之后，我重新进入了人工智能领域。
2.AI 1.0 的泡沫破灭 1985 年，我通过学习算法、C、C++、分布式计算，重新装备成了 IT(信息技术)架构师。
3.我在 1993 年迷上了 Oak ，它后来在 1994 年被称为 Java 。我想，“这是一种用于 N 服务器分布式计算的语言。”我错了。原来是 Scala 。(IMHO，我很接近了。)我成了 CORBA 的拥护者，又一个泡沫破灭，这一阶段修图的最后部分。
4.自然，从 1997 年到 2000 年 Web 1.0 泡沫破裂，下一次“重组”是学习然后建立网站。
在 2012 年底，我开发了一个房地产应用程序，它可以改进邮件活动。我使用了一种叫做 R 的脚本语言，但是在钻研机器学习和深度学习的时候遇到了很多阻力。
由于这种阻力，我在 2013 年底尝试了 Python ，并一直留在 Python ，因为我更深入地了解了机器学习，然后是深度学习，然后是NvidiaGPU，然后是云计算。
我的新目标
我有一个问题，我想我与机器学习(ML)社区的很大一部分人都有这个问题。
我需要一种方法来加速我的 Python 机器学习解决方案，以便将其投入生产。
或者
Python 对于生产机器学习应用来说太慢了。我需要放弃 Python。
我决定做的是:
学习 GoLang 。
它几乎和 C 一样快。它被宣传为易学，因为它有一个类似 C 的语法。对并发性有语言级别的支持。它是静态类型的，但也包括垃圾收集。
这是值得注意的，因为它是在 Windows、Mac、Linux 和其他平台上。它支持新的多核架构。
GoLang 是开源并且有一个不断增长的贡献者社区。
对我来说，重要的是 GOLang 在 Google 的生产中使用了很多年。另外，我要求 GOLang 可以调用 Python 。我的基于 Python 的 ML 内核的包装器是我的快速生产运行时解决方案。
本文的其余部分是我建立 GoLang 开发环境的旅程。后面的文章详细介绍了如何使用 GoLang 和 Python 作为机器学习生产应用的双动力组合。
准备开始:设置您的 Go 开发环境
最好的开始方式是在源头:https://golang.org。
在这里，我下载了 MacOS 10.14 的二进制发布安装程序go 1 . 14 . 4 . Darwin-amd64 . pkg。6.也有针对 Windows 和 Linux 的下载。
我双击了驻留在我的Mac 下载文件夹中的 go . 1 . 14 . 4 . Darwin-amd64 . pkg。然后，我按照弹出的安装向导的指示进行操作。
注: Go 安装需要所选目标磁盘上的 350 MB 空间。
注:根据您计算机上的安全设置，安装过程中可能会要求您输入密码。
注意:安装后，最后的操作是“将安装程序移到垃圾箱吗？”我点击了，是的。
设置您的 GoLand IDE
我选择的 Python 交互式开发环境(IDE)是 PyCharm 。我欣赏的关于 PyCharm IDE 是它几乎完全自动化了我的 Python 开发管道，只需点击几下鼠标。
这种偏见导致我寻找 GoCharm。原来 PyCharm 背后的公司 JetBrains 称他们的GoLangIDEGoLand。
有一个方便的按钮可以下载 GoLand 的安装。从下载中，我双击了驻留在我的Mac 下载文件夹中的 goland-2020.1.3dmg、。然后，我按照弹出的安装向导的指示进行操作。**
安装过程中把图标 GoLand 放到我的工具栏里。我双击了 GoLand 图标。
发射时的初始 GoLand 屏幕。瑞秋·科特曼的动画
接下来，我点击了New Project:
在戈兰创建第一个项目。瑞秋·科特曼的动画
我的第一个围棋程序
你知道我的第一个 GoLang 节目是什么吗？
*package main
import "fmt"
func main() {
fmt.Printf("hello world")
}*
如果你猜对了Hello World，你就对了！通过点击 GoLand 教程“The hitchicker ' s Guide to GoLand”，将Hello World 代码放入我的第一个项目 awesomeProject1 。
注:我用的是 GoLand 的社区版。
然后，我在 GoLand 跑了Hello World。有效！
运行“开始构建学习开始…”
我继续浏览剩下的戈兰教程，“戈兰搭便车指南”如果你一直在使用 PyCharm ，本教程是对 GoLand 的快速介绍。
如果你对 PyCharm 不感兴趣，你可能想使用其他的 IDE。我可以推荐一下 VSCode ，另一个流行的多语言支持 IDE。
在下一部分，我列出了一些学习资源。我用过的。
学习资源
当你开始学习一门新语言时，你必须有原始文档。然而，我建议你不要在这里开始学习..
Go 编程语言是一个开源项目，旨在提高程序员的工作效率。围棋富有表现力，简洁…
golang.org](https://golang.org/doc/)
如果你想要五到十分钟的时间来学习 GoLang 或者现在需要一些话题，我推荐你
理解 Go 编程语言的教程列表，通过基本示例深入语言规范
medium.com](https://medium.com/rungo/go-introductory-tutorials-896aeda0fb8a)
在“你必须拥有”的清单上应该有另外 12 种在网上可以免费获得的 GoLang 资源:
- 围棋之旅；
- 学习围棋:面向各层次程序员的 30 大围棋教程；
- Golang 教程系列；
- 围棋教程和课程；
- 以身作则；
- Gophercises；
- 围棋练习；
- 围棋学习完全指南；
- 必备围棋 是一本关于围棋编程语言的免费书籍；
- 如何写 Go 代码？
- Go 并发模式
- 边学边考
GOLang 包列表(进口！)可以在这里找到:
标准库▹这些包是 Go 项目的一部分，但是在主 Go 树之外。它们是在…下开发的
golang.org](https://golang.org/pkg/)
另外，你可以在这里找到 GOLang 包:
Go 1.13 API 文档，包含即时搜索、离线支持、键盘快捷键、移动版本等。
devdocs.io](https://devdocs.io/go/#subrepo)
这些包是 Go 项目的一部分，但是在主 Go 树之外。它们是在比 Go 内核更宽松的兼容性要求下开发的。用“去拿安装它们。
我发现对机器学习有用的包:
书籍(非免费)
表演
选择 GoLang 的两大原因是
- 简单易学的语法
- 比 Python 更快
就我所知 C ，第一个理由就满足了。我发现 GOLang 在基本构造上与 C 相似，有一点点 Python 的味道，以及并发中的新功能。
不知道 GoLang、作者的心态(我去查维基版。)，我的偏见让我相信 GoLang 是对 C 的重大改写，以适应分布式计算。
至于第二个原因，我查看了各种基准测试，结果显示 GoLang 比 Python 快 30 到 50 倍。
包和模块
我花了大约四个小时阅读 GoLang 的包和模块。然而，我需要做的是:
go get “github.com/pa-m/sklearn/base”
go get “github.com/pa-m/sklearn/cluster”
go get “github.com/pa-m/sklearn/dataset”
我认为 GoLang 已经发展到包可以归结为这些规则:
- 全局变量是骆驼大小写的。它们是变量，从它的包中对外公开。
- Packages 是由
package <name>.设置的文件顶部的名字。该文件中指定的所有函数和全局变量都在 package<name>.中 - 你可以用命令
go get <URL-for-package-file>将这个包加载到你 GoLang 环境(类似于pip install <package-name>)。 - 您可以使用您的
package main文件中的语句import (<URL-for-package-file>)访问<package-name>中的定义。
对集群例程 kmeans 的 GoLang 实现的调用结果是:
package main
import (
"fmt"
"github.com/pa-m/sklearn/cluster"
"github.com/pa-m/sklearn/datasets"
"time"
)
func main() {
start := time.Now()
_ = start
kmeansBlobs()
fmt.Printf("elapsed %s s\n", time.Since(start))
}
func kmeansBlobs(){
X,Y := datasets.MakeBlobs(&datasets.MakeBlobsConfig{
NSamples: 10000,
Centers: 10,
ClusterStd: 0.5})
kmeans := &cluster.KMeans{NClusters: 10}
start := time.Now()
_ = start
kmeans.Fit(X, nil)
kmeans.Predict(X, Y)
fmt.Printf("elapsed %s s\n", time.Since(start))
}
另外，你可以浏览一下关于 GoLang 包和模块的内容，因为你很有希望使用GoLang。 GoLand 在 run: 上为您设置本地GOROOT和GOPATH
GoLandGoLangkmeams-blogs . go 的运行
基准
我们在 Python 和 GoLang kmeans 实现上执行基准测试。以上给出了 GoLang 实现。Python 的**实现就是 :**
from sklearn.cluster import KMeans
def km():
kmeans = KMeans(n_clusters=N_CLUSTERS)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)
对于k 均值 实现，聚类的点数( n_p )从100到70,000不等。
Python-sklearn-Kmeans 与 GoLang-Kmeans (Y=MS)对比表，X =点数。
Python-sklearn-Kmeans 对 GoLang-Kmeans (Y=MS)乘以 X =点数。
通过观察，我们观察到 GoLang-kmeans 实现上升为O(n)， 而Python-sk learn-k means实现上升为 O(log(n))。
Python-sk learn-k means实现使用cy thoncallouts(C语言)对整体速度和特殊算法进行微调以实现O(log(n))。******
我很惊讶地看到 GoLang-kmeans 实现比 P ython-sklearn-kmeans 实现要快 N < 10，000 点。
我的好奇心被触发；你或我应该试试:
- 解释 GoLang-kmeans 实现和 Python-sklearn-kmeans 在低 N 个数据点时的速度结果。
- 使用GPU有多容易？对性能有影响吗？
- 在没有性能增强的情况下， Python-kmeans 实现的速度有多快？
- GoLang-kmeans 的实现会因为并发性的增强而加速吗？是 1/ O(n 核) 更快？
结论
我喜欢我与 GoLang 和 GoLand 的生产力。我准备从社区升级到专业版 GoLand。
我对 GoLang 和 Python kmeans 实现的速度并不感到惊讶。 Python sklearn 使用 cython、和**log(N)**算法进行了高度优化。
我预计其他领先的 Python 机器学习包从切换到 GoLang 中受益很少或根本没有。 XGBoost 在一个 C++ 实现之上有一个 Python API，并且是并发的。 Lightgbm 给出与 XGBoost 相似的结果，并且通常比 XGBoost 更快。
我希望加速的地方是用 GoLang 代码替换围绕 ML 内核的 Python 无关预处理和后处理代码。
但是当有 GPU(加速)和云计算(可扩展性)和量子计算(在不久的将来大规模加速)的时候，为什么还要费心去加速 Python(T21)呢？)?
以下是我的推理。有一些现有的和未来的设备，比如几十亿部智能手机、无人机、电源插座( IoT )和其他设备，它们可能不想接入互联网，也不想拥有 GPU 也没有互联网接入(云)。
鉴于这种推理和 70 年的计算历史，对更快程序的需求一直存在，并且已经尝试了不同的方法。
如果说 Python 用 C 是为了更好的性能，那么或许 GoLang 可以用 Python 来交付生产机器学习。
我旅程的下一步
我用 Docker 换 Python 。太棒了。 GoLang 版本多，包多。我想为不同的戈朗环境一个码头工人形象。
Python 2.x 到 Golan g 有一个翻译器。如果能找到一个 Python 3.x 到 Golang 的翻译器就太酷了。
我确定有办法从 Python 调用 Golang ，从 Golang 调用 Python 。我还需要安全的呼叫机制。
Python 有开发工具，有持续集成/持续部署的自动化部署( CI/CD )。 GoLang 有什么开发工具？我们已经遇到了 GoLand ，一个全面的 IDE。
这里使用的所有代码都可以在https://github.com/bcottman/GoApplication找到。
我希望这些博客“我的加速 Python 的旅程”对你的 Python 和 GoLang 编码和规划有用。我喜欢写它们。我更喜欢思考 Python 和 GoLang 可能的未来。请让我知道你对这些事情的想法。*
我的 TensorFlow 认证开发者之旅
这篇帖子是关于我如何通过 TensorFlow 开发者证书考试的。此外，它是关于我的机器学习之旅和我对机器学习驱动的软件开发的看法。
作者:安德烈·巴拉诺夫斯基
关于我
我是一个企业软件开发人员，正在跳上机器学习的列车。在过去的 15 年里，我一直在做独立的甲骨文咨询，主要与甲骨文开发者工具和 Java 相关。我喜欢与社区分享我的知识，从 2006 年到 2020 年，我发布了 1030 个带有示例代码的博客条目，其中大部分都与 Oracle 技术相关。我的博客在 Oracle 社区中很有名，我是 Oracle 开创性的大使和大会发言人(从 2007 年到 2018 年，我每年都在旧金山的 Oracle Open World 和 Oracle Code One 大会上发言)。当我在 2004 年攻读硕士学位时，我正在研究支持向量机和神经网络。然而，我转到了企业领域，开始使用 Oracle 工具。那是我在甲骨文工作的一段美好时光，作为一名独立顾问，我周游世界，结识了许多优秀的人，并在加拿大、美国、南非、香港、沙特阿拉伯、俄罗斯和欧洲国家工作过。2017 年末，我决定改变我的工作方式，开始开发自己的产品 Katana ML(带机器学习的业务自动化)。从那以后，我决定特别关注开源和 TensorFlow。获得 TensorFlow 开发者证书有助于更接近我从传统编程转向成为机器学习开发者的目标。
为什么是机器学习？
我为什么决定投身机器学习？我相信机器学习是未来的编程模式。这是我的主要原因。当然，它不会取代所有传统的编程用例，但它开启了一种全新的构建软件的方式。请看 Laurence Moroney 的精彩解释图，摘自他的 Youtube 视频— 机器学习基础:Ep #1 —什么是 ML？:
这张图表总结了传统编程和机器学习之间的主要区别。完美的例子——用传统的编程方法，你可以计算一个人何时在走路、跑步或骑自行车(使用速度)。但是怎么算一个人是不是在打高尔夫呢？这就是机器学习优势发挥作用的地方——它可以处理这些复杂的情况，否则根本不可能编写代码。这个例子来自 Laurence Moroney 视频— 机器学习基础:Ep #1 —什么是 ML？:
我是如何准备考试的
你的第一站应该是 TensorFlow 认证项目网站。在那里你会找到考生手册。这份文件列出了通过考试所需的所有技能。这个列表很长，但是不要害怕——这是可行的。
我不是在为备考做微观规划，我不太喜欢使用各种规划应用程序。我更喜欢遵循我脑海中的高层次计划，相当方便:)
我的高层次计划是，我严格遵循该计划(我应该提到，我已经在 TensorFlow 工作了 2 年)来成功通过考试:
- 阅读弗朗索瓦·乔莱的一本书——《用 Python 进行深度学习》(也有第二版，将于今年晚些时候完成，现在以 MEAP 的名字出版)
- 阅读 Aurélien Géron 的书—
使用 Scikit-Learn、Keras 和 TensorFlow 进行机器学习，第二版 - 在 Coursera 上学习劳伦斯·莫罗尼教授的实践专业化课程中的张量流
- 在 Coursera 上学习劳伦斯·莫罗尼教授的 TensorFlow:数据和部署专业化课程
- 浏览谷歌的机器学习速成班
证书网站强烈推荐第 3 项。如果你没有时间阅读第一和第二本书，我建议你也仔细阅读第四和第五项。你应该仔细阅读 Coursera 上的资料。不要跳，跳过任何笔记本。不要复制粘贴代码，从头开始学习自己实现用例。这在考试的时候会有帮助。
仅仅通过考试并不是唯一的目标。我正在仔细学习，并花了相当多的时间来提高我的张量流技能，这是我参加考试的主要目的(非常好的学习动机)。
在准备考试的时候用 PyCharm 编写代码。如果你对 PyCharm 很有信心，这在考试中肯定会有帮助。PyCharm 提供了 API 自动完成功能，这是一件大事——它将加速您的编码并减少错误。
在我有信心参加考试之前，我花了大约 6 周的时间集中学习。我没有全职学习，我也有工作。我帮忙照看我 9 个月大的儿子，你可能知道——有时候会很忙:)
考试
完成准备后，我没有马上去考试。我计划在接下来的三四天里参加一场考试。我是故意这样做的，把知识沉淀在脑子里，带着一个新鲜的头脑去考试。
在考试期间，我在使用 Python 或 PyCharm IDE 时没有遇到任何问题。我在我的 MacBook Pro CPU(2.4 GHz 8 核英特尔酷睿 i9)和 64 GB RAM 上运行训练，没有使用 Colab GPU。
你有五个任务，在考试中建立五个模型。考试时间为 5 小时。当您通过用于 TensorFlow 认证的 PyCharm 插件启动考试时，时间计数器会立即启动。任务从最简单到最复杂排序。你的作业会被相应地评分，最简单的任务得分较少。
任务 1 :我很快实现了，提交了——但是评分结果并不完美。我调整了一些调整(我不会深入细节，因为这是不公平的)，重新提交保存的模型，并获得了最高分
任务二:我被这个任务卡住了。它应该不太复杂，但我在模型训练中不断出错。在某个时刻，我想——好吧，也许我考试会不及格。但后来我设法找到了一个变通办法，训练了模型，并从评分员那里得到了最高分。我看了看时间计数器，还剩 3.5 小时。这意味着我在前两项任务上花了 1.5 小时
任务 3 :这个任务对我来说比较顺利，我重拾了信心——我仍然有机会通过考试。然而，模型训练的准确率并没有像我希望的那样快速提高。在这个任务上花了 30 分钟后，我决定切换到任务 4 和 5。这时，还剩 3 个小时。我在任务 4 和任务 5 上花了 1.5 小时，然后回到任务 3。在这个任务上工作了 30 多分钟后，我设法找到了解决方案，此时模型训练的准确性开始迅速提高。然而，我仍然没有从评分员那里得到最高分。我意识到训练需要运行更长时间，以获得更好的模型准确性。还剩 55 分钟，我将模型配置为训练 40 分钟(在这一点上我是在冒险，如果训练因任何原因失败，我将没有机会再次运行它)。幸运的是，培训按时完成，我还有 10 分钟提交模型。这次我取得了好成绩，提交了我的作品
任务 4 :在 45 分钟内完成该任务，实现模型，并获得评分员的最高分
任务 5 :与任务 4 类似，45 分钟完成模型，提交给评分员，获得最高分
下一刻，我收到了一封邮件，正文是——“恭喜你，你通过了 TensorFlow 开发者证书考试！”
摘要
我是一名软件开发人员，决定进入机器学习领域。如果你像我一样——一个想投身机器学习的软件开发人员，希望这篇文章能给你动力。花时间学习，努力工作——会有回报的。
从人工智能开始
我的 ML 之旅—第一/四部分
机器学习——它是什么，为什么重要，以及如何开始
作者图片
4 月的一个决定性的日子，我决定投身于机器学习(在此之前我甚至不知道这个领域包含什么)。也许我很无聊。我可能在寻找除应用开发之外的事情做，这是我从 2018 年开始做的。四个月，很多个通宵之后，感觉自己开悟了！今天，我是一名 TensorFlow 认证的开发人员和谷歌云认证的专业机器学习工程师(我知道这有点拗口)，同时还是一名谷歌认证的助理 Android 开发人员(我从 2018 年开始就是一名)。
我想写下我的经历和旅程已经有一段时间了。你看，自从我 7 月份拿到 TensorFlow 开发者证书以来，我的 LinkedIn DMs 上就充斥着各种各样的问题(从我如何准备考试到如何打入 AI 领域)。随着时间的推移，我开始注意到这些问题中的一些固定模式和相似之处。在某个时候，我意识到每个人脑子里都有差不多一样的问题。
我患有冒名顶替综合症，非常严重。我经常问自己，作为一个新手，如何在网上写出有价值的东西。我看过很多由非常有经验和能力的人写的博客，有些人有几十年的经验。我亲眼目睹了由开发软件的工程师们撰写的包含代码片段的深度文章。我想知道我的旅程对任何人来说有什么意义。
然后我突然想到！我意识到什么需要存在，但还没有。这是一种以人为本的方法来回答人们对这个领域的疑问。大多数人似乎只会谈论AI 有多棒，AI 有多 AI 有多未来，以及你做一个 AI 工程师能赚多少钱。大多数博客都为你提供一些关于框架或工具的教程。
但是我还没有看到一个帖子说为什么我的生活会因为学习这些而变得更好，为什么这个世界需要更多的人在这个领域工作。我们现在有过剩的失业工程师，不是吗？
这个四部分系列的第一部分将解决所有这些问题。我不想告诉你那些你可以通过谷歌搜索得到的信息。从经验上来说，我想向你展示我走过的路程，让你自己形成结论。
它无处不在，我是说无处不在
这听起来可能有点老生常谈，但我还是要说——AI 是未来。
抱歉，我收回那句话。
人工智能是我们当今现实的一部分。就像氧气一样。即使你没有意识到，你也在消费它。不过，没必要惊慌；世界末日还没有开始。
如果你和大多数人一样，你有一部智能手机。你的相机应用程序可能正在使用人工智能来拍摄人像模式照片。人工智能算法控制着你电池耗尽的速度，你在抽屉顶部看到的应用程序，以及更新应用程序的最佳时间。你知道并喜爱的谷歌产品——搜索、地图、GBoard 等。是由人工智能驱动的。你已经生活在科幻现实中了；你只是还没有意识到。
我们目前的教育体系是一个年轻人被推进计算机科学领域的体系，不管他们是否喜欢。因此，人们似乎普遍排斥科技职业。然而，人工智能是不同的，因为它是一种工具，而不是一种技术。你的激情在于唱歌吗？人工智能是你的职业。跳舞呢？写作？心理学？金融？交易？有一种方法可以将人工智能应用于其中。这意味着人工智能模糊了非技术职业和技术职业之间的界限。你可以对烹饪充满热情，同时仍然是人工智能社区的一部分。对于两类人来说，这是一个极好的消息——那些被迫从事科技职业但有其他兴趣的人，以及那些在非科技领域工作并希望提升工作方式的人。
我听到的另一个常见的抱怨来自那些“不想整天坐在电脑前的小隔间里写代码”的人。我也有好消息。在人工智能领域，你可能需要编写总共 25-50 行代码，这可能需要你在电脑前坐大约半个小时。当然，在这半个小时之后可能会有几个小时的思考时间，但是你可以用这段时间去闻一闻玫瑰花香或者做些别的事情。
我遇到的最后一个担忧是 ML 是否过于数学化。对此，我说，这取决于你。如果你在一个需要你使用特定工具和框架的领域工作，那么你就不需要关心它们背后复杂的数学。如果你想进入一个以研究为基础的领域，你需要学习线性代数、微积分和概率。
还不服气？
也许你属于以下两类中的一类:
- 总的来说，你对技术感兴趣，但不知道 ML 是否适合你。我建议遵循我的一个月策略——涉足计算机科学的任何领域(比如嵌入式系统),列出在精通该领域之前你必须查阅的所有资源，然后预算一个月来做这件事。如果你喜欢你做的事情，再坚持一个月。如果你不喜欢，那就转移到另一个领域(比如物联网)，等等。一直这样做，直到找到自己喜欢的。如果 ML 是/不是你的那杯茶，你会用这个方法发现。预算中的一个月是承诺期，不管你有多不喜欢你正在做的事情，你都不能放弃。如果不出意外，你将在一年内探索 12 个领域，这本身就很棒了。
- 你对技术不感兴趣，但发现自己被推进了这个领域。进入 AI！想办法让你的兴趣领域(比如说摄影)关于 AI。也许创建一个工具，自动编辑你拍的照片，让它看起来更好？你的想象力和决心是这里唯一的限制。
“我的笔记本电脑就是垃圾！”
这似乎是很多想进入人工智能领域的人非常关心的问题。然而，从我的经验来看，到目前为止，每个接近我的人都有比我更好的电脑(我的电脑是华硕 X556UQK，配有第七代英特尔 i7 处理器、Nvidia 940MX GPU、8 GB 内存和 1 TB 硬盘)。
你还觉得不确定吗？你知道你可以用 Google Colab 在云上进行人工智能编程吗？你知道谷歌云平台和其他竞争平台(微软 Azure 和亚马逊 AWS)为你提供了可以按需利用的低成本云资源吗？你在这里没什么好害怕的。
如果你有预算，你可以买一台游戏笔记本电脑(这些电脑也可以用来开发人工智能应用)。还有 Lambda Labs Tensorbook ，一款为深度学习工程师打造的笔记本电脑(也是我梦想中的笔记本电脑)。
你已经过时了
这是你作为一个 AI 工程师会面临的问题。这个领域非常新，发展非常快，每一天都有变化。你今天所擅长的将在半年内变得过时。在这个领域取得成功需要你致力于成为一个终身学习者。如果你害怕改变，就不要在人工智能领域寻找职业生涯(更多内容将在第四部分讨论)。
吃太多不好吗？
当我第一次踏上与 AI 的旅程时，我不知道从哪里开始！有许多课程来自 Coursera、Udacity、Udemy、EDX、YouTube、Fast.ai、Nvidia、英特尔、其他在线网站、在线博客、教练中心、大学和公司内部培训。我发现可供选择的资源数量之多令人望而生畏，选择正确的资源有着巨大的压力(其中一些选项可能非常昂贵)。数周的研究让我最终选择了这条路。在本系列的下一部分中，了解我的学习之旅、一路上获得的认证以及我犯的错误！
第一部:一个卑微的开始与艾
如果你喜欢你所读的，请分享这篇文章。订阅接收关于未来文章的通知。如果你有问题，建议，或者反馈，就在评论里讨论吧！
本文原载此处。
TensorFlow 开发者证书
我的曼梯·里之旅——第二/四部分
TensorFlow 开发者证书——有用性、准备和时间承诺
作者图片
2020 年 3 月， TensorFlow 团队发布了 TensorFlow 开发者证书。这一基础证书允许 ML 从业者证明他们拥有在入门级 ML 角色中取得成功所需的技能。对于外行来说，TensorFlow 是谷歌的一个开源机器学习框架。除了作为一个强大的数值计算软件，ML 开发人员和研究人员可以快速构建和部署生产级 ML 模型。
作者图片
在这个四部分系列的第二部分中，我将与你分享我的学习之路，这样你也可以从对 ML 一无所知开始，以在这个领域获得入门级工作的技能结束。我还将分享获得认证的优势，以及认证是否对你有用，是否值得你花费时间和金钱。
一张证书到底值多少钱？
关于证书在求职者的简历中是否有用，科技界存在激烈的争论。有些人认为他们完全没用，重要的是重大项目、美妙的实习经历以及在行业岗位上的成功历史。其他人认为，它们有助于证明申请人在该领域有一些经验，可以提高候选人的就业能力。我认为任何一方都没有错。
我相信证书确实有它的位置。以我的经验来看，获得某方面的认证总能为我打开机会之门。例如，我的大学委托我构建多个官方 App，并允许我在 2018 年创办移动应用开发俱乐部；在这方面，我已经成为谷歌认证的 Android 助理开发人员，这是一个巨大的信誉助推器。自从我获得 TensorFlow 开发者证书以来，我的 LinkedIn 个人资料获得了巨大的关注，各行各业的人都给我发消息，征求我的建议和意见。这个证书也为我的简历增添了精彩的一笔。这让我可以马上和招聘人员谈论一些事情。
我认为仅仅有证书就足够了吗？肯定不是。但如果我说获得认证并没有提高我的职业生活质量，那我就是在撒谎。你在想是否适合你？在这篇文章结束时，你将更好地准备做出决定。
你是视觉学习者吗？
科技领域的另一个激烈辩论是，是从教科书还是在线视频中学习。一些人认为没有什么能打败一本好的老式教科书的全面性和彻底性。其他人说，在线课程和视频提供了一种现代的、图形化的、个性化的学习材料消费方式。
我对此的看法很明确——我完全赞成后者。ML 概念倾向于用图形来最好地解释，因为它们涉及到大量的精神可视化来处理。例如，当通过丰富的动画演示时，我发现理解卷积滤波器如何在图像的像素上移动要比在静态教科书中容易得多，静态教科书将一切留给想象力。
此外，正如我在第一部分提到的，这个领域发展得太快了。虽然在线课程可能会定期更新，以反映最新的内容和趋势，但教科书可能会在发布几个月后就过时了。推而广之，今天市场上的大多数书籍可能已经过时，或者至少不包含最新和最更新的信息。
“我不知道从哪里开始！”
我刚开始的时候也不知道。正如我在本系列的第一部分中提到的，有太多的资源可用，而关于选择的指导太少。然而，在经历了这个过程并做了我的研究之后，我写了这一节，所以我相信这条路对大多数初学者来说是最好的。
请注意，我绝不受任何人赞助或隶属于任何人；我在这里推荐的一切都来自我的研究和经验。此外，我对你在考试中的表现不负任何责任，按照下面的步骤操作需要你自担风险。
作者图片|保存到你的电脑。可能会帮你组织准备！
第 0 步:学习人工智能
当我开始我的旅程时，我跳过了这一步，后来我后悔了。请查看 Coursera 和 deeplearning.ai 的 AI for Everyone 课程。这个简单、非技术性的课程非常引人注目，让剩下的旅程更加顺畅。我后来选了这门课，但它应该是我事后做的第一件事。
第一步:Python
你习惯用 Python 编码吗？在开始之前，我对 Python 不熟悉，还有点害怕。来自 Java/C++的括号世界，不得不学习 Pythonic 式的做事方式的想法让我害怕。然而，我从 Udacity 开始使用 Python Nanodegree 进行人工智能编程，并感到非常自信(尽管需要一段时间来适应)。然而，我建议考虑 Udacity 的免费Python 编程入门课程，因为它包含的内容与 Nanodegree 中的几乎相同。如果你心中有任何其他首选资源，请随意考虑。如果你熟悉 Python，你可以完全跳过这一步。
第二步:深度学习基础
我看到许多人犯的一个常见错误是，他们跳过这一步，直接进入下一步；因此，他们对欣赏深度学习所需的基本原理的理解很少甚至没有。我推荐 Coursera 和 deeplearning.ai 的深度学习专业化，培训师吴恩达是一位出色的讲师，他成功地将多年的经验提炼为单一的专业化。
在这门对初学者友好的课程中，你将学习到所有的理论概念(加上大量的实践实验)，这将为以后的一切打下基础。
第三步:用 TensorFlow 应用深度学习
拿 Coursera 和 deeplearning.ai 的 TensorFlow in Practice 专业证书(以前叫 TensorFlow in Practice Specialization)来说，这是 tensor flow 开发者证书页面官方推荐的资源。在这里，您将获得优秀、实用、真实的 TensorFlow 实践经验，并为通过考试做好充分准备。讲师劳伦斯·莫罗尼和吴恩达非常出色地讲述了这些内容，最终会让你充满自信。
该页面还列出了一个替代项目，来自 Udacity 的深度学习 TensorFlow 简介课程，但如果你打算在某个时候进行考试，我不建议你这样做。
第四步:TensorFlow 开发者证书
此时，你要做好充分的准备去参加考试；在接下来的章节中会有更多的介绍。
第五步:一些更高级的话题
这可能被看作是一个可选的步骤，但我推荐它。以 Coursera 和 deeplearning.ai 的tensor flow:Data and Deployment Specialization为例。该专业涵盖了一些特定的主题，其中一些可能与你不太相关(如在网络浏览器、移动设备和物联网设备上部署模型)，但包含某些部分(如构建数据管道和联合学习)，我不建议你错过。
那么，这需要什么呢？
- 时间——一般来说，我建议你为每个专业投入最多一个月的时间，每天大约 2 小时的学习时间。
- 课程费用 -你可以选择审核课程，这样你就可以免费获得课程资料，但最终不会获得 Coursera 证书；或者花钱从事专业研究。在我看来，就你所得到的而言，这些费用是合理的。
- 考试费用——在撰写本文时，考试费用为 100 美元。你所得到的价格合理吗？我相信是这样的，但是你必须自己决定(在下一节中会有更多的介绍)。
- 奉献精神——很多。尤其是如果编程对你来说是新的。东西坏掉并停止工作，你可能会发现自己熬夜调试代码。软件的安装本身就是一个挑战。
我的一些经验提示:
- 多次阅读 TensorFlow 考生手册以熟悉考试。请注意，除了手册中提到的以外，关于考试本身的一切都是保密的。
- 我怎么强调这一点都不为过。如果你运行的是 Windows 10，考试前暂停自动更新。你需要做的最后一件事是，一旦你开始模型训练，你的计算机就开始运行后台更新！
- 考试前先熟悉一下 PyCharm。确保你对此感到满意。在上面运行一些代码，以确保一切按预期运行。
对你有什么好处？
首先，你会得到一张证书和一枚徽章。
你也会被添加到认证目录。
你将有东西与招聘人员谈论，添加到你的简历，把你的电子邮件签名，并改善你的 LinkedIn 个人资料。你的技能将被验证为这个领域的入门级角色，你会对自己的进步充满信心。
但是，请注意，证书本身可能不足以帮助你脱颖而出；项目、实习和工作经验都是为了这个。此外，该证书在您收到后的三年内到期，您必须支付费用并重新认证才能保留该头衔。如果你是业内资深人士，这个认证可能对你没什么用。
如果你选择不参加这次考试，你可能会很高兴地知道，根据官方网站，未来将发布更多的高级认证考试。我呢，考完了，连一次都没后悔过。
我参加了另一个可能感兴趣的认证考试——谷歌云专业机器学习工程师考试。在这个系列的下一部分中会有更多的介绍！
第二部分:TensorFlow 开发者证书
如果你喜欢你所读的，请分享这篇文章。订阅接收关于未来文章的通知。如果你有问题，建议，或者反馈，就在评论里讨论吧！
本文原载此处。
云专业 ML 工程师
我的曼梯·里之旅——第三/四部分
ML 工程，以及谷歌云专业机器学习工程师考试
作者图片
谷歌云平台 (GCP)是谷歌提供的一套云服务，运行在支持谷歌应用的相同底层架构上。这些服务为客户(独立用户和组织)提供了对强大的基础架构、无服务器工具和企业级软件的访问，而安装和管理的开销时间最少。GCP 为微软的 Azure 和亚马逊的 AWS 平台提供了竞争。
虽然 GCP 有大量功能可以支持许多不同的工业应用，但我们关心的用例是人工智能。因此，我们将在本文中研究该平台提供的人工智能相关工具。
此外，谷歌云为开发人员、工程师和架构师提供了各种认证途径，以展示他们在云上构建的能力。8 月，谷歌发布了云专业机器学习工程师 (PMLE)考试，测试模式，我参加了并成功通过。截止 2020 年 10 月 15 日，考试不再公测；即每个人都可以使用它。本文将涵盖考试准备、培训和认证的相关成本以及获得认证的利弊。
作者图片
虽然人们可以以项目的形式展示他们使用 TensorFlow 的技能，但在使用云时几乎不可能展示同样的能力；毕竟，一个人如何展示他们使用工具的能力？因此，我强烈建议你考虑参加这个考试，即使你可能并不想参加 TensorFlow 开发者证书考试。
开发者还是工程师？
根据 Google 的说法，只有 5%的生产 ML 系统包含 ML 代码。建立和训练一个模型是必不可少的，但是还有许多其他的过程组成了一个 ML 管道。这些可能包括但不限于数据收集、数据验证、特征提取、模型验证、模型部署和模型自动化。
作者图片|基于图片此处
如果到目前为止您已经阅读了本系列，那么您现在将会意识到 ML 不仅仅是构建一个 Keras 模型并在您的笔记本电脑上对其进行训练。
这就是做一个 ML 开发者和 ML 工程师的区别。
你不能称自己为 ML 工程师，除非你对 ML 管道中的每个阶段都了如指掌，而不仅仅是建模。这些技能很重要，因为如果没有人能使用它做任何事情，那么在你的笔记本电脑上有一个训练有素的 Keras 模型是没有用的。
谷歌云平台提供了什么
那么，GCP 提供了什么工具来缓解这些担忧呢？下面让我们来看看其中的一些，特别是从 ML 工程师的角度来看:
- Google 云存储为您提供了存储大量结构化和非结构化数据的能力。
- Pub/Sub 允许您让客户端(比如物联网设备)将数据发布到主题中，这些主题可以从其他 GCP 工具订阅和传输。
- DataFlow 是 Apache Beam 的一个实现，它允许您在模型训练之前预处理批处理和流式数据，也可以用于对模型预测结果进行后处理。
- DataPrep 为您提供了一种图形化可视化数据的方法，并在幕后使用数据流执行任何指定的转换。
- BigQuery 让您能够针对大量结构化数据编写 SQL 查询，并从中快速学习模式。
- AI 平台笔记本、作业和模型让你有能力快速实验、训练和部署模型(这是你现在必须非常熟悉的部分)。
- KubeFlow Pipelines 作为 Kubernetes 上的一层实现，允许您编写可移植的、平台无关的 ML 代码，这些代码可以在任何地方运行和部署，包括您的笔记本电脑或不同的云提供商。
- Cloud Composer 是 Apache Airflow 的一个实现，它为您提供了一种协调调度和编排所有其他 GCP 组件的方法。
GCP 还提供解决方案，让你不用写任何代码就能使用人工智能。这些允许你毫不费力地创建 ML 系统，它非常强大，但是可能没有你需要的定制功能。
GCP 最好的一点是整个生态系统是多么的统一。每个服务都可以很好地与其他服务协同工作，从而允许您在构建管道时轻松地将一系列服务串联起来。
“我从哪里开始？”
考试的细节是完全保密的。下面的内容不是暗示考试内容，而是指导你学习成为一名成功的 ML 工程师所需的材料。这恰好是考试测试你的内容。
请注意，我绝不受任何人赞助或隶属于任何人；我在这里推荐的一切都来自我的研究和经验。此外，我对你在考试中的表现不负任何责任，按照下面的步骤操作需要你自担风险。
根据 PMLE 页面，该考试的推荐培训是 Coursera 的 GCP 大数据和机器学习基础课程，Coursera 的机器学习与 TensorFlow on GCP 专业化，以及 Coursera 的高级机器学习与 TensorFlow on GCP 专业化。
作者图片|保存到你的电脑。可能会帮你组织准备！
在撰写本文时，上述课程的部分内容已经过时。这些专业化最初于 2018 年发布，此后发生了很多变化。如果我的观察是正确的，它们将在未来的几个月/几年内被修改。在那之前，你需要知道的是:
- 如果您遵循了本系列前一部分中的学习路径，您可以有效地跳过这些专门化中的大部分张量流部分。他们使用 TensorFlow 1.x，我们目前使用 2.x，这改变了我们在 TensorFlow 中的许多做事方式。但是，您仍然必须彻底了解估计器，因为从今天起， Keras 模型不支持分布式训练和 TFX (如果您听不懂我说的话，不要担心，一旦开始，您就会懂了)。
- 在GCP上用 TensorFlow 进行高级机器学习，可以完全避开第一门课；这只是对 GCP 上用 TensorFlow 进行机器学习所涉及的课程的一个回顾。
- 如果您遵循了本系列前一部分中的学习路径，在GCP tensor flow 高级机器学习中，您可以跳过第三个课程的大部分(仅完成第 2 周，从更深入更快，直到周末)，第四个课程的大部分(仅完成 AutoML 和 DialogFlow 部分)，以及第五个课程的大部分(仅完成第 1 周至因子分解方法和第 2 周的构建端到端推荐系统部分)。
- 请注意，这些专业中的许多实验已经过时，因此可以跳过。
然而，如果你想要 Coursera 的课程和专业证书，你不能跳过任何东西。
“需要什么？”
- 我建议你为每个专业准备一个月的预算，每天投入大约 2-3 个小时的学习。
- 课程费用- 你可以选择旁听课程，这样你就可以免费获得课程资料，但最终不会获得 Coursera 证书；或者花钱从事专业研究。在我看来，就你所得到的而言，这些费用是合理的。
- 考试费用- 考试的零售费用是 200 美元。你得到的价格合理吗？我相信是这样的，但是你必须自己决定(在下一节中会有更多的介绍)。
- 奉献- 很多吧。并不是所有的事情都有很好的记录和解释。你可能会发现你的理解中有相当大的差距，这需要花很多个晚上来阅读。
为什么要经历这些？
你将获得一张证书，证明你有能力使用谷歌云产品构建有效的 ML 解决方案。
你还会被添加到 Google Cloud 证书持有者目录。
你可以在这里和这里阅读所有其他福利。
但是，请注意，证书本身可能不足以帮助你脱颖而出；项目、实习和工作经验都是为了这个。此外，该证书在您收到后的两年内到期，您必须付费并重新认证才能保留该头衔。值得吗？你现在有你需要决定的了。请注意，微软的 Azure 和亚马逊的 AWS 平台也提供类似的认证考试。
在这个系列的下一个也是最后一个部分，我们将看看为什么人工智能如此重要，如何利用它有所作为，以及它如何有时会令人沮丧。
第三部分:云专业 ML 工程师
如果你喜欢你所读的，请分享这篇文章。订阅接收关于未来文章的通知。如果你有问题，建议，或者反馈，就在评论里讨论吧！
本文原载此处。
机器学习之旅
我与曼梯·里的旅程——第四部分
下一步，以及为什么这个过程有时会令人沮丧
作者图片
我认为许多人已经错过了计算机科学的要点。我们生活在这样一个世界里，年轻人相信科技行业是有利可图的，因为这个领域有很多高薪、稳定的工作。当这些人进入就业市场时(在大学学习过过时或不相关的内容后，他们可能首先被迫加入)，他们会受到粗暴的冲击；他们不具备行业知识，因此必须花费自己的时间、金钱和精力来武装自己以适应现实世界。现在我知道事情在最近发生了变化。不是每个人都是这种条件反射的受害者。然而，我想花点时间来解决这些问题，并解释人工智能是如何与众不同并产生影响的，不仅对我们的职业生涯，而且对我们的生活质量。
我还想借此机会谈谈我在这一领域发现的不足之处，以及如何改进这些不足之处的一些想法。最后，我想讲述一下我在过去几个月中面临的一些挑战，以及我是如何克服这些挑战的。
真正的问题是
当你想到技术时，你会想到什么？生活在这个科幻小说般的世界里，你是否充满了激情、兴奋和惊奇？成为未来创造者的想法是否让你感到兴奋和鼓舞？或者你充满了恐惧，想着在你那毫无生气的显示器前再坐一天，做一份你不喜欢的平凡的工作，为了一份充其量是可管理的，最差是微薄的薪水？这两种思维方式本身都不会错。然而，我发现缺乏的不是这个系统本身，而是它所创造的期望。
我在我们的社会中观察到的一个最大的缺陷是职业分为技术和非技术类别。许多人认为，技术工作需要数小时无意识、静止不动的编码，而非技术工作需要冒险和令人兴奋的任务，报酬也不高。而且很长一段时间，可能都是这样。然而今天，我相信这两个世界之间的界限正在消失，未来所有的工作都在某种程度上涉及这两种任务。
我在本系列的第一部分中谈到了这一点；你可以将人工智能应用到任何领域，彻底改变传统的做事方式。这意味着你不必为了科技职业而放弃你的爱好/激情/副业；你可以用技术增强它们。这也意味着机会的数量实际上是无限的！更重要的是，学习所需的技能从未如此简单；你不需要一个昂贵的学位就能胜任；在 Coursera 上进行几周的密集学习就足够了(如果你阅读了本系列的其他部分，你可能已经意识到了)。
我认为现在是时候了，作为一个社会，我们应该走出用金钱来定义成功的僵化思维。取而代之的是，把成功作为一种衡量标准，让自己找到新的和创新的方法去做旧的和平凡的事情。我相信，这是这个世界迫切需要的，而且在我看来，从长远来看，这将带来更多的财富。
古怪，但合乎道德
那么，你如何寻找创新的方法呢？古怪点！想想那些听起来很荒谬，但在技术上是可能的事情。想造一辆火星车？给狗装上微型摄像机，这样你就可以生成大量的运动数据！(当然，不伤害狗)。你是钢琴家吗？创造一个和你一起玩的机器人！也许你是一个跑步者；创建一个应用程序，帮助你逐步增加你的距离和更好地计时。你会注意到，只要稍加思考，可能性是无穷无尽的，不管你是谁。
建造人们会使用的东西。我怎么强调这有多重要都不为过。举一个我生活中的例子——当我获得 Android 应用程序开发认证时，我喜欢成为一名移动应用程序开发人员，但当我为我的大学创建了一个数千人使用的官方应用程序时，我喜欢成为一名应用程序开发人员。如果你像我一样，你可能会发现自己更被冲击力而不是技术所吸引，这没关系。
当涉及到人工智能时，伦理是一个重要的问题。请始终确保您的想法从一开始就考虑到数据隐私和道德。谷歌在这方面有一些很棒的资源。
后续步骤
因此，您已经完成了本系列其他部分的所有课程。你觉得自己知识渊博，但仍不完全自信。以下是您可以采取的一些后续步骤:
- 找一份相关的工作或实习。
- 做一个个人项目/增强你的副业。
- 为开源项目做贡献。
- 参加在线竞赛； Kaggle 在这点上很优秀。
- 寻找你感兴趣的更高级、更小众的课程(例如，AI at the Edge)
- 搜索那些提供挑战你的高级课程的大学。
- 成为一名作家，在 ML online 上发布您的旅程…
最大的挑战
每隔一天，就会有新的发现。新的研究论文正在不断拓展人工智能的能力。今天可能是业内最热门的东西，明天可能会被弃用。你可能一年都不接触这门学科，一旦回来就什么都不懂了。
作为一名人工智能开发者，这是一个合理的挑战。你永远也学不够。你永远不能停止学习。这在传统的软件编程中可能是可能的，但在这里不可能。这是一个真正的挑战，尤其是如果你不想学习新事物的话。在进入人工智能之前，确保你对这个事实感到舒服。好的一面是，在线教育通常非常实惠。
有时候有点令人沮丧
正如标题所示，旅程并不总是舒适的。正如在第一部分中提到的，可用的资源太多了，而关于选择最佳资源的指导太少了(尽管我希望到目前为止我已经为您提供了重要的指导)。软件的安装有时会令人头疼。你今天学到了一些东西，但却不得不在 6 个月后重新学习。许多最新工具的适当文档可能很少，您将不得不自己修复损坏的东西。有时你的代码因为一些愚蠢的原因而无法运行，你不得不花一整晚的时间来修复它(只是意识到你在某个地方漏掉了一个括号)。
传统的基于行业的职业仍在发展。许多顶级公司要求求职者拥有“5 年以上的经验”,使用一种仅推出 3-4 年的工具(从个人经验来说)；这使得新生进入这个行业变得更加困难。大学课程仍在发展，教师自己也不得不从头开始学习所有这些概念。
也就是说，这是否意味着不值得努力开始？不！作为一名 AI 从业者，你将站在现代技术的巅峰，创新的火炬手，变革的领导者。最初的挑战可以很快克服，当学习过程不再令人生畏，开始变得愉快时，你将无法停止(我认为是六个月到一年)。随着就业市场的开放和世界走向人工智能，这个领域将会有大笔资金。
这一天很快就要来临了，没有(至少是基本的)人工智能知识不是一个选择。从现在开始，你将在这场革命中领先一步。当这是一个选择的时候，现在就要学会，因为很快就不会了。😃
第四部分:机器学习之旅
如果你喜欢你所读的，请分享这篇文章。订阅接收关于未来文章的通知。如果你有问题，建议，或者反馈，就在评论里讨论吧！
本文原载此处。
我的机器学习模型表现很好，但我希望它失败
探索数据科学家的伦理责任
来源:图片 via Pikist 在知识共享许可下。
我是 Metis 数据科学训练营的应届毕业生，在那个项目中，我们的一个项目专注于建立一个分类模型。我们可以选择任何我们选择的数据集来工作，在我的情况下，我选择使用疾病控制中心 2007-2016 年的国家健康和营养检查调查(NHANES)结果，并训练一个模型来预测一个人是否患有高血压(二元分类:是或否)。我在我的机器学习模型中测试了一系列 28 个变量，包括人口统计数据、饮食习惯、酒精摄入量、活动水平、职业等。在测试了各种模型之后，我选择了一个逻辑回归模型，它使用了 5 个变量、过采样，并将阈值设置为 0.34，从而将我的目标召回率提高到 0.899。我构建了一个漂亮的 Tableau 图形来表示我的发现，这样，我在技术上实现了我的目标:分类模型完成。检查。
对于数据科学社区的人来说，这可能不是一项突破性的工作。对于数据科学社区之外的人来说，你可能会想(如果我还没有失去你的话)，“我不知道什么是逻辑回归模型或者你在那之后说的任何事情。”不管你的观众是谁，我都明白。但是我的模型的技术细节不是我想谈论的。
我想谈谈为什么我希望我的模型失败。
为什么？
在我的模型中，五个变量中有四个是在意料之中的。首先是年龄，这是不幸但不可避免的。年龄越大，患高血压的几率就越高。然后，体重、的增加、酒精摄入和吸烟都增加了预测高血压的机会，这可能很难，但可以由个人控制或改变。
但让我困惑的是模型的第五个变量。这个变量是一个特殊的少数民族——如果一个人是这个民族的，他就会有更高的血压。我觉得没有必要在这里说种族，因为我不想这篇文章是关于我(白人妇女)谈论另一个种族。那不是我的位置，也不是我应得的平台。如果你真的想知道，用谷歌很快就能找到答案，因为我看到了我的模型的结果，并搜索了让人们处于高血压风险的因素，以检查我的变量(并希望能告诉我为什么我的种族变量是错的)。
我想谈的是如何看待我的模型中的种族变量，以及在这种情况下数据科学家的责任。有可能在种族和高血压之间有一种基因联系——这本身是令人悲伤的——但也有可能它代表了这个种族面临的许多其他可能导致高血压的社会问题。那是…真的很难过。即使这个特定的模型不是这样，这种相同的思路也可以应用于任何一个模型，在这个模型中，由于历史上对种族的压迫，种族作为一个变量出现。
当数据科学家看到他们的模型结果代表更大的社会问题时，他们会怎么做？
有些人可能认为这不是数据科学家的责任，而是其他人的责任，数据科学家只是构建东西。我不太同意这一点，并认为有义务做得更多，但我也不知道这看起来像什么。所以我想在这里提出这个问题，因为我相信这应该是一个更广泛的对话。对我来说，很难将这种模式视为“完成”并继续前进。我对我在建模方面的技术工作感到自豪，但不能说我对展示这些发现感到自豪。我很难过，很生气，也很不舒服。
也许我的机器学习模型很简单，但它提出的道德问题很复杂。
我鼓励并希望对这篇文章的评论。如前所述，我不是带着答案来的；我来这里是为了开始一场对话，希望你能加入进来，这样我们就能一起努力找到解决方案。
这款机型的完整代码可以在 github 上的 这里 找到。
我的营销分析技术堆栈
寻找适合您业务的产品
*miro.com 流量(按作者)
我在一个有点有趣的地方。在 covid 疫情期间，我发现自己的角色发生了变化，从利用分析来增加收入，转变为专注于在我们的创意中、在我们的许多营销渠道中寻找见解，并通过少花钱或不花钱来实现这一点。我写这篇日记，也是为了与他人分享我发现的有用的东西。
谈到分析，我是自学的，或者更确切地说是通过互联网学习的。从我作为营销人员的早期开始，我就很幸运地为拥有丰富数据的公司工作。跨部门共享这些数据帮助我做出最佳、最明智的决策，以推动我们想要的结果。看到数据驱动的营销部门的力量，我开始专注于寻找更多的方法来做得更好。它始于创收渠道、电子邮件、付费数字和付费社交。由于目前缺乏广告支出，我一直专注于推动一些非收入驱动计划的洞察力。作为一个团队，我处理过程中的所有角色，数据收集，数据清理和可视化。我需要找到尽可能自动化的方法，以确保我可以不断更新我所创建的内容，并继续为团队构建更多内容。
在这里，我将向您介绍我们现有的解决方案、我选择它们的原因，以及一些如何使用它们的示例。
数据准备—表格准备
我为建立我们的社交媒体数据集的 Tableau 准备流程。
Tableau Prep 是一个非常强大的工具，它是我开始旅程的一个好地方。事实上，如果我有升级的平台，允许我通过 Tableau 服务器设置自动运行流，我会更多地使用它。但这目前不在预算中，所以我每天使用它来运行上述流程，该流程对来自 4 个社交媒体平台的数据进行标准化/合并，加上附加的情感数据和定制标签，以构建我们的社交媒体洞察仪表板。这是一个大电梯，大约需要 30 分钟处理。我们将在后面的文章中详细讨论该报告。
数据准备— Google 脚本
Google Scripts 是一个免费的工具，我用它来移动数据并同时清理数据。你需要对 javascript 有一个基本的了解，但是一旦你了解了，你就可以做任何事情。不是服务器端程序员我经常遇到的一个问题是自动化我编写的函数。Google Scripts 解决了这个问题，它允许我创建触发器来自动执行脚本。
数据准备/来源— Zapier
一个 Zap 寻找一封电子邮件，并自动保存附件到谷歌驱动器
从我有权获取报告的来源获取数据，但不在我管理的仓库或存储环境中，Zapier 对我帮助很大。最著名的是 Adobe Analytics。我目前使用 Zapier 从 Adobe Analytics 获取自动发送的报告，并将附件保存到 Google drive。
数据源—网络数据库
快速网络主题分析
我们使用 Netbase 有两个目的。监控围绕我们品牌的对话，并将情感数据添加到我们自己的社交媒体帖子中。无论如何，这都不是一个便宜的工具，然而，我们公司跟踪谈话和情绪的目标使我们能够为购买做商业案例。通过连接到 API，我已经能够为每天更新的报告自动收集数据。
数据源— RapidAPI
我只是在刮 RapidAPI 的表面。我的用例是从抖音收集见解。由于没有官方 API，我使用 RapidAPI + Google 脚本为我们的渠道和我们的竞争对手收集数据。
数据源/存储— Improvado
最初，当我创建社交媒体报告时，我从脸书& Twitter 本地导出数据，并使用 Netbase 导出 Instagram insights。这变成了一个乏味的日常过程，但是一旦我们能够证明报告的价值，我就能够让 Improvado 的支出得到批准，以自动化这个过程，并把我自己解放出来，致力于建立新的见解，而不是保持以前的见解与时俱进。
数据存储— Tableau 服务器
我使用 Tableau 服务器来存储与我们的 Tableau 准备流程相关的数据。当您使用 Tableau Prep 时，您实际上没有其他选择。
数据存储— Google Drive/Sheets
对于较小的数据集或构建概念证明时，我一直使用 Google Drive 和 Google Sheets 来存放数据。一些好处是，我可以与同事共享对文件的访问，我还可以使用 Zapier 将文件推送到这里，并使用 Google 脚本操纵这些文件。
数据存储—谷歌云 SQL
一旦我证明了数据集的价值，并确保它是干净的，并且处于最终形式，那么将它从 Google Sheet 转移到像 SQL 这样的真正数据库是有意义的。有很多方法可以选择，我使用的是 Google Cloud SQL ,因为它可以通过 Google 脚本轻松访问和操作。另外，在承担任何费用之前，它给了我 300 美元的信用额度，以向公司展示价值。这是一个很棒的视频，它帮助我建立并更新了我的第一个谷歌云 SQL 数据库。
数据源—谷歌自然语言应用编程接口
我们总是希望为我们的内容创作者提供有价值的见解。我目前正在使用谷歌自然语言 API 来识别我们网站上文章中的实体。希望这将取代标记内容以创建片段的手动过程。你也可以用它来识别情绪。
数据可视化工具— Tableau
Tableau 是我们所有其他工作的终点。我通常会创建两种类型的报告。可以提供高级见解的高管级报告，可以通过电子邮件提供，无需登录；交互式报告，允许数据所有者挖掘自己的见解。
什么适合你？
有大量的选择可供选择。花点时间确定适合您预算和需求的解决方案。此外，如果你在为一家负责任的企业工作，你必须先证明自己的价值，然后才能获得财政支持。随着您的成长，准备好多次构建和重建。这可能同时是一个令人愉快和疯狂的过程，只是不要忘记全程记录下来。
我的 NLP 学习之旅
开始用文本数据处理项目的指南。
当你阅读标题时，我将与你分享我惊人的学习之旅，它始于一年前我在 NLP 领域做毕业设计的时候。在开始这个项目之前，我对自然语言处理(NLP)领域的了解还不够多。
“永远不要后悔你的过去。
更确切地说，像老师一样接受它。”——罗宾·夏尔马。
介绍
通常在执行分析时，许多数据是数字的，例如销售数字、物理测量、可量化的类别。计算机非常擅长处理直接的数字信息。然而，我们如何处理文本数据呢？
作为人类，我们可以看出文本文档中有过多的信息。但是计算机需要专门的处理技术来理解原始文本数据。我们知道，文本数据是高度非结构化的，可以使用多种语言！
这就是为什么 NLP 试图使用各种技术来创建文本数据的结构。
在这篇文章中，我想概述一下在学习 NLP 技术时我必须知道的一些主题。我注意到许多其他帖子都涉及到同样的事情，但是写下我的学习之旅帮助我组织我所知道的事情。
目录
- 工业中的自然语言处理
- 文本预处理
- 计算语言学和单词嵌入
- 深度学习的基础
- 面向自然语言处理的深度学习
工业中的自然语言处理
我们可以注意到文本数据无处不在。这就是为什么自然语言处理负责大量的应用。
在这一部分，我列出了其中一些应用:
- NLP 启用了一些有用的功能，如自动更正、语法和拼写检查，以及自动完成。
- 提取和总结信息:NLP 可以从各种文本源中提取和综合信息。
- 情感分析(电影、书籍和产品评论)。
- 聊天机器人:是使用自然语言处理的算法，能够理解你的查询，并充分、自动和实时地回答你的问题。
- 自动翻译是 NLP 的一个巨大应用，它使我们能够克服与来自世界各地的个人交流的障碍，并理解用外语编写的技术手册。
可以查看我之前的文章 这里 我在哪里做过 NLP 相关的项目。
文本预处理
这一节是关于熟悉和熟悉基本的文本预处理技术。
从多个来源加载文本数据:
在这一部分，我将向你展示如何打开不同来源的文本文件，如 CSV 文件，PDF 文件等。
正则表达式:
正则表达式(有时称为 regex)允许用户使用几乎任何类型的规则搜索字符串。例如，在字符串中查找所有大写字母，或者在文档中查找电话号码。正则表达式必须能够过滤出任何你能想到的字符串模式。使用 Python 的内置**re**库来处理它们。更多信息见文档。
大多数行业仍然使用正则表达式来解决问题，因此我们不能忽视它的重要性。它们通常是数据清理的默认方式。知道了它们的适用性，了解它们并恰当地使用它们是有意义的。
让我们看一些使用**re**的代码示例
Spacy vs NLTK:
我将稍微介绍一下**nltk**和**spacy**，它们都是 NLP 中最先进的图书馆，以及它们之间的区别。
Spacy:是一个开源的 Python 库，可以解析并“理解”大量文本。针对特定语言(英语、法语、德语等)提供不同的型号。).旨在通过最有效地实现常用算法来处理 NLP 任务。
NLTK:自然语言工具包是一个非常流行的开源。最初发布于 2001 年，比 Spacy(2015 年发布)要老很多。它也提供了许多功能，但实现效率较低。
→对于许多常见的 NLP 任务，Spacy 更快、更有效，代价是用户不能选择算法实现。然而，Spacy 并不包括一些应用程序的预创建模型，比如情感分析，这通常更容易用 NLTK 来执行。
空间安装和设置:安装分为两步。首先，使用**conda**或**pip**安装 SpaCy。接下来，根据语言下载您想要的特定型号。更多详情，请访问此 链接 。
从命令行或终端:
conda install -c conda-forge spacy
or
pip install -U spacy
接下来，**python -m spacy download en_core_web_sm**
符号化:
处理文本的第一步是将所有的部分(单词和标点)分割成“记号”。这些标记在 Doc 对象内部进行了注释，以包含描述性信息。与句子分割一样，标点符号也很有挑战性。作为一个例子，英国应该被认为是一个令牌，而“我们”应该被分成两个令牌:“我们”和“'的”。对我们来说幸运的是，SpaCy 将隔离那些不构成单词组成部分的标点符号。句子末尾的引号、逗号和标点符号将被分配给它们的标记。但是，作为电子邮件地址、网站或数值的一部分存在的标点符号将作为令牌的一部分保留。这里有一个例子，你可以运行它，看看结果。
命名实体:
超越了令牌，命名实体增加了另一层上下文。语言模型认为某些单词是组织名称，而其他单词是位置，还有一些组合与金钱、日期等有关。命名实体可以通过ents访问。
词干:
词干提取是对相关单词进行编目的一种粗略方法；它基本上是从末尾直到词干截断字母。这在大多数情况下工作得相当好，但不幸的是，英语有许多需要更复杂过程的例外。SpaCy 没有包含词干分析器，而是选择完全依赖于词汇化。我们将在下一部分讨论引理化的优点。相反，我们将使用另一个名为**nltk** 的 NLP 库。
词汇化:
与词干化相反，词汇化不仅仅是减少单词，而是考虑一种语言的全部词汇，对单词进行词法分析。“was”的引理是“be”，“mice”的引理是“mouse”。此外,“meeting”的引理可能是“meet”或“meeting ”,这取决于它在句子中的用法。
变元化比简单的词干化提供了更多的信息，这就是 Spacy 选择变元化而不是词干化的原因。我们应该指出，尽管词汇化查看周围的文本来确定给定单词的词性，但它并不对短语进行分类。
import spacy
nlp = spacy.load('en_core_web_sm')text = nlp(u"I am a runner always love running because I like to run since I ran everyday back to my childhood")for token in text:
print(token.text, '\t', token.pos_, '\t', token.lemma, '\t', token.lemma_)
#### ----> In the above sentence, running, run and ran all point to the same lemma run. ####
停止单词:
停用词是指像“a”和“the”这样出现频率很高的词，它们不像名词、动词和修饰语那样需要彻底标记。SpaCy 拥有一个大约 305 个英语停用词的内置列表。
之后，我们可以将所有这些技术结合在一起，如果我们需要纠正拼写，删除多余的空格或标点符号等，我们可以添加更多的技术。建立一个文本规范化和预处理我们的文本数据。
“数据清理和准备是数据科学过程的关键步骤”
图片:来源
计算语言学和单词嵌入
在这一部分，我将讨论几个主题，例如:
- 提取语言特征
- 向量空间中的文本表示
- 主题建模
提取语言特征
- 使用空间进行词性标注:
有些看起来完全不同的词，意思却几乎一样。相同的单词以不同的顺序排列可以表达完全不同的意思。然而，我们需要看这个词的词性，而不仅仅是这个词。这正是 Spacy 的设计目的:你放入原始文本并得到一个 Doc 对象，它带有各种注释。
名词、动词、形容词等词性标签，以及复数名词、过去式动词、最高级形容词等细粒度标签。
回想一下，您可以通过索引位置获得特定的标记。
- 使用
token.pos_查看粗略位置标签 - 使用
token.tag_查看细粒度标签 - 使用
spacy.explain(tag)查看任一类型标签的描述
注意‘token . pos’和‘token . tag’返回整数散列值；通过添加下划线，我们得到了等价的文本。更多详情和信息，可以查看 这里 。
结果是:
Visualizing POS: SpaCy 提供了一个出色的可视化工具，名为displaCy。
#Import the displaCy library
from spacy import displacy#Render the dependency parse immediately inside Jupyter:
displacy.render(doc, style='dep', jupyter=True, options={'distance': 110})
POS 文档可视化
- NER 使用空间:
命名实体识别(NER):寻找非结构化文本中的命名实体并将其分类到预定义的类别中，如人名、组织、位置、医疗代码、时间表达式、数量、货币值、百分比等。Spacy 有一个“ner”管道组件，它标识符合一组预定命名实体的令牌跨度。
结果:
Spain - GPE-Countries, cities, states next April - DATE-Absolute or relative dates or periods the Alhambra Palace - FAC-Buildings, airports, highways, bridges, etc.
欲了解更多关于命名实体识别请访问此 链接 。
向量空间中的文本表示
- 单词的离散表示:
假设我们有一门拥有 10 个单词的语言。
V = {cat*, car, ship, city, man, laptop, word, woman, door, computer*}
我将“笔记本电脑”和“汽车”这两个词表示如下:
我们可以看到，所有的条目都是“0”，除了单词“laptop”= 1 的索引，单词“car”也是如此。我们称那些向量为 10 个单词的【one-hot】表示。
离散表示的问题是，它可能无法捕获特定于领域的语义。换句话说，我们无法捕捉表示中的语义相似性和关联性。例如，家和住所是相似的，所以应该彼此靠近。但在按字母顺序组织的英语词典中，它们却相距甚远。
- 作为分布式表示的神经单词嵌入:
一个单词将由其相邻单词的平均值来表示。为每个单词构建一个 密集向量 。例子:hello=[0.398, -0.678, 0.112, 0.825, -0.566]。我们称这些单词嵌入为或单词表示。
Word2vec 模型是一个处理文本的两层神经网络。它的输入是一个文本语料库，输出是一组向量。Word2vec 的目的和用途是将向量空间中相似词的向量分组。给定足够的数据、用法和上下文，Word2vec 可以根据过去的表现对单词的意思做出高度准确的猜测。这些猜测可以用来建立一个单词与其他单词的关联(例如，“男人”对“男孩”，“女人”对“女孩”)。给定一个中心词，它可以预测周围的词，反之亦然。
它以两种方式中的任何一种来实现，使用上下文来预测目标单词(这种方法被称为连续单词包，或 CBOW )或使用单词来预测目标上下文，这被称为 skip-gram 。
主题建模:
主题建模允许我们通过将文档聚集成主题来分析大量文本。我们将从检查潜在的狄利克雷分配如何尝试为文档集发现主题开始。
- 【潜在狄利克雷分配法】 :
深度学习的基础
深度学习是 NLP 最近发展的核心。从谷歌的 BERT 到 OpenAI 的 GPT-2，每个 NLP 爱好者都应该至少对深度学习如何为这些最先进的 NLP 框架提供动力有一个基本的了解。
在我们直接进入神经网络之前，我们需要首先了解单个组件，例如单个“神经元”。
人工神经网络有生物学基础！让我们看看如何用一种被称为感知器的人工神经元来模仿生物神经元。
人工神经元也有输入和输出！这个简单的模型被称为感知器。
输入将是特征值，它们乘以一个权重。这些权重最初是随机生成的。
然后这些结果被传递给一个激活函数(有许多激活函数可供选择，我们将在后面详细介绍)。现在，我们的激活函数将非常简单…如果输入的和是正回报，1 如果和是负输出 0。
因此，有一个可能的问题。如果原始输入从零开始会怎样？
那么任何权重乘以输入仍然会得到零！我们可以通过添加一个偏置项来解决这个问题，在这种情况下，我们选择 1。
神经网络简介:
我们已经看到了单个感知器的行为，现在让我们将这个概念扩展到神经网络的想法！！
我们来看看如何连接多个感知机。
图片:来源
多重感知器网络:
-输入层(来自数据的真实值)。
- 2 个隐藏层(输入和输出之间的层(3 层或更多层是“深度网络”)】
- 1 个输出层(输出的最终估计)
关于之前的激活函数:这是一个非常戏剧性的函数，因为微小的变化没有反映出来。所以，如果能有一个更动态的函数就好了。
让我们再讨论几个激活功能:
ReLu 因其简单性和前向与后向计算容易，在许多情况下具有最佳性能。但是，在某些情况下，其他激活函数会给我们带来更好的结果，例如当我们希望我们的输出在[0，1]
之间压缩时，会在最后一层使用Sigmoid。DL 库为我们内置了这些函数，因此我们不必担心必须手动实现它们！！
现在我们已经了解了神经网络理论的基础，我们可以进入更高级的话题了。
面向自然语言处理的深度学习
在我们看到深度学习基础知识的简要概述后，是时候将事情提升一个档次了。深入了解高级深度学习概念，如递归神经网络(RNNs)、长短期记忆(LSTM)等。这些将帮助我们掌握行业级的 NLP 用例。
递归神经网络:专门设计用于处理序列数据。让我们想象一个序列[1,2,3,4,5,6]，你可以问的问题是:你能预测一个类似的序列移动一步到未来吗？？像那个[1,2,3,4,5,6,7]。
最终，有了 RNN，我们可以做到这一点。
RNN 直觉:
- 序列到序列 : 是关于训练模型将序列从一个领域(例如英语中的句子)转换到另一个领域中的序列(例如翻译成法语的相同句子)。我们可以用它来进行机器翻译或问答任务。
- 序列到向量:情绪得分你可以输入一个单词序列，可能是一段电影评论，然后请求返回一个向量，指示它是否是积极的情绪，例如他们是否喜欢这部电影。
- Vector to sequence: 可能只是为一个单词提供一个种子，然后得到一个完整的高概率序列短语序列。(exp: word=Hello，为你生成的序列= How are you)。
RNN 建筑
现在我们已经了解了基本的 RNNs，我们将继续了解一种称为 LSTM(长短期记忆单位)的特殊细胞结构。生成有意义的文本是必要的，因为我们希望网络不仅知道最近的文本，还知道它看到的文本的整个历史。
长短期记忆(LSTM):
RNN 面临的一个问题是，过一段时间后，网络将开始“忘记”最初的输入，因为信息在通过 RNN 的每一步都会丢失。因此，我们的网络需要某种“长期记忆”。
LSTM 分部帮助解决这些 RNN 问题。
让我们来看看 LSTM 细胞是如何工作的！记住，这里会有很多数学！查看资源链接获得完整的分解！
在这里，我们可以看到整个 LSTM 细胞似乎如此复杂，当我们看到它的格式。然而，当你把它分解成几个部分时，它就没那么糟糕了。
在此图中，每条线都承载一个完整的向量，从一个节点的输出到其他节点的输入。粉色圆圈代表逐点操作，如向量加法，而黄色方框是学习过的神经网络层。行合并表示连接，而行分叉表示其内容被复制，并且副本被移动到不同的位置。
lst ms 的关键是单元格状态，即贯穿图表顶部的水平线。
GRU:LSTM 的另一个变种。这是最近在 2014 年左右推出的，它最终通过将遗忘门和输入门合并为一个名为更新门的门来简化事情。此外，它合并了单元格状态和隐藏状态，并做了一些其他更改。
下一步是什么？
在本文中，我想从零开始，只介绍 NLP 中的基本技术和一些高级技术。但是，我不能跳过基本概念就跳到更高级的话题。下一次，我们将探索现代 NLP 技术，如迁移学习，NLP 快速进步的原因。敬请关注！！！
结论
"让你做的每一件事都像有所不同一样."威廉·詹姆斯
如果你正在读这篇文章，这是我的一篇较长的文章；我想为你陪我到最后而热烈鼓掌。本文通过一些例子介绍了我在 NLP 领域的学习历程，我相信这些例子会给你一个关于如何开始处理文本文档语料库的好主意。正如我所说的，我将在以后的文章中介绍迁移学习技巧。同时，请随时使用下面的评论部分让我知道你的想法，或者问你对这篇文章的任何问题。
快乐阅读，快乐学习，快乐编码。
在你离开之前:
你可以在这里找到我之前与 NLP 领域相关的项目。
参考资料:
[1] Sainbayar Sukhbaatar，Arthur Szlam，Jason Weston，Rob Fergus。端到端存储网络。 2015 年。
[2] D. Bahdanau、K. Cho 和 Y. Bengio。通过联合学习对齐和翻译的神经机器翻译。 2016。
[3] I.Sutskever、O.Vinyals 和 Q.Le (2014 年)。用神经网络进行序列对序列学习。神经信息处理系统进展(NIPS 2014)。
[4]米科洛夫，托马斯；等人向量空间中单词表示的有效估计。2013.
[5]利维，奥默；戈德堡，Yoav 达甘，伊多。 利用从单词嵌入中吸取的经验教训提高分布相似度 。 2015 年。
浙公网安备 33010602011771号