如何为 PyTorch 设置本地 AWS SageMaker 环境
声明:我是本教程中提到的booklet . ai的联合创始人。
作为一名黑客数据科学家，但基本上是合法的 web 开发人员，我对创建一个 ML 应用程序的过程感到沮丧(一个触发预测的简单 UI 和一个可公开访问的 API)。创建和迭代一个典型的 web 应用程序的流程感觉就像在一个春日沿着一条低流量、平缓弯曲的乡村道路行驶。ML 应用开发流程？就像学开手动挡的车一样。
为什么 ML 应用开发流程这么粗糙？一个重要原因:没有强调本地发展。我来举例说明。
我将向您展示如何为部署到 AWS Sagemaker 的 PyTorch 神经网络创建 ML 应用程序。🚀试试 Booklet.ai 上的 ML web app 。
所以您想将 PyTorch 模型部署到 AWS Sagemaker？
您已经构建了一个模型，现在您想要部署它。您偶然发现了 AWS Sagemaker 登录页面，并看到了这段文字:
一键部署？在几分钟内将新模型集成到您的应用中？你是数据科学家，不是 web 开发人员，为什么要花时间学习 web 技术呢？这听起来很棒——注册吧！
接下来，您搜索“使用 PyTorch 和 Amazon SageMaker ”,并意外发现您的用例:
完美！您点击链接，在 SageMaker SDK 文档中的部署来自模型数据的端点。只需两个函数调用，您就有了一个部署好的模型！
…但是接着疼痛开始了:
model_data文件格式是什么？您有一个模型文件，但是您也有一些预处理中需要的编码器。你是怎么装的？entry_point脚本是做什么的？文档的“从模型数据部署端点”一节没有对此进行描述。
哦好吧。你交叉手指，运行代码，部署，然后等待大约 10 分钟过程完成。接下来，您找到一些代码示例，这样您就可以调用invoke_endpoint()并触发一个预测。这失败了，CloudWatch 日志提到缺少model_fn()函数，所以您在文档中发现加载了一个模型。你试试这个然后部署。
…并等待 10 分钟。你叫invoke_endpoint()。这次input_fn()出现错误，好像和预处理有关。原始输入中有字符串 SageMaker 不喜欢这样吗？还是你在invoke_endpoint()发送了一个畸形的有效载荷？
您尝试一些东西，部署，然后…等待… 10 …分钟。
神圣的地狱。这有什么难的！嗯，我写了一些没用的蹩脚代码。当我在笔记本上训练 PyTorch 模型时，这不是问题，因为我可以快速修复我的错误。部署到 SageMaker 是一个不同的故事— 每一个小小的改变都需要漫长的等待。
您需要一个本地 SageMaker 环境
**当你写完这篇文章，那些在 SageMaker 上等待 10 分钟来验证新代码的工作将成为过去！**您将拥有一个在您的计算机上运行的本地 SageMaker 开发环境。您将拥有一个简单的脚本来部署对 Sagemaker 的更改。
PyTorch + SageMaker 示例
我们的起点是一个 PyTorch 文本分类神经网络我已经从优秀的用 ML 教训 GitHub repo 取得了分叉。我的 fork 添加了一个[deploy/sagemaker](https://github.com/itsderek23/lessons/tree/master/notebooks/03_APIs/pt-text-classification/deploy/sagemaker)目录，其中包含将模型部署到 local + production SageMaker 环境的逻辑。
这一课也是一个很好的起点，因为它展示了如何使用 FastAPI 为模型创建 RESTful API。您可以看到用 FastAPI 开发自己的 API 和利用 Sagemaker 之间的区别。
运行本教程的先决条件
- GitHub Repo —用 SageMaker 更新:
git clone [https://github.com/itsderek23/lessons.git](https://github.com/itsderek23/lessons.git.)克隆我用 ML Lessons repo 制作的分叉副本。 - amazonseagemakerfullcaccess IAM 角色 —使用amazonseagemakerfullcaccess策略创建角色。
- 项目设置 —遵循自述文件中的设置说明。
- 训练 PyTorch 型号——按照自述中的说明进行。
我引用的命令和文件假定当前目录如下:
亚马逊 SageMaker 本地模式是如何工作的？
除了在一篇介绍性博客文章中的一些线索之外，我还没有找到关于 SageMaker 本地模式应该如何配置以服务于本地 ML 模型的重点总结。AWS 官方博客文章的重点是培训，而不是托管已经构建好的 PyTorch 模型。这是我拼凑出来的。
SageMaker 本地模式需要三类变更:
- 预构建的 Docker 容器:在为您的 PyTorch 模型提供服务时，使用 SageMaker 在云中运行的相同的 Docker 容器。这给了你很高的信心，如果你的模型在本地工作，它也能在生产中工作。
- API 客户端的本地版本:通常情况下，你使用
botocore.client.SageMaker和botocore.client.SageMaker Runtime类来使用 Python 中的 SageMaker。为了在本地使用 SageMaker，我们将使用sagemaker.local.LocalSagemakerClient()和sagemaker.local.LocalSagemakerRuntimeClient()来代替。 - 函数参数改变:我们也改变了几个参数到
PyTorchModel()和pytorch_model.deploy()。这些变化如下。
Sagemaker 本地的 PyTorchModel()
从本地文件加载model_data。我们不需要上传model.tar.gz文件并从 S3 桶中加载它。这在测试新代码时要快得多。
用于 Sagemaker 本地的 pytorch_model.deploy()
将instance_type设置为local，而不是标准的 Sagemaker 实例类型(例如:ml.t2.medium)。
为了处理本地环境和生产环境之间的差异，我创建了一个 **DeployEnv** 类，它从 **deploy/sagemaker/config.yml** 加载特定于环境的设置。
介绍 DeployEnv 类
因为我们的本地环境需要一组分散的修改，所以我将这些更改封装到一个类中。这意味着我们不必让检查本地或生产环境的if语句污染我们的脚本。
让我们看看DeployEnv是如何工作的。
首先，如果没有指定环境，我们默认为 **local** 环境。这是你应该花费大部分时间的地方，因为这里的发展更快。
加载生产设置通过设置 **DEPLOY_ENV=production** 环境变量:
通过 **DeployEnv.client()** 和 **DeployEnv.runtime_client()** 为您的环境加载正确的 SageMaker API 客户端。
local环境 SageMaker 客户端:
production环境 SageMaker 客户端:
通过 **DeployEnv.setting()**访问特定环境设置。这些使用[deploy/sagemaker/config.yml](https://github.com/itsderek23/lessons/blob/master/notebooks/03_APIs/pt-text-classification/deploy/sagemaker/config.yml)作为底层数据存储。
例如，model_data_path在local环境中使用一个本地文件:
…在生产中:
既然我们可以访问特定于环境的设置，那么是时候编写与环境无关的部署脚本了。
SageMaker PyTorch 模型部署脚本
我想用相同的脚本将 PyTorch 模型部署到我的本地和生产环境中。
部署到本地环境:
本地部署需要多长时间？这是第一行和最后一行日志:
**23 秒！**或者，比部署到 AWS SageMaker 生产环境快 26 倍。这使得 ML 应用程序的迭代速度大大加快。注意，第一次本地部署将花费更长时间，因为 SageMaker 需要下载 PyTorch Docker 映像。
**部署到生产环境:**[**deploy/sagemaker/deploy.py**](https://github.com/itsderek23/lessons/blob/master/notebooks/03_APIs/pt-text-classification/deploy/sagemaker/deploy.py)如何处理两种环境？
我们只是使用上面的DeployEnv类。例如:
了解 Booklet.ai 的最新动态，并率先访问我们的测试版。
这个deploy/sagemaker/serve.py文件是什么？
在 Sagemaker 中加载和服务我们的 PyTorch 模型
SageMaker PyTorch 模型服务器允许我们配置模型如何加载和服务(前/后处理和预测流程)。这可能需要做一些工作来适应现有的模型(这就是创建本地环境的原因)。
[deploy/sagemaker/serve.py](https://github.com/itsderek23/lessons/blob/master/notebooks/03_APIs/pt-text-classification/deploy/sagemaker/serve.py)封装了加载和服务我们的文本分类神经网络模型的逻辑。下面是我如何调整model_fn、input_fn和predict_fn来适应现有的模型。
型号 _fn
model_fn 告诉 SageMaker 如何从磁盘加载模型。此功能是必需的。我猜 SageMaker 创建了一个加载模型的专用函数，这样模型只能在启动时加载，而不是在每次 API 调用时加载。从磁盘反序列化模型很慢。
然而，为了不重构这个应用程序现有的Predict类，我将model_fn设为空操作。Predict.predict()很好地封装了前/后处理、加载模型和预测。我更喜欢重复使用这个。如果这是一个频繁使用的 API，我会将模型加载转移到一个专用的调用，这样它只在启动时执行。
代码如下:
输入 _fn
SageMaker 使用一个专用函数input_fn来处理预处理数据。有一个默认的反序列化单个 JSON 列表的函数。然而，如果你仔细观察，你会发现文档提到列表被转换成了一个torch.Tensor，所以它不能处理string对象的列表(这就是我们所拥有的)。这是因为默认实现在我们的输入上调用torch.from_numpy()。from_numpy不喜欢串串。
以下是习俗input_fn:
重要:我想确认默认的 SageMaker PyTorch JSON 格式(单个 JSON 列表)，这样我就可以把模型钩到 Booklet.ai 里，免费得到一个 web app UI + public API。 Booklet.ai 期望 API 模式匹配默认值。此外，当我几天后忘记 API 模式时，我可能会回到 SageMaker SDK 文档。有通用格式真好。
预测 _fn
因为Predict.predict()已经做了我们需要的一切，我们只需要在一个定制的predict_fn函数中调用它。SageMarker 提供了一个默认的预测函数，它基本上执行model_fn().__call__()。但是，我决定不为这个概念验证加载model_fn()中的模型。
predict函数返回是什么？项目中实际上有一个predict.py脚本，我们可以执行它来从命令行调用模型。我们会得到相同的输出:
输出 _fn
我们只返回模型输出，而不是返回raw_input和preprocessed_input的键/值。我们可以用一个专用函数来处理这个过程:
测试 PyTorch SageMaker 端点
我想让验证端点在本地和生产环境中都能工作变得容易。介绍。
**test.py**脚本使用两个输入调用 SageMaker 端点: 下面是一些输出:
想要测试您的生产端点吗？你猜对了！只需使用DEPLOY_ENV=production:
回顾我们新的 SageMaker PyTorch 开发流程
下面是工作原理的总结(参见 GitHub 上的脚本):
- 特定环境设置 —将这些设置放入
deploy/sagemaker/config.yml - 展开 :
python deploy/sagemaker/deploy.py - 测试 :
python deploy/sagemaker/test.py - 加载和服务模型:参见
deploy/sagemaker/serve.py中定义的功能。
默认情况下，所有脚本都使用local环境。要使用production，设置DEPLOY_ENV=production环境变量。例如，要部署到生产环境中:
ML web app 呢？
我们可以通过 SageMaker SDK 调用模型，这很好，但是做同样事情的 web 应用程序不是更酷吗？
****你可以用 Flask、React、Docker 等等来构建一个网络应用。或者，您可以将booklet . ai与您的 AWS 帐户集成。事实上，我已经为这个 PyTorch 文本分类演示设置了一个 web 应用程序:
在 Booklet.ai 上试试这款 ML 车型的响应式 ui
已经可以访问 Booklet.ai？遵循我们的 SageMaker 集成说明。 还没有访问 Booklet.ai？在 Booklet.ai 报名提前获取。
摘要
通过使用 SageMaker 本地模式，我们将查看 ML 模型应用程序更改的时间从 10 分钟缩短到了 23 秒。我们可以轻松地在本地或生产中部署变更。我们已经添加了一个响应性的 web ui，通过 Booklet.ai 使用该模型，而无需构建一个定制的 Flask 应用程序。我们的 ML 应用程序开发流程现在顺畅多了！
在 GitHub 上查看本教程的源代码。
原载于 2020 年 4 月 2 日https://booklet . ai*。*
如何在 Linux 虚拟机上设置 Selenium
如何在 Linux 操作系统上安装 selenium 和 chromedriver 以运行无头抓取的分步指南
尼古拉斯·皮卡德在 Unsplash 上拍摄的照片
Selenium 是测试 web 应用程序的流行框架。您在这里可能是因为您已经在本地机器上编写并测试了您的 web 抓取/测试脚本。现在，你想知道…
“我如何每 X 小时/天/周自动运行我的 Selenium 脚本？”
因此，本指南将向您展示如何使用 Selenium 和 Chromedriver 设置一个 Linux 虚拟机(VM)来实现这一点。虽然你可以一直使用 Windows 操作系统，但是在本指南中，让我们把重点放在 Linux 操作系统上。
装置
要让 selenium 和 Chromedriver 在本地机器上运行，可以分为 3 个简单的步骤:
- 安装依赖项
- 安装 Chrome 二进制和 Chromedriver
- 安装 Selenium
第一步
每当你得到一台新的 Linux 机器，总是首先更新软件包。然后安装必要的依赖项。
第二步
为了让 Chromedriver 在 Linux 上运行，你必须安装 Chrome 二进制文件。
对于 Chromedriver 版本，这将取决于你的 Chrome 二进制版本。
第三步
最后，安装 Selenium。
还有…你都准备好了！
测试您的脚本
剩下要做的就是检查 Selenium 和 Chromedriver 是否安装正确，以及您是否能够运行使用 Selenium 的 python 脚本。
from selenium import webdriver
from selenium.webdriver.chrome.options import OptionsCHROMEDRIVER_PATH = '/usr/local/bin/chromedriver'
WINDOW_SIZE = "1920,1080"chrome_options = Options()
chrome_options.add_argument("--headless")
chrome_options.add_argument("--window-size=%s" % WINDOW_SIZE)
chrome_options.add_argument('--no-sandbox')driver = webdriver.Chrome(executable_path=CHROMEDRIVER_PATH,
chrome_options=chrome_options
)
driver.get("[https://www.google.com](https://www.google.com)")
print(driver.title)
driver.close()
如果它打印“Google”，这意味着你已经在一个 Linux VM 上成功运行了带有 Chromedriver 的 Selenium！
奖金
如果你正在寻找一个文档，你很幸运。希望这有所帮助！
如何用 Ngrok 用 3 行代码分享你的 Jupyter 笔记本
想象一下，让你的朋友在远程机器上使用你的本地 Jupyter 笔记本
动机
您是否曾经想要与您的朋友共享您的 Jupyter 笔记本以协作完成某个项目，但却发现没有协作按钮？你不能只是复制粘贴你的 Jupyter 笔记本的链接，因为它是在本地机器上运行的。你希望有一种方法，你可以给你的朋友发送一个链接，这样你们俩就可以在同一个笔记本上工作了。如果一个人在笔记本上做了更改，另一个人也会看到该更改。
Google Colab 中的共享按钮
Google Colab 允许你分享你的笔记本。Jupyter 笔记本的分享按钮在哪里？在从 Jupyter 笔记本转向 Google Colab 进行协作之前，你可以考虑另一种选择:用 ngrok 为你的 Jupyter 笔记本创建公共服务器。
Ngrok
ngrok 是什么？Ngrok 通过安全隧道将 NAT 和防火墙后面的本地服务器暴露给公共互联网。这意味着您可以将本地服务器提供给 web 服务器的端口。当您访问该 web 服务器时，您应该能够到达您指定的本地地址。在您的终端上使用 3 行代码，您将获得一个您的 Jupyter 笔记本的公共 URL，该 URL 可用于共享！
装置
从在这里安装 ngrok 开始。然后注册 ngrok 账号。注册后，你应该可以在这里获得你的隧道授权令牌。
将 authtoken 的代码复制并粘贴到终端。一旦您将带有 authtoken 的计算机链接到此帐户，您就不需要在将来重复此操作。
接下来，通过更改 Jupyter 笔记本的配置，允许远程访问 Jupyter 笔记本
jupyter notebook --generate-config
您将看到 Jupyter 笔记本配置文件的链接地址。在我的机器中，这个链接是/Users/khuyentran/.jupyter/jupyter_notebook_config.py。复制那个地址。然后运行下面的代码
echo "c.NotebookApp.allow_remote_access = True" >> ~/.jupyter/jupyter_notebook_config.py
为了更加安全，请为您的 Jupyter 笔记本设置密码
jupyter notebook password
然后告诉 ngrok 你的 jupyter 笔记本在哪个端口运行。如果您的端口是 8888。类型:
./ngrok http 8888
您应该会看到下面的结果
点击链接 http://b32b5f59.ngrok.io 访问您隧道的公共 URL。
就是这样！现在，您应该能够复制和粘贴您生成的链接，并与您的朋友和同事分享它！确保告诉他们您访问笔记本的密码。
结论
恭喜你！您已经学习了如何共享您的 Jupyter 笔记本，以及如何在不同的机器上使用它。需要注意的一点是，由于这个公共 web 服务器连接到您的本地机器，如果您在本地机器上终止服务器，您的隧道的公共 URL 也将被终止。所以，如果你想让 Jupyter 笔记本在另一台机器上运行，请确保你的服务器正在运行。
最后但同样重要的是。在您的终端上运行以下命令行:
say "Thank you for reading this article"
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以通过 LinkedIn 和 Twitter 与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
它们有相同的中位数和标准差，但它们是两个明显不同的数据集！
towardsdatascience.com](/how-to-turn-a-dinosaur-dataset-into-a-circle-dataset-with-the-same-statistics-64136c2e2ca0) [## 如何使用 HyperDash 远程监控和记录您的机器学习实验
培训需要很长时间才能完成，但你需要去洗手间休息一下…
towardsdatascience.com](/how-to-monitor-and-log-your-machine-learning-experiment-remotely-with-hyperdash-aa7106b15509) [## 如何用 Faker 创建假数据
您可以收集数据或创建自己的数据
towards data science . com https://towards data science . com/cy thon-a-speed-up-tool-for-your-python-function-9bab 64364 bfd](/how-to-create-fake-data-with-faker-a835e5b7a9d9) [## 如何在 10 分钟内为您的数据科学产品组合创建一个优雅的网站
你需要做的就是编辑
towardsdatascience.com](/how-to-create-an-elegant-website-for-your-data-science-portfolio-in-10-minutes-577f77d1f693) [## cy thon——Python 函数的加速工具
当调整你的算法得到小的改进时，你可能想用 Cython 获得额外的速度，一个…
towardsdatascience.com](/cython-a-speed-up-tool-for-your-python-function-9bab64364bfd)
如何在一行代码中跨不同环境共享 Python 对象
对设置环境与他人分享您的分析感到沮丧？以下是如何让它变得更简单
动机
你有没有想过在不同的脚本之间共享 Python 对象？或者在你和你的队友之间分享发现，这样每个人都可以工作在最新的结果上？你可能会遇到三个困难:
- 您的队友可能会部署与您的脚本不同的环境
- 由你的队友训练的模型每天都在变化。所以他们需要每天和你分享模型。
- 文件或模型很大。每次部署脚本时重新上传它们是很麻烦的。
如果你所需要做的就是像这样共享数据帧，不是更容易吗
import datapane as dpdf = dp.Blob.get('profile', owner='khuyentran1401').download_df()df
或者类似这样的分享你的模型？
import datapane as dppredictor = dp.Blob.get(*name*='predictor',*owner*='khuyentran1401').download_obj()X_TEST = [[10, 20, 30]]outcome = predictor.predict(*X*=X_TEST)
这时我们需要 Datapane 的 Blob API
什么是 Datapane 的 Blob？
Datapane 提供了一个 API 集合，使得与其他人共享 Python 分析变得容易。如果你还不知道 Datapane，我在这里写了一篇关于 Datapane 的文章。
[## Datapane 简介:构建交互式报表的 Python 库
创建精美报告并与您的团队分享分析结果的简单框架
towardsdatascience.com](/introduction-to-datapane-a-python-library-to-build-interactive-reports-4593fd3cb9c8)
除了用于创建报告和部署笔记本的 API(在另一篇博文中显示……等等), Datapane 还提供了用于其他常见用例的 API，例如共享 blob 和管理秘密。
为了说明 Blob 的使用，我使用了来自本文的一个机器学习模型的例子。假设您正在训练一个这样的模型，它在测试集上有很好的性能。
您希望将此模型发送给您的团队成员，以便他们可以使用您的模型来预测新的数据集。你怎么能这样做？
你可以建立一个 docker 环境，并把它发送给你的队友。但如果他们只是想快速测试你的模型，而不需要设置环境，datapane.Blob会是更好的选择。
如果您希望其他人访问它，请确保拥有visibily='PUBLIC'。现在其他人可以用你的 blob 写他们的代码了！
Outcome : [140.]
Coefficients : [1\. 2\. 3.]`
尝试运行相同的代码，看看是否可以访问和使用预测器！在复制和粘贴代码之前，请确保预先在 Datapane 上注册以获得令牌。然后使用您的令牌
datapane login — server=[https://datapane.com/](https://datapane.com/) — token=yourtoken登录终端
现在试试
dp.Blob.get(name='predictor', owner='khuyentran1401').download_obj()
看看您是否能够访问和使用预测器并产生与上面相同的结果！
如果您想在您的组织中私下共享您的 blob，请遵循相同的过程，但是将 blob 的可见性设置为ORG
我还能用 Blob 做什么？
除了上传 Python 对象，您还可以使用 blob 来上传 Pandas Dataframe，一个文件。
并从 blob 中获取数据帧、文件或对象
例如，在文章中，我写了我在搜集了超过 1k 个 Github 概要文件后的发现
[## 我收集了超过 1k 的顶级机器学习 Github 配置文件，这就是我的发现
从 Github 上的顶级机器学习档案中获得见解
towardsdatascience.com](/i-scraped-more-than-1k-top-machine-learning-github-profiles-and-this-is-what-i-found-1ab4fb0c0474)
为了让你访问我的数据集，我需要做的就是给你数据集的名称和我的数据面板的帐户。现在您已经准备好访问它了！
import datapane as dpdf = dp.Blob.get('profile', owner='khuyentran1401').download_df()df
当然，为了让您访问我的数据，我需要将 blob 的可见性设置为“PUBLIC”
可变的
像数据库密钥、密码或令牌这样的变量不应该嵌入到我们的代码中，尤其是当你的脚本对外界可见的时候。Datapane 的Variable对象为提供了一种安全可靠的方式来创建、存储和检索脚本所需的值。
例如，在这个脚本中，我使用了dp.Variable来存储我的 Github 令牌和我的用户名，这样当我在 GitHub 上共享我的代码时，我就不需要担心我的令牌被暴露了。
这个变量对我来说是完全保密的，除非我用visibility='PUBLIC'.指定每个人都可以访问它
如果另一个拥有不同账户的人想要访问我的github_token变量并指定我为所有者，他们将会得到一个错误
requests.exceptions.HTTPError: 403 Client Error: Forbidden for url
因为我在私有模式下使用变量。
另一个好处是:如果我碰巧在另一个脚本中重用了这个变量，我可以很容易地再次访问这个令牌，而不需要记住它是什么！
但是这不跟泡菜差不多吗？
对于那些熟悉 Python pickle 的人来说，您可能会看到 Datapane 的Blob和Variable的功能与 Python pickle 相似。是的，它们几乎是相似的，但是Blob和Variable与泡菜相比有 3 个主要的优点
- 有了
Blob,，其他人不需要为了得到相同的模型而建立与你相似的环境。例如，您可能在 Sagemaker 上训练一个模型，并希望在您的脚本中使用它。 - 您只需使用
upload上传更改，然后您的队友就可以使用get查看更改，而无需将 pickle 文件发送给他人。 - 您可能会在新版本中意外出错，并希望回到旧版本(即训练错误的数据)。你可以在
get的参数中用version =回到老版本
结论
恭喜你！您刚刚学习了如何使用 Datapane 的Blob和Variable来跨不同的脚本或不同的环境共享您的数据帧、文件、Python 对象和变量。
如果你的队友只需要一行代码就能看到你的结果，而不需要设置环境，他们会很高兴的。当你的队友可以像你一样访问相同的数据时，你会很高兴。
在这个 Github repo 中，您可以随意派生和使用本文的代码。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
您可以收集数据或创建自己的数据
towardsdatascience.com](/how-to-create-fake-data-with-faker-a835e5b7a9d9) [## 字典作为 If-Else 的替代
使用字典创建一个更清晰的 If-Else 函数代码
towardsdatascience.com](/dictionary-as-an-alternative-to-if-else-76fe57a1e4af) [## 如何使用 HyperDash 远程监控和记录您的机器学习实验
培训需要很长时间才能完成，但你需要去洗手间休息一下…
towardsdatascience.com](/how-to-monitor-and-log-your-machine-learning-experiment-remotely-with-hyperdash-aa7106b15509) [## 如何通过将自己置于合适的环境中来加速您的数据科学职业生涯
我感到增长数据科学技能停滞不前，直到我有了一个飞跃
towardsdatascience.com](/how-to-accelerate-your-data-science-career-by-putting-yourself-in-the-right-environment-8316f42a476c) [## 如何创建可重用的命令行
你能把你的多个有用的命令行打包成一个文件以便快速执行吗？
towardsdatascience.com](/how-to-create-reusable-command-line-f9a2bb356bc9)
如何显示熊猫数据框的所有列/行？
加:改变数据帧中数字的精度。
汉斯·雷尼尔斯在 Unsplash 拍摄的照片
(这个帖子的所有代码你可以在我的 github 里找到)
大家好！在我的熊猫提示系列文章(上一篇文章是关于分组提示的)之后，我将解释如何显示熊猫数据帧的所有列和行。除此之外，我将解释如何显示数据帧中列表中的所有值，并选择数据帧中数字的精度。所有东西都用同样的工具。
在本教程中，我使用的是从数据世界下载的前 250 个 IMDB 电影数据集。数据库有 250 行和 37 列
问题:熊猫截断信息
有时，我读取一个有许多行或列的数据帧，当我在 Jupyter 中显示时，这些行和列被隐藏(在红色框中突出显示):
movies = pd.read_csv("data/IMDB_Top250movies2_OMDB_Detailed.csv")
movies
一些行和列是隐藏的(红框)
我知道它们被隐藏起来是为了避免显示太多的信息。但是有时候我想看所有的列和行！那么，如何把它们都打印出来呢？
我们可以在熊猫身上玩选项参数。让我们看看。
选择
Pandas 有选项配置，您可以更改数据框的显示设置(等等)。
你所需要做的就是选择你的选项(用一个字符串名)并获取/设置/重置它的值。这些函数接受正则表达式模式，所以如果您传递一个子串，它将工作(除非匹配多个选项)。
列
display.max_columns 选项控制要打印的列数。它接收一个 int 或 None (打印所有列):
pd.set_option('display.max_columns', None)
movies.head()
这些列不再隐藏。Jupyter 创建一个滚动条
你也可以使用字符串 max_columns 代替 display.max_columns (记住它接受一个正则表达式):
pd.set_option('max_columns', None)
传递一个数字而不是无:
pd.set_option('max_columns', 2)
movies.head()
仅显示两列
要恢复默认值，您需要重置选项:
pd.reset_option(“max_columns”)
movies.head()
一些列再次被隐藏
列宽
您可以使用选项 max_colwidth 更改列宽。例如，图的列有许多字符，最初显示时被截断:
绘图列的某些文本被隐藏
您可以增加通过一个 int 的宽度(或设置为最大无通过):
pd.set_option(“max_colwidth”, None)
movies[[“Title”, “Plot”]].head()
将显示绘图列的全部文本
行
要更改行数，您需要更改 max_rows 选项。
pd.set_option("max_columns", 2) #Showing only two columnspd.set_option("max_rows", None)
movies
所有的行都被显示出来。Jupyter 折叠单元格并创建一个滚动条
与行相关，有两个设置: max_rows 和 min_rows 。当行数大于 max_rows 时，数据帧被截断，显示为 min_rows rows。
比如说。让我们再次打印电影数据帧以及默认值 max_rows 和 min_rows :
print("Default max_rows: {} and min_rows: {}".format(
pd.get_option("max_rows"), pd.get_option("min_rows")))movies
由于数据帧中的行数为 250(大于 max_rows 值 60)，因此显示 10 行( min_rows 值)，前 5 行和后 5 行。
如果我们将最小行数改为 2，它将只显示第一行和最后一行:
pd.set_option(“min_rows”, 2)
movies
仅显示两行，第一行和最后一行
如果我们使用值低于 max_rows 值(60)的 head 命令，所有的行都会被显示。例如，使用值为 20 的头:
movies.head(20)
显示所有 20 行，因为该值小于 max_rows (60)
项目顺序
如果项目序列(列表)包含许多字符，也会被截断:
#Create "my_list" column and put a list of 100 values in each row
movies[‘my_list’] = [[1]*100] * 250
movies.head()
改变这种行为的选项是 max_seq_items。但是我们也必须改变最大列宽。首先，更改 max_colwidth (列表将被截断):
pd.set_option(“max_colwidth”, None)
movies.head()
“我的列表”列已展开，但列表被截断
然后你改变最大序列项。
pd.set_option(“max_seq_item”, None)
movies.head()
显示列表的所有值
额外收获:数字的精确性
另一个有用的选项是使用精度选项设置浮点精度——小数点后的位数。
#adding more decimal places to imdbRating column
movies[‘imdbRating’] = movies[‘imdbRating’] + 0.11111
movies[[‘imdbRating’]].head()
有 5 个小数位的数字
pd.set_option(‘precision’, 2)movies[[‘imdbRating’]].head()
有两位小数的数字
来源:
- 选项和设置— pandas 1.0.1 文档
- https://stack overflow . com/questions/19124601/pretty-print-an-entire-pandas-series-data frame
- https://stack overflow . com/questions/52580111/how-do-I-set-the-column-width-when-using-pandas-data frame-to-html/52580495
谢谢，随时添加您的评论
IMDB top 250 中有一部巴西电影:上帝之城。很好看的电影=)
如何简单快捷地对熊猫数据帧进行操作
在这篇文章中，我将介绍并评估不同的 python 方法，以便在 pandas 中运行相同的函数并创建新的列。这些方法将在数值和非数值运算中进行检查。
Marc Sendra Martorell 在 Unsplash 上拍摄的照片
如果你以前有过足够大的数据集，你就会知道有时一个简单的操作需要很多时间。有很多方法可以使熊猫数据帧上的操作更快。你可以使用像 multiprocessing，modin[ray]，cuDF，Dask，Spark 这样的库来完成这项工作。此外，您可以修改您的算法，以更快地执行任务。但是在寻求一个困难的解决方案之前，让我们看看有没有简单的方法来获得更高的速度和节省一些时间！
至于我的数据集，我用的是T5 这个 T7 的一部分。它有两个数字列和一个文本列，由“HelpfulnessNumerator”列中的 0 和“ProfileName”列中的 NaN 组成。(数据集和所有笔记本都已经上传到了 这个 Github 资源库中。)
数值运算
我想在不改变主函数的情况下简单地检查不同的方法。数字部分的函数是一个除法函数。
**def** divide(t,h):
**if** h == 0:
**return** np.nan
**return** t/h
我在处理熊猫数据帧时学到的第一件事是 df.iterrows()
%%timeit
iterrows_divide = []
**for** index,row **in** df.iterrows():
Time = row['Time']
HelpfulnessNumerator = row['HelpfulnessNumerator']
iterrows_divide.append(divide(Time,HelpfulnessNumerator))
5min 12s ± 31.1 s per loop (mean ± std. dev. of 7 runs, 1 loop each)
apply()方法是另一个选项:
%timeit df.apply(**lambda** row: divide(row['Time'],row['HelpfulnessNumerator']),axis = 1)1min 25s ± 4.88 s per loop (mean ± std. dev. of 7 runs, 1 loop each)
pandas 行操作中最好的选择是 itertuples()方法:
%%timeit
itertuples_divide = []
**for** _ **in** df.itertuples():
Time = getattr(_,'Time')
HelpfulnessNumerator = getattr(_,'HelpfulnessNumerator')
itertuples_divide.append(divide(Time,HelpfulnessNumerator))4 s ± 238 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
大多数情况下，我们并不强制使用按行操作。但如果对你来说是必须的，df.itertuples()是最快的方法。
让我们试试 map()方法:
%timeit list(map(divide,df['Time'],df['HelpfulnessNumerator']))861 ms ± 22.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
让我们做一些(假的)numpy 矢量器()方法:
%timeit np.vectorize(divide)(df['Time'],df['HelpfulnessNumerator']) 636 ms ± 24.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
我们可以对(实)numpy 矢量器使用 numpy where()方法:
%timeit np.where(df['HelpfulnessNumerator'] == 0 , 0 , df['Time']/df['HelpfulnessNumerator'])21.6 ms ± 329 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
正如你所看到的，我们不能在任何地方使用 np.where()方法。但是真的很快。让我们稍微改变一下函数:
**def** modified_divide(t,h):
**return** t/h
现在我们可以在 np.where()中使用这个函数:
%timeit np.where(df['HelpfulnessNumerator'] == 0 , 0 , modified_divide(df['Time'],df['HelpfulnessNumerator']))21.4 ms ± 200 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
此外，我们可以直接用 pandas 操作这个函数:
%timeit modified_divide(df['Time'],df['HelpfulnessNumerator'])8.75 ms ± 114 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
还有其他选择吗？绝对是的。如果你能用 Python 写代码，你就能用 Fortran 写代码。我在 Jupyter 笔记本里为 Fortran magic 做了一个 笔记本 。举个例子，看看这个:
%%fortran
subroutine fortran_divide(x, y, z)
real, intent(**in**) :: x,y
real, intent(out) :: z
z = x/y
IF ( 0 .EQ. Y ) THEN
Z = 0
END IF
end subroutine fortran_divide%timeit np.vectorize(fortran_divide)(df['Time'],df['HelpfulnessNumerator'])669 ms ± 22.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
我们可以用 numba。Numba 是一个 python 库，我们可以非常直接地使用它。它比 np.where()快 2 倍，而且这里没有 np.where()的一些限制:
**from** **numba** **import** njit
@njit()
**def** divide(t, h):
res = np.empty(t.shape)
**for** i **in** range(len(t)):
**if** h[i] != 0:
res[i] = t[i] / h[i]
**else**:
res[i] = 0
**return** res
%timeit divide(df['Time'].values, df['HelpfulnessNumerator'].value9.99 ms ± 133 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
numba 和 Fortran 都可以选择使用多处理的能力。这取决于数据帧的大小和操作。有时候我们可以使用多重处理来获得更快的速度，而有时候 numba 和 Fortran 中的多重处理对我们没有太大帮助。
每种方法的对数时间。
总之，不要在 pandas 数据帧上使用逐行操作。如果是必须的，可以使用 df.itertuples()。永远不要使用 df.iterrows()和 df.apply(…，axis=1)。
大部分时候可以用 np.where()搭配一些小技巧。这是最好的选择。但是如果不能使用，可以在进行数值运算的同时使用 np.vectorize()。
如果我们有一个很大的数据集，有一些其他的选项可以帮助我们，比如 numba 和 Fortran magics，值得花一些时间去学习和使用它们。
另外，有时候熊猫本身也支持我们想要的。先查熊猫比较好。😃
非数值运算
我将定义一个简单的函数来评估不同的方法。该函数将在每条记录的开头添加一个短语。
**def** edit_name(profileName):
**if** profileName != profileName:
**return** np.nan
**return** 'Name is **{}**'.format(profileName)
使用 df.iterrows()很简单。但是它太慢了:
%%timeit
iterrows_name=[]
**for** index,row **in** df.iterrows():
name = edit_name(row['ProfileName'])
iterrows_name.append(name)4min 15s ± 2.45 s per loop (mean ± std. dev. of 7 runs, 1 loop each)
使用逐行应用方法():
%timeit df.apply(**lambda** row: edit_name(row['ProfileName']),axis = 1)43.2 s ± 687 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
使用 itertuples()方法:
%%timeit
itertuples_name=[]
**for** _ **in** df.itertuples():
name = edit_name(getattr(_,'ProfileName'))
itertuples_name.append(name)3.78 s ± 128 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
另一种使用 apply()的方法:
%timeit df['ProfileName'].apply(**lambda** x: edit_name(x))1.58 s ± 86.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
让我们使用 map()方法:
%timeit list(map(edit_name,df['ProfileName']))1.41 s ± 65.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
哎呀，np.vectorizer 没有我们预期的那么快。是的，因为运算不是数值的。
%timeit np.vectorize(edit_name)(df['ProfileName'])2.16 s ± 155 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
有一只熊猫。可以非常快速地完成有限任务的 Series.map 。它可以自己处理 NaN 值。例如，让我们更改函数并查看结果:
**def** modified_edit_name(profileName):
**return** 'Name is **{}**'.format(profileName)
我们可以在 np.where()中轻松处理 NaN 值:
%timeit np.where(df['ProfileName'] == np.nan,np.nan, modified_edit_name(df['ProfileName']))2.69 s ± 98.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
熊猫系列地图方法:
%timeit df['ProfileName'].map('Name is **{}**'.format, na_action='ignore')1.16 s ± 50.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
每种方法的对数时间。
说到文字，我更喜欢用 map()，因为它速度快。如果我必须进行行操作，我将使用 df.itertuples()。
正如我所说的，在这个简单的优化之后，我们可以在应用多重处理和使用其他库之后对 pandas DataFrame 进行更快的操作。
关于 numba 和 Fortran magic 的更多信息，请看这里:
[## 示例- numba 0.15.1 文档
假设我们想用 Python 写一个图像处理函数。下面是它可能的样子。Numba 实际上产生了两个…
numba.pydata.org](http://numba.pydata.org/numba-doc/0.15.1/examples.html) [## mgaitan/fortran_magic
使用 f2py，用 Fortran 代码编译和导入单元格中的符号。单元格的内容被写入 a .f90…
github.com](https://github.com/mgaitan/fortran_magic) [## 从 python 使用 fortran
我喜欢 numpy(python 中数值计算的核心库)，但在一些非常罕见的情况下，我需要实现…
arogozhnikov.github.io](http://arogozhnikov.github.io/2015/11/29/using-fortran-from-python.html)
如何用 Python 模拟金融投资组合
克里斯·利维拉尼在 Unsplash 上的照片
多维几何布朗运动的一个应用
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
在一个日益全球化的世界里，金融市场不断受到越来越多因素的影响:新闻、政治、体育……尤其是市场本身。许多科学家正试图对金融市场内外事件之间的这些相互作用进行抽象和建模。然而，在定量金融领域，很难开发出一个代表实际市场的模型。然而，需要一个有价值的市场模拟模型来解决以下问题:
- 期权定价；
- 投资组合估价；
- 对冲策略；
- 敏感性分析；
- 不确定的未来现金流计算。
简而言之，高效地模拟尽可能多的场景，有助于我们减少市场不确定性带来的不便。下面我介绍一个强大的方法来实现一个简单而有价值的市场模拟模型。
单只股票的价格趋势可以被塑造成一个随机过程，称为几何布朗运动(GBM)模型。然而，对于由多个公司股票组成的投资组合，我们需要扩展 GBM 模型。本文旨在使用多维几何布朗运动模型对投资组合中的一个或多个股票价格进行建模。
总结
- 介绍
- 理论和算法
- 用 Python 实现
- 投资组合模拟示例
- 结论
介绍
尽管我们可以非常精确地计算出子弹的轨迹，但预测市场趋势似乎是不可能的。至少到目前为止。
这是因为金融市场的随机特性使其成为复杂系统的完美例子。事实上，复杂系统有一个本质上难以塑造的行为，因为它们各部分之间的相互作用(在物理数学意义上)。在复杂系统中，部件的集体行为会导致特征的出现，而这些特征很难从单个部件的属性中推断出来，甚至根本无法推断出来。
“整体是部分之外的东西.”
金融市场的复杂性源于其各部分之间的高度相关性。相互作用的非线性本质反映在因果过程中，直到产生不可预测的事件。由于这个原因，他们的行动之间的相互关系的性质和动态特征是金融市场复杂性的关键方面。
然后，重要的是建立一个连贯的和尽可能现实的市场模型，以便对这一特征的研究可以改进经济预测和复合金融规模的形成，如股票投资组合。
理论和算法
一维
几何布朗运动是一个连续时间的随机过程。更严格地说，几何布朗运动过程是通过以下形式的随机微分方程(SDE)来规定的
其中 W 是布朗运动，和σ是分别代表百分比漂移和百分比波动的常数。
上述 SDE 有解析解
这提供了一个简单的递归过程，用于在时间离散化的每个瞬间模拟 S 的值:
对于 n = 0，1，…，N -1 ，与 Z 独立的标准法线。
多个维度
多维几何布朗运动可以通过一个随机微分方程系统来描述。假设您想要模拟一个由 d 支股票组成的投资组合，系统采用以下形式
用 i = 1，.。。
股票之间的相关信息包含在布朗运动中，事实上我们有
如果我们通过设置定义一个d×d矩阵σ
在一个方便的术语滥用中，我们称σ为协方差矩阵；尽管协方差由下式给出
回想一下，具有均值 0 和协方差矩阵σ的布朗运动可以表示为 AW ，其中 W 为标准布朗运动，而 A 为
我们可以应用这个性质，把 SDE 的系统改写成
这种表示导致了用于模拟多维 GBM 的简单算法:
对于 i = 1，.。。，d 和 n = 0，…，N -1 ，其中 Z 为标准正态随机向量。
注:选择 A 为σ的乔莱斯基因子，可以减少每一步所需的乘法和加法的次数。
有关更多详细信息，请参见参考文献[1]。
用 Python 实现
我们使用 numpy 包及其矢量化属性来使程序更紧凑、更易于阅读、维护和更快执行。
我们定义一个函数来模拟给定参数的多维 GBM。除了模型参数之外，我们还选择插入一个与随机化种子相关的参数，以便能够以相同的结果重复模拟。
我们构建一个包含所有模拟股票路径的大小(股票数量，增量数量)数组。
投资组合模拟示例
让我们从展示二维情况的例子开始。对于这种情况，假设我们想从时间序列中估计模型参数。
一个简单的方法是使用一个名为 pandas_datareader (这里是文档的链接)的库。
我们选择任意两只股票，例如英特尔(INTC)和 AMD。
因此，我们有熊猫数据框架形式的历史数据。
为了估计𝜇、𝜎和𝐶𝑜𝑣的参数，我们计算了调整后收盘价的对数收益。
模拟获得的投资组合的 2 支股票与真实数据估计参数。
对于有超过 2 只股票的多维情况，我们选择通过随机化参数来举例。特别是，我们从相关矩阵开始创建协方差矩阵，因为它们必须符合特定的数学条件。我们记得这两个矩阵之间的关系由下面的公式描述
为了应用乔莱斯基分解，协方差矩阵必须是对称正定的。
因此，让我们利用 scipy 库获得一个随机相关矩阵，给定一个特征值向量。
用随机参数对 10 只股票的投资组合进行模拟。
结论
由于几何布朗运动的推广，本文提供了一个算法来模拟一只或多只股票，并强调了多维相关性的重要性。上面的例子显示了用 Python 实现一个在各种金融应用中有用的数学模型是多么简单。很明显，从这个基本模型开始，通过引入进一步的细节，例如与时间相关的参数，可以使模型越来越复杂。
点击此处查看完整代码。感谢阅读，希望这篇文章对你有所帮助！
参考
[1] P .格拉斯曼，金融工程中的蒙特卡罗方法。第 53 卷(2013)，施普林格科学&商业媒体。
如何用 Python 模拟交易
我们总是看到，所谓的交易者声称他们有超过 70%的胜率，他们的风险回报比超过 1:2(风险 1%，盈利 2%)。你觉得可能吗？让我们来了解一下！
作者图片
我有 70%的胜率，风险回报比为 1:2
ROFL！你确定你没有错过高中的数学课(可能是小学？！)?请记住，在 2019 年，对冲基金的平均回报率为 6%。这里是来源的链接。
现在让我们开始谈论 Python。
我们只需要两个库
import numpy as np
import matplotlib.pyplot as plt
现在我们需要写一个函数来模拟交易。当然不是真的。
def simulate(account_size, total_trades, risk_per_trade, win_rate, risk_reward):
account = account_size
accounts = [account]
profits = []
loss = []
wins = []
total_win = 0
max_con_l = 0
max_con_w = 0
con_l = 0
con_w = 0
pre = 0
rnd = list(np.round(np.random.uniform(1, 101, total_trades), 2))
for i in range(len(rnd)):
r = rnd[i]
win = r <= win_rate
risk = -np.round(account * risk_per_trade / 100, 2)
profit_per_trade = abs(risk) * risk_reward
profit = profit_per_trade if win else risk
profits.append(profit)
account += profit
accounts.append(account)
if profit > 0:
total_win += 1
wins.append(profit)
con_l = 0
if pre == 1:
con_w += 1
if con_w > max_con_w:
max_con_w = con_w
pre = 1
else: # 0 is also a loss (spread + commissions)
loss.append(abs(profit))
con_w = 0
if pre == -1:
con_l += 1
if con_l > max_con_l:
max_con_l = con_l
pre = -1
avg_win = np.mean(wins)
avg_loss = np.mean(loss)
max_win = np.max(wins)
max_loss = np.max(loss)
win_r = np.round(total_win / total_trades * 100, 2)
rrr = np.round(avg_win / avg_loss, 2)
profit_factor = np.round(np.sum(wins) / np.sum(loss), 2)
net_profits = np.cumsum(profits)
gain = np.round(accounts[-1] - account_size, 2)
growth_rate = np.round((accounts[-1] - account_size) / account_size * 100, 2)
print("--- Trading Results ---\n")
print("Total trades : {}".format(total_trades))
print("Wins : {} / {}%".format(total_win, win_r))
print("Average Win : {}".format(np.round(avg_win, 2)))
print("Average Loss : {}".format(np.round(avg_loss, 2)))
print("Max Win : {}".format(np.round(max_win, 2)))
print("Max Loss : {}".format(np.round(max_loss, 2)))
print("Max Cons. Wins : {}".format(max_con_w))
print("Max Cons. Loss : {}".format(max_con_l))
print("Risk Reward Ratio : {}".format(rrr))
print("Profit Factor : {}".format(profit_factor))
print("Risk per trade : {}%".format(risk_per_trade))
print("---")
print("Initial Account : {}".format(account_size))
print("Profit : {} / {}%".format(gain, growth_rate))
print("Final Account : {}".format(np.round(account, 2)))
print()
print("Results are compounded. Spread and commissions are not calculated.")
fig, ax = plt.subplots(2, 1, figsize=(16, 10))
ax[0].plot(net_profits)
ax[1].plot(accounts)
ax[1].axhline(account_size, color="#000000", ls="-.", linewidth=0.5)
ax[0].set_title("Equirty Curve")
ax[1].set_title("Account Growth")
plt.show()
让我们来定义一下这个人的说法
account_size = 10000
total_trades = 200 #trades per year maybe?
risk_per_trade = 2 #risk 2% of your account per trade
win_rate = 70 # in percentage
risk_reward = 2 # risk 1% profit 2%
OMG！这太疯狂了。如果你准备好了，我们就跑吧？😃
simulate(account_size, total_trades, risk_per_trade, win_rate, risk_reward)
奥斯卡颁给了这个家伙！！！！
他每年能赚 80% 25%还想卖给你一个产品？！加油！！！！
ok；现在让我们试着更现实一点。我将使用以下参数:
account_size = 10000
total_trades = 200 #trades per year maybe?
risk_per_trade = 2 #risk 2% of your account per trade
win_rate = 52
risk_reward = 1.4
结果呢
即使有 52%的胜率和 1.4 的风险回报比，每年也能赚 193%！然而，这并不容易。
结论
请不要再相信那些所谓的交易者了。大多数社交媒体交易者都是骗子。他们只是想卖给你一个梦想和他们所谓的圣杯产品。没有圣杯，你也不需要 70%的胜率。
免责声明
我不是专业的财务顾问。这篇文章和代码，分享仅用于教育目的，而不是财务建议。你要对自己的输赢负责。
本文的全部代码可以在这个资源库中找到:
如何用 Python 模拟交易？通过创建一个关于…的帐户，为培训/贸易模拟发展做出贡献
github.com](https://github.com/atillayurtseven/TradeSimulation)
啊也；记得在以下社交渠道关注我:
直到下次；保持安全，交易安全！！！
阿蒂拉·尤尔特塞文
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
如何用 Word2Vec 解决类比问题
美国之于加拿大，就像汉堡之于 _？
Word2vec 是什么？
为了让机器学习算法理解单词，使用单词嵌入将单词映射到实数的向量。有各种各样的单词嵌入模型，word2vec 就是其中之一。
简而言之，word2vec 是一组用于产生单词嵌入的相关模型。这些模型被训练来构建单词的语言上下文。Word2vec 采用大型文本语料库并产生一个向量空间，其中将语料库中的每个唯一单词分配给空间中相应的向量。
但是单词向量在向量空间中是如何定位的呢？它们被定位成使得在语料库中共享共同上下文的单词在空间中彼此靠近。
从怀特哈特学校取得
为了理解 word2vec 是如何工作的，让我们探索一些可以使用 word2vec 的方法，比如寻找单词之间的相似性或解决类似的问题
加载数据和模型
我们将使用来自手套的预训练单词向量。我们对包含 2B 推文、27B 令牌和 200d 向量的 Twitter 数据集特别感兴趣。数据可以在这里下载。我们使用 Gensim 将手套向量转换成 word2vec，然后使用 KeyedVectors 加载 word2vec 格式的向量。
查找最相似的单词
现在我们用model.most_similar()来寻找前 N 个最相似的单词。积极的词语对相似性有积极的贡献。负面词汇对相似性有负面影响，或者换句话说，对差异有影响。让我们测试一下这个模型！
找出与“爱”最相似的单词
model.most_similar(positive=['love'])
“女孩”怎么样？
model.most_similar(positive=['girl'])
。我们不妨查一下和‘男孩’类似的词
model.most_similar(positive=['boy'])
嗯。那么‘男孩’和‘男人’在相似的词上有区别吗
model.most_similar(positive=['man'])
“男孩”变成“男人”似乎有明显的不同
解决类比
单词嵌入方法还能够捕获单词之间的多个不同程度的相似性。语义模式可以使用向量算法来复制。因此，我们也可以使用 word2vec 来解决类比问题。如果美国有汉堡包，加拿大有什么食物？
结果似乎显示了加拿大流行的各种食物。来自加拿大的读者可以确认这些热门词汇是否合理。让我们用一个名为analogy().的函数再探索几个国家。这次，我们只为每个类比返回一个最上面的相似单词。
既然可视化很好，让我们创建一个国家和它们相应的食物之间的地图。我们使用主成分分析将数据的维数降低到 2。
在这张地图上，国家之间的距离显示了在二维空间中哪些国家彼此更接近。箭头表示国家和食物之间的关系。
结论
恭喜你！你已经学习了什么是 word2vec，以及如何用 word2Vec 寻找单词之间的相似之处。看到 word2vec 的强大，你可能会想:“这种方法怎么能工作得这么好？”
我们知道，word2vec 对象函数导致出现在相似上下文中的单词具有相似的嵌入。但有趣的是，是什么让 word2vec 框架中的单词嵌入学习如此有效却知之甚少。无论是什么原因使这种嵌入成功，我希望您理解它的功能，并利用这个强大的工具进行文本分析。我鼓励您使用这个数据集或您选择的数据集来创建 word2vec 的其他类比。
在 this Github repo 中，您可以随意使用本文的代码。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以通过 LinkedIn 和 Twitter 与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
给定个人偏好，如何匹配使得总偏好最大化？
towardsdatascience.com](/how-to-match-two-people-with-python-7583b51ff3f9) [## 字典作为 If-Else 的替代
使用字典创建一个更清晰的 If-Else 函数代码
towardsdatascience.com](/dictionary-as-an-alternative-to-if-else-76fe57a1e4af) [## 用 Python 选择要投资的股票
您计划在未来 3 年投资几只股票，每只股票的每一美元都有不同的预期回报…
towardsdatascience.com](/choose-stocks-to-invest-with-python-584892e3ad22) [## 使用 Python 最大化您的生产力
你创建了一个待办事项清单来提高效率，但最终却把时间浪费在了不重要的任务上。如果你能创造…
towardsdatascience.com](/maximize-your-productivity-with-python-6110004b45f7) [## 用这 6 个小窍门提高你的效率
并控制您的阵列
towardsdatascience.com](/boost-your-efficiency-with-these-6-numpy-tricks-29ca2fe81ecd)
参考
*Word2vec。*维基百科。【https://en.wikipedia.org/wiki/Word2vec 号
如何解决编码问题
Daria Nepriakhina 在 Unsplash 上拍摄的照片
工作数据科学家的实际问题解决策略
曾经写过的每一行代码最终都是为了一个目的:解决问题。无论你做什么，你都是在同时解决几个方面的问题。
一个小的一行程序解决了一个让函数工作的问题。数据处理管道需要该函数。该管道被集成到一个平台，该平台为其用户实现了机器学习驱动的解决方案。
问题无处不在。它们的规模和影响可能不同，但解决问题的一般策略是相同的。
作为一名工程师、开发人员或数据科学家，有效地解决问题真的可以提高你的成绩，让你领先于你的同行。有些人经过多年的练习可以本能地做到这一点，有些人则需要有意识地努力去学习。然而，无论你是谁，你都可以并且你必须提高你解决问题的技巧。
有了研究级数学的背景，我有机会练习解决问题并观察过程。令人惊讶的是，这不是你每次都要即兴创作的东西。相反，
一个成功的问题解决者有几个标准的工具和一个总的计划，并随时调整。
在这篇文章中，我的目标是给出这些工具的一个概述，并使用它们来创建一个可以随时遵循的过程。为了使情况变得现实，让我们将自己置于以下场景中:我们是深度学习工程师，正在研究对象检测模型。我们的数据有限，所以需要为图像增强提供一个解决方案。
图像放大。来源:相册自述文件
增强是通过应用随机变换(如裁剪、模糊、亮度变化等)从可用图像生成新数据的过程。请看上面的图片，它来自 awesomealbuminations库的自述文件。
你需要在下周之前发布这个特性，所以你需要马上开始工作。如何处理问题？
(作为一名数学家，我的思维过程深受乔治·波利亚的《如何解决》一书的影响。虽然数学问题不同于现实生活中的编码问题，但这是任何希望解决问题的人的必读之作。)
步骤 0:理解问题
在试图解决你脑海中的任何问题之前，有一些问题需要回答。没有正确理解一些细节会导致浪费时间。你肯定不想这么做。例如，明确以下几点是有好处的。
- **问题的规模有多大？**在我们的图像增强示例中，您是否需要在生产中每秒处理数千张图像，或者只是让您尝试一些方法？如果需要生产级解决方案，您应该提前意识到这一点。
- 其他人会使用你的解决方案吗？如果人们打算广泛地使用你的代码，必须在代码质量和文档方面投入大量的精力。另一方面，如果这只是供您使用，就没有必要在这方面做太多工作。(我已经看到有人不同意我的观点:)然而，我坚信应该尽量减少工作量。所以，如果你只需要快速尝试一个想法和实验，请放心而不是考虑代码质量。)
- 您需要一般解决方案还是特殊解决方案？许多时间会被浪费在实现没人会用到的功能上，包括你自己。在我们的例子中，您需要广泛的图像增强方法，还是只需要垂直和水平翻转？在后一种情况下，预先翻转图像并将其添加到训练集中也是可行的，这需要最少的工作。
衡量你理解程度的一个很好的标准是你解释和与他人讨论问题的能力。讨论也是发现意想不到的方法和边缘案例的好方法。
当您理解了您的约束并有了一个稍微精确的问题规范时，就该开始工作了。
第一步。有没有现成的解决方案？
你必须做的第一件事就是寻找现有的解决方案。除非你正在挑战人类知识的极限，否则其他人已经遇到了这个问题，创建了一个关于堆栈溢出的线程，并可能围绕它编写了一个开源库。
利用这一点。使用成熟的工具，而不是创建自己的工具，有几个好处。
- 你节省了大量的时间和工作。在时间紧迫的情况下，这一点至关重要。(我的一个老师曾经讽刺地说“你可以用两个月的工作节省一个小时的谷歌搜索”。完全正确。)
- **既定的工具更有可能是正确的。**开源工具不断得到社区的验证和检查。因此，它们不太可能包含 bug。(当然，这不是保证。)
- **更少的代码供你维护。**同样，我们应该一直努力降低复杂度，最好是代码量。如果你使用外部工具，你就不用担心它的维护，这是一个很大的好处。每一行代码都有隐藏的维护成本，以后再支付。(往往是最不方便的时候。)
初级开发人员和数据科学家经常忽略这些，更喜欢从头开始编写所有东西。(我当然有，但很快就学会了更好地了解。)我见过最极端的案例是一个开发者，他自己写的深度学习框架。你应该永远不要这样做，除非你是一个深度学习研究者，并且你知道如何比现有的框架做得更好。
当然，并不是所有的问题都需要一个完整的框架，也许你只是在寻找一个命令行程序。寻找现有的解决方案肯定是有益的，尽管在这种情况下你需要小心。如果您花时间去理解它是如何工作的以及为什么工作，那么从堆栈溢出中查找和使用代码片段是很好的。不这样做可能会导致不愉快的调试会话，甚至在最坏的情况下导致严重的安全漏洞。
您会惊讶地发现，许多最常见的解决方案都包含安全漏洞
medium.com](https://medium.com/better-programming/why-code-snippets-from-stack-overflow-can-break-your-project-ced579a48ddb)
对于这些较小的问题，寻找现有的解决方案包括浏览教程和最佳实践。总的来说，在无情的实用主义和盒子外面的思维之间有一个平衡。当你以通常的方式实现某个东西时，你是在为将要使用和维护这段代码的开发人员做一件好事。(往往包括你。)
有一个现有的解决方案。接下来呢？
假设在您为数据预处理管道提供图像增强的道路上，您遵循了我的建议，寻找现有的解决方案，并找到了令人敬畏的album ations库。太好了！接下来呢？
一如既往，需要考虑的事情范围很广。不幸的是，仅仅因为您已经确定了一个可能是潜在解决方案的外部工具，并不意味着它将适合您的目的。
- 它工作正常吗？是否得到了适当的支持？有一件事比不使用外部代码更糟糕:使用有 bug 且未经维护的外部代码。如果一个项目没有被很好地记录并且没有被维护，你应该避免它。
对于较小的问题，答案通常可以在堆栈溢出中找到，而运行良好的部分是必不可少的。(见上面我链接的帖子。) - **是直接适应吗？**例如，如果您使用的图像处理库与相册不兼容，那么您必须做额外的工作。有时，这可能太多，你必须寻找另一种解决方案。
- **性能是否足够？**如果您需要每秒处理数千张图像，性能是一个因素。一个库使用起来可能非常方便，但是如果它不能运行，它就必须被淘汰。这可能不是所有情况下的问题(例如，如果你只是在寻找一个快速的解决方案来做实验)，但如果是，应该在投入大量工作之前尽早发现。
- 你了解它是如何工作的吗？它的基本假设是什么？由于我上面提到的原因，对于使用堆栈溢出代码片段来说尤其如此。对于更复杂的问题，如图像增强问题，您不需要逐行理解每一段外部代码。但是，您需要了解库的要求，例如输入图像的格式。
当然，这只有在你确实能找到外部解决方案的情况下才适用。请继续阅读，看看在这种情况下应该怎么做。
如果没有现成的解决方案呢？
有时候你必须自己开发解决方案。问题越小，发生的越频繁。这些都是学习和建设的大好机会。事实上，这是真正的解决问题的部分，也是最让我们兴奋的部分。
有几种策略可以采用，它们都应该在你的工具箱里。如果你仔细阅读，你会发现有一个共同的模式。
- 你能简化吗？有时候，只解决一个特例就够了。例如，如果您确实知道图像增强管道的输入将总是具有相同的格式，则没有必要花费时间来处理几种情况下的输入。
- 隔离问题的组件。解决一个问题可能很难，更别说同时解决两个了。你应该总是让事情变得简单。当我年轻的时候，我曾经认为解决困难的问题是为了得到发展点。很快，我意识到解决难题的人总是通过解决许多小问题来做到这一点。
- **你能解决特殊情况吗？**在你实现一个图像增强的抽象接口之前，你应该做一个方法来添加到你的管道中。一旦您发现了更好的细节并规划出确切的需求，就可以设计出更通用的解决方案。
本质上，解决问题是一个迭代的过程，在这个过程中，你一步一步地把问题分解，最终把它简化成容易解决的部分。
第二步。打破解决方案(可选)
我注意到许多优秀的数学家和开发人员有一个共同的特点:他们喜欢分析解决方案，分析是什么让他们工作。这是您学习的方式，也是您构建健壮而简单的代码的方式。
打破东西可能是解决问题过程的一部分。从特殊情况到一般情况，你通常会通过打破现有状况来找到解决方案。
当它完成的时候
根据问题本身的严重程度，如果允许的话，您应该考虑开源它。为其他开发人员解决问题是对社区做出贡献的一个很好的方式。
例如，我就是这样构建了model，这是 Python 最流行的主动学习库之一。我从一个非常具体的问题开始:为生物信息学构建主动学习管道。因为构建复杂的方法总是需要实验，所以我需要一个能够快速实验的工具。用当时可用的框架很难做到这一点，所以我慢慢地将我的代码转换成一个可以被其他人轻松采用的工具。
Python3 的模块化主动学习框架 modAL 是 Python3 的一个主动学习框架，用…
github.com](https://github.com/modAL-python/modAL)
曾经“只是”一个解决方案变成了一个库，拥有成千上万的用户。
结论
与流行的观点相反，有效的解决问题并不等同于一直有好主意。相反，它是一个思维过程，带有一些定义明确且易于使用的工具，任何人都可以学习。聪明的开发人员本能地使用这些，使它们看起来像魔术一样。
解决问题的技巧可以通过有意识的练习和思考习惯来提高。你可以在几个平台上发现问题并着手解决，比如 Project Euler 或 HackerRank 。然而，即使你开始应用这些方法来解决你在工作中遇到的问题，你也会看到你的技能迅速提高。
如果你喜欢把机器学习概念拆开，理解是什么让它们运转，我们有很多共同点。看看我的博客，我经常在那里发表这样的技术文章！
如何解决你深度学习训练中的数据加载瓶颈
即使你没有固态硬盘
在 Unsplash 上由 Varun Gaba 拍摄的照片
深度学习训练中的每一次迭代，你都形成一批数据，并传递给模型。从 HDD 中读取数据是一个非常耗时的过程，因为机械致动器臂会穿过 HDD 板来寻找数据点的目标块。你知道，我们通常混洗数据集，并从这个混洗的数据集形成批次。这意味着批次中的数据点随机分布在硬盘中。这称为随机读取，与顺序读取相比非常慢。如果您要训练大型数据集(如 ImageNet ),您应该避免这些类型的瓶颈。下面是一个例子:使用 RTX2080 GPU 和 7200 RPM HDD ，ResNet18 模型在 ImageNet 数据上的一次迭代需要 32 个批处理大小，耗时 0.44 秒。**100 个纪元，需要 20 天！**当我们测量函数的计时时，数据加载+预处理需要 0.38 秒(其中 90%的时间属于数据加载部分)，而优化(向前+向后传递)时间只需要 0.055 秒。如果将数据加载时间减少到合理的时间，完全训练可以轻松减少到 2.5 天！
硬盘内部。我们在深度学习训练中形成批次时执行随机访问。照片由弗兰克 R 在 Unsplash。
最基本、最快的解决方案:购买 NVMe 固态硬盘
如果你的硬件系统支持固态硬盘，购买一个 NVMe M2 型固态硬盘将立即解决你的问题。为什么？让我们检查一些存储设备的读取速度。
**7200 RPM 硬盘:**100 MB/秒
**采用 SATA 速度的固态硬盘:**600 MB/秒
**SSD (NVMe 型)通过 M2:**3500 MB/秒
所以在 NVMe 型固态硬盘和你的 7200 RPM 硬盘之间，有 35 倍的差别。因此，购买和 NVMe 类型的固态硬盘是最基本和最快的解决方案。
如果固态硬盘不适合您，该怎么办？然后你必须继续使用你的硬盘。这是一些收据，可以让你用硬盘更快地加载数据。
1.如果你的数据是在硬盘上，它适合内存
在训练开始时将所有数据集加载(读取)到 RAM 中，这样在每次迭代中就不会消耗从磁盘读取的时间。你必须为此编写一个自定义数据集类(对于 PyTorch，请查看这里:https://py torch . org/tutorials/beginner/data _ loading _ tutorial . html)。
2.如果您的数据存储在硬盘中，但不适合存储在 RAM 中
如果您正在处理大型数据集，如 ImageNet(大约 150 GB)，您不能将所有数据加载到 RAM 中。所以，你必须从硬盘上一批一批地读取数据。然而，我们怎样才能让它更快呢？提示在本文的第一段:我们应该执行顺序读取而不是随机读取。
你混洗你的数据集，并将混洗后的数据集再次写入磁盘，这样，如果你按顺序读取每一批，你将得到混洗后的批。您可以使用 Tensorpack 库来完成此操作(https://tensor pack . readthedocs . io/tutorial/efficient-data flow . html)。
当您没有固态硬盘时，Tensorpack 库是一个救命恩人[1]。
现在，让我们比较这三种不同的数据加载方法。
三种不同数据加载方法的数据加载时间比较。
HDD，随机读取 果然最慢。然而，这里有一个惊喜！硬盘，顺序读取 *，*比 SSD 快一圈，随机读取 *。*所以，我们不花钱买固态硬盘，就不能用硬盘吗？
不幸的是没有。
首先，读写混洗数据需要时间。对于 ImageNet 2012 数据(150 GB)，读取、混洗和写入需要 4 个小时。因此，您不能对每个时期执行此操作。如果你没有固态硬盘，这是唯一的救命稻草。
第二，将数据加载时间从 0.370 秒减少到 0.018 秒是重要的，但是对于训练来说将其从 0.018 秒减少到 0.003 秒是不必要的，因为存在额外的优化时间(向前传递+向后传递)。一旦数据加载时间减少，优化时间就会成为主要瓶颈。此外，许多框架提供异步数据加载；因此，这种差异不会显著影响整体训练表现。
预处理呢？
- 裁剪、翻转、规格化等基本操作不会显著影响训练时间；因此，大多数时候，您可以动态地执行这些操作。但是，如果您有一长串预处理函数或自定义预处理函数会降低处理速度，您可以对原始数据集执行一次这些操作并将其写入磁盘，然后您可以读取预处理文件并直接将其提供给模型。
- 可以使用 GPU 张量进行预处理。 NVIDIA DALI [2]设计用于在 GPU 上进行预处理，它也具有快速的 CPU 实现。
- 可以使用低级语言(比如 C++)进行预处理，充分利用线程机制。
额外收获:了解你的图书馆。
PyTorch 和 Tensorflow 等框架将复杂的操作和 GPU、CPU 数据传输与用户隔离开来。这是这些图书馆的魅力之一。然而，它可能是有害的。例如，您想在每次迭代中获得一个张量的值，您可以通过下面的代码行(在 PyTorch 中)轻松获得它:
aValue = aTensor.item()
虽然看起来是很无辜的一行，但是每次执行这一行，都会把 GPU RAM 中的张量复制到主 RAM 中，这是一个很耗时的操作。它就像一个 print() 函数，我们不能随时使用它(尤其是在循环中)。因此，我们必须知道正在发生什么，以及函数如何在后台运行。了解这一点有助于我们编写更有效的代码。
下面是本文中提到的方法的简单流程图:
图片作者。
觉得这篇文章有用？看看我下面的其他文章:
传统的 CNN(Alex net，VGG，GoogLeNet，ResNet，DenseNet …)在样本较多的情况下有很好的表现…
medium.com](https://medium.com/swlh/deep-learning-architectures-that-you-can-use-with-a-very-few-data-8e5b4fa1d5da) [## 使用 PyCharm 和 Docker 的有效深度学习开发环境
借助全面承诺的 IDE 和虚拟化提高您的工作效率。
towardsdatascience.com](/effective-deep-learning-development-environment-with-pycharm-and-docker-34018f122d92)
参考
[1]吴，庾信。“Tensorpack。”(2016).(【https://github.com/tensorpack/tensorpack】T4)
[2]https://github.com/NVIDIA/DALI
如何解决人工神经网络中的随机性？
了解一个人工神经网络随机性的原因以及如何修复。
在这篇短文中，我们将了解
- 人工神经网络的随机性是什么？
- 为什么我们在 ANN 中会有随机性？
- 如何修复随机性，让一个神经网络稳定？
- keras 中的简单代码实现，用于从人工神经网络获得一致的结果
人工神经网络(ANN)的随机性是什么？
人工神经网络(ANN)的随机性是指当相同的神经网络对相同的数据进行训练时，它会产生不同的结果。
有时，我们可能已经随机选择了训练数据和测试数据，如果我们从训练数据和测试数据中去除随机性，即使使用相同的神经网络，每次执行我们仍然可能得到不同的结果。
结果的这种随机性使得神经网络不稳定和不可靠，尤其是在与他人共享您的代码或展示您的工作时。
人工神经网络为什么会有随机性？
人工神经网络中的随机性可能由于多种原因而发生
- 权重和偏差的随机初始化
- 像辍学这样的正规化技术中的随机性
- 随机梯度下降(SGD)等优化技术中的随机性
我们如何修复一个 ANN 的随机性？
如果我们使随机性更可预测，我们就能获得一致的结果。
为了使随机性可预测，我们使用了 种子的概念。
Seed 有助于每次获得可预测、可重复的结果
如果我们不设置种子，那么我们在每次调用时都会得到不同的随机数
将种子设置为某个值，比如 0 或 123，将在同一台机器或不同机器上多次执行代码时生成相同的随机数。
为了解决我们使用的人工神经网络的随机性
- numpy 随机种子
- 张量流集合 _ 随机 _ 种子
让我们在不设置随机种子的情况下构建一个简单的 ANN，接下来，我们将设置随机种子。我们将在 ketas 中实现代码
我使用了 Kaggle 的房屋数据集
证明人工神经网络的随机性
#Importing required libraries
import numpy as np
import pandas as pd
from keras import Sequential
from keras.layers import Dense# Reading the data
dataset = pd.read_csv('housingdata.csv')
dataset.head(2)# Creating independent and dependent variable
X=dataset.iloc[:,0:13]
y=dataset.iloc[:,13].values# creating train and test data
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test =X[:400], X[400:], y[:400], y[400:]# Building a simple ANN for regression
**def build_regressor():**
regressor = Sequential()
regressor.add(Dense(units=13, input_dim=13))
regressor.add(Dense(units=1))
regressor.compile(optimizer='adam', loss='mean_squared_error', metrics=['mae','accuracy'])
return regressor# creating the kears Regressor with 100 epochs
from keras.wrappers.scikit_learn import KerasRegressor
regressor = KerasRegressor(build_fn=build_regressor, batch_size=32,epochs=100)# Fitting the training data
results=regressor.fit(X_train,y_train)# Making prediction the test data
y_pred= regressor.predict(X_test)# printing the first 5 predictions for comparison
y_pred= regressor.predict(X_test)
y_pred[:5]
程序第一次运行的输出
第二次运行的输出
您将在每次执行时得到不同的输出
修复我们人工神经网络的随机性
我们将导入另外两个库并设置种子
**from numpy.random import seed
from tensorflow import set_random_seed**
设置 numpy 种子和 tensorflow 种子
**seed(0)
set_random_seed(0)**
最终代码
#Importing required libraries
import numpy as np
import pandas as pd
**from numpy.random import seed
from tensorflow import set_random_seed**
from keras import Sequential
from keras.layers import Dense**# settingt he seed
seed(0)
set_random_seed(0)**# Reading the data
dataset = pd.read_csv('housingdata.csv')
dataset.head(2)# Creating independent and dependent variable
X=dataset.iloc[:,0:13]
y=dataset.iloc[:,13].values# creating train and test data
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test =X[:400], X[400:], y[:400], y[400:]# Building a simple ANN for regression
**def build_regressor():**
regressor = Sequential()
regressor.add(Dense(units=13, input_dim=13))
regressor.add(Dense(units=1))
regressor.compile(optimizer='adam', loss='mean_squared_error', metrics=['mae','accuracy'])
return regressor# creating the kears Regressor with 100 epochs
from keras.wrappers.scikit_learn import KerasRegressor
regressor = KerasRegressor(build_fn=build_regressor, batch_size=32,epochs=100)# Fitting the training data
results=regressor.fit(X_train,y_train)# Making prediction the test data
y_pred= regressor.predict(X_test)# printing the first 5 predictions for comparison
y_pred= regressor.predict(X_test)
y_pred[:5]
首次运行和任何运行时的输出
结论:
由于权重的随机初始化、偏差、使用漏失和不同的优化技术，人工神经网络本质上是不确定的。我们可以为 numpy 和 TensorFlow 设置种子，以便在同一台计算机或不同的计算机上使用相同的数据集获得一致的结果。
如何解决 SQL 中的“不明确的名称列”错误
给这些表起一个别名
迈克尔·泽兹奇在 Unsplash 上的照片
有时，您可能希望在 SQL 中连接两个表，并且表中有同名的列。
在这种情况下，如果您连接两个表并运行查询，而不区分相同的列名，错误“Ambiguous name column”将会出现。
这个怎么解决？
简单。
有各种方法可以解决“不明确的名称列”错误。下面解释一个最简单的解决方法。
如何解决 SQL 中的“不明确的名称列”错误
例如，您想要联接两个名为 TABLE1 和 TABLE2 的表。表 1 包含这些列—雇员 ID、姓名、薪金。表 2 包含这些列——雇员 ID、姓名和年龄。
首先，让我们创建表。
注意，除了 EmployeeID 之外，这两个表有一个共同的“Name”列，它始终是一个数字。
现在让我们把桌子连起来。运行以下查询:
如果您运行上面的查询，您将得到这个错误——“不明确的名称列”。
这意味着两列具有相同的列名，即“名称”列。SQL 机器不知道您引用的是两个表中的哪一个“名称”。这是模棱两可的——不清楚。
为了澄清这一点，请将 TABLE1 或 TABLE2 的别名添加到同名的列中。你会注意到上面，表 1 的别名是 A，而表 2 的别名是 b。
所以，让我们来修复这个 bug。
运行查询。没有错误！
您可能想进一步区分表 2 中的“姓名”,编写如下查询:
结论
您可以为同名的列指定不同的名称。这可能会使列内容的识别变得困难。列名应该描述列中的内容。
解决“不明确的列名”错误的最简单方法之一——不改变列名——是给要连接的表取一个别名。这向 SQL 机器发送了一个清楚的信息，列是不同的。
快乐查询。
谢谢你的时间。
附言 作家面临的挑战可能会让他们终生无法写作……久坐导致的慢性背痛、长时间盯着屏幕导致的眼睛问题、写作时手指窒息等等。如果你想继续得到这种类型的文章，你可以成为 媒介订阅者来支持我。每月 5 美元。你的一部分订阅费归我 。
如何解决企业人工智能中的最大挑战
企业人工智能战略路线图
90%的现有数据是在过去两年中生成的。每天，产生 7.5 万亿千兆字节的数据 — 每人大约 147，000 千兆字节。这些数字是惊人的，但这是意料之中的:世界在增长，机器经济呈指数增长。
这并不是说所有这些数据都立即有用。没有大量的预处理，组织不能简单地利用这些资源——但是有人在做这项工作吗？Forrester 报告称，在企业内部，73%的数据仍未用于分析。业务战略和数据战略之间仍有很大差距——您组织的预测性解决方案只能像最初的问题陈述一样可靠。根据 Gartner 的说法，组织需要建立具体的用例，并部署具有可衡量结果的技术，以实现人工智能的价值。
数据是拼图中的一大块
这个比喻仍然存在——数据是新的石油(尽管，这个短语最迟在 2006 年被创造出来，可能并不那么“新”)。它在原始状态下绝对有价值。提炼出来就更值钱了。但是当它变成一种产品，一种专门为解决某个特定问题而制造的产品时，它的应用是数不胜数的，它的价值也在飙升。
这同样适用于数据:组织需要记住，这里的最终目标不是收集尽可能多的数据。他们需要从数据中提取价值，并将其应用于特定的业务问题。观察数据，从中学习，然后根据反馈自动完成工作的想法是机器学习的核心。
GIF via giphy
尽管好莱坞经常描绘，曼梯·里并没有证明“终结者假说”。
理解机器学习
在任何组织成为数据驱动型组织之前，了解基础知识非常重要。人们通常认为机器学习的最终目标是在实时仪表板上显示数据的图表和可视化。ML 是关于自动化任务的(不是关于取代工作)，它不仅仅是展示统计数据。广义而言，机器学习教给计算机一些关于世界的知识，以便机器可以使用这些知识来执行其他任务。另一方面，统计学教给人们一些关于世界的东西，这样他们就能看到更大的图景，做出明智的决定。
根据埃森哲的数据，与追求概念证明的公司相比，战略性扩展人工智能的公司报告的人工智能投资回报几乎是其三倍。显然，ML 不是一个精心打扮的仪表板；事实上，它可以帮助您的组织构建智能系统，这些系统可以模仿、扩展和增强人类智能，以实现特定的“机器智能”，使您组织中的人员能够专注于解决更适合人类的问题。
然而，大多数组织都在努力实现可扩展的人工智能解决方案，并错过了好处(见:钱)。问题？你的组织不缺人才，缺的是战略。不服气？我们来看一些数字。
可扩展解决方案
自 2015 年以来，数据科学职位需求增长了 344%。我们可以清楚地看到，组织正在投资发展他们的数据科学团队，他们的印象是，如果他们继续雇佣数据科学家，创新和数字化转型将是一个自动的副产品。然而只有** 27%的企业数据 被使用，算上外部数据更是令人震惊——在世界上所有可用的数据中， 不到 1%被用于分析 。**
所有这些数据都有一个临界点。公司可以投入数百万美元建立庞大的数据团队来搜索互联网搜索结果，并准备来自各地的数据——但这永远不会是一个可扩展的解决方案，并且缺乏管理策略是造成瓶颈的原因。
公司部署 AI 和 ML 需要什么？
那么这个过程从哪里开始，组织实际上是如何构建和部署成功的机器学习项目的呢？
- 从目标开始。你必须清楚地了解你面临的问题以及你想要实现的解决方案。在保龄球运动中，你可以用每一个球击倒十个瓶，但只有当你投对了球道，这才是一场完美的比赛。对于 ML，你需要知道你的目标是什么。组织是以目标为导向的，他们总是寻求增加收入和提高 KPI——如果你的问题没有解决这些目标，它可能偏离目标。
- ****问正确的问题。大多数企业在试图用 ML 解决问题之前都没有提出正确的问题。分析并理解你能回答什么，不能回答什么，然后弄清楚你的预测系统如何真正让最终用户受益。要问的一个关键问题是:“我的项目会被它能为组织创造的价值深深地驱动吗？”
- ****定义商业战略。制定战略时，必须像对待其他项目一样，对数据和 ML 项目给予同样的关注和细节。您需要具体的、可测量的、可实现的目标、实施计划以及帮助跟踪项目成功的度量标准。仅仅从技术层面来看你的项目是不够的，你需要能够将解决方案与你的组织联系起来。例如，在实施您的模型后，您的公司会增加收入或在市场中获得稳固的竞争优势吗？
- ****建立合适的团队。组织往往无法为工作雇用合适的候选人，因为他们要么不知道自己想要实现什么，要么对数据科学家的角色有冲突的看法。数据团队由更多角色组成，而不仅仅是数据科学家，认为一个角色能够建立和维护仓库，设计数据工作流，编写完美优化的机器学习算法，并对一切进行分析是无知的。为了填补项目的正确角色，你需要清楚地定义你的目标，理解每个技术角色/团队结构的细微差别，并确保所有这些都在你的招聘公告中概述。下图显示了核心技能对于数据科学新兴角色的相对重要性:
数据科学中技能重要性图表
****5。创建数据战略路线图。数据是 ML 项目的关键资产，因为它训练模型。据人工智能领域的先驱 吴恩达称，最大、最成功的产品拥有最多的用户。拥有最多的用户通常意味着你获得最多的数据，而在现代 ML 中，拥有最多的数据通常意味着你可以创造出最好的 AI。下图描述了上述概念:
6。利用第三方软件。不要试图重新发明轮子，建立一个内部数据管道。为了成功推出 AI，选择正确的工具非常重要，这些工具可以帮助您的组织完成可以自动化的任务，如寻找、收集、标准化、提炼和集成数据。 代表 Alegion 进行的维度研究报告 发现，最终，71%的团队将训练数据和其他机器学习项目活动外包出去。在“建造还是购买”的争论中，选择“建造”的公司花费更多的时间和金钱。记住，你不是在雇佣数据管理员，而是在雇佣数据科学家。采用 DataOps 工具并找到自动化数据生命周期的准备和处理阶段的方法将缩短洞察时间。
这从来都不容易——但没必要这么难
一些企业没有足够的数据，另一些企业则在苦苦寻找超过十年的无用数据。拥有数据并不意味着可以从中获得洞见。组织未能认识到从数据中提取洞察力所需的准备工作，因此在创新和增长方面出现了越来越多的瓶颈。不是没有数据，是没有可用的数据。
数据是创建预测和智能解决方案的一个重要因素，但数据不仅仅是拥有大量数据。找到一个问题，找到合适的人来解决它，给他们有效解决问题所需的工具，并衡量他们的功效——这些是成功的 ML 的要求。
最初发表于【https://blog.thinkdataworks.com】。**
如何解决真正的大数据问题——加载巨大的 Excel 文件
提示:多线程。使用 PDI 和 PostgreSQL，我们可以在几分钟内加载一个巨大的 excel 文件。
越来越多的公司开始意识到数据的重要性。因此，他们会要求将庞大的 CSV 或 Excel 文件从其传统系统或手动流程加载到数据库，以进行数据驱动的分析。我知道，我们现在有很多解决这个问题的方案，像 pandas 、 dask 、 vaex python 库或 Informatica 等工具。
然而，学习不同的方法来解决问题陈述总是很有趣的。我们将使用 PDI 来解决这个问题，并使用 PostgreSQL 作为我们的数据库。这里的想法是优化利用我们的系统能力。我知道不是所有人都有内存优化服务器的特权。
如果你是数据管道建设过程的新手，那么我会推荐你看下面的故事。
通过使用 PDI 的真实用例，逐步构建您的第一个数据管道。
medium.com](https://medium.com/swlh/build-your-first-data-pipeline-in-just-ten-minutes-2a490867b901)
先决条件
用户故事
我喜欢首先为我们的问题陈述定义用户故事。这有助于我设计数据管道的高级架构。我们需要将问题分解成简单的小块。
- 我想读取包含数百万条记录的经济数据的巨大 CSV 文件。
- 我想用一个维度/主表对数据中的每个内容进行查找。
- 我想清理数据并删除空字段。
- 我想添加一个行级条件。如果状态栏包含“修订”一词，我想添加“_R”。
- 我想在 PostgreSQL 数据库中加载相同的。
我们试图通过增加一点复杂的数据操作来复制真实世界的场景。
输入数据
理解输入数据文件是一个很好的做法。现在，在我们的例子中，可能很难打开巨大的 CSV 文件并检查列和行。然而，我们可以通过一些方法来确定或检查样本数据。PDI 通过创建一个小的转换来读取样本数据和检查其他元数据。
在这里，我谷歌了“csv 格式的巨大数据文件”这个词，并从第一个网站下载了这个文件。下面是环节。
现在，我想让系统崩溃并创建巨大的文件；就像我们在处理大数据一样，对吗？下载的文件有66526 条记录，所以我多次追加相同的记录来创建一个巨大的文件，大约有11974697 条记录；是的，没那么大。
测试案例
定义测试用例在这里很重要，因为我们不能手工检查整个数据。我们需要确保，我们检查了足够好的样本数据来交叉验证准确性。
- 检查行数并与输入数据匹配。请注意，因为我们将删除空数据。存储这些空记录也很重要。
- 交叉验证至少 500 -1000 条记录的维度输出结果。
- 随机交叉验证计算结果，以检查准确性；至少一千张唱片。
步骤 1:项目的设置
我们为这个项目设置了一个非常简单的项目。只有一个目录和一个转换文件。
我喜欢在一个名为“work”的项目目录中创建所有与工作相关的项目；我知道，多有创意啊！我们需要执行以下操作:你可以跳过这一步。
- 创建我们的项目目录- LoadData。
- 在项目目录中创建一个目录“Input”。
- 在项目目录中创建一个名为“Main.ktr”的空转换。
项目目录结构
如果你不知道像转换或工作这样的词，那么我将推荐下面提到的故事。
[## Pentaho 数据集成(Kettle)及其组件入门。
了解勺子、平底锅、厨房等关键部件将使我们对 PDI 工具有更好的了解
medium.com](https://medium.com/ai-in-plain-english/getting-started-with-pentaho-data-integration-kettle-and-its-components-ef1e71101323)
步骤 2:创建数据库表
我假设您已经在这里安装了数据库。我们使用 PostgreSQL。
现在，我更喜欢使用 Django 模型创建表格。您不一定必须使用这种方法。
话虽如此，但通过编写 Django 模型而不是手动创建表和列，我们的生活变得简单了。Django models 使用简单的 migrations 命令为我们做到了这一点，并且还获得了开箱即用的 CRUD (创建、读取、更新和删除)功能。
你可以选择下面提到的两个选项来创建数据库和表。我已经创建了一个表 medium_db
- PostgreSQL 创建脚本。
— Table: public.economic_data — DROP TABLE public.economic_data;CREATE TABLE public.economic_data
(id integer NOT NULL DEFAULT nextval(‘economic_data_id_seq’::regclass),series_reference character varying(255) COLLATE pg_catalog.”default” NOT NULL,indicator_name character varying(255) COLLATE pg_catalog.”default” NOT NULL,period character varying(45) COLLATE pg_catalog.”default” NOT NULL,indicator_value numeric(30,10) NOT NULL,status character varying(255) COLLATE pg_catalog.”default” NOT NULL,
indicator_unit character varying(255) COLLATE pg_catalog.”default” NOT NULL,group_name character varying(255) COLLATE pg_catalog.”default” NOT NULL,series_name character varying(255) COLLATE pg_catalog.”default”,
CONSTRAINT economic_data_pkey PRIMARY KEY (id)
)TABLESPACE pg_default;ALTER TABLE public.economic_data
OWNER to YOURUSER;
- 运行迁移的 Django 模型脚本。
from django.db import models# Create your models here.class EconomicData(models.Model):**series_reference** = models.CharField(db_column="series_reference",max_length=255,help_text="Unique code to identify a particular record",verbose_name="Series Reference",)**indicator_name** = models.CharField(db_column="indicator_name",max_length=255,verbose_name="Name of the indicators")**period** = models.CharField(db_column="period",max_length=45,verbose_name="Period")**indicator_value** = models.DecimalField(db_column="indicator_value",max_digits=30,decimal_places=10,verbose_name="Value of the Field")**status** = models.CharField(db_column="status",max_length=255,verbose_name="Status of the value For eg, Final or Revised")**indicator_unit** = models.CharField(db_column="indicator_unit",max_length=255,verbose_name="Unit of the indicators")**group_name** = models.CharField(db_column="group_name",max_length=255,verbose_name="Group of the indicators")**series_name** = models.CharField(db_column="series_name",max_length=255,verbose_name="Series of the indicators"null=True)def __str__(self):return f"{self.indicator_name} - {self.value}"class Meta:db_table = "economic_data"verbose_name = "Economic Data"verbose_name_plural = "Economic Data"
如果你有兴趣了解我们如何从 Django 的数据管道中获益，请在下面的回复部分告诉我。
我们已经准备好桌子了。现在，让我们创造我们的转变。
步骤 3:加载程序转换
我们需要创建一个 loader 转换，它读取我们的输入 CSV，执行操作并将数据加载到数据库中。
我们需要打开 Main.ktr 文件并拖动一些插件，如下所述。
步骤 1:拖动步骤
- 首先，让我们添加一个关于转换的小描述。文档是任何数据管道的关键。
- 将“CSV 文件输入”、“数据网格”、“连接行(笛卡尔乘积)”、“用户定义的 Java 表达式”、“过滤器行”、“文本文件输出”、“表格输出”插件从“设计”选项卡拖到画布上。
- 按照我们的命名约定重命名字段。
重命名后的主要转换
步骤 2:配置属性
- 我们需要为上述每个步骤配置属性。让我们配置 CSV 输入步骤，我们需要在文件名字段中浏览我们的输入文件，并点击获取字段。我们可以根据内存可用性调整 NIO 缓冲区大小；它将分批处理文件，每批 50K 条记录。
- 我们需要在数据网格中添加数据(在这里复制一个表)。在这里，我们使用数据网格来表示数据。在真实的场景中，您将从一些维度表中获得这些数据。我们正在使组名标准化。你可以参考下面的数据截图。我们需要在元选项卡中添加列名，并在数据选项卡中添加实际数据。
- 在 Join rows 步骤中，我们需要将输入中的字段映射到我们的维度表/网格中。因为我们在这里映射组，所以我们需要添加条件来映射相同的组。
- 在用户定义的 java 表达式中，我们将配置自定义的行级条件。我们需要将我们的新字段定义为‘Series _ reference _ flag ’,如果状态列为‘Revised ’,这里我们要更改‘Series _ reference’字段并附加‘R’。在我们的 Java 表达式中，我们将添加以下条件——‘status = =‘Revised’？Series _ reference+" _ R ":Series _ reference '；这是 java 代码。我们可以执行类似的条件或计算，功能强大！最后，我们需要将值类型添加到‘String’中。
- 在筛选行步骤中，我们需要定义传递没有空值的记录的条件。
- 在文本文件输出(错误报告)中，我们需要添加文件名为 ’ ${Internal。entry . current . directory }/error _ report**'并将扩展名**改为‘CSV’。
- 在表格输出步骤中，我们需要创建一个新的连接来连接到我们的数据库。我们可以根据需要连接到任何数据库。我们在这里将连接到 PostgreSQL 有关连接的详细信息，请参考屏幕截图。我们需要浏览目标表到‘经济 _ 数据’。我们需要检查指定数据库字段的字段字段。然后，我们需要将输入/转换字段映射到表字段。
输入步骤配置
数据网格配置-维度
联接行配置
条件配置
过滤空配置
数据库输出配置
数据库映射
第四步:让我们加快进程
现在我们已经配置了属性，我们可以通过创建插入数据的多线程来加速这个过程。这将提高性能。PDI 为我们提供了按步骤配置多线程的工具。如果我们在输入步骤中使用它，它将成倍增加记录。然而，如果我们将它用于像数据库这样的输出步骤，它将分发记录。
PDI 为我们提供了许多优化性能的选项。我们可以执行以下步骤来提高性能。
- 在我们的输入步骤中更改 NIO 缓冲区大小，定义我们的批处理大小。
- 改变**最大值。高速缓存大小(行数)**在查找步骤中，定义它将存储在高速缓存中的行数，而不是查询数据库。
- 改变**提交大小，**类似于缓冲区大小改变批量大小来插入记录。
- 使用多线程来执行活动，我们可以添加一个虚拟步骤，并在输出步骤之前，右键单击选择根据我们的要求，将启动的副本数从 1 更改为 1 以上的任何值。
- 请注意，如果我们想要在表输出步骤上执行多线程，那么我们不能使用第四点。然后，我们必须在输出之前添加一个虚拟步骤，并且在多个输出表步骤中分配记录。
哇！我们有这么多的选择，我们应该改变所有的性能优化器吗？简而言之，答案是否定的。我们需要用样本数据进行尝试，并对最适合我们的方法进行多次测试。
第二步:评估
让我们在没有性能优化器的情况下运行这个流，然后通过应用优化器进行比较。
成功
步进矩阵——用了 8m 42s
添加了简单的优化器—20 倍的 on 条件和两个输出线程
步骤矩阵——花了 4m 35s
通过添加一些简单的性能优化器，我们将执行相同活动的时间减少了近 50%。
如果我们想读取多个文件，并创建一个循环来处理相同的文件，那么我会推荐你阅读下面的故事。
应用这个循序渐进的指南来解决问题，使用神奇的元数据注入 PDI。
towardsdatascience.com](/how-to-automate-multiple-excel-workbooks-and-perform-analysis-13e8aa5a2042)
结论
我们提出了一个问题陈述，并尝试使用多种方法解决它，还尝试优化它。理论上，您可以应用这个过程来满足您的需求，并尝试进一步优化它。PDI 也为我们提供了 PostgreSQL 批量加载器步骤；我也试过那一步。然而，这并没有提供任何显著的性能提升。
我们不能在一开始就优化代码/管道，必须执行多次测试才能获得理想的结果。然而，为了缩短学习曲线，你可以随时阅读我的经验，并通过使用下面的链接订阅我的电子邮件列表来找到问题陈述的解决方案。
[## WryteEx -使用真实世界用例寻找解决方案的平台
我写的博客涉及数据工程、金融、Python、Python Django、项目管理、Web 开发等等
wryteex.com](https://wryteex.com/)
下一篇文章再见。快乐的 ETL
如何解决旅行商问题——比较分析
行业笔记
通过 3 种优化方法:动态规划、模拟退火和 2-opt。
凯勒·琼斯在 Unsplash 上拍摄的照片
我相信你已经听说过旅行推销员问题或 TSP。这个问题有许多应用，也有许多具有不同性能的解决方案。在这里，我想分享一下我最近解决旅行商问题的经验，特别是用 2-opt 法 这是解决这个问题最简单也是最有效的方法之一。
如果你只是想了解 2-opt，你可以直接跳到这篇文章的末尾。您也可以使用我在下面开发的 Python 包来解决 TSP 问题。
在优化中，2-opt 是一种简单的局部搜索算法，具有特殊的交换机制，非常适合于求解复杂的优化问题
pypi.org](https://pypi.org/project/py2opt/)
在这篇文章里，我想分享我用 120 个城市去访问解决一个 TSP 的经验。这个问题必须在不到 5 分钟的时间内解决，才能用于实践。我的目标是用以下方法解决这个问题:
- 动态编程，
- 模拟退火，以及
- 二选一。
首先，让我简单解释一下 TSP。
[## 人工智能:非正统的教训:如何获得洞察力和建立创新的解决方案
亚马逊网站:人工智能:非正统课程:如何获得洞察力和建立创新的解决方案电子书…
www.amazon.com](https://www.amazon.com/gp/product/B08D2M2KV1/ref=dbs_a_def_rwt_hsch_vapi_tkin_p1_i0)
旅行推销员问题
旅行商问题是组合优化中的经典问题。这个问题是要找到一个推销员应该走的最短路径来遍历一个城市列表并返回到起始城市。提供了城市列表和每对城市之间的距离。
TSP 在现实生活中的各种应用中都很有用，比如规划或物流。例如，想要为乐队安排一系列演出的巡回音乐会经理必须确定巡回演出的最短路径，以确保降低旅行成本，并且不会使乐队不必要地筋疲力尽。
这是一个 NP 难问题。简单来说，就是你不能保证在合理的时间限制内找到最短的路径。这并不是 TSP 所独有的。在现实世界的优化问题中，您经常会遇到这样的问题，您必须找到次优解，而不是最优解。
旅行推销员问题
一、动态编程
动态规划或动态规划方法保证找到 TSP 的最佳答案。然而，随着城市数量的增加，其时间复杂度将呈指数增长。DP 方法的时间复杂度渐近地等于 N × 2^N，其中 n 是城市的数量。
为了给你时间复杂度增加的提示，让我分享我的实验。10 个城市的 TSP，用英特尔酷睿 i7 用 DP 法差不多 0.2 秒就能解决。在 15 个城市中，这个数字增加到几乎 13 秒(大约 60 倍)。也就是说，即使城市数量增加很少，时间复杂度也会显著增加。
为了优化 DP 方法，我可以使用记忆技术。然而，具有大量城市的记忆化技术需要一个 2^N × 2^N 矩阵，该矩阵不容易在存储器中处理。
建议- 如果要解决有大量城市的旅行商问题，动态规划方法不是最佳选择。DP 方法可以保证全局最优，但它需要大量的时间和计算能力，这是我们在现实世界问题中所不能承受的。
二。模拟退火
模拟退火或 SA 是一种启发式搜索算法，其灵感来自冶金工业中的退火机制。退火指的是一种控制的冷却机制，它导致材料达到期望的状态。但是，这如何映射到优化问题呢？
优化专家从退火机制中学到的经验是，与具有固定规则的梯度下降算法相反，对搜索过程实施更多的控制。SA 方法有两个主要规则，解释如下。
- 的移动方向必须在每一步中以概率的方式确定，希望不会陷入局部最优，并向全局最优移动。
- 搜索步骤在搜索过程向前推进并接近最终结果时，必须缩小规模。这有助于在早期积极行动，在后期谨慎行动。
在 SA 方法中，搜索过程必须继续，直到找到足够好的解决方案或达到停止标准。此外，该方法对其参数(包括搜索步长和移动方向)的制定和调整非常敏感。SA 方法是一种启发式搜索算法，因此，它对搜索空间中的初始点敏感。
我实现了 SA 方法并测试了几次。最后，由于执行时间有限，我无法获得比 2-opt 方法更好的结果。2-opt 方法执行得非常快。
建议- 模拟退火法的结果对其参数和停止准则很敏感。模拟退火法是一种强有力的工具。但是如果你想和它一起工作，确保你知道它的缺点。
三世。双选项
2-opt 算法是一个简单的局部搜索方法，带有一个作为启发式算法的特殊交换机制。2-opt 方法背后的主要思想是在城市的每一个邻近区域移除路径交叉。2-opt 可以很容易地实现并快速执行。比如 120 个城市的 TSP，在英特尔酷睿 i7 上用这种方法不到 5 秒就能解决。在这里，“已解决”意味着算法收敛到一个足够好的解，这是一个次优解。2-opt 方法收敛快，因为它与 SA 方法相反是确定性的。
使用随机初始点运行 3 次 2-opt 方法。停止标准是基于与最佳结果相比的改进比率来定义的。
这种方法类似于其他启发式搜索算法，不能保证找到全局最优解。2-opt 方法很容易陷入局部最优，因为它没有跳出局部最优的机制。知道了所有这些缺陷，这种方法在 TSP 中仍然工作得很好，因为它的启发式算法在这个问题中非常相关，非常有效。
在优化中，2-opt 是一种简单的局部搜索算法，具有特殊的交换机制，非常适合于求解复杂的优化问题
github.com](https://github.com/pdrm83/py2opt)
类似于其他启发式搜索算法的 2-opt 方法对其在搜索空间中的初始点敏感。这意味着不同的初始点会改变最终的结果。我使用了一个简单的技巧来解决这个问题，并改善 2-opt 方法的结果。我用不同的随机初始点运行该方法 10 次，并从中选择最佳结果。通过这种方法，我在一定程度上降低了对起点的敏感性。
**建议-**2-opt 方法容易实施，执行速度快。另外，它比预期的效果好得多，尤其是当你降低它对搜索空间中初始点的敏感度时。我强烈建议使用这种方法来解决 TSP，除非一个足够好的结果不适合你。
四。摘要
下面的视频很好的总结了这篇文章。你会喜欢看它的。
外卖食品
解决 TSP 的方法有很多。然而，上述方法是最常见的。我强烈推荐 2-opt 方法，因为它实现简单，执行速度快。然而，模拟退火方法是非常强大的，如果你可以适当地调整它，并且你没有时间限制找到最终结果。
最后一句话——当你想为包括 TSP 在内的任何问题找到一个解决方案时，总是要想一想像 2-opt 方法这样的简单技术是如何工作得很好的。为什么？因为它的启发式非常适合这个问题。
感谢阅读！
如果你喜欢这个帖子，想支持我…
[## 通过我的推荐链接加入 Medium—Pedram Ataee 博士
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
pedram-ataee.medium.com](https://pedram-ataee.medium.com/membership)
“你在用那张桌子怎么解决？!"问题
如何快速识别数据仓库中最关键的表格和报告
随着公司越来越依赖数据来推动决策和创新，这些数据的及时性、准确性和可靠性变得非常重要。当您考虑到全球每天产生的超过 7.5 万亿(77 亿)GB 的 数据中只有一小部分是可用的 时，跟踪哪些数据资产是重要的只会变得更加困难。
在本文中，我们将介绍 “关键资产】、 一些最优秀的数据团队采用的一种新方法，来展示您最重要的数据表和报告，以获得快速可靠的见解。
你有没有想出最奇怪的方法来命名“相关”的表，如“IMPT”或“使用这个 _V2”？数据仓库迁移已经进行了四分之三，您是否发现自己不知道哪些数据资产是正确的，哪些是错误的？您的分析团队是否迷失在电子表格的海洋中，看不到救生衣？
如果你对这些问题中的任何一个回答是肯定的，你并不孤单。在过去的几年里，我与数百个数据团队交谈过，他们对自己公司数据资产的潜力感到兴奋和不知所措，他们负责维护一个不断发展的数据资产生态系统。
我们称之为“你在用那张桌子？!"问题，而且比你想象的更普遍。
以下是你可能正在经历的三个迹象:
您正在迁移到新的数据仓库
就像水牛迁移穿过塞伦盖蒂平原一样，迁移到新的数据仓库可能是一个混乱而乏味的过程，让您的团队意识到数据(或水牛)不再适合或可用。图片来自Jan Rix on Shutterstock。
随着数据团队越来越多地从本地数据仓库转移到雪花、红移和其他云仓库，或者在云仓库之间转移，了解哪些数据有价值以及哪些数据可以像渡渡鸟一样变得越来越重要。
不幸的是，数据验证和交叉引用通常是手动处理的，成本高、耗时且难以扩展。一位客户是一家全球金融服务公司的数据团队负责人，目前正在迁移到雪花，他透露说，他们“正在手动将 Redshift 中的表映射到 Tableau 中的报表，这样我们就知道将什么迁移到雪花和 Looker 中。”
通常，当数据团队从 Redshift 迁移到 Snowflake 时，他们最终会求助于两个数据仓库中相同表的副本之间的手动差距分析，因为**“了解表下游的哪些报告将有助于我们确定迁移的优先级，或者废弃我们不再需要的表。”**
您公司的数据分析师和数据科学家不知道使用什么数据
数据团队的第二个也是最常见的痛点是不知道什么数据最有用，更不用说有用了。
如果你和你的团队问了以下任何一个问题，他们可能正处于一个连史酷比都无法解决的谜团之中。以下是常见数据发现问题的列表。也许他们会产生共鸣:
- 我应该使用什么数据？
- 我找不到我需要的数据，我该怎么办？
- 很难理解什么是我们的“重要数据”……帮帮忙？
- 谁在用这张桌子？这些数据重要吗？
当这些问题被频繁问及时，您的公司明显缺乏数据信任和数据发现，这对您公司利用数据作为竞争优势的能力造成了损害。
您有大量的“数据债务”
数据债务不仅仅是代价高昂；它会侵蚀用户的信任，导致糟糕的决策。图片由 Shutterstock 上的 baranq 提供。
像技术债务一样，数据债务指的是过时的、不准确的或者占用数据仓库中宝贵存储空间的数据资产。这种情况太常见了，即使是最先进的数据团队也会陷入困境，很难及时获得相关的见解。
数据债在实践中是什么样子的？这里有三个强有力的指标:
- 您的衣柜里有旧的数据框架(包括过时的、不准确的表和遗留数据类型)，团队可能会错误地使用它们。
- 您会收到不同作业和系统检查失败的警报，但它们都被忽略了，因为“事情总是这样。”
- 您已经更新了您的技术堆栈，迁移到了雪花，并且使用了最新的新工具，但不再利用相同的数据格式、数据表甚至数据源。
简介:关键资产
数据团队的任务是通过数据驱动的洞察来创建业务的可见性，但当涉及到他们自己的运营时，他们往往会盲目行事。相反，团队需要一个单一的视图来了解他们的数据的健康状况，这些数据是识别您的数据仓库中最关键的数据表和数据集的关键资产。
幸运的是，最好的数据可靠性和可发现性(目录)解决方案已经将它们集成到他们的产品中。通过利用机器学习，这些解决方案可以智能地映射您公司的静态数据资产，而无需从您的数据存储中提取数据，从而生成一个**“关键资产仪表板”**。
关键资产可能是:
- 许多人经常查询的表
- ETL 过程大量使用的数据集，用于派生其他数据集
- 为许多或常用仪表板提供信息的表格
- 具有重要下游依赖性的外部来源
但是团队如何识别他们的关键资产呢？在其他变量中，我建议团队寻找具有以下特征的表和数据集:
- 经常被访问(例如，每天 AVG 读取次数)
- 频繁更新(例如，AVG 每天的写入次数)
- 被大量用户使用
- 定期更新/使用(即，每个单独数据资产的< 1–5 days since latest update)
- Leveraged by a large number of ETL processes
- Supports connectivity, in other words is read-from/written-to many other data assets
- Experiencing a high data incident rate (over days/weeks/months)
- Queried recently/frequently by BI tools
Additionally, Key Assets should include an 【重要性分数】)。此分数是关于数据使用的关键指标的组合，表明哪些资产对您的组织最重要。分数越高，该资产越有可能成为您团队的重要资源。
虽然过于简单，但这个关键资产仪表板的呈现具有搜索功能，允许用户查找特定的资产，同时还可以根据统计数据(如每天的平均表读取次数和表用户总数)明确哪些资产是重要的，哪些资产可以折旧或清理。图片由作者(巴尔·摩西)提供。
利用关键资产实现数据信任和发现
随着 数据架构 变得越来越孤立和分散，我看到了关键资产和类似解决方案在优化数据发现和恢复数据信任方面的巨大潜力，包括:
促进更顺畅的仓库迁移
引领 数据仓库迁移 可能是一项既令人兴奋又令人畏惧的任务。通常，数据团队被迫手动处理数据验证。有了关键资产，团队可以自动识别哪些表正在使用和依赖，哪些表可以废弃，从而使这个过程更快。
更容易找到用于智能决策的重要数据
关键资产功能可以轻松找到重要数据，从而做出明智的决策。图片由作者(巴尔·摩西)提供。
很可能整个公司的分析师都在为阳光下(或者更确切地说，在你的仓库里)的每个数据集制作 v1、v2、v3 和 v4；当你在进行批判性分析时，发现并知道哪些是真正相关和重要的将会有很大的不同。如果用户还可以搜索特定的数据资产，则加分。关键资产支持这两种功能。
减少数据债务
关键资产使清理“垃圾”表和管道变得更加容易，通过突出显示哪些数据表被广泛使用，哪些已经过时甚至不准确，您可以减少数据仓库或湖中的数据债务。减少数据债务的传统方法严重依赖于代码密集型集成(即开源)或围绕工作流编排工具的临时 SQL 查询。关键资产提供了一种更简单、更快捷的方法来获取这些指标及更多信息。
实现端到端的数据可观察性
从摄取到分析，端到端的数据可观测性 是任何一个严肃的数据工程团队必备的。通过了解您的重要数据位于何处，以及它在管道的所有阶段是如何被使用的，已经被否决的表和数据集可以被忽略，关键表可以浮出水面。
通过机器学习自动生成关键资产
在我看来，一个智能但安全的关键资产仪表板应该自动生成，利用机器学习算法，通过拍摄数据生态系统的历史快照来学习和推断你的数据资产，而不是实际访问数据本身。
通过消除数据停机时间提高数据可靠性
自动生成的单一真实来源(如关键资产)是理解如何利用表的逻辑结论，可防止数据停机的影响在您的数据管道中显现。
使用关键资产，用户可以搜索并确定哪些数据资产需要密切监控以发现可能的异常或问题，哪些数据资产可以暂时搁置。这种解决方案可以帮助团队自动消除过时数据的嘈杂警报，并只监视业务部门经常使用的数据资产。
我不知道你怎么想，但我等不及“你要用那张桌子？!"问题已经成为过去。
想要识别您自己的数据组织的关键资产？ [蒙特卡洛](http://montecarlodata.com?utm_source=blog&utm_medium=medium&utm_campaign=key assets&utm_term=october) 可以帮忙。
如何在 Power BI 中按时间顺序排列月份
了解如何在 Power BI 中按时间顺序对月份字段进行排序
图片来自 Unsplash
在本文中，我将演示如何在 Power BI 中按时间顺序对月份进行排序。可视化一段时间内的销售数据是最有影响力的报告方式之一。通常，设计图表来显示指标随时间的趋势或增长是非常重要的。时间段可以是任何时间，例如几天、几周、几个月或几年。它基本上让您了解指标在特定时间段内是如何增加或减少的。
在 Power BI 中，您还可以按特定的选定时间段可视化您的指标。这通常通过绘制显示一段时间内趋势的折线图来实现，或者通过使用垂直条形图来显示该时间段内的特定指标，甚至简单地使用表格矩阵来以文本方式显示结果。出于本文的考虑，为了简单起见，我们将只考虑第三种情况，即表格矩阵。然而，同样的解决方案可以适用于任何类型的包含时间段的图表。
有时，当您将数据导入 Power BI 时，特别是如果您在原始数据源中有月或季度作为文本数据(来自平面文件的*，那么 Power BI 无法理解导入的字段是否是实际的日期字段(日/月/年等)。)或者只是简单的文本数据。在这种情况下，在导入后，月份或季度按字母顺序排序，而不是按时间顺序排序，这是一个错误，取决于需求和与开发趋势报告不太相关的东西。在这个解决方案中，我们将首先学习如何重现错误，然后了解如何对数据模型进行必要的更改以解决这个错误，并在 Power BI 中按时间顺序对月份进行排序。*
重现错误
让我们首先试着重现这个错误，然后我将解释如何在幂 BI 中按时间顺序排列月份。为了重现错误，我们需要创建一个简单的 CSV 文件，如下图所示。
图 1 — CSV 数据集
如上图所示，我们只有两个简单的列— 月和销售。月列出了从“1 月”到“12 月”的所有值以及相应的销售额值。一旦创建了 CSV 文件，下一步就是打开 Power BI 并将其连接到这个数据集。
打开 Power BI Desktop，按照以下步骤将该数据提取到 Power BI 数据模型中:
选择获取数据，并从出现的菜单中选择文本/CSV 。
图 2 —获取功率 BI 中的数据
浏览上一步刚创建的文件，点击打开。
图 3 —浏览数据集
在出现的下一个对话框中，验证数据并点击加载。
图 4 —将数据加载到 Power BI 模型中
您将看到数据已经加载到 Power BI 中。
点击可视化 窗格中的表格，将字段拖放到如图所示的表格中。
在创建的新表中，您可以看到月份现在按字母顺序排序。
图 5 —创建表格
在 Power BI 桌面中，选择转换数据，然后点击转换数据。
图 6 —转换数据
在打开的 Power Query Editor 中，导航到打开的 Add Column 选项卡。
选择自定义栏，输入公式，如下图所示。
对于自定义列的名称，我使用“ Date ”，因为该列将存储虚拟日期值。
在自定义列的公式中，使用以下内容:= " 1 " &[月] & " 2020"。
图 7 —添加虚拟日期列
因此，基本上，我们试图实现的只是创建一个虚拟日期值，方法是将“1”作为日期，将“2020”作为年份值添加到已经存在的月份中。
图 8 —增加了新的日期栏
下一步是将这个新字段 Date 转换为 date 数据类型。右键点击该列，选择更改类型，然后选择日期。
图 9 —改变数据类型
您可以看到该列的数据类型和值已经更改。
图 10 —更改了数据类型
我们现在将再添加一个自定义列，从该字段中提取月份数。点击添加列，然后点击自定义列。
提供字段名称为“月份号”，公式为“=日期”。月份([日期])”并点击确定。
图 11 —添加新的月份号列
现在，您将看到数据集中又添加了一列。
图 12 —增加了新的月份号列
我们将把这个字段的数据类型改为整数。右键点击月份号，选择更改类型，然后选择整数。
图 13 —将数据类型更改为整数
由于我们的数据模型中有了所需的字段 MonthNumber ，我们可以删除在前面的步骤中创建的虚拟日期字段。右键单击日期栏并选择移除。
最后，您可以通过导航到主页并选择关闭和应用来关闭 Power Query 编辑器窗口。
图 15 —关闭电源查询编辑器
在 Power BI 中选择按时间顺序排列月份的列
既然我们已经在数据模型中进行了必要的更改，以在 Power BI 中按时间顺序对月份进行排序，那么最后一步就是按照 MonthNumber 的升序对月份进行排序。请按照下面的步骤对月份进行排序。
点击左侧窗格上的数据选项卡。
选择月列，然后在上方工具栏的排序窗格中选择按列排序。
在出现的下拉菜单中，选择月份号并导航至报告选项卡。
图 16 —按月号排序
您现在可以看到，月份是按时间顺序而不是字母顺序排序的。
图 17——按时间顺序排列的月份幂 BI
此外，如果您想隐藏月份号字段，您只需右击它并选择隐藏。
图 18 —隐藏月份号字段
您将拥有原始 CSV 文件中的数据集，但月份是按时间顺序排序的。
图 19——以幂 BI 形式按时间排序的月份
结论
在本文中，我解释了如何在 Power BI 中按时间顺序对月份进行排序。我还提到了复制错误的步骤，然后提供了如何解决问题并最终获得预期结果的分步指导。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
