TowardsDataScience 博客中文翻译 2020（五百一十一）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

如何在 Julia 中使用语法表达式和调度

原文：https://towardsdatascience.com/how-to-use-syntactical-expressions-and-dispatch-in-julia-67ce155e4af9?source=collection_archive---------37-----------------------

朱莉娅综合教程

朱莉娅的面包和黄油:句法表达和多重调度

(图片作者:)

本文视频

今日回购:

[## emmettgb/JuliaLessons

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/emmettgb/JuliaLessons/tree/master/4)

介绍

在过去的几个教程中，我们已经学习了一些相对基础的编程概念，比如类型、循环和函数。所有这些基本技能最终都消失了——这意味着你可以实际练习和学习有趣的东西了！虽然你可能确实需要一些练习来达到这个目标，而且如果你打算认真对待它的话，这将是一个很大的工作量和终生学习的承诺，你正在成为一个伟大的 Julian 开发者！

虽然之前我们没有讨论任何特定于 Julia 语言的内容，但是今天将会有所改变。对于以前编程过的人来说，这是一个理想的地方——但实际上不是在 Julia 中。这意味着很快我们将会使用真正的软件包和解决真正的问题，这将会使这些教程变得更加有用和有趣！

不要惊慌

当然，仅仅通过观看一些视频来成为一名程序员是很困难的。幸运的是，我们将重复使用并反复复习我们在这些视频中学到的所有技能。如果你当时没有给予足够的关注，某些事情似乎很容易被掩盖——但是不要担心，你会明白的！

句法表达

在 Julia 中，语法表达式是一个奇妙的工具，它使得编写新函数来执行算术变得非常科学和容易。通常，我们可以使用这些表达式将原本需要十到二十行的代码压缩成一两行。在大多数语言中，您会像这样编写一个函数来计算平均值:

function mean(x)
    return(sum(x) / length(x))
end

在 Julia 中，我们甚至可以更快地完成像这样的小操作:

mean(x) = sum(x) / length(x)

虽然保存两行代码可能不会令人难以置信地改变生活，但是下一个例子是一个更大的代码压缩！：

function Normalize(array)
    q = std(array)
    avg = mean(array)
    [i = (i-avg) / q for i in array]
end

此标准化函数获取平均值和标准偏差，并将其放入公式中，以便对数据进行标准化。这在统计学中被称为数据的“正态分布”对于这样的函数来说，四行代码当然是合理的，但是，使用 Julia，我们可以使用 dispatch 将整个代码块压缩成一行。我们所要做的就是将我们的计算放入一行 for 循环中，并设置一个语法表达式将其连接到一个方法，如下所示:

normalize(x) = [i = (i-mean(x)) / std(x) for i in x]

与后者相比，使用这种方法的唯一缺点是，每次运行这个循环时，都要计算平均值和标准偏差。这意味着在每个节拍，处理器移动数据要做的第一件事是计算平均值，然后从当前迭代中减去它。这也是判断的一个很好的例子——什么时候需要保存性能，当我们改变循环时性能会损失多少？

如果使用得当，语法表达式是一个非常有用的工具。此外，它们可以允许您分派类型，并将这些分派函数作为数据使用——从而使范例更加灵活。

多重调度

多重分派是 Julia 编程语言的最大特点。它甚至在朱莉娅的网站上写着，

“朱莉娅使用多重分派作为范例.”

在这种情况下，Julia 解决多态性技术问题的方法成为一种通用的工具，允许该语言在它想要的任何范式中工作。dispatch 实际上可以应用于很多事情。Dispatch 甚至可以像孩子一样用方法创建对象，让 Julia 一下子变成了面向对象的编程语言。

虽然我们今天不会处理弯曲范式为所欲为的问题，但我们将研究如何以最基本的形式使用调度来改善你的生活。这两个函数也许能够以相同的类型运行，但是让我们假设运行 string()将一个字符串的类型更改为 string 会破坏我们的性能，或者使计算机爆炸，或者类似的事情。

function print_symbol(symb)
    symb = string(symb)
    for char in symb
        println(char)
    end
endfunction print_string(str::String)
    for char in str
        println(char)
    end
end

所以我们有两个函数，一个会导致我们的计算机崩溃，如果我们传递一个字符串，另一个会返回一个错误，如果我们试图传递一个符号。在大多数其他应用程序中，在这种情况下唯一的选择是单独调用这些函数——或者，如果这些是自定义对象，我们可以使用 decorators。不管怎样，朱莉娅很好地解决了这个问题。使用 dispatch，我们可以创建两行代码来识别正在使用的类型，然后为该类型调用正确的函数。

prints(symb::Symbol) = print_symbol(symb)
prints(symb::String) = print_string(symb)

现在我们可以打印这两种类型:

(图片由作者提供)

很酷，对吧？

结论

Julia 编程语言将许多解决编程问题的有趣方法带到了一个非常高级和优雅的解决方案版本中。如果你以前没有使用过许多其他编程语言，这是这种语言很难让人钦佩的伟大之处之一。

多才多艺是一个很好的词。

真正令人兴奋的是教程的进度！您可以正式将调度添加到您已经学习的内容列表中——或者至少从这些教程中变得熟悉！非常感谢您的阅读、观看和反馈！在下一个教程中，我们将回顾我们已经完成的内容，并添加我们的第一个模块！

如何在 react.js 中使用 tensorflow.js 情感分析

原文：https://towardsdatascience.com/how-to-use-tensorflow-js-in-react-js-sentimental-analysis-59c538c07256?source=collection_archive---------13-----------------------

与 TENSORFLOW 反应。射流研究…

了解如何在 react web 应用程序中实现情感分析

克里斯里德在 Unsplash 上的照片

2018 年 3 月，谷歌宣布tensor flow . js 1.0 版本，该版本使开发者能够直接在浏览器中或通过 JavaScript 在 Node.js 中使用机器学习(ML)模型。

从那以后，我总是想在我的项目中使用 google 发布的那些花哨的预训练模型，如对象检测、姿态估计等等。然而，这些例子和演示是用纯 JavaScript 显示，关于如何在 react 应用程序中使用它的指导很少。

灵感来自 Tensorflow.js 社区中的本森鲁阿代码【展示&讲述。我决定写一些关于使用 create-react-app + tensorflow.js 的东西，以鼓励更多的人加入这个社区:

本教程的最终目的是创建一个情感分析计算器，它可以计算书面句子的积极(1)或消极(0)。当你需要发现和防止应用程序中的负面评论时，这是非常有用的。

计算值接近零(否定句)

试玩 app 此处

1.0 设置您的创建-反应-应用程序

通过终端中的以下命令创建一个 Create-React-App :

npx create-react-app tfjs-sentiment
cd tfjs-sentiment

按如下方式安装 tensorflow.js:

npm install @tensorflow/tfjs 

并启动应用程序

npm start

2.0 理论和了解您的模型

我们在这里将使用的模型是 tensorflow.js 情感分析示例中的卷积神经网络(CNN)模型。它根据来自 IMDB 数据集的 25000 条电影评论进行训练，这些评论被标记为积极或消极情绪。

模型在这里可用，元数据在这里可用。在我们开始编码之前看一下。

基本上，这个模型是一个经过训练的神经网络，它是一种“特殊的算法”,可以将你输入的句子分为肯定(1)和否定(0)两类。

我们必须将正确的输入放入模型中，以使我们的模型能够顺利工作。你必须知道的第一件事是，模型工作是作为一种数学逻辑，使用数学输入进行训练，它不理解字面上的“单词”或“英语”。我们必须把我们的句子转换成某种数学输入，以便使它起作用。接下来是元数据，元数据将文字输入转换为数字输入，例如:

book >>> 274
cutely >>> 68327

注意:由于本教程关注的是如何在 react 中使用，这些模型背后的理论可以参考 word2vec 或其他 NLP 理论

通过将每个单词分割成数字记号，将句子编码成这些数字输入:

this is a book >>> 14,9,6,274

然后，数字记号被改变为固定长度(100)的序列，以便改变为 2d 张量

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,9,6,274

2D 张量

最后，这个序列被转换成一个 2D 张量(基本上是一个矩阵)输入到模型中，神奇的事情发生了，模型会自动将句子分类成肯定或否定的陈述。

3.0 编码

如果你理解了上面的逻辑，就很容易将其转化为行动。

3.1 加载模型和元数据

import * as tf from '@tensorflow/tfjs';//Model and metadata URL
const url = {
model: 'https://storage.googleapis.com/tfjs-models/tfjs/sentiment_cnn_v1/model.json',
metadata: 'https://storage.googleapis.com/tfjs-models/tfjs/sentiment_cnn_v1/metadata.json'
};async function loadModel(url) {
try {
const model = await tf.loadLayersModel(url.model);
setModel(model);} catch (err) {
console.log(err);
}}async function loadMetadata(url) {
try {
const metadataJson = await fetch(url.metadata);
const metadata = await metadataJson.json();
setMetadata(metadata);} catch (err) {
console.log(err);
}} //React Hook
const [metadata, setMetadata] = useState();
const [model, setModel] = useState();useEffect(()=>{
tf.ready().then(()=>{
loadModel(url)
loadMetadata(url)
});
},[])

3.2 将句子转换为张量输入:

这里，我们将根据上述理论设置一个函数来逐个函数地处理输入文本:

标记句子中的每个单词:

const inputText = text.trim().toLowerCase().replace(/(\.|\,|\!)/g, '').split(' ');

使用元数据将字母标记转换为数字标记:

//Convert the alphabetical token to numerical token using metadata
const OOV_INDEX = 2;const sequence = inputText.map(word => {
let wordIndex = metadata.word_index[word] + metadata.index_from;
if (wordIndex > metadata.vocabulary_size) {
wordIndex = OOV_INDEX;
}
return wordIndex;
});

通过 padSequences 函数将序列固定为固定长度(截断和填充)

const PAD_INDEX = 0;const padSequences = (sequences, maxLen, padding = 'pre', truncating = 'pre', value = PAD_INDEX) => {
return sequences.map(seq => {
if (seq.length > maxLen) {
if (truncating === 'pre') {
seq.splice(0, seq.length - maxLen);
} else {
seq.splice(maxLen, seq.length - maxLen);
}
}if (seq.length < maxLen) {
const pad = [];
for (let i = 0; i < maxLen - seq.length; ++i) {
pad.push(value);
}
if (padding === 'pre') {
seq = pad.concat(seq);
} else {
seq = seq.concat(pad);
}
}return seq;});}const paddedSequence = padSequences([sequence], metadata.max_len);

最后，将填充的序列转换成我们的张量 2D 矩阵

const input = tf.tensor2d(paddedSequence, [1, metadata.max_len]);

3.3 将 tensor2D 加载到模型中

当你得到所有正确的输入后，最后一个简单的步骤就是使用 model.predict 对你的输入进行分类。

const predictOut = model.predict(input);
const score = predictOut.dataSync()[0];
predictOut.dispose();
setScore(score)
return score;

3.4 设置文本字段和按钮

通过 npm 安装材料界面

npm install @material-ui/core

然后把下面的代码输入到你的 react 应用程序中，一个文本框将会出现，你可以愉快地玩这个模型了！

import {
TextField,
Button
} from '@material-ui/core'const [testText, setText] = useState("");<TextField
id="standard-read-only-input"
label="Type your sentences here"
onChange={(e)=> setText(e.target.value)}
defaultValue=""
value={testText}
multiline
rows={4}
variant="outlined"
/>
{testText !== "" ?
<Button style={{width:"20vh", height:"5vh"}} variant= "outlined" onClick={()=>getSentimentScore(testText)}>Calculate</Button>
: <></>}

4.0 最后的话:

作为一名 react 前端开发人员和一名数据科学学生，我正在积极寻求一种将我的数据科学知识和 react 技能结合在一起的解决方案。

TF.js 提供了在 react 中集成深度学习模型的便利，其优势是一切都可以在前端完成，我们不需要后端服务器(例如 fastAPI，flask)或无服务器功能(例如 AWS lambda)来集成我们基于 python 的模型，我们可以利用当前的免费主机提供商，如 netlify 和 vercel。

使用 TF.js 的缺点是没有服务器，所有深度学习的模型都必须下载才能使用，有些模型价值超过 100Mb，与服务器中预装的模型相比，这对用户来说是糟糕的体验。

最后，开发者应该根据需要选择合适的深度学习模型的实现。

谢谢你的阅读，希望你喜欢它。

源代码可在这里获得

我的 TF.js + React.js 文章:

[## 使用 React 和 Tensorflow.js 进行自定义对象检测

让我们用 Azure 自定义视觉在 30 分钟内制作一个实时自定义对象检测器

towardsdatascience.com](/custom-object-detection-using-react-with-tensorflow-js-7f79adee9cd4) [## 使用 react.js 将模型加载到 tensorflow.js

立即在 react.js 中使用您的 python Tensorflow 模型

towardsdatascience.com](/loading-models-into-tensorflow-js-using-react-js-f3e118ee4a59) [## 如何在 react.js 中使用 tensorflow.js 对象检测

使用 COCO-SSD 模型定位和识别单个图像中的多个对象

towardsdatascience.com](/how-to-use-tensorflow-js-in-react-js-object-detection-98b3782f08c2)

如何使用 Aito 引擎预测动物

原文：https://towardsdatascience.com/how-to-use-the-aito-engine-to-predict-animals-6853672eac7e?source=collection_archive---------62-----------------------

利用自动机器学习预测的逐步指南

今天，谈论数据不可能不提到人工智能、机器学习和数据工程等话题。事实上，虽然人工智能从 50 年代就开始被研究和讨论，但只是在过去几年里它才被大肆宣传并成为商业词汇的一部分。

有时很难看到所有流行词汇背后的东西，但在过去几年中，数据和人工智能确实处于新的突破性商业模式和社会创新的最前沿。商业和技术领导者是时候利用人工智能提供的优势了。

自动机器学习和智能预测

在机器学习中，一个从数据中学习规则的算法和技术工具箱，预测值一直是一个受欢迎的用例。通常，数据科学家使用回归算法(如线性或逻辑)来估计从属值之间的关系，从而使他们能够预测值。

这些众所周知的机器学习例子，如预测，结合算法和云技术的成熟，导致自动机器学习(AutoML)服务和平台的诞生。

通过 AutoML，我们可以使用简单的 API 请求对数据进行智能预测。这使得任何人，如果没有事先的数据科学知识，只需利用这些预先训练的机器学习 API，就可以获得人工智能的好处。

最近的研究告诉我们，大多数人工智能项目的失败是由于缺乏熟练的员工和不切实际的期望。组织需要开始以不同的方式看待他们处理数据科学项目的方式。自动化机器学习是开始用真实数据进行实验的一种很好的方式，门槛低，可以转化为即时的商业价值。

智能预测引擎 Aito 简介

Aito 是一个智能预测引擎，使开发人员和专家能够获得机器学习能力。作为一个平台，它结合了数据库引擎和自动机器学习功能，如预测、相似性等。

传统的数据库平台通常专注于搜索和过滤已知信息。反过来，Aito 在此基础上增加了通过分析和索引你上传的数据的模式和特征来预测未知信息的能力。

Aito 可用于实现智能自动化，例如改善输入和预测数据、匹配系统之间的记录或自动化重复性决策。

使用案例和可能性是无穷无尽的，但 Aito 特别擅长的一个领域是机器人过程自动化(RPA)。借助 Aito，组织可以将智能添加到现有 RPA 工作流中，这有助于他们降低成本，并使现有团队能够增加更多业务价值。

使用 Aito 预测动物类型的步骤

由加州大学欧文分校提供的动物园数据集在 OpenML 中可用，它是不同动物布尔属性的一个非常简单的数据集合。这为我们提供了一个很好的基线数据集，我们可以使用它来根据动物的一些属性(如腿、尾巴、捕食者等)预测动物的类型(如鸟、鱼、哺乳动物)。

我们真的很容易预测这个动物园里的动物类型吗？通过自动机器学习和 Aito 引擎，我们可以快速回答这个问题。在几个实际步骤中，我们将向您展示如何使用 Aito 和进行预测查询。

创建 Aito 实例

如果你是 Aito 的新手，你可以从注册开始，创建一个新的实例。

创建过程非常简单，只需给它一个名称并选择所需的实例类型。沙盒类型是完全免费的，它给你足够的能力去尝试动物园的例子。

Aito 控制台中的实例创建面板

提交实例请求后，只需等待团队的确认。您的 Aito 实例详细信息将在 web 控制台中可见。

Aito 实例详细信息

记下仪表板中的 API url 和键。我们将使用这些参数与实例进行交互。

配置您的本地环境

虽然可以通过 web 控制台上传数据，但您需要使用 Aito CLI 和 Python SDK 或 REST API 来适当利用引擎功能。

1. 首先，使用以下命令将数据集下载到您的计算机上:

curl -O [https://www.openml.org/data/get_csv/52352/openml_phpZNNasq](https://www.openml.org/data/get_csv/52352/openml_phpZNNasq)

2.创建一个 python 虚拟环境，并使用命令 pip install aitoai 安装 Aito CLI

下载动物园数据集并安装 Aito CLI

3.通过将环境配置到 Aito 实例来完成设置。您可以通过设置 AITO _ 实例 _URL 和 AITO_API_KEY 环境变量来定义这一点。

为 Aito 实例配置环境

使用 Aito CLI 输入数据

安装 Aito CLI 并准备好使用后，让我们从从 zoo 数据集推断数据模式开始。因为在其核心，Aito 引擎表现为一个数据库，这是描述我们的数据看起来如何的必要步骤。幸运的是，这可以不费吹灰之力完成。

输入数据的最快方式是使用 Aito UI 拖放功能或 CLI quick-add-table 命令。这两个选项都将模式推断和数据上传捆绑到一个操作中，并从用户那里抽象出内部细节。但是，在下面的示例中，我们采用了更长的路线，将摄取步骤分解为单独的单个操作。这给了我们完全的控制权，也让我们对 Aito 的工作方式有了更好的理解。

1. 使用 infer-table-schema 命令自动分析数据集，并将模式提取到 JSON 文件中。这个特性还使您能够在将数据提供给 Aito 之前，根据需要修改模式文件(在这个用例中不是这样)。

aito infer-table-schema csv < openml_phpZNNasq > inferredSchema.json 

自动模式推理

2.根据我们在上一步中推断的数据模式，在 Aito 实例中创建一个表(例如 myzoo)。使用以下命令:

aito database create-table myzoo inferredSchema.json

3.将动物园数据集文件从 CSV 转换为适合文件上传的格式(压缩的 NDJSON)。使用以下命令:

aito convert csv < openml_phpZNNasq > zoo-dataset.ndjson gzip zoo-dataset.ndjson

4.使用以下命令用数据填充 Aito 表(例如 myzoo ):

aito database upload-file myzoo zoo-dataset.ndjson.gz

正在将动物园数据集上传到 Aito 实例

5.数据集现在可以使用了，并准备好与 Aito API 功能一起使用。

使用 Aito 预测 API

从一开始，我们的目标是根据某些属性(例如腿、尾巴、捕食者等)预测动物的类型(例如鸟、鱼、哺乳动物)。通过在 Aito 中填充数据，我们获得了开箱即用的预测功能，只需查询 API 就可以访问这些功能。

1.首先准备一个 JSON 查询语句，描述我们想要使用什么属性以及我们想要预测什么。如果您想要查询在空中飞行、产卵、有羽毛和两条腿的动物类型，该语句可能是这样的:

{
  "from": "myzoo",
  "where": {
            "airborne": true,
            "eggs": true,
            "feathers": true,
            "legs": 2
  },
  "predict": "type"
}

2.将 JSON 查询语句保存到本地环境中的一个文件(例如 myquery.json)中。

JSON 查询文件

3.使用 curl 等工具将查询提交给 Aito 实例预测 API 端点。使用以下命令作为示例(填入您的实例 url 和 API 密钥):

curl -X POST “https://<YOUR_INSTANCE_URL>/api/v1/_predict” \> -H “accept: application/json” \
> -H “Content-Type: application/json” \
> -H “x-api-key: <YOUR_API_KEY>” \
> -d @myquery.json

Aito 预测 API 的查询

4.预测 API 响应将返回具有不同关联分数的多种动物类型。在这种情况下，我们的查询结果显示，我们正在寻找的动物类型有大约 96%的概率是鸟，其他动物类型的得分不到 1%。

进一步探索

您可以使用任何其他动物属性(检查推断的模式)来查询数据，但是从这个简单的示例用例中，我们可以看到使用 Aito 这样的服务进行数据分析有着巨大的潜力。

自动机器学习工具，如 Aito 引擎，可以简化日常操作，并通过简单的 API 请求带来真正的业务洞察力。

预测功能只是 Aito API 中 7 个以上功能中的一个。查看 API 文档并了解其他特性，如搜索、推荐、相似性等等。

如果你需要额外的灵感，看看 Aito 陈列柜，了解更多关于预测缺失输入值、领导资格，甚至如何将门与宜家厨房框架搭配。

我希望这篇文章对你有用。请分享您的反馈和想法，并随时联系 Twitter 和 Linkedin

布鲁诺

如何在 React.js 中使用带有自定义样式的 Google Maps API

原文：https://towardsdatascience.com/how-to-use-the-google-maps-api-with-custom-styling-in-react-js-f6e7e59273df?source=collection_archive---------8-----------------------

前端

在 React 项目中集成漂亮的谷歌地图

照片由像素的皮克斯拜拍摄

当我的朋友尝试一个新发型时，我问他“你为什么剪成这样？”他说他想成为一名出色的模特。因此，我明白了人们喜欢独特而美丽地展示它们。

当我开发个人 react 应用程序时，我想实现 google map API。我在谷歌上搜索了很多例子，最后，我找到了一个简单的解决方案。在这里，我将简要说明我如何使用该应用程序，以及我们可以添加到谷歌地图的自定义样式。这里我们将从头开始看。你可以在这里看到演示。这是我在 Medium 的第 29 篇文章。

首先

如果你没有谷歌地图 API 令牌注册谷歌地图 API 并获得令牌使用！要获得令牌，您必须输入信用卡号码。然而，谷歌表示，如果你不亲自更新服务，他们不会向你的账户收费。做你的决定吧。一旦你有了 API 密匙，就开始开发你的应用吧！

要创建 react 应用程序，请在您的 shell/终端的特定文件夹(例如，desktop)中运行以下命令

npx create-react-app google-map

将创建一个新文件夹，并将其命名为 google-map。从这一步开始，用 Create React App 引导您的应用程序。有关更多信息，请单击链接。然后在 IDE 中打开该项目。我使用的是 VS 代码集成开发环境。

来自突发的妮可·德·霍斯的照片

着手工作

如果您打开 react 应用程序，那么您需要删除不需要的文件。因此，您需要转到 src 文件夹，删除 Logo.svg、App.css、index.css 和 App.test.js 文件。并在名为 components，assets and helpers 的 src 文件夹中创建以下文件夹，然后将 serviceWorker.js 移动到助手的文件夹中，将 App.js 文件移动到 Components 文件夹中。然后打开 index.js 文件，删除 index.js 文件中的以下代码片段。

*import* ‘./index.css’;

然后修改 index.js 导入中的 App.js 和 serviceWorker.js 文件路径，如下所示。

*import* App *from* ‘./components/App’;
*import* * *as* serviceWorker *from* ‘./helpers/serviceWorker’;

转到 Components 文件夹，打开 App.js，删除 App 函数的返回部分。

您需要安装一个依赖项来将谷歌地图作为一个组件。为此，使用下面的命令来安装依赖项。

npm install --save google-maps-react

布鲁诺·纳西门托在 Unsplash 上拍照

完全（或彻底）地

在你的组件 app 里面新建一个文件，命名为 Map.js，然后你需要导入google-maps-rect。为此，在 Map.js 中添加以下代码片段。

import { Map, GoogleApiWrapper } from 'google-maps-react';

现在您需要呈现Map组件。因此，添加Map组件到你的渲染函数中。

在上面的代码中，我添加了普通的样式。我在 render 方法中使用了常量变量。

const mapStyles = {
  width: '100%',
  height: '100%',
};

您需要在 Maps.js 文件中添加 export default 语句，如下所示

export default GoogleApiWrapper({
  apiKey: 'TOKEN HERE'
})(MapContainer);

确保在这里输入您的 API 密钥！

来自爆炸的克里斯蒂安·穆里略的照片

在 App.js 文件中导入Maps组件。所以你的 App.js 应该是这样的。

当你使用npm start启动你的开发服务器时，你会看到下面的结果。

嘣！你做到了，但是使用谷歌地图有什么意义呢？但是，合理地说，使用没有任何标记的谷歌地图有什么意义。因此，我们来添加一个标记。为此，更新您的Map组件以包含Marker组件。这里我使用了不同的纬度和经度，你可以使用任何你需要的纬度和经度。

import { Map, GoogleApiWrapper, Marker } from 'google-maps-react';

太好了！你在地图上添加了标记。

美好的事物永远是一种快乐

现在，您已经进入了本文最有趣的部分。现在，让我们来看看自定义样式。它只是一个 JSON 对象。您将在 GoogleMapStyles.js 文件中存储自定义样式 JSON。我使用的主题来自样式向导:谷歌地图 API。如果你需要更漂亮的样式，那么试试时髦地图的样式，或者通过定制 JSON 对象建立你自己独特的地图样式。您的 GoogleMapStyles.js 文件将如下所示。

现在你需要在你的Maps组件中导入这个样式的 JSON。

*import* googleMapStyles *from* “./GoogelMapStyle”;

导入样式 JSON 后，可以将样式 JSON 设置为Maps组件的defaultProps。这可以通过在类体之外的组件类本身上定义defaultProps来实现，如下面的代码片段所示:

Maps.defaultProps = googleMapStyles;

然后，您需要将这个属性传递给Map组件的样式属性，如下面的代码片段所示:

<Map
  *google*={*this*.props.google}
  *zoom*={15}
  *styles*={*this*.props.mapStyle}
  *initialCenter*={{ lat: 9.761927, lng: 79.95244 }}
/>;

现在你的Maps组件将如下面的文件所示。

把你的脚抬起来

在 react 中实现谷歌地图很容易。有很多 npm 包可以帮助 React 实现谷歌地图。对我来说，google-maps-react很容易使用，它是一个比其他更小的包。你可以从这个链接克隆回购。

快乐编码😊！！！

如何使用管道的魔力

原文：https://towardsdatascience.com/how-to-use-the-magic-of-pipelines-6e98d7e5c9b7?source=collection_archive---------46-----------------------

使用 ETL 拯救世界

斯文·库契尼奇在 Unsplash 上的照片

您肯定听说过管道或 ETL(提取转换负载)，或者见过库中的一些方法，甚至听说过任何创建管道的工具。但是，您还没有使用它。所以，让我向你介绍管道的奇妙世界。

在了解如何使用它们之前，我们必须了解它是什么。

管道是一种包装和自动化流程的方式，这意味着流程将始终以相同的方式执行，具有相同的功能和参数，并且结果将始终符合预定的标准。

因此，正如您可能猜到的，目标是在每个开发阶段应用管道，以试图保证设计的过程不会与理想化的过程不同。

用 Kapwin g 制成

管道在数据科学中有两个特别的用途，要么是在生产中，要么是在建模/勘探过程中，这两个用途都非常重要。此外，它使我们的生活更容易。

第一个是数据 ETL。在制作过程中，分支要大得多，因此，花费在其中的细节层次也大得多，但是，可以总结为:

e(提取)—我如何收集数据？如果我要从一个或几个网站，一个或多个数据库，甚至一个简单的熊猫 csv 来收集它们。我们可以把这个阶段看作是数据读取阶段。

t(转换)—要使数据变得可用，我需要做些什么？这可以被认为是探索性数据分析的结论，这意味着在我们知道如何处理数据(移除特征、将分类变量转换为二进制数据、清理字符串等)之后。)，我们将其全部编译在一个函数中，该函数保证清理总是以相同的方式进行。

l(加载)—这只是将数据保存为所需的格式(csv、数据库等)。)某处，要么云端，要么本地，随时随地使用。

这个过程的创建非常简单，只需拿起探索性数据分析笔记本，将 pandas read_csv 放入一个函数中；编写几个函数来准备数据并在一个函数中编译它们；最后创建一个函数保存前一个函数的结果。

有了这些，我们就可以在 python 文件中创建 main 函数，并且用一行代码执行创建的 ETL，而不用冒任何更改的风险。更不用说在一个地方改变/更新所有东西的好处了。

第二个，可能是最有利的管道，有助于解决机器学习中最常见的问题之一:参数化。

我们多少次面临这些问题:选择哪种模式？我应该使用规范化还是标准化？

“作者捕获的屏幕截图”

scikit-learn 等库为我们提供了流水线方法，我们可以将几个模型及其各自的参数方差放入其中，添加归一化、标准化甚至自定义流程等预处理，甚至在最后添加交叉验证。之后，将测试所有可能性，并返回结果，或者甚至只返回最佳结果，如下面的代码所示:

def build_model(X,y):                          
 pipeline = Pipeline([
        ('vect',CountVectorizer(tokenizer=tokenize)),
        ('tfidf', TfidfTransformer()),
        ('clf', MultiOutputClassifier(estimator=RandomForestClassifier()))                           ])# specify parameters for grid search                           parameters = { 
    # 'vect__ngram_range': ((1, 1), (1, 2)),  
    # 'vect__max_df': (0.5, 0.75, 1.0),                                
    # 'vect__max_features': (None, 5000, 10000),
    # 'tfidf__use_idf': (True, False),
    # 'clf__estimator__n_estimators': [50,100,150,200],
    # 'clf__estimator__max_depth': [20,50,100,200],
    # 'clf__estimator__random_state': [42]                                                   } 

# create grid search object                          
cv = GridSearchCV(pipeline, param_grid=parameters, verbose=1)                                                   return cv

在这个阶段，天空是极限！管道内部没有参数限制。然而，根据数据库和所选参数的不同，可能需要很长时间才能完成。即便如此，这也是一个非常好的研究工具。

我们可以添加一个函数来读取来自数据 ETL 的数据，并添加另一个函数来保存创建的模型，这样我们就有了模型 ETL，结束了这个阶段。

尽管我们谈论了所有的事情，创建管道的最大优点是代码的可复制性和可维护性，这是指数级提高的。

那么，开始创建管道还等什么呢？

这方面的一个例子可以在这个项目中找到。

如何在您的 Azure web 应用中使用 Microsoft 身份平台

原文：https://towardsdatascience.com/how-to-use-the-microsoft-identity-platform-in-your-azure-web-app-fcb3839a44e5?source=collection_archive---------26-----------------------

通过身份、角色和权限管理对应用的访问

介绍

微软身份平台是安全访问您的网络应用的关键。用户可以使用他们的 Azure AD 身份或社交帐户对你的应用进行身份验证。授权模型可用于向您的后端应用程序或标准 API(如 Microsoft Graph)授予权限。在这篇博客中，我们讨论了一个 web 应用程序，它具有以下功能:

• 1.具有用户角色的 Azure AD 登录:基本或用户角色:高级
• 2.使用已登录用户的委托权限访问 MS 图表
• 3.使用应用程序权限和应用程序角色访问后端

项目的代码可以在这里找到，架构可以在下面找到。

项目架构，作者图片

重点是提供一个使用微软身份平台的工作示例，并“弄脏你的手”。重点不是解释 OAuth 2.0 和 Azure AD 的内部工作方式。在本博客的剩余部分，将讨论以下内容。

• 步骤 0:准备工作—设置前端和后端
• 步骤 1:访问前端— Azure AD 登录，添加用户角色
• 步骤 2:访问图表-委托权限检索用户详细信息
• 步骤 3:访问后端—应用程序检索数据的权限
• 杂项:配置项目的其他可能性
• 结论

要了解如何使用授权或应用程序权限访问 Azure SQL 数据库，请参见我之前的博客。注意，两个博客共享同一个 git repo，所以这个项目可以配置为访问 Azure SQL，而不是后端应用程序。

步骤 0。准备工作—设置前端和后端

这个示例展示了如何使用 Flask 和 MSAL Python 构建 Python 前端 web 应用程序，以及如何使用 Azure 函数构建后端应用程序。在该步骤中，执行以下子步骤:

• 0.1:创建前端 web 应用程序
• 0.2:创建和配置前端应用程序注册
• 0.3.创建后端 Azure 功能
• 0.4:配置 python webapp 项目
• 0.5:运行示例
• 0.6:(可选)将前端 web 应用部署到 Azure

0.1:创建前端 web 应用程序

若要运行此示例，您需要在本地安装它:

• Python 2.7+ 或 Python 3+
• Azure 活动目录(Azure AD)租户。有关如何获得 Azure AD 租户的更多信息，请参见如何获得 Azure AD 租户。
• Git 克隆下面的项目:git clone https://github.com/rebremer/ms-identity-python-webapp-backend.git或者下载并解压存储库。zip 文件。

0.2:创建和配置应用程序注册

创建和配置应用程序注册，如下所示:

• 使用此链接中的步骤创建应用注册以创建应用注册。两个备注:
• 使用http://localhost/getAToken作为回复网址。如果您在创建过程中没有这样做，可以使用应用程序注册的验证选项卡添加它
• 转到认证并启用隐式授权中的选项 ID 令牌
• 转到证书&秘密创建一个秘密。复制客户端 id 和客户端密码

0.3:创建后端 Azure 函数

在这一部分，将部署 Azure 功能。这是按如下方式完成的:

• 使用这个快速入门在 python 中创建一个 Azure 函数。
• 从 git repo 更新 blog-webappaad-backend 文件夹中的requirement.txt和__init__.py，再次发布功能
• 在此快速入门之后，使用快速设置在您的 Azure 功能中启用身份验证/授权。

0.4:配置 pythonwebapp 项目

1. 打开app_config.py文件，改变下面的变量。
2. 在步骤 1.2 中创建应用程序注册时，找到文本<<Enter_the_Client_Secret_here>> ，并将其替换为您的应用程序密码。
3. 找到文本<<Enter_the_Tenant_Name_Here>>并用您的 Azure AD 租户名称替换现有值。
4. 找到文本<<Enter_the_Application_Id_here>>并用步骤 1.2 中应用程序注册的应用程序 ID (clientId)替换现有值。
5. 查找文本<<your Azure Function>>和<<your secret>>用步骤 1.3 中创建的 Azure 函数替换现有值。

0.5:运行示例

您需要使用 pip 安装依赖项，如下所示:

$ pip install -r requirements.txt

使用以下命令从 shell 或命令行运行 app.py:

flask run --host localhost --port 5000

当 app 在本地运行时，可以通过 localhost:5000(不是 127.0.0.1:5000)访问。步骤 1 之后，用户可以使用他们的 Azure AD 凭据登录，并从后端检索数据。

0.6:(可选)将前端 web 应用部署到 Azure

最后，请看这个链接如何在 Azure web 应用中部署你的前端 flask 应用。部署代码的最简单方法是从放置 app.py 的目录中运行以下命令:

az webapp up -n <<your unique webapp>> --sku F1

确保将https://<<your uniquewebapp>>.azurewebsites.net/getAToken添加为回复 URL。当您登录并点击链接从 backed 中检索数据时，应显示以下屏幕:

0.6.从后端成功检索到数据

然而，为了能够执行本教程的剩余步骤，也可以使用 localhost。

步骤 1:访问前端— AAD 登录，添加角色

在此步骤中，将为用户分配一个角色，以指示其是基本用户还是高级用户。执行以下子步骤:

• 1.1:在应用配置中设置配置
• 1.2:向清单添加角色
• 1.3:为用户分配高级角色

步骤 1 关注架构的以下部分。

1.Azure 广告登录，配置用户角色，按作者分类的图片

1.1:在应用配置中设置配置

索赔验证是一个可选步骤，可以使用app_config.py文件中的以下设置启用:AAD_ROLE_CHECK = True。

1.2:向清单添加角色

按照本教程中的步骤，向步骤 1.2 中创建的应用程序注册添加角色。显然，应使用以下方法:

"appRoles": [
  {
    "allowedMemberTypes": ["User"],
    "description": "Basic user, read product data from backend",
    "displayName": "basic_user_access",
    "id": "a8161423-2e8e-46c4-9997-f984faccb625",
    "isEnabled": true,
    "value": "basic_user_access"
  },
  {
    "allowedMemberTypes": ["User"],
    "description": "Premium user, read all data from backend",
    "displayName": "premium_user_access",
    "id": "b8161423-2e8e-46c4-9997-f984faccb625",
    "isEnabled": true,
    "value": "premium_user_access"
  }
],

1.3:将用户分配给角色

在链接中解释了用户的分配。作为测试，可以创建两个用户。用户 1 被分配了basic_user_access，而用户 2 获得了premium_user_access角色，另请参见下面的屏幕截图，其中 admin、student2 被分配了高级角色，而 student 1 只有基本角色。

1.3a .分配给用户的角色

如果学生点击客户链接，对后端的访问将被前端拒绝，另请参见下面的消息。

1.3b .角色为“基本拒绝访问”的用户

在下一步中，使用 Microsoft Graph API 检索用户数据。

第二步。对图表的访问-委托权限

用户是 Azure 广告公司或学校用户帐户或 Microsoft Graph 中的 Microsoft 帐户的表示。在这个步骤中，使用users.read范围，使用登录用户的委托权限来检索自己的数据。执行以下子步骤:

• 2.1:验证应用注册中的权限
• 2.2:检索数据

第 2 步关注架构的后续部分。

2.委托权限，按作者获取图表数据、图像

2.1:验证应用注册中的权限

应用程序注册需要同意从 Microsoft Graph 读取用户数据。根据 Azure AD 配置，以下类型的同意是可能的:

• 管理员同意:管理员已经同意应用程序可以代表登录的用户读取用户的数据。这种同意可以事先在应用程序注册权限中完成，也可以在管理员首次登录 web 应用程序时完成。
• 用户同意:An uses 本人已经同意 app 可以代表登录用户读取用户的数据。一旦用户第一次登录应用程序，这种同意就完成了

在这种情况下，使用事先完成的管理员许可。请参阅下面的 users.read 权限是在应用程序注册中授予的:

2.1a .用户。读入应用程序注册管理员同意书

随后，在 app 注册的附着企业应用中验证 App 可以代表用户读取用户的数据。

2.1b .用户。读入应用程序注册管理员同意书

注意那个用户。只读允许用户检索他自己的数据，而不是其他人的数据(只有有权限的用户才能这样做。Read.All)

2.2:检索图形数据

一旦应用程序获得用户同意或管理员同意检索数据，只需登录并单击链接调用 Microsoft Graph API，用户自己的数据就会返回，也见下文。

2.2.图形调用返回用户数据

第三步。访问后端—应用程序权限

在步骤 1 中，已经从后端检索了数据。然而，不仅前端可以从后端检索数据，同一 Azure AD 租户内的所有身份都可以检索数据。使用应用程序权限和用户分配，确保只有前端可以访问后端。

执行以下子步骤:

• 3.1:向后端和前端添加应用程序权限
• 3.2:在后端启用用户分配

第 3 步关注架构的后续部分。

3.应用程序权限，配置应用程序角色，按作者分类的图像

3.1:向后端和前端添加应用程序权限

转到后端应用程序注册清单，并将以下应用程序角色添加到清单中。

"appRoles": [
  {
    "allowedMemberTypes": ["Application"],
    "description": "frontend_app_access",
    "displayName": "frontend_app_access",
    "id": "f8161423-2e8e-46c4-9997-f984faccb625",
    "isEnabled": true,
    "value": "frontend_app_access"
  },

随后，进入前端的应用注册，点击 API 权限，将这些权限授予你的前端应用，也见下文。

3.1a .在前端授予应用程序权限

随后，授予管理员权限，以便前端可以使用应用程序角色 front_end_access 访问后端。要验证前端是否具有应用程序角色 front_end_access，请转到后端应用程序注册、企业应用程序并查找用户/组，另请参见下文。

3.1b .后端的应用程序角色

请注意，角色 front_end_access 没有明确显示，但在 3.2 中将会显示该角色。

3.2:在后端启用用户分配

转到您的后端应用程序注册，企业应用程序，并寻找属性和启用用户分配，也见下文。

3.2a .后端中的应用程序角色

启用此属性时，前端是唯一可以从后端检索数据的应用程序，另请参见下面显示角色的位置

3.2b .显示的前端应用访问角色

多方面的

属于这个项目的 git repo 有额外的配置选项，讨论如下:

• 通过在 appconfig 中设置DAEMON_ENABLED=True，可以将应用程序配置为守护程序应用程序。用户不必再登录来检索数据。
• 通过在 appconfig 中设置Option 2b. Database，Azure SQL 数据库可以用作后端，而不是 Azure 函数。详见这篇博客。
• 在应用程序配置中使用Option 3b. Delegated user is used to authenticate to backend,委托权限用于对后端而不是应用程序权限进行认证。
• 这篇博客中的第 3 步可以通过调整这个 git repo 中的 Power Shell 脚本来实现自动化。

结论

Microsoft identity platform 可以帮助您保护对应用程序的访问。在这篇博客中，提供了一个具体的例子，它使用 Azure AD 以“基本”或“高级”用户角色登录用户。随后，登录用户的委托权限用于检索 Microsoft Graph 数据，应用程序权限用于访问后端，另请参见下面的架构。

项目架构，作者图片

如何使用 Google Sheets 中臭名昭著的 VLOOKUP 功能？

原文：https://towardsdatascience.com/how-to-use-the-notorious-vlookup-function-in-google-sheets-3dd6f825d4fe?source=collection_archive---------45-----------------------

电子表格/虚拟桌面

以及如何克服它带来的各种挑战。

照片由布鲁斯·马尔斯在 Unsplash 拍摄

Google Sheets(或 Microsoft Excel)最神奇(也最令人困惑)的功能之一是 VLOOKUP 。尽管从任何意义上来说都不完美，但它确实提供了强大的功能来连接两个不同的表，或者将一个表的值附加到另一个表中。

什么是 VLOOKUP？

VLOOKUP 是电子表格中的一个功能，它允许用户在两个表格之间建立关系。让我们试着用一个例子来理解它。

假设您是一家即将成立的游戏工作室的分析师，他们希望您创建一个 2002 年最畅销游戏的数据库。幸运的是，您发现了一个包含所有信息的惊人数据集，它是这样的:

它包含两个独立表格中的信息:

• 一个表格包含游戏名称和发布平台的信息。
• 第二个表包含游戏名称和北美和欧洲的销售额(以百万计)。

有关上述数据集的更多信息，您可以访问 Kaggle 。

我们如何合并两个表？我们可以简单地将值从一个复制粘贴到另一个。但是仔细看，两个表中的名字不是同一个顺序！嗯，我们可以一个一个复制粘贴。但是任务太多了！为什么不让电子表格来帮我们做呢？听起来像个计划！这就是全能的 VLOOKUP 函数出现的地方！

如何使用 VLOOKUP？

下面是 VLOOKUP 函数的样子:

=VLOOKUP(search_key, range, index, [is_sorted])

函数中需要的 3 个强制参数。以下是它们是什么以及它们是如何工作的:

VLOOKUP 函数的作用

• 搜索关键字:选择您想要查找其值的单元格。在这个例子中，我们想要找到单元格 A2 中提到的游戏标题的NA_Sales数字。所以搜索关键字是 A2。
• 范围 : 你想要的数值在哪里？在我们的例子中，它位于表中 D2 到 F16 的某个位置。因此，我们选择要从中复制值的整个表。请注意我们是如何添加许多$符号的。一旦你选择了表格范围，要做到这一点，只需按下键盘上的 F4，你会有相同的格式。

关于为什么使用$ signs 的一个小注意:一旦你创建了你的函数，下一个自然的步骤是向下拖动该函数并将其应用于下面的所有单元格。如果你没有按下 F4，随着拖动公式中的搜索键，你就是也在拖动你所选择的范围。这将意味着，为了找到对应于 A4 的值，您实际上是在范围 D3:F17 中搜索，而不是您原来的 D2:F16。所以如果你的 A4 值在 D2，你的函数不会读取它并抛出一个错误。这就是$符号出现的地方。按下 F4 一次，你就冻结了选定的范围，这样一旦你把公式拖到下面的单元格中，它就不会改变范围，而只会改变搜索关键字。

• Index :在您刚刚选择的范围内，您要抓取的列是哪一列？在我们的例子中，它是NA_Sales列，这是 D2 到 F16 的选定范围中的第二列。请注意，索引号从步骤 2 中所选范围的第一列开始。
• 已排序:这是一个可选的字段。出于所有实际目的，将其设置为零或假。就我个人而言，我从未遇到过将该字段设置为其他方式的情况。

然后按回车键！这个函数现在在您提到的的范围内，在您的搜索关键字中找到值，一旦找到匹配，它就会抓取提到的索引列并给出结果。在这种情况下，它将打印值 8.41，因为这是提到的第一个游戏在北美地区的销售额。以下是最终的解决方案:

成功实现 VLOOKUP 后的最终结果

常见陷阱以及如何避免它们

以下是应用 VLOOKUP 时需要记住的几个要点:

1. 查找函数如何知道在提到的范围内匹配什么？请始终记住，查找函数只会匹配公式中指定范围的第一列中提到的值。在我们的例子中，我们提到的产品系列是 D2:F16。搜索关键字将只与 D2:F16 范围的 D 列中的值匹配。通常，搜索范围的第一列应该是搜索关键字所在的列。
2. 查找函数将总是提供它得到的第一个结果。
   例如，如果在销售表中多次提到一个游戏，它会获取第一个匹配的值并相应地提供结果。
   如果你有同一个搜索关键字的多个实例，VLOOKUP 是而不是要走的路！
3. 您需要确保在范围中找到的搜索关键字和值与完全匹配。不应该有多余的空格。字符串大小写应该是一样的。如果不是，它将与值不匹配，您将得不到想要的结果。
4. 当 VLOOKUP 在该范围内没有找到您要寻找的值时，它通常会抛出一个 #N/A 错误。这仅仅意味着该值不存在于所提到的范围内，或者该范围存在一些额外的空格或大小写问题(如上所述)。

VLOOKUP 还有另一个变种，叫做 HLOOKUP。VLOOKUP 垂直匹配值，HLOOKUP 水平匹配值。该功能的工作方式完全相同。

VLOOKUP 并不是连接两个表的完美解决方案。但是在大多数情况下，小心执行并记住常见陷阱，你可以在很多场景中使用 VLOOKUP。还有另一种更强大的方法来解决连接两个表的问题，这种方法通常被称为索引匹配函数，在下一篇文章中会详细介绍。

同时，继续分析！

作为一名数据科学家，如何利用“为什么”的力量实现自己的目标

原文：https://towardsdatascience.com/how-to-use-the-power-of-why-to-achieve-what-you-want-65fdbde71ea3?source=collection_archive---------29-----------------------

(来源)

成为一名数据科学家很难。

成为一名 伟大的 数据科学家更难。

作为一名伟大的数据科学家，我的意思是对你所做的事情有热情和信念以及用数据解决问题的能力推动行动。

现在…我这么说是什么意思？

数据科学讲解

你看。如果你对业务领域、技术能力(编码、数学、统计等)有很好的理解，解决数据问题是很容易的。)以及与同事的协作。

任何人都可以解决问题，只要他们有知道做什么和如何做的技能。

然而，我相信有两个重要的因素需要认真地成为一个伟大的数据科学家来实现你想要的。

在这篇文章结束时，我希望你能理解拥有“为什么”的重要性，以及如何利用“为什么”的力量成为一名伟大的数据科学家，实现你想要的东西，无论是工作还是生活。

我们开始吧！

1.有激情，相信你所做的事情

数据科学之路并不容易。

如果你是一名数据科学家，正在阅读这篇文章。你会明白我的意思。

很艰难。这是一个不断变化的领域。它是动态的。它移动得很快。

换句话说，你需要快速学习和适应，以跟上行业的最新趋势和技术。

你现在使用的工具或语言可能会在几周或几个月后过时。

如果你对自己的工作没有热情，作为一名数据科学家，你如何确保自己能够坚持不懈地学习和提高？

更糟糕的是，如果你甚至不相信你正在做的事情，你很可能不会在这个领域呆很久。

这听起来可能有点刺耳，但却是千真万确的。

换句话说，这一切都归结为一个问题，“你为什么做你所做的事情？”

句号。

如果你一开始就不知道为什么要做你要做的事情，你就不会有动力每天早上醒来去做你喜欢的事情。

作为一名数据科学家，当你在整个旅程中遇到困难时，你不会有动力继续努力。

对我来说，我的“为什么”很简单。

我想让每个人都能接触到数据科学。

这才是我热爱的。

这是我所信仰的。

作为一名数据科学家，这就是我的工作。

现在你的问题是，“你的原因是什么？”

请在下面的评论中告诉我。😊

2.用你的“为什么”推动行动

Simon Sinek —从为什么开始

人们不买你做什么，他们买你为什么做。

—西蒙·西内克

如果你没有看过西蒙·西内克的 TED 演讲，那就看看吧。

几秒后你就知道为什么重要了。

那么，作为一名数据科学家，为什么推动行动对我们如此重要呢？

你看。

想象一下，你非常擅长建立预测准确度很高的机器学习模型。

酷毙了。你做得很好。

这一天到来了，你需要向你的老板和其他利益相关者展示你的预测结果。

你展示了该模型高达 95%的惊人预测准确率，这太棒了。

现在坐在桌子对面的老板问了这个问题，“结果很好。那么我们下一步能对结果做什么呢？”

你惊呆了。

你以为你刚刚解决了一个问题，但是你忘了回答问题的核心问题。

作为一名数据科学家，我认为我们总是需要提供可操作的见解，而不仅仅是展示结果。

通过可操作的见解，我的意思是用结果说服人们，并根据结果推荐接下来的步骤。最重要的是，我们需要告诉人们**“为什么”结果和推荐的步骤是至关重要的**。

因为当你告诉他们原因时，人们很可能会跟随你的做法。

这就是你如何通过说出“为什么”来说服你的利益相关者，从而推动行动。

最后的想法

(来源)

感谢您的阅读。

这个话题是我一直想分享的。

我希望现在你已经更好地理解了“为什么”的重要性，以及如何利用它成为一名伟大的数据科学家，以实现你想要的东西，无论是工作还是生活。

在一天结束的时候，知道“为什么”会让人们(包括你自己)在更深的层次上参与进来，从而激励人们去做。

一如既往，如果您有任何问题或意见，请随时在下面留下您的反馈，或者您可以随时通过我的网站或 LinkedIn 联系我。在那之前，下一篇文章再见！😄

关于作者

Admond Lee 目前是Staq**—**的联合创始人/首席技术官，该平台是东南亚首屈一指的商业银行应用编程接口平台。

想要获得免费的每周数据科学和创业见解吗？

加入 Admond 的电子邮件简讯——Hustle Hub，每周他都会在那里分享可行的数据科学职业技巧、错误&以及从创建他的初创公司 Staq 中学到的东西。

你可以在 LinkedIn 、 Medium 、 Twitter 、脸书上和他联系。

[## 阿德蒙德·李

让每个人都能接触到数据科学。Admond 正在通过先进的社交分析和机器学习，利用可操作的见解帮助公司和数字营销机构实现营销投资回报。

www.admondlee.com](https://www.admondlee.com/)

如何用 Python 在机器学习中使用 SimpleImputer 类

原文：https://towardsdatascience.com/how-to-use-the-simpleimputer-class-in-machine-learning-with-python-10b321c94861?source=collection_archive---------30-----------------------

简单地使用简单估算器

图片由罗斯·斯奈登 Unsplash 提供

缺失值插补

数据集经常有缺失值，这可能会给机器学习算法带来问题。在执行预测建模之前，识别并替换数据集每一列中缺失的值被认为是一种良好的做法。这种缺失数据替换的方法被称为数据插补。

数据集中的缺失值可能是由多种原因造成的。这些通常包括但不限于:测量设备故障、不一致数据集的整理以及实验期间数据收集的变化。

缺失数据插补的一个方便策略是用一列中其他值计算出的统计值替换所有缺失值。这种策略通常可以带来令人印象深刻的结果，并避免在构建机器学习算法时丢弃有意义的数据。常用的统计包括计算列的平均值、中值和众数，并为缺失值输入该值。此外，可以输入一个常数值来补充上述方法。

本教程旨在演示简单估算类在统计估算中的用法。

数据集和缺失数据评估

本教程中使用的数据集是“逻辑回归预测心脏病数据集，可通过这里的 kaggle 或我的 github 页面获得。

该数据集来自一项正在进行的对马萨诸塞州弗雷明汉镇居民的心血管研究。分类目标是预测患者是否有未来冠心病(CHD)的 10 年风险。数据集提供了患者的信息。它包括 4000 多条记录和 15 个属性。这些属性可以通过 kaggle 找到。我在这里的主要目的不是深入研究这个数据集，而是展示一个使用 SimpleImputer 类进行预测建模的用例。

首先导入所需的库，并执行一些探索性数据分析(EDA)。

dataframe 上调用的 dataframe 和 columns 属性的头显示了所有 15 个数据属性。

为了计算缺失值的数量以及它们相对于列的百分比，我首先对列进行迭代。对于每一列，我使用 isna()方法调用来评估 NaN 值的数量，并通过方法链接对这些值求和。

然后，我计算总行数中缺失值的数量，得到每列缺失值的百分比，并打印出这些数据。

虽然这是信息性的，但需要一些阅读来完全解释结果。确定缺失结果的更好方法可能是使用 seaborn 热图制作一个有用的图形。

我们首先传入 dataframe.isna()，如果缺少值，它将返回 True。然后，我们可以将 cbar 和 ytickslabels 都设置为 False，选择一个颜色映射(这里是字符串 viridis)，并可视化结果。

现在我们有了一个快速参考图，它可以有效地告诉我们，哪些列缺少数据。在这里，我们可以看到葡萄糖列丢失的数据值最多。

简单估算类的统计估算

sci-kit learn 机器学习库提供了实现统计插补的 SimpleImputer 类。

要使用 SimpleImputer，首先导入该类，然后用传递给策略参数的字符串参数实例化该类。为了清楚起见，我在这里包含了‘mean ’,这是默认的，因此没有必要显式包含。

我通过调用 dataframe 上的值将 dataframe 转换成一个 numpy 数组(不必要)，但这是我喜欢的习惯。然后我选择我的特征并把它们赋给变量 X，选择我的目标变量并把它赋给变量 y。

估算值适合数据集，用于计算每列的统计数据。然后将拟合估算值应用于数据集，以创建数据集的副本，其中每列的所有缺失值都用计算出的均值统计数据替换。

为了确认数据插补有效，我们可以评估应用和不应用数据转换的数据集上缺失值的数量。当应用数据转换时，已经估算了 645 个列值。

模型评估

模型评估最好使用重复的 k- 折叠交叉验证。要求首先在训练数据集上计算每列的计算统计量，然后应用于数据集中每个折叠的训练集和测试集。

为了实现这一点，我们可以创建一个建模管道，其中第一步是统计插补，第二步是模型本身。

以下管道使用均值策略进行统计插补，并使用 RandomForestClassifier 进行模型预测。

我们达到了 84.7%的准确率，标准偏差为 0.007。这是一个合理的结果，但了解哪种插补策略最适合预测建模性能会很有用。

测试插补策略

为了测试不同的插补策略，我们可以遍历这些策略。对于每个管道，我们可以构建一个新的策略，计算交叉值分数，并将它们添加到结果列表中。

我们可以使用结果列表中的数组和策略类型来生成一个盒须图，以解读哪种数据插补策略是最佳的。我已经决定检查每种策略类型的平均分数和最高分数。

盒状图和须状图表明使用常数(0)插补策略获得了最佳准确度分数。

对样品进行测试

现在可以使用最佳插补策略进行预测。根据所有可用数据定义和拟合管道。

我们可以获取数组中的第一行，对其进行整形，将其赋给变量名 sample，并将其作为参数传递给管道上调用的 predict 方法调用。

为了确认这是正确的结果，我们可以检查第一个 y 目标变量标签。我们的模型预测了一个 0 类，而这个类实际上也是一个 0 类。

摘要

简单估算类是使用计算统计数据估算缺失值的有效方法。通过使用 k -fold 交叉验证，我们可以快速确定传递给 SimpleImputer 类的哪个策略给出了最佳的预测建模性能。

链接到完整的 Jupyter 笔记本

这个教程的完整 Jupyter 笔记本的链接可以在这里找到。

如何使用时间旅行来调试你的 ML 管道

原文：https://towardsdatascience.com/how-to-use-time-travel-to-debug-your-ml-pipelines-efb5263372c0?source=collection_archive---------39-----------------------

让你的管道步骤透明化，探索它们的状态，住在 Jupyter。

丹尼尔·利维斯·佩鲁西在 Unsplash 上的照片

机器学习项目由几个不同的步骤组成:数据获取、数据验证、数据处理、模型训练、模型评估等。每一步都接受定义明确的输入，并产生特定的输出。

如果我们能回到过去，在熟悉的 Jupyter 环境中探索跑步的状态，那就太好了

**如果传入的数据有问题，该步骤可能会失败，甚至会破坏下游的分析任务。**后者可能会引入不太容易调试的重影问题:例如，数据泄漏(即，当训练数据集之外的信息用于创建模型时)可能会影响模型的泛化能力，但它不会在训练期间引发异常。

为了避免这种错误，我们应该能够窥视管道并尽早发现它们。因此，数据科学家最终会检查日志，打印原始指标并创建可视化，如学习曲线和混淆矩阵。

虽然这些工具为构建更健壮的模型提供了有价值的见解，但是如果我们能够回到过去并探索正在运行的步骤的状态，那就太好了。在这个故事中，我们探索如何在 Kubeflow 管道中做到这一点。

学习率是为那些对 AI 和 MLOps 的世界感到好奇的人准备的时事通讯。你会在每周五收到我关于最新人工智能新闻和文章的更新和想法。在这里订阅！

安装 Kubeflow

首先，我们需要一个工作站。设置 Kubeflow 不是一件容易的事情，尤其是如果你没有使用 Kubernetes 的经验。但这不应该阻止你；我们可以在谷歌云平台(GCP)上使用 MiniKF 在 10 分钟内构建一个单节点集群。

1. 访问 GCP 页面上的 MiniKF
2. 选择启动，设置虚拟机配置并点击部署

为了获得最佳性能，建议保留默认的虚拟机配置

MiniKF 部署—作者图片

就是这样！部署最多需要十分钟，您可以按照屏幕上的说明观看进度；ssh 进入机器，在终端上运行minikf,等待直到您的端点和凭证准备好。

MiniKF 的提供已完成—图片由作者提供

现在，我们准备访问 Kubeflow 仪表板。点击网址，输入你的凭证，你就可以开始了！

Kubeflow 仪表板—按作者分类的图像

有关部署过程以及如何启动 Jupyter 服务器的更多详细信息，请阅读下面的故事:

[## 有了 MiniKF，Kubeflow 比以往任何时候都更容易访问

10 分钟入门 Kubernetes 最好的机器学习平台。

towardsdatascience.com](/kubeflow-is-more-accessible-than-ever-with-minikf-33484d9cb26b)

调试 Kubeflow 管道

为了演示如何在某个时间点返回并探索管道步骤的状态，我们需要管道本身。无需编写一行代码，就可以轻松地从 Jupyter 笔记本上创建 Kubeflow 管道。你可以在下面的故事中看到。

[## Jupyter 准备生产；原样

无需编写一行代码，即可将您的笔记本草稿转化为生产就绪的 Kubeflow 管道。

towardsdatascience.com](/jupyter-is-ready-for-production-as-is-b36f1d1ca8f8)

对于这个例子，我们假设您已经成功地运行了一个管道。如果你想了解前面提到的故事，我们使用众所周知的泰坦尼克号数据集来训练五个不同的分类器。最后，您的管道应该类似于下面这样:

泰坦尼克号管道——作者图片

所以，假设我们对 SVM 算法的结果不满意。**我们想回到这一步，在训练算法和探索我们生活在笔记本中的世界的状态之前。**为此，我们求助于韩国！

韩国快照

Rok 是一个数据管理产品，允许您对您的完整环境及其数据进行快照、版本化、打包、分发和克隆。它作为其支持的平台之一与 Kubernetes 进行了本机集成，并在几分钟内部署到现有的集群、本地或云上。

它预装在 MiniKF 中，所以让我们使用它:

1. 点击smv步骤并选择Visualizations选项卡
2. 跟随Rok autosnapshot卡内的链接
3. 复制页面顶部的韩国网址
4. 创建一个新的笔记本服务器，并在顶部粘贴复制的网址
5. 配置虚拟机资源，并为工作区指定一个有效的名称
6. 点击LAUNCH按钮

与韩国同行——作者图片

当笔记本电脑服务器准备就绪后，连接到它，一个新的 JupyterLab 环境将在您请求的位置准确地打开。到目前为止的所有单元格都已为您执行。您可以从该单元格继续工作；探索变量状态、数据集和您的模型。

继续你的 JupyterLab 状态——作者图片

现在，您有了一种调试错误的方法，即探索在特定时间点管道中发生了什么。这当然比原始日志更有价值，也比静态可视化更强大。

结论

在这个故事中，我们看到了如何使用 Rok，一种数据管理服务，在 Jupyter 笔记本中进行时间旅行，并实时探索管道步骤的状态。这给了我们调试 ML 管道的能力，也给了他们版本。如果您关心版本控制，可以看看下面的文章。

[## 你控制 ML 项目版本的方式是错误的

当您可以拥有更多时，是否在寻找一种类似 git 的数据版本控制方法？是时候跳出框框思考了

towardsdatascience.com](/the-way-you-version-control-your-ml-projects-is-wrong-42910cba9bd9)

关于作者

我叫迪米特里斯·波罗普洛斯，我是一名为阿里克托工作的机器学习工程师。我曾为欧洲委员会、欧盟统计局、国际货币基金组织、欧洲中央银行、经合组织和宜家等主要客户设计和实施人工智能和软件解决方案。

如果你有兴趣阅读更多关于机器学习、深度学习、数据科学和数据操作的帖子，请在 twitter 上关注我的 Medium 、 LinkedIn 或 @james2pl 。

所表达的观点仅代表我个人，并不代表我的雇主的观点或意见。

如何利用 Spotify 的 API 并在 Streamlit 中创建用户界面

原文：https://towardsdatascience.com/how-to-utilize-spotifys-api-and-create-a-user-interface-in-streamlit-5d8820db95d5?source=collection_archive---------18-----------------------

实践教程

关于如何从 API 提取数据并在交互式图表中显示用户确定的结果的演练

首先，我们必须进入下面的 Spotify 开发者页面。

[## 我的仪表板|面向开发者的 Spotify

我们和我们的合作伙伴使用 cookies 来提供我们的服务，并根据您的兴趣向您显示广告。通过使用我们的…

developer.spotify.com](https://developer.spotify.com/dashboard/)

您将使用您的 Spotify 帐户凭据登录。登录后，您可以选择“创建应用程序”。

作者照片

一旦你创建了一个应用程序，你会看到你的客户 ID 和客户密码。我们将需要这些来生成一个访问令牌，我们将使用它从 API 获取数据。

我们将把代码分成三个独立的脚本。一个将是访问 API 的 API 客户端，一个将调用客户端并在 Streamlit 中生成接口，一个将用于帮助改善 Streamlit 接口的外观。

构建 API 客户端脚本

我们的目标是创建一个允许我们轻松进行 API 调用的类。

为了帮助指导我们构建类，我们将遵循 Spotify 开发者页面上的授权指南。

https://developer . Spotify . com/documentation/general/guides/authorization-guide/

首先，我们将导入所有必需的库。

然后，我们可以开始在类中声明一些我们需要的变量以及一个初始化函数。

应该注意，访问令牌在 3600 秒后过期，因此我们将实现一些代码来检查令牌的过期时间。令牌 URL 可以在 Spotipy 文档的授权指南中找到。

https://developer . Spotify . com/documentation/general/guides/authorization-guide/

作者照片

然后，我们需要使用我们的客户端 ID 和客户端密码为我们的客户端凭证创建一个 base64 编码的字符串。将我们的凭证编码成 base64 字符串使它更加安全。

我们现在可以使用 get_client_credentials 函数，并在另一个函数中调用它来生成一个令牌头，我们将需要它来进行授权。

作者照片

我们还将构建一个 get_token_data 函数。

有了函数和变量之后，我们现在将编写一个函数来执行身份验证，给出函数的输出和变量的值。

有了验证我们凭证的代码，我们现在可以创建一个函数来生成令牌。下面的代码确保凭据验证正确，并将生成一个令牌。

接下来，我们将生成一个请求所需的头。您将会看到，在这个函数中，我们需要使用一个“承载”认证器，而不是我们之前使用的“基本”认证器。“载体”认证器用于令牌，而“基本”认证器与 ID 和秘密一起使用。

作者照片

一切就绪后，我们现在可以编写一些函数来获取数据。我们将使用对应于 Web API 文档中“搜索”引用的端点。

https://developer . Spotify . com/documentation/we b-API/reference/search/search/

作者照片

下面的代码将允许我们进行查询搜索，而不必在每次我们想要进行不同的搜索时复制和粘贴函数。它允许我们搜索的方式是传入一个字典，然后用冒号{k}:{v}将字典分成一个键值对。最终，这允许我们将字典转换成字符串，这是我们需要搜索的格式。

现在，我们可以将所有内容放在一起，并将其保存为 python 文件。我将该文件命名为 spotipy_client.py，您可以随意命名，但是请记住这个名称，因为我们需要将它导入到另一个脚本中。

Streamlit 界面 CSS 文件

接下来，我们将创建一个 CSS 文件，用于定制我们的 Streamlit 界面。

下面的代码将允许自定义背景颜色以及自定义搜索按钮。

我们可以将这个脚本保存为 CSS 文件。与客户端脚本类似，记住名称，因为我们也需要导入这个文件。

构建界面的脚本

在构建界面脚本之前，我们需要做的最后一件事是创建一个虚拟环境来下载成功运行最终脚本所需的包。我用 conda 为这个项目创建了我的虚拟环境。您可以通过打开 Anaconda 提示符并运行以下代码来完成同样的工作。

创建虚拟环境的原因是我们可以为特定的项目下载特定的包。这也比将包直接下载到机器的基本实例更安全。

一旦我们有了我们的环境，我们将需要激活它来下载包，然后最终运行我们的脚本。

您可以使用以下命令激活环境。

我们需要在虚拟环境中安装 Streamlit。你可以和皮普一起做这个。

最后，我们可以开始构建允许我们创建 streamlit 接口的脚本。

首先，我们将利用我们的 CSS 代码来定制我们将要生成的页面的外观。

接下来，我们将创建 streamlit 变量，该变量将允许用户向我们的 python 代码传递数据，这些代码将利用我们的 spotipy_client.py 脚本。

上面的代码创建了一个搜索栏，供用户搜索艺术家，一个下拉菜单，提供不同的功能供用户选择，还有一个按钮，供用户选择后运行代码。我们将使用所做的选择在脚本中进一步传递相应的变量。

接下来，我们将把所需的参数传递给 SpotifyAPI 类。您需要确保您的 spotipy_client.py 文件位于您当前工作的目录中，否则，它将不会加载到我们当前的脚本中。

将 client_id 和 client_secret 传递给我们的类后，我们现在就可以查询我们想要的数据了。

我们的目标是使用通过 Streamlit 接口生成的变量 Name_of_Artist 来搜索特定艺术家的曲目。您会注意到，这会以 JSON 格式返回数据。为了在我们的脚本中使用它，我们需要解析 JSON 数据并提取我们想要传递到 dataframe 中的值。在下面的代码中，“artist”是键，“Name_of_Artist”是值。

我们现在有一个数据帧，它包括一些与艺术家的音轨相关的字段。

对于我们的项目，我们还需要引入音轨的特定音频特征。我们可以通过文档了解我们具体需要将什么传递到查找 URL 中。

https://developer . Spotify . com/documentation/we b-API/reference/tracks/

作者照片

正如我们所看到的，我们需要传入一个音轨 id 来获取我们正在寻找的音频特征数据。在我们现有的数据框架中，我们在列名“Id”下有该信息。我们一次只能查找一个“Id ”,因此我们将创建一个循环，进入我们的数据帧并将每个“Id”值传递给它。每个输出都是一行，我们可以将它附加到数据帧中，将数据转换成表格格式。

有了音轨信息的数据帧和音频特征的数据帧，我们可以将两者合并成一个组合表，并提取我们希望在界面中显示的字段。Name_of_Feat 将根据用户的选择传入。

最后，有了数据框架，我们可以构建图表和表格来显示。

我们将使用 Altair 图表，允许用户将鼠标悬停在不同的数据点上，以查看歌曲的不同方面，如流行度、音频功能、歌曲名称和专辑名称。

最后要补充的是如何测量不同音频特性的描述。我在屏幕底部添加了这个，以便我们的潜在用户在查看数据时查看。这些描述来自 Spotify 开发者网站上的音频功能文档。

[## 获取音轨的音频功能|面向开发者的 Spotify

需要路径参数授权。来自 Spotify 帐户服务的有效访问令牌:参见 Web API…

developer.spotify.com](https://developer.spotify.com/documentation/web-api/reference/tracks/get-audio-features/)

在测试我们的脚本之前，我们将把上面所有的代码放在一起，保存为一个 python 文件。

一切就绪后，我们可以测试我们的最终产品了。在您的终端中，您将运行以下命令。我将最终的 python 文件命名为 streamlit_audio_features.py，但是您可以随意命名。记得在终端中激活你的虚拟环境。此命令将在您的浏览器中打开一个新标签，并显示我们的界面。

下面展示了我们界面的一些快照。要查看界面的运行情况，您可以点击下面的 youtube 视频链接，或者自己运行代码。

作者照片

作者照片

https://www.youtube.com/watch?v=BuVZ07DNWj0

这些代码文件的完整脚本也可以在 Github 上找到。

[## jjevans25/Spotipy 图表

使用 Spotipy API 在 Streamlit 中创建交互式散点图。为了成功运行，您将…

github.com](https://github.com/jjevans25/Spotipy-Chart)

我希望这给了你一些关于如何使用 Python、API 和 Streamlit 的见解，以及你对项目的任何潜在想法。

spotipy_client.py 脚本修改自

麻省理工学院许可证(MIT)

面向企业家的版权 2020 编码

如何利用迁移学习和最新的深度学习模型对图像进行分类

原文：https://towardsdatascience.com/how-to-utilize-transfer-learning-to-classify-images-with-state-of-the-art-deep-learning-models-d8e5d5bb35d4?source=collection_archive---------59-----------------------

在这篇文章中，我将展示如何使用一个预先训练好的最先进的图像分类模型来对自定义数据进行分类。我展示了如何在 Keras 中使用谷歌的 efficientnet 模型来应用迁移学习，对来自斯坦福汽车数据集的汽车图像进行分类。完整的 jupyter 笔记本可以在我的 github 库中找到。

效率网

从最初简单的卷积神经网络(CNN)开始，通常可以通过任意缩放网络维度(如宽度、深度和分辨率)来逐步进一步提高模型的精度和效率。增加使用的层数或使用更高分辨率的图像来训练模型通常需要大量的人工工作。来自谷歌人工智能的研究人员发布了 EfficientNet，这是一种基于一组固定缩放系数和 AutoML 及其他技术进展的缩放方法(例如深度可分离卷积、 swish 激活、 drop-connect )。EfficientNet 不再像以前那样独立优化单个网络维度，而是寻求一种跨所有网络维度的平衡扩展流程。

借助 EfficientNet，参数数量大幅减少，同时在 ImageNet(此类应用的基准)上实现了最先进的结果。

迁移学习

虽然 EfficientNet 减少了参数的数量，但卷积网络的训练仍然是一项耗时的任务。为了进一步减少培训时间，我们可以利用迁移学习技术。

迁移学习意味着我们使用预先训练的模型，并根据新数据对模型进行微调。在图像分类中，我们可以考虑将模型分为两部分。模型的一部分负责从图像中提取关键特征，如边缘、常见模式等。一部分是使用这些特征进行实际分类。

通常，CNN 由堆叠的卷积块组成，减少了图像大小，同时增加了可学习特征(滤波器)的数量，最终所有内容都被放入一个完全连接的层中，该层进行分类。迁移学习的思想是使第一部分可以转移，这样通过只替换完全连接的层(通常只是称为“顶层”)就可以用于不同的任务。

履行

这款 keras Efficientnet 实施(pip install efficientnet)带有适用于所有尺寸(B0-B7)的预训练模型，我们只需添加自定义分类层“top”即可。用weights='imagenet'我们得到一个预训练的模型。这个片段大致展示了它是如何工作的(完整的例子见 jupyter 笔记本):

base_model = EfficientNetB5(include_top=False, weights='imagenet')
x = base_model.output
x = GlobalAveragePooling2D()(x)
predictions = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)# fix the feature extraction part of the model
for layer in base_model.layers:
    layer.trainable = Falsemodel.summary()
--------Total params: 28,615,970
Trainable params: 102,450
Non-trainable params: 28,513,520

我们只有 10 万个可训练参数，而整个网络有 2800 万个。有了这组减少的自由参数，我们可以在自定义数据上训练最后一层，而特征提取层使用来自 imageNet 的权重。

训练模型后，我们可能会看到以下结果:

训练数据集的损失(蓝色)看起来不错，但是测试数据的损失(橙色)看起来很奇怪。通常，这种损耗曲线是过度拟合的指标。

模型精度也是如此。虽然训练数据的准确性看起来还可以，但是测试的准确性却完全不行。

批量标准化的怪异之处

这种怪异的行为来自 BatchNormalization 层。好像有个 bug ，在使用 keras (2.2.4)和 tensorflow 1.x 的时候，问题好像是冻结的批量归一化层确实也冻结了归一化参数。(点击阅读更多关于不同标准化层的信息)。要解决这个问题，我们可以使 BatchNormalization 层可训练:

for layer in base_model.layers:
    if isinstance(layer, BatchNormalization):
        layer.trainable = True
    else:
        layer.trainable = False

不幸的是，我们失去了使用更大 batch_size 的能力，当我们使 BatchNormaliation 可训练时，keras 似乎需要更多的内存来存储模型。

或者，我们可以忽略上面的奇怪分数，因为我们的层仍在学习，正如我们在训练损失/准确性中看到的，随后我们以 BatchNormalization 可训练的方式训练整个网络。然而，以下是 BN 可训练时模型的得分:

训练数据集(蓝色)和测试数据(橙色)的损失现在看起来很完美。

还有准确性

当只训练最后一层时，我们仍然有好处。例如，我们有较少的可训练参数，这意味着更快的计算时间。在大型数据集上，我宁愿忽略验证分数，并通过完全冻结基本模型(包括 BN)来利用较大的 batch_size。

释放网络的全部能量

在训练过程中的某个点，模型没有进一步改进，是时候打开网络的其余部分来微调特征提取部分了。因此，我们使所有的层可训练，并再次适应模型。现在，我们有超过 2800 万个参数，训练需要更长的时间，但由于我们已经训练了最后一层，我们有一个更好的起点。

for layer in model.layers:
    layer.trainable = True
model.summary()
--------Total params: 28,615,970
Trainable params: 28,443,234
Non-trainable params: 172,736

注意:避免模型的早期过度拟合是很重要的，因为模型可能很难逃脱局部最小值，因此我们确保在全面训练之前和之后更好地打开网络。另外，不要忘记调整 batch_size，否则我们会运行 OOM。要估计模型所需的内存，请看这里( stackoverflow )。我也建议利用早停。

第二次调用 fit()后，我们得到了一个更好的模型:

第二训练阶段的损失仍然减少，因此模型得到改进

对于训练和测试数据，模型的准确性也提高了

最后，我们在自定义数据上训练了一个最先进的 efficientnet 模型。为了使这个模型生产就绪，还有一些工作要做。如果你对如何部署这样一个模型感兴趣，你可以查看这篇文章。

这篇文章最初发表在我的个人博客这里。

如何验证进化优化算法的正确性

原文：https://towardsdatascience.com/how-to-validate-the-correctness-of-an-evolutionary-optimization-algorithm-570c8b71b6d7?source=collection_archive---------36-----------------------

检查已实现的元启发式多目标优化算法的正确性和准确性的可能方法。

f = Y . * sin(X)-X . * cos(Y)的 3D 空间

目录

1. 简介
2. 正确性验证
3. 浅谈绩效考核
4. 结论
5. 参考文献
6. 一些相关的中帖

1.介绍

进化和元启发式优化算法被认为是人工智能(AI)的子集。这些算法试图模仿自然机制并解决优化问题。例如，遗传算法(GA)使用受启发的生物机制，如繁殖、交叉、选择、突变和重组，来寻找优化问题的最佳解决方案。另一个例子是帝国主义竞争算法(ICA ),在这种算法中，统治、革命和殖民化等社会机制被用来寻找解决方案[1]。进化算法通常在复杂的优化问题中表现良好，而使用经典方法在数学上是困难的。他们可以轻松处理非线性问题，而不会陷入局部极小值。

为了用进化优化算法优化一个问题，可以使用认证的工具箱。然而，对于某些算法，要么没有可用的认证工具箱，要么可能更喜欢用任何编程语言来实现他/她自己的代码。在这种情况下，最重要的问题是——我们如何信任编写的代码？我们如何验证我们实现的进化或元启发式代码的正确性？

在这篇文章中，一些现有的检查和验证已实现的进化优化算法的正确性的方法已经得到了简要的阐述。此外，使用 Ackley 函数的例子，讨论优化算法的性能评估。

2。正确性验证

有不同的方法来检查所实现的元启发式多目标优化算法(例如，遗传算法(GA)或差分进化(DE))的正确性和准确性。下面的方法可以简单地用来检查所实现的优化算法的正确性:

A) **与经典方法的比较:**在一些问题中，可以同时运行经典方法和多变量遗传算法，以确保结果正确和准确。然而，在大多数情况下，由于数学的复杂性，使用经典方法进行比较是不可能的。

B) **使用众所周知的基准:**代码的正确性也可以通过现有的基准来证明。所使用的算法可以通过众所周知的基准进行验证[2–6]。

C) **使用专家思想:**系统的专家可以检查结果及其合理性。他们应该都同意最后的结果是合乎逻辑的。如果一个问题需要精确的最小成本值，那么使用专家的想法是没有说服力的。

D) **收敛性:**通过成本与迭代的关系图，可以容易地观察到所实现的多目标遗传算法的收敛性。还有其他因素，如舍入误差和局部极值，也有相同的观点。

[7]中的收敛图示例(适应度与迭代次数)

E) **支配因子:**NSGA-II、NSGA-III、MOPSO 等新一代优化算法通常具有将支配结果与非支配结果分离的功能。因此，所有的最终结果都应该是占优势的，并且有了适当的初始种群，很少会陷入局部极小值。然而，不能保证他们找到系统的全局最小值。有关支配的更多信息，请查看[8]。

3。浅谈绩效评估

下图显示了 Ackley 函数，其中 a 等于 20， b 等于 0.2， c 等于 2【9】。这个函数是用于进化或元启发式优化的众所周知的基准之一。它有一个唯一的全局最小值和几个局部最小值。

a = 20，b = 0.2，c = 2 的阿克利函数。

使用下面的 MATLAB 代码可以很容易地生成上图:

通过将 b 的值增加到 1000，可以得到下图。正如在这个函数中可以看到的，有许多局部最小值和一个狭窄的唯一全局最小值。

a = 20，b = 1000，c = 2 的阿克利函数。

也可以使 c 等于零，并移除所有局部最小值。然后可以得到下图。作为全局最小值的具有窄而深的孔的平面。在这种情况下，适应度与迭代次数的关系图是没有用的。

a = 20，b = 1000，c = 0 的阿克利函数。

为了了解优化算法的性能，让我们简化这个问题。首先，我们可以离散化区域。假设 X 和 Y 的范围为-5 到 5，步长为 1，点 x = 0，y = 0 是全局最小值。所以，X 和 y 会有 121 种可能的组合，随机找到最优值的概率应该是 1/121。在最坏的情况下，找到最优值的概率是多少？

答案应该是新生成值的总数(考虑所有算法部分，如初始种群、变异、交叉、重组等)。)除以输入(基因)的总可能组合。在这种情况下，只有新生成值的数量和离散化的精度才能提高性能。下面的表达式可以用作这个例子的误差概率。

上述表达式不仅可用作最坏情况下的误差概率上限，还可用于任何其他情况。该表达式还可以证明，当离散化中的步长足够小时(N → ∞),并且迭代次数是无限的(需要巨大的计算能力),那么误差概率应该为零。

应该注意的是，给出最坏的情况是因为问题的本质很容易被绕过或减少进化算法中策略的影响。换句话说，在这个例子中，进化优化算法的策略对性能和准确性的影响很小。

寻找进化优化的性能和准确性仍然是一个没有答案的研究问题。在许多情况下，算法的策略会影响性能。例如，Arnold，D. V .等人[10]提出了一种方法来测量步长对进化优化算法输出性能的影响。但这项研究不能被视为进化优化算法的准确性和性能评估的一般解决方案。

4。结论

与迭代次数、初始群体和内部函数评估相关的计算工作，这些可能与元启发式算法的性能或准确性相关。因此，计算优化算法的大 O 是有用的。

问题维度包括目标的数量、约束、输入基因的范围和数量以及优化算法的结构可以与性能相关[11]。

进化优化算法的正确性可以通过不同的方法来验证，概括如下:

检查进化或元启发式算法正确性的可能方法

5.参考

[1]阿塔什帕斯-加尔加里等人和卢卡斯等人(2007 年)。帝国主义竞争算法:一种受帝国主义竞争启发的优化算法。在 IEEE 进化计算大会(第 4661-4667 页)。

[2]姚，谢，刘，杨，林等(1999).进化编程变得更快。进化计算汇刊，3(2)，82–102。

[3]迪加拉基斯和玛格丽特(2001 年)。关于遗传算法的基准函数。国际计算机数学杂志，77(4)，481–506。

[4]m .莫尔加和 c .斯穆特尼基(2005 年)。优化需求的测试函数。优化需求的测试函数，101。

[5]杨晓生(2010)。最优化中的测试问题。arXiv 预印本 arXiv:1008.0549。

[6]s .米尔贾利利和 a .刘易斯(2013 年)。二进制粒子群优化的 s 形和 V 形传递函数。群体和进化计算，9，1–14。

[7]陈，陈，杨，江，魏(2016)。基于遗传粒子群优化的甚高分辨率遥感影像目标变化检测特征选择。传感器、 16 (8)、1204。

[8] Elarbi，m .，Bechikh，s .，Gupta，a .，Said，L. B .，和 Ong，Y. S. (2017 年)。一种新的基于分解的多目标优化 NSGAⅱ。IEEE 系统、人和控制论汇刊:系统，48(7)，1191–1210。

[9]埃克利博士(2012 年)。基因爬山的联结主义机器(第 28 卷)。斯普林格科学&商业媒体。

[10]d . v . Arnold 和 h . g . Beyer(2004 年)。累积步长自适应进化优化的性能分析。 IEEE 自动控制汇刊， 49 (4)，617–622。

[11]网址:https://www . research gate . net/post/How _ to _ assesse _ the _ performance _ of _ an _ optimization _ algorithm

6.一些相关的中等职位

[## 揭开机器学习优化的神秘面纱

优化是机器学习算法配方中最重要的成分。它从定义开始…

towardsdatascience.com](/demystifying-optimizations-for-machine-learning-c6c6405d3eea) [## 了解 RMSprop —更快的神经网络学习

免责声明:我假定关于神经网络优化算法的基本知识。特别是关于 SGD 的知识…

towardsdatascience.com](/understanding-rmsprop-faster-neural-network-learning-62e116fcf29a) [## 自适应元启发式智能粒子(AMI-P)

AMI 粒子

towardsdatascience.com](/adaptive-meta-heuristically-intelligent-particle-ami-p-4badd123b3a2) [## 进化策略简介

在这篇文章中，我们将学习使用 Python 中的进化策略(es)来训练一个没有反向传播的神经网络…

towardsdatascience.com](/introduction-to-evolution-strategy-1b78b9d48385)

注: 写这篇文章的想法是在我们得到下面这篇文章的评论时开始的:

阿赫拉吉，杨，巴迭埃，a，赵，x，阿斯兰塞法特，k，肖，x，什图，s .，&马，X. (2020)。使用数字双胞胎对最新露点冷却器进行约束多目标进化优化。能量转换与管理、 211 、112772。https://doi.org/10.1016/j.enconman.2020.112772

如何对自然语言处理任务的数据帧中的文本进行矢量化——3 种简单的技术

原文：https://towardsdatascience.com/how-to-vectorize-text-in-dataframes-for-nlp-tasks-3-simple-techniques-82925a5600db?source=collection_archive---------6-----------------------

使用 Texthero、Gensim 和 Tensorflow 的简单代码示例

Justin Luebke 在 Unsplash 上的照片

今天就开始学习 NLP 吧！

你可能听说过自然语言处理(NLP)是十年来最具 T4 变革性的技术之一。现在是进入 NLP 的绝佳时机，因为新的库已经抽象掉了许多复杂性，允许用户通过很少的模型训练和很少的代码获得最先进的结果。

虽然计算机实际上很擅长寻找模式和总结文档，但它必须先将单词转换成数字，然后才能理解它们。不同于像我过去所做的那样在单词级别对文本进行矢量化，我将探索以下技术在句子、段落或文档级别对数据帧中的文本进行矢量化:

text hero:TF-IDF
Gensim:doc 2 vec
tensor flow 2:通用语句编码器 4

作为奖励，我也将使用 t-SNE 可视化矢量！完整代码朝向底部！

下载数据集

我将不再从我最喜欢的来源中收集数据，而是从游戏《魔法:聚会中寻找卡片。我几乎一生都在玩纸牌游戏，并在 90 年代中期大约在二年级的时候开始玩魔法:聚会(MTG) 。如果你有兴趣尝试一下，你可以在线免费玩！

魔法:聚会 法律

我很高兴发现所有卡片的免费数据集。要了解示例，请从MTGJSON.com下载 AllPrintings SQLITE 文件

MTGJSON 是一个开源项目，它将所有魔术编目:以可移植的格式收集卡片。

导入依赖项和数据

很容易将数据连接并加载到 dataframe 中，因为它已经是一个 sqlite 文件。按照三个步骤加载库、数据和数据框架！

1.导入 pandas 和 sqlite3 库
2。连接到 sqlite 文件
3。将数据加载到熊猫数据框架中。

#*Import dependencies*
import pandas as pd
import sqlite3*#Establish connection to sqlite database*
conn = sqlite3.connect("AllPrintings.sqlite")*#load the data into a pandas DataFrame*
df = pd.read_sql("select * from cards", conn)

注意，我使用 pandas read_sql 函数来生成一个使用原始 sql 的数据帧。我可以看到数据集中有 73 列和 54033 行。

我将减少列数和行数，因为我只关心不同的卡片。在游戏魔法:聚会中，有 5 种核心颜色:黑色、蓝色、绿色、红色和白色。

我将探索我最喜欢的颜色，绿色。

df = pd.read_sql("select distinct name, text, convertedManaCost, power, toughness, keywords from cards where borderColor ='black' and colorIdentity = 'G'", conn)

注意，我用 SELECT DISTINCT 开始 SQL 查询，以排除重复的卡。这是必要的，因为一些卡片多年来已经被重印了多套。

df.shape 返回数据帧的形状

删除重复项并将数据集限制为绿卡，这样我就有了 3085 行 6 列。

清理数据

为了清理数据并为矢量化做准备，我将使用 Texthero 库 ，因为它简化了数据帧中文本的清理。要应用默认的文本清理脚本，运行 hero.clean(pandas。系列)。

使用 clean() 时，默认运行以下七个功能:

1. fillna(s)用空格替换未赋值的值。
2. lowercase(s)小写所有文本。
3. remove_digits()去掉所有的数字块。
4. remove_punctuation()删除所有字符串.标点(！" #$% & '()*+，-。/:;< = >？@[]^_`{|}~).
5. remove_diacritics()去除琴弦上的所有重音。
6. 删除所有停用词。
7. remove_whitespace()删除单词之间的所有空格。

定制清洗管道

我将构建自己的管道，而不是使用默认的 clean 函数。使用我自己的管道，我可以保留尽可能多的卡片上下文以实现相似性:

import texthero as hero
from texthero import preprocessingcustom_pipeline = [preprocessing.fillna,
                   #preprocessing.lowercase,
                   preprocessing.remove_whitespace,
                   preprocessing.remove_diacritics
                   #preprocessing.remove_brackets
                  ]df['clean_text'] = hero.clean(df['text'], custom_pipeline)
df['clean_text'] = [n.replace('{','') for n in df['clean_text']]
df['clean_text'] = [n.replace('}','') for n in df['clean_text']]
df['clean_text'] = [n.replace('(','') for n in df['clean_text']]
df['clean_text'] = [n.replace(')','') for n in df['clean_text']]

注意我用了 fillna ，因为有些卡片没有文字。
注意我决定从管道中排除移除括号。这是因为 Texthero 也会删除括号中的数据！

熊猫数据帧的前两行

使用 TF-IDF 生成矢量

TF-IDF 代表词频-逆文档频。是一种经典的对单词值进行加权而不是简单计数的方法。它用于确定一个单词对集合文档中的文本有多重要。

TF-IDF 是文本的一个词包(BoW) 表示，描述文本语料库中词的出现。它不能解释单词的顺序。我将在下一节详细讨论这些限制…

TextHero 使得将 TF-IDF 应用到 dataframe 中的文本变得很容易。

df['tfidf'] = (hero.tfidf(df['clean_text'], max_features=3000))

将值添加到 dataframe 实际上只有一行代码！我建议探索不同数量的 max_features ，看看它如何影响向量。

df.head(2)显示 dataframe 中新的 tfidf 列

TF-IDF 生成一个稀疏矩阵，其中包含许多 0，因为卡片上有各种各样的单词。

使用 Doc2Vec 生成矢量

虽然 TF-IDF 是使用经典矢量化技术建立基线的良好起点，但它有很大的局限性。由于它是一个单词包表示法，所以它没有保持单词的顺序，也没有说明太多的语义。作为稀疏矩阵，它也可能是资源密集型的。

Word2Vec 革命

为了解决语义关系和稀疏矩阵的问题，创建了像 Word2Vec 这样的模型。以前我写过关于使用 Gensim 库在文本数据上应用 Word2Vec 模型的文章。

[## 用 Python 实现自然语言处理中单词嵌入的简单方法

使用 Gensim 和 Plotly 探索单词嵌入

towardsdatascience.com](/the-simple-approach-to-word-embedding-for-natural-language-processing-using-python-ae028c8dbfd2)

Word2Vec 模型为每个单词生成向量，但是为了计算整个文档的向量，我可以对文档中每个单词的向量进行平均。相反，我会使用更简单的路线: Doc2Vec 。

使用 Doc2Vec

2014 年推出的 Doc2Vec 是一款表示 文档 s，段落或句子作为 向量 。Doc2Vec 通常优于 Word2Vec 向量的简单平均，因此值得探索！

在基本层面上，Doc2Vec 算法为文档提供了另一个类似浮动单词的向量，称为 doc-vector。它有助于所有的训练预测，并像其他词向量一样被更新。查看乐和米科洛夫的全文，了解技术方面的内容。

Doc2Vec 需要训练。为了训练模型，标签/编号需要与训练的每个文档相关联。使用 doc2vec 可以轻松完成标记。标签文档()。

from gensim.models.doc2vec import Doc2Vec, TaggedDocument*#tokenize and tag the card text*
card_docs = [TaggedDocument(doc.split(' '), [i]) 
             for i, doc in enumerate(df.clean_text)]#display the tagged docs
card_docs

注意，我使用做了简单的标记化。拆分(’ ')在清洗过的卡片文字上。

标记和令牌化的卡文本

接下来，实例化一个 Doc2Vec 模型。

设置向量大小以确定将包括多少个维度。设置训练时期以确定它将迭代训练数据的次数。

model = Doc2Vec(vector_size=64, min_count=1, epochs = 20)

当设置纪元时，考虑高的数字倾向于达到递减的回报。试验超参数！查看文档，获取所有模型参数的完整列表。

在实例化模型后构建一个词汇表，然后训练模型。

*#instantiate model*
model = Doc2Vec(vector_size=64, window=2, min_count=1, workers=8, epochs = 40)*#build vocab*
model.build_vocab(card_docs)*#train model*
model.train(card_docs, total_examples=model.corpus_count
            , epochs=model.epochs)

构建词汇表创建了一个字典(可通过model.wv.vocab访问),包含从训练中提取的所有独特单词以及计数。

现在模型已经训练好了，使用 model.infer_vector 将标记化的文本传递给模型以生成向量。

*#generate vectors*
card2vec = [model.infer_vector((df['clean_text'][i].split(' '))) 
            for i in range(0,len(df['clean_text']))]card2vec

矢量化卡片文本

注意数据输出为 numpy 数组。要将向量添加到数据帧中，使用 numpy.array()。【tolist().这将把它们保存为列表列表。然后，它们可以作为一列添加到数据帧中。

import numpy as np*#Create a list of lists*
dtv= np.array(card2vec).tolist()*#set list to dataframe column*
df['card2vec'] = dtvdf.head(2)

带有 Doc2Vec 向量的数据帧

注意 card2vec 列包含 Doc2Vec 向量。将向量添加到数据帧是存储它们的一种便捷方式。

虽然 Doc2Vec 方法只用了几行代码就完成了，而不是训练一个 Doc2Vec 模型，但是有一些预训练的选项甚至需要更少的代码！

使用通用语句编码器生成向量

比使用 Doc2Vec 更简单的是，托管在 Tensorflow-hub (tfhub)上的通用句子编码器 (USE)是一个预先训练好的模型，它将文本编码成 512 维向量。它在各种各样的文本资源上被训练。

通用句子编码器将文本编码成高维向量，这些向量可用于文本分类、语义相似性、聚类和其他自然语言任务。— 文档

使用模型的最新迭代使用 TensorFlow2。我过去曾使用 Tensorflow 1 模型来生成葡萄酒推荐，这些新模型使用起来更简单，应用起来也更快。

模型需要从 tfhub 下载。

!pip install --upgrade tensorflow_hubimport tensorflow_hub as hub*#download the model*
embed = hub.load("[https://tfhub.dev/google/universal-sentence-encoder-large/5](https://tfhub.dev/google/universal-sentence-encoder-large/5)")

接下来，通过模型运行 cleaned_text 来生成向量。使用 Doc2Vec 示例中的相同技术，将 numpy 数组中的向量转换为 list 列表。

由此，很容易将向量添加到数据帧中。就是这么简单！

*#generate embeddings*
embeddings = embed(df['clean_text'])*#create list from np arrays*
use= np.array(embeddings).tolist()*#add lists as dataframe column*
df['use'] = use*#check dataframe*
df.head(2)

通用句子编码器向量

恭喜你！您刚刚学习了 3 种快速简单的方法来矢量化数据帧中大于单词长度的文本！

可视化矢量

既然我费了这么大的劲来生成向量，我还不如探索一下！使用 Texthero 库，很容易应用 t-SNE 算法来降低向量的维度，并在 2D 空间中可视化它们。

t-SNE(t-distributed random neighbor embedding)是一种用于可视化高维数据的机器学习算法。t-SNE 技术应用了非线性维度缩减。

df['tsnetfidf'] = hero.tsne(df['tfidf'])
df['tsnec2v'] = hero.tsne(df['card2vec'])
df['tsneuse'] = hero.tsne(df['use'])

算法很复杂，可能需要一点时间才能完成！

显示 t-SNE 结果的数据框

接下来，使用 Texthero 构建 t-sne 列的散点图。Texthero 在引擎盖下使用 Plotly，因此图形是交互式的。

*#create scatter plot of tfidf*
hero.scatterplot(df, col='tsnetfidf', color='convertedManaCost'
                 , title="TF-IDF", hover_data = ['name','text'])*#create scatter plot of doc2vec*
hero.scatterplot(df, col='tsnec2v', color='convertedManaCost'
                 , title="Doc2Vec", hover_data = ['name','text'])*#create scatter plot of uni. sent. enc.*
hero.scatterplot(df, col='tsneuse', color='convertedManaCost'
                 , title="U.S.E", hover_data = 'name','text'])

注意我将 hover_data 设置为 name 和 text 。将鼠标悬停在某个点上将显示卡片名称和卡片文本。这样就很容易比较各种技术如何将相似的卡片聚集在一起。

文本向量散点图

每种技术产生不同的情节，但是把相似的卡片聚集在一起。举例来说，我发现有践踏，或加+1/+1，或横置以加魔法力的牌丛。

最后的想法和完整的代码

自然语言处理可能是一个复杂的话题，但是这些技术应该给你一个跳板，让你可以更深入地研究这个领域。我介绍了三种在段落、句子或文档级别对文本进行矢量化的简单方法:

text hero:TF-IDF
Gensim:doc 2 vec
tensor flow 2:通用语句编码器 4

从文本创建向量为机器学习任务做准备，如文本分类、语义相似性和聚类。在我的其他文章中了解关于自然语言处理和数据科学的更多信息:

** [## 如何使用 Python 和 Dash 创建控制股市的仪表板

自由期权订单流、价格、基本面、聊天集于一身

medium.com](https://medium.com/swlh/how-to-create-a-dashboard-to-dominate-the-stock-market-using-python-and-dash-c35a12108c93) [## 使用 Python 学习自然语言处理的 3 个超级简单的项目

单词云、垃圾邮件检测和情感分析的简单代码示例

towardsdatascience.com](/3-super-simple-projects-to-learn-natural-language-processing-using-python-8ef74c757cd9)

完全码

这里是完整的代码或在我的 github 上找到它！

[## bendgame/Medium_doc2vec

GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…

github.com](https://github.com/bendgame/Medium_doc2vec)

#Import dependencies
import pandas as pd
import sqlite3
import texthero as hero
from texthero import preprocessing
from gensim.models.doc2vec import Doc2Vec, TaggedDocument
import numpy as np
import tensorflow_hub as hub#Establish connection to sqlite database
conn = sqlite3.connect("AllPrintings.sqlite")
#load the data into a pandas DataFrame
df = pd.read_sql("select * from cards", conn)df = pd.read_sql("select distinct name, text, convertedManaCost, power, toughness, keywords from cards where borderColor ='black' and colorIdentity = 'G'", conn)custom_pipeline = [preprocessing.fillna,
                   #preprocessing.lowercase,
                   preprocessing.remove_whitespace,
                   preprocessing.remove_diacritics
                   #preprocessing.remove_brackets
                  ]
df['clean_text'] = hero.clean(df['text'], custom_pipeline)
df['clean_text'] = [n.replace('{','') for n in df['clean_text']]
df['clean_text'] = [n.replace('}','') for n in df['clean_text']]
df['clean_text'] = [n.replace('(','') for n in df['clean_text']]
df['clean_text'] = [n.replace(')','') for n in df['clean_text']]df['tfidf'] = (hero.tfidf(df['clean_text'], max_features=3000))#tokenize and tag the card text
card_docs = [TaggedDocument(doc.split(' '), [i]) 
             for i, doc in enumerate(df.clean_text)]
card_docsmodel = Doc2Vec(vector_size=64, min_count=1, epochs = 20)#instantiate model
model = Doc2Vec(vector_size=64, window=2, min_count=1, workers=8, epochs = 40)#build vocab
model.build_vocab(card_docs)#train model
model.train(card_docs, total_examples=model.corpus_count
            , epochs=model.epochs)#generate vectors
card2vec = [model.infer_vector((df['clean_text'][i].split(' '))) 
            for i in range(0,len(df['clean_text']))]
card2vec#Create a list of lists
dtv= np.array(card2vec).tolist()#set list to dataframe column
df['card2vec'] = dtvdf.head(2)#download the model
embed = hub.load("[https://tfhub.dev/google/universal-sentence-encoder-large/5](https://tfhub.dev/google/universal-sentence-encoder-large/5)")#generate embeddings
embeddings = embed(df['clean_text'])#create list from np arrays
use= np.array(embeddings).tolist()#add lists as dataframe column
df['use'] = [v for v in use]#check dataframe
df.head(2)df['tsnetfidf'] = hero.tsne(df['tfidf'])
df['tsnec2v'] = hero.tsne(df['card2vec'])
df['tsneuse'] = hero.tsne(df['use'])#create scatter plot of tfidf
hero.scatterplot(df, col='tsnetfidf', color='convertedManaCost'
                 , title="TF-IDF", hover_data = ['name','text'])
#create scatter plot of doc2vec
hero.scatterplot(df, col='tsnec2v', color='convertedManaCost'
                 , title="Doc2Vec", hover_data = ['name','text'])
#create scatter plot of uni. sent. enc.
hero.scatterplot(df, col='tsneuse', color='convertedManaCost'
                 , title="U.S.E", hover_data = 'name','text'])

[## 使用这些查询优化技巧成为 SQL 向导

如何对 SQL Server 查询进行性能优化

medium.com](https://medium.com/swlh/become-a-sql-wizard-using-these-query-optimization-tips-a932d18c762f)

谢谢大家！

• 如果你喜欢这个， 在 Medium 上关注我 获取更多
• 通过订阅 获得对我的内容的完全访问和帮助支持
• 我们来连线一下LinkedIn
• 用 Python 分析数据？查看我的 网站

—埃里克·克莱本**

如何使用 Q-Q 图验证数据的分布？

原文：https://towardsdatascience.com/how-to-verify-the-distribution-of-data-using-q-q-plots-acdb7ca2d576?source=collection_archive---------13-----------------------

艾萨克·史密斯在 Unsplash 上拍摄的照片

统计数字

理解 Q-Q 图并在 Python 中实现它

Q-Q 图，或分位数-分位数图，是一种验证任何随机变量(如正态、指数、对数正态等)分布的图形方法。这是一种观察任何分布性质的统计方法。

例如，如果给定一个分布，需要验证它是否是正态分布，我们运行统计分析，并将未知分布与已知正态分布进行比较。然后通过观察 Q-Q 图的结果，就可以确认给定的分布是否正态分布。

绘制 Q-Q 图的步骤:

1. 给定一个未知的随机变量。
2. 找到每个整数百分位值或 100 个 z 值。
3. 生成一个已知的随机分布，并对该分布执行步骤 1–2。
4. 绘制 Q-Q 图

给定一个随机分布，需要验证它是否是正态/高斯分布。为了便于理解，我们将这个未知分布命名为 X、，已知的正态分布命名为 Y.

生成未知分布 X:

X = np.random.normal(loc=50, scale=25, size=1000)

我们正在生成具有 1000 个值的正态分布，平均值=50，标准差=25。

(图片由作者提供)，X 的前 20 个随机值

查找 100%的值:

X_100 = []
for i in range(1,101):
    X_100.append(np.percentile(X, i))

计算每个整数百分位数(1%，2%，3%，。。。，99%，100%)X 随机分布的值并存储在 X_100 中。

(图片由作者提供)**，左:**X 的分布，**右:**X _ 100 的分布

生成已知的随机分布 Y 及其百分位值:

Y = np.random.normal(loc=0, scale=1, size=1000)

生成具有 1000 个值的正态分布，平均值=0，标准偏差=1，这些值需要与未知分布 X 进行比较，以验证 X 分布是否正态分布。

Y_100 = []
for i in range(101):
    Y_100.append(np.percentile(Y, i))

计算每个整数百分位数(1%，2%，3%，。。。，99%，100%)的值，并将其存储在 Y_100 中。

绘图:

为上面获得的未知分布到正态分布的 100%值绘制散点图。

(图片由作者提供)， Q-Q 剧情

这里 X-是与 Y-正态分布相比较的未知分布。

对于 Q-Q 图，如果图中的分散点位于一条直线上，那么两个随机变量具有相同的分布，否则它们具有不同的分布。

从上面的 Q-Q 图，可以观察到 X 是正态分布的。

如果两个分布不一样呢？

如果 X 不是正态分布，它有一些其他的分布，那么如果 Q-Q 图绘制在 X 和正态分布之间，分散点将不会位于一条直线上。

(图片由作者提供)， Q-Q 剧情

这里，X 分布是对数正态分布，与正态分布相比，因此 Q-Q 图中的散点不在一条直线上。

让我们有更多的观察:

这是 X 和 Y 分布的 4 种不同条件下的 4 个 Q-Q 图。

(图片由作者提供)，**左上:**对数正态分布与正态分布的 QQ 图，**右上:**正态分布与指数分布的 QQ 图，**左下:**指数分布与指数分布的 QQ 图，**右下:**logistic 分布与 logistic 分布的 QQ 图

实施:

(作者代码)

结论:

Q-Q 图可用于比较任何两个分布，也可用于通过与已知分布比较来验证未知分布。这种方法有一个主要的限制，即需要大量的数据点，因为推断较少的数据不是一个明智的决定。通过观察 Q-Q 图，可以预测两个分布是否相同。

感谢您的阅读

如何控制 Jupyter 笔记本的版本

原文：https://towardsdatascience.com/how-to-version-control-jupyter-notebooks-ccf0be144319?source=collection_archive---------14-----------------------

根据 Shutterstock.com 的许可使用图像

Jupyter 笔记本在许多方面都很棒，但使用它们进行协作并不容易。在这篇文章中，我们将看看你可以利用的所有工具，让笔记本与现代版本控制系统(如 git)很好地配合！

为什么 Jupyter 版本控制这么难？

软件世界已经将 git 作为版本控制工具的首选。Git 主要用于人类可读的文本文件。而 Jupyter 是一个丰富的 JSON 文档，它将源代码、markdown、HTML、图像都整合到一个。ipynb 文件。

Git 不能很好地处理像笔记本这样的富文档。例如，对于长嵌套 JSON 文档的 git 合并是不可能的，对于二进制图像字符串的 git diff 是可怕的(如下所示)。

对笔记本版本控制有什么要求？

这是我们从现代版本控制系统中需要的-

• 创建检查点/提交的能力
• 快速检查任何过去的笔记本版本
• 查看从一个版本到另一个版本的变化(笔记本电脑的视觉差异
• 多人可以在一个笔记本上工作，轻松解决合并冲突
• 能够就特定的笔记本电池提供反馈并提出问题

这是我们的愿望清单！这篇博客将向你介绍所有能帮助你实现这些目标的重要工具。

免责声明:我是下面列出的两个工具的作者(ReviewNB & GitPlus ),但这是对该领域所有有用工具的公正评论。

nbdime

nbdime 是一个用于本地区分和合并笔记本的开源库。您可以将其设置为与本地 git 客户端一起工作，以便git diff & git merge命令使用 nbdime。ipynb 文件。有了 nbdime，你可以—

• 在提交之前，运行git diff来查看笔记本发生了什么变化
• 轻松将远程更改与本地编辑的笔记本合并

JupyterLab Git 扩展

以下 JupyterLab 扩展对笔记本版本控制很有用。你可以在你本地的 JupyterLab 上安装这些。

• jupyterlab-git 可用于浏览 GitHub 库，查看已更改文件的视觉差异，并推送您的提交
• GitPlus 可用于直接从 JupyterLab UI 在 GitHub 上推送提交和创建拉取请求

AWS SageMaker

SageMaker 是 AWS 提供的托管服务，让您可以访问托管的 JupyterLab。它与 GitHub 存储库集成，因此您可以将您的公共/私有存储库克隆到 SageMaker 实例中。它使用了 jupyterlab-git 扩展，因此你可以将你的笔记本提交到 GitHub。

使用 SageMaker，您只需点击几下鼠标，就可以构建一个强大的 EC2 实例来训练您的模型。缺点是您总是使用昂贵的云计算，即使是那些可以在本地机器上轻松完成的任务，例如浏览数据、编辑笔记本。对于大多数人来说，本地 Jupyter 会话与稀疏 SageMaker 使用(当您真正需要强大的云计算时)的健康平衡是理想的。

谷歌联合实验室

另一个受欢迎的选择是谷歌 Colab。他们有体面的 GitHub 集成，你可以在 GitHub 库中打开一个特定的笔记本。您还可以将任何更改提交回存储库。

Colab 提供有限的免费 GPU，您可以升级到 Colab Pro 以获得更高的使用限制。一些限制是，

• Colab pro 是一个付费产品，但不提供任何 GPU 时间和类型方面的资源保证。
• 一切都以单个笔记本文件为中心，您不需要克隆整个存储库或访问本地文件系统。Colab 似乎建议使用 Google Drive 作为你的虚拟文件系统。这将影响训练的速度(通过网络调用获取数据文件，而不是在磁盘上本地获取)。

评论 NB

ReviewNB 是一个 GitHub 应用程序，显示任何笔记本提交或拉取请求的视觉差异。您可以在特定的笔记本单元格上写下评论，以便向您的队友提供反馈或提出问题。

它对开源库是免费的，但对私有库需要付费计划。ReviewNB 应用程序已通过 GitHub &验证，获准在 GitHub marketplace 上销售。

结论

当谈到 Jupyter 笔记本版本控制和协作时，没有一个工具适合所有情况。但是，您的团队可以利用以下专门构建的工具来创建可靠的笔记本工作流-

• GitHub 存储笔记本
• git 命令的 jupyterlab-git 扩展&丰富的本地差异
• GitPlus 扩展创建拉取请求
• 笔记本代码评审
• 如果您需要在大型云实例上运行笔记本电脑，请使用 AWS SageMaker

暂时就这样吧！黑客快乐！

原载于 2020 年 8 月 27 日 https://blog.reviewnb.com。

如何使用 Matplotlib 可视化悉尼的温度变化

原文：https://towardsdatascience.com/how-to-visualise-sydneys-temperature-change-from-1859-to-2019-using-matplotlib-79b2dc7308c2?source=collection_archive---------31-----------------------

matplotlib 的动画情节

制作动画情节的详细指南

我相信你读过的主要时事之一一定是澳大利亚森林大火危机。这场毁灭性的灾难影响了超过 1000 万公顷的土地，这与葡萄牙的土地面积相当，估计有 10 亿只野生哺乳动物、鸟类和爬行动物被杀害(来源此处)。越来越多的证据表明气候变化/全球变暖与今年的森林大火之间的联系，例如极端温度(高于平均温度 1.5 摄氏度)和长期干旱(来源此处)。孤立地阅读这些数字，你可能看不到气候变化是如何随着时间的推移而演变的。从数据可视化的角度来看，使用时间序列图可能更有吸引力和信息量，而不是使用单个值来描述变化范围，时间序列图可以显示变量在大范围时间段内的动态趋势。因此，我借此机会利用悉尼的长期气温数据在matplotlib中练习ax.xxx()方法。如果你想知道matplotlib中的ax.xxx()方法是什么，请看一下我的上一篇帖子。这将有助于你理解这个职位，并进一步了解matplotlib。

在这篇文章中，我将向你展示我是如何制作悉尼 160 年间年最高气温的动画时间序列图(如本文开头所示)的。在我们深入研究代码之前，这里有一些要点:

1. 1920 年前后，年最高气温超过 40°C 的年数从 13%增加到 30%。
2. 悉尼有史以来最高的日最高气温是 2013 年的 45.8 摄氏度。
3. 在 1920 年前后，经历长时间高温天气(定义为一年中日最高温度超过 30°C 的总天数)的几率分别为 12%和 24%。
4. 2019 年，与所有其他有记录的年份相比，我们经历了最多的高温日数(34 天)。

情节的结构和主题

图 1，静态版本

作为一个独立的图形(图 1)，它至少应该包含三个部分，即标题、情节和脚注。前两部分很容易理解。至于脚注，通常用来表示该图的数据来源和特别说明。

剧情无疑是整个人物最重要的部分。在这种情况下，我用两个不同的 y 轴分别表示温度和日，它们共用同一个 x 轴，即年。 matplotlib提供了创建双轴:ax.twinx() / ax.twiny()的简单方法。具体来说，ax.twinx()创建一个新的axes，它与ax共享 x 轴，但可以有不同的 y 轴。同样，ax.twiny()返回一个共享 y 轴的axes，但是使用不同的 x 轴。在构建了人物框架后，我设置了一个未来色彩主题，灵感来自 Tron Legancy 。在matplotlib中，我们可以通过plt.rc()轻松配置体形样式。rc代表 C 启动时自动 R un 的配置文件。

使用 plt.rc()的 Tron 主题

创建用于静态绘图的函数

我们来看看matplotlib中创建动画剧情的 lite 函数。

animation.FuncAnimation(*fig*, *func*, *frames=None*)

从本质上来说，动画fig只是func用不同的值(frames)获得的静态axes的集合。这非常像动画书动画。以我为例，axes(从 1859 年到 2019 年，即range(1859, 2020, 1))总共有 160 帧。解决了这个问题后，我创建了一个可以普遍应用于不同year值的函数。

这个函数的原理是一层一层的绘制元素(或者我也可以说是matplotlib绘图中的原理)。我来一节一节的解释一下上面的函数。

• ax.clear()和ax2.clear()，之前的axes应该在绘制新的之前被擦除，否则axes中的旧内容仍会留在fig上并记录在动画中。这也是为什么我没有把fig, ax = plt.subplots(figsize=(12,4), dpi=300)和ax2 = ax.twinx()包含在函数体中，而是在animation.FuncAnimation()之前分别调用。绘图空间(即fig、ax、ax2)只需设置一次，就像一个可重复使用的白板。
• df_tmp=df_sydney.loc[df_sydney[‘Year’] <= Num_Year]，标绘输入应为数据。新的axes应该包含当前年度及其所有以前年度的数据(即<=)。因此，当animation.FuncAnimation在任一给定年份使用Num_Year调用draw_linechart时，静态图中的线应该从开始(即 1859 年)跨越到被调用的年份(图 2)。

图 2，一个静态图形

• ax.plot(df_sydney.Year, df_sydney.max_tmp_year*0, label=’_1', color=’#222222', zorder=1)，这是第一行剧情。注意，这里使用的数据不是df_tmp而是完整的数据帧df_sydney。本节将为每个df_tmp的axes创建一个从起始年(1859)到结束年(2020)的框架。这保证了每个axes的 x 轴具有相同的年份范围(即 1860–2020)，而不是随着df_tmp的年份范围(即 1860- Num_Year)而变化。此外，我只需要框架和线应该隐藏这一层，所以我为 y 轴的每个值(df_sydney.max_tmp_year)计时 0。您可能会注意到分配给label的值包含一个下划线，这是为了防止该层被稍后的自动图例元素选择(ax.legend())显示。这里用的另一个自变量是zorder，可以认为是沿 z 轴的层序列，1 表示底层。
• 从ax.plot()到ax2.plot()，这些增加了两条水平线，方便观众估算每年最高气温和累计天数的数值。
• 从ax.plot()到ax.text()这是fig中绘制大部分元素(线条、头点、带头点的文字)的部分。这很容易理解。我唯一想再次强调的是ax.xxx()的威力，它让每个axes的操作变得足够简单。

设置好draw_linechart函数后，我们通过输入具体年份来画一个静态图。如果一切顺利，您将看到图 2。

# run one frame to test the function
fig, ax = plt.subplots(figsize=(12,4), dpi=300)
ax2 = ax.twinx()
draw_linechart(1987)

动画图形摘要

运行下面的代码将生成所有的帧并将它们分配给对象animator。然后这个对象就可以通过animator.save()保存成你想要的任何格式。我个人的偏好是另存为mp4。最后要注意的是fig背景颜色要用savefig_kwargs={‘facecolor’:’#222222'}指定，否则会保存为白色，与Tron legancy主题不一致。

import matplotlib.animation as animationfig, ax = plt.subplots(figsize=(12,4), dpi=300)
ax2 = ax.twinx()animator = animation.FuncAnimation(fig, draw_linechart, 
                                   frames=np.arange(df_sydney.Year.values.min(),df_sydney.Year.values.max(),1), interval=300)animator.save('./animation5.mp4', savefig_kwargs={'facecolor':'#222222'}) 

在这里，我从设计到代码演示了如何使用matplotlib创建一个动画图表，这有助于我们更好地理解悉尼 160 年来的温度变化。你可以从我的 Github 下载数据、动画、图表和 jupyter 笔记本。

和往常一样，我欢迎反馈、建设性的批评以及听到关于您的数据科学项目的信息。你可以在 Linkedin 上找到我，现在也可以在我的网站上找到我。