TowardsDataScience-博客中文翻译-2020-六十三-
TowardsDataScience 博客中文翻译 2020（六十三）
如何在你的 Python Dash 应用中嵌入引导 CSS & JS
使用 Dash Bootstrap 组件构建新冠肺炎感染预测应用程序
摘要
在本文中，我将展示如何使用 Python 、 Dash 和 Bootstrap 构建一个预测新冠肺炎病毒在任何受感染国家传播的 web 应用程序，如下所示:
让我从这个开始:编写 Dash 应用程序很麻烦…我没有任何恶意，我喜欢 Dash，我认为它是 Python web 开发的未来。 Dash 是一个用于构建 web 应用的 Python(和 R)框架。它建立在 Flask、Plotly.js 和 React js 之上。它是开源的，它的应用程序运行在网络浏览器上。如果你更擅长 Python 而不是 Javascript，Dash 会非常方便，因为它允许你使用纯 Python 来构建仪表盘。
不知道大家有没有见过 dash 的应用代码。这是一个烂摊子:代码出来真的很长，因为你需要编写每个 html Div 的内容和属性，就像一个 html 页面之前，引导发明。Bootstrap是一个开源的工具包，用于开发 HTML、CSS 和 JS。它是 web 开发中使用最多的库，这要归功于它广泛的预构建组件和基于 jQuery 构建的强大插件。
我喜欢 Boostrap，不仅因为它的输出总是非常好看，而且特别是因为它为您节省了一行又一行的 HTML、CSS 和 JS 代码。如果我告诉你它也可以用于 Dash 应用呢？你喜欢这种声音，不是吗？
通过本教程，我将一步一步地解释如何将 Bootstrap 轻松集成到 Dash 中，以及如何使用我的新冠肺炎感染预测应用程序为例构建和部署 web 应用程序、(链接如下，加载可能需要 30 秒)。
**[## 病毒预报员
编辑描述
app-virus-forecaster.herokuapp.com](https://app-virus-forecaster.herokuapp.com/)**
我将展示一些有用的 Python 代码，这些代码可以很容易地用于其他类似的情况(只需复制、粘贴、运行)，并通过注释遍历每一行代码，这样您就可以很容易地复制这个示例(下面是完整代码的链接)。
** [## GitHub-mdipietro 09/App _ 病毒预报员:新冠肺炎预报员网络应用
新冠肺炎预报员网络应用。通过在…上创建帐户，为 mdipietro 09/App _ virus forecaster 开发做出贡献
github.com](https://github.com/mdipietro09/App_VirusForecaster)
我将使用这几天隔离中最流行的数据集: CSSE 新冠肺炎数据集。它显示了自疫情开始以来，每个国家每天报告的确诊传染病病例数的时间序列。这个数据集可以在约翰霍普金斯大学的 GitHub 上免费获得(链接如下)。
这是由约翰·霍普金斯大学运营的 2019 年新型冠状病毒视觉仪表板的数据存储库…
github.com](https://github.com/CSSEGISandData/COVID-19)
特别是，我将经历:
- 环境的设置
- 后端:编写模型来获取、处理和绘制数据
- 前端:用 Dash 和 Bootstrap 构建应用程序
- 部署应用程序
设置
首先，我将通过终端安装以下库:
pip install **dash**pip install **dash-bootstrap-components**pip install **pandas**
安装 dash 的命令还会下载有用的包，比如 dash-core-components 、 dash-html-components 和 plotly 。类似地，pandas 安装包括 numpy 和 scipy ，我稍后也会用到它们。我假设你已经知道了这些，因此我将花点时间来介绍一下 Dash Bootstrap 组件 :基本上，这就是将 Bootstrap 集成到 Dash 中的诀窍，它使构建具有复杂和响应性布局的风格一致的应用程序变得更加容易。我是这个库的粉丝，因为它保存了大量的 dash 代码行，稍后您会看到。
安装完所有需要的东西后，我建议在终端上运行以下命令，将需求保存在适当的文本文件中:
pip freeze > **requirements.txt**
关于文件夹结构，我将 4 个基本元素放在了根级别:
- 应用程序文件夹:dash.py 文件中所有 dash 代码所在的位置
- python 文件夹:我放置模型逻辑的地方
- 设置文件夹:其中有所有的配置
- run.py 文件:如果在终端上用下面的命令执行，它将运行全部内容
python **run.py**
到目前为止，这些都是我让应用程序工作所需的，然而，还有一些其他有用但不必要的东西，我添加了静态图像(在应用程序文件夹中)、注释(在设置文件夹中)、Procfile 和部署中使用的 requirements.txt(在根级别)。
总而言之，应用程序应具有以下结构:
现在一切都设置好了，我将浏览每个 python 文件并展示其中的代码。我们开始吧，好吗？
后端:获取数据、流程、绘图
首先，我将编写获取新冠肺炎感染数据的类，然后我将建立从过去的观察中学习的模型，并预测时间序列的未来趋势。
在 data.py (在 python 文件夹内)中，我将使用一个在应用程序启动时执行的方法来定义“data”类，这意味着每次加载应用程序运行的浏览器页面时，后端都会直接从数据源获取新数据(下面代码中的 get_data 函数)。保存国家列表很重要，因为它将在仪表板上显示给用户，供他们选择特定的国家。数据类的任务还包括接收来自前端的输入、用户选择的国家、过滤和处理数据(下面代码中的 process_data 函数)。在过滤特定国家之前，我会创建一个名为“世界”的聚合时间序列，这将是应用程序启动时默认选择的国家。
用 python 的术语来说，data.py 文件如下所示:
import **pandas** as pd class **Data()**:
def **get_data**(self):
self.dtf_cases = pd.read_csv("[**https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv**](https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv)", sep=",")
self.countrylist = ["World"] + self.dtf_cases["Country/Region"].unique().tolist()
@staticmethoddef **group_by_country**(dtf, country):
dtf = dtf.drop(['Province/State','Lat','Long'], axis=1).groupby("Country/Region").sum().T
dtf["World"] = dtf.sum(axis=1)
dtf = dtf[country]
dtf.index = pd.to_datetime(dtf.index, infer_datetime_format=True)
ts = pd.DataFrame(index=dtf.index, data=dtf.values, columns=["data"])
return ts
def **process_data**(self, **country**):
self.dtf = self.**group_by_country**(self.dtf_cases, **country**)
现在，我将构建模型来拟合数据和预测。本文的目的不是挖掘什么是最适合该数据集的模型，因此我将保持简单:我将使用参数曲线拟合方法，为每个国家的时间序列优化逻辑函数的参数。如果你对这个基本的建模方法感兴趣，你可以在这里 找到它的解释 。
在Model . py(python 文件夹内)中，我将使用一个方法(下面代码中的 forecast 函数)定义“模型”类，该方法将在应用程序启动时以及每次从前端选择特定国家时在世界时间序列上执行。这个班的任务是在选定的国家数据上拟合最佳的逻辑函数(用 scipy ),并产生一个 pandas 数据框架:
- 实际数据和拟合的逻辑模型，将用于绘制总病例
- 实际数据和拟合逻辑模型(delta t = y t — y t-1)的每日变化，用于绘制活动案例。
举例来说，model.py 文件包含以下代码:
import **pandas** as pd
import **numpy** as np
from **scipy** import optimize class **Model()**:
def **__init__**(self, dtf):
self.dtf = dtf
@staticmethod
def **f**(X, c, k, m):
y = c / (1 + np.exp(-k*(X-m)))
return y
@staticmethod
def **fit_parametric**(X, y, f, p0):
model, cov = optimize.curve_fit(f, X, y, maxfev=10000, p0=p0)
return model
@staticmethod
def **forecast_parametric**(model, f, X):
preds = f(X, model[0], model[1], model[2])
return preds
@staticmethod
def **generate_indexdate**(start):
index = pd.date_range(start=start, periods=30, freq="D")
index = index[1:]
return index
@staticmethod
def **add_diff**(dtf):
**## create delta columns**
dtf["delta_data"] = dtf["data"] - dtf["data"].shift(1)
dtf["delta_forecast"] = dtf["forecast"] - dtf["forecast"].shift(1)
**## fill Nas**
dtf["delta_data"] = dtf["delta_data"].fillna(method='bfill')
dtf["delta_forecast"] = dtf["delta_forecast"].fillna(method='bfill')
**## interpolate outlier**
idx = dtf[pd.isnull(dtf["data"])]["delta_forecast"].index[0]
posx = dtf.index.tolist().index(idx)
posx_a = posx - 1
posx_b = posx + 1
dtf["delta_forecast"].iloc[posx] = (dtf["delta_forecast"].iloc[posx_a] + dtf["delta_forecast"].iloc[posx_b])/2
return dtf def **forecast**(self):
**## fit**
y = self.dtf["data"].values
t = np.arange(len(y))
model = self.fit_parametric(t, y, self.f, p0=[np.max(y),1,1])
fitted = self.f(t, model[0], model[1], model[2])
self.dtf["forecast"] = fitted
**## forecast**
t_ahead = np.arange(len(y)+1, len(y)+30)
forecast = self.forecast_parametric(model, self.f, t_ahead)
**## create dtf**
self.today = self.dtf.index[-1]
idxdates = self.generate_indexdate(start=self.today)
preds = pd.DataFrame(data=forecast, index=idxdates, columns=["forecast"])
self.dtf = self.dtf.append(preds)
**## add diff**
self.dtf = self.add_diff(self.dtf)
是时候制作一些很酷的情节了，这项工作的最佳工具是 Plotly，因为 Dash 是在它的基础上构建的。我将在result . py(python 文件夹内)中放入一个类，这个类将负责处理这个问题
- 绘制总例数时间序列及其预测的方法(下面代码中的 plot_total 函数):
- 绘制活动案例时间序列及其预测的方法(下面代码中的 plot_active 函数):
- 该方法检索一些统计数据显示在前端上(下面代码中的 get_panel 函数):
以下是 result.py 中的完整代码:
import **pandas** as pd
import **plotly**.graph_objects as goclass **Result()**:
def **__init__**(self, dtf):
self.dtf = dtf
@staticmethod
def **calculate_peak**(dtf):
data_max = dtf["delta_data"].max()
forecast_max = dtf["delta_forecast"].max()
if data_max >= forecast_max:
peak_day = dtf[dtf["delta_data"]==data_max].index[0]
return peak_day, data_max
else:
peak_day = dtf[dtf["delta_forecast"]==forecast_max].index[0]
return peak_day, forecast_max
@staticmethod
def **calculate_max**(dtf):
total_cases_until_today = dtf["data"].max()
total_cases_in_30days = dtf["forecast"].max()
active_cases_today = dtf["delta_data"].max()
active_cases_in_30days = dtf["delta_forecast"].max()
return total_cases_until_today, total_cases_in_30days, active_cases_today, active_cases_in_30days
def **plot_total**(self, today):
**## main plots**
fig = go.Figure()
fig.add_trace(go.Scatter(x=self.dtf.index, y=self.dtf["data"], mode='markers', name='data', line={"color":"black"}))
fig.add_trace(go.Scatter(x=self.dtf.index, y=self.dtf["forecast"], mode='none', name='forecast', fill='tozeroy'))
**## add slider**
fig.update_xaxes(rangeslider_visible=True)
**## set background color**
fig.update_layout(plot_bgcolor='white', autosize=False, width=1000, height=550)
**## add vline**
fig.add_shape({"x0":today, "x1":today, "y0":0, "y1":self.dtf["forecast"].max(),
"type":"line", "line":{"width":2,"dash":"dot"} })
fig.add_trace(go.Scatter(x=[today], y=[self.dtf["forecast"].max()], text=["today"], mode="text", line={"color":"green"}, showlegend=False))
return fig
def **plot_active**(self, today):
**## main plots**
fig = go.Figure()
fig.add_trace(go.Bar(x=self.dtf.index, y=self.dtf["delta_data"], name='data', marker_color='black'))
fig.add_trace(go.Scatter(x=self.dtf.index, y=self.dtf["delta_forecast"], mode='none', name='forecast', fill='tozeroy'))
**## add slider**
fig.update_xaxes(rangeslider_visible=True)
**## set background color**
fig.update_layout(plot_bgcolor='white', autosize=False, width=1000, height=550)
** ## add vline**
fig.add_shape({"x0":today, "x1":today, "y0":0, "y1":self.dtf["delta_forecast"].max(),
"type":"line", "line":{"width":2,"dash":"dot"} })
fig.add_trace(go.Scatter(x=[today], y=[self.dtf["delta_forecast"].max()], text=["today"], mode="text", line={"color":"green"}, showlegend=False))
return fig
def **get_panel**(self):
peak_day, num_max = self.calculate_peak(self.dtf)
total_cases_until_today, total_cases_in_30days, active_cases_today, active_cases_in_30days = self.calculate_max(self.dtf)
return peak_day, num_max, total_cases_until_today, total_cases_in_30days, active_cases_today, active_cases_in_30days
前端:用 Dash 和 Bootstrap 构建应用程序
最后，在这里，我们将使用 Dash 和 Dash Bootstrap 组件(以下简称“dbc”)来编写应用程序，我将一步一步地解释它，并提供 dash.py 的完整代码(在应用程序文件夹内)。
为此，我们需要以下进口:
import **dash**
from dash.dependencies import Input, Output, State
import **dash_core_components** as dcc
import **dash_html_components** as html
import **dash_bootstrap_components** as dbc
首先，我需要定义应用程序实例，在这个过程中，dbc 已经提供了一个选择引导 CSS 主题 的强大功能:
app = dash.**Dash**(external_stylesheets=[**dbc.themes.LUX**])
按照视觉顺序，我现在将接近顶部导航条。我想要一个很酷的反应式点击，有弹出菜单和下拉菜单，但我不想浪费太多时间写 CSS 和 JS 代码。换句话说，我想这样使用 Bootstrap:
https://getbootstrap.com/docs/4.0/components/navs/
与这个 html 类似，我们可以使用 dbc 创建导航栏及其项目:
dbc.**Nav**([
dbc.**NavItem**(),
dbc.**NavItem**(),
dbc.**DropdownMenu**()
])
你得到了秘密装置，对不对？Dash 和 Dbc 复制了 html 语法的相同结构和逻辑。考虑到这一点，我们可以在每个项目中添加我们想要的任何内容:
继续使用输入表单，我想得到一个简单的下拉菜单，将所有可能的国家作为选项，将“世界”作为默认选项。为了做到这一点，有必要在编码下拉菜单对象之前读取数据。还记得之前在 data.py (python 文件夹)里面写的数据类吗？好吧，现在是时候使用它了:
from python.data import Datadata = Data()
data.get_data()
既然我们在数据对象中有了国家列表，我们就可以编写下拉菜单，并用一个简单的 for 循环设置其中的选项:
dcc.**Dropdown**(id="country", options=[{"label":x,"value":x} for x in
**data.countrylist**], value="World")])
在 Dash 中，如果没有特别编程，输出将按行排列，一行在另一行下面。但是，我希望所有的内容都包含在屏幕尺寸中，这样用户就不需要向下滚动了。这就是为什么我要使用选项卡，每个选项卡将显示我之前用 plotly 在 result.py(在 python 文件夹中)中编码的 2 个图中的一个。使用 dbc，这非常简单:
dbc.**Tabs**([
dbc.**Tab**(**dcc.Graph(id="plot-total")**, label="Total cases"),
dbc.**Tab**(**dcc.Graph(id="plot-active")**, label="Active cases")
])
我敢打赌，你一定想知道“应用程序如何知道它必须在第一个选项卡中放置第一个情节，在第二个选项卡中放置另一个情节？”。嗯，你没有错，应用程序需要在 html 和 Python 代码输出之间建立一个链接。在 Dash 中，这是通过回调来完成的。一个回调只不过是一个装饰器，一个接受另一个函数并扩展后一个函数的行为而不显式修改它的函数。
让我们以总案例的绘图为例:我需要一个函数，它将从前端选择的国家作为输入，并使用我之前编码的模型和结果类(在 python 文件夹中)将绘图作为输出返回。大概是这样的:
def **plot_total_cases**(country):
data.process_data(country)
model = Model(data.dtf)
model.forecast()
model.add_deaths(data.mortality)
result = Result(model.dtf)
return result.plot_total(model.today)
正如你肯定注意到的，在我定义选项卡的前一段代码中，我在第一个选项卡中放了一个id(id = " plot-total ")。因此，我需要在这个函数的顶部添加一个回调装饰器，告诉应用程序后端将绘制的数字是指那个 id ，输入是国家值。
**@app.callback**(output=Output("plot-total","figure"),
inputs=[Input("country","value")])
最终，右边的面板和一些统计数据有一点不同，因为 python 函数没有像以前那样返回一个图，而是返回一个完整的 html div。事实上，这次的破折号代码将在计算这些数字的回调函数中。我说的是这个:
这几乎涵盖了前端布局的所有元素，它是一个非常基本的应用程序，只有一个输入和几个输出(图形和数字)。
dash.py 的完整代码:
**# Setup**
import **dash**
from dash.dependencies import Input, Output, State
import **dash_core_components** as dcc
import **dash_html_components** as html
import **dash_bootstrap_components** as dbcfrom settings import config, about
from python.data import Data
from python.model import Model
from python.result import Result**# Read data**
data = Data()
data.get_data()**# App Instance**
app = dash.Dash(name=config.name, assets_folder=config.root+"/application/static", external_stylesheets=[dbc.themes.LUX, config.fontawesome])
app.title = config.name**# Navbar**
navbar = dbc.Nav(className="nav nav-pills", children=[
**## logo/home**
dbc.NavItem(html.Img(src=app.get_asset_url("logo.PNG"), height="40px")),
**## about**
dbc.NavItem(html.Div([
dbc.NavLink("About", href="/", id="about-popover", active=False),
dbc.Popover(id="about", is_open=False, target="about-popover", children=[
dbc.PopoverHeader("How it works"), dbc.PopoverBody(about.txt)
])
])),
**## links**
dbc.DropdownMenu(label="Links", nav=True, children=[
dbc.DropdownMenuItem([html.I(className="fa fa-linkedin"), " Contacts"], href=config.contacts, target="_blank"),
dbc.DropdownMenuItem([html.I(className="fa fa-github"), " Code"], href=config.code, target="_blank")
])
])**# Input**
inputs = dbc.FormGroup([
html.H4("Select Country"),
dcc.Dropdown(id="country", options=[{"label":x,"value":x} for x in data.countrylist], value="World")
])**# App Layout**
app.layout = dbc.Container(fluid=True, children=[
**## Top**
html.H1(config.name, id="nav-pills"),
navbar,
html.Br(),html.Br(),html.Br(), **## Body**
dbc.Row([
**### input + panel**
dbc.Col(md=3, children=[
inputs,
html.Br(),html.Br(),html.Br(),
html.Div(id="output-panel")
]),
**### plots**
dbc.Col(md=9, children=[
dbc.Col(html.H4("Forecast 30 days from today"), width={"size":6,"offset":3}),
dbc.Tabs(className="nav nav-pills", children=[
dbc.Tab(dcc.Graph(id="plot-total"), label="Total cases"),
dbc.Tab(dcc.Graph(id="plot-active"), label="Active cases")
])
])
])
])**# Python functions for about navitem-popover**
@app.callback(output=Output("about","is_open"), inputs=[Input("about-popover","n_clicks")], state=[State("about","is_open")])
def **about_popover**(n, is_open):
if n:
return not is_open
return is_open@app.callback(output=Output("about-popover","active"), inputs=[Input("about-popover","n_clicks")], state=[State("about-popover","active")])
def **about_active**(n, active):
if n:
return not active
return active**# Python function to plot total cases**
@app.callback(output=Output("plot-total","figure"), inputs=[Input("country","value")])
def **plot_total_cases**(country):
data.process_data(country)
model = Model(data.dtf)
model.forecast()
model.add_deaths(data.mortality)
result = Result(model.dtf)
return result.plot_total(model.today)**# Python function to plot active cases**
@app.callback(output=Output("plot-active","figure"), inputs=[Input("country","value")])
def **plot_active_cases**(country):
data.process_data(country)
model = Model(data.dtf)
model.forecast()
model.add_deaths(data.mortality)
result = Result(model.dtf)
return result.plot_active(model.today)**# Python function to render output panel**
@app.callback(output=Output("output-panel","children"), inputs=[Input("country","value")])
def **render_output_panel**(country):
data.process_data(country)
model = Model(data.dtf)
model.forecast()
model.add_deaths(data.mortality)
result = Result(model.dtf)
peak_day, num_max, total_cases_until_today, total_cases_in_30days, active_cases_today, active_cases_in_30days = result.get_panel()
peak_color = "white" if model.today > peak_day else "red"
panel = html.Div([
html.H4(country),
dbc.Card(body=True, className="text-white bg-primary", children=[
html.H6("Total cases until today:", style={"color":"white"}),
html.H3("{:,.0f}".format(total_cases_until_today), style={"color":"white"}),
html.H6("Total cases in 30 days:", className="text-danger"),
html.H3("{:,.0f}".format(total_cases_in_30days), className="text-danger"),
html.H6("Active cases today:", style={"color":"white"}),
html.H3("{:,.0f}".format(active_cases_today), style={"color":"white"}),
html.H6("Active cases in 30 days:", className="text-danger"),
html.H3("{:,.0f}".format(active_cases_in_30days), className="text-danger"),
html.H6("Peak day:", style={"color":peak_color}),
html.H3(peak_day.strftime("%Y-%m-%d"), style={"color":peak_color}),
html.H6("with {:,.0f} cases".format(num_max), style={"color":peak_color})
])
])
return panel
我们如何发现我们是否在代码中犯了错误？我们运行应用程序。运行整个程序只需要一行代码，我将把它放在 run.py 文件中(在根级别):
from application.dash import **app**
from settings import config**app**.**run_server**(debug=config.debug, host=config.host, port=config.port)
在终端中运行以下命令:
python run.py
你应该看看这个:
干得好，应用程序已经启动并运行了！
部署
您想让任何人都可以使用您的应用程序吗？那么你必须把它部署在某个地方。我通常使用 Heroku ，云平台即服务，只需一个免费帐户即可部署 PoC 应用。
您可以链接一个 Github repo 并部署其中一个分支。
为了让这个工作，应用程序需要一个 requirements.txt 和一个 Procfile。在 Setup 部分，我已经输入了创建包含所需包的文本文件的命令。关于 Procfile，它只是运行我在上一节中放入的应用程序的命令行。Heroku 将运行它，你去那里:
结论
这篇文章是一个教程，展示了用 Dash 和 Dash Bootstrap 组件嵌入 Bootstrap 的所有 CSS 和 JS 来构建一个好看的 web 应用程序是多么容易。我以我的新冠肺炎感染预测应用程序为例，经历了从后端到前端甚至部署的每一步。现在你知道它是如何工作的，你可以开发自己的预测器，例如改变数据源(即雅虎财经)和机器学习模型(即 lstm 神经网络)你可以建立一个股票价格预测器。
我希望你喜欢它！如有问题和反馈，或者只是分享您感兴趣的项目，请随时联系我。
👉我们来连线👈
本文是使用 Python 进行 Web 开发系列文章的一部分，参见:
[## 用 Python 进行 Web 开发:Dash(完整教程)
用 Plotly 绘图，嵌入引导 CSS，上传和下载文件，选择后改变输入，导航条，微调器，和…
towardsdatascience.com](/web-development-with-python-dash-complete-tutorial-6716186e09b3) [## 字符串匹配:用 Python 和 NLP 超越 Excel VLOOKUP
为所有 Excel 爱好者(和讨厌者)构建一个字符串匹配应用程序
towardsdatascience.com](/surpass-excel-vlookup-with-python-and-nlp-ab20d56c4a1a) [## 构建和部署一个具有短期和长期记忆的电报机器人
从头开始创建一个聊天机器人，用 Python 记住并提醒事件
medium.com](https://medium.com/towards-artificial-intelligence/build-deploy-a-python-bot-with-short-term-and-long-term-memory-a3f1cd6254b8)**
如何在你的媒体文章和个人网站上嵌入互动图表
两行代码是您嵌入交互式图表进行引人入胜的演示所需的全部内容
动机
您是否曾经想要在 Medium、Reddit 或您自己的博客等社交媒体平台上共享您的交互式 Python 图表，但最终不得不拍摄图表的照片或录制视频或 gif？或者，许多人最终使用非代码解决方案，如 Mapbox 或 Flourish，即使他们更愿意使用 Pandas、Altair、Bokeh、Folium 和 Plotly 等库在 Python 中构建他们的可视化。
我喜欢在 Medium 的文章中使用图表来展示我的结果，但在我发现 Datapane 之前，嵌入我的交互式图表很有挑战性。有了 Datapane，我可以在两行代码中嵌入我的图表。
什么是 Datapane？
Datapane 是一个 API ，面向用 Python 分析数据并且需要一种方式来分享他们的结果的人。Datapane 使数据分析师或数据科学家可以轻松地从 plot、markdown、dataframe 等组件生成报告，并在 web 上发布以发送给他人。如果你不了解 Datapane，我写了一篇介绍 Datapane 的短文
[## Datapane 简介:构建交互式报表的 Python 库
创建精美报告并与您的团队分享分析结果的简单框架
towardsdatascience.com](/introduction-to-datapane-a-python-library-to-build-interactive-reports-4593fd3cb9c8)
除了易于创建报告和部署脚本之外，Datapane 还易于嵌入图表或表格。
嵌入媒体
假设您用以下代码创建了一个交互式 Plotly 气泡图:
使用 Datapane 的 API，您可以将这个 Plotly 图表发布到 web 上，并将其嵌入到 Medium 中。
首先，使用 pip 安装 Datapane:
pip3 install datapane
然后只需注册 Datapane 来获得您的 API 令牌。复制并使用它通过 Datapane CLI 登录:
datapane login --token=[your_secret_token]
登录后，您可以使用 Datapane API 来发布您的图。
将 Datapane 导入到您的脚本中，并发布一个带有的新Report，其中包含一个单独的 Plot组件。
在这个例子中，我们还告诉 Datapane 将我们报告的可见性设置为 public，这样任何人都可以通过这个 URL 访问它。
当您运行这个 Python 代码时，Datapane 将使用 API 上传您的 Plotly 图表，并给您一个您可以共享的 URL！
https://data pane . com/khuyentran 1401/reports/bubble _ c7ac 0e 14/
接下来，在编辑模式下将这个链接复制到你的文章中，瞧！—在您的 Medium post 中会自动为您创建一个嵌入式图表。
因为您在 Medium 上处于编辑模式，所以您将首先看到没有交互模式的图表，但是一旦您发布了您的文章，您(和您的读者)将能够交互地使用它。
对于一个有一些嵌入的中等职位的例子，检查这个职位
在 5 行简单的 Pythn 代码中利用您的数据分析
towardsdatascience.co](/how-to-create-interactive-and-elegant-plot-with-altair-8dd87a890f2a)
除了图表之外，你还可以像这样嵌入一个数据框
嵌入你的个人网站
有了你的个人网站，你可以应用同样的技术或者根据你使用的平台稍微改变一下技术。对于 Wagtail，我所做的只是简单地点击嵌入按钮，然后将 URL 粘贴到嵌入框中。
结论
恭喜你！你已经学会了如何用 Datapane 在媒体或个人网站上嵌入你的图表。有什么比让你的观众或读者与图表互动来观察你的结果更好的呢？
在 this Github repo 中，您可以随意使用本文的代码。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以通过 LinkedIn 和 Twitter 与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
[## 如何在数据科学项目中利用 Visual Studio 代码
直到发现一种新的有效方法，我们才意识到我们是多么低效
towardsdatascience.com](/how-to-leverage-visual-studio-code-for-your-data-science-projects-7078b70a72f0) [## 如何通过将自己置于合适的环境中来加速您的数据科学职业生涯
我感到增长数据科学技能停滞不前，直到我有了一个飞跃
towardsdatascience.com](/how-to-accelerate-your-data-science-career-by-putting-yourself-in-the-right-environment-8316f42a476c) [## 如何创建可重用的命令行
你能把你的多个有用的命令行打包成一个文件以便快速执行吗？
towardsdatascience.com](/how-to-create-reusable-command-line-f9a2bb356bc9) [## 如何为你最喜欢的可视化工具创建下拉菜单和滑动条
使用 Python Widget，您可以用 3 行代码升级可视化
towardsdatascience.com](/how-to-create-a-drop-down-menu-and-a-slide-bar-for-your-favorite-visualization-tool-3a50b7c9ea01) [## 如何用 Ngrok 用 3 行代码分享你的 Jupyter 笔记本
想象一下，让你的朋友在远程机器上使用你的本地 Jupyter 笔记本
towardsdatascience.com](/how-to-share-your-jupyter-notebook-in-3-lines-of-code-with-ngrok-bfe1495a9c0c)
如何将 Julia 代码嵌入 Python 以提高性能
使用 Julia 作为 Python 包来轻松提升性能。
unsplash 的图像
介绍
这篇博客文章是关于 Python 和 Julia 的合作，主要面向那些想要快速提高运行时性能的 Python 数据科学家，并通过另一种在大学、公司和用户中广受欢迎的编程语言来实现。
图片:Julia Computing(GitHub stars for Julia)
在这篇文章结束时，你将获得:
- 一个 docker image 环境，也包含 Julia 和 Python
- Julia 和 Python 在速度上的直接比较。
- 将 Julia 代码嵌入 Python 的三种不同方法。
我希望你会发现它内容丰富！
装置
为了设置环境，我使用了这个包含 Julia、Python 和 Jupyter 的 docker 映像:
在参考资料部分可以找到码头工人的逐步指南。
Julia 与 Python 在 for 循环上的速度测试
在我演示如何将 Julia 代码嵌入 Python 以提高性能之前，我想让您相信使用 Julia 是有价值的，并且在使用 for 循环时，它可以比 Python 快得多。
那么，让我们在 Julia 和 Python 中运行一个简单的 for 循环，并比较它们的运行时间:
在 Python 中:
def for_loop(iterations = 100):
a = 0
for i in range(iterations):
a = a+1
return a
大概用了 1 秒。
%%time
res = for_loop(iterations = 10_000_000)
>>> CPU times: user 953 ms, sys: 0 ns, total: 953 ms
>>> Wall time: 951 ms
在朱丽亚身上:
function for_loop(iterations = 100)
a = 0
for i in 1:iterations
a = a+1
end
return a
end
用了 0.000001 秒:
@time res = for_loop(10_000_000)
>>> 0.000001 seconds (1 allocation: 16 bytes)
差别很大！
但这只是一个极端的例子；通常，差异不会那么显著。
将 Julia 代码嵌入 Python
因此，在我们确信这里有一些潜力之后，让我们看看机器学习中 NLP 领域的一个真实例子。我们将挑选一个涉及到 for loop 的任务来使用 Julia 的力量。
我们将使用词干任务(不熟悉这个任务的读者可以在这里了解:https://en . Wikipedia . org/wiki/Stemming)。
数据
我们将在 NLTK 包中使用来自莎士比亚-哈姆雷特数据集的数据。可以这样访问它:
from nltk.corpus import gutenberg
data = gutenberg.raw('shakespeare-hamlet.txt')
data = data.replace("\n", " ")
data = data.replace(" ", " ")
数据看起来是这样的:
”《哈姆雷特的悲剧》由威廉·莎士比亚于 1599 年创作。斯科纳·普里马。进入巴纳德和弗朗西斯科两个世纪。巴纳德。谁在那里？弗兰。不要回答我:站起来，收起你自己的棍子。朗·刘鹗国王弗兰。巴纳德？巴录书他叫弗兰。你小心翼翼地来到你的酒吧。现在是午夜，去睡觉吧，弗兰斯科·弗兰。对于这封信，我非常感谢:天气很冷，我在谷仓里感到很不舒服。豪埃尔你有安静的警卫？弗兰。没有一只老鼠蠢蠢欲动……”
使用 Python 进行词干分析
我们还将使用 NLTK 来完成词干部分:
import nltk
from nltk.stem import PorterStemmerporter = PorterStemmer()%%time
stem_words = []
nltk_tokens = nltk.word_tokenize(data)
for token in nltk_tokens:
new_token = porter.stem(token)
stem_words.append(new_token)>>> CPU times: user 1.52 s, sys: 0 ns, total: 1.52 s
>>> Wall time: 1.57 s
我们花了 1.57 秒。
使用 Julia 进行词干分析
现在是有趣的部分。
将 Julia 代码嵌入 Python 的方法很少，我们将介绍其中的三种:
- 运行朱莉娅的整个表达式
- 用“魔法”命令运行 Julia
- 用脚本运行 Julia
首先，我们将导入相关模块:
from julia.api import Julia
jl = Julia(compiled_modules=False)from julia import Mainjl.using("TextAnalysis")
(我们从 Python 和 Julia 导入了相关的包)。
运行整个表达式
让我们运行代码，然后理解这里发生了什么:
%%timeMain.data = data
Main.token_data = jl.eval("tokens_data = TokenDocument(data) ; return(tokens_data)")
stem_list = jl.eval("stem!(tokens_data);stem_tokens_data = tokens(tokens_data) ; return(stem_tokens_data)")>>> CPU times: user 747 ms, sys: 112 µs, total: 747 ms
>>> Wall time: 741 ms
因此，在第一行中，我们将数据变量存储在主数据变量中，这样 Julia 就可以读取这个变量。
Main 是我们从 Julia 导入的一个模块。我们在这里使用它来存储 Julia 格式的数据变量，以便稍后使用(当我们调用 TokenDocument(data)时)。
请注意，如果我们没有写那一行(Main.data = data)，Julia 无法识别任何名为‘data’的变量。
接下来，我们对 Julia 中的数据进行标记化，并将其存储在 Main.token_data 变量中。 ( 注:我们要用 return 命令来存储变量)。
然后，我们对标记化的数据进行词干提取，并将其存储在一个常规的 python 列表中。
所以，在 Python 中运行 Julia 的表达式，我们需要做的就是使用 jl.eval 函数，用“连接 Julia 的表达式；"之间，并以返回命令结束。
我们花了大约 740 毫秒——大约是 Python 的一半时间。
用“魔法”命令运行
%load_ext julia.magic
要使用 magic 命令，我们首先需要加载它。
请注意，此方法仅适用于 Jupyter 笔记本。% %时间
tokens = %julia TokenDocument($data)
%julia stem!($tokens)
stem_list = %julia tokens($tokens)>>> CPU times: user 849 ms, sys: 3.39 ms, total: 852 ms
>>> Wall time: 845 ms
所以，在我们加载了 julia.magic，之后，我们运行这三行代码。
我们应该注意两件事:
- 在使用 Julia 的语法之前加上符号 % 。
- 在引用 python 变量之前使用 $ 符号。
像以前一样，我们首先将数据标记化，然后对其进行词干处理，并将其精细地存储为 Python 列表。
使用 Julia 脚本运行
在这个方法中，我们可以编写一个完整的独立的 Julia 脚本，并从 python 中调用它。
因此，如果我们编写一个名为 julia_stemming.jl 的脚本，并在其中存储这个 julia 函数:
function stemming_document(document_string)
tokens_data = TokenDocument(document_string)
stem!(tokens_data)
stem_tokens_data = tokens(tokens_data)
return stem_tokens_data
end
我们可以从我们的 Python 脚本/笔记本中调用这个函数:
%%timejl.eval('include("julia_stemming.jl")')
Main.data = data
stem_list = jl.eval("stemming_document(data)")>>> CPU times: user 602 ms, sys: 3.24 ms, total: 606 ms
>>> Wall time: 602 ms
首先，我们包含这个脚本以使它可用，然后我们调用其中的函数。
最终速度测试
我们展示了对于这个特定的数据集( shakespeare-hamlet.txt )，Julia 比 Python 快两倍多。但是当我们使用更大的数据集时会发生什么呢？
我们使用不同的数据集长度(复制我们的原始数据集)多次执行词干函数，并绘制结果:
作者图片
如您所见，数据集越大，运行时间之间的差异就越显著——这使得 Julia 在处理大型数据集和 for 循环时非常有用。
我们用这个代码来计算差异:
time_list_python = []
time_list_julia = []
dataset_length = []duplicates_list = [1,2,5,10]
for t in duplicates_list:
data_repeat = ' '.join([data] * t)
dataset_length.append(len(data_repeat))
time_start_python = time.perf_counter()
stemming_python(data_repeat)
time_end_python = time.perf_counter()query_time_python = time_end_python - time_start_python
time_list_python.append(query_time_python)
time_start_julia = time.perf_counter()
Main.data_repeat = data_repeat
jl.eval("stemming_document(data_repeat)")
time_end_julia = time.perf_counter()query_time_julia = time_end_julia - time_start_julia
time_list_julia.append(query_time_julia)
这段代码用来绘制:
import pandas as pd
import matplotlib.pyplot as pltdf = pd.DataFrame({"running_time_python" : time_list_python,
"running_time_julia" : time_list_julia,
"dataset_length" : dataset_length})
df.set_index("dataset_length", inplace=True)df.plot(figsize = (10,6), title = "Python vs Julia running time comparison")
plt.ylabel('seconds', fontsize = 20)
plt.xlabel('dataset_length', fontsize = 20)
plt.show()
摘要
我希望我让你相信了将 Julia 和 Python 联系起来的好处。
据我所见，纯 Python 在多个领域仍然更好——比如处理矢量化计算(比如 NumPy ),所以我们需要确保切换到 Julia 是值得的。
感谢您的阅读，当然，我会很高兴听到您的回应。
参考
https://julia.mit.edu/(使用茱莉亚的大学)
https://julia computing . com/media/2017/09/19/Julia-the-ai-language-for-next-150 years . html(使用 Julia 的公司)
https://Julia computing . com/blog/2018/12/04/12 月-newsletter . html(GitHub stars)
https://hub.docker.com/r/jupyter/datascience-notebook(我们使用的图片)
https://dagshub . com/blog/setting-up-data-science-workspace-with-docker/(docker 分步指南)
https://pyjulia.readthedocs.io/_/downloads/en/latest/pdf/(py Julia 包文档)
https://py Julia . readthedocs . io/en/latest/usage . html #高层接口 (PyJulia 包文档)
https://Julia Text . github . io/Text analysis . JL/latest/documents/(文本分析包)
如何对分类数据进行编码
从基础到高级的 12 种不同的编码技术
在这本笔记本中，我将介绍编码分类数据的不同方法。我想用简单的语言写出来，并加入一点数学知识。它们是你应该放入工具箱的基本编码方案。为了方便起见，我还会提供scikit-learn版本和每个方法对应的库。
在这篇文章结束时，我希望你会对如何处理分类数据有一个更好的想法。你可以在这里找到我的代码。
目录
对字符串数据类型进行编码有三种主要方法:
经典编码器:广为人知，应用广泛
对比编码器:****通过查看不同层次的特征对数据进行编码的创新方法
6.赫尔默特
7.向后差异
****贝叶斯编码器:一种更高级的方法，使用目标作为编码的基础
8.目标
9.漏掉一个
10.证据的权重
11.詹姆斯-斯坦
12.M-估计器
而且还有很多！然而，一旦你知道这些最常见的编码方案是如何工作的，你会发现谷歌搜索另一种编码方案是相当容易的。
让我们创建一个随机的口袋妖怪数据集！
资料组
我是一个超级粉丝，也是一个努力的口袋妖怪研磨者。我经常去口袋妖怪数据库看看我的队伍里应该有哪个口袋妖怪。有 4 个特征会影响我的选择:类型、大小、属性和传奇。我创建了这个只有 10 个观察值的样本数据，以更好地说明不同的编码技术，并给自己带来一些快乐！
来源: Huy Bui
I .经典编码器
我们从最基本的技术开始，经典的编码器。顾名思义，这些编码器是众所周知的和广泛使用的。他们的概念也非常直接。
1)顺序编码
序数特征是具有顺序的特征。这种类型的数据也称为序数数据。让我们看看数据框中的Height列。这些类别是:*very short,**short**normal**tall**very tal*l，按升序/降序排列是有意义的。通过手动编码列，我们可以显著提高模型性能。****
来源: Huy Bui
2)一键编码
再来看专栏Type。这是与Height栏中的序号数据相反的名义数据。将该列转换为数字的最简单方法是通过以下两个步骤使用一键编码
- 将一列中的所有类别拆分到不同的列中
- 将勾号 1 放在适当的位置
熊猫的get_dummies功能可以达到这个目的
来源: Huy Bui
3)二进制编码
想象你有200个不同的类别。一键编码将创建 200 个不同的列。大量的列会占用大量的内存。与此同时，二进制编码只需要 8 列。它利用了二进制系统，所以一行中可能有多个 1。二进制编码背后的逻辑解释是:
- 沿着列往下，每次看到一个新的类别，它都会给出一个数字，从 1 开始(下一个是 2)
- 将这些数字转换成二进制
- 将该二进制中的每个数字放在单独的列中。
在下面的代码中，我将添加encounter step列，这样您可以看到它是如何工作的。
来源: Huy Bui
4)频率编码
给每个类别一个概率(发生/总事件)。这意味着，如果一列中有两个具有相同概率的类别(3 fire和 3 bugs)，在进行频率编码后，您无法真正区分它们。代价是不会引入新的列。
资料来源: Huy Bui
5)散列编码
哈希将分类变量转换为更高维的整数空间。由于 scikit-learn 已经很好地解释了这个方法，所以我不会在这里过多地评论它。
n_feature是要添加的列数。这些新列区分相应的类别。但是，您可以调整到任何数字。这就像类固醇上的二进制编码！
优势
- 处理大规模分类特征
- 高速和减少的内存使用
缺点
- 无逆变换方法
来源: Huy Bui
注:什么是好的回特征数？如果m是明显的特征，而n_feature=k，那么m<2^k
二。对比度编码器
对比编码允许类别变量重新居中，使得模型的截距不是类别的一个级别的平均值，而是数据集中所有数据点的平均值。
许多人认为这些编码不是很有效。但是，我将它们留在这里作为参考。
6)赫尔默特(反向)编码
赫尔默特编码将分类变量的每个级别与后续级别的平均值进行比较。多读书。
资料来源: Huy Bui
7)后向差分编码
在后向差分编码中，一个级别因变量的平均值与前一个级别因变量的平均值进行比较。阅读更多
来源: Huy Bui
三。贝叶斯目标编码器
这种方法的总体思想是考虑目标。
优势:
- 只需很少的工作，只需为该特性中任意数量的类别创建一个列
- Kaggle 竞赛中最受欢迎的编码方案
缺点:
- 只为监督学习工作(因此，本质上是有漏洞的)。这意味着在处理无监督数据时，情况会变得更糟！
- 由于前面的原因，需要正规化
8)目标编码
基于目标的编码基本上是指使用目标对分类特征进行编码。它的公式是:
在下表中，Legendary是我们的目标。由于3 Fire口袋妖怪中只有1是传说中的，所以它的价值就是1/3。把目标编码想象成目标上的频率编码！
资料来源: Huy Bui
注意:有一些不同的版本将输出乘以一个(Laplace)smoothing value.这是为了避免数据泄漏。
9)省去一个编码
留一个编码(LOOE) 与目标编码非常相似，但在计算某个级别的平均目标以减少异常值的影响时，会排除当前行的目标。
此外，您可以通过在 0 和 1 之间更改 sigma 值，向数据中添加一些(高斯)噪声，以防止过度拟合。
来源: Huy Bui
10)证据权重编码
证据权重编码(WoE)是对证据支持或破坏假设程度的衡量。
其中adj是相邻因子，是一个避免除以 0 的函数。
优势:
- 与逻辑回归配合良好，因为 WoE 转换具有相同的逻辑标度。
- 可以使用 WoE 来比较不同特性，因为它们的值是标准化的。
缺点:
- 可能会丢失信息，因为某些类别可能具有相同的 WoE
- 不考虑特征相关性
- 过度拟合
来源: Huy Bui
注:我们可以通过改变正则化来调整adj因子。(默认情况下为 1)。当将其设置为 0 时。你回到原来的悲哀，可能会遇到除以 0
11)詹姆士-斯坦编码(JSE)
这是目标编码，但更健壮。 James-Stein (JS) 对于具有正态分布的特征，它是最有效的。JS 由以下公式定义:
权重B取决于方差*σ(y)*和*σ(yi)*。更多关于这个方法的在这里。
资料来源: Huy Bui
12) M 估计编码
M 估计编码器是目标编码器的简化版本。代表最大似然型。它只有一个超参数m，代表正规化的力量。m 值越高，收缩越强。推荐值m在1到100的范围内。更多关于它的这里。
来源: Huy Bui
动词 （verb 的缩写）结论
对特征进行编码没有单一的公式。然而，如果你理解我上面介绍的12编码技术，你将能够快速移动。此外，尝试所有适用于该特性的技术并决定哪一种效果最好总是值得的。尝试输入不同的正则化系数值，看看它们是否增加你的分数。下面的备忘单将帮助你做一些初步的决定。
分类编码备忘单
玩编码器玩得开心！
如何在递归神经网络中对时间属性进行编码？—星期五实验
Keras 中 RNNs 的时间相关和非等间隔时间编码。
TL；速度三角形定位法(dead reckoning)
你有一个用于神经网络训练的事件流。这些事件具有持续时间和/或不相等的间隔或其他与时间相关的属性。您知道丢弃这些信息会适得其反，但是您无法找到一种简单、合理且可行的方法来将这些数据整合到现有的 RNN 架构中。不再害怕。你需要知道的是:
- 这篇论文有所有的数学知识，它很简单——https://www . ground ai . com/project/time-dependent-re presentation-for-neural-event-sequence-prediction/2
- 我已经在我的 GitHub 中将其实现为 Keras 层
IMHO，这应该是事件驱动的 AI 和营销平台特别感兴趣的。
为什么需要这样做？
我一直在玩一个 Datascience Bowl 2019 Kaggle 比赛。背后的数据集基本上是混合粒度的各种应用程序发起的事件流。目前(2019 年 12 月)，似乎主导方法是经典的“特征工程-梯度增强-集成”组合。我很好奇，我们是否可以用 RNNs 或 Transformers 获得类似或更好的结果，因为更多的“事件本地”(至少看起来是这样)的方法。
对事件本身进行编码并不是一件容易的事情，考虑到所涉及的超参数和选择的数量，我还偶然发现了一个明显的问题——如何对事件的时间信息进行编码？这看起来很直观，时间有很多信息，尤其是当与事件的性质相联系时。
我决定写这篇文章，有几个原因:
- 花了 10 多分钟才找到相关途径。这对于 2019 年来说很奇怪。
- 上述方法的实现没有 Github。
- 阅读和实现起来既容易又有趣，对于初学 ML 的工程师来说是一个很好的开始。
如何编码时间
[1]提出了两种编码时间的方法。
- 用时间掩码嵌入事件
- 事件-时间联合嵌入
作者比较了这两种方法，并表明第二种方法在性能上有更好的改进，所以我在这里主要关注它。
任何表征事件持续时间或间隔的时间属性都应该表示为每个事件的单个标量。根据数据的性质，应用对数变换是个不错的主意。如果你不确定——把它当作一个超参数。以下是您应该如何准备原始数据:
其中，事件数据是唯一的事件类型，用分类编码器编码，时间数据是浮点数，表示事件的时域(从上一个事件或时间到下一个或关键事件的距离)
事件-时间联合嵌入。想法和数学。
我们希望将单个浮点标量嵌入到嵌入空间中，使用与单词嵌入相同的原理。单词嵌入的工作非常简单，这基本上是一个可学习的哈希表，它将词汇中的单词索引映射到一个嵌入向量，无需任何额外的转换。
这适用于整数单词索引，但是我们如何将这种技术应用于具有连续和非线性性质的浮点值呢？
第一步是转换向量中的单个标量。为此，我们将一个标量乘以一个随机初始化的可训练向量 W，并添加一个偏差向量 b。
时间潜向量空间的第一标量时间投影
式中，W 为【1，隐藏向量维度】形状的权重矩阵，B 为【隐藏向量维度】形状的偏置向量。
由于这是一个线性变换，它没有任何巨大的编码和表示能力，你可以把它看作是一个可学习的线性标量到矢量变换的一个步骤。
然后，我们将 softmax 函数应用于所获得的向量。
如您所知，softmax 倾向于增加向量中的一个值，而减少其他值。把这个想成“这是最重要的矢量”。然后，我们使用与单词嵌入中相同的方法，但是不是采用对应于单词索引的一个向量，而是采用所有嵌入矩阵，其中我们根据向量值中的值对嵌入空间中的所有行进行加权，将它们作为权重进行阈值化。瞧，我们有了一个时间嵌入向量！
现在，我们可以自由选择如何将这个向量与另一个数据流相结合——使用传统的事件类型嵌入矩阵获得的事件嵌入。我第一个自然的想法是将它们连接起来，但是作者在[1]中建议采取时间嵌入和事件嵌入的方法。
组合时间和事件嵌入数据
事件-时间联合嵌入。实施。
在这里，我提出这个时间嵌入层的一个 Keras+Tensorflow 2.0 实现。你可以在我的 GitHub 上随意下载。
让我们看看，这是怎么回事。
我们使用两个超参数初始化该层:隐藏嵌入潜在空间的大小和时间嵌入向量的输出大小。
在“构建”方法中，我们随机初始化权重、偏差和嵌入矩阵。
在“调用”方法中，我们进行实际计算。使用 keras 后端函数完成标量的投影和 softmax 函数的应用:
x = tf.keras.activations.softmax(x * self.emb_weights + self.emb_biases)
然后我们做最有趣的部分——潜在向量在嵌入矩阵上的投影。虽然这可以用点积符号来实现，但在数学上是不正确的。更好的方法是使用爱因斯坦符号。
我们的输入将是【批处理，时间步长，隐藏向量维度】的形式，输出预计是【批处理，时间步长，嵌入矩阵维度】的形式，其中数学上看起来是这样的:
得到最终时间嵌入的 Einsum 符号
只要你能用这种数学求和的形式来表达，你就可以直接使用 einsum 符号，只要把求和的指数复制到 einsum 符号中。
x = tf.einsum('bsv,vi->bsi',x,self.emb_final)
这是最终代码。
class TimeEmbedding(Layer):def __init__(self, hidden_embedding_size, output_dim, **kwargs):
super(TimeEmbedding, self).__init__(**kwargs)
self.output_dim = output_dim
self.hidden_embedding_size = hidden_embedding_sizedef build(self, input_shape):
self.emb_weights = self.add_weight(name ='weights',shape=(self.hidden_embedding_size,), initializer='uniform', trainable=True)
self.emb_biases = self.add_weight(name ='biases',shape=(self.hidden_embedding_size,), initializer='uniform', trainable=True)
self.emb_final = self.add_weight(name ='embedding_matrix', shape=(self.hidden_embedding_size,self.output_dim), initializer='uniform', trainable=True)
def call(self, x):
x = tf.keras.backend.expand_dims(x)
x = tf.keras.activations.softmax(x * self.emb_weights + self.emb_biases)
x = tf.einsum('bsv,vi->bsi',x,self.emb_final)
return x
def get_config(self):
config = super(TimeEmbedding, self).get_config()
config.update({'time_dims': self.output_dim, 'hidden_embedding_size':self.hidden_embedding_size})
return config
参考
原载于 2020 年 1 月 4 日 https://fridayexperiment.com**。
如何执行 ML 分类器的结果
如何校准机器学习分类器的分步指南
根据分类器的输出做出决定可能会很棘手。幸运的是，通过校准工具的使用，预测概率的解释最近变得更容易了。我接触过这个问题，因为我工作的很大一部分要求我不仅要解释模型的输出，还要根据这些结果推荐产品策略。事实上，许多企业依靠预测的概率来做决定(例如，打赌的几率，广告定位…)。如果这也是你的情况，这篇文章描述了一个系统的方法来确保你的分类器与理论，代码和可视化的健康组合校准！
对于具有工程背景的人来说，术语“校准”可能会让您的系统 1 ( Daniel Kahnema n)兴奋不已，并引发了一个装满测量仪器的实验室的可视化，如图所示。嗯，校准你的 ML 分类器是非常相似的。
感兴趣？
在整篇文章中，最基本的是要记住校准的目标是获得“接近经验概率[即观察到的类频率]的预测概率，正如de groot&fien Berg(1983)【1】所定义的那样。
在本文结束时，目标是让您知道如何做 3 件事:
- 评估校准不良概率的风险
- 使用合适的工具调整
- 更加自信地解读它们
一、为什么校准很重要
米娅似乎知道答案！(照片由 Camylla Battani 在 Unsplash 上拍摄)
分类可以简单地理解为用一条“线”(2D 的平面或> 3D+的超平面)分隔数据点，正如吴恩达在 Coursera 上的第一个机器学习课程中所解释的那样。算法负责寻找最佳“路线”。然而，这些算法采用不同的方法，同时依赖不同的假设。在推理过程中，分类器可以直接预测标签，也可以预测属于每个类别标签的概率。
校准之所以重要，是因为在理想情况下，我们希望能够将这些概率解释为事前概率。
但是，当概率的分布与数据中观察到的分布不匹配时，如何做到这一点呢？
答:校准。
但具体来说，这对你和你的分类器意味着什么？
再来看逻辑回归。回想一下，分类器试图最小化损失函数(在这种情况下是交叉熵),以便找到将数据分成两部分(二元分类)的最佳“线”。当损失函数的导数等于 0 时，可以找到损失函数的最小值。我将省去 3-4 行数学公式，方便地得出以下等式:
作者图片
其中 p 是类概率，y 表示观察到的类值。
假设数据集是线性可分的，这个等式似乎告诉我们，类概率将与期望值完全对应。因此，逻辑回归很可能提供校准概率。这使得它在应用用例中非常有吸引力。
不幸的是，其他(更复杂的)分类器没有这个特征。支持向量机就是一个很好的例子。事实上，支持向量机通过最大化决策边界周围的边界(即“线”)来找到最优的“线”。它没有输出任何可能性，而是使用了边际的概念(这是斯坦福大学一门课程的一些材料)。
在这一点上，你们中的一些人可能会感到困惑，并在 scikit-learn (如果你是 python 用户)上打开一个新的标签页，查看是否可以从 SVM 输出概率。让我为你节省一些时间:
Scikit-Learn ( 开源库)的文档快照
在线性 SVM 估计量上 sklearn predict_proba 方法的输出概率似乎实际上来自对 SVM 分数的逻辑回归(对描述这种方法的论文的作者来说，这种方法通常被称为普拉特标度)。
有趣吧。看起来 scikit-learn 已经帮你做了。但是对所有的量词都成立吗？决策树怎么样？
让我再为您节省一些时间:
Scikit 的文档快照——了解 DecisionTreeClassifier ( 开源库)
对于单个决策树，输出的概率代表一个频率(由你的训练集决定，这就是为什么单个决策树很可能过度拟合你的训练数据，也就是高方差)，而不是一个可能性。
让我为您节省更多时间，RandomForestClassifiers 也是如此。
事实上，返回的概率是所有树中预测感兴趣类别的树的分数。gradientboosting 分类器的类似推理(在 scikit-learn github repo 中的 _stagged_raw_predict 函数中描述)
注意:
-没有提到 scikit-learn 上基于树的分类器的校准
二。评估校准的需要
- 一个 [可靠性图](http://www.bom.gov.au/wmo/lrfvs/reliability.shtml#:~:text=Reliability diagrams (Hartmann et al,a forecast probability actually occurred.) 作为一个强大的工具，帮助我们对错误校准的存在及其性质(信心不足或信心过度)进行定性评估。
实际上，可靠性图是感兴趣类别的观察频率作为预测概率的函数的图。
作者图片
该图似乎显示了标准 GB 校准不佳的明显情况。曲线似乎遵循 S 形趋势。对于此图，我选择显示 10 个箱，因为我有一个相对较大的数据集(400k+数据点)用于校准。
然而，我们是否可以用更少数量的箱得到相同的结论🤔？
作者图片
这是完全相同的图，但是使用 4 个箱而不是 10 个箱。我们仍然可以注意到标准 GB 的校准不佳。然而，曲线的形状不是很明显。在这种情况下，这不是有害的，因为数据集足够大，我们可以使用保序回归来校准模型。更多关于它的信息。
在您训练了您的模型并根据您的测试数据进行了预测之后，现在是时候构建您的可靠性图表了。您可以手动操作:
步骤 1 :选择面元数
步骤 2 :将数据点和预测概率桶入相应的面元。可以通过确保它们都包含相同数量的数据点(统一策略)或者使用分位数遵循更复杂的分割来确定容器的大小。
步骤 3 :计算相应仓中的平均概率和平均频率
步骤 4 :绘制作为平均预测概率的函数的平均观察频率
或者您可以选择使用 scikit-learn 上的现成方法:
#Path of least resistance: Use Sklearn [2]from sklearn.calibration import calibration_curve
import matplotlib.pyplot as pltobserved_pos_frequency, mean_pred_proba = calibration_curve(y_true, y_proba, n_bins=10, strategy='uniform')
plt.plot(mean_pred_proba, observed_pos_frequency)
***提示***:
——⚠️警告:一个常见的错误是使用平均精度绘制可靠性图表👎而不是平均预测概率👍正如向江也指出的那样[3]
——箱子的宽度不必一致。您可以选择使用遵循分位数分布的分割
-我建议使用相对较高数量的箱(取决于您的数据集大小)，以便更好地可视化较差校准的存在。
- 欧石南损失 是校准拟合的定量度量。它被定义为标签和感兴趣的数据集中的数据点的预测概率之间的均方差。差异越小越好。
n 是数据点的数量(图片由作者提供)
作者图片
请注意，早期的大幅波动是由于样本量小(方差大)。事实上，越多的数据被用来计算短暂的损失，它就变得越稳定。
#Path of least resistance: Use Sklearn [4]from sklearn.metrics import brier_score_lossbrier_loss = brier_score_loss(y_true, y_proba)
注: 前面的公式不包括样品重量。
如果您使用类别权重(阳性和阴性类别的数据点比例)，则以下公式更适合计算 Brier 损失。
作者图片
三世。如何校准您的模型
到目前为止，大家都知道，校准您的模型可以被描述为拟合回归变量的行为。回归器被期望找到将分类器的输出概率映射到观察到的类频率的函数。
实际上，可能会出现两种情况:
- 您已经安装了分类器(方法 1 和 2 适用)
- 您尚未安装分类器(所有方法都适用)
- Platt Scaling :通过最大似然法(此处有的论文)拟合回归变量，找到将模型输出映射成概率的 sigmoid 函数的参数。
# Path of least resistance: Use Sklearn [5]
# Case with a classifier already fittedfrom sklearn.calibration import CalibratedClassifierCV
from sklearn.ensemble import RandomForestClassifierrf_est = RandomForestClassifier()
rf_est.fit(X_train, y_train)platt_rf = CalibratedClassifierCV(rf_est, cv="prefit", method=’sigmoid’)
platt_rf = platt_rf.fit(X_test, y_test)
calibrated_yhat = platt_rf.predict_proba(X_test)brier_loss = brier_loss_score(y_test, calibrated_yhat[:,1])
**注意: - ⚠️当校准来自已经拟合的分类器的概率时，拟合步骤仅应用于用于校准的回归器，而不是底层分类器(如 Sklearn 校准文件[6]的源代码的第 237 行所述)
- ⚠️当校准来自已经拟合的分类器的概率时，必须用与用于拟合分类器的数据集不相交的数据集来拟合回归器**(如指南[7]所述)****
2。保序回归有助于对数据进行单调拟合。请记住，完美校准概率的定义是可靠性图中的对角线。因此，我们知道最好的情况是曲线趋势是单调的。因此，通过设计，保序回归可以在模型输出单调的任何情况下充当强大的平滑器。这里有一个有用的可视化来理解它的机制:
比较等渗拟合与线性拟合的图表(图片由作者和来源提供代码由 n .Varoquaux&a . gram fort 根据 BSD 许可**
关于保序回归有趣的事实是没有参数可寻。这是一种利用“智能”平滑方法的非参数方法，如合并相邻违规者算法(PAVA)。事实上，scikit-learn [8]中的保序回归方法使用了 PAVA。
**# Path of least resistance: Use sklearn [5]
# Case with a classifier not yet fittedfrom sklearn.calibration import CalibratedClassifierCV
from sklearn.ensemble import RandomForestClassifierrf_est = RandomForestClassifier()
isotonic_rf = CalibratedClassifierCV(rf_est, cv=5, method=’isotonic’)
isotonic_rf.fit(X_train, y_train)
calibrated_yhat = isotonic_rf.predict_proba(X_test)brier_loss = brier_loss_score(y_test, calibrated_yhat[:,1])**
注意:
—💢如果某件事好得不像真的，它可能就是真的。事实上，通过设计，保序回归有过度拟合的趋势。为了减少过度拟合，您应该考虑仅对大型数据集使用保序回归。
3。拉普拉斯估计& m 估计 :
你也可以选择改变你的基础模型的估计量，比如拉普拉斯估计量或者 m 估计量。 N. Chawla 在【9】中描述了 RandomForestClassifier 的这种变化的一个例子:
“[预测概率]可以是基于叶频率的估计，或者[可以]通过拉普拉斯或 m 估计来平滑。”
不幸的是，他的工作还没有被实现成一个软件包(据我所知)。
四。框架
最后但同样重要的是，这是您可以用于案例的框架:
第 0 步:您应该担心校准吗？
您是否在使用逻辑回归之外的分类器？
如果是，继续步骤 1。
步骤 1:风险评估
1.1 绘制您的可靠性图
1.2 计算 Brier 损失
第二步:采取行动
2.1 如果可靠性图上的失真看起来像 S 形，那么拟合一个利用 sigmoid 函数的回归变量可能是一个好主意。
你猜对了→使用普拉特缩放
2.2 否则，在使用保序回归之前，你应该验证你正在使用一个大数据集进行校准。****
第三步: 解读
作者图片
动词 （verb 的缩写）摘要
在本文中，我们看到:
- 通过设计，非线性和非参数模型很可能呈现出校准不良的概率。
- 有可用的工具来评估校准不良概率的情况，例如:
1。可靠性图
2。Brier 损失 - 可以使用
1 进行校准。普拉特缩放(现成的 API 可用)
2。等渗回归(现成的 API 可用)
3。自定义评估员
就这样结束了！
我希望这个指南对你有用。随着更多的 ML 模型被部署，我们(创建者)有责任确保它们的结果被正确地解释。鼓励责任感，永远！
我很想听听大家对这个话题的看法。不要像陌生人一样，用你的经验/方法发表评论。
六。参考文献
阅读材料:
提及的参考文献:
[1] 比较概率预测者:基本二元概念和多元扩展由德根&芬伯格(1982)
【2】sk Learn 校准曲线法
【3】简介不确定度校准和可靠性图表由向江
【4】sk Learn Brier 评分法
【5】sk Learn 校准法
【6】
如何确保 SaaS 应用程序的安全性
杰佛森·桑多斯在 Unsplash 上拍摄的照片
随着企业将数据和应用程序迁移到云中，他们不断面临着在提高生产力和降低成本的优势与重大的合规性和安全性问题之间进行平衡的任务。
随着 94%的企业使用云，企业开始关注数据和业务流程，如记录、交易、定价信息等。对于遵从性策略和访问控制至关重要。
虽然软件即服务(SaaS)是一个很好的软件分发模型，它提供了已经在云中安装和配置的易于使用的产品，但它也存在一些挑战。
这些挑战是什么？
例如，SaaS 应用程序通常存储敏感信息，如客户的信用卡信息，但这也带来了潜在的 SaaS 安全风险。网络犯罪分子可能会出于恶意的原因试图破坏数据以获取这些信息或窃取凭据。
所有这些因素都构成了重大应用程序安全漏洞和数据泄露的威胁，这可能会导致法律和财务责任。这就是为什么对于企业来说，确保 SaaS 应用程序的安全性至关重要——保护客户的数据免受攻击者的攻击，并且不成为可能导致法律或财务问题的网络攻击的受害者。
以下是每个 SaaS 提供商为保护其应用而必须具备的一些基本安全控制措施:
保护 SaaS 应用程序的最佳实践
为了成功安全地保护您的 SaaS 应用程序，企业必须致力于实施一流的 SaaS 安全性。
通过评估 SaaS 应用程序环境中的应用程序安全风险和威胁，您可以了解应用程序的漏洞。
一旦确定了 SaaS 应用中的漏洞，您不仅可以保护易受攻击的热点，还可以采用更好的解决方案来保护您的 SaaS 应用，使其免受新的 SaaS 安全风险的威胁。
我们收集了一系列提高 SaaS 应用程序安全性的最佳实践和方法。这些将让您更好地了解如何在体验云服务带来的好处的同时，在您的 SaaS 应用程序中实现安全控制。
制定安全审查核对表
数据泄露会对您的公司造成不利影响，并且可能需要几个月甚至几年的时间才能从泄露造成的损害中恢复过来。
此外，如果数据泄露导致敏感信息丢失、品牌声誉下降或对您保护数据安全的能力失去信心，这可能是您公司成败的关键。
因此，企业必须创建一个清晰、简明的安全审查清单，以确保您的网络、设备和用户符合所需的安全标准。
安全审查核对表应该包括什么？
安全审查清单上可能包含许多内容。以下是一些宽泛的类别，可能涵盖了许多重要的网络安全方面:
管理
- 创造安全第一的文化。
- 制定强有力的安全策略，记录这些策略，并通过培训和技术控制来实施这些策略。
- 确保符合适当的合规框架以及自己的内部和外部审计
员工
- 实施强密码策略和多因素身份验证。
- 就最新的网络安全威胁以及如何有效应对这些威胁进行定期培训。
- 为所有员工举办安全意识培训，使安全成为共同的责任。
保护数据
- 根据用途和敏感度对数据进行分类，并针对每个分类级别适当地保护数据。
- 启用加密。
- 为每个客户端数据集使用单独的加密密钥，强制实施强数据分段。
- 安全网络、移动设备、计算机和存储设备。
- 加固所有设备。
- 定期扫描漏洞和与批准配置的偏差。
- 识别敏感数据，并对其使用和访问实施严格的策略。
- 为客户端启用多因素身份验证。
- 确保应用程序具有传输套接字层(TSL ),通过强大的算法、密钥长度和密码配置来保护数据传输。
- 通过强制最低权限访问来强制实施强用户访问控制。
- 确保实施强大的检测控制来识别恶意/可疑行为。
- 确保建立强大的审核日志记录，并将其输入到经过调整的事件和事件管理器中。
- 确保建立健全的事件响应计划和灾难恢复计划，并定期进行测试。
- 确保您拥有完全安全的软件开发生命周期(SDLC ),部署了自动扫描、威胁建模和安全专家的手动审查。
安全审查核对表可能因您使用的平台而异，但对于组织来说，定期审查并使用最新威胁更新核对表至关重要，这将有助于他们在保持质量的同时确定应用程序安全的优先级。
确保认证和审计的合规性
对于组织来说，关注像支付卡行业数据安全标准 (PCI DSS)这样的认证是至关重要的。这些认证有助于公司确保其敏感数据得到全面保护。
SaaS 提供商如何确保符合认证和审计要求？
对于 PCI DSS，SaaS 提供商必须执行全面的审核，以确保敏感数据以安全的方式传输、处理和存储。
它需要一个全面的安全标准，其中包含对云安全策略、程序、管理、网络架构、软件设计和其他重要保护措施的要求。
SaaS 提供商的另一项重要认证是系统和组织控制(SOC 2)II 型，该认证用于监督法规遵从性、供应商管理流程和内部风险管理流程。
它确保云服务得到部署和主动监控，以保持高安全性控制，从而确保数据安全。
这两项认证将保护您的组织免受数据泄露的影响，并确保维护适当的机密性和完整性。
实施数据保留策略
数据保留是 SaaS 应用程序安全性的一个重要方面。虽然许多 SaaS 应用程序有不同的保留策略，但有些应用程序没有任何可用的保留选项。
企业必须为其 SaaS 应用程序制定数据保留政策，尤其是在账户管理和订阅方面。
为什么这很重要？
您需要了解哪些数据需要保留。虽然法律要求将一些数据保留一段特定的时间，但其他数据可能对您的业务很重要，但不一定需要保留。
数据保留策略不仅有助于创建备份和释放文件空间，而且通常是法规遵从性的必要条件。
除了公司的内部合规性规则，还有一些法规和法律要求拥有云服务的公司制定数据保留政策。
例如 PCI DSS 和萨班斯-奥克斯利法案。遵守法律法规是企业非常关心的问题。对不合规行为的处罚从高额罚款到名誉损失不等。
确保安全部署
通过专门的 SaaS 供应商，如亚马逊或谷歌，他们通过提供安全的基础设施服务来帮助确保数据隔离、数据安全、网络安全等，共同承担保护 SaaS 应用的责任。
在我们的例子中，我们使用 Amazon Elastic Beanstalk，它允许我们将敏感凭证隔离到生产栈。所有其他开发者都不被允许访问这个环境，而只能使用他们在本地生成的开发证书。
自托管部署呢？
在自托管部署中，您必须确保采取适当的安全措施，并制定严格的应用程序安全策略来保护您的应用程序免受 DoS 攻击和网络渗透攻击。
如果您选择在公共云上部署 SaaS 应用程序，请确保遵循公共云供应商推荐的最佳实践和规范。
端到端加密传输数据
在 SaaS 应用程序中保护数据的另一个有效方法是对传输数据进行加密。
加密使您能够对数据进行编码，以防止未经授权或无法访问的用户对数据进行攻击。它通过提供完整性、不可否认性、机密性和身份验证来保护您的数据。
简而言之，即使未经授权的用户能够访问您的数据，如果没有加密密钥，他们也无法解码。
要加密传输数据，请确保与服务器的所有交互都通过 TLS(传输层安全性)传输进行。TLS 应仅在云服务提供商内部终止。
除了传输中的数据，存储中的数据也应该适当加密，以保护敏感信息。理想情况下，云服务提供商通常提供字段级加密，因此您可以选择想要加密的字段，并确保您的数据安全传输和存储。
监控用户级数据安全性
对于企业来说，监控用户级数据安全性以确保符合内部和外部应用程序安全标准至关重要。
您的云服务提供商可能会为您提供基于角色的访问控制(RBAC)功能，使您能够指定特定于用户的访问和其他操作权限。
其理念是将正确的访问权限授予正确的人，确保只有经过授权的个人才能访问 SaaS 应用程序上的数据。
这种系统能够实现精确的、基于访问控制的、强制的应用程序安全级别，该安全级别隔离用户以及用户如何访问企业内 SaaS 应用程序中的数据。
集成实时保护
SaaS 应用程序为最终用户提供了巨大的价值，因为它们易于安装和协作。
保护您的 SaaS 应用程序的最有效方法之一是集成实时监控，这将为您的 SaaS 应用程序提供更好的可见性、控制、策略管理和合规性，以保护您的数据不被暴露。
实时监控如何帮助保护 SaaS 应用程序？
SQL 注入、XSS 和账户接管等攻击是攻击 SaaS 产品的一些常用方法。
实时监控可以通过保护逻辑帮助您区分合法查询和恶意攻击。实时保护工具可以在开发阶段集成到代码中。
它帮助您在开发过程的早期检测攻击，并通过采取适当的措施来降低 SaaS 安全风险。
采用安全的软件开发生命周期(SDLC)
传统的 SDLC 侧重于满足特性和功能方面的需求。然而，在 SDLC 的不同阶段发生的一组动作可能并不总是本质上符合设定的应用安全标准。
要解决这个问题，可以考虑从开发阶段的开始就将安全性集成到 SDLC 的所有阶段。
在 SDLC 流程的早期嵌入安全性的想法是为了让安全性融入到流程中，而不是附加上去。
通过将安全性向左转移，也就是向开发阶段这样的初始阶段转移，您可以在 SDLC 的早期轻松地检测到应用程序中潜在的漏洞或弱点。
使用这种方法，您可以创建一个安全的应用程序，在其中您可以实现安全编码的最佳实践，尤其是在代码审查期间。
此外，在 SDLC 流程的早期实施安全指南有助于防止 SaaS 安全漏洞的侵入，并消除潜在的挫折。
准备好确保 SaaS 应用程序的安全性了吗？
SaaS 提供了各种好处，如降低成本和提高运营效率。然而，从合规到安全部署，采用 SaaS 安全实践至关重要，并确保您提前解决云安全挑战，以保护您的 SaaS 应用。
虽然这些问题大多源于我们对 SaaS 提供商如何存储我们的数据缺乏可见性和控制，但您必须遵循上述最佳实践，以确保您的 SaaS 应用程序的云安全。
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
如何确保您的数据科学项目每次都成功
在 2017 年的一项调查中，Gartner 分析师发现超过一半的数据科学项目从未部署。这可能会导致一些人认为数据、分析工具或潜在的 ML 模型中存在缺陷，但事实并非如此。在 Plotly，我们从经验中了解到，产品发布失败通常是因为无法将模型输出与实际业务或组织的后续步骤联系起来。
正如统计数据所显示的，这是整个行业的一个主要症结。为了帮助克服这一障碍，我们总结了多年来与客户合作的经验以及从 Plotly 社区听到的信息。它始终回到三个要点——如果你把这些做对了，你就能确保你的项目在每次开发时都有真正的商业影响。
首先，问正确的问题。这是一个典型的故事——另一个部门的一位同事带着一个数据集过来，他们问类似这样的问题:“我应该使用哪种图表类型？”那不是正确的方法。不要粗制滥造一些潜在无益的模型或图表，而是问问你的同事他们正在试图解决什么问题，理想的结果和目标是什么。理解你想问数据什么问题是关键。而且，成功项目的唯一途径是清楚地识别团队试图获得的知识，并从那里逆向工程出解决方案。
大多数团队已经转向 Python 或 R 作为他们在人工智能和数据科学计划中选择的语言，使用数据管理和机器学习(ML)模型构建的工具。这可能是最熟悉的领域，大多数团队都有自己选择的工具来完成这一步。这也是从模型到分析型 web 应用的第一步。
嗯，什么是分析型网络应用？将分析 web 应用程序视为模型和数据的前端。它明显不同于 BI 工具或仪表板，因为它使最终用户能够直接与模型和数据交互，而不需要理解代码。想象一下，给你的同事一个模型，他们可以通过交互式图形和 UI 控件进行研究，以执行自己的下游分析。
以分析应用为最终目标，第二步是构建合适的 UI 。一旦您充分理解了为什么一组特定的数据很重要，以及业务和组织合作伙伴希望对结果做些什么，您就可以专注于开发一个模型 UI，为您的分析提供最准确和最具探索性的视图。它更多的是关于开发和定制一种理解人工智能模型或数据集的方式，而不是呈现结果。随着您的受众需求的变化，让他们有机会接触数据。有许多工具可以帮助可视化数据，这些工具既美观又易于任何人理解和交互。找到一个对你和你的组织有用的，但是记住，你要的是交互式的，所以不要局限于静态的图表，这样其他人可以探索和试验。
第三步，定义应用程序的操作结构。通常情况下，模型、数据，甚至是交互式应用程序都可能会卡在某人机器上的笔记本中。这是大规模共享的主要障碍。解决方案(和挑战)是部署一个任何人都可以访问的独立应用程序——换句话说，释放数据。有效的解决方案考虑了供应、安全性、视觉设计/品牌和维护，允许用户通过将数据科学与实际业务结果相结合来真正实施关键项目。实现这个有很多方法，从耗时且昂贵的全栈开发团队，到帮助您自己完成这个任务的工具。同样，您需要找到适合您的部署流程。一旦你这样做了，你就成功地开发了一个端到端的过程。
现在是成为数据科学家的绝佳时机。社会几乎淹没在数据中，需要收集、整理、分析和操作的海量数据每天都呈指数级增长。最后一块——操作化数据和模型——是最重要的。在我们的工作中，我们必须确保我们不仅要展现洞察力，而且要以与业务和组织成功相关、易于理解、易于互动的方式来实现。
如何参加你的第一次 Kaggle 比赛
Arny Mogensen 在 Unsplash 上拍摄的照片
用 python 中的自然语言处理预测灾难微博
Kaggle 可能是最知名的机器学习竞赛网站。Kaggle 竞赛由网站上提供的数据集组成，其中包含一个要用机器、深度学习或其他数据科学技术解决的问题。一旦你开发出一个解决方案，你将把你的预测上传到网站上，根据你解决方案的成功，你将在竞赛排行榜上赢得一个位置，甚至可能获得现金奖励。
Kaggle 可以是一个磨练你的机器学习和数据科学技能的好地方，让你与他人进行比较，并学习新技术。在下面的文章中，我将提供一个如何第一次参加 Kaggle 比赛的演示。在本文中，我们将:
- 开发一个模型来预测一条推文是否是关于一场真正的灾难。
- 使用该模型对 Kaggle 提供的测试数据集进行预测。
- 第一次提交，就能登上 Kaggle 排行榜。
检测灾难微博
该网站上的最新比赛之一提供了一个数据集，其中包含推文以及一个标签，可以告诉我们它们是否真的是关于一场灾难。这项比赛有一个排行榜，有近 3000 个参赛项目，最高现金奖为 10，000 美元。数据和比赛大纲可以在这里查看。
如果您还没有 Kaggle 帐户，您可以在这里免费创建一个帐户。
如果您从竞赛页面选择“下载全部”,您将获得一个包含三个 CSV 文件的 zip 文件。
第一个包含一组用于训练目的的特征及其相应的目标标签。该数据集由以下属性组成:
- tweet 的数字标识符。当我们将预测上传到排行榜时，这将非常重要。
- 关键词:来自 tweet 的关键词，在某些情况下可能会丢失。
- 位置:发送推文的位置。这也可能不存在。
- 文本:推文的完整文本。
- 目标:这是我们试图预测的标签。如果推文确实是关于一场灾难，这将是 1，如果不是，这将是 0。
让我们阅读这些文件，并对它们有更多的了解。你会注意到在下面的代码中，我包含了一个set_option命令。熊猫 set_options 允许你控制数据帧结果的显示格式。我在这里包含了这个命令，以确保显示文本列的全部内容，这使得我的结果和分析更容易查看。
import pandas as pd
pd.set_option('display.max_colwidth', -1)train_data = pd.read_csv('train.csv')
train_data.head()
第二个数据集仅包含特性，对于该数据集，我们将预测目标标签，并使用结果在排行榜上获得一席之地。
test_data = pd.read_csv('test.csv')
test_data.head()
第三个例子展示了我们的提交文件应该是什么样子。这个文件将包含来自test.csv文件的 id 列和我们用模型预测的目标。一旦我们创建了此文件，我们将把它提交到网站，并在排行榜上获得一个位置。
sample_submission = pd.read_csv('sample_submission.csv')
sample_submission.head()
为机器学习准备数据
对于任何机器学习任务，在我们可以训练模型之前，我们必须执行一些数据清理和预处理。这在处理文本数据时尤其重要。
为了使我们的第一个模型简单，并且因为这些列中有很多缺失的数据，我们将放弃位置和关键字特征，只使用 tweet 中的实际文本进行训练。我们还将删除id列，因为这对训练模型没有用。
train_data = train_data.drop(['keyword', 'location', 'id'], axis=1)
train_data.head()
我们的数据集现在看起来像这样。
文本，尤其是推文，通常会包含许多对机器学习算法来说不一定有意义的特殊字符。因此，我采取的第一个步骤是删除这些。我也把所有的单词都变成小写。
import redef clean_text(df, text_field):
df[text_field] = df[text_field].str.lower()
df[text_field] = df[text_field].apply(lambda elem: re.sub(r"(@[A-Za-z0-9]+)|([^0-9A-Za-z \t])|(\w+:\/\/\S+)|^rt|http.+?", "", elem))
return dfdata_clean = clean_text(train_data, "text")data_clean.head()
另一个有用的文本清理过程是删除停用词。停用词是非常常用的词，通常没有什么意义。在英语中，这些词包括“the”、“it”和“as”等。如果我们将这些单词留在文本中，它们将产生大量噪声，这将使算法更难学习。
NLTK 是用于处理文本数据的 python 库和工具的集合，完整的文档可以在这里访问。除了处理工具之外，NLTK 还有大量的文本语料库和词汇资源，包括一个包含各种语言的所有停用词的语料库。我们将使用这个库从数据集中删除停用词。
NLTK 库可以通过 pip 安装。安装后，您需要导入库语料库，然后下载停用词文件。
import nltk.corpus
nltk.download('stopwords')
一旦这一步完成，你就可以读入停用词，并使用它从推文中删除它们。
from nltk.corpus import stopwords
stop = stopwords.words('english')data_clean['text'] = data_clean['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in (stop)]))data_clean.head()
数据预处理
清理后，数据需要进一步预处理，以准备在机器学习算法中使用。
所有机器学习算法都使用数学计算来映射特征中的模式，在我们的情况下是文本或单词，以及目标变量。因此，在可以训练机器学习模型之前，必须将文本转换成数字表示，以便可以执行这些计算。
这种类型的预处理有很多方法，但是在这个例子中，我将使用 scikit-learn 库中的两种方法。
这个过程的第一步是将数据分割成记号或单个单词，统计每个单词在文本中出现的频率，然后将这些计数表示为稀疏矩阵。计数矢量器函数实现了这一点。
下一步是对 CountVectoriser 产生的字数进行加权。应用这种加权的目的是按比例缩小文本中非常频繁出现的单词的影响，以便在模型训练期间，不太频繁出现并且可能更有信息的单词被认为是重要的。 TfidTransformer 可以执行此功能。
机器学习管道
让我们将所有这些预处理和模型拟合放在一个 scikit-learn 管道中，看看模型是如何执行的。对于第一次尝试，我使用线性支持向量机分类器(SGDClassifier ),因为这通常被认为是最好的文本分类算法之一。
from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(data_clean['text'],data_clean['target'],random_state = 0)from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.linear_model import SGDClassifierpipeline_sgd = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('nb', SGDClassifier()),
])model = pipeline_sgd.fit(X_train, y_train)
让我们使用训练好的模型来预测我们保留的测试数据，看看模型的表现如何。
from sklearn.metrics import classification_reporty_predict = model.predict(X_test)
print(classification_report(y_test, y_predict))
对于第一次尝试，该模型表现相当好。
首次提交
现在让我们看看模型在竞争测试数据集上的表现以及我们在排行榜上的排名。
首先，我们需要清理测试文件中的文本，并使用模型进行预测。下面的代码获取测试数据的副本，并执行我们应用于训练数据的相同清理。输出显示在代码下方。
submission_test_clean = test_data.copy()
submission_test_clean = clean_text(submission_test_clean, "text")
submission_test_clean['text'] = submission_test_clean['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in (stop)]))
submission_test_clean = submission_test_clean['text']
submission_test_clean.head()
接下来，我们使用模型来创建预测。
submission_test_pred = model.predict(submission_test_clean)
为了创建一个提交，我们需要构建一个数据帧，只包含来自测试集的 id 和我们的预测。
id_col = test_data['id']
submission_df_1 = pd.DataFrame({
"id": id_col,
"target": submission_test_pred})
submission_df_1.head()
最后，我们将其保存为 CSV 文件。包含index=False很重要，否则，索引将被保存在文件中的一列，您的提交将被拒绝。
submission_df_1.to_csv('submission_1.csv', index=False)
一旦我们有了 CSV 文件，我们可以返回到竞争页面，并选择提交预测按钮。这将打开一个表单，您可以在其中上传 CSV 文件。添加一些关于该方法的注释是一个好主意，这样您就有了以前提交的尝试的记录。
提交文件后，您将看到此屏幕。
现在我们已经成功提交了！
这个模型在排行榜上给我打了 0.78 分，排名 2371。显然有一些改进的空间，但现在我有一个未来提交的基准。
在这篇文章中，我概述了如何在 Kaggle 比赛中首次提交作品。在这一点上，你可以采取很多进一步的措施来改进。这包括更好地清理文本，不同的预处理方法，尝试其他机器学习算法，模型的超参数调整等等。
感谢阅读！
如何估算和降低机器学习产品的成本
一个简单的矩阵，用于确定您路线图上的下一个机器学习产品的成本。
深深困惑的产品经理。作者的插图。
动机
人工智能和机器学习产品出现在当今几乎任何公司的路线图上，并且趋势正在上升。但是很少有公司真正实现过十几个成功的产品。根据最近的一项研究， 65%投资于人工智能的公司还没有看到任何商业回报。在同一项研究中，高成本被认为是一个主要障碍。因此，让我们看看如何通过一个简单的矩阵来降低人工智能产品的成本并加快开发速度。
让我们看看你的公司。想过为你的企业建立一个推荐引擎会有多贵吗？或者预测你的流量负荷？还是对你的客服话单进行分类系统？
今天那些种类的产品都涉及机器学习。它们都是由机器学习工程师或数据科学家构建的。它们都有很大的用处。然而，估计成本，尤其是如果您的公司只实施了不到一打这样的产品，可能会相当令人难以承受。
ML 产品矩阵
在 Ville Tuulos 的一次演讲中，我偶然发现了四个类别，这些类别描述了当今机器学习解决方案的四个主要成本类别。在我看来，要了解像推荐引擎这样的产品的成本，你只需回答两个问题:
- 问题 1(批处理或实时):该产品是否需要处理接近实时的新数据，或者是否可以在批处理/少量时间流程中处理？
- 问题 2(延期成本):如果这个产品坏了，不能用了怎么办？延迟可以吗？还是严重的钱丢了？
机器学习产品成本类别矩阵。
对于每个象限，您可能能够想到一个适合该象限的典型产品。如果没有，不要担心，让我们详细探索所有这些象限，以及每个象限的相关成本。这似乎是显而易见的，所以让我们探讨一下主要的成本驱动因素、商业价值、一些例子，然后看看如何降低要求更高的产品的成本。
象限一，“实时”&“严重金钱损失”
网飞推荐引擎，基于你刚才看到的。
这些产品无时无刻不在接受数据，无时无刻不在进行推断。如果它们发生故障，将会造成严重的经济损失，工作流程受阻，无法做出决策。典型的例子是网飞个性化引擎。正是它为你提供了上述观点，当然还有其他许多方面，使网飞如此令人愉快。
它每运行一秒钟，就将网飞最重要的指标每秒开始的新视频数量增加几个百分点。事实上，在网飞上观看的所有视频中，大约有 70%是由于某种形式的推荐。但结果是，这个系统每一秒钟都不是实时运行的，它实际上花费了大量的金钱。每一秒它都要摄取你刚刚看的东西，更新它的推理过程。
另一个例子是汽车购买者的价格预测&经销商，如德国的" wirkaufendeinauto.de "。
具有约束估计的价格估计使得实时推断和更新变得至关重要。
汽车市场的价格非常不稳定，每天都在变化。因此，如果他们的定价系统没有正确预测，他们确实会赔钱。
象限一，业务价值和成本
通常，这种机器学习产品的商业价值是通过通常的产品经理魔术来计算的:
“CTR x 转换 x 转换值”。
代价:实时推理&更新很难。这类产品通常有两个主要的成本驱动因素:
- 使得服务(一些 dockerized API)高度可用。这主要是软件工程方面的内容。
- 使推理过程以及基于数据的更新成为实时的。这是机器学习的一面。
成本猜测:这些解决方案需要小型到大型团队不断努力。
象限二，“批量”&“严重资金损失”
让我们考虑这样一种情况，当然，这种情况成本较低，也就是说，如果我们没有实时约束，但可以采用批处理模式。
典型例子:客户邮件分类&分拣系统。这种系统从发送到“info@wordpress.com”的 1000 封电子邮件中提取信息，并将其分类成“队列”,然后由更专业的客户人员根据主题进行处理。如果某样东西没有被正确分类，那么人类必须对它进行分类。此外，通常会产生上下文切换成本。
该象限中的其他产品是用于营销的客户分类，以及客户流失预测等。对于所有这些产品来说，以一个小时这样的固定时间间隔进行批处理、排序、分类和预测，每周或每月使用新数据进行一次更新通常都没问题。
象限二，业务价值和成本
同样，对于商业价值，你可以用一个公式来计算，比如“获得一个活跃客户的可能性 x 终身价值”或者“分类节省的时间 x 价值”等等。
费用:
- 推理的 SLA。
- 开发成本，通常被分摊到相对较少的迭代中。
成本猜想:一个团队的工作，几个星期到几个月。不需要持续的工作，调优过程将需要几次迭代，但不会更多。
象限三，“实时”，“成本低”
典型例子:这些产品通常是给决策者看的。它们不在关键流程中，但如果利用这些信息做出决策，它们会产生非常大的影响。因此，现金流预测、总体层面的“客户观点的主要驱动因素”分析或“客户流失预测”都是很好的例子。
象限三，业务价值和成本
商业价值通常体现在可以做出的决策中。这些决策通常很难定价，因此这里的目标是与高管密切沟通，让他经常可靠地使用这些决策。
成本动因:
- 开发时间，你将需要几次迭代来使它工作，这样它确实被经常使用。与其他象限相比，这实际上是流程的很大一部分，实际上是让一个原型出门。
- SLA 几乎没有成本，因为决策者是今天还是明天查看这些数字并不重要。
费用猜想:一人几周。
象限四，“批量”&“成本低”
典型例子:数据科学独角兽。这是一个 jupyter 笔记本的原型，一个经过训练和评估的分析。甚至可能是一个 excel 结果列表。这是数据科学家在处理大型产品之前通常会产生的东西。但是，即使是那些一次性的静态结果也可以部署到完整的产品中。
象限四，业务价值和成本
商业价值:要么是纯粹的原型制作，“这能行吗？”；或者是对我们认为未来不会改变的事情的一次性分析，比如“让我们猜测一下 2020 年客户流失的主要因素”。
费用猜想: 1-几周，一对多数据科学家。
所以我们的完整矩阵是这样的:
四象限，独角兽是最便宜的产品。
。成本链是这样的:
独角兽< real time & cost high < batch & serious money < real-time heavy load thing.
但这如何帮助我让我的机器学习产品更便宜？
神奇的是几乎任何你目前想到的产品，你都可以选择一个更便宜的，在第一次迭代中有大致相同的商业价值。当然不是在以后的迭代中，但这是要点。您总是可以使用第一次迭代来获得反馈和对业务价值的更好的估计。
实时、高成本的产品:比如前面提到的“ wirkaufendeinauto.de 的销售算法。这个想法是，当你把车开到一家“wirkaufendeinauto.de”店时，他们需要一个这辆车明天会卖多少钱的准确估计。那么，除了根据价格数据每分钟更新一次，他们还能做什么呢？
让我们把它变成批量产品:当然，他们可以每晚开始批量生产。这意味着不使用日内价格变化。但是，估计还是很不错的。为了减轻这些影响，并使解决方案更加稳健，他们可以简单地对所有价格应用 1–2%的折扣来说明这一事实。
让我们进一步把它变成一批没有严重损失的产品:所以这个解决方案仍然很贵，我们可以通过不同的方式把它变成一个更便宜的解决方案。这怎么可能呢？你可以雇佣真正的人来做价格估算(例如，通过浏览一些网站)，让他们使用你的解决方案提供的“预计价格”，这个价格每天都会更新。这样，如果机器学习解决方案失败，人们仍然可以对汽车进行大致正确的定价，并且不会严重损失金钱。
最后，让我们看看作为一只独角兽我们可以从什么开始:当然，我们会先做一个非常粗略的猜测，然后交给做价格估算的人。他们可以使用“2020.01.01 的预计价格”,如果他们觉得有用，你将继续开发批处理过程。
使用同样的过程，你可以把几乎任何成熟的想法变成独角兽。
现在轮到你来打造你的机器学习产品了！
更多资源:
如何估算数据科学项目的数据收集成本
在在线市场的高进入壁垒和过时的 API 之间导航的技巧:在线租赁市场的案例研究
(注:所有观点均为本人)
介绍
数据收集是任何数据科学或分析项目的初始和基本步骤，从数据分析到模型部署，所有后续活动都依赖于数据收集。
随着 API 和云计算的普遍存在，我对最大化工作和个人项目数据收集活动的效率和自动化水平越来越感兴趣。
在后一个类别中，我一直对从英国市场的在线房屋租赁平台( Zoopla ， RightMove ， OnTheMarket 等)收集数据感兴趣，目的是提取图像和文本数据进行处理，以用于机器学习模型(例如预测房产价格、从图像数据中提取关键特征以推断房源的真实价值等用例)..)
在接下来的几行中，我将讨论如何着手:
- 最关键数据源的识别
- 如果您想将您的解决方案投入商业使用，数据收集成本的估算
我对这篇文章进行了更广泛的分析，它涉及到在围绕潜在商业目的的数据收集进行推理时要考虑的市场和监管问题，以及使用 API 的更多技术问题，因为我意识到在这个非常有趣的主题中有多个层面要讨论。
我希望以下要点将有助于您建立当前和未来数据科学项目的数据收集模块，无论您的行业重点是什么。
做你的市场调查，确定你的关键数据来源
在双边市场，如在线房屋租赁平台，由供需代理主导(在供应方，房主希望直接或通过房地产代理出租；在需求方面，个人寻求租赁)，你将在那些平台上找到数量和质量最多的数据，这些平台在给定的市场中驱动了大部分流量，来自供应和需求两方面。
从这个意义上来说，你需要确定哪些平台拥有最大的市场力量，因为它们吸引了最多的眼球。如果您希望在一段时间内获取大量数据，并且不希望集成来自较小市场参与者的多个数据流，那么了解市场整体流量/数据量的分布非常有用。
在英国的在线房屋租赁市场，大部分流量和房源分布在前 1-5 家公司之间，因此这些公司(下图中曲线的左侧)是您希望重点收集数据的公司。
帕累托原则。来源:Mode.com
这当然是一把双刃剑，因为在签订数据共享协议时，你将从中采购的大玩家拥有高杠杆，这允许他们:
1)充当特定市场的实际上的看门人，并制定自己的数据使用政策，尤其是在监管较少的市场情况下
2)签订数据共享协议时，每单位数据量多收费
3)有效监控初创公司对其核心业务的潜在竞争威胁，这些公司需要访问他们的数据，因此更加依赖他们的服务
与此同时，鉴于市场份额的不均衡分布以及缺乏反竞争监管，这是数据的真正价值所在，因此希望染指这些数据的有抱负的数据科学团队需要付出一定的代价来占领大部分市场并访问大量高质量的数据点。
注意:对于非商业或研究目的，您可能可以从这些网站上抓取数据(尽管这种活动在高频率和高容量的情况下并不总是受欢迎，这纯粹是出于实际考虑，我不鼓励在有政策禁止的网站上抓取网页，您最好遵守数据提供商的条款和条件)。
总是先寻找 API
一旦您确定了主要的数据源，您的第一个赌注就是浏览他们的开发人员资源并找出:
- 他们是否有一个活动的 API，您可以从中获取所需的数据
- 他们的总体数据共享条款和条件(T & Cs)是什么
例如，Zoopla 有一个 API 页面，可以用来返回一些特性和列表数据。Zoopla 的特定 API 已经有一段时间没有更新了，并且显然已经招致了之前在介质上记录的批评，但是这种类型的信息是你在比较不同数据源时想要寻找的。
当进入 RightMove 时，你会被引导到他们的官方网站上的数据服务页面。在撰写本文时，他们似乎没有或没有授权任何官方 API。OnTheMarket.com 似乎也没有任何空气污染指数。
检查主要参与者对于确定数据收集策略的下一步非常有用。如果您找到一个活动的 API 并决定:
- 数据量和质量是否足以满足您的应用
- 你是否违反了他们的 T & Cs
- 您是否想联系数据提供商(参见后续步骤)提交一份格式数据请求，以获得更多更丰富的数据集
- 是否转向市场中其他较小的参与者，这些参与者可能(通过他们自己的 API)给你足够的数据(其他聚合器，如 内斯特利亚 ，它们确实提供了一个)
无论如何，不要跳过这一步，因为它提供了非常有价值的信息，即使你没有立即得到你所需要的信息。
不要害怕与数据提供商联系，讨论潜在的数据共享协议
就我而言，我决定更深入一点，因此通过电子邮件和 LinkedIn，通过搜索分析职位和接触可行的潜在客户，初步接触了 RightMove & Zoopla。
我建议这样做，因为你总能在另一边找到对支持开发者感兴趣的人，并听到有趣的用例。你也可能发现以前在阅读各种文档时没有注意到的信息。
就我而言，我发现 RightMove 对他们的数据使用限制非常严格，因此我从他们那里真正得到的唯一东西就是冷淡。Zoopla 也是一样，它只是让我回到他们现有的 API，在用 Python 脚本简单测试后，我怀疑它的数据丰富性。
在这一点上，我决定在网上搜索，以确定已经利用了来自两个主要提供商之一的数据的应用程序和平台，并看看我是否可以提取更多信息，了解他们是如何做到这一点的，以及潜在的成本。
我本来也可以加倍下注 Zoopla & RightMove，决定提出一份数据共享协议，但作为一个个体，我在这样的对话中实际上能拥有多少筹码？
在您试图决定从哪里以及如何收集数据的类似情况下，我建议您:
- 花时间研究市场和各种数据提供商，给自己尽可能多的潜在数据源，这也将允许你比较他们的成本和你愿意分配给你的项目的预算
- 花时间与选择的几个供应商建立关系(如果他们不一定有明确的 API，比如在这种情况下),并从他们那里获取尽可能多的价格/其他信息，同时在计划使用他们的数据时也要非常透明(研究、商业、个人等)。)
利用在你之前收集数据的人的专业知识
在确定了您的主要数据源并检查了 API 及其使用潜力之后，您还需要接触其他正在利用这些数据源的市场参与者，看看您是否能发现更多的见解。
我发现这是一个不可思议的小步骤，可以获得一些关于数据收集成本的高质量上下文信息。
例如，我发现了一个很棒的网站， Property Data ，它引用了我正在寻找的相同的数据源，因此我立即使用他们的联系方式发送了一封电子邮件。
令我惊讶的是，这位创始人自己回复了，提到了一家提供商向 PropertyData 收取的费用，以获得他们需要的数据，并确认他们无法说服另一家提供商发送他们的数据，无论提出的价格是多少，从而证实了我之前通过电子邮件/LinkedIn 联系他们大多数人时的负面体验。
-(以下是我从 PropertyData 获得的电子邮件回复的摘录，出于保密原因，在可能的情况下进行了删节)-
“我们每月支付源 1 XX。那使我们得到了我们所需要的东西！
来源 2，再多的钱也不能让他们感兴趣！
属性数据"
这是很好的信息，因为:
- 在没有任何 API 或价格点的情况下，它为您提供了一个实际的估计金额，从中可以推断出类似提供商的数据收集成本。
- 利用他人的经验作为指南针，进一步指出哪些数据源更适合使用，哪些应该完全避免使用。
我总是建议花些时间去接触那些曾经做过的人，然后问一下，你可能会得到积极的、令人惊讶的、有益的回应！
运行您的估计并检查财务和技术可行性
至此，您应该已经收集了计算每月数据收集运行成本所需的所有信息，可以通过以下方式进行估算:
(数据源数量平均值。*API/数据协议的月订阅费用
为此，您可能希望考虑任何 云计算资源，这将取决于您的数据收集脚本和处理资源量(时间、数据大小驱动),您将利用这些资源将您的数据放入您的数据湖/数据仓库，以供以后处理和分析。
除了单纯的数字之外，此时你还应该对给定项目设置的方法的整体技术可行性有所了解，以及继续进行或完全改变你的数据收集策略是否有意义。
概括起来
拥有一套完善的数据收集方法和途径确实可以让您的数据科学项目以最佳方式启动和运行，同时根据您的市场领域知识和可用的数据提供商，以尽可能好的价格获得尽可能好的数据。
如果可以:
- 进行扎实的市场调查，确定最优质的来源
- 彻底检查现有的 API 及其(通常)丰富的文档
- 此外，联系数据提供商，解决潜在的数据请求，以及他们是否愿意为您提供帮助
- 通过询问在你之前有权访问数据的人和公司，进一步扩大你的知识库
- 对你实际将要花费多少时间和金钱来获取你需要的所有数据进行一个合理的估计
您可以大大增加开发可靠的数据收集方法的机会，并以有效的方式最大化获得大量数据的机会。感谢阅读！
访问我的免费数据科学资源清单 这里
[## 通过我的推荐链接加入 Medium-Edoardo Romani
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
edo-romani1.medium.com](https://edo-romani1.medium.com/membership)
使用 Bootstrap 策略估计中位数的标准误差
弗兰基·查马基在 Unsplash 上拍摄的照片
通过替换抽样得到经验分布
在这篇文章中，我将讨论我们可以用来估计中位数的标准误差的方法。我将首先说明一些定义，并讨论我们如何估计均值的标准误差。然后我会讨论如何用 bootstrap 策略估计介质的标准差。
标准误差是多少？
根据维基百科，统计数据的标准误差是其抽样分布的标准偏差或该标准偏差的估计值。在继续之前，这句话中有几个概念需要澄清:
首先，统计是参数的抽样估计。例如，样本均值 x_bar 是一个统计量，而总体均值是一个参数。因为通常是未知的，我们需要一个统计来估计它。x_bar 被认为是的无偏估计。
第二，标准差是离差的度量，是方差的平方根。它通常代表你估计的置信度，用于置信区间、假设检验等。
最后，抽样分布是来自随机样本的统计的概率分布。我们举个例子。假设我们正在估算美国大学毕业生的平均收入。人口是所有大学毕业生的收入。收集所有毕业生的数据并估计他们的收入几乎是不可能的。这就是为什么我们从总体中抽取有代表性的样本，并计算样本均值来估计总体均值。
平均值的标准误差(SEM)是多少？
由于有了 中心极限理论 ，估算平均值的标准误差变得简单明了。该理论指出，无论总体的分布是什么，随着样本量的增加，样本均值的抽样分布接近正态分布。此外，正态分布的均值等于总体均值，标准差等于总体标准差除以样本大小 n 的平方根。因此，如果总体标准差未知，则均值的标准差等于样本标准差除以样本大小 n 的平方根。给定任何随机分布，我们将很容易估计 SEM。
如何估计中位数的标准差？
不幸的是，中心极限理论不适用于中位数，因此我们需要其他方法来估计中位数的标准误差，只给定一个样本。这就是自举策略派上用场的时候。
引导程序正在使用替换进行采样。如果有样本:
我们可以从这个样本中取 n 个项目 替换 。在这里，我们将生成一个新的样本，它可以是:
样本大小等于 n。使用 bootstrap 策略估计标准误差的步骤如下:
1、从给定样本中取 n 项作为新样本:
从这个样本中，我们可以很容易地计算出样本的中位数:
2，对 B 轮重复前面的过程，我们将获得 B 个新样本，具有 B 个样本中值:
3，现在我们已经得到了中位数的经验分布，因此我们可以从中估计中位数的标准误差:
(1)计算前一个中位数样本的平均值:
(2)计算变化量:
(2)计算标准差，即经验样本的标准差:
为什么 bootstrap 在工作？
bootstrap 有效的原因是 bootstrap 使用经验分布函数(EDF)来估计人口的 CDF。样本的统计量是从总体中随机抽取的样本的函数。因此，它的分布将取决于人口的 CDF 和样本大小。虽然总体的 CDF 通常是未知的，但是我们可以使用 EDF 来估计它，从而得到样本的统计分布。我们可以在这里找到详细的数学解释，以及其他一些限制。
希望这有所帮助！感谢您的阅读！这是我所有博客帖子的列表。如果你感兴趣的话，可以去看看！
我快乐的地方
zzhu17.medium.com](https://zzhu17.medium.com/my-blog-posts-gallery-ac6e01fe5cc3) [## 阅读朱(以及媒体上成千上万的其他作家)的每一个故事
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
zzhu17.medium.com](https://zzhu17.medium.com/membership)
如何评价一个分类机器学习模型
准确度、精密度、ROC/AUC 和逻辑损失介绍
众所周知，机器学习模型的评估至关重要。它是衡量模型在准确度、精确度、召回率、性能等方面的有效性的过程。
在我以前的一篇文章中:
学术研究中的机器学习 v . s . Practical
https://towardsdatascience . com/machine-Learning-in-Academic-Research-v-s-Practical-5e7b 3642 fc 06
我提出以下阶段是典型的工业机器学习项目:
如上图所示，选择合适的评估指标是问题建模阶段的第一步，也是关键的一步。
由于我们需要选择合适的指标来评估机器学习模型，因此在为模型选择评估指标时，输出值类型是您需要考虑的最重要的因素。即，输出值是否
- 离散分类
- 连续值，或
- 等级
在本文中，我将介绍离散分类机器学习模型的三种最常用的评估指标。
精确度和召回率
布尔输出中通常使用精度和召回率。在我们能够很好地定义这两个概念之前，我们先来看看著名的“混淆矩阵”:
图片提供:https://towards data science . com/understanding-confusion-matrix-a9ad 42 dcfd 62
在上面的混淆矩阵中，
- TP(真阳性)表示实际结果和预测结果都是真的
- FP(假阳性)表示实际结果应该是假的，但是预测结果是真的，所以这是一个错误
- TN(真阴性)表示实际和预测结果都是假的
- FN(假阴性)表示实际结果应该为真，但预测结果为假
因此，很容易推导出:
精确度和召回率的定义
然后，我们可以将我们的精度(P)和召回率(R)定义如下:
理想情况下，这两个指标应尽可能高，以获得更好的性能。然而，大多数时候，这两者是相反的。也就是说，当你试图提高精度时，会导致更差的召回率，反之亦然。
这里举个极端的例子。假设你正在使用一个搜索引擎通过一些关键字搜索网页。如果搜索引擎只返回一个最相关的网页，我们认为准确率为 100%。然而，召回率将会非常低，因为将会有相当数量的网页是相关的(肯定的)但是被忽略了(假否定，FN)。让我们回到回忆的定义，TP 只有 1，但是 FN 非常大，所以分母非常大而提名者非常小。
另一方面，如果搜索引擎返回所有的网页(假设我们这里不做“检索”，简单地返回互联网上的所有网页)，召回率将是 100%，但精度将接近 0%。这是因为假阳性(FP)非常大。
因此，大多数时候，我们需要平衡这两个指标。在不同的场景中，我们可能会尝试改进其中任何一个，并在另一个上进行一些权衡。
平均精确度分数
有时我们可能会使用“平均精度分数”(AP)来衡量一个模型。
图片提供:https://stats . stack exchange . com/questions/345204/iso-f1-curve-for-precision-recall-curve
如图所示，我们使用 x 轴表示召回率，y 轴表示精确度。曲线产生了一个以蓝色显示的区域。通常，我们可以为所有模型生成这样的 AP 得分曲线，模型产生的大小越大，表明模型的性能越好。
然而，AP 也有一些缺点。例如，这种方法使用起来不太方便，因为我们需要计算曲线下的面积。因此，我们通常使用下面将要介绍的其他指标。
从精确度和召回率得出的其他指标
其中最常用的可能是 F 值。F1 的定义如下，它认为精度和召回率对模型同样重要。
在实践中，我们可能希望为精确度和召回率增加不同的权重。例如，如果我们认为回忆比精确重要𝛼倍，我们可以使用下面的等式来计算 F-measure。
此外，我们还可以测量准确率和错误率:
在科学和工程方面，准确度和精确度通常是指不同的概念。在本文中，我不会在这里详细讨论这一点，因为这不是重点。基本上，最显著的区别是精度是指布尔输出(真或假)，而精度可以应用于多个分类，例如:
在上面的公式中，
n是样本空间中的分类数P是计算具体分类精度的函数，可以独立定义
ROC 和 AUC
在实践中，有时我们可能不输出布尔值，而是输出一个概率。例如，患者有 99.3%的概率患有特定疾病。在这种情况下，如果我们坚持使用精度和召回，我们将不得不定义一个阈值。如果我们将 0.8 定义为阈值，那么每个大于 0.8 的预测都将被认为是正确的。那么，如果实际结果也是真的，这个预测就是真的正。
这有点不方便也不合适，因为门槛会
- 显著影响模型的评估
- 涉及另一个人为参数
- 降低模型在更一般问题中的性能
接收机工作特性
在这种情况下，ROC(接收器工作特性)曲线将更有效，因为它不需要这样的阈值。
在 ROC 曲线中，x 轴是假阳性率(FPR)，y 轴是真阳性率(TPR)，计算如下:
ROC 曲线如下所示:
图片提供:https://towardsdatascience . com/understanding-AUC-roc-curve-68b 2303 cc9 C5
如图所示，ROC 曲线越靠近左上角，该模型的性能越好。当左上角点的坐标为(0，1)，即 TPR=1，FPR=0 时，我们可以根据它们的公式推导出 FN 和 FP 都等于 0。因此，理想的情况是所有的测试样本都被正确分类。
ROC 曲线下面积
上图中还显示了 AUC(ROC 曲线下面积),其仅用作在不同模型之间进行比较以评估其性能的单一值。
ROC 曲线下面积的计算方法如其定义:
因此，AUC 是一个用于衡量多个模型表现的数字。
物流损失
逻辑损失(logloss)是分类问题中常用的另一种评估方法。基本思想是试图测量预测值(概率)和实际值之间的相似性的可能性。logloss 的原始形式是:
在我们的例子中，我们希望使用 logloss 函数来“最大化”预测值的分布与测试数据集中的原始分布相同的概率。假设我们的模型预测一个布尔输出，logloss 将如下:
在哪里
N是样本的数量y∈{0,1}，原始数据集中第 I 个值的真或假p是预测输出等于 1 的第 I 个样本的概率
Logloss 也可用于多类别分类问题，如下所示:
在这个等式中，C是类别的数量。
总结和提示
照片由 Aaron Burden 在 Unsplash 上拍摄
到目前为止，我们已经介绍了三种不同类型的评估指标，它们特别适用于分类机器学习模型:
- 精确度和召回率(平均精确度分数)
- ROC 和 AUC
- 逻辑损失函数
本文旨在介绍这些评估指标，而不是对它们进行比较，因为这可能会以期刊论文告终。但是，如果您希望知道如何在这三个指标中为您的分类模型选择一个合适的指标，我可以提供如下粗略的指导。
- 如果您正在处理类别极度不平衡的多分类问题，即某些类别的样本数量明显多于其他类别，您可以使用平均精度分数。
- 如果你认为你的预测等级或误差范围比预测产生多少误差更重要，你可能需要使用 ROC 和 AUC。
- 如果您确实关心预测的误差大小，而不是其分布，则应该使用逻辑损失来提高模型的误差敏感度。
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@qiuyujx/membership)
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)
如何评估数据科学候选人
意见
我与许多环境中的大量数据科学家合作过。一些人参加黑客马拉松、数据马拉松、Kaggle 竞赛、“为了好玩”的项目，以及作为多家公司的数据科学顾问。我也不得不申请我应得的工作。我认为评估数据科学家的最佳方法是应对基本的 python 挑战，我将在下面讨论这个案例。
一系列问题/挑战
考虑你的问题中的能力水平，你希望为你的候选人提出问题/挑战，淘汰最差的候选人，而不要有一个占用你或候选人大量时间来管理或评估的问题。
这里有一个选择难度的问题。如果你挑的东西太容易，所有人都会通过。还有拒绝合格申请人的额外风险。考虑下面我收到的问题:
在公司愿意让我进入下一轮之前，我必须回答这个问题和其他 99 个类似难度的问题。作为一名申请人，这告诉我 1)我们认为你没有能力掌握小学水平的数学 2)我们不太珍惜你的时间 3)我们不研究有趣或有挑战性的问题。最终，这个过滤器的问题是，你可能没有去掉很多不合格的人，你可能已经失去了对你最好的人才的兴趣。
现在，如果你选的东西太难，要么没人通过，要么你就要冒风险去问一个只有少数人有经验的特定问题。作为一名数据科学家，有太多的东西需要学习，如果你问一个关于数据科学中某个较窄领域的问题，不要认为这意味着他们精通所有领域，而其他候选人不擅长。如果你希望这个职位必须经常处理特定的技能/工具，那么有合适的问题/挑战是可以的，但是我建议确保工作描述(甚至可能是头衔)反映了对该技能/工具的需求。最后，如果你正在挑选一个非常难的问题，你可能没有能力给予部分信任。对你的问题给予部分肯定是有好处的，因为如果你真正想要的人接受了另一份工作，你就能知道谁是你的下一个最佳候选人。有了一个更简单的挑战，你就不必担心找到一个独特的问题，提供部分信用，并可用于许多申请人。
那么，为什么选择 Python 呢？
数据科学家的工作非常广泛。在一家公司，这可能意味着你正在制作可视化/仪表板，在另一家公司，你可能是制作模型的机器学习专家，而在另一家公司，你可能是恰好擅长将 ML 投入生产的软件工程师。但是，我相信不管是什么工作，python 都将是你的面包和黄油。我在上面说过，数据科学有许多子领域需要学习，不要用任何一个领域来代表其他领域的技能。我建议你使用 python 作为衡量标准，这似乎违反了这个规则，但我觉得不管申请人过去的经验如何，python 都是一个必不可少的工具，因此是最好的晴雨表。
当我在大学三年级申请第二次实习时，我面临一个现场编码挑战，基本上是说“给定一个数字数组，返回数组中每个数字的频率。”下面的例子。
input_array = [3, 6, 8, 2, 4, 8, 3, 1, 8, 9, 7, 0, 5, 5, 1]expected_output = {"0": 1, "1": 2, "2": 1, "3": 2, "4": 1, "5": 2, "6": 1, "7": 1, "8": 3, "9": 1}
我在不到 2 分钟的时间内成功完成了挑战，离开时感到有些失望，因为这不是一点点困难，所以我没有机会区分自己和我的能力。我确实得到并接受了那份实习工作，所以几个月后我问面试官:“为什么我被选中了？我觉得每个人都一定答对了这个问题。”令我惊讶的是，我被告知，在大约 50 名接受挑战的人中，只有 5 人答对了，而且只有我反应很快。令我惊讶的是，其他一些实习生候选人是博士生或计算机科学专业的学生。但我认为这个例子的目的是消除那些不能完成基本数据科学任务的人，而不会给申请人或面试官带来麻烦。
现在，我可能有偏见，因为我通过了那次面试，但其他人失败了，但我发现在数据科学项目中成功的限制因素通常是基本的编程能力。如果有人说他们在深度学习方面有经验，但他们不能从 JSON 对象中正确解析他们需要的数据，我并不特别在意。在任何项目的生产化过程中，良好的编程技能都非常适合您。
Python 提问
更具体地说，我认为你应该问的问题类型是 leetcode 类型的问题。如果你正在雇佣一个数据科学家，我不认为你应该期望他们也是一个精英软件工程师，记住我们实际上是试图快速检查最低能力。所以我不建议去解决最难的问题，我认为过滤掉简单的问题可能是最好的。从那时起，我可能甚至不关心解决方案的效率或时间复杂性，也许让这成为候选人之间的平局决胜。
如何评价机器学习模型在 Python 中的性能
机器学习，数据科学
一种实用的方法来计算模型的性能，并在 Python 中实现，涵盖了所有的数学推理
雪莉·胡利在 Unsplash 上的照片
欢迎光临！您是否准备好了在数百万个数据点上训练的酷机器学习模型，现在您想测试它的性能，但不知道从哪里开始，也不知道有什么更好的方法可以做到这一点？
在本文中，我们将讨论测试模型性能所需的一切，无论是分类模型还是回归模型，在本文中，我们将深入了解机器学习模型的评估过程，这对于机器学习工程师或数据科学家来说确实是非常关键的一步。
所以让我们开始吧！
分类算法评估
让我们从理解如何评估一个分类算法开始。分类模型将输出预测为类别标签。假设有一个随机变量' xᵢ '，那么 xᵢ 的预测值为' yᵢ '，标注为:
yᵢ∈{一班，二班，三班，…}
下面是一些非常有用的方法来衡量分类模型的性能。在我们下面的研究中，为了便于理解这个概念，我们将主要处理二元分类，这可以很容易地扩展到多类分类。
准确(性)
准确度告诉我们正确分类的数据点相对于总数据点的数量。顾名思义，准确性是指预测值与目标值的接近程度。
准确度=正确分类点数/总点数
但是由于假设的简单性，准确性并不总是模型评估的好方法。让我们看看这两个例子，在这两个例子中，精确度不是一个好的衡量标准。
- 不平衡数据:在现实世界的大多数问题中，类数据并不是均匀分布的，我们有一些高频率的类和一些低频率的类。例如，以癌症患者为例，假设 90%的数据是没有患癌症的人，而 10%的人被诊断患有癌症。因此，在这种情况下，即使是未经训练的基于规则的模型也可以预测所有的点为负面，并且可以达到 90%的准确性，这在许多情况下是非常危险的。这个问题可以通过使用本文后面部分讨论的 ROC-AUC 来解决。
- 概率估计:与其他测量不同，准确性不理解来自模型的概率值，而是只考虑二进制值。因此，对概率值分别为 97%和 3%的正值和负值进行分类的模型与另一个概率值为 62%和 38%的模型具有相同的精度，但我们知道第一个模型比第二个模型好得多，这里精度无法评估这一点。使用本文后面部分讨论的日志损失可以很容易地识别出这一点。
混淆矩阵
混淆矩阵是机器学习中许多评价方法的核心基础方法之一。混淆矩阵是分类模型的一个“ n 维矩阵，它在 x 轴上标注实际值，在 y 轴上标注预测值。
通常对于二元分类器，混淆矩阵是一个 2x2 维矩阵，其中 0 为负类， 1 为正类。
对于一个好的模型，混淆矩阵的主对角线元素应该是高值，非对角线元素应该是低值。
混淆矩阵中的每个单元对于理解模型的性能都起着非常重要的作用。 TN 、 FN 、 FP 、 TP 是根据每个单元格在该单元格中的实际值和预测值给每个单元格起的名字。让我们一个一个地理解它们，然后我们会从它们身上发现一些惊人的联系。
图 1:二元分类器的混淆矩阵。
TN =真阴性(实际为阴性且被模型正确分类为阴性类别的数据)。
FN =假阴性(实际为阳性但被模型错误分类为阴性的数据)。
FP =假阳性(实际为阴性但被模型错误分类为阳性的数据)。
TP =真阳性(实际为阳性且被模型正确分类为阳性类别的数据)。
如何记住它们？
有一个简单的方法来记住它们，的第一个字母回答了问题“我们是正确的吗？和第二个字母讲述的是预测值。
这些符号之间有一些惊人的关系，对我们的评估非常有用。在此之前，让我们看看什么是实际正和实际负值。
图 2:混淆矩阵中的负值和正值
阳性(P) :假阴性值和真阳性值之和就是数据中实际的一组正值。P = FN+TP
Negative (N) :真负值和假正值之和就是数据中实际的一组正值。 N = TN+FP
现在我们知道了单元符号和正负符号，有 4 个重要的测量值是使用这些符号计算的，它们对于模型性能估计非常有用。它们如下:
- 真阳性率(TPR) :真阳性/总阳性= TP/P
- 真阴性率(TNR) :真阴性/总阴性= TN/N
- 假阳性率(FPR) :假阳性/总阴性= FP/N
- 假阴性率:假阴性/总阳性= FN/P
它们听起来有点令人困惑，但当我们查看困惑矩阵，并形象地找到这些关系时，它们就开始给出某种意义了。
对于一个执行良好的车型【TPR 和 TNR 应该是高值】【FPR 和 FNR 应该是低值】 。
TPR⬆、TNR⬆、FPR⬇、FNR⬇
精确度和召回率
精确度和召回率主要用于信息检索的情况。对于二进制分类问题，这两个度量主要集中在正类上。对，正课。现在，让我们来看看关于图 3 中的混淆矩阵的精确度和召回率的公式。我们可以清楚地看到，精确度和召回率的全部焦点都在混淆矩阵的真阳性单元上，它们与真阴性无关。
图 3:使用混淆矩阵的精确和回忆理解
精度:在所有模型预测为正的点中，有多少是真的正。
精度= TP / (TP+FP)
回忆:在所有实际上积极的点中，有多少是模型预测为积极的。
回忆= TPR = TP / P = TP / (TP+FN)
Precision 和 Recall 两个值都在[0，1]的范围内，我们总是希望这两个值尽可能的高。有时，将两个不同的值结合起来比单独分析它们更好，因此为了将它们结合起来，我们有一个名为 F1-score 的指标，即 “精确度和召回率的调和平均值”。
f1-得分= 2 精度召回/(精度+召回)
在 Kaggle.com的一些比赛中，F1 分数有时被用作模型评估的指标，但用简单的英语理解有点困难，而精确度和召回率则更容易解释。
让我们在 Python 3.x 中实现它。下面是使用混淆矩阵的模型评估的手动实现。
下面是上述代码实现的示例输出。
使用混淆矩阵的评估输出示例
ROC 曲线和 AUC
接收机工作特性曲线 或 ROC 是 TPR 对 FPR 的曲线图，形成一条曲线，代表不同阈值的 TPR 和 FPR 值“ 𝜏 ”。AUC 是曲线下的面积。它们有时合在一起称为 AUROC(受试者工作特性下的面积)曲线。****
图 4:来源:接收机工作特性曲线维基百科
给定一个阈值参数 𝜏 ，如果 X > 𝜏 该实例被归类为 正类 ，如果 X < =𝜏 则归类为 负类 。如果实例实际上属于，则 x 遵循概率密度 f1(x) ，如果实例属于负类，则遵循概率密度 f0(x) 。因此，真实阳性率由下式给出:**
使用 ROC 的 TPR
假阳性率由下式给出:
FPR 使用 ROC
ROC 曲线参数化地绘制了 TPR(𝜏)对fpr(𝜏，阈值 𝜏 作为曲线上的变化参数，给出了类似于图 4 接收器工作特性曲线所示的形状。
AUC 是曲线下的面积。 AUC 位于【0，1】范围内。0.5的值表示模型的性能是随机的**。在[0.5，1]范围内的 AUC 值表明模型表现良好，而在[0，0.5]范围内的 AUC 值表明模型表现不佳。****
"AUC 值越高，模型表现越好。"
AUC 值低于 0.5 怎么处理？
当 AUC 在[0，0.5]范围内时，有一个非常简单的技巧来处理模型性能。绝招::简单切换模型预测的类别标签。“是的，假设我们得到的 AUC 为 0.32，那么在将类别标签从 0 切换到 1 和从 1 切换到 0 之后，我们得到的 AUC 值为 1–0.32 =0.68，这使它成为一个好模型。就这么简单！**
使用对数损失计算概率分数！
Log-Loss 用于发现二元分类算法的模型性能，该算法可以容易地扩展到多类分类。它考虑由机器学习模型预测的所有概率分数，并使用下面图 5 中的公式计算相对于' yᵢ '的真实值和预测值' p(yᵢ) '的损失。
图 5:测井损失计算公式
理解这个公式很简单，对于每个 yᵢ=1 ，值log(p(yᵢ)】被加到损失上，而对于每个 yᵢ=0 值log(1-p(yᵢ)】被加到损失上，然后通过将计算的总和除以 N (数据点的数量)来计算平均值。
简单地说，对数损失是平均负对数(正确分类标签的概率)
简而言之，我们可以说，当'【p(yᵢ】)'较低时，这意味着模型预测''的值更不确定，那么对它的惩罚就更多，对数损失也更多，反之亦然。
预测概率⬇对数损失⬆
预测概率⬆对数损失⬇
查看下图 6，了解预测概率和测井曲线损失之间的反比关系。
图 6:与预测概率相关的测井曲线的来源图像
- 因此，我们需要 Log-Loss 尽可能小才能说我们的模型表现良好。
- 对数损耗可以在【0，INF】的范围内，如图 6 所示。****
也就是说，现在让我们看看如何实现日志丢失。下面是 Python3 中的代码实现。
但是 Scikit-learn 提供了一行输入来计算日志损失，
使用 Log-Loss 的一个缺点是有点难以解释，因为我们不能仅仅通过看到 Log-Loss 的一些值来说什么。这是因为对数损耗并不限定输出值的范围，而是从 0 到无穷大。例如，如果我们得到一个 Log-Loss = 12 的值，那么仅仅通过看到这个值，我们不能说什么。
回归算法评估
分类和回归算法的区别在于分类的输出属于一个类，而回归算法的输出属于实数，如 yᵢ ∈ ℝ 。
设 yᵢ 是输入 xᵢ 的实值输出，而 ŷᵢ (y-hat)是回归算法的预测实值输出。因此，误差 eᵢ 计算如下:
eᵢ=yᵢ—ŷᵢ****
因此，让我们看看用于回归模型性能测量的各种类型的模型评估技术。
r 或决定系数
先来了解一下平方和 ( SS )是一个随机变量' xᵢ '的' yᵢ '的方差值之和。这里' ȳ '(y-bar)是所有' yᵢ '的值的的意思。****
平方和ₜₒₜₐₗ=σ(yᵢ+ȳ)****
简单来说，平方和( SS- total )是其真实值相对于其平均值的误差平方和。
而且，
平方和ᵣₑₛ=σ(yᵢ+ŷᵢ)****
平方和( SS- residue )是其真实值相对于其预测值的误差平方和。****
所以，R 被定义为，
R = 1 - (SSᵣₑₛ / SSₜₒₜₐₗ)
让我们考虑几个案例，基于这些案例，当我们看到 R 值时，我们可以获得关于模型性能的一些直觉。
- 如果误差 e =σ(yᵢ+ŷᵢ)为 0 那么，r 为 1 ( 为最佳值)。
- 如果 SSᵣₑₛ < SSₜₒₜₐₗ then R² lied between 0 和 1 (一般接受)。
- 如果 SSᵣₑₛ = SSₜₒₜₐₗ，那么 r 就变成了 0 (性能不好)。
- 如果 SSᵣₑₛ > SSₜₒₜₐₗ，那么 r 变成负的值(最差性能)。
让我们看看 Python3 中 R 的实现
https://gist . github . com/paras 009/b 46 ded 4 f1 ea 24 ab 48508623 f 6024294 b
Scikit-Learn 为 compute R 提供了一个单行导入。
https://gist . github . com/paras 009/229 ad 9 ba 3a 7595 b 26 ba 8 bfb 7 e 179 c 379
需要注意的重要一点是，R 在某些情况下表现不佳:
有异常值的数据 : 如果数据中有一些异常值，那么 R 不是计算回归模型性能的一个很好的方法，误差值会立即增加，并反过来严重影响 R 值。因此，在这种情况下，我们将使用下一节讨论的中值绝对偏差的概念。****
中位数绝对偏差
由于异常值对误差“ eᵢ ”有很大影响，因此 MAD 通过计算所有误差值的中值并计算它们与每个误差值的绝对偏差来解决这个问题，这有助于计算 MAD 值，从而消除异常值对误差值的影响。
MAD =中位数(|eᵢ—中位数( eᵢ )|)****
中位数和 MAD 对异常值稳健。中值和 MAD 的较小值表明该模型表现非常好。请记住，我们可以使用均值或标准差，但它们不能处理异常值，而 MAD 对异常值没有显著影响。
注:绘制误差分布图有助于理解异常值以及误差值是如何传播的。分布“右偏越多，模型表现越好。这意味着大多数点的误差较低，只有极少数点的误差值较高，这些误差值并不显著，可以使用 MAD 进行归一化。****
概率与误差图
所以，就这样，我们到了这篇文章的结尾。现在，你可以放心大胆地评估你的模型了！
来源:https://media.giphy.com/media/5nkIn9AEfUQ6JtXL43/source.gif
参考
- https://en . Wikipedia . org/wiki/Evaluation _ of _ binary _ classifiers
- https://en.wikipedia.org/wiki/Confusion_matrix
- https://en . Wikipedia . org/wiki/Receiver _ operating _ character istic
- https://en . Wikipedia . org/wiki/Loss _ functions _ for _ class ification
- https://en.wikipedia.org/wiki/Coefficient_of_determination
- https://en.wikipedia.org/wiki/Median_absolute_deviation
更多关于机器学习的文章:
KNN 算法背后的科学解释！
towardsdatascience.com](/k-nearest-neighbour-explained-part-1-5e5e9192050) [## Q-Q 图解释
探索 Q-Q 图的力量。
medium.com](https://medium.com/@pv009/q-q-plots-explained-5aa8495426c0) [## “正态分布”的功效
理解钟形曲线背后的科学！
medium.com](https://medium.com/@pv009/the-powers-of-normal-distribution-4cbb06e4a955)
还有更多在 Paras Varshney 的。
如果你从这篇文章中学到了新的东西或者喜欢阅读它，那么就分享出来，让其他人也能感受到。欢迎给我留言。
谢谢！******
如何评价文本生成模型？自然语言处理模型自动评估的度量
实践教程
文本生成是一个棘手的领域。学术界和工业界仍在为评估生成模型质量的相关指标而努力。每一个生成任务都是不同的，都有自己的微妙之处和独特之处——对话系统有不同于总结的目标指标，机器翻译也是如此。
我将讨论 NLP 中用于比较生成性或提取性任务的度量，其中要比较两个文本。我将在此讨论的指标可应用于以下任务:
- 短格式或长格式文本生成
- 机器翻译
- 总结
- 聊天机器人和对话系统
- 问题回答
- 释义系统
- 多媒体系统，如语音 2 文本、图像字幕、自动视频配音
首先，让我们来谈谈这篇文章中的一些常用术语。在 NLG，为了检查评估，机器生成的文本通常根据目标文本(真值)进行评估。这个 目标文本 是期望模型理想生成的文本。 生成文本 指机器产生的文本(模型的输出)，而 目标或参考文本 指原始真值文本。其他一些基本术语是 n-gram 和单词建模包，它们是基本的 NLP 概念/术语。如果你还不知道他们，你可以在网上了解更多。我还展示了用 python 计算这些指标的代码片段。
BLEU:双语评估替角分数
BLEU 和 Rouge 是最流行的评估指标，用于比较 NLG 领域的模型。每一份 NLG 的报纸肯定都会报道标准数据集上的这些指标，永远如此。BLEU 是一个专注于精度的指标，它计算参考文本和生成文本的 n 元语法重叠。这种 n 元语法重叠意味着除了 n 元语法的术语关联之外，评估方案是独立于单词位置的。在 BLEU 中需要注意的一点是——有一个简短的惩罚，即当生成的文本与目标文本相比太小时应用的惩罚。
下面是使用 python 的 ntlk 库计算 BLEU 的代码片段。
胭脂:回忆导向的吉斯丁评价替角
如前所述，Rouge 是另一个被广泛报道的指标。报告标准任务的 Rouge 和 BLEU 分数是一种非常常见的做法。它非常类似于 BLEU 的定义，不同之处在于 胭脂是回忆聚焦的，而 BLEU 是精确聚焦的 。有 3 种类型的胭脂:n-胭脂，最常见的胭脂类型，这意味着 n-gram 重叠。例如(2-胭脂，1-胭脂分别代表 2 克和 1 克)。第二个是 l-rouge，它检查最长的公共子序列，而不是 n-gram 重叠。第三个是以跳克为主的 s-rouge。这些的标准实现可以在大多数 ML 库中找到，n-rouge 是最常用的。下面是 n-rouge 的原始源代码。
困惑
困惑是一种常用于评估生成模型有效性的度量，它被用作由数据集上训练的模型产生句子的概率的度量。在信息论中，困惑是指概率分布对样本进行预测或分配概率的能力。困惑值越低，模型越好。困惑是根据句子的长度来标准化的。
这里 T 是句子中的总字数。
对于语言模型，我们最终想要检查测试集上的困惑值，并选择这个度量具有最低值的模型。这意味着—选择分配高概率的概率模型来建模/生成测试集语句。
如果模型是完全哑的(最坏的可能)，困惑= |v|即词汇量的大小。
困惑是一个依赖于模型的分数。大多数创成式模型实现/库都会提供现成的。否则，你基本上需要根据特定的语言模型来计算句子中每个单词的概率，就像上面的公式所示。
LSA:潜在语义分析
LSA 用于根据两个文本中包含的单词计算两个文本的语义相似度。它使用预先计算的大型语料库中的单词共现计数。它使用单词包(BOW)方法来完成，这与单词位置无关。与其他指标不同，它不会过多地惩罚单词选择的变化，即该指标对“好”和“不错”比较宽容，而 rouge 和 bleu 则不会。
本质上，LSA 是一种使用单词包方法将句子/文档编码成向量的方法。使用这些向量，我们可以计算相似性度量(余弦)来检查生成的文本和目标文本的相似性。关于 LSA 度规的详细解释在这里给出。
METEOR:使用显式排序评估翻译的度量
METEOR 是一个不常见的度量标准，用于单词对齐。它计算生成文本和参考文本中单词的一对一映射。传统上，它使用 WordNet 或 porter stemmer。最后，它根据这些映射计算 F 分数。Meteor 在 NLG 是一个相对较少使用的指标，尤其是在深度学习模型起飞之后。
这里给出了计算 meteor 的代码，由 metric 的作者用 java 实现。
TER:翻译编辑率
TER 的工作原理是将生成的文本转换成目标文本。它通过计算将一个字符串转换为另一个字符串所需的操作次数来衡量字符串之间的绝对差异。它紧密基于编辑距离算法
这就是 NLG 常用指标的列表。为了计算所有提到的分数，下面是代码。
我希望这有助于呈现可能对您有用的可能指标的概述。如果你需要更全面的解释，你可以在网上了解更多。
如何评价无监督学习模型
数字音乐
韩国流行音乐和古典音乐到底有多大的不同？
一个音乐集群。视频:像素
所以到目前为止，在这个博客系列中，我们已经研究了如何通过聚集一组曲目来创建自动的歌曲播放列表，完全基于它们的音频特征。之前，我们制作了一个包含 32 首歌曲的玩具示例，并展示了分层凝聚聚类 (HAC)如何自动创建相似歌曲的子组。我们能够通过我们现有的歌曲知识来验证这一聚类练习的结果(我们的算法确认motrhead和黑色安息日在音乐上是相似的——请看图)。
但是如果我们没有这些先验知识呢？如果数据甚至没有被标记(许多现实生活中的聚类情况就是如此)，那会怎么样呢？即使是，如果这些标签最初对我们来说毫无意义呢？有很多我从未听说过的艺术家，如果我们试图将数千首曲目分组，那么手动验证每一组显然是不切实际的。在这些情况下，我们需要某种数学方法来衡量我们的聚类有多“成功”。
为了探索我们可能如何去做这件事，我们再次求助于 Spotify 的 API。假设我们从四个非常不同的播放列表中选取歌曲:
如果我们将这些合并成一个数据集，一个无监督的机器学习算法应该能够将他们的歌曲分成四个集群，这四个集群有点类似于最初的四个播放列表。
在我们开始之前，我们可能确实想要检查我们的假设，即来自这些不同播放列表的歌曲确实是“不同的”。当然，在一张图表上同时显示两个以上的特征是具有挑战性的。然而，如果我们绘制一个所有特征的散点图，按播放列表进行颜色编码，我们可以看到有大量的度量组合来展示每个流派的独特特征。
我们在之前的博客中看到，在 Scikit-Learn 中运行聚类算法非常简单:
**#We scale the data to ensure that
#feature units don't impact distances
from** sklearn.preprocessing **import** StandardScaler
sclaer = StandardScaler()
X_scaled = scaler.fit_transform(X)***#This scaled data can then be fed into the HAC algorithm* from** sklearn.cluster **import** AgglomerativeClustering
***#We can tell it how many clusters we're aiming for***
agg_clust = AgglomerativeClustering(n_clusters=4)
assigned_clusters = agg_clust.fit_predict(X_scaled)
我们还看到 HAC 有三种不同的“链接标准”——算法通过这种方法将集群连接在一起:
- ward (默认):选择两个聚类进行合并，使所有聚类内的方差增加最小。一般来说，这导致集群的大小相当一致。
- 完全(或最大链接):合并两个点之间具有最小 最大 距离的簇。
- 平均:合并所有点之间 平均 距离最小的两个聚类。
让我们看看这三个链接标准是如何处理流派播放列表数据集的。我们用一个矩阵表示我们的结果，显示每个播放列表中的歌曲在每个集群中的百分比(集群被随意命名为“A”、“B”、“C”和“D”)。
当然，如果聚类是完美的，我们希望矩阵的每一行和每一列都包含一个 100%的条目(当然，它不必在对角线上，因为聚类名称的分配是任意的)。
默认的“ward”链接试图最小化集群内的差异，在所有四种类型中都做得很好，尽管有一些泄漏到集群 b 中。
“完全”联动显然效果不佳。它已将大量数据集放入聚类 a。聚类 C 由一首说唱歌曲组成。
“平均”关联与“完全”关联有相似的问题。许多数据点被放入一个集群中，两个集群由一首歌曲组成。
值得一提的是，还有另一种常见的聚类类型，K-Means，它的工作方式略有不同。HAC 通过将聚类合并在一起来迭代地减少聚类的数量，而 K-Means 聚类保持固定数量的聚类(名义上的 k )，但是迭代地改变每个聚类的成员。
每个聚类的“中心”由带有黑色“+”号的“大”标记表示。所有的点都被分配到离其中心最近的聚类中。在这个分配步骤之后，重新计算聚类中心以包括新成员，并且发生另一个重新分配步骤。如果在重新分配步骤中没有点改变聚类，则算法结束(动画:维基百科)。
K-Means 在 Python 中实现起来很简单:
**#We scale the data to ensure that
#feature units don't impact distances
from** sklearn.preprocessing **import** StandardScaler
sclaer = StandardScaler()
X_scaled = scaler.fit_transform(X)***#This scaled data can then be fed into the K-Means alorithm* from** sklearn.cluster **import** KMeans
***#We can tell it how many clusters we're aiming for***
km_clust = KMeans(n_clusters=4)
assigned_clusters = km_clust.fit_predict(X_scaled)
如果我们对播放列表数据集应用 K-Means 聚类，我们会得到以下结果:
与使用“ward”链接的 HAC 算法一样，K-Means 聚类在大多数算法中都做得很好，一些爵士乐和说唱歌曲被“误认为”K-Pop。
虽然这些矩阵有利于“目测”我们的结果，但它们远非数学上的严格。让我们考虑一些指标，以实际帮助我们为集群质量分配一个数字。
调整后的兰德指数
调整后的 Rand 指数是经典 Rand 指数的变体，并试图表达多少比例的聚类分配是“正确的”。它通过考虑所有样本对，计算两个不同聚类之间的相似性度量，并针对真实聚类对分配到相同或不同预测聚类中的样本对进行计数，针对随机机会进行调整。
这一点(以及我们将考虑的其他指标)可以使用 Scikit-Learn 进行评估。
**from** sklearn **import** metricsmetrics.adjusted_rand_score(predicted_labels, actual)
调整后的 Rand 指数介于-1 和 1 之间。越接近 1 越好，越接近-1 越不好。
我们看到 K-Means 和 Ward Linkage 得分很高。根据我们之前观察到的矩阵，我们预料到了这一点。
福克斯·马洛得分
Fowlkes Mallow 评分也是类似的，因为它告诉你聚类分配的“正确”程度。特别地，它计算精确度和召回率之间的几何平均值。它介于 0 和 1 之间，值越高越好。
metrics.fowlkes_mallows_score(predicted_labels, actual)
我们的排名类似于调整后的兰德指数——这是我们所期望的，因为它们是试图回答同一个问题的两种方法。
值得注意的是，为了计算这些指标，我们需要知道原始标签。考虑到处理未标记数据是无监督学习的主要用例之一，我们需要一些其他度量来评估聚类结果，而不需要参考“真实”标签。
假设我们从三个独立的聚类分析中得到以下结果。
显然，我们能使集群越“紧密”越好。有什么方法可以把这个“紧密”的概念归结为一个数字吗？
剪影分数
剪影分数试图描述一个数据点与其聚类中的其他数据点的相似程度，相对于其聚类中的数据点而非(这是对所有数据点的汇总，以获得整体聚类的分数)。换句话说，它考虑的是星团在空间中的“独特性”——事实上，人们可以使用任何“距离”来计算分数。
它介于-1 和 1 之间。更接近-1 表示聚类不正确，而更接近+1 表示每个聚类都非常密集。
metrics.silhouette_score(scaled_feature_data, cluster_labels)
我们看到没有一个集群有超高的轮廓分数。有趣的是，我们看到平均连锁群得分最高。但是，请记住，这种算法产生了两个集群，每个集群只包含一个数据点，这在现实世界中不太可能是一个理想的结果(这是一个教训，您通常不能依赖单个指标来决定算法的质量！)
卡林斯基哈拉巴兹指数
卡林斯基哈拉巴兹指数是一个数据点相对于其他聚类中的点的方差与相对于其聚类内的点的方差的比率。因为我们希望第一部分高，第二部分低，所以高 CH 指数是理想的。与我们看到的其他指标不同，这个分数是没有界限的。
metrics.calinski_harabasz_score(scaled_feature_data, cluster_labels)
这里我们看到我们的 K-Means 和 Ward 连锁算法得分很高。完整和平均连锁算法因具有一个或两个较大的聚类而受到惩罚，这将具有较高水平的内部方差。
这是我的“数字音乐”专栏中的最新博客，它使用数据讲述关于音乐的故事。我很乐意听到对上述分析的任何评论——欢迎在下面留言，或通过 LinkedIn 联系我！
如何评价来自 python 的 Vespa 排名函数
使用 pyvespa 评估 cord19 搜索应用当前生产中的排名功能。
这是一系列博客文章中的第二篇，将向您展示如何改进文本搜索应用程序，从下载数据到微调 BERT 模型。
前一篇文章展示了如何下载和解析 TREC-科维德数据。这一次将重点评估在 cord19 搜索应用中可用的两个查询模型。这些模型将作为未来改进的基准。
您也可以从 Google Colab 运行这里包含的步骤。
下载处理过的数据
我们可以从下载我们在之前已经处理过的数据开始。
import requests, json
from pandas import read_csv
topics = json.loads(requests.get(
"https://thigm85.github.io/data/cord19/topics.json").text
)
relevance_data = read_csv(
"https://thigm85.github.io/data/cord19/relevance_data.csv"
)
topics包含 50 个可用主题的数据，包括query、question和narrative。
topics["1"]{'query': 'coronavirus origin',
'question': 'what is the origin of COVID-19',
'narrative': "seeking range of information about the SARS-CoV-2 virus's origin, including its evolution, animal source, and first transmission into humans"}
relevance_data包含 50 个主题中每个主题的相关性判断。
relevance_data.head(5)
安装 pyvespa
我们将使用 pyvespa 来评估 python 中的排名函数。
!pip install pyvespa
pyvespa给 Vespa 提供一个 python API。它允许我们创建、修改、部署正在运行的 Vespa 实例，并与之进行交互。该库的主要目标是允许更快的原型开发，并促进 Vespa 应用程序的机器学习实验。
将带标签的数据格式化为预期的 pyvespa 格式
pyvespa期望带标签的数据遵循如下所示的格式。这是一个字典列表，其中每个字典代表一个包含query_id、query和一个relevant_docs列表的查询。每个相关文件包含一个必需的id键和一个可选的score键。
labeled_data = [
{
'query_id': 1,
'query': 'coronavirus origin',
'relevant_docs': [{'id': '005b2j4b', 'score': 2}, {'id': '00fmeepz', 'score': 1}]
},
{
'query_id': 2,
'query': 'coronavirus response to weather changes',
'relevant_docs': [{'id': '01goni72', 'score': 2}, {'id': '03h85lvy', 'score': 2}]
}
]
我们可以从之前下载的topics和relevance_data中创建labeled_data。我们将只在最终列表中包含相关性分数为> 0 的文档。
labeled_data = [
{
"query_id": int(topic_id),
"query": topics[topic_id]["query"],
"relevant_docs": [
{
"id": row["cord_uid"],
"score": row["relevancy"]
} for idx, row in relevance_data[relevance_data.topic_id == int(topic_id)].iterrows() if row["relevancy"] > 0
]
} for topic_id in topics.keys()]
定义要评估的查询模型
我们将在这里定义两个要评估的查询模型。两者都将匹配与查询至少共享一个术语的所有文档。这通过设置match_phase = OR()来定义。
查询模型之间的差异发生在排序阶段。or_default模型将根据native ank对文档进行排序，而or_bm25模型将根据 BM25 对文档进行排序。关于这两种排名的讨论超出了本教程的范围。知道他们按照两种不同的公式对文档进行排序就够了。
这些排名资料是由 cord19 应用程序背后的团队定义的，可以在这里找到。
from vespa.query import Query, RankProfile, OR
query_models = {
"or_default": Query(
match_phase = OR(),
rank_profile = RankProfile(name="default")
),
"or_bm25": Query(
match_phase = OR(),
rank_profile = RankProfile(name="bm25t5")
)
}
定义评估中使用的指标
我们希望计算以下指标:
- 查询匹配的文档的百分比
- 回忆@ 10
- 倒数排名@ 10
- NDCG @ 10
from vespa.evaluation import MatchRatio, Recall, ReciprocalRank, NormalizedDiscountedCumulativeGain
eval_metrics = [
MatchRatio(),
Recall(at=10),
ReciprocalRank(at=10),
NormalizedDiscountedCumulativeGain(at=10)
]
评价
连接到正在运行的 Vespa 实例:
from vespa.application import Vespa
app = Vespa(url = "https://api.cord19.vespa.ai")
为每个查询模型计算上面定义的指标，并将结果存储在一个字典中。
evaluations = {}
for query_model in query_models:
evaluations[query_model] = app.evaluate(
labeled_data = labeled_data,
eval_metrics = eval_metrics,
query_model = query_models[query_model],
id_field = "cord_uid",
hits = 10
)
分析结果
让我们首先将数据组合成一个 DataFrame，其格式便于在查询模型之间进行比较。
import pandas as pd
metric_values = []
for query_model in query_models:
for metric in eval_metrics:
metric_values.append(
pd.DataFrame(
data={
"query_model": query_model,
"metric": metric.name,
"value": evaluations[query_model][metric.name + "_value"].to_list()
}
)
)
metric_values = pd.concat(metric_values, ignore_index=True)
metric_values.head()
我们可以在下面看到，基于 BM25 的查询模型在这里考虑的所有指标中都是优越的。
metric_values.groupby(['query_model', 'metric']).mean()
我们还可以可视化指标在查询中的分布，以便更好地了解结果。
import plotly.express as px
fig = px.box(
metric_values[metric_values.metric == "ndcg_10"],
x="query_model",
y="value",
title="Ndgc @ 10",
points="all"
)
fig.show()
如何用 Python 代码评价你的机器学习模型！
使用这些方法来确保您已经创建了一个好的模型
你终于建立了你的机器学习模型来预测比特币的未来价格，这样你就可以最终成为一名亿万富翁。但是你怎么知道你创建的模型是好的呢？
在这篇文章中，我将谈论几种方法来评估你的机器学习模型，并提供代码！本文分为两部分:
a)评估回归模型
b)评估分类模型
更具体地说，我将涵盖以下指标:
- r 平方
- 调整后的 R 平方
- 绝对平均误差
- 均方误差
- 混淆矩阵和相关指标
- F1 分数
- AUC-ROC 曲线
a)评估回归模型
1.r 平方
r 平方是一种度量，它告诉你因变量的方差在多大程度上是由自变量的方差来解释的。更简单地说，当系数估计趋势时，R 平方表示最佳拟合线周围的散布。
例如，如果 R 是 0.80，那么 80%的变化可以用模型的输入来解释。
如果 R 为 1.0 或 100%，这意味着因变量的所有变动都可以完全由自变量的变动来解释。
举个直观的例子，尽管有相同的最佳拟合线，右边的 R 比左边的高很多。
低 R 模型与高 R 模型的比较
R 的公式如下:
解释的变差等于残差平方和，而总变差等于残差平方和。
现在您已经理解了 R 是什么，代码非常简单！
*from sklearn.metrics import r2_score
sklearn.metrics.**r2_score**(*y_true*, *y_pred)**
2.调整后的 R 平方
添加到模型中的每一个额外的独立变量总是增加 R 值——因此，一个有几个独立变量的模型可能看起来更适合，即使它不是。这就是调整后的 R 的用武之地。调整后的 R 补偿每个额外的独立变量，并且仅在每个给定变量将模型改进到超出概率可能的程度时才增加。
使用 Python 有几种方法可以找到调整后的 R:
选项 1:手动计算
*# n = number of sample size
# p = number of independent variablesAdj_r2 = 1-(1-R2)*(n-1)/(n-p-1)*
选项 2: statsmodel.api
*import statsmodels.api as sm
from statsmodels.sandbox.regression.predstd import wls_prediction_stdmodel1=sm.OLS(y_train,x_train)
result=model1.fit()
print(result.summary())*
3.平均绝对误差
绝对误差是预测值和实际值之间的差值。因此，平均绝对误差是绝对误差的平均值。
通过从 sklearn.metrics 导入 mean_absolute_error，您可以轻松地计算模型的 MAE。
*from sklearn.metrics import mean_absolute_error
mean_absolute_error(y_true, y_pred)*
4.均方误差
均方差或 MSE 类似于 MAE，只是您取预测值和实际值之间的平方差的平均值。
因为差值是平方的，所以较大的误差被赋予更高的权重，所以当您想要最小化较大的误差时，这应该在 MAE 上使用。下面是 MSE 的等式和代码。
*from sklearn.metrics import mean_squared_error
mean_squared_error(y_true, y_pred)*
b)评估分类模型
5.混淆矩阵和相关指标
混淆矩阵，也称为误差矩阵，是用于评估分类模型的性能度量。下面是一个两类混淆矩阵的例子。
在混淆矩阵中，您需要了解一些术语，这些术语可用于计算各种指标:
- 真阳性:模型正确预测阳性类别的结果。
- 真阴性:模型正确预测阴性类别的结果。
- 假阳性(1 型错误):模型错误预测阳性类别的结果。
- 假阴性(2 型错误):模型错误预测阴性类别的结果。
现在您已经了解了这些术语，下面是一些您可以计算的指标:
- 准确性:等于模型预测正确的比例。
- 回忆:尝试回答“正确识别实际阳性的比例是多少？”
- Precision: 试图回答“多大比例的肯定识别实际上是正确的？”
为了真正击中要害，下面的图表是记住精确和回忆之间的区别的一个很好的方法(它确实帮助了我)！
摘自维基百科
混淆矩阵和相关指标的代码如下:
*# Confusion Matrix
from sklearn.metrics import **confusion_matrix**
confusion_matrix(y_true, y_pred)# Accuracy
from sklearn.metrics import **accuracy_score**
accuracy_score(y_true, y_pred)# Recall
from sklearn.metrics import **recall_score**
recall_score(y_true, y_pred, average=None)# Precision
from sklearn.metrics import **precision_score**
precision_score(y_true, y_pred, average=None)*
6.F1 分数
F1 分数公式
F1 分数是对测试准确性的一种衡量——它是精确度和召回率的调和平均值。它的最高分是 1(完美的精确度和召回率)，最低分是 0。总的来说，这是对你的模型的精确性和健壮性的一个度量。
在 Python 中有三种方法可以计算 F1 分数:
***# Method 1: sklearn**
from sklearn.metrics import f1_score
f1_score(y_true, y_pred, average=None)**# Method 2: Manual Calculation**
F1 = 2 * (precision * recall) / (precision + recall)**# Method 3: BONUS - classification report**
from sklearn.metrics import classification_report
print(classification_report(y_true, y_pred, target_names=target_names))*
7.AUC-ROC 曲线
AUC-ROC 曲线是对分类问题的一种性能度量，它告诉我们一个模型在多大程度上能够区分不同的类别。更高的 AUC 意味着模型更准确。
要计算 AUC-ROC 得分，您可以复制以下代码:
**import numpy as np
**from sklearn.metrics import roc_auc_score**y_true = np.array([0, 0, 1, 1])
y_scores = np.array([0.1, 0.4, 0.35, 0.8])
**roc_auc_score(y_true, y_scores)**
0.75**
就是这样！现在你知道如何评估你的机器学习模型，以确定它们是否真的有用。接下来，我们将讨论改进机器学习模型的各种方法。
更多类似的文章，请查看https://blog.datatron.com/
感谢阅读！
如果你喜欢我的工作，想支持我…
- 支持我的最好方式就是在媒体** 这里关注我。**
- 在 Twitter 这里成为首批关注我的人之一。我会在这里发布很多更新和有趣的东西！
- 此外，成为第一批订阅我的新 YouTube 频道 这里！
- 在 LinkedIn 这里关注我。
- 在我的邮箱列表上报名这里。
- 查看我的网站，terenceshin.com。
如何评价自己的炒股模式
提示:不要使用传统的损失函数
在 Unsplash 上由 Austin Distel 拍摄的照片
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
当我偶尔观察到“使用 LSTMs 预测股价”时，准确性和盈利性的衡量标准是亏损，通常是均方误差函数。对于以预测值的准确性为最终目标的数据集来说，这一切都很好。
在股票交易的情况下，盈利是最终目标。那么如何才能量化这个价值呢？
概念:
评估模型的最佳值应该与项目的最终目标——盈利能力直接相关。所以我们知道脚本应该能够评估估计的盈利能力。
此外，为了进行盈利能力评估，程序必须对以前从未见过的数据进行处理。这意味着我们必须对数据进行测试，以检查一个人能赚多少钱。
有了利润估算程序的两个最重要的特征，让我们开始创建这个程序。
代码:
我为不同类型的交易准备了三种不同的脚本:
- 固定时间交易
- 正常股票交易
- 二元期权交易
固定时间交易:
def trading_simulator(trade_time,trade_value,close_price,sma_one,sma_two):
intersections,insights = intersection(sma_1,sma_2)
profit = 0
logs = []
for i in range(len(insights)):
index = intersections[i]
if insights[i] == buy:
if index+trade_time < len(fx_data):
if fx_data[index][-1] < fx_data[index+trade_time][-1]:
profit += trade_value * 0.8
logs.append(trade_value*0.8)
elif fx_data[index][-1] > fx_data[index+trade_time][-1]:
profit -= trade_value
logs.append(-trade_value)
elif insights[i] == sell:
if index+trade_time <= len(fx_data):
if fx_data[index][-1] > fx_data[index+trade_time][-1]:
profit += trade_value * 0.8
logs.append(trade_value*0.8)
elif fx_data[index][-1] < fx_data[index+trade_time][-1]:
profit -= trade_value
logs.append(-trade_value)
profit = profit
return profit,logs
这个交易程序使用两个 SMA 值的交集来测试如果基于对两个定义的 SMA 值的交集的理解以及准确性(所有交易中盈利的交易数量)进行交易，将会赚多少钱。
这个程序基于固定时间交易的利润估计:一种交易策略，其中你预测在下一个时间框架内，如果价格将增加或减少。您可以修改程序，或者只是从这里复制整个脚本来测试利润估计:
import requests
import numpy as np
from matplotlib import pyplot as plt
import datetime
API_KEY = 'YOURAPIKEYHERE'
from_symbol = 'EUR'
to_symbol = 'USD'def sell():
pyautogui.click(1350,320)
def buy():
pyautogui.click(1350,250)
def SMA(prices,value):
means = [] count = 0
while value+count <= len(prices):
pre_val = prices[count:value+count]
count +=1
means.append(np.mean(pre_val))
return meansdef intersection(lst_1,lst_2):
intersections = []
insights = []
if len(lst_1) > len(lst_2):
settle = len(lst_2)
else:
settle = len(lst_1)
for i in range(settle-1):
if (lst_1[i+1] < lst_2[i+1]) != (lst_1[i] < lst_2[i]):
if ((lst_1[i+1] < lst_2[i+1]),(lst_1[i] < lst_2[i])) == (True,False):
insights.append(buy)
else:
insights.append(sell)
intersections.append(i)
return intersections,insightsdef trading_simulator(trade_time,trade_value,close_price,sma_one,sma_two):
intersections,insights = intersection(sma_1,sma_2)
profit = 0
logs = []
for i in range(len(insights)):
index = intersections[i]
if insights[i] == buy:
if index+trade_time < len(fx_data):
if fx_data[index][-1] < fx_data[index+trade_time][-1]:
profit += trade_value * 0.8
logs.append(trade_value*0.8)
elif fx_data[index][-1] > fx_data[index+trade_time][-1]:
profit -= trade_value
logs.append(-trade_value)
elif insights[i] == sell:
if index+trade_time <= len(fx_data):
if fx_data[index][-1] > fx_data[index+trade_time][-1]:
profit += trade_value * 0.8
logs.append(trade_value*0.8)
elif fx_data[index][-1] < fx_data[index+trade_time][-1]:
profit -= trade_value
logs.append(-trade_value)
profit = profit
return profit,logsclose_price = []
r = requests.get(
'[https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol='](https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol=') +
from_symbol + '&to_symbol=' + to_symbol +
'&interval=1min&outputsize=full&apikey=' + API_KEY)
jsondata = json.loads(r.content)
pre_data = list(jsondata['Time Series FX (1min)'].values())
fx_data = []
for data in pre_data:
fx_data.append(list(data.values()))
fx_data.reverse()
for term in fx_data:
close_price.append(float(term[-1]))sma_1 = SMA(close_price,2)
sma_2 = SMA(close_price,1)
profit,logs = trading_simulator(1,10,close_price,sma_1,sma_2)
profit
为了让程序工作，你必须用你自己的 API 密匙替换 API 密匙参数。
正常交易:
正常的交易是买入或卖出一定数量的股票，所赚的利润是股票价格的差额。
def estimate_profits(standard_qty,model,data,close,open_,high,low):
close_prices = close
open_prices = open_
low_prices = low
high_prices = high
pred_close = list()
pred_open = list()
orders = list()
profits = list()
for i in range(len(data)):
pred = model.predict(data[i])[0]
open_price,close_price = pred
if open_price > close_price:
side = -1
elif open_price < close_price:
side = 1
qty = standard_qty
orders.append([side,qty])
pred_close.append(close_price)
pred_open.append(open_price)
for i in range(len(data)):
sign = 0
mult = 0
side,qty = orders[i][0],orders[i][1]
dif = close_prices[i] - open_prices[i]
if dif > 0:
sign = 1
else:
sign = -1
if sign == side:
mult = 1
else:
mult = -1
profit = dif*mult*qty
profits.append(profit)
return profits
该程序计算资产在制造时和下一次制造时之间的差异。它将这一差额乘以股票数量来计算利润。你可以调整时间步长，测试更长时间的交易策略。
二元期权交易:
def trading_simulator(open_prices):
profit = 0
insights = []
logs = []
for i in range(len(pred)):
if float(open_prices[i]) > pred[i][0]:
insights.append('sell')
elif float(open_prices[i]) < pred[i][0]:
insights.append('buy')
for i in range(len(insights)):
if insights[i] == 'sell':
if float(open_prices[i]) > y[i]:
profit += 8
logs.append(8)
else:
profit -= 10
logs.append(-10)
if insights[i] == 'buy':
if float(open_prices[i]) < y[i]:
profit += 8
logs.append(8)
else:
profit -= 10
logs.append(-10)
return profit,logs
该函数计算利润，考虑交易金额的固定 80%利润。它计算当前值和下一个时间步长值之间的差值。
结论:
我真的希望人们可以使用程序的盈利能力来评估他们的模型，以便真正了解交易算法是否有效。
我的链接:
如果你想看更多我的内容，点击这个 链接 。
如何评估你的网站在不确定时期的表现
nabler.com
了解分析您的分析实施的重要性
传统观点认为，不可预测的市场和整体混乱状态等同于糟糕的业务。尽管我们是从经验数据中得出结论的，而我们通常将这些数据作为现实的标准，但市场的不可预测性可以开辟新的途径。凭借聪明的营销策略，企业可以通过在新创造的市场空间中建立据点来创造前所未有的利润。
随着最近新冠肺炎制造的混乱，所有的企业都在前述的空间里。从生产者到消费者的传统交易方式正在以前所未有的方式发生变化。所有垂直行业的企业都见证了收入下降的趋势。在如此严重的危机期间，将有效的贸易扩张营销作为重中之重的建议，可能会让人感觉像是泰坦尼克号撞上冰山后打扫房间的建议。但这种类比与事实相去甚远。一个更准确的比喻是，有人提议修补船上的洞，防止它下沉。
随着 COVID 引发的经济动荡，追踪每一笔营销支出的可衡量结果势在必行。在不确定的时期，营销人员明白，需要关注细节和仔细调整流程，以跟踪和解释业务目标的快速变化。这就是数字营销领域中经过精心计算和精心策划的支出所能发挥的作用。
正如一个人需要有一个坚实的基础来建造摩天大楼一样，有效实施数字分析是任何数字营销企业的先决条件。
使用数字营销分析，营销人员可以确定他们的每项营销计划(例如，社交媒体与博客和电子邮件营销等)的相互对比情况，确定他们活动的真实投资回报，并了解他们实现业务目标的情况。
分析提供正确分类和划分用户行为的数据。相同的数据被用作营销策略的基础。最后，分析提供了对营销活动有效性的全面洞察。
用一个更简单的比喻来说，没有分析的营销就像没有建筑师的纪念碑的建造。
数字分析成功的关键是正确的测量策略。衡量策略是一个包罗万象的计划，它组织了您的业务目标以及如何衡量这些目标。该策略遵循从尽可能广泛的目标(通常是业务目标)开始的路径，并将其分解为可测量的指标和分割所述指标的特定方式。现在，最终目标是优化网站的性能，获取关于消费者行为的信息，并努力收集必要的维度和指标。
最后，如果没有持续和严格的数据治理，所有有效分析的努力都将失败。数据治理包括维护数据的责任以及对分析能力的定期审核。跟上每一次技术更新，并确保收到的数据是一致的、有意义的和简明的。数据治理是确保分析架构有效性的持续活动；催化每一次营销活动的产出。
如前所述；这个喧嚣的商业时代已经打开了各种各样的市场，这些市场到目前为止还不是主流需求。这篇文章现在将跟随三个案例研究，它们将说明拥有一个全面的架构来收集分析的重要性，以及做出正确的推断来促进对话和销售的重要性。
案例研究 1:
我们有成千上万的课程和证书，我们的一个客户是专业教育领域的先驱。然而，随着新冠肺炎的出现，就像教育部门的其他人一样，入学表格的讨论处于历史最低点。网站的总流量每天都在下降。访问者在浏览了所有可用课程的第一页后就离开了网站。
我们可以通过在页面视图上设置触发器、表单交互、跟踪每个访问者的退出链接以及热图来观察这一点，热图让我们了解用户交互最多的网页上的集群。
从这些数据中得出的结论是，人们不寻找传统的教育证书，因为没有去教室的机会。由于这个疫情以其不可预测性而闻名，学生们甚至对那些批量开始于未来的课堂课程不感兴趣。
通过测试工具和分析他们的参与率，在网页上出现了多种可能的变化后，我们在可用课程列表的顶部只显示了远程教育项目。我们改变了表单，减少了远程学习课程的 UI 路径。我们通过创建一个单独的远程学习课程列表，而不是将它们集中在所有认证课程的列表中，实现了这一点。
在任何正常情况下，远程学习项目是最不受欢迎的项目，因为教师之间的互动有限。但是这种不可预测的情况为我们的客户开辟了一条新的途径。分析和数字营销为得出这一结论提供了必要的信息。
案例研究 2:
我们的客户是一个电子商务平台，销售咖啡、营养和健康产品。我们客户的主要产品仍然是咖啡。每当有新访客访问平台，他看到的第一个产品将是咖啡。通常，这种做法会导致更高的转化率。这主要是因为新用户更愿意购买一家公司的主要产品，而不是他们第二条生产线上的产品。
为了跟踪平台上所有可用产品的点击量，我们实现了标记，这些标记是代码的小片段，具有跟踪每个访问者在平台上的交互的功能。根据收集的数据，我们观察到寻找健康产品的人数激增，而购买咖啡的人数却下降了。
在这些冲突时期，每个人都在寻找一种方法来提高他们的免疫力，并为逆境做好更好的准备。基于我们收集的数据，我们建议我们的客户改变他们的默认主页，更多地关注基于蛋白质和营养的产品。
两周之内，我们的客户看到了销售额的猛增。当每个企业都在努力实现收支平衡时，通过对分析和数字营销的精心投资，我们的客户增加了他们的收入。发生这种情况是因为他们能够抓住市场中的一个新缺口。
案例研究 3:
我们的客户是领先的家用、家庭办公和商用产品的主要供应商，如打印机、缝纫机、齿轮马达等。他们广泛关注他们的打印机业务。他们的主要收入来源于每个公司环境中所需的办公设备。最明显的是打印机。
然而，随着全球各地办公室的关闭以及数字化趋势的不断增强，对打印机的需求降到了历史最低点。这从我们在他们平台的所有网页上实现的热图中可以明显看出。我们观察到家用产品的最大滚动密度。尤其是针线包。
基于这些数据的收集，营销团队有了一个推论。根据他们的说法，由于全球对个人防护设备套件和口罩的需求巨大，而商业行业的产量又低于需求，人们开始为家人的福利缝制自己的口罩和个人防护设备套件。此外，进一步的研究表明，许多人将此作为一个机会，开始自己的口罩和个人防护设备套件生产业务。这项研究的触发点是观察到行业级缝纫机的销售增长。这些缝纫机很少售出，但通过仔细的反思，我们发现了市场中的另一个缺口，我们的客户可以利用它来增加他们的利润。
这三个简短的案例研究显示了优化网站性能的内在重要性。然而，潜台词中可能没有的一个主要推论是，这些公司在动荡时期取得成功，是因为它们投资了数字分析。他们只能在强大、平衡、预先计划的上述测量策略的帮助下才能做到这一点。
最后总结一下。
- 在市场不断变化的时代，数字营销和分析的重要性是至关重要的。
- 没有分析，数字营销将不会带来投资回报。
- 作为一家企业，有必要了解你的数据，并通过它了解你的消费者，以便与他们建立更私人的关系。了解他们的需求，改变你的平台来迎合那些观察到的需求。
- 既然数字营销和分析的重要性已经得到证明，那么开始数字营销之旅的第一步就是制定一个可持续的衡量策略。规划你的期望，你的远大目标和你的货币投资。每个企业都有自己的衡量策略，基于其资源和整合数字营销的必要条件。
最初发表于T5【https://www.nabler.com】。
如何进化人工智能生命:初学者指南
为人工智能爱好者提供介绍、进度更新和概念验证
智能人工生命是可以进化的。图片由com break在 Pixabay 拍摄。
“进化中的人工智能生命”听起来可能像是个人的夸大其词——甚至可能是科幻小说。我认为你的怀疑更多的是关于我们如何习惯于思考生活，而不是这个主张本身的价值。
普遍的共识会让你相信宇宙中的生命极其稀少，或者说极其难以创造。一个简单的思想实验，用来更好地理解费米悖论，可以揭示反对‘稀有生命假说的天文几率。
也就是说，在 0 到 100 摄氏度的狭窄温度范围内，形成生命的化学物质肯定不是唯一基于碳和水的。相反，它们可能出现在温度、辐射和压力光谱上下的任何地方，跨越几乎无限的物质范围(即甲烷在低温下是液体，铁在高温下是液体)。
在 0 到 100 摄氏度的狭窄温度范围内，形成生命的化学物质肯定不是唯一基于碳和水的。
这些化学物质需要的唯一共性是存储和传输数据的能力，使辐射(光)成为生命的潜在基质，甚至可能是重力。
也许生命唯一的基本先决条件是储存和传输数据的能力。
电脑有我们需要的一切。但是我跑题了…
我说的不是目前形态的 AI ( 人工智能)。神经网络是对我们所知的大脑工作方式的模仿。它们是智能设计的。
你不设计人工智能生命。这不是一种自然的(或优雅的)方式。相反，我要提供适合智慧生命进化的初始条件。大自然也为我们做了同样的事情。
你不要设计人工智能生命。这不是一种自然的(或优雅的)方式。
但是从哪里开始呢？
有几个重要的概念支撑着我的方法，所以让我们从这里开始。
试探法简介
试探法是解决极其复杂问题的自然方法。我不是说对我们来说是自然的，我是说自然，就像自然——宇宙一样。
启发式是一种比较过程，不能保证产生完美的结果。
我首先开始使用启发式算法来解决一个著名类型的 NP-Hard 数学问题，即所谓的旅行推销员问题。本质上，你需要找出最有效的方法去访问指定数量的地点。听起来很简单，对吧？
困难在于所涉及的排列数量之多。根据此路线优化概述:
一个只有一辆车和 50 个停靠站的简单路线优化问题的排列比太阳中的氢原子多 3000 万倍(10⁵⁷).
使用 bang ( )很容易确认这一点！科学计算器上的符号。排列的数量可以计算如下:
50 x 49 x 48 x 47 x … x 2 x 1 = 50！= 3 x 10⁶⁴
世界上最快的超级计算机需要数万亿年来检查每一种可能性，这使得这个简单的问题(每天都要面对快递公司和快递员)在没有启发的情况下变得难以处理。
相比之下，使用试探法的系统可以在几秒钟内为 50 个地点的游览提供以下最佳路线:
由 Optergon 提供的具有 50 个停靠点的单个车辆的最佳路线。
启发式算法经常在自然界中找到灵感。从蚁群收集食物到我们 DNA 的突变，启发式是生活中不可或缺的一部分。没有启发法，就不会有进化。
奇怪的是，但重要的是，在我们继续时要记住，自然发生的启发法可以出现全新的启发法。浮现这个词也很重要。我将很快更详细地介绍它。
自然发生的试探法可以产生全新的试探法。
我会解释的。
我们的大脑一直在使用启发式方法。没有它们我们抓不到球。
我们不是计算牛顿定律来预测球的飞行路径，而是将当前情况(即球朝我们飞来)与存储的记忆库进行比较，并基于此估计球将到达的位置和时间。我们练习得越多，我们用来做决定的记忆和经验就越多，我们就会变得越好。由于试探法不能保证完美的结果，即使是我们中最优秀的人也会偶尔失手。
在生命最初进化的时候,“T20”接球试探法并不存在。当生命首次爬上陆地时，它并不存在。一段时间后，它作为遗传启发式进化过程的结果出现了。
换句话说，一个启发式过程(进化)出现了另一个(接球)。
这很重要！
紧急情况介绍
涌现是一种美丽优雅的现象，似乎毫不费力地违反了热力学定律。宇宙中真正的宝石之一。
涌现是一种美丽优雅的现象，似乎毫不费力地违反了热力学定律。
当一个系统表现出任何组成部分最初都没有的特性时，我们就观察到了涌现。
有很多肉眼可见的宏伟的例子。向窗外看。在太阳系形成之初，没有地球。没有月亮。没有太阳。随着时间的推移，所有这些东西都是在重力作用下由尘埃和气体形成的。
即使一旦太阳的核火焰点燃，我们的星球清扫干净它的轨道，这里也没有生命。没有花。没有树。没有鸮鹦鹉(可悲的是，我们正在杀害许多大自然中已经出现的美好事物，而 鸮鹦鹉很可能很快就会成为其中之一 )。所有这些生物都是在适应生存的基因启发过程(即突变)中出现的。
简言之，
简单的启发式系统可以产生复杂的生命和智能。
这很重要！
“启发式涌现”是进化智能的好方法
启发式涌现，我用来描述我进化人工智能的方法的术语，是你从未听说过的最强大的自然现象。它负责宇宙中的所有生命。它对鸮鹦鹉负责。它对我们的智力负责。
进化是启发式涌现的一个具体例子。
使用启发式涌现来进化人工智能的好处在于，它不需要设计师或指导手。只需设置好虚拟生物 ( 沃斯)进化所需的初始条件。按播放。
迟早，就像我们的智慧来自自然选择一样，他们会开始展现出像常识、解决问题、直觉和创造力这样的特质。它们不会由人类来设计，也不会使用机器学习 ( ML )来训练。它们是它们自己的东西。独立，有自知之明。
和我们一样。
概念证明:使用启发式涌现的人工进化
最近，我有时间采取一些具体的步骤来建立一个启发式的紧急系统。我把它叫做草原。
grasses 是一个虚拟环境，它支持单一类型的 VO(本例中为，grass )，由编码大小的单一基因组成。我试图让这个系统的规则尽可能地接近我们本质上认为的自然草原环境，以便让这个演示更具关联性。
- 在环境的某些部分，水和降雨充足，而在其他部分，水很少。
- 草要生存就必须有足够的水。
- 草可以生长，达到性成熟，在合适的条件下繁殖(有小几率突变)，最终死亡。
- 大草比小草需要更多的水才能生存，但如果条件合适，它们可以更快地繁殖。
这就是全部了。
该模拟在没有任何干扰的情况下运行一段时间，并每隔几年显示环境的快照。
下面的截图来自我的电脑，显示了使用的初始条件(显然它们是可配置的)以及 20 年后的环境。
草原启发式涌现环境初始条件。
从截图底部角落的沙色地图上，你或许可以看出一条河流从西北流向中心的模糊轮廓，然后流入内陆三角洲比如博茨瓦纳的奥卡万戈。西北地区较高的降雨量为河流和三角洲系统提供了水源(平均降雨量未在地图上标出)。
最初，有两个小草群落占据了主导地位——一个在地图的顶部中心，另一个在中心，靠近三角洲。根据起始条件，两个初始草菌落都具有基因表达大小 20。
绝大多数的地图没有足够的水来支持基因大小表达 20 的草。简而言之，为了在地图上更干燥的地区定居，种子殖民地将不得不进化。
经过 240 年的模拟，地图看起来是这样的(结果每次都不同，因为系统是不确定的，没有办法准确预测结果——除了一般趋势)。
草原启发式涌现模拟显示适应 VOs。
深绿色的区域表示大而茂盛的草已经在西北、沿河和内陆三角洲的潮湿区域定居。最大的草已经进化到 111 的基因大小表达。比种子群体大得多，繁殖速度也快得多。
最小的草已经进化到只有 7 的基因大小表达，这使它非常适合干旱地区。请注意，较小的草，在地图上被描绘为浅绿色的瓦片，已经占据了整个可用区域，尽管这对于种子草来说最初是不可能的。
这里突出的一点是，一般来说，这个系统是启发式涌现的概念证明，特别是人工进化。
一般来说，草原是启发性涌现的概念证明，尤其是人工进化。
没有任何代码，没有任何指令，没有任何程序，没有任何功能，或任何其他东西，来指导草适应更干燥的环境区域。它进化是因为随着时间的推移，其 DNA 中的随机突变导致了允许它在更干燥的环境中生存和繁殖的特征——将这些特征传递给后代。
和我们一样。
向进化革命前进
机器拥有许多方面的智能。它们是很好的计算器。他们有记忆。他们可以交流。人工智能可以学习特定的智能行为，例如识别人脸或物体。
他们做很多事情都比我们好。然而，我们并不认为他们比我们聪明。为什么？计算机目前缺乏启发性，比如常识、同理心和创造力。
计算机目前缺乏启发性，如常识、同理心和创造力。
然而试探法恰恰是那些使用…试探法最能展现智慧的方面。大自然已经通过进化我们向我们展示了如何做到这一点。我只是打算遵循已经制定的路线图。
下一步是进化出一个拥有启发性行为的虚拟有机体，比如创造力或常识。
现在有一些挑战(也就是找时间)。在技术方面，我需要找到一种方法，将新基因的出现与特定特征联系起来。这些特征协同工作，最终将形成新的启发。
请记住，我不能简单地为创造力创建一个基因表达式，就像我在草原中对大小基因所做的那样。大小是一个基本特征。创造力是一种复杂的行为。简单地说一个基因编码创造力并不会使它成为现实。
我有一些关于如何做到这一点的想法，我会让你知道我的进展(或者在可疑的情况下死亡——在这种情况下，真的需要有人销毁我的 PC 和云帐户)。与此同时，我想留给你以下令人费解的想法。
大自然使用启发式涌现来进化充满启发的生命，这允许它使用启发式涌现来涌现充满启发的生命。
似乎大自然有一种递归的诗意对称。
如何用 Scrapy 执行 JavaScript？
了解如何使用 Scrapy 和 Selenium、Splash 和 ScrapingBee 中间件为无头浏览器抓取动态网站
图片由 Pierre de Wulf [ 来源
大多数现代网站使用客户端 JavaScript 框架，如 React、Vue 或 Angular。在没有服务器端呈现的情况下，从动态网站抓取数据通常需要执行 JavaScript 代码。
我刮过几百个站点，一直用 Scrapy。Scrapy 是一个流行的 Python web 抓取框架。与其他 Python 抓取库(如 Beautiful Soup)相比，Scrapy 迫使你根据一些最佳实践来构建代码。作为交换，Scrapy 负责并发性、收集统计数据、缓存、处理重试逻辑以及许多其他工作。
如果你是 Scrapy 新手，你可能应该开始阅读这个伟大的教程，它将教你所有Scrapy的基础知识。
在这篇文章中，我比较了使用 Scrapy 执行 JavaScript 的最流行的解决方案，如何扩展无头浏览器，并介绍了使用 ScrapingBee API 实现 JavaScript 支持和代理轮换的开源集成。
用 Scrapy 抓取动态网站
用 Scrapy 抓取客户端渲染的网站曾经很痛苦。我经常发现自己在浏览器网络工具上检查 API 请求，并从 JavaScript 变量中提取数据。
虽然这些技巧可能在一些网站上有效，但我发现代码比传统的 XPATHs 更难理解和维护。但是要直接从 HTML 中抓取客户端数据，首先需要执行 JavaScript 代码。
无头浏览器的零碎中间件
无头浏览器是没有图形用户界面的 web 浏览器。我用三个库来用 Scrapy 执行 JavaScript:Scrapy-selenium、 scrapy-splash 和 scrapy-scrapingbee 。
所有三个库被集成为一个 Scrapy 下载器中间件。一旦在你的项目设置中进行了配置，你就可以产生一个 SeleniumRequest 、 SplashRequest 或scraping beer Request，而不是从你的蜘蛛那里产生一个普通的 Scrapy 请求。
用 Selenium 在 Scrapy 中执行 JavaScript
在本地，你可以通过 scrapy-selenium 中间件与 Scrapy 的无头浏览器进行交互。Selenium 是一个与浏览器交互的框架，通常用于测试应用程序、网页抓取和截屏。
Selenium 需要一个 web 驱动来与浏览器交互。比如 Firefox 要求你安装 geckodriver。然后，您可以在 Scrapy 项目设置中配置 Selenium。
在你的蜘蛛中，你可以产生一个硒元素请求。
Selenium 允许您用 Python 和 JavaScript 与浏览器进行交互。驱动程序对象可以从 Scrapy 响应中访问。有时在你点击一个按钮后检查 HTML 代码是很有用的。在本地，您可以用一个 ipdb 调试器设置一个断点来检查 HTML 响应。
否则，可以从响应对象访问杂乱的 XPATH 和 CSS 选择器，以便从 HTML 中选择数据。
SeleniumRequest 带有一些附加参数，例如在返回响应之前的 wait_time 到 wait ，等待 HTML 元素的 wait_until ，截屏的screen和执行定制 JavaScript 脚本的 script 。
在生产中，scrapy-selenium 的主要问题是没有简单的方法来建立一个 Selenium grid 来在远程机器上运行多个浏览器实例。接下来，我将比较用 Scrapy 大规模执行 JavaScript 的两种解决方案。
用 Splash 在 Scrapy 中执行 JavaScript
Splash 是一个带有 API 的网络浏览器即服务。它由 Scrapinghub 维护，Scrapy 的主要贡献者，并通过 scrapy-splash 中间件与 Scrapy 集成。也可以由 Scrapinghub 托管。
Splash 创建于 2013 年，在 2017 年无头 Chrome 和其他主要无头浏览器发布之前。从那时起，其他流行的项目如 PhantomJS 已经停止，转而支持 Firefox、Chrome 和 Safari 无头浏览器。
您可以使用 Docker 在本地运行 Splash 的实例。
配置 Splash 中间件需要添加多个中间件，并在您的项目设置中更改HttpCompressionMiddleware的默认优先级。
然后，您可以生成一个带有可选参数 wait 和 lua_source 的 SplashRequest 。
Splash 是一种流行的解决方案，因为它已经问世很长时间了，但它有两个主要问题:它使用自定义的无头浏览器，并需要用 Lua 编码来与网站交互。因为这两个问题，对于我的最后一个抓取项目，我决定为 ScrapingBee API 创建一个中间件。
使用 ScrapingBee 在 Scrapy 中执行 JavaScript
ScrapingBee 是一个 web 抓取 API，它为您处理无头浏览器和代理。ScrapingBee 使用最新的 headless Chrome 版本，支持 JavaScript 脚本。
像其他两个中间件一样，你可以简单地安装带有 pip 的 scrapy-scrapingbee 中间件。
首先，您需要创建一个 ScrapingBee 帐户来获取 API 密钥。然后，您可以添加下载器中间件，并在项目设置中根据您的 ScrapingBee 计划设置并发性。
然后你可以从 ScrapingBeeSpider 继承你的 Spider 并产生一个 ScrapingBeeRequest 。
ScrapingBeeRequest 采用一个可选的 params 参数来执行一个 js_snippet ，在返回响应之前设置一个自定义的 wait 或者用 wait_for 在 HTML 代码中等待一个 CSS 或者 XPATH 选择器。
在一些网站中，当你滚动页面时，HTML 是异步加载的。您可以使用下面的 JavaScript 代码片段滚动到页面的末尾。
ScrapingBee 在 ScrapingBee 文档上收集了其他常见的 JavaScript 片段来与网站进行交互。
在幕后，scrapy-scrapingbee 中间件将原始请求转换为转发给 ScrapingBee API 的请求，并对 URL 查询字符串中的每个参数进行编码。API 端点记录在你的垃圾日志中，api_key 被垃圾蜘蛛隐藏。
在您的蜘蛛解析方法中， response.url 被中间件解析为传递给 ScrapingBeeRequest 的原始 url。
使用 ScrapingBee 的另一个优点是，您可以访问不同国家的住宅代理，并通过以下参数进行代理轮换。
使用 Scrapy 缓存和并发来提高速度
Scrapy 使用了 Twisted under the hood，这是一个异步网络框架。Twisted 使 Scrapy 快速，能够同时刮多个页面。然而，要执行 JavaScript 代码，您需要使用真正的浏览器或无头浏览器来解析请求。无头浏览器有两个挑战:速度较慢，难以扩展。
在无头浏览器中执行 JavaScript 并等待所有网络调用，每页可能需要几秒钟。当刮多个页面时，它会使刮刀明显变慢。希望 Scrapy 提供缓存来加速开发和生产运行的并发请求。
在本地，当开发一个刮刀时，你可以使用 Scrapy 的内置缓存系统。这将使后续运行更快，因为响应存储在您计算机上的一个隐藏文件夹中。scrapy/httpcache 。您可以在您的项目设置中激活 HttpCacheMiddleware :
无头浏览器的另一个问题是它们为每个请求消耗内存。在生产中，您需要一个可以处理多种浏览器的环境。要同时发出多个请求，您可以修改项目设置:
使用 ScrapingBee 时，记得根据您的 ScrapingBee 计划设置并发性。
结论
我比较了三个 Scrapy 中间件，用 Scrapy 渲染和执行 JavaScript。Selenium 允许您在所有主流的无头浏览器中使用 Python 与 web 浏览器进行交互，但是很难扩展。Splash 可以使用 Docker 在本地运行，也可以部署到 Scrapinghub，但是它依赖于定制的浏览器实现，而且你必须用 Lua 编写脚本。ScrapingBee 使用最新的 Chrome headless 浏览器，允许您在 JavaScript 中执行自定义脚本，并为最难抓取的网站提供代理旋转。
资源
原载于https://www.scrapingbee.com。
如何解释回归模型
高 R 平方值本身就好吗？为什么 R 平方越高，特征越多？回归系数的含义是什么？
艾萨克·史密斯在 Unsplash 上拍摄的照片
作者注:这篇文章是线性模型系列的一部分，它没有解释线性模型的所有属性，因为这会使文章太长。请务必继续阅读，以免错过本系列的下一篇文章。
我主要使用 statsmodels 包进行回归分析，因为它提供了开箱即用的回归模型的详细摘要。在本文中，我将解释摘要中基本术语的含义。
这里有几个你可能会感兴趣的链接:
- [Labeling and Data Engineering for Conversational AI and Analytics](https://www.humanfirst.ai/)- [Data Science for Business Leaders](https://imp.i115008.net/c/2402645/880006/11298) [Course]- [Intro to Machine Learning with PyTorch](https://imp.i115008.net/c/2402645/788201/11298) [Course]- [Become a Growth Product Manager](https://imp.i115008.net/c/2402645/803127/11298) [Course]- [Deep Learning (Adaptive Computation and ML series)](https://amzn.to/3ncTG7D) [Ebook]- [Free skill tests for Data Scientists & Machine Learning Engineers](https://aigents.co/skills)
上面的一些链接是附属链接，如果你通过它们购买，我会赚取佣金。请记住，我链接课程是因为它们的质量，而不是因为我从你的购买中获得的佣金。
什么总结？
当我们用 statsmodels 包训练一个模型时，我们可以调用 summary 函数来产生如下图所示的输出。输出类似于 R 在训练回归模型时产生的输出。
使用 statsmodels 训练的回归模型的摘要。
没听说过 statsmodels？
statsmodels 标志
statsmodels 是一个 Python 包，用于许多不同统计模型的估计，以及进行统计测试和统计数据探索。
如果您错过了我之前关于 statsmodels 的文章，我将它与 sklearn 进行了比较:
谈到 Python 中的经典机器学习算法，sklearn 是第一个首选包——还有其他包…
towardsdatascience.com](/are-you-still-using-sklearn-for-regression-analysis-fb06bb06ce96)
摘要的解释
statsmodels 索引页面显示了如何训练普通最小二乘回归模型的简单示例:
import numpy as npimport statsmodels.api as smimport statsmodels.formula.api as smf# Load data
dat = sm.datasets.get_rdataset("Guerry", "HistData").data# Fit regression model (using the natural log of one of the regressors)
results = smf.ols('Lottery ~ Literacy + np.log(Pop1831)', data=dat).fit()# Inspect the results
results.summary()
回归模型的详细总结。
以上术语是什么意思？
让我们从简单的术语开始:
- 离开变量是模型正在学习的目标变量(上面公式中的彩票)，
- 模型是普通的最小二乘法，因为我们使用 smf.ols 函数，
- 观察值是训练集中的样本数，
- Df 模型显示了模型中特征的数量。上面模型中的识字率和 Pop1831。这不包括常数，该常数在将 statsmodels 与公式一起使用时自动添加。
r 平方
默认情况下，回归模型会报告 R 平方和可调 R 平方指标。
r 平方是衡量数据与拟合回归线接近程度的指标。r 平方可以是正数，也可以是负数。当拟合完美时，R 的平方为 1。注意，向模型添加特征不会减少 R 平方。这是因为当添加更多特征时，模型可以找到与之前相同的拟合。更多情况下，添加要素时，R 平方会偶然增加。
skearn 有一个计算 R 平方的函数。在以下情况下，R 平方为负:
from sklearn.metrics import r2_scorey_true = [1, 2, 3]
y_pred = [3, 2, 1]
r2_score(y_true, y_pred)-3.0 # r-squared
产生上述负 R 平方的数据点图。
调整后的 R 平方
调整后的 R 平方通过针对模型中的要素数量进行调整来解决 R 平方的问题。向模型中添加更多要素将增加 R 平方，但可能会减少调整后的 R 平方。经调整的 R 平方的这一属性可用于找到给出最佳准确度的特征。Adj. R-squared 介于 0 到 1 之间，其中 1 表示模型解释了响应数据在其平均值附近的所有可变性。
sklearn 没有计算调整后的 R 平方的函数，因为它也需要样本和特征的数量。我们可以用下面的函数来计算:
def adj_r2(r2, n_samples, n_features):
return 1-(1-r2) * (n_samples-1) / (n_samples-n_features-1)
注意，高调整的 R 平方并不意味着你的模型是好的。拟合回归模型时，我们需要检查残差图。线性回归的假设之一是同方差，这意味着残差的方差对于 x 的任何值都是相同的，我打算在下一篇关于回归模型的文章中写残差图。
系数是如何计算的？
普通最小二乘回归(OLS)通过计算获得解析解:
计算普通最小二乘回归系数的方程。
我们自己试着拟合一下模型吧。首先，我们需要转换功能:
dat.loc[:, 'intercept'] = 1
dat['Pop1831'] = dat['Pop1831'].apply(np.log)
然后我们分离特征和目标变量:
x = dat["intercept Literacy Pop1831".split()].values.T
y = dat['Lottery'].values.T
计算等式的第一部分:
a = np.inner(x, x)array([[8.60000000e+01, 3.37600000e+03, 5.04663925e+02],
[3.37600000e+03, 1.58156000e+05, 1.98401100e+04],
[5.04663925e+02, 1.98401100e+04, 2.97314045e+03]])
计算等式的第二部分:
b = np.inner(x, y)array([ 3741\. , 133414\. , 21572.9563115])
通过寻找线性矩阵方程的最小二乘解来计算系数:
coef = np.linalg.lstsq(a, b)[0]array([246.43413487, -0.48892344, -31.31139219])
我们可以确认这些系数与 OLS 模型中的相同。
系数是什么意思？
系数的符号告诉我们一个特征和一个目标变量之间是正相关还是负相关。
正系数表示当特征增加时，目标的平均值也增加。负系数表示随着特征值的减小，目标趋于减小。
让我们把系数形象化。
# Extract the coefficients from the model
df_coef = results.params.to_frame().rename(columns={0: 'coef'})# Visualize the coefficients
ax = df_coef.plot.barh(figsize=(14, 7))
ax.axvline(0, color='black', lw=1)
回归模型的系数。
在你走之前
在 Twitter 上关注我，在那里我定期发布关于数据科学和机器学习的。
使用个体条件期望(ICE)图的模型不可知的局部解释
如何用 ICE 曲线解释和影响个人决策
理解机器学习决策
如果你的贷款申请被拒绝，你可能想知道两件事:
- 为什么我被拒绝了？
- 以后怎么做才能获得批准？
来自 Pexels 的 Karolina Grabowska 摄影
换句话说，你想要的解释是针对你自己的。特别是，你会想知道你的情况是如何影响结果的，如果可能的话，做点什么。例如，如果你在现在的地址住了一年多，你获得贷款的机会大大增加，那么你可以放心地在将来再次申请！
无论决策是由人类做出还是由机器学习算法做出，这种对对个人有意义的解释，或众所周知的“局部解释”的需求都适用。在可解释的机器学习领域，有许多众所周知的解释个体决策的技术(例如， SHAP 和莱姆)。这些技术不仅为梳理出“黑盒”机器学习模型的个体预测背后的原因提供了创新的想法，它们还通过以有趣的方式可视化它们来帮助我们理解结果(例如，参见我关于 SHAP 摘要情节的文章)。
一种流行的可视化技术是个体条件期望(ICE)图，这种技术通常与局部解释无关，但我认为在这种情况下可以有所贡献。传统上，冰图主要被视为支持全球解释的可视化；也就是说，解释模型在群体层面的作用。然而，通过对它们的可视化方式进行一些简单的修改，我认为它们在局部解释层面上也是有价值的。使用 ICE 图的好处是它是一种简单易懂的技术。它还提供了丰富的信息，观众可以利用这些信息了解当地的情况，并模拟如果情况发生变化会发生什么。
这篇文章的目的是检验 ICE 图如何帮助解释个人决策，并帮助说明影响决策的因素。我将首先详细描述 ICE 图(第 1 部分)，然后使用它的修改版本，通过几个例子来探索它的实用性(第 2 部分)。
本文面向对统计学和机器学习(ML)有基本了解，并对可视化如何帮助解释和影响个人 ML 决策感兴趣的任何人。
什么是冰情节？
ICE 图是部分相关图(PDP)的扩展。PDP 可视化了特征值的变化如何影响 ML 模型的预测。这是通过绘制您感兴趣的某个特性的不同值的平均预测结果，同时保持其他特性值的值不变来实现的。这很有用，因为我们可以看到预测和我们感兴趣的特征之间的关系(通常一次一个或两个)。
例如，我们可以回答以下问题:
- 如果温度上升，冰淇淋需要多少库存？
- 与卧室数量相关的平均房价是多少？
此处显示的图是一个 PDP 示例，显示了来自流行的波士顿房价数据集的“RM”(每个住宅的平均房间数)特征。x 轴是卧室的平均数，y 轴是千片订量的中值。使用 scikit-learn PDP 功能创建图形。
冰图可视化个体差异
PDP 简单易懂。然而，它们的简单性隐藏了单个实例之间潜在的有趣关系。例如，如果一个实例子集的特征值趋势为正，而另一个子集趋势为负，则平均过程可以抵消它们。
冰图解决了这个问题。冰图显示了 PDP 中聚合过程的结果曲线。每条 ICE 曲线都显示了一个实例的不同特征值的预测，而不是平均预测。当它们一起出现在一个图中时，我们可以看到实例子集之间的关系以及单个实例行为的差异。
如下图所示，虽然大多数实例遵循之前显示的 PDP 中的曲线形状，但是在图的顶部有一小部分表现与 PDP 曲线相反；在 x 轴上，它们不是在 6–7 之间增加，而是实际上减少了。
波士顿房价数据集中“RM”要素的 ICE 图
创建一个冰情节很简单。有许多可用的包(例如在 Python 和 R 中)。当然，你自己创造也是可以的。
使用冰图进行局部解释
ICE 图传统上用于理解数据子集中的相互作用和差异，作为部分相关(PD)分析的一部分。然而，如前所述，由于 ICE 图描述的是单个观察结果，因此有可能使用它来关注您感兴趣的特定实例。
计算冰曲线的值
为了可视化实例，我们需要弄清楚如何计算曲线的值(或者能够在创建 ICE 图的工具中定位实例。例如，参见本教程关于在 PyCEbox 中访问 ICE 数据帧。这里有一个简单的例子来说明计算 ICE 曲线值的步骤:
1.找到您感兴趣的实例和特性。
2.查找特征的唯一值。
3.对于这些值中的每一个，用其他特征值创建一个实例。换句话说，固定其他特征值并置换感兴趣的特征值。
4.对每种组合进行预测。
5.获取每个实例的预测值，并绘制预测曲线。
实例#3 特征 B 的冰图
注意相关性
使用 ICE 图(和 PDP)时需要处理的一个潜在问题是特征之间的高度相关性。这在很多方面都有问题:
- 我们可能最终得到不太可能或不可能的特征值组合，然后输入到模型中。例如，在一个包含“怀孕状态”和“性别”特征的数据集中，我们可能最终得到一个怀孕的男性作为输入组合！
- 很难将影响归因于单个特征(即“共线性”或“多重共线性”的结果 ) 。换句话说，很难知道有多少预测影响是由于一个特征或另一个特征。
许多研究人员详细指出了这些问题，并提出了各种补救方法。在实践中，有一些简单的方法来处理高度相关的变量(如聚合、逐步消除)。关于如何处理相关性的详细示例，请参见下面的文章。
可视化冰的曲线
出于解释和影响预测的目的，有许多不同的方法来可视化单个实例。两种主要方法是:
- 独自一人。将单个实例单独可视化，不需要任何关于其余群体的附加信息(如上例所示)。这种方法的优点是生成的图易于理解。观众可以只关注他们试图解释和影响的例子。
- 在上下文中。在数据集中其他实例的上下文中可视化单个实例。这种方法的优点是，查看者可以检查单个实例，同时参考其他实例；以查看该实例是否是异常值，它如何符合或偏离其他实例等。缺点是情节可能会混乱不堪。
社会科学的研究表明，人们经常寻找对比和上下文相关的解释。因此，在上下文中突出感兴趣的实例的方法似乎具有潜在的好处，值得进一步探索。
然而，大多数可用的 ICE 绘图工具不加区别地显示所有实例。如果我们想关注某个特定的实例，我们需要做一些改变。在这方面，有两个变化特别重要:
- 将感兴趣的实例与数据集中的其他实例进行对比。可视化需要在其他实例的上下文中显示感兴趣的实例，但要以一种区别于其他实例的方式。
- 指出不同的特征值以帮助结果的假设模拟。它应该突出显示当前特征值和曲线中的变化值。这将有助于观众在上下文中看到感兴趣的实例，并在心理上模拟可能的理想变化方向。
以下修改后的 ICE 图显示了上例中常规 ICE/PD 图的相关实例。
感兴趣的实例的突出显示
关于这块冰地，有几点需要注意:
- 中间较粗的黑线是 PD 曲线。也就是说，它是所有实例的平均值。
- 所有其他的线都是冰曲线。也就是说，它们是它们的值因感兴趣的特征(即特征 B)而变化的实例。
- 带有标记的蓝线是感兴趣的实例。每个圆形标记代表一个变化的特征值(如 x 轴所示)和一个预测(如 y 轴所示)。
- 蓝线上的黄色菱形标记显示了我们感兴趣的实例的当前特征值和预测。
- 突出显示的实例遵循 PD 曲线的一般形状，但是预测概率水平更高。
通过在 ICE 图的上下文中高亮显示感兴趣的实例，我们可以看到在数据集中其他实例的上下文中改变感兴趣的实例上的特定要素的值的影响。然而，重要的是要注意，这是一个简单的例子，用于说明一个概念。这里所做的设计决策是否会在解释特征对个体决策的影响时导致不可管理的复杂性，还有待观察。
在第 2 部分中，我们将使用几个更现实的例子来说明之前的讨论，并进一步探索 ICE 曲线在为黑盒 ML 模型提供局部解释方面的效用。
参考
[1] Goldstein，a .，Kapelner，a .，Bleich，j .，和 Pitkin，E. (2014 年)。"窥视黑盒内部:用个体条件期望图可视化统计学习." arXiv:1309.6392
[2]j . h .弗里德曼(2001 年)。"贪婪函数逼近:梯度推进机."统计年鉴，29 卷，第 1189-1232 页。
如何用 ICE 曲线解释和影响个人决策
在信贷申请和员工保留中使用个人条件期望图的示例
现在我们有办法在 ICE 图中突出显示感兴趣的单个实例(参见第一部分)，让我们用两个更现实的例子来说明它们的用法:信用申请和员工保留。这些例子显示了可能需要局部解释的不同背景，并允许我们测试早期做出的设计决策是否能够使 ICE 图有助于解释和影响个人决策。这篇文章的代码可以在 GitHub 上找到。
示例 1:信用申请
方案
Andrea Piacquadio 拍摄于 Pexel
罗恩是靠固定收入生活的退休人员。他最近申请了汽车贷款，但被拒绝了。他很恼火，要求对他的拒绝做出解释。
您是贷款专家，负责与 Ron 一起审查自动决策。你渴望帮助他，因为得到他想要的也有利于你的生意。你与 Ron 会面，详细回顾他的拒绝，看看你能提供什么建议。
数据:贷款违约
本例的数据集是可从 Kaggle 获得的贷款违约数据。数据由 10 个特征和“过去 90 天的严重拖欠”的目标输出组成。我们将使用该目标作为贷款批准的建议。也就是说，如果“严重拖欠”的预测是真的，那么贷款被拒绝，否则它被批准。
贷款默认数据集的片段
数据探索
根据我们在第 1 部分中的讨论，我们应该首先看看是否有高度相关的特性。
所有变量的相关矩阵
数据显示了高度相关的三个实例:
- 30–59 天和 90 天:0.98
- 30 到 59 天以及 60 到 89 天的延迟时间:0.98
- 90 天和 60–89 天
换句话说，数据显示，所有时间段(即 30-59 天、60-89 天或 90 天)的逾期债务支付都高度相关。
为了处理这些相关性，尝试了分组和排除策略(即，将所有 3 个变量聚合为一个，并丢弃一个或多个高度相关的变量)。然而，在它们如何影响预测方面没有发现显著差异。为了简化对下游解释的理解，我删除了与目标变量相关性较低的特性，从而保留了特性“30–59 天”。
scikit-learn 的随机森林算法用于拟合具有这些特征的模型，以预测贷款批准(准确度= 0.93)。这些功能的相对重要性如下。
贷款审批的功能重要性
特征重要性分析表明，我们的模型最重要的特征是“利用率”。这一特征被定义为“信用卡和个人信用额度的总余额(除了房地产，没有分期付款债务，如汽车贷款)除以信用限额的总和”。换句话说，信贷余额与信贷限额的比率。这一特征的重要性紧随其后的是负债率和月收入。让我们使用修改后的 ICE 图来绘制这些特性，以更详细地了解我们的单个实例的情况。
冰原
使用我们修改的 ICE 图可视化的前 6 个特征如下。我使用 Python 中的 pyCEbox 包来计算 ICE 值，并对第 1 部分中描述的可视化函数进行了修改。这个的代码可以在 GitHub 上找到。
回想一下第 1 部分:
- 较粗的黑线是 PD 曲线(回想一下，这是所有实例的平均值)。
- 所有其他线都是单个实例的 ICE 曲线。这里的每个子图显示了来自数据集的 602 个单独的实例。
- 带有标记的蓝线是感兴趣的实例。
- 蓝色线上的黄色菱形标记显示了我们感兴趣的实例的当前特征值和预测值。
让我们依次检查这些子情节。提醒一下，预测值为 1 是好的(贷款批准)，预测值为 0 是坏的(贷款拒绝)。
利用:ICE 图显示 x 轴值达到 1.0 时有相当大的湍流；此后，在稳定之前，在 1.0-1.1 之间的较低概率水平上有更多的波动。PD 曲线反映了这一点，但清楚地显示在值 1.0 附近有下降。
Ron 的 ICE 曲线(带圆形标记的蓝色)或多或少遵循 PD 曲线模式，直到 x 轴上的值为 1.0，之后有一个比 PD 曲线低得多的陡峭下降。此外，如黄色菱形标记所示，对 Ron 的预测接近该特征的 ICE 曲线的底部。因为这是最重要的特征，所以这是为什么 Ron 的贷款申请被拒绝的重要的部分解释。
修改了利用率特性的 ICE 图
根据罗恩的 ICE 曲线，为了增加获得贷款的机会，他可以提高或降低利用率。可视化显示降低这个比率看起来更有效(通过减少他的信用余额或增加他的信用限额大小)。换句话说，如果“利用率”降低，曲线的急剧下降将立即逆转，而增加“利用率”将导致更加平缓的上升。
除了短暂的初始颤振，PD 曲线和单个结冰曲线显示预测相对稳定。
月收入:罗恩的冰上曲线显示他接近曲线底部。如果他的月收入增加，那么他获得贷款的机会也会增加。
罗恩目前退休后每月有 5804 英镑的固定收入。ICE 曲线显示 Ron 的最佳水平需要高于 18，000。这比他目前的水平有了很大的提高。然而，ICE 曲线表明，即使 Ron 可以少量增加他的月收入(从而移动到曲线中黄色菱形标记的右侧)，他获得贷款的机会也会增加。与 Ron 讨论后，得出的结论是这不是他可以立即做的事情。然而，这次谈话确实让他更多地考虑去做兼职。
年龄:虽然曲线有一些有趣的波动，但不幸的是，这是我们无法控制的变量之一。然而，好消息是罗恩的 ICE 曲线表明，随着年龄的增长，他获得贷款的可能性保持不变。
OpenCreditLinesAndLoans:PD 曲线和 ICE 曲线都比较平坦。对于 Ron，值在 20 以下时会有一些小的变化，之后会稳定下来。
30–59 天逾期时间:该特征被定义为“借款人逾期 30–59 天的次数，但在过去 2 年中没有恶化”。
ICE 曲线显示，如果罗恩能够减少他的逾期付款，那么他获得批准的机会将大大增加。PD 曲线还显示，随着逾期付款的增加，贷款批准概率呈下降趋势。
尽管罗恩在过去的两年中只迟到过一次，但这仍然对他获得贷款批准的机会产生了巨大的影响。虽然这不是罗恩能马上解决的事情，但这是未来的一个重要收获。
将相关变量聚合为一个变量:过期 30–90 天
回想一下，我还尝试了一种将高度相关的变量组合起来的策略(即，“30–59 天时间”、“60–89 天时间”和“90 天时间”)。结果表明，ICE 曲线的总体形状与上述曲线相似(在浅恢复之前有一个陡峭的下降),并证实了付款的任何延迟都可能增加贷款下降的可能性的结论。
摘要
分析表明，“利用率”是解释 Ron 贷款申请被拒的最重要特征。为了最大化他将来获得贷款的机会，罗恩应该考虑三件事:
- 降低他的“利用率”。
- 如果可能的话，以后增加他的月收入。
- 确保他以后不拖欠债务。
在回顾了这些设想并与您讨论后，Ron 觉得有一些具体的行动值得考虑，并对自己的贷款被拒感觉好多了。
示例 2:员工保留
方案
照片由 loly galina 在 Unsplash 上拍摄
Sourabh 是你们研发团队的明星员工。他 30 多岁，已经在公司工作 5 年了。
作为他的经理，除了奖励他的表现，你还想更好地了解你能做些什么来确保他有动力留在公司。您会见了您的人力资源专家，他们使用 ML 模型来帮助预测员工流失，来讨论这个问题。
会议开始时并不顺利。你的人力资源专员告诉你，根据 ML 模型，Sourabh 很可能会离开。当务之急是，你和你的人力资源专员仔细检查结果，以进一步了解它，看看你需要采取什么步骤来留住 Sourabh。
数据:员工流失
本例的数据集是 IBM 关于员工流失的流行数据集。在删除了一些多余的特征并将数据减少到仅研发团队之后，我们最终得到 1470 条记录、24 个特征和一个目标变量“流失”。请注意，与前面的例子相比，在我们的分析和可视化中，我们需要处理更多的特性。
IBM 员工流失数据集的片段
数据探索
该数据集中有如此多的要素，以至于很难在此处查看和详细检查相关矩阵。然而，可以看出有许多变量是高度相关的。
25 个变量的相关矩阵
特别是，有两组高度相关的功能:
- 月收入和工作水平:0.99
- 工作年限和工作级别合计:0.79
毫不奇怪，个人的工作级别和薪酬(“工作级别”和“月收入”)之间存在关联，因为在许多公司，更高的工作级别通常意味着更高的货币薪酬。同样，晋升到更高的职位级别通常需要时间，因此职位级别高的个人也可能意味着他们在特定公司工作了多年(“TotalWorkingYears”和“job level”)。
出于稍后将讨论的原因，为了处理这些相关性，我选择移除其中一个特性(“JobLevel”)，而不是组合它们。与前面的示例一样，随机森林算法用于创建预测模型。这些功能的相对重要性如下:
剩余变量的相关矩阵
如上所示，“MonthlyIncome”是最终模型中最重要的特性。“MonthlyIncome”和下一个最重要的特性之间的差异比较大。之后，重要性会稳步下降。
冰原
由于有如此多的功能，我尝试了各种方法来显示尽可能多的 ICE 图，以提供这些功能的高级视图。我选定了一个 4x 4 的格子。结果是一个冰图的图标化呈现，从顶部最重要的特征开始，从左到右按重要性降序排列。
前 16 个特征的合成冰图
这个合成 ICE 图有效地概述了我们感兴趣的实例相对于前 16 个特征中的每一个的位置。尽管这些特征中的一些对预测的影响相对较低，但是看到它们的趋势仍然是有帮助的。回想一下，概率接近 1.0 意味着 Sourabh 更有可能离开，所以我们希望看到 Sourabh 的 ICE 曲线在 y 轴上更低。
让我们一次一行地检查这些特性，并详细关注更有趣的特性。
月收入
在最上面一行，除了“MonthlyIncome”之外，大多数特征都相对平坦。
“月收入”(较粗的黑线)的 PD 曲线显示，在稳定下来之前，月收入为 2，500 英镑(x 轴)时，流失概率下降到 0.15 左右(y 轴)。有趣的是，一旦大多数人的月收入达到 12500 英镑左右，自然减员的可能性就会增加，这表明月收入的增加只在一定程度上有效。之后，其他因素可能变得更加重要。
Sourabh 的 ICE 曲线反映了这种模式，只是它处于整体损耗概率的较高水平。他目前的月收入为 2313 英镑，接近 2500 英镑-3000 英镑可能会降低他离开的可能性。此后，在很长一段时间内，薪酬增加的回报可以忽略不计。
回想一下，为了处理“MonthlyIncome”和“JobLevel”之间的高度相关性，我们之前已经决定移除其中一个变量，而不是将它们合并。这被证明是正确的决定。否则，很难准确知道每月收入需要增加多少。
离家的距离
在复合冰图的第二行，有两个特征非常突出。首先是“离家的距离”功能:
PD 曲线表明“离家的距离”在 25 英里的范围内保持相对稳定，超过这个范围，损耗的可能性开始增加。ICE 曲线显示 Sourabh 处于离家距离的容许范围的边缘。如果这一距离增加，那么前往苏拉布的可能性也会增加。
如果通勤状况恶化，员工会考虑离开，这一事实并不令人惊讶。但是，ICE 图和突出显示单个实例的好处是，它允许我们以更高的精确度预测变化对单个员工的影响。
股票期权水平
这一行中另一个有趣的特性是“StockOptionLevel”。
Sourabh 目前没有获得任何股票期权。Sourabh 的 ICE 曲线表明，如果“股票期权水平”增加，那么自然损耗的可能性就会降低。ICE 曲线表明“StockOptionLevel”增加到 1.0 是最佳的，因为这是 Sourabh 的 ICE 曲线中的最低拐点。
在第三行，似乎没有任何值得调整的地方。自从 Sourabh 加入公司以来，他就一直和你——他的经理——在一起，这个模型表明，从减员的角度来看，这是一件好事。看起来，获得晋升(也许只是在工作层面)似乎不会影响自然减员的可能性。
最后，当我们移动到第四行中的较低重要性特征时，这些图上的曲线相对平坦。像其他图一样，Sourabh 的 ICE 曲线高于 PD 曲线，相对于其他人来说接近堆栈的顶部，支持他可能会离开的假设。
摘要
你从与人力资源专家的会面中得出的结论是，你需要尽快采取补救措施。分析表明，应考虑以下因素:
- “月收入”增加到 2，500-3，000 英镑。
- 提供“股票期权级别”为 1.0 的股票期权。
未来要考虑的另一个因素是，如果工作地点相对于员工的家有所增加，那么像 Sourabh 这样的员工流失的可能性将会受到影响。
在你的要求下，你的人力资源专员用新的数据再次进行预测。您发现调整“MonthlyIncome”(到 3，000)会使自然减员的概率达到 0.27。此外，增加“StockOptionLevel”(到 1.0)的额外调整会使损耗的概率更低，达到 0.22。
分析为您提供了一些要使用的参数的具体概念。会议结束后，你比开始时更加乐观。在您的预算允许的范围内，您渴望与 Sourabh 进行对话，并尽早采取适当的补救措施。
讨论和结论
这篇文章的目标是探索使用 ICE 图来帮助解释和影响个人决策的潜力。就我们为此做出的设计决策而言，我发现:
- 突出显示感兴趣的实例(通过带有圆形标记的蓝色冰曲线)和突出显示其当前特征值(通过黄色菱形标记)的组合使我们能够清楚地看到当前预测以及它如何随着不同的特征值而变化。
- 冰图的复合图标可视化提供了最重要特征的不同值如何影响预测结果的有用的高级视图。这种可视化有助于我们确定我们应该关注哪些特征来有效地影响变化；通常，当前特征值接近曲线上明显的方向变化。相反，如果 ICE 曲线相对平坦，则表明通过改变该特征的值，预测不太可能有任何显著变化。
- 在其他实例和 PD 曲线的上下文中突出显示单个实例不会导致难以管理的复杂性。回想一下第 1 部分，视觉复杂性是一个不确定的领域，我们想用更真实的例子来测试它。这里的分析表明，先前做出的设计决策是恰当的。ICE 图中剩余的实例提供了一个对比，从中我们可以看到我们的实例在总体中的位置。PD 曲线还用作参考，以查看当前实例是否偏离或符合数据集的平均值。
然而，需要指出的是，这种视觉清晰度可能是由于我们示例中的 PD 曲线和 ICE 曲线没有重叠(信贷申请示例中的“利用率”特征除外)。否则，两条曲线之间的细节差异可能会更加难以辨别。除了探索曲线的重叠和透明度级别的排序，未来可能的增强可能是提供一种交互地打开和关闭这些曲线的方法。这将允许更好地辨别图中有显著重叠的曲线。
关于分析过程，如以上示例所示，ICE 图的解释需要仔细导航。特别是，我们需要注意:
- 潜在动作的解释和推断需要关于特征特性的一般知识。在信贷申请示例中，知道我们能够控制一些功能(例如，“利用率”)，但不能控制其他功能(例如，“年龄”)，这使我们能够专注于我们能够做些什么的功能。一般来说，在决定采取什么样的潜在行动时，仔细考虑特性的特征是至关重要的，否则我们可能会做出错误的推断。
- 解释突出显示的 ICE 曲线可能需要专业领域知识。大多数人能够毫不费力地掌握信贷申请和人员保留等领域。但是，如果所涉及的特性属于需要大量学习和培训的领域，那么可能需要领域专家来解释结果，并推断可以采取什么潜在的行动。此外，向受影响的个人解释预测结果的任务，如我们的场景中所描述的，可能也更加困难。
汉斯·雷尼尔斯在 Unsplash 上的照片
- 使用 PDP 和 ICE 图时，要素工程和找出处理高度相关要素的最佳方法至关重要。在员工保留的例子中，归因的潜在困难意味着我们必须明智地决定放弃和保留哪些特征。在许多情况下，可能有必要采用试错法来测试处理高度相关特性的不同方法。
同样值得指出的是，在本文中，我们只使用了简单的方法来检测和处理线性关系。可以说，对于更复杂的关系(例如，非线性相关性)，可能需要更广泛的技术来处理它们。如果梳理出特征之间的相关性变得难以管理，我们可能不得不考虑使用替代的局部解释可视化技术。例如，累积局部效应(ALE)图避免了相关性问题，并且对其创建的支持变得越来越普遍。在任何情况下，这里显示的可视化方法，即突出感兴趣的个体实例，应该有利于在这类解释工具中解释和影响个体决策。
总之，这项研究表明，当小心使用时，ICE 图的修改版本在试图解释个人决策时非常有用，并有助于我们理解影响决策的因素。
可视化是为最大似然预测提供解释并使黑箱模型更加透明的重要工具。因此，这是一个值得更多关注的领域。考虑到这次探索的发现，带有适当可视化的 ICE 图可以成为 ML 个人决策分析工具包的一个有价值的补充。
参考
[1] Apley，D.W .和 Zhu，j .在黑盒监督学习模型中可视化预测变量的效果。arXiv:1612.08468
如何在面试时解释每个机器学习模型
从回归到支持向量机再到 XGBoost 的模型综述
由卡特曼戈斯塔创作—www.freepik.com
- 如果你喜欢这个， 跟我上 Medium 了解更多
- 关注我Kaggle了解更多内容！
- 我们连线上LinkedIn
- 有兴趣合作？查看我的 [网站](http://Want to collaborate?) 。
- 查看 我的免费数据科学资源 每周都有新素材！
在准备任何采访时，我想分享一个资源，提供每个机器学习模型的简明解释。它们并不意味着广泛，而是相反。希望通过阅读这篇文章，您会对如何以简单的方式交流复杂的模型有所了解。
涵盖的型号
- 线性回归
- 里脊回归
- 套索回归
- 逻辑回归
- k 最近邻
- 朴素贝叶斯
- 支持向量机
- 决策树
- 随机森林
- adaboost 算法
- 梯度增强
- XGBoost
线性回归
线性回归包括使用最小二乘法找到代表数据集的“最佳拟合线”。最小二乘法包括寻找最小化残差平方和的线性方程。残差等于实际值减去预测值。
举个例子，红线比绿线更适合，因为它离点更近，因此残差更小。
作者创建的图像
里脊回归
岭回归，也称为 L2 正则化，是一种引入少量偏差以减少过拟合的回归技术。这是通过最小化残差的平方和加上惩罚来实现的，其中惩罚等于λ乘以斜率的平方。λ指的是惩罚的严厉程度。
作者创建的图像
没有惩罚，最佳拟合的线具有更陡的斜率，这意味着它对 x 的小变化更敏感。通过引入惩罚，最佳拟合的线对 x 的小变化变得不那么敏感。这是岭回归背后的思想。
套索回归
套索回归，也称为 L1 正则化，类似于岭回归。唯一的区别是，惩罚是用斜率的绝对值来计算的。
逻辑回归
逻辑回归是一种分类技术，也能找到“最佳拟合线”。但是，与使用最小二乘法找到最佳拟合线的线性回归不同，逻辑回归使用最大似然法找到最佳拟合线(逻辑曲线)。这样做是因为 y 值只能是 1 或 0。 查看 StatQuest 的视频，看看最大似然是如何计算的 。
作者创建的图像
k-最近邻
作者创建的图像
K-最近邻是一种分类技术，其中通过查看最近的分类点对新样本进行分类，因此称为“K-最近”。在上面的例子中，如果 k=1，那么未分类的点将被分类为蓝点。
如果 k 值太低，它可能会受到异常值的影响。但是，如果它太高，可能会忽略只有几个样本的类。
朴素贝叶斯
朴素贝叶斯分类器是一种受贝叶斯定理启发的分类技术，贝叶斯定理陈述了以下等式:
因为假设变量是独立的，我们可以将 P(X|y)改写如下:
此外，由于我们求解 y，P(X)是一个常数，这意味着我们可以将其从等式中删除，并引入一个比例。
因此，y 的每个值的概率被计算为给定 y 的 xn 的条件概率的乘积。
支持向量机
支持向量机是一种分类技术，它找到一个最佳边界，称为超平面，用于区分不同的类别。通过最大化类之间的间隔来找到超平面。
作者创建的图像
决策树
决策树本质上是一系列条件语句，它们决定了样本在到达底部之前的路径。它们直观且易于构建，但往往不准确。
随机森林
随机森林是一种集成技术，这意味着它将几个模型结合成一个模型，以提高其预测能力。具体来说，它使用自举数据集和随机变量子集(也称为 bagging)构建了 1000 个较小的决策树。对于数千个较小的决策树，随机森林使用“多数获胜”模型来确定目标变量的值。
例如，如果我们创建一个决策树，第三个，它会预测 0。但是如果我们依赖所有 4 个决策树的模式，预测值将是 1。这就是随机森林的力量。
adaboost 算法
AdaBoost 是一种增强算法，类似于随机森林，但有两个显著的区别:
- AdaBoost 通常制作树桩森林(树桩是只有一个节点和两片叶子的树)，而不是树木森林。
- 每个树桩的决策在最终决策中的权重并不相等。总误差少(精度高)的树桩会有更高的话语权。
- 树桩创建的顺序很重要，因为每个后续树桩都强调在前一个树桩中被错误分类的样本的重要性。
梯度增强
梯度增强在某种意义上类似于 AdaBoost，它构建多棵树，其中每棵树都是基于前一棵树构建的。与 AdaBoost 构建树桩不同，Gradient Boost 构建的树通常有 8 到 32 片叶子。
更重要的是，Gradient 与 AdaBoost 在决策树的构建方式上有所不同。梯度增强从初始预测开始，通常是平均值。然后，基于样本的残差构建决策树。通过采用初始预测+学习率乘以残差树的结果来进行新的预测，并且重复该过程。
XGBoost
XGBoost 本质上与渐变增强是一样的，但是主要的区别是如何构建残差树。使用 XGBoost，通过计算叶子和前面的节点之间的相似性分数来构建残差树，以确定哪些变量被用作根和节点。
感谢阅读！
希望在读完这篇文章时，你会有一个想法，如何通过突出要点来总结各种机器学习模型。同样，这并不意味着是一篇深入的文章，解释每篇文章的复杂性。根据上面的总结，随意研究任何不完全有意义的模型！
特伦斯·申
- 如果你喜欢这个， 在 Medium 上关注我 获取更多
- 关注我的Kaggle了解更多内容！
- 我们连线上LinkedIn
- 有兴趣合作？查看我的 [网站](http://Want to collaborate?) 。
- 查看 我的免费数据科学资源 每周都有新素材！
如何导出 BigQuery ML 模型并将其部署用于在线预测
以 TensorFlow SavedModel 格式导出 BigQuery ML 模型并部署到云 AI 平台预测
在本文中，我将向您展示如何将 BigQuery ML 模型导出为 TensorFlow 的 SavedModel 格式。这将允许您将模型部署到任何支持 TensorFlow 服务的环境中。我将使用云人工智能平台预测来演示这一点，并向您展示如何调用在线预测。
1.训练 BigQuery ML 模型
当然，首先我们需要一个 BigQuery ML 模型。为了简单起见，我将在我们的书“ BigQuery:权威指南”中使用的同一个伦敦自行车数据集上使用一个简单的线性模型。
首先，在 EU 位置创建一个数据集来保存训练好的模型(可以在 CloudShell 中运行这个命令，也可以从 BigQuery 控制台执行这个操作；请确保选择 EU 作为地点):
bq show ch09eu || bq mk --location=EU ch09eu
接下来，在 BigQuery 控制台中运行这个查询:
CREATE OR REPLACE MODEL ch09eu.bicycle_model_linear
OPTIONS(input_label_cols=['duration'], model_type='linear_reg')
ASSELECT
duration
, start_station_name
, IF(EXTRACT(dayofweek FROM start_date) BETWEEN 2 and 6, 'weekday', 'weekend') as dayofweek
, FORMAT('%02d', EXTRACT(HOUR FROM start_date)) AS hourofday
FROM `bigquery-public-data`.london_bicycles.cycle_hire
这将创建一个名为 bicycle_model_linear 的模型，该模型采用 3 个输入(start_station_name、dayofweek、hourofday)来预测以秒为单位的持续时间。
2.在 SQL 中尝试批量预测
让我们试着调用 BigQuery 本身的模型。为此，运行以下查询:
SELECT * FROM ML.PREDICT(MODEL ch09eu.bicycle_model_linear,(
SELECT
'Vauxhall Cross, Vauxhall' AS start_station_name
, 'weekend' as dayofweek
, '17' AS hourofday)
)
这将返回:
如你所见，周末下午 5 点在沃克斯豪尔开始的一次骑行的预计持续时间是 1329 秒。
3.将模型导出到 Google 云存储
让我们从 BigQuery 下载这个模型作为 TensorFlow SavedModel。为此，从 CloudShell 运行以下命令:
PROJECT=$(gcloud config get-value project)
BUCKET=${PROJECT}-eu
gsutil mb -l eu gs://${BUCKET}
bq extract -m ch09eu.bicycle_model_linear \
gs://${BUCKET}/bqml_model_export/bicycle_model_linear
该命令的作用是创建一个名为 xyz-eu 的 bucket，其中 xyz 是您的项目名称。然后，我们调用 bq extract 将模型导出到 GCS。
命令完成后，检查导出了哪些文件:
gsutil ls gs://${BUCKET}/bqml_model_export/bicycle_model_linear/
当我这么做的时候，我得到了:
gs://ai-analytics-solutions-eu/bqml_model_export/bicycle_model_linear/
gs://ai-analytics-solutions-eu/bqml_model_export/bicycle_model_linear/saved_model.pb
gs://ai-analytics-solutions-eu/bqml_model_export/bicycle_model_linear/assets/
gs://ai-analytics-solutions-eu/bqml_model_export/bicycle_model_linear/variables/
这是 TensorFlow SavedModel 格式。您可以将它部署到任何 TF 服务环境中进行在线预测。在 GCP，TensorFlow/xgboost/PyTorch/etc 的全托管服务环境。models 是云 AI 平台(CAIP)的预测。
4.将模型部署到云人工智能平台预测
为了部署模型，从 GitHub 存储库中下载 deploy.sh 并运行它:
./deploy.sh gs://${BUCKET}/bqml_model_export/bicycle_model_linear \
europe-west1 london_bicycles bqml
deploy.sh 的作用是在 CAIP 预测中创建一个模型和模型版本，然后部署到其中。
部署模型可能需要 4-5 分钟，因此在进入下一步之前，请监控https://console . cloud . Google . com/ai-platform/models/London _ bicycles/versions以确保模型已部署。
5.尝试在线预测
用我们想要发送给模型的输入创建一个名为 input.json 的文件。您可以通过在 CloudShell 中键入以下内容来实现这一点:
cat > input.json
然后，在提示符下，键入:
{"start_station_name": "Vauxhall Cross, Vauxhall", "dayofweek": "weekend", "hourofday": "17"}
最后，按 Ctrl-D 返回到提示符。
使用以下方式将 input.json 发送到 CAIP 预测:
gcloud ai-platform predict --model london_bicycles \
--version bqml --json-instances input.json
当我这样做的时候，我回来了:
PREDICTED_LABEL
[1329.178180269723]
这与我们在 BigQuery ML 中进行批量预测时获得的持续时间相同。
CAIP 预测公开了一个采用 JSON 的 REST API，因此可以从任何能够进行 web 服务调用的语言中调用它。
尽情享受吧！
后续步骤:
如何将数百万条记录从 Mysql 导出到 AWS S3？
构建自我恢复和可扩展的系统
Apache Spark 生态系统信用:数据块
在 Twilio ，我们每天处理世界各地发生的数百万个电话。一旦通话结束，就会被记录到 MySQL 数据库中。客户能够通过 API 查询 调用 的详细信息。(是的，Twilio 是 API 驱动的公司)
我最近做的一个任务是建立一个系统，允许客户导出他们的历史通话数据。这将允许他们导出直到最近的所有历史通话记录
乍一看，这似乎是微不足道的，但是如果我们更深入地思考，一个系统将如何为从一开始就与我们合作的一些最大的客户进行扩展，这个问题可以归类为构建一个可扩展的系统。我们典型的客户规模从每天打几百个电话到几百万个不等。
当一个每天打 100 万个电话的大客户请求过去 5 年的数据时，这个问题突然变成了一个大数据问题。呼叫总数可以在 1，000，000 * 5 * 365 的范围内。
我不得不考虑如何优化从 Mysql 读取数据，并高效地向 S3 发送数据，以便下载文件。
可能的解决方案
1.编写一个 cron 作业，查询 Mysql 数据库中的特定帐户，然后将数据写入 S3。这对于获取较小的记录集可能很有效，但是为了使作业能够很好地存储大量记录，我需要构建一种机制来在失败时重试，并行读取和写入以实现高效下载，添加监控来衡量作业的成功。我将不得不编写连接器或使用库来连接 MySql 和 S3。
2.使用 火花流
我决定使用 Apache Spark 来处理这个问题，因为在我的团队中( Voice Insights )我们已经大量使用它来进行实时数据处理和构建分析。 Apache Spark 是一个用于构建可扩展实时处理应用的流行框架，在行业中广泛用于解决大数据和机器学习问题。Spark 的一个关键特性是它能够从 Kafka、Kinesis、S3、Mysql、文件等各种来源产生/消费数据。
Apache Spark 也是容错的，并提供了一个处理失败和优雅地重试的框架。它使用检查点机制来存储所执行任务的中间偏移量，以便在任务失败的情况下，任务可以从最后保存的位置重新开始。为水平扩展配置作业效果很好。
假设读者对 Spark 有基本的了解(Spark 官方 文档 是一个很好的起点)。我将深入研究代码。
让我们看看如何从 MySQL 数据库中读取数据。
**val** jdbcDF **=** spark.read
.format("jdbc")
.option("url", "jdbc:mysql://localhost:port/db")
.option("driver", "com.mysql.jdbc.Driver")
.option("dbtable", "schema.tablename")
.option("user", "username")
.option("password", "password")
.load()
与 JDBC 连接的另一种方法是将配置作为地图。
**val** dbConfig = Map("username" -> "admin",
"password" -> "pwd",
"url" -> "http://localhost:3306")
**val** query = "select * FROM CallLog where CustomerId=1"**val** jdbcDF **=** spark.read
.format("jdbc")
.options(dbConfig)
.option("**dbtable**", s"${query} AS tmp")
.load()
**OR****val** jdbcDF **=** spark.read
.format("jdbc")
.options(dbConfig)
.option("**query**", s"${query} AS tmp")
.load()
使用查询和 dbtable 有细微的区别。这两个选项都会在 FROM 子句中创建一个子查询。上述查询将被转换为
SELECT * FROM (SELECT * FROM CallLog where CustomerId=1) tmp WHERE 1=0
这里最重要的一点是query不支持partitionColmn，而dbTable支持分区，这通过并行实现了更好的吞吐量。
比方说，如果我们必须为我们的一个大客户导出通话记录，我们将需要利用分而治之的方法，并且需要一种更好的方法来并行化这项工作。
按列值对 SQL 查询进行分区
这意味着 Spark 可以同时对同一个表执行多个查询，但是每个查询通过为一个列(分区列)设置不同的范围值来运行。这可以在 Spark 中通过多设置几个参数来实现。让我们再看几个参数:
numPartitions选项定义了表中可用于并行读取的最大分区数。这也决定了并发 JDBC 连接的最大数量。
partitionColumn必须是相关表中的数值、日期或时间戳列。这些参数描述了在多个工作线程并行读取时如何对表进行分区。
lowerBound和upperBound只是用来决定分区步距，而不是用来过滤表中的行。因此表中的所有行将被分区并返回。此选项仅适用于阅读。
fetchSizeJDBC 提取大小，决定每次往返要提取多少行。这有助于提高默认为低读取大小的 JDBC 驱动程序的性能(例如，Oracle 有 10 行)。此选项仅适用于阅读。
上例中的partitionColumn可以是CallId。让我们试着把所有的参数联系起来。
**val** dbConfig = Map("username" -> "admin",
"password" -> "pwd",
"url" -> "http://localhost:3306",
"numPartitions" -> 10,
"paritionColumn" -> "CallId",
"lowerBound" -> 0,
"upperBound" -> 10,000,000)
**val** query = "select * from CallLog where CustomerId=1"**val** jdbcDF **=** spark.read
.format("jdbc")
.options(dbConfig)
.option("dbtable", s"(${query}) AS tmp")
.load()
上述配置将导致运行以下并行查询:
SELECT * from CallLog where CustomerId =1 AND CallId >=0 AND CallId <1,000,000
SELECT * from CallLog where CustomerId =1 AND CallId >= 1,000,000 AND CallId <2,000,000
SELECT * from CallLog where CustomerId =1 AND CallId>= 2,000,000 AND CallId <3,000,000
....
SELECT * from CallLog where CustomerId =1 AND CallId>= 10,000,000
上述查询并行化将有助于更快地从表中读取结果。
一旦 Spark 能够从 Mysql 读取数据，将数据转储到 S3 就变得轻而易举了。
jdbcDF.write
.format("json")
.mode("append")
.save("${s3path}")
结论:
上面的方法让我们有机会使用 Spark 来解决一个经典的批处理作业问题。我们正在用 Apache Spark 做更多的事情，这是众多用例中的一个。我很想听听你用火花在做什么。
如何将熊猫数据帧导出为 CSV 格式
在这篇文章中，我们将讨论如何将数据帧写入 CSV 文件。
简短回答
最简单的方法是:
df.to_csv('file_name.csv')
如果想不带索引导出，只需添加index=False；
df.to_csv('file_name.csv', index=False)
如果得到UnicodeEncodeError，简单加encoding='utf-8'；
df.to_csv('file_name.csv', encoding='utf-8')
概述熊猫数据框架
熊猫数据框架创建了一个带有标签轴(行和列)的 excel 数据结构。要定义一个数据帧，至少需要数据行和列名(标题)。
这里有一个熊猫数据帧的例子:
熊猫数据框架是类似 Excel 的数据
生成数据帧的代码:
将数据帧导出到 CSV 文件中
Pandas DataFrame to_csv()函数将数据帧导出为 CSV 格式。如果提供了文件参数，输出将是 CSV 文件。否则，返回值是类似字符串的 CSV 格式。
以下是一些选项:
path_or_buf :文件或字符串的字符串路径
dt.to_csv('file_name.csv’) # relative position
dt.to_csv('C:/Users/abc/Desktop/file_name.csv')
sep :为 CSV 输出指定一个自定义分隔符，默认为逗号。
dt.to_csv('file_name.csv',sep='\t') # Use Tab to seperate data
na_rep :类似 NaN 的缺失值的字符串表示。默认值为“”。
dt.to_csv('file_name.csv',na_rep='Unkown') # missing value save as Unknown
float_format: 浮点数的格式字符串。
dt.to_csv('file_name.csv',float_format='%.2f') # rounded to two decimals
表头:是否导出列名。默认值为 True。
dt.to_csv('file_name.csv',header=False)
列:要写入的列。默认值为 None，每一列都将导出为 CSV 格式。如果设置，只有列会被导出。
dt.to_csv('file_name.csv',columns=['name'])
索引:是否写行索引号。默认值为 True。
dt.to_csv('file_name.csv',index=False)
附录
写入 CSV 文件的常见场景
DataFrame to_csv()的语法是:
DataFrame.to_csv(
self,
path_or_buf,
sep: str = ',',
na_rep: str = '',
float_format: Union[str, NoneType] = None,
columns: Union[Sequence[Union[Hashable, NoneType]], NoneType] = None,
header: Union[bool, List[str]] = True,
index: bool = True,
index_label: Union[bool, str,
Sequence[Union[Hashable, NoneType]], NoneType] = None,
mode: str = 'w',
encoding: Union[str, NoneType] = None,
compression: Union[str, Mapping[str, str], NoneType] = 'infer',
quoting: Union[int, NoneType] = None,
quotechar: str = '"',
line_terminator: Union[str, NoneType] = None,
chunksize: Union[int, NoneType] = None,
date_format: Union[str, NoneType] = None,
doublequote: bool = True,
escapechar: Union[str, NoneType] = None,
decimal: Union[str, NoneType] = '.')
使用 to_csv 的常见场景
如何扩展 Keras 模型
使用 Keras 模型时传递实例键和特征
通常，您只需要 Keras 模型返回预测值，但是在某些情况下，您希望您的预测保留一部分输入。一个常见的例子是在执行批量预测时转发唯一的“实例键”。在这篇博客和对应的笔记本代码中，我将演示如何修改一个经过训练的 Keras 模型的签名，以将特性转发到输出或传递实例键。
通过实例键排序。照片由 Samantha Lam 在 Unsplash 上拍摄
如何将实例键转发到输出
有时，您会有一个与每一行相关联的唯一实例键，并且您希望该键与预测一起输出，以便您知道该预测属于哪一行。当使用类似云人工智能平台批量预测的服务执行分布式批量预测时，您需要添加密钥。此外，如果您正在对模型执行连续评估，并且想要记录有关预测的元数据以供以后分析。 Lak Lakshmanan 展示了如何使用张量流估值器实现这一点，但是 Keras 呢？
假设您有一个以前训练过的模型，它已经用tf.saved_model.save()保存了。运行以下代码，您可以检查模型的服务签名，并查看预期的输入和输出:
tf.saved_model.save(model, MODEL_EXPORT_PATH)!saved_model_cli show — tag_set serve — signature_def serving_default — dir {MODEL_EXPORT_PATH}The given SavedModel SignatureDef contains the following input(s):
inputs['image'] tensor_info:
dtype: DT_FLOAT
shape: (-1, 28, 28)
name: serving_default_image:0
The given SavedModel SignatureDef contains the following output(s):
outputs['preds'] tensor_info:
dtype: DT_FLOAT
shape: (-1, 10)
name: StatefulPartitionedCall:0
Method name is: tensorflow/serving/predict
要传递唯一的行键和先前保存的模型，请加载您的模型，创建一个替代的服务函数，然后重新保存，如下所示:
loaded_model = tf.keras.models.load_model(MODEL_EXPORT_PATH)@tf.function(input_signature=[tf.TensorSpec([None], dtype=tf.string),tf.TensorSpec([None, 28, 28], dtype=tf.float32)])
def keyed_prediction(key, image):
pred = loaded_model(image, training=False)
return {
'preds': pred,
'key': key
}# Resave model, but specify new serving signature
KEYED_EXPORT_PATH = './keyed_model/'loaded_model.save(KEYED_EXPORT_PATH, signatures={'serving_default': keyed_prediction})
现在，当我们检查模型的服务签名时，我们会看到它将键作为输入和输出:
!saved_model_cli show --tag_set serve --signature_def serving_default --dir {KEYED_EXPORT_PATH}The given SavedModel SignatureDef contains the following input(s):
inputs['image'] tensor_info:
dtype: DT_FLOAT
shape: (-1, 28, 28)
name: serving_default_image:0
inputs['key'] tensor_info:
dtype: DT_STRING
shape: (-1)
name: serving_default_key:0
The given SavedModel SignatureDef contains the following output(s):
outputs['key'] tensor_info:
dtype: DT_STRING
shape: (-1)
name: StatefulPartitionedCall:0
outputs['preds'] tensor_info:
dtype: DT_FLOAT
shape: (-1, 10)
name: StatefulPartitionedCall:1
Method name is: tensorflow/serving/predict
您的模型服务现在将在任何预测调用中同时期待一个image张量和一个key，并将在其响应中输出preds和key。这种方法的一个好处是，您不需要访问生成模型的代码，只需要访问序列化的 SavedModel。
如何利用多个服务签名
有时保存具有两个服务签名的模型是方便的，或者是出于兼容性原因(即默认签名是未加密的)，或者是为了使单个服务基础结构可以处理加密和未加密的预测，并且用户决定执行哪一个。您需要从加载的模型中提取服务函数，并在再次保存时将其指定为服务签名之一:
inference_function = loaded_model.signatures['serving_default']loaded_model.save(DUAL_SIGNATURE_EXPORT_PATH, signatures={'serving_default': keyed_prediction,
'unkeyed_signature': inference_function})
如何将输入要素转发到输出
出于模型调试的目的，您可能还希望转发某些输入要素，或者计算特定数据切片的评估指标(例如，根据婴儿是早产还是足月来计算婴儿体重的 RMSE)。
本例假设您使用了多个命名输入，如果您想利用 TensorFlow 特性列，您可以这样做，如这里的所述。您的第一个选择是像往常一样训练模型，并利用 Keras Functional API 创建略有不同的模型签名，同时保持相同的权重:
tax_rate = Input(shape=(1,), dtype=tf.float32, name="tax_rate")
rooms = Input(shape=(1,), dtype=tf.float32, name="rooms")x = tf.keras.layers.Concatenate()([tax_rate, rooms])
x = tf.keras.layers.Dense(64, activation='relu')(x)
price = tf.keras.layers.Dense(1, activation=None, name="price")(x)# Functional API model instead of Sequential
model = Model(inputs=[tax_rate, rooms], outputs=[price])# Compile, train, etc...
#
#
#forward_model = Model(inputs=[tax_rate, rooms], outputs=[price, tax_rate])
另一种方法，如果您没有生成模型的代码，则特别有用，就是像使用键控预测模型一样修改服务签名:
@tf.function(input_signature=[tf.TensorSpec([None, 1], dtype=tf.float32), tf.TensorSpec([None, 1], dtype=tf.float32)])
def feature_forward_prediction(tax_rate, rooms):
pred = model([tax_rate, rooms], training=False)
return {
'price': pred,
'tax_rate': tax_rate
}model.save(FORWARD_EXPORT_PATH, signatures={'serving_default': feature_forward_prediction})
尽情享受吧！
感谢 拉克什马南 帮我把他原来的估计器帖子更新到 Keras。
如何从熊猫的现有序列和数据框架中提取数据
探索地图的力量()并应用()
准备数据集的一个关键操作是从现有数据中提取信息。熊猫的两个重要功能是专门为完成这一任务而设计的——map()和apply()。我注意到，许多现有的教程都专注于介绍如何使用这些函数，而没有设置适当的上下文，以至于许多初学者仍然不知道在自己的项目中何时使用这些函数。在本文中，我想通过为这些功能设置适当的使用场景来解决这个问题，希望能够让您更容易地将这些用例直接转化为您自己特定的业务需求。
出于各种演示的目的，我们将在适用的地方使用以下系列和 DataFrame 对象。
抽样资料
场景 1。从现有系列创建系列
假设您从一个 Series 对象开始，并且您想要创建另一个具有基于相应值的单个值的序列。最好简单地在系列对象上使用map()功能。有多种方法可以使用map()函数，如下面的代码片段所示。
现有系列的映射
- 以上三种用法产生了一系列相同值的对象。
- 您可以使用另外一个参数—
na_action，它指定了映射如何处理现有序列的NaN值。您可以选择‘ignore’，这将在新系列中创建一个NaN值，或者选择None(默认选项)，这将把 NaN 值传递给映射字典或函数。你可以在这里了解更多。 - 因为 DataFrame 对象的行和列是 Series 对象，所以这个用例可以用来从现有的列创建 DataFrame 对象的新列(它也可以用于行)。以下代码向您展示了这样的用法—通过映射创建新行和新列。
数据框架映射新列
场景 2。从数据帧中的多个系列创建系列
有时需要从多行或多列中提取数据。为了简化本教程，我们假设需要从其他列创建一个列。在这种情况下，我们可以对 DataFrame 对象使用apply()函数。就像map()函数一样，你可以为apply()函数设置一个 lambda 函数或者一个常规函数。
数据框架创建列
- 参数
axis设置为 1，这意味着我们正在处理行，并且想要创建列。 - 当 axis=1 时，lambda 函数或常规函数的默认参数是行序列，其值可以使用键来访问(例如，
[‘col 0’])。 - 当需要指定额外的参数时，可以设置
args参数，这些参数除了行数据之外，还可以发送给映射函数。在示例中，我们将 5 设置为映射函数的额外参数的n。
场景 3。从现有系列创建多个系列
假设您需要从现有系列创建多个系列。您可以对 Series 对象使用apply()方法。请注意，尽管它与上一节提到的apply()函数同名，但这个函数是一个系列对象的方法，而前一个函数是 DataFrame 的方法。鉴于它们在功能上的相似性，它们只是碰巧有相同的名字。下面的代码向您展示了这种用法的一个简单例子。
从一个系列创建多个系列(即数据帧)
如前所述，因为 DataFrame 的列是 Series 对象，所以我们可以从 DataFrame 列创建多个列。下面的代码向您展示了它是如何工作的。
从一个列创建新列
- 正如前面的代码示例，Series 对象上的
apply()方法必须返回一个 Series 对象(注意 lambda 函数创建了一个 Series 对象)。这里，我们创建了一个包含两个值的 Series 对象，因为我们创建了两列。 - 您必须在等式的左侧指定您正在创建的列，以便新创建的列可以知道去哪里。
场景 4。从多个系列创建多个系列(即数据帧)
在 Pandas 中，DataFrame 对象可以被认为在两个轴上都有多个系列。因此，本节标题中描述的场景本质上是从现有列创建新列或从现有行创建新行。最好的方法是在 DataFrame 对象上使用apply()方法。为了简单起见，让我们只考虑在下面的例子中从现有的列创建新的列，然后进行一些说明。
多列中的多列
- lambda 函数(也可以使用常规的定义函数)正在创建一个包含两项的列表，因为我们创建了两列。
- lambda 函数中的 x 表示行数据，我们可以使用列名来访问各个值。
- 这里重要的是将
result_type参数指定为‘expand’，这将扩展 lambda 函数的结果以形成新的列。换句话说，这里的 lambda 函数创建了一个包含两项的列表，该列表将被扩展为两列。
值得注意的是，result_type论点还有其他一些选择。例如，默认选项是None，它不扩展结果并保持不变。另一个选项是‘reduce’，它通过返回一个序列对象完成与‘expand’选项相反的工作。要了解关于这些不同选项的更多信息，您可以在这里查阅文档。 - 示例中没有包括的一件事是，正如第 2 节中使用
apply()方法显示的结果一样，我们可以提供将在映射函数中使用的附加位置和关键字参数。
结论
在本文中，我们介绍了如何以 Series 和 DataFrame 对象的形式从现有数据创建新的 Series 对象(例如，行和列)。我们确定了您在项目中可能遇到的四种最常见的使用场景，这将允许您根据自己的需要修改这里的代码。
如何使用 Python 从 PDF 表单中提取数据
理解用于数据挖掘的 PDF 文档的对象模型
莱昂·德维耶在 Unsplash 上拍摄的照片
介绍
PDF 或可移植文档文件格式是当今最常用的文件格式之一。它广泛应用于企业、政府机构、医疗保健和其他行业。因此，存在大量 PDF 格式的非结构化数据，提取和分析这些数据以生成有意义的见解是数据科学家的共同任务。
我在一家金融机构工作，最近遇到一种情况，我们必须从大量 PDF 表单中提取数据。虽然有大量的工作可以用来描述从 PDF 文档中提取简单的文本，但是我很难找到一个全面的指南来从 PDF 表单中提取数据。我写这篇文章的目的就是开发这样一个指南。
有几个专门处理 PDF 文档的 Python 库，其中一些比另一些更受欢迎。出于本文的目的，我将使用 PyPDF2 。PyPDF2 是一个纯 Python 库，作为 PDF 工具包构建。作为纯 Python，它可以运行在任何 Python 平台上，没有任何依赖或外部库。您可以通过执行下面的代码来使用 pip 安装这个库。
pip install PyPDF2
一旦您安装了 PyPDF2，您应该已经准备好了。我们将快速浏览一下 PDF 文件的结构，因为这将帮助我们更好地理解从 PDF 表单中提取数据的编程基础。我将简要讨论广泛使用的两种 PDF 表单。然后，我们将直接进入示例，从两种类型的 PDF 表单中提取数据。
PDF 文件的结构
不要把 PDF 文档看作一个整体，而应该把它看作一个对象的集合。所有这些物体都以一种固定的模式排列。如果您在文本编辑器(如记事本)中打开 PDF 文件，内容可能没有多大意义，看起来像垃圾。但是，如果您使用一个工具来提供对 PDF 对象的低级访问，您可以看到并欣赏底层结构。例如，请看下面的图 1。我用 iText RUPS 打开了一个简单的 PDF 文档。左边的图片是我在阅读器应用程序(Acrobat Reader)中打开的一个简单的 PDF 文档。中间的图像显示了由 RUPS iText 渲染的该文档的低级对象模型。右边的图像显示了捕获 PDF 第一页内容的数据流。正如您所看到的，对象模型(中间的图像)有一个固定的模式，并且封装了独立于软件、硬件、操作系统等呈现文档所需的所有元数据。这种结构是 PDF 如此通用和受欢迎的原因。
图 1—PDF 文件的结构
PDF 表单
有两种主要类型的 PDF 表单。
- 基于 XFA (XML 表单架构)的表单
- Acroforms
Adobe(开发 PDF 格式的公司)有一个名为 AEM(Adobe Experience Manager)Forms Designer 的应用程序，旨在使客户能够创建和发布 PDF 表单。Adobe 使用术语 PDF 表单来指代使用 AEM Forms Designer 创建的交互式和动态表单。这些 PDF 表单基于 Adobe 的 XML Forms Architecture (XFA ),后者基于 XML。这些表单本质上可以是动态的，可以根据用户输入重排 PDF 内容。
还有另一种类型的 PDF 表单，称为 Acroform。Acroform 是 Adobe 在 1996 年作为 PDF 1.2 规范的一部分引入的较早的原始交互表单技术。Acroforms 是定义静态布局的传统 PDF 与固定在顶部的交互式表单域的组合。首先，使用 Microsoft Word、Adobe InDesign 或 Adobe Illustrator 等设计表单布局。然后添加表单元素——字段、下拉控件、复选框、脚本逻辑等。
从基于 XFA 的 PDF 表单中提取数据
下面的图 2 显示了一个基于 XFA 的 PDF 表单的截图，我们将用它作为这个练习的例子。这是银行和其他机构用来向监管机构报告某些金融交易的货币交易报告表。这是一个动态表单，您可以根据需要报告的信息量来添加和删除部分。我已经用一些虚拟数据部分地填写了这个表格。
图 2 — XFA 表单示例
图 3 显示了这个表单的对象模型。图像右侧显示的 XML 文档构成了 XFA，它作为 XFA 键的值存储在 AcroForm 字典中(请看图像左侧的对象模型)。Acroform 字典是目录字典的子元素，目录字典位于 PDF 文件的根目录中。我们需要做的就是使用 PyPDF2 从这个文件的对象结构中访问 XML 文档。一旦我们访问了 XML，就很容易解析出 XML 文档来访问各种表单元素的值，然后可以将这些值存储到 Python 列表、Numpy 数组、Pandas dataframe 等中。为了分析的目的。
图 3 —示例 XFA 的对象模型
下面是提取组成这个表单的 XML 的代码。
import PyPDF2 as pypdfdef findInDict(needle, haystack):
for key in haystack.keys():
try:
value=haystack[key]
except:
continue
if key==needle:
return value
if isinstance(value,dict):
x=findInDict(needle,value)
if x is not None:
return xpdfobject=open('CTRX_filled.pdf','rb')pdf=pypdf.PdfFileReader(pdfobject)xfa=findInDict('/XFA',pdf.resolvedObjects)
xml=xfa[7].getObject().getData()
在第一行中，我只是导入 PyPDF2 库，并为它提供一个别名——pypdf。第二行是函数定义的开始，通过提供字典键来查找字典的元素。您可能还记得我们上面的讨论，我们的 XML 嵌入在一个由键“/XFA”引用的字典中。这个函数帮助我导航 PDF 文件的复杂对象模型，它基本上是嵌入在多组字典中的一组字典。在函数定义之后的一行中，我正在读取 PDF 表单并创建一个 PdfFileReader 对象。该类的 resolvedObjects 方法将 PDF 对象模型分解为一组 Python 字典。然后，我调用 find submit 函数提取“/XFA”字典的元素，这是一个数组，如下面的图 4 所示。
图 4 — XFA 阵列
这个数组的第七个元素是组成表单的实际 XML 内容。它是一个间接对象。IndirectObject 是指向实际对象的别名。当同一对象出现在多个位置时，此引用有助于减小文件的大小。代码最后一行中使用的 getObject()方法检索实际的对象。如果对象是一个文本对象，使用 str()函数应该会给出实际的文本。否则，需要使用 getData()方法来呈现对象中的数据。下面是在上面代码的最后一行中检索到的一部分 XML 的快照。您可以看到我在示例表单中输入的一些虚拟地址数据。您可以很容易地从 XML 中解析出这些数据，并将其用于进一步的分析。
图 5 —从 XFA PDF 表单中检索到的 XML 的快照
从 Acroforms 中提取数据
这一个相对容易，因为我们已经在上面的章节中讨论了与 PDF 对象模型相关的大部分概念。下面是一份所得税表格的样本，我将用它作为例子。我在里面放了一些假数据。
图 6 — Acroform 示例
下面的图 7 显示了这个表单的对象模型。
图 7 — Acroform 示例对象模型
各个表单字段的值由嵌入在“/Fields”中的键“/V”引用，而键“/V”又嵌入在“/AcroForm”中。“/AcroFrom”是此 PDF 文件的根目录字典的子目录。我们可以使用我们在 XFA 表单中使用的方法，使用‘find submit’函数来检索'/Fields '字典，然后检索各个字段的值。幸运的是，PyPDF2 提供了一种更直接的方法来实现这一点。PdfFileReader 类提供了一个 getFormTextFields()方法，该方法返回所有表单值的字典。下面是简短的代码。图 8 显示了输出。dictionary 对象可以很容易地转换成一个列表或一个熊猫数据帧，以便进一步处理。
import PyPDF2 as pypdfpdfobject=open('incometaxform_filled.pdf','rb')pdf=pypdf.PdfFileReader(pdfobject)pdf.getFormTextFields()
图 8 — AcroForm 示例输出
结论
一旦您理解了底层对象模型，从 PDF 表单中提取数据就很容易了，PyPDF2 是一个强大的库，使您能够访问它。享受数据带来的乐趣！
如何从任何 Youtube 视频中提取面部表情、头部姿势和凝视
数据科学教程
使用 Google Colab & OpenFace 从 Youtube 视频中提取面部特征的教程，无需在笔记本电脑上安装任何程序。
通过研究人们的面部表情、头部姿势和凝视信息，可以研究和分析人们的感受、想法和兴趣。有许多公司和计算机视觉算法可以帮助从面部视频中提取这些面部特征，包括 Emotient 和 Affectiva(它们的算法对比这里、这里)，但很少有公司免费提供这些服务，大多数公司要求用户购买订阅或按视频分钟付费。
在这篇文章中，我分享了一个免费的、易于使用的、健壮的面部特征提取付费服务的替代方案，它使用了 OpenFace ，这是一个最先进的面部动作单元识别、凝视估计、面部标志检测和头部姿势估计工具。在这里，我分享如何使用 Google Colab Jupyter 笔记本的说明，它允许你设置 OpenFace 并从任何 Youtube 视频中提取面部特征，而不必在你的笔记本电脑上安装一个软件包。
1.设置
您不需要在您的笔记本电脑上安装任何东西，但是您仍然需要在您的 Colab 实例上安装 OpenFace 包。不幸的是，这一部分可能需要一段时间(大约 40 分钟)，这段时间非常适合你看一些 Youtube 视频，以确定你想从哪个视频中提取面部特征。哦，你可能需要一个谷歌账户。
2.找个 Youtube 视频分析一下。
找一个你想分析的 Youtube 视频。它可以是一个人的面部视频，也可以是多个人的面部视频。只是要小心避免视频中的人脸太小，这使得大多数算法很难找到人脸。在本教程中，我们将从我和我的同事为 Pioneer.app 推出的一个应用创意 TasteSpace 中提取面部特征。下面的代码将向您展示感兴趣的视频。
这是我们将要使用的视频..我们正在描述一个名为 TasteSpace 的项目。
接下来的几行代码下载视频并剪辑视频的前几秒(10 秒)。这只是为了节省处理时间，所以如果你想处理整个视频，可以随意移除第五行的-t 10标志。
如果你想从整个视频中提取特征，你可以去掉“-t 10”标志(这会花更长时间)。
3.使用 OpenFace 处理视频
现在我们将使用可以同时从多张人脸中提取面部特征的FaceLandmarkVidMulti。
如果你在视频中一次只有一张脸，那么你可以使用FeatureExtraction来代替，或者如果你想从图像中提取特征，可以使用FaceLandmarkImg。单击此处查看命令行函数及其参数的完整列表。
4.可视化结果！
您可以使用下面的代码来可视化结果，如果输出有意义，您可以直接从笔记本上检查。
5.下载输出。
你现在可以通过打开你的 Colab 笔记本左边菜单上的文件标签来下载提取的面部特征，并将文件下载到processed/videos.csv文件夹中。
展开文件选项卡并下载结果。
结论
希望这是一个有趣的练习，教你如何使用 Google Colab 和 OpenFace 在几分钟内(安装后)从任何 Youtube 视频中提取面部特征。如果你有兴趣了解更多关于如何在这种面部表情数据中分析个体之间的同步性，请随时查看我以前关于如何做到这一点的帖子。
用于计算同步指标的样本代码和数据，包括皮尔逊相关、时滞交叉相关…
towardsdatascience.com](/four-ways-to-quantify-synchrony-between-time-series-data-b99136c4a9c9)
额外学分
如果你还在读这篇文章，你可能会对如何处理 OpenFace 的输出感兴趣，这里有一些额外的代码可以帮助你入门。
加载数据
首先，我们将数据加载到 Pandas 数据帧中，重命名列以消除空白，评估数据帧的形状、数据的最高帧数，并绘制数据的头部。
从视频中计数唯一个体的数量
您可能会注意到第face_id列，它试图区分视频中的个人。
看起来我们有 4 张不同的脸，而不是 3 张！
从视频中检测人脸的平均模型置信度
我们可以使用以下函数进一步评估该算法检测每个人脸的置信度。
可视化视频中人脸的位置
我们看到face_id==3具有最低的置信度，这可能是被检测到的伪造人脸。让我们通过在整个剪辑中绘制人脸的位置来进一步检查这一点。
我们可以看到，在左边的图中，face_id==3 的脸确实在某个不存在脸的地方。我们可以根据任意置信水平(这里我们使用 80%)设定输出阈值，在左侧的图中我们可以看到，我们已经消除了伪脸。
分析面部肌肉随时间的运动
现在让我们画出每张脸的每个动作单元预测的轨迹随时间的变化情况。然后，我们将打印出视频中人们在一段时间内是如何相似地微笑的(动作单元 12)。
每个 face_id 的 AU 强度预测随时间的时间序列
每对个体微笑的相关性(AU12)。
随着时间的推移分析眼睛凝视
最后，我们可以画出每个人在看哪里。这可能不是画弧度角的最好方法，但是你仍然可以感觉到每个面在看哪里。这通过了完整性检查，即左边的面(face_id2)主要从原点(0，0)看向右边，右边的面(face_id0)看向左边，中间的面看向两边。
如果你想了解更多关于不同输出的信息，我强烈推荐你在 OpenFace wiki 中阅读更多关于每个输出代表什么的信息。
在媒体上阅读金贤昌的作品。人类行为和数据科学爱好者||认知神经科学博士…
medium.com](https://medium.com/@jinhyuncheong)
如何使用值从 Python 字典中提取键
从 python 字典给定值中提取键的四种方法
如果我们有钥匙，提取价值就像用钥匙开锁一样简单。但是，反过来就没那么简单了，像“开锁”，可能！
有时候提取键变得很重要，尤其是当键和值是一对一的关系时。也就是说，当它们中的任何一个是唯一的，因此可以充当键时。
在研究各种方法之前，首先我们将创建一个字典来进行说明。
currency_dict 是以货币缩写为键，货币名称为值的字典。
currency_dict={'USD':'Dollar',
'EUR':'Euro',
'GBP':'Pound',
'INR':'Rupee'}
如果有键，只需将键加在方括号中就可以得到值。
例如， currency_dict['GBP'] 将返回 'Pound '。
方法 1:使用列表
步骤 1:将字典键和值转换成列表。
第二步:从值列表中找到匹配的索引。
步骤 3:使用索引从密钥列表中找到合适的密钥。
key_list=list(currency_dict.keys())
val_list=list(currency_dict.values())
ind=val_list.index(val)
key_list[ind]Output: 'GBP'
所有这三个步骤可以合并为一个步骤，如下所示:
list(currency_dict.keys())[list(currency_dict.values()).index(val)]
方法 2:使用 For 循环
方法 1 可以使用一个 for 循环稍微修改一下，如下:
步骤 1:将字典键和值转换成列表。
第二步:遍历值列表中的所有值，找到需要的值
第三步:从键列表中返回对应的键。
def return_key(val):
for i in range(len(currency_dict)):
if val_list[i]==val:
return key_list[i]
return("Key Not Found")return_key("Rupee")Output: 'INR'
方法 3:使用项目()
items()将字典元素保持为键值对。
步骤 1:遍历 item()中的所有键值对。
步骤 2:找到与所需值匹配的值
步骤 3:从键-值对中返回键。
def return_key(val):
for key, value in currency_dict.items():
if value==val:
return key
return('Key Not Found')return_key('Dollar')Output: 'USD'
方法 4:使用 Pandas 数据框架
在我看来，在转换成数据帧后获取密钥是最简单易懂的方法。
然而，这并不是最有效的方法，在我看来，这应该是方法 1 中的一行程序。
字典可以转换成如下熊猫数据帧:
df=pd.DataFrame({'abbr':list(currency_dict.keys()),
'curr':list(currency_dict.values())})
所有键都在列'缩写'中，所有值都在数据帧' df' 的' curr' 列中。
现在查找值非常简单，只需从【curr】列的值为所需值的行返回【缩写】列的值。
df.abbr[df.curr==val]Output: 2 GBP
比听起来简单多了！
注意，输出也包含索引。输出不是字符串格式，但它是熊猫系列对象类型。
可以使用许多选项将 series 对象转换为 string，下面是几个选项:
df.abbr[df.curr==val].unique()[0]
df.abbr[df.curr==val].mode()[0]
df.abbr[df.curr==val].sum()Output : 'GBP'
资源
这篇文章的代码可以在我的 GitHub Repo 中找到。
如果你对视觉格式更感兴趣，你可以看看我的 YouTube 视频
作者的 YouTube 教程
成为会员
我希望你喜欢这篇文章，我强烈推荐 注册中级会员 来阅读更多我写的文章或成千上万其他作者写的各种主题的故事。
你的会员费直接支持我和你看的其他作家。你还可以在 Medium 上看到所有的故事。
这里是我的一些其他文章，你可能会觉得有趣…干杯！
在你的媒体文章中嵌入代码的两种简单方法。
abhijithchandradas.medium.com](https://abhijithchandradas.medium.com/how-to-embed-code-in-medium-4bd380c8102d) [## 如何在 Matplotlib/ Seaborn 中向散点图添加文本标签
使用 Seaborn 或 Matplotlib 库时，如何在 python 中向散点图添加文本标签的分步指南。
towardsdatascience.com](/how-to-add-text-labels-to-scatterplot-in-matplotlib-seaborn-ec5df6afed7a) [## 新冠肺炎酒吧比赛图表使用繁荣
竞赛条形图是一个非常简单的工具，可以用来比较随时间变化的数量。简单来说，就是一个条形图…
towardsdatascience.com](/covid-19-bar-race-chart-using-flourish-89136de75db3) 
照片由 Hitesh Choudhary 在 Unsplash 上拍摄
如何从维基百科中提取知识，数据科学风格
WikiData 和 SPARQL 查询语言简介
作为数据科学家，人们倾向于认为他们所做的是开发和试验复杂的算法，并产生最先进的结果。这在很大程度上是真实的。这是数据科学家最引以为豪的，也是最具创新性和回报最大的部分。但是人们通常看不到的是他们为收集、处理和整理数据而付出的汗水，这些数据带来了巨大的成果。这就是为什么你可以看到 SQL 出现在大多数数据科学家的职位要求上。
SPARQL 是什么？
T 这是另一种查询语言，在从多个来源和数据库获取数据时可能非常有用，维基百科是其中最大的一个。查询语言叫做 SPARQL 。根据维基百科:
SPARQL (读作" sparkle "，是 SPARQL 协议和 RDF 查询语言的递归缩写词)是一种 RDF 查询语言——也就是说，一种用于数据库的语义 查询语言——能够检索和操作存储在资源描述框架(rdt23)中的数据
这不是一个很好的定义。它几乎没有告诉你它能做什么。把它翻译成人类可读的语言:
SPARQL 是一种语法上类似于 SQL 的查询语言，但它工作在像 Wikipedia 这样的知识图数据库上，允许您通过定义一系列过滤器和约束来提取知识和信息。
如果这对你来说还是太抽象，请看下图:
获得诺贝尔化学奖
这是一个诺贝尔化学奖的时间表，由维基数据查询服务网站使用以下代码生成:
#Awarded Chemistry Nobel Prizes
#defaultView:Timeline
SELECT DISTINCT ?item ?itemLabel ?when (YEAR(?when) as ?date) ?pic
WHERE {
?item p:P166 ?awardStat . # … with an awarded(P166) statement
?awardStat ps:P166 wd:Q44585 . # … that has the value Nobel Prize in Chemistry (Q35637)
?awardStat pq:P585 ?when . # when did he receive the Nobel prize
SERVICE wikibase:label { bd:serviceParam wikibase:language "en" . }
OPTIONAL { ?item wdt:P18 ?pic }
}
任何熟悉 SQL 的人都会发现上面的代码非常直观。我将使用另一个例子来解释基本上如何制定类似的查询来获得您感兴趣的结果。
起点:维基百科页面
PARQL 在多个知识图数据库上工作。要知道什么是知识图谱，先从大家都熟悉的东西说起:维基百科。当大多数人想要研究一个主题时，维基百科是他们的首选。如果你去 Python 创始人吉多·范·罗苏姆的页面，你会看到一个详细的页面，里面有各种有用的信息。
组织页面:维基数据
这个页面的问题在于它没有条理。你可以搜索关键词，但是你不能轻易地找出信息节点之间的关系。这就是知识图表发挥作用的地方。上面页面上的红色矩形拼写为“Wikidata Item”，单击它会将您带到同一页面的知识图表视图:
开始查询
在我们看到之前，所有关于 Guido 的信息都被很好地组织成类别，每个类别都有多个条目。使用 SPARQL，您可以很容易地查询这些信息。为此，维基百科提供了另一个页面，一个用户友好的查询服务，名为维基数据查询服务:
这是我们可以试验 SPARQL 的地方。在 WikiData 页面上，我们观察到 Guido 是一名程序员(显然！)，现在如果我们想知道在维基百科上有条目的其他程序员呢？让我们看看 SPARQL 代码:
SELECT ?personWHERE {?person wdt:P106 wd:Q5482740 .}
这里我们定义了一个?person作为感兴趣的主题，这也是我们的查询结果中的一列。然后我们用WHERE指定一些约束。约束是wdt:P106需要是wd:Q5482740。什么？你说。让我更详细地解释一下。wdt是主语的“谓语”或“属性”的前缀，而wd是属性的值(SPARQL 术语中的对象，但这并不重要)的前缀。wdt:表示我将在这里指定主题的一个属性，wd:表示我将指定这个属性的值。那么什么是P106和Q5482740？这些只是特定属性和值的代码。P106代表‘职业’，Q5482740代表‘程序员’。这行代码的意思是，我想让?person主题有一个‘程序员’的‘职业’属性。没那么可怕了，对吧？你可以在上面提到的维基数据页面上很容易地找到这些代码。
运行查询，您将获得以下结果:
从代码到名称
我们得到了一堆person不同wd:value的物品。如果你仔细观察这个值，它们实际上是另一个人的代码。比如第一个wd:Q80是WWW 的发明者蒂姆·伯纳斯·李。这是不直观的，我们希望能够直接看到名字。为此，我们添加了一个 WikiData“标签服务”,帮助我们将代码转换为名称，如下所示:
SELECT ?person ?personLabelWHERE { ?person wdt:P106 wd:Q5482740 .
?person rdfs:label ?personLabel .
FILTER ( LANGMATCHES ( LANG ( ?personLabel ), "fr" ) )
}
类似的语法，我们希望person 有一个‘label’属性，我们定义了一个personLabel 值变量来保存这些值，这样我们就可以在查询结果中显示它们。此外，我们将personLabel添加到我们的SELECT短语中，因此它将被显示。请注意，我还在下面添加了一个过滤器，只显示法语语言标签，否则将为一个人显示多个语言标签，这不是我们想要的:
缩小范围
从上面的结果中，我们可以看到我们有大约 790 个结果。这太多了。让我们把范围缩小到那些在行业中“重要”的人。具有“值得注意的工作”属性的人:
SELECT ?person ?personLabel ?notableworkLabelWHERE {?person wdt:P106 wd:Q5482740 .
?person rdfs:label ?personLabel .
FILTER ( LANGMATCHES ( LANG ( ?personLabel ), "fr" ) )
?person wdt:P800 ?notablework .
?notablework rdfs:label ?notableworkLabel .
FILTER ( LANGMATCHES ( LANG ( ?notableworkLabel ), "fr" ) )
}
再次，wdt:P800表示‘值得注意的作品’属性，其他都类似。然后我们得到以下结果:
组合多个标签
现在我们只有 175 个结果，每个人值得注意的工作也列出来了。但是等等，为什么我们有五个理查德·斯托尔曼？原来，理查德有不止一部著名的作品，因此在搜索结果中多次出现。让我们通过将所有值得注意的工作归入一个属性来解决这个问题:
SELECT ?person ?personLabel ( GROUP_CONCAT ( DISTINCT ?notableworkLabel; separator="; " ) AS ?works )WHERE {?person wdt:P106 wd:Q5482740 .
?person rdfs:label ?personLabel .
FILTER ( LANGMATCHES ( LANG ( ?personLabel ), "fr" ) )
?person wdt:P800 ?notablework .
?notablework rdfs:label ?notableworkLabel .
FILTER ( LANGMATCHES ( LANG ( ?notableworkLabel ), "fr" ) )
}GROUP BY ?person ?personLabel
这里用的是‘T1’。还有，GROUP_CONCAT函数用于将多个notableworkLabel 串联成一个新列works ( 我不会解释这些函数是如何工作的，只是想快速向您展示 SPARQL 能做什么。如果你想了解更多，请随时谷歌，那里有大量的教程文章和视频):
表面
现在我们有一个 90 个结果的列表，包括软件工程世界中所有的“名人录”。但是 SPARQL 可以做得更多。让我们给这些名字添加一些面孔:
SELECT ?person ?personLabel ( GROUP_CONCAT ( DISTINCT ?notableworkLabel; separator="; " ) AS ?works ) ?imageWHERE {?person wdt:P106 wd:Q5482740 .
?person rdfs:label ?personLabel .
FILTER ( LANGMATCHES ( LANG ( ?personLabel ), "fr" ) )
?person wdt:P800 ?notablework .
?notablework rdfs:label ?notableworkLabel .
FILTER ( LANGMATCHES ( LANG ( ?notableworkLabel ), "fr" ) )
OPTIONAL {?person wdt:P18 ?image}
}GROUP BY ?person ?personLabel ?image
同样的模式，我们只是添加了一个OPTIONAL 关键字 prior，因为我们不想排除那些在个人资料中没有图片的人。我们还将视图切换到“图像网格”:
他们在哪里？
哇！这样好多了。我看到了一些熟悉的面孔！也许你想知道这些家伙在哪里？让我们来看看:
#defaultView:ImageGridSELECT ?person ?personLabel ( GROUP_CONCAT ( DISTINCT ?notableworkLabel; separator="; " ) AS ?works ) ?image ?countryLabel ?coodWHERE {
?person wdt:P106 wd:Q5482740 .
?person rdfs:label ?personLabel .
FILTER ( LANGMATCHES ( LANG ( ?personLabel ), "fr" ) )
?person wdt:P800 ?notablework .
?notablework rdfs:label ?notableworkLabel .
FILTER ( LANGMATCHES ( LANG ( ?notableworkLabel ), "fr" ) )
OPTIONAL {?person wdt:P18 ?image} OPTIONAL {?person wdt:P19 ?country .
?country rdfs:label ?countryLabel .
?country wdt:P625 ?cood .
FILTER ( LANGMATCHES ( LANG ( ?countryLabel ), "fr" ) )
}}GROUP BY ?person ?personLabel ?image ?countryLabel ?cood
你也许可以破译你上面的密码。基本上就是说我要这个人有一个属性country，放入一个变量country，然后找出国家的coordinates ，放入一个变量cood。有了坐标，我们可以激活“地图”视图:
我们可以看到，美国有很多，欧洲有一些，世界其他地方也有一些。
更多示例
通过几行代码，我们找出了软件行业中的重要影响者，他们为人所知，他们在哪里，他们看起来怎么样。如你所见，这里的潜力是无限的。
你可以点击维基数据页面上的“示例”按钮，找到更多有趣的例子。
作为本文的一项任务，您能想出如何添加“出生日期”属性并生成一个类似本文开头的时间线图吗？
结论
在这篇文章中，我们使用 WikiData 作为知识图示例来介绍 SPARQL 查询语言。还有其他知识图表，如 DBpedia 等。这篇文章绝不是一个全面的教程。我只是想把这种语言介绍给更多的人，这样知识和信息的提取就能更有效地进行。
觉得这篇文章有用？在 Medium 上关注我(李立伟)或者你可以在 Twitter @lymenlee 或者我的博客网站wayofnumbers.com上找到我。你也可以看看我下面最受欢迎的文章！
为什么 CS50 特别适合巩固你的软件工程基础
towardsdatascience.com](/this-is-cs50-a-pleasant-way-to-kick-off-your-data-science-education-d6075a6e761a) [## 一枚硬币的两面:杰瑞米·霍华德的 fast.ai vs 吴恩达的 deeplearning.ai
如何不通过同时参加 fast.ai 和 deeplearning.ai 课程来“过度适应”你的人工智能学习
towardsdatascience.com](/two-sides-of-the-same-coin-fast-ai-vs-deeplearning-ai-b67e9ec32133) [## 你需要了解网飞的“朱庇特黑仔”:冰穴📖
是时候让 Jupyter 笔记本有个有价值的竞争对手了
towardsdatascience.com](/what-you-need-to-know-about-netflixs-jupyter-killer-polynote-dbe7106145f5)
解决基于人工智能的搜索引擎的最大挑战之一:相关性
让我们学习如何实现点击模型，以便从点击流数据中提取相关性。
图片作者:约书亚·戈德
构建搜索引擎系统通常遵循一些众所周知的步骤:
- 为搜索操作选择合适的数据库。
- 保存一组文档。
- 将转换应用到文档字段(删除重音符号、过滤复数、断开空格……)。
- 创建检索这些文档的查询规则。
这些步骤往往是为给定应用程序实现足够有效的搜索引擎系统所必需的。
最终，可能需要升级系统以提供定制的结果。这样做应该很简单。人们可以从一组机器学习排序算法中进行选择，训练一些选定的模型，为生产做准备并观察结果。
事实上，除了一个缺失的部分之外，它可能就是这么简单:不管选择的排名模型是什么，我们仍然需要以某种方式准备一个能够教授算法如何正确排名的训练数据集。无论如何，一定会有一个数据集告诉算法什么是好文件，什么是坏文件。
这将是这篇文章的重点。为了用人工智能算法推动搜索引擎更上一层楼，一个“教导”算法如何正确排列结果的训练数据是根本。
我们将讨论如何使用 ClickModels ，一个使用概率图形模型 (PGM)的字段，来开发一组解释用户和检索到的文档之间的交互的变量。这些变量将为我们提供相关性(或判断，也在文献中已知)的概念，它基本上作为一个标记，表明一个文档对于给定的搜索查询有多少价值。
用于从点击流数据推断相关性的图形模型示例。图片摘自 clickmodels 图书公开发售。
我们的挑战将是创建一个概率模型，从用户交互中学习每个查询和上下文有多少相关文档。基于 Cython 构建的最终代码可以在 pyClickModels 存储库中找到(Cython 是必需的，因为这些算法的优化过程可能需要相当长的时间才能收敛)。
所以，事不宜迟，让我们看看如何将搜索引擎提升到一个新的水平。
那么，相关性为什么？
弄清楚什么对人们是相关的可能是相当具有挑战性的。想象一下，为一个电子商务商店建立一个搜索引擎。
搜索查询“智能手机”的搜索结果示例。图片作者。
在这种环境下(我们可以说大多数检索引擎在相似的环境下工作)，观察到的数据包含:
- 用户在搜索什么。
- 搜索的背景(用户的地区、人口统计数据、他们的偏好等等)。
- 他们点击的产品。
- 他们点击后购买的产品。
我们期望从搜索结果页面购买的产品是非常相关的，所以它们应该有一个良好的相关性得分。但是后来我们意识到，可能有一些产品没有展示给用户(例如，在第 2 页或更高的页面上的产品)，他们最终会享受到更多！
不仅如此，在向用户排列项目时，往往会观察到几个模式。例如，结果页面上的第一个文档往往比其他文档获得更多的点击，这不一定是因为它是适合查询的产品，而仅仅是因为它位于目录的第一个位置(也称为“位置偏差”)。
现在事情开始变得棘手了。
找到什么与人们相关的一个方法就是简单地问他们。有趣的是，这实际上是一些公司使用的一种可用的解决方案。但是这种方法的缺点是，它不能很好地扩展，而且通常不太准确。
另一种方法，也是我们感兴趣的方法，从点击流的数据中推断出隐含的相关性。点击流数据基本上是用户与搜索引擎系统本身的浏览交互的记录。这里有一个例子:
点击流数据示例。
我们可以使用这些信息来模拟每个文档与每个查询的相关程度。
点击救援模型！
从点击流数据中提取相关性的一种方法是使用由 PGM 组成的点击模型，以推断用户点击文档的可能性。我们可以假设点击的概率越高，相应地，文档可能越相关。
接下来，这里讨论的想法和概念是从 Aleksandr Chuklin 和其他人的书网络搜索的点击模型中摘录的。
我们有许多方法来模拟用户与文档排序列表的交互。这里，[动态贝叶斯网络](https://en.wikipedia.org/wiki/Dynamic_Bayesian_network#:~:text=A Dynamic Bayesian Network (DBN,other over adjacent time steps.) (DBN)方法将被选为讨论和实现的方法。请记住，一旦您理解了模型背后的概念和理论，您就可以使用您认为合适的任何变量来推断这些知识。例如，亚历山大的书讨论了其他几种模型。
首先，这里是用于从数据中提取相关性的 DBN 的图形表示:
为查找与搜索引擎结果相关联的文档的相关性而实现的图形模型的示例。图片作者。
这个模型中的所有变量都遵循伯努利分布，这意味着它们可以是 0 或 1，有一定的概率 p。这些是从网上掌握的主要概念:
r表示与搜索页面中给定文档相关联的位置；r=0表示第一个文件，r+1表示从r位置开始的下一个文件。u是文档的标识符。E_r是一个被称为“考试”的随机变量。顾名思义，它决定了用户是否检查了文档(即 E=1)或 E=0)。如果没有经过检查，文档就不会有点击和购买。A_u表示对应文档u对结果是否有吸引力。如果文档是吸引人的(A=1)，则观察到点击事件。S_ur表示位置 r 的文件是否令客户满意。当他们满意时(S=1)，他们停止检查新文档。购买的文件被认为是令人满意的。C_r是观察到的点击变量，来自点击流数据集。P_r与观察到的购买事件相关。如果 P=1，那么 S=1。这个变量只有在文档出售时才有意义。- γ 是用户在不满意时继续检查大于
r位置的文档的概率。
使用我们之前的智能手机示例，以下是 DBN 的表示方式:
与智能手机搜索结果关联的 DBN 模型。图片作者。
请注意，对于每个文档，我们都关联了一组潜在变量(At 吸引力， S 满意度， E 检查)，这些变量模拟了用户如何以及为什么与引擎结果交互。点击和购买用灰色填充，因为它们是观察变量(点击流数据)。
这里有一个问题:如果我们指定代表每个潜在变量的概率的值，我们可以使用这些相同的值来推断每个文档与每个搜索查询的相关性。
例如，假设我们将 α 与 σ 相关联，以表示给定文档对用户有吸引力的概率。如果我们使用一些优化技术从数据中学习这些值应该是什么，我们可以找到每个文档的相关性。
为此，让我们开始用一组规则来描述我们的网络(这些规则将用于优化过程):
DBN 主要方程用来描述优化过程应该如何操作。
以下是对每条规则的简要解释:
(1) 表示在r-1处的先前文档未被检查的情况下，用户检查给定等级r处的给定文档的概率为零。
(2) α是决定吸引力概率等于 1 的参数。
(3) 如果一个文档被检查并且有吸引力，我们必须观察点击。
(4) 如果一个文档没有被点击也没有被购买，那么对于给定的查询，它不能被认为是满意的。
(5) 如果一个文档被点击但没有被购买，文档满意的概率是σ。
(6) 如果观察到点击和购买，满意度为 1。
(7) 如果之前的文档令人满意，用户将不会继续检查新产品。
(8) 如果一份文件不符合要求，且之前的文件已经过检查，则客户将继续检查新文件，可能性为 γ。
(9) 观察到点击的概率由点击给定检查的概率乘以由α * ε给出的检查概率(贝叶斯规则，其扩展为与被点击和检查的概率相同)给出。
有了支配 DBN 模型的方程，可以使用一些技术来找到最好地解释观察到的数据的α、σ和 γ 的值。
第一种技术是最大似然估计( MLE )的直接实现。它基本上包括找到模型可能性的表达式(用对数表示)，即在给定模型变量的情况下观察到数据的概率。
在我们的例子中，我们的 DBN 具有以下对数似然表达式:
- X 是用于描述数据的每个伯努利变量(在我们的例子中，是“A”、“S”和“E”)。
- C 和 P 是观察到的点击量和购买量。
- ψ 是我们要寻找的描述数据的变量集合(α，σ和 γ )。
求和发生在代表会话的“ s 上，它代表用户与搜索引擎的交互。
在 MLE 方法中，我们可以简单地对每个潜在变量取这个表达式的导数，并使其等于零。但是这种方法效果不太好。问题是，由于潜在的变量，最终的表达式很难求解。
这实际上是一个已知的问题。事实证明，除了 MLE，另一种技术是期望最大化算法(EM)(它的工作方式有点像流行的 kMeans 算法)。
它首先将随机期望值分配给潜在变量α、σ和 γ 。然后，通过使用特定的成本函数，继续迭代优化过程。为变量分配新值，并重复该过程，直到达到收敛或总迭代次数。
用作优化参考的成本函数由下式给出:
它类似于前面看到的对数似然表达式，但它用随机变量的期望值代替了表达式的一部分，这使得求导变得容易得多(但它最终也是最优解的近似值)。
这是我们的模型中定义的成本函数 Q :
Par(X)= p指变量 X 的双亲。例如，在我们的 DBN 中，给定网络的边连接，变量 S (满意度)将点击和购买作为其父变量。变量 θ 代表我们试图寻找的潜在参数(α等)。 I 是指示函数， Z 只是与 θ 无关的值的参考，在推导过程中会被丢弃。
通过使用随机变量的期望值，我们所完成的是，现在推导这个方程要简单得多。这是我们已经得到的 θ 的隔离结果:
这基本上是期望最大化算法的本质。我们首先将对数似然表达式中的随机变量替换为它们的期望值，然后推导出使其等于零的方程。我们获得了用于每个变量的优化规则(等式 10 ),该优化规则应该缓慢地收敛到局部或全局最小值。
让我们看看如何使用等式 10 的定义来调整每个变量。
吸引力——α
首先，吸引力变量被定义为:
q 表示查询，而 u 表示文档。在我们的 DBN 表示中，注意α没有任何父代，所以它是直接定义的。
为了开发它的优化方程，首先我们需要如下描述与文档检查相关联的概率:
其中cr是给定查询q的给定文档u的转化率，定义为总销售额除以该文档在给定查询 q 的结果页面中出现的总次数。它只在文件出售时定义，否则它被认为是零。
到目前为止，我们知道:
其中|S|是查询 q 的搜索结果页面返回文档 u 的所有会话的基数。
注意，给定我们的 DBN 的架构，变量C和P是独立的给定C，这意味着我们只需要考虑前者:
等式 13 可以进一步展开如下:
如果在r上方观察到任何点击，则C_{>r}为 1，否则为 0。
对于分子 14，我们可以进一步展开为:
分母有点复杂:
等式 14.4 应该递归实现。你可以在 pyClickModels 上看到它是如何完成的，这里有一个例子:
最后，我们可以使用所有这些等式，并将它们融合在一起，得出调整吸引力变量的最终规则:
您可以在这里看到这个规则是如何在 pyClickModels 上实现的:
满意度——σ
在我们的 DBN 中，满意度变量σ确实有双亲。因此，根据等式 10，我们只需要在定义变量的地方使用会话，给定适当的父变量。
具体来说，等式 5 已经描述了它。我们有:
因此，使用等式 10，我们得到:
S'_{uq}包含文档u被点击但未被购买的所有会话。
(16)的分子可以进一步展开为:
这直接归结为满足的适应规则:
这比吸引力更直接。这个等式是如何实现的:
坚持——𝛾
现在，最具挑战性的变量出现了。
注意，正如我们的 DBN 中所定义的，持久性是全局定义的，也就是说，它不依赖于要定义的查询或文档。
如前所述，它由下式给出:
为了获得𝛾的更新规则，我们将使用以下预期充分统计(ESS):
其中E_r和S_ur是E_{r+1}的父母。
为了进一步开发 19，可以实现辅助功能φ。我们会有:
其中:
策略是将等式 20 分成 3 个主要部分:
第三个发展为:
为了发展内部概率方程，我们有:
还有一点:
用 22 和 23 乘以 21，我们最终得到:
第一个公式为(注意可变转换率在这里被称为“w”):
最后，第二个等式是等式 1 至 9 的直接实现。
你可以在这里看到这三个等式是如何实现的:
更新参数很简单:
最后，这就是实现前面定义的 DBN 所需的全部工作。
好吧，现在回到我们的主要目标，我们如何从中提取相关性？
最后…相关性
现在很简单了。在使用点击流数据训练模型之后，我们将获得吸引力和满意度的优化值(记住这些值仍然可以指局部最优值)。
排名相关性或判断仅仅是两者的产物，即:
在 pyClickModels 中，可以在拟合模型后导出判断值。为每个搜索查询/上下文和所有相应的文档创建一个换行符分隔的 JSON 文件。
将所有这些放在一起:编码时间
现在让我们来看看所有这些概念的实际应用。
事实证明，我们可以使用谷歌大查询上的公共数据集来测试这些想法。在实践中，我们将查询 Google Analytics 的一个样本，从中我们可以提取客户，他们搜索、点击和购买了什么(尽管如此，我们只能访问很少的数据，所以这仍然是一个简单的实验)。
下面是我们测试所需的代码:
它需要 GCS 客户端和 pyClickModels，两者都可以安装:
pip install pyClickModels google-cloud-storage
只需将代码复制并粘贴到您的本地，然后用 Python 运行它。文件将在/tmp/pyclickmodels/model/model.gz保存。打开该文件，您应该看到几行 JSON 代码，如下所示:
请注意，库返回整个搜索上下文作为关键字(在这种情况下，它使用用户通过哪个渠道组访问网站以及他们的平均消费券作为信息)。值是该搜索上下文的每个文档以及相关联的相应判断，范围从 0 到 1。
结论
差不多就是这样了！
通过使用 PGMs，我们可以使用尽可能多的潜在变量来描述观察数据的行为。正如我们已经看到的，我们这样做的方式是，我们可以提取一些概念，如一个文档可能有多吸引人，以及用户在看到该文档时有多满意。
有了这些相关性值，我们可以训练学习来排列模型，使搜索引擎进入下一个操作级别，使它们能够为每个用户及其各自的上下文检索个性化结果，只要这些已经在模型中训练过。
从那时起，可以在搜索引擎内部定制更复杂的算法，从简单的决策树到从数据中完全捕捉统计细微差别的深度学习网络。不过，只有在相关性数据可用的情况下，这才是可能的，否则就没有办法教授学习算法如何正确排序。
完整的代码实现可以在 pyClickModels 开源存储库中找到:
ClickModels 的 Cython 实现，使用概率图形模型来推断用户在交互时的行为…
github.com](https://github.com/WillianFuks/pyClickModels)
参考
[2]https://clickmodels.weebly.com/
[3]https://github.com/varepsilon/clickmodels
https://www.cs.ubc.ca/~murphyk/Thesis/thesis.html
https://en.wikipedia.org/wiki/Maximum_likelihood_estimation
[7]https://static . Google user content . com/media/research . Google . com/en//pubs/archive/46485 . pdf
https://en.wikipedia.org/wiki/Conditional_independence
如何用 Python 从图像中提取文本
学习用 3 行代码从图像中提取文本
肖恩·林在 Unsplash 上的照片
在这篇短文中，我将向您展示如何使用 Python 从图像中提取文本。这项技术的应用是无止境的。一些例子包括:
- 机器学习(ML)项目的数据挖掘
- 拍摄收据照片并读取内容进行处理
Python 库
为了解决这个问题，我们将使用一个名为 Python Tesseract 的库。来自图书馆的网站:
Python-tesseract 是 Python 的光学字符识别(OCR)工具。也就是说，它将识别并“读取”嵌入图像中的文本。
Python-tesseract 是 Google 的 Tesseract-OCR 引擎的包装器。它作为 tesseract 的独立调用脚本也很有用，因为它可以读取 Pillow 和 Leptonica 图像库支持的所有图像类型，包括 jpeg、png、gif、bmp、tiff 等。此外，如果用作脚本，Python-tesseract 将打印识别的文本，而不是将其写入文件。
设置事物
当设置要使用的 Python 库时，通常是一步到位的过程。然而，对于 PyTesseract，我们需要做两件事:
- 安装 Python 库
- 安装宇宙魔方应用程序
首先，要安装 Python 库，只需打开命令行窗口并键入:
pip install pytesseract
然后，前往这个网站，下载并安装宇宙魔方 OCR 可执行文件。在撰写本文时，我使用的是 2020 年 3 月 28 日编译的 64 位 Alpha Build v5.0.0。
我们需要知道我们在哪里安装它，因为我们需要让你的 python 脚本知道。
一旦你完成了以上步骤，你就可以开始了。
Python 代码
正如所承诺的，用 3 行代码，你就能从一幅图片中读出文字:
import pytesseractpytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract'print(pytesseract.image_to_string(r'D:\examplepdf2image.png'))
如果您喜欢上面的文章，您可能也会喜欢:
最后，你可以在 10 分钟内找到一个图书馆
towardsdatascience.com](/learn-how-to-quickly-create-uis-in-python-a97ae1394d5) [## 估算一个软件的最后期限真的很难——让我们来谈谈为什么
规划时你需要知道的 5 条法则
medium.com](https://medium.com/better-programming/estimating-a-software-deadline-is-really-hard-lets-talk-about-why-44687a6baf9d)
如何从 PDF 中提取文本
学习使用 Python 从 pdf 中提取文本
卡尔·海尔达尔在 Unsplash 上拍摄的照片
在这篇博客中，我们将研究用 Python 处理 pdf 的最流行的库。很多信息都是以 PDF 的形式分享的，往往我们需要提取一些细节做进一步的处理。
为了帮助我识别最流行的 python 库，我查看了 StackOverflow 、 Reddit 以及大量的谷歌搜索。我识别了许多包，每个包都有自己的优点和缺点。具体来说，整个互联网的用户似乎都在使用:PyPDF2，Textract，tika，pdfPlumber，pdfMiner。
然而，在我的研究中，由于这样或那样的原因，我只能让其中的 3 个库正常工作。对于其中一些库来说，设置太复杂了(缺少依赖项，奇怪的错误信息，等等。)
让我们快速回顾一下所有这些库。
PyPDF2
评分:3/5
PyPDF2 的好消息是安装起来很容易。文档有些缺乏容易理解的例子，但是如果你足够注意，你最终会明白的。
然而，坏消息是结果并不好。
如您所见，它识别了正确的文本，但出于某种原因，它将文本分成了多行。
代码:
import PyPDF2fhandle = open(r'D:\examplepdf.pdf', 'rb')pdfReader = PyPDF2.PdfFileReader(fhandle)pagehandle = pdfReader.getPage(0)print(pagehandle.extractText())
Textract
评分:0/5
许多人对这个图书馆赞不绝口，这是一个有希望的开始。文档也不错。
不幸的是，最新版本有一个 bug，每次你试图从 PDF 中提取文本时都会抛出一个错误。通过图书馆的开发论坛跟踪这个 bug，可能会有一个修复。手指交叉。
阿帕奇蒂卡
评分:2/5
Apache Tika 有一个 python 库，显然可以让你从 pdf 中提取文本。安装 Python 库非常简单，但是除非安装了 JAVA，否则它无法工作。
至少理论上是这样。我不想安装 JAVA 因此我停留在:“runtime error:无法启动 Tika 服务器。”错误。
根据这个媒体博客(无关联)，然而，一旦你让它工作，它是了不起的。所以，我们用 2/5 评级吧。
该代码看起来像这样:
from tika import parserfile = r'D:\examplepdf.pdf'file_data = parser.from_file(file)text = file_data['content']print(text)
pdf 木材
评分:5/5
正当我开始对从 pdf 中挖掘文本的简单易用的 python 库的存在失去信心时，出现了 pdfPlumber。
文档不算太差；几分钟之内，整个事情就开始了。结果好得不能再好了。
然而，值得注意的是，该库确实明确表示，它在机器生成的 pdf 上工作得最好，而不是扫描文档；我用的就是这个。
代码:
import pdfplumberwith pdfplumber.open(r'D:\examplepdf.pdf') as pdf:
first_page = pdf.pages[0]
print(first_page.extract_text())
pdfMiner3
评分:4/5
我会诚实；以典型的 pythonic 方式，我扫了一眼文档(两次！)并且不明白我应该如何运行这个包；这包括 pdfMiner(也不是我在这里讨论的版本 3)。我甚至安装了它，并尝试了一些没有成功的事情。
唉，来救我的是一个善良的陌生人。一旦你看完了提供的例子，实际上就很容易理解了。哦，结果和你预期的一样好:
代码可以在链接的堆栈溢出帖子中找到。
PDF -> JPEG ->文本
解决这个问题的另一种方法是将 PDF 文件转换成图像。这可以通过编程或截取每个页面的屏幕截图来完成。
一旦有了图像文件，就可以使用 tesseract 库从其中提取文本:
学习用 3 行代码从图像中提取文本
towardsdatascience.com](/how-to-extract-text-from-images-with-python-db9b87fe432b)
在你离开之前，如果你喜欢这篇文章，你可能也会喜欢:
4 个不同库的介绍(命令行和用户界面)
towardsdatascience.com](/learning-to-use-progress-bars-in-python-2dc436de81e5) [## 构建用于比较数据的 Python UI
如何快速让您的非技术团队能够比较数据
towardsdatascience.com](/building-a-python-ui-for-comparing-data-13c10693d9e4)
如何有效提取 Web 数据:4 种方法
这些被忽视的方法将为你节省时间和金钱
卢卡斯·布拉塞克在 Unsplash 上的照片
作为一名程序员和经常使用数据的人，我经常很难找到好的完整数据集来使用。开源数据库是有限的，API 使用起来可能很昂贵——更不用说每分钟、每天、每月调用次数的限制了。
在几个项目的过程中，我总结了一些为 Python(和 Excel)用户提取和导入 web 数据的基本方法。我非常依赖这些方法来完成任何需要自己获取数据并将其导入工作空间的项目。
最后，对于非编码项目，我将演示一个有价值的 Excel 工具，它允许您从网页中抓取格式化数据，自动将值填充到电子表格中。
以下是四种方法。我将用同样的目标数据集来说明它们:截至 2020 年 3 月的 ATP 网球运动员排名。
1.使用熊猫:read_html
网球数据的一个奇妙来源是 tennisabstract.com 的 T4。这是 ATP 官方排名的网页。
ATP 排名更新 2020 年 3 月 9 日，tennisabstract.com
检查 HTML 后，结构看起来很简单——有四个 table 标记，最后一个包含逐行列出的玩家排名。
当数据已经被很好地格式化成 HTML 表时，检索它的最快方法是使用 Pandas 的 read_html 。这个方法只是将一组 HTML 表读入一个 DataFrame 对象列表。
注意:有一个字符串参数， match ，它确保只返回包含与给定字符串匹配的文本的表。这对于包含大量 HTML 表格的页面非常有用。
import pandas as pdtables = pd.read_html("[http://tennisabstract.com/reports/atpRankings.html](http://tennisabstract.com/reports/atpRankings.html)")rankings = tables[-1]
rankings.iloc[:200]
以下是前 200 名选手。
Top 200 强选手排名，http://tennisabstract.com
2.使用 HTML 解析器:美丽的汤
然而，事情并不总是那么简单。根据配置的不同，一些网站禁止使用 read_html 函数直接访问，导致 HTTP 错误 403。无论如何，如果您想抓取表中没有格式化的数据，该怎么办呢？
这就是像 Beautiful Soup 这样的 HTML 解析器派上用场的地方。
我们试试用美汤从 ATP 官方网站提取排名。安装说明可以在这里找到。
import requests
from bs4 import BeautifulSoupurl = "[https://www.atptour.com/en/rankings/singles"](https://www.atptour.com/en/rankings/singles)
response = requests.get(url)
page = response.text
soup = BeautifulSoup(page, 'lxml')
有了这段简短的代码，我们现在有了网页的 HTML。我们可以使用 soup.find_all("table") 获得所有表的列表。可以通过传入 id 来定位一个特定的表——就此而言，页面上的任何对象都可以通过它的 HTML 标签和传入唯一的属性来访问(参见 docs )。
table = soup.find(class_="mega-table")
[row.text.split() for row in table.find_all("tr")]
嵌套列表，包含(1)标题列和(2)播放器行
经过一点清理后，我们可以将数据组织成一个标题列表和另一个播放器行列表。剩下的工作就是将信息存储在数据帧中。
header = [j for j in [i.strip(" ") for i in table.find_all("tr")[0].text.splitlines()] if j != ""]
header.remove("Country")
header.remove("Move")data = []
for row in table.find_all("tr")[1:]:
x = row.text.split()
name = " ".join(i for i in x if i.isalpha() or "-" in i)
res = [i for i in x if not (i.isalpha() or "-" in i)]
res.insert(1, name)
if len(res) == 8:
res.pop(2)
data.append(res)rankings2 = pd.DataFrame(data, columns=header)
rankings2
ATP 排名前 100，https://www.atptour.com
3.使用 JSON 请求
第三种方法是提取 JSON 格式的数据。作为一个例子，我们将从ultimatetennisstatistics.com检索排名。
如果您愿意右键单击并检查页面，您会在“Network”选项卡下看到一个 GET 请求是由 JSON 类型构成的。
只需点击相关的链接，就会产生下面的 JSON 输出页面。
使用请求和 json 库可以很容易地将 JSON 数据读入 Python，然后导入到 Pandas 数据帧中。这个简单的函数完成了这个任务。
import requests
import jsondef get_json(url):
response = requests.get(url)
rows = json.loads(response.text)['rows']
data = pd.DataFrame.from_dict(rows)
return datarankings3 = get_json(["https://www.ultimatetennisstatistics.com/rankingsTableTable?current=1&rowCount=-1&sort%5Brank%5D=asc&searchPhrase=&rankType=RANK&season=&date=&_=1589249780003](https://www.ultimatetennisstatistics.com/rankingsTableTable?current=1&rowCount=-1&sort%5Brank%5D=asc&searchPhrase=&rankType=RANK&season=&date=&_=1589249780003)")rankings3
ATP 排名前 500，ultimatetennisstatistics.com
4.额外收获:使用 Excel 下载 HTML 数据
无需一行代码，您就可以将任何 HTML 文件下载到 Excel 电子表格中。我将使用来自tennisabstract.com的相同排名数据集来演示这一点。
Excel for Windows
- 找到包含所需数据的网页。复制网址。
- 打开 Excel，导航到“数据”选项卡，然后单击“从 Web”。
- 将网站的 URL 粘贴到弹出框中，并按照提示匿名连接到该页面。
- 打开“导航”菜单，在“显示选项”下找到所需数据。检查数据是否正确显示，并将其“加载”到电子表格中。
ATP 排名(tennisabstract.com)，导入 Windows Excel
苹果电脑版 Excel】
- 当在网页上时，右键单击，您应该会看到一个类似于“另存为…”或“将页面另存为…”的选项，这取决于您的浏览器。继续将文件以 HTML 格式保存在本地。
- 打开 Excel，导航到“数据”选项卡，然后单击“来自 HTML”。注意，该选项可能位于子菜单“获取外部数据”中。
- 从弹出菜单中找到并打开保存的 HTML 文件。按照提示将数据加载到电子表格中。
ATP 排名【tennisabstract.com，导入 Excel for Mac
就是这样！现在，数据已经被导入并格式化，每个值都在单独的单元格中。
事后思考
这些方法对于抓取网络数据并将其导入到一种更易处理的格式中是必不可少的——从这种格式中，你可以根据需要对数据进行清理、过滤、建模和可视化。
因此，如果您的第一反应是使用 API，您可能需要再考虑一下。尽管在某些情况下这可能是不可避免的，但是许多在线数据可以在不使用 API 的情况下被访问，这样就省去了您获取 API 密钥和浏览文档的精力和费用。
我希望这些工具对你的下一个数据分析项目有用。
感谢阅读！
如何通过 Azure 基础认证
看看参加 AZ-900 考试时应该做什么(和不应该做什么)
A Z-900 是世界上最受欢迎的云服务的最受欢迎的认证。Azure Fundamentals 是许多使用云的人的起点。
这表明你对 Azure 有很好的、高水平的理解，这很好，但也让很多人感到困惑。它不是关于您是否可以设计一个 web 应用程序，并通过 CI/CD 管道自动化您的部署。
相反，该认证的优势来自于它所针对的业务用户视角，但这也是我们中许多更倾向于技术的人将会努力的地方。
这并不是说这个认证对技术人员没有用；的确如此。事实上，对云概念、基础架构、安全性和服务的概述是任何从事云工作的人的必备知识。
这门课程在技术上没有挑战性，但范围很广。我们将讲述全天候访问客户电话线路所需的支持级别，或者我们的 IT 管理员使用 Powershell 脚本部署虚拟机所需的设置。
因此，尽管表面上看起来很蓬松，但这是可以理解的——这是一个棘手的认证方法。让我们来演练一下第一次使用 AZ-900 时应该做什么和不应该做什么。
准备时间
你需要准备考试的时间会有很大的不同。如果你是一名从 AWS 转移到 Azure 的高级云工程师，你可能最多不需要超过一天的时间。
如果你想知道为什么微软提供一个覆盖天空中那些毛茸茸的白色东西的认证，给自己多几天时间。
如果你是一名开发人员，但是还没有接触过云。每天三到四个小时，持续一周应该足够了——或者两周才安全。
官方 Azure 基础学习路径
很容易，最好的起点是比尔自己的 Azure 基础学习路径。
官方说法是，总共需要 9 小时 48 分钟。对我来说，需要更长的时间。
如果你只是简单地通读，并观看短视频，不到十个小时可能是正确的。但我会推荐一种更积极的方法，尝试以下几种方法的组合:
1。做大量笔记。我对记笔记的一个小建议——尝试一下【T2 概念】(太棒了)。
2。当你看到新的术语时，比如负载平衡器阅读更多相关信息。询问类似这样的问题— 为什么它是第 4 层负载平衡器？等。
3。尝试使用服务。在一些迷你项目中使用 Azure 会让你的理解达到一个全新的水平。
同时，不要在这些额外的步骤上走极端。在接下来的步骤中，我们将继续这种更积极的学习方法，所以不要让自己筋疲力尽。
总的来说，我建议在这上面花大约 15 个小时——当然，按照你自己的节奏工作。
FreeCodeCamp 的 Azure 基础教程
接下来是 FreeCodeCamp 在 YouTube 上的 AZ-900 教程视频。在经历了微软的学习历程后，这是一个受欢迎的步伐变化。
这个视频是我见过的最好的 AZ-900，在三个小时长，它涵盖了很多。
虽然它在很高的层次上解释了一切，但仅凭这个视频，你可能无法通过这门课程。但是这对于巩固我们在官方学习途径中学到的东西是非常好的。视频格式也使它更容易跟随！
同样的积极学习的方法也适用于这里。做笔记，做一些额外的阅读，并进行一些练习。
模拟测试
最初，我对支付在线模拟测试的费用犹豫不决。在我完成第一次考试后，我只得了可怜的 56%分——肯定不及格。
因此，如果有一件事我可以推荐，甚至比官方的学习路径，或 FreeCodeCamp 的视频更值得推荐。你应该投资做一次模拟测试。
其次，如果有什么比买模拟试题更值得我推荐的话。阅读测试评论！
很多模拟测试已经过时了，所以要小心一点。
我使用了 Skillcertpro ，它附带了七个模拟测试。
无论你使用 Skillcertpro 还是其他平台，完成他们提供的每一个考试。我发现我会在一次考试中获得 92%的高分，然后在下一次考试中获得 60%的高分。它们可以变化很大。
最后，在这个阶段，积极的方法是非常重要的。参加模拟考试，通读结果——记下你做对了什么，并通过官方 Azure 文档或其他地方调查你做错了什么。
要记住的最后几点
对于考试，有一些额外的事情需要注意:
- 门槛根据考试难度变化。以 700 分(满分 900 分)为目标应该能让你及格。
- 问题的数量可能变化很大；许多资源总共引用了 40-65 个问题。我得了 29 分——不要对此感到惊讶！
- 考试时间也各不相同，但实际上你不必着急。慢慢来，在点击提交之前仔细检查你的问题。
- 如果你在家考试，早点登录。在开始之前，你需要下载他们的软件，验证你的 ID，拍摄你周围的照片等等。
学习完本文中的所有材料后，你将会为考试做好充分的准备。
我希望你喜欢这篇文章！如果你有任何其他资源可以推荐，或者有任何问题，请通过推特或者在下面的评论中联系。
祝你好运！
有兴趣应用你新发现的 Azure 知识吗？试试我的 Azure 网络应用部署指南:
利用 Angular 和 Azure 应用服务快速轻松地部署应用
towardsdatascience.com](/how-to-deploy-web-apps-with-azure-52ca340b41b9)
如何在 3 分钟内过滤一个熊猫数据帧
如何过滤熊猫数据框有很多选择，我将向你展示最常见的功能
在 Pandas 中，有许多方法可以过滤数据帧。我将在辛普森一家的帮助下向你介绍最重要的选择。
布尔索引
布尔索引需要找到每一行的真值。如果你寻找df['column'] == 'XY' ，，一个真/假序列被创建。
我想象你刚刚在《辛普森一家》的片场。他们是明星，每个人都可以为下一季订购一些东西，由制作人支付费用。你的工作是接受主角的命令并转发相关数据:
df = pd.DataFrame({'Items': 'Car Saxophone Curler Car Slingshot Duff'.split(),
'Customer': 'Homer Lisa Marge Lisa Bart Homer'.split(),
'Amount': np.arange(6), 'Costs': np.arange(6) * 2})print(df)
Items Customer Amount Costs
0 Car Homer 0 0
1 Saxophone Lisa 1 2
2 Curler Marge 2 4
3 Car Lisa 3 6
4 Slingshot Bart 4 8
5 Duff Homer 5 10
示例 1-选择具有特定值的行
让我们找出 Bart 的所有条目，以便转发给他的经理:
df.loc[df['Customer'] == 'Bart'] Items Customer Amount Costs
4 Slingshot Bart 4 8
示例 2 —从列表中选择行
片场有传言说，我们是数据专家，广告合作伙伴想知道节目中的孩子们出于营销原因订购了什么:
kids = ['Lisa','Bart']df.loc[df['Customer'].isin(kids)] Items Customer Amount Costs
1 Saxophone Lisa 1 2
3 Car Lisa 3 6
4 Slingshot Bart 4 8
我们会在电视广告上看到萨克斯管、汽车和弹弓…
示例 3 —组合多个条件
辛普森一家也必须省钱。新规则是:1)禁止汽车，2)每人最多可订购 3 件商品:
df.loc[(df['Items'] != 'Car') & (df['Amount'] <= 3)] Items Customer Amount Costs
1 Saxophone Lisa 1 2
2 Curler Marge 2 4
我希望霍默和巴特能和我们在一起，不要怒气冲冲地离开节目…
示例 4 —选择未出现在列表中的所有行
不幸的是，该系列的明星们对这些削减一点也不热情，所以第一批赞助商站出来帮忙:
happy_stars = ['Lisa','Marge']df.loc[~df['Customer'].isin(happy_stars)]Items Customer Amount Costs
1 Saxophone Lisa 1 2
3 Car Lisa 3 6
4 Slingshot Bart 4 8
位置索引
有时，您不想根据特定条件进行过滤，而是根据数据帧的位置选择特定行。在这种情况下，我们使用切片来获得想要的行。
示例 1 —选择数据帧的前几行
你部门的新实习生不应该直接处理整个数据集，他只需要前三个条目:
df.iloc[0:3]
Items Customer Amount Costs
0 Car Homer 0 0
1 Saxophone Lisa 1 2
2 Curler Marge 2 4
示例 2 —选择数据帧的最后几行
你有很多工作要做，你会得到另一个实习生。为了让两个学员独立完成他们的任务，您现在保存记录的最后三行:
df.iloc[-3:]
Items Customer Amount Costs
3 Car Lisa 3 6
4 Slingshot Bart 4 8
5 Duff Homer 5 10
结论
我们能够根据其值或位置从我们的数据集中选择任何特定的行。Pandas 提供了在制定条件时考虑多个值的简单方法。列表和条件可以很容易地链接在一起。
如果您喜欢中级和数据科学，并且还没有注册，请随时使用我的推荐链接加入社区。
如何从命令行查找和组织数据
metaframe 简介:面向数据科学家的基于 markdown 的文档工具和数据目录。
回购:【https://github.com/rsyi/metaframe】T2
如果你是一名数据科学家，你的工作就是从数据中提取价值。但是在你的职业生涯中，你可能会花费(并且已经花费)大量的时间去寻找和获取所说数据的背景。以我的经验来看，这通常是徒劳的——你问团队中最资深的人，谁让你去找别人，谁让你去找别人，谁告诉你他们不知道你在说什么。然后你重复这个过程，直到你找到一个人可以给你一个有用的表。
person = senior_data_scientist
while person and not_tired:
response = ask(person)
if type(response) == Table
rejoice()
if type(response) == Person
person = response
但是这个算法真的是蛮可怕的！这绝不是一个彻底的搜索，您最终会得到一个无人维护、无人使用的表。如果你决定冒险把它用在你的生产流水线上，当你六个月后发现这张桌子并不像你想象的那样工作时，你可能会让你的公司损失一大笔钱。更何况这是一个巨大的时间浪费！有时你会忘记几个月后桌子做了什么，你不得不再次做这个，让你的同事沮丧。那么你能做什么呢？
简要介绍数据目录及其局限性
幸运的是，这个问题已经有了解决方案:数据目录。数据目录名副其实，因为它们只是为您提供一个数据目录。它们允许您按名称搜索和查找表，查看它们的列和元数据，并使用附加文档丰富这些元数据。存在许多闭源播放器，如 Alation 和 Collibra ，许多科技公司已经发布了开源版本，包括网飞的 Metacat ，Lyft 的 Amundsen ，以及 LinkedIn 的 Datahub 。许多公司都在为自己开发这些工具(Airbnb、优步、谷歌、脸书等等)。
这就引出了一个问题:为什么不使用/实现这些解决方案中的一个呢？
嗯，你可能想认真考虑一下，最终，但是有巨大的进入壁垒:建立目录往往是昂贵的，或者，在开源工具的情况下，很难建立。对于只有少数数据科学家和分析师的公司来说，花费几十万美元或几个月的工作来实现一个工具几乎是不值得的，这个工具最多可以节省你转向你的邻居并再次向他/她询问那张桌子的几分钟时间。**
我和一些在小型创业公司工作的朋友谈过这个问题，虽然数据文档和数据发现的问题即使在最小的规模上也很突出，但成本效益权衡根本没有意义。但是，仅仅因为问题太昂贵而无法用现有方法解决，并不意味着不存在划算的解决方案。
那么解决办法是什么呢？
我想，“T7 比 T8 更容易建立目录。”日复一日，我只想寻找我的数据，检查列名，并做一些笔记。为什么这么难？我已经可以通过将所有内容保存在团队范围的电子表格中来手动完成这项工作。
所以我想我应该试着 80/20 这个。结果呢？
元框架 。
Metaframe 是一个基于 CLI 的数据目录，带有一个定制的基于 Markdown 的元数据后端，一个基于 fzf 的搜索服务，以及一个用 bash 和 python 编写的 ETL 管道，构建于 lyft 的 amundsendatabuilder 库之上。
但这很难理解。这里有一个快速演示:
本质上， metaframe 只是一个有点固执己见的文档工具。想只为一桌写笔记？很简单，只需键入以下内容:
**mf new table_name**
您将进入一个位于~/.metaframe/metadata/table_name.docs.md的文本文件，您可以在此表格上添加您的注释。然后，通过运行以下命令，可以在您的搜索中访问这些内容
**mf**
这并不局限于表格——您可以为 SQL 查询、ML 模型、jupyter 笔记本等创建新的文档。我个人在~/.metaframe/中保存了一个名为recipes的子文件夹，在那里我存储了 SQL 的命名片段。
如果您想要更全面的数据目录体验，metaframe 还支持本地运行的 ETL 作业。您所需要做的就是通过运行mf connections edit在 yaml 中指定一个连接，然后运行mf etl，您所有的数据都可以使用mf来访问。搜索并找到要做笔记的表格后，可以按 enter 编辑与所选表格相关联的文档，该文档将在以后的搜索中附加到元数据预览窗口。
因为文件结构完全是基于文本的，您甚至可以导航到~/.metaframe/metadata并用 git 跟踪它的版本。在一个有许多想要共享笔记的合作者的公司中，一个简单的模式可以是设置 CI/CD(或一个气流作业)来自动填充 git 存储库中的数据，并让用户将他们的个人文档推送到这个 repo 中的分支。因为这是版本跟踪的，所以通过检查您的同事的个人分支的提交历史，您应该能够很容易地看到您的同事了解哪些表，而不必询问他们。
有什么警告吗？
我注意到 metaframe 的唯一问题是，它会在 100，000 张左右开始突突。但是对于具有这种规模的公司来说，谨慎的做法可能是:( a)不在本地运行 ETL 作业,( b)限制正在提取的模式。在 metaframe 中，这只是简单地给你的mf connections edit文件添加几个标志，比如included_schemas或者excluded_schemas。更多详情参见文档。
Metaframe 支持 presto 或 neo4j 上的手动文档和 ETL(amundsen ),但是我们也支持定制的构建脚本,以支持定制的提取作业(从任何仓库，从预先抓取的数据库存储，等等。).我们也正在建立更多的本地连接(例如，雪花和 Postgres 正在工作中)。如果您热衷于让它为您的特定设置工作，请随时提出问题，我们会帮助您。或者，如果你愿意，做点贡献吧！😃
摘要
数据文档和数据发现是严重的问题，但它们不是数据科学家通常考虑的事情。我们很容易忽视一个每周浪费不到一个小时的问题，但我在这里告诉你，在所有规模上都有解决这个问题的办法。试试 metaframe 吧，我保证一旦你尝到了它的味道，你就离不开它了。
****回购:【https://github.com/rsyi/metaframe】T2
如何用 80 行代码找到便宜的航班
使用 Python 毫不费力地找到划算的交易
来源:https://unsplash.com/photos/Nukqi6L_5DU
由于旅行已经变得几乎不可能，我决定考虑如何开始为我的下一次旅行做准备。是的，我想到了旅行。
正如大多数人所知，飞机票价格相差很大。这是因为航空公司使用收益管理，这是一种旨在预测消费者行为以实现利润最大化的定价策略。
例如，用下面的代码，我连续两天每天 48 次查看一张从蒙特利尔到奥斯陆的机票。价格在 891 美元到 1298 美元之间(所有数据都是从 Kayak 报废的，右边这里)。同样的日期，同样的目的地，价格却相差很大。
考虑到这一点，我编写了一个代码，可以搜索便宜的机票，如果找到了，就通过电子邮件通知我。
这是代码。
包和参数
让我们从导入必要的包开始:
**# import libraries** from bs4 import BeautifulSoup
from selenium import webdriver
import pandas as pd
import datetime, re, time, itertools, smtplib, ssl
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
然后，我们定义代码工作所需的参数:
**#Define parameters** start_date = datetime.datetime(2020,9,13)
days_range = 2
trip_length, min_length, max_length = 7, 6, 12
price_goal = 900
cities = 'YMQ-OSL'
- 航班起飞的最早日期。
days_range:离开start_date的最大天数。基本上，旅行最晚什么时候开始(这里是 9 月 15 日)。trip_length, min_length, max_length:期望的行程长度，以及可接受的最小和最大长度。可以等同于trip_length。price_goal:您希望收到电子邮件提醒的价格。cities:出发和到达的城市。为了找到正确的缩写，请在网站上搜索航班时查看网址。
创建日期组合
既然已经定义了所有参数，下面是如何为旅行创建所有可能的出发/返回日期组合。
事实上，你可能有灵活的日期，无论是出发/返回还是旅行的长度。下面的代码将根据前面定义的参数生成所有可能的旅行日期。
首先，我使用itertools库生成所有可能的日期组合。
然后，下面的循环允许我们去掉所有不尊重条件的日期(旅行的最小/最大长度)或不连贯的日期(出发日期之前返回)。
最后，下面几行代码清除了日期，使它们可用于后面的循环。
**#Cleaning dates to make them usable in loop** for i in range(len(departing)):
departing[i]=re.sub(' 00:00:00', '', departing[i])
returning[i]=re.sub(' 00:00:00', '', returning[i])
抓取数据并接收警报
现在，说点实际的。这是用来找到最佳航班的算法，并确保当价格足够低时，您会收到提醒。
- 在 URL 中插入城市和日期
- 获得 Kayak 使用硒和美丽的汤提议的最佳飞行的价格
- 如果找到一个价格，保存它，如果没有，返回“没有找到航班”(try-expect 循环)
- 如果找到的价格低于
price_goal参数，发送一封电子邮件提醒，其中包含找到价格的 URL。
这是完整的代码。
这里我想提三件事。首先，不要忘记下载一个 chrome 驱动程序(并在第 6 行调整可执行路径)来使用 Selenium。
第二，不要忘记更新发送者、密码和接收者参数。这些指定了发送电子邮件的地址和接收电子邮件的地址。如果你愿意，你也可以改变邮件内容(主题或正文)。
第三，代码当前是为 Gmail 地址发送者设置的。对于任何其他类型的地址，应该更改端口(第 22 行)和stmp.gmail.com(第 37 行)。
收到的电子邮件警报应该是这样的:
使用任务计划程序
所有这些都是一个好的开始，但是不断地手工运行代码是浪费时间，直到找到一个好的交易。还不如像任何人一样，手动在 Kayak 上寻找交易。
幸运的是，任务调度程序是存在的。这个想法很简单。您可以安排您的代码每天运行 N 次，时间长短由您决定。你甚至可以在电脑睡眠时让它工作(但不要关机)。
关于如何用 python 脚本设置 Windows 任务调度器的教程，请点击这里。使用这个工具在很多情况下都非常有用，我强烈建议你学会使用它！
现在，当你坐下来喝杯啤酒时，你可以让你的电脑搜索廉价航班。你不仅节省了时间和金钱，而且是免费的。
非常感谢你的阅读！
完整的代码可在这里。
如何从 FP-Growth 中发现闭和最大频繁项集
Python 优化寻找闭和最大频繁项集
在上一篇文章中，我已经详细讨论了什么是 FP-growth，以及它是如何发现频繁项集的。此外，我从头开始演示了 python 实现。在这篇文章中，我将介绍关联规则挖掘中的两个重要概念，闭项集和最大频繁项集。为了理解这个概念，你需要对什么是 FPtree 和什么是频繁项集有一些基本的了解。我的上一篇文章涵盖了所有的基础知识。
什么是闭频繁项集和最大频繁项集
这里我们快速回顾一下频繁项集的概念。项目集的支持度大于或等于 minsup(最小支持度)阈值。支持度是项目集出现的频率。例如，给定一组事务 T，我们希望找到在所有事务中出现 2 次以上的所有项集。这可以看作是寻找所有 minsup ≥2 的频繁项集。
那么什么是闭和最大频繁项集呢？
根据定义，如果一个项目集的直接超集都不是频繁的，那么这个项目集就是最大频繁项目集。如果一个项集的直接超集都不具有与该项集相同的支持度，则该项集是封闭的。让我们用一个例子和图表来更好地理解这个概念。
这里我们有 5 个事务的事务 T，让我们用一个树形图表示所有的项集层次结构，并用红色写下项集出现在顶部的事务。
示例演示。
如果我们将 minsup 设置为 2，那么任何出现两次以上的项集都将是频繁项集。在这些频繁项集中，我们可以通过比较它们的支持度(出现频率)和它们的超集来发现闭的和最大的频繁项集。
突出显示所有封闭和最大频繁项目集
我们可以看到最大项集是闭项集的子集。同样，最大项目集作为一个边界，任何低于最大项目集的都不是频繁项目集(任何最大项目集的超集都不是频繁的)。
频繁、闭和最大项目集之间的关系
Python 实现
有许多不同的方法试图有效地找到最大和最接近的频繁项目集。这仍然是数据挖掘领域的一个热门研究问题。有兴趣的话可以找很多不同算法的研究文章来解决这个问题。我将演示一种相对简单的方法，通过比较每个项目的支持度和它们的超集来发现基于频繁项目集的闭和最大频繁项目集。然而，考虑到 O(n)的运行时间复杂度，这种方法可能相当耗时。为了在处理大型数据库时优化算法，我们需要利用 python 字典。通过将具有相同支持计数的所有项目集存储到一个字典中，使用支持作为关键字，我们可以将复杂度降低到 O(n)。因为我们不需要比较每一项，因为所有超集都有来自其父代的≤支持。并且我们在寻找封闭项集时只需要比较具有相同支持计数的项。同样的事情也适用于寻找最大项目集。
为了实现，我首先使用 MLXtend 库和 fpgrowth 函数来计算频繁项集，并编写自己的函数来从第一步的结果中挖掘封闭和最大频繁项集。
#Import all basic libray
import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
import time
from mlxtend.frequent_patterns import fpgrowth#Task1 : Compute Frequent Item Set using mlxtend.frequent_patterns
te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset)
df = pd.DataFrame(te_ary, columns=te.columns_)start_time = time.time()
frequent = fpgrowth(df, min_support=0.001, use_colnames=True)
print('Time to find frequent itemset')
print("--- %s seconds ---" % (time.time() - start_time))# Task 2&3: Find closed/max frequent itemset using frequent itemset found in task1su = frequent.support.unique()#all unique support count#Dictionay storing itemset with same support count key
fredic = {}
for i in range(len(su)):
inset = list(frequent.loc[frequent.support ==su[i]]['itemsets'])
fredic[su[i]] = inset#Dictionay storing itemset with support count <= key
fredic2 = {}
for i in range(len(su)):
inset2 = list(frequent.loc[frequent.support<=su[i]]['itemsets'])
fredic2[su[i]] = inset2#Find Closed frequent itemset
start_time = time.time()cl = []
for index, row in frequent.iterrows():
isclose = True
cli = row['itemsets']
cls = row['support']
checkset = fredic[cls]
for i in checkset:
if (cli!=i):
if(frozenset.issubset(cli,i)):
isclose = False
break
if(isclose):
cl.append(row['itemsets'])print('Time to find Close frequent itemset')
print("--- %s seconds ---" % (time.time() - start_time))
#Find Max frequent itemset
start_time = time.time()ml = []
for index, row in frequent.iterrows():
isclose = True
cli = row['itemsets']
cls = row['support']
checkset = fredic2[cls]
for i in checkset:
if (cli!=i):
if(frozenset.issubset(cli,i)):
isclose = False
break
if(isclose):
ml.append(row['itemsets'])print('Time to find Max frequent itemset')
print("--- %s seconds ---" % (time.time() - start_time))
感谢您的阅读，我期待听到您的问题和想法。如果你想了解更多关于数据科学和云计算的知识，可以在 Linkedin 上找我。
参考文献
http://rasbt . github . io/mlx tend/user _ guide/frequent _ patterns/FP growth/
如何在新冠肺炎期间找到数据科学工作
Clem Onojeghuo 在 Unsplash 拍摄的照片
众所周知，新型冠状病毒 2019(新冠肺炎)的爆发正直接或间接地深深影响着全球数百万人的生活。由于新冠肺炎政府关门，仅美国在过去两周就失去了近 1000 万个工作岗位。
一些会议、聚会、课程、音乐会和其他文化活动已经被推迟、取消或转移到网上。他们中还有数据科学、数据工程和数据分析职位，这些职位已经转移到了网上。
然而，调查表明，数据团队目前还没有看到大范围的裁员或休假，特别是在大公司中。所以，趁工作还没结束就罢工吧？
在任何给定的时间点，数据对于任何公司都是不可避免的，在这种情况下，初级水平的数据位置可能是一个堆栈，但你不能放弃。我们都明白目前国家和全球对招聘的影响是不确定的，但在这个动荡的时期，你有办法保持积极主动地找工作。
这些天我读了很多文章，都是关于这些天如何转换工作，或者如何在疫情期间找工作，如何保持理智。在这个故事中，我总结了 7 件现在要做的事情来继续你的数据科学求职。开始了…
1.加强你的联系
投入时间与你感兴趣领域的人、数据线索、招聘公司的数据团队建立联系。至少花一两个小时在职业网络上与人交流。
虽然你可能非常想要求引荐，但花点时间了解他们的工作，他们公司的情况，近期的前景，工作要求和期望。
- 利用你的时间进入你的人际网和他们的人际网，看看他们是否认识正在招聘的人或者有空缺职位的组织。
- 寻找志同道合的专业人士，你可能一直钦佩他们来引发关于可能的机会和虚拟网络活动和聊天的对话。
- 参加更多的在线活动、研讨会、实验室，看看是否有机会获得面试机会
专业建议:加入脸书和 LinkedIn 上的专业团体，扩大你的求职和人际网络。在封锁期间，这是建立新的、真实的联系和恢复旧联系的绝佳机会。
2.参与您的网络
这是你已经认识的人的网络。你肯定已经这么做了，但是问问你的朋友、导师、很久以前的同事，他们是否知道任何空缺的职位。
问问他们是否愿意通过电子邮件把你介绍给公司的同事，或者更好的是招聘经理。我认识一个人，由于前公司前老板的电子邮件介绍，他在 4 月下旬被录用了。相信我，电子邮件介绍从来不会失败。
让你关系网中的人代表你发送你的简历和求职信，可以让你的申请排在最前面，即使人力资源部在这些繁忙、不可预见的时期没有整理好通过 ATS 收到的申请。
如果你看到前同事和老板的公司有空缺，不要犹豫，立即联系他们。他们比其他人更有可能雇用你，因为他们已经知道你的技能和职业道德。
即使那家公司没有在招人，或者可能通过他们的关系网听说过其他工作，他们也可以为你提供很好的参考。如果还没有联系，现在就联系吧！
3.修改你的简历和作品集
Tbh，每次打开我的 LinkedIn 个人资料，我都觉得我可以提高。我甚至没有谈论 Github，尽管它在我的简历上。
如果你想走得更远，永远没有尽头。
花点时间写你的简历，磨练你的技能来推销你的“雇佣”版本。简历和网上资料是第一印象，甚至在别人了解你之前。你的简历反映了你目前的职业成就、教育、激情和技能。
说白了，我总觉得你应该是一个自己的品牌；一份能准确反映你是谁的工作，一份能让雇主感受到你的叙述和使命的工作。我们都很清楚 ATS 是如何运作的，如何让你从众多申请者中脱颖而出是一项艰巨的任务。申请远程职位时，仔细阅读职位描述，展示与职位描述相匹配的具体技能。
学习新技能，完成那些你已经开始但从未完成的，或者温习那些早已遗忘的。
4.为每项工作定制您的应用程序
尽管如此，将你的简历与工作描述相匹配，如果你没有根据工作要求和期望定制你的申请，那将是一个遗憾。
花更多的时间来构思你的求职信和简历，这样你的工作申请会得到应有的关注。通过 ATS 的秘诀是包含帖子本身的关键词！
因此，我们永远不应该犯从职位、职责或所需技能中抄袭工作的错误。但是，要确保你符合招聘经理指定的要求，比如合适的技能、教育水平或职称。
5.从事自由职业
数据科学或分析领域的自由职业者是一个棘手的概念。如果你已经了解了数据科学的概念，要成为一名自由职业的数据科学家，你可以做很多事情，也可以学习很多东西。Upwork 将是你寻找自由职业者的最佳起点。
更多的自由职业者工作可以从 PeoplePerHour.com 的到、到或
我推荐阅读来自 freeCodeCamp 的这篇关于如何成为自由数据科学家的博客。从建立一个文件夹开始，突出你的工作调色板，你的热情。
退一步说，如果你目前没有工作，至少自由职业可以支付我们的账单。这也是从“真正的”项目中获得一些急需技能的好机会。
如果你目前在 WFH 时尚界，值得注意的一点是，雇主正在寻找灵活、自律、拥有与同事和客户远程沟通所需的出色书面和口头沟通技能，并且高效的人。把这些都写进你的个人资料吧！
6.考虑临时职位——要灵活
有总比没有好！
你可能会遇到一个需要你工作 3-6 个月或者直到项目结束的职位，那么接受这个职位怎么样？谁知道那会不会变成一份全职工作！？足够敏捷，可以根据需要进行旋转。
我只会建议谷歌搜索“临时数据科学工作”。你可能会惊讶地发现，在 Indeed、ZipRecruiter、LinkedIn 或任何其他招聘网站上，有几个职位都有这个关键词。
这篇跳板文章有一个寻找数据科学工作的网站列表。
考虑一下临时的数据科学工作，让你在这个全球化的疫情中度过难关。如果这是你第一次进入自由职业者的领域，评估一下你最重要的可转移技能，然后寻找机会在不同的岗位上利用这些技能。
7.了解虚拟工作工具
您知道 Zoom 有分支会议室吗？分支会议室是从主 Zoom 会议中分离出来的会议，允许参与者在更小的小组中开会。
我发现，在实习开始前，我可能不得不学习一个工具，一个 Office 365 或独立的微软工具，我从来不知道它的存在。顺便说一句，组织使用 SharePoint 来创建网站。
了解所有功能和几乎所有相关信息:
实时沟通: Slack，微软团队，
视频会议: Zoom、Google Hangout、Skype for Business
项目管理:阿萨纳，Monday.com，特雷罗，适时
工具:谷歌在线套件，Office 365
8.保持高昂的情绪！
对于我们所有人来说，这是一个艰难的时期，甚至那些正在招聘的公司也在经历着不必要的转型。尽可能对自己和雇主有耐心。
虽然我们周围的一切都势不可挡，但你需要认识到，鉴于公司正在努力适应这些新常态，招聘过程将比平时慢。
记得一天一次拿东西。公司仍在积极招聘和寻找优秀的新人才来解决他们的问题，并继续在逆境中保持弹性。
感谢您阅读本文！我希望你。一定要让我知道你对这次启示录招聘的想法。对于读到这里的招聘人员，请让我们知道你的公司是否正在招聘！！
保持安全，保持理智..
免责声明:本文表达的观点仅代表我个人，不代表严格的观点。
了解你的作者
拉什是芝加哥伊利诺伊大学的研究生。她喜欢将数据可视化，并创造有见地的故事。当她不赶着赶学校的最后期限时，她喜欢喝一杯热巧克力，写一些关于技术、UX 等的东西。
如何通过交叉验证找到决策树深度
消化偏差-方差权衡、过拟合、欠拟合、K 倍交叉验证背后的直觉。
RegalShave 在 Pixabay 拍摄的照片
什么是决策树？
假设我们有一组经度和纬度坐标，对应于两种类型的区域:植被和非植被。我们可以建立一个逻辑回归模型，能够将任何坐标分类为植被或非植被。如下图所示，当类别在特征空间中很好地分离时，用于分类的逻辑回归工作得最好。
资料来源:哈佛大学 P. Protopapas 教授的讲稿
现在，让我们设想一种情况，植被分布在几个地区。如下图所示，现在解释非线性决策边界就不那么简单了。
资料来源:哈佛大学 P. Protopapas 教授的讲稿
事实证明，在这种情况下，一个简单的流程图可以被公式化为用于分类的数学模型。它们的优势是可以被人类理解。我们用一个简单的例子来说明这些决策树是如何工作的，在这个例子中，一种水果应该被识别为柠檬或橙子。
资料来源:哈佛大学 P. Protopapas 教授的讲稿
如何训练决策树？
为任何给定的训练数据集学习最小的决策树是一项困难的任务。在每个节点中，我们需要选择分裂的最佳预测值，需要选择分裂的最佳阈值。在前面的示例中，我们首先通过查看水果的宽度并使用阈值 6.5 厘米来决定。我们也可以从水果的高度开始，或者为宽度选择不同的阈值。我们的选择对树的区域形状有影响。
理想情况下，随着分裂次数的增加，这些区域应该逐渐变得更纯。每个区域应该专门针对一个类(柠檬或橙)。通常通过测量分类误差来评估这种分割的质量。也可以使用所谓的基尼指数来评估该区域的纯度。或者，区域的熵可以告诉杂质的级别。
什么是偏差-方差权衡？
在训练期间，该树将继续增长，直到每个区域恰好包含一个训练点(100%训练准确度)。这产生了一个完整的分类树，该分类树分割训练数据，直到每个树叶包含单个观察值。换句话说，整个树会过度适应训练数据。
过度拟合
过拟合的树将实现训练观察的完美分类，并且偏差(误差)将为 0 。然而，这样的树会非常敏感，因为训练观察的微小变化会导致预测的类别发生很大变化，这意味着模型方差会非常高。这个模型不能很好地概括看不见的数据。
权衡取舍
为了防止过拟合的发生，我们需要定义一个停止条件。低深度的树不能捕捉分隔类的非线性边界。通过减少树的深度，我们增加了 biais(训练的误分类误差),但是我们也减少了方差。偏差-方差权衡寻求偏差和方差之间的折衷，这里使用交叉验证。
什么是交叉验证？
适当的深度可以通过交叉验证在保留的数据集上评估树来确定。通过多次对数据进行重新采样，将分为训练折叠和验证折叠，在训练折叠上拟合不同大小的树，并查看验证折叠上的分类精度，我们能够找到树的深度，这提供了最佳的偏差-方差权衡。这种树不能完美地预测训练集(可接受的偏差)，但是如果我们稍微改变训练集(可接受的方差)，它的性能将大致相同。
来源—Scikit-learn.org
通过 K-fold 交叉验证找到最佳深度
诀窍是选择一系列树深度进行评估，并使用 K 倍交叉验证绘制每个深度的估计性能+/- 2 标准偏差。我们提供了一个 Python 代码，可以在任何情况下使用，在这种情况下，您需要调整给定预测张量 X 和标签 y 的决策树。该代码包括图中的训练集性能，同时缩放 y 轴以关注交叉验证性能。
该方法选择树深度 5，因为它使用大小为 5 的交叉验证折叠来实现对训练数据的最佳平均准确度。准确度置信区间的下限足够高，使得该值有意义。当更多的节点被添加到树中时，很明显，交叉验证的准确性向零变化。
深度为 20 的树在训练集上实现了完美的准确度(100%)，这意味着树的每一片叶子恰好包含一个样本，并且该样本的类别将是预测。深度为 20 的树过度适合训练集。
我们通过交叉验证选择的树深度 5 有助于我们避免过度拟合，并提供了一个更好的机会来重现准确性，并根据测试数据概括模型，如下所示。
结论
本文中的想法是使用 K-fold 交叉验证和搜索算法。搜索的输入是超参数网格，这是在训练模型之前选择的参数。在我们的例子中，这是一个简单的潜在树深度范围。
我们提供了易于复制的 Python 代码，不仅可以用于调整决策树，还可以用于一般的模型选择任务。其他方法包括嵌套交叉验证。
感谢 Anne Bonner 和 Amber Teng 来自《走向数据科学》的编辑评论。
如何在数据中找到隐藏的局部模式
应用局部偏差变换来揭示数据中微小的局部空间扰动
随着半导体和光电子器件性能的快速提高，相关制造工艺的规范也在快速收紧。这些流程中使用的制造设备必须保持领先，以保持路线图目标。这意味着对现有设备本身的改进是不够的，必须同时为 N+1 或更远的一代开发解决方案。
典型的半导体和光电器件制造包括在半导体晶片或其他衬底上的几十到上千个薄膜沉积、蚀刻、图案化和后处理封装步骤。最终的器件产量高度依赖于衬底上各个薄膜层的空间均匀性。这些不均匀性通常是由硬件的限制或工艺条件的稳定性造成的。因此，理解关键薄膜性质(例如厚度、导电性或光学性质)的不希望的空间变化是设计更好的制造硬件和增加最终器件产量的关键。
半导体晶片上薄膜的不均匀性正在经历戏剧性的改善，从 90 年代初的> 30%到 2000 年代初的 10–15 %,现在正在快速接近并在某些情况下超过< 1%的目标。实现这种改进的难度一级比一级增加得快。
虽然从 30%到 20%可能只花了几年时间，但对于一些流程来说，从 15%到 5%却花了近十年时间。进步不仅是渐进的，而且在许多情况下也是连续的。很容易想象，在总体变化为 10–15%的数据中，很难看到< 1%的变化模式。然而，如上所述，等待发现隐藏的模式不再是一个选项。
早期，许多过程的不均匀性通常是由长期空间趋势决定的。随着制造设备变得越来越复杂以及长期问题的解决，局部不均匀性的重要性开始增加。然而，尽管人们知道下一个大的非均匀性问题将是由局部模式引起的，但是找到这些模式的能力仍然有限。
在本文中，我们描述了在通过化学气相沉积沉积的薄膜的均匀性中搜索隐藏的局部图案的真实生活用例(出于保密的目的，真实的薄膜均匀性数据被替换为质量上相似的趋势，并且真实的隐藏的局部图案被替换为人工生成的图案)。
我们讨论一种通过执行局部偏差变换(LDT) 在整体长期趋势中发现隐藏的局部空间模式的方法。 LDT 通过将每个点的输入值替换为这些值与特征空间中周围邻域点的加权平均值的偏差来转换数据。通过限制邻域的大小和最小化更远的邻居的贡献，长期趋势的影响被最小化并且局部模式出现。
可视化数据
让我们在下图中用凹形、凸形和环形的长期趋势来可视化表示半导体衬底上的薄膜特性的数据，其中有和没有局部隐藏图案，等高线图中色阶显示薄膜特性的变化(蓝色:低；绿色:mid 黄色:高)。
你能看出有什么不同吗？
由于每个集合中的总体模式包含大约 0.5%的随机噪声，来自隐藏模式(当存在时)的贡献不到 2%，其余来自长期径向趋势，因此很难看出上部和下部地图集合之间的任何差异。
也许我们看径向图比看 2D 地图更幸运？
隐藏局部模式的径向图
现在我们有进展了！看到我们橙色线上的蓝色小波浪了吗？好吧，我们可以确认我们的数据中有一些奇怪的东西，但它是什么呢？
局部偏差变换
我们在寻找小扰动方面运气稍好一些(记得<2% hidden pattern?) in the data on the radial profile plots above, but we cannot easily tell the 2D locations or say anything at all about the 2D shape of these perturbations. Thus, we would not be able to link these spatial non-uniformities to specific hardware features causing them in the thin film deposition tool.
那么，我们如何着手寻找这些特征呢？我们可以通过只检查小的局部子集——邻域——的变化来最小化数据中压倒性的长期趋势的重要性。通过计算每个点的值与其周围点的差异，限制邻域的半径，并缩放更远的邻居的重要性，我们可以放大其他长期趋势中的局部模式。局部偏差变换的数学表达式如下:
V 是我们要变换的值，Rlocal是邻域的半径，p是谢泼德距离加权倒数法中的幂参数[1]。****
使用这些等式，让我们对数据集进行 LDT 变换，看看会得出什么结果。下面的代码片段是 LDT 算法的 Python 实现。
同时，我们还对不包含隐藏模式的数据执行转换以进行比较。
****
********
局部偏差变换在起作用。****
可以使用两个参数来针对各种使用情况微调 LDT 变换:邻域半径、 R local ，以及邻域距离灵敏度、 p ，这是 Shepard 方法中用于逆距离加权的功率参数。**
较大的局部邻域半径将对转换后的数据产生较强的长期影响。而大的功率参数将降低更远的邻居的相对重要性(当距离敏感度等于零时，所有邻居被同等对待)。
虽然 LDT 在过滤随机噪声方面相当有效，但是转换并不完美。当“远程”效果的范围与 LDT 变换邻域半径、T21局部相当时，就会出现一个限制。在这种情况下，转换不能完全移除“长程”特征(见圆环的残余部分，甚至在 LDT 转换后的数据上可见，用于圆环图案)。另一个影响是笛卡尔空间中采样点网格的不均匀性，这会导致在没有隐藏模式的凹和凸集合的 LDT 变换上最明显的人工特征。****
尽管有这些限制， LDT 是一种非常有效的技术，已经在发现隐藏的局部模式中得到证明，该模式对实际半导体加工应用的整体趋势贡献不到 2%。
LDT 不仅可以有效地应用于 2D 等高线地图数据，而且可以有效地应用于由多个叠加空间模式组成的任何维度的数据，以搜索隐藏的局部模式。
你能在你的数据分析中应用局部偏差变换吗？
我很想听听你对 LDT 可能的应用的想法或主意。
参考文献:
[1]https://en.wikipedia.org/wiki/Inverse_distance_weighting
如何找到最大似然算法的最佳预测器
了解特征选择及其各种技术，以提高机器学习算法的预测能力
图片由 JrCasas 在 Shutterstock 拍摄
所以现在，你已经清理了你的数据，并准备好将其输入机器学习(ML)算法。但是，如果您有大量的输入要素呢？对于模型学习来说，它们都足够有用和有预测性吗？如果你使用了所有的特性，是否会使你的模型缺乏解释力？拥有大量预测器还可能会增加开发和模型训练时间，同时会占用大量系统内存。
特征选择技术旨在为模型训练系统地选择输入特征的最佳子集，以预测目标变量。不要将特征选择与其他降维技术(如 PCA 或使用信息论)相混淆。特征选择技术不修改预测器的原始语义，而只是选择它们的一个子集，从而产生一个更易解释的模型。
Sayes 等人认为:“特征选择的目标是多方面的，其中最重要的是:
- 为了避免过拟合和提高模型性能，即在监督分类情况下的预测性能和在聚类情况下的更好的聚类检测，
- 提供更快和更多性价比高的车型，以及
- 更深入地了解生成数据的底层流程。"
虽然特征选择适用于有监督的和无监督的学习，但我在这里将重点放在有监督的特征选择上，其中目标变量是预先已知的。
在监督特征选择的环境中，我们可以定义三大类别:
- 嵌入式方法:有时也称为内在方法，这些技术内置于分类或回归模型的模型训练阶段。例子包括惩罚回归模型(例如，Lasso)和基于树的模型。因为这样的嵌入方法是模型训练的一个组成部分，所以我们不会在这篇文章中讨论这些。
- 过滤方法:这些技术着眼于要素的内在属性，并使用统计技术来评估预测值和目标变量之间的关系。然后，最佳排序或评分特征的子集被用于模型训练。在这篇文章中，我们将回顾这些不同的统计技术。
- 包装器方法:这些方法利用 ML 算法作为特性评估过程的一部分，根据特定的性能指标迭代地识别和选择最佳的特性子集。例如，scikit-learn 的递归特征消除(RFE) 类，我们将在本文稍后介绍。
过滤特征选择方法
在选择输入特征的最佳子集之前，过滤器特征选择技术利用各种统计测试和测量来推断输入和目标变量之间的关系。
请注意，这些统计测量是单变量的，因此，没有考虑各种输入特征对之间的相关性。首先从相关矩阵开始剔除冗余的相关特征可能是个好主意。或者，可以利用特定的高级多元滤波器技术，例如，基于相关性的特征选择(CFS)、马尔可夫毯式滤波器(MBF)和快速基于相关性的特征选择(FCBF)。然而，目前还没有得到广泛使用和支持的 python 包支持这些高级多元要素选择技术。
分类特征选择
可用于分类问题中的分类特征的两种常规统计特征技术是:
- 独立性卡方检验
- 交互信息
卡方检验用于确定两个分类变量之间的关系或依赖程度，在我们的示例中，一个是分类输入要素，另一个是分类目标变量。
在概率论和信息论中，两个随机变量的互信息度量它们之间的独立程度。更高的值意味着更高的依赖性。
对于编码为整数的分类特征(例如，通过[OrdinalEncoder](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html))，scikit-learn 的[SelectKBest](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectKBest.html)类与[chi2](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.chi2.html)或[mutual_info_classif](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.mutual_info_classif.html)函数结合使用，以识别和选择前 k 个最相关的特征。SelectKBest返回的分数越高，该特征的预测能力就越强。入围的特征然后被馈送到用于模型开发的 ML 算法中。
显示chi2和mutual_info_classif的完整工作示例如下:
注意SelectKBest也可以作为Pipeline的一部分用于交叉验证。然而，根据输入特性的基数，当模型在测试集中遇到训练集中没有的新值，因此没有用于编码时，在Pipeline中使用OrdinalEncoder有时是不可行的。在这种情况下，一个解决方法是使用不同的test_size和random_state运行train_test_split多次，然后取所选验证指标的平均值。
对于尚未进行数字编码的object类型分类特征(可能因为它们将被一次性编码或在稍后阶段转换为虚拟变量，SciPy 的[chi2_contingency](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chi2_contingency.html)类用于计算每对分类特征和目标变量的 chi 统计量和 p 值。然后，p 值最低的要素将被列入建模候选名单。
一个完整的工作示例如下:
数字特征选择——分类问题
可用于分类问题中的数字特征的两种常规统计特征技术是:
- 方差分析 F 统计量
- 相互信息(如上所述)
方差分析(ANOVA) F 统计量计算两个或多个数据样本均值的方差比率。数字输入特征和分类目标特征之间的比率越高，两者之间的独立性越低，越可能对模型训练有用。参见这篇优秀文章，了解 ANOVA F 统计的详细信息。
通过 sci-kit learn 的[f_classif](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.f_classif.html)函数，用于特征选择的 ANOVA F-statistic 在 Python 中类似地实现为独立性的卡方检验。假设我们这次处理的是数字特性，我们可以通过管道轻松实现交叉验证，如下所示:
数字特征选择—回归问题
啊，这是最简单的特征选择类型:为一个数字目标变量识别最合适的数字输入特征(回归问题)。可能的技术包括:
- 相关统计
- 相互信息(与前面解释的相同，只是使用了不同的
score_func:mutual_info_regression)
相关性衡量一个变量因另一个变量而发生变化的程度。也许最著名的相关性度量是假设数据为高斯分布的皮尔逊相关性。相关系数的范围在-1(完全负相关)和 1(完全正相关)之间，0 表示变量之间没有任何关系。
除了绘制相关矩阵之外，还可以使用 sci-kit learn 的[f_regression](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.f_regression.html)函数和SelectKBest类，实现基于相关性的自动特征选择，类似于独立性卡方检验或 ANOVA F 统计。此外，就像 ANOVA F-statistic 函数一样，我们可以通过管道轻松实现交叉验证，如下所示:
包装特征选择
来自 scikit-learn 的递归特征消除 (RFE)是实践中最广泛使用的包装器特征选择方法。RFE 是特征类型不可知的，它通过给定的监督学习模型(估计器)迭代地选择最佳数量的特征。
来自 scikit-learn 文档:“首先，在初始特征集上训练估计器，并且通过coef_属性或feature_importances_属性获得每个特征的重要性。然后，从当前特征集中删除最不重要的特征。该过程在删减集上递归重复，直到最终达到要选择的特征的期望数量。”
如上所述，RFE 只能与具有coef_或feature_importances_属性的算法一起使用来评估特征重要性。由于 RFE 是一种包装器特征选择技术，它可以使用任何给定的估计器(可以不同于应用于所选特征的算法)来识别最合适的特征。
假定RFE可用于分类和数字特征；在分类和回归问题中，它的实现是相似的。
需要调谐的RFE的主要参数是n_features_to_select。使用DecisionTreeClassifier进行特征选择和分类算法，基于RFE确定最佳特征数量的实际演示如下:
上面的代码片段将打印出RFE中使用的每个特性的平均和标准差，如下所示:
>2: 0.710
>3: 0.815
>4: 0.872
>5: 0.884
>6: 0.891
>7: 0.888
>8: 0.888
>9: 0.884
纯粹基于准确度分数，选择六个特征在这种情况下似乎是理想的。
自动特征选择以及对 RFE 多个模型的评估
然而，我们怎么知道DecisionTreeClassifier是 RFE 使用的最佳算法呢？如果我们想用 RFE 评估各种算法呢？来帮助我们了。
RFECV的主要目的是通过自动交叉验证选择最佳数量的特征。由于理想数量的特性将由RFECV自动选择(因此，在最后的代码片段中不需要for循环)，我们可以有效地训练和评估用于RFECV特性选择的多个模型。然后，可以使用具有最佳验证度量的模型向前进行预测。
现在让我们看一个实际的例子:
上面的代码片段将打印出RFECV中使用的每个模型的准确性得分的平均值和标准值，如下所示:
>LR: 0.891
>DT: 0.882
>RF: 0.888
>XGB: 0.886
简单的逻辑回归模型赢得了包装特征选择。然后我们可以用这个来做预测:
# create pipeline
rfecv = RFECV(estimator = LogisticRegression(), cv = 10, scoring =
'accuracy')
model = DecisionTreeClassifier()
pipeline = Pipeline(steps=[('features', rfecv), ('model', model)])# fit the model on all available data
pipeline.fit(X, y)# make a prediction for one example
data = #load or define any new data unseen data that you want to make predictions uponyhat = pipeline.predict(data)
print('Predicted: %.3f' % (yhat))
额外小费
大多数 ML 算法都有一个内置属性，用于查看模型学习过程中使用的特征的相对重要性。一些例子包括:
- 线性回归:
coef_给出系数列表。系数越高，输入特征对目标变量的影响越大 - 逻辑回归:
coef_提供系数列表，解释与线性回归相同 - 决策树和随机森林:
feature_importanes_—越高越好
结论
这次我就这样了。如果您想讨论任何与数据分析、传统机器学习或信用分析相关的问题，请随时联系我。
下次见，摇滚起来！
参考
受机器学习大师的杰森·布朗利博士的启发
[1] Saeys Y，Inaki I，Larranaga P .生物信息学中的特征选择
技术综述。生物信息学。2007;23(19): 2507-
2517。
如何用 Voronoi 图找到最近的医院
给定美国医院的大型数据集，我们如何快速找到最近的医院？
动机
有了美国医院的数据集，创建一个简单的应用程序，在患者需要时找到最近的医院，难道不是很有帮助吗？这听起来像是一个简单的任务。毕竟，你只需要在美国所有医院中找到最短的距离，对吗？
谷歌地图上医院位置的截图
显而易见的解决方案可能不是最佳解决方案。每次用户请求最近的医院时，搜索医院将会是耗时的，更不用说有数千用户同时使用应用程序的情况了。那么解决办法是什么呢？
检索自维基百科
我们可以像上面一样预先建立区域，点是医院。每当患者需要医院时，我们只需要知道他们在哪个地区，并把他们带到与该医院相关的地区。例如，如果一个病人在粉色区域，我们 100%确定最近的医院是该区域内的点。
是什么让这个方法如此伟大？我们只是提前计算一次图。当收到医院的请求时，医院会立即被发现。听起来这个实现值得一试！
检索自维基百科
Voronoi 图简介
上面的图是一个 Voronoi 图。Voronoi 图是将一个平面划分成靠近一组给定对象中的每一个的区域。为了创建 Voronoi 图，我们首先需要抓住它的一些特征。
作者图片
在上图中，点(1，8)到边界的距离等于点(9，4)到边界的距离。相同的规则适用于点(9，4)到(9，0)。2 点之间的边界是平分线，是将另一条线段切割成相等部分的线。****
用迭代算法实现
我选择用增量算法创建 Voronoi 图。由于目前还没有这个实现的 Python 源代码，所以我决定从头开始实现这个算法。
为了使这个算法工作，我们需要的数据结构是一个双连通边列表。双连通边列表是被分成半边的列表，每个半边指向不同的方向。这种方向上的差异将有助于识别哪个面对与相关的边缘。
作者图片
一次计算每个点的 Voronoi 图将是困难的和计算昂贵的。相反，我们将从一个小问题开始。假设我们已经有了 Voronoi 图，我们如何为创建一个额外的点的 Voronoi 图？一次更新一个点肯定会比一次更新多个点更容易。
从一个空的双连通边列表开始
作者图片
然后画两点之间的平分线。请注意，每个点到平分线的距离是相等的。
作者图片
当第三点出现时:
- 先找离最近点最近的点，就是 p2！
- 在两点之间画一条平分线。这条平分线将与另一条边界相交。使用该交点作为另一条平分线的起点
- 因为 p1 是与直线相交区域相关的点，所以画出 p2 和 p3 之间的平分线。
作者图片
这应该给我们一个更新的 Voronoi 图，有 3 个点！
作者图片
如果我们有第四点，同样的策略被应用。
让我们试试这个！
经过一个多月的努力理解算法、实现和调试，我终于让它工作了。这是我实现的一个 Github repo 。
要尝试这一点，克隆 repo 并转到目录
git clone [https://github.com/khuyentran1401/Voronoi-diagram.git](https://github.com/khuyentran1401/Voronoi-diagram.git)
cd Voronoi-diagram
在该目录中打开 Jupyter 笔记本或. py 文件并运行
你应该会看到这样的东西
作者图片
plotVoronoi 的第一个参数是点列表(元组列表)。其他参数是可选的，并且是 Voronoi 图的边界(xmin，xmax，ymin，ymax)。
要查看算法如何更新 Voronoid 图，请运行
在医院数据上使用 Voronoi 图
当然，我们仍然需要将这个图表应用于医院数据。因为我的代码仍然需要改进来处理每种情况，所以我不能在超过 7581 个数据点的情况下工作。所以我从美国四个不同医院的纬度中挑选了四个数据点来看看它是什么样子的
作者图片
我得到了这个
作者图片
创建地图和 Voronoi 图的代码可以在这里找到。如您所见，地图被分成 4 个不同的区域，每个区域有一家医院。如果患者需要找医院，我们只需要找到患者属于哪个地区，指引患者去最近的医院！
结论
恭喜你！你刚刚学会了一种用 Voronoi 图在地图上最大化你的发现的技术。实现这种算法是一种冒险，但我觉得看到这种工作是值得的。仍然有错误，我需要修复，以涵盖每一种情况，并使这在地图上的工作。另一个任务也是找出如何用 Voronoi 图搜索。我仍在努力，如果您有任何反馈或想法，我将不胜感激。
如果你想尝试这种算法或者在你的项目中使用它，请选择这个回购协议。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以通过 LinkedIn 和 Twitter 与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
如何利用包装算法实现数据可视化
towardsdatascience.com](/convex-hull-an-innovative-approach-to-gift-wrap-your-data-899992881efc) [## 如何用图论可视化社交网络
找出《权力的游戏》中的影响者
towardsdatascience.com](/how-to-visualize-social-network-with-graph-theory-4b2dc0c8a99f) [## 如何用 Altair 创建交互式剧情
在 5 行简单的 Python 代码中利用您的数据分析
towardsdatascience.com](/how-to-create-interactive-and-elegant-plot-with-altair-8dd87a890f2a) [## 如何用支持向量机学习非线性数据集
支持向量机简介及其在非线性数据集上的应用
towardsdatascience.com](/how-to-learn-non-linear-separable-dataset-with-support-vector-machines-a7da21c6d987)**
如何找到 KNN K 的最优值？
可视化误差率与 K 的关系图，找出最合适的 K 值。
图 1:通过educba.com拍摄的照片
介绍
K-最近邻是T5 用于分类和回归的监督机器学习算法。它处理训练数据，并基于距离度量对新的测试数据进行分类。它找到测试数据的 k 个最近邻，然后由大多数类别标签执行分类。
对于数据科学家来说，选择最佳 K 值以实现模型的最大准确性始终是一项挑战。我希望你们都知道 knn 背后的基本思想，但是我将在本文后面阐明 KNN 的概述。要全面了解这个算法的工作原理，我建议阅读下面的文章:
在本文中，我将演示在 knn 算法中感知 K 的理想值的可实现方法。
目录
- KNN 概况
- 距离度量
- 如何选择一个 K 值？
- KNN 模式实施
- 关键要点
我们开始吧，
1.KNN 概况
图 2:照片通过kdnuggets.com
使用 K-最近邻，我们通过找到测试点和训练的 K 个最近特征值之间的距离，从可用的类别标签中预测测试点的类别。通过分析所有的信息，你会提出一个问题，
距离怎么算？
让我在距离度量的下一部分回答你的热情问题。
2.距离度量
距离度量是有效的超参数，通过它我们测量数据特征值和新测试输入之间的距离。
图 3:通过slideplayer.com拍摄的照片
通常，我们使用欧几里得方法，这是最广泛使用的距离度量，用于计算测试样本和训练数据值之间的距离。我们沿着从点(x1，y1)到点(x2，y2)的直线测量距离。
图 4:照片通过slideplayer.com
通过分析上面的计算，我希望你能理解我们是如何计算欧几里德距离的。让我们来解释一下 KNN 的预测方法。
图 5:通过datacamp.com的照片
要对未知记录进行分类:
- 初始化 K 值。
- 计算测试输入和 K 个训练好的最近邻之间的距离。
- 检查最近邻的类别，并确定测试输入属于哪种类型。
- 将通过获得多数票来进行分类。
- 返回班级类别。
我们理解对未知记录进行分类的过程，但是选择一个最优的 K 值呢？
我们来回答一下。
3.如何选择一个 K 值？
图 6:simplilearn.com 通过的照片
K 值表示最近邻居的计数。我们必须计算测试点和训练标签点之间的距离。每次迭代更新距离度量的计算代价很高，这就是为什么 KNN 是一个懒惰的学习算法。
图 7:通过datacamp.com拍摄的照片
- 从上图可以看出，如果我们从 K=3 开始，那么我们预测测试输入属于 B 类，如果我们从 K=7 开始，那么我们预测测试输入属于 a 类。
- 这就是你如何想象 K 值对 KNN 性能有强大的影响。
那么如何选择最优的 K 值呢？
- 没有预先定义的统计方法来寻找最有利的 k 值。
- 初始化一个随机的 K 值，开始计算。
- 选择小的 K 值会导致不稳定的决策边界。
- 较大的 K 值对于分类更好，因为它导致平滑决策边界。
- 绘制误差率和 K 之间的曲线图，表示定义范围内的值。然后选择具有最小误差率的 K 值。
现在你会得到通过实现模型来选择最优 K 值的想法。
4.KNN 模式实施
让我们通过导入所有必需的包来启动应用程序。然后使用 read_csv() 函数读取电信数据文件。
图 8:主数据集
如您所见，有 12 列，即地区、任期、年龄、婚姻、地址、收入、学历、雇佣、退休、性别、居住和客户。我们有一个目标列，“cust cat”将客户分为四组:
- 1-基本服务
- 2-电子服务
- 3+服务
- 4-全面服务
图 9:K = 4 时的精度测量
- 我们将所有独立的数据特征收集到 X 数据框中，并将目标字段收集到 y 数据框中。然后我们处理数据并使其正常化。
- 分割数据后，我们将 0.8%的数据用于训练，其余用于测试。
- 我们从 sklearn 库中导入分类器模型，并通过初始化 K=4 来拟合模型。所以我们在这里达到了 0.32 的精度。
现在是时候改进模型，找出最优 k 值了。
图 10:误差率与 K 值的关系
从图中可以看出，在 K=37 时，我们得到的最小误差为 0.59。接下来，我们可视化了精度和 K 值之间的关系。
图 11:精度与 K 值的关系
现在您看到了改进的结果。我们在 K=37 得到了 0.41 的精度。由于我们已经推导出了误差图，并在 k=37 时获得了最小误差，因此我们将在该 K 值下获得更好的效率。****
因为我们的主要重点是确定最佳 K 值，但是，您可以执行探索性数据分析，甚至可以实现更高的准确性。数据文件和代码在我的GitHub库中。
5.关键要点
- 我们在 k=37 时获得了 0.41 的精度，比 k=4 时计算的效率要高。
- ****小 K 值不适合分类。
- 通常找到的最佳 K 值是 N 的平方根，其中 N 是样本总数。
- 使用误差图或精度图找到最有利的 K 值。
- KNN 在处理多标签类时表现良好，但是您必须注意异常值。
- KNN 广泛应用于模式识别和分析评价领域。
所有人都在这里，
在我的下一篇文章中再见。
你好👋我希望你能从我的文章中获得知识。如果你愿意支持我，请随意给我买些咖啡🙏☕
https://www.buymeacoffee.com/amey23
或通过 ameypband23@gmail.com 联系我
乐意为您效劳。
参考文献:监督机器学习中的肘方法
github.com](https://github.com/Amey23/Machine-Learning/tree/master/K-Nearest Neighbor)**
如何为您的企业找到合适的数据科学用例
数据科学和商业战略
第 1/4 集—识别
介绍
如果你在谷歌上搜索“数据科学用例”，你会发现数百个这样的列表，每个条目都以一个时髦词开头，比如欺诈检测、推荐系统或其他更花哨的术语。接下来是一小段，试图用 200 个词来解释它，勉强够将这个术语与其他术语放在一起，如人工智能、数据科学、机器学习、深度学习，所有这些都用最高级来调味。反正数据科学(或者 AI，或者机器学习，或者深度学习)应该让事情变得更好，要不然，有什么意义？
看着这些清单，对于一个试图弄清楚实际需要做什么的 DS 来说，这可能是令人困惑的。它们充其量只是灵感，但不是配方，也不包含任何诀窍。作为(好的)DS，我们应该能够识别潜在的用例，找到并掌握解决它的工具，并与我们的业务同事一起产生影响。先从识别开始，下面是你如何做好。
确定数据科学使用案例
数据科学用例至少有两个先决条件，一个是数据(不足为奇)，另一个是导致行动的业务决策。数据科学提供工具来检查数据背后的机制，以便可以利用它来制定更好的业务决策。以一种非常示意性的方式，我们可以设计一个练习，通过 4 个步骤找出最佳数据科学用例:
第一步:理解上下文
- 画出你感兴趣的业务部门的关键决策和后续行动(BDA)的结构，就像这样。所有 BDA 都分组在一个节点下，代表拥有决策或行动的单位。节点之间的箭头表示它们如何通过材料影响(工厂的生产取决于原材料供应)或信息交换(仓库库存水平在很大程度上取决于工厂的需求)相互影响。
- 然后列出用于驱动此 BDA 的数据。问问你自己，这些数据是否质量良好，或者是否可以引入任何其他数据来改进决策，也把它们记下来。
- 最后，添加一些关于推动这些 BDA 的流程的信息，注意所需的时间、涉及的人员或业务部门、技术支持的程度以及是否有任何难点。
这个过程可能需要一段时间，因为了解公司其他部门的情况并不容易。然而，对驱动 BDA 的机制和原理有一个很好的理解是至关重要的，否则我们可能会忽略要解决的实际问题，最终得到一个完美但无用的模型。因此，搜索文档和演示文稿，最重要的是，与人交谈。
第二步:缩小关注范围
是时候为您的数据科学项目评估和选择最佳的 BDAs 了。尝试回答以下每个问题:
- 它是否有很大的财务影响，即要么产生高成本，要么产生可观的收入？
- 它是否是许多其他 BDA 的必要投入，因而需要高质量？
- 是否存在可以通过使用更好的技术和数据科学来缓解的紧迫痛点？
- OP 接受新技术和改变工作方式的可能性有多大？
对于理想的 BDAs，你应该能够回答“是”所有这些问题。他们是从数据科学中受益最多的人，这就是为什么我们应该关注他们。
第三步:高级数据评估
数据质量对于数据科学用例的可行性至关重要。早期评估可以帮助我们确定优先级，并选择正确的方法和技术。为了更好地了解数据质量，我们可以考虑以下几个方面:
- 数据是决策的关键输入(如果不是主要输入)吗？如果不是，那么使用一些数据作为关键/主要输入是否会更好？
- 数据来源可靠吗？ETL 是如何工作的？它是否依赖于传统的 it 系统？需要人工操作吗？数据库维护得如何？
- 使用的数据量有多大？可能用于决策的数据量有多大？
- 我们有多大可能获得改善当前决策所需的额外数据？
在最好的情况下，数据源应该是可靠的，并用作决策的主要输入。数据大小可以向我们指示正确的工具(例如，当数据大小较大时，应考虑分布式系统)和经常使用的方法(例如，对于小数据集，优选线性回归或传统统计方法等简单算法，以避免过度拟合)。
第四步:总结归纳
通过比较第 2 步和第 3 步的结果，我们应该能够根据这些基于两个维度(影响和可行性)的标准来选择甚至排列 BDAs:
- 【影响】无论在财务还是非财务方面，它都有很大的影响
- 【影响】数据科学和技术可以极大地改善其结果
- 【可行性】关键利益相关者愿意接受新技术和变革
- 【可行性】所需数据输入可用且质量良好
- 【可行性】ds 和 SE⁴团队拥有部署所需技术的技能
然后，可以通过将具有重叠数据需求和关键利益相关者的紧密联系的 BDA 分组在一起来定义用例。最后，为了找出从哪里开始和从哪里结束，我们将再次查看每个用例的影响和可行性，但是现在有了一个额外的维度——依赖性。不用说，其他案件所依赖的案件应该尽早开始。现在，您的数据科学使用情形有了一个坚实的路线图！
符号
DS:数据科学家，但也是机器学习工程师，他们更擅长建模而不是软件工程
BDA:商业决策和行动。
运营和生产，确保日常业务良好运转的人。
SE⁴:软件工程师，但也有数据工程师，他们更感兴趣的是制造良好和强大的产品或管道。
如何有效地微调你的机器学习模型
发现为您的 ML 模型寻找最佳参数非常耗时？用这三招
动机
您是否曾经想为您的模型试验不同的参数，但发现这样做真的很耗时？假设您想要使用支持向量机(SVM)来训练和预测模型。
你争论什么可能是C的最佳值，所以你继续手动试验C的不同值，希望得到好的结果。这很费时间，但还不算太糟。
但是如果要先用sklearn.feature_extraction.text.TfidfVectorizer提取重要文本，再用sklearn.feature_selection.SelectKBest寻找最佳特征，最后用sklearn.SVM.LinearSVC训练预测模型呢？在中会有很多参数需要调整。此外，你需要找到一种方法来记录结果进行比较。所以你的笔记本可以看起来乱七八糟！
有没有更好的方法来选择参数，缩短代码，以及保存结果进行比较？是的，当然！我们的方法就像一个美味的蛋糕，有三种简单的配料:
- 合并不同模型的管道
- 网格搜索以找到每个模型的最佳参数
- MLflow 记录结果
有你需要的所有成分吗？厉害！现在我们准备把它们放在一起。
照片由德鲁·帕特里克·米勒在 Unsplash 上拍摄
管道
什么是管道？[**sklearn.pipeline.Pipeline**](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html)允许我们将一系列转换和一个最终估计器组合成一个链。
例如，为了预测一条推文是否具有攻击性，在处理文本后，我们使用tfidf_vectorizer,和SelectKBest作为变压器，使用svm.LinearSVC作为最终估计器。
上面的代码可以合并到一个管道中，管道中有一列表示为元组的步骤。在每个元组中，第一个参数是类名，第二个参数是类。
短得多，有条理！我们可以很容易地将任何步骤切换到另一个转换器或估计器。确保管道中的类来自sklearn.如果不是，你可以像这样用def __init__, def fit(),和def transform()轻松创建定制的sklearn类。
在这里找到示例源代码
网格搜索简历
因此，我们准备好了转换和预测数据的管道。但是参数调优呢？通过[***sklearn.model_selection.GridSearchCV***](https://scikit-learn.org/stable/modules/compose.html)***.***，我们可以很容易地找到管道中变压器和估算器的最佳参数
假设我们想要找到SelectKBest的最佳值k，最佳值C的最佳值svm.LinearSVC,，最佳值analyzer, ngram_range,和binary的最佳值TfidfVectorizer.，我们可以给网格几个参数来搜索。参数表示为嵌套在字典中的列表。
为了设置特定类的参数，我们使用class_name__parameter = [para_1, para_2, para_3].确保类名和参数之间有两个下划线。
grid_search.fit(X_train, y_train) 使用不同的参数、指定的转换和估算器创建几次运行。将为转化步骤选择产生最佳结果的参数组合。
我们还可以用不同的变压器和估算器创建其他管道，并再次使用 GridSearchCV 来寻找最佳参数！但是我们如何保存所有运行的结果呢？
可以通过上下滚动屏幕或拍摄结果照片来观察结果。但是这很费时间，没有考虑到我们可能希望在以后的项目中看到结果。有没有更好的方法来跟踪我们的结果？这就是我们需要像 MLflow 这样的跟踪工具的时候
MLflow
MLflow 是一个管理端到端机器学习生命周期的工具，包括跟踪实验、以可复制的形式打包 ML 代码以供共享和部署。我们将利用这个工具来记录我们的结果。
MLflow 的安装可以像这样简单
pip install mlflow
让我们将目前为止所做的与物流跟踪工具结合起来
在这段代码中，我们只添加了三个元素来记录结果:
mlflow.set_experiment('name_of_experiment')创造新的实验mlflow.start_run()我们要运行实验的代码在里面mlflow.log_param()和mlflow.log_metric()来记录参数和指标
将上面的文件保存为train.py.最后一步是运行文件
python train.py
代码运行完成后，我们可以通过运行
mlflow ui
访问链接 http://localhost:5000 ，我们应该会看到这个
正如我们从上面可以看到的，实验的指标和参数都被记录下来了！我们可以创建几个实验并记录这些实验的结果，以便进行简单有效的比较。
结论
恭喜你！您已经学习了如何使用 Pipeline、GridSearchCV 和 MLflow 高效地调整机器学习模型的参数。您可以在这里找到本文的类似示例代码。我鼓励你在现有的机器学习项目中尝试这些方法。从长远来看，编码方法上的一点点改变就能产生很大的不同。有效地进行实验并跟踪结果不仅会节省您的时间，还会使您更容易找到最佳参数并从实验中学习。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上联系我。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
被新信息淹没？现在，您可以轻松地跟踪文章并为其创建自定义注释
towardsdatascience.com](/how-to-organize-your-data-science-articles-with-github-b5b9427dad37) [## 如何为你最喜欢的可视化工具创建下拉菜单和滑动条
使用 Python Widget，您可以用 3 行代码升级可视化
towardsdatascience.com](/how-to-create-a-drop-down-menu-and-a-slide-bar-for-your-favorite-visualization-tool-3a50b7c9ea01) [## 如何用 Ngrok 用 3 行代码分享你的 Jupyter 笔记本
想象一下，让你的朋友在远程机器上使用你的本地 Jupyter 笔记本
towardsdatascience.com](/how-to-share-your-jupyter-notebook-in-3-lines-of-code-with-ngrok-bfe1495a9c0c) [## 如何使用 HyperDash 远程监控和记录您的机器学习实验
培训需要很长时间才能完成，但你需要去洗手间休息一下…
towardsdatascience.com](/how-to-monitor-and-log-your-machine-learning-experiment-remotely-with-hyperdash-aa7106b15509) [## cy thon——Python 函数的加速工具
当调整你的算法得到小的改进时，你可能想用 Cython 获得额外的速度，一个…
towardsdatascience.com](/cython-a-speed-up-tool-for-your-python-function-9bab64364bfd)
如何在不编码的情况下微调 BERT 来对您的空闲聊天进行分类
伯特图摘自原始论文
随着时间的推移，松散的聊天会变得混乱，难以提取有意义的信息。在这篇文章中，我想介绍一种快速的无代码方式来微调和部署常用的 BERT 分类器来进行会话分析。我们将使用该系统从我们的空闲对话中提取任务、事实和其他有价值的信息。它可以很容易地扩展到分类任何其他文本数据，如支持请求，电子邮件等。
我们想从 Slack 中提取什么？这可能取决于您的团队使用它的目的，以及共享的信息类型。对我们来说，我们发现很多 todo 任务迷失在不停的文本流中，还有一些有价值的信息可以进一步添加到产品文档中，或者需要在日常会议中讨论。
从标签工作室的角度看机器学习生命周期
Label Studio 提供了一种简单的方法来试验 NLP 机器学习，在不到一个小时的时间内覆盖了从原始未标记数据到部署预测服务的整个 ML 生命周期。如果你想随意聊天，请遵循以下简单步骤:
收集数据
从 Slack 收集数据可以通过使用 Evernote Slack bot integration来完成。这很简单，只需设置并运行 /clip 进入您想要卸载的松弛通道。然后你会在 Evernote 应用中找到相应的文档:
使用 Evernote 应用程序删除松散的对话
那么原始文档应该被分割成单独的消息。保存时间戳也有助于进一步分析。使用以下项目列表创建一个 JSON 格式的文件 tasks.json :
[{
"text": "Hello, dear Anton.\nLabel Studio is the basis of our Heartex platform. Everything you describe here is available on the platform. And much more:)",
"date": "November 15, 2019"
}]
微调伯特分类器
你可以将 Label Studio 连接到机器学习后端，并在新数据可用时使用它进行预测和重新训练。模型在每次接收到新的带注释的任务时更新其状态，并且重新部署新的状态以对新进入的任务进行推理。一旦设置好了，微调就变得非常容易——您只需要做一件事就是标记您的任务——过一会儿，您就可以通过 REST API 服务获得一个可用的工作模型。
我们专门构建了一个应用，它将 Label Studio 与机器学习后端集成在一起，后者由开源变形金刚库中的 BERT 模型提供支持。假设您安装了 docker-compose，您可以用以下命令启动它:
git clone [https://github.com/heartexlabs/label-studio-transformers](https://github.com/heartexlabs/label-studio-transformers)
cd label-studio-transformers
docker-compose up
这个命令在本地启动位于 http://localhost:8200 的 Label Studio。进入导入页面，上传之前创建的 tasks.json 文件。就这样，所有的设置都完成了，现在你可以对来自标签 UI 的消息进行分类，检查模型的建议是否随着时间的推移而改进。
用 Label Studio 微调 BERT 分类器。
数百条消息可能就足够了，这取决于您愿意解决的任务有多复杂，以及您期望的准确度有多高。在我们的例子中，我们将消息分为五类:问题、议题、建议、提交和其他。可接受的质量是在三百个任务之后建立起来的，并且需要大约一个小时的注释。如果时间不够，也可以让奶奶对分类器进行微调。
识别聊天信息
由于在注释过程中已经部署了模型，所以您可以使用 right away 通过 REST API 预测新消息的未知标签:
curl -X POST -H 'Content-Type: application/json' -d '{"text": "Its National Donut Day."}' [http://localhost:8200/predict](http://localhost:8200/predict)
如果一切正常，您将看到 JSON 响应:
[
{
"cluster": null,
"result": [
{
"from_name": "label",
"to_name": "text",
"type": "choices",
"value": {
"choices": [
"Other"
]
}
}
],
"score": 1.6718149185180664
}
]
其中“其他”是带有某种“分数”的预测消息类型(有关格式的更详细解释，请联系 Label Studio docs )
除了通过 Label Studio API 使用模型之外，您还可以在存储/label-studio-ml-backend/ 模型目录中找到所有检查点，并使用 Tensorboard 检查训练进度。
我们学到了什么
松散的聊天是混乱的，但是感谢现代的 NLP，它变得很容易把你的对话组织起来并获得有用的见解。例如，你可以探索在某个时间段内你的对话中发生了什么，就像我们通过汇总过去几个月我们的信息预测所做的那样:
根据伯特模型，我们过去几个月的轻松谈话
我们从这张图表的一些观察模式中得出的结论是:
- 圣诞节和新年假期期间的许多随意交谈
- 当有问题/错误报告时，不要随意交谈
- 代码提交后，接下来是对问题的讨论
- 问题与建议相关联，这显然是正常的
- 建议引发问题和讨论
我们实际学到的是花一个小时注释你的文本足以构建一个合理的 ML 工具。我相信标记更多的数据会让您受益于更高的细粒度准确性。
结论
通过创建 Slack analytics 应用程序，我们展示了如何通过仅使用数据注释来解决复杂的机器学习任务。你不用写代码，而是通过展示一个你如何解决的例子来教模型执行任务。可以更深入地将 Label Studio 与其他机器学习框架一起使用，例如，微调一些用于分割、姿势估计、场景检测等的计算机视觉任务。很想听听你有什么想法和实现
快乐贴标签！
如何更快地适应随机森林
Sebastian Unrau 在 Unsplash 上的照片
使用热启动和开箱交叉验证
随机森林是机器学习的基本模型/算法。最近在 2001 年，已故的利奥·布雷曼在一篇经典的论文中首次描述了它们目前的形式。尽管人工神经网络越来越受欢迎，但它们在各种情况下都有实际用途。
有大量资源详细介绍了随机森林是如何工作的。本文将非常简要地回顾它们，然后转向主要焦点:如何通过热启动和开箱交叉验证更快地适应它们。有了这两种技术，超参数选择可以大大加快，减少拟合时间。
随机森林
随机森林是基本估计器的集合，通常是单个决策树。因此有这样一个比喻:把一堆树放在一起，你会得到一片森林。
单个决策树的问题在于它们的方差很大。这是一个经常使用的术语，所以有必要具体说明它的含义。假设从群体中重新采样数据，并重新调整决策树。然后我们可以收集各种各样的预测(比如一个固定的样本外输入)。这允许我们为预测创建一个概率分布，我们指的是这个分布的方差。这种差异通常不被明确地测量，导致有时术语偏差和差异的模糊用法。
随机森林的主要观点是，如果我们有一组不相关的决策树，它们的均值方差会更低。这是一个关于随机变量均值方差的一般性质，你习惯于从例如中心极限定理中得到。在这种情况下，随机变量是来自随机选择的树的预测(稍后我们将详细介绍如何做到这一点)。在回归环境中，平均值就是字面上的平均值。在分类上下文中(为简单起见，比如说二进制)，平均值相当于投票。
为了创建随机决策树，我们通过重新采样我们的训练数据来模拟人口的重新采样，这一过程称为引导。如果我们有一个大小为 N 的数据集，我们通过替换从原始数据集采样来创建新的大小为 M 的随机数据集。通常 M=N，但不需要如此。当自举被用来产生各种预测器时，就像这里一样，这个过程被称为bootstrapaggregation，或者 bagging。
此外，当我们创建每个单独的决策树时，我们选择输入变量的随机子集，以便在树中的每个节点选择最佳分割时加以考虑。这进一步降低了树的相关性。
最后，从讨论中可以明显看出，我们的目标是使用高方差、低偏差的估计量和总量来减少方差。从本质上来说，对森林的聚集就是正则化方法。因此，使用更大的树(具有更多的节点和更低的偏差)作为基本估计器是有意义的。
拟合随机森林
一如既往，拟合随机森林归结为选择超参数。随机森林的超参数是
- 基础估计器(通常是决策树)的超参数可能很多。
- 放入森林的树木数量。
同样，您应该认为第二个参数有点像正则化参数。随着树的数量越来越多，方差越来越小(但没有伴随的偏差损失)。随着树的数量增加，在准确性(或其他类似的度量)方面没有真正的损失。然而，推理时间与树的数量成线性比例，拟合时间也是如此。
随机森林的性质意味着有两种很好的方法来加快超参数选择:热启动和开箱交叉验证。
袋外交叉验证
当构建随机树时，上面描述的引导程序意味着只有一部分训练数据被包括在用于拟合该特定树的数据中。这意味着树对“袋外”样本的预测类似于样本外预测，即在验证集上的预测。“包”是指由引导程序选择的训练数据的子集。
这意味着，当拟合随机森林时，可以在拟合过程中生成验证误差的估计值(形式上:泛化误差),而无需使用实际的验证数据集。这通常是一个很好的估计。
与在验证数据集上重新运行拟合树相比，使用出袋误差可以节省时间。
热启动
当与热启动相结合时，袋外交叉验证的真正威力才会显现。当考虑要在我们的森林中包含多少棵树时，人们每次都可以天真地改造整个森林。例如，如果我们想决定是包括 100、200 还是 300 棵树。如果我们每次都改装，我们总共要装 600 棵树。然而，在拟合 200 棵树时，我们可以重用前 100 棵树。毕竟，它们是 100 棵树的完美随机样本。结果是我们只需要安装 300 棵树，速度提高了 2 倍。如果我们考虑是安装 100、200、300……还是 1000 棵树，我们可以实现 5.5 倍的加速！
与袋外交叉验证的结合是因为我们可以很容易地生成验证误差的估计值！
笔记
[1]假设用相同的超参数重新装配该树，或者，如果您愿意，用包含通过交叉验证的超参数选择的相同程序重新装配该树。
[2]然而，随机森林本质上是非常可并行化的(因为每棵树都可以独立地拟合和计算)。如果关注的不是 CPU 的使用时间，而是挂钟的时间，那么没有太大的损失。
[3]例如，参见统计学习的要素 (Hastie、Tibshirani 和 Friedman 2009)，第 15 章。
如何使用读取修复修复 Cassandra 一致性问题
由 Unsplash 上的 Louis Hansel @shotsoflouis 拍摄的照片
为什么 CAP 定理中存在一致性问题或 C
很多人可能都知道，Cassandra 是 AP 大数据存储。换句话说，当网络分区发生时，Cassandra 仍然可用，并放松了一致性属性。人们总是说它最终是一致的，或者换句话说，它将在未来的某个时间点上是一致的。
需要知道的不太明显的重要事项是:
- 集群变经常不一致。当然，有许多因素会影响群集的稳定性，例如适当的配置、专用资源、生产负载、运营人员的专业水平等，但事实是，节点不时出现故障从而导致数据变得不一致的可能性非常高。
- 该集群不会自动或再次变得一致。这与上帝对现代成熟分布式系统的感觉背道而驰。除非您有企业版的 Datastax 并启用了 DSE v6 的最新功能，否则您必须手动修复不一致问题。
修复不一致的方法
幸运的是，有一些方法可以解决不一致的问题。这里有几个选项:
- nodetool 维修工具。这可能是要使用的主要和默认方法。在所有表或特定表关闭的节点上运行命令。不过有一点需要注意:当您运行命令时，所有的节点都应该处于运行状态。
- 阅读修复卡珊德拉特写。这是一个重要的特征，意味着在读取请求期间，集群有机体正在自我修复，更准确地说，它修复正确的数据副本。如果读取请求中涉及的复制副本不一致，则会再次对齐它们
何时及为何阅读修复
如上所述，修复不一致的默认和主要方法是 nodetool 修复工具，因此自然的问题是何时以及为什么使用 read 修复方法。让我用我的一个项目的经验来回答这个问题。
在某个时候，我们进入了一个时期，此时我们的 Cassandra 集群开始变得非常不稳定，并且花费了大量的时间，直到所有节点再次返回到运行状态。这导致了两个主要后果:
- 数据不一致
- 在此期间，无法使用 nodetool 修复工具来修复不一致
在这种情况下，我们能做的最好的事情就是使用读取修复功能来确保至少在大多数复制副本中，在仲裁级别，数据是一致的，因此对于使用仲裁一致性级别的所有读取，数据都是一致的和最新的
如何使用读取修复
读修复特性只修复读操作所涉及的记录的一致性，那么如何修复整个表呢？
可以使用以下方法:
- 选择一个最窄的列进行阅读
- 使用 copy 命令读取整个表，将数据导出到文件中
因此，让我们考虑在一个 keyspace“test”中有一个 Cassandra 表“event”，其中一个最窄的列称为“id”；复制命令如下所示:
cqlsh -e "consistency QUORUM; copy test.event(fid) to '/tmp/tid'"
或者，您可以读取整个记录并将它们发送到'/dev/null ':
cqlsh -e "consistency QUORUM; copy test.event to '/dev/null'"
当然，当所有节点都启动时，您可以使用 consistency ALL，但在这种情况下，最好使用 nodetool 修复工具，如下所示:
nodetool repair test event
结论
Cassandra 是伟大的大数据存储，但为了充分利用它，它需要很好地理解主要原则，它是如何工作的，就像任何美丽的东西一样，它需要一些小心:)
如何修复 ModuleNotFoundError 和 ImportError
做适当的模块导入，让你的生活更轻松
照片由莱昂·温特在unsplash.com拍摄
TL；博士；医生
- 使用绝对进口
- 将您的项目根目录附加到
PYTHONPATH—在您希望运行 Python 应用程序的任何环境中，如 Docker、vagger 或您的虚拟环境，即在 bin/activate 中，运行(或例如，如果您使用 virtualenv，则添加到bin/activate)以下命令:
export PYTHONPATH="${PYTHONPATH}:/path/to/your/project/"
- *避免使用
sys.path.append("/path/to/your/project/")
模块导入肯定会让人们感到沮丧，尤其是那些对 Python 相当陌生的人。由于我每天都在 StackOverflow 上看到相关的问题，所以我决定在 Medium 上写一篇文章，尝试描述 import 在幕后是如何工作的，以及为了使您的生活更轻松，您需要遵循什么方法。
术语
首先，让我们从定义一些有用的术语开始，这些术语将帮助您理解本文中描述的概念。
- 一个 python 模块是一个带有的单个文件。py 分机。
- 一个 python 包是一个包含至少一个 python 模块的文件夹。对于 python2，一个包需要一个 init。py 文件
- 一个 python 包可以包含任意数量的嵌套子包，即包含项目结构中其他包的包。
- 导入在一个模块需要使用另一个模块(相同或不同的包或子包)中编写的一些功能(如函数或类)时很有用
例如，考虑以下项目结构:
└── myproject
├── mypackage
│ ├── a.py
└── anotherpackage
├── b.py
├── c.py
└── mysubpackage
└── d.py
项目myproject包含两个包，mypackage和anotherpackage，每个包包含许多 python 模块，而后者还包含一个名为mysubpackage的子包，该子包又包含一个额外的 python 模块。
模块导入是如何在幕后工作的？
现在让我们假设在您当前的模块中，您希望导入另一个模块，如下所示:
import a
Python 将分两步执行上述语句:
- 定位、加载和初始化(如果需要)所请求的模块
- 在本地名称空间和相应的作用域中定义必要的名称
现在 Python 解释器将按照下面的步骤尝试解决a。
步骤 1:系统模块查找
最初，Python 会尝试在[sys.modules](https://docs.python.org/3/library/sys.html#sys.modules)中搜索模块名，这是一个将模块名映射到已经加载的模块的字典。如果名称解析成功(这意味着另一个模块已经加载了它),那么它将可用于本地名称空间；否则，跳到步骤 2。
步骤 2: Python 标准库查找
Python 标准库包含内置模块(用 C 编写),提供对系统功能的访问，如 Python 程序员无法访问的文件 I/O，以及用 Python 编写的模块，为日常编程中出现的许多问题提供标准化解决方案。其中一些模块被明确设计成通过将特定于平台的抽象成平台中立的 API 来鼓励和增强 Python 程序的可移植性。
如果在sys.modules中找不到这个名字，那么 Python 将在 Python 标准库中搜索它。同样，如果名称被解析，那么它将在本地名称空间中定义，否则需要遵循步骤 3。
步骤 3:系统路径查找
现在，如果在sys.modules和标准库中都找不到模块名，Python 将最终尝试在sys.path下解析它。这是事情肯定会出错的地方。我相信大部分 Python 程序都很熟悉**ModuleNotFoundError**
import aModuleNotFoundError: No module named 'a'
或者**ImportError**:
from . import aImportError: cannot import name 'a'
绝对进口与相对进口
在绝对导入中，我们指定了从项目根目录开始的显式路径。在我们的例子中
└── myproject
├── mypackage
│ ├── a.py
└── anotherpackage
├── b.py
├── c.py
└── mysubpackage
└── d.py
这意味着如果我们想要在模块b中导入模块a，我们必须指定
import mypackage.a
其他有效的示例包括以下导入:
# in module a.py
import anotherpackage.mysubpackage.d# in module b
import anotherpackage.c
另一方面，在相对导入中，我们指定了相对于当前模块位置的模块路径。我们示例中的几个例子可能是:
# in module a.py
from ..anotherpackage import b
from ..anotherpackage.b import another_function# in module b
from . import c
from .c import my_function
我个人不赞成使用相对进口，因为它们不如绝对进口可读性强，PEP-8 也是这样建议的。在一些罕见的情况下，您可能必须使用相对导入来避免不必要的长路径。例如，
from package_a.sub_b.sub_c.sub_d.module_d import my_function
如何修复 ModuleNotFoundError 和 ImportError？
现在，我们已经了解了基本导入语句的执行方式以及绝对导入和相对导入之间的区别，我们现在可以继续讨论当您的 Python 应用程序在使用ModuleNotFoundError 或ImportError失败时该怎么办。
在大多数情况下，这两种错误都是由于 Python 无法解析sys.path中的模块名而导致的。回想一下，当您调用import a时，如果模块的名称既没有在sys.modules中找到，也没有在标准库中找到，Python 将尝试在sys.path中解析它。同样，当您使用from语法(例如from mypackage import a)时，Python 将首先尝试查找并加载模块。当它失败时，Python 会在第一种情况下抛出ModuleNotFoundError，在第二种情况下抛出ImportError。
如果是这样的话，回想一下我们下面的例子，
└── myproject
├── mypackage
│ ├── a.py
└── anotherpackage
├── b.py
├── c.py
└── mysubpackage
└── d.py
- 首先确保你使用的是绝对导入
- 将项目的根目录导出到
大多数现代 Python IDEs 会自动完成这一任务，但如果不是这样，我很肯定会有这样的选项，您可以为您的 Python 应用程序(至少是 PyCharm)定义PYTHONPATH。
如果您在任何其他环境中运行 Python 应用程序，比如 Docker、vagger 或者在您的虚拟环境中，您可以在 bash 中运行以下命令:
export PYTHONPATH="${PYTHONPATH}:/path/to/your/project/"# * For Windows
set PYTHONPATH=%PYTHONPATH%;C:\path\to\your\project\
现在既然你的项目的根目录已经被附加到了PYTHONPATH中，你的绝对导入应该会非常有效。
或许我也能做到，但这绝对不是一次好的练习。
结论
如果您是 Python 的新手，导入模块可能会成为一场噩梦，尤其是当您需要处理复杂的项目结构时。如果您遵循两步规则——即使用绝对导入并将项目的根目录附加到 PYTHONPATH 中——那么您就不应该担心将来的模块导入。
如果你是 Python 新手，我强烈推荐你在亚马逊上买一本 学习 Python 的书。
成为会员 阅读介质上的每一个故事。你的会员费直接支持我和你看的其他作家。你也可以在媒体上看到所有的故事。
[## 通过我的推荐链接加入 Medium-Giorgos Myrianthous
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
gmyrianthous.medium.com](https://gmyrianthous.medium.com/membership)
免责声明:本文包括附属链接
如何为机器学习修复断裂的价值链
尽管数据科学家的平台取得了良好进展，但商业用户仍难以消费他们的机器学习模型。
欢迎光临！下面是您可以从这篇文章中期待的内容:
- 如果你是一名数据科学家，你会更好地理解为什么你的机器学习(ML)模型可能不被操作采用的一个原因
- 如果你站在商业的角度，你会更清楚为什么你可能难以消费和利用 ML 模型
- 如果你想投资机器学习和业务自动化平台，你会发现一个被忽视的集成点
机器学习的工具、库和平台在过去 10 年里取得了惊人的进步，也许令人惊讶的是，几乎完全是由开源工具和开放标准驱动的。在商业战略方面，机器学习价值链的前半部分是高度模块化的(见下图)。这里没有苹果或星巴克——没有垂直整合的玩家将几个步骤融合在一起作为专有解决方案的一部分。
这种模块化意味着在 ML 价值链的每一步(从数据到库再到部署)，很有可能自由选择前一步的组件。是的，有些库是针对 Python 的，有些在 Spark 中工作得最好，但是很大程度上可以根据手头问题的需要混合搭配 ML 库、管道、工具和平台。
在机器学习价值链中，从数据科学到商业的移交是模块化未能为商业用户提供足够简单性的一步。
就专有平台而言(无论是来自亚马逊、IBM、谷歌还是微软)，它们倾向于将各种语言(例如 Python、R)、工具(例如笔记本、ide)和库(例如 scikit-learn、TensorFlow)打包为开源，并支持这些作为平台的一部分。
至关重要的是，这些供应商平台旨在扩展到模型部署、模型监控和模型服务，通常运行在 Kubernetes 上，并将 ML 模型作为 REST 端点公开。这部分链有时被称为“ML Ops”，类似于 DevOps 为软件开发和 IT 团队提供的东西。
因此，当 REST 端点可用时，大多数数据科学家、ML 工程师和 ML Ops 平台认为他们的任务已经完成。
然而，当业务和 IT 想要使用这些部署的 ML 模型，使它们成为业务操作的一部分时，这会导致在后续步骤中出现问题。
这些问题通常包括:
- 模型发现:有哪些 ML 模型可用，它们预测/分类什么，哪一个适合特定的业务需求？
- 模型连接:我如何调用一个 ML 模型，向它提供数据并处理输出(和异常)？
- 模型管理:有没有新的 ML 模型版本，有什么不同，我应该什么时候升级？
为了满足这些需求，关于可用的 ML 模型、它们的目的和状态，需要相当多的透明度。当前使用的方法(开放的基于 REST 的 API)技术性太强，没有携带足够的关于 ML 模型的元数据来满足业务消费者的需求。
这里所需要的实际上是 ML 服务和 ML 消费步骤之间更紧密的集成，即确保业务自动化平台对 ML 服务平台具有可见性，能够发现和反思可用的模型。您可以将此视为供应链中的合作伙伴协作，其中供应商向买方提供库存的可见性。
或者，业务自动化平台可以接管 ML 服务的任务，在操作上托管 ML 模型。在这个模型中，ML 模型的消费本质上是通过导入模型来完成的，而不是通过 REST 端点来引用和调用它们。虽然这在技术上可能是可行的，但它对谁来管理 ML 模型有影响，潜在地将 ML 工件的管理从 ML 工程师那里移走。
不管怎样，ML 和自动化平台之间的鸿沟需要被弥合。目前的情况是广泛采用机器学习的主要障碍。
我们从中得到了什么，哪些行动被认为是短期的？
- 如果你是数据科学家或 ML Ops 工程师，计划与那些使用你的模型的人密切合作。如果使用 REST APIs 的“黑盒”式集成是您采用的方法，那么您的业务同事将需要您的信息和支持，以了解您正在提供什么模型以及如何使用它们。
- 如果您所在的组织寻求在业务运营中利用机器学习，请寻找与数据科学家使用的机器学习平台紧密集成的业务自动化平台。评估它提供可发现性、模型消费和模型管理的能力。
最后，如果你是机器学习和业务自动化领域的软件开发人员或供应商，这里可能会有机会脱颖而出。想想克莱顿·M·克里斯坦森的诱人利润守恒定律(见他的书 【创新者的解决方案 ):
“当 诱人的利润 因为产品商品化而在价值链的某一阶段消失时，用专有产品赚取 诱人利润 的机会通常会在相邻阶段出现”
由于机器学习市场如此分散和模块化(接近商品化)，诱人的利润可能会提供给那些密切整合 ML 服务和 ML 消费的人，为商业用户利用机器学习提供了一种简单的体验。
注意:如果你喜欢这篇文章，你可能还想看看它的姊妹篇— “解决机器学习的‘最后一英里问题’以进行运营决策”。
格雷格在 IBM 工作，常驻法国。以上文章为个人观点，不代表 IBM 的立场、策略或观点。
如何解决您的数据质量问题
介绍一种更好的方法来防止坏数据。
巴尔·摩西授权下的图片。
数据质量是每一个数据专业人员最关心的问题，这是有充分理由的。 坏数据 耗费公司宝贵的时间、资源，最重要的是，收益 。那么，为什么我们中的许多人都在努力信任我们的数据呢？没有更好的办法吗？
数据环境在不断发展，每时每刻都在为更丰富的洞察力创造新的机会。新旧数据源混合在同一个数据湖和数据仓库中，有供应商可以满足您的每一种需求，从帮助您构建更好的数据目录到生成令人垂涎的可视化效果(让 NYT 来让抵押贷款看起来更性感)。
毫不奇怪，客户问我的最常见的问题之一是“您推荐什么数据工具？
更多的数据意味着更深入地了解您的业务。与此同时，更多的数据增加了出错和不确定性的风险。难怪数据领导者争先恐后地购买解决方案并建立团队，既支持更明智的决策，又管理数据固有的复杂性。
但是我认为我们应该问自己一个稍微不同的问题。相反，请考虑: “我们的组织需要什么来充分利用和信任我们的数据？”
数据质量并不总能解决坏数据
用不可信的数据做决策是一种可怕的前景，然而，即使是最有能力、最有经验的数据团队也是如此。许多团队首先将数据质量视为数据健康和可靠性的轶事。我们喜欢说“垃圾进来，垃圾出去”这是一个真实的陈述——但是在今天的世界里，这就足够了吗？
企业花费时间、金钱和资源购买解决方案并建立团队来管理所有这些基础设施，梦想有一天成为一台运转良好的数据驱动机器——但从摄取到洞察，数据问题可能发生在管道的任何阶段。简单的行数、特别的脚本，甚至摄取时的标准数据质量约定都不能满足要求。
我在一家大型运输公司采访的一位数据主管告诉我，平均而言，他的 45 名工程师和分析师团队每周花费 140 个小时 来手动检查管道中的数据问题。即使你有一个 10 人的数据团队，那也是整整五天的时间，可以用来开展创收活动。
数据质量问题可能发生在管道中的任何地方，导致错误决策、资源浪费和沉没成本。虽然对于识别这类问题很有用，但是数据质量本身只能帮你做到这一步。(图片由 蒙特卡洛 提供)。
无论有多少花哨的工具、训练有素的工程师和管理层的支持，都无法防止坏数据破坏您的管道。虽然组织在构建良好的基础设施方面投入了大量资金，但他们经常发现自己在系统整体的完整性方面不知所措，或者说:数据宕机。
数据宕机 ，换句话说，数据丢失、出错或以其他方式受损的时刻，既是数据生态系统最大的痛点，也是全面了解数据质量的关键。数据宕机会导致时间浪费、决策失误，而且最重要的可能是损失收入和客户信任。
如果不跟踪数据停机时间，工具再先进也没用。(为了帮助我的客户解决这个问题，我创建了一个简单的 KPI来衡量数据停机时间，作为更好地了解数据可靠性的函数。)
虽然直觉决策有时是有用的，但我坚信使用坏的或不完整的数据比没有数据更糟糕。
数据可观察性是数据质量 2.0
有很多解决方案将自己推销为一个魔术箱，毫不费力地消耗原始数据来吐出可操作的见解，但在我看来，“数据”和“魔术”是永远不应该出现在同一个句子中的两个术语(好吧，也许只是在某些情况下……)。相反，重要的是将数据视为应该频繁跟踪和监控的东西，作为数据管理“控制台”方法的一部分。
为了释放数据的真正价值，我们需要超越数据质量。我们需要确保我们的数据无论在哪里都是可靠和值得信赖的。实现这一目标的唯一途径是创造可观察性——从源头到消费的整个过程。 数据可观察性 ，组织完全了解其系统中数据健康状况的能力，通过将 DevOps 的最佳实践应用于数据管道，消除了这种神奇的感觉。
是的，数据可能因为一百万种不同的原因而变得“糟糕”。但是根据我的经验，通过关注数据可观察性的五大支柱——新鲜度、容量、模式、分布和沿袭——你不仅可以主动发现数据中的问题，而且实际上可以从一开始就防止它们发生。(查看我最近关于数据可观察性的文章,了解一些可行的策略，以及对这 5 个支柱的更全面的解释。)
数据可观察性可能不会告诉你下一步应该购买哪种新奇的数据工具，但它可以让你避免对数据做出糟糕的(可能代价高昂的)决策。
得到了坏数据？ 加入我们的候补名单 获得帮助。
如何骗过一个神经网络？
通过一些对抗性的输入，神经网络很容易被欺骗
使用 Canva 设计
想象一下，你在 2050 年，你正坐在自动驾驶汽车去上班的路上(很可能)。突然，你意识到你的车在穿过十字路口后以 100 公里的时速行驶在繁忙的道路上，但你不知道为什么。
纯粹的恐怖！
会发生什么事？
嗯，可能有很多原因。但是在这篇文章中，我们将关注一个特殊的原因——汽车被骗了。
准确地说，在十字路口看到招牌的神经网络被欺骗，认为停止标志是 100 公里/小时的标志，并导致其瞬时加速。
这可能吗？
是的，它是。但是在深入了解之前，我们先来了解一下一个神经网络经过训练后看到了什么。据信，网络中的每个独立神经元的工作方式都与我们的生物神经元类似，我们假设神经网络在观看图像时的思维方式与我们的大脑相同。实际上，情况并非如此。我们来看一个例子。
猜猜下图是什么。
你猜对了。这是一座寺庙，神经网络以 97%的置信度预测它是一座寺庙。
现在，猜猜这个图像是什么。
又是寺庙？
他们看起来一模一样，但事实并非如此。上面的图像被预测为一只鸵鸟，有 98%的可信度，与我们之前使用的模型相同。网络现在被这个形象忽悠了。但是怎么做呢？
第二张图像不是来自真实世界的相机，而是手工设计的，专门用来欺骗神经网络分类器，同时与我们的视觉系统相同。
这个吵闹的家伙要对模型的错误分类负责。将该噪声添加到第一图像中导致了修改的第二图像，这被称为对抗示例。增加的外部噪声称为扰动。
同样，汽车可能以这种方式将停车标志与 100 公里/小时标志错误分类。
使用 Canva 设计
让我告诉你，除了上面的自动驾驶汽车案例，为什么这对许多现实世界的机器学习应用程序来说是一个非常重大的威胁。
- 也有可能创建一副 3D 打印眼镜，但当你戴上它们时，你突然无法被任何现有的面部识别软件识别。
- 此外，打印一个定制的车牌，看起来完全正常，但会被任何现有的交通监控摄像头误注册。
这样，神经网络容易受到大量不同的攻击。有白盒攻击，黑盒攻击，物理攻击，数字攻击，可感知和不可感知的攻击等等。在任何真实环境下工作时，网络必须能够抵御所有此类攻击。
这是如何工作的？
安德烈·卡帕西写了一个非常有趣的博客，你可以在这里阅读。这里有一个小的先睹为快。
那么，在传统的培训过程中，我们该怎么做呢？我们得到损失函数，我们反向传播，计算梯度，采用这个梯度并使用它来执行参数更新，它在正确的方向上稍微摆动模型中的每个参数，以增加预测分数。这些参数更新负责增加输入图像的正确类别的置信度得分。
注意这是如何工作的。我们保持输入图像不变，并调整模型参数以增加我们想要的任何类别的分数。反过来说，我们可以很容易地翻转这个过程来创造出愚蠢的图像。也就是说，我们将保持模型参数不变，取而代之的是，我们将计算输入图像中所有像素在我们希望的任何类上的梯度。例如，我们可以问一个问题—
当我调整图像的像素时,(你想要的任何类)的分数会怎样？
使用 Canva 设计
我们像以前一样用反向传播计算梯度，然后我们可以执行图像更新而不是参数更新，最终结果是我们增加我们想要的任何类的分数。例如，我们可以拍摄一张熊猫图像，并根据该图像在猫类上的渐变来调整每个像素。这会稍微改变图像，但是猫的分数现在会增加。有点不直观的是，事实证明你不需要过多地改变图像就可以将图像从被正确分类为熊猫切换到被分类为任何其他种类(例如猫)。
现在你已经对这是如何工作的有了一个基本的概念，有一个你应该知道的流行技术叫做快速梯度符号方法，用于产生对立的例子，这是由 Ian J. Goodfellow 在解释和利用对立的例子中讨论的。
快速梯度符号法
在这种方法中，您获取一个输入图像，并使用损失函数相对于输入图像的梯度来创建一个新图像，使现有损失最大化。通过这种方式，我们获得了视觉系统几乎察觉不到变化的图像，但是同一个神经网络可以看到显著的差异。这个新形象被称为敌对形象。这可以用下面的表达式来概括:
adv_x = x + ϵ * sign(∇x * J(θ,x,y))
在哪里
- adv_x:对抗性的形象。
- x:原始输入图像。
- y:原始输入标签。
- 确保扰动较小的ϵ:乘数。
- θ:模型参数。
- j:损失。
你可以通过在这个笔记本中为图像生成你自己的对立例子来试验这种方法。在这里，您将找到一个在 MNIST 数据集上训练的模型，您可以看到调整ϵ(ε)参数时置信度得分如何变化。
Colab 的结果
对于任何 x → y，x 表示实际类，y 表示预测类。
正如你所看到的，如果你增加ε值，扰动会变得更加明显，我们的视觉系统会有明显的变化。然而，我们的神经系统足够强大，可以预测正确的类别。
该方法通过找出给定输入图像中的每个像素对损失值的贡献来实现这一点，并相应地添加扰动。
不仅是快速梯度符号方法，我们还有其他一些流行的方法，称为对抗性补丁方法，单像素攻击方法，通过对抗性扰动创建 3D 模型，等等。让我们来看看其中的一些。
对抗性补丁
谷歌在 2018 年提出了一个独特的想法，以下列方式在图像框中放置一个对抗性的补丁。
这张纸展示了如何向模特展示任何图像，它将给定的图像归类为烤面包机。这个补丁被设计成这样一种方式，它可以欺骗任何负责分类的底层神经网络，让它认为是一个烤面包机，不管你给它什么图像。你只需要把这个标签贴在物品旁边。它工作得很好，足以欺骗不够健壮的模型。
打印受到不利干扰的 3D 模型
不仅仅是图像，你还可以创建一个专门设计的 3D 模型，在任何角度愚弄模型。
既然我们已经看到了这些对立的例子是如何欺骗神经网络的，那么同样的例子也可以用来训练神经网络，使模型免受攻击。这也可以作为一个良好的正则化。
从上图可以明显看出，在用对立的例子进行训练后，模型现在不太容易被愚弄了。
现在是最后一个问题。
我们人类自己有对立的例子吗？
我认为答案是肯定的！例如，如果你看一些像这样的视错觉，
你会注意到这些线起初看起来并不平行。但是当仔细观察时，这些线是相互平行。
是的，这些正是对立的例子。它们是我们看到不该看到的东西的图像。因此，我们可以看到，我们的人类视觉系统也可能被某些例子愚弄，但很明显，我们对愚弄我们的神经网络的对抗性例子非常敏感。
结论
这些对立的例子不仅仅局限于图像。从简单的感知器到自然语言处理模型的任何模型都容易受到这种攻击。但是这些可以通过一些策略在一定程度上得到控制，例如被动和主动策略，这些将在我接下来的文章中详细讨论。
从好的方面来看，我认为这些对立的例子暗示了一些非常有趣的新研究方向，我们可以用它们来改进现有的模型。我希望你今天能学到一些新东西！
如果你想联系我，请在 LinkedIn 上联系我。
参考
- https://arxiv.org/pdf/1802.08195.pdf
- https://pytorch.org/tutorials/beginner/fgsm_tutorial.html
- https://www . tensor flow . org/tutorials/generative/adversarial _ fgsm
如何在 Python3 中格式化日期
strftime、format 和 f 字符串的比较
照片由 Surene Palvie 发自 Pexels
您可能以前使用过 Python 的格式化语法。但是你如何格式化日期呢？使用 datetime 对象，可以用%Y、%m、%d分别以数字形式显示对象的年、月、日(即三月会被数字“03”代替)。
Python 有几种格式化字符串的语法。这样每条线路都会产生相同的输出。
输出:
2020 年 08 月 04 日
These lines produce the standard for Japanese dates. 年 means year, 月 means month, 日 means day.
让我们看看每个语法。
使用strftime
strftime是一个可以追溯到 python 早期的函数。它的名字相当神秘，但尽管如此，它最常用于我们所期望的日期格式化:一种工作就是格式化事物的方法。
它做得很好。但是语法可能有些笨拙。strftime不是最容易打字的单词。此外，如果我们需要在同一个字符串中格式化几个日期呢？
不过注意.strptime的存在，它是.strftime的逆变换。在英语中，这些名称可以翻译成“字符串解析时间”和“字符串格式化时间”。
使用.format方法
.format是str类的一个方法，用来格式化一个包含格式化语法的字符串。我们称之为的替代领域以荣誉{}为标志。它用于标记传递给该方法的参数将被插入的位置。奖项内的数字{1}用于选择参数。注意它从 0 开始，所以第一个传递的参数将被插入{0}。这里有一个例子来总结:
"The {0} parameter. The {2} parameter. The {1} parameter.".format("first", "second", "third")
请注意，您可以根据需要订购或复制替换字段{}的使用。您也可以插入命名参数
"Cut the {first}. Wash the {second}. Prepare the {third}.".format(first="onions", second="carrots", third="salad")
对于日期时间对象，我们有额外的格式。例如,{0:%Y}将在第一个位置参数中插入日期的年份，这应该是一个日期时间对象。因此，您可以看到为什么这两行会产生相同的输出。
"{:%Y 年%m 月%d 日}".format(datetime.today())
"{0:%Y}{1}{0:%m}{2}{0:%d}{3}".format(datetime.today(), "年", "月", "日")
第一个将所有内容放在替换字段{}中，而第二个将它分成几个插入的参数。看情况选择哪个会更有可读性。
f 弦f""
由于最近在 python3.6 中引入，f-String 或 String interpolation 是一种强大而简洁的字符串格式化方法，这种方法鲜为人知。使用f""语法，您可以直接将变量名与格式语法放在一起。比如说。
age = 25
print(f"So you are {age} years-old?")
我们甚至可以在里面写函数调用！现在，您应该明白我们是如何获得与之前相同的输出的:
f"{datetime.today():%Y 年%m 月%d 日}"
结论
尽管.strftime仍然被广泛使用，但在我看来，它的可读性较差，因为其他语法更接近我们所期望的 pythonic 代码。这背后的主要原因是格式化操作是在str对象上有效执行的，而不是在 datetime 对象上。所以我会推荐你更喜欢.format和f""，它们更简洁。f 字符串也可以用于调试。例如,print(f"{a=}")将打印出a=,后跟a的实际值。查看文档了解更多。
原载于 2020 年 8 月 4 日https://adamoudad . github . io。
如何为有意义的数据分析制定好的研究问题
了解如何从数据中获得好的见解
来源:TAHA·AJMI
如今，数据无处不在。有许多不同大小和形状的数据。如果没有人分析这些数据，它们就没有任何意义。所以，数据科学家和数据分析师有很多事情要做。但是，如果我们不知道从数据中推断出什么信息，分析就不会有效。无论数据来源多么真实，花费多少金钱和时间来取样或收集数据，如果研究问题没有得到很好的阐述，这些都是无用的，甚至是有害的。我说有害是因为如果我们对一个非常敏感的数据集做出错误的解释，那会导致在一个重要的问题上做出错误的决定。因此，对于数据科学家来说，学会如何提出精心设计的研究问题至关重要。
在这篇文章中，我想解释一些在设计研究问题时需要考虑的关键因素。
感兴趣的目标人群
在研究问题中，必须对感兴趣的目标人群进行清晰而简明的描述。一个很好的例子是芝加哥地区家庭收入超过 100，000 美元或更多的西班牙裔人口。或者，具有大学或更高教育水平的非裔美国女性。
描述性或分析性问题
知道要执行哪种计算很重要。这里，描述性是指是否有具体的参数需要计算，如平均年龄、总收入或最高身高。另一方面，解析意味着更抽象的参数。可以是收入水平和学历的关系。所以，没有直接计算统计参数。相反，分析不同的参数并从中得出结论。
问题是原创的吗
问题是原创吗？它是否增加了一个新的知识领域，或者为任何现有领域增加了更多，或者提供了一个关于旧研究的不同视角？许多研究旨在建立在一些现有研究的基础上或增加现有的知识。但这需要在研究陈述或研究问题中明确。
数据已经有了吗
我们需要确保变量随时可用，或者资源和工具可用于收集适当的数据。必须对数据进行仔细的研究，这样数据才能抓住研究的核心思想。
这是一个好的研究问题的四个基本组成部分。如果没有一套经过深思熟虑的问题，数据分析可能毫无意义，或者带来糟糕和误导性的见解。
糟糕的问题
"收入和健康质量之间有什么关系？"
让我们从四个关键部分来分析这个问题。首先，它是否准确描述了目标人群？事实并非如此。因此，研究领域变得过于宽泛，可能会导致模糊的分析结果。第二，它是否提到分析是描述性的还是分析性的？是的，确实如此。这是一个分析性的问题。这个问题是要找出收入和健康质量之间的关系。第三，问题是否原创？我想不会。但要看是哪部分人群。第四，数据是否已经可供分析？那要看哪个部分，哪个地区，哪个年龄段的人口。
精心设计的问题
“考虑到年龄在 50 岁以上，纽约市患糖尿病的美国白人和非裔美国人的百分比有多大差异？”
现在，我们来分析一下它是否涵盖了所有的关键组件。首先，它清楚地描述了研究的目标人群。第二，问题是描述性的。我们需要计算美国白人和非裔美国人患糖尿病的百分比。第三，问题可能不是原创。但是它会在现有知识的基础上增加新的知识。这可能会给去年的数据与今年的数据进行比较提供空间。第四，数据可能已经存在，但仍有更新信息的余地。最重要的是，这个问题有一个明确的目标。
作为一名数据科学家，你可能知道世界上所有的工具。但是，如果不知道如何正确地从数据中推断出见解，学习数据科学是不完整的。
如何生成访问 API 端点的数据，甚至无需编码
实践教程
Python 库——sandman 2 简介
作为任何 Web 或移动应用最常见的架构，数据库+后端 API +前端是非常典型和经典的。虽然不同的应用程序肯定会有自己的前端设计，但后端 API 通常非常相似。也就是说，他们必须能够访问数据库中的数据。换句话说，后端 API 的主要职责是充当中间件，接收来自前端的请求并根据请求检索数据库，然后将结果返回给前端，以便用户可以使用。
当然，对于大多数应用程序，后端 API 也需要一定程度的定制，尤其是安全需求，如 JWT 等。然而，当没有太多安全问题时，有一种方法可以“生成”您的后端 API，它甚至不需要编码就可以访问您的数据库。
在本文中，我将介绍一个 Python 库可以帮你做到这一点。假设你是一个前端开发人员，你只想在你的测试环境中测试一些前端特性，不想浪费太多时间去写自己的后端 API。在这种情况下，Python 库 sandman2 是最好的选择之一！
样本数据库的准备
照片由 manniguttenberger 在 Pixabay 上拍摄
sandman2 库支持许多数据库管理系统，例如:
- SQLite
- 关系型数据库
- 一种数据库系统
- 神谕
- MS SQL Server
- 赛贝斯
- 下毛毛雨
- 火鸟
sandman2 库支持它们作为不同的 SQL“方言”，这意味着我们不需要担心我们正在使用哪个数据库，只需告诉 sandman2 是哪个数据库，它就可以开箱即用。
在本文中，我将使用 SQLite 作为例子，因为它是最简单的，我不需要下载、安装和配置任何东西。
在我以前的一篇文章中，我介绍了一个 Python 内置库 sqlite3，它可以非常容易地生成 sqlite 数据库。我将跳过 Python 中 SQLite 库的介绍。你可以看看我下面的文章了解详情。
Python 内置库 sqlite3 简介
towardsdatascience.com](/do-you-know-python-has-a-built-in-database-d553989c87bd)
让我们创建一个名为“我的测试”的数据库。
import sqlite3 as slcon = sl.connect('sandman2/my-test.db')
然后，出于演示目的，创建一个名为USER的表。
with con:
con.execute("""
CREATE TABLE USER (
id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
name TEXT,
age INTEGER
);
""")
之后，让我们插入一些示例行。
sql = 'INSERT INTO USER (id, name, age) values(?, ?, ?)'
data = [
(1, 'Alice', 21),
(2, 'Bob', 22),
(3, 'Chris', 23)
]with con:
con.executemany(sql, data)
好的。现在，我们可以查询该表。
with con:
data = con.execute("SELECT * FROM USER")
for row in data:
print(row)# Output:
# (1, 'Alice', 21)
# (2, 'Bob', 22)
# (3, 'Chris', 23)
我们现在已经有了一个填充了表的数据库。让我们在下一节开始演示 sandman2 库。
基于 Web 的 SQL 客户端
在一切之前，我们需要安装 sandman2 库。只用pip。
pip install sandman2
然后，正如我在标题中所说的，我们不需要编写任何代码，只需要使用命令行界面。
$ sandman2ctl sqlite+pysqlite:///sandman2/my-test.db
下图显示了连接字符串的构造方式。
请注意，DB 驱动程序是可选的。如果我们保持它为空，SQLAlchemy (sandman2 构建在 SQLAlchemy 之上)将尝试使用默认驱动程序。但是，如果驱动程序不存在，它可能会抱怨。别担心，我们可以得到默认驱动库的名称，这样我们就可以使用pip来安装它。
运行该命令后，web 服务启动。
让我们尝试使用任何浏览器访问管理控制台的 web 客户端。
[http://localhost:5000/admin/](http://localhost:5000/admin/)
我们可以看到页面上已经有一个对象USER。这是因为我们创建了这个表。如果我们点击USER，我们可以看到我们之前插入的三行显示在数据表中。
在此页面上，我们可以单击“创建”按钮来插入新行、更新现有行或批量删除行。您将能够很容易地找到这些特性，所以让我跳过这些内容，在下一节中向您展示最重要的特性。
数据访问 RESTful API
sandman2 最酷的功能一定是我们已经连接的数据库自动生成的 RESTful API 端点。
在上面的部分中，保持 web 服务运行，那么 API 已经在那里供我们使用。您可能更喜欢 Postman 或失眠症等 API 测试工具，但在本文中，我将只使用“curl”命令来保持简单，因此如果您只想测试 API 端点，您不必下载任何东西。
1.获取表格中的数据条目列表
还记得我们有一张桌子叫USER吗？现在，我们可以简单地向下面的 URL 发送 GET 请求来获取条目列表。
http://localhost:5000/user/
请注意
- 大多数 DBMS 如 SQLite 和 MySQL 不区分大小写，所以我们可以安全地使用小写的表名。
- URL 末尾的正斜杠
/一定不能错过。
然后，让我们使用curl测试 GET API。
curl [http://localhost:5000/user/](http://localhost:5000/user/)
它返回表中的所有记录。但是，如果我们在一个表中有太多的条目，并且想要进行分页，该怎么办呢？是的，睡魔 2 支持开箱即用！
curl "[http://localhost:5000/user/?page=1&limit=2](http://localhost:5000/user/?page=1&limit=2)"
curl "[http://localhost:5000/user/?page=2&limit=2](http://localhost:5000/user/?page=2&limit=2)"
在这个例子中，我们使用page参数来指定页码，使用limit参数来指定页面大小。在第 1 页中，我们得到了前两个用户 Alice 和 Bob。然后，在第 2 页，我们得到了 Chris 的第三行，由于没有其他行，所以只返回了 1 行。
2.按键获取行
既然我们定义了主键，我们也可以通过它来查询表。
curl [http://localhost:5000/user/](http://localhost:5000/user/)3
3.按任意字段筛选行
我们也可以按任何字段过滤行。
curl "http://localhost:5000/user/?name=Chris"
目前，有一个限制，即不支持对比较>, <, >=, <=进行过滤。
4.插入新行
要插入新行，我们需要使用 POST 方法。
curl -X POST -d "{\"age\":24, \"name\":\"David\"}" -H "Content-Type: application/json" http://localhost:5000/user/
请注意，我使用的是 Windows，所以单引号在 cmd 中不起作用，我必须使用反斜线来转义双引号。如果你使用 Linux 或 Mac OS，你可能不需要这些。
此外，当我们创建USER表时，我们已经将“id”字段设置为自动递增，所以我们不需要传入“id”值。
我们无法使用基于 Web 的 SQL 客户端来查看该表。新用户 David 已成功插入。
5.更新行
我们可以使用 PATCH 方法来更新一行。
curl -X PATCH -d "{\"age\":30}" -H "Content-Type: application/json" http://localhost:5000/user/3
如示例所示，在 URL 中传递当前主键“id”很重要，在我们的示例中是“3”。Sandman2 依靠主键找到要更新的记录。
如果我们回到网络客户端，可以看到克里斯的年龄已经更新。
6.删除一行
我们可以使用 DELETE 方法删除一行。
curl -X DELETE -H "Content-Type: application/json" http://localhost:5000/user/3
运行上面的 CURL 命令后，id=3 的用户被删除了。
7.表的定义
sandman2 库不仅支持一般的数据访问 API，还支持其他一些高级 API，比如获取表的元数据。
curl http://localhost:5000/user/meta
8.将表格导出到 CSV 文件
最后，它还支持将数据导出到 CSV 文件。
curl -o user.csv "http://localhost:5000/user/?export"
摘要
在本文中，我介绍了一个令人惊叹的 Python 库，名为 sandman2。它是用 Python 写的，但是你不需要写任何 Python 代码来使用它。只需用有效的数据库连接字符串运行它，您将获得
- 基于 Web 的 SQL 客户端
- 一整套访问 RESTful API 的数据
原来《睡魔 2》并没有太多的安全实现，所以请千万不要在生产中使用。然而，安全问题通常意味着定制实现，这几乎不可能在开箱即用的工具集中通用。因此，sandmand2 是一个优秀的库，可以节省我们大量的测试和实验时间。
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@qiuyujx/membership)
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)
如何产生数据科学项目想法
你可以从 3 个实用的方法开始
我应该展示什么样的项目才能在面试中脱颖而出？
在面试中，展示一个伟大的项目是很重要的。虽然这可能不是在面试中成功的最重要的因素，但它绝对是在其他候选人中脱颖而出的加分项。
然而，在进入如何为你的项目找到一些好主意的细节之前，我会告诉你为什么这在你的面试中很重要。
假设您是竞争数据科学家职位的候选人之一。你可能会担心面试中要问的技术或机器学习知识问题。因此，你花了很多精力去修改你的课堂笔记，或者不断地用谷歌搜索来回答突然出现在你脑海中的任何疑问。你在步入面试室之前，努力把所有的知识都吞下去，这样你会感觉更自信。
面试的时候，面试官用一大堆刁钻的问题轰炸你，你开始冒汗。你变得越来越焦虑，因此，大多数面试问题你只是试图猜测。最终，在你的脑海中，你会想，哦，我的天哪！我这次面试会失败的。因此，你正在努力思考在面试结束前应该问什么问题，这样你才能给面试官留下一个好印象。
现在，如果我告诉你，有一种方法可以减少面试官问的问题，这样你就有更大的机会通过面试。你会感兴趣吗？
不要让面试官一直问你一些你无法控制的问题，你可以让他问你一些你已经准备好的问题。你可能会问，我该怎么做呢？
你至少需要一个定义明确的项目，不是学校的项目，至少是能引起讨论的有趣项目。因此，你只需要准备好面试时他们可能会问你的所有问题。如果你足够聪明，你可以有意省去一些项目的关键点，让他们来问你。
如果你的项目足够有趣，并且你准备充分，讨论的大部分时间将会被与你的项目相关的问题占据。现在，让我们从引用开始。
所有的想法都源于其他的想法——安尼施·卡普尔
关于解决什么问题的想法其实并不难找到。有时候，你可能没有注意到你在生活中面临的一些问题，或者一些你很想知道的问题。这些问题已经被认为是很好的想法或问题。
在这篇文章中，我将展示一些方法，在这些方法中你可以找到一些有趣的问题来解决。
1.过去的项目
如果你要为一家金融科技公司面试，并且你做过一个与欺诈相关的项目。答对了。你可以只展示这个项目，但一定要确保有一些你认为对公司有价值的方面。
但是，如果你认为你所做的特定项目不够好，或者你对哪些方面需要改进有一些想法，请这样做！这是因为这可能是你大放异彩的机会。
例如，对于您现有的欺诈项目，您只需使用互联网上的一些常用功能，并将其应用到您的模型中。但现在，你有一种感觉，如果这个人在平台上有一张个人资料图片，他或她进行欺诈的机会就会更小，一定要尝试一下！虽然大多数时候这可能不是一个很好的特点，但只要向面试官展示你确实有一些打破常规的思维技巧，他们就会有兴趣了解你是如何做到的！
这是因为特征工程就像是实验和拥有领域知识的结合。因此，如果你认为这个特性有意义，那就试试吧！
2.互联网上已有的想法
如果你没有读过我在 Airbnb 上的文章，这篇文章也刊登在《亚洲科技》上，请点击这个链接。
这是我如何从网上想到这个主意的。有一个叫做的网站。我发现在互联网上可以找到的关于 Airbnb 的大多数项目都在使用这个网站的数据集。有趣的是，马来西亚的数据集没有出现在那里。
因此，如果我自己从 Airbnb 收集数据，并进行分析，这将是一个很好的主意。我不仅能够展示我能够独自完成整个流程(从收集数据、分析和建模)，而且能够提供价值。
我发现的差距是缺乏马来西亚的数据集和我能够提供的价值。这里我指的价值是为 Airbnb 的投资者提供一种方式，让他们可以找到应该投资的领域。
简而言之，如果你能够找出你正在解决的问题中的差距，这肯定会让你的解决方案看起来更有趣。
3.现实生活中的问题
这个问题可能你甚至你的朋友都面临。我在我的 Airbnb 文章中提供的额外价值，其实就是我朋友面临的问题。他问我是否有办法解决这个问题，我接受了挑战。
此外，你可以解决你的一些疑惑。例如，您有兴趣知道哪家公司在马来西亚的汽车市场拥有最大的市场，以及每家公司明年的销售额是多少。遵循我在上一篇文章中提到的三个步骤，识别并阐明问题，然后进行分析和建模。
不仅如此，我们非常欢迎你解决你目前面临的问题。如果你正在解决你所面临的问题，你会对问题本身有更深刻的理解。因此，您将更容易得出一些对您的模型有用的特性。
最后的想法
创意是廉价的。想法很容易。想法是共同的。每个人都有想法。想法被高度高估了。执行才是最重要的。— 凯西·奈斯塔特
想法是廉价的，执行才是最重要的。非常感谢你读到最后，下周见！
关于作者
Low 魏宏是 Shopee 的数据科学家。他的经验更多地涉及抓取网站，创建数据管道，以及实施机器学习模型来解决业务问题。
他提供爬行服务，可以为你提供你需要的准确和干净的数据。你可以访问这个网站查看他的作品集，也可以联系他获取抓取服务。
如何用 Python 生成 MS Word 表格
30 秒内自动生成报告
在讨论自动化的时候，Python 是经常被提到的。与其他编程语言相比，易于使用的语法、大量的库和面向脚本的语言结构使 Python 在自动化方面更胜一筹。
小型和大型公司每天都使用 Word 和 Excel 等 Microsoft Office 工具生成报告。在本文中，我将提供关于通过 Python 在 MS Word 中生成数据表的端到端解释。
我将考虑一个场景，其中我们有许多新闻文章，我们需要生成一个 Word 文档，其中包含从这些文章中提取的统计数据。这些统计数据包括:字数，句子数和平均单词长度。
属国
对于这个例子，我使用了 Python 3.7 。您需要安装的唯一依赖项是 python-docx 。您可以通过在您机器的终端中提交以下命令来安装这个依赖项。
pip install python-docx
从文章中提取统计数据
对于这个例子，我从 CNN 中随机选取了两篇体育文章。为了提取统计数据，我编写了下面的describe_text(text)函数。这个函数接受一个字符串参数(文章、评论等等)并返回一个统计数据字典，比如字符数、字数、句子数等等。
生成表格
首先你需要通过Document类实例化一个文档对象。对于每篇文章，通过调用describe_text(text)函数提取统计数据，并通过add_table(row, columns)函数创建一个表格。对于字典中的每个 stat，通过add_row()函数创建一行并添加相应的 stat。最后，通过调用add_page_break()函数在末尾添加一个分页符，以便在新的页面中显示每个表格。
关于纯 Python 函数的更多文本统计，请查看我下面的另一篇文章。
不使用外部库压缩文本数据
towardsdatascience.com](/10-pure-python-functions-for-ad-hoc-text-analysis-e23dd4b1508a)
结论
用 Python 生成 word 文档很容易。您所需要的就是 python-docx 库。这个库提供了在 MS Word 中完成大多数(但不是全部)事情的可能性。
以我的经验来看，我在几秒钟内就生成了数千份两位数页数的 Word 文档。我这样做是为了以更易读的格式组织日志数据，或者在分析产品评论文本数据后呈现书面发现。
更好地利用 Python
towardsdatascience.com](/5-scenarios-where-beginners-usually-misuse-python-98bac34e6978)
如何在 Java 中生成拼花文件
马丁·范·登·霍维尔在 Unsplash 上的照片
Parquet 是 Apache 为 Hadoop 基础设施开发的一种开源文件格式。嗯，它最初是 Hadoop 的一种文件格式，但后来变得非常流行，甚至 AWS 等云服务提供商也开始支持这种文件格式。这只能意味着拼花地板应该做一些正确的事情。在这篇文章中，我们将看到什么是 Parquet 文件格式，然后我们将看到一个简单的 Java 例子来创建或编写 Parquet 文件。
拼花文件格式介绍
在传统方法中，我们将数据存储为行。但是 Parquet 采用了一种不同的方法，它在存储数据之前将数据展平成列。这允许更好的数据存储压缩，也允许更好的查询性能。此外，由于这种存储方法，该格式可以处理具有大量列的数据集。
由于所有这些特性，大多数大数据项目都使用 Parquet 文件格式。拼花文件还减少了所需的存储空间。在大多数情况下，我们对某些列使用查询。这种文件格式的优点是一列的数据都是相邻的，所以查询运行得更快。
由于文件格式的优化和流行，甚至亚马逊也提供内置功能，在保存到 S3 (其中充当数据湖)之前，将传入的数据流转换为拼花文件。我在亚马逊的“雅典娜”和一些 Apache 服务中广泛使用了这个。关于 Parquet 文件系统的更多信息，可以参考官方文档。
依赖关系
在我们开始写代码之前，我们需要注意依赖关系。因为这是一个 Spring Boot Maven 项目，我们将在 pom.xml 文件中列出我们所有的依赖项:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.apache.parquet</groupId>
<artifactId>parquet-hadoop</artifactId>
<version>1.8.1</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-core</artifactId>
<version>1.2.1</version>
</dependency>
</dependencies>
如您所见，我们正在添加 Spring Boot 启动包和几个其他 Apache 依赖项。对于这个例子，这就是我们所需要的。
属性
和往常一样，我们有一个 application.properties 文件，我们在其中指定所有属性。对于这个例子，我们只需要两个属性:一个指定模式文件的路径，另一个指定输出目录的路径。稍后我们将了解更多关于该模式的内容。因此，属性文件如下所示:
schema.filePath=
output.directoryPath=
因为这是一个 Spring Boot 应用程序，我们将使用 @Value 注释来读取代码中的这些值:
@Value("${schema.filePath}")
private String schemaFilePath;
@Value("${output.directoryPath}")
private String outputDirectoryPath;
拼花文件的模式
我们需要指定将要写入 Parquet 文件的数据的模式。这是因为当创建一个 Parquet 二进制文件时，每一列的数据类型也会保留。基于我们在模式文件中提供的模式，代码会在将数据写入 Parquet 文件之前相应地格式化数据。
在这个例子中，我尽量保持简单，正如您从下面的模式文件中看到的:
message m {
required INT64 id;
required binary username;
required boolean active;
}
让我解释一下这是什么。第一个参数的类型是 INT64，这是一个整数，它被称为 id 。第二个字段是二进制类型，它只是字符串。我们称之为用户名字段。第三个是名为活动的布尔字段。这是一个非常简单的例子。但是不幸的是，如果你的数据有一百列，你必须在这里声明所有的列。
字段声明前的必需的关键字用于验证，以确保为该字段指定了值。这是可选的，对于非必填字段，您可以删除它。
拼花作家
声明时间，我没有写这两个类，我在这一节讨论。几个月前，当我研究这个的时候，我在 StackOverFlow 上发现了这两个类。我不知道这是谁写的，但我一直在到处使用这两个类。但是是的，我已经重新命名了这些类来适应这个项目。
首先是 CustomParquetWriter 类。这扩展了 Apache 提供的 ParquetWriter 类。该类的代码如下:
public class CustomParquetWriter extends ParquetWriter<List<String>> {
public CustomParquetWriter(
Path file,
MessageType schema,
boolean enableDictionary,
CompressionCodecName codecName
) throws IOException {
super(file, new CustomWriteSupport(schema), codecName, DEFAULT_BLOCK_SIZE, DEFAULT_PAGE_SIZE, enableDictionary, false);
}
}
这里没什么好说的。下一个是 CustomWriteSupport ，您可以在上面的代码片段中看到它是 super()构造函数的第二个参数。这是很多事情发生的地方。您可以检查完整类的 repo ，看看它做了什么。
基本上，该类检查模式以确定每个字段的数据类型。之后，使用 RecordConsumer 类的一个实例，数据被写入文件。我不会过多谈论这两个类，因为 a)它们不是我写的，b)代码简单到任何人都能理解。
为拼花文件准备数据
让我们准备一些数据来写入 Parquet 文件。字符串列表表示拼花文件的一个数据集。列表中的每一项都是模式文件中更正字段的值。例如，假设我们有一个如下所示的列表:
查看 scheme 文件，我们可以看出数组中的第一个值是 ID，第二个值是名称，第三个值是活动字段的布尔标志。
因此，在我们的代码中，我们将有一个字符串列表来表示多行。是的，你没看错，这是一个字符串列表:
List<List<String>> columns = getDataForFile();
让我们看看这个函数，看看我们是如何生成数据的:
private List<List<String>> getDataForFile() {
List<List<String>> data = new ArrayList<>();
List<String> parquetFileItem1 = new ArrayList<>();
parquetFileItem1.add("1");
parquetFileItem1.add("Name1");
parquetFileItem1.add("true");
List<String> parquetFileItem2 = new ArrayList<>();
parquetFileItem2.add("2");
parquetFileItem2.add("Name2");
parquetFileItem2.add("false");
data.add(parquetFileItem1);
data.add(parquetFileItem2);
return data;
}
这很简单，对吧？那我们继续吧。
获取模式文件
正如我们已经讨论过的，我们有一个模式文件。我们需要将该模式放入代码中，特别是作为 MessageType 类的实例。让我们看看如何做到这一点:
MessageType schema = getSchemaForParquetFile();
...
private MessageType getSchemaForParquetFile() throws IOException {
File resource = new File(schemaFilePath);
String rawSchema = new String(Files.readAllBytes(resource.toPath()));
return MessageTypeParser.parseMessageType(rawSchema);
}
如您所见，我们只是将文件作为字符串读取，然后使用 Apache 库提供的 MessageTypeParser 类中的 parseMessageType() 方法解析该字符串。
让拼花作家
这几乎是整个过程的最后一步。我们只需要获得我们之前讨论过的 CustomParquetWriter 类的一个实例。这里，我们还提供了 writer 将写入的输出文件的路径。这方面的代码也很简单:
CustomParquetWriter writer = getParquetWriter(schema);
...
private CustomParquetWriter getParquetWriter(MessageType schema) throws IOException {
String outputFilePath = outputDirectoryPath+ "/" + System.currentTimeMillis() + ".parquet";
File outputParquetFile = new File(outputFilePath);
Path path = new Path(outputParquetFile.toURI().toString());
return new CustomParquetWriter(
path, schema, false, CompressionCodecName.SNAPPY
);
}
将数据写入拼花文件
这是最后一步，我们只需将数据写入文件。我们将循环我们创建的 list 列表，并使用我们在上一步中创建的 writer 将每个列表写入文件:
for (List<String> column : columns) {
writer.write(column);
}
logger.info("Finished writing Parquet file.");
writer.close();
差不多就是这样。您可以转到输出目录并检查创建的文件。例如，这是我运行这个项目后得到的结果:
如果你想直接从工作示例开始，你可以在我的 Github repo 中找到 Spring Boot 项目。如果你有任何疑问，欢迎在评论中问我。
最初发表于 2020 年 4 月 7 日 https://blog.contactsunny.com。
如何用 Python 生成伪随机数据集:用 Numpy & Faker 从头开始
当数据丢失时，创建它！(负责任地)
介绍
您即将开始下一个数据项目，但是您立即遇到了一个障碍:您希望使用的数据不容易访问。
发生这种情况有多种原因，例如:
- 您试图访问的数据是机密的，不能共享
- 数据可以共享，但是签订数据共享协议在时间和金钱上都是昂贵的
- 你获得了一些数据，但样本量太小，你无法根据代表性的数据源做出任何相关的统计推断或建模
- 您一直在寻找公共在线数据集，但就是找不到符合您特定需求的数据集
这些是同样面临的共同问题:
a)希望为其下一个数据解决方案开发 MVP 的企业家
b)希望模拟数据可视化解决方案的数据分析师
c)希望为客户开发概念验证解决方案的分析顾问
无论是哪种用例，本文的目标都是向您展示一个简单的例子，说明如何使用 Python 来生成伪随机数据集，其目的是尽可能地模拟真实世界的数据。
尽管生成伪随机数据将不可避免地具有给定的限制:
- 数据中人为构建的相关性和相互关系
- 样本数据集构建方式的固有偏差(通常由作者驱动)
- 缺失混杂因素和其他关键变量
为了让您的数据项目获得初步启动，并让您能够向投资者或您的下一个客户展示您的数据解决方案的潜力，该活动可能至关重要。
这项活动甚至可能说服你的同事与你分享真实世界的数据，这是你的最终目标。在咨询行业中，这样的同行是您的实际客户和数据的看门人，一旦数据解决方案的初步探索的可行性得到积极评估，这种情况就会经常发生。
现在让我们来看看 Python 中一个简单的数据生成工作流，在这个工作流中，您将主要利用 Numpy 和 Faker 包。
第一步:掌握正确的事实
假设您必须生成一个数据集，该数据集包含来自特定细分市场的保险索赔请求列表。您不是保险专家，并且希望得到至少 200，000 行与现实至少有一些相似之处的保险索赔，以便您可以将这些数据用于您将在前端创建的应用程序的示例用户界面。
你在网上找，你什么也没找到，因为你的新应用将覆盖一个你认为是行业空白的市场。
我称之为“询问专家”是一个很好的起点。实际上，这可能意味着:
- 向拥有相关行业经验或背景知识的朋友和同行伸出援手
- 在网上寻找行业报告、市场展望或相关文章
来源:作者
这项活动的目标是了解尽可能多的背景信息，以便以尽可能接近您试图代表的细分市场现实的方式生成数据。在本例中，这可能意味着询问数据的地理划分(即，如果您所在市场中 30%的索赔来自澳大利亚和日本，您可能希望您的数据反映这一点)以及与手头问题相关的任何其他问题。
这里的关键是不断地以迭代的方式收集有用的信息，这样当您生成数据时，您就可以返回到您的源并对照它们检查您的结果，并相应地调整您的数据生成活动。
为了获得有意义的生成数据样本，这可能是最重要的一步，而且这肯定需要相当长的时间，因为你会想要考虑各种变量和关系。
一旦完成了第一个关键步骤，就该使用一些 Python 代码来生成数据了！
步骤 2:生成数据
现在让我们看一下生成来自客户的 200，000 行随机保险索赔所需的代码。
- 导入相关的包:作为第一步，您需要导入相关的 Python 包。您可以使用熊猫和 numpy 操作数据，请求和 BeatifulSoup 处理网页， random 和Faker生成随机数据。在进行过程中，您将会用到所有这些包。当你开始设置的时候，不要忘记初始化一个 faker 生成器。
2。生成 200，000 个随机保险客户和相关变量
2.1 客户名称、地址、公司名称、索赔原因、保密等级
您可以生成的前五个变量是客户姓名、家庭地址、公司(假设每个客户都是公司的雇员)、保险索赔的原因以及索赔所附带的数据保密级别。
在这种情况下，您还隐式地定义了样本大小 n_names=200，000 。您可以使用 fake.name() 生成 n_names 名字，并存储到名字列表中。还可以使用 fake.company() 和 fake.address() 生成假的客户地址和公司名称。
假设步骤 1 中的专家告诉您，提出索赔的常见原因类型是“医疗”、“旅行”、“电话”或“其他”。对于这些原因中的每一个，都有一定程度的数据保密性(从“非常低”到“高”)，这也是您需要考虑的。您可以通过定义一个字典(这里称为claim _ confidential _ dict)来做到这一点，该字典存储每个索赔原因并将其映射到其相对数据机密性级别。
假设您还阅读了一份声誉良好的行业报告，该报告指出，所有索赔的分布严重偏向医疗索赔原因，这占所有索赔原因的 55%，其他索赔原因各占其余 45%的份额。然后，您可以使用 random.choice 函数创建一个 claim_reasons 列表，设置列表的长度等于 n_names (200，000) 以及使用 p 参数挑选给定索赔原因的概率。该参数是包含每个原因的可用概率的列表，允许我们提取 200，000 个索赔原因的有意义分布，以与我们的客户名称配对。
最后，您还可以生成一个包含所有保密级别的列，然后映射到您刚刚生成的 200，000 claim_reasons 列。为此，您可以使用之前定义的claim _ confidential _ dict字典作为查找参考，在索引 i 处生成一个保密级别，该索引与 claim_reasons 列表的相同索引位置配对。
创建了所有五列之后，现在可以将它们放入一个名为 df 的 pandas DataFrame 对象中。并调用 df 。head()来可视化全新的 200，000 行乘 5 列数据集的前 5 行。
图片:作者
2.2 国家、销售经理、索赔金额
现在让我们看看如何添加一个国家列，它标识客户的国籍，以及客户的索赔金额和处理索赔所需的指定销售经理。
你希望这家保险公司在世界各地开展业务，因此假设 200，000 名客户的样本具有国家频率，该频率等于特定客户来自 X 国的概率，给定其总人口。
因此，您可以使用列出所有国家和相关人口的维基百科页面来确定从特定国家挑选客户的概率。您首先需要导入一个国家列表及其人口列表。
让我们将代码分解如下:
你首先定义 URL 变量，它指向在线数据源。然后建立两个空列表， countries_list 和 pop_list，，用于存储来自网页的数据。
在 Python 中，你可以用漂亮的汤和请求包抓取网页。可以用 request.get 方法获取相关的 URL 内容。然后，您可以用提取它的文本。text 方法，最后把它解析成一个漂亮的 Soup 对象。
然后，为了在 HTML 中定位包含列表以及国家和人口的表格，您可以检查页面的代码(这可以通过在 Google Chrome 上单击 Ctrl + Shift + I 来完成)，并看到您感兴趣的表格元素有一个类 wikitable。然后您可以迭代它的 rows ("tr ")元素，对于表中的每一行(代码中的数据组件)，您可以提取相应的国家和人口元素。
提取后，您可以将它们添加到 countries_list 和 pop_list 中，并移动到下一个元素，直到到达表的末尾。
通过接下来的三行代码，您可以获得从 Wikipedia 页面返回的按人口排列的前 100 个国家(网页上的表格有已经排序的国家和人口列表，因此通过选择列表的前 100 个元素，您可以立即选择人口最多的国家)，以及相关人口规模的列表。
然后，通过将每个国家的人口除以前 100 个国家的总人口来获得相应的概率，并将这些概率用作选取随机国家的权重，以附加到新创建的国家列，该列插入到 df 数据集中。
最后两行代码还为数据集的每个索赔分配了一个索赔管理器，假设总共有 5 个 claim _ managers(简化),被分配一个索赔的概率相等。
您知道需要生成一个“索赔金额”列。你知道每笔索赔金额往往因索赔原因而异。
以下是您从另一份行业报告中获得的每个索赔原因类别的典型范围:
a)医疗:1300-3200 美元
b)差旅费:300-900 美元
c)电话:200-270 美元
d)其他:1-100 美元
如何根据索赔原因类别，将给定范围内的索赔金额分配给每一行？
您可以初始化一个空的“索赔金额”列，然后用分配给每个类别的给定范围内的随机整数填充它。索赔金额通过 numpy 提供的 np.random.randint(低，高)生成。然后你可以在数据集上调用 df.head() 来看一下你到目前为止得到了什么。
图片:作者
2.3 已付保费和索赔请求输出
您要创建的最后三列是:
- Category Premium，基本上是一个列，记录每个客户在给定索赔原因类别中支付的平均保险费金额
- 保费/金额比率，基本上是登记索赔金额与平均类别保费的比率的列
- 索赔请求输出，基本上是一个“是”/“否”列，说明索赔金额最终是否由保险公司承保。
让我们假设您的市场研究也发现，在您给定的细分市场中，支付的保费平均比给定类别中的平均索赔额高 8 倍。假设您还知道您的数据集想要一家保险公司，出于效率原因，该公司自动支付平均类别保费的 6%或更低的索赔额(因为该公司不想花时间验证某项索赔背后的合理性，因为小额金额不值得为此付出巨大努力)。
您可以通过使用 pandas groupby 然后在索赔原因列使用 mean()调用来计算您的平均索赔金额，如下所示。然后，您可以将每个平均索赔额乘以 8，以获得您的平均类别保费，并将它们存储在一个列表中。完成后，您可以创建一个新的 Category Premium 列，根据特定行的索赔原因，列出每行的平均保费金额。
然后，您可以通过简单地将索赔金额列除以类别保费列来创建保费与金额比率列。
如果按类别细分，你会发现平均而言，每项索赔占该类别保费的 13%左右
现在让我们计算最后一列，即索赔请求输出，方法是为所有保费/金额比率低于 6%的索赔分配一个“Yes”值。您可以使用 np.where 函数轻松创建新列，并通过调用控制台来可视化整个数据集。
图片:作者
第三步:外卖
你完了！您已经成功地生成了 200，000 行和 11 列的伪随机数据，准备用于项目。
这个数据集绝不是一个封闭的解决方案，您可以根据自己的数据生成需求扩大或缩小这个方法。
记住关键的一步是第一步。在这里，您试图收集尽可能多的关于问题的上下文知识，这样，即使您仍然得到随机的行，您也可以在第一次尝试中建立一定程度的逻辑和连贯性。
我鼓励您将数据生成作为一种迭代练习。Python 是一种很好的从头构建数据的编程语言，但是当你在代码中灌输关于用例的技能和直觉时，真正的价值就会增加，这样输出就可以尽可能地(伪随机)。
从这个意义上说，主题专家、在线资源和你的团队是你最好的助手。
访问我的免费数据科学资源清单 这里
[## 通过我的推荐链接加入 Medium-Edoardo Romani
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
edo-romani1.medium.com](https://edo-romani1.medium.com/membership)
如何从头开始生成随机变量(不使用库)
我们将通过一个简单的伪随机生成器算法，展示如何使用它来生成重要的随机变量
图片来源 : Pixabay(免费用于商业用途)
介绍
随机变量是数据科学、机器学习和统计建模不可或缺的一部分。它们在我们周围采用人工智能或深度神经网络的系统和服务中发挥着越来越重要的作用。
随机变量的概念和性质用于
- 回归技术，
- 像随机森林，梯度推进，
- 深度学习，
- 聚类算法，
- 自然语言处理，
- 强化学习，
- 人工智能和博弈论中的高级搜索算法。
这篇文章不是关于随机变量的属性和效用。为此，鼓励读者参考其他优秀资源。
随机变量在统计学和概率学中非常重要，如果任何人想要…
towardsdatascience.com](/understanding-random-variable-a618a2e99b93) [## 深度学习背景下的概率统计解释
这篇文章是为希望获得概率和统计知识的深度学习初学者而写的。
towardsdatascience.com](/probability-and-statistics-explained-in-the-context-of-deep-learning-ed1509b2eb3f)
这篇文章旨在展示如何通过简单的编程从零开始生成随机变量。
注意短语“从零开始*”。意思是我们不会调用第三方库或者子程序。相反，我们将编写我们自己的简单函数来生成这样的随机变量。*
你能做到以下几点吗？
- 加法、乘法、除法和模数
- 正弦、余弦和对数运算
我们将展示如何使用这些基本的数学运算来生成，
- 均匀随机变量
- 指数分布的随机变量
- 正态分布的随机变量
图片来源:imgflip.com 作者生成的模因
这个练习将让你对我们必须使用的伪随机数的质量有一个直观的了解，并且展示常见的概率分布是如何从一个发展到另一个的。
等等，我说的是“伪-随机”吗？让我们看看我是什么意思。**
在软件领域，你必须拥抱“伪”
大自然母亲提供了许多真实随机过程的例子。核衰变就是这样一个例子。
图片来源:维基媒体(知识共享许可)
原来真正的随机过程只能用所谓的 硬件随机发生器 **，一种从物理过程中产生随机数的设备来模拟和建模，而不是通过算法。这种设备通常基于产生低水平随机“噪声”信号的量子力学现象，例如热噪声、光电效应、光束干涉和其他量子现象。
不幸的是，在日常计算系统中，以及在算法设置中，我们只遇到所谓的’伪随机数 。它们不像自然过程那样是真正随机的，在某种程度上，它们是确定的。一个种子数被提供给一个算法，该算法生成一系列这样的数。
本页解释了为什么很难(也很有趣)让计算机产生合适的随机数。
www.random.org](https://www.random.org/randomness/)
一个非常有名的人对这种方法说了这样的话！
图片来源:作者在 imgflip.com 创作的带有维基百科图片的模因
然而，对于所有实际的计算目的，如果这些“伪随机数”不表现出明显的重复模式或可预测性，它们就足够了。
所有主要的编程语言中都有复杂而精致的伪随机生成器。在许多情况下，他们使用特殊类型的数学，如 模运算 或 马森纽斯特 。下面以 Python 的[**random**](https://docs.python.org/3/library/random.html) 模块的链接为例。
围绕用于加密系统的 密码安全伪随机发生器 还有一个完全独立的研发分支。想象一下，如果有人能猜出或梳理出为您的 Google 密码生成散列密钥的确切算法，会发生什么？
如果你一直在关注最近关于美国国家安全局和英国政府进行技术间谍活动的新闻…
blog.cloudflare.com](https://blog.cloudflare.com/why-randomness-matters/)
但是我们不关心如此复杂的事情！
在本文中，我们将借助基本的数学运算编写一个非常简单的程序来构建我们的随机生成器。实际上，我们将使用一种叫做 线性同余生成器 的方法，这种方法在伪随机生成的旧时代很流行。
我们程序的输出将采取简单的 均匀分布 的形式。此后，我们将根据这个随机发生器，使用统计定理和变换来产生对应于其他分布的随机变量。
均匀随机发生器
线性同余发生器(“坏”版本)
我们将使用如下的线性递归关系，
并且，均匀随机变量是在缩放之后获得的，
我们还需要一个种子号来开始生成过程。这里有一个简单的 Python 函数来完成这个任务，
到目前为止，我们所做的只是一些乘法、加法、模数和除法。很简单的算术，对吧？
让我们看看这个简单的函数是如何执行的。注意，我们命名为pseudo_uniform_bad是因为我们知道乘数和模数的选择相当糟糕。
让我来说明我的意思。让我们用seed=3生成 1000 个随机数，并绘制它们的直方图来查看分布。
不太好，嗯？我们期望看到 0 和 1 之间的均匀分布，但却得到了一些数字补丁。
事实证明，我们可以很容易地通过改变乘数和模整数来改善它。
线性同余发生器(更好的版本)
让我们放大这些整数的大小。
现在，如果我们生成 10，000 个随机数，并绘制它们直方图，看起来如下:
广义均匀随机发生器
现在，构造广义均匀随机发生器函数是非常容易的，
这里有一万个-5 到+7 之间的均匀随机分布的数。
其他随机函数和分布
既然我们可以编写一个像样的均匀随机生成器，我们可以很容易地扩展它，为大量的统计分布构造随机变量生成器。
样品拾取器
例如，使用 uniform generator，我们可以快速制作一个样本选取器，它将从给定的项目列表中选取一个随机样本(不需要数字，任何类型的对象都可以)。
注意，我们还使用当前系统时钟返回的浮点值的小数部分作为该函数的种子。
我们可以用一个公平掷骰子的模拟来测试它，掷骰子的六个面作为列表传递给函数，
伯努利分布
这是一个离散的概率分布，它可以被认为是任何一个提出是非问题的实验的一组可能结果的模型。单个参数表示为p——成功的概率。
我们的伯努利生成器代码看似简单，
二项分布
它是一系列 n 个独立实验中特定数量成功的离散概率分布，每个实验都提出一个是非问题，并且每个实验都有自己的布尔值结果:成功概率 p 或失败概率q= 1p。
我们可以很容易地从均匀发生器中编码出一个二项随机变量发生器，
假设翻转 100 个装载的硬币，每个硬币的头部概率为 0.75，这样的尝试/实验重复 15 次。每个实验中的头数由我们的函数给出，
泊松分布
它是一个离散的概率分布，表示在固定的时间或空间间隔内发生的给定数量的事件的概率，如果这些事件以已知的恒定平均速率发生，并且独立于自上次事件以来的时间。
我们可以使用我们的统一生成器来编码泊松生成器，如下所示，
下面显示了三个不同速率参数的模拟结果，其中使用上面的函数产生了 10，000 个随机变量，并且绘制了事件的计数，
指数分布
是一个泊松点过程中事件之间时间的连续概率分布，即事件以恒定的平均速率连续独立发生的过程。
为了从均匀分布生成指数分布，我们可以使用一种称为“ 逆变换方法 ”的强大技术。我们不需要在这里详述理论细节，但最终这种方法通过简单的数学变换将两种类型的分布联系起来。
这是一个 10，000 个随机变量的直方图，比率参数为 0.1，
正态分布
正态或高斯分布毫无疑问是最著名的统计分布(主要是因为它与中心极限定理的联系)。
事实证明，使用一种叫做 Box-Muller 变换 的特殊方法，我们可以从均匀随机生成器生成正态分布的随机变量。
这是三组不同参数的模拟结果，
摘要
在本文中，我们展示了如何从一个简单的线性同余生成器开始，通过简单的编程来生成均匀分布的随机数。此后，我们展示了如何使用基本的数学运算和转换从这个基础生成器构建一个更复杂的统计分布集。
我们能够为多种广泛使用的概率分布构建函数，而无需使用任何标准库，如 NumPy 包的**np.random**模块。
如果你已经走到这一步，这里有一个来自 Cloudflare 的有趣视频，它在旧金山的办公室使用一系列熔岩灯，为他们的加密系统产生随机性。
A lso，你可以查看作者的 GitHub 知识库获取机器学习和数据科学方面的代码、思想和资源。如果你和我一样，对人工智能/机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。
[## Tirthajyoti Sarkar - Sr .首席工程师-半导体、人工智能、机器学习- ON…
通过写作使数据科学/ML 概念易于理解:https://medium.com/@tirthajyoti 开源和有趣…
www.linkedin.com](https://www.linkedin.com/in/tirthajyoti-sarkar-2127aa7/)***
如何生成合成表格数据？
生成敌对网络的 Wasserstein 损失
在过去的一篇博客文章中，我已经介绍了什么是生成性对抗网络，以及我们如何使用它们来生成设计为私有的数据，在这篇文章中，我介绍了 T2 的普通 GAN 和条件 GAN。但是，尽管非常有前景，但这些生成性对抗网络的训练非常具有挑战性，并且它们生成的数据没有足够的质量用于 ML 工作负载作为真实数据的替代。还有许多其他有趣的 GAN 架构，其中一些引入了更稳定的训练和更少的模式崩溃倾向的改进，今天我将涵盖 Wasserstein GAN 。
瓦瑟斯坦·甘
Wasserstein GAN 被认为是 Ian good fellow 提出的生成性对抗网络的延伸。WGAN 是由 Martin Arjovsky 在 2017 年推出的，承诺在训练模型时提高稳定性，并引入能够与生成事件的质量相关联的损失函数。听起来不错吧？但是和 WGAN 引入的核心区别是什么？
WGAN 有什么新功能？
GAN 没有使用“鉴别器”的概念来分类或预测某个生成事件的真实或虚假的概率，而是引入了“评论家”的概念，简而言之，该概念对给定事件的真实或虚假进行评分。这种变化主要是由于当训练生成器时，理论上我们应该寻求在训练数据集中观察到的数据分布和在生成的例子中观察到的分布之间的距离的最小化。
我们可以将 WGAN 引入的主要差异总结如下:
- 使用从 Wasserstein 距离导出的新损失函数。
- critic 函数每次梯度更新后，将权重箝位在一个小的固定范围内，[-c，c]。这允许实施 Lipschitz 约束。
- 向歧视者——批评家提出的替代方案。
- 使用线性激活函数作为 Critic 网络的输出线性。
- 生成器和评论家网络的更新次数不同。
好处
前面提到的和 WGAN 引入的变化在训练这些网络时带来了一系列好处:
- 与例如最初提出的 GAN 相比，WGAN 的训练更加稳定。
- 它对模型架构的选择不太敏感(生成器和评论家的选择)
- 此外，受超参数选择的影响较小，尽管这对于获得良好结果仍然非常重要。
- 最后，我们能够将批评家的损失与生成事件的整体质量联系起来。
使用 Tensorflow 2.0 实施
现在我们已经完成了导入，让我们来看看网络:生成器和评论家。
与生成器类似，我决定为评论家选择一个简单的网络。在这里，我有一个 4 密集层网络，也 Relu 激活。但是，我想在这里强调一下最后一行代码。与普通 GAN 不同，我们通常将它作为网络的最后一层:
x = Dense(1, activation=’sigmoid’)(x))
它在鉴别器的输出层使用 sigmoid 函数，这意味着它预测给定事件为真实事件的可能性。当谈到 WGAN 时，critic 模型需要线性激活，以便预测给定事件的“真实度”得分。
x = Dense(1)(x)
或者
x = Dense(1, activation=’linear’)(x)
正如我提到的，WGAN 模型的主要贡献是使用了一个新的损失函数 Wasserstein 损失。在这种情况下，我们可以在 Keras 中将 Wasserstein 损失实现为一个自定义函数，它计算真实事件和生成事件的平均分数。
分数是真实事件最大化，生成事件最小化。下面实施瓦瑟斯坦损失:
另一个重要的变化是为评论家网络引入了权重裁剪。在这种情况下，我决定用下面的方法定义扩展 Keras 约束类:
现在我们已经介绍了主要的变化，您可以在这个 open GitHub 存储库中找到 WGAN 的完整实现，由 YData 提供支持。
WGAN 面临的挑战
尽管 WGAN 为数据生成领域带来了许多好处，但它仍然有一些需要解决的挑战:
- 尽管与其他架构相比更加稳定，但仍然存在训练不稳定的问题
- 权重裁剪后收敛缓慢-当裁剪窗口太大时
- 消失渐变—当剪辑窗口太小时
自其发表以来，基于 WGAN 主要问题与所选权重裁剪方法相关的事实，一些建议的改进是最有前途的改进之一，并使用了梯度惩罚— WGAN-GP 文章。
表格数据生成
现在，我们已经介绍了 WGAN 及其实现的大部分理论知识，让我们开始使用它来生成合成的表格数据。
出于这个练习的目的，我将使用我之前在这篇博文中提到的存储库中的 WGAN 实现。
我将用于此目的的数据集是数据科学界非常熟悉的一个数据集，即信用欺诈数据集。
出于演示的目的，我决定选择这个数据集的一个较小的样本。在这种情况下，我决定只综合欺诈事件。
信用欺诈数据集的小样本。
在对数据进行几个预处理步骤之后，我们准备好将数据输入 WGAN。
更新批评家的次数要比生成器多
在其他 GAN 架构中，如 DCGAN ，发生器和鉴频器模型必须在相同的时间内更新。但是对于 WGAN 来说，这并不完全正确。在这种情况下，critic 模型必须比 generator 模型更新更多次。
这就是为什么我们有一个输入参数，我称之为n _ critic——这个参数控制 critic 从每批生成器获得更新的次数。在这种情况下，我将它设置为 3 次。但是你可以为其他人设置并检查最终结果的影响。
与其他 GAN 架构的训练过程相比，在使用相同数据集的情况下，可以看出 WGAN 训练确实不太容易出现不稳定性，产生的结果更接近真实数据集分布，尽管并不完美。
WGAN 在 1000 个时期后为 V1 和 V10 变量生成数据点
我还决定通过利用主成分分析和 TSNE 算法来降低数据集的维度，选择两个分量，以简化数据的可视化。下面你可以找到这些图，我比较了 WGAN 生成的数据和原始数据的 PCA 和 TSNE 结果。很明显，WGAN 未能符合原始数据中捕获的一些行为，尽管如此，结果还是很有希望的。
PCA 和 TSNE 对合成和原始欺诈事件进行了计算，包括两个部分
合成数据集和原始数据集之间的基本统计差异。越轻差别越小。
结论
与使用 GANs 生成具有真实价值的合成数据以用于机器学习任务并以保护隐私的方式共享相比，本文中显示的结果仍然非常简单。与其他架构相比，Wasserstein 作为损失函数的引入无疑有助于使训练更加稳定，并且对网络架构和超参数的选择不太敏感。
对于那些对生成合成表格数据感兴趣并想尝试一下的人，可以看看这个 GitHub 库。我们将使用新的 GAN 架构和新的数据集示例对其进行更新，并邀请您参与合作。
改进了人工智能的数据
YData 为数据科学家提供了一个以数据为中心的开发平台，致力于高质量的合成数据。
如何生成考虑任何国家节假日的熊猫时间序列
照片由 Unsplash 上的 Joost Crop 拍摄
如何使用美国假日日历，为任何目的或任何其他国家生成自定义假日日历，如何将日期序列合并到数据集中
在时间序列数据分析中，生成日期在现实生活中的许多场合都是必要的。有时我们有数据，但时间没有记录，有时我们可能不得不使用一个国家的数据进行另一个国家的研究，或者今年使用去年的数据。今年的假期与去年不同，或者这个国家与另一个国家不同。这篇文章显示:
a.如何使用内置的假日日历？
b.生成自定义假日日历。
c.将一系列日期合并到数据集中。
考虑假期的时间序列
- 生成一个考虑所有节假日的时间序列。
熊猫已经内置了美国假日日历。使用“CustomBusinessDay”功能生成自定义频率，传递内置的美国假日日历。使用此自定义工作日作为频率。
**from** pandas.tseries.holiday **import** USFederalHolidayCalendar
**from** pandas.tseries.offsets **import** CustomBusinessDayusb **=** CustomBusinessDay(calendar **=** USFederalHolidayCalendar())
pd.date_range('7/1/2018', '7/10/2018', freq=usb)#Output:
DatetimeIndex(['2018-07-02', '2018-07-03', '2018-07-05', '2018-07-06', '2018-07-09', '2018-07-10'], dtype='datetime64[ns]', freq='C')
我用的范围是 7 月 1 日到 7 月 10 日。看输出。7 月 3 日之后是 7 月 5 日。因为 7 月 4 日是假日。
2.现在，我将向你展示如何制作你的定制假日日历。如果你的客户不是美国人，你必须做一个定制的假日日历。因为其他国家的假期和美国不一样。
为了简化本教程，假设我是一家大公司的老板。我宣布我的周年纪念日为公司假日。虽然这不太可能。我这样做只是为了演示如何制作一个自定义的假日日历。
熊猫图书馆让你使用他们的类来修改和制作你自己的。在 这一页的最后 ，你会发现类‘USFederalHolidayCalendar’是这样的:
class USFederalHolidayCalendar(AbstractHolidayCalendar):
"""
US Federal Government Holiday Calendar based on rules specified by:
[https://www.opm.gov/policy-data-oversight/](https://www.opm.gov/policy-data-oversight/)
snow-dismissal-procedures/federal-holidays/
"""
rules = [
Holiday("New Years Day", month=1, day=1, observance=nearest_workday),
USMartinLutherKingJr,
USPresidentsDay,
USMemorialDay,
Holiday("July 4th", month=7, day=4, observance=nearest_workday),
USLaborDay,
USColumbusDay,
Holiday("Veterans Day", month=11, day=11, observance=nearest_workday),
USThanksgivingDay,
Holiday("Christmas", month=12, day=25, observance=nearest_workday),
]
现在，修改名称和规则来制作一个定制的假日日历。我假设我的周年纪念日是 3 月 20 日。使用“遵守”作为“最近工作日”。这意味着如果指定的日期是周末，假日日历将自动将最近的工作日作为假日。“遵守”几乎没有其他选择。分别是:'周日 _ 至 _ 周一'，'下周 _ 周一 _ 或 _ 周二'，'之前 _ 周五'，'下周 _ 周一'。请随意自己尝试。
from pandas.tseries.holiday import AbstractHolidayCalendar, nearest_workday, Holidayclass MyAnniversaryCalendar(AbstractHolidayCalendar):
rules = [
Holiday("MyAnniversary", month=3, day=20, observance = nearest_workday)
]
在这里，我做了我的周年日历。使用此类“MyAnniversaryCalendar”自定义频率，并将其用作“freq”参数的值。
myday = CustomBusinessDay(calendar=MyAnniversaryCalendar())pd.date_range('3/15/2020', periods=12, freq=myday)#Output:
DatetimeIndex(['2020-03-16', '2020-03-17', '2020-03-18', '2020-03-19', '2020-03-23', '2020-03-24', '2020-03-25', '2020-03-26', '2020-03-27', '2020-03-30', '2020-03-31', '2020-04-01'], dtype='datetime64[ns]', freq='C')
请看一下输出。3 月 19 日之后，是 3 月 23 日。有一个三天的周末！
3.一些国家有不同的工作日。例如，像埃及、卡塔尔这样的国家将星期五和星期六作为周末。所以，他们的假日日历应该是不同的。以下是如何定义和使用每周工作日:
b = CustomBusinessDay(weekmask = 'Sun Mon Tue Wed Thu')
pd.date_range('6/20/2020', '6/30/2020', freq=b)#Output:
DatetimeIndex(['2020-06-21', '2020-06-22', '2020-06-23', '2020-06-24', '2020-06-25', '2020-06-28', '2020-06-29', '2020-06-30'], dtype='datetime64[ns]', freq='C')
检查输出中缺少的日期。你会看到它们是星期五和星期六。
在数据集中使用日期序列
在本节中，我们将使用由 date_range 函数生成的一系列日期，并在数据集中使用它。在这个练习中，我使用了脸书股票数据集。首先导入数据集:
df = pd.read_csv('FB_data_with_no_date.csv')
df.head()
现在，生成时间序列，其中开始日期是 2020 年 1 月 1 日，“周期”是数据集的长度，频率
rng = pd.date_range('1/1/2020', periods = len(df), freq='B')
将此时间序列设置为脸书股票数据集的索引。
df.set_index(rng, inplace=True)
df.head()
这是时间序列数据集，可用于时间序列数据分析或预测。
结论
在时间序列分析中，处理节假日是正常的。在不同的文化和不同的国家，有不同的时区和不同的节日。所以，如果你处理时间序列数据，你会经常用到这个。希望这篇文章对你有帮助！
更多阅读:
熊猫的所有基本视觉类型和一些非常高级的视觉…
towardsdatascience.com](/an-ultimate-cheat-sheet-for-data-visualization-in-pandas-4010e1b16b5c) [## Numpy 的终极备忘单
对学习也有好处
towardsdatascience.com](/an-ultimate-cheat-sheet-for-numpy-bb1112b0488f) [## 描述统计学导论
对最基本和广泛使用的描述性统计方法有清晰和详细的理解
towardsdatascience.com](/introduction-to-the-descriptive-statistics-a050b5ec99fb) [## 学习机器学习和深度学习的优质免费课程
顶级大学高质量免费课程的链接
towardsdatascience.com](/great-quality-free-courses-to-learn-machine-learning-and-deep-learning-1029048fd0fc) [## 练习数据科学技能和制作优秀投资组合所需的所有数据集
一些有趣的数据集提升你的技能和投资组合
towardsdatascience.com](/all-the-datasets-you-need-to-practice-data-science-skills-and-make-a-great-portfolio-857a348883b5) [## 一个完整的推荐系统从零开始:一步一步
基于用户评分的线性回归电影推荐系统
towardsdatascience.com](/a-complete-recommender-system-from-scratch-in-python-step-by-step-6fc17a4da054)
作为一名害羞的数据科学家，如何获得工作推荐？
办公时间
技巧、经验教训和 1+1+1 流程
TL；获得推荐是获得面试分数的最有效方式，但许多有抱负的数据科学家，尤其是内向的数据科学家，很难做到这一点。我正在分享一些经验教训和一个“1+1+1 过程”,它帮助我在最负盛名的公司获得面试(和工作机会)。我还包括了一些小挑战来帮助你开始。
免责声明 :我把数据科学和 ML 这两个术语互换使用。我的观点完全来自个人经验，不代表我的雇主的官方招聘准则。
喜欢读什么？ 跟我上 中LinkedIn，以及Twitter。查看我的《* 对机器学习的影响 》指南。它帮助数据科学家更好地解决问题、设计和交流。*
最近，我受邀向一群有抱负的数据科学家发表演讲。一个学生问:“你怎么让别人推荐你？我没那么外向。”
我的简短回答是:如果你提前得到了一些东西，你就不需要请求推荐，尤其是如果你是一个内向的人。
回想我自己的旅程，我在顶级咨询公司、大型科技公司、华尔街对冲基金和人工智能初创公司的大多数面试(和工作邀请)都源于冷淡的关系，而不是来自老朋友或投简历。
作为一个内向的人，每次我需要发电子邮件、建立关系网和引导对话时，这都是一次极其令人畏惧的经历。但是随着我职业生涯的进展，我开始用不同的方式对待这种互动。在这篇文章中，我将分享一种方法和过程，让它变得更容易和更有效。
要设定期望值，您必须了解并准备好以下内容:
- 真正的好奇心。你必须对对方感到好奇，就像你作为一名数据科学家对数据中的见解感到好奇一样。
- 要有耐心。建立关系需要时间和互动。不要指望在与第一个人第一次互动后就能获得推荐。并不是每一次互动都会有所收获——这完全没问题。
- 纪律。有些事情是你控制不了的。你需要坚持不懈的努力。好事会来的。
那么，不求人怎么能得到推荐呢？我们按步骤分解一下。这里的教训主要适用于建立冷淡的关系(例如，不在你的家庭和现有朋友网络中的人)。
第一步。值得推荐
这是没有办法的。你必须花时间发展基本技能和“品牌”,这样人们才会有信心把你带进他们的团队和网络。怎么才能“可参考”？作为有抱负的数据科学家，我认为有几种方法可以脱颖而出:
- 独一无二。与几年前不同，现在有很多数据科学家。每个人都知道如何建立模型(或者他们是这么说的)。你还能带来什么？(如领域知识、特殊技术诀窍、做别人不想做的事等。)
- 来点激情项目。如果你是一名应届毕业生，参与有激情的项目(而不是学校布置的任务)是展示你的工作并在简历中突出多年工作经验的好方法。最棒的是，你是你工作的主人，你不需要任何人的许可，也不需要一封聘书就可以开始工作。
- 说不清就秀。如果你是一个内向的人，你可能不会大声说出你能做什么(尽管你应该试着这么做)。最好的办法就是展示。展示你的作品是在陌生人之间建立信任的最好方式。所以，在自己的网站或者 Github 上有一个好的作品集。让你的工作为你辩护。这是设计界的标准做法，许多科技公司已经在寻求你的 Github 的链接。
迷你挑战#1: 拿你最近的学校或激情项目，清理代码，写一个你奶奶能看懂的简单 1 页总结，上传到 Github 或你的个人网站。接下来的 1-2 周，每天给 1-2 个人看。获得反馈，并请他们与可能会觉得有趣和有用的朋友分享。如果你开始有困难，看看我关于 12 小时挑战 的帖子，试试吧。
第二步。从合适的公司找到合适的人
谁是“合适的”人？如果你有世界上所有的时间和精力，你应该去认识每一个有趣的人。但是，实际上，你很可能会违背招聘计划或下一份工作的跑道。因此，我的建议是按照以下顺序进行连接:
- 招聘经理(例如工程经理、团队领导、首席数据科学家等。)—发现和雇佣优秀人才是他们的使命。但是经理们通常忙于在日常工作和招聘之间周旋。所以，让你的互动有影响力(见第 3 步& 4)。
- 入门级(如数据科学家、分析师等。)—虽然他们可能没有决定权，但初级人员仍然可以为招聘经理做介绍(有些人有一天会成为经理)。
- 高管(如高管、合伙人、高级/副总裁等。)—如果能从首席执行官那里得到一份自上而下的介绍给招聘团队，那就太好了。这种情况时有发生，但大多数高管都太忙了，没有参与日常的招聘过程。
有哪些合适的公司？根据我的经验，从在初创公司和中型公司工作的人那里获得推荐会更有效。大公司通常对入门级职位有标准的校园招聘流程，大多数人会推荐他们更有经验的朋友和熟人去做非入门级的工作。
你可以看看这篇文章我对数据科学角色和公司的类型进行了分类。
了解数据科学到底是什么。找到符合您的个人资料和兴趣的数据科学角色类型。想出一个从小到大的目标公司列表，职位名称，并根据我在第二步中建议的优先级开始在 LinkedIn 上与人联系。
小挑战#2: 写下你想加入的 5 家公司(1-2 家大公司，2-3 家中型公司，3-4 家初创公司)。在这些公司中找到 1-3 个数据科学/分析职位。在 LinkedIn 上找到每家公司的 1-2 名经理级人员。先和同城或者同校的联系，不要一下子和所有人联系。按照下面的第 3 步，给他们发送一条好的介绍信息。
第三步。写一个好的介绍信息
不是每个人都会接受并回复你的 LinkedIn 邀请和信息。根据我的经验，接受率为 50–70%，回复率为 20–30%(例如，要让一个人回复，你至少需要联系 8-10 个人)。
你真的不能对接受率做任何事情，但你可以根据你如何写你的信息来尝试提高回复率。
以我的经验来看，带有明确问题和选项的简短信息效果更好。作为一个内向的人，我曾经认为这样的消息是粗鲁和唐突的。但是更重要的是尊重他人的时间，让他们知道他们如何能帮上忙——并且让事情变得简单。
具体来说，这里有一个几天前出现在我收件箱里的坏例子。
LinkedIn 留言的一个不好的例子，作者的作品
我知道这个人在寻求帮助，但是我不知道我能帮什么，怎么帮。
总的来说，介绍信息的目标应该是让接收者知道为什么以及如何用最少的精神能量来帮助。
以下是我遵循的一些原则:
- 对你的问题要明确具体(简短的总结和/或链接)
- 提出一个对你合适的时间，然后让对方决定(只需查看日历比发送额外的信息来确定一个对双方都合适的时间更容易)
- 提供选项(但不要太多)
- 让人们说不，但留下跟进的机会
考虑到这些，以下是我重写 LinkedIn 信息的方式:
“嗨，伊恩，谢谢你接受我的邀请。我喜欢你在媒体 ( 上的文章😉，好吧也许不是眨眼)。我正在探索数据科学的机会，看到贵公司有一个职位空缺(如果有，请附上链接)。你可以在这里查看我的简历和工作(简历和作品集的链接)。您是否有空在本周五或下周五下午 3 点进行一次 15 分钟的简短聊天？如果你认为有一个更好的人可以和我说话，如果你能把我们联系起来，那就太好了。”
您可以从该信息中提取一些元素，并根据自己的需要进行调整。网上有很多好的邮件和信息模板。坚持原则，找到自己的风格。
第四步。见面，但不要要求介绍
一旦你与来自正确公司和团队的正确的人安排了一次会议，并带着正确的介绍信息，现在到了关键时刻:让那个人把你放在面试过程中。
吉菲
对于内向的数据科学家来说，不得不与陌生人聊天并寻求帮助可能是最难以承受的过程。不幸的是，我不能提供一个脚本，因为对话可能以多种形式发生，取决于对方的个性、会议前和会议期间每个人的情绪、招聘过程的背景等。
好消息是，在这个阶段，你要见的人知道你的意图(例如，在他/她的团队中找到一份工作，或者与其他人取得联系)，能够影响和采取行动，并乐于提供帮助，或者至少倾听你的建议。你获得“推荐”的机会已经比随机与某人交谈或向普通收件箱发送简历高得多。
为了让谈话不那么令人畏惧，更有效，这里有一些我认为有用的心理和谈话技巧:
- 不要把它当成面试。因为这个人会评估他们是否应该帮助你并让你加入，所以这个对话就是一次正式或非正式的面试。尽管如此，告诉自己“这就像和一个多年未见的朋友的对话，我们只是在叙旧。”在心里说这句话通常会让我放松，不会显得太绝望。
- 温和地带头。招聘经理通常也不知道如何与你交谈，或者被他的日常工作所困扰。会有死气沉沉的尴尬。这让我这个内向的人受不了。因此，在感谢您接听电话并抽出时间之后，我通常会建议“为什么我不告诉您更多关于我的数据科学经验，我很想了解更多关于您的团队以及您在该职位上的期望……”要友好、冷静、具体，并准备好您的故事。我还没有遇到反对这个建议的人。
- 献，莫问。在对话接近尾声时，你们双方都应该知道是否有合适的人选。如果你还想继续，关键时刻到了。不要问“你能推荐我吗？”这可能会很唐突，让每个人都感到尴尬，但要提供两个机会:你的简历和你能帮上忙的事情。你可以这样说:“我很想进一步探索，我可以把我的简历和作品集分享到你的邮箱吗？请看看，如果你觉得合适，请告诉我。我一两周就能跟进。”
现在你已经尽力了。让生活来处理剩下的事情。
在会议期间，能够促进对话并讲述关于你自己的好故事是很重要的。和招聘经理一起练习风险太大，成本也太高(你需要在参加会议时做好准备)。
小挑战#3 :准备好你想如何解释你的工作，它有什么有趣的地方，以及它为什么重要。自己排练。和你的好朋友喝饮料或咖啡时，不经意地提起这些故事。目的是让他们问问题并跟随对话的流程。当场练习思考和表达，避免预先准备好一切。
1+1+1 流程
正如我在开头提到的，建立关系需要时间、耐心和自律。随着我的工作和生活越来越忙，我制定了一个建立新的和维护现有网络的过程(作为一个内向的人，我天生做不好这一点，所以我必须依靠一个过程)。
这就是所谓的“1+1+1 过程”:每个月的周五下午(比如 1+1+1)，试着去见一个新人，和一个老朋友、熟人或者同事。如果你有更多的时间，想加速，可以调整人数和频率(如每 2 周 3+2)。
当你经历求职过程时，你可以采用这个过程来开始并保持建立关系的势头，你现在或将来都可以依靠它。
没有捷径可走。准备投入时间、精力，最重要的是，投入你对他人的真正兴趣。好事会来的。直到下一次！
喜欢读什么？ 跟我上 中 ，LinkedIn，以及Twitter。查看我的《* 用机器学习影响 》指南。它帮助数据科学家更好地解决问题、设计和交流。*
你可能也喜欢
我如何应对部署机器学习的无聊日子
towardsdatascience.com](/data-science-is-boring-1d43473e353e) [## 最有用的 ML 工具 2020
每个懒惰的全栈数据科学家都应该使用的 5 套工具
towardsdatascience.com](/the-most-useful-ml-tools-2020-e41b54061c58) [## 我们应该留在数据科学领域吗？
数据科学家的 4 个现实职业选择
towardsdatascience.com](/the-most-realistic-data-science-career-guide-d12c4af87cc8)*
如何找到数据工程师的工作
本世纪发展最快的职业之一的 10 种需求技能和决定职业前景的主要因素
内森·赖利在 Unsplash 上拍摄的照片
数据工程是一个令人着迷的领域。您可以与各种有趣的数据、前沿技术以及不同的数据专业人员和领域专家团队一起工作。数据工程的整个领域相对较新。作为一名数据工程师，您的角色对公司的成功至关重要-许多数据专业人员，包括数据分析师和数据科学家，都依赖您来完成他们的工作。您有责任为他们配备始终可用、可靠且结构正确的数据。
公司需要你根据真实数据和由此产生的 KPI 做出明智的决策。如果你做得好，他们愿意给你优厚的报酬！我们来看看哪些技能需求量大，哪些因素对未来的职业前景起着很大的作用，以及如何接近技术面试。
需求中的技能
总的来说，通常很难给出任何真正通用的建议，但我总结了一些似乎最相关的技能，这些技能来自我在招聘广告中多次看到的内容以及我在该领域的经验。
1.成为 T 型职业者
从某种意义上来说，你理解数据库、云计算、数据仓库、大数据的一般概念，并且你至少知道 SQL、Python、Docker 和创建 ETL 的一些基础知识，这被认为是最好的目标。
同时，你应该在至少一个特定领域(T中的竖条)拥有更强的技能。例如，你可能真的很擅长编写数据操作的 Spark 或 Dask 或者你可能有你申请的公司所要求的某些特定的领域知识，这使你有别于其他申请人。
很多情况下， 熟知 SQL*+Python、Linux 和 AWS 的基础知识，已经可以让你到一个待遇还算不错的初级职位。*
2.用于处理数据的云服务
云计算革命性地改变了许多行业。作为一名数据工程师，您需要了解存储、计算、网络和数据库最重要的服务。如果你不太了解这些，我强烈建议学习亚马逊网络服务——即使你最终会使用谷歌云平台或微软 Azure，从 AWS 学到的概念可以很容易地应用到不同的云供应商，因为云供应商之间的许多服务是类似的，它们的概念实际上是相同的(例如。块存储 vs 对象存储 vs NFS* 。*
如果你是 AWS 新手，跟随这个链接，你可以在 AWS 上找到很棒的免费课程——它们都是直接由 AWS 提供的。你不需要为额外的证书付费——从我的经验来看，招聘人员和工程经理并不太在乎证书。他们希望有实践经验的人懂得很多，并能应用于商业问题。****
数据工程职位最重要的 AWS 服务有:
- 能够以编程方式与 S3 上的文件进行交互。下载和上传 CSV 或拼花文件
- 能够启动并 SSH 到一个 EC2 实例+了解一些 Linux 基础知识，能够使用 CLI 与之交互
- IAM :了解如何创建 IAM 用户，为相关服务附加一个策略，使用它来通过AWS CLI+IAM 角色如何工作的基础知识来配置编程访问
- VPC:你应该知道什么是 VPC、子网，并且知道它们是如何工作的。:您的 VPC 位于特定的 AWS 区域，并在该区域内的特定可用性区域中划分子网
- RDS: 知道如何运行或者至少如何与 Postgres 这样的关系数据库进行交互。
此外，了解 AWS Lambda ( 无服务器功能即服务)、ECS & EKS ( 大规模运行容器)、亚马逊红移(云数据仓库)、Athena ( 无服务器查询引擎以查询 S3 数据湖)以及 AWS Kinesis 或亚马逊 MSK ( 均用于实时流数据)也很有帮助。但是你可以先关注项目列表中的项目。Edx 的课程解释了其中的大部分。另外，**记得练习*** :通过 AWS 免费层，您可以(受限)访问那些基本服务，这样您就可以边玩边学了。*
3.构建 ETL 管道
作为一名数据工程师，需要整合各种来源的数据，将其转换成适合分析的形式，然后加载到某个数据湖或数据仓库中。你应该有一些创建 ETL 的经验。这并不意味着你必须为一些大公司的大数据项目工作过——甚至你在 Github 或博客帖子上分享的自我驱动项目也能让你在申请过程中走得更远，让你脱颖而出。
4.管理、监控和调度 ETL 管道
数据工程师的主要职责之一是确保数据总是可用的、可靠的并且具有适当的结构。为了实现这一点，您需要调度和监控您的数据管道。许多公司使用工作流管理系统，如 Apache Airflow 或 Prefect，所以了解其中一个可以大大提高你获得一份数据工程工作的机会。如果你想让了解更多，请阅读我以前的故事，比如这篇——在那篇文章中，我演示了如何在 AWS 上使用无服务器 Kubernetes 集群轻松建立工作流管理系统。
5.使用容器的能力:Docker & Kubernetes
如果您使用 Python，您知道您的代码可能会突然不再工作，因为您升级到了新的 pandas 版本。容器化是关键，能够处理容器化的工作负载是(任何)工程工作中最关键和最受欢迎的技能之一，因为它使您的代码自包含、无依赖性，并让您将代码部署到几乎任何环境中。**
6.了解基本概念
这与成为一名 T 型专业人员是一致的:你应该知道数据仓库、数据湖、大数据、REST APIs 和数据库的基础知识。在你的工作面试中解释不了大数据的 3v或数据仓库的特征会令人相当失望。此外，了解架构组件也是值得的。例如，在这篇文章中，我讨论了迁移到云时的数据仓库架构和关键考虑事项。
7.独立工作和学习的能力
这是不言而喻的:随着技术发展如此之快，关键是你是一个自我导向的学习者，你愿意不断学习和实验新的工具。这并不意味着你需要追随每一个炒作，而是你要保持开放的心态。
8.编码技巧
编程并不意味着你必须是一个“黑客”，你需要整天除了写代码什么都不做。更重要的是能够快速学习并知道如何编写好的抽象。在数据工程领域，这意味着你知道如何创建干巴巴的代码 ( 不要重复自己)，意味着:你不会从一个脚本向另一个脚本复制粘贴相同的代码，但是你知道如何以模块化和可重用的方式编写函数或类。干净的代码可以重复使用，扩展和参数化，易于维护，将节省您和他人的时间。
举个例子:我曾经在一家公司工作，那里几乎没有模块化。在几乎每个 Python 项目中，人们都在复制相同的代码来建立日志记录，连接到数据仓库并从中加载一些数据，或者建立 S3 客户端并从某个 S3 存储桶下载 CSV 文件。为了改进这一点，我创建了一个 Python 包:
- 它包含了几乎所有项目中需要的所有功能，我把它推到了一个新的 GitHub 仓库中
- 这个包可以通过
pip install git+https://github.com/<COMPANY>/<PACKAGE_NAME>.git安装在任何地方。
从长远来看，这个包为我们节省了大量的时间，并且使代码库更加整洁。
如果你是 Python 初学者，你不需要学习如何创建包。首先，如果你能写出好的 Python 函数，如果你知道如何使用基本的数据操作包，比如 Pandas ，这就足够了。
许多公司还寻找懂 Scala、Java、R 或 C ( 或你能想到的任何其他语言)的数据工程师——不管是什么编程语言，如果你理解了处理数据的基本数据类型，以及函数式编程和模块化的原则，你就能得到一份好得多的工作。
9.命令行
能够使用 Linux 操作系统并通过使用 bash 命令与之交互是最重要的技能之一，这将使你更加高效。
许多框架和云服务的工作方式是，我们通过声明性语言(如 Dockerfile 或 Kubernetes YAML 文件)定义我们的资源和服务，然后可以通过命令行界面( CLI ) 部署它们。这个范例通常被称为代码的**基础设施。例如，AWS CLI 允许您通过向 AWS API 提交 bash 命令来提供整个资源集群。其他云提供商(如 GCP 或 Azure* )也提供类似的命令行界面。***
10.软技能
有些人可能期望数据工程师是一个除了写 ETL 和处理数字什么也不做的人。但是在每份工作中，拥有与你的简历互补的技能是值得的。假设你有两个候选人:
- 一个优秀的程序员，但不擅长公开演讲，
- 一个普通的程序员，但同时也是一个伟大的演说家。
你会雇佣哪一个？许多公司会选择后者。雇主寻找全面发展的人，他们还拥有重要的软技能，比如项目管理、公开演讲、记录，或者擅长主持和组织活动。
在你的职业前景中扮演重要角色的因素
数据工程工作的薪水因地点、行业、所需技能和经验水平而异。下面，我列出了决定薪水和未来发展的 7 个最重要的因素。有些是显而易见的，但有些可能会让你大吃一惊:
- 地点——即使你申请了一份远程工作，公司也有可能根据你所在国家的标准支付你工资，以反映生活成本等
- 行业 —金融、汽车、科技或制药行业的公司通常比初创公司和电子商务公司的薪酬高得多
- 工作经验——招聘者对此很着迷，尽管工作经验本身并不能告诉你你从以前的工作中学到了多少…
- 专长 —经验的年限并不等同于专长(至少我是这么认为的)。通常人们只是擅长 Spark、Linux、Dask 或高级 SQL。如果你能证明你真的很了解它，那么 20 多年的拖放式 ETL 经验可能是值得的
- 实践经验——在工程领域，没有什么比实践经验更有价值。如果我们不能把知识应用到现实生活中，没有人能从我们的知识中受益。做个人项目，练习。不要只是看了一些东西就以为自己已经知道了— 如果没有应用，那都只是理论，很快就会忘记 。
- 学历 —我个人发现招聘人员并不像我预期的那样看重你的学历。当然，他们会检查你是否有学士或硕士学位，甚至是博士学位，但对于招聘人员来说，你曾就读于哪所大学或你的专业是什么并不重要。认证也是如此——许多技术经理更看重你使用特定工具或编程语言的实际经验，而不是你知识的任何官方证明，他们可能更喜欢在技术面试中亲自验证你的知识，而不是依赖证书。
- 你的特殊技能、领域知识和软技能比你想象的更重要。招聘人员通常会拒绝某人，因为他们觉得这个人不适合团队和公司的文化。
面试准备
我听说过这样的情况，申请人在电话面试中无法回答他或她申请的公司在做什么。还有，像:说说你自己和你为什么要换一家新公司这样的问题太常见了，提前想好就好。
另外，如果你打算申请，你应该准备一些 ( 基础 ) 技术问题。许多数据工程经理要求根据某些情况设计一个星型模式或者给你一些编码问题比如什么是 SQL 窗口函数、生成器、广播或者 Python 中的列表理解，Docker 映像和 Docker 容器之间有什么区别，或者你如何着手创建 Docker 映像和运行 Docker 容器。
最后，相信自己，保持自信。
结论
在这篇文章中，我们讨论了什么样的数据工程技能目前需求量很大，以及如果你在这个领域寻找一个入门级的职位，你需要知道什么。我们还列出了对数据工程职业前景起很大作用的因素，以及如何准备面试。我希望你可能会发现一些有用的。感谢您的阅读！
没有工作怎么找工作
在东京和伦敦做机器学习工程师，没有理科学士学位
越来越多的学生选择攻读包含一年工作实习的学位。这一年让学生将他们的知识融入到环境中，向专业人士学习，并获得现实世界的技能。这是新毕业生区别于其他年轻毕业生的绝佳方式。我强烈建议你去一所有学位课程实习年的大学。
最近参加了母校为金学者(现生)和金学者导师(校友)举办的联谊活动。晚上，学者们表示有兴趣为更小的公司、初创企业甚至慈善机构工作，这与他们的激情和对影响力的渴望非常吻合。我告诉他们，在我实习的那一年，我在东京的一家人工智能(AI)初创公司工作，有一次不可思议的经历。学者们想知道我是如何在一个遥远的地方的一家小型初创企业找到如此令人兴奋的职位的。对于学生来说，很难找到并获得分班机会。在不宣传职位安排或实习项目的公司找到机会就更难了。
大学充当了人才进入大公司的漏斗，而忽视了小公司。在我大学的第一年和第二年，我每周花 1 个小时为我们的实习申请和随后的实习做准备。在这些会议中，高盛、摩根士丹利、普华永道和野村证券等公司将与我们探讨如何在申请过程中取得成功。其中一些公司甚至在我们的校园里举行面试。只有在每周的电子邮件和偶尔的谈话中，我们才会收到其他为学生提供实习机会的小公司的信息。对于不想在大公司工作或找不到合适职位的学生来说，这有什么选择呢？
在这篇文章的结尾，我会和你分享一些我用来获得多份实习和工作的技巧。我希望你也能够使用这些技术来获得你理想的就业机会或工作。
“机会总是降临到创造机会的人身上”——查理大帝 Tha God
获得职位的策略
寻找非传统的工作机会比通过求职面试更少被讨论，也更困难。以下策略将重点帮助你找到你想要的工作机会。
通过永久职位发布申请
忽略你感兴趣的永久职位标志和招聘启事上的大部分要求。人们错误地认为，如果他们不符合几乎所有的要求，他们就不是合适的候选人。不要让这种担心阻止你在一家与你的价值观一致的公司申请你感兴趣的职位。事实是，大多数公司并不期望或要求你符合他们职位描述中的每一项要求。
当你申请一个永久职位时，在你的求职信的开头明确说明你想做为期一年的工作安排。你会惊讶地发现，许多公司都愿意给你提供实习机会。一年的时间框架允许一个实习生学习和做比其他短期实习生多得多的工作，而公司的成本却很低。
挖掘你的网络
“重要的不是你知道什么，而是你认识谁”——无名氏。
作为一名大学生，你的人际网络很可能由其他学生或者一些应届毕业生组成。目的是挖掘你的人脉，找到愿意把你介绍给你需要的人或者愿意把你介绍给有能力的人的人。这尤其适用于没有安置计划的公司。
朋友和家人
不要害怕向别人寻求帮助！你网络中的某个人可能已经能帮上忙了，你只需要开口。年龄较大且已经进入行业的朋友和家人可以成为知识和社会资本的财富。他们会认识更多可以介绍给你的业内人士。他们还会知道一些更小、更不知名的公司，以及职业发展和他们所在领域的工作专长。
如果你的家庭不从事工业，你可以向你的大学朋友的父母寻求帮助。很可能他们的父母在想要的公司工作，或者认识在那里工作的人。
领英
使用 LinkedIn 可以让你搜索人并直接给他们发消息。您可以按公司、教育程度和联系级别过滤结果。联系的程度告诉你你和某人有多亲密。一级关系是你已经认识的人，二级关系意味着你认识某个认识这个人的人，同样的逻辑也适用于更高级别的关系。使用这些过滤器可以把 LinkedIn 变成一个工具，找到愿意帮助你的人，同时最大化他们想要帮助你的机会。
例如，如果你想在 A 公司工作，你可以在 LinkedIn 上搜索 A 公司，根据大学和关系级别过滤结果列表。列表中的其他人将与您共享背景。当你把信息发送给公司 A 的员工时，你可以参考这个共享的背景，并继续寻求任何你需要的帮助。
社交媒体
社会企业、非政府组织、慈善机构和广播节目可能没有 LinkedIn，但他们可能有 Instagram 或 Twitter 帐户。如果有特定的行业或组织，你感兴趣的话可以看看他们的账号。从该帐户，您可以找到类似的帐户，让您发现许多组织从一个单一的。
Twitter 和 Instagram 可以用来直接向你所在领域的名人发送信息。如果他们回复了，你可以安排一次咖啡会议，或者向他们寻求建议。他们可能不会雇佣你，但肯定会给你指出一个可以雇佣你的人的方向。
互联网和社交网络的出现意味着我们有幸能够与全球各地的个人和机会保持联系。
当事人
参加聚会的好处是，你可能会与那些你在其他情况下从未接触过的人互动。这些互动可以帮助你分散你的思维，让你帮助别人，和/或让别人帮助你。
2017 年，我参加了世界上最大的人工智能会议 NeurIPS。参加完 AI 工坊的 Black，我们开了一个船会。在去船上的班车上，我和一位女士聊了起来，这位女士碰巧是伦敦一家名为 Selerio 的人工智能初创公司的首席技术官(CTO)和联合创始人。我问她是否有实习机会，她给了我一张名片，让我有空的时候给她发邮件。
我一结束在 Cogent 实验室的工作，就回到了伦敦。我给首席技术官发了一封邮件，我们进行了一次面试，然后我加入了。
这个团队由三位联合创始人和我组成。一个超小的、高度集中的团队致力于尖端技术。在 Selerio 工作让我加强了我在计算机视觉和深度学习方面的知识。
我的安置经历
在搜索安置机会时，我随机想到了谷歌“AI start-up Tokyo”，因为它结合了我感兴趣的两件事。
通过这次搜索，我找到了 Cogent Labs ，一个新的(大约 10-15 名员工)令人兴奋的世界级 OCR(光学字符识别)技术。他们没有实习生、实习学生或初级工程师的空缺，但我还是申请了。我花时间精心制作了一封非常好的求职信，然后通过他们的永久职位发布申请了职位。经过几次面试和一次编码测试，我通过了。
当我到达东京时，我的工作头衔从软件工程师变成了研究工程师，尽管我不知道这个职位是什么。被扔进深水区让我学到了很多关于人工智能和研究领域的知识。这段经历彻底改变了我的职业和兴趣的轨迹。
由于我在 Cogent Labs 的工作，我获得了前往加州长滩参加 NeurIPS 的旅行许可，这是世界上最大的人工智能会议(感谢人工智能团队中的布莱克)。
当我离开 Cogent 实验室时，已经有 60-70 人了。今年，我亲眼目睹了初创企业是如何成长和壮大的。在那里工作让我认识了一些了不起的人，并生活在一个不可思议的城市。
结论
连接每种技术的核心线索是它们都需要你积极主动。你必须走出去，寻求你想要的机会。在任何情况下，你都不应该坐以待毙。也就是说，去发那个 DM，电子邮件，LinkedIn 消息或者 tweet。不要等着别人教你，去学吧。
我希望你能够使用上面介绍的技巧来获得你理想的工作机会、实习或工作。
“把好奇心和激情作为一种工具，在生活中开拓出自己独特的道路。”——奥马尔·里德
如何用 Python 找工作
有这么多网站为不同领域的工作提供工作列表。即使你可能在某个职位上，你也应该总是 找工作，这可能会变得很无聊。但是这里有一个简单的解决方案可以让你轻松通过这么多的工作邀请！
我们将构建一个简单的 Python 脚本来获取工作列表，并根据您的喜好过滤它们。
这是一个简单的使用 Python，你不需要任何特定的技能来做这件事。我们将一步一步来，共同建设一切。
让我们直接投入进去吧！
编码
规划流程
首先，我们必须找到工作列表网站，我们将得到提供。
我选择一个名为的网站，实际上是。(这只是本教程的一个例子，但是如果你有一个更喜欢用来找工作的网站，请随意使用！)
我们要做的是:
筛选适合我们的工作标准，并对其进行筛选。
下面是我在美国搜索数据科学后 Indeed 的网站的样子。
在网站上搜索示例
最后，一旦我们有了数据，我们将把它打包成数据帧，得到一个 CSV 文件，可以很容易地用 Excel 或 Libre Office 打开。
设置环境
你将不得不安装一个 ChromeDriver 并与 Selenium 一起使用，这将使我们能够操纵浏览器并向它发送命令以供测试和使用。
打开链接并下载适用于您的操作系统的文件。我推荐最新稳定版，除非你已经知道自己在做什么。
接下来，您需要解压缩该文件。我建议进入文件，通过右键单击手动操作，然后单击“Extract here”。
在文件夹里面，有一个名为“chromedriver”的文件，我们必须将它移动到你电脑上的特定文件夹中。
打开终端，键入以下命令:
**sudo su** #enter the root mode
**cd** #go back to base from the current location
**mv /home/*your_pc_name*/Downloads/chromedriver /usr/local/bin**
#move the file to the right location
请插入您的实际电脑名称，而不是您的电脑名称。
要做到这一点，还需要几个库:
在终端中，您应该安装这些:
*pip3 install pandas*
Pandas 是一个快速、强大、灵活且易于使用的开源数据分析和操作工具，构建于 Python 编程语言之上。
sudo pip3 install beautifulsoup4
美汤 是一个 Python 库，用于从 HTML、XML 和其他标记语言中获取数据。
完成后，我们打开编辑器。我个人选择的是 Visual Studio 代号。它简单易用，可定制，并且对你的计算机来说很轻。
打开一个新项目，创建两个新文件。这是一个我的例子，看起来可以帮助你:
Visual Studio 代码—项目设置
在 VS 代码中，有一个“Terminal”选项卡，您可以使用它打开 VS 代码中的内部终端，这对于将所有内容放在一个地方非常有用。
当你打开它时，我们还需要安装一些东西，那就是虚拟环境和用于 web 驱动程序 selenium。在您的终端中键入这些命令。
pip3 install virtualenv
source venv/bin/activate
pip3 install selenium
激活虚拟环境后，我们就完全准备好了。
创建工具
我们已经设置好了一切，现在我们要编码了！
首先，如前所述，我们必须导入已安装的库。
*from* **selenium** *import* webdriver
*import* **pandas** *as* pd
*from* bs4 *import* **BeautifulSoup**
*from* time *import* **sleep**
用任何名字创建你的工具并启动 Chrome 的驱动程序。
class **FindJob**():
def __init__(self):
self.driver = webdriver.Chrome()
这就是我们开始发展所需要的一切。现在转到您的终端并键入:
python -i findJob.py
这个命令让我们把我们的文件作为一个互动的游乐场。浏览器的新选项卡将会打开，我们可以开始向它发出命令。
如果你想试验，你可以使用命令行，而不是直接输入到你的源文件中。只是用机器人代替自身。
对于终端:
**bot** = FindJob()
**bot**.driver.get('https://www.indeed.com/jobs?q=data+science&l=United+States&start=')
现在来看看源代码:
self.driver.get('https://www.indeed.com/jobs?q=data+science&l=United+States&start=')
创建我们将要使用的数据帧很容易，所以让我们从这里开始吧！
对于这个数据框，我们需要有“头衔”、“位置”、“公司”、“薪水”、“描述”都与我们要刮的工作相关。
**dataframe** = pd.DataFrame(
columns=["Title", "Location", "Company", "Salary", "Description"])
我们将使用这个数据帧作为 CSV 文件的列名。
这个网站的问题是，在每一页上都有 10 个工作机会，当你进入下一页时，链接会发生变化。一旦我明白了这一点，我就做了一个 for 循环来检查每一页，并在它完成后转到下一页。看起来是这样的:
*for* **cnt** in range(0, 50, 10):
self.driver.get("https://www.indeed.com/jobs?q=data+science&l=United+States&start=" + str(cnt))
我设置了一个计数器变量“cnt ”,并将这个数字添加到我的链接中，并转换为字符串。for 循环特别从 0 开始，一直到 50，迭代 10 次，因为这是每页显示的作业数。
当我们进入第一页时，我们需要一个接一个地抓取报价表，我们将这样做:
在上图中，您可以看到报价，它们被打包在一个表中，我们可以通过按键盘上的 F12 键或右键单击-> Inspect 找到该表。
看起来是这样的:
我们将通过类名找到该表，并输入以下行:
**jobs** = self.driver.find_elements_by_class_name('result')
它保存通过类名结果找到的所有 Web 元素。
一旦保存了这些数据，我们就可以创建另一个 for 循环，遍历表中的每个元素，并使用在表中找到的数据。
在我向您展示更多收集这些报价的代码之前，我们应该先看几件事情。
对于这一部分，我们将使用 BeautifulSoup ，因为我发现它的工作方式更快。
我们必须为 BeatifulSoup 设置一些东西，这些是我们给它执行搜索的实际数据，以及我们说它应该使用的解析器:
**result** = job.get_attribute('innerHTML')
**soup** = BeautifulSoup(result, 'html.parser')
一旦我们得到这些，我们只需要找到“汤”定义的变量中的元素，这只是 BeautifulSoup 准备的数据。
我们得到我们想要的数据帧的数据:
**title** = soup.find("a", class_="jobtitle").text.replace('\n', '')
**location** = soup.find(class_="location").text
**employer** = soup.find(class_="company").text.replace('\n', '').strip()
*try*:
**salary** = soup.find(class_="salary").text.replace(
'\n', '').strip()
*except*:
**salary** = 'None'
我用这种方式做了一个薪水部分，因为有时它没有被定义，我们必须为这个特定的单元格设置 None 或 empty。
因为我在终端中测试我的代码，所以您也可以打印到目前为止您所发现的内容:
print(title, location, employer, salary)
一旦这个脚本完成，它将看起来像这样:
数据框中缺少的最后一项是工作描述，之所以省略它，是因为为了获得工作描述的文本，您必须首先单击工作待遇。我是这样做的:
**summ** = job.find_elements_by_class_name("summary")[0]
**summ**.click()
**job_desc** = self.driver.find_element_by_id('vjs-desc').text
在我们得到所有应该放入数据帧的元素后，我们填充它:
**dataframe** = dataframe.append(
{'Title': title, 'Location': location, 'Employer': employer, 'Description': job_desc}, ignore_index=True)
****在你开始亲自测试之前，还有一件事我必须提一下。
一旦你进入网站的第二页，会有一个弹出窗口阻止你进一步点击任何东西！
我也想到了这一点，并创建了一个 try-expect，它将关闭弹出窗口并继续抓取数据！
**pop_up** = self.driver.find_element_by_xpath('/html/body/table[2]/tbody/tr/td/div[2]/div[2]/div[4]/div[3]/div[2]/a')**pop_up**.click()
for 循环完成后，我们将数据帧数据复制到名为“jobs”的 CSV 中:
dataframe.to_csv("jobs.csv", index=False)
我们完了！
完整的代码在我的 GitHub 账户下面:
用于作业抓取的简单 Python 脚本。通过在 GitHub 上创建一个帐户，为 lazargugleta/findJob 开发做出贡献。
github.com](https://github.com/lazargugleta/findJob)
后续步骤
你可以通过实现不同网站之间的比较，将这个脚本带到另一个层次，并在互联网上获得整体的最佳报价。
在此之前， 关注我 求更！😎
感谢阅读！
查看我的其他文章并关注我的媒体
当我有新文章发表时，请在 Twitter 上关注我**
使用 Python 获得通知的 3 种方式
现在，您可以在等待培训完成的同时从事其他项目
动机
作为一名数据科学家或程序员，处理数据和训练模型可能需要花费大量时间。不断地在屏幕上查看培训内容是低效的，尤其是当培训可能需要几个小时或几天的时候。有什么方法可以让你在使用 Python 完成训练后收到通知？
是的，您可以通过以下方式获得通知:
- 噪音
- 电子邮件
- 松弛的
这些方法中的每一种都只需要多 2 到 3 行代码。让我们看看如何使用这些方法创建自己的系统来获得通知。
制造噪音
如果你在等待训练结束的时候正在电脑旁边做一些事情，那么简单地在训练结束的时候制造一点噪音就是一个足够好的解决方案。
我在 StackOverflow 上找到了这段代码。下面的函数产生具有指定持续时间和频率的蜂鸣声
在 Windows 上
在 Linux 和 Mac 上
您需要安装sox来运行下面的代码
在 Linux 上，运行
sudo apt install sox
在 Mac 上，运行
sudo port install sox
只需在你的训练代码底部插入函数make_noise()
一旦训练结束运行，功能make_noise()将被执行，并会有一个噪音！如果你正在做别的事情，你可以停下你正在做的事情，检查你的训练结果。
电子邮件
制造噪音是获得通知的一个很好的方式，但是如果训练结束时你不在电脑旁边怎么办？另外，你可能想让你的队友知道训练何时结束。这就是发送电子邮件派上用场的时候。
有一个叫做 knockknock 的 Python 库，可以让你在训练完成或者训练过程中崩溃的时候得到通知。得到一个通知只需要增加两行代码。
要安装 knock-knock，请键入
pip install knockknock
您需要一个 Gmail 电子邮件地址才能使用 knock-knock 发送电子邮件。确保为 knockknock 打开不太安全的应用功能，以使用您的 Gmail 帐户。为了保护您的主 Gmail 帐户，最好创建另一个 Gmail 帐户来发送通知。
要发送电子邮件，只需在你的培训功能上方插入一个装饰器@email_sender()
您可以使用recipient_emails=[“youremail@gmail.com”, “your_teammate_email@address.com”]向一个人或一组人发送电子邮件。
如果没有指定sender_email，那么recipient_emails中的第一封邮件将作为发送者的邮件。
现在当你运行你的脚本时
python yourscript.py
培训结束后，您将收到一封电子邮件。
在你现有的脚本上试试这个，并检查你的电子邮件！
松弛的
Slack 是许多团队讨论工作和分享进展的公共平台。如果您正在使用 Slack，您可能希望将它发送到您公司的一个渠道，例如 channel #developer，以便在培训结束时通知您的开发团队。幸运的是，knock-knock 还允许你在训练结束时发送通知！
要向您的 Slack 发送通知，从启用并创建一个传入的 webhook 开始。然后简单地用webhook_url指定你的空闲房间的网址，用channel.指定要通知的频道
如果您想标记您的队友，请将user_mentions=[“your_slack_id”, “your_teammate_slack_id”]添加到@slack_sender
现在，当您运行您的脚本时，当代码完成执行时，一条消息应该被发送到您的 slack 通道！
结论
恭喜你！您刚刚学习了如何通过制造噪音、向您的电子邮件或 Slack 频道发送通知来获得通知。现在，您不再需要经常检查您的计算机来了解培训是否已经完成！您和您的队友可以在等待培训结束的同时从事其他项目。
如果您想使用电报信使、文本消息或其他方式获得通知，请选中 knock-knock 。
本文的源代码可以在这里找到:
有用的数据科学主题以及代码和文章的集合- khuyentran1401/Data-science
github.com](https://github.com/khuyentran1401/Data-science/tree/master/python/notification)
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
您可以收集数据或创建自己的数据
towardsdatascience.com](/how-to-create-fake-data-with-faker-a835e5b7a9d9) [## Datapane 简介:构建交互式报表的 Python 库
创建精美报告并与您的团队分享分析结果的简单框架
towardsdatascience.com](/introduction-to-datapane-a-python-library-to-build-interactive-reports-4593fd3cb9c8) [## VSCode 中数据科学家的 4 大代码查看器
让 YAML、JSON、CSV 和 Jupyter Notebook 为你工作，而不是与你作对
towardsdatascience.com](/top-4-code-viewers-for-data-scientist-in-vscode-e275e492350d) [## 高效 Python 代码的计时
如何比较列表、集合和其他方法的性能
towardsdatascience.com](/timing-the-performance-to-choose-the-right-python-object-for-your-data-science-project-670db6f11b8e) [## 数据科学家 Pytest
适用于您的数据科学项目的 Pytest 综合指南
towardsdatascience.com](/pytest-for-data-scientists-2990319e55e6)
如何获得一个令人惊叹的终端
在 Windows 和 Linux 中；包括提示、字体和颜色
使用 Agnoster 主题的鱼壳示例。它在 Gnome 终端中执行，该终端使用 Ubuntu Mono Powerline 作为字体。这幅图像是由马丁·托马斯创作。
作为一名拥有 10 多年经验的开发人员，我喜欢使用 shell。命令永远不会改变，我可以创建自定义的快捷方式，这是可靠和快速的。不过，默认设置并不太好。看完这篇文章，你就知道如何在你的系统上获得一个牛逼的 shell +终端了。
术语
外壳是实际执行命令的部分。终端是一个运行外壳的包装器。
终端是你设置字体、字体大小、配色方案、多标签支持的地方。终端模拟器的例子有 KDE 上的 GNOME 终端、 Konsole 、终结器和 XTerm 。在 Linux 上，我建议保留默认值。在 Windows 上， Windows 终端牛逼。在 Mac 上，我听说过关于 iTerm 2 的好消息。
Linux 上的四个终端模拟器(Gnome 终端、Konsole、XTerm、Terminator)。XTerm 不直接支持制表符。其他有 2 个标签打开。它们都运行 Bash shell。这幅图像是由马丁·托马斯创作。
外壳存储输入命令的历史，定义如何设置环境变量，如何切换当前目录。Linux 上 shells 的例子有 ZSH 、 Bash 、 fish 。在 Windows 上，典型的 Shell 是 PowerShell 。您可以通过执行echo $0来查看您正在运行哪个 shell。在 Linux 上，最有可能是 Bash。
Gnome 终端中的三个 Linux shell(ZSH、Bash、fish)。我大量定制了 ZSH 外壳；Bash 和 fish 显示默认。您可以看到 fish 有一个内嵌的自动建议特性，这是其他两种 shells 所没有的。图片由马丁·托马斯提供。
每个外壳都有一个提示。提示是写在光标前的内容。它通知您可以输入命令，并给出有用的上下文信息。在上面的例子中，提示包含用户名moose、当前计算机pc08、当前工作目录~/GitHub/MartinThoma/flake8-simplify、活动 git 分支feature/19以及存在修改的事实。
字体
不管你拿什么，字体很重要。你可能想有一个等宽字体。你肯定想要一个电力线字体；相信我。电力线字体使您的 shell 可以使用看起来像图像的字符。它可以使提示方式更好。
我喜欢 Ubuntu Mono 和 Droid Sans Mono :
上面一行是 Ubuntu Mono，下面的例子是用 Droid Sans Mono 写的。我更喜欢 Ubuntu Mono，但两者都是合理的字体。图片作者:马丁·托马斯
还有像 Fira Code 或者 Jetbrains Mono 这样的“编程字体”。我不喜欢它们，因为它们让我更难真正知道写的是什么。不过，它们看起来不错。
Windows 终端
首先，确保您已经安装了 Windows 终端:
[## 获取 Windows 终端— Microsoft 商店
Windows 终端是一个现代的、快速的、高效的、强大的、多产的终端应用程序，适用于…
www.microsoft.com](https://www.microsoft.com/en-us/p/windows-terminal/9n0dx20hk701?source=lp&activetab=pivot:overviewtab)
启动终端并导航到设置。就是这个向下指的小“箭头”:
点击“设置”。截图由马丁·托马斯拍摄
您应该看到一个 JSON 文件，您可以根据自己的喜好进行更改。我有以下内容:
下载并安装所有 4 种"DejaVu Sans Mono power line"字体。在我所知道的所有系统上，安装一个字体都是通过双击来完成的。然后一个有“安装”按钮的窗口打开。
Linux 和 Windows 终端:Aminal
Aminal 是一个用 Go 编写的终端模拟器。它可以在 Linux、Windows 和 Mac 上使用。它允许通过配置文件进行配置，并在其中包含颜色和键盘快捷键。
首先，你需要在你的系统上安装和配置 Go。在 Ubuntu 上，它是这样工作的:
$ sudo apt-get install golang libgl1-mesa-dev xorg-dev
$ export GOPATH="$HOME/go"
$ export GOBIN=$(go env GOPATH)/bin
然后，您可以安装并运行 aminal:
$ go get -u github.com/liamg/aminal
$ aminal
Linux: Gnome 终端
Gnome 终端可以通过编辑配置文件来定制。这里我设置了Ubuntu Mono derivative power line Regular的字体大小为 12。
图片作者:马丁·托马斯
该命令被设置为zsh，因为这是我最喜欢的 shell。
图片作者:马丁·托马斯
颜色设置为曝光深色(从左到右，顶线/底线)
- 背景:
#2e3436/#555753 - 深红色:
#cc0000/浅红色:ef2929 - 深绿色:
#4e9a06/浅绿色:#8ae234 - 深黄色:
#c4a000/浅黄色:#fce94f - 深蓝色:
#3465a4/浅蓝色:#729fcf - 深紫色:
#75507b/浅紫色:#ad7fa8 - 深青色:
#06989a/浅青色:#34e2e2 - 深灰色:
#d3d7cf/浅灰色:#eeeeec
Linux Shell: fish
安装落鱼外壳；
sudo apt-get install fish
将终端模拟器中的默认 shell 更改为fish。在 Gnome 终端中，它被称为“自定义命令”。
然后安装“ 哦我的鱼 ”:
curl -L https://get.oh-my.fish | fish
并将主题设置为未知者:
omf install agnoster
omf theme agnoster
关于 fish shell 的酷炫特性，请阅读 Alec Brunelle 的为什么我使用 Fish Shell 而不是 Bash 和 Zsh 。
别名
让终端变得强大的一个核心部分是让常用命令变得简短。为此，您可以为命令创建一个别名，即原始命令的较短版本。最常见的例子是将目录向上更改一级。比如你在/home/user/foo/bar，你想去/home/user/foo。在大多数 shells 中，您必须输入cd ..。我喜欢将其缩写为..。所以我有了别名alias ..='cd ..'。语法可能会有所不同，这取决于您的 shell。对巴什、ZSH 和费什来说
alias short='long'
对于巴什，你将它们插入~/.bashrc，对于 ZSH，插入~/.zshrc。在鱼类中，则不同。
以下是我喜欢的一些别名:
# Shorten things
alias ..='cd ..'
alias ...='cd ../../'
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'
alias c='clear'# If your terminal supports colors, use them!
alias ls='ls --color=auto'
alias grep='grep --color=auto'
alias fgrep='fgrep --color=auto'
alias egrep='egrep --color=auto'
alias diff='colordiff'# Works only if you have notify-send
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
摘要
- 确保你有一个合理的终端模拟器。我建议Linux 用 Gnome 终端，Mac 用 iTerm 2 ，Windows 用 Windows 终端。
- 安装一个好的电力线字体像 Ubuntu Mono 电力线 。
- 根据您的喜好调整终端仿真器的字体、字号和配色。
- 安装好外壳。我建议 Linux 用鱼，Windows 用 PowerShell 。
- 根据你的需要调整你的外壳的提示。我喜欢不可知论者主题。
如何用神经风格迁移获得漂亮的结果
深入探究使神经类型转移起作用的技巧
我最近对用机器学习生成中等轮廓图片产生了兴趣。这让我深深陷入了神经类型转移的领域。虽然 NST 在概念上很容易理解，但生成高质量的图像却异常困难。有许多错综复杂的细节和未提及的技巧，你必须正确实施，以获得巨大的成果。在本文中，我们将深入探讨神经类型转移，并详细检查这些技巧是什么。
在媒体和其他出版物上有许多关于 NST 的可靠介绍，所以我不会浪费任何时间来复习基础知识。如果你不知道 NST 是什么(或者你想跟随这篇文章),一个很好的开始方式是查看官方 PyTorch 教程。不幸的是，与许多其他介绍性文章一样，最终的实现充其量只能产生一般的结果(图 1)。我们将在接下来的几节中更新教程代码，以提高传输质量，但首先我们要谈一个话题。
本文的所有附带代码都可以在my GitHub上找到。
图 1:两种不同实现的神经风格传输质量的比较。(左下角)我们要匹配其内容的图像。(左上)我们想要匹配其样式的图像。(中间)使用 PyTorch 教程实现的样式传递结果。(右)使用本文中详细介绍的实现的风格转换结果。生成的图像在视觉上具有更高的质量，并且更忠实地匹配风格图像的风格。
题外话:为什么克矩阵测量风格？
大多数介绍神经类型转移的 Gatys 等人的论文简单易懂。然而，一个没有解决的问题是，为什么 Gram 矩阵是表示风格(即纹理)的自然方式？
在高层次上，Gram 矩阵测量同一层中不同特征地图之间的相关性。特征映射只是卷积层的激活后输出。例如，如果一个卷积层有 64 个滤波器，它将输出 64 个特征图。然后，Gram 矩阵测量图层中每个要素地图和每个其他要素地图之间的相关性(相似性),而不必关心精确的像素位置。为了说明为什么这是一个合理的纹理测量，假设我们有两个过滤器，一个检测蓝色的东西，一个检测螺旋。我们可以将这些滤波器应用于输入图像，以产生 2 个滤波器图，并测量它们的相关性。如果过滤贴图高度相关，那么图像中出现的任何螺旋几乎肯定是蓝色的。这意味着图像的纹理由蓝色螺旋组成，而不是红色、绿色或黄色螺旋。
虽然这个解释仍然让我有点不安，但在纹理合成社区，Gram 矩阵对应于样式似乎是一个被广泛接受的事实，正如这篇文章所解释的。此外，我们不能否认，我们使用 Gram 矩阵得到的结果令人印象深刻。
修复 PyTorch 实现
提高传输质量的第一步是修复 PyTorch 教程的实现。本教程试图忠实于 Gatys 等人的论文，但在此过程中遗漏了一些东西。首先，论文的作者用一个AvgPool2d代替了MaxPool2d，因为他们发现它产生了更高质量的结果。另一个细节是，本教程计算卷积输出的ContentLoss和StyleLoss，而不是 ReLU 激活。这更像是吹毛求疵，因为我没有注意到在我的实验中使用卷积和 ReLUs 之间有很大的区别。
图 VGG19 网络及其层(来源)。
教程和论文之间最惊人的区别是“错误的”层分别用于ContentLoss和StyleLoss。我在引号里写错了，因为层的选择很大程度上是主观的，很大程度上取决于什么能产生最令人愉快的风格。也就是说，我们可以用一些经验法则来指导我们的决定。当测量内容相似性时，当在content_img和生成的input_img之间存在像素完美匹配时，较低层倾向于最高度激活。我们越深入网络，这些层就越不关心精确的匹配，相反，当特征通常处于正确的位置时，它们就会高度激活。为了可视化每一层最关心的是什么，我们可以设置style_weight=0并使用不同的层作为content_layer在随机的input_img上运行训练过程。
图 3:可视化 VGG19 网络不同层响应的内容。网络中更靠右的层更深。
本教程使用第四个卷积(图 2 中的conv2_2)作为内容层。正如我们在上面的图 3 中看到的，这可能是一个太低的层，不能用于内容，因为网络仍然关心在这个深度匹配像素。Gatys 等人用conv4_2代替，它更关心整体的特征排列，而不是单个像素。
就风格而言，较低层对小的重复特征作出反应，而较高层则捕捉更抽象的整体特征。因此，为了传递style_img的整体风格——从底层细节到总体主题——我们应该在网络中包含所有深度的层。本教程使用前 5 个卷积层，但这些都是相当低的网络，不太可能捕捉全局特征。Gatys 等人使用了conv1_1、conv2_1、conv3_1、conv4_1和conv5_1，这是一种跨越整个网络层次的良好分层分布。我们可以使用我们用于内容的相同方法来可视化每一层选择的优化样式。为此，我们设置content_weight=0，指定我们想要使用哪个style_layers，并随机运行训练过程input_img。
图 4:(左)PyTorch 教程中选择的图层产生的样式。(右)在 Gatys 等人的论文中选择的图层产生的风格。
正如预期的那样，由教程层优化的样式捕获了低级的、重复的特征，但是未能捕获高级的、全局的特征。
提高传输质量
到目前为止，我们已经实现的修复应该让我们相当接近 Gatys 等人的论文中看到的质量。从这里，我们将更深入，看看接下来我们可以采取什么措施来生成更好的图像。
我从论文中改变的第一件事是将优化器从L-BFGS切换到Adam。在论文中，作者声称L-BFGS导致更高质量的传输，但我在实验中使用Adam时没有注意到差异。此外，Adam似乎更稳定，尤其是在训练大量步数或大幅度style_weight时。在这些情况下，L-BFGS似乎NaN出来了，可能是由于爆炸梯度(虽然我没有看得太深)。
另一个小调整是将mse_loss(即 L2 损失)切换到l1_loss。我想不出一个很好的理由来使用 L2 损失进行风格转换(除了在 0 的可微性)，因为平方项严重惩罚离群值。正如前面提到的，我们并不真正关心像素的精确匹配，可以容忍生成的图像中有一些异常值。事实上，当样式和内容特征融合在一起时，离群值甚至可能会导致视觉上更令人愉悦的结果。最后，特性可视化——相关主题的必读文章——的作者也使用l1_loss完成他们的任务，可能是出于类似的原因。
实际上，许多用于生成高质量特征可视化的技巧优雅地转移到了神经风格转移上。事实上，FV 和 NST 在概念上非常相似，只是它们生成input_img的方式不同。在 NST 中，input_img经过优化，以与content_img和style_img相同的方式激活网络中的不同层。另一方面，FV 不使用content_img和style_img，而是生成一个input_img，最大限度地激发不同层中的神经元。
图 5:由激进的数据扩充引起的生成图像右上方边缘的旋转伪影。
我从 FV 借鉴的一个技巧是在input_img上使用数据增强。这与常规的分类任务完全一样:在每一步，我们对input_img应用一些增强(例如，旋转、裁剪、调整大小等。)然后在模型中运行并计算损失。通过在每一步增加input_img，我们迫使input_img产生对微小扰动具有鲁棒性的特征。这些健壮的特征应该包含较少的高频伪像，并且通常看起来更具视觉吸引力。然而，我发现特性可视化文章中使用的增强非常激进，必须适当地缩小它们。即便如此，在生成的图像边缘仍然会出现一些旋转伪影(图 5)。消除这些伪像的最简单的方法是将图像向下裁剪几个像素🙃。
最后，我做的最后一个修改是将content_layer换成conv3_2，而不是 Gatys 等人使用的conv4_2。我读的大多数文章也推荐conv4_2，尽管我发现在conv4_2细节会被洗掉，而且风格会压倒生成图像中的内容。另一方面，conv3_2仍然保持了这些细节，而没有像下层那样过度牺牲像素的完美性。事实上，我们可以通过再次查看图 3 来确认这一点。
进一步提高质量
我们现在已经讨论了我在我的神经风格转换代码中实现的所有技巧。在这一点上，我们已经大大提高了原始 PyTorch 教程的传输质量。此外，content_weight和style_weight对于特定的图像选择更加健壮。例如，在 PyTorch 教程中，我发现如果没有适当的调整，一组图像上的好的style_weight不容易转移到另一组。
也就是说，通过尝试去除生成图像中的高频噪声，有可能获得更好的结果。我遇到的最有趣的方法来自文章可微分图像参数化——另一篇涉及类似主题的必读文章。在本文中，作者通过首先在(去相关)傅立叶空间而不是(相关)像素空间中对其进行参数化来生成input_img。由于input_img是通过梯度下降生成的，去相关输入充当预处理程序，通过允许梯度下降更快地找到最小值，使优化更容易(类似于在监督学习任务中移除相关特征)。我还不完全清楚为什么会导致更高质量的传输，除此之外，像去相关空间中的最小值这样的手动波动解释更广泛、更可靠。
一种更简单的方法是通过直接或间接抑制高频噪声。通过将input_img的总变化损失加到优化目标上，可以直接惩罚噪声。相反，可以通过在每个梯度下降步骤之后模糊input_img，或者在将梯度应用到input_img之前模糊梯度，来隐式地惩罚噪声。这两种方法的一个问题是它们也不利于真正的高频特征。这可以通过在训练期间缩小总变化损失或模糊量而得到某种程度的改善。
结论
如果你已经做到这一步，你现在应该知道很多关于用神经风格转换生成美丽图像的知识。虽然在概念上很简单，但是获得高质量的结果需要非常小心。我最初的目标是使用机器学习来生成中等轮廓的图片。经过多次反复试验，我想我偶然发现了一些看起来相当惊人的东西。对我来说，整个过程中最令人兴奋的部分是神经网络的端到端可微性。只需很少的努力，我们就能够“反转”一个最初被训练来区分猫和狗的模型，并使用它来生成无数不同风格的图像。尝试在随机森林中这样做。
如果你喜欢这篇文章，请关注我，以便在我发布新内容时得到通知。所有代码都可以在我的 GitHub 上找到。
欧根·霍塔杰，
2020 年 3 月 27 日
脚注
如何更好地进行评估
按时交付项目的一些技巧
在 Unsplash 上由 Veri Ivanova 拍摄的照片
很难估计。每个开发人员都在努力完成这项任务。原因很简单:开发人员被要求评估他们以前从未做过的事情。除非它是一个代理机构，使新的品牌应用程序从一个白色标签完全相同的功能。
为了更好地描述为什么评估是困难的，想象一下下面的场景:一个工程师必须使用他过去从未使用过的特定框架来实现注册功能。然而，随着多年经验的积累，估计会变得更加精确。但是不确定性并没有完全消失。你如何通过评估取得成功？
按小时估算
有一次，我在一家公司工作，在那里我们对评估和时间跟踪有非常严格的规定。对于我们得到的每一个新的特性请求，我们必须精确地估计它。有一条规则:任务不能超过 2 小时。如果任务超过 2 小时，我们必须把它分成更小的子任务。任务粒度为 15 分钟，意味着任务不能短于 15 分钟。否则，花更多的时间在报告上而不是实际任务上是没有任何意义的。
所有这些听起来像是工作中的开销，会产生压力感。另一方面，它教导纪律和责任。没人说过登录功能需要 2 个小时。处理这种回答很容易。尝试向开发人员解释，所有超出估计的工作都不会得到支付。这不一定会发生，但至少工程师在做下一次评估时会采取负责任的行动。我们都知道它通常是如何发生的:我们忘记了一些微小的细节，而这个功能已经完成了 4 个小时。是最初估计的两倍。
因此，良好的分析和关注细节是提高评估质量的关键。
建议: 提前花些时间分解每一个特性请求。考虑每一个可能的用例，包括错误处理。如果网络调用失败，是否有错误对话框？用户可以重试吗？
按天估算
另一种可能的估算方法是将它们四舍五入到一整天。例如，实现注册功能- 2 天，实现登录功能- 1 天。与第一种估计方法相比，这种方法产生的时间压力较小。如果你对你的估计没有信心，你应该试着按天来估计。
如果遗漏了什么，按天估计会有一些时间缓冲。如果注册功能花了 15 个小时，而你计划花 2 天，那么你为自己节省了一个小时。你不必急于在 6 小时内完成任务，如果你在 1 天内完成它。由于有足够的时间，这种方法提供了在构建特征时涵盖所有可能场景的机会。
有些任务需要一个小时才能完成。这些任务以及其他类似的任务需要收集。这样我们就可以知道我们需要一天的时间来完成 3 项任务。
建议: 把每一项任务看成一个完整而独立的特性。然后试着评估你会用多少个 8 小时的工作日来完成它。1 天的时间足够建造它吗？为什么需要 3 天而不是 2 天？不要犹豫，增加一些缓冲。
根本不用估计
有一次，我加入了一个团队，在一个伟大而专业的 scrum 大师的领导下。他已经有多年处理流程和应用最新敏捷方法的经验。最让我吃惊的是，他告诉我，他的团队没有估计。没有日期，没有故事点，没有 t 恤尺寸。没什么。我的第一个问题是“这个团队如何在没有估计的情况下按时完成每个冲刺？”。
和他好好商量了一下，我明白了。每隔一周的周一，团队都会制定冲刺计划。他们定义了他们想要在下一次冲刺中完成的目标。backlog 中的故事由产品负责人预先确定优先级。所以团队从待办事项列表的顶部抽取一些。
但是谁来控制应该拍多少故事呢？答案是一个 scrum 高手。他每次冲刺都在做统计。基于这一点，他观察到大多数故事的大小大致相同。每个故事平均需要 3 天完成，在 2 周的冲刺中，团队能够交付 3 个故事。为了更好地理解这个系统，这里有一个来自艾伦·霍勒伯的精彩解释讲座。
所以在这种情况下，团队对评估一无所知。scrum master 试图控制故事的大小，每当它看起来太大时，他会根据与产品负责人的讨论将它分成更小的故事。
建议: 如果团队在估算上有困难，将它们转化为计算要完成的故事。找一个人来委派这个责任。这个人将负责评估要做的工作量，而不是估计。
很难估计。没有人喜欢做评估，因为这是对我们不确定的事情的承诺。提高评估质量的关键在于实践。如果你多练习，从所有错过的截止日期中学习，你将学会如何做出准确的估计。
如何用 Python 从 API 获取数据🐍
数据科学家需要数据。没有数据，你就没有模型、仪表板或应用程序。在本文中，您将学习如何查询 API 来获取构建酷东西所需的数据！🚀
资料来源:pixabay.com
说数据是新石油有点老生常谈了。我更愿意把它看作像风能一样的可再生资源。💨无论你选择哪种能源作为你的隐喻，你都想利用它的一些力量！⚡️
理想情况下，您可以直接访问您控制的文件或数据库中的数据。如果情况不是这样，幸运的话，这些数据可以通过面向公众的 API 获得。☘️
在本文中，我将向您展示使用 Python 从公共 API 获取数据的步骤。🐍首先，我将向您展示如何以及在哪里寻找 Python API 包装器，并分享最大的 Python API 包装器库。🎉
然后，我将向您展示如何使用请求库从没有 Python 包装器的 API 中获取您想要的数据。
如果您想要的数据在一个网站上，但不能通过面向公众的 API 获得，那么有几种选择来抓取它。何时使用哪个刮包是我正在做的另一篇文章。关注我确保你不会错过！😁
我们往下钻吧！
已经钻好了。资料来源:pixabay.com
蜜蜂
面向外部的应用程序编程接口(API)通常用于提供大块数据。你只需要知道如何使用 API。
一个组织创建一个面向公众的 API，目的是让您使用它。他们的动机从理想主义到唯利是图，可能包括以下内容:
- 希望你能建造一些东西来改善这个世界。🌍
- 希望你会使用他们的免费计划，然后需要如此多的数据或需要数据如此频繁，你会付钱给他们访问更多的数据。💵
- 如果他们不给你一个直接的链接，你会从网站上抓取数据，所以他们可能会减少他们的服务器开销，让你的体验更好。😀
API 可以被很好地记录，很差地记录，或者介于两者之间。如果你幸运的话，它们是有据可查的。如果你真的幸运的话，有一个 Python 包装器可以运行，并且有很好的文档记录。🎉
查找 Python API 包装器
为您需要的 API 找到 Python 包装器可能很棘手。这是我建议的方法。
Python API 包装器列表
我在 GitHub 维护我认为最大的 Python API 包装器列表。 Real Python 做了一个很好的列表，由 johnwmiller 分叉并更新。我稍微清理了一下列表，然后，鉴于冠状病毒隔离终止了我的孩子从足球裁判⚽️和照看猫中赚钱的能力🐈我付钱让他们帮忙改进名单。我们更新和扩充了这个过时的列表，因为我在别处找不到一个好的可用 API 包装器列表。😀
如果您发现列表中缺少一个 Python API 包装器，请编辑 ReadMe 文件并提交一个 pull 请求。如果您是新手，这里有一个在 GUI 中编辑 GitHub Markdown 文件的快速指南:
点击右上角的铅笔图标，进行修改(这里有一个可爱的降价教程，如果你需要的话)。然后点击页面底部的绿色提议文件更改按钮。然后点击绿色的创建拉动请求按钮，总结更改，并点击底部的绿色创建拉动请求按钮。谢谢大家！🎉
仅供参考，我经常在我的 Data Awesome 邮件列表中突出 Python 包。在下一期文章中，我将重点介绍由冉阿让撰写的 yfinance 。yfinance 包装了雅虎金融 API。你可以用一行代码将股票市场数据读入熊猫数据框。🚀
如果 Python API 包装器列表中没有您需要的东西，我建议您使用通常的方法在互联网上查找。🕸
谷歌一下
一个好的搜索引擎是开发者或数据科学家最好的朋友😁
具体来说，我会搜索我正在寻找的 Python 包装器的名称。GitHub 链接可能是最有成效的。如果回购协议在过去几年中没有更新或者已经存档，那么成功使用包装器的可能性就不大。那样的话，我建议你继续找。👓
查看 API 网站
如果幸运的话，您正在使用的 API 的网站可能会列出各种编程语言中可用的包装器。值得一试。😃
直接使用 API
当没有 API 包装器时，你必须直接查询 API。我建议你使用 Python 请求库。
使用请求
古老的请求库是久经考验的从 API 获取信息的方法。Requests 由 Kenneth Reitz 创建，受 Python 软件基金会保护。在撰写本文时，这是下载量最大的 Python 包。👍
使用pip install requests从命令行将请求安装到您的环境中
然后导入使用。使用 HTTP 动词 get 和 post 作为返回所需信息的方法。大多数情况下，您将使用 get。下面是如何查询 GitHub API:
import requestsr = requests.get**(**'https://api.github.com/events'**)**
您可以将参数作为字典传递给 get 方法。这是快速入门指南。
当你发出一个 get 请求时，你经常会得到 JSON。您可以使用请求。json() 快速将 json 变成字典的方法。
my_dict = r.json()
用请求提炼数据查询比提炼石油要快得多😀资料来源:pixabay.com
Requests 在幕后使用了 urllib3 库并对其进行了增强。您还可以使用其他库，但是 requests 非常可靠，易于使用，并且为大多数 Python 程序员所熟悉。我建议您在想要进行 API 调用并且 API 没有 Python 包装器时使用请求。
说到这里，如果你最喜欢的 API 没有 Python 包装器，我鼓励你考虑做一个。👍
制作 Python API 包装器🛠
制作 API 包装器是学习 Python 打包技能的好方法。我写了一个指南让你开始制作 Python 包并在 PyPi 上发布。
我创建了py libraries，这是一个用于 Libraries.io API 的 Python 包装器。制作它是一次很棒的学习经历，回馈给我受益匪浅的开源社区是一件很酷的事情。🚀
关于 API 你应该知道的其他事情
API 键、速率限制和 cURL 是您应该熟悉的另外三个术语。
API 键🗝
您通常需要一个 API 键来查询 API。API 文档应该清楚地说明如何获得密钥。大多数时候，你可以通过在你想要其数据的组织的网站上注册来免费获得一个。如果你想要大量的数据或者经常需要，你可能需要支付特权。
钥匙。资料来源:pixabay.com
您可以将 API 密钥存储在环境变量中。这里有一个在 Mac、Linux 和 Windows 上设置环境变量的指南。按照惯例，环境变量名都是大写的。说到所有的大写:
在任何情况下，⚠️都不会在 GITHUB 或其他可公开访问的在线版本控制系统中存储 API 密钥。⚠️
你的钥匙可能会被盗和滥用——尤其是当你的账户有信用卡的时候。☹️
要在 Python 中访问保存 API 键的环境变量，请导入os模块并从字典中获取值，该值的键与环境变量的名称相匹配。例如:
import osos.environ.get('MYENVIRONMENTVARIABLE')
这段代码返回您的 MYENVIRONMENTVARIABLE 环境变量的值。
如果您将在云上的应用程序中使用您的密钥，您应该研究一下秘密管理，正如这里讨论的。
说到远离麻烦，我们来讨论一下费率限制。
费率限制
需要限制一下。😲资料来源:pixabay.com
许多 API 限制在给定的时间内 ping 它们的次数，以避免支付大量额外的服务器。为了避免超过这些限制，您可以使用 Python time 库并将您的请求放入一个循环中。例如，这里有一个简短的代码片段，它在请求之间等待五秒钟。
import time
import requestst = 0
my_url = 'https://example.com'while t < 100:
r = requests.get(my_url)
time.sleep(5) # wait five seconds
t += 1
print(r.json())
这段代码的目的是向您展示如何使用 time.sleep() 来避免可能使您超过速率限制的不间断 API 端点 pings。在真实的用例中，您可能希望以某种方式保存数据，并使用 try…except 块。
卷曲
这是一个使用 Python 和 API 的指南，但是你应该知道你可以用流行的 cURL 程序从命令行查询 API。默认情况下，运行最新 Windows 10 版本的 MAC 和机器上都包含 cURL。如果你想学习 cURL，我建议你去看看免费的电子书征服命令行，作者是 Mark Bates。🚀
概述
如果你想从一个 API 中获取数据，首先尝试找到一个 Python 包装器。点击查看 Python 包装器列表。如果失败，谷歌搜索，并检查 API 网站。如果你在 GitHub 上发现我的列表中缺少一个 Python 包装器，请添加它。😀
如果没有 API 的 Python 包装器，就使用请求库。如果您有时间，可以考虑创建一个包装器，这样所有 Python 用户都可以受益。❤️
不要忘记保护您的 API 键的安全，避免达到速率限制。🔑
包装
您已经学习了使用 Python 查找和使用 API 的工作流。您正在获得做大事所需的数据！🚀
我希望这篇关于在 Python 中使用 API 的指南对你有用。如果你有，请在你最喜欢的社交媒体上分享，这样其他人也可以找到它。👍
我撰写关于 Python 、 SQL 、 Docker 、数据科学以及其他技术主题的文章。如果你对此感兴趣，请关注我，在这里阅读更多。😀
驾驭风！资料来源:pixabay.com
如何使用 R 获得每个 NBA 球员的数据
篮球| NBA
nbastatR 的美丽、简单和快速
照片由 JC Gellidon 在 Unsplash
**In this article you'll learn how to:**
- install and load nbastatR
- get every NBA player loaded into R
- get a player's career statistics
NBA 赛季暂停了。你可以把它看成一个负面的东西，然后重复看《最后的舞蹈》。
或者，你可以将此视为一个机会，最终学习如何在 NBA 上做一些数据科学，并真正了解联盟和球员的历史。
安装和加载
有几个 R 包可以让你抓取 NBA 数据。我使用名为 nbastatR 的方法，因为在我看来它是实现最好的方法。要安装该软件包，请使用以下命令:
devtools::[install_github](https://www.rdocumentation.org/packages/devtools/topics/reexports)("abresler/nbastatR")
那么你需要做的就是使用:
[library](https://www.rdocumentation.org/packages/base/topics/library)(nbastatR)
基本功能:获得每个 NBA 球员
nbastatR 中有很多函数，但让我们首先使用以下函数获得每个 NBA 球员的矩阵:
[assign_nba_players()](http://asbcllc.com/nbastatR/reference/assign_nba_players.html)
这将为每个 nba 球员加载一个名为“df_dict_nba_players”的 tible。永远不会。
每个观察都是一个玩家，每个玩家有 17 个变量。直接相关的是:
- namePlayer :玩家的名字(咄)
- idPlayer: 玩家的 id 号(注:这个其实超级重要)
- isActive: 表示玩家是否正在玩游戏
您可以在闲暇时探索其他变量。重要的是，你现在知道每个球员的身份证号码。虽然如果使用球员姓名，nbastatR 中的许多功能仍然可以工作，但一些 NBA 球员有类似的姓名，很容易出现拼写错误。如果你使用一个玩家的 id，你永远不会有这些问题。
获取玩家数据集
让我们用 nbastatR 的“球员 _ 职业生涯”函数来做一个快速获取勒布朗·詹姆斯数据的例子。
players_career 函数至少只需要一个输入:
- 玩家标识符
您可以在 R 中使用
players_careers(players = c("LeBron James"))
注意:你可以使用 players _ careers(players = " LeBron James ")来代替，但我把它作为一个列表，以防我想找到不止一个球员的数据。
调用此函数将返回 8 个表:
- dataplayercarertotalsallstarseason
- dataPlayerCareerTotalsPostSeason 季
- 数据播放目录定期
- 季后赛
- 数据播放季节
- dataplayersaasontotalsallstarseason
- 数据播放季节总计发布季节
- 数据播放季节总计常规季节
每个 tibbles 中都有大量数据。您应该探索每一个都给了您什么，以便更好地了解 nbastatR 的功能。
或者，您可以调用勒布朗的球员 id，而不是他的名字，使用:
players_careers(player_ids = c(2544))
这将给出完全相同的结果，但我更喜欢使用 player_ids 方法，因为我知道它不会给我关于其他不如勒布朗出名的球员的错误。
如果需要更具体的东西，您还可以添加另一个名为“mode”的输入，并将数据加载到一个变量中。
例如，要获得勒布朗的职业生涯总成绩，您可以使用:
lebron_totals <- players_careers(players = c("LeBron James"),
modes = c("Totals"))
您现在有一个如下所示的 tibble:
nameTable 变量告诉您每个 dataTable 变量中究竟存储了什么数据。如果你点击一个数据表变量，它会打开另一个包含更多数据的表。
例如，点击 SeasonTotalsRegularSeason 的数据表，你会看到一个包含勒布朗在 NBA 每个赛季的常规赛总成绩的表格。(这是两张截图，因为我无法在一个屏幕上显示所有变量):
模式输入需要以下名称之一:
- 总数
- PerGame
- Per36
因此，如果你对一个球员的每场比赛或每 36 分钟的数据更感兴趣，可以使用其他模式。您也可以使用以下命令调用所有三种模式:
lebron_career <- players_careers(players = c("LeBron James"),
modes = c("Totals", "PerGame", "Per36"))
这将为您提供一个应用了所有三种模式的“表格”。
这只是冰山一角。nbastatR 还有很多其他功能。这只是用 r 获取玩家数据的一个基本方法。
有很多数据要探索，所以尽情享受吧！如果你有具体的问题想让我在以后的帖子中回答，请在下面的评论中告诉我。
资源
如何获得数据科学面试:找工作、联系看门人和获得推荐
数据科学面试
对于许多工作来说，获得面试机会自然是必不可少的，数据科学工作也不例外。虽然关于这个主题的资源肯定不缺乏，但实用和可操作的建议却很少。在我的求职过程中，我知道超过 70%的求职者通过某种形式的网络找到了工作。我知道我应该"联系招聘人员，建立自己的关系网，在这个领域闯出一片天地"。但即使知道这一点，我仍然有一个重要的问题:如何？
我第一次找数据科学工作是在 2017 年 2 月我即将完成研究生学业的时候。我尽我所能去采访，包括…
- LinkedIn、GlassDoor 上的数百份申请，事实上
- 向所有社交网络上的人(校友、有共同朋友的人)寻求推荐
- 在谷歌上搜索并尝试了所有文章中推荐的方法(除了创建我自己的数据科学工作)，如“获得数据科学面试的 10 大方法”、“获得数据科学工作的 5 个技巧”和“如何获得数据科学工作:一个可笑的具体指南”。
- 我花了很多时间来创建、格式化和精炼我的简历
在以一份全职工作的承诺(即每天至少花 8 小时)找了三个月的工作后，我终于通过 AngelList 获得了第一次面试机会。
我第二次发现自己在寻找数据科学工作是在 2018 年 12 月被我当时的创业公司解雇的时候。这一次，通过 50 份申请和 18 次推荐，我在一个月内获得了 10 次面试机会(总共花了不到 30 个小时)。这种巨大的差异并不是因为我有工作经验。事实上，第二次在就业市场上，我并没有更有竞争力。这种剧烈的变化是因为我第一次就做错了！这并不是因为关于获得数据科学面试的文章是误导性的或不正确的，而是它们只告诉我做什么而不是如何做。
在这篇文章中，我不仅会分享该做什么(只有 3 种方法而不是 10 种)以及如何有效地获得面试。你会在这篇文章中找到策略、脚本和其他免费资源，它们将帮助你有条不紊地寻找工作。具体来说，这篇博客回答了这些问题:
- 我应该去哪里找数据科学的工作？
- 我如何联系看门人？
- 我如何获得推荐？
- 一份好的数据科学简历是由什么构成的？
如果你认为我能以任何方式让你的旅程更轻松，你可以在这里联系我。
在我们开始之前，你更喜欢视频吗？看这个 YouTube 视频而不是阅读。
目录
- 三种方法
- 原始应用程序:在哪里搜索很重要！
- 与看门人接触:向更多的面试问好
- 获得推荐:去你梦想中的公司面试的最佳方式
- 优秀简历的品质
- 最终想法
三种方法
获得面试机会有三种方式:原始申请，联系把关人，以及获得推荐。原始申请意味着简单地将你的简历提交给空缺职位。虽然这是一个简单的方法，但它的效率也很低。联系看门人可能更有效，但需要更多的努力。获得推荐是最有效的方式，但也最耗费时间和精力(假设你还不知道有谁愿意推荐你)。下图从工作量/时间和有效性方面展示了这三种方法。
图片由艾玛丁 |获得面试机会的三种方式
原始应用程序:在哪里搜索很重要！
当我们在找工作时第一次想到要查看求职信息时，我们通常会立即转向热门的在线求职信息，如 LinkedIn、GlassDoor 或 Indeed。我第一次找工作时，在 LinkedIn 上提交了数百份申请，但没有得到任何回复。事实上，我的一些正在进行职业转型的朋友也发现自己在 LinkedIn 上没有得到回复。当我开始第二次找工作时，我没有在 LinkedIn 上提交一份申请。
为什么？问题是，对于每个职位，数百名申请人在一周内申请。如果你仅仅依靠这些受欢迎的求职网站，你得到回复的机会很小。你在和堆积如山的候选人竞争！
不幸的是，事实是，近年来，LinkedIn 已经成为一个服务于招聘人员的平台，这些招聘人员希望接触到具有确切经验和资格的潜在候选人。它不是一个为缺乏经验的求职者服务的平台，因为你必须与数百(有时数千)名申请人竞争一个职位。
解决这个问题的一个方法是申请不太受欢迎的网站。使用尚未成为主流的网站。怀疑？Edouard Harris 在他的博客中很好地解释了为什么“公司更关注通过不太为人知的渠道申请的人。以下是我和我认识的人尝试过的一些网站，它们被证明是有帮助的。有些甚至是专门与数据科学相关的。
- Kaggle Jobs
- KDNuggets 乔布斯
- 数据科学中心—分析人才(以美国为中心)
- 数据作业(以美国为中心)
- icruncdata(以美国为中心)
- r/数据科学作业
- 三字节—数据科学
此外，还有一些规模较小的在线招聘网站的回复率比三大网站更高。
- AngelList——我通过它获得了我的第一份数据科学工作！
- 黑客新闻
- Github 乔布斯
- 录用了
- SmartHires
- 白松露
- ZipRecruiter
无论何时申请任何职位，试着给招聘的人发一封个性化的短信。调查这家公司(使用公司网站、谷歌和 Glassdoor ),解释为什么你最适合这个职位。个性化会大大增加你得到回应的机会。
向看门人伸出手:向更多的采访问好
尽管我推荐的网站往往比大型招聘网站的回复率更高，但招聘人员仍然需要几周时间才能回复，因为他们总是有一大堆简历要审阅。现在，您可能想尝试第二种方法——直接联系看门人。使用这种方法，我能够比原始应用程序更快地获得响应。
看门人指的是你感兴趣的公司中的技术招聘人员或数据科学家。大公司通常有专门聘请数据科学家的技术招聘人员，但小公司的数据团队可能更独立。如果你能赢得看门人的信任，这可能会让你在招聘过程中继续前进。
以下是赢得看门人的几个步骤:
- 整理一份你感兴趣的公司的个人名单(即使目前没有空缺)
- 通过访问公司网站或使用 LinkedIn 找到把关者的联系信息(您可能会在同一家公司找到多个把关者)
- 开发一个能吸引看门人注意力的电子邮件推介
- 如果一周左右没有回音，发一封跟进邮件，继续跟进，直到你被拒绝
电子邮件的推介应该简洁而完整。你的电子邮件可能会被转发给不同的人，没有人会为你复制和粘贴多封电子邮件，所以营销需要有一切。一份好的电子邮件推介包含两个部分:
- 第一部分是一个简短的介绍(2-3 句话),包括你的意图，你的经历的简要描述，以及你为什么对这家公司感兴趣。再次强调，对公司做一些调查将会非常有助于以一种特定的方式表达你的兴趣。
- 第二部分是关于你最有影响力的项目。确保这是有趣的，可读的，可分享的。
为了使事情更简单，这里有一个模板。
此电子邮件模板已更新自 吸取了惨痛的教训:黑客数据科学访谈 作者格雷格·卡姆拉德
如果你在几天内得到回复，那太好了！但是如果你在一周左右没有收到，给看门人发一封跟进邮件。根据我自己和我朋友的经验，后续邮件的回复率高于第一封邮件。这是我在后续邮件中使用的模板:
此电子邮件模板已更新自 如何跟进工作申请:电子邮件模板 作者 Alex cavulacos
虽然您当然可以使用这两个模板作为起点，但是不要而不是复制它们。如果看门人看到完全一样的邮件模板，会留下负面印象。你可以改变事情。你可以把它变长或变短。请记住，主要的想法是显示您的兴趣，并发送所有必要的东西。
获得推荐:去你梦想中的公司面试的最佳方式
照片由克里斯蒂娜@ wocintechchat.com在 Unsplash 上拍摄
第一次找工作时，我联系校友、有共同朋友的人，甚至是随机的人来获得推荐。然而，我最终什么也没得到。相比之下，我第二次找工作时，我的人际网络中的人告诉我，他们愿意介绍我，甚至在我开口之前。
随着时间的推移，我已经了解了一些关于请求推荐的误解。获得推荐就是让熟悉你工作的人给他们的公司一份热情的推荐。这不是你在 LinkedIn 或其他地方找到的与陌生人争论的问题。况且大多数时候，后一种方法是行不通的。
获得推荐不同于主动联系看门人，因为它始于与在科技公司工作的人建立关系，不管他们的职业是什么。无论是产品经理、软件工程师、产品设计师，还是其他。一段感情要走很长的路。Haseeb Qureshi 有一篇关于进入科技行业的的博文。关于网络的部分尤其精彩。库雷希说…
…人们 讨厌你向他们求职。
给你一份工作？为什么？他们不了解你。他们为什么会给你工作？他们为什么要在你身上浪费时间？
信息面试的力量在于，你可以让他们了解你，而不是让他们了解你。人们喜欢谈论自己。他们喜欢教别人。他们想帮忙。但是他们不想被陌生人纠缠着要好处。
如果你继续这样做，人们会看到你的好奇心和你的真诚。他们会相信你的故事，他们会 想要 指代你。
这听起来像是很多工作，尤其是当你以前没有做过的时候，但实际上只有 4 个步骤来正确地建立关系:
- 给人买咖啡。在疫情期间这可能不容易做到，所以你可以要求一个简短的缩放聊天。
- 进行信息面试。你要表现出对这个人、他们的工作以及他们的公司的兴趣。
- 第二天通过电子邮件感谢他们并跟进。你不想做一次性连接。一段感情是需要维持的。
- 一旦有人愿意推荐你，你要让它顺利推荐。与其问“你们公司有空缺吗”，不如自己去看看公司网站，找到最适合你的空缺。然后准备一封电子邮件，附上你的简历、工作链接、对你经历的描述，以及对你为什么非常适合的解释。
正是这些步骤让我在第二次找工作时得到了推荐。如果你遵循所有这些步骤，你会得到强有力的推荐！这不仅有助于你第一次找工作，也有助于未来的求职。
下面是一个冷邮件模板，你可以用来作为第一次外联的参考。这里的要点是要使它个性化，并显示出你真正的兴趣。
此电子邮件模板已由 Haseeb Qureshi 更新为如何打入科技行业
还是那句话，世界很小。不要完全照搬剧本。花时间定制你的信息，因为从长远来看，这是值得的。
优秀简历的特质
根据你的目标和时间，你可以选择三种方法中的一种或多种来获得面试机会。但是不管你用哪种方法，一份好的简历都是关键。这是能让招聘者扭转局面的东西。
简历是你成就的总结。它应该是简短的，所以它不是一个展示你知道或能做的一切的地方。添加过多的内容只会让人们被不必要的信息淹没。因此，在你的数据科学简历中，你希望突出与数据科学相关的最重要的东西，如工作经验、培训和相关技能。当招聘人员或招聘经理看到你的简历时，他们应该会立即感觉到你在数据科学方面有丰富的经验，并且你是一个合格的候选人。
这里有几条写简历的规则，是我在测试了自己的简历，与许多招聘人员和招聘经理交谈，并审阅了其他人的简历后创建的。
避免危险信号:
- 一份好的简历总是一页长。招聘人员和人事经理一天会收到很多简历，他们通常只有不到一分钟的时间浏览简历并做出决定。如果你的简历有多页，他们可能不会看到第二页。
- 不要有错别字。在发送之前，请朋友进行同行审查，确保没有打字错误或语法错误。
改进你的简历:
- 有选择性，有策划。从你最有影响力的经历、项目和技能开始。在“经验”和“项目”部分，确保每个项目不超过 4 个要点。第一个要点应始终是根据业务指标衡量的最有影响力的要点，如用户保留率或转换率的提高、跳出率或成本的降低等。
- 言简意赅。你的简历展示了你的沟通技巧，为了表明你能有效地沟通，你应该注意去掉多余的短语，重新安排冗长的表达。
让你的简历脱颖而出:
- 不要讲，展示数字和度量。在描述你的经历和项目时，展示你通过业务指标衡量的贡献。展示所处理数据的大小和类型，并引用您使用的确切技术。具体一点会让你的简历更值得信赖。
- 不要给所有的职位都发一份简历。为每个应用添加定制的调整总是值得的。至少，如果你注意到工作描述中提到的重要关键词和技能，就在简历中使用它们，突出你在这些领域的技能。编造事情是不可以的，但是重组你的技能和经历以适应工作描述的背景是完全可以的。
最后的想法
在一天结束时，获得数据科学面试是困难的，尤其是对初学者来说。即使你已经努力工作了几个月，但没有得到任何回应，这可能会令人沮丧。希望这篇文章能让那些正在找工作的有抱负的数据科学家明白一些事情。如果你想要更多的建议，请随时联系我这里，我很乐意帮忙！
感谢阅读！
如果你喜欢这个帖子，想支持我…
- 订阅我的 YouTube 频道
- 跟我上 中 ！
- 连接上Linkedin！
- 前往emmading.com/resources获取更多关于数据科学面试技巧和策略的免费资源！
* [## 我是如何获得 4 份数据科学工作邀请，并在被解雇后两个月内收入翻倍的
获得 100%现场报价率的秘诀
towardsdatascience.com](/how-i-got-4-data-science-offers-and-doubled-my-income-2-months-after-being-laid-off-b3b6d2de6938)*
如何从任何 Sklearn 管道中获取特性重要性
入门
管道可能很难导航，下面是一些通用的代码。
介绍
管道太神奇了！我基本上在我从事的每个数据科学项目中都使用它们。但是，轻松获得特性的重要性要比需要的困难得多。在本教程中，我将介绍如何从管道中访问单个特征名称及其系数。在那之后，我将展示一个通用的解决方案来获取几乎所有管道的特性重要性。
管道
让我们从一个超级简单的管道开始，它应用一个单独的特征化步骤，然后是一个分类器。
from datasets import list_datasets, load_dataset, list_metrics
from sklearn.pipeline import FeatureUnion, Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn import svm# Load a dataset and print the first examples in the training set
imdb_data = load_dataset('imdb')classifier = svm.LinearSVC(C=1.0, class_weight="balanced")
model = Pipeline(
[
("vectorizer", TfidfVectorizer()),
("classifier", classifier),
]
)
x_train = [x["text"]for x in imdb_data["train"]]
y_train = [x["label"]for x in imdb_data["train"]]
model.fit(x_train, y_train)
这里我们使用优秀的数据集 python 包来快速访问 imdb 情感数据。这个由 HuggingFace 整理的包有大量的数据集，它们都已经准备好了，所以你可以直接进入有趣的模型构建。
上面的管道在一个列表中定义了两个步骤。它首先接受输入并将其传递给 TfidfVectorizer，后者接受文本并将文本的 TF-IDF 特征作为向量返回。然后，它将该向量传递给 SVM 分类器。
注意这是如何按顺序发生的，TF-IDF 步骤，然后是分类器。您可以链接任意多的特征化步骤。例如，上述管道相当于:
model = Pipeline(
[
("vectorizer", CountVectorizer()),
("transformer", TfidfTransformer()),
("classifier", classifier),
]
)
在这里，我们甚至更多地手动操作。首先，我们得到每个单词的计数，其次，我们应用 TF-IDF 变换，最后，我们将这个特征向量传递给分类器。TfidfVectorizer 一步就完成了这两项工作。但这说明了一点。在原始管道中，事情按顺序执行。稍后我们将讨论如何将特性堆叠在一起。现在，让我们努力获得第一个示例模型的特性重要性。
特征重要性
管道使得访问单个元素变得容易。如果您在培训后打印出模型，您将会看到:
Pipeline(memory=None,
steps=[('vectorizer',
TfidfVectorizer(...)
('classifier',
LinearSVC(...))],
verbose=False)
也就是说有两个步骤，一个叫做vectorizer，另一个叫做classifier。我们可以通过查看管道的named_steps参数来访问它们，如下所示:
model.named_steps["vectorizer"]
这将返回我们拟合的 This 矢量器。相当整洁！Sklearn 中的大多数特征化步骤还实现了一个get_feature_names()方法，我们可以通过运行该方法来获得每个特征的名称:
# Get the names of each feature
feature_names = model.named_steps["vectorizer"].get_feature_names()
这将为我们提供矢量器中每个特征名称的列表。然后我们只需要从分类器中获取系数。对于 Sklearn 中的大多数分类器来说，这就像获取.coef_参数一样简单。(集合方法略有不同，它们有一个feature_importances_参数代替)
# Get the coefficients of each feature
coefs = model.named_steps["classifier"].coef_.flatten()
现在我们有了分类器中的系数和特征名称。让我们把它们组合成一个好的情节。
import pandas as pd# Zip coefficients and names together and make a DataFrame
zipped = zip(feature_names, coefs)
df = pd.DataFrame(zipped, columns=["feature", "value"])# Sort the features by the absolute value of their coefficient
df["abs_value"] = df["value"].apply(lambda x: abs(x))
df["colors"] = df["value"].apply(lambda x: "green" if x > 0 else "red")
df = df.sort_values("abs_value", ascending=False)
想象一下:
import seaborn as snsfig, ax = plt.subplots(1, 1, figsize=(12, 7))
sns.barplot(x="feature",
y="value",
data=df.head(20),
palette=df.head(20)["colors"])
ax.set_xticklabels(ax.get_xticklabels(), rotation=90, fontsize=20)
ax.set_title("Top 20 Features", fontsize=25)
ax.set_ylabel("Coef", fontsize=22)
ax.set_xlabel("Feature Name", fontsize=22)
所以我们可以看到，负面的单字似乎是最有冲击力的。那很酷。获得这些特性的重要性很容易。让我们尝试一个稍微复杂一点的例子。
从要素联合中获取要素重要性
在大多数真实的应用程序中，我发现我以复杂的方式将许多功能结合在一起。前面我们看到了管道如何按顺序执行每个步骤。我们如何处理多个同时发生的步骤？答案是 FeatureUnion 类。假设我们想要构建一个模型，在这个模型中，我们采用 TF-IDF 的二元模型特性，但是也有一些手工策划的二元模型。(参见我关于使用模型寻找好的 unigrams 的博文。)我们可以使用 FeatureUnion 来定义这个管道。FeatureUnion 接受一个transformer_list，它可以是转换器、管道、分类器等的列表。然后连接它们的结果。
classifier = svm.LinearSVC(C=1.0, class_weight="balanced")
vocab = {"worst": 0, "awful": 1, "waste": 2,
"boring": 3, "excellent": 4}
model = Pipeline([
("union", FeatureUnion(transformer_list=[
("handpicked", TfidfVectorizer(vocabulary=vocab)),
("bigrams", TfidfVectorizer(ngram_range=(2, 2)))])
),
("classifier", classifier),
])
正如你所看到的，我们的模型有两个步骤，一个是 T4，一个是 T5。在union中，我们做了两个不同的特征化步骤。我们找到一组手工挑选的一元特征，然后是所有二元特征。
从这个模型中提取特征稍微复杂一些。我们必须进入联盟，然后获得所有的个人特征。让我们手动尝试一下，然后看看我们是否可以推广到任意管道。我们已经知道如何访问管道的成员，要进入 FeatureUnion 内部，我们可以直接查看transformer_list并遍历每个元素。所以代码应该是这样的。
handpicked = (model
.named_steps["union"]
.transformer_list[0][1]
.get_feature_names())bigrams = (model
.named_steps["union"]
.transformer_list[1][1]
.get_feature_names())feature_names = bigrams + handpicked
因为分类器是对单个向量进行操作的 SVM，所以系数将来自相同的地方并且处于相同的顺序。我们可以再次看到我们的结果。
看起来我们的二元模型比我们手工选择的二元模型信息量更大。
一般情况
因此，我们已经做了一些简单的例子，但现在我们需要一种方法来实现任何(几乎任何)管道和功能联合的组合。为此，我们求助于老朋友深度优先搜索(DFS)。我们将把管道看作一棵树。每一层都可以有任意数量的特征联合，但它们最终都会叠加成一个特征向量。遍历时大致有三种情况需要考虑。第一种是基本情况，我们在一个实际的转换器或分类器中，它将生成我们的特征。第二个是如果我们在管道中。第三种也是最后一种情况是当我们处于 FeatureUnion 内部时。让我们更深入地讨论这些。
案例 1:特征化步骤
这里我们想写一个函数，给定一个某种类型的特征，它将返回特征的名称。这是我们 DFS 中的基本情况。在 Sklearn 中，有许多不同类型的东西可用于生成特征。一些例子是聚类技术、降维方法、传统分类器和预处理器等等。每一种都允许您以不同的方式访问特性名称。例如，文本预处理器 TfidfVectorizer 实现了一个get_feature_names方法，就像我们上面看到的那样。然而，大多数聚类方法没有任何命名的特征，它们是任意的聚类，但是它们有固定数量的聚类。让我们编写一个助手函数，给定一个 Sklearn 特征化方法，它将返回一个特征列表。
在这里，我们尝试并列举一些可能发生在 Sklearn 内部的潜在情况。我们使用hasattr来检查所提供的模型是否有给定的属性，如果有，我们调用它来获得特性名称。如果该方法类似于聚类，并且不涉及实际命名的特征，那么我们通过使用提供的名称来构造我们自己的特征名称。例如，假设我们将这个方法应用到有两个组件的PCA，我们将步骤命名为pca，那么返回的结果特征名称将是[pca_0, pca_1].
深度优先搜索
现在我们可以实现 DFS 了。
让我们一起来解决这个问题。这个函数需要三样东西。首先是我们要分析的模型。这个模型应该是一个管道。第二个是我们想要提取的所有命名的特征化步骤的列表。在我们的上一个示例中，这是bigrams和handpicked.这是我们在模型中使用的各个步骤的名称。最后一个参数是我们正在查看的当前名称。这对于递归来说是必要的，在第一遍中并不重要。(我应该创建一个 helper 方法来对最终用户隐藏这一点，但是现在需要解释的代码较少)。
- 第 19–25 行构成了基本案例。它们处理步骤名称与我们所需名称列表中的名称匹配的情况。这对应于一个叶节点，它实际上执行特征化，我们希望从它那里获得名称。
- 第 26–30 行管理管道中的实例。当这种情况发生时，我们希望通过访问
named_steps参数来获得每一步的名称，然后遍历它们来收集特征。我们遍历管道中的每个命名步骤，并在一个列表中获取所有的特性名称。 - 第 31–35 行管理我们在 FeatureUnion 时的实例。当这种情况发生时，我们希望从
transformer_list参数中获得每个子转换器的名称，然后遍历它们来收集特性。
有了这些，我们现在可以使用任意嵌套的管道，比如说下面的代码，并以正确的顺序获得特性名称！
from sklearn.decomposition import TruncatedSVD
classifier = svm.LinearSVC(C=1.0, class_weight="balanced")
vocab = {"worst": 0, "awful": 1, "waste": 2,
"boring": 3, "excellent": 4}
model = Pipeline([
("union", FeatureUnion(transformer_list=[
("h1", TfidfVectorizer(vocabulary={"worst": 0})),
("h2", TfidfVectorizer(vocabulary={"best": 0})),
("h3", TfidfVectorizer(vocabulary={"awful": 0})),
("tfidf_cls", Pipeline([
("vectorizer", CountVectorizer()),
("transformer", TfidfTransformer()),
("tsvd", TruncatedSVD(n_components=2))
]
))
])
),
("classifier", classifier),
])
在这个例子中，我们构造了三个手写的规则特征化器和一个子管道，该子管道执行多个步骤并导致维数减少的特征。我们可以使用一行代码从这个管道中获得所有的特性名称！
get_feature_names(model, ["h1", "h2", "h3", "tsvd"], None)
它会回来的
['worst', 'best', 'awful', 'tsvd_0', 'tsvd_1']
正如我们所料。
结论
有很多方法可以混合和匹配管道中的步骤，获得特性名称可能是一种痛苦。如果我们使用 DFS，我们可以按照正确的顺序提取它们。这种方法在 SciKit-Learn 的生态系统中的大多数情况下都有效，但我还没有测试所有的东西。要扩展它，你只需要查看你试图从中提取名字的任何类的文档，并用一个新的条件检查来更新extract_feature_names方法，如果想要的属性存在的话。我希望这有助于使管道更容易使用和探索:)。你可以在这里找到一个 Jupyter 笔记本，里面有这篇文章的一些代码示例。和我所有的帖子一样，如果你遇到困难，请在这里评论或在 LinkedIn 上给我发消息，我总是很有兴趣听到人们的意见。编码快乐！
如何获得免费的 GPU 硬件
以及当你长大后该怎么做
Rafael Pol 在 Unsplash 上的照片
你听说过深度学习。你已经听说它正在改变世界。你也听说过需要一个非常好的 GPU 。
很自然，你看一看你的计算机，看看你有什么样的硬件。你可能会发现以下三种情况中的一种:
- 你根本没有专用的 GPU(笔记本电脑常见)。
- 你有一个 GPU，但它不是深度学习非常需要的 Nvidia GPU。
- 你有一个 Nvidia GPU，但它远不足以满足你的深度学习需求。
那么——现在怎么办？你如何接触到必要的硬件来接触深度学习？让我们来看看。
Kaggle 笔记本
Kaggle 笔记本(也称为内核)是由 Kaggle 提供的一个免费的计算环境，你可以用它来运行你的代码。以下是技术规格:
- 9 小时的执行时间
- 5gb 自动节省的磁盘空间(/kaggle/working)
- 16gb 的临时暂存磁盘空间(外部/ka ggle/工作)
CPU 规格
- 4 个 CPU 内核
- 16 千兆字节的内存
GPU 规格
- 2 个 CPU 内核
- 13 千兆字节的内存
你可以从上面看到，你有两个选择:基于 CPU 的笔记本电脑或基于 GPU 的笔记本电脑。既然在讨论深度学习，我们就假设 GPU 笔记本。注意:如果对 GPU 笔记本电脑的需求很高，你可能会被放在一个队列中，不得不等待一个。
对于 GPU 笔记本，你得到一个单一的英伟达特斯拉 P100。这个 GPU 有 12GB 的内存和 4.7 万亿次双精度性能。
Kaggle 还预装了运行深度学习实验所需的几乎所有库，使设置变得极其简单。真的，你要做的就是打开一个带 GPU 的 Kaggle 笔记本，开始编码。
在我看来，这是一个惊人的选择，但它也有一些缺点。首先，当提交代码时，你只能得到 6 个小时的执行时间。提交代码是保存代码的方式。深度学习实验需要几天的训练并不罕见，所以如果你开始处理更复杂的问题，6 小时的限制可能会非常有限。
其次，尽管硬件的零成本令人惊叹，但对于需要大量内存或大量培训的模型来说，单个 GPU 可能太小。例如，在视频或大型文本语料库上训练的深度学习模型。这两者都需要大量的 GPU 内存。几乎可以肯定的是，他们在单个 GPU 上训练的时间会超过 6 个小时。
这两种失败都只发生在试图训练相当大的深度学习模型的高级用户身上。出于这个原因，如果你刚刚开始深度学习，我强烈建议你从 Kaggle 笔记本开始。它们不需要任何成本，让您能够访问一个良好的单个 GPU，预装了基本上所有必要的库，并允许您专注于学习如何利用深度学习。
然而，如果你继续沿着深度学习的道路走下去，在某一点上，你可能会超越你的 Kaggle 笔记本。那么——然后呢？
云的魅力
在这一点上，我看到很多人转向云。这很容易上手，你只需为你使用的东西付费，你就可以使用一些真正强大的机器。
例如，每小时大约 31 美元，你就可以使用一台 8 特斯拉 V100s 和 256GB 总 GPU 内存的机器。那是一台很重要计算机。你还可以以每小时 0.90 美元的价格获得单个 K80 GPU。K80 GPU 不是最好的(它比 Nvidia 1080 GPU 慢 2.5 倍)，但它有 24GB 的内存！
也就是说，对于大多数人来说，我会避免在云中训练你的深度学习模型。
主要原因很简单——如果你总是不得不花钱尝试新模式或进行新实验，这将在精神上侵蚀你。你每次都必须决定你想要运行的模型是否值得。这种心理斗争会阻止你尽可能多地学习和尝试。
此外，如果你继续使用更便宜的机器，你不会比从 Kaggle 得到更多的硬件。你将得到的最大好处是无限的时间来运行你的模型，但是因为你是按小时付费的，这将开始累加。此外，如果你从 Kaggle 大幅升级你的硬件，它也开始变得相当昂贵。
那么，你还有什么选择呢？
建造它
如果你已经开始使用 Kaggle 笔记本进行深度学习，并且你知道你想变得更大，跳过云的精神痛苦，建立自己的深度学习平台。
让我们浏览一些数字。
现在让我们假设你对 1 个 GPU 没问题，但想要更长时间运行的模型的自由，而你在 Kaggle 上没有，以及以后升级到更多 GPU 的能力。那正是我建造我的机器的地方。
我选择了以下核心组件:
- 英特尔酷睿 i7–6850k3.6 GHz 6 核处理器。我选择这款处理器是因为它可以为您提供 40 个 PCI-E 通道，让您能够最大限度地运行 2 个 GPU。此外，拥有 6 个内核非常有利于并行数据处理。
- 海盗船复仇 LPX 32gb(2x 16 GB)DDR 4–3200 内存，因为在我看来，如今 16GB 是不够的。
- 三星 970 PRO512 GB m . 2–2280 NVME 固态硬盘，以便尽可能最快地从我的硬盘上加载数据。我还买了一个 3 TB 的旋转磁盘来存储我目前培训时不需要访问的数据。
- 技嘉 GeForce GTX 1080 Ti 11 GB AORUS 显卡。当我购买我的机器时，这真的是基于桌面的深度学习的最佳选择。如果我今天购买，我会仔细看看 2080 Ti。
现在，你可以用大约 2400 美元来构建上述系统(包括所有其他必要的组件)。
为了保守的比较，让我们把这个和 AWS 上的一个 p2.xlarge 的成本进行比较，AWS 是一个更差的机器(除了更多的 GPU 内存)。这台机器每小时收费 0.90 美元。增加 512GB 的存储空间可能会让你每小时多花 0.07 美元。花 2400 美元，你可以运行这台机器大约 103 天。
听起来很神奇，对吧？
除了当我想到可能花了两周的计算时间才搞清楚强化学习，所以我可以在超人的水平上玩乒乓球。如果你认为你尝试的每个项目可能需要大约 14 天的训练来找出所有的错误并进行优化，那么在你达到 2400 美元之前，你会得到大约 7 个项目。
哎哟。
更糟糕的是，想象一下每次你训练 2 天后发现一个 bug。那个窃丨听丨器花了你将近 50 美元。对我来说，每次我想训练一个模特都要付钱，这太痛苦了。我宁愿沉下建造自己机器的成本，然后放心去疯狂。我知道我通过这种方式学到了更多，因为我不怕尝试。事实上，由于我预先花了这么多钱，我没有动力去做尽可能多的实验。
余钱
建造你自己的机器有非金钱的好处。通过为我的机器选择所有的部件，然后把它们组装起来，我学到了很多。当然——这有时令人沮丧，但最终，这是一种巨大的成就感。
我还能够发现如何安装和优化所有必要的库、驱动程序和软件包来运行深度学习。如果我想升级我的系统，我有一个非常强大的基础。比如，就在这个月我买了一个更大的 NVME 硬盘(升级到 1 TB)。我现在以大约 150 美元的投资获得了 1.5TB 真正快速的数据存储。如果我想将我的 GPU 升级到 2080 Ti，我就不必购买全新的机器。我会买新的图形处理器，然后把它放进去。一旦你建立了自己的机器，这种随着时间的推移逐步升级的能力是惊人的！
希望我已经让你相信，一旦你不再需要 Kaggle 笔记本电脑，就可以自己制造一台机器。2400 美元不是一笔小投资，但我认为大多数人在攒钱造机器的同时继续使用 Kaggle 笔记本会更好。这并不是说你不应该接触云计算。如果在保存的时候你有一个大规模的模型想要运行，试试 AWS 或者 Google 云计算。我只是不认为云对于那些想做很多深度学习项目的人来说是一个好的长期解决方案。
然而，无论你选择哪条道路，我希望你能在构建深度学习模型方面取得成功！
注意:当链接到产品时，我使用附属链接，但这些是我实际购买和使用的产品。
这个故事也可以在这里找到。
如何使用 Python 获得免费的历史和实时股票价格和外汇汇率
Python 中的股票价格
这是一个指南，展示了如何使用 Python 从雅虎财经或 Alpha Vantage 获得历史和实时股票价格和外汇汇率。
这两个 API 都是免费的，但是 Alpha Vantage 标准 API 限制为每分钟 5 个请求，每天 500 个请求。这对于一个简单的投资组合股票监控工具来说应该足够了。
克里斯·利维拉尼在 Unsplash 上的照片
有多少 API？
这个清单很长，而且近年来还在增加。允许免费 API 调用股市数据的提供者列表包括: Finnhub.io 、 TenQuant.io 、 UniBit 、 IEXCloud 、 marketstack 、 Quandl 、 EOD 历史数据并且是不断变化的。
我使用哪些市场标识符？
在金融服务行业的实践中，你会遇到 SEDOL、ISIN、CUSIP、RIC、BB Ticker、BB Full Ticker(最后两个是彭博社的标识符)，但对于免费的 API，你可以在这里查看这个 MICs(市场标识符代码)列表。
雅虎财经
雅虎财经 API 是免费的，但是报价器的世界是有限的。也很难确定在 API 调用中应该使用什么代码，但是上面的 ISO 列表会有所帮助。下面是一组函数，可以返回一个报价器或一组报价器的收盘价。您可以更改周期，但有些报价机的数据没有那么旧。
下面的代码使用了一个为雅虎财经 API 包装的 Python，更多细节你可以点击这里。
以下是使用美元英镑货币对的价格函数的示例:
另一个是两种股票价格:
阿尔法优势
Alpha Vantage 正在提供基于云的股票市场 API。用户可以访问历史和实时财务数据、技术指标和其他数据类型。这家创业公司的两位创始人都是哈佛商学院的 MBA 毕业生。
要使用 Alpha Vantage 标准 API，你必须先注册。如果您想获得更多或其他种类的数据，有一个文档页面提供了更多 API 调用的示例。
下面的代码使用了 Alpha Vantage API 的 Python 包装器，更多细节请点击这里。
下面是一个为微软公司(MSFT)和 Tesla 公司(TSLA)使用 get_prices 函数的示例:
另一个是与英镑配对的外汇汇率:
对于一个基本的股票投资组合工具，价格和利率是你计算自己的指标所需要的最低要求。
如何被聘为机器学习工程师
获得机器学习工程师工作的 7 个步骤
成为一名机器学习工程师绝不是一件容易的事情(文章开头一个积极的注解)。但是如果你有耐心和自律，这是完全可行的。坏消息是，要想在科技公司找到工作，你必须大量学习。好消息是，即使在大型科技领域，熟练的机器学习工程师也很短缺，而且薪水高得离谱。非常疯狂。值得吗？对我来说完全是。但这取决于你。
那么我该如何开始呢？
了解你的性别
在考虑申请之前，你必须了解一些基本知识。我说的基础不是指卷积神经网络。即使是 K- Means 也不行。我指的是基本的计算机科学原理。算法与数据结构，编程语言(最好是 Python)，调试，测试，版本控制，云计算。这个清单还在继续。
但是请记住。机器学习工程师首先是软件工程师。他不是数据科学家，也不是数据分析师。为了学习一切，我个人会选择 Coursera 的这门令人惊叹的课程，关于 Python 编程，以及 Udacity 的这门课程，关于算法和数据结构
了解你的机器学习
没有第一步重要，但还是有用的。您应该熟悉基本算法，如回归、决策树、K 均值，并熟悉数据预处理和建模。还是那句话，不要太花里胡哨。一般来说，公司不会寻找能从数学上证明反向传播的人。他们寻找开发人员来编码和构建他们的机器学习管道。在这些管道中，机器学习只占了大约 5%的工作。同样，这些由 Coursera 和 Udacity 开设的课程是你的朋友。
你也可以在我们的博客 AI Summer 上找到围绕机器学习的很棒的教育内容，在那里我们分析了现实生活应用中使用的不同人工智能算法和模型。
得到经验
假设你知道基础知识(你应该知道)，下一个重要的步骤是获得经验。我建议开始做一些你感兴趣的个人项目(也许你可以用神经网络预测比特币价格，或者在大规模数据集中运行快速排序，我不知道)，参加一两个 Kaggle 比赛，也许可以从客户那里获得一些小型自由职业者的工作。
重要的是从零开始建造整个东西。从数据库和服务器到生产中部署的 API。这是真正理解整个堆栈并接触管道所有组件的唯一方法。相信我。任何课程或教训都无法与之相比。它会立刻给你一个全新的视角。
建立投资组合和简历
现在你感觉自信了，而且你已经参与了一些现实世界的项目，是时候建立你的简历了。但是，你的简历不仅仅是一个 pdf。这是一个展示你所有项目和课程的个人网站。这是一个 LinkedIn 账户(非常重要),里面有你所有的最新信息。这是一个 GitHub 配置文件，包含了您在过去几个月中编写的所有代码。也许是一个展示你目前所学的博客。最好是以上全部。
这就是你如何从你梦想的公司吸引招聘人员的注意。这就是招聘经理在谷歌上搜索你的名字时会发现的。
准备编码面试
现在到了有趣(没那么有趣)的部分。你要准备编码面试。不要假设你知道你在做什么。即使你有麻省理工的硕士学位。让我再说一遍。你得做好准备。
如果你对自己的算法和数据结构技能有信心，下面是你需要做的。拿一本破解编码面试(软件面试的圣经)，开一个 Leetcode 账号。开始练习简单的问题。试着想出一个蛮力解决方案，然后试着优化。卡住的时候，想想还有哪些数据结构可以用。或者查一下书上类似的问题。但是不要放弃。
那就再做一个。还有一个。随着你解决的问题越来越多，你开始识别模式，你可以着手解决中等甚至困难的问题。你应该解决多少问题？越多越好。如果你想在 FAANG 工作，可能要 150 英镑。否则大约 50。
还有，我的建议是，在你练习的时候，尽快尝试和模拟实际的面试体验。设置一个计时器。大声解释你的想法。
学习系统设计
面试中不可或缺的一部分是系统设计环节，在这一环节中，你要描述你将如何构建一个流行的架构，比如 Instagram 或网飞。它评估你所有的技术能力，你的背景和你的一般知识。因此，这不是你一夜之间就能学会的。
虽然你可以准备。你可以从 10 个最流行的应用程序的系统设计开始，然后尝试设计一个不同的应用程序。重复这个过程，直到你感到自信。
你还应该强调机器学习架构，如推荐系统或搜索自动完成。一般来说，这一轮公司会测试你的 ML 背景。但请记住，这是一个非常高层次的谈话。
应用
最后一步是开始申请。当然，你可以在公司的在线平台上提交申请。但是不要期待任何结果。为了加快这一过程，我将重点关注三件事:
- 在 LinkedIn 上找到招聘人员，向他们发送好友请求，表达你对某个职位的兴趣，让你的简历/ GitHub 账户/网站为你做所有的工作。但是要巧妙的做。表达你对这家公司的兴趣，打电话询问信息，等等。
- 向一位在科技公司工作的朋友寻求推荐(50%的人是通过推荐被雇佣的)。
- 参加招聘会和社交活动
就这样吗？就这么简单？Lol。可以说这是一个漫长的过程，在被拒绝后继续下去需要勇气和决心。但是不要气馁。没有一个人没有被拒绝过。你也应该知道，不幸的是，这也是一个时机和运气的问题。
但最终，你所有的努力都会有回报。这不是时机或运气的问题。这是必然的。
如果你有兴趣阅读更多关于人工智能的帖子，请不要不看我们的博客就离开 艾夏
原载于 2020 年 2 月 8 日 https://theaisummer.com。
Foobar 挑战:谷歌的秘密招聘过程
Google Foobar 招聘挑战(图片由作者提供)
终极指南
关于谷歌桌面挑战赛你需要知道的一切
最近，当我在谷歌上搜索关键词“无头浏览器”时，我的窗口出现了一个不寻常的弹出窗口，上面有一条信息:
众所周知，好奇的开发人员会寻求有趣的问题。从谷歌解一个？
我很惊讶地看到谷歌给我发送了一个挑战，我立即接受了！点击“我想玩”,我进入了谷歌的 Foobar 页面。
这是谷歌足球挑战赛！
Google Foobar Challenge 到底是什么？
Google Foobar challenge 是该公司在全球招募顶级程序员和开发者的秘密招聘程序。众所周知，谷歌的一些开发人员就是通过这种方式被聘用的。
挑战包括五关共九题，每关难度递增。
得到挑战后怎么办？
选择“我想玩”选项后，你进入 Foobar 的网站，它有一个类似 Unix 的外壳界面，包括一些标准的 Unix 命令，如help, cd, ls, cat and etcetera.
(图片由作者提供)
所以，挑战从一个科幻冒险故事情节开始(在上面的蓝色文字中)。要开始限时挑战，我们必须在 shell 中输入一个request命令。
请求挑战后，命令行文件夹中添加了四个文件:solution.java、solution.py、readme.txt和constraints.txt ，我们必须使用cat and ls命令访问它们(列于help)。
在
***java***或***python 2.7***中，我们有一个选择来解决问题。
要开始编写代码，我们必须运行命令edit file.py或edit file.java，一个代码编辑器将在同一个网页上打开(并使用快捷键save代码)。我们可以通过运行verify file命令随时验证我们的代码。代码将通过在几个测试用例上运行来验证，其中两个是可见的，其余的是隐藏的测试用例。一旦代码准确地通过了所有的测试用例，我们就可以通过运行submit file命令来提交我们对那个问题的解决方案。
(图片由作者提供)
五个层次的足球挑战
随着挑战的深入，难度会不断增加。
第一关:这一关只有一个问题，简单明了，很容易解决。它不需要任何特殊的算法来解决它。给 48 小时来解决这个问题。
第二关:本阶段有两个问题，每个问题的解决时间为七十二小时。这两个问题都是基于线性代数和数学的基本原理。
在解决了这两个问题后，我们会得到一个推荐链接，也就是说，我们可以邀请我们的一个朋友参加 Google Foobar 挑战赛！
第三关:这是挑战开始变得有点棘手的地方。要通过这一关，我们必须解决三个问题，每个问题的时间为七天。
要解决这些问题，需要很好的数学知识和编程概念，如动态编程、马尔可夫链等。
但是如果你不知道这些概念，你也不需要担心，你可以随时在网上学习这些概念。挑战给你足够的时间来理解概念，并在给定的编程问题中实现它们。在其中一个问题中，我用最直观的方法解决了问题，但是对于大值来说不够理想，需要执行动态编程才能得到结果。
使用一些简单的技术优化你的代码
towardsdatascience.com](/beginners-guide-to-dynamic-programming-8eff07195667)
完成第 3 级后，我们被要求填写我们的详细信息，以便与 Google 招聘人员联系！
他们会询问你的基本信息:姓名、电话号码、电子邮件地址、国家、简历(可选)，以及你是学生还是专业人士。
(图片由作者 ) Foobar 招聘表
第四级:我发现这一级是五级中最难的。它需要实现几个概念来解决一个问题。这一级总共有两个问题，每个问题有两个星期的时间来解决。
在这一级需要广泛的算法和数据结构知识。
第一个问题是基于数论和图形的概念。为了解决这个问题，我必须实现贝尔曼-福特算法。
我花了很多时间去理解这些概念，并实现它们来解决这些问题。但是我能够按时解决这两个问题。
成功完成第 4 级后，您将获得另一个推荐链接，邀请您的另一位朋友尝试这项挑战！
第五关:这是整个挑战中第二难的问题，完全基于数学概念。最后一关只有一个问题，给了 22 天的时间来解决这个问题！
该题要求理解排列组合和实施【pólya】计数定理 和 伯恩赛德引理 。理解了这两个定理后，编码部分就简单多了。
随着这个问题的提交，Google Foobar 挑战就完成了！
(图片由作者 ) Foobar 挑战完成
结束挑战后，我得到了一个加密的字符串，使用base64很容易解密。
import base64encrypted="THE ENCRYPTED MESSAGE"my_eyes=str.encode("MY USER NAME")decoded=base64.b64decode(encrypted)decrypted=""for i in range(0,len(decoded)):decrypted+=chr((my_eyes[i%len(my_eyes)] ^ decoded[i]))print(decrypted)
这是我用来解密信息的代码。解密的消息是:
{'success' : 'great', 'colleague' : 'esteemed', 'efforts' : 'incredible', 'achievement' : 'unlocked', 'rabbits' : 'safe', 'foo' : 'win!'}
完成挑战后会发生什么？
在成功完成所有五关之后，谷歌的招聘人员很可能会联系你进行面试。
你可能会收到一封电子邮件或一个电话，如果你通过了面试，那么你就可以被谷歌录用。
如何获得 Foobar 挑战？
不幸的是，这一挑战并不是每个人都可以获得的，谷歌只向特定的开发人员发送(这可能是基于他们的搜索历史——技术关键词)。
如果你没有收到邀请，不要担心，这不是在谷歌找到工作的唯一途径。
不要找 Foobar，让 Foobar 找你！
(图片由作者提供)
结论
我想说这是一个很好的学习机会，如果你收到邀请，我会建议你解决这些问题。
在解决问题的同时，不要把目标放在被谷歌录用上，而是要学习新的技术，体验最好的编码挑战之一。
Foobar 更多的是学习和执行，而不是之前什么都知道！
如果您有任何疑问或意见，请发表在评论区。
要改进你的代码，请点击这里查看我们的文章。
(图片由作者提供)
看看这个:https://www.fiverr.com/share/LDDp34
最初发表于:www.patataeater.blogspot.com
Resources:
[https://foobar.withgoogle.com/](https://foobar.withgoogle.com/)
[https://www.freecodecamp.org/news/the-foobar-challenge-googles-hidden-test-for-developers-ed8027c1184/](https://www.freecodecamp.org/news/the-foobar-challenge-googles-hidden-test-for-developers-ed8027c1184/)
没有学位如何进入数据科学
来自同一职位的数据科学家的建议
介绍
这篇文章是为那些属于下列类别之一的人而写的:
- 你没有大专学位，但你对数据科学感兴趣。
- 你没有 STEM 相关的学位，但是你对数据科学感兴趣。
- 你在一个与数据科学完全无关的领域工作，但你对数据科学感兴趣。
- 你只是对数据科学感兴趣，想了解更多。
你可能在想，“我还有机会吗？”
答案是，“是的，有可能。”
好消息是你已经通过了第一步，那就是你对数据科学感兴趣。现在，这不会是一个轻松的旅程，因为你处于劣势，但要以此为燃料，每天激励自己。
最重要的是，我要给你我的建议，我希望我在开始的时候就有。
首先，简单介绍一下我自己…
我有商科学位，但我从大学二年级开始就对机器学习感兴趣。因此，我自学了今天我所知道的大部分知识，并且我很幸运地在一些数据分析师/数据科学工作中工作过。
我为什么要告诉你这些？我想说清楚，我也曾经和你有过类似的处境！
请记住，这是一个长期目标，因此你应该期待长期结果。如果你愿意投入 100%的精力，我会给你至少一年的时间来决定是否继续。
说完这些，让我们深入探讨一下:
没有学位如何进入数据科学
进入数据科学归结为两件事，成长和展示你的技能。
1)提高您的数据科学技能
不久前，我写了一篇文章，“如果可以重来，我会如何学习数据科学。“在这篇文章中，我按科目划分了要学的内容，即统计&数学、编程基础和机器学习。
在这篇文章中，我将根据你的理解水平来划分你应该学什么。
0 级:基础
你必须从最基本的开始，构建模块，不管你想叫它什么。但是相信我这么说，你的基本面越好，你的数据科学之旅就会越顺利。
特别是，我建议你在以下主题上建立你的基础:统计与概率、数学和编程。
统计和概率:如果你读过我以前的文章，那么你可能已经听过无数次了，但是数据科学家实际上只是一个现代统计学家。
- 如果你很少或者没有接触过统计和数学，我推荐 可汗学院的统计和概率课程 。
- 但是，如果你有一些微积分和积分方面的知识，我强烈推荐你去上乔治亚理工学院的课程，叫做“ 统计方法 ”。当它通过更多的证明时，会有一点困难，但是它会帮助你理解每个想法的复杂性。
数学:取决于你在高中的注意力有多集中，将决定你需要花多少时间学习基础数学。你应该学习三个领域:微积分、积分和线性代数:
- 当涉及到与优化相关的任何事情时，微积分是必不可少的(这在数据科学中非常相关)。为此我推荐 可汗学院的微积分课程 。
- 当涉及到概率分布和假设检验时，积分是必不可少的。我推荐 可汗学院的积分课程 。
- 如果你想进入深度学习，线性代数尤其重要，但即使如此，了解其他基本的机器学习概念也是很好的，如主成分分析和推荐系统。惊喜惊喜，你能猜到我为此推荐什么课程。此处 提供了 的链接。
正如对数学和统计学有一个基本的了解很重要一样，了解编程的核心基础知识会让你的生活变得容易得多，尤其是在实现方面。所以，我建议你在一头扎进机器学习算法之前，先花时间学习基本的 SQL 和 Python 。
- 如果你完全不熟悉 SQL，我推荐你去浏览一下Mode 的 SQL 教程 ，因为它非常简洁透彻。
- 同样，如果你完全不熟悉 Python， Codecademy 是熟悉 Python 的好资源。
第一级:专业化
一旦你学会了基础知识，你就可以专攻了。此时，是否要专注于机器学习算法、深度学习、自然语言处理、计算机视觉等，就看你自己了……
- 如果你想了解更多关于机器学习算法和实现的知识，我可以查看一下 Kaggle 的《机器学习入门》 ， 斯坦福大学的《机器学习教程》 ，或者 Udemy 上的 机器学习 A-Z。看看他们，看看什么最适合你的喜好！
- 如果你想了解更多关于深度学习的知识，可以在这里查看 deeplearning.ai 的专精 。这钱花得值！
- 如果你想了解更多关于 NLP 的知识，这里有来自顶尖大学的 5 门免费自然语言处理课程，像斯坦福和牛津 。
你可以专攻的东西太多了，所以请你在做决定之前多探索一下！
第二级:实践
像任何事情一样，你必须练习你所学的东西，因为你失去了你不用的东西！这里有 3 个我推荐的资源来练习和完善你的技能。
- leet code 是一个很棒的资源，它帮助我学会了我从来不认为是可能的技能和巧妙的技巧。这是我在找工作时充分利用的东西，也是我会经常回去查阅的资源。最好的部分是，他们通常有推荐的解决方案和讨论板，因此您可以了解更有效的解决方案和技术。
- 熊猫练习题: 这个资源 是一个装满了专门为熊猫准备的练习题的资源库。通过完成这些练习题，你将知道如何:过滤和排序数据，汇总数据，使用。apply()操作数据等等。
- Kaggle 是世界上最大的数据科学社区之一，有数百个数据集可供您选择。有了 Kaggle，你可以在比赛中竞争，或者只是利用可用的数据集来创建自己的机器学习模型。
2)展示您的数据科学技能
学习数据科学是一回事，但人们通常忘记的是营销自己——你最终会想要展示你所学到的东西。如果你没有数据科学相关的学位，这对你来说尤其重要。
一旦你完成了几个个人数据科学项目，以下是你展示它们和推销自己的几种方式:
你的简历
首先，利用你的简历展示你的数据科学项目。我建议创建一个名为“个人项目”的部分，在那里你可以列出两到三个你已经完成的项目。
同样，你可以在 LinkedIn 上的“项目”部分添加这些项目。
Github 知识库
如果您还没有创建 Github 库，我强烈建议您创建一个。当我们谈到 Github 时，学习 Git 将是一个好主意。在这里，你可以包含你所有的数据科学项目，更重要的是，你可以把你的代码分享给别人看。
如果你有一个 Kaggle 帐户，并在 Kaggle 上创建笔记本，这也是一个不错的选择。
一旦你有了一个有效的 Kaggle 或 Github 帐户，确保你的帐户网址可以在你的简历、LinkedIn 和你的网站(如果有的话)上找到。
个人网站
说到网站，我强烈建议以网站的形式建立一个数据科学作品集。HTML 和 CSS 很容易学习，这将是一个有趣的项目！如果你没有时间，像 Squarespace 这样的东西也可以。
在媒体上写博客
我有偏见，因为这对我很有效，但这并不意味着我不能推荐博客！有了 Medium 这样的平台，你就可以写项目走查了，就像我在 葡萄酒品质预测 上写的。
非营利机会
最后，利用非营利数据科学机会。我偶然看到苏珊·柯里·西维克、写的一篇足智多谋的文章，文章提供了几个组织，你可以在那里获得从事现实生活中的数据科学项目的机会。
感谢阅读！
我希望这能为您的数据科学事业提供一些指导和帮助。没有一成不变的方法来处理这个问题，所以请放心地持保留态度。尽管如此，我还是希望你在数据科学的努力中一切顺利！
不确定接下来要读什么？我为你挑选了另一篇文章:
为什么数据科学工作可能不适合你
towardsdatascience.com](/4-reasons-why-you-shouldnt-be-a-data-scientist-e3cc6c1d50e)
特伦斯·申
- 如果你喜欢这个， 关注我的 Medium 了解更多
- 报名我的邮箱列表 这里 ！
- 我们连线上LinkedIn
- 有兴趣合作？查看我的 网站 。**
如何从纽交所获取不到 3 行的市场数据(Python)。
在本文中，您将学习使用 Python 包获取股票市场数据，如价格、交易量和基本面数据。(不到 3 行代码)
由 Aditya Vyas 在 Unsplash 上拍摄的照片
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指南 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
在本文中，您将学习使用 Python 包获取股票市场数据，如价格、交易量和基本面数据。(中不到 3 行代码)
首先，在开始之前，您需要安装 Python 3 版本和以下软件包:
- 熊猫
- 熊猫 _datareader
- 日期时间
如果这些软件包中的任何一个尚未安装，您可以使用如下所示的 pip 命令。
pip install pandas-datareader
pip install DateTime
一旦您确保安装了以下软件包，我们就可以开始了。
如果你已经有了使用 Python 的经验，你可以跳到第三步。第一步和第二步包括导入数据并转换为日期格式。
一、进口包装
第一步将包括导入必要的包。
首先，您将使用以下代码行导入先前安装的软件包:
上面的代码行用于导入 python 库。
从 pandas_datareader 库中，我准备只导入数据和 wb 模块。
一旦我们设置好了，让我们进行下一步。
现在库已经导入，第二步将由将日期转换成日期时间格式组成。
二。将日期转换为日期时间格式
如果您之前已经转换过日期，则此步骤不是强制性的。但是，如果您没有，我建议您使用下面的代码行:
在上面的代码行中，Python 将日期从字符串格式转换为日期时间格式。
你会注意到，关于结束日期，我故意用今天作为结束日期。这是 DateTime 模块的优点之一。它将不断地让你的笔记本保持最新的日期。
例如，如果您在 3 个月后重新运行您的内核，您的数据框架和图表将会用最新的市场数据进行更新。
设置好开始和结束日期后，我们现在可以导入市场数据。
三。使用 Yahoo Finance 或 Alpha Vantage API 导入数据
既然我们已经以正确的格式转换了开始和结束日期。我们将使用 Tesla 作为例子来设置我们的导入。
Pandas DataReader API 将需要 4 个强制参数，顺序如下:
- 心脏
- 特定的 API(雅虎、AlphaVantage、sooq……)
- 开始日期
- 结束日期
- 和潜在的 API 密钥
对于我们的例子，股票代码将是 TSLA ，API 将是雅虎，开始和结束日期已经在上面定义了(从 2020 年 2 月 4 日到今天)。快速提醒一下，特斯拉的股票代码是 TSLA 。
因此，让我们通过使用下面的代码行来尝试这种组合:
让我们检查一下输出…
输出:
嘣！！！
你得到的市场数据包括成交量、最高价、最低价、开盘价和调整收盘价。
我希望你喜欢这篇文章，如果你有任何问题或使用不同的方式，评论如下。
赛义德·莱萨尼
完整的 Python 代码:
来源:
(1)一天学会算法交易:
交易 707 是数据科学家和交易员的结合。我们都在伦敦工作和生活。我们觉得累了…
www.udemy.com](https://www.udemy.com/course/learn-algorithmic-trading-in-one-day/?couponCode=TOWARDSCIENCE)*
如何在 operator 中使用 SQL 获得更多洞察？
使用 IN 运算符跨表合并数据
我们都知道 SQL IN 是一个有用的操作符，它允许您在 WHERE 子句中选择多个条件。然而，IN 操作符甚至比您想象的更有用。在中，您可以跨表合并数据。
一个使用 Google BigQuery 公共数据集的例子
为了举例说明，我将快速浏览一遍教程。我使用 Google BigQuery 的公共数据集，名为 austin_bikeshare 。因此，你可以很容易地按照我的代码来练习。
这个数据集中有两个表。 bikeshare_stations 表格包含有关站点名称、状态和位置的信息。 bikeshare_trips 表包括关于行程的开始时间、结束时间、开始站、结束站、持续时间和订户类型的信息。
作为一名数据分析师，我可能想通过出行次数了解每个起点站的性能。然而，我只对仍然活跃的站感兴趣。因此，我可以把我的问题框定如下:
每个活动始发站进行了多少次旅行？
您可以从 bikeshare_trips 表中轻松找到始发站和相关的行程。但是，每个站点的状态位于 bikeshare_stations 表中。解决方案可能是使用 JOIN:
还有一个使用 IN 的解决方案，在这个方案中，您不必使用 JOIN。首先，通过从 bikeshare_trips 表中计算行程 id，选择所有起点站的名称和行程数。然后，在 WHERE 子句中，编写一个子查询，从 bikeshare_stations 表中选择所有活动的站点，并使用 in 运算符。结果，所选择的站被限制在活动站的子集内，而不是所有站。代码如下:
另一个 Leetcode 问题的例子
我用 607 号问题(销售人员)来进一步说明。问题是选择表销售人员中的所有姓名，他们没有销售给“RED”公司。
表:salesperson
+----------+------+--------+-----------------+-----------+
| sales_id | name | salary | commission_rate | hire_date |
+----------+------+--------+-----------------+-----------+
| 1 | John | 100000 | 6 | 4/1/2006 |
| 2 | Amy | 120000 | 5 | 5/1/2010 |
| 3 | Mark | 65000 | 12 | 12/25/2008|
| 4 | Pam | 25000 | 25 | 1/1/2005 |
| 5 | Alex | 50000 | 10 | 2/3/2007 |
+----------+------+--------+-----------------+-----------+
表:company
+---------+--------+------------+
| com_id | name | city |
+---------+--------+------------+
| 1 | RED | Boston |
| 2 | ORANGE | New York |
| 3 | YELLOW | Boston |
| 4 | GREEN | Austin |
+---------+--------+------------+
表:orders
+----------+------------+---------+----------+--------+
| order_id | order_date | com_id | sales_id | amount |
+----------+------------+---------+----------+--------+
| 1 | 1/1/2014 | 3 | 4 | 100000 |
| 2 | 2/1/2014 | 4 | 5 | 5000 |
| 3 | 3/1/2014 | 1 | 1 | 50000 |
| 4 | 4/1/2014 | 1 | 4 | 25000 |
+----------+----------+---------+----------+--------+
由于该问题仅询问销售人员的姓名，因此从销售人员表中选择姓名是有意义的。然而，那些没有销售给“红色”公司的呢？
在这个场景中，IN 操作符发挥了作用。我们不用 IN，而只用 NOT IN。首先，我们通过连接 orders 表和 company 表，选择销售 id，并使用公司名称为“RED”的条件，来选择与公司“RED”有销售关系的雇员子集。然后，我们只需选择不属于该子集的销售 id。以下是需要遵循的代码:
通过这两个例子，我希望您能更好地理解如何使用 IN 操作符在不使用 JOIN 的情况下跨表合并数据。
借助 RapidsAI，将您的机器学习管道速度提高 300 倍
你有没有在 GPU 卡上运行过最近邻！没有吗？那你为什么还不读书？
https://unsplash.com/photos/9HI8UJMSdZA
当在大型数据集上使用简单的机器学习算法(如最近邻算法)时，找到好的模型超参数甚至建立强大的交叉验证框架往往会变得很困难，因为即使使用简单的训练测试分割，也需要模型时间来完成训练！克服这个问题的一种方法是使用 Dask 或 PySpark 在 CPU 上进行分配。但是今天我想向您展示另一种方法——使用您的 GPU 能力来拟合模型。以前从 sklearn 库中没有好的方法可以做到这一点，但是现在你可以使用 Rapids AI cuML 库来适应绝大多数 Sklearn 模型！在这篇文章中，我想给你看一个 Rapids cuML 和 Sklearn 在近邻算法上的快速比较。如果你对安装过程感兴趣，在 Rapids github 页面上有很好的描述。我们开始吧！
代码
我将使用 Kaggle 平台，该平台每周提供 30 小时的免费 K-80 GPU 使用(TPU 也可用)。
首先，让我们从两个库中导入最近邻算法。这两个库中的 API 调用看起来是一样的。
现在，我将使用sk learn . datasets . make _ blobs方法创建一个虚拟数据集。我将创建 5 个不同大小的数据集:从小到大。在每个数据集上，我将使用 10 个邻居来拟合最近邻居模型，然后计算测试集中每个点的最近邻居。让我们先来拟合 Rapids GPU 最近邻。
如你所见，它运行得非常快。现在，是时候适合 Sklearn 了。
哇！这真的很长。正如你在小数据集上看到的，sklearn 优于 rapids，但在最大数据集上，我们获得了 300 倍的速度提升。
让我们也使用 Plotly 构建一个小的比较图(我将使用 log 转换，以便更好地显示结果)
哇，我有时候还是不相信会有这么大的速度提升，cuML 库绝对值得一试！将 Rapids 与 Dask 之类的东西进行比较也很有趣，但这是另一篇文章的想法。
感谢您的阅读！
你可以在我的 网站 上查看其他帖子
如何用机器学习技术获得更多的 YouTube 浏览量
Python 中流行健身频道的循序渐进过程
来源: Pixabay
在本帖中，我们将机器学习算法应用于 YouTube 数据，就如何获得更多浏览量提出建议。
我们将包括端到端流程
- 抓取 YouTube 数据
- 在视频标题上使用自然语言处理
- 特征工程
- 构建预测决策树
- 更多
尽在 Python 。
如果你想知道数据科学如何帮助 YouTube 频道获得更多的浏览量/收入，那就看看吧。
让我们开始吧。
我们正在分析的 YouTube 频道是Sydney Cummings——我们最喜欢的教练。她发展很快，最近已经超过了 20 万用户。
此外，Sydney 每天都会发布各种锻炼视频，这是一个很好的分析数据量。
今天没健身吗？下面是她最近的一个视频。
30 分钟手臂撕裂和强健臀肌锻炼！🔥燃烧 310 卡路里！* 🔥
你可能已经注意到她的视频的标题都遵循标准格式。它们通常包括长度、身体部位、消耗的卡路里和其他关于锻炼的描述性词语。在我点击这个视频之前，我会知道:
- 30 分钟——我将在 30 分钟内完成整个锻炼。
- 手臂和臀大肌——我会在手臂和臀大肌上下功夫，重点是力量。
- 燃烧 310 卡路里——我会燃烧相当多的卡路里。
我们将分析这些关键信息。
让我们看看是否可以向 Sydney 推荐任何新的内容创作策略来进一步改进甚至！
准备:收集数据
抓取 YouTube 数据有不同的方法。由于这只是一个一次性项目，我们用最简单的方法来做，这需要手工操作，但是不需要额外的工具。
以下是逐步程序:
- 将向下滚动到频道的视频页面，直到所有视频都出现。
- 右击最新的视频，选择“检查”。
- 将光标悬停在每行上，找到 HTML 代码/元素的最低级别，突出显示所有视频。
例如，我们使用 Chrome 浏览器，它看起来是这样的:
4.右键单击元素并选择“复制”，然后选择“复制元素”。
5。将复制的元素粘贴到文本文件中并保存。我们使用 JupyterLab 文本文件，并将其保存为 sydney.txt 。
6。使用 Python 提取信息和清理数据。我们不解释细节，因为每个案例都不一样。为了您的方便，这里的代码是。
现在我们可以开始有趣的部分了！
我们将从该数据集中提取特征，并研究影响视图数量的特征。
步骤 1:观察数据
将数据加载到 Python 是在最后一节完成的；让我们来看看我们的数据集 df_videos 。
df_videos 有 8 个描述每个视频细节的特征，包括:
- 标题
- 时间发布 _ 之前
- 长度
- 视图
- 链接
- 卡路里
- 发布日期
- 天 _ 自 _ 贴
还有 837 个视频。
此外，我们发现数据中存在重复，因为 Sydney 多次上传了相同的视频。但是我们会忽略它，因为重复的很少。
第二步:用自然语言处理技术对视频进行分类
在这一步中，我们着重于根据标题中的关键字对视频进行分类。
我们希望根据以下内容对视频进行分组:
- 这段视频关注的是身体的哪些部位？
- 这个视频到底是在帮我们增力还是减脂？
- 其他关键词？
我们使用自然语言处理技术和自然语言工具包来处理标题。
在这篇文章中，我们不会解释这些技术的所有细节。如果你不熟悉的话，可以看看这篇文章(如何在 Python 中使用 NLP:一个实用的分步示例)。
形成关键词列表
首先，我们标记视频的标题。
此过程使用空格(" ")等分隔符将标题文本字符串显式拆分为不同的标记(单词)。这样，计算机程序可以更好地理解文本。
这些标题中有 538 个不同的单词。列表的顶部在下面。
很多词使用频率很高。这再次证明悉尼确实使用标准格式的视频标题。
通过查看上面的列表，我们创建了 3 个关键字列表，可用于在未来的步骤中对视频进行分类。
- body_keywords —标识视频关注的身体部位，如“丰满”的身体、“腹肌”、“双腿”。
- 健身程序 _ 类型 _ 关键词 —显示健身程序类型，如“有氧”、“拉伸”、“力量”。
- other_keywords —包括经常使用但难以归类的关键词，如“训练营”、“倦怠”、“调色”。
对关键字列表进行词干分析
在形成这些关键字列表后，我们还提取它们。词干提取过程确保计算机程序能够匹配具有相同意思的单词。
比如“abs”和“ab”这两个词，词干“ab”是一样的。
标记和词干化 YouTube 标题
除了关键词，我们还需要对标题进行分词和词干处理。
这些过程为进一步匹配准备了关键字和标题列表。
相关文章:
现在我们已经准备好构建特性了！
步骤#3:设计特性
经过头脑风暴，我们提出了与 Sydney 的 YouTube 视图相关的两种主要类型的功能——基于关键字和基于时间。我们一个一个来看。
基于关键字的功能
-指示器特征
感谢上一步的辛勤工作，我们有了 3 个关键词列表和精简的标题。我们现在可以匹配它们来对视频进行分类。
对于 body_keywords 和 workout_type_keywords ，一个视频中可能有多个关键字。所以在匹配之前，我们还要创建 2 个特征区域和健身类型。这些功能将一个视频的所有身体部位和锻炼类型连接成一个字符串。
例如，一个健身视频可以同时做“ab”和“leg”，或者同时做“cardio”和“strength”。该视频的功能区域为“ab+腿部”，锻炼类型为“有氧+力量”。
同时，我们还识别出“总”和“全”、“核心”、“ab”等相似的关键词，并进行分组。
最后，我们创建三种不同类型的虚拟特征:
- is_{}_area 用于识别视频中是否包含特定的身体部位。
- 是 _ { } _ 健身程序用于识别健身程序类型。
- title_contains_{} 查看健身程序标题是否包含其他关键字。
明确地说，“腿部力量耗尽锻炼”的视频标题将具有 is_leg_area = True、is_strength_workout = True 和 title _ contains _ burnout = True 而所有其他指标都是假的。
请阅读下面的 Python 代码了解详细信息。
-频率特性
除了这些指标，我们还创建了三个功能，称为 num_body_areas 、 num_workout_types 和 num_other_keywords 。他们计算一个视频标题中提到的关键词的数量。
举个例子，标题“腹肌和腿部有氧力量锻炼”的 num_body_areas 和 num_workout_types 都是 2。
这些功能有助于我们确定视频中应包含的最佳身体部位数量或锻炼类型。
-费率特性
最后但同样重要的是，我们创建一个功能卡路里每分钟查看卡路里燃烧率。
毕竟，我们都想要一些明确的(可量化的)锻炼目标。
资料来源: Giphy
在进入基于时间的功能之前，我们还修复了几个分类错误的视频。该过程是手动的，所以我们在这里不包括它们。
基于时间序列的特征
通过上述基于关键词的特征，我们已经可以找到特定的流行类型的视频。但这是否意味着悉尼应该总是发布相同类型的视频？
为了回答这个问题，我们还创建了一些基于时间序列的功能:
- num_same_area —过去 30 天内关注同一区域的视频(包括当前视频)数量。
例如，当当前视频关注上身时，此功能= 6，并且在过去 30 天内还有 5 次其他上身锻炼。 - num_same_workout —此功能与 num_same_area 相似，不同之处在于计算健身程序类型。
例如，当当前视频是一个 HIIT 健身程序，并且在过去 30 天内还有 2 个其他 HIIT 健身程序时，此功能= 3。 - last_same_area —自上一个视频聚焦于与当前视频相同的身体区域以来的天数。
比如当前视频聚焦 abs 时这个特征= 10，之前的 abs 视频是 10 天前的。 - last_same_workout —该功能与 last_same_area 类似，只是比较了不同的健身程序类型。
- num_unique_areas —过去 30 天内处理的唯一身体区域的数量。
- num_unique_workouts —过去 30 天内发布的独特锻炼类型的数量。
这些特征有助于我们看到观众更喜欢相似的还是各种类型的视频。
下面看看特征工程的详细流程。它包括一些转换以适应熊猫的滚动功能。
我们发现 Sydney 偶尔会发布一些与锻炼无关的视频。他们获得的浏览量明显更少，表现也与锻炼视频不同。所以我们把它们从分析中剔除。
我们还过滤掉前 30 天的视频，因为它们缺乏足够的历史数据。
多重共线性测试
多重共线性(也称共线性)是一种现象，在这种现象中，多元回归模型中的一个预测变量可以通过其他预测变量以相当高的准确度进行线性预测。
多重共线性不会降低模型整体的预测能力或可靠性，至少在样本数据集内是如此；它只影响关于单个预测因子的计算。
正如维基百科解释的那样，多重共线性确实会影响个体特征对结果的影响力。
为什么这很重要？
假设 Sydney 只在周一发布力量训练，她的视频总是在周一获得更多的浏览量。这些视频获得更高的浏览量是因为它们发布在周一还是因为它们是力量训练？
在做推荐的时候，我们希望回答这些类型的问题。因此，我们希望确保我们的要素之间没有强烈的共线性。
既然我们已经清楚了多重共线性测试的原因。让我们看看我们应该使用哪种方法。
我们经常使用成对相关来测试共线性，但有时这是不够的。多个要素(多对)之间可能同时存在共线性。
因此，我们使用一种更复杂的方法。在高层次上，我们使用 K 倍交叉验证来实现这一点。
详细过程如下:
- 根据我们的判断选择一组关键特征来测试共线性。
我们选择以下特征，因为它们对于预测 YouTube 视频的观看量至关重要。
可以看到，我们还添加了三个由随机数组成的特征 rand0 、 rand1 、 rand2 。在比较特征之间的关系时，它们充当锚。如果一个预测特征与这些随机特征相比不太重要或相似，则它不是目标特征的重要预测。
- 为 K 倍交叉验证准备这些特征。
在此过程中，我们转换了分类特征区域和锻炼类型。这种转换确保每个类别级别至少有 K 个值。
- 使用其中一个特征作为目标，其余特征作为预测器，训练预测模型。
接下来，我们遍历每个特征，并使用其他特征拟合一个模型来预测它。我们使用一个简单的模型梯度推进模型(GBM) 和 K 倍验证。
根据目标特征是数值的还是分类的，我们应用不同的模型和分数(模型预测能力评估度量)。
当目标特征为数值时，我们使用梯度推进回归器模型和均方根误差(RMSE)；当目标特征是分类的，我们使用梯度推进分类器模型和精确度。
对于每个目标，我们打印出 K 倍验证分数(分数的平均值)和最重要的 5 个预测值。
- 研究每个目标特征的得分和重要预测因素。
我们研究每个目标特征以及它们与预测因子的关系。我们不会涵盖整个过程，而只是解释下面的两个例子。
我们发现长度和卡路里特征是相关的。这一发现很直观，因为锻炼时间越长，燃烧的卡路里可能就越多。
我们也可以想象这种关系。
如你所见，长度和卡路里之间存在正相关关系。但是它不够强壮，我们不能扔掉它们。40-45 分钟的视频中燃烧的卡路里与 30-35 分钟、50-55 分钟甚至 60 多分钟的视频重叠。因此，我们保留了它们。
我们还发现 num_same_area 和 area_full 特征是相关的。这一发现有些令人惊讶。我们来探究一下原因。
下图显示了 num_same_area 和 area 之间的关系。
num_same_area 功能统计过去 30 天内发布的关注同一区域的视频(包括当前视频)的数量。特色 area_full 代表全身锻炼，是悉尼视频中最常见的类型。
因此，当 num_same_area 较大时，这些视频关注的唯一可能的区域是整个身体。
假设我们发现更高的 num_same_area (>=10)确实会导致更高的 YouTube 浏览量。我们无法知道是因为 area_full 还是 num_same_area。所以我们放弃了 num_same_area 特性来防止这种情况。
除此之外，我们还使用类似的逻辑删除了 num _ same _ outsets。
步骤#4:创建目标
你可能还记得，这个项目的目标是增加 YouTube 的浏览量。我们是否应该仅仅以浏览量作为我们的目标？
观点的分布是高度倾斜的。视频的平均浏览量为 27，641 次，最高浏览量为 130 万次。这种偏斜会给模型的解释带来问题。
因此，我们创建 feature views_quartile 作为目标，而不是视图。
我们将视频分为两类——高浏览量视频(“高”)和低浏览量视频(“低”)。“高”被定义为第 75 百分位的视图(35，578)或以上，而“低”则不然。
通过这种方式，我们使用预测模型来找到产生前 25%观看视频的特征组合。这个新目标提供了稳定的结果和更好的见解。
步骤#5:构建决策树
最后，我们拥有了构建模型的一切！
我们在 target views_quartile 上训练决策树模型。
为了避免过度拟合，我们将一片叶子的最小样本设置为 10。为了便于理解，我们将树的最大深度设置为 8 级。
相关文章: 如何可视化 5 步决策树
步骤 6:阅读决策树
在这最后一步，我们研究并总结导致高视图或低视图的“分支”。
我们发现的主要洞见是什么？
洞察力#1:每分钟燃烧的卡路里是最重要的特征
是的，卡路里每分钟是最重要的特征。
人们似乎不太关心锻炼的类型或身体的部位。
在每分钟消耗的卡路里较高(≥ 12.025)的锻炼中，51/(34+51) = 60%的视频观看率较高。
而每分钟消耗热量较少(≤ 9.846)的视频比其他视频受欢迎程度低得多。只有 12/(154+12) = 7.2%的浏览量很高。
对于每分钟消耗的卡路里中等的视频(介于 9.846 和 12.025 之间)，其他因素开始起作用。
当然，每个人都想高效地燃烧卡路里！
洞察力#2:不同身体部位的各种独特锻炼不会增加视野
这种洞察力和我们想象的有些不同。健身项目的多样性不是更好吗？
当过去一个月工作的独特身体区域的数量(num_unique_area)高(≥ 10)时，视频往往具有较低的观看率。即使每分钟燃烧的卡路里很高，这种说法也是正确的。
结合前面两种观点，42/(12+42) = 78%的视频在以下情况下获得了更多的观看次数
- 每分钟燃烧的卡路里很高(≥ 12.025) 和
- 过去一个月中工作的独特区域的数量较少(< 10)。
最近几个月提到的太多身体部位可能会给观众造成困惑。
洞察力#3:臀部锻炼很受欢迎
当一个视频燃烧的卡路里较少(卡路里 _per_min ≤ 9.846)时，5/(10+5) = 33%的人只要是屁屁锻炼，仍然获得高浏览量；然而，只有 7/(144+7) = 4.6%的非屁股有高的看法。
虽然我们在树上看不到其他特定的身体部位，但悉尼的观众想找出“屁股”区域！
获得更多视图的可能建议
那么，我们可以向悉尼推荐哪些策略呢？
策略 1:燃烧更多卡路里🔥
我们可以看到，每分钟燃烧的卡路里是最重要的特征。每分钟燃烧 12.025 卡路里似乎是神奇的数字。
下表是不同长度的热门视频应该燃烧多少卡路里的良好起点:
- 30 分钟锻炼:361 卡路里
- 40 分钟锻炼:481 卡路里
- 50 分钟锻炼:601 卡路里
- 60 分钟锻炼:722 卡路里
我们怀疑数字(长度和卡路里)的显示是心理作用。人们可能喜欢看到卡路里的前两位数字形成一个比长度大得多的数字。
策略 2:使用较少不同的身体部位关键词🔻
有时候少就是多。
人们不喜欢健身标题中描述的太多独特的身体部位。根据我们的模型，一个月内专注于少于 10 个身体部位组合更好。
我们注意到 Sydney 在她最近的视频中使用了更少的身体部位关键词。最明显的一个是她一直使用“手臂”或“上身”，而不是像“二头肌”或“背部”这样的词。
策略 3:创造更多的臀部锻炼🍑
悉尼的订户可能更多是女性，她们倾向于关注锻炼“臀部”，而不是获得肌肉发达的手臂。人们愿意牺牲燃烧更少的卡路里来获得更健美的臀部。也许悉尼应该总是包括一些燃烧更少卡路里的视频。
额外策略
除了上述策略，还有其他想法值得进一步研究。
例如，悉尼可以尝试:
- 在月初发起新的活动。
月初发布的视频更容易获得较高的浏览量。也许人们喜欢设立新的目标来开始新的一个月。 - 避免在 5 天内发布相同类型的锻炼。
这是一个我们正在尝试开发的应用程序，用来提高 YouTube 的浏览量。有一些限制:
- 这些建议基于过去的经验。YouTubers 倾向于尝试超越他们过去常规的创新想法。鉴于这一点，我们可以将机器学习应用于他们的既定竞争对手，以获得洞察力。
- 我们只关注标题的分析。还有其他数据，比如可以抓取的视频标题。它们也可能包含有价值的见解。
- 我们的数据比 YouTube 频道的所有者还少。还有其他重要信息，如用户统计数据。可能会有更多的特性、更多的见解以及对这些见解的更好的解释。
感谢您的阅读。我们希望你觉得这篇文章很有趣。
留下评论让我们知道你的想法！
【https://www.justintodata.com】原载于 2020 年 3 月 1 日。
更多来自 Lianne & Justin 的关于数据科学的文章，请在 网站 上注册我们的电子邮件简讯。我们在推特上分享它们，有时也会在媒体上发布。
* [## Python 中的数据清理:终极指南(2020)——只进入数据
我们用 Python 创建了这个新的完整的分步指南。你将学习如何寻找和清理的技巧:丢失…
www.justintodata.com](https://www.justintodata.com/data-cleaning-python-ultimate-guide/) [## 如何在 Python 中使用 NLP:一个实用的分步示例——只进入数据
在这篇文章中，我们展示了一个分步的 NLP 应用程序。这是对…的技术解释
www.justintodata.com](https://www.justintodata.com/use-nlp-in-python-practical-step-by-step-example/) [## 如何提高体育博彩赔率 Python 中的一步一步指南-只是进入数据
体育博彩可能不仅仅是利用你的直觉。查看我用来赚 20，000 美元的数据科学策略…
www.justintodata.com](https://www.justintodata.com/improve-sports-betting-odds-guide-in-python/)*
使用 C#或 Python 生成 OneDrive 直接下载链接
为新冠肺炎数据集生成直接下载链接并导入熊猫数据框架的示例
插图作者:金彩云
在许多项目中，您可能需要文件托管服务来共享大量数据集、脚本或任何带有直接下载选项的文件。你可能已经在使用最流行的托管服务，比如 Google Drive、微软 OneDrive、DropBox 和 iCloud。在这篇文章中，我将重点介绍如何从 OneDrive.com 的制作直接下载链接。
为什么直接下载链接？
直接下载可以让你在其他软件中灵活地使用这个文件。例如，如果您托管带有直接下载链接的 excel 或 csv 表数据集，接收者可以直接将其加载到 Python 中的 Pandas 数据框架。
为什么选择 OneDrive？
我想我没有必要介绍那么多关于 OneDrive 的东西。它免费提供 5 GB 的存储空间。这对任何大型数据集来说都足够了。如果您有非常大的数据集要共享，请考虑数据库。你们大多数人甚至有微软 Office 365，其中包括 1 TB 的在线空间。此外，它很容易使用，分享，在线编辑。
我们开始吧
共享你的 OneDrive 文件
您只需转到 OneDrive，拖放到那里上传任何文件，单击页面顶部的“共享”按钮，然后单击复制链接。就是这样！
与微软 OneDrive 共享 CSV 文件【全球新冠肺炎病例时间序列 CSSE 】(作者)
例如，我通过 OneDrive 以 excel 表格的形式分享了来自 CSSE 的新冠肺炎时间序列数据集。当您通过您创建的链接访问该数据集时，浏览器将自动打开 Excel Online，以便您以表格格式浏览该数据集。多方便啊！
查看可分享的 CSV 文件【全球新冠肺炎病例时间序列来自CSSE】来自 OneDrive 链接(作者)
但是，不幸的是，如果您的接收者想要下载数据集，它需要几次点击或重定向。所以，如果你的目的是让你的接收者下载文件，你最好分享一个直接下载链接。
生成 OneDrive 直接下载链接
根据 OneDrive API 文档，您可以使用以下逻辑轻松生成 OneDrive 直接下载链接:
- 首先，使用 base64 编码 URL。
- 通过删除值末尾的
=字符，用_替换/，用-替换+，将 base64 编码的结果转换为未填充的 base64url 格式。) - 追加
u!作为字符串的开头。
选项 1:用 C#生成直接下载链接
为了遵循上述逻辑，OneDrive API 文档还为您提供了一个 C#示例脚本，如下所示:
string sharingUrl = **"Your OneDrive Link here";**
string base64Value = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(sharingUrl));
string encodedUrl = "u!" + base64Value.TrimEnd('=').Replace('/','_').Replace('+','-');
您可以尝试使用以下链接在 C#中在线运行该脚本:
[## 从 onedrive.com 获得直接链接，C# - rextester
用 C#从 onedrive.com 获得直接链接
rextester.com](https://rextester.com/QNSY6325)
打开链接后，您只需将sharingUrl更改为您的任何一个 OneDrive 链接。等待几秒钟，然后您会在输出控制台中获得输出 direct OneDrive 下载链接。
从 onedrive.com 获得直接链接(作者)
选项 2:用 Python 生成直接下载链接
Python 在许多数据科学项目中很受欢迎。因此，在对数据集进行数据分析之前，您可能希望直接在 Python 中生成一个直接下载链接。如果有人(或您自己)共享 OneDrive 链接，您可以使用以下 Python 脚本将其转换为可下载的链接:
one drive _ DD _ generator . py(作者)
例如，您可以按照下面的脚本以 excel 格式从我们的新冠肺炎数据集示例中生成直接下载链接。URL:https://1drv.ms/x/s!AmLiprCs46qqhMgFb5pcJisePNNlXw?e=ZgPsGZ然后导入到熊猫数据框:
**import pandas as pd** # Input any OneDrive URL **
onedrive_url = "**[**https://1drv.ms/x/s!AmLiprCs46qqhMgFb5pcJisePNNlXw?e=ZgPsGZ**](https://1drv.ms/x/s!AmLiprCs46qqhMgFb5pcJisePNNlXw?e=ZgPsGZ)**"**# Generate Direct Download URL from above Script
**direct_download_url = create_onedrive_directdownload(onedrive_url)
print(direct_download_url)**# Load Dataset to the Dataframe
**df = pd.read_excel(direct_download_url)
print(df.head())**# Continue with your data analysis ...
****上面脚本的输出数据帧示例。(作者)
结论
本文介绍了如何通过 OneDrive 分享你的文件，并用 C#或 Python 将其转为可直接下载的链接。请注意，您也可以使用 apply 这个逻辑并用任何其他编程语言重写它。
我希望你喜欢这篇文章，并发现它对你的日常工作或项目有用。如果您有任何问题或意见，请随时给我留言。
关于我&查看我所有的博客内容:链接
祝平安和健康！💪
感谢您的阅读。📚
如何对 HTAP 数据库进行基准测试
整合数据库以降低成本并变得实时
塞尔吉奥·费拉古特和蒙特·兹韦本
如何在不崩溃的情况下整合您的 RDBMS 和数据仓库(图片: Sawitre
你曾经为了昨天的销售报告等了一夜吗？或者，您可能渴望通过实时销售点和订单管理数据预测库存需求的最新需求预测。我们总是在等待我们的分析。更糟糕的是，要求修改我们的报告通常需要几周时间。雪上加霜的是，您一直在为专用分析数据库不断增加的成本缴税。
但是如果这不再是必要的呢？如果您可以整合分析，使其与运营工作负载在同一个数据库上运行，会怎么样？你的第一反应可能是，“你疯了。我们将分析从数据库中移走，因为它永远不够快。”过去是这样，但现在不是了。现在，通过将您的分析整合到一种称为混合事务分析平台(HTAP)的不同类型的 SQL RDBMS 上，可以降低您的数据库成本。一些 HTAP 数据库可以是专门的工程系统，可能花费数百万美元。但是在一个横向扩展架构上有一种新的 HTAP。这种架构将数据分布在多个服务器上，并在每个服务器上的不同引擎上执行计算，以实现混合工作负载的规模和性能。
HTAP 是 Gartner 创造的一个术语，用来描述新兴的数据库技术和应用程序，这些技术和应用程序可以提供在线事务处理(OLTP)和分析处理(OLAP)，从而产生更丰富的应用程序体验和更多的商业价值。Forrester 称之为 Translytical 数据平台。如果没有这种平台，企业将被迫通过利用运营数据存储、数据仓库和数据集市的复杂管道来转换数据并将其移出应用数据库，以便最终实现分析和数据科学。这非常耗时，并导致以下方面的延迟:
- 生成报告
- 更新已部署的机器学习模型的特征，从而对旧数据进行预测
- 机器学习模型重新训练，导致模型不太准确。
在这篇博客中，我们展示了如何测量 HTAP 工作负载的性能。为此，我们将在同一组表上同时运行的 TPC-C 和 TPC-H 基准组合起来。TPC-C 模拟批发零售企业用户接受销售订单、处理付款、进行库存水平检查，并在大量交易数据上以高并发性记录交付。TPC-H 基准测试由 22 个复杂的分析查询组成，这些查询以相对较低的并发性扫描大量历史数据。
我们在这里使用开源基准测试项目来驱动最初发表在The mixed workload CH-benCHmark，Richard Cole 等人，db test’11，Athens，Greece 中的测试。基准测试依赖于 OLTP-Bench 中提供的代码:一个用于对关系数据库进行基准测试的可扩展测试床，D. E. Difallah，A. Pavlo，C. Curino 和 P. Cudre-Mauroux 在 2014 年 VLDB 大会上。这种处理 HTAP 工作负载的方法从 TPC-C 作为基线开始，然后覆盖修改后的针对 TPC-C 模式的 TPC-H 查询。我们已经让位于这里的集群免费试用。
TPC-C 新订单交易
我们测试的工作负载运行中测量的事务不是单个 SQL 语句，而是实际上复杂的应用程序逻辑，由一系列打包在 ACID 事务中的 select、insert 和 update 语句组成，这些语句要么作为一个整体提交，要么作为一个整体回滚。每个新订单事务平均由十个不同的行项目组成，平均需要 46 条 SQL 语句来处理。
我们的实验是在 AWS 上的开源 RDBMS 平台即服务的拼接机器上进行的。(声明:两位作者都在 Splice Machine 工作，一位是 CEO)。Splice Machine 为数据工程师和数据科学家提供集成开发环境的“笔记本”。这些笔记本包括用于多语言编程的 JupyterLab 和 BeakerX，跨单元格的变量共享，以及许多其他很酷的编码和可视化 API。下面一组 Jupyter 笔记本单元格显示了构成新订单事务的 SQL 语句。为了简化这里给出的代码，我们对示例事务的一些元素进行了硬编码:我们在订单中使用了一个商品，并将订单保存在同一个仓库的本地。基准并不局限于此。
新订单交易从客户和地区查找开始，以便获得折扣、信用和税收信息，并保留订单 id，这些都是处理新订单所需要的。我们在这里使用一个 python 单元来存储 SQL 的结果，并为多语言访问设置一些 BeakerX 变量:
接下来，我们更新该地区递增的下一个订单 id，在 order 和 NEW_ORDER 表中创建一个新的订单条目，并检查所订购商品的仓库库存水平:
接下来，应用程序逻辑计算订单中每个项目的订单总数和补货需求，更新库存记录，并创建订单行记录。在示例代码中，我们只做一次，但是在实际的基准测试中，订单中的每个行项目都会发生一次，平均每个订单 10 次。
TPC-H 查询
TPC-H 基准旨在测试决策支持系统，为业务运营提供见解。在这里，TPC-H 查询#2 搜索欧洲的供应商，这些供应商具有尺寸为 15 的黄铜零件的最低欧洲价格:
这要求我们首先计算整个欧洲当前的最低价格，然后找到在欧洲以最低价格供应的 15 号黄铜零件。这需要跨大型数据集的多个连接和聚合。这种查询通过使用并行分布式处理进行水平扩展来实现更高的吞吐量。
拼接机 RDBMS 有单独的工作人员负责 OLTP 和 OLAP 工作负载。为了实现以下结果，我们利用了一个由 8 个 m5.2x 大型节点组成的 AWS 集群，该集群由 4 个 OLTP 工作线程和 4 个 OLAP 工作线程组成，同时运行 100 个并发 TPC-C 用户和 8 个并发 TPC-H 用户。Splice Machine 提供了一个免费的试用集群，利用相同的硬件配置和附带的 HTAP 笔记本，让您可以轻松地试验其他并发配置。我们运行了 10 分钟长的 HTAP 工作负载，按工作负载的事务类别测量总计数，并记录所有响应时间。
前两个图表是已完成交易的累计计数。X 轴以秒为单位测量经过的测试时间。在 TPC-C 图表中，计数按请求类型划分，其中测量的每个事务是许多 SQL 语句的集合；图例中的 2I 3U 4S 表示 2 次插入、3 次更新、4 次选择作为最小操作计数。在许多事务中，SQL 语句计数随着订单中项目计数的增长而增长，平均订单大小为 10 个项目。在 TPC-H 查询图表中，我们统计了已执行查询的总数。这些是复杂的查询，涉及表扫描、大型连接和聚合、子查询以及其他开销很大的查询结构。
延迟图表向我们展示了事务响应时间在整个工作负载执行过程中是如何变化的。第 99 百分位线显示，99%的事务运行时间不到一秒钟。第 50 百分位线显示 50%的查询持续运行不到一秒。
总之，在一个 4x4 拼接机数据库上，在 100 个 TPC-C 用户和 8 个 TPC-H 用户的情况下，运行 10 分钟，我们看到完成了 191，789 个 TPC-C 事务和 14 个 TPC-H 查询，99%的查询的 SLA 都在 1.085 秒内运行，但由于测试初始化开销，只有一个 3.3 秒的初始峰值。
接下来，我们想了解如果我们将资源翻倍，这将如何扩展。我们建立了一个 8 OLTP x 8 OLAP 拼接机数据库，并对 100 个 TPC-C 用户和 8 个 TPC-H 用户重新运行了 10 分钟的相同测试:
更多计算资源这导致两种工作负载的吞吐量显著增长:
- TPC-C 交易= 279，480 (+46%)
- TPC-H 查询= 32 次(+128%)
SLA 也更好，99%的事务运行时间不到 0.79 秒。
TPC-H 的增长似乎好于预期，而 TPC-C 没有预期的那么多，因此我们进行了另一项测试，试图更好地理解这一点。我们的理论是 100 个 TPC-C 用户不会使拼接机 OLTP 工作线程饱和，因此我们将 TPC-C 上的并发数增加到 200，并再运行 10 分钟:
该测试的结果是:
- TPC-C 交易= 330，728(与第一次相比增加了 72%)
- TPC-H 查询= 24 次(与第一次相比增加了 71%)
- SLA—99%的交易在 1.3 秒内完成
确认我们仍然可以通过请求更多事务来增加 8x8 的吞吐量。
结论
我们能够运行并发的 TPC-C 和 TPC-H 工作负载，同时保持稳定的事务响应时间。我们还通过将 OLTP 和 OLAP 工作人员增加一倍来测试增加的资源，并看到两种工作负载都有近乎线性的提高。然而，最终测试中 TPC-H 成绩的下降促使我们调查为什么会发生这种情况。
通过检查所有服务的资源消耗，我们意识到使用 CPU 请求的默认 Kubernetes 配置(相对于 CPU 限制)允许一个服务通过抓取分配给其他服务的未使用的 CPU 来消耗超过其分配量的 CPU。
可变资源分配可能是一件好事，也可能是一件坏事，这取决于你的需求。考虑到可变的工作负载，我们可能希望动态地将 OLTP 工作线程的资源用于 OLAP 工作，就像我们在第二个测试中看到的那样，或者当我们增加 OLTP 端的工作时，回收分配给 OLAP 工作的 CPU。另一方面，为了保证 OLTP SLAs，我们可能希望为 OLAP 工作人员尝试固定的 CPU 限制。关于可用配置、如何调整它们以及它们的影响的更多信息将在以后的博客文章中进行深入探讨。
要执行您自己的测试，可以从这里获得基准。数据库启动后，只需点击数据库快速启动页面上的“运行 HTAP 基准”链接。
如何开始分析新冠肺炎数据
Kaggle 上的新冠肺炎公开研究数据集挑战
本月早些时候，Kaggle 发布了一项新的数据集挑战:新冠肺炎开放研究数据集挑战。这一挑战呼吁人工智能专家开发文本处理工具，以帮助医疗专业人员找到高优先级问题的答案。
为此，卡格尔与 AI2 大学、CZI 大学、MSR 大学、乔治城大学、国家卫生研究院和白宫合作，收集了一个“超过 29，000 篇学术文章的数据集，其中包括超过 13，000 篇关于新冠肺炎、新型冠状病毒和相关冠状病毒的全文。”
我相信许多数据科学家正在寻找机会来帮助对抗新冠肺炎疫情，这是一个很好的起点。Kaggle 提供数据，甚至一系列任务供您处理。例如，一项任务是:
我们对新冠肺炎风险因素了解多少？我们从流行病学研究中学到了什么？
为了帮助其他人开始使用这个数据集，我想我会提供一个相当简单的方法来分析数据。需要注意的是，这种方法并不旨在对数据或任务进行全面的审查。相反，只是一个想法被走过，以帮助你有希望开始你的想法。
元数据
我想把精力集中在提供的CORD-19-research-challenge/2020–03–13/all _ sources _ metadata _ 2020–03–13 . CSV文件上。您可以使用以下代码将该文件读入 Pandas 数据框:
meta = pd.read_csv("/kaggle/input/CORD-19-research-challenge/2020-03-13/all_sources_metadata_2020-03-13.csv")
以下是元数据文件的前 5 行:
我们将专门研究抽象栏。该文件中有 29，500 行数据，其中 2，947 行缺少摘要(约 10%)。以下是关于摘要长度(字符数)的一些基本统计数据:
count 26553.000000
mean 1462.129176
std 1063.536406
min 17.000000
25% 1087.000000
50% 1438.000000
75% 1772.000000
max 122392.000000
抽象向量
我的想法很简单:
- 将摘要转换成向量
- 计算余弦相似度以找到与其他摘要相似的摘要
其目标是，如果医学研究人员发现一篇有价值的论文，他或她可以提取该论文的摘要，并快速找到其他相似的摘要。
为了计算我们的抽象向量，我们将利用空间。scispaCy 是一个“Python 包，包含用于处理生物医学、科学或临床文本的 spaCy 模型。”我决定使用 allenai 创建的这个包，因为它是专门为生物医学文本培训的，非常容易使用。我们可以使用以下代码计算所有摘要的向量:
nlp = spacy.load("en_core_sci_sm")
vector_dict = {}
for sha, abstract in tqdm(meta[["sha","abstract"]].values):
if isinstance(abstract, str):
vector_dict[sha] = nlp(abstract).vector
这段代码利用了一个预先训练的单词向量模型，该模型将抽象中的每个单词转换为向量表示，希望这是该单词的良好表示。一个好的表示应该在向量空间中接近其他相似的单词(在非常高的水平上)。然后，对所有的单词向量进行平均，以将摘要表示为单个向量。
我使用 sha 值作为查找键，这样我们可以很容易地将向量与论文联系起来。为了快速处理所有的摘要，我还使用了小版本的模型。在 Kaggle 内核上运行上述代码大约需要 20 分钟。
余弦相似性
既然我们已经将所有的抽象表示为向量，那么使用 sklearn 计算所有的成对余弦相似性就很容易了。余弦相似度是一种比较两个向量相似度的方法。
values = list(vector_dict.values())
cosine_sim_matrix = cosine_similarity(values, values)
我们的余弦相似性矩阵的每个值是两个摘要之间的相似性得分(由行表示的摘要和由列表示的摘要)。值越高，抽象就越相似(假设我们的向量是好的)。因此，我们只需要选择一行(抽象的)并按照具有最大值的索引对它进行排序(忽略它自己的索引，因为它总是与自己最相似)。代码如下:
n_sim_articles = 5
input_sha = "e3b40cc8e0e137c416b4a2273a4dca94ae8178cc"keys = list(vector_dict.keys())
sha_index = keys.index(input_sha)
sim_indexes = np.argsort(cosine_sim_matrix[sha_index])[::-1][1:n_sim_articles+1]
sim_shas = [keys[i] for i in sim_indexes]
meta_info = meta[meta.sha.isin(sim_shas)]
您只需要提供您想要的类似文章的数量和您的查询摘要的输入 sha 就可以获得结果。让我们把下面的例子抽象为一个查询:
【2019 年 12 月，湖北武汉报告有华南海鲜市场暴露史的不明原因肺炎病例。一种新的冠状病毒，新型冠状病毒，被确定是造成这种疾病的原因。人际传播得到证实，这种疾病(被世界卫生组织(世卫组织)命名为新冠肺炎)在全国和全世界迅速传播。截至 2020 年 2 月 18 日，确诊病例数已达到 75，199 例，其中 2009 例死亡。与严重急性呼吸综合征(SARS)和中东呼吸综合征(MERS)相比，新冠肺炎导致确诊病例中的病死率低得多(约 2.67%)。在从已发布的官方报告中收集的 45 例死亡病例的症状构成中，前四位是发烧、咳嗽、气短和胸闷/疼痛。死亡病例的主要共病包括高血压、糖尿病、冠心病、脑梗塞和慢性支气管炎。病毒的来源和这种疾病的发病机理仍未得到证实。还没有发现特定的治疗药物。中国政府已经启动了一级公共卫生响应，以防止疾病的传播。与此同时，加快研制疫苗和治疗药物也至关重要，这将使我们能够尽快击败新冠肺炎。
根据我们的算法，最相似的抽象应该是:
背景:直到 2008 年，在法属圭亚那从未报告过人类狂犬病。2008 年 5 月 28 日，法国国家狂犬病参考中心(巴黎巴斯德研究所)根据一名圭亚那人的皮肤活检和唾液样本的半巢式聚合酶链反应，确认了狂犬病诊断，这名圭亚那人从未出国旅行，在出现临床典型脑膜脑炎后死于卡宴。方法/主要发现:病毒的分子分型鉴定出一种狂犬病毒(狂犬病毒种)，与拉丁美洲吸血蝙蝠(主要是圆齿蝙蝠)中传播的狂犬病毒密切相关。启动了一个多学科危机小组。其目标是实施一项流行病学调查和一项兽医调查，提供控制措施并建立一个交流计划。污染源尚未正式确定，但根据分离出的病毒类型，可能与蝙蝠咬伤有关。在确认 90 人暴露后，他们接种了狂犬病疫苗:42 人来自该病例的随行人员，48 名医护人员。为了应对这一突发事件和当地人口对疫苗接种的日益增长的需求，利用电视、报纸、广播等多种媒体建立了一个专门的宣传计划。结论/意义:这一事件发生在远离法国大陆的一个部门，强烈影响了当地人口、医护人员和当局，管理团队面临巨大压力。这一观察证实了在法属圭亚那感染狂犬病的风险是真实的，并对人口教育计划、控制措施、医疗诊断和暴露后预防产生了影响。
如果你看看前 5 个最相似的摘要，它似乎将查询文章与讨论狂犬病的文章联系起来。在我看来，这似乎不是一个很好的结果。也就是说，我不是医学研究者，所以我可能遗漏了一些东西。但是让我们假设第一遍是没有价值的。
后续步骤
我认为上述想法是合理的。我的猜测是，向量这个词并不特别适合这种研究。下一步，我会在提供的所有论文的文本中寻找训练词向量。这应该有助于向量更好地适应这一研究领域。
此外，还可以进行大量的文本处理，以潜在地改进流程。例如，删除停用词可能有助于减少某些摘要中的噪音。
LinkedIn 上的 Vinit Jain 也建议尝试一下 Biobert 或 BioSentvec，我认为这也是个好主意。尤其是以一种比平均单词向量更聪明的方式将摘要转换成向量的想法。
虽然我第一次尝试为新冠肺炎数据集提供价值时表现平平，但我希望本文实现了它的真正目标，即帮助您开始分析数据。
你可以在这里找到我的 Kaggle 内核和所有讨论过的代码。
这篇文章也可以在这里找到。
有兴趣了解有关 Python 数据分析和可视化的更多信息吗？查看我的课程。
如何从零开始构建股票交易机器人
交易策略，资源，和以前做过的人的建议。
尼古拉斯·霍伊泽在 Unsplash 上拍摄的照片
想不出策略？不确定使用哪个 API 和包？不想多此一举？我从头开始建立了一个股票日交易程序( github repo )，并希望分享一些有用的资源以及一些关于如何开始的建议。我知道开始一个新的项目，尤其是在一个外国领域，是具有挑战性的，我希望这篇文章能帮助拉平学习曲线。退一步说，我也想讨论一下我对“好”项目的标准。你可以做很多项目，那么为什么要做这个呢？
免责声明: 这并不代表理财建议。您使用下面的算法、策略或想法进行的任何投资都是自担风险的。我对与本文包含的信息相关或由其引起的任何后果不承担任何责任。
大纲:
- 为什么我认为建立一个交易机器人是一个“好”项目:在花时间建立一个投资机器人之前，重要的是要问一下这是否是你时间的一个好投资。
- 如何开始:我提供一些示例伪代码来帮助你开始。
- 资源:github repos、网站、其他媒体文章、youtube 视频、书籍和播客的列表，它们给了我极大的帮助。
为什么我认为建立一个交易机器人是一个“好”项目:
1.整合感兴趣的技术
鉴于买卖股票/加密货币/外汇的复杂性几乎是无限的，引入新技术的空间很大。你是一名 数据科学家 并且想要分析埃隆马斯克的一些推文或者识别 SEC 文件中的关键词吗？一个有抱负的 云工程师 希望使用云在 EC2 实例上全天候运行您的脚本？一个 后端开发者 想给终端用户提供一个 API，从你的算法中获取何时买卖的信号？一个 ETL 或数据工程师 想要使用 Kafka、Spark、DynamoDB 等大数据工具，并构建一个管道来传输价格数据，并将其放入 NoSQL/SQL 数据库。一位 前端开发人员或财务分析师 对使用 DASH 或 React+Flask 向最终用户展示算法的性能感兴趣？你想加入一些机器学习吗？希望你能明白。
2.合作的
通过将您的程序分成感兴趣的领域，轻松地与他人协作。我想任何项目都可以是合作的，但是考虑到这种挑战的复杂性，人们可以选择他们的兴趣并简单地应对这些挑战。这个项目的总体目标很明确，即赚钱，这也很有帮助。有时很难合作，因为人们迷失在细节中，忘记了整体目标。无论你是建立一个数据管道，创建仪表板，还是建立一些机器学习模型，目标都是明确的。
3.成功的明确衡量标准:$$$
有时候很难衡量成功与否，但是对于这个项目来说，知道这个项目赚了多少钱或者赔了多少钱才是最终的指标。坦率地说，从学习的角度来看，这是一个双赢的局面。如果你赚了钱，想想怎么才能赚更多的钱或者少亏一些。如果你在亏钱，想一想你如何能赚更多的钱或损失更少。没错，没有区别。总是有改进的空间，所有的努力都是一样的。有时候对于其他项目，很难知道你的改变是否有益。成功可能依赖于用户的反馈，或者仅仅是观点的问题。相比之下，这个项目很棒，因为成功和失败都很明显。然而，重要的是要记住市场是无限复杂的。虽然衡量进步很容易，但这并不意味着取得进步很容易。
4.容易被招聘者/未来雇主/奶奶理解
有一个大家都能理解的项目就好。几乎每个人都投资股票市场。低买高卖的目标很容易理解。当雇主询问项目时，大多数人会漫无边际地谈论他们已经实施的一些技术，而忽略了招聘人员或招聘经理的细节。这并不是说这项技术不重要，而是这个项目的最终目标是让解释这项技术变得更容易。例如，“我想限制股票报价机的范围，所以我使用 K 均值聚类来聚类我所有成功的交易，并找到相似的股票”，而不是“我实现了 K 均值聚类”。即使你不知道 K-Means 聚类是什么，你也能明白它的用途。
5.潜在有利可图(但不太可能)
你可以通过构建一个成功的算法来赚钱。几个月前，当我第一次开始这个项目时，我确信建造一些有利可图的东西主要是运气和机会。我仍然基本上是这样认为的，但我相信创造一些有利可图的东西是可能的。我绝不会拿我输不起的钱去冒险，我强烈建议其他人也采取同样的心态。赚钱不应该是这个项目的目标，但这是一个不错的附带利益和令人向往的目标。
6.无限复杂
这与我之前关于轻松整合任何技术的观点一致。无限的复杂性意味着你永远不会完成。(我认为这是半杯水)。总会有新的策略、技术、指标和度量标准需要整合和测试。这是一个永无止境的游戏。随你怎么解释，但我觉得这很有趣，也很令人兴奋。
如何入门？
定义策略
制定一个有效的策略。请注意，我没有说创建一个有利可图的策略。事实是你会重复。定义策略将有助于提供一些可以改进的框架。这是我创建的一个股票交易策略的例子:
我在我写的另一篇文章中解释了这个策略，这篇文章讲述了我的股票交易算法的最初表现。现在重复这个策略并提供更多的细节。一旦你觉得自己有了可以轻松实现的东西，就开始思考如何实现。这时，我觉得我可以开始实施:
注意:包括我希望在实现过程中使用的 API 调用。这可能比伪代码阶段当前需要的更具体。
你将如何实施你的战略？
什么 API、包和其他资源有助于或者有必要实现这个伪代码？这可能吗？这是我做了一些研究，发现有 Robinhood (不推荐) TD Ameritrade 和羊驼的股票 API 可以执行买卖单。对于新闻故事，我正在考虑使用 Python 模块 Beautiful Soup 和 Selenium 和 Scrapy 做一些网络抓取。我可以使用雅虎财经 API 来获取移动平均线和跟踪交易量。为了构建一些机器学习模型，我可能会使用 scikit-learn、pandas 和 numpy(我不建议一开始就过多关注机器学习)。我在 Jupyter 笔记本上写了我的初始程序，用 Github 作为我的回购。
现在，在这一点上，你可能会开始钻研新的技术和平台，如结合一些云或使用气流或 kubeflow，但我建议专注于尽快实施。如果您对整合其他技术感兴趣并且更有经验，您可以在整合技术之前，对您计划使用的技术进行概念验证(POCs)。如果您在一个小组中工作，有些人可能只关注做概念验证，看看什么最有效。
迭代:快速失败
简单地经历实现伪代码的过程会教会你很多东西。你开始明白设计中的瓶颈和改进在哪里。并且可能已经了解了有用的新 API、包或框架。我也推荐做一些纸上交易(模拟交易)来测试你的程序的表现。记住，没有什么比现场交易更好的了。当你进行实时交易时，有很多因素会影响你的程序的表现。阅读我之前的一篇文章，其中描述了我在构建算法时面临的一些挑战。
资源
照片由 Fikri Rasyid 在 Unsplash 上拍摄
下面是一些帮助我开始的资源，可能对你也有帮助。同样，有些人可能会提供具体的建议，而其他人则为您提供一些领域知识和专业技能。
注意:我会不断更新下面有用的资源列表。
Github Repos
其他媒体文章
- 股市 API
- 股票市场策略(高级)
- 指标和更高水平
- 如何获取指标值(使用抓取从 Finviz)
- 使用指示器的例子
- 启发我的算法的刷单策略实现
- 财经网页抓取示例
- 构建比特币流媒体后端
- 流式股票数据
- 埃隆·马斯克发推特赚钱
网站:
- 点击一个报价器，查看专业交易者使用的所有指标和过滤器。这可能会启发您在自己的过滤算法中使用哪些指标。
- 市场观察:日内交易者的热门新闻来源。(收集这些故事并做一些情感分析可能会很有趣)。
- SEC 文件:如果你输入一个股票代码，你会看到该公司所有的官方文件。(我们正在考虑从这些文件中提取一些，为我们的股票交易算法提供信息)。
- Subreddit AlgoTrading :算法交易的 Subreddit。这里也有一些很棒的资源。这里有一个关于最好的 API 交易平台的讨论。交易算法 Python 介绍。
油管（国外视频网站）
- 熊牛交易者:新手交易者培训视频
- Forrest Knight :构建日交易算法的资源
- 关于人工智能在外汇领域的有趣 TED 演讲
书
- 闪光男孩:大家之所以要对股市赚钱持怀疑态度。
播客:
这是一些描述高级策略的播客。(你也可以谷歌一下“日内交易播客”——有很多)。
如果你喜欢你所读的
子栈:
我最近创建了一个子栈来学习如何用 Python 编程和解决 LeetCode 问题。请点击这里查看:
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
数据科学如何入门
有这么多的资源，我应该从哪里开始呢？
图片由皮克斯拜的尼诺·卡雷拍摄
介绍
当开始学习数据科学时，可能会有些力不从心。你需要了解统计学、编程、机器学习……在这些领域中的每一个领域中，都有许多许多子领域可以主导一个人的注意力，一旦他们读完了关于一件事情的所有知识，他们可能不会觉得比开始时更深入。
在这篇文章的过程中，我将谈论一些入门的挑战，将数据科学视为一门学科的最佳方式，以及如何入门。
入门的挑战
资源的数量是巨大的
今天尝试进入数据科学的一个惊人之处是有大量的资源…也就是说，浏览所有这些资源可能有点令人不知所措。你应该从什么开始，你应该把你的时间和金钱花在什么上面，这些都是经典的问题，似乎没有一个有抱负的数据科学家有答案。
udemy、udacity 和其他学习网站上有无数的机器学习课程，其中许多课程从非常浅显的角度涵盖了机器学习...我看到，当个人使用这种类型的资源时，他们经常从一门课程跳到另一门课程，试图更深入，但却得到了许多冗余的材料。这并不是说这些资源不好，但当涉及到像这样的课程的时间安排时，人们需要方向。
有一些非常昂贵的付费项目，也可以很好地让人们在这个领域立足，这些项目在内容的管理和线性学习结构方面非常出色，人们需要成功，但总而言之，在数据科学领域起步可能不是绝对必要的。在这两种情况下，收集一些基础知识并熟悉这个领域可以帮助一个人更成功，也可以帮助他们真正验证自己的兴趣。
发生的另一件事是，一个人可能会学习一门 ML 课程，然后学习一门基本的 python 课程，然后跳到一门 ML 工程课程，等等。这导致了一种非常脱节的教育，在这种教育中，一个人正在学习的原则不一定是建立在彼此之上的。
冒名顶替综合症
数据科学中一个非常普遍的现象就是所谓的冒名顶替综合症。冒名顶替综合征是一种感觉，也许你不属于，或者不值得你拥有的头衔，因为有太多你不知道的。因为数据科学的范围如此之广，这使得数据科学家很难深入该领域的每个子学科。数据科学家通常被视为所有数据科学方面的专家，因此，盲点经常被凸显出来。事实是，在这个领域有太多的东西需要了解，你会很难学会所有的东西。克服冒名顶替综合症的关键是要很好地理解什么是真正属于数据科学领域的，什么是必要的，什么是值得拥有的。
昂贵的
从硕士课程、纳米学位、视频课程到时事通讯、教科书等等；这些资源可能很贵！虽然其中许多无疑有很大的内容，它可以构成许多障碍。补充关于冒名顶替综合征的说明，并很好地理解一个人真正需要什么，什么是优先考虑的；如果你是这个领域的新手，并开始学习深度学习，你可能会在感觉没有更接近你作为数据科学家的第一个角色时烧掉一大块改变。
数据科学到底是什么？
正如我所回避的，关键的第一步是真正掌握数据科学家的工作流程，以及不同的技能和技术是如何发挥作用的。
在下一节中，我们将对此进行分解。
数据收集
首先，也是最重要的，你需要能够获得数据。不管你希望用它做什么，拥有获得它的技能是关键的第一步。
如果您还不熟悉，请尝试一下 SQL。SQL 代表结构化查询语言。这都是关于从数据库中提取数据。就代码而言，这实际上非常简单，因为主要目的是向数据库请求数据。
假设你是 SaaS 一家 B2B 公司的数据分析师。他们将所有销售活动数据保存在一系列数据库表中。你的老板想知道他们应该关注哪些行业。作为第一步，你需要了解公司已经销售给哪些行业，以及他们在每个行业的表现如何。这可能是一个非常有价值的分析，第一步是能够编写一个 SQL 查询。
如果你刚刚开始；我几乎总是说先从 SQL 开始。我不会在这里分解 SQL 的细节，但这是思考数据、数据结构以及如何正确提取和使用数据的良好开端。
SQL 有多种风格，最终取决于您使用的 DBMS(数据库管理系统)。你可能会听说过 redshift、mysql、sql server、mariadb 等等……这里的语法变化通常很小，只需简单的谷歌搜索即可。不要觉得有必要马上熟悉每一种的独特风味…它们没有足够的不同以至于没有必要，尤其是在开始的时候。
有很棒的 SQL 课程。可汗学院有一个免费的 SQL 课程，这是一个很好的介绍。Codeacademy & datacamp 也有优秀的 SQL 课程，会给你开始收集数据所需的基础知识。
除了 SQL，还有许多其他地方可以获得数据。数据可以来自 csv、excel 文件，也可以直接来自网站、JSON 等。虽然熟悉是有帮助的，但我会称之为有好处的。在您作为数据科学家的早期，您需要知道您可以很好地编写 SQL 查询。
数据清理
数据清理就是让您的数据进入一种状态，在这种状态下，无论接下来进行什么样的分析，它都是可用的。
数据清理有很多方面；我们如何处理丢失的值，数据类型是否正确，是否需要对变量进行任何特定类型的重新编码，以及许多其他事情——在很大程度上要考虑后面的分析。
数据争论
数据争论是数据清理的相邻步骤。这也与让你的数据以正确的格式变得有用有关。
您可能有一系列需要合并成一个的数据集。因此，您可以使用所谓的连接或联合来组合所述数据集。还有一个考虑是让你的数据集更宽而不是更长，我不会在这里详细说明，但是在你的工具箱中有这些简单的操作将会有很大的帮助。
您通常可以使用 SQL 完成大多数数据争论需求，也就是说，R 或 Python 提供了许多额外的功能。
探索性数据分析
探索性数据分析或 EDA 代表对数据的熟悉。这包括查看数据集的样本、查看其数据类型、通过不同的图表选项评估不同变量组合之间的关系、使用汇总统计数据评估不同变量。
建模之前，参与 EDA 过程有助于理解不同变量之间的模式和关系，并有助于您最终进行的分析。
这就是数据可视化软件技能的用武之地。虽然您可以使用 R 或 Python 创建这些可视化，但有时让它们存在于 Tableau、Domo、PowerBI 等数据可视化平台中会很有帮助。
到目前为止，我认为你有资格成为一名数据分析师。也就是说，典型的数据科学家可能会在我们已经讨论过的任何领域引入更复杂的方法或途径。这并不是说你不会发现数据分析师在做超出这个范围的工作，但这只是我识别区别的典型地方。
统计分析和建模
一旦你对你的数据有了很好的理解，这就是你开始展示你的统计学肌肉的地方。这包括概率密度函数、t 检验、线性回归、逻辑回归、假设检验等等。
有许多需要熟悉的统计工具和方法，这是让你成为数据科学家的一个重要方面。数据科学作为一个领域主要源于统计学，但通常被视为更复杂的机器学习方法。
拥有扎实的统计学背景将使你成为一名数据科学家。
机器学习
机器学习或 ML 构成了许多更基本的统计学原理的抽象，否则你可能会用到这些原理。许多最有用的 ML 算法代表传统线性回归的不同包装，或者它可能只是构建各种线性回归模型，从输入到传递给它们的数据略有变化，最终达到理想的模型。
从神经网络到深度学习，一路都是如此。
当您第一次开始时，努力对支持更复杂算法的统计学和数学有一个基本的了解，这将有助于对您正在使用的东西有信心，而且还将帮助您更好地确定给定算法的适当用法。
ML 很容易显得势不可挡。当人们意识到人工智能是建立在传统的统计模型之上时，人工智能这个同义词通常会让人感到惊讶。
这里我的建议是先学基础。给自己足够的时间来掌握数据分析师路线，接触使用各种统计工具和分析，不要被 ML 的概念淹没，努力让自己接触广阔的机器学习算法，并寻求理解它们与其他任何算法的区别。
ML 工程
我想强调的最后一点是众所周知的 ML 工程。
首先，我应该澄清，这不是我明确解释为数据科学领域的东西。虽然许多数据科学家都具备这些技能，但作为一名数据科学家，你并不一定了解这个领域的所有知识。
事实上，机器学习工程师是一个非常常见的职位，一个人的全部工作都围绕着这个领域。ml 工程就是部署 ML 模型。这是从建立团队和个人可以与模型交互的 API，设置重新训练模型和重新运行预测的作业，存储这些模型并使它们可访问的一切。
结论
数据科学是一个令人兴奋的新领域，但往往会让人不知所措。从这个角度思考这个问题，将有助于您在从事数据科学教育时做出艰难的决定，即应该选择哪些资源和顺序。
数据科学保护伞
- 数据收集
- 数据清理
- 数据争论
- 探索性数据分析
- 统计分析
- 机器学习
- 机器学习工程
以线性方式思考您的数据科学教育，并牢记这些特定技能，将有助于您在成为数据科学家的旅程中迈出下一步。
祝你好运！祝数据科学快乐！
如何开始 Kaggle 竞赛
关于如何在 Kaggle 上构建第一个数据科学项目的分步指南
Jonathan Chng 在 Unsplash 上的照片
如果你正在开始你的数据科学和机器学习之旅，你可能听说过全球最大的数据科学社区 Kaggle 。随着无数的课程、书籍和教程在网上讨论这个问题，感到不知从何开始是完全正常的。
虽然在开始学习一项技能时，没有一致同意的最佳方法，但从数据科学道路的起点开始使用 Kaggle 是一个可靠的建议。
这是一个学习和分享经验的绝佳场所，所有级别的数据科学家都可以从与其他用户的协作和互动中受益。更有经验的用户可以跟上新的趋势和技术，而初学者将找到一个很好的环境来开始该领域的工作。
Kaggle 有几个速成班帮助新手训练技能。有关于 python、熊猫、机器学习、深度学习的课程，仅举几例。随着你获得更多的自信，你可以参加比赛来测试你的技能。事实上，在几门课程之后，你会被鼓励加入你的第一场比赛。
在这篇文章中，我将用一种简单明了的方式向你展示如何构建你的第一个项目的一些技巧。我将参与房价竞赛，这是在 Kaggle 上开始的最好的动手项目之一。
1.了解数据
当你面对一个新的数据集时，第一步是花些时间去了解数据。在 Kaggle 比赛中，你会遇到类似下面的例子。
Kaggle 竞赛登录页面
在竞赛页面上，您可以在概述上查看项目描述，并在数据选项卡上找到关于数据集的有用信息。在 Kaggle 竞赛中，通常在单独的文件中提供训练集和测试集。在同一个选项卡上，通常会有您将使用的功能的摘要和一些基本的统计数据。理解需要解决的问题和我们手头的数据集是至关重要的。
您可以使用 Kaggle 笔记本来执行您的项目，因为它们类似于 Jupyter 笔记本。
2.导入必要的库和数据集
2.1.图书馆
这个项目中使用的库如下。
2.2.数据集
下一步是将数据集读入 pandas DataFrame，并获得目标向量 y ，这将是列SalePrice，以及预测值 X ，这将是剩余的列。
为了获得数据的概述，让我们检查第一行和数据集的大小。
数据帧的第一个样本的样本
检查 X 和 y 的大小
我们有 1460 行和 79 列。稍后，我们将检查这些列，以验证它们中的哪一个对模型有意义。
下一步，我们将把数据分成训练集和验证集。
3.培训和验证数据
将我们的数据分成一组用于训练模型，另一组用于验证结果，这一点至关重要。值得一提的是，我们不应该在这里使用测试数据。我们的测试集保持不变，直到我们对模型的性能感到满意。
我们要做的是将预测值 X 和目标向量 y 分成训练集和验证集。为此，我们将使用 scikit-learn 的train_test_split。
4.分析和准备数据
现在，我们开始通过检查一些关于特性的信息来分析数据。
检查 X 信息
从上面的总结中，我们可以观察到一些列缺少值。让我们仔细看看。
4.1.缺少值
检查缺少的值
一些要素的大部分条目都有缺失值。检查竞赛页面，我们会发现关于每个特性值的更多详细信息，这将有助于我们处理缺失的数据。
例如，在PoolQC、MiscFeature、Alley、Fence和FireplaceQu列中，缺少的值意味着该房屋不符合该特定特征，因此，我们将用“NA”来填充缺少的值。以Garage和Bsmt开头的列中的所有空值分别与没有车库或地下室的房屋相关。我们将用“NA”或平均值填充这些值和剩余的空值，考虑要素是分类的还是数值的。
4.2.预处理分类变量
大多数机器学习模型只对数值变量有效。因此，如果我们在没有对分类变量进行预处理的情况下向模型输入分类变量，我们将会得到一个错误。
有几种方法可以处理分类值。这里，我们将使用 One-Hot Encoding ，它将创建新的列，指示原始数据中每个值的存在或不存在。
One-Hot 编码的一个问题是处理具有许多唯一类别的变量，因为它将为每个唯一类别创建一个新列。因此，该项目将只包括不超过 15 个唯一值的分类变量。
4.3.创建管道
管道是保持数据建模和预处理更有组织、更容易理解的好方法。创建一个管道，我们将处理丢失的值和前两步中涉及的预处理。
如上所述，数值缺失条目将用平均值填充，而缺失分类变量将用“NA”填充。此外，分类列也将使用一键编码进行预处理。
我们使用简单估算器来填充缺失值，而列转换器将帮助我们在单个转换器中应用数字和分类预处理程序。
5.定义模型
既然我们已经在管道中捆绑了我们的预处理器，我们可以定义一个模型。在这篇文章中，我们正在与 XGBoost 合作，这是最有效的机器学习算法之一，在许多 Kaggle 比赛中取得了很好的结果。作为评估指标，我们使用的是平均绝对误差。
验证集的平均绝对误差
6.交叉验证
使用交叉验证可以产生更好的结果。交叉验证不是简单地使用训练集和测试集，而是在不同的数据子集上运行我们的模型，以获得模型质量的多种度量。
我们将使用默认设置中的交叉验证器 KFold 将训练数据分成 5 份。然后，每个折叠将被用作一次验证，而剩余的折叠将形成训练集。之后，交叉验证将评估指标。在这种情况下，我们使用平均绝对误差。
交叉验证后的平均绝对误差
通过交叉验证，我们可以提高分数，减少误差。下一步，我们将尝试进一步改进模型，优化一些超参数。
7.超参数调谐
XGBoost 在默认设置下通常会产生很好的结果，但是它也有很多可以优化的超参数来改进模型。这里，我们将使用一个名为 GridSearchCV 的方法，它将搜索指定的参数值并返回最佳值。我们将再次利用管道和上面定义的交叉验证器 KFold 。
GridSearchCV 将对参数进行彻底搜索，这可能需要大量的计算能力，并需要大量的时间来完成。我们可以通过将参数n_jobs设置为-1来稍微加快进程，这意味着机器将使用任务上的所有处理器。
最佳参数值为:
- n_estimators: 400
- 最大深度:3
- 最小 _ 子 _ 体重:0.0001
- learning_rate: 0.1
8.生成测试预测
在调优了一些超参数之后，是时候再次检查建模过程以对测试集进行预测了。我们将根据 GridSearchCV 提供的优化值定义我们的最终模型。
9.提交您的结果
我们快到了！机器学习建模已经完成，但是我们仍然需要提交我们的结果来记录我们的分数。
这一步相当简单。我们需要创建一个包含预测的.csv文件。该文件由两列数据帧组成。在这种情况下，一列用于“Id ”,另一列用于目标特征的测试预测。
10.参加比赛
最后，我们只需要加入竞争。请根据 Kaggle 的说明，遵循以下步骤。
- 首先进入竞赛页面，点击加入竞赛。
- 在你的 Kaggle 笔记本中，点击窗口右上角的蓝色保存版本按钮。
- 将出现一个弹出窗口。选择选项保存并运行所有，然后点击蓝色的保存按钮。
- 笔记本电脑运行时，左下角会出现一个新的弹出窗口。当它停止运行时，点击数字右边的保存版本按钮。您应该点击最新笔记本版本右侧的省略号(…) ，并选择在查看器中打开。这将使您进入同一页面的查看模式。
- 现在，点击屏幕右侧的输出选项卡。然后，点击蓝色的提交按钮，将您的结果提交至排行榜。
提交后，您可以在排行榜上查看您的分数和排名。
竞赛排行榜
结论
本文旨在提供指导，帮助数据科学初学者以简单的步骤构建他们在 Kaggle 上的第一个项目。通过这种简单的方法，我得到了 14，778.87 的分数，这个项目排在前 7%。
在进一步学习后，你可以回到过去的项目，并尝试使用你学到的新技能来提高他们的表现。为了改进这个项目，我们可以更仔细地调查和处理异常值，对缺失值应用不同的方法，或者进行一些特性工程。
我给初学者的建议是，一开始就保持简单。不要以“完美”的模式为目标，而是专注于完成项目，正确应用你的技能，并从你的错误中学习，了解你在哪里以及为什么把事情搞砸了。数据科学社区在不断扩张，有很多更有经验的人愿意在 Kaggle 或 Stack Overflow 这样的网站上提供帮助。试着从他们过去的错误中吸取教训！通过练习和训练，开始构建更精细的项目并在 Kaggle 的比赛中排名上升只是时间问题。
如何开始你的人工智能之旅
弗拉德·巴加西安在 Unsplash 上拍摄的照片
现在有一千个理由让你至少了解一点人工智能。有些引用像“成功创造人工智能将是人类历史上最大的事件。不幸的是，这也可能是最后一次，除非我们学会如何规避风险。”由斯蒂芬·霍金，“我们的智慧是我们成为人类的原因，而人工智能是这种品质的延伸。”我想起了 Yann LeCun。但忘记所有这些，对我来说，学习人工智能最重要的原因是你对它感兴趣。
一个好的起点是理解人工智能是什么，它是如何起源的，以及它目前在哪里。你还应该考虑建立它与机器学习、深度学习、强化学习以及数据科学等常见术语的关系。还需要找出在该领域中使用的编程语言。
马库斯·斯皮斯克在 Unsplash 上拍摄的照片
遇到的常见困难
像生活中的大多数事情一样，学习人工智能有一些好处和困难。我遇到的一些困难包括
大量可用的资源和学习材料
寻找高效学习的最佳路线图和时间表
为初学者选择最好的项目，以及你的投资组合中哪些项目看起来不错
评估所需的数学知识
我花了很多时间寻找这些问题的解决方案。网上有很多关于最佳方法、学什么、应该学多长时间的想法和观点。然而，经历了这么多之后，我发现每个人都是不同的，对一个人有效的可能对你无效。
我的建议是找出适合你的方法，尝试你能接触到的东西。你可以从阅读一本关于人工智能的教科书开始，参加在线或物理课程，查看人工智能博客和网站，听人工智能和数据科学播客，参加人工智能训练营，并查看一些人工智能 YouTube 频道
你可以尝试其中的两种或更多种，给自己一个好主意，哪种学习路线最适合你。上面提到的所有要点也可以免费获得。最重要的是入门，借用耐克的广告语“做就好！”。
避免倦怠，应对冒名顶替综合症
在我看来，最好是一次做一件事，同时专注于完成你已经开始的事情。多任务处理不同的教科书或课程有它的好处，但对初学者来说是不可取的。最重要的是知道自己的极限，避免给自己太大压力。睡眠不足不会带来任何好处。
如果你来自非计算机科学或技术背景，你会发现自己有时像个骗子。以我为例，在石油行业工作了 16 个月后，我决定从石油工程(我的学士学位)转行到数据科学。从我开始学习 Python 的那一刻起，我就开始经历冒名顶替综合症。即使在我的 GitHub 上学习了 9 个月和 15 个以上的项目后，它仍然存在。
当我决定开始申请入门级职位和实习时，我感受到了这一点的全部重量。我一直觉得自己低于标准，永远不够好。即使是现在，我仍在处理这件事，尽管与我开始时相比，现在的规模已经变小了。
杰斐逊·桑托斯在 Unsplash 上拍摄的照片
帮助我应对冒名顶替综合症的是:
1。加入一个好的人工智能社区:他们可以帮助你成长，给你带来惊人的机会。
2。持续学习:当你完成一门课程或一本教科书时，不要害怕进入下一门课程，尝试新的东西。抱着终身学习的态度。
3。做很多副业:做副业是值得的；它们有助于巩固你所学的知识。他们也是伟大的信心建立者。
4。参加黑客马拉松:它们让你知道你的武器库中有什么，让你知道你还有多少需要学习，激励你变得更好。
5。参加人工智能会议和训练营 : 这些让我大量接触到了这个行业的最新发展水平，让我和其他初学者联系起来，让我感觉到自己真正的归属。
6。听 AI 和数据科学播客 : 数据怀疑论者和偏导数来了我强烈推荐给初学者。我从他们身上学到了很多。
要获得的利益
学习人工智能的一些显著好处包括
让你更加了解当今世界发生的事情
帮助您快速找到现实世界的趋势
为您提供算法、推荐引擎如何工作的基本理解
让你明白数据(尤其是你的个人数据)的价值
将 21 世纪最强大的问题解决工具添加到您的武器库中。
人工智能已经对我们今天的生活产生了巨大的影响。它存在于我们周围，在我们的家里、办公室、电话、电器、汽车里，在我们玩的游戏里，在我们访问的网站上。你不能忽视它。我祝你在人工智能的旅程中好运。干杯。
数据怎么入门？—第一部分
从数据开始
即使你以前没有做过分析。
我的数据科学之旅始于在德国最大的汽车制造商之一的高级分析部门的一份学生工作。我很天真，还在攻读硕士学位。
我对这份工作很兴奋，因为我目前的专业是数字化。我想知道它到底是如何工作的。我也学过编程，但不是 python。我的同事都非常聪明——博士、数学家和物理学家。他们对分析的理解水平远远超出了我仅仅通过读书所能获得的！
最初几天，各种各样的项目和任务、分析和项目让我不知所措。但是，你知道什么更令人困惑吗？像什么是分析这样的问题？为什么这么做？这么多数据的这些文件都是什么？结果中的这些数字说明了什么？一个分析项目看起来像什么？他们说在分析数据是什么意思？
势不可挡！
我花了几天时间理解分析和工作本身。我狼吞虎咽地阅读了各种教授 python、统计学、数据科学等的书籍和在线课程。渐渐地，我对这些课题有了理解，并在同一个系成功地完成了我的论文。
我在下面为你解释了数据分析的诀窍。希望你能以此为指导，即使你的成分随着应用而改变。
让任何项目成功的最重要的一步是有一个清晰的开端。无论你的项目有多大或多小，如果你没有所需形式的配料和合适的工具，即使是一个大师级厨师的食谱也不能保证最后是一顿美味的饭菜。
先说食材，再开始准备。
来自 Pixabay 的图片由 Seksak Kerdkanno 提供
配料:
1。问题
你在谷歌中搜索你的查询后，有没有得到不相关的结果？那你会怎么做？重新措辞并提炼关键词，再次搜索。同样，在一开始就明确你分析的“为什么”有助于你更好地解释你的结果。
在获得所有需要的数据后，下一步是理解和定义问题陈述。这里需要解决业务案例的难点。你的目标必须与公司的商业战略相一致，这样分析才能对利益相关者证明是富有成效的。
考虑上面的商店位置示例。根据您的分析结果，您将获得分配给每个潜在位置的分数。如果你的管理策略是，只有当新地点在一个人口最少为 5000 的新城市产生超过 100，000 美元的利润时，才为项目融资。因此，您有明确的标准来根据您公司的愿景缩小分析结果的范围。
2。数据
对于任何一种数据分析，获取数据是毋庸置疑的。数据可以从各种相关来源获得。因此，它可能有不同的类型和格式。你的工作是根据它的类型切割和粉碎它，这样它就可以用在你的食谱上了。
在数据的表格表示中，每一列是一个数据字段，每一行是一条记录。每个记录可以用一个 ID 唯一地标记。
例如，为了预测下一个开设新店的地点，您可能必须使用
的年度销售数据、现有商店地点的销售数据、地点的人口密度、家庭总数、人口普查数据、土地面积。如果你的公司销售宠物产品，那么你需要有宠物的家庭数量。如果你的公司销售儿童产品，那么有 15 岁以下儿童的家庭数量。
最常见的输入文件类型有。csv(逗号分隔值文件)。xlsx (excel 表格文件)和。txt(文本文件)。Excel 文件在导入数据时会消耗更多内存。相反，CSV 文件速度更快，消耗的内存更少。
无论文件类型如何，您都必须清理每个文件，然后将所有文件混合到一个文件中进行分析。你可以在这里查看更多信息:
[## 什么是数据准备？
数据准备是收集、清理和整合数据到一个文件或数据表中的过程，主要是…
www.datawatch.com](https://www.datawatch.com/what-is-data-preparation/)
3。软件
用于分析的软件可以根据您想要的结果类型进行选择；对于那些不喜欢编程的人来说，可以简单地使用任何模块化分析软件。在这样的工具中，你只需拖放所需的功能，你就可以很好地处理结构精美的结果和演示。
流行的“无代码”分析软件包括:
- 表格 —数据可视化和报告
- DataRobot —自动化机器学习平台
- RapidMiner —适用于从预测到部署的整个生命周期
- Alteryx —高级分析平台
- MLBase —开源
- TriFacta —免费
对于这些，你只需要去他们的网站，创建一个帐户并下载(有些可能只允许有限时间的试用版本)
之后，只需上传您的数据文件进行分析和运行。当你读完这篇文章的时候，你已经有结果了。
统计计算的流行 ide:
这篇文章最初发表在 blog.zakjost.com 上
towardsdatascience.com](/getting-started-with-python-for-data-analysis-64d6f6c256b2)
您还可以直接在线启动您的数据分析项目，无需下载或安装任何东西！
准备:
不同类型的数据有不同的格式。通常来自不同来源的数据需要在下游流程中进行清理、丰富和适当整合，以形成一种可用的形式。通常使用的技术术语是数据清理、特征选择、数据转换、特征工程和降维。
数据清理和准备是整个分析过程中最耗时的任务。
对任何文件要做的第一件事是检查给定的路径是否正确，以及它是否正确无误地打开。将数据加载到您选择的软件中。现在，看看里面。
查看数据的一个例子是 Alteryx 中的字段汇总工具，它提供了所有字段的数据汇总。摘要如下所示:
数字域:图片来自 Alteryx 软件的 Priyanka Mane
使用统计工具分析和解释数据(即发现相关性、趋势、异常值等)。).但是，数据可能有缺失值、键入错误或不同的日期格式；为了获得更好的结果，必须首先确定并解决这个问题。
字符串字段:图片来自 Alteryx 软件的 Priyanka Mane
变数
分类变量是可以取属于固定数量类别的值或标签的变量。性别是一个名义分类变量，有两个类别——男性和女性。这些类别没有内在的顺序。序数变量有明确的顺序。温度是一个序数分类变量，有三个有序类别(低、中、高)。为了便于分析，这些变量使用不同的技术进行编码。
数量变量代表测量和计数。它们有两种类型:连续型(可以取区间内的任何值)和离散型(可数)。
数据类型:数值型和分类型
下面的链接概述了对变量进行编码的方法。
初学者分类变量编码指南。
towardsdatascience.com](/what-are-categorical-variables-and-how-to-encode-them-6e77ddc263b3)
在准备数据时，您可能必须应对以下挑战:
- 空值/缺失数据
空值在数据中显示为 NaN 或“非数字”值。NaN 属性与数字相同，但不是合法的数字。在 python 中，使用 isNaN()全局函数检查值是否为 NaN。在 Alteryx 软件中，运行代码后，值显示为[Null]。可以使用公式工具中的 isNull 对它们进行筛选。此外，汇总工具还可以帮助您计算空值。
当数据集中没有为某个观测值存储数据值时，在统计数据中称为缺失数据或缺失值。 Rubin 阐述了缺失数据发生的三种机制:随机缺失(MAR)、完全随机缺失(MCAR)和非随机缺失(MNAR)。
将替代值分配给缺失值的过程称为插补。如果数据的一小部分(高达 5%)缺失，那么可以使用平均值、中值或众数等方法对这些值进行估算。它使用同一列中的其他值进行插补。原则性方法，如多重插补(MI)方法、全信息最大似然(FIML)方法和期望最大化(EM)方法。
如果超过 10%的数据丢失，建议删除字段，因为这可能会增加结果的统计偏差。
在 Alteryx 中，字段汇总工具显示每个数据字段缺失记录的百分比。
请点击此链接了解在 excel 中处理缺失数据的步骤和公式。
收集数据时面临的另一个问题是一些数据可能会丢失。例如，在与…进行调查时
www.real-statistics.com](http://www.real-statistics.com/descriptive-statistics/missing-data/)
- 异构数据
由于格式不统一，年龄、货币、日期等数字字段很有可能出错。例如，年龄可以写成 30 岁或 30.2 岁或简单地写成 30 岁。货币的千位分隔符和小数点分隔符因国家和地区而异。确保这些列的格式一致。
- 离群值
一旦数据集被清理，就该对其运行另一个预处理机制了。异常值是数据集中可能导致计算中出现统计错误的异常值。它们异常远离数据集中的其他值，可能会严重扭曲您的输出值。
回归结果中的异常值:图片来自 Jim 的统计
当您需要立即识别数据中的异常值时，散点图非常有用。使用图表简单地显示每个预测变量和目标变量之间的关系。
以下是一些链接，可以帮助您了解处理异常值的术语和方法:
7.产品和工艺比较。异常值的定义异常值是一个存在于…
www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/prc/section1/prc16.htm) [## 四分位数、盒子和胡须
对于统计中的许多计算，假设您的数据点(即列表中的数字)是…
www.purplemath.com](https://www.purplemath.com/modules/boxwhisk.htm)
以上是第 1 部分的全部内容。查看第 2 部分，了解数据科学项目的分析和演示阶段。敬请期待！
步入正轨的最好方法是做好准备，远离你的毒瘾。阅读以下内容，了解更多信息。
以及如何控制它！激励性的谈话没有帮助。引发你内心的化学反应。
medium.com](https://medium.com/illumination/why-am-i-not-motivated-enough-for-my-success-f2a0fb5735a5) [## 毫无准备是没有借口的
有太多事情要做的时候该做什么。事半功倍。
medium.com](https://medium.com/age-of-awareness/there-is-no-excuse-for-being-unprepared-7725634d4f30)
普里扬卡·马内|学习者|数字内容创作者
insta gram:Wanderess _ Priyanka|LinkedIn:Priyanka Mane
数据怎么入门？—第二部分
从数据开始
业余爱好者循序渐进指南
麦克斯韦·尼尔森在 T2 的照片
数据科学是一门艺术。你需要实践来完善它。2017 年我第一次和它联系在一起。你可以在这里阅读我的故事和到这篇文章的第一部分。在本文中，我继续了数据项目的下一阶段——通过构建模型进行分析，并使用图形进行展示。
分析:
选择正确的数据字段可以显示正确的结果。
优化变量选择
方法 1:
为您的分析选择最佳变量会对您的结果产生巨大影响。使用回归模型时，可以通过查看模型统计结果中 p 值列的星号来衡量变量的显著性。
在下面的线性回归结果快照中，查看右边的最后一列:
每个预测变量都是重要的，因为它的 p 值<= 0.05. A low p-value suggests that the slope is not zero, which in turn suggests that changes in the predictor variable are associated with changes in the response variable. The multiple R-squared and the adjusted R-squared values must be close to 1. Low p-values and high R-squared value suggests that the model is highly predictive.
Selecting predictor variables from Linear Regression results using P-Value: Image by Priyanka Mane 来自 Alteryx 软件
方法二:
使用交叉表！列联表或交叉表显示了某组数据出现的频率变化。您可以获得更好的可读性。它有助于同时对各种领域进行相互比较，以明确决定最有效的领域。
来自维基百科的交叉表图片
如果你熟悉 Python 中的 Pandas，下面的链接很有帮助。
Pandas 提供了几个分组和汇总数据的选项，但这种多样性的选项可能是一种祝福和一个…
pbpython.com](https://pbpython.com/pandas-crosstab.html)
分小块分析
如果数据集非常大，将它分成更小的块。使用这些组块进行训练和验证。比较您的模型对这些块的整体准确性，以了解模型对不同集合的表现。
构建和运行“模型”
通过比较不同模型的准确性进行分析:图片由 Alteryx 软件的普里扬卡·马内提供
数据清理结束后，将清理后的数据存储在一个单独的文件中，以供分析使用。这样你的模型会看起来很瘦。它将运行得更快，因为预处理已经完成了。
将清理后的数据分成测试和验证样本。将模型应用于这两个数据样本。这一步有助于您了解您对新数据的预测有多准确。也不要过度合身。这里，您必须将定型数据集结果与验证数据集结果进行比较。总体精度是一个很好的比较参数。为最终结果选择精确度最高的模型。
在上述分析的模型比较结果中，查看“准确性”列。FM_Credit 是我给森林模型起的名字。它被认为是其他模型中精度最高的，所以我选择它进行最终分析。AUC(曲线下面积)也必须很高。
Alteryx 软件中的模型比较:图片由 Alteryx 软件中的普里扬卡·马内提供
演示:
人类大脑处理图像的速度比处理文本快 60，000 倍，传输到大脑的 90%的信息是视觉的。
你的可视化越好，你的工作就越有影响力！
数据可视化
以有意义的方式呈现这些数据:图表、可视化、图表、表格等。数据分析师可以向项目经理、部门主管和高级业务主管报告他们的发现，以帮助他们做出决策并发现模式和趋势。本文第 1 部分中提到的 Tableau 软件是迄今为止最好的、最用户友好的说服性可视化软件。
Mathplotlib 非常有名，但不一定是最容易使用的。它的优点是“可以从 python 的舒适中使用”。Rand python 的其他一些鲜为人知但极具影响力的选项是plot . ly——它可以将 java 嵌入到网页中，也可以离线工作， bokeh 和 ggplot 。
来自 xkcd 的网络漫画
作为初学者
- 数据分析师的大部分工作时间都花在为管理层理解和解释业务案例上。因此，合理的做法是尽可能多地阅读数据科学案例。你将能够理解不同的场景和权衡。与此同时，你将获得根据问题进行结构化思考的专业知识。
- 如果你不知道从哪里开始获取数据，只需在 Kaggle 上寻找数据科学项目和竞赛。
- 将这些项目上传到 GitHub 上，从其他用户那里获得真知灼见。
- Stackoverflow 也是一个从别人的问题和错误中学习的好地方。
如果您觉得这个方法有用，或者您想要我在本系列文章中使用的任何项目的详细的一步一步的解释，请告诉我。
以及如何控制它！激励性的谈话没有帮助。引发你内心的化学反应。
medium.com](https://medium.com/illumination/why-am-i-not-motivated-enough-for-my-success-f2a0fb5735a5) [## 毫无准备是没有借口的
有太多事情要做的时候该做什么。事半功倍。
medium.com](https://medium.com/age-of-awareness/there-is-no-excuse-for-being-unprepared-7725634d4f30)
普里扬卡·马内|学习者|数字内容创作者
insta gram:Wanderess _ Priyanka| LinkedIn:Priyanka Mane
如何开始使用 Python 和 R 进行数据分析和数据科学——一种实用的方法
没有编码背景的数据分析师学习 Python 或 R 的实用方法
当使用一个软件进行数据分析时，人们经常会感到沮丧，这个软件并不特别适合某个特定的任务，但是仍然继续使用它，因为他们熟悉这个软件。例如，使用 MS Excel 处理主要由文本组成的数据。使用 Python 或 R 会使工作变得更容易，让人们工作得更有效率。然而，人们经常回避学习 Python 或 R，因为他们认为编码很难。一个常见的误解是，要成为一名优秀的程序员，你需要擅长数学(查看这个了解更多的误解)。如果你是这些人中的一员，让我向你保证这不是真的。在这篇文章中，我想为您提供一套工具，帮助您入门 Python 或 r 中的数据分析和数据科学，我已经在 2019 年在伦敦大学学院教授了一门初学者数据科学夏季课程，并将在这里分享我所有的技巧和资源(免费)。
如何开始
就像你学习任何新东西一样，你需要从基础开始。在这种情况下，学习基本语法。我建议至少花一个周末的时间，通过做一些简单的算术，熟悉简单的数据结构(列表、集合、字典等)，编写一些函数、if-else 语句和 for-loops，来对你想学的语言有所了解。有足够的资源让你开始。建议你去看看 Coursera、Udemy、edX、Udacity 这样的网站，找一门适合你学习风格的课程(我个人比较喜欢 IBM 关于 Coursera 的课程大纲“ Python for Data Science 和 AI ”)。Hackerrank 和 Leetcode 也是练习编码技能的好网站，不需要你下载任何东西到你的电脑上——你可以在浏览器中练习(尽管我更喜欢离线练习——下一节会有更多的介绍)。查看 Hackerrank 的 Python 挑战和 Datacamp 对 R 的介绍。
下载 Anaconda(或使用 Google Colab)
对于 Python，以及 R，建议大家下载 Anaconda 。Anaconda 是用于科学计算的 Python 和 R 的免费发行版，旨在简化包管理(如果您不知道什么是包，不要担心，稍后会有更多介绍)。Anaconda 附带了一个名为 Jupyter Notebook 的工具，这是一个开源的 web 应用程序，允许您创建和共享包含实时代码、等式、可视化和叙述性文本的文档。这是我最喜欢的数据分析工具。如果你想体验一下，可以去看看谷歌实验室，这是一个免费的 Jupyter 笔记本环境，不需要任何设置，完全在云中运行。
Google，百度或者 Yandex it！
在过去的几年里，我无数次告诉我的学生“你不是第一个遇到这个问题的人——以前已经有人问过这个问题了——谷歌一下！”。如果你得到一个你不理解的错误信息，或者你不知道如何在 python 中将一个数字四舍五入到小数点后两位——stack overflow 是你的朋友！我可以向你保证，不管是什么——已经有人在 stackoverflow 上回答了你的问题。所以，当你陷入困境时，不要害怕谷歌搜索。程序员一直在谷歌上搜索。(正如我告诉我的中国暑期学校学生的那样——谷歌在你们国家被禁并不是不在网上寻找答案的借口)
然而，我在教授暑期学校课程时注意到，许多人不知道如何表述他们的问题，因此很难在互联网上找到答案。知道如何把你的问题用语言表达出来，这本身就是一种技能，需要练习。以上面的舍入例子为例——谷歌搜索“如何舍入数字”不会给你想要的答案(试试看)。当谷歌搜索“如何舍入数字 python”时，上面的结果会告诉你 Python 内置的 round()函数，这将要求你通读更多不必要的文本。只有当你谷歌“如何四舍五入数字 python 小数点后两位”你会在 stackoverflow 上得到一个建议问题列表。这可能听起来很明显，但在处理以前没有处理过的问题时可能会很困难。
经历一个众所周知的问题
好了，你知道了基础知识，你已经熟悉了 Jupyter 笔记本、Rstudio、Google Colab 或任何你想使用的其他工具——现在该怎么办？现在，您要寻找一个著名的数据集，它易于理解，但具有足够的挑战性，可以用来做一些有趣的事情。一步一步地浏览教程，试着理解每一行代码和它在做什么。在我的暑期学校课程中，我使用了泰坦尼克号数据集。这是一个很棒的数据集，您可以在其中应用许多数据探索和可视化技术，以及不同的分类算法。您可以将相同的原则用于您自己的数据。这里有两个分步教程，介绍如何分析泰坦尼克号数据集，以及如何训练一个分类器来预测某人在泰坦尼克号上是死是活。
R(我给学生们的泰坦尼克号笔记本，作为他们个人项目报告应该是什么样子的例子)
注意:R 示例涵盖了更多的内容，所以我鼓励你去看一看，即使你想开始使用 Python。
在阅读这样的教程时，你会遇到你可能想要研究的包/库(如 pandas 或 scikit-learn in Python)和机器学习算法，如逻辑回归、决策树、支持向量机或神经网络。这取决于您想要深入研究这些主题中的每一个，并且超出了本文的范围。我只想为您提供入门的初始工具。
查找与您的数据集相似的数据集
如果你想在工作中应用你的新技能，或者对特定类型的数据感兴趣，你的下一步应该是浏览一个著名的数据集，该数据集与你想要分析的数据类型相似(分析图像、声音、文本或数字数据都需要不同的方法)。在我的博士学位中，我主要分析文本数据——这一过程被称为自然语言处理(NLP)。当然，分析像电影评论这样的文本数据与分析泰坦尼克号数据集中给出的数据类型是完全不同的。如果您对如何开始使用 Python 进行文本分析感兴趣，请查看我的另一篇文章。
以下是一些著名数据集的例子(你会在互联网上找到许多关于如何分析和训练机器学习模型的资源):
图片 : 手写数字分类，服装物品分类
文本 : 文本分类(火腿/垃圾)，情感分析(影评)
注意:你可以使用所有的分类数据集来训练像 k-means 这样的无监督学习算法，这超出了本文的范围。
我希望这篇文章对您有所帮助，并为您提供一些关于如何开始使用 Python 或 r 进行数据分析、数据科学和机器学习的线索。如果您有任何问题或希望我写一篇类似于“机器学习简介”的文章，请告诉我。
深度学习如何入门
分四步走
JESHOOTS.COM在 Unsplash 上拍照
我最近向订阅我的电子邮件列表的人发出了一份调查，询问他们最感兴趣的学习内容。
关于86%的人说深度学习。
这让我震惊。我知道深度学习是一个热门话题，但我不知道人们对学习更多有多大兴趣。
所以——我想如果我今天开始，我会写下我将如何开始学习深度学习。
深度学习专业化
不出所料，在我看来，最好的起点是吴恩达的深度学习专业化。
吴恩达在教学方面有着不可思议的天赋，他从基础开始，使用深度学习进行图像和文本处理，做得非常好。该专业的课程有:
- 神经网络和深度学习
- 改进深度神经网络
- 构建机器学习项目
- 卷积神经网络
- 序列模型
我最喜欢他的方法是，他帮助你理解如何在进入更高级的架构之前改进和构建你的项目。我发现这种自下而上的方式对于初学者来说非常容易理解。这门课也很好地向你介绍了网络中注意力的概念，这对于最先进的架构来说是一个非常重要的概念。
在我看来，不利的一面是课程是在张量流中进行的。随着 TensorFlow 的改进，这并不是一个很大的缺点，但我更喜欢 PyTorch。我所做的，也是我建议你做的，是在 PyTorch 中做所有的功课。这不仅能让你接触到 TensorFlow 和 PyTorch 代码，还能确保你理解这些概念，因为你不会太依赖任何提供的代码。
面向编码人员的实用深度学习
杰瑞米·霍华德和雷切尔·托马斯做了很多工作，让深度学习变得更加平易近人。
他们采用我称之为自上而下的方法，从非常高的层次开始，并开始填充细节。如果你没有深度学习的经验，我实际上发现这种方法有点令人困惑。这就是为什么我建议你从吴恩达的课程开始。
你可能认为除了吴恩达的课程之外，这门课不值得上，因为它也是一门入门课，但是我发现教学风格和涉及的主题实际上相当不同。虽然你肯定会从安德鲁的课程中得到一些复习的科目，但我认为以不同的方式看待这些科目是非常有价值的。
本课程还将从非常实用的意义上讨论深度学习，重点放在他们在没有谷歌级计算的情况下将深度学习应用于现实世界问题时发现有价值的主题上。
该课程混合使用 PyTorch 和他们自己在 PyTorch 基础上构建的名为 fastai 的库。Fastai 是一个非常高级的库，只需几行代码就可以让您使用最佳实践和最先进的模型。虽然这很好，但我仍然更喜欢直接编写 PyTorch 代码，因为这将增加您对底层发生的事情的理解，并且不会太难。
如果你喜欢这门课程，你也可以考虑参加更高级的课程的第二部分。该课程基本上是带你了解他们是如何构建 fastai 库的，这需要你更深入地钻研代码和基础知识。
完成一篇论文
在这一点上，你应该对深度学习的基础有了真正坚实的掌握。
世界上最好的两位老师以两种不同的方式教你。
我认为人们通常在深度学习中出错的地方是他们没有花足够的时间真正理解基础知识。我甚至没有提到算法背后的数学。我说的是核心概念、构建模块和问题。如果你觉得你没有完全掌握前两门课的概念，那就回去复习。
如果你感觉良好，那就继续写论文吧。
这听起来可能很可怕，但几乎可以肯定没有你想象的那么可怕。事实上，我如此喜欢 PyTorch 的原因之一是，我发现我几乎可以从一篇论文中提取架构，使用 PyTorch 将其输入 Python，并且它可以工作。
我推荐的一份报纸是谷歌网。这篇论文有点老，所以它不会使用任何未知的构建模块，它写得很好，我不相信它在任何课程中都有很深入的涉及。
坐下来，阅读你选择的论文，这样你就能理解它，将其转换成代码，并将其应用于标准数据集，以确保你的实现是可行的。这不仅有助于你理解这篇论文，还能树立你的信心，从而无所畏惧地处理其他论文。
选择你自己的冒险
这个过程的最后一步是继续寻找新的论文并实施它们。深度学习作为一个领域发展如此之快，以至于为了保持在最先进的架构之上，你需要舒适地阅读和实现论文。
利用你在实施第一篇论文时建立的信心，不要害怕花时间坐下来消化论文。在我看来，那是继续学习的最好方法。你会发现，对于最有影响力的论文，其他人会写非常棒的博客文章来帮助你剖析论文。利用这些！
如果没有找到，那就看懂了再写一个！
然后，慢慢地，随着时间的推移，你将继续建立你的基础深度学习知识，直到你发现其他人认为你是专家，并对你的知识深度印象深刻。
因此，虽然这是一个需要时间的过程，但我相信这是一个能够全心全意成功完成的旅程。
这个故事也可以在这里找到。
有兴趣了解有关 Python 数据分析和可视化的更多信息吗？查看我的课程。
如何使用 Python 开始使用 Google 文本到语音转换
语言模型设计
从零开始的文本到语音转换简介
来源:克里斯托弗·高尔在 unsplash 上拍摄的照片
在本文中，我们将介绍文本到语音翻译的基础知识。我将简单介绍一下文本到语音转换，然后我将介绍如何开始安装谷歌文本到语音转换(gTTS)模块。然后，我们将继续理解 gTTS 模块是如何工作的，并编写一个简单的程序来更好地掌握整体概念。我们还将探索更多关于使用这个模块还可以做什么的想法，然后尝试理解许多可以使用 gTTS 完成的真实用例。
基本要求:至少具备中等带宽的活跃互联网连接。这是因为我们将使用 Google API 进行文本到语音的翻译。
注意:这将是语言建模教程的第一部分。在这个教程系列中，我们将介绍如何使用谷歌文本到语音，光学字符识别，深度学习模型，如序列到序列模型，以及其他很酷的东西。
文本到语音转换简介:
文本到语音(TTS)是将单词转换成有声音频形式的过程。程序、工具或软件从用户处获取输入文本，并使用自然语言处理方法理解所用语言的语言学，并对文本执行逻辑推理。该处理后的文本被传递到下一个块，在该块中对处理后的文本执行数字信号处理。使用许多算法和变换，这个处理过的文本最终被转换成语音格式。这整个过程包括语音合成。下面是一个简单的框图，以了解相同的。
作者图片
这似乎是一个相当复杂的过程，但是由于 python 和 gTTS 模块，这个过程可以简化为几行代码。从框图中我们可以了解到，被传递的文本首先借助自然语言处理进行预处理，然后利用数字信号处理转换成语音。
事不宜迟，让我们动手做一些代码。
gTTS 模块的安装:
在本教程的剩余部分，我们将使用 python。如果你还没有安装 python，那么请在这里安装。
gTTS 模块的安装很简单，可以在命令提示符终端中使用以下命令来完成—
安装完成后，我们可以继续编写一个非常简单的程序来理解我们如何使用这个模块将我们输入的文本转换成语音输出。打开 python 文件，给它起一个自己选择的名字，并确保它以。py 格式。让我们看看这个程序—
gTTS (谷歌文本到语音)是一个 Python 库和 CLI 工具，用于与谷歌翻译文本到语音 API 接口。我们将从可用于语音翻译的 gtts 模块中导入 gTTS 库。
文本变量是一个用来存储用户输入的字符串。该文本可以由引号内您选择的任何内容替换。另一种方法是使用 input 语句，让用户在每次运行程序时键入自己想要的输入。这可以通过以下方式完成:
tts 变量用于对用户输入执行谷歌文本到语音翻译。转换后的文本输出以语音的形式存储在 tts 变量中。
tts.save 功能允许我们将转换后的语音保存为允许我们播放声音的格式。我把它保存在一个名为 hi 的文件中，格式为. mp3。wav 格式也可以。
我们已成功完成保存文件。现在有三种方法来运行这个文件。我将回顾完成这项任务的所有 3 种方法—
- 从文件夹中直接运行保存的文件:您可以在运行 python 程序的同一位置找到保存的文件，并且可以在那里访问它。
- 使用 os 模块:我们可以使用 python 的 OS 模块直接从程序中运行文件。这样做的命令如下。
3.使用 playsound 模块:playsound 模块可以通过一个简单的 pip install playsound 命令来安装，然后我们可以使用下面的命令继续播放文件中的音频。
马特·博茨福德在 Unsplash 上拍摄的照片
结论:
gTTS 模块可广泛用于其他语言，如法语、德语、印地语等。，也是。当存在沟通障碍，用户无法向他人传达信息时，这是非常有用的。文本到语音对视力受损的人或有其他残疾的人来说是一个很大的帮助，因为它可以通过帮助文本到语音的翻译来帮助他们。gTTS 模块也有许多可能的想法，它也可以用于其他语言。
有可能会有很多同样出色的项目。我将鼓励观众尝试更多地尝试这个模块。观众可以随意参考我以前做过的一个很酷的项目。在这个系列中，我们将看到如何使用深度学习来实现翻译，以及 gTTS 模块如何在这一过程中发挥作用。
我希望你们都喜欢这篇文章，并祝你们有美好的一天！
机器学习如何入门
机器学习可能会令人生畏，在线学习可能会令人不知所措，因为那里有大量的材料，大多数人不知道从哪里或如何开始。
在这篇文章中，我提出了一个自学机器学习的计划，这个计划对我认识的许多人都有效，包括我自己。同样重要的是要注意，没有放之四海而皆准的学习路径，因为每个人都是独一无二的，并且有不同的目标，这些目标会随着时间的推移而变化。把这个计划当作一个指导方针或者别人的经验，你可以调整它来适应你。
Artem Sapegin 在 Unsplash 上拍摄的照片
学习基础知识
如果你没有机器学习背后的基础数学和统计学，那么现在就建立一个是个好主意。即使你有数学背景，复习一下总是好的。这一步的努力程度由你决定。
开始学习机器学习背后的数学的最好方式之一是阅读一本书的旧时尚方式。在我看来，最好的书之一是哈斯蒂等人写的《统计学习导论》 。好消息是，多亏了南加州大学商学院，你可以免费下载。这是书的链接。当然，你也可以从亚马逊购买。
同一作者的另一本非常好的书是 统计学习的要素 。你可以通过这个链接免费下载这本书，感谢斯坦福大学。还有，你可以从亚马逊买。
如果你不是那种坐着看书的人，那么看视频对你来说是个不错的选择。来自加州理工学院(CalTech)的 Abu-Mostafa 博士有一个很棒的免费在线课程，吸引了 700 多万观众。他的课程 从数据中学习 是 18 节课，分为理论、技术和分析。所有的课都在 YouTube 上，这里是课程的链接。
谈到在线机器学习基础课程，有著名的斯坦福大学在 Coursera 上开设的吴恩达 课程。这是最常见的初学者课程。这是一个很容易学习的课程，有一些小测验，完成后你将获得一个 Coursera 证书，你可以在你的 Linkedin 个人资料上分享。
编程语言选择
虽然您可以使用任何编程语言来编写机器学习代码，但 Python 和 R 是最常用的语言。Python 和 R 里有那么多专门为机器学习打造的库和包。此外，你可以很容易地通过 StackOverflow 这样的网站找到社区支持。机器学习建议坚持用这两种语言。
照片由克里斯蒂娜@ wocintechchat.com在 Unsplash 上拍摄
但是，如果您不了解 Python 或 R，或者您需要复习一下，该怎么办呢？好消息是，有几门在线课程同时教授 Python 和 R，重点是机器学习。你可以参加一个以机器学习为重点的速成班，而不是花几个小时学习 Python 和 R 的语法。
我最喜欢的三门课程是Python A-Z:Python For Data Science with Real 习题和Python For Data Science and Machine Learning boot camp，都是基于 Python 语言的。 R 编程 A-Z: R For Data Science with Real 习题，基于 R 语言。这些课程将向您介绍编程语言(Python 或 R ),并带您浏览机器学习所需的主要软件包以及如何使用它们。
动手机器学习课程
到目前为止，您已经学习了机器学习背后的数学知识，并在 Python 或 R 或者两者之间打下了坚实的基础。让我们将所有这些学习付诸行动，是时候参加一个在线课程，在那里你可以亲自编写代码来解决机器学习问题。
再说一遍，网上有大量的课程，所以做好你的研究，选择一个适合你的。我真正喜欢的课程之一是机器学习 A-Z:数据科学中的动手 Python & R。我喜欢这门课程的原因是，每一部分都分为 3 个部分，首先，讲师解释理论并提出一个要解决的问题，其次，讲师使用 Python 代码解决这个机器学习问题，最后再次使用 R 代码解决相同的机器学习问题。所以不管你是用 Python 还是 R 编程都没关系，因为这门课教你用两者来解决机器学习问题。我喜欢的另一个实践课程是机器学习、数据科学和使用 Python 的深度学习，大量的理论和机器学习实践编码练习。
做一些机器学习项目
在这一步，你在机器学习和 Python 或 r 方面有很强的基础，让你的技能更上一层楼的最好方法就是做一些真实的项目。进入 Kaggle 的竞赛页面，您可以从查看已完成的竞赛开始，并按照随附的笔记本进行操作。无论你对自己的技能是否有信心，我都强烈建议你参加一个积极的竞赛。在我看来，加入任何积极的竞争都是最好的学习方式。
如果你是那种想要参加课程并解决一些现实世界机器学习问题的人，那么我推荐机器学习实践锻炼| 8 个现实世界项目。这是一门实践课，我发现它非常有用，可以将你的机器学习技能运用到工作中。
获得证书
现在是时候获得证书并将其放入您的 LinkedIn 个人资料中了。你希望你的同事、招聘人员和潜在雇主了解你的机器学习技能。
再说一次，这是我的个人观点，你的研究也是如此。我相信最好的机器学习证书是 AWS 机器学习专业。你必须了解基本的 AWS 云才能开始学习这个证书，这是一个很难获得的证书，需要大量的准备。我前阵子写了一篇文章，讲的是通过 AWS 机器学习认证考试需要了解的 5 个主要概念。
你可以获得的另一个有价值的证书是 Udacity 的纳米学位机器学习项目。Udacity 与 AWS 和 Azure 合作，提供面向这些云提供商的机器学习计划。检查 AWS-Udacity 机器学习程序和 Azure-Udacity 机器学习程序。这些是为期数月的课程，教你机器学习和 AWS 或 Azure 云基础知识。
最后，我在下表中总结了前面描述的学习路径。
提议的学习路径
这对我和一些同事很有效，我把它放在这里作为你的参考指南。根据你的目标、需求和可用时间来设计你自己的学习计划是非常重要的。对一个人有用的东西对另一个人可能有用也可能没用，我们都是独一无二的，但是互相学习，看看什么有用，什么没用是很好的。祝你的机器学习之旅好运，这是一个艰难但非常值得的旅程。
如何开始 ML 重现性挑战 2020
本文的合著者:Ananya Harsh Jha 和 Eden Afek
免责声明: 所有作者均为 PyTorch 闪电队成员
了解如何在 PyTorch 闪电研究工具箱的帮助下，帮助缓解深度学习可重复性危机，同时提高您的技能。
灵感来自 v1 @ NeurIPS 2018
什么是再现性，为什么要关注再现性
复制实验结果的能力是任何科学领域的核心基础。然而，结果的可重复性一直困扰着整个机器学习领域，在很多情况下，它严重依赖于随机优化，而不能保证收敛。在深度学习中，重复性的关键往往在于最微小的细节，许多作者没有提到最关键的参数或训练程序，这些参数或训练程序使他们获得了最先进的结果。
可重复性不仅对于确定新的研究领域很重要，而且对于使它们更容易解释也很重要，这在我们试图用这种算法代替人类决策时至关重要。标准化提交的再现性并不一定意味着复制发表在主要论文中的精确结果，而是为其他研究人员提供指导，以根据他们自己的任务和计算能力得出论文中提出的相同结论。
再现性挑战
为了缓解这个问题，在 2017 年 ICML 机器学习研讨会的初始再现性之后，Joelle Pineau 博士和她的同事在 2018 年 ICLR 开始了第一个版本的再现性挑战。这项挑战的主要目标是鼓励人们复制 ICLR 2018 年提交的结果，这些论文可以在 OpenReview 上随时获得。随后是 2019 年 ICLR 挑战赛的第二版，以及 2019 年 NeurIPS 的第三版，通过 OpenReview 可以获得被接受的论文。
在论文“改善机器学习研究中的再现性】中，Pineau 等人列出了机器学习中再现性差距的原因:
- 无法获得相同的培训数据/数据分布不同
- 模型或培训程序的规格错误或规格不足
- 缺少运行实验所需的代码或代码错误
- 用于报告结果的指标不规范
- 不恰当地使用统计数据来分析结果，例如在没有进行恰当的统计测试的情况下声称具有显著性，或者使用错误的统计测试
- 选择性报告结果或忽略适应性过度拟合的危险
- 对结果的过度宣称，超出了提出的证据(即实验数量不足，或者假设和宣称不匹配)
Pineau 博士还发布了再现性清单:
该清单的目的是为作者和审稿人提供指南，说明提交给这些会议的结果的预期重现性标准。
ML 再现性挑战 2020
今年， ML 再现性挑战扩大了范围，涵盖了 2020 年横跨机器学习、自然语言处理和计算机视觉的 7 个顶级人工智能会议:NeurIPS、ICML、ICLR、ACL、EMNLP、CVPR 和 ECCV。挑战对每个人开放，你需要做的就是从列表中选择并声明一篇已发表的论文，并尝试复制其核心声明。
目的是评估原始论文中得出的结论是否可重现；对于许多论文来说，完全复制所展示的结果是不可能的，因此本次挑战的重点是遵循论文中描述的过程，并尝试得出相同的结论。
闪电再现性
显然，复制结果的一些障碍取决于研究科学家组织他们的项目的方式，然而对于其他人，你可以使用 PyTorch Lightning 来缩小这种差距。
PyTorch Lightning 的创造者和核心贡献者一直是机器学习和深度学习研究中可复制性的倡导者。事实上，NeurIPS 2019 上的再现性挑战的 v3 正式推荐使用 PyTorch Lightning 提交挑战。
Lightning 的主要理念是将工程与研究分离，从而使代码更具可读性。我们在 Lightning 的团队努力提供一种编写深度学习知识库的标准，让任何人都更容易知道你的代码在做什么，以及研究的有趣部分在哪里。
为了使研究更具可重复性，我们创建了 PyTorch 闪电，这是我们最先进的模型、数据模块和模型组件的工具箱。Bolts 的想法是让你能够在预先构建的组件上开始你的项目，并快速迭代你的研究，而不是担心如何设置项目或试图复制以前发布的结果。
作者图片
例如，如果您正致力于改进标准的 ImageGPT，只需对现有的实现进行子类化，并开始您令人敬畏的新研究:
作者图片
1.数据
如果您的工作涉及一些用于研究的标准数据集，请利用可用的 LightningDataModules ，并使用种子值来指定您进行实验的确切分割！
DataModule 封装了 PyTorch 中数据处理涉及的五个步骤:
- 下载/令牌化/处理。
- 清理并(可能)保存到磁盘。
- 在
[Dataset](https://pytorch.org/docs/stable/data.html#torch.utils.data.Dataset)内装载。 - 应用变换(旋转、标记化等)。
- 包在一个
[DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)里面。
这个类可以在任何地方共享和使用:
作者图片
在 Bolts 中，您可以找到以下实现:
2.模型检查点
Lightning 提供自动检查点，因此您可以随时恢复训练。当您使用 PyTorch Lightning 创建和保存模型时，我们会自动保存 Lightning 模块中定义的超参数。该检查点还包括优化器、LR 调度器、回调和其他任何需要的东西，以完美地重建您刚刚运行的实验的结果，从而发布一个新的艺术状态！
作者图片
我们的模型检查点不仅仅包含 state_dict！图片作者。
阅读更多关于检查点的信息。
3.预先训练的重量和实验记录
对于 Bolts，我们提供了一组预先训练好的重量以及用于实现某个结果的实验日志。我们提供经过验证的结果，因此您可以为您希望复制的不同论文提供一个经过测试的起点，而不是花费时间试图从一篇论文中复制一个声明。在接下来的几个月里，我们将努力在 Bolts 中添加更多的模型检查点和可复制的结果。
下面，我们展示了 CIFAR-10 上的 SimCLR 预训练实验的结果，这些结果是我们基于原始论文复制的。
该表概述了螺栓中存在的模型所实现的结果！图片作者。
这是来自 Bolts 文档的日志的一个例子，在这种情况下，它代表了在自我监督学习模型被预训练之后的微调过程。通过数据模块中的种子分割，任何人都可以复制我们在这里展示的相同结果！
作者图片
这些文档还包含我们得出结果所使用的精确超参数。
作者图片
祝你好运！
参加再现性挑战是加深你在深度学习中的知识的一个很好的方式，也是对整个科学界的贡献。我们邀请大家参与并考虑将您的模型贡献给 bolts 以增加可见性，并根据我们强大的测试套件对其进行测试。如果你想提问、反馈或寻找合作者，请查看我们的休闲频道。
编码快乐！
如何在两周内开始使用 Spark NLP 第一部分
良好的开端是成功的一半……
如果您想在企业 NLP 中有一个良好的开端，但是对 Spark 毫无头绪，那么这篇文章就是为您准备的。我见过许多同事想要进入这个领域，但是由于 Spark 带来的初始学习开销而灰心丧气。乍一看，这似乎并不明显，因为 Spark 代码与常规的 Python 脚本有些不同。然而，Spark 和 Spark NLP 基础并不难学。如果你理所当然地接受这个断言，我将向你展示基础是多么简单，并将提供一个路线图来为学习关键元素铺平道路，这将满足中级从业者的大多数用例。由于 Spark NLP 管道所带来的无可挑剔的模块化，对于一个普通的学习者来说，记住我的话，两周的时间足以构建基本的模型。卷起袖子，我们开始吧！
为什么 Spark NLP？
供需就是答案:是企业使用最广泛的库！这里有几个原因。如今常见的 NLP 包是由学者设计的，他们更喜欢原型的简易性，而不是运行时性能、可伸缩性、错误处理、目标节约内存消耗和代码重用。虽然一些像“工业级 NLP 库— spaCy”这样的库可能被认为是一个例外(因为它们被设计成完成事情而不是进行研究)，但当涉及到处理大量数据时，它们可能达不到企业目标。
无法方便地使用为研究和小规模任务设计的工具
这里我们将有 一个不同的策略 。我们将使用基本库来温习“基础知识”,然后直接跳到企业领域，而不是按常规随大流。我们的最终目标是通过建设大陆管道来瞄准利基市场，这是不可能用标准库解决的，尽管它们的容量在他们的联盟中。
如果你还不相信，请阅读这篇关于基准测试和与 spaCy 比较的文章，它会给你五个开始使用 Spark NLP 的好理由。首先，Spark NLP 具有与生俱来的特性可伸缩性它继承了 Spark，Spark 主要用于分布式应用，它被设计成可伸缩性。Spark NLP 从中受益，因为它可以在任何 Spark 集群以及内部和任何云提供商上扩展。此外，Spark NLP 优化的方式使得它的运行速度比传统库的固有设计限制要快个数量级。它提供了注释器的概念，并且包含了比其他 NLP 库更多的内容。它包括句子检测、标记化、词干化、词条化、词性标注、NER、依存解析、文本匹配器、日期匹配器、组块、上下文感知拼写检查、情感检测器、预训练模型，以及根据学术同行评审结果具有非常高准确度的训练模型。Spark NLP 还包括用于命名实体识别的 BERT 嵌入的生产就绪实现。例如，与 spaCy 相比，它在 NER 上犯的错误要少得多，我们在本文的第二部分测试了 spaCy。此外，值得注意的是，Spark NLP 包括提供完整 Python API 的功能，支持 GPU、用户定义的深度学习网络、Spark 和 Hadoop 上的培训。
该库提供了 BERT 嵌入的生产就绪实现，并使用迁移学习进行数据提取。迁移学习是一种高效的提取数据的方法，甚至可以利用少量的数据。因此，没有必要收集大量数据来训练 SOTA 模型。
此外，John Snow labs Slack channel 提供了有益的顶级支持，因为开发人员和新学习者倾向于团结在一起，创建每个人都可以从中受益的资源。你将从开发者那里得到你的问题的答案。我去过那里几次，可以证明他们的反应迅速而准确。此外，任何发现自己陷入困境的人都可以通过堆栈溢出或类似平台快速获得有类似问题的人的帮助。
关于 Spark 的著名“事实”是错误的
- Spark 是集群计算，所以它不能在本地机器上运行
不对！你可以在你的本地机器上运行 Spark，每个 CPU 核心都会用到核心！这就是 Spark NLP 运行时的样子:
Spark NLP 正在运行…我为所有这些 CPU 内核支付了费用，我很高兴看到它们都在运行。
虽然可以使用 Joblib 进行多重处理，但这是 spaCy 进程的典型情况。
更重要的是，你可以在 GPU 上运行 Spark。
- Spark 又是一门需要学习的语言！
好吧，如果你了解 SQL，PySpark 和 Spark NLP 根本不会让人觉得是另一种语言。SQL 和 Regex 本身都是语言，但是学习它们的基础知识并不难，对吗？
- Spark 是为大数据打造的，所以 Spark NLP 只对大数据有好处。
是的，Spark 内部使用了大量开销，但是 Spark NLP 为较小的数据集引入了一个“轻管道”。
起初，Spark 似乎是另一种具有挑战性的语言。Spark 不是最容易理解的库，但是我们将在 NLP 领域中做的事情已经在 Spark NLP 的基础设施中被巧妙的处理了，该基础设施由一个简单的 API 提供，可以很容易地与它交互。
虽然熊猫是数据科学家工具箱中最锋利的铅笔之一，但它只使用一个 CPU 内核，本质上，它的速度不够快，也不够强大，无法处理更大的数据集。Spark 被设计成使用集群计算来克服这些缺陷，你甚至可以在你的本地机器上运行它，分配任意多的 CPU 核心！遗憾的是，即使在本地机器上运行，pip install Pyspark 也不足以设置好，必须在 PC 和 Mac 上安装一系列的依赖项。对于那些想尽快投入行动的人，我推荐使用 Google Colab。
1)在 Mac 或 Linux 上设置使用 Spark NLP，必须安装 Apache Spark 版本 2.4.3 和更高版本。假设你还没有安装 Apache Spark，我们先从 Java 安装开始。只需进入官网并从“Java SE 开发套件 8u 191”，安装 JDK 8 。必要的命令行脚本可以在这里找到。
2)在 PC 上设置 Spark 可能有点棘手。试过很多方法后，我发现这篇文章是唯一有效的。还包括一段清晰简洁的视频。除了提供的文档，这个博客页面也帮助了我。
- 除非你必须在本地机器上运行 Spark，否则开始使用 PySpark 最简单的方法就是使用 Google Colab。由于它本质上是一个运行在谷歌服务器上的 Jupyter 笔记本，所以你不需要在我们的系统中本地安装任何东西。
要在 Colab 中运行 spark，首先，我们需要安装 Colab 环境中的所有依赖项，如 Apache Spark 2.3.2 with Hadoop 2.7、Java 8 和 Findspark，以便在系统中定位 Spark。详情请参见这篇文章。
**import** **os***# Install java*
! apt-get install -y openjdk-8-jdk-headless -qq > /dev/null
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-8-openjdk-amd64"
os.environ["PATH"] = os.environ["JAVA_HOME"] + "/bin:" + os.environ["PATH"]
! java -version*# Install pyspark*
! pip install --ignore-installed -q pyspark==2.4.4*# Install Spark NLP*
! pip install --ignore-installed -q spark-nlp==2.4.5
对于不想在 Colab 上运行笔记本的 PC 用户，我推荐在双引导 Linux 系统上安装 Spark NLP，或者使用 WSL 2 ，然而，这篇基准测试文章反映了 WSL 2 的一些性能损失。更准确地说，我在双启动 Ubuntu 20.04 安装后获得了我最好的 Spark NLP 体验。
第 2 天:Spark 基础知识、RDD 结构和使用 Spark 的 NLP 婴儿步骤
如前所述，Apache Spark 是一个分布式集群计算框架，对于大型数据集来说非常高效，它使用内存计算来进行闪电般的数据处理。对于在磁盘上运行的复杂应用程序，它也被认为比 MapReduce 更高效。
虽然像 pandas 这样的库足以满足大多数日常操作，但由于 容量、多样性和速度，大数据需要集群计算框架，这是大数据的三个定义属性或维度。
Spark 的核心是 Spark 核心——整个项目的基础，其余的 Spark 库都是在它的基础上构建的。Spark SQL 允许您使用 SQL 或熟悉的 DataFrame API 查询 Spark 程序中的结构化数据。
MLlib 适合于 Spark 的 API，并在 Python 和 R 库中与 NumPy 互操作。您可以使用任何 Hadoop 数据源，从而轻松插入 Hadoop 工作流。Spark 擅长迭代计算，使 MLlib 能够快速运行——比 MapReduce 快 100 倍。
Spark Mllib 包含构建在 rdd 之上的遗留 API。虽然我发现作为 Python 实践者，Spark Mllib 和 RDD 结构更容易使用，但是从 Spark 2.0 开始，Spark 中基于 RDD 的 API。MLlib 包已进入维护模式。Spark 的主要机器学习 API 现在是 Spark ML 包中基于数据帧的 API。
转换创建新的 rdd 和操作来执行计算。Lambda、Map 和 Filter 是一些基本功能。真实数据集通常是键、值对，类似于 Python 字典，但表示为元组。请观察下面创建二元模型和字数的代码，看看它与 Python 代码有多相似。我强烈推荐这门课程了解更多详情。
import resentences = sc.textFile(“ulyses.txt”) \
.glom() \
.map(lambda x: “ “.join(x)) \
.flatMap(lambda x: x.split(“.”)).map(lambda x: re.sub(‘[^a-zA-Z\s]’,’’,x))bigrams = sentences.map(lambda x:x.split()) \
.flatMap(lambda x: [((x[i],x[i+1]),1) for i in range(0,len(x)-1) \
if all([x[i].lower() not in stop_words,x[i+1].lower() not in stop_words])])freq_bigrams = bigrams.reduceByKey(lambda x,y:x+y) \
.map(lambda x:(x[1],x[0])) \
.sortByKey(False)In [1]:freq_bigrams.take(10)Out[1]:(1, ('Author', 'James')),
(1, ('Joyce', 'Release')),
(1, ('EBook', 'Last')),
(1, ('Last', 'Updated')),
(1, ('December', 'Language')),
(1, ('English', 'Character')),
(1, ('Character', 'set')),
(1, ('set', 'encoding')),
(1, ('UTF', 'START')),
(1, ('II', 'III'))]
# word count exampletext_file = sc.textFile(“example_text1.txt”)
counts_rdd = text_file.flatMap(lambda line: line.split(“ “)) \
.map(lambda word: (word, 1)) \
.reduceByKey(lambda a, b: a + b)# print the word frequencies in descending ordercounts_rdd.map(lambda x: (x[1], x[0])) \
.sortByKey(ascending=False)\
.collect()[:10]
输出
Out [3]: [(988, 'the'),
(693, 'and'),
(623, 'of'),
(604, 'to'),
(513, 'I'),
(450, 'a'),
(441, 'my'),
(387, 'in'),
(378, 'HAMLET'),
(356, 'you')]
第 3/4 天:Pyspark 的特征工程/清洁数据
Spark ML 提供构建在数据帧之上的更高级 API，用于构建 ML 管道，标准化机器学习算法的 API，从而更容易将多种算法结合到单个工作流中。这里我们将介绍 Spark ML API 引入的关键概念。
机器学习步骤可以应用到 from Spark SQL，在统一的数据集概念下支持多种数据类型。可以从常规的RDD中隐式或显式地创建一个SchemaRDD。
一个[Transformer](https://spark.apache.org/docs/1.2.2/api/scala/index.html#org.apache.spark.ml.Transformer)是一个抽象，包括特性转换器和学习模型，实现一个方法transform()，将一个SchemaRDD转换成另一个【】，通常通过附加一个或多个列。
An [Estimator](https://spark.apache.org/docs/1.2.2/api/scala/index.html#org.apache.spark.ml.Estimator)抽象了学习算法或任何适合或训练数据的算法的概念，实现了接受一个SchemaRDD并产生一个Transformer的方法fit()。比如LogisticRegression这样的学习算法是一个Estimator，调用fit()训练一个LogisticRegressionModel，是一个Transformer。
在机器学习中，通常运行一系列算法来处理和学习数据，例如将每个文档文本分割成单词，将单词转换成数字特征向量，以及使用特征向量和标签来训练预测模型。Spark ML 表示像[Pipeline](https://spark.apache.org/docs/1.2.2/api/scala/index.html#org.apache.spark.ml.Pipeline)s这样的工作流，它由一系列按照特定顺序运行的Transformers和Estimators组成，分别调用transform()和fit()方法，产生一个Transformer(它成为PipelineModel的一部分，或者被拟合为Pipeline)，并且在数据集上调用Transformer的transform()方法。
一个Pipeline就是一个Estimator。因此，在一个Pipeline的fit()方法运行之后，它会产生一个PipelineModel，也就是一个Transformer。一旦在测试数据集上调用了PipelineModel的transform()方法，数据就按顺序通过Pipeline，随着每个阶段的transform()方法更新数据集并将其传递给下一个阶段，数据集也随之更新。
和PipelineModel帮助确保训练和测试数据经过相同的特征处理步骤。下面是一个管道模型的例子。请注意，数据预处理是在熊猫数据框架上进行的。
#define regex pattern for preprocessing
pat1 = r’@[A-Za-z0–9_]+’
pat2 = r’https?://[^ ]+’
combined_pat = r’|’.join((pat1,pat2))
www_pat = r’[www.[](http://www.[)^ ]+’
negations_dic = {“isn’t”:”is not”, “aren’t”:”are not”, “wasn’t”:”was not”, “weren’t”:”were not”,
“haven’t”:”have not”,”hasn’t”:”has not”,”hadn’t”:”had not”,”won’t”:”will not”,
“wouldn’t”:”would not”, “don’t”:”do not”, “doesn’t”:”does not”,”didn’t”:”did not”,
“can’t”:”can not”,”couldn’t”:”could not”,”shouldn’t”:”should not”,”mightn’t”:”might not”,
“mustn’t”:”must not”}
neg_pattern = re.compile(r’\b(‘ + ‘|’.join(negations_dic.keys()) + r’)\b’)def pre_processing(column):
first_process = re.sub(combined_pat, ‘’, column)
second_process = re.sub(www_pat, ‘’, first_process)
third_process = second_process.lower()
fourth_process = neg_pattern.sub(lambda x:\
negations_dic[x.group()], third_process)
result = re.sub(r’[^A-Za-z ]’,’’,fourth_process)
return result.strip()df[‘text’]=df.iloc[:,:].text.apply(lambda x: pre_processing(x))
df=df[~(df[‘text’]==’’)]# shuffle the data
df = df.sample(frac=1).reset_index(drop=True)
# set the random seed and split train and test with 99 to 1 ratio
np.random.seed(777)
msk = np.random.rand(len(df)) < 0.99
train = df[msk].reset_index(drop=True)
test = df[~msk].reset_index(drop=True)
# save both train and test as CSV files
train.to_csv(‘pyspark_train_data.csv’)
test.to_csv(‘pyspark_test_data.csv’)
tokenizer = [Tokenizer(inputCol='text',outputCol='words')]ngrams = [NGram(n=i, inputCol='words',
outputCol='{}_grams'.format(i)) for i in range(1,4)]cv =[CountVectorizer(vocabSize=5460,inputCol='{}_grams'.format(i),\
outputCol='{}_tf'.format(i)) for i in range(1,4)]idf = [IDF(inputCol='{}_tf'.format(i),\
outputCol='{}_tfidf'.format(i), minDocFreq=5) \
for i in range(1,4)]assembler = [VectorAssembler(inputCols=['{}_tfidf'.format(i)\
for i in range(1,4)], outputCol='features')]label_stringIdx = [StringIndexer(inputCol='sentiment', \
outputCol='label')]lr = [LogisticRegression()]pipeline = Pipeline(stages=tokenizer+ngrams+cv+idf+assembler+\
label_stringIdx+lr)model = pipeline.fit(train_set)predictions = model.transform(test_set)
在 PySpark 中，通过 DataFrame API 和 SQL 查询与 SparkSQL 的交互是需要优先学习的科目。为了更好地理解基本操作，必须仔细阅读 Pyspark.sql 模块。以编程方式构造数据帧转换和操作并不太难，而且对数据帧的操作也可以使用 SQL 查询来完成。如果你只有一门课的时间，请花在约翰·霍格的特色工程和 Pyspark 课程上。如果时间允许(第五天)，也推荐本课程。
第 6/7 天:熟能生巧
学习的最好方法是实践。下周你将需要一套强化技能。尝试深入 Pyspark 模块，因为您将广泛使用它们。要重复“PySpark 和大数据处理的第一步”，请遵循这些练习。建议从 Kaggle 或 Project Gutenberg 下载一些数据集，并解决预处理问题以及其他问题。请跟随这款来自 Spark NLP 创作者的优秀笔记本。如需更多资源，请查看本笔记本和本文章。
接下来:第二部分——如何把你的头缠在 Spark NLP 上。在这一部分中，我们将理解“Spark NLP 中的注释器/转换器”，并使用大量笔记本强调“使用 Spark 进行文本预处理”、“预训练模型”和“文本分类器”。此外，我们将使用 spaCy 和 SparkNLP 运行完整的管道，并比较结果。
如何入门 Neo4j 的图形数据科学库
入门
Neo4j 中图形数据科学管理方式的巨大变化带来了巨大的机遇
图片来自 Ecpp，CC BY-SA 4.0【https://creativecommons.org/licenses/by-sa/4.0>】T2，转自维基共享。我没有改变这个形象。
图形分析领域已经存在很长时间了。总的想法是创建一个事物连接到其他事物的数据库。这些事情可能是人们在社交媒体上与其他人联系，或者可能是城市之间的航班或任何其他数量的例子。图形通常用于增强搜索能力，向电子商务网站上的购物者推荐产品，检测欺诈，或者绘制从 A 点到 b 点的最短路线。
长久以来，Neo4j 一直是图形数据库领域的重要参与者。历史上，它使用密码查询语言与数据库进行交互。有很多关于如何分析图表或使用密码的初级读本。相反，这篇文章旨在介绍如何使用新的 Neo4j 图形数据科学库 (GDS)来完成数据科学中的任务，这是对原始 Neo4j 图形算法库(现已废弃)的重大增强。从图算法到 GDS 有一些根本性的转变，但对于那些使用前者的人来说，一旦你掌握了新的使用方式，它将成为第二天性。出于本文的目的，没有必要使用任何一种来开始用数据科学方法解决图形问题。
我们将从你有一个正在运行的 Neo4j 服务器的前提开始。如果你还没有这个，你可以在这里下载开源社区版。需要注意的是，为了访问 GDS 图书馆，您需要下载 Neo4j 的 v4 版本。当前版本永远是最好的，并提供了 GDS 的最新功能(他们总是添加伟大的新功能！).
使用。图形数据的 csv 文件
一旦 Neo4j 服务器启动并运行，您将需要一些图形数据来填充它。虽然 Neo4j 中内置了一些示例图，但是介绍一下如何导入您自己的数据可能会有所帮助。
图形数据通常以边列表和节点列表的形式出现，它们通常是独立的文件。Neo4j 使导入这些文件变得容易。csv 格式，我们将讨论一种最容易导入的格式。让我们分别讨论一下这些文件。
节点列表:在此。csv 文件我们提供关于节点的信息——它们的标签。可以有许多类型的标签，或者您可以只提供一个通用的节点 ID。这些标签将用作上述node1和node2中的标识符。可以有任意数量的标签与节点相关联。好的选择是像唯一标识符、已知的名称(如果已知的话)和节点的一般类型(想想像“这个节点是一个人”或“这个节点是一个地方”，这可以用来给出像“人”或“地方”这样的节点类型)。格式看起来像这样
node1, label1, label2, …
边缘列表:在此。csv 文件中，您有关于哪些节点连接到哪些其他节点的信息。它还可以指定关系的类型。所以格式遵循典型的
node1, node2, relationship_type, weight
其中，node1是起始节点，node2是终止节点，relationship_type指定边标签(可选)，而weight表示该关系的强度(可选)。
请注意，为每个文件设置一个标题行通常是一个好习惯(尽管不是必需的),这样您就可以跟踪哪些列是什么。一旦你有了这些文件，我们就可以把它们载入 Neo4j。出于本教程的考虑，我们将使用《权力的游戏》(GoT)中的角色图。GoT out 上的图形数据有几个来源，但我特别喜欢 Andrew Beveridge 在 this repo 中维护的那个，因为它简单、有条理且易于使用。
数据被方便地分解成。节点和边的 csv 文件，每个季节一个文件。在本教程中，我将 repo 克隆到我的本地机器上以读取文件，但是您也可以选择从 web 上读取它们。
警告！！！图形分析是一个强大的工具，当我们进入 GoT 时，它将揭示一些严重的破坏者！所以如果你不想让系列剧透，现在就回头吧！
将数据加载到 Neo4j
使用内置的LOAD CSV命令将数据加载到数据库非常简单。因为我们在装货。csv 文件，您将希望确保进入 neo4j.conf 文件并注释掉行dbms.directories.import=import,以便允许我们从您本地机器上的任何地方加载文件。加载方式有很多种。csv 数据到数据库中，我挑了下面我觉得最简单的。
我们将从使用以下命令加载节点列表开始:
WITH "file:///Users/cj2001/gameofthrones/data/got-s1-nodes.csv" AS uri
LOAD CSV WITH HEADERS FROM uri AS row
MERGE (c:Character {id:row.Id})
SET c.name = row.Label
(这是加载到第一季文件中的命令，您可以重复这个命令来加载任何您想要的季节。我已经对从s1到s8的每个文件执行了这个命令。注意:第五季的文件名有轻微的错别字。)
使用上面的命令，我现在有了一系列类型为Character的节点，这些节点具有名为id和name的属性。注意，我们已经用标题行中可用的列名对应的Id和Label逐行加载了这个文件。
接下来，我们将使用以下命令加载边列表:
WITH "file:///Users/cj2001/gameofthrones/data/got-s1-edges.csv" AS uri
LOAD CSV WITH HEADERS FROM uri AS row
MATCH (source:Character {id: row.Source})
MATCH (target:Character {id: row.Target})
MERGE (source)-[:SEASON1 {weight: toInteger(row.Weight)}]-(target)
(同样，我们将对每个想要合并的边缘文件重复上述步骤。)
上面的命令创建了边缘类型为:SEASON1的字符之间的关系。我发现给每个季节赋予它自己的边类型是很方便的，这样可以探索不同季节之间图形的变化。边缘本身由源角色和目标角色交互的次数加权。注意，在导入时，Neo4j 认为所有的列都是字符串，但是对于我们将来的计算，我们希望 Neo4j 知道Weight实际上是一个整数，所以我们必须将其重新转换。还要注意我们使用了格式(source)-[edge_type]-(target)。因为在这个关系中没有指示方向的箭头，所以我们创建了一个无向图。如果我们想做其他的事情，这种关系应该看起来像(source)-[edge_type]->(target)。
内存中的图形:转移到 GDS 图书馆的大问题和简单的 PageRank 计算
内存图形的创建代表了 Neo4j 的革命性进步。基本上，它允许我们做的是创建不同的图或子图进行分析。我们可以在部分数据库上运行命令，而不是整个数据库。例如，在得到的数据中，我们可能关心对整个图表进行的计算，或者我们可能只想对单个季节进行计算。这种新的哲学方法为数据科学和图形上的机器学习打开了许多大门，我怎么强调都不为过！
我们将从创建整个 8 个赛季的内存图开始。在 GDS 有两种主要的方法可以做到这一点:使用 Cypher 投影或“本地”投影。我将在这里使用前者，因为这是一组非常直接的命令，很容易理解发生了什么。虽然原生投影非常快速和强大，但是超出了本教程的范围。为了用 Cypher 投影创建内存中的图形，我们使用命令
CALL gds.graph.create.cypher(
'full_graph',
'MATCH (n) RETURN id(n) AS id',
'MATCH (n)-[e]-(m) RETURN id(n) AS source, e.weight AS weight, id(m) AS target'
)
图形创建需要三样东西:
- 一个图形名称(
full_graph) - 一个节点查询(
MATCH (n) RETURN id(n) AS id - 一个边缘查询(
MATCH (n)-[e]-(m) RETURN id(n) AS source, e.weight AS weight, id(m) AS target
图形名称非常清楚。但是节点和边查询需要一点解释。出于速度原因，Neo4j 处理节点 id，而不是实际的节点信息。通常，这些 id 除了与我们拥有的任何节点或边标签无关的一组整数之外，不会映射到任何东西。但是当你看到id(n)时，这就是 GDS 与这些数据的实际关联。我们在节点查询中获得这些 id，然后在边查询中返回它们。
现在我们有了一个图表，我们可以在上面做一些数学运算。我们可以做的最基本的事情之一是计算图表中每个字符的 PageRank。我们可以用两种不同的方式来查看和使用这些结果。为了理解其中的区别，我们认为大部分 GDS 函数可以调用stream或write方法。前者将计算结果输出到屏幕上。例如，为了计算这个图表上的 PageRank 并将其输出到屏幕上，我们应该这样做
CALL gds.pageRank.stream('full_graph', {
maxIterations: 20,
dampingFactor: 0.85,
relationshipWeightProperty: 'weight'
})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).id AS id, gds.util.asNode(nodeId).name as name, score as full_pagerank
ORDER BY full_pagerank DESC
(我只是使用了maxIterations和dampingFactor的默认值。)注意，我们使用的是之前的节点 id，我们通过gds.util.asNode(nodeId)命令将它们从各自的 id 转换成我们识别的属性，比如id和name。
如果我们在所有 8 个季节的图表上这样做，我们会发现一些不令人惊讶的结果。各季排名最高的五个角色依次是提利昂、琼恩、丹妮莉丝、瑟曦和珊莎。(别担心……艾莉亚是 6 号。)
这个结果并不令人惊讶，也许我们真的想把它作为一个节点属性，用于内存图之外的未来分析。为此，我们想使用write方法，该方法将计算结果作为属性写入节点。为了做到这一点，我们做到了
CALL gds.pageRank.write('full_graph', {
maxIterations: 20,
dampingFactor: 0.85,
relationshipWeightProperty: 'weight',
writeProperty: 'full_pagerank'})
我们现在可以做一个简单的MATCH (c:Character RETURN c.name ORDER BY c.full_pagerank DESC来看看上面的结果。然而，我们可以看到，在这种情况下，PageRank 被添加为一个名为full_pagerank的节点属性。
这很有趣，但是如果我们了解《GoT》的话，我们会认为 PageRank 会随着每一季角色的增加和减少或者死亡而改变。为了探索这一理论，我将创建两个额外的内存中图表—一个用于第 1 季，一个用于第 8 季。对于第一季，这看起来会像
CALL gds.graph.create.cypher(
's1_graph',
'MATCH (n) RETURN id(n) AS id',
'MATCH (n)-[e:SEASON1]-(m) RETURN id(n) AS source, e.weight AS weight, id(m) AS target'
)
第八季也差不多。您可以使用CALL gds.graph.list()来检查图表。
现在，如果我对第一季进行同样的 PageRank 计算，我会得到奈德、提利昂、凯特琳、琼恩和丹妮莉丝是最具影响力的前五个角色。第八季再重复一遍，我得到前五名分别是提利昂、琼恩、丹妮莉丝、詹姆和珊莎。再说一次，如果你了解这部剧，这些都不会让人感到惊讶。
通过 Louvain 方法的社区检测
GDS 库中包含的一个强大工具是在内存图形上运行 Louvain 聚类的能力。要在所有 8 个季节的完整图表上这样做，并将计算的社区作为属性写入每个节点，我们将运行
CALL gds.louvain.write('full_graph',
{relationshipWeightProperty: 'weight',
writeProperty: 'full_community_id'
})
(注意，这样做不会得到很好的模块化，但是为 Louvain 调优参数超出了本教程的范围。)如果我想获得提利昂所有 8 个赛季的检测到的社区，我们将首先获得 ID 值(MATCH (c:Character {name: ‘Tyrion’}) RETURN c.name, c.full_community_id ，它给了我社区 143，但你的可能会不同)，然后在同一个社区中找到排名最高的人物。就我而言，我会做MATCH (c:Character {full_community_id: 143}) RETURN c.name, c.full_community_id ORDER BY c.full_pagerank DESC，我会得到 8 季中对提利昂生活影响最大的 5 个角色是瑟曦、詹姆、瓦里斯、乔佛里和泰温。不奇怪。我把它作为一个练习留给读者，让他们探索其他角色，或者看看探测到的社区是如何随季节变化的。
最后的想法
Neo4j 从基本的查询转向形式化的图表处理，使数据科学和机器学习成为可能，这给我留下了深刻的印象。这里有很多功能，我在本教程中只触及了皮毛。我希望在未来撰写其他文章，讨论诸如本机投影和 node2vec 和 GraphSAGE 的矢量嵌入所提供的全部可能性之类的事情，在 GDS 库的最新版本中，它们已经从 alpha 版本中移除。
[1] M. Needham 和 A. Hodler，图算法:Apache Spark 和 Neo4j 中的实际例子 (2020)，奥赖利媒体。
如何使用 Python 获取股票数据
用于获取股票价格数据和公司数据的 Python 一行程序
莎伦·麦卡琴在 Unsplash 上的照片
我最近对股票数据非常感兴趣；看看我是否能精心挑选出能够在中期带来适度回报的股票。我希望写一整篇关于我想出的策略的文章，但首先，我想分享如何首先获得股票价格数据，这样你就可以为自己进行类似的分析！
事实证明，使用名为 yfinance 的非常方便的 Python 库，这个任务变得非常容易。
为了解决这个问题，假设我们对获得微软(股票代号 MSFT)过去 10 年的股价数据感兴趣。
首先，我们将安装 yfinance 库:
- 打开 Anaconda 提示符或其他命令提示符，键入:pip install y finance
下面是为微软收集历史股票数据所需的基本代码:
这里的关键论点是:
- 周期:采集数据的频率；常见选项包括“1d”(每天)、“1mo”(每月)、“1y”(每年)
- 开始:开始收集数据的日期。例如“2010 年 1 月 1 日”
- 结束:结束收集数据的日期。例如“2020 年 1 月 25 日”
您的结果应该是一个包含微软每日历史股票价格数据的 Pandas dataframe。关键字段包括:
- 开盘:当日/月/年初的股票价格
- 收盘:当日/月/年末的股票价格
- 高点:当日/月/年股票达到的最高价格
- 低点:股票当日/月/年的最低价格
- 交易量:当天/月/年交易了多少股票
您可以使用生成的数据框架创建如下图表:
虽然history**是 yfinance 库最常见的函数，但我还想提到一些其他函数。
信息
对许多 tickers 来说，你可以从公司整体上获得有价值的信息，如地理位置、网站、业务摘要等。
日历
您还可以使用 yfinance 库来获取关于公司的即将到来的收益事件。
推荐
最后，您可以使用建议属性来查看分析师是如何对这只股票进行评级的。
仅此而已！希望这能帮助你开始进行自己的股票数据分析。
感谢阅读，下次再见！~
如何使用谷歌新闻订阅获取最新的新冠肺炎新闻
通过 RSS 源检索实时数据
照片由 Pexels 的 Lisa Fotios 拍摄
由于目前的在家政策，我在家工作。当我浏览互联网，寻找新冠肺炎相关的新闻文章时，我很好奇一些网站是如何获取最新的新闻或文章的。这些网站可以从各种网站检索新闻或文章。
我在想，太棒了！他们会在各个网站上建立多个爬虫来获取最新消息吗？但是这需要大量的工作。
或者可能存在一些免费检索新闻的 API？然而，我发现这些 API 提供者只跟踪某些网站。
我在想，有没有更简单的方法来获取最新的谷歌新闻？由于谷歌机器人正在抓取大多数网站，这应该是一个好的开始。尽管如此，谷歌在限制机器人方面的效率是出了名的。
经过数小时的研究，我发现有一种方法可以检索最新的谷歌新闻，那就是搜索谷歌 RSS 新闻源。
如果你有兴趣知道如何建立一个网站，将显示最新消息？或者也许你正试图将现场新闻整合到你的网站上？或者您可能只是想知道如何检索新闻？
这篇文章是给你的。
什么是 RSS？
RSS 代表【丰富的网站摘要】或【真正简单的联合】，它是一种提供定期变化的网络内容的格式。它允许用户在一个单一新闻聚合器中跟踪许多不同的网站。因此，许多与新闻相关的网站、博客和其他在线出版商将他们的内容作为 RSS 提要提供给任何想要的人。
所以，你对什么是 RSS 有了更好的理解，让我们从抓取开始吧！
我们需要搜集的确切网址是什么？
BASE URL: http://news.google.com/news?
以下是我认为对检索英语相关的新冠肺炎新闻有用的参数列表。如果您有兴趣了解更多信息，请随意点击此处获取 google 官方 XML API 文档。
查询术语:
- 问:这代表我想要请求的查询词，在本例中，它是新冠肺炎。
- hl:你正在使用的用户界面的宿主语言。我更喜欢用 en-US。
- sort:这个参数是可选的。我将希望根据日期对新闻进行排序，因此值是日期。
- gl:这是原产国与参数值匹配的增强搜索结果。该值是美国，因为这是我的 web 浏览器的默认值。
- num:您希望获得的新闻数量。我会选择最大值 100。
- 输出:你想要的输出格式。我会选择 RSS。
这是我将向其发送请求的最后一个字符串。
URL: http://news.google.com/news?q=covid-19&hl=en-US&sort=date&gl=US&num=100&output=rss
恭喜，你现在只剩下代码部分了。
编码部分
我使用的编程语言是 Python。在测试代码之前，一定要安装这两个库— bs4 和 feedparser 。
您会注意到我创建了一个名为 ParseFeed 的类，有两个方法clean 和parse。clean 函数将从 HTML 文档中提取所有文本，并用空格字符替换字符\xa0。
此外，parse函数将解析 HTML 并打印一些我认为重要的字段。例如，新闻的标题、描述、发布日期和 URL。
下面是在 Jupyter 笔记本上运行上述代码后的输出快照。
最终想法
吉尔·威灵顿摄于 Pexels
正如你可能注意到的，你可以通过 RSS 以一种更方便的方式检索新闻。如果你有兴趣追踪其他种类的新闻，你可以调整参数来得到你想要的。但是，请注意，有些参数是有限制的。
非常感谢你一直读到最后。如果你有任何你想让我讨论的话题，欢迎在下面评论。
大家待在家里，注意安全！
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
关于作者
低魏宏是 Shopee 的数据科学家。他的经验更多地涉及抓取网站，创建数据管道，以及实施机器学习模型来解决业务问题。
他提供爬行服务，可以为你提供你需要的准确和干净的数据。你可以访问这个网站查看他的作品集，也可以联系他获取抓取服务。
在媒体上阅读低纬鸿的作品。数据科学家|网络抓取服务:https://www.thedataknight.com/.每…
medium.com](https://medium.com/@lowweihong)
如何在 Kaggle 上获得前 1%并帮助进行组织病理学癌症检测
一个关于我第一次 Kaggle 比赛的故事，以及我在那次比赛中学到的东西。此外，大量的代码、模型权重以及可能对其他研究人员有帮助的想法。
肾单位通过维基共享资源
大约一年前，我参加了第一次关于癌症分类的 Kaggle 竞赛。从那以后，我参加了更多的比赛，甚至和我的团队一起发表了一篇关于 CVPR 的论文。但是，我觉得我们在一场比赛结束后失去了大部分知识，所以我想分享一下我的方法以及 发布代码模型权重 (迟到总比不到好吧？).
我希望我的想法(+实现它们的 PyTorch 解决方案)对研究人员、Kaggle 爱好者以及希望在计算机视觉方面做得更好的普通人有所帮助。
免责声明:我不是医学专业人士，只是个 ML 工程师。也就是说，对我所有与医疗相关的声明都要持保留态度。然而，我乐于接受批评，所以如果你在我的陈述或一般方法中发现了错误，请随时联系我，我会尽最大努力纠正它。
什么是组织病理学癌症，为什么它很重要
neverov 通过 memepedia
简而言之，你需要一个大型的数字病理扫描，裁剪它的碎片(补丁),并试图在这些作物中找到转移组织。在这种特殊情况下，我们有来自淋巴结大扫描的补丁(PatchCamelyon 数据集)。请记住，转移是癌细胞扩散到身体的新部位。通常，它是通过淋巴系统的血流来完成的。
这项工作的重要性非常简单:构建机器学习驱动的系统可能也应该帮助那些无法获得准确诊断的人。也许他们没有好的专家，或者只是想再次检查他们的诊断。
然而，请记住自我治疗并不是一个明智的想法，而且许多 ML 医疗系统都是有缺陷的( 最近的例子 )。
引擎盖下是什么
目标
主要的挑战是解决斑块是否包含转移组织的分类问题。阳性标签表示补片的中心 32×32 像素区域包含至少一个肿瘤组织像素。贴片外部区域的肿瘤组织不影响标记。
所有解决方案都在预测概率和观察目标之间的 ROC 曲线下的面积上进行评估。
电子设计自动化(Electronic Design Automation)
在任何 ML 项目中，首先要做的是探索性数据分析。
Train/Test images: 220025/57458Value counts:
0 130908
1 89117Image size: (96, 96)
确认
毫无疑问，对于构建 ML 模型来说，最重要的事情是验证。有人可能会认为，简单地将数据随机分成 80/20 的比例进行训练和验证，或者以分层的方式进行，或者应用 k 倍验证，都是可以的。但实际上，验证这种模型的最好方法是分组折叠。我们如何建立组，为什么在这种情况下它是最好的验证技术？让我们后退一点。
正如我之前所说，我们处理的补丁是一些更大图像(扫描)的一部分。也就是说，我们不能将扫描的一部分发送给培训，而将剩余部分发送给验证，因为这将导致泄漏。因此，每次扫描都应该是训练或完全验证。这就是我们构造组的原因，这样组与组之间就没有扫描的交集。
为了做到这一点，我们需要将每个补丁与其对应的扫描相匹配。我们这样做是 Kaggle challenge 的一部分，你可以在 GitHub repo 中找到文件 (patch_id_wsi_full.csv) 的完整匹配。
数据准备
关键的一步是调整大小，因为在原始大小上训练产生的结果一般。更糟糕的是，只对中心作物进行训练。文章末尾附有完整的表格和模型比较。
基于对手工训练集的检查，我认为把我的增强集中在翻转和颜色变化上是个好主意。请注意，我没有使用白蛋白，而是使用默认 pytorch 变换。这只是遗产，因为我大约一年前写了这部分代码，不想在转移到 albumentations 时破坏它。
模型和优化细节
模型的主干是 EfficientNet-B3 或 SE_ResNet-50，其头部经过修改，具有自适应平均池化和最大池化的串联+具有密集压差的附加 FC 层(3 层，压差为 0.8)。使用 EfficientNet 和 SE_ResNet 的主要原因是，它们是非常适合这个特定数据集的默认主干。
优化器是没有任何权重衰减的 Adam+ReduceLROnPlateau(因子= 0.5，耐心= 2，度量=验证 AUROC)，用于调度，训练分两部分完成:微调头部(2 个时期)，然后解冻网络的其余部分，并微调整个事情(15-20 个时期)。两个阶段的学习率都是 0.01，并使用 LR 范围测试进行计算(学习率以指数方式增加，计算训练集的损失):
阶段 1 的学习率范围测试
阶段 2 的学习率范围测试
请记住，实际上使用莱斯利·史密斯提出的原始想法更好，在那里您线性增加学习率并计算验证集上的损失。这样，你会得到更可靠的结果，但只是需要更长的时间来完成。
训练是使用常规的 BCEWithLogitsLoss 完成的，没有任何类权重(原因很简单，它是有效的)。
附加技巧(增加的东西+不起作用的东西)
托弗麦卡洛克通过 flickr
为了获得更好的性能，应用了 TTA。特别是 4-TTA(所有旋转 90 度+原始),用于使用平均平均值进行验证和测试。此外，所有倍的高效网-B3 和 SE_ResNet-50 是混合在一起的一个简单的手段。
如果你想进一步提高最终模型的质量，并且不想被原创的想法所困扰(比如高级的预处理和后处理)，你可以很容易地应用 SWA。为了做到这一点，回购支持 SWA(这不消耗内存，因为 EfficientNet-B3 的权重需要大约 60 Mb 的空间，SE_ResNet-50 的权重需要 40 Mb 的空间)，这使得平均模型权重变得容易(请记住，SWA 不是平均模型预测，而是平均其权重)。
我试图为最后阶段的训练增加更复杂的损失(像 FocalLoss 和 Lovasz 铰链损失)，但改善是微不足道的。还有，我实现了渐进式学习(训练时增加图像大小)，但出于某种原因，这并没有帮助。也许，我的实现是有缺陷的，因为这通常是提高模型性能的一种相当安全的方法。
模型比较
请注意，合奏没有 CV 分数。这样做的原因是，基于单倍分数比较单个模型很容易(但你需要冻结种子)，但为了比较整体(如混合、堆叠等)。)您需要一个额外的维持集。换句话说，例如，您将所有数据的 20%用于维持，其余的 80%照常分成多个部分。这很简单，也是我没有在这个解决方案中实现它的唯一原因——我没有计算资源从头开始重新训练 10 次折叠。
这也是我不公布加权综合得分的原因:你需要根据验证的坚持来微调权重。
最后的想法
Mememaster 通过 memepedia
这个比赛已经结束一年了，所以很明显，很多新的想法已经浮出水面，这应该会提高这个模型的质量。个人可以推荐以下。
如果您的资源不低，只需训练更多具有不同主干(重点是 SE_ResNet、SE_ResNeXt 等模型)和不同预处理(主要是图像大小+添加图像裁剪)的模型，并将它们与更密集的 TTA(添加关于颜色的变换)混合，因为集成对于这个特定的数据集非常有用。但请记住，为了评估整体(并可靠地比较折叠)，有必要从折叠中单独分离出一个坚持。
如果你想要比混合神经网络更具原创性的东西，我当然会建议在领域知识方面研究更复杂的数据增强技术(也就是说，与领域专家合作，并征求如何增强图像的想法，以便它们仍然有意义)。此外，很明显，我使用了预先训练的 EfficientNets 和 ResNets，它们是在 ImageNet 上训练的。在类似于这个数据集的一些医疗相关数据集上运行额外的预训练(甚至从头开始训练)应该是一种有利可图的方法。
联系人
如果你对这个解决方案有任何问题，请随时在评论、GitHub 问题或我的电子邮件地址 ivan.panshin@protonmail.com 联系我
如何让 Turi Create 在 Windows 上运行
很有可能，你正在学习一门在线课程，并对所有这些错误信息感到沮丧。这是一个关于如何做到这一点的教程。
沙哈达特·拉赫曼在 Unsplash 上拍摄的照片
受众:机器学习初学者，命令行初学者，windows 用户，Python 3，Anaconda
我一直在学习机器学习基础在线课程，但在建立所需的库时已经失败了，这让我彻底疯了。让我们省点挫折吧。这个简短的教程旨在帮助你更容易地完成第一步
为什么我们要用 Turi 创建 ？
Python 中有很多机器学习库，其中大部分都不容易扩展到大型数据集。Turi Create 使我们能够创建各种各样的 ML 模型，而不必安装额外的软件包。它易于使用，包含有用的绘图选项，并且对于您可能想要使用的数据是灵活的。
Turi Create 可以完成许多 ML 任务，大多数不需要额外的库。
要求:
- Python 2.7、3.5、3.6
- x86_64 架构
- 至少 4 GB 内存
支持的平台:
- macOS 10.12 以上
- Linux(带有 glibc 2.10 以上版本)
- Windows 10 (WSL)
这就是我的问题开始的地方。就像我经常做的那样，我只看了手册的一半就开始打字…并且面对一条又一条的错误信息。
评论:你将不能简单地在 Windows 10 平台上安装/运行 Turi Create。你必须先为 Linux(WSL)安装一个WwindowsS子系统。
安装 WSL
为了安装任何 WSL，必须启用“用于 Linux 的 Windows 子系统可选功能”。
-
按照以下命令以管理员安润身份打开 PowerShell:
-
出现提示时，重新启动计算机
-
安装您选择的 linux 发行版。在这个例子中，我们使用的是 Ubuntu 16.04
评论:Ubuntu 16.04 不是最新版本，以后还得更新。如果找到最新版本，直接安装，跳过“更新”这一步。
- 以管理员身份打开命令行，并使用以下代码
结果应该是这样的:
现在我们需要使用 PowerShell 安装我们的发行版。运行以下命令，而“app_name”是您的 distro.appx 文件的名称
评论:这个也可以手动完成，不赘述。它基本上是寻找 distro.appx 文件并点击安装。
如果你不小心下载了一个过时的版本(像我一样)，你会被提示更新(我已经更新了)
您的发行版命令终端会被自动提示，并要求您输入一个新的 Unix 用户名:遵循正则表达式
规则:
- 以小写字母或下划线开始
- 后跟小写字母、数字、下划线、破折号
- regex:I .[a-z _][a-z0–9 _-]*[$]？
评论:我试过各种各样的名字，但都被拒绝了。最后我选择了一个简单的名字，全部小写，没有特殊字母。
安装 pip
使用 pip 安装 turicreate。如果你已经安装了 Ubuntu，你可以使用这个教程。确保您使用的是 sudo 权限。
- 将提示您批准使用额外的磁盘空间—按“Y”
- 然后会要求您重新启动。我选了
。不过这取决于你
- 安装完成后，验证是否安装了 pip3
- 尽管版本号可能会有所不同，但看起来应该是这样的:
- 一旦安装了 Turi Create，您将得到以下错误(除非您已经安装了 T ensorflow
使用 pip 安装 Tensorflow
- 打开您的 Ubuntu(或首选发行版)控制台，使用以下命令:
差不多就是这样。我还安装了 Sframe 来处理大数据集，但这是个人喜好的问题。该社区已经开始提供直观的教程供进一步使用，并提供鼓舞人心的文章。你现在可以开始玩 Turi Create 和机器学习了。玩得开心！
如何让您的数字化转型顺利进行
在您的组织中(再次)实现数字化的八种做法
维多利亚博物馆在 Unsplash 拍摄的照片
数字化正处于炒作曲线的顶点，但大多数公司都在艰难前行。
一些公司雇佣了一大批数据科学家，希望奇迹发生。
其他公司雇佣顾问，希望找到一种能让他们在竞争中脱颖而出的策略。
每个人都希望成为下一个 Airbnb、优步、网飞、亚马逊等，但显然这只会是少数快乐的人。
然而，大多数公司将从改善现有业务中受益，例如通过降低成本、提高产量、提高效率、改善质量和提高安全性。
这意味着数字化的重点应该是公司现有的员工和工作流程。
你可以雇佣像数据科学家这样的新人，但是他们通常缺乏领域知识(例如，对工作流程的深入了解)。你可以聘请战略顾问，但他们通常离车间太远。
你应该关注你自己的人，并培养他们为你改变公司。
以我的经验来看，有八种做法可以让你更有机会成功启动数字化转型，它们都以员工为重点。我不是一名商业顾问(也不打算成为一名)，我不确定这些对你的情况是否有用。很可能有更多的实践有所帮助。无论如何，我确实认为这八个大大提高了你的机会。
第一个练习取自精益，叫做:
1.拉，不是推
当开始一件新的事情时，你会面临阻力。然而，总有人渴望尝试新事物。你需要识别这些人，你需要给他们你所有的注意力和精力。
在他们工作的领域开始行动，无论是一个地点还是一个流程，都没有关系。给他们你的时间(当他们向你寻求支持或建议时，放下其他事情)。突破障碍，让他们的生活变得轻松，并要求他们升级瓶颈。给他们提供培训机会，让他们向你的高级经理和主管展示他们的工作。
有时候，更大的机会出现在阻力最大的领域。不过，不要在那里消耗你的能量，先解决阻力。只把精力花在人们要求支持的领域，因此得名拉，而不是推。人们应该寻求帮助，而不是你把它推给他们。从短期来看，推动可能会奏效，但以我的经验来看，这种效果不会持久。
所以，拉，而不是推。
2.赞助
你需要组织中的高层人士来赞助 digital，否则，人们不会开始行动。这并不意味着计划应该从最高层开始(尽管那会有所帮助)，你也可以通过展示自下而上计划的早期结果来影响高层领导。
赞助可以简单到在与员工的交流中提到数字。简单易行，效果很好。其他有帮助的事情包括为计划释放预算，释放人们的时间，通过召集思想领袖和组织对其他公司(通常是其他行业)的参观来促进公司内部的活动。
你可以在没有赞助者的情况下开始，但是这种努力是不可持续的。
所以，给自己找个赞助人吧。
3.小核心
少即是多。如果你想快速行动，最好从一个小团队开始。如果你在超过 10 人的团队中工作过，你就知道我在说什么。团队中的人越多，沟通的开销就越大，这通常无助于加快速度。普莱斯的平方根定律也适用于数字:50%的产出是由参与的人的平方根产生的。如果你的组织中有 100 人从事数字化工作，其中大约 10 人将产生 50%的产出。
要开始数字化，你需要一个小型的全职核心团队(约 5 人)，为其他人铺平道路。只为这个群体选择最优秀的人，但也要注意整体构成(即技能互补)。
小核心团队。安妮·斯普拉特在 Unsplash 上的照片
你需要寻找具有领域知识、编码经验(不需要全栈软件开发人员)和沟通技巧的人。这些人很难找到，但不要犯退而求其次的错误，你会后悔的，因为东西不会动。
所以，建立一个小的核心团队。
4.工程师变成了数据科学家
数据科学是 20 世纪最性感的工作，这吸引了大量年轻人学习计算机科学。在您的数字化工作中，您肯定需要数据科学家，但不要低估对领域知识的需求。无论你有多聪明，你都无法赶上几年甚至几十年的领域知识。大多数数据科学家确实掌握了最低水平的领域知识，但在某些领域这是非常困难的，例如在工程领域。
我总是和工程师一起工作，大多数工程师在大学时都做过某种形式的编码。当他们开始工作时，对这些技能的需求会减少，因为他们开始在工作中使用商业软件。这是一个遗憾，因为他们带来了领域知识，并拥有编码的技能(但却藏在某个地方)。我发现当你让工程师重新编码时，他们会变得非常高效。他们不具备数据科学家的深入编码技能，但如果你向他们解释(Scikit learn)机器学习主要涉及线性回归，他们会很快明白你在说什么。反过来，我看到聪明的数据科学家完全忽略了他们正在构建的模型背后的物理原理，最终得到了完全无用的结果。
因此，为了转型，从一些数据科学家那里获得帮助，但是更好地专注于让你的工程师重新拾起编码。
5.线上+线下培训
这年头不缺网上培训。你可以在大规模开放在线课程(MOOC)中学习任何数字化的东西。你甚至可以在任何你喜欢的领域获得纳米学位。这当然很好。然而，训练只有在实践中应用才有用。
为了实用，你可以用离线(课堂)培训来补充在线培训，让参与者解决你公司的实际问题。这样你就获得了双赢，人们可以发展自己，解决公司中存在的问题。
课堂训练的主要好处不是你想的那样。在公司里，人们总是被拉向日常工作(紧急的，不重要的)，这使得人们很难投入时间学习。如果你让人们只做在线培训，只有最敬业的人才会完成培训。通过“强迫”他们进入教室，他们将更有可能阻碍他们的议程并专注于学习。通过让人们共处一室，他们还将从更广阔的视角了解这些材料如何帮助解决业务问题。这在(个人)在线培训中并不容易。
作为课堂培训的一部分，你可以要求人们组成小组，一起解决业务问题。通过合作，他们学到了更多，他们更有可能坚持下去，他们为公司创造了价值。
所以，不要只局限于线上培训，要辅以线下培训。
用线下培训补充线上培训。在 Unsplash 上 NeONBRAND 拍摄的照片
6.投资自助服务
自助服务意味着让业务人员自己开发数字解决方案，而不是 IT 部门。这可以像仪表板一样简单，但也可以是简单的应用程序或自动化工作流。自助服务并不意味着人们必须成为成熟的软件开发人员。关键是让人们创造一个最低可行的产品，他们可以展示给它，这样他们就可以创建一个可持续的解决方案，而不用在设计阶段花费太多时间。值得注意的是，许多数字解决方案从未投入生产，因为开发过程本身解决了问题的根本原因。
数字化最困难的部分通常是获取数据。确保您让人们能够访问您公司的核心数据源。也要给他们工具来处理数据和平台来发布他们的产品。给人们空间来开发他们自己的解决方案，但是当他们陷入困境时支持他们。
所以，投资自助服务吧。
7.永远不要等待下一个/更好/更闪亮的工具/倡议/承诺，永远不要
数字化发展如此之快，以至于当你正在实施某件事情的时候，下一个更好的版本就会出现来取代它。人们很想等待下一个更好、更闪亮的版本，因为它可能会带来更多价值。这是很多公司面临的问题。等待的问题是你永远不会开始。如果你不开始，你就不能解决问题。
随着新的库和框架以创纪录的速度出现，许多数据科学家/开发人员也经历了这种情况。学习一个新的库、框架甚至编程语言都需要投入大量的时间。这段时间你也可以花在开发解决方案上。相当多的数据科学家因为跟不上发展而筋疲力尽。然而，对于一个企业来说，使用哪种框架并不重要，只要它能工作。通过解决问题，你会增加更多的价值，即使解决方案使用的是“旧”技术。在数字化过程中,“老”是相对的。
所以，永远不要等待，永远不要。
永远不要等待下一个最好的事情。雷·桑加·库苏马在 Unsplash 上的照片
8.为了速度而变通规则
最后一种做法叫做“为了速度而变通规则”。我并不是说要打破这里的规则，尽管有时这可能是必需的。
变通规则意味着你接受事情不完全按照书上说的去做，但是你知道在有限的时间内这样做不会有太大的伤害。这需要你的员工有些勇气，所以如果你发现这本书没有被遵守，不要责备他们。
在大公司里，不可避免地会有繁文缛节，繁文缛节会拖你的后腿。繁文缛节之所以存在，是因为过去出了问题，而控制措施是为了避免将来出现这种情况。这没什么不好，然而，繁文缛节往往有不良的副作用。
当你开发数字解决方案时，你肯定会遇到繁文缛节。例如，您想用生产数据测试一些东西，但是您需要遵守各种政策，并且需要获得各种部门的批准。嘣，几个星期的延迟。或者，您可以让 IT 部门的朋友进行临时连接，瞧，测试完成了，但只需 5 分钟。确保你保护那些帮助你违反规则的人，他们通常支持组织中级别较低的团队。
所以，变通规则让你继续前进。
摘要
如果你无法在自己的组织中开始使用数字技术，或者当你陷入困境时，考虑我上面描述的八种做法，因为它们将增加你再次摆脱困境或开始前进的机会。它们不是火箭科学，也不是所有的都适用于你的情况。如果你感到停滞不前，至少尝试几次，看看你是否能再次前进。像任何转型一样，保持前进是最重要的。
总之，这是我描述的八个实践:
- 拉，不是推
- 赞助
- 小核心
- 工程师变成了数据科学家
- 线上+线下培训
- 投资自助服务
- 永远不要等待下一个/更好的/更闪亮的工具/倡议/承诺，永远不要
- 为了速度而变通规则
祝您的数字化转型好运！
观点是我自己的，不是我雇主的观点
如何赋予您的微生物组数据生命？
关于如何使用 Plotly 的 R graphing library 进行微生物组数据分析和可视化的教程。
从人类占 50%的艺术科学项目中移走微生物。信用:索尼娅·布梅尔。
我是一名微生物生态学家，这意味着我研究微生物如何相互作用及其环境。最近，我跳进了数据科学的世界，这要感谢我从 Mitacs 获得的研究员资格，与数据分析&可视化公司 Plotly 一起工作。Plotly 是关于构建交互式数据科学 web 应用程序的，在这篇文章中，我想分享一些背景知识，介绍如何使用 Plotly 的 R graphing library 通过我的研究中的一些数据实现微生物组数据的交互式可视化。您可以使用提供的代码和链接复制所有图形。你甚至可以自己点击“编辑图表”按钮进入编辑器，对它进行修改或提出改进建议！
在直接进入可视化部分之前，让我先给你一个我们正在处理的数据类型的概述。如果你已经熟悉微生物组数据，你可以跳过下一节。
什么是扩增子或鸟枪数据？
它们本质上是通过 DNA 测序方法获得的数据，这些方法识别关于 DNA 片段或整个基因组的信息。这些序列被组装和注释，使用生物信息学工具提取关于给定环境中微生物身份或基因丰度的生物信息。这种分析的输出是所谓的 OTU(操作分类单位)表或基因丰度表。
包含样本信息和原始计数的 OTU 表。图片由作者提供。
包含与 OTU ID 相关的分类单元信息的分类表。图片由作者提供。
这个表以及关于分类法和元数据的信息可以用于统计分析和可视化。我选择的编程语言是 R，因为已经开发了许多用于微生物组分析的软件包(例如， phyloseq 、 microbiomeSeq 、 microbiome 、 picante )，也因为这种语言的统计特性。
先说交互数据可视化(还有一些统计)！
作为评估样品或环境差异的第一个概述，通常查看α多样性。阿尔法多样性描述了特定样本或环境中的多样性(有关阿尔法多样性统计的更多信息，请查看 Amy D. Willis 的论文)。使用具有以下代码的盒状图可以很容易地绘制多样性指数，并通过将鼠标悬停在图上或单击图例以隔离轨迹的方式进行交互式探索(有关特征的说明，请参见右上角的工具)。
# load libraries
library(dplyr)
library(data.table)
library(plotly)# load file
df <- fread("[https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/alphadf.csv](https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/alphadf.csv)")# create annotations for y axis
y_p1 <- list(
title = "Shannon")
y_p2 <- list(
title = "Phylogenetic Diversity")# filter variable and plot first subplot
p1 <- df %>% filter(variable == "Shannon") %>%
plot_ly(
x = ~Compartment,
y = ~value,
color = ~Treatment,
colors = "Dark2",
type = "box",
legendgroup = ~Treatment,
showlegend = TRUE) %>%
subplot(nrows = 1, shareX = TRUE, shareY =TRUE, titleX = FALSE) %>% layout(boxmode = "group", yaxis = y_p1)# filter variable and plot second subplot
p2 <- df%>% filter(variable == "Phylogenetic Diversity") %>% plot_ly(
x = ~Compartment,
y = ~value,
color = ~Treatment, colors = "Dark2", type = "box", legendgroup = ~Treatment, showlegend = FALSE) %>%
subplot(nrows = 1, shareX = TRUE, shareY =TRUE, titleX = FALSE) %>% layout(boxmode = "group", yaxis = y_p2)# combine subplots
p_box <- subplot(nrows = 1, p1, p2, titleX = TRUE, titleY = TRUE)
p_box# you can also update details of the graph in [chart studio](https://plotly.com/chart-studio/) (e.g. legend names) by creating a free account and api key and then upload them
Sys.setenv("plotly_username"="put your username here")
Sys.setenv("plotly_api_key"="put your api key here")chart_link = api_create(p, filename = "your file name")
chart_link
显示 16S rRNA 扩增子测序数据的α多样性指数的箱线图。这些只是一些常见的例子，可以选择更多的指数。
条形图的替代方法是所谓的小提琴图，它是箱形图的扩展，增加了一个内核密度图，显示数据的分布形状。小提琴越宽，该范围内的数据点越多；数据点越少越小。下面的代码生成了一个分割的 violin 图，其优点是可以直接比较多个组(这里是植物-土壤区间)。通过对其他分集指数进行过滤，并遵循上述组合图的代码，可以添加额外的子图。
# load libraries
library(dplyr)
library(data.table)
library(plotly)# load file
df <- fread("[https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/alphadf.csv](https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/alphadf.csv)")# filter variable, assign sides of plot
p_violin <- df %>% filter(variable == "Shannon") %>%
plot_ly(type = 'violin')
p_violin <- p_violin %>%
add_trace(
x = ~Compartment[alphabac.dfmelt$Treatment == 'Control'],
y = ~value[alphabac.dfmelt$Treatment == 'Control'],
legendgroup = 'Control',
scalegroup = 'Control',
name = 'Control',
side = 'negative',
box = list(
visible = T),
meanline = list(
visible = T),
color = I("#1B9E77"))
p_violin <- p_violin %>%
add_trace(
x = ~Compartment[alphabac.dfmelt$Treatment == 'Treatment'],
y = ~value[alphabac.dfmelt$Treatment == 'Treatment'],
legendgroup = 'Treatment',
scalegroup = 'Treatment',
name = 'Treatment',
side = 'positive',
box = list(
visible = T),
meanline = list(
visible = T),
color = I("#D95F02"))p_violin %>%
layout(
xaxis = list(
title = ""),
yaxis = list(
title = "Shannon",
zeroline = F),
violingap = 0,
violingroupgap = 0,
violinmode = 'overlay')
显示 16S rRNA 扩增子测序数据的 Shannon alpha 多样性的分裂小提琴图。
下一步，我们可以探索基于所选的分类等级给出微生物种类信息的分类法。通常，选择门(用于更广泛的概述)和属(用于更深入的概述)的等级。提示:这有助于根据平均丰度从最丰富到最不丰富的分类群对数据进行排序，以便于解释(阅读更多关于为什么排序数据对清晰解释很重要的信息此处)。
# load libraries
library(dplyr)
library(data.table)
library(plotly)# load data (already normalized)
df <- fread("[https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/psbac.df.csv](https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/psbac.df.csv)")# annotate plots (for more on annotation check out this [link](https://plotly.com/r/text-and-annotations/))
a <- list(
text = sprintf("Bulk"),
font = list(size = 14),
xref = "paper",
yref = "paper",
yanchor = "bottom",
xanchor = "center",
align = "center",
x = 0.5,
y = 1,
showarrow = FALSE)b <- list(
text = sprintf("Rhizosphere"),
font = list(size = 14),
xref = "paper",
yref = "paper",
yanchor = "bottom",
xanchor = "center",
align = "center",
x = 0.5,
y = 1,
showarrow = FALSE)# order based on decreasing mean abundance and group by Phylum, filter for desired variable (here plant compartment) and pass into plotly function
p1 <- df %>%
mutate(Phylum=fct_reorder(Phylum, Abundance, .fun='mean', .desc=T)) %>%
group_by(Phylum) %>%
filter(Compartment == "Bulk") %>%
plot_ly(x = ~Treatment,
y = ~Abundance,
color = ~Phylum,
colors = "Dark2",
type = "bar",
legendgroup = ~Phylum,
showlegend = F) %>%
layout(barmode = "stack", legend=list(title=list(text='Phylum')),
annotations = a, xaxis = list(autorange = "reversed"))# repeat previous step for second variable
p2 <- df %>%
mutate(Phylum=fct_reorder(Phylum, Abundance, .fun='mean', .desc=T)) %>%
group_by(Phylum) %>%
filter(Compartment == "Rhizosphere") %>%
plot_ly(x = ~Treatment,
y = ~Abundance,
color = ~Phylum,
colors = "Dark2",
type = "bar",
legendgroup = ~Phylum,
showlegend = T) %>%
layout(barmode = "stack", legend=list(title=list(text='Phylum')),
annotations = b, xaxis = list(autorange = "reversed"))# plot subplots
p <- subplot(nrows = 1, p1, p2, titleX = T, titleY = T, shareX = T, shareY = T, margin = 0.05)
p
16S rRNA 扩增子测序数据的门水平上相对丰度以降序排列的堆积条形图。
我喜欢用气泡图来代替堆积条形图，在堆积条形图中，气泡的大小代表分类群的丰度。我将在这里用鸟枪法宏基因组学数据用下面的代码来说明这一点。
# load libraries
library(dplyr)
library(data.table)
library(plotly)# read in file (already converted to df using the [psmelt](https://www.rdocumentation.org/packages/phyloseq/versions/1.16.2/topics/psmelt) function of the phyloseq package)
df <- fread("[https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/meta_relative.csv](https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/meta_relative.csv)")
# convert to factor
df$perc_SWHC = as.factor(df$perc_SWHC )# hide tick labels for x axis, set title (you can do this alternatively directly in the layout using lists)ax <- list(
title = "soil history",
zeroline = FALSE,
showline = FALSE,
showticklabels = FALSE,
showgrid = FALSE
)# alternatively pass in phyloseq object and use psmelt function, order based on mean abundance, then split based on desired parameter and pass everything into a plotly functionp <- df %>%
mutate(Phylum=fct_reorder(Phylum, Abundance, .fun='mean', .desc=T)) %>% split(.$soil_type) %>%
lapply(function(d) {
plot_ly(d,
x = ~perc_SWHC,
y = ~Phylum,
text = ~Abundance,
type = 'scatter',
mode = 'markers',
size = ~Abundance,
color = ~perc_SWHC,
colors = "Dark2",
#Choosing the range of the bubbles' sizes:
sizes = c(10, 50),
marker = list(opacity = 1, sizemode = 'diameter')) %>%
layout(xaxis = ax,
yaxis = list(showgrid = FALSE))}) %>%
subplot(nrows = 1, shareX = T, shareY =T, titleX = T, titleY = T, margin = 0.01) %>%
layout(legend=list(title=list(text='% SWHC')))
# remove unwanted legends from plot
for (i in seq(3, length(p[["x"]][["data"]]))) {
p[["x"]][["data"]][[i]][["showlegend"]] <- FALSE
}
p
鸟枪法宏基因组学数据的相对丰度显示了以平均丰度递增顺序排列的最优势门。颜色显示了第二个类别，在这种情况下，土壤持水能力的百分比被用作模拟干旱与非干旱条件的处理。
关于相对丰度的旁注
关于根据数据的相对丰富程度来解释数据的缺点，一直存在争议；这是有充分理由的，因为一个分类单元丰度的每一次增加都会导致其余分类单元丰度的相应减少。正如加州大学圣地亚哥分校奈特小组的詹姆斯·莫顿所说:
“知道生物体 A 和 B 是否以 80%和 20%的比例存在是一回事，但这些数字是来自 1 亿还是 1 亿个细胞对宿主来说有着巨大的差异。”(更多信息请查看唐磊的评论和声明背后的论文)。
这就是说，相对丰度数据应仔细解释，从这些数据中推断准确的分类转变时必须谨慎。
让我们通过观察β多样性来继续典型微生物组分析的下一步。β多样性衡量从一个环境或样本到另一个环境或样本的物种多样性变化。这通常以散点图或 PCoA/NMDS 图(主坐标分析/非公制多维标度)的形式示出，其中样本基于它们的相似性或不相似性被分离，并被排列在低维 2D 或 3D 空间中。不同的指数可用于计算相异矩阵。关于这方面的更多信息，请查看 r . com 中的 distance { phyloseq } pr design dist { vegan }文档。
# load libraries
library(dplyr)
library(data.table)
library(plotly)# load file (in this case I calculated the matrix based on Bray-Curtis dissimilarity using the ordinate function of the phyloseq package and converted it to a df, then merged the df with the sample metadata)df <- fread("[https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/pca_16S.csv](https://raw.githubusercontent.com/ruthlys/files_plotlyr/master/pca_16S.csv)")# create axis annotation
x <- list(
title = "Axis 1"
)
y <- list(
title = "Axis 2"
)# plot 2d plot with color settings and text annotations
p1 = plot_ly(df,
x= ~Axis.1,
y= ~Axis.2,
color = ~Compartment,
colors = "Dark2",
mode = "markers",
type = "scatter",
text = ~Compartment,
alpha = 0.8,
marker = list(size = 12)) %>%
layout(xaxis = x, yaxis = y)
p1# plot 3d plot with color settings and text annotations
p2 <- plot_ly(
df,
x = ~Axis.1,
y = ~Axis.2,
z = ~Axis.3,
color = ~Compartment,
colors = "Dark2",
text = ~Treatment,
mode = "markers",
type = "scatter3d")
p2 <- p2 %>% layout(scene = list(xaxis = list(title = 'Axis 1'),
yaxis = list(title = 'Axis 2'),
zaxis = list(title = 'Axis 3')))p2
基于 Bray-Curtis 指数计算相异矩阵后的 16SrRNA 扩增子测序数据的 2D 散点图(NMDS 图)。
基于 Bray-Curtis 指数计算相异矩阵后，16SrRNA 扩增子测序数据的 3D 散点图(NMDS 图)。
暂时就这样了。我希望本教程对你有用，并且对你自己的数据分析和可视化有所帮助。请继续关注更多关于如何使用 Plotly 的 R 图形库、Dash for R 和 Dash Bio 可视化组学数据的教程！
如何在两个月内从 Python 新手成为 Google 认证的 TensorFlow 开发者
在疫情期间感到无聊，我决定挑战自己，学习 Python，并在两个月内获得 Google 认证为 TensorFlow 开发人员。下面是我的故事和我的学习之路。
作者照片。
我仍然记得我向大学提交论文的那一天。当我的学士学业接近尾声时，我如释重负地叹了口气。然而，厌倦很快征服了我。无事可做，世界被疫情吞噬，我拼命寻找新的活动来填补我空虚的日子。
在这篇文章中，我将告诉你这种疫情的无聊是如何让我在不到两个月的时间里成为谷歌认证的 TensorFlow 开发者的，尽管我以前从未用 Python 编码过。我提供了一份我用来准备这次考试的相关学习材料的清单。
我张量流'起源故事'
作为一个喜欢学习的人，我的好奇心促使我阅读了大量关于疫情的新闻和文章，当时我偶然发现了一篇关于一组研究人员开发一种新系统的文章，该系统可以在 X 射线图像中区分肺炎和新冠肺炎病毒。
文章提到，他们使用“人工智能”和“神经网络”来制作系统。这立刻激起了我的兴趣——他们如何训练一个可以区分 x 光扫描的系统？这个人工智能甚至没有医学学位，但它有超过 90%的准确率！就这样开始了我深入学习的兔子洞之旅。
长话短说，和一个朋友的简短对话让我对 TensorFlow(和 Keras)大开眼界。又一天的好奇浏览让我读了丹尼尔·伯克的博客，关于他如何获得 TensorFlow 开发者认证的。
我也挑战自己去获得认证，但我担心我没有足够的时间，因为我马上就要被雇用了，而且几乎同时开始我的硕士学位课程。再者，我对 Python 一窍不通。我真的能完成这个壮举吗？
我本科学习的是精算学的应用数学，这意味着我非常熟悉微积分、回归、时间序列和统计学。然而，我的 Python 编程技能很少，因为我知道的唯一编程语言是 R。虽然我发现 R 是一种非常通用的语言，可以满足数据相关工作的需求，但不幸的是，目前语言 R 不支持 TensorFlow 开发人员认证考试。
作为一名自称的数据和人工智能爱好者，获得这项认证将是我旅程中的一个里程碑。好了，我的故事讲完了。再说 TensorFlow。
什么是张量流？为什么要学？
TL；DR 版本:TensorFlow 是一个广泛可用的机器学习软件库。
略低的 TL；DR 版本:TensorFlow 是一个免费的开源框架，使用户能够开发端到端的机器学习和深度学习项目，从预处理到模型训练和部署。它最初是由谷歌大脑团队开发的，供谷歌内部使用，但现在它的使用已经非常广泛。
现在，你为什么要学习 TensorFlow？因为它能做很多事情，而且比你想象的更广泛。很有可能，你在不知情的情况下使用了 TensorFlow 提供的服务。
展示 Gmail 智能回复如何工作的 gif 图片。图片来自 Greg Bullock (2017)，来自文章“在 Gmail 中使用智能回复节省时间”。https://blog . Google/products/Gmail/save-time-with-smart-reply-in-Gmail/。来源:谷歌
你用过 Gmail 的 Smartreply 吗？它是人工智能驱动的，并根据你电子邮件上写的内容向你建议三种回答。它是使用 TensorFlow 构建的。
你的推特时间表的排序方法？WPS Office 的 OCR(图像转文本识别)？VSCO 的为你的照片预设建议？张量流。
写这篇文章的时候，TensorFlow 只有 4 年的历史，它已经在我们日常使用的许多服务和产品中广泛使用。虽然没有明确写下，但开发图像识别系统以区分常规肺炎和新冠肺炎肺炎的研究人员有可能在他们的系统中使用 TensorFlow。
在未来，随着深度学习和人工智能领域的改善，我们可能会看到越来越多的产品、服务以及科学突破，这些产品、服务和科学突破都是由 TensorFlow 提供支持，以帮助他们进行深度学习。
如果这些领域的从业者熟悉这个平台，他们就会受益，这种思路也是我自己有兴趣成为认证 TensorFlow 开发者的原因。也许，你在阅读这篇文章之前或期间有类似的想法，或者也许你也有自己的理由去研究张量流。尽管如此，请继续阅读下一部分，了解更多关于考试的信息。
什么是 TensorFlow 开发者证书考试？这要花多少钱？
TensorFlow 数字徽章。图片摘自文章:“介绍 TensorFlow 开发者证书！“阿丽娜·辛卡斯基。来源:TensorFlow
TensorFlow 开发者证书考试是笔试，必须用 Python 语言完成。在考试中，我们利用 Python 的 TensorFlow 库及其 API。每次考试费用为 100 美元。如果你第一次试用失败，你可以再次支付 100 美元，并在两周后重考。关于考试费用和规则的更多细节可以在手册这里找到。
考试大纲包括四个要点:使用 TensorFlow 建立和训练神经网络，图像分类，自然语言处理，以及时间序列。考试必须在 Pycharm IDE 中进行。
看完手册后，我开始计划我的学习路径，从学习 Python 语言本身开始，然后熟悉 TensorFlow。
我的学习之旅:第一个月
如果你还和我在一起，或者如果你跳过了阅读这篇文章，那么让我简单地提醒你一下。一个无聊的应用数学毕业生，无事可做，没有任何 Python 经验，突然梦想在两个月内成为 TensorFlow 开发人员。以下是我实现这一目标的历程。
在第一个月，我熟悉了 Python 语言。我如何快速地做这件事？我做的第一件事是去 hackerrank ，并立即用大量的 Python 问题进行练习。当我遇到自己无法解决的问题时，我会试着在旅途中上网查找解决方案。如果这也没有帮助，我查看了解决方案，并试图理解我在这个问题中可以掌握的概念。
这就是我两个星期所做的一切，到那时，我能够回答大多数问题，甚至是那些难度更高的问题，而不需要看任何答案。
剩下的两周我做了什么？我看免费的 YouTube Python 教程。你没听错。
好吧，免责声明来了。如果你有机会以一种更结构化的方式学习正式的 Python 课程，请务必这样做。下面我列出的三个视频只是我个人的选择，加速我的 Python 学习之旅。
这些视频之所以被如此低估，仅仅是因为它们是“免费”的，而你完成它们并没有获得任何证书。以下是几个不错的选择:
-
《Python 初学者教程》用 Mosh 编程。这个视频简明清晰地重述了 Python 的基本概念，从字符串、操作、函数、数据类型(列表、字典、元组)、继承开始，然后通过制作三个初学者友好的项目结束视频。第二个项目与我的道路最相关，因为它是关于机器学习的。
-
《Python for Data Science 全教程》edu reka！本视频涵盖了 Python 中的必要包，为数据科学打下坚实的基础。在视频的最后，他们简要地谈到了使用 Keras 和 TensorFlow 在 Python 中进行深度学习，所以这让我对即将发生的事情有了一个初步的了解。
-
freeCodeCamp.org《用 Python 分析数据》。在我们制作模型和训练它们之前，一个经常被忽视的阶段是预处理我们的数据。这个视频更多地集中在上述部分，并强调收集数据，加载它们，清理它们，以及使可视化，以得出见解。
虽然在我接下来的研究中，我会注册一个“正式”的 Python 课程，但这三个 YouTube 视频现在已经足够了。只要确保做笔记，写你自己的代码，以及在你观察的时候尝试不同的东西。
我的学习之旅:第二个月
我花了一个月的时间参加深度学习。Coursera 的 AI TensorFlow 开发者专业证书。在本课程中，我们将接受谷歌首席人工智能倡导者劳伦斯·莫罗尼和 deeplearning.ai 创始人吴恩达的辅导
这个专业有四门课程，涵盖了前面提到的考试大纲的四个要点。每门课程包括四周的课程，但我一天学了一周的课程，因为这是我那个月的首要任务。
完成每门课程后，我会休息一天，利用这一天来研究我的练习代码，或者以休闲的方式探索与课程相关的想法。
概括地说，我花五天时间完成每门课程。四天查看课资料，第五天休息复习。因此，我能够在 20 天内完成所有的课程。
每门课程都有自己的编码项目，我真的探索提供的代码。我经常发现自己花了几个小时摆弄神经网络的超参数(当你开始学习它时，你就会知道我在说什么)，以便尝试并获得最佳的验证准确性。通过这样做，你会对创建深度神经网络模型的试错过程有一种“直觉”。
有时，课程参考了外部资源，如数据集、文章和未分级的材料。这些并不是通过这门课程的必要条件，但出于好奇，我探索了许多外部资源。由于课程大多是实践性的，我们经常会看到吴恩达制作的视频链接，他在视频中解释了特定主题的更直观和理论化的方法。
替代材料
为了在这次考试中取得成功，你不一定要遵循我的学习路径和我的学习材料。如果你不想每月花 49 美元来学习 coursera 课程，还有其他选择，我会在这里列出来:
- 用 Scikit-Learn、Keras 和 Tensorflow(第二版)实践机器学习。这本书是我想在未来几个月内完全阅读并完成的东西，因为它的全面性真的有助于我理解关于机器学习和深度学习的关键概念。第 10-16 章包含了与考试大纲相似的材料。
- 编码 Tensorflow Youtube 播放列表。这是一个免费的 YouTube 播放列表，包含了这次考试的材料，大部分是由劳伦斯·莫罗尼教授的。我更喜欢参加 coursera 认证，因为它有额外的评分测验和项目，但如果你敢于根据 YouTube 播放列表中的材料进一步探索，我认为你会得到很好的帮助。不要忘记在他们的官方网站上查看 Keras 和 TensorFlow 文档。
参加考试
我花四天时间复习功课，在完成所有课程后重读手册。第二个月 25 号，开始考试。
好了，登陆日到了。好的，这是第一个问题的答案——开玩笑的。由于显而易见的原因，我无法了解考试的详细信息，但我整理了一些关于准备和参加考试的要点:
- 首要任务—安装所需的 Python IDE。在我的考试迭代中，我们被要求使用 PyCharm 。确保下载正确的版本(参考手册)并禁用/卸载其他第三方插件。快速提示:在开始测试之前，我会先测试我的 PyCharm，运行一些 TensorFlow 模型，看看是否有任何错误需要解决。
- 报名参加考试这里。完成付款并上传您的 ID(身份证/护照)。之后，你会收到另一本手册，这本手册只留给那些已经付费并注册参加考试的人。好好复习，确保你在考试开始前准备充分。
- 考试是五个小时。明智地管理你的时间。当你的问题模型正在被训练时，你可以开始处理下一个问题。在您的模型被训练和保存后，不要忘记提交和测试您的模型(安装考试插件后，您的 IDE 将有一个“测试和提交模型”按钮)。
- 首先集中完成所有问题，然后如果您有时间，您可以回去调整您的模型。记住，有时间限制。只要你的模型得了满分，你就可以走了。
- 可以在 Google Colab、AWS 等外部平台上训练模型。在开始考试之前，你应该学习如何从外部平台保存你的模型，然后在 PyCharm 中加载它。您必须以“. h5”格式保存您的模型。
如果你学得很好，并且确信你已经学完了考试大纲中列出的所有东西，你应该会通过考试。我可以告诉你，手册上写的大纲没有误导，你真的可以用那里提供的列表作为你考试准备的基准。
就我个人而言，我在没有专用 GPU 的 AMD 笔记本电脑上进行考试，但我只需要在处理大型数据集的问题时使用一次 Google Colab。在你的设备上训练几个练习模型，你就会知道你的设备是否足够强大。我更关心互联网的速度和稳定性，因为你需要上传这些模型来完成考试。
考试成绩
结束考试后，我马上收到一封邮件，说我已经通过考试了。两周内，我的官方数字证书发送到我的邮箱，我可以把它链接到我的 LinkedIn 个人资料。
有效期只有三年，所以我要在 2023 年再考一次认证考试。到那时，我只能对 TensorFlow 和深度学习领域的进步感到惊讶，希望我参加那个考试的旅程比第一次更顺利。
结论…然后下一步是什么？
这不是结束，事实上对我来说这只是开始。将这次考试作为我的第一个里程碑真的让我超级兴奋，并且是我进入数据科学世界的大门，这很奇怪——因为通常深度学习是有抱负的数据科学家的最佳选择。
我很高兴在我开始精算工作和攻读硕士学位的前几天，我设法完成了这个证书考试并写了这篇文章。通过这两个月，我对数据科学和人工智能的世界产生了新的兴趣。这个领域可能带来的解决现实世界问题的可能性似乎是无穷无尽的。
我要写一个提醒，我相信我的学习之路并不是最好的，还有很大的提升空间。对于那些不受时间限制的人来说，也许放慢速度，同时做项目是更好的学习途径。至于现在，即使我是一名认证的 TensorFlow 开发人员，我还没有在我的 GitHub 帐户上做一个项目。这就是我在这篇文章发表后的目标——通过制作真实的个人项目并把它们放到我的 GitHub 上来进一步提高我的技能。
作为一个充满创新、发现和突破的快速增长的领域，我相信人工智能、数据科学、机器学习和深度学习的世界是一个等待探索的新领域。冒险来到这个世界，你兴奋吗？因为我是。而对我来说，这一切都是从疫情期间的无聊开始的。
如何从贝叶斯定理到贝叶斯推理
当我还是一名统计学新手并试图学习贝叶斯统计时，我经常发现开始时非常混乱，因为大多数在线内容通常以贝叶斯公式开始，然后直接跳到贝叶斯推理的 R/Python 实现，而没有给出多少关于我们如何从贝叶斯定理到概率推理的直觉。因此，我希望这篇文章能够真正填补我们在简单公式和完全不同层次的贝叶斯研究之间的空白，用尽可能少的数学。具体来说，我想谈谈
- 一个经典贝叶斯公式例子背后的直觉，以及为什么在理解贝叶斯推理中没有用
- 贝叶斯推理在实践中是如何工作的
- 概率分布和似然之间有什么区别，这是贝叶斯推理中的两个主要组成部分(因此我们将知道先验和似然之间的区别)
- 我们如何能够忽略计算的分母和命名的贝叶斯公式在实践中的大部分时间与一个简单的现实生活中的例子在后验模型，以估计股票市场的回报。
一个经典贝叶斯公式示例背后的直觉
我想再次重申，在这里我将专注于直觉而不是数学。
贝叶斯定理通常从癌症检测中的一个例子开始。在这篇文章中，没有例外。高中/本科学习这个公式的时候，总会给你一些事件的概率，计算另一些事件的概率。
你经常看到的贝叶斯公式
比如我们会提前知道某人得癌症的概率，像 P(癌症)=0.1 。这意味着如果我们从这个国家随机抽取一个人，10%的人会得癌症。有了新的癌症检测技术，它可以提供更准确的信息，更新我们对一个人是否患有癌症的信念。幸运的是，有了贝叶斯公式，我们可以量化我们在确定一个人是否患有癌症方面有多少把握。
以前，如果我们对一个人进行随机抽样，我们只有 10%的把握确定他患有癌症，这是我们的先验信念。借助新的测试技术和数据(可能性)，我们将确定性提高到 66%。这是获得贝叶斯定理背后的直觉的一个很好的开端，但有可能你这辈子再也学不到这个了，因为这个公式毫无用处，原因有二。
1。公式的每一部分都有不确定性
首先，先验、似然、分母在现实生活中都是不确定的。我们永远无法确切知道我们的人口中有多少%患有癌症，我们所能做的最好的事情就是做出一个有根据的猜测。
在统计领域，每当我们试图对不确定性建模时，我们称之为概率过程(相对于确定性过程)。我们将用概率分布对事件建模。
因此，对于先验(又名多少人患有癌症)，为了量化我们的信念，我们将不对概率本身设定一定的值，而是对产生概率分布的参数设定一定的值。
我们使用的概率分布取决于我们试图估计的变量/参数。如果我们要估计某件事情发生的概率(也称为离散变量)，我们可以使用二项式或泊松分布。另一方面，如果我们要估计股票收益(也称为连续变量)，我们可以使用正态/学生 t 分布。
因此，在现实生活中，我们不会说 P(stock_up)=0.1，在贝叶斯统计中，我们会说“作为一名金融专家，我根据经验猜测，未来 12 个月的股票回报将遵循均值为 30%、方差为 5%的正态分布，我希望用我们后来获得的新数据来更新这一经验(先验)。
然后，你就有了理解贝叶斯推理的良好开端。
2。贝叶斯统计是关于概率函数的乘法，而不是实数
我们确定先验总是被建模为概率分布。概率分布总是有一个概率质量函数(对于离散变量)或概率密度函数(对于连续变量)。在我们的股票回报的例子中，先验分布是一个正态分布，一个已知的均值和方差作为我们的猜测。
正态分布的概率密度函数，这将作为我们的先验分布
在现实生活的贝叶斯统计中，我们经常忽略分母(上式中的 P(B )),不是因为它不重要，而是因为它在大多数情况下无法计算。我将跳过为什么计算它如此困难的讨论，但请记住，即使没有分母，我们也有不同的方法来计算/估计后验概率。
这使得我们的“现实生活”贝叶斯统计只有两个组成部分，可能性和先验。
似然函数也遵循与先前相似的方式。我们还将假设可能性函数的概率分布。但是，我们不是对参数进行猜测，而是让数据来确定将用于生成似然函数的参数值。生成似然函数后，我们可以将似然函数与先验函数相乘，得到后验函数。
正态分布的似然函数
在现实生活中，与教科书中的癌症例子不同，在贝叶斯统计中，我们不是对我们的可能性概率有一个确定的值，而是说“我作为一名数据分析师，从股票市场收集了许多数据，并得出股票回报遵循正态分布的结论。根据我收集的数据，最有可能的是均值为 10，方差为 2。我们将利用这一点来更新我们先前的信念”
为了有一个短暂的停顿和总结，我们可以看到，在实践中，我们将两个概率函数相乘并产生一个后验概率函数，它被证明是一个概率分布，它代表了对我们先验知识的更新信念。在股票市场回报的例子中，这意味着我们对关于股票市场回报的参数(也称为均值和方差)有一个初始的信念(先验)。有了额外的数据，我们收集并量化为可能性，我们进一步更新我们对均值和方差(后验)的信念。
但是当我研究这个问题的时候，上面的解释只是给出了更多的问题而不是答案。似然和概率分布有什么区别？上面显示的公式看起来很复杂，我如何推导后验分布的公式/概率密度函数？这是否意味着我需要成为一名概率专家才能实现哪怕是一个基本的贝叶斯模型？
我向你保证，我们就快到了。让我们继续吧。
概率和可能性之间的差异
让我们退一步，再来谈谈高中数学。当我们开始学习概率的时候，我们会有一个抛硬币的例子。假设我们有一个公平的硬币，我们假设 P(头)=0.5。这意味着伯努利分布，参数p已知为 0.5。
这个例子非常适合我们之前的组件，我们将假设某个值作为我们的参数(在正态分布中，参数是平均值和方差，以防您不将它们联系在一起)。
在高中数学中，我们知道参数，我们试图计算某些数据出现的概率。但是在现实生活中，我们很可能想做相反的事情。通常我们对自己的参数一无所知，会有满手的数据，想要对自己的参数值做出推断(估计)。似然函数正是为此目的而设计的。
让我们再次以抛硬币为例。我们没有事先知道抛硬币是否公平，而是不做任何假设，一直把硬币抛 100 次。结果正好是硬币有头的 50 倍，有尾的 50 倍。然后我们得出结论，通过设置 P(head)=0.5，将最大化这种数据模式出现的概率。
直观的说，而概率设置参数 fix，估计数据的概率，是可变的。在似然度中，我们设置数据修正，并改变参数，直到我们找到最佳参数，该参数提供生成这种数据集的最佳模型。
这就是为什么当我们处理概率和可能性时，它们会在函数中表现出相似的形式。但是用数学术语来说，它们具有完全不同的性质。
稍作停顿和总结，我们可以看到，在实践中，我们有一个固定参数的先验和一个参数完全由(1)我们选择的概率分布和(2)我们拟合到概率分布中的数据决定的可能性。
贝叶斯统计更棒的是，我们可以将一个离散(连续)先验乘以一个连续(离散)似然。我们在 prior 和 likelihood 中选择的概率分布可以是随机的，并根据我们的使用情况进行调整，这要归功于它们都有一个概率密度函数，我们可以用纸张或计算统计来相乘和求解。
说到解数学方程，让我们再来看看股票回报的例子。我们有一个单变量正态先验和一个单变量正态似然，当我们试图将它们的函数相乘时，实际上有一个很好的解，它是一个正态反卡方分布，均值和方差等于
【https://en.wikipedia.org/wiki/Conjugate_prior
如果我们访问维基百科，我们可以看到不同概率和可能性的不同可能组合的列表。以及我们如何能够使用不同的概率分布来模拟最终的后验概率。基本上，我们只需要使用 wiki 中显示的后验分布，并插入我们从可能性和先验中获得的参数值，就会生成作为后验分布的更新信念。这种技术被称为共轭先验。这将节省我们在纸上解决数学问题的大量时间。
但是共轭先验只能处理最基本的概率分布模型。如果我们有一个 100 多元的正态分布作为我们的先验呢？在这种情况下，不可能推导出后验概率的数学形式解。
在实践中，我们如何能够忽略贝叶斯公式的分母和分母的计算
事实证明，我们真的不需要在我们的命名符中计算乘法，也不需要计算分母。
因为我们有计算给定数据集(X = x1，x2 … xt)的先验和似然性所需的一切，所以我们可以从数据集(x1)中随机选取一个样本，计算似然性和先验值，并将它们相乘以生成随机样本后验密度。
作为一个提醒，我已经简单地提到了后验概率保证是一个概率分布(成熟的数学，老实说，我并不完全理解，但它是经过验证的)，因此当我们说计算后验概率时，我们指的是概率密度的计算，它描述了一个参数(例如股票回报的平均值)在给定数据集的情况下出现的可能性。
如果我们对可能性和先验无限量的时间进行采样，我们生成的后验密度值将形成真实后验概率分布的非常好的近似。
这种抽样技术被称为马尔可夫链蒙特卡罗 ( MCMC )方法。在 MCMC 上有几种实现，包括随机游走 metropolis 和哈密顿蒙特卡罗。类似于深度学习，其中某些激活功能通常优于其他功能。在 MCMC 中，已知无 U 形转弯采样器(从哈密尔顿蒙特卡罗得到)是最好的实现。
因此，MCMC 不会帮助我们解决贝叶斯统计中的所有问题，而只是在我们无法计算后验分布的情况下实现后验分布。为了有一个实际的用例，我们仍然需要确定先验和似然的概率分布，并自己拟合数据。
这实际上是使用贝叶斯统计的一个优势，我们通过显示我们选择的先验和似然概率分布，预先使我们的假设非常清楚，这些假设可以帮助我们更好地理解模型的不确定性。
更好的是，得到的后验分布是一个概率分布，这意味着我们可以尽可能地从字面上理解它，并得出某个事件在未来发生的概率很大的结论，而不是使用一些令人困惑的评估方法，如置信区间。
在 python 中，P ystan 和 PyMC 都旨在为我们运行 MCMC。我们唯一需要提供的是先验和似然函数，以及用于似然估计的先验参数和数据。
股票回报的全面检查
再次假设，我作为一名金融专家，知道在过去几年中，未来 12 个月的整体股市回报总是遵循均值等于 30%、方差等于 5%的正态分布。然而，对于 covid19，这一假设是不可靠的，我的同事是一名数据专家，他不同意我的观点，但温和地承认，我先前的观点对于估计 covid 情况稳定后未来 12 个月的股票回报是有用的。
我的同事花了几天时间收集银行和科技等不同行业的股票回报数据，他也使用正态分布来描述 covid 19 下的股票回报，均值等于 10%，方差也等于 10%。
使用共轭先验或 MCMC(假设我们有一个多元正态分布，它将股票收益进一步细分到每个部门，那么 MCMC 将是必要的)，我们能够计算后验概率分布。
我们可以看到，在 covid 情况稳定后，平均回报率约为 22–23%。
由于后验也是一种概率分布，我们可以根据给定的概率，对均值和方差的取值范围进行有根据的猜测。然后，你的团队老板可以考虑发生几率不同的情况，并为未来可能出现的负面风险做好准备。
我希望这可以很好地总结贝叶斯统计背后的直觉，以及为了在实践中使用它或详细研究它而需要做的所有准备工作。
如何进行主成分分析
巨大的知识给了我们超能力。
乔·考克在 1970 年的《疯狗和英国人现场》双张专辑的内折中，将此次巡演的音乐总监利昂·拉塞尔描述为“时空大师”那张照片给我留下了深刻的印象。
操纵数据让我觉得自己是时空大师。处理时序数据和多维数据框是对空间和时间的流畅处理。
降维是对空间和时间的终极操控。
你知道《传道书》中的那句话吗？太阳底下没有新事。机器学习和人工智能确实是天底下的新事物。
这些算法，加上个人电脑、云计算和对海量数据的访问，给了我们巨大的新力量。我们都离超级大国只有一段可以跨越的训练距离。
Grok 是科幻作家罗伯特·A·海因莱因在他 1961 年的小说《异乡客》中创造的一个词。它意味着凭直觉理解某事，并建立融洽关系。
有时障碍似乎势不可挡。在这篇文章中，我想分享我对流水线过程的一个部分的见解:主成分分析(PCA)。
PCA 是机器学习、人工智能和统计分析管道中的关键步骤。
PCA 对你来说是一个具有挑战性的课题。在这里，我描述了我灵光一现的时刻。
这篇文章不是一篇综述性技术文章；这是概念性的。一旦你有了背景知识，技术细节就更有意义了。
这里我用数量金融学作为一个应用来描述 PCA。主成分分析和降维是数量金融学的基础。
主成分分析在许多其他领域和领域中是至关重要的，在这些领域中，您试图使用已知数据来预测结果。希望这个概述对你有帮助。
一些因素解释了一个结果，我们试图找到它们。我们将这些因素建模为电子表格式矩阵中的行。为了操作它们，我们使用线性代数的向量和矩阵的数学。
在 Python 中，我们使用 Pandas 将这些数据集存储为数据帧和序列。我们使用线性代数的矩阵数学来处理熊猫的数据帧。
这些计算机文件的大小会变得很大，处理起来很麻烦。
为了使它们更易于管理，我们减小了尺寸。我们使用 PCA 来分析矩阵中的哪些向量对我们正在建模的结果贡献最大。
我们的目标是从过去的数据预测未来的结果。我们在噪音中寻找信号。我们从过去寻找对未来有预测力的信息。我们希望提取这些信息，并对其预测能力进行排名。
在 Unsplash 上由 Austin Distel 拍摄的照片
在量化金融中，我们要预测股票未来的价格走势。根据我们的因素进行投资。
我们称这些因素为阿尔法因素。
我们通过消除对预测能力贡献不大的因素向量来减少数据集的大小。
每行数据都是多维线性代数空间中的一个向量。有些向量增加了价值，有些向量是多余的或不重要的。我们的目标是降维。
PCA 是我们用来进行降维的工具。我们输入数据集和我们想要保留的预测能力。PCA 算法处理这些数字。它提供了一组按贡献大小排序的最有效的向量。
当我想到它像线性回归时，我第一次明白了 PCA 是如何工作的。线性回归需要两个变量，一个自变量和一个因变量。它会在所有数据点之间绘制一条最接近的直线。这是大量的迭代数字运算，但对计算机来说很容易快速完成。
线性回归直线拟合。
PCA 的工作原理类似。它绘制了前两个变量，并在它们之间拟合了一条线。
该 PCA 线与线性回归线具有不同的属性。PCA 不是针对距离进行优化，而是将点投影到直线上，并针对它们之间的距离进行优化。这个距离就是方差。
我们使用散点图来绘制所有点，并直观地估计直线可能如何倾斜。
这条线有一个斜率，就像线性回归一样。
这条新线然后成为新坐标系的 X 轴。然后 PCA 查看下一个变量，并将其绘制成与新计算的 X 轴正交(垂直)。第二次迭代成为新的 Y 轴。它运行相同的优化，并沿 Y 轴投影这些点。
散点图的 PCA 直线拟合。
对我来说，那是“啊哈”的一刻。我意识到这是一种旋转，基于通过数据创建一条线，就像线性回归一样。
X 轴和 Y 轴的旋转表示空间的变换坐标系。这个变换表示一组数字，将原始空间的 x 和 y 分量转换到这个变换后的空间。这个转换的空间是为这个特定的数据集优化和定制的。
散点图中的点仍在同一位置。但是我们用来标识它们位置的数字现在需要在新的坐标系中表示。
平移的数字和过程，以及它们所代表的向量，称为特征向量和特征值。
在运行 PCA 之前，需要对数据进行归一化处理。归一化是减去两个变量的平均值，使数据位于原点(0，0)附近。这是特征向量的标准，原点保持不变。
帮助你掌握线性代数和特征向量的一系列精彩视频是 3Blue1Brown。
强烈推荐按顺序看剧集。
PCA 遍历所有的数据向量，并将它们作为多维空间中的额外维度进行绘制。主成分分析给出了排名和有多少向量贡献。然后，您可以在进行因子分析时校准要使用的数量。
L 让我们更详细地探讨一下旋转在概念上代表了什么，以及这对执行 PCA 的数据科学家来说意味着什么。
自动减少数据集列数的方法称为降维。最流行的方法之一是主成分分析或简称 PCA。
数据科学中的 PCA 是流水线中的一个处理步骤。我们希望降低数据集的复杂性，为以后在管道中执行的过程做准备。
PCA 是一种降维技术，可以将高维向量映射到低维空间。
我们希望在保留信息含义的同时降低复杂性。在主成分分析的情况下，信息以方差的形式出现:数据变化的程度。降低复杂性也降低了聚合错误的脆弱性。
一个数据集可以有数百、数千或更多的列和行。每一列或每一行都可以是一个特征。一些特征在它们对目标的预测能力方面比其他特征更相关。
PCA 处理的矩阵也可以是优化约束的一部分。
从包含不相关特征的数据中构建的模型既麻烦又容易出现累积误差。这些模型也容易过度拟合训练数据。与根据最相关的数据训练的模型相比，它们的构造很差。
随着矩阵中元素的增加，矩阵中要计算的数量呈指数增长。
例如，3000 维的矩阵有大约 450 万个元素要计算和跟踪。一个 70 的矩阵大约有 2500 个量要估计。规模差别很大，引入估计误差的机会要少得多。
PCA 是降低数据集、模型和训练复杂性的优化过程。
诀窍是找出数据的哪些特征是相关的，哪些是不相关的。
主成分分析将数据压缩成保留数据核心信息的格式。核心信息是原始数据在其列或行之间的差异。
PCA 是一系列的计算，为我们的数据集提供了一个新的独特的基础。
那么它为什么是独一无二的呢？
PCA 计算新维度，并根据其差异内容对其进行排序。
第一个维度是数据点最分散的维度。数据点在这个维度上的差异最大。
那到底是什么意思？
PCA 在 2D 平面上创建一个新的轴。PCA 计算我们的数据点沿着这个新轴的坐标。它通过将它们以最短的路径投影到新轴来实现这一点。
PCA 以这样的方式选择新的轴，使得新的坐标尽可能地展开。它们有最大方差。坐标扩展最多的线也是最小化每个坐标到新轴的垂直距离的线。
该基础使重建误差最小化。最大化方差和最小化重构误差是密切相关的。
翻译使用勾股定理。
从原点到投影的距离的平方加上从投影到点的距离的平方等于从原点到点的距离的平方。
提取，血统
PCA 提取由数据中的方差表示的模式，并执行维数缩减。PCA 方法的核心是来自线性代数的矩阵分解方法，称为特征分解。
假设我们有一个包含 1000 列的数据集。换句话说，我们的数据集有 1000 个维度。我们需要这么多维度来捕捉数据集的方差吗？大多数时候，我们不会。
我们需要一种快速简单的方法来移除对方差没有贡献的特征。使用 PCA，我们可以在更少数量的转换维度中捕获 1000 个维度的数据的本质。
差异
由列或行表示的 1000 个特征中的每一个都包含一定量的差异。有些值高于平均值，有些值低于平均值。
随着时间的推移保持不变的特性无法提供洞察力或预测能力。
一个特性包含的差异越多，这个特性就越重要。该特征包括更多的“信息”。方差表示特定要素的值在整个数据中如何变化。PCA 根据特征的变化量对特征进行排序。
主成分
现在我们知道了方差，我们需要找到一个能够更有效地解释方差的转换后的特征集。PCA 使用原始的 1000 个特征进行线性组合，将方差提取为新的特征。这些变换后的特征是主成分(PCs)。
主成分与原始特征无关。转换后的特征集或主成分具有第一个 PC 中解释的最显著的变化。第二台 PC 将具有第二高的方差，依此类推。
主成分分析有助于您了解数据中是否有一小部分可以解释大部分的数据观察结果。
例如，第一个 PC 解释了数据中总方差的 60%，第二个特征解释了 25%，接下来的四个特征包含 13%的方差。在这种情况下，98%的方差仅由 6 个主成分定义。
假设接下来的 100 个特征总共解释了总方差的另外 1%。为了增加百分之一的方差而增加 100 个维度是没有意义的。通过取前 6 个主成分，我们将维数从 100 减少到 6。
PCA 按照主成分解释的方差的顺序排列主成分。我们可以选择顶部的成分来解释一个足够值的方差比。您可以选择电平作为 PCA 发生器的输入。
主成分分析能让你深入了解数据集中的差异是如何分布的。PCA 创建了简化的数据集，该数据集在矩阵数学计算中更容易处理以进行优化。PCA 在定量金融中用于建立风险因素模型。
降低维度可以减少可能聚集的误差项的影响。PCA 还通过消除多余的特征来解决过拟合问题。如果您的模型是过度拟合的数据，它将在测试数据上工作良好，但在新数据上表现不佳。PCA 有助于解决这个问题。
结论
PCA 是一种特征提取技术。它是特征工程的一个组成部分。
我们正在寻找更好的模型，具有更强的预测能力，但地图并不是我们的领域。我们正在创造一种失去了一些原始保真度的抽象。诀窍是使 PC 矩阵尽可能简单，但不能更简单。
预测是我们努力渐近接近的一种理想。我们无法达到完美。如果我们努力追求完美，我们就能达到卓越。
Python 内置了 PCA。
Python 的一个很棒的特性，如果你需要更多的东西来证明它是一种强大的数据科学语言，那就是它在 Scikit-learn 中有一个易于使用的 PCA 引擎。Scikit-learn 是一个免费的 Python 软件机器学习库。从 Scikit 导入 PCA 了解并试用它！
PCA 是机器学习中的一个重要工具和组件。我希望这有助于使它更容易成为您的工具包的一部分。
Python 熊猫里如何按时间间隔分组数据？
一行程序将时间序列数据组合成不同的时间间隔，例如基于每小时、每周或每月。
如果你曾经处理过时间序列数据分析，你肯定会遇到这些问题
- 将数据组合成特定的间隔，如基于每天、一周或一个月。
- 聚合时间间隔内的数据，例如，如果您正在处理价格数据，那么问题就像一小时或一天内添加的总量。
- 基于时间间隔查找数据集中其他要素的模式。
在本文中，您将了解如何使用两个不同的 Pandas API，即 resample()和 Grouper()，通过一行代码解决这些问题。
众所周知，学习一件东西的最好方法是开始应用它。因此，我将使用由世界银行公开数据提供的样本时间序列数据集，并与从 15 个国家收集的众包价格数据相关。有关数据的更多详情，请参考众包价格数据收集试点。在本练习中，我们将使用为阿根廷收集的数据。
📚资源: Google Colab 实现 | Github 仓库 | 数据集📚
数据集详细信息
这些数据是由参与世界银行 2015 年调查的不同参与者收集的。调查的基本想法是收集不同国家不同商品和服务的价格。出于演示目的，我们将只使用数据集中的几列——
按作者分类的数据集示例片段。
基于不同的时间间隔组合数据。
Pandas 提供了一个名为 resample() 的 API，可以用来将数据重采样到不同的区间。让我们来看几个例子，看看我们如何使用它—
每小时添加的总量。
假设我们需要知道一个贡献者在一个小时内增加了多少，我们可以简单地使用——
# data re-sampled based on an hour
data.resample('H', on='created_at').price.sum()# output
created_at
2015-12-14 18:00:00 5449.90
2015-12-14 19:00:00 15.98
2015-12-14 20:00:00 66.98
2015-12-14 21:00:00 0.00
2015-12-14 22:00:00 0.00
这是我们正在做的事情—
- 首先，我们为日期列(即 created_at)将数据重新采样为一个小时“H”频率。我们可以使用不同的频率，我将在本文中介绍其中几种。查看熊猫时间频率获得完整的频率列表。甚至可以达到纳秒。
- 之后，我们从重新采样的数据中选择“价格”。稍后，我们将看到如何在一个命令中聚合多个字段，即总金额、数量和唯一的项目数。
- 计算所有价格的总和。这将给出该小时内添加的总量。
默认情况下，时间间隔从一个小时的第 0 分钟开始，如 18:00、19:00 等。我们可以改变它，从一个小时的不同分钟开始，使用偏移量属性，比如—
# Starting at 15 minutes 10 seconds for each hour
data.resample('H', on='created_at', offset='15Min10s').price.sum()# Output
created_at
2015-12-14 17:15:10 5370.00
2015-12-14 18:15:10 79.90
2015-12-14 19:15:10 64.56
2015-12-14 20:15:10 18.40
2015-12-14 21:15:10 0.00
请注意，您需要 Pandas 版本大于 1.10 才能使用上述命令。
每周添加的总量。
在本例中，我们将了解如何基于每周对数据进行重新采样。
# data re-sampled based on an each week, just change the frequency
data.resample('W', on='created_at').price.sum()# output
created_at
2015-12-20 4.305638e+04
2015-12-27 6.733851e+04
2016-01-03 4.443459e+04
2016-01-10 1.822236e+04
2016-01-17 1.908385e+05
默认情况下，一周从周日开始，我们可以将其更改为从不同的日期开始，也就是说，如果我们希望基于从周一开始的一周进行合并，我们可以使用—
# data re-sampled based on an each week, week starting Monday
data.resample('W-MON', on='created_at').price.sum()# output
created_at
2015-12-14 5.532860e+03
2015-12-21 3.850762e+04
2015-12-28 6.686329e+04
2016-01-04 5.392410e+04
2016-01-11 1.260869e+04
每月添加的总量。
这类似于我们在前面的例子中所做的。
# data re-sampled based on each month
data.resample('M', on='created_at').price.sum()# Output
created_at
2015-12-31 1.538769e+05
2016-01-31 4.297143e+05
2016-02-29 9.352684e+05
2016-03-31 7.425185e+06
2016-04-30 1.384351e+07
此处需要注意的一点是，每个月的输出标签基于该月的最后一天，我们可以使用“MS”频率从该月的第一天开始，即不是 2015-12-31，而是 2015-12-01-
# month frequency from start of the month
data.resample('MS', on='created_at').price.sum()created_at
2015-12-01 1.538769e+05
2016-01-01 4.297143e+05
2016-02-01 9.352684e+05
2016-03-01 7.425185e+06
2016-04-01 1.384351e+07
采样数据的多重聚合。
通常我们需要在不同的列上应用不同的聚合，就像在我们的例子中，我们可能需要找到—
- 每小时添加的独特项目。
- 每小时添加的总量。
- 每小时添加的总量。
我们可以通过对重采样的数据使用 agg()在一行中实现这一点。让我们看看我们如何做到这一点—
# aggregating multiple fields for each hour
data.resample('H', on='created_at').agg({'price':'sum', 'quantity':'sum','item_code':'nunique'})
基于作者每小时的汇总数据。
基于不同的时间间隔对数据进行分组
在上述示例中，我们对数据进行了重新采样，并对其应用了聚合。如果除了时间间隔之外，我们还想按其他字段对数据进行分组，该怎么办？熊猫提供了一个名为 grouper() 的 API，可以帮助我们做到这一点。
在本节中，我们将了解如何对不同字段的数据进行分组，并在不同的时间间隔内对其进行分析。
每月每种店铺类型的新增金额。
假设我们需要根据每月的商店类型来分析数据，我们可以使用—
# Grouping data based on month and store type
data.groupby([pd.Grouper(key='created_at', freq='M'), 'store_type']).price.sum().head(15)# Output
created_at store_type
2015-12-31 other 34300.00
public_semi_public_service 833.90
small_medium_shop 2484.23
specialized_shop 107086.00
2016-01-31 market 473.75
other 314741.00
private_service_provider 325.00
public_semi_public_service 276.79
small_medium_shop 31042.79
specialized_shop 29648.44
2016-02-29 market 1974.04
other 527950.00
private_service_provider 1620.00
public_semi_public_service 1028.52
small_medium_shop 224653.83
让我们来理解我是如何做到的—
- 首先，我们将 Grouper 对象作为 groupby 语句的一部分进行传递，该语句根据月份(即“M”频率)对数据进行分组。这类似于 resample()，所以我们上面讨论的内容在这里也适用。
- 我们将 store_type 添加到 groupby 中，这样每个月我们都可以看到不同的商店类型。
- 对于每个组，我们选择价格，计算总和，并选择前 15 行。
每月根据 item_name 添加的总金额。
正如我们在上一个示例中所做的那样，我们也可以对 item_name 做类似的事情。
# Grouping data based on each month and item_name
data.groupby([pd.Grouper(key='created_at', freq='M'), 'item_name']).price.sum()# Output
created_at item_name
2015-12-31 Bar soap, solid, SB 33.17
Beer, domestic brand, single bottle, WKB 29.79
Black tea, BL 12.00
Black tea, in bags, WKB 60.99
Bread, white, sliced, WKB 85.45
...
2016-08-31 Wheat flour, not self-rising, BL 150.38
White sugar, WKB 266.47
Women's haircut, basic hairdresser 7730.00
Wrist-watch, men's, CITIZEN Eco-Drive BM6060 52205.00
Yoghurt, plain, WKB 150.96
每月 store_type 的多重聚合。
我们可以像使用 resample()那样在多个字段上应用聚合。这里唯一不同的是，数据也将按 store_type 分组，而且，我们可以对 groupby 对象进行命名聚合(为每个聚合分配一个名称),这不适用于重新采样。
# grouping data and named aggregation on item_code, quantity, and price
data.groupby([pd.Grouper(key='created_at', freq='M'), 'store_type']).agg(unique_items=('item_code', 'nunique'),
total_quantity=('quantity','sum'),
total_amount=('price','sum'))
按作者基于不同字段的汇总数据
结论
我希望这篇文章能帮助你节省分析时间序列数据的时间。我建议你查看一下关于重采样()和群组() API 的文档，了解你可以用它们做的其他事情。
如果你想了解其他可以帮助你完成数据分析任务的熊猫应用编程接口，请查看文章熊猫:收起新手数据分析师状态，在那里我解释了你可以用熊猫做的不同事情。
如果你在使用熊猫或数据分析时遇到任何问题，请在评论中告诉我，或在 LinkedIn 上 ping 我。我们可以试着一起解决。目前就这些了，下篇文章再见。
干杯！！！注意安全！！！继续学习！！！
如何指导:在 Kubernetes 上建立、管理和监控 Spark
带有代码示例
在 2020 Spark + AI 峰会上，我们提出了一个关于在 Kubernetes (K8s) 上运行 Apache Spark 的最佳实践和陷阱的会议。
在本帖中，我们将对该演示进行扩展，并与您讨论:
- 什么是 Kubernetes？
- 为什么要在 Kubernetes 上运行 Spark？
- Kubernetes 上的 Spark 入门
- 优化性能和成本
- 在 Kubernetes 上监控您的 Spark 应用
- Kubernetes 上的 Spark 现已上市(更新:2021 年 3 月
如果你已经熟悉 k8s 以及为什么 Kubernetes 上的 Spark 可能适合你，请随意跳过前几个部分，直接进入帖子的核心部分！
什么是 Kubernetes (k8s)？
Kubernetes (也称为 Kube 或 k8s)是一个开源的容器编排系统，最初由谷歌开发，于 2014 年开源，由云计算原生计算基金会维护。Kubernetes 用于自动化容器化应用的部署、扩展和管理——最常见的是 Docker 容器。
它提供了许多对稳定性、安全性、性能和可扩展性至关重要的功能，例如:
- 水平可扩展性
- 自动化推出和回滚
- 负载平衡
- 机密和配置管理
- …还有更多
Kubernetes 已经成为传统软件开发领域基础设施管理的标准。但是 Kubernetes 在大数据领域并不那么受欢迎，因为大数据领域经常被像 Hadoop YARN 这样的老技术所困扰。直到 Spark-on-Kubernetes 加入游戏！
为什么要在 Kubernetes 上打火？
当 Apache Spark 2.3 中增加了对 Kubernetes 上原生运行 Spark 的支持时，许多公司决定改用它。这种流行的主要原因包括:
- 本地集装箱化和码头支持。
- 能够在彼此完全隔离的情况下运行 Spark 应用程序(例如，在不同的 Spark 版本上)，同时享受共享基础架构的成本效益。
- 将您的整个技术基础设施统一在一个与云无关的工具下(如果您已经将 Kubernetes 用于您的非 Spark 工作负载)。
最重要的是，与 YARN 相比，在 Kubernetes 上运行没有设置损失(如基准测试所示)，Spark 3.0 为 Spark-on-Kubernetes 带来了许多额外的改进，如支持动态分配。自Spark 3.1(2021 年 3 月)以来，Kubernetes 上的 Spark 已被正式宣布为正式上市和生产就绪！
阅读我们之前关于在 Kubernetes 上运行 Spark 的利弊的帖子，了解关于这个主题的更多细节以及与主要替代方案的比较。
Kubernetes 上的 Spark 入门
架构:当你提交一个 Spark 应用到 Kubernetes 时会发生什么
您通过直接与 Kubernetes(确切地说是主节点上的 Kubernetes API 服务器)对话来提交 Spark 应用程序，然后 Kubernetes API 服务器将为 Spark 驱动程序安排一个 pod(简单地说，一个容器)。一旦 Spark 驱动程序启动，它将直接与 Kubernetes 通信来请求 Spark 执行器，这也将在 pod 上进行调度(每个执行器一个 pod)。如果启用了动态分配，Spark 执行器的数量会根据负载动态变化，否则它是一个静态数字。
Kubernetes 参考架构上的 Apache Spark。图片作者。
如何提交申请:spark-submit 与 spark-operator
这是你需要尽早做的一个高层次的选择。向 Kubernetes 提交 Spark 应用程序有两种方式:
- 使用 spark 附带的 spark-submit 方法。Spark 应用程序的进一步操作将需要直接与 Kubernetes pod 对象进行交互
- 使用火花操作器。这个项目是由 GCP 开发的(并且是开源的)，但是它在任何地方都可以工作。它需要在集群上运行一个(单个)pod，但会将 Spark 应用程序转变为自定义 Kubernetes 资源，可以像其他 Kubernetes 对象一样对其进行定义、配置和描述。它增加了其他细节，比如支持直接从 Spark 应用程序配置中挂载配置图和卷。
Spark 提交与 Kubernetes 运营商应用管理上的 Spark。图片作者。
我们建议使用 spark-operator，因为它更容易使用。
设置清单
根据您当前的基础架构和云提供商(或内部设置)，以下步骤会有所不同。但是在高层次上，这里是你完全自己开始使用 Kubernetes 上的 Spark 所需要设置的主要内容:
- 创建一个 Kubernetes 集群
- 根据您的工作负载要求定义您想要的节点池
- 根据您的网络需求加强安全性(我们建议将 Kubernetes 集群设为私有)
- 为您的 Spark docker 映像创建 docker 注册表，并开始构建您自己的映像(更新:截至 2021 年 4 月，我们已经公开发布了我们针对 Spark 优化的 docker 映像。
- 安装火花操作器
- 安装 Kubernetes 集群自动缩放器
- 将 Spark 驱动程序日志和 Spark 事件日志的集合设置到永久存储器中
- 安装 Spark 历史服务器(掌舵图，或者使用我们的开源监控工具 Delight 。
- 设置节点和火花指标(CPU、内存、I/O、磁盘)的收集
如您所见，如果您在内部完成这项工作，这需要做大量的工作，并且需要维护大量移动的开源项目。
这就是我们构建托管 Spark 平台(数据机制)的原因，目的是让 Kubernetes 上的 Spark 尽可能地简单易用。我们的平台负责这一设置，并提供额外的集成(如 Jupyter、Airflow、IDEs)以及强大的优化，以使您的 Spark 应用程序更快，并降低您的云成本。
优化性能和成本
尽可能使用固态硬盘或大磁盘，以获得 Spark-on-Kubernetes 的最佳洗牌性能
洗牌是 Spark 中经常出现的昂贵的全对全数据交换步骤。它们会占据你整个 Spark 工作的很大一部分，因此优化 Spark shuffle 性能很重要。我们已经在我们的 YARN vs Kubernetes 性能指标评测文章(阅读“如何在 Kubernetes 上使用 Spark 优化 shuffle”)中讨论了这个主题，所以我们在这里只给出我们的高级技巧:
- 尽可能使用本地 SSD 磁盘
- 当它们不可用时，增加磁盘的大小以提高其带宽
优化您的火花舱尺寸，以避免浪费容量
我们来看一个例子。假设:
- 您的 Kubernetes 节点有 4 个 CPU
- 您想在每个 Kubernetes 节点上安装一个 Spark executor pod
然后，您将提交配置为Spark . executor . cores = 4的 Spark 应用程序，对吗？不对。你的 Spark app 会卡死，因为 executors 装不下你的节点。您应该考虑下图中描述的开销。
来自 Kubernetes 和 Daemonsets 的 Apache Spark 节点的开销。图片作者。
通常，可分配的节点表示 95%的节点容量。为daemonset保留的资源取决于您的设置，但是请注意，daemonset 在日志和指标收集、网络和安全性方面很受欢迎。让我们假设这为您的 Spark 执行器留下了 90%的可用节点容量，即 3.6 个 CPU。
这意味着您可以使用配置Spark . executor . cores = 3提交 Spark 应用程序。但是这将仅保留 3 个 CPU，并且会浪费一些容量。
因此，在这种情况下，我们建议采用以下配置:
spark . executor . cores = 4
spark . kubernetes . executor . request . cores = 3600m
这意味着您的 Spark 执行器将请求正好 3.6 个可用的 CPU，Spark 将在这个执行器上并行调度多达 4 个任务。
高级提示:
将 spark.executor.cores 设置为比spark . kubernetes . executor . request . cores大 2 倍(通常为2 倍或 3 倍)称为超额预订，可以显著提升 CPU 使用率较低的工作负载的性能。
在这个例子中，我们已经向您展示了如何调整 Spark executor pods 的大小，使它们紧密地适合您的节点(每个节点一个 pod)。公司还通常选择使用更大的节点，并在每个节点上安装多个 pod。在这种情况下，您仍然应该关注 Spark CPU 和内存请求，以确保节点上执行器的装箱是高效的。这是由数据机制平台提供的动态优化之一。
支持应用级动态分配和集群级自动扩展
如果您在云中运行，并且希望让您的数据基础架构具有反应能力和成本效益，这是绝对必要的。有两个级别动态缩放:
- App 级动态分配。这是每个 Spark 应用程序在运行时请求 Spark 执行器(当有未决任务时)和删除它们(当它们空闲时)的能力。从 Spark 3.0 开始，通过设置以下配置，动态分配在 Kubernetes 上可用:
- spark . dynamic allocation . enabled = true
spark . dynamic allocation . shuffle tracking . enabled = true - 集群级自动伸缩。这意味着当 Kubernetes 集群需要更多的容量来调度 pods 时，它可以向云提供商请求更多的节点，反之亦然，当节点变得不可用时，就将其删除。
针对 Apache Spark 的 Kubernetes 集群动态分配和自动缩放。图片作者。
这两项设置将使您的整个数据基础设施在 Spark 应用能够从新资源中受益时动态扩展，并在这些资源未被使用时缩减规模。实际上，当集群中有容量时，启动 Spark pod 只需要几秒钟。如果必须首先从云提供商处获取新节点，您通常需要等待 1-2 分钟(取决于云提供商、地区和实例类型)。
如果您想保证您的应用程序总是在几秒钟内启动，您可以通过在 Kubernetes 集群上安排所谓的“暂停单元”来增加集群的规模。这些是低优先级的吊舱，基本上什么也不做。当 Spark 应用程序需要空间来运行时，Kubernetes 将删除这些优先级较低的 pods，然后重新安排它们(导致集群在后台扩大规模)。
应用级动态分配和集群级自动扩展的说明。图片作者。
使用点节点降低云成本
Spot(也称为 preemptible)节点的成本通常比随需应变的机器低 75%左右，换来的是较低的可用性(当您请求 Spot 节点时，不保证您会得到它们)和不可预测的中断(这些节点可能随时消失)。
Spark 工作负载在 spot 节点上工作得非常好，只要您确保只有 Spark 执行器被放置在 spot 上，而 Spark 驱动程序在按需机器上运行。事实上，Spark 可以从失去执行器(一个新的执行器将被放置在一个按需节点上，并重新运行丢失的计算)中恢复，但不能从失去驱动程序中恢复。
要在 Kubernetes 中启用 spot 节点，您应该创建多个节点池(一些是按需节点，一些是 spot 节点)，然后使用节点选择器和节点关联将驱动程序放在按需节点上，执行器最好放在 spot 节点上。
在 Kubernetes 上监控您的 Spark 应用
使用 Kubernetes 仪表板监控 pod 资源使用情况
Kubernetes 仪表板是一个开源的基于 web 的通用监控 UI。它将为您提供集群上运行的应用的可见性，以及对其性能进行故障排除的基本指标，如内存使用、CPU 利用率、I/O、磁盘等。
Kubernetes 仪表板上的 Pod 资源使用监控。来源: Kubernetes.io
这个项目的主要问题是，将这些指标与实际的 Spark 工作/阶段协调起来很麻烦，而且当 Spark 应用程序结束时，这些指标中的大部分都会丢失。保持这些指标有点挑战性，但也是可能的，例如使用普罗米修斯(从 Spark 3.0 开始内置 servlet)或 InfluxDB 。
如何访问 Spark 用户界面
Spark UI 是 Spark 内置的重要监控工具。无论应用程序是否是实时的，访问它的方式都是不同的:
- 当应用程序运行时，Spark UI 由 Spark 驱动程序直接在端口 4040 上提供服务。要访问它，您应该通过运行以下命令port-forward:
$ ku bectl port-forward4040:4040
然后您可以在 http://localhost:4040/ 打开 Spark UI - 当应用程序完成时，您可以通过运行 Spark 历史服务器并将其配置为从持久存储中读取 Spark 事件日志来重放 Spark UI。你应该首先使用配置spark . event log . dir将这些事件日志写到你选择的存储后端。然后，您应该按照这个文档从一个 Helm 图表安装 Spark 历史服务器，并将其指向您的存储后端。
Spark UI 的主要问题是很难找到您正在寻找的信息，并且它缺乏以前工具的系统指标(CPU、内存、IO 使用)。
数据力学用户界面概述。图片作者。
更新:
- 截至 2020 年 11 月，我们已经发布了一个免费的、托管的、跨平台的 Spark 历史服务器。这比自己托管 Spark 历史服务器更简单！
- 截至 2021 年 4 月，这个免费的监控工具 Delight 还显示了你的 Spark 作业&阶段之上的 CPU &内存指标。查看我们的博客文章 & github 页面了解更多信息。
Kubernetes 上的 Spark 现已正式发布(Spark 3.1 更新)
自 2021 年 3 月和 Apache Spark 3.1 发布以来，Kubernetes 上的 Spark 已被正式宣布为生产就绪和正式可用。
最令人兴奋的功能是 Spark 能够预测执行程序点杀(通过收听云提供商提前发出的终止通知),并将 shuffle 文件和缓存数据从即将死亡的执行程序迁移到将存活的执行程序。该功能被称为【SPARK-20624】更好地处理节点关闭。并且在下面的 GIF 中有图解。
优雅的节点退役 Spark 3.1 的一个新特性，使 Apache Spark 对定点清除更加健壮。目前仅在 Kubernetes &独立模式下可用。
第二个主要改进是能够在 Kubernetes(一个网络支持的存储，可以由所有 Spark 应用程序共享，并预先填充数据)中装载共享的 NFS 卷，以及动态提供 PersistentVolumeClaims(而不是静态)的能力，如果您试图在启用动态分配的情况下运行 Spark 应用程序，这尤其有用。
查看我们关于 Spark 3.1 发布的博客文章以深入了解这些改进，并对 Spark 3.1 的新特性进行概述。
结论
我们希望这篇文章能让你对 Spark-on-Kubernetes 以及如何成功使用它有所了解。
如果您想以最简单的方式开始使用 Spark-on-Kubernetes，与我们预约时间，我们的数据力学团队将非常乐意帮助您交付您的用例。如果你想更好地了解我们的平台与 Spark-on-Kubernetes 开源平台相比如何，查看这篇文章。
这篇文章的最初版本发表在数据力学博客上
机器学习中如何处理循环数据
不要一次性编码日期信息。改为这样做。
今天，我们将探讨数据科学中一个常见但鲜为人知的话题——周期性数据。它是许多数据集的一部分，很容易被发现——日期信息是最常见的形式。有很多方法可以将日期信息编码成机器学习友好的东西，但有些方法比其他方法更好。
以下是我被教导如何处理日期值的方法— 将它们视为分类。不同的月/日/小时可以被视为单独的类别，因此为了对它们进行编码，可以创建一组虚拟变量。例如，在处理月度数据时，我们可以创建 11 个虚拟列(one-hot)，它们采用Is_January、Is_February等形式，其中一行中只有一列可以有非零值。
那就不对了。
当然，你可以这样做，机器学习模型不会抱怨，但这并不意味着这是正确的方法。时间数据是循环的，一小时有 60 分钟，一天有 24 小时。当一个小时结束时，下一个小时开始从零开始计时。
它使一个小时的第 1 分钟和第 2 分钟紧密相连，但也使第 59 分钟和第 1 分钟相连，因为只有一分钟的差异，而不是模型假设的 59。
这就是我们想要的行为。下一节将使前面的观点更加清楚。
数据集介绍和加载
我们需要一个带有日期或其他循环属性的数据集——这是显而易见的。快速的 Kaggle 搜索产生了这个小时能耗数据集，我们将使用其中的第一个AEP_hourly.csv文件。它有几兆的大小，所以把它下载到你的机器上。
一旦加载了Pandas，前几行看起来是这样的:
import pandas as pd
df = pd.read_csv('data/AEP_hourly.csv.zip')
df.head()
很好——我们有一些日期信息，但它是实际的日期还是字符串？
df.dtypes
果然不出所料，所以我们来做个换算。我们还将从日期中提取小时信息，因为这是我们要处理的内容。
df['Datetime'] = pd.to_datetime(df['Datetime'])
df['Hour'] = df['Datetime'].dt.hour
df.head()
现在情况好多了。让我们分离出上周的数据(最后 168 条记录),来形象化地说明为什么一次性编码不是一件好事情。
last_week = df.iloc[-168:]
import matplotlib.pyplot as plt
plt.title('Individual hours', size=20)
plt.plot(range(len(last_week)), last_week['Hour'])
预期行为。这是一个重复七次(7 天)的循环，在第 23 个小时之后每天都有一个粗略的切断。我认为您可以很容易地推理出为什么这种类型的行为对于周期性数据不是最佳的。
但是我们能做些什么呢？幸运的是，很多。
编码循环数据
在这种情况下，一键编码不是明智之举。我们最终会得到 23 个附加属性(n-1)，这很糟糕，原因有二:
- 维度的巨大跳跃——从 2 到 24
- 属性之间没有连通性-23 小时不知道它后面是 0 小时
那么，我们能做什么呢？
使用正弦和余弦变换。以下是我们将使用的公式:
或者，在 Python 中:
import numpy as np last_week['Sin_Hour'] = np.sin(2 * np.pi * last_week['Hour'] / max(last_week['Hour'])) last_week['Cos_Hour'] = np.cos(2 * np.pi * last_week['Hour'] / max(last_week['Hour']))
厉害！以下是上周的数据:
这些转换使我们能够以更有意义和简洁的方式来表示时间数据。看一下最后两行。正弦值几乎相同，但仍有一点不同。这同样适用于接下来的每一个小时，因为它现在遵循一个波形。
太好了，但是为什么我们需要这两种功能呢？
在我给你答案之前，让我们先用图形来研究一下这些函数。
一次看一张图。有一个问题。这些值重复。看看正弦函数，在 x 轴的 24 到 48 之间。如果你要画一条直线，它将与同一天的两个点相交。这不是我们想要的行为。
为了进一步证明这一点，如果我们绘制正弦和余弦柱的散点图，会发生以下情况:
没错；我们得到了一个完美的循环。只有用周期来表示周期性数据才有意义，你不同意吗？
你应该知道的就这些。让我们在下一部分总结一下。
在你走之前
这是一篇相对简短且切中要点的文章，但是我仍然希望我能够让您相信一键编码并不是所有问题的解决方案。当然，当分类属性不以任何方式“连接”时，它就像一种魅力，但这是任何周期性数据的首选方法。
有人可能会说我们引入了两个新的维度，这并不理想。我同意，但是 2 比 23 好，23 是一次性编码方法的结果。
感谢阅读。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
原载于 2020 年 10 月 12 日【https://betterdatascience.com】。
如何处理 ML 中的不平衡数据和小训练集
不平衡数据是指每个类的观察值数量分布不均，通常有一个主要类占数据集的比例较大，而次要类没有足够的示例。
按作者分类的图表
小的训练集也苦于没有足够的例子。这两个问题在现实应用中非常普遍，但幸运的是有几种方法可以克服这个问题。本文将通过许多不同的技术和视角来应对不平衡数据。特别是，您将了解到:
- 采样技术(上采样和下采样)
- 加权损失
- 数据扩充技术
- 迁移学习
不平衡的数据如何影响你的模型？
不平衡数据是数据科学中常见的问题。从图像分类到欺诈检测或医疗诊断，数据科学家面临不平衡的数据集。不平衡的数据集会降低模型对少数类的敏感度。让我们用简单的数学来解释一下:
想象一下，你有 10000 张肺部 x 光图像，其中只有 100 张被诊断为肺炎，这是一种传染病，会使一个或两个肺部的气囊发炎，并使它们充满液体。如果你训练一个模型，预测每个例子都是健康的，你会得到 99%的准确率。哇，多棒啊？错了，你刚刚用你的模型杀了很多人。
作者图片
通常，我们通过准确性来衡量模型的表现，但是不平衡的数据会误导我们，就像上面的例子一样。这篇文章的重点是如何处理这些情况，我不会详细介绍如何衡量您的模型，但请记住，要将衡量指标从准确性改为精确度、召回、F1 分数。但是即使他们实际上也没有那么伟大。在处理不平衡数据时，我建议选择: AUC 曲线、 平均精度。这是一个令人惊叹的 github 知识库，它通过谈论一个特定的不平衡数据集示例来深入研究这些指标的细节:信用卡欺诈。
比方说，我们有一个不平衡的数据集，我们无法访问更多的数据。所以我们应该创建自己的数据。下一章将在高抽象层次上介绍这些技术，我还添加了一些用 Python 实现这些技术的参考资料。
取样技术
您可以通过重采样来平衡数据。以下是两种不同的重采样技术:
- 向上采样(增加你的少数类)
- 向下采样(减少多数类)
对于这两者，我们将使用 Sklearn 重采样函数。让我们导入库并将我们的数据定义为df:
# Importing the libraries
import numpy as np
import pandas as pd
from sklearn.utils import resample# Importing the dataset
# Read dataset
df= pd.read_csv('data.csv')
在本例中，我们有一个二元分类问题，其中多数类表示为 1，少数类表示为 0。让我们把它们分开:
# Separate majority and minority classes
df_majority = df[df.iloc[:,4608]==1]
df_minority = df[df.iloc[:,4608]==0]
我们可以对多数类进行下采样，对少数类进行上采样，或者两者兼而有之。你应该试一试，看看哪一款最适合你。您可以调整的另一个超参数是n_samples，它是您重新采样的样本数。
# Separate majority and minority classes
df_majority = df[df.iloc[:,4608]==1]
df_minority = df[df.iloc[:,4608]==0]
# Downsample majority class
df_majority_downsampled = resample(df_majority,
replace=False,
n_samples=1000)#Upsample minority class
df_minority_upsampled = resample(df_minority,
replace=True,
n_samples=1000)# Combine minority class with downsampled majority class
df_up_down_sampled = pd.concat([df_majority_downsampled, df_minority_upsampled])
最后显示新的班级人数:
df_downsampled.prediction.value_counts()
恭喜你，你给权力带来了平衡。🎉
编辑:我最近被问到的一个面试问题: 你如何确保你的上采样&下采样数据来自良好的分布/你如何衡量这些方法的性能？
衡量这些方法性能的一个简单方法是获取用这些额外数据训练的新模型的测试结果。大多数情况下，进行上采样时，您可能会先看到性能有所提高，然后趋于平稳，甚至有所下降。我会选择数量最少、性能最高的上采样数据。
但是有时候重采样本身是不够的。本文继续介绍更高级的技术。
加权损失
避免阶级失衡的另一个方法是用不同的方式来衡量损失。要选择权重，首先需要计算类别频率。
*# Count up the number of instances of each class (drop non-class columns from the counts)*
class_counts = df_classes.sum()#print the class frequencies **for** column **in** class_counts.keys():
print(f"The class **{**column**}** has **{**df_classes[column].sum()**}** samples")
通过更改损失函数中的权重，数据科学家可以平衡每个类别的贡献。一种方法是将每个类中的每个例子乘以一个特定于类的权重因子，这样每个类的总体贡献是相同的。
感谢 Sklearn，在大多数 ML 算法中有一个内置的参数 class_weight，它可以帮助你平衡每个类的贡献。例如，在 Sklearn 的 RandomForestClassifier 中，您可以选择 balanced、balanced_subsample，或者您可以手动给每个类一个字典的权重。
#Fitting RandomForestClassifier
from sklearn.ensemble import RandomForestClassifiermodel = RandomForestClassifier(n_estimators=1000, class_weight={0:0.10, 1:0.90})
Amazing🥳，现在你学会了一个非常普通的技术，你可以用每一种最大似然算法应用几乎每一种数据。让我们深入了解更先进的技术。
数据扩充
从现在开始，我将要提到的技术主要适用于计算机视觉和图像。使用图像时，有多种方法可以生成数据。
众所周知，数据扩充是一种非常强大的技术，用于在现有图像中人工创建变化，以扩展现有图像数据集。这从代表可能图像的综合集合的现有图像数据集中创建新的和不同的图像。以下是增加数据集的几种方法。
- 轻弹
- 一款云视频会议软件
- 轮流
- 剪羊毛
- 种植
- 最后用生成性对抗网络生成新图像。
注意:有时候使用这些技术对你的模型有害无益。让我们假设相同的肺部 X 射线数据集情况，其中我们有许多不同的 X 射线。如果你翻转图片，你会在右边看到一颗心，它可以被看作是一个 cist。你又杀了人=(所以要小心使用这些增强技术。
迁移学习
如果您没有足够的数据来概括您的模型，您可以使用预先训练的模型，并针对您自己的任务调整它们。这被称为迁移学习，在计算机视觉领域非常普遍。自从培训以来，庞大的模型需要花费如此多的时间和资源，人们正在获得像 DenseNet 这样的预培训模型并使用它们。方法如下:
- 找到符合你要求的型号
- 重用模型。这可能涉及使用模型的全部或部分或神经网络的第一层。由于要素的复杂性随着层数的增加而增加，因此第一层总是具有更多可以成功使用的通用要素。
- 微调:通过深入，神经网络在任务上变得专业化，所以你可能想要为你自己的任务调整最后几层，这被称为微调。
摘要
我们学习了 4 种不同的技术，您可以将其应用于不平衡的数据/小型训练集。现在，您知道如何通过以下方式提高模型的性能:
- 使用取样技术
- 改变损失函数的类权重
- 使用数据增强技术
- 利用迁移学习
其中最后两个更专门针对计算机视觉。我希望这篇文章能帮助你理解如何用不同的技术克服不平衡数据问题。祝贺你完成这篇文章，感谢你一直以来的阅读。
参考资料:
- https://machine learning mastery . com/resample-interpolate-time-series-data-python/
- https://towards data science . com/data-augmentation-techniques-in-python-f 216 ef 5 eed 69
- https://machine learning mastery . com/transfer-learning-for-deep-learning/
- https://machine learning mastery . com/tactics-to-combat-unbalanced-classes-in-your-machine-learning-dataset/
如何在 Python 中正确处理地图投影
Python 中概念和代码的演练
西蒙·米加吉在 Unsplash 上的照片
如果您曾经尝试叠加地理空间数据，结果发现它们没有正确对齐，那么您很可能遇到了令人烦恼的坐标参考系统问题。在本教程中，我们首先阐明坐标参考系统(CRS)的概念和术语，然后介绍如何使用地理空间数据在 Python 中处理 CRS。
嘿，墨卡托——非洲比北美大
M 无论是纸上的还是屏幕上的，AP 大多是平面的，二维的。然而，地球不是二维的。因此，地图总是会说谎——在某种程度上。为了表现地球的大部分，你必须在大小、角度、形状或方向之间进行权衡。你不可能全部答对。那么在平面上表现地球的最好方式是什么呢？
嗯，看情况吧！这就是为什么我们今天在大多数网络地图上使用墨卡托投影。墨卡托投影保持所有角度的正确形状，这意味着如果您使用该投影测量角度，您将获得真实世界中的正确方向，这对地图导航非常有用。
但是，您不能在 web Mercator 中比较不同国家的大小，因为它不保留大小。非洲大陆比它看起来要大得多，加拿大和俄罗斯占据了很大的面积，而实际上，它们只占地球表面的 5%。
地理与预测
这里有两个密切相关的概念需要澄清。我们有地理坐标系，主要用于全球制图。地理坐标系通常使用纬度和经度。相比之下，有多个局部投影会带来视觉失真，称为投影坐标系。通用横轴墨卡托坐标系、国家平面和罗宾逊投影是最广泛使用的投影。
在地理坐标系中，测量单位是十进制度，这有助于定位地球上的位置。然而，要用米或英尺等其他单位来测量距离，我们需要投影。
带 Geopandas 的 CRS
由于 Geopandas 的存在，只要对坐标参考系统和投影有一个基本的了解，就可以很容易地在 Python 中正确处理它们。让我们阅读三个不同的数据集来说明正确处理投影的重要性。
import geopandas as gpd
import matplotlib.pyplot as plt# Read world Countries
world = gpd.read_file(
gpd.datasets.get_path(“naturalearth_lowres”)
)# Read world cities
cities = gpd.read_file(
gpd.datasets.get_path(“naturalearth_cities”)
)# Read Graticules
graticules = gpd.read_file(
“ne_110m_graticules_10/ne_110m_graticules_10.shp”
)
要知道数据是哪个坐标参考系，Geopandas 有.crs()，可以提供数据及其参考系的信息。
world.crs
让我们看看并理解这个方法的输出。
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
首先，数据位于地理 2D CRS 和世界大地测量系统(WGS84)中。我们通常使用不同坐标系的代码。WGS84 的代码是 EPSG:4326。你可以从 EPSG.io 网站找到这些代码，或者在空间参考组织中搜索。
我们需要检查所有的数据集是否有相同的 CRS，然后将它们绘制在一起。
cities.crs == world.crs == graticules.crs
这将返回 True，因为所有数据集都具有相同的坐标系。因此，让我们继续在地图上绘制数据。
fig, ax = plt.subplots(figsize=(12,10))
world.plot(ax=ax, color=”lightgray”)
cities.plot(ax=ax, color=”black”, markersize=10, marker =”o”)
graticules.plot(ax=ax, color=”lightgray”, linewidth=0.5)
ax.set(xlabel=”Longitude(Degrees)”,
ylabel=”Latitude(Degrees)”,
title=”WGS84 Datum (Degrees)”)plt.show()
WGS84 中的世界地图
还要注意 x 轴和 y 轴，它们有十进制度数。
预测
为了投影任何地理数据，Geopandas 也有采用投影代码的.to_crs()方法。让我们重新投影数据。让我们从埃克特四号投影开始。
埃克特 IV 投影是一个等面积 伪圆柱地图投影。极线的长度是赤道的一半，经线是半椭圆，或者说是椭圆的一部分。— 维基百科
world_eckert = world.to_crs(“ESRI:54012”)
graticules_eckert = graticules.to_crs(“ESRI:54012”)
现在，让我们打印出这些投影数据集的 CRS。世界埃克特投影数据集具有以下参数。
<Projected CRS: ESRI:54012>
Name: World_Eckert_IV
Axis Info [cartesian]:
- E[east]: Easting (metre)
- N[north]: Northing (metre)
Area of Use:
- name: World
- bounds: (-180.0, -90.0, 180.0, 90.0)
Coordinate Operation:
- name: World_Eckert_IV
- method: Eckert IV
Datum: World Geodetic System 1984
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
请注意世界数据集和世界埃克特投影数据集之间的差异。后者有投影 CRS，而前者有地理 2D CRS。第一个数据集的轴是以度为计量单位的椭球体，而后一个数据集的轴是以米为计量单位的笛卡尔坐标。
现在，让我们尝试绘制这两个投影数据集和未受保护的城市数据集。由于我们将多次绘制这些地图，所以让我们创建一个函数并绘制它们。
def plot_map(gdf1, gdf2, gdf3, name,unit):
fig, ax = plt.subplots(figsize=(12,10))
gdf1.plot(ax=ax, color=”lightgray”)
gdf2.plot(ax=ax, color=”black”, markersize=10, marker =”o”)
gdf3.plot(ax=ax, color=”lightgray”, linewidth=0.5)
ax.set(xlabel=”X Coordinate -”+unit,
ylabel=”Y Coordinate -” +unit,
title=name
)plt.show()plot_map(world_eckert, cities, graticules_eckert, "Eckert IV - Cities not Projected", "Metre")
城市点数据集在哪里？
不匹配的投影图
这些城市聚集在一个地方。大多数情况下，GIS 世界中的未对齐图层问题是由不匹配的 CRS 和投影造成的。我们可以通过将城市数据集投影到埃克特四投影来解决这个问题。
cities_eckert = cities.to_crs(“ESRI:54012”)
plot_map(world_eckert, cities_eckert, graticules_eckert, “Eckert IV — With projected Cities”, “Metre”)
正确匹配的世界地图-埃克特投影。
最后，让我们展示另一个投影，并展示任何投影之间的差异。让我们用罗宾逊投影。
world_robinson = world.to_crs(“ESRI:54030”)
graticules_robinson = graticules.to_crs(“ESRI:54030”)
cities_robinson = cities.to_crs(“ESRI:54030”)plot_map(world_robinson, cities_robinson, graticules_robinson, "Robinson Projection", "Metre")
世界罗宾逊投影
上面两个投影乍看起来可能是一样的，但它们是不同的。我们可以看到两个投影的重叠图。
埃克特投影(蓝色)和世界罗宾逊投影(红色)
对不同投影进行的任何计算都会产生不同的结果，例如，面积大小或距离。
结论
在本文中，我们解释了地理坐标参考系统(CRS)和投影坐标的基本概念。我们还看到了如何使用 Geopandas 在 Python 中正确处理它们。
如何处理交叉验证中的缺失值
为什么我们不应该用熊猫
处理缺失值是机器学习流水线中一个重要的数据预处理步骤。
Pandas 在检测和处理缺失值方面是通用的。然而，当涉及到交叉验证的模型训练和评估时，有一种更好的方法。
scikit-learn 的估算器以及管道提供了一种更实用的方法来处理交叉验证过程中的缺失值..
在本帖中，我们将首先做几个例子，展示处理熊猫缺失值的不同方法。之后，我将解释为什么我们需要不同的方法来处理交叉验证中的缺失值。
最后，我们将使用 scikit-learn 的缺失值估算器和管道来做一个示例。
先说熊猫吧。这是一个简单的数据框架，有几个缺失值。
import numpy as np
import pandas as pddf = pd.DataFrame(np.random.randint(10, size=(8,5)), columns=list('ABCDE'))df.iloc[[1,4],[0,3]] = np.nan
df.iloc[[3,7],[1,2,4]] = np.nandf
isna 函数返回布尔值，指示缺少值的单元格。isna()。sum()给出了每一列中缺失值的数量。
df.isna().sum()
A 2
B 2
C 2
D 2
E 2
dtype: int64
fillna 函数用于处理缺失值。它提供了许多选项来填写。让我们对每一列使用不同的方法。
df['A'].fillna(df['A'].mean(), inplace=True)df['B'].fillna(df['B'].median(), inplace=True)df['C'].fillna(df['C'].mode()[0], inplace=True)df['D'].fillna(method='ffill', inplace=True)df['E'].fillna(method='bfill', inplace=True)
列 A、B 和 C 中缺少的值分别用该列的平均值、中值和众数填充。对于 D 列，我们使用“ffill”方法，该方法使用该列中的前一个值来填充缺失的值。“bfill”的作用正好相反。
以下是数据框架的更新版本:
我们在 D 列中仍然缺少一个值，因为我们对该列使用了“bfill”方法。使用这种方法，丢失的值应该用后面的值来填充。由于最后一个值是一个缺失值，因此未对其进行更改。
fillna 函数也接受常数值。让我们用一个常量替换最后一个缺失的值。
df['E'].fillna(4, inplace=True)
如您所见，fillna 函数非常灵活。然而，当涉及到训练机器学习模型时，我们需要小心处理丢失的值。
除非我们使用常量值，否则需要在拆分训练集和测试集后处理缺失值。否则，模型将被给予关于导致数据泄漏的测试集的信息。
数据泄露是机器学习中的一个严重问题。不应该给机器学习模型任何关于测试集的信息。测试集中的数据点需要是以前看不见的。
如果我们使用整个数据集的平均值来填充缺失值，我们会将关于测试集的信息泄露给模型。
一种解决方案是在训练测试分割后处理缺失值。这绝对是一种可以接受的方式。如果我们想做交叉验证呢？
交叉验证意味着将数据集划分为子集(即折叠)。然后，使用不同的组合运行许多迭代，以便每个示例都将在训练和测试中使用。
考虑 5 重交叉验证的情况。数据集被分成 5 个子集(即折叠)。在每次迭代中，4 个折叠用于训练，1 个折叠用于测试。经过 5 次迭代后，每个折叠都将用于训练和测试。
我们需要一种实用的方法来处理交叉验证过程中的缺失值，以防止数据泄漏。
一种方法是用 scikit-learn 创建一个管道。管道接受数据预处理功能，并可用于交叉验证过程。
让我们创建一个适合简单线性回归任务的新数据框架。
df = pd.DataFrame(np.random.randint(10, size=(800,5)), columns=list('ABCDE'))df['F'] = 2*df.A + 3*df.B - 1.8*df.C + 1.12*df.D - 0.5df.iloc[np.random.randint(800, size=10),[0,3]] = np.nandf.iloc[np.random.randint(800, size=10),[1,2,4]] = np.nandf.head()
从 A 列到 E 列有 10 个缺失值。F 列是具有附加偏差的其他列的线性组合。
让我们导入任务所需的库。
from sklearn.linear_model import LinearRegressionfrom sklearn.pipeline import Pipelinefrom sklearn.impute import SimpleImputer
简单估算器根据给定的策略填充缺失值。我们可以创建一个包含简单估算对象和线性回归模型的管道。
imputer = SimpleImputer(strategy='mean')regressor = Pipeline(
steps=[('imputer', imputer), ('regressor', LinearRegression())]
)
“回归”管道包含一个简单的估算器，用平均值填充缺失值。线性回归模型完成预测任务。
我们现在可以使用这个管道作为交叉验证的估计量。
X = df.drop('F', axis=1)
y = df['F']scores = cross_val_score(regressor, X, y, cv=4, scoring='r2')scores.mean()
0.9873438657209939
R 平方得分相当高，因为这是一个预先设计的数据集。
这里重要的一点是在分割训练集和测试集之后处理缺失值。如果我们做一个常规的训练测试分割，这在熊猫身上很容易做到。
但是如果要做交叉验证，用熊猫会很繁琐。scikit-learn 库的管道提供了一种更实用、更简单的方法。
管道的范围相当广泛。您还可以在管道中添加其他预处理技术，例如用于数值的缩放器。使用管道可以实现某些任务的自动化，从而优化流程。
感谢您的阅读。如果您有任何反馈，请告诉我。
如何在 Python 中处理缺失值
入门指南
缺失值插补的简明介绍
马库斯·温克勒在 Unsplash 上的照片
数据科学家面临的最大挑战可能是一些听起来很平常，但对任何分析都非常重要的事情——清理脏数据。当您想到脏数据时，您可能会想到不准确或格式错误的数据。但事实是，缺失数据实际上是脏数据最常见的情况。想象一下，试图做一个客户细分分析，但 50%的数据没有地址记录。这将很难或不可能做你的分析，因为分析会显示在某些地区没有客户的偏见。
探索缺失的数据
- 有多少数据丢失了？您可以运行一个简单的探索性分析，看看您丢失数据的频率。如果百分比很小，比如说 5%或更少，并且数据完全随机丢失，那么您可以考虑忽略并删除这些情况。但是请记住，如果可能的话，分析所有数据总是更好，丢弃数据会引入偏差。因此，最好检查一下分布情况，看看丢失的数据来自哪里。
- 分析数据是如何丢失的 (MCAR，三月，四月)。我们将在下一节中发现不同类型的缺失数据。
缺失数据的类型
有三种缺失数据:
- 数据完全随机丢失(MCAR)
- 数据随机丢失(MAR)
- 非随机数据丢失(MNAR)
在这篇文章中，我将通过例子回顾缺失数据的类型，并分享如何用插补来处理缺失数据。
数据完全随机丢失(MCAR)
当我们说数据是随机缺失的时候，我们的意思是缺失与被研究的人无关。例如，一份问卷可能在邮寄过程中丢失，或者一份血样可能在实验室中被损坏。
数据完全随机缺失的统计优势是分析保持无偏，因为数据缺失不会使估计参数产生偏差。然而，很难证明这些数据是否确实是 MCAR 的。
数据随机丢失(MAR)
当我们说数据随机缺失时，我们假设一个数据点缺失的倾向与缺失数据本身无关，但与一些观察到的数据有关。换句话说，缺失值的概率取决于可观测数据的特征。例如，如果你的暗恋对象拒绝了你，你可以通过观察其他变量，比如“她已经做出承诺了”，或者“她的生活目标与你不同”等，来知道原因。
随机缺失相对容易处理——只需将所有影响缺失概率的变量作为回归输入。不幸的是，我们通常不能确定数据是否真的是随机缺失的，或者缺失是否取决于未观察到的预测值或缺失的数据本身。
数据不是随机丢失 (MNAR)
当我们说数据不是随机丢失时，我们假设丢失的数据中有一种模式会影响您的主要因变量。例如，受教育程度最低的人错过了教育，病情最严重的人最有可能退出研究，或者吸毒者在调查中将药物使用字段留空。这也意味着这些丢失的值不是随机的，而是故意为空的。
如果数据不是随机丢失的，那么我们估算丢失的数据是没有意义的，因为它会使你的分析或模型的预测产生偏差。
诊断机制
- MAR vs. MNAR :区分 MNAR 和 MAR 的唯一真实方法是测量一些缺失的数据。我们可以比较受访者的答案和非受访者的答案。如果有很大的差异，这是数据是 MNAR 的好证据。另外，调查问题越敏感，人们回答的可能性越小。
- MCAR vs .马尔:一种技术是创建虚拟变量，判断某个变量是否缺失。然后，在该变量和数据集中的其他变量之间运行 t 检验和卡方检验，以查看该变量的缺失是否与其他变量的值相关。例如，如果女性真的比男性更不愿意告诉你她们的体重，卡方检验会告诉你女性的体重变量缺失数据的百分比高于男性。那么我们可以断定重量是有标记
数据插补方法
简单插补
用列中的平均值、中值或众数替换缺失值是一种非常基本的插补方法。这种方法速度最快，但对编码的分类要素效果不佳。此外，它没有考虑特征之间的相关性。如果我们必须使用这种简单的插补方法，考虑使用中间值而不是平均值，因为平均值会给分析带来异常值或噪声。
from sklearn.preprocessing import Imputerimputer = Imputer(missing_values='NaN', strategy='median')
transformed_values = imputer.fit_transform(data.values)# notice that imputation strategy can be changed to "mean", “most_frequent”, 'constant'
# read the documentation here: [https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html](https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html)
KNN 插补
KNNImputer 通过使用欧几里德距离矩阵查找 k 个最近邻来帮助估算观测值中存在的缺失值。你可以在这里查看 KNNImputer 是如何工作的。这种方法比简单的插补更准确；然而，它可能计算量很大，并且对异常值很敏感。
import numpy as np
from sklearn.impute import KNNImputer
imputer = KNNImputer(n_neighbors=2) #define the k nearest neighbors
imputer.fit_transform(data)# read the documentation here: [https://scikit-learn.org/stable/modules/generated/sklearn.impute.KNNImputer.html](https://scikit-learn.org/stable/modules/generated/sklearn.impute.KNNImputer.html)
多元插补
多元插补通过考虑数据中的其他变量来解决噪音增加的问题。链式方程的基本多重插补(MICE)假设数据随机缺失。我们可以通过查看其他数据样本，对其真实价值做出有根据的猜测。
以下是三个主要步骤:
- 使用带有随机成分的插补流程为缺失值创建 m 组插补。
- 分析每个完整的数据集。每组参数估计值都会略有不同，因为数据略有不同。
- 将 m 个分析结果整合成最终结果。
如果你有兴趣了解它是如何工作的，请看这个视频这里。请注意，当我们对测量因缺失值导致的不确定性不感兴趣时，单变量与多变量插补在预测和分类中的有用性仍是一个未解决的问题。
图片作者 stefvanbuuren
import numpy as np
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
imp = IterativeImputer(max_iter=10, random_state=0)
imp.fit(X_train)
imp.transform(X_test)# read the documentation here: [https://scikit-learn.org/stable/modules/impute.html](https://scikit-learn.org/stable/modules/impute.html)
结论
任何分析都不能忽略缺失数据。作为数据科学家或数据分析师，我们不能简单地丢弃缺失的值。我们需要了解数据是如何丢失的，并相应地处理 NaN 值。
参考
- https://www.statisticssolutions.com/missing-values-in-data/
- https://measuringu.com/handle-missing-data/
- https://www.theanalysisfactor.com/missing-data-mechanism/
- https://www . analyticsvidhya . com/blog/2020/07/knnimputer-a-robust-way-to-imput-missing-values-using-scikit-learn/
- https://scikit-learn.org/stable/modules/impute.html
- https://www4 . stat . ncsu . edu/~ post/suchit/Bayesian-methods-completed . pdf
如果你觉得这很有帮助，请关注我，看看我在❤️的其他博客
下次见，快乐学习！👩🏻💻
举例说明最常见的离散概率分布
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)
如何处理多类不平衡数据？-对 SMOTE 说不
不需要再打了。
机器学习中的一个常见问题是处理不平衡数据，其中目标类中存在高度不相称的数据。
你好，世界，这是我为数据科学社区写的第二篇博客。在这篇博客中，我们将看到如何处理多类不平衡数据问题。
什么是多类不平衡数据？
当分类问题的目标类(两个或两个以上)不是均匀分布时，那么我们称之为不平衡数据。如果我们不能处理这个问题，那么这个模型将会变成一场灾难，因为使用阶级不平衡数据的模型偏向于大多数阶级。
处理不平衡数据有不同的方法，最常用的方法是过采样和创建合成样本。
什么是 SMOTE？
SMOTE 是一种过采样技术，它从数据集生成合成样本，从而提高少数类的预测能力。尽管没有信息丢失，但它有一些限制。
合成样品
局限性:
- SMOTE 对于高维数据不是很好
- 可能会发生类的重叠，这会给数据带来更多的噪声。
因此，为了跳过这个问题，我们可以用' class_weight '参数为类手动分配权重。
为什么使用类权重？
类权重通过给具有不同权重的类一个惩罚来直接修改损失函数。它意味着有目的地增加少数阶级的权力，减少多数阶级的权力。因此，它比 SMOTE 给出更好的结果。
概述:
我的目标是让这个博客非常简单。我们有一些最常用的技术来获得数据的权重，这些技术对我不平衡的学习问题有效。
- Sklearn utils。
- 计数到长度。
- 平滑重量。
- 样本权重策略。
1.Sklearn 实用程序:
我们可以使用 sklearn 计算类权重来获得类权重。通过在训练模型时将那些权重添加到少数类，可以在分类类时帮助性能。
from sklearn.utils import class_weightclass_weight = class_weight.compute_class_weight('balanced,
np.unique(target_Y),
target_Y)model = LogisticRegression(class_weight = class_weight)
model.fit(X,target_Y)# ['balanced', 'calculated balanced', 'normalized'] are hyperpaameters whic we can play with.
从逻辑回归到 Catboost，几乎所有的分类算法都有一个 class_weight 参数。但是 XGboost 有针对二元分类的 scale_pos_weight 和针对二元和多类问题的 sample_weights(参考 4)。
2.计数与长度之比:
非常简单直白！将每类的计数除以行数。然后
weights = df[target_Y].value_counts()/len(df)
model = LGBMClassifier(class_weight = weights)
model.fit(X,target_Y)
3.平滑权重技术:
这是选择权重的优选方法之一。
labels_dict 是包含每个类的计数的字典对象。
log 函数平滑不平衡类的权重。
def class_weight(labels_dict,mu=0.15):
total = np.sum(labels_dict.values())
keys = labels_dict.keys()
weight = dict()for i in keys:
score = np.log(mu*total/float(labels_dict[i]))
weight[i] = score if score > 1 else 1return weight# random labels_dict
labels_dict = df[target_Y].value_counts().to_dict()weights = class_weight(labels_dict)model = RandomForestClassifier(class_weight = weights)
model.fit(X,target_Y)
4.样品重量策略:
以下函数不同于 class_weight 参数，该参数用于获取 XGboost 算法的样本权重。它为每个训练样本返回不同的权重。
Sample_weight 是一个与数据长度相同的数组，包含应用于每个样本的模型损失的权重。
def BalancedSampleWeights(y_train,class_weight_coef):
classes = np.unique(y_train, axis = 0)
classes.sort()
class_samples = np.bincount(y_train)
total_samples = class_samples.sum()
n_classes = len(class_samples)
weights = total_samples / (n_classes * class_samples * 1.0)
class_weight_dict = {key : value for (key, value) in zip(classes, weights)}
class_weight_dict[classes[1]] = class_weight_dict[classes[1]] *
class_weight_coef
sample_weights = [class_weight_dict[i] for i in y_train]
return sample_weights#Usage
weight=BalancedSampleWeights(target_Y,class_weight_coef)
model = XGBClassifier(sample_weight = weight)
model.fit(X, target_Y)
类 _ 权重 vs 样本 _ 权重:
sample_weights用于给出每个训练样本的权重。这意味着您应该传递一个一维数组，其中的元素数量与您的训练样本完全相同。
class_weights用于为每个目标类赋予权重。这意味着你应该为你要分类的每个类传递一个权重。
结论:
以上是为你的分类器寻找类权重和样本权重的几种方法。我提到了几乎所有对我的项目有效的技术。
我请求读者尝试一下这些可以帮助你的技术，如果不是把它当作学习的话😄下次可能会对你有帮助😜
通过 LinkedIn 联系我😍
不平衡分类问题中 SMOTE 数据的处理
知道陷阱在哪里以及如何避免它们
照片由盖蒂图片社提供
分类问题在数据科学领域非常普遍。无论是欺诈检测、情绪分析还是疾病测试，能够预测特定数据点属于哪个组都是非常强大的。
通常，重点是检测少数群体中的数据点，这可能会出现一些常见问题。通常在这种情况下，您收集的数据是不平衡的，这意味着您感兴趣的目标比其他组的数据量小得多。数据中的这种不平衡会导致你的模型偏向于选择多数群体。在处理不平衡数据集时，有三种常用的技术来平衡数据:
- 欠采样多数类
- 对少数民族阶层进行过度采样
- 多数类欠采样和少数类过采样的组合
这篇博文将介绍一种叫做 SMOTE 方法的过采样技术。
SMOTE(合成少数过采样技术)是一种用于校正组中不平衡的过采样过程。这种技术通过复制现有的少数民族实例并对其进行小的修改来创建少数民族的新数据实例。这使得 SMOTE 非常擅长放大已经存在于少数群体中的信号，但不会为这些群体创造新的信号。
我们来看看一些还没有用 SMOTE 平衡的分类数据。我们将使用 sci-kit 学习库中的乳腺癌数据集。让我们导入必要的包，导入我们的数据，并创建一个可以评估我们的模型的函数。
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import cross_val_score
from sklearn.metrics import confusion_matrix def evaluate_model(X_train, y_train, model): model.fit(X_train, y_train)
preds = model.predict(X_test)
scores = cross_val_score(model, X_train, y_train, cv=3, scoring="accuracy")
diff = scores.mean() - model.score(X_test, y_test)
SD = diff / scores.std()
print(f"Training Score:{model.score(X_train, y_train)}")
print(f"Cross V Score: {scores.mean()} +/- {scores.std()}")
print(f"Testing Score: {model.score(X_test, y_test)}")
print(f"Cross & Test Diff: {diff}")
print(f"Standard Deviations Away: {SD}")
print(confusion_matrix(y_test, preds))cancer = datasets.load_breast_cancer()
X = cancer.data
y = cancer.target
从这里开始，我们将对我们的数据执行训练测试分割，并初始化我们的基本模型。
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegressionX_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=0)clf = LogisticRegression(random_state=0, solver='newton-cg', max_iter=1000)
提醒:在训练-测试分割函数中设置随机状态非常重要，这样可以确保模型性能的任何变化都是由于您所做的更改，而不是由于随机种子。分层参数根据输入参数分割数据，在本例中是 y 。这意味着每组的训练集和测试集将具有相同的样本百分比。
现在让我们看看我们的基本模型表现如何。
evaluate_model(X_train, y_train, clf)
基本模型结果
总的来说，我们看到我们的基本模型在建模数据方面做得不错，但是让我们看看是否可以使用 SMOTE 来提高性能。
现在，当处理合成数据时，第一条规则是:
不要把合成数据放在你的测试数据里！
我们想在实时数据上实现我们的模型，所以我们想看看我们的模型在真实数据上的表现，而不是我们创建的合成数据。这意味着我们只能将合成数据添加到训练集中。我们可以用下面的代码做到这一点:
from imblearn.over_sampling import SMOTE
smt = SMOTE(random_state=0)
X_train_SMOTE, y_train_SMOTE = smt.fit_sample(X_train, y_train)
从这里，我们可以使用包含 SMOTE 的训练数据来训练我们的模型。
evaluate_model(X_train_SMOTE, y_train_SMOTE, clf)
使用 SMOTE 数据的模型结果
正如我们所看到的，我们的模型能够更准确地预测包含 SMOTE 数据的测试数据。然而，引起关注的一个问题是我们的交叉验证分数。交叉验证分数用于评估有限数据集上的模型，以预测模型在真实世界数据中的表现。理想情况下，我们希望交叉验证分数与测试分数相同或接近。在这种情况下，我们的分数出现了分歧，因为我们违反了处理合成数据的第二条规则，即:
不要把合成数据放在你的验证数据里！
就像我们的测试数据一样，我们希望只使用真实数据来验证我们的模型。这意味着我们只希望我们的 SMOTE 数据在训练折叠中，而不是在验证折叠中。在 sci-kit learn 文档中可以找到如何使用 StratifiedKFold 函数将合成数据添加到每个单独折叠的示例。
幸运的是，有一个不平衡学习模块可以为我们处理所有的数据，即管道模块。只需将 SMOTE 流程和您的模型包含到管道中，模块就会处理剩下的工作。对于此任务，您可以使用 Pipeline 或 make_pipeline 函数。
from imblearn.pipeline import make_pipeline
pipeline = make_pipeline(smt, clf)evaluate_model(X_train, y_train, pipeline)
使用 imblearn 管道模拟性能
正如我们可以看到的，我们的交叉验证分数现在更准确地反映了我们可以从现实世界中的模型中预期的实际性能。希望这篇博客能帮助你在现实世界中实现你的模型。
如何使用模糊查询处理弹性搜索中的错别字
实践教程
使用 Elasticsearch 轻松处理错别字，改善用户体验
由 Ksenia Makagonova 在 Unsplash 上拍摄的照片
错别字是经常发生的事情，会降低用户的体验，幸运的是，Elasticsearch 可以通过模糊查询轻松处理它。
如果你正在用 Elasticsearch 构建一个高级的自动完成系统，处理输入错误是必须的。
如果你想创建一个简单的，你可以阅读我的其他文章“用 Elasticsearch 创建一个简单的自动完成功能”。
什么是模糊逻辑
模糊逻辑是一种数学逻辑，其中变量的真值可以是 0 到 1 之间的任何数字。这与只有真值 0 或 1 的布尔逻辑不同。
在弹性搜索中，模糊查询意味着查询中的术语不必与倒排索引中的术语完全匹配。
为了计算查询之间的距离，Elasticsearch 使用 Levenshtein 距离算法。
如何使用 Levenshtein 距离算法计算距离
用 Levenshtein 距离算法计算距离很容易。
你只需要把第一个和第二个单词一个字符一个字符的比较。
如果字符不同，那么你可以将单词之间的距离加一。
我们来看一个例子，如何计算常见错别字"Gppgle"与正确字"Google"的距离。
弹性搜索模糊查询:Levenshtein 距离
在我们用 Levenshtein 距离算法计算出"Gppgle"和"Google"之间的距离后，我们可以看到距离为 2。
弹性搜索中的模糊查询
使用模糊查询处理 Elasticsearch 中的输入错误也很简单。
让我们以错别字"Gppgle"为例。
当我们使用普通匹配查询时，Elasticsearch 将在搜索到 Elasticsearch 之前首先分析查询"gppgle"。
倒排索引中唯一的术语是“google”，它与术语"gppgle"不匹配。因此，Elasticsearch 不会返回任何结果。
现在，让我们在匹配查询中尝试 Elasticsearch 的 fuzzy。
如你所见，使用 fuzzy，Elasticsearch 返回了一个响应。
我们以前学过"gppgle"和"google"的距离是 2。
在查询中，我们插入了"fuzziness":"AUTO"而不是一个数字。为什么会起作用？
如果我们在"fuzziness"字段中使用"AUTO"值，Elasticsearch 将确定什么样的模糊距离是合适的。
对于 6 个字符，Elasticsearch 默认情况下将允许 2 个编辑距离。
模糊性更好，但是如果你愿意，你可以用一个精确的数字来调整它。
现在，让我们用一个确切的数字来证明"gppgle"和"google"的距离为 2。
当我们使用"fuzziness":"1"时，Elasticsearch 没有返回任何结果。
不过，使用"fuzziness":"2"，Elasticsearch 返回了文档"google"。
这证明了我们之前用 Levenshtein 距离算法对"gppgle"和"google"的距离计算，结果是 2。
弹性搜索中的两种模糊查询
在前面的例子中，我们使用模糊查询作为匹配查询中的参数。
但是还有另一种方法来使用模糊特性，即模糊查询。
好像是一样的！那么，它们有什么区别呢？
模糊查询
模糊查询的工作方式类似于术语查询，对 Elasticsearch 的查询不经过分析，也不用于搜索倒排索引。
例如，让我们再索引一个文档"Hong Kong"。
让我们看看分析器用 Elasticsearch 的 Analyze API 产生了哪些术语。
如您所见，standard_analyzer产生了两个术语，"hong"和"kong"。
如果你读了我的另一篇文章“elastic search:Text vs . Keyword”，你就会知道如果我们使用一个术语查询来搜索"Hong Kong"，那么我们不会得到任何结果。
这是因为在 Elasticsearch 中没有与"Hong Kong"的编辑距离小于 2 的术语。
现在，让我们用"Hpng"试试模糊查询。
查询中的术语"Hpng"和弹性搜索中的术语"hong"的距离为 2。
请记住，被查询的术语和倒排索引中的术语是区分大小写的，距离“2”来自于"Hp"和"ho"之间的差值。
用模糊性参数匹配查询
带模糊参数的匹配查询比模糊查询更好。查询中的分析器将在将查询搜索到倒排索引之前对其进行分析。
让我们尝试与模糊查询部分相同的查询。
不出所料，两个查询都返回了结果！
第一个查询，"Hpng Kong"被解析为"hpng"和"kong"。术语"hpng"和"kong"都存在于倒排索引中。
"hpng"和"hong"匹配距离为 1。而"kong"和"kong"完美匹配。
如果您计划使用匹配查询，需要注意的一点是查询中的每个术语都允许模糊性。
我们可以尝试使用"fuzziness":2用"hggg kggg"查询，它与"Hong Kong"的编辑距离为 4。
如您所见，Elasticsearch 返回了一个结果。
这是因为分析器将查询"hggg kggg"分析为术语"hggg"和"kggg"。
"hggg"和"kggg"在弹性搜索中对"hong"和"kong"的编辑距离分别为 2。
弹性搜索中模糊查询的调整
您可以调整模糊查询来匹配您的用例。
在这一节中，我将介绍我们可以在查询中更改的参数。
模糊
模糊性是模糊查询的核心。
我们传递给这个参数的值是允许的最大距离。
我们可以传递两种类型的值，一个是精确最大距离的整数，另一个是"AUTO"。
"AUTO"值允许查询中的模糊性是动态的。
我们可以在"AUTO"值中调 2 个参数，写成"AUTO:[low],[high]"。如果术语长度低于下限值，查询会将模糊度设置为 0。如果术语长度介于低值和高值之间，查询会将模糊度设置为 1。最后，如果术语长度大于上限值，查询会将模糊度设置为 2。
如果未确定高低值，Elasticsearch 将使用 3 和 6 作为默认值。
让我们以一个文档“Elasticsearch 中的模糊查询允许您处理错别字”为例。
我们可以尝试一些查询来证明我们之前描述的 AUTO 机制。
“tp”: 1 编辑距离“to”的距离。“Fyzzy”: 1 编辑距离“Fuzzy”的距离。“Fyzyy”: 2 编辑距离“Fuzzy”的距离。“Elastissearcc”: 2 编辑距离“Fuzzy”的距离。“Elestissearcc”: 3 编辑距离“Fuzzy”的距离。
查询之后，这些查询产生了一个结果:
“Fyzzy”“Elastissearcc”
这些查询不会:
“tp”“Fyzyy”“Elestissearcc”
换位
transpositions将允许您的查询将两个相邻字符(ab - > ba)的换位计算为 1 个距离。
例如，如果我们将transpositions设置为 true，那么用"leasticsearcc"查询就会得到一个结果。
但是如果我们将其设置为 false，那么弹性搜索将不会有任何结果。
弹性搜索默认transpositions设置为真。
我们无法将此设置设置为匹配查询。匹配查询总是将transpositions计算为 1 距离。
最大扩展
将决定您从查询中获得的最大结果。
如果您将max_expansions设置为 1，并且在 Elasticsearch 中有 2 个文档适合您的查询，那么 Elasticsearch 将只返回 1。
注意max_expansions适用于碎片级。因此，如果在 Elasticsearch 中有许多碎片，即使将max_expansion设置为 1，查询也可能返回更多结果。
max_expansions的默认值为 50。
前缀长度
prefix_length是模糊查询中不考虑的前缀字符数。
例如，如果我们将prefix_length设置为 1，那么查询"llasticsearch"将不会得到任何结果。
prefix_length 设置默认为 0。
重写
如果您想改变结果的得分，可以改变rewrite参数。
你可以在弹性搜索文档中找到关于rewrite参数的更多信息。
结论
处理 Elasticsearch 中的输入错误非常容易，可以改善用户体验。
处理输入错误的最简单方法是在匹配查询中添加"fuzziness":"AUTO"。
如果您想调优查询，可以更改一些参数，其中"fuzziness"是最重要的。
谢谢你一直读到最后！
如何在金融领域利用数据科学的力量
简要介绍金融机构可以有效利用数据科学和机器学习技术的某些使用案例
金融世界从来都是关于数据的。人们甚至可以说，金融专业人士甚至在数据科学、机器学习和人工智能出现之前就在日常运营中利用数据了。最重要的证据是 1958 年 FICO 分数的发展。
计算处理能力的进步、获取大数据的便利性以及复杂算法模型的发展，只是推动了金融专业人士对 ML 和 AI 的快速吸收。难怪美国最大的银行和世界第七大银行摩根大通&公司每年在新技术上投资 110 亿美元。
让我们看看数据科学帮助金融专业人士和金融机构变得更加有效和高效的具体使用案例。
欺诈检测和防范
确保客户数据安全并最大限度地减少欺诈性交易对于金融机构的持续运营至关重要，通常由监管机构强制执行和规定。ML 算法可以从历史数据中学习，并识别不寻常的行为、模式或交易。这些算法包括:
洗钱可以帮助金融机构识别:
- 基于真实索赔中发现的历史模式的虚假保险索赔
- 可疑的高价值或高交易量
- 身份盗窃
- 洗钱
- 用相似的 KYC 数据开立的多个账户
风险评估和预测分析
金融机构面临各种风险，可能来自竞争对手、债权人、债务人、监管机构，也可能来自各种市场(资本、商品、外汇等。).可以实施不同的 ML 技术来分析风险驱动因素，并对未来做出预测和/或开发风险模型。
例如:
- 给定特定借款人的历史付款行为和其他特征(年龄、收入、家庭规模、地址等)，该借款人对其未来债务违约的可能性有多大。)?
- 在客户或投资组合层面估计和预测违约损失(LGD)
- 分析和预测市场前景
- 投资银行可以开发各种风险模型和场景，以提供可操作的、数据驱动的见解
客户数据管理和分析
金融机构被海量数据(包括结构化和非结构化数据)淹没，后者在管理、处理和洞察方面更具挑战性。
ML 和 AI 工具，如自然语言处理、数据挖掘和文本分析，可以将这种过去繁琐的数据管理练习转变为一个独特的机会，以了解更多有关客户的信息，并确定可操作的见解，从而推动新的收入机会。
聚类和分割算法可用于将相似的客户分割在一起。客户细分将允许有针对性的营销活动，并为具有高流失风险的客户提供额外支持。
客户数据也可用于执行客户终身价值分析(CLV) 。应识别高 CLV 客户，并对其进行适当管理，以从该关系中获得最大的金钱利益和增长。
个性化服务
与前一点有些关系的是，ML 还可以用来为客户提供个性化和定制化的服务，从而确保长期互利的关系。
数据分析还支持创建个性化营销，在正确的时间和正确的设备上为正确的潜在客户提供正确的产品。数据挖掘广泛用于目标选择，以识别新产品的潜在客户。行为、人口统计和历史购买数据用于建立模型，该模型预测客户/潜在客户对促销或报价的响应概率。
推荐引擎(无论是协同、基于内容还是混合)可以分析和过滤用户的活动，向他推荐最相关和最准确的产品或服务。
客户支持
人工智能支持的虚拟助理使金融机构更容易实现渠道无关的一致客户服务体验，使客户能够向虚拟助理请求日常信息、方向或按需援助。这些虚拟助手(也称为聊天机器人)也节省了员工的时间。
算法交易
尽管算法交易有时会遭到反对，但大型金融机构和经纪商正在大规模开展这种交易。这些算法以预编程的方式发出市场订单，同时自动考虑数量、价格和时间变量；并利用计算机的计算处理速度。执行速度被认为对普通交易者不公平，因为他们的交易可能落后于算法交易，使他们处于不利地位。
通过时间序列分析进行预测
时间序列预测不同于常规的最大似然预测，因为它在历史观测值之间增加了一个显式的顺序相关性:一个时间维度。使用历史趋势、季节性和数据中的任何噪声，时间序列预测试图预测在给定的未来时间点的变量值，无论是否有任何其他因变量。
递归神经网络(RNN) ，或者更具体地说，长短期记忆(LSTM)网络通常用于时间序列预测。谈到金融领域，金融专业人士通常利用时间序列预测来预测未来的销售量、股票价格、产品需求等。
结论
金融专业人士对数据科学的使用不仅限于欺诈、风险管理和客户分析。金融机构也可以利用机器学习算法来自动化业务流程并提高安全性。
如果您想讨论任何与数据分析、机器学习、金融或信用分析相关的问题，请随时联系 me 。
下次见，继续！
如何在软件工程中有一个坚实的开端
我的第一个软件开发项目 A-Z 编程体验！
虽然我现在是一名研究人员，但每当我用我的软件工程知识开发我的算法时，我发现自己成为了一名更好的研究人员/科学家/无论什么。在这篇文章中，我将分享我的第一次软件开发/编程经历。这是我们在本科大学(斯里兰卡莫拉图瓦大学)计算机科学与工程系第一学期必须完成的项目。
用我的电子表格程序随机绘制
鉴于我对 JAVA(我在其中做了这个项目)的了解很少，这确实是一个非常具有挑战性的练习。编程语言的选择是自由的，然而，JAVA 是我的首选，因为它比 C/C++更容易。此外，NetBeans 是一个易于使用的 GUI 开发工具。我相信这些天真的选择可能帮助我不费吹灰之力就掌握了编程。我必须感谢Surangika Ranathunga(唯一课程召集人/讲师)博士(夫人)在短短 4 个月(1 个学期)内为许多新生注入如此大量的知识。这很困难，但结果是惊人的。这篇文章中任何有帮助的内容都必须反映出她教导和指导新手的能力。让我们检查一下这个项目！
概述
目标是开发一个具有基本数据类型、单元格引用和将单元格内容标记为数据类型的能力的电子表格程序。完整的实现必须遵循适用的 OOP 概念(继承、抽象、封装和多态)。
第一个任务-字符串标记器
学习编程语言的最好方法之一是在实践中使用语法。此外，作为一名程序员，你必须知道如何使用正则表达式和算法(尽管这是大学里完全不同的课程)，你必须做一个好项目。我相信实现一个简单的记号化器和一个算法来简化数学字符串可能是一种立刻学习它们的方法。
- 标记器应识别数据类型；整数、浮点数、字符串、日期/时间、货币。
- 如果字符串是 excel
=500*10/5中的数学表达式，则值必须计算为1000。
可以使用字符串中的前缀=在上述情况之间切换。我在案例 1 中使用的正则表达式如下。
booltype = ".*?(((=?[<>])|(!=)|([<>]=?)|<>|><)|==|=).*?";
currency = "[A-Za-z$]{1,2}[ .]?[0-9][0-9]*[.]?[0-9]*";time12hr = "(1[012]|[1-9]):[0-5][0-9]?[:]?[0-5][0-9]?(am|AM|pm|PM)"; time24hr = "(2[0-4]|1[0-9]|[0-9]):[0-5][0-9]?[:]?[0-5][0-9]?"; integer = "[-]?[0-9]*";
floating = "[-]?[0-9]*[.][0-9]*";dateformatSL = "[0-9]{2,4}[/-](1[012]|0?[0-9])[/-](1[0-9]|0?[0-9]|2[0-9]|3[01])";dateformatINTL = "(1[0-9]|0?[0-9]|2[0-9]|3[01])[/-](1[012]|0?[0-9])[/-][0-9]{2,4}";
我这里有我天真的实现。然而，简单地说，可以用一个静态类来保存函数，这些函数可以解析字符串并返回解析的部分(类型、格式化/评估的内容、原始内容)。请注意，解析后，我们必须保留类似于 excel 的原始内容。
对于情况 2，必须实现算法；调车场这只是将左括号推入堆栈，并在遇到右括号时通过回溯来解决。如果你有一个类似于12*(5+6)的等式，你可以推栈直到你找到第二个右括号。然后弹出，直到第一个左括号出来，然后简化5+6并再次推入堆栈。最后，堆栈将没有括号，您可以使用 BODMAS 来简化最终的堆栈。你可以在这里看看我的实现。
现在这两个类都完成了。第一个类将解析条目，如果输入字符串是一个表达式，第二个类将由第一个使用。
计算表达式的单元格
第二个任务-单元类
作为一名学徒，我的单元实现并不完美或合适。然而，理想的方法是做适当的泛型的实现。如果你是新手(像我一样)，你可以在单独的类中使用数据类型的字符串。以下是我现在组织课程的方式:
Cell<E> <- used to render cells, a generic class
AbstractDataType <- store shared data (user input string, etc)
DataType extends AbstractDataType <- store data (an example)
FloatType extends AbstractDataType <- floating point data storage
这里 E 可以是解析器找到的单元的数据类型(解析器可以返回泛型中正确数据类型的类)。我们使用继承来共享任何单元格都应该具有的公共属性(用户输入字符串、单元格颜色，如果有的话，以及稍后将讨论的更多内容)。AbstractDataType 类演示了抽象。你永远不会创建 AbstractDataType 的类，因为它毫无意义。
在我们的操作中，我们将使用AbstractDatatype dataT = new DataType()，也就是多态性。当单元格引用开始起作用时，这将使我们能够增加和减少单元格。单元格中的所有字段都被封装，并且只使用 getters 和 setters 进行变异。
现在我们已经涵盖了所有主要的 OOP 概念以及如何实现一个算法！
对于任何一个刚接触编程的学生来说，这都不是一个简单的任务，更不用说 JAVA 了。
第三项任务-用户界面
这是一件很难用文字来解释的事情。因此，我将分享我的实现的外观和感觉。但是，NetBeans 是一个简单的工具，可以实现正确的 GUI。我相信在实践中已经不再使用它了，因为我们已经有了类似于 Electron/Qt 的框架。
JAVA 有内置的 GUI 组件，一旦你阅读了文档，它们就非常简单。阅读文档是一项重要的技能，我相信我是从同一门课程中学到的。
电子表格程序的关键 UI 组件
- 工作表视图(单元格板)
- 用于保存、复制、粘贴等的菜单
- 单元格编辑器(您可以在其中看到原始公式或单元格文本)
- 活动单元格指示器(显示您点击的单元格，如 A1)
下面是我的 GUI 实现。请注意，我使用了一个主题(显然是唯一一个在非 windows 平台上能够正确呈现的好主题)。
电子表格程序
单元格引用
引用单元格以红色突出显示
这是我从 MS Excel 程序中抓取的一个特性。相当整洁的功能！
JAVA 有许多库，这些库激励我们在这个特定的项目上更进一步。我加了几张这样的截图，激励我亲爱的读者和未来的工程师们！
绘图(J-free-chart 库)
JFreeChart 库提供了大量的绘图功能。我用了一些来使程序看起来优雅一些。
Y=X 绘图的绘图工具
使用 OpenCSV 保存(序列化)
导出电子表格数据的最常见方式之一是使用 CSV 格式。在这个程序中，我使用 OpenCSV 库来处理 CSV 文件解析。
文件打开
实现特性和有用的数据结构/设计模式
单元格引用
这可以通过多种方式实现。
- 观察者设计模式 —这里的观察者是引用其他单元格的单元格。我们将这样的细胞添加到被观察细胞内的观察细胞阵列中。更改作为更新被推送。请注意，JAVA 有一个可观察的接口，这使得实现非常流畅。
- 中介模式 —在这个实现中，我们有一个单元协调器，负责变更和更新。HashMap 对象可以用来存储可能的引用和参考。
特别注意——寻找循环依赖是很重要的。否则，由于永无止境的引用循环，程序可能会遇到堆栈溢出。
撤消/重做
虽然我没有在我的程序中实现这一点，但这可以通过使用 纪念品设计模式 来实现。这可以实现为链接的对象引用，也可以实现为一堆动作。
对当前时代的最后思考
这个项目是 2014 年 6 年前进行的！。既然时代已经让我们从桌面图形用户界面转移，一个基于网络的项目会更有意义。让我分享几个项目，它们可能有助于一个初露头角的软件工程师建立编程信心。
- 图书馆管理程序
- 办公室使用的投票程序(用于决策)
- 一个基于网络的婴儿监视器(适用于那些喜欢处理图像等的人)
- 一些商品(汽车、房屋等)的买卖程序
希望你喜欢读这篇文章。我展示这个项目的唯一想法是激励年轻人完成这个项目。试一试，并与我分享你的项目。干杯！
试一试吧！
git clone [https://github.com/anuradhawick/SpreadSheet.git](https://github.com/anuradhawick/SpreadSheet.git)
cd SpreadSheet/dist/
java -jar SpreadSheet.jar
😃
在简单的小表格中突出数据
驯服 Matplotlib 表的更多方法
如何突出显示单元格(图片由作者提供)
当显示表格数据时，我们通常希望关注某个特定的单元格。这种关注改善了我们希望从表中获得的视觉支持，并使观众不会被包含在整个值集中的数据的广度所淹没。尽管如此，我们还是希望在整个集合的上下文中呈现关键信息。有了表格，我们可以通过使单元格在大小、粗细、颜色、形状、间距或边框上与其他单元格不同来突出显示所需的单元格。
本文对我之前的文章“使用 Matplotlib 的简单小表格”进行了扩展，提供了一组我们可以用来突出 Matplotlib 表格中的单元格的技术。这些技术包括改变单元格的边框宽度、背景颜色、字体粗细和字体颜色的方法。我们还将看到如何淡化未突出显示的单元格。在这个过程中，我们将发现一些相关的样式技术，比如改变表格网格线的颜色和使用开源调色板。我将注释转换的每一步，以提供对pyplot.table行为的洞察，我们可能会重用这些行为来完成其他任务，或者让您扩展我正在分享的发现。我会在文章的最后呈现完整的源代码，所以你不需要一行一行的拼凑。
起点
起点是来自“使用 Matplotlib 的简单小表”文章的最终代码。这些技术也应该适用于从pyplot.table派生的任何可能需要调整的表。
更改调色板
我们要做的第一件事是从继承自pyplot.table例子的色图中改变调色板。我使用了一个令人愉快的调色板，由 colourlovers.com 的 TaraLynn1221 命名为“Outcomes”。使用来自艺术社区的开源调色板是我们设计困难的程序员可以将至少在某些情况下匹配的颜色放在一起的一种方式。
# colors from "Outcomes" palette by TaraLynn1221
# https://www.colourlovers.com/palette/4751687/Outcomes
cl_outcomes = {
'white':'#FFFFFF',
'gray': '#AAA9AD',
'black':'#313639',
'purple':'#AD688E',
'orange':'#D18F77',
'yellow':'#E8E190',
'ltgreen':'#CCD9C7',
'dkgreen':'#96ABA0',
}
...
# Get some lists of color specs for row and column headers
rcolors = np.full(len(row_headers), cl_outcomes['ltgreen'])
ccolors = np.full(len(column_headers), cl_outcomes['ltgreen'])
我还为我们将要创建的高亮单元格和绘图中的其他组件创建了一些颜色变量。
grid_color = cl_outcomes['dkgreen']
fig_background_color = cl_outcomes['white']
fig_border = cl_outcomes['dkgreen']
label_text_color = cl_outcomes['black']
highlight_text_color = cl_outcomes['yellow']
faded_text_color = cl_outcomes['gray']
highlight_color = cl_outcomes['purple']
highlight_border = cl_outcomes['dkgreen']
title_text_color = cl_outcomes['black']
在此期间，我为文本元素更新并添加了一些变量。在本例中，我们将向图中添加文本注释和副标题。
title_text = 'Loss by Disaster'
subtitle_text = '(In millions of dollars)'
annotation_text = 'The ten-year loss due to floods is $78.0M.'
footer_text = 'July 28, 2020'
更改调色板(图片由作者提供)
突出显示单元格
突出显示是通过设置单元格的填充和边缘(边框)颜色实现的。如果需要，可以对几个单元格重复此过程。
表格对象由单元格对象组成。使用从表格左上角开始的(0,0)索引来引用单元格。列标题在这个矩阵中，所以(0，0)指的是第一个列标题。行标题确实是这个矩阵的一部分，但是被索引为列-1。
下面的代码将突出显示第二行第三列中的单元格。记住，我们必须考虑第 0 行是列标题行。行标题的列索引为-1。最上面一行的标题是(1,-1)。
为了突出显示，我们从表中检索单元格。然后，我们设置表面颜色，边缘颜色和线宽。为了控制字体样式，我们从单元格中获取文本对象。可以控制的文本属性是有限制的。例如，设置单个单元格的字体大小没有任何效果。数据网格中的所有单元格需要具有相同的字体大小，这是在表格级别控制的。
一旦我们完成了所有想要的高亮样式的改变，我们就调用ax.add_patch()来传递对单元格的引用。您可能认为简单地更改属性就足以设置样式，但这似乎并没有按 z 顺序重新定位单元格，相邻的单元格样式显示在突出显示的单元格的顶部。将单元格作为补丁添加到 Axes 对象可以解决这个问题。如果你找到了更优雅的方式，请在评论中告诉我们。
# Highlight the cell to draw attention to it
the_cell = the_table[2,2]
the_cell.set_facecolor(highlight_color)
the_cell.set_edgecolor(highlight_border)
the_cell.set_linewidth(2)
the_text = the_cell.get_text()
#the_text.set_weight('bold')
the_text.set_fontstyle('italic')
the_text.set_color(highlight_text_color)
ax.add_patch(the_cell)
突出显示单元格(作者图片)
Cell 对象是 Matplotib 矩形的子类。矩形是面片的子类。这种继承意味着您可以引用 Rectangle 和 Patches 的属性和功能，从而对格式进行更多的控制。
淡化未突出显示的单元格
为了将更多的注意力吸引到突出显示的单元格，我们可以淡化它们。我们将使用类似于高亮显示的技术将它们设置为较浅的颜色。我们可以调用get_children()来获取单元格列表并遍历它们。表格只包含单元格，因此不需要对元素进行类型检查。对于每个单元格，我们得到它的文本对象。从过程中排除标题就像检查标题标签列表中的单元格文本一样简单。当然，如果您的单元格的值与标签相匹配，您就需要想出另一种方法。这种循环技术也是我们设置表格边框颜色的方式，所以我们在这里添加cell.set_edgecolor(grid_color)。Table 对象上没有设置该颜色的属性，所以我们用循环的方式来设置。
# Fade the cells
for cell in the_table.get_children():
cell_text = cell.get_text().get_text()
cell.set_edgecolor(grid_color)
if cell_text not in row_headers\
and cell_text not in column_headers:
cell.get_text().set_color(faded_text_color)
else:
cell.get_text().set_weight('bold')
cell.get_text().set_color(label_text_color)
我们可以添加代码来排除突出显示的单元格。不过，更简单的方法是在突出显示之前全部淡入淡出。因此，让我们在流程的前面插入衰落代码例程。
get_children()的替代物是get_celld()。当get_children()返回一个艺术家对象的列表，而这些对象恰好只是这里的单元格时，get_celld()将返回一个单元格字典，这些单元格的关键字是行和列元组。
print(the_table.get_children())
[<matplotlib.table.CustomCell object at 0x7fb7b430f150>, <matplotlib.table.CustomCell object at 0x7fb7b6bf2890>, <matplotlib.table.CustomCell object at 0x7fb7b6bf26d0>,...
print(the_table.get_celld())
{(1, 0): <matplotlib.table.CustomCell object at 0x7fb7b4313390>, (1, 1): <matplotlib.table.CustomCell object at 0x7fb7b4313e50>, (1, 2): <matplotlib.table.CustomCell object at 0x7fb7b4313150>,...
淡化未突出显示的单元格(图片由作者提供)
提示: get_celld()可用于生成单元格文本的索引表，用于故障排除或按索引手动引用单元格。
for key, val in the_table.get_celld().items():
# call get_text() on Cell and again on returned Text
print(f'{key}\t{val.get_text().get_text()}')
(1, 0) 66.4
(1, 1) 174.3
(1, 2) 75.1
...
添加注释和副标题
如果我们要在演示或报告中使用我们的表格图像，我们可能希望向它添加文本注释，以帮助读者理解我们为什么要调出单元格值。副标题也能帮助读者理解图表。在我们的例子中，我们没有让读者知道表中的度量单位是什么，这样信息就可以成为一个好的副标题。
有几种方法可以在 Matplotlib 中创建注释。我们在表格周围有大量的空白，所以让我们在图表下面使用一行简单的图形文本。我们也会包括一些造型。
# Add annotation
plt.figtext(0.5, 0.2,
annotation_text,
horizontalalignment='center',
size=9, weight='light',
color=title_text_color
)
Matplotlib 没有给我们一个一流的字幕函数，所以我们也将使用图形文本。不幸的是，这意味着如果我们以后更改标题或整体图形结构，我们可能需要调整它的位置。我们可以使用 heroics 来计算字幕相对于图片和标题的位置，但是我们将保持简单，并根据实验对字幕位置进行硬编码。
# Add subtitle
plt.figtext(0.5, 0.9,
subtitle_text,
horizontalalignment='center',
size=9, style='italic',
color=title_text_color
)
注意:记住suptitle()是在图上设置标题的功能，而不是 sub 标题。不幸的命名。
添加注释和副标题(图片由作者提供)
最终来源
这是最终的源代码。我还在标题和页脚中添加了一些明确的样式。我有一个设计师朋友，他教我平面设计中最好的黑色不是纯黑，所以我们用#313639代替#000000。
这是最终产品，你可以随心所欲地裁剪。
import numpy as np
import matplotlib.pyplot as plt
# colors from "Outcomes" palette by TaraLynn1221
# https://www.colourlovers.com/palette/4751687/Outcomes
cl_outcomes = {
'white':'#FFFFFF',
'gray': '#AAA9AD',
'black':'#313639',
'purple':'#AD688E',
'orange':'#D18F77',
'yellow':'#E8E190',
'ltgreen':'#CCD9C7',
'dkgreen':'#96ABA0',
}
title_text = 'Loss by Disaster'
subtitle_text = '(In millions of dollars)'
annotation_text = 'The ten-year loss due to floods is $78.0M.'
footer_text = 'July 28, 2020'
grid_color = cl_outcomes['dkgreen']
fig_background_color = cl_outcomes['white']
fig_border = cl_outcomes['dkgreen']
label_text_color = cl_outcomes['black']
highlight_text_color = cl_outcomes['yellow']
faded_text_color = cl_outcomes['gray']
highlight_color = cl_outcomes['purple']
highlight_border = cl_outcomes['dkgreen']
title_text_color = cl_outcomes['black']
data = [
[ 'Freeze', 'Wind', 'Flood', 'Quake', 'Hail'],
[ '5 year', 66386, 174296, 75131, 577908, 32015],
['10 year', 58230, 381139, 78045, 99308, 160454],
['20 year', 89135, 80552, 152558, 497981, 603535],
['30 year', 78415, 81858, 150656, 193263, 69638],
['40 year', 139361, 331509, 343164, 781380, 52269],
]
# Pop the headers from the data array
column_headers = data.pop(0)
row_headers = [x.pop(0) for x in data]
# Table data needs to be non-numeric text. Format the data
# while I'm at it.
cell_text = []
for row in data:
cell_text.append([f'{x/1000:1.1f}' for x in row])
# Get some lists of color specs for row and column headers
rcolors = np.full(len(row_headers), cl_outcomes['ltgreen'])
ccolors = np.full(len(column_headers), cl_outcomes['ltgreen'])
# Create the figure. Setting a small pad on tight_layout
# seems to better regulate white space. Sometimes experimenting
# with an explicit figsize here can produce better outcome.
plt.figure(linewidth=1,
edgecolor=fig_border,
facecolor=fig_background_color,
tight_layout={'pad':1},
#figsize=(5,3)
)
# Add a table at the bottom of the axes
the_table = plt.table(cellText=cell_text,
rowLabels=row_headers,
rowColours=rcolors,
rowLoc='right',
colColours=ccolors,
colLabels=column_headers,
loc='center')
# Scaling is the only influence we have over top and bottom cell padding.
# Make the rows taller (i.e., make cell y scale larger).
the_table.scale(1, 1.5)
# Hide axes
ax = plt.gca()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
# Hide axes border
plt.box(on=None)
# Add title
plt.suptitle(title_text,
weight='bold',
size=14,
color=title_text_color)
# Add subtitle
plt.figtext(0.5, 0.9,
subtitle_text,
horizontalalignment='center',
size=9, style='italic',
color=title_text_color
)
# Add footer
plt.figtext(0.95, 0.05, footer_text,
horizontalalignment='right',
size=6,
weight='light',
color=title_text_color
)
# Add annotation
plt.figtext(0.5, 0.2,
annotation_text,
horizontalalignment='center',
size=9, weight='light',
color=title_text_color
)
# Fade the cells
for cell in the_table.get_children():
cell_text = cell.get_text().get_text()
cell.set_edgecolor(grid_color)
if cell_text not in row_headers\
and cell_text not in column_headers:
cell.get_text().set_color(faded_text_color)
else:
cell.get_text().set_weight('bold')
cell.get_text().set_color(label_text_color)
# Highlight the cell to draw attention to it
the_cell = the_table[2,2]
the_cell.set_facecolor(highlight_color)
the_cell.set_edgecolor(highlight_border)
the_cell.set_linewidth(2)
the_text = the_cell.get_text()
#the_text.set_weight('bold')
the_text.set_fontstyle('italic')
the_text.set_color(highlight_text_color)
ax.add_patch(the_cell)
# Force the figure to update, so backends center objects correctly within the figure.
# Without plt.draw() here, the title will center on the axes and not the figure.
plt.draw()
# Create image. plt.savefig ignores figure edge and face colors, so map them.
fig = plt.gcf()
plt.savefig('pyplot-table-highlight.png',
bbox='tight',
edgecolor=fig.get_edgecolor(),
facecolor=fig.get_facecolor(),
dpi=300
)
结论
我们已经有了第一个小表格，并在单元格中添加了一些突出显示，使它对我们的观众来说更加明显。我们学习了如何从开放的设计网站上获取调色板。我们看到了基于大小、颜色、相对褪色和边框的高亮技术。我们学习了添加注释和副标题的简单方法。Matplotlib 表格是一个灵活而强大的工具，用于显示表格汇总数据。
如何雇佣一名数据科学家
图片来自 Pixabay
今天我写的是我如何通过将数据科学应用到招聘过程中，为我的公司招聘了一名数据科学家。我第一次雇用数据科学家，让我大开眼界，在花了几年时间作为候选人参加面试后，我坐在了桌子的另一边。
我想深入探讨三个要点。
- 定义数据科学角色和职责。确切了解数据科学家将从事的工作。
- 利用自动化测试和评分标准大规模评估候选人，而不是没完没了地查看简历和打招聘经理电话。
- 为漏斗的所有部分创建基于指标的招聘流程。
首先，我们为什么需要数据科学家？
具有讽刺意味的是，一个数据科学家创立的数据科学创业公司需要另一个数据科学家。数据科学家有助于企业通过分析数据来影响产品方向，或者通过大规模实施机器学习来增加像参与度、保留率和收入这样的指标，从而增加收入。
这通常是在大型平台、市场、电子商务上完成的——基本上所有的事情面试查询都不是。作为一个小企业，我们当前开发新功能的首要任务是与我们的客户交谈，因为他们通常对我们应该构建什么有强烈的意见。
我们了不起的首席技术官。
但作为一个数据科学教育企业，似乎有必要将其他人的整个工作(除了我的工作)集中在应用分析和发现有趣的产品见解和功能上。除了提供面向数据科学的教育内容，我还希望将数据科学实际应用到业务中，以提高我们用户的学习目标。
定义数据科学角色
如果你曾经与数据科学经理或招聘人员聊天，你可能听说过招聘过程有多痛苦。他们浏览了成千上万份简历，他们面试的所有候选人都被拒绝了，有人被录用了，但在第一个月内就辞职了——随你挑。
老实说，根据我的经验，这个问题通常可以归结为职位描述和面试过程中的期望值不一致。你不能采访一个数据科学家，滔滔不绝地谈论产品见解，然后在 Leetcode 上钻牛角尖。
在为我们的空缺职位撰写职位描述时，我确保列出了他们将参与的几个项目- 改进我们的时事通讯，创建 AB 测试系统等。我非常清楚地说明了为什么我们需要一名数据科学家，以及这个职位需要什么。
这个过程的第二部分包括创建你自己的招聘策略。以下是我多年来学到的一些技巧。
在漏斗的每一步，淘汰 50%的候选人。例如，如果你要招聘一个职位，并想提供两个机会，你可以根据简历或课后练习安排四次现场面试、八次技术筛选和十六次招聘经理面试。这就像一个二叉查找树，目标是优化你的面试过程，在最短的时间内找到最好的候选人。
了解候选人中的技能分布。一旦你为这份工作设定了要求，包括薪水、工作时间、工作风格和技能期望，你很可能会收到一大堆各种各样的候选人。要了解一个好的候选人是什么样子，你也要看看一个坏的候选人是什么样子。
换句话说，在一个被录用的候选人身上定义你的基本要求。对于面试查询，我们需要一名精通产品分析并能独立工作的数据科学实习生。作为雇主，我们的优势在于我们是一家初创公司，我可以直接指导数据科学家，但老实说，我们不确定这对应用程序有多大吸引力。
令人惊讶的是，一周后，我们有超过 500 名候选人申请！太疯狂了。
然后，我们遇到了当今招聘的经典问题——衡量和筛选所有候选人，而不是花数百个小时面试每个人。
我们如何准确地、不带偏见地、大规模地评估候选人？
我们接下来做的是…分配带回家的挑战。
大规模评估候选人
是的。我知道你在想什么。杰伊，你已经写了你如何 讨厌 带回家的挑战。我的天啊。你做了什么？
我承认:我的态度总是倾向于讨厌带回家的挑战，因为我是站在候选人一边面试的。老实说，虽然承认这一点让我很痛苦，但带回家的挑战对雇主来说是很大的，因为它们允许雇主大规模地评估候选人。你可以在同一时间内真实地回顾 50 个带回家的挑战，而不是进行五个单独的技术筛选。
此外，我有动力去寻找被低估的候选人。我认为，在雇佣个人贡献者时，最容易出现误判的情况是雇主过于看重简历和以往的经验，而不是实际技能。当用作过滤和分配机制，同时最小化转化率损失时，带回家的挑战是最好的。例如:
带回家挑战有效性图表。
图表上的 x 轴代表以小时为单位的带回家挑战的长度，垂直轴代表如果带回家的复杂性增加，我们理论上可以获得的数据科学技能的信号。我假设虽然信号可能随着带回家的长度而增加，但在某一点上，它在有效性上处于平稳状态。很多时候，数据科学家也会在带回家的挑战上花费过多的时间，这可能会混淆候选人的比较。
第二行是候选人的转换率，这些候选人会接受的挑战。正如所料，随着挑战时间的增加，完成带回家挑战的候选人数量会减少。
我们的目标是找到这两条线之间的点，最大限度地提高挑战在评估技能方面的有效性，同时保留最有潜力的合格候选人。
鉴于我之前在带回家挑战上的负面经历。我决定，这个最大化的价值应该是一个可以持续一个小时的带回家的东西，并且对于一个合格的候选人来说足够简单。
我们的目标是我们雇佣的候选人对主动性和勇气有所了解。
我在 Typeform 上主持了“带回家”项目，这样我就可以在 Indeed 上把链接发给不同的候选人，并在“带回家”项目中创造了三个不同的问题。在一天结束时，我们在做了 200 多份简历审查后，向 100 名候选人发送了带回家的简历，并收到了 70 份作业，带回家的完成率约为 70%。
来自带回家挑战的整体大图。
建造带回家的房子
你大概可以猜到，70 个带回家的作业仍然是很多考生要复习的。我们的问题是在评估技能时继续筛选候选人。
我们分两部分来处理这个问题，并提出了三个问题，每个问题都有不同的目的。
第一个问题是关于基础分析的。
带回家挑战的第一个问题。
对于任何曾经远程使用过分析的人来说，我认为这个问题是免费的。然而，只有 58%的候选人答对了这个问题。
带回家挑战第一题的结果。
对于那些答错这个问题的人来说，他们剩下的带回家的挑战就被丢弃了。这里的一个错误答案表明，候选人要么不够善于观察，不关心带回家的东西，要么就是不擅长分析。这里需要一种过滤机制来减少候选字段。
带回家挑战的第二个问题。
第二个问题基于 SQL。这个问题旨在测试候选人是否能够使用连接编写一个相对简单的查询。如果他们不能写出正确的 SQL，那么他们就不能从我们的数据库中提取数据。这个问题也相对容易得分。我在采访查询中已经有了示例表。我只需在我们的编辑器中运行他们的解决方案，如果返回正确的结果，那么他们就通过了这一轮 SQL。
唯一的问题是有不同的 SQL 引擎，这意味着许多人答对了问题，但遗漏了一些语法。如果答案大部分都在那里，我就给他们及格，所以大约一半的候选人答对了这部分问题。
带回家挑战的第三个问题。
最后，最后也是最重要的问题是产品分析案例问题。
这个问题让我能够在几个关键方面对候选人进行评估。
- 他们能提出对案例研究有意义的指标和分析吗？
- 他们了解内容业务框架内的分析吗？这个问题很棒，因为它涉及到一个大家都知道的产品——Youtube——的案例研究，并且是关于一个与采访查询几乎相似的情况。不，我们没有创作者，但我们有很多内容，我想知道候选人会如何看待企业内部的内容。
- 最后，我想了解他们的技术概念沟通水平。沟通和结构都是数据科学家需要了解的最重要的技能。如果我不能和你交流，那我就不能和你一起工作。
这里有一个好答案的例子。候选人描述了他们想要使用的指标，概述并阐明了谁是业余和超级明星创作者，并了解如何建立两个时间表来比较这些指标。
让我们首先指定一个 6 个月到一年的时间段来分析和移除所有那些在该时间段内不活动的通道。然后，让我们将订户数量超过 100，000 的所有频道指定为超级明星 youtubers，其余频道指定为业余爱好者。
指标 1:业余 YouTube 用户在时间段内的平均增加量/时间段开始前的用户数/超级明星 YouTube 用户的平均增加量(时间段内的用户增加量/时间段开始前的用户数)。
第一度量应该优选地高于 1，因为较小的频道比较大的频道更容易增长，但是小于 1 的值表示只有超级明星频道在增长。
指标 2:(比率(建议标签页中的业余频道视频/业余频道视频总数)/比率(建议标签页中的巨星频道视频/巨星频道视频总数))。
这个指标应该更接近于 1，因为这表明 youtube 同等地推荐这两种类型的频道。
指标 3:(比率(通过 Youtube 搜索获得的业余频道观看次数/业余频道观看总次数)/比率(通过 Youtube 搜索获得的超级明星频道视频/超级明星频道观看总次数))。
这个指标也应该接近 1。它指示是否可以通过 youtube 搜索访问较小的频道。
这里有一个不好的答案。候选人基本上什么也没说。什么是趋势视频？什么是类别？我不会带着任何洞察力离开。
首先，我将采用“趋势视频”、“浏览量”和“类别”等指标。通过分析，找出每个类别中业余爱好者和超级明星的数量。如果在一段时间内进行相同的分析，我们就可以确定趋势。
正如你在上面看到的，候选人是否通过产品面试问题的一个主要因素是基于他们的条目的长度。这就是我们想要的！我们需要更多的想法——尽管是好的想法——最终需要有人能够思考这个问题，并找到用数据解决问题的方法。(有关如何获得数据科学案例研究的更多信息，请点击此处查看我们的文章！)
有了这个收获，我们将候选人名单从最初的 100 名候选人缩小到 10 名，在每个后续的面试问题中排除 50%的候选人。我们没有给 100 个不同的候选人打电话，也没有根据经验给前 10 名打电话，而是不与任何人交谈就找到了最合格的候选人。
最终现场数据科学访谈
招聘过程的最后一步是面试每个候选人。对我来说，这可能是最令人惊讶的一步，因为虽然我认为我已经找到了真正合格的候选人，但他们中的许多人并没有那么优秀。(对于数据科学新人，* 下面是 你需要什么才能在数据科学实习面试中取得成功。)*
一些人没有安排面试，因为他们要么找到了另一份实习工作，要么不再感兴趣了。在面对面的面试中，我会根据沟通技巧、对工作的兴趣和案例研究对每位候选人进行评分。此外，我还试图判断候选人本人是否符合从他们带回家的材料中收集的技能评估。
我所问的案例研究是关于改进面试查询每周发送的电子邮件简讯。这与其说是一个真正的面试问题，不如说是数据科学家应该参与的第一个项目。他们在这个面试问题上表现得越好，工作效率就越高。
当我和我最终面试的八个左右的候选人交谈时，他们中的大约一半人都不是很强。他们中的一些人不知道面试查询实际上是做什么的，或者甚至没有注册使用这个网站。其中一个人甚至告诉我，他爸爸帮他做了 SQL 部分。其他弱的候选人只是没有很强的沟通技巧，虽然他们可以在写作部分将想法串在一起，但我意识到面对面的沟通可能更难，因为它需要你在讨论中当场思考。
不过，最终我面试了一位我非常喜欢的候选人，一周后，我给了他机会，他接受了。
注意事项和提示
以下是这一过程的要点。
在招聘时，确保你的时间得到有效利用。
招聘人员和招聘经理把时间浪费在给候选人发电子邮件、安排面试和安排带回家的任务上。重要的是要有一个精简的招聘流程，你可以在未来为每个候选人复制。从现在开始，无论我们何时雇佣任何人，我都将使用这一流程，因为我觉得我最大限度地有效利用了我的时间，并且仍然收到了优秀的候选人。
定义角色并预先设定期望。
发挥你作为雇主的优势。我在面试中告诉每个候选人，与大公司相比，我们不能支付那么多，但他们会得到直接的指导，他们的贡献实际上会影响面试提问。作为一家初创公司，我们的弱点最终也成为了我们的优势，我们得到了一位出色的实习生。
你知道有多少无用的噪音。一开始，我在职位描述的底部添加了一段简单的文字，写道:如果你看到这段文字，请在你的简历旁边的文本框中写下“我阅读了职位描述”。只有五个人最终把它写了进去。许多候选人最终并不在乎他们申请的每一份工作。如果你付出一点点努力，你一定能脱颖而出。
对于雇主来说，如果你有兴趣了解更多关于有效雇用数据科学家的信息，请联系我们，了解更多关于面试查询如何提供帮助的信息。
感谢阅读！
- 如需更多独家面试解说，请查看 面试查询 ！
- 查看我的 Youtube 频道 获取更多面试指南，以及解决问题的技巧&。
- 在面试查询博客上找到更多面试指南，如 罗宾汉数据科学家面试 *和字节跳动数据科学家面试*。****
原载于 2020 年 11 月 16 日 https://blog.interviewquery.com。**
如何雇佣令人惊叹的数据科学家
数据科学的业务
如何雇佣和留住优秀的数据科学家
在桌子的两边，面试数百名候选人以及被面试后，我得出了我喜欢和不喜欢这个过程的原因。
第一步:知道你需要什么
很多时候，我遇到过不确定自己需要什么的企业或公司。他们想利用数据做些事情，但不清楚他们需要谁或需要什么。这是首先要解决的问题。
就数据而言，清楚地了解自己的成熟度。如果你的公司仍然在使用 excel 电子表格，也许是一个小型数据库，你可能不需要一个具有多年后端经验的深度学习工程师。你可能会从初级数据分析师那里获得很多价值。
知道你需要什么是最重要的，这不仅是为了招聘好员工，也是为了确保你雇佣的人留在你的公司并获得宝贵的经验。招聘是一个耗时且昂贵的过程——所以你想把它做好。
如果你不确定你需要什么，有很多方法可以解决这个问题。你可以得到一个外部评估。做市场调研。采访数据科学家只是为了获取信息——他们可以把你引向正确的方向。
照片由克里斯蒂娜@ wocintechchat.com在 Unsplash 上拍摄
第二步:正确处理流程
这可能有点争议，但我不认为用不相关的脑筋急转弯来测试数据科学家是找到合格候选人的最佳方式。在一个完美的世界中，这个过程应该是这样的:
- 初始屏幕
你想得到这个人的照片，看看他们是否合适。询问他们的背景，兴趣，特长。这些符合贵公司目前的需求吗？
在技术筛选之前，如果你打算问算法问题，或者做一个现场编码评估，让它相关，并在之前提供“研究领域”。如果你真的觉得移位和这个角色相关[ 95%的可能性不是]，提前让他们知道你的测试包括移位。
向贵公司的技术屏幕发送电子邮件介绍示例。
嗨[候选人]！
我们很高兴在[日期]与您会面并了解您的更多背景。
我们希望您能与[您的面试官]一起完成一次技术面试。
在这次技术面试中，你将被要求对[x]个问题进行编码。我们花时间创造了模拟你日常工作的现实问题，而不是问你一些毫无意义的脑筋急转弯。我们认为重要的是我们的工程师能够批判性地思考，并在我们实际解决的问题上展示他们的技能。
问题可能包括以下特定主题【帮助缓解压力，给你一个候选人的关注点】:
[一些例子]
-如何使用ε贪婪方法训练强化学习算法
-使用您最喜欢的深度学习库创建一个简单的多层感知器
-在你最喜欢的深度学习库中编写自定义损失函数
我们也可能会问一些关于以下库的问题:numpy(数组和造型)、pandas(数据帧、系列)、PyTorch (…)等
期待与你交谈，
令人敬畏和体贴的公司
2.技术屏幕
第二次面试，你深入了解他们最喜欢的算法和工作经历，而不是你的。
他们理解数学吗？他们能描述算法是如何解决问题的吗？他们能从头到尾完成一个项目吗？他们应该有几个例子。
如果您计划进行现场编码评估，请按照上面给出的介绍来做。不要指望一个高级工程师会钻研他们 10 年前学过的每一门算法。给出具体和相关的重点领域，跳过脑筋急转弯。
3.作业
这就是这个过程与今天的标准不同的地方。我非常喜欢这一点，因为它提供了一个展示多种不同技能的候选人。作业应该是开放式的，包括建模部分。这项作业还会向你展示候选人的工作风格和演讲风格。他们检查数据吗？最终的演示或输出是否经过润色？清楚了吗？
这比现场编码评估要好得多，原因如下:
- 白板编码问题(或类似 coderpad 的东西)可能会很紧张。虽然工作中会有压力，但我认为这种形式可能会阻碍找到有才华的工程师
- 在准备这些面试的过程中，我发现自己更多地关注无关的算法理论(已解决的问题)，并试图研究不同的脑筋急转弯，而不是让我擅长我所做的事情的实质——主动机器学习研究和实现
为了确保候选人确实做了工作，最后阶段的一次面试应该是工作产品的演示，候选人在演示中回顾他们所做的工作。
4.超级日
超级日是对团队的检查——确保你的高级工程师和管理团队都有机会见到候选人，并对他们感到舒适。这对其他工程师来说是一个“彻底检查”候选人的机会，确保他们能够处理智力辩论，并展示他们的能力。
同样，您希望让候选人实际回顾他们在现场环境中执行的项目。这是为了认可他们为你的公司付出的努力，并了解他们是如何思考问题的。
他们应该能够自如地回答关于他们所选择的方法的问题。
我不喜欢在超级日进行编码评估。尽早完成这一部分。超级日是你的工程师/团队了解这个人的时候，并询问相关的问题。
尽早进行技术筛选。在玩具问题上的糟糕表现可能会分散应聘者的注意力，从而在不相关的面试中造成糟糕的印象。
我敢保证，你的候选人仍在反思，当他们应该批判性地思考你的公司、你的团队、提问、谈论他们的背景等问题时，他们在寻找最接近的回文惊喜问题方面做得不够好。
就是这样。你应该知道这个人是否适合你的公司。到了这一天，你应该很有信心这个人会非常适合这家公司。
希望这能帮助你创建一个伟大的数据科学团队。
感谢阅读！
如果您喜欢这篇文章，您可能也会喜欢:
分解创建您的组织的步骤 AI CoE
medium.com](https://medium.com/swlh/the-3-steps-to-create-a-world-class-artificial-intelligence-center-of-excellence-4faaa6a87dd6)
如何托管自己的 Python 模型
如何设置本地私有服务器并在其上部署端点。
在使用机器学习进行部署的主题下，有许多事情需要考虑，许多不同的选项将为您提供不同的结果。首先，有很多标准的 VPS 和半共享主机可以用来部署你的模型。对于初学者来说，这些通常不是很好的选择，但是在使用什么样的应用程序以及如何安排文件系统方面允许更多的自由。当然，另一个选择是像 AWS 或 Google Cloud 这样的部署解决方案。虽然这两个都是很好的选择，但是它们都不能给你性价比和自己托管服务器的便利性。虽然自己托管服务器当然有缺点，但如果你碰巧有良好可靠的互联网和一台额外的计算机，这肯定是一个很好的选择。
设置
当你运行自己的服务器时，需要考虑的一件非常重要的事情是它实际上要在什么上面运行。您可能不会像许多计算狂人那样在自己的壁橱里放着一台成熟的服务器，但这没关系。对于大多数应用程序，您不太可能需要 128GB 的内存和高得离谱的内核数处理器。例如，如果您希望只部署几个端点，也许是提供一些静态文件，那么您可以选择任何内存超过 1GB 的计算机。
也就是说，你要考虑的另一件事是热量。你住的地方有多热，你有中央空调吗？保持服务器组件冷却很重要，服务器处理器会产生大量热量，需要比普通计算机更多的环境冷却。因此，您甚至可以拥有一台服务器，但由于环境温度过高而不想使用它。
你可能需要考虑的另一件事是功耗。毕竟，如果您没有使用服务器的所有功能，而是运行一个高 TDP 处理器，自己托管它甚至可能不具成本效益——您可能最终要支付比您预想的更多的电费。
当你不需要那么多能量的时候，我有一个很好的建议，那就是使用笔记本电脑。许多人在某个地方都有一台大约 4GB 内存的旧 I-7 或 I-5 笔记本电脑，对于一台可以执行大量操作的简单服务器来说，这是一个非常好的选择，而且非常便宜。与台式机处理器相比，笔记本电脑处理器的 TDP 要低得多，因此它们产生的热量和消耗的电能也少得多。
域、名称服务器和端口转发
为了向万维网提供任何类型的文件，你需要做的第一件事是设置端口转发。端口转发允许您到 internet 服务提供商和网络的本地连接不仅从网络传入，而且传出到网络。网页和网站总是配置为在端口 80 上运行。例如，有时端口 80 充当端口 8000 的套接字端口，这正是您的模型可能使用端口的方式。
默认网关是所有其它设备都将使用的默认设备 IP，以便通过它到达您的 ISP。换句话说，网络的默认网关是路由器的本地 IP 地址。在 Linux 上，您可以使用
**route -n**
在 Windows 上，您首先需要以管理员身份运行命令提示符。接下来，您只需输入
**ipconfig**
进入命令提示符，返回，然后在提供的值列表中搜索默认网关。获取网络的默认网关，并将其粘贴到网络浏览器中。这将把您带到路由器的登录页面，您现在当然需要登录。
登录后，您的路由器设置几乎肯定会发生变化，因此很难解释每台路由器上的端口转发位置。通常，它要么在它自己的选项卡中，要么在“高级”选项卡下。
我不太清楚为什么，但出于某种原因，您的网络可能会请求一个应用程序名称来转发您的端口。这可以是任何东西，应用程序叫什么并不重要。我想这唯一的目的是为了组织。您需要转发端口 60–82 和端口 8000–8030。至于 TCP 与 UDP 的问题，TCP 速度较慢，但占用的带宽要少得多，而 UDP 速度很快，但如果使用不当，会导致不稳定的连接。明确地说，UDP 通常用于需要高 ping 连接的东西，如视频游戏和类似的东西。所以对于托管网站来说，使用 TCP 可能是个好主意。不过，我通常只转发 TCP 和 UDP，因为该协议在这方面并不真正有效。协议是由应用程序决定的，而不是由路由器决定的，所以在这里选择 TCP 或 UDP 只会限制您使用其中一个的能力。
接下来，你当然需要一个域名。这是一个不言自明的过程—
购买域名。
或者，您也可以始终使用服务器的公共 IP 地址作为您的域。接下来你需要做的是把你的域名服务器从你的路由器上移除。这将让域注册表知道将传入的连接发送到哪里。你需要把它放入你选择的域名注册网站的域名服务器中。
设置端点
在开始实际创建和部署端点之前，测试您的服务器以查看它是否真正工作是很重要的。在这篇文章中，我将使用 Ubuntu，因为它绝对统治着服务器市场，而且与 RHEL 或 Arch 服务器相比，它对初学者来说是友好的。将我们的新服务器连接到 wifi 后，我们将需要使用 dig 或 curl 来获取我们的公共地址。dig 的问题在于它通常依赖于域名服务器，这些服务器可能会根据你的硬件地址而不是 IP 地址来识别你，所以我通常会这样做:
curl ifconfig.co
现在我们有了服务器的 IP 地址，将其复制到另一台计算机上。这是一个公共 IP 地址，所以它不能通过本地连接工作。换句话说，我们没有向本地服务器发出请求，所以我们不会得到本地服务器，所以计算机是否在同一个网络上并不重要，如果端口没有正确转发，这将不起作用。现在回到服务器上运行
python -im http.server
这将启动一个开发服务器，它将静态地提供存储在您机器上的文件。现在继续前进，导航到您的另一台计算机上的公共 IP 地址，如果您最终在您的服务器上的~/中，那么恭喜您！
为了设置你的服务器的虚拟部分，你首先需要知道你要做什么。两个最大和最常用的选项是 NGINX 和 Apache。我不久前发表了一篇文章，对这两者进行了比较，如果你想单独了解它们以做出决定的话:
你应该使用哪个网络服务器？
medium.com](https://medium.com/chifi-media/nginx-or-apache-a3bb7ec4ca68)
您还需要使用 Supervisor 并设置一个来运行您的服务器。我不打算在这里包括配置，因为这篇文章更多的是基于网络的，但这里有一些文章将带您了解如何使用 NGINX 和 Supervisor 部署 Gunicorn3 (Python 生产服务器)和 Genie (Julia 生产服务器):
应用程序部署通常会带来意想不到的后果和错误。部署可以是制定或…
towardsdatascience.com](/deploying-flask-with-gunicorn-3-9eaacd0f6eea) [## 带精灵的 A-Z Julia 端点
介绍如何使用 Genie web-framework 的虚拟环境设置。
towardsdatascience.com](/a-z-julia-endpoint-with-genie-a2e0c2f1c884)
如果您想提供静态文件，我也可以满足您的要求:
对于那些使用端点和可执行服务器的人来说，有时可能会注意到一个特定的任务不需要…
medium.com](https://medium.com/@emmettgb/how-to-serve-static-files-with-an-ubuntu-vps-81e8f3a57cc7)
结论
在这个项目中，我要做的最后一步是在两台机器上安装 Openssh
(my daily machine runs Fedora)
sudo dnf install openssh-client(The server runs Ubuntu)
sudo apt-get install openssh-server
这将允许您在服务器没有连接到任何外围设备的情况下连接到服务器。这意味着你将能够登录到它，而不需要实际使用计算机本身，这是非常方便的！另一件很酷的事情是，您还可以使用 SSH 从世界任何地方登录到您的公共 IPV4 地址，只要 SSH 端口(端口 22)也被转发。
我要说的是，根据你的情况，以及你到底想用你的服务器做什么，在你的路由器上运行你自己的服务器可能是一个奇妙的和非常划算的方法。运行您自己的服务器允许您管理自己的硬件，而不是租用它。使用低 TDP 处理器确实可以为您节省一些钱，因为您可能每个月都要花费几分钱来维持网站和终端的运行。需要更多储物空间？买一个更大的硬盘。需要更多内存？多买内存。这很简单，省去了一个通常不受欢迎的中间人，他在幕后操纵你的网站，给你自由和灵活性，让你可以把你的网站带到任何地方！
如何用 Python 识别日本烛台图案
克里斯·利维拉尼在 Unsplash 上的照片
日本烛台是最重要的工具之一，用于自由交易或量化交易。它们是被称为价格行动的特殊交易风格的第一个例子。
让我们看看它们是什么，以及如何在 Python 中使用它们。
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
日本的烛台有哪些？
日本烛台是一种特殊的图表类型。对于每个时间段，它们显示最高价、最低价、开盘价和收盘价。
让我们看一个示例图表:
日本烛台图表示例。图片作者。
每一天都用一个叫做蜡烛的符号来代表。每根蜡烛由一个实体、一个上影和一个下影制成。
作者图片
蜡烛有一种颜色。如果收盘价高于开盘价，它们通常是白色、绿色或蓝色的(看涨蜡烛线)。如果收盘价低于开盘价，它们就是黑色或红色的(看跌蜡烛线)。
它们是如何使用的？
这种图表非常有用，因为它在一个简单的符号中给了我们很多信息，但最重要的用途与模式有关。模式是蜡烛线的组合，显示一个特殊的图形形状，它们对发现价格反转很有用。让我们看看其中的一些。
在 Python 中识别模式
下面是最常见模式的列表，Python 代码可以让我们识别它们。
你可以在我的 GitHub 储存库中找到完整的代码:https://GitHub . com/gianlucamalato/machine learning/blob/master/candlesticks . ipynb
首先要安装 yfinance 库，下载市场数据。
!pip install yfinance
然后我们可以导入熊猫和金融。
import pandas as pd
import yfinance
对于这个例子，我们将使用过去 5 个月的标准普尔 500 每日数据。
ticker = yfinance.Ticker("SPY")
df = ticker.history(period = '5mo')
现在，我们将创建与模式一样多的列，每一列都有一个布尔值，如果模式出现则为真，否则为假。
所以，我们必须在历史数据中扫描。我们将使用 for 循环。我们计算真实的身体宽度和烛光范围。
for i in range(2,df.shape[0]):
current = df.iloc[i,:]
prev = df.iloc[i-1,:]
prev_2 = df.iloc[i-2,:] realbody = abs(current['Open'] - current['Close'])
candle_range = current['High'] - current['Low'] idx = df.index[i]
现在让我们看看一些模式及其代码，它们必须包含在循环的中。
看涨摇摆
看涨摆动是一个简单的 3 蜡烛线模式。第二根蜡烛线在三根蜡烛线中最低。蜡烛的颜色无关紧要。这是一个信号，表明价格可能上涨。
作者图片
所以，代码很简单:
df.loc[idx,'Bullish swing'] = current['Low'] > prev['Low'] and prev['Low'] < prev_2['Low']
看跌摇摆
看跌的波动与看涨的波动相反。它由三根蜡烛组成，第二根蜡烛最高。蜡烛的颜色无关紧要。
作者图片
这是代码:
df.loc[idx,'Bearish swing'] = current['High'] < prev['High'] and prev['High'] > prev_2['High']
多头针棒
针条是非常频繁和强大的模式。众所周知，针棒有很长的影子和很小的实体。非常重要的一点是，针棒不仅仅是蜡烛，它还必须从周围的价格活动中突出出来。所以，相对于前一根蜡烛线，一根看涨的针棒线必须有一个更低的低点。
我们可以定义一个“小”的真实物体为宽度小于烛光范围除以 3 的真实物体。一根看涨的针棒将会把真实的主体放在蜡烛的上半部分。蜡烛的颜色无关紧要。
作者图片
下面是多头针棒的代码:
df.loc[idx,'Bullish pinbar'] = realbody <= candle_range/3 and min(current['Open'], current['Close']) > (current['High'] + current['Low'])/2 and current['Low'] < prev['Low']
轴承销杆
看跌的针柱就像看涨的针柱一样，但是真正的主体现在位于蜡烛线的下半部分，并且比之前的蜡烛线高。
作者图片
代码如下:
df.loc[idx,'Bearish pinbar'] = realbody <= candle_range/3 and max(current['Open'] , current['Close']) < (current['High'] + current['Low'])/2 and current['High'] > prev['High']
内部酒吧
酒吧内部是由两根蜡烛组成的图案。第二根蜡烛完全包含在第一根蜡烛的范围内。颜色无关紧要。
这种模式显示了波动性的收缩，这可能是一个强大的方向性爆炸的前奏。
作者图片
代码如下:
df.loc[idx,'Inside bar'] = current['High'] < prev['High'] and current['Low'] > prev['Low']
外部酒吧
外侧杠与内侧杠相反。蜡烛系列完全包括之前的蜡烛。
作者图片
代码如下:
df.loc[idx,'Outside bar'] = current['High'] > prev['High'] and current['Low'] < prev['Low']
看涨吞没
多头吞没是一种强势的多头形态。这是一个外面的酒吧，有一个巨大的、乐观的真实身体。我们可以把“巨大”定义为一个真实的物体，它的宽度占蜡烛线的 80%以上。
作者图片
代码如下:
df.loc[idx,'Bullish engulfing'] = current['High'] > prev['High'] and current['Low'] < prev['Low'] and realbody >= 0.8 * candle_range and current['Close'] > current['Open']
熊市吞没
看跌吞没是看涨吞没的反义词。一根巨大的熊蜡烛完全吞没了前一根蜡烛。
作者图片
代码如下:
df.loc[idx,'Bearish engulfing'] = current['High'] > prev['High'] and current['Low'] < prev['Low'] and realbody >= 0.8 * candle_range and current['Close'] < current['Open']
完整的代码
下面是完整的代码。请记住，我们必须用错误来填补空白。
for i in range(2,df.shape[0]):
current = df.iloc[i,:]
prev = df.iloc[i-1,:]
prev_2 = df.iloc[i-2,:]realbody = abs(current['Open'] - current['Close'])
candle_range = current['High'] - current['Low']idx = df.index[i]
# Bullish swing
df.loc[idx,'Bullish swing'] = current['Low'] > prev['Low'] and prev['Low'] < prev_2['Low']# Bearish swing
df.loc[idx,'Bearish swing'] = current['High'] < prev['High'] and prev['High'] > prev_2['High']# Bullish pinbar
df.loc[idx,'Bullish pinbar'] = realbody <= candle_range/3 and min(current['Open'], current['Close']) > (current['High'] + current['Low'])/2 and current['Low'] < prev['Low']# Bearish pinbar
df.loc[idx,'Bearish pinbar'] = realbody <= candle_range/3 and max(current['Open'] , current['Close']) < (current['High'] + current['Low'])/2 and current['High'] > prev['High']
# Inside bar
df.loc[idx,'Inside bar'] = current['High'] < prev['High'] and current['Low'] > prev['Low']
# Outside bar
df.loc[idx,'Outside bar'] = current['High'] > prev['High'] and current['Low'] < prev['Low']
# Bullish engulfing
df.loc[idx,'Bullish engulfing'] = current['High'] > prev['High'] and current['Low'] < prev['Low'] and realbody >= 0.8 * candle_range and current['Close'] > current['Open']# Bearish engulfing
df.loc[idx,'Bearish engulfing'] = current['High'] > prev['High'] and current['Low'] < prev['Low'] and realbody >= 0.8 * candle_range and current['Close'] < current['Open']df.fillna(False, inplace=True)
我们的数据框最终将是这样的:
根据列的值过滤行将使我们回测任何使用这种模式的交易策略。
结论
日本烛台模式对于发现趋势反转非常有用。本文中没有描述许多不同的模式，但是在这里您可以找到最重要的模式。这种模式的 Python 实现对任何想开始算法交易冒险的人都非常有用。
如何在人群中识别潜在客户？
数据科学
邮购销售公司的真实数据科学任务
介绍
在这个项目中，德国的一家邮购销售公司对确定普通人群的细分市场感兴趣，并以此作为其营销增长的目标。人口统计信息(由 Arvato Finacial Solutions 通过 Udacity )已提供给普通大众以及邮购公司的老客户以建立公司客户群模型。目标数据集包含邮寄营销活动目标的人口统计信息。
目标是确定哪些人最有可能响应营销活动，成为邮购公司的客户。
数据描述
的。由于与 Arvato 签订了保密协议，因此没有提供该项目的 csv 文件。以下是所使用的文件:
- uda city _ AZDIAS _ 052018 . CSV:德国一般人口的人口统计数据；891 211 人(行)x 366 个特征(列)
- uda city _ CUSTOMERS _ 052018 . CSV:邮购公司客户的人口统计数据；191 652 人(行)x 369 个特征(列)。
- uda city _ MAILOUT _ 052018 _ train . CSV:作为营销活动目标的个人的人口统计数据；42 982 人(行)x 367 人(列)。
- uda city _ MAILOUT _ 052018 _ test . CSV:作为营销活动目标的个人的人口统计数据；42 833 人(行)x 366 人(列)。
- DIAS Attributes—Values 2017 . xlsx:文件中按字母顺序描述的列的详细信息。要了解更多功能，请点击此处。
数据预处理
- 记忆力减退。CSV(uda city _ AZDIAS _ 052018)保存普通人群人口统计数据的文件大小为 2.5 GB，因此我编写了一个简单的函数来更改数据类型(int64 到 int16)，并减少了 78%的内存使用。要了解更多关于功能和内存缩减的信息，请点击此处。
- 数据理解:所有的数据文件都有相同的特征，所以我决定用uda city _ AZDIAS _ 052018 . CSV文件去理解人口统计数据。我使用了DIAS Attributes—Values 2017 . xlsx文件来理解每个值对列的意义。请参见下图中的示例:
这里，属性 AGER_TYP 描述了最佳 AGER 类型。如果您看到上面的值列，它的值为 -1，0，，这意味着含义未知，无法进行分类。进一步检查发现有意义的属性‘未知’/‘无分类’为缺失值。所以，我决定用 nan 来填充这样的值。当然，有许多属性的值是未知的。欲知详细分析，请点击此处。
3。处理缺失值:有 366 个特性，所以我决定在理解数据(来自第 2 部分)之后首先检查列，因此，我计算了每列中缺失值的百分比，并决定阈值为 30%，也就是说，如果列包含的缺失值超过 70% ，我将简单地删除这些列。
通过进一步检查，我发现以 D19 开头的属性被删除了。D19 当我们在DIAS Attributes-Values 2017 . xlsx文件中查找时，显示它包含交易数据(例如，基于产品组指南的交易活动)
我做的下一件事是按行查找缺失值，我决定删除包含超过 15 个缺失值的行。我在这里使用 Q3–1.5 iqr 来决定阈值 15。
为简单起见，其余的缺失值用平均值估算。
4.特征工程:有很多分类变量，所以如果它们少于 10 级，我就用它们创建虚拟变量。既然所有的特征都是数字，我们可以应用任何机器学习算法。但在此之前，我应用了 StandardScaler() 对所有列进行了变换。
客户细分
这里，主要目标是使用无监督学习方法来分析现有客户和一般人群的属性，以创建客户细分。该分析描述了普通人群中更有可能成为邮购公司主要客户群的部分，以及普通人群中不太可能成为主要客户群的部分。
因此，我使用了 PCA 技术来捕捉数据中的最大方差并降低数据的维度。我决定了一个阈值 50% 。
366 个特征中的 36 个能够捕捉 50%的变化。遵循主成分分析维度 0:
解读第一个 PCA 组件(10 大特性):
- plz 8 _ BAUMAX:plz 8(pos)内最常见的建筑类型——主要是> 10 户家庭住宅
- plz 8 _ ant G4:plz 8(pos)高份额> 10 户住宅数量
- plz 8 _ ant G3:plz 8(pos)中 6-10 户住宅的数量-高份额
- plz 8 _ ant G1:plz 8(负)低份额 1-2 户住宅数量
- MOBI_REGIO :移动模式(负)——高机动性
所以这个群体是高流动性，大家庭区域，拥挤区域，低收入。
接下来，我使用经过主成分分析的数据来应用 k-means 聚类，并确定客户细分群体。我用肘法来决定集群的数量，我决定用 10。
我对邮购公司客户的人口统计数据做了同样的转换uda city _ CUSTOMERS _ 052018 . CSV .
在这里，我们可以看到属于集群 1 和集群 8 的人是响应邮购公司的营销活动并成为客户的人。所以，营销团队应该关注这样的群体。好消息是德国有很多人(1 和 8 的蓝条)属于这些群体。
营销预测-监督学习模型
这里，我们将使用包含作为营销活动目标的个人的人口统计数据的数据集。训练数据集具有客户的响应，我们将使用 ML 模型来学习参数并预测测试数据中客户的响应。
- uda city _ MAILOUT _ 052018 _ train . CSV:作为营销活动目标的个人的人口统计数据；42 982 人(行)x 367 人(列)。
- uda city _ MAILOUT _ 052018 _ test . CSV:作为营销活动目标的个人的人口统计数据；42 833 人(行)x 366 人(列)。
数据准备
我已经使用了相同的清理功能，它是我在分段报告中使用的。我用平均值填充了数字列中缺少的值，并为分类列创建了虚拟变量。我还执行了一个 scaler 转换，因为我想检查不同 ML 算法的性能。但是，数据集中的类是一个不平衡，训练数据中 98% 的响应是负的， 2% 是正的，所以用召回(识别潜在客户)作为衡量标准是不正确的。因此，我使用 ROC AUC 作为评估性能的指标。我还从客户数据集中添加了额外的功能。
test['CUSTOMER_GROUP'] = test['CUSTOMER_GROUP'].apply(lambda x:1 if x=='SINGLE_BUYER' else 0)
test['PRODUCT_GROUP1'] = test['PRODUCT_GROUP'].apply(lambda x:1 if 'FOOD' in x else 0)
test['PRODUCT_GROUP2'] = test['PRODUCT_GROUP'].apply(lambda x:1 if 'COSMETIC' in x else 0)
表现最好的模型是:
我尝试优化两个模型的超参数，Adaboostclasifer 排在最前面。以下是我使用的参数:
预测竞赛
我向 Kaggle 上举办的比赛提交了我对测试数据的预测，我得到了 0.79459，的分数，仅比排行榜第一名落后 0.016。
特征重要性
D19_SOZIALES :这是与数据字典中没有给出的交易相关的特征，是潜在客户响应营销活动的最重要特征。
结论
我们使用德国的人口统计数据和营销活动的历史客户数据来确定最佳目标人口统计群体，从而减少营销支出。我们成功地应用主成分分析和 K-均值聚类来识别客户群。我们使用带有超参数调整的 Adaboost 分类器来预测和分类客户是否会对营销活动做出反应。详细分析可以在 这里找到 。
如何使用自然语言处理(NLP)识别垃圾邮件？
使用 Python 自然语言处理的垃圾邮件检测
人类掌握了数百万个单词，但从计算上来说:我们如何使用编程技术操纵大量文本？
计算机可以理解普通语言并与人类对话的想法一直是科幻小说的主题。然而，二十世纪上半叶又有一篇经典论文设想由艾伦·图灵(1950)作为计算智能的标志。
本文将关注计算机系统如何使用自然语言处理(NLP)来分析和解释文本。为此，你应该安装自然语言工具包，你可以从http://nltk.org开始安装。在引用的网站上可以找到说明以及需要安装的相关包的细节，包括 Python 本身，它也是免费的。
什么是自然语言处理(NLP)？
自然语言处理(NLP)是人工智能(AI) 的一个子集，它基本上负责机器或机器人对人类语言的理解。
NLP 中的一个重要子主题是【NLU】自然语言理解，原因是它用于理解人类语言的结构和意义，然后在计算机科学的帮助下将这些语言知识转化为基于规则的机器学习算法，这些算法可以解决特定的问题并执行所需的任务。
PYTHON 语言处理
这篇文章的目的是告诉你如何检测垃圾短信。
为此，我们使用来自 UCI 数据集 的数据集，这是一个公共数据集，包含为手机垃圾邮件研究而收集的带 SMS 标签的消息。它有一个由 5.574 条英文短信组成的集合，根据合法(ham)或垃圾邮件进行标记。
因此，我们将训练一个模型来学习自动区分火腿/垃圾邮件。然后我们将使用“测试数据”来测试模型。最后，为了评估我们的模型是否有效，我们将计算准确率、分类报告和混淆矩阵。
探索性数据分析
要开始，我们应该首先导入所有的库，然后加载数据并重命名 names 列:
# Import libraryimport pandas as pd
import numpy as np
import string
import seaborn as sns
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from collections import Counter
from sklearn.metrics import classification_report,confusion_matrix
from sklearn.model_selection import GridSearchCV
%matplotlib inline# Load data
data = pd.read_excel('data.xlsx')# Rename names columns
data.columns = ['label', 'messages']
让我们看看我们的数据描述:
data.describe()
数据描述(图片由作者提供)
请注意，我们的数据包含 5574 条短信的集合，而且我们只有 2 个标签:火腿和垃圾邮件。现在，我们创建一个名为“length”的列，以了解文本消息有多长，然后根据标签绘制它:
data["length"] = data["messages"].apply(len)
data.sort_values(by='length', ascending=False).head(10)
data.hist(column = 'length', by ='label',figsize=(12,4), bins = 5)
长度和标签之间的直方图(图片由作者提供)
请注意，通过直方图，我们已经能够发现垃圾邮件往往有更多的字符。
最有可能的是，您遇到的大多数数据都是数值型或分类型的，但是当它是字符串类型(文本格式)时会发生什么呢？
您可能已经注意到，我们的数据是 string 类型的。因此，我们应该将它转换成一个数字向量，以便能够执行分类任务。为此，我们使用 单词袋 ，其中文本中的每个唯一单词将由一个数字表示。但是在做这个转换之前，我们要去掉所有的标点符号，然后常见的词像:['我'，'我'，'我自己'，'我们'，'我们的'，'我们的'，'我们自己'，'你'，'是'…]。这个过程叫做标记化。在这个过程之后，我们将字符串序列转换成数字序列。
- 去掉所有标点:假设我们有下面这句话:
*** * * * * * * * * 大家好！！！很高兴遇见你*******
而且我们要去掉！！！和。****
首先，我们加载导入字符串库，并执行以下操作:
message = "Hi everyone!!! it is a pleasure to meet you."message_not_punc = []for punctuation in message:
if punctuation not in string.punctuation:
message_not_punc.append(punctuation)# Join the characters again to form the string.
message_not_punc = ''.join(message_not_punc)
print(message_not_punc)**>>> Hi everyone it is a pleasure to meet you**
2.删除常用词:****
为此，我们使用 nltk 库，即 nltk.corpus 中的导入停用词****
重要的是要知道停用词支持 23 种语言(这个数字必须是最新的)。在这种情况下，我们使用英语:
from nltk.corpus import stopwords# Remove any stopwords for remove_punc, but first we should to transform this into the list.message_clean = list(message_not_punc.split(" "))# Remove any stopwordsi = 0
while i <= len(message_clean):
for mess in message_clean:
if mess.lower() in stopwords.words(‘english’):
message_clean.remove(mess)
i =i +1
print(message_clean)**>>> ['Hi', 'everyone', 'pleasure', 'meet']**
因此，通过步骤 1 和 2，我们可以创建以下函数:
def transform_message(message):
message_not_punc = [] # Message without punctuation
i = 0
for punctuation in message:
if punctuation not in string.punctuation:
message_not_punc.append(punctuation)
# Join words again to form the string.
message_not_punc = ''.join(message_not_punc)
# Remove any stopwords for message_not_punc, but first we should
# to transform this into the list.
message_clean = list(message_not_punc.split(" "))
while i <= len(message_clean):
for mess in message_clean:
if mess.lower() in stopwords.words('english'):
message_clean.remove(mess)
i =i +1
return message_clean
现在，我们可以通过以下方式将上述函数应用于我们的数据分析:
data['messages'].head(5).apply(transform_message)>>>
0 [Go, jurong, point, crazy, Available, bugis, n...
1 [Ok, lar, Joking, wif, u, oni]
2 [Free, entry, 2, wkly, comp, win, FA, Cup, fin...
3 [U, dun, say, early, hor, U, c, already, say]
4 [Nah, dont, think, goes, usf, lives, around, t...
Name: messages, dtype: object
…向量化…
请注意，我们将消息作为令牌列表。因此，下一步是将这些消息转换成一个向量。
为此，我们从 Scikit Learn 中使用 计数矢量器 。CountVectorizer 将文档集合转换为令牌计数数组。如果你想看 Python 中 countvectorizer 的例子，我们邀请你阅读下面这篇文章:Python 中的 count vector izer
首先，我们从 sklearn learn 导入计数矢量器:
from sklearn.feature_extraction.text import CountVectorizer
CountVectorizer 有很多参数，但是我们只使用“ analyzer ”，这是我们自己之前定义的函数:
vectorization = CountVectorizer(analyzer = transform_message )X = vectorization.fit(data['messages'])
现在，我们应该将消息的整个数据帧转换成向量表示。为此，我们使用变换函数:
X_transform = X.transform([data['messages']])print(X_transform)
>>> : :
(0, 11383) 9
(0, 11384) 20
(0, 11385) 14
(0, 11386) 2
(0, 11387) 4
(0, 11391) 11
(0, 11393) 5
(0, 11396) 1
(0, 11397) 1
(0, 11398) 18
(0, 11399) 18
(0, 11405) 2
(0, 11408) 1
(0, 11410) 1
(0, 11411) 8
(0, 11412) 7
(0, 11413) 1
(0, 11414) 1
(0, 11415) 27
(0, 11417) 3
(0, 11418) 104
(0, 11420) 9
(0, 11422) 1
(0, 11423) 7
(0, 11424) 1
TF-IDF
在对我们的数据应用“计数矢量器”之后，我们使用 TF-IDF。你肯定想知道 TD-FT 是什么？我们为什么要使用它？让我给你解释一下:
TF-IDF 是 的缩写逆文档频率 是一个数值度量，表示一个词与集合中的一个文档的相关程度。
TF-IDF 的值与单词在文档中出现的次数成比例地增加，并且被该单词在文档集合中的频率抵消，这允许处理一些单词通常比其他单词更常见的事实。
如何计算 TF-IDF？
TF-IDF 由两项组成:第一项是项频率(TF) ，第二项是**逆文档频率(IDF)**
词频(TF): 衡量一个词在文档中出现的频率，即一个词在文档中出现的次数除以该文档中的总字数:
TF(t) =(术语 t 在文档中出现的次数)/(文档中的总术语数)
逆文档频率(IDF): 衡量一个术语的重要性，计算方法是语料库中文档数量的对数除以特定术语出现的文档数量。
IDF(t) = log_e(文档总数/包含术语 t 的文档数)
更多信息请参考[TF-IDF 是什么意思？”T34](http://www.tfidf.com/#:~:text=TF(t) %3D (Number,terms are considered equally important.&text=IDF(t) %3D log_e(,with term t in it).)
继续我们的代码，我们从 sk learn . feature _ extraction . text 导入 TfidfVectorizer，然后:
*tfidf_transformer = TfidfTransformer().fit(X_transform)*
要一次将整个词袋语料库转换为 TF-IDF 语料库:
*X_tfidf = tfidf_transformer.transform(X_transform)
print(X_tfidf.shape)>>> (5572, 11425)*
分类模型
将特征表示为向量，我们最终可以训练我们的垃圾邮件/垃圾邮件分类器。你可以使用任何分类算法。这里我们用支持向量分类(SVC) 算法。
首先，我们将数据分为训练数据和测试数据。我们采用 80 % (0.80)的训练数据和 30% (0.30)的测试数据，并使用 SVC 拟合模型:
*X_train, X_test, y_train, y_test = train_test_split(X_tfidf, data['messages'], test_size=0.30, random_state = 50)
clf = SVC(kernel='linear').fit(X_train, y_train)*
试验模型
为了测试模型，我们使用之前计算的 X_test:
*predictions = clf.predict(X_test)
print('predicted', predictions)>>> predicted ['spam' 'ham' 'ham' ... 'ham' 'ham' 'spam']*
我们的模型可靠吗？
出现的问题是:我们的模型在整个数据集上可靠吗？
为此，我们可以使用 SciKit Learn 的内置分类报告，它返回 P recision，Recall ，F1-Score以及混淆矩阵 x****
***from sklearn.metrics import classification_report
print (classification_report(y_test, predictions))***
分类报告(图片由作者提供)
***from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_test,predictions))***
困惑矩阵(图片由作者提供)
准确性是了解模型是否有效的好方法，但这不足以说明我们的模型是好的，为此我们使用了分类报告和混淆矩阵。你可以看到获得的结果相当好。
我们完了！！！希望这些信息对您有用。如果您对完整代码感兴趣，可以从下面的链接中获得: 如何使用 NLP 识别垃圾邮件
如何使用基于 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)，以及一些关键技能的出现(c)。
作为一个例子，我统计了合同和固定工作的出现,“高级”一词的出现，以及工作描述中一些关键技能的出现。请注意，如何从简单的词汇分析中，收集关于特定技能重要性的有价值的信息是可能的。
与工资的相关性
我的计划是定义一个数据获取方案，从数百个招聘广告中收集信息，并探索建立回归模型来估计工资的可能性。我正在测试这个想法的可行性，方法是评估所报告的工资信息的质量，并查看任何关键词的出现是否与工资相关。
工作广告页面包含了在一个明确定义的领域中的建议工资范围的信息，这是很容易阅读的。然而，薪水数字经常被替换为“有竞争力的薪水”，“薪水面议”，或类似的表达。在兴趣的情况下，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了解更多关于罗德和他的作品。
浙公网安备 33010602011771号