Onepanel.io GPUs 上的傻股票交易
ur 首席执行官 Mathieu Lemay 最近写了一篇关于各种流行的人工智能模型在罗夏墨迹测试中看到了什么的文章。那很有趣。这让我想到当只有噪音时，我们人类能看到多少信号。我想看看当我们使用深度学习通过首席执行官的个人资料照片预测一家公司的股票市场表现，并使用首席执行官的星座交易股票时会发生什么。我们与 Onepanel.io 合作，在 GPU 上实现这个想法。
Using AI to interpret horoscopes and generate alpha. Mary Kate MacPherson made the bot a logo and everything. The tagline is “Your Fortune Awaits!”
当然，这些都是可怕的想法。你能从这里学到的很简单:坏主意会导致糟糕的模型性能。更重要的是，在数据科学确认该项目在统计学上有意义之前，你不能进行机器学习。
我将使用 Onepanel.io 平台带您了解这个人工智能项目从注册到项目执行的全过程，这会让您感受到我们从他们的解决方案中获得的价值。给你一点背景知识，我非常喜欢 DigitalOcean，但是他们没有 GPU 实例。当您想要在分布式协作中为深度学习项目启动一个开发实例时，AWS 很棒，但是很贵，而且有些机械，即使是从 AMI。我们从 Onepanel.io 中得到的，你将在本文中看到的，是一个平台，我们可以在这个平台上轻松地在一个 GPU 项目的团队中协作，而无需安装并运行所有的库，共享密钥等等。这是一个很棒的界面。
这篇文章的代码可以在 Onepanel.io 这里找到:https://c . onepanel . io/Daniel-lemay-ai/projects/star-sign-trade-stocks/code
开始:为您的团队旋转 GPU 的 10 个步骤
根据星座买卖股票的第一步是通过注册程序。
不要忘记点击你的电子邮件中的链接来验证你的电子邮件地址。如果你被提示输入信用卡，那是为了支付你将要启动的 GPU。有指令做这一切东西，但是 TL；像我这种 DR 的人，就是想飞过去，有一个有 GPU 库，源码控制，安全等等的工作环境。
Log in and make a project
Set the details of the project
Create a project workspace
Set the workspace details
The instance will take a few minutes to spin up, so note the time message and the status color
While we wait, let’s invite our team members to the project. No SSH key exchange required!
Great! Our instance is up. Let’s run Jupyter. Notice that tensorboard and terminals are also available with one click in the LAUNCH menu.
Make a new notebook to show the GPU is working
Copy-paste example code from keras.io Running!
这两条线显示 GPU 正在工作:
from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())
OK. It all works!
我们现在有了一个低成本的 GPU 实例，安装了所有正确的东西。那很容易。我们能够共享对项目的访问，这样我们就可以在团队成员之间进行协作。现在是时候用系统做项目了！
利用占星术进行投资组合管理
让我们来看看星座和股票交易之间的关系是如何吸引人，但却毫无意义。即使我们找到了相关性，它们也应该是随机的，而不是因果关系。那是因为星座是随机的，而随机，虽然经常很优雅，却什么都预测不到。先从根据各公司 CEO 的星座投资股市开始，看看会发生什么……好玩！
GitHub 是人们构建软件的地方。超过 2800 万人使用 GitHub 来发现、分享和贡献超过…
github.com](https://github.com/dcshapiro/onepanel)
搜集星座:建立一个数据集
我使用 Travis Riddle的代码从《纽约邮报》获取星座数据。我只是做了一些修改，让它能在 Python 3 中工作。我还对脚本做了一点修改，使它每天抓取所有的标志，而不是一次一个标志。如果主机生气并阻塞了我的虚拟机的 IP 地址，这使得脚本更容易恢复。我没有使用花哨/昂贵的 IP 轮换策略，我只是让我们撕开看看会发生什么。
首先，我在 3 天的范围内运行脚本。效果很好。接下来，我在 2014 年 1 月 1 日到 2017 年 12 月 31 日的日期范围内运行它。结果进来的时候就存了，以防万一。只坠毁过一次。我继续说道。完成了。那是 4 年的星座数据。我很确定这属于公平使用条款，但出于版权原因，我不会发布数据集。
Here is a look at the raw horoscope text, publication date, star sign, and sentiment
Horoscope sentiment is a bit more positive than negative, which makes sense for a feel good marketing thing
共有 17，186 行星座数据:4 年中的每一天对应一个星座(123654 = 17，520)。所以我们每年会错过大约 7 天的星座运程。我假设那是没有论文发表的时代，所以没有占星术。现在我们有了“我能预见未来”的数据，让我们来学习数据和市场之间的关系，每天根据这些“信息”进行交易。
仅供参考， Onepanel.io 有一个平台的数据集部分，你可以毫无痛苦地获取数据集来训练模型。它有像 MNIST 和许多其他的东西，一般来说比你自己把数据拉进一个公共数据集要少。
All the data.
您还可以将 S3 桶或任何东西捕捉到正在运行的实例上，或者将您自己的数据集添加到系统中。
我们通常解释文本的方法是使用 spaCy 将星座文本转换成向量，或者使用 FastText 训练一个定制的嵌入模型，然后训练一些神经模型从输入数据中预测东西。但是让我们简单点。我使用 TextBlob 将文本转换成基于情感的决策。这并不完全是现代投资组合理论。要使用深度学习来计算真实资产管理的资产分配，你需要大量的 GPU 和专业知识。对于这个项目，我们决定保持它的美好和简单。
from textblob import TextBlob
def sentiment(horoscope):
analysis = TextBlob(horoscope.lower())
if analysis.sentiment.polarity > 0:
return 1
elif analysis.sentiment.polarity == 0:
return 0
else:
return -1
为了决定我们是否应该交易，我们测量星座运势，如果它是积极的，我们买入一只股票(或者持有，如果我们已经在)，否则我们卖出。我们把钱平均分配在首席执行官的星座运势为正的股票上。我们跟踪持有情况，以了解我们的投资组合价值随时间的变化。我们将该策略的盈利(亏损)与投资组合的同等权重买入并持有策略进行比较，看看我们的积极策略是否跑赢了市场。让我们非常慷慨地假设费用是 0 美元，尽管实际上费用和税收在主动自动交易策略中起着巨大的作用。
Our data source gives a whole new meaning to non-traditional data sources used to make investment decisions.
现在，在我们进入图表之前，我们需要选择一个投资组合，并获得首席执行官的生日。
我们用 stocker 来模拟股票市场。最后，由于 stocker 中的怪异之处，我们只是从 stocker 中取出股票历史数据集，并使用这些数字来做我们自己的回溯测试模拟。系统中的公司列表(tickers)可以在这里找到，这是寻找首席执行官的起点。
One CEO per astrological sign. What could possibly go wrong?
结果
我们模拟了 5 年的每日交易，以下是我们的发现:
**Psychicbot**
Initial Investment: $100.00
Final Balance: $200.34
Annualized Return: 19.0%
我们赚了$$$！？一个基于星座的交易机器人是如何赚钱的？
Hold on….
所以，那是 理应失败的 。为什么会成功？好吧，让我们来看看这是否只是我一生中最大的牛市中的测量结果。让我们后退一步，将结果与这些股票以及 IVV 的基准进行比较。如果我们赚了钱，但少于买入并持有的等权重投资组合，或 ETF 的市场，那么这是一个赚钱策略，比简单地持有市场赚得少。这个想法叫做 alpha 。从逻辑上讲，我们不应该从没有信息的东西中赚钱，所以 alpha 应该是 0 或者负的。所以，让我们来看看…
**Equal Weight (EQWT)** Initial Investment: $100.00
Final Balance: $177.75
Annualized Return: 15.5%
我们比 EQWT 多赚了$$$！？
And this is how the IVV index did over the same period… See: calculator here and growth rate formula here.
所以……IVV 的年增长率为 9.86%，这大约是同等权重结果的 2/3，大约是我们星座情绪机器人回报的一半。
那么…为什么用星座运势交易股票比传统投资策略更有效呢？？魔法？
让我们总结一下我们的现状:
**Annualized Return:**IVV 9.9%
Equal Weight 15.5%
Psychicbot 19.0%
A quick look behind the curtain.
为什么会成功？
答案:偏见+运气+不收费=假
偏见是一种狡猾而微妙的东西，它会毁掉一个精心设计的实验。这里的偏见是，我们只在投资组合中包括首席执行官几年没有变化的股票，而首席执行官的变化通常意味着公司的问题。这给了 EQWT 一个优势。我们当时不可能知道这些公司不会更换 CEO。所以，我们有点不小心作弊了，选择稳定的股票导致我们选择表现良好的股票。这种策略的偏差只是相对于 IVV 而言的。对于 EQWT，我们投资于相同的股票，因此我们的情绪机器人最终在线上或线下的位置基本上是一个随机变量。
此外，我们假设费用为 0 美元。这太低了。在现实生活中，积极的策略，我们可以支付 50%至 100%的总利润的费用。有时更多。净收入在这里很重要，因为净利润被再投资，所以有复合效应。积极策略中较低的费用会带来更高的利润。相比之下，IVV 等 ETF 的费用非常低，EQWT re-balanced monthly 等策略的费用也非常低。
Source: Chapter 3 of Narang, Rishi K. Inside the Black Box: A Simple Guide to Quantitative and High Frequency Trading. Vol. 883. John Wiley & Sons, 2013.
那么，你应该相信这种基于占星术的投资策略吗？绝对不行！好运并不意味着好主意。
Bias is totally a thing (credit: xkcd)
有时，一种方法的不可能性或愚蠢性并不像这里介绍的基于占星术的投资组合管理方案那样明显。有时候很难知道这种方法没有价值。如果你想证明一个策略是错误的，有时你会遇到一些策略，它们的阿尔法值来自偏见，或者仅仅是运气。想象一下，在根据星座运势交易时，有多少 12 只股票的组合，谁的首席执行官生日正确，而且赚的钱不比 EQWT 和 IVV 多。甚至像修改测试周期这样简单的事情也会让“阿尔法”蒸发。你可以用数字撒谎，但纸牌屋很快就会倒塌。当策略转移到纸上交易时，回报不会实现。或者，当参数被测试时，理论就分崩离析了。使用深度学习的真正投资组合管理(例如invest fai)不仅要对数字，甚至对数字所基于的假设进行严格的测试和再测试。阿尔法模型不仅仅是数字；它们是关于想法的。
这又是一次模拟，但这次考虑了使用滑索的交易成本:
Portfolio value using zipline. Initial value is 1 billion dollars. When taking into account fees, we lose almost $1e15 (Also known as $15,000,000,000) before swinging up to $2e10.
上面的图表看起来更真实。所以，基本上，因为我们不能负债 150 亿美元，这个模型在第一年就损失了所有的钱。即使我们一开始有 10 亿美元，我们也会全部输掉。之后的一切都无关紧要了。是的，它最终依靠杠杆推动市场上涨，但这是不相干的怪异之处，因为没有保证金账户让我们在那一点上仍然存在。现在我们终于可以看到这个策略是一个可怕的想法。即使存在知道哪些股票几年内不会更换 CEO 的偏见，以及在没有费用的情况下产生超额回报的运气，这种策略也会损失 10 亿美元。
现在你可能很好奇为什么收费这么高。开始了。如果你通过卖出其他 100 美元的股票来买入一只 100 美元的股票，你在买卖时要支付费用。比方说的费用是 1% ，尽管机构投资者的费用要低得多。这意味着我们通过卖出和买入移动 100 美元的成本为 1+0.99 美元，总共 1.99 美元(忽略按实际美元金额购买股票的量化误差)。所以我们需要在交易中获得 2%的利润才能达到收支平衡。即使费用只有几个基点，但公司仍然是有利可图的，因此该战略需要做得比机会更好，并有足够的利润来支付费用，以避免仅在费用上就达到 0 美元。
产生扣除费用后的净利润的策略是资产管理公司所依赖的阿尔法模型。这些模型需要大量的 GPU 计算能力来运行模拟，所以我们应该更多地使用这些强大的 GPU。
CEO 直面公司业绩
好的。所以我们展示了用占星术交易看起来像一件事(其实不是)。一些更具预测性的模型怎么样？现在，我们已经收集了 CEO 星座的数据集，让我们使用股票代码+“CEO”的图像搜索结果，获取数据来训练一个模型，以预测每家公司的回报。例如:“APPL 首席执行官”。我们知道这应该没有成功的机会。现在让我们通过做实验来证明它。
Image search result for “APPL CEO”
Gobbling up pictures from the interwebz…
首先，我们使用图像搜索 API 获取首席执行官的图像。我们可以使用谷歌的“知识图搜索 API”从公司代码中获取 CEO 的名字。我们还可以使用图像识别 API 或基于 dlib 的库来检查图像中的人脸，并丢弃没有人脸的照片。
让我们看看我们从什么开始:
显然，对于一些公司来说，刮刀没有得到任何结果，而另一些公司找错了人，比如奥巴马总统和公司的某个人站在一起。有时候照片完全不相关。我们通过过滤掉不包含人脸的图像来丢弃它们。受欢迎的人物会跳到这些文件夹中，因为他们与相同的 CEO 和公司关键词相关，例如“埃隆·马斯克”、“比尔·盖茨”、“比尔·阿克曼”、“沃伦·巴菲特”等等。在移除重复图片之后，我最终收集了大约 7GB 的图片进行分类。我们可以抓取多少图像没有真正的上限。你只要坚持下去，直到你不再喜欢它。图像文件的数量是 39，262。
我们收集了 2305 家公司的价格数据，其中 1596 家在测试期结束时价值更高。69%的公司价值更高。这还没有考虑股票分割或股息。另外，请注意 stocker 从 Quandl 获取数据，他们每天只允许您获取 50 个查询，除非您有帐户(免费的那种)。因此，没有帐户会导致代码停止运行。我们继续…
我们需要在 GPU 中进行这种将图像嵌入的处理。要将数据集上传到 S3 存储桶，请执行以下操作(使用真正的 AWS 密钥):
# install AWS cli
pip install awscli# set the AWS credentials
export AWS_ACCESS_KEY_ID=BLAHBLAHBLAHKEYGOESHERE
export AWS_SECRET_ACCESS_KEY=SECONDRANDOMSTRINGYTHINGHERE# upload files in current directory to onepanel-lemayai-datasets
aws s3 sync . s3://your-awesome-dataset/
并从 CLI 将数据集下载到实例，如下所示:
# set the AWS credentials
export AWS_ACCESS_KEY_ID=BLAHBLAHBLAHKEYGOESHERE
export AWS_SECRET_ACCESS_KEY=SECONDRANDOMSTRINGYTHINGHERE# download files in current directory
aws s3 sync s3://your-awesome-dataset/ .
我们可以使用 Onepanel.io 的作业功能来完成这些 GPU 图像转换和分类任务。我在过去讨论过 SageMaker 如何比独立的虚拟机好得多，因为它们只在你关心的任务期间运行。作业以同样的方式工作，但是不会将您局限于定制的 SageMaker 库。
与此相关的是，SageMaker 在本地不可用，但 Onepanel.io 正在为整个平台开发本地私有云部署选项，这对我们的许多企业客户(例如政府、医疗和金融科技)至关重要，他们无法将其数据集迁移到公共云。
现在是有趣的部分。我们把图像转换成嵌入！如 keras 应用页面所述，我们可以将图像转换成嵌入向量。
第一步是知道层的名称。我们用下面的代码得到这个结果:
从这里我们知道我们想要的输出图层在最后，就在实际的分类任务之前。如果我们选择“展平”的输出，我们会得到一个非常大的形状(每个图像 25，088 个要素)，因此我们在输出中选择第一个完全连接的图层的输出，该图层只有 4，096 个要素。
最后，我们可以将嵌入向量设置为输入数据 (x) ，将相应的盈亏价格设置为输出数据 (y) ，以训练一个 DNN (f) ，根据嵌入向量预测价格。每个预测都采用 y=f(x) 的形式。借助 test_train_split 函数，我们可以根据训练数据进行训练，并使用测试数据验证结果。
这是二进制分类的一个很好的例子，在 keras.io 网站的“二进制分类的 MLP”下也有一个很方便的例子。
下面是将图像数据集转换为 CSV 文件中的嵌入向量的代码:
下面是用于训练和测试二元分类模型的代码:
最后，结果如下:
Why are there more TRUE than FALSE?
为什么真的比假的多？我们知道这不是任何类型的集合不平衡，因为我们在代码中对此进行了修正。如果这个结果是真的，那么我们可以用 CEO 的脸来预测股市的赢家和输家……这是怎么回事？？
事实证明，我们的刮刀刮出了许多小变化的相同图片(例如上面提到的沃伦·巴菲特和埃隆·马斯克)，这导致了一些测试和训练数据非常相似。移除完全重复的图像并不是一个足够强大的过滤器来真正消除数据中的这个问题。有效地拥有同一个 CEO 的多个形象，并在培训和测试之间认出这些 CEO，就是作弊。所以，再次强调，不要因为结果好就相信结果好。相信他们，因为他们有意义，并帮助你预测事情。
如果你正在经历脚本和驱动程序安装的痛苦，或者通常不喜欢启动和运行机器学习基础设施的过程， Onepanel.io 可能会让你非常感兴趣。新功能会定期上线。这个解决方案被打包到一个简单的 web 界面中。它只是工作。因此，总之，在本文中，您从头到尾详细了解了一个机器学习项目，包括启动服务器、连接团队、收集数据集、对股票数据进行一些分析，以及以一些预测性的东西结束。你看到了你不应该仅仅因为投资策略赚钱就相信它们。
如果你喜欢这篇文章，那么请点击关注按钮，拍拍这个东西，看看我过去读过的一些文章，比如“如何为人工智能项目定价”和“如何聘请人工智能顾问”另外，查看 Onepanel.io 。
在下一篇文章中，我将介绍我们已经研究了很长时间的东西，它可以帮助企业在内部审计期间自动分析非结构化报告。
下次见！
丹尼尔
daniel@lemay.ai ←问好。
LEMAY . AI
1(855)LEMAY-AI
您可能喜欢的其他文章:
多任务深度学习的 3 种数据技术。
**TLDR；**这篇文章对多任务学习技术进行了高度的介绍，然后概述了三种实用的数据准备方法，我称之为银、金和银金矿。
什么是多任务学习？
多任务学习 (MTL)是学习的共享表征互补任务任务以提高给定目标任务结果的过程。
数据科学领域之外的 MTL 的一个很好的例子是健身房的组合练习，例如俯卧撑和引体向上，它们相互补充，以最大限度地增加全身的肌肉。
单独俯卧撑主要锻炼胸部，其次是背部。而引体向上主要锻炼背部，其次是上胸部。然而，当一起做时，引体向上和俯卧撑相辅相成，为胸部和背部提供比单独做时更好的增益。
为了更好地理解这个概念，让我们后退一步，回顾一下机器学习和深度学习的基础知识。
机器学习 ML 的目标是找到特性来训练模型，该模型将输入数据(如图片、时间序列或音频)转换为给定的输出(如字幕、价格值、转录)。在传统的数据科学中，这些特征通常是手工选择的。
A canonical example of a feed forward deep neural network.
在深度学习(DL) 中，我们通过将我们的输入表示为向量，并通过一系列巧妙的线性代数运算将其转换为给定的输出，来学习提取这些特征。
然后我们使用一个叫做损失函数的等式来评估我们的输出是否是我们所期望的。该过程的目标是使用来自每个训练输入的损失函数的结果来指导我们的模型提取将在下一次传递中导致较低损失值的特征。
“多任务学习 (MTL)是通过组合****任务的损失函数来学习共享表征以提高给定目标任务的结果的过程。”
通过在相关任务之间共享表示，我们可以使模型更好地概括每个原始任务。
例如，让我们看看两个 NLP 任务词性标注和句法短语分块。如果我们使用相同的表示层，并通过结合我们的位置损失和分块预测来更新我们的权重，我们可以将我们的结果提高 0.7 的 F1 分数。当 MTL 模型共享所有相同的参数，但是通过在输出层直接组合两个或更多不同的损耗来更新时，这被称为硬参数共享。
**另一方面，**选择性参数共享，利用下游任务的分级性质，并且仅在相关层更新任务损失。想法是上游任务的更好的表示将导致更好的整体结果。在我们的分块示例中，使用软参数共享导致 1.2 F1 分数比我们的独立结果高。
From left to right. F1 results on standalone chunking, MTL (Hard Parameter sharing), MTL (Soft Parameter Sharing)
一个多任务学习的聪明例子是通过将预测人阅读时的凝视位置的任务与压缩句子结合起来进行的。
An example of gaze tracking.
在对象检测模型中，诸如 RetinaNet 和faster CNN之类的最先进的区域提议网络使用多任务学习来组合来自区域提议和分类任务的损失。
RetinaNet MultiTask Architecture Image Src
MTL 为什么工作
多任务学习似乎直觉上可行，原因如下:
- 隐性数据扩充——通过一起学习两个相关的任务，我们可以在每个任务之间转移隐性理解。
- ****聚焦表征——MTL 将习得的特征表征聚焦在正在学习的任务之间的交集上。
- 注意 规则化——MTL 提供监督防止模特过度配合主任务 。 在这种情况下任务应该是并行学习的。**
警告
然而，在执行多任务学习时会面临一些挑战。
- 让它发挥作用并不容易。
- 很难找到好的任务对，大多数任务对在某些有害的性能上没有任何改进。
- 当两个或更多的任务重叠太多，MTL 往往提供微不足道的收益。
- 如果一个网络不够宽，MTL 伤害所有的任务。
根据经验，更多的任务内数据会比简单地增加更多的任务带来更好的结果。然而，在处理不平衡数据集时，它被证明是有效的。我希望在未来我们可以建立一个框架来尽量减少这些警告。这些挫折通常是为 MTL 准备数据的结果。下面，我将概述三种适用于 MTL 的最佳实践数据技术。
关于多任务学习的更深入的阅读，我强烈推荐 Sebastian Ruder 的帖子和来自 BIU CS 89–687 课程的 Yoav Goldberg 的幻灯片，以及来自 Yoav 的书的第 20 章。
MTL 数据技术
Assorted metal coins. Image Src
如前所述，多任务学习的最大驱动力之一是数据。多任务学习面临的一个挑战通常是给定数据集中所有任务缺乏统一的预先标记或黄金标记的数据。
例如，如果一个人想要在带有词性任务的 SNLI 数据集上用纯金色标签执行多任务学习，他们需要用 POS 标签手动注释 570，000 个人类书写的英语句子对中的每一个。
这种注释是昂贵的，并且通常是禁止的，下面我提出了三种不同的技术，可以应用于处理给定数据集的直接金标记的缺乏，我称之为银、金和银金矿。
白银:
因为我们没有 POS 值，所以我们可以使用一个预先训练好的标记器，比如 Spacy 或 AllenNLP，来为我们的 SNLI 任务生成 POS 标记，并根据它们计算我们的损失。虽然不能保证标签是正确的，但是我们可以希望它们足够接近来指导我们的模型学习我们的主要 SNLI 任务所需的 POS 的正确特征。这种方法的优点是我们的主要 SNLI 任务的 POS 覆盖将是完整的，缺点是我们在我们的模型中引入了噪声。
金色:
虽然我们可能没有给定任务(如 SNLI)的黄金 POS 数据，但我们仍然可以利用来自单独数据集(如 TreeBank)的黄金数据，然后我们可以根据 treebank 计算 POS 任务的损失，并根据 SNLI 数据集计算 SNLI 任务的损失。这种方法的优点是我们保证树库值没有噪声。缺点是，在树库和 SLNI 数据集之间的 POS 标签和句法结构之间可能存在不均匀的覆盖。
银金矿:
Electrum 结合了上述黄金和白银技术，交替或组合加权损失。希望来自 treebank 数据集的黄金值将有助于调节白银数据中的噪声，但白银数据中的正确值将为我们的最终模型提供更好的覆盖范围。这种方法的缺点是需要计算额外的损失和两倍的数据。
行动号召
在我自己的实验中，金、银和银金矿的数据准备方法对我很有效。在未来的帖子中，我希望通过一个基本的 MTL 任务为这种方法提供更好的基准，并可能提供一个简单的 API 来管理 MTL 的数据集和损失。
如果这是你会在下面发现有趣的评论或者发推特给我@ python coder。希望有合作者
资源
Python 中的简单和多元线性回归
Python 中线性回归的快速介绍
大家好！在简单介绍了“熊猫”库和 NumPy 库之后，我想提供一个用 Python 构建模型的快速介绍，还有什么比最基本的模型之一线性回归更好的起点呢？这将是关于机器学习的第一篇文章，我计划在未来写一些更复杂的模型。敬请期待！但是现在，让我们关注线性回归。
在这篇博文中，我想重点介绍线性回归的概念，以及它在 Python 中的实现。线性回归是一种统计模型，用于检验两个(简单线性回归)或多个(多元线性回归)变量(因变量和自变量)之间的线性关系。线性关系基本上意味着当一个(或多个)自变量增加(或减少)时，因变量也增加(或减少):
如你所见，线性关系可以是正的(自变量上升，因变量上升)，也可以是负的(自变量上升，因变量下降)。正如我所说的，我将重点关注回归模型在 Python 中的实现，所以我不想过多地钻研回归背后的数学，但我会写一点关于它的内容。如果你想写一篇关于这方面的博文，请不要犹豫给我回信！
稍微了解一下数学
变量 Y 和 X 之间的关系由以下等式表示:
**Y`i = mX + b**
在这个等式中， Y 是因变量——或者是我们试图预测或估计的变量；x 是独立变量——我们用来做预测的变量；m 是回归线的斜率——它代表了 X 对 Y 的影响。换句话说，如果 X 增加 1 个单位， Y 将增加正好 m 个单位。(“全公开”:只有当我们知道 X 和 Y 有线性关系时才成立。在几乎所有的线性回归情况下，这都不会是真的！) b 是常数，也称为 Y 截距。如果 X 等于 0，Y 将等于 b ( 警告):参见之前的完整披露！).这在现实生活中不一定适用——我们不会总是知道 X 和 Y 之间的确切关系或者有一个确切的线性关系。
这些警告将我们引向一个简单的线性回归。在 SLR 模型中，我们基于数据构建模型——斜率和 Y 轴截距来自数据；此外，我们不需要 X 和 Y 之间的关系是完全线性的。SLR 模型还包括数据中的误差(也称为残差)。我现在不会过多地讨论它，也许在以后的文章中，但残差基本上是 Y 的真实值和 Y 的预测/估计值之间的差异。需要注意的是，在线性回归中，我们试图预测一个连续变量。在回归模型中，我们试图通过找到“最佳拟合线”来最小化这些误差——误差的回归线将是最小的。我们试图将黑线的长度(或者更准确地说，是蓝点与红线的距离)最小化，尽可能接近零。它与最小化均方误差(MSE) 或误差平方和(SSE) 相关(或等效)，也称为“残差平方和”。(RSS)但是这可能超出了这篇博客的范围:-)
在大多数情况下，我们会有不止一个自变量——我们会有多个变量；它可以小到两个独立变量，大到数百个(理论上甚至数千个)变量。在这些情况下，我们将使用多元线性回归模型(MLR)。回归方程与简单回归方程非常相似，只是变量更多:
**Y’i = b0 + b1X1i + b2X2i**
这篇文章的数学部分到此结束:)准备好用 Python 实现它了吗？
Python 中的线性回归
在 Python 中有两种主要的方法来执行线性回归——使用 Statsmodels 和 scikit-learn 。使用 Scipy 库也是可能的，但是我觉得这不如我提到的另外两个库那么常见。让我们来研究一下在这两种情况下进行线性回归:
统计模型中的线性回归
Statsmodels 是“一个 Python 模块，它为许多不同的统计模型的估计，以及进行统计测试和统计数据探索提供了类和函数。”(来自文档)
与 Pandas 和 NumPy 一样，获取或安装 Statsmodels 的最简单方法是通过 Anaconda 包。如果出于某种原因，你有兴趣以另一种方式安装，请查看此链接。安装后，每次需要使用它时，您都需要导入它:
**import statsmodels.api as sm**
让我们看看如何实际使用 Statsmodels 进行线性回归。我将使用我在 DC 大会上的数据科学课中的一个例子:
首先，我们从 sklearn (我提到的另一个库)导入一个数据集:
**from** **sklearn** **import** datasets *## imports datasets from scikit-learn*
data = datasets.load_boston() *## loads Boston dataset from datasets library*
这是波士顿房价的数据集(链接到描述)。因为它是为测试和学习机器学习工具而指定的数据集，所以它附带了数据集的描述，我们可以通过使用命令打印数据来查看它。DESCR(这只适用于 sklearn 数据集，而不是每个数据集！虽然会很酷…)。为了更好地理解变量，我添加了描述的开头:
Boston House Prices dataset
===========================
Notes
------
Data Set Characteristics:
:Number of Instances: 506
:Number of Attributes: 13 numeric/categorical predictive
:Median Value (attribute 14) is usually the target
:Attribute Information (in order):
- CRIM per capita crime rate by town
- ZN proportion of residential land zoned for lots over 25,000 sq.ft.
- INDUS proportion of non-retail business acres per town
- CHAS Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
- NOX nitric oxides concentration (parts per 10 million)
- RM average number of rooms per dwelling
- AGE proportion of owner-occupied units built prior to 1940
- DIS weighted distances to five Boston employment centres
- RAD index of accessibility to radial highways
- TAX full-value property-tax rate per $10,000
- PTRATIO pupil-teacher ratio by town
- B 1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
- LSTAT % lower status of the population
- MEDV Median value of owner-occupied homes in $1000's
:Missing Attribute Values: None
:Creator: Harrison, D. and Rubinfeld, D.L.
This is a copy of UCI ML housing dataset.
http://archive.ics.uci.edu/ml/datasets/Housing
This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.
运行 data.feature_names 和 data.target 将分别打印自变量和因变量的列名。也就是说，Scikit-learn 已经将房价数据设置为目标变量，并将 13 个其他变量设置为预测变量。让我们看看如何对这个数据集进行线性回归。
首先，我们应该将数据加载为 pandas 数据框以便于分析，并将房屋价值中值设置为我们的目标变量:
**import** **numpy** **as** **np**
**import** **pandas** **as** **pd**# define the data/predictors as the pre-set feature names
df = pd.DataFrame(data.data, columns=data.feature_names)
*# Put the target (housing value -- MEDV) in another DataFrame*
target = pd.DataFrame(data.target, columns=["MEDV"])
我们在这里所做的是获取数据集并将其作为熊猫数据框加载；之后，我们设置预测值(如 df)，即数据集中预设的独立变量。我们也在设定目标——因变量，或者我们试图预测/估计的变量。
接下来，我们要拟合一个线性回归模型。我们需要选择我们认为能很好预测因变量的变量——这可以通过检查变量之间的相关性，通过绘制数据并直观地搜索关系，通过对哪些变量能很好预测 y 等进行初步研究来完成。对于第一个例子，让我们以 RM——房间的平均数量和 LSTAT——较低地位人口的百分比为例。需要注意的是，Statsmodels 默认情况下不添加常量。让我们先看看回归模型中没有常数的情况:
*## Without a constant*
**import** **statsmodels.api** **as** **sm**
X = df["RM"]
y = target["MEDV"]
*# Note the difference in argument order*
model = sm.OLS(y, X).fit()
predictions = model.predict(X) # make the predictions by the model
*# Print out the statistics*
model.summary()
输出:
解读桌子这是一张很长的桌子，不是吗？首先我们有因变量，模型和方法。 OLS 代表普通最小二乘法，方法“最小二乘法”意味着我们试图拟合一条回归线，这将最小化到回归线的距离的平方(见本文的前一部分)。日期和时间是不言自明的:)观察次数也是如此。残差和模型的 Df 与自由度相关——“统计数据最终计算中可自由变化的值的数量。”
系数 3.6534 意味着 RM 变量增加 1， MDEV 的预测值增加 3.6534 。其他几个重要的值是 R 平方——我们的模型解释的方差的百分比；标准误差(是统计抽样分布的标准偏差，通常是平均值)；假设检验的 t 分数和 p 值——RM具有统计上显著的 p 值； *RM 有 95%的置信区间(*意味着我们以 95%的置信度预测 RM 的值在 3.548 到 3.759 之间)。
如果我们想在模型中添加一个常量，我们必须使用命令X = sm.add_constant(X)来设置它，其中 X 是包含输入(独立)变量的数据框的名称。
**import** **statsmodels.api** **as** **sm #** import statsmodels
X = df["RM"] *## X usually means our input variables (or independent variables)*
y = target["MEDV"] *## Y usually means our output/dependent variable*
X = sm.add_constant(X) *## let's add an intercept (beta_0) to our model*
*# Note the difference in argument order*
model = sm.OLS(y, X).fit() *## sm.OLS(output, input)*
predictions = model.predict(X)
*# Print out the statistics*
model.summary()
输出:
解读表格 —常数项的系数不同。如果没有常数，我们将强制我们的模型通过原点，但是现在我们有一个 y 截距在 -34.67 。我们还将 RM 预测器的斜率从 3.634 更改为 9.1021 。
现在让我们尝试拟合一个包含多个变量的回归模型——我们将使用我之前提到的 RM 和 LSTAT。模型拟合是相同的:
X = df[[“RM”, “LSTAT”]]
y = target[“MEDV”]model = sm.OLS(y, X).fit()
predictions = model.predict(X)model.summary()
输出是:
Note: this table looks different because I’ve updated my Jupyter Notebook
解释输出 —我们可以看到，该模型的 R 平方值更高，为 0.948，这意味着该模型解释了因变量中 94.8%的方差。每当我们向回归模型中添加变量时，R 会更高，但这是一个相当高的 R。我们可以看到 RM 和 LSTAT 在预测(或估计)中值房屋价值方面具有统计显著性；毫不奇怪，我们看到当 RM 增加 1 ， MEDV 将增加 4.9069，当 LSTAT 增加 1 ， MEDV 将减少-0.6557。你可能还记得，LSTAT 是较低地位人口的百分比，不幸的是，我们可以预计它会降低房屋的中值。同样的逻辑，房子里的房间越多，通常它的价值就会越高。
这是统计模型中一元和多元线性回归的例子。我们可以在回归模型中使用尽可能少或尽可能多的变量——最多 13 个！接下来，我将演示如何在 SKLearn 中运行线性回归模型。
SKLearn 中的线性回归
当谈到 Python 中的机器学习时，SKLearn 几乎是黄金标准。它有许多学习算法，用于回归、分类、聚类和降维。查看我关于 KNN 算法的帖子获得不同算法的地图和更多 SKLearn 的链接。为了使用线性回归，我们需要导入它:
**from** **sklearn** **import** linear_model
让我们使用之前用过的数据集，波士顿房价。该过程在开始时是相同的——从 SKLearn 导入数据集并加载到波士顿数据集中:
**from** **sklearn** **import** datasets *## imports datasets from scikit-learn*
data = datasets.load_boston() *## loads Boston dataset from datasets library*
接下来，我们将数据加载到 Pandas(与之前相同):
# define the data/predictors as the pre-set feature names
df = pd.DataFrame(data.data, columns=data.feature_names)
*# Put the target (housing value -- MEDV) in another DataFrame*
target = pd.DataFrame(data.target, columns=["MEDV"])
现在，和以前一样，我们有包含自变量的数据框(标记为“df”)和包含因变量的数据框(标记为“target”)。让我们用 SKLearn 拟合一个回归模型。首先，我们将定义 X 和 y，这一次我将使用数据框中的所有变量来预测房价:
X = df
y = target[“MEDV”]
然后我会拟合一个模型:
lm = linear_model.LinearRegression()
model = lm.fit(X,y)
lm.fit()函数适合线性模型。我们希望使用模型进行预测(这就是我们在这里的目的！)，所以我们将使用 lm.predict():
predictions = lm.predict(X)
print(predictions)[0:5]
print 函数将打印 y 的前 5 个预测(为了“节省空间”，我没有打印整个列表。移除[0:5]将打印整个列表):
[ 30.00821269 25.0298606 30.5702317 28.60814055 27.94288232]
记住，lm.predict()使用我们拟合的线性模型来预测 y(因变量)。你一定注意到了，当我们用 SKLearn 运行线性回归时，我们不会像在 Statsmodels 中那样得到一个漂亮的表(好吧，它不是那么漂亮…但它相当有用)。我们能做的是使用内置函数返回分数、系数和估计截距。让我们看看它是如何工作的:
lm.score(X,y)
会给出这样的输出:
0.7406077428649428
这是我们模型的 R 分。你们可能还记得，这是解释预测方差的百分比。如果你有兴趣，在这里阅读更多。接下来，让我们检查预测值的系数:
lm.coef_
将给出以下输出:
array([ -1.07170557e-01, 4.63952195e-02, 2.08602395e-02,
2.68856140e+00, -1.77957587e+01, 3.80475246e+00,
7.51061703e-04, -1.47575880e+00, 3.05655038e-01,
-1.23293463e-02, -9.53463555e-01, 9.39251272e-03,
-5.25466633e-01])
截距:
lm.intercept_
这将给出以下输出:
36.491103280363134
这些都是我之前提到的多元回归方程的(估计/预测)部分。查看文档，了解关于 coef_ 和 intercept_ 的更多信息。
所以，这是一个快速(但相当长！)关于如何用 Python 进行线性回归的介绍。实际上，您不会使用整个数据集，但是您会将数据拆分为用于训练模型的训练数据和用于测试模型/预测的测试数据。如果你想了解它，请看看我的下一篇博文。与此同时，我希望你喜欢这篇文章，我会在下一篇文章中“看到”你。
感谢您的阅读！
简单的网络抓取入门
Photo by Jay Wennington on Unsplash
当您需要数据仓库中不容易获得的数据时，或者当数据可以在线获得但不能通过 API 获得时，Web 抓取几乎是您的首选技术，您可以使用 API 通过 HTML 请求提取信息。
假设我们的目标是找到流行的印度博客平台。记住这个用例，现在让我们看看如何为我们的分析找到信息。
数据源:
在谷歌上快速搜索关键词——印度博客，这个网站会出现在第一个结果中。这个网站列出了一些最受欢迎的印度博客和他们的博客链接。因此，这个网站成为我们的数据来源，我们将从那里收集信息，供我们进一步分析。
工具箱:
对于这个分析，我们将使用 Python 编程语言。以下是此分析所需的软件包列表。
- 请求—对于 HTML 请求
- bs4——著名的解析 html 内容和收集所需数据的工具
- re —用于正则表达式和模式匹配
- matplotlib —用于可视化
让我们加载所需的库:
import requests
from bs4 import BeautifulSoup, Comment
import pandas as pd
import re
import matplotlib.pyplot as plt
HTTP 请求
web 抓取的第一步只是发出一个 HTTP 请求，获取 URL 内容(记住这一步只是收集 URL 的内容，并不抓取所需的信息)。
url='https://indianbloggers.org/'
content = requests.get(url).text
对于使用get()的请求，创建一个带有 url 内容的请求对象，而.text方法提取对象/ URL 的内容。
初始化所需的数据对象:
为了进一步进行分析，我们将需要一些数据对象，这里我们正在初始化那些将在后续步骤中使用的对象。
#initalizing an empty dictionary that would be written as Pandas Dataframe and then CSV
d = {'title':[],'links':[]}#initializing blog hosting category
cat = {'blogspot':0,'wordpress':0,'others':0}
正如你所看到的，我们已经创建了两个字典——一个用于肌酸 a 熊猫数据框架，另一个用于我们想要收集信息的必需博客平台。所以基本上是 Blogspot vs WordPress(我们还有其他的，可以包括从自定义域到 medium.com 的任何东西)
开始刮
soup = BeautifulSoup(content, "html.parser") for link in soup.find_all('a',):
if len(link.text.strip()) > 1 and bool(re.match('^http',link['href'])) and not bool(re.search('indianbloggers|twitter|facebook',link['href'])):
d['title'].append(link.text)
d['links'].append(link['href'])
#finding the blog hosting type
if re.search('blogspot',link['href']):
cat['blogspot']+=1
elif re.search('wordpress',link['href']):
cat['wordpress']+=1
else:
cat['others']+=1
#d['len'].append(len(link.text.strip()))
从上面的代码中，您可以注意到已经使用 BeautifulSoup 函数启动了抓取，该函数使用了我们在 HTTP 请求后提取的内容。那只是刮的开始。正如我们在目标中定义的那样，我们在这里提取链接——尤其是域名，以分析哪个博客平台(由 URL 的域名定义)受欢迎。考虑到这一点，我们可以确定我们需要抓取锚链接(带有 HTML 标签‘a’的超链接)。在这个过程中，我们需要做一些数据清理步骤。例如，有一些标签什么都没有，这需要被绕过，我们也不需要获得网站中社交媒体个人资料 URL 的超链接。因此，我们设法用一些正则表达式和 if 条件来清理数据。因为我们提取多个 URL，所以我们需要通过 for 循环迭代我们的数据提取，以提取域信息并统计各个类别——blogpost、WordPress 等——还需要构建追加到我们在上一步中创建的字典中，该字典可以转换为 Pandas 数据框。
输出数据帧:
上一步结束时，我们已经获得了所有需要的信息。为了更进一步，我们将把字典对象‘d’转换成 Pandas 数据框，这在数据分析中更加灵活和有用。然后，可以将数据框保存在您的计算机上，以供将来参考或进一步分析。同时，让我们也打印一些关于数据帧和数据摘要的信息。
blog_list = pd.DataFrame(d).set_index('title')
print(blog_list.head())
blog_list.to_csv('blog_list.csv', encoding='utf-8')
print(str(len(blog_list.index))+' rows written')
print(cat)
>>>
links
title
Amit Agarwal [http://www.labnol.org/](http://www.labnol.org/)
Jyotsna Kamat [http://www.kamat.com/jyotsna/blog/](http://www.kamat.com/jyotsna/blog/)
Amit Varma [http://www.indiauncut.com/](http://www.indiauncut.com/)
Sidin Vadukut [http://www.whatay.com/](http://www.whatay.com/)
Hawkeye [http://hawkeyeview.blogspot.in/](http://hawkeyeview.blogspot.in/)
363 rows written
{'wordpress': 49, 'blogspot': 106, 'others': 208}
正如您在结果中看到的，对象“cat”为我们提供了可视化所需的数据。
可视化流行领域:
有了生成的字典“cat ”,现在让我们使用 matplotlib 来可视化数据(不太美观)。
#plotting the blog hosting type
plt.bar(range(len(cat)), cat.values(), align='center')
plt.xticks(range(len(cat)), cat.keys())
plt.show()
给出了这个图:
虽然“其他”类别(包括自定义域名和任何其他博客平台)赢得了这场比赛，但 WordPress 和 Blogspot 之间——博客帖子成为了赢家——这也可能是第一批移动者主要在博客帖子平台上的原因，然后他们可能会变得受欢迎，并最终出现在这个网站上。
最终注释:
尽管如此，这篇文章的目的只有一个，那就是找到流行的博客平台。这篇文章旨在帮助你开始掌握网络抓取的基础知识。如果你有兴趣了解更多关于网络抓取的知识，你可以查看一下这个 Datacamp 教程。这里使用的完整代码可以在我的 Github 上获得。这个帖子最初出现在 DS+ 上。
张量流基因组变异调用的简单卷积神经网络
生物技术创业公司中的人工智能/机器学习
毫无疑问，使用深度神经网络的最新进展的快速发展已经改变了我们可以解决从图像识别到基因组学的各种问题的方式。许多创业公司(Viome/CZ bio hub/Deep Genomics)都强调在他们的研究和产品中使用“人工智能/机器学习”。硅谷其他相对“大”的生物技术初创公司，如 Verily 、 Calico 和 Grail 要么由 Alphabet 资助，要么与谷歌有着深厚的联系。
当然，这些公司将专注于应用机器学习、深度神经网络和对他们可以收集的大量数据进行挑战性的统计分析(通过各种来源的投资)。).Google Research 还发表了一篇论文，介绍了使用 Google 内部计算能力从 DNA 序列数据中进行单核苷酸多态性(SNP)调用的“deep variant”，并将其作为云服务提供。
在一家为基因组学提供研究仪器(单分子实时 DNA 测序仪)的公司工作，并负责分析基因组学数据和算法开发的日常工作，“DeepVariant”的工作当然吸引了我们的注意。这项工作令人印象深刻，使一般设计的神经网络(Inception v2)的东西，它不是最初设计的。
虽然我已经在生物信息学领域工作了 10 多年，但我在“变异体呼叫”这个子领域工作不多。变体呼叫的算法和工具集中于从测序数据中识别基因组之间的微小差异。在过去的几年里，我主要致力于“从头”重建基因组，即在没有基因组先验知识的情况下构建基因组序列。然而，最近，我开始对现代机器学习工具和理论感兴趣，特别是人工神经网络(ANN)的形式。把解决一些小问题作为一个练习可能是一个很好的练习，所以我最近考虑把变体调用作为 ANN 的一个应用。
什么是变体调用？
基因组学中的“变异体调用”是什么？人类基因组大约有 60 亿个字母。如果你觉得基因组像一本书，那就是一本由“A”、“C”、“G”、“T”60 亿个字母组成的书。现在，每个人都有自己独特的基因组。然而，科学家发现人类基因组的大部分是相同的。随着人类基因组计划，科学界构建了一套序列作为人类基因组“参考”，作为基因组分析工作的基础书籍。每个人的 DNA 测序技术提供了信息，例如，书中的一小段文字，可以用来识别每个人的基因组“书”与参考书的差异，而不是每次从头开始重写书。
有了人类基因组参考，科学家和商业服务提供商就可以对短 DNA 片段进行测序，并将这些片段读数“映射”到参考，从而识别这些微小的差异。由于不需要像从头开始的方法那样从零开始重建基因组序列，这是一种更容易和更便宜的方法来获得一些有用的遗传信息。虽然这种方式更便宜，但也存在一些问题。如果有一些更个人化的特定 DNA 序列不在参考文献中，那么在将读数分配给参考文献的作图过程中会导致错误。参考文献中也有许多相同或接近相同的序列。如果一个读数不包含一些“独特的”签名，那么我们不知道在哪里放置读数。还有排序错误。不是所有我们从序列发生器得到的读数都是 100%准确的。
基本上，为了正确地称呼变体，我们需要确定(1)一个读数在基因组中的正确位置，(2)作图读数与参考读数之间的正确比对，以及(3)用于从比对中识别变体的正确统计。通常情况下，(1)和(2)由“基因组比对器”或“基因组映射器”负责。比如“ bwa ”就是恒力研发的一款流行的基因组比对仪。一旦我们绘制了 DNA 片段阅读图谱，生物信息学从业者可以通过生成一些“堆积”视图(见下文)来可视化它们。在大多数情况下，序列数据与参考数据的差异是明显的。通过一些简单的计数算法，我们将有一个合理的好的变体调用程序。与此同时，基因组和生物信息学过程会引入人为因素，结合测序错误，使得可靠的变异调用相对棘手。
A “pile-up” view of DNA fragment reads for a heterozyguous variant G to A
如果你阅读“DeepVariant”预印本，你可以看到作者为“精密度 FDA 真相挑战”竞赛开发了这项工作。我认为挑战的一个目标是建立一个标准的评估变量集，以便人们可以用它来测试变量调用管道和算法。挑战赛的组织者为那些变异体生成了一个“高质量变异体”数据集，这些变异体可以在阅读参考作图过程不是问题的那些区域中用多种测序技术调用。这些数据集用于评估不同调用算法的质量。
使用 CNN (Inception v2)进行变体调用
The architecture of the DeepVariant caller
DeepVariant 预印本展示了它如何使用谷歌的 DNN 基础设施来制作一个赢得 PrecisionFDA 挑战的变体调用程序。我不认为我能在这里进入 DeepVariant 方法的更多细节。在此期间，概念相当简单。正如我们在上面的堆积图中看到的，大多数情况都很简单，但也会有一些困难的情况。在一些复杂的比对情况下，大多数时候，仔细查看比对视图的人可以比一些简单的算法更好地调用变体。如果这样的图像可能包含从那些模糊的变体调用情况中获得的适当信息，那么对于图像分类工作良好的神经网络将可能能够在调用那些变体方面做得更好，而手动编码的算法可能不能很好地捕捉一些边缘情况。
作者将潜在候选变体的序列比对数据转换成“堆积”图像。不同的颜色和 alpha 通道用于编码阅读序列，根据碱基质量和阅读链。他们使用挑战组织者在人类基因组中识别的几乎所有高置信度变体调用来训练神经网络，并将调用的变体分为三类:纯合变体、杂合变体和无变体。预印本中的表格总结了评估结果:
Evaluation Results from the DeepVariants preprint
DeepVariant 在 Variant 调用许多不同的排序数据类型时表现出良好的性能。然而，正如作者在预印本中指出的，当使用图像分类器进行基因组变异调用时，这将是次优的。在将序列数据转换为图像的过程中，可能会丢失许多有价值的信息。使用单分子测序，错误率可能会更高。人们已经可以从视觉上看到单分子测序的堆积图像与短阅读测序的图像有很大不同。由于单分子技术的不同性质，这种堆积图像可能无法捕获用于单分子测序的正确信息。
An example of pile-up image from single molecule sequencing data.
在过去的几个月里，我一直在用 Tensorflow 构建神经网络模型，用于各种测序相关的分析。虽然我通常不怎么研究变异体调用问题，但我认为作为一个小练习来测试它是有用的，以查看我们是否可以通过对神经网络学习的数据进行编码，从单分子 DNA 测序数据中调用变异体。
一个更简单的用于变体呼叫的 CNN
不同的 DNA 测序方法有不同的错误模式。在单分子 DNA 测序中，由于没有放大信号的化学步骤，人们得到微弱的原始信号。此外，单分子 DNA 测序通常通过实时观察单分子事件来完成。在 DNA 片段阅读中，我们得到了额外的碱基或者错过了一些碱基。我们称这样的错误为“插入-删除”错误。目前大多数单分子技术都比其他的镜头读取技术有更高的错误率。然而，单分子技术允许我们读取很长的 DNA 片段。相比之下，通常单分子技术读取 DNA 的时间是非单分子 DNA 测序技术的 10 到 100 倍。更多的错误使许多事情变得更具挑战性。另一方面，较长的 DNA 片段读数有助于解决歧义，因为较长的 DNA 片段可能包含基因组中独特的信息。我们将能够正确地识别一个读数来自基因组的什么地方。
“indel”错误的影响是，它使比对(DNA 阅读片段与参照片段之间的碱基对碱基对应)“更模糊”。因此，关于变体的信息可能不集中在变体位点，而是分散开来。像 DeepVariant 一样，如果我们能够以简洁的方式收集变异位点以外的信息，神经网络将能够使用这些额外的信息进行更好的分类。我们也没有像谷歌那样的资源来训练一个大的神经网络模型。我们能不能制造一个小的神经网络变体呼叫者，可以使用有限的资源来训练它？
事实上，使用 Google 的 Tensorflow 构建一个用于变体调用的小型卷积神经网络并使用有限的资源训练一个小型神经网络是非常简单的。我构建了一个快速原型，我称之为“ VariantNET ”。我们不生成对齐堆积图像，并使用大型图像分类器 CNN 进行变体调用。我们将比对信息总结成三个 15×4 的矩阵。我们首先做一些简单的统计来建立一个候选变量列表。对于每个候选物，我们在两侧添加 7 个碱基侧翼碱基。包括变异候选位点，我们同时考虑参考文献中的 15 个碱基。
对于每个位置，我们使用独热码来生成矩阵。也就是说，对于每个位置，我们跟踪“A”/“C”/“G”和“T”每个基数的 4 个计数。一个矩阵追踪编码参考序列的基线和通过一个位置支持的阅读数。另外两个 15×4 矩阵追踪测序数据和参考之间的差异。一个矩阵被设计用于追踪序列数据中所有碱基的差异，另一个矩阵集中于参考序列中缺失的碱基。我们认为这种总结比排列堆积图像更能简明地捕捉有用的信息。例如，如果读数中有一个额外的碱基，它通常只是堆积图像中的一个简单标记，我们可能会丢失关于额外碱基是哪种 DNA 核苷酸的信息。
VariantNET for variant calling
对于每个候选变体站点，一个 15 乘 4 乘 3 形状的“张量”被发送到一个几乎令人尴尬的简单卷积神经网络 (2 个卷积+ maxpool 层，后面是 3 个全连接+丢弃层)用于变体调用。我们设计网络输出，将候选人称为“杂合变异体”、“纯合变异体”、“非变异体”或“复合变异体”。除了对候选位点的变异类型进行分类，变异网络还被训练来预测可能的变异碱基。我们使用这种更简单的 CNN 进行变体呼叫的初步实验结果显示，在最小调整的情况下，具有相当好的性能。在示例中，我们只使用了一个小的训练集。当使用来自 21 号染色体的预先识别的变异体调用时，训练通常运行不到 10 分钟。我们在 22 号染色体上测试预测，我们通常得到 98%以上的召回率和 PPV。由于我们没有对比对进行任何优化，也没有使用除 PacBio 测序仪生成的碱基之外的任何其他信息，因此进一步优化可以使其达到更高的变体调用准确性也就不足为奇了。
下一步是什么？
我还没有进行更大规模的变异调用实验，所以现在还没有直接的比较。导致学术论文撰写的全面评估可能需要一段时间。我还没有做那件事的计划。我认为这个小练习已经表明，假设错误不是系统性的，可以使用小的神经网络而不是大的神经网络来提高更多噪音测序数据的变体呼叫准确性。
VariantNET 可能处理大多数孤立的 SNP 呼叫。当附近有变体或者变体是小的 indel 时，那么我们当前将变体调用放入“复杂变体”桶中。这可能并不理想。对于那些复杂的变异体，像 VariantNET 这样的分类器可以起到增加候选体附近确实有变异体的置信度的作用。我们可以为最终的变体调用产生从头共识，以避免由阅读和参考之间的较大差异引起的比对假象。
我确信还有其他人也在研究使用神经网络进行变异调用。无论如何，使用 ANN 进行变体调用似乎是显而易见的事情。幸运的是，正如我们在这里展示的，我们可能不需要大型机器来完成这项工作。我们使用非常简单的神经网络和来自测序读数的非常少的信息，但是我们在第一次尝试中获得了相当好的结果。令人兴奋的是，除了碱基之外，结合其他有用的信息和使用更好的预处理算法可以进一步提高变体调用的质量。我不确定此刻我会沿着这条线做多少工作。然而，如果任何读者对一些讨论感兴趣，请让我知道。这是一个有趣的东西，结合了当今的两个热门话题:机器学习和基因组学！！
附言
感谢 亚历山大·巴甫洛夫加里宁 指出他们对当前生物学和医学深度学习技术现状的伟大而全面的综述论文:http://www.biorxiv.org/content/early/2017/05/28/142760，里面有很多有用的信息和讨论。我强烈推荐。
部署 Web 应用程序+ ML 模型+API—教程
了解如何部署由逻辑回归模型提供服务的 web 应用程序。我们将创建一个应用程序来预测数据科学家年收入超过 10 万美元的概率。
如果不投入生产，创造一个 ML 模型有什么意义？计算模型的指标并将其调整到更好的性能并不是数据科学家工作的终点。你能做的远不止这些。事实上，部署一个可伸缩的模型比看起来容易得多。知道如何做到这一点，肯定会给你的简历增加很大的价值，因为大多数数据科学家不会走那么远。您可以将本教程视为成为数据科学独角兽的第一步。
我们在这里做什么？
我们将在 AWS Lambda 中部署一个逻辑回归模型，然后用 API Gateway 创建 API 端点。这样你就有了一个可扩展的服务模型，你只需要做一个简单的 POST 请求，它就会把预测结果返回给你。
然后，我们将构建一个带有 HTML 表单的 Flask 应用程序，以获取一些答案来填充我们的模型。该应用程序向我们的 API 发出请求，将用户重定向到另一个页面，并在其上展示模型预测。
在这里，您可以访问我们在本教程中开发的工作应用程序。你爱怎么玩就怎么玩。
This is how our Flask App will look like.
第一:模型
这篇文章的主要目的不是开发一个模型，但是你可以自由地查看我们在这里使用的模型是如何开发的。这是一个简单的逻辑回归模型。要部署它，我们基本上有两种选择:
- 将模型导出为序列化对象，加载到 AWS lambda 并开始进行预测。
- 参数化模型，将所有系数和截距手动加载到λ。
我选择第二个选项，因为我希望模型对任何人都是透明的。应该清楚系数是什么，分数是怎么算出来的。一个系列化的模型不会让我们看到细节。
在这篇由本·韦伯撰写的关于数据科学的文章中，你会找到关于如何向 AWS Lambda 部署序列化模型的说明。
参数化:那是什么鬼东西？
逻辑回归模型可以写成这样:
log-odds = b0 + b1x1 + b2x2 + ... + bnxn **Where**:
**b0** is the intercept
**b1,b2, bn** are the coefficients
**x1, x2, xn** are the variables
我们训练我们的模型并得到所有系数的值。所以这只是一个手工写方程的问题:将所有系数和截距相加。然后为了得到 0 到 1 之间的分数(概率),我们做:
scores = 1 / (1 + exp(-(b0 + b1x1 + b2x2 + ... + bnxn)))
第二:λ
登录 AWS 控制台，转到 IAM 并创建一个至少附加了这些权限策略的角色:
- AWSLambdaFullAccess
- 亚马逊 3 完全访问
- CloudWatchFullAccess
IAM Role Permissions
然后你可以去 Lambda，点击进入“创建函数”。现在我们将定义函数的基本配置。
Choose the runtime to be Python 3.7, and the role to be the one you just created.
现在，您转到函数代码，将以下内容添加到已经创建的 lambda 函数中:
这段代码是做什么的？
该函数接收一个 json 作为事件参数，并将其处理为正确的格式。接下来，我们用下面将要定义的帮助函数计算分数，然后我们构建一个响应并返回它。就这么简单。
现在我们将创建一些辅助函数。转到文件>从模板新建> Python 文件:
添加以下代码，并将其保存为 normalizer.py:
创建一个新的 Python 文件，将其命名为 pre_treatment.py:
最后，我们将添加一个计算分数的函数。请注意，这里的模型系数是硬编码的。命名为 scorer.py。
搞定了。现在让我们为我们的模型创建一个 API。在设计器>添加触发器，点击 API 网关。
点击 configuration required，选择 create a new API，然后保存 lambda 函数。如果您返回到 API 网关，您应该会看到一个可用的端点。这就是你用来访问你的 API 的那个。
要测试您的 API，只需向端点发送一个 POST 请求，如下所示(用您刚刚创建的 url 替换 URL):
您应该期望得到计算的分数作为响应。大概是这样的:
{ “isBase64Encoded”: False,
“headers”: {“Content-Type”: “application/json”},
“statusCode”: 200,
“body”: {“score”: 350}
}
太好了！我们刚刚创建了一个可伸缩的服务，它在给定输入的情况下运行我们的模型。现在，我们构建了一个 web 应用程序，它向我们的服务发送请求，并期望得到答案。
完整的项目有更多的功能，看看这里:
[## andresionek 91/ka ggle-top 20-预测器
预测数据科学家的年收入是否超过 10 万美元-andresionek 91/ka ggle-top 20-预测者
github.com](https://github.com/andresionek91/kaggle-top20-predictor)
第三:Flask 应用
用下面的文件夹结构创建一个项目(你可以从我的 github 中克隆它)。
有两个 HTML 页面(index.html 和 score.html)存储在模板文件夹中。所有的 css，图片和 js 都在静态文件夹中。我们对这个应用程序感兴趣。py:
将我们的应用程序部署到 beanstalk 也很简单。
- 首先确保在文件夹中创建了 git 存储库。确保代码被提交并推送到主服务器。
- 打开终端并运行
pip install awsebcli来安装 Beanstalk 命令行界面 - 然后
cd到你的项目文件夹并运行eb init - 运行之后，您可以运行
eb create来创建您的应用程序 - 最后
eb open会打开你的 app 网址
要进行额外的部署和更新:
- 首先提交/推送代码
- 然后运行
eb deploy
完整烧瓶项目可从以下网址获得:
计算数据科学家报酬的 Flask 应用程序-andresionek 91/data-scientist-value
github.com](https://github.com/andresionek91/data-scientist-value) 
这是一个将 ML 模型部署为服务的教程，创建一个 API，最后使用 Flask 构建一个 web 应用程序来请求我们的模型的 API。我知道这个教程可能过于简单，但是你可以通过简单的网上搜索找到大量关于每个主题的详细资料。这个想法只是为了证明这是可能的，而且并不复杂！
我希望这篇文章能帮助你找到成为更有价值的数据科学家的方法！
使用 DataExplorer 包在 R 中进行简单快速的探索性数据分析
Image Courtesy: https://pixabay.com/en/calculator-calculation-insurance-1680905/
探索性数据分析在整个数据科学工作流程中扮演着非常重要的角色。事实上，这占用了整个数据科学工作流程的大部分时间。有一句很好的引言(不确定是谁说的):
“在数据科学中，80%的时间花在准备数据上，20%的时间花在抱怨需要准备数据上。”
随着 R 成为许多数据分析师的首选语言，EDA 需要一名 R 程序员将几个来自臭名昭著的tidyverse世界的包放到他们的 R 代码中——即使是最基本的带有一些条形图和直方图的 EDA 也是如此。
最近，我遇到了这个包 DataExplorer ，它似乎只用一个函数create_report()就完成了整个 EDA(至少是典型的基本 EDA ),这个函数生成了一个很好的可呈现的 Rmarkdown html 文档。这只是一个自动生成的报告，如果您想要控制想要在其上执行 EDA 的内容，DataExplorer 为此提供了几个绘图功能。
这篇文章的目的是解释使用DataExplorer包在 R 中你能有多快。
安装和装载
让我们从加载库开始我们的 EDA:
#Install if the package doesn't exist
#install.packages('DataExplorer)
library(DataExplorer)
资料组
我们将用于此分析的数据集是发布在 Kaggle 上的巧克力棒评分。数据集可以在这里下载。将输入数据集加载到 EDA 的 R 会话中:
choco = read.csv('../flavors_of_cacao.csv', header = T, stringsAsFactors = F)
数据清理
在继续之前，需要对数据类型进行一些重新格式化。比如可可。百分比应该是一个数字值，但由于%符号的存在而被读作一个字符，因此需要固定。
choco$Cocoa.Percent = as.numeric(gsub('%','',choco$Cocoa.Percent))
choco$Review.Date = as.character(choco$Review.Date)
变量
在 EDA 中，首先要做的是检查输入数据集的维度和变量的时间。
plot_str(choco)
给出了这个图:
这样，我们可以看到我们有一些连续变量和一些分类变量。
人类寻找缺失的价值
在深入分析之前，查看用于分析的输入数据是否有缺失值非常重要。
plot_missing(choco)
给出:
幸运的是，这个数据集中没有缺失值。
连续变量
直方图是分析师分析/表示连续变量的最好朋友。
plot_histogram(choco)
给出了这个图:
也许，你是密度图的粉丝，DataExplorer已经有了一个函数。
plot_density(choco)
给出了这个图:
多变量分析
这标志着单变量分析的结束和双变量/多变量分析的开始，从相关性分析开始。
plot_correlation(choco, type = 'continuous','Review.Date')
给出了这个图:
与相关图类似，DataExplorer具有绘制箱线图和散点图的功能，语法与上面类似。
分类变量—柱状图
到目前为止，我们已经看到了 EDA 绘图的种类，DataExplorer让我们为连续变量绘图，现在让我们看看我们如何能为分类变量做类似的练习。没想到，这变成了一个非常简单的功能plot_bar()。
plot_bar(choco)
给出了这个图:
最后，如果你只有几分钟时间(就像 maggi noodles 广告中那样，两分钟！)只要简单地使用create_report()就可以了，它在 html 中给出了一个非常好的可展示/可分享的渲染 markdown。
create_report(choco)
希望这篇文章能帮助您执行简单快速的 EDA，并使用典型的 EDA 元素生成可共享的报告。要了解更多关于 R 中的探索性数据分析，请查看这个 DataCamp 课程
参考
数据集
Kaggle 内核
源代码—Github
data explorer—CRAN
这篇文章最初发表在数据科学+
通过 Python 中的 TensorFlow 使用 ML 进行简单的房价预测
现实职业正在进入 21 世纪，正如你可以想象的那样，房屋清单充斥着互联网。如果你曾经考虑过买房、租房，或者只是想看看城里最贵的房子是什么样的(我们都去过)，那么你很可能去过 Zillow、Realtor.com、Readfin 或 Homesnap。如果你去 Zillow 网站搜索你附近的房子，你会看到这样的列表:
这肯定是一个审美清单，像所有分类广告一样，它有一个要价；在这种情况下，379，900 美元。但是如果你继续向下滚动，你会看到一个标题为“家庭价值”的标签，展开窗口会给你一个“Zestimate”
Zestimate 是 Zillow 预测的房子的价值；这是他们最好的猜测。Zillow 给出了这个定义，“Zestimate 住宅估价是 Zillow 的估计市场价值。这不是评估。用它作为一个起点来确定一个家的价值。
但是 Zillow 是怎么把价格猜的这么准的？要价和 Zestimate 的差价只有 404 美元。但这肯定不是手动完成的，对吗？Zillow 的数据库中有超过 1.1 亿套住房(并非目前全部在市场上)，手工进行这些估算是不可行的。你可能会认为这是某种形式的算法，你可能是对的。但考虑到房屋估价的复杂性，即使是传统的算法也可能表现不佳，而且复杂得不可思议。房屋价值取决于位置、浴室数量、面积、楼层数、车库、游泳池、邻近价值等。我想你明白了。这就是本文主题发挥作用的地方，机器学习！
在这篇文章中，我将带你使用 python 中的神经网络构建一个简单的房价预测工具。喝杯咖啡，打开一个新的 Google Colab 笔记本，让我们开始吧！
步骤 1:选择模型
在我们开始告诉计算机做什么之前，我们需要决定我们将使用什么样的模型。我们需要首先问自己目标是什么。在这种情况下，我们有一些关于房子的输入(位置、浴室数量、条件等)，我们需要产生一个输出:价格。这是一个数字输出，这意味着我们可以在一个连续的尺度上表达它(稍后会详细介绍)。给定这些参数，我们可以选择利用神经网络来执行回归。谷歌机器学习框架 Tensorflow 是一个很好的基础，可以在其上建立这样一个模型。
如果你不熟悉神经网络是如何工作的，这将有助于理解这里发生的事情，简单地谷歌一下或找到一个 YouTube 视频，有一个很好的资源。
第二步:收集数据
我们将要使用的数据集来自 Kaggle.com。如果你不熟悉 Kaggle，这是一个很好的机会去那里看看！本质上，它是一个存放数据科学应用数据集以及举办竞赛(通常有可观的现金奖励)的网站。事实上，Zillow 举办了一场比赛来帮助改进 Zestimate。当我告诉你奖金是 120 万美元时，我不是在开玩笑。有一天…
无论如何，去 Kaggle.com 创建一个账户，只需要几秒钟，而且是免费的。找到“编辑配置文件”并向下导航到“创建新的 API 令牌”这将创建一个名为“kaggle.json”的文件，您可以下载该文件。这是一个包含你的用户名和 API 密匙的文件，所以不要把它给任何人，也不要编辑它的内容(如果你不小心丢失了它或者改变了它，你可以让旧的过期，换一个新的)。
导航到 Kaggle 的“竞争”标签，搜索“房价:高级回归技术”您将看到有一个“Data”选项卡，我们将从这里提取数据。
旁注:你需要接受与比赛相关的条款和条件来下载数据，但这并不需要参与比赛，不用担心。
现在我们有了得到这个面包所需要的一切…我指的是数据。
第三步:建立模型
我们将要构建这个模型的环境是 Google Colab，一个免费的在线 python 笔记本环境。在浏览器中输入 colab.research.google.com，开始一个新的 Python 3 笔记本。
对于以前没有使用过笔记本的人来说，在移动下一个单元格之前，您可以通过点击 run 来编译每个单元格。
让我们从安装和导入依赖项开始:
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
Tensorflow 是我们将使用的机器学习框架，pandas 将作为我们的数据框架，numpy 将协助数据操作，matplotlib 是我们的数据可视化工具，sklearn 将为我们提供一种扩展数据的方法。
下一个命令将安装 Kaggle API，我们将结合 kaggle.json 文件使用它来将数据直接导入到环境中。
!pip install kaggle
下一行使用内置的 Colab 文件工具，它允许我们将“kaggle.json”上传到笔记本。只需执行下面的命令，并使用出现的按钮上传文件。
from google.colab import files
files.upload()
Kaggle API 需要该文件位于特定的位置，以便进行身份验证。这次就相信我吧。执行此命令创建目录并放置文件。
!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/!chmod 600 ~/.kaggle/kaggle.json
现在我们已经准备好使用 API 导入数据了！转到 Kaggle 竞赛页面上的数据选项卡并按下以下按钮，这会将您需要的特定命令直接复制到您的剪贴板:
当然，你可以复制下面的代码，但这是你从不同的数据集/比赛中获取数据的方式。重要提示:您需要放置“！”在 Colab 中的命令前面，如果您在本地运行，就不需要这样做。
!kaggle competitions download -c house-prices-advanced-regression-techniques
如果您运行该行并收到“错误 403:禁止”，那么您可能不接受 Kaggle 竞争的条款和条件。
执行以下命令，查看当前目录中文件的名称(我们刚刚下载的内容):
!ls
现在来看一大段代码。下一个单元格正在读取。csv 文件并构建一个数据框架来存放它们。我们可以使用这个数据框架与我们的数据进行交互。这段代码获取数据帧，删除这里不需要的“Id”列，然后将数据分成两个独立的数据帧:一个用于分类值，另一个用于连续值。
#Build the dataframe for train data
train=pd.read_csv('train.csv',encoding='utf-8')
train.drop(['Id'], axis=1)
train_numerical = train.select_dtypes(exclude=['object'])
train_numerical.fillna(0,inplace = True)
train_categoric = train.select_dtypes(include=['object'])
train_categoric.fillna('NONE',inplace = True)
train = train_numerical.merge(train_categoric, left_index = True, right_index = True)
那么，我们为什么要将数据分成数字列和分类列呢？这是因为它们是两种不同的数据类型。一个由连续谱上的数字数据组成，另一个包含与类别相关联的字符串。我们需要区别对待他们。
附注:如果您想查看数据帧的内容以帮助可视化，只需调用 head()函数，如下所示。
train.head()
运行以下命令来隔离异常变量。Sklearn 将帮助我们去除数据中的异常值。这将使那些更准确地代表非异常情况的数据点的学习过程更容易。
from sklearn.ensemble import IsolationForestclf = IsolationForest(max_samples = 100, random_state = 42)
clf.fit(train_numerical)
y_noano = clf.predict(train_numerical)
y_noano = pd.DataFrame(y_noano, columns = ['Top'])
y_noano[y_noano['Top'] == 1].index.valuestrain_numerical = train_numerical.iloc[y_noano[y_noano['Top'] == 1].index.values]
train_numerical.reset_index(drop = True, inplace = True)train_categoric = train_categoric.iloc[y_noano[y_noano['Top'] == 1].index.values]
train_categoric.reset_index(drop = True, inplace = True)train = train.iloc[y_noano[y_noano['Top'] == 1].index.values]
train.reset_index(drop = True, inplace = True)
下一段代码获取数据帧，将其转换为矩阵，并应用所谓的最小最大缩放器。该过程将值缩小到指定的范围，以使训练更容易。例如，从 100 到 1000 的数字列表可以转换为 0 到 1 的范围，其中 0 表示 100，1 表示 1000。
col_train_num = list(train_numerical.columns)
col_train_num_bis = list(train_numerical.columns)col_train_cat = list(train_categoric.columns)col_train_num_bis.remove('SalePrice')mat_train = np.matrix(train_numerical)
mat_new = np.matrix(train_numerical.drop('SalePrice',axis = 1))
mat_y = np.array(train.SalePrice)prepro_y = MinMaxScaler()
prepro_y.fit(mat_y.reshape(1314,1))prepro = MinMaxScaler()
prepro.fit(mat_train)prepro_test = MinMaxScaler()
prepro_test.fit(mat_new)train_num_scale = pd.DataFrame(prepro.transform(mat_train),columns = col_train_num)
train[col_train_num] = pd.DataFrame(prepro.transform(mat_train),columns = col_train_num)
下面的代码将把分类特征散列成我们的模型可以理解的数字输入。哈希是另一篇文章的主题，如果你感兴趣，可以在谷歌上搜索一下。
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
COLUMNS = col_train_num
FEATURES = col_train_num_bis
LABEL = "SalePrice"FEATURES_CAT = col_train_catengineered_features = []for continuous_feature in FEATURES:
engineered_features.append(
tf.contrib.layers.real_valued_column(continuous_feature))for categorical_feature in FEATURES_CAT:
sparse_column = tf.contrib.layers.sparse_column_with_hash_bucket(
categorical_feature, hash_bucket_size=1000)engineered_features.append(tf.contrib.layers.embedding_column(sparse_id_column=sparse_column, dimension=16,combiner="sum"))
现在，我们将隔离输入和输出变量，然后将它们分成测试集和训练集。创建测试序列时要使用的经验法则是 80%测试和 20%训练，我已经在下面完成了(test_size=0.2)。这里的结果是测试和训练的输入和输出集
# Build the training set and the prediction set
training_set = train[FEATURES + FEATURES_CAT]
prediction_set = train.SalePrice# Split the train and prediction sets into test train sets
x_train, x_test, y_train, y_test = train_test_split(training_set[FEATURES + FEATURES_CAT] ,
prediction_set, test_size=0.2, random_state=42)
y_train = pd.DataFrame(y_train, columns = [LABEL])
training_set = pd.DataFrame(x_train, columns = FEATURES + FEATURES_CAT).merge(y_train, left_index = True, right_index = True)y_test = pd.DataFrame(y_test, columns = [LABEL])
testing_set = pd.DataFrame(x_test, columns = FEATURES + FEATURES_CAT).merge(y_test, left_index = True, right_index = True)
现在，我们可以将连续和分类特征重新组合在一起，然后通过调用 DNNRegressor 函数并传入特征、隐藏层和所需的激活函数来构建模型框架。这里我们使用了三层，每层的节点数量都在减少。激活函数是“relu”但是尝试使用“leaky relu”或者“tanh”看看你是否得到更好的结果！
training_set[FEATURES_CAT] = training_set[FEATURES_CAT].applymap(str)
testing_set[FEATURES_CAT] = testing_set[FEATURES_CAT].applymap(str)def input_fn_new(data_set, training = True):
continuous_cols = {k: tf.constant(data_set[k].values) for k in FEATURES}
categorical_cols = {k: tf.SparseTensor(
indices=[[i, 0] for i in range(data_set[k].size)], values = data_set[k].values, dense_shape = [data_set[k].size, 1]) for k in FEATURES_CAT}# Combines the dictionaries of the categorical and continuous features
feature_cols = dict(list(continuous_cols.items()) + list(categorical_cols.items()))
if training == True:
# Converts the label column into a constant Tensor.
label = tf.constant(data_set[LABEL].values)# Outputs the feature columns and labels
return feature_cols, label
return feature_cols# Builds the Model Framework
regressor = tf.contrib.learn.DNNRegressor(feature_columns = engineered_features,
activation_fn = tf.nn.relu, hidden_units=[250, 100, 50])categorical_cols = {k: tf.SparseTensor(indices=[[i, 0] for i in range(training_set[k].size)], values = training_set[k].values, dense_shape = [training_set[k].size, 1]) for k in FEATURES_CAT}
执行以下功能将开始训练过程！这需要几分钟的时间，所以伸个懒腰吧！
步骤 5:训练模型
regressor.fit(input_fn = lambda: input_fn_new(training_set) , steps=10000)
让我们把结果可视化吧！这段代码将导入我们的数据可视化工具，计算预测值，获取实际值，然后将它们绘制成图表。
步骤 6:评估模型并可视化结果
import matplotlib.pyplot as plt
import matplotlibev = regressor.evaluate(input_fn=lambda: input_fn_new(testing_set, training = True), steps=1)
loss_score = ev["loss"]
print("Final Loss on the testing set: {0:f}".format(loss_score))import matplotlib.pyplot as plt
import matplotlib
import itertoolsev = regressor.evaluate(input_fn=lambda: input_fn_new(testing_set, training = True), steps=1)
loss_score = ev["loss"]
print("Final Loss on the testing set: {0:f}".format(loss_score))
reality = pd.DataFrame(prepro.inverse_transform(testing_set.select_dtypes(exclude=['object'])), columns = [COLUMNS]).SalePricey = regressor.predict(input_fn=lambda: input_fn_new(testing_set))
predictions = list(itertools.islice(y, testing_set.shape[0]))
predictions = pd.DataFrame(prepro_y.inverse_transform(np.array(predictions).reshape(263,1)))matplotlib.rc('xtick', labelsize=30)
matplotlib.rc('ytick', labelsize=30)fig, ax = plt.subplots(figsize=(15, 12))
plt.style.use('ggplot')
plt.plot(predictions.values, reality.values, 'ro')
plt.xlabel('Predictions', fontsize = 30)
plt.ylabel('Reality', fontsize = 30)
plt.title('Predictions x Reality on dataset Test', fontsize = 30)
ax.plot([reality.min(), reality.max()], [reality.min(), reality.max()], 'k--', lw=4)
plt.show()
还不错！要获得更好的结果，请尝试更改激活函数、层数或层的大小。或许完全使用另一种模式。这不是一个庞大的数据集，所以我们受到信息量的限制，但这些技术和原理可以转移到更大的数据集或更复杂的问题上。
如有任何疑问、意见、担忧或建议，请随时联系我。
我也想给朱利安·海杜克大声喊出来，他的模型是。点击这里查看他的视频:https://www.kaggle.com/zoupet
简单介绍使用 TorchFusion 和 PyTorch 的条件性 GANs
人类非常善于认识事物，也非常善于创造新事物。长期以来，我们一直致力于教计算机模仿人类识别事物的能力，但创造新事物的能力长期以来一直未能被人工智能系统所掌握。直到 2014 年，Ian Goodfellow 发明了生成式对抗网络。在这篇文章中，我们将对生成对抗性网络进行一个基本的概述，并且我们将使用它们来生成特定数字的图像。
生成性对抗网络概述
想象一下，你是一名艺术家，正试图画一幅非常逼真的奥巴马画像，让法官误以为这幅画是真的。你第一次这样做，法官很容易发现你的照片是假的，然后你一次又一次地尝试，直到法官被愚弄，认为照片是真的。生成敌对网络是这样工作的，它由两个模型组成，
绘制图像的生成器 和试图区分真实图像和由鉴别器绘制的图像的 鉴别器 。
从某种意义上说，两者是相互竞争的，生成器被训练来愚弄鉴别器，而鉴别器被训练来正确区分哪些图像是真实的，哪些是生成的。最终，生成器将变得如此完美，以至于鉴别器将无法区分真实图像和生成的图像。
下面是由 GAN 发生器创建的样本。
Source: Karras et al, 2017 (http://arxiv.org/abs/1710.10196)
GANs 分为两大类，无条件 GANs 随机生成任意类图像，有条件 GANs 生成特定类图像。在本教程中，我们将使用条件 gan，因为它们允许我们指定我们想要生成的内容。
工具设置
训练 GANs 通常很复杂，但多亏了 Torchfusion，一个建立在 PyTorch 基础上的研究框架，这个过程将会超级简单和直接。
通过 PyPi 安装火炬融合
pip3 install torchfusion
安装 PyTorch
如果你还没有安装 torchfusion，去pytorch.org下载 PyTorch 的最新安装文件。
现在您已经完全设置好了！
接下来，导入几个类。
定义发生器网络和鉴别器
在上面，我们指定要生成的图像的分辨率为 1 x 32 x 32。
为生成器和鉴别器模型设置优化器
现在我们需要加载一个数据集，我们将尝试从中抽取样本。在这种情况下，我们将使用 MNIST。
下面我们创建一个学习者，torchfusion 有各种各样的学习者，他们高度专业化，用于不同的目的。
现在，我们可以调用训练函数来训练这两个模型
通过将 save_outputs_interval 指定为 500，学习者将在每 500 次批量迭代后显示示例生成的输出。
这是完整的代码
仅经过 20 个时期的训练，就生成了下图:
现在到了最激动人心的部分，使用你训练过的模型，你可以很容易地生成特定数字的新图像。
在下面的代码中，我们生成了数字 6 的新图像，您可以指定 0-9 之间的任何数字
结果:
生成对抗网络是一个令人兴奋的研究领域，torchfusion 通过最佳 GAN 算法的优化实现使它变得非常简单。
火炬融合由我和摩西·奥拉芬瓦(I and Moses Olafenwa)开发和维护，这是我们努力实现人工智能民主化并让地球上每个人和组织都可以使用它的一部分。
火炬传递的官方回购是 https://github.com/johnolafenwa/TorchFusion
火炬融合的教程和文档可以从https://torch fusion . readthedocs . io获得
你可以随时在推特上通过 @johnolafenwa 联系我
线性回归
"正确问题的近似答案比近似问题的精确答案更有价值。"约翰·图基
线性回归是一种线性方法，用于模拟标量因变量 y 和一个或多个独立变量x之间的关系，与逻辑回归不同，这里的因变量可以取连续的值范围。使用称为线性假设的线性预测函数对关系进行建模，其未知模型参数根据数据进行估计。让我们从一个线性假设开始。
其中
我们可以用如下简洁的符号来表示。
上述等式表明，给定新的输入特征向量 x ，输出的预测值将由假设 h 给出。所以预测的准确性取决于输入特征的 权重。
如果我们用大小为 m 的向量来表示 m 训练示例的实际输出值，一种合理的方式是使用训练集来使的值接近于y .我们将的实际差值定义为 代价函数**
所以现在这个等式变成了寻找 权重 对于哪个 代价函数 J 最小。
让
其中
Y :为 m 个训练样本的输出向量。
X :是大小为 m*n 的矩阵，其中每第 I 行属于第 I 个训练集。
Q :为 n 训练特征的大小为 n 的权重向量。
所以
和
这导致了
示例: 给定训练集此处
X =索赔数量
Y =所有索赔的总支付金额，单位为千瑞典克朗
Plot of Y w.r.t. X.
以上将解决
最后，这个模型将会是
****
The plot of data along with model fitting the data.
用 Python 编写的简单机器学习模型，只有 5 行代码
在这篇博客中，我们将训练一个线性回归模型，并期望在新的输入上执行正确。
任何机器学习模型的基本思想是，它暴露于大量的输入，并且还提供适用于它们的输出。通过分析越来越多的数据，它试图找出输入和结果之间的关系。
考虑一个非常原始的例子，当你必须根据天气决定是否穿夹克时。你可以访问我们称之为的训练数据
+---------------------+---------------+
| Outside Temperature | Wear a Jacket |
+---------------------+---------------+
| 30°C | No |
| 25°C | No |
| 20°C | No |
| 15°C | Yes |
| 10°C | Yes |
+---------------------+---------------+
不知何故，你的大脑找到了输入(温度)和输出(决定穿夹克)之间的联系。
因此，如果温度是 12 摄氏度，你仍然会穿夹克，尽管你从来没有被告知这一特定温度的结果。
现在，让我们转到一个稍微好一点的代数问题，这个问题将由计算机来解决。
在我们开始之前，不要忘记安装 scikit-learn ，它提供了易于使用的功能和预定义的模型，节省了大量时间
pip install scikit-learn
样本训练集
这里，X 是输入，y 是输出。
给定训练集，您很容易猜到输出(y)是(x1 + 2x2 + 3x3)。
如何生成训练集
ML 模型-线性回归
使用线性回归模型很简单。创建一个模型，训练它，然后使用它:)
训练模型
我们已经准备好了训练集，所以创建一个线性回归模型，并将训练数据传递给它。
测试数据
X = [[10，20，30]]
结果应该是 10 + 202 + 303 = 140。让我们看看我们得到了什么…
结局:【140。]
系数:[ 1。2.3.]
你注意到刚才发生了什么吗？该模型可以访问训练数据，通过这些数据计算分配给输入的权重，以达到期望的输出。在给出测试数据时，它成功地得到了正确的答案！
如果你想更深入地研究机器学习，使用 Python 我更喜欢从这本书开始。
机器学习已经成为许多商业应用和研究项目不可或缺的一部分，但这个领域是…
shop.oreilly.com](http://shop.oreilly.com/product/0636920030515.do?sortby=publicationDate)
我也做了很多实验，修补代码。在我尝试公开 scikit 的功能的地方，可以随意使用 ML 原型。如果你觉得这篇文章有趣，别忘了鼓掌。
创建动画图形的简单方法
数据科学工具包
介绍
答在我最近的一篇文章发表后，许多人向我询问如何用 Python 制作动画图表的技巧。事实上，经常会出现静态图表已经不够用的情况，为了说明我们正在处理的问题，我们需要更强大的工具。当然，有许多库允许我们制作动画，有时甚至是交互式图形，比如 Bokeh、Pygal 或我个人最喜欢的 Plotly。然而，这一次我们将采用传统的方法——我将向您展示如何仅使用“简单的”Matplotlib 和一些命令行技巧来创建令人印象深刻的图表。在文章中，我将只放置代码中最重要的部分。但是在我的 GitHub 上，你可以找到用来创建可视化展示的完整笔记本。
Figure 1. Gradient descent visualization coming from my previous article
Matplotlib 动画 API
寻找我可以在这篇文章中使用的有趣的例子，我决定说明洛伦兹吸引子。其优雅的形式和独特的属性使其成为创造引人注目的视觉效果的绝佳材料。洛伦兹吸引子以对几乎相同的初始条件产生完全不同的结果而闻名。让我们尝试使用 Matplotlib 库中的专用动画 API 来可视化这个属性。我们将在三维空间中创建三个独立的轨迹，并呈现它们在不同时间点的行为。首先，当然，我们必须导入所有必要的依赖项。
将帮助我们执行动画的类是FuncAnimation ( 链接)。然而，为了使用它，我们首先必须准备一个基本的空图表和一个函数，该函数将在每次迭代中执行，以更新当前帧中呈现的数据。在我的例子中，创建和样式化图表的过程被提取到一个单独的辅助函数中— create_blank_chart_with_styling，您可以在完整的笔记本中查看它的细节。在其他事情中，它负责选择背景颜色，调用轴或缩放它们。创建图表后，我们还定义(目前为空)数据序列，用符号表示相应的轨迹。
我们动画的核心是图表更新功能，它将当前渲染帧的索引作为参数，并确保在图表上显示一组适当的数据。在版本中，我在每一帧中使用 Matplotlib，获取一个我们在构造函数中提供的干净的图形，并将当前选择的数据添加到其中。这意味着在每一帧中，我必须添加我想要显示的所有元素。顺便说一句，值得注意的是，该库还包含另一种模式，即在上一次迭代中获得的图中添加更多元素。
Figure 2. Lorenz Attractor created using the Matplotlib animation API
最后，我们创建一个FuncAnimation类的实例，给出参数:初始图形、更新函数、帧数以及它们应该改变的时间间隔。我们现在可以选择输出文件格式和我们的动画质量。我们工作的结果可以在图 2 中看到。
让我们阅读神经网络思想
M atplotlib 动画 API 很棒，但我经常选择将单独的帧渲染为 png 图像，然后使用 ImageMagick 将它们组合成一个移动的 gif 这是一个在 Linux、Mac 以及 Windows 上可用的非常有用的工具。我这样做是因为创建一个更新图表的函数并不总是那么明显和方便——例如，当我们想要可视化我们的神经网络的学习过程时，使用 Keras 进行训练。
Figure 3. Fages obtained in successive epochs of neural network learning process.
由于使用了keras.callbacks.LambdaCallback ( link )，我们可以在每次迭代后访问我们的模型，收集所有必要的数据并进行可视化。我们所要做的就是将我们的渲染方法作为.fit()方法的一个参数来传递。我为完成这项任务而创建的函数如下所示。
假设我们已经定义了模型的架构(参见如何做)，我们现在可以开始训练了。让我们不要忘记添加我们的回调。我们可以这样做。
结果，在每个时期，我们未来动画的一个单独的帧被创建。获得的所有图像在图 3 中并排显示。现在我们唯一要做的就是将它们相互结合，创造出流畅的动画。幸运的是，使用 ImageMagic，我们只需要一个命令。
Figure 4. Visualization showing the boundaries of classification during the neural network learning process.
结论
我希望我的提示和例子对你有所帮助，你会在工作中、在大学里或者在下一篇关于媒体的文章中用到它们。你需要的只是一点创造力和一些空闲时间。如果你喜欢这篇文章，分享出来，在 Twitter 和 Medium 上关注我，在 GitHub 和 Kaggle 上查看我正在做的其他项目。保持好奇！
成功数据治理的简单指标
最近，许多公司已经实施了数据治理框架。数据治理不应被认为是一次性的，而是一项持续的工作，以确保数据在组织的优先级中得到适当的重视。高级管理人员倾向于问这样的问题“我们到了吗？”展示数据治理的有效性。显示成功数据治理进度的一种方式是通过监控某些关键指标。让我与您分享识别任何数据治理功能成功的 4 大指标。
1)数据质量得分的提高
2)遵守数据管理标准和流程
3)风险事件的减少
4)降低数据校正成本
1)数据质量得分的提高
每一个产生/拥有数据的职能部门都应该监控其产生的数据的质量。简单地说，质量被定义为数据的完整性、准确性和及时性。这些维度中的每一个都可以有一个三维分数，也可以有一个适当加权的综合分数。关键是要确保对这些进行测量和监控，以进行改进。
2)遵守数据管理标准和流程
作为框架的一部分，几乎所有的公司都建立了某种标准/政策，需要所有员工遵守。这些文档说明了在各种情况下需要遵循的准则。例如，应该限制对生产数据的访问，但是在特殊情况下，IT 部门可以通过适当的控制程序进行修改，并获得一定的批准。必须有一个认证流程(自我认证或通过其他方式),通过该流程，每个部门都应确认遵守标准和政策。
3)风险事件的减少
每当出现数据质量问题时，都有可能导致风险事件。
事件可以是
A)监管机构因误报而施加的处罚/罚款
b)由于不良数据导致的不准确决策
c)由于错误报告导致的客户损失
一旦实施了数据治理，公司应该会看到此类风险事件的减少。如果风险事件持续发生，这表明治理功能出现故障。
4)降低数据校正成本
公司需要花费成本来纠正不良数据或增强数据以满足其需求。数据治理的核心原则是“在源头修复”，即坏数据不是由这些数据的消费者修复的，而是在它产生的源头修复的。有时这可能是在组织边界内，或者可能来自外部供应商。一个组织应该跟踪整改成本，以确保将其保持在最低水平。
一个更加成熟的数据治理功能可以确定其他成功指标，例如即将出台的法规对关键数据资产的影响等等。
如果您的组织正在评估数据治理职能的成功进展，以上 4 个简单指标应该提供一个起点。
这篇文章发表在 LinkedIn 的 https://www . LinkedIn . com/pulse/simple-metrics-successful-data-governance-suriya-n-subra manian-fcca
你可以在 https://www.linkedin.com/in/suriyansubramanian/的 LinkedIn 上关注我
应用中的简单 NLP 搜索 Scala 中的逐步指南
全文搜索很容易使用。但是自然语言固有的模糊性导致搜索结果存在误报。为了获得更准确的结果，我们需要改变方法，向搜索引擎提供更多特定领域的数据。
改善搜索结果最常见和最容易的方法是引入过滤器，即多个输入字段(文本字段、单选按钮等)。)以属性命名。这样我们就知道如何构造查询，然后返回特定的结果。结合一些近似的字符串匹配算法，我们可以获得非常精确的搜索结果。不幸的是，过滤器需要具有多个字段的表单，代价是简单的 UX。(参见图 1 )。
Figure 1
如果我们希望坚持使用单个文本字段，并且仍然有准确的搜索结果(见图 2 )会怎么样？当然，人们需要使用自然语言处理(NLP)工具。但是 IT 行业的每个人都知道 NLP 很难掌握，大多数人认为这是一种高度学术化的方法。如何轻松地利用这一点来改善特定领域的搜索结果？
Figure 2
领域
领域的特殊性是该方法的关键部分。机器学习算法还远远没有准备好回答一般的问题。即使算法存在，它们也离我们很远。为了简单起见，我们必须缩小范围。通常，当我们需要引入一个搜索表单时，我们在某个区域内操作，即在 ebay.com 找到一辆车，我们指定车的类型、生产年份、制造商、型号等…
对于本文，让我们以电影放映的领域为例，即:电影、剧院和日期时间的元组。我们也可以假设我们知道电影院的地理位置和电影的类型。我们将通过标题(或只是流派)、影院名称(或只是地点)以及放映的日期和时间来查询电影放映，这是我们需要从用户那里收集的数据。我们想要处理的示例表达式:
- 明天旧金山的火星人:查询旧金山所有明天上映火星人的影院，
- 下周 amc 的《归来者》:查询 AMC 剧场*下周《归来者》*的所有演出，
- cinemark 下周三:查询 Cinemark 影院下周三将上演的所有节目，
- 6 月 11 日旧金山的戏剧:查询旧金山所有剧院将于 6 月 11 日上演的戏剧。
所有表达式都从自然语言转换为以下形式的查询:
对自然语言处理的需求
很难从自然语言中提取信息。如果我们假设只有几种输入语句，如**【电影名称】****【剧院位置】【时间表情】**，那么就有可能为这种语句显式地编写解析器。但是，即使有人设法做到了这一点，这样的算法将是不可维护的。有了 NLP 工具，我们可以在不需要显式编程的情况下解决这个问题。
此外，一些语句在结构上极其相似，例如:【电影名称】【时间表达式】和【剧院名称】【时间表达式】——不可能明确区分这两种语句。NLP 工具还关心**【MOVIE _ NAME】和【THEATER NAME】**的结构，那么当从语句中提取信息时，它拥有比显式解析器更多的数据来做出决定。
解决方案的描述
对于我们的例子，我们需要的信息提取的唯一子任务叫做命名实体识别。正确标记了语句之后，我们就能够编写我们的查询。我们所说的标记是指为语句中的每个单词分配一些特定于领域的元信息，例如:
- 明日旧金山的火星人——(电影 _ 名字:火星人)(介词:在)(影院 _ 地点:旧金山)(时间 _ 表情:明日)
- amc 下周三——(剧场 _ 名称:amc)(时间 _ 表情:下周三)
工具
当试图解决这个问题时，我们的第一次尝试是尝试斯坦福命名实体识别器，它给了我们惊人的结果，但不幸的是，由于 GNU GPLv2 许可，它不能用于商业。
最后，我们决定使用 ScalaNLP 套件中的 Epic 库。Epic 实现了许多 NLP 算法，但是我们遇到的缺点是缺少文档，因此它的使用远非简单明了。
抽样资料
为了训练命名实体识别器(NER ),我们需要为算法提供样本数据。如果我们没有任何现实生活中的数据，那么我们可能会根据可能的模式生成一些随机语句，例如:
- [影院 _ 位置][时间 _ 表情]中的[电影 _ 名称]
- [影院 _ 位置]中的[电影 _ 流派][时间 _ 表情]
输入的格式取决于我们使用的库。描述训练数据的学术标准 CoNLL 涵盖了我们所需要的更多。幸运的是，有一种方法可以简化标记，即:
训练样本的最佳大小取决于领域的复杂性，应该根据经验进行验证。
你可以在 GitHub 查看我们如何生成样本数据的例子。
训练 NER
我们需要对标记语句之间的关系进行编码，然后构建一些一致的解释以供进一步重用。解决这个问题的统计工具被称为条件随机场(CRF)。在 ScalaNLP 中，有两种可用的 CRF 实现。第一个 epic.sequences.CRF 是普通的线性链 CRF，第二个 epic.sequences.SemiCRF 是半马尔可夫线性链的实现，它应该以较小的精度代价具有更好的性能。
将输入数据加载到序列阅读器
ScalaNLP 具有内置的用于 CoNLL 数据的解析器—epic . corpora . conllsequencereader，它接受我们在示例数据一节中提出的数据输入。
应用分段函数
我们通过将输入数据转换为*epic . sequences . segmentation【Any，String】*来训练 CRF。分段是将相同的标签组合成一行。
我们使用的分段函数:
构建 CRF
将输入分段后，我们可以构建 CRF:
使用经过训练的通用报告格式来标记序列
epic . preprocess . tokenize只是通过空格进行标记。
分段携带标记序列。当我们呈现一个样本表达式时，我们得到一个带有标记段的字符串:
【电影 _ 名称: 火星人 】【介词: 在 】【剧场 _ 地点: 三藩 】【介词: 在 】【时间 _ 表情:2016 年 6 月 11 日唯一缺少的部分是 TIME_EXPRESSION s。我们需要类型 DateTime 的从和到的显式参数。我们可以使用 PrettyTime::NLP 来解析显式的时间表达式，比如:2016 年 6 月 11 日，但是如果我们想要获得更复杂的东西，比如下周三或明天，我们应该再次使用 NLP 方法，即训练 CRF 用于时间表达式。结果相当惊人。 crf 一旦经过训练，马上就能发挥作用。解释的准确性将根据领域的复杂性和训练样本的大小而变化。在我们的案例中，我们对准确性感到惊讶——即使对于含糊不清的陈述, crf 也做得很好。****
对于 20 万条输入语句的样本量(用simple-ner-search-dataset-generator生成)，我们用 ner-trainer 对 ner 进行了训练，得到如下结果:
通过安装 ner-trainer 并通过调用ner-trainer-l film-screenings.tar.gz加载序列化的示例，您可以在互动会话中亲自检查这一点。
权衡
不幸的是，训练 CRF 非常耗时(以小时计算)。为了不浪费时间，需要序列化 SemiCRF 对象。序列化是以牺牲二进制兼容性为代价的。此外，SemiCRF 可能是一个相当重的物体，因此会增加额外内存的成本。
Epic 库不好用。文档不是很有帮助，也缺乏严肃的静态类型。即使在这个简短的例子中，我们也无法避免将作为的实例。
结论
目前可用的库很好地覆盖了问题的困难部分。权衡是可能克服的，而且其中许多相对容易解决，所以将来可能会消失。尽管如此，我们还是有可能构建非常复杂的基于自然语言处理的搜索，而不会淹没在复杂的数学中。即使是新手也应该能够在几天内实现搜索。
资源定位符
- http://www.scalanlp.org/
- 斯坦福命名实体识别器:http://nlp.stanford.edu/software/CRF-NER.shtml
- pretty time::NLP:http://www.ocpsoft.org/prettytime/nlp/
- https://github.com/evojam/ner-trainerNER 培训师
- 电影放映数据集生成器:https://github . com/Evo jam/simple-NLP-search-dataset-Generator
- 样本用于电影放映的序列化通用报告格式
你们所有人都觉得被邀请去使用 NER 训练器和数据集生成器在你们的领域进行测试和黑客攻击。请在评论中提供反馈，说明这种方法如何为您服务。
该帖子最初在 tech.evojam.com 发表。
调整深度神经网络的简单参考指南
入门指南
考虑到涉及到如此多的参数，设计深度神经网络可能是一项痛苦的任务，而且似乎没有通用公式适合所有的用例。我们可以使用 CNN 进行图像分类，使用 LSTMs 进行 NLP 相关的任务，但是仍然需要特征的数量、特征的大小、神经元的数量、隐藏层的数量、激活函数的选择、权重的初始化等。在不同的使用案例中会有所不同。
Image Dataset: with neighboring pixels being related.
这些参数的变化可归因于不同类型的数据，需要独立于其他数据集的分析。像图像数据集将具有不同的属性，因为相邻位置的像素是相关的，但是在关系数据库中，条目可以是随机的，没有关系。因此，为此需要一种不同的方法。
我们能够概括数据类型的类型和适合它们的神经网络结构，如用于图像、音频、视频的 CNN 和用于 NLP 相关任务的 RNN/lstm 等。但是，为了最大限度地发挥它们的性能，我们应该让它们变得更聪明。什么是神经网络的智能？概括而不是记忆神经网络可以被认为是智能神经网络。这种行为在任何形式的学习中都是可取的。
dim(h) < dim(xi) <- undercomplete autoencoder || overcomplete autoencoder -> dim(h) ≥ dim(xi)
为简单起见，本文只讨论自动编码器，这是一种特殊类型的前馈神经网络，它对隐藏层中的输入进行编码，并从该隐藏表示中进行解码。CNN 是自动编码器的一个例子，例如，CNN 以与自动编码器相同的方式对 MNIST 函数中的数字进行分类，其中网络试图近似从隐藏层重构输出信息的函数。每个神经网络架构都有自动编码器作为其基本块。因此，通过对它们的讨论，我们可以扩展不同深度学习架构的思想。
在本文中，我们将探索微调网络的技术，以获得更好的验证准确性，从而实现更好的预测。此外，我们还将研究这些技术背后的一些数学知识，以加深对这些技术背后的理解。
创建智能自动编码器有什么问题？
嗯，我们真正想从神经网络中得到的是从可用数据中归纳出 T1，而不是 T2 记忆 T3。记忆的问题是模型可能会过度拟合。因为深度学习模型很复杂，并且倾向于过度拟合目标函数。考虑非常基本情况，其中模型在训练数据集上被广泛训练，使得训练数据集上误差最小化并接近零。有可能神经网络没有捕捉数据的趋势，只是记住了用非常复杂的函数再现整个数据的方法。
让我们使用偏差 v/s 方差权衡的概念来更清楚地理解这一点。看看下面的图，x 轴代表模型的复杂性，而 y 轴代表误差。随着复杂度的增加，训练误差趋于减小，但方差增大，验证误差增大。
Blue: Training Error, Red: Validation Error. Initially bias will be high with model being primitive. With training error approaching zero, model will overfit resulting in high variance.
我们想要对变化更敏感的模型，以捕捉稀疏但重要的特征的微小细节。因此，欠拟合数据根本不是一个选项。因为更复杂的模型对变化更敏感。只有在深度学习的背景下进行关于过度拟合的讨论才有意义。
对于示例以过完备自动编码器为例，在这种情况下，它们可以学习简单琐碎的编码，即在整个网络中复制粘贴值。比如将输入(xi)复制到隐藏层(h)，然后再从 h 复制到输出层(x hat )。显然，错误将是最小的，但没有学习😉
It is also a type of overfitting as autoencoders captures all the variations in the mapping of weights in training data. Remember, above figure doesn’t mean that undercomplete autoencoders doesn’t have overfitting problems instead cause for them is different like in complex network architecture.
让我们建立在上述讨论的想法上，为了深度学习自动编码器的成功，必须消除过度拟合。当然，也有其他问题，如没有足够的数据，大量参数，相关特征是否被学习，何时停止训练。从这里我们可以说智能自动编码器是对我们可以观察到的信息进行归纳，并从中了解重要趋势，从而能够做出预测的编码器。让我们开始探索这些技术，目的是培养直觉，找到使用它们的理由和合适的例子，以增加我们的学习。
- 数据集扩充
- 提前停止
- l2 正则化
- 避免普通的自动编码器:噪声和稀疏
- 参数共享和捆绑
- drop 和 DropConnect 的集成方法
数据集扩充
在计算机视觉分类任务中，模型通过更多的训练数据学习得更好。但是大数据的问题是它增加了训练时间。
嗯，深度学习模型中的参数数量是巨大的(百万量级)。如果一开始就没有足够的可用数据，这显然会有所帮助。但是，如果你已经有了足够的数据会有帮助吗？是的，因为它将增加数据集中的相关特征，这有助于自动编码器学习重要的稀疏特征，而不是不相关的丰富特征。
数据扩充是一种从现有数据中创建新数据的技术，目的是增加原始数据中的相关特征。请参见下图，了解数据扩充。
Invariance: data is robustly classified at difference in translations, rotations, size, viewpoints and illumination.
以这种方式增加用于分类的最明显的特征成为最相关的特征。在 ML 管道中哪里增加我们的数据？首先是离线增强应用变换并将图像添加到数据集。但是，它会根据应用的变换数量增加大小。其次，在线增强是在输入到我们的学习模型之前应用于小批量的。在这里，看到一些张量流脚本应用于这样的转换，并假设我们不关心图像边界外的东西。
这是什么意思？假设图像的某个部分什么也没有，即它是未知空间，那么我们需要如下不同的变换。例如，一些黑色背景的旋转图像。
From the left, we have the constant, edge, reflect, symmetric and wrap transformations applied. Courtesy: Nanonets
Tensorflow 脚本基于上述对小批量数据应用简单转换的假设。
**# 1\. Flip: 'x' = A placeholder for an image.** shape = [height, width, channels]
x = tf.placeholder(dtype = tf.float32, shape = shape)
flip_2 = tf.image.flip_up_down(x)
flip_5 = tf.image.random_flip_left_right(x)**# 2.** **Rotate: 'y' = A batch of images
# To rotate in any angle. In the example below, 'angles' is in radians** shape = [batch, height, width, 3]
y = tf.placeholder(dtype = tf.float32, shape = shape)
rot_tf_180 = tf.contrib.image.rotate(y, angles=3.1415)**# 3\. Noise: 'x' = A placeholder for an image.** shape = [height, width, channels]
x = tf.placeholder(dtype = tf.float32, shape = shape)**# Adding Gaussian noise**
noise = tf.random_normal(shape=tf.shape(x), mean=0.0, stddev=0.5,
dtype=tf.float32)
output = tf.add(x, noise)
可以类似地为随机裁剪、换行、颜色通道移动等编写其他增强。
提前停止
顾名思义，这给了我们一些想法，我们可以通过在训练时尽早停止来避免过度适应。但是多早停止呢？基本上，我们的目标是在训练误差趋于零，验证误差即将爆发之前停止。
Patience Parameter P: If you are at step k and there was no improvement in validation error in the previous p teps then stop training and return the model stored at step k − p.
这些提前停止规则通过将原始训练集分成新的训练集和验证集来工作。在确定过度拟合何时开始时，验证集上的误差被用作原始训练误差的替代。有了 Keras，你可以简单地用下面的方法做到这一点。
keras.callbacks.EarlyStopping(monitor='val_loss',
min_delta=0,
patience=0,
verbose=0, mode='auto')
min_delta是是否将某个时期的损失量化为改善的阈值。如果损失差异低于min_delta，则量化为无改善。最好让它为 0，因为我们感兴趣的是损失何时变得更严重。patience自变量代表当你的损失开始增加(停止改善)时，在停止之前的周期数。mode争论取决于你监控的数量的方向(应该是减少还是增加)，因为我们监控损失，我们可以使用min。
现在，如果我说提前停止也是一种正则化技术。这个说法是真的吗？让我们看少量的数学来理解早期停止的可见工作的背后。记住，正则化是在学习神经网络中对权重&偏差添加一些约束的任何技术。
Update rule for Stochastic Gradient Descent Method. Let ‘τ’ be maximum value gradient of delta(wi). Apply inequality to above equation and we get:
Clearly, t controls how far wt can go from the initial w0. It controls the space
of exploration.
提前停止停止只允许 t 更新参数**。**维度越重要，与其相关的损失就越大，因为使用上述等式，我们控制学习速率和*t。*只有与梯度相关的损失仍然是主导因素，这实际上意味着只有损失越大的重要参数才占更多。因此，与不太重要的参数相比，重要参数的比例缩小较少，这将导致更好的精度。这类似于 L2 正则化，参见下文。
L2 正则化
正则化是在学习时分配给模型的约束。L2 正则化是权重衰减正则化，它使权重更接近原点，同时更多地缩小不太重要的要素。
让我们以直观的方式来理解真误差的概念。该误差可以用下面的给定形式表示，其中经验误差项是基于估算程序，因为我们不知道 f(x)。
where yi = f(xi) + ε, ε is small value
主要目的是将模型复杂性对真实误差的影响联系起来。显然，它将训练误差加上一些东西。那是什么东西？利用斯坦引理和一些数学知识，我们可以证明
When a small change in the observation causes a large change in the estimation(fhat(xi)). The error will be more.
这和复杂模型有关系吗？是的，上述观察结果与模型越复杂，对观察结果的变化越敏感这一事实有关。因此，我们可以说真实误差=经验训练误差+小常数+ω(模型复杂度)。这个ω是正则化的基础。因此，在正则化中，我们的目标是最小化由于模型复杂性而导致的误差，而模型复杂性又与偏差-方差权衡相关。
The intuition for adding this term is that training error doesn’t drive to zero. w influence gradient and update rules from above equations.
以上加入更新规则和 SGD 的公式是什么意思？等式上面提到的两个运算在数学上表示权重矩阵在重要性方向上的缩放，即具有主要特征值和次要特征值的权重矩阵被缩小，但是不太重要的特征被缩小得更多。该正则化操作有效地首先旋转权重矩阵，然后对角化它，然后再次旋转它。这里，在等高线图上可以看到这些操作的效果。参考这篇文章的等高线图，只看那部分。
weight vector(w∗) is getting rotated to (w̃). Geometrically it is visible that all elements are getting shrunken down but for some more shrinking is there like the one in the direction of w1. Important features gets more weight assigned.
这是 Tensorflow 脚本，用于在基于上述公式的神经网络模型中使用正则化。第一个例子是仅在一层上使用它，第二个例子是在所有层上使用它。
**# Code 1:**
# Loss function using L2 Regularization
regularizer = tf.nn.l2_loss(weights)
loss = tf.reduce_mean(loss + beta * regularizer)
# Optimizer.
optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)**# Code 2:** #Loss for all trainable variables, 0.001 is beta above
vars = tf.trainable_variables()
regularizer = tf.add_n([ tf.nn.l2_loss(v) for v in vars ]) * 0.001
# Let's say you wan't to regularize biases
regularizer = tf.add_n([ tf.nn.l2_loss(v) for v in vars
if 'bias' not in v.name ]) * 0.001# More descriptive code
regularizers = tf.nn.l2_loss(weights_1) + tf.nn.l2_loss(weights_2) + tf.nn.l2_loss(weights_3) + tf.nn.l2_loss(weights_4) + tf.nn.l2_loss(weights_5) + tf.nn.l2_loss(weights_6)loss = tf.reduce_mean(loss + beta * regularizers)
避免普通的自动编码器:噪声和稀疏
考虑如上所述的过完备普通自动编码器的情况。显然，他们容易过度适应和琐碎的学习。因此，在这些情况下，使用这些普通的自动编码器不会有太大的好处。解决这一问题的一种方法是向输入中添加噪声，这将迫使神经网络不学习琐碎的编码，而是专注于更多的概括。
A denoising encoder simply corrupts the input data using a probabilistic process (P (x(tilda)ij |xij )) before feeding it to the network. These are known as Denoising Autoencoders.
# Generate corrupted MNIST images by adding noise with normal dist # centered at 0.618 and std=0.618
noise = np.random.normal(loc=0.618, scale=0.618, size=x_train.shape)
x_train_noisy = x_train + noisenoise = np.random.normal(loc=0.618, scale=0.618, size=x_test.shape)
x_test_noisy = x_test + noise# np.clip to move out of bound values inside given interval
x_train_noisy = np.clip(x_train_noisy, 0., 1.) x_test_noisy = np.clip(x_test_noisy, 0., 1.)
Plot describes neurons firing for different features like strokes, edges for MNIST dataset digits. Clearly we can see more meaningful patterns are captured by denoising AE as compared to Vanilla AE.
随着高斯噪声的加入，这些隐藏的神经元成为边缘检测器，PCA 不能给出这些边缘检测器。此外，噪声可以应用于目标类别，这将导致具有随机分析的软目标，而不是硬目标。
稀疏自动编码器也用于解决稀疏参数的这种问题，当特征与要观察的特征相关时，这将导致神经元在罕见的情况下放电。可以写成 Lˇ(θ)= L(θ)+ω(θ)，其中 L(θ)是平方误差损失或交叉熵损失，ω(θ)是稀疏性约束，它强制触发重要特征的神经元。
**奖励:收缩型自动编码器，**正则项ω(θ)= | | j x(h)||^ 2 是编码器的雅可比矩阵。雅可比矩阵的(j，l)项捕捉到第1个神经元的输出变化，而第个个神经元的输入变化很小。L(θ) —捕捉数据中的重要变化&ω(θ)—不捕捉数据中的变化，因为雅可比使神经元对变化不敏感。通过这种权衡，我们可以只捕捉最重要的特征。对于稀疏 AE 可以进行类似的论证。
参数共享&捆绑
共享权重 简单来说就是使用相同的权重向量来进行*运算。*这样做的主要动机是限制参数的数量。
ℎ1=𝑤⋅𝑥[1:3], ℎ2=𝑤⋅𝑥[3:5], ℎ3=𝑤⋅𝑥[5:7]
我们可以通过一个直观的假设来大幅减少我们的参数，如果一个特征在一点上很重要，那么它在另一点上也很重要。**示例:**如果在特定位置检测边缘很重要。因此，由于图像的 的 平移不变结构，对于所有位置，边缘重复自身。这将导致更快的收敛。此外，我们限制了灵活性，这也可以作为避免过度拟合的正则化机制。考虑这样一种情况，我们希望并行处理两组图像，但也希望各列共享参数。
def function(x, reuse):
with tf.variable_scope(layer_name) as s:
output = tf.contrib.layers.convolution2d(inputs = x, num_outputs = 10, kernel_size = [3, 3], stride = [1, 1], padding = 'VALID', reuse = reuse, scope = s)
return output
output1 = function(image1, False)
output2 = function(image2, True)
权重绑定概念基于与上述相同的想法，具有相同的动机来减少向下参数，但应用于自动编码器单元，其中编码器权重和解码器权重被绑定和使用。它减少了自动编码器的容量，并作为一个正则化。
Tie the weights of the encoder and decoder i.e., W∗=WT
整体到辍学和 DropConnect
集成组合不同模型的输出以减少泛化误差，模型可以是不同的分类器。这里，它们是在不同的超参数、特征和训练数据的不同样本上训练的相同神经网络的不同实例。 Bagging 是一种跨整个数据集的方法，它根据训练数据的子集训练模型。因此，一些训练示例没有显示给定的模型。它允许不同的神经元跨训练数据集捕捉不同的相关特征。所有模型平均预测产生的误差？
Expect Square Error is given by: Expectation of error made by average prediction of all models.
从上面可以看出，模型之间的独立性越强，误差就越小，只有(V/k)。非常好，因为当神经网络的结构变化很大时，误差理想地变得非常小。但是，随着单个模型数量的增加，要处理的训练参数的数量会激增。这使得训练在计算上变得昂贵。
如果我们能减少这些参数不是很好吗？此外，不同的架构将帮助我们增加模型之间的差异。这两个问题通过退学**解决了。**它给出了组合许多不同网络的近似方法，并在没有任何显著开销的情况下训练几个网络。它在所有网络之间共享权重，并为每个训练实例采样不同的训练网络。只有活动参数从正向和反向传播中更新。不要聚集 2^n 稀疏网络，而是通过训练期间每个节点打开的时间来缩放其输出。
Dropout refers to dropping out units. i.e. Temporarily remove a node and all its incoming/outgoing connections resulting in a thinned network.
它应用于每个训练示例中的特征，导致某些特征对网络不可用。因为一个神经元不能完全依赖于一个输入，所以这些网络中的表示往往更加分散，网络不太可能过度适应。这种情况发生是因为丢失给隐藏单元添加了屏蔽噪声，这阻止了协同适应，本质上隐藏单元不会依靠其他单元来检测特定特征，因为那些单元可能会被丢失。这使得隐藏单元更加健壮。
**# Simple keras implementation of MNIST for dropout**import tensorflow as tf
mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512, activation=tf.nn.relu),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test)
什么是 dropconnect ？假设我们决定随机丢弃权重子集，而不是丢弃节点。其行为方式与辍学类似。从伯努利分布中提取的二进制掩码被应用于原始权重矩阵。
Courtesy: nickcdryan
不是在每次训练中随机丢弃连接，而是由于输入数据类或连接对更深层的贡献，连接会丢弃并保持丢弃。
tf.nn.dropout(W, keep_prob=p) * p
OR
tf.layers.dropout(W, rate=1-p) * p
结论
何时使用这些技术的直觉我们可以创建有效的深度神经网络，这些网络在其核心内更智能，同时具有学习任何特定任务的功能。有了这些知识，我们对创建更好的深度学习架构有了更好的理解。但是，这绝不意味着这个讨论是完整的，因为随着更好的精度更快的收敛也是一个期望的行为。让我们看看后续文章中关于衔接的内容。
感谢艾西瓦娅的改进。基线内容改编自来自 IITM 的 CS7015(DL) ，由 Mitesh M. Khapra 教授主讲的精彩课程。感谢阅读！！
简单强化学习:时间差异学习
Exploration Image: Credit to Photographer https://www.pexels.com/@valentinantonucci
所以最近我读了很多关于强化学习的书，还看了大卫·西尔弗的 强化学习简介 视频系列，顺便说一下，这些视频非常棒，我强烈推荐它们！从传统的统计学和机器学习背景来看，就研究生院和工作项目而言，这些主题对我来说有些新。因此，就我个人的学习而言，并与感兴趣的人分享我的学习，我想我会通过一个中等的帖子来存档，同时试图使这些概念尽可能简单易懂。
为什么我们要使用强化学习而不是其他监督学习方法呢？为了回答这个问题，我想出了这个适时的例子:
假设你是 NFL 的超级粉丝，你想预测即将到来的赛季的胜利数。在赛季初，你可能会看到一些变量，如:过去赛季的胜利，受伤球员的数量，天气预报，第一年首发球员的数量等。然后你拟合一个模型，预测一个 9 胜赛季。你有一个很好的团队，但一个未经证实的新四分卫(与去年相比只少了 1 场比赛)。在前 5 场比赛后，你的球队战绩为 5-0，你的新四分卫已经被誉为未来的名人堂成员。
在这个例子中，使用监督学习模型，你必须等到赛季结束后才能学习和做出任何改变。然而，通过强化学习，你可以在学习过程中获得信息，帮助你修正最初的预测。这个应用程序在任何时候都可以很好地工作，只要有一个时间或时间步长组件，您就可以不断地接收信息，并对您的目标或估计进行调整。
现在让我们看一个使用随机漫步(图 1)作为环境的例子。这是萨顿和巴尔托在《T4 强化学习:导论》一书中找到的一个例子。你可以在他们的网站上免费下载数字第二版。基本思想是，你总是从状态“D”开始，以 50%的概率随机向左或向右移动，直到到达终点或结束状态“A”或“G”。如果你在状态“A”结束，你得到的奖励是 0，但是如果你在状态“G”结束，奖励是 1。从“B”到“F”状态没有奖励。
Figure 1: Random Walk Example [1]
在这个例子中使用强化学习的目的是看看我们是否可以通过无模型方法准确预测这些状态中的每一个的值。基础真值仅仅是每个状态相对于结束于状态‘G’获得奖励的概率。因此，我在下面添加了一个表格，标明了我们要评估的每个州的标签。让我们讨论一下我们的模型，现在我们知道了我们的数据/环境和目标值，时间差异是什么。
-----------------------
| state | probability |
-----------------------
| a | 0.0 |
| b | 0.167 |
| c | 0.333 |
| d | 0.50 |
| e | 0.667 |
| f | 0.833 |
| g | 1.0 |
-----------------------
简单介绍
所以为了讨论这些算法，我将尝试用一种简单的方式来解释它们。请随意参考大卫·西尔弗讲座或萨顿和巴尔托的书，以获得更多的深度。时间差异是一个主体在事先没有环境知识的情况下通过片段从环境中学习。这意味着时间差异采用无模型或无监督的学习方法。你可以把它看作是从尝试和错误中学习。
让我们学习希腊语
你会在这篇文章中注意到一些符号，我们将讨论 3 种算法:TD(0)，TD(1)和 TD( λ )。我将展示每一个方程，我们将解释它们，但让我们快速定义至少一些超参数的符号(希腊字母有时令人生畏)。
- Gamma (γ): 贴现率。介于 0 和 1 之间的值。价值越高，折扣越少。
- **λ(λ)😗*信用分配变量。介于 0 和 1 之间的值。值越高，您可以分配给更后面的状态和操作的信用就越多。
- Alpha (α): 学习率。我们应该接受多大的误差，从而调整我们的估计。介于 0 和 1 之间的值。较高的值调整积极，接受更多的误差，而较小的值调整保守，但可能更保守地向实际值移动。
- 增量(δ): 数值的变化或差异。
所以我们开始的第一个算法是 TD(1)。在一集结束时，TD(1)以与蒙特卡罗相同的方式更新我们的值。所以回到我们的随机行走，随机向左或向右，直到在“A”或“G”着陆。一旦情节结束，则对先前的状态进行更新。正如我们上面提到的，如果λ值越高，信用就可以分配得越多，在这种情况下，λ等于 1 就是极限。这是一个重要的区别，因为 TD(1)和 MC 只在偶发环境中工作，这意味着它们需要一个“终点线”来进行更新。
现在让我们看看算法，试着理解一下。Gt(图 2)是我们这一集看到的所有奖励的贴现总和。因此，当我们在我们的环境中旅行时，我们跟踪所有的奖励，并以折扣(γ)将它们加在一起。所以让我们表现得好像我们在大声朗读这个:在给定的时间点(时间，t+1)的即时回报®加上未来回报(Rt+2)的折扣(γ)等等。你可以看到，我们在未来对γ^T-1.的折现(γ)更大因此，如果γ=0.2，你在第 6 步贴现回报，你的贴现值γ变成γ⁶–1，等于 0.00032。仅 6 个时间步长后明显变小。
Figure 2: Sum of Discounted Rewards
现在，我们将对我们的价值评估 V(S)进行更新。重要的是要知道，当你开始时，你真的没有一个好的开始估计。你用随机值或全零初始化，然后对估计值进行更新。对于我们的随机游走序列，我们将‘B’和‘F’之间所有状态的值初始化为零[0,0,0,0,0,0,1]。我们不考虑终端状态，因为它们是已知的。记住我们只是试图预测非终态的值，因为我们知道终态的值。
我们将使用我们在本集看到的上述 Gt 的折扣奖励总和，并从先前的估计中减去它。这被称为 TD 误差。我们的最新估计减去先前的估计。然后，我们乘以α项，以调整我们希望更新误差量。最后，我们只需将之前的估计值 V(St)与调整后的 TD 误差相加，即可完成更新(图 3)。
Figure 3: TD(1) Update Value toward Action Return
所以这是第一集。我们做了 1 次随机行走，积累了奖励。然后，我们在每一个时间步取这些奖励，并将其与我们最初的估计值(全部为零)进行比较。我们权衡差异并调整我们先前的估计。然后重新开始。你刚学了 TD(1)或者 MC 更新！
既然我们已经解释了 TD(1)，那么 TD(0)就更容易理解了。让我们看看图 3 的括号内，因为这是唯一的区别。我们不使用折扣奖励的累积和(Gt)我们只看即时奖励(Rt+1)，加上仅领先 (V(St+1))一步的的估计值的折扣(图 4)。
Figure 4: TD(0) Update Value toward Estimated Return
这是 TD(0)和 TD(1)更新之间的唯一区别。请注意，我们刚刚将图 3 中的 Gt 替换为提前一步的估计。
当我们使用估计来更新估计时，我们称之为自举。这种类型的技术比 TD(1)或 MC 有更高的偏差，因为你是从估计值中进行估计，而不是从观看整个剧集中进行估计。然而，这往往具有较低的方差。TD(0)的另一个好处是，它可以学习没有终端状态的环境，而 TD(1)则不能。
假设我们想要在一集结束之前进行值更新(TD(1))并且使用多于 1 步的超前(TD(0))来进行我们的估计。这就是 TD(λ)发挥作用的地方。要知道 TD(λ)有两种实现:前视和后视。前瞻视图查看前面的所有 n 步，并使用λ从本质上衰减那些未来的估计。在这篇文章中，我们将继续使用 TD(λ)的后向视图，但是已经证明前向视图和后向视图是等价的，Sutton 表明如果感兴趣的话，这里的就是。
TD(λ)的后向视图在每一步更新值。所以在每集的每一步之后，你都要更新之前的所有步骤。问题是你如何恰当地权衡或分配前面所有步骤的功劳？答案是使用一种叫做资格追踪(ET)的东西。ET 基本上记录了进入给定状态的频率和最近次数(图 4)。它将信用分配给相对于我们的最终状态频繁访问和最近访问的状态。lambda (λ)和 gamma (γ)项用于贴现这些轨迹。
Figure 4: Eligibility Traces
如果你直觉地思考这个问题，我们知道状态‘F’将会被频繁地访问，并且在最近结束于我们的最终状态‘G ’,因此将会收到许多更新。因此，ET 将根据 TD 误差(图 5，αδtEt(s))的比例向状态“F”分配更多信用。然而，相对于终止于状态‘G’而言，状态‘B’不会被频繁地访问，因此该状态的值不会被频繁地更新，并且将保持接近于其初始化时的 0。从这里开始，我们不断更新我们先前的估计。
Figure 5: Update with Respect to TD Error (δt) and Eligibility (Et(s))
所以我希望这是一种简单的学习方式。它的要点是我们做一个初始估计，探索一个空间，并根据我们的探索努力更新我们先前的估计。强化学习的困难部分似乎是在哪里应用它，环境是什么，我如何正确地设置我的奖励，等等，但至少现在你理解了状态空间的探索和用无监督的无模型方法进行估计。
1.理查德·萨顿《学习用时间差异的方法预测》机器学习，第 3 卷第 1 期，1988 年，第 9–44 页。，doi:10.1007/bf00115009。
2.西尔弗，大卫，导演。大卫·西尔弗的 RL 课程——第四讲:无模型预测。 YouTube ，YouTube，2015 年 5 月 13 日，www.youtube.com/watch?v=PnHCvfgC_ZA.
3.RL 创始人理查德·萨顿的免费下载，强化学习:简介
4.这允许你编写 LaTex 并保存为图像。可能有更好的，但这是我用的。在线乳胶编辑
原载于 2018 年 10 月 29 日【medium.com。
用 Python 中的 ML 进行简单的股票价格预测——ML 学习指南
介绍
机器学习的一个最突出的用例是“金融科技”(为那些不是时髦词汇爱好者的人准备的金融科技)；其中很大一部分在股票市场。在过去 50 年的大部分时间里，金融理论家和数据科学家被用来理解市场，以增加投资回报。然而，由于问题的多维性质、系统的规模以及随时间的内在变化，即使有传统数据分析工具的帮助，人类也难以解决这个问题。然而，随着机器学习应用中最近进步的开始，该领域已经发展到利用非确定性解决方案“学习”正在发生的事情，以便进行更准确的预测。
在本文中，我将演示一个简单的股票价格预测模型，并探索“调整”该模型如何影响结果。这篇文章旨在易于理解，因为它是一个介绍，所以更高级的读者可能需要忍受我。
第一步:选择数据
机器学习和预测建模中最重要的步骤之一是收集好的数据，执行适当的清理步骤并认识到局限性。
在这个例子中，我将使用一只股票 Zimmer Biomet(股票代码:ZBH)的股价数据。只需前往 finance.yahoo.com，搜索所需的股票。一旦你进入所需股票的主页，只需导航到“历史数据”标签，输入你想包含的日期范围，然后选择“下载数据”我选择了 5 年，但是你可以选择你想要的时间。
现在我们有了数据，让我们继续看看我们有什么。只需在 Excel 中打开文件。
看起来我们这里有些好东西。您可能会注意到所有的字段都是数值，除了那个讨厌的日期值…我们需要解决这个问题。我们要传递到模型中的值需要采用最容易理解的格式。因此，我们需要执行一些“数据预处理”步骤。在我们的例子中，我们将在 1 后面插入一个新列，命名为“日期值”，并将第 1 列中的所有日期复制到第 2 列中。然后选择所有数据，并将类型从“日期”更改为“文本”结果应该如下所示:
好了，现在把文件保存为“choose_a_name.csv”(确保是 a)。csv”而不是 excel 默认格式之一)。
在我们开始之前，让我们谈谈限制。您会注意到，我们提供给这个模型的唯一数据是日期和价格。在历史价格之外，还有许多外部因素影响价格。高度稳健的模型可能利用外部数据，如新闻、一年中的时间、社交媒体情绪、天气、竞争对手的价格、市场波动、市场指数等。这是一个非常基础的模型，但是随着时间的推移，你可以学习建立一个对整个市场更加“了解”的模型的技巧。话虽如此，我们继续吧。
第二步:选择模型
现在我们已经清理了数据，我们需要选择一个模型。在这种情况下，我们将使用神经网络来执行回归函数。回归将在一个连续的尺度上产生一个数值，与可用于分类工作的模型相反，这将产生一个分类输出。在这种情况下，我们试图预测股票在任何一天的价格(如果你试图赚钱，这一天还没有发生)。
为了建立我们的模型，我们将使用 TensorFlow…嗯，一个叫做 TFANN 的简化模块，代表“TensorFlow 人工神经网络”为了做到这一点，我们将使用 Google Colab。如果你不熟悉 Colab，只需导航到 colab.research.google.com，这是一个免费的虚拟 python 笔记本环境。(对于那些将要跟进但不知道自己在做什么的人，只需将下面的代码复制粘贴到一个“单元格”中，然后在创建新的单元格并复制更多代码之前点击 run)。
步骤 3:构建模型
首先我们需要安装 TFANN。打开一个新的 Colab 笔记本(python 3)。Colab 有许多无需安装即可访问的库；但是，TFANN 不在其中，因此我们需要执行以下命令:
!pip install TFANN
现在让我们导入我们的依赖项:
import numpy as np
import matplotlib.pyplot as mpl
from sklearn.preprocessing import scale
from TFANN import ANNR
from google.colab import files
NumPy 将用于我们的矩阵运算，Matplotlib 用于图形，sykit-learn 用于数据处理，TFANN 用于 ML goodness，google.colab 文件将帮助我们将数据从本地机器上传到虚拟环境。
现在我们需要导入已经处理过的数据。为此，我们将执行以下命令，这将为我们提供一个窗口来上传。csv 文件。
files.upload()
很简单，对吧？
您现在有一个包含该文件的虚拟文件夹。如果你不相信我，执行下面的命令，它将打印当前目录下的文件名。
!ls
现在我们终于可以进入这个项目的核心部分了。执行以下命令:
#reads data from the file and ceates a matrix with only the dates and the prices
stock_data = np.loadtxt('ZBH_5y.csv', delimiter=",", skiprows=1, usecols=(1, 4))
#scales the data to smaller values
stock_data=scale(stock_data)
#gets the price and dates from the matrix
prices = stock_data[:, 1].reshape(-1, 1)
dates = stock_data[:, 0].reshape(-1, 1)
#creates a plot of the data and then displays it
mpl.plot(dates[:, 0], prices[:, 0])
mpl.show()
您应该会得到一个漂亮的图形，如下所示:
请注意，y 轴上的刻度不再是美元，x 轴上的刻度不再是任意的整数日期值。我们缩小了数据规模，以使学习过程更加有效。尝试编写一些代码，将 y 轴的刻度返回到美元，将 x 轴的刻度返回到年！
现在，我们需要构建模型。在这种情况下，我们将使用一个输入和输出神经元(输入日期，输出价格),并将有三个隐藏层，每层 25 个神经元。每一层都有一个“tanh”激活功能。如果你不理解这些概念，请随时谷歌一下，然后回来，理解神经网络原理的基础知识将对你的进步非常有帮助。
#Number of neurons in the input, output, and hidden layers
input = 1
output = 1
hidden = 50
#array of layers, 3 hidden and 1 output, along with the tanh activation function
layers = [('F', hidden), ('AF', 'tanh'), ('F', hidden), ('AF', 'tanh'), ('F', hidden), ('AF', 'tanh'), ('F', output)]
#construct the model and dictate params
mlpr = ANNR([input], layers, batchSize = 256, maxIter = 20000, tol = 0.2, reg = 1e-4, verbose = True)
我们现在已经初始化了模型，并准备好训练！
步骤 4:训练模型
#number of days for the hold-out period used to access progress
holdDays = 5
totalDays = len(dates)
#fit the model to the data "Learning"
mlpr.fit(dates[0:(totalDays-holdDays)], prices[0:(totalDays-holdDays)])
一旦训练完成，我们可以执行以下命令来看看我们做得如何。
#Predict the stock price using the model
pricePredict = mlpr.predict(dates)
#Display the predicted reuslts agains the actual data
mpl.plot(dates, prices)
mpl.plot(dates, pricePredict, c='#5aa9ab')
mpl.show()
不算太差！但是我们可以做得更好。
让我们考虑一些可以增加模型逼真度的方法。我们可以把这个想成“我们可以转动什么旋钮”来调整我们的模型。首先是简单地降低误差容限。
第一次试验，误差容限设定为. 2；然而，我们可以把它降低到一个更小的数字，比如说 0.1，让我们试一试！
只需进行以下更改。请注意，我还更新了变量的名称，以便我们已经创建/观察的值不会改变。当然这不是最有效的方法，但我相信你可以创造一个更好的方法！
#Number of neurons in the input, output, and hidden layers
input2 = 1
output2 = 1
hidden2 = 50
#array of layers, 3 hidden and 1 output, along with the tanh activation function
layers = [('F', hidden2), ('AF', 'tanh'), ('F', hidden2), ('AF', 'tanh'), ('F', hidden2), ('AF', 'tanh'), ('F', output2)]
#construct the model and dictate params
mlpr2 = ANNR([input2], layers, batchSize = 256, maxIter = 10000, tol = 0.1, reg = 1e-4, verbose = True)
使用以下命令再次运行该模型，我们会得到新的结果:
holdDays = 5
totalDays = len(dates)
mlpr2.fit(dates[0:(totalDays-holdDays)], prices[0:(totalDays-holdDays)])
一旦它完成训练:
pricePredict2 = mlpr2.predict(dates)
mpl.plot(dates, prices)
mpl.plot(dates, pricePredict, c='#5aa9ab')
mpl.plot(dates, pricePredict2, c='#8B008B')
mpl.show()
更好看！如你所见，喜欢容错…嗯…降低了误差。所以你可能想知道“为什么不把误差设置成一个非常小的数字呢？”这将是一个很好的问题。继续自己尝试，重新执行刚才运行的代码，将公差设置为 0.05。您将观察到的是，您使用的最大迭代次数将在执行达到所需的错误级别之前停止执行。那么，为什么不增加最大迭代次数呢？嗯，问题出在给定的模型参数上。模型本身有局限性，我们构建的模型的最低可实现误差可能只有 0.8(我还没有为这个模型检查过这一点)。在这种情况下，添加多少次迭代都没有关系，无论运行多少次迭代，模型的结构都不会产生更好的结果。它只是被封顶了。
这里要问的下一个逻辑问题是“我们如何改变模型以达到更大的误差？”这就是我们将要探索的！
模型有所谓的“超参数”这些是管理模型的参数，它们定义了如何创建模型。改变这些可以给我们更好(或者更差)的结果。示例包括:每个隐藏层中的神经元数量、隐藏层的数量、激活函数等。
我们的目标是“调整”这些超参数，以实现比我们的第一个模型更低的误差容限。在我看来，最简单的方法就是增加隐藏层中神经元的数量。我绝不是这个主题的主要知识来源，但我敢说，增加神经元的数量和/或隐藏层的数量可以提高模型表示给定数据的抽象级别。所以让我们试试吧！
将每个隐藏层中的神经元数量从 50 增加到 100，并将容差设置为 0.075:
好多好多！橙色线是最新的预测。请注意，它比上一个模型更好地跟踪了最近的价格。
我认为我们创造了一个很好的模式，我对结果很满意！但是这个项目可以继续学习更多关于超参数的知识。尝试改变激活功能，除了“tanh”，或者增加一个额外的层。
要添加另一层，请参考这行代码:
layers = [('F', hidden), ('AF', 'tanh'), ('F', hidden), ('AF', 'tanh'), ('F', hidden), ('AF', 'tanh'), ('F', output)]
通过在输出节点前添加另一个层(“AF”，隐藏)、(“AF”，“tanh”)来添加一个附加层。这将在层被馈送到下一层之前添加该层和应用于该层的激活函数。
layers = [('F', hidden), ('AF', 'tanh'), ('F', hidden), ('AF', 'tanh'), ('F', hidden), ('AF', 'tanh'),('F', hidden), ('AF', 'tanh'), ('F', output)]
或者，也许你想在每一个隐藏层有不同数量的神经元，减少它们是一种常见的方法。以下示例在输出之前从 100 个节点逐渐减少到 25 个节点:
layers = [('F', 100), ('AF', 'tanh'), ('F', 50), ('AF', 'tanh'), ('F', 25), ('AF', 'tanh'), ('F', output)]
所以，你有它！一个关于机器学习和神经网络的简单介绍，你可以在家里用大约一个小时免费完成！
我要感谢 Nicholas T. Smith，他的模型影响了这篇文章的创作。
最后，如果您有任何问题、意见、建议或顾虑，请随时联系我们！
用 R 中的例子简单解释了逻辑回归
我假设读者熟悉线性回归模型及其功能。在这里，我试图用尽可能简单的解释来解释逻辑回归。当我自己试图理解逻辑回归时，我没有得到任何全面的答案，但是在对这个话题做了彻底的研究后，我想到了这篇文章。请注意，这更多的是一篇介绍性文章，要深入这个主题，您必须了解数据分析及其实现的许多不同方面。
话虽如此，我们还是开始吧。我们知道，线性模型假设响应变量是正态分布的。我们有形式为 *Yi = β0 + β1X+ εi，*的方程，其中我们预测 X 的某个值的 Y 值。我们知道这是线性的，因为对于 X 的每个单位变化，它将在一定程度上影响 Y 值 *β1。此外，*误差项 εi 是假设正态分布，如果误差项添加到 Y 的每个输出，则 Y 也正态分布，这意味着对于 X 的每个值，我们得到 Y，并且 Y 对该正态分布有贡献。现在，当 Y 的值可以是-∞到+ ∞时，这都是好的，但是如果值需要为真或假，0 或 1，是或否，那么我们的变量不遵循正态分布模式。我们所有的是 0 和 1 的计数，它只对发现概率有用，例如，如果你有五个 0 和十五个 1，那么得到 0 的概率是 0.25，得到 1 的概率是 0.75。但是我们如何用这个概率来做一个平滑的分布，拟合一条线(非线性的)尽可能接近你所拥有的所有的点，假设那些点不是 0 就是 1。
要做到这一点，你必须想象概率只能在 0 和 1 之间，当你试图用一条线来拟合这些点时，它不可能是一条直线，而是一条 S 形曲线。
Linear vs Logistic
如果你有更多的 1，那么 S 将向上倾斜，如果你有更多的 0，那么它将向下倾斜。请注意，Y 轴上的数字 0 表示总计数的一半在左边，总计数的一半在右边，但情况并不总是如此。
现在问题来了，我们如何将 1 和 0 的二进制信息映射到使用连续变量的回归模型？我们做这种映射的原因是因为我们希望我们的模型能够发现预期结果为真的概率。下面我将描述我们是如何进行映射的。请记住，逻辑回归的主要前提仍然是基于一个典型的回归模型，有一些方法上的变化。
现在，要找到预期结果的概率，我们必须始终遵循两件事。
1-概率不能为负，所以我们在我们的正态回归模型中引入一个称为指数的项，使其成为逻辑回归。
2-由于概率永远不会大于 1，我们需要将结果除以比它本身更大的数。
基于这两点，我们的逻辑回归公式展开如下:
1.回归公式使用公式 Yi = β0 + β1X+ εi. 给出 Y
2.我们必须使用指数，这样它就不会变成负数，因此我们得到 P = exp( β0 + β1X+ εi )。
3.我们将 P 除以比它本身大的数，使它保持小于 1，因此我们得到 P = e(β0+β1X+εI)**/**e(β0+β1X+εI)+1。
4.经过一些计算后，第三步中的公式可以改写为 log(p**/**(1-p))=β0+β1X+εI .
5.log(p / (1-p))称为概率的赔率。如果你仔细观察，它是预期结果为真的概率除以预期结果不为真的概率，这叫做 logit 函数。
工作:
当您计算 1 和 0 的总数时，您可以很容易地计算 log(p / (1-p))的值，我们知道该值等于*β0+β1X+εI。*现在您可以将该值放入公式 P = e(β0+β1X+εI)**/**e(β0+β1X+εI)+1 和
从另一个角度来看，假设您已经有了截距和斜率的回归公式，您只需要输入 X 的值来预测 y。但您知道在逻辑回归中它不是这样工作的，这就是为什么您将 X 值放在这个公式 P = e(β0+β1X+εI)**/**e(β0+β1X+εI)+1 中，并将结果映射到 X-上如果该值高于 0.5，则您知道它接近于期望的结果(即 1)，如果该值低于 0.5，则您知道它接近于不期望的结果(即 0)。
稍微涉及一下指数的功能
假设你在某个地方投资了一美元。现在，一年内它将增长其先前价值的 50%，所以在 2018 年，如果它是 1 美元，那么在 2019 年它将变成 1.5 美元，在 2020 年它将变成 2.25 美元。为什么是 2.25？因为 1 美元产生了 0.5 美元，这 0.5 美元开始赚取自己的利息，也就是 0.25 美元，随着时间的推移，每个新芽不断赚取自己的利息，这就是为什么我们有上面显示的 S 形曲线。
R 中的示例
需要记住的事情，
1-线性回归方法试图最小化残差，这意味着最小化((MX+c)-y)的值。而逻辑回归模型则试图在考虑了手头的所有变量后，尽可能准确地预测结果。
2-它计算数据集中每个点的概率，该点可以是 0 或 1，并将其提供给 logit 函数。
3-使用逻辑回归后得到的系数告诉我们特定变量对对数概率的贡献有多大。
数据来源于加州大学洛杉矶分校，它有 4 个变量，称为录取，GRE 分数，GPA 和他们的本科学校排名。我们的目标是建立一个模型，以便在给定学生简介的情况下，预测该学生被录取的概率。
df <- read.csv(“https://stats.idre.ucla.edu/stat/data/binary.csv")
str(df)
## ‘data.frame’: 400 obs. of 4 variables:
## $ admit: int 0 1 1 1 0 1 1 0 1 0 …
## $ gre : int 380 660 800 640 520 760 560 400 540 700 …
## $ gpa : num 3.61 3.67 4 3.19 2.93 3 2.98 3.08 3.39 3.92 …
## $ rank : int 3 3 1 4 4 2 1 2 3 2 …
我们看到变量不是整数就是数字。
sum(is.na(df))## [1] 0
没有空值
summary(df)## admit gre gpa rank
## Min. :0.0000 Min. :220.0 Min. :2.260 Min. :1.000
## 1st Qu.:0.0000 1st Qu.:520.0 1st Qu.:3.130 1st Qu.:2.000
## Median :0.0000 Median :580.0 Median :3.395 Median :2.000
## Mean :0.3175 Mean :587.7 Mean :3.390 Mean :2.485
## 3rd Qu.:1.0000 3rd Qu.:660.0 3rd Qu.:3.670 3rd Qu.:3.000
## Max. :1.0000 Max. :800.0 Max. :4.000 Max. :4.000
我们可以注意到，由于变量 admit 的平均值小于“0.5”，所以拒绝的数量大于接受的数量。
xtabs(~ admit +rank ,data=df) ## rank
## admit 1 2 3 4
## 0 28 97 93 55
## 1 33 54 28 12
我们这样做是为了检查录取是否在每个等级类别中分布得足够好。如果假设一个等级只有 5 个接纳或拒绝信息，那么就没有必要在分析中包括该等级。
现在，我们运行我们的 logit 函数，但在此之前，我们还必须将秩变量从整数转换为因子。
df$rank <- as.factor(df$rank)
logit <- glm(admit ~ gre+gpa+rank,data=df,family="binomial")
summary(logit)##
## Call:
## glm(formula = admit ~ gre + gpa + rank, family = "binomial",
## data = df)
##
## Deviance Residuals:
## Min 1Q Median 3Q Max
## -1.6268 -0.8662 -0.6388 1.1490 2.0790
##
## Coefficients:
## Estimate Std. Error z value Pr(>|z|)
## (Intercept) -3.989979 1.139951 -3.500 0.000465 ***
## gre 0.002264 0.001094 2.070 0.038465 *
## gpa 0.804038 0.331819 2.423 0.015388 *
## rank2 -0.675443 0.316490 -2.134 0.032829 *
## rank3 -1.340204 0.345306 -3.881 0.000104 ***
## rank4 -1.551464 0.417832 -3.713 0.000205 ***
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## (Dispersion parameter for binomial family taken to be 1)
##
## Null deviance: 499.98 on 399 degrees of freedom
## Residual deviance: 458.52 on 394 degrees of freedom
## AIC: 470.52
##
## Number of Fisher Scoring iterations: 4
简要解释
gre 中每一个单位的变化都会使被录取的对数几率增加 0.002，其 p 值表明它在决定录取方面有一定的意义。
2-平均绩点每增加一个单位，录取几率的对数就增加 0.80，p 值表明它在决定录取方面有一定的意义。
3-排名的解释与其他人不同，从排名第一的大学去排名第二的大学会将被录取的几率降低-0.67。从等级 2 到等级 3 将减少-1.340。
零偏差和剩余偏差之间的差异告诉我们，该模型是一个很好的拟合。差异越大，模型越好。零偏差是当方程中只有截距而没有变量时的值，剩余偏差是当考虑所有变量时的值。如果差异足够大，那么认为模型是好的是有道理的。
预言；预测；预告
假设一个学生的 GRE 成绩为 790 分，GPA 为 3.8，他就读于一所排名第一的大学。现在你想预测那个男孩将来被录取的机会。
x <- data.frame(gre=790,gpa=3.8,rank=as.factor(1))
p<- predict(logit,x)
p## 1
## 0.85426
我们看到这个人有 85%的机会被录取。
参考文献
匿名。“Logit 回归| R 数据分析示例”。数字研究与教育研究院。【https://stats.idre.ucla.edu/r/dae/logit-regression/
匿名。“逻辑回归解释了”。学习营销。http://www . learn by marketing . com/methods/logistic-regression-explained/
计数模型:理解对数链接功能。theanalysisfactor.com。https://www . the analysis factor . com/count-models-understanding-the-log-link-function/
匿名。《指数函数直观指南& e》。BETTEREXPLAINED.COM。https://better explained . com/articles/an-intuitive-guide-to-index-functions-e/
匿名。“视频 7:逻辑回归——简介”。数据挖掘。https://www.youtube.com/watch?v=gNhogKJ_q7U
Aggarwal，a .逻辑回归。简体”。IITR 数据科学集团。https://medium . com/data-science-group-iitr/logistic-regression-simplified-9 B4 EFE 801389
匿名*。* YES NO GAME(青年组比赛)。年轻的天主教徒。https://young-天主教徒网/2017/12/30/yes-no-game-youth-group-game/
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
