如何使用基于 RFM 的细分来识别最佳客户
最好的客户并不总是我们所说的高价值客户
基于 RFM 分析的客户细分(气泡大小代表每个细分市场的平均总收入)
在新冠肺炎·疫情，我手头有了一些空闲时间，于是我决定做无偿咨询工作。我在帮助一些电子商务公司分析他们的客户数据。我在工作中遇到的一个常见主题是，这些公司更感兴趣的是获得他们最好的客户名单，这样他们就可以开展一些营销活动来增加收入。我的建议一直是，每个客户群都有一些有价值的见解可以提供，并且最佳客户取决于当前的公司目标/目的。换句话说，最佳客户并不总是我们所说的高价值客户。在这篇文章中，我将强调 RFM 细分可以提供的各种见解。
使用 RFM 分析的分割
基于 RFM 的分析——代表新近性、频率和货币——可能是细分客户的最简单方法之一，因为公司通常随时可以获得客户购买信息。
这里有一个样本客户购买历史数据，这是 RFM 分析需要的。这样，每位顾客的 RFM 属性都得到了 1-5 分(或 1-4 分或 1-3 分，取决于你对购买行为的观察程度)，1 分最低，5 分最高。
用于 RFM 分析的客户购买历史数据示例
例如，最近一次购买的客户在最近性上的得分为 5，而一段时间没有购买的客户的得分为 1。
这里需要注意的重要一点是，评分标准因业务而异，通过了解客户购买周期，我们可以得出评分标准。对于这个样本数据，我使用了以下基于 2 个月购买期的最近得分。一旦你对所有三个属性进行评分，我们就可以创建 RFM 评分(这三个评分的总和)和 RFM 类别(当 R=4，F=3，M=4，RFM 类别= 434)。你可能已经看到过 RFM 分数被用来细分客户的例子。这种方法有一些严重的缺陷，最好使用 RFM 类别。
使用 5 分制可以导致多达 125 个 RFM 类别。下一步是将这些 RFM 类别分成不同的部分。虽然标准的 RFM 分析没有考虑其他数据点，如客户关系的时间长度，但这是整体查看购买数据并为 RFM 类别分配细分的时候了。例如，与业务有长期关系、最近购买但金额较低的客户可能比与我们有类似近期、金额但频率较低且关系较短的客户更频繁地使用促销优惠。一个可以被划分为交易寻求者，另一个可以被划分为新人。
RFM 细分后的客户数据
在上面的例子中，我确定了 6 个具有独特购买行为的细分市场。
辍学者:换句话说，他们是流失的顾客。他们通过最初的促销优惠成为我们的客户，要么没有回来，要么进行了 1-2 次后续购买。
早期爱好者:这些顾客和公司在一起的时间比中途退出的顾客相对要长，他们经常购物，花很多钱。然而，他们一路上都迷路了。如果目标是重新激活流失的客户，这些客户将是最佳客户。
新人:顾名思义，这个细分市场由相对较新且活跃的客户组成。针对这一细分市场的任何营销努力都可能是向他们推广忠诚度计划或提供尝试其他产品的促销活动。
交易寻求者:这些客户与公司的关系相对较长，目前很活跃。他们对频繁购买感兴趣，但通常会留意促销优惠。如果开展促销活动，这些人将是最佳客户。
潜在高价值客户:与交易寻求者相比，这些客户相对较新，但对价格不太敏感，或者对促销优惠不太感兴趣。在更短的时间内，他们频繁购买，花了公司很多钱。将他们推向高价值客户，并让他们加入忠诚度计划。
高价值客户:这些是最忠诚的客户。他们购买频繁，货币价值高。他们可能是品牌传播者，应该专注于服务好他们。他们可能是获得任何新产品发布反馈的最佳客户，或者是早期采用者或推广者。
从可视化中获得洞察力
一旦使用 RFM 分析确定了客户群，将这些客户群可视化总是一个好主意，这不仅是为了进行健全性检查，也是为了获得可操作的见解。我用 Tableau 来显示片段。
R&F 得分的每用户平均收入(ARPU)矩阵
新近和频率得分矩阵图通常是一个很好的健全性检查。随着 R 分数和 F 分数的增加，货币价值增加。考虑到企业最近可能获得了新客户，较高的 R 分数不一定会带来较高的货币价值。
每个客户群总收入的树形图
树形图显示了每个客户群对总收入的贡献，以及给定客户群中的每个客户对总收入的贡献。在某种程度上，这有助于预测在有多少客户和其他细分市场有多活跃的情况下，收入会有多稳定。
当客户有地理信息时，将它们标在地图上会给出一些独特的见解。我见过的一个有趣的案例是一家有一些零售业务的电子商务公司。绘制客户地理数据有助于解释该公司零售店所在地理区域的在线购物者集群。有趣的是，这些在线客户群是有机获得的。因此，您可以评估扩大零售业务的策略，这可能会促进电子商务业务的发展。
按细分市场划分的客户地理分布(气泡大小代表客户的总销售额)
总收入和客户数量方面的渠道绩效
还有就是渠道表现。客户细分有助于更好地了解渠道绩效。通过查看每个细分市场的客户终身价值(LTV ),以及每个细分市场的哪一部分属于某个渠道，以及与该渠道相关的获取成本，我们可以比没有细分市场时更准确地评估渠道绩效。
最后
通常，初创公司更倾向于增长，而不是保留。即使资源有限，创业公司最好将有限的资源投入到了解现有客户上，这样他们就可以制定有效的保留策略，从而帮助他们获得新客户。毕竟，留住现有客户可能比获得一个新客户要便宜得多。口碑仍然是一个主要的客户获取渠道，你希望你的客户成为你产品的传播者。
客户细分的牛眼图
重申对最佳客户的追求，高价值客户就是最佳客户似乎是显而易见的。当手头有一个目标时——比方说开展一场营销活动来增加收入——我们应该更深入地挖掘，找出谁是该特定目标的最佳客户，或者哪个客户群处于靶心。
如何识别数据科学就业市场上最需要的数据科学技能
使用抓取和自然语言处理从招聘广告中提取信息
做一个好看的字云不是必备技能，但应该是。
几天前，我的 LinkedIn 网络中的一名技术招聘人员发布了一个请求，要求为未来的数据科学家推荐学习资源。她希望确保候选人获得适合当今市场的技能。在她收到的回复中，许多是轶事(“我做了这个……我学到了那个”)，暗示了一套常见的在线学习平台，而其他人则包含通用的建议，如“练习编码面试”或“试试 Kaggle 竞赛”。
我想:**这个没用。我如何能同时做所有这些事情？现在有没有更好的方法来收集就业市场上最需要的技能的有用信息？**作为一名数据科学新人，我感觉自己在追逐市场，根据我在招聘广告上最常看到的(或我认为我看到的)内容，或根据我在面试中被问到的问题，挑选新项目或学习材料。
我决定向前迈出一步，自己找出答案:在这个项目中，我从一个流行的求职网站上收集了一些职位描述，以找出其中反复出现的关键词，哪些与可获得的技能相对应，以及它们如何(以及是否)与广告上的工资相关联。
项目结构
该项目分为三个主要部分:
- 数据采集:识别信息来源，抓取相关招聘广告网页，保存内容；
- 数据操作:职位描述中包含的文本通过词干清理，并矢量化；
- 数据分析和结论:与关键技能相对应的最频繁出现的词被识别，并且与广告工资的相关性被调查。
你可以在这里找到项目的代码。
数据采集
这个过程的第一步是确定信息的来源，选择合适的工具并获取信息。作为一个来源，我选择了 reed.co.uk 的 T4，因为它容易导航，细节丰富，并且在我的地区很受欢迎。
使用美汤，我做了一个简单的脚本，当我在伦敦和 20 英里范围内搜索【数据科学家】职位时，抓取了一定页数结果的招聘广告。该脚本保存搜索结果，然后访问每个招聘广告对应的页面，并以 JSON 格式存储职位描述、工资、合同类型和位置信息。每个职务都由一个参考号标识，如果某些职务在搜索中出现多次(例如，如果被提升)，它们将只保存一次。
数据操作
文本操作和分析的工具并不缺乏，因为 NLP 是目前机器学习最流行的应用之一(查看这里和这里关于这个主题的一些有趣的见解)。我个人的学习建议是看一下 fastAI 在线资料，涵盖了 fastAI 库等等。
招聘广告描述包含不同词形变化(主要是复数和-ing 后缀)、标点符号和停用词。它们都可以被清理掉，只留下那些可能传达有用信息的文字。作为第一步，我使用了 nltk 包对文本执行词干提取，删除了单词的变形和大写字母。
原文与其词干版本和词条版本的比较。词汇匹配需要知道每个单词的位置才能正常工作，因此例如单词“口语”和“理解”以大写字母开始，并被视为名词，而不被转换为“口语”和“理解”。
词干提取的另一种方法是词汇匹配，它根据意思而不是拼写来减少单词。我决定使用词干，因为我的目的是分离文本中的单词，而不是研究文本的含义。
第二步是使用 scikit learn 中的 TF-IDF 矢量器函数对我的文本进行矢量化，该函数返回一个包含所分析文本中所有单词的词汇表，以及一个针对每个工作广告描述的矢量，该矢量包含每个词干单词的术语频率乘以逆文档频率(因此 TF-IDF)的值，该值突出显示有意义的单词，有利于高度重复出现的单词，如“The”、“a”、“is”等。
图中的矩阵包含被分析文本语料库的 TF-IDF 值。每行对应一个工作描述文本，每列对应语料库词汇表中的一个单词。
简单来说，TF-IDF 值矩阵的每一行对应于我们目标的一个观察(一个工作广告描述)，每一列对应于一个给定变量(我们词汇表中的一个词)的值，它的值对应于变量的值。
这对于描述职位描述非常有用，我们可以用它来找到最常用的词，看看它们是否与其他因素相关，比如工资。
最常见的关键技能
整个职位描述语料库中最常见的单词可以通过对矩阵的列求和来识别，得到每个单词的累积值。我对结果进行了过滤，去掉了一些无处不在的词，比如“数据”和“工作”。在分析的时候，我可以观察到，大致按顺序并按亲和力分组:
求职广告中的词干及其相对重要性分数。
- 历练，而学长(比学弟多得多)；
- 产品，市场；
- 建模，统计；
- Python ，SQL；
- NLP ，机，学，深，学；
- AWS；
- 研究，洞察，分析。
令我惊讶的是，计算机视觉、金融科技和社交媒体在某种程度上并不常见。从技术角度来看，NLP 和 SQL 以及对 AWS 的熟悉是值得学习的技能。
如果你是大三或者初入市场(像我一样)，那么你大概不会喜欢看到“经验”排在首位，但它与市场趋势是一致的。
从绝对意义上来说，我们可以看看某些关键词在招聘广告中出现的频率，并使用获得的数字作为我们决策过程的衡量标准。
在 167 份分析的招聘广告中，就业类型的分布(a)，职位描述中“高级”一词的出现(b)，以及一些关键技能的出现©。
作为一个例子，我统计了合同和固定工作的出现,“高级”一词的出现，以及工作描述中一些关键技能的出现。请注意，如何从简单的词汇分析中，收集关于特定技能重要性的有价值的信息是可能的。
与工资的相关性
我的计划是定义一个数据获取方案，从数百个招聘广告中收集信息，并探索建立回归模型来估计工资的可能性。我正在测试这个想法的可行性，方法是评估所报告的工资信息的质量，并查看任何关键词的出现是否与工资相关。
工作广告页面包含了在一个明确定义的领域中的建议工资范围的信息，这是很容易阅读的。然而，薪水数字经常被替换为“有竞争力的薪水”，“薪水面议”，或类似的表达。在兴趣的情况下，69%的值不幸丢失。另一个复杂因素是，全职工作的工资是按年报告的，而承包商工作的工资是按日报告的，税收制度的差异使得比较变得棘手。
我们可以通过创建一个表来检查薪水是否与任何关键字相关，该表包含每个工作的薪水数字和对应于关键技能的 TF-IDF 矩阵的子集，并使用 Pandas corr() 方法来获得相应的相关矩阵。
相关聚类热图(参见 seaborn 的指南，了解如何用相关关键词制作一个)的“薪水”。
在聚类相关矩阵中，相关的数量彼此相邻，因此很容易发现。在这种情况下，任何两个变量之间的最小相关分数都高于-0.25，这意味着没有显著的负相关。关于正相关，我们感兴趣的是白色到红色的方块。树状图显示了变量是如何逐步聚类的。
最明显的相关性是在 Python 和 SQL 之间，它们可能经常在详细描述其需求的工作描述中出现，以及深度(学习)与 NLP 和视觉之间的相关性，这是 NLP 和计算机视觉神经网络的两个最流行的应用。其他可见的关联是在机械(电子学习)和统计学家(ics) 之间，以及产品和市场之间。
工资呢？它与 financ(e) 的相关性很弱，这可能说明了薪酬最高的部门，但这不是足够的证据。
**注意:**聚类图也非常有用，可以直观地感受到所选关键词在职位描述语料库中的分布情况，如何基于这些关键词进行聚类，以及职位描述之间如何进行聚类。例如，你可以看到关键词 experience 和 python 几乎均匀地分布在整个语料库中，而其他关键词，如 NLP 和 vision ，则更加集中(详见我的地图)。
结论
在这篇文章中，我展示了我的智能求职方法，使用基本的网络搜集和 NLP 技术来收集对就业市场的见解。根据结果:
- 我会考虑投资时间来提高我的 NLP 和 SQL 技能。
- 我会特别注意用现实生活中的项目来丰富我的投资组合，从而增强我在该领域的经验。
- 我还会致力于我的分析和研究技能，创造我自己的问题来解决，并从中产生有价值的见解。
进一步的工作
这在很大程度上是一个开放式项目，因为所获得的信息取决于当时的情况，并将随着时间的推移而变化，并且可以在许多不同的层面上进行分析。例如，有趣的是:
- 根据内容对招聘广告进行聚类，以找到关键词和数量或工作特征之间的进一步联系。
- 开发一个工作工资回归预测器，收集大量的工资值观察值，并正确比较不同类型合同的薪酬。
希望我在这里描述的工作能对别人有用。如果你想谈论它，请随时联系。
关于我
我是一名数据科学家，目前正在寻找新的机会。在过去的几年里，我一直致力于空间应用的量子技术。
GitHub:https://github.com/RaffaToSpace
领英:https://www.linkedin.com/in/raffaele-nolli-581a4351/
机器学习监督算法如何识别正确的自变量？
在计算机科学领域有一个非常著名的缩写词 GIGO ，这是我在学生时代学过的。 GIGO 代表垃圾进出。本质上，这意味着如果我们向计算机程序和算法提供不适当的垃圾数据，那么它将导致垃圾和不正确的结果。
机器学习算法和我们人类是一样的。广义的机器学习算法有两个阶段——学习和预测。
学习环境和参数应与未来要做预测的条件相似。在无偏数据样本上训练的算法和输入变量值的排列真实地反映了全部人口数据集，能够很好地进行准确的预测。
监督机器学习算法成功的基石之一是为学习阶段选择正确的独立变量集。在本文中，我将讨论一种结构化的方法来选择正确的独立变量来输入算法。我们不希望过多输入冗余数据点，即高度相关(多重共线性)数据，并在不提高预测准确性的情况下使模型复杂化。事实上，有时过多的数据会降低预测的准确性。另一方面，我们需要确保模型不会过于简单，并反映真实的复杂性。
目标
我们想建立一个模型来预测 ASML 公司的股票价格。我们已经下载了过去 20 年来 ASML 的一些客户、竞争对手和指数点的股价数据。我们不确定在构建 ASML 股票预测模型时应该包括这些数据点中的哪一个。
样本数据文件
我写了一个小函数，我可以从不同的程序调用它来下载过去 20 年的股票价格。
"""Filename - GetStockData.py is a function to download the stock from 1st Jan 2000 until current date"""import datetime as dt
import pandas as pd
import pandas_datareader.data as web
import numpy as npdef stockdata(ticker): start= dt.datetime(2000,1,1) ## Start Date Range
end=dt.datetime.now() ## Curret date as end date Range
Stock=web.DataReader(ticker, "yahoo", start, end)
name=str(ticker) + ".xlsx"
Stock.to_excel(name)
return ()
从另一个带有股票代码的程序调用函数 stockdata()来下载数据。
""" Filename - stockdownload.py"""
import GetStockData
ticker= ["MU", "ASML","TSM","QCOM", "UMC", "^SOX", "INTC","**^**IXIC"]
for i in ticker:
GetStockData.stockdata(i)
请注意，GetStockData python 文件和 stockdownload.py 文件放在同一个文件目录中，以便成功导入文件。
第一步- 第一步是想到所有可能影响因变量的变量。到了这一步，我会建议不要约束自己的思维，大脑转储所有的变量。
第二步- 下一步是收集/下载预期自变量数据点进行分析。
我已经将下载的数据格式化并整理成一个 excel 文件“StockData.xlsx”
过去 20 年的股票价格数据—从 2000 年 1 月到 2020 年 8 月
步骤 3- 我们将导入包 pandas、matplotlib、seaborn 和 statsmodels 包，我们将使用这些包进行分析。
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.stats.outliers_influence import variance_inflation_factor
步骤 4- 将完整的数据样本数据 excel 文件读入名为“数据”的 PandasDataframe 中。此外，我们将用日期列替换索引
data=pd.read_excel("StockData.xlsx")
data.set_index("Date", inplace= True)
我不会关注初步的数据质量检查，如空白值、异常值等。和各自的修正方法，并假设不存在与差异相关的数据序列。
第 5 步- 开始理解自变量之间关系的最好地方之一就是变量之间的相关性。在以下代码中，使用绘制了关联的热图。熊猫的 corr 方法。
sns.heatmap(data.corr(), annot=True, cmap="YlGnBu")
plt.show()
如下所示，相关性热图为我们提供了变量之间关系的可视化描述。现在，我们不想要一组与因变量有或多或少相似关系的自变量。例如，TSM 和纳斯达克指数与 ASML 的相关系数分别为 0.99 和 0.97。包括 TSM 和 NASDAQ 可能不会提高预测的准确性，因为它们与因变量 ASML 股票价格有类似的关系。
第 6 步- 在我们开始舍弃多余的自变量之前，让我们检查一下自变量中的方差膨胀因子 ( VIF )。VIF 在普通最小二乘回归分析中量化了多重共线性的严重程度。它提供了一个指标来衡量估计回归系数的方差(估计值的标准差的平方)因共线性而增加的程度。我鼓励你们大家阅读维基百科上关于方差膨胀因子的页面，以便更好地理解它。
在下面的代码中，我们计算每个独立变量的 VIF 并打印出来。我们将创建一个没有 ASML 历史股票价格的新数据框架，因为我们的目标是确定潜在自变量中的 VIF。
X=data.drop(["ASML"], axis=1)
vif = pd.DataFrame()
vif["features"] = X.columns
vif["vif_Factor"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]
print(vif)
一般来说，我们的目标应该是自变量的 VIF 小于 10。我们已经从之前的热图中看到，TSM 和 NASDAQ 与 ASML 有相似的相关系数，同样也反映了高 VIF 指标。
基于我们对热图和 VIF 结果的理解，让我们放弃纳斯达克(最高的 VIF)作为我们模型自变量的潜在候选，重新评估 VIF。
X=data.drop(["ASML","NASDAQ"], axis=1)
vif = pd.DataFrame()
vif["features"] = X.columns
vif["vif_Factor"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]
print(vif)
我们可以看到，除去纳斯达克，VIF 的其他几个潜在的独立公司也减少了。
选择独立变量的正确组合需要一点经验，还要用不同的排列进行试错 VIF 检验。TSMC 是世界领先的半导体代工厂，作为 ASML 的客户，对 ASML 的业务有很大的影响。考虑到这一点，我将放弃“INTC”和“PHLX ”,并重新评估剩余变量的 VIF。
正如我们可以看到的，经过两次迭代后，所有剩余变量的 VIF 都小于 10。我们删除了具有多重共线性的变量，并确定了与预测 ASML 股票价格相关的独立变量列表。
我希望，在为你的机器学习模型选择正确的自变量集合时，你会发现本程序中解释的方法是有帮助的。
如果你喜欢这篇文章，那么你可能也会喜欢机器学习和供应链管理:动手系列
免责声明——本文仅为教育目的而写。不要根据本文中确定的独立变量进行任何实际的股票买卖或任何金融交易。
如何在 AWS 上实现无服务器批处理作业架构
概念性的想法和使它们工作的代码
这篇博文是关于 AWS 上无服务器批处理作业的特定类型架构的三篇技术深度文章之一。该架构背后的基本前提是，我们希望使用 AWS 的托管服务来运行批处理作业。如果您想了解更多关于该架构的信息，请点击此处了解更多详情。该架构的整体情况如下:
整体架构(作者图解)。
简而言之，该架构由一个用于开发的组件块和另一个用于执行批处理作业的组件块组成。在这篇博文中，我们只关注这个架构的托管服务。还有一个公共代码库，允许你基于 Cloudformation 脚本复制完整的服务及其所有部分。
云提供商用两个核心承诺宣传托管服务。首先，云提供商管理维护和其他底层职责。因此，客户可以专注于功能和架构。第二，托管服务往往更便宜，因为您只需为您使用的服务付费，而无需大量的前期投资。
托管服务支持无服务器设计。换句话说，体系结构可以让您摆脱与服务器堆栈相关的许多顾虑。这种抽象级别加速了开发，并引入了与服务架构相关的不可能的灵活性级别。
让我们从云形成脚本的初级入门开始。如果你已经有了云形成或者类似概念的经验，你可以略读或者跳过下面三段。
CloudFormation 是针对基础设施的 AWS 服务，代码为。也就是说，您定义一个目标基础设施，将其推送给 AWS，AWS 为您提供它。您将资源组织在所谓的堆栈中，使其易于调整、监控或删除。
您可以在 JSON 或 YAML 文件中编写 CloudFormation 脚本。这里和代码库中的所有例子都是 YAML 文件，但是您也可以在 JSON 中做同样的事情。
还有一组专门针对 CloudFormation 的命令可供您使用。在接下来的例子中，我使用了其中的四个:
- ！Ref 是内部参考；也就是说，CloudFormation 从同一个堆栈插入一个值。
- ！Sub 用于将变量替换成字符串。
- ！GetAtt 类似于“！Ref”但是指向资源的特定属性，而不是一般的引用。
- ！ImportValue 用于从当前堆栈外部导入值。在本例中，网络和策略规范来自其他配置文件。
大局
该架构的指导原则是开发和生产工作流的分离。也就是说，这里涉及到两个角色:开发者负责实现业务逻辑，云工程师保证稳定运营。
开发工作流程由三个功能组成——一个代码库，它是开发者之间协作的主要工具。一个构建环境克隆存储库，并将代码转换成容器。最后，每当代码库发生变化时，编排工具就会触发新的构建，并将结果推送到映像注册中心。只要开发人员确保主分支反映了他们工作的当前状态，容器就会自动更新。
批处理工作流程包含两个功能。首先，计算资源需要加载容器并运行它。第二，触发器需要在要求的时间间隔内开始计算。
这两个工作流之间唯一的重叠是图像注册。这种最小重叠的减少确保了开发和生产之间的分离。
实施细节
我将实现细节分成三个小节，它们反映了上面描述的大背景。对于每个托管服务，我解释了它们在架构中的角色以及它们最相关的参数。我还提供了 CloudFormation 片段，以便您可以将我的解释与实际代码联系起来。
**注意:**这些说明仅涵盖托管服务。但是不包括网络和访问管理。如果你想了解更多的细节，请看网络和 IAM 角色和政策上的两篇相关文章。
开发组件中的托管服务
开发工作流程(作者插图)。
开发工作流程的第一个组成部分是一个代码提交库。唯一特殊的配置是代码部分。这个部分允许你在 S3 上以 ZIP 文件的形式提供一个初始代码库。我在示例中使用它来使整个工作流直接启动，但是它是可选的。但是，如果您为代码指定了一个不可用或不可访问的位置，则堆栈创建会失败。下面是相关的 CloudFormation 脚本:
第二，有一个 CodeBuild 项目。它将一个源转换成一个图像，并将结果推送到一个容器注册表中。在这种情况下，源代码是上面定义的 CodeCommit 存储库。该项目使用存储库的 HTTP URL 来克隆它。注意，构建的规范来自一个 buildspec.yml 文件，它是克隆代码的一部分。
一旦 CodeBuild 克隆了存储库，构建的映像就会在您需要指定的环境中发生。要使它按预期工作，您必须了解几个参数:
- 类型描述了总体环境，例如，您是否需要 GPU。通常， LINUX_CONTAINER 完成这项工作。
- 计算类型指定用于构建的虚拟硬件。在撰写本文时，对于 LINUX_CONTAINER ，有四个不同的选项可供选择。最小的选项包括 3 GB 内存和两个 vCPUs。
- 特定基础图像的选择取决于你的构建需要什么。查看文档中的运行时列表，看看哪个选项能满足您的需要，并做出相应的选择。例如，寻找正确的 Python 版本。
- 特权模式使项目能够构建 Docker 容器。由于本例使用了 Docker 图像，因此参数为 true 。
- 您还可以为构建指定额外的环境变量。在这个例子中，我们传递了帐户 ID、容器注册名和一个图像标签。你需要什么变量取决于 buildspec.yml 和 Dockerfile。
将该列表与 Cloudformation 脚本进行比较，了解更多详细信息:
最后，还有一个代码管道用于编排。它由两个阶段组成，包括一个名称和一个动作列表。不同类型的操作需要不同的配置参数集，所以我在这里主要关注其中的一些。
主分支中的每个变化都会触发源阶段。这个阶段充当流水线的初始化阶段。主要参数是存储库的名称、您想要监控变更的分支，以及一个指示管道是否应该拉取变更的标志。如果您将此设置为 true ，每当库被更新时，新的运行将自动开始。
如果采购成功，则构建阶段开始。所有管道需要的是对上述 CodeBuild 项目的有效引用。
下面是 CloudFormation 脚本中涵盖管道的部分:
对于 CodePipeline 来说，还有比我列出的更多的可用操作。例如，您可以用 GitHub 或 Bitbucket 上的库替换源库，用 webhook 替换对变更的提取。请将此设置视为您实验的起点。
连接环节
连接容器注册表(由作者图解)。
使用弹性容器注册表(ECR) 很容易。您需要做的就是定义一个存储库的名称:
如您所见，选择注册表作为链接是分离开发和执行的一种强有力的方式。只要开发工作流将图像推送到图像存储库，它就不会中断批处理作业工作流。
批处理作业组件中的托管服务
批处理作业架构(作者举例说明)。
批处理作业的计算核心是 Fargate 任务。但是我们首先需要一个托管的地方来运行它们，即 AWS 弹性容器服务(ECS) 上的集群。幸运的是，我们需要实现的只是它的集群名:
然而，在任务定义中涉及到更多的配置。有两组值需要设置:通用参数和容器定义。让我们从常规设置开始:
- CPU 和内存是任务的硬件需求。AWS 只允许这两个参数的某种组合，因此请查看文档以避免出现错误消息。请注意，您指定了 CPU 单元的数量，因此 256 是 0.25 个 vCPU，1024 是一个 vCPU，依此类推。
- Fargate 任务的正确网络模式是 awsvpc 。如果您尝试使用另一个选项，您的容器将无法连接到外部。
- 为了确保任务使用无服务器基础设施，您需要将所需的兼容性设置为 Fargate 。
这些参数定义了图像运行的框架。接下来让我们看看确切的容器定义:
- 映像是容器注册表中容器映像的地址。不幸的是，AWS 没有提供一种干净的方法来提取它，所以您必须自己构建字符串。
- 我不能夸大日志配置的重要性。如果做错了，调试应用程序几乎是不可能的。相比之下，如果将日志驱动设置为 awslogs ，则可以访问 CloudWatch 中的所有日志记录信息。
现在任务已经就绪，我们需要添加一种方法来定期触发它。这个功能由一个 CloudWatch 规则接管。 ScheduleExpression 定义触发器触发的频率。状态参数指定一旦 CloudFormation 部署它，触发器是否激活。配置中更重要的部分是触发器的目标，所以我想为您提供更多的细节:
- Arn 参数指向我们上面指定的虚拟 ECS 集群。其余设置参考 ECS 细节。
- 发射类型有两种选择: EC2 和 Fargate 。因为我们设计的一切都是无服务器的，所以我们需要选择后者。
- 从安全角度来看，关键的是网络配置，这是我们在 AWS VPC 中指定的。为了确保无法访问互联网，我们禁用了公共 IP 并分配了子网和安全组。
- 任务定义 Arn 指的是我们上面指定的实际任务。
以下是 CloudFormation 中的完整规范:
为了完整起见，下面是我如何在 CloudFormation 脚本中指定两个 S3 桶。请注意，可以定义生命周期策略或其他更细微的配置:
我希望这篇文章能帮助你更好地理解每个托管服务对无服务器工作流的贡献。同样，如果你想了解更多关于架构的知识，请参考概念帖子。如果你打算重建它，看看公共代码库。
请在评论中告诉我你的想法和经历。我也很乐意在 Twitter 和 LinkedIn 上连接。感谢您的阅读！
如何实施成功的数据清理流程
因为你不能测量脏数据
干净的数据是发现和洞察的基础。如果数据是脏的，你的团队为分析、培养和可视化数据付出的极大努力完全是浪费时间。当然，脏数据并不新鲜。早在计算机普及之前，它就一直困扰着人们的决策。现在计算机技术在日常生活中无处不在，这个问题变得更加复杂。
公司需要确定的第一件事是，他们的内部是否有脏数据。幸运的是，这很容易做到。答案是肯定的。每个人都有脏数据，这意味着你也有脏数据。现在我们已经越过了这个障碍，我们必须提出的下两个问题更难回答，“哪些数据是脏的？”以及“我们如何清理我们的数据？”
这些年来，我看到许多公司和团队竭尽全力清理他们的数据。它们涉及大型专门团队、主要项目时间表以及数月或数年的努力。他们都以差不多相同的方式结束，失败。至少项目结束时公司数据被清理的最初任务是失败的。
事实是，项目的形式往往会改变。它从一个有开始和结束的线性项目，然后是一个干净数据的预期交付，演变成一个无限持续的循环过程。然而，用于分析和洞察的干净数据的最终目标得以实现。
失败的例子……
在我解释一个成功的数据清理循环过程所涉及的步骤之前，让我们花点时间来探究像上面给出的例子这样庞大的数据清理项目总是失败的原因。清理数据的线性项目方法有一个固有的假设，会导致我们重复失败。它假设您正在清理的数据在本质上是静态的。新数据将进入您的系统，但新数据将正确输入，不包含错误或不干净。但是，如果脏数据以某种方式再次被引入源系统，那么您已经实施的流程将考虑所有可能形式的脏数据问题，这些问题可能会在将来出现。
这不是源系统工作方式的真实写照。例如，假设我们有人力资源部门使用的软件。它允许人力资源人员输入员工姓名，并通过所有入职要求跟踪他们的进度，从最初的聘用日期到员工接受其职位的全面培训。
该软件由第三方软件开发团队编写(或至少是定制的),贵公司曾使用该团队根据其特定的入职流程定制该软件。正如我们所期望的，该软件将所有数据保存到 SQL 事务数据库中。数据库中的一个字段存储了每个员工在整个入职流程中每次评估的分数。当然，如果某项评估尚未完成，则不会记录分数。您对数据的初步检查显示，未完成的评估在分数字段中包含一个空字符串，而已完成的评估在该字段中包含一个实际分数值。
您的团队实现了清理转换，以确保这些空字符串值在您的分析数据表中变为空值，以便您可以在计算过程中轻松找到并忽略它们。问题解决了！或者你是这么认为的…
数据清理工作完成几个月后，一名人力资源员工发现了人力资源软件本身的问题，他们向软件开发团队提出了这个问题。第三方团队选择通过改变其软件的行为来解决问题，不再使用空字符串值来表示不完整的评估分数，但他们现在使用零作为不完整的占位符。起初，这似乎解决了人力资源的问题，但很快分析师的报告开始反映出入职团队的平均得分极低。
当您的团队最终被要求进行调查时，您意识到问题来自所使用的平均方法。由于空字符串最初是不完整的指示符，并且您将它们转换为空值，所以分数的平均值可以通过简单的 average 函数来完成，因为它忽略了空值。它不会忽略零。因此，平均值现在包含了未完成评估的零分。
回到制图板！
一个循环的清洗过程将起作用
虽然上面的例子很简单，但现实生活中的问题要复杂得多，它清楚地展示了线性数据清理方法固有的问题。
相反，我们不断改变和增加影响整个业务数据的流程，因此，我们不断改变我们的环境，为有问题的数据带来新的机会。更糟糕的是，我们不仅改变了流程、系统、来源、领域和与数据收集相关的许多其他元素，我们还在以越来越快的速度添加新数据。
当您已经创建了一种清理数据的方法并实现了它时，这些因素中的许多或全部都已经改变了——改变了许多次。
线性数据清理路径注定要失败，应该放弃。相反，让我们从每个人最终都会采用的循环过程的系统化版本开始。与其在线性版本上浪费时间、精力和资源，然后采用无组织的循环数据清理方法，并像其他人一样让您的团队感到失败，您可以从一开始就正确地构建循环流程，每个人都会成功，知道他们为什么成功，同时带着成功的感觉做他们的工作。听起来不是更好吗？
把你的清洁过程想象成急诊分诊
数据清理的循环过程相当简单。它由 5 个类似于医院急诊室的阶段组成。虽然各医院在急诊室程序的具体实施上有所不同，但基本步骤是相同的。第一阶段是分流。在这一阶段，医疗专业人员对患者进行评估，根据患者的严重程度为其分配优先级，并将他们分配到适当的小组进行治疗。第二阶段是治疗阶段。它包括对病人进行实际治疗，以及在病人出院前和出院后安排任何必要的随访。
使用这些 ER 和 triage 过程作为指南，让我们考虑一下周期性数据清理是什么样子的。
分析——一名患者走进急诊室
人们出现在急诊室不仅仅是为了闲逛或者喝杯咖啡。他们在那里是有原因的。即使他们疾病的原因还没有被诊断出来，这次访问的背景也是明白无误的。数据清理也是如此。
更传统的线性数据清理方法的困难之一是情况的抽象性。让我们思考一下这个问题。如果我们正在查看数据库中的数据，但实际上并没有试图为公司分析任何东西(即月度销售趋势或损耗)脏数据可能很明显，也可能不明显。但是，一旦我们开始计算收入、利润、客户流失率，以及我们的企业要求了解的其他典型项目，脏数据就会出现。脱离上下文的数据很容易伪装成干净的数据。因此，在线性方法中，我们经常会遗漏许多实际包含脏数据的数据字段。在线性清理项目结束时，当分析师第一次发现利润一栏中的数字完全不合理时，就需要重新检查得到的“干净”数据。
使用数据清理的循环过程，我们从分析开始。继续前进，让分析师们在数据中放松。告诉他们向数据工程师提出要求，施展他们的分析魔法，当数据看起来不正确时，不要羞于提出问题。这是我们的清理过程迫切需要的帮助和上下文，以便正确和全面地清理我们当前拥有的数据。
每当分析师发现与数据有关的东西时，这就成为将病人送到急诊室的理由。是胃痛或者气短或者高烧把数据带给你清洗。当然，一旦分析师将“数据”患者发送到您的急诊室，您的数据分诊人员必须准备好执行。
评估——伸出舌头，说“啊”
当有人走进急诊室时，医疗小组做的第一件事就是评估病人。他们测量他们的体温、血压、逐项列出病人正在服用的药物清单、获得症状描述等等。开始评估“数据”患者时也是如此。
当然，在医疗情况下，大部分信息都是与已知的正常范围进行比较的。护士和医生知道你的体温或血压是否高于可接受的范围。那些法线已经建立了。但是在有数据的情况下，可能需要先建立正常值，然后才能验证患者的健康状况。
您的“数据”分类小组将评估分析师(转诊医生)发给他们的患者。在我们循环流程的这一阶段，您的团队将与分析师以及可能的其他业务团队成员一起工作，以验证数据确实是脏的。您还需要使用这些数据评估业务案例及其对公司或公司下属部门的影响。
在这一阶段，我们要问的第一个问题是“这些数据看起来应该是什么样的:相加或平均还是作为一个维度或其他什么？”如果没有对数据应该是什么的正确理解，我们很有可能做出不清理数据的更改。我们可能只是将数据转换成另一种形式的脏数据。
接下来，您需要理解数据的影响和重要性。首席执行官或首席财务官是否使用这些数据来制定市场决策、产品决策、向公众报告公司进展？客户服务部是否使用这些数据来改善您客户的体验？营销部门会利用这些数据来规划他们的下一个广告策略吗？是否存储了这些数据，并在今年晚些时候用于董事会的趋势分析？有无限的可能性，但数据的影响和重要性将帮助您正确地优先考虑这个病人。
分配优先级——即使紧急情况也有严重程度
甚至急诊室的病人也有不同程度的紧急情况。一名患者可能感到恶心，另一名患者感到极度的胸部和手臂疼痛。还有一个可能失去知觉或遭受烧伤。虽然他们都需要医疗护理，但目前只有这么多的医疗专业人员来帮助他们，最糟糕的情况将值得优先考虑。当然，许多因素被用来确定某人疾病的严重程度和相应的优先级。“数据”患者也是如此。
一旦您在上下文中理解了数据应该是什么以及它的重要性和影响，您将需要为它分配一个优先级。所有团队的资源都是有限的，您的数据清理团队也不例外。这暴露了线性清洁方法的另一个问题。当您线性清理数据时，每一个识别出的脏数据出现往往会获得同等的优先级，因为它成为一个大型项目的一部分，该项目将在项目结束时考虑数据清理。当今世界，大多数团队的资源都非常有限。同等优先地处理所有问题会大大延迟团队发布最重要和最有影响力的结果。
您的数据团队需要建立自己的优先级规则。也许任何特别来自客户要求或故障单的东西都会跳到列表的最前面。或者，最高管理层的请求可能会获得最高优先级。每一种公司文化都有其自身的动力，你的团队应该与公司领导一起工作，以确定对请求进行优先排序的最佳行动方案。但是，一旦定义了该标准，您的团队应该使用在评估中收集的上下文、影响和重要性，以及确定优先级的标准，并相应地分配每个请求。
确定清理数据的适当流程和团队
医院经常每班雇用一名急诊室医生。这位医生将在她值班期间，为每一位病人看病，并解决进入急诊室的每一种情况。然而，如果一个特殊的急诊室病人需要一个专家，值班医生将努力稳定病人的病情，然后将他分配到一个部门。那个特定部门的随叫随到的医生将接手这个特殊的病例。如果一个特定的病人需要多个专家，那么可以分配多个部门来协助整个治疗计划。
在清理数据时，指派一名通才甚至可能是多名专家的做法是一样的。你必须总结出最好的团队来获得最好的结果。为了做到这一点，您的数据专家团队，也许是多面手，需要更多地了解有问题的脏数据。
首先确定数据的来源，以及数据在最终保存到数据库供分析师使用之前所经历的任何转换。同样，您的团队可能需要获得数据工程师、数据辩论者、数据库管理员或更多业务团队成员的协助，以正确评估患者。如果您确定与源数据相关的应用程序没有正确地将数据保存到数据库中，您甚至可以寻求软件开发人员的帮助。不要害怕与他人合作，寻求帮助。
通过概述数据和任何 ETL 的源系统，您可以更加容易和快速地从正确的团队获得必要的资源。如果是会计数据，您可能需要与这些服务器的数据团队合作。或者，如果是地球科学数据，您需要接触一些地球科学家，以了解他们与数据工程师一起帮助设计的 ETL 过程。你明白了。
执行这些前期工作，将您的“数据”患者置于尽可能好的护理中，并确保最快的“恢复”或清洁时间。
确定清理数据的必要步骤
有了合适的团队，病人的治疗现在可以开始了。集合起来的团队将需要决定如何最好地清理数据，以便在分析师使用的数据库中使用和存储。当然，这可能是一个快速的过程，也可能需要一段时间，这取决于现有 ETL 的复杂性或所涉及的源系统的肮脏本质。
一旦必要的步骤被识别、测试并达成一致，它们就需要被记录，当然，还要被实现。最好是使用一个开发、测试、生产环境架构，并首先将变更实现到开发中。然后提升到测试环境，只有当所有内容都被验证为正确时，才把最终解决方案提升到生产环境。但是这些环境和部署步骤因公司而异，您需要遵循您的组织概述的流程。
自动执行您刚刚实施的清洁步骤
在医院里，一旦病人接受了治疗并被认为可以出院，他们仍然可能有后续的预约或需要执行的任务，如服药。对于数据清理，可能还需要多个后续任务，但是始终需要的一个后续任务涉及自动化。
不管你公司的变化过程是什么，你必须做的一件事是通过自动化使变化持久。自动化有多种形式。您可能需要改变现有的 ETL 过程，或者引入一个自动化的过程来清理 ETL 后的数据。自动化可以通过为你和你的公司工作的任何语言或系统来实现:SQL、Python、C#、SAS 等等。使用微软产品的公司常用的自动化系统是 SQL Server Integration Services(或 SSIS)。这些任务的计划执行可以像 cron 或 Microsoft 任务管理器或 SQL 代理一样简单。不一定需要精密。但是需要自动化。
如果您允许清理过程仍然是手动的，您将很快让您的团队被重复的手动工作淹没，并且承担新的数据清理工作的希望将被放弃。
我已经在其他地方说过了，但是让你的团队变得无用的最快方法是用重复的手工工作来压倒他们。所有探索、清理和初始数据争论工作都是手动的。但是一旦过程被清晰地定义，如果你的团队希望继续影响你公司的洞察力和决策，它必须是自动化的。
重复
现在，您已经完成了清洁流程的所有步骤，包括分析、识别、评估、优先排序、团队分配、建立清洁流程和自动化清洁流程，现在是时候重复该流程了。分析师将确认您团队的工作结果并心存感激，但他们也会向您发送新的“数据”患者，并为这些生病并需要您治疗的新患者重新开始这一过程。
最后一次提醒，正式建立您的周期性数据清理流程……
在医院急诊室救人的医生和护士并不只是即兴发挥。他们已经训练多年了。他们几乎可以在睡梦中完成工作，因为这已经通过数小时的正式训练而在他们心中根深蒂固。他们不仅在医疗程序和知识方面接受了严格的培训，急诊室中用于对患者进行分类、收治患者、确定患者优先顺序的政策和程序，以及治疗患者的所有方式都经过了彻底的研究和正式化，以便为任何来到他们门前的患者提供最佳的生存机会。
医务人员和医院管理人员知道，一个强大的、正式的计划会减少出错的机会，从而带来更大的成功。形式化计划的好处同样适用于数据清理。
正如本文开头所概述的，大型的基于线性的数据清理项目最终通常会以相同的循环过程告终。线性过程让他们失望了，因为工作还必须完成，团队在每个问题出现时就着手解决。但是很多时候，在一次失败的线性尝试之后，到达这个相同的过程，会使该过程处于一种非正式的状态。这实际上只是以一种特别的方式进行的。
避免这个陷阱！
没有形式化，过程结果将在成功和失败之间起伏不定。每个新发现的脏数据问题的成功清理将永远是待价而沽的。你的团队会工作不稳定，他们对工作的动力时好时坏。即使随着时间的推移，随着团队的形成，你的临时方法开始发挥作用，但每当团队成员离开或新成员加入时，它就会被颠覆。原因是…没有计划可循。
有时候，当你的团队对自己的工作感觉良好时，他们会表现出色。但是其他时候，重复的工作和对最初数据清理项目失败的回忆会促使他们质疑自己的工作和工作的性质。
“为什么我们不能创建一个流程来解决所有这些问题，而不是每天面对一场火灾？”
“为什么管理层不关心我们已经超负荷工作了？他们只是不断给我们发送更多的请求。”
“我们什么时候才能赶上？”
如果您愿意花时间并努力将清理数据的循环过程正式化，您的团队将有一个路线图可以遵循，并且您组织中的其他部门将有一个指南来正确地与您的团队进行交互。在许多方面，这只是一个视角，但是过程的形式化消除了模糊性，并使正在完成的工作有了目的。形式化是确保您的团队在数据清理方面取得一致成功的必要步骤。
杆蓖麻 帮助企业获得分析权！他与国际组织和小型企业合作，开始或改进他们在数据分析、数据科学、技术战略和技术领导力方面的工作。除了咨询，Rod 还喜欢公开演讲、教学和写作。你可以在rodcastor.com和applied ai . us了解更多关于罗德和他的作品。
如何从头开始实现 Adam 优化器
没你想的那么难！
TL；博士如果你想跳过教程。这里是我创作的笔记本。
Adam 是一种基于自适应矩估计优化随机目标函数的算法。Adam 的更新规则是 momentum 和 RMSProp 优化器的组合。
规则很简单。从头开始编写 Adam 代码，无需借助任何外部 ML 库，如 PyTorch、Keras、Chainer 或 Tensorflow。只允许我们使用的库是numpy和math。
(っ‿)っ(っ‿)っ(っ‿)っ(っ‿)っ(っ‿)っ(っ‿)っ
第一步:理解亚当是如何工作的
学习亚当作品最简单的方法就是看吴恩达的 视频 。或者，你可以阅读亚当的 原论文 来更好地理解背后的动机和直觉。
亚当依赖的两个值是 β ₁和 β ₂. β ₁是一阶矩估计的速率的指数衰减，其文献值为 0.9。β是二阶矩估计的指数衰减率，文献值为 0.999。这两个文献值适用于大多数数据集。
使用参数β1 和β2 计算移动平均值
在给定的迭代 t 上，我们可以根据参数 β ₁、 β ₂和梯度 *gt 计算移动平均。*由于 SGD 和 RMSProp 等大多数依赖于移动平均值的算法都存在偏差，因此我们需要额外的步骤来纠正偏差。这被称为偏差校正步骤:
移动平均线的偏差修正
最后，我们可以根据计算出的移动平均值，以步长 η 更新参数(权重和偏差):
步骤 2:用 Python 实现 Adam
总结一下，我们需要定义几个变量:一阶指数衰减 β ₁，二阶指数衰减 β ₂，步长 η 和一个小值 ε 防止零除。此外，我们将m_dw、v_dw、m_db和v_db定义为权重和偏差dw和db的梯度的前一时间步的均值和无中心方差。
回想一下，Adam 依赖于两个重要的矩:均值的一阶矩估计和方差的二阶矩估计。使用这些矩估计，我们可以在给定适当步长的情况下更新权重和偏差。
步骤 3:测试实现
为了测试我们的实现，我们首先需要定义一个损失函数及其各自的梯度函数。梯度函数可以通过简单地对损失函数求导来获得。例如:
注意，我们还定义了一个额外的函数来检查收敛性，这是基于当达到收敛时权重不会改变的事实。最后，我们可以使用构建的 Adam 优化器迭代更新权重和偏差，并查看它们是否收敛:
查看结果，在 750 次迭代下达到收敛。大获成功！
请随意查看我的其他故事和 github 项目。祝你今天开心！玩的开心！
如何使用 Fastai-v2 和 Albumentations 实现多光谱卫星图像分割的增强
通过多光谱图像增强和 Fastai v2 提高深度学习算法的性能
图 1:应用于 Landsat 8 补丁及其相应的云掩膜的增强。图片作者。
更新
关于课程科学家 Python 入门 ( 可在 YouTube ) 和其他类似文章的信息，请访问我的网站cordmaur.carrd.co。
介绍
我们知道图像增强是计算机视觉任务的一个关键因素。它有助于算法避免过度拟合，也限制了对庞大训练数据集的需求[1]。大多数深度学习框架都有一个实现增强“开箱即用”的视觉模块，如 Keras、PyTorch 和 Fastai 库的情况。当我们需要向模型提供与 3 通道标准(RGB)不匹配的图像时，问题就出现了。这是大多数遥感应用的情况(例如图 1)和许多其他区域。
为了克服这一限制，我将展示如何使用白蛋白库[2]实现多光谱增强，并将其插入 Fastai v2 数据块以供进一步培训。关于如何为卫星图像创建数据块的原则可以在我之前的故事“如何使用 Fastai-v2 为多光谱卫星图像分割创建数据块”中找到。
1-数据集
我们将使用的数据是 Kaggle 提供的公共数据集，名为“95 云:卫星图像上的云分割” ，，包含从 57 个 Landsat 8 场景中提取的训练补丁。事实上，这个数据集是以前的 Kaggle 数据集的扩展，该数据集用于训练一个非常简单的 Fastai v1 模型(此处为)。这些贴片的尺寸为 384x384，包含 4 个波段——红、绿、蓝和近红外。此外，还有一个标记云的地面真相补丁。由于我们的目标只是展示如何实现增强，没有进一步考虑准确性，我们将只使用最新版本。
图 2— Kaggle 数据集。图片来自 ka ggle(https://www . ka ggle . com/sorour/95 cloud-cloud-segmentation-on-satellite-images)
为了方便起见，这里显示的所有代码都可以在 Kaggle 笔记本中使用(这里是)，所以我们将从安装必要的依赖项开始:
# update torch and torch vision
!pip install -q torch==1.6.0+cu101 torchvision==0.7.0+cu101 -f [https://download.pytorch.org/whl/torch_stable.html](https://download.pytorch.org/whl/torch_stable.html)# install kornia, we will give it a try to accelarate our preprocessing
!pip install -q --upgrade kornia
!pip install -q allennlp==1.1.0.rc4# and install fastai2
!pip install -q --upgrade fastai
2-打开图像
除了视觉库不支持多通道图像的问题，该数据集将每个波段保存在单独的文件夹中。因此，为了打开一个图像，我们首先需要纠正每个波段的路径，然后将它们整理成一个单一的 4 通道图像。不像我们在之前的故事中那样子类化 TensorImage 类，我将尝试使事情变得更简单，并将图像作为张量打开。这种方法的缺点是我们不能像DataLoader.showbatch()一样使用 Fastai 的内部可视化功能，因为它不知道如何显示 4 个波段。
第一步是创建三个基本函数:
- 打开一个 TIF 文件，并将其作为 PyTorch 张量返回；
- 给定一个文件名(假设是红色波段)，返回其他三个波段(绿色、蓝色和 Nir)的名称；
- 一次打开 4 个波段，将它们整理成一个图像。为此，我们将使用第一维(或轴)连接图像
一旦我们的函数被定义，我们将通过传递一个项目到管道来测试它们。管道是应用于一个项目的一系列功能，以我们想要的方式转换它。
为了加载项目，我们将考虑我们的基础图像在红色文件夹中，然后我们将自动获取其他波段。因此，我们的管道将由两个功能组成:1- get_filenames 和 2- open_ms_tif。我们的最终图像将有形状(4, 384, 384)。用 matplotlib 显示它会在维度上做最后的排列，把通道放在最后一个轴上成为(384, 384, 4)，并且用[…, :3]切掉 Nir 波段。
考虑到我们的最终目标是分割图像中的云，我们必须将相同的增强应用于地面真相。因此，将进行类似的程序来打开面罩。
torch.Size([4, 384, 384]) torch.Size([384, 384])
图 3:显示补丁和相应云遮罩的代码输出。图片作者。
如我们所见，我们的管道运行良好。我使用 TensorMask 的.show() 方法和 context ctx参数，只是为了说明在 Fastai 中可以将输出强制到任何上下文。另一个有趣的命令是 partial，它返回对预先填充了一组给定参数的函数的引用。
3-创建数据集和数据加载器
在进行扩充之前，我们将首先创建一个数据集和一个数据加载器，只是为了检查是否一切都按预期工作。注意，我们不需要在数据块中指定 get_items 函数，因为我们的源已经是一个条目列表。我们还将定义一个函数show_img()来显示多通道张量。
torch.Size([4, 4, 384, 384]) torch.Size([4, 384, 384])
图 4:显示一个批处理样本的代码输出。(上)RGB 图像|(下)云遮罩。图片作者。
4-扩充
为了扩充，我们将使用白蛋白库。有一个巨大的可能的增强列表，分为不同的类，如像素级和空间级变换。对于本教程，我们将保持简单，只使用基本的移动，翻转，缩放，旋转，亮度和对比度。完整的列表可以通过他们的在线文档获得(此处)。
白蛋白库的一个重要方面是它支持分割和对象检测的增强。这意味着它可以将应用于图像的相应增强应用于其目标(遮罩或边界框)。这是至关重要的一点，因为我们需要保持我们的云遮罩与增强图像相匹配。
Fastai 将对一个元组(X，Y)应用增强，其中 X 是图像，Y 是遮罩。为了让它在框架内工作，有必要子类化 ItemTransform 类并创建encodes()方法。为了使它通用，我们的子类将在实例创建时接收期望的转换，如下所示:
图 5:代码输出显示:(左)原始项目(图像和遮罩)|(右)图像和遮罩的增强版本。图片作者。
注意，在这个类中定义了一个split_idx=0。这就是告诉 Fastai 只增加训练数据集，而不是验证数据集。现在我们已经建立了我们的转换类，让我们在数据块中使用它。我们将重新创建数据块，现在将item_tfms参数设置为aug。然后，我们将要求数据加载器多次创建一个项目，以查看它是如何进行的。
图 6:代码输出演示了在通过数据加载器时应用于同一个补丁的增强。图片作者。
结论
正如我们在这个故事中看到的，实现多光谱卫星图像的数据增强只是找到正确工具的问题。在这方面，白蛋白是一个很好的伴侣，因为它可以处理许多渠道，并增加目标。
如前所述，包含所有代码的笔记本可以在 Kaggle ( 此处)找到。在那里，还可能找到有和没有增强的学习准确度的比较。
希望你喜欢。
参考
[1] Shorten，c .，Khoshgoftaar，T.M .，2019 年。面向深度学习的图像数据增强综述。j 大数据 6、60。https://doi.org/10.1186/s40537-019-0197-0。
[2] Buslaev，a .，Iglovikov，V.I .，Khvedchenya，e .，Parinov，a .，Druzhinin，m .，Kalinin，A.A .，2020。快速灵活的图像增强。信息 11125。【https://doi.org/10.3390/info11020125
如何使用 PyCaret 在 Power BI 中实现集群
Power BI 中的集群仪表板
在我们的上一篇文章中，我们展示了如何通过将异常检测器与 PyCaret 集成，在 Power BI 中构建异常检测器，从而允许分析师和数据科学家在他们的报告和仪表板中添加一层机器学习，而无需任何额外的许可成本。
在这篇文章中，我们将看到如何使用 PyCaret 在 Power BI 中实现聚类分析。如果你以前没有听说过 PyCaret，请阅读这个公告以了解更多信息。
本教程的学习目标
- 什么是集群？聚类的类型。
- 在 Power BI 中训练和实现无监督聚类模型。
- 在仪表板中分析结果和可视化信息。
- 如何在电力 BI 生产中部署集群模式？
开始之前
如果您以前使用过 Python，很可能您的计算机上已经安装了 Anaconda 发行版。如果没有，点击这里下载 Python 3.7 或更高版本的 Anaconda 发行版。
https://www.anaconda.com/products/individual
设置环境
在我们开始在 Power BI 中使用 PyCaret 的机器学习功能之前，我们必须创建一个虚拟环境并安装 pycaret。这是一个三步走的过程:
✅ 步骤 1——创建一个 anaconda 环境
从开始菜单打开 Anaconda 提示符并执行以下代码:
conda create --name **myenv** python=3.7
✅ 第二步—安装 PyCaret
在 Anaconda 提示符下执行以下代码:
pip install pycaret
安装可能需要 15-20 分钟。如果您在安装时遇到问题，请查看我们的 GitHub 页面，了解已知问题和解决方案。
✅t22】第三步——在 Power BI 中设置 Python 目录
创建的虚拟环境必须与 Power BI 链接。这可以使用 Power BI Desktop 中的全局设置来完成(文件→选项→全局→ Python 脚本)。默认情况下，Anaconda 环境安装在以下位置:
C:\Users\ 用户名\ AppData \ Local \ Continuum \ anaconda 3 \ envs \ myenv
文件→选项→全局→ Python 脚本
什么是集群？
聚类是一种将具有相似特征的数据点分组的技术。这些分组对于探索数据、识别模式和分析数据子集非常有用。将数据组织成簇有助于识别数据中的底层结构，并在许多行业中找到应用。集群的一些常见业务用例有:
以营销为目的的✔客户细分。
促销和折扣的✔顾客购买行为分析。
✔在诸如新冠肺炎的流行病爆发中识别地理群集。
聚类的类型
考虑到集群任务的主观性，有各种算法适合不同类型的问题。每种算法都有自己的规则和计算聚类背后的数学原理。
本教程是关于使用名为 PyCaret 的 Python 库在 Power BI 中实现聚类分析的。对这些算法背后的具体算法细节和数学的讨论超出了本教程的范围。
Ghosal A .、Nandy A .、Das A.K .、Goswami S .、Panday M. (2020)对不同聚类技术及其应用的简短回顾。
在本教程中，我们将使用 K-Means 算法，这是最简单和最流行的无监督机器学习算法之一。如果你想了解更多的 K-Means，你可以阅读这篇论文。
设置业务环境
在本教程中，我们将使用来自世界卫生组织全球卫生支出数据库的当前卫生支出数据集。该数据集包含 2000 年至 2017 年 200 多个国家的卫生支出占国民生产总值的百分比。
我们的目标是通过使用 K-Means 聚类算法在这些数据中找到模式和组。
样本数据点
👉我们开始吧
现在，您已经设置了 Anaconda 环境，安装了 PyCaret，了解了集群分析的基础知识，并且有了本教程的业务上下文，让我们开始吧。
1.检索数据
第一步是将数据集导入 Power BI Desktop。您可以使用 web 连接器加载数据。(Power BI 桌面→获取数据→来自 Web)。
Power BI 桌面→获取数据→其他→ Web
链接到 csv 文件:
https://github . com/py caret/power bi-clustering/blob/master/clustering . CSV
2.模特培训
为了在 Power BI 中训练聚类模型，我们必须在 Power Query Editor 中执行 Python 脚本(Power Query Editor→Transform→Run Python script)。将以下代码作为 Python 脚本运行:
from **pycaret.clustering** import *
dataset = **get_clusters**(dataset, num_clusters=5, ignore_features=['Country'])
超级查询编辑器(转换→运行 python 脚本)
我们使用 ignore_features 参数忽略了数据集中的“ Country 列。可能有许多原因导致您不想使用某些列来训练机器学习算法。
PyCaret 允许您隐藏而不是删除数据集中不需要的列，因为您可能需要这些列用于以后的分析。例如，在这种情况下，我们不想使用“国家”来训练算法，因此我们在 ignore_features 下传递它。
PyCaret 中有超过 8 种现成可用的聚类算法。
默认情况下，PyCaret 训练一个具有 4 个聚类的 K 均值聚类模型。默认值可以很容易地更改:
- 要更改模型类型，使用 get_clusters() 中的 模型 参数。
- 要更改簇号，使用 num_clusters 参数。
参见具有 6 个集群的 K 模式集群的示例代码。
from **pycaret.clustering** import *
dataset = **get_clusters**(dataset, model='kmodes', num_clusters=6, ignore_features=['Country'])
输出:
聚类结果(执行 Python 代码后)
最终输出(点击表格后)
包含分类标签的新列被附加到原始数据集。然后，所有年份列都被取消透视以规范化数据，这样它就可以用于 Power BI 中的可视化。
下面是 Power BI 的最终输出。
Power BI Desktop 中的结果(应用查询后)
3.仪表盘
一旦您在 Power BI 中有了集群标签，以下是一个如何在 dashboard 中可视化集群标签以获得洞察力的示例:
仪表板的摘要页面
仪表板的详细信息页面
你可以从我们的 GitHub 下载 PBIX 文件和数据集。
👉在生产中实施集群
上面展示的是在 Power BI 中实现集群的一种简单方法。但是，需要注意的是，每当 Power BI 数据集被刷新时，上面显示的方法都会训练聚类模型。这可能是一个问题，原因有二:
- 当使用新数据重新训练模型时，分类标签可能会改变(例如，在重新训练时，先前被标记为分类 1 的一些数据点可能被标记为分类 2)
- 你不想每天花几个小时的时间重新训练模型。
在 Power BI 中实现集群的一种更有效的方法是使用预先训练的模型来生成集群标签，而不是每次都重新训练模型。
事前培训模型
你可以使用任何集成开发环境(IDE)或笔记本来训练机器学习模型。在此示例中，我们使用 Visual Studio 代码来训练一个聚类分析模型。
Visual Studio 代码中的模型定型
然后将训练好的模型保存为 pickle 文件，并导入到 Power Query 中以生成分类标签。
群集管道保存为 pickle 文件
如果您想了解更多关于使用 PyCaret 在 Jupyter 笔记本中实现聚类分析的信息，请观看这个 2 分钟的视频教程:
https://www.youtube.com/watch?v=2oxLDir7foQ
使用预先训练的模型
以 Python 脚本的形式执行以下代码，从预训练的模型中生成标签。
from **pycaret.clustering** import *
dataset = **predict_model**('c:/.../clustering_deployment_20052020, data = dataset)
它的输出将和我们上面看到的一样。不同之处在于，当您使用预训练模型时，标签是使用同一模型在新数据集上生成的，而不是重新训练模型。
让它在 Power BI 服务上发挥作用
一旦你上传了。pbix 文件到 Power BI 服务，还需要几个步骤来实现机器学习管道到数据管道的无缝集成。其中包括:
- 为数据集启用计划刷新—要使用 Python 脚本为包含您的数据集的工作簿启用计划刷新，请参见配置计划刷新，其中还包括关于个人网关的信息。
- 安装个人网关 —你需要一个个人网关安装在文件所在的机器上，并且安装了 PythonPower BI 服务必须能够访问 Python 环境。您可以获得关于如何安装和配置个人网关的更多信息。
如果您有兴趣了解更多关于聚类分析的知识，请查看我们的笔记本教程。
PyCaret 1.0.1 来了！
我们收到了来自社区的大力支持和反馈。我们正在积极改进 PyCaret，并准备我们的下一个版本。 PyCaret 1.0.1 会更大更好。如果您想分享您的反馈并帮助我们进一步改进，您可以在网站上填写此表格或者在我们的 GitHub 或 LinkedIn 页面上发表评论。
关注我们的 LinkedIn 并订阅我们的 Youtube 频道，了解更多关于 PyCaret 的信息。
重要链接
用户指南/文档
GitHub 资源库 安装 PyCaret
笔记本教程
贡献于 PyCaret
想了解某个特定模块？
从第一个版本 1.0.0 开始，PyCaret 有以下模块可供使用。点击下面的链接，查看 Python 中的文档和工作示例。
另请参见:
笔记本中的 PyCaret 入门教程:
你愿意投稿吗？
PyCaret 是一个开源项目。欢迎每个人都来投稿。如果您愿意投稿，请随意处理个未决问题。dev-1.0.1 分支上的单元测试接受拉请求。
如果你喜欢 PyCaret，请给我们 GitHub 回购的⭐️。
中:【https://medium.com/@moez_62905/】T4
领英:https://www.linkedin.com/in/profile-moez/
推特:https://twitter.com/moezpycaretorg1
如何在 TensorFlow(Keras)中实现自定义正则化
技术的
了解如何使用 TensorFlow 和 Keras 相对轻松地实现自定义神经网络正则化技术。
萨法尔·萨法罗夫在 Unsplash 上拍摄的照片
介绍
本文介绍了神经网络中的正则化主题。它包括机器学习工程师和数据科学家如何实施定制正则化技术的细节。
正则化技术通过限制网络中权重值的范围来降低神经网络过拟合的可能性。
下面的文章介绍了传统的正则化技术以及它们是如何在 TensorFlow(Keras)中实现的。下面的参考文章是针对那些喜欢神经网络内正则化主题的深入概述的读者。
理解用于减轻深度神经网络中过拟合问题的传统技术。
towardsdatascience.com](/regularization-techniques-and-their-implementation-in-tensorflow-keras-c06e7551e709)
实现自定义正则项
在我们继续之前，值得注意的是，在大多数情况下，您不需要实现您的自定义正则化技术。
tensor flow、Keras 和 PyTorch 等流行的机器学习库内部实现了标准的正则化技术。
我将要实现的正则化技术是 L2 正则化技术。
L2 正则化惩罚权重值。对于较小的权重值和相对较大的权重值，L2 正则化将这些值转换为接近 0 但不完全 0 的数字。
L2 惩罚权重的平方和，因此我们将在 python 函数中实现这个逻辑。
L2 正则化
def custom_l2_regularizer(weights):
return tf.reduce_sum(0.02 * tf.square(weights))
上面的代码是我们自定义的 L2 正则化技术。
使用 TensorFlow 的数学运算，我们可以计算传入函数的权重的平方和。
- tf.reduce_sum :数学运算，其结果是传递给函数的值的总和。
- tf.square :对其参数中的值进行平方的数学运算
这就是全部了。
为了利用我们的自定义正则项，我们将其传递到神经网络层，如下所示:
keras.layers.Dense(200, activation='relu', kernel_regularizer=custom_l2_regularizer),
Keas 神经网络层可以在其’kernel _ regulator’参数内接受自定义函数。
把所有的放在一起
为了了解所实现的自定义正则化技术的效果，我们将构建一个简单的神经网络，并执行图像分类这一简单任务。
这一节将包括执行一些常见神经网络实现任务的代码片段，并且 GitHub repo 链接也是可用的这里包括本文中的所有代码。
为了实现我们的神经网络和加载数据集，我们将利用以下工具和库:Keras、TensorFlow 和 NumPy。
import tensorflow as tf
from tensorflow import keras
import numpy as np
将数据集加载并划分到测试、验证和培训中。
还需要将数据集中图像的像素强度从 0–255 到 0–1 的值范围进行归一化。
数组’ class_names '被初始化以保存数据集中图像所表示的服装的商品标签。
(train_images, train_labels),(test_images, test_labels) = keras.datasets.fashion_mnist.load_data()train_images = train_images / 255.0
test_images = test_images / 255.0validation_images = train_images[:5000]
validation_labels = train_labels[:5000]class_names = ["T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"]
这里，我们按照前面的解释定义了自定义正则项。
def custom_l2_regularizer(weights):
return tf.reduce_sum(0.02 * tf.square(weights))
下一步是实现我们的神经网络及其层。这里为每一层分配适当的参数，包括我们的自定义正则化。
model = keras.models.Sequential([
keras.layers.Flatten(input_shape=[28,28]),
keras.layers.Dense(200, activation='relu', kernel_regularizer=custom_l2_regularizer),
keras.layers.Dense(100, activation='relu', kernel_regularizer=custom_l2_regularizer),
keras.layers.Dense(50, activation='relu', kernel_regularizer=custom_l2_regularizer),
keras.layers.Dense(10, activation='softmax')
])
为了确保我们的神经网络正确训练，我们利用随机梯度下降优化算法，并设置一些任意的超参数，如时期和学习率。
sgd = keras.optimizers.SGD(lr=0.01)
model.compile(loss="sparse_categorical_crossentropy", optimizer=sgd, metrics=["accuracy"])
model.fit(train_images, train_labels, epochs=60, validation_data=(validation_images, validation_labels))
在训练之后，在测试数据集上对训练的模型进行评估。评估数据必须包含模型在训练期间没有遇到的数据。
model.evaluate(test_images, test_labels)
为了验证我们的模型的准确性，我们可以获取测试图像的子集，并运行推理来验证它们的结果。
practical_test_images = test_images[:10]
predictions = model.predict_classes(practical_test_images)
print(predictions)
print(np.array(class_names)[predictions])
使用 Keras 实现神经网络的定制组件(如正则化器)非常容易；您甚至可以更进一步，探索如何使用 Keras 实现定制指标、激活函数、损失函数以及更多功能。
我希望这篇文章对你有用。
要联系我或找到更多类似本文的内容，请执行以下操作:
- 订阅我的 YouTube 频道 即将发布的视频内容 这里
- 跟我上 中
- 通过 LinkedIn 联系我
如何实现 Kohonen 的自组织地图
安|索姆| SOFM | MATLAB
用 MATLAB 玩和学 SOMs
巴黎艾菲尔铁塔——照片由丹尼斯·内沃扎伊在 Unsplash 上拍摄
人工神经网络(ANN)的灵感来自大脑早期的感觉处理模型。可以通过在计算机中模拟模型神经元网络来创建人工神经网络。通过应用模拟真实神经元过程的算法，我们可以让网络“学习”解决许多类型的问题。—安德斯·克拉夫(自然生物技术)
在后现代生活中，我们在每一项活动中都参与了大量惊人的人工神经网络应用，但我们对它们的能力和复杂性一无所知。人工神经网络已被用于解决从语音识别到蛋白质二级结构预测、癌症分类和基因预测等难题。由于对这些高级性能的认识在不久的将来将是必要的，我们应该对这些有更好的了解，并且我们可以从简单的水平开始我们理解 ann 的旅程。
作为一种基本类型的人工神经网络，让我们考虑一种自组织映射(SOM) 或自组织特征映射(SOFM) ，使用无监督学习对其进行训练，以产生训练样本输入空间的低维离散化表示，称为映射。
自组织地图？
它将高维数据之间的非线性统计关系转化为它们在低维显示器上的图像点的简单几何关系，通常是规则的二维节点网格。因为 SOM 由此压缩信息，同时在显示器上保留主要数据元素的最重要的拓扑和/或度量关系— Teuvo Kohonen
🔎为什么是 SOM？
基本上，SOMs 被表征为高维输入数据流形到常规低维数组元素的非线性、有序、平滑映射。在训练 SOM 的神经元之后，我们得到高维输入数据的低维表示，而不会扰乱数据分布的形状和每个输入数据元素之间的关系。自组织映射不同于其他人工神经网络，因为与误差校正学习(梯度下降反向传播等)相比，自组织映射应用无监督学习，并且自组织映射使用邻域函数来保持输入空间的拓扑属性。由于它的简单性，我们可以很容易地解释和演示它的功能。详细的解释请参考 Teuvo Kohonen 的自组织地图。
💡SOM 是如何工作的？
SOM 学习数据表示——在第 1、10、50 和 100 时段，输入用蓝点表示，模型的神经元值用红点表示(图片由作者提供)
上图给出了学习过程的简单说明，我们可以很容易地从这种表示中理解 SOMs 的特性。最初，输入数据(蓝点)在 2D 空间占据特殊分布，未学习的神经元(权值)(红点)随机分布在一个小区域内，神经元经过输入的修改和学习后，在学习过程中逐步得到输入数据分布的形状。此外，每个神经元代表一个小的输入数据空间集群。因此，在这个演示中，我们能够用 100 个神经元表示 1000 个数据点，保留输入数据的拓扑结构。这意味着我们已经在高维数据和低维表示(map)之间建立了联系。对于进一步的计算和预测，我们可以利用这几个神经元值来表示巨大的输入数据空间，这使得处理速度更快。
📄学习算法
作为 SOM 的基本模型，我们将从’N '-维输入数据空间映射到一个二维神经元阵列(’ N '个神经元)。该 SOM 可以使用以下过程来实现:
🛠设置:
- “P” 输入矢量数量可用。(i= 1，2，…，P)
- 第 I 个输入向量有 n 个元素: Xᵢ = (xᵢ1，xᵢ2，…，xᵢn)
- **“N”**神经元数量(节点或权重)可用。(i= 1，2，…，N)
- 第 I 个神经元向量有 n 个元素: mᵢ = (mᵢ1，mᵢ2，…，mᵢN)
- 这些神经元向量排列成 2D 矩阵来表示。
- 假设所有向量元素都是实数。
SOM 基本模型的建立—输入向量和神经元矩阵(图片由作者提供)
🔖活动动态:
对于给定的输入 Xᵢ ，找到离给定输入最近(最小欧氏距离)的神经元，并用 c 表示该神经元。
✏️学习动力公司:
对于给定的输入 Xᵢ ，在找到 mc 神经元后，仅更新 mc 的邻域神经元集合:
对于 t = 0，1，2，… T 。(t 是模型将被更新的迭代次数，并且 mᵢ (0) 可以是初始的任意向量)。函数 hci(t) 是所谓的邻域函数，在格点(矩阵元素)上定义的平滑核。
由于我们只有需要更新 mc 神经元周围的邻近神经元，首先我们需要找到神经元 mc 周围矩阵点的邻域集合。下面给出了一个简单的拓扑邻域查找方法，更高级的平滑邻域查找方法可以在文献中找到。
在 Nc(t) 内寻找数组点的邻域集——绿色神经元是 mc 神经元，蓝色神经元是神经元的邻域集，只会更新(图片由作者提供)
标记为 Nc(t) 的圆内的所有神经元，我们认为它们是‘MC’神经元的邻域集合。神经元的邻域集合半径 Nc(t) 通常在迭代(t)中单调递减。我们通常从 Nc(0) = √N/2 开始，我们需要在每次迭代中减小半径。
在找到需要更新的邻域神经元集后，我们可以使用下面的 hci(t) 函数，更新 mc 周围的神经元。
在这个方程中， || rc — ri|| 定义了神经元的 2D 矩阵位置之间的距离( √N x √N 矩阵)。 α(t) 的值被识别为学习率因子(0 < α(t) < 1)。 α(t) 和 σ(t) 都是时变的单调递减函数，如下:
对每个输入数据向量( P 个输入数据向量)进行学习。然后在相同的输入数据向量上重复进行相同的过程 T 次迭代。经过 T 次迭代后，你将得到一个完全学习过的神经元矩阵，它映射了我们的输入数据值。
📦MATLAB 实现
使用上述算法，Teuvo Kohonen 的《自组织地图》一书中提到的几个有趣的例子已经使用 MATLAB 实现，您可以将其复制到您的本地计算机，如下所示:
git clone [https://github.com/KosalaHerath/kohonen-som.git](https://github.com/KosalaHerath/kohonen-som.git)
让我们将存储库的 home 定义为 < REPO_HOME > 。然后，转到以下位置，您可以找到三个 MATLAB 实现示例，并且可以在您的计算机上使用任何 MATLAB 版本运行它们:
<REPO_HOME>/source/kohonen_examples
否则，您只需单击以下链接并转到实施库:
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/KosalaHerath/kohonen-som.git)
这些例子从均匀随机分布的二维( n=2 )输入数据向量开始。共有 1000 个输入数据值( P=1000 )。此外，我们将神经元的数量定义为 N = 10 x 10 = 100 ，迭代次数定义为 T = 300 。您可以更改这些参数，并使用上面的实现来处理模型。
📍示例 1:平方输入分布
这个例子的输入数据值是在 2 维空间上随机分布的正方形。
方形输入分布的 SOM 学习数据表示-输入以蓝点表示，模型的神经元值以红点表示，时间为 1、50、250 和 300(图片由作者提供)
📍示例 2:三角形输入分布
该示例的输入数据值是在二维空间上随机分布的三角形。
三角形输入分布的 SOM 学习数据表示——在第 1、50、250 和 300 时段，输入用蓝点表示，模型的神经元值用红点表示(图片由作者提供)
📍示例 3:具有 1D 神经元阵列的三角形输入分布
这个例子的输入数据值是在 2 维空间上的正方形形状的随机分布，并且特别地，我们考虑 1D 神经元阵列而不是 2D 矩阵。因此，由神经元阵列所作的线将试图覆盖如下的所有输入数据分布。
1D 神经元阵列的 SOM 学习数据表示——在第 1、50、250 和 300 时段，输入用蓝点表示，模型的神经元值用红点表示(图片由作者提供)
因此，现在您可以通过不同的输入和修改来学习和使用这些实现，并且您尝试的越多，您会理解得越好。请在此 处提出任何修改来改进 的这些实现。
干杯！🍺
🗞参考
[1] Krogh，A. (2008 年)。什么是人工神经网络？自然生物技术，26(2)，第 195–197 页。
人工神经网络已被应用于从语音识别到蛋白质预测等问题
www.nature.com](https://www.nature.com/articles/nbt1386)
[2] Teuvo Kohonen (2001 年)。自组织地图。纽约斯普林格。
[## 自组织地图| Teuvo Kohonen | Springer
自从这本书的第二版在 1997 年初出版以来，在……
www.springer.com](https://www.springer.com/gp/book/9783540679219)
如何用 NumPy 实现线性回归
更好地理解线性回归并提高您的数字技能
作者图片
我们先简单回忆一下什么是线性回归:
L 线性回归是根据一些其他已知变量以线性方式估计未知变量。视觉上，我们通过我们的数据点拟合一条线(或更高维的超平面)。
如果你对这个概念不太适应，或者想更好地理解它背后的数学原理，你可以阅读我以前写的关于线性回归的文章:
线性回归背后的数学详细解释
towardsdatascience.com](/understanding-linear-regression-eaaaed2d983e)
现在，让我们把重点放在实现上。
首先，很明显，我们需要导入一些库。我们导入numpy，因为它是我们用于实现的主要内容，matplotlib用于可视化我们的结果，以及来自sklearn的make_regression函数，我们将使用它来生成一个回归数据集作为示例。
**import** **numpy** **as** **np****import** **matplotlib.pyplot** **as** **plt****from** **sklearn.datasets** **import** make_regression
然后我们将使用以下方法创建一个LinearRegression类:
.fit()—该方法将实际学习我们的线性回归模型；在这里，我们将找到最佳权重.predict()—这个将用于预测；它将返回我们的线性模型的输出.rmse()—用给定的数据计算我们的模型的均方根误差；这个指标有点像“从我们的模型估计值到真实 y 值的平均距离”
我们在.fit()中做的第一件事是将一个额外的 1 列连接到我们的输入矩阵 x。这是为了简化我们的数学，并将偏差视为一个始终为 1 的额外变量的权重。
.fit()方法将能够通过使用封闭公式或随机梯度下降来学习参数。为了选择使用哪一个，我们将有一个名为method的参数，它需要一个字符串“solve”或“sgd”。
当method设置为“求解”时，我们将通过以下公式获得模型的权重:
这要求矩阵 X 具有满列秩；因此，我们将检查这一点，否则我们会显示一条错误消息。
我们的第一部分.fit()方法是:
注意method之后的其他参数是可选的，仅在我们使用 SGD 的情况下使用。
该方法的第二部分处理method = ‘sgd’的情况，它不要求 X 具有完整的列秩。
我们的最小二乘线性回归的 SGD 算法概述如下:
我们将通过将 weights 类属性初始化为一个 numpy 向量来开始此算法，该向量的值取自均值为 0、标准差为 1/(列数)的正态分布。我们将标准偏差除以列数，以确保在算法的初始阶段不会得到太大的输出值。这是为了帮助我们更快地收敛。
在每次迭代的开始，我们随机地打乱我们的数据行。然后，对于每一批，我们计算梯度并将其从当前权重向量中减去(乘以学习率),以获得新的权重。
下面是我们.fit()方法的后半部分:
我们从这个方法返回self，以便能够像这样连接构造函数和.fit()的调用:lr = LinearRegression().fit(X, y, ‘solve’)。
.predict()方法相当直接。我们首先检查之前是否调用了.fit()，然后将一列 1 连接到 X，并验证 X 的形状允许与权重向量相乘。如果一切正常，我们只需返回 X 和权重向量相乘的结果作为预测。
在.rmse()中，我们首先使用.predict()获得模型的输出，然后如果预测期间没有错误，我们计算并返回均方根误差，该误差可以被认为是“从我们的模型估计值到真实 y 值的平均距离”。
下面是LinearRegression类的完整代码:
在一个例子中使用我们的LinearRegression类
为了展示我们的线性回归实现，我们将使用来自sklearn的make_regression()函数生成一个回归数据集。
X, y = make_regression(n_features=1,
n_informative=1,
bias=1, noise=35)
让我们绘制这个数据集，看看它是什么样子的:
plt.scatter(X, y)
作者图片
make_regression()返回的 y 是平面向量。我们将把它改造成一个列向量，用于我们的LinearRegression类。
y = y.reshape((-1, 1))
首先，我们将使用method = ‘solve’来拟合回归线:
lr_solve = LinearRegression().fit(X, y, method='solve')plt.scatter(X, y)plt.plot(X, lr_solve.predict(X), color='orange')
作者图片
上述回归模型的均方根误差为:
lr_solve.rmse(X, y)
# 35.59874949855057
然后，我们也使用method = ‘sgd’，我们将让其他参数具有它们的默认值:
lr_sgd = LinearRegression().fit(X, y, method='sgd')plt.scatter(X, y)plt.plot(X, lr_sgd.predict(X), color='orange')
作者图片
如你所见，上面两幅图中方法“solve”和“sgd”的回归线几乎相同。
使用“sgd”时，我们得到的均方根误差为:
lr_sgd.rmse(X, y)
# 36.34038690848635
这是 Jupyter 笔记本，包含所有代码:
我希望这些信息对您有用，感谢您的阅读！
这篇文章也贴在我自己的网站这里。随便看看吧！
如何用 PyTorch 实现线性回归
通过实现线性回归学习 PyTorch 基础知识
作者图片
很可能，用 PyTorch 实现线性回归是大材小用。这个库是为神经网络、复杂的深度学习架构等更复杂的东西而创建的。尽管如此，我认为使用它来实现一个更简单的机器学习方法，比如线性回归，对于那些想开始学习 PyTorch 的人来说是一个很好的练习。
在其核心，PyTorch 只是一个类似于 NumPy 的数学库，但是有两个重要的改进:
- 它可以使用 GPU 来加快运算速度。如果您正确配置了兼容的 GPU，只需做一些更改，就可以让代码在 GPU 上运行。
- 它能够自动区分；这意味着对于基于梯度的方法，您不需要手动计算梯度，PyTorch 会为您完成。
你可以把 PyTorch 想象成服用类固醇的 NumPy。
虽然这两个功能对于我们在这里想要做的事情(线性回归)来说似乎不是很大的改进，因为这不是非常昂贵的计算，并且手动计算梯度非常简单，但它们在深度学习中有很大的不同，在深度学习中，我们需要大量的计算能力，并且手动计算梯度非常困难。
在着手实现之前，让我们先简单回忆一下什么是线性回归:
线性回归是通过一些其他已知变量以线性方式估计未知变量。视觉上，我们通过我们的数据点拟合一条线(或更高维的超平面)。
如果你对这个概念不太适应，或者想更好地理解它背后的数学原理，你可以阅读我以前写的关于线性回归的文章:
线性回归背后的数学详细解释
towardsdatascience.com](/understanding-linear-regression-eaaaed2d983e)
现在，让我们跳到编码部分。
首先，很明显，我们需要导入一些库。我们导入torch，因为它是我们用于实现的主要内容，matplotlib用于可视化我们的结果，sklearn中的make_regression函数，我们将使用它来生成一个回归数据集作为示例，以及 python 的内置math模块。
**import** **torch****import** **matplotlib.pyplot** **as** **plt****from** **sklearn.datasets** **import** make_regression**import** **math**
然后我们将使用以下方法创建一个LinearRegression类:
.fit()—该方法将实际学习我们的线性回归模型；在这里，我们将找到最佳权重.predict()—这个将用于预测；它将返回我们的线性模型的输出.rmse()—用给定的数据计算我们的模型的均方根误差；这个指标有点像“从我们的模型估计值到真实 y 值的平均距离”
我们在.fit()中做的第一件事是将一个额外的 1 列连接到我们的输入矩阵 x。这是为了简化我们的数学，并将偏差视为一个始终为 1 的额外变量的权重。
.fit()方法将能够通过使用封闭形式的公式或随机梯度下降来学习参数。为了选择使用哪个，我们将有一个名为 method 的参数，该参数需要一个字符串“solve”或“sgd”。
当method设置为“求解”时，我们将通过以下公式获得模型的权重:
这要求矩阵 X 具有满列秩；因此，我们将检查这一点，否则我们会显示一条错误消息。
我们的第一部分.fit()方法是:
注意method之后的其他参数是可选的，仅在我们使用 SGD 的情况下使用。
该方法的第二部分处理method = ‘sgd’的情况，它不要求 X 具有完整的列秩。
我们的最小二乘线性回归的 SGD 算法概述如下:
我们将通过将 weights 类属性初始化为一个张量来开始此算法，该张量是一个列向量，其值取自均值为 0、标准差为 1/(列数)的正态分布。我们将标准偏差除以列数，以确保在算法的初始阶段不会得到太大的输出值。这是为了帮助我们更快地收敛。
在每次迭代的开始，我们随机地打乱我们的数据行。然后，对于每一批，我们计算梯度并将其从当前权重向量中减去(乘以学习率),以获得新的权重。
在上面描述的 SGD 算法中，我们已经展示了手动计算的梯度；就是那个表达式乘以 alpha(学习率)。但是在下面的代码中，我们不会显式地计算这个表达式；相反，我们计算损失值:
然后我们让 PyTorch 为我们计算梯度。
下面是我们.fit()方法的后半部分:
为了计算损失相对于权重的梯度，我们需要在self.weights张量上调用.requires_grad_(True)方法，然后我们根据上面给出的公式计算损失。计算损失后，我们在损失张量上调用.backward()方法，该方法将计算梯度并将其存储在self.weights的.grad属性中。在我们完成更新后，我们调用.detach()来获得一个新的张量，上面没有记录任何运算，这样下次我们计算梯度时，我们将只基于单次迭代中的运算。
我们从这个方法返回self，以便能够像这样连接构造函数和.fit()的调用:lr = LinearRegression().fit(X, y, ‘solve’)。
.predict()方法非常简单。我们首先检查之前是否调用了.fit()，然后将一列 1 连接到 X，并验证 X 的形状允许与权重向量相乘。如果一切正常，我们只需返回 X 和权重向量相乘的结果作为预测。
在.rmse()中，我们首先使用.predict()获得模型的输出，然后如果预测期间没有错误，我们计算并返回均方根误差，该误差可以被认为是“从我们的模型估计值到真实 y 值的平均距离”。
下面是LinearRegression类的完整代码:
在一个例子中使用我们的LinearRegression类
为了展示我们的线性回归实现，我们将使用来自sklearn的make_regression()函数生成一个回归数据集。
X, y = make_regression(n_features=1, n_informative=1,
bias=1, noise=35)
让我们绘制这个数据集，看看它是什么样子的:
plt.scatter(X, y)
作者图片
make_regression()返回的 y 是平面向量。我们将把它重新整形为一个列向量，用于我们的LinearRegression类。
y = y.reshape((-1, 1))
首先，我们将使用method = ‘solve’来拟合回归线:
lr_solve = LinearRegression().fit(X, y, method='solve')plt.scatter(X, y)plt.plot(X, lr_solve.predict(X), color='orange')
作者图片
上述回归模型的均方根误差为:
lr_solve.rmse(X, y)# tensor(31.8709, dtype=torch.float64)
然后，我们也使用method = ‘sgd’，我们将让其他参数有它们的默认值:
lr_sgd = LinearRegression().fit(X, y, method='sgd')plt.scatter(X, y)plt.plot(X, lr_sgd.predict(X), color='orange')
作者图片
如你所见，上面两幅图中方法“solve”和“sgd”的回归线几乎相同。
使用“sgd”时，我们得到的均方根误差为:
lr_sgd.rmse(X, y)# tensor(31.9000, dtype=torch.float64)
这是 Jupyter 笔记本，包含所有代码:
我希望这些信息对你有用，感谢你的阅读！
这篇文章也贴在我自己的网站这里。随便看看吧！
如何实现深度 Q 网络的优先化体验重放
学习如何训练一个智能代理人降落飞船
在本文中，我们将使用名为 Lunar Lander 的 OpenAI 环境来训练一个代理像人类一样玩！为了做到这一点，我们将实现一个名为优先体验重放的深度 Q 网络算法版本。
SpaceX 在 Unsplash 上拍摄的
为了对我们想要完成的事情有一个概念，让我们看一个未经训练的代理人玩这个游戏。当目标落在两个黄旗之间时，我们可以看到代理仍有许多要学习的地方！
首先，让我们回忆一下，把事情放在上下文中。什么是深度 Q-网络(DQN ),我们为什么要使用它？在全球范围内，我们想要解决什么样的问题？
深度 Q 网络属于强化学习算法家族，这意味着我们将自己置于环境能够与代理交互的情况下。代理能够采取一个动作，将它从一个状态带入另一个状态。然后，环境会为达到这种新状态提供奖励，奖励可以是积极的，也可以是消极的(惩罚)。我们想要解决的问题是能够为每个状态选择最佳行动，从而使我们的总累积回报最大化。
归功于 Lilian Weng @ Lilian Weng . github . io/
对于强化学习算法来说，给定一个状态，提供最佳累积奖励的动作不应该依赖于过去访问过的状态。这个框架被称为马尔可夫决策过程。通过多次访问各州，并用我们实际获得的奖励来更新我们的预期累积奖励，我们就能够找出对每一种环境状态采取的最佳行动。这是 Q 网络算法的基础。
现在，当我们有有限数量的状态时，这是非常好的，例如当一个代理在一个网格中移动时，状态是由它所在的情况定义的。我们现在希望解决的问题是非有限状态变量(或动作)的情况。例如，机器人手臂的环境状态是关节位置和速度的列表。由于状态是不确定的，所以我们不太可能多次访问一个状态，从而无法更新对最佳行动的估计。我们需要某种东西，在给定两个与我们当前状态足够接近的已知状态的情况下，能够预测在我们当前状态下应该采取的最佳行动。你猜对了，解决方案是某种形式的插值。当线性插值只是“在两个状态之间画一条线”时，我们需要能够以更高的复杂度进行预测。这就是神经网络登场的地方。神经网络为我们提供了利用非线性模型预测给定已知状态(及其最佳行动)的最佳行动的可能性。这就是深度 Q 网。DQN 提出了几个与神经网络的训练部分相关的实现问题。这个“技巧”被称为经验重放，基本上是指我们偶尔停止访问环境，以首先收集一些关于过去访问状态的数据，然后根据收集的经验训练我们的神经网络。换句话说，它在探索阶段和训练阶段之间交替，将这两个阶段解耦，从而允许神经网络向最优解收敛。
既然我们已经很好地理解了是什么把我们带到了 Q-Network，那就让乐趣开始吧。在本文中，我们想要实现一个名为优先体验重放的 DQN 的变体(参见发布链接)。这个概念非常简单:当我们对经验进行采样以输入神经网络时，我们假设一些经验比其他经验更有价值。在一个统一的抽样 DQN 中，所有的经历都有相同的概率被抽样。因此，在培训结束时，每项经验的使用次数都大致相同。如果我们用权重进行采样，我们可以让一些更有益的体验平均被采样更多次。现在我们如何分配每次经历的权重呢？该出版物建议我们计算一个抽样概率，该概率与神经网络正向传递后获得的损失成比例。这相当于说，我们希望保留那些导致预期奖励和实际获得的奖励之间存在重要差异的经历，或者换句话说，我们希望保留那些让神经网络学到很多东西的经历。
好了，现在我们有了概念，是时候在一个真实的案例场景中实现了。我们将尝试解决名为“月球登陆者”的 OpenAI 健身房环境。在这个环境中，代理人是一艘受到重力作用的宇宙飞船，它可以采取 4 种不同的行动:什么也不做或启动左、右或底部引擎。如果宇宙飞船降落在正确的位置，我们会得到奖励，如果着陆器坠毁，我们会受到惩罚。每次我们使用底部油门时，我们也会受到一点惩罚，以避免收敛到人工智能将着陆器保持在空中的情况。
现在我们可以质疑我们解决这个问题的方法。这里为什么要用深 Q 网？这种环境的状态由 8 个变量描述:x，y 坐标和速度，着陆器的旋转和角速度，以及两个布尔变量来说明着陆器的腿是否与地面接触。正如我们所看到的，大多数变量是连续的，因此 Q 网络的离散方法是不够的，我们需要能够插入我们期望在一个状态下获得的总回报，以选择最佳行动，这里使用神经网络。
现在出现了另一个问题，在这种情况下，对一些经历进行优先排序如何帮助我们获得更好或更快的结果？当我们开始训练我们的算法时，着陆器很可能会在大多数情况下崩溃。然而，着陆器可能会在不坠毁的情况下接触地面，或者在极少数情况下正确着陆。在这种情况下，预期结果(负回报)和实际产出(正回报)之间的差异将是显著的，导致这种体验被抽样的概率高得多。在某种意义上，我们希望多次使用这种经验来训练神经网络，作为什么在起作用以及我们应该采取什么方向来提高网络权重的例子。
太好了，我们现在确信我们的方法是有效的。让我们深入研究一下实现的细节。我们将把重点放在类“ReplayBuffer”上，因为它包含了与优先体验重放相关的大部分实现，但其余代码可在 GitHub 上获得。我们将设定的目标是提高算法的快速性(能够用更少的情节来解决环境)，而不会由于额外的计算复杂性而牺牲运行时间。为了做到这一点，我们将会小心使用哪些类型的容器来存储我们的数据，以及我们如何访问和整理数据。该出版物引用了两种存储优先级的方法，一种是使用常规容器，另一种是使用 sum 树，sum 树是一种自定义数据类型，可以在复杂度为 o(1)的优先级上授予写和访问权限。在这里，我们将尝试把重点放在使用常规容器的实现上，因为优化以降低复杂性似乎更具挑战性，这提供了一个很好的编码练习！
这里，我们假设深度 Q 网络的实现已经完成，也就是说，我们已经有了一个代理类，它的作用是通过在每一步将经验保存在重放缓冲器中来管理训练，并且不定期地训练神经网络。神经网络也已经被定义，这里我们选择了一个神经网络，其具有两个分别具有 256 和 128 大小的具有 ReLu 激活的神经元的隐藏层，以及最后的线性激活层。
在统一采样 DQN 中，我们通过线性分布随机采样体验，这意味着我们只需要一个容器来存储体验，而不需要任何额外的计算。对于优先体验重放，我们确实需要将每个体验与附加信息、其优先级、概率和权重相关联。
根据神经网络前向传递后获得的损失更新优先级。概率是从经验优先级中计算出来的，而权重(校正在神经网络反向传递期间由不均匀采样引入的偏差)是从概率中计算出来的。论文引入了另外两个超参数α和β，它们控制了我们想要优先化的程度:在训练结束时，我们想要统一采样，以避免由于一些经验被不断优先化而导致的过度拟合。这些等式可以在下面找到:
P =优先级，P =概率，w =权重，N =经历次数
根据作者的说法，仅在优先体验重放的情况下，权重可以被忽略，但是当与双 Q 网络(另一种 DQN 实现)相关联时，权重是强制性的。这里仍将实现权重，以用于与双 Q 网络结合的潜在用途。
因此，与统一的 DQN 相比，我们现在有 3 个与体验相关联的值。更糟糕的是，我们需要能够更新这些变量。在实现方面，这意味着在随机抽样我们的经验后，我们仍然需要记住我们从哪里获得这些经验。具体地说，就是在我们采样的时候记住容器中经验的索引(啊，如果我们有指针就好了)。所以我们现在有 4 个相关的变量。我们选择的容器是一本字典。实际上有两个字典，一个用于体验本身，一个用于相关数据，这很好，因为我们无论如何都需要记住索引。因为我们需要在神经网络中处理完数据后再找回来，所以字典是一个很好的选择，因为它的访问器的复杂度是 o(1)量级，因为我们不需要浏览整个容器。对于这两个字典，值都是命名元组的形式，这使得代码更加清晰。我们还添加了一个小的 for 循环来初始化字典索引。
接下来，让我们剖析一下可能是计算量最大的一步，随机采样。这是很昂贵的，因为为了进行加权采样，我们可能需要对包含概率的容器进行排序。为了进行采样，我们使用 random.choices 函数，让我们看看这是如何实现的。
如果我们浏览 Python 文档中的平分函数，我们可以看到这一点:“该模块支持按排序顺序维护列表，而不必在每次插入后对列表进行排序”。答对了。无需深入研究代码，该函数确实需要在每次调用 random.choices 时至少对容器排序一次，这相当于 o(n)量级的复杂性。我们的字典有 10e5 大小，这一点远非微不足道。我们真的负担不起对每个样品进行分类，因为我们每四步取样一次。解决这个问题的一个方法是在 prevision 中对多个神经网络训练一次采样多个批次。我们看到 random.choices 是用 bissect 函数实现的，它确保容器只排序一次，因此对更多批次进行采样不会增加任何复杂性。
这种方法有两个缺点:
- 当我们对第一批以外的其他批次进行采样时，我们使用的优先级不是最新的。这实际上是没问题的，因为下一批采样的优先级仍然是更新的，所以在多次采样迭代后不会看到这种差异。
- Python 的 random.choices 将对相同的值进行多次采样。如果我们只对收集的状态的一部分进行采样，这实际上并没有什么不同，但是如果我们一次对太多批次进行采样，一些状态将会被过度采样。对实现进行的测试表明，采样大小为 2000(与大小为 10e5 的容器相比)显示出最好的结果。
让我们看看这是如何在 ReplayBuffer 类中实现的:
这里，变量 update_mem_every 和 update_nn_every 分别表示我们希望计算一组新的经验批次的频率以及我们希望训练网络的频率。current_batch 变量表示当前用于向神经网络提供数据的批次，此处重置为 0。
我们现在能够用概率权重有效地对经验进行抽样。让我们看一下 PER 算法，以了解如何将我们的采样包含在更大的画面中。
我们可以注意到对于计算复杂度优化来说很棘手的两件事:能够记住每一步的最大优先级和最大权重。这看起来很容易做到，基本上只是在每一步比较新更新的值和最大值。但这忘记了容器是固定大小的，这意味着每一步我们还将删除一个体验，以便能够再添加一个。现在，如果我们删除最大值，我们如何找到第二高的值？我们应该总是跟踪容器中值的顺序吗？当然不是！这意味着每一步的复杂度为 o(n)。实际上，每次删除最大值时，我们可以简单地找到最大值。因此，我们跟踪最大值，然后将每个删除的条目与它进行比较。通常，要删除的体验已经被使用过几次了，所以它们的优先级应该很低，因为它实际上是最大值的机会。所以我们可以偶尔对容器进行分类。请参见下面第 9 行的代码:
要指出的是，我们还有一个名为 priorities_sum_alpha 的变量。从抽样概率的定义中可以看出，每次都需要计算所有记录的经验优先级的总和的α次方。当然，我们不希望每次都从头开始计算这个值，所以我们会跟踪它，并在添加/删除体验时更新它。
我们的代码被优化了很多，总的来说我们应该有 o(n/T)的复杂度，T 是我们一次采样的批次数量。当然，复杂性取决于那个参数，我们可以利用它来找出哪个值会导致最佳效率。
是时候测试我们的实现了！我们运行了两个测试，一个使用优先体验重放实现，另一个使用统一采样 DQN。我们绘制了如下所示的图表:
优先体验重放分数的演变
均匀抽样得分的演变
不，这不是一个错误，均匀抽样优于优先抽样！两种算法都使用相同的超参数运行，因此可以比较结果。我们发现，通过使用优先采样，我们可以在大约 800 集内解决环境问题，而在均匀采样的情况下，我们可以在大约 500 集内解决环境问题。尽管我们研究了理论，发现优先化经验是有益的！有几个原因可以解释这里的问题:
- 我们可以从出版物中看到，优先化体验在多种环境中有不同的结果。特别地，在基于等级和比例的两种提出的方法之间已经存在性能上的差距。还不确定月球着陆器是否会从优先体验中受益。
- 在该出版物中，所有的实验都是在双 Q 网络算法的基础上优先考虑体验。作者没有详细说明这种实现对 PER 结果的影响。有可能实现两个决斗 Q 网络将使优先体验重放释放其全部潜力。
- 我们不能不注意到，月球着陆器是一个相当简单的解决环境，大约需要 400 次经验。Atari 系列的其他游戏可能需要多几个数量级的体验才能被考虑解决。毕竟，在我们的情况下，最重要的经历，比如说在没有摔倒的情况下获得高额奖励，并不罕见。对它们进行过多的优先排序会使神经网络过度适应这一特定事件。换句话说，你将学会正确地接触地面，但不知道如何接近地面！
事实上，我们试图调整算法，以便只优先考虑积极的体验。这背后的原因是，当学习如何玩时，算法崩溃的可能性比正确着陆的可能性大得多，而且由于我们可以在比我们可以着陆的更广的区域崩溃，我们往往会记住更多的崩溃经历。为此，我们尝试进行如下调整:我们查看神经网络实际输出和期望值之间的符号差。如果是积极的，我们实际上获得了比预期更好的回报！然后我们应用一个 ReLu 函数，如果差值为负，则赋为 0，否则不做任何事情。在重放缓冲器中，为了不仅仅删除具有负差异的体验，我们给它们分配平均优先级。
从理论上来说，这将导致简单地优先考虑更多具有高积极回报差异(着陆)的经历。在实践中，这是一个不同的故事…算法甚至不再收敛！说实话，对经历进行优先排序是一个危险的游戏，很容易产生偏见，也很容易一遍又一遍地对相同的经历进行优先排序，从而导致网络过度适应一部分经历，无法正确地学习游戏。该出版物确实建议将 alpha 值(控制您对优先级的依赖程度)退火为 0，以便我们倾向于使用均匀采样，但在我们的情况下，这只会导致算法在足够的迭代后收敛。
即使该算法没有带来更好的学习性能，我们仍然可以验证我们的另一个目标，降低计算复杂性，是满足。为此，我们将使用我们所知的解决环境问题的统一采样算法，以及优先化经验实现的一个修改版本，其中参数α被赋值为 0。这样，我们可以统一采样，同时保持区分经验优先级的复杂性:我们仍然需要加权采样，更新每个训练批次的优先级，等等。由于这两个实验是相似的，我们可以安全地直接比较训练持续时间
优先和均匀采样的经验处理中计算时间的演变
正如我们所看到的，我们的实现确实将求解环境的总计算时间从 2426 秒增加到了 3161 秒，这相当于大约增加了 34%。考虑到我们要做的事情的复杂性，这是一个可以接受的代价(在每次迭代中访问和修改容器的元素，命令容器经常从中采样)。从图表中可以看出，在 300 集之前，这两种算法需要的处理时间大致相同，但之后就出现了分歧。这是可以理解的，因为 10e5 元素的容器大约在这个阶段变满。还记得如果我们删除了最高优先级值，就必须更新所有容器的小细节吗？这没关系，因为这几乎不会发生。在这里，所有的优先级都是一样的，所以每次容器装满时都会发生。因此，为了进行真正的比较，我们可以将自己限制在前 300 次体验中，这两种实现之间几乎没有区别！要注意的是，该出版物提到它们用和树的实现导致大约 3%的额外计算时间。看来我们的实现可以提供类似的结果，这是相当令人满意的。
当然，这些结果取决于为优先化体验重放实现选择的超参数，即您想要一次采样多少批次，以及您想要多频繁地更新参数α和β(需要更新缓冲区中的每个概率)。这两个值越大，算法的计算速度就越快，但这可能会对训练产生不可忽略的影响。由于我们的算法在这一部分没有提供好处，因此很难定义最佳参数，但应该可以对一组参数进行基准测试，并确定最佳的整体折衷方案。
在这个实验中我们能得出什么结论？首先，我们能够在几乎没有额外计算复杂度的情况下实现深度 Q 网络的优先化体验重放。第二，这种实现似乎没有提高代理在这种环境下的学习效率。那么接下来我们能做什么呢？
- 实施决斗 Q-网络和优先体验重放。
- 在其他环境中尝试这个代理，看看在给定的实现下，优先化的体验重放是否可以提高结果。
- 实施基于等级的优先体验重放(使用 sum 树的那种),因为它声称可以提供更好的结果。
最后但同样重要的是，让我们观察一个训练有素的代理玩游戏！经过那些可怕的计算后，我们应该得到这些。当然，我们使用优先内存重放实现中训练有素的代理，这花费了更多的时间，但它仍然训练有素！
为了提高…
完整代码:https://github.com/Guillaume-Cr/lunar_lander_per
出版地:【https://arxiv.org/abs/1511.05952
如何从零开始用 Python 实现一个高斯朴素贝叶斯分类器？
你有没有问过自己最古老的机器学习算法是什么？
今天，我们有很多机器学习算法，从简单的 KNN 到集成算法，甚至神经网络。有时它们看起来如此复杂，以至于你可以认为它们是最近几年开发的，而机器学习，总的来说，是一种新事物。但是第一个算法出现的时间比你想象的要早。
朴素贝叶斯算法。
朴素贝叶斯算法是最古老的机器学习形式之一。贝叶斯理论(该算法的基础)和统计学基础是在 18 世纪发展起来的。从那以后，直到 50 年代，计算都是手工完成的，直到出现了第一台计算机实现这种算法。
但是这个算法有什么简单到可以手动使用的呢？
该算法的最简单形式由两个主要部分组成:
- 朴素贝叶斯公式(定理)。
- 和分布(在这种情况下是高斯分布)。
朴素贝叶斯理论。
朴素贝叶斯理论在大多数情况下可以简化为一个公式:
朴素贝叶斯公式[来源—https://miro . medium . com/max/640/1 * 7lg _ ul M8 _ 1 fygjxpbtrqfq . png]
这个公式意味着事件 A 发生的概率知道事件 B 已经发生了…
不知何故，对朴素贝叶斯理论的解释超出了本文的范围，这就是为什么我强烈推荐你阅读这篇关于 NB 理论的文章。
什么是发行版？
分布，基本上是显示数值是如何在数列中分散的，以及它们在这个数列中出现的频率。这里有一个例子:
从上图中可以看出，高斯分布或正态分布取决于一个系列的两个参数——平均值和标准差。知道这两个参数的序列，我们可以找到它的分布函数。它有下一种形式:
高斯分布函数[来源—https://i.stack.imgur.com/bBIbn.png
但是，我们为什么需要这个功能呢？很简单，世界上大多数数据都表示为连续值，但是你猜怎么着，你不能计算 X 值的概率来得到 v 值，它会是 0。为什么？从技术上来说，当你将某物除以无穷大时，你会得到什么？正确——零。
那么，我们该如何解决这个问题呢？当然，使用高斯分布函数，如上图所示。输入一个序列的平均值和它的标准偏差，而不是 x 值，你可以找出 x 值出现的概率。瞧。
那么这一切是如何协同工作的呢？
我不知道为什么，但对我个人来说，有时候通过在代码中实现算法会更容易理解算法是如何工作的。让我们开始吧:
- 首先，让我们导入所有的依赖性:
# Importing all needed libraries
import numpy as np
import math
就这些，是的，我们需要纯粹的数字和数学库。
2.现在让我们创建一个类，该类将实现算法和第一个函数，该函数将按类分离我们的数据集。
# gaussClf will be the class that will have the Gaussian naive bayes classifier implimentation
class gaussClf:
def separate_by_classes(self, X, y):
*''' This function separates our dataset in subdatasets by classes '''* self.classes = np.unique(y)
classes_index = {}
subdatasets = {}
cls, counts = np.unique(y, return_counts=True)
self.class_freq = dict(zip(cls, counts))
print(self.class_freq)
for class_type in self.classes:
classes_index[class_type] = np.argwhere(y==class_type)
subdatasets[class_type] = X[classes_index[class_type], :]
self.class_freq[class_type] = self.class_freq[class_type]/sum(list(self.class_freq.values()))
return subdatasets
separate_by_classes 函数按类分离出数据集，分别为每个类计算每列的平均值和标准偏差。
3.拟合函数。
def fit(self, X, y):
*''' The fitting function '''* separated_X = self.separate_by_classes(X, y)
self.means = {}
self.std = {}
for class_type in self.classes:
# Here we calculate the mean and the standart deviation from datasets
self.means[class_type] = np.mean(separated_X[class_type], axis=0)[0]
self.std[class_type] = np.std(separated_X[class_type], axis=0)[0]
接下来是拟合函数，我们只计算每一类每一列的平均值和标准差。
4.高斯分布函数。
def calculate_probability(self, x, mean, stdev):
*''' This function calculates the class probability using gaussian distribution '''* exponent = math.exp(-((x - mean) ** 2 / (2 * stdev ** 2)))
return (1 / (math.sqrt(2 * math.pi) * stdev)) * exponent
calculate_probability 函数使用一个序列的平均值和标准差来计算一个函数在一个序列中出现的概率。
5.预测函数。
def predict_proba(self, X):
*''' This function predicts the probability for every class '''* self.class_prob = {cls:math.log(self.class_freq[cls], math.e) for cls in self.classes}
for cls in self.classes:
for i in range(len(self.means)):
print(X[i])
self.class_prob[cls]+=math.log(self.calculate_probability(X[i], self.means[cls][i], self.std[cls][i]), math.e)
self.class_prob = {cls: math.e**self.class_prob[cls] for cls in self.class_prob}
return self.class_prob
这个函数返回一个字典，其中包含样本属于某个类的概率。在经典的 sklearn 估计器中，predict_proba 函数获取样本列表并返回标签列表。为了使它更容易使用，我决定只在一个例子中实现它。
同样，在这个函数中，我不计算先验概率，以避免无用的计算，因为对于每个类估计，你需要除以上面得到的相同值。
6.预测函数。
def predict(self, X):
*''' This funtion predicts the class of a sample '''* pred = []
for x in X:
pred_class = None
max_prob = 0
for cls, prob in self.predict_proba(x).items():
if prob>max_prob:
max_prob = prob
pred_class = cls
pred.append(pred_class)
return pred
在这里，我决定使用经典的实现方法。列出来，列出来。
你可以在我的 github 库上看到代码。
对比 sklearn。
现在让我们将我们的实现与 sklearn one 进行比较。在 sklearn 库中，Gaussian Naive Bayse 实现为 GaussianNB 类，要导入它，您应该编写以下代码:
from sklearn.naive_bayes import GaussianNB
我们会让你来实施，你可以在那里找到怎么做。那么在虹膜数据集上有什么结果呢？
我们的实现:0.00000000001
Sklearn 实现:1.0 精度。
发生这种情况是因为 sklearn 模型使用了一个比我们使用的模型稍多的其他实现，你可以在 sklearn 网站上阅读更多内容。
结论。
因此，在本文中，我向您展示了如何实现实际上最古老的机器学习算法的最简单形式——高斯朴素贝叶斯算法，并简要介绍了它的工作原理。我强烈建议您学习 sklearn 实现的工作原理，并尝试自己实现 BernoulliNB。
谢谢你。
如何将 CSV 文件导入 MySQL Workbench
入门指南
没有错误
如果你熟悉求职过程，你可能已经注意到一些公司喜欢用带回家的作业来决定候选人是否合适。因为大多数公司都使用 SQL，所以他们通常想看看你是否能使用 SQL 解决问题。然而，并不是所有的公司都会给你提供数据集。很可能一家公司只提供了一个表模式，您可能想知道您的查询是否能实际运行。因此，将数据集导入数据库会非常有帮助。
在本文中，我将介绍如何一步一步地安装 MySQL Workbench 并将数据导入 MySQL Workbench。
入门指南
MySQL Workbench 是数据库架构师、开发人员和 DBA 的统一可视化工具。在这篇文章中，我将使用 Mac OS X 系统。要开始，你需要安装 MySQL 和 MySQL Workbench 。
使用软件包安装程序安装 MySQL:
下载包含 MySQL 包安装程序的磁盘镜像(.dmg)文件(社区版本可从这里获得)。连按文件以装载磁盘映像并查看其内容。
MySQL 安装页面(作者截图)
不要忘记这个密码，因为您稍后将需要它来登录您的 MySQL workbench！(作者截图)
安装完**MySQL和 MySQL Workbench 之后，现在就可以打开 MySQL Workbench 了。我犯了一个错误，没有安装 MySQL，因为我忘记了我安装的 SQL 是 Postgresql。如果你没有安装 MySQL，你将无法连接到数据库。**
MySQL Workbench 检测不到任何 MySQL → 下载 MySQL 的时间。(作者截图)
如果您成功下载 MySQL，您将看到一个弹出窗口，输入您之前设置的相同密码。输入密码后，您应该会看到类似这样的内容:
耶！你连上了 MySQL(作者截图)
现在，您可以点击进入 MySQL 实例。
如果在安装 MySQL 后仍然看到这个错误，可以点击屏幕右上角的“停止按钮或者点击“启动/关机”按钮。
未建立连接错误消息(作者截图)
(作者截图)
****创建一个模式/表
如果您想让表格更有条理，可以为您正在处理的每个项目创建一个模式。这样，您将更容易为每个项目找到不同的表格。您可以简单地右键单击并选择创建模式**。"**
如何创建模式(作者截图)
现在您已经创建了一个模式，您可以选择“创建表或“表 数据导入向导”来在模式中构建一个表。
如何创建表格(作者截图)
下面是您创建表格时将看到的内容:
创建空表格(作者截图)
导入 CSV 文件
首先，找到要导入的 CSV 文件的文件路径。
找到数据的路径(作者截图)
您可以创建一个新表，也可以添加到现有的表中(作者截图)
**不幸的是，我无法导入数据，因为“**表格数据导入向导在 UTF-8 编码的带 BOM 的文件上失败。”我不明白为什么会这样，因为我确实将文件保存为 UTF-8 CSV 格式。
最后，我发现对于 Mac OSX 系统，我们需要使用数字/记事本、打开 CSV 或 excel 文件，然后将文件导出为。csv 格式。
将文件保存为 CSV 文件(作者截图)
有时候只有把编码改成别人才管用(作者截图)
恭喜你！！！你做到了！现在您已经成功地将 CSV 文件加载到 MySQL workbench，您可以开始编写查询了！
简单查询的结果(作者截图)
如果你觉得这很有帮助，请关注我，看看我的其他博客。❤️
下次见，快乐学习！👩🏻💻
举例说明最常见的离散概率分布
towardsdatascience.com](/understanding-and-choosing-the-right-probability-distributions-with-examples-5051b59b5211) [## 作为分析师如何准备商业案例面试？
作为数据分析师或数据科学家，我们不仅需要知道概率和统计，机器学习算法…
towardsdatascience.com](/how-to-prepare-for-business-case-interview-as-an-analyst-6e9d68ce2fd8) [## 为电子商务建立一个产品推荐系统:第一部分——网络搜集
今天，如果我们想到机器学习在商业中最成功和最广泛的应用，推荐者…
medium.com](https://medium.com/@kessiezhang/building-a-product-recommendation-system-for-e-commerce-part-i-web-scraping-798b6251ab51) [## 如何将 Jupyter 笔记本转换成 PDF
用几行代码将 Jupyter 笔记本转换为 pdf(调试“500:内部服务器错误”)
towardsdatascience.com](/how-to-convert-jupyter-notebooks-into-pdf-5accaef3758)**
如何使用 pandas read_csv 命令导入数据
熊猫基础:读取数据文件
马库斯·斯皮斯克在 Unsplash 上拍摄的照片
在任何数据分析项目中，我们都试图从一组给定的数据中发现有用的、可操作的见解。如果我们幸运的话，这些数据可能已经为我们打包好了；如果没有，我们可能需要自己收集。无论哪种方式，一旦数据被存储，我们将需要把它读入一个程序来执行分析。
软件包 pandas 经常用于此目的。这是一个功能强大的库，可以与 Python 编程语言一起工作。在 pandas 中，选择读入数据文件的工具是无处不在的read_csv函数。
在本文中，我们将探索 pandas 的
read_csv命令的基础:标题选项、指定子目录(如果适用的话)、使用逗号以外的分隔符、标识要用作索引的列、定义字段类型以及处理缺失值。
数据
与任何熊猫项目一样，我们首先使用标准别名pd导入熊猫。让我们也使用数字包 NumPy 的标准别名来导入它。
对于我们的例子，让我们读入股票价格数据。这个数据集列出了交易的日期、开盘价、收盘价、最高价和最低价、交易量以及交易代码。
在电子表格程序中显示的前几行数据如下所示。
什么是. csv 文件？
如果我们在文本编辑器中查看数据文件(与上面的电子表格程序相反)，前几行如下。
date,open,high,low,close,volume,Name
2013–02–08,15.07,15.12,14.63,14.75,8407500,AAL
2013–02–11,14.89,15.01,14.26,14.46,8882000,AAL
2013–02–12,14.45,14.51,14.1,14.27,8126000,AAL
2013–02–13,14.3,14.94,14.25,14.66,10259500,AAL
2013–02–14,14.94,14.96,13.16,13.99,31879900,AAL
我们看到第一行由列名组成，也称为字段名称。包含列名的这一行被称为标题。接下来的行列出了对应于该行中每个字段的数据。因此，第一行数据的日期为 2013 年 2 月 8 日，开盘价为 15.07 美元，以此类推。每个数据点与下一个数据点之间用逗号分隔，因此称为“逗号分隔值”(csv)文件。
标题选项
pandas 命令从文件中读取数据并将其存储在一个名为stocks_df的数据帧中，这是一个简单的命令行程序。
为了确保该命令按预期工作，让我们使用head检查数据帧的前几行。
您可能不会对。csv 文件。在这种情况下，通过使用usecols选项指定想要读入数据框的列。例如，如果您只对日期、成交量和股票名称感兴趣，请指定usecols=['date', 'volume', 'Name']。
正如预期的那样，只有我们指定的列包含在数据框中。
默认情况下，pandas 假设数据的第一行是一个标题。当然，并不是每个数据文件都有标题。例如，假设我们有一个没有标题的数据文件，如下所示。
2013-02-08,15.07,15.12,14.63,14.75,8407500,AAL
2013-02-11,14.89,15.01,14.26,14.46,8882000,AAL
2013-02-12,14.45,14.51,14.1,14.27,8126000,AAL
2013-02-13,14.3,14.94,14.25,14.66,10259500,AAL
2013-02-14,14.94,14.96,13.16,13.99,31879900,AAL
如果我们像以前一样尝试读取文件，我们将不会得到我们想要的结果。
pandas 假定第一行是一个标题，并照此读入。在这种情况下，这不是我们想要的，因为第一行是数据。幸运的是，修复很容易——只需指定选项header=None。
现在熊猫从 0 开始给这些列编号。如果您喜欢使用命名列，使用names选项来指定您自己的列名。
目录
在上面的例子中，我将数据文件保存为与我的 Python 程序相同的目录中的stocks.csv。为了保持有序，通常将数据文件保存在子目录中。在这种情况下，在read_csv语句中指定数据子目录。
像以前一样，让我们检查前几行，以确保一切顺利。
分隔符
并非所有数据文件都使用逗号分隔值。可以使用制表符、空格或任何其他字符。例如，我们的数据文件可能是用分号而不是逗号设置的。
date;open;high;low;close;volume;Name
2013-02-08;15.07;15.12;14.63;14.75;8407500;AAL
2013-02-11;14.89;15.01;14.26;14.46;8882000;AAL
2013-02-12;14.45;14.51;14.1;14.27;8126000;AAL
2013-02-13;14.3;14.94;14.25;14.66;10259500;AAL
2013-02-14;14.94;14.96;13.16;13.99;31879900;AAL
要指定逗号以外的分隔符，使用sep选项。
指定要作为索引的列
如果不需要默认索引，可以指定一列作为数据框的索引。例如，要将索引指定为date列，可以使用index_col='date'。
现在，根据需要，日期列就是索引。
类型
让我们检查每个列的类型。
假设我们想要将数字数据存储为 32 位类型以节省空间。为此，将选项dtype设置为一个字典，其中键是列，值是所需的类型。
尽管我们知道数据由日期组成，但是date列是作为通用对象类型读入的。要以日期类型读取列，使用设置为包含列索引的列表的parse_dates选项。
缺少值
数据包含缺失值是很常见的。用某种指示符(如问号或单词“missing ”)来指示缺失值也很常见。
如您所见，第一行数据中缺少两个值，第二行缺少一个值。此外，第三个数据行的一个条目中有一个问号。我们该如何应对？
正如我们所预料的那样，缺失的值被 pandas 读入为“非数字”(NaN)，所以我们对这些值没有进一步的要求。然而，pandas 不知道如何处理表示缺少值的问号。为了纠正这种情况，我们可以将列表中被视为缺失值的值列表传递给na_values选项。
现在问号已经被念成 NaN 了。
进一步阅读
read_csv命令非常灵活，有很多选项。要进一步了解这些选项，请参考文档。
如何使用 Google 的 API v4 (2020)将 Google Sheets 数据导入熊猫数据框架
图片来自 Pixabay
将 Google 工作表数据导入熊猫数据框架
Google Sheets 是一种共享数据和远程协作的有用方式。但是定期将数据转移到 Python 这样的环境中会很麻烦。这篇文章将介绍如何为 Python 设置最新的 Google Sheets API，即 2020 年 6 月的 v4。我们还将介绍如何从 Google 工作表范围(甚至整个工作表)中提取数据到 Pandas 数据框中。
开始之前:
开始之前，您需要以下材料:
- Python 2.6 或更高版本(建议使用 Python 3)
- Pip/pip3 包管理工具(Python 2 >= 2.7.9 或 Python 3 >= 3.4 的标准配置)
- 一个谷歌账户(和包含你感兴趣的数据的谷歌表单)。
API 设置:
首先，你需要在你的 Gmail 账户上启用 Google Sheets API，Google Sheets 就存储在这里。登录您的 Gmail 帐户，访问Google Sheets API Python 快速入门指南。你会看到一个蓝色的“启用 Google Sheets API”按钮。点击按钮(下图中标为[1]):
作者图片
从下拉菜单中选择“桌面应用程序”(下图中标为[2])，然后单击“创建”(下图中标为[3])。这将创建一个客户端配置，我们需要通过 API 设置初始连接:
作者图片
单击蓝色的“下载客户端配置”按钮(在下图中标为[4])。
作者图片
您现在应该已经下载了一个名为“ credentials.json 的文件。您需要将该文件移动到您的工作目录中。
安装 Google 的客户端库:
接下来，我们需要使用 pip 安装 Google 的客户端库:
pip install — upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib
**注意:**我们将使用他们脚本的修改版本，而不是运行 Google 在其指南中提供的示例 Python 代码。
生成我们的 API 用户令牌:
首先，我们将设置我们的 gsheet_api_check() 函数。它查找现有的令牌。pickle 文件(存储我们的用户访问和刷新令牌)。如果没有找到 token.pickle 文件，该功能将提示您登录您的 Google Gmail 帐户。您的工作目录中必须有 credentials.json 才能启动 token.pickle 创建/刷新。该函数生成我们将用来进行 API 调用的凭证:
import pickle
import os.path
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Requestdef gsheet_api_check(SCOPES):
creds = None
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token) if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0) with open('token.pickle', 'wb') as token:
pickle.dump(creds, token) return creds
**注意:**完成初始凭证设置后，我们可以丢弃 gsheet_api_check()和在以后的 api 调用中直接加载我们的令牌。或者，保留 gsheet_api_check() 可能是有益的，因为该函数检查我们的令牌是否过期和/或丢失。如果令牌过期/丢失， gsheet_api_check() 将开始刷新用户令牌(通过提示您重新登录您的 Google 帐户)。您可以决定是继续使用 gsheet_api_check() 还是直接加载令牌。
进行 API 调用:
接下来，我们将定义一个函数，该函数进行 API 调用并从 Google Sheets 中提取我们想要的数据。 pull_sheet_data() 函数建立 API 调用，拉取我们想要的数据。如果没有找到数据，该函数将显示“没有找到数据”，否则它将通过打印“完成:数据已复制”来确认数据已被检索，并返回我们的数据:
from googleapiclient.discovery import builddef pull_sheet_data(SCOPES,SPREADSHEET_ID,DATA_TO_PULL):
creds = gsheet_api_check(SCOPES)
service = build('sheets', 'v4', credentials=creds)
sheet = service.spreadsheets()
result = sheet.values().get(
spreadsheetId=SPREADSHEET_ID,
range=DATA_TO_PULL).execute()
values = result.get('values', [])
if not values:
print('No data found.')
else:
rows = sheet.values().get(spreadsheetId=SPREADSHEET_ID,
range=DATA_TO_PULL).execute()
data = rows.get('values')
print("COMPLETE: Data copied")
return data
注意: 可以修改 pull_sheet_data() 来定义其他 API 任务，比如将数据追加到 google 工作表，更新现有数据，或者创建新的电子表格。
运行我们的 API 调用并将数据保存为 Pandas DataFrame:
接下来，我们需要两条信息。首先，我们需要找到并复制感兴趣的电子表格的 ID。这可以在您的谷歌电子表格的 URL 中找到(在下图中标记为[5]):
作者图片
其次，我们需要从中提取数据的电子表格选项卡的名称。或者，如果希望从电子表格中提取特定的数据部分，可以明确定义要检索的单元格范围(下面提供了示例):
#Pulls data from the entire spreadsheet tab.
DATA_TO_PULL = 'spreadsheet_tab_name'or#Pulls data only from the specified range of cells.
DATA_TO_PULL = 'spreadsheet_tab_name!A2:C6'
最后，我们将通过指定 pull_sheet_data() 参数，运行函数，然后将检索到的数据存储到 Pandas DataFrame 中，从而将所有代码组合在一起。确保用您复制的电子表格 ID 替换’电子表格 _url_ID ，并替换’电子表格 _tab_name！'以及您的电子表格选项卡名称(如有必要，还有范围):
import pandas as pdSCOPES = ['[https://www.googleapis.com/auth/spreadsheets'](https://www.googleapis.com/auth/spreadsheets')]
SPREADSHEET_ID = 'spreadsheet_url_ID'
DATA_TO_PULL = 'spreadsheet_tab_name'data = pull_sheet_data(SCOPES,SPREADSHEET_ID,DATA_TO_PULL)
df = pd.DataFrame(data[1:], columns=data[0])df
现在，您可以在 Python 中探索检索到的数据，而无需手动下载或导入数据集！
如何改进机器学习算法:偏差、方差和正则化
偏差和方差都是机器学习中的常见问题。它们也可以被称为欠拟合和过拟合。本文解释了如何诊断偏差和方差，以及如何调整算法来解决偏差和方差问题。
如果机器学习算法不像你预期的那样工作，几乎所有的时间都是因为偏差或方差而发生的。该算法可能会出现欠拟合或过拟合，或者两者兼而有之。重要的是找出问题来改进算法。
偏差与方差
想想多项式回归。众所周知，如果增加多项式的次数，精度会更高。但是这个精度是在训练集上的。如果多项式的次数足够高，则算法可以很好地学习训练数据，从而可以完美地适应训练数据集。看下图。多项式的次数越高，训练误差变得越低。
来源:作者
交叉验证数据在这里扮演了一个有趣的角色。当多项式的次数较低时，训练误差和验证误差都将较高。这被称为高偏置问题。你也可以称之为不适应问题。因此，高偏差问题的标志是，训练集精度和验证集精度都很低。
另一方面，当多项式的次数太高时，训练数据将非常适合算法。所以，训练误差会很低。但是该算法在交叉验证数据上表现很差。所以，交叉验证误差会很大。这被称为高方差问题或过拟合问题。过度拟合问题或高方差问题的标志是，训练集精度将非常高，而交叉验证集精度将很差。
正规化
正则化有助于处理过拟合或欠拟合问题。选择正则化参数λ可能是关键的。
这是多项式回归的假设方程(顶部)和成本函数(底部)。如果我们选择太大的λ，例如 10000，除了θ0 之外的θ值将是不重要的。因为所有的θ值都是 0 到 1 之间的随机初始化值。在这种情况下，假设将是:
因此，我们将面临高偏差(欠拟合)问题。如果λ太小，在高阶多项式中，我们会遇到通常的过拟合问题。所以，我们需要选择一个最佳的λ。
如何选择正则化参数
花一些时间选择一个好的正则化参数是值得的。我们需要从零开始取几个λ值。以下是一步一步的过程:
- 选择一些λ值，如 0，0.02，0.04，0.08，0.1，…10.24.
- 使用这些 lambdas，并使用训练集训练模型，使成本最小化。因此，我们将得到最小化的成本和每个λ值的θ值。
- 使用优化的θ值并计算交叉验证数据集的成本函数。
- 找出交叉验证集中哪个 lambda 值的成本最小。λ值应该是我们最终的正则化参数。在下图中，比如说，j-cv(3)是最小的。最终的正则化参数λ将是 0.04。在这张图表中，我试图列出所有的步骤。
5.最后，检查正则化参数和θ值，找出它在测试数据集上表现如何。
我希望这是有帮助的。
推荐阅读:
如何提高机器学习的数据质量？
建立更好模型的秘密。
弗兰基·查马基在 Unsplash 上拍摄的照片
The ultimate goal of every data scientist or Machine Learning evangelist is to create a better model with higher predictive accuracy. However, in the pursuit of fine-tuning hyperparameters or improving modeling algorithms, data might actually be the culprit. There is a famous Chinese saying “工欲善其事，必先利其器” which literally translates to — To do a good job, an artisan needs the best tools. So if the data are generally of poor quality, regardless of how good a Machine Learning model is, the results will always be subpar at best.
为什么数据准备如此重要？
由 Austin Distel 在 Unsplash 上拍摄的照片
众所周知，数据分析过程中的数据准备是一项重要但不重要的任务，超过一半的数据科学家认为清理和组织数据是他们工作中最不愉快的部分。
数据科学家和专家的多项调查确实证实了常见的 80/20 比喻——即 80%的时间陷入准备数据的琐碎家务中，从收集、清理到发现数据的洞察力(数据争论或咀嚼)；只留下 20%用于建模和构建算法的实际分析工作。
因此，数据分析过程的致命弱点实际上是花费在数据准备上的不合理的时间。对于数据科学家来说，这可能是构建有意义模型的生产力的一大障碍。对于企业来说，这可能是对资源的巨大打击，因为对数据分析的投资只能看到剩余五分之一的分配专用于最初的意图。
听说过 GIGO(垃圾进，垃圾出)？这正是这里发生的事情。数据科学家带着一组给定的数据完成一项任务，并期望构建最佳模型来实现任务的目标。但是在任务进行到一半时，他意识到无论模型有多好，他都不可能获得更好的结果。经过反复研究，他发现数据质量存在问题，并开始清理数据，使其“干净可用”。当数据最终再次拟合时，日期线正在慢慢到来，资源开始枯竭，他只剩下有限的时间来构建和完善他被雇佣的实际模型。
这类似于产品召回。当发现已经上市的产品存在缺陷时，往往为时已晚，不得不召回产品以确保消费者的公共安全。在大多数情况下，缺陷是供应链中使用的组件或成分的质量控制疏忽的结果。例如，笔记本电脑因电池问题被召回，或者巧克力因乳制品污染被召回。无论是物理产品还是数字产品，我们在这里看到的惊人的相似之处是，总是原材料受到指责。
但是如果数据质量是个问题，为什么不直接改善它呢？
要回答这个问题，我们首先要了解什么是数据质量。
数据质量的定义有两个方面。第一，独立质量作为基于固有特性和特征的呈现的数据视图和真实世界中的相同数据之间的一致性的度量；第二，依赖于的应用的质量——衡量数据是否符合用户预期目的的需求。
假设你是一名大学招聘人员，试图招聘应届毕业生从事初级工作。你有一份相当准确的联系人名单，但当你浏览名单时，你意识到大多数联系人都是 50 岁以上的人，认为你不适合接近他们。通过应用这个定义，这个场景只实现了完整定义的前半部分——这个列表具有准确性，并且包含了良好的数据。但是它不符合第二个标准——无论多么精确的数据都不适合应用程序。
在本例中，准确性是我们用来评估数据内在质量的维度。还有更多不同的维度。为了让您了解同行评审文献中通常研究哪些维度，在研究了涉及 32 个维度的 15 种不同的数据质量评估方法后，这里有一个直方图显示了前 6 个维度。
数据质量评估的系统方法
如果你没有计划，你就计划失败。没有良好的规划，一个好的系统方法是不可能成功的。要有一个好的计划，你需要对业务有一个彻底的理解，尤其是在与数据质量相关的问题上。在前面的例子中，应该意识到联系人列表虽然是正确的，但是具有数据质量问题，不适用于实现所分配任务的目标。
问题明确后，需要调查的数据质量维度应该是定义的。这可以使用经验方法来完成，如在利益相关者中进行调查，以找出哪个维度对数据质量问题最重要。
一套评估步骤也应随之进行。设计一种实现方式，以便这些步骤可以将基于所选维度的评估映射到实际数据。例如，以下五项要求可用作示例:
[1]时间范围—决定收集调查数据的时间间隔。
[2]定义—定义如何区分好数据和坏数据的标准。
[3]汇总—如何量化评估数据。
[4]可解释性——评估数据的数学表达式。
[5]阈值—选择一个分界点来评估结果。
一旦评估方法到位，就该动手进行实际评估了。在评估之后，可以建立一个报告机制来评估结果。如果数据质量令人满意，则数据适合于进一步分析。否则，必须修改数据，并可能再次收集数据。下图中可以看到一个例子。
结论
对于所有的数据质量问题，没有一个放之四海而皆准的解决方案，正如上面概述的定义，数据质量方面有一半是高度主观的。然而，在数据质量评估的过程中，我们总是可以使用系统的方法来评估和评价数据质量。虽然这种方法很大程度上是客观的，并且相对通用，但是仍然需要一些领域知识。例如在数据质量维度的选择中。对于用例 A，数据的准确性和完整性可能是数据的关键方面，但是对于用例 B，这些方面可能不太重要。
如何用 WSL2 提升 Docker
WSL 为 docker 带来了显著的性能提升，但是在开启之前需要知道一些事情
Docker 被认为是建立本地开发环境的领先解决方案。由于 docker-compose 文件的简单性，您可以为每个项目创建一个独立的环境，它反映了生产环境的相同配置。
此外，该解决方案使开发独立于您拥有的操作系统。在 poo word 中，即使你的容器将是 Linux 镜像，你也可以使用 Windows 或 Mac 进行开发。
无论如何，在某些设置中，性能可能会降低，从而影响生产率。
从上一次 Docker 更新开始，Docker 工程师增加了使用 WSL2 技术提升性能的可能性，在所有平台上提供相同的开发体验，包括 windows。
本文解释了为什么我们在 Windows 上可能会有性能问题，以及如何正确安装 WSL2 来提高性能。
由 Unsplash 上的 CHUTTERSNAP 拍摄
WSL2 如何改变 Docker
docker 如何工作
Docker 是领先的容器解决方案，自 2013 年开始使用。我不想花太多时间讨论 docker 是什么。如果您在这里，可能已经使用过它，所以我将花一些时间来介绍 WSL2 克服的限制。无论如何，如果你想了解更多关于 docker 的信息，你可以阅读这篇文章，我试图用简单的语言解释“到底是什么 docker ”。
关于 Docker 要注意的中心部分是它在 windows 下是如何工作的。因为它共享操作系统，而不是硬件，所以你不能在 Windows 上有任何基于 Linux 的容器。那就是。但是每个人都在 windows 上使用 Linux 容器，这怎么可能呢？Docker 工程师用一招解决了这个问题。我们不能在 windows 上有一个 Linux 容器，但是我们可以通过使用一个管理程序把 Linux 放在 Windows 机器上。因此，解决方案很快被创造出来。Docker Desktop for windows 使用虚拟机管理程序(通常是 Microsoft HyperV)来运行虚拟机，它将 VM OS 共享给 Docker 容器。事情就是这样运作的，我试图用图表来解释。
docker 开发如何在“Linux over Windows”模式下工作。作者是❤️from。
这种架构的主要问题是:
- 资源限制。虽然 docker 是为共享操作系统而设计的，但管理程序仍然使用硬件，你需要为它分配资源。这导致了我们在使用虚拟机时遇到的同样的性能问题。
- **磁盘开销。**容器映像位于虚拟机内部，它将文件存储在卷中，但您可能希望从 Windows 环境中共享文件夹，尤其是在开发时。这是图中的红色箭头往返及其影响性能。
作为在 Windows 上运行 Linux 容器的 Docker，如果主要在开发环境中使用，性能不是很重要。事实上，大多数解决方案一次处理一个请求只需要很少的资源。无论如何，有些情况下这种性能很重要。
具有应用程序状态的平台，其中可执行文件被编译和加载一次，不提供太多关于磁盘延迟的信息。发展中。net 或 java，你只需按下播放按钮，等一分钟，然后你的应用程序准备好进行测试，所有编译的源代码或多或少都在 RAM 中，你不需要给硬盘增加压力。
相反，对于 PHP 或 Python 应用程序，情况就不同了。由于它们没有任何应用程序状态，每个请求都是独立解释的，所以每次都需要扫描并加载所有需要的文件。这意味着大量的文件读取，因此大量的文件会增加您的延迟。
对于这个系统，在 windows 上使用体积映射是非常昂贵的，并且会降低性能。您可以使用挂载到 Linux 操作系统的卷，但是在这种情况下，从 Windows UI 进行编辑会有问题。
这就是为什么在大多数情况下，我们接受了最慢的性能(大多数情况下对于开发环境来说是可以接受的)，或者在其他情况下，我们被迫切换到 Linux，抵消了使用 Docker 获得多操作系统可用性的优势。
什么是 WSL2
WSL (Windows Subsystem for Linux)是一个兼容层，用于在 Windows 上本地运行 Linux 二进制可执行文件。它从 Windows 10 开始工作，让你在不使用虚拟机的情况下在 Windows 内部使用 Linux。自 2019 年 6 月以来，Windows 10 提供了 WSL 的增强版本(WSL 2)。此更新通过一组优化的 Hyper-V 功能带来了大量性能改进。
简而言之，你现在在你的 Windows 机器中有一个比运行虚拟机更快的 Linux 发行版。
好消息是 Docker 桌面支持它，它可以提升你的容器。
WSL2 如何改变 Docker
使用 WLS2 和 Docker 组合，我们几乎跳过了一个步骤。
windows 和 Linux 文件系统是相互共享的:您可以从 Windows 访问共享驱动器\WSL$\看到 Linux，或者从/mtn/c 看到 Windows)
docker 容器使用 Linux WSL，没有任何资源限制，性能更好。
Docker 如何使用 WSL2 工作。作者和❤️一起做的
在这种情况下，有巨大的坏消息。共享 windows 文件夹仍然是可能的，但是比标准情况下的性能更差。这在 Java 或者。或者说是一个可以忍受的问题，但是却使得 PHP 开发变得不可行。
幸运的是，有一个解决方案将使用 WSL2 的好处和良好的开发体验结合在一起。事实上，Visual Studio 代码能够远程处理 WSL2 子系统，因此您可以执行以下操作:
- 将 WSL2 中的卷保持为常规卷挂载，以便获得文件系统访问的最佳性能。
- 像往常一样，在 Windows 上工作，在 Linux 上编辑代码。
很明显，如果您在双击 IDE 中的某个项目或保存它时会为访问该文件支付更多的费用，这是一个非常好的解决方案。这个问题伴随着大量的文件加载而来，而这并不是一个开发人员同时写十几个时间的代码的情况。
总之，Visual Studio 做得更好。它有一个扩展，可以与他们的远程子系统远程交互，所以您可以将 UI 保留在 Windows 中，但从 Linux 中的实例使用引擎。因此，作为开发人员，您的用户体验是安全的。
如何使用 WSL2 编码？作者和❤️一起做的
好吧，一旦我们理解了如何以及为什么我们可以提高 Docker 的性能，我们只需要遵循一些简单的步骤来完成事情。
我们需要执行几个步骤，但是，从更高的角度来看，我们必须:
- 启用 WSL2 环境
- 配置 IDE 并开始编码。
启用 WSL2 环境
本节解释了如何安装 WSL2 版本，并为使用 Docker 和 WSL2 开始编码做好准备。
启用 WSL
第一步是启用窗口子系统。您必须使用管理权限在命令行上运行它。
dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
启用 WSL 虚拟机
第二个命令激活虚拟机平台(是的，WSL 仍然使用 hyper-v)。如果您的电脑没有开启虚拟化功能，您可能需要从 BIOS 进行设置。
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
在第二步之后，欢迎重新启动。
安装 WSL2 更新
安装和配置 WSL2 的最后一步是安装更新。这是一个简单的 MSI 包，所以你可以下载它并双击安装。
文件托管在这里来自微软。
将 WSL2 设置为默认值
一旦我们确定了 WSL2，只需将版本 2 设置为所有子系统的默认版本。
wsl --set-default-version 2
从微软市场安装 ubuntu
要在子系统上运行 Docker，我们需要下载一个 Linux 发行版。既然微软+开源现在已经成为现实，那就有可能直接从微软商店获得。我用的是 Ubunto，它只有 440MB，所以不用担心用完你的磁盘空间。
在这一步之后，您将看到所有的操作系统都作为一个子系统安装。
wsl --list --verbose
你应该在 WSL 2 上看到 docker，docker-data，ubuntu。
激活 Docker WSL2 扩展
在 Docker Desktop 中，只需检查配置并启用 WSL2 特性。它可能需要一些 docker 重启或 PC 重启。
**警告:**当您从标准模式切换到 WSL2 时，您将需要重新下载所有的图像(您已经位于 Hyper-v VM 中，而不是 WSL2 中)。此外，命名卷中的数据存储在 VM 中，所以您不会在新的 WSL2 机器中找到它们。所以，首先，从 Docker 容器中提取并备份所有相关数据。根据您的本地设置，您可能会丢失数据。
第一步是检查“使用基于 WSL2 的引擎”。
激活 WSL2 功能。作者和❤️一起做的
然后你解锁 WSL 集成面板，在那里你可以激活 Ubuntu 发行版。
激活 ubuntu 发行版。作者和❤️一起做的
安装 VsCode 扩展
最后一步是安装和下载 Visual Studio 插件。通常，您可以通过从网站或 Visual Studio 代码用户界面单击“安装”来完成此操作。
从 Visual Studio 代码扩展安装远程 WSL。作者和❤️一起做的
你也可以在这里找到的扩展。
WSL2 用法
这时候所有的步骤都完成了，就可以开始编码了。当你看到表演时，你会感谢这段时间的！最后的平衡将是仅仅在工作的第一天节省大量的时间。
对于开始编码，您有两种选择:从 WSL 开始或者从 Windwsow 开始。
就我个人而言，我更喜欢第二个，因为它非常独立。
表单命令行:
1.打开 WSL 终端或在 shell 中输入命令“WSL”。由于 Ubunto 是首选的子系统，你将在其中。
2.键入“代码”这将在您的 windows 计算机上打开 Visual Studio 代码。
从用户界面:
1.打开 visual studio 代码。
2.单击 WSL 框(左下角，底部工具栏的绿色按钮)或 F1 + Remore WLS+ New Window
从 Visual Studio 代码扩展安装远程 WSL。作者和❤️一起做的
3.新窗口与 Linux 操作系统连接
从那时起，您就可以使用 Visual Studio 代码做所有您需要的事情了。事实上，您可以从文件树中打开一个终端。终端将位于 WSL 机器内部，如果您运行 docker-compose up，您将激活主机 docker 系统上的容器。您还可以使用 git 工具来处理提交，所以这可能就是您开始编码所需的全部内容。
摘要
出于多种原因，许多开发人员使用 Windows 作为开发环境。这是获得最佳程序兼容性或比 Linux 更好的用户体验的常见选择。其他人使用 Windows 来获得比 Mackbook 更便宜的笔记本。
Docker 有助于在所有操作系统上获得相同的开发体验，但在某些情况下可能会导致 Windows 上的性能问题。
WSL2 提高了性能，但是需要注意将文件放在哪里以及如何创建卷。
一旦完成了这些步骤，您就可以获得与在 Linux 中相同的性能，同时获得舒适的 Windows 用户体验。
**免责声明:**我不想将 Linux、Windows 和 Mac 支持者之间的分组主义动画化。每个开发人员应该可以自由选择他们喜欢的操作系统，拥有相同的用户体验。这不是 Docker 的主要目的，而是一个令人舒服的副作用。本文的目的只是为喜欢使用 Windows 的人打开一个新的机会，避免被迫更换操作系统。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Daniele Fontani
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
daniele-fontani.medium.com](https://daniele-fontani.medium.com/membership)
参考文献:
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
