预测黄金之前:探索 ETF 的跟踪误差
金的探索性数据分析
跟踪误差 EDA。使用 ETF 作为因变量的好处和注意事项。
“作为人类，我们被五颜六色的树叶所吸引，有时很少注意对树的生命至关重要的根、茎和枝。这相当于做一个金融模型，一个定量分析师新手没有花足够的时间探索数据的复杂细节就匆忙开始建模过程。
来自笔记本的 LBMA PM Fix 和 GLD ETF
在这篇文章中，我将分享我个人做全球贵金属研究项目的经验。我的公司是贵金属市场的利基参与者，为潜在客户提供从销售和交易到储存和交付贵金属的全球端到端服务。他们的目标是“给传统的物理作业带来一些量化的实践”。我将参与这场革命，并帮助公司实现一种系统化的方法来将资金配置到黄金上。该公司可能不熟悉回归模型的数学成本函数，但他们知道黄金行业的机制。我总是对围绕这种两极分化的资产的大量信息和发现感到惊讶，这从第一天起就点燃了我的探索。
我告诉自己“忘了建模吧，该学学黄金了”。
使用黄金交易所交易基金作为黄金现货价格的替代品进行建模有很多好处和警告。我还会提到基金跟踪误差的概念和偏离的潜在因素。跟踪误差存在于每一个跟踪基准的基金中。因为它的存在，人们不得不质疑黄金 ETF 是否能代表黄金的真实价值。它不仅给黄金模型制作者，也给投资者带来了警示。本文不会深入探讨跟踪错误的机制，但会引导您了解我的解决方法。
本文将在开发黄金模型之前解决以下考虑事项:
- 我们的模型所基于的普通黄金资产，以及为什么 ETF 是一个可行的选择
- 计算/可视化不同黄金 ETF 的跟踪误差
- 验证影响黄金 ETF 跟踪误差的因素
- 根据跟踪误差选择黄金 ETF
关于黄金选择的一点细节
所以我们想创造一个黄金投资模型。第一个问题是我们用哪种黄金资产建模。一些资产选择包括:
- 实物黄金:伦敦黄金场外交易市场(LBMA)向投资者提供黄金这种有形资产。以这种方式持有黄金可以维持长期财富，而没有任何交易方风险。尽管 LBMA 位于伦敦，但市场可以在全球范围内交易。 LBMA 网站 保存了一些关于定价和交易条款的有用信息。
- 交易所期货合约:期货合约交易者主要由套期保值者和投机者组成。套期保值者将买入/卖出他们希望持有的黄金的当前合约价格(在未来交割),并对冲到期日之前价格上涨/下跌的风险。投机者进行交易是为了从他们对价格运动的投机中获利，因为他们的目标不是持有实物黄金本身。
- 黄金追踪交易所交易基金(ETF) :这类 ETF 通过持有实物黄金和期货合约来追踪现货黄金价格的回报。投资者将投资于 ETF 的股票。期货投机者和 ETF 投资者类似，因为他们交易黄金而不持有黄金。还有一些黄金 ETF 不直接投资于该商品，而是投资于专门从事黄金的公司。
那么用哪种黄金做模特呢？
假设你的目标是投资和储存黄金。黄金的分配将每周重新平衡。我们决定使用一个 ML 模型，通过每日观察来预测一周的回报方向。
使用期货价格是不可能的，因为我们既不对冲也不投机期货价格。我们可以将模型建立在 LBMA 现货价格的基础上，但是这种方法在构建我们的特征集时会带来一些问题。
数据-时间对齐问题 — LBMA 每天两次在拍卖中设定黄金价格(工作日伦敦夏令时 10:30 和 15:00 )。因此，只有每日上午和下午的价格数据。考虑这些场景:
- 包含存在于不同时区的非伦敦 BST 市场指标要求这些指标的生成时间与 AM 或 PM 价格相匹配。如果我们想使用 GC 期货的价格衍生品，那么我们必须在美国东部时间 10:00 对每日观察数据进行采样，以匹配伦敦夏令时 15:00。然而，并不是每个人都可以访问当天的数据，数据订阅会产生巨大的成本。想象一下，必须将 50 个基于美国的特征与现货金对齐。大多数美国经济指标都不是当天的，调整这些指标是不明智的。
- 调整我们的投资组合以包括其他资产，如现货白银(不同的 LBMA 结算时间)将在投资组合回溯测试中造成障碍 ，因为现货价格不一致。我们也有向前/向后看的偏见的风险。
解决方案 — **这就是黄金 ETF 的用武之地。**因为我们的许多功能都是基于美国的(大多数模型都是这样)，所以使用在美国交易所交易的黄金 ETF 作为目标变量是明智的。与使用 LBMA 现货价格不同，现在时区是同步的，数据对齐过程变得更容易。你可能不得不使用一些日内数据，但是你减少了大量不必要的工作。此外，投资组合现在也可以通过使用白银 ETF 的价格作为现货白银的代理来进行调整。通过使用相应的收盘价，可以毫不费力地调整黄金 ETF 价格和白银 ETF 价格。
**然而，由于 ETF 的跟踪误差，与使用现货价格相比，使用 ETF 的价格作为代理会出现一些回溯测试滑动。**每个试图跟踪指数/资产的 ETF 都会有跟踪误差。好消息是，我们可以选择一只黄金 ETF，表现出可容忍的跟踪误差。
总的来说，我们正在用最小的滑动来换取正确和干净的数据。
导入数据和时区
对于后续的分析，我们将需要 LBMA 黄金固定和 ETFs 数据。我们知道这些时间序列位于不同的时区。为了适应性，我们将把所有时间序列标准化为 UTC，消除日光节约的细微差别。
我们导入 pytz 并定义时区实例:
import pytz
london_tz = pytz.timezone('Europe/London') ***# for LBMA fix***
est_tz = pytz.timezone('US/Eastern') ***# for ETFs***
target_tz = pytz.timezone('UTC') ***# target timezone***
我们从Quandl下载 LBMA 黄金修复 CSV 数据，通过熊猫导入。数据来自 1968 年 1 月 2 日。通过使用 PM fix time，我们可以确保对应的 ETF 价格在市场时段(伦敦时间 15:00 相当于美国东部时间 10:00)。
***#importing LBMA Gold Fix data***from datetime import datetime
import pandas as pd
lbma_gold = pd.read_csv('LBMA-GOLD.csv',index_col = 0,parse_dates=True).sort_index()***#creating gold settlement london pm time***
lbma_gold = lbma_gold.reset_index()
lbma_gold['PM_TIME'] = '15:00'***#joining date and time***
dt = pd.to_datetime(lbma_gold['Date'].astype(str) + ' ' + lbma_gold['PM_TIME'])***#localize the datetime using london TZ and normalize using UTC TZ***
lbma_gold['UTC_PM'] = [pd.to_datetime(target_tz.normalize(london_tz.localize(x)).strftime("%Y-%m-%d %H:%M:%S")) for x in dt]lbma_gold = lbma_gold.set_index('UTC_PM')lbma_gold.head(10)
UTC LBMA 金牌服务从笔记本中修复数据
处理 NaN 值的方法将在后面介绍。
接下来，我们将获取以下 ETF 数据进行分析:
- GLD-SPDR 黄金信托公司
- IAU-iShares 黄金信托公司
这些 ETF 在 NYSEARCA 交易所交易，并跟踪金条，这使它们成为衡量其表现的候选对象。我们将使用来自 、firstratedata.com的分钟数据，这是一家可靠的各种资产的日内数据提供商。数据下载到每个跑马灯的多个文本文件中，并按日期范围分开。我们也将美国东部时间转换为 UTC 时区。
***# function for loading txt files, input in a list of file names***
def load_etf(file_list):
df = pd.DataFrame()for txt in file_list:
***#iterate and concat data***
temp_df = pd.read_csv(txt,sep=',',header=None)
temp_df.columns = ["dt", "o", "h", "l","c","v"]
df = pd.concat([df,temp_df])
df['dt'] = pd.to_datetime(df['dt'])
df = df.set_index('dt')
***#sample to hourly, to speed up time normalization process***
df = resample_prices(df,freq='H').dropna() #sample to hour
df = df.reset_index()
***#normalize to UTC* **
df['dt'] = [pd.to_datetime(target_tz.normalize(est_tz.localize(x))
.strftime
("%Y-%m-%d %H:%M:%S")) for x in pd.to_datetime(df['dt'])]df = df.set_index('dt')return df
#==========================================================***# GLD***
gld = load_etf(['GLD_2000_2009.txt',
'GLD_2010_2019.txt','GLD_2020_2020.txt'])***# IAU***
iau = load_etf(['IAU_2000_2009.txt',
'IAU_2010_2019.txt','IAU_2020_2020.txt'])gld.head(10)
笔记本中的 UTC GLD 数据
计算跟踪误差和跟踪差
跟踪误差来源于跟踪差。根据 etf.comT5的说法，跟踪差的定义是“ETF 的表现与指数表现之间的差异”。跟踪误差是指基金的总回报表现与其标的指数的总回报表现之间的跟踪差异的年化标准差。根据每日回报数据，可以通过找出指数回报和 ETF 回报之间的差异来计算每日观察的相应跟踪差异。由此，我们可以计算每日跟踪差异的年化标准差。
我们现在将 LBMA 金牌 PM 修复与 GLD 保持一致。我们移除任何 NaN 行，而不是使用前端填充，因为我们希望我们的计算尽可能真实。
lbma_gld = lbma_gold.merge(gld,how='inner',
left_index=True,right_index=True).loc[:,['USD_PM','o']].dropna()lbma_iau = lbma_gold.merge(iau,how='inner',
left_index=True,right_index=True).loc[:,['USD_PM','o']].dropna()
下面是计算跟踪误差和创建一个新的有跟踪差的数据帧的函数:
***# T.E.Function***
def tracking_error(dff):
df = dff.copy()
***# spot and etf returns* **
df['spot_ret'] = df['USD_PM']/df['USD_PM'].shift(1) - 1
df['etf_ret'] = df['o']/df['o'].shift(1) - 1
df = df.dropna()***# daily T.D.***
df['te_term'] = (df['spot_ret'] - df['etf_ret'])
***# take annualized std of daily T.D.***
te = df['te_term'].std() * np.sqrt(252)return(te,df)lbma_gld_te,lbma_gld_te_df = tracking_error(lbma_gld)
print("Spot vs GLD TE: " + str(lbma_gld_te * 100) + '%')lbma_iau_te,lbma_iau_te_df = tracking_error(lbma_iau)
print("Spot vs IAU TE: " + str(lbma_iau_te * 100) + '%')
与 GLD 一起可视化
import matplotlib.pyplot as plt
%matplotlib inline***# T.D. with std reference lines***
fig = plt.figure(figsize=(15,8))
lbma_gld_te_df['te_term'].plot(label='T.D.')
plt.axhline(lbma_gld_te_df['te_term'].std(), color='r',
linestyle='--',label='+STD')
plt.axhline(-lbma_gld_te_df['te_term'].std(), color='r',
linestyle='--',label='-STD')
plt.legend()
plt.show()***# T.D. probability density plot***
fig = plt.figure(figsize=(15,8))
plt.hist(lbma_gld_te_df['te_term'], color = 'purple', edgecolor =
'black',bins = 200,label='T.D. PDF')
plt.legend()
plt.show()
GLD 每日时间序列和 PDF 图
时间序列和 PDF 图中偶尔会出现时间峰值。理论上，它们代表了异常值，但实际上，它们反映了 GLD 的实证表现。
在下一节中，我们将调查 T.E .和建议因素之间的因果关系。
影响热电势的潜在因素
以下是一些可能影响商品跟踪基金 T.E .的潜在因素:
- 基金费用率
- 波动性
- 期货滚动
费用率
每个基金都有一个费用比率费用。这是向投资者收取的管理费和运营费。潜在的情况是，费用越高，基金在跟踪指数时的表现差距就越大。让我们比较一下 GLD 和 IAU 的费用率和成本费用。众所周知，GLD 的费用率高于 IAU。此外，我们将仅使用 2017 年的数据来重新计算我们的 T.E 。,因为它将描绘与当前费用率更现实的关系。
lbma_gld_te,lbma_gld_te_df =
tracking_error(lbma_gld.loc['2017-01-01':])print("Spot vs GLD TE: " + str(lbma_gld_te * 100) + '%')lbma_iau_te,lbma_iau_te_df =
tracking_error(lbma_iau.loc['2017-01-01':])print("Spot vs IAU TE: " + str(lbma_iau_te * 100) + '%')
成绩对比:
费用率取自 ETF.com
GLD
费用率:0.40%
(2017 年起):3.05%
(自成立以来):3.91%
IAU
费用率:0.25%
(2017 年起):2.95%
(自成立以来):3.87%
结果表明，教育费用与费用率之间存在正相关关系。考虑到 GLD 较高的费用率，IAU 的 T.E .一直相对低于 GLD。
波动性
人们的假设是，当价格大幅波动时，基金将更难跟踪黄金的走势，从而造成回报之间的差异。让我们和 GLD 一起利用这一点。
我们将需要来自 Finnhub.io 的 GLD 每日数据来使用 Wilder 的 ATR 计算滚动波动率。Finnhub 提供了一个免费的 api，允许我们从一开始就获取股票/ETF 的每日数据。
# fetch data from finnhub start and end date in unix timestamp
gld_daily = pd.read_csv('https://finnhub.io/api/v1/stock/candle?symbol=GLD&resolution=D&from=1009843200&to=1588291200&adjusted=true&format=csv&token=' + apikey)# extract UTC timestamp from unix timestamp
gld_daily['dt'] = [datetime.utcfromtimestamp(x) for x in
gld_daily['t']]
gld_daily = gld_daily.set_index('dt')gld_daily.head(10)
来自笔记本的 GLD 每日数据(Finnhub)
我们定义 ATR 函数和一个数据框架函数来创建一个新的数据框架，将现有的 T.D .数据框架与包含每日滚动 ATR 的数据框架合并。20 天的回顾用于定义波动性，相当于 1 个月的跨度。
***# wilder's atr***
def wwma(values, n):
**"""
J. Welles Wilder's EMA
"""**
return values.ewm(alpha=1/n, adjust=False).mean()def atr(dff, n):
data = dff.copy()
high = data['h']
low = data['l']
close = data['c']
***# calculate true range***
data['tr0'] = abs(high - low)
data['tr1'] = abs(high - close.shift())
data['tr2'] = abs(low - close.shift())
tr = data[['tr0', 'tr1', 'tr2']].max(axis=1)
** *# find ewm of true ranges for n lookback***
atr = wwma(tr, n)
return atrdef make_atr_df(df,df_te,n=20):
mdf = df.copy()
mdf_te = df_te.copy()
mdf['ATR'] = atr(df,n)
***# convert datetime to date***
mdf_te['dt'] = list(mdf_te.reset_index()['index'].dt.date)
mdf['date'] = list(mdf.reset_index()['dt'].dt.date)***# merge atr df with original tracking difference df***
dff = mdf_te.merge(mdf,how='inner',left_on='dt',right_on='date')
.loc[:,['dt','USD_PM','o_x','spot_ret', 'etf_ret','te_term','ATR']]
***# need shifting since vol of previous day will reflect on
# subsequent price on 10 AM next day***
dff['ATR_shift'] = dff['ATR'].shift(-1) dff['dt'] = pd.to_datetime(dff['dt'])
dff = dff.set_index('dt')
dff = dff.rename(columns={'o_x':'etf_price'})return(dff.dropna())gld_atr_df = make_atr_df(gld_daily,lbma_gld_te_df,n=20)
gld_atr_df.head(10)
笔记本中的组合数据帧
用 T.D .可视化波动
fig = plt.figure(figsize=(17,7))
graph = gold_atr_df.copy()
graph['te_term'].plot(label='T.D.')plt.axhline(graph['te_term'].std(), color='r', linestyle='--',label='+STD')
plt.axhline(-graph['te_term'].std(), color='r', linestyle='--',label='-STD')plt.legend()
fig = plt.figure(figsize=(17,7))
graph['ATR_shift'].plot(color='green',label = '20 day ATR')plt.legend()
plt.show()
波动性对交易时间的影响
这些图说明了 ETF 的价格波动对 T.D .的影响。当出现突然的波动峰值时，T.D .也会随后出现峰值。在最近的新冠肺炎疫情期间，黄金价格的熊市下跌导致新台币上涨。这些是波动性和 ETF 表现之间因果关系的证据。
期货卷
许多商品交易所交易基金通过期货市场跟踪商品的价格。该基金将在交割日期前卖出附近的合约，以便【滚动】买入下一个附近的合约。由于黄金期货的期货溢价性质，即使现货价格保持不变，期货价格上涨也会给 ETF 带来损失。我们不确定 GLD 是否存在这种机制，也不确定基金滚动合同的时间。下面的分析检验了我们的假设。****
*****# extract the day of date***
gold_atr_df['day'] = list(gold_atr_df.reset_index()['dt'].dt.day)**
黄金期货合约的第一个交割日期是每个月的第一个交易日。因此，假设 GLD 将在每月的最后 10 天滚动其合约，考虑到某些天不是交易日。我们将数据框架分为 3 天范围:每月的 1 日至 10 日、11 日至 20 日和 21 日至 31 日。然后我们计算每个数据帧的时间长度。为了保证我们分析的可信度，我们每年迭代一次，计算每年的 T.E .并取每年值的平均值。前提是，我们的数据应该代表总体。
*****# separate T.D. series by date ranges***
gld_te_1st_df = gold_atr_df[(gold_atr_df['day'] >= 1) & (gold_atr_df['day'] <= 10)]['te_term']
gld_te_2nd_df = gold_atr_df[(gold_atr_df['day'] >= 11) & (gold_atr_df['day'] <= 20)]['te_term']
gld_te_3rd_df = gold_atr_df[(gold_atr_df['day'] >= 21) & (gold_atr_df['day'] <= 31)]['te_term']***# extract unique years***
years = np.unique(gold_atr_df.index.strftime('%Y'))***# initiate list to store yearly T.E. for each series***
te_1st = []
te_2nd = []
te_3rd = []***# iterate through each year and calcualte T.E.***
for y in years:
te_1st.append(gld_te_1st_df.loc[y].std() *np.sqrt(252))
te_2nd.append(gld_te_2nd_df.loc[y].std() *np.sqrt(252))
te_3rd.append(gld_te_3rd_df.loc[y].std() *np.sqrt(252))***# take the mean* **
print(np.array(te_1st).mean())
print(np.array(te_2nd).mean())
print(np.array(te_3rd).mean())**
结果
- 第一至第十区间 T.E.: 3.26%
- 第 11 至 20 个区间 T.E.: 3.67%
- 第 21 至 31 个区间 T.E.: 4.02%
我们的结果表明，随着日期范围接近月末，T.E .会增加。虽然 values 没有准确地推断出 T.E .的上升是由于期货滚动结算，但它表明存在一些导致基金表现不佳的交易/再平衡活动。至少，我们确信 GLD 在接近月底时会出现追踪困难。这为未来关于 T.E .上升的潜在月末活动提供了研究机会…
GLD vs IAU:哪一个更好？
我们现在将选择我们的候选 ETF。ETF 的价格将被选为我们预期 ML 模型的目标变量。
方法是计算每个 ETF 的回报对现货回报的敏感度。这种灵敏度被称为线性系数β。另一个要观察的指标是 R 平方，这是衡量 ETF 和黄金价格变动相关性的统计指标。越接近 1，基金表现越好。
我们对每个 ETF 数据框架进行线性回归，观察 R 平方和 Beta，并使用线性拟合可视化散点图。
*****# Beta, R-Squared and plots***
def sensitivity_score(df,c):
X = df['spot_ret'].values.reshape(-1,1)
y = df['etf_ret'].values.reshape(-1,1)
reg = LinearRegression(fit_intercept=False).fit(X, y)print(reg.score(X, y)) ***# R-Squared***
print(reg.coef_[0][0]) ***# Beta coefficient***
y_line = reg.coef_ * X ***# Regression line***
fig = plt.figure(figsize=(18,10))
plt.scatter(X,y,label='Scatter ETF vs Spot',color=c)
plt.plot(X,y_line,label='Linear Regression ETF vs Spot',color='black')
plt.legend()
plt.show()sensitivity_score(lbma_gld_te_df,'green')
sensitivity_score(lbma_iau_te_df,'red')**
GLD vs 即期回报+回归线
IAU vs 即期回报+回归线
分数:
- GLD:β= 0.955，R = 0.967
- IAU:贝塔= 0.956，R = 0.97
IAU 的分数略高于 GLD。仅基于相关性的标准，分数彼此如此接近，以至于我们可以使用 GLD 或 IAU。然而，IAU 的跟踪误差低于 GLD，这反映了 IAU 更好的长期表现。此外，IAU 的费用率低于 GLD，因此我们可以预期长期回报偏差较低。因此，这表明 IAU 可能是一个更好的模型候选人。
结论
我们已经走过了建立黄金模型的先验知识的过程。该流程的重点是分析您的黄金数据，并研究跟踪误差的小细节，从而为模型构建流程添加上下文。我们分析了基金跟踪误差的潜在因素，并提出了一种选择黄金 ETF 目标变量的方法。这里的要点是探索数据与构建高性能 ML 模型一样重要。
未来考虑
- 对比其他黄金追踪 ETF 的结果
- 考虑流动性。流动性与买卖价差有直接关系，这一特征会导致回溯测试中的滑动
联系人
概率分布之前
为什么我们要使用概率分布，为什么它们很重要？
梅尔·普尔在 Unsplash 上的照片
我决定写这篇介绍概率分布的文章，目的很明确:解释我们为什么使用它们，并应用现实生活中的例子。学习概率时，我厌倦了听掷硬币、纸牌游戏和编号球。除非你只喜欢赌博(这不是我的情况)，你需要真正务实地应用概率概念来解决其他问题，而不是彩票中奖的几率。但是在陷入实用主义之前(这将是我们的第一次冲突)，我们需要经历一些概念上的事情。这篇文章描述了我们为什么关心概率，并且将帮助你发展一些关键术语，我们将需要这些术语来理解如何把它应用到我们的现实生活问题中。
概率是什么，我们为什么要关心它？
概率是关于解释和理解生活中的随机事件，由于我们生活在绝对的随机性中(即使我们试图相信我们没有)，它的有用性变得相当明显。概率是某个随机过程发生某种结果的长期可能性。它基本上告诉你不同种类的事件发生的频率。
使用概率的一些实际例子是:
- **金融:**通过估计给定金融资产在特定范围内下跌的可能性，可以开发交易策略来捕捉预测的结果。
- 天气预报:气象学家不能准确预测天气，所以他们使用工具和仪器来确定下雨、下雪或冰雹的可能性。他们还检查历史数据库，以估计当天或一周的高温和低温以及可能的天气模式。
- **保险:**概率在分析保险单以确定哪些计划最适合客户以及他们需要多少免赔额时起着重要作用。
- **运动:**运动员和教练用概率来决定游戏和比赛的最佳运动策略。像 BWin 这样的公司已经以此为业，你甚至可以使用不同的策略下注。
- **广告:**概率用于根据潜在客户的消费模式，估计他们更有可能对特定活动做出积极反应。
从数字上来说，概率是一个范围从 0(意味着事件不可能发生)到 1(意味着事件肯定会发生)的数字，如果你把所有可能的结果加起来，你的总和就是 1。概率值越大，事件发生的可能性越大。
所以比如你会说明天下雨的概率是 40%(表述为" P(雨)=0，4" )，或者某个特定地区发生汽车盗窃的概率是 2%(定义为" P(汽车盗窃)=0，02 )。在第一种情况下，您对变量“雨”感兴趣，而在第二种情况下，您对变量“偷车”感兴趣。这些变量，以及任何其他随机过程的结果，被称为“随机变量”。
随机变量是一个受随机变化影响的变量，因此它可以呈现多个不同的值，每个值都有一个相关的概率
它没有特定的值，而是潜在值的集合。在进行测量并显示具体值后，随机变量就不再是随机变量，而变成了数据。
当试图估计它们时，不同的概率呈现不同的复杂性。通常，过去的数据被用作可能发生的事情的代理，但这并不总是适用的(例如，对于没有历史的新事件)，或者在极端事件发生时可能具有误导性:想想 2011 年的福岛事故，海啸的高度被低估了，因为概率计算导致了比实际发生的地震小得多的地震。也有不同的方法来计算概率(例如，使用计算机模拟，或收集数据并计算事件发生的时间百分比)，但所有这些方法都和你用来提供它们的数据一样好。
概率分布
概率分布是一个随机变量所有可能结果的列表，以及相应的概率值。概率分布将随机变量或过程的每个结果与其出现的概率联系起来。例如，如果你在一个给定的地方采集不同个体的血液样本，你可以计算出他们血型的概率分布:
你在这里做的是统计不同血型的个体数量，然后用每个血型组除以个体总数。这样你就能得到每种血型的概率。
在这种情况下，血型是随机变量。概率分布显示，A 型血的人发病概率最高，而 AB 型血的人发病概率最低。同样，如果你把不同的概率加起来，你会得到 1。你是怎么做到的？简单:你定义你要分析的随机变量(在这个例子中是“血型”)，你设置你要统计的类别(“O”、“A”、“B”和“AB”)，你统计每个类别中出现的次数。然后，你要么处理这个绝对数字(例如，150 例血型为“A”的病例)，要么用它除以病例总数(使它占总数的百分比，就像我们的例子一样)。
但是这里有一个技巧。当您估计随机变量(如血型或任何其他变量)的概率分布时，您实际上是在使用仅代表您正在分析的随机变量的真实行为的一部分的数据。你没有看到所有可能的数据值(用概率术语定义为**“群体”)，因为你只从给定时间和空间的一个子集(称为“样本”**)中获得数据。
样本是总体的子集
由于随机变量的值在分析它们的上下文中会发生变化，所以每次计算结果的概率时，您都需要获取数据的子集(采样)，并且由于您是在特定条件下进行的，这意味着如果您将来再次重复分析，您可能会得到不同的结果(由于变量的随机性)。有些值今天比其他值更有可能产生，但其他值可能在其他时间更有可能产生。这样，样本就是我们想要分析的人群的代表，但它永远不会与它 100%相同。
如果我们随时随地测量我们感兴趣的随机变量的所有可能结果，并捕捉它的真实行为，会怎么样？
我的答案是，如果你能做到这一点，那么你的问题就解决了:你可以绝对确定地计算所有结果的概率分布，理解你感兴趣的随机变量的行为，甚至更准确地预测它。然而，大多数情况下(如果不是一直的话),获取您感兴趣的全部数据是极其昂贵的(有时甚至是不可能的)。
举个例子:假设我们对 2000 个成年人进行调查，估计德国(+8000 万栖息地)赞成死刑的成年人比例。如果我们得出 60% (1.200)的被调查者是赞成的，是否可以得出 60%的德国人也是这么想的？显然不是。我们需要使用概率(和统计)工具从我们的样本中建立一个结论，或者获得全部数据，忘记那些烦人的概率概念。你能想象调查 8000 万人吗？
如果你只有有限的结果，而且它们的行为也是随机的，你怎么能描述你正在分析的随机变量的真实行为呢？
好了，现在我们知道，我们想要根据我们在分析中发现的东西(仅限于我们可以得到的样本)，对随机变量的“真实行为”得出可靠的结论(不仅在我们的样本中，而且在样本之外)。有没有一种方法可以概括这些结果，使它们具有代表性？
答案是肯定的，这个概括掌握着预测的秘密。如果您可以将特定随机变量的样本结果推广到总体，那么您就可以预测这些随机变量的行为。
预测的力量
有概率分布模型帮助你预测特定情况下的结果。当满足某些条件时，这些概率分布模型会帮助您计算每个结果概率、长期平均结果，并估计随机变量结果的可变性，而不需要您感兴趣的随机变量的所有实际结果。
这意味着有一种方法可以将你对随机变量的有限分析结果推广到更广泛的行为，这将帮助你节省时间和金钱，并获得更有信心的结果。许多概率分布模型存在于不同的情况下，关键是你必须选择一个适合你的数据，并帮助你解释你试图理解的正确的模型。
简单来说，概率分布模型是你用来拟合随机变量以概括其行为的指南。这些模型有数学背景，可能非常挑剔。为了使它们正常工作，您试图拟合的随机变量必须满足不同的假设，以便模型的结果具有正确的概率，并且您可以根据随机变量的真实数据来测试和验证模型。
随机变量的类型
到目前为止，我们一直在谈论随机变量，但有不同类型的随机变量。嗯…有意思，但是我们为什么要关心它呢？因为在定义应该选择哪种概率分布模型时，随机变量的类型是一个关键参数。
有两种主要类型的随机变量:
- **离散随机变量:**是那些有有限或可数个可能结果的变量。你通过计数来计算它的值。
比如，想一想“某年某个地方的出生人数”。这是一个离散的随机变量，因为结果可能是 0，1，2…999 或任何其他值。你通过计数得到变量的值。在离散随机变量中，如果你选择任何两个连续的结果，你不可能得到一个介于两者之间的结果。
- **连续随机变量:**有不可数的无限个可能值。你通过测量来计算它的值。
考虑“一个算法运行一项任务所需的时间”。时间通常被四舍五入到合适的间隔，比如秒或毫秒，但事实是它实际上是一个连续体:它可能需要 1.6666666…秒才能运行。体重，温度，价格，都是连续的随机变量。
在概率术语中，离散和连续随机变量是两种不同的生物，应该完全分开对待，它们中的每一个都有不同的概率分布模型。这意味着，如果你在处理一个离散的随机变量(例如，某一地区房主的手机数量)，你需要选择一个处理离散随机变量的概率分布模型(你不能选择一个只处理连续随机变量的模型)。
与统计数据共舞
概率与统计学有着密切的关系。事实上，它们是如此紧密地联系在一起，以至于谈论一个而不提及另一个几乎是不可能的。统计学被应用于数据集，以确定表征它们的因素或属性，从而获得关于它们的信息:它是一门与收集和解释定量数据有关的学科，它与概率相结合，使我们有可能对结果进行预测。
一个统计是一个描述数据的一些属性的数值度量，信不信由你，我们每天都在使用它们。例如，当你检查一个足球运动员的平均得分率(在统计学术语中称为“平均值”)，或在给定时期你的国家最受欢迎的新生男孩的名字(在统计学术语中称为“模式”)，你是在使用统计学。
统计中只描述数据的部分叫做 【描述性统计】 ，而让你做出预测的部分叫做 【推断统计】 。
均值、众数、中位数、方差、标准差，这些是你可以用来描述数据的一些统计数据，就像在概率中一样，除非你可以访问所有可用的数据(总体)，否则一个**“统计数据”总是从一个样本中获得:如果你可以从总体中获得它，你会称它为一个“参数”。根据这些信息，可以建立预测模型，并在结果真正实现之前确定某些结果的概率**。这样，你就可以用统计学来计算出某一事件发生的概率。
例如，如果你想知道你的假日飞机坠毁的几率(抱歉这个黑暗的例子)，你可以想到一年内通常有多少架飞机坠毁，由于这个数字非常小，你可以推断出你的飞机坠毁的概率也很小。在这里，您实际上是通过计算某个参数来应用统计数据，例如失事飞机的数量除以航班总数。或者，您可以使用统计数据，例如来自给定城镇的女性样本数据，对居住在城市等更大区域的大量女性(年龄范围相似)做出推断。
再说一次，我们这样做是因为估计或推断参数比处理现实生活更容易。我们需要统计学来描述我们的可用数据，理解它，然后将它与概率混合，以猜测“真实”(不可用)数据的行为。
这是因为统计数据是可观察的，是根据观察结果计算出来的，而总体参数是抽象的，是不可观察的，必须进行估计(除非您完全可以访问它)。
可以从样本中估计总体参数(推断)
那么，我们如何推断呢？
随机变量的可能结果可以使用统计和概率以不同的方式进行估计:
- 计算一个随机变量的单个结果的值(如股票价格均值的精确值)，称为点估计。
- 估计一个随机变量可能结果的一个区间或范围(如股票价格均值的不同值)，称为区间估计。
- 通过使用统计方法来确认或拒绝某个陈述，从而测试该陈述(相对于总体参数)的有效性。这种说法被称为假设，用于此目的的统计测试被称为统计假设测试。
这些方法依赖于概率分布的概念，因为您需要使用概率分布模型来进行推断和归纳您的结论。
最后的想法
概率分布有助于模拟我们的世界，使我们能够获得某一事件可能发生的概率估计，或估计发生的可变性。它们是描述和预测事件概率的一种常用方法。
主要的挑战是定义我们试图描述其行为的变量的特征，因为有必要确定什么分布应该应用于特定过程的模型。
正确分布的识别将允许模型(例如，标准化正态分布)的适当应用，该模型将容易预测给定事件的概率。
在您开始在线学习数据科学之前
关于年轻有志者在线学习数据科学时犯的错误以及如何克服这些错误的笔记。
背景图片由斯坦纳恩格兰
我们每天产生超过 2.5 万亿字节的数据。仅在过去两年中，我们拥有的世界上 90%的数据都是由[1创造的。于是，出现了很多与数据相关的领域。许多年轻的有志之士每天都开始学习数据科学。我见过我的朋友和其他人在学习它的时候开始犯错误。当我开始学习数据科学时，我也犯过错误。
有很多来自数据科学领域知名机构的伟大教授开设的令人惊叹的课程。很多年轻考生都犯过错误，至少有一次是在学习的时候。甚至你可能曾经犯过这些错误，或者希望有人在你开始学习数据科学之前告诉你这些事情。当我开始的时候，我没有意识到很多事情。我整理了一些人们在开始在线学习数据科学之前应该知道的要点。
在线课程不会教你领域知识
在解决任何问题之前，您需要拥有正确的领域知识。正确的领域知识将帮助您很好地理解数据集的特征，并帮助您构建分析数据集的方法来讲述其中的故事。大多数有志青年都忘记了这一点。领域知识是最容易被忽视的技能，但对初学者来说却是最重要的。但是人们应该意识到，花时间去了解这个领域和他们试图解决的问题是必要的。
领域知识是解决问题的第一步。这是整个解决方案所依赖的基础。
你需要理解数据集
在您匆忙寻找丢失的值或开始清理数据之前，请适当地查看数据集，并尝试很好地理解它。使用 pandas 库中的 describe()方法提取关于数据的更多信息，如平均值、标准差、第一个四分位数。从数据集中选取任何特定的示例，并使用特征来理解它。
图片由斯科特·格雷厄姆
不要急于创建机器学习模型
许多初学者在预处理任何数据之前直接应用 ML 算法。任何人都可以写两到三行来训练算法和预测结果。数据科学家花费 80%的时间准备和管理数据。寻找异常值和相关性，填写缺失值。了解哪个功能影响最大。例如，如果你想解决一个分类问题，那么就要检查分类的不平衡。通俗地说，如果类不包含相同数量的例子，数据集就是不平衡的。例如，在一个二元分类任务中，我的 A 类占总数据的 99%，B 类占 1 %。不平衡的数据可能会导致所谓的过度拟合。
花时间准备和管理数据。在这个预处理中花点时间是没问题的。
在解作业之前理解已经写好的代码
许多初学者通常会学习他们之前在课程的那一周所做的事情，并将其应用到数据中。例如，如果学生正在学习支持向量机(一种分类算法)。在作业中，如果学生必须训练和测试我的模型。大多数学生都会完成这项任务。他们不会注意到之前编写的关于预处理数据的代码。
不要羞于提问
论坛是提问的好方法。不要羞于提问。永远清除你的疑虑。任何人都不应该对提问感到尴尬。继续满足你的好奇心。
重要的是不要停止质疑。好奇心有它存在的理由。——阿尔伯特·爱因斯坦
如果你不懂算法，那就从头实现
如果你在理解一个特定的算法时有问题，那么最好的方法就是自己编写算法。在这个过程中，您将了解它，这将帮助您理解 scikit-learn 这样的库是如何工作的。
图片由 Hitesh Choudhary 提供
不要欺骗自己
当你做作业或测验时，不要抄袭互联网资源。如果你被任务困住了，那就慢慢来。而是你认为解决问题有多聪明，而不仅仅是为了一个证书。我学到的大部分东西都来自于被困在一个问题中。
以前的编码和数学知识是非常有益的
我不同意有人说学一些数据科学的课程不需要有编码方面的经验。有编码的基础知识有助于相处。他们以后可能会教你 Python/R，但是如果你正在某个课程中学习它，那么我会建议你在像 HackerRank 、 HackerEarth 这样的平台上解决问题，以获得更多关于特定语言的经验，这样以后如果你使用任何像 matplotlib、NumPy 这样的库，你就可以轻松地编写它的代码了。如果你不知道基础数学，那么不要担心，YouTube 上有很好的资源可以学习。如果你想学微积分，那么我会推荐 3Blue1Brown 的微积分、线性代数频道，以及 Stat Quest 的统计学频道。对于希望开始学习数据科学数学的初学者来说，它们是极好的。
图片由 Antoine Dautry 提供
不要满足于 ML 算法的初始结果
您可以随时调整各种算法的值来改进您的模型。不要满足于模型的初始结果。始终使用超参数调整来获得更好的结果。许多算法允许您更改它们的超参数值，如 K 最近邻算法允许您更改可能会改善结果的邻居数量。记住你总是可以表现得更好。
永远不要停止学习
完成任何在线课程后，不要停止学习。在线课程将帮助你建立坚实的基础，但你必须不断学习。不断寻找各种数据集，练习。实践是做好任何工作的关键。不断查看各种博客帖子、笔记本、视频、研究论文，以了解更多信息。永远不要限制自己做任何事。作为一名数据科学家，你需要不断学习新技术。不要放弃。
图像由元素 5 数字
参考资料:
[1] blazon，我们每天创造多少数据 (2019)
适合初学者的机器学习资源
闯入人工智能
Avel Chuklanov 在 Unsplash 上拍摄的照片
传统的程序是我们提供给机器的一组指令，用来执行特定的任务。另一方面，机器学习是非常不同和独特的。机器学习是人工智能的一个子集，机器有能力根据经验学习和改进自己，而无需任何人明确编程。机器学习正处于蓬勃发展的阶段，有许多有趣的研究工作正在进行。每个人都想了解它，为了利用它的力量而闯入 AI。不幸的是，它通常被视为一个神奇的黑匣子，接受一些输入数据并给出神奇的预测，但它远不止如此。来自不同特征和领域的学生和开发人员希望开始在他们的项目中使用机器学习，但重要的问题是，
“我从哪里开始机器学习？”
进入这个领域不是几天的任务，但今天的许多资源已经使初学者更容易起步。今天，你不需要注册一个博士项目，或者你甚至不需要获得一个计算机科学学位来学习这项新技术。不管背景如何，您都有各种选择来开始使用 ML。在这篇文章中，我们将回顾一些最好的初学者友好的机器学习资源。
在直接进入之前，你应该知道基本上有各种各样的路径可以让你进入 ML 和 AI。有一种自顶向下的方法，在这种方法中，您只需简单地学习高层次的东西，并使用 TensorFlow 和 Pytorch 等框架关注实现[我们将在本文后面讨论这些框架]。另一种方法是，你专注于每一个算法及其背后的所有数学和统计。后一种方法对于想进入人工智能和人工智能研究领域的人来说是最有益的。确定更适合自己的。
根据我的看法，自顶向下的方法更适合大多数想要进入 AI 和 ML 并开始从事他们的项目的初学者。在这种方法中，你可以在需要的时候学习背后的数学知识。在这里，你可以直接体验实际工作，这让你有动力继续学习。然而，如果他们只是不停地学习 ML 的理论，而没有在任何地方使用它，他们可能会失去兴趣。需要记住的重要一点是，在这种方法中，人们倾向于跳过感知部分，只是从互联网或课程中复制粘贴一些代码。代码将会工作，但是理解它背后的直觉和推理是必要的。你必须知道你写的每一行代码的原因。
如果你想从自上而下的方法开始，那么互联网上有很多免费的资源。人们问我的最常见的问题是，“我做过 Python。现在，我如何从 ML 开始？”我的答案是一系列的步骤，我将在这篇文章中讨论。如果你有 Python 语言的知识，那很好，因为它有大量的机器学习库，这使它成为 ML 的最佳语言之一。但是如果你对这种语言一无所知，也不要气馁。这是最简单的编程语言之一。
学习 Python
**1-**Python for Everybody Specialization由密歇根大学在 Coursera 上开设— 链接 这是 Coursera 上最好的 Python 编程语言入门课程之一。它涵盖了所有的主题，如数据结构，数据库和网络应用程序接口。
由密歇根大学提供。这种专业化建立在 Python 面向所有人课程的成功基础上，并且…
www.coursera.org](https://www.coursera.org/specializations/python)
2 - *从零开始学习 Python【Python boot camp】*在 YouTube 上从零到精通— 链接 Andrei Neagoie 是一位很棒的导师，在 Udemy 上有很精彩的点评。我个人很喜欢他所有的课程。这是他为想开始学习 Python 的人开设的课程。
3 - *学习 Python —初学者的完整课程【教程】*由 YouTube 上的 freeCodeCamp 提供— 链接 这是一个大约 4 小时 30 分钟长的视频，在这里您将获得开始学习 Python 语言所需的一切。本课程由 Mike Dane 开发。
用于机器学习的 Python
学习完 Python 之后，最好先掌握一些在 ML 和 AI 项目中需要用到的库的知识，比如 Pandas、Matplotlib、Numpy。
**1-**Python for Data Science and AI由 IBM 在 Coursera 上— 链接 这涵盖了第一周 Python 的一些基础知识。然后它前进到数据结构和使用 python 处理数据。最后一周包括分析美国经济数据和建立一个仪表板。
由 IBM 提供。用这个开始你的数据科学 Python 学习，以及一般的编程…
www.coursera.org](https://www.coursera.org/learn/python-for-applied-data-science-ai?)
密歇根大学 Coursera 上的 2 - 应用数据科学与 Python 专业——链接 对于所有 ML 爱好者来说，这是一个非常棒的专业。如果你完成了这门课程，你将会非常熟练地使用 python 语言进行数据可视化、挖掘、操作以及数据科学中需要的其他东西。
由密歇根大学提供。密歇根大学专业的 5 门课程向学习者介绍了…
www.coursera.org](https://www.coursera.org/specializations/data-science-python)
3 - 用于数据科学的 PythonupGrad-链接 本课程涵盖的主题包括 Python 简介、使用 Python 编程、数据科学库和数据可视化。
upStart 是 upGrad 中一个独特的生态系统，帮助您保持领先地位，并体验 upGrad 的一部分…
www.upgrad.com](https://www.upgrad.com/free-courses/?utm_source=organicchannels&utm_medium=web&utm_campaign=banner_homepage)
熟悉这些库的最佳资源是浏览它们的官方文档。它们是探索和深入了解它的最佳场所。
https://numpy.org/doc/
熊猫—https://pandas.pydata.org/docs/
马特普洛特利—https://matplotlib.org/3.3.2/contents.html
ML 和 AI 的基础
在学习 python 和函数库的时候，最好继续学习人工智能的基础课程，这样你就能直观地了解它到底是什么。
Reaktor 和赫尔辛基大学合作的 1 - 人工智能元素——链接 人工智能元素是一门免费的在线课程，面向所有初学者。你会得到人工智能的基本概念，他们的主要目标是揭开人工智能的神秘面纱。
2018 年春天，Reaktor 和赫尔辛基大学携手合作，旨在帮助人们获得力量…
www.elementsofai.com](https://www.elementsofai.com/)
**2-**AI For every oneby deep learning . AI on Coursera—链接 这是吴恩达策划的又一场精彩课程。它涵盖了任何人在涉足人工智能之前可能想知道的所有要点。这是为各种性格和背景的人准备的。
由 DeepLearning.AI 提供 AI 不仅仅是给工程师的。如果你想让你的组织更好地使用人工智能…
www.coursera.org](https://www.coursera.org/learn/ai-for-everyone)
**3-**Google 开发者在 YouTube 上的机器学习方法——链接 在这个系列中，乔什·戈登很好地解释了任何人如何使用 Scikit Learn 和 TensorFlow 这样的库开始使用 ML 的基本代码。
**4-**upGrad 上的机器学习概念介绍——链接 这是一门为期 6 周的课程，涵盖了线性回归、逻辑回归、聚类和推荐系统等 ML 主题。
upStart 是 upGrad 中一个独特的生态系统，帮助您保持领先地位，并体验 upGrad 的一部分…
www.upgrad.com](https://www.upgrad.com/free-courses/?utm_source=organicchannels&utm_medium=web&utm_campaign=banner_homepage)
机器学习深入
在经历了人工智能的基础知识并准确理解其背后的概念后，ML 不再是一个神奇的黑匣子。现在，您应该更深入地了解它，并学习如何使用 TensorFlow 和 PyTorch 这样的框架来构建自己的 ML 模型。
1 - 机器学习斯坦福大学 Coursera — 链接 如果你想深入了解所有类型的机器学习算法，这是你的不二之选。课程内容非常精彩，形式也很好。在本课程中，您将看到回归、分类、神经网络、异常检测、推荐系统等等。它充满了伟大的内容。
机器学习是让计算机在没有明确编程的情况下行动的科学。在过去的十年里…
www.coursera.org](https://www.coursera.org/learn/machine-learning?)
2 - 机器学习速成班 by Google — 链接 本速成班是有志于机器学习从业者的自学指南。它包含一系列课程，包括视频讲座、真实案例研究和动手实践练习。
学习和应用基本的机器学习概念的速成课程，获得现实世界的经验与…
developers.google.com](https://developers.google.com/machine-learning/crash-course)
3 - MIT 6。S19:深度学习入门 — 链接 麻省理工学院关于深度学习方法的官方入门课程，应用于机器人、游戏、艺术、计算机视觉、语言、医学等领域！学生将获得深度学习算法的基础知识，并获得在 TensorFlow 中构建神经网络的实践经验。
麻省理工学院关于深度学习方法的入门课程，应用于计算机视觉，自然语言处理…
introtodeeplearning.com](http://introtodeeplearning.com/)
4 - 深度学习。AI TensorFlow 开发者专业证书 — 链接 TensorFlow 是 Google 的一个开源机器学习库，它让构建深度学习模型变得非常容易。这是一个非常强大、可伸缩和灵活的框架。本课程将引导你了解从初级到中级的所有关于 TensorFlow 的知识。
由 DeepLearning.AI 提供。TensorFlow 是最受欢迎和最受欢迎的开源深度学习框架之一…
www.coursera.org](https://www.coursera.org/professional-certificates/tensorflow-in-practice)
5 - 用 PyTorch 介绍深度学习由脸书人工智能在 Udacity 上——链接 PyTorch 是脸书 AI 研究实验室的另一个开源机器学习库。它基于 Torch 库。它允许用户很容易地在较低的级别上进行修改和更改，因此它主要在研究领域流行。本课程涵盖了 PyTorch 入门所需的所有基础知识。
[## PyTorch 深度学习简介| Udacity 免费课程
深度学习正在推动人工智能革命，PyTorch 正在让任何人比以往任何时候都更容易建立深度学习…
www.udacity.com](https://www.udacity.com/course/deep-learning-pytorch–ud188)
根据领域定制
一旦你熟悉了机器学习和之前课程中的所有基本算法，你会想要探索机器学习中的特定领域，如深度学习、自然语言处理、计算机视觉等。这里有一些很好的课程，将从零开始涵盖这些主题。
1 - 深度学习专业化由 Coursera 上的 Deep Learning . ai—链接 入门神经网络和深度学习，对我来说，这是最重要的课程之一。他们的项目笔记本是测试我们能即时应用多少知识的好方法。
从 deeplearning.ai 学习深度学习，如果你想打入人工智能(ai)，这个专精…
www.coursera.org](https://www.coursera.org/specializations/deep-learning)
2 - 自然语言处理专门化由 Coursera 上的 deep learning . ai—链接 深度学习蓬勃发展的另一个领域是 NLP。NLP 需要大量的预处理，并且总体上有一种不同的方法。通过专业学习后，你会对这个领域充满信心。
自然语言处理(NLP)使用算法来理解和操纵人类…
www.coursera.org](https://www.coursera.org/specializations/natural-language-processing)
**3-**fast . ai 为编码人员提供的实用深度学习——链接 Fast.ai 是另一个库，旨在让任何背景的人都更容易建立 ML 模型。这是基于 PyTorch 的，有很大的特点。他们的课程涵盖了这个图书馆的一切，Fast.ai 的创始人杰里米也以非常易懂的方式解释了机器学习的大多数重要概念。
如果你现在就准备好投入进去，下面是开始的方法。如果你想更多地了解本课程，请阅读…
course.fast.ai](https://course.fast.ai/)
4 - 医药专用 ai由 deeplearning.ai 上 Coursera — 链接
医药用 AI 和其他用途 AI 不是很像。它要求更高的精度，更高的准确度，而我们可用的数据却非常少。本课程展示了数据扩充和其他方法的力量，用更少的数据建立更好的模型。
模型解释图像分割自然语言提取机器学习时间到事件建模深度…
www.coursera.org](https://www.coursera.org/specializations/ai-for-medicine)
5 - 强化学习由佐治亚理工学院在 Udacity 上— 链接
免费课程由佐治亚理工学院提供，编号为 CS 8803。关于本课程的免费课程，如果你需要，你应该选修本课程
www.udacity.com](https://www.udacity.com/course/reinforcement-learning–ud600)
6 - 深度强化学习课程 — 链接 本课程是一系列文章和视频，在这里您将掌握成为深度强化学习专家所需的技能和架构。您将通过 Tensorflow 和 PyTorch 实现出色的代理来建立强大的专业投资组合，这些代理学习玩太空入侵者、《我的世界》、星际争霸、刺猬索尼克等等！
深度强化学习课程是一个关于深度强化学习的免费课程(文章和视频)，其中…
simoninithomas.github.io](https://simoninithomas.github.io/deep-rl-course/)
**7-**Coursera 上的 deeplearning.ai 提出的生成对抗网络——链接 GANs 是 Ian Goodfellow 在 2014 年提出的一个相对较新的概念。GANs 概念对深度学习的认知产生了巨大的变化。这是一门很好的课程，你以后可能会想学。
由 DeepLearning.AI 提供关于 GANs 生成对抗网络(GANs)是强大的机器学习模型…
www.coursera.org](https://www.coursera.org/specializations/generative-adversarial-networks-gans)
8 - 关于深度学习和自然语言处理的介绍关于 upGrad-链接 了解更多关于 AI 和 ML 背后的数学这门课程包括为期 4 周的数据分析背后的数学、深度学习的介绍和自然语言处理的介绍。
upStart 是 upGrad 中一个独特的生态系统，帮助您保持领先地位，并体验 upGrad 的一部分…
www.upgrad.com](https://www.upgrad.com/free-courses/?utm_source=organicchannels&utm_medium=web&utm_campaign=banner_homepage)
9 - 机器学习和云高级认证由 IIT 马德拉斯在 upGrad — 链接 在本课程中，您将学习使用云计算和印度最先进的认证计划部署机器学习模型，该计划由 IIT 马德拉斯& upGrad 独家提供。
[## IIT 马德拉斯大学的机器学习和云计算高级认证| upGrad
通过印度最先进的认证计划，学习使用云计算部署机器学习模型…
www.upgrad.com](https://www.upgrad.com/advanced-certification-ml-cloud-iitm/)
有趣的播客
播客是与机器学习领域保持同步的最佳资源，因为它非常活跃并且不断变化。我提到了一些我听过的最好的播客。
1 - 线性题外话 — 链接
2 - 莱克斯·弗里德曼播客 — 链接
3 - 数据怀疑者 — 链接
最佳书籍
就我个人而言，在学习完这些课程后，我发现书籍是最好的知识来源。这是你可以加强对你在 ML 项目中使用的概念的理论理解的地方。
1 - 百页机器学习书作者安德烈·布尔科夫
一本很短但知识很完善的书。安德烈已经压缩了 AI/ ML 中所有至关重要的点，放在这本 100 页的书里【准确的说是 138 页】。
2 - 用 Scikit-Learn、Keras 和 Tensorflow 2.0 实践机器学习的书作者 Aurelien Geron-O ’ Reilly
对我来说，这本书是 deeplearning.ai 的机器学习和深度学习专业的替代物。我更喜欢这本书，因为它有完美的解释，每个概念都有很好的代码可以一起尝试。你也可以通过以下链接获得本书的开源代码—https://github.com/ageron/handson-ml2
3 - 深度学习书作者:Ian Goodfellow
如果你想更深入地了解深度学习的数学方面，那么这本书有你需要的一切。是 2015 年出版的，所以比较老但是内容很棒。
乙举证书
Max Tegmark
Life 3.0 不是用来学习 AI 和 ML 的，但它是一本美丽的书，讨论了人工智能对人类未来的影响和宇宙的影响。作者的观点很有趣，这的确是一本好书。
结论
最后，我们已经到达了整个资源列表的末尾。这些很多，还有更多！但不要不知所措。一旦你浏览了大部分的资源，你会发现自己探索更多和发现新的有用资源是很有趣的。最重要的是要知道，你不应该停留在完成课程和书本上。时不时地继续做项目。让你在学习每项新技能后建立项目成为一种习惯。对我来说，这是你知道自己学到了什么的方法，也是你保持动力的方法——通过建立有趣的项目。
此外，继续阅读技术博客和文章。Medium、Wired、TechCrunch 是这类技术博客的好去处。了解最新的研究成果。你会注意到，开始时你不会理解很多，但随着你的进步，一切都变得有意义了。很高兴看到 ML/ AI 最近的进展，因为一切都在快速变化。
前方是一段伟大的旅程……继续学习！
初学者指南，在 10 分钟内构建、比较和评估机器学习模型
通过 Python 示例笔记本，探索构建机器学习模型的主要步骤。
初学者指南，在 10 分钟内建立、比较和评估机器学习模型。约书亚·索蒂诺在 Unsplash 上拍摄的照片
本笔记本的目标是给出构建和评估机器学习模型的步骤的高级概述。这是通过将每一步总结成最短的形式来完成的，所以请记住，在现实生活中，每一步都要复杂得多。
你可以跟着一起过来 完整笔记本 。
机器学习的步骤
- 数据准备— 检查并准备数据集
- 定义模型验证策略— 在训练、验证和测试集中拆分数据
- 模型开发— 使用 Python 中的 sklearn 库构建三个不同的模型:随机森林、决策树、逻辑回归。
模型评估和微调使用 GridSearch 交叉验证 - 型号选择
- 最终模型评估
步骤 1:数据准备
对于这个项目，我将使用现有的网络安全数据集。该数据集的目标是预测某个连接是否是网络攻击。
数据集包含许多历史连接数据。对于这些连接中的每一个，已经注册了关于它们的不同变量。我们还有一个变量来表示连接是否危险(网络攻击)。
目标是开发一个能够“学习”如何区分正常连接和危险连接的模型。我们还不知道如何做到:我们的机器学习模型将不得不学习这一点。
这一行的结果:scikit learn 获取数据集。
下面我们看到了数据的快速打印。第一列给出了关于连接类型的信息，其他列是关于连接的数字信息(参见 kddcup99 以获得关于变量内容的更多详细信息)。
这一行的结果:我们数据的前 5 行。
在现实生活中的机器学习案例中，我们需要检查这些数据，并找出我们应该使用哪些变量，或者我们应该明确忽略哪些变量。但这是一个简单的例子，所以我们按原样取数据，看看我们在 10 分钟内可以获得什么样的精度。因此，我们删除了关于连接类型的列，并且我们以相同的方式对待每种类型的连接。
我们还检查了因变量，我们注意到它不是我们想要的数字 1 对 0 格式。让我们改变这一点。
这是目标变量的格式。我们想把它转换成 0 和 1。
为了快速了解数据，我们在数据中绘制了攻击和正常连接的计数。请注意，我们的数据是有偏差的，因为“攻击”连接比正常连接多得多。
正常(0)连接和攻击(1)连接的最终分布不是 50–50。
第二步:定义模型验证策略:训练验证测试分割
为了验证任何预测模型，我们最好将一部分数据分开。当完成开发一个模型时，我们将能够在这个测试数据上应用它。这允许我们在实际部署模型之前，测量我们的模型在现实生活中的效果。
我们有很多观察结果，所以我们可以允许分成三个部分:训练、验证、测试。在数据较少的情况下，我们通常一分为二:训练和测试。
- 训练数据:用于开发 3 个模型，并通过超参数调谐(网格搜索)进行微调
- 验证数据:用于型号选择
- 测试数据:用于对我们的分类模型的样本外精度有一个客观的最终估计
第三步:模型开发
在模型开发步骤中，我们将构建三个不同的模型，并应用 GridSearch 进行超参数调整。实际上，测试三个模型是您应该测试的最少模型数量。尝试更多的模型有更高的机会找到一个伟大的结果！
我们将使用的三种模型是:
- 随机森林
- 决策图表
- 逻辑回归
除了玩模型的选择，我们还可以玩每个模型的超参数的选择。有一种自动化的方法可以测试大量的超参数组合，并保留最佳评分超参数组合:网格搜索。
将使用 GridSearchCV 调整以下超参数:
- 对于随机森林:“最大特征”
- 对于决策树:“最大特征”和“最小样本分割”
- 对于逻辑回归:“C”
步骤 3a:随机森林超参数调整
步骤 3a 结果:对验证数据应用随机森林并打印 roc_auc_score
99%很高！
步骤 3b:决策树超参数调整
步骤 3b 结果:对验证数据应用决策树并打印 roc_auc_score
也 99%，也很高！
步骤 3c:逻辑回归超参数调整
步骤 3c 结果:对验证数据应用逻辑回归并打印 roc_auc_score
94%也高，但是有点不太好。
第四步:在验证数据集上选择性能最佳的模型
根据 GridSearch 的分数，选择的模型将是随机森林！
步骤 5:精度的最终估计:将选择的模型应用于测试数据
为了获得随机森林准确性的最终估计，我们将其应用于测试数据。这为我们提供了一个新的准确度分数，该分数可能更接近于从任何新的(外部)数据中获得的分数。
分数相差不大，可以保留模型。
虽然机器学习建模的实际过程比这要复杂一点，但我希望这篇文章确实对需要采取的不同步骤进行了很好的高层次描述。记得你可以跟着 一起把 的完整笔记本拿过来。希望你喜欢这篇文章。感谢阅读，不要犹豫，继续关注更多！
如何从 OpenStreetMap 下载数据集？
面向所有人的开源 GIS 数据
插图作者:金彩云
为什么选择 OpenStreetMap？
它是免费的。💸
有许多可用的地图提供商，如**谷歌、OS Survey、Mapbox、**等等。但是数据是有版权的，达到限额后你要为你使用的东西付费。而 OpenStreetMap(OSM) 对每个人都是免费的，没有任何隐性费用。它是在开放数据公共开放数据库许可 (ODbL)下许可的。每个人都可以自愿贡献数据，每个人都可以免费使用这些数据！
获取原始数据！📂
大多数商业地图提供商不会让您访问地图背后的数据。使用 OpenStreetMap ，您可以完全访问数据库，并且可以提取所需位置的原始 GIS 数据。
全球数据覆盖🌍
世界各地成千上万的贡献者不断更新数据，使 OpenStreetMap 成为覆盖世界各地的最新 GIS 数据库之一。
从 OpenStreetMap 获取 GIS 数据
有几个在线工具可以从 OpenStreetMap 数据库下载 GIS 或地图数据。在这些工具中，您可以根据所需的输出数据格式、大小和要求的边界区域来选择它们。
案例 1:如果您需要一个带有指定边界框的小型 GIS 数据集。
在这种情况下，您可以直接从主OpenStreetMap网站获取数据，非常快速简单，虽然输出数据格式和大小有限。它允许您在中导出 GIS 数据。osm 格式，面积限制为 0.25 度( )平方(例如 1 x0.25 或 0.5x0.5 等)，其中 1 约为 69 英里或 111 公里。如果您的项目需要更大的数据，请使用其他可用的工具。
从 https://www.openstreetmap.org/导出 OSM 数据
要提取数据，你只需浏览到 OpenStreetMap 网站，像任何其他网络地图一样使用搜索、平移、缩放工具找到你想要数据的区域。然后，使用顶部工具条菜单上的导出工具，在导出数据前确认边界框区域。就是这样！
如果在某处保存了边界框区域，还可以使用以下结构直接构造对 OpenStreetMap API 的 HTTP 调用，以下载 OSM 数据:
https://api.openstreetmap.org/api/0.6/map?bbox=**<min long>**, **<min lat>**, **<max long>**, **<max lat>**
无论哪种方式，都会得到中所选区域的数据。osm 格式。如果想要其他数据格式，请使用其他工具。
情况 2:如果您需要一个具有指定边界框的较大 GIS 数据集。
现在，假设您的项目需要更大的数据，您可以使用 BBBike Extract 服务提取指定边界框区域的 GIS 数据。该 web 应用服务允许您提取和下载多种格式的 OSM 数据，包括 OSM 、 PBF 、 Garmin 、 Shapefile 、 mapsforge 、 OsmAnd 、 SVG 、 GeoJSON 、 SQL 等。每个请求的最大请求大小为 512 MB，处理大约需要 2-7 分钟。
BBBike 摘录 Web 界面
要使用这项服务，你只需要在地图界面中平移或缩放到你想要的区域，并绘制出你需要的区域的边界框区域。然后，点击提取按钮，等待您的结果，您可以在https://download.bbbike.org/osm/extract/看到您的数据提取状态
案例 3:如果您需要特定行政区域的 GIS 数据集。
如果您需要世界上任何特定行政区域的 GIS 数据， GeoFabrik 下载服务器将是您的正确选择。它提供每天更新的现成 GIS 数据，并允许您下载不同级别的数据，包括洲、国家、州和更小的级别。该工具为您提供了中的数据。面向全球的 osm 格式和面向小型数据集的 ESRI 形状文件格式。访问该网站后，您会在页面的左下角找到可用数据的表格列表。您可以选择直接从各大洲下载 .osm.pbf 或 .osm.bz2 格式的数据。
GeoFabrik 下载服务器中的可用区域列表
或者如果你只需要特定的子区域，比如德国拜仁州某个地区的数据，你可以通过子区域菜单欧洲 > 德国 > 拜仁简单选择。更深层次的数据可以在下载。osm 和 ESRI shapefile 格式。
GeoFabrik 下载服务器中的子区域区域数据
或者，如果您想要使用 GeoJSON 格式的数据，您可以使用 OSM 跨线提取 工具以相同的方式提取数据，但其数据覆盖范围较小。
案例 4:如果你需要一个完整的 OSM 数据集。
如果您的项目需要一个完整的 OSM 数据集并使用数据库，请随时前往 行星 OSM 服务，您可以找到并下载整个 OSM 数据集。它有一个压缩的 XML 文件(超过 88GB)和一个定制的 PBF 格式文件(超过 50GB)。你可以点击 查看用于处理这些 OSM 文件类型 的工具列表。此外，历史 OSM 数据集也可用于此源。更多关于 OSM 星球的数据和网络可用性的信息可以在 这里 找到。
案例 5:如果您想要查询部分 OSM 数据集。
您可以看看 立交桥 API 来查询您需要的部分 OSM 地图数据。如何使用立交桥 API 的教程在 这里 有。你可以在 天桥 Turbo 上试试，作为直接通过 web 查询 OSM 数据的界面。
如果您已经在使用 QGIS 软件，您可以尝试使用 QuickOSM 插件来轻松查询您需要的特定数据集。在后端，该插件使用 trans 过场 API 下载查询到的 OSM 数据，并将数据转换为 QGIS 矢量图层。假设您的机器上已经安装了 QGIS 的更新版本，让我们来看看如何安装和使用 QuickOSM 插件的基本指南:
如何使用 QuickOSM 插件 QGIS 软件的基本指南
- 打开 QGIS 软件后，在插件菜单中找到名为 QuickOSM 的插件。
- 安装插件！！
- 安装完成后，你会在 Vector 菜单栏中找到这个工具。
- 查询你需要的数据。例如，上图显示了对斯图加特地区行政边界的查询。然后，等待插件下载完数据。如果你愿意，你也可以在查询标签中使用天桥 API。
- 搞定了。数据图层被添加到 QGIS 中。请注意，您应该将项目坐标系设置为 WGS 84/伪墨卡托(EPSG:3857)以使用 OSM 数据集。
请注意，您还可以使用任何其他选项来下载 GIS 数据，因为 QGIS 默认支持 OSM 矢量文件。
案例六:还有什么？🤔
如果你熟悉 Python3 或 Docker，想为你的项目自动化一些流程，可以使用 OpenMapTilesdownload-osm工具下载指定位置或整个星球的 osm 数据。如果你热爱 Java，请查看一下 渗透 repo，这是一个用于处理开放街道地图数据的命令行 Java 应用程序。
作者消息:
大概就是这样。有多种工具可用于从 OSM 提取或下载 GIS 数据。我希望这篇文章能帮助你找到适合你的项目的合适的工具或方法。如果你有任何问题，请随时给我发信息。
关于我&查看我所有的博客内容:链接
平安健康！
感谢阅读。👋😄
深度学习和 CNN 的初学者速成班
没有复杂数学的生动解释。
注:这是我关于深度学习和卷积神经网络的视频总结。如果你感兴趣，可以随时观看，了解更多信息！
本文中的所有资产和图像都是由我创建的
深度学习极其迷人。从识别和分类图像，到甚至产生梦一样的幻觉，深度学习都做到了。
当我了解到这个话题时，我不断受到极其复杂的数学方程和无数充满缩写词的术语的轰炸，听起来像是深度学习的口袋妖怪等价物。然而，剥去所有这些，深度学习实际上变得直观了。欢迎来到我的深度学习和卷积神经网络的“动画”指南！
图像分类
我们将通过使用一个蜱的黑白图像来简化事情，其中一层代表一个专用的黑白通道。黑色用-1 表示，而白色用正 1 表示。
分笔成交点的数字表示
现在，如果我们想对图像本身进行分类，我们需要首先对输入进行一些处理。
卷积步骤
这里的主要目的是从输入图像中提取关键特征。
为了检测特征，我们需要一个叫做过滤器的东西。过滤器只是一种模式的数字表示。从这里，我们可以看到，这定义了蜱的茎的模式。
滤波器的数值表示
从左上角开始，这个过滤器试图找到与它所具有的特征相匹配的特征。请注意，这个过滤器在任何时间点都只关心一个小区域。这个区域被称为感受野。
为了找到匹配，过滤器对它正在查看的图像部分执行一系列数学运算。
过滤器对图像的一部分执行的数学运算
首先，对于每个对应的图像和过滤器像素，将这些值相乘。然后，将它们相加给出一个结果。然后将该值除以过滤器中的像素总数，得到平均值。计算结果随后存储在特征图中的一个像素上。
整个图像的卷积过程
当滤波器逐步移动并在每个点执行操作时，我们对整个图像重复这个过程。滤波器的这种滑动运动概括了卷积的全部思想。过滤器在每一步移动的距离称为步长，在本例中为 1。
此时，您可能想知道:功能图的意义是什么？特征图实际上是我们的过滤器的特征与图像匹配程度的空间表示。理解上面的值的直观方式是，1 表示完全匹配，而-1 表示完全不匹配。中间的任何剩余值仅仅表示部分匹配。
我们可以使用不同的过滤器来帮助检测其他特征。可以相应地定制每个滤波器的大小和我们想要在这个卷积步骤中使用的滤波器的数量。
至此，我们的第一个卷积层就完成了。
整流线性单位
校正线性单位—标准化过程
现在，我将添加一个层来将我们的特征图中的所有负值变成零，这是一种纠正特征图的归一化的形式。这被称为 ReLU 层，代表整流线性单元。
最大池化
步长为 2 的 2px x 2px 区域的池化过程
此外，我们可能还会添加一个层来做一些精简，以帮助提高计算速度。一种方法是从一个区域中取出最重要的值(也就是最大值)并记录下来。这就是所谓的最大池层。在这种情况下，我的 max-pooling 层汇集了一个 2px 乘 2px 的区域，并设置为步长为 2，一次移动两个像素并记录值。
我们像汉堡一样重复和堆叠上述层，以形成卷积神经网络的肉，增加了有助于图像分类的特征的复杂性。
全连接层
最后，我们添加一个完全连接的层来解释结果。这基本上是你通常看到的代表神经网络的通用神经元和突触模型。
为了直观地理解它，这只是网络决定某个特征的重要性的地方。越重要，“权重”越重——用粗线表示——意味着神经元之间的联系越强。
全连接层介绍和图像展平演示
第一层神经元代表在一系列卷积、ReLU 和汇集循环之后创建的特征图的每个单独像素，像这样被展平成一维。该像素的值可以被视为神经元的信号强度，值越高表示信号越强。因此，随着连接越来越强，这组神经元发出的信号的更大比例可以通过。
最后一层神经元的激活
这最后一层神经元将告诉我们它在预测某个对象时有多自信。这些神经元的激活是基于它接收到的信号的强度。更高的激活意味着来自先前神经元的累积信号更强。
因为我们要在两类物体之间做出决定，所以我们会有两个输出神经元——一个用于滴答，一个用于十字。激活 1 表示将图像分类为它所对应的任何类别的百分之百的置信度，而 0 表示完全拒绝。如果你愿意，你可以在它们之间堆叠更多的神经元层，使你的模型更加动态。
学习过程
直觉的、非数学的解释
训练模型的想法就像你训练宠物变戏法一样。如果宠物玩得好，你就奖励它们一份礼物。嗯，对于机器来说，它们的“待遇”是以成本函数的形式定义的。如果他们表现得更好，成本函数的值就会更低，这意味着他们的方向是正确的，反之亦然。神经网络想要尽可能地最小化这个成本。
为了训练神经网络，我们需要称为训练集的数据。训练集包含一组图像，在我们的例子中是勾号和叉号，它们都标有正确的答案。每当我们向网络提供一幅图像时，它就会通过所有层，根据它认为的图像生成一个响应。根据输出，网络会对自己进行评估，并确定它与正确答案的差距。
然后，网络调整权重，以试图通过找到正确的组合来提高其准确性，从而将自己导向正确的方向。这是通过反向传播和梯度下降完成的，这涉及到一点微积分，在这里将不深入讨论。
最小化成本函数的图形表示
然而，从图形上来说，它试图编辑成本函数，以便最终达到局部最小值。它学习的速率可以通过改变它的学习速率来修改。
然后，我们使用一个验证集，这是一组神经网络看不到的图像，来检查它在训练阶段后的性能。这就好比让神经网络考试，看它考得怎么样。
然后，如果需要的话，我们进一步训练该模型，以获得可能的最佳结果。现在，你已经对卷积神经网络和深度学习有了直观的了解！
我确实希望这篇文章能帮助你更好地理解深度学习和 CNN。感谢您的阅读！
自然语言处理中数据清理和特征提取初学者指南
本文将解释使用神经语言处理(NLP)进行文本分析的数据清理和未来提取的步骤。
在网上，有很多很棒的文字清理指南。一些指南在文本清理之后进行特征提取，而一些指南在文本清理之前进行特征提取。这两种方法都很好。然而，这里有一个很少被关注的问题:在数据清理过程中，我们丢失了一些可能的特征(变量)。在数据清洗之前，我们需要进行特征提取。另一方面，有些特征只有在数据清理后提取时才有意义。因此，我们还需要在数据清洗后进行特征提取。本研究关注这一点**、和这是本研究的独特之处。**
为了解决上述问题，本研究依次遵循三个步骤:
- 特征提取—第一轮
- 数据清理
- 特征提取—第二轮
这篇研究文章是采用 NLP 方法的亚马逊综述分析的一部分。这里是主研究代码的 Colab 笔记本的 my GitHub repo ，以及本次研究的 代码 。
**关于我使用的数据的简要信息:**本项目使用的数据是从 Kaggle 下载的。是斯坦福网络分析项目上传的。原始数据来自 J. McAuley 和 J. Leskovec (2013)对“从业余爱好者到行家:通过在线评论对用户专业知识的演变进行建模”的研究。这个数据集由来自亚马逊的美食评论组成。该数据包括了从 1999 年到 2012 年的所有 568，454 篇评论。评论包括产品和用户信息、评级和纯文本评论。
特征提取—第一轮
在这一部分中，将提取数据清洗后不可能获得的特征。
- **停用词的数量:**停用词是搜索引擎已经被编程忽略的常用词(例如“the”、“A”、“an”、“in”)，无论是在索引用于搜索的条目时还是在作为搜索查询的结果检索它们时。在 Python 的 nltk 包中，有 127 个英文停用词默认。通过应用停用词，这 127 个词被忽略。在删除停用词之前，让我们将“停用词数量”作为一个变量。
df['stopwords'] = df['Text'].apply(lambda x: len([x for x in x.split() if x in stop]))df[['Text','stopwords']].head()
2.**标点符号的数量:**数据清洗后无法获得的另一个特征是因为发音会被删除。
def count_punct(text):
count = sum([1 for char in text if char in string.punctuation])
return count#Apply the defined function on the text data
df['punctuation'] = df['Text'].apply(lambda x: count_punct(x))#Let's check the dataset
df[['Text','punctuation']].head()
3.标签字符的数量:我们可以从文本数据中提取的一个更有趣的特征是标签或提及的数量。在数据清理期间，标签将被删除，我们将无法访问这些信息。因此，让我们在仍然可以访问它的时候提取这个特性。
df['hastags'] = df['Text'].apply(lambda x: len([x for x in x.split() if x.startswith('#')]))df[['Text','hastags']].head()
4.**数字字符的数量:**拥有评论中出现的数字字符的数量可能是有用的。
df['numerics'] = df['Text'].apply(lambda x: len([x for x in x.split() if x.isdigit()]))df[['Text','numerics']].head()
5.**大写单词的数量:**愤怒、愤怒等情绪经常通过大写单词来表达，这使得这成为识别这些单词的必要操作。在数据清理过程中，所有字母将被转换成小写。
df['upper'] = df['Text'].apply(lambda x: len([x for x in x.split() if x.isupper()]))df[['Text','upper']].head()
现在，我们完成了只能在数据清理之前获得的特征。我们准备清除数据。
文字清理技巧
在对数据应用 NLP 技术之前，首先需要清理数据并为分析准备数据。如果这个过程做得不正确，它可能会完全破坏分析部分。以下是应用于数据的步骤:
- **将所有文本转换成小写:**第一个预处理步骤是将评论转换成小写。这避免了相同单词的多个副本。例如，在计算字数时，如果我们忽略这种转换，则“狗”和“狗”将被视为不同的单词。
df['Text'] = df['Text'].apply(lambda x: " ".join(x.lower() for x in x.split()))df['Text'].head()
2) 目前，NLP 方法还没有一个有意义的方法来分析标点符号。因此，它们被从文本数据中删除。通过这一步，这些字符被删除:[！" #$% & '()*+，-。/:;= >？@[]^_`{|}~]
df['Text'] = df['Text'].apply(lambda x: " ".join(x.lower() for x in df['Text'] = df['Text'].str.replace('[^\w\s]','')
df['Text'].head()
3) 停用词的移除:通过这一步，我移除了 nltk 包中所有默认的英文停用词。
from nltk.corpus import stopwords
stop = stopwords.words('english')df['Text'] = df['Text'].apply(lambda x: " ".join(x for x in x.split() if x not in stop))df['Text'].sample(10)
添加自己的停用词 :此时，你可能想添加自己的停用词。我这样做主要是在检查了最常用的单词之后。我们可以这样检查最常用的单词:
import pandas as pd
freq = pd.Series(' '.join(df['Text']).split()).value_counts()[:20]
freq
最常见的 20 个单词
从这几个词中，我想去掉’ br ‘，’ get ‘，’ also '，因为它们没有太大意义。让我们将它们添加到停用词列表中:
# Adding common words from our document to stop_wordsadd_words = ["br", "get", "also"]
stop_words = set(stopwords.words("english"))
stop_added = stop_words.union(add_words)df['Text'] = df['Text'].apply(lambda x: " ".join(x for x in x.split() if x not in stop_added))df['Text'].sample(10)
注意:在其他指南中，您可能会遇到 TF-IDF 方法。TF-IDF 是从文本数据中去除没有语义价值的单词的另一种方法。如果你用的是 TF-IDF，就不需要应用停用词(但是两个都应用也无妨)。
4) **移除 URL:**URL 是被移除的数据中的另一个噪音。
def remove_url(text):
url = re.compile(r'https?://\S+|www\.\S+')
return url.sub(r'', text)# remove all urls from df
import re
import string
df['Text'] = df['Text'].apply(lambda x: remove_url(x))
5) 去除 html HTML 标签: HTML 在互联网上被广泛使用。但是 HTML 标签本身在处理文本时并没有什么帮助。因此，所有以 url 开头的文本都将被删除。
def remove_html(text):
html=re.compile(r'<.*?>')
return html.sub(r'',text)# remove all html tags from df
df['Text'] = df['Text'].apply(lambda x: remove_html(x))
6) **删除表情符号:**表情符号可以是与客户满意度相关的一些情绪的指示器。不幸的是，我们需要在我们的文本分析中删除表情符号，因为目前还不能用 NLP 分析表情符号。
# Reference : https://gist.github.com/slowkow/7a7f61f495e3dbb7e3d767f97bd7304bdef remove_emoji(text):
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F" # emoticons
u"\U0001F300-\U0001F5FF" # symbols & pictographs
u"\U0001F680-\U0001F6FF" # transport & map symbols
u"\U0001F1E0-\U0001F1FF" # flags
u"\U00002702-\U000027B0"
u"\U000024C2-\U0001F251"
"]+", flags=re.UNICODE)
return emoji_pattern.sub(r'', text)#Example
remove_emoji("Omg another Earthquake 😔😔")
# remove all emojis from df
df['Text'] = df['Text'].apply(lambda x: remove_emoji(x))
7) **移除表情符号:**表情符号和表情符号有什么区别？
:-)是表情符号
😜是一个→表情符号。
!pip install emot #This may be required for the Colab notebookfrom emot.emo_unicode import UNICODE_EMO, EMOTICONS# Function for removing emoticons
def remove_emoticons(text):
emoticon_pattern = re.compile(u'(' + u'|'.join(k for k in EMOTICONS) + u')')
return emoticon_pattern.sub(r'', text)#Example
remove_emoticons("Hello :-)")
df['Text'] = df['Text'].apply(lambda x: remove_emoticons(x))
8) **拼写纠正:**亚马逊评论上，拼写错误多如牛毛。产品评论有时充满了匆忙发送的评论，有时几乎无法辨认。
在这方面，拼写纠正是一个有用的预处理步骤，因为这也将有助于我们减少单词的多个副本。例如，“分析”和“分析”将被视为不同的词，即使它们在同一意义上使用。
from textblob import TextBlob
df['Text'][:5].apply(lambda x: str(TextBlob(x).correct()))
9.词条释义: 词条释义是将一个单词转换成其基本形式的过程。词汇化考虑上下文，将单词转换成有意义的基本形式。例如:
“关怀”->“词化”->“关怀”
Python NLTK 提供了 WordNet 词条整理器，它使用 WordNet 数据库来查找单词的词条。
import nltk
from nltk.stem import WordNetLemmatizer
# Init the Wordnet Lemmatizer
lemmatizer = WordNetLemmatizer()df['Text'] = df['Text'].apply(lambda x: lemmatizer(x))
关于词汇化的更详细的背景，可以查看 Datacamp 。
在这里，我将停止清理数据。但是，作为一名研究人员，您可能需要根据您的数据进行更多的文本清理。例如，您可能希望使用:
⚫对文本数据进行词干分析
⚫拼写纠正的替代方法*:孤立词纠正和上下文相关*纠正方法
⚫不同的包使用不同数量的停用词。你可以试试其他的 NLP 包。
特征提取-第二轮
一些特征将在文本清理后提取，因为它们在此步骤获得更有意义。例如，如果我们在数据清理之前提取这个特征，字符的数量会受到 URL 链接的严重影响。此时，我们必须尝试提取尽可能多的特征，因为额外的特征有机会在文本分析期间提供有用的信息。我们不必担心这些功能将来是否真的有用。在最坏的情况下，我们不使用它们。
- **字数:**此功能告知评论中有多少字
df['word_count'] = df['Text'].apply(lambda x: len(str(x).split(" ")))df[['Text','word_count']].head()
2.**字数:**评论中包含多少个字母。
df['char_count'] = df['Text'].str.len() ## this also includes spacesdf[['Text','char_count']].head()
3.**平均单词长度:**评论中单词的平均字母数。
def avg_word(sentence):
words = sentence.split()
return (sum(len(word) for word in words)/(len(words)+0.000001))df['avg_word'] = df['Text'].apply(lambda x: avg_word(x)).round(1)
df[['Text','avg_word']].head()
让我们检查提取的要素在数据框中的样子:
df.sample(5)
结论
这项研究解释了文本清洗的步骤。此外，本指南的独特之处在于，在文本清理之前和文本清理之后，通过两轮 : 来完成特征提取。我们需要记住，对于实际的研究来说，文本清理是一个递归过程。一旦我们发现异常，我们会回来通过解决异常进行更多的清理。
*特别感谢我的朋友塔比瑟·斯蒂克尔校对了这篇文章。
使用 Streamlit 制作交互式鸢尾花分类应用程序的初学者指南
使用 Streamlit 的虹膜分类应用程序
学习使用 Streamlit 制作互动、美观的机器学习应用程序:)
您将学到的内容:
- 关于 Streamlit 的简介
- 安装程序
- 使用 Streamlit 的基本示例
- 如何保存机器学习模型？
- 鸢尾花分类 app
- 分步代码讲解+视频演示:)
大家好:)
最近，我在当地社区参加了一个关于Streamlit的网络研讨会，我想，让我们制作一个关于它的教程，并与开源社区分享:)
作为一个初学者，我相信我们都希望尽快使用机器学习来制作很酷的东西！
Streamlit 的开发者为我们创造了一个非常简单的方法:)
在浪费时间之前，让我们开始吧。
照片由 Streamlit 拍摄
什么是 Streamlit？
Streamlit 是一个开源框架，用于创建一个交互式的、漂亮的可视化应用程序。全部用 python！
Streamlit 提供了许多有用的特性，对数据驱动项目的可视化非常有帮助。
为什么我应该使用 Streamlit？
- 创建交互式用户界面的简单易行的方法
- 不需要开发经验
- 在数据驱动的项目中使用不同的功能很有趣:)
- 全面的文档
使用 Streamlit 的 Face-GAN explorer
这个 Streamlit 应用程序使用关的 TL-GAN[6]演示了 NVIDIA 名人脸 GAN[5]模型。
安装程序
针对 Linux 的
你只需要在你的终端写下下面的命令来安装 Streamlit
pip install streamlit
仅此而已:)
对于 Windows
您可以找到 windows 的安装说明:
现在让我们探索 Streamlit
绘图内容
在下面几行代码中键入，并将其另存为。py 扩展
**import** **streamlit** **as** **st**
x = 4
st.write(x, 'squared is', x * x)
以下是使用 Streamlit 运行 python 脚本的方式:
打开一个终端，并确保你是在同一个工作目录下保存文件。
键入以下命令，然后按 enter 键:
streamlit run filename.py
输出:
这是您将在默认 web 浏览器中看到的内容
好了，现在让我们通过在代码中包含 slider 小部件来增加它的交互性:
x = st.slider('x') # 👈 this is a widget
#st.write(x, 'squared is', x * x)
输出:
在 Streamlit 中使用 Slider Widget
注意:每当你修改代码的时候，你就可以在你的项目中看到的快速变化。
好了，现在让我们回到我们的主要目标！
虹膜分类应用程序
问题陈述:根据鸢尾花的特征对其进行分类。
虹膜特征:萼片，花瓣，长度和宽度
这个分类问题也被称为监督机器学习的 Hello World ！
首先，让我们探索虹膜数据集:
from sklearn.datasets import load_irisiris= load_iris()# Store features matrix in X
X= iris.data#Store target vector in
y= iris.target
功能
# Names of features/columns in iris dataset
print(iris.feature_names)Output : ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
目标/虹膜种类
# Names of target/output in iris dataset
print(iris.target_names)Output : ['setosa' 'versicolor' 'virginica']
鸢尾花的种类
虹膜数据集的尺寸/大小
# size of feature matrix
print(iris.data.shape)Output: (150, 4)# size of target vector
print(iris.target.shape)Output : (150,)
因此，我们有 150 行/观察值和 4 列/特征。
下一步是研究机器学习算法:)
作为开始，我们将使用 K 最近邻。
KNN 就像是:
告诉我谁是你的朋友，我会告诉你你是什么人
照片由 CC BY-SA 3.0 授权的agor 153拍摄
以下是 KNN 的步骤:
给出新数据:
- 计算新数据和数据集中每个观察值/行之间的距离
- 获得与新数据最接近的 k 个观察值****
最近:最小距离的观测值(升序)
3.获取 k 个观察值的输出标签，并基于这些最具代表性/最流行的输出标签对个新数据进行分类
让我们使用 Scikit 学习库来应用 KNN 吧！
以下是使用 scikit learn 应用机器学习模型的 4 个基本步骤:
第一步:导入机器学习模型
#Import the classifier
from sklearn.neighbors import KNeighborsClassifier
****第二步:实例化模型
knn = KNeighborsClassifier()
****第三步:用数据拟合模型
knn.fit(X, y)Output : KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',metric_params=None, n_jobs=None, n_neighbors=5, p=2,weights='uniform')
在这里，我们可以看到 KNN 分类器中许多不同类型的参数，但我们将使用 n_neighbors:)
第四步:预测
#Predicting output of new data
knn.predict([[3.2, 5.4, 4.1, 2.5]])// Random valuesOutput : array([1]) # 1 -> versicolor (Iris flower specie)
让我们改变 K 值并探究结果
对于 K = 1
# instantiate the model
knn = KNeighborsClassifier(n_neighbors=1)# fit the model with dataknn.fit(X, y)# predict the response for new observationsknn.predict([[3, 5, 4, 2]])Output : array([2]) 2 -> virginica (Iris flower specie)
对于 K = 5
# instantiate the model
knn = KNeighborsClassifier(n_neighbors=5)# fit the model with dataknn.fit(X, y)# predict the response for new observationsknn.predict([[3, 5, 4, 2]])Output : array([1]) // 1 -> versicolor (Iris flower specie)
当 k = 1 时，KNN 预言了维吉尼亚和 k = 5 时，KNN 预言了云芝。****
这就产生了一个问题:
如何估计 我的模型 在样本外数据上的可能表现？
答案在于评估程序！
首先，我们将使用培训/测试分割评估方法:
训练/测试分割
- 将数据集分成两块****训练集和测试集****
- 在训练设备上安装/训练模型
- 在测试装置上测试模型
****注:思路是在训练集上训练/拟合模型，在没有训练模型的测试集上评估！
**# split X and y into training and testing sets
from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=4)**
使用 train_test_split 我们可以实现这一点，在这里您可以看到一些参数。
x:数据集/特征矩阵
y:鸢尾物种标签/输出向量
test_size:你想给测试集多少比例的数据集这里 0.4 表示 40%给测试集，可能 60%给训练集
random_state:这里传递一个固定的值意味着每当你多次运行代码时，它将把相同的数据索引分成训练集和测试集。
**# print the shapes of the new X objects
print(X_train.shape)
print(X_test.shape)Output :
(90, 4)
(60, 4)# print the shapes of the new y objects
print(y_train.shape)
print(y_test.shape)Output :
(90,)
(60,)**
我们得到了(60%)训练集的 90 个观察值和(40%)测试集的 40 个观察值。
如果你想知道我们为什么使用培训/测试分割，请查看下面的文章
**** [## 如何评价和改进 Knn 分类器第 3 部分
初学者指南，学习在 knn 分类器中评估和选择最佳参数
medium.com](https://medium.com/@jalalmansoori/how-to-evaluate-and-improve-knn-classifier-part-3-62d72fd17eec)
让我们开始使用训练/测试分割来查看模型性能。
对于 K=1
knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
print(metrics.accuracy_score(y_test, y_pred))Output:
0.95
对于 K=5
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
print(metrics.accuracy_score(y_test, y_pred))Output:
0.9666666666666667
因此，对于 k=1，我们得到(95%的测试精度)，对于 k=5，我们得到(大约 97%的测试精度)。
注: 检验精度最好是对样本外数据进行估计。
有趣的部分来了，我们能进一步提高测试精度吗？
如何选择 knn 分类器中的最佳参数？
如上所述，我们将使用 n _ neighbour 参数:)
我们来玩吧:
# try K=1 through K=30 and record testing accuracy
k_range = list(range(1, 31))
scores = []
for k in k_range:
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
scores.append(metrics.accuracy_score(y_test, y_pred))
在上面的代码中，我们实现了一种非常直观的方法，即为了提高测试精度，我们可以针对特定范围的 K 值运行 knn 分类器，并将测试精度结果存储在一个列表中，然后最终获得测试精度最高的 K 值。
下面是 matplotlib 库制作的可视化绘图
# import Matplotlib (scientific plotting library)
import matplotlib.pyplot as plt# allow plots to appear within the notebook
%matplotlib inline# plot the relationship between K and testing accuracy
plt.plot(k_range, scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Testing Accuracy')
K 值与测试精度的关系图
在这个图中，我们可以看到测试精度在(10–15)K 值之间相当好，所以让我们只选择 K=12 来完成 knn 分类器。
让我们完成并保存 Knn 分类器。
如何最终确定 Knn 分类器对新数据进行预测？
这就是机器学习大师的创始人杰森·布朗利所说的:
在进行预测之前，必须训练一个最终模型。
您可能已经使用 k-fold 交叉验证或数据的训练/测试拆分来训练模型。这样做是为了让您对模型在样本外数据(如新数据)上的技巧有一个估计。
这些模型已经达到了它们的目的，现在可以丢弃了。
现在，您必须根据所有可用数据训练最终模型。
如何保存机器学习模型？
from sklearn.datasets import load_irisiris= load_iris()# Store features matrix in X
X= iris.data#Store target vector in yy= iris.target# Finalizing KNN Classifier after evaluation and choosing best
# parameter#Importing KNN Classifier
from sklearn.neighbors import KNeighborsClassifier# instantiate the model with the best known parameters
knn = KNeighborsClassifier(n_neighbors=12)# train the model with X and y (not X_train and y_train)
knn_clf=knn.fit(X, y)# Saving knn_clfimport joblib# Save the model as a pickle in a file
joblib.dump(knn_clf, "Knn_Classifier.pkl")
因此，使用 joblib 我们保存了最终的训练模型，现在我们可以在我们的虹膜分类应用程序中使用它:)
使用 streamlit 的最终版本虹膜分类应用程序
这是我们要做的:
使用 Streamlit 的鸢尾花卉种类分类应用程序
第一步
import streamlit as st
import pandas as pd
import joblib
from PIL import Image#Loading Our final trained Knn model
model= open("Knn_Classifier.pkl", "rb")
knn_clf=joblib.load(model)st.title("Iris flower species Classification App")#Loading imagessetosa= Image.open('setosa.png')
versicolor= Image.open('versicolor.png')
virginica = Image.open('virginica.png')
在上面的代码中:
- 我们导入了一些有用的库
- 加载我们的 Knn 分类器和虹膜花图像
注意:你可以访问本教程中使用的所有代码和下面源代码标题下的 Iris 图片！
第二步
st.sidebar.title("Features")#Intializing
parameter_list=['Sepal length (cm)','Sepal Width (cm)','Petal length (cm)','Petal Width (cm)']
parameter_input_values=[]
parameter_default_values=['5.2','3.2','4.2','1.2']values=[]
在上面的代码中，我们用随机值初始化了鸢尾花的特征，如萼片、花瓣、长度等
显示特征
#Display
for parameter, parameter_df in zip(parameter_list, parameter_default_values):
values= st.sidebar.slider(label=parameter, key=parameter,value=float(parameter_df), min_value=0.0, max_value=8.0, step=0.1)
parameter_input_values.append(values)
input_variables=pd.DataFrame([parameter_input_values],columns=parameter_list,dtype=float)
st.write('\n\n')
在 streamlit slider 小部件中显示 Iris Flower 特征的代码
这里我们使用了 for 循环来高效地显示鸢尾花的特征！
第三步
if st.button("Click Here to Classify"):
prediction = knn_clf.predict(input_variables)st.image(setosa) if prediction == 0 else st.image(versicolor) if prediction == 1 else st.image(virginica)
如果满足 3 个条件中的任何一个，则显示图像
最后，与其写文字，不如展示一张鸢尾花物种的图片:)
最后，在您的终端中键入以下命令
streamlit run iris_app.py
恭喜你用 streamlit 制作了 hello world 的机器学习 app:)
视频演示
使用 streamlit 演示的虹膜分类应用程序
源代码:
你可以找到所有的代码+模型+虹膜图像在这里
非常感谢您抽出时间
学习、创造、分享和重复，不要忘记学习是有趣的！
结论
在本教程中，您使用 streamlit 制作了第一个机器学习应用程序。祝你未来的项目好运:)
接触
Gmail-> jalalmansoori19@gmail.com
github->https://github.com/jalalmansoori19
参考
- https://www.coursera.org/learn/machine-learning
- https://www.streamlit.io/
- 使用 scikit-learn 在 Python 中进行机器学习— YouTube
- https://github.com/justmarkham/scikit-learn-videos
- T.Karras、T. Aila、S. Laine 和 J. Lehtinen，为提高质量、稳定性和变化而逐步种植甘蔗 (2018)，ICLR。
- 南关，【使用新型 TL-GAN 模型控制图像合成和编辑】 (2018)，洞察数据科学博客。
图像分类初学者指南:VGG-19、Resnet 50 和带 TensorFlow 的 InceptionResnet
本文用迁移学习示例说明了一个图像分类任务，对 120 个狗品种的 20，000 多张照片进行了分类。
柯基和它的朋友。信用:阿尔万需要
我还记得我第一次听说深度学习以及听到这个术语时的激动，认为它是一个神秘的黑盒子和全能的模型。
对于初学者来说，图像分类是一项简单而又有意义的任务，可以帮助他们了解深度学习，并习惯它的符号和概念。在这个项目中，我选择使用迁移学习，这是深度学习领域中最简单的方法。
这个项目使用的代码可以在我的 GitHub 库中找到。
#数据
本项目使用的数据可在 Kaggle 获得，也可在斯坦福找到。你可以在提供的第二个链接中找到它的原始论文和基线结果。
所有 120 个品种的标签分布
该数据集由 120 种狗的 20 多万张照片组成。我们的目标类别是什么？它们在 120 个品种中分布均匀吗？左图显示，类别相当平衡，一些类别的图片略多，而大多数类别至少有 150 张照片。
我们还想看看数据集中的一些随机照片。
从数据集中随机选取狗的照片及其品种
我们观察到，尽管品种不同，有些狗有相似的特征。例如，第一排的梗看起来和我很像。我想知道这对于计算机来说是不是太难了。
#数据预处理
对于图像处理主题来说，数据预处理是一个很深的主题，但我们在这里不会深入探讨。该项目使用迁移学习模型的标准预处理，结合一些数据扩充，如旋转、水平翻转、放大等。
#转移学习
在深入研究项目所用的模型之前，我们想先谈谈迁移学习。简单地说，迁移学习就是利用他人预先训练好的模型来完成你的任务，它可以是不同的任务，但应该是相关的。文献已经证明，深度学习模型在一定程度上是可以移植的。
我探索了两种迁移学习的方法:简单地使用预训练的模型作为特征提取或重新训练(微调)模型的一部分。你们中的一些人可能会接触到第一种方法而没有意识到。比如在 NLP 任务中用 Word2Vec 做编码器，其实就是用迁移学习做特征提取的一种方式。通过保持模型的原始重量，可以容易且直接地应用它。相反，微调方法需要一些试错实验。如果任务非常不同，您可以考虑对模型进行至少 50%或更多的微调。如果您的任务非常相似，比方说最初模型用于对汽车进行分类，现在您希望对卡车进行分类，您可以考虑微调最后几层或原始模型的 30%。所需的微调量需要花费时间和精力，这取决于任务的性质。
对于计算机视觉任务，有许多已建立的模型，对于这个项目，我们用我们的例子回顾了其中的三个。
- VGG-19
VGG-19 是我们探索的第一个型号，也是我们审查的型号中最老的一个。VGG-19 是 VGG-16 的改进型。它是一个 19 层的卷积神经网络模型。它是通过将卷积堆叠在一起而构建的，但是由于一个称为梯度递减的问题，该模型的深度受到限制。这个问题使得深度卷积网络难以训练。该模型在 ImageNet 上进行训练，用于对 1000 种类型的对象进行分类，其余被审查的模型也是如此。
我们探索了 VGG-19 的特征提取和微调。我们得到的最好结果是简单地使用 VGG-19 作为特征提取。在我们情况下，微调和重新训练对 VGG-19 并不奏效。
- Resnet50
Resnet 模型是为解决梯度递减问题而提出的。其思想是跳过连接，将残差传递给下一层，这样模型就可以继续训练。有了 Resnet 模型，CNN 模型可以越来越深入。
Resnet 模型有许多变体，我们在这里选择 Resnet50 是因为它在 Kaggle 的教程中使用过，并且为我们所熟悉。通过 Resnet 50 获得的最佳结果是重新训练所有参数的近 40%。
- InceptionResnetV2
InceptionResnet 是对 Resnet 的进一步改进，结合了称为 Inception 的技术。点击此处阅读更多关于该车型的信息。
我还做了一个简单的例子来比较这三种不同的架构。彩色块代表模型的层。
视觉模型比较
人们会注意到，在这三个模型中，我们对其中的两个进行了微调和重新培训。当我们试图重新训练 30%的模型时，VGG-19 表现很差。原因可能是 VGG-19 作为深度学习网络相对“肤浅”。用少量数据输入一次重新训练太多参数会损害模型性能，因为模型没有足够的输入来学习。
#结果和讨论
我们的最佳模型实现的性能—验证数据
作为一个基准，你可以在这里阅读关于预训练的模特表演。左边的表格显示了我们的模型在看不见的数据上实现的性能。我们可以看到，模型可以保留基准性能。对于那些我们已经重新训练和微调的，它比基线表现得更好，这并不奇怪，因为我们的任务在本质上比原来的任务更简单(类别更少)。
我还想分享一些训练模型时的诊断图。
Resnet 损失 50
显示的损耗图来自 Resnet50 型号。我们观察到，在这里验证损失总是低于训练损失。它显示出惊人的概括预测的能力，这是迁移学习模型中一个非常独特的现象。这是由于模型中预先存储的知识。然而，这也表明该模型不能提高列车组的性能，因此很难进一步调整该模型。这是我开始考虑新模型而不是坚持 Resnet50 架构的地方。
来自 InceptionResnetV2 的损失
显示的第二个损失图使用来自我们的 InceptionResnet 模型的数据，在 20 个时期后进行训练。与培训损失相比，验证损失开始时较低。这是与上面的模型类似的行为。这里的验证损失相对稳定，培训损失继续下降。这表明我们在训练集中的改进倾向于过度拟合，不能推广到看不见的数据。为了进一步改进，我们可以探索在模型上添加更多的正则化。
真相:真实的品种；我的模型给出的三个预测
让我们来看看预测。我们的模型在第一次猜测时基本上是正确的，如果我们考虑前 2 个预测，它实际上是所有正确的分类。考虑到任务的难度，我认为这是相当不错的表现。
然而，当我们深入研究该模型造成的更多错误时，仍然有很大的改进空间，我们希望迅速讨论进一步改进的方法。
真相:真实的品种；我的模型给出的三个预测
作为分类模型，我们的模型缺乏辨别狗的大小的能力，例如，它是小型、中型还是大型狗。这是非常重要的，当试图了解狗的品种，因为有许多狗有相似的面部特征和体型，但只有大小不同。下图显示模型很难区分梗类。为了使我们的模型学习对象大小，人们可能想要实现对象识别模型，而不是简单的分类。
蓝黑还是白金？
最重要的是，该模型在正确识别颜色方面也存在问题。这就像一件蓝黑色的衣服在不同的环境光照下改变颜色的经典例子(如下所示)。因此，我们可能要考虑在预处理步骤中增加颜色失真增强，例如，随机化亮度、对比度、饱和度等。
最后，我们还观察到，模型与狗的细微差异，即不同的皮毛长度作斗争。模型可能需要更好的分辨率输入来更好地学习细节。如果我们能够获得更多的数据输入，这将有助于提高模型的性能。
#结尾
这是我们在 CNN 的第一个使用迁移学习的项目。接下来我会写关于使用 CNN 模型来预测图像掩蔽。
敬请关注，在家注意安全！😃
使用 Dash、Plotly 和 Bootstrap 构建多页面应用程序的初学者指南
我从一个完全初学者的角度，一步一步地介绍了使用新冠肺炎数据构建多页仪表板的过程。
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
当你因为你的国家处于部分封锁状态而整天被困在家里，并且你意识到你已经看不到节目和玩不到游戏的时候，你会做什么？没错，您从事的是像这样的热门项目，在这里您可以自学如何使用开源库构建仪表板。当然，我是开玩笑的，我很确定有很多事情比试图构建一个仪表板更有趣，也更少令人沮丧，但是如果你和我一样，这篇文章记录了我所学到的一切，希望可以作为任何想尝试使用 Python 构建仪表板的人的良好指南。
你可以在这里访问仪表板(只需给它大约 30 秒的加载时间)，所有用于构建仪表板的文件都可以在 GitHub 上找到。
该应用使用了两个数据集，全球页面使用来自欧盟开放数据门户的新冠肺炎数据，新加坡页面使用该数据集。我稍微清理了一下这两个数据集，最终的数据文件是上传到我的 GitHub 存储库中的。
3 周(老实说，我都不记得花了多长时间)的血汗钱和眼泪的最终结果。但是，哇，最终产品肯定是非常令人满意的。
只是让你了解一下我的背景，在此之前，我从未使用过 Dash 或 Plotly，也不了解 HTML 和 CSS。我有使用 Pandas 的经验，但除此之外，我认为很明显，在使用 Python 进行 web 开发方面，我还是个初学者。听起来很难，对吧？但是，还是接受了# challengeaccepted
Dash 到底是什么？
Dash 是一个开源库，它有助于使用 Python 构建交互式 web 应用程序。它包含 Plotly，可用于可视化数据。换句话说，不需要任何 JavaScript 知识，你所需要的只是 Python，这使得事情变得容易得多，也更加用户友好。顺便说一下， Dash 文档和用户指南是一个很好的学习起点。
你可以使用 Bootstrap 来设计你的 Dash 应用，这是一个用于 web 开发的开源 CSS 框架。这意味着您的应用程序可能非常美观，而不必经历从头构建 CSS 样式表的麻烦。
让我们从小处着手——构建一个单页应用程序
直接进入多页面应用程序的想法听起来很复杂，令人望而生畏，所以让我们从构建组件开始，并将它们放入单页面应用程序中。我将以该应用的新加坡页面为例。
1.安装集成开发环境(IDE)
我以前只在数据分析项目中使用 Python，在这些项目中我总是求助于 Jupyter Notebook。对于 web 开发，您需要安装一个 IDE(或者从终端运行所有东西，老实说这不是一个好主意),在那里您可以编写和运行您的脚本。我最终选择了 PyCharm ，并从这个视频中学会了如何设置。
这不是必须的，但是有人告诉我，为你的项目创建一个虚拟环境是一个好习惯，这样你就可以将所有的依赖项从主环境中分离出来。请注意，您必须在虚拟环境中安装所有需要的依赖项，即使您之前已经在主环境中安装了它们。
一般来说，你需要的包括:dash，plotly，pandas，dash-bootstrap-components(如果你使用 bootstrap 进行造型)。
2.了解仪表板特征
我想快速浏览一下 Dash 的三个特性。
布局
布局告诉 Dash 你希望你的页面是什么样子。我将使用我的新加坡页面代码中的一个例子来解释这些事情。
这是我的新加坡. py 文件，可以在应用程序文件夹中找到
这段代码表明我的页面结构如下。
第 1 行:文本行，“新加坡新冠肺炎一瞥”
第 2 行:文本行，“显示新加坡新冠肺炎疫情不同阶段的趋势”
第 3 行:另一行文本，“最新更新”
第 4 行:单选按钮，让用户在选项“压缩表”和“全表”之间进行选择
第 5 行:一个数据表
你在代码片段中看到的其他东西都是样式元素，比如字体、颜色和间距。最终产品看起来像这样:
这不太难吧？太好了，让我们进入下一个专题！
组件
组件是让你的应用程序具有交互性的东西。实际上，我在上一节提到过一个:单选按钮。我的单选按钮根据用户的偏好决定是显示精简的数据表(列数较少)还是完整的数据表(列数较多)。你可以在这里找到仪表板组件的完整列表。
回调
简单地说，回调赋予组件生命。回到单选按钮的例子，我必须编写一个回调函数，以便 Dash 知道是显示更少的列(精简表)还是更多的列(完整表)。
这个片段也来自我的 Singapore.py 文件，可以在 apps 文件夹中找到
这个回调更新两个输出:我的数据表的数据和列，这取决于来自用户选择的单选按钮的输入。
Dash 回调中一个更有趣的特性是，您可以在一个图形中使用 hoverData (鼠标悬停的数据点)作为另一个图形的输入。
这是来自应用程序的新加坡页面
在这种情况下，我使用鼠标悬停在新加坡的新冠肺炎病例作为下两个条形图的输入，这两个条形图显示了本地和输入病例的细分，以及它们是否是来自外籍工人宿舍的病例。
3.设计 Dash 应用程序
当涉及到 Dash 应用程序的样式时，有几个选项。你可以使用外部样式表，如这个或者点击 Bootstrap。使用 Bootstrap 的一个好处是，他们有一个内置的导航栏功能，你可以使用！或者，您也可以构建自己的样式表(或者修改一个外部样式表)。你所要做的就是创建一个名为“assets”的文件夹，并将你的 CSS 文件保存到该文件夹中。哦，是的，如果你打算在你的应用程序中包含图片，也把它们保存到资产文件夹中。
4.组装单页应用程序
有了它，我们就可以组装一个单页应用程序，并在本地运行它，以确保一切正常运行。请注意，这里的代码与您在 singapore.py 文件中看到的略有不同，因为这是针对单页应用程序的。新加坡. py 文件中注释掉了这些差异。
我想指出的是，出于某种原因，我必须在代码的最后一行插入 host='127.0.0.1 '，以便让代码运行。否则，我最终只会得到一条错误消息(我花了几个小时搜索解决方案，但最终没有找到一个对我有用的)。
升级到多页面应用程序
既然我们已经完成了构建单页应用程序的基础工作，我们可以开始研究多页应用程序了——毕竟，多页应用程序只是一个包含多个单页应用程序的应用程序，但是有一些额外的调整。我想包括的附加页面是应用程序的全球页面和主页。有两种方法来构建多页面应用，我将采用将每个页面保存为单独文件的方法。
下面提供了我的可以在本地运行的多页应用程序的结构概述。在下一部分，我将介绍如何部署多页面应用程序。
让我们现在浏览一些文件。
1.应用程序文件夹
这是一个文件夹，您可以在其中包含应用程序每个页面的单独文件。请注意，如果您之前将文件作为单页应用程序运行，您将需要进行一些更改，否则您将会遇到一系列错误。我已经注释掉了每个文件中需要更改的部分。
您还需要创建一个名为 init 的空文件。py 在这个文件夹里。
2.app.py 文件
app.py 文件应该如下所示:
3.index.py 文件
最重要的文件之一，因为这是链接所有单个页面的文件！我还在这个文件中为我的应用程序添加了一个导航栏，这样就可以很容易地在页面间导航。
请注意，上面的代码与我的存储库中的代码略有不同，因为此时我们仍在本地测试我们的应用程序。
在 Heroku 上部署多页面应用程序
现在，我们已经成功地构建了一个在本地运行良好的多页面应用程序，让我们尝试将其部署到网上，以便与他人共享！我会用 Heroku。
我很大程度上遵循了由 Dash 和这个视频提供的说明，但是做了一些改变，因为我之前已经为我的项目创建了一个文件夹和一个虚拟环境。这些是我采取的步骤，但是请注意，如果您之前没有为您的项目创建文件夹或虚拟环境，那么您的情况会有所不同。
1.创建一个 Heroku 帐户
前往 Heroku ，创建一个免费帐户，并确保通过点击他们将发送到您电子邮件的链接来激活您的帐户。
2.在 PyCharm 中打开您的项目，并单击 Terminal 选项卡
我们首先需要初始化一个空的 git 存储库，然后我们需要再安装一个依赖项 gunicorn，以便部署我们的应用程序。
3.添加一个. gitignore 文件、Procfile 和 requirements.txt 文件
的。gitignore 文件应该如下所示
Procfile 应该如下所示
注意，index 指的是文件 index.py，server 指的是该文件中的变量 server。这就引出了我的下一个观点，您必须在 index.py 文件中添加以下代码行，以便在 Heroku 上成功部署应用程序。
requirements.txt 文件给出了您的应用程序需要的依赖项列表。它可以使用下面的代码自动创建。
4.安装 Heroku 命令行界面
如果您使用的是 Mac，您可以通过在“终端”中键入以下内容来使用 Homebrew 安装它(但要确保之前已经安装了 home brew ): brew tap heroku/brew & & brew install heroku
如果没有，你可以越过这里的来安装它。
5.部署到 Heroku
你完了！您可以在https://dash-app.herokuapp.com查看您的应用，其中 dash-app 是您为应用选择的名称。
简单说明一下，如果你想在 Heroku 默认的 Python 3.6 上运行你的应用程序，你可以删除 runtime.txt 文件。
6.更新你的应用
只要在 PyCharm 终端(您打开项目的地方)中输入上述代码，就可以对您的应用程序进行任何更改，无论是更新数据还是更改应用程序中的功能。
这标志着我第一次尝试用 Dash 构建仪表板的结束，这绝对是一次让我学到很多东西的旅程。希望这篇文章对对此感兴趣但不知从何下手的人有所帮助。
免责声明:我没有任何网页开发的背景，所以非常欢迎所有的建议和评论！
建造新加坡式人工智能聊天机器人的初学者指南
人工智能文本生成是 NLP 中最令人兴奋的领域之一，但对初学者来说也是一个令人望而生畏的领域。这篇文章旨在通过将几个现有教程合并和改编为一个实用的端到端演练，并为一个可在交互式应用程序中使用的对话聊天机器人提供笔记本和样本数据，来加快新手的学习过程。
对于非新加坡人来说,“模糊如一个 sotong”这样的新加坡式英语短语可能会令人困惑。变形金刚模型能理解吗？照片:蔡展汉
自动文本生成无疑是近年来自然语言处理中最令人兴奋的领域之一。但由于对技术知识和资源的高要求，这也是一个对新来者来说相对困难的领域。
虽然市面上并不缺少有用的笔记本和教程，但是将各种线索整合在一起可能会很耗时。为了帮助新来者加快学习过程，我已经整合了一个简单的端到端项目来创建一个简单的人工智能对话聊天机器人，你可以在一个交互式应用程序中运行。
我选择围绕聊天机器人来构建文本生成项目，因为我们对对话的反应更直观，并且可以很容易地判断自动生成的文本是否有任何好处。聊天机器人也无处不在，我们大多数人都可以很好地了解预期的基线性能，而不必咨询手册或专家。如果是坏的，你会马上知道，而不必检查分数或指标。
项目中的工作流是根据初学者的实际问题构建的:如何开始数据提取和准备，需要什么来微调预训练的 transformer 模型，以及如何在应用程序中测试/使用机器人。
正如下面一个测试运行的截图所示，最终产品并不是人们所说的“完美的”。但是作为第一个实验，结果已经足够好了(在我看来),凸显了通过迁移学习生成人工智能文本的可能性和局限性。
新加坡式聊天机器人在 Colab 上的测试截图。
数据、回购和要求
如果上面的对话样本让你感到困惑，那么，你可能没有去过新加坡，或者听说过“新加坡式英语”，或者新加坡口语。这是几种语言和当地俚语的大杂烩，可能会让非新加坡人感到困惑。换句话说，这是测试 DialoGPT 模型局限性的一个不错的方法。
用于微调模型的数据来自当地一所大学的新加坡学生收集的短信。虽然“新加坡式英语”的书面和口头形式可能有很大的不同，但出于实际原因，我们将把它放在一边。
在我的 repo 中有数据集(用于训练的原始版本和干净版本)和四个相关的笔记本。笔记本根据以下任务进行拆分:
- 笔记本 3.0 :数据准备
- 笔记本 3.1 :在 Colab (Pro)上微调预训练的 DialoGPT-medium 模型
- 笔记本 3.2 :在交互式 Dash 应用上测试模型性能
- 笔记本 3.3 :使用 aitextgen 生成文本的 CPU 替代方案
就资源需求而言，如果你对 DialoGPT-small 模型而不是更大的版本进行微调，你可以在免费的 Google/Colab 帐户上运行这个项目。如果您使用更健壮的数据集，也许微调 DialoGPT-small 模型就足够了。
但我发现，我对较小型号进行微调的结果并不理想，而且为了避免突破免费谷歌账户的 15Gb 存储限制而不断进行的内务处理是对生产力的一种消耗。
如果你预见到自己将来会尝试更多/更大的变形金刚模型，我会推荐你升级到 Colab Pro，并增加你的谷歌账户的存储空间。这让我可以快速迭代，而不必在家里设置物理 eGPU。
为了简洁起见，我不会在这篇文章中讨论技术细节。我仍在边走边学，关于这个话题的的文章要好得多。大部分代码都是从以前作者的作品中摘录或改编的，它们在笔记本中也得到承认。
步骤 1:数据准备
该项目的第一个也是最大的问题是，你是否能为你的用例找到一个合适的数据集。用例越具体(比如说，一个特雷弗·诺亚聊天机器人)，就越难找到合适的训练数据。从一开始就应该考虑伦理问题:即使你可以接触到文字记录，用真人来模拟聊天机器人合适吗？潜在的误用可能性有多大？
这个项目中使用的匿名短信数据集是公共空间中为数不多的“新加坡式”语料库之一，也是我发现的唯一一个足够大的数据集。 notebook3.0 的前半部分包含了从深度嵌套的 json 文件中提取 SMS 所需的步骤。如果您使用不同的数据集，请跳过此步骤。
第二部分讨论了在 DialoGPT 模型中必须准备好的训练和验证数据集的具体方法。基本上，对于每条短信，你必须创建 x 条以前的短信作为“上下文”:
点击这里查看另一个例子如何在构建 Rick Sanchez 机器人时准备数据。
我选择了之前的七个回答，但你可以上下调整，看看这对聊天机器人的性能有没有影响。如果这对你来说不仅仅是一个实验，我怀疑这是你将花费大量时间调整数据集以清理响应/上下文的地方。不幸的是，我还没有遇到一个好的教程，告诉我如何最好地构造或调整定制数据集来微调 DialoGPT 模型。
将响应上下文数据集分成训练集和验证集之后，就可以进行微调了。
步骤 2:微调对话框
微调过程中涉及到大量的代码，但由于像内森·库珀和 T2 这样的人的早期工作，训练循环可以原样使用，而新用户不必进行重大更改。当你有更多的时间时，你可以更详细地研究这些代码。记事本 3.1 中需要注意的关键单元格如下:
这是您需要根据您的数据集和设置进行更改的地方。例如，您可以坚持使用中型 DialoGPT 型号或向下调节至小型型号。
如果您遇到 GPU 内存不足的问题，您将不得不减少批量大小(正如我在上面的单元格中所做的那样，减少到 1)。如果你的 Google Drive 中没有太多剩余的存储空间，你必须相应地调整 logging_steps 和 save_steps 的间隔(在各个检查点保存的文件可能会在一瞬间吃掉存储空间)。
微调过程可能需要 40 分钟到大约 2 小时，具体取决于您设置的参数。请注意，即使在 Colab Pro 上也有使用限制。例如，由于 GPU 内存限制，我无法微调 DialoGPT-large 模型。Colab Pro 笔记本电脑可以运行长达 24 小时，但我还没有用更多的时间来测试。
在微调过程结束时需要注意的一个指标是困惑分数——衡量模型在选择下一个令牌时有多确定。分数越低越好，因为这意味着模型的不确定性越小。
通过微调 DialoGPT-medium 模型，我得到了 1.6134 的困惑分数，与使用 DialoGPT-small 模型时 6.3 到 5.7 的分数相比，这是一个显著的改进。你要跑几次才能算出可接受的分数。
你可以在笔记本的末端开始与机器人聊天(假设一切运行正常)，但我更喜欢将微调后的模型加载到应用程序中。感谢陆星汉 @ 剧情，为此有了一个笔记本。
第三步:在 DASH 应用程序中测试你微调过的模型
Plotly repo 包含在本地机器上运行聊天机器人应用程序的代码，如果你希望这样做的话，但出于实际原因，我选择在 Colab 上运行 notebook3.2 (微调模型已经存在)。该代码直接从陆星汉的演示中摘录，对于那些可能想进一步试验机器人输出的人，在结尾做了一些小的改动:
“温度”允许你控制回应的创造性(或疯狂/厚颜无耻)程度。您可以通过降低 max_length(最大令牌数:1，024；默认值:256 个令牌)。您可以在这里的“使用交互脚本”一节中找到一个完整的参数列表。
这是我和聊天机器人成功对话的截图。突出显示的单元格是我的条目:
微调过的 pytorch 模型太大了(1.44Gb)，无法部署在任何免费的主机帐户上，所以(目前)你没有办法在 web 应用程序上尝试这个特殊的新加坡式聊天机器人。
我的观点是:“新加坡式”聊天机器人还没有准备好进入黄金时段。它有时会给出令人惊讶的好的回应，但在几次交流之后就无法继续努力了。正如你在上面的截图中所看到的，事情在接近尾声时变得不稳定。有了更丰富的数据集和足够的计算来训练一个 DialoGPT-large 模型，响应可能会变得更好。
但是作为一个实验，我不得不说性能一点也不差。
额外的一步:CPU 替代自动文本生成
如果您不想使用 Colab 和/或将数据和微调限制在本地机器上，那么有很多替代方法。我将重点介绍我一直在试验的一个 Python 库——aitextgen——它为纯 CPU 训练提供了一个选项。
笔记本 3.3 概述了一个在本项目中使用相同 SMS 数据集的简单示例。我之前曾尝试用 aitextgen 处理其他数据集，包括新加坡政治演讲的 YouTube 文本。不幸的是，到目前为止我还没有得到非常满意的结果。
我可能没用对。你可能会有更好的运气。一个 itextgen 也可以在 Colab 上运行。
希望这篇文章和附带的笔记本能帮助你快速开始你自己的人工智能聊天机器人实验。更难的是弄清楚如何提高它的性能，或者确保它对公众使用是安全的。
还有一些相关的技术问题需要探索，例如为部署而精简模型，或者更高级的交互式应用设计，可以在聊天机器人中带来更多功能。如果你对以上话题有什么建议，或者发现了这篇文章中的错误，请联系我:
推特:蔡钦汉
领英:www.linkedin.com/in/chuachinhon
使用 Python 中的 Keras 构建人工神经网络的初学者指南
初学者的深度学习
创建网络架构、训练、验证和保存模型并使用它进行推理的提示和技巧。
图片由 Gerd Altmann 从 Pixabay 拍摄
为什么是 Keras，而不是 Tensorflow？
如果你在问“我应该用 keras 还是 tensorflow？”，你问错问题了。
当我第一次开始我的深度学习之旅时，我一直认为这两者是完全独立的实体。好吧，截至2017 年年中，他们不是！ Keras，一个神经网络 API，现在已经完全集成在 TensorFlow 中。那是什么意思？
这意味着您可以在使用高级 Keras API 或低级 TensorFlow API 之间进行选择。高级-API在一个命令中提供更多的功能，并且更易于使用(与低级 API 相比)，这使得它们甚至对于非技术人员也是可用的。低级 API允许高级程序员在非常精细的级别上操作模块内的功能，从而允许为新颖的解决方案定制实现。
注意:出于本教程的目的，我们将只使用 Keras！
让我们直接进入编码
我们首先在机器上安装 Keras。正如我之前所说，Keras 集成在 TensorFlow 中，因此您所要做的就是在您的终端(Mac OS)中pip install tensorflow访问 Jupyter 笔记本中的 Keras。
资料组
我们将使用贷款申请数据集。它有两个预测特征，一个连续变量- age和一个分类变量- area(农村与城市)，以及一个二元结果变量application_outcome，可以取值 0(批准)或 1(拒绝)。
import pandas as pddf = pd.read_csv('loan.csv')[['age', 'area', 'application_outcome']]
df.head()
我们数据集中的样本。
预处理数据
为了避免过度拟合，我们将使用MinMaxScaler在 0 和 1 之间缩放age，并使用Sklearn工具包中的LabelEncoder对area和application_outcome特征进行标签编码。我们这样做是为了将所有输入要素放在同一个比例上。
from sklearn.preprocessing import LabelEncoder, MinMaxScaler
from itertools import chain# Sacling the Age column
scaler = MinMaxScaler(feature_range = (0,1))a = scaler.fit_transform(df.age.values.reshape(-1, 1))
x1 = list(chain(*a))# Encoding the Area, Application Outcome columns
le = LabelEncoder()x2 = le.fit_transform(df.area.values)
y = le.fit_transform(df.application_outcome) # Updating the df
df.age = x1
df.area = x2
df.application_outcome = ydf.head()
来自我们的缩放的数据集的样本
如果您阅读了 Keras 文档，它要求输入数据是 NumPy 数组类型。这就是我们现在要做的！
scaled_train_samples = df[['age', 'area']].values
train_labels = df.application_outcome.valuestype(scaled_train_samples) *# numpy.ndarray*
生成模型架构
建立 Keras 模型有两种方式:顺序(最基本的一种)和泛函(复杂网络用)。
我们将创建一个序列模型，它是一个线性层叠。也就是说，顺序 API 允许你逐层创建模型。在大多数情况下，它非常适合开发深度学习模型。
# Model architecturemodel_m = Sequential([
Dense(units = 8, input_shape= (2,), activation = 'relu'),
Dense(units = 16, activation = 'relu'),
Dense(units = 2, activation = 'softmax')
])
在这里，第一密集层实际上是第二层整体(因为实际的第一层将是我们从原始数据中输入的层)但是第一“隐藏”层。它有 8 个单元/神经元/节点，8 个是任意选择的！
input_shape参数是您必须根据您的数据集分配的。直观地说，就是网络应该期望的输入数据的形状。我喜欢把它想成— “我正在馈入神经网络的一个 单个 行数据是什么形状？”。
在我们的例子中，输入的一行看起来像[0.914, 0]。即它是一维的。因此，input_shape参数看起来像一个元组(2，)，其中 2 指的是数据集中的要素数量(age和area)。因此，输入层需要一个包含 2 个输入元素的一维数组。它将产生 8 个输出作为回报。
如果我们正在处理，比如说黑白 2×3 像素图像(我们将在下一篇关于卷积神经网络的教程中研究，我们将会看到输入的一行(或向量表示单个图像)看起来像[[0 , 1, 0] , [0 , 0, 1]，其中 0 表示像素是亮的，1 表示像素是暗的。即，它是二维的。随后，input_shape参数将等于(2，3)。
注意:在我们的例子中，我们的输入形状只有一个维度，所以您不一定需要以元组的形式给出它。相反，你可以给 *input_dim* 作为标量数。因此，在我们的模型中，我们的输入层有两个元素，我们可以使用这两个中的任何一个:
*input_shape=(2,)*-当你只有一个维度时，逗号是必要的*input_dim = 2*
围绕输入形状参数的一个普遍误解是，它必须包括我们输入到神经网络的输入样本总数(在我们的例子中是 10，000)。
训练数据中的行数是网络输入形状的而不是部分，因为训练过程每批向网络提供一个样本(或者更准确地说，每批的 batch_size 样本)。
第二个“隐藏”层是另一个密集层，具有与第一个隐藏层相同的激活功能，即“relu”。激活函数确保传递的值位于可调的预期范围内。整流线性单元(或 relu)功能返回直接作为输入提供的值，如果输入为 0.0 或更小，则返回值 0.0。
你可能想知道为什么我们没有为这个层指定input_shape参数。毕竟，Keras 需要知道它们输入的形状，以便能够创建它们的权重。事实是，
无需为第二(或后续)隐藏层指定
input_shape参数，因为它会根据架构(即每层的单元和特性)自动计算输入节点的最佳数量。
最后，我们的顺序模型中的第三个或最后一个隐藏层是另一个具有 softmax 激活功能的密集层。softmax 函数返回两个类的输出概率— approved(输出= 0)和rejected(输出= 1)。
模型摘要如下所示:
model_m.summary()
我们的顺序模型的总结
让我们看看如何计算每一层的参数总数，即Param #。请记住，在每一层中，我们还有一个偏置神经元(除了在模型架构中预先指定的神经元之外)。因此，在第一个隐藏层中，我们有 3 个输入神经元(2 个来自输入数据特征的神经元+ 1 个偏置神经元)和 8 个输出神经元。因此，总共需要训练 83 = 24 个参数。类似地，在第二隐藏层中，我们现在有 9 个输入神经元(8 个来自第一隐藏层加上 1 个偏置神经元)和 16 个输出神经元，总共 169 = 144 个可训练参数。最后，最后一层将具有 17*2=34 个可训练参数。
为培训准备模型
model_m.compile(optimizer= Adam(learning_rate = 0.0001),
loss = 'sparse_categorical_crossentropy',
metrics = ['accuracy']
)
在我们开始用实际数据训练我们的模型之前，我们必须用某些参数compile模型。在这里，我们将使用亚当optimizer。
优化器的可用选择包括 SGD、Adadelta、Adagrad 等。
loss参数指定应该在每次迭代中监控交叉熵损失。metrics参数表示我们希望根据精确度来判断我们的模型。
训练和验证模型
# training the model
model_m.fit(x = scaled_train_samples_mult,
y = train_labels,
batch_size= 10,
epochs = 30,
validation_split= 0.1,
shuffle = True,
verbose = 2
)
x和y参数非常直观——分别是预测变量和结果变量的 NumPy 数组。batch_size指定一个批次中包含多少个样本。epochs=30表示模型将在所有数据上训练 30 次。verbose = 2表示它被设置为输出消息中最详细的级别。
我们正在使用 0.1 validation_split动态创建一个验证集，即在每个时期保留 10%的训练数据，并将其排除在训练之外。这有助于检查我们模型的可推广性，因为通过获取训练集的子集，模型仅在训练数据上学习而在验证数据上进行测试。
请记住，验证拆分发生在训练集被打乱之前，即在验证集被取出后，只有训练集被打乱。如果在数据集的末尾有所有被拒绝的贷款申请，这可能意味着您的验证集有对类的错误描述。所以你必须自己洗牌，而不是依靠 keras 来帮你！
这是前五个纪元的样子:
这是最后五个纪元的样子:
如您所见，在第一个时期，我们从验证集的高损失(0.66)和低准确度(0.57)开始。渐渐地，我们能够减少损失(0.24)并提高最后一个时期验证集的准确性(0.93)。
对测试集进行推理
我们以类似于训练集的方式对之前未见过的测试集进行预处理，并将其保存在scaled_test_samples中。相应的标签存储在test_labels中。
predictions = model.predict(x = scaled_test_samples,
batch_size= 10,
verbose=0)
确保选择与培训过程中使用的
batch_size完全相同的产品。
由于我们的最后一个隐藏层有一个 softmax 激活函数，predictions包括两个类的输出概率(左边是类 0 的概率(即批准的)，右边是类 1 的概率(即拒绝的)。
当最终层具有 softmax 激活时，来自 ANN 的预测。
从这里开始有几种方法。您可以选择一个任意的阈值，比如 0.7，并且只有当类别 0(即批准)的概率超过 0.7 时，您才应该选择批准贷款申请。或者，您可以选择概率最高的类作为最终预测。例如，根据上面的截图，该模型预测贷款将有 2%的概率被批准，但有 97%的概率被拒绝。因此，最后的推论应该是，此人的贷款被拒绝。我们将采取后者。
# get index of the prediction with the highest probrounded_pred = np.argmax(predictions, axis = 1)
rounded_pred
为测试集所做的预测
保存和加载 Keras 模型
为了保存 来自已训练模型的所有内容:
model.save('models/LoanOutcome_model.h7')
我们基本上保存了我们训练模型
1 的所有内容。架构(神经元的层数等)
2。学习的重量
3。训练配置(optimizers，loss)
4。优化器的状态(便于重新训练)
要加载我们刚刚保存的模型:
from tensorflow.keras.models import load_model
new_model = load_model('models/LoanOutcome_model.h7')
为了只保存 的架构:
json_string = model.to_json()
从先前存储的架构中重建新模型:
from tensorflow.keras.models import model_from_json
model_architecture = model_from_json(json_string)
只保存重量:
model.save_weights('weights/LoanOutcome_weights.h7')
要将权重用于其他模型架构:
model2 = Sequential([
Dense(units=16, input_shape=(1,), activation='relu'),
Dense(units=32, activation='relu'),
Dense(units=2, activation='softmax')
])# retrieving the saved weights
model2.load_weights('weights/LoanOutcome_weights.h7')
现在我们有了。我们已经成功地建立了我们的第一个人工神经网络，并对其进行了训练、验证和测试，还成功地将其保存下来以备将来使用。在下一篇文章的中，我们将通过卷积神经网络(CNN)来处理图像分类任务。
在那之前:)
[## 使用 TensorFlow 的 Keras API 在 Python 中构建卷积神经网络的初学者指南
解释具有 MaxPool2D、Conv2D 和 Dense 图层的端到端二值图像分类模型。
towardsdatascience.com](/beginners-guide-to-building-convolutional-neural-networks-using-tensorflow-s-keras-api-in-python-6e8035e28238) [## 在数据科学面试中解释你的 ML 项目的逐步指南。
在结尾有一个额外的样本脚本，让你谨慎地展示你的技术技能！
towardsdatascience.com](/step-by-step-guide-to-explaining-your-ml-project-during-a-data-science-interview-81dfaaa408bf) [## 使用 FLASK 将 H2o 模型部署为 API
模型训练、调优和创建简单 API 的端到端示例(没有技术术语)。
towardsdatascience.com](/deploying-h2o-models-as-apis-using-flask-42065a4fa567) [## 使用 Python 中的 Pandas 进行时间序列分析
对季节性、趋势、自相关等关键词的额外介绍。
towardsdatascience.com](/time-series-analysis-using-pandas-in-python-f726d87a97d8)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
