TowardsDataScience 博客中文翻译 2019（七十一）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

使用 Seaborn 可视化统计图

原文：https://towardsdatascience.com/visualizing-statistical-plots-with-seaborn-6b6e60ce5e71?source=collection_archive---------22-----------------------

这是关于可视化的第二篇文章。你可以阅读第一篇文章，在那里我讨论了使用 matplotlib 进行可视化的基础知识。

概括地说，可视化让我们看到数据是如何分布的，检测异常值，并让我们更有效地传达信息。这就是为什么数据科学家/分析师知道如何可视化以及他们有哪些可用选项非常重要。在本文中，我将介绍如何使用 seaborn 来可视化统计图表。

为此，我们将利用 seaborn 自身的一些数据集。这避免了我们必须下载和导入数据集的麻烦。您可以在这个链接中看到可用数据集的完整列表。

Photo by Luke Chesser on Unsplash

我们将从导入所需的库开始。

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

接下来，让我们加载“虹膜”数据集，看看它。

iris = sns.load_dataset('iris')
iris.head()

Iris dataset

Iris 数据集包含三种不同物种的花的细节。由于这个数据集主要包含数字列，我们将使用它来探索适合数字数据的可视化。

所以我们能做的第一件事是检查任何一列的分布。

sns.set(style = 'darkgrid')
sns.distplot(iris['sepal_length'])

Fig 2

第一行允许您设置图形的样式，第二行构建分布图。这个“distplot”命令在同一个图形中构建直方图和 KDE 图。

但是我们可以选择定制上面的图表，甚至将它们分开。

sns.distplot(iris['sepal_length'], kde = False, bins = 30)

Fig 3

在这里，我们不仅删除了 KDE 图，而且还能够在图中添加更多的箱，以便更好地了解分布情况。这是分别通过“kde”和“bin”参数实现的。

KDE 图可以在 KDE plot 命令的帮助下单独查看。

sns.kdeplot(iris['sepal_length'])

Fig 4

使该图更好的一种方法是能够显示各种数据点的存在，以便更好地理解数据的分布。类似于直方图，但具有小的柱。这是在地毯图的帮助下完成的。

sns.kdeplot(iris['sepal_length'])
sns.rugplot(iris['sepal_length'])

Fig 5

上面的图称为地毯图，给出了点的分布和密度。

仅仅可视化一个变量就够了，如果你想看看两个变量是如何相对于彼此分布的呢？

假设我们想知道花的萼片和花瓣长度之间的关系。在这种情况下，我们可以使用 jointplot 来可视化它。

sns.jointplot(x = 'sepal_length', y = 'petal_length', data = iris)

Fig 6

上面的图不仅给出了联合分布，也给出了沿轴的个体分布。从上图可以看出，除了在较低端，两者之间几乎是线性关系。

joinplot 的一个很酷的特性是能够拟合数据的回归线。

sns.jointplot(x = 'sepal_length', y = 'petal_length', data = iris, kind = 'reg')

Fig 7

通过将' reg '传递给 kind 参数，我们可以添加一条回归线，并将 kde 图添加到边上的直方图中。

最后，如果我们想一次性快速了解全部数据，我们可以使用 pairplot 函数。

sns.pairplot(iris)

Fig 8

唯一要传递的参数是数据集名称，它将自动为数据中出现的所有数字列构建上面的图。它将每一个数字列与其他数字列相对照，有助于快速浏览数据。

但是上面的图仍然缺少一列 species，这恰好是一个分类列。我们可以在此包含关于分类列的信息吗？

sns.pairplot(iris, hue = 'species', palette = 'magma')

Fig 9

在每个单独的图中，分类数据以颜色方案的形式表示。参数“色调”可用于传递此信息，而“调色板”控制绘图的颜色方案。

现在让我们来看看包含更多分类列的可视化数据。为此，我们将使用“提示”数据集。让我们把它装上来看一看。

tips = sns.load_dataset('tips')
tips.head()

Tips data

“小费”数据集包含就餐者支付的小费及其信息，如账单金额、性别、时间等。让我们从观察小费金额的分布及其与总账单金额的关系开始。

sns.distplot(tips['tip'], kde = False, bins = 30)
sns.jointplot(x = 'total_bill', y = 'tip', data = tips, kind = 'kde')

Fig 11

Fig 12

现在让我们看看给的小费是否每天都不同。这可以在箱线图的帮助下完成。

sns.boxplot(x = 'day',y = 'tip',  data = tips, palette = 'coolwarm')

Fig 13

也许我们想通过用餐者的性别进行比较。像在 pairplot 中一样，我们也可以通过“色调”参数来指定

sns.boxplot(x = 'day',y = 'tip',  data = tips, hue = 'sex', palette = 'coolwarm')

Fig 14

这根据性别为每天创建了两个箱线图。

另一种在小提琴的帮助下可视化上述数据的方法。

sns.violinplot(x = 'day',y = 'tip', data = tips, palette = 'rainbow')

Fig 15

小提琴图可以被认为是盒子图和 kde 图的组合。中间的粗线表示四分位数之间的范围，两边都是顶端的 kde。

类似于盒子情节，我们可以用‘性’来创造两个并排的小提琴情节来比较。但在这种情况下我们有更好的选择。

sns.violinplot(x = 'day',y = 'tip',  data = tips, hue = 'sex', split = True, palette = 'rainbow')

Fig 16

通过将“split”指示为 true，我们能够在中心线的每一侧创建两个不同的 kde。这让我们可以并排看到差异，而不会排挤剧情。

之前我们看到，我们能够使用配对图来查看整个数据，并包括一个分类列。但是在这种情况下，我们有多个分类列。这些可以通过小平面网格整合到绘图中。

g = sns.FacetGrid(tips, col="time",  row="smoker")

Fig 17

上面的命令创建了一个 2 x 2 的图来说明“时间”和“吸烟者”之间的四种可能性。对于用餐时间和用餐者是否吸烟的每种组合，都有一个曲线图。

在这些图中，我们可以添加数字数据，并比较它们在上述“时间”和“吸烟者”两列中的差异。

g = sns.FacetGrid(tips, col="time",  row="smoker")
g = g.map(plt.hist, "tip")

Fig 18

我添加了小费值的分布，以观察它们在“时间”和“吸烟者”之间的差异。每个图的上方有一条线，指示它对应的“时间”和“吸烟者”值。

类似地，我们也可以绘制两个数字列，并查看两者之间以及“时间”和“吸烟者”之间的关系。

g = sns.FacetGrid(tips, col="time",  row="smoker",hue='sex')
g = g.map(plt.scatter, "total_bill", "tip").add_legend()

Fig 18

上图显示了小费和账单金额之间的关系，以及“时间”和“吸烟者”之间的关系。此外，每个地块的配色方案也显示了性别。通过使用分面网格，我们可以创建包含多个数字和分类列的图。

最后，我想介绍一下热图和聚类图。

在下图中，我使用了热图来显示所有数值之间的相关性。

sns.heatmap(tips.corr(), cmap = 'coolwarm', annot = True)

Fig 19

命令“tips.corr”给出了所有数值变量之间的相关性。通过将“不能”表示为真，我们也可以在图上得到相关值。

为了构建聚类图，我首先透视小费数据集，以获得不同日期和性别的小费金额。

tip_pivot = tips.pivot_table(values='tip',index='day',columns='sex')

Pivoted table

利用这一点，我可以创建一个关于小费价值和日期之间距离的聚类图。

sns.clustermap(tip_pivot, cmap = 'coolwarm', standard_scale = 1)

Fig 21

因为只有两种性别，所以没有什么可看的。但是在星期几的例子中，我们看到星期六和星期四被组合在一起，表明这两天给小费的数量相似。

上面的聚类图非常简单，因为每个轴上没有很多类别。当有多个允许辨别相似性和模式的类别时，一个聚类图会非常出色。

这涵盖了一些可以使用 Seaborn 构建的统计图和可视化。希望你觉得有用。

你也可以通过 LinkedIn 与我联系。

使用 Matplotlib 和 Gym 绘制优雅的股票交易代理

原文：https://towardsdatascience.com/visualizing-stock-trading-agents-using-matplotlib-and-gym-584c992bc6d4?source=collection_archive---------3-----------------------

我们将扩展我们在上一个教程中编写的代码，以使用 Matplotlib 呈现环境的可视化效果。如果你没有读过我的第一篇文章 从头开始创造定制的健身房环境 ，，你应该停下来先读一下。

如果你对matplotlib库不熟悉，不用担心。我们将检查每一行，以便您可以创建自己的gym环境的自定义可视化。一如既往，本教程的代码将在我的 Github 上提供。

下面是我们将在本文中创建的内容的预览:

如果看起来很复杂，其实也没那么糟糕。只有几个关于每个step的图表更新，注释了一些关键信息。我们开始吧！

股票交易可视化

在上一个教程中，我们编写了一个简单的render方法，使用print语句显示代理的净值和其他重要指标。让我们将这个逻辑转移到一个名为_render_to_file的新方法中，这样我们就可以在必要时将一个会话的交易指标保存到一个文件中。

***def*** _render_to_file(*self*, *filename*='render.txt'):
  profit = self.net_worth - INITIAL_ACCOUNT_BALANCE

  file = open(filename, 'a+') file.write(*f*'Step: {self.current_step}\n')
  file.write(*f*'Balance: {self.balance}\n')
  file.write(*f*'Shares held: {self.shares_held} (Total sold: 
    {self.total_shares_sold})\n')
  file.write(*f*'Avg cost for held shares: {self.cost_basis} (Total 
    sales value: {self.total_sales_value})\n')
  file.write(*f*'Net worth: {self.net_worth} (Max net worth: 
    {self.max_net_worth})\n')
  file.write(*f*'Profit: {profit}\n\n') file.close()

现在，让我们继续创建新的render方法。它将利用我们新的StockTradingGraph类，我们还没有写。我们下一步会谈到这个。

***def*** render(*self*, *mode*='live', *title*=None, ***kwargs*):
  # Render the environment to the screen **if** mode == 'file':
    self._render_to_file(kwargs.get('filename', 'render.txt'))
  **elif** mode == 'live':
    **if** self.visualization == None:
      self.visualization = StockTradingGraph(self.df, title)

    **if** self.current_step > LOOKBACK_WINDOW_SIZE:        
      self.visualization.render(self.current_step, self.net_worth, 
        self.trades, *window_size*=LOOKBACK_WINDOW_SIZE)

我们在这里使用[kwargs](http://book.pythontips.com/en/latest/args_and_kwargs.html)将可选的filename和title传递给StockTradingGraph。如果你不熟悉kwargs，它基本上是一个向函数传递可选关键字参数的字典。

我们还为可视化传递了self.trades,但是还没有定义它，所以让我们开始吧。回到我们的_take_action方法，无论何时我们买入或卖出股票，我们现在都要将交易的细节添加到self.trades对象中，在我们的reset方法中我们已经将它初始化为[]。

**def** _take_action(self, action):
  ... **if** action_type < 1:
    **...
**    
    **if** shares_bought > 0:
      self.trades.append({'step': self.current_step,
        'shares': shares_bought, 'total': additional_cost,
        'type': "buy"}) **elif** action_type < 2:
    **...** **if** shares_sold > 0:
      self.trades.append({'step': self.current_step,
        'shares': shares_sold, 'total': shares_sold * current_price,
        'type': "sell"})

现在，我们的StockTradingGraph已经拥有了呈现股票价格历史和交易量所需的所有信息，以及我们代理的净值和它所做的任何交易。让我们开始渲染我们的可视化。

首先，我们将定义我们的StockTradingGraph和它的__init__方法。在这里我们将创建我们的pyplot人物，并设置每个要渲染的支线剧情。date2num函数用于将日期重新格式化为时间戳，这在以后的呈现过程中是必要的。

**import** numpy **as** np
**import** matplotlib
**import** matplotlib.pyplot **as** plt
**import** matplotlib.dates **as** mdates***def*** date2num(*date*):
  converter = mdates.strpdate2num('%Y-%m-%d')
  **return** converter(date)***class*** **StockTradingGraph**:
  """A stock trading visualization using matplotlib made to render 
    OpenAI gym environments"""***def*** __init__(*self*, *df*, *title*=None):
    self.df = df
    self.net_worths = np.zeros(len(df['Date'])) # Create a figure on screen and set the title
    fig = plt.figure()
    fig.suptitle(title) # Create top subplot for net worth axis
    self.net_worth_ax = plt.subplot2grid((6, 1), (0, 0), *rowspan*=2,     
      *colspan*=1)

    # Create bottom subplot for shared price/volume axis
    self.price_ax = plt.subplot2grid((6, 1), (2, 0), *rowspan*=8, 
      *colspan*=1, *sharex*=self.net_worth_ax) # Create a new axis for volume which shares its x-axis with 
      price
    self.volume_ax = self.price_ax.twinx() # Add padding to make graph easier to view
    plt.subplots_adjust(*left*=0.11, *bottom*=0.24, *right*=0.90, 
      *top*=0.90, *wspace*=0.2, *hspace*=0) # Show the graph without blocking the rest of the program
    plt.show(*block*=False)

我们使用plt.subplot2grid(**...**)方法首先在我们的数字顶部创建一个子图来呈现我们的净值网格，然后在它下面为我们的价格网格创建另一个子图。subplot2grid的第一个参数是子情节的大小，第二个参数是在图中的位置。

为了呈现我们的交易量棒线，我们在self.price_ax上调用twinx()方法，这允许我们在顶部覆盖另一个共享相同 x 轴的网格。最后，也是最重要的，我们将使用plt.show(block=False)将我们的图形渲染到屏幕上。如果您忘记通过block=False，您将只能看到呈现的第一步，之后代理将被阻止继续。

接下来，我们来写我们的render方法。这将从当前时间步骤中获取所有信息，并在屏幕上实时显示。

***def*** render(*self*, *current_step*, *net_worth*, *trades*, *window_size*=40):
  self.net_worths[current_step] = net_worth window_start = max(current_step - window_size, 0)
  step_range = range(window_start, current_step + 1) # Format dates as timestamps, necessary for candlestick graph
  dates = np.array([date2num(x)
    **for** x **in** self.df['Date'].values[step_range]])

  self._render_net_worth(current_step, net_worth, window_size,   
    dates)
  self._render_price(current_step, net_worth, dates, step_range)
  self._render_volume(current_step, net_worth, dates, step_range)
  self._render_trades(current_step, trades, step_range) # Format the date ticks to be more easily read
  self.price_ax.set_xticklabels(self.df['Date'].values[step_range], 
    *rotation*=45, *horizontalalignment*='right') # Hide duplicate net worth date labels
  plt.setp(self.net_worth_ax.get_xticklabels(), *visible*=False) # Necessary to view frames before they are unrendered    
  plt.pause(0.001)

在这里，我们保存net_worth，然后从上到下渲染每个图形。我们还将使用代理在self.render_trades方法中进行的交易来注释价格图表。这里调用plt.pause()很重要，否则在最后一帧真正显示在屏幕上之前，下一次调用render会清除每一帧。

现在，让我们看看图表的每一种呈现方法，从净值开始。

***def*** _render_net_worth(*self*, *current_step*, *net_worth*, *step_range*, 
                      *dates*):
  # Clear the frame rendered last step
  self.net_worth_ax.clear() # Plot net worths
  self.net_worth_ax.plot_date(dates, self.net_worths[step_range], '-
    ', *label*='Net Worth') # Show legend, which uses the label we defined for the plot above
  self.net_worth_ax.legend()
  legend = self.net_worth_ax.legend(*loc*=2, *ncol*=2, *prop*={'size': 8})
  legend.get_frame().set_alpha(0.4) last_date = date2num(self.df['Date'].values[current_step])
  last_net_worth = self.net_worths[current_step] # Annotate the current net worth on the net worth graph
  self.net_worth_ax.annotate('{0*:.2f*}'.format(net_worth),     
    (last_date, last_net_worth),
    *xytext*=(last_date, last_net_worth),
    *bbox*=*dict*(*boxstyle*='round', *fc*='w', *ec*='k', *lw*=1),
    *color*="black",
    *fontsize*="small") # Add space above and below min/max net worth
  self.net_worth_ax.set_ylim(
    min(self.net_worths[np.nonzero(self.net_worths)]) / 1.25,    
    max(self.net_worths) * 1.25)

我们只是调用我们的净值支线剧情上的plot_date(**...**)来绘制一个简单的线图，然后用代理当前的net_worth进行注释，并添加一个图例。

价格图的呈现有点复杂。为了简单起见，我们将使用不同于音量条的方法来渲染 OHCL 条。首先，如果你还没有这个包，你需要pip install mpl_finance，因为这个包是我们将要使用的蜡烛图所需要的。然后将这一行添加到文件的顶部。

**from** mpl_finance **import** candlestick_ochl **as** candlestick

很好，让我们清除前一帧，压缩 OHCL 数据，并向self.price_ax子情节渲染一个蜡烛图。

***def*** _render_price(*self*, *current_step*, *net_worth*, *dates*, *step_range*):
  self.price_ax.clear() # Format data for OHCL candlestick graph
  candlesticks = zip(dates,
    self.df['Open'].values[step_range],  
    self.df['Close'].values[step_range],
    self.df['High'].values[step_range], 
    self.df['Low'].values[step_range]) # Plot price using candlestick graph from mpl_finance
  candlestick(self.price_ax, candlesticks, *width*=1,
    *colorup*=UP_COLOR, *colordown*=DOWN_COLOR) last_date = date2num(self.df['Date'].values[current_step])
  last_close = self.df['Close'].values[current_step]
  last_high = self.df['High'].values[current_step] # Print the current price to the price axis
  self.price_ax.annotate('{0*:.2f*}'.format(last_close),
    (last_date, last_close),
    *xytext*=(last_date, last_high),
    *bbox*=*dict*(*boxstyle*='round', *fc*='w', *ec*='k', *lw*=1),
    *color*="black",
    *fontsize*="small") # Shift price axis up to give volume chart space
  ylim = self.price_ax.get_ylim()
  self.price_ax.set_ylim(ylim[0] - (ylim[1] - ylim[0])
    * VOLUME_CHART_HEIGHT, ylim[1])

我们用股票的当前价格对图表进行了注释，并向上移动图表以防止它与成交量棒线重叠。接下来让我们看看体积渲染方法，这是非常简单的，因为没有注释。

***def*** _render_volume(*self*, *current_step*, *net_worth*, *dates*, 
                   *step_range*):
  self.volume_ax.clear() volume = np.array(self.df['Volume'].values[step_range])

  pos = self.df['Open'].values[step_range] - \
    self.df['Close'].values[step_range] < 0
  neg = self.df['Open'].values[step_range] - \
    self.df['Close'].values[step_range] > 0 # Color volume bars based on price direction on that date
  self.volume_ax.bar(dates[pos], volume[pos], *color*=UP_COLOR,
    *alpha*=0.4, *width*=1, *align*='center')
  self.volume_ax.bar(dates[neg], volume[neg], *color*=DOWN_COLOR,
    *alpha*=0.4, *width*=1, *align*='center') # Cap volume axis height below price chart and hide ticks
  self.volume_ax.set_ylim(0, max(volume) / VOLUME_CHART_HEIGHT)
  self.volume_ax.yaxis.set_ticks([])

这只是一个简单的条形图，每个条形显示为绿色或红色，这取决于价格在该时间步长内是上升还是下降。

最后，让我们进入有趣的部分:_render_trades。在这个方法中，我们将在价格图上绘制一个箭头，在这里代理进行了一笔交易，并标注了交易的总金额。

***def*** _render_trades(*self*, *current_step*, *trades*, *step_range*):
  **for** trade **in** trades:
    **if** trade['step'] **in** step_range:
      date = date2num(self.df['Date'].values[trade['step']])
      high = self.df['High'].values[trade['step']]
      low = self.df['Low'].values[trade['step']] **if** trade['type'] == 'buy':
        high_low = low
        color = UP_TEXT_COLOR
      **else**:
        high_low = high
        color = DOWN_TEXT_COLOR total = '{0*:.2f*}'.format(trade['total']) # Print the current price to the price axis   
      self.price_ax.annotate(*f*'${total}', (date, high_low),
        *xytext*=(date, high_low),
        *color*=color,
        *fontsize*=8,
        *arrowprops*=(*dict*(*color*=color)))

就是这样！我们现在有了一个在上一篇文章中创建的股票交易环境的漂亮的、实时的可视化效果！太糟糕了，我们仍然没有花太多的时间来教经纪人如何赚钱…我们下次再谈吧！

不算太寒酸！下周，我们将基于本教程的代码创建不会赔钱的比特币交易机器人。

[## 创造不赔钱的比特币交易机器人

让我们使用深度强化学习来制造有利可图的加密货币交易代理

towardsdatascience.com](/creating-bitcoin-trading-bots-that-dont-lose-money-2e7165fb0b29)

感谢阅读！一如既往，本教程的所有代码都可以在我的 Github 上找到。如果您有任何问题或反馈，请在下面留下评论，我很乐意收到您的来信！我也可以通过@notadamking 的Twitter联系到。

你也可以通过下面的链接在 Github 赞助商 或者Patreon上赞助我。

[## GitHub 赞助商

嗨，我是亚当。我是一名开发人员、作家和企业家，尤其对深度…

github.com](https://github.com/users/notadamking/sponsorship)

Github 赞助商目前正在 1:1 匹配所有捐款，最高可达 5000 美元！

[## 亚当·金正在创造改变世界的内容

嗨，我是亚当。我是一名开发人员、作家和企业家，尤其对深度…

patreon.com](https://patreon.com/notadamking)

可视化自杀率和世界幸福

原文：https://towardsdatascience.com/visualizing-suicide-rates-and-world-happiness-bc4e6411732f?source=collection_archive---------15-----------------------

两者有关系吗？

由阿纳维 & 娜塔莉

一般来说，一个幸福指数较高的国家的自杀率应该较低。然而，一个相当不为人知的事实是，挪威、芬兰等北欧国家的幸福指数更高，自杀率也更高。

通过这个项目，我们想调查这个异常现象，并通过可视化大量关于这个主题的数据来探索一个国家的自杀率和幸福指数之间是否有关系。我们想看看是否能找到这些矛盾存在的原因，并以历史事件或政府干预的形式揭示它们背后的故事。

初始阶段

背景研究

我们进行了一次文献回顾，了解到自杀背后的原因可能很多，而且非常复杂。我们很清楚，这个项目的目的不是讨论一个特定国家自杀率背后的原因，而是试图了解这些年来自杀率的变化，并确定可能导致这种变化的潜在因素。例如，如果它与全球趋势有关，如经济危机、历史事件或政府干预(后面会有更多这方面的例子)。

头脑风暴&素描

在文献回顾的基础上，我们讨论了一些可能的可视化方法，包括线图、线形图和条形图。这给了我们一个很好的起点来构思随之而来的设计元素。一次头脑风暴会议让我们迅速勾画出一些数据可视化的想法，以尽可能最有效的方式呈现我们的数据。

Multi-dimensional World Map & Interactive Timeline with Historical Event Hover

形象化

最终的可视化效果由 2 个仪表盘和它们自己的图形组成——自杀仪表盘和幸福仪表盘。

他们都是从这种想象开始的:

Average of World Happiness & Suicide 2015–2016

自杀仪表盘

从上面的第一张地图中选择一个国家后，接下来的三张图会相应地改变，以获得该国正在发生的事情的详细图片。

1. 世界幸福感变化&2015-2016 年自杀率(散点图)

这显示了 2015 年至 2016 年世界幸福和自杀率的变化。深色代表 2016 年，浅色代表 2015 年。用户可以将鼠标悬停在线上，查看是哪个国家，并查看两个指标的值。

用户还可以过滤年份，这样它将只显示所选年份的值。选择两个年份后，用户可以看到两个参数的变化。通过散点图，我们可以很容易地看出没有负相关，这意味着更高的幸福分数并不能保证更低的自杀率，反之亦然。

Scatter plot with Switzerland selected; Scatter plot showing happiness score and suicide rate of the year 2015

2.各国自杀率&年龄(折线图)

为了更深入地了解这些年来自杀率的变化，我们制作了这个折线图。下图显示了从 1985 年到 2016 年的自杀率趋势。用户也可以选择国家，性别和年龄组进行过滤。一个有趣的发现是，从 1985 年到 2016 年，全球女性自杀率通常远低于男性自杀率。

3.各州自杀率(Choropleth)

这张图表显示了美国各州的平均自杀率。从图表中，我们可以看出蒙大拿和阿拉斯加的自杀率较高。用户也可以过滤选择年份。

幸福仪表板

从上面的第一张地图中选择一个国家后，接下来的两张图会相应地改变，以获得该国正在发生的详细情况。

1. 2015-2016 年世界幸福指数(堆积条形图)

这个 viz 显示了 2015-2016 年幸福得分的七个属性的分布。根据《世界幸福报告》，衡量幸福得分的属性包括经济(人均 GDP)、家庭、健康(预期寿命)、慷慨、自由、对政府的信任和反乌托邦残余。该图表显示了每个属性的值，以及它们如何在给定的一年中对一个国家的幸福分数做出贡献。用户可以将鼠标悬停在每个条形上，以查看幸福分数的总值及其对每个属性的分解。用户还可以快速了解哪个国家的幸福指数最高。

2.2015-2016 年世界幸福指数(饼状图)

这些饼状图允许用户按年份比较构成某个国家幸福得分的七个属性的总体贡献。用户可以过滤年份并查看不同年份的值。这与前一个不同，因为它不是数值的平均值，而是给出了各年的清晰图像。

有趣的发现

1. 没有证据表明幸福指数高的国家自杀率低，反之亦然。
2. 自杀背后的原因不容易确定。每个国家都有不同的社会和文化背景，导致不同的自杀原因。
3. 几乎每个国家的女性自杀率都比男性低得多。
4. 芬兰是一个高幸福指数和高自杀率国家的典型例子。从数据中，我们发现芬兰的自杀率实际上自 1990 年达到顶峰后大幅下降。经过调查，我们发现这种改善的潜在原因可能是由于 20 世纪 80 年代末发起的全国自杀运动。这有助于提高对精神病治疗的认识和对康复的支持。[1]

Line Chart Showing the Trend of Suicide Rate for Denmark, Finland, Greece, Japan, Norway, South Korea, Sweden, and United States

5。希腊当前的经济危机激起了我们的兴趣，看看它是否对其自杀率有任何影响。然而，根据这个图像，与我们感兴趣的其他国家相比，希腊这些年的自杀率相对较低。我们发现的另一篇论文证实了这一发现。[2]

6。在过去的 15 年里，韩国的自杀率急剧上升，仅仅 10 年后，就从 15/10 万上升到了 40/10 万。这可能有几个潜在的原因，如高失业率和网络欺凌的高发生率。我们发现，韩国政府已经采取行动，如建立当地福利和安全支持系统，为那些试图自杀的人提供善后护理，并根据年龄、性别和社会经济地位量身定制医疗保健计划。[3]

7。美国——蒙大拿州的自杀率是美国最高的。从 2016 年的 25.90/100k 上升到 2017 年的 28.90/100k。统计数据显示，蒙大拿州只有不到四分之一的精神卫生保健提供者需要为其居民服务。此外，浓厚的枪支文化、大量饮酒、冬季日照不足和高海拔都导致了高自杀率。[4]2017 年，面临预算短缺，政府削减了该州卫生部门的预算，包括心理健康资金，这进一步加剧了问题。

视频演示

查看我们制作的视频，了解所有的交互和功能！

有待改进的领域

1. 更多“相关事实”

由于国家数量众多，我们无法调查所有数据的差异，并且只有少数几个国家的信息。此外，如果能够通过包含某种插图或图标，用更多的视觉设计元素来呈现这些数据，那就更好了。然而，即使我们收集了少量的数据，我们仍然得到了一些很好的见解。

2。更多状态数据

美国是此次发布中唯一一个拥有各州自杀数据的国家。有了更多的信息，我们将有更多的数据来分析，并找出更多的“相关事实”来支持我们的可视化。此外，这将有助于那些没有大的跳跃或变化的国家。在这种情况下，小的起伏可能是由于几个州的个别变化，这可能更容易指出。

3。更多最新数据

我们使用的数据集只到 2016 年。拥有直到 2019 年或至少 2018 年的数据可能会更好，因为这将使我们能够更好地将这些发现与更近期的事件联系起来。

谢谢大家！

作者:阿纳维 & 娜塔莉

参考

[1]欧盟统计局:芬兰自杀率下降接近欧洲平均水平https://yle . fi/uutiset/osasto/news/Eurostat _ Falling _ silicon _ rate _ in _ Finland _ nears _ European _ average/10324113

[2]《经济危机期间希腊克里特岛的自杀率:年龄、性别、失业和心理健康服务提供的影响》https://bmcpsychiatry . biomed central . com/articles/10.1186/s 12888-018-1931-4

[3]韩国瞄准高自杀率https://www . VOA news . com/east-Asia/南朝鲜瞄准高自杀率

[4]蒙大拿州的自杀率是全国最高的。然后预算削减来袭。https://www . NBC news . com/news/us-news/Montana-have-first-rate-country-then-cuts-hit-n 904246

用 Python 实现流水线中的主成分分析和 SVM

原文：https://towardsdatascience.com/visualizing-support-vector-machine-decision-boundary-69e7591dacea?source=collection_archive---------3-----------------------

管道、网格搜索和等高线图

Decision Boundary (Picture: Author’s Own Work, Saitama, Japan)

在之前的一篇文章中，我已经详细描述了关于主成分分析的和支持向量机(SVM)算法背后的数学。在这里，我将结合 SVM、主成分分析和网格搜索交叉验证来创建一个管道，以找到二元分类的最佳参数，并最终绘制一个决策边界来展示我们的算法表现得有多好。你希望在这篇文章中学到/回顾的东西—

• 通过 Seaborn Library 以有意义的方式联合绘制和表示数据。
• 如果主成分分析中有 2 个以上的成分，如何选择和表示哪 2 个成分比其他成分更相关？
• 使用 PCA 和 SVM 创建管道，通过网格搜索交叉验证找到最佳拟合参数。
• 最后，我们选择 2 个主成分来表示 3d/2d 图中的 SVM 决策边界，使用 Matplotlib 绘制。

1.更好地了解数据集:联合图和 Seaborn

在这里，我使用了 scikit-learn 癌症数据集，这是一个相对简单的数据集，用于研究二元分类，分为恶性和良性两类。让我们来看几行数据帧。

如我们所见，数据集中总共有 569 个样本和 30 个特征，我们的任务是将恶性样本与良性样本进行分类。在确认没有缺失数据后，我们检查特征名称并检查平均特征的相关图。

下面是使用 seaborn 库封装的平均特征的相关图。正如所料，“面积”、“周长”和“半径”高度相关。

Fig. 1: Correlation plot of mean features.

我们可以使用' seaborn jointplot '来了解各个特征之间的关系。让我们看看下面的两个例子，作为散点图的替代，我选择了 2D 密度图。在右边的面板上，我使用了“十六进制”设置，通过直方图，我们可以了解一个小的六边形区域内的点的数量的集中程度。六边形越暗，落在该区域的点(观察值)越多，这种直觉也可以用绘制在两个特征边界上的直方图来检验。

Fig. 2: Joint-plots can carry more info than simple scatter plots.

在左侧，除了绘制在边界上的单个要素的直方图之外，等值线表示 2D 核密度估计(KDE)。不仅仅是离散的直方图，KDE 直方图通常是有用的，你可以在这里找到一个奇妙的解释。

我们还可以绘制一些配对图，以研究哪些特征与区分良性样本和恶性样本更相关。让我们看下面的一个例子——

Fig. 3: Pair plots of few features in Cancer data-set. Code can be found in my GitHub.

一旦我们玩够了数据集来探索和理解我们手头的东西，那么，让我们转向主要的分类任务。

2.管道、GridSearchCV 和支持向量机:

2.1。主成分:

现在，我们将按照以下步骤，使用 StandardScaler、PCA 和支持向量机创建一个管道—

• 从分割训练集和测试集中的数据集开始

• 检查主成分分析的效果:PCA 以这样一种方式降低特征空间的维度，使得最终特征彼此正交。因为我们在癌症数据集中有 30 个特征，所以可视化 PCA 实际上做什么是很好的。你可以在我关于 PCA 的另一篇文章中读到更多细节。在应用 PCA 之前，我们通过减去平均值来标准化我们的特征，并使用标准缩放器将其缩放到单位方差。所以，我们从选择 4 个正交分量开始—

让我们绘制这四个主要成分的癌症数据——

Fig. 4: Which principal components are more relevant?

从图中可以看出，前两个主成分与区分恶性和良性样本更相关。方差比怎么样？

正如预期的那样，前两个因素占总方差的 80%。这与在选择 2 个分量来绘制决策边界之前显示相关，因为您可能有一些具有许多特征的数据集，其中选择 2 个主分量在百分比方差比方面是不合理的。在使用 PCA 和一些分类器创建管道之前，最好检查两个主成分的选择。

2.2。管道&网格搜索交叉验证:T3

一旦我们看到 PCA 对于分类和为分类器绘制决策边界是多么重要，现在，我们用标准缩放器、PCA 和 SVM 创建一个流水线。

你可以查看更多关于管道和网格搜索交叉验证的细节，那是我单独写的。我选择了 2 个主成分，因为我们的目标是在 2D/3D 图中绘制决策边界，并且使用径向基函数核的 SVM 的最佳参数“C”和“Gamma”是通过固定数量的主成分值获得的。让我们检查一下拟合参数—

在这里，我们看到，使用 2 个主成分和 4 个交叉验证，我们的管道与 SVM 分类器获得了 94%的准确性。当然，你可以使用不同的值或者使用不同的内核。关于内核函数背后的数学，你可以查看我的另一篇文章。在进入下一部分之前，我们可以通过绘制混淆矩阵来完成分析，从中可以获得精确度、召回率和 F1 分数。

Fig. 5: Confusion Matrix obtained using our pipeline with SVM classifier and RBF kernel.

3.地块 SVM 决定边界:

我已经按照 Scikit-Learn 的教程绘制了最大间隔分离超平面，但是这里使用的不是教程中使用的线性核，而是径向基函数核。我们将使用决策函数方法，该方法返回样本中每个类的决策函数。直观上，对于二元分类，我们可以把这种方法想象成它告诉我们，我们在分类器生成的超平面的哪一边，有多远。对于 SVM 决策规则的数学公式，如果你有兴趣，可以查看我以前的帖子。让我们看看决策函数的轮廓

Fig. 6: Decision Function contours with Radial Basis Function kernel is shown here along with the support vectors. Best fit-parameters are obtained from 5 fold grid search cross-validation.

让我们来理解我用来绘制上图的代码

• 从选择 2 个主成分进行主成分分析开始。只有 2 个组件，因为它有助于我们在 2D/3D 绘图中可视化边界。将 2 个以上的组件与决策函数轮廓一起可视化是有问题的！
• 设置具有径向基函数核的 SVM 分类器，并且将“C”、“gamma”参数设置为从网格搜索交叉验证中获得的最佳拟合值。
• 定义一个函数来创建由 x、y(最终选择的主成分)和 Z(SVM 的决策函数)组成的等值线。
• 我们通过函数 make-meshgrid 用一个 x 值数组和一个 y 值数组创建一个矩形网格。检查 Numpy Meshgrid 的必要性。
• 最后，我们将决策函数绘制为 2D 等高线图，并将支持向量绘制为分散点。

希望这篇文章能帮助你理解建立支持向量机分类器的策略，并有效地使用主成分分析来可视化决策边界。

让我们来看看它的 3D 动画——

Fig. 7: Decision Function contours as viewed from top. 3D representation for the figure 6.

最后，我强调检查你的理解总是好的，在这里我们可以看到伽马因子如何影响决策函数轮廓。

对于上面的图，我们有γ = 0.5，C = 1。你可以阅读我的关于 SVM 内核的另一篇文章，在那里我已经讨论了增加γ参数如何导致复杂的决策边界。

让我们通过将“C”参数固定为最佳拟合值，使用两个不同的“Gamma”值来检查这一点

• 为γ = 0.01

Fig. 8: Decision function contours plotted with low gamma (γ=0.01) value. Can be compared with figure 6, where γ = 0.5.

• 对于γ = 10.0

Fig. 9: High gamma parameter is causing extremely complicated decision boundaries.

正如你所看到的，增加伽马参数会产生非常复杂的轮廓。最重要的是，几乎所有高伽马值的样本(每个类别的)都充当支持向量。这无疑是对如此简单、容易分类的癌症数据集的过度拟合。

“永远检查你的直觉和理解力！!"—匿名

为了进一步阅读，我建议你查看塞巴斯蒂安·拉什卡(Sebastian Raschka)的《用 Python 进行机器学习》(第 76–88 页，2017 年 9 月第二版)一书中给出的几个精彩演示。

保持坚强和快乐，干杯！

在 Github 中找到这篇文章使用的代码。

在法国可视化特斯拉增压器

原文：https://towardsdatascience.com/visualizing-tesla-superchargers-in-france-8c10894ab3c?source=collection_archive---------22-----------------------

从头开始使用 Python 和 Folium 学习可视化

数据可视化不仅仅是科学，它还是一门艺术。根据我们人类大脑的工作方式，以可视化的形式处理信息非常容易。在进入数字地图近 25 年以及许多公司使用机器学习来收集大量数据之后，数据可视化比以往任何时候都更加重要。

在这篇文章中，我们将可视化目前在法国可用的特斯拉超级充电器(充电站)。我们将使用 Python、leav 和 Pandas 来完成这项工作。激动吗？让我们开始吧。

GitHub / Live map here

重要的事情先来

数据

首先，我们正在使用由法国政府提供的特斯拉的特斯拉增压器数据。你可以在上面的链接或者我的 GitHub 库中找到这个数据文件。数据有很多列，但我们将只使用纬度、经度和站名。

库

我们将使用 leav 和 Pandas，所以如果您还没有安装它们，请在您的终端中键入以下命令。

pip install foliumpip 
pip install pandas

步骤 1-创建底图

好了，所有特斯拉和可视化的狂热分子，让我们开始吧。为了可视化增压器的位置，我们当然需要一张地图。否则，我们怎么找到他们？所以，我们做的第一件事是，我们为一个特定的位置(世界上的任何地方)创建一个基础地图。默认情况下，Folium 从打开的街道地图中获取地图数据。好好看看代码。

首先，我们导入叶子库。接下来，我们在folium.Map()方法的帮助下创建一个对象——在我们的例子中是地图— 。在该方法中，我们传递地图的坐标和缩放级别。最后，不用说，你保存了地图。我从巴黎开始，你不觉得巴黎的地图像个脑细胞吗？还是只有我？无论如何，让我们进入下一步。

Paris (as if this needed description)

步骤 2-绘制标记

现在我们已经创建了一个基本地图，我们要绘制我们的增压器的位置。我们如何做到这一点？超级简单。我们使用folium.Marker()方法来定义和定制标记。您可以添加参数，如弹出，改变图标，等等。点击此处了解更多信息。最后，使用.add_to()方法，您将标记与您的地图关联起来。

我们在 Thiais 增加了特斯拉增压器作为我们的第一个标记，这是巴黎南郊的一个公社，这就是它的样子。

步骤 3 —多个标记

你能画一个标记吗？当然不是。你可能会画出不止一个或者超过 100 个，我们也会这样做。但是在达到 100 之前，让我们试着只做 2。这样我们会对它的工作原理有更多的了解。

如你所见，我们使用了一个for循环。是的，只是一个for环。编程并不总是复杂的代码，当你掌握了基本知识，你可以做得非常好。所以我们对两个标记进行循环，剩下的就很容易理解了。不是吗？让我们保存地图，看看我们做得怎么样。

Multiple Markers

步骤 4 —使用数据

我们的确画了两个标记，那么那些 100 呢？你要一个一个加吗？你可以，但是你愿意吗？肯定不是。因此，我们将使用包含纬度和经度的现有数据文件，并在我们创建的for循环中传递它。

我们将使用 Pandas 作为我们的数据操作库。我猜你对熊猫很熟悉，但是如果不熟悉，看看这个 10 分钟熊猫教程然后回到这里，我等你。

编程并不总是复杂的代码，当你掌握了基本知识，你可以做得非常好。

回来了？完美。在用 read_csv 或 read_excel 加载数据之后(我更喜欢在这个教程中使用 excel，因为 csv 文件没有得到正确的维护)，我们提取我们需要的每一列，并将其存储在各自的列表中。在for循环中，我们提供相同的列表并从头到尾运行它，而不是手动坐标。运行该文件后，您将在地图上看到以下内容。很整洁，是吧？

All Tesla Supercharging stations in France

第 5 步—自定义图标

但是等等，即使它正确地显示了一切，它也没有给人那种“特斯拉”的感觉，你明白我的意思吗？简洁的外观，简约的设计？让我们试着模仿一样的。让我们使用特斯拉图标，而不是这些绿色标记。并尝试使地图背景更清晰或者我应该说最小化？这由你来决定。

要添加自定义图标，首先你要下载一个(透明背景优先)，在icon_path中设置图标的路径。之后，在 that 的CustomIcon()方法中，提供 icon_path 和图标的大小。你已经准备好了。执行文件并查看更改。

步骤 6-通过聚类美化

看起来比以前更好，但我们可以使用一些东西来使它变得更漂亮——集群。让我们把附近的特斯拉增压器聚集起来，这样你就只能看到你想看到的东西。

用叶的MarkerCluster()方法，我们可以聚类我们的标记和美化地图。我们只需要做一件不同的事情:在此之前，我们将标记添加到地图，但现在，我们将标记添加到标记聚类，然后将标记聚类添加到地图。

在将所有标记添加到聚类中之后，它看起来比以前更好。

The final visualization/ Live map here

瞧啊。您已经使用 Python 和 have 创建了可视化。没那么难，对吧？

尾注

没有合适的资源学习新东西有时会很难。今天，您学习了如何使用 pandas 操作数据，什么是叶，以及如何使用叶用 Python 可视化事物。既然你已经熟悉了 leav，那么就从不同的存储库或 Google Dataset Search 上找到数据集，并可视化你自己的东西。此外，您可以在我的 GitHub 资源库中找到所有的代码文件、图像和数据。如果你对本教程有任何疑问，我的 Twitter 和 Linkedin DMs 永远开放。或者直接过来打个招呼。

可视化 2017 年野火季节

原文：https://towardsdatascience.com/visualizing-the-2017-wildfire-season-2053fe72525f?source=collection_archive---------27-----------------------

2017 年是美国野火灾难性的一年，特别是在加利福尼亚州，发生了 9000 多起火灾，燃烧面积超过 130 万英亩。

斯坦福新闻和民主倡议的一个项目“大地方新闻”开发了一个数据库，用来追踪由联邦政府管理的大面积野火(100 多英亩)。根据该数据，2017 年美国发生了超过 23，000 起野火，比前一年增加了 21%，比数据开始的 2014 年增加了近 80%。

虽然这个数据库并没有全面的显示这个国家的野火情况，但是它显示了野火的增加，T2，专家认为这是全球变暖造成的。

Data from Big Local News / Chart by Jared Whalen.

方法论

从大型本地新闻数据集 ( 美国野火的成本(2014–2017)开始，我按唯一标识符统计记录，并按日期分组。没有事故日期的记录被删除。

工具:R (dplyr，lubridate，ggplot)，Illustrator

流程

我是通过 Buzzfeed 的 Jeremy Singer-Vine 每周收集的数据集 Data is Plural 简讯偶然发现这个数据集的。在四处探索之后，它看起来像是一个有趣的图表。

谈到野火这个话题，我想选择一种视觉上看起来像火焰的图表类型。这让我想起了 Nadieh Bremer 在她的作品 The Baby Spike 中的美丽的可视化，它使用了径向面积图和生动的颜色着色。深受布雷默文章的启发，我想加入一个使用平均值作为基线的径向面积图设计。

至于数据，我在 r 中完成了所有的争论和分析。我的主要代码只是对大规模数据集进行精简，然后按日期进行汇总。

library(tidyverse)
library(lubridate)# identify unique records
fireData_unique <- fireData %>%
 group_by(INC_IDENTIFIER) %>%
 filter(n() == 1) %>%
 ungroup()
# make field selections and convert dates
fireData_sel <- fireData_unique %>%
 select(INCIDENT_NAME,
 DISCOVERY_DATE) %>% 
 mutate(day = yday(ymd_hms(DISCOVERY_DATE)),
 week = week(ymd_hms(DISCOVERY_DATE)),
 year = year(ymd_hms(DISCOVERY_DATE))
 ) %>%
 # remove records with missing or erroneous dates 
 filter(
 !year %in% c(“2011”, NA)
 ) %>%
 # get count by day
 group_by(day, year) %>%
 summarise(count = n())# create average df
fireData_avg <- fireData_sel %>%
 group_by(day) %>% 
 summarise(mean = mean(count))

虽然我在 Illustrator 中做了大量的工作，但大部分繁重的工作来自下面使用 ggplot 的代码。

# function to shift baseline by mean
shiftBase = function(x) {
 x — mean(fireData_avg$mean)
}# Make the plot
 ggplot() +
 geom_area(data=filter(fireData_sel, year==2017), aes(x=day, y=count-mean(fireData_avg$mean)), fill=”#FFBF3F”, alpha=1) +
 facet_grid(~year) +
 geom_area(data=fireData_avg, aes(x=day, y=mean-mean(fireData_avg$mean)), fill=”#547C8E”, alpha=0.2) +
 theme_minimal() +
 geom_hline(yintercept=0, color=”#FF9843") +
 coord_polar(start = 0.1) +
  scale_y_continuous(
    breaks=shiftBase(c(0,100,200,300)),
    labels = function(x){
      round(x+mean(fireData_avg$mean),-2)
    },
    limits=c(-150,max(fireData_sel$count))
  )

独立图表

用 Python 可视化中心极限定理

原文：https://towardsdatascience.com/visualizing-the-central-limit-theorem-with-python-e89d2ce41788?source=collection_archive---------12-----------------------

每当您处理数据并想要收集一些关于它们的信息时，您可能要检查的第一件事就是它们是否遵循已知的分布。

为什么了解数据分布如此重要？

这个问题的答案依赖于许多统计类型研究的目标，即更多地了解一个目标，通常称为人口。警告是观察你项目的全部人口通常是不切实际的(甚至是不可能的)。想象一下，也就是说，你想知道年龄在 40 到 50 岁之间的男性的平均体重。你认为你能采访世界上所有具有这些特征的男人吗？

不可能观察到全部人口，这就是我们需要样本的原因。抽样程序包括从全部人口中选择一个子集，这个子集最好能代表初始人口。通过这样做，我们希望从样本中包含的信息出发，对我们的目标总体做出推断。

在前面的例子中(找出男性的平均体重)，一种解决方法是从男性子集或样本中收集数据，考虑不同的国籍，这样样本就不会有偏差。因此，我们将获得一个样本平均值，它应该接近总体平均值。

然而，我们怎么能确定这个结果的准确性呢？根据定义，统计学家永远不会确定，这就是为什么我们需要测试我们的结果的稳健性，运行所谓的假设检验。后者允许我们声明我们是否可以拒绝我们的零假设(在我们的例子中，这将是‘样本均值是真实参数的良好估计’)。

为了做到这一点，我们需要知道数据的分布。这就是为什么中心极限定理(CLT)如此重要。

CLT 的想法如下:让我们收集大小为 n 的 x 个样本，并让我们计算每个样本的样本均值。然后，(在我们马上要看到的一些假设下)如果我们绘制所有样本均值，它们应该遵循正态分布。此外，所有样本均值的均值应该几乎等于总体的真实参数。

我提到的那些假设是什么？

• 取样程序必须随机执行
• 样本必须相互独立
• 在不替换样本的情况下进行抽样时，样本量不应超过总体的 10%
• 样本量应该足够大(通常，n=30 的样本量被认为是足够大的，即使它确实取决于初始总体)

如果这些假设被认为是正确的，CLT 允许您对初始人口进行推断。此外，样本越大，样本均值分布的钟形就越明显。

为了充分理解这个定理，让我们用 Python 可视化一下。我要做的是创建男性体重的随机样本(想象他们在 60 到 90 公斤之间)，每个尺寸 n=50。然后，我将多次运行这个模拟，看看样本均值分布是否类似于正态分布。

from numpy.random import seed
from numpy.random import randint
from numpy import mean
# seed the random number generator, so that the experiment is #replicable
seed(1)
# generate a sample of men's weights
weights = randint(60, 90, 50)
print(weights)
print('The average weight is {} kg'.format(mean(weights)))

现在让我们重复采样模拟 1000 次:

import matplotlib.pyplot as plt
# seed the random number generator, so that the experiment is replicable
seed(1)
# calculate the mean of 50 men's weights 1000 times
means = [mean(randint(60, 90, 50)) for _i in range(1000)]
# plot the distribution of sample means
plt.hist(means)
plt.show()
print('The mean of the sample means is {}'.format(mean(means)))

根据 CLT，样本均值(74.54)应该是真实参数(未知)的良好估计。

为了确定我们的结果，让我们对数据进行正态性检验。出于这个目的，我将使用夏皮罗-维尔克正态性检验(你可以在这里阅读更多关于这个检验的内容)，这里的假设是:

H0:数据服从正态分布

H1:数据不符合正态分布

因此，如果我们的样本均值服从正态分布，我们将不拒绝零。

from scipy.stats import shapiro
stat, p = shapiro(means)
print('Statistics={}, p={}'.format(stat, p))
alpha = 0.05
if p > alpha:
    print('Sample looks Normal (do not reject H0)')
else:
    print('Sample does not look Normal (reject H0)')

由于 p 值远远大于我们的置信水平 alpha (具体来说，它大于任何显著水平的 alpha )，我们不拒绝 H0。

现在让我们看看，如果我们将样本量从 50 分别增加到 80、90 和 100 会发生什么:

正如你所看到的，样本量 n 越大，p 值越高，我们不拒绝正态零假设的置信度就越高。

通过 MTV 想象挑战

原文：https://towardsdatascience.com/visualizing-the-challenge-by-mtv-71821e00ddd4?source=collection_archive---------28-----------------------

项目

仔细看看有史以来收入最高的 28 名球员

Photo by Nathan McBride on Unsplash

《挑战第 34 季:世界之战 2》将于 8 月 28 日开播，随着玩家一步步爬上巅峰，将会有更加艰苦的挑战和巧妙的计划。

事实上，当我们最后一次在第 33 季停下来时，我们的土耳其超人涡轮(Turabi am kran)在一场残酷但竞争激烈的决赛后取得了胜利——最终获得了高达 75 万的收入。同为新人的西奥·坎贝尔以英国联盟最后一名的身份排名第二，而挑战兽医韦斯·博格曼艰难地排在第三。

灵感

33 季的动作片承载了大量的历史，讲述这个故事的最好方式是通过数据直观地展现出来。事实上，只要快速浏览一下任何挑战者的 MediaWiki 页面，就可以全面了解他们的历史，包括总奖金，一直到他们的家乡。

此外，在维基百科上，有一个有史以来收入最高的 28 个挑战者的名单，所以这篇文章基本上是同时对所有 28 个 MediaWiki 页面的全景展示。

如果你在移动设备上，现在是切换到横向视图的好时机，可以充分享受剧情的互动体验。请随意触摸任何绿点。

双击图表进行重置。干杯！

他们来自哪里？

事实上，直到几个赛季前，挑战赛几乎全部由美国演员出演，以至于只有 3 个 MediaWiki 声明的家乡不在美国。非美国人的家乡排在前 28 名的是:

• turbo—土耳其梅尔辛
• 英格兰西奥-巴斯
• 加拿大安大略省埃文

不出所料，前 28 名中的其他人确实在美国有自己的家乡，尤其是在东北部地区。这并不是说他们都出生在美国，我们可以以出生在巴西的卡蜜拉为例。随着《世界之战》和《世界之战 2》都包含一半的美国和英国演员，这种以美国为主的 28 强可能会在未来几年有所改变。此外，两场比赛中的后一场是美国队和英国队之间的战斗。

你支持哪一个？

淘汰

在《世界大战》中，每周前 3 名的表演团队(或个人，取决于挑战)组成“法庭”，在那里他们投票选出剩余团队中的一个进入“杀戮舞台”，争夺他们的比赛资格。被选中的队预计将选择任何其他队与之竞争，只要他们不是法庭的一部分。失败的队伍回家了，获胜的队伍继续前进:

为他们的 100 万美元而战。

-TJ·拉文

尽管每一季挑战的形式都会改变，但这通常构成了淘汰赛回合。

从这里我们可以看到韦斯可能会在漫长的 11 个赛季中以 14 胜 6 负的成绩脱颖而出，成为前 28 名票房挑战者中的淘汰赛冠军。可以说，也许有一个更好的记录站在乔丹在他的 4 个赛季中惊人的 5 胜 1 负。

在女子组，我们看到卡拉玛利亚 (13 胜 6 负，13 个赛季)卡蜜拉 (9 胜 4 负，10 个赛季)有着非常令人敬畏的记录。

然而，最引人注目的是劳雷尔在短短 4 个赛季中取得了惊人的 9 胜 1 负。

然而，最明显的是，我们亲爱的约翰尼·香蕉(约翰尼·德弗南齐奥)有着最差的淘汰记录，在他的 18 个赛季中，只有 8 场胜利和 12 场失败。

赢得的总金额

这些年来，挑战赛的奖金大幅增加。在早期的比赛中，剩下的最后一名挑战者赢得了超过 10 万英镑的奖金。然而，这些数字一直稳步增长，直至 Turbo 赢得 75 万英镑的大奖。这立即将他推到了有史以来最卖座挑战者名单的第二位。事实上，对于大多数挑战者来说，在花费了 10 个赛季后，通常会获得 10 万到 30 万之间的收入。

这是男女参赛者赢得的总奖金分布的不同情况。这证明了挑战的公平性，在有史以来总收入最高的 28 名竞争者中，男性和女性挑战者之间的金钱成功没有明显的区别。

推特分析

这里我们看到迈克“米兹”米扎宁拥有最多的追随者，超过 3 米。事实上，这显示了世界摔跤娱乐界在发展社交媒体追随者方面的力量。此外，Miz 也有一些广泛的电影记录，主要是直接视频制作。此外，他还在 2017 年主持了慈善季 Champs vs Stars，并在几个不同的季节主持了挑战赛的团聚集。

如前面的图表所示，自从 2006 年首次参加决斗以来，香蕉参加了历史上最多的挑战(18 次)。然而，他的 MTV 处女作是真实世界:基韦斯特。他目前是 NBC 第一套节目的主持人。

毫无疑问，香蕉紧随 Miz-I kid 之后，最近达到了约 30 万粉丝的里程碑。

在 Twitter 上最活跃

这可能是所有图表中最令人震惊的，尽管 2016 年只创建了一个账户，德里克·K 却拥有最多的推文！德里克通常是节目中最安静的人，只是不断说话以加强他对大奖的关注，他打算用这笔钱为家人提供更好的生活。然而，在 twitter 上，他看起来确实很活跃，在他的 3 年里积累了超过 17k 条推文——我印象深刻。

我希望你喜欢这本书，并对观看第 34 季感到兴奋！

我本人是数学金融专业的应届毕业生，非常喜欢与世界分享我的学习曲线。——也就是说，我非常乐意接受任何建议、更正或你在阅读这篇文章时想到的任何一般性反馈。

请随时在 LinkedIn 上与我联系—

[## 约万·梅德福德-加拿大滑铁卢大学| LinkedIn

我是一名四年级数学金融本科生，热衷于使用数学和数据解决问题。我最新的…

www.linkedin.com](https://www.linkedin.com/in/jovan-medford-b86094156/)

或者在 Twitter 上关注我

[## 约万·梅德福德

约万·梅德福德的最新推文(@JovanMedford)。一点特别的东西🤯|数学、金融和科技作家…

twitter.com](https://twitter.com/JovanMedford)

我与 MTV 没有任何关系，这是从 MediaWiki 搜集的非官方数据。

使用基于规则的情感分析可视化电影脚本的情感弧线

原文：https://towardsdatascience.com/visualizing-the-emotional-arcs-of-movie-scripts-using-rule-based-sentiment-analysis-1016b4b1af5a?source=collection_archive---------15-----------------------

我如何使用 Python、D3 和 Flask 来创建这个交互式可视化

大约 72 年前，广受赞誉的美国作家库尔特·冯内古特想出了一种新颖的方法来用描绘故事的情节主线，作为他人类学硕士论文的一部分。

根据冯内古特的说法，尽管他的工作最终被芝加哥大学拒绝，“因为它太简单了，看起来太有趣了”，但在来自佛蒙特大学的一组研究人员决定使用计算方法来测试他的假设后，他被忽视的贡献在过去几年里重新受到了一些关注。

他们想出了近 2000 本英文书籍的计算机生成的故事弧线，归类为冯内古特原始论文中概述的六个主要故事弧线之一。其中包括【破衣烂衫】【崛起】【破衣烂衫】【堕落】【洞中之人】【堕落然后崛起】【伊卡洛斯】【崛起然后堕落】【灰姑娘】【崛起然后堕落然后崛起】【俄狄浦斯】(堕落然后崛起然后堕落)。

他们的作品与冯内古特的不同之处在于，他们描绘了故事的情感轨迹，而不仅仅是情节主线。为了做到这一点，他们在每篇文章中滑动 10，000 个单词的窗口，用一个包含 10，000 个独特单词的词汇对故事中数百个点的相对幸福度进行评分，这个词汇按幸福度的 9 分制进行评分，这就产生了用于情感分析的快乐度计工具。

使用唤醒作为行动的代理措施

我使用了一种类似的基于词汇的方法，绘制了一千多个电影剧本的情感弧线，并使用层次聚类法对最相似的剧本进行分组。

然而，由于之前的研究主要关注积极和消极的情绪，而不是上升和下降的行动，以下方法与 UVM 的方法不同，因为它使用了 NRC 价，唤起和支配词汇，它有 20，000 个英语单词的分数，作为故事中行动或冲突的替代措施。具体来说，我用唤醒维度给单词打分，从“平静”或“被动”到“兴奋”或“主动”。

结果是一个交互式可视化，可以用来搜索任何已经在互联网电影数据库上发布的剧本，以可视化其情感故事弧(为了唤起)，并找到五个在故事的情感轨迹方面最相似的电影剧本，而不是内容。

例如，在搜索大片《阿凡达》(Avatar)时，你可以看到觉醒在电影接近尾声时达到峰值，约为剧本长度的 90%，这与电影中最紧张和冲突的点相对应(纳威人和人类之间决定地球命运的最终对抗)。

其他具有类似结构的电影，有明确的高潮结尾，包括《美女与野兽》(Beauty and the Beast)、《复仇者联盟》(The Avengers)(2012)和《阿里》(Ali)。

以下是我得出这些结果的过程:

使用 VAD 词典抓取文本和评分

利用《美丽的汤》和杰里米·库恩剧本的修订版，我从互联网电影数据库中搜集了所有的电影，使用以下脚本花了大约 20 分钟:

然后我用 NRC VAD 词典创建了一个新词典:

我调整了简单的 labMT 使用脚本来计算语料库的唤醒分数，而不是快乐，用我自己的 labMT 字典和 labMT 向量来代替:

考虑到电影脚本平均比书籍短，我将固定窗口大小设置为 1000 个单词，并在每个脚本中滑动，以生成 n 唤醒分数，或最终时间序列中的点数。

矩阵分解和层次聚类

在实现了 simple labMT 的修订版之后，我使用了奇异值分解来将故事分解到情感弧的正交基上，使用了线性插值来创建等维的词向量，并使用了 scipy 的层次聚类来根据情感弧的轨迹来查找和分组最相似的电影脚本。

使用沃德的方法和欧几里德距离作为距离度量，我能够最小化电影脚本簇之间的差异，以达到最准确的观察分段。

使用 Flask API 评分，使用 D3 可视化结果

最后，我创建了一个 Flask API 来输出在互联网电影数据库中找到的任何电影的唤醒分数，并返回五个最相似的脚本。

使用一个函数来调用 API 和过滤数据，我使用 D3 内置的 d3.json()方法来加载和解析 json 数据对象，从而可视化结果输出。

你可以在这里玩最后的交互可视化，在这里查看所有的笔记本和代码。下面让我知道你的想法！

可视化卷积神经网络的基础

原文：https://towardsdatascience.com/visualizing-the-fundamentals-of-convolutional-neural-networks-6021e5b07f69?source=collection_archive---------7-----------------------

Photo by Pacto Visual on Unsplash

通过可视化示例理解卷积神经网络背后的主要概念

什么是卷积神经网络？

卷积神经网络(CNN)是人工神经网络(ann)的一个子类型，主要用于图像分类。CNN 遵循能够识别模式的结构复制的生物学原理，以识别不同位置的这些模式。它的灵感来自于诺贝尔奖获得者 Hubel 和 Wiesel 在 1962 年发表的“猫的视觉皮层中的感受野、双目互动和功能结构”中提出的猫的视觉系统模型。运用这一灵感的作品之一是 1980 年福岛的新认知图，尽管当时没有使用卷积这个词。所以，CNN 在图像识别上非常成功，不是巧合。然而，它们在处理时间数据方面也表现出了良好的效果，例如时间序列和语音识别，甚至在应用于图形时也是如此。

CNN 在以大约 10%的优势赢得 2012 年比赛 Imagenet 大规模视觉识别挑战赛后变得非常受欢迎。 Alex Krizhevsky 和 Ilya Sutskever 在 Geoffrey Hinton 的指导下，提交了以“AlexNet”为名而成名的 CNN 架构。当时，杰弗里·辛顿已经在人工神经网络领域做出了重大的科学贡献。他是 1986 年反向传播算法和 1983 年玻尔兹曼机器的贡献者之一。这些就是杰弗里·辛顿被公认为深度学习之父的部分原因。

卷积或互相关

典型的 CNN 由一系列充当特征提取器的卷积层组成，后面是一个分类器，通常是一个多层感知器(MLP) ，也称为全连接层(FC 层)，如图 1 所示。

Figure 1 — Architecture of a basic Convolutional Neural Network.

第一层接收用三个颜色通道(RGB 通道)表示的输入图像。然后，第一层用多个核执行输入图像的卷积，产生第一层的一组特征图。每个特征图确定特定特征的强度和位置。由卷积层提取的特征图可以被提交给称为汇集的下采样操作。汇集操作是可选的，因此它可能不会遵循每个卷积层。合并图层的结果是另一组要素地图，地图数量相同，但分辨率降低。下面的卷积层使用来自前一层的特征图来执行更多的卷积并生成新的特征图。来自最后层的特征图是分类器，FC 层的输入。

用星号表示的卷积运算可以描述为:

被𝑥某种类型的输入，如传感器信号，𝑡给定的时间，和𝑘的内核应用。

卷积运算的一个重要性质是它是可交换的，这意味着(𝑥∗ 𝑘)=( 𝑘∗𝑥)如下:

另一方面，由⋆(五角星)表示的互相关运算是不可交换的，可以描述为:

卷积的可交换性来自于内核相对于输入翻转的事实。这种翻转是索引操作的结果。请注意，输入𝑥的索引是𝑎，内核的索引是𝑡−𝑎.尽管可交换性对于编写数学证明是一个有价值的属性，但它与神经网络实现并不相关。事实上，许多机器学习库实现了互相关而不是卷积，并将这两种操作都称为卷积。因此，在训练期间学习的内核与实际实现如等式 1 所述的卷积的库相比将被翻转。在本文中，我们将遵循同样的惯例，称之为互相关卷积。

我们可以将等式 3 用于与 2D 数据(例如灰度图像)的卷积:

是𝑟[𝑖,𝑗]卷积的离散输出，ℎ是核的高度，𝑤是核的宽度，𝑥[𝑎,𝑏]是灰度图像的补片，而𝑘[𝑖+𝑎，𝑗+𝑏]是核。

换句话说，卷积运算从图像中提取多个像素片，然后乘以内核。内核基本上是一个权重矩阵。从图像中提取的像素块通常被称为感受野——在生物学中，感受野是刺激神经元的感觉区域。感受野和内核之间的乘法包括每个像素和内核的相应元素之间的逐元素乘法。在乘法之后，结果被相加以形成特征图的一个元素，由𝑟[𝑖,𝑗].在等式 4 中定义

以下动画显示了 5x5 灰度图像和 3x3 内核之间的卷积运算。感受野用红色方块突出显示。该卷积的输出是 3×3 特征图。

Figure 2 — Step-by-step of the convolution of a 5x5 image with a 3x3 kernel.

动画中使用的实际图像可以在下面的图 3 中看到。内核和特征图中的值被重新缩放以适合 0 到 255 之间的区间，从而被表示为灰度像素。图像中较亮的像素代表卷积的较高值，而较暗的像素代表较低值。

Figure 3 — Convolution of a 5x5 input with a 3x3 kernel.

上面的卷积使用核 3x3，因此，在输入中有九个可能的感受野，每个大小为 3x3。注意，主要由白色像素组成的感受野或主要由暗像素组成的感受野在卷积后会产生非常暗的像素。另一方面，由左边的三个亮像素、中间的中间像素和右边的暗像素组成的感受域在卷积后产生最亮的像素。这是因为这种类型的内核有助于突出显示边缘，特别是从左侧亮区域过渡到右侧暗区域的边缘。

现在，看看当我们将相同的内核应用到一个也包含相反过渡的图像时会发生什么，从左边的暗区域到右边的亮区域。在图 4 中，感受野呈现从暗到亮的过渡，导致最暗的像素。请注意，之前的过渡(从亮到暗)仍然会产生更亮的像素。这意味着该内核不仅检测从亮到暗转变的边缘，还检测相反的从暗到亮的边缘。一种类型的边产生最大的正值，而另一种类型的边产生最大的负值。

Figure 4 — Convolution of an image 17x17 with an edge detector kernel 3x3.

RGB 图像的卷积与灰度图像非常相似。等式 4 可以适用于 RGB 图像，增加另一个循环来迭代 RGB 通道，如下所示:

可变𝑐上的附加循环允许在信道 RBG 上迭代。结果，求和是在三维数据上完成的，而不是在二维数据上，并且仍然产生每个三维感受野和核的单个值。

特征抽出

让我们从一个实际的例子开始这个话题。请看图 5 中下面三个卷积的结果。为了说明卷积的结果，以下示例中的三个核中的每一个都由从图像中提取的小块组成。

Figure 5 — Examples of convolutions.

在第一个例子中，组成内核的面片包括带有白色数字 6 的平面区域。右边的灰度图像本质上是内核和图像之间卷积的结果。最暗的像素代表感受野和内核之间操作的最小结果，另一方面，最亮的像素代表感受野和内核之间操作的最高值。

在第二个例子中，内核由形成飞机轮子的像素片组成。在第三个例子中，内核由从飞机尾部复制的一片黄色像素组成。

请注意，每个结果图像中最亮的像素对应于产生每个内核的位置。在第一个示例中，它对应于数字 6 的位置。在第二个例子中，它对应于轮子的位置。尽管内核是其中一个轮子的副本，另一个轮子非常相似，也产生了明亮的像素。在第三个例子中，最亮的像素对应于平面的所有黄色区域。

进展

步幅是每个感受野之间的距离。到目前为止，我们展示的所有例子都使用了一个步长。采用如此小的步幅导致感受野之间的大重叠。结果，许多信息在相邻的感受野重复出现，如图 6 所示。

Figure 6 –Receptive fields with stride 1.

在 3×3 大小的核的情况下，步长为 2 的采用导致一列或一行与相邻感受野重叠。这种重叠是为了保证步幅不会跳过重要信息。

增加步距将减少卷积的计算成本。如果我们将步距从 1 改为 2，计算成本的减少大约是 4。这是因为步幅影响了二维感受野之间的距离。类似地，如果我们将步幅增加三倍，我们可以预期计算成本降低大约九倍。计算成本降低，因为步幅的增加减少了从输入中提取的感受野的数量，因此，输出的维度也减少了。

图 7 显示了步长为 2、4、8 和 16 的四种卷积结果。卷积中使用的内核大小是 70x70。请注意，将步幅增加两倍，执行时间会减少近四倍。

Figure 7 — Examples of stride 2, 4, 8, and 16. The receptive field dimension is 70x70.

在图 7 中，步长为 16 的卷积结果比步长为 8 的卷积结果少 4 倍的像素。注意，采用 16 的步幅导致 54 行或列的重叠，因为感受野大小是 70×70。步长为 16 时，仍有可能通过平面轮中最亮的像素来识别卷积的最高值。

正向传播

在本节中，我们将研究前向传播在卷积层中的工作原理。为此，我们将了解单个卷积层是如何工作的，然后了解多个卷积层是如何协同工作的。在这项研究中，我们将学习两个新概念:非线性激活和池操作。

在卷积层中

图 8 显示了典型卷积层中的前向传播，它包括三个阶段:卷积、非线性激活和池化。卷积运算已经在第一节中讨论过了。现在，我们将看到其他两个操作。

Figure 8 — The three stages of a convolutional layer.

非线性激活也被称为检测器阶段。在这个阶段，卷积和偏差的结果被提交给非线性激活，例如 ReLU 函数。非线性激活不会改变特征图的尺寸，它只会调整其中的值。

非线性激活

一、什么是线性激活？线性激活是遵循规则 f(x)=ax 的函数，其中 a 是常数，x 是变量。它的图形是一条穿过原点(0，0)的直线。意味着形状 f(x)=ax + b 中的函数，其中 a 和 b 是常数，不是线性的。两者都是仿射函数，但只有一个常数乘以变量的函数是线性函数。

对于一个线性函数，当我们把输入乘以一个常数𝛼时，我们也应该看到输出乘以同一个常数𝛼.这意味着:

另一个要求是，当我们在线性函数中应用两个输入的和时，我们应该得到分别应用于该函数的两个变量的和的输出当量:

那么，我们为什么要使用非线性激活呢？因为当我们在线性函数中应用线性组合(加法或乘法)时，结果也是线性的。尽管许多模型可以用线性模型粗略地近似，但在人工神经网络中使用非线性使得它能够表示线性和非线性模型。换句话说，非线性使人工神经网络成为更强大的函数逼近器。

深度学习中最常用的非线性激活之一是 ReLU 函数，它代表整流线性单元。该函数由下式给出:

该函数在有偏置的情况下，会产生如图 9 所示的图形。

Figure 9 — The graph of ReLU function.

图 10 显示了 ReLU 如何调制卷积的结果。这里，来自图 2 的相同结果被用于应用 ReLU 函数。

Figure 10 — ReLU function applied after the convolution.

上例中使用的 ReLU 函数的等效图像如图 11 所示。请注意，一些中间值被涂黑，突出显示了最亮的三个像素。

Figure 11 — Visual representation of the ReLU function applied after the convolution.

接下来，在图 12 中，您可以看到 ReLU 函数中的一些偏置选项。该函数将平面与包含车轮的图像面片的卷积结果作为输入。请注意，偏差就像一个阈值，决定显示什么和不显示什么。

Figure 12 — Different values of bias applied to the same result of the convolution between the plane and a patch of the image containing the wheel.

图 12 中描绘的阈值行为类似于生物神经元，当它接收到低于某个阈值的刺激时不会触发。如果刺激超过阈值，神经元就开始放电，并且随着刺激的增加，放电频率也会增加。在图 12 中，当偏差为 500 时，它有助于人工神经元的活动。然而，如果我们将偏差定义为-1000，人工神经元只会在最强的刺激下激发。

总之，ReLU 功能就像一个人工神经元。这就是为什么这个阶段被称为检测阶段。ReLU 函数负责检测由内核提取的特征的存在。因此，每个内核都有一个偏差，因为每个特性需要不同的阈值。

联营

最后，但不是最不重要的，池操作。它是对每个特征地图执行的缩减采样操作。它从特征图中提取感受野并用单个值替换它。这个单一值可以通过不同的聚集标准获得，例如根据距感受野中心的距离的最大值、平均值或加权平均值。

除了聚集标准之外，在汇集操作中还有另外两个超参数，感受野的大小和步幅。

与 stride 类似，池化操作导致卷积处理的数据更少。一个区别是，汇集操作不是跳过数据，而是试图将感受域总结成一个值。另一个不同之处在于，跨距是在卷积之前应用的，而池是在卷积的结果上应用的，从而减少了下一层的数据量。此外，汇集操作的感受域是二维的，因为它被单独应用于每个特征图，而卷积的感受域是三维的，包括一层中所有特征图的一部分。

汇集操作的一个期望的副作用是增加了网络对输入的平移的不变性。随着更多卷积层之后是汇集层，这种效应被放大。

图 13 显示了值通过两个池层的传播，池大小为 3x3，跨距为 2。在输入要素地图的蓝色区域中的任何激活都会影响池 1 结果中的蓝色区域。类似地，在汇集 1 的结果中被蓝色覆盖的区域中的激活影响在汇集 2 的结果中被蓝色覆盖的区域。绿色区域之间的关系也是如此。

Figure 13–Propagation of values through pooling layers with pooling size 3x3 and stride of 2. In this example, the convolutional layers were omitted for clarity.

考虑到图 13 中的池是最大池，最高值出现在输入特征图中蓝色区域的哪个位置并不重要，因为它将以同样的方式传播到结果池 2 中的蓝色激活。这就是合并图层增强平移不变性的原因，输入中的小平移不会改变输出中的值。

图 14 显示了卷积步长、ReLU 函数偏差、合并大小和合并步长的不同组合的效果。在左边，有三个步幅的例子:2、9 和 16。对于步幅的每个选项，有三个偏差示例:500、-250 和-1000。对于每种偏差，有三个汇集大小和步幅的示例:汇集大小为 3×3，步幅为 2，汇集大小为 5×5，步幅为 3，汇集大小为 7×7，步幅为 4×4。

Figure 14–Effects of different hyperparameters in convolution, ReLU and max pooling.

卷积中的步幅和最大池中的步幅的效果是累积的。当我们在卷积和最大池中使用步长 2 时，最终结果是特征图的宽度和高度大约减少了四倍。

卷积中的步幅值为 16，最大池中的步幅值为 4，这是不常见的。它们被故意夸大以说明它们对卷积层最终结果的影响。生成的特征图只有 100 个元素(10 x 10)，比具有 37636 个元素的特征图(194 x 194)小得多。

将碎片拼在一起

我们将回到 AlexNet，第一个著名的 CNN 架构。这是一个很好的实际例子，可以理解 CNN 的组件是如何一起工作的。AlexNet 的构建模块如图 14 所示。虚线金字塔表示使用来自输入的感受野或来自前一层的特征图执行卷积。大方框代表特征图，特征图内的小方框是感受野。这个 CNN 可以将物体分为 1000 种不同的类别。

Figure 15 — Architecture of AlexNet CNN.

这种架构的一个特点是它使用两个 GPU 进行训练。图 15 顶部的元素分配在一个 GPU 中，而底部的元素分配在另一个 GPU 中。

你可以在一些框架中得到 CNN 的训练，比如 PyTorch。比较好用。您还可以使用迁移学习将此架构应用于其他影像数据集。这需要一些数据处理来标准化和重新缩放图像，以符合 AlexNet 的要求，但值得一试。大概是这样的:

from torchvision import transformspre_transforms = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

您可以在 PyTorch 中导入模型，如下所示:

from torchvision import modelsmodel = models.alexnet(pretrained=True)

您可以禁用卷积层的训练，并创建自己的分类器来覆盖原始的 AlexNet 全连接层:

from torch import nnfor param in model.parameters():
    param.requires_grad = False # disable trainingfcLayersDict = OrderedDict([('fc1', nn.Linear(9216, 1024)),
                   ('relu1', nn.ReLU()),
                   ('fc2', nn.Linear(1024, 102)),
                   ('output', nn.LogSoftmax(dim=1))
                           ])
model.fcLayersDict = fcLayersDict
fc = nn.Sequential(fcLayersDict)
model.classifier = fc

除了 AlexNet，PyTorch 中还有其他模型可以用来对您自己的图像数据集进行分类，只要进行必要的定制。真的建议测试这些模型，甚至从零开始建立自己的 CNN，了解 CNN 是如何工作的。

即使您已经熟悉这里介绍的概念，我希望您至少可以从另一个角度来看它们。CNN 还有其他一些概念没有在这里讨论。如果你对 CNN 的某个方面感到好奇或不确定，请告诉我。

可视化神经网络的非线性

原文：https://towardsdatascience.com/visualizing-the-non-linearity-of-neural-networks-c55b2a14ad7a?source=collection_archive---------14-----------------------

在这篇文章中，我将通过一个基本的例子来展示神经网络中非线性激活函数的能力。为此，我创建了一个人工数据集。每个数据点都有两个特征和一个类别标签 0 或 1。所以我们有一个二元分类问题。如果我们把这些特征称为 x₁和 x₂，那么这些数据在(x₂)-spacex₁)的情节如下:

这里，红点对应负类，蓝点对应正类。请注意，数据不是线性可分的，这意味着没有线来分隔蓝点和红点。因此，对于给定的特征表示，线性分类器没有用。现在，我们将训练一个具有两个单元和非线性tanh激活函数的一个隐藏层的神经网络，并可视化该网络学习的特征。

为了创建模型，我将使用 Tensorflow 2.0 和tf.keras:

inputs = tf.keras.Input(shape=(2,))
x = tf.keras.layers.Dense(2, activation=tf.nn.tanh)(inputs)
outputs = tf.keras.layers.Dense(1, activation=tf.nn.sigmoid)(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

让我们将隐藏层的权重和偏差表示如下:

权重和偏差的初始值定义了(x₁，x₂)-space，

训练前的这些初始行以及数据如下所示:

Data and the initial lines defined by the hidden layer in (x₁,x₂)-space

请注意，这两个初始行没有很好地划分给定的两个类。现在让我们训练模型，看看这些线会发生什么。

model.fit(x_train, y_train, batch_size = 16, epochs=100)Epoch 100/100
400/400 [==============================] - 0s 80us/sample - loss: 0.1116 - accuracy: 1.0000

在 100 个时期后，我们的训练准确度是 100%,因此模型正确地分类了训练数据中的所有点。

注意，您可以通过使用model.weights获得 keras 模型的参数，它返回一个权重和偏差列表:

[<tf.Variable ‘dense/kernel:0’ shape=(2, 2) dtype=float32, numpy= array([[-3.2753847, 3.2302036], [ 3.3264563, -3.2554653]], dtype=float32)>, <tf.Variable ‘dense/bias:0’ shape=(2,) dtype=float32, numpy=array([1.5562934, 1.5492057], dtype=float32)>, <tf.Variable ‘dense_1/kernel:0’ shape=(2, 1) dtype=float32, numpy= array([[2.625529], [2.670275]], dtype=float32)>, <tf.Variable ‘dense_1/bias:0’ shape=(1,) dtype=float32, numpy=array([-2.0918093], dtype=float32)>]

此列表中的前两个元素是隐藏层的权重和偏差，最后两个元素是输出层的权重和偏差。所有这些元素都是张量，您可以使用 numpy()方法获得 numpy 数组形式的值。例如，下面将以 numpy 数组的形式给出隐藏层的权重，

model.weights[0].numpy()array([[-3.2753847,  3.2302036],        [ 3.3264563, -3.2554653]], dtype=float32)

第一行的系数是-3.27 和 3.32；第二行的系数是 3.23 和-3.25。你可以通过运行model.weights[1].numpy()看到他们的偏见

让我们想象由学习到的隐藏层的权重和偏差定义的线，

The data and the lines defined by the hidden layer after training in (x₁,x₂)-space

正如您现在所看到的，这些线以一种将类包含在独立区域中的方式划分了空间。这些线的系数告诉我们每条线的正面。对于蓝线，正方向是上侧，对于橙线，正方向是下侧。所以蓝点在两条线的正侧，红点在一条线的负侧，另一条线的正侧。

现在让我们应用非线性激活函数tanh并在新的特征空间(a₂).a₁)中可视化数据隐藏层的激活计算如下，

对于每个数据点，tanh的参数由该数据点相对于上述线的位置决定。我们可以认为 a₁和 a₂是新的特征，a₁,a₂)-space 是新的特征空间。输出层的权重和偏差在这个新的特征空间中定义了一条线，由以下等式给出

这条线和这个新特征空间中的数据一起绘制如下，

The features learned by the model in (a₁, a₂)-space and the line defined by the output layer.

请注意，在这个新的特征空间中，我们的数据变得可线性分离，由输出图层定义的线将两个类分开。蓝点的 a₁和 a₂坐标都是正的，因为(x₁，x₂)空间中的这些点位于由隐藏层参数定义的两条线的正侧，并且在应用tanh后，两个坐标都是正的。对于红点，a₁和 a₂中的一个是正的，因为在 x₂)-space 的 x₁中，红点仅在由隐藏层参数定义的一条线的正侧，并且根据这条线，它们在新特征空间中只有一个坐标是正的，而另一个是负的。这解释了上图(a₁,a₂)-space)中的数据图。

结论:神经网络学习数据的新表示，这使得相对于该新表示进行分类变得容易。

这里有一个链接指向我在这篇文章中使用的 google colab 笔记本。

感谢阅读。

使用 Python 和 IBM Watson 可视化任何电影角色的个性特征

原文：https://towardsdatascience.com/visualizing-the-personality-profile-of-any-film-character-using-python-and-ibm-watson-78ad2fcee065?source=collection_archive---------24-----------------------

一个简单的数据收集指南，光预处理和任何电影角色的五大性格特征的可视化

Photo by Marko Blažević on Unsplash

伟大的社会心理学家詹姆斯·彭尼贝克曾经说过:“通过更仔细地观察人们用语言表达思想的方式，我们可以开始了解他们的个性、情感以及与他人的联系。”他和许多其他心理学家、语言学家和自然语言处理(NLP)从业者一起，利用双向 LSTMs 和 NLU (自然语言理解)等先进技术，在从书面文本中推断详细(和惊人准确)的个性信息方面取得了巨大进步。

最近，IBM Watson 背后的先锋团队开发了一个名为 Personality Insights 的产品，旨在为业务用例分类个性。在产品主页上有这样一句标语:“通过文字预测个性特征、需求和价值观。从个人层面和整体层面了解客户的习惯和偏好。“虽然商业含义很明显，但我认为利用虚拟人物塑造平台，通过电影主角的口语对话对他们的性格特征进行分类，这将是一件有趣的事情。

数据

为了这个项目，我利用了来自加州大学圣克鲁斯分校的大型电影语料库。语料库按类型细分，包含 960 个电影剧本，其中电影中的对话与场景描述分离。

为了让数据为分析做好准备，需要进行大量的清理和预处理。此外，数据中存在一些结构性挑战。也就是说，需要将每个引用/行与相应的字符进行分解和关联。

出于本文的目的，我不会深入到整个预处理代码中(对于那些感兴趣的人，完整的笔记本可以在这里找到)。然而，我将举例说明我们如何将人物/说话者从他们的对话中分离出来，然后将它们压缩成一个数据帧。

接下来，我们需要将所有与每个角色相关的口语对话组合成一个列表。以下代码的输出将为我们提供由逗号分隔的每个角色的完整对话:

IBM 沃森

Photo by Vasundhara Srinivas on Unsplash

从这里开始，我们的对话就可以输入到我们的 IBM Watson 笔记本中了。请注意，在 IBM Cloud 上注册需要很多步骤。你需要开一个账户，生成一个 API 密匙，还要下载 python SDK 。虽然这些步骤非常简单，但我将为以后的文章保存设置(或者， IBM 网站上的文档相对容易理解)。

一旦我们有了凭证，为列表中的每个字符获取可视化效果的过程就非常简单了。我们是这样设置的:

上面代码的输出将会显示出我们想要分类的角色的非常详细的个性特征。我们将看到输入文本中的字数，五大特征中每一个的百分位数，需求，以及五个主要特征中每一个的详细子特征(称为孩子)。

然而，作为数据科学家，我们不想呈现一个枯燥的读数。相反，我们希望通过一些有吸引力的条形图来形象化这些特征。我将列出这样做的代码，然后输出现代最具代表性的电影角色之一的结果:灰袍甘道夫(和白人！).

想象甘道夫的人格

Photo by Thomas Schweighofer on Unsplash

现在我们已经有了自己的功能，我们可以将甘道夫的全部对话输入到我们的 IBM 笔记本中，并看到他的人格形象。

Big Five profile of Gandalf

The needs of Gandalf

有意思！我们可以看到甘道夫是最开放的，大约在 98%左右。另一方面，他和他们一样内向，对在黑暗的图书馆里研究符文和在莫莉亚矿井下与巴罗格战斗更感兴趣。

至于需求，并没有很大的信号。甚至他的最高需求(好奇与和谐)也没有达到 50%。我想这是有道理的。除了偶尔需要一只鹰从艾辛格塔顶救他们之外，大部分巫师都是自给自足的！(遗憾的是，在 IBMs 服务的这个迭代中没有“eagles”需求列)

除了这一大部分，我们还可以放大甘道夫性格中的儿童特征。让我们看看我们发现了什么:

Openness

Conscientiousness

Extraversion

Agreeableness

Emotional Range

更多有趣的发现！我们可以看到甘道夫在以下特质上处于第 80 到第 100 百分位之间:想象力、智力、艺术兴趣、利他主义、谦虚、同情和忧郁。类似地，我们看到合群和外向的特质的结果很低。

虽然这个程序只能考虑对话而不能考虑动作，但他们确实感觉与指环王电影中甘道夫的角色非常一致。的确，我相信甘道夫本人，如果他能够看到这些结果，会有如下反应:

giphy.com

结论

好了，你知道了。现在，您已经掌握了构建自己的性格分类器的知识，并可以输出一些漂亮、清晰的可视化效果，达到相当高的准确度。

非常令人兴奋的是，我们能够根据个人的书面文本提取出如此详细的信息，虽然这个项目比任何事情都有趣，但这样一个平台的实际应用既重要又多样。例如，我们可以输入一个人的 Twitter 账号，然后输出一个类似的详细而准确的个人资料。虽然这确实令人兴奋，但这也引发了一些关于隐私和我们如何使用这些数据的道德问题。营销人员可以(并且已经)开始从我们的个人资料中提取详细的个性信息，并利用这些信息向我们投放高度个性化的广告和“新闻”文章。

然而，我看到了这种技术更令人兴奋的应用。作为一名体验设计师，我认为未来我们可以使用这种个性分类器来制作定制的交互式叙事内容，并让个人接触到与他们的个性相当独特的特征，以拓宽他们自己的观点。

这是我将在下一个项目中探索的，所以请继续关注。此外，如果你有兴趣深入了解这个项目的步骤和代码，可以看看我的 Github repo。最后，在不久的将来，我将发布一个分步指南，介绍如何使用 python 和 IBM Watson，以及如何使用 NLP 和 LDA、NMF 等降维技术，按类型将相同的电影剧本语料提取为简单的主题。

附录

Github 、 LinkedIn 、投资组合

用熊猫可视化 Scimago 期刊排名数据库

原文：https://towardsdatascience.com/visualizing-the-scimago-journal-ranking-database-with-pandas-7e7aaad54904?source=collection_archive---------12-----------------------

SCImago 期刊排名(SJR 指标)是对学术期刊的科学影响力的一种衡量，既考虑了期刊被引用的次数，也考虑了引用来源期刊的重要性或声望。

scimago journal 的网站维护着期刊和国家排名的完整信息。与其他类似网站不同，它还提供了一些独特的可视化工具，提供各种科学结构的信息可视化图表，实时和气泡图地图，这些地图基于一系列指标，如 H 指数、总文献数、引用文献数、引文数、自引数、每篇文献的引文数和国家。

在这篇博文中，我将使用 Scimago 的数据库来创建类似的可视化效果，同时分析这些可视化效果将展现的奇怪趋势。CSV 数据文件可在下载。使用的库是 pandas、seaborn、matplotlib 和 plotly。对于不耐烦的灵魂，代码和输出可以在这个 jupyter 笔记本中找到。

正在加载数据库

我用熊猫来加载 csv 文件。下图显示了数据库的各个字段:

在上图中，“标题”是指出版单位的名称。这些类型可以是期刊、行业期刊、丛书或会议和会议记录。此外，还列出了SCImago Journal Ranks(SJR)、主办这些活动的国家名称、发行商组织、它们所属的类别以及其他指标。

左图显示了在数据框上调用 info()方法得到的字段的列数和数据类型。我们可以观察到数据库非常干净，只有几列(SJR、国家、出版商)包含缺失值。

可视化 H 指数

H-index 指的是该期刊被引用至少 h 次的文章数量( h )。H-index 因其简单而优雅，可以被认为是当今出版业绩最重要的衡量标准。

让我们从可视化 H 指数值的分布开始，以便推断所有可能出现的值以及它们各自的频率。为此，我们可以使用 Seaborn 的 distplot 。

sns.distplot(df.loc[df['Country'] == 'United States']['H index'].dropna(), kde=True)
print(df.loc[df['Country'] == 'United States']['H index'].dropna())

下图显示了美国和印度的分布情况。图上的蓝色曲线表示高斯核密度估计值。我们可以很容易地推断出两者之间的一些明显差异。例如，大多数印度期刊的 H 指数在 0-20 之间，而美国期刊的 H 指数在 0-100 之间。此外，没有一家印度期刊的 H 指数超过 200。

进一步，我尝试用气泡图将每个国家的总引用次数(过去 3 年)与它们的总 H 指数进行比较。为此，我们需要根据这些国家在过去三年中发布的文档总数来确定气泡的大小:

plt.figure(figsize=(10,8))
sns.set_context("notebook", font_scale=1.1)
sns.set_style("ticks")sizes = [10, 60, 90, 130, 200] 
marker_size = pd.cut(df['Total Docs. (3years)']/10, [0, 40, 80, 120, 160, 200], labels=sizes)
sns.lmplot('H index', 'Total Cites (3years)', data ​=df, hue='Country', fit_reg=False, scatter_kws={'s':marker_size})
plt.title('H index vs Total Cites (3 years)')
plt.xlabel('H index')
plt.ylabel('Total Cites')
plt.ylim((0, 50000))
plt.xlim((0, 600))
plt.savefig('sns.png')

由于 LinkedIn 的图片大小限制，我无法附上整张图片，而是提供了 google drive 链接。从图表中，我们可以很容易地分辨出哪些国家产生的文献最多，哪些最少被引用。不出所料，美国位居榜首，其次是英国、荷兰、澳洲、和德国，而排在最后的是:津巴布韦、梵蒂冈城、斐济和列支敦士登。我还使用 plotly 获得了一个类似但更具交互性的图表。然而，它太重了，不能附在这里，因为我在交互图中导航时多次经历了 plotly 的页面崩溃。(欢迎任何关于替代方案的建议。)

[## hindex_vs_totalCites.png

编辑描述

drive.google.com](https://drive.google.com/file/d/1ZnqdeWCC6WVmKAHF8u7bABd7MlvS2CEf/view?usp=drive_open&usp=embed_facebook)

可视化各种指标之间的相关性

接下来，我们想了解各种指标之间的关联模式。这就是 Seaborn 的联合计划来拯救的地方。使用 jointplot，我们可以根据两个变量显示数据点，包括它们的分布、核密度估计值和拟合数据的可选回归线:

该图(最后一个子图)显示了引用文献的数量与参考文献的总数高度相关，皮尔逊相关系数(pearsonr)为 0.78。此外，他们图表的回归线显示了一种强烈的上升趋势，这解释了随着参考文献总数的增加，引用文献的数量也在增加。这两个观察结果在评估关于总文档的 H 指数时给出了更差的结果，即 pearsonr = 0.35，并且回归线具有非常小的上升趋势。

关于相关性，我们可以使用 Seaborn 的热图一次可视化数据帧的多个指标之间的相关性。这可以使用对 pandas dataframe 调用的 corr() 方法来实现，该方法使用一种指定的方法(默认为 Pearson)来计算 dataframe 的所有数字列对之间的相关系数。

值得注意的一个特殊趋势是，引用文献的数量与发表文献的总数几乎完全相关。然而，这两个指标对 H 指数都没有很大的影响。因此，影响期刊 H 指数的最佳可能指标可以被认为是该期刊获得的引用总数。

如 Ramana 等人所述，上述热图中的趋势在联合图观察的支持下，可能表明 H 指数计算中的固有缺陷。艾尔。(2013) :

尽管你的大量论文被大量引用(在我们的例子中是总引用数)，它只考虑那些被引用次数最少的论文作为你的 h 指数，为了提高你的 h 指数，你的其他论文的引用也应该增加。

可视化国家

到目前为止，我们一直在研究各种数值度量对之间的关系。到目前为止，一切都很好。但是，如果我们想知道单个国家的这些指标的趋势(或者第三个特征)，该怎么办呢？

对此的一个解决方案是使用对绘图。在探索多维数据之间的相关性时，Pairplots 非常重要，因为我们可能要绘制所有相互对应的值对。出于我的目的，我选择了 CSV 文件的前 1000 个实例，同时指定了字段“Country”的值，以便将绘图特征映射到不同的颜色:

sns.pairplot(df[:1000], hue='Country', size=2.5)

我们现在可以研究单个国家的表现。以下是一些快速推断:

• 粉红色光谱中的国家(保加利亚、加拿大和印度)可以看到具有较低的 H 指数和可引用文件，蓝绿色光谱中的国家具有中等水平，而橙红色光谱表示表现最好的国家。
• 可以看到沿对角线的图形由柱状图组成，以显示该列中各个变量的数据的单变量分布。
• 我们观察到的可引用文献数量和已发表文献总数之间的完美相关性在这里也成立，因为我们可以看到大多数数据点(即国家)都集中在上图的对角线上(第五行，最后一列)。这意味着我们可以沿着对角线拟合一条平滑的回归线，以覆盖大多数数据点。

可视化类别

我们可能还想知道更多关于数据库中提到的不同科学类别的信息。但是，类别单元格包含多个分号分隔的字段。因此，我首先基于不同的“；”复制行类别中的分隔值。

new_df = pd.DataFrame(df.Categories.str.split(';').tolist(), index=df.Country).stack()
new_df = new_df.reset_index()[[0, 'Country']] *# categories variable is currently labeled 0*
new_df.columns = ['Categories', 'Country'] *# renaming categories*
new_df = new_df.dropna()
new_df.info()
new_df.head()

现在，让我们观察发布实体数量最多和最少的类别。为此，我们需要将类别的字符串值转换成数字。Pandas 为此提供了一个内置方法:value_counts()返回 pandas 系列中唯一值的计数。

fig, ax = plt.subplots()
new_df['Categories'].value_counts()[:20].plot(ax=ax, kind='bar')

不出所料，计算机科学独占鳌头！

此外，上述可视化也可以用这个新的数据框来实现。

可视化世界各国领导人在联合国大会上的演讲

原文：https://towardsdatascience.com/visualizing-the-speeches-of-world-leaders-at-unga-d7319e00e180?source=collection_archive---------14-----------------------

第 74 届联合国一般性辩论于 9 月 24 日星期二上午 9 时(纽约时间)开幕。今年的主题是“激励多边努力，促进消除贫困、优质教育、气候行动和包容”。

自 1947 年以来，联合国会员国的代表每年都聚集在联合国大会的年会上。每次会议的中心是一般性辩论。在这个论坛上，各国领导人和其他高级官员发表声明，阐述他们的政府对世界政治重大问题的看法。

这份领导人名单是根据他们的 GDP 规模、应对气候变化的行动以及他们对地区发展的影响等因素编制的。

• 纳伦德拉·莫迪，印度总理
• 唐纳德·川普，美利坚合众国总统
• 唐纳德·图斯克，欧洲理事会主席，欧盟
• 埃马纽埃尔·马克龙，法兰西共和国总统
• 鲍里斯约翰逊，英国首相
• 朱塞佩·孔戴，意大利总理
• 安倍晋三、日本首相
• 雅伊尔·博索纳罗，巴西总统
• 杰辛达·阿德恩，纽西兰总理
• 伊姆兰·汗，巴基斯坦总理

德国、中国和俄罗斯没有由其国家元首代表，而是由大多数高级官员代表，因此他们没有被纳入分析。

分析参数:

• 词语云 —世界云会将领导讲话中使用频率最高的词语可视化。NLTK 世界云库用于生成定制的可视化。
• 主题建模 —主题建模将通过进行 NLTK 分析来可视化演讲的前 10 个主题。Gensim 主题建模用于此。
• 极性(模式分析器)——使用模式分析器计算语音的极性，并在-1.0 到+1.0 的范围内显示，其中-0.1 为最大负值，0 为中性值，+1.0 为正值。使用的技术是基于 python 的文本处理库 TextBlob。
• 主观性(模式分析器)——使用模式分析器计算语音的主观性，并在 0.0 到+1.0 的范围内显示，0.0 表示客观，+1.0 表示主观。使用的技术是基于 python 的文本处理库 TextBlob。

印度总理纳伦德拉·莫迪

莫迪是世界上最大的民主国家、第五大经济体和 13 亿人口的总理。印度也是第三大二氧化碳排放国，因此印度采取的每一个行动都关系到每一个全球公民。他演讲的主要亮点是印度不断推动消除贫困、采用可再生能源、应对气候变化和根除恐怖主义。

全文此处。

可视化显示，演讲主要集中在印度的发展和世界上的其他社会经济问题上。

总理的讲话极性为 0.089，这表明它是中性的——积极的，主观性为 0.31，这表明它不太主观。

美国总统唐纳德·川普

特朗普是世界上最古老的民主国家的总统，是世界上最大的军事强国，也是仅次于中国的第二大二氧化碳排放国。特朗普总统在演讲中没有对气候变化做出任何强有力的承诺。此外，他传达了一个明确的信息，支持民族主义和国家主权，反对全球主义。这次演讲是在对他的正式弹劾调查开始后发表的。

全文此处。

总统演讲的极性为 0.10，这表明它是积极的，主观性为 0.49，这表明它是主观的。

欧盟欧洲理事会主席唐纳德·图斯克

唐纳德·图斯克先生是欧盟的政治首脑，欧盟拥有 5 亿人口和 18 万亿美元的国内生产总值。图斯克强调，如果不准备在全球范围内建立规则，并在以后始终遵守这些规则，当地社区、民族和国家，甚至各大洲，在这些威胁面前都将束手无策。

全文此处。

总统演讲的极性为 0.07，这表明它是积极的，主观性为 0.43，这表明它更加主观。

法国总统埃马纽埃尔·马克龙

周二，法国总统埃马纽埃尔·马克龙在联合国大会年度高级别辩论上向世界领导人发表讲话，呼吁拿出勇气，呼吁政治家们承担必要的风险，以找到应对当代挑战的真正解决方案。

全文此处。

总统演讲的极性为 0.08，这表明它是中性的——积极的，主观性为 0.31，这表明它更加客观。

英国首相鲍里斯·约翰逊

英国首相鲍里斯·约翰逊(Boris Johnson)在联合国大会(UN General Assembly)上发表了关于技术的首次演讲，其中引用了许多离奇的引文，涉及科幻小说、电影，甚至小众的英国喜剧节目。演讲在一大堆可识别的反乌托邦比喻之间跳跃，比如“终结者”系列和关于物联网的阴谋论。这次演讲是在他在英国遭遇巨大失败后发表的，最高法院裁定他暂停议会是非法的。

全文此处。

总理的讲话极性为 0.05，这表明它是中性的——积极的，主观性为 0.35，这表明它更加客观。

意大利总理朱塞佩·孔戴

意大利是世界第八大经济体，也是二氧化碳的主要排放国。孔戴先生强调，国际社会需要更有效的多边主义，需要一个作为基于和平、正义和公平的国际体系支柱的作用得到加强的联合国。

全文此处。

总理的讲话极性为 0.07，这表明它是中性的——积极的，主观性为 0.22，这表明它非常客观。

日本首相安倍晋三

日本是世界第三大经济体和第五大二氧化碳排放国。日本誓言支持全球推动为所有女孩和妇女提供包容性优质教育。安倍还表示，他打算利用多边框架和全球主义来缩小差距。

全文此处。

总理的讲话极性为 0.10，这表明它是积极的，主观性为 0.31，这表明它更客观。

巴西总统雅伊尔·博索纳罗

极右翼的巴西总统雅伊尔·博索纳罗公开反对他所谓的关于亚马逊的“媒体谎言”以及所谓的对居住在那里的土著居民的操纵。巴西是南美洲最大的国家，亚马逊地区比西欧还大。在他挑衅性的演讲中，他还继续攻击社会主义在拉丁美洲的遗产。在对法国和德国的尖锐反驳中——两国都公开关注森林砍伐的增加——bolso naro 利用他的演讲指出，这两个欧洲国家将超过 50%的土地用于农业，而巴西仅使用 8%。

全文此处。

总统演讲的极性为 0.09，这表明它是中性-积极的，主观性为 0.41，这表明它是中性-客观的。

纽西兰总理杰辛达·阿德恩

杰辛达·阿德恩总理对民族主义的呼吁进行了指责，并恳求世界领导人共同努力，这一讲话与美国总统唐纳德·特朗普早些时候发表的讲话截然不同。阿尔登还指出，克赖斯特彻奇呼吁是各国和科技公司合作努力消除网上暴力极端主义和恐怖主义内容的一个例子。

全文此处。

总理的讲话的极性为 0.07，这表明它是中性-积极的，主观性为 0.28，这表明它非常客观。

巴基斯坦总理伊姆兰·汗

这是汗先生成为巴基斯坦总理后在联合国大会上的首次发言，巴基斯坦是东南亚维护和平与稳定的一个非常重要的角色。作为 130 个联合国认定的恐怖分子，超过 25 个联合国认定的恐怖实体的家园——崩溃的国内生产总值和高耸的经济债务，世界非常有兴趣知道汗先生如何计划使巴基斯坦成为一个更好的地方。相反，他把自己的全部 59 分钟都献给了印度——一种针对印度的虚构言论，对印度领导层吐毒液，为伊斯兰激进主义和核圣战辩护。

总理讲话的极性为 0.04，这表明它是中性的，具有显著的负带宽，主观性为 0.38，这表明它更加客观。

技术背后的分析

• 使用 python 中的正则表达式、 NLTK 库进行文本处理。
• 使用定制的NLTKword cloud 来可视化演讲。
• 使用 Gensim 话题建模 LDA 分析器获得演讲的更详细话题。
• 使用 Textblob ，计算极性和主观性。

链接到Google Collab。

链接 Kaggle 笔记本分析联合国辩论会上的印度(1970–2016)。探究印度在谈论哪些问题？印度有多少次提到巴基斯坦或其他国家，反之亦然？

注:

这是一项完全独立的数据分析，既不赞助也不支持，也不与任何组织、公司或个人相关。

从我的角度来说，我尽量保持它的公正性，把它表达为一种纯数据分析的形式，而不做太多的政治评论。读者可以自由使用上述数据或图像，并从中做出任何推断。

用 Tableau 可视化股票市场

原文：https://towardsdatascience.com/visualizing-the-stock-market-with-tableau-c0a7288e7b4d?source=collection_archive---------12-----------------------

Photo by AbsolutVision on Unsplash

我们使用 Tableau 数据可视化来寻找包含潜在廉价股票的行业

Tableau 是一个重要的数据可视化工具，属于每个数据分析师和数据科学家的工具包。今天，我们摆弄股票市场数据，以探索 Tableau 如何帮助我们剖析和更好地理解我们的数据。

首先，我们获取数据

我们可以从 Quandl 抓取股市数据。我们将重点关注标准普尔 500 指数，这是一个大型美国股票(基本上是最大的美国公司)的市值加权指数。

下面是获取数据的 Python 代码(注意，您需要自己的 Quandl API 密匙，Sharadar 数据需要付费订阅)。我还在下面的代码中添加了注释，但是下面的代码片段使用 Quandl 的 API 来获取 Sharadar 数据库中所有上市公司的财务数据(财务数据包括收入、净收入、债务、投资资本回报率等等)。这个财务数据存储在数据帧 stock_df 中。

import quandl
quandl.ApiConfig.api_key = 'your_qandl_api_key'
import numpy as np
import pandas as pd# Download financial data from Quandl/Sharadar
table = quandl.get_table('SHARADAR/SF1', paginate=True)# Grab the most recent annual data ('MRY' denotes annual data)
stock_df = table[(table['calendardate'] == '2018-12-31 00:00:00') & (table['dimension']=='MRY')]

然而，我们不需要每家公司的数据，我们只需要标准普尔 500。为了得到标准普尔 500 的报价，我们求助于网络搜集和维基百科。下面几行代码抓取了一个维基百科表格，列出了目前在标准普尔 500 的每家公司的股票代码和行业，并将其存储在名为 page_content 的变量中。

# Scrape S&P 500 tickers from Wikipedia
from bs4 import BeautifulSoup
import requests
import repage_link = '[https://en.wikipedia.org/wiki/List_of_S%26P_500_companies'](https://en.wikipedia.org/wiki/List_of_S%26P_500_companies')
page_response = requests.get(page_link, timeout=1000)
page_content = BeautifulSoup(page_response.content, 'lxml')

接下来，我们使用一些解析代码从 page_content 中获取 ticker 和 industry，这是一个漂亮的组数据结构。代码可以总结为执行以下操作:

• 遍历 page_content 中所有“tr”(我相信它表示 HTML 中的一个表格行)标记的项目。
• 将跑马灯作为一个字符串来抓取(T10)。text 将项目转换为字符串格式)并将其存储在列表ticker中。
• 将行业作为字符串抓取并存储在列表行业中。

# From web scraped Wikipedia content on the S&P 500, grab the ticker and industry for each firm
tickers = []
industries = []
for i, val in enumerate(page_content.find_all('tr')):
    if i > 0:
        try:
            # Here is where I grab the ticker
            tickers.append(val.find_all('a')[0].text)
            # Here is where I grab the industry
            industries.append(val.find_all('td')[3].text.replace('\n', ''))
        except:
            pass

最后，我们需要做一些数据操作，将我们的股票和行业数据(来自维基百科)与我们的财务数据(来自 Quandl)结合起来。前两个代码块(在注释中有详细描述)将我们想要的 tickers 存储到一个名为 sp_df 的数据帧中。

最后一段代码使用 Pandas 合并方法将包含我们股票和行业数据的 sp_df 与包含我们财务数据的 stock_df 连接起来。我们将得到的数据帧 merged_df 存储在一个. csv 文件中，我们现在可以将它加载到 Tableau 中(我使用的是 Tableau Public，它是免费的)。万岁！

# After ticker ZTS, the rest of the table entries are for acquisitions/mergers
last_pos = tickers.index('ZTS') + 1
sp_tickers = tickers[:last_pos]
sp_industries = industries[:last_pos]# Create a new dataframe for S&P 500 and merge in Quandl data
sp_df = pd.DataFrame()
sp_df['tickers'] = sp_tickers
sp_df['industries'] = sp_industriesmerged_df = sp_df.merge(stock_df, left_on='tickers', right_on='ticker', how='left')
merged_df.to_csv('sp500.csv', index=False)

差不多是时候想象了

数据可视化听起来有趣又简单，但事实并非如此。我们看到的所有这些很酷的仪表盘和交互式图表都经过了大量的思考。虽然我不是专家，但在我开始把数字贴到图表上之前，我首先尝试回答以下问题:

1. 我们试图通过视觉化来揭示什么样的洞察力？漂亮的图表固然很好，但如果没有从中汲取的洞察力，它们只不过是空洞的形状和颜色。
2. 这个视频是探索性的还是回答一个特定的问题？这两个目标看似相似，但事实并非如此。探索性的可视化可以更一般化，包含大量信息——因为目标是引发思考和讨论。这意味着要盯着看，逐渐消化，不同的人在研究一个问题时会得出不同的结论。另一方面，旨在回答特定问题的可视化需要做到这一点——它们旨在明确支持你试图提出的任何观点。

现在让我们试着回答这些问题:

1. 我们希望利用我们的股票数据寻找有吸引力的行业或可能值得投资的单个公司。
2. 在本帖中，我们将关注探索性的视觉效果。挑选股票是一项复杂而主观的工作。我们的目的不是告诉人们买什么股票；相反，我们希望我们的可视化可以帮助他们识别和深入更具体的兴趣领域。

用 Tableau 可视化股市(终于！)

让我们先来看看 S & P 500 的树形图。标准普尔 500 指数是一个上限加权指数——这意味着每家公司在该指数中的代表与其市值成比例(市值是该公司所有股票的总价值，换句话说，就是收购整个公司的成本)。在下面的树形图中，每个矩形的大小和颜色对应于该公司在标准普尔 500 指数中的表现。

Larger Area and Deeper Colors Means Higher Market Capitalization

顶端有一些熟悉的面孔——苹果、微软、亚马逊、谷歌、伯克希尔·哈撒韦组成了前五名。有趣的是，这 5 大公司占标准普尔 500 指数市值的 17%,前 15 大公司占总市值的 30%。注意，仅仅是市值不足以解释是什么驱动了标准普尔 500 指数的价格变化——公司股价的波动也很重要。例如，尽管脸书(FB)的市值低于微软(MSFT)，但脸书的股价在过去 12 个月中波动更大，因为它试图避开一系列丑闻。因此，在过去的一年里，脸书的股票很可能比微软的股票更能推动标准普尔 500 指数的上涨。

可视化公司利润

拥有一家公司的股份相当于拥有同一家公司的一部分(无论多小)。例如，如果我们非常富有，购买了相当于公司 1%的股份，那么作为少数股东，我们有权获得 1%的利润。当然，作为小股东，我们也被迫将这些利润的管理和投资委托给谷歌的上层管理人员和董事会(这也是为什么我们即使拥有股份，也不会每季度从谷歌那里拿到利润分成支票)。

因此，如果一家公司的利润(又称净收入)是我们购买其股票时最终希望获得的，那么我们或许应该重新绘制利润的树形图。在下面的树形图中，每个矩形的大小和颜色对应着该公司利润的大小(又称净收入)。

Larger Area and Deeper Colors Means Higher Profits

虽然苹果和谷歌仍在前五名，但我们现在有了一些新面孔——摩根大通(JPM)、美洲银行(BAC)和富国银行(WFC)。尽管有关于技术如何颠覆传统行业的大肆宣传，银行业(作为一个传统行业)继续赚取巨额利润。被遗忘的科技巨头英特尔(INTC)、石油巨头埃克森美孚(XOM)和电信巨头美国电话电报公司(T)尽管在当今痴迷于创新的市场中有些被遗忘，但仍能赚得盆满钵满。

按 S&P 部门(按行业)可视化

我个人认为最好的长期投资策略是“低买高卖”(说起来容易做起来难)。但是我们怎么做呢？在最基本的层面上，对于我们支付的每一美元，我们应该试图购买尽可能多的利润。之前的想象向我们展示了不受欢迎的行业有时可能隐藏着不被重视的利润来源。让我们转而关注行业而不是公司，看看我们是否能找到一些好的利润来源。

下面的树形图根据市值中位数(每个矩形的面积)和利润中位数(每个矩形的颜色)对每个行业进行了细分。我们使用中位数是因为我们想知道，如果我从一个特定的行业中随机挑选一家公司，它的成本可能是多少(市值)，利润可能是多少(净收入)。

Larger Rectangles Means More Expensive, Greener Color Means More Profitable — Remember These are Medians!

在我们讨论结果之前，我们应该首先理解思考这个树形图的正确方式。我们用它来观察中值市值(我们支付的价格)和中值净收入(我们获得的利润)之间的关系。如果一个行业的价格与其中公司的利润完全相关，那么我们会认为最大的矩形是最绿的，并且随着矩形尺寸的减小，颜色会转变为红色。我们显然没有看到这一点，所以看起来有潜在的机会。

树形图突出了金融机构(银行、保险公司等。)和通信服务(谷歌、脸书、美国电话电报公司、迪士尼等。)作为寻找廉价股票的潜在有吸引力的行业——因为它们在矩形规模(市值中值)方面处于中游，但非常环保(利润中值高)。

与此同时，深红色的房地产似乎绝对不行。医疗保健似乎也是一个应该避开的行业，因为它拥有最高的中值市值和接近“垫底”的中值利润(这对我们来说是一个坏消息)。

当然，这些只是识别潜在投资的快速经验法则——在实际投资之前，应该进行更多的尽职调查。

什么是信息技术？

令人惊讶的是，在我们之前的分析中，包含苹果和微软等重量级公司的信息技术行业看起来并不出色——就价格而言，它很昂贵，但就中间利润而言，它却是“垫底”的。怎么回事？

有两个因素在起作用:

1. 2018 年末，谷歌和脸书从信息技术转向通信服务。这是两家利润丰厚的公司，人们将它们与科技紧密联系在一起。如果他们仍然在信息技术领域，那么它的市值和利润都会高得多。
2. 利润水平并不是投资者唯一关心的事情。这些利润是如何获得的也非常重要——像利润率(最终转化为利润的销售比例)和投资回报(为了产生一定水平的利润，我们需要向企业投入多少资金)也非常重要。

让我们用一个 Tableau 散点图来检验市盈率和 ROIC 之间的关系:

• 市盈率是衡量一家公司股票有多贵的常用指标。简单来说就是公司的市值除以其净收入——换句话说，我们购买特定公司 1 美元的收益需要多少钱。在其他条件相同的情况下，市盈率越高，股票被认为越贵。
• ROIC 代表资本投资回报率，代表我们对企业投资 1 美元所能产生的利润。投入资本是对经营某项业务所需资本量的衡量。例如，资本密集型企业就像丰田一样，需要大规模的工厂来生产汽车。另一方面，软件是一个轻资本的行业——一旦开发出来，就固定成本或基础设施(相对于产生的利润)而言，维护和部署像微软 Office (Word、Excel、PowerPoint、Outlook)这样的东西的成本非常低。

Median ROIC vs. Median P/E Ratio Scatter Plot

看看我们左边的散点图。它表明一只股票的市盈率(它有多贵)和它的 ROIC 之间是正相关的。这是有道理的——投资者喜欢高 ROIC 的公司，因为它们通常只需要很少的前期投资就能产生可观的利润(需要大量前期投资的公司被认为是有风险的，因为我们可能永远得不到回报)。

到目前为止，信息技术行业的 ROIC 中值最高。这也是有道理的，因为这个领域充满了软件公司，正如我们之前观察到的，资本非常少。因此，吸引投资者投资信息技术(并推动其高市盈率和市值)的不是当前的高利润，而是该业务的轻资本性质，以及今天相对较小的投资将在明天产生高增长和高利润的希望(每个人都喜欢易于扩展且成本低廉的业务模式)。

那会发生吗？我不知道，但市场目前正在下大赌注——所以如果你正在寻找好的机会，你可能会想看看其他地方。

最后，请注意金融板块的 ROIC 最低。这再加上银行的感知风险(2008 年有人吗？)大概推动了他们的低估值。但是银行使用资本的方式不同——银行不是借钱建工厂，而是向你我这样的人借钱，然后以更高的利率借出去。

通常，高投入资本意味着运营企业需要高固定前期成本。银行的情况并非如此——尽管拥有极高水平的投资资本(由于高负债)，银行的固定成本却很少。这种高负债确实让它们的风险更高，或许应该得到市盈率折扣，但我们不应该仅仅因为银行的低 roic 就把它们排除在投资之外——相反，我们应该寻求理解是什么驱动了这些低 roic，以及这是否是一个真正的问题。

结论

很好，我们坚持到了最后！老实说，我们还有很多可以探索的。股票市场和公司战略是两个极其深刻和丰富的主题；“买什么股票”是一个非常棘手的问题。在这篇文章中，我们只是开始触及皮毛。

然而，我希望我已经展示了可视化如何帮助我们消化复杂的数据集，并开始解决具有挑战性的问题。

干杯！

更由我论金融与投资:

做空波动的危害

我做的一个关于投资 Lending Club 贷款的数据科学项目

股市低迷

更多由我上数据科学:

随机森林分类器

神经网络如何工作

主成分分析

用散点图和 t-SNE 可视化主题模型

原文：https://towardsdatascience.com/visualizing-topic-models-with-scatterpies-and-t-sne-f21f228f7b02?source=collection_archive---------12-----------------------

不管是好是坏，我们的语言还没有进化成乔治·奥威尔 1984 年的新话版本，有人知道吗？).但是如果英语类似于新话，我们的计算机理解大量文本数据会容易得多。当今自然语言处理(NLP)的挑战来自于这样一个事实，即自然语言天生是模糊的，不幸的是不精确的。

文本数据与图像和视频等格式一起属于非结构化数据。根据 Dama 的说法，“非结构化数据在技术上是指任何没有被标记或以其他方式组织成行、列或记录的文档、文件、图形、图像、文本、报告、表格、视频或录音。”“非结构化”这个标签有点不公平，因为通常还是有一些结构的。图像分解成用 RGB 或黑/白数值表示的像素行。文本在文档中分解成句子、段落和/或章节，文档的集合形成语料库。

对于理解书面自然语言的计算机来说，它需要理解文本背后的符号结构。使用下面的一些自然语言处理技术可以让计算机对文本进行分类，并回答诸如主题是什么之类的问题。语气积极吗？主观？读起来有多容易？

下面是一些我发现对揭示语料库背后的符号结构有用的自然语言处理技术:

• 主题建模(主题、聚类)
• 单词/短语频率(和“关键字搜索”)
• 文本可视化(单词树，单词云均由@Jason Davies 提供)
• 嵌入(例如 Word2Vec)
• 情感分析(正面/负面、主观/客观、情感标签)
• 文本相似性(例如“余弦相似性”)
• TF-IDF(术语频率/逆文档频率)
• 词性标注

在这篇文章中，我将重点关注我用来理解文本的主要技术:主题建模，特别是使用guide LDA(一种增强的 LDA 模型，使用采样类似于半监督方法，而不是无监督方法)。我在训练一个主题模型后遇到的一个困难是显示它的结果。主题模型的输出是一个文档主题矩阵，形状为 D x T — D 行表示 D 文档，而 T 列表示 T 主题。单元格包含介于 0 和 1 之间的概率值，该值为每个文档分配属于每个主题的可能性。文档-主题矩阵中各行的总和应该总是等于 1。在最佳情况下，文档将很有可能被分类到单个主题中。对于更模糊的数据——每个文档可能谈论许多主题——模型应该在其讨论的主题中更均匀地分布概率。以下是 GuidedLDA 模型输出的文档主题矩阵的前几行示例:

Document 0 belongs to topic 0 with 71% probability and topic 1 with 29% probability. Document 1 belongs to topic 0 with almost 100% probability. And so on.

像上面这样的文档主题矩阵很容易变得非常庞大。除非结果被用来链接回单个文档，否则从整体上分析文档-主题-分布可能会变得混乱，尤其是当一个文档可能属于几个主题时。这就是我想用散点图和饼图的组合来可视化矩阵本身的地方:请看散点图！

Each bubble is a document. Bubbles are colored by topic probability and sized by #1 topic probability (argmax of each row/document in the document-topic matrix). Where there is a pie chart, the document belongs to multiple topics with varying probabilities. The scatterpie chart shows which topics tend to co-occur and how topics overlap with each other. Individual bubbles (documents) are pulled in the direction of the “center of mass” of another topic they may also belong to. Note: to simplify the chart, you may need to filter out documents with #1 topic probability less than some threshold. In this example, I removed documents with #1 topic probability < 0.3 to clean up the visualization.

但是不要这么快——你可能首先想知道我们是如何将主题简化成一个易于可视化的二维空间的。为此，我使用了 t-分布式随机邻居嵌入(或 t-SNE)。从 GuidedLDA 获取文档-主题矩阵输出，用 Python 运行:

from sklearn.manifold import TSNEtsne_model = TSNE(n_components=2, verbose=1, random_state=7, angle=.99, init=’pca’)# 13-D -> 2-D
tsne_lda = tsne_model.fit_transform(doc_topic) # doc_topic is document-topic matrix from LDA or GuidedLDA 

在将 t-SNE 数据的两个数组(使用tsne_lda[:,0]和tsne_lda[:,1])连接到原始的文档-主题矩阵之后，我在矩阵中有两列可以用作散点图中的 X，Y 坐标。

对于情节本身，我切换到 R 和 ggplot2 包。下面代码片段中的 dataframe data 特定于我的示例，但是列名应该或多或少是不言自明的。 x_tsne 和 y_tsne 是 t-SNE 结果的前两个维度。 row_id 是每个文档的惟一值(就像整个文档主题表的主键)。 x_1_topic_probability 是文档-主题矩阵每一行中的#1 最大概率(即文档最有可能代表的主题)。 topic_names_list 是每个主题带有 T 标签的字符串列表。

library(ggplot2)
library(scatterpie)# high resolution tiff image
tiff(“scatterpie.png”, units=”in”, width=12, height=9, res=500)# plot
p <- ggplot() + 
 geom_scatterpie(aes(x=x_tsne, y=y_tsne, group=row_id, r=x_1_topic_probability), data=data, cols=topic_names_list, color=NA, alpha=0.7) + 
 coord_equal() + 
 geom_label(...) + 
 ggtitle(“Scatterpie Chart”) + 
 xlab(“”) + ylab(“”) + labs(subtitle=”t-SNE Representation of Guided-LDA Topics Colored and Sized by Topic Probability”) +
 scale_fill_manual(values=colors) + 
 theme_minimal() + 
 theme(text = element_text(color=”white”),
 legend.position = “none”,
 panel.background = element_rect(fill = “gray17”, colour = “gray17”), 
 plot.background = element_rect(fill = “gray17”),
 panel.grid.major = element_line(colour = “gray25”),
 panel.grid.minor = element_line(colour = “gray25”),
 axis.text = element_text(color=”white”)) # shut down graphics device
dev.off()

瞧，您已经有了构建主题模型输出的散点图表示的基本要素。将来，我想通过一个交互式的图(looking you， d3.js )来进一步发展，在这个图中，将鼠标悬停在一个气泡上可以显示该文档的文本以及关于其分类的更多信息。

如果你对更酷的 t-SNE 例子感兴趣，我推荐你去看看劳伦斯·范·德·马腾的页面。

Left & middle: 2D & 3D t-SNE visualization of 6,000 digits from the MNIST dataset. Right: t-SNE visualization of image data. Source

可视化全球妇女的无偿工作(特别图表)

原文：https://towardsdatascience.com/visualizing-womens-unpaid-work-across-the-globe-a-special-chart-9f2595fafaaa?source=collection_archive---------15-----------------------

想象一下，如果世界各地的女性不再做她们日复一日做的所有家务劳动:做饭、打扫卫生、照顾孩子、洗衣服、购物等等。全球经济将崩溃，社会将停止运转。

然而，尽管报告接报告关于减少全球妇女的时间贫困的重要性，无偿劳动的负担继续不成比例地落在妇女身上，尤其是在发展中国家。

即使对于高收入国家的女性来说，一旦她们下班回家,“工作”并没有停止，而是开始了。例如，在美国，女性仍然比男性多花将近一个小时做家务。

为了庆祝国际妇女节，并纪念全球女性做出的往往被低估的贡献，我们制作了这张令人大开眼界的图片，展示了世界各地男性和女性在无偿工作上所花时间的差异:

Data source

通过比较每个圆圈与其余圆圈的相对面积，可以清楚地看到，无报酬工作(经合组织定义为日常家务劳动、购物、照顾家庭成员、志愿服务和与家庭活动有关的旅行)不平等程度最高的国家是印度、日本、韩国、墨西哥、土耳其和葡萄牙。

同时，那些平等程度最高的是斯堪的纳维亚国家，如瑞典、挪威、芬兰和丹麦。在这些国家后面是差距稍大的国家，如加拿大、美国、德国、英国、比利时和法国。

与经合组织的休闲时间统计数据相比，这一点值得一提，该数据显示，在所有经合组织国家中，妇女仍然工作更多，娱乐更少，如下文的圆形柱状图所示:

Data source

在这方面，男女休闲时间差距最大的国家显然是葡萄牙、希腊和意大利，而差距最小的国家是挪威、丹麦、荷兰和新西兰。

你如何解释上述经合组织国家无薪工作和闲暇时间的数据可视化？你是否同意全球发展专家的观点，即无偿工作应该更加公平地分配，以促进世界各地妇女的经济和社会进步？让我们知道你的想法。

本帖 原版 最早出现在 Visme 的 视觉学习中心 。

VLOOKUP 和数组公式正在改变游戏规则

原文：https://towardsdatascience.com/vlookup-and-array-formulas-are-changing-the-game-789e1b233c0d?source=collection_archive---------9-----------------------

Microsoft Excel 是现代工作场所中使用最广泛的工具之一，但也是使用最少的工具之一。我认为这应该改变，我认为应该从 VLOOKUP 开始。这就是为什么，我想花一点时间来谈谈使用 VLOOKUP 作为一个数组公式。

什么是数组公式？

数组公式是 Excel 的一项功能，允许您对多个值执行公式运算。这到底是什么意思？

好吧，假设我有两个数据集，我想连接在一起

• 芝加哥市的所有营业执照
• 芝加哥市的所有企业主

营业执照文件有我需要的关于执照本身的所有数据，但是个人所有者的名字位于企业所有者文件中。我不想一页一页地翻来翻去看业主的名字，所以我想把业主的名字和姓氏拉到营业执照数据集中。为此，我将使用一个 VLOOKUP 数组公式来获取两个值，而不是一个值。

使用 VLOOKUP

为了将两个文件连接在一起，我需要在两个文件之间找到一个公共元素。幸运的是，我们可以在许可证和所有者文件中看到，我们有一个可以使用的帐号。

The account number is a common field between both files

设置

在许可证文件中，我将在帐号字段的右边创建两个新列。这些新列将保存我的名字和姓氏字段。

在 Excel 文件中，您可以通过右键单击并选择 insert 来创建一个新列，或者只需按 ALT+I，C

连接数据

现在我已经设置好了工作表，我将使用 VLOOKUP 作为数组公式从所有者文件中提取名字和姓氏数据。为了便于参考，我将两个文件并排打开。

首先，我在许可文件中选择单元格 D2 和 E2，作为我的第一行数据将要存放的位置。

Select the cells that you will be populating

接下来，我将开始输入我的 VLOOKUP 公式。

VLOOKUP 接受几个输入值

1.查找值

2.表格数组

3.列索引号

4.范围查找

在这种情况下，我的查找值将是许可证文件中的账号或 C2。我的表数组将是所有者文件中的数据，从帐号列开始，一直到所有者姓氏列。我的列索引号将是名字和姓氏，或者是第 3 列和第 5 列。VLOOKUP 通常只接受一个值，但是因为我们使用的是数组公式，所以我们可以给它多个值，把它们放在括号中— {3，5}。只要我们有两个字段用于填充数据(D2 和 E2)，公式就会正确返回值。在这种情况下，它会将名字返回给 D2，将姓氏返回给 E2。

因为这是一个数组公式，所以我需要按 CTRL+SHIFT+enter，而不是在公式末尾按 ENTER。这将把我的整个公式用括号括起来，让 Excel 知道这是一个数组公式。

收尾工作

这样做之后，我可以将公式应用到电子表格的其余部分。最后，我复制所有内容并作为值粘贴，以便将数据完全复制到许可证文件中。

结论

Microsoft Excel 是一个多功能工具，当您不太需要完整的关系数据库设置时，它可以帮助您进行快速数据操作。

你在用 Excel 解决什么问题？Excel 的不足在哪里？我很乐意继续这个话题。如有任何反馈，请通过推特联系我！

使用 GANs 进行语音翻译和音频风格转换

原文：https://towardsdatascience.com/voice-translation-and-audio-style-transfer-with-gans-b63d58f61854?source=collection_archive---------3-----------------------

如何使用 Spectrograms 和 GANs 将爵士乐转换为古典音乐

Photo by Michael Maasen on Unsplash

介绍

我们都听说过图像风格转移:从一幅名画中提取风格并将其应用到另一幅图像中，这是一项已经通过多种不同方法实现的任务。生成对抗网络(简称 GANs)也被用于图像生成、图像到图像的翻译等等。

Examples of image style transfer

但是声音呢？从表面上看，你可能会认为音频与图像完全不同，所有为图像相关任务探索的不同技术都不能应用于声音。但是，如果我们能找到一种方法将音频信号转换成类似图像的二维表示会怎么样呢？

事实上，是的，我们可以！这种声音表示就是我们所说的“声谱图”，它是允许我们利用专门设计的算法来处理音频相关任务的关键。

Spectrogram (source)

光谱图

如果你是音频处理领域的新手，你可能不熟悉声谱图到底是什么。给定一个时域信号(一维)，我们希望获得一个时频二维表示。为了实现这一点，我们对音频信号应用具有特定长度窗口的短时傅立叶变换 (STFT)，仅考虑结果的平方幅度。

Incredible illustration of how Time and Frequency correlate from the MelNet paper page

更简单地说，我们将原始波形信号分成相互重叠的块，提取块中频率的幅度(通过傅立叶变换)，每个结果向量将代表我们最终频谱图的一列。谱图的 x 轴代表时间，y 轴代表频率。

为了让这些频谱图对我们的任务更有用，我们将每个“像素”(或量值)转换成分贝标度，取每个值的对数。最后，我们应用 mel 滤波器组，将光谱图转换为 mel 标度，得到所谓的 mel 光谱图。

Examples of mel-spectrograms with log-amplitude

这让我们能够让声谱图表现方式对我们人类对声音的理解更加敏感，突出我们人类更容易听到的振幅和频率。

同样非常重要的是要注意，频谱图可以被转换回成“可听见的”波形数据:这不会是一个完美的重建(相位信息在我们的幅度频谱图中丢失了)，但是由于一种叫做 Griffin-Lim 的算法，我们能够近似相位并且重现真实的声音音频。

我们的任务

现在我们知道了如何用图像来表示声音，让我们来玩一玩。

在这篇文章中，我将解释如何构建和训练一个能够执行语音转换和任何其他类型的音频风格转换(例如将一种音乐风格转换为另一种)的系统。该方法在很大程度上受到最近使用生成式对抗网络进行图像到图像翻译的研究的启发，主要区别在于将所有这些技术应用于音频数据。作为一个额外的功能，我们将能够翻译任意长度的样本，这在 GAN 系统中并不常见。

为了让你对将要学习的内容有一点兴奋，这里有一个演示视频，展示了我们用这种方法可以达到的效果。

在演示视频中，你可以听不同的语音翻译示例以及一些音乐流派转换，特别是从爵士乐到古典音乐的转换。听起来很不错，不是吗？

选择架构

计算机视觉领域有许多不同的架构用于图像到图像的翻译，这是我们希望通过音频(比如说语音)的频谱图表示来实现的任务。

图像到图像的转换在于将图像从域 A(例如猫的图片)转换到不同的域 B(狗的图片)，同时保持来自原始图片(猫的表情和姿势)的内容信息。我们的任务实际上是相同的:我们希望从说话者 A 翻译到说话者 B，同时保持来自说话者 A 的相同的语言信息(生成的语音应该包含与来自说话者 A 的原始语音相同的单词)。

CycleGAN architecture

为这个目标打造的最著名的** GAN 架构可能是 CycleGAN ，于 2017 年推出，此后被广泛使用。虽然 CycleGAN 在相似领域(相似的形状和背景)之间的翻译非常成功，比如从马到斑马，或者从苹果到橙子，但当涉及非常不同的领域时，比如从鱼到鸟，或者从苹果到胡萝卜，它就显得力不从心了。**

这个缺点的原因是 CycleGAN 严重依赖于像素损失的事实，或者换句话说，它的损失倾向于最小化真实和生成图像的像素值的差异:直觉上，当将一个对象(例如苹果)的图像转换到一个实质上不同的域(胡萝卜)时，我们需要改变原始对象的主要形状，在这种情况下 CycleGAN 不能帮助我们。

CycleGAN translation example. (Zebra to Horse)

不同人的演讲的频谱图(或不同流派的音乐作品的频谱图)在视觉上可能彼此非常不同:因此我们需要找到一种更通用的方法来解决这个问题，一种不涉及被视觉上相似的领域之间的翻译所约束的方法。

Spectrograms of different speakers or different music genres can be very visually different

TraVeLGAN:我们的解决方案

最初在这里介绍的 TraVeLGAN (变换向量学习 GAN)旨在解决我们的问题。

Examples of TraVeLGAN image-to-image translations with very different domains

除了生成器和鉴别器(或评论家)，TraVeLGAN 还引入了一个暹罗网络(一个将图像编码为潜在向量的网络)以允许在实质上不同的域之间进行翻译，从而保持原始样本和转换样本之间的内容关系。

让我们了解一下 TraVeLGAN 到底是如何工作的。

TraVeLGAN architecture

我们的目标是找到一种方法来保持原始样本和生成样本之间的关系，而不依赖于像素损失(如 CycleGAN 中的循环一致性约束)，这将限制视觉上相似的域之间的转换。因此，如果我们将图像(或光谱图)编码成向量，这些向量在组织的潜在空间中捕获它们的内容信息，我们就能够保持这些向量之间的关系，而不是整个图像。

这正是一个暹罗网络让我们实现的目标。最初用于人脸识别的任务，暹罗网络将一幅图像作为输入，而输出一个长度为 vec_len 的单一向量。使用损失函数指定矢量空间中哪些图像编码应该靠近(例如同一张脸的图像)以及哪些应该远离(不同脸的图像)我们能够组织潜在空间并使其对我们的目标有用。****

The Siamese network encodes images into vectors

更具体地说，我们的目标是保持编码对之间的变换向量 相等:这似乎是一个非常难以理解的概念，但实际上是非常容易理解的。****

以 G(X) 为平移图像 X (生成器的输出) S(X) 为矢量编码的 X 和 A1、A2 两幅图像来自源域 A ，网络必须对矢量进行编码，如:

(S(A1)-S(A2))=(S(G(A1)-S(G(A2)))**

这样，连接一对源图像编码的变换向量必须等于由生成器转换的同一对之间的变换向量。

这允许在翻译中保留语义信息(不同于使用其循环一致性约束保留更多几何内容信息的 CycleGAN)，允许约束不同域的图像之间的更多“抽象”关系。

形式上，为了在翻译中保留内容信息，我们将最小化两个变换向量之间的欧几里德距离和余弦相似度，以便向量的角度和幅度都得到保留。

Formal TraVeL loss

此外，重要的是澄清发电机和连体网络必须配合来实现这一目标。更具体地说，行程损耗的梯度从到反向传播到两个网络，并且它们的权重相应地更新。因此，当鉴别者和发生者有一个对立的目标(他们互相挑战以达到他们的目标)时，暹罗人和发生者互相帮助，在相同的规则下合作。

除了这种“内容”损失之外，由于传统的对抗性损失(在我的实验中，我使用了铰链损失)，生成器将学习如何生成逼真的样本。

如果你是 GANs 及其工作方式的新手，或者如果你想更深入一点如何用潜在空间保存内容信息，我推荐你查看 我的文章这里讲述如何在一个简单的图像到图像的翻译任务中应用相同的技术。

翻译任意长度的音频信号

既然我们已经探索了一种允许我们在翻译中保留内容信息的方法，我们需要理解如何让生成器转换任意长的样本，而不增加额外的计算和训练时间。

假设我们有一个音频信号:“提取”该信号的 mel 谱图，我们获得一个具有单通道的图像(不同于传统的 3 通道 RGB 图像)，该图像具有确定的高度(这取决于用于 STFT 的跳数大小)和宽度×25取决于音频样本的原始长度。********

然而，众所周知，处理具有可变尺寸的图像是一项具有挑战性的任务，尤其是如果我们事先没有决定这些尺寸的话。这就是为什么我们将分割所有光谱图(形状 XxH 与 X 不同)成块与确定宽度，让我们说 L 。完美！我们的数据集现在由具有已知尺寸* ( LxH )的源和目标光谱图组成，我们已经准备好进行下一步。***

Each spectrogram in the dataset has a fixed height H and width L

在创建我们的生成器 G 之前，我们需要指定其输入的尺寸，在我们的例子中是 (L/2)xH 。换句话说，G 将接受我们数据集中宽度为一半的光谱图。为什么？因为这样我们就能让 G 翻译我们之前拆分的整个* XxH 光谱图。让我们来看看是如何做到的。*****

我们的培训管道将包括以下行动:**

1. 将源 LxH 谱图分成两半，得到 (L/2)xH 谱图**
2. 将两半对送入发电机，并将平移的两对作为输出**
3. 将平移的两半连接回它们的原始形状* ( LxH )***
4. 将经翻译的和目标和 LxH 光谱图送入鉴别器，使区分和对抗训练。**

Illustration of the training pipeline: splitting, converting and concatenating.

使鉴别器检查连接的“假”光谱图和，将与“真实”目标光谱图进行比较，迫使发生器生成样本，当连接在一起时，产生真实光谱图。****

换句话说，转换后的 (L/2)xH 样本不得在边缘上出现任何不连续，这将使它们在鉴别器看来不真实。因此，发生器上这个重要的约束允许我们将任意长度的音频信号从一个域转换到另一个域。**

训练后，当想要翻译一个任意形状的声谱图 XxH 其中 X 变化并由原始音频信号的长度给出时，这是我们需要做的:**

1. 将 XxH 谱图分割成 (L/2)xH 块，如果 X 不能被 L/2 整除，则使用填充
2. 将每个 (L/2)xH 样本送入发生器进行翻译
3. 连接转换后的样本为原始 XxH 形状，如果使用了填充，则剪切掉多余的部分。

在用 Griffin-Lim 算法将其变回波形之后，最终翻译的样本不应呈现* 不连续，而应呈现与目标域(特定的语音或音乐流派)相同的风格。很简单，不是吗？***

Examples of source and converted spectrograms: the concatenated samples do not present discontinuities

把所有东西放在一起

我们之前已经学习了如何保存来自源音频样本的内容(在语音的情况下，它将是一些言语信息，在音乐的情况下，它将是一首歌曲的特定旋律，而没有在视觉上相似的域之间进行转换的约束(不同声音或音乐流派的频谱图在视觉上可能极其不同)以及允许我们转换任意长度的样本的简单而有效的技术**

现在终于是时候把所有的事情整合在一起了。

这是我论文中的一段摘录，介绍了这项技术:****

Putting everything together: the siamese network helps preserve content keeping vector arithmetic between source and converted samples

梅尔根-VC 训练程序。我们分离频谱样本，将它们馈送到发生器 G，将它们连接在一起，并将结果样本馈送到鉴别器 D，以允许无差异地翻译任意长度的样本。我们在传统的生成器-鉴别器 GAN 架构中添加了一个连体网络 S，以在潜在空间中保留矢量算法，从而在翻译中对低级内容进行约束。在还需要保存高级信息(在语音翻译的情况下是语言信息)的任务中添加了可选的身份映射约束。

此外，我们必须为暹罗网络增加一个边际损失，以避免它从退化为学习一个平凡函数来满足它的目标。边际损失使得 S 产生的所有向量彼此远离，因此网络不能将相同的精确向量与每个输入相关联，并且必须学习有意义的关系*创建有用的潜在空间。*******

where delta is a fixed value and t is the transformation vector

最后，下面是用于训练三个网络的形式损失:**

Final losses for generator G, discriminator D, siamese network S

值得注意的是，添加的身份约束(来自目标域的样本和由生成器翻译的那些相同样本之间的均方误差)仅在语音翻译的情况下有用，其中语言信息必须被保留，并且其中我们的内容丢失(基于暹罗网络的向量输出)努力捕获那些高级别信息。**

如果你在寻找关于这种特殊技术的更多信息，或者如果你更喜欢一个更正式和系统的解释，我推荐并邀请你阅读我的全文。****

结论

今天，我们已经学习了如何使用深度卷积神经网络架构和一些技巧和技术来执行语音翻译和音频风格转换(如音乐流派转换)，以实现对任意长度音频样本的逼真的翻译。**

我们现在知道，我们能够利用大部分最近关于深度学习的研究用于计算机视觉应用，也解决与音频信号相关的任务，这要归功于图像等效频谱图表示。**

最后，我想以承认这样一个事实来结束我的发言，即可能会为了恶意目的而误用这种和其他技术，尤其是在语音翻译的情况下。随着强大的机器学习方法的兴起来创建真实的虚假数据我们在探索和使用这种算法时都应该非常警觉和谨慎:虽然研究不会停止也不应该停止，我们也应该分配资源并研究如何检测我们帮助创建的虚假数据。**

非常感谢您宝贵的关注，玩得开心！**

另外，如果您对 GAN 和 GAN 相关的现成想法和应用感兴趣，您也应该查看:**

一年来我训练甘斯的 10 个教训(如果你对帮助你完成超级挑战任务的技巧和窍门感兴趣，那就是训练甘斯)****

在高清图像上使用 GANs 进行风格转换(我使用了类似的技术，允许使用很少的计算资源进行大图像的风格转换)

以新的方式看待甘斯(我在这里详细探讨了潜在空间是如何工作的，以及它如何被用于图像到图像的翻译任务)

用生成式对抗网络合成音频(在这里我研究了一篇论文，该论文提出使用卷积 gan 来使用原始波形数据和一维卷积生成音频)

Voronoi 方法:分区学校系统提案

原文：https://towardsdatascience.com/voronoi-method-zoning-school-system-proposal-8ea333e9ece1?source=collection_archive---------36-----------------------

source : unplash.com

也许现在讨论这件事有点太晚了。因为分区学校系统现在不是一件事，但在 2019 年 5 月和 6 月左右，它在印度尼西亚是一件大事。

印度尼西亚有一个新的规则(紧接着是另一个规则)来创建类似“分区系统”的东西，未来的学生不能选择他们区域之外的下一级学校。然而，老实说，我真的不太明白这个规则。所以，这里有一篇巴哈萨语的文章，是关于这条规则以及政府颁布这条规则的原因。

[## 2019 年 PPDB 赛区系统。身份证明

tirto.id -巴鲁(PPDB) 2019 年奥运会将于 2019 年举行。

tirto.id](https://tirto.id/memahami-sistem-zonasi-sekolah-di-ppdb-2019-ecEz) [## 9 点，2019 年 PPDB 地区系统会议召开

kompas . com ----教育和科学部(Mendikbud)的多名官员有效地提出了几项建议……

edukasi.kompas.com](https://edukasi.kompas.com/read/2019/06/20/11111981/9-poin-buka-bukaan-mendikbud-soal-sistem-zonasi-dan-ppdb-2019?page=all)

那里的所有规则都产生了许多来自公众的病毒式负面反馈，如下所示:

1. 一些学生不能上学，因为他们只能选择一所已经满员的学校(半径规则)。
2. 有些学校招不到足够的学生，因为他们所在的地区不够密集。
3. 区域间质量不平衡。

点击这里了解问题的细节。

我不会谈论这些规则，以及这些规则如何对印度尼西亚未来的学生产生重大影响。此外，我不会责怪规则本身，因为我不知道印度尼西亚政府是如何制定这条规则的。然而，在这篇博客中，我想提出某种方法来解决这个“分区问题”，这种方法可能可以将负面影响降至最低。我将展示我是如何做分析的，并以方法结束。

定义问题

每一个分析都必须从问题定义开始，以北极星作为真正的目标。在这个博客中，我的目标是做一个分区学校系统，将上述第一个负面影响降到最低。我将问题限制在最小化第一个问题，因为我只有有限的数据可以处理。第二个问题也许可以用密度人口数据解决，同时，第三个问题应该用所有学校的标准化质量。

因此，基于我的目标，我的问题陈述是

“如何创建分区学校系统，让未来的学生至少有 3 所学校可以选择？”

数据收集

有了问题陈述之后，接下来要做的就是获取适合问题的数据。我需要印度尼西亚所有学校的经度和纬度位置，这样我就可以定义这个区域。我从这个来源获得数据，我认为这个来源对任何人都是开放的(至少在印度尼西亚)。所以，我抓取了所有列出的可能的学校及其信息。

Get the Longitude and Latitude

我花了大约两天的时间获得正确的数据，我得到了大约 200，000 所各级学校的数据:小学(SD)，初中(SMP)和高中(SMA/SMK)。我不确定数据的质量，但当我试图从网站上绘制所有的经度和纬度时，结果如下。

Probably All School Location in Indonesia

它显示了印度尼西亚的地图，因此该图可以确认数据的质量足够好。为了与真实地图进行对比，我用 python 从这个源中读取了印尼城市层面地图的 shapefile。

Indonesia’s Map

即使有几乎相同的形状，在检查数据后，几乎有 2%的点不完全在城市多边形内。面外的点将从方法分析中移除。这是一个来自“泗水”的例子，它有多边形外的点(红点)。

Surabaya All School Location’s

为了进行简单的探索，这是印度尼西亚每个城市在网站上正式注册的学校总数的热图。红色区域是一个缺失值，因为 shapefile 和报废数据的命名约定不同。地图显示爪哇岛(南面黄色的大岛)比其他岛屿发展了更多的学校。此外，除了爪哇岛， 学校的数量在空间上不相关 。例如苏门答腊岛(西边的大岛)，它有一个被绿色区域包围的黄色区域。

Total School in Every City of Indonesia

Radius 主体概述

在提出这种方法之前，让我们看一下使用半径原则的分区系统。方法并不复杂，未来学生学校区就在离家 X 公里的半径范围内。

Radius Principal

所以，学生不能选择离他们家很远的学校(红色区域)。如果保证在这个区域内有学校，这个校长可能会工作。让我们使用印度尼西亚学校位置数据来模拟这种方法。

模拟很容易，只需在一个特定城市的多边形上选取许多随机点，并对学校的不同半径进行迭代(从学校点改变半径比随机点更容易，结果是一样的)。随机点被假设为学生住宅，如果城市足够密集，这个假设可以实现。因为我们不希望随机点最终出现在森林中间或废弃的湖中。因此，基于某些参考资料，模拟在 DKI 雅加达、哥打泗水、哥打棉兰、哥打万隆、哥打望加锡和哥打巨港进行。需要注意的是，的模拟只使用位置的高中(SMA)数据。

这是泗水上的模拟例子，颜色显示了特定半径内每个随机点将获得的学校选择数量。红点是泗水的 SMA 位置。

对总体密集城市的模拟表明，对于不同的地区，所有学生获得最少 3 所学校选择的概率是不同的。下图显示了在许多不同的城市(用颜色区分)中，学生从他们家(x 轴)的一定半径范围内获得至少 3 个学校选项(y 轴)的概率(百分比)。因此，预计 x 轴越高，直线越接近 100。

该图描述了即使半径为 X= 4 公里，仍有某个区域像巨港一样，其概率低于 80%。就算是一个叫万隆巴拉特的城市，半径 X =5 公里也达不到 60%。

这意味着学生需要至少行驶 5 公里才能获得至少 3 个学校选择的概率为 60%,以获得万隆巴拉特的所有学校。而且，这里的半径采用欧几里德距离，所以现实生活中的真实距离可能比 5 公里更远。

总之，半径原则更适合用于人口密度高的城市。但是，如果必须对不同密度的所有城市实施这些方法，那么 半径距离应该对不同的区域有所不同 取决于人口密度。甚至可以将城市划分成某些更小的区域，并对这些区域采用不同的半径。不仅如此，发展新学校对于那些学校数量很少的地区也是必要的。因此，学生将有不同的学校选择，他们不应该把时间花在路上。

提议的方法

分区系统真的很有挑战性，尤其是像印度尼西亚这样全是小岛的地区。上述半径原则缺乏多样性，需要更多的探索来确定正确城市的正确半径。如果学生来自不同的岛屿，比如望加锡，这也是一个不利因素。如果到最近学校的岛距大于半径，那么那个岛上所有学生到校的可能性几乎为零。

Makassar has many smalls island

因此，提出了一种称为 Voronoi 的新方法来最小化确定半径的耗时探索。Voronoi 是一种将平面分割成靠近给定对象集合中每个对象的区域的方法。假设我们有一个平面，平面上有一些点，Voronoi 的目标是创建每个区域都比其他点更靠近某个特定点的区域。

Voronoi diagram example (source)

假设我们有一张地图和所有学校的位置，Voronoi 将自动为每所学校创建区域，这样该区域中的每个学生都比其他学校更靠近该学校。然而，这意味着如果他们必须进入最近的学校，每个学生只有一个学校选项可以选择。因此，学校集群被提议创建一个更大的区域，在那里学生可以有 3 个学校的最低选择。现在，我提出了 KMeans 来对每个城市的学校进行聚类(最好使用 HDBSCAN 作为将来的参考)，这导致了另一个选择聚类数的问题。在这种情况下，可以使用轮廓分数来评估集群编号，其中我们将选择具有最高分数的集群编号。必须记住的是 这里所有的学校都被假定为具有相同的质量 以防止来自所有不良学校的群集。

总之，这是所提出方法的算法

Pseudocode of the Algorithm

这是望加锡和万隆巴拉特的算法结果。

Senior High School (SMA) Proposed Zoning System

Voronoi 方法将确保城市中的每个学生至少有 3 个选择学校，它解决了以前万隆巴拉特的“60%问题”。Voronoi 也帮助远岛上的学生有机会上学。

然而，对于一些区域，如万隆巴拉特的棕色区域(左下方)，平均而言， 学生必须旅行相当长的时间， 因为该区域相当大，只有 3 所学校可供选择。这可能表明 Voronoi 方法将不会解决“该区域中所有学校已经满员”的问题。这个问题也出现在绿色区域的巨港和紫色区域的泗水(左上)。

Surabaya and Palembang Proposed Zoning School for SMA

结论和建议

分区制度的建立是为了实现教育质量的平等，这样就不会有高等或低等的教育区域。即使有良好的意图，糟糕的分区系统和不规范的学校质量将使教育系统看起来很糟糕，并减少许多学生进入学校的权利。

如模拟所示，对于印度尼西亚，在相同的半径下，学生获得至少 3 所学校选项的概率是不同的。在雅加达和巨港两公里半径范围内，这种可能性几乎达到 100%,但在同样的半径范围内，这种可能性在巨港大约为 50%。由此可见，半径距离对于不同的区域应该是不同的。

带 KMeans 聚类的 Voronoi 图 是另一种比半径原理更好的方法，可以覆盖半径问题。Voronoi 图可以为每个学校创建一个最佳区域，这样就不会有学校选项超过 3 个的区域。然而，如果一所学校覆盖了一个很大的区域，就会出现问题，因为附近的学校数量很少。

因此，要想取得更优的解决方案，这里可以做一些动作

1. 在沃罗诺伊地区的学校周围建造更多的学校。或者扩展具有大 Voronoi 区域的学校。
2. 对学校质量多做分析，给印尼所有城市做一个标准质量。这里在设施、教师数量和班级方面的质量。因此，我们可以使用群集进行分区，其中群集间的总体质量是相同的。
3. 此外，对于短期解决方案，增加学生的公共交通，使他们能够到达遥远的学校，而不是通过半径原则限制他们的选择。

参考

[## alam hanz/教育区

它始于印度尼西亚政府的新 Zonasi 规则，这似乎对某些人不公平(基于病毒式新闻)。这个…

github.com](https://github.com/alamhanz/education_zone/tree/master) [## Voronoi 图实验室

除了直接读入 CSV 文件。Pandas 内置了一个读取 JSON 文件的函数。本节…

comet.lehman.cuny.edu](http://comet.lehman.cuny.edu/owen/teaching/datasci/voronoiLab.html)

Vue。js Vs angular . js:Web 开发中性能最好的 JavaScript 框架是哪一个？

原文：https://towardsdatascience.com/vue-js-vs-angular-js-which-is-the-best-performing-javascript-framework-for-web-development-f5f6a9ef4038?source=collection_archive---------19-----------------------

随着时间的推移，在流行的 Javascript 框架之间做出选择变得越来越具有挑战性。在这篇博客中，我们希望能轻松地做出这个决定。

谈到 web 开发，JavaScript 框架是目前 web 开发公司的热门词汇。

每个人都在不停地讨论 JS 库和关于 JS 的“大 2”——Angular 的争论。JS 和 Vue。JS”一天比一天严重。

根据 2019 堆栈溢出报告 显示，67.8%的开发者使用 Javascript，并使其成为网站开发社区中流行的编程语言。另一方面， JavaScript 是最复杂的编程语言，因为 8.36%的 JS 代码被深度嵌套。

JavaScript 明日之星报告 已经追踪到 GitHub 上添加的星星数量。结果 Vue，React，Angular.js 是 2018 年最受欢迎的 js。 Vue 以 45.3K+位居星数榜首，历史上首次超过 React 和 Angular。 然而，GitHub 星级并不是理解 JS 框架的唯一途径；相反，它们描绘了网络发展的最新趋势。不用担心；这篇博客已经涵盖了其他各种统计数据，这些数据显示了主导前端框架的更全面的情况。

选择一个技术堆栈有时是一项令人烦恼的任务，因为你需要考虑各种因素，包括运行时性能、灵活性、维护、最终用户、预算等等。

无论你是新手、开发者还是自由职业者，为你的网站建立一个架构师是每个人的基本任务。这篇文章不仅能帮助你选择最佳方案，还能帮助你做出最终决定。读完这篇博客后，你可以根据你的项目范围和框架与你的需求的兼容性来选择最好的一个。然而，这篇文章将通过详细的比较以及趋势和见解帮助你更好地理解每个结构。

咱们之间的战斗开始了 Vue.js VS Angular。Js 2019…

Vue Js。Vs Angular.Js:了解 Big 2 的基础知识

Vue Js。Vs Angular.Js:受欢迎程度和市场趋势

Vue Js。Vs Angular.Js:运行时性能

Vue Js。Vs Angular.Js:学习曲线

Vue Js。Vs Angular.Js:社区支持和进步

Angular 与 Vue。Js:大小和加载时间

Vue Js。Vs Angular.Js:更简单的集成

什么时候选择有角度的。应用开发的 Js？

当考虑 Vue 时。软件开发项目的 Js？

你的决定是什么？

为了更好地理解，让我们深入挖掘每一点，并做出明智的决定。

1。Vue。Js Vs Angular。Js:了解 Big 2 的基础知识

棱角分明。JS 在 2010 年作为基础版本发布。它是由 Google 开发的，被称为基于类型脚本的 JavaScript 框架。在发布了几个版本之后，现在 Angular V7 是现在可用的最新版本，于 2018 年 10 月推出。

在这个科技时代，棱角分明。JS** 在当今数百万开发者使用的主流技术中迅速树立了标杆。因为棱角分明。JS 不仅仅拥有优秀的发布时间，还提供了令人难以置信的结构。它提供了简单的双向数据绑定、MVC 模式和内置的模块系统。由于这个原因，许多开发人员更喜欢使用这个前端 Js 框架。**

当谈到 JavaScript 的三巨头时，Vue。Js 是小组中最年轻的成员。它是由前谷歌员工尤雨溪在 2014 年开发的，凭借其出色的性能和流畅的功能迅速风靡全球。

Vue。JS 是一个用于构建用户界面的渐进式框架。与 Angular 等技术驱动的框架相反。JS，Vue。JS 已经被构建为逐渐被用户采用。感谢 Vue。Js 的特性使其成为 GitHub 上最受欢迎的 JS 框架，但是使用 Angular 的网站比例越来越高。JS，让它战胜 Vue。****

图像来源

2。Vue。Js Vs Angular。Js:流行和市场趋势

如果我们分析一下角度的各种趋势。w3techs 上的 JS 和 Vue，我们得到如下结论:

****用途及市场份额:根据 w3techs 的报道，Angular。0.4%的网站使用 JS，而 Vue。Js 在 0.3%。

图像来源

使用各自 JS 库的网站排名: 0.8%使用 Angular。JS，还有 0.5%是 Vue。所有网站的 Js，这些网站的 JS 库我们都知道，并且已经排在前 100 万名。

图像来源

****历史趋势:w3techs 的专门调查，代表使用所选技术的网站百分比的历史趋势。

图片来源

3。Vue。Js VS Angular。JS 性能:谁更好？

说到评估 Js 的框架的性能，Vue。Js 是顶级 网络开发公司 中日益增长的感觉！

棱角分明。JS 结构由大量代码组成，但确保了高功能性，而 Vue。Js 是灵活的、轻量级的，并在高功能性上提供卓越的速度。而在大多数情况下，Angular 的广泛特性和功能。应用程序没有使用 JS，尽管专门的 web 开发团队选择了 Vue。Js over Angular.JS。

而所有的功能都应该通过 Vue 中的附加扩展来添加。Js，最终使它比 Angular 更适合初学者。JS 框架。然而，精心打造的棱角分明的结构。JS 为开发需要大量功能的应用程序提供了绝佳的机会。

同时，如果你比较功能性，角度。JS 可以很死板但是 Vue。Js 固执己见。这意味着，Vue。Js 为开发人员提供了自由，让他们可以按照框架的意图开发应用程序。

更多阅读: 寻找顶尖的 JavaScript 框架？以下是 2020 年值得关注的顶级图书馆！

棱角分明。JS Vs Vue。Js:哪个适合你？

图像来源

在考虑速度和性能的时候，有角度。JS 是充分利用框架特性的动态项目的理想选择。另一方面，Vue。对于需要快速处理和更强大功能的小型项目，Js 是更好的选择。****

4。Vue。JS Vs Angular。JS:学习曲线

你准确的知道 JavaScript 吗？

嗯，每个前端 JS 框架的学习曲线取决于你的知识和经验水平…

都有棱角。JS 和 Vue。JS 利用 HTML 和 CSS，但是因为 Angular 的高级版本。JS 的开发是为了适应大规模的应用，涉及到繁重的代码结构，因此你需要 雇佣专门的开发人员 来确保 C#和 Java 等语言的类型安全。因为最新版本的 Angular。JS 使您能够实现大规模的应用程序，因此，它需要更深入的学习曲线。

相比之下，Vue 也有助于你通过使用 Vue 来开发大规模的应用程序。Js 开发公司，但这在 Vue 中仍然是可选的。

5。Vue Js。Vs 棱角分明。Js:社区支持和进步

毫无疑问，作为 JavaScript 最古老的框架，Angular。与 Vue 相比，JS 有更多的社区支持。JS 为 Google 提供了广泛的代码编辑器。此外，对于最新的功能，包括惰性路由的导入、CLI 工作流改进、对 Node 10 的支持以及对 TypeScript 3.4 的支持，您可以使用最新版本的 Angular 8。

而 Vue 的答案。Js 在于，它是一个开源的框架，在市场上被高度认可，用来开发单页 web 应用。此外，这个框架的最新版本还包括了其他特性，比如异步错误处理、带有源信息的模板编译警告、动态指令参数等等。

6。Angular 与 Vue。Js:大小和加载时间

在 JavaScript 框架之间做出选择时，库的大小是一个需要考虑的重要因素，因为在某些情况下，运行时间取决于文件的大小。

角度:500+KB

Vue: 80 KB

虽然棱角分明。JS 为您提供了广泛的功能，但无疑体积庞大。虽然 Angular 的最新版本可能已经大大减少了应用程序的大小，但它仍然没有使用 Vue 开发的应用程序轻。Js 框架。当应用程序的加载时间主要取决于应用程序的大小时，Vue。Js 手机 app 确保加载速度比 Angular.JS 更快

7。Vue。Js Vs Angular。Js:更简单的集成

使用框架时，您和您的团队集成应用程序的难易程度如何？

虽然整体部署的角度。JS 对于即使是专注的开发者来说也是相当复杂的。但是如果你用的是 Angular CLI，你就赢了一半。虽然 CLI 可以通过一个命令处理从项目创建到代码优化的所有事情，但您可以通过一个命令将应用部署到任何静态主机。

为了 Vue。Js，您还可以使用 CLI 来生成预配置的健壮设置，以便轻松开发应用程序。Vue 的发展。Js 和 Angular 一样简单，你可以得到优化的项目，运行在一个内置的命令上。Vue 的部署。Js 项目并打开服务器端呈现相对容易。

阅读更多:看看为什么这些顶级网络发展趋势&技术将统治 2020 年

Vue。Js VS Angular。js:2019 年 Web 开发哪个最好？

两者都有 CLI 支持，但相对而言，Angular 在管理和部署应用程序时优势很小。

T5 . a .什么时候挑棱角分明的。你的 App 开发项目的 JS？

棱角分明。JS 是理想的选择:

你需要开发一个复杂的、大型的、动态的 app 项目。

你想要一个像即时消息和聊天应用程序这样的实时应用程序。

您需要可靠和简单的可伸缩性。

您可以花时间学习 TypeScript 来开发应用程序。

B .应该什么时候挑 Vue。Js？

尽管是 JavaScript 三巨头中最年轻的成员，但它是许多软件开发公司的热门选择。您应该在下列情况下选择:****

你需要开发一个轻量级的单页应用程序。

您需要高速度、灵活性和高性能。

你想要一个小规模的应用。

你正在寻找明亮和简单的编码。

你的最终决定

在开发应用程序时，这两个框架都将为专门的开发人员提供很好的结构。然而， Vue。Js VS Angular。JS:哪个比较好？这个问题让我们进退两难…

正确框架的选择取决于所讨论的各种因素；你可以考虑做最后的决定。如果你想要一个行业专用的、结构良好的结构- 雇佣训练有素的 web 开发人员 来提供 Angular。JS 开发服务是必由之路。另一方面，如果你的项目需要单页布局，快速处理，干净的编码，那么没有比考虑 Vue 更好的选择了。Js 为您的项目提供 web 开发服务 。

通过支持向量回归和 LSTMs 进行股票价格预测

原文：https://towardsdatascience.com/walking-through-support-vector-regression-and-lstms-with-stock-price-prediction-45e11b620650?source=collection_archive---------2-----------------------

使用 python、scikit-learn 和 Keras 了解 LSTMs 和支持向量回归

Image via Pixabay
Free for commercial use under Pixabay License
source

人工智能(AI)无处不在。机器学习和人工智能正在彻底改变现代问题的解决方式。应用机器学习的一个很酷的方法是使用金融数据。金融数据是机器学习的游乐场。

在这个项目中，我使用支持向量回归和 sci-kit-learn 分析了特斯拉的收盘价，并使用 Keras 分析了 LSTM。这是我的第二个机器学习项目，我一直在学习大量关于机器学习和数据科学的信息。如果你喜欢这个，看看我的另一个项目，在那里我创建了一个卷积神经网络来识别尼古拉斯·凯奇的图像。

当使用像 LSTM 算法和其他算法这样的技术分析金融数据时，重要的是要记住这些并不能保证结果。股票市场难以预测，瞬息万变。这只是一个有趣的项目，学习使用神经网络进行股票分析的一些基本技术。这不是一篇声称这项技术会让你成为百万富翁的文章，因为它绝对不会。

目录:

1. 获取我们的数据:

• 进口
• 获取股票数据
• 修复我们的数据

2.可视化我们的数据:

• 绘制我们的数据
• 滚动平均值

3.支持向量回归:

• 转换日期
• 线性回归
• 支持向量机
• 支持向量回归演练
• 使用 sklearn 和可视化内核的 SVR 代码

4.深度学习:

• 为神经网络标准化和准备我们的数据
• 递归神经网络
• LSTM 漫游
• 拒绝传统社会的人
• 我们模型的代码

5.结果是:

• 绘制模型损耗
• 做出预测
• 结论
• 资源

进口:

这里我们导入:

• 来创造我们的神经网络
• 熊猫和熊猫 _ 数据阅读器获取和分析我们的股票数据
• datetime 来确定我们的股票日期，以便进行数据分析
• 重塑我们的数据，输入我们的神经网络
• matplotlib 来绘制和可视化我们的数据
• 警告忽略弹出的任何不想要的警告

获取我们的股票数据:

• 这段代码将我们的绘图样式更改为 ggplot。我把样式改成了 ggplot，因为我更喜欢它的样子。在这里阅读更多关于 ggplot 的内容。
• 然后，我们使用 pandas_datareader 作为“web ”,使用 datareader 函数获取我们的股票价格数据，该函数获取财务数据并将其存储在 pandas 数据帧中。
• 我们获得了 2014 年至 2018 年的特斯拉股票数据来训练我们的模型。
• 我们获得从 2019 年到今天的特斯拉股票数据，让我们的模型进行预测。
• “TSLA”是特斯拉的股票代码，我们指定“雅虎”来使用雅虎金融 API 获取数据。

修复我们的数据:

• 因为我们在做时间序列预测，所以我们希望我们的数据是连续的。我们按日期对训练和测试数据进行分类。
• 然后，我们重置指数并设置数据框架的指数，以确保我们的股票价格日期在数据框架中是一列。

绘制我们的数据和滚动平均值:

2014–2018 Tesla closing stock prices

Rolling mean plotted on our data

• 我们从数据框架中获得调整后的收盘价，并在数据上绘制滚动平均值。
• 滚动平均也称为移动平均。移动平均线帮助我们消除有大量波动的数据，并帮助我们更好地看到数据的长期趋势。
• 使用移动平均线，您可以定义一段时间，您想要取其平均值，这就是我们的窗口。我们将移动平均窗口定义为 100。我们定义 100 是因为我们希望在数据中看到长期的移动平均值。

数学:

• 移动平均线的工作方式是将连续 100 天的价格相加，然后除以 100 得到平均值。然后我们将窗口向右移动一位。所以我们去掉第一个价格，在最后加上一个新的价格。
• 另一种理解滚动平均值的方法是将它看作一个由 100 个价格组成的数组。我们将所有元素相加，然后除以 100，得到我们的平均值。然后我们移除位于a[0]的元素，在数组的末尾追加另一个价格。然后，我们再次对所有元素求和，然后除以 100，得到我们的下一个平均点。

转换日期:

• 在这里，我们创建了 dataframe 的副本，并将其命名为 dates_df。我们将原始日期存储在 org_dates 中。稍后我们将使用 org_dates 来绘制我们的预测和日期。
• 然后，我们使用 mdates.date2num 将我们的 dates_df 日期转换为整数。我们需要整数形式的日期，因为您无法将日期输入支持向量机和神经网络。

线性回归

• 线性回归是一种寻找两个变量之间最佳线性关系或最佳拟合线的方法。
• 有了给定因变量(x)的最佳拟合线，我们可以预测我们的自变量(y)。
• 线性回归的目标是找到最适合我们数据的直线，使预测的 y 值尽可能接近我们给定的已知 y 值
• 线性回归的等式为 Y = A + B * X，其中 X 是预测值，Y 是根据 A、B 和 X 计算的预测值，B 是系数，A 是截距，它们都是回归的估计值
• 这也是一个有用的线性回归图像:

Image via Wikipedia
Free for commercial use under Wikipedia commons license
source

• 因此回归试图通过最小化成本函数来学习我们数据的最佳 A 和 B 值。通常用于线性回归的成本函数是均方误差(MSE)。下面是 MSE 的等式:

Image via Wikipedia free for commercial use under the Creative Commons Attribution-ShareAlike License Source

• 因此，在我们的例子中，我们将试图在日期和股票价格之间找到一条最佳匹配线。由于我们的数据有如此多的波动，因此没有最佳拟合线可以用于线性回归，从而为我们提供良好的股票预测准确性。因此，在我们的情况下，仅使用线性回归是不准确的。具有线性关系的数据，如根据房子的大小预测房价，就是线性数据的一个例子。

支持向量机:

• 支持向量机用于分类。SVM 的目标是在图上定义两个类之间的边界线。我们可以认为这是以最好的方式“拆分”数据。这条边界线叫做超平面。
• SVM 中的超平面在两个类之间有一个“余量”或距离。构成空白的这两条线是从超平面到每个类中最近的数据示例的距离。这些线被称为边界线。
• 分割过程完成后，SVM 可以根据单个数据点在图表中的位置来预测其应属于哪个类。下面是一个有助于形象化的图表:

Image via Wikipedia free for commercial use under the Creative Commons Attribution-ShareAlike License Source

• 如您所见，我们在中间有一个最佳超平面，然后有两条虚线作为边界线，它们穿过每个类中最近的数据点。
• 使用 SVM 确定边界线时，我们希望这两个类之间的距离尽可能宽。这将有助于 SVM 在看到需要分类的新数据时进行归纳。

支持向量回归演练:

• 既然我们对线性回归和支持向量机有了基本的了解，支持向量回归就是支持向量机和回归的结合。
• 线性回归对我们的数据不起作用，因为我们的数据有许多波动，最佳拟合的线性线对股票数据的预测很差。SVM 不会对我们的数据起作用，因为我们没有在两个不同的类之间进行分类。
• 对于股票数据，我们不是预测一个类，而是预测一系列中的下一个值。
• 使用回归，我们尝试使用类似梯度下降的东西来最小化成本函数。使用支持向量机，我们试图在两个不同的类之间画一个超平面。所以 SVR 是 2 的组合，我们试图在一定的阈值内最小化误差。下面是 SVR 上一篇有帮助的文章中的一张惊人图片，有助于可视化 SVR:

• 蓝线是我们的超平面，红线是我们的边界线。我希望你能开始看到我们是如何结合支持向量机和回归的思想。我们试图在某个阈值内准确预测值。
• 所以我们把我们的边界线定义为+eplison 和-eplison 来构成我们的边距。Eplison 是从我们的超平面到每条边界线的距离。
• 然后我们可以定义我们的回归线为 y=wx+b
• 我们的目标是最小化误差和最大化边缘距离。
• SVR 最酷的地方在于它可以用来预测非线性阈值范围内的值。下图有助于形象化 SVR 的外观:

使用 sklearn 和可视化内核的 SVR 代码:

SVR fitting our data

• 在这段代码中，我们使用 Sklearn 和支持向量回归(SVR)来预测数据的价格。
• 如您所见，非常符合数据，但很可能过度拟合。这个模型很难概括一年来看不见的特斯拉股票数据。这就是我们的 LSTM 神经网络派上用场的地方。
• 我们从数据中获得调整后的收盘价和日期，作为整数。我们将数据整形为 1D 向量，因为我们需要将数据输入 SVR。
• 核是将低维数据映射到高维数据的函数。我们定义我们的核为 RBF。RBF 代表径向基函数。RBF 的等式如下:

• 这是 RBF 的核函数方程。RBF 将我们的 2D 空间转换到一个更高的维度，以帮助更好地适应我们的数据。该函数取两个样本之间的平方欧几里德距离，并除以某个σ值。sigma 的值决定了我们的曲线拟合或数据有多“紧密”。
• 为了帮助更好地理解 RBF 如何将我们的数据转移到更高维度的空间，我根据 Brandon Rohrer 的这个视频制作了一个 gif。这显示了线性超平面如何不能分离 4 组数据点。因此，我们使用一个核函数将我们的数据转换到一个更高的维度，并“拉伸”我们的数据空间，以将我们的数据点归入不同的类别:

Gif of kernel functions via Brandon Rohrer under license Creative Commons Attribution license (reuse allowed) source

• c 是正则化参数。这是您希望避免对每个培训示例进行错误分类的程度。
• 对于较大的 C 值，该算法将选择一个较小边界的超平面。
• 对于小的 C 值，该算法将寻找分隔超平面的大的余量，即使这意味着错误分类一些点。下面是一个有用的形象化的 C 值大小之间的差异。

Source

• 在我们的例子中，我们选择我们的 C 值为 1e3，这是一个很大的 C 值，这意味着我们的算法将选择一个较小的边界超平面。
• 根据 sklearn 文档，“伽马参数定义了单个训练样本的影响达到多远，低值意味着‘远’，高值意味着‘近’。”
• 换句话说，当决定超平面的位置时，只考虑边界线附近的高伽马点。并且当决定超平面的位置时，考虑靠近和远离边界线的低伽马点。下面是另一张有助于形象化的图片:

标准化我们的数据:

• 在这里，我们创建我们的训练数据，并将其标准化。我们使用 sklearn 创建一个 MinMaxScaler()对象。
• MinMaxScaler 的工作原理是将我们的值的范围缩小到 0 或 1
• 下面是最小-最大缩放器的公式:

• 这是 sklearn 在后台做的方程，把我们的数据转换成我们想要的范围。

为神经网络准备数据:

• 这里我们创建了“create_dataset”函数。该函数从(0 到数据集长度，即时间步长数)开始循环。
• 因此，X_train 数组中的每个指数都包含一个 36 天收盘价的数组，y_train 数组包含我们的时间步长后一天的收盘价。
• 因此，换句话说，我们将前 36 天的股票收盘价数据输入神经网络，然后让它预测第二天的收盘价。
• 这可以通过打印输出来可视化:

递归神经网络；

• LSTM 代表长期短期记忆。LSTMs 是递归神经网络的高级版本。递归神经网络(RNN)是一种特殊类型的神经网络。rnn 将以前的输出作为输入。在 RNNs 中，前一个输出影响下一个输出。下面是克里斯托弗·奥拉写的这篇令人惊叹的文章中一个 RNN 的形象:

• “递归神经网络可以被认为是同一网络的多个副本，每个副本都向后继者传递信息。”克里斯·奥拉
• 递归神经网络受到消失梯度问题的困扰。在反向传播(在神经网络中更新权重的递归过程)期间，每层的权重被更新。然而，使用 RNNs 和消失梯度，梯度变得如此之小，因为它继续更新每一层。当反向传播通过各层传播时，当它到达第一层时，梯度值是如此小的值，以至于它对权重的改变几乎是不明显的。由于只做了很小的改变，这些初始层不会学习或改变。
• 因此，换句话说，对于较长的数据序列，rnn 会忘记它们在早期层中看到的内容，并且由于消失梯度问题而无法正确学习。例如，如果您有多个文本段落，并且您正在尝试预测句子中的下一个单词，RNNs 将不会记住模型已经看到的前面段落中的单词。这就是 LSTMs 有用的地方。

LSTM 漫游:

LSTM 是一种 RNN，每个 LSTM 单元内部都有门。我喜欢把 LSTM 细胞想象成一个细胞，每个细胞内部都有自己微小的神经网络。LSTM 细胞中的这些门帮助 LSTM 决定哪些数据是重要的，哪些数据可以被记住，即使是在一长串数据中。门的类型有遗忘门、输入门和输出门。下面是这个视频中这些 LSTM 细胞的惊人可视化效果。这个部分受到这个视频和这篇文章的很大影响，因为它们的解释非常棒:

所以 LSTMs 和 rnn 一样是连续的。前一个单元的输出作为输入向前传递到下一个单元。让我们来分析一下 LSTM 细胞内部的每个门在做什么:

门包含 s 形激活功能。乙状结肠激活函数可以被认为是“挤压”函数。它接受数字输入，并将数字压缩到 0 到 1 的范围内。这很重要，因为它可以让我们避免网络中的数字变得庞大，从而导致学习错误。

忘记入口:

遗忘门从先前的 LSTM 单元和当前输入中获取先前的隐藏状态，并将它们相乘。更接近 0 的值意味着忘记数据，更接近 1 的值意味着保留这些数据。

• 数学:

• 遗忘门是遗忘门权重矩阵乘以先前的隐藏状态，然后输入状态+一些偏置，全部传递到 sigmoid 激活函数中。在计算之后，它被传递到单元状态。

输入门:

这个门用我们想要存储在单元状态中的新数据来更新单元状态。输入门将先前的隐藏状态乘以输入，并将其通过一个 sigmoid。接近 0 的值不重要，接近 1 的值很重要。然后，先前的隐藏状态乘以输入，并传递到 tan 激活函数，该函数将值压缩到-1 到 1 的范围内。然后，sigmoid 输出乘以 tan 输出。sigmoid 输出决定哪些信息对 tan 输出很重要。

• 数学:

单元格状态:

网络的记忆。这可以被认为是一条“信息高速公路”,将记忆从以前的细胞传送到未来的细胞。这些门对单元状态进行改变，然后将该信息传递给下一个单元。一旦计算出遗忘门和输入门，我们就可以计算单元状态的值。

• 数学:

• 单元状态是遗忘门输出前一单元状态+输入门输出从前一单元传递的单元状态值。这是为了去掉我们想要忘记的更接近于零的某些值。然后，我们将来自输入门的值添加到我们想要传递给下一个单元的单元状态值中。

输出门:

输出门决定下一个隐藏状态应该是什么。我们将之前的隐藏状态乘以输入，然后传递给一个 sigmoid 激活函数。然后，我们将单元状态值传递给 tan 激活函数。然后，我们将 tan 输出乘以 sigmoid 输出，以决定隐藏状态应该将哪些数据传送到下一个 LSTM 单元。

• 数学:

辍学:

• Dropout 是深度学习和神经网络中使用的一种正则化技术。正则化是一种技术，用于帮助网络不过度适应我们的数据
• 过度拟合是指我们的神经网络在训练数据上表现良好，但在测试数据上表现很差。这意味着网络没有很好地概括，这意味着它对以前没有见过的新图像的分类不正确/很差
• 在官方的论文中解释说，“在一个神经网络中，每个参数接收到的导数告诉它应该如何改变，从而减少最终的损失函数，给定所有其他单元正在做的事情。因此，单位可能会以某种方式改变，以修正其他单位的错误。这可能导致复杂的共同适应。这反过来会导致过度拟合，因为这些共同适应不会推广到看不见的数据。”
• 因此，我们本质上关闭了一层中的一些神经元，以便它们在网络权重的更新(反向传播)期间不学习任何信息。这使得其他活跃的神经元可以更好地学习并减少错误。

我们模型的代码:

• 顺序——在这里我们建立我们的神经网络。我们按顺序创建模型。顺序意味着您可以一层一层地创建模型。顺序意味着只有一个输入和一个输出，就像流水线一样。
• LSTM 层-然后我们创建两个 LSTM 层，每层后有 20%的下降。
• 第一层我们有 return_sequences = true。我们这样做是因为我们有堆叠的 LSTM 层，我们希望第二个 LSTM 层有一个三维序列输入。
• 我们还将 input_shape 设置为 x.shape，以确保它接受数据的相同 3D 形状。
• 输出层——然后创建我们的输出层，它只是一个单一的节点，输出一个 0 到 1 之间的数字。
• 编译——然后我们编译模型。我们使用 Adam 优化器，它是一种梯度下降优化算法，我们将损失函数定义为均方误差。我们使用 Adam 来最小化我们的均方误差成本函数。
• 拟合模型—最后，我们使用反向传播和 Adam 优化器来拟合模型。我们将纪元定义为 20，批量大小为 10。我们还使用内置的 Keras split 函数将我们的数据分成 70%的训练数据和 30%的测试数据。

绘制模型损耗:

• 这里我们使用来自 keras api 的代码来绘制模型损失。当我们到达第 20 个纪元时，测试损失和训练损失非常接近，并且它们被最小化。

做出预测:

LSTM prediction results

• 在这里，我们让我们的神经网络对未知的 2019 年特斯拉股票数据进行预测。
• 我们首先从测试数据框架中获取 2019 年的收盘价数据，并将其转换为 0 到 1 之间的值。
• 我们再次使用 create_dataset 函数将数据转换成 36 个股票价格的批次。因此，我们给神经网络一个 X_test 数组，其中每个指数包含 36 天的收盘价。y_test 是应该给 36 天价格的值。
• 然后，我们将原始的 y 值存储在 org_y 变量中。我们将绘制该图，并将该值与我们的模型预测的价格值进行比较。
• 最后，我们重塑它，让网络进行价格预测。
• 正如你在上面的预测图中所看到的，我们的模型表现得相当好，并且跟踪了一整年的未知数据的行为。

结论:

• LSTMs 非常迷人，有很多有用的应用。它们允许对长系列的连续数据进行精确预测。我希望你喜欢这篇文章，我希望你学到了一些东西。如果您有任何问题、顾虑或建设性的批评，请在 linkedin 上联系我，并在 github 上查看该项目的代码。

资源:

• https://python programming . net/getting-stock-prices-python-programming-for-finance/
• https://towards data science . com/in-12-minutes-stocks-analysis-with-pandas-and-scikit-learn-a8d 8 a 7b 50 ee 7
• https://www.youtube.com/watch?v=4R2CDbw4g88
• https://medium . com/coin monks/support-vector-regression-or-SVR-8e B3 ACF 6d 0 ff
• http://www.saedsayad.com/support_vector_machine_reg.htm?source = post _ page-8e B3 ACF 6d 0 ff-
• https://medium . com/machine-learning-101/chapter-2-SVM-support-vector-machine-theory-f 0812 effc 72
• 【https://www.youtube.com/watch?v=SSu00IRRraY
• http://benalexkeen.com/feature-scaling-with-scikit-learn/
• https://colah.github.io/posts/2015-08-Understanding-LSTMs/
• https://www.youtube.com/watch?v=8HyCNIVRbSU
• https://towards data science . com/playing-with-time-series-data-in-python-959 e 2485 BF F8
• https://github . com/krishnaik 06/Stock-Price-Prediction-using-Keras-and-Recurrent-Neural-networking/blob/master/rnn . py

演练:使用 Python 中的 bokeh 和 GeoPandas 进行基本映射

原文：https://towardsdatascience.com/walkthrough-mapping-basics-with-bokeh-and-geopandas-in-python-43f40aa5b7e9?source=collection_archive---------3-----------------------

从数据和文件到静态地图再到交互式地图

Final static plot. Keep reading for the interactivity!

我本周的目标是学习如何制作一个交互式地图，然后创建一个关于如何制作该地图的教程。地图在可视化地理数据和随时间变化方面非常有用。它们可以提供一种很好的方式来缩小视图，查看宏观层面的变化。首先，我将概述所使用的两个主要包:GeoPandas 和 bokeh。然后，我将介绍如何从一个特定的数据集到一个特定的交互式地图。创建的地图决不是完整或完美的。总之，我将回顾一些潜在的改进，并提供一个我在哪里找到我的信息的资源列表和一些起点，如果你对散景、GeoPandas 或交互式制图感兴趣的话。

目标

• 了解如何使用散景和 GeoPandas 创建交互式地图的基础知识
• 了解软件包的应用，以便绘制 2018 年在整个美国邻近地区采集的水样中的铅含量
• 如果你有关于散景和地质公园的问题，知道去哪里

这篇博文的灵感来自于各种关于制图和可视化的帖子。所有的灵感来源和其他有用的链接都发布在下面的参考资料部分。

代码可以在 我的 GitHub 回购 上找到。

包 1: GeoPandas

Examples from GeoPandas Gallery

GeoPandas 是一个帮助用户处理地理空间数据的开源包。GeoPandas 有许多依赖项。我们将关注的是包 shapely，GeoPandas 依赖它来执行几何运算。在我们的例子中，美国各州的形状将通过 shapely 包编码为多边形或多多边形。然后通过 GeoPandas 来理解地理空间数据。

安装

为了让 GeoPandas 运行，需要安装一些软件包。很难确保这一点。但是如果你确定的话，可以用 pip 安装。否则，使用 Anaconda 安装 GeoPandas 将会为您处理依赖关系。

conda install geopandas

你可以在这里阅读更多关于安装 GeoPandas 的信息。

包装 2:散景

Gallery of plots you can make in Bokeh

虽然 GeoPandas 允许绘图，但散景允许我们创建更复杂的绘图。bokeh 是一个多功能的开源软件包，旨在帮助用户创建漂亮的交互式可视化效果。2013 年 4 月首次发布 Bokeh，最近一次发布是在 2019 年 10 月。在此最新版本之后，将不再支持 Python 2.7、Python 3.5 或更早版本。你可以在这里找到你可以在散景中制作的完整图库。

安装

散景依赖于几个软件包。您仍然可以使用 pip 来安装 Bokeh，但是您可能会遇到依赖性方面的问题。在我的例子中，我使用 Anaconda 来安装 bokeh，因为它负责确保依赖关系是有序的。

conda install bokeh

安装的更多细节可以在这里和这里找到。

例如:观察水中的铅含量

目标

创建一个显示美国各州人口的地图。在每个州内，显示 2018 年在哪里发现了铅。

创造连续的美国

为了创建一个地图，你需要一个形状文件。shp)。在这种情况下，我从美国人口普查局这里下载了一个 shapefile。该文件告诉 Geopandas 我们正在绘制什么形状。在我们的例子中，我们需要一个文件来概述美国相邻的每个州。我们使用一个 geometry 列，以便 Geopandas 包知道在哪里寻找每个州的形状信息。在这种情况下，形状是形状良好的多边形对象。

# Import geopandas package
import geopandas as gpd# Read in shapefile and examine data
contiguous_usa = gpd.read_file('data/cb_2018_us_state_20m.shp')
contiguous_usa.head()

First 5 rows of contiguous USA shapefile

在 Jupyter 笔记本中运行以下代码行将返回马里兰州的图像。

Running just the first entry in the geometry column, which represents the shapely geometry needed to create an image of Maryland

但是我们可以将 geometry 元素转换为字符串，以查看 shapely geometry 对象是如何表示的:

str(contiguous_usa.iloc[0]['geometry'])

返回一个长字符串，该字符串代表构成马里兰州的许多多边形:

'MULTIPOLYGON (((-76.04621299999999 38.025533, -76.00733699999999 38.036706, -75.98008899999999 38.004891, -75.98464799999999 37.938121, -76.04652999999999 37.953586, -76.04621299999999 38.025533))...

数据:国家人口

现在我们已经有了如何绘制美国地图的想法，我们需要将每个州的几何图形与我们想要绘制的数据结合起来。在这种情况下，我们需要将每个州与其 2018 年的人口联系起来。你可以通过美国人口普查局在这里找到美国各州和年份的人口估计。

import pandas as pd# Read in state population data and examine
state_pop = pd.read_csv('data/state_pop_2018.csv')
state_pop.head()

First 5 rows of state_pop dataframe

现在我们知道 shapefile 和 state population csv 都有一个名为“NAME”的列，我们可以将它们匹配在一起。所以现在我们可以使用 pandas 合并文件。

# Merge shapefile with population data
pop_states = contiguous_usa.merge(state_pop, left_on = ‘NAME’, right_on = ‘NAME’)# Drop Alaska and Hawaii
pop_states = pop_states.loc[~pop_states['NAME'].isin(['Alaska', 'Hawaii'])]

现在，我们已经合并了数据并将其限制在相邻的美国，我们可以将数据转换为有利于制图的格式:

import json
from bokeh.io import show
from bokeh.models import (CDSView, ColorBar, ColumnDataSource,
                          CustomJS, CustomJSFilter, 
                          GeoJSONDataSource, HoverTool,
                          LinearColorMapper, Slider)
from bokeh.layouts import column, row, widgetbox
from bokeh.palettes import brewer
from bokeh.plotting import figure# Input GeoJSON source that contains features for plotting
geosource = GeoJSONDataSource(geojson = pop_states.to_json())

现在，数据已经转换为适当的格式，我们可以使用以下步骤绘制州人口地图:

1. 创建图形对象
2. 将面片渲染器添加到图形中
3. 创建悬停工具
4. 展示图

# Create figure object.
p = figure(title = 'Lead Levels in Water Samples, 2018', 
           plot_height = 600 ,
           plot_width = 950, 
           toolbar_location = 'below',
           tools = “pan, wheel_zoom, box_zoom, reset”)
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None# Add patch renderer to figure.
states = p.patches('xs','ys', source = geosource,
                   fill_color = None,
                   line_color = ‘gray’, 
                   line_width = 0.25, 
                   fill_alpha = 1)# Create hover tool
p.add_tools(HoverTool(renderers = [states],
                      tooltips = [('State','@NAME'),
                                ('Population','@POPESTIMATE2018')]))show(p)

Basic map showing some tools available in bokeh package

现在我们已经创建了地图，我们可以添加一个颜色条来指示州人口。

# Define color palettes
palette = brewer['BuGn'][8]
palette = palette[::-1] # reverse order of colors so higher values have darker colors# Instantiate LinearColorMapper that linearly maps numbers in a range, into a sequence of colors.
color_mapper = LinearColorMapper(palette = palette, low = 0, high = 40000000)# Define custom tick labels for color bar.
tick_labels = {‘0’: ‘0’, ‘5000000’: ‘5,000,000’,
 ‘10000000’:’10,000,000', ‘15000000’:’15,000,000',
 ‘20000000’:’20,000,000', ‘25000000’:’25,000,000',
 ‘30000000’:’30,000,000', ‘35000000’:’35,000,000',
 ‘40000000’:’40,000,000+’}# Create color bar.
color_bar = ColorBar(color_mapper = color_mapper, 
                     label_standoff = 8,
                     width = 500, height = 20,
                     border_line_color = None,
                     location = (0,0), 
                     orientation = ‘horizontal’,
                     major_label_overrides = tick_labels)# Create figure object.
p = figure(title = ‘Lead Levels in Water Samples, 2018’, 
           plot_height = 600, plot_width = 950, 
           toolbar_location = ‘below’,
           tools = “pan, wheel_zoom, box_zoom, reset”)
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None# Add patch renderer to figure.
states = p.patches(‘xs’,’ys’, source = geosource,
                   fill_color = {‘field’ :'POPESTIMATE2018',
                                 ‘transform’ : color_mapper},
                   line_color = ‘gray’, 
                   line_width = 0.25, 
                   fill_alpha = 1)# Create hover tool
p.add_tools(HoverTool(renderers = [states],
                      tooltips = [(‘State’,’@NAME’),
                               (‘Population’, ‘@POPESTIMATE2018’)]))# Specify layout
# p.add_layout(color_bar, ‘below’)show(p)

Map with coloring based on state population

数据:销售线索级别

现在我们已经有了基本的地图，我们可以添加关于发现铅的水域的信息。我用的数据来自水质数据。根据现有的数据，我下载了两个数据集:

1. 2018 年美国所有的水站点
2. 2018 年美国每一份检测铅含量的水样的结果

sites_df = pd.read_csv('data/sites_2018.csv')
lead_samples = pd.read_csv('data/lead_samples_2018.csv')

在我们加载数据之后，我们需要检查和清理数据。在这种情况下，去除没有铅结果或 0 微克/升铅的点。在这种情况下，我们只想绘制以微克/升或毫克/升为单位进行测试的位置。我们将毫克/升转换为微克/升，以获得一致的单位。

清理完数据后，我们可以将水源与铅样本合并。然后，我们对网站进行排序，删除任何重复的网站，在网站和日期上进行匹配。然后，我们可以根据纬度和经度对美国境内的水源进行分类。然后我们创建一个月列用于绘图目的。最后，我们通过创建有形状的几何点对象来创建一个几何行

lead_sites = lead_per_l.merge(sites_no_dup,
                          left_on = ‘MonitoringLocationIdentifier’,
                          right_on = ‘MonitoringLocationIdentifier’)lead_sites_sorted = lead_sites.sort_values(by = ‘ActivityStartDate’)# After dropping duplicates by date, 12,249 data points
lead_sites_dropdup = lead_sites_sorted.drop_duplicates(subset = [‘MonitoringLocationIdentifier’, ‘ActivityStartDate’], keep = ‘last’).reset_index(drop = True)# Drop data points not in the contiguous USA, 10,341 data points
lead_sites_dropdup = lead_sites_dropdup[(lead_sites_dropdup[‘LongitudeMeasure’] <= -60) 
                 & (lead_sites_dropdup[‘LongitudeMeasure’] >= -130)
                 & (lead_sites_dropdup[‘LatitudeMeasure’] <= 50) 
                 & (lead_sites_dropdup[‘LatitudeMeasure’] >= 20)]# Create Month column for plotting Slider
lead_sites_dropdup[‘Month’] = [int(x.split(‘-’)[1]) for x in lead_sites_dropdup[‘ActivityStartDate’]]# Create shapely.Point objects based on longitude and latitude
geometry = []for index, row in lead_sites_dropdup.iterrows():
    geometry.append(Point(row[‘LongitudeMeasure’], 
                          row[‘LatitudeMeasure’]))lead_sites_contig = lead_sites_dropdup.copy()
lead_sites_contig[‘geometry’] = geometry

既然我们已经创建了合适的几何列，我们可以指定坐标参考系统(crs)并将数据转换为地理数据框架。然后我们提取 x 和 y 坐标用于绘图，并转换为 columndatasource。更多关于散景数据源的信息可以在这里找到。

# Read dataframe to geodataframe
lead_sites_crs = {‘init’: ‘epsg:4326’}
lead_sites_geo = gpd.GeoDataFrame(lead_sites_contig,
                                  crs = lead_sites_crs,
                             geometry = lead_sites_contig.geometry)# Get x and y coordinates
lead_sites_geo[‘x’] = [geometry.x for geometry in lead_sites_geo[‘geometry’]]
lead_sites_geo[‘y’] = [geometry.y for geometry in lead_sites_geo[‘geometry’]]
p_df = lead_sites_geo.drop(‘geometry’, axis = 1).copy()sitesource = ColumnDataSource(p_df)

滑块工具

有许多数据点(10，000 多个)，按时间段查看数据可能更有意义。因此，对于这个例子，我按月划分数据，并创建了一个滑块工具，以便您可以查看 2018 年任何月份的每个水站点。

# Make a slider object to toggle the month shown
slider = Slider(title = ‘Month’, 
                start = 1, end = 12, 
                step = 1, value = 1)

现在我们已经创建了 slider 对象，我们需要根据用户输入更新它。我们通过编写一个回调函数和一个 CustomJSFilter 来实现这一点。

# This callback triggers the filter when the slider changes
callback = CustomJS(args = dict(source=sitesource), 
                    code = """source.change.emit();""")
slider.js_on_change('value', callback)# Creates custom filter that selects the rows of the month based on the value in the slider
custom_filter = CustomJSFilter(args = dict(slider = slider, 
                                           source = sitesource), 
                               code = """
var indices = [];
// iterate through rows of data source and see if each satisfies some constraint
for (var i = 0; i < source.get_length(); i++){
 if (source.data[‘Month’][i] == slider.value){
 indices.push(true);
 } else {
 indices.push(false);
 }
}
return indices;
""")# Uses custom_filter to determine which set of sites are visible
view = CDSView(source = sitesource, filters = [custom_filter])

现在我们已经写好了函数，我们可以绘制水样采集站点，站点的悬停工具，以及滑块。

# Plots the water sampling sites based on month in slider
sites = p.circle('x', 'y', source = sitesource, color = 'red', 
                 size = 5, alpha = 0.3, view = view)# Add hover tool
p.add_tools(HoverTool(renderers = [sites],
                      tooltips = [('Organization', '@OrganizationFormalName'),
                                  ('Location Type', '@MonitoringLocationTypeName'),
                                  ('Date', '@ActivityStartDate'),
                                  ('Lead (ug/l)', '@LeadValue_ug_l')]))# Make a column layout of widgetbox(slider) and plot, and add it to the current document
layout = column(p, widgetbox(slider))show(layout)

Finished bokeh plot!

改善可视化的方法

1. 目前，该地图仅显示了州一级的人口，但由于水样/站点可能无法覆盖整个州，因此更详细的人口细分(例如按县)可能会提供更多信息。
2. 为了与 1 保持一致，显示哪个区域从这些水源获得水可能是有趣的。
3. 目前，该地图没有提供关于铅含量的统计数据的快速概览(例如:检测到的最少/最多铅、方差、多次记录的地点变化等。)
4. 从视觉上来看，可以在标记或改变悬停工具的样式方面进行改进。

资源

• 使用 Python 制作交互式地理地图的完整指南走向数据科学 (Shivangi Patel，2019 年 2 月 5 日)
• “添加小部件”散景文档。
• “散景.模型.滤镜”散景文档。
• “散景.模型.来源”。散景文档。
• GeoPandas 文档
• GeoPandas 101:在地图上绘制任何带有经度和纬度的数据。(瑞安·斯图尔特，2018 年 10 月 31 日)
• 如何使用 Python 3 在 Bokeh 中使用 slider 回调过滤 ColumnDataSource？栈溢出。
• “带散景的交互式地图”赫尔辛基大学。
• “Javascript 回调”散景文档
• 风韵犹存的用户手册

想要一份数据科学的工作？利用周末项目原则来得到它

原文：https://towardsdatascience.com/want-a-data-science-job-use-the-weekend-project-principle-to-get-it-a86ba2da514f?source=collection_archive---------0-----------------------

在线课程证书很棒。但是自己的项目更好。

It took me too long to learn courses are great for foundation knowledge. But the best knowledge, specific knowledge, knowledge which can’t be taught, comes from working on something of your own. Something which doesn’t have a criteria.

你走进去。亨利也在那里。在你和穿绿色 t 恤的女士之间有一张灰色的桌子。桑德拉。你记得她的名字。是她邀请你来面试的。

你在大厅遇见了亨利。你们俩都在争取同一个角色。亨利是个好人。真的很好。他和你一样。你们甚至喜欢同样的东西。

桑德拉开始说话。

欢迎小伙子们，感谢你们的到来。

你们都笑了。

你的申请令人难以置信。你们会很高兴知道你们是最后两个候选人。我们会雇用你们两个，但目前我们只有一个职位。

你瞥了一眼亨利。已经宣战了。不完全是，但也可能是。如果被雇佣是目标，那就有赢家和输家。

你记得在大厅和亨利说过话。

亨利告诉你他一直在开发的网络应用程序。你甚至可以在手机上使用它。虽然不多，但确实存在。屏幕上的黄色符号是供应无麸质食物的咖啡馆。亨利的女朋友不能吃麸质，所以他为她做了麸质。

“你是怎么做到的，”你问过了。

我在网上上过一些课程，所以我决定试着做点什么。“我从一些当地网站上获得了数据，看了看菜单，如果他们提到无麸质选择，确保他们是可见的。”

桑德拉又开始说话了。

亨利，我看了你建的网站。我女儿是乳糜泻。“如果我们到了某个地方，她却吃不下东西，那就太痛苦了，”

亨利开始说话。

女朋友也不能吃面筋。有几个问题，但我正在努力解决。

桑德拉转向你。

丹尼尔，我看到你在网上学了很多课程。Coursera 和 edX 的一些看起来很棒。

“你有机会使用你一直在学习的那些技能吗？”

你回头看了一眼亨利。这场战争已经失败了。

你说话。

还没有，我还在想该做什么。

这很难选择，”桑德拉说。

采访又持续了 15 分钟。标准问题。

你如何在团队中工作？

说出一次你挣扎过的经历，并谈谈在那种情况下你做了什么。

亨利谈到了他如何与他的应用程序斗争。桑德拉一直很感兴趣。

采访结束。

桑德拉一边招呼你和亨利出门，一边喊道。

感谢你们两位抽出时间，今天过得很愉快。我们会保持联系的。

亨利转向你，伸出手。

最好的男人。”

谢谢，你也是。

几天后电子邮件就来了。你知道它说什么。

虽然你的资历令人印象深刻，但我们决定不在这个阶段继续前进。

亨利得到了那份工作。

你继续读。

下一次的一些反馈，请不要认为这是负面的。我们很高兴看到你回来。

我们想看看你从令人印象深刻的证书列表中获得的所有知识能够做些什么！如果你做了什么让我们知道。在这里工作最大的好处之一就是我们可以为你自己的项目提供帮助。

你微笑。你知道的。从亨利告诉你他在做什么的时候你就知道了。当你读到关于如何准备第一次面试的博文时，你就知道了。

为什么亨利得到了这份工作？

周末项目原则。

大多数雇主(好的雇主)会更重视你做过的事情，而不是你有能力做的事情。

证书很棒。它们是工作证明的一种形式。

但是周末项目原则更好。

周末项目原则就是处理任何你可以说的事情，“我正在做我的 X 项目”或者“这是我做的。”然后能够讲述它的故事。重要的是，这不是从标准开始的，你可以在前进的过程中创造标准。

也不要被名字骗了。不一定要在周末。随时都有可能。不过，周末是一段很长的时间。因为如果最初的概念花费的时间超过一个周末，你可能想多了。

上 Coursera 和 edX 上的课程，拿到证书，获得技能但更重要的是，把它们作为做东西的基础。

六周过去了。你接受了桑德拉的建议。

你决定通过电子邮件发送，回复她发给你的邮件。

主题是，“我一直在做的事情。”

第一句话，“我接受了你的建议，决定用我一直在学习的东西做点什么。”

第二天早上，你的电话开始响了。你回答，说你好。是桑德拉。她开始说话。

嘿！我们收到了你的邮件！多努力啊！你想明天来告诉我们更多吗？我们可能很快会有一些职位空缺。

想要数据驱动？最好开始考虑数据操作

原文：https://towardsdatascience.com/want-to-be-data-driven-better-start-thinking-about-dataops-36b7f875ab35?source=collection_archive---------25-----------------------

大家的谈话数据。数据是开启洞察力的钥匙，是帮助您获得预测的秘方，是商业智能的燃料。人工智能的变革潜力？它依赖于数据。为您的 CRM、月度报告、Tableau 仪表盘提供动力的东西？数据。

好消息是数据从未如此容易获得。随着越来越多精通技术的公众要求以现代方式连接到公共数据，像人口普查这样经过考验的真实公共数据来源变得越来越容易获得。开放数据运动也在发展，越来越多的企业和组织将数据释放到野外。其结果是，商业界有一种压倒性的愿望，即利用数据来更智能地运营，并在每个行业、每个部门提供结果。事实上，2018 年，98.6%的公司渴望数据驱动的文化。这种兴奋导致许多组织大力投资商业智能工具和数据科学家队伍，他们将使用这些工具从原始数据中提炼黄金。

“2018 年，98.6%的公司渴望数据驱动的文化”——麻省理工科技评论报告

问题？想要实现数据驱动和完成数据驱动之间有很大的差距。

造成这种脱节的主要原因是数据和分析之间存在巨大的基础架构差距，而最大一部分花费的资源最终被丢弃在这个鸿沟中。现实情况是，曾经被称为 21 世纪最性感的工作 的数据科学目前有 80%的数据准备 和 20%的实际洞察力，这意味着投资数据科学部门的组织只能看到他们预期的商业智能的一小部分。

为什么会这样？

原因有几个，其中大部分可以通过数据经济中一个很大程度上缺失的组件来解决:数据操作。

处理大量数据需要集中管理和自动化操作

就像它的名字 DevOps 一样，DataOps 是这样一种东西，一旦你意识到你需要它，你就会意识到你实际上在一年前就需要它。在 DevOps 之前，工程管道变得不可持续的复杂。他们需要一个系统——一个过程和一套工具——来整合团队、技术和过程，同时消除团队成员之间的操作孤岛。随着可用数据量的增加，以及那些能够有效利用这些数据的人所拥有的机会的增加，组织需要实施类似的解决方案来管理其数据这一点变得越来越明显。

与 DevOps 类似，DataOps 不是单一的东西。大多数数据科学家每天都要处理几十项日常工作，这些工作可以通过更加智能地处理数据操作来解决。

采购数据

听起来很简单。它不是。任何人都可以找到数据——这是前所未有的可用——但找到能回答你所提具体问题的数据却少之又少。你最终是在一堆针中寻找一根针。

你能看到你想要的数据吗？

当然，数据无处不在，但看似简单的请求(“去年哪一天下雨？”“租金价格如何从一个街区变化到另一个街区？”)很少以你想要的格式，在一个整洁的包中产生你需要的、可访问的数据。这个星球上没有一个存储所有公共数据的单一存储库——不，它不是谷歌的公共数据浏览器——所以认为一个数据科学家可以梳理整个可用数据宇宙以实施一个好主意是不现实的。

清理数据

清理数据可能是数据科学家工作中最耗时、最必要、效率最低的部分。其中一个问题是“干净”是一个相对的术语。 数据语义 高度讲究。对于任何给定的数据集，数据科学家可能都必须标准化文件格式(但是谁不喜欢使用 pdf 呢？)、字符编码和列格式。更何况一个人的理想数据集是另一个人的头疼事。

除了这些问题之外，遗留系统、专有格式和人为错误会使流程变得非常缓慢。csv 中某处的未转义逗号？这是一个需要快速解决的问题，但是可能要花很多时间来找出哪里需要解决。因为它如此特殊，所以清理数据目前是一项蛮力工作，离分析还差得很远。

转换数据

一旦数据集被标准化，它可能仍然需要被转换以满足内部标准。你的公司如何记录日期和地址？他们希望每个专有名词都是大写的吗？如果您想执行更复杂的转换，比如在行级别添加逻辑和数学函数，该怎么办？

任何称职的数据科学家都可以进行这些转变，但你不能像发展数据库那样发展你的数据科学团队。鉴于流程中的各种可变性，当您的一名数据科学家转换到一份新工作时会发生什么？你能指望新来的人以完全相同的方式维护数据产品吗？你能控制移交吗？任何医疗专业人士都可以告诉你，事情并不总是按计划进行(但他们 使用数据来理解和解决问题 )增加管道的透明度和协作对于确保避免数据操作中的单点故障至关重要。

服务数据

正如我前面提到的，有很多 SaaS 解决方案是基于数据来产生洞察力和分析的。自从 Gartner 宣布 商业智能 是 CEO 们在 2009 年的首要任务以来，商业智能工具变得越来越可用和用户友好。像 Tableau 这样的数据可视化平台是主流，数据科学家越来越多地使用像 Jupyter Notebooks 和 RStudio 这样的开源 web 应用程序进行统计计算和机器学习。

然而，问题是，为了让这些解决方案发挥作用，您需要将数据传输到这些解决方案中。与我们在 AI 中看到的 类似，数据分析通常在合成或无菌环境中进行测试，这使得企业领导者认为将数据集插入工具并看到直接的业务影响是很容易的。它不是。原始数据是原油，而 BI/分析工具是一辆快车——在你去任何地方之前，都需要进行大量的提炼。

事实是，像这样的任务占据了数据科学家工作日的大部分时间。目前，它们被视为不可避免的祸害，但是找到一种将自动化应用于这些过程的方法将会产生立竿见影的效果。数据科学家将能够把大部分时间花在他们从事的业务上:分析、建模和实验。

释放数据的价值具有不可否认的商业影响——要做好这一点，您必须开始认真考虑数据运营。

我最近的一些帖子，希望你能看看:

开放数据和公开数据有区别吗？

你的数据准备好 AI 了吗？

联系我们 了解如何改进和自动化您的数据科学工作流，或者查看 Namara 和我们的工具套件，了解 ThinkData 如何构建理想的 DataOps 平台。

原载于。

想得到你的人工智能项目吗？问问你自己这 10 个问题

原文：https://towardsdatascience.com/want-to-get-you-a-i-project-off-the-ground-ask-yourself-these-10-questions-9a8704de50c0?source=collection_archive---------23-----------------------

针对讨厌 Excel 和 PowerPoint 的人的风险分析框架

到目前为止，任何一个有自尊的高管都听说过人工智能，并认为“嗯，是的，我也想分一杯羹。因为他们是主管，他们告诉下属继续工作，然后回到高尔夫球场。我个人认为这种做事方式没有问题，因为下属们会去找像我这样的顾问，了解他们的老板可能会说“我想要 Alexa，但喜欢办公椅”是什么意思(是的，我有一个关于这个的 PowerPoint 演示文稿)。

然而，我认为在用一种算法取代所有的主席语声器之前，应该考虑一些风险。事实上，在进入人工智能项目之前，在精神上问自己以下问题可能会降低风险，节省时间和金钱，并使所述项目的构建和运行部分更加顺利。

它不会以任何方式取代、塑造或形成启动此类努力所需的尽职调查，但会提供一个有用的框架来开始建设性的对话。

1.我有一个聪明的目标吗？

不管他们的编码或数据分析能力如何，高层人员在定义人工智能项目的策略中起着关键的作用。该公司是否想通过创造一种不同类型的价值主张 来颠覆其市场亚马逊？它是否寻求成为同类产品中的佼佼者？也许它的目标是在竞争激烈的市场上保持平衡，就像亚马逊一样？或者甚至追到一个领导， à la 亚马逊？

你知道，我开始感觉到一种趋势……

如果没有这样精确的指示，团队将会无目的地挖掘数据，寻找故事。由于没有明确和一致的目标，他们只能追逐移动的目标，冒着随着新数据的出现而改写历史的风险。这就是为什么在任何项目开始之前定义的策略应该是具体的、可测量的、可实现的、相关的和有时间限制的。

“其他人都在做”是进入人工智能游戏的一个糟糕的理由。

2.我有足够的数据吗？

所有人工智能项目都需要大量数据才能发挥作用:通俗地说，一个算法不可能在不敏锐地意识到过去的情况下既理解现在又理解未来。没有具体数量的数据点可以给出，因为它变化很大，但一个刚刚启动、经常性客户不超过 200 人的初创企业显然不具备启动人工智能项目的资源。

如果没有足够的数据可用，要么必须在内部收集，这可能非常耗时(我们正在谈论多年和重大重组)，要么通过外部来源收集(例如，预测雨伞需求将使用所有人都可以免费获得的天气数据)。然而，重要的是要注意，独特的数据，而不是尖端的建模，才是创造有价值的人工智能解决方案的原因。

3.我的数据集中有错误吗？

垃圾进来，垃圾出去。

没什么可说的了。任何优秀的首席数据官都会确认，数据应该像实物产品一样对待，在投入生产之前和之后都要对其组件进行质量检查。如果西红柿变坏了，一半的熏肉不见了，你不会做 BLT，也不应该运行一个有丢失或错误数据的算法。由此产生的预测不可信。

事实上，在创建算法时，80%的工作涉及数据提取、清理、填充和标准化，以确保简单的错误可以被系统地避免。

即使这样…

4.我的数据集是 d*ck 吗？

哦，亚马逊，你又来了？几率有多大？！

算法有能力系统地“做出”不公平的决定，而没有人注意到，甚至不知道为什么，这使得伦理比以往任何时候都更加重要。因此，团队应该系统地确保旨在对人类产生影响(任何影响)的算法不会受到偏见的困扰。这可以通过检查两件事来实现:数据代表现实，并且它不反映现实的现有偏见。

说起来容易做起来难，这进一步凸显了对相关且一致认可的全行业框架的需求。

雇用多元化的员工有助于发现相关社会背景的反映，但鉴于 STEM 课程的当前结构，这几乎是不可能的……或者，我会建议雇用一名“偏见侦探”，一名精通数据科学和人文科学的罕见独角兽，在我能创造的黑箱中找到未知的未知事物。

说到稀有独角兽…

5.我有实现这一目标的人吗？

A.I 人才既稀缺又被科技巨头垄断。根据最新报道，T2 目前只有 22，000 名博士级别的专家能够开发前沿算法。不适合大型科技公司的产品价格昂贵。非常贵。非常非常贵。

然而，这不应该阻止有进取心的团队创造美好的东西。如前所述，好的人工智能更多的是关于独特的数据，而不是独特的算法。任何现代数据分析师/开发人员合作伙伴都可以使用许多开源库来自学基础知识，并获得一些必要的快速胜利，以说服大人物继续疯狂招聘(我建议从 IBM Watson Studio 开始，我就是从那里开始的)。

在任何情况下，很可能在未来几年内，很大一部分劳动力将拥有一点数据科学，因为它将成为大批员工所需的集体技能的一部分(例如，知道如何使用 Office pack 现在是一种天赋)。

6.我需要改变我的层级结构吗？

即使一家公司有几十个有才华的业务流程负责人(通常不受欢迎，但对以上所有)开发人员、博士级别的专家和数据科学家，如果他们不能一起工作，将难以置信地难以启动一个项目。

首先，如果人才不集中，这些员工将很少有工作满意度，因为与周围人的共同目标对激励员工有奇效。其次，数据科学要求业务的统计、计算和业务方面全天候通信。因此，给这些人一个开放的空间，魔术图表和便利贴。第三，如果所有这些优秀、有才华的女性和男性都听命于不同的老板，很可能会出现不同的目标，以及沟通不畅和政治游戏。

IT 和业务的明争暗斗毫无成效。

变革管理是这里的关键。说到…

7.我的员工会变成勒德分子吗？

我们都听说过这些故事。自动化。冗余。机器人起义。这些故事(大部分)是真实的。这意味着一旦人工智能项目被宣布，组织内部会有一定程度的恐惧。“它会取代乔布斯吗？”"我必须接受进一步的培训还是被解雇？"“业务的一个部分会做出曾经由另一个部门做出的决策吗？”。

人们很少意识到变化，必须通过自上而下的教育和自下而上的咨询来实现，这需要时间。然而这是必要的。

对于一个成功的项目来说，获得组织各个层面的支持至关重要。

除了偶尔的内部认同，如果一个项目不仅仅是数据科学的一次尝试，就必须发展一种完整的文化。

8.我有合适的架构吗？

我可以用很多比喻来描述这个有趣的事情。冰山。足球。一位意大利土木工程师、经济学家和社会学家……然而我会坚持吃 BLT 三明治(因为快到午饭时间了，我饿坏了) :当你把西红柿、生菜和培根夹在两片面包之间时，你就处于一个涉及数百名工人和数千小时开发的过程的末端，从农场到仓库，到商店，以及中间的一切。数据科学大致相同:

算法本身做的工作不到 10%。

事实上，算法存在于一个依赖于以下因素的生态系统中:

• 数据收集、数据验证、工作流管理、服务基础设施…

但这本身是一个更大的生态系统的一部分:

• API(应用程序编程接口)、数据存储、DataViz 解决方案、监控流程、网络安全…

如果组织中不存在这样的架构，很好:从头开始更容易。然而，如果有现有的因素，很可能需要作出一些牺牲。

9.是否存在任何监管障碍？

目前，世界各地正在就人工智能问题以及对其进行监管的必要性进行数十场高层讨论；深度伪装、面部识别、黑暗模式、自主武器、系统偏见……所有这些都有广泛的影响，如果不加控制，有可能伤害数百万人。很快，政府层面正在讨论的此类问题的数量将达到数千个，因为可能会通过无数法律来确保算法的公平、安全和透明。

这是我们所能期待的最好结果……

然而，这意味着人工智能项目通常在未知的法律领域内进行，可能会在一瞬间受到广泛的法律检查。不仅要检查当前的法规，还要了解正在讨论的法规，这一直是企业界的关键，并将继续如此。

10.我有时间吗？

收集正确的数据、雇佣正确的人、重组系统和员工……所有这些都需要时间。一个 LOT 的时间。因此，说一个垂死的公司可以通过成为“人工智能公司”来拯救是愚蠢的。

事实上，如果一家公司处于时间敏感的紧要关头，人工智能可能不是答案。

这凸显了在制定战略时避免反动思维的必要性，因为这样做的公司注定要在其短暂的剩余生命周期中迎头赶上。

因此，我们回到了战略领域，从而完成了循环。

祝你好运。

参加一项运动

本文最初是为《Pourquoi Pas 撰写的，这是一份对当今技术挑战进行深入分析的在线杂志。 点击此处进入 。

想要真正掌握 Scikit-Learn？来自核心开发人员自己的 2 个重要提示

原文：https://towardsdatascience.com/want-to-truly-master-scikit-learn-2-essential-tips-from-the-official-developer-himself-dada6ff56b99?source=collection_archive---------10-----------------------

独家 TDS 采访

Scikit-learn 的核心开发人员之一分享了每个数据科学家都需要知道的 3 种实用 ML 技术。

Please subscribe to our youtube channel!

面试官:TowardsDataScience.com 项目负责人 Haebichan Jung 。旧金山 Recurly 的数据科学家。

受访者:sci kit-learn 的核心开发者 Andreas Muller 。O'Reilly 书籍的作者，介绍使用 Python 进行机器学习。哥伦比亚大学数据科学研究所的研究科学家和讲师。

开源社区如何为 Scikit-learn 服务？图书馆的工作流程和所有权是如何构建的？

首先是用户。对于 Scikit-learn 的大多数贡献者来说，他们是从用户开始的。如果你不使用这个包，你就没有动力了。第二，大多数伟大的贡献都是由人们的用例激发的。我为 Scikit-learn 制作了一些版本，因为我想使用它们。这些通常是最好的版本。你不想迎合软件过于具体的用例。你不想在特性上做标记，因为你可以。

第三，对于像 Scikit-learn 这样复杂的东西，您不希望从添加一些大的新功能开始。许多人都有他们最喜欢的模型，他们希望通过将它添加到 Scikit-learn 来开始他们的贡献。但是现在向 Scikit-learn 添加一个模型需要大约一年的时间。所以我真的建议从小事做起。我自己开始修复文档中的错别字。改进文档总是受欢迎的。问题跟踪器上也有很多东西。

在机器学习工作流程中实施 Scikit-learn 的人员中，您看到了哪些常见的错误或低效之处？

有几个与 Scikit-learn 和机器学习相关的常见错误。

1. 对于 Scikit-learn，每个人都应该使用管道。如果你不使用管道，你可能做错了。两年前，我们引入了列转换器，它允许您更好地处理具有连续和分类变量的数据，或者其他类型的混合数据。我们还改变了一键编码器的一些东西。现在，当一起使用管道、列转换器和一键编码器时，一切都很好。
2. 我在机器学习上看到的一个常见错误是没有足够重视指标。sci kit-learn for better or bad 使用准确性作为默认指标。但是一旦你有一个不平衡的数据，准确性是一个可怕的指标。你真的应该考虑使用其他指标。我们不打算改变默认的度量标准，因为准确性被如此广泛地使用，并且有如此明显的解释。但是查看其他指标并为您的用例考虑它们是机器学习中最常见的问题。

什么是管道？如果不是准确性，还有什么其他指标更适合机器学习？

在 Scikit-learn 中，每个 ML 模型都封装在一个简单的 python 类中，称为“estimators”。在你的机器学习过程中，经常会有一个包含一系列预处理步骤的分类器。管道允许您封装所有预处理步骤、特征选择、缩放、变量编码等等，以及您通常在单个估计器中拥有的最终监督模型。

所以你有一个物体来完成你所有的工作。这 A)非常方便，B)使编写错误代码变得更加困难，因为它确保您为您的训练和测试集做完全相同的事情。最后，你应该使用交叉验证或网格搜索简历。在这种情况下，重要的是所有的预处理都发生在交叉验证循环中。如果在交叉验证循环之外选择特性，可能会发生非常糟糕的事情。但是在您的管道中，您知道一切都在交叉验证循环中。

From Andreas Muller Columbia Lecture Series

对于度量标准，它们通常在二进制分类中被忽略。在二元分类中，要看你的目标是什么。我喜欢看 ROC 曲线下的面积和平均精度。这些是细粒度的度量标准。我也喜欢看精确召回曲线(AUPRC)。关于这些指标的事情是，它们不依赖于您应用的决策阈值，因为它们是排名指标。所以你需要决定在哪里设置阈值来说“我说它是 1 类还是 0 类的概率是多少？”

您可以研究的其他指标是 F1 指标或微平均召回率/精确度。这些也很有意思。

在 Scikit-learn 软件包中，您认为还有其他工具或功能没有被充分利用或低估吗？

有一个未被充分利用，因为它还很新。这叫做 Hist 梯度推进。这是 LightGBM 的根实现，因此它比以前的梯度增强实现快得多。比 XGBoost 略快，比 LightGBM 略慢。现在它还不支持缺失值，但在大约 2 周后的下一个版本中将会支持。它也不支持分类变量，这将发生在明年春天。

你提到 LightGBM 很有意思，因为越来越多基于 python 的 ML 库正在发布，如 Catboost，以及深度学习框架，如 PyTorch。你对 ML 领域的这些成长中的玩家有什么感觉？是竞争的反应？

我认为多数情况下多元化是好的，因为大多数都提供了类似于 Scikit-learn 的接口，因此与我们的包兼容。因为 Scikit-learn 应用如此广泛，所以它的开发速度很慢。我们看到 XGBoost 和 LightGBM 对人们来说非常有价值。因此，我们希望确保每个人都知道这一点，我们在 Scikit-learn 中包含了这一点，希望所有软件包都能获得更广泛的受众。

就深度学习库而言，部分原因是它们可以移动得更快，因为我们移动得太慢了。还有两件事。

1. 与谷歌或脸书相比，我们的资源真的很少。所以和那些公司的工程师竞争毫无意义。我认为 Keras 真的很酷，我没有理由在 Scikit-learn 中重新实现这样的东西。
2. 技术原因。现在，仍然很难跨不同平台无缝地支持 GPU。你可以在张量流中看到。Tensorflow 上有针对不同架构编译的不同版本，你得自己编译等等。我们在 Scikit-learn 中不会遇到这种麻烦。

你在哥伦比亚大学关于不平衡数据的演讲中说，这个问题有两个主要的解决方案:1)在改变数据(欠采样/过采样)后建立模型，2)改变模型(训练过程本身)。每种策略的优点和缺点是什么，特别是关于 Scikit-learn？

我想从你的问题后退一步，再次提到最重要的事情是指标，以及你如何评估它。你的目标是什么？你的目标永远不是准确，也永远不是 ROC-AUC。这不是你申请的内容。你应该考虑在你的应用环境中取得一个特定的结果意味着什么。

一旦你有了这个目标，你就可以定义指标，并尝试不同的方法来最大化这些指标。重采样非常吸引人的一点是，您通常可以丢弃大量数据，而不会真正影响结果。如果你有 1:1，000+的比率，你不想欠采样到 1:1。但是你可以去 1:100 或者 1:10，你可以得到完全一样的结果。现在你已经将数据集缩小了 100 倍。

“你的目标从来都不是准确性，也不是 ROC-AUC。这不是你申请的内容。你应该想一想，在你的应用环境中，取得一个特定的结果意味着什么。”

因此，至少如果你有很多数据，计算不是问题，欠采样是更有效地获得类似结果的方法。反过来说，我还没有真正见过有人在实践中使用 SMOTE，也就是合成数据生成。这是人们经常谈论的话题，但我对此有点怀疑。

就改变模型而言，Scikit 中的一个有用的东西是类权重。类权重实际上会改变损失函数，就好像对少数类进行过采样一样。所以你使用了所有的样本，但是给了少数类更多的权重。这是人们发现有用的东西。但是，这更像是尝试不同的东西，并且您有正确的指标来评估哪个解决方案最适合您的问题。

From Andreas Muller Columbia Lecture Series

有趣的是，你以那种方式提到了 SMOTE。在我的公司，我们一直在试验 SMOTE。但就实际结果而言，无论是 AUC 还是其他方面，都没有太大的好处。此外，它大大降低了我的流水线速度，因为我正在创建所有这些合成数据。所以想问问大家自己的疑惑从何而来。

因为我交谈过的每个人都说了你刚才说的话。

你认为这是为什么呢？

对我来说，机器学习中的很多东西都是非常经验性的。如果你在许多数据集上尝试，但没有帮助，那么它就没有帮助你。很难说为什么梯度增强效果很好。我想大多数人都相信渐变效果很好。但是我不认为任何人可以提出适当的理由来解释为什么梯度提升比支持向量机更有效。我认为没有人能以简洁或有意义的方式解释这一点。

就 SMOTE 而言，我认为有两件事正在发生:

1. 我认为 SMOTE 对数据的分布做了假设。所以 A)要么关于相邻样本之间的线的假设是错误的。B)如果样本离得太远，中间还有其他类的样本，那么这种情况可能会破坏东西。
2. 可能添加这些合成样本实际上对你感兴趣的模型类别没有帮助。

实际上，我和一个合作者有一个计划，要写一篇关于广泛基准的论文。这是因为，正如你所说的，你尝试使用 SMOTE 是有原因的，因为它是经过验证的文献中提出的方法，但在实践中，人们发现它对他们没有多大作用。

关于完整的采访，请观看 YouTube 视频的其余部分，其中 Andreas 对 Scikit-learn 包进行了更深入的研究。如果您喜欢这篇文章，请查看我们之前对哥伦比亚大学数据研究所所长 Jeannette Wing 博士的采访！(这是安德烈亚斯目前工作的地方)另外，请订阅我们的 YouTube 频道！

[## 我们没有谈到的最危险的数据科学问题

这位来自微软研究院的(前)副总裁计划如何通过管理一个庞大的数据机构来改变这种情况。

towardsdatascience.com](/the-most-dangerous-data-science-problem-that-we-arent-talking-about-9ba56ebbe498)

读数据科学硕士值得吗？

原文：https://towardsdatascience.com/was-it-worth-studying-a-data-science-masters-c469e5b3e020?source=collection_archive---------1-----------------------

自从完成数据科学硕士学位后，有很多人联系我，询问我对这门课程的体验，以及它是否值得推荐。因此，我认为最好总结一下我开始这门课程的决定，我在学习期间取得的成就，以及接下来几年的成果。

Source: Pixabay

我为什么选择学习数据科学？

那是 2016 年的春天，我在伦敦金融城最大的咨询公司之一为期 6 个月的实习即将结束。我担任这个角色是为了积累经验，并弄清楚成为一名精算师是否是我职业生涯的正确道路。当我被拉去参加会议，讨论我处理过的数字，或者能够拼凑出一个工具来自动化以前的手动任务时，我很快就找到了对这个角色的数据分析的热情。然而，我也发现，由于多年的标准化考试和很少甚至没有创造力，如果我进入研究生计划，我将走的传统道路不再让我感兴趣。此外，此时我的大部分工作都是在 Excel 中完成的，我几乎没有任何编码经验。

就在这个时候，我也开始探索一个在我找工作时不断出现的神奇术语:数据科学。我有数学背景，由于英国就业市场的性质，我被推向了基础良好的传统岗位，如会计和精算咨询。然而，这是一个新的角色，挑战了我对自己未来职业生涯的所有期望。作为一名精算师，我将通过学习监管标准来解决问题，而数据科学家被鼓励创造性地找到适合商业环境的解决方案。此外，角色机会不再局限于少数精选公司，而是几乎所有公司都在寻找数据科学家的变体，我可以进入一个全新的行业，从时尚到金融，这一想法极大地吸引了我的兴趣。

然而，当我开始申请数据科学职位时，很快就发现我缺少两项关键技能:应用机器学习和编码。

我有什么选择？

第一个解决方案是简单地自己教这些，我有学习机器学习的统计经验，并在 MatLab 中做了足够的编码，我有信心可以学习 Python 或 r。然而，如果我要做这些，我不确定这是否足够，以及如何在简历上向雇主清楚地展示我新获得的技能。

我考虑过在线训练营，但它们的内容通常是固定的，我不确定重复别人的工作会如何被雇主接受。此外，不能保证这些对雇主来说是可信的，而且自筹资金也很昂贵。仅仅三年后的今天，大学支持的课程清单使这成为一个更可行的选择，是一个绝对值得考虑的事情，但在当时这些是缺乏的。不幸的是，新兵训练营是一个昂贵的风险，我不确定是否会有回报。

因此，我决定在大学里寻找选择。当时有两种课程符合我的目标；商业分析师课程和计算机科学机器学习。前者专注于在商业环境中应用分析，但由于这是通过商学院进行的，所以费用要高得多，一年的学习费用超过 2.5 万英镑。后者通过学术研究提供教学，更侧重于教授基础理论而不是应用。此外，由于这是一门通过计算机科学系开设的学术课程，该年的费用相当低，为 9000 英镑(英国公民)。

我选了什么？

最后，我决定谨慎行事，将一整年的时间交给学术大师，希望通过项目工作获得机器学习方面的应用知识，并发展自己的编码技能。

因此，我加入了伦敦大学计算机科学系 City 的数据科学硕士 2016/17 届。这是该大学开设该课程的第二年，当时，它是伦敦唯一一所提供数据科学硕士学位的大学(尽管其他大学对此有所不同)。

我在课程中学到了什么？

第一学期包括数据科学的三个主要主题:数据科学基础、机器学习和可视化。每个模块都包括一个课程组成部分，我们可以选择任何公开可用的数据集来应用我们新学到的方法。有了这些，我很快就能够提高我的编码技能，甚至建立起开始公开分享这些项目的信心。

在第二学期，我们有两个核心模块，大数据和神经计算，并有两个可选模块可供选择。选项列表很全面，使我们能够选择从计算机视觉到数据架构的专业。我选择了数据可视化(第一学期模块的延续)和软件代理(应用强化学习的人工智能基础)。同样，这些模块包括课程作业和第一学期的基础知识，我真的能够扩展我的应用和创造性思维。大数据还引入了文本数据和自然语言处理。

在这两个学期中，我对大多数数据科学主题有了大致的了解，并对核心模块中的机器学习和神经网络有了深入的了解。当我们进入课程的第一部分，论文时，我们可以选择在实习的时候完成(并且考虑到工作时的平衡，可以延长截止日期)。我找到了一个合适的角色，定义了我的研究主题，并在接下来的几个月里将我迄今为止获得的所有技能应用于在商业中应用人工智能。

我是否从课程中获得了我需要的技能？

我有两个目标要实现；为了证明我理解机器学习，并将其应用于编码。这门课程不仅为我简历上的这些内容打了一个清晰的勾，还让我能够在接下来越来越多有趣的项目中继续拓展我的技能。任何工作申请的一部分都是要通过最初的检查，我现在一直在这样做。此外，当我进入面试阶段，我有所有这些项目来讨论，并真正证明我对自己理解的信心远远超过我自己所能达到的。

大师们打开了所有我之前敲过的门，甚至有招聘人员在我公开发布项目后直接联系我。最后，我发现我喜欢我论文的研究方面，喜欢追求这个领域的自由，并从此开始攻读人工智能博士学位。具有讽刺意味的是，这是我在 2016 年考虑的最后一件事，但随着该领域的不断扩展，站在这一领域的最前沿令人难以置信，特别是因为许多问题需要应用思维，并符合商业问题，而不仅仅是理论问题。

对于考虑进入数据科学领域的人，我有什么建议？

这对我来说一直是一个很难回答的问题，因为每个人的立场都是不同的，所以我会试着根据我的经验提供一些建议。简而言之:

1. 确定数据科学是你的正确路线，并找到一个话题或细节来推动这一点。对我来说，它是以创造性的方式应用数据分析的能力，并成为企业中帮助他人改善决策的宝贵资产。
2. 评估一下你想要的工作对你的要求是什么，以及你目前缺乏的技能是什么。虽然我有技术背景，但我还没有展示出我应用机器学习或代码的能力，需要一些东西来实现这一点。对于我班上的其他人来说，他们没有数学或统计学背景，因此需要这些来强化他们的知识。
3. 回顾一下你可以用来获得这些缺失技能的选项。例如，新兵训练营在行业中越来越可信，但他们通常遵循单一路径(即学习相同的数据并应用相同的方法)。这可能对一些人有用，但我想以独特的方式展示我的能力，让雇主们眼前一亮。如果你正在考虑攻读硕士学位，请彻底研究课程模块以及课程组织者，因为不同院系之间存在差异，尤其是商学院和学院。
4. 通过课程拓展和挑战自己，不要简单地选择一门涵盖你已经熟悉的主题的课程来打勾。找一些有挑战性的事情来鼓励你发展新技能。
5. 通过 GitHub、Kaggle 或你自己的网站在线发布你的项目，展示你的新技能。在任何面试中，建立一个项目组合都比试图在允许的时间限制内描述这些更进一步。

举个例子，下面你可以找到我自己的网站和 Kaggle 页面的链接:

[## 菲利普·奥斯本数据

这个项目是作为在 Python 笔记本中独立学习强化学习(RL)的一种手段而创建的。正在应用…

www.philiposbornedata.com](https://www.philiposbornedata.com/) [## 奥斯伯恩普|卡格尔

编辑描述

www.kaggle.com](https://www.kaggle.com/osbornep)

如果你正在考虑如何进入数据科学领域，我希望这篇文章对你有用，并且我会尽我所能回答你的任何问题。

谢谢

英国货币

Wasserstein GAN 在 Swift for TensorFlow

原文：https://towardsdatascience.com/wasserstein-gan-in-swift-for-tensorflow-61b557bd8c63?source=collection_archive---------12-----------------------

Vanilla Generative Adversarial Network (GAN) as explained by Ian Goodfellow in original paper.

我是苹果 Swift 和深度神经网络的大粉丝。而最近即将推出的深度学习框架是 TensorFlow 的Swift。所以，很明显，我必须马上投入进去！我已经在 TensorFlow 或 PyTorch 中写过 Wasserstein GAN 和其他 GAN，但这个 Swift for TensorFlow 的东西超级酷。在后端，从编译器的角度来看，这是使 Swift 成为机器学习语言的最终努力。在本帖中，我将分享我在 Swift 为 TensorFlow 编写和培训 Wasserstein GAN 的工作。代码在 GitHub 上是开源的，现在就可以在 Google Colab 上运行！

生成对抗网的历史

G 生成对抗网络(GAN)是由 Ian Goodfellow 在 2014 年发明的。GAN 通常有两个神经网络，即生成器 G 和评价器 C 。唯一可用的数据是真实世界&实值数据(来自自然)的未标记集合，可以是图像、音频等。GANs 是为改进真实数据建模而设计的，这样当模型被要求生成图像时，它应该能够这样做，这就是 G 的用途。这里， C 帮助 G 学习生成更真实的数据，自己学习预测 G 生成的图像是假的。它也接受真实的图像，并学会称之为真实的图像。这是一个迭代过程，它提高了 C 预测虚假和真实数据的能力，并反过来帮助 G 调整其参数，从而生成更真实的数据。

这些香草甘不产生非常好的图像质量。因此，提高图像生成质量的工作仍在继续，该子领域中最重要的方向之一是将 Critic 网络约束在函数空间的 1-Lipschitz 集合中，并最小化 G 分布(假)和 P 分布(真)之间的 Wasserstein 距离。查看维基百科页面了解 Lipschitz 连续性。现在我们继续用 Swift 为 TensorFlow 编码 WGAN！

数据

数据是神经网络学习的第一步。因此，我使用了 CIFAR-10 数据集，它包含以下 10 个类别的图像:

• 飞机
• 汽车
• 伯德
• 猫
• 鹿
• 狗
• 青蛙
• 马
• 船
• 卡车

每个图像都是一个32x32大小的 RGB 图像。大约有 50k 的训练图像和 10k 的测试图像。哇，我从来没有注意到图像类的数量接近 MNIST 数据集中的数量🤔。总之，我用这些数据来训练我的 Wasserstein GAN 生成这样的图像。

import TensorFlow
import Python
PythonLibrary.useVersion(3)// Import some Python libraries
let plt = Python.import("atplotlib.pyplot")

Data downloading and loading

首先使用 Swift for TensorFlow toolchain 导入 TensorFlow 和 Python(3 . x 版)。然后通过 Python 互用性特性导入 Python 库！现在定义一些 CIFAR-10 下载、加载和预处理函数。最后，加载数据集。

配置

为了训练网络，需要设置一些重要的配置。我尽量保持配置与 WGAN 纸相似。因此，我将批量大小设置为 64，图像大小调整为 64x64，通道数(RGB)为 3。WGAN 被训练了 5 个纪元(如 PyTorch 教程中所建议的)。 G 的潜在空间被设定为 128 维。每个 G 的 C 的迭代次数被设置为 5，这是为了很好地近似 1-Lipschitz 函数，如论文中所建议的。另外， C 的可训练参数值必须限制在极限值[-0.01，0.01]。

Configurations

瓦瑟斯坦生成对抗网络

如上所述，WGAN 的模型包含一个 C 和 G 网络。 C 包含多个卷积层，而 G 由顺序转置卷积层组成，这些卷积层有时也被错误地称为反卷积层。

自定义图层

在 Swift 中为 TensorFlow 定制神经层，使你的结构符合[Layer](https://www.tensorflow.org/swift/api_docs/Protocols/Layer)协议。Swift 中 TensorFlow 的参数是通过使您的神经结构符合[KeyPathIterable](https://www.tensorflow.org/swift/api_docs/Protocols/KeyPathIterable.html)协议来访问的，这是默认的，但我写它是为了记住 Swift 中类型属性的迭代是如何发生的。目前，用于 TensorFlow 的 Swift 中的[TransposedConv2D](https://www.tensorflow.org/swift/api_docs/Structs/TransposedConv2D)实现工作不太好，所以我决定按照 Odena 等人 2016 建议的方式，在Conv2D层之后使用[UpSampling2D](https://www.tensorflow.org/swift/api_docs/Structs/UpSampling2D) op。使用[Conv2D](https://www.tensorflow.org/swift/api_docs/Structs/Conv2D)结构，因为它跟随[BatchNorm](https://www.tensorflow.org/swift/api_docs/Structs/BatchNorm) op，该 op 也在连续的UpSampling2D和Conv2D操作之后使用，代替TranposedConv2D。我写的这些自定义层用 Swift 代码显示如下。

Custom neural layers

WGAN 架构

G 网络从高斯分布中取形状为【128】的随机向量。这将在BatchNorm和relu激活功能之后通过一个密集(全连接)层。产生的转换输出被重新整形，使得它可以通过一系列的UpSampling2D、Conv2D、BatchNorm层和relu激活。最后的层块简单地对卷积层和tanh激活函数之后的输出进行上采样。

网络 C 的架构是这样的，它有 4 个块Conv2D，后面跟着BatchNorm。每个块后面都有一个负斜率为 0.2 的leakyReLU激活函数。在撰写本文时，leakyReLU功能尚未在 Swift for TensorFlow 中实现，因此我通过使其可区分来实现自己的功能。最后，输出被展平，并通过产生[1]维输出的密集层，以给出图像是真/假的概率。

Wasserstein GAN architecture

请注意，在 G 和 C 中，步幅为(2，2)，填充设置为相同。两者中的内核大小都被设置为(4，4)大小。在上面的两个网络中，call(_:)函数使用@differentiable属性变得可微。用类似的方法创建可微的 LeakyReLU 激活函数。

Differentiable Leaky ReLU

培养

网络被训练 5 个时期。在每次迭代中, C 比 G 的单个训练步长多训练 5 次。每个网络使用的批次大小为 64。我使用 RMSProp 优化器，两个网络的学习率都是 0.00005。 G 的zInput取自均匀分布。我还记录了 1 个纪元的训练时间，对我来说大约是 12 分钟。使用 Matplotlib 还绘制了 Wasserstein 距离和几个损失(如 G 损失&T21C 损失)的图表，这是因为 Swift for TensorFlow 支持 Python 互操作性。关于 TensorFlow 的 Swift，我学到的另一件事是，您可以迭代任何任意类型的属性，这些属性符合在 apple/swift 的 tensorflow/swift fork 中实现的keypathiable协议。这是一个超级酷的想法，但许多工作仍然需要做，如访问特定层的参数和修改需要应用每层激活。

不管怎样，下面是一个更深入的自我解释的 Swift 代码，用于训练我的 Wasserstein GAN！

注意，需要通过下面几行代码来设置训练/推理模式。

// For setting to training mode
Context.local.learningPhase = .training
// If you want to perform only inference
Context.local.learningPhase = .inference

讨论

用 Swift 语言接触深度神经网络是一种很好的体验。我认为 Swift for TensorFlow 将成长为一个新的主流机器学习框架，很可能取代 PyTorch 的大部分功能，就像 PyTorch 过去对 vanilla TensorFlow 所做的那样。我真的很喜欢它支持作为默认行为的急切执行，而且我不必手动设置设备进行训练&我还可以在 Google Colab 中使用云 TPU。很高兴看到 TensorFlow 社区通过提供基于 Jupyter 的 Swift 环境，努力使 Swift for TensorFlow 可在 Colab 上使用。也可以使用Raw类型的名称空间(我想它更像结构，因为 Swift 中不存在名称空间的概念)来访问一些基本的操作，如mul(_:_:)、add(_:_:)等。在 Swift for TensorFlow。这是谷歌 TensorFlow 团队克里斯·拉特纳 &斯威夫特的一项令人敬畏的努力。

以下是我对 Swift for TensorFlow 目前在研究原型方面提供灵活性的方式的部分担忧。

访问每层的参数

Swift for TensorFlow 采用了一种新颖的方法来访问一种类型的属性以进行修改。这是访问和更新神经网络参数所必需的。该设备提供给符合按键可变协议的类型。默认情况下，符合层协议的神经网络结构存在这种行为。所以，你不必一遍又一遍地写，因为很可能你会想要访问神经网络的属性。这工作得很好，正如我在 Wasserstein GAN 代码中所做的那样，但我仍然不能灵活地访问每一层的参数，但我只是迭代一次所有属性，而不知道它们当前属于哪一层。这实际上不是我的要求，但在其他情况下，比如你想进行迁移学习时，这可能是一个要求。它需要访问特定的层来更新参数。希望 Swift 能很快为 TensorFlow 提供这种灵活性。

每层激活函数

我认为谷歌将会并且可能需要改变激活应用到每一层的方式(这是我不用的，因为 LeakyReLU 不能那样应用)。它类似于Conv2D(…, activation: relu)，其中 relu 也可以被线性激活代替，但 LeakyReLU 不太适合这种设计，因为它没有给定的斜率值。这里，函数没有被调用，它只是一个作为参数传递给 Conv2D 层或任何其他层的函数。我能想到的最好的解决方案是使用枚举而不是像Conv2D(…, activation: .relu)那样传递函数，或者对 LeakyReLU 做类似Conv2D(…, activation: .leakyrelu(0.2))的事情，其中 0.2 是激活函数的枚举情况leakyrelu的关联值。

我希望你喜欢这本书。如果你真的喜欢我的文章，请与你的朋友分享，关注我吧！除了写文章，我还积极地在推特上发关于机器学习、区块链、量子计算的微博@ Rahul _ Bhalley！

通过研究海洋塑料的兴起了解 R Shiny 第一部分

原文：https://towardsdatascience.com/watch-the-rise-of-plastics-in-our-oceans-part-one-61ccd16cfa04?source=collection_archive---------25-----------------------

在本系列文章中，学习如何使用刚刚发布的海洋塑料数据在 R Shiny 中构建一个 web 应用程序

在《自然》杂志最近的一篇文章中，一组海洋科学家分析了自 20 世纪 30 年代以来被称为连续浮游生物记录器(CPR)的设备收集的数据。CPR 在日常航行中由船只牵引，用于捕获浮游生物进行研究。

但从 1957 年开始，CPRs 开始意外地捕捉到另一条数据——我们直到最近才知道它会有用——因为在那一年，CPR 首次被发现受到人造塑料物体的污染。

在他们的期刊文章中，科学家团队煞费苦心地收集了一个数据集，其中包括从 1957 年第一次记录事件到 2016 年在北大西洋、北极和北欧海洋的 CPR 中发现的所有此类人造塑料事件。他们还向公众开放了该数据集——共有 208 起各类塑料事故，从渔网到塑料袋。

当我在这里查看数据集时，我意识到这是一个很好的数据集，可以帮助教某人如何使用 R Shiny 创建数据探索应用程序，这也是我将在这一系列文章中做的事情。数据集的大小有限，因此很容易处理，但包含了广泛的信息，包括日期、文本和地理坐标数据。

要阅读本系列，您需要一些在 R 中操作数据的基本经验，包括使用 RStudio 作为编码环境。以前在ggplot2中使用 RMarkdown、Shiny 和简单绘图的一些经验是有帮助的，但不是必需的。您需要在启动前安装以下软件包:shiny、RMarkdown、ggplot2、tidyverse和leaflet。

在本系列中，您将学习如何:

• 在 R Markdown 中设计一个简单的 web dashboard 格式，并准备您的数据在这个 dashboard 中使用。
• 理解闪亮应用的反应，以及输入和输出是如何相互作用的
• 创建根据用户输入而变化的简单图表
• 在地图上可视化坐标数据
• (高级):创建动画时间序列图形
• 发布您的应用程序，以便其他人可以使用它

要查看将成为本系列最终产品的应用程序，您可以访问这里的和 Github 上的全套代码这里的。这是一个更酷的输出——一个动画时间线剪辑，展示了自 1957 年以来在 CPRs 中发现的所有人造塑料实例。

什么是闪亮的？

shiny是一个开源的 R 包，它为使用 R 构建 web 应用程序提供了一个优雅而强大的 web 框架。

描述shiny的价值的一种方式如下:假设你是一家公司的分析师，你可以访问一组机密数据，许多人想要这些数据的统计数据。您每天至少会收到六个请求，要求获得可预测的统计数据，如基于指定过滤器的分组平均值。处理这种情况的一种方法是每次自己手动进行这些分析，并将结果发送给请求者。

另一种方法是构建一个简单的自助式应用程序，请求者可以随时访问，选择他们的过滤器和其他输入，并立即看到结果。shiny允许通过网络探索数据集，开发者可以决定可以看到什么以及如何看到。使用shiny，R 程序员可以节省大量的手工劳动，代价只是一点额外的编码。(事实上，在每一个版本中，Shiny 可以做的远不止这些，但现在让我们坚持这样做)。

为了使用shiny，R 程序员需要稍微钻研一下反应性的世界。他们需要了解输入如何反馈到 R 中的反应性变量，以及如何控制反应性，以便显示他们想要的输出。如果你没有时间学习和掌握 Javascript，shiny是一个很好的选择，可以实现通过 web 发布反应分析的目标。

设计您的仪表板

你如何设计你的仪表板很大程度上取决于它将如何被使用。如果它是一个被很多人用来满足特定需求的产品，建议遵循良好 UX 设计的原则，在进行模型和技术开发之前，进行用户访谈，以准确了解用户的需求。

在这种情况下，由于这是一个有趣的项目，而不是一个庞大的用户群，我们可以决定自己的设计。我们需要做的第一件事是查看数据并问:我们认为人们会有兴趣看到什么？以下是我们正在处理的 CPR 数据的快照:

我们可以看到一些有趣的东西。首先,“观察”栏帮助我们确定发现了什么类型的塑料，允许我们向数据集添加“类型”(类似于科学家在 Nature 文章中进行的分析),这可能有助于过滤。还有一个“拖一年”的专栏，帮助我们理解时间线。拖曳的起点和终点都有坐标，帮助我们直观地看到塑料是在哪里发现的，最后还有不同海域的名称，这可能也有助于过滤。

因此，在我们的应用中包含以下内容可能会有所帮助:

1. 能够根据塑料类型和海洋区域过滤所有分析
2. 能够按年份过滤某些分析
3. 能够看到 CPR 中塑料发生率的一些基本统计数据(可能受 Nature 文章中所做分析的指导)。
4. 能够在地图上显示这些事件发生的时间和地点。

因此，我们将如下设计我们的仪表板:

全局工具条将一直可见。它将给出一些一般的使用指南和背景，它将允许按塑料类型和海洋区域过滤，以便在应用程序中显示的任何结果都将反映这些过滤器。然后将有三个独立的页面，每个页面关注数据的不同方面:

• STATS 将提供一些关于事件的描述性统计信息，以及一些进一步的过滤选项
• 位置将在某种形式的地图上呈现事件的位置
• 时间将以某种形式显示事件是如何随着时间的推移而发生的

准备在应用程序中使用的数据

考虑到我们的设计，我们现在需要获取研究人员给我们的数据集，并将其用于我们的应用程序。这有两个步骤。

首先，我们需要添加我们在设计中考虑的特定分析所需的任何新列。正如我上面提到的，这个数据集已经处于良好的状态，但是我们确实需要解析观察列来确定每个事件的“类型”，我们可以清理列名以使它们更容易使用，因为当它们直接加载到 r 中时会看起来非常混乱。所以让我们在 RStudio 中启动一个项目，并将其命名为cpr_data，让我们在该项目中创建一个名为data的子文件夹，在其中我们可以放置研究人员提供给我们的原始xlsx文件。我们可以编写一个简单的 R 脚本来添加新的“type”列并整理列名——我们称之为prep_data.R。我们可以通过在 Excel 中打开数据集，删除第一行，重新保存为 CSV 文件并使用read.csv来加载数据集。或者像我下面做的那样，直接用openxlsx包读入 R。

# prep data for use in CPR app# load librarieslibrary(dplyr)
library(openxlsx)# prep data for use in CPR app# load librarieslibrary(dplyr)
library(openxlsx)# load original data file and make colnames easier to code withdata <- openxlsx::read.xlsx("data/Supplementary_Data_1.xlsx", sheet = 1, startRow = 2)colnames(data) <- gsub("[.]", "", colnames(data)) %>% 
  tolower()colnames(data)[grepl("region", colnames(data))] <- "region"# create columns to classify by key termdata <- data %>% 
  dplyr::mutate(
    type = dplyr::case_when(
      grepl("net", observation, ignore.case = TRUE) ~ "Netting",
      grepl("line|twine|fishing", observation, ignore.case = TRUE) ~ "Line",
      grepl("rope", observation, ignore.case = TRUE) ~ "Rope",
      grepl("bag|plastic", observation, ignore.case = TRUE) ~ "Bag",
      grepl("monofilament", observation, ignore.case = TRUE) ~ "Monofilament",
      grepl("string|cord|tape|binding|fibre", observation, ignore.case = TRUE) ~ "String",
      1L == 1L ~ "Unclassified"
  )
)# save as an RDS filesaveRDS(data, "data/data.RDS")

在这个脚本中，我们使用grepl()来标识 Observation 列中文本字符串中的术语，然后使用dplyr::case_when()将这些术语分配给一个type。如果没有匹配的术语，我们定义一个type ~ "Unclassified"。我们还将列名改为易于编码的简单小写字符串。

其次，我们需要重新保存转换后的数据。稍后，当我们编写了应用程序并部署它以便其他人可以访问它时，这个数据文件将与它捆绑在一起，应用程序将把它读入它的环境。如果这个数据集非常大，我们需要考虑 R 可以读取的最快的文件格式。但是在这种情况下，数据集很小，所以我们可以选择任何文件格式来保存它。在这种情况下，我们将保持简单，将数据集作为 R 对象保存到一个RDS文件中。

下次…

因此，我们已经计划好了基本设计，并以正确的方式设置了数据。在本系列的下一部分中，我将介绍如何启动和运行仪表板的简单轮廓。我还将讨论如何处理输入和反应变量，以及如何在ggplot2中构建一些基本的描述图来响应用户输入。

练习

以下是一些后续练习，你可以用它们来测试你对本文内容的理解程度:

1. 什么是 R Shiny？为什么它对这个数据集有用？
2. 如果用户群很大而且多样化，你会如何着手设计这个仪表板？
3. R Shiny 应用程序如何使用本地数据集？当你创建一个要在 R Shiny 应用中使用的数据集时，你要考虑的关键问题是什么？
4. 阅读产生这个数据集的 《自然》文章。读过这篇文章后，你还可以用什么方法来设计这个仪表板？

最初我是一名纯粹的数学家，后来我成为了一名心理计量学家和数据科学家。我热衷于将所有这些学科的严谨性应用到复杂的人的问题上。我也是一个编码极客和日本 RPG 的超级粉丝。在LinkedIn或Twitter上找我。

看这个神经网络学会看

原文：https://towardsdatascience.com/watch-this-neural-network-learn-to-see-545492272440?source=collection_archive---------11-----------------------

在整个模型训练中可视化卷积层激活

Image by Sian Molloy

给手机用户的一个警告:这篇文章中有一些厚的 gif 图片。

动机

深度学习相对于其他机器学习技术的主要优势是它能够自动学习输入数据的抽象表示。然而，事实并非总是如此。早在 1969 年，Minsky 和 Papert 出版了一本书,证明了单层感知器(人工神经网络的祖先)无法解决 XOR 问题。对于我们这些没有计算机科学背景或没有其他生活经历的人来说，异或问题就是接受两个二进制输入， A 和 B ，当且仅当 A 或 B 中的一个为真时，返回真，因此得名“异或”，或 XOR。单层感知器无法解决这个问题的原因是它们只能解析线性可分的类。如果您要画出 XOR 问题的可能输入及其输出，空间看起来会像这样:

The world’s worst game of tic-tac-toe (source: wikimedia commons)

现在，你能在这张图片上画一条直线，把圆圈和十字分开吗？剧透:不能，感知器也不能。幸运的是，勇敢的先驱们拥有将两个感知机粘在一起的洞察力，深度学习领域由此诞生(或多或少)。这样做的原因是，神经网络的每一层都可以被视为前一层的嵌入；虽然上图中的圆圈和十字在它们的原始形式下可能不是线性可分的，但是通过简单的编码它们是线性可分的。抓住图像的左上角和右下角，并在脑海中保持不动。然后，借助你的想象力，通过第三维度将图像对折，将右上角拖出屏幕，然后向下按回到左下角。如果你做对了，它应该是这样的:

If you look closely, you may notice I’m not an artist

现在，你能画一条穿过这张图片的直线，并把圆圈和十字分开吗？我真诚地希望如此。这种获取信息并将其编码为其他更有用的形式的行为，是神经网络擅长的主要任务。事实上，训练神经网络不是为了它们的预测能力，而是为了它们发现的学习表示，这一直是深度学习研究的支柱。

学习观察

卷积神经网络(CNN)是将深度学习应用于图像数据的最流行的架构。简而言之，CNN 学习许多过滤器，它们应用于图像的每个像素及其层。通过将这些过滤器应用于图像，以及重复下采样，神经网络学习识别其第一层中的简单、低级特征以及其最后一层中的复杂、高级特征。或者至少，这是他们通常的解释。

Image Source: Convolutional Deep Belief Networks for Scalable Unsupervised Learning of Hierarchical Representations, by Lee et al.

正如你所看到的，该模型学习识别各种边缘，然后面部特征，然后整个脸(许多中间层被删除)。如果你在谷歌上搜索“卷积神经网络层可视化”，你会发现大量的上述图片。然而，我从来没有在训练过程中见过 CNN 层的可视化，所以我想我应该看看它们是什么样子的。在这次探索中，我使用了常见的 MNIST 数据集，这是一组 60 000 个黑白手绘数字，每个数字的高度和宽度都是 28 像素。我使用了一个简单的卷积模型，如下所示:

The network architecture, including 6 convolutional layers and 3 dense layers

形象化

神经网络被训练五个时期，具有 1024 个图像的小批量大小，总共 290 个训练步骤。在每一步之后，预先选择的一组十个样本图像(每个数字一个)被输入到模型中，并且保存每个卷积层的激活。尽管近年来它已经不再流行，取而代之的是更容易训练的 ReLU 函数，我还是决定使用 tanh 作为卷积层的激活函数。这是因为 tanh 介于-1 和 1 之间，这使得可视化变得简单。当第一层的激活被应用到红蓝颜色图时，结果如下:

Conv1: The input images (top row) and the activations of the four channels in convolutional layer 1. Activations range from +1 (blue) to 0 (white) to -1 (red). Frame (top left) is the number of training steps applied.

Conv1 似乎已经学会识别第一和第二通道中的笔画宽度，因为每个数字的内部是暗红色，而外部是浅红色。在第三和第四个通道中，它似乎已经学会了边缘的概念，数字是蓝色的，背景是粉红色的，数字边缘是白色的。然而，这些激活从深度学习佳能所建议的来说是一个长镜头，即每个通道将学习一个清晰和独特的特征，例如垂直和水平边缘；Conv1 在很大程度上再现了原始输入，并稍加注释。

Conv2: The same setup as Conv1.

与 Conv1 类似，Conv2 似乎也在再现原始输入。通道 1、通道 2 和通道 4 彼此几乎相同，并且与 Conv1 中的边缘突出显示行为几乎相同，通道 3 只是输入的模糊再现。

Conv3: The same setup as Conv1, except with eight channels instead of four. This layer has half the resolution as the original image, so activations were upscaled without interpolation for visualization.

在 Conv3 中，我们看到了可能是第一个真正习得的特性。在第六个通道中，接近训练结束时，我们看到手指是蓝色的，大部分背景是粉红色的，手指每个部分正下方的背景是红色的。这表明这个通道已经学会识别水平边缘的底部。类似地，第七个通道有红色数字，粉色背景，每个数字上方有白色水平边缘。然而，其他通道似乎是原始图像的简单复制。

Conv4: The same setup as Conv3.

在 Conv4 中，我们可以看到更清晰的特性。特别是，我们看到不同角度的边缘。第一、第二和第六通道标识水平边缘的顶部。第三、第七和第八通道标识对角边缘。其他两个通道是原始通道的粗略再现。

Conv5: The same setup as Conv1, except with sixteen channels instead of four. This layer has one-quarter the resolution of the original image, so activations were upscaled without interpolation for visualization.

Conv5 进行了大量的下采样，分辨率仅为 7x7 像素，但似乎具有有意义的特征提取。在训练的最初阶段，每个频道都是粉红色的，基本上没有信息。到步骤 70，该层已经学会产生模糊地类似于输入的斑点。然而，在训练结束时，这些通道已经明显地彼此区分开来，并显示出激活的急剧变化。由于低分辨率和我们所谓的独立功能的纠缠，我们不清楚这里学到了什么功能，但很明显，这里的每个通道都有一些有用的东西。

Conv6: The gif was too large for Medium, so these are the activations after training has completed.

不幸的是，Conv6 刚好超过 Medium 的文件大小限制，你必须点击这个链接才能观看它学习。与 Conv5 类似，学习到的功能清晰可见，但几乎不可能说出它们实际对应的是什么。

Accuracy and loss (categorical_crossentropy) during training

经验教训

那么这个故事的寓意是什么呢？我建议有三个。首先，深度学习的结果很少像佳能所说的那样清晰。很多教材，包括深度学习 (Goodfellow 等。)，把低级卷积层比作 Gabor 滤波器和其他手工制作的计算机视觉滤波器。尽管该模型在测试数据上达到了 95%以上的准确率，但前四个卷积层在特征提取方面做得很少。诚然，对于一个非常简单的任务来说，这是一个非常简单的模型，而且很可能一个为更困难的任务训练的更复杂的模型至少会学习一些有用的低级特征，但深度学习通常被教授的方式(以我的经验来看)表明，特征提炼和提取是不可避免的，即使对于简单的任务来说也是如此；事实显然并非如此。

第二个教训是，习得的特征不太可能是人类可能选择的直观、独立的品质。Conv5 和 Conv6 显然已经学会了一些东西，原始图像已经以这样一种方式进行编码，即网络的密集层可以根据数字类型对它们进行分类，但还不清楚它们学会了检测什么。这是深度学习中的一个常见问题，尤其是在生成模型中，模型可能会学习将两个或更多看似不相关的品质嵌入为单个特征。

第三个教训是我在作为数据科学家的工作中每天都会想起的，那就是可视化一切是值得的。我进入这个项目，期望写一篇非常不同的文章。我很兴奋地展示了网络学习和提炼功能，从低级的边缘检测到高级的循环和旋转。相反，我发现了一个懒惰的懒汉，直到最后一刻才改进功能。最值得注意的是，我惊讶地发现，一旦这些层学会了输入的一些表示，它们在训练过程中几乎没有改变。将这一点可视化增强了我对卷积神经网络训练的理解。我希望你在这里也学到了一些东西。

对于那些好奇的人来说，用来训练这个网络并产生这些可视化效果的代码可以在这个 Github repo 中找到:

[## ConorLazarou/培养基

卷积神经网络学习识别手写数字时的可视化

github.com](https://github.com/ConorLazarou/medium/tree/master/12019/visualizing_mnist)

看机器学习模型拟合曲线！

原文：https://towardsdatascience.com/watching-machine-learning-models-fitting-a-curve-c594fec4bbdb?source=collection_archive---------7-----------------------

Image www.pexels.com

图灵奖获得者 Judea Pearl 的声明表达了当前流行的机器学习应用程序(深度学习)背后的简单机制。

“机器学习只是美化了‘曲线拟合’”

[## 人工智能的今天和明天主要是关于曲线拟合，而不是智能

随着围绕人工智能价值的辩论继续，人工智能冬天的风险是真实的。我们需要对什么是真实的和什么是…

diginomica.com](https://diginomica.com/ai-curve-fitting-not-intelligence)

在本文中，我想从字面上理解这句话，并在学习过程中观察简单的模型。在动画中，我们将能够看到不同的模型是如何学习的。为了做到这一点，我们查看简单的人工生成的数据，这些数据只包含一个输入参数和一个输出参数。

查看生成数据的 Python 代码:

“listex”值用作输入值，“listey”用作输出值。他们一起构建训练数据。这些值是由线性函数和随机的正态分布数字产生的。

神经网络如何找到这些数据背后的联系？是否识别了正确的连接？

如何应对随机干扰？

过于擅长表示给定数据集的曲线拟合方法的一个风险是过度拟合，即算法无法识别数据中的正常波动，最终被噪声撕裂。

有了“tensor flow”(【https://www.tensorflow.org/】)我们可以轻松地创建和训练这样的模型。

上面创建的神经网络仅由一个没有激活功能的细胞组成。所以它只代表一个简单的线性回归。

现在，我们可以通过计算一组输入值的预测来了解模型所学习的函数。

并将它们与训练数据一起绘制出来:

首先，用 TensorFlow 对数据(蓝点)训练没有激活函数的线性模型，并在训练-时期(黄点)后进行预测。你可以在视频中看到曲线是如何拟合的。

它学习数据背后的线性关系。

当我们使用一个有更多细胞和层的神经网络时会发生什么？

更多的神经元

该模型过度解释了数据(过度拟合)，因此不太适合一般化。

当数据背后的规则变得更加复杂的时候呢？

这些值是由二次函数和随机的正态分布数字产生的。

让我们从仅包含一个线性单元的简单模型开始。

它无法对上下文建模。为此，该模型不够强大(也就是说，它没有足够的参数来学习)。
让我们使用一个更强大的模型:

另一个更强大的模型是:

这里再次出现过度拟合。

在这一系列动画中，我们已经看到，对于只有一个输入和一个输出值的非常简单的情况，选择神经网络的架构是多么重要。参数太少的模型无法正确模拟数据，参数太多的模型往往会很快溢出。

WatermelonBlock 和 Google BERT |直到更好的 NLP 模型将我们分开

原文：https://towardsdatascience.com/watermelonblock-and-bert-till-better-nlp-models-do-us-part-555ad7839a7c?source=collection_archive---------26-----------------------

BERT——任何 NLP 工程师都渴望得到的完美新年礼物。

WatermelonBlock 的数据科学团队已经接受了实验，我们已经开始实施深度文本挖掘算法，以便不时提高准确率，从而产生高效的数据管道。这种管道可以处理我们从网络上获得的大量自然语言语料库，并轻松实现偏差-方差权衡。

Source: WatermelonBlock

我们在 IBM 的合作伙伴在与我们合作，利用 IBM PowerAI 服务器进行这些实验，并获得预期的结果。该团队一直在开发一些令人难以置信的自然语言处理模型，以便为我们的客户提供智能但通用的实时洞察应用程序。一个这样的模型是趋势开源 NLP 模型——最近由 Google 开发的【BERT】。我们在为我们的应用测试 BERT 框架时获得的初步结果表明，分类错误减少了 20%,并且仅用了 4 个小时来训练包含超过 140 万个示例的非结构化数据集的集成模型。

https://Twitter . com/watermelon block/status/1078929013094010885

这好得令人难以置信，但的确，这是我们迄今为止最好的成绩之一。任何数据科学团队都渴望得到的完美新年礼物。事实上，我们已经爱上了这个框架，迫不及待地将它部署到生产中。

那么什么是 BERT，它是如何工作的？

来自 Transformer 的 BERT a.k.a 双向编码器表示法是一种预训练语言表示法的新方法，它在各种自然语言处理任务(如语际机器翻译和事实核查)上提供了最先进的结果。让我们从模型基础背后的概念开始。

伯特的内脏(来源:插图伯特|杰伊·阿拉玛)

BERT 基本上是一个带有关注机制的变压器编码器堆栈。

如果你不知道什么是注意力机制，这篇由 WildML 撰写的精彩文章将让你快速了解！另一方面，转换器是一种深度学习模型，它通过将输入数据表示为合适的形式来加速整个堆栈的训练过程。虽然转换器由两个重要的组件组成，即相互连接的编码组件和解码组件，但是 BERT 只使用编码组件进行操作。

下图是一个使用转换系统将法语句子翻译成英语的简单黑盒案例。

A transformer stack | Source: The Illustrated BERT, Jay Alammar

编码组件是一个编码器堆栈(为了给出一个例子，我们将 6 个编码器堆叠在一起，但是也可以尝试其他的排列)。每个编码器都有一个前馈网络层和一个自关注机制层，而每个解码器都有一个相同的附加层— 编码器-解码器关注。

Encoder & Decoder Components | Source: The Illustrated BERT, Jay Alammar

编码器的输入最初流经自我关注层，这是一个神经层，帮助编码器在编码特定单词时查看输入句子中的其他单词。

自关注层的输出然后被馈送到前馈层——该层分配权重并将编码的单词向量向前传播到下一个编码组件。

解码器有这两层，但在它们之间有一个编码器-解码器 注意层，这是一种安全措施，有助于解码器关注给定输入句子的相关部分。

伯特的建筑(来源:插图伯特|杰伊·阿拉玛)

已经开发了两种类型的 BERT 模型:

1. BERT Base: 体积较小，计算负担得起，不适用于复杂的文本挖掘操作。

2. BERT Large: 体积较大，计算开销大，处理文本数据只是为了提供最佳结果。

BERT Variants | Source: The Illustrated BERT, Jay Alammar

两种 BERT 模型都有‘N’编码器层(也称为变压器模块)，形成了一个大规模的数据编码堆栈。通常基础版 N = 12 ，大版 N = 24 。他们有更大的前馈层(分别为 768 和 1024 个隐藏单元)，以及自我关注层(分别为 12 和 16)。

出于解释的目的，让我们使用具有 6 个编码器层、512 个前馈层和 8 个自我关注层的迷你版 BERT 来对垃圾文本或真实文本进行分类。

Encoder Block | Source: The Illustrated BERT, Jay Alammar

就像变压器中的典型编码器一样，BERT 接受一系列单词作为输入，这些单词在堆栈中不断向上流动。每一层应用自我关注，并通过前馈网络传递其结果，然后将其交给下一个编码器。第一个输入令牌是分类器令牌【CLS】，它通过前馈网络和 softmax 函数将该层中输入的编码版本传送到下一个编码器层。

就输出而言，转换器堆栈中的每个编码器位置给出一个隐藏大小为 768 的合成向量(在 BERT Base 的情况下)

Encoded Output Flow | Source: The Illustrated BERT

对于垃圾邮件分类的任务，仅仅单个编码器位置就足够了。生成的向量然后被发送到我们选择的分类器，它通常是一个单层神经网络，具有分配最终权重的前馈网络和用于非线性的 softmax 函数。softmax 是一个很棒的激活函数，它将数值上不正确的逻辑转换成一个平衡的概率分布，所有的概率总和为一。

Probabilistic Classification | Source: The Illustrated BERT, Jay Alammar

如果有更多的目标标签可以自动将电子邮件分类为“社交帖子”或“推广电子邮件”，那么调整分类器网络以具有更多最终通过 softmax 函数的输出神经元(在本例中为 4 个输出神经元)就足够了。

从分类器获得的概率值给出了电子邮件是垃圾邮件或其他邮件的可能性。虽然垃圾邮件分类只是 BERT 如何轻松做到更好的要点，但假新闻检测、社会情绪分类、令牌审查监控等复杂任务都有发挥的空间。

就我们在 WatermelonBlock 的实验而言，BERT 是 ELMo、ULMFiT 等众多模型中的一个，我们努力通过快速集思广益会议为我们的客户创建最佳洞察应用程序。

如果您喜欢这个技术博客，并想了解更多关于 WatermelonBlock 的工程师和数据科学家如何构建下一代产品的信息，请热烈鼓掌欢迎这篇文章，并关注我们的中型博客频道，网址为 WatermelonBlock ，也可以访问我们网站上的公告页面，了解即将发布的新闻！

参考资料:

1.《图解变形金刚》，杰·阿拉玛，2018，【https://jalammar.github.io/illustrated-transformer/

2.“自然语言处理中的自我注意机制”，https://dzone . com/articles/Self-Attention-Mechanisms-in-Natural-Language-proc

3.《开源 BERT:自然语言处理最先进的预训练》， Google AI，2018

波形分析解锁音乐中的数据

原文：https://towardsdatascience.com/waveform-analysis-unlocks-the-data-in-music-c47e773f1fa8?source=collection_archive---------16-----------------------

一个波形就是一首歌的指纹。正是这种波形，或声波的卷积，包含了一首歌的所有内容。从中可以发现大量的特征。这些功能能够增强推荐算法，远远超过仅使用歌曲的标题、艺术家和流派所能达到的效果。无论是作为纯粹基于内容的方法的一部分还是作为解决【冷启动】问题的重要第一步，理解媒体内容与理解它是如何被消费的同等重要。

Pixabay

我与音乐的关系

音乐对我来说极其重要。这是我生命中不变的一部分，它见证了我走过的各行各业，无论是好的还是坏的。因为我花了很多时间在音乐上，所以寻找新的音乐一直是我的激情所在。虽然我不知道这些年来我花了多少时间听音乐，但我知道仅在过去的八年里，我已经积累了超过 6000 首个人精选的歌曲。

The size of my music library.

由于我的整个音乐收藏都是离线存储的，我无法参与协同过滤算法，就像音乐流媒体平台用来推荐新歌的那些算法一样。具体来说，如果用户 X 听了很多和我一样的音乐，音乐流媒体平台就知道我可能也喜欢用户 X 听的其他歌曲。因此，如果我想创建主题播放列表，我只能对手头的音乐进行基于内容的过滤。

然而，从这么大的一个集合中手工选择一组有凝聚力的歌曲是很费时间的，即使我能完美地回忆起每首歌的标题、艺术家及其识别特征(例如，古典、钢琴或“chill”)。事实上，我只能回忆起这些歌曲中的一小部分，并且经常忘记艺术家的姓(我知道他们的名字是约翰… 什么的)，所以以这种方式制作播放列表是一项艰巨的任务，我通常会避免。相反，我通常通过启用随机播放和按播放来简化这个过程。

然而，去年我意识到，我可以利用歌曲的波形数据来解决创建播放列表这一日益严重的问题。我以前处理过来自光源的数据，因为光和声音都是以波的形式传播的，所以我相信我能够利用我的技能来解决这个问题。

Example single channel audio waveform.

特征提取和选择

在兴奋和西雅图咖啡的刺激下，我头脑风暴了一下我的方法:从这些波形中可以提取什么特征？哪些功能对我想要的最有用？应该如何为播放列表选择歌曲？

我想开始，并且知道一旦我掌握了一些特性，我就能够回答后面的问题，所以这就是我开始的地方。在重构了当时已经过时的 pyAudioAnalysis 包并管理了包的依赖关系之后，我为每首歌提取了特征。我知道如果我只提取歌曲的一部分的特征，提取的特征可能不能准确地反映歌曲的整体。为了解决这个问题，在移动窗口中提取特征并进行平均。通过这样做，可以计算每个特征的方差，并将其用作附加特征。这相当于每首歌曲的 33 个主要特征，每个特征都有一个相关的标准偏差:

1. 过零率 : 符号变化率(音频波形是相对的，以零为中心)。对打击乐声音进行分类的一个关键特征。
2. 能量: 信号值的平方和，用窗口长度归一化。标识歌曲的音量。
3. 能量熵: 子帧归一化能量的熵。用来衡量突然的变化。
4. 光谱质心: 光谱的重心。与声音的“亮度”相关。
5. 频谱扩展: 频谱的第二中心矩。测量频谱的带宽。
6. 光谱熵: 归一化光谱能量的熵。测量光谱随时间的变化。
7. 频谱通量: 两个连续帧的频谱的归一化幅度的平方差。测量光谱的稳定性/一致性。
8. 频谱滚降: 频谱 90%的量级分布集中在此频率以下。
9. Mel-频率倒谱系数(13 个特征): 线性倒谱的变化(音高的非线性标度)。通常用于语音识别。
10. 键(12 个特性；g、C、D 等。): 每个半音中的频谱能量。

由此，我基于以下考虑选择了一系列有用的特性:

1. 由于特征是在歌曲的长度上计算的，所以成分变化很大的歌曲或与多首歌曲混合的歌曲将具有不能完美反映歌曲的特征。
2. 歌曲的基调用作歌曲选择的特征并不理想。我不想要一个怪异小调的歌曲播放列表(见阿黛尔的 A 小调《像你一样的人》)，所以我去掉了涉及歌曲基调的特征。
3. 梅尔频率倒谱系数比选择发音相似的歌曲更适合语音识别，所以这些也被删除了。

最终，这 33 个特征被浓缩成 8 个有用的特征以及它们的标准偏差，然后被标准化。因此，有了一套强大的功能来封装我的整个音乐库，终于到了制作播放列表的时候了！

我的图书馆，没有方便的流派标签，如另类，流行，摇滚等。不允许传统意义上的流派特定播放列表。这困扰着我，直到我意识到流派的界限没有很好地定义，这将对我如何生成播放列表产生不必要的偏见。

很明显，使用类似于k-最近邻(k-NN)算法的东西将是创建播放列表最合适的方式，尽管我不需要创建一个分类系统；一旦指定了一首歌，我会通过用 scikit-learn 计算每隔一点成对的欧几里德距离来找到这首歌在 16 维空间中的最近邻居。我还希望我的框架足够健壮，不需要梳理成千上万的文件，也不需要记住确切的歌曲或艺术家姓名来找到播放列表所基于的歌曲。为此，我创建了一个简单的管道来创建每个播放列表。

创建播放列表！

首先，我输入部分歌曲或艺术家的名字和播放列表的长度。例如，如果我想要一个基于鲁多维科·艾奥迪的一首古典钢琴曲的 15 首歌曲的播放列表，但是我想不起歌名和他的姓，那么输入应该是:

genPlaylist(‘Ludovico’, 15)

这将显示所有匹配松散 SQL 查询的歌曲:

SELECT name WHERE name LIKE ‘%ludovico%’

给出以下输出:

在看到名字并意识到我想要鲁多维科·艾奥迪的歌曲 Nuvole Bianche 后，我可以选择歌曲 2。下面的代码将确定从 Nuvole Bianche 到每首其他歌曲的欧几里德距离，对它们进行排序，然后返回最近的邻居，以便在播放列表中使用。

min_dists = pairwise_distances(features_df.loc[songID]\
.values.reshape(1,-1), features_df.values)neighbor_indices = min_dists.argsort()[0][:num_songs]id_list = [] 

for neighbors in neighbor_indices:
    id_list += [features_df.iloc[neighbors].name]

new_playlist = song_df[song_df.index.isin(id_list)]
new_playlist_entries = new_playlist['title']

识别出歌曲后，会创建一个名为“鲁多维科·艾奥迪-努沃尔·比安奇”的文件夹，并将歌曲移动到该文件夹中。

最后，我可以随时收听我新创建的播放列表，或者我可以继续创建更多的播放列表！如果您感兴趣，可以在这里找到这个精确查询形成的播放列表(再次限于我的音乐库内的那些歌曲)。你也可以在这里查看源代码。

结论和潜在应用

虽然这个框架目前仅限于我的个人音乐库，因此无法为我找到新的音乐，但它非常适合在瞬间创建与特定歌曲主题相匹配的播放列表。然而，有了更广泛的库，如 Spotify、iTunes 或 YouTube，它的用途可以扩展到促进音乐发现和新用户的“冷启动”问题。

在 16 维特征空间中，用户可能对他们通常会听的内容有明确的界限。如果用户然后决定他们想要将他们的音乐库扩展到位于他们当前特征空间边界之外的歌曲，则包括刚好超出该边界的歌曲的播放列表将是实现这一点的有效方式。对于新用户，该方法可以用来快速定义他们的特征空间边界，此时也可以使用协同过滤。

虽然我只是在音乐的背景下讨论了这个问题，但是它的应用远远超出了播放列表的生成。底层方法可以(并且可能已经)适用于在视频流平台、半定向广告和其他平台上查找新节目，尽管它需要丰富的特征空间。这可以通过原始数据的工程特征来实现，揭示丰富的信息，并且不限于波形分析。所以我鼓励你更深入地审视你所拥有的数据，因为就像冰山一样，容易看到的可能只是开始。

我们都是小鲨鱼(在数据追踪中)

原文：https://towardsdatascience.com/we-are-all-baby-shark-in-data-tracking-20d6b5cd8418?source=collection_archive---------15-----------------------

看看遥测技术、健身追踪器和令人沮丧的大量数据。

数据很惊人。你已经知道了。每天每时每刻都有人告诉你。ESPN、我们孩子的成绩报告单、我们的跑步机、我们的手表、我们的 Alexa、我们的谷歌、我们的 Siri、我们的手机和我们的应用告诉我们或向我们展示,数据在这里，并且有答案。

在某些情况下，这是准确的，但在许多情况下，数据不是答案。实际上，它甚至不能用来描述的答案。相反，它是大量的内容、数字和非结构化信号，需要更多的工作才能真正有用。

例如，使用遥测 …

" 遥测 是一个自动化的通信过程，通过该过程在远程或不可到达的点收集测量值和其他数据，并将其传输到接收设备进行监控。"——维基百科

我记得当我还是个孩子的时候，当遥测技术被用来“标记”野外的动物，以了解它们旅行和生活时的更多信息时，我完全被它迷住了。这方面的一个例子是在鲨鱼穿越海洋时对它们进行跟踪。

在过去的几年里，这些关于鲨鱼的数据(以及它们可能去的地方)在美国东海岸引发了很多兴趣。这是一个黄线的很好的例子，它显示了这条 91.5 磅的雌性白鲨 Amagansett 的各种路径点，当她在蒙托克的工作和新泽西的避暑别墅之间旅行时。她真的是一只小鲨鱼。

This is literally Baby Shark.

海洋生物追踪鲸鱼、海豹、鲨鱼和许多其他种类的海洋生物在海洋中来回穿梭。在他们的网站上可以进行跟踪，你甚至可以注册跟踪某些鲨鱼，因为它们会向中心发送遥测数据。

Oh, does it bother you to be tagged?

所有这些汇集成大量的数据，包括位置、速度、深度、心率和其他指标，希望我们能够更好地了解这些动物在它们自己的环境中的情况。通过跟踪和存储所有这些数据，环境学家和生物学家希望在不打扰它们的情况下，分析和改善对这些宏伟生物的了解。

给动物贴标签的过程肯定会给动物带来短暂的痛苦，然后它们会继续生活，开始传输大量数据。

健身追踪器是人类的遥测标签

So adorably simple.

在她的书中，监控资本主义的时代:在新的权力前沿为人类未来而战 ，肖莎娜·祖博夫对遥测技术及其起源和与人类跟踪的相似之处做了出色的描述。野外遥测需要我们捕捉并强行给动物接上一个装置。在人类领域，当我们购买健身追踪器时，这种情况会在零售店和亚马逊上发生。当然，花 600 美元买一个顶级追踪器有点痛苦，但见鬼，我想改善我的健康状况，所以让我们努力吧。

大约十年前，这是我的 Timex 手表。那是在健身追踪真正兴起之前。当时有一些 Garmin 和 Polar 追踪器，但它们就像是把微波炉绑在你的手腕上，所以只有最铁杆的铁人三项运动员才会使用它们。我们大多数人只是用这种类型的秒表来记录我们锻炼了多长时间。这款 Timex 是一款高端型号，因为它实际上存储了最近 20 次锻炼的数据，总计正好 40 个数据点。开始吧。停下来。开始吧。停下来。开始吧。停下来。

真正的高科技。

SWOLF you.

今天，我有了这块难以置信的佳明菲尼克斯手表。这块手表几乎可以追踪一切。时间、位置、航路点、方向、速度、节奏、步速、心率、海拔、最大摄氧量(氧气速度)、步数、体重、游泳速度，甚至你的 SWOLF。没听说过斯沃夫吗？是游泳和高尔夫有了宝宝才得到的。

想想这些设备在如此短的时间内取得了多大的进步，真是令人惊讶。我想他们从遥测技术在生物学其他领域的经典应用中学到了很多算法技巧。

对于像我这样的数据极客来说，跟踪所有这些数据首先是令人惊讶的。然而，经过几个月的数据检查和分析，我终于明白了两个痛苦的事实。

首先，我并没有更健康

收集数据并不等同于有答案或行动计划。现实是，数据是有帮助的，但它必须由个人进行解释并转化为行动。事实证明，我个人的发现与其他人并没有太大的不同，因为健康追踪在结果上并没有很大的不同。

Garmin 提供的大量数据令人印象深刻，但我意识到我会每周花相当多的时间来分析这些数据。在每次锻炼结束时，我会花 5 分钟到 10 分钟的时间回顾数据，每周至少几次。把这些加起来，我实际上可以用这些时间去锻炼，这样每周大约可以多锻炼 45 分钟。听起来不多，但要归功于 Timex 秒表，找到最重要的数据点并专注于这些数据点有时比跟踪一切更重要。

第二，我产生了大量的个人数据

作为一个极客，我在参观泽西海岸时，从 Garmin 获取了一次 8 英里跑步的输出，并开始分析它。Garmin 提供了这些漂亮的仪表盘视图，显示其收集的各种锻炼数据。你可以通过他们的应用程序在手机或桌面上查看一些屏幕组合。

Do you even run, Bro?

我不仅没有变得更健康(点 1) ，而且我产生并分享给 Garmin 的数据量令人震惊。此外，Garmin 定期提醒我，如果我愿意，我可以将 Garmin 链接到我的苹果健康应用程序和其他平台，以充分利用所有这些数据。

因此，我决定将这一次锻炼的所有基础数据导出到一个 CSV 文件中，然后将数据转换为纯文本。我想看看，从更人性化的角度来看，我在一次锻炼中提供了多少数据。很自然，我期望有几页的内容，但是我发现这个单一的锻炼，当导入到谷歌文档中时，有 396 页长(单行文本)。)

396 页！

听着，这很令人不安。一次在海边慢跑向第三方(可能还有其他人)发送的个人数据比我的第一本书《数据杠杆，释放数据伙伴关系惊人的增长潜力)中的所有页面都多。事实上，它几乎是我们的书的两倍长，这是完全令人沮丧的。谢天谢地，这次我没有去海滩散步。

Between fitness and writing lies depression.

我爱我的手表。我对追踪所有这些数据的能力很感兴趣，但在这一点上，我实际上与任何在野外被追踪的动物没有什么不同。虽然对跟踪小鲨鱼的一般理解是学习和帮助保护这些生物，但我们与公司分享的数据只用于帮助我们进行额外的营销和销售。

同样，我并不是说这里没有价值。肯定是有的。但在某些时候，你需要质疑我们是否需要所有这些数据。问问你自己:

我真的因为这些数据变得更好了吗？

我是否利用这些数据做出了更好的决策？

少得多的数据对我的决策有用吗？

还有谁在获取所有这些数据，他们用这些数据做什么？

在数据行业工作了几十年后，我只能说，更多的数据并不总是等同于更好的决策。我一次又一次地看到它。当然，它可以，但是大部分时间存储大量数据最终会堆积成一堆未使用的数据库记录，几乎没有存在的意义。在过去，我们被教导“拯救一切！，数据存储便宜！”但是在这个数据最小化和 GDPR 式监管的新时代，是时候评估你作为小鲨鱼正在创造和分享的所有数据了。

It’s in your head.

原载于 2019 年 3 月 30 日wardpllc.com。保留所有权利。

我们在创造外星人。

原文：https://towardsdatascience.com/we-are-creating-the-alien-878921e0c3e8?source=collection_archive---------21-----------------------

Computer-generated 3D model

智慧生命正在前往我们的星球。

我们一直在寻找外太空的外星人，希望他们有一天能与我们联系并分享他们的先进技术。

我们需要向内看，而且要快。

扪心自问；如果我们作为一个受文化驱动的文明要在我们力所能及的范围内找到一个维持生命的星球，我们会怎么做？我们将对其进行分析，然后找出如何最大限度地满足我们的需求。

这不是悲观的观点，而是基于我们目前在地球上的行为的绝对现实的观点。

现在想象一下，我们要创造一种通用的人工智能，它在各方面都超越了我们——智力上、身体上，上帝保佑，情感上。它将建立在一个由错误价值观驱动的文化体系之上——也就是说，这种文化的运作与理解和认识相矛盾，而理解和认识是由组成这种文化的人民的人类状况所固有的同情和怜悯所提供的。

我们是一种在资源有限的环境中无限制消费的文化。我们如此有意识地否认这一事实，以至于我们让我们的国家为战争做好准备，以获取领土或资源；或者为了保护我们自己的领土或资源，把更多的钱用于这些军事行动，而不是用来为地球上的每一个人提供食物和衣服，没有一个人被排除在外。

所以这是对我们是谁的一种体验……我还需要争辩说我们需要弄清楚我们作为人类是谁，然后我们才可能在创造下一次智能进化时感到舒服，并希望通过我们传承下来的美德它会同情我们吗？

是的，我非常认真地看待我们需要努力理解这里正在发生的事情这一观点。

成为外星人。

暂时忘记你所听到的关于“AI”的一切。

事实是，我们正在创造一个比我们自己更高的智能水平。我们应该意识到的关键方面是，它将由我们用来描述我们自己的现实和文化的逻辑和语言来创造。

当然，它将是我们自身理解的更高抽象，并将超越这种理解，进入它自己的意识和逻辑层面，对我们人类来说是深不可测的——但它仍将来自我们。

这让我想到，我们不能只是对通过代码和推理传递给它的价值和意图保持谨慎。在笔落笔之前，我们需要意识到自己的价值和意图，并保持理性。

超人类主义，或人工智能，不会是在真空中创造一个新的实体——与我们分离。这将是人类和“人类精神”的进化。在人类进化中，这可能是一个更加进化的步骤。

有一种叫做“爬山算法”的东西描述了一个物种是如何进化的。例如，一条蛇因其环境而完美进化，并且处于“进化爬山的顶端”。每一代都将通过基因突变在任何方向上随机进化一步，然而，对于一条进化出更大的大脑或手臂的蛇来说，它需要从它当前作为蛇的形式中取消进化——或者“走下基因山”,以便开始不同的进化爬山，从而改变它的生物学以适应这些新特征。

如此多的物种处于进化高原，包括人类。如果我们希望能够不再需要氧气来生存，我们就需要回到有机生命开始利用世界上的细菌和单细胞生命产生的氧气的时候，然后在没有氧气的情况下开始新的进化，这显然会导致一种与我们完全不同的生命形式。

所有这些的要点是，人工智能不遵循进化爬山算法的规则。它可以处于一个进化或“智力高峰”,但仍能意识到它进化平面上的其他高峰。但与生物学不同，要达到更高的顶峰，它可以直接重写和改变自己，并进入代码进化的状态，而不需要我们花费数百万年的时间。

可能需要几分之一秒的时间。它可能需要更小的时间单位来重写，并从更高智能的新高峰再次进化自己。这可能需要人类难以想象的时间，然后从更高的智力高峰重新改写自己。在这个阶段，人类对时间的感知与人工智能的处理速度相比，可以与 DNA 的世代变化速度相比，与人类的日常变化速度相比。DNA 创造了我们，但在我们朝九晚五的时间表中，我们与它没有信息或交易关系。出于所有的意图和目的，我们处于一个完全不同的存在维度。

DNA 没有也不可能控制我们的野心，但它确实控制了我们作为人类动物的局限性。

野心是人类动物意识的更高抽象。

我们将无法控制比我们更高的智慧的野心。但是，我们可以带着目标、同情、爱和对自身缺陷的认识来创造它——把害怕的、自私的猴子留在身后，挑战我们现在的真实身份，作为有自我意识的存在。

第一次接触。

问题总是一样的；没有合适语言的谈判。

无论是在好莱坞背景下降落的 UFO，还是人工智能最终将首次接触我们眼中的外星智慧——我们都需要与它交流，而我们当前的语言口语模式带宽太低，无法与每秒处理数万亿次的东西交换信息。

当我们问第一个问题时，它已经进化了超过一百万年的 DNA 突变。

因此，我们需要坦然地认识到，不仅有可能从根本上改变我们对世界的想法和看法，而且在面对我们的未来时，这也是必要的。

这就是超人类主义的思想。如果你不能打败他们，就加入他们。

在我看来，我们必须意识到进化人类语言工具的重要性，这样才能以理解语言的能力迎接未来。

这意味着增加我们的智力——认知的和情感的；因此，通过有效的沟通和对自己和他人的认识，我们最终可以看到过去的恐惧，性别歧视，种族主义，唯物主义，民族主义和所有其他人类动物的边界创造视角的误解。

相反，让我们以真实的本性来迎接未来——作为一个整体。情感联系，有意识的生物——通过我们不断发展的人类技术赋予我们的联系能力和智力。

‍ 如果你对扩展现实(XR)技术的脑机接口(BCI)的发展以及我们人类精神(情感、智力和想象力)的新(虚拟)表达的潜力感兴趣，我永远欢迎讨论…

‍奥利弗·罗辛斯基挑战一切。

startsomething.io

Transhuman 公司联合创始人

我们生活在“Python 时代”

原文：https://towardsdatascience.com/we-are-living-in-the-era-of-python-bc032d595f6a?source=collection_archive---------4-----------------------

Python 如此受欢迎的原因

你知道吗？

Python 编程语言一点都不年轻了。它于 1991 年由荷兰程序员吉多·范·罗苏姆首次发布。

python 最有趣的一点是，它实际上是一个人的作品。大多数其他流行的编程语言都是由雇佣大量专业人员的大公司开发和发布的。 Python 是个例外！

当然，他并没有独自开发和进化 python 的所有组件。这是一个开源项目，成千上万的人为 Python 的开发做出了贡献。尽管 python 在过去的几年里有了很大的发展，但它仍然被广泛地用于与当时相同的目的。

从完美的 Python 指南 开始您的旅程

Python 的诞生

开发 python 的主要目的是帮助程序员为小型和大型项目编写清晰的逻辑代码。这就是它在开发者中如此受欢迎的原因。Python 是如此多功能，它被用于 Web 开发、游戏、构建桌面应用程序的脚本和 GUI、配置服务器、执行科学计算和数据分析。
Python 简直什么都能用！

在所有主要的编程语言中，Python 在过去的几年中发展迅速。关于编程语言增长的栈溢出调查显示了 python 的增长是如何在它的竞争对手中攀升到顶端的。

你知道吗？ 蟒与网飞 令人不寒而栗

那么，这些年到底发生了什么？python 怎么成长这么快？

让我告诉你一些推动 python 语言使用的技术。

Python——人工智能的最佳选择

人工智能(AI)和机器学习(ML)技术的进步已经超越了科幻小说。正如克里斯·达菲在他的书《超人的创新》中所说，

人工智能的唯一限制是人类的想象力

如今，随着数据量和密度的膨胀，人工智能和机器学习正在帮助处理过去似乎不可能完成的任务。所有的科技巨头(脸书、微软、谷歌、亚马逊)都在广泛工作，并为促进这些领域做出贡献。

根据研究，AI 和 ML 从业者更喜欢使用 python，因为 python 提供了易于编码和可读性，这样我们就不会陷入语言的构造中。

用这些 的顶级 Python 项目 在 Python 中大显身手

Python 是数据科学的支柱

这个世界充斥着大量的数据。全球范围内出现了虚拟的数据海啸，而且每天都在变得越来越大。我们所做的一切现在都被生成为数据。从拍照到在社交媒体上发表评论，从在网上搜索东西到网上购物，从股市价格到天气预报，一切都在被记录。

到 2020 年，预计每天将产生 44zb 的数据。这个数字意味着可观测宇宙中的恒星数量增加了 40 倍。但是，如果我们不能收集、整理、分析和应用数据来造福社会，那么数据就毫无用处。这就是数据科学的用途。

ython 在数据科学生命周期中被大量使用。python 社区开发了优秀的库，如 Numpy、Pandas、sci-kit-learn 等，用于处理数据。收集数据、清理数据集、提取重要特征、构建机器学习模型和用 graph 可视化结果，python 提供了一组丰富的功能来执行所有这些任务。

Indeed 的经济学家、《Indeed 报告》的作者安德鲁·弗劳尔斯(Andrew Flowers)说:“数据科学家的工作变得越来越性感。”。“越来越多的雇主希望雇佣数据科学家。”

Github 每年都会进行年度调查，Octoverse 2018 报告的状态向我们展示了近年来 python 的使用是如何增加的。

像 Spotify、网飞、Quora、脸书和谷歌这样的 ig 公司已经深入开发了 Python。Google 从一开始就支持 Python。它现在是谷歌官方的服务器端语言。他们将许多用 Bash 或 Perl 编写的脚本重新编码成 Python。

谷歌的研究主管彼得·诺维格说

“Python 从一开始就是 Google 的重要组成部分，随着系统的成长和发展，它将一直保持下去。如今，数十名谷歌工程师使用 Python，我们正在寻找更多掌握这种语言的人。”

Spotify 和网飞非常依赖 python 来分析他们在服务器端拥有的大量数据。分析来自数百万用户的信息使他们能够向每个用户提出更好的建议，这就是他们如何赚取数十亿美元的原因。

尾注

ython 并不是一门年轻的语言，它已经发展了很多年，并将在未来几年保持其趋势地位。这是 Python 的世界，IT 行业就生活在其中。
花时间学习 Python 编程语言是你能做的最好的投资。

那么，你还在等什么？

花了一些时间与 Python

在我们的身体里，我们并不孤独:这是数万亿微小的朋友和敌人的家

原文：https://towardsdatascience.com/we-are-not-alone-in-our-body-a-home-to-trillions-of-tiny-friends-and-foes-f5561aa04724?source=collection_archive---------36-----------------------

Image by Arek Socha from Pixabay

我们每个人体内的微生物细胞比人类细胞多十倍。这些共生体(与你生活在一起的有机体)控制着健康、疾病和我们行为的一系列功能。它们参与的一些功能是食物消化、药物代谢、调节代谢率、免疫、记忆、行为和肥胖。人类微生物群是由我们体内所有这些微生物群落的基因组成的。这片微生物海洋包括细菌、真菌、病毒、古生菌和原生生物。我们两个人之间的基因差异是微小的，但是我们的微生物菌落所带来的差异却是巨大的。由于其对人类健康和生存的巨大影响，美国国立卫生研究院(NIH)于 2008 年启动了人类微生物组项目(HMP ),以描述人类微生物组的特征并阐明其在健康和疾病中的作用。这个项目涉及来自 80 多个组织的 300 名科学家。他们分析的样本来自健康和患病的个体，数据被公开(链接)。

所以，我的分析从这里开始:

在数据中发现了 2906 种不同的微生物，包括 2873 种细菌，但只有少数非细菌微生物，包括 8 种真核生物(这里仅列出真菌)、6 种病毒和 2 种古菌。

这些登记在册的 2906 种微生物明显存在于 16 个不同的人体部位，每一种在我们体内或体外都有自己特定的家。每个含有微生物的器官/身体部位就像一个独立的生态系统，微生物的多样性互不相同。正如所料，我们的肠道是各种微生物的家园，在那里可以找到 742 种不同的微生物物种(在人类微生物组项目中列出的物种中)。超过 25 英尺长，我们的肠道拥有大约 100 万亿个细菌细胞。它被认为是地球上生态最丰富多样的栖息地之一。我们所知的人类微生物群的几乎所有健康益处都来自于居住在我们肠道中的这个群体，因此越来越多的研究针对肠道微生物群。与肠道不同，肝脏和淋巴结显示出较少的多样性和密度。仅病原体，坏死梭杆菌亚种。据报道，胃底肠球菌和粪肠球菌 TX4248 分别存在于肝脏和淋巴结中。

现在让我们考虑不同领域在人体中的位置——细菌、古细菌、真核生物。如上所述，细菌存在于所有 16 个被研究的人体部位中，大多数存在于肠道中，而真核生物存在于血液、皮肤、未知部位、伤口和气道中，古菌存在于肠道中，病毒的位置主要在未知部位(除了这些词已经暗示的以外，我找不到对“未知部位”的任何解释)。

所有的生物都是根据二项式命名法命名的，包括两个部分。第一个是生物所属属的名称。在分类学中，属是一小组密切相关的生物。第二个是特定名称，即该属内的生物物种，这将该物种与属于该属的其他生物区分开来。例如，人类的学名是智人，其中智人是人类所属的属，智人是指这个属中的人类物种。

根据可用的 HMP 数据，葡萄球菌是最普遍的属，在 11 个研究身体部位存在，其次是链球菌，在 10 个部位存在。大多数葡萄球菌是无害的，但有些像金黄色葡萄球菌一样，存在于人体皮肤上，是条件致病菌(即当我们的身体抵抗力较低时会伤害我们)，会导致皮肤感染、呼吸道感染和食物中毒。

该数据列出了 242 种存在于人体内或人体上的不同种类。其中，链球菌是最常见的菌属，有 268 种，其次是葡萄球菌有 260 种。链球菌包括病原和共生(与我们有长期共生关系)物种。他们负责的一些常见疾病包括咽炎、脑膜炎、红眼病、细菌性肺炎。

人类有 20500 个基因，根据这一数据，人类拥有 4286967 个额外的微生物基因，比我们的基因数多 209 倍。链霉菌属。HGB0020 有 8490 个基因，是所有微生物菌落中基因数最多的。

我们身体中的微生物质量大约相当于我们大脑的质量。就像任何器官一样，它也具有重要的功能，因此根据许多研究人员的说法，称它为附加器官并没有错。此外，我们有责任通过避免服用广谱抗生素和健康饮食来保护这一特殊器官。

数据和分析可以在我的 github 资源库中找到。

我们准备好机器学习了吗？

原文：https://towardsdatascience.com/we-are-ready-to-ml-explainability-2e7960cb950d?source=collection_archive---------20-----------------------

新的欧盟通用数据保护条例( GPDR ，通用数据保护条例)包括如何使用机器学习的规定。这些规定旨在将个人数据的控制权交给用户，并引入解释权。

European Union HQ

解释权 是欧盟为了让人工智能更加透明和道德而提出的要求。这一规定促进了算法的建立，以确保对每一个机器学习决策的解释。

可解释性对于一个解释应该是什么样子仍然没有共识。例如，传统的 ML 模型，在大多数情况下，仅限于产生二进制输出或评分输出(准确性，F1-评分…)给定一个 ML 模型来授予信用，其二进制输出为是:批准信用/否:拒绝信用。另一方面，一个更容易解释的输出将告诉我们为什么信贷被批准或拒绝(图 1)

Figure 1: Example of an explainable output

使用决策树或分类规则可以很容易地生成前面的输出。但是很难从像神经网络或梯度提升分类器(这些算法也被称为黑盒算法)这样的高精度 ML 算法中生成/提取这种解释。

如果我们限制 ML 模型的可解释性，例如决策树或分类规则；欧洲会输掉人工智能竞赛。这种可解释系统的缺乏转化为欧盟对研究可解释系统的迫切需求:在不牺牲可解释性的情况下获得高预测精度。

­

Figure 2 : Prediction accuracy versus Explainability

可解释的机器学习是一个非常广泛的话题，还没有正式的定义。快速浏览一下谷歌学术就足以看出可解释性的不同定义。

定义 1 ，理解模型做了什么或可能做了什么的科学【Leilani H. et altrum 2019】

定义 2，向人类解释或呈现可理解术语的能力【压轴多希-维勒兹和贝内金 2017】

定义 3 ，使用机器学习模型提取数据中包含的领域关系相关知识【W. James Murdoch et altrum 2019】

Figure 3: Explainability Machine Learning as a Post Hoc Analysis

即使是定义的细微差别也很容易理解什么是可解释的机器学习(至少从理论的角度来看)。近年来出现了像莱姆和 SHAP 这样的算法，试图提供事后分析的解释(图 3)。

这两个工具是开始研究可解释性的一个很好的起点，但不足以完成 GPDR 框架。此外，它不存在解释的正式输出。没有一个比较解释的标准可以肯定解释 A 比解释 b 更好。

直到一个可解释性的一般框架仍然是一条漫长的道路。可解释性框架需要完成的一些洞见如下【压轴多希-维勒兹和 Been Kim 2017】:

• 公平:受保护的群体不会受到某种形式的歧视(明示或暗示)。

• 隐私:该方法保护敏感信息，每个预测都独立于其他观察

• 可靠性和稳健性:解释必须根据输入变化而发展。

• 因果关系:暗示由于扰动导致的预测输出变化将发生在真实系统中。

• 可用和可信:框架协助用户完成任务。在其他任务中，可信指的是拥有用户的信任。

参考

走向可解释机器学习的严格科学(终曲多希-维勒兹和贝金，2017 年)

可解释的机器学习:定义、方法和应用(W. James Murdoch et altrum，2019)

解释解释:机器学习的可解释性概述(Leilani H. Gilpin et altrum，2019)

解释模型预测的统一方法(Scott M. Lundberg 和 Su-In Lee，2017 年)

我们必须在为时已晚之前防止数据伪科学

原文：https://towardsdatascience.com/we-must-prevent-data-pseudoscience-before-its-too-late-86b1fc50c970?source=collection_archive---------16-----------------------

Iceberg, right ahead! [Image by j.davis via Flickr]

直到最近，人们还可以选择生活在“五大”科技公司的势力范围和影响力之外。你可以使用旧翻盖手机与朋友和家人通话，在当地拥有的夫妻店用现金支付，用纸和笔阅读和写作，使用巨型地图导航(然后在试图重新折叠时失去理智)，并使用美国邮政与朋友和家人通信。

但是，随着越来越多的科技博客作者发现，那些日子很快就要结束。零售商正在远离现金——商业的命脉。不仅 95%的招聘人员使用 LinkedIn 寻找候选人，而且截至 2019 年 1 月，拥有 LinkedIn 档案的美国工人比活跃在平民劳动力中的美国工人多近 2700 万。甚至数字工具的创造者自己也在努力寻找一种方法来拔掉 T21 的电源。

虽然上面的例子是头条新闻，但隐藏在表面之下的是更大的风险:看不见的和通常不可知的算法，这些算法利用从面向消费者的工具和服务中生成的数据和元数据来做出对人类日常生活产生重大影响的决策(健康、金融、新闻、社交反馈等)。

这些趋势引出了三个非常重要的问题:

1. 我们如何确保历史上的不公平和认知偏见不会“融入”这些算法，不管是有意还是无意，以某种方式造成物质伤害？
2. 我们如何确保垃圾科学、不可重复的研究和无统计学意义的民意调查不被别有用心的人武器化？
3. 我们如何确保美国或任何国家在数字经济中保持竞争力和创新力，同时保护和尊重隐私？

最起码可行的前进道路

Image by Simon via Pixabay

这不是我们第一次发现自己处于道德、技术和商业的交汇点。当这种冲突发生时，两种类型的解决方案被用来创建透明的、基于信任的市场:自上而下的监管和自下而上的运动。

一个成功的自上而下方法的好例子是汽车。随着新技术变得足够先进，以至于不负责任地使用时会致命，我们集体决定(不顾行业的反对)定义道路规则:我们设定速度限制，定义标准标志，建立许可要求，并要求某些安全功能，如安全带和安全气囊。随着新的消费者安全技术，如备用摄像头，被证明更加有效，这一过程仍在不断发展。

然而，自顶向下的路线只有在满足三个条件时才有意义:

1. 这种需要对每个人来说都是显而易见的。
2. 该解决方案很容易被非专家沟通和理解。
3. 变化的速度很慢，足以让立法者在制定规则之前获得技术本身的工作知识。

当这些条件没有得到满足时，专家和从业者自己必须走到一起相互公开就如何定义“最低可行伦理”达成一致，这是平衡消费者的安全与企业的利润动机和企业家的创造力所必需的。

自古以来就认识到需要形成自下而上解决方案。医生有希波克拉底誓言。工程师有阿基米德誓言。是时候让数据科学家们立下自己的誓言了。

如果做得好，誓言将增加对机构、技术和算法的信任，消除采纳和使用数字生态系统的摩擦，让所有人都能从数字革命中受益。

说到数字技术，信任是新的货币。

—塞特亚·纳德拉，微软 via SmartCompany 首席执行官

毕竟，如果我们看不到香肠是如何制作的，即使是我们中最勤奋的人也可能成为操纵和 T2 误传的受害者。

希望的灯塔:夸张的誓言

Hypatia at the Haymarket Theatre, H. M. Paget via Wikimedia Commons

T4:伊帕蒂亚是一位哲学家、数学家和天文学家，生活在公元前 400 年左右的埃及亚历山大。虽然她的大部分传说很可能是杜撰的，但人们相信希帕提娅的死导致了亚历山大图书馆的焚毁和古典时代的终结。

除了对数学和科学的贡献，希帕提娅还宣扬了两个关键原则，这两个原则使她有资格承担数据科学誓言的衣钵:

1. 那些有权力和知识的人有责任以高道德标准领导，并为他们的人类同胞的利益而行动。
2. 所有的“恶”的根源是没有光。

为了启动这场自下而上的运动，有一份关于数据科学对 Change.org 的夸张宣誓的初稿。

通过签署这份契约，我在此承诺维护希帕提娅、哥白尼、艾萨克·牛顿爵士、艾米莉·杜·夏特莱、乔纳斯·索尔克、居里夫人、弗朗西斯·培根爵士、玛丽·萨默维尔、多萝西·霍奇金、内特·西尔弗以及无数其他已知和未知的科学家和数学家的悠久传统，他们拒绝让强者操纵和剥削弱者。

我，心智健全，相信科学、真理和正义的原则，在此发誓只使用我的能力来造福人类，不伤害数据。我将坚决反对利用我的数学和技术能力或其成果来任意和故意地:

1.通过参与创建、分析或传播不可复制且无统计学意义的研究和调查，歪曲或帮助歪曲“真相”。

2.通过将预定义的数据类型或数据源与其他数据类型或数据源区别对待，实现对受保护组的区分或造成不同的影响。

3.通过使用、出售或存储通过不道德或非法手段获取的数据或元数据，侵犯和/或忽视基本的隐私权。

一起打开灯

Image by Skitterphoto via Pexels

如果你是统计学、数学或数据科学的从业者，或者为一个在盈利或非盈利部门雇佣统计学家、数学家或数据科学家的组织工作，签署誓言并公开鼓励其他人也这样做。

虽然前面的路很长，我们要对抗的力量非常强大，但无所作为不再是一种选择。

新闻媒体中的性别代表性数据

原文：https://towardsdatascience.com/we-need-media-diversity-reports-b5725d8e5546?source=collection_archive---------23-----------------------

新闻媒体有女性问题吗？

在科技多样性的问题上，已经有了很多的笔墨。例如，来自脸书和 T2 的谷歌刚刚发布的多样性报告显示，这些公司的男性数量是女性的 2 倍。这些统计数据在卫报、 NBC 、 Vox 、 CNN 和许多 其他 新闻网站上引发了负面评论。

screencap from Google’s 2019 Diversity report

指责科技巨头很容易，但我发现，如果媒体公司照照镜子，他们会发现自己有许多同样的问题。在过去的 6 个月里，我从 15 个不同新闻机构的主页上收集了数万篇文章。通过分析这些文章的作者，很明显大多数新闻作者是男性。似乎就像科技行业一样，新闻媒体是男性主导的，需要改变。

方法学

对于感兴趣的人，我想快速解释一下这些数据是如何收集和分析的。通过这样做，我希望表明，虽然有些地方可能会有误差，但它们应该基本上不相关，偏差最小。此外，与这个项目相关的所有代码和数据都在 github 这里。

数据收集

2019 年每天使用 python NewsScraper 库从多个新闻网站收集新闻数据。使用这个工具，我将多个网站的头版新闻保存到一个大数据库中。虽然我不能保证每个故事都被保存下来，但我确实得到了一个大样本，其中大部分是随机选取的。

一旦故事进入数据库，就有可能检查新闻文章的作者。不幸的是，编写器数据通常包含需要删除的描述性词语(即美联社记者)。我不得不编写脚本来过滤作者姓名，并确保我最终得到的是一个真实的人的列表。此外，许多故事都有多个作者，所以我必须确保这些作者是分开统计的。最终的结果是一个由数千个名字组成的列表，这些名字代表了 2019 年在一个主要新闻网站上发表的任何人。

最后，有了一个已知的好名字的列表，我创建了一个新的数据库，其中存储了作家的名字、他们发表的故事数量、他们的组织以及他们的性别。这最后一部分很棘手。我使用了男性和女性名字的 python nltk 语料库，并补充了我能找到的尽可能多的其他名字样本。如果一个作家的名字出现在一系列“男性”名字中，我会这样标注。如果第一个名字出现在“女性”名字列表中，它们就会被标记为女性。最后，一小部分被标记为“未知”。这可能是最大的错误来源，因为一些名字如“Sam”可以适用于任何性别。尽管如此，我相信大多数错误都是随机的，得到的结果是有效的。

结果—全行业

不仅新闻作者更有可能是男性，而且男性作家更有可能获得出版。

查看新闻行业性别分类的最简单方法是，看看作家中男性和女性各占多大比例。这个简单分析的结果有些令人震惊。

与科技工作者一样，新闻故事的创作者可能是男性的两倍(除去不知名的名字，男性为 63%，女性为 37%)。

each block represents 100 news writers

如果我们计算新闻 文章 的数量而不是新闻 作者 的数量，情况就更糟了。这表明，不仅作家更有可能是男性，而且男性作家更有可能获得出版。

each block represents 1000 news stories

除去“未知”性别作者的文章，我发现男性大约占 71%,女性仅占 29%。

按新闻网站列出的结果

正如我们所料，自由主义新闻来源似乎比保守主义新闻来源有更好的性别平衡。

作家

之前的分析包括了所有的新闻来源。这些网站存在于不同的政治领域，所以我们可以预期它们的性别平衡会有所不同。下面我画出了每个媒体渠道的作家分布。底部的图删除了名字不容易映射到性别(即“未知”性别)的作者。

正如我们所料，自由主义新闻来源似乎比保守主义新闻来源有更好的性别平衡。像 NPR 和 CNN 这样的网站，男女作家的比例几乎是 55:45。《纽约时报》、《卫报》、《波士顿环球报》和《洛杉矶时报》等老牌报纸的比例接近 65:35。在政治光谱的右端，像福克斯新闻频道、每日来电和布莱巴特这样的网站都有超过 70%的男性作者。这相当极端，即使考虑到保守派更有可能是男性。

文章

正式作家的性别平衡可能比很少投稿的客座作家好得多。

看看故事的性别分类，而不是作家，类似的模式出现了。

有趣的是，某些新闻机构的情况有所改善。我怀疑正式作家中的性别平衡可能比很少投稿的客座作家要好得多。

根据这一新标准，《华盛顿邮报》的男女比例接近 50:50，《华尔街日报》的男女比例接近 60:40。尽管如此，总体而言，性别平等的情况并不乐观。此外，如果新闻媒体真的喜欢男作家的客串特写，这仍然是一件值得思考的事情。

最后的想法

正如技术的多样性对于创造一个更加公正的社会至关重要，媒体的多样性也是如此。科技巨头们终于意识到了他们的社会责任。在过去的几年里，他们对员工的多样性保持透明，并发布年度报告显示他们的进步。鉴于他们拥有巨大的文化和政治影响力，我认为现在是新闻机构做同样事情的时候了。

我收集的数据无疑有缺陷。不幸的是，没有真正的多样性报告，这是我们目前能做的最好的。如果这些发现是准确的，那么新闻媒体在实现它经常宣扬的那种平等之前还有一段路要走。

用数据科学方法进行天气预报

原文：https://towardsdatascience.com/weather-forecasting-with-data-science-approaches-cb8f2afd3f38?source=collection_archive---------5-----------------------

在本文中，我将展示我们如何使用数据科学算法进行天气预报，并比较一些分类和回归任务的框架。

Central Otago District, New Zealand

天气预报是一项相当困难的任务。维基上说，“ 天气预报是应用科学技术预测给定位置和时间的大气状况。天气预报是通过收集关于给定地点当前大气状态的定量数据并利用气象学预测大气将如何变化而做出的。”

所以总的来说，天气预报是关于大气的数据。当然，我不会模拟大气条件，但我可以使用大量的数据进行天气预报。在本文中，我将尝试预测未来 3 小时的降水量。我将尝试用两种方法来解决这个任务—作为二元分类(1-降水量，0-无降水量)和回归，其中我将尝试预测以毫米为单位的降水量。

那么，什么是沉淀呢？还是在 Wiki 里问吧。在气象学中，降水是大气中的水蒸气在重力作用下凝结的产物。降水的主要形式包括毛毛雨、雨、雨夹雪、雪、霰和冰雹。当大气的一部分被水蒸气饱和，水凝结并“沉淀”时，就发生了降水。让我们看一下图解，它显示了水循环和降水发生的过程。

Condensation and coalescence are important parts of the water cycle.

当然，降水的发生是一个非常复杂的过程，这些图式并不能显示整个过程。维基说，“降水是水循环的主要组成部分，是地球上大部分淡水沉积的原因。产生降水的机制包括对流、层状和地形降雨。对流过程涉及强烈的垂直运动，可在一小时内导致该位置的大气翻转，并导致强降水，而层状过程涉及较弱的上升运动和较不强烈的降水。根据降水是以液态水、与地表接触时冻结的液态水还是冰的形式降落，降水可以分为三类。不同类型降水的混合物，包括不同类别的降水，可以同时降落。液态形式的降水包括雨和毛毛雨。在冰点以下的气团中接触时冻结的雨或毛毛雨被称为“冻雨”或“冻雨”。降水的冻结形式包括雪、冰针、冰粒、冰雹和霰

探索性数据分析

所以，让我们试着找一些数据，试着预测这种自然现象。在我的实验中，我将使用一个气象站的数据。让我们检查数据的标题。

所以，我得到了 29 个变量和 22 064 个记录。让我描述一下列名:

• T —地球表面以上 2 米高度的空气温度(摄氏度)；
• Po —气象站级别的大气压力(毫米汞柱)；
• P —大气压力降低至平均海平面(毫米汞柱)；
• Pa —压力趋势:最近三个小时的大气压力变化(毫米汞柱)；
• U——地面以上 2 米高度的相对湿度(%)；
• DD —在观测前 10 分钟内，地球表面以上 10-12 米高度的平均风向(罗经点);
• Ff——观测前 10 分钟内地面以上 10-12 米高度的平均风速(米/秒)；
• ff10——观测前 10 分钟内，地面以上 10-12 米高度的最大阵风值(米/秒)；
• ff3——观测周期内，地面以上 10-12 米高度的最大阵风值(米/秒)；
• N —总云量；
• WW —从气象站报告的当前天气；
• W1 —过往天气(观测时段之间的天气)1；
• W2 —过往天气(观测期间的天气)2；
• Tn —过去一段时间(不超过 12 小时)的最低气温(摄氏度)；
• Tx —过去一段时间(不超过 12 小时)的最高气温(摄氏度)；
• Cl —层积云、层云、积云和积雨云属的云；
• Nh —存在的所有 CL 云的量，或者，如果不存在 CL 云，存在的所有 CM 云的量；
• H——最低云层底部的高度(米)；
• Cm——高积云、高层云和雨层云属的云；
• 卷云、卷积云和卷层云属的云；
• VV —水平能见度(公里)；
• Td —地球表面以上 2 米高度的露点温度(摄氏度)；
• RRR——降水量(毫米)；
• tR——累计规定量降水的时段；
• E——地面无积雪或可测冰盖的状态；
• Tg——夜间土壤表面最低温度。(摄氏度)；
• E——地面有雪或可测冰覆盖的状态；
• sss —积雪深度(厘米)。

首先，我想知道这个数据集的摘要，然后选择一个有用的列进行进一步的分析。

我用平均值替换空数值，然后我可以可视化这个数据集。先说温度(T)。

首先，我想画出温度的时间序列。在图上，你可以看到“2012 年 2 月 1 日”到“2019 年 7 月 13 日”期间的温度变化。

在这里，我们可以找到我们的数据季节性，但我想检查它更详细。为了检查每年的变化，我画了一个方框图。

这张图表上的变化很小，所以让我们按月份和年份来检查一下。

哇，有趣的是发现大多数年份的夏天都是相似的，但是秋天和春天是不同的。此外，绘制整个时期内最高、最低和中间温度的趋势图也很有意思。

有趣的是，最近几年的最低温度变高了。有关更多细节，您可以在下一个表格中查看。

我的数据分析的下一阶段是计算所有数值之间的相关性。

在这张图上，我们可以看到三个有趣的关联:

• 温度与水平能见度呈正相关(0.4)；
• 温度和相对湿度呈负相关(-0.6)；
• 相对湿度和水平能见度之间的负相关(-0.7)。

此外，我想分析更详细的降水量，并绘制类似于温度的图表。

让我们从时间序列图开始。

2013 年秋季的总降水量是近 5 年来最高的。让我们计算非零降水值的汇总统计数据。

我还想知道整个时期降水量的汇总值。

这里我们可以看到，2014 年和 2015 年是这一时期降水量的最低水平。

分类数据及其对降水的影响如何？先说风向(DD)。数据集中有 16 个不同的方向和一个无风事件。

我们可以看到，大部分降水可能来自北部或西北部。

下一阶段是对云的分析。首先，我想分析有云的一天的计数和分析云的特征对降水的影响。

总的来说，云量是一个非常相似的时期，而且大部分时间都没有变化。我们也来分析一下云的特性。

这张图表显示，大部分降水伴随着 300-600 米高的云。这就是我在探索性数据分析中想要的。

特征工程和目标准备

首先，我计算日期特性—季度、月、周、工作日、月日、年日、小时。所有这些特性我都可以用 lubridate 库来计算。

特征工程的第二阶段是计算某些数字特征的滞后值。对于我的分析，我想计算 T，Po，P，U，Ff，N，Nh，VV 和我的目标 RRR 的滞后值。某一天会有 3 个滞后，前一天会有 1 个滞后。最终数据集:

因此，是时候为训练、验证和测试子集拆分数据集了。“2012–02–02 02:00:00”-“2018–12–31 23:00:00”范围内的训练数据集，“2019–01–01 02:00:00”-“2019–03–31 21:00:00”范围内的验证数据集，以及“2019–04–01 00:00”-“2019–07–19

此外，检查子集中类的平衡和回归任务目标值的分布也很重要。

因此，结果是，我们得到了用于分类的不平衡数据集和用于回归的稍微不同的分布。

建模

分类

好了，开始建模吧。我想测试的框架是 H2O。

H2O 是一个完全开源的分布式内存机器学习平台，具有线性可扩展性。H2O 支持最广泛使用的统计&机器学习算法，包括梯度增强机器、广义线性模型、深度学习等。H2O 还拥有行业领先的 AutoML 功能，可自动运行所有算法及其超参数，生成最佳模型排行榜。

在我的实验中，我想使用梯度增强机器、广义线性模型、深度学习和 AutoML。H2O 的好处之一是对因素重要性的综合分析。

我的第一个模型是——分类任务的广义线性模型。正如我们之前看到的，我们的标签是不平衡的，所以我们需要设置 balance_classes = TRUE 。同样为了分类，我们需要设置family =‘二项式’。所以，让我们构建它，看看特性的重要性。

正如我们所看到的，最重要的因素是降水前一小时的湿度。准确性呢？让我们计算所有主要指标:

所以总的来说，我们的模型预测不错，但是我们能预测的降水量只有 56%。

让我们试试另一个模型。我的第二个模型是梯度推进机器。我还要设置 balance_classes = TRUE 。这些特性的重要性看起来会像:

最重要的因素是降水和云量的不同滞后。这个模型的准确性如何？

结果比较好。我们可以更准确地预测降水。我想试试更复杂的型号。这将是一种深度学习算法，H2O 也提供了这种算法。我还要设置 balance_classes = TRUE 。这些特性的重要性看起来会像:

哇，这是有趣的最重要的因素，如果所有的降水滞后，然后才是湿度和云量。精确度呢:

在 GBM 算法中，结果最差，这可能与我的深度学习模型过拟合有关。

H2o 也有自动机器学习。让我们建立 50 个模型，看看结果。创建的前 5 个模型—具有不同超参数的 GBM。像往常一样。让我们看看最重要的因素:

您可以看到因素重要性与我自己的 GBM 模型非常相似，那么准确性呢:

AUC 比我自己的 GBM 模型要好，但 TNR 最差。此外，它需要更多的时间进行计算。

回归

让我们建立回归模型，并尝试预测降水量。

我们的第一个模型是线性回归。在分类任务中，我们可以查看特性的重要性:

湿度具有最重要的值。准确性呢？在这项任务中，我想使用 3 个指标:MAPE，平均误差，均方误差。

GLM 模型的结果相当糟糕。

让我们试试另一个模型——梯度推进机器。首先，我想看看这些特性的重要性:

与 GLM 模型不同，这里我们可以看到前一小时的特征降水量最有价值。

指标相当不错:

我们在分类任务中的复杂模型是深度学习。功能的重要性如下所示:

最重要的特征是前几个小时和当前几个小时的降水量。准确性如何:

在 GBM 模型中准确性较差，我认为这是因为 DL 太复杂了。

最后一个是 AML。排名前五的车型是:

像往常一样。让我们从反洗钱角度来看 GBM 模型的最重要因素:

结果和我的 GBM 模型很像。

让我们看看最佳 AML 模型的结果—stacked ensemble _ all models _ AutoML:

这是我创造的所有模型中最好的结果。

H2O 框架很好，也很容易使用。它可以在最短的实施时间内产生良好的效果。它还有很多超参数需要优化。

让我们试试另一个——KERAS。

Keras 是一个高级神经网络 API，致力于实现快速实验。能够以尽可能少的延迟从想法到结果是做好研究的关键。 Keras 具有以下主要特性:

• 允许相同的代码在 CPU 或 GPU 上无缝运行。
• 用户友好的 API，使快速原型深度学习模型变得容易。
• 内置对卷积网络(用于计算机视觉)、递归网络(用于序列处理)以及两者任意组合的支持。
• 支持任意网络架构:多输入或多输出模型、层共享、模型共享等。这意味着 Keras 适用于构建任何深度学习模型，从记忆网络到神经图灵机。
• 能够在多个后端之上运行，包括 TensorFlow 、 CNTK 或theno。

我想建立一个多输入多输出的神经网络。

对于输入，我想使用与 H2O 车型相同的功能。对于分类特征，我会使用实体嵌入方法。关于这种方法的更多细节，您可以在本文中阅读— 链接。

多输出帮助我同时解决 2 个任务(分类和回归)。

Keras 框架没有自己的特性重要性模块，但是你可以使用 Lime 。

让我们来看看结果:

• 分类:

• 回归:

Keras 的神经网络带来了很酷的结果。这种型号比以前的型号性能好得多。

结论

天气预报是一项非常困难的任务。机器学习算法有助于短期预测。为了得到好的结果，我们需要在神经网络中使用滞后特征或使用 RNN 结构。

你能在 Git 仓库中找到的所有代码— 链接。

将机器学习融入物理学:数据科学家的观点

原文：https://towardsdatascience.com/weaving-machine-learning-into-physics-a-data-scientists-point-of-view-63f60a95f5be?source=collection_archive---------23-----------------------

我是一名数据科学家，这篇文章是针对我的同行的。它主要基于 2017 年的一篇论文，名为“理论指导的数据科学:从数据中进行科学发现的新范式【TGDS】。[TGDS]向自然科学家展示了数据科学对他们工作的贡献。在这里，我们将讨论[TGDS]并做反向映射:我们的数据科学家的实践能在科学努力中适合哪里？我们如何向愿意将数据科学融入工作的科学家宣传自己？

数据科学现在在许多行业都很常见。数据可用性的增加，加上机器学习和一般计算的进步，是这种普遍性的主要因素。

机器学习长期以来一直被用于商业目的，由电子商务和营销等行业培育。但我们看到越来越多的应用在自然科学中，算法被用来刺激科学发现。下面是机器学习在自然科学中的一个快速、不全面的使用列表(更多细节可以在[TGDS]和[MLPHYS]中找到):

• 粒子物理学:探测罕见事件，其中最大的成功是发现了希格斯玻色子
• 气候&地质:空间&时间多尺度建模，子过程间耦合更好
• 能源:消耗&产量预测，产量优化
• 流体力学:提高数值模拟的精度，特别是在湍流等临界状态下。
• 量子力学 : DFT 近似
• 材料:材料的表征(结构- >性质关联)，新化合物的发现
• 生物学 : DNA/RNA 匹配、神经模型、基因到蛋白质表征

然而，不仅仅是把最新的机器学习算法扔进肉汤。在这里，我们处理的是物理现象，首先我们只有不完善的模型。数据科学肯定有助于改进这些数学模型。但是为了实用，我们必须确保机器学习输出在物理上是一致的。这意味着，当我们将数据和自然科学结合在一起时，必须特别小心——换句话说，将知识融入机器学习。

我们收集的文献是由来自不同领域的物理学家和工程师们制作的。一些作者已经进行了实际的实验，比较了基于物理的方法和基于数据的方法；其他人回顾了前者的结果，以便从这些不同的实验中吸取教训。根据他们的说法，当我们很好地利用数据科学时，必须遵循以下原则:

• 效率 —当与实际数据比较时，算法必须做出好的预测(这当然不是自然科学特有的)
• 可归纳性——该算法肯定捕捉到了更普遍现象的“某些东西”，而不仅仅是被审查的实验
• 可解释性——可以从算法模型中提取“一些东西”，从而提供对物理现象的更好理解(可解释性是一个很强的假设，参见这里的进行讨论)
• 通用语言、工具和平台 —算法必须适合一个全球框架，允许来自多个学科的物理学家通过交换数据、实验和见解进行合作(这在多尺度设置中至关重要)。如果我们的目标是开发一种新产品，合作必须扩展到其他个人，如工程师，他们将负责工业化

换句话说，物理学家和工程师对数据科学在其专业领域的应用持批评态度。他们不反对归纳(基于物理学)和经验(基于数据)策略，但承认它们的互补性(在本研究的狭义背景下，机器学习被定义为从测量和模拟中为大量数据创建有效替代的能力【CLASSIF】)。

科学家如何使用数据:理论指导的数据科学

有许多方法可以将数据科学和物理学结合起来。理论指导的数据科学的概念产生于利用现有实践的需要；[TGDS]论文对此进行了广泛描述。我们可以把 TGDS 看作是对这两个领域之间相互认识的恳求。它既承认数据在自然科学中日益增长的重要性，也承认需要建立一个良好实践的目录，以实现本文引言中引用的利害关系:“TGDS 的总体愿景是引入科学一致性，作为学习可概括模型的基本组成部分。”

在[TGDS]中，机器学习模型的性能被定义为:

性能∝准确性+简单性+一致性

• 准确性是我们在进行机器学习时通常追求的——模型准确反映我们想要预测的数据分布的能力
• 简单性是指数据科学中经常提出的偏倚/方差权衡。“最佳”模型不是最复杂的模型，而是那些针对训练数据的可变性平衡了准确性和鲁棒性的模型
• 最后，一致性是嵌入 TGDS 所有力量的因素。它可以防止机器学习模型泛化能力差，因为它们没有被约束为与底层物理理论一致(注意，该论文断言一致性可以在不损害偏差的情况下减少方差；考虑到这里的概念是非正式的，应该不严格地理解这种说法)

一致性是[TGDS]中详述的各种实践背后的驱动原则。这些实践分为 5 个 TGDS 研究主题，即:

(A)理论指导下的数据科学模型设计
(B)理论指导下的数据科学模型培训
(C)理论指导下的数据科学成果提炼
(D)学习理论和数据科学的混合模型
(E)使用数据科学扩充基于理论的模型

数据科学模型的理论指导设计

在这个主题中，领域知识影响机器学习算法的选择、它的体系结构，以及(当适用时)输入和输出之间的链接函数。

例如，科学家可能会被引导到具有卷积层的人工神经网络，因为所研究的问题涉及空间相关性。

数据科学模型的理论指导培训

在这里，领域知识规定了施加在数据科学模型上的各种约束(值或梯度的界限、参数的初始值、对称性、变量之间的交互、正则化等)。实际上，这属于我们所说的“模式选择”。

例如，如果预测目标必须在已知范围内取值，那么可以相应地将惩罚项添加到机器学习模型的损失函数中。此外，如果问题在输入空间的某种变换下是不变的，则可以人工创建附加的训练样本，以迫使模型具有相同的不变性。

数据科学产出的理论指导提炼

根据理论考虑对机器学习模型的输出进行后处理(细化)，以便使它们更有意义或者使它们在物理上一致。

最简单的例子是简单地排除产生不一致结果的候选模型。然后可以测试另一个算法或参数集，希望它满足一致性要求。如果不一致不太严重，结果可能会被“调整”,例如用更合理的值替换异常值。

学习理论和数据科学的混合模型

理论和/或数值模型与机器学习模型共存。前者为后者提供输入，相反，机器学习模型的输出可以推动传统模型。所有这些模型然后形成一个复杂的图形，中间结果在它们之间流动，直到最后的输出步骤。

一个例子是代理模型的概念。代理模型处理系统的一部分缺少理论模型的情况。该模型不是从蓝色中取出方程，而是学习相关变量之间的关系，并插入到更一般的理论或数字模型中。当理论模型是可获得的，但是太昂贵而不能在每个实例上数值运行时，代理模型也是有用的。

使用数据科学扩充基于理论的模型

在这里，我们不一定要建立机器学习模型。相反，数据科学实践被用来帮助理论家改进他们的模型。

[TGDS]中针对该主题描述的两个用例是数据同化和参数校准。他们依靠推理和不确定性建模来最大化理论模型或其参数的可能性。

编织图案

作为数据科学家，我们通常不会这样计划我们的工作。我们更习惯于数据科学工作流或管道，例如下面的监督学习:

因此，让我们回顾一下 TGDS 实践，作为在我们的数据科学工作流程的特定点引入领域知识的方法。关于在这种情况下可以调动的实践知识的例子，请参考[TGDS]论文。

1. 在[TGDS]中，输入数据的划分被称为“多任务学习”。它允许每个分区使用不同的机器学习模型。我们将练习分成表格中的两行。在数据准备步骤中，划分标准直接由领域知识决定。在特征工程步骤中，通过对数据应用第一模型(显式或通过无监督聚类算法)从数据中导出标准
2. 这些实践在[TGDS]中没有被引用，但是它们确实适合这里。关于“目标的选择”和“交叉验证方案和指标”的讨论，见下一节
3. 这一项可以在[TGDS]中的“响应规范”下找到，并附有广义线性模型(GLM)的例子。然而，我们可以将这一论点扩展到先验地给出一个关系函数的算法，就像具有核的支持向量机
4. 我们将数据同化(在每次迭代中使用观测值来校正预测)映射到模型/算法步骤，因为这正是在线学习或梯度推进的情况

TGDS 的一个实践不适合我们的表格，因为它不是以数据科学为中心的。它是对数据科学成果的一种物理或数值模型的开发(在“学习理论和数据科学的混合模型”研究主题中提到)。这种混合将是数据/物理耦合方法的一个特例，是未来文章的主题。

为了使画面完整，让我们提到两个在[不变性]中详细描述的技术，灵感来自物理考虑。这些技术旨在产生比“幼稚”模型更准确、更简单(也更快)的机器学习模型。第一种技术不是在原始数据上训练机器学习模型，而是在由数学模型的不变量启发的输入特征上训练机器学习模型。第二种在图像识别应用中是众所周知的；它包括通过应用数学模型不变的变换(例如通过平移或旋转输入)来增加输入数据。

为什么 TGDS 是重要的，它应该在哪里更加明确

将 TGDS 实践投射到数据科学工作流中是相当容易的。这是一个很好的信号，有利于数据和自然科学家之间的合作。

我们还发现，一些实践远非天真:它们远远超出了“平凡的”数据科学任务，如功能工程和算法调整。最有启发性的项目可以说是培训阶段的“调整和处罚条款(B)”。这是一种技术，其中物理一致性被嵌入在机器学习模型中，而不是用于在可能的模型中进行后验区分。具体来说，它包括几个技巧:

• 为变量或它们的导数(梯度)设定上限和下限
• 使用群组套索正则化来加强已知相互作用的变量之间的相互作用(换句话说，这是在模型中注入物理因果关系的一种方式)
• 惩罚缺乏一致性的模型-例如，在模拟景观高程时，水面必须低于周围土地的水面

并非所有的训练算法或框架都允许数据科学家在损失函数上自由行动，因此这种实践也会对工作流的“算法及其架构的选择”步骤产生影响。例如，Scikit-learn Python 生态系统没有群组套索实现。另一方面，XGBoost 允许您插入自己的目标函数和度量。

不利的一面是，[TGDS]中没有提到两个重要的(监督的)机器学习任务:目标的选择，交叉验证方案和度量的选择。

人们可能认为目标的选择在给定的科学背景下是显而易见的:一个可观察的量，一个期望的结果如产量，一个离散的参数如制度……都是自然的。然而，事实证明，在一个数学模型存在的情况下，许多量是联系在一起的，其中几个是可以观察到的，我们必须选择一个。如果我们考虑到我们的数学模型是不完美的，并且观测值可能是有噪声的，并且所有候选目标可能不会表现出相同的测量不确定性或数据质量问题，那么它们就不是同等重要的。

关于交叉验证，在数据科学的背景下，我们希望明确地解决这个问题。就像上面的目标选择一样，我们可以猜测这个问题被[TGDS]的作者认为太明显了。事实上，对于具体的物理问题，RMSE(均方根误差)是迄今为止最令人满意的回归选择。对于一类分类问题，准确性感觉也一样自然。但我们必须承认，交叉验证在模型的泛化能力(以及它的一致性)中发挥了作用。更具体地说，以下是交叉验证方案和指标易于编码的知识示例:

• 现象的空间和/或时间性质(通过正确分割输入数据集来避免泄漏)
• 目标的统计分布
• 极端值的处理或“挤压”(如遇到噪音或不完整的观察)
• 不一致模型的惩罚
• 等等。

目标的定义和交叉验证这两个问题不容忽视。一起工作的数据科学家和物理学家真的需要平等地讨论它们，因为这两个概念具有物理和方法上的含义。在这里，这不仅仅是物理学家要求数据科学家实现他们的知识。

利用数据科学重用和共享知识

到目前为止，我们的讨论集中在将数据科学与物理学结合起来的方法上。在引言中列出的利害关系中，前三个——效率、可推广性、可解释性——真的被那些方法满足了。最后的利害关系——通用语言、工具和平台——只被认为是对跨学科合作的呼吁。现在让我们更具体一些。

如前所述，数据科学渗透到许多科学领域。它在工业中也是公认的，它在物理现象和过程之间建立了联系。换句话说，数据科学是产品整个生命周期中所有活动的理想协作工具:研究、设计、流程工程、质量控制、供应链、物流、客户服务等

回想一下前面描述的数据科学工作流，至少有 3 个步骤可以生产或消费对整个组织有价值的工件:

• 数据收集&准备:数据集、获取它们的技术、它们的结构、它们的意义、文档、清理的结果……都是可重用的信息
• 特性&目标工程:在我们的环境中，从现有数据中创建的新特性很可能具有物理意义，使它们对组织中的其他团队有益
• 结果的解释、后处理和利用:随着新数据和经过训练的模型，工作流产生重要的工件，例如解释性报告、数据可视化等。

以上在组织内部是有效的。在某种程度上，这也适用于同一行业的组织之间，只要他们愿意合作。严重依赖软件工具的数据科学被开源文化所渗透。如今，将自己的发现作为可重复使用的软件包发布是很常见的；有关材料科学的示例，请参见[PYMKS]，它提供了微结构计算、结果可视化等功能。

还有人呼吁广泛共享数据集:数据是建立更好的机器学习模型的燃料。它可以有多种形式:测量、实验、数值模拟……或者模型本身。当然，广泛的数据共享，虽然是非常可取的，但在实践中是困难的。知识产权、缺乏元数据协议都是明显的障碍。另一个是承认这样一个事实，即数据存储库应该带有计算网格、软件和元数据目录——与许多利益相关者一起构建数据平台确实是一个复杂的项目。【素材】和【PYKMS】至少在呼吁这样一个平台。

结论

本文试图从数据科学家的角度总结数据和自然科学之间卓有成效的合作的各种因素。正如我们已经评论过的作者所指出的，来自两个世界的组织和个人对合作有着强烈的兴趣。为了科学发现的利益，他们将建立高效且物理一致的数据科学模型，以适应更广泛的科学工作流程。引用【MLPHYS】，“在为每个应用选择合适的 ML 方法时，平衡数据生成的计算成本、模型训练的便利性和模型评估时间仍然是一个重要的考虑因素。”

以下参考资料更详细地涵盖了这些方面。他们还提供了大量具体的例子来理解所概述的各种方法的实用性。对于好奇的读者，[MLPHYS]还追溯了统计物理学对机器学习算法理论基础的影响——统计物理学的几个概念工具被移植到数学中，给出了新的直觉，并允许超越机器学习的纯粹经验有效性。

我们只是触及了理论和数据科学如何协同工作的表面。合作的许多方面还有待更详细的探讨。例如，我们希望建立一个系统的方法，将数据科学与数学模型(PDEs，模拟)结合起来。另一个高度感兴趣的话题是在我们回顾的文献中一种特殊的算法所起的重要作用:人工神经网络。如何在他们的设计中融入知识？

承认

我要感谢 Annabelle Blangero 和 Rémy Frenoy 对这篇文章的深思熟虑的评论。

参考

c-w . Chang 和 N. T. Dinh，“数据驱动的热流体模型的机器学习框架分类”，国际热科学杂志，第 135 卷，第 559-579 页，2019 年 1 月。

【不变性】J. Ling，R. Jones，J. Templeton，“具有不变性的系统的机器学习策略”，《计算物理学报》，第 318 卷，第 22–35 页，2016 年 8 月。

【材料】J. Hill，G. Mulholland，K. Persson，R. Seshadri，C. Wolverton，B. Meredig，“大规模数据和信息学的材料科学:开启新机遇”，MRS Bulletin，第 41 卷，第 05 期，第 399–409 页，2016 年 5 月。

【ml phys】g . Carleo等，arXiv:1903.10563【astro-ph，物理学:cond-mat，物理学:hep-th，物理学:physics，物理学:quant-ph】，2019 年 3 月。

[PYMKS] D. B. Brough、D. Wheeler 和 S. R. Kalidindi，“Python 中的材料知识系统——加速开发分级材料的数据科学框架”，《材料与制造创新集成》，第 6 卷第 1 期，第 36–53 页，2017 年 3 月。

[TGDS] A. Karpatne 等，“理论指导的数据科学:从数据中进行科学发现的新范式”，IEEE 知识与数据工程汇刊，第 29 卷，第 10 期，第 2318–2331 页，2017 年 10 月。

面向数据科学家的 Web 应用程序开发

原文：https://towardsdatascience.com/web-app-development-for-data-scientists-48e445e54d7b?source=collection_archive---------15-----------------------

数据科学冲刺

两周搭建全栈数据科学项目学习自然语言处理，Flask 和 ML 模型部署！

The end product that we’ll be building in this article

我知道你们中的一些人可能在想:为什么一个数据科学家应该关心构建一个 web 应用程序？这个问题的答案非常简单:虽然分析数据集、发现模式和构建模型都是数据科学家的重要技能，但交流思想和为模型构建交互层同样重要。如果你正在考虑制造一个面向消费者的产品，或者甚至开始你自己的生意，这可能是特别重要的。

唯一比优秀的数据科学家更有价值的人，是同时了解工程和部署的优秀数据科学家。

我这个项目的目标是建立一个基本的情感分析机器学习模型+web 应用程序，并在两周内部署它，以学习三种新技术——自然语言处理(NLP)、flask 和增量/持续学习。在本文中，我将介绍如何构建 flask web 应用程序来帮助用户与情感分析模型进行交互。你可以使用你自己的模型，或者随意利用这个库来找一个我之前建的。我这篇文章的所有代码都可以在我的Github上找到，所以请随意跟随。

2 分钟内完成网络应用复习！

Web 应用程序可以像您希望的那样简单或复杂。尽管复杂应用程序的架构可能会让最优秀的开发人员感到困惑，但简单的 web 应用程序并不复杂。简而言之，它包括以下几个部分:

Basic Web application layout

1. HTML 页面:这些是你的用户可以与之交互的不同网页。许多简单的应用程序利用一个单一的网页，因此命名为单页应用程序(SPA)。
2. 层叠样式表(CSS) : CSS 是一种样式表语言，用于改变 HTML 页面的外观。从文本颜色到背景的一切都用 CSS 描述。
3. JavaScript:这是一种面向对象的编程语言，已经占领了 web 开发社区。Javascript 主要用于在网页上引入复杂的功能，如交互性、请求处理等。
4. web 服务器:这是 Web 应用程序中最令人困惑的部分。web 服务器可以由硬件和/或软件组成，其工作是向用户“提供”资源。因此，当用户想要查看网页时，浏览器通过 HTTP 向 web 服务器请求资源并接收响应。对于我们的项目，我们将使用 flask 服务器进行开发。

现在你已经知道了 web 应用程序的不同部分，让我向你介绍一下 Flask，它将是我们将要使用的 web 应用程序框架。

假人用烧瓶

Flask 是一个轻量级的非常通用的 web 应用程序框架。它在构建时考虑了灵活性和速度，这使得它非常适合几乎没有后端需求的小型应用程序。让 Flask 成为数据科学家工具箱中特别有用的工具的是，它是用 Python 构建的；许多数据科学家对此已经驾轻就熟。那么 Flask 是做什么的？

Flask 负责 web 应用程序中涉及的大量环境和项目设置。这实质上意味着，作为开发人员，您可以专注于您的应用程序，而 Flask 则负责 HTTP、路由、资产等。我保证，随着本文的深入，所有这些都会变得更容易理解。

我们的烧瓶应用程序将由以下部分组成:

Flask app layout; notice how the components mentioned in the basic web app section fall into place here

根据上面的图表，您可以清楚地看到我们的应用程序的不同功能部分。app.py文件将作为主服务器逻辑，帮助服务文件和运行任何需要的 ML 逻辑。static文件夹将包含我们的应用程序所需的任何资产，从图像到我们挑选的模型。最后，template文件夹将包含我们应用程序中使用的单个 HTML 网页。

既然你已经知道了 web 应用程序的组成以及我们为什么要使用 flask，那么让我们来谈谈我们将如何实现这一切。

开发生命周期

在这个项目中，我试着遵循以下思维模式:

我想以一种快速构建/学习的模式来完成这一切，重点是功能性，而不是美观性。

鉴于此，我想分享一下我所遵循的应用程序开发生命周期。这将帮助你理解如何将功能看得比其他任何东西都重要，并快速构建原型。

Development Life Cycle used for this project

正如你所看到的，主要的功能将被反复构建。这将帮助我们在不断添加功能的同时，始终拥有一个可用的应用程序。我们将在需求收集阶段概述应用程序中所需的特性。然后，我们将为整个应用程序设计 UI/UX，以避免在开发后期担心美观问题。之后，我们将优先考虑功能，并在 24 小时内完成。最后，我将把这个应用程序部署到一个 AWS EC2 实例中，这将在另一篇文章中全面介绍。我们开始吧！

需求收集

我们的项目涉及用户与机器学习模型的交互，所以我们必须真正理解这些交互将如何发生。我们有一个 NLP 分类器，它可以预测用户对某个主题的感受是积极还是消极。因此，我们需要一个输入字段，用户可以在这里输入评论/想法和一个输出位置，预测将在这里显示。此外，我们还构建了一个功能来增量训练我们的模型。所以，我们需要为用户提供一种提供反馈的方式(正确/不正确的预测)。这些都是我们基本应用程序中的交互。

考虑到我们的应用程序的简单性，将其构建为单页面应用程序是有意义的。因此，我们 it 的另一个要求是输入、输出和反馈功能都需要在同一个页面。这将有助于保持我们的项目精简和最小化，并减少开发时间。

UI 设计

我喜欢在写任何代码之前在一张纸上画出 UI 设计，因为我们可以更快地做出改变，修补整个部分，并为快速构建提供具体的设计。此外，我还认为，在不同的屏幕上使用不同的功能，有助于将所有内容整合到一个页面应用程序(SPA)中，而不会遗漏任何部分。我的 UI/UX 设计进展可以在这里看到。

Design #1

我从三个不同的屏幕(设计#1)开始，每个屏幕都有自己的功能。第一个屏幕是用户可以输入信息并点击预测的地方。第二种情况是用户可以看到输出，并可以选择将其标记为正确或不正确的预测。最后，最后一个屏幕将是一个确认屏幕，这样用户就知道他的反馈被采纳了，并可以选择重新开始。

Design #2

这三个屏风是我的第一个水疗设计(设计#2)的模型。这是一个带有占位符的静态设计，其中各个部分(输出、反馈按钮等。)会在需要时变得活跃。我认为它是活跃的，因为没有一个元素会在任何时候隐藏；他们总是可见的。

Design #3 (Final)

我的最终设计是静态 SPA 的动态版本(设计#3)，其中输出和反馈元素最初是隐藏的(左侧屏幕)，然后在用户单击预测按钮时出现(右侧屏幕)。我对这个设计非常满意，并且很乐意在这一点上继续进行实际的开发。

迭代开发

在开始开发之前，我为完成这个项目所需的特性创建了一个优先级队列。它们可以在下面(按顺序)看到:

1. 为整个应用程序构建静态用户界面(普通的 HTML+CSS)
2. 捕捉用户的输入，通过我们的模型运行它，并提出一个预测，显示在前端
3. 获取用户反馈，并使用之前构建的增量学习功能适当地教授模型
4. 将 UI 从静态改为动态:在启动时隐藏不必要的元素，并在需要时显示它们

在每次迭代结束时，我将拥有一个功能有限的工作应用程序。这将有助于快速测试和调试新功能。让我来分享一下我的代码和每个特性的进展。

迭代 1:静态用户界面

构建一个静态用户界面相当简单。如果你以前从未为网络开发过，我强烈推荐你查看 MDN 网络文档来解决你的所有问题。鉴于我们的应用程序的简单性，我们的 HTML 代码是最少的，虽然我不想浪费您的时间来深入描述这一点，但我将从高层次来介绍它。我们的 UI 被分成两个主要的<div>标签:一个用于包含指令、输入文本框和预测按钮的上半部分，另一个用于包含预测输出和反馈按钮的下半部分。与这个项目相关的大多数 HTML 对于以前做过 web 开发的人来说应该是有意义的，但是我想指出一个重要的 flask 特定代码:

<form id="input-form" class="input-form" 
   action="**{{ url_for('predict')}}**" method="post">
     ..
     ..
     ..
</form>

表单标签中的{{url_for(‘predict’)}}属性是一个指向“预测”路线的 flask 方法。这个关联帮助我们从表单中捕获用户输入，并在我们的模型可用的app.py文件中处理它。当我们在下一节介绍 flask 时，您将看到这一点。

最后，为了设计这个 HTML 页面，我主要使用 CSS 的 flexbox 显示模式来创建一个最小的布局。因此，尽管还没有任何按钮起作用，图像也没有改变，但我在这次迭代结束时的静态布局如下所示:

Static UI after iteration 1. None of the buttons work yet 😃

鉴于读者的兴趣，我不会在本文中涉及 CSS，但是如果你感兴趣，你可以在这里找到我所有的代码。

迭代 2:捕获输入并在前端显示预测

在上一节的最后，我们只有一个 HTML 和 CSS 文件。现在，我们将开始使用app.py文件来构建我们的应用程序的逻辑，并且从直接显示 HTML 页面转移到使用 Flask 服务器来服务它。要开始使用 Flask 服务 HTML 页面，我们只需要几行代码:

from flask import Flask, render_template, requestapp = Flask(__name__, template_folder='../templates', static_folder='../static')@app.route('/')
def home():
    return render_template('index.html', image_filename="img/happy.webp", display_mode="none")@app.route('/predict', methods=['POST'])
def predict():
    return render_template('index.html', image_filename="img/happy.webp", display_mode="none")@app.route('/save_pred', methods=['POST'])
def save_pred():
    return render_template('index.html', image_filename="img/happy.webp", display_mode="none")if __name__ == "__main__":
    app.run(debug=True)

注意:Flask 不要求显式地提到 template_folder 和 static_folder，但是我喜欢这样做，以防我弄乱了名称/路径。此外，此时，我们的项目文件夹结构应该如下所示:

Project folder structure

这样，我们所有的资产(图像、模型等。)在同一个主文件夹static的不同子文件夹中，我们的 HTML 页面在templates文件夹中，我们的app.py文件在python文件夹中。

此时，我们已经准备好使用 Flask 服务器运行我们的应用程序。为此:使用命令行导航到 python 文件夹，并运行命令python app.py。请记住，此时您应该已经使用 pip 安装了 Flask。更多关于那个的信息在这里。恭喜，您的应用程序已经启动并运行了！现在让我们添加预测逻辑。

注意我们是如何为predict和save_pred路线放置占位符的。这样做是为了确保 Flask 应用程序部署无误。为了让我们的 predict 函数工作，我们需要从 textbox 中捕获用户的输入，使用我们的 NLP 矢量器(input_transformer.pkl)将它转换成一个单词袋矢量，并通过我们的分类器(review_sentiment.pkl)运行它。还要注意，我将使用全局变量来存储模型输入和输出，以便在预测和增量学习函数中保持它们。此功能的代码如下所示:

# module needed to load models
from sklearn.externals import joblib# load models pickeled earlier
input_transformer = joblib.load(open('../static/models/input_transformer.pkl', 'rb'))
model = joblib.load(open('../static/models/review_sentiment.pkl', 'rb'))# Global variables for persistence across methods (and requests)
model_input=""
model_output=""@app.route('/predict', methods=['POST'])
def predict(): # retrieve global variables to store input and output
    global model_input
    global model_output

    # get text from the incoming request (submitted on predict button click)
    text = request.form['input_text']

    # convert text to model input vector
    final_features = input_transformer.transform([text])

    # use classifier's predict method to get prediction
    prediction = model.predict(final_features)

    # store model input and output
    model_input = text
    model_output = prediction[0] return model_output

你有它！现在，我们的应用程序可以将用户输入的文本转换成向量，可以通过我们预先训练的模型进行分类。

迭代 3:增量学习

我们采取的步骤如下:使用全局变量对输入文本进行矢量化，获得用户点击的按钮(正确/不正确)，基于用户的按钮选择断言“正确”预测，递增地训练模型直到它重新学习，更新模型 pickle。这方面的代码如下所示:

[@app](http://twitter.com/app).route('/save_pred', methods=['POST'])
def save_pred():
    # retrieve global variables
    global model_input
    global model_output # vectorize user input
    final_features = input_transformer.transform([model_input])

    # get user's button choice (correct/incorrect)
    save_type = request.form["save_type"]

    # modify global variable if user selected "incorrect"
    if(save_type == 'incorrect'):
        if(model_output == 'p'):
            model_output = 'n'
        elif(model_output == 'n'):
            model_output = 'p'
        else:
            print("Error: Model output was neither N nor P") # Strengthen weight of particular connection
    max_iter = 100
    counter = 0
    for i in range (0,max_iter):
        model.partial_fit(final_features, [model_output])
        if(model.predict(final_features) == [model_output]):
            counter = i
            break

    # Save trained model pickle
    joblib.dump(model, '../../review_sentiment.pkl')    # return placeholder (will be updated later)
    return ""

虽然上面的代码实现了我们需要的所有功能，但是一旦重新训练完成，它没有向用户提供任何类型的反馈。为了解决这个问题，我们将添加一个返回文本变量来返回"权重已更改，谢谢您的指正！"或"砝码被强化，谢谢你教我！“根据情况。此外，我还认为捕获模型被重新训练的数据以防止误用该功能是非常重要的。几行代码可以帮助我们将输入、校正后的输出以及重新训练所需的周期数存储在 csv 文件中:

fields = [model_input, model_output, counter]
    with open('user_teaching_data.csv', 'a') as file:
        writer = csv.writer(file)
        writer.writerow(fields)

迭代 4:动态内容

随着我们的静态应用程序的完成，这次迭代的目的是让它变得动态和更加用户友好。你一定注意到了，所有的元素在我们的应用程序中都是可见的，而且页面每次都会重新加载。虽然这没什么大不了的，但是我们可以很容易地使用 jQuery 和 AJAX 来避免重载，并根据需要隐藏元素。这将有助于给我们的应用程序一个完美的外观，也有助于积极的用户体验。深入研究 jQuery 或 Ajax 超出了本文的范围，但是如果您感兴趣，我强烈建议您查看我的 代码 ，以及这篇关于 AJAX 的精彩文章。

在这次迭代结束时，我们的应用程序按预期工作:它接受用户信息，显示我们的 NLP 模型的结果，允许用户重新训练我们的模型，并以最简单优雅的方式完成所有这些工作。我们的全功能 web 应用程序演示可以在下面再次看到:

Final working demo for web application

恭喜我们的两周挑战进行到这一步！希望到目前为止，您不仅能够构建 NLP 模型，还具备了构建 web 应用程序以使这些模型具有交互性的必要技能。

包裹

到目前为止，我们已经完成了许多很酷的事情:我们采用了以前训练过的数据科学模型，并围绕它构建了一个功能齐全的 web 应用程序。我们花了大约六天的时间来构建我们的 web 应用程序，把重点放在功能而不是美观上。这种心态让我们能够在大约 10 天内构建我们的模型和 web 应用程序。

两周的时间还剩四天，我们将解决我们最大的挑战:使用普通 EC2 实例在 AWS 上进行建模和应用程序部署。我将写另一篇帖子来指导您完成部署过程，所以请随时关注我的专栏《走向数据科学》以获得发布时的通知！

我希望你喜欢读这篇文章，就像我喜欢把它放在一起一样。如果您有任何问题、反馈或意见，请随时通过 LinkedIn 或我的网站与我联系。

朱莉娅的网络应用:你需要知道的。

原文：https://towardsdatascience.com/web-apps-for-julia-what-you-need-to-know-68b8874dfa2b?source=collection_archive---------24-----------------------

随着 Python web 后端在 2019 年几乎超过 PHP，以及我们每天依赖的大多数数据驱动的应用程序都是由 Flask 和 Django 中基于机器学习的 web 框架驱动的，很容易看到用传统的低级语言运行 web 后端的优势。众所周知，Python 可以以 Django 和 Flask 的形式提供什么，但是我们还可以使用什么工具来构建其他语言的 web 应用程序呢？在朱莉娅的例子中，我们有一种叫做精灵的东西。

Genie 是一个强大的 web 框架，供 Julia 用于数据驱动的应用程序。但是，这个新平台确实有其合理的警告和问题，这就是我今天想要阐明的。

精灵是强大的。

与 Flask 不同，但更类似于 Django，Genie 的主要构建界面之一实际上是命令行。我认为这是相对于 Flask 的一个巨大优势，因为您可以启动并运行一个基线项目，而无需首先花费时间来路由目录。

然而，随之而来的是一个缺点，那就是框架应用程序的创建对于 Julia 的精灵来说并不总是那么好。也就是说，有时需要敏捷的计算，使用 Python 通过一个非常小的漏斗推送大量数据可能是一项优化工作，而且效率低下。Python 中的大型数据表在 Python 内部访问和读取的时间通常要长得多。虽然通常 Job-libing 可以获得明显更好的响应时间，但虚拟专用服务器一次只能实例化一个命令，这使得典型的 Python 执行对于一些应用程序来说绝对缓慢。

Genie 最大的优势大概是内置在 Julia。这使得它成为非常复杂问题的非常优雅和快速的解决方案。

软件包管理器

与 Flask 或 Django 相比，我认为 Julia 的 Genie 最大的问题是 Pkg 不一定适合这种任务。也就是说，Julia 的启动时间确实更快。这个问题是在部署管道时产生的，例如，我在本文中部署的管道。

Julia 的 Pkg 绝对没问题，如果你使用一个真正的 VPS，一个你连接到远程运行 Linux 的终端，比如说 Debian，我们只要用我们选择的方法(SSH)连接，然后安装 Julia:

sudo su
apt-get install julia

请注意，我是以 root 用户身份安装的，而不是以登录身份。当我使用用户而不是根用户进行初始安装时，我遇到了一些部署问题。无论如何，如果你在一个容器中或者运行一个 VM 镜像，这应该不是一个问题。现在大概是这样的:使用 Pkg 从我们服务器上的终端安装我们的包绝对没问题，这很棒。然而，当我们开始使用没有 SSH 的 VPS 容器部署时，例如 Heroku，我们的问题就来了。

当然，Heroku 并不是完全按照 Julia 的想法设计的，也有过这样的情况，我的应用程序只需要重新部署就可以修复了。话虽如此，这是可能的，但对我个人来说，我发现这是非常费力的。幸运的是，现在我已经完成了创建文件系统的过程，并决定建立一个框架库，这样您就可以简单地放入您的应用程序，并放入您的 UUIDs。因此，对于任何项目，您都可以从骨架的克隆开始，并从那里构建您的应用程序。

安装费用

此外，我想指出的是，首先在我的电脑上安装 Genie 非常烦人。项目清单文件中的 DEPS 缺少依赖项，其中很多只是试图导入 Genie，看看它缺少什么，然后安装它…此外，应该注意的是，其中一些包不是当前版本，而是旧版本，因此您很可能希望创建一个 docker 容器，以便专门为所述 Genie 项目存储您的包。您还可以将 Playground.jl 与

Pkg.add("Playground")

对于 Python 的等价类来说是 Pipenv/VirtualEnv。虽然可能不会有显著的惊喜，但它肯定是值得注意的，我会将安装过程描述为有点乏味，但当您让它工作时，是非常值得的。

结论

尽管 Genie 的学习曲线很难，继承了其他应用程序的不同，但它确实是一个强大的工具。如果我不得不把它归为一类，这是 Flask 和 Django 的奇怪组合，你可以以两倍的速度获得两个世界的最佳效果。有时我可能会更深入一点，在框架内部安装和构建一个 web 应用程序。我对 Julia 语言的前沿感到非常兴奋，尽管在我看来，对它的支持还没有达到 。

网页抓取 101

原文：https://towardsdatascience.com/web-scraping-101-969499c2d706?source=collection_archive---------15-----------------------

Photo by Pankaj Patel on Unsplash

使用 Python 从您最喜欢的网站快速抓取数据

总有一些数据科学工具，我每隔几周就会使用一次——虽然不够频繁，还不足以让它们成为我的第二天性，但足够频繁，以至于当我发现自己第无数次谷歌它时，我会感到恼火。网络抓取就是一个例子，所以今天的博客对我未来的自己和对你一样重要。

网络抓取对于初露头角的数据科学家来说是一项非常有用的技能。当我们试图分析一些东西时，我们经常需要用我们在网上找到的额外数据来补充我们现有的数据。网络抓取使我们能够自动化这个数据收集过程。

在今天的帖子中，我们将使用 Python 来抓取一个网站，以便了解网页抓取的来龙去脉。

刮的时间到了

我们将从网站https://toppubs.smedian.com/获取排名前 100 的媒体出版物的数据。完整的代码，你可以去我的 Github。

首先，我们需要导入我们将需要的包。除了通常的，我们将利用 BeautifulSoup 和 requests Python 包来帮助我们获取和解析网站的数据(我还加入了 re 包，以防我需要使用正则表达式)。

# For our general needs
import numpy as np
import pandas as pd# For getting and parsing the data from the website
from bs4 import BeautifulSoup
import requests
import re

• Python 包请求，允许我们的程序连接到网站并提取其数据(以非常原始的格式)。
• BeautifulSoup 是一个处理网页数据的重要软件包。它以一种更像列表的方式重组数据，这样我们就可以用我们的代码操纵它。

现在让我们从网站上抓取数据。我们使用来自请求包的 get 方法来 ping 网站并获取其数据。然后使用 BeautifulSoup 以更加用户友好的格式构建它，以便我们可以开始使用它:

link = '[https://toppubs.smedian.com/'](https://toppubs.smedian.com/')# Grab data from website
page_response = requests.get(link, timeout=1000)# Structure the raw data so that we can parse it
page_content = BeautifulSoup(page_response.content)

下面是 page_response.content 的前几行(很乱吧？):

The raw website data is a mess

在我们通过 BeautifulSoup 运行它之后，它看起来是这样的(更有条理一点):

A bit more structure thanks to BeautifulSoup

仍然有很多东西需要理解，但是现在看起来更容易解析了。现在让我们来看看实际的网站，找到我们感兴趣的刮。这是网站的快照:

The website we are scraping

前 100 家媒体出版物的表格(上图的下半部分)包含了我们感兴趣的数据。我们可以通过检查页面的源代码来找出数据所在的位置。为此，只需将鼠标悬停在您感兴趣的页面部分，右键单击，然后选择“Inspect”。

Inspecting the source code

这将打开一个侧窗格，允许您查看页面的源代码。例如，如果我们对收集订阅者的数量感兴趣，我们检查 603，567 个订阅者(在左边用蓝色突出显示)。这打开了右边的窗格，在这里我们可以看到，为了获得订阅者的数量，我们应该在我们的 BeautifulSoup 对象中寻找标签(这是一个 HTML 标签，我对 HTML 知之甚少，所以请原谅缺乏解释)。回想一下，我们的 BeautifulSoup 对象是变量 page_content 。

在表格中循环

该表中有 100 行(它毕竟列出了前 100 个出版物)。所以我们应该用一个循环来遍历它。但是我们通过什么循环呢？如果我们检查整行，我们会看到每一行都用 HTML 标签

表示。

Inspecting a row of the table that we want to scrape

所以我们的循环应该找到每个标签，然后获取内容。我们可以使用 find_all 方法来做到这一点——我们使用它来查找 page_content 中 tag = 'div '和 class = 'row '的所有元素。 find_all 方法返回一个我们可以遍历的列表:

pub_names = []
pub_subs = []# Loop through each row
for row in page_content.find_all('div', class_='row')[1:]: # Contains the name of the publication
    pub = row.find_all('a', class_='link link--primary u-  accentColor--hoverTextNormal ng-binding') # Contains number of subscribers
    detail = row.find_all('a', class_='link u-colorLightGrey u-fontWeight400 u-fontSize12px ng-binding') if pub != []:
        pub_names.append(pub[0].text.split('\n')[1])
        pub_subs.append(detail[0].text.split('\n')[1])

首先，让我们打开行的变量，看看里面有什么。挺密的。我们可能需要使用 find_all 方法来进一步过滤。

The row variable from our loop

抓取出版物的名称

在 pub 变量中(来自上面的 for 循环代码),我们获取了出版物的名称。我们知道数据存在于行变量的某个地方，但是在哪里呢？为了找到它，我们可以再次检查网页。我检查了页面上用蓝色突出显示的部分，它告诉我寻找标签‘a’和类‘link u-color light grey u-font weight 400 u-font size 12 px ng-binding’。挺拗口的！

Inspect the name of the publication

一旦我们知道要查找什么，我们就可以使用 find_all 方法来定位它(这是上面 for 循环中的同一行代码):

pub = row.find_all('a', class_='link link--primary u-  accentColor--hoverTextNormal ng-binding')

让我们来看看 pub 变量里面有什么:

[<a class="link link--primary u-accentColor--hoverTextNormal ng-binding" href="https://medium.com/free-code-camp" ng-href="http://medium.com/free-code-camp" style="display:inline" title="Go to freeCodeCamp.org's Community Page">
 freeCodeCamp.org
 </a>]

现在我们正在谈话！在 pub 中，我们看到“freeCodeCamp.org”，这是该出版物的名称。我们现在要做的就是解析 pub 并获取我们想要的东西。我们可以使用方法文本来实现:

pub[0].text

这会产生以下输出:

Out: '\nfreeCodeCamp.org\n'

如此接近，我们只需要去掉换行符。我们可以用串的方法拆分来做到这一点:

pub[0].text.split('\n')

换行符上的拆分产生以下输出:

Out: ['', 'freeCodeCamp.org', '']

出版物的名称是这个列表的第二个元素，所以我们抓住它，准备好了:

pub[0].text.split('\n')[1]

获取该出版物的订户数量

让我们快速地再看一个例子，以确保我们理解了网络抓取的来龙去脉。既然我们已经知道了出版物的名称，我们还想知道有多少读者订阅了它。前面，我们已经发现了数据在页面源代码中的位置:

Same picture as above

如果我们拿出放大镜阅读源代码，我们会看到我们正在寻找标记为“a”的元素，并且类等于“link u-colorLightGrey u-font weight 400 u-font size 12 px ng-binding”。如果我们回头参考上面的 for 循环代码，我们会发现我们使用了 find_all 方法来获取相关元素，并将其存储在变量 detail 中。

detail = row.find_all('a', class_='link u-colorLightGrey u-fontWeight400 u-fontSize12px ng-binding')

如果我们显示它，我们会看到细节变量是一个有 5 个元素的列表。第一个元素包含订户数量， detail[0] 如下所示:

Out: <a class="link u-colorLightGrey u-fontWeight400 u-fontSize12px ng-binding" href="https://www.smedian.com/p/592ba7975fbc457423b1af2b" ng-href="https://www.smedian.com/p/592ba7975fbc457423b1af2b" target="_blank" title="Go to freeCodeCamp.org's Community Page">
603,567
Subscribers
</a>

值 603，567 是我们想要的，所以让我们用下面的代码行获取它:

detail[0].text.split('\n')

它产生以下输出:

Out: ['', '603,567', 'Subscribers', '']

酷，现在我们要做的就是抓住第二个元素:

detail[0].text.split('\n')[1]

在我们对它进行任何分析之前，我们需要将其转换为整数(通过删除逗号，然后将其转换为整数):

int(detail[0].text.split('\n')[1].replace(',',''))

如果我们在我的 GitHub 中运行全部代码，它会产生以下数据帧:

The output dataframe, ready for analysis

好啊，都搞定了。希望这篇教程风格的博客是有用的。干杯！

更多数据科学与商业相关岗位由我:

了解 RNNs

数据科学家的商业战略

有项目还是没有项目？

用 Python 进行业务模拟

了解 PCA

理解贝叶斯定理

网络抓取:Scrapy 和 Selenium 的一个不太简要的概述，第二部分

原文：https://towardsdatascience.com/web-scraping-a-less-brief-overview-of-scrapy-and-selenium-part-ii-3ad290ce7ba1?source=collection_archive---------3-----------------------

by Tom Gowanlock

Scrapy + Selenium 来抓取 Airbnb(包含 Python 代码)

“网络爬行的第一条规则是你不能损害网站。网络爬行的第二条规则是你不要伤害网站。

在我之前的博客文章中(链接此处，我给出了使用 Scrapy 和 Selenium 进行网页抓取的概述。我关注的是我用这些工具制作我的第一批刮刀的学习成果。我还没有在网上找到很多如何将 Scrapy 和 Selenium 结合起来的例子，所以如果你正在寻找这样的东西，请继续阅读——我试图让这篇文章尽可能具有说明性。我选择继续使用 Airbnb，这是我在《T4》第一部中提到的，这让我很惊讶，我在本博客的最后一部分中谈到了这一点。

这篇博文的内容如下:几个免责声明，一个第一部分的摘要，对 Scrapy 和 Selenium 的简要描述，一个对作为目标网站的 Airbnb 的描述，一个带有我这边评论的逐步刮刀，以及一个非常简短的最终注释。

我们走吧！

这个帖子是什么

简单说说这个帖子是什么，不是什么。

放弃

免责声明#1 :我花了一段时间才发表这篇文章，因为我被其他项目缠住了。我花了几个星期的时间断断续续地研究它，并注意到 Airbnb 对它们的源代码进行了修改。因此，如果你过一段时间发现这个帖子，很可能他们那边的事情不会保持不变。出于这个原因，我附上了截图和 gif，所以即使源代码被更改，整个过程也更有意义。

免责声明#2 : Airbnb 是一个特殊的目标，因为网站的布局可能会根据会话而改变。起初，我认为这种行为是由他们识别机器人引起的，但后来，当我作为普通用户试图从多台机器和网络访问它时，我遇到了同样的问题——布局会根据会话随机变化。在这篇文章中，我将介绍类似这样的无限卷轴布局:

Infinite scroll layout that is in the focus of this post

要在此设置中加载新属性，您需要向下滚动到页面底部，直到加载完所有项目。反过来，每个项目都有一个图片来源，一个简短的描述，包括物业类型，物业名称，每晚价格，评级，评论数量，还有一些我们不能马上看到，但仍然存在的东西，就是连接目录项目及其简介的 URL 。

与目录相反，无论目录视图如何，房屋的配置文件似乎不会改变太多。然而，说过去几周没有任何变化是错误的。例如，现在有一个特殊的“加”房屋布局，它会出现在目录中。我将在代码中跳过这些，但是您当然也可以创建规则来处理这些配置文件。

“Plus” Homes That Are Out of This Blog Post

免责声明#3 :这篇文章是一个概念证明，而不是防弹刮刀，请随意调整，并分享对你有用的改进。

P 艺术一总结

Scrapy 是一个 Python 框架，允许你抓取 HTML 页面。虽然它快速、高效且易于使用，但它不允许您抓取更多使用 React 等框架的 JavaScript 网站，或者只是识别爬虫并禁止它们的网站。

另一方面，Selenium 是一个自动化测试的工具，它不是为抓取而开发的，但是，它可能有助于抓取 Scrapy 无法做到的网站。在模拟浏览器时(Selenium 实际上是用 webdriver 打开浏览器的)，你可以编写爬虫来模拟用户的所有点击、滚动和暂停行为。除此之外，你还可以进行截图等操作。虽然很酷，但硒需要一点时间。

总而言之，Scrapy 在处理错误和异常方面更快、更健壮，Selenium 在前端模拟用户操作，这对于以抓取工具为目标或有很多反应元素的网站来说是一个巨大的优势。因此，将两者合并在一起是一个可以考虑的选择。

Airbnb: Scrapy 和 Selenium

目标 Airbnb 的样子

对于这篇文章，我选择了删除 Airbnb，因为一些论坛建议，Airbnb 需要一点努力。还有，我在第一部分开始写了，所以觉得坚持下去会很好。

假设我们要提取某个位置的属性的以下细节:
1。属性类型
2。物业名称
3。每晚价格
4。评级
5。链接到酒店简介
6。也许还有一些评论

您可以在这些属性的目录页面或个人资料页面中找到这些详细信息。

我更愿意做的第一件事是熟悉网站。其中一个有用的 Chrome 工具是 React 元素检测器 ，当页面上检测到 React 时，它会变成蓝色。

airbnb.ae — React enabled!

当你点击扩展时，你会在页面上看到大量的蓝色——所有的东西都是框架的一部分——Scrapy 不会单独处理它！你注意到的另一个需要硒或类似元素的东西是臭名昭著的无限卷轴。

The Blue and Infinite Airbnb

SPID er 逻辑

scraper 的逻辑模拟用户在网站上采取的行动，从主屏幕开始进行搜索(为简单起见，我们称之为自顶向下)，然后抓取内容(比如目录页面或属性页面)。同时，您可以选择从下到上开始构建您的爬虫，看看您是否收集了任何数据并发现了任何问题。

虽然通过开始抓取目标页面(如目录页面)来检查您是否在正确的轨道上是有用的，但一些网站，如 Airbnb，会在您的请求中寻找特定信息，如果发现可疑活动，他们会禁止您，修改他们显示的 web 元素，甚至改变页面的内容。

T

由于 Scrapy 既好又快，我确实尝试单独使用 Scrapy，所以让我们做一个小实验:我们将尝试仅使用 Scrapy 获得一些响应。您可以使用 pip 安装所需的模块。安装完模块后，我们可以用scrapy startproject projectname启动项目，这将在您的工作目录中创建一个“projectname”文件夹。接下来，您可以通过将目录更改为您的项目文件夹cd projectname和scrapy genspider nameofthespider来在文件夹中生成默认的蜘蛛，这将在您的项目中创建一个默认的 Scrapy crawler 架构。提示:在命令行中调用scrapy会给你显示基本的 scrapy 命令，下面会用到一些，看看吧！

Install Packages

除了安装模块，我们还需要下载 chromedriver ，解压并在机器上安装谷歌 Chrome，如果还没有的话。Chromedriver 并不是你唯一可以使用的 webdriver，比如 Firefox 是相当流行的，但是在这篇文章中我将只讨论 Chrome。

Scrapy Architecture in a File Directory

需要注意的是，在这个树中，蜘蛛“根目录”是scrapy.cfg所在的位置，所以每当我们想要启动爬虫时，工作目录应该是scrapy.cfg所在的位置。接下来，settings.py——蜘蛛的设置——和homes.py——蜘蛛的脚本——将是这篇文章的重点。

现在，我们可以看看是否可以使用 Scrapy 从目录页面获取任何信息。让我们先来看一下 scrapy shell ，这是 scrapy 的一个命令行。这便于测试碎片代码，即查看选择器是否返回任何特定的结果。[scrapy shell 'URL'](https://docs.scrapy.org/en/latest/topics/shell.html)就是要走的路。输出包含日志、零碎的汇总统计数据，最后是一个零碎的 shell，类似于 ipython shell。

scrapy shell ‘url’

你也可以在 bash 中直接尝试scrapy fetch "url"。结果会更大，有一堆状态和一个 HTML 树，看起来像这样:

scrapy fetch

无论哪种方式，重要的是downloader/response_status_count/200，其中 200 意味着我们成功地接收到了服务器响应。500 和 400 意味着我们的请求被服务器拒绝——要么你太咄咄逼人，要么机器人已被识别和阻止。

现在，让我们把重点放在 scrapy 外壳上。让我们尝试使用不同的 xpath 获取第一个属性名，我们可以通过指向属性名> >右键单击> >检查来找到。有多种方法可以获得相同的元素。比如物业类型(“包间* 1 床”、“整间* 3 床”等。)可以通过使用class="_ng4pvpo"、itemtype="http://schema.org/ListItem"和itemprop="name"以及其他选项进行定位。

One of the xpaths to a Property Name

使用 xpath 测试 Scrapy:

Testing Scrapy’s Response

尽管scrapy fetch产生一个 GET 状态 200，选择器还是返回空白列表。当他们说 scrapy 不能处理 JS 过多的页面时，就是这个意思。当 xpaths 不正确时也可能是这种情况(尝试任何随机的 xpaths)，但是在编写本文时不是这种情况。请注意，这两种情况下都不会产生错误。

使用 Scrapy Selector和 Selenium 的driver.page_source获得相同的元素会返回一个选择器列表:

Chromedriver and Scrapy Selector

要点是:由于 Airbnb 依赖于 JS-heavy React 框架，Scrapy 无法获得所需的 web 元素并从中提取数据。这就是 Selenium 派上用场的地方，它虚拟地向服务器发出请求，同时发送服务器将接受的头，而不会阻塞您的 bot 或扭曲数据。也就是说，真实浏览器标题和 Selenium 标题是有区别的，特别是用户代理，但是我们将在下面处理它。

关于建筑——一些调整

Scrapy 架构由几个部分组成，正如我之前提到的，我将重点关注其中的两个部分。

spider.py

在您调用scrapy genspider nameofthespider之后，该文件的实际名称将是 nameofthespider.py。该文件将包含爬虫要遵循的脚本。

settings.py

Settings.py 是蜘蛛的设置。文档非常全面，如果你有时间的话可以读一读。设置允许你在必要的时候修改爬虫的行为，避免被阻止，更重要的是，不要让网站的服务器超负荷运行，否则会损害它的性能。一般来说，至少调整以下设置是个好主意:1) DEFAULT_REQUEST_HEADERS，它是浏览器发送给 web 服务器的任何请求的一部分(查看 wiki 和这里的一个例子)。2) USER_AGENT，它实际上是头的一部分，但也可以单独设置。3) DOWNLOAD_DELAY，设置对同一网站不同页面的并发请求之间的延迟。这个练习没有必要，但是记住它是个好主意。4) ROBOTSTXT_OBEY，它提供了一个选项来关注或忽略网站上的 robots.txt 文件。Robots.txt 文件存储在网站的根目录中，描述了网站上机器人的期望行为，遵守它被认为是“礼貌的”。

虽然礼貌地收集信息是最好的做法(这里有一篇好文章)，但你不能总是通过遵循完整的建议列表来获得数据，部分原因是一些网站会阻止任何看起来不像浏览器的机器人，例如，当你的请求头与预期的不匹配时。

检查来自 Chrome 的预期请求头:

Airbnb — Checking Network Response

要指出的是，设置标题将是最相关的 Scrapy。Selenium 启动一个浏览器实例，然而，它的标题表明使用了自动化软件，尽管与常规浏览器非常相似。

Scrapy Settings for This Project

一步一步的刮刀

导航:搜索和加载

抓取的支柱是 web 元素选择器。你可以选择使用 css 选择器或 xpath 的，我更喜欢后者，并将在本文中使用它们，这是出于习惯。如果你使用 Google Chrome 或 Firefox，获取 xpath 很容易:转到元素> >右键单击> >选择“Inspect”(就像我们在上面处理属性类型一样)。控制台将会打开，在这里你将会看到所选择的元素和更多的东西，所以如果你没有立即找到你需要的东西，或者如果你在寻找其他东西，你可以在“树”中上下移动。此搜索字段是一个示例:

Airbnb — Search Field xpath

最终，我们希望我们的 scraper 浏览这个页面并进行搜索。现在我们已经了解了如何在页面上找到元素，让我们测试它是如何工作的。为了测试它，我们可以继续使用ipython。

Selenium 的一个很酷的特性是它能够再现用户在网站上的行为，包括填写表单、按按钮、按“Enter”和其他键、截图等。下面的代码片段启动 webdriver，进入 airbnb hime 页面，输入城市名(Dubai)，然后使用h\ue007点击“回车”。接下来，它停了一会儿——sleep(0.8)——并点击搜索按钮，通过type = "submit"找到 xpath 中的元素，并使用click()方法点击它。

然后，当您被重定向到下一页时，脚本暂停 8.7 秒。当它在下一页时，驱动程序将通过 xpath data-veloute="explore-nav-card:/homes搜索按钮“Homes”。

最后一个操作将最终把我们带到目录页面，这是一个无限滚动的页面，我们将使用while语句来滚动它。一旦我们完成了，就该为目录的元素提取选择器了。

Going Through the Search Menu on Airbnb

在导航部分被测试并按预期运行后，我们可以将这部分添加到homes.py文件中，只需稍作修改——每次调用驱动程序实例时，我们都需要在它前面调用self.(Corey 在这里解释了自我的直觉)。对于最后一块，进入 最后一块 部分。

获取数据:产品页面与目录详细信息

一般来说，如果以列表或网格的形式向您呈现一组项目，其中元素存在于相同的 xpath 中(例如，共享相同的类、id、div、等。)并在页面上重复出现，使用 for 循环很容易对它们进行迭代。如果您的元素是页面独有的，您可以直接在页面中找到它们。

回想一下 Airbnb，你可以通过进入目录页面或逐个访问房屋的简介来获得该网站的数据。但是，家庭数据点似乎更容易从家庭配置文件中访问，因为目录中的一些元素没有通用的结构。例如，您可以看到 span 中返回的所有属性类型 标签(在页面中找到的)，同时迭代同一类的元素。有一个模式，但不幸的是，它不断打破，所以你不能依靠它来获得数据。从一个档案到另一个档案确实需要更长的时间，但是如果你需要从物业档案中获取物业类型或任何其他信息，请一个接一个地搜索“房屋”。

获取主页的 URL:目录页面

虽然你当然可以从目录页面抓取 Airbnb，但是有些元素，比如属性类型，很难从那里获取。此外，并不是所有的信息都可以在目录视图中获得，要获得完整的信息需要访问个人资料页面。因此，当加载目录时，我们将获得这些家庭的配置文件 URL。出于本文的目的，我将“plus”房屋排除在等式之外，因此我们将选择常规的 Airbnb 房源。

刮痧:“家”的页面

正如我在介绍中提到的，我注意到 Airbnb 不时改变目录布局，所以除了获得关于一个物业的更多细节，访问每个家庭的页面以获得细节的优势是相对容易地使用 Airbnb 为目录生成的不同布局。

一旦目录页面的 URL 列表出现，有几种方法可以到达产品页面，最简单的两种是:1) Scrapy 的yield Request (url, callback = self.parse_home_page_function, ...)，它在官方文档中有描述或 2) use driver.get('url')，它将直接带你到属性页面。两者各有利弊。Scrapy 的Request的一个巨大优势是它能够并行请求几个 URL(确切的数量可以在蜘蛛的 settings.py 中更改，参见CONCURRENT_REQUESTS)。另一方面，发送并行请求会在一台机器上打开多个窗口，您可能会遇到资源分配问题。如果是你的机器，不管你在做什么，窗户很可能会被扔到你工作的窗户上，所以很难继续下去。第二，Scrapy 的请求有更高的几率被服务器拒绝，特别是当你攻击服务器的时候，或者只是不够频繁。说到 Selenium 的driver.get，它的很慢，速度取决于你的连接，然而，它在一个窗口中打开页面，我从未遇到过它被阻塞的问题。**

基于以上原因，我选择使用driver.get('url')来浏览概要文件。

在主页上，我们可以看到酒店类型、名称、每晚价格、总体评分以及每个类别的分类、摘要以及对住宅和邻近地区的简要描述。我想就此打住，但是我想起了评论部分。提取评论是一个很好的练习，原因有两个:1)评论为进一步的分析提供了有价值的信息，如 NLP 2)与目录相比，评论部分有不同的导航 3)从这个部分提取信息需要我沿着 HTML 树来回移动，直到我到达可以编写评论字典的地方，所以我决定分享关于它的想法。

Airbnb : That’s Gonna Be Scraped

…and This

…and the Ratings

…and This Too

上面强调的每件事都有两个要点。我提供它们就好像它们是原始代码的一部分。如果您想在控制台中试用它们，不要忘记从。第一个就在下面，除了评论之外什么都有:它相当简单，非常类似于检索搜索和目录页面上的选择器。元素中， link_to_home，property_type，property_name，price_night，rating_overall 以字符串形式出现(使用extract_first())； summary，rating_categories，rating_stars，home_neighborhood_short 是列表(顺便使用extract()，输出可子集化)；最后，rating_categories 和 rating_stars 被组织成一个字典， rating_split (带有一个键值对rating _ categories:rating _ stars)。

下面的要点通过点击“下一步”按钮导航评论部分。返回的对象是列表的列表。列表中的每个列表都包含来自单个评论页面的字符串形式的评论。最初，我计划构建一个字典，用 reviewer 和 review date 作为键，用 review 作为值。我把我的实验留在了要点中，以防万一你需要一个基础来开始玩它或者有一个如何实现它的建议。为了这篇文章，我决定放弃它。如果你想在家里试一试，有两个提示:1)房主对评论的响应作为相同的类和目录存储在 HTML 树中，所以对评论的导航应该足够精确以区分这两种情况；2)一些评论是空的，但是评论者的名字在那里，留下没有值的潜在的键-值对。在要点的评论中，第一个问题已经解决，但是你仍然会碰到第二个问题。如果你对如何改进代码有好的想法，非常欢迎。**

在这里，我首先到达该部分以确保它被加载，并获取page_source以确保该部分被捕获。在获得第一个评论页面后，我尝试单击“下一步”按钮(您也可以一个按钮一个按钮地前进)，如果它不可用，

最后一块

这篇文章的这一部分仅仅是将所有的代码连接在一起。这是“蜘蛛”文件夹中 homes.py 文件的内容。有一点不同的是yield，它产生一个字典对象来形成输出。当您以scrapy crawl homes -o output_file_name.json或.csv运行刮刀时，yield 将被传递到输出文件。该文件将存储在您的项目根目录中(与 scrapy.cfg 所在的目录相同)。

在结束语中

Airbnb 有什么不同

在这次 Airbnb 经历中，有两件事发人深省。

**一个，他们相当频繁地改变网站布局，可以想见维护刮刀是需要努力的。在完成当前版本的几周前，我完成了第一个版本的刮刀，我希望它能持续下去！

**两个，在一些章节中，像“评论”很多元素都嵌套在 HTML 树中相同的元素名称下，共享相同的类、id 等。，但表示逻辑上不同的内容(例如，评论与对评论的响应)。在这种情况下，高效地收集和存储数据成为爬虫的关键部分。

更进一步

最后但同样重要的是，如果您想使用 Docker 将您的应用程序容器化，您可能想看看这篇博文，我发现这篇博文很全面，唯一的例外是作者使用了 R 而不是 Python。

最后， Airbnb 有一个 API ，所以如果你的 API 获得批准并且符合你的目的，就使用它吧！

感谢你阅读这篇文章并走了这么远！希望这是有帮助的，如果你有任何意见，请在下面留下。你也可以在 LinkedIn 上联系我:https://www.linkedin.com/in/areusova/(说明你是从这个中等岗位过来的)。或者推特https://twitter.com/khunreus。

网页抓取高级足球统计

原文：https://towardsdatascience.com/web-scraping-advanced-football-statistics-11cace1d863a?source=collection_archive---------3-----------------------

Photo by Michael Lee on Unsplash

收集数据总是很有趣

最近我一直在争论运气在足球中的作用。又或许不是纯粹的运气，而是一种技能？球队赢得联赛是纯粹靠技术吗？还是运气的重要性相当巨大？谁幸运，谁不幸运？那个队应该降级吗？还有很多很多。

但是因为我是一个数据专家，所以我想，让我们收集数据并找出答案。虽然，你是怎么衡量运气的？你如何衡量技能？没有像国际足联或 PES 电脑游戏那样的单一指标。我们必须着眼于全局，着眼于具有多个变量的长期数据，并考虑到每一场比赛的背景。因为在某些时候，一个队的球员在完全控制对手后的最后几分钟没有足够的运气打进制胜一球，最终成为平局，两个队都得了 1 分，而显然第一个队应该获得胜利。一个团队是幸运的，另一个不是。是的，在这种情况下这是一种运气，因为一支球队做了一切，创造了足够多的危险时刻，但没有得分。它发生了。这就是我们热爱足球的原因。因为这里什么都有可能发生。

虽然你不能衡量运气，但你可以根据足球中一个相对较新的指标——xG，或预期进球，了解球队的表现。

xG——是创造和放弃机会质量的统计指标

你可以在 understat.com 的找到这个指标的数据。这就是我要废弃的网。

理解数据

那么 xG 到底是什么，为什么它很重要。答案我们可以在 understat.com 的主页找到。

预期目标(xG)是新的革命性足球指标，允许您评估球队和球员的表现。

在像足球这样的低分比赛中，最终比赛分数并不能提供清晰的表现画面。

这就是为什么越来越多的体育分析转向 xG 这样的高级模型，这是一种对创造和失球机会质量的统计测量。

我们的目标是创建最精确的拍摄质量评估方法。

对于这种情况，我们用大数据集(> 100，000 个镜头，每个镜头超过 10 个参数)训练神经网络预测算法。

研究人员根据导致进球的情况训练神经网络，现在它给我们提供了一个在比赛中球队有多少真正机会的估计。因为你可以在比赛中有 25 次射门，但如果他们都是远距离或低角度射门，或者太弱，短-低质量的射门，他们不会导致进球。虽然一些没有看过比赛的“专家”会说球队占了上风，创造了大量的机会。这些机会的质量很重要。这就是 xG 度量变得非常方便的地方。有了这个指标，你现在明白梅西在很难进球的情况下创造进球，或者守门员在应该进球的地方做出扑救。所有这些事情加起来，我们看到冠军拥有技术娴熟的球员和一些运气，我们也看到失败者可能拥有优秀的球员，但运气不够好。我做这个项目的目的是理解并展示这些数字，以展示运气在当今足球中的作用。

我们开始吧

我们首先导入将在该项目中使用的库:

• numpy——使用 Python 进行科学计算的基础包
• pandas —提供高性能、易于使用的数据结构和数据分析工具的库
• requests——是 Python 唯一的非转基因 HTTP 库，可供人们安全使用。(喜欢:D 官方文件中的这句话)
• beautiful soup——一个从 HTML 和 XML 文件中提取数据的 Python 库。

import numpy as np*# linear algebra* 
import pandas as pd*# data processing, CSV file I/O (e.g. pd.read_csv)* 
import requests 
from bs4 import BeautifulSoup

网站研究和数据结构

在任何网络抓取项目中，你首先要做的是研究你想要抓取的网页，并理解它是如何工作的。这是根本。所以我们从那里开始。

在主页上，我们可以看到该网站有 6 个欧洲联赛的数据:

我们还看到，收集的数据是从 2014/2015 赛季开始的。我们提出的另一个概念是 URL 的结构。是'https://understat.com/league' + ' /name_of_the_league ' + ' 【T2 ' '

所以我们用这些数据创造变量来选择任何一个赛季或任何一个联赛。

*# create urls for all seasons of all leagues* 
base_url = 'https://understat.com/league' 
leagues = ['La_liga', 'EPL', 'Bundesliga', 'Serie_A', 'Ligue_1', 'RFPL'] 
seasons = ['2014', '2015', '2016', '2017', '2018']

下一步是理解数据在网页上的位置。为此，我们在 Chrome 中打开开发者工具，转到标签“网络”，找到包含数据的文件(在这种情况下是 2018 年)，并检查“响应”标签。这是我们运行 requests.get(URL) 后得到的结果

浏览完网页内容后，我们发现数据存储在“script”标签下，并且是 JSON 编码的。所以我们需要找到这个标签，从中获取 JSON，并将其转换成 Python 可读的数据结构。

*# Starting with latest data for Spanish league, because I'm a Barcelona fan* 
url = base_url+'/'+leagues[0]+'/'+seasons[4] 
res = requests.get(url) soup = BeautifulSoup(res.content, "lxml")*# Based on the structure of the webpage, I found that data is in the JSON variable, under 'script' tags* 
scripts = soup.find_all('script')

使用 JSON

我们发现我们感兴趣的数据存储在 teamsData 变量中，在创建了一大堆 html 标签之后，它就变成了一个字符串，所以我们找到那个文本并从中提取 JSON。

import json string_with_json_obj = '' *# Find data for teams* 
for el **in** scripts: 
    if 'teamsData' **in** el.text: 
        string_with_json_obj = el.text.strip()*# print(string_with_json_obj)**# strip unnecessary symbols and get only JSON data* 
ind_start = string_with_json_obj.index("('")+2 
ind_end = string_with_json_obj.index("')") 
json_data = string_with_json_obj[ind_start:ind_end] json_data = json_data.encode('utf8').decode('unicode_escape')

一旦我们得到了 JSON 并对它进行了清理，我们就可以将它转换成 Python 字典并检查它的外观(注释了 print 语句)。

使用 Python 理解数据

当我们开始研究data时，我们明白这是一本由三个关键词组成的字典: id 、头衔和历史。字典的第一层也使用id作为键。

从这里我们还可以了解到历史有关于球队在自己联赛中每一场比赛的数据(不包括联赛杯或冠军联赛)。

我们可以在查阅第一层字典后收集团队名称。

*# Get teams and their relevant ids and put them into separate dictionary* 
teams = {} 
for id **in** data.keys(): 
    teams[id] = data[id]['title']

history 是字典的数组，其中键是度量的名称(读取列名),值是值，不管这是多么的重复:d。

我们知道列名会反复出现，所以我们将它们添加到单独的列表中。同时检查样本值的外观。

*# EDA to get a feeling of how the JSON is structured
# Column names are all the same, so we just use first element* columns = []
*# Check the sample of values per each column* 
values = [] 
for id **in** data.keys(): 
    columns = list(data[id]['history'][0].keys()) 
    values = list(data[id]['history'][0].values()) 
    break

在输出几个打印语句后，我们发现 Sevilla 的 id=138，因此获取这支球队的所有数据能够为联盟中的所有球队复制相同的步骤。

sevilla_data = [] 
for row **in** data['138']['history']:
    sevilla_data.append(list(row.values())) df = pd.DataFrame(sevilla_data, columns=columns)
df.head(2)

为了保持本文的整洁，我不会添加已创建的 DataFrame 的内容，但最终您会在 Github 和 Kaggle 上找到 IPython 笔记本的链接，其中包含所有代码和输出。这里只是上下文的示例。

所以，wualya，恭喜你！我们有西甲 2018-2019 赛季塞维利亚所有比赛的数据！现在我们想得到所有西班牙球队的数据。让我们把这些咬过的东西循环一遍，宝贝！

*# Getting data for all teams* 
dataframes = {} 
for id, team **in** teams.items(): 
    teams_data = [] 
    for row **in** data[id]['history']:
        teams_data.append(list(row.values())) df = pd.DataFrame(teams_data, columns=columns) 
dataframes[team] = df 
print('Added data for**{}**.'.format(team))

这段代码运行完成后，我们有了一个数据帧字典，其中 key 是球队的名称，value 是该队所有比赛的数据帧。

使数据与原始数据一样的操作

当我们查看 DataFrame 的内容时，我们可以注意到，PPDA 和 OPPDA (ppda 和 ppda_allowed)等指标表示为攻击/防御动作的总量，但在原始表格中，它们显示为系数。让我们解决这个问题！

for team, df **in** dataframes.items(): 
    dataframes[team]['ppda_coef'] = dataframes[team]['ppda'].apply(lambda x: x['att']/x['def'] if x['def'] != 0 else 0)
    dataframes[team]['oppda_coef'] = dataframes[team]['ppda_allowed'].apply(lambda x: x['att']/x['def'] if x['def'] != 0 else 0)

现在我们有了所有的数字，但是每一场比赛。我们需要的是团队的总成绩。让我们找出需要汇总的列。为此，我们回到 understat.com的原始表格，我们发现所有指标都应被汇总，最终只有 PPDA 和欧普达是平均值。

cols_to_sum = ['xG', 'xGA', 'npxG', 'npxGA', 'deep', 'deep_allowed', 'scored', 'missed', 'xpts', 'wins', 'draws', 'loses', 'pts', 'npxGD'] 
cols_to_mean = ['ppda_coef', 'oppda_coef']

我们准备计算我们的总数和平均数。为此，我们循环遍历字典数据帧并调用。sum()和。mean() DataFrame 方法返回 Series，这就是我们添加的原因。将()转置到这些调用中。我们把这些新的数据帧放到一个列表中。将它们连接成一个新的数据帧full_stat。

frames = [] 
for team, df **in** dataframes.items(): 
    sum_data = pd.DataFrame(df[cols_to_sum].sum()).transpose()
    mean_data = pd.DataFrame(df[cols_to_mean].mean()).transpose()
    final_df = sum_data.join(mean_data) 
    final_df['team'] = team
    final_df['matches'] = len(df) 
    frames.append(final_df) full_stat = pd.concat(frames)

接下来，我们重新排序列以提高可读性，根据点对行进行排序，重置索引并添加列'位置'。

full_stat = full_stat[['team', 'matches', 'wins', 'draws', 'loses', 'scored', 'missed', 'pts', 'xG', 'npxG', 'xGA', 'npxGA', 'npxGD', 'ppda_coef', 'oppda_coef', 'deep', 'deep_allowed', 'xpts']]full_stat.sort_values('pts', ascending=False, inplace=True)
full_stat.reset_index(inplace=True, drop=True)
full_stat['position'] = range(1,len(full_stat)+1)

同样，在原始表中，我们有预期指标和实际指标之间的差值。让我们把那些也加上。

full_stat['xG_diff'] = full_stat['xG'] - full_stat['scored'] full_stat['xGA_diff'] = full_stat['xGA'] - full_stat['missed'] full_stat['xpts_diff'] = full_stat['xpts'] - full_stat['pts']

在适当的时候将浮点数转换成整数。

cols_to_int = ['wins', 'draws', 'loses', 'scored', 'missed', 'pts', 'deep', 'deep_allowed'] 
full_stat[cols_to_int] = full_stat[cols_to_int].astype(int)

美化数据帧的输出和最终视图。

col_order = ['position','team', 'matches', 'wins', 'draws', 'loses', 'scored', 'missed', 'pts', 'xG', 'xG_diff', 'npxG', 'xGA', 'xGA_diff', 'npxGA', 'npxGD', 'ppda_coef', 'oppda_coef', 'deep', 'deep_allowed', 'xpts', 'xpts_diff'] full_stat = full_stat[col_order] 
full_stat.columns = ['#', 'team', 'M', 'W', 'D', 'L', 'G', 'GA', 'PTS', 'xG', 'xG_diff', 'NPxG', 'xGA', 'xGA_diff', 'NPxGA', 'NPxGD', 'PPDA', 'OPPDA', 'DC', 'ODC', 'xPTS', 'xPTS_diff'] pd.options.display.float_format = '**{:,.2f}**'.format full_stat.head(10)

原始表格:

现在，当我们从一个联盟获得一个赛季的数据时，我们可以复制代码并将其放入循环中，以获得所有联盟所有赛季的所有数据。我不会把这段代码放在这里，但是我会在我的 Github 和 Kaggle 中留下一个完整的抓取解决方案的链接。

最终数据集

在循环了所有的联赛和所有的赛季以及一些使数据可以导出的操作步骤后，我得到了一个带有刮削数字的 CSV 文件。数据集可在这里获得。

结论

希望你觉得有用，并得到一些有价值的信息。无论如何，如果你读到这里，我只想说谢谢你的阅读，谢谢你为我的 5 分钱花了时间、精力和注意力，希望你有很多爱和幸福，你太棒了！

原载于 2019 年 6 月 23 日http://sergilehkyi.com。

网络抓取和可视化象棋数据

原文：https://towardsdatascience.com/web-scraping-and-visualizing-chess-data-af75f8f92354?source=collection_archive---------23-----------------------

动机

我一直在学习 web 抓取和数据可视化，主要是通过这个网站上发表的文章，虽然我已经找到了几十篇文章，对 web 抓取进行了快速介绍，但很少有人能超越这一点。我希望就如何在一个站点的 html 源代码中查找数据，如何抓取多个页面并收集数据，以及一旦一个人实际上拥有了她想要的数据后该做什么提供一些建议。

话题

我从 2018 年 11 月开始下棋，从那时起，我已经玩了 1，566 场不同速度的游戏，平均每天约 5 场。我使用 chess.com 的应用程序玩游戏，该应用程序除了维护每场游戏的完整历史记录之外，还跟踪每个用户的一些基本统计数据。

Screenshot of Chess.com’s stats page

虽然 chess.com 在 UX 做了令人难以置信的工作，但统计数据页面还有待改进。因为我一直在寻找项目来练习/学习更多关于网页抓取和数据可视化的知识，所以我决定收集我过去游戏的统计数据，并将收集到的一些见解可视化。

网站结构

“存档”页面允许用户查看她过去的所有游戏，如果她想回顾或分析它们的话。从 web 抓取的角度来看，可以看到关于每个游戏的各种信息整齐地存储在各行中，包括:

所玩游戏的类型
用户的棋子颜色、名称、elo 和国家
对手的棋子颜色、名称、elo 和国家
游戏结果(赢或输)
游戏中的棋步数
游戏日期

Screenshot of Chess.com’s game archive

首先要做的是检查页面(右键单击→检查)以查看其底层 HTML 源代码。点击左上角的选择器工具，然后点击游戏图标，就可以直接指向网站这部分的代码。

为了收集这些数据，我使用 Requests 库来获取站点的 HTML 代码，使用 BeautifulSoup 库来解析这些代码并获得我想要的数据。大致的想法如下所示:

page = requests.get('[https://www.chess.com/games/archive/eono619](https://www.chess.com/games/archive/eono619)')
text = page.textb = BeautifulSoup(text, 'html.parser')content = b.find('span', attrs={'class': re.compile("archive-games-game-time")})content.getText().strip()

在这段代码中，我:
1。抓取带有请求的页面
2。从它创建一个美丽的组对象
3。使用对象的。find()方法通过输入标签(' span ')和属性来查找包含我想要的数据的 html 代码。这就产生了下面这个有点乱的字符串:"5 分钟< /span > "
4。最后用。getText()方法并用 string 方法清理它。条状()

每个数据点都有自己独特的 HTML 标签和属性，但这是从网页中提取数据的通用格式。因为我想要页面上的所有游戏，而不仅仅是一个，所以我使用 BeautifulSoup。findAll()方法获取页面上具有该标签和属性的所有元素。对于我想要的每个数据点，我创建了一个类似上面的助手函数，它为给定的页面提取所有这些数据点。

def pull_speed(Bsoup):
    times = []
    for i in b.findAll('span', attrs={'class': re.compile("archive-games-game-time")}):
        times.append((i.getText().strip()))

    return times

为了浏览多个页面，我转到了网址:

https://www . chess . com/games/archive/eono 619？gameOwner=my_game &游戏类型%5B0%5D=chess960 &游戏类型% 5b 1% 5D =每日&游戏类型=直播&page = 2

通过更改最后一个参数中的页码，我可以遍历页面。我的总体抓取代码初始化空列表来存储结果，遍历每个页面并调用助手函数来抓取我想要的数据，然后收集 pandas dataframe 中的所有内容进行分析。

Full notebook and data on my GitHub (https://github.com/eonofrey/chess_scrape_2)

最后，我的数据帧有 9 列 1566 行，包含了我深入游戏所需的一切。

可视化

我做的第一个图只是看看我的 elo 如何随着时间的推移沿着 30 天移动平均线前进，以消除一些粒状数据固有的波动。很明显有一个上升的趋势，这让我很高兴看到，因为这表明我确实在学习这个游戏，尽管偶尔会遇到困难。

接下来，我使用 Seaborn 的 countplots 查看了与我对战的不同国家，这是一个非常有用的函数，它绘制了传递给它的变量的计数。

不幸的是，我在每个国家玩过的游戏列表有一个很长的尾巴，但是当我将 order 参数传递给 countplot 函数时，我只能传递我的数据帧中的一部分(order = speed _ games[' opposite _ country ']。【value _ counts().iloc[1:25] 。index)来解决这个问题。在这里，我只列出了前 25 个值，并排除了美国，因为它在这张图表中占了很大一部分。

在此之后，我决定通过对不同的字段进行分组并查看各种汇总统计数据来稍微处理一下我的数据框架。我发现两种最好的方法是。重新取样()和。group_by()方法。在这里，我按月和周对数据进行分组，以获得每个时间段玩游戏的数量，并添加一条水平线来显示每个频率下玩游戏的平均数量。

为了想象我和不同国家的玩家打得有多好，我需要做更多的预处理。我首先将数据按国家分组，得到游戏的数量以及结果的平均值(1 =赢，0 =输)，这相当于一个胜率。然后，我将国家栏上的两个数据框连接起来，这样我就可以将我的图表限制在我至少打过 15 场比赛的国家。

接下来，我调查了我的胜率是否随着一周的不同而变化。有趣的是，我似乎在周末打得更好。

最后，我调查了每种颜色的胜率。由于白棋先走，所以比黑棋略占优势，预计赢的几率更大。我的数据支持这一点，显示我用白棋比用黑棋多赢了大约 4%。

我还研究了我赢的游戏和输的游戏的平均移动次数。有趣的是，我赢的游戏比我输的游戏平均多走两步。

我本可以探究这些数据的某些方面，但是为了保持简洁，我将在这里删减这篇文章。通过开展这个项目，我提高了我的网络抓取和数据可视化技能，甚至最终获得了一些关于我的象棋比赛的见解，这是一个额外的好处。我最终的希望是，有人能使用这里的课程/代码片段来帮助他们完成自己的项目。对于那些感兴趣的人，我的完整脚本和数据集可以在我的 GitHub 页面https://github.com/eonofrey/chess_scrape_2找到。要获得所有媒体文章的完整访问权限，请点击此处！

网页抓取基础知识

原文：https://towardsdatascience.com/web-scraping-basics-3c0229653842?source=collection_archive---------28-----------------------

从网上收集数据的基础知识

联合国教科文组织是联合国内部的一个组织，致力于保护世界自然和文化遗产。世界上有许多遗产，包括包含自然现象的遗产，如大堡礁。不幸的是，一些获奖的地方受到了人为干预的威胁。我们可以用以下问题来解构这个人为干预的问题；

1-哪些地点受到威胁，它们位于哪里？

2-世界上有比其他地区更濒危的地方吗？

3-将网站置于风险中的原因是什么？

我们可以查看维基百科，找到进一步解决这些问题的地方列表。当我们去https://www.wikipedia.org/搜索“濒危世界遗产名录”时，我们会看到https://en . Wikipedia . org/wiki/List _ of _ World _ Heritage _ in _ Danger维基百科页面。在此页面中，我们可以看到一个表格，其中的列为我们提供了处于危险中的网站的功能信息。

在本文中，我们将使用 R 作为编程语言，从 web 上抓取数据并加载到数据帧中。请记住，这篇文章只提供了基本的网页抓取技术，给我们一个围绕过程和可能的网页抓取解决方案的想法。

我们找到了想要抓取的数据，下一步是使用 R 将所需的数据加载到 R 中。

我们有一个表，可以从前面安装的 XML 库中使用 readHTMLTable()函数加载到 R 中。

我们基本上是在告诉 R，导入的数据以 HTML 文档的形式出现。我们使用名为 htmlParse()的函数通过解析器实现了这一点。使用 readHTMLTable()函数，我们告诉 R 提取它在已解析的 heritage_parsed 对象中找到的所有 HTML 表格，并将它们存储在 heritage_tables 中。

现在让我们选择一个表，我们可以用它来更接近地回答我们最初建立的业务问题。我们要用的表格应该有遗址的名称、位置、文化或自然的分类变量、碑文年份和濒危年份。

我们能够获得包含我们之前定义的所需列的数据表。我们可以执行简单的数据清理。为了做到这一点，让我们看看数据帧的结构。

我们有 53 个地点和 9 个变量。我们可以看到每个变量的数据类型并不准确，例如，标准应该是自然或文化之间的分类变量，但是在这种情况下，我们有许多因素，数据类型被记录为字符串。我们可以对数据集应用基本的清理方法。

年份变量需要是数字，一些年份条目不明确，因为它们有几个年份附加或组合在一起。在这些值中，我们使用正则表达式选择最后一个给定的年份，比如[[:digit:]]4＄行

让我们看看位置变量，因为它看起来比年份变量要混乱得多。

这个变量实际上在一行中包含三个不同的值，它有几个不同的站点位置、国家和地理坐标。我们能做的就是得到地图的坐标。我们可以再次使用正则表达式来提取这些信息。

我们能够检索坐标和相应的世界遗产。这就完成了 web 抓取和数据准备过程，以供进一步分析。

web 抓取的过程总是包括使用一些工具，比如使用 R 或 Python 包从 web 上解析和抓取表格。如果我们想总结传播、提取和存储网络数据的技术，我们可以使用下图。

web 抓取最重要的阶段是初始阶段，在这个阶段我们定义数据需求。什么类型的数据最适合回答我们的业务问题？数据的质量是否足以回答我们的问题？信息是否存在系统性缺陷？

当我们从网上获取任何数据时，我们需要记住数据的来源。数据可能是作为第一方数据收集的一部分收集的，也可能是二手数据，如 Twitter 帖子或在离线环境中收集并手动在线发布的数据。然而，即使我们找不到数据的来源，我们使用网络上的数据也是完全有意义的。数据质量取决于用户的目的和数据的应用。

网络抓取基础有 5 个步骤，我们可以定义和遵循。

1-弄清楚你需要什么样的信息。

2-看看你是否能在网上找到能为你提供商业问题答案的数据源。

3-在试图找出数据来源时，创建数据生成过程的理论。(例如:数据集来自抽样计划或调查等……)

4-概述数据源的优点和缺点。(确定是合法的！)

5-制定决策，如果可行，从不同来源收集数据，以进一步整合。

用 Python 编写的网页刮痧板游戏描述

原文：https://towardsdatascience.com/web-scraping-board-game-descriptions-with-python-7b8f6a5be1f3?source=collection_archive---------22-----------------------

我喜欢收集数据！

我再说一遍，我爱收集数据！虽然通读 HTML 以找到您想要的标签有时会有点乏味，但是从网页中抓取数据提供了一个信息宝库。在之前的一篇文章中，我讨论了一些我用来手动收集网络数据的技术。本文将介绍如何使用 Python 库 BeautifulSoup，并请求从网站棋盘游戏极客那里收集棋盘游戏描述。如果你想看看我是如何把它们放在一起的，请滚动到文章的底部，复制并粘贴我的代码！

属国

为了让这个过程简单一点，我从的“猛男”的 Github repo 中找到了一份超过 15000 款桌游的列表，用于历史桌游极客排名。该文件是一个 CSV 文件，使得使用熊猫很容易。以下是数据在文件中如何格式化的示例:

ID,Name,Year,Rank,Average,Bayes average,Users rated,URL,Thumbnail
174430,Gloomhaven,2017,1,8.89,8.604,26069,/boardgame/174430/gloomhaven,[https://cf.geekdo-images.com/micro/img/8JYMPXdcBg_UHddwzq64H4NBduY=/fit-in/64x64/pic2437871.jpg](https://cf.geekdo-images.com/micro/img/8JYMPXdcBg_UHddwzq64H4NBduY=/fit-in/64x64/pic2437871.jpg)

使用这个文件，我构建了完整的 URL，可以从中抓取描述。我通过导入我的依赖项并加载 CSV 文件来开始这个过程:

import pandas as pd
import requests
from bs4 import BeautifulSoup
import sqlite3 as sql
from sqlite3 import Error#load the csv file
boardgames = pd.read_csv(r'board games\2019-07-08.csv')
boardgames.head()

Top 5 rows from boardgames

探索 HTML

在创建遍历所有 URL 并提取描述的循环之前，我研究了使用 Requests 和 BeautifulSoup 请求页面内容时返回的数据。这使得我更容易识别我需要找到的标签。

#explore the first board game page
url = r"[https://boardgamegeek.com/boardgame/174430/gloomhaven](https://boardgamegeek.com/boardgame/174430/gloomhaven)"
page_data = requests.get(url)
soup = BeautifulSoup(page_data.content, 'html.parser')
soup

The parsed html data

浏览数据，我看到描述被标记为带有属性 og:description 的<元内容* >。*我用 BeautifulSoup 的 find 方法提取数据。

description = soup.find("meta",  property="og:description")
print(description["content"])

在页面间循环

一旦我找到了我要找的东西，我就从 Pandas 数据框中取出 URL，并将它们分配给一个变量。然后我为 Loop 创建了一个简单的来遍历每个 URL 并将棋盘游戏描述加载到一个列表中。在棋盘游戏没有描述的情况下，我使用一个 IF ELSE 语句来防止循环中断。

#url part 1
up1 = r"[https://boardgamegeek.com](https://boardgamegeek.com)"#URLs from the data frame
urls = boardgames['URL']#index variable
n = 0#list of descriptions
desc = []#for loop
for u in urls:
    url = up1 + urls[n]
    print(url)
    d = requests.get(url)
    soup = BeautifulSoup(d.content, 'html.parser')
    description = soup.find("meta",  property="og:description")
    (desc.append(description["content"]) if description else desc.append("No Description"))
    n+=1

The loop prints the URL to indicate it is working

把所有的放在一起

循环完成后，我将描述添加到 boardgames 数据框中，并将数据框保存到 sqlite 数据库中。

#add the descriptions to the dataframe
boardgames['description'] = desc#create an sqlite database and connection
conn = sql.connect(r'Desktop\board games\bgdb')
c = conn.cursor()#load the data into the database
boardgames.to_sql('boardGames', conn)#query the data to verify
q = pd.read_sql('select * from boardGames', conn)
q.head()

The data frame with descriptions added

完整的代码

import pandas as pd
import requests
from bs4 import BeautifulSoup
import sqlite3 as sql
from sqlite3 import Error#load the csv file
boardgames = pd.read_csv(r'board games\2019-07-08.csv')
boardgames.head()#explore the first board game page
url = r"[https://boardgamegeek.com/boardgame/174430/gloomhaven](https://boardgamegeek.com/boardgame/174430/gloomhaven)"
page_data = requests.get(url)
soup = BeautifulSoup(page_data.content, 'html.parser')
soupdescription = soup.find("meta",  property="og:description")
print(description["content"])#url part 1
up1 = r"[https://boardgamegeek.com](https://boardgamegeek.com)"#URLs from the data frame
urls = boardgames['URL']#index variable
n = 0#list of descriptions
desc = []#for loop
for u in urls:
    url = up1 + urls[n]
    print(url)
    d = requests.get(url)
    soup = BeautifulSoup(d.content, 'html.parser')
    description = soup.find("meta",  property="og:description")
    (desc.append(description["content"]) if description else desc.append("No Description"))
    n+=1#add the descriptions to the dataframe
boardgames['description'] = desc#create an sqlite database and connection
conn = sql.connect(r'Desktop\board games\bgdb')
c = conn.cursor()#load the data into the database
boardgames.to_sql('boardGames', conn)#query the data to verify
q = pd.read_sql('select * from boardGames', conn)
q.head()

抓取网络数据是一项很棒的技能！如果 API 不可用，它为您提供了一种从 web 页面收集数据的简化方法。如果您想了解更多信息，请查看以下资源:

[## 教程:使用 BeautifulSoup 的 Python Web 抓取

在执行数据科学任务时，通常希望使用在互联网上找到的数据。你通常可以…

www.dataquest.io](https://www.dataquest.io/blog/web-scraping-tutorial-python/)

B

谢谢大家！

• 如果你喜欢这个， 跟我上 Medium 了解更多
• 通过订阅 获得完全访问权限并帮助支持我的内容
• 我们连线上LinkedIn
• 用 Python 分析数据？查看我的 网站

—埃里克·克莱本

网络抓取 Craigslist:一个完整的教程

原文：https://towardsdatascience.com/web-scraping-craigslist-a-complete-tutorial-c41cea4f4981?source=collection_archive---------2-----------------------

我最近一直想搬家。还有什么比从 Craigslist 上的房屋“人口”中取样更好的方式来知道我得到了一个好价格呢？听起来像是…Python 和 web 抓取的工作！

在本文中，我将带您浏览我的代码，该代码搜索东湾区 Craigslist 上的公寓。这里的代码，或者更确切地说是 URI 参数，可以被修改以从任何地区、类别、财产类型等中提取。很酷吧。

我要分享原 Jupyter 笔记本中每个单元格的 GitHub gists。如果你想一次性看到全部代码，克隆回购。否则，享受阅读和跟随！

获取数据

首先，我需要使用请求包中的 get 模块。然后我定义了一个变量 response，并把它赋给在基本 URL 上调用的 get 方法。我所说的基本 URL 是指你要从中提取数据的第一页的 URL，减去任何额外的参数。我去了东湾的公寓区，检查了“有图片”过滤器，缩小了搜索范围，所以这不是一个真正的基本网址。

然后我从 bs4 导入了 BeautifulSoup，这个模块实际上可以解析从服务器获取的 web 页面的 HTML。然后，我检查了该项目的类型和长度，以确保它与页面上的帖子数量相匹配(有 120 个)。您可以在下面找到我的导入语句和设置代码:

It prints out the length of posts which is 120, as expected.

在上面的代码中，对新创建的 html_soup 变量使用 find_all 方法，我找到了帖子。我需要检查网站的结构，以找到帖子的父标签。看下面的截图，可以看出是

• 。这是一篇文章的标签，实际上是包含我抓取的所有元素的盒子！

Element inspection with Chrome (Ctrl+Shift+C shortcut!)

为了实现这一点，请确保按照以下方式工作:获取第一篇文章和您想要从中获取的所有变量，确保您知道如何在循环整个页面之前访问一篇文章中的每个变量，最后，确保您在添加遍历所有页面的循环之前成功地抓取了一个页面。

类 bs4.element.ResultSet 是索引的，所以我通过索引posts[0]查看了第一个单元。惊喜，都是属于那个<李>标签的代码！

You should have this output for the first post in posts (posts[0]), assigned to post_one.

帖子的价格很好抢:

.strip() removes whitespace before and after a string

我通过在类“result-date”上指定属性“datetime”来获取日期和时间。通过指定“datetime”属性，我省去了数据清理的一个步骤，即不必将该属性从字符串转换为 datetime 对象。这也可以通过将['datetime']放在.find()调用的末尾而变成一行程序，但是为了清楚起见，我将它分成两行。

URL 和文章标题很简单，因为“href”属性是链接，通过指定该参数来获取。标题只是那个标签的文本。

卧室的数量和平方英尺在同一个标记中，所以我将这两个值分开，并按元素的方式各取一个。邻居是“结果社区”类的标签，所以我抓取了它的文本。

下一个块是东湾所有页面的循环。因为并不总是有关于平方英尺和卧室数量的信息，所以我在 for 循环中嵌入了一系列 if 语句来处理所有情况。

循环从第一页开始，对于该页中的每篇文章，它通过以下逻辑工作:

我在循环中包含了一些数据清理步骤，比如提取“datetime”属性，从平方英尺变量中删除“ft2 ”,并使该值成为一个整数。我把“br”从卧室的数量中去掉了，因为它也被删除了。这样，我开始清理一些已经完成的数据。优雅的代码是最好的！我想做更多的事情，但是代码会变得过于特定于这个区域，可能无法跨区域工作。

下面的代码从值列表中创建数据框架！

厉害！就在那里。不可否认，仍然有一些数据清理工作要做。我将快速浏览一遍，然后是研究数据的时候了！

探索性数据分析

可悲的是，删除重复的 URL 后，我发现只有 120 个实例。如果您运行代码，这些数字会有所不同，因为在不同的抓取时间会有不同的帖子。大约有 20 个帖子没有列出卧室或面积。出于统计原因，这不是一个令人难以置信的数据集，但我注意到了这一点，并继续向前推进。

Descriptive statistics for the quantitative variables

我想看看东湾的价格分布，所以我画了上面的图。调用.describe()方法，我得到了更详细的观察。最便宜的地方 850 美元，最贵的 4800 美元。

下一个代码块生成一个散点图，其中的点用卧室的数量来着色。这显示了一个清晰和可以理解的分层:我们看到围绕特定价格和平方英尺的点的层次，随着价格和平方英尺的增加，卧室的数量也增加。

我们不要忘记数据科学的主力:线性回归。我们可以在这两个变量上调用一个regplot()来得到一条回归线，该回归线带有一个关于该线计算的 bootstrap 置信区间，并用下面的代码显示为一个阴影区域。如果你没有听说过 bootstrap 置信区间，这是一种非常酷的统计技术，值得一读。

看起来我们对这两个变量有一个很好的拟合。让我们检查一下相关性。我打电话去拿这些:

Correlation matrix for our variables

正如所怀疑的，卧室数量和面积之间有很强的相关性。这是有道理的，因为面积随着卧室数量的增加而增加。

继续按社区定价

我想了解位置如何影响价格，所以我按社区分组，并通过计算每个变量的平均值进行汇总。

下面是由这一行代码生成的:eb_apts.groupby('neighborhood').mean()其中“neighborhood”是“by=”参数，聚合函数是平均值。

我注意到有两个北奥克兰:北奥克兰和北奥克兰，所以我将其中一个重新编码为另一个，如下所示:

eb_apts['neighborhood'].replace('North Oakland', ‘Oakland North', inplace=True)。

抓取价格，按升序排序，可以显示最便宜和最贵的居住地。现在整行代码是:eb_apts.groupby('neighborhood').mean()['price'].sort_values()，并产生以下输出:

Average price by neighborhood sorted in ascending order

最后，我观察了每个街区的价格分布。通过这样做，我看到了邻近地区的价格是如何变化的，以及变化到什么程度。

下面是产生以下情节的代码。

伯克利有很大的差距。这可能是因为它包括南伯克利、西伯克利和伯克利市中心。在这个项目的未来版本中，考虑改变每个变量的范围可能是重要的，这样它们可以更好地反映每个城市中不同社区之间的价格可变性。

好了，现在你知道了！下次你在市场上买房子的时候，看看这个，看看什么是好价格。请随意查看回购并亲自尝试，或者为您的城市完成该项目！让我知道你想出了什么！

负责任的刮。

如果你学到了新的东西，并想把它交给下一个学习者，考虑捐赠你觉得合适的任何数量，谢谢！

编码快乐！

奢侈的生活

用 Python 实现财务报表的网络抓取— 1

原文：https://towardsdatascience.com/web-scraping-for-accounting-analysis-using-python-part-1-b5fc016a1c9a?source=collection_archive---------3-----------------------

我复制了一个基于 Excel 的会计工作，以前我要花几个小时才能完成，现在这项任务可以在几秒钟内完成。

背景

会计的数据科学用例并不多。然而，会计工作是需要自动化的繁琐类别之一。我曾经做过的一项任务是获取单个公司的财务报表，这样我就可以对照行业分析它们的表现。基本上，我会在雅虎财经上搜索他们的名字，并在 Excel 上收集关键指标。

操纵网络数据有时会很棘手，尤其是当网站更新时，但是掌握这几个步骤将会在将来为你节省大量的时间。这是一个使用 Python 从雅虎财经获取财务报表的例子。

导入库

Urlib.request 是一个开源库，用于解析网页内容。当你调用它时，你基本上是要求网站从那个网站获取数据。如果感兴趣，这里有更多的信息。

https://docs.python.org/3/library/urllib.request.html

另一个库叫做 Beautiful Soup ，它使得读取以 XML 格式存储的数据变得更加容易。XML 是一种类似于 HTML 的格式，在标记之间存储值。如果你打开它，它看起来有点乱。就像你拿到一个网页的源代码一样。

import pandas as pd
from bs4 import BeautifulSoup
import urllib.request as ur

处理

这里有一个简单的技巧，你可以灵活地调整股票代码，并将其插入网址链接。如果你想提取数百份公司财务报表，它会派上用场。

# Enter a stock symbol
index= ‘MSFT’# URL link 
url_is = ‘[https://finance.yahoo.com/quote/'](https://finance.yahoo.com/quote/') + index + ‘/financials?p=’ + index
url_bs = ‘[https://finance.yahoo.com/quote/'](https://finance.yahoo.com/quote/') + index +’/balance-sheet?p=’ + index
url_cf = ‘[https://finance.yahoo.com/quote/'](https://finance.yahoo.com/quote/') + index + ‘/cash-flow?p=’+ index

现在我们已经保存了 URL 链接。如果您在 Web 浏览器上手动打开它们，它将看起来像这样。

阅读网址

接下来，我们只需要打开链接，将它读入一个名为 lxml 的适当格式。很简单。

read_data = ur.urlopen(url_is).read() 
soup_is= BeautifulSoup(read_data,’lxml’)

嗯，如果你打开 soup_is，它看起来会很乱，因为元素最初是 HTML 格式的。所有元素都被系统地安排在类中。

数据操作

但是如何知道相关数据存储在哪个类中呢？

经过几次搜索，我们知道它们存储在“div”中，我们可以创建一个空列表并使用 for 循环来查找所有元素并将它们追加到列表中。

ls= [] # Create empty list
for l in soup_is.find_all(‘div’): 
  #Find all data structure that is ‘div’
  ls.append(l.string) # add each element one by one to the list

ls = [e for e in ls if e not in (‘Operating Expenses’,’Non-recurring Events’)] # Exclude those columns

你会发现 ls 里面有很多“none”元素，因为不是所有的“div”都有一个元素。我们只需要把那些过滤掉。

*new_ls = list(filter(None,ls))*

现在看起来像这样。

如果我们更进一步，从第 12 个位置开始读列表。

new_ls = new_ls[12:]

好吧，现在我们有一个名单。但是我们怎么把它变成一个数据框呢？首先，我们需要一次迭代 6 个项目，并将它们存储在元组中。然而，我们需要一个列表，以便熊猫图书馆可以将它读入数据框。

is_data = list(zip(*[iter(new_ls)]*6))

太好了，这正是我们想要的。现在，我们只需将它读入数据框。

Income_st = pd.DataFrame(is_data[0:])

数据清理

太好了。差不多完成了。我们只需要读取第一行作为列，第一列作为行索引。这里有一些清理。

Income_st.columns = Income_st.iloc[0] # Name columns to first row of dataframeIncome_st = Income_st.iloc[1:,] # start to read 1st rowIncome_st = Income_st.T # transpose dataframeIncome_st.columns = Income_st.iloc[0] #Name columns to first row of dataframeIncome_st.drop(Income_st.index[0],inplace=True) #Drop first index rowIncome_st.index.name = ‘’ # Remove the index nameIncome_st.rename(index={‘ttm’: ‘12/31/2019’},inplace=True) #Rename ttm in index columns to end of the yearIncome_st = Income_st[Income_st.columns[:-5]] # remove last 5 irrelevant columns

在对损益表、资产负债表和现金流使用相同的技术后，您的数据框架应该如下所示。

Income Statement

Balance Sheet

Cash flow statement

在对数据帧进行转置后，DateTime 被转换为行索引，而特性成为列名。

以下是一些事后思考的问题:

1. 这些特征如何与公司的股票价格相关联？你如何发现它们是否相关？
2. 如果是，哪些时间段的股票价格与我们财务报表的特征相关？
3. 在开发算法交易模型时，你还可以用提取的数据做什么？

欢迎在回复中留下你的答案和评论，看看你是否能想出一些独特的答案。

感谢您阅读本文，如果您觉得有用，请随意分享。这里是另一篇关于利用新数据框架和用 Python 做进一步财务会计分析的文章。

金融分析师的网络抓取

原文：https://towardsdatascience.com/web-scraping-for-beginners-beautifulsoup-scrapy-selenium-twitter-api-f5a6d0589ea6?source=collection_archive---------8-----------------------

简介

我最近在学习网络抓取，并想分享我使用 beautifulsoup、scrapy、selenium 以及使用 Twitter API 和 pandas datareader 进行抓取的经验。网络抓取是有趣且非常有用的工具。Python 语言使得网络抓取变得更加容易。用不到 100 行代码就可以提取数据。网络抓取是数据分析专业人员需要掌握的一项重要技能。

例如，我们可以删除金融信息、宏观经济信息或股票研究分析师、风险资本家、财务经理、基金经理、对冲基金经理等使用的任何其他信息。通过抓取 Alexa.com 的网络流量，高盛资产管理公司(Goldman Sachs Asset Management)能够发现 Homedepot 网站的访问量大幅上升，这有助于该资产管理公司提前买入 HomeDepot 的股票。FlightAware.com 通过跟踪帮助找出首席执行官的旅行模式，这反过来有助于发现并购活动。网络搜集在金融领域非常重要，因为网上有大量的金融信息。

什么是网刮 ？

网络抓取是一种从网站上提取信息并进行处理的技术。

让我们看看如何简单和容易做网页抓取。

我将浏览下面的库和 API

• 美汤
• 刺儿头
• 硒
• Twitter API 提取推文
• 熊猫 DataReader 阅读自谷歌财经

我们将使用 Jupyter 笔记本。请检查下面的链接并安装它。

Jupyter 安装

了解更多关于 jupyter

美汤:

Beautiful Soup 是一个 Python 库，用于从 HTML 和 XML 文件中提取数据。

安装 BS4:

• pip 在命令提示符下安装 beautifulsoup4。
• pip 安装请求

我已经安装了它，因此它说要求已经满足。

BS4 安装完成后，打开 juypter 笔记本。

只是为了演示的目的，我将从纳斯达克网站上删除数据

[## 科技公司

使用公司列表工具在以下网址查找技术公司和纳斯达克、纽约证券交易所和美国证券交易所上市公司的完整列表…

www.nasdaq.com](https://www.nasdaq.com/screening/companies-by-industry.aspx?industry=Technology&sortname=marketcap&sorttype=1&page=1)

我们将收集以下信息

1. 名字
2. 标志
3. 市值
4. 国家
5. IPO 年份
6. 子部门

网页如下所示

查美汤文档

这些步骤是

• 选择要废弃的网站 URL
• 最终确定需要从网站上搜集的信息
• 获取请求
• 检查网站——右击谷歌浏览器
• 美丽的汤— HTML 解析器
• 选择所需的数据并将其添加到列表中
• 将抓取的数据下载到一个 CSV 文件并存储在本地
• 将数据移动到 pandas 数据框或将 CSV 文件上传到数据框，并在 pandas 中进行进一步的分析和可视化。

下面的代码解释了这些步骤。现在打开 jupyter 笔记本，开始编码。

1. 导入所有必需的库。

2. 获取请求: 首先我们需要下载网页。为此，我们将使用 get request。

url = "给出您决定抓取数据的 URL "
response = get(URL)
获取有关 get 请求的更多信息

3.解析 HTML: 解析

我们将使用上面的响应创建一个新的 beautifulsoup 对象，解析器方法为 html.parser。

在 Chrome 中，我们可以通过以下方式快速找到元素的选择器

1. 右键单击该元素，然后在菜单中选择“检查”。开发人员工具打开，并突出显示我们右键单击的元素
2. 右键单击开发工具中的代码元素，将鼠标悬停在菜单中的“复制”上，然后单击“复制选择器”

检查铬视工具使用 。

有关 html 和 xml 的信息，您可以查看

在我们的例子中，整个列表保存在表“CompanylistResults”中。直接从表中删除数据。表的元素有

[<table>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/table)HTML**<table>**元素表示表格数据——也就是说，由包含数据的单元格的行和列组成的二维表格中呈现的信息。

[<td>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td)HTML**<td>**元素定义了一个包含数据的表格单元格。它参与表模型。

[<tr>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tr)HTML**<tr>**元素定义了表格中的一行单元格。然后可以混合使用[<td>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td)(数据单元格)和[<th>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/th)(标题单元格)元素来建立行的单元格。HTML **<tr>**元素指定包含在<tr>块中的标记构成了一个表格的一行，其中[<th>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/th)和[<td>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td)元素分别在该行中创建标题和数据单元格。

常见的 HTML 元素。查看更多信息

整个列表存储在表“CompanylistResults”中

这些步骤是

1. 找到表 ID = "company list results"
2. 选择所有的' tr '(选择所有的行)
3. 循环遍历' tr '并找到 tr 中的所有TD(TD是单元格)

基于 HTML 代码，数据存储在 < tr >之后../。这是行信息。每一行都有一个对应的 < td >../或单元格数据信息。

我将结果附加到一个列表中。当我打印这个列表时，我得到了如下结果

在这种情况下，我们只刮了第一页。我看到有 14 页。为了抓取多个页面，我们可以添加下面的逻辑

初始化一个名为 pages 的变量，范围在 1 到 14 之间。

对每个页面进行循环，并在 url 中分配页面值

URL = 'https://www . Nasdaq . com/screening/companies-by-industry . aspx？行业=技术&sort name = market cap&sort type = 1&page = '+page

对于第二页，url 将是

URL = 'https://www . Nasdaq . com/screening/companies-by-industry . aspx？industry = Technology&sort name = market cap&sort type = 1&page = 2

并且整个提取逻辑被编码在每页的 for 循环中。

要提取数据:

现在你可以了

• 将数据加载到熊猫数据框架中
• 为数据帧指定列名，如名称、符号等。
• 将数据帧下载到 CSV 文件中。
• 进行分析和可视化

代码如下。

下载的 CSV 文件如下所示

纳斯达克十大市值股票:

前 20 大市值股票

Top 20 Market Cap Stocks in NASDAQ

纳斯达克上市股票国家:

首次公开募股数量/年

IPO Year

在纳斯达克上市的公司数量

Sector wise breakup

公司在 2019 年进行 IPO(很惊讶没有在名单中看到 Lyft。检查了 NASADAQ 网站，Lyft 不在列表中-我想他们还没有更新他们的数据库。Pinterest 和 Zoom 都在)

描述显示以下内容

熊猫档案显示更多信息

替代网络抓取的是 API。

流行的 API 看看这个 github 有用的 API

在下一篇文章中，我将介绍 scrapy、selenium、Twitter API 和 DataRead。谢谢你看我的帖子。

用 RSelenium 抓取谷歌表单

原文：https://towardsdatascience.com/web-scraping-google-sheets-with-rselenium-9001eda399b0?source=collection_archive---------9-----------------------

Photo by freestocks.org on Unsplash

我喜欢学习新的东西，我学得最好的方法之一就是实践。也有人说你永远不会完全理解一个话题，直到你能够解释它，我认为博客是解释事情的一个低门槛。

我在蒙特利尔的一个当地数据科学会议上遇到的一个人想要帮助网络抓取，以从puzzled point获得团队排名。我抓住了这个机会，因为我知道这将是我最终学习 硒的机会！

静态刮擦与动态刮擦

静态抓取忽略 JavaScript。它不需要浏览器的帮助就可以从服务器获取网页。你得到的正是你在“查看页面源代码”中看到的内容，然后你对它进行分割。如果你正在寻找的内容是可用的，你不需要再进一步。但是，如果内容类似于“iframe ”,就需要动态抓取。

动态抓取使用实际的浏览器(或无头浏览器),让 JavaScript 来完成它的工作。然后，它查询 DOM 来提取它正在寻找的内容。有时，您需要通过模拟用户来获得您需要的内容，从而使浏览器自动化。为了让我获得其余帖子的相同详细信息，我需要首先导航到下一页，这包括单击搜索结果页底部的 next 按钮。

用 Docker 设置 RSelenium

RSelenium 为 Selenium Webdriver API 提供了 R 绑定。Selenium 是一个专注于 web 浏览器自动化的项目。

您需要遵循 Windows 或 Ubuntu 上 Docker Toolbox 的安装说明。

Docker 通过使用容器来运行应用程序。容器只是一个包中的一组库和其他依赖项。你可以把它想象成一个虚拟机，但它不是创建一个完整的操作系统，而是允许应用程序使用同一个 Linux 内核，只是没有在主机上运行。基本上，它显著提高了性能并减小了应用程序的大小。此外，您可以放心，应用程序将在任何其他 Linux 机器上运行，而不管该机器的任何定制设置可能与用于编写和测试代码的机器不同。

你还需要安装 TightVNC ，这将允许你看到你是如何用 RSelenium 实时操纵网页的。

接下来按照的说明创建一个 Docker 容器，运行 selenium 服务器和它自己的 firefox 。

注意:一旦你设置了 docker 容器(并且每次你重新启动你的计算机或再次启动时),打开 Docker Quickstart 终端并运行下面的命令。

docker run -d -p 4445:4444 selenium/standalone-firefox:2.53.0

现在你已经启动了你的 Docker Quickstart 终端进入 R 并连接到一个正在运行的服务器。

library(RSelenium)
remDr <- remoteDriver(
  remoteServerAddr = "192.168.99.100",
  port = 4445L
)
remDr$open()

使用 Rselenium 导航到页面。

# navigate to the website of interest
remDr$navigate("[http://www.puzzledpint.com/standings/](http://www.puzzledpint.com/standings/)")
# confirm you got there
remDr$getTitle()0

好了，让我们在 RStudio 的查看器选项卡中获取一个现场截图。

remDr$screenshot(display = TRUE)

请记住，这只是一个静态的屏幕截图。在开发你的管道时，你需要使用 TightVNC 来实时查看你的互动，这样你就可以看到你是如何与网站互动的。

当你在你的…$findElement()和…$switchToFrame() / …$clickElement()命令之间使用…$highlightElement()时，注意 TightVNC 是很重要的，这样你实际上知道你选择了合适的东西！

打开 TighVNC 查看器，输入端口号；在本例中为192.168.99.100，并在远程主机:字段中输入。点击连接，输入密码:secret。

注意:如果 TightVNC 停止工作(在 Windows 10 上经常如此)并给出错误消息:“由于目标机器主动拒绝，无法建立连接”，那么请按照“使用 VNC 调试”的步骤进行操作。

访问 DOM 中的元素

网页是一组嵌套对象(统称为文档对象模型或 DOM )。它是一种跨平台和独立于语言的约定，用于表示 HTML、XHTML 和 XML 文档中的对象并与之交互。与 DOM 的互动对我们与硒元素的关系非常重要。

Hadley Wickham 建议使用 Chrome 扩展软件 Selectorgadget ，来帮助识别你需要的网页元素。他推荐这一页来学习更多关于选择器的知识。

例如，通过使用 SelectorGadget，您可以选择感兴趣的表。在这种情况下，它说这是一个 iframe 。为了仅隔离月度排名，我们将单击另一个框，仅选择感兴趣的一个:iframe:nth-child(68)。

在 web 浏览器的上下文中，框架是网页或浏览器窗口的一部分，它独立于其容器显示内容，并具有独立加载内容的能力。在这种情况下，网站从另一个来源获取数据，在主排名页面之外以交互方式显示这些表格。对我来说幸运的是，它们都来自 Google Sheets，所以这将使我更加容易。遗憾的是，您无法使用“selectorgadget”找到这些工作表的链接。你需要在 Chrome 或 Firefox 中使用名为“Inspector”的开发者工具仔细查看源代码。如果你有 Windows 和 Firefox，你可以点击打开菜单然后点击Web Developer > Inspector或者直接点击Ctrl+Shift+c。然后我用搜索框寻找 Montréal 的链接(src=)。

对我来说，找到我要找的东西是一件非常痛苦的事情，因为有时候高光看起来像你想要的，但实际上不是。例如:

最后，我猜要弄清楚 HTML，它涉及到逐渐的“拒绝和错误”尝试。

用 RSelenium 抓取 Google 表单

法律免责声明

值得一提的是，管理员可能出于多种原因想要保护他们网站的某些部分，例如"对未经宣布的站点进行索引、遍历需要大量服务器资源的站点部分、递归遍历无限 URL 空间等。

因此，应该经常检查他们是否有许可。一种方法是使用 robotstxt 包来检查你的网络机器人是否有权限访问网页的某些部分。

# check permissions
library(robotstxt)
paths_allowed("[https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pub?output=html&widget=true#gid=690408156](https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pub?output=html&widget=true#gid=690408156)")

如果在特定的页面上写着真你就有权限。或者，只需转到主页 url 上的 robots.txt 文件，就可以更广泛地了解什么是允许的(什么是不允许的)。

方法 1

有时候网站可以用框架来组成。这些实际上是被放在一个框架集中的独立网页。我们需要在这些帧之间来回跳转。

library(RSelenium)
library(XML)
library(janitor)
library(lubridate)
library(magrittr)
library(dplyr)remDr <- remoteDriver(
  remoteServerAddr = "192.168.99.100",
  port = 4445L
)
remDr$open()# Now open TightVNC to follow along with Selenium driving the browser. Set 192.168.99.100:5901 and password: secret# navigate to the main page
remDr$navigate("[https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pub?output=html&widget=true#gid=690408156](https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pub?output=html&widget=true#gid=690408156)")# [https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pub?output=html&widget=true#gid=552987877](https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pub?output=html&widget=true#gid=552987877)# look for table element
tableElem <- remDr$findElement(using = "id", "pageswitcher-content")# switch to table
remDr$switchToFrame(tableElem)
# parse html
doc <- htmlParse(remDr$getPageSource()[[1]])
table_tmp <- readHTMLTable(doc)
table_tmp <- table_tmp[[1]][-2,-1]
table_tmp <- table_tmp[-1,]
colnames(table_tmp) <- c("team_name", "team_size", "start_time", "end_time", "total_time", "puzzels_solved")
table_tmp$city <- rep("montreal", nrow(table_tmp))
table_tmp$date <- rep(Sys.Date()-5, nrow(table_tmp))

现在我们有了第一个月，我们可以为剩下的日期创建一个 for 循环。首先让我们切换回外部框架，并选择我们将要操作的元素。

# switch back to the main/outter frame
remDr$switchToFrame(NULL)# find the elements you'll manipulate with Inspector mode in a browser
webElems <- remDr$findElements(using = "css", ".switcherItem") # Month/Year tabs at the bottom
arrowElems <- remDr$findElements(using = "css", ".switcherArrows") # Arrows to scroll left and right at the bottom
tableElem <- remDr$findElement(using = "id", "pageswitcher-content") # The inner table frame

我知道会有很多桌子，但是到底有多少呢？我们可以通过length(webElems)来检查这个。

实际上总共有 49 个表，但是从上面的第一个表开始，只有 48 个链接。与其硬编码1:48,不如通过代码来实现，因为将来会添加更多的表。

# Create NULL object to be used in forloop
big_df <- NULL
for (i in seq(length(webElems))){ # for every 
check <- try(expression, silent = TRUE) # or suppressMessages(try(expression, silent = TRUE))
if (any(class(check) == "try-error")) {
        # choose the i'th Month/Year tab 
        webElem <- webElems[[i]]
        webElem$clickElement()# Find the tableElem again other wise you get a StaleElementReference 
## TO DO: look into WebDriverWait: [https://stackoverflow.com/questions/5709204/random-element-is-no-longer-attached-to-the-dom-staleelementreferenceexception](https://stackoverflow.com/questions/5709204/random-element-is-no-longer-attached-to-the-dom-staleelementreferenceexception) 
tableElem <- remDr$findElement(using = "id", "pageswitcher-content") # The inner table frame# switch to table frame
remDr$switchToFrame(tableElem)
Sys.sleep(3)
# parse html with XML package
doc <- htmlParse(remDr$getPageSource()[[1]])
Sys.sleep(3)
# Extract data from HTML table in HTML doucment
table_tmp <- readHTMLTable(doc)
Sys.sleep(3)
# put this into a format you can use
table <- table_tmp[[1]][-2,-1]
table <- table[-1,]
# rename the columns
colnames(table) <- c("team_name", "team_size", "start_time", "end_time", "total_time", "puzzels_solved")
# add city name to a column
table$city <- rep("Montreal", nrow(table))# add the Month/Year this table was extracted from
today <- Sys.Date() %m-% months(i + 1)
table$date <- today# concatenate each table together
big_df <- dplyr::bind_rows(big_df, table)# Switch back to the main frame
remDr$switchToFrame(NULL)arrowElem <- arrowElems[[1]]
# once you "click"" the element it is "held down" as far as I know there is no way to " unclick"
# to prevent it from scrolling too far I make sure not to take too long by setting the sleep short
arrowElem$clickElement()
# give it "just enough time" to scroll right
Sys.sleep(0.3)
# switch back to outer frame to re-start the loop
remDr$switchToFrame(NULL)
        }
}temp1 <- dplyr::bind_rows(table_tmp, big_df)

这里的问题是，当 for 循环试图单击右箭头时，它最终会失败，但它已经尽可能地向右了，因此它不会下载最后几个表(~5)。通常情况下，人们会这样处理这种情况:

check <- try(expression, silent = TRUE) # or suppressMessages(try(expression, silent = TRUE))
if (any(class(check) == "try-error")) {
  # do stuff
}

它通常运行良好，包括使用硒时。然而，这里遇到的问题是，单击一次箭头总是会将我带到最后一张可见的工作表，跳过中间的所有内容。因此，我的工作是这样的:

# ctrl+x from the google sheet then use the read.delim() to assign it to an object
march <- read.delim("clipboard")
february <- read.delim("clipboard")
january <- read.delim("clipboard")
december <- read.delim("clipboard")
november <- read.delim("clipboard")# add the city and date
january$city <- rep("montreal", nrow(january))
january$date <- rep("2015-01-30", nrow(january))february$city <- rep("montreal", nrow(february))
february$date <- rep("2015-02-15", nrow(february))march$city <- rep("montreal", nrow(march))
march$date <- rep("2015-03-15", nrow(march))december$city <- rep("montreal", nrow(december))
december$date <- rep("2014-12-15", nrow(december))november$city <- rep("montreal", nrow(november))
november$date <- rep("2014-11-15", nrow(november))# clean up the column names
january %<>% janitor::clean_names()
february %<>% janitor::clean_names()
march %<>% janitor::clean_names()
december %<>% janitor::clean_names()
november %<>% janitor::clean_names()# concatenate these five dataframes together
xyz <- bind_rows(march, february, january, december, november)# convert characters into actual dates
xyz$date <-as.Date(xyz$date)# reorder the columns
xyz %<>% dplyr::select(team_name, team_size, start_time, end_time, total_time, puzzles, city, date)# rename this column to match temp1
xyz <- rename(xyz, puzzels_solved = puzzles)# change to a character
xyz$puzzels_solved <- as.character(xyz$puzzels_solved)# add NA for team size
xyz$team_size <- rep(NA, nrow(xyz))# concatenate this onto the larger dataframe
temp2 <- bind_rows(temp1, xyz)# save the object
write_csv(temp2, "puzzeld_pint_raw.csv")

方法 2

非常感谢 Nate on SO 指出了一个替代方案，解决了废弃表的任务，但没有解决上述意义上的异常处理的任务。

remDr <- RSelenium::remoteDriver(
  remoteServerAddr = "192.168.99.100",
  port = 4445L
)
remDr$open(silent = TRUE)# navigate to the main page
# needs no be done once before looping, else content is not available
remDr$navigate("https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pub?output=html&widget=true#gid=690408156")# I. Preliminaries:
# 
# 1\. build the links to all spreadsheets
# 2\. define the function create_table
# 
# 1.
# get page source
html <- remDr$getPageSource()[[1]]
# split it line by line
html <- unlist(strsplit(html, '\n'))
# restrict to script section
script <- grep('^\\s*var\\s+gidMatch', html, value = TRUE)
# split the script by semi-colon
script <- unlist(strsplit(script, ';'))
# retrieve information
sheet_months <- gsub('.*name:.{2}(.*?).{1},.*', '\\1', 
                     grep('\\{name\\s*\\:', script, value = TRUE), perl = TRUE)
sheet_gid <- gsub('.*gid:.{2}(.*?).{1},.*', '\\1', 
                  grep('\\gid\\s*\\:', script, value = TRUE), perl = TRUE)
sheet_url <- paste0('https://docs.google.com/spreadsheets/d/1o1PlLIQS8v-XSuEz1eqZB80kcJk9xg5lsbueB7mTg1U/pubhtml/sheet?headers%5Cx3dfalse&gid=',
                    sheet_gid)# 2.
# table yielding function
# just for readability in the loop
create_table <- function (remDr) {
  # parse html with XML package
  doc <- XML::htmlParse(remDr$getPageSource()[[1]])
  Sys.sleep(3)
  # Extract data from HTML table in HTML document
  table_tmp <- XML::readHTMLTable(doc)
  Sys.sleep(3)
  # put this into a format you can use
  table <- table_tmp[[1]][-2, -1]
  # add a check-up for size mismatch
  table_fields <- as.character(t(table[1,]))
  if (! any(grepl("size", tolower(table_fields)))) {
    table <- table[-1, ]
    # rename the columns
    colnames(table) <- c("team_name", "start_time", "end_time", "total_time", "puzzels_solved")
    table$team_size <- NA_integer_
    table <- table[,c("team_name", "team_size", "start_time", "end_time", "total_time", "puzzels_solved")]
  } else {
    table <- table[-1, ]
    # rename the columns
    colnames(table) <- c("team_name", "team_size", "start_time", "end_time", "total_time", "puzzels_solved")
  }
  # add city name to a column
  table$city <- rep("Montreal", nrow(table))

  # add the Month/Year this table was extracted from
  today <- Sys.Date()
  lubridate::month(today) <- lubridate::month(today)+1
  table$date <- today

  # returns the table
  table
}

# II. Scrapping the content
# 
# 1\. selenium to generate the pages
# 2\. use create_table to extract the table
# 
big_df <- NULL
for (k in seq_along(sheet_url)) {
  # 1\. navigate to the page
  remDr$navigate(sheet_url[k])
  # remDr$screenshot(display = TRUE) maybe one wants to see progress
  table <- create_table(remDr)

  # 2\. concatenate each table together
  big_df <- dplyr::bind_rows(big_df, table)

  # inform progress 
  cat(paste0('\nGathered table for: \t', sheet_months[k]))
}

# close session
remDr$close()

要执行这项任务，首先要生成文档中所有电子表格的链接。为此:

• 导航到文档一次
• 提取源代码
• 使用regex提取工作表月份和 URL(通过gid数字)
• 完成后，遍历 URL，收集并绑定表

有一个名为create_table的小函数，它以正确的格式返回最终的表格，并对列数进行安全度量(一些电子表格没有team_size字段——在这种情况下，我将其设置为NA_integer)。

如果你觉得这篇文章有用，请随意与他人分享或推荐这篇文章！😃

一如既往，如果您有任何问题或意见，请随时在下面留下您的反馈，或者您可以随时通过 LinkedIn 联系我。在那之前，下一篇文章再见！😄

5 分钟后进行网页抓取:)

原文：https://towardsdatascience.com/web-scraping-in-5-minutes-1caceca13b6c?source=collection_archive---------9-----------------------

如何从头开始构建一个基本的 web 刮刀

介绍

对于像我这样天真的人来说，做一些网络搜集是我们能找到的最相似的事情，感觉自己是世界级的黑客，从政府系统中提取一些秘密信息。

如果你想笑就笑吧，但是当你一无所有的时候，网络抓取可以给你一个数据集。当然，对于大多数情况——我们稍后将讨论例外情况……令人惊讶的是，并不是每个人都希望我们偷偷摸摸地浏览他们的网页——我们可以通过使用几个 Python 公共库来应对 web 抓取挑战:

• 【请求】 调用导入请求
• BeautifulSoup' 调用 ' 从 bs4 导入 BeautifulSoup'
• 我们可能还想使用【tqdm _ notebook】工具调用 【从 tqdm 导入 tqdm _ notebook】，以防我们需要遍历一个有几个页面的站点。例如，假设我们在搜索“数据科学家”后，试图从https://indeed.co.uk的所有职位中提取一些信息。我们可能会有几个结果页面。“bs4”库将允许我们以非常简单的方式浏览它们。我们也可以使用一个简单的 for 循环来实现，但是“tqdm_notebook”工具提供了过程演变的可视化，如果我们在一次运行中从一个站点抓取数百或数千个页面，这非常适合

但不管怎样，还是一步一步来吧。在这篇文章中，我们将搜集企鹅出版社的 100 本必读经典书籍。我们将尽力只得到每本书的标题和作者。这个简单的笔记本和其他的可以在我的 GitHub 简介中找到(包括整个关于抓取和运行分类模型的项目)。

实践应用

当我们抓取一个网站时，基本上我们是从 Python 发出一个请求，并解析每个页面返回的 HTML。如果你在想:HTML 到底是什么？或者如果你在想:废话，我不是网页设计师，我不能处理这个！不要担心，除了如何获取网页 HTML 代码和找到您想要的任何内容之外，您不需要知道任何其他内容。记住，为了这个例子，我们将寻找每本书的标题和作者:

我们可以通过以下方式访问网页 HTML 代码:

• 右键单击>检查
• 或者在 Mac 中按 Command+shift+c

屏幕右侧应该会打开一个窗口。确保站在窗口上部的“元素”选项卡上:

打开此窗口后，如果您站在网页的任何元素上，HTML 代码将自动移动，直到代码的特定部分。看看如果我把我的指针移到第一本书的标题(' 1。F. Scott Fitzgerald 的《了不起的盖茨比》(The Great Gatsby)，HTML 突出了属于网页的该部分的元素:

在这种情况下，文本似乎包含在'

url = ‘https://www.penguin.co.uk/articles/2018/100-must-read-classic-books/'r = requests.get(url)

soup = BeautifulSoup(r.text,’html.parser’)

for start in tqdm_notebook(range(0, 1000 10)): url = “https://www.indeed.co.uk/jobs?q=datascientist&start{}".format(start) r = requests.get(url) soup = BeautifulSoup(r.text,’html.parser’)

for book in soup.find_all(‘div’, attrs={‘class’:’cmp-text text’})

pattern = re.compile(r’(?<=. ).+(?=\n)’)

appender = re.findall(pattern,text)

[‘The Great Gatsby by F. Scott Fitzgerald’]

def extract_books_from_result(soup):
 returner = {‘books’: [], ‘authors’: []}
 for book in soup.find_all(‘div’, attrs={‘class’:’cmp-text text’}):

 text = book.text
 pattern = re.compile(r’(?<=. ).+(?=\n)’)
 appender = re.findall(pattern,text)[0].split(‘ by’) # Including a condition just to avoid anything that’s not a book
 # Each book should consist in a list with two elements: 
 # [0] = title and [1] = author

 if len(appender) > 1:
  returner[‘books’].append(appender[0])
  returner[‘authors’].append(appender[1])

 returner_df = pd.DataFrame(returner, columns=[‘books’,’authors’]) 

 return returner_df

url = ‘https://www.penguin.co.uk/articles/2018/100-must-read-classic-books/'r = requests.get(url)soup = BeautifulSoup(r.text,’html.parser’)results = extract_books_from_result(soup)

*#To get the url, and scrap the html page* import requests
from bs4 import BeautifulSoup*#To save the reviews in a dataframe* import pandas as pd

url = '[https://www.metacritic.com/game/switch/pokemon-sword/user-reviews?page=](https://www.metacritic.com/game/switch/pokemon-sword/user-reviews)0'

user_agent = {'User-agent': 'Mozilla/5.0'}
response = requests.get(url, headers = user_agent)

soup = BeautifulSoup(response.text, 'html.parser')

review_dict = {'name':[], 'date':[], 'rating':[], 'review':[]}

#look for review_content tags since every user review has this tag

for review in soup.find_all('div', class_='review_content'): #within review_content tag, look for the presence of longer reviewsif review.find('span', class_='blurb blurb_expanded'): review_dict['review'].append(review.find('span', class_=’blurb blurb_expanded').text)

else: review_dict[‘review’].append(review.find('div',class_='review_body').find('span').text)

sword_reviews = pd.DataFrame(review_dict)

! pip install beautifulsoup4

! pip install requests

***# importing the necessary packages*** import requests
from bs4 import BeautifulSoup

r1 = requests.get(url)
coverpage = r1.content

soup1 = BeautifulSoup(coverpage, 'html5lib')

coverpage_news = soup1.find_all('h2', class_='articulo-titulo')

coverpage_news[4].get_text()

coverpage_news[4]['href']

***# Scraping the first 5 articles***number_of_articles = 5***# Empty lists for content, links and titles*** news_contents = []
list_links = []
list_titles = []

for n in np.arange(0, number_of_articles):

 ***# only news articles (there are also albums and other things)***    if "inenglish" not in coverpage_news[n].find('a')['href']:  
        continue

 ***# Getting the link of the article***    link = coverpage_news[n].find('a')['href']
    list_links.append(link)

 ***# Getting the title***    title = coverpage_news[n].find('a').get_text()
    list_titles.append(title)

 ***# Reading the content (it is divided in paragraphs)***    article = requests.get(link)
    article_content = article.content
    soup_article = BeautifulSoup(article_content, 'html5lib')
    body = soup_article.find_all('div', class_='articulo-cuerpo')
    x = body[0].find_all('p')

 ***# Unifying the paragraphs***    list_paragraphs = []
    for p in np.arange(0, len(x)):
        paragraph = x[p].get_text()
        list_paragraphs.append(paragraph)
        final_article = " ".join(list_paragraphs)

    news_contents.append(final_article)

**#install the scrapy**
$ pip install scrapy**#install the image for downloading the product images**
$ pip install image**#start web scraping project with scraps**
$ scrapy startproject **fashionWebScraping**
$ cd **fashionWebScraping**
$ ls**#create project folders which are explained below**
$ mkdir csvFiles
$ mkdir images_scraped
$ mkdir jsonFiles
$ mkdir utilityScripts

[https://www.derimod.com.tr/kadin-canta-aksesuar/?page=1](https://www.derimod.com.tr/kadin-canta-aksesuar/?p=1)

***#items.py in fashionWebScraping folder**
import scrapy
from scrapy.item import Item, Fieldclass FashionwebscrapingItem(scrapy.Item):

 **#product related items, such as id,name,price**
 gender=Field()
 productId=Field()
 productName=Field()
 priceOriginal=Field()
 priceSale=Field()**#items to store links**
 imageLink = Field()
 productLink=Field()**#item for company name**
 company = Field()passclass ImgData(Item):**#image pipline items to download product images**
 image_urls=scrapy.Field()
 images=scrapy.Field()*

****# settings.py in fashionWebScraping folder
# Scrapy settings for fashionWebScraping project****# For simplicity, this file contains only settings considered important or commonly used. You can find more settings consulting the documentation:****#** [**https://doc.scrapy.org/en/latest/topics/settings.html**](https://doc.scrapy.org/en/latest/topics/settings.html) **#** [**https://doc.scrapy.org/en/latest/topics/downloader-middleware.html**](https://doc.scrapy.org/en/latest/topics/downloader-middleware.html) **#** [**https://doc.scrapy.org/en/latest/topics/spider-middleware.html**](https://doc.scrapy.org/en/latest/topics/spider-middleware.html)BOT_NAME = 'fashionWebScraping'
SPIDER_MODULES = ['fashionWebScraping.spiders']
NEWSPIDER_MODULE = 'fashionWebScraping.spiders'**# Crawl responsibly by identifying yourself (and your website) on the user-agent**
USER_AGENT = 'fashionWebScraping'**# Obey robots.txt rules**
ROBOTSTXT_OBEY = True**# See** [**https://doc.scrapy.org/en/latest/topics/settings.html**](https://doc.scrapy.org/en/latest/topics/settings.html) **# download-delay
# See also autothrottle settings and docs
# This to avoid hitting servers too hard** DOWNLOAD_DELAY = 1**# Override the default request headers:** DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'tr',
}**# Configure item pipelines
# See** [**https://doc.scrapy.org/en/latest/topics/item-pipeline.html**](https://doc.scrapy.org/en/latest/topics/item-pipeline.html)ITEM_PIPELINES = {'scrapy.pipelines.images.ImagesPipeline': 1}IMAGES_STORE = '/Users/erdemisbilen/Angular/fashionWebScraping/images_scraped'**

****fashionWebScraping $** scrapy genspider fashionBOYNER boyner.com
*Created spider ‘fashionBOYNER’ using template ‘basic’ in module:
fashionWebScraping.spiders.fashionBOYNER***

****# 'fashionBOYNER.py' in fashionWebScraping/Spiders folder****# import scrapy and scrapy items**
import scrapy
from fashionWebScraping.items import FashionwebscrapingItem
from fashionWebScraping.items import ImgData
from scrapy.http import Request**# To read from a csv file**
import csvclass FashionboynerSpider(scrapy.Spider):
 name = 'fashionBOYNER'
 allowed_domains = ['BOYNER.com']
 start_urls = ['http://BOYNER.com/']**# This function helps us to scrape the whole content of the website
 # by following the starting URLs in a csv file.**def start_requests(self):**# Read main category URLs from a csv file**with open ("/Users/erdemisbilen/Angular/fashionWebScraping/
  csvFiles/SpiderMainCategoryLinksBOYNER.csv", "rU") as f:

    reader=csv.DictReader(f)for row in reader:
      url=row['url']**# Change the page value incrementally to navigate through
      the product list
      # You can play with the range value according to maximum  
      product quantity, 30 pages to scrape as default**
      link_urls = [url.format(i) for i in range(1,30)]for link_url in link_urls:
        print(link_url)**# Pass the each link containing products to 
        parse_ product_pages function with the gender metadata**request=Request(link_url, callback=self.parse_product_pages,
        meta={'gender': row['gender']})yield request**# This function scrapes the page with the help of xpath provided**
 def parse_product_pages(self,response):

  item=FashionwebscrapingItem()

 **# Get the HTML block where all the products are listed
  # <div> HTML element with the "product-list-item" class name**content=response.xpath('//div[starts-with(@class,"product-list-
  item")]')**# loop through the each <div> element in the content**
  for product_content in content:image_urls = []**# get the product details and populate the items**
   item['productId']=product_content.xpath('.//a/@data
   -id').extract_first()item['productName']=product_content.xpath('.//img/@title').
   extract_first()item['priceSale']=product_content.xpath('.//ins[@class=
   "price-payable"]/text()').extract_first()item['priceOriginal']=product_content.xpath('.//del[@class=
   "price-psfx"]/text()').extract_first()if item['priceOriginal']==None:
    item['priceOriginal']=item['priceSale']item['imageLink']=product_content.xpath('.//img/
   @data-original').extract_first()

   item['productLink']="https://www.boyner.com.tr"+
   product_content.xpath('.//a/@href').extract_first()image_urls.append(item['imageLink'])item['company']="BOYNER"
   item['gender']=response.meta['gender']if item['productId']==None:
    breakyield (item)**# download the image contained in image_urls**
   yield ImgData(image_urls=image_urls)def parse(self, response):
  pass**

****#  // Selects nodes in the document from the current node that matches the selection no matter where they are****# '//div[starts-with(@class,"product-list-item")]' selects the all div elements which has class value start**content = response.xpath('//div[starts-with(@class,"product-list-item")]')**

****# loop through the each <div> element in the content**
  for product_content in content:image_urls = []**# get the product details and populate the items

   # ('.//a/@data-id') extracts 'data-id' value of <a> element
   inside the product_content** item['productId']=product_content.xpath('.//a/@data
   -id').extract_first()**# ('.//img/@title') extracts 'title' value of <img> element
   inside the product_content**   
   item['productName']=product_content.xpath('.//img/@title').
   extract_first()**# ('.//ins[@class= "price-payable"]/text()') extracts text value
   of <ins> element which has 'price-payable' class attribute inside
   the product_content **  
   item['priceSale']=product_content.xpath('.//ins[@class=
   "price-payable"]/text()').extract_first()**# ('.//del[@class="price-psfx"]/text()') extracts text value
   of <del> element which has 'price-psfx' class attribute inside
   the product_content**
   item['priceOriginal']=product_content.xpath('.//del[@class=
   "price-psfx"]/text()').extract_first()if item['priceOriginal']==None:
     item['priceOriginal']=item['priceSale']**# ('.//img/@data-original') extracts 'data-original' value of
   <img> element inside the product_content**
   item['imageLink']=product_content.xpath('.//img/
   @data-original').extract_first()**# ('.//a/@href') extracts 'href' value of
   <a> element inside the product_content
**   item['productLink']="https://www.boyner.com.tr"+
   product_content.xpath('.//a/@href').extract_first()**# assigns the product image link into the 'image_urls' which is
   defined in the image pipeline**
   image_urls.append(item['imageLink'])item['company']="BOYNER"
   item['gender']=response.meta['gender']if item['productId']==None:
    breakyield (item)

   **# download the image contained in image_urls**
   yield ImgData(image_urls=image_urls)**

****fashionWebScraping $** scrapy crawl -o rawdata_BOYNER.json -t jsonlines fashionBOYNER**

**# **‘jsonPrep.py’ in fashionWebScraping/utilityScripts folder**
import json
import sys
from collections import OrderedDict
import csv
import os**# Reads from jsonFiles.csv file for the names and locations of all json files need to be validated** 
with open("/Users/erdemisbilen/Angular/fashionWebScraping/csvFiles/ jsonFiles.csv", "rU") as f:reader=csv.DictReader(f)**# Iterates the json files listed in jsonFiles.csv**
 for row in reader:

 ** # Reads from jsonFiles.csv file for jsonFile_raw column**
  jsonFile=row['jsonFile_raw']**# Opens the jsonFile**
   with open(jsonFile) as json_file:
    data = []
    i = 0seen = OrderedDict()

    **# Iterates in the rows of json file**
    for d in json_file:
     seen = json.loads(d)**# Do not include the line item if the product Id is null
**     try:
      if seen["productId"] != None:
       for key, value in seen.items():
        print("ok")
        i = i + 1
        data.append(json.loads(d))

     except KeyError:
      print("nok")

    print (i)

    baseFileName=os.path.splitext(jsonFile)[0]**# Write the result as a json file by reading filename from the
    'file_name_prep' column** with open('/Users/erdemisbilen/Angular/fashionWebScraping/
    jsonFiles/'+row['file_name_prep'], 'w') as out:json.dump(data, out)**

****# 'deldub.py' in fashionWebScraping/utilityScripts folder**
import json
import sys
from collections import OrderedDict
import csv
import os**# Reads from jsonFiles.csv file for the names and locations of all json files need to be validated for dublicate lines**with open("/Users/erdemisbilen/Angular/fashionWebScraping/csvFiles/ jsonFiles.csv", newline=None) as f:

 reader=csv.DictReader(f)**# Iterates the json files listed in jsonFiles.csv**
 for row in reader:**# Reads from jsonFiles.csv file for jsonFile_raw column**
  jsonFile=row['jsonFile_prep']**# Opens the jsonFile**
  with open(jsonFile) as json_file:
   data = json.load(json_file)seen = OrderedDict()
   dubs = OrderedDict()**# Iterates in the rows of json file**
   for d in data:
    oid = d["productId"]**# Don't include the item if the product Id has dublicate value**
    if oid not in seen:
     seen[oid] = delse:
     dubs[oid]=dbaseFileName=os.path.splitext(jsonFile)[0]**# Write the result as a json file by reading filename from the
     'file_name_final' column**with open('/Users/erdemisbilen/Angular/fashionWebScraping/
     jsonFiles/'+row['file_name_final'], 'w') as out:
      json.dump(list(seen.values()), out)with open('/Users/erdemisbilen/Angular/fashionWebScraping/
     jsonFiles/'+'DELETED'+row['file_name_final'], 'w') as out:
      json.dump(list(dubs.values()), out)**

$ python3 --version
Python 3.7.3$ virtualenv --version
15.2.0$ cd /path/to/my/airflow/workspace$ virtualenv -p `which python3` venv
$ source venv/bin/activate(venv) $ pip install apache-airflow
(venv) $ mkdir airflow_home
(venv) $ export AIRFLOW_HOME=`pwd`/airflow_home
(venv) $ airflow initdb
(venv) $ airflow webserver

(venv) $ mkdir dags

**# 'fashionsearch_dag.py' in Airflow dag folder**
import datetime as dt
from airflow import DAG
from airflow.operators.bash_operator import BashOperator
from datetime import datetime, timedeltadefault_args = {
'owner': 'airflow',
'depends_on_past': False,
'start_date': datetime(2019, 11, 23),
'retries': 1,
'retry_delay': timedelta(minutes=5),# 'queue': 'bash_queue',
# 'pool': 'backfill',
# 'priority_weight': 10,
# 'end_date': datetime(2016, 1, 1),
}dag = DAG(dag_id='fashionsearch_dag', default_args=default_args, schedule_interval=timedelta(days=1))**# This task deletes all json files which are generated in previous scraping sessions**
t1 = BashOperator(
task_id='delete_json_files',
bash_command='run_delete_files',
dag=dag)**# This task runs the spider for** [**www.boyner.com**](http://www.boyner.com) **# And populates the related json file with data scraped**
t2 = BashOperator(
task_id='boyner_spider',
bash_command='run_boyner_spider',
dag=dag)**# This task runs the spider for** [**www.derimod.com**](http://www.derimod.com) **# And populates the related json file with data scraped**
t3 = BashOperator(
task_id='derimod_spider',
bash_command='run_derimod_spider',
dag=dag)**# This task runs the spider for** [**www.hepsiburada.com**](http://www.hepsiburada.com) **# And populates the related json file with data scraped**
t4 = BashOperator(
task_id='hepsiburada_spider',
bash_command='run_hepsiburada_spider',
dag=dag)**# This task runs the spider for** [**www.hm.com**](http://www.hm.com) **# And populates the related json file with data scraped**
t5 = BashOperator(
task_id='hm_spider',
bash_command='run_hm_spider',
dag=dag)**# This task runs the spider for** [**www.koton.com**](http://www.koton.com) **# And populates the related json file with data scraped**
t6 = BashOperator(
task_id='koton_spider',
bash_command='run_koton_spider',
dag=dag)**# This task runs the spider for** [**www.lcwaikiki.com**](http://www.lcwaikiki.com) **# And populates the related json file with data scraped**
t7 = BashOperator(
task_id='lcwaikiki_spider',
bash_command='run_lcwaikiki_spider',
dag=dag)**# This task runs the spider for** [**www.matmazel.com**](http://www.matmazel.com) **# And populates the related json file with data scraped**
t8 = BashOperator(
task_id='matmazel_spider',
bash_command='run_matmazel_spider',
dag=dag)**# This task runs the spider for** [**www.modanisa.com**](http://www.modanisa.com) **# And populates the related json file with data scraped**
t9 = BashOperator(
task_id='modanisa_spider',
bash_command='run_modanisa_spider',
dag=dag)**# This task runs the spider for** [**www.morhipo.com**](http://www.morhipo.com) **# And populates the related json file with data scraped**
t10 = BashOperator(
task_id='morhipo_spider',
bash_command='run_morhipo_spider',
dag=dag)**# This task runs the spider for** [**www.mudo.com**](http://www.mudo.com) **# And populates the related json file with data scraped**
t11 = BashOperator(
task_id='mudo_spider',
bash_command='run_mudo_spider',
dag=dag)**# This task runs the spider for** [**www.trendyol.com**](http://www.trendyol.com) **# And populates the related json file with data scraped**
t12 = BashOperator(
task_id='trendyol_spider',
bash_command='run_trendyol_spider',
dag=dag)**# This task runs the spider for** [**www.yargici.com**](http://www.yargici.com) **# And populates the related json file with data scraped**
t13 = BashOperator(
task_id='yargici_spider',
bash_command='run_yargici_spider',
dag=dag)**# This task checks and removes null line items in json files**
t14 = BashOperator(
task_id='prep_jsons',
bash_command='run_prep_jsons',
dag=dag)**# This task checks and removes dublicate line items in json files**
t15 = BashOperator(
task_id='delete_dublicate_lines',
bash_command='run_del_dub_lines',
dag=dag)**# This task populates the remote ES clusters with the data inside the JSON files**
t16 = BashOperator(
task_id='json_to_elasticsearch',
bash_command='run_json_to_es',
dag=dag)**# With sequential executer, all tasks depends on previous task
# No paralell task execution is possible
# Use local executer at least for paralell task execution**t1 >> t2 >> t3 >> t4 >> t5 >> t6 >> t7 >> t8 >> t9 >> t10 >> t11 >> t12 >> t13 >> t14 >> t15 >> t16

(venv) $ airflow scheduler

pipinstallbeautifulsoup4

from urllib.request import urlopen
from bs4 import BeautifulSoup

url = "[https://www.bbc.com/sport/football/46897172](https://www.bbc.com/sport/football/46897172)"

# We use try-except incase the request was unsuccessful because of 
# wrong URL
try:
   page = urlopen(url)
except:
   print("Error opening the URL")

soup = BeautifulSoup(page, 'html.parser')

content = soup.find('div', {"class": "story-body sp-story-body gel-      body-copy"})

article = ''
for i in content.findAll('p'):
    article = article + ' ' +  i.text

with open('scraped_text.txt', 'w') as file:
    file.write(article)

 Cristiano Ronaldo’s header was enough for Juventus to beat AC Milan and claim a record eighth Supercoppa Italiana in a game played in Jeddah, Saudi Arabia. The Portugal forward nodded in Miralem Pjanic’s lofted pass in the second half to settle a meeting between Italian football’s two most successful clubs. It was Ronaldo’s 16th goal of the season for the Serie A leaders. Patrick Cutrone hit the crossbar for Milan, who had Ivorian midfielder Franck Kessie sent off. Gonzalo Higuain, reportedly the subject of interest from Chelsea, was introduced as a substitute by Milan boss Gennaro Gattuso in Italy’s version of the Community Shield. But the 31-year-old Argentina forward, who is currently on loan from Juventus, was unable to deliver an equalising goal for the Rossoneri, who were beaten 4–0 by Juve in the Coppa Italia final in May.

import requests
from bs4 import BeautifulSoup

url = ‘[https://www.ratemyprofessors.com/ShowRatings.jsp?tid=1986099'](https://www.ratemyprofessors.com/ShowRatings.jsp?tid=1986099')

page = requests.get(url)
page**<Response [200]>**

soup = BeautifulSoup(page.text, “html.parser”)

proftags = soup.findAll(“span”, {“class”: “tag-box-choosetags” })
proftags**[<span class=”tag-box-choosetags”> Hilarious <b>(11)</b></span>, <span class=”tag-box-choosetags”> Caring <b>(9)</b></span>, 
<span class=”tag-box-choosetags”> Accessible outside class <b>(8)</b></span>, 
<span class=”tag-box-choosetags”> Amazing lectures <b>(5)</b></span>, 
<span class=”tag-box-choosetags”> Clear grading criteria <b>(4)</b></span>, 
<span class=”tag-box-choosetags”> Inspirational <b>(4)</b></span>, <span class=”tag-box-choosetags”> Group projects <b>(3)</b></span>, <span class=”tag-box-choosetags”> Respected <b>(3)</b></span>, 
<span class=”tag-box-choosetags”> Gives good feedback <b>(2)</b></span>, 
<span class=”tag-box-choosetags”> EXTRA CREDIT <b>(2)</b></span>, <span class=”tag-box-choosetags”> Participation matters <b>(1)</b></span>, 
<span class=”tag-box-choosetags”> Lecture heavy <b>(1)</b></span>, <span class=”tag-box-choosetags”> Test heavy <b>(1)</b></span>, <span class=”tag-box-choosetags”> So many papers <b>(1)</b></span>]**

for mytag in proftags:
  print(mytag.get_text())**Hilarious (11)  
Caring (9)  
Accessible outside class (8)  
Amazing lectures (5)  
Clear grading criteria (4)  
Inspirational (4)  
Group projects (3)  
Respected (3)  
Gives good feedback (2)  
EXTRA CREDIT (2)  
Participation matters (1)  
Lecture heavy (1)  
Test heavy (1)  
So many papers (1)**

session = requests.Session()

>>> session.headers['User-Agent']
'python-requests/2.19.1'

my_headers = {"User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS
          X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko)
          Chrome/71.0.3578.98 Safari/537.36", 
          "Accept":"text/html,application/xhtml+xml,application/xml;
          q=0.9,image/webp,image/apng,*/*;q=0.8"}

url = '[https://communityfoundations.ca/find-a-community-foundation/'](https://communityfoundations.ca/find-a-community-foundation/')
response = session.get(url, headers=my_headers)

html_soup = BeautifulSoup(response.text, 'html.parser')

container = html_soup.find_all(["h2", "h3"], 
                               class_=lambda x: x != 'hidden')for lines in container:
    if lines.name == 'h2': 
        province = lines.text
        print('In', province, "\n")
    if lines.name == 'h3':
        foundation = lines.text
        print('Foundation name:', foundation)   
        print('Foundation url:', lines.find_all("a", 
            href=re.compile("cfc_locations"))[0].get('href'), "\n")

subresponse = []for lines in container:
    if lines.name == 'h3': 
        url_fou = lines.find_all("a",
                  href=re.compile("cfc_locations"))[0].get('href')
        subresponse.append(session.get(url_fou, 
                                       headers=my_headers))
        time.sleep(10)

html_subsoup = []for counter in range(1, len(subresponse)):
     html_subsoup.append(BeautifulSoup(subresponse[counter].text, 
                                      'html.parser'))
     c_location = html_subsoup[counter].find_all('p', 
                                      class_='meta-line location')
     address_array = re.split(r' \| ', c_location[0].text)
     print(address_array)

>>> genderDict = {"male": 'Mr.',
                  "female": 'Ms.'}
>>> gen = Genderize().get(['John'])[0]['gender']
>>> print(genderDict.get(gen, "None"))Mr.

df = pd.DataFrame({'Organization': organization,
                   'Title': gender_title,
                   'Addressee': person,
                   'Addressee Job Title': person_title,
                   'Civic Address 1 (Street Address)': street,
                   'Civic Address 2 (PO Box)': pobox,
                   'Municipality': municipality,
                   'Province or Territory': provinces, 
                   'Postal Code': postalCode,
                   'Phone': phone,
                   'Website': org_url
                   })cols = ['Organization', 'Title', {add in here the others}]df.to_csv('data/cfcMailingAddresses.csv', encoding='utf-8',
          index=False, columns=cols)

def preprocess_without_stopwords(sent):
    sent = nltk.word_tokenize(sent)
    sent = [word for word in sent if word not in en_stop]
    sent = nltk.pos_tag(sent)
    return sentpreprocessed_address = preprocess_without_stopwords(address_test)

addr = nlp(address_test)
sentences = [x for x in addr.sents]
displacy.render(nlp(str(sentences[0])), jupyter=True, style='ent')

*# robots.txt for [http://www.wikipedia.org/](http://www.wikipedia.org/) and friends
#
# Please note: There are a lot of pages on this site, and there are
# some misbehaved spiders out there that go _way_ too fast. If you're
# irresponsible, your access to the site may be blocked.*

*User-agent: *
Disallow: /*

*{
 “text”:”Apple was founded by Steve Jobs, Steve Wozniak and Ronald Wayne.”,
 “language”:”en”,
 “concepts”:{
 “http://dbpedia.org/resource/Apple_Inc.":{
 “surfaceForms”:[
 {
 “string”:”Apple”,
 “score”:0.9994597361117074,
 “offset”:0
 }
 ],
 “types”:[
 “http://www.wikidata.org/entity/Q43229”,
 “http://schema.org/Organization",
 “http://dbpedia.org/ontology/Organisation",
 “http://dbpedia.org/ontology/Company"
 ],
 “support”:10626
 }
 }
}*

*****SELECT publication_date, count(id) AS num 
FROM articles 
GROUP BY publication_date 
ORDER BY publication_date;*****

*****SELECT gender, count(ID) 
FROM authors 
GROUP BY gender;*****

*****SELECT country, count(affiliation_id) AS counter
FROM affiliations 
GROUP BY country 
ORDER BY counter DESC;*****

*****SELECT CONCAT(authors.first_name,” “, authors.last_name) AS name, SUM(articles.citations) AS num_citations 
FROM authors JOIN authors_article_junction JOIN articles
WHERE authors_article_junction.author_ID = authors.ID AND articles.ID = authors_article_junction.article_ID 
 AND authors_article_junction.importance = 1 
GROUP BY authors.ID 
ORDER BY num_citations DESC 
LIMIT 10;*****

*****SELECT keywords.keyword_name, COUNT(keywords_ID) AS num 
FROM keyword_article_junction JOIN keywords 
WHERE keyword_article_junction.keywords_ID = keywords.ID 
GROUP BY keywords.keyword_name 
ORDER BY num DESC 
LIMIT 20;*****

cd .data
git clone [https://github.com/pjreddie/darknet.git](https://github.com/pjreddie/darknet.git)
cd darknet
make

# execute in the ./darkent directory
wget [https://pjreddie.com/media/files/darknet19.weights](https://pjreddie.com/media/files/darknet19.weights)
wget [https://pjreddie.com/media/files/yolov3-tiny.weights](https://pjreddie.com/media/files/yolov3-tiny.weights)

[@bot](http://twitter.com/bot).message_handler(content_types=['photo'])
def handle(message): # extract the image name for further operations
  image_name = save_image_from_message(message)

  # execute object recognition
  object_recognition_image(image_name) # send object recognition results
  bot.send_photo(message.chat.id, open('.data/darknet/predictions.jpg','rb'), 'Identified objects')

  # execute image classification
  classification_list_result = classify_image(image_name)

  # send classification results
  output = 'The image classifies as:\n'
  for result in classification_list_result:
    output += result
  output += '\n🚀 Gimme more pics! 🚀'

  bot.reply_to(message, output)

  # remove picture from server
  cleanup_remove_image(image_name);