如何使用 Python 构建数据科学作品集网站
提高您的 Python 技能，同时构建您自己的数据科学组合网站。
作为一名数据科学家，你需要有一个组合网站，帮助你在一个地方展示你的项目和个人资料。你可能已经有了 Github 和 LinkedIn 页面，但不要指望潜在雇主会浏览你所有的代码和帖子来了解你更多。
建立一个作品集网站可以像使用 WordPress 或 GitHub 模板一样简单；然而，自己创建一个网站将有助于您在学习 Python 中的新事物的同时添加更多的定制功能。
虽然建立一个网站通常需要 Python 之外的知识，但我们不需要成为其他编程语言的专家来创建一个作品集网站。这就是为什么我决定做这个指南，向您介绍构建和部署您的数据科学组合网站所需的基本材料。
**Table of Contents** 1\. [Planning the Website](#1b64)
- [What to include](#2f09)
- [Get a Custom Domain Name](#4e22)
2\. [How to Build the Website](#b188)
- [Backends: Flask vs Django](#0d44)
- [Front End: Bootstrap (+ HTML, CSS, Javascript)](#c39a)
3\. [Deployment](#2aa5)
规划网站
包括什么
在开始写代码来建立你的作品集网站之前，花些时间来计划网站将会有哪些部分。确保你的作品集网站至少有下面列出的部分。
- 作品集 : 这将是网站最重要的页面。列出迄今为止你完成的最重要的数据科学项目。添加简短描述和源代码链接。如果你已经写了一篇关于这个项目的文章，那么包括链接。
- 关于我:这个部分将帮助人们了解你的技能、背景和任何与你相关的事情。
- 联系方式:您应该在这里添加一个表单，以便人们可以填写他们的姓名、电子邮件，并写消息与您联系。除此之外，您还可以将链接添加到您的 GitHub 和 LinkedIn。
如果您完成了许多数据科学项目，并且有很多关于您作为数据科学家的经历要写，则在每个部分创建一个页面，然后添加一个总结其他部分的登录页面。然而，如果你没什么可写的，那么一页纸应该足够包含前面提到的所有部分。
如果有必要，添加更多的部分，使您的投资组合网站脱颖而出。
获取自定义域名
域名是网站的位置。它是用户在浏览器窗口中输入的文本，用来访问一个网站；例如，Google 的域名是google.com。
虽然我们还没有建立网站，但至少你应该检查一下你想要的域名的可用性。有很多域名注册商，比如 GoDaddy 和 NameCheap，你可以在那里看到该域名是否可用。
万一域名可用，不要等到建好网站再去买，否则几周或几个月后可能就不再可用了。域名通常很便宜，所以万一出了问题，你不会损失很多钱。
如何建立网站
后端:烧瓶 vs Django
用 Python 构建网站的两个最流行的框架是 Flask 和 Django。Django 是一个高级 Python web 框架，它使开发者能够在没有第三方库和工具的情况下创建网站。相比之下，Flask 是一个微框架，它提供了 web 应用程序的基本功能。它旨在保持其轻量级的简单性和可扩展的使用。
你应该使用哪一种？这在很大程度上取决于你项目的规模。Flask 更适合较小的、不太复杂的应用程序，而 Django 是为较大的、更复杂的、高负载的应用程序设计的。
如果你想创建一个简单的投资组合网站，Flask 可能是最好的选择。它不仅更适合小项目，而且最容易学习。Flask 比 Django 更 Pythonic 化，因为 flask Web 应用程序的代码大多数时候比 Django 代码更显式。这使得 Flask 对于 Python 编码人员来说很容易上手。
也就是说，如果你计划创建一个更复杂的多功能网站，你应该使用 Django。此外，如果你对 web 开发感兴趣，学习 Django 可能更有价值，因为它比 Flask 更受欢迎。下面是我在 Google Trend 上对这两个框架在 5 年内进行的网络搜索比较。
图片来源:谷歌趋势
上图显示 Django 比 Flask 更受欢迎。也就是说，学习这些框架将帮助您提高 Python 技能。在这篇文章中，你可以阅读到这两个框架的更深入的比较。
YouTube 上有很多免费的 Django 和 Flask 课程。我亲自观看了这个完整的 Django 系列，从中你可以学习如何构建一个博客应用程序。在同一频道还有一个烧瓶系列。在学会基础知识后，我尝试的另一个项目是这个 Django 电子商务网站。完成这些课程后，你可以查看这个视频教程，它展示了一个非常基本的投资组合简历网站的介绍，因此你可以获得一些灵感，并开始建立自己的网站。
前端:引导(+ HTML，CSS，Javascript)
到目前为止，我们已经成功地建立了网站的骨架，但要使网站好看，我们需要使用其他工具。
Web 开发人员需要相当多的 HTML、CSS 和 Javascript 知识来创建一个网站；然而，如果我们的目标是创建一个基本的数据科学组合网站，我们可以使用 Bootstrap 节省几周时间来学习这些编程语言。
Bootstrap 是 HTML、CSS 和 JavaScript 工具的集合，用于创建和构建网页和 web 应用程序。使用 Bootstrap，我们可以专注于开发工作，而不用担心设计，并快速创建一个好看的网站。最重要的是，Bootstrap 是手机友好的，所以网站在手机上看起来仍然不错
这太棒了！多亏了 Bootstrap，我们不需要成为 JavaScript 或 CSS 方面的专家来让你的网站看起来更好(尽管我们仍然需要知道至少一些基础知识)。下面你可以找到一些基本的 Bootstrap 模板，你可以用在你的网站上。
确保你遵循我之前提到的 Django/Flask 免费课程。在那里，您将发现何时以及如何在您的代码中实现这些引导模板。
注意:正如我之前提到的，你至少应该了解 HTML、CSS 和 JavaScript 代码的基础知识。根据我的经验，HTML 的使用频率更高，所以可以考虑查看这个 免费 HTML 课程 。
部署
到目前为止，我们建立的网站只能在我们的本地机器上访问。很自然，我们想让所有能上网的人都能访问我们的网站，所以我们将使用 Heroku 来解决这个问题。
Heroku 是一个平台，允许我们轻松地部署和托管应用程序，而不需要我们自己手动设置一切。要使用 Heroku，你必须先创建一个账户。在这之后，你需要做一些事情来设置 Heroku。这个过程可能需要几分钟，所以请查看这个视频教程，一步一步地学习如何用 Heroku 部署您的 web 应用程序。
注意:虽然你可以用 Heroku 免费主持一个项目，但是如果 30 分钟内没有网站流量，他们会让你的网站进入睡眠状态。如果有人访问您的网站，它会在短暂的延迟后变得活跃。要避免这种行为，可以升级到 Heroku 的爱好计划。
就是这样！现在，您已经很好地了解了如何使用 Python 构建一个基本的数据科学组合网站。有了这个，你将能够定制你的网站，并学习我们用于数据科学的普通 Python 材料之外的东西。
与 3k 以上的人一起加入我的电子邮件列表，获取我在所有教程中使用的 Python for Data Science 备忘单(免费 PDF)
如何搭建数据和技术基础实现跨越
每当商业机会出现时，学会利用数据并迅速将其货币化。
图片来自 [Pixabay](http:// from ) (CC0)
我在数据库技术蓬勃发展的时候开始了我的职业生涯。甲骨文和赛贝斯 RDBM 是主流中的顶尖软件；随着市场上出现全新的在线分析处理(OLAP)和 ETL(例如，提取、转换和加载)工具，数据仓库刚刚开始出现。在那段时间，我们的工作很简单:开发、操作，然后维护。
今天，当您走进一个拥有十年或十年以上 IT 历史的成熟组织时，您会看到复杂的数据系统和迁移的困难。虽然数据和分析已经成为业务数字化的中心，但公司利用数据并实现其价值的速度越快，它获得的竞争优势就越大。实现这一目标需要新技术、新平台和新方法。特别是，一个可扩展的解决方案来跟上不断增长的数据量是一家大型公司的首要计划之一。然而，遗留系统不可能很快被取代。通常一个已建立的遗留系统需要数年时间才能被替换。IT 资源在维护现有系统的常规业务和创新与转型的持续需求之间捉襟见肘，因此出现了迁移浪潮。
一个组织的数据和分析路线图通常有 4 个阶段:首先是构建坚实的基础，然后是自动化和运营化；下一步是跟上业务需求，最后是将 it 转化为新的业务增长机会。问题是没有时间首先建立基金会，然后将其货币化，因为基金会的工作需要很长时间才能完成，而且似乎永无止境。沮丧的业务利益相关者不得不等到重大迁移完成，这可能需要几年时间。更糟糕的是，经过多年的努力，结果往往达不到预期。
许多人将技术债务和遗留系统比作徒步旅行者的背包。“背包”越轻，从长远来看，组织就能越快、越成功地完成技术之旅。这怎么可能，因为在过去十年中，遗留系统曾经是推动业务增长的引擎。这是可能的，但并不容易。下面总结了一个组织可以做的四个关键领域，以确保一个更轻的“背包”来利用数据，并在业务机会出现时快速将其货币化。
- 快速设计和实施，但要牢记长期目标
不管是采用敏捷还是开发 3 个月的 MVP，如果你是将来将新系统迁移到新平台的人，你还会做同样的事情还是用不同的方式？每个人都应该问自己这个问题，包括架构师、经理、数据工程师和开发人员。现代技术发展越来越快，各种供应商提供了许多选择。软件或工具可能在短短几年内变得无关紧要或可替代。迁移或改用新工具已经成为常态，而不是例外。
记住这一点，团队应该从一开始就记录每一个需求和业务规则，编写带有注释的好代码，最重要的是，设计一些简单且易于维护的东西，以便将来可以顺利迁移。在管理方面，值得集思广益和深思熟虑来设计整个组织的正确架构，并从一开始就避免部门孤岛。
虽然从产品的角度来看，使用敏捷方法开发 MVP 是可行的，但是我们仍然应该从长远的角度来设计和开发，以便从一开始就进行扩展。它包括小步骤和日常纪律，例如:
- 建立并遵循标准命名约定、标准文件夹结构
- 从头开始为事务表构建分区
- 设计架构和基础设施时考虑未来的增长和容量
- 建立流程和操作以确保未来的成功。
我们经常听说一个项目是在没有连贯的设计或标准的情况下仓促启动的。它可能会实现短期目标，但从长远来看却不能自我维持。令每个人沮丧的是，我们经常在三个月后发现改变为时已晚，因为这将需要额外的资源和努力——这就是技术债务是如何建立和积累的。为了避免技术债务，整个团队需要遵守纪律，并遵循他们所走的每一步标准。如果没有标准，那就创造一个，从长远来看会买下所有人。
2。因业务需求而创新，但不是为了追逐新技术
我们经常听到人们说他们需要建立一个新的系统来应用最新的技术，这可能是原因之一，但它应该不是主要原因。这项新技术可以提供更多的功能、更快的性能或可扩展的解决方案，但它不是灵丹妙药。许多新技术承诺的比他们目前能提供的更多。因此，评估每一项新工具或技术、进行概念验证、培训和学习、体验并最终构建一个成熟的解决方案都需要时间和精力。我们处在一个技术和工具发展越来越快的时代。当我们跳到一项新技术上时，另一项新技术很快就会出现。当我们最终在一项技术上成熟时，我们已经晚了另一个新浪潮也就不足为奇了。
众所周知，对于数据平台来说，重新设计成本高昂，成功率很低。数据库系统给了开发者和用户极大的灵活性，只要他们有权限，就可以做他们想做的任何事情。可以快速创建新的表或列；存储过程可以在几分钟或几小时内编写完成。所有这些对象都可以独立存在，不依赖于其他对象。随着时间的推移，许多对象变得过时，没有明确的所有者，业务逻辑被埋在许多脚本中。当新的资源加入进来以重新设计系统时，如果不理解数据和业务逻辑，他们就不能移动。这就是为什么重新设计或迁移整个数据仓库需要很长时间的原因。
考虑到这些因素，总是从真实的业务用例和计划开始新技术。在新技术通过审查并且组织的技能集和经验建立并成熟之后，计划使用分阶段的方法迁移遗留组件。赶上新浪潮永远不会太晚。最好的策略是保持现有平台的稳固，但要准备好迎接新的商机。换句话说，不要让业务等待；相反，从小处着手，使用新技术快速实施，以解决业务问题。
3。重塑应该成为常态，一切照旧
在过去的十年中，许多组织成功地构建了一个可扩展的系统。问题是，通过不断的增强，它一直保持着相同的架构。因为资源非常了解这个系统，所以他们会不断地用常规的增强来使业务需求适应当前的架构。对当前架构的不断增强和修补是积累技术债务的另一种方式。人们试图将新的业务需求融入到现有的架构中，而不是构建一个新的架构来更好地满足需求，并且从长远来看可以加速它。
相反，在我们有一个成熟的系统在生产中运行后，我们应该立即开始考虑更适合业务增长的下一代平台。换句话说，不要在十年后进行最后的大规模迁移，而是在 2-3 年内进行增量迁移。虽然在短期内可能需要付出更多努力，但好处是多方面的:
- 它迫使整体架构以模块化和解耦的方式设计。
- 通过正确的设计更多地关注业务需求，而不是通过其他方式将业务需求融入当前架构。
- 通过增量创新不断提高资源的技能和经验
- 避免需要大量预算的大规模迁移
- 业务涉众不需要等待新基础的建立。
以上所有的好处都和某个特定的技术无关。它是一种组织战略，是管理 It 预算、资源和规划的方式。然而，对于一个公司来说，保持领先地位以获得并保持其竞争优势是非常重要的。有了这个策略，再创造和基础工作之间不应该有界限，再创造应该变成“照常营业”迁移变得越来越小，越来越增量，并且在微观尺度上执行。因此，企业不需要等待构建基础或进行多年迁移来实现业务增长。
4。为合适的工作培养和利用合适的人才
我们经常观察到，一家公司需要从外部招聘，以启动从当前遗留系统的大迁移，并引入具有创新经验和技能的新人才。那些在过去十年中为最初的创新做出贡献并建立了最新技术的人一直坚持使用当前的系统来不断增强和维护它。他们的日常工作从最初令人兴奋的设计和开发变成了重复但高效的增强和操作工作。
如果我们不断根据业务需求进行再发明，这些人才将会不断学习和积累新的技能和经验。这对公司来说是一笔极好的投资，因为这些有经验的人对业务逻辑了如指掌，并且能够比公司的新人更快地创造出新的解决方案。不断的创新也带来了不断学习和改进的新文化。也就是说，一个组织应该从一开始就确定合适的人才类型。某些人才非常擅长新的想法和承担风险，而其他人则擅长通过建立标准和流程来完善系统。这两者对于组织的 IT 和数据战略的成功同样重要，并且应该因为他们的成就而得到认可。
结论
在 20 世纪 90 年代，微处理器公司英特尔因每两年重新发明和更换一代芯片以赶上摩尔定律而闻名。因此，当时没有人能超越其市场第一的位置。对于 IT 和数据组织，我们也应该采取“英特尔”的方法，不断创新。随着当今技术领域的快速发展，企业不能等待 it 部门花多年时间来构建基础。每当业务需求或机会出现时，就应该设计、增强和构建基础。预先创建基础工作的传统方式已经过时了。创新是基础工作的一部分，所有的基础都可以逐步扩展或替换。这将要求一个组织的战略、预算规划和资源管理发生重大转变。它还需要高度组织化和纪律性的团队，他们建立并遵循标准的每一步。最终，它会带来文化变革，培养基于业务需求的不断学习和创新，从而推动业务增长。
如何使用 Python 构建数据库
使用 Flask-SQLAlchemy 库实现您的数据库，而不处理 SQL
泰勒·维克在 Unsplash 上的照片
介绍
SQLAlchemy 是一个 Python 库，用于实现 SQL 数据库，而不使用 SQL 语言本身。换句话说，您需要做的就是使用 Python 语言实现您的数据库。
SQLAlchemy 是一个用于连接 Flask 项目中的 SQLAlchemy 库的库，它使您的数据库实现比以往任何时候都更容易。本文将向您展示如何使用 Flask-SQLAlchemy 库构建您的数据库。
没有进一步，让我们开始吧！
数据库ˌ资料库
在我们开始实现之前，让我向您解释一下数据库。什么是数据库？数据库是相互集成的数据集合，我们可以使用我们的计算机访问它。
在数据科学中，您可能会以电子表格的形式插入和分析数据。在软件开发领域，就有点不一样了。让我们来看看这个电子表格。
该图像由作者捕获。
在电子表格中，我们可以看到有两列。有书名和作者的名字。如果您查看 author 列，您会看到有些值重复了几次。这种情况我们称之为冗余。
将整个数据集用作一个表并不是最佳做法，尤其是对于那些想要构建网站或应用程序的人。相反，我们必须分离表，我们称之为规范化。
总之，规范化过程会将数据集分成几个表，每个表都包含唯一的标识符。我们将把每个标识符称为主键。如果我们分离上面的数据集，我们将得到如下所示的数据集:
该图像由作者捕获。
从上面可以看到，数据集已经被分成两个表。有图书表和作者表。作者的名字在作者表上。因此，我们不能像在电子表格中那样直接访问名称。
为了检索作者的名字，我们必须通过从 author 表中获取 id 来连接 Book 表和 Author 表。我们将作者的 id 作为 Book 表的外键。
也许这很复杂，但是如果你开始实现一个构建应用程序的数据库，它将提高你的应用程序的性能。
履行
安装库
在我们开始实现之前，我们需要做的第一件事是在我们的计算机中安装这个库。要安装它，我们可以使用 pip 来完成。以下是安装库的语法:
要加载库，我们可以调用下面的语法:
正如您从库的名称中所知道的，我们还需要加载 Flask 库。
启动数据库引擎
加载库之后，下一步是设置 SQLAlchemy 对象和数据库的路径。默认情况下，SQLAlchemy 附带 SQLite 软件。
SQLite 是一个数据库管理系统，我们可以在其中建立和分析我们已经建立的数据库。您可以使用其他 DBMS，如 MySQL、PostgreSQL 或您喜欢的任何 DBMS。要设置我们的数据库，请添加以下代码行:
这段代码将初始化 Flask 和 SQLAlchemy 对象，我们设置一个包含数据库路径的参数。在这种情况下，数据库路径是 SQLite:///C:\ \ SQLite \ \ library . db。
实现数据库
设置好对象和参数后，我们就可以开始实现数据库了。让我们回忆一下上面的数据库表:
该图像由作者捕获。
从上面可以看到，上面有两张桌子。每个表都有自己的类，我们可以在其中初始化列名和表之间的关系。我们将继承一个名为 Model 的类来实现我们的表。根据上图，代码如下所示:
插入值
创建类之后，我们可以构建数据库。要构建数据库，您可以访问终端并运行以下命令:
现在让我们尝试在我们的表上插入值。对于这个例子，让我们输入上面的电子表格中的数据。您可以按照下面的代码插入值:
查询该表
在表中插入值后，现在让我们运行查询来查看数据是否存在。下面是实现这一点的代码:
从上面可以看出，我们的提交是成功的。好吧，这仍然是一个介绍，但我希望你能掌握这个概念，并在一个更大的项目上实施它。
附加:SQL 查询
除了 Flask-SQLAlchemy 库之外，我还将向您演示如何使用本地 SQLite 访问数据库。我们这样做是为了确保已经在上面创建了数据库。要访问 SQLite，您可以打开终端并编写以下脚本:
**sqlite3**
之后，它会这样显示 SQLite 的界面:
该图像由作者捕获。
在下一步中，您可以使用。打开命令，将路径添加到数据库，如下所示:
**.open absolute//path//to//your//database.db**
为了确保我们已经打开了数据库，请写信。终端上的表格是这样的:
**.tables**
它会产生这样的结果:
该图像由作者捕获。
很好，有用。现在让我们尝试使用 SQL 语言来查询我们的数据库:
**SELECT * FROM books**
这是结果:
该图像由作者捕获。
现在让我们试着将两个表合二为一。您可以在终端上编写这行代码:
**SELECT Book.title, Author.name FROM Book
INNER JOIN Author ON Book.author_id = Author.id;**
这是结果:
该图像由作者捕获。
结束语
干得好！现在，您已经使用 Flask-SQLAlchemy 库实现了您的数据库。我希望这篇文章能帮助你在项目中实现数据库，尤其是当你想用 Flask 构建一个 web 应用程序的时候。
如果你对我的文章感兴趣，你可以在媒体上关注我，或者订阅我的时事通讯。还有，如果你有什么问题或者只是想打个招呼，你可以在 LinkedIn 上关注我。
谢谢你看我的文章！
如何使用 Python tweepy 从 Twitter 构建数据集
数据收集
一个快速教程和一个现成的脚本来提取推文
在本教程中，我解释了一个使用tweepy Python 库从 Twitter 提取数据的非常简单的过程。代码可以从我的 Github 库下载。
具体来说，我将实现一个策略，用#新冠肺炎标签提取前一天的推文，并实现每日提取的自动化。
您可以修改这段代码来提取其他标签。输出数据集如下所示:
作者图片
它包含文本、推文的收藏计数、转发次数和创建日期。
该软件的体系结构由以下元素组成，如下图所示:
- Twitter 应用程序
- 获取推文
- Cron 作业(配置为 crontab)
作者图片
Twitter 应用程序
首先，我需要在 Twitter 开发者网站上注册一名 Twitter 开发者。如果我有一个 Twitter 账户，我可以使用它。我应该单击“Apply ”,然后按照向导进行操作。创建我的 Twitter 开发人员档案后，我可以进入 Twitter 仪表盘并选择项目和应用:
作者图片
我创建了一个新应用程序:
作者图片
我跟随巫师。在向导结束时，我将提供的秘密注册在一个单独的文件中，名为config.py。该文件应该如下所示:
TWITTER_CONSUMER_KEY = 'PUT HERE YOUR API KEY'TWITTER_CONSUMER_SECRET = 'PUT HERE YOUR API SECRET'
向导结束时，新应用程序会出现在左侧的“项目和应用程序”标题下
作者图片
我点击新应用程序，然后点击关键符号:
作者图片
然后我生成访问令牌和密码，并将它们注册到config.py文件中。
TWITTER_ACCESS_TOKEN = 'PUT HERE YOUR ACCESS TOKEN'TWITTER_ACCESS_TOKEN_SECRET = 'PUT HERE YOUR SECRET TOKEN'
获取推文
我可以将 Get Tweet 脚本实现为 jupyter 笔记本，然后我可以将其下载为 Python 脚本。
这个脚本提取了与前天(昨天)相关的带有#新冠肺炎标签的所有推文，并将它们保存到一个. csv 文件中。我用的是tweepy库，可以用pip install tweepy命令安装。
首先，我导入名为config.py的配置文件，它必须位于这个脚本的同一个目录中。
from config import *
import tweepy
import datetime
我通过使用OAuthHandler()类和它的access_token()函数建立了到我们 Twitter 应用程序的连接。然后我通过API()函数调用 Twitter API。
auth = tweepy.OAuthHandler(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET)
auth.set_access_token(TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET)
api = tweepy.API(auth,wait_on_rate_limit=True)
现在我安排约会。我需要设置今天和昨天。
today = datetime.date.today()
yesterday= today - datetime.timedelta(days=1)
我使用Cursor()功能在 Twitter 上搜索推文。我将参数api.search和查询字符串传递给游标，查询字符串是通过游标的参数q指定的。查询字符串可以接收许多参数，例如以下(非强制)参数:
from:-指定特定的 Twitter 用户资料since:-指定搜索的开始日期until:-为了指定搜索的结束日期，光标还可以接收其他参数，如语言和tweet_mode。如果tweet_mode='extended'，则返回 tweet 的所有文本，否则只返回前 140 个字符。
tweets_list = tweepy.Cursor(api.search, q="#Covid-19 since:" + str(yesterday)+ " until:" + str(today),tweet_mode='extended', lang='it').items()
现在我循环遍历tweets_list，对于每条推文，我提取文本、创建日期、转发次数和收藏数。我将每条推文存储在一个名为output的列表中。
output = []
for tweet in tweets_list:
text = tweet._json["full_text"]
print(text)
favourite_count = tweet.favorite_count
retweet_count = tweet.retweet_count
created_at = tweet.created_at
line = {'text' : text, 'favourite_count' : favourite_count, 'retweet_count' : retweet_count, 'created_at' : created_at}
output.append(line)
最后，我将output列表转换为pandas DataFrame列表，并存储结果。第一次运行这个脚本时，我使用了没有任何其他参数的to_csv()函数。从第二次开始，我应该添加以下参数:df.to_csv(‘output.csv’, mode=’a’, header=False)，以便将结果追加到先前存储的输出中，并避免重写头。
import pandas as pddf = pd.DataFrame(output)
df.to_csv('output.csv')
现在，我可以通过在 jupyter 中选择相应的菜单来下载 Python 代码作为.py 脚本。
作者图片
Cron 作业
cron 作业是调度一些重复性操作的一种方式。在这个例子中，cron 作业用于每天下载前一天的 tweets。
它要求运行 cron 作业的机器在将要运行 cron 作业时打开。
如果您有一台 Linux/Mac OS 计算机，您可以按照以下过程来配置 cron 作业:
- 打开终端并键入
crontab -e
该命令打开一个文本编辑器来插入、修改或删除一个任务 - 每个任务必须包含执行的时间和日期。顺序是分钟、小时、一月中的某一天、一月、一周中的某一天。您可以使用*来表示所有值
- 用
00 01 * * * python /<path_to_file>/get_tweets.py
插入新的一行。这将在每天凌晨一点运行脚本一次。
如果你有一台 Windows 10 机器，你可以按照这篇文章.&text=This%20will%20open%20a%20window,Server%202016%20or%20Windows%2010.)中描述的步骤来配置 cron 作业。
现在 Twitter 提取器已经准备好了！好好享受吧:)
摘要
在本教程中，我演示了如何通过 Python tweepy提取 tweets。这个过程需要三个步骤:Twitter 应用程序设置、代码编写和 cronjob 设置。
当您想要提取多个 hashtag 时，也可以使用所描述的机制。您可以简单地在查询字符串中添加您想要的所有标签。
如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。
相关文章
https://medium.com/analytics-vidhya/how-to-extract-multiple-tables-from-a-pdf-through-python-and-tabula-py-6f642a9ee673 https://alod83.medium.com/how-to-extract-data-from-a-search-engine-through-python-and-selenium-35dfe6b20db https://betterhumans.pub/6-tips-for-extending-your-knowledge-with-twitter-af2bc8c16bdb
保持联系！
如何建立一个分散的数据平台
一个数据工程团队通过端到端数据信任平衡自助服务平台需求的方法。
数据平台 让数据变得比以往任何时候都更容易访问和操作——假设你可以信任它。下面是 Auto Trader 的数据工程团队如何构建一个兼顾分散数据所有权和可靠性的数据平台。
总部位于曼彻斯特的 汽车交易商 是英国和爱尔兰最大的数字汽车市场。对于汽车交易商来说，将数百万买家与数千卖家联系起来需要大量数据。
该公司每月有 2.35 亿次广告观看和 5000 万次跨平台访问，每分钟有数千次交互，汽车交易团队可以分析和利用所有数据点来提高效率、客户体验，并最终提高收入。从广告优化到报告，再到 ML 动力汽车估价，数据也为业务成果提供动力。
对于首席开发者 Edward Kent 和他的数据工程团队来说，收集和处理如此大量的数据绝非易事。最近，数据团队一直专注于两项关键任务。
“我们希望让汽车交易商及其客户能够做出基于数据的决策，”Edward 说，“并通过自助服务平台实现数据访问的民主化。”
这些雄心勃勃的目标与向基于云的现代数据架构的迁移不谋而合，这意味着 Edward 和他的团队必须同时让更多团队更容易访问数据，同时建立对数据质量的信任。毫无疑问，这是一个不小的成就。
挑战:建立信任和支持自助数据
“随着我们将可信的内部系统迁移到云，这些旧系统的用户需要相信新的基于云的技术与他们过去使用的旧系统一样可靠，”Edward 说。
如今，Edward 和他的团队拥有强大的数据堆栈。他们通过 Kafka 和 Fivetran 接收数据，在 Apache Airflow 中处理编排和调度，在 BigQuery 和亚马逊 S3 中存储数据，使用 dbt 和 Apache Spark 进行建模，使用 Databricks 进行数据科学记事本，并通过 Looker 向内部消费者提供表面数据。
这些数据吸引了很多眼球。超过 500 名活跃用户(超过所有汽车交易商员工的 50%！)每个月都会登录并使用 Looker 中的数据，包括财务报告等复杂、备受瞩目的数据产品。当然，随着海量数据和多层技术堆栈的出现，数据管道出现故障的机会也越来越多，而这些事件几乎总是由 500 个数据消费者中的一个首先注意到。
Edward 和他的团队需要解决 数据宕机 (他们的数据不完整、错误或不准确的时间段)以提高信任度，但与此同时，这也成为了公司其他部门的瓶颈。他们的数据工程师集中团队处理与数据运营相关的一切事务，从构建新管道和报告的请求，到调查数据质量问题的紧急电话。这种方法无法扩展，并导致请求积压，这促使 Edward 和他的团队制定了一项计划，为企业消费者构建一个抽象的自助式平台，供他们自己使用。
“我们不希望让一个数据团队做所有的事情，而是希望给团队平台级的能力和自主权来构建他们自己的数据产品，”Edward 说。“理想情况下，我们希望让团队管理数据管道生命周期中的一切。所以从摄取到建模到报警，等等。因此，在这种背景下，我们希望将数据可观察性作为一种平台功能来提供。”
解决方案:分散数据所有权
图片由爱德华·肯特提供。
为了实现数据信任和分散数据责任，Auto Trader 希望在 BigQuery 和 Looker 之上添加一个监控、警报和沿袭层，big query 和 Looker 是其数据堆栈中可见性最高的层。
“对我们来说，现在比以往任何时候都更重要的是，我们提供的数据是正确、准确和最新的，”Edward 说。
Auto Trader 使用自动化数据可观察性对 BigQuery 中的所有表执行容量和新鲜度检查，以及模式更改警报。Edward 的团队还在几十个关键表中选择了一套 ML 驱动的统计检查，从而轻松获得列级置信度，而无需定义阈值的繁琐过程。这种方法还帮助他们了解了数据中的所有依赖关系。
“我们发现很难理解 BigQuery 中的哪些表出现在 Looker 的哪些报告中，反之亦然，”Edward 说。“跨这两个系统的自动血统跟踪对我们来说非常强大。”
结果:建立信任的事件跟踪
在迁移到云之前，当内部消费者向他们发送关于看起来不太正确的 Looker 报告的松散消息时，数据工程团队会发现数据质量问题。
图片由爱德华·肯特提供。
然后，数据团队必须 a)调查是否存在真正的问题；b)尝试确定 的根本原因；c)找出哪些表或仪表板在下游，哪些消费者会受到影响；d)最后，跟踪并通知相关的利益相关方，告知他们发现了问题，估计问题何时会得到解决，并在问题解决后再次跟进。
爱德华将这一过程描述为“被动的、缓慢的、不可扩展的”
现在，当检测到可能的事件时，Edward 的团队会收到延迟通知。
图片由爱德华·肯特提供。
由于自动化的端到端沿袭，他们可以更快地调查问题，这有助于数据工程师了解可能的上游和下游影响，直到现场级别，并提供对新鲜度、量和分布变化的可见性，这有助于他们查看更新模式并注意可疑的变化。
图片由爱德华·肯特提供。
沟通也是精简的。Edward 的团队不需要追踪利益相关者——再次使用沿袭——并且可以向相关团队的 Slack 通道发送关于问题和解决方案的通知。
图片由爱德华·肯特提供。
随着自动化监控和警报的实施，以及 lineage 加快了事件解决的速度，数据工程团队通过在下游消费者发现问题之前主动解决数据问题，与利益相关方建立了更大的信任。
结果:可扩展的监控和对“未知的未知”的可见性
Edward 还将机器学习动力监控归功于他们的分散式方法。
“为了开始获得价值，我们不需要知道我们需要监控什么，”Edward 说。“我们的 ML 可以开始寻找模式，并提醒我们任何异常和偏离这些模式的情况。”
图片由巴尔·摩西提供。
例如，他们的数据可观察性平台在一个很少删除的表中发现了 150，000 行的意外删除。一名数据工程师能够深入到 UI 中，并注意到一个通常只看到添加的表被删除了。使用沿袭跟踪，他们可以查看数据的上游是什么，看到它是通过 ETL 从外部来源进入的，然后去与数据所有者核实，看看这是否合法和有意的，或者是否有什么地方出错了。
“在这种情况下，不需要采取任何行动，”爱德华说。“但知道我们的数据正在发生这种事情真的很有价值，因为这给了我们信心，如果真的有问题，我们会以同样的方式发现它。”
数据工程团队使用定制的 SQL 规则和 dbt 进行手动测试，但由于其数据的规模，依赖数据可观察性作为其平台的基石，因此他们可以捕捉“ 未知的未知的 ”。
“无论是自定义 SQL 规则还是 dbt 测试，您都必须进行预先配置，”Edward 说。“你必须事先知道你要监控的是什么，并经历设置它的过程。对我们来说，我们每天都要定义数百个数据模型和构建数百个表。我们想要的是能够有效地启动并运行的东西，而不需要我们付出努力。模式检查、卷检查、新鲜度检查都可以做到这一点。”
成果:增强汽车交易商的自助服务数据平台
图片由爱德华·肯特提供。
这种新方法还支持汽车交易商向分散的自助式数据计划过渡，而不会影响数据质量。
在这种新模式下，分散的警报被发送到适当的团队警报通道。Edward 和他的团队要求将数据所有权和警报与 dbt 中的其他属性一起定义为元数据。yaml 文件，因此拥有特定数据集的产品团队将自动接收到他们自己渠道的警报。
图片由爱德华·肯特提供。
“分散的数据所有权意味着分散的数据质量责任，”Edward 说。“数据可观察性有助于我们提供这种平台能力。”
汽车交易商分散数据所有权的影响
随着汽车交易商寻求在开放访问的同时建立对数据的信任，数据可观察性是确保数据保持准确和可靠的关键。
“我们对数据的了解比以往任何时候都要多得多，”Edward 说。“以前，这些问题中有许多会被数据消费者发现并报告，但现在却被标记出来。从跟踪的角度来看，这种可见性对我们非常重要，因为我们正在向一个分散的数据平台迈进。”
对学习如何构建更可靠的数据平台感兴趣？把手伸向巴尔摩西和其余的 蒙特卡洛团队 ！
特别感谢 Edward Kent 和 Auto Trader 的数据工程团队的其他成员！
如何用 Python 构建数字双胞胎
思想和理论
锂离子电池数字孪生的 Python 实现
图片由 Pedro Figueras - Pexels 提供。哈维尔·马林插图。
在本教程中，我们将展示如何用 Python 创建一个简单而实用的数字孪生体。锂离子电池将是我们的有形资产。这个数字孪生将使我们能够分析和预测电池行为，它可以集成到任何虚拟资产管理工作流程中。
虚拟系统和数字双胞胎
D 数字双胞胎是工业 4.0 的重要组成部分。其基本原理是在虚拟世界中复制物理资产，以便对其动态进行建模。想象一下，我们在城市水管网的某个地方有一台水泵。水泵消耗能量，并以水流和压力的形式释放出来。术语“复制品”指的是能够模拟这种行为的虚拟对象的创建。
该泵是整个水管网系统的一部分，还有管道、阀门、仪表和其他附件或子系统。这些子系统都是相互联系的。虚拟化系统需要对所有子系统进行同样的操作。之后，我们可以模拟整个系统，包括它的依赖关系。虚拟系统的目标是模拟现实世界，以便引入变更、评估性能或预测该资产或子系统所涉及的场景(例如维护任务)。
如前所述，数字孪生是代表一个子系统的虚拟对象。这个“双胞胎”应该和它的“物理双胞胎”一样对输入变量做出反应。这个虚拟对象必须集成一个模型才能做到这一点。数字双胞胎最重要的特征是一个可以在数字环境中模拟“物理”行为的模型。请记住，当我们说“物理”时，我们指的是任何真实世界的实体(可以是锂离子电池、水泵、人、城市或猫)。任何可以建模的东西都可以被虚拟化(图 1)。
**图一。**通过模型从物理世界到虚拟世界。图片作者。
ba 电池上锂-i 的数字模型
可充电锂离子电池是一种尖端的电池技术，其电化学依赖于锂离子。除了便携式技术设备之外，这些电池对于电动汽车和配电网络中的能量存储等应用来说也是重要的资产。这些电池最关键的方面是它们的老化成本。经过反复充放电循环后，电池的电池会退化，导致充电容量减少。这种现象一直是开发更持久电池的关键研究领域。它的建模同样也是一个有争议的话题。电池退化对上述技术规划和操作具有重要影响。
电池寿命下降的物理过程相当复杂。近年来，人们提出了一些测量电池寿命损失的半经验锂离子电池退化模型(Chu et al .，2018；Laresgoiti 等人，2015 年)。报废电池通常被描述为只能提供其额定最大容量 80%的电池。使用其中一个经验模型(Chu 等人，2018 年)，这种退化可以写成如下:
**方程式 1。**电池续航时间。
其中𝐿是电池寿命，是初始电池寿命， d 是每单位时间和每循环的线性化退化率(Chu 等人，2018)。该速率可以写成是放电时间- 𝑡、*放电循环深度-δ、*平均充电循环状态- σ 和电池温度-𝑇𝑐.的函数
方程式 2 。线性化降解速率。
实验数据
我们的模型必须根据我们掌握的信息来预测电池寿命。但是，我们希望将该模型与测量值进行比较，以确定我们的模型的准确性。让我们暂停一会儿。
许多数字双胞胎并不基于精确的物理模型，只使用实验数据集和机器学习算法。这是一种非常酷的做事方法。例如，他们可以使用深度神经网络建立一个模型来捕捉数据的真实动态。然而，为了获得可靠的通用模型，将该模型推广到其他对象需要处理大量样本。另一方面，当处理物理模型时，我们需要较少的数据来获得准确的通用模型。
我们将利用锂离子电池充放电循环的真实数据来构建我们的数字双胞胎。我们将使用美国宇航局艾姆斯预测卓越中心(PCoE)提供的锂离子电池老化数据集。这个数据集对于确定我们的物理模型的准确性和改进它将是有价值的。我们将使用与 5 号电池相关的数据。我们将绘制出*“容量”*特征与循环次数的关系，并将其与我们的物理模型进行比较。在我们开始之前，我们将用变量𝐿( 电池寿命代替 C ( 电池容量)。等式 1 将被写成如下:
其中，𝐶是电池容量，𝐶_0 是初始电池容量。对于𝑓𝑑，我们使用了以下近似值:
其中，𝑖是充电-放电循环，𝑇𝑐是循环期间在电池中测量的温度，𝑡𝑖是放电时间，𝑘和经验常数的值为 0.13 。
图二。实验数据与我们的半经验模型的比较。图片作者。
图 2 展示了结果。我们的模型精确地预测了观察值(我们得到平均绝对误差——MAE 为 0.004)。该模型应该收集电池容量行为，其中容量在第一个循环期间缓慢降低，然后在特定点之后加速。这些变化是微妙的，许多工程师利用简单的线性模型来近似这种行为。我们的模型是半经验的，包括各种调整以避免处理 PDEs ( 偏微分方程)。
构建混合数字双胞胎
我们可以用我们的“模型”来直接创建一个数字双胞胎。但是，为了应用机器学习，我们将使用它来改进我们的模型，使用来自 NASA 数据集的实验数据。我们的建议如图 3 所示。
**图 3。**创造混合数字双胞胎。图片作者。
我们正在使用实验数据改进我们的数学，并使用神经网络改进我们模型的输出。
**#Define inputs and outputs****# input: the simulation capacity**
X_in = (dfb['C. Capacity'])**# output: difference between experimental values and simulation** X_out = (dfb['Capacity']) - (dfb['C. Capacity']) X_in_train, X_in_test, X_out_train, X_out_test = train_test_split(X_in, X_out, test_size=0.33)
我们使用一个非常简单的神经网络:
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(1,)))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))
编译:
epochs = 100
loss = 'mse'
model.compile(optimizer = SGD(learning_rate=0.001),
loss=loss,
metrics=['mae'], **#Mean Absolute Error** )
history = model.fit(X_in_train,
X_out_train,
shuffle=True,
epochs=epochs,
batch_size=20,
validation_data=(X_in_test, X_out_test),
verbose=1)
比较的结果:
图 4 。模型结果与实验结果的比较。图片作者。
正如我们在图 4 中看到的，神经网络学习了我们的数学模型和实验结果之间的差异的基本理解。现在我们可以把这种学习加入到我们的数学模型中来改进它:
**# Our digital twin by improving our model with experimental data**
X_twin = X_in + model.predict(X_in).reshape(-1)
仅此而已。我们有我们的数字双胞胎(或混合双胞胎):
- 我们创造了一个物理模型(或数学模型)
- 我们将我们的模型与实验数据进行了比较。
- 通过这种比较，我们能够改进我们的模型。
最后，在我们的虚拟环境中，我们有一个这种电池的“双胞胎”,预计其性能与现实世界中的电池相似。接下来，我们将对比我们的数学模型和数字模型:
图 5 :数学模型与“混合”数字孪生的最终比较。图片作者。
图 5 显示了我们的数字孪生兄弟如何适度地改进了我们的模型。混合数字孪生的好处是，它允许我们采用半经验的数学模型，并使用实验数据来完善它。它具有优于两者的优点，一个是特别的数学模型，因为它可以改进，另一个是 ML 模型，因为它更通用(因此可以应用于例如其他电池，获得比单独的 ML 模型更好的精度)。
预测
通过我们的数字孪生兄弟，我们可以做出预测，以便操作锂离子电池。
**图六。**使用数字双生子和数学模型进行预测。图片作者。
结论
数字双胞胎是工业 4.0 领域的新兴话题。我们已经展示了如何使用 Python 制作一个最小的数字孪生。当我们有实验数据集时，我们可以展示“混合”数字双胞胎如何成为虚拟化资产的更现实的方式。此外，开发可靠的模型需要较少的数据。我们可以将更多未来的实验数据测量添加到我们的数字双胞胎中，以进一步改进我们的数学模型。
图书馆
我们使用 Keras 库用于 NN，使用 Plotly 用于 plots。
感谢
致汉堡理工大学 Merten Stender 教授， m.stender@tuhh.de 及其作品 Digital twin for structural dynamics applications(此处)。
代码和数据
您可以在 repo 中找到该代码，并在此处找到数据(锂离子电池老化数据集)。
引文
- B.徐、a .乌达洛夫、a .乌尔比格、g .安德森和 D. S .克尔申。(2018).用于电池寿命评估的锂离子电池退化建模。IEEE 智能电网汇刊第 9 卷第 2 期第 1131-1140 页。doi: 10.1109/TSG.2016.2578950。
- I .拉雷斯戈伊蒂、s .卡比茨、m .埃克和 D. U .绍尔。(2015).模拟锂离子电池在循环过程中的机械退化:固体电解质相间断裂。能源杂志，第 300 卷，第 112-122 页。
如何用 FastAPI 和 JavaScript 构建一个拖放表单
创建上传文件表单的分步教程
[更新:2022–1–5 引导程序 5]
**Table of Contents**
· [Introduction](#bf70)
· [Set-Up](#8b46)
· [Installing Python Packages Using requirements.txt](#5c70)
· [Structure](#ea1a)
· [Creating the Upload Page](#66a4)
∘ [① How to add a router in app/main.py](#e2ac)
∘ [② Adding a link to the templates/include/topnav.html](#3174)
∘ [③ Creating a controller app/routers/upload.py](#7931)
∘ [④ Creating a view page, templates/upload.html](#64d7)
· [Creating Upload Area](#577b)
∘ [Updating upload.html](#b8e6)
· [Plan of Procedure](#8a8f)
· [Adding Drag & Drop Functions](#af7f)
· [Python Codes](#1b9a)
· [Adding the upload/new Post Method](#5b10)
· [Demo Using Drag and Drop](#1613)
· [Demo Using File Select](#0db0)
· [Conclusion](#baaf)
· [Updates](#0bcc)
· [References](#fc90)
介绍
本文展示了如何使用 Python 和 Javascript 构建一个拖放表单。上传文件允许用户在你的应用上分析他们的数据或图像。我们在本教程中使用 FastAPI [1],但是您可以将它应用到 Flask 或其他 Python 框架中。FastAPI 是一个现代的高性能 web 框架，用于基于标准 Python 类型提示用 Python 3.6+构建 API。HTML 拖放[2]接口使应用程序能够在浏览器中使用拖放功能。
随文章编码或抓取最终编码。
(选项)这些文章，“创建虚拟环境”和“使用 Gitstart 创建 GitHub 存储库”将帮助您设置 Python 环境。如果你想免费托管你的 FastAPI 应用，请阅读“如何在 Heroku Free 上部署 FastAPI 应用”。
设置
我们在 FastAPI Web Starter 之上构建应用程序。FastAPI Web Starter 是一个用 FastAPI 和 Jinja 构建的静态网站。
$ git clone [git@github.com](mailto:git@github.com):shinokada/fastapi-web-starter.git
$ cd fastapi-web-starter
使用 requirements.txt 安装 Python 包
在根目录下创建requirements.txt文件。
我们将Pillow添加到 FastAPI Web Starter 的requirements.txt中。Pillow【3】是一个 Python 成像库。
使用此 rquirements.txt 安装 Python 包:
$ pip install -r requirements.txt
运行服务器:
$ uvicorn app.main:app --reload --port 8000
结构
FastAPI Web Starter 拥有大部分文件。我们将在本文中创建丢失的文件。
创建上传页面
让我们创建一个新页面。我们需要在app/main.py中添加①一个路由器，②顶部菜单中的一个链接，③一个控制器app/routers/upload.py，④一个查看页面。
①如何在 app/main.py 中添加路由器
我们在app/main.py中为upload增加一条新的路线:
...
from app.routers import upload, twoforms, unsplash, accordion
...
app.include_router(upload.router)
我们从app.routers导入upload，包含路由器upload.router。这让我们可以访问http://127 . 0 . 0 . 1:8000/upload。
②向 templates/include/topnav.html 添加链接
<li class="nav-item {{'active' if active_page == 'upload' }}">
<a class="nav-link" href="/upload">Upload</a>
</li>
我们使用 Jinja 的 if 语句来检查active_page是否为upload。如果是这样，它将添加active类。
③创建控制器 app/routers/upload.py
第 1 行:我们导入 FastAPI 的 APIRouter。我们可以将这个文件包含在app/main.py中。
第 5 行:我们创建一个APIRouter对象，router。
第 9-12 行:我们使用 URL 为/upload的get方法。我们使用HTMLResponse返回一个名为upload.html的 HTML 文件。现在，我们向 HTML 文件返回一个变量result。
④创建视图页面，templates/upload.html
第 1 行:我们扩展了 FastAPI Web Starter 中的[base.html](https://gist.github.com/shinokada/47e29b95570ccb3950b8e2d77b8abb4d) 。
第 2 行:我们将active_page设置为upload。这确保了它将在顶部导航菜单中添加active类。
第 12 行:显示result。
让我们启动服务器:
$ uvicorn app.main:app --reload --port 8000
访问http://127 . 0 . 0 . 1:8000/upload
创建上传区域
更新 upload.html
我们将在templates/upload.html中创建一个 div upload-area。
第 17 行:因为我们不仅允许用户拖放，还允许用户选择要上传的文件，所以我们也添加了一个提交按钮。
第 37 行:添加dragdrop.js。请注意type="module"。这允许我们在dragdrop.js中导入另一个 javascript 文件。
让我们为static/css/mystyle.css中的上传页面添加一些样式:
现在页面看起来像这样:
上传区。图片作者。
程序计划
以下流程图是按顺序上传文件的总结过程。对于本例，我们将上传一个图像文件并创建一个缩略图。
有序的总结过程。图片作者。
我们用 JavaScript 处理大部分过程，用 Python 创建一个缩略图。我们将在下一节中逐一介绍上述过程。
添加拖放功能
static/js/imagehelpers.js有两个功能。
detect()函数查找图像的宽度和高度。它接受一个图像 URL 和一个回调。它创建一个新的图像对象，并使用 URL 分配图像src。我们找到图像的宽度和高度，并在回调中使用它们。我们将使用图像的宽度和高度来确定缩略图的宽度和高度。
在dragdrop()函数中，我们使用dragger、drop和dragenter事件来改变用户在upload-area上拖动文件时的文本。我们添加preventDefault()和stopPropagation()来防止浏览器的默认动作。
在最后一行，我们导出了这两个函数，这样我们就可以将它们导入到另一个 javascript 文件中。
在static/js/dragdrop.js中:
第 1 行:因为我们使用了type="module"，所以我们可以从./imghelper.js导入detect()和dragdrop()函数。
第 4 行:运行导入的dragdrop()函数。
第 6–20 行:preparedata()函数使用file作为源创建一个图像 URL blob。它使用导入的detect()函数和创建的图像 URL blob。回调函数使用的window.width()、imgWidth和imgHeight -都在detect()函数返回的result中。我们将它们存储在data对象中，并使用stringily()函数将 JavaScript 对象转换成 JSON 字符串。我们追加它和删除的文件。然后我们运行uploadData()函数。
第 23–36 行:这个部分控制用户放下文件时的动作。首先，它会将文本更改为“我们正在上传您的文件”。
event.originalEvent.dataTransfer.files返回文件列表。
从 e . original event . data transfer . files 返回的值
我们用它来定义file变量，获取窗口宽度，winWidth并获取列表中第一个被删除的文件。如果拖放的文件与imageType匹配，则将其发送给preparedata()功能。否则，更改文本“请使用图像文件。再试一次。”。
第 39–41 行:这将触发“选择文件”对话框。
第 44–54 行:该部分与第 28–36 行相同。
第 57–69 行:这个 AJAX 部件将数据发送到 URL /upload/new。一旦成功，它运行updatatags()功能。
第 71–76 行:我们使用一个img标签设置 HTML 内容，并将文本改回"Drag and Drop file here<br />Or<br />Click to Upload"。
Python 代码
我们给library/helpers.py增加了四个功能。
setdimensions()计算并返回缩略图的尺寸。
create_workspace()返回一个目录路径，使用uuid.uuid4()创建一个唯一的目录名。
thumb()创建缩略图并保存在目录中。
image_trannspose_exif()防止创建的图像旋转。
添加上传/新发布方法
更新app/routers/upload.py:
第 1 行:从fastapi导入File和UploadFile。
第 4 行:从../library/helpers导入所有函数。
第 18 行:添加参数，imgdata和file。
第 19 行:imgdata[0]包含winWidth、imgWidth和imgHeight。我们使用eval()将字符串转换成 Python 字典。
第 22 行:创建目录路径并将其存储在workspace变量中。
第 24 行:将拖放的文件名保存到file_name。
第 26 行:存储img_full_path变量的完整路径。
第 27–29 行:将拖放的文件保存在目录中。
第 31–35 行:创建一个缩略图并将路径存储到thumb_path变量。
第 37–40 行:返回img_full_path和thumb_path。这些值将在dragdrop.js中用于在页面上插入缩略图。
使用拖放进行演示
使用文件选择进行演示
结论
上传的图像可以在您的应用程序中进行分析。在以后的文章中，我们将介绍如何在图像中找到主色。因为我们在目录中有原始图像和缩略图，所以我们可以根据工作量使用其中一个图像。
通过 成为 的会员，可以完全访问媒体上的每一个故事。
https://blog.codewithshin.com/subscribe
更新
[更新:2022–1–5 Bootstrap 5]
[更新:2021–11–07 FastAPI&依赖项更新]
[更新:2021–08–15 Python 和依赖项更新]
参考
如何通过 sqlite3 在 Observablehq 中构建动态条形图
数据可视化
一个现成的笔记本，利用了 Observablehq 提供的最新 sqlite3 特性
最近，Observablehq 团队发布了一个新功能，允许将 sqlite3 数据库导入笔记本。这个特性非常强大，因为它允许通过经典的 SQL 语法动态查询数据集。Mike Bostock 提供的原始教程可在此链接获得。
在本教程中，我利用新的 sqlite3 特性构建了一个简单的条形图，它可以根据用户的选择动态更新。
作为示例数据集，我使用通用食品数据库，该数据库由 data.world 提供，可通过链接获得。下表显示了通用食品数据库的快照:
作者图片
在本教程中，我们将构建一个动态条形图，显示每个子组的项目数，前提是该组。组选择是通过下拉选择完成的。
将 CSV 文件转换为。
通用食品数据库以 CSV 文件发布，因此，在下载后，必须将其转换为. db 文件。然后，它可以作为文件附件上传到可观察的笔记本中。
为了执行到的转换。db，首先我们必须从其官网下载 sqlite3。我们可以解压缩下载的文件夹，并从命令行进入该文件夹。从 sqlite3 文件夹中，我们可以启动 sqlite3 命令:
./sqlite3
现在 sqlite3 终端打开，我们可以创建一个新的数据库，即food_db:
.open food_db
我们可以按如下方式导入通用食物表:
.mode csv .import /path/to/your/file/generic-food.csv food_table
在前面的示例中，我们已经将 CSV 文件导入到了 food_table 表中。现在我们可以检查该表是否已被正确导入:
.schema
输出应该如下所示:
CREATE TABLE food_table(
"FOOD NAME" TEXT,
"SCIENTIFIC NAME" TEXT,
"GROUP" TEXT,
"SUB GROUP" TEXT
);
如果我们查看运行 sqlite3 命令的文件夹，我们可以看到有一个名为food_db的文件。这个文件可以作为 Observablehq 提供的sqlite()函数的输入。
将数据库加载到 Observable
现在我们可以在 Observable 中创建新的笔记本并导入数据库。我们可以单击页面右上角的三个点，然后选择文件附件:
作者图片
我们从文件系统中选择文件，并将其上传到可观察的笔记本中。我们可以通过下面一行代码加载数据库:
db = FileAttachment("food_db").sqlite()
我们可以通过describe()函数列出数据库中包含的所有表格:
db.describe()
它给出了以下输出:
作者图片
describe()函数也可以接收表名作为输入:
db.describe('food_table')
它给出了以下输出:
作者图片
查询数据库
我们准备查询数据库。我们可以使用 SQL 语法来构建任何查询。例如，如果我们想要列出所有组，我们可以运行以下查询:
groups = db.query('SELECT DISTINCT(`GROUP`) from food_table')
下图显示了group变量的快照:
作者图片
我们可以构建一个包含所有组的下拉菜单:
viewof term = Inputs.select(groups.map(d => d.GROUP), {value: "Vegetables", label: "Group"})
注意，我们已经将group变量转换为一个对象列表。下拉选择的输出如下所示:
我们可以通过询问属于通过下拉选择选择的组的所有子组来再次查询数据库:
data = db.query('SELECT count(*) AS value, `SUB GROUP` AS name FROM food_table WHERE `GROUP` LIKE $1 GROUP BY name ORDER BY value DESC', [`%${term}%`])
我们可以将结果显示为表格:
Inputs.table(data)
它给出了以下输出:
作者图片
构建条形图
最后，我们可以按照链接中提供的示例来构建条形图。结果如下所示:
如果您回到本文并在下拉选择中选择另一个组，您应该会在条形图中看到变化。仅此而已！
摘要
在本教程中，我已经说明了如何利用 Observable 提供的新的 sqlite3 特性来构建一个动态条形图。
完整的笔记本可以从这里下载。
如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。
相关文章
[## 如何改进带注释的 D3.js 图形
towardsdatascience.com](/how-to-improve-d3-js-graphs-with-annotations-252fbb9c5bb5)
如何使用 Flask 构建假新闻检测 Web App
机器学习部署
用 Flask 部署文本分类模型
照片由来自 Unsplash 的 Markus Winkler 拍摄
随着不同社交网络的采用，假新闻的传播势不可挡。在推特、脸书、Reddit 上，人们利用假新闻传播谣言，赢得政治利益和点击率。
检测假新闻对于一个健康的社会至关重要，检测假新闻有多种不同的方法。从机器学习的角度来看，假新闻检测是一个二元分类问题；因此，我们可以使用传统的分类方法或最先进的神经网络来处理这个问题。
本教程将从头开始创建一个自然语言处理应用程序，并将其部署在 Flask 上。最终，您将拥有一个运行在本地机器上的假新闻检测 web 应用程序。请看这里的预告。
本教程采用以下结构组织:
- 第一步:将数据从 Kaggle 加载到 Google Colab。
- 第二步:文本预处理。
- 第三步:模型训练和验证。
- 步骤 4:挑选并加载模型。
- 第五步:创建一个 Flask 应用程序和一个虚拟环境。
- 第六步:添加功能。
- 结论。
**注:**完整的笔记本在 GitHub 上。
第一步:将数据从 Kaggle 加载到 Google Colab
嗯，机器学习项目最基础的部分就是数据。我们将使用来自 Kaggle 的虚假和真实新闻数据集来构建我们的机器学习模型。
我以前写过一篇关于如何从 Kaggle 下载数据到 Google Colab 的博客。请随意按照里面的步骤操作。
文件夹里有两个独立的 CSV 文件，真和假，分别对应真假新闻。让我们看看数据是什么样的:
true = pd.read_csv('True.csv')
fake = pd.read_csv('Fake.csv')
true.head(3)
真实 CSV 文件的前三行(图片由作者提供)
第二步:文本预处理
数据集有四列，但它们还没有标签，让我们先创建标签。假新闻作为标签 0，真新闻标签 1。
true['label'] = 1
fake['label'] = 0
数据集是相对干净和有组织的。为了提高训练速度，我们使用两个数据集中的前 5000 个数据点来构建模型。您还可以使用完整的数据集来获得更全面的结果。
*# Combine the sub-datasets in one.*
frames = [true.loc[:5000][:], fake.loc[:5000][:]]
df = pd.concat(frames)
df.tail()
用于训练和测试的组合数据集(图片由作者提供)
我们还可以将要素和标签分开，并制作一份数据帧的副本，供以后培训使用。
X = df.drop('label', axis=1)
y = df['label']
# Delete missing data
df = df.dropna()
df2 = df.copy()
df2.reset_index(inplace=**True**)
酷！时间对于真正的文本预处理，这包括删除标点符号，降低所有大写字符，删除所有停用词， 词干 ，很多时候我们把这个过程叫做 标记化 。
**from** **nltk.corpus** **import** stopwords
**from** **nltk.stem.porter** **import** PorterStemmer
**import** **re**
**import** **nltk**nltk.download('stopwords')
ps = PorterStemmer()
corpus = []**for** i **in** range(0, len(df2)):
review = re.sub('[^a-zA-Z]', ' ', df2['text'][i])
review = review.lower()
review = review.split()
review = [ps.stem(word) **for** word **in** review **if** **not** word **in** stopwords.words('english')]
review = ' '.join(review)
corpus.append(review)
接下来，让我们使用 TF-IDF 矢量器将每个记号转换为矢量，也就是矢量化记号或 单词嵌入 。您可以使用其他单词嵌入技术来处理这个数据集，如 Word2Vec、Glove，甚至 BERT，但我发现 TF-IDF 足以生成准确的结果。
TF-IDF(词频—逆文档频率)的简明解释:它通过同时考虑一个单词在一个文档中的频率和同一语料库中其他文档的频率来计算该单词的重要性。
例如， detection 这个词在这篇文章中出现的比较多，但在 MEDIUM 语料库的其他文章中却没有出现；因此“检测”是这篇文章中的一个关键词，但是“ term ”这个词几乎在任何文档中都存在，出现频率很高，所以它并不那么重要。
关于 TF-IDF 更详细的介绍可以在这个媒体博客中找到。
**from** **sklearn.feature_extraction.text** **import** TfidfVectorizer
tfidf_v = TfidfVectorizer(max_features=5000, ngram_range=(1,3))
X = tfidf_v.fit_transform(corpus).toarray()
y = df2['label']
大部分完成了！让我们做最后一步，拆分数据集进行训练和测试！
**from** **sklearn.model_selection** **import** train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
步骤 3:模型训练和验证
你可以在这里尝试多种分类算法:逻辑回归、SVM、XGBoost、CatBoost 或神经网络。我使用的是 在线被动攻击算法 。
**from** **sklearn.linear_model** **import** PassiveAggressiveClassifier
**from** **sklearn** **import** metrics
**import** **numpy** **as** **np**
**import** **itertools**classifier = PassiveAggressiveClassifier(max_iter=1000)
classifier.fit(X_train, y_train)
pred = classifier.predict(X_test)
score = metrics.accuracy_score(y_test, pred)
print("accuracy: **%0.3f**" % score)
模型精度(图片由作者提供)
相当不错的成绩！让我们打印混淆矩阵来看看误报和漏报。
**import** **matplotlib.pyplot** **as** **plt**
**def** plot_confusion_matrix(cm, classes,
normalize=**False**,
title='Confusion matrix',
cmap=plt.cm.Blues):
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
**if** normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
**else**:
print('Confusion matrix, without normalization')
thresh = cm.max() / 2.
**for** i, j **in** itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" **if** cm[i, j] > thresh **else** "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')cm = metrics.confusion_matrix(y_test, pred)
plot_confusion_matrix(cm, classes=['FAKE', 'REAL'])
作者图片
因此，在使用 TF-IDF 矢量器的平衡数据集中，使用被动-主动算法，我们得到了 3 个假阳性，没有假阴性。
让我们使用一个看不见的数据集进行验证，比如说来自假 CSV 文件的第 13070 个数据点。我们预期分类模型的结果是 0。
# Tokenization
review = re.sub('[^a-zA-Z]', ' ', fake['text'][13070])
review = review.lower()
review = review.split()
review = [ps.stem(word) **for** word **in** review **if** **not** word **in** stopwords.words('english')]
review = ' '.join(review)# Vectorization
val = tfidf_v.transform([review]).toarray()# Predict
classifier.predict(val)
模型输出(图片由作者提供)
酷！我们得到了我们想要的。您可以尝试完整数据集中更多看不见的数据点。我相信这个模型会给你一个满意的答案，而且准确度很高。
第 4 步:挑选和加载模型
现在，是时候清理(保存)模型和矢量器了，这样你就可以在其他地方使用它们了。
**import** **pickle** pickle.dump(classifier, open('model2.pkl', 'wb'))
pickle.dump(tfidf_v, open('tfidfvect2.pkl', 'wb'))
再来看看不训练能不能用这个模型。
# Load model and vectorizer
joblib_model = pickle.load(open('model2.pkl', 'rb'))
joblib_vect = pickle.load(open('tfidfvect2.pkl', 'rb'))
val_pkl = joblib_vect.transform([review]).toarray()
joblib_model.predict(val_pkl)
酸洗模型的输出(图片由作者提供)
我们得到了相同的输出！这正是我们所期望的！
现在模型已经准备好了，是时候部署它并检测 web 应用程序上的任何消息了。
第五步:创建一个 Flask 应用程序和一个虚拟环境
Flask 是一个轻量级的 WSGI web 应用框架。与 Django 相比，Flask 更容易学习，但是出于安全考虑，它不适合用于生产。出于这个博客的目的，你将学习 Flask。相反，你可以自由地跟随我的另一个教程学习如何使用 Django 部署一个应用。
- 从终端或命令行创建一个新目录:
mkdir myproject
cd myproject
2.在项目目录中，为项目创建一个虚拟环境。
如果您没有安装 virtualen ，运行以下命令在您的终端中安装环境。
pip install virtualenv
在安装了 virtualen 之后，运行下面的代码来创建一个 env。
virtualenv <ENV_NAME>
替换<env_name>中 env 的名称</env_name>
通过以下方式激活环境:
source <ENV_NAME>/bin/activate
您可以在需要时使用以下命令移除 env:
sudo rm -rf <ENV_NAME>
现在你的 env 已经准备好了。让我们先安装烧瓶。
pip install flask
是时候构建 web 应用程序了！
步骤 6:添加功能
首先，让我们在同一个目录中创建一个新文件，包含以下内容，并将其命名为 app.py，我们将在该文件中添加一些功能。将上一步中经过酸洗的模型和矢量器移动到同一个目录中。
我们要构建四个函数: home 用于返回主页；预测用于得到分类结果，判断输入的新闻是假的还是真的； webapp 用于返回网页上的预测； api 是将分类结果转换成 JSON 文件，构建外部 api。
你可能会发现官方文件对你很有帮助。
from flask import Flask, render_template, request, jsonify
import nltk
import pickle
from nltk.corpus import stopwords
import re
from nltk.stem.porter import PorterStemmerapp = Flask(__name__)
ps = PorterStemmer()# Load model and vectorizer
model = pickle.load(open('model2.pkl', 'rb'))
tfidfvect = pickle.load(open('tfidfvect2.pkl', 'rb'))# Build functionalities [@app](http://twitter.com/app).route('/', methods=['GET'])
def home():
return render_template('index.html')def predict(text):
review = re.sub('[^a-zA-Z]', ' ', text)
review = review.lower()
review = review.split()
review = [ps.stem(word) for word in review if not word in stopwords.words('english')]
review = ' '.join(review)
review_vect = tfidfvect.transform([review]).toarray()
prediction = 'FAKE' if model.predict(review_vect) == 0 else 'REAL'
return prediction[@app](http://twitter.com/app).route('/', methods=['POST'])
def webapp():
text = request.form['text']
prediction = predict(text)
return render_template('index.html', text=text, result=prediction)[@app](http://twitter.com/app).route('/predict/', methods=['GET','POST'])
def api():
text = request.args.get("text")
prediction = predict(text)
return jsonify(prediction=prediction)if __name__ == "__main__":
app.run()
您可以在前面的部分看到一个index.html文件，它是应用程序的主页。在根文件夹中创建一个名为*“模板”的文件夹，在里面创建一个文件“index . html”*。现在让我们给页面添加一些内容。
<!DOCTYPE HTML>
<html><head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>Fake News Prediction</title>
<link href="[https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css](https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css)" rel="stylesheet"
integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
<script src="[https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js](https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js)"
integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM"
crossorigin="anonymous"></script>
<script src="[https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js](https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js)"></script></head><body>
<nav class="navbar navbar-expand-lg navbar-light bg-light">
<div class="container-fluid">
<a class="navbar-brand" href="/">FAKE NEWS PREDICTION</a>
<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNavAltMarkup"
aria-controls="navbarNavAltMarkup" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="nav navbar-nav navbar-right" id="navbarNavAltMarkup">
<div class="navbar-nav">
<a class="nav-link" target="_blank"
href="[https://rapidapi.com/fangyiyu/api/fake-news-detection1/](https://rapidapi.com/fangyiyu/api/fake-news-detection1/)">API</a>
<a class="nav-link" target="_blank"
href="[https://medium.com/@fangyiyu/how-to-build-a-fake-news-detection-web-app-using-flask-c0cfd1d9c2d4?sk=2a752b0d87c759672664232b33543667/](https://medium.com/@fangyiyu/how-to-build-a-fake-news-detection-web-app-using-flask-c0cfd1d9c2d4?sk=2a752b0d87c759672664232b33543667/)">Blog</a>
<a class="nav-link" target="_blank"
href="[https://github.com/fangyiyu/Fake_News_Detection_Flask/blob/main/Fake_news_detection.ipynb](https://github.com/fangyiyu/Fake_News_Detection_Flask/blob/main/Fake_news_detection.ipynb)">NoteBook</a>
<a class="nav-link" target="_blank" href="[https://github.com/fangyiyu/Fake_News_Detection_Flask](https://github.com/fangyiyu/Fake_News_Detection_Flask)">Code Source</a>
</div>
</div>
</div>
</nav><br>
<p style=text-align:center>A fake news prediction web application using Machine Learning algorithms, deployed using Django and Heroku. </p>
<p style=text-align:center>Enter your text to try it.</p>
<br>
<div class='container'>
<form action="/" method="POST">
<div class="col-three-forth text-center col-md-offset-2">
<div class="form-group">
<textarea class="form-control jTextarea mt-3" id="jTextarea'" rows="5" name="text"
placeholder="Write your text here..." required>{{text}}</textarea><br><br>
<button class="btn btn-primary btn-outline btn-md" type="submit" name="predict">Predict</button>
</div>
</div>
</form>
</div>
<br>
{% if result %}
<p style="text-align:center"><strong>Prediction : {{result}}</strong></p>
{% endif %}<script>
function growTextarea (i,elem) {
var elem = $(elem);
var resizeTextarea = function( elem ) {
var scrollLeft = window.pageXOffset || (document.documentElement || document.body.parentNode || document.body).scrollLeft;
var scrollTop = window.pageYOffset || (document.documentElement || document.body.parentNode || document.body).scrollTop;
elem.css('height', 'auto').css('height', elem.prop('scrollHeight') );
window.scrollTo(scrollLeft, scrollTop);
};
elem.on('input', function() {
resizeTextarea( $(this) );
});
resizeTextarea( $(elem) );
}
$('.jTextarea').each(growTextarea);
</script>
</body></html>
上面的脚本创建了这样一个网页:
假新闻检测网络应用用户界面(图片由作者提供)
现在，您可以通过在终端中键入以下命令来运行您的应用程序:
python3 app.py
您将能够在本地运行您的应用程序，并对模型进行测试。
结论
在本教程中，您构建了一个机器学习模型来从真实新闻中检测假新闻，并保存该模型以使用 Flask 构建一个 web 应用程序。web 应用程序正在您的本地机器上运行，您可以尝试使用 Heroku、AWS 或 DigitalOcean 等云服务将其公开。我已经在 Heroku 部署了地雷。请随意试一试。
我希望你喜欢这次旅行。欢迎留言评论，在 Linkedin 与我联系。
如何用数据科学打造梦幻英超球队
利用数据科学和数学优化您的 FPL 团队。
照片由 Nguyen Thu Hoai 在 Unsplash
介绍
梦幻超级联赛是一个体育战略游戏，我们建立了一个足球队的基础上，从英格兰超级联赛的球队。这个游戏的目标是挑选对比赛有贡献的球员。
为了知道球员有没有贡献，我们可以看看它的分数。这些分数是基于几个统计数据检索的，比如助攻数、进球数、上场时间等等。随着分数越来越大，球员们为比赛做出了巨大的贡献。
对于挑选球员，我们也有几个约束。这些制约因素是:
- 一个队由 15 名队员组成。具体来说，一个球队有两名守门员，五名后卫，五名中场，三名前锋。
- 给一个团队的预算只有 1 亿英镑。
- 我们最多只能从一支英超球队中挑选三名球员。
我们如何在这些限制下建立一个团队？我们可以利用数据科学和数学的帮助，而不是依靠我们的常识！
本文将向你展示如何用一个叫做线性规划的数学概念来构建一个梦幻英超球队。
如果对那个概念理解不深也不用担心。我们将使用一个基于 Python 语言的名为 Pulp 的库。
没有进一步，让我们开始吧！
最优化和线性规划
在我们进入实现之前，让我给你解释一下优化和为什么我们应该使用线性编程的原因。
优化过程是优化问题的工作流程。这个问题包括结果和我们受到的限制。一般来说，这个过程分为几个步骤。它们是:
- 获取问题描述。
- 制定数学程序
- 求解数学程序
- 评估结果
- 最终确定结果
在我们的例子中，问题描述是我们想要建立一个足球队，它有大量的分数，同时有效地使用预算。
要将问题公式化为数学问题，我们需要知道一些信息。这些是:
- 我们想要观察的变量。对于我们的问题，我们需要像玩家的价格、点数、团队和位置这样的数据。
- 目标函数。我们想优化这个函数。在这种情况下，我们希望从我们挑选的球员身上得到很多分数。
- 因为 FPL 有像预算和球员数量这样的规则，所以我们给出了约束条件。
- 最后，我们需要跟踪玩家统计数据的数据。
在我们得到所有我们需要的信息后，下一步是解决问题。为此，我们可以使用线性规划。
使用线性编程的原因是因为函数是基于线性表达式格式的。基于该表达式，线性编程将试图找到最佳点。因此，我们可以得到最优的结果。
我不会解释线性规划背后的细节。如果你有更多的兴趣，你可以在网上探索更多。目前，我们主要关注如何使用 Python 解决优化问题。
履行
数据源
对于数据源，FPL 为我们提供了访问历史数据的 API。我们可以检索数据，如球员的统计数据，每个游戏周的结果，球队的表现，等等。数据本身是 JSON 格式的，所以我们必须先重新格式化它。
如果您不能使用 API 或预处理 JSON，不要担心，我们可以使用来自 vaastav 的 GitHub 存储库中的预处理数据。您可以在这里访问数据。要下载数据，我们可以使用 git 克隆来完成。在您的终端上，编写如下命令:
**git clone** [**https://github.com/vaastav/Fantasy-Premier-League.git**](https://github.com/vaastav/Fantasy-Premier-League.git)
加载库
获得数据后，下一步是导入库来处理数据集。我们需要像 pandas 这样的库来分析和处理数据，需要 pulp 来应用线性编程。
如果您仍然没有这些库，您可以使用 pip 命令来安装这些库。在终端上，编写以下命令:
**pip install pandas
pip install pulp**
在你的 jupyter 笔记本上，写下这几行代码:
加载数据
加载库之后，下一步是加载数据。我们将在每个比赛周使用包含当前赛季(2021–22)球员统计数据的数据。让我们写这几行代码:
在这种情况下，我们只取前一个游戏周。就像文章目前写的那样，目前的游戏周是游戏第 6 周。因此，我们从第 5 周的游戏中获取数据。让我们写这几行代码:
从上表可以看出，我们有很多列。因此，我们只选取我们实际需要的列。
这些列是玩家的名字、俱乐部、总点数、价格(价值)和位置。关于这些列的细节将在下一节中解释。
现在让我们写这几行代码:
初始化变量
现在我们有了我们需要的数据。下一步是初始化几个变量。正如我之前提到的，我们从表中提取了几列。原因有两个，目标和限制。
我们采用总点数变量是因为我们想优化点数。同时遵守我们现有的约束。像团队名称、位置和价格这样的变量是需要满足的约束。
现在让我们编写这些代码行来初始化我们需要的变量:
初始化问题
现在我们有了我们需要的变量。下一步是初始化包含我们的目标和约束的 LpProblem 对象。
我们设置参数，如问题的名称和一个对象，以确定问题的目标。因为我们想要最大化点数，所以我们将 LpMaximize 设置为对象的参数。
下面是实现这一点的代码:
定义目标
初始化问题后，下一步是定义目标。我们问题的目标是使点数最大化。
让我们写这几行代码:
定义约束
让我们回忆一下来自 FPL 的约束:
- 一个队由 15 名队员组成。具体来说，一个球队有两名守门员，五名后卫，五名中场，三名前锋。
- 给一个团队的预算只有 1 亿英镑。
- 我们最多只能从一支英超球队中挑选三名球员。
基于上面的约束，我们创建数学上描述约束的表达式。
让我们写这几行代码:
解决问题
我们有了我们需要的变量和数学表达式。现在让我们通过使用这行代码来解决这个问题:
检索玩家列表
程序解决问题后，我们可以检索符合约束条件的玩家姓名。让我们写这几行代码:
检索预期点数和总成本
现在你有了适合 FPL 限制的球队阵容。如果我们想知道期望的点数和使用的预算呢？
从这个问题中，我们可以得到目标和约束方程。我们可以通过计算等式来计算总点数和价格值。
下面是处理结果的代码:
结论
干得好！现在，您已经使用 Python 实现了构建梦幻超级联赛最佳团队的线性规划。
我希望它能帮助你为 FPL 建立你的团队。因此，你可以用有限的预算建立一个能为比赛做出贡献的最佳团队。
如果你对我的文章感兴趣，你可以在 Medium 上关注我。如果有任何问题，可以在 LinkedIn 上联系我。
感谢您阅读我的文章。
参考
[1]https://towards data science . com/how-our-ai-got-top-10-in-the-fantasy-premier-league-using-data-science-ba88b 185 b 354
【2】https://towards data science . com/creating-a-fantasy-cricket-team-application-of-of-linear-programming-4b 60 c 261702d
【3】https://medium . com
如何构建首次机器学习项目(带完整代码)
使用设施操作示例的机器学习演练
虽然机器学习看起来势不可挡，但在寻找潜在的开始方式时，知道从哪里开始是关键。一个很好的出发点是看看企业在哪里执行可重复的过程。作为一个在设施运营和可靠性工程领域有几年职业背景的人，我的日常经验让我深入了解了机器学习如何应用于可重复流程的运营。
当我第一次对机器学习感兴趣时，我正在寻找通过开发实际创造商业价值的技术解决方案来应用我新发现的兴趣的方法。然而，我经常发现，我在早期学习中去的许多来源都是推销他们专有的 ML 平台或软件，而我并不想购买。虽然这些公司可能有价值，但我决心学习如何在不依赖昂贵的第三方解决方案的情况下应用机器学习。
出于这个原因，我创建了一个样本机器学习项目，它可以通过开放源代码技术免费完成，进入门槛相对较小，并去除了一些你不想购买的软件的任何“专有数据”或“隐藏的销售宣传”。相反，它旨在成为一个起点，激励其他人尝试机器学习，并可能利用代码来创建他们自己的解决方案。(尽管这个示例与设施行业相关，但是这个演练可以应用于您可能拥有的任何领域专业知识中的任何“重复过程”。)
问题陈述和背景
按时完成维护对于设施可靠地提供其商业价值至关重要，如今许多运营都使用 CMMS(计算机化维护管理系统)来记录和控制正在进行的工作。存储在这些企业数据库系统中的是工作是否按时完成的所有历史记录(通常称为工作订单)。机器学习可以用来帮助找到数据中的模式，以便做出主动决策，确保按时完成正确的工作。
机器学习项目概述
以下是我们的机器学习项目将做什么的高级概述:
- 从历史工单数据中学习
- 将工作单的特性作为输入
- 预测未来的工作订单是否会延迟
- 提供输入如何影响预测的详细解释
模型概述(图片由 Cory Randolph 提供)
详细演练
对于这个详细的演练，我将只显示和解释相关的代码部分，因为整个代码可以在 Google Colab 这里查看和运行。
数据
许多工厂运营依赖于存储工作订单历史信息的企业数据库。为了这个项目，我创建了 500 个虚构的工作指令，反映了在这种系统中发现的信息类型。当试图识别自己的数据时，我发现在开始机器学习项目时有 5 个好问题可以问。我在我的文章5 个简单的问题为一个机器学习项目寻找数据 中对这个过程做了详细的解释
样本数据(图片由 Cory Randolph 提供)
每个特征/列的解释:
部门 =给定工单/维护任务中正在执行的工作类型的部门名称。(例如，电气、机械等)
姓名 =完成工作的技术人员的姓名。(为此示例数据随机生成的虚构名称)
预计工时 =给定工单/任务预计需要的大概工时数。
频率 =必须再次完成这些工作指令/任务的频率间隔。(例如，90 天的任务意味着每年要完成 4 次(365 天/ 90 天))。
过期 =特定工单是否过期的标签。(例如，1 =工作订单过期，0 =工作订单按时完成。)
要获得 Jupyter 笔记本中的完整数据:
# Set the url of where the csv data can be downloaded fromurl = 'https://raw.githubusercontent.com/coryroyce/Facilities_ML_Project/main/Data/Maintenace_Past_Due_Sample_Data.csv'# Load the csv data into a Pandas DataFrame to easily work with the data in pythondf = pd.read_csv(url)
接下来，我们处理数据，以便通过将特征/输入(表示为“X”)与标签/输出(表示为“y”)分离，ML 模型可以使用该数据。然后保存 20%的数据作为测试数据，用于验证 ML 模型是否真的在学习模式，而不仅仅是记忆训练数据。
# Separate the features/inputs from the labels/outputsX = df.copy()y = X.pop('Past_Due')# Split the data into train and test data with 20% of the data to test the modelX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)
机器学习模型
既然数据已经加载并准备好进行处理，我们就可以开始创建机器学习模型了。如果您刚刚开始使用 ML，值得注意的是，我们的模型是一个监督分类模型，具有数值和分类特征数据。Catboost 是一个 ML 框架，在简单性和良好性能方面非常适合，不需要太多的超参数调整。为了更好地理解这些 ML 模型如何更详细地工作，一个好的起点是谷歌的机器学习速成班。
因为我们使用的是 CatBoost 库，所以我们可以只用两行代码创建和构建一个性能良好的模型:首先，将模型设置为 CatBoost 分类器。接下来，根据我们之前设置的数据对其进行拟合/训练。
# Select the ML Model typemodel = CatBoostClassifier()# Fit the model to the training datamodel.fit(X_train, y_train, cat_features=['Department', 'Name', 'Frequency'], eval_set=(X_test, y_test))
运行上面的代码块后，我们现在有了一个经过训练的机器学习模型，我们可以用它来预测未来的工作订单是否会延迟。
衡量标准
现在，我们已经有了一个训练有素的机器学习模型，我们需要检查我们的模型有多“好”，并了解它是否可以提供关于工作订单是否可能延迟的有用预测。虽然有大量的指标或方法来评估一个模型有多好，但最有用和最容易理解的指标是准确性(要更深入地了解准确性，请查看杰瑞米·乔登的文章， 评估机器学习模式 l )。简而言之，准确性是模型做出正确预测的百分比。因此，在决定工作订单是否会延迟时，50%的准确率与随机猜测或抛硬币是一样的。
使用一个名为 SKlearn 的通用 ML 库使得获得我们模型的准确性变得非常简单。
# Store the predicted scores from the test datasetpreds_test = model.predict(X_test)# Print the accuracy of the test predictionsprint(f'Model Accuracy on test data: {metrics.accuracy_score(y_test, preds_test)*100}%')
虽然根据数据分割和模型训练，整体精度可能略有不同，但我最近获得的精度是 89%。这意味着我们有一个模型可以正确预测一个工作订单是否会延迟大约 10 次。
预测
有了我们有效且准确的模型，价值就来自于对未来工作订单的预测。这使业务人员能够洞察何时需要调整流程，以确保有可能延迟的工作能够提前得到主动解决。
接下来的代码块显示了如何预测单个工作订单，但可以很容易地修改为进行批量预测，以检查下个月到期的所有工作订单，然后将它们导出到 csv、excel 或 Google 表中，以最适合您的企业正在使用的操作流程。
# Manually input any combination of features to get a prediction (Note: Order of data has to match the column orders)sample = ['Electrical', 'Chris', 4,'90 Days']# Send the sample to the model for predictionsample_prediction = model.predict(sample)# Display predictionprint(f'Current Sample is predicted as {sample_prediction} \n(Note: 1 = Past Due, 0 = On Time)')
解释(奖金)
这种预测工作订单是否会延迟的工作机器学习模型已经在一个很好的地方增加了商业价值，但打开机器学习的“黑匣子”可以帮助我们更多地理解数据，并提供对“为什么”模型做出某种预测的洞察。能够提供详细的解释有助于在内部以及向客户/顾客建立项目的可信度。
一个越来越受欢迎的帮助解释的工具叫做 SHAP 。为了让文章的以下部分更容易阅读，我将省略详细的代码，只展示视觉效果和解释(完整的代码可以在这里找到)。
第一层解释来自模型概要层，需要回答的一个重要问题是:“哪些特性/输入是最重要的，它们有多重要？”有几种不同的方法可以直观地看到 SHAP，为了简单起见，我们将使用条形图汇总图。
SHAP 特征重要性汇总图(图片由 Cory Randolph 提供)
此汇总条形图显示部门对模型的影响最大，而估计工时对模型的影响最小。
下一个需要回答的问题是:“每个输入实际上对模型的预测有多大影响？”这里，SHAP 工具再次为任何单个工单提供了一种查看这种情况的方法。
单一预测的 SHAP 瀑布图(图片由 Cory Randolph 提供)
为了理解该图，我们从左下方的 E[f(x)]开始，它基本上是给定工单的预期输出，向右移动(红色)显示工单延迟的变化增加，向左移动(蓝色)显示工单延迟的机会减少。
- 估计工时为 16 小时，增加了此工作单延迟的可能性。
- 将 Nathan 作为技术人员分配给工作单也增加了工作单延迟的可能性。
- 一年 360 天的频率也会增加迟到的几率。
- 将管道作为一个部门可以显著降低工作订单延迟的可能性。
总的来说，由于最终的 f(x)位于起始位置 E[f(x)]的右侧，因此该工作单将被预测为延迟，但是现在我们有了一个关于为什么会得出该结论的详细解释。
最后要问的问题是:“是哪几组详细的数据导致工单延期？”在 SHAP，帮助回答这个问题的工具叫做依赖图。这些图帮助我们深入了解输入的实际值(包括分类值和数值值),并了解它们如何影响模型的预测。虽然完整代码文件显示了每个特性/输入的这些图，但让我们只看一下部门的依赖图。
SHAP 依赖情节的部门(图像由科里伦道夫)
为了理解该图，如果您在 0 值处画一条水平线，那么该线以上的值将指示该部门的工作订单延迟的可能性，而 0 以下的值将指示工作订单将按时完成。总之，HAVC 部门有很高的延迟工作订单的可能性，而管道有很低的延迟工作订单的可能性。电气和机械相当平衡，有相似数量的延迟和准时工作订单。
这也成为可操作的数据。既然我们看到 HVAC 和延迟工作订单之间存在关联，我们可以进一步询问业务问题；暖通是不是人手不足？暖通空调中是否有特定类型的工作会导致迟到问题？管道系统做了哪些改变，让他们能够按时完成工作？
摘要
总之，早期 ML 项目可以分为 4 个主要阶段:
- 定义最初的业务问题
- 确定哪些可重复的过程提供可用的数据
- 创建工作机器学习模型
- 生成详细的解释
使用提供的代码作为模板，我希望你将通过这 4 个阶段中的每一个来创造一些有价值的东西。
如果你读完了这篇教程，并且能够在你自己的项目中使用它，请在下面的评论部分分享你的经验和应用。我真的很想知道你是如何利用机器学习来解决问题的。
快速参考
如何将 Streamlit 应用程序库构建为单个 Web 应用程序
数据可视化
下载一个免费模板，插入多个 Streamlit 应用程序，就大功告成了
作者图片
我使用 Streamlit 已经有一段时间了，并且已经编写了一些实验性的应用程序。虽然我对它们很满意(就它们而言——它们只是简单的例子),但没有一个值得拥有专门的网页。
那么，呈现可以从单个网页访问的应用程序库的最佳方式是什么呢？
你可以把所有代码放在一个应用程序中，然后用一个if语句在它们之间进行选择(正如我在本文的中所做的那样)，但是这不是很容易扩展——一旦你使用了几个以上的应用程序，就会变得混乱。
那么，如何创建一个应用程序库，用一个调度程序根据下拉菜单中的选择调用每个应用程序呢？这样，应用程序就被编写成独立的功能。您只需创建一个库文件夹来包含应用程序，然后 dispatcher 调用相应的文件夹。
我认为那听起来更好。
Mustrapp 一个简单的框架
因此，为此，我创建了一个名为Mustrapp(Mul pleStreamlitApps)的应用程序模板(可以免费下载)，这使得创建多个 Streamlit 应用程序的过程变得非常简单。
为了让应用程序工作，你需要将它们组织起来，使它们位于一个名为run()的可调用函数中。并且，理想情况下(但不是必须的)，包含一个描述字符串，该字符串将被用作下拉菜单中的文本(如果您没有提供，将使用模块名称)。
所以，一个应用程序看起来会像这样:
description = "My first app"
def run():
st.header("This is my first app")
st.write("I hope you like it")if __name__ == "__main__":
run()
你可以在一个应用中拥有尽可能多的功能，但是它必须从一个叫做run 的功能开始，这是唯一的要求。最后一个if语句是可选的，但是很有用，因为它允许您将单个应用程序作为独立应用程序运行，或者作为多应用程序的一部分运行。它主要检查该函数是否作为主模块被调用(在这种情况下，它的__name__将是 __main__)。如果它作为一个库模块被调用(这就是我们想要做的),那么__name__将是模块名。
能够将应用程序作为一个独立的功能来运行对于调试非常有用，因为您不需要应用程序的其他部分来运行。
假设你写了上面的 app，保存在一个文件app1.py里。
然后，您可以编写另一个应用程序app2.py，如下所示:
description = "My second app"
def run():
st.header("This is my second app")
st.write("Here is an image:")
st.image("image.png")if __name__ == "__main__":
run()
然后，我们将这些文件放在一个名为stlib 的文件夹中——这将是我们的库文件夹，我们所有的应用程序都将存放在这里。为了让 Python 将这个文件夹识别为一个库，它需要包含一个名为__init__.py的文件。如果你已经下载了模板，它已经在那里了。
调度程序位于个人文件夹中。这是我们启动 Streamlit 应用程序时将运行的程序。我打算把它叫做index.py。
所以我们完整的应用程序是这样构建的:
/home
|
|-- index.py
|
|-- /stlib
|
|-- __init__.py
|
|-- app1.py
|
|-- app2.py
要运行应用程序，请执行以下命令:
streamlit run index.py
这将在您的浏览器中弹出:
示例应用程序—作者图片
您可以在本文末尾的要点中看到 dispatcher 的完整代码(太长了，这里不包括)。最后，我还会提供一个 Github 资源库的链接，您可以在这里克隆或下载完整模板的 zip 文件，包括调度程序、目录结构和几个虚拟应用程序。
但基本上是这样运作的。
首先，我们导入 Streamlit 库(当然)以及我们需要的其他库。(它还将布局设置为*宽。*这个是可选的，但在我看来，如果你打算使用侧边栏，看起来会更好，就像我们在这里做的一样——如果你愿意，可以删除它。)
然后我们开始识别库中的应用程序(stlib，并在名为names、modules和descriptions的全局数组中记录应用程序的名称、模块引用和描述。stlib库中的任何模块都被视为 Streamlit 应用，除非其名称以_字符开头。通过这种方式，您可以添加非应用程序库模块(例如_mylibrary.py)，如果您需要的话，它们不会被作为 Streamlit 应用程序选中。
完成此操作后，我们创建一个包含模块名称的下拉菜单(显示描述，如果可用),一旦选择，从modules数组中选择适当的模块，并执行其功能run()。换句话说，对应于选择的应用程序正在运行。
就算我自己说，这个也挺管用的。将 dispatcher 应用程序与任意数量的可调用应用程序一起使用很容易，维护起来也非常简单。现在，我们可以在一个网页上一次性部署任意数量的迷你应用程序。
这些都不是火箭科学，但我希望它有用。你可以在这里看到一个使用这个模板的示例网站，你可以从它的 Github 库下载或者克隆完整的模板。
一如既往地感谢阅读，如果你想知道我什么时候发表新文章，请考虑在这里注册一个电子邮件提醒。我也偶尔在子栈上发布免费的时事通讯。请在下面留下任何评论，或者您可以通过 LinkedIn 或 Twitter 联系。
有趣的是，这里是调度程序代码:
调度员代码
如何使用开源工具构建 GitHub 活动仪表板
将 Airbyte 和 Metabase 结合在一起
作者形象
在本文中，我们将利用 Airbyte (一种开源数据集成平台)和元数据库(一种供贵公司每个人提问和从数据中学习的开源方式)来构建上面的 GitHub 活动仪表板。
Airbyte 为我们提供了一套丰富的源连接器，其中之一就是 GitHub 连接器，它允许我们从 GitHub repo 中获取数据。
我们将使用这个连接器获取 airbyte repo 的数据，并将它们复制到 Postgres 数据库目的地。
然后，我们将该数据库连接到元数据库，以便创建活动仪表板。
我们需要的是:
- 饭桶
- 码头工人
- 码头工人写作
- Airbyte
- Postgres 数据库
- GitHub 访问令牌
- 元数据库
第 1 步:使用 Airbyte 将数据从 GitHub 复制到 Postgres
设置 Airbyte
如果您的机器上已经有 Airbyte，您可以跳过这一步。
要在您的机器上设置 Airbyte，请确保您有 Docker 和 Docker 编写设置以及 git。然后，打开一个终端，并前往您想下载 Airbyte 的位置，然后运行:
git clone [https://github.com/airbytehq/airbyte.git](https://github.com/airbytehq/airbyte.git)
您需要通过运行 cd airbyte 进入克隆的 airbyte repo，然后运行:
docker-compose up
或者如果您使用的是最新版本的 Docker CLI，您可以运行:
docker compose up
上述命令将创建并启动 Airbyte 容器。完成后，您可以通过 http://localhost:8000/ 访问 Airbyte(您可以继续设置您的首选项，然后保持 Airbyte web 应用程序打开，我们很快会回来)
建立 Postgres 数据库
该数据库将是来自 GitHub 的数据的目的地。为了设置这个，我们将通过 docker 运行 postgres 容器，如下所示:
docker run --rm --name github-destination -e POSTGRES_PASSWORD=password -p 3003:5432 -d postgres
如果您是第一次运行上述命令，它将从 Docker Hub 注册表下载 Postgres 映像，然后将其作为名为 github-destination 的容器运行。
我们还通过将环境变量 POSTGRES_PASSWORD 传递给密码值来设置数据库密码。
我们还将容器的 5432 端口绑定到 3003 端口上的主机。最后，我们在后台运行带有-d 标志的容器。
现在我们已经建立了目标数据库，让我们转到 Airbyte web 应用程序，并创建一个从 Airbyte GitHub 源到 Postgres 数据库的连接。
创建 Airbyte 连接
回到浏览器中的 Airbyte web 应用程序，单击应用程序右上角的新来源按钮，进入添加新 Airbyte 来源的页面。
输入名称 github-source 作为信号源名称，点击下拉菜单，选择 Github connector 作为信号源类型。选择 GitHub 源类型后，您将看到两个文本框。首先是输入您想要的存储库。在这个框中，键入 airbytehq/airbyte ，然后，在第二个框中，您需要提供一个 GitHub 访问令牌，您可以从这里的获得。
确保您授予令牌 repo 和 write:discussion 权限。填写完所有字段后，点击“设置来源”按钮。
如果设置成功，您将被带到目的地屏幕，在那里您将添加一个新的目的地。
点击添加目的地按钮，在随后的下拉菜单中，点击添加新目的地。然后，您将看到一个添加目的地名称的页面。输入我们之前创建的 Postgres 容器的名称(github-destination)，然后选择 Postgres 作为目的地类型。
之后，您将看到一些文本框，用于输入数据库连接的详细信息。为我们之前创建的 Postgres 容器输入值:
- 主机—本地主机
- 3003 年后
- 模式-公共(保留默认值)
- 数据库— postgres
- 密码—密码
- 用户名— postgres
然后点击基本的标准化切换按钮来检查它，因为我们希望 Airbyte 标准化来自 GitHub 的数据。总的来说，用户界面应该是这样的:
作者图片
然后点击设置目的地按钮。如果您的凭证对于数据库来说都是正确的，那么 postgres 目的地应该已经设置好了，现在您需要建立从源(GitHub)到目的地(Postgres)的连接。
您应该选中下面截图中的复选框，然后在同步频率下拉列表中选择 Airbyte 每小时尝试复制数据的频率。然后，点击设置连接按钮。
作者图片
您将被带到源页面，单击源，您将看到您的同步状态。同步需要一段时间才能完成。
完成后，您将看到状态从运行更改为成功。此外，字节数指的是 Airbyte 从 GitHub 提取到 Postgres 数据库中的数据字节。
那不是很多工作，是吗？你可以拍拍自己的背，因为你刚刚将数据从 GitHub 同步到 Postgres 数据库。
让我们继续将该数据库连接到元数据库，这样我们就可以开始创建我们的仪表板了。
步骤 2:将 PostgreSQL 数据库连接到元数据库
正在安装元数据库
Metabase 是一个开源的分析工具，你可以通过几种方式开始使用它；使用。jar 文件，将其安装为 Mac 应用程序或使用 Docker 容器。
在本教程中，我们将使用 Mac 应用程序(你也可以在这里找到适合你的安装)。为此，只需运行:
如果你用的是 Mac，你可以从这里下载元数据库应用。下载后，启动应用程序并完成帐户注册，您将看到元数据库仪表板:
作者图片
在元数据库中设置 Postgres 数据库
为了设置我们的数据库，我们将单击 Metabase 应用程序菜单栏上的 cog(设置)图标，并选择 admin 选项以进入 admin 视图，我们可以在其中添加数据库:
作者图片
单击 add a database 按钮，您将看到一个表单，您应该选择 PostgreSQL 作为您选择的数据库，然后填写连接参数，这将是我们为保存来自 GitHub 的数据而创建的 PostgreSQL 数据库的参数
填写详细信息，以匹配我们之前创建的 PostgreSQL 数据库的凭据。
作者图片
然后，当您输入完数据库凭据后，单击 save，您的数据库将被完全加载到元数据库中，为我们开始创建仪表板做好准备。
步骤 3:在元数据库中创建仪表板
Metabase 基于对数据的提问，因此为了构建我们的 GitHub 仪表板，我们将提出以下问题:
- 每天都有新的天文学家
- 贡献了新的问题
- 每天 PR 贡献者的数量
- 每天来自非团队成员的新评论
- 每天来自非团队成员的新问题
每天都有新的天文学家
注意:我们通常需要处理日期时间类型，以便为我们的仪表板找到演化度量，所以如果您注意到您需要的字段不是合适的类型，比如 starred_at 是 VARCHAR 类型而不是数据时间，您可以转到元数据库中的管理视图，单击数据模型选项，并告诉元数据库转换该字段
因此，我们将使用 Metabase 的一般工作流程是单击菜单栏顶部的提问按钮。然后选择你想问的问题类型。我们将从一个简单的问题开始:
作者图片
然后你选择你想要处理的数据。如果一切配置正确，应该会出现一个名为 Airbyte_GitHub 的数据源。然后让我们选择我们想要使用的表，因为对于第一个问题，我们想要观星者的数量，我们选择观星者表。
作者图片
然后，您将看到所选表格中的数据。对于这第一个，我们将看到 Stargazers 表中的数据。
作者图片
为了计算我们第一个问题的答案，点击“总结”按钮，按分组，以开始，按计数总结，然后你就有了第一个问题的答案:一天中新的观星者的数量。
作者图片
点击右上角的蓝色保存按钮来保存问题，并确保你在线模式下进行可视化。保存时，Metabase 会提示您将其添加到仪表板中，这正是我们想要的！
作者图片
点击创建一个新的仪表板，命名您的仪表板，并点击创建。然后，您可以根据自己的情况调整仪表板卡的大小，点击保存，我们的第一个问题就有了答案！
作者图片
对于我们需要问的其余问题，步骤非常相似，因此我们将只提及我们正在使用的表，并显示可视化以及我们在到达那里时使用的设置。
公关人员数量的变化
表:拉取请求
作者图片
发行人数量的演变
表格:问题
作者图片
来自非团队成员的新评论数量的变化
表:注释
我们将使用“作者关联”字段过滤掉合作者的任何评论。
作者图片
来自非团队成员的新问题数量的变化
表:问题
作者图片
结束了。
在本文中，我们使用 GitHub Airbyte 连接器从 GitHub repo 获取数据，并将数据存储在 PostgreSQL 数据库中。然后，我们设置元数据库，并提出问题来可视化数据。
这是 GitHub 仪表板的成品，带有我们在 Metabase 上的可视化效果:
作者图片
额外学分
以下是使用相同过程可以获得答案的其他问题:
- 来自非团队成员的#新评论的演变
- 来自非团队成员的#新问题的演变
- 来自非团队成员的#新 PRs 的演变
- 非团队成员互动的首次评论时间(第 50、90 百分位)
- PR 第一次审核前的时间(第 50、90 百分位)
最初发表于 Airbyte
如何用 Neo4J 和变形金刚搭建知识图
使用自定义命名实体识别和关系提取模型
图片作者:Neo4j 中的知识图谱
介绍
在我的上一篇文章“使用 BERT Transformer 构建求职知识图”中，我们探讨了如何使用定制 Transformer 模型提取的实体和关系，从职位描述中创建知识图。虽然我们能够使用 Python 库 networkX 获得节点和关系的良好视觉效果，但实际的图形存在于 Python 内存中，而不是存储在数据库中。当试图创建一个可伸缩的应用程序时，这可能会有问题，因为您必须存储一个不断增长的知识图。这就是 Neo4j 的优势所在，它使您能够将图表存储在一个功能齐全的数据库中，从而允许您管理大量数据。此外，Neo4j 的 Cypher 语言丰富，易于使用，非常直观。
在本文中，我将展示如何使用基于转换器的命名实体识别(NER)和 spacy 的关系提取模型，从工作描述中构建知识图。这里描述的方法可以用于任何不同的领域，例如生物医学、金融、保健等。
以下是我们将要采取的步骤:
- 在 google colab 中加载我们微调过的变压器 NER 和空间关系提取模型
- 创建一个 Neo4j 沙箱并添加我们的实体和关系
- 查询我们的图表，找到与目标简历最匹配的工作，找到三个最受欢迎的技能和最高技能的共现
有关如何使用ubai生成训练数据以及微调 NER 和关系提取模型的更多信息，请查看以下文章:
- 【UBIAI 简介:面向自然语言处理应用的易用文本注释
- 如何使用具有空间 3 的 BERT 变换器训练联合实体和关系提取分类器
- 如何用空间 3 微调 BERT 变压器
工作描述数据集在 Kaggle 中公开。
在本教程结束时，我们将能够创建如下所示的知识图。
作者图片:职位描述知识图
命名实体和关系抽取
-
首先，我们加载 NER 和关系模型的依赖关系以及 NER 模型本身，该模型之前已经过微调，可以提取技能、文凭、文凭专业和多年经验:
-
加载我们要从中提取实体和关系的作业数据集:
-
从作业数据集中提取实体:
在将提取的实体输入到关系提取模型之前，我们可以先看一下这些实体:
[('stock market analysis', 'SKILLS'),
('private investor', 'SKILLS'),
('C++', 'SKILLS'),
('Investment Software', 'SKILLS'),
('MS Windows', 'SKILLS'),
('web development', 'SKILLS'),
('Computer Science', 'DIPLOMA_MAJOR'),
('AI', 'SKILLS'),
('software development', 'SKILLS'),
('coding', 'SKILLS'),
('C', 'SKILLS'),
('C++', 'SKILLS'),
('Visual Studio', 'SKILLS'),
('2 years', 'EXPERIENCE'),
('C/C++ development', 'SKILLS'),
('data compression', 'SKILLS'),
('financial markets', 'SKILLS'),
('financial calculation', 'SKILLS'),
('GUI design', 'SKILLS'),
('Windows development', 'SKILLS'),
('MFC', 'SKILLS'),
('Win', 'SKILLS'),
('HTTP', 'SKILLS'),
('TCP/IP', 'SKILLS'),
('sockets', 'SKILLS'),
('network programming', 'SKILLS'),
('System administration', 'SKILLS')]
我们现在准备预测关系；首先加载关系提取模型，确保将目录更改为 rel_component/scripts，以访问关系模型所需的所有脚本。
cd rel_component/
Predicted relations: entities: ('5+ years', 'software engineering') --> predicted relation: {'DEGREE_IN': 9.5471655e-08, 'EXPERIENCE_IN': 0.9967771} entities: ('5+ years', 'technical management') --> predicted relation: {'DEGREE_IN': 1.1285037e-07, 'EXPERIENCE_IN': 0.9961034} entities: ('5+ years', 'designing') --> predicted relation: {'DEGREE_IN': 1.3603304e-08, 'EXPERIENCE_IN': 0.9989103} entities: ('4+ years', 'performance management') --> predicted relation: {'DEGREE_IN': 6.748373e-08, 'EXPERIENCE_IN': 0.92884386}
Neo4J
我们现在准备将我们的作业数据集和提取的数据加载到 neo4j 数据库中。
-
首先，启动一个 neo4j 空白沙箱并添加您的连接细节，如下所示:
-
接下来，我们将文档、实体和关系添加到知识图中。请注意，我们需要从实体 EXPERIENCE 的名称中提取整数年数，并将其存储为一个属性。
现在开始有趣的部分。我们准备启动知识图并运行查询。让我们运行一个查询来查找与目标概要文件最匹配的职务:
以表格形式显示常见实体的结果:
在图形可视化中:
作者图片:基于最佳工作匹配
虽然该数据集仅由 29 个职位描述组成，但是这里描述的方法可以应用于具有数千个职位的大规模数据集。只需几行代码，我们就可以立即提取与目标概要文件最匹配的职务。
让我们找出最受欢迎的技能:
query = """MATCH (s:SKILLS)<-[:MENTIONS]-(o:Offer)RETURN s.name as skill, count(o) as freqORDER BY freq DESCLIMIT 10"""res = neo4j_query(query)res
和需要最高年经验的技能:
query = """MATCH (s:SKILLS)--(r:Relation)--(e:EXPERIENCE) where r.type = "EXPERIENCE_IN"return s.name as skill,e.years as yearsORDER BY years DESCLIMIT 10"""res = neo4j_query(query)res
网站开发和支持需要最高年的经验，其次是安全设置。
最后，让我们检查一下最常出现的一对技能:
neo4j_query("""MATCH (s1:SKILLS)<-[:MENTIONS]-(:Offer)-[:MENTIONS]->(s2:SKILLS)WHERE id(s1) < id(s2)RETURN s1.name as skill1, s2.name as skill2, count(*) as cooccurrenceORDER BY cooccurrenceDESC LIMIT 5""")
结论:
在这篇文章中，我们描述了如何利用基于变形金刚的 NER 和斯帕西的关系提取模型，用 Neo4j 创建知识图。除了信息提取之外，图拓扑可以用作另一个机器学习模型的输入。
将 NLP 与 Neo4j 的 graph DB 结合起来，将会加速许多领域的信息发现，在医疗保健和生物医学领域有更显著的应用。
如果您有任何问题或想要为您的特定案例创建定制模型，请在下面留言或发送电子邮件至 admin@ubiai.tools。
在推特上关注我们 @UBIAI5
如何在 macOS 上使用 Django 和 Visual Studio 代码构建 Lotto Generator Web 应用程序
WEB 开发
使用 Django 构建有趣的项目
介绍
在本教程中，您将使用 Django 构建一个乐透生成器 web 应用程序。
Django 是一个 Python web 框架，它简化了 web 开发中的常见实践。它是可靠的，也有一个充满活力的稳定库生态系统，支持日常开发需求。
对于这个项目，您将使用 HTML、CSS 作为前端语言，Python 作为后端语言，Django 作为后端框架。在本教程结束时，您将拥有一个完全正常工作的应用程序，它允许您随机生成两组数字 LottoMax 和 649 。你可以在这里看到现场演示。
App UI(图片来自作者)
**注意:**本教程的源代码可以在 GitHub 上获得。
先决条件
要完成本教程，您需要:
- 安装并设置 Python 3 的本地编程环境。
- 使用 MacOS 操作系统。
- 安装 Visual Studio 代码。
**警告:**本教程中提供的代码是用于教育目的，而不是用于生产用途。
步骤 1——创建 Django 项目。
- 在您的终端中运行以下命令来创建一个 Django 项目。
django-admin startproject <PROJECT_NAME>
2.通过以下方式进入项目文件夹:
cd <PROJECT_NAME>
3.运行以下代码启动一个应用程序:
python3 manage.py startapp <APP_NAME>
现在您已经创建了一个基本的 Django 应用程序。您可以运行以下命令来查看本地计算机上的 web 应用程序。
python3 manage.py runserver
你的 Django app 将在 http://127.0.0.1:8000/ 开发。在这一步，web 应用程序将如下图所示。
图片来自作者
输入 Control+C 退出服务器。
步骤 2—创建虚拟环境。
在这一步，您将创建一个虚拟环境(env)来存储这个特定项目的所有依赖项。
- 如果您没有安装 virtualen ，运行以下命令在您的终端中安装环境。
pip install virtualenv
2.在安装了 virtualen 之后，运行下面的代码来创建一个 env。
virtualenv <ENV_NAME>
在<env_name>中替换您的 env 的名称</env_name>
3.通过以下方式激活环境:
source <ENV_NAME>/bin/activate
您可以在需要时使用以下命令移除 env:
sudo rm -rf <ENV_NAME>
现在你的 env 已经准备好了。是时候建造一些有趣的东西了！
步骤 3—在根目录中配置 settings.py 和 urls.py
现在，在 visual studio 代码中打开 Django 项目文件夹。
您应该会看到这样的项目结构:
你的 Django 项目的结构(图片来自作者)
我使用“Lotto”作为我的项目名，“app”作为应用名，“env”作为环境名。
- 在您的根目录(在我的例子中是文件夹“Lotto ”)中，单击 setting.py，并将您的 APP_NAME 添加到 INSTALLED_APPS。
图片来自作者
2.在同一个文件夹中，点击 urls.py，导入库 include 并将应用中的所有 URL 添加到 urlpatterns 。urls.py 将如下所示:
图片来自作者
第 4 步—添加模板。
- 在你的 app 目录下，新建一个名为templates的文件夹。 Django 依靠模板动态生成 HTML。在模板中，请新建一个与你的 APP_NAME 同名的文件夹(在我这里是 app )，然后在这个文件夹中新建一个名为【index.html 的文件。您将在这个 HTML 文件中构建您的网页。
- 由于我们正在建立一个乐透生成器应用程序，我们希望应用程序随机生成符合乐透最大值和 649 规则的数字集，所以在网页上，我们需要两个按钮，单击按钮，生成的数字将出现在屏幕上。你可以基于这个目的或者按照下面的代码来构建应用程序:
index.html(图片来自作者)
3.你还需要导入库来使用 Jquery 和 Bootstrap，关于 HTML 文件的完整代码请参考 Github Repo (我在 Repo 中做了三个按钮，但是对于我们的教程两个就够了)。
4.在您的 APP_NAME 中创建一个名为 static 的新文件夹，然后创建一个与您的 APP_NAME 同名的新文件夹。在这个文件夹中，创建你的 CSS 文件。静态文件夹用于保存所有的静态文件，包括图片、JavaScript 和 CSS 文件。
现在，Django 项目的结构应该是这样的:
你的 Django 项目的结构(图片来自作者)
步骤 5—添加视图
- 在你的 app 目录下，创建一个名为 predict.py 的文件，生成一定范围内的随机数。
predict.py(图片来自作者)
2.单击 views.py，开始在这里创建视图。
每个视图都是一个 Python 函数，接受 Web 请求并返回 Web 响应。视图本身包含返回响应所需的任意逻辑。
对于 Lotto Generator 应用程序，我们将构建一个视图函数来返回两个列表:一个用于 Lotto Max，它将返回 1 到 50 范围内的 7 个随机数，一个用于 649，它将返回 1 到 50 范围内的 6 个随机数。
您的 view.py 将如下所示:
from django.shortcuts import renderfrom . import predictimport numpy as npimport pandas as pdimport random# Create your views here.def index(request):MaxLotto_range = range(1,51)MaxLotto = predict.lotto(MaxLotto_range, 7)MaxLotto = sorted(MaxLotto) six49_range = range(1, 50)six49 = predict.lotto(six49_range, 6)six49 = sorted(six49) return render(request, 'app/index.html',{"MaxLotto": MaxLotto,"six49": six49})
第 6 步—添加 urls.py
最后，在您的 app 目录中添加一个名为 urls.py 的新文件，并添加与您创建的 Python 函数(您的视图)对应的所有 URL 路径。
from django.urls import include, pathfrom . import viewsurlpatterns = [path("", views.index, name="index"),]
万岁！您的应用程序已经可以运行了！
第 6 步—运行应用程序
在您的终端上运行以下命令:
python3 manage.py runserver
Ops 似乎还没有安装依赖项。
让我们先安装它们。
在您的终端中:
pip install Django numpy pandas
然后，跑
python3 manage.py runserver
您的终端将显示:
运行后的终端(图片来自作者)
我们把网址(http://127.0.0.1:8000/)复制粘贴到你的浏览器，看看你都建了什么！
看到了吗？然后点击按钮。现在你有你的乐透发电机运行！
结论
在本文中，您将使用 Django 和 VS 代码从头开始构建一个乐透生成器。您在根目录中配置了 settings.py 和 urls.py，在 app 目录中添加了模板、静态文件和 urls.py，并在 views.py 中创建了一个函数，该函数带有您创建的帮助器函数，用于生成随机数。
如果你想了解更多关于使用 Django 建立机器学习模型或个人投资组合的信息，欢迎访问我的 GitHub repo 或在下面发表评论。我很乐意把我一路走来学到的东西分享给公众，以尽量减少你花在搜索 Google 和 StackOverflow 上的时间。
在 Linkedin 上向我问好。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
