如何利用自然语言处理分析产品评论？
在这篇文章中，我将展示如何使用自然语言处理从产品评论中提取关键词(方面)。这个想法实质上是试图复制亚马逊对评论所做的事情。例如，在下图中，你可以看到亚马逊从给定产品的评论中提取关键词，然后允许用户通过这些关键词搜索评论。
Aspect Based Search in Amazon.in
我将试着复制这些关键词产生的过程，然后这些关键词可以用来做各种各样的任务，从基于方面的搜索到基于方面的情感分析。让我们开始吧。
NLP:这是什么？
在我们开始方面提取的任务之前。我们先来了解一下什么是自然语言处理。
NLP，是让计算机理解人类语言的一种尝试。计算机很容易理解编程语言。但是我们如何确保计算机能够理解人类语言呢？要理解 NLP，我们先来了解一下有哪些重大任务可以归为 NLP 任务。
1.**标记化:**人类可以阅读和理解语言，因为我们可以很容易地识别给定文档中的单词、句子、段落等。大多数 NLP 框架允许计算机理解文本的哪些部分是单词、句子或段落。
2.**词性标注:**另一个，语言理解的特点是人类能够识别语言中语法成分的能力。例如，我们可以很容易地在给定的句子中找出哪个词充当动词、名词或代词等。NLP 框架允许计算机识别文本中每个单词的语法功能。
3.**依存解析:**当我们看任何一个句子时，我们不仅能够识别语法元素，还能够识别这些元素在给定句子中是如何以什么是“主语”和什么是“宾语”的形式相互关联的。我们也理解什么是句子中的名词短语，以及它如何与给定句子中的其他短语和单词相关联。NLP 工具包也有助于完成这项任务。
4.**共指解析:**人类能够轻松破译代词与句子中不同语法元素的关系。例如在文本中
“莫迪指责反对双重标准。他今天在议会提出了这一指控”
我们知道第二句中的“他”指的是莫迪。使用 NLP 框架，人们可以很容易地建立规则来理解文本中的哪个代词指代哪个名词或者与哪个名词短语相关。
5.**命名实体识别:**对于我们来说，判断一个句子中的单词是否指人、地点、日期、公司实体等是非常自然的。即使我们以前没有见过一个单词，我们也能够正确地猜出这个单词所指的是哪个实体。例如在下面的句子中:
“协和女神宣布给股东 3000 万美元的股息”
虽然我们可能从未听说过“Concordia”是一家公司，但我们仍然可以从句子的上下文中合理地说它是一个公司实体。NLP 框架还有助于计算机理解给定单词所指的“实体”。
提取关键词(方面)
为了复制 amazon 所做的，我将展示如何提取关键字。我将依靠基于规则的方法，这将利用评论的语法结构。这种方法正常工作的假设是，注释一般是以尊重语法规则的方式编写的。我们将使用的语法规则是:
去掉了常用词的文本中最常用的名词将显示文本中的关键词(方面)
为了在产品评论的语料库上实现这个规则，将需要以下预处理。
- 从语料库中提取单词标记。
- 删除常用词
- 提取所有名词
- 找出前 5 个最常用的名词，这些将是关键词/方面
我使用 spacy 来实现我的 NLP 管道。
下面是我写的函数，用于从关于某个特定产品的评论中提取方面，这个产品是一个非常受欢迎的手机品牌。这些评论是由班加罗尔竖锯学院一个学期项目的学生团队收集的。(https://www.jigsawacademy.com/
现场演示:
这里可以看到一个现场演示http://ec2-18-188-32-93 . us-east-2 . compute . Amazon AWS . com:8051/(这是一个比较小的机器，不要征税太多！！！)
下一步？
一旦你能够从产品评论中识别方面，你可以尝试建立一个基于 方面的搜索 或者甚至可以尝试做一个基于 方面的情感 分析。基于方面的情感分析可以用来找出人们对产品不同特性的感受。例如，人们是否普遍对手机的电池寿命感到满意。你可以把这段代码扩展成这样。
如何利用噪音成为你的优势？
Photo by Jason Rosewell on Unsplash
噪音是工程师的头号敌人。
对科学家来说，随机波动或噪声是不受欢迎的。
虽然通常被认为会降低性能，但它有时可以改善非线性系统中的信息处理。在这篇文章中，我们将看到一些例子，噪音可以被用来作为一种优势。
示例 1
向神经网络中添加噪声
最近的工作表明，通过在训练深度神经网络时允许一些不准确性，不仅可以提高训练性能，而且可以提高模型的准确性。
神经网络能够学习输出函数，该函数可以随着输入的微小变化而剧烈变化。向输入中随机添加噪声就像告诉网络不要在你的精确输入周围改变输出。
通过限制网络中的信息量，我们迫使它学习 输入特征的紧凑表示 。
- 变分自动编码器 (VAE) 给隐藏层添加高斯噪声。
- 具有随机深度的深度网络 :类似于 dropout 的概念，但在每层级别而不是每单元级别。
示例 2
更好地探索参数噪声
RL 是机器学习的一个区域，假设有一个 代理 位于 环境 中。在每一步，代理采取一个 动作 ，并从环境中接收一个 观察 和 奖励 。
给定一个先前未知的环境，RL 算法通过一个通常涉及大量试错的学习过程来寻求最大化代理的总报酬。
为了理解深度 RL 系统探索中的挑战，想想那些在实验室中花费大量时间却没有产生任何实际应用的研究人员。等价地，RL 代理可以花费大量的资源而不收敛到局部最优。
OpenAI 提出了一种称为参数空间噪声的技术，在每集开始时在模型策略参数中引入噪声。
其他方法集中在所谓的动作-空间-噪声上，它们引入噪声来改变与代理从一个时刻到下一个时刻可能采取的每个动作相关联的可能性。
Action-Space-Noise (left) and Parameter-Space-Noise (right)
“我们发现，向强化学习算法的参数中添加自适应噪声经常会提高性能”——open ai
参数-空间-噪声模型的初步结果证明是很有希望的。这项技术有助于算法更有效地探索它们的环境，从而获得更高的分数和更优雅的行为。更多细节可以在研究论文中找到。
要记住的重要事情是，添加噪声被用作提高强化学习算法的探索性能的优势。
示例 3
从有噪声的标签中学习(弱监督训练)
提高识别率并不像向这些系统投放更多标签图像那么简单。事实上，手动注释大量图像是一个昂贵且耗时的过程。
脸书的研究人员和工程师通过在大量带有标签的公共图像上训练图像识别网络来解决这个问题。
由于人们经常给他们的照片加上标签，这将是一个很好的模型训练数据来源。
脸书开发了新的方法，专门用于使用标签监督进行图像识别实验。这项研究在探索弱监督预培训的限制中有详细描述
在 COCO 对象检测挑战中，已经表明使用 hashtags 进行预训练可以将模型的平均精度提高 2%以上。
“标签可以帮助计算机视觉系统超越一般的分类术语，以识别图像中的特定子类别和附加元素。”——脸书
结论
噪音不应该是我们的敌人！它并不总是一种不必要的干扰，经常可以被用作一种优势，甚至是一种有价值的研究工具。如果有人试图告诉你不同的说法，那么，就给他我们提供的例子…
请继续关注，如果你喜欢这篇文章，请留下👏！
参考
[1]弱监督预训练:https://research . FB . com/publications/exploring-the-limits-of-Weakly-supervised-pre training/
[2]带参数噪声的更好探索:https://blog . open ai . com/Better-Exploration-with-Parameter-Noise/
如何在你的电脑上使用 PySpark
我发现对于大多数人来说，在本地机器上开始使用 Apache Spark(这里将重点介绍 PySpark)有点困难。有了这个简单的教程，你会很快到达那里！
https://www.mytectra.com/apache-spark-and-scala-training.html
我假设您知道 Apache Spark 是什么，PySpark 也是什么，但是如果您有问题，请不要介意问我！哦，你可以在这里查看我不久前做的一个快速介绍。
$符号将表示在 shell 中运行(但不要复制该符号)。
在 Jupyter 运行 PySpark
- 安装 Jupyter 笔记本
$ pip install jupyter
2.安装 PySpark
确保您的计算机上安装了 Java 8 或更高版本。当然，你也会需要 Python(我推荐 Anaconda 的> Python 3.5)。
现在访问 Spark 下载页面。选择最新的 Spark 版本，这是一个针对 Hadoop 的预构建包，并直接下载。
如果你想得到蜂巢的支持或者更多有趣的东西，你必须自己建立你的星火分布-> 建立星火。
将其解压缩并移动到/opt 文件夹中:
$ tar -xzf spark-2.3.0-bin-hadoop2.7.tgz
$ mv spark-2.3.0-bin-hadoop2.7 /opt/spark-2.3.0
创建一个符号链接(这将让您拥有多个 spark 版本):
$ ln -s /opt/spark-2.3.0 /opt/spark̀
最后，告诉你的 bash(或 zsh 等。)哪里找火花。为此，通过在~/中添加以下行来配置$PATH 变量。bashrc(或者~/。zshrc)文件:
export SPARK_HOME=/opt/spark
export PATH=$SPARK_HOME/bin:$PATH
现在要在 Jupyter 中运行 PySpark，您需要更新 PySpark 驱动程序环境变量。就把这几行加到你的/。bashrc(或者/。zshrc)文件:
export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS='notebook'
重启你的终端并启动 PySpark:
$ pyspark
现在，这个命令应该在您的 web 浏览器中启动一个 Jupyter 笔记本。点击“新建”>“笔记本 Python[默认]”，创建一个新的笔记本。瞧，您的计算机中有一个 SparkContext 和 SqlContext(或 Spark > 2.x 的 SparkSession ),可以在笔记本中运行 PySpark(运行一些示例来测试您的环境)。
在您最喜欢的 IDE 上运行 PySpark
有时候你需要一个完整的 IDE 来创建更复杂的代码，PySpark 默认不在 sys.path 上，但这并不意味着它不能作为一个常规库使用。您可以通过在运行时将 PySpark 添加到 sys.path 来解决这个问题。findspark 包会帮你做到这一点。
要安装 findspark，只需输入:
$ pip install findspark
然后在您的 IDE 上(我使用 PyCharm)初始化 PySpark，只需调用:
import findspark
findspark.init()import pyspark
sc = pyspark.SparkContext(appName="myAppName")
仅此而已。很简单，对吧？下面是一个完整的独立应用程序示例，用于在本地测试 PySpark(使用上面解释的 conf):
如果你有什么要补充的，或者只是有问题，请提出来，我会尽力帮助你。
编辑由于贡献巨大:)——————>>
Jupyter 笔记本 Python，Scala，R，Spark，Mesos 栈
Docker 就像一个轻量级的“虚拟机”(Docker 技术上提供的是“映像”和“容器”而不是虚拟机。)，就好像您有一台完整的第二台计算机，它有自己的操作系统和文件，就在您的真实计算机中。您可以从您的真实计算机登录到这台机器，并像通过 ssh 登录到另一台远程计算机一样使用它。
Docker-stacks——Docker 中现成的 Jupyter 应用程序的自以为是的堆栈。
github.com](https://github.com/jupyter/docker-stacks/tree/master/all-spark-notebook)
只需到那里并按照步骤操作，就可以获得 Spark 的完整“容器化”版本(2.3 和 Hadoop 2.7)
基本用途
以下命令启动一个容器，笔记本服务器使用随机生成的身份验证令牌在端口 8888 上侦听 HTTP 连接。
$ docker run -it --rm -p 8888:8888 jupyter/pyspark-notebook
Pip 安装
这种打包目前是试验性的，在未来的版本中可能会改变(尽管我们会尽最大努力保持兼容性)。
Spark 的 Python 打包并不打算取代所有其他用例。Spark 的 Python 打包版本适合与现有集群(无论是 Spark standalone、YARN 还是 Mesos)进行交互，但不包含设置您自己的独立 Spark 集群所需的工具。
要安装它，只需运行:
$ pip install pyspark
最初发布在我的 LinkedIn 上。
如果您想联系我，请务必在 twitter 上关注我:
Favio Vázquez 的最新推文(@FavioVaz)。数据科学家。物理学家和计算工程师。我有一个…
twitter.com](https://twitter.com/faviovaz)
资源:
如何使用 Python 为您的研究计算样本大小
数据科学家普遍认为，你 80%的时间花在清理数据上，而 20%的时间花在实际分析上。
在做实证研究时，也有类似的问题:通常，在你进入有趣的部分(即看到和解释结果)之前，有大量的工作要做。
实证研究中一个重要的前期活动是计算出你需要的样本量。这一点至关重要，因为它会显著影响您的研究成本和结果的可靠性。收集太多样本:你浪费了金钱和时间。收集太少:你的结果可能没用。
了解您需要的样本大小取决于您计划使用的统计测试。如果这是一个简单的测试，那么找到想要的样本量只需要将数字代入一个等式。然而，它可以更复杂，在这种情况下，像 Python 这样的编程语言可以使生活变得更容易。在这篇文章中，我将讲述其中一个更困难的案例。
场景是这样的 :你正在研究一项旨在增加进入你商店的女性比例的营销活动(比如，改变招牌)。假设你想知道这一变化是否真的增加了女性走过的比例。你计划在改变标志之前和之后收集数据，并确定是否有差异。您将使用一个 双比例 Z 测试 来比较两个比例。您不确定需要多长时间来收集数据以获得可靠的结果——您首先必须计算出需要多少样本！
两比例 Z 检验概述
确定所需样本量的第一步是了解您将使用的静态测试。比例的双样本 Z 检验确定一个人口比例 p1 是否等于另一个人口比例 p2。在我们的示例中，p1 和 p2 分别是营销变化前后进入商店的女性比例，我们希望了解 p2 是否比 p1 有统计学上的显著增加，即 p2 > p1。
该测试检验零假设:p1 — p2 = 0。我们用来检验这种无效假设的检验统计量是:
其中 p*是两个样本中“成功”(即女性进入商店)的比例。即
Z 近似呈正态分布(即~N(0，1))，因此给定两个比例的 Z 分数，您可以根据正态分布查找其值，以查看该值偶然出现的可能性。
那么如何算出我们需要的样本量呢？这取决于几个因素:
- 信心水平: 我们需要有多大的信心来确保结果不是偶然发生的？对于给定的结果差异，以更高的置信度检测它需要更多的样本。这里的典型选择包括 95%或 99%的置信度，尽管这些只是惯例。
- 我们希望能够检测到的百分比差异 :您希望能够检测到的差异越小，需要的样本就越多。
- 您想要检测差异的概率的绝对值: 这有点复杂，对于我们正在进行的特定测试来说有点独特。事实证明，例如，检测 50%和 51%之间的差异与检测 80%和 81%之间的差异需要不同的样本量。换句话说，所需的样本大小是 p1 的函数，而不仅仅是 p1 — p2。
- 数据结果的分布: 假设您想要比较子组内的比例(在我们的例子中，假设您按年龄组细分女性比例)。这意味着您需要在每个亚组中有足够大的样本来进行统计显著性比较。您通常不知道样本在这些组中的表现如何(对某些组来说，获取样本可能要困难得多)。这里至少有几个选择:I)你可以假设样本在各个子群中均匀分布；ii)你可以进行初步测试(例如，在商店外面坐半天，以获得每个年龄组进入商店的女性的初步比例)。
那么，当有这么多因素在起作用时，你如何计算样本量呢？
用 Python 计算样本大小的可能性
最终，我们想要确定我们能够计算 p1 和 p2 之间的差，当它存在的时候。所以，让我们假设你知道 p1 和 p2 之间存在的“真实”差异。然后，我们可以查看 p1 的各种置信水平和绝对水平的样本大小要求。
我们需要一种计算 Z 的方法，这样我们就可以确定给定的样本大小是否提供了具有统计意义的结果，所以让我们定义一个函数，在给定 p1、p2、n1 和 n2 的情况下返回 Z 值。
然后，我们可以定义一个函数，在给定 p1(之前概率)、p_diff(即 p2-p1)和 alpha(表示 p 值，或 1 减去置信水平)的情况下，返回所需的样本。为简单起见，我们假设 n1 = n2。如果你预先知道 n1 的大小大约是 n2 的四分之一，那么把它合并到函数中就很简单了。然而，您通常事先不知道这一点，在我们的场景中，等样本假设似乎是合理的。
该函数非常简单:它从 1 开始从 n 开始计数，直到 n 足够大，其中统计值足够大的概率(即 p 值)小于α(在这种情况下，我们将拒绝 p1 = p2 的零假设)。该函数使用 scipy 库中可用的正态分布来计算 p 值，并将其与 alpha 进行比较。
我们定义的这些函数提供了确定所需最小样本水平所需的主要工具。
如前所述，需要处理的一个复杂问题是，确定 p1 和 p2 之间差异所需的样本取决于 p1 的绝对水平。所以，我们想回答的第一个问题是“什么样的 p1 需要最大的样本量来确定与 p2 的给定差异？”弄清楚这一点，你就可以计算出任何一个 p1 的样本的下限。如果您用最高要求的样本计算 p1 的样本，您知道它将足够用于任何其他 p1。
假设我们希望能够以 95%的置信度计算出 5%的差异，我们需要找到一个 p1，它给出了我们所需的最大样本。我们首先在 Python 中生成一个要查看的所有 p1 的列表，从 0%到 95%，然后对每个差异使用 sample_required 函数来计算样本。
然后，我们用下面的代码绘制数据。
产生了这个图:
该图清楚地表明，p1 = 50%产生最高的样本量。
使用此信息，假设我们想要计算计算 p1 和 p2 之间的差异所需的样本大小，其中 p2 - p1 介于 2%和 10%之间，置信水平为 95%或 99%。为了确保我们得到足够大的样本，我们知道设置 p1 = 50%。我们首先编写代码来构建要绘制的数据框。
然后，我们编写以下代码，用 Seaborn 绘制数据。
最后的结果是这样的情节:
这显示了对于 95%和 99%的置信水平，检测 2%和 10%之间的概率差异所需的最小样本。因此，例如，在 95%的置信水平下检测 2%的差异需要约 3，500 个样本，即 n1 = n2 = 1，750。因此，在我们的例子中，在营销干预之前，你需要大约 1750 人走进商店，之后需要 1750 人在 95%的置信度下检测 2%的概率差异。
结论
这个例子展示了 Python 是如何成为一个非常有用的工具来执行“封底”计算的，比如对测试所需样本量的估计，在这种情况下，这种确定是不直接的。这些计算可以为你节省大量的时间和金钱，尤其是当你考虑为一个研究项目收集你自己的数据时。
原载于 2018 年 7 月 22 日【www.marknagelberg.com】。要访问我共享的 Anki deck 和 Roam Research notes 知识库，以及关于间隔重复和提高学习效率的技巧和想法的定期更新， 加入“下载马克的大脑”。
如何在 Ubuntu 18.04 上将笔记本电脑 GPU 专用于 TensorFlow？
使用 Ubuntu 18.04 将笔记本电脑的 100% GPU 内存专用于 TensorFlow 并非如此简单。在这篇文章中，你会找到一个完整的教程，一步一步地去做。
Output of $ nvidia-smi at the end of this post
这篇文章分为三个部分:
- 检查您的 GPU 是否符合 TensorFlow 标准。
- 在您的笔记本电脑上安装合适的驱动程序，TensorFlow 和所有必需的依赖项，以便在您的 GPU 上训练模型。
- 安装自定义驱动程序以确保只有 TensorFlow 可以使用 GPU 内存。
检查您的 GPU 是否符合 TensorFlow 标准。
走向你的终端，输入:
这段代码将列出所有的 PCI 设备，并过滤 NVIDIA 设备。
在我的例子中，前面命令的结果是:
01:00.0 3D controller: NVIDIA Corporation GM108M [GeForce 940MX] (rev a2)
(我的笔记本电脑是小米笔记本 Air 13”配显卡 NVIDIA GeForce 940MX。)
如果什么都没有出现，对不起，但似乎你没有任何 NVIDIA GPU，所以你将无法使用 TensorFlow 与它(但它仍然有可能与你的 CPU！).
如果出现一条线，那我们走！
在您的笔记本电脑上安装合适的驱动程序，TensorFlow 和所有必需的依赖项，以便在您的 GPU 上训练模型。
安装 NVIDIA 专有驱动程序。
配备 NVIDIA 显卡的现代笔记本电脑通常配备 Optimus 技术。Optimus 技术意味着你的笔记本电脑实际上有 2 个图形芯片:第一个位于主板上，靠近 CPU。第二个在你的 NVIDIA 卡上。默认情况下，在 Ubuntu 18.04 上，不使用 NVIDIA 卡。你必须安装特定的驱动程序才能使用它。
要安装它们，非常简单:
- 转到您的软件&更新应用程序
- 点击标签附加驱动
在我的笔记本电脑上，我有:
我们可以看到没有使用 NVIDIA 二进制驱动。要修复它:
- 点击使用 NVIDIA 二进制驱动，然后点击应用更改
- 完成后，重新启动计算机
重新启动计算机后，打开终端写下:
在我的计算机上，我得到了以下结果:
显示 NVIDIA 显卡正在使用中。
CUDA 9.0 工具包安装
TensorFlow 需要 CUDA 9.0 才能使用你的 GPU。让我们安装它。
你应该不要安装其他版本的 CUDA，因为 TensorFlow 不会接受。
- 进入 CUDA 工具包 9.0 下载页面
- 点击 Linux ，然后点击你的架构(可能是 x86_64 ，然后点击 Ubuntu ，然后点击 17.04 (因为用于 Ubuntu 18.04 的 CUDA 9.0 不可用，但我们会做需要做的事情来让它工作)，然后点击然后点击 runfile (local) ，然后点击**下载 (不要选择除 runfile(本地)之外的其他安装程序类型，否则我们安装 CUDA 会有一些麻烦)。**
- 在控制台中，运行:
不要忘记“ —覆盖”选项，否则安装程序会抱怨它与 GCC 7.3(Ubuntu 18.04 提供的 GCC 版本)不兼容。
“—覆盖”选项将强制安装程序使用可用的 GCC 版本，这很好。
- 阅读 EULA(如果你想的话)，然后按下“ q ，然后写下“接受”。
- 关于问题*“您正试图在不支持的配置上安装。您希望继续吗？”*回答是 。
- 关于“*为 Linux-x86_64 384.81 安装 NVIDIA 加速图形驱动？”*回答否(非常重要！).
- 关于*的问题“安装 CUDA 9.0 工具包？”*回答是 。
- 在问题*“输入工具箱位置”*上点击进入。
- 关于问题*“您希望使用‘sudo’运行安装吗？”*回答是然后输入你的密码。
- 关于问题*“要不要在/usr/local/cuda 安装一个符号链接？”*回答是 。
- 关于问题*“安装 CUDA 9.0 样品？”*回答没有 。
- 安装完成后，在文件 ~/中添加以下两行。bashrc (或者 to ~/。zshrc 如果使用 ZSH
恭喜你！你刚刚在 Ubuntu 18.04 上安装了 CUDA 9.0 ！
NVIDIA cuDNN 安装。
TensorFlow 还需要 NVIDIA cuDNN 来使用你的 GPU。让我们安装它。
- 继续 NVIDIA cuDNN 页面。
- 点击下载 cuDNN 。
- 如果您还没有帐户，请创建一个帐户(这是免费的)。
- 点击与 CUDA 9.0 兼容的最新 cuDNN 版本。
- 点击链接 cuDNN … for Linux 。
- 提取下载的文件。
- 从提取的下载文件中，将 cuda/include 的内容复制(可能需要 root 权限)到 /usr/local/cuda/include 。
- 从提取的下载文件中，复制 cuda/lib64 到 /usr/local/cuda/lib64 的所有 libcudnn.so* 文件(可能需要 root 权限)。
(无需复制**)。一个"**文件)
恭喜你！你刚刚在 Ubuntu 18.04 上安装了 NVIDIA cuDNN ！
TensorFlow 和 TensorFlow GPU 安装。
-
如果 pip 尚未安装，用以下工具安装:
-
安装 TensorFlow 和 TensorFlow GPU
如果只安装 TensorFlow ， TensorFlow 会使用 CPU。
TensorFlow 安装 TensorFlow GPU 后才会使用 GPU。
恭喜你！你刚刚在 Ubuntu 18.04 上安装了 TensorFlow 和 TensorFlow GPU ！
让我们训练一个 MNIST 模特吧！
- 在一个全新的控制台中，下载以下文件。它包含一个简单的全连接(带有一个隐藏层)网络来识别手写数字。
该脚本将训练 5 个时期(这意味着训练集的每个示例将在训练期间被算法看到 5 次)。
出于某种原因，安装完所有这些东西后，第一次培训的第一个时期相当长(在我的电脑上只有 5 分钟)。也许有一些编译，因为在这段时间里，我的一个 CPU 被完全使用。
训练时间比其他所有训练都更“平常”。
在另一个控制台中，您可以编写:
它会每秒刷新一次 nvidia-smi 的输出。当 Python 脚本运行时，您应该在底部看到一行带有进程名:Python 的内容，并为其分配了一定数量的内存。此外， Volatile GPU-Util 应该显示一个工作的 GPU。
恭喜你！你刚刚在装有 Ubuntu 18.04 的笔记本电脑上，用 TensorFlow 和你的 GPU 训练了你的第一个模型！
不幸的是，正如 $ nvidia-smi 的输出所示，你的 GPU 的大量内存被用于其他事情，而不是训练你的模型。
安装自定义驱动程序以确保只有 TensorFlow 可以使用 GPU 内存。
在这一部分，我们将看到如何将你的 GPU 内存 100%奉献给 TensorFlow 。基本上我们会用 NVIDIA 芯片做 TensorFlow ，其余(包括图形显示)用 Intel 芯片。
下载 NVIDIA 驱动程序安装运行文件。
- 进入 NVIDIA 驱动程序安装页面
- 选择您的显卡(如果您想查看 Linux，请不要忘记点击**“显示所有操作系统”**)。
- 下载文件。
安装自定义 NVIDIA 驱动程序。
暂时，我们需要关闭 X 服务器，这意味着你将无法访问 Ubuntu 的窗口界面(因此也无法访问这篇文章……)。
因此，请打印、写下或在其他设备上打开这篇文章，比如你的手机。
您还需要您的登录名，因此如果您不知道它，只需在控制台中写入:
-
要关闭 X 服务器，在控制台中写入:
-
重启。
-
输入您的登录名和密码。
-
进入您下载驱动程序的文件夹，然后写下:
这个命令行将安装驱动程序而不处理 X 服务器(所以这个驱动程序不会用于图形显示目的)。
- 关于问题*“发行版提供的预装脚本失败！您确定要继续吗？”*回答继续安装 。
- 关于问题*“警告:不会安装 nvidia-drm 模块。因此，DRM-MMS 将无法与此 NVIDIA 驱动程序安装一起使用。*
- 关于问题*“你想向 DKMS 注册内核模块源代码吗？这将所有 DKMS 自动建立一个新的模块，il fou 安装一个不同的内核后？”*回答是 。
- 关于*的问题【安装 NVIDIA 的 32 位兼容库】*回答否 。
现在应该开始安装驱动程序了。
如果过了一会儿(比如说 5 分钟)，安装程序卡在
构建模块上。(这可能需要一段时间)
然后只需按几次回车。如果多次按下 Enter 没有任何作用，只需打开一个新的终端(例如使用 Ctrl + Alt +F3 )并从行*“输入您的登录名和密码”*重新执行协议。现在应该可以了。
现在，我们必须告诉 NVIDIA 配置工具打开英特尔图形卡，然后我们必须告诉 NVIDIA 配置工具打开 NVIDIA 图形卡，然后我们必须重新启动。不清楚为什么我们应该这样做，但是如果我们不这样做，我们可能会在下次重新启动时卡在*“启动的登录服务”*上。然后我们必须重新打开 X 服务器。
这最后四个步骤总结如下:
重启后，
现在应该显示:
正如我们所见，没有进程使用 NVIDIA GPU。
现在，如果我们重新运行 MNIST python 文件(这一次，第一个纪元可能需要几分钟)，同样的 NVIDIA SMI 命令应该显示:
我们到了！只有 TensorFlow 使用 GPU 内存！
python 脚本完成后，应再次显示消息*“未找到正在运行的进程”*。
还有一件事:如果你不小心忘记了步骤
“sudo prime-select Intel/NVIDIA” ，如果在重启过程中你陷入了奇怪的状态*“Started log in Service”*，那么只需等待 5 分钟以获得登录/密码命令/提示，然后再写一次。
机器学习快乐！
如何使用 TorchText 进行神经机器翻译，加上 hack 使其速度提高 5 倍
处理文本是 NLP 中任何成功项目的第一步，幸运的是，帮助我们的工具正在变得越来越复杂。
对于我的第一个深度学习项目，我构建了一个高功能的英法翻译器，如果没有 TorchText 库，我不可能做到这一点。好吧，也许这是一个有点戏剧性的说法…我至少会被大大减慢。
TorchText 非常方便，因为它允许您快速标记和打包(这些是单词吗？)你的数据。原本需要你自己的功能和大量思考的东西现在只需要几行代码，然后，你就可以构建你的人工智能了，它将接管这个世界(或者只是翻译一种语言什么的，我不知道你在计划什么)。
然而，它也不是没有缺点，在这篇文章中，我们还将探讨它最大的低效率以及如何快速规避它。
因此，现在让我们通过浏览我在越来越多的互联网上找到的一些英语-法语数据来探索如何使用 TorchText。
所有翻译数据的始祖
这是我用来训练我的翻译的数据集。
虽然法语和英语之间有许多小型并行数据集，但我想创建一个尽可能强大的翻译器，于是我选择了 big kah una:the European Parliament Proceedings Parallel Corpus 1996–2011(可从这里下载)。
15 years of EU proceedings makes an enthralling read for our seq2seq model!
这个坏男孩包含了 15 年来来自欧盟程序的评论，总计 2007724 个句子，50265039 个单词。
解压缩可下载文件将产生两个文本文件，可以通过以下方式加载:
europarl_en = open('{YOUR_PATH}/europarl-v7.fr-en.en', encoding='utf-8').read().split('\n')
europarl_fr = open('{YOUR_PATH}/europarl-v7.fr-en.fr', encoding='utf-8').read().split('\n')
这给我们留下了两个 python 句子列表，其中每个句子都是另一个句子的翻译。
使用分词器快速处理文本
我们需要做的第一件事是为每种语言创建一个标记器。这是一个将文本分割成独立单词并给它们分配唯一数字(索引)的功能。当我们讨论嵌入时，这个数字将会发挥作用。
Sentences turned into tokens, which are then given individual indexes
下面的代码展示了如何同时使用 Torchtext 和 Spacy 来标记文本。Spacy 是一个专门构建的库，用于获取各种语言的句子，并将它们拆分成不同的标记(更多信息，请参见此处)。没有 Spacy，Torchtext 默认为一个简单的*。*拆分(“”)的方法进行标记化。这比 Spacy 的方法要少得多，Spacy 的方法也将像“不”这样的词分成“做”和“不”，等等。
import spacy
import torchtext
from torchtext.data import Field, BucketIterator, TabularDataseten = spacy.load('en')
fr = spacy.load('fr')def tokenize_en(sentence):
return [tok.text for tok in en.tokenizer(sentence)]def tokenize_fr(sentence):
return [tok.text for tok in fr.tokenizer(sentence)]EN_TEXT = Field(tokenize=tokenize_en)FR_TEXT = Field(tokenize=tokenize_fr, init_token = "<sos>", eos_token = "<eos>")
在短短几行代码中，我们创建了两个 field 对象，稍后它们将能够处理/标记我们的文本。
使用 Torchtext TabularDataset 构建迭代器
也许与直觉相反，使用 Torchtext 的最佳方式是将数据转换成电子表格格式，不管数据文件的原始格式是什么。
这要归功于 Torchtext TabularDataset 函数令人难以置信的多功能性，它可以从电子表格格式创建数据集。
因此，首先要将我们的数据转换成一个合适的 CSV 文件，我们使用了一点熊猫的魔法:
import pandas as pdraw_data = {'English' : [line for line in europarl_en], 'French': [line for line in europarl_fr]}df = pd.DataFrame(raw_data, columns=["English", "French"])# remove very long sentences and sentences where translations are
# not of roughly equal lengthdf['eng_len'] = df['English'].str.count(' ')
df['fr_len'] = df['French'].str.count(' ')
df = df.query('fr_len < 80 & eng_len < 80')
df = df.query('fr_len < eng_len * 1.5 & fr_len * 1.5 > eng_len')
我们现在必须创建一个验证集。这一步很关键！例如，seq2seq 上的这个 pytorch 教程没有做到这一点，在我自己构建它并使用验证集后，我发现它过度拟合了。
幸运的是，Sklearn 和 Torchtext 一起让这个过程变得异常简单:
from sklearn.model_selection import train_test_split# create train and validation set
train, val = train_test_split(df, test_size=0.1)train.to_csv("train.csv", index=False)
val.to_csv("val.csv", index=False)
这将创建一个 train 和 validation csv，每个 csv 都有两列(英语、法语)，其中每行在“英语”列中包含一个英语句子，在“法语”列中包含其法语翻译。
调用 magic TabularDataset.splits 然后返回一个训练和验证数据集，其中加载了相应的数据，并根据我们前面定义的字段进行了处理(/标记化)。
# associate the text in the 'English' column with the EN_TEXT field, # and 'French' with FR_TEXT
data_fields = [('English', EN_TEXT), ('French', FR_TEXT)]train,val = data.TabularDataset.splits(path='./', train='train.csv', validation='val.csv', format='csv', fields=data_fields)
处理几百万字可能需要一段时间，所以在这里喝杯茶吧…
一旦最终完成，我们可以索引所有的令牌:
FR_TEXT.build_vocab(train, val)
EN_TEXT.build_vocab(train, val)
要查看每个字段中的令牌被分配了哪些数字，反之亦然，我们可以使用 self.vocab.stoi 和 self.vocab.itos…这在以后会很方便。
example input: print(EN_TEXT.vocab.stoi['the'])
example_output: 11example input: print(EN_TEXT.vocab.itos[11])
example_output: 'the'
只需多一行代码，我们就有了一个迭代器…
train_iter = BucketIterator(train, batch_size=20, \
sort_key=lambda x: len(x.French), shuffle=True)
让我们来看一个批次的例子，这样我们就可以看到我们到底用所有这些 Torchtext 魔法做了什么…
在每一批中，句子已经被转置，所以它们是垂直下降的(**重要:**我们将需要再次转置这些句子以使用转换器)。每个索引代表一个单词，每个列代表一个句子。我们有 10 列，因为 10 是我们指定的 batch_size。
你可能会注意到所有的“1 ”,并想这是哪个极其常见的单词的索引？这个“1”当然不是一个词，而是纯粹的填充。事实上，它太多了(这是我们将在下一节中解决的问题)。
..., sort_key = lambda x: len(x.French), ...
最后，这个排序关键字位决定了如何形成每一批。lambda 函数告诉迭代器尝试查找相同长度的句子(这意味着矩阵中更多的是有用的数据，更少的是填充)。
用这么少的几行代码完成了这么多的工作…我们已经将数据处理成了标记，并得到了一个迭代器，它返回匹配的、成批的法语和英语句子，所有的句子都是填充的，等等。
黑客入侵 TorchText 使其效率大大提高
# code from [http://nlp.seas.harvard.edu/2018/04/03/attention.html](http://nlp.seas.harvard.edu/2018/04/03/attention.html)
# read text after for description of what it doesglobal max_src_in_batch, max_tgt_in_batchdef batch_size_fn(new, count, sofar):
"Keep augmenting batch and calculate total number of tokens + padding."
global max_src_in_batch, max_tgt_in_batch
if count == 1:
max_src_in_batch = 0
max_tgt_in_batch = 0
max_src_in_batch = max(max_src_in_batch, len(new.English))
max_tgt_in_batch = max(max_tgt_in_batch, len(new.French) + 2)
src_elements = count * max_src_in_batch
tgt_elements = count * max_tgt_in_batch
return max(src_elements, tgt_elements)class MyIterator(data.Iterator):
def create_batches(self):
if self.train:
def pool(d, random_shuffler):
for p in data.batch(d, self.batch_size * 100):
p_batch = data.batch(
sorted(p, key=self.sort_key),
self.batch_size, self.batch_size_fn)
for b in random_shuffler(list(p_batch)):
yield b
self.batches = pool(self.data(), self.random_shuffler)
else:
self.batches = []
for b in data.batch(self.data(), self.batch_size,
self.batch_size_fn):
self.batches.append(sorted(b, key=self.sort_key))
虽然 Torchtext 很出色，但它基于 sort_key 的批处理还有一些不足之处。通常，句子的长度根本不一样，你最终会向你的网络中输入大量的填充(正如你在最后一个数字的中看到的所有 1)。
此外，如果您的 RAM 每次迭代可以处理 1500 个令牌，并且您的 batch_size 是 20，那么只有当您的批处理长度为 75 时，您才会利用所有的内存。一个有效的批处理机制将根据序列长度改变批处理大小，以确保每次迭代处理大约 1500 个令牌。
这是通过上面在 Torchtext 上运行的补丁批处理代码实现的。我们现在可以创建一个更有效的迭代器，如下所示:
train_iter = MyIterator(trn, batch_size=1300, device=0,
repeat=False, sort_key= lambda x:
(len(x.English), len(x.French)),
batch_size_fn=batch_size_fn, train=True,
shuffle=True)
准备出发！
现在你有了它，一个迭代器，可以部署在任何神经机器翻译模型上。看我的 github 这里，我在我的变形金刚模型的实现中使用了这个代码，你可以在你自己的数据集上尝试这个最先进的 NMT 模型。
如何使用 Twitter 的 API
为什么要使用 API？API 代表应用程序编程接口(API ),它们允许您访问仅在服务器上可用的资源。让我们学习如何使用 twitters 的 API。
首先，你需要一个 twitter 账户，并附上你的电话号码作为验证。然后你需要去apps.twitter.com并创建应用程序，这样我们就可以引用 Twitter 为该应用程序生成的相应密钥。这些是我们将在应用程序中用来与 Twitter API 通信的键。
现在进入代码，我们需要安装 python-twitter API 库
!pip install python-twitter
确保你理解 Twitters 的 API 使用规则，如果你不遵守他们的规则，他们会阻止你访问数据。这里有一个链接，链接到他们的一些费率限制【https://dev.twitter.com/rest/public/rate-limiting
现在我们有了我们的应用程序，我们有了与应用程序相关联的键。
按键设置
- 消费者密钥——在你的应用页面“密钥和访问令牌”下找到它
- consumer _ secret——位于“密钥和访问令牌”选项卡中的 consumer_key 下方
- access_token_key —您需要点击“生成令牌”按钮来获取此信息
- access_token_secret —按下“生成令牌”后也可用
我们将在下面的函数中插入这些特定的键
import twitter, re, datetime, pandas as pdclass twitterminer():request_limit = 20
api = False
data = []
twitter_keys = {
'consumer_key': , #add your consumer key
'consumer_secret': , #add your consumer secret key
'access_token_key': , #add your access token key
'access_token_secret': #add your access token secret key
}
def __init__(self, request_limit = 20):
self.request_limit = request_limit
# This sets the twitter API object for use internall within the class
self.set_api()
def set_api(self):
self.api = twitter.Api(
consumer_key = self.twitter_keys['consumer_key'],
consumer_secret = self.twitter_keys['consumer_secret'],
access_token_key = self.twitter_keys['access_token_key'],
access_token_secret = self.twitter_keys['access_token_secret']
)def mine_user_tweets(self, user=" set default user to get data from", mine_retweets=False):statuses = self.api.GetUserTimeline(screen_name=user, count=self.request_limit)
data = []
for item in statuses:mined = {
'tweet_id': item.id,
'handle': item.user.name,
'retweet_count': item.retweet_count,
'text': item.text,
'mined_at': datetime.datetime.now(),
'created_at': item.created_at,
}
data.append(mined)
return data
然后，我们需要实例化我们的类，以便能够使用我们上面的函数。
mine = twitterminer()
让我们使用 API 从唐纳德·特朗普的推特上获取一些推文
# insert handle we like
trump_tweets = miner.mine_user_tweets("realDonaldTrump")
trump_df = pd.DataFrame(trump_tweets)
我们现在已经成功地将来自唐纳德·特朗普推特的推文拉到我们的本地机器上进行分析。祝你收集数据顺利。
如何对机器学习任务进行版本控制— I
什么是版本控制？
软件配置管理、版本控制的一个组成部分，也称为版本控制或源代码控制、【1】是对文档、计算机程序、大型网站以及其他信息集合的变更管理。变更通常由数字或字母代码标识，称为“修订号”、“修订级别”，或简称为“修订”。例如，一组初始文件是“修订版 1”。当进行第一次更改时，结果集是“修订版 2”，依此类推。每个修订都与一个时间戳和做出更改的人相关联。可以比较、恢复修订，还可以合并某些类型的文件。
为什么要版本控制？
一个重要的问题:**为什么我们需要版本控制？**我在我的本地计算机/云上做任务，一旦模型准备好，并且只有当我完成测试时，我才在我的服务器上部署它。那么为什么我需要版本控制呢？
现在让我们看一个场景:我在一家像 Botsupply 这样的公司工作，我有客户。我是人工智能的家伙。我使用基于 TF-IDF 的模型进行了问答搜索。我把它部署在我的服务器上。在下一阶段，我对它做了一些更改，在我的虚拟数据上，我的准确性增加了。我把它部署在服务器上了。现在，由于测试数据的复杂性，性能下降了。现在我想回到之前的版本。
一种方法是再次部署之前的版本。第二，或者说更好的解决方案是版本控制并恢复到以前的版本。
如何做版本控制？
- 版本控制最流行的方式之一是 Git 。非常受欢迎，基本上每个人都知道如何使用它。(至少是每个程序员和数据科学家)。
现在，Git 真的很酷，但对于一个数据科学家来说，保持 Git 中所有文件夹的同步是一项艰巨的任务。模型检查点和数据大小占用了所有不必要的空间。因此，一种方法是将所有数据集存储在像亚马逊 S3 这样的云服务器中，并将所有可复制的代码存储在 Git 中，并动态生成模型。看起来是一个不错的选择，但是如果在相同的代码中使用多个数据集，将会造成混乱，如果没有正确地记录，从长远来看，可能会导致数据集的混合。
此外，如果数据变更/升级，并且所有的提交没有被正确地记录，模型可能会丢失上下文。
如果文件不能动态复制，可以选择 git-annex 。
[## git-附件
git-annex 允许用 git 管理文件，而不需要将文件内容签入 git。虽然这看起来有些矛盾…
git-annex.branchable.com](https://git-annex.branchable.com/)
2.第二个选择是在沙盒环境中做所有事情，看看结果，如果不好，就不要将更改提交到生产环境中。 Ipython 笔记本(Jupyter Notebook) 就是这么做的好方法。代码可以在不同的单元中分成更小的片段，然后在每一步都可以看到结果，这使得 Ipython 成为机器学习的最佳编辑器之一。
Jupyter 笔记本是一个基于网络的交互式计算平台。该笔记本结合了现场代码，方程式…
jupyter.org](https://jupyter.org/)
3.最好的选择(在我看来)是 数据版本控制或者【DVC】。DVC 在许多方面与 Git 相似(如命令结构)，但它也提供对步骤的跟踪、步骤之间的依赖关系、代码和数据文件之间的依赖关系以及所有代码运行参数，因此它结合了对代码和数据库的版本控制。
[## 数据版本控制——让您的数据科学项目具有可复制性和可共享性。
阅读有关 dataversioncontrol 的更多信息。数据科学项目 Git。
dataversioncontrol.com](https://dataversioncontrol.com/)
在现实生活中，很难一次性开发出一个好的机器学习模型。ML 建模是一个迭代过程，跟踪您的步骤、步骤之间的依赖关系、代码和数据文件之间的依赖关系以及所有代码运行参数非常重要。DVC，德米特里·彼得罗夫
什么是 DVC 和使用它的 5 个好理由？
DVC 通过自动构建数据依赖图(DAG)使数据科学项目具有可重复性。你的代码和依赖项可以很容易地被 Git 和数据共享——通过云存储(AWS S3，GCP)在一个单一的 DVC 环境中。
- 它是完全开源的，可以用 pip 的简单命令安装:
**pip install dvc** #pip3 for python3
2.命令类似于 git :
**dvc run python train_model.py data/train_matrix.p data/model.p**
3.它是独立于语言的，机器学习过程可以很容易地转换成任何语言的可重复的 DVC 流水线。
4.DVC 不仅可以将你的工作简化到一个单一的、可复制的环境中，它还可以通过 Git 共享这个环境，包括依赖关系(DAG)——这是一个令人兴奋的协作功能，它提供了在不同的计算机上复制研究结果的能力。
5.数据文件可以由任何云文件共享服务共享，如 AWS S3 或 GCP 存储，因为 DVC 不会将数据文件推送到 Git 存储库。
要详细了解 DVC 的安装和使用，请查看下面的博文:
在现实生活中，很难一次性开发出一个好的机器学习模型。ML 建模是一种…
blog.dataversioncontrol.com](https://blog.dataversioncontrol.com/data-version-control-beta-release-iterative-machine-learning-a7faf7c8be67)
阅读 第二部分 以了解 DVC 如何在与numeri合作时帮助我进行版本控制，在那里，数据科学家使用机器学习来做出预测，为 numeri 的对冲基金提供动力。
这篇文章是上一篇文章的延续:如何对你的机器学习进行版本控制- I。如果你还没有…
medium.com](https://medium.com/@shridhar743/how-to-version-control-your-machine-learning-task-ii-d37da60ef570)
如何用高斯过程可视化黑盒优化问题
更新:我开了一家科技公司。你可以在这里找到更多
缺乏框优化在机器学习中很常见，因为我们试图优化的过程或模型往往没有可以解析求解的代数模型。此外，在目标函数评估昂贵的某些使用情况下，一般方法包括创建目标函数的更简单的替代模型，该替代模型评估起来更便宜，并且将用于解决优化问题。在以前的一篇文章中，我解释了其中一种方法，贝叶斯优化，它使用高斯过程来逼近目标函数。这篇文章是一个 Python 教程，展示了如何使用贝叶斯优化 APIopta as评估和可视化高斯过程代理。
在某些应用中，目标函数是昂贵的或难以评估的。在这些情况下，一般…
towardsdatascience.com](/the-intuitions-behind-bayesian-optimization-with-gaussian-processes-7e00fcc898a0)
在本教程中，我们将使用 OPTaaS 来查找由以下公式定义的 Beale 函数的全局最小值:
装置
OPTaaS 在 PyPi 上，可以直接 pip 安装:
!pip install mindfoundry-optaas-client%matplotlib inline
from matplotlib import pyplot as plt
import numpy as npfrom mindfoundry.optaas.client.client import OPTaaSClient, Goal
from mindfoundry.optaas.client.parameter import FloatParameter
连接到 OPTaaS
为了连接到 OPTaaS，您需要一个 API 密钥。你可以在这里得到一个。
client = OPTaaSClient(OPTaaS_URL, OPTaaS_API_key)
创建任务
要开始优化过程，我们需要定义参数并创建一个任务。
parameters = [
FloatParameter(name='x', minimum=-4.5, maximum=4.5),
FloatParameter(name='y', minimum=-4.5, maximum=4.5),
]initial_configurations = 5task = client.create_task(
title='Beale Optimization',
parameters=parameters,
goal=Goal.min,
initial_configurations=initial_configurations,
)configurations = task.generate_configurations(initial_configurations)
然后，我们需要生成一些初始均匀采样配置(5)来加权高斯过程代理模型。
出于本教程的目的，我们将把优化过程分解成几个步骤，但是在一个典型的场景中，我们将简单地运行总迭代次数的任务。
运行任务 5 次迭代
number_of_iterations = 5for i in range(number_of_iterations):
configuration = configurations[i]
x = configuration.values['x']
y = configuration.values['y']
score = beale_function(x, y)
next_configuration = task.record_result(configuration=configuration, score=score)
configurations.append(next_configuration)
既然我们已经用初始配置对代理模型进行了加权，我们将检索它的值来可视化它。
检索代理
我们将从 OPTaaS 生成的代理模型中请求预测。高斯过程替代模型的预测以它们的均值和方差为特征。
random_configs_values = [{'x': np.random.uniform(-4.5, 4.5),
'y': np.random.uniform(-4.5, 4.5)
} for _ in range(1000)]predictions = task.get_surrogate_predictions(random_configs_values)mean = [p.mean for p in predictions]
var = [p.variance for p in predictions]
我们现在将检索对最初 5 种配置的 Beale 函数的评估:
predictions = task.get_surrogate_predictions(random_configs_values)surrogate_X = [[c['x'], c['y']] for c in random_configs_values]
surrogate_X=np.array(surrogate_X)results = task.get_results(include_configurations=True)evaluations_config_values = [r.configuration.values for r in results]
evaluations_score = [r.score for r in results]
绘制代理
我们现在将重新格式化这些值以绘制它们:
xs = [results[i].configuration.values['x'] for i in range(len(results)) ]
ys = [results[i].configuration.values['y'] for i in range(len(results)) ]
zs=evaluations_scorebeale=np.zeros(len(surrogate_X[:,1]))for i in range(len(surrogate_X[:,1])):
beale[i]=beale_function(surrogate_X[i,0], surrogate_X[i,1])
最后，我们将绘制代理函数与实函数的曲线图，并将曲线图与 OPTaaS 所做的函数求值叠加。
plt.clf()
fig = plt.figure(figsize=(20, 10))
ax3d = fig.add_subplot(1, 2, 1, projection='3d')
ax3d.view_init(15, 45)surface_plot = ax3d.plot_trisurf(surrogate_X[:,0], surrogate_X[:,1], np.array(mean), cmap=plt.get_cmap('coolwarm'), zorder=2, label='Surrogate')
surface_plot.set_alpha(0.28)plt.title('Surrogate after 5 iterations')
ax3d.plot(xs, ys,zs, 'x', label='evaluations')plt.xlabel('x')
plt.ylabel('y')ax3d = fig.add_subplot(1, 2, 2, projection='3d')
ax3d.view_init(15, 45)surface_plot_real = ax3d.plot_trisurf(surrogate_X[:,0], surrogate_X[:,1], true, cmap=plt.get_cmap('coolwarm'), zorder=2, label='real')
surface_plot_real.set_alpha(0.28)plt.title('Real')
ax3d.plot(xs, ys,zs, 'x', label='evaluations')display(plt.gcf())plt.close('all')
哪些输出:
正如我们所看到的，代理在 5 次迭代后看起来不太像真正的函数，但我们希望随着评估次数的增加，随着它对底层函数的了解增加，这种情况会有所改变。
代理人的进化
随着迭代次数的增加，代理很快适应了 Beale 函数的更真实的表示。这些图是用与上面相同的代码生成的。
从不同的角度来看，相同的过程显示了 OPTaaS 性能的演变，并突出了接近最优值的推荐的集中程度:
绘制方差的等值线图
我们也可以尝试用等值线图来显示替代变量的变化。蓝色阴影越深，表示相关预测的不确定性越低。
OPTaaS
如果您有任何问题或想了解更多关于 OPTaaS 的信息，您可以查看以下链接:
教程:https://tutorial . opta as . mind foundry . ai
API 文档:https://opta as . mind foundry . ai
研http://www . robots . ox . AC . uk/~ mosb/projects/project/2009/01/01/bayesopt/
如果你仍然好奇，请随时给我发邮件了解更多信息和 API 密钥:Charles . bre cque @ mind foundry . ai
如何使用 Scikit-Learn 在 Python 中可视化随机森林中的决策树
有助于理解您的模型的实用程序
下面是完整的代码:只需复制并粘贴到 Jupyter 笔记本或 Python 脚本中，用您的数据替换并运行:
Code to visualize a decision tree and save as png (on GitHub here).
最终结果是一个完整的决策树图像。
Decision Tree for Iris Dataset
代码解释
- **创建一个模型训练并提取:**我们可以使用一个单独的决策树，但是因为我经常使用随机森林来建模，所以在这个例子中使用了它。(树与树之间会略有不同！).
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=10)*# Train*
model.fit(iris.data, iris.target)
*# Extract single tree*
estimator = model.estimators_[5]
**2。将树导出为。点文件:**这利用了 Scikit-Learn 中的export_graphviz函数。这里有许多参数控制显示的外观和信息。查看文档了解具体信息。
from sklearn.tree import export_graphviz# Export as dot file
export_graphviz(estimator_limited,
out_file='tree.dot',
feature_names = iris.feature_names,
class_names = iris.target_names,
rounded = True, proportion = False,
precision = 2, filled = True)
3。使用系统命令 : 将 **dot** 转换为 **png** 在 Python 中运行系统命令可以方便地执行简单的任务。这需要安装包含点工具的 graphviz。有关转换的完整选项，请查看文档。
# Convert to png
from subprocess import call
call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])
4。可视化:最好的可视化出现在 Jupyter 笔记本中。(相当于你可以用matplotlib来显示图像)。
# Display in jupyter notebook
from IPython.display import Image
Image(filename = 'tree.png')
考虑
有了随机森林，每棵树都将被不同地建造。我使用这些图像来展示决策树(以及随后的随机森林)背后的推理，而不是具体的细节。
当您拥有大量要素时，限制树的最大深度会很有帮助。否则，你最终会得到巨大的树，看起来令人印象深刻，但根本无法解读！这是一个包含 50 个特性的完整示例。
Full decision tree from a real problem (see here).
结论
机器学习仍然受到黑箱问题的困扰，一张图片并不能解决问题！尽管如此，观察单个决策树向我们展示了这种模型(和随机森林)并不是一种无法解释的方法，而是一系列逻辑问题和答案——就像我们在进行预测时形成的一样。请随意为您的数据使用和修改这些代码。
和往常一样，我欢迎反馈、建设性的批评以及倾听您的数据科学项目。可以在推特上找到我 @koehrsen_will
如何可视化分布
Source: https://xkcd.com/539/
您已经将所有必要的数据整理成一种清晰的格式，您已经恰当地执行了一个时髦的统计分析，现在是分析结果的时候了。这就是可视化数据派上用场的地方。信息丰富的数据可视化不仅揭示了新颖的见解，也许你正在和某人约会，但你并不知道，但当你要向老板/客户传达你的发现时，它们真的是非常宝贵的。
这篇文章将专门研究我一次又一次面临的可视化任务。在分析数据的这些年里，我经常发现自己想要比较和对比数字数据的多种分布。这可能很棘手，取决于分布的不同程度，以及分布的大量可能的表示方法(http://www . darkhorsanalytics . com/blog/visualizing-distributions-3)。当比较分布时，我通常有两个目标，或者我想突出它们异常值的差异，或者，通常是它们各自分布的细微差异。也许我想展示用不同标准收集的数据集如何对统计程序做出不同的反应，或者应用统计校正如何改进评分函数。
如果我对比较异常值感兴趣，我倾向于箱线图。箱线图显示数据的总体分布，同时绘制异常值的数据点。这一物理点使得它们的特定值很容易在样品中识别和比较。
让我们忽略数据的实际意义，因为这并不重要。您可以看到分布的分布或多或少是相等的，异常值很容易比较。红色/洋红色分布具有最极端的异常值，后面是我从绿色分布中着色为红色的点。对于这个分析，红色分布已经预先计算过了，我能够通过观察极端异常值来重现他们的数据。然而，红点是一个新奇的观察。
如果你是一个关注绘图轴并了解一些统计数据的人，那么你可能已经意识到我对我的数据集应用了一个统计变换，以便放大分布异常值中的差异。我将我的数字分布转换成一个 z 值。z 得分通过测量数据点偏离样本均值的标准偏差数来转换数据点。
我通常为分布图做的第一个可视化是直方图。你可以在这里看到这是一个可怕的和无信息的方式来看待数据。使用这种方法，不同组之间样本大小的差异使得它们不可比较。它是如此的极端，以至于你再也看不到蓝色的分布。这种可视化在比较甚至看到异常值方面也是失败的。从这个图像中我唯一能得出的结论是红色和绿色的分布有大致相同的意思。
虽然我认为箱线图是这种情况下的最佳选择，但它们看起来非常正式，人们通常不知道如何正确地解释它们(四分位数范围，分布，说什么？).此外，箱线图无法洞察用于创建它们的样本大小。对于不太在意统计的观众来说，带状图更直观，因为他们可以看到所有的数据点。该图还显示了分布的样本量。我喜欢在点上应用抖动和不透明度，让这些图更吸引人。
让我们跳到第二种情况，我们感兴趣的是比较分布的分布。在这里，如果被比较的分布具有相同的样本大小，并且您最多进行 3 次比较，直方图是一个很好的选择。否则，你会得到一个非常繁忙的图，很难看到数据。
在这些情况下，我倾向于没有填充的内核密度图。它不是很漂亮，但是你可以看到和比较分布。在最近的一个项目中，为了克服这一点，我决定在直方图上实现一个旋转，并使用一种叫做阶梯图的变体，效果很好。如果你的图变得笨拙，我建议改变你表示数据的方式。
但是如果你想要全部呢？！在这种情况下，我喜欢使用小提琴情节。我看到这些情节变得越来越受欢迎，还有许多变化，使他们更加强大。它们本质上是箱线图，周围有一个旋转的核密度图。在这里，我绘制了旋转内核密度图内的箱线图。
这就是我现在能给你的。我使用 r 中的 ggplot2 包制作了上面所有的图。我还使用 matplotlib 和 seaborne 在 python 中制作了相当多的图。案例 2 中使用的数据集是使用 R 附带的 airquality 数据集完成的，另一个数据集是我自己为我的硕士论文构建的。
代码可以在这个库中找到。如果你愿意，请随意添加图表，如果你认为有更好的方法来分析分布，请在评论中告诉我！
Pixabay.com
如何使用 Plotly R 可视化多元轨迹置信区间
Simulated datasets — 3D lines with confidence bands drawn with Plotly R
统计学或机器学习中的任何概率回归方法都会产生一个折线图以及相关的置信区间，通常定义为平均值周围的两个标准差。尽管 Plotly 拥有许多强大的图表工具，可用于绘制二维或三维图表，并可为 2D 折线图绘制误差线或置信区间，但它没有在三维折线图或曲面图中绘制置信区间的选项。
多元挑战
许多有趣的概率回归任务本质上是多元的；例如，跨位置坐标 x 预测时间 t 上的数据值 z。该预测的结果将是表示时间 t 上每个点 x 处的预期值 z 的 3D 表面，以及每个值点处的相关误差的估计。这种类型的表面图在表面拓扑探测中很常见，其中传感器网格在目标空间内的每个网格点捕获数据。在 Plotly 中，该网格将被很好地可视化为跨所有 x，y 坐标的数据值的 3D 表面图，但是 Plotly 不呈现跨该表面的置信边界。
轨迹
通常问题的领域局限于通过目标空间的轨迹，而不是整个领域的完整探索。例如，想象一个火箭轨道，在飞行的每个纬度和经度上都标有发动机温度的测量值。温度数据是在相对于位置的每个点捕获的，但是位置数据是整个子午线空间的子集，仅沿着火箭的轨迹测量。这在建模和可视化时，以图形方式显示为一条穿过温度、高度和经度的 3D 空间中的轨迹的温度线，而不是表面。Plotly 允许我们画出这条轨迹，但它不允许我们轻易地在这条线上画出上下置信区间。我们可以重构计算，以显示温度与高度的关系，如 2D 图，但这样我们会失去空间分辨率，例如，将无法区分火箭向外飞行的方向与向内、向地球飞行的轨迹，在不同的时间穿越相同的高度，这将给我们的回归分析带来问题。
如何绘制三维置信区间
显示的图表是模拟数据的渲染图，代表样本数据在 x，y 平面上的三个轨迹，z 显示每个点的数据值，带显示置信上限和置信下限。直接沿 z 轴向下看，可以看到置信带位于 z 平面内，因为误差是相对于数据值显示的，而观察到的 x 和 y 观察点被假设为是已知的，没有误差。这是回归分析中通常采用的方法，通常假设我们可以精确地获得测量坐标。
Projection down z axis
用于创建这些图的 R 代码使用 Plotly mesh3D 图表类型来构建向上和向下指向的交错三角形的表面，这些三角形链接在一起以在数据值的平面中形成连续的表面。
所描述的方法是完全通用的，并且可以用于创建任何形式的表面，例如在 3D 绘图表面上构造上下边界表面。使用这种方法的唯一限制是表面重叠的复杂性，当在平面图像中渲染时，会使眼睛感到困惑，而不是作为情节动态可视化。
r 代码
*#R code for 3D confidence error intervals*
install.packages("plotly")
library(plotly)
*# Generate Simulated Data Points*
x <- seq(-5,5, .1)
y <- seq(0, 10, .1)
y <- cbind(y, sin(y), cos(y))
*# Generate Simulated Data Values*
z1 = sin(x+y[,1])
z2 = sin((x+y[,1])/2.)
z3 = sin((x+y[,1])/3.)
z <- cbind(z1, z2, z3)*# Generate Simulated Standard Deviations*
sd <- sqrt(abs(z) * .05)
n = length(x)
i = seq(0,n-1)*# Create Plots for each of three simulated trajectories*
p <- plot_ly(type = 'scatter3d')
for (index in 1:3){
p <- add_trace(p, x = x, y = y[,index], z = z[,index], mode = 'lines', line = list(width = 8, color=index))
p <- add_trace(p, type = 'mesh3d',
*# Setup triangle vertices*
x = c(x, x),
y = c(y[,index], y[,index]),
z = c(z[,index] - 2 * sd[,index], z[,index] + 2 * sd[,index]),
*# Create triangles*
i = c(i[1:n - 1], i[1:n - 1]),
j = c(n + i[1:n - 1], n + i[2:n]) ,
k = c(n + i[2:n], i[2:n]),
color = index
)
}
*#END*
如何用 Python 在 4 分钟内完成网页抓取
Python 网页抓取初学者指南
Photo by Chris Ried on Unsplash
网页抓取
Web 抓取是一种从网站中自动访问和提取大量信息的技术，可以节省大量的时间和精力。在本文中，我们将通过一个简单的例子来演示如何从纽约 MTA 自动下载数百个文件。这是一个伟大的练习网页抓取初学者谁正在寻找了解如何网页抓取。网络抓取可能有点吓人，所以本教程将分解如何进行这个过程。
纽约 MTA 数据
我们将从以下网站下载十字转门数据:
[http://web.mta.info/developers/turnstile.html](http://web.mta.info/developers/turnstile.html)
十字转门的数据从 2010 年 5 月到现在每周都有汇编，所以几百个。网站上有 txt 文件。下面是一些数据的片段。每个日期都是一个链接。txt 文件，您可以下载。
手动右键点击每个链接并保存到你的桌面是很痛苦的。幸运的是，有网络抓取！
关于网页抓取的重要注意事项:
- 通读网站的条款和条件，了解如何合法使用数据。大多数网站禁止你将这些数据用于商业目的。
- 确保下载数据的速度不要太快，因为这可能会破坏网站。您也可能被阻止访问该网站。
检查网站
我们需要做的第一件事是找出在多层 HTML 标签中我们可以在哪里找到我们想要下载的文件的链接。简而言之，网站页面上有大量代码，我们希望找到包含我们数据的相关代码。如果你不熟悉 HTML 标签，参考 W3Schools 教程。理解 HTML 的基础知识对于成功抓取网页是很重要的。
在网站上，右键点击“检查”。这可以让你看到网站背后的原始代码。
一旦你点击“检查”，你应该看到这个控制台弹出。
Console
请注意，在控制台的左上方，有一个箭头符号。
如果您单击这个箭头，然后单击站点本身的一个区域，则该特定项目的代码将在控制台中突出显示。我点击了第一个数据文件，2018 年 9 月 22 日，星期六，控制台以蓝色突出显示了该特定文件的链接。
<a href=”data/nyct/turnstile/turnstile_180922.txt”>Saturday, September 22, 2018</a>
注意所有的。txt 文件在上面一行后面的<a>标签中。当你做更多的网页抓取时，你会发现<a>是用于超链接的。
现在我们已经确定了链接的位置，让我们开始编码吧！
Python 代码
我们从导入以下库开始。
import requests
import urllib.request
import time
from bs4 import BeautifulSoup
接下来，我们设置网站的 url，并使用我们的请求库访问该站点。
url = '[http://web.mta.info/developers/turnstile.html'](http://web.mta.info/developers/turnstile.html')
response = requests.get(url)
如果访问成功，您应该会看到以下输出:
接下来，我们用 BeautifulSoup 解析 html，这样我们就可以使用更好的嵌套式 BeautifulSoup 数据结构。如果你有兴趣了解这个库的更多信息，请查看 BeatifulSoup 文档。
soup = BeautifulSoup(response.text, “html.parser”)
我们使用这种方法。findAll 找到我们所有的<a>标签。
soup.findAll('a')
这段代码给出了每一行带有<a>标签的代码。我们感兴趣的信息从第 38 行开始，如下所示。也就是说，第一个文本文件位于第 38 行，所以我们想要获取位于下面的其余文本文件。
subset of all tags
接下来，让我们提取我们想要的实际链接。让我们测试第一个链接。
one_a_tag = soup.findAll(‘a’)[38]
link = one_a_tag[‘href’]
这段代码将第一个文本文件“data/nyct/turnstile/turnstile _ 180922 . txt”保存到我们的变量 link 中。下载数据的完整网址其实是‘http://web . MTA . info/developers**/**data/nyct/turnstile/turnstile _ 180922 . txt’，是我在网站上点击第一个数据文件作为测试发现的。我们可以使用我们的 urllib.request 库将这个文件路径下载到我们的计算机上。我们为 request.urlretrieve 提供两个参数:文件 url 和文件名。对于我的文件，我命名为“turnstile_180922.txt”、“turnstile_180901”等。
download_url = 'http://web.mta.info/developers/'+ link
urllib.request.urlretrieve(download_url,'./'+link[link.find('/turnstile_')+1:])
最后但同样重要的是，我们应该包含这一行代码，这样我们可以暂停我们的代码一秒钟，这样我们就不会向网站发送垃圾请求。这有助于我们避免被标记为垃圾邮件发送者。
time.sleep(1)
现在我们已经了解了如何下载一个文件，让我们试着用 for 循环下载整个数据文件集。下面的代码包含了网络抓取纽约 MTA 十字转门数据的整套代码。
Note that line 19 should be 38 and not 36 due to an updated on the website.
你可以在我的 Github 上找到我的 Jupyter 笔记本。
感谢大家的阅读和快乐的网刮！
如何赢得 70%以上的石头剪刀布比赛
https://www.flickr.com/photos/gozalewis/4565833940
一个流行游戏的初级人工智能方法
你有没有想过算法是怎么下棋的？如何设置围棋程序？为什么 AI bot 能够在你最喜欢的游戏中打败你？你不会在这篇文章中读到它。我将要写的这个游戏更容易玩，也更容易实现。
虽然石头剪子布(RPS)看起来像一个微不足道的游戏，但它实际上涉及到时间模式识别的困难计算问题。这个问题是机器学习、人工智能和数据压缩领域的基础。事实上，它甚至对理解人类智能的工作方式至关重要。
以上文字来自伟大的石头剪刀布编程大赛 页面。它举办了一场自由开放的比赛，每个人都可以提交他/她的游戏算法。代码提交在 Python 2 中，每个人都可以看到。它让每个人都有机会看到最佳解决方案的细节。然而理解它们并不总是容易的。
提交的算法和其他程序打一千回合。这叫比赛。获胜回合数较多的算法获胜。玩家在排行榜上的排名基于通过比赛获得或失去的分数。
让我们实现最简单的播放算法。它总是放摇滚。
注意，在程序中你唯一要做的事情就是给全局输出变量一个 range 值(‘R’，‘P’，‘S’)。你反对算法将其移动分配给输入全局变量。每一轮你都可以看到前一轮的输入。第一轮变量是一个空字符串。
好吧，第一个游戏对于任何从数据中学习的算法来说都是很容易对付的。现在采取相反的方法。
http://dilbert.com/strip/2001-10-25
你认为会怎样？这很容易预测:平均三分之一输，三分之一平，三分之一赢。这个策略让你有 50%的机会赢得每场比赛。为了获得更高的胜率，你必须冒险。只看随机模特比赛有趣吗？不，所以请不要提交完全随机的解决方案。不过我们会在某些情况下使用这个模型。
请注意，您可以离线测试您的模型。从网站下载 rpsrunner.py 即可。你可以发布它们来检查它们做得怎么样，但是没有太多的计算能力。一开始犯了一个错误，贴了一些无意随机的代码。这很容易测试——只需让您的代码处理持续的输入(就像第一个实现的模型一样)。如果它松动了大约 50%,你的模型可能是随机的。
我们要实现的模型是一个离散马尔可夫链。它建立在一个简单的想法上。假设一个进程有两种可能的状态 A 和 e，我们现在在状态 A，我们停留在状态 A 的几率是多少？还有，去 E 州的几率有多大？关于具有两种可能状态的马尔可夫链，这两种概率的总和必须为 1。充分地说，当前状态 e 有两种概率，你可以在下面的图片上看到机制。
https://en.wikipedia.org/wiki/Markov_chain
这里有一个关于马尔可夫模型如何工作的极好的可视化。
我们如何在 RPS 竞赛中使用该模型？一种自然的方法是分析最近一轮的输入和输出，并尝试预测下一个输入。然后采取行动击败它。这个设置表明我们的当前状态是一对，就像“RP”，下一个状态是我们的输出。应该是这样的:
Image by author
下面是实现。我还添加了一个 n_obs 键来保存过去发生的次数。我们将在学习过程中使用它。
衰减参数代表模型的记忆。值 1 意味着模型具有完美的记忆。如果分配一个介于 0 和 1 之间的值，模型将会忘记先前的观察，从而更快地适应对手行为的变化。
作为输入预测，给定最新的输出-输入对，模型选择具有最高概率的移动。
下面你可以找到整个播放程序:
你可以玩算法:
http://www.rpscontest.com/human/5706404883070976
我必须警告你。这种型号在比赛中表现不好。只是太初级了。大部分冒险算法应该可以对抗这种策略。你可以在这个链接下看到它的表现。它只是一个让你在石头剪刀布比赛中开始冒险的地方。你可以修改参数，训练许多模型，选择最好的来玩，创建合奏。这取决于你的想象力。最好的算法赢得大约 80%的匹配。你可以在这里查看我的超 70%算法。你能做得更好吗？
关于 RPS 游戏中贝叶斯推理的说明。当我开始参加竞赛时，我认为最好的解决方案是贝叶斯方案。现在我相信不是贝叶斯问题。你可以评估所有的策略，因为输入和输出是同时的，因此相互独立。它否定了贝叶斯推理最大的优势之一——选择下一个要测试的算法。
你打算参加比赛吗？你有别的方法吗？如果你喜欢这篇文章，请在评论区或拍手告诉我！
Kitsune-ken — a popular Japanese rock–paper–scissors variant. https://en.wikipedia.org/wiki/Rock-paper-scissors
如何赢得数独
Photo by Xan Griffin on Unsplash
了解被称为数独的流行谜题，以及我们如何教计算机自己解决它。
Sudoku (aka 数独)
数独这个名字来自日本，翻译过来就是‘数’(Su)和‘单’(Doku)。然而，虽然这个名字表明了日本的传统，但创造这个谜题的主要功臣是伦纳德·欧拉；一位非常著名的 18 世纪瑞士数学家。从那以后，这个谜题在国际上被广泛采用，甚至在计算机中也是如此。
那么数独怎么玩呢？首先，这个谜题是一个由 81 个方块组成的棋盘(就像井字游戏一样),根据谜题的难度，有许多方块填满了数字，而其余的都是空白的。下面你可以在左边看到一个尚未解决的数独拼图板，在右边看到一个已经解决的相同拼图板。
https://blogs.unimelb.edu.au/sciencecommunication/files/2016/10/sudoku-p14bi6.png
要解决这个难题，你需要用从 1 到 9 的数字填充空白方块。问题是每个方块必须包含一个对该行、列和框唯一的值。这些行、列和框将被称为区域。一行从左到右由九个正方形组成，一列从上到下由九个正方形组成，一个盒子由九个均匀分布在棋盘上的 3x3 盒子之一组成。
Udacity AI Nanodegree Program
现在这个谜题有不同的变体，但我们将只关注最初的。如果你没有玩过数独，那就去试试吧！人们已经玩了几个世纪了，这很有趣(有时令人沮丧)。
解决数独
好了，现在你知道了数独的规则，并且有希望获得一些玩数独的经验，你可能已经注意到了在你寻找解决方法的过程中的一些模式。更有可能的是，你从填一个只能取一个值的方块开始。然后，也许你开始解决其余的方块，通过消除所有可能的值，一个特定的方块不能采取，并选择剩下的一个。可能有几次你不得不记住多个方块的几个值。也许你遇到了两个岔路口，你不得不在两条不同的路径中选择一条来寻找解决方案，其中一条路径要么帮助你解决了难题，要么产生了一个迫使你原路返回的死胡同。
这是对两种常见策略的很好的介绍，称为消除和唯一选择，它要求你列出每个方块可能取的所有值(消除)，然后填写只列出一个可能值的方块(唯一选择)。你需要做的就是一遍又一遍地重复这个循环来解决这个难题。不错！
约束传播
现在要教计算机如何做到这一点，我们需要使用一种常见的人工智能方法，称为约束传播。简而言之，这是一种方法，它允许计算机朝着可能的解决方案移动(传播)，同时遵循一些空间的规则和每个变量可能使用的值(约束)。在这种情况下，我们的约束是只能包含一个从 1 到 9 的值的正方形，并且每个区域必须是唯一的。
那么，这种方法实际上是怎样的呢？让我们从下面的数独板开始。别担心，这个难题很简单，使用约束传播时对计算机来说甚至更容易。
Udacity AI Nanodegree Program
首先，我们要列出每个方块可能取的所有可能值，这样我们可以缩小可能的选择范围，并发现“已经解决”的方块(即，只有一个可能值的方块)。根据下面的板子，你可以看到所有可能的值都列在了每一个方块上，其中一些只有一个值。
Udacity AI Nanodegree Program
现在要做的显而易见的事情是解决已经缩小到只有一个值的正方形。基于数独的规则，我们可以查看单个区域(行、列和框)来找出每个方块的不同值。这是向下钻取局部约束的过程；在这里是区域。
例如，让我们看看下图中顶部中间的红色方框。你可以看到我们几乎已经解决了这个区域，但还没有完全解决。由于这个方框中的每个方块必须是唯一的，我们知道 2、3、5、6 和 8 都不是未解方块的可能值。然而，我们可以看到，值 1 只可能出现在这个区域的右上角的正方形中，而该区域中的每个未解正方形都包含 4、7 或 9。
Udacity AI Nanodegree Program
这导致我们将 1 赋给那个正方形，因为它是值中的唯一选择，保证它在整个给定区域中是唯一的。接下来，计算机会在所有区域重复做同样的事情，直到找到解决方案。
Udacity AI Nanodegree Program
通过使用约束传播，我们可以教会计算机如何通过关注局部约束来解决几乎任何数独难题。但是你可能从经验中知道，有时候棋盘会达到一种“停滞”状态，在这种状态下，有些方块可以有多种值。也许对于任何特定的未解正方形，可供选择的最少数值是两个或更多！嗯，这将是一个你面对裸体双胞胎的例子，这表明在通往伟大的道路上有多条道路可供选择(解决难题)。让我们一起走向伟大。
搜索
如果在解数独谜题的时候，有一个点是你在一个不完整的解上停滞不前，你知道你在解这个谜题的时候做了一个曾经有效的选择，导致了一个无效的解。这意味着你必须回到你当初做那个选择的地方，做出一个不同的选择。希望你留下了面包屑。
实现一种搜索方法，允许计算机遍历可能导致有效解决方案的多个场景，这正是我们在这里想要的，当面对裸体双胞胎时，我们知道我们有两个选择。当在两个不同的方向之间做出选择时，我们必须扩展到两个不同的可能性世界。这可以使用一棵树来完成，特别是一棵(BST)。
现在，BST 由一个根节点组成，从这个根节点分支出两个方向，这些后续的点本身可以有从它们分支出的两个方向，依此类推。
https://i.stack.imgur.com/9jegh.png
现在把节点 A 想象成一个时间点，我们必须在两个决定中做出选择，最终不是 B 就是 c，在数独中，这和遇到裸体双胞胎(wut？);你必须在两条路径中选择一条，这两条路径可能会也可能不会产生有效的解决方案。
Udacity AI Nanodegree Program
如果你看上面的棋盘，你会注意到一个停滞的数独棋盘，左下角有一个方块，包含数值 8 和 9。既然我们被困在一个不完整的解决方案中，我们必须跃入未知，这意味着选择以一种方式解决难题，并希望它能成功。如果没有，我们知道哪里出了问题，并可以通过回溯和选择另一个选项来纠正我们的错误。
谁知道呢，也许在我们做出 8 或 9 的选择后，我们会遇到另一对裸体双胞胎(嗯…)，这将导致另一组可能性，从而在我们的树上出现另一组分支！通过将此建模为 BST，我们可以让计算机使用深度优先搜索遍历这些可能的解决方案，这将最终引导我们找到有效的解决方案。
这是智力吗？
现在计算机不知道有解存在。它只是在时间中前进，四处探索，希望能找到一个。虽然我们人类当然知道一个合适的数独棋盘有一个或多个有效解，但计算机不知道。这意味着它必须通过做出适当的选择来聪明地找到这些解决方案之一，因为解决这个难题所需的时间是未知的，在这种情况下，这被称为 NP 问题。
有些人可能不相信这是智力，但这真的取决于你对智力的定义是什么。它可能不会像 Siri 一样跟我们说话，但它肯定是在解决一个问题，而没有潜在的解决方案(就它所知)，也没有我们给它明确的条件语句。在解决数独谜题的情况下，我们只是告诉计算机:“你可以这样做，但不可以这样做。现在解决问题。”然后它就明白了。
彼得·诺维格——一位著名的人工智能研究员——发现了如何应用 BST 的约束传播和深度优先搜索来解决数独难题，并在这里详细讨论了它。他甚至深入研究了代码，以展示教计算机如何做到这一点是如何可能的。
包裹
我们讲述了在解决古老的数独难题时，约束传播与 BST 的深度优先搜索是如何完美结合的，这更好地告诉我们如何教会计算机自己做这件事。如果你有兴趣了解更多关于这个主题的知识，我强烈建议你阅读彼得·诺维格的帖子，在那里他提供了关于代码片段问题的更深入的观点。你也可以看看我为我的 Udacity 人工智能 Nanodegree 写的解决这个问题的代码，你可以在我的 GitHub repo 上找到。
嗨，我是格兰特！我是一名自由开发者和作家。查看我在 https://grantbartel.com 的网站。干杯！
如何编写 Jupyter 笔记本扩展
让 Jupyter 笔记本成为你的游乐场
Jupyter 笔记本扩展是简单的附加组件，可以显著提高您在笔记本电脑环境中的工作效率。它们自动执行乏味的任务，如格式化代码或添加功能，如创建目录。虽然有许多现有的扩展，我们也可以编写自己的扩展来扩展 Jupyter 的功能。
在本文中，我们将了解如何编写一个 Jupyter 笔记本扩展，在每个新笔记本的顶部添加一个默认单元格，这在您发现自己要向每个笔记本导入库时非常有用。如果你想了解扩展的背景，那么看看这篇文章。GitHub 上提供了该扩展的完整代码。
默认单元格扩展的最终结果如下所示:
Extension to add a default cell to the top of every notebook.
开始前的注意事项
(如果您还没有 Jupyter 扩展，查看本文或在命令提示符下运行以下代码:pip install jupyter_contrib_nbextensions && jupyter contrib nbextensions install然后启动一个新的笔记本服务器并导航到扩展选项卡)。
不幸的是，没有太多关于编写自己的扩展的官方文档。我的策略是阅读其他扩展，大量复制和粘贴，并进行试验，直到我弄明白为止。这个栈溢出问答提供了这个扩展的基本代码。
Jupyter 笔记本扩展的结构
任何 Jupyter 笔记本扩展都有 3 个部分(至少):
description.yaml:Jupyter 读取的配置文件main.js:扩展本身的 Javascript 代码README.md:扩展的降价描述
(我们也可以在其他文件或css中有更多的函数进行造型)。
这 3 个文件应该位于一个目录中，我们称之为default_cell。这个文件夹需要在jupyter_contrib_extensions库的nbextensions子目录中(你用 pip 安装的)。要找到安装了 pip 的库的位置，请运行pip view package。)
我的jupyter_contrib_extensions目录是:
/usr/local/lib/python3.6/site-packages/jupyter_contrib_nbextensions/nbextensions
所以文件结构看起来是这样的(如上图nbextensions):
nbextensions/
default_cell/
- description.yaml
- main.js
- README.md
当您运行jupyter notebook时，Jupyter 在这个位置查找扩展，并在服务器上的 extensions 选项卡上显示它们:
Jupyter Notebook Extensions tab
当您在开发过程中对扩展文件进行了更改，并且希望在 Jupyter 笔记本中看到效果时，您需要运行命令jupyter contrib nbextensions install来重写 Jupyter 配置文件。然后，重新启动笔记本服务器以查看您的更改。
详细情况说完了，让我们来看一下我们需要的三个文件。
描述. yaml
YAML (YAML 不是标记语言)是一种人类可读的标准，用于编写配置和头文件。YAML 文件描述了要在扩展选项卡上呈现的 Jupyter 扩展配置器的扩展。
这是一个相当容易的文件复制+粘贴和修改我们的需要。
这将很好地呈现在笔记本的NBExtensions选项卡上:
兼容性指明了该扩展适用的 Jupyter 版本。我刚刚把它们全部加了进去(3.x — 6.x ),看起来效果不错！
主页. js
这是应用程序的核心，是扩展的实际逻辑所在。Jupyter 笔记本在浏览器中运行，这意味着扩展必须用 Javascript 编写，Javascript 是 web 的语言。
要弄清楚使用什么命令来让笔记本做你想要的事情可能有点困难。一种试验方法是使用 Chrome 开发工具(Windows 上的 cntrl + shift + i)或右键单击> inspect。
开发工具打开后，我们可以使用console选项卡来运行命令。
Console in Chrome developer tools
尝试在 Jupyter 笔记本中打开开发者工具，使用以Jupyter.notebook.开头的选项，你输入的任何命令都必须是 Javascript 格式的。这种行为的一个例子可以在下面的剪辑中看到。我打开开发工具，然后运行一些命令来执行单元格，插入一个新的单元格，并选择前一个单元格。
开发 Javascript 代码需要大量这样的实验！这也有助于阅读其他扩展，以确定您需要做什么。
最终的main.js如下:
代码中最重要的部分是add_cell函数。
var add_cell = function() {
Jupyter.notebook.
insert_cell_above('code').
// Define default cell here
set_text(`Define default cell here`);
Jupyter.notebook.select_prev();
Jupyter.notebook.execute_cell_and_select_below();
};
这将在当前选中的单元格上方添加一个代码单元格，括号中写有 python 代码(在set_text调用中)。这是应该定义默认代码单元的地方。然后，该函数执行单元格并选择下面的单元格。
load_ipython_extension功能首先检查笔记本中的单元格数量。如果只有一个单元格——一个新的笔记本——它调用add_cell函数，将默认单元格放在笔记本的顶部。
// Run on start
function load_ipython_extension() {// Add a default cell if a new notebook
if (Jupyter.notebook.get_cells().length===1){
add_cell();
}
defaultCellButton();
}
然后运行defaultCellButton功能，在 Jupyter 笔记本工具栏上放置一个按钮。我们可以使用此按钮在当前选定的单元格上方添加并运行默认单元格。当我们有一个已经启动的笔记本并且我们想要我们的正常导入时，这可能是有用的。
Function of defaultCellButton
我们可以在浏览器中用 Javascript 完成几乎无限多的任务。这只是一个简单的应用程序，但是还有许多更复杂的 Jupyter 扩展(例如变量检查器)演示了更多的功能。我们还可以用 Javascript 编写应用程序，调用 Python 脚本来获得更好的控制。
README.md
一个 readme markdown 文件对任何一个有一点编程经验的人来说都应该是熟悉的。这里是我们解释我们的应用程序做什么以及如何使用它的地方。这显示在“扩展”选项卡上:
README rendered on the extensions tab
(实际的代码很无聊，但为了完整起见，在这里)
Default Cell**=========**Adds and runs a default cell at the top of each new notebook. To change the default cell, edit the `add_cell` function in the `main.js` file. The relevant section is`Jupyter.notebook.insert_cell_above('code', 0).set_text(``)`Set the `text` to whatever you would like.This extension also adds a button to the toolbar allowing you to insert and run the default cell above your current cell. This can be helpful if you open an already started notebook and notice you are missing some common imports.This extension is a work in progress and any help would be appreciated. Feel free to make contributions on GitHub or contact the author (Will Koehrsen) at wjk68@case.edu
一旦有了三个必需的文件，您的扩展就完成了。
要查看扩展的工作情况，请确保default_cell目录位于正确的位置，运行jupyter contrib nbextensions install并启动 Jupyter 笔记本服务器。如果您导航到NBExtensions选项卡，您将能够启用扩展(如果您没有该选项卡，请打开笔记本并编辑> nbextensions 配置)。
Extension enabled
启动新笔记本，查看您的扩展功能:
Default cell jupyter notebook extension
这个扩展不会改变你的生活，但是它可能会节省你几秒钟的时间！
结论
获得计算机知识的部分乐趣是意识到如果你想在计算机上完成某件事，有机会你可以用正确的工具和学习的意愿。这个制作 Jupyter 笔记本扩展的小例子表明，我们不会受到开箱即用产品的限制。我们只需要几行代码来完成我们的目标。
希望这个扩展证明对你有用或者启发你写你自己的。我从扩展中得到了很多用处，并期待看到人们还能开发出什么。一旦你开发了一个扩展，分享它，这样其他人可以惊叹你的代码并从你的努力工作中获益。
一如既往，我欢迎反馈和建设性的批评。可以通过推特 @koehrsen_will 或者通过我的个人网站 willk.online 找到我。
数据科学如何写一个生产级代码？
dreamstime/Scyther5
编写生产级代码的能力是数据科学家角色的抢手技能之一——无论是否明确公布。对于一个从软件工程师转型为数据科学家的人来说，这听起来可能不是一个具有挑战性的任务，因为他们可能已经完善了开发生产级代码的技能，并多次部署到生产中。
本文面向那些刚开始编写生产级代码并对学习它感兴趣的人，如大学应届毕业生或任何进入数据科学领域(或计划转型)的专业人士。对他们来说，编写生产级代码似乎是一项艰巨的任务。
我会给你一些关于如何编写生产级代码并实践它的技巧，你不一定要在数据科学的角色中学习这项技能。
1。保持模块化
这基本上是推荐给任何软件工程师的软件设计技术。这里的想法是根据它的功能将一个大的代码分成小的独立部分(函数)。它有两个部分。
(I)将代码分成较小的部分，每个部分用于执行特定的任务(可能包括子任务)
(ii)基于其可用性将这些功能分组到模块(或 python 文件)中。它还有助于保持组织性和代码的易维护性
第一步是将一个大代码分解成许多具有特定输入(和输入格式)和输出(和输出格式)的简单函数。如前所述，每个函数应该执行一个任务，如清除数据中的异常值、替换错误值、对模型评分、计算均方根误差(RMSE) 等等。试着将这些功能进一步分解为执行子任务，继续下去，直到没有功能可以进一步分解。
低级函数 —不能再分解的最基本的函数。例如，计算数据的 RMSE 或 Z 分数。这些函数中的一些可以广泛用于任何算法或机器学习模型的训练和实现。
中级功能 —使用一个或多个低级功能和/或其他中级功能来执行其任务的功能。例如，清除异常值函数使用计算 Z 值函数来移除异常值，只保留特定范围内的数据，或者使用计算 RMSE 函数的误差函数来获取 RMSE 值。
高级功能 —使用一个或多个中级功能和/或低级功能来执行其任务的功能。例如，使用几个函数的模型训练函数，例如获得随机采样数据的函数、模型评分函数、度量函数等。
最后的步骤是将对多个算法有用的所有低级和中级函数分组到一个 python 文件中(可以作为一个模块导入),并将仅对所考虑的算法有用的所有其他低级和中级函数分组到另一个 python 文件中。所有的高级函数都应该驻留在一个单独的 python 文件中。这个 python 文件规定了算法开发的每个步骤——从组合来自不同来源的数据到最终的机器学习模型。
遵循以上步骤没有硬性规定，但是我强烈建议你从这些步骤开始，然后发展你自己的风格。
2。测井和仪器仪表
记录和仪表(LI)类似于飞机上的黑匣子，记录驾驶舱内发生的所有事情。LI 的主要目的是记录代码执行过程中的有用信息，帮助程序员在出现问题时进行调试，并提高代码的性能(如减少执行时间)。
日志记录和检测有什么区别？
(i)日志记录— 仅记录可操作的信息，如运行时的关键故障，以及结构化数据，如代码本身稍后将使用的中间结果。在开发和测试阶段，可以接受多种日志级别，如调试、信息、警告和错误。然而，在生产过程中要不惜一切代价避免它们。
日志记录应尽量少，仅包含需要人工关注和立即处理的信息。
(ii)检测— 记录日志中遗漏的所有其他信息，这些信息将帮助我们验证代码执行步骤，并在必要时改进性能。在这种情况下，拥有更多的数据总是更好，因此要尽可能多地收集信息。
为了验证代码执行步骤——我们应该记录诸如任务名称、中间结果、经过的步骤等信息。这将有助于我们验证结果，并确认算法遵循了预期的步骤。无效的结果或异常执行的算法可能不会引发在日志记录中会被捕获的严重错误。因此记录这些信息是必要的。
为了提高性能，我们应该记录每个任务/子任务花费的时间和每个变量使用的内存。这将有助于我们改进代码，进行必要的修改，优化代码以运行得更快并限制内存消耗(或者识别 python 中常见的内存泄漏)。
插装应该记录日志中遗漏的所有其他信息，这些信息将帮助我们验证代码执行步骤并致力于性能改进。数据多总比少好。
3。代码优化
代码优化意味着降低时间复杂度(运行时间)和降低空间复杂度(内存使用)。时间/空间复杂度通常表示为 O(x)，也称为 Big-O 表示法 其中 x 是时间或空间占用多项式中的主导项。时间复杂度和空间复杂度是衡量 算法效率 的度量。
例如，假设我们有一个嵌套的 for 循环，每个循环的大小为 n ，每次运行大约需要 2 秒，然后是一个简单的 for 循环，每次运行需要 4 秒。那么时间消耗的等式可以写成
耗时~ 2 n +4 n = O(n +n) = O(n)
对于 Big-O 表示，我们应该去掉非主导项(因为它可以忽略不计，因为 n 趋向于 inf )以及系数。系数或比例因子被忽略，因为我们在优化灵活性方面对其控制较少。请注意，绝对耗时中的系数是指循环的数量与每次运行所用时间的乘积，而 O(n +n)中的系数代表循环的数量(1 个双用于循环，1 个单用于循环)。同样，我们应该从等式中去掉低阶项。因此，上述过程的大 O 是 O(n)。
现在，我们的目标是用时间复杂度更低的更好的替代方案替换效率最低的代码部分。比如 O(n)比 O(n)好。代码中最常见的杀手是循环的*，最不常见但比循环的更糟糕的是递归函数(O(branch^depth)).尝试用 python 模块或函数替换尽可能多的 for 循环，这些模块或函数通常用可能的 C 代码执行计算进行了大量优化，以实现更短的运行时间。*
我强烈推荐你阅读盖尔·麦克道尔的《破解编码采访中关于“大 O”的部分。事实上，试着通读整本书来提高你的编码技能。
4。单元测试
单元测试——根据功能自动化代码测试
您的代码在进入生产之前必须清除多个测试和调试阶段。通常有三个级别—开发、试运行和生产。在一些公司中，在生产之前会有一个模拟生产系统确切环境的阶段。代码应该没有任何明显的问题，并且应该能够在进入生产时处理潜在的异常。
为了能够识别可能出现的不同问题，我们需要针对不同的场景、不同的数据集、不同的边缘和角落情况等来测试我们的代码。每次我们想要测试代码时，手动执行这个过程是低效的，因为每次我们对代码进行重大修改时都会这样。因此，选择包含一组测试用例的单元测试，它可以在我们想要测试代码的任何时候执行。
我们必须添加具有预期结果的不同测试用例来测试我们的代码。单元测试模块逐个检查每个测试用例，并将代码的输出与期望值进行比较。如果没有达到预期的结果，测试就会失败——这是您的代码在部署到产品中时会失败的早期迹象。我们需要调试代码，然后重复这个过程，直到所有的测试用例都被清除。
为了让我们的生活变得简单，python 有一个名为 unittest 的模块来实现单元测试。
5。与生态系统的兼容性
最有可能的是，你的代码不会是一个独立的函数或模块。它将被整合到公司的代码生态系统中，您的代码必须与生态系统的其他部分同步运行，没有任何缺陷/故障。
例如，假设你开发了一个算法来给出推荐。流程通常包括从数据库中获取最近的数据，更新/生成推荐，将其存储在数据库中，该数据库将被前端框架(如网页)读取(使用 API)以向用户显示推荐的项目。简单！它就像一条链条，新的链环应该与前一个和下一个链环锁在一起，否则该过程将失败。同样，每个进程都必须按预期运行。
每个流程都有明确定义的输入和输出需求、预期的响应时间等等。如果当其他模块(从网页)请求更新的建议时，您的代码应该在可接受的时间内以期望的格式返回期望值。如果结果是意想不到的值(当我们在购买电子产品时建议购买牛奶)，不希望的格式(以文本而不是图片的形式提出的建议)，以及不可接受的时间(没有人等待分钟来获得建议，至少在这些日子里)，这意味着代码与系统不同步。
避免这种情况的最好方法是在我们开始开发过程之前与相关团队讨论需求。如果团队不在，仔细阅读代码文档(很可能你会在那里找到很多信息)和代码本身，如果必要的话，理解需求。
6。版本控制
git——一个版本控制系统是最近发生在源代码管理上的最好的事情之一。它跟踪对计算机代码的修改。也许有许多现有的版本控制/跟踪系统，但是与其他任何系统相比，Git 被广泛使用。
这个过程简单来说就是“修改和提交”。我把它过分简化了。这个过程有很多步骤，例如创建一个开发分支，在本地提交更改，从远程提取文件，将文件推送到远程分支，等等，我将留给您自己去探索。
每当我们对代码进行更改时，我们不是用不同的名称保存文件，而是提交更改——这意味着用新的更改覆盖旧的文件，并使用与之链接的键。我们通常在每次提交代码变更时都要写注释。比方说，你不喜欢在最后一次提交中所做的更改，并且想要恢复到以前的版本，使用提交引用键可以很容易地做到这一点。Git 对于代码开发和维护来说是如此强大和有用。
您可能已经理解了为什么这对生产系统很重要，以及为什么必须学习 Git。我们必须总是能够灵活地回到稳定的旧版本，以防新版本意外失败。
7。可读性
你写的代码对其他人来说也应该是容易理解的，至少对你的团队成员来说是这样。此外，如果没有遵循正确的命名约定，即使是对您来说，在编写代码后的几个月内理解自己的代码也是一个挑战。
(一)适当的变量和函数名
变量和函数名应该是不言自明的。当有人阅读你的代码时，应该很容易找到每个变量包含什么，每个函数做什么，至少在某种程度上是这样。
使用一个能清楚说明其功能/作用的长名称，而不是使用诸如 x、y、z 等短名称，是完全可以的。，那都是模糊的。变量名不要超过 30 个字符，函数名不要超过 50–60 个字符。
以前，基于完全过时的 IBM 标准，标准代码宽度是 80 个字符。现在按照 GitHub 的标准，大概是 120 左右。为角色名设置 1/4 的页面宽度限制，我们得到 30，这足够长了，但并没有填满页面。函数名可以稍微长一点，但是也不应该占满整个页面。因此，通过设置 1/2 页宽的限制，我们得到 60。
例如，样本数据中亚洲男性平均年龄的变量可以写成 mean_age_men_Asia 而不是年龄或 x 。类似的论点也适用于函数名。
(二)文档字符串和注释
除了适当的变量名和函数名之外，在任何必要的地方都要有注释和注解，以帮助读者理解代码。
文档字符串 —特定于函数/类/模块。函数定义中的前几行文本，描述函数的角色及其输入和输出。文本应该放在一组 3 个双引号之间。
定义<function_name>:</function_name>
" " " “” " "
返回
注释 —可以放在代码中的任何位置，以告知读者特定部分/行的操作/角色。如果我们给变量和函数起一个合适的名字，注释的需求就会大大减少——代码在很大程度上是不言自明的。
代码审查:
尽管这不是编写产品质量代码的直接步骤，但是您的同行对代码的评审将有助于提高您的编码技能。
没有人能写出完美的计算机代码，除非有人有 10 年以上的经验。总会有改进的余地。我见过有几年编写糟糕代码经验的专业人士，也见过有杰出编程技能的正在攻读学士学位的实习生——你总能找到比你更好的人。这完全取决于一个人投入了多少时间来学习、练习，最重要的是提高这一特殊技能。
我知道比你更好的人总是存在的，但是在你的团队中并不总是可能找到他们，只有他们你才能分享你的代码。也许你是你团队中最棒的。在这种情况下，让团队中的其他人测试你的代码并给出反馈是可以的。即使他们没有你好，有些东西可能会逃过你的眼睛，他们可能会抓住。
当您处于职业生涯的早期阶段时，代码审查尤其重要。这将极大地提高你的编码技能。请按照下面的步骤成功审查您的代码。
(I)在您完成所有开发、测试和调试的代码编写之后。确保你没有遗漏任何愚蠢的错误。然后恳请您的同行进行代码审查。
(ii)将您的代码链接转发给他们。不要让他们一次复习几个剧本。一个接一个地问他们。他们对第一个脚本的评论可能也适用于其他脚本。在发送第二个脚本进行审查之前，请确保将这些更改应用于其他脚本(如果适用)。
(iii)给他们一到两周的时间来阅读和测试你每次迭代的代码。还要提供所有必要的信息来测试您的代码，比如样本输入、限制等等。
㈣与他们每个人会面，听取他们的建议。记住，你不必在你的代码中包含他们所有的建议，根据你自己的判断选择那些你认为会改进代码的建议。
(v)重复，直到你和你的团队满意为止。尝试在最初的几次迭代(最多 3-4 次)中修复或改进您的代码，否则它可能会对您的代码能力产生不好的印象。
希望这篇文章是有帮助的，你喜欢阅读它。
我很乐意阅读您的反馈。
如何用 R 编写整洁的 SQL 查询
如今，我们大多数人都必须与数据库进行交互，而 SQL 是目前最常用的语言。然而，在 R 中使用 SQL 可能会很麻烦。如果您的查询很复杂，您必须将它们编码为文本字符串，这很容易出错，并且面临格式方面的挑战。此外，当您想要构建包含变量的 SQL 查询时，您必须进行替换或粘贴，这有点麻烦。
理想情况下，您希望能够使用 tidy 原则处理您的数据库，利用 tidyverse 的奇迹，最好不要先将整个数据库下载到您的会话中。这就是dbplyr的魔力所在。
dbplyr充当 SQL 翻译器，允许你使用tidyverse来处理数据库。所以现在你可以尽情宣泄了。如果你还没有用过这个，我现在就开始用。编写整洁的数据库查询有许多优点。当你过一段时间再回到你的工作时，你可以更容易地理解你的工作，你可以更清楚地评论，并且它也迫使你去思考你的查询的最有效的结构。
在 dbplyr 中工作的基本原则
要在dbplyr中工作，您需要像在 R 会话中一样设置数据库连接，我们称之为myconn。您将使用dbplyr::in_schema()在 R 会话中设置数据库对象。这需要两个参数:第一，您希望在数据库连接中访问的模式，第二，您在该模式中感兴趣的表。下面是一个如何设置的示例:
catdata <- dplyr::tbl(
myconn,
dbplyr::in_schema("ANIMAL_ANALYSTS", "CAT_TABLE")
)
现在catdata是一个数据库对象。上面的命令连接到数据库并下载关于字段、数据类型等的最少信息。—足以允许操纵对象，而无需物理下载数据。
现在，您可以像操作 r 中的其他表一样操作catdata。例如:
weight_by_age <- catdata %>%
dplyr::group_by(AGE) %>%
dplyr::summarise(AVG_WT = mean(WT, na.rm = TRUE))
所有这些操作都是通过在后台将您的代码翻译成 SQL，而无需实际下载数据。由于数据下载通常是最耗时的步骤，这允许您在提取数据之前考虑您希望在服务器上完成多少工作。
准备拉数据的时候，用dplyr::collect()就可以了。这将把后台编译的 SQL 查询发送到数据库并执行它。例如:
weight_by_age %>%
dplyr::rename(`Age of Cat` = AGE,
`Average Weight` = AVG_WT) %>%
dplyr::collect()
dbplyr 中更复杂的 SQL 操作
dbplyr非常灵活，我还没有发现我不能用dbplyr重写 tidy 的 SQL 查询。
连接通过在数据库对象上使用dplyr的连接函数来工作，例如:
fullcatdata <- dplyr::left_join(
catregistrationdetails,
catdata,
by = "SERIAL_NO"
) %>%
dplyr::left_join(
cathealthrecord,
by = "SERIAL_NO"
)
可以使用dplyr::mutate()将新列添加到数据中，甚至可以用于更复杂的连接。例如，如果您的卡特彼勒序列号在一个表中有“CAT-”开头，但在另一个表中没有:
fullcatdata <- catregistrationdetails %>%
dplyr::mutate(SERIAL_NO = paste0("CAT-", SERIAL_NO)) %>%
dplyr::left_join(catdata, by = "SERIAL_NO")
dbplyr巧妙地将 R 函数翻译成 SQL 等价物。您可以使用dbplyr::translate_sql()功能来查看它的功能。例如:
dbplyr::translate_sql(substr(NAME, -3, -1))
<SQL> substr("NAME", -3, 3)
我发现dbplyr也让我在反应式环境中更容易编码。如果你要建立一个闪亮的应用程序，根据输入计算猫的平均体重input$age:
weight <- reactive({
catdata %>%
dplyr::filter(AGE == input$age) %>%
dplyr::select(WT) %>%
mean(na.rm = TRUE) %>%
dplyr::collect()
})
这些只是dbplyr帮助您在 SQL 中更整洁地工作的许多方式中的一部分。我强烈推荐。
关于 *dbplyr* 的更多信息，请点击 这里 。
最初我是一名纯粹的数学家，后来我成为了一名心理计量学家和数据科学家。我热衷于将所有这些学科的严谨性应用到复杂的人的问题上。我也是一个编码极客和日本 RPG 的超级粉丝。在LinkedIn或Twitter上找我。
如何用 Python 写你最喜欢的 R 函数？
r vs Python——争论仍在继续。与此同时，我们尝试走一条中间道路，创建一个 Python 脚本来模仿方便的 R 风格函数，以便更好、更容易地进行统计！
介绍
数据科学和机器学习的现代大战之一是“Python vs. R”。毫无疑问，这两种语言近年来都取得了巨大的进展，成为数据科学、预测分析和机器学习的首选编程语言。事实上，在 IEEE 最近的一篇文章中，Python 取代 C++成为 2018 年的顶级编程语言，R 也牢牢占据了前 10 名的位置。
然而，这两者之间有一些基本的区别。 R 最初是作为统计分析和数据分析问题的快速原型开发的工具。另一方面，Python 是作为一种通用的现代面向对象语言开发的，与 C++或 Java 一脉相承，但具有更简单的学习曲线和更灵活的风格。因此，R 继续在统计学家、定量生物学家、物理学家和经济学家中非常流行，而 Python 已经慢慢成为日常脚本、自动化、后端 web 开发、分析和通用机器学习框架的首选语言，具有广泛的支持基础和开源开发社区工作。
在 Python 环境下模仿函数式编程？
R的函数式编程特性为用户提供了极其简单紧凑的界面，用于快速计算概率和对数据分析问题进行必要的描述/推断统计。例如，仅仅通过一个简单的函数调用就能回答下面的问题，这不是很好吗？
如何计算一个数据向量的均值/中值/众数？
如何计算服从正态分布的事件的累积概率？如果分布是泊松分布呢？
如何计算一系列数据点的四分位间距？
如何生成几个服从学生 t 分布的随机数？
r 编程环境允许您这样做。
另一方面，Python 脚本能力允许分析师在各种各样的分析管道中使用这些统计数据，具有无限的复杂性和创造性。
为了结合两个世界的优势，我们需要一个简单的基于 Python 的包装器库，它包含了最常用的与概率分布和描述性统计相关的函数，这些函数在 R-style 中定义，这样用户就可以非常快速地调用这些函数，而不必去适当的 Python 统计库，找出所有的方法和参数。
用于最方便的 R 函数的 Python 包装器脚本
我写了一个 Python 脚本，用 Python 定义了简单统计分析中最方便、最广泛使用的 R 函数。导入这个脚本后，您将能够像在 R 编程环境中一样自然地使用这些 R 函数。
该脚本的目标是提供简单的 Python 子程序，模仿 R 风格的统计函数，用于快速计算密度/点估计值、累积分布、分位数，并为各种重要的概率分布生成随机变量。
为了保持 R 风格的精神，没有使用类层次结构，只在这个文件中定义了原始函数，这样用户就可以导入这个 Python 脚本，并在需要时通过一个名字调用来使用所有的函数。
注意，我用 这个词模仿 。在任何情况下，我都不会声称要模仿真正的 R 函数式编程范例，它包含了深层的环境设置以及这些环境和对象之间复杂的相互关系。这个脚本只允许我(我希望无数其他 Python 用户也是)快速启动 Python 程序或 Jupyter 笔记本，导入脚本，并立即开始做简单的描述性统计。这就是目标，不多不少。
或者，您可能在研究生院编写了 R 代码，刚刚开始学习和使用 Python 进行数据分析。您将会很高兴在 Jupyter 笔记本上看到并使用一些众所周知的功能，就像您在 R 环境中使用的方式一样。
不管是什么原因，这都很有趣:-)。
简单的例子
首先，只需导入脚本并开始处理数字列表，就像它们是 r 中的数据向量一样。
**from R_functions import ***
lst=[20,12,16,32,27,65,44,45,22,18]
<more code, more statistics...>
例如，你想从一个矢量数据点中计算出 Tuckey 五个数 summary。你只需要调用一个简单的函数 fivenum 并传递向量。它将在 Numpy 数组中返回五个数字的摘要。
lst=[20,12,16,32,27,65,44,45,22,18]
**fivenum**(lst)
> array([12\. , 18.5, 24.5, 41\. , 65\. ])
或者，你想知道下面这个问题的答案。
假设一台机器每小时平均产出 10 件成品，标准偏差为 2。输出模式遵循近似正态分布。机器在接下来的一个小时内输出至少 7 台但不超过 12 台的概率是多少？
答案基本上是这样的，
使用 pnorm …只需一行代码就能得到答案
**pnorm**(12,10,2)-**pnorm**(7,10,2)
> 0.7745375447996848
或者，下面，
假设你有一枚装了子弹的硬币，每次扔的时候，有 60%的概率正面朝上。你在玩 10 次投掷的游戏。你如何用这枚硬币画出所有可能的中奖概率(从 0 到 10)？
只用几行代码和一个函数 dbinom …，你就可以得到一个漂亮的条形图
probs=[]
import matplotlib.pyplot as plt
for i in range(11):
probs.append(**dbinom**(i,10,0.6))
plt.bar(range(11),height=probs)
plt.grid(True)
plt.show()
概率计算的简单界面
r 为从基本概率分布中快速计算提供了一个极其简化和直观的界面，令人惊叹。界面是这样的…
- d{分布} —给出点 x 的密度函数值
- p{分布} —给出点 x 的累积值
- q 【分布】—以概率 p 给出分位数函数值
- r{分布} —生成一个或多个随机变量
在我们的实现中，我们坚持使用这个接口和相关的参数列表，这样您就可以像在 R 环境中一样执行这些函数。
当前实现的功能
目前，脚本中实现了以下 R 风格的函数用于快速调用。
- 均值、中值、方差、标准差
- 塔基五号总结，IQR
- 矩阵或两个向量之间的协方差
- 以下分布的密度、累积概率、分位数函数和随机变量生成-正态分布、均匀分布、二项式分布、泊松分布、f 分布、学生 t 分布、卡方分布、贝塔分布和伽玛分布。
工作正在进行中…
显然，这是一项正在进行的工作，我计划在这个脚本中添加一些更方便的 R 函数。例如，在 R 中，一行简单的命令lm就可以让你得到一个普通的最小二乘拟合模型，它是一个带有所有必要的推断统计数据(P 值、标准误差等)的数字数据集。).这是强有力的简洁和紧凑！另一方面，Python 中的标准线性回归问题通常使用 Scikit-learn 来解决，这需要更多的脚本来完成。我计划使用 Python 的 statsmodels 后端整合这个单一函数线性模型拟合特性。
如果你喜欢这个脚本，并在你的工作中找到它的用处，请在我的 GitHub repo 上签名并传播这个消息。
如果您有任何问题或想法要分享，请通过tirthajyoti【AT】Gmail . com联系作者。此外，您可以查看作者的 GitHub 资源库 中其他有趣的 Python、R 或 MATLAB 代码片段和机器学习资源。如果你像我一样对机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。
如果你喜欢这篇文章，请别忘了留下掌声:-)
追踪应用如何分析你的 GPS 数据:Python 实践教程
如今，运动追踪应用和伴随它们的社交网络无处不在。每个人都想在像 Nike+ Run 或 Strava 这样的应用上做出最大或最快的努力。但是你有没有想过所有这些花哨的统计数据是从哪里来的，或者它们是如何计算出来的？
我们先来解释一下你的手机是如何知道你在哪里的，或者更准确的说，你手机里的 GPS 接收器是如何知道你在哪里的。全球定位系统(GPS)是美国政府拥有的基于卫星的无线电导航系统。
它是一个全球导航卫星系统，向地球上任何地方的 GPS 接收机提供地理位置和时间信息，在那里可以畅通无阻地看到四颗或更多的 GPS 卫星。你的手机接收器的位置通常被转换成纬度，经度和海拔，伴随着一个时间戳，并存储为一个 gpx 文件(更多关于文件格式如下)。
在本教程中，我们将使用 Python 在 Jupyter 笔记本中提取、管理和分析一条路线的 gpx 数据。我们将从把数据从 gpx 文件提取到一个方便的 pandas 数据框架开始。从那里，我们将探索数据，并尝试复制我们最喜欢的运行应用程序的界面为我们提供的统计数据和图表。
获取数据
大多数流行的追踪应用程序允许你下载你的成果作为一个 gpx 文件。在本教程中，我们下载了来自 Strava 的 11 公里跑步记录。gpx-file 是 GPS 交换格式的简称，通常可以通过点击导出获得。下面的截图显示了你可以在哪里下载你的 gpx 文件。你可以在这里下载本文使用的文件。
Export data as gpx-fle
Gpx 是一种 XML 模式，设计为软件应用程序的通用 GPS 数据格式。它可以用来描述路点、轨迹和路线。这也意味着下面的所有代码都可以用于运行任何GPS 数据，只要你考虑到运动的速度和类型。
首先，理解我们的 gpx 文件的结构很重要。在任何文本编辑器(这里是 Notepad ++ )中打开文件后，您应该会得到一个XML-文件，其中包含许多条目，如下所示。注意每个轨迹点由四个值组成:纬度、经度、海拔或海拔和一个时间戳。这四个价值将是我们分析的基础。
加载数据
现在，我们想将 gpx 数据加载到 pandas 数据框架中。没有直接的方法可以做到这一点，所以我们必须使用 gpxpy 库来帮助我们。当我们导入模块时，您可能希望确保您也安装了以下库: matplotlib ， datetime ， geopy ， math ， numpy ， pandas ， haversine 和 plotly (可选)。下载这些库，并确保下面的代码可以成功运行。
import gpxpy
import matplotlib.pyplot as plt
import datetime
from geopy import distance
from math import sqrt, floor
import numpy as np
import pandas as pd
import plotly.plotly as py
import plotly.graph_objs as go
import haversine
将 gpx 数据加载到 Python 中就像以读取模式打开文件并将其解析成一个新变量一样简单。
gpx_file = open('my_run_001.gpx', 'r')
gpx = gpxpy.parse(gpx_file)
看一下这个新对象，注意它是一个由一系列 GPXTrack 对象组成的 GPX 对象。GPXTrack 对象依次存在于一系列 GPXTrackSegment 对象中，这些对象依次存在于 GPXTrackPoints 中。这些点是我们感兴趣的四值数据点。可以通过经度、纬度、高程和时间属性访问。
在使用数据之前，检查数据在这些对象之间是如何划分的很重要。您可以通过检查轨道、段和点列表的长度来完成此操作。
len(gpx.tracks)
len(gpx.tracks[0].segments)
len(gpx.tracks[0].segments[0].points)
在我们的例子中，轨道和片段的长度都是 1。这意味着所有数据都集中在第一个轨迹的第一个段的点属性中。创建一个直接指向数据点列表的新变量是有意义的。
data = gpx.tracks[0].segments[0].points
看看你的起点和终点，确保一切都有意义(即开始时间
## Start Position
start = data[0]
## End Position
finish = data[-1]
一旦你找到了所有的数据，把所有的东西都放进一个数据框就很容易了。只需创建一个空的数据帧，并在将所有数据点添加到数据帧时遍历所有数据点。
df = pd.DataFrame(columns=['lon', 'lat', 'alt', 'time'])for point in data:
df = df.append({'lon': point.longitude, 'lat' : point.latitude, 'alt' : point.elevation, 'time' : point.time}, ignore_index=True)
数据帧的头部应该如下所示:
请注意，数据点之间的时间间隔应该是一秒钟(对于 Strava，您可以在设置中进行更改)。不幸的是，由于连接问题，我的设备无法始终提供 GPS 数据。在这种失败的情况下，数据点被跳过(没有任何种类的错误),应用程序将在下一个时间间隔收集数据。重要的是要记住这一点，以便进一步分析，而不是假设所有点之间的间隔是相同的。
绘制数据
现在我们已经加载了数据，我们可以通过绘制一些基本的图表来开始探索它。最简单的两个是 2d 地图(经度对纬度)和我们在活动中的高度增益(高度对时间)。将这些图与我们应用程序中的图进行比较，我们可以看到，到目前为止，我们做得相当不错。
plt.plot(df['lon'], df['lat'])
plt.plot(df['time'], df['alt'])
如果我们想变得更有趣，我们可以用 plotly 绘制一条数据的交互式 3d 线。虽然这个情节是否给我们的故事增加了任何分析价值还有待商榷，但从另一个角度看你付出的巨大努力总是让人感觉很好。如果你以前没有用过 plotly，别忘了在 plot.ly 上创建一个账户，并在凭证文件中设置你的用户名和 API-key。
_data = [go.Scatter3d(x=df['lon'],
y=df['lat'], z=df['alt'], mode='lines')]py.iplot(_data)
如果你想学习如何在谷歌地图上叠加你的地图，看看这个关于 gmplot 的教程。
转换数据
虽然到目前为止我们做得很好，但我们仍然缺少一些关键价值，如距离和速度。计算这两个似乎不太难，但是有几个陷阱。第一，我们必须考虑两个 LL 点(经度，纬度)之间的距离不是直线，而是球面。
Spherical distance vs Euclidean distance
有两种主要的方法来计算球面上两点之间的距离:哈弗森距离和文森特距离。这两个公式采用不同的方法计算距离，但这超出了本文的范围。你可以在他们的维基百科页面找到更多信息:哈弗辛公式维基和文森提公式维基。
下一个问题是，我们可能要在计算中考虑海拔的增加或减少。最简单的方法是计算球面 2d 距离，然后使用欧几里德公式添加第三维度。下面的公式显示了这最后一步。
distance _ 3d = sqrt(distance _ 2d * * 2+(alt 2—alt 1)* * 2)
现在我们有了所有需要的理论背景，我们可以开始在代码中实现这个公式了。为了方便起见，我们让数据框架保持原样，并像以前一样遍历所有数据点。我们为距离公式的每一个可能的实现创建一个列表(Haversine 或 Vincenty 和 2d 或 3d ),并将每个数据点的总距离添加到列表的末尾。
当我们遍历数据点时，我们还为所有连续数据点之间的高度差、时差和距离差创建了一个列表。
alt_dif = [0]
time_dif = [0]
dist_vin = [0]
dist_hav = [0]
dist_vin_no_alt = [0]
dist_hav_no_alt = [0]
dist_dif_hav_2d = [0]
dist_dif_vin_2d = [0]for index in range(len(data)):
if index == 0:
pass
else:
start = data[index-1]
stop = data[index]
distance_vin_2d = distance.vincenty((start.latitude, start.longitude), (stop.latitude, stop.longitude)).m dist_dif_vin_2d.append(distance_vin_2d)
distance_hav_2d = haversine.haversine((start.latitude, start.longitude), (stop.latitude, stop.longitude))*1000dist_dif_hav_2d.append(distance_hav_2d)
dist_vin_no_alt.append(dist_vin_no_alt[-1] + distance_vin_2d)
dist_hav_no_alt.append(dist_hav_no_alt[-1] + distance_hav_2d)
alt_d = start.elevation - stop.elevation
alt_dif.append(alt_d)
distance_vin_3d = sqrt(distance_vin_2d**2 + (alt_d)**2)
distance_hav_3d = sqrt(distance_hav_2d**2 + (alt_d)**2)
time_delta = (stop.time - start.time).total_seconds()
time_dif.append(time_delta)
dist_vin.append(dist_vin[-1] + distance_vin_3d)
dist_hav.append(dist_hav[-1] + distance_hav_3d)
为了进一步方便，我们可以将数据放入之前创建的 dataframe 中。
df['dis_vin_2d'] = dist_vin_no_alt
df['dist_hav_2d'] = dist_hav_no_alt
df['dis_vin_3d'] = dist_vin
df['dis_hav_3d'] = dist_hav
df['alt_dif'] = alt_dif
df['time_dif'] = time_dif
df['dis_dif_hav_2d'] = dist_dif_hav_2d
df['dis_dif_vin_2d'] = dist_dif_vin_2d
使用下面的 print 命令检查结果。
print('Vincenty 2D : ', dist_vin_no_alt[-1])
print('Haversine 2D : ', dist_hav_no_alt[-1])
print('Vincenty 3D : ', dist_vin[-1])
print('Haversine 3D : ', dist_hav[-1])
print('Total Time : ', floor(sum(time_dif)/60),' min ', int(sum(time_dif)%60),' sec ')
输出应该是这样的。让我们将我们的结果与跑步应用程序显示的统计数据进行比较。
有几件事需要注意。首先，我们所有的总距离计算——尤其是 2d 的——似乎是我们的应用程序为我们计算的距离的一个很好的近似值。其次，总活动时间与我们的计算完全一致，但移动时间似乎不同。
这可能意味着每当两个数据点之间的距离过小时，应用程序就会停止移动时间，但仍然会考虑距离，例如，当我们必须减速并停下来等红绿灯时，这可能是现实的。
在这种情况下，我们的二维计算是正确的，我们可以得出结论，该应用程序没有考虑海拔。app 公司的一篇博文确实证实了这一点。
假设表面平坦，不考虑来自地形的垂直速度。—斯特拉瓦
令人担忧？不完全是。应用程序提出的距离和我们最大的 3d 估计值之间的差异只有 61m (0.55%)。这意味着 100 公里跑(或骑行)的总四舍五入将是大约 600 米。请注意，如果你从事更高强度的活动(山地自行车或徒步旅行)，这种差异会增加。
让我们看看是否可以找出 Strava 使用哪个阈值来停止计时器(从而提高我们的平均速度)。要做到这一点，我们需要创建一个新的变量来计算我们每秒米数的运动(而不仅仅是每个数据点的运动，因此我们创建了时间差变量)。让我们为我们的哈弗辛二维距离这样做，因为这是由应用程序提出的距离的最接近的近似值。
df['dist_dif_per_sec'] = df['dis_dif_hav_2d'] / df['time_dif']
有了这个新变量，我们可以迭代一系列阈值，比如说 50 厘米和 1 米之间的阈值，并尝试找出哪个阈值的计时器超时最接近 51 秒。
for treshold in [0.5, 0.6, 0.7, 0.8, 0.9, 1]:
print(treshold, 'm', ' : Time:',
sum(df[df['dist_dif_per_sec'] < treshold]['time_dif']),
' seconds')
你的笔记本应该打印出这样的内容。
因此，我们可以得出结论，如果每秒钟的移动小于 80 厘米，应用程序不会将其视为移动，并停止计时器。这似乎很合理，因为每秒 80 厘米大约是每小时 2.9 公里，这个速度远远低于大多数人他们的步行的速度。
说到速度，我们不妨计算一下每个数据点的速度。首先，我们在数据框架中创建了一个名为 speed 的新列。这个新变量的计算方法是，用以米为单位的行驶距离除以以秒为单位的时间，然后转换为公里/小时。
df['spd'] = (df['dis_dif_hav_2d'] / df['time_dif']) * 3.6
接下来，我们过滤掉每秒移动大于 90 厘米的所有数据(原因见上一节)。
df_with_timeout = df[df['dist_dif_per_sec'] > 0.9]
然后我们计算加权平均速度，并将其转换为每公里分钟秒(跑步者广泛使用的度量标准)。
avg_km_h = (sum((df_with_timeout['spd'] *
df_with_timeout['time_dif'])) /
sum(df_with_timeout['time_dif']))print(floor(60 / avg_km_h), 'minutes',
round(((60 / avg_km_h - floor(60 / avg_km_h))*60), 0),
' seconds')
这导致平均速度为每公里 5 分 3 秒，与我们的应用程序提出的速度完全相同。让我们也画一个我们的速度图。为每秒绘制一个数据点会过于精细，所以我们将为每 10 秒绘制一个平均速度数据点。
因此，创建一个新的变量，将我们的时间差的累积和向下舍入到 10 秒，并根据它绘制聚合速度。
df['time10s'] = list(map(lambda x: round(x, -1)
, np.cumsum(df['time_dif'])))
plt.plot(df.groupby(['time10s']).mean()['spd'])
结果是一个平滑的线图，我们可以看到以千米/小时为单位的速度和以秒为单位的时间。
我们要仔细研究的最后一个指标是仰角增益。根据 apps 文档，累积高度增益是指整个行程中每次高度增益的总和。这意味着我们应该只考虑正的高度增益。
我们可以写一个简单的函数，把它映射到数据帧的高度差栏上。
def positive_only(x):
if x > 0:
return x
else:
return 0pos_only = list(map(positive_only, df['alt_dif']))sum(pos_only)
总和约为 237 米，与我们的应用程序告诉我们的高度(150 米)相差甚远。仔细观察海拔高度的差异，我们可以看到它精确到 10 厘米。
在跑步的情况下，这可能是在人行道上跳上跳下，或者用手里的手机挠头。将数字四舍五入到 1 米是有意义的。我们可以通过在之前的结果上映射一个 lambda 函数来做到这一点。
sum(list(map(lambda x: round(x,0) , pos_only)))
新的结果是 137 米，非常接近应用程序提出的海拔高度。知道了这一点，我们还应该用这些新的高程值重新计算我们的 3d 距离。不用计算，我们知道总距离会下降并接近 2d 距离。这使得不考虑总距离中的高度增益更加合理。
值得思考的事情
我将用一个关于海拔增加的启示来总结这篇文章:在实际跑步过程中，我没有增加任何海拔(除了几个小楼梯)。更有甚者，我的手机就像大多数低端市场的手机一样，没有气压计。
气压计是一种测量大气压力的仪器，尤其用于预测天气和确定海拔高度。但是斯特拉发是如何确定我们的高度的呢？答案是 Strava 的高程底图。
它是使用来自社区的数据创建的。通过从过去上传到 Strava 的任何活动中收集气压高度计测量值(从带有气压计的设备中)，他们能够建立一个全球海拔数据库。
目前，底图还不够可靠，也没有覆盖足够多的世界。但是，如果他们能够在未来使其更加可靠，他们可能能够结合 3d 计算和更复杂的海拔增益模型，为所有的运动者提供更准确的统计数据。
下一步是什么？
在本文的后续文章中，我们将可视化在本教程中与另一个热门人物一起获得的所有数据: QlikView 。
—请随时在评论中或私信中向我指出任何不一致或错误。—
Turi 创造的方式正在颠覆机器学习的格局
几个月前——1 月 18 日星期四——我在西雅图的第一次聚会上发表了演讲。这是我从芝加哥搬家后的第三天，所以没有浪费时间！
原因？没有什么比苹果开源 Turi Create 的消息更让我关注的了，这是它在 2016 年收购 Turi 的后拥有的机器学习(ML)库。
一句话:Turi Create 是一个 Pythonic 式的机器学习库，非常强大且易于使用，你应该探索它的能力！
首先，我要感谢 Metis 、 BeMyApp 和 Intel 共同赞助此次活动。
这篇文章是 meetup 的总结:我做了什么，观众问了一些相关的问题，一些意外访客的记录，以及我对 Turi Create 未来发展的想法。我还将分享最佳实践、经验教训以及对我未来项目的想法。
Turi Create
我展示的东西
首先，我分享了在准备 GraphLab Create 环境时学到的经验。眼尖的读者可能会注意到，GraphLab Create(以下简称 GC)看起来与 Turi Create(以下简称 TC)是不同的产品；Turi 团队告诉我，这种差异只是表面现象，因为两个包使用相同的核心代码，开源变体(TC)基本上可以做 GC 能做的一切。因此，虽然一些程序项目可能有所不同，但一般用法是非常相似的。
为了深入了解产品是如何发展的，我强烈推荐创始人 Carlos Guestrin 的这个演示。它已经有五年的历史了，但是 Guestrin 触及了早期开发阶段的动机和关注领域。为了了解软件包在“堆栈”中的位置，这里有一个常见的架构:
GC Architecture
值得注意的是，GC 和 TC 都运行在 Python 2 上，环境必须用特定版本的支持库来设置。作为一个挑战，我试图将新的包合并到我的主 anaconda 环境中，但是遇到了版本和依赖地狱。所以，对于第一次来说:
- 确保你有至少 8GB 的内存用于严肃的工作，或者设置在虚拟环境中
- 根据设置说明创建一个新的 conda 环境
- 然后，注册许可证(针对 GC)
- 如果使用 TC，将 repo 克隆到您的机器上
- 尝试入门指南中的一些练习
加载和管理数据与熊猫非常相似:
import graphlab as gl
%matplotlib inline# load data into SFrame
url = '[https://raw.githubusercontent.com/plotly/datasets/master/data.csv](https://raw.githubusercontent.com/plotly/datasets/master/data.csv)['](https://static.turi.com/datasets/millionsong/song_data.csv')df = gl.SFrame.read_csv(url)
从这里，我们可以调用汇总统计数据和一个交互式控制面板，它具有以下功能:
# summary statistics for a column
df['column'].sketch_summary()# show dashboard
df.show()
然后，您将能够快速找到特定的行范围，跟踪更多的汇总统计数据，并构建如下所示的交互式图表:
View large datasets with ease!
Heatmaps with various scaling functions
Line charts with zoom and drag capabilities
建模看起来与 SciKit-Learn 非常相似，但这是一件好事。如果它没坏，不要修理它:
# load housing data and fit a linear model
url = '[https://static.turi.com/datasets/regression/Housing.csv'](https://static.turi.com/datasets/regression/Housing.csv')
x = gl.SFrame.read_csv(url)lm = gl.linear_regression.create(x, target='price')
值得注意的是，GC 会自动创建“样本外”验证集，以跟踪真实的模型性能。有许多巧妙的技巧可以让你更有效地编码，更快地得到结果。然而，GC 预先选择了常见的方法，因此您需要了解文档中的默认参数和假设！
与 SciKit-Learn 相比，一个常见的观众问题与性能有关。如果你仅仅使用 CPU 来拟合模型或者搅动数据，差别很小，并且会归结为代码优化、稍微不同的求解方法等等。然而，如果你有一个高度可并行化的任务，并且运行在 AWS P2 或 P3 实例上，或者你在办公室里有一个强大的 Cuda 设置，我们所说的 TC 会快几个数量级。
这个事实本身就是将你公司的模型转移到 Turi 环境的完美理由。
目前，TC 和 SciKit-Learn 基于 Python 的 ML 库之间的一般比较如下:
Scikit-learn 的优势:
- 开源:Scikit-learn 是一个开源库，有 500 多个贡献者和强大的支持
- 对 Python 3 的支持:Scikit-learn 支持 Python 3，而 Graphlab Create 只与 Python 2 兼容
- 更多算法:与 Graphlab 相比，Scikit-learn 拥有更多算法
Graphlab Create 的优势:
- Graphlab Create 是一款 24/7 全天候支持的商业软件
- 可伸缩性:Scikit-learn 实现只在内存中执行。GraphLab Create 能够扩展到核外，许多多线程实现利用了机器上的多个核。
- GPU 支持:你可以安装带有 GPU 加速的 Graphlab Create，它可以让某些任务的速度快得惊人
最后，在演讲之后，Turi 的三个核心成员——负责 GC 和 TC 的编码和开发——走上前来介绍他们自己！现在，苹果的员工们，我们就产品的未来、外部市场的看法和商业模式进行了深入的交谈。
太神奇了！
也许是好事，我不知道他们一直在看着我…无知是福。
苹果和机器学习
苹果非常认真地建设其机器学习(ML)能力，因为它寻求在利润丰厚的“大数据”领域与谷歌和脸书等其他巨头竞争。然而，苹果的策略却截然不同。作为一个以客户数据隐私为荣的组织，我们的重点是利用苹果对其产品用户的了解来改善总体用户体验，包括:
- Siri 变得更加智能预测你的需求
- Apple Music 利用 ML 帮助您发现令人惊叹的新艺术家
- 来电显示用于拨打您 iPhone 的新号码
- 使用 ML 来预测你的卡路里消耗和一般活动
- 差异化隐私为所有这些服务提供动力
在苹果的定期更新并面向公众的博客上，我们可以看到最新最棒的产品和服务的暗示——以及数据科学是如何实现的。
Turi 如何创造可能进化
TC 已经是 Pandas 和 SciKit-Learn combo 的有力竞争对手，拥有完整的堆栈数据管理和建模能力。它快速而高效，并具有某些功能，如 GPU 加速，这些功能在 SciKit-Learn 中不存在或处于早期阶段。此外，由于该产品是苹果 ML 推广的一个关键方面，我希望看到与框架的深度集成，如 Core ML 、 ARKit 和 HealthKit 。
Turi 与 Tensorflow 等平台有功能重叠，鉴于对神经网络等模型的关注和宣传，这种重叠可能会在深度学习领域增长。事实上，GPU 加速的一个关键价值主张是允许更快地拟合大型数据集上的深度模型。我也希望看到像 Keras 这样的包装器扩展数据科学家修改参数和架构的便利性。
已经有一个快速指南介绍如何将 TC 集成到 iPhone 应用程序中，并通过 App Store 直接向用户部署你的 ML 模型。当前的型号产品包括以下列表，但随着时间的推移，我们应该会看到更多的产品:
最后，我希望在未来几年看到对主题建模和自然语言处理空间的更深入的推动，特别是随着 Siri 的不断完善。
您企业的下一步
TC 似乎是一个令人惊叹的平台，但真正重要的问题是:
Turi Create 如何让我的业务受益？
- 如果你的企业出售订阅服务，或者软件许可，TC 的广泛的分类模型套件可以决定哪些客户更有可能流失，或者“流失”。然后，您可以激励这些客户续订，或者确定另一种产品是否符合他们的需求。
- 如果你的公司提供许多产品或服务——并且你对你的客户群有所了解——你可以实施 TC 的推荐系统来量化客户的兴趣，并对你营销或提供的新产品进行优先排序。这些模式为亚马逊和易贝的“推荐给你”列表、Spotify 的音乐播放列表管理和 GrubHub 的供应商聚光灯提供了动力。
- 最后，如果您经营一家使用身体传感器收集心脏、大脑或活动指标的医疗企业，TC 的活动分类器可以从加速度计、陀螺仪、恒温器等设备中获取数据。该模型将预测可能发生的锻炼形式、心脏状况或医疗紧急情况。这个应用程序可以扩展到其他领域，如网络安全、工程应用程序或任何从噪声数据中推断模式的领域。
Classifying Activities from Gyroscope Data
我业务的下一步
我想在 TC 环境中重新创建我过去的一些项目，作为一个具有审查基线的真实世界测试。我将把这些代码中的一部分——尤其是我的集合模型——部署到各种 AWS 实例类型中，以便判断哪种架构能给我带来最高的性能。
今年，我专注于将更多的数据科学应用到我的投资和加密货币策略中，TC 是建立神经网络或类似投资组合优化模型的有力竞争者。
最后但同样重要的是，作为 Metis 的数据科学讲师，我将寻找将 TC 纳入我们课程的方法，以便让学生了解。在我的书中，最终的成功是:一名学生构建了一个以 ML 为中心的 iOS 应用程序，并成功地将其部署到拥有超过 10 亿智能手机用户的市场中！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
