人工智能和机器学习对交易和投资的影响
Source: Wikipedia
以下是我几个月前在欧洲做的一次演讲的节选，当时我是一名受邀演讲者，面对的是一群低调但高净值的投资者和交易者。主题被主办方确定为关于人工智能和机器学习对交易和投资的影响。以下节选分为四个部分，涵盖了原演示文稿的 50%左右。
1。人工智能和机器学习对交易的一般影响
人工智能(AI)允许用机器代替人类。在 20 世纪 80 年代，人工智能研究主要集中在专家系统和模糊逻辑上。随着计算能力变得越来越便宜，使用机器解决大规模优化问题在经济上变得可行。由于硬件和软件的进步，如今人工智能专注于使用神经网络和其他学习方法来识别和分析预测器，也称为特征或因素，这些预测器具有经济价值，可以与分类器一起使用，以开发有利可图的模型。人工智能的这种特殊应用通常被称为机器学习(ML)。
基于人工智能开发交易策略的方法在短期和长期投资中的应用越来越受欢迎，有一些对冲基金在这一领域非常活跃。然而，由于各种因素，这种新技术的广泛接受是缓慢的，最重要的是人工智能需要对新工具和人才的投资。大多数基金使用基本面分析，因为这是经理们在 MBA 课程中学到的东西。单纯依靠 AI 的对冲基金并不多。人工智能在零售层面的应用越来越多，但大多数交易者仍然使用二十世纪中期提出的方法，包括传统的技术分析，因为它们容易学习和应用。
请注意，人工智能和 ML 不仅用于开发交易策略，还用于其他领域，例如开发流动性搜索算法和向客户建议投资组合。因此，随着人工智能应用的普及，参与交易和投资决策的人数减少了，这显然会影响市场和价格行为。现在推测这种新技术对行业的整体影响还为时过早，但人工智能的广泛使用可能会导致更有效的市场，在更长的时间内波动性更低，随后由于制度变化而偶尔出现波动性峰值。这是可能的，因为人类对信息的主观评估的影响将被最小化，并且相关的噪声也将被最小化。但这还有待实践检验。
2。人工智能和机器学习对阿尔法一代的影响
在这些采用人工智能技术的初始阶段，对于那些了解它并知道如何管理其风险的人来说，将会有机会。基于人工智能的交易策略的一个问题是，它们可能产生比随机模型更差的模型。我将试着解释我的意思:传统的技术分析是一种无利可图的交易方法，因为基于图表模式和指标的策略在任何交易成本之前从零均值分布中获得回报。有些交易者总是出现在分布的右尾，这给人一种错误的印象，认为这些方法有经济价值。我的研究表明，特别是在期货和外汇市场，无论使用哪种方法都很难实现长期盈利，因为这些市场旨在让做市商受益。然而，在较短的时间内，由于运气好，一些交易者可以在杠杆市场上获得高额利润。然后，这些交易者把他们的成功归因于他们的策略和技巧，而不是运气。
对于 AI 和 ML，还有额外的影响，如偏差-方差权衡。数据挖掘偏差可能导致策略过度适应过去的数据，但对新数据立即失效，或者策略过于简单，没有捕捉到数据中具有经济价值的重要信号。这种权衡的结果是比随机策略更差的策略，甚至在交易成本增加之前，这些交易者的回报分布也是负的。在后量化宽松时代，这为大型基金和投资者带来了获利机会。然而，随着比随机更差的人工智能交易者被从市场上清除，只有那些拥有稳健模型的交易者留下来，利润之战将变得激烈。现在猜测人工智能交易员或大型投资者是否会赢得这场战斗还为时过早。
我还想提一下这方面一个常见的误解:有些人认为值在使用的 ML 算法中。这不是真的。真正的价值在于所使用的预测因素，也称为特征或因素。最大似然算法无法在没有金子的地方找到金子。一个问题是，大多数 ML 专业人员使用相同的预测器，并试图以迭代的方式开发模型，这将产生最佳结果。这一过程受到数据挖掘偏见的困扰，并最终失败。简而言之，数据挖掘偏差是由对许多模型多次使用数据的危险做法造成的，直到结果在训练和测试样本中可以接受。我在这一领域的研究表明，如果一个简单的分类器，如二元逻辑回归，不能令人满意地与一组给定的预测因子一起工作，那么它很可能没有经济价值。因此，成功取决于所谓的功能工程，这既是一门科学，也是一门艺术，需要知识、经验和想象力来提出具有经济价值的功能，只有一小部分专业人士可以做到这一点。
3。人工智能和机器学习对技术分析的影响
我们必须区分传统技术分析和定量技术分析，因为所有依赖于价格和交易量序列分析的方法都属于这一范畴。传统的技术分析，即图表模式、一些简单的指标、某些价格行为理论等。，一开始就没有效果。除了一些范围和深度有限的不完整的努力，吹捧这些方法的出版物从未提出他们的长期统计预期，而只是承诺如果使用这种或那种规则，将有利润潜力。由于市场的利润和亏损遵循某种统计分布，总有人把他们的运气归功于这些方法。与此同时，整个行业围绕这些方法发展起来，因为这些方法简单易学。不幸的是，许多人认为他们可以通过更好地使用其他人都知道的方法来获利，结果是大量财富从这些天真的交易员转移到做市商和其他消息灵通的专业人士手中。
在 20 世纪 90 年代早期，一些市场专业人士意识到大量的散户在用这些幼稚的方法交易。一些人开发了算法和人工智能专家系统，以提前识别地层，然后根据它们进行交易，这导致了散户交易者(也称为弱手)无法应对的过程波动。从更根本的角度来说，传统技术分析的失败可以归因于从 20 世纪 90 年代开始的市场中高序列相关性的消失。基本上是高度的序列相关性提供了这些方法有效的错误印象。如今，除了少数例外，市场正在回归均值，没有给简单的技术分析方法留下空间。然而，一些定量的技术分析方法往往效果很好，如均值回复和统计套利模型，包括使用具有经济价值的特征的 ML 算法。
请注意，这种类型的套利不太可能在人工智能和 ML 的案例中重复，因为模型的种类繁多，而且大多数模型都是专有的，但这种新技术的主要问题不是确认偏差，就像传统技术分析的情况一样，而是数据挖掘偏差。
在我看来，观察市场，看图表，正在成为一个过时的过程。交易的未来是关于实时处理信息、开发和验证模型。未来的对冲基金将不再依赖图表分析。有些人仍然这样做，因为他们正处于新旧时代的交接点。许多不熟悉人工智能的交易者将发现未来很难竞争，并将退出。
4。新交易技术的赢家和输家
人工智能的应用将在许多方面改变交易，这已经在发生。投资者可能很快就会发现，在 QE 引发的当前趋势结束后，中期回报将远低于预期。如果这种情况成为现实，那么投资者将不得不回到老路上，寻找一位优秀的财务顾问，他可以建议投资组合，并挑选会升值的证券。在某些情况下，顾问将是一个人工智能程序，这个过程将在线执行。
交易者需要熟悉这项新技术。大多数交易者仍在旧方法中挣扎，只是希望“买入下跌”会奏效，并为未来几年提供利润。
其中一个问题是在过去的八年里，中央银行在金融市场的直接支持下培育的道德风险。许多交易员和投资者现在认为，熊市是不可能的，因为央行将把他们的损失重新分配给其他所有人，尽管他们可以保留自己的利润。因此，大多数市场参与者对下一次重大的市场机制变化毫无准备，可能会面临毁灭性的损失。
网上有关于 ML、AI 和交易的优秀资源。最好的学习方法是试图解决一些实际问题。但我认为，对大多数交易者来说，这种转变是不可能的。理解和应用人工智能所需的技能组合排除了 95%习惯于在图表上画线和观察均线的交易者。
投资者应该自己做研究，并咨询熟悉这些新发展的有能力的财务顾问。每个投资者都有不同的风险规避特征，很难提供通用的指导方针。机器人顾问很快就会激增，选择一个适合特定需求和目标的机器人顾问可能会成为一项具有挑战性的任务。
任何不熟悉 ML 和 AI 以及它们与交易和投资的关系的人可能会发现，向熟悉这一领域的专业人士咨询比开始阅读书籍和文章更有利可图，阅读书籍和文章可以在理解基础知识后进行。我希望我已经在这次演讲中提供了一个大概的想法，可以作为这个有趣且可能有回报的努力的起点。
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
如有任何问题或意见，欢迎在推特上联系: @mikeharrisNY
关于作者:迈克尔·哈里斯是一名交易者和畅销书作家。他也是 17 年前第一个识别价格行为无参数模式的商业软件的开发者。在过去的七年里，他一直致力于开发 DLPAL，这是一个软件程序，可以用来识别市场数据中的短期异常，与固定模型和机器学习模型一起使用。点击此处了解更多信息。
社交媒体对票房的影响:最佳影片提名的 twitter 活动分析| 2018 年奥斯卡与 Python
photo credit: 889noticias.mx
你认为观众在 twitter 等社交媒体渠道上的帖子和评论能左右公众舆论，增加或减少电影的票房吗？
这是我们要做的，为我们的问题找到可能的答案:我们将收集关于 2018 年奥斯卡最佳影片提名的推文；我们在每部电影上映前 4 周开始收集推文，在电影结束后 1 周停止收集。 接下来我们分析推特活动(主角演员推特账号、推文数量、推文情绪、电影评分和评论)并探索推特活动和票房销售之间可能的关系。
从技术角度来看，我们将使用数据科学和数据可视化技术和工具来解决这个问题。我们广泛使用 python 来实现这个项目。为了收集推文，我们有两个选择:1-使用 twitter API(像 tweepy )。2-使用 web 抓取技术来手动解析推文。在这种情况下，我决定使用网络抓取来收集推文，因为 tweepy API 非常慢，而且有一些限制。对于抓取任务，我决定使用 python 中的 beautiful Soup 编写一个 web scraper，但随后我做了一个随机搜索，以检查是否有人已经这样做了。我发现了 Twitter 搜索的一个很好的 python 实现，它让我的生活变得更加轻松。然后我修改了它的代码，这样推文就可以保存到 sql 数据库中。
下一步是评估推文的情绪。简单解释一下，谷歌对情感分析的定义是:“通过计算识别和分类一段文本中表达的观点的过程，特别是为了确定作者对特定主题、产品等的态度。，是积极的，消极的，还是中性的。”对于这个任务，我们将使用 python 中的Vader perspection包。Vader perspective 是一个专门针对社交媒体上表达的情绪的工具。对于每条推文，该工具将给出一个介于[-1，+1]之间的数值分数。完全负面情绪为-1，完全正面情绪为+1，0 代表中性情绪。
在收集推文并计算情绪后，我们使用 python 中的 pandas 和 matplotlib 来可视化每周情绪变化和推文数量与票房之间的关系。以下是工作流程的整体架构:
Overall Workflow
值得一提的是，门票销售数据是从 boxofficemojo 收集的。评分是从 metacritic.com 的挑选出来的。现在我们来看看每部电影的总销量和推文总数:
%matplotlib inline
import pandas as pd
import matplotlib.pyplot as plt# this csv contains the records for total sales and total tweets
total_sales = pd.read_csv('totally.csv')fig, ax1 = plt.subplots()#plotting the bar plot to show the distribution of sales
ax1.bar(total_sales.index, total_sales['total_sales'], width = 0.6)
ax1.set_title('Total Sales', fontsize = 14)
ax1.tick_params('y', colors='b')
ax1.set_xticks(ticks=total_sales.index-0.8)
ax1.set_xticklabels((total_sales['movie']), rotation = 45)
plt.show()
total sales
total number of tweets for each movie
我们可以立即看到两部电影在总销售图中脱颖而出(《敦刻尔克》和《滚出去》)。这是该类别中唯一票房超过 1 亿美元的电影。我让你们评论一下为什么这两部电影有更高的票房，稍后，我们会看到这两部电影的周销售图也不同于这一类别的其他电影。
谈到推文的总数，我们可以看到几乎所有人在大约 5 个月的时间里平均有 3000 到 4000 条推文。
分析(为本文开头的问题找到可能的答案)
- 让我们从这个问题开始分析:twitter 上主要角色演员的追随者和门票销售之间的关系是什么？
嗯，我觉得答案是没有很强的关系。这些票房巨大的电影中的一些主要角色演员甚至没有 twitter 账户，或者即使他们有，也没有那么多粉丝。
- 接下来，每周的推文数量与门票销售相比如何？
我们首先从 sqlite 数据库中读取数据，其中包含推文的日期、推文本身和情感评分，并将其保存到熊猫数据帧中。然后，我们将数据重新采样到每周粒度。接下来，我们使用 matplotlib 展示推文数量相对于销售额的变化。
import pandas as pd
import sqlite3
import matplotlib.pyplot as pltconn3 = sqlite3.connect('twitterDunkirk.db')
c3 = conn.cursor()
dunkirk = pd.read_sql('select * from sentiment', conn3)dunkirk.tail()
# this file contains all the weekly sales info
weekly_track = pd.read_csv('weeklysales.csv')# we convert the date from string to date format
dunkirk['date'] = pd.to_datetime(dunkirk['date'])
dunkirk.sort_values('date', inplace = True)
dunkirk.set_index('date', inplace=True)# resample the data to weekly granularity
weekly_tweets = dunkirk.resample('w').size()
weekly_sentiment = dunkirk.sentiment.resample('w').mean()# print(weekly_sentiment)
weekly_sales = weekly_track['dunkirk']adjusted = []
for item in weekly_sales:
adjusted.append(int(item))
if len(adjusted) == len(weekly_tweets):
break# print(len(weekly_sales), len(weekly_sentiment), len(weekly_tweets))# this is the new weekly dataframe
weekly = pd.DataFrame({'dates': weekly_tweets.index,'tweet_count': weekly_tweets.values,
'sentiment': weekly_sentiment.values, 'sales': adjusted})# print(weekly.head())
fig, ax1 = plt.subplots()
ax1.bar(weekly.index, weekly['sales'])
ax1.set_title("Dunkirk (Release Date: July 21, 2017)", fontsize = 16)
ax1.set_xlabel('Weeks')
ax1.set_ylabel('Weekly Sales', color='b')
ax1.tick_params('y', colors='b')
ax1.set_xticks(ticks=weekly.index-0.6)
ax1.set_xticklabels(labels=( "4 Weeks Out", "3 Weeks Out", "2 Weeks Out", "1 Week Out", " Release Week",
"1 Week After", "2 Weeks After","3 Weeks After","4 Weeks After","5 Weeks After","6 Weeks After","7 Weeks After",
"8 Weeks After","9 Weeks After","10 Weeks After","11 Weeks After","12 Weeks After","13 Weeks After","14 Weeks After",
"15 Weeks After","16 Weeks After","17 Weeks After","18 Weeks After","19 Weeks After","20 Weeks After","21 Weeks After",
"22 Weeks After","23 Weeks After","24 Weeks After","25 Weeks After","26 Weeks After","27 Weeks After",
"28 Weeks After", "29 Weeks After"), rotation=45, size="medium" )
ax2 = ax1.twinx()
ax2.plot(weekly.index, weekly['tweet_count'],'k-')
ax2.set_ylabel('Weekly Tweets', color='k')
plt.show()
我们可以看到，门票销售不受推文数量的影响。然而，我们可以在图表中看到一些模式。我把这个留给读者进一步讨论。
- 接下来，我们来评估推文的情绪之间的关系，看看它对门票销售是否有影响。我们遵循与之前相同的过程，只是在绘制图表时将“tweet_count”更改为“perspective”。
同样，我们可以看到门票销售总体上不受推文情绪的影响。然而，我们可以在所有的图中看到一些模式，除了一个。我把这个留给读者去发现哪个情绪图是不同的，为什么？
- 现在我们来看看回归图，它显示了每部电影的总体平均情绪与 metacritic.com 提供的评级之间的相关性。等级从 0 到 10。
# in this section, we try to find any possibel correlation between the sentiment and rating scoresimport numpy as npweekly_data = pd.read_csv('weeklt_data.csv')
ratings = pd.read_csv('ratings.csv')m_names = ["ladyb", "thepost", "threebill", "shapeofwater", "phantom", "getout", "dunkirk", "darkest", "callme"]threebill = weekly_data[weekly_data['movie']== 'threebill']
ladyb = weekly_data[weekly_data['movie']== 'ladyb']
thepost = weekly_data[weekly_data['movie']== 'thepost']
shapeofwater = weekly_data[weekly_data['movie']== 'shapeofwater']
phantom = weekly_data[weekly_data['movie']== 'phantom']
getout = weekly_data[weekly_data['movie']== 'getout']
dunkirk = weekly_data[weekly_data['movie']== 'dunkirk']
darkest = weekly_data[weekly_data['movie']== 'darkest']
callme = weekly_data[weekly_data['movie']== 'callme']list_x = [callme['sentiment'].mean(), darkest['sentiment'].mean(), dunkirk['sentiment'].mean(), thepost['sentiment'].mean()
, getout['sentiment'].mean(), threebill['sentiment'].mean(), shapeofwater['sentiment'].mean(),
ladyb['sentiment'].mean(), phantom['sentiment'].mean()]
list_y = ratings['rating']fit = np.polyfit(list_x,list_y,1)
fit_fn = np.poly1d(fit)
# fit_fn is now a function which takes in x and returns an estimate for yplt.plot(list_x,list_y, 'yo', list_x, fit_fn(list_x), '--k')plt.show()
我想我只能说，根据我对上图的解释，大多数情感得分分布在 0.05 和 0.2 之间，它们与回归线不太一致。这里的离群值是最黑暗的时刻；它有负面情绪，原因是这部电影的大多数推文中有“最黑暗”这个词，这使得情绪倾向于负面。
- 最后，让我们看看所有电影的推文、情感和销售的累积图，以便更好地理解每个类别中的可能模式。
我不打算在这里添加更多的解释，希望这篇文章的读者能提出问题和评论。
非常感谢您的反馈。
我的 github 页面 上有这个项目的源代码、python 笔记本和数据集。
利用 AWS SageMaker 实现清晰的数据科学
本文旨在展示 AWS 开发和托管行业标准机器学习产品和研究级算法的能力和敏捷性。
该概念通过使用“对象检测算法”示例(https://github.com/wutianchen/object-detection-algo)在 AWS 云上实施 CRISP 数据科学工作流得到验证。
数据科学中关注点的分离
CRISP(数据挖掘的跨行业标准流程)是一个敏捷的工作流或框架，它很好地捕捉了数据科学中关注点的分离。
CRISP Workflow
标准 CRISP 包括上述 7 个组件和 4 个阶段。
- 形成业务问题并收集数据
- 处理数据并基于数据建立模型
- 将模型打包到数据产品中并部署
- 监控模型并收集信息
过程中来来回回并不少见。例如，我们可能被迫收集某些数据来回答一个业务问题，或者尝试各种统计模型来提高模型的准确性。
SageMaker—CRISP 的 AWS 实现
SageMaker 涵盖了从“数据理解”到“监控”的脆。前 SageMaker 时代的另一个类似工具是钯。
SageMaker and CRISP
SageMaker 笔记本: (Jupyter 笔记本)启用从数据处理到统计建模，从分布式模型训练到评估的所有数据科学工作。
**SageMaker 端点:**利用微服务容器架构部署数据科学的成果。也允许在单个端点后部署集合模型(加权模型集合)。
**sage maker 和 Cloudtrail 的集成:**自动记录结果。监控对于数据科学非常重要，因为它可以检测模型在现实世界中的“真实”准确性和数据分布漂移，以支持下一次清晰迭代中的决策。
一个例子——检测图像中的对象
- 我们来形成一个问题:
用概率检测图像中预定义对象列表的位置和标签。
- 问题需要算法:
为了解决这个问题，我们借用 Keras RetinaNet 对象检测算法(后端 tensorflow)的实现，在论文密集对象检测的焦损失中有详细描述。
使用快速 R-CNN 实现的以前版本的解决方案可以在这里找到(博客:用更快的 R-CNN 计算对象)
可以在 Pascal VOC 数据集以及 MS COCO 数据集等上轻松训练模型。使用存储库中提供的脚本。然后在特定领域数据集上应用迁移学习来提高其回答特定问题的性能。
由于关注点的分离，模型可以在不涉及项目其他部分的情况下被改变和部署。
把算法的东西还给算法，把基础设施的东西还给基础设施。
- 算法需要一个 web 服务器:
为了在 AWS 上部署该算法，必须实现两个接口。
- web 服务器路由接口
- 预测功能界面
(由于 AWS Lambda 的上传限制，以无服务器方式在 AWS 上部署机器学习算法仍然很困难。)
实现 web 服务器路由接口(/ping 和/invocations)
实现预测接口(get_model 和 predict 函数)
带有轻量级 python web 服务器 flask 和 docker 脚本的通用模板可以在这里找到。
- 服务器需要端点:
使用 Sagemaker，有两种面向客户端的端点可能性
Build Endpoint for ML Model
- HTTP 端点(https://AWS . Amazon . com/blogs/machine-learning/call-an-Amazon-sage maker-model-Endpoint-using-Amazon-API-gateway-and-AWS-lambda/)
- SageMaker API 端点(https://docs . AWS . Amazon . com/SageMaker/latest/DG/API _ runtime _ invokeendpoint . html
模型被打包到 docker 容器中，并自动部署到 AWS ECR 上。然后可以通过端点调用 predict()方法来提供推断。
- 测试终点:
我们可以用 Sagemaker Notebook 调用和测试已部署的 ML 端点，并可视化结果。
Invoke the Endpoint
在原始图像上绘制结果:
总结和下一次迭代
总之，AWS SageMaker 是目前市场上在敏捷框架下实现数据科学概念的最佳工具。它还集成了其他 AWS 本地服务，如 S3，红移，AWS Lambda，AWS IoT 等。很好。例如，结合 Kinesis KVS，我们可以将图像对象检测扩展到视频流中的对象检测。
因为这是敏捷的…所以我们从简单开始，经过多次迭代来添加特性。
在 Python 中实现梯度下降
什么是梯度下降？
这是一种寻找函数最小值的优化算法。我们从函数上的一个随机点开始，沿着函数的梯度的负方向移动，到达局部/全局最小值**。**
Homer descending !
手动示例:
问题:求从点 x=3 开始的函数 y=(x+5)的局部极小值
**解法:**我们只要看图就知道答案了。当 x = -5 时，y = (x+5)达到最小值(即当 x=-5，y=0 时)。因此 x=-5 是函数的局部和全局最小值。
现在，让我们看看如何使用梯度下降获得相同的数值。
第一步:初始化 x =3。然后，求函数的梯度，dy/dx = 2*(x+5)。
第二步:向渐变的负方向移动(为什么？)。但是等等，要移动多少？为此，我们需要一个学习率。让我们假设学习率→ 0.01
步骤 3 :让我们执行 2 次梯度下降迭代
第四步:我们可以观察到 X 值在慢慢减小，应该收敛到-5(局部最小值)。然而，我们应该执行多少次迭代呢？
让我们在算法中设置一个精度变量，用于计算两个连续“x”值之间的差值。如果连续两次迭代的 x 值之差小于我们设置的精度，停止算法！
Python 中的渐变下降:
第一步:初始化参数
cur_x = 3 # The algorithm starts at x=3
rate = 0.01 # Learning rate
precision = 0.000001 #This tells us when to stop the algorithm
previous_step_size = 1 #
max_iters = 10000 # maximum number of iterations
iters = 0 #iteration counter
df = lambda x: 2*(x+5) #Gradient of our function
步骤 2 :运行一个循环执行梯度下降:
I .当两次连续迭代的 x 值之差小于 0.000001 或迭代次数超过 10，000 时，停止循环
while previous_step_size > precision and iters < max_iters:
prev_x = cur_x #Store current x value in prev_x
cur_x = cur_x - rate * df(prev_x) #Grad descent
previous_step_size = abs(cur_x - prev_x) #Change in x
iters = iters+1 #iteration count
print("Iteration",iters,"\nX value is",cur_x) #Print iterations
print("The local minimum occurs at", cur_x)
输出:从下面的输出中，我们可以观察到前 10 次迭代的 x 值——这可以与我们上面的计算进行交叉检查。该算法在终止之前运行 595 次迭代。下面嵌入了代码和解决方案以供参考。
在 LinkedIn 上连接。
线性回归(第 2 部分):用 python 实现，从头开始的例子。
5 分钟机器学习实现示例。用 python 实现多元线性回归模型(第 3 部分)。
Linear Regression
先决条件: 【线性回归(第一部分)
既然理论已经讨论过了，现在让我们从实际的实现开始。有不同的数据集可用，但让我们用自己的数据集来实现它。简单的线性回归有因变量(Y)和自变量(X)。
步骤 1:准备数据集
dataset to be used
- X —房子大小从 1K 平方英尺到 10K 平方英尺。
- Y —从 30 万到 120 万的房价。
所以我们的数据集已经准备好了，因为它是一个简单的线性回归，所以我们只有一个因素:房子的大小影响房子的价格。在多元线性回归的情况下，我们会有更多的因素影响房价，如位置、房间数量等。(这将在线性回归 ie 的下一部分中实现。第三部分)。
Plotted data on a graph
现在我们需要找到回归线(在上面的散点图中最符合的一条线，这样我们就可以预测响应 y (即。房子的成本)为任何新的价值 x (即。房子的大小)。
第二步:让我们开始编码吧！！！
导入所需库
- Numpy 是 Python 编程语言的一个库。我们在机器学习中使用它，因为我们必须在机器学习中处理大量数据，这比普通数组更快。(习惯了 numpy 数组，我们在哪里都会用到)。有关安装说明，请点击此处。
- Matplotlib : Matplotlib 是 Python 编程语言及其数字数学扩展 NumPy 的绘图库。基本上，这有助于绘制图表。
这里我们使用了“numpy as np”和“matplotlib.pyplot as plt ”,这样做是为了将庞大的名称重命名为较小的名称(便于使用)。而不是写 1 。***numpy . array()***简称为 np.array()
2。 matplotlib.pyplot.plot(x，y) 简称为 **plt.plot(x，y)**这些都是为了便于编码。
如何知道自己是否安装正确？？运行上面两行的文件，如果没有发现错误，就可以运行了。
定义所需功能
Function1: 这是一个确定或估计系数的函数，其中 x 和 y 值被传递到该函数中。
步骤包括:
- 计算 n
- 计算 x 和 y 数组的平均值。
- 计算交叉偏差和偏差:记住这里我们计算的是 SS_xy 和 SS_xx，它们是误差平方和。如前文所述 【线性回归(第一部分) 。
- 计算回归系数:回归线需要移动的量或值。
功能 2 :根据计算值绘制图形的功能。
步骤包括:
- 绘制点:" plt.scatter "在图上绘制点，其中
- “ x 和 y 是图上点的位置
- 颜色是标绘点的颜色，将其更改为红色或绿色或橙色，并尝试更多可能的颜色 点击此处 。
- **【马克笔】**是点的形状像一个圆或者其他什么符号代表不同类型的马克笔 在这里找到 。
2.预测回归线值:取可能的最小误差，回归线在此决定。
3.绘制回归线
4.标签放在这里，而不仅仅是 x 和 y，即 x 和 y 的名称放在这里的图表上。
5.显示绘制的图形
功能 3 :主功能
步骤包括:
- 收集 ie 所需的数据集。x 和 y。
- 计算所需的系数。回归线在 x 和 y 方向上的移动值。
- 绘制图表
最后，编写 main 并调用 main 函数:
所以最终结果，
因此，如果在这里询问 7Ksq 英尺大小的房子的价格，答案将是 92 万左右，而实际价值将是 90 万左右，因此误差为 2 万。
在 GitHub 上找到代码，链接如下:
https://github.com/chethangn/SimpleLinearRegression
更多参考资料:
接下来是 线性回归(第 3 部分),我们将实现多元线性回归。
请务必关注我的***，LinkedIn，Twitter，insta gram获取更多更新。如果你喜欢这篇文章，请鼓掌并分享它。*
在这里加入我们的 WhatsApp 社区。
基于聚类质心的多数欠采样技术在 Python 中的实现
在机器学习和深度学习中，数据不平衡分别是许多分类算法和深度神经网络性能下降的主要原因。不平衡数据是指属于不同类或类别的实例或样本数量不相等，差异显著。二进制不平衡数据的一个这样的例子是 19668 个，其中有 2 个类，但包含不相等数量的实例，76，090 个实例带有标签“0 ”,而 76，090 个实例带有标签“1 ”:
Binary Imbalanced Data
为了最小化不平衡的程度，必须将数据挖掘和特征空间几何整合到解决机器学习分类问题的经典方法中。有许多用于数据平衡的数据挖掘方法。一种重要的方法是基于聚类质心的多数欠采样技术 ( CCMUT )。
在多数欠采样中，不重要(或不那么重要)的实例在多数样本中被移除。在 CCMUT 中，重要和不重要实例的划分是通过使用特征空间几何上的聚类概念来完成的。
聚类是一种无监督的学习方法。但是 CCMUT 仅使用寻找聚类质心的概念(聚类是围绕属于多数类的数据点创建的)，因为实例已经被标记。通过在属于特征空间中多数类的数据点上获得所有特征的平均特征向量来找到聚类质心。
在找到多数类的聚类质心之后，在特征空间中距离聚类质心最远的属于该聚类(多数类)的实例被认为是最不重要的实例。相反，属于多数类的实例，即在特征空间中最接近聚类质心的实例**，**被认为是最重要的实例。
因此，在 CCMUT 中，属于多数类的实例根据其重要性被删除，欠采样的样本数取决于欠采样或 CCMUT 的 %。
CCMUT 的 Python 实现:
从实现角度来看，特征空间几何中的所有距离都被认为是欧几里德距离。
下面以函数 CCMUT()的形式给出了 CCMUT 的 Python 实现，它采用:
- 多数样本矩阵= X
- CCMUT 或欠采样的百分比= f
作为自变量，并返回欠采样后的多数样本矩阵= X_f。
import numpy as np
from math import sqrtdef **CCMUT**(X,f):
# 1\. finding cluster centroid....
cluster_centroid = np.sum(X,axis=0)/X.shape[0]
# 2\. finding **Euclidean Distance** from cluster centroid to samples
euclidean = [None]*X.shape[0]
for i in range(0,X.shape[0]):
euclidean[i] = sqrt(sum((cluster_centroid-X[i])**2))
# 3\. tracking indices of samples in descending order of distance
indices = list(reversed(sorted(range(len(euclidean)),
key = lambda j: euclidean[j])))
# 4\. removing the instances or under-sampling order-wise....
X_f = np.delete(X, indices[:int(f/100*X.shape[0])], axis=0)
# 5\. returning the under-sampled Majority Sample Matrix
return X_f
因此，使用多数样本矩阵和%欠采样调用 CCMUT()，将获得欠采样多数样本矩阵。显然，在欠采样之后，它不会以大幅度或差异被称为多数。
此后，欠采样的多数样本矩阵可以与少数样本矩阵连接(在 CCMUT 之前被分离),并被混洗以用于使用机器学习的预测分析或预测分类模型开发。
也有许多可用的研究，其中 CCMUT 已被直接应用或经过某些修正。
- 使用 AdaBoost 改进说话人确认决策的基于聚类的欠采样技术IAPR 模式识别统计技术国际联合研讨会(SSPR) 。施普林格，柏林，海德堡，2004。
- 甄子丹、秀珍和李月诗。"不平衡数据分布的基于聚类的欠采样方法."专家系统与应用36.3(2009):5718–5727。
- 拉赫曼、莫斯塔菲祖尔和戴维斯。“不平衡心血管数据的基于聚类的欠采样。”世界工程大会会议录。第三卷。2013.
- Sobhani，Parinaz，Herna Viktor 和 Stan Matwin。“使用集成方法和基于聚类的欠采样从不平衡数据中学习。”采矿复杂模式新前沿国际研讨会。施普林格，查姆，2014 年。
- Srividhya 和 R. Mallika。"基于欠采样的聚类同心圆处理不平衡数据."中东科学研究杂志24(2016):314–319。
- 阿奴拉达、那伽苏里和 g .帕萨萨拉迪瓦尔玛。"基于抽样技术聚类的非平衡数据分类方法."印度科技期刊 10.18 (2017)。
- 阿拉法特，医学博士亚希尔，萨贝拉霍克，和万德医学博士法里德。“基于聚类的欠采样随机森林多类不平衡分类。” 2017 第十一届软件、知识、信息管理与应用国际会议(SKIMA) 。IEEE，2017。
用 Keras 实现卷积神经网络
在本文中，我们将看到在 MNIST 数据集上使用 Keras 实现卷积神经网络(CNN ),然后将结果与常规神经网络进行比较。强烈建议在继续学习 CNN 实现之前，先阅读文章“卷积神经网络—简而言之”，以培养对 CNN 的直觉。
1-简介
MNIST 数据集最常用于影像分类研究。MNIST 数据库包含美国人口普查局雇员和美国高中生手写的数字图像，从 0 到 9。分为 6 万张训练图像和 1 万张测试图像。Tensorflow 和 Keras 都允许我们使用 API 直接下载 MNIST 数据集。
2-使用 API 下载数据集
我们将只使用两行代码来导入 TensorFlow 并在 Keras API 下下载 MNIST 数据集。我们将把数据分配到训练集和测试集中。x_train 和 x_test 部分包含灰度 RGB 代码(从 0 到 255 ),而 y_train 和 y_test 部分包含从 0 到 9 的标签。
我们将使用‘matplotlib’库可视化图像。
需要强调的是，MNIST 数据集中的每幅图像大小为 28 X 28 像素，这意味着 x_train 的形状为(60000，28，28 ),其中 60，000 是样本数。作为通过 Keras API 进行处理的要求，我们必须将 x_train 从 3 维重塑为 4 维。此外，我们必须标准化我们的数据，否则我们的计算成本将非常高。我们可以通过将 RGB 代码划分为 255 来实现，如下所示:
3-卷积神经网络结构
首先，我们将卷积神经网络架构定义如下:
1-第一个隐藏层是一个卷积层，称为卷积 2D。我们将使用 32 个尺寸为 5×5 的过滤器。
2-然后是池大小为 2×2 的最大池层。
3-具有 64 个滤波器的另一个卷积层，每个滤波器的大小为 5×5。
4-然后是池大小为 2×2 的最大池层。
5-然后下一步是扁平化层，在建立完全连接的层之前，将 2D 矩阵数据转换为 1D 矢量。
6-之后，我们将使用一个具有 1024 个神经元和 relu 激活功能的全连接层。
7-然后我们将使用一个正则化层称为辍学。它被配置为随机排除该层中 20%的神经元，以减少过度拟合。
8-最后，输出层，其具有用于 10 个类别的 10 个神经元和用于输出每个类别的概率状预测的 softmax 激活函数。
决定上述内容后，我们可以用如下几行代码建立一个神经网络模型:
注:
–注释带有’ # '来解释命令。
–您可以下载 iPython 笔记本 并在您的 PC 上训练模型，或者只是复制并粘贴这些代码。py 文件。
步骤 1 —创建模型:
Keras 首先创建一个模型对象的新实例，然后一个接一个地向其添加层。它被称为顺序模型 API。我们可以通过调用 model.add 并传入我们想要添加的层的类型来向神经网络添加层。最后，我们将用两个重要信息编译模型，损失函数和成本优化算法。
一旦我们执行了上面的代码，Keras 将在幕后构建一个 TensorFlow 模型。
步骤 2 —训练模型:
我们可以通过调用 model.fit 并传入训练数据和预期输出来训练模型。Keras 将运行培训过程，并将进度打印到控制台。训练完成后，它将报告训练数据达到的最终准确度。
步骤 3 —测试模型:
我们可以通过调用 model.evaluate 并传入测试数据集和预期输出来测试模型。
步骤 4 —保存并加载模型:
一旦达到最佳结果，我们可以使用 model.save 保存模型，并传入文件名。这个文件将包含我们在另一个程序中使用我们的模型所需要的一切。
您的模型将以扩展名为. h5 的分层数据格式(HDF)保存。它包含科学数据的多维数组。
我们可以通过调用 load model 函数并传入一个文件名来加载之前训练好的模型。然后，我们调用 predict 函数并传入新数据进行预测。
总结
- 我们学习了如何加载 MNIST 数据集并对其进行归一化。
- 我们学习了使用 Keras 实现 CNN。
- 我们看到了如何保存训练好的模型并在以后加载它进行预测。
- 准确率超过 98%,这比我们用常规神经网络实现的准确率高得多。
从零开始使用梯度下降优化在 Python 中实现多变量线性回归
学习、实施和调整…
机器学习的大多数实际应用涉及目标结果所依赖的多个特征。类似地，在回归分析问题中，存在目标结果依赖于许多特征的情况。多元线性回归是解决这类问题的一种可能的方法。在本文中，我将讨论多变量(多特征)线性回归，它的 Python 实现，在一个实际问题上的应用和性能分析。
由于它是一种“线性”回归技术，在构建假设时，将只采用每个特征的线性项。设 x_1，x_2，… x_n 是目标结果所依赖的特征。然后，多元线性回归的假设:
where theta_0, theta_1, theta_2, theta_3,…., theta_n are the parameters
此外，上述假设也可以根据向量代数重新构建:
还有一个与依赖于参数θ_ 0，θ_ 1，θ_ 2，…，θ_ n 的假设相关的成本函数(或损失函数)
这里的成本函数与多项式回归的情况相同[1]。
因此，这些参数θ_ 0，θ_ 1，θ_ 2，…，θ_ n 必须采用这样的值，对于这些值，成本函数(或简单地成本)达到其可能的最小值。换句话说，必须找出成本函数的最小值。
在这种情况下，分批梯度下降可用作优化策略。
使用批量梯度下降实现多元线性回归:
实现是通过创建 3 个模块来完成的，每个模块用于在培训过程中执行不同的操作。
=> hypothesis():是计算并输出目标变量的假设值的函数，给定 theta (theta_0，theta_1，theta_2，theta_3，…，theta_n)，矩阵中的特征，维数为[m X (n+1)]的 X 其中 m 是样本数，n 是特征数。假设()的实现如下所示:
def **hypothesis**(theta, X, n):
h = np.ones((X.shape[0],1))
theta = theta.reshape(1,n+1)
for i in range(0,X.shape[0]):
h[i] = float(np.matmul(theta, X[i]))
h = h.reshape(X.shape[0])
return h
=>BGD():它是执行批量梯度下降算法的函数，将当前的θ值(theta_0，theta_1，…，theta_n)、学习速率(alpha)、迭代次数(num_iters)、所有样本的假设值列表(h)、特征集(X)、目标变量集(y)和特征数(n)作为输入，并输出优化的 theta (theta_0，theta_1，theta_2，theta_3，…，theta_n)和包含所有迭代的成本函数值的成本历史或成本 BGD()的实现如下所示:
def **BGD**(theta, alpha, num_iters, h, X, y, n):
cost = np.ones(num_iters)
for i in range(0,num_iters):
theta[0] = theta[0] - (alpha/X.shape[0]) * sum(h - y)
for j in range(1,n+1):
theta[j] = theta[j] - (alpha/X.shape[0]) *
sum((h-y) * X.transpose()[j])
h = hypothesis(theta, X, n)
cost[i] = (1/X.shape[0]) * 0.5 * sum(np.square(h - y))
theta = theta.reshape(1,n+1)
return theta, cost
=>linear_regression():它是主函数，以特征矩阵(X)、目标变量向量(y)、学习速率(alpha)和迭代次数(num_iters)作为输入，输出最终优化的 theta，即[ theta_0，theta_1，theta_2，theta_3，…]的值。成本函数在批量梯度下降后几乎达到最小值的θ_ n****和存储每次迭代的成本值的成本**。**
def **linear_regression**(X, y, alpha, num_iters):
n = X.shape[1]
one_column = np.ones((X.shape[0],1))
X = np.concatenate((one_column, X), axis = 1)
# initializing the parameter vector...
theta = np.zeros(n+1)
# hypothesis calculation....
h = hypothesis(theta, X, n)
# returning the optimized parameters by Gradient Descent...
theta, cost = BGD(theta,alpha,num_iters,h,X,y,n)
return theta, cost
现在，让我们继续讨论多元线性回归在实际数据集上的应用。
让我们考虑俄勒冈州波特兰市的房价数据。它包含房子的大小(平方英尺)和卧室的数量作为特征，房子的价格作为目标变量。该数据集可从以下网址获得:
通过在 GitHub 上创建帐户，为 navoneel 1092283/multivariate _ regression 开发做出贡献。
github.com](https://github.com/navoneel1092283/multivariate_regression.git)
问题陈述:给定房子的大小和卧室数量，分析预测房子可能的价格"
数据读入 Numpy 数组:
data = np.loadtxt('data2.txt', delimiter=',')
X_train = data[:,[0,1]] #feature set
y_train = data[:,2] #label set
特征标准化或特征缩放:
这包括缩放特征以实现快速高效的计算。
Standard Feature Scaling Strategy
其中 u 是平均值，sigma 是标准偏差:
特征缩放的实现:
mean = np.ones(X_train.shape[1])
std = np.ones(X_train.shape[1])for i in range(0, X_train.shape[1]):
mean[i] = np.mean(X_train.transpose()[i])
std[i] = np.std(X_train.transpose()[i])
for j in range(0, X_train.shape[0]):
X_train[j][i] = (X_train[j][i] - mean[i])/std[i]
这里，
- 特征“房子的大小(平方。英尺)或 F1: 2000.6808
- 特征“床位数”的平均值或 F2: 3.1702
- F1 的标准偏差:7.86202619e+02
- F2 的标准偏差:7.52842809e-01
# calling the principal function with **learning_rate = 0.0001** and
# **num_iters = 300000**
theta, cost = linear_regression(X_train, y_train,
0.0001, 300000)
theta after Multi-Variate Linear Regression
在分批梯度下降迭代过程中，成本得到了降低。成本的降低借助于曲线显示出来。
import matplotlib.pyplot as plt
cost = list(cost)
n_iterations = [x for x in range(1,300001)]
plt.plot(n_iterations, cost)
plt.xlabel('No. of iterations')
plt.ylabel('Cost')
Line Curve Representation of Cost Minimization using BGD in Multi-Variate Linear Regression
使用三维散点图并排显示特征和目标变量实际值和预测值:
= >实际目标变量可视化:
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3Dsequence_containing_x_vals = list(X_train.transpose()[0])
sequence_containing_y_vals = list(X_train.transpose()[1])
sequence_containing_z_vals = list(y_train)fig = pyplot.figure()
ax = Axes3D(fig)ax.scatter(sequence_containing_x_vals, sequence_containing_y_vals,
sequence_containing_z_vals)
ax.set_xlabel('Living Room Area', fontsize=10)
ax.set_ylabel('Number of Bed Rooms', fontsize=10)
ax.set_zlabel('Actual Housing Price', fontsize=10)
= >预测目标变量可视化:
# Getting the predictions...
X_train = np.concatenate((np.ones((X_train.shape[0],1)), X_train)
,axis = 1)
predictions = hypothesis(theta, X_train, X_train.shape[1] - 1)from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3Dsequence_containing_x_vals = list(X_train.transpose()[1])
sequence_containing_y_vals = list(X_train.transpose()[2])
sequence_containing_z_vals = list(predictions)fig = pyplot.figure()
ax = Axes3D(fig)ax.scatter(sequence_containing_x_vals, sequence_containing_y_vals,
sequence_containing_z_vals)
ax.set_xlabel('Living Room Area', fontsize=10)
ax.set_ylabel('Number of Bed Rooms', fontsize=10)
ax.set_zlabel('Housing Price Predictions', fontsize=10)
Actual Housing Price Vs Predicted Housing Price
性能分析:
- 平均绝对误差:51502.7803(美元)
- 均方差:4086560101.2158(美元平方)
- 均方根误差:63926.2082(美元)
- r 平方得分:0.7329
需要注意的一点是，平均绝对误差、均方误差和均方根误差不是无单位的。为了使它们无单位，在训练模型之前，可以用缩放特征的相同方式缩放目标标注。除此之外，还获得了 0.7329 的下降 R 平方分数。
这就是使用梯度下降法在 Python 中实现多元线性回归的全部内容。
参考文献
2017 年深度学习优化实现亮点(feat。塞巴斯蒂安·鲁德)
GIF from this website
Sebastian Rude r 是自然语言处理专业的博士生，也是 T2 AYLIEN 的研究科学家。他有一个关于自然语言处理和机器学习的最有趣、信息量最大的博客。(我一直都在读，我强烈推荐任何人也去读！)
我在这篇文章中讲述了我从他的博客文章中了解到的所有优化算法。现在这篇文章是第二个版本，涵盖了更先进的优化技术。
网络架构/基准比较
Network Architecture of ELU Network, from this blog post
我最近报道了’ 通过指数线性单元(ELUs)进行快速准确的深度网络学习’ ，单击此处阅读博文，不幸的是，我们在那里实现的模型遭受了对训练图像的过度拟合。所以让我们来看看这些方法是如何提高模型的性能的。(换句话说，它能概括得多好)我之所以这么说，是因为所有这些方法都在解决概括的问题。
请注意，为了公平比较(我想知道这些方法如何改进网络),所以我没有添加任何额外的层，如批量标准化或任何数据预处理。此外，所有的网络都是使用 Adam Optimizer 的某种变体来训练的。
上图是同一个网络在使用 L2 正则化的自动微分(adam optimizer)进行训练时的表现。因此，总的来说，我们的目标是用新的优化方法在测试图像上达到 64%的准确率。
修正 Adam 中的权重衰减正则化
上述论文是塞巴斯蒂安在他的博客文章中使用的主要参考资料之一。所以我认为把它链接到这里也是一个好主意。
案例 1)解耦重量衰减/结果
左图 →常规 Adam 优化器
右图 →带解耦权重衰减的 Adam
红框 →添加权重衰减项
第一种方法非常简单，当更新新的权重时，我们将添加某种权重衰减项(小于 1 ),将其乘以权重以及学习速率。当用 python 实现时，它看起来像下面这样。
红线 →添加重量衰减调整线
我已经将重量衰减率设置为 0.512，并且在每 10、50、100 和 150 次迭代中，我将重量衰减值减半。
左图 →一段时间内的训练精度/成本
右图 →一段时间内的测试精度/成本
由于成本上升到 80 英镑，右边的图表是倾斜的，但是不要担心，我已经附上了下面的图像，以显示模型的最终准确性。
如上所述，使用这种方法，我们能够在测试图像上实现 56%的准确率。考虑到仅亚当和 L2 正则化就能达到 64%的准确率，这还不算太好。
案例 2)固定指数移动平均值/结果
红框 →新旧 v 值之间的最大值
上图显示了 Adam 的新更新规则(该算法的另一个名称是 AMSGrad)。另外，请注意，对于这条规则，我已经将 Beta 2 的值更改为 0.9，而不是使用默认值 0.999。(如下图所示)
最后，当在 Tensorflow 中实现时，它可能如下所示。
Followed Filip KRZN’s implementation
红框 →新旧 v 值之间的最大值
我个人最喜欢这种方法，因为它实现起来非常简单。但是我明白当比较张量时，减少和可能不是最好的方法，另一种方法可以是比较欧几里得范数。但是现在让我们看看这个方法是如何提高模型的性能的。
左图 →一段时间内的训练精度/成本
右图 →一段时间内的测试精度/成本
如上所述，这种方法并没有完全防止模型过度拟合，但是它确实比我们的基准测试获得了更好的性能。
在测试图像上有 66%的准确性，而在训练图像上有 99%的准确性，除了我们在反向传播中所做的改变之外，没有其他形式的正则化方法。
情况 3)调整学习率/结果
红框 →更改 Adam 的 Hyper 参数
蓝框 →模型参数的计算数量
紫框 →等式选择当前步骤的学习率
为此，我们将计算我们网络中的参数数量。如果有人想知道怎么做，请点击这个链接。下面是 VGG 16 计算参数值的一个简单例子。
Image from this [website](http://networks?, H. (2018). How to calculate the number of parameters of convolutional neural networks?. Stack Overflow. Retrieved 8 May 2018, from https://stackoverflow.com/questions/28232235/how-to-calculate-the-number-of-parameters-of-convolutional-neural-networks)
下面是一个为我们的网络计算参数的例子。
红框 →参数计算
蓝框 →网络架构参考
现在，既然我们已经准备好了参数的数量，让我们来看看计算学习率的等式。
通过简单的 tf.cond()，我们能够在 step_num^(-0.5 和 step_num*warmup_steps^(-1.5).之间选择最小值最后让我们看看结果。
左图 →一段时间内的训练精度/成本
右图 →一段时间内的测试精度/成本
如上所述，使用这种方法，模型甚至不能在训练图像上表现良好。我怀疑这种方法的学习率会更高。
请注意，我将步骤数解释为迭代(或当前迭代)数，如果这是错误的，请在下面评论。
对于训练图像和测试图像，该模型最终精度大约为 23%。
情况 4)带重启/结果的 Adam
上面是重启的随机梯度下降(SGD)方程。总之，对于每次迭代 Ti，学习率被重置。所以当我们绘制学习率随时间变化的曲线时，它看起来会像下面这样。
如上所述，学习率在迭代 1 时被设置为 1，再次设置为 300，700 等等。现在让我们来看看如何将这个方法应用到亚当身上。
红框 →如何将此方法应用于 Adam 优化器
如上所述，我们首先需要修复重量衰减，我们已经看到了这一点。(这是我们在案例 1 中使用的方法)。现在让我们看一下实现。
红框→Ti 和 Tcur 的可变占位符
蓝框 →学习率计算公式
实现重启的方法有很多种，但我选择最简单的方法 LOL。另外请注意，原始论文的作者建议将学习率的最大值设置为 1，我设置为 0.001。当我们绘制学习率如何随时间变化(200 次迭代)时，它看起来像下面这样。
重启迭代次数设置为 10、30、70 和 150。(当我们将第一次重启迭代设置为 10 时)。现在让我们来看看模型的性能。
左图 →一段时间内的训练精度/成本
右图 →一段时间内的测试精度/成本
嗯……毫无疑问，这个模型做得很糟糕。我实际上花了很多时间试图让这个模型工作，但是这个模型似乎总是只在迭代的开始学习一些东西，并且在训练期间的某个地方，它似乎过了头，停止了所有的学习过程。
由于我很想知道我做错了什么，如果你对这款车型有什么推荐，请在下面评论。
训练图像和测试图像的最终准确度都是 9%。
互动代码/透明度
对于谷歌实验室，你需要一个谷歌帐户来查看代码，你也不能在谷歌实验室运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！同样为了透明，我在训练期间上传了所有的日志。
要访问案例 1 的代码请点击此处，要访问日志请点击此处。
访问案例 2 的代码请点击此处，访问日志请点击此处。
访问案例 3 的代码请点击此处，访问日志请点击此处。
要访问案例 4 的代码请点击此处，要访问的日志请点击此处。
最后的话
这些都是由许多聪明的研究人员完成的惊人的工作，然而，对于这个实验来说，没有一个看起来像是灵丹妙药。
如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。
同时，在我的 twitter 上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 t。
参考
- 2017 年深度学习优化亮点。(2017).塞巴斯蒂安·鲁德。检索于 2018 年 5 月 7 日，来自http://ruder.io/deep-learning-optimization-2017/
- 只有 Numpy:实现和比较梯度下降优化算法+谷歌大脑的…(2018).走向数据科学。2018 年 5 月 7 日检索，来自https://towards data science . com/only-numpy-implementing-and-comparison-gradient-descent-optimization-algorithms-Google-brains-8870 b 133102 b
- 克利夫特博士、安特辛纳、t .和霍克雷特博士(2015 年)。通过指数线性单元(ELUs)进行快速准确的深度网络学习。Arxiv.org。检索于 2018 年 5 月 7 日，来自https://arxiv.org/abs/1511.07289
- [ICLR 2016]通过指数线性单元(ELUs)进行快速准确的深度网络学习，具有…(2018).走向数据科学。2018 年 5 月 7 日检索，来自https://towards data science . com/iclr-2016-fast-and-accurate-deep-networks-learning-by-index-linear-units-elus-with-c 0 cdbb 71 bb 02
- 张量流正则化。(2018).ritchieng . github . io . 2018 年 5 月 7 日检索，来自http://www . ritchieng . com/machine-learning/deep-learning/tensor flow/regulation/
- tf.cond |张量流。(2018).张量流。检索于 2018 年 5 月 7 日，来自https://www.tensorflow.org/api_docs/python/tf/cond
- ‘开关’)，V. (2018)。值错误:形状的等级必须为 0，但对于“cond _ 11/Switch”(op:“Switch”)的等级为 1。堆栈溢出。2018 年 5 月 8 日检索，来自https://stack overflow . com/questions/47739707/value error-shape-must-be-rank-0-but-is-rank-1-for-cond-11-switch-op-switch
- tensorflow？，H. (2018)。如何在 tensorflow 中求圆周率？。堆栈溢出。检索于 2018 年 5 月 8 日，来自https://stack overflow . com/questions/45995471/how-to-get-pi-in-tensor flow
- 网络？，H. (2018)。如何计算卷积神经网络的参数个数？。堆栈溢出。检索于 2018 年 5 月 8 日，来自https://stack overflow . com/questions/28232235/how-to-calculation-the-number of-parameters-of-convolutionary-neural-networks
- Loshchilov，I .，& Hutter，F. (2017)。修正 Adam 中的权重衰减正则化。 arXiv 预印本 arXiv:1711.05101 。
- 示例:基础— imgaug 0.2.5 文档。(2018).img aug . readthe docs . io . 2018 年 5 月 8 日检索，来自http://img aug . readthe docs . io/en/latest/source/examples _ basics . html
- [ICLR 2016]通过指数线性单元(ELUs)进行快速准确的深度网络学习，具有…(2018).走向数据科学。2018 年 5 月 8 日检索，来自https://towards data science . com/iclr-2016-fast-and-accurate-deep-networks-learning-by-index-linear-units-elus-with-c 0 cdbb 71 bb 02
- (2018).Arxiv.org。于 2018 年 5 月 8 日检索，来自https://arxiv.org/pdf/1711.05101.pdf
从零开始使用梯度下降优化在 Python 中实现单变量多项式回归
学习、实施和调整…
回归是一种对特征空间中的数据或数据点进行连续分类的方法。弗朗西斯·高尔顿在 1886 年发明了回归线的用法[1]。
线性回归
这是多项式回归的一个特例，假设中多项式的次数是 1。一般多项式回归将在文章的后半部分讨论。顾名思义，“线性”，这意味着关于机器学习算法的假设本质上是线性的，或者仅仅是线性方程。耶！！这确实是一个线性方程。在单变量线性回归中，目标变量依赖于单一特征或变量。
单变量线性回归的假设如下:
where theta_0 and theta_1 are the parameters and x is the single feature or variable
上述假设也可以用矩阵乘法格式或向量代数的形式写成:
存在与取决于参数θ_ 0 和θ_ 1 的假设相关联的成本函数。
线性回归的成本函数通常如下所示:
现在，这两个参数 theta_0 和 theta_1 必须采用这样的值，使得该成本函数值(即成本)采用可能的最小值。因此，现在的基本目标是找到成本最小的θ_ 0 和θ_ 1 的值，或者简单地找到成本函数的最小值。
梯度下降是最重要的凸优化技术之一，使用它可以找到函数的最小值。梯度下降算法如下所示:
梯度下降有两种方法:
- 随机梯度下降
- 批量梯度下降
使用随机梯度下降实现线性回归:
在随机梯度下降中，运行梯度下降算法，一次从数据集中取一个实例。
实现是通过创建具有不同操作的 3 个模块来完成的:
=>hypothesis():是在给定 theta (theta_0 和 theta_1)和 Feature，X 作为输入的情况下，计算并输出目标变量的假设值的函数。假设()的实现如下所示:
def **hypothesis**(theta, X):
h = np.ones((X.shape[0],1))
for i in range(0,X.shape[0]):
x = np.concatenate((np.ones(1), np.array([X[i]])), axis = 0)
h[i] = float(np.matmul(theta, x))
h = h.reshape(X.shape[0])
return h
=>SGD():该函数执行随机梯度下降算法，将当前值 theta_0 和 theta_1、alpha、迭代次数(num_iters)、假设值(h)、特征集(X)和目标变量集(y)作为输入，并在由实例表征的每次迭代时输出优化的 theta (theta_0 和 theta_1)。SGD()的实现如下所示:
def **SGD**(theta, alpha, num_iters, h, X, y):
for i in range(0,num_iters):
theta[0] = theta[0] - (alpha) * (h - y)
theta[1] = theta[1] - (alpha) * ((h - y) * X)
h = theta[1]*X + theta[0]
return theta
=>sgd_linear_regression():它是主函数，将特征集(X)、目标变量集(y)、学习速率和迭代次数(num_iters)作为输入，输出最终的优化θ，即代价函数在随机梯度下降后几乎达到最小值的θ_ 0 和θ_ 1 的值。
def **sgd_linear_regression**(X, y, alpha, num_iters):
# initializing the parameter vector...
theta = np.zeros(2)
# hypothesis calculation....
h = hypothesis(theta, X)
# returning the optimized parameters by Gradient Descent...
for i in range(0, X.shape[0]):
theta = SGD(theta,alpha,num_iters,h[i],X[i],y[i])
theta = theta.reshape(1, 2)
return theta
现在，我们来看一个实践数据集，它包含了公司利润如何依赖于城市人口的信息。该数据集可在 GitHub link 上获得，
通过在 GitHub 上创建帐户，为 navoneel 1092283/univariate _ regression 开发做出贡献。
github.com](https://github.com/navoneel1092283/univariate_regression)
问题陈述:给定一个城市的人口，用线性回归分析预测一家公司的利润
数据读入 Numpy 数组:
data = np.loadtxt('data1.txt', delimiter=',')
X_train = data[:,0] #the feature_set
y_train = data[:,1] #the labels
数据可视化:可以使用散点图来可视化数据集:
import matplotlib.pyplot as plt
plt.scatter(X_train, y_train)
plt.xlabel('Population of City in 10,000s')
plt.ylabel('Profit in $10,000s')
散点图数据可视化看起来像-
Scatter Plot
使用三模块线性回归-SGD:
# calling the principal function with **learning_rate = 0.0001** and
# **num_iters = 100000**
theta = sgd_linear_regression(X_train, y_train, 0.0001, 100000)
θ输出结果为:
theta after SGD
散点图上θ的可视化:
获得的θ的回归线可视化可以在散点图上完成:
import matplotlib.pyplot as plt
# getting the predictions...
training_predictions = hypothesis(theta, X_train)
scatter = plt.scatter(X_train, y_train, label="training data")
regression_line = plt.plot(X_train, training_predictions
, label="linear regression")
plt.legend()
plt.xlabel('Population of City in 10,000s')
plt.ylabel('Profit in $10,000s')
回归线可视化结果为:
Regression Line Visualization after SGD
使用批量梯度下降实现线性回归:
在批量梯度下降中，梯度下降算法运行，一次从数据集中提取所有实例。
实现是通过创建具有不同操作的 3 个模块来完成的:
=>hypothesis():是在给定 theta (theta_0 和 theta_1)和 Feature，X 作为输入的情况下，计算并输出目标变量的假设值的函数。假设()的实现保持不变。
=>BGD():它是执行批量梯度下降算法的函数，将当前的θ_ 0 和θ_ 1、α、迭代次数(num_iters)、所有样本的假设值列表(h)、特征集(X)和目标变量集(y)作为输入，并输出优化的θ(θ_ 0 和θ_ 1)、θ_ 0 历史(θ_ 0)和θ_ 1 历史(θ_ 1)，即每次迭代的θ_ 0 和θ_ 1 的值，以及最终包含成本函数值的成本历史 Gradient_Descent()的实现如下所示:
def **BGD**(theta, alpha, num_iters, h, X, y):
cost = np.ones(num_iters)
theta_0 = np.ones(num_iters)
theta_1 = np.ones(num_iters)
for i in range(0,num_iters):
theta[0] = theta[0] - (alpha/X.shape[0]) * sum(h - y)
theta[1] = theta[1] - (alpha/X.shape[0]) * sum((h - y) * X)
h = hypothesis(theta, X)
cost[i] = (1/X.shape[0]) * 0.5 * sum(np.square(h - y))
theta_0[i] = theta[0]
theta_1[i] = theta[1]
theta = theta.reshape(1,2)
return theta, theta_0, theta_1, cost
=>linear_regression():它是主函数，将特征集(X)、目标变量集(y)、学习速率和迭代次数(num_iters)作为输入，并输出最终优化的 theta，即成本函数在批量梯度下降后几乎达到最小值的 theta_0 和 theta_1 的值，以及存储每次迭代的成本值的 cost 。
def **linear_regression**(X, y, alpha, num_iters):
# initializing the parameter vector...
theta = np.zeros(2)
# hypothesis calculation....
h = hypothesis(theta, X)
# returning the optimized parameters by Gradient Descent...
theta,theta_0,theta_1,cost= BGD(theta,alpha,num_iters,h,X,y)
return theta, theta_0, theta_1, cost
在相同的利润估算数据集上使用 3 模块线性回归 BGD:
data = np.loadtxt('data1.txt', delimiter=',')
X_train = data[:,0] #the feature_set
y_train = data[:,1] #the labels
# calling the principal function with **learning_rate = 0.0001** and
# **num_iters = 300**
theta,theta_0,theta_1,cost=linear_regression(X_train,y_train,
0.0001,300)
θ输出结果为:
theta after BGD
散点图上θ的可视化:
获得的θ的回归线可视化可以在散点图上完成:
import matplotlib.pyplot as plt
training_predictions = hypothesis(theta, X_train)
scatter = plt.scatter(X_train, y_train, label="training data")
regression_line = plt.plot(X_train, training_predictions, label="linear regression")
plt.legend()
plt.xlabel('Population of City in 10,000s')
plt.ylabel('Profit in $10,000s')
回归线可视化结果为:
Regression Line Visualization after BGD
此外，在逐迭代的批量梯度下降过程中，成本已经降低。成本的降低借助于线形曲线和曲面图显示出来。
代表 300 次迭代中成本降低的线形曲线:
import matplotlib.pyplot as plt
cost = list(cost)
n_iterations = [x for x in range(1,301)]
plt.plot(n_iterations, cost)
plt.xlabel('No. of iterations')
plt.ylabel('Cost')
线条曲线显示为:
Line Curve Representation of Cost Minimization using BGD
表示成本降低的曲面图:
J = np.ones((300,300))
in1 = 0
in2 = 0
theta_0 = theta_0.reshape(300)
theta_1 = theta_1.reshape(300)
for i in theta_0:
for j in theta_1:
t = np.array([i,j])
h = hypothesis(t, X_train)
J[in1][in2]=(1/X_train.shape[0])*0.5*sum(np.square(h-y_train))
in2 = in2 + 1
in1 = in1 + 1
in2 = 0from mpl_toolkits.mplot3d import Axes3Dfig = plt.figure()
ax = fig.add_subplot(111, projection='3d')X,Y = np.meshgrid(theta_0, theta_1)
ax.plot_surface(X, Y, J)
ax.set_xlabel('theta_0')
ax.set_ylabel('theta_1')
ax.set_zlabel('J')
Surface Plot Representation of Cost Minimizaion with values of theta_0 and theta_1
表现分析(新加坡元对 BGD)
模型性能分析基于以下指标:
= >平均绝对误差:实例样本中预测值和实际观测值之间的平均模(差)。
寻找梅:
ae = 0 # Absolute Error
for i in range(0,y_train.shape[0]):
ae = ae + abs(training_predictions[i] - y_train[i])
MAE = ae/y_train.shape[0] # Mean Absolute Error
= >均方误差:实例样本中预测值和实际观测值之间的平方差的平均值。
查找 MSE:
from math import *
se = 0 # Square Error
for i in range(0,y_train.shape[0]):
se = se + pow((training_predictions[i] - y_train[i]), 2)
MSE = se/y_train.shape[0] # Mean Square Error
= >均方根误差:在一个实例样本中，预测值和实际观测值之间的平方差的平均值的平方根。
寻找 RMSE:
from math import *
RMSE = sqrt(MSE) # Root Mean Square Error
=>R 平方得分或决定系数:
import numpy as np
y_m = np.mean(y_train)SStot = 0
for i in range(0,y_train.shape[0]):
SStot = SStot + pow((y_train[i] - y_m), 2)SSres = 0
for i in range(0,y_train.shape[0]):
SSres = SSres + pow((y_train[i] - training_predictions[i]), 2)R_Square_Score = 1 - (SSres/SStot)
新加坡元和 BGD 的比较:
因此，批量梯度下降在各方面都明显优于随机梯度下降！！
这就是使用梯度下降在 Python 中实现单变量线性回归的全部内容。
多项式回归
在涉及对单个特征或变量进行回归的预测分析问题中(称为单变量回归)，多项式回归是回归分析的一个重要变体，主要用作线性回归的性能助推器。在本文中，我将介绍多项式回归、它的 Python 实现以及在一个实际问题上的应用和性能分析。
正如前缀“多项式”所暗示的，机器学习算法的相应假设是多项式或多项式方程。因此，这可以是任何次数的，比如如果假设是一次多项式，那么它是一个线性方程，因此称为线性回归，如果假设是二次多项式，那么它是一个二次方程，类似地，如果是三次多项式，那么它是一个三次方程，等等。因此，可以说:
线性回归是多项式回归的真子集或特例方法，因此多项式回归也称为广义回归
多项式回归的假设如下:
where theta_0, theta_1, theta_2, theta_3,…., theta_n are the parameters and x is the single feature or variable
其中θ_ 0，θ_ 1，θ_ 2，θ_ 3，…，theta_n 是参数， x 是单一特征或变量
上述假设也可以用矩阵乘法格式或向量代数的形式写成:
这里，也存在与依赖于参数θ_ 0，θ_ 1，θ_ 2，θ_ 3，…的假设相关联的成本函数。，theta_n。
一般来说，广义回归的成本函数如下所示:
因此，这些参数θ_ 0，θ_ 1，θ_ 2，…，θ_ n 必须采用这样的值，对于这些值，成本函数(或简单地成本)达到其可能的最小值。换句话说，需要找出成本函数的最小值。
批量梯度下降可以用作优化函数。
使用批量梯度下降实现多项式回归:
实现是通过创建 3 个执行不同操作的模块来完成的。
=>hypothesis():是计算并输出目标变量的假设值的函数，给定 theta (theta_0，theta_1，theta_2，theta_3，…，theta_n)，特征 X 和多项式回归中多项式的次数(n)作为输入。假设()的实现如下所示:
def **hypothesis**(theta, X, n):
h = np.ones((X.shape[0],1))
theta = theta.reshape(1,n+1)
for i in range(0,X.shape[0]):
x_array = np.ones(n+1)
for j in range(0,n+1):
x_array[j] = pow(X[i],j)
x_array = x_array.reshape(n+1,1)
h[i] = float(np.matmul(theta, x_array))
h = h.reshape(X.shape[0])
return h
=>BGD():该函数执行批量梯度下降算法，将当前的θ值(theta_0，theta_1，…，theta_n)、学习速率(alpha)、迭代次数(num_iters)、所有样本的假设值列表(h)、特征集(X)、目标变量集(y)和多项式回归中多项式的次数(n)作为输入，并输出优化的 theta (theta_0，theta_1，theta_2，theta_3，…，theta_n)、theta_history(包含每次迭代的 theta 值的列表)和最终 BGD()的实现如下所示:
def **BGD**(theta, alpha, num_iters, h, X, y, n):
theta_history = np.ones((num_iters,n+1))
cost = np.ones(num_iters)
for i in range(0,num_iters):
theta[0] = theta[0] — (alpha/X.shape[0]) * sum(h — y)
for j in range(1,n+1):
theta[j]=theta[j]-(alpha/X.shape[0])*sum((h-y)*pow(X,j))
theta_history[i] = theta
h = hypothesis(theta, X, n)
cost[i] = (1/X.shape[0]) * 0.5 * sum(np.square(h — y))
theta = theta.reshape(1,n+1)
return theta, theta_history, cost
=>poly_regression():它是主函数，将特征集(X)、目标变量集(y)、学习率(alpha)、多项式回归中多项式的次数(n)和迭代次数(num_iters)作为输入，输出最终优化的 theta，即[ theta_0，theta_1，theta_2，theta_3，…]的值。成本函数在批量梯度下降后几乎达到最小值的θ_ n**，存储每次迭代的θ值的θ_ history**，以及存储每次迭代的成本值的 cost 。
def **poly_regression**(X, y, alpha, n, num_iters):
# initializing the parameter vector…
theta = np.zeros(n+1)
# hypothesis calculation….
h = hypothesis(theta, X, n)
# returning the optimized parameters by Gradient Descent
theta,theta_history,cost=BGD(theta,alpha,num_iters,h, X, y, n)
return theta, theta_history, cost
现在，我们来看一个实践数据集，它包含了公司利润如何依赖于城市人口的信息。
在利润估算数据集上使用 3 模多项式回归，
通过在 GitHub 上创建帐户，为 navoneel 1092283/univariate _ regression 开发做出贡献。
github.com](https://github.com/navoneel1092283/univariate_regression)
问题陈述:给定一个城市的人口，用多项式回归分析预测一家公司的利润
data = np.loadtxt(‘data1.txt’, delimiter=’,’)
X_train = data[:,0] #the feature_set
y_train = data[:,1] #the labels
**# calling the principal function with learning_rate = 0.0001 and
# n = 2(quadratic_regression) and num_iters = 300000** theta,theta_history,cost=poly_regression(X_train,y_train,
0.00001,2,300000)
theta after Polynomial Regression
散点图上θ的可视化:
获得的θ的回归线可视化可以在散点图上完成:
import matplotlib.pyplot as plt
training_predictions = hypothesis(theta, X_train, 2)
scatter = plt.scatter(X_train, y_train, label=”training data”) regression_line = plt.plot(X_train, training_predictions
,label=”polynomial (degree 2) regression”)
plt.legend()
plt.xlabel(‘Population of City in 10,000s’)
plt.ylabel(‘Profit in $10,000s’)
回归线可视化结果为:
Regression Line Visualization after Quadratic Regression
此外，在逐迭代的批量梯度下降过程中，成本已经降低。成本的降低借助于曲线显示出来。
import matplotlib.pyplot as plt
cost = list(cost)
n_iterations = [x for x in range(1,300001)]
plt.plot(n_iterations, cost)
plt.xlabel(‘No. of iterations’)
plt.ylabel(‘Cost’)
线条曲线显示为:
Line Curve Representation of Cost Minimization using BGD in Quadratic Regression
现在，必须进行模型性能分析以及多项式回归与线性回归的比较(迭代次数相同)。
因此，线性回归是使用批量梯度下降完成的，迭代次数为 3，00，000 次，学习速率(alpha)为 0.0001，使用的是我上一篇文章中的实现:
[## 使用梯度下降优化在 Python 中实现单变量线性回归…
学习、编码和调整…
towardsdatascience.com](/implementation-of-uni-variate-linear-regression-in-python-using-gradient-descent-optimization-from-3491a13ca2b0)
data = np.loadtxt(‘data1.txt’, delimiter=’,’)
X_train = data[:,0] #the feature_set
y_train = data[:,1] #the labels
# calling the principal function with **learning_rate = 0.0001** and
# **num_iters = 300000**
theta,theta_0,theta_1,cost=linear_regression(X_train,y_train,
0.0001,300000)
theta after Linear Regression
散点图上θ的可视化:
获得的θ的回归线可视化可以在散点图上完成:
import matplotlib.pyplot as plt
training_predictions = hypothesis(theta, X_train)
scatter = plt.scatter(X_train, y_train, label=”training data”)
regression_line = plt.plot(X_train, training_predictions
, label=”linear regression”)
plt.legend()
plt.xlabel(‘Population of City in 10,000s’)
plt.ylabel(‘Profit in $10,000s’)
Regression Line Visualization after Linear Regression
此外，在逐迭代的批量梯度下降过程中，成本已经降低。成本的降低借助于曲线显示出来。
import matplotlib.pyplot as plt
cost = list(cost)
n_iterations = [x for x in range(1,300001)]
plt.plot(n_iterations, cost)
plt.xlabel(‘No. of iterations’)
plt.ylabel(‘Cost’)
线条曲线显示为:
Line Curve Representation of Cost Minimization using BGD in Linear Regression
性能分析(使用 BGD 优化的线性回归与二次回归):
但是在这里，使用批量梯度下降优化，我们最终得到的线性回归在所有方面都优于多项式(二次)回归。但是，在实践中，多项式(高次或广义)回归总是比线性回归表现更好。虽然使用 BGD，但由于 BGD 优化本身的一些缺点，我们无法获得与命题相匹配的实验结果。还有另一种优化或寻找多项式(也称线性)回归中成本函数最小值的方法，称为**【OLS(普通最小二乘法)】或正规方程法**。
我将在以后的文章中讨论这些内容，并提到本文的参考资料。使用 OLS，可以清楚地证明多项式(在本实验中是二次的)比线性回归表现得更好。除了单变量问题，使用适当的特征工程技术，多项式回归也可用于多变量问题(多特征)。
这就是多项式回归的全部内容。
参考文献
[1]迈克尔·布尔默(2003 年)。弗朗西斯·高尔顿:遗传和生物统计学的先驱。约翰霍普金斯大学出版社。ISBN0–8018–7403–3。
实现 DeepMind 基线星际强化学习代理
将研究用语翻译成代码
实现研究论文中描述的深度学习模型是一种具有挑战性但具有启发性的体验，它显示了有多少信息可以压缩到少数几个句子或段落中。
本周，在了解了《星际争霸 python API 和强化学习环境的诀窍之后，我开始构建《T4》中描述的三个基线代理中的第一个:强化学习的新挑战。
具体来说，一个优势行动者-批评家代理使用卷积神经网络架构来估计状态值和最佳策略，该架构基于深度强化学习的异步方法中的架构。由于资源限制，我没有实现 A3C 的“异步”部分，这意味着我一次只运行一个代理，而不是并行运行多个代理。
在这篇文章中，我将重点介绍这两篇研究论文中关于代理设计的部分，其中包含了与技术实现相关的最多信息。我希望这将作为一个有用的例子，说明如何将研究人员的语言翻译成代码。我的完整实现可以在这里找到。
概括地说，深度强化学习代理需要满足五个要求:
- 接收包含状态信息的感知(输入)
- 通过深层网络处理感知以产生状态表示。
- 使用状态表示来通知策略(从状态到动作的功能映射)。
- 使用该策略选择操作并与环境交互。
- 从环境中获得奖励，并利用这些奖励来改进国家和政策的模式。
这只是一个任意的分解，但是我发现它直观上是有帮助的，并将使用它来指导本文的结构。
输入
因此，主要的观察来自于以 N × M 像素渲染的特征层集合…除了屏幕和小地图，游戏的人机界面还提供了各种非空间观察。
对于与 PySC2 交互的代理，它必须有一个在每个时间步长调用的step(self, obs)方法。此外，它可能有一个在每集开始时调用的reset(self)方法。
我喜欢为我的深度神经网络使用单独的类，如下所示。以要素图层形式出现的输入相对直接地对应于张量流图中的占位符。API 将它们暴露在形状为[channels, y, x]的数组中，所以后来在我的网络中，我确保适当地排列这些维度，以便它们可以被馈送到卷积层，并且在将一批 1 馈送到图中时经常使用np.expand_dims。
国家代表权
我们将包含分类值的所有要素图层嵌入到一个连续空间中，这相当于在信道维度中使用一键编码，然后进行 1 × 1 卷积。我们也用对数变换重新缩放数字特征，因为它们中的一些如生命值或矿物可能达到相当高的值。
虽然我发现“嵌入”的语言有点吓人，但随后的细节证明实现起来更简单。比起在卷积层之后应用一键编码，我发现推断一个特征是分类的还是数字的是更费力的任务。
它处理屏幕和小地图要素图层，这两个图层分别有 16，32 个大小为 8，4 和步幅为 4，2 的过滤器。非空间特征向量由具有双曲正切非线性的线性层处理。结果被连接并通过一个带有 ReLU 激活的线性层发送。
Figure from https://arxiv.org/abs/1708.04782
虽然论文的这些段落对应于一些最长的代码块，但它们很容易实现，因为有强大的深度学习框架可用，其中 Tensorflow 是我在这里选择的工具。
策略表示
…我们建议利用链式法则，以自动回归的方式表示策略:
我在这里困惑的一点是关于“链式法则”它指的是概率论中的一般乘积规则，而不是微积分中也称为“链式规则”的规则。
在我们的大多数实验中，我们发现独立地对子动作建模就足够了…对于空间动作(坐标),我们独立地对策略建模，以选择(离散的)x 和 y 坐标。
基本上，因为在星际争霸 2 中任何给定的动作(称为函数标识符)可能需要可变数量的参数，一种有效的方法来表示函数标识符和参数上的策略是对每种类型有一个独立的策略，其中任何参数给定一个不需要它的函数标识符的概率变为零。
PySC2 中大约有 10 种通用类型的函数标识符，每一种都需要不同的参数序列。在 Tensorflow 图中实现时，我发现使用字典是跟踪所有输出层的好方法。我还为占位符构建了一个字典，稍后将用于训练网络。
动作选择
为了确保我们的代理永远不会选择不可用的动作，我们屏蔽了 a0 的功能标识符选择，这样只有适当的子集可以被采样，模仿玩家随机点击 UI 上的按钮的方式。我们通过屏蔽动作和重整 a0 上的概率分布来实现这一点。
虽然在我的第一遍中，我在 Tensorflow 图之外实现了这个屏蔽，但在实际选择动作时，它也可以在图中实现，在未来的更新中，我可能会将它移到那里。
培养
在 A3C 中，我们在网络的 K = 40 个前向步骤之后或者如果接收到终端信号，就切断轨迹并运行反向传播。
这句话实际上启发了整个帖子。最初我不知道“切断轨迹”意味着什么，于是我踏上了知识之旅。以下两句语录来自原 A3C 论文。
像我们的 n 步 Q-learning 的变体一样，我们的 actor-critic 的变体也以前瞻的观点操作，并使用相同的 n 步回报组合来更新策略和价值函数。
当然，我直接跳到了 A3C 代理的部分，但是我知道线索越来越多了。
然后，该算法为自上次更新以来遇到的每个状态-动作对计算 n 步 Q 学习更新的梯度。每个 n 步更新使用最长的可能 n 步返回，导致最后一个状态的一步更新，倒数第二个状态的两步更新，等等，总共最多 t_max 个更新。在单个梯度步骤中应用累积的更新。
最后，一切都清楚了！不，不是真的。这仍然是一篇高度密集的研究论文，但是在附录中一些伪代码的帮助下，我终于明白了一些关于用来训练网络的目标是如何产生的。
额外收获:A3C(或 A2C)渐变
A3C 梯度定义如下:
我打算将来写这方面的东西，但是这个等式中有太多东西需要解开，所以我认为把它包括进来会很有趣。有趣的一点是，策略和值梯度代表了性质上不同的东西，但是通过简单的加法将它们结合在一起仍然能够产生可行的优化目标(提供了一些可以调整的超参数旋钮)。
令我感兴趣的还有“优势”(观察到的回报和估计值之间的差异，梯度成分通过该差异进行缩放)作为一个常数因子，尽管它在计算中包括了网络输出值。这意味着我必须使用[tf.stop_gradient](https://www.tensorflow.org/api_docs/python/tf/stop_gradient),这样权重就不会以游戏化等式的方式更新以改变价值估计。
结论
我在两篇指导性研究论文中最重要的部分加了下划线，并展示了它们如何映射到代码上。这个项目让我对研究人员能够将堆积如山的信息浓缩成短到可以在 Twitter 上分享的句子有了新的认识。
虽然我的评论很简短——也是故意如此，因为我希望强调科学报道和代码之间的关系——但我计划继续写一篇文章，更深入地探究所有这些概念的含义。
实现生成性对抗网络(GAN/DCGAN)来绘制人脸
在上一个教程中，我们学习了使用 Tensorflow 来设计一个变分自动编码器 (VAE)，它可以绘制 MNIST 字符。大多数创建的数字看起来很好。只有一个缺点——一些创建的图像看起来有点模糊。用均方误差损失函数训练 VAE。然而，很难对精确的字符边缘位置进行编码，这导致网络无法确定这些边缘。如果一个字符的边缘开始向左或向右多几个像素真的有关系吗？我不这么认为。
在本文中，我们将了解如何训练一个不依赖于均方误差或任何相关损失函数的网络，而是让它自己学习真实图像的样子。我们将要了解的架构叫做 深度卷积生成对抗网络(DCGAN) 。罗威尔·阿蒂恩萨在三月下旬写的一篇很棒的文章启发我完成了这个项目，他教我们如何在 keras 应用同样的技术。为了能够与上一个基于 VAE 的模型进行比较，我们将首先看看如何实现一个能够绘制 MNIST 角色的 DCGAN。之后，我们将在一个更酷的项目中应用我们的知识——只需一些小的调整，我们的网络将学会如何绘制(半)逼真的人脸！
深度卷积生成对抗网络
像 VAE 一样，DCGAN 是一种学习生成新内容的架构。就像 VAE 一样，DCGAN 由两部分组成。在这种情况下，它们是:
- 鉴别器，，学习如何从我们想要创建的类型的真实对象中辨别出赝品
- *生成器，*创建新内容并试图欺骗鉴别器
基本思想是两个网络部分相互竞争。当鉴别器变得更好时，生成器也需要变得更好，否则它不能再欺骗鉴别器了。类似地，当发生器变得更好时，鉴别器也必须变得更好，否则它将失去区分真假内容的能力。
如果你想对 GANs 有更多的直觉，这里有一篇的文章，作者chan chana sornsountorn，描述了一些应用了 DCGANs 的创意项目。其中一个项目是 MNIST 人物的生成，另一个是人脸的生成。在本文中，我们将了解如何在 Python 和 Tensorflow 中实现所描述的技术。我们将从 MNIST 的角色开始。如果你想看这个教程的全部代码，去我的 github 账号看看 MNIST 和人脸生成的代码。
* [## Felix mohr/使用 Python 进行深度学习
在 GitHub 上创建一个帐户，为深度学习 Python 开发做贡献。
github.com](https://github.com/FelixMohr/Deep-learning-with-Python)
设置基础
所以，让我们直接进入代码。
和上一篇教程一样，我们使用 tensorflow 自己的方法来访问批量的 MNIST 字符。我们将批量大小设置为 64。我们的生成器将噪声作为输入。这些输入的数量被设置为 100。批量标准化大大改善了这个网络的训练。对于 tensorflow 应用批处理规范化，我们需要让它知道我们是否处于训练模式。keep_prob变量将由我们的辍学层使用，我们引入辍学层是为了获得更稳定的学习结果。lrelu定义了流行的 leaky ReLU，希望 tensorflow 的未来版本能够支持它！我首先尝试将标准 ReLUs 应用于这个网络，但这导致了众所周知的 死亡 ReLU 问题 ，并且我收到了看起来像 Kazimir Malevich 的艺术品的生成图像——我只是得到了黑色方块。
然后，我们定义一个函数binary_crossentropy，我们将在以后计算损失时使用它。
鉴别器
现在，我们可以定义鉴别器。它看起来类似于我们的 VAE 的编码器部分。作为输入，它采用真实或虚假的 MNIST 数字(28 x 28 像素灰度图像)并应用一系列卷积。最后，我们使用 sigmoid 来确保我们的输出可以被解释为输入图像是真实的 MNIST 字符的概率。
发电机
发生器——就像我们的 VAE 中的解码器部分——接收噪音，并尝试学习如何将噪音转换为数字。为此，它应用了几个转置卷积。一开始我没有对生成器应用批量归一化，它的学习好像真的效率不高。应用批量标准化图层后，学习能力有了很大提高。此外，我首先有一个更大的密集层接受发电机的输入。这导致发生器总是产生相同的输出，不管输入噪声是什么，例如，它总是输出看起来完全相同的 9(模式崩溃)。另一方面，根本不使用密集层会导致生成器在多次迭代后没有学到任何有意义的东西。老实说，调整发电机需要相当大的努力！
损失函数和优化器
现在，我们将两部分连接在一起，就像我们在上一个教程中对 VAE 的编码器和解码器所做的那样。但是，我们必须创建两个鉴别器对象:
- 第一个对象接收实像
- 第二对象接收假图像
第二个对象的reuse被设置为True，所以两个对象共享它们的变量。我们需要两种情况来计算两种类型的损失:
- 当接收真实图像时，鉴别器应该学会计算高值(接近 1 )，这意味着它确信输入图像是真实的
- 当接收到假图像时，它应该计算低值(接近 0 ，这意味着它确信输入图像不是真实的
为此，我们使用前面定义的二元交叉熵函数。生成器试图实现相反的目标，它试图让鉴别器给假图像分配高值。
现在，我们也应用一些正则化。我们创建了两个不同的优化器，一个用于鉴别器，一个用于生成器。我们必须定义允许这些优化器修改哪些变量，否则生成器的优化器可能会弄乱鉴别器的变量，反之亦然。
在应用批处理规范化时，我们必须向我们的优化器提供update_ops——看看 tensorflow 文档,了解关于这个主题的更多信息。
训练 GAN
最后，有趣的部分开始了——让我们训练我们的网络！我们向生成器输入随机值，它将学习从这些噪音中生成数字。我们还注意，通过平衡它们的损失，生成器和鉴别器都不会变得太强，否则，这将抑制任一部分的学习，甚至可能阻止网络学习任何东西(我有过这种经验)。
MNIST 结果
看看我们的生成器绘制的图片——它们看起来比 VAE 绘制的图片更真实，后者的边缘看起来更模糊。然而，训练比训练另一个模型花费的时间要长得多。我还必须提到，在创建的角色看起来有意义之前，我需要比罗威尔·阿蒂恩萨更多的迭代，所以特别是如果你没有强大的 GPU，你可能想参考本文顶部提到的他的架构。
MNIST characters created by our DCGAN
这是一个真正的优势，我们不依赖于基于像素位置的损失函数，使结果看起来不那么模糊。这在创建更复杂的数据时尤其重要，例如人脸图片。所以，只要有点耐心，结果最终会回报你的。
画人脸
我不会详细介绍生成人脸的完整代码，因为架构基本上是一样的。主要区别在于，我们现在使用三个颜色通道，而不是像以前那样使用一个通道，并且我们允许卷积转置层针对这种更复杂的输入数据学习更多的滤波器。你可以在我的 github 找到完整的代码。
我使用的数据集是麻省大学的 LFW(野外标记人脸)数据集。或许使用更大的数据集可以改善结果，但我还没有尝试过。为了让学习在相当长的时间内发生，我将图像缩小到 40 x 40 像素，并以前面提到的相同方式训练 DCGAN。生成器的卷积变换层创建了更多的过滤器，因为这个数据集比 MNIST 数据集更复杂。
Faces drawn by our neural network
看看结果吧！我在特斯拉 K80 GPU 上训练了大约一个小时的网络，以获得这些。也许这些家伙不会骗你相信他们是真人。但是想想看，神经网络以前从未见过任何人，在完成 MNIST 项目后，我们对它的重新设计付出了多么少的努力！这项技术显然有很大的应用潜力。
如果你喜欢这篇文章，你可能也会对我的关于使用变分自动编码器 生成 MNIST 字符的 教程感兴趣。*
用 Python 实现 Trie(不到 100 行代码)
介绍
让我问你一件事。一些我们经常遇到并且(几乎)总是忽略的有趣的事情。
你肯定还记得你的手机键盘上的那个漂亮的功能，你开始输入一个单词，它就开始向你显示建议。这真他妈的方便！事实上，由于这个原因，我几乎可以一直写英语单词而没有拼写错误。
你觉得，电脑到底怎么样(对！你的智能手机也是一台电脑)想出了这些建议？
事实证明，在许多情况下，使用某种特定的数据结构在您键入时向您显示单词建议。这种特殊的数据结构被称为 Trie 。
那么，什么是特里呢？在我开始定义它之前，让我给你看一张图。
(image courtsey — http://www.mathcs.emory.edu)
从上图可以看出，它是一个树状结构，每个节点代表给定字符串的一个字符。与二叉树不同，一个节点可能有两个以上的子节点。
我们来分析一个例子。我们假设我们从零开始，这意味着我们只有一个空的根节点，其他什么都没有。我们从“买”字开始。从图中可以清楚地看到，我们的 Trie 实现没有在根节点中存储一个字符。所以我们添加第一个字符，即“b”作为它的子节点。我们这样做是因为它在任何一个孩子身上都没有这种性格。否则，我们将跳过添加子节点。因为我们已经有了。然后是“u”字。在添加这个字符时，有一点我们必须注意，那就是我们需要搜索“u”是否出现在“b”的任何子节点中(我们最后添加的节点)以及T5【而不是 的根
而“y”也是如此。因此，一旦添加整个单词“buy”的操作完成，我们的 Trie 看起来就像这样
而现在是“牛”的时候了。我们重复同样的步骤，在我们的 Trie 中添加“bull”。只是这一次，我们不再添加“b”和“u”。因为它们已经存在。所以一旦手术完成，它看起来像这样-
我相信，这让您对什么是 Trie 以及在其中添加字符的操作是如何工作的有了一个清晰的概念。详细情况，你可以去维基百科。
在解决 Hackerrank 中的一个挑战时，我偶然发现了这种稍微有点非传统且讨论较少的数据结构。在摆弄了几个小时的代码后，我成功地编写了代码并解决了这个难题。这是我的代码的样子-
代码
Trie implementation in Python 3
它是如何工作的？
现在，我将简要介绍一下算法的主要步骤
- 要考虑的第一件事是我们如何添加新单词。
add函数正是这样做的。它的工作方式非常简单。它将根节点(没有分配任何字符值的节点)和整个单词作为输入。 - 然后，它遍历这个单词，从第一个字符开始，一次一个字符。
- 它检查当前的“节点”(在指向根节点的过程的开始)是否有一个具有该字符的子节点。
- 如果找到了，它只是增加该节点的计数器，以表明它得到了该字符的重复出现。
- 如果没有找到，那么它只是添加一个新节点作为当前节点的子节点。
- 在这两种情况下(4 & 5)，在从单词的下一个字符开始之前，它将子节点指定为“当前节点”(这意味着在下一次迭代中，它将从这里开始)。
这就是在特里树中添加一个单词的全部内容。它还做了一件事，就是在整个过程结束后标记一个单词的结束。这意味着特里树的每个叶节点将把word_finished设为真。
搜索前缀有几个简单的步骤-
- 它从根节点和要搜索的前缀开始。
- 它一次从前缀中取出一个字符，并搜索“当前节点”的子节点(在指向根节点的开头)以找到包含该字符的节点。
- 如果找到了，它将该子节点重新分配为“当前节点”(这意味着在下一个迭代步骤中，它将从这里开始)
- 如果没有找到，则返回 False，表示前缀不存在。
- 在这个算法中有一个小的变化来处理试图找到一个比单词本身更大的前缀的情况。这意味着，我们有
hammer作为一个 Trie，我们正在搜索hammers
这就是用 Python 构建和遍历通用 Trie 数据结构的全部内容。
这里给出的代码是可重用的(和良好的注释:)，并在公共领域。如果你需要，请随意使用它！
那都是乡亲们！我希望你喜欢这篇文章，如果是的话，请尽可能多的点击拍手。如果您有任何反馈或建议，请通过评论或直接通过我的 Linkedin 告诉我。这些将鼓励我在未来写更多的文章。回头见！
实施分析:向上扩展！
你终于到了那个时刻:你知道你想用你的分析实现做什么，你的利益相关者都在船上，你准备好将其扩展到整个组织。现在怎么办？
在向更广泛的受众推广您的分析平台之前，您需要考虑几件事情:数据集的结构和存储，扩展您的分析的正确工具；您确保数据质量的方法；和适当的文档来指导您的团队正确使用数据。
结构和存储
您将在哪里以及如何存储您的数据？您的数据是结构化的还是非结构化的？真的需要“数据湖”吗？需要进行多少数据操作？什么是正确的安全和访问控制级别？一些用户(如您组织中的数据科学家)是否需要访问更多非结构化数据集来进行分析，而其他人则在寻找 BI 仪表盘、数据可视化和更结构化的报告？
SQL Server、Teradata 等关系数据库或 MySQL、PostgreSQL 等开源数据库支持大规模高效的数据存储。这些数据库使用结构化查询语言或 SQL，它允许用户编写用于基本数据过滤、组合和聚合的查询。您是希望使用关系数据库，还是选择提供更大灵活性的 Hadoop 框架，这将取决于您正在处理的数据类型以及您的用户可能想要回答的问题。
合适的工具
随着您需求的发展，您对满足这些需求的“正确工具”的定义也将随之变化。您可以从开源工具开始，随着您在企业范围内的扩展而转向许可产品。
虽然传统数据库可以使用查询和存储过程进行一些数据操作，但它们的主要目的是数据存储和检索。为了获得更强大的复杂数据分析、建模和报告功能，您可以尝试 Python 之类的脚本语言或 R 或 SAS 之类的统计软件包。它们可用于从数据库中提取数据，执行数据准备，然后将结果存储回数据库。他们还可以连接、提取和集成来自任何其他数据源(原始文件、网页、API)的数据，并执行数据验证和错误处理。
对于企业级数据集市，有许多商业和开源的、专门的提取、转换、加载(ETL)软件可用。许多已经与上游的数据库或商业智能和分析产品集成。大多数 ETL 产品不需要任何编码，数据管道可以以图形方式创建、可视化和执行。
确保数据质量
越早解决数据质量问题越好；终端用户花在数据争论上的时间越少，他们就可以更多地关注高价值分析。随着您组织的数据基础设施的成熟，从电子表格迁移到数据库和数据仓库，数据质量检查应该正式定义、记录和自动化。应该在数据输入期间使用预定义的业务规则逻辑自动处理异常，或者要求用户立即干预以纠正任何错误。
向终端用户提供干净、集中且可供分析的数据不应是单向的过程。允许最终用户专注于高价值分析，如数据挖掘、网络图、聚类等。，他们可以发现数据中的某些异常值和异常。有效的数据管理应该包括一个反馈循环来交流这些发现，并且如果必要的话，合并 ETL 过程中的任何变化，使得集中的数据管理更加动态和灵活。
证明文件
如果你是一个把数据集放在一起的人，你可能知道关于它的一切。数据来自哪里，您用来填充缺失值的插值方法，或者支出日期是指从资金承诺日期到组织收到资金的实际日期之间的任何时间。随着越来越多的人开始关注你的数据集，你不能再把这些知识视为理所当然。这就是适当的数据治理和质量文档的来源。
除了描述数据元素的内容、格式和结构的数据字典之外，源到目标映射允许用户追溯每个数据元素的原始来源。随着计算、转换和数据丰富数量的增长，这对于保持透明度和准确性变得越来越重要。实施和维护这些类型的文档可以降低滥用数据的风险。
这也是为强大的数据治理框架奠定基础的时刻！
实施分析:数据监管案例
“策展”是一个经常与博物馆和图书馆联系在一起的术语，但对于数据分析来说，它是发现、收集和展示数据的行为。
数据监管是选择最相关信息的过程，以满足业务用户对特定主题的需求；喜欢好的编辑或者博物馆馆长！它是将独立创建的数据源(结构化和半结构化数据)转化为可用于分析的统一数据集的过程，使用领域专家来指导该过程，以呈现最佳可用内容。适当的数据监管不仅需要数据管理、编程技能和领域专业知识，还需要整合正确信息的创造力，让业务用户发现新的见解。数据科学就是这样一个从需求中成长起来的领域。但是，数据科学家到底是什么？
“数据科学家是一个罕见的混合体，一个计算机科学家拥有构建软件的编程能力，能够收集、组合和管理来自各种来源的数据，一个统计学家知道如何从信息中获得洞察力。他们将创建新原型的技能与询问和回答关于数据及其秘密的最深层问题的创造力和彻底性相结合。”—杰克·波威
为什么数据监管是必要的？
组织拥有的数据在规模和复杂性上都在增长。然而，研究表明，许多组织只使用了大约 10%的数据，因为这些数据分散在组织的各个孤岛中。
数据集成 是跨组织的共同挑战。它可能由许多不同的因素驱动，例如:独立业务单位的孤立流程、业务过程中对其他公司的收购、遗留系统的数据质量，甚至只是尝试集成项目的预期劳动力成本。在 2008 年金融危机期间，许多银行面临的主要挑战之一是无法及时汇总整个组织的风险敞口。获取所有业务线和法律实体的总风险敞口可能需要数周时间，而不是数小时。随着危机在 2008 年秋季迅速恶化，这使得银行大大低估了它们对某些市场事件和交易对手的风险敞口。
Tableau 等 自助式分析工具 越来越受欢迎，这增加了在数据库中管理数据的必要性。这些工具旨在让最终用户能够“以思考的速度”直观地从数据仓库中查询数据，并快速可视化结果。这种类型的功能允许用户对数据进行多次不同的迭代，以真正探索数据并产生独特的见解。当底层数据库表没有被正确管理时，这些工具不能很好地工作。
数据监管的好处是什么？
- 有效的数据监管流程或策略可以让组织在数据准备上花费更少的时间和金钱，而有更多的时间来回答业务问题。
- 查看跨业务线报告可以帮助组织了解其风险，并准确衡量外部事件对运营的影响。
- 结构合理的数据可以有效利用自助服务分析工具，帮助业务用户获得洞察力，而无需额外开发新的仪表板和报告。
有序逻辑回归
R 中的概述和实现
Fig 1: Performance of an individual — Poor, Fair, Excellent
你能猜出下面提到的变量中有什么共同联系吗:
- 工作满意度— 不满意、满意、高度满意
- 个人表现— 差、一般、优秀
- 监管对银行绩效的影响— 正面、中性、负面
变量不仅是分类的，而且它们也遵循一个顺序(从低到高/从高到低)。
如果我们想预测这样的多类有序变量那么我们可以使用 比例优势逻辑回归 技术。
目标
为了理解有序逻辑回归的工作原理，我们将考虑世界价值观调查的一项研究，该研究着眼于影响人们对政府减贫努力的看法的因素。
我们的目标是根据个人的国家、性别、年龄等因素，预测个人对政府减贫努力的看法。在给定的案例研究中，个人的感知可以取以下三个值- 太少、大约合适、太多。
在我们的分析中，我们将使用来自澳大利亚、挪威、瑞典和美国的世界价值观调查数据。
**library(carData)
library(MASS)****data(WVS)
head(WVS)**
Fig 2 — Dataset
数据的描述
贫困是多级有序因变量，分类为“太少”、“差不多”和“太多”。我们有以下五个独立变量
- 宗教:宗教成员——否或是
- 学位:拥有大学学位——否或是
- 国家:澳大利亚、挪威、瑞典或美国
- **年龄:**年龄(岁)
- 性别:男性或女性
现在让我们分析这个数据集的描述性统计数据:
**summary(WVS)**
Fig 3 — Descriptive Statistics
我们还可以分析不同年龄、性别和国家的贫困分布
ggplot(WVS, aes(x = poverty, y = age, fill = poverty)) + geom_boxplot(size = .75) + facet_grid(country ~ gender, margins = FALSE) + theme(axis.text.x = element_text(angle = 45, hjust = 1, vjust = 1))
拟合模型
我们现在将使用质量包中的 polr 函数来拟合比例优势逻辑回归模型。
**model_fit <- polr(poverty~religion+degree+country+age+gender, data = WVS, Hess = TRUE)
summary(model_fit)**
Fig 4 — Model Summary
在上面的输出中，我们得到了关于
- 模型方程
- 回归系数及其值、标准误差和 t 值。默认情况下没有显著性检验，但我们可以通过将 t 值与标准正态分布进行比较来计算 p 值。
- 两次截距的估计值
- 剩余偏差和 AIC，用于比较不同模型的性能
系数和截距的重要性
**summary_table <- coef(summary(model_fit))
pval <- pnorm(abs(summary_table[, "t value"]),lower.tail = FALSE)* 2
summary_table <- cbind(summary_table, "p value" = round(pval,3))
summary_table**
Fig 5 — Model Significance
由于所有变量的 p 值<0.05, hence they are statistically significant at 95% CI
解释了比例优势模型
为了解释这个模型，我们首先需要理解比例优势模型的工作原理。
设 J 为因变量的总类别数，M 为自变量的个数(在给定的数据集中，J=3，M = 5)。
比例优势模型的数学公式如下所示
Fig 6 — Equation for Proportional Odds Model
这里，J 是具有 J 个级别的有序范畴的级别，I 对应于独立变量
在我们的情况下
- j = 1 表示“太少”
- j = 2 表示“大约正确”
- j = 3 表示“太多”
- i = 1 指“宗教”
- i = 2 表示“程度”
- i = 3 表示“国家”
- i = 4 表示“年龄”
- i = 5 表示“性别”
解释图 4T3 中的模型统计
系数:
- 像性别这样的分类变量可以解释为:与女性个体相比，男性个体更有可能对政府的减贫努力产生积极的看法。t 值大于 2，因此在 5%的水平上具有统计学意义。
- 像年龄这样的连续变量可以解释为:年龄每增加一个单位，对政府减贫努力持正面看法的概率对数就增加 0.011
截距:
- 数学上，截距’**过小|左右’**对应 logit[P(Y ≤ 1)] 。它可以被解释为相信政府做得“太少”与相信政府做得“差不多”或“太多”的概率对数
- 同样，截距’**左右|太多’**对应 logit[P(Y ≤ 2)] 。它可以被解释为相信政府做得“太少”或“差不多”与相信政府做得“太多”的概率对数
对新数据进行预测
假设我们想要预测与具有以下特征的个人的每个感知相对应的概率
- 宗教:是的
- 学位:否
- 国家:挪威
- 年龄:30 岁
- 性别:男
- 数学计算
通过使用模型摘要中的截距和斜率值，我们可以按以下方式估计期望的概率
对应于太少感知的概率将被计算为:
logit[P(Y≤1)]= 0.7298-[(0.17973 * 1)+(0.14092 * 0)+(-0.32235 * 1)+(0.01114 * 30)+(0.17637 * 1)]
=> logit[P(Y ≤ 1)] =0.36185
= > P(Y≤1)= exp(0.36185)/(1+exp(0.36185))= 0.589
在我们的例子中， P(Y ≤ 1) = P(Y =1) = 0.589
类似地，对应于右感知的的概率将被计算为:
logit[P(Y≤2)]= 2.5325-[(0.17973 * 1)+(0.14092 * 0)+(-0.32235 * 1)+(0.01114 * 30)+(0.17637 * 1)]
=> logit[P(Y ≤ 2)] =2.16455
= > P(Y≤2)= exp(2.16455)/(1+exp(2.16455))= 0.897
因此，P(Y = 2)= P(Y≤2)—P(Y≤1)= 0.897-0.589
=> P(Y = 2) = 0.308
对应于感知过多的概率将被计算为:
因此，P(Y = 3) = 1-P(Y ≤2)
= > P(Y = 3) = 0.103
2。在 R 中计算
幸运的是，我们可以通过使用 R 中的预测函数来绕过上面的数学计算
**new_data <- data.frame("religion"= "yes","degree"="no","country"="Norway","age"=30,"gender"="male")****round(predict(model_fit,new_data,type = "p"), 3)**
Fig 7 —Model Prediction
我们的模型预测，个体测试者认为政府减少贫困的努力太少
如果您希望了解更多关于这一概念的信息，我建议您访问以下链接:
- https://stats . idre . UCLA . edu/r/DAE/ordinal-logistic-regression
- http://data . library . Virginia . edu/fitting-and-interpreting-a-proportional-odds-model
谢谢！
用 Postgres 和 Python 实现自动完成
(linguistics something linguistics) Photo by Skyler Gerald on Unsplash
介绍
No, she hasn’t learned Python yet. © alphabet inc
如果没有某种自动完成功能，搜索引擎看起来几乎是不完整的。这里有一个从头构建你自己的自动完成的快速指南。我们将使用 Python，Postgres 和 Spacy。弹性搜索是 Postgres 的一个非常好的替代品，但是对于不涉及数百万行的简单任务，Postgres 尽管没有内存能力，但也不算太差。这里的是一篇强调两者区别的有趣文章。
我们将遵循的流程概述:
- 处理文本数据以提取搜索时弹出的相关短语。
- 将这些数据存储在搜索优化的实体化视图中。
- 创建相关索引。
- 查询该视图并解析自动完成的结果。
提取关键短语
Spacy 提供了一个工业级的文本解析框架。我们将使用它从文本中提取名词块。代码就像这样简单:
Extraction of noun chunks
此外，您可以使用 Python 的Counter来计算这些短语的频率，用于排名和其他目的。下面的代码片段还显示了一个 pg 查询，用于在数据库中插入这些短语，并在发生冲突时采取必要的措施。在我们的例子中，我们通过添加新发现的短语来更新现有短语的频率。
Storing the noun chunks
对于事务性目的，表更适合。我们将把这个表的精选版本放入一个物化视图，用于分析任务，比如搜索。
物化视图
了解 Postgres 提供的不同类型的视图之间的区别是很重要的，我们将会看到两种类型:(普通)视图和物化视图。
物化视图将它包含的数据存储在磁盘上，而普通视图在每次查询视图时运行底层查询。这意味着物化视图必须定期刷新。刷新 es 既可以手动进行，也可以通过主表上的触发器或监听/通知系统之类的机制进行。我们暂时不讨论这个问题。
主表*prompts* 看起来如下:
You can add several conditions on the types of phrases that you want: ngram size, presence of certain POS tags, all phrase as lowercase text, excluding certain stop-words, and so on.
这里的*，id* 是这个表的主键。在 ngram 字段上有一个唯一的约束，类型为 varchar(256)。我们不希望关键词太长，因此太具体。
我们现在将创建这个表的物化视图，并在这个视图上建立一个索引。对底层提示表的任何更改都可以通过简单地刷新该视图来解决。
Creation, Indexing and Refreshing of a Materialized View
对于生产级应用程序，请查看并发刷新视图。
获取提示
有几种搜索视图的方法，我们将坚持使用下面的方法:
select ngram from <schema_name>.mv_prompts
where tsquery('charges' || ':*') @@ to_tsvector(ngram)
limit 10
另一个巧妙的技巧是在查询的tsquery(‘charges’ || ‘:*’)部分包含|| ‘:*’。这也可以通过正则表达式搜索得到不完整单词的搜索结果！
搜索结果
这里，’ charges’ '是一个示例搜索词。我们有一个关于to_tsvector(ngram)的索引，这将优化搜索。
查询执行时间:109 毫秒。
注意:此搜索词仅检索到 9 个结果。
Prompts for search term ‘charg’
下图显示了搜索术语’ charg '的前 10 个结果。这完全符合我们的目的，因为除了搜索*“费用”得到的提示外，我们还得到类似于“应支付利息”和“应支付会计期间”*的提示。
查询执行时间:182 毫秒。
没有通配符搜索应该会缩短执行时间，但也会限制结果的数量。这是一个应用程序特有的功能。
用一个 API 把它包装起来
(i had a nice dad joke about hitting a space-bar after long day at work, turns out everyone is paranoid about potential copyright infringement and i could not find the source for the original dad joke. So here, enjoy this mildly futuristic bar 😕). Photo by Skyler Gerald on Unsplash
后端现已准备就绪。现在我们需要反复调用 API 端点来获取用户输入的搜索建议。从前端应用程序中获取方法应该能行。这个调用可以在每次按键、按下空格键、输入延迟达到某个阈值或者这些情况的任意组合时触发。
包扎
带有 Flask API 处理程序和后续数据库查询的 Python 脚本如下所示:
We done yet?
在活动
Straight outta iOS! © ME 😎
进一步的部分包括包括相关的动词短语，解析以保持语义的相似性，以及理解为什么媒体不允许作者定制他们的媒体。
二元逻辑回归
R 中的概述和实现
Customer satisfaction for a product — Satisfied vs Dissatisfied (Source: pixabay.com)
你有没有遇到过这样的情况，你想预测一个二元的结果，比如:
- 一个人对一个产品是否满意？
- 一个考生是否会被研究生院录取？
- 两位总统候选人中谁会赢得选举？
- 飞机是否会在预定时间到达目的地？
一个非常简单的机器学习算法将会拯救你，那就是逻辑回归。
逻辑回归是一种分类算法，当我们想要基于一组独立变量预测分类变量(是/否，通过/失败)时使用。
在逻辑回归模型中，因变量的比值对数被建模为自变量的线性组合。
让我们使用 R. 中的一个实际例子来更清楚地了解二元逻辑回归
考虑这样一种情况，您希望根据血糖浓度、血压、年龄等特征将一个人归类为糖尿病或非糖尿病患者。
数据描述
对于我们的分析，我们将使用来自 R 中的 mlbench 包的皮马印第安人糖尿病数据库
**install.packages('mlbench')
install.packages('MASS')
install.packages('pROC')****library(mlbench)
library(MASS)
library(pROC)****data(PimaIndiansDiabetes2)
head(PimaIndiansDiabetes2)**
糖尿病是该数据集中的二元因变量，分类为 pos/neg。我们有以下八个独立变量
- 怀孕:怀孕次数
- 葡萄糖:血浆葡萄糖浓度(葡萄糖耐量试验)
- 压力:舒张压(毫米汞柱)
- 三头肌:皮褶厚度(mm)
- 胰岛素 : 2 小时血清胰岛素(μU/ml)
- 体重:体重指数(体重公斤/(身高米) )
- 谱系:糖尿病谱系功能
- 年龄:年龄(岁)
现在让我们分析该数据集的描述性统计数据:
**summary(PimaIndiansDiabetes2)**
从汇总统计数据中可以明显看出，数据集中存在某些缺失值，它们被突出显示为 NA。
作为一种保守的措施，我们可以删除这样的观察。
**newdata <- na.omit(PimaIndiansDiabetes2)
summary(newdata)**
我们来分析一下各个自变量的分布情况:
**par(mfrow = c(4,2))****for( i in 1:8){
hist(newdata[,i], main = colnames(newdata)[i],xlab = colnames(newdata)[i], col = 'yellow')
}**
Histogram of independent variables
从上面的直方图来看，很明显变量——怀孕和年龄是高度倾斜的，我们可以分桶分析它们。
对于年龄，我们可以创建以下四个时段:20–30 岁、31–40 岁、41–50 岁和 50 岁以上
**newdata$age_bucket <- as.factor(ifelse(newdata$age<=30,"20-30",ifelse(newdata$age<=40,"31-40",ifelse(newdata$age<=50,"41-50","50+"))))**
对于怀孕的人，我们可以创建以下三个桶:0-5，6-10 和 10+
**newdata$preg_bucket <- as.factor(ifelse(newdata$pregnant<=5,"0–5",ifelse(newdata$pregnant<=10,"6–10","10+")))**
对于连续的自变量，我们可以通过分析它相对于因变量的分布来得到更清晰的分布。
**par(mfrow = c(3,2))****boxplot(glucose~diabetes, ylab="Glucose", xlab= "Diabetes", col="light blue",data = newdata)****boxplot(pressure~diabetes, ylab="Pressure", xlab= "Diabetes", col="light blue",data = newdata)****boxplot(triceps~diabetes, ylab="triceps", xlab= "Diabetes", col="light blue",data = newdata)****boxplot(insulin~diabetes, ylab="Insulin", xlab= "Diabetes", col="light blue",data = newdata)****boxplot(mass~diabetes, ylab="Mass", xlab= "Diabetes", col="light blue",data = newdata)****boxplot(pedigree~diabetes, ylab="Pedigree", xlab= "Diabetes", col="light blue",data = newdata)**
Box Plot for Continuous Independent Variables
从上面的图中，我们可以推断糖尿病患者的葡萄糖含量中位数更高。对于其余的变量，可以得出类似的推论。
对于分类自变量，我们可以分析每个分类因变量的频率
**xtabs(~diabetes + age_bucket, data = newdata)
xtabs(~diabetes + preg_bucket, data = newdata)**
我们现在将创建一个相关建模变量的新数据框。
**newdata2 <- newdata[,c("diabetes","glucose","pressure","triceps","insulin","mass","pedigree","age_bucket","preg_bucket")]**
实施逻辑回归以预测数据集“新数据 2 ”中的二元结果——糖尿病。
**logit_1 <- glm(diabetes~., family = binomial,data = newdata2)**
模型总结分析
**summary(logit_1)**
汇总统计数据通过提供以下信息帮助我们更好地理解模型:
- 偏差残差的分布
- 截距和斜率估计值以及标准误差、z 值和 p 值
- AIC 值
- 剩余偏差和零偏差
结果解读
对于 连续变量 ，解释如下:
葡萄糖**每增加一个单位*，糖尿病【阳性】(相对于糖尿病【阴性】)的对数几率增加0.039。
同样，压力每增加一个单位*，患糖尿病【阳性】(相对于患糖尿病【阴性】)的对数几率减少 0.0045。****
对于 分类变量 ，每个类别的表现都以基本类别为基础进行评估。变量“age_bucket”的基本类别是 20–30，变量“preg_bucket”的基本类别是 0–5。这些变量的解释如下:
处于 31-40 岁的年龄段相对于 20-30 岁年龄段，患糖尿病“阳性”(相对于患糖尿病“阴性”)的对数几率变化 0.854。**
处于 6-10 的怀孕区间相对于 0-5 的怀孕区间，患糖尿病“阳性”(相对于患糖尿病“阴性”)的对数概率变化了-0.24。**
变量选择
对于给定的一组独立变量，模型“logit_1”可能不是最佳模型。
变量选择有多种方法。在本文中，我们将只探索“stepAIC”函数。
R 中的“stepAIC”函数执行逐步模型选择，目标是最小化 AIC 值。
***logit_2 <- stepAIC(logit_1)***
为新创建的具有最小 AIC 的模型分析模型摘要
***summary(logit_2)***
实现“stepAIC”函数后，我们现在剩下四个独立变量—葡萄糖、质量、谱系和 age_bucket。在所有可能的模型中，这个模型(logit_2)具有最小的 AIC 值。
此外，入围变量非常重要。
结果分析
为了分析将“糖尿病”的值作为“pos”的预测概率，我们可以使用如下的汇总函数
***summary(logit_2$fitted.values)***
我们还可以分析“pos”糖尿病的预测概率的分布。
***hist(logit_2$fitted.values,main = " Histogram ",xlab = "Probability of 'pos' diabetes", col = 'light green')***
现在，如果拟合值超过 0.5，我们将预测分类为“正”，否则为“负”。
***newdata2$Predict <- ifelse(logit_2$fitted.values >0.5,"pos","neg")***
模型性能评估
我们现在可以使用以下参数评估模型的性能:
- AIC
AIC 代表 Akaike 信息标准。它是类似于调整后的 R，是惩罚模型自变量数量的拟合度。我们总是喜欢最小 AIC 值的模型。
我们可以比较原始模型 logit_1 和由阶梯函数导出的模型 logit_2 的 AIC。
***logit_1$aic
logit_2$aic***
正如所料，由阶梯函数导出的模型对应于较低的 AIC 值。
2。混乱矩阵
它是观察值与预测值的表格表示。它有助于量化模型的效率(或准确性)。
现在让我们比较“糖尿病”的观察值和预测值:
***mytable <- table(newdata2$diabetes,newdata2$Predict)
rownames(mytable) <- c("Obs. neg","Obs. pos")
colnames(mytable) <- c("Pred. neg","Pred. pos")
mytable***
***efficiency <- sum(diag(mytable))/sum(mytable)
efficiency***
从混淆矩阵来看，我们的模型的准确率为 81.4%。
3。ROC 曲线
ROC 代表接收机工作特性。它通过评估敏感性和特异性来解释模型的性能。
***roc(diabetes~logit_2$fitted.values, data = newdata2, plot = TRUE, main = "ROC CURVE", col= "blue")***
ROC 曲线下的面积是准确性的指标。曲线下的面积越大，模型的预测能力越强。
完美预测模型的 AUC 等于 1。
***auc(diabetes~logit_2$fitted.values, data = newdata2)***
模型’ logit_2 的曲线下面积为 0.863。
在下一篇文章中，我们将学习另一种广泛使用的逻辑回归技术— 有序逻辑回归
谢谢！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
