厌倦了棋盘游戏中的失败？如果你是一名数据科学家，你不必这样做。
作者聚焦
通过模拟大量的大富翁游戏、井字游戏和掷骰子游戏，我们能学到什么？
在 Author Spotlight 系列中，TDS 编辑与我们社区的成员谈论他们在数据科学领域的职业道路、他们的写作以及他们的灵感来源。今天，我们很高兴与 杰克·米切尔 分享我们的对话。
杰克 是一名机械工程专业的学生，对数据科学感兴趣。他喜欢在空闲时间模拟棋盘游戏和进行体育分析。我们最近采访了他，聊了聊他在棋盘游戏和统计方面的热门系列，以及其他话题。
作为一名工程专业的学生，最初是什么吸引你进入数据科学领域的？
我的数据科学之旅始于我高中低年级的时候，当时有一门新的计算机科学课程可供选修。在很快看到编程的好处和用处后，我认为这只是我大学申请上的一个额外的复选框变成了真正的热情。
大概就是在这个时候，我发现了FiveThirtyEight这个网站。他们使用数据和统计分析来写关于体育和政治的文章，但是他们题为《谜语者 T21》的系列真正引起了我的兴趣。谜语者每周发出挑战，这些挑战大多需要编码来回答。我将我新发现的数据科学技能用于测试，并以解答每周谜语为乐，同时也学到了更多关于编码的知识。这些谜语向我展示了如何将编码应用到几乎任何事情上，这将激发我对数据科学文章的兴趣。
哪种以数据为中心的项目最吸引你？
数据科学中我更感兴趣的领域是那些需要模拟的领域。因为我有数学和统计学的背景，我喜欢寻找没有固定公式的问题的答案。没有一个公式可以像掷 10 次硬币的结果一样计算出赢得垄断的几率。这些因其复杂性而需要模拟的问题在我看来有最令人满意的结果，这可能是我觉得它们最有趣的原因。
你的数据科学和棋盘游戏系列的创意来自哪里？
我将数据科学与桌游结合的想法是在我被弟弟妹妹们在“大富翁”中击败太多次后开始的。这是我考虑写我的项目之前的几年，所以我的主要目标是利用数据科学来赢得更多与我家人的棋盘游戏。快进 4-5 年，我在卡坦输给了我的室友。不是这个又是。
我决定打开 MATLAB，开始再次策划我的复仇。结果真的很有趣，我开始想知道其他人是否也会对这些结果感兴趣。终于，我的数据科学和桌游系列诞生了。
你是如何计划这个系列的？
当我在设计这些项目时，我希望所有背景的人都能够享受这些成果，并在他们的下一个游戏之夜使用它们。有些人真的很喜欢看到项目背后的代码，这就是为什么我要确保在我的代码中包含一部分解释。有些人希望看到大量代表数据的图表和数字(我也是其中之一)，所以我也确保用图形来表示我的发现。我还希望那些没有数学或统计学背景的人能够从这些文章中获得一些东西，所以我确保在最后用易于理解的术语总结所有内容。
对你来说，这个项目最意想不到的收获是什么？
在制作这个系列的过程中，有几件事真的让我很惊讶。第一个肯定是看似随机的游戏中有这些真正有趣的模式。当着眼于 1 个游戏的范围时，涉及掷骰子的游戏似乎是随机的，但是扩展到 50，000 个游戏，一些重要的优势就暴露出来了。我发现，把一个本质上涉及到随机数生成器的游戏，变成一篇文章，展示即使是最简单、最随机的游戏也有玩起来的优势，真的很令人满意。
第二个收获是这个系列获得的兴趣。当我第一次发布一篇关于桌游的文章时，我想我可能会从一些人那里得到一些意见，他们也认为这是一个好主意。我没想到的是，在过去的一个月里，我收到了大量的兴趣和反馈。相当多的人真正喜欢阅读这个系列，这促使我寻找新的棋盘游戏来写。
您是否发现了这个系列(这似乎是一个有趣的附带项目)与您的其他数据科学和工程兴趣之间的任何联系？
桌游和工程学之间的联系起初可能看起来模糊不清，但是从我制作这个系列的经验来看，有很多点需要考虑。工程师是专业的问题解决者，将复杂的棋盘游戏转化为计算机可以理解的算法是一个巨大的问题。我已经看到了编码的好处，无论是机器设计(随机模拟轴组件以找到最佳设计)还是机器人技术(预测机器人肢体的电机角度)。虽然在棋盘游戏优势方面获得的知识可能不会在我的其他数据科学或工程兴趣中发挥巨大作用，但在此过程中获得的经验和解决问题的技能是无价的。
说到你的工作和其他项目，你的下一步是什么？
我即将进入机械工程项目的高年级，我开始思考我毕业后想做什么。我将努力专注于机器人技术，希望在该领域运用我的数据科学经验。在公共写作方面，我将继续写我的副业，无论是我现有的系列还是新的系列。我对我的文章的未来感到兴奋，我希望继续增加我对媒体和数据科学的关注。
通过在 Medium 和 LinkedIn 上关注杰克的最新作品，如果你还没有阅读它们，这里是他最近的一些 TDS 帖子，主题从棋盘游戏到迪士尼世界:
- 杰克的棋盘游戏系列揭示了一些最受欢迎的游戏中的模式和违反直觉的见解——他已经探索了连接 4 、垄断、井字游戏、滑道&梯子和曼卡拉。
- 如果你计划有一天参观迪士尼公园，你会想看看这个三 - 部分 系列，它使用可用的数据和统计数据来优化最短的等待时间和最多的乘坐次数。
- 杰克还在他的作品中探索了体育分析，从用蒙特卡洛方法模拟 NFL和对当前 NBA 赛季进行预测，到展望未来 50 年的棒球。
权威情报:数据标签如何提高人工智能模型的准确性
今天，机器学习的方法可以分为两大阵营:以模型为中心和以数据为中心
弗兰基·查马基在 Unsplash 上拍摄的照片
尽管许多人仍然坚持前者，但包括人工智能(AI)杰出人物吴恩达在内的一些人热切地认为，数据，而不是模型，必须是人工智能进步的核心。事实证明他说得有道理。事实上，不止一个。但是让我们从头开始。
虽然所有的 ML 模型本质上都试图做出预测，但标签的准确性决定了这些预测在现实生活中是否成立。换句话说，数据的标记方面需要始终与“外部世界”一致，即模型设计的实际条件。正因为如此，就模型而言，数据标签比其他任何东西都重要。除非数据被正确标注，否则没有任何模型能够达到合理的实际精确度，即使它声称在理论上达到 99%的精确度。
照片由 Alicia Gauthier 在 Unsplash 上拍摄
一个以迷因形式出现的众所周知的例子来自计算机视觉领域:虽然一般人区分不同的吉娃娃和松饼没有问题，但这个看似基本的任务对机器来说非常具有挑战性，该模型的成功不可否认地依赖于干净、完美的标签数据。
因此，数据准确性是迄今为止数据质量最具决定性的组成部分。它必须存在于整个数据集中，ML 模型才能对任何人真正有用。这就是为什么我们可以认为，今天专注于数据标签的准确性可以成为提高所有人工智能模型准确性的主要途径。
今年 6 月，曾担任谷歌大脑(Google Brain)负责人、百度首席科学家的吴教授发起了一项活动，鼓励人工智能开发人员这样做:将他们的注意力从模型和算法转移到提高用于训练这些模型的数据质量上来。根据 ng 的说法，已建立的以模型为中心的方法在开发人员改进模型时保持数据不变，直到他们获得合适的结果。这需要一个极其敏捷的模型，能够以某种方式解决所有与数据质量相关的问题，这些问题可能会在未来某个时间点出现。唉，大多数模型完全没有做到这一点。直截了当地说，你的最终结果只会和你使用的数据一样好，但很少会更好。以数据为中心的方法翻转脚本并保持模型或代码不变，而人工智能从业者迭代地努力提高数据质量。Ng 认为这是前进的方向。我们也这么认为。
以模型为中心与以数据为中心
Ng 的积极探索再次证明了数据在现代人工智能发展中的重要作用。当然，数据质量对于人工智能行业来说并不是一个新话题——的研究一致显示80%的人工智能项目时间都花在了数据准备上。因此，随着人工智能的发展变得越来越以数据为中心，最基本的是，ML 科学家应该敏锐地理解如何通过过程中的数据标记部分来提高他们模型的准确性。
说实话，以模型为中心的方法确实有一些好处；毕竟这样更便宜，更省时，一看就没那么麻烦。作为一名计算机科学家，你可以完全控制正在发生的事情——模型就在你的手中，你可以随心所欲地调整和扭曲。因此，这本质上归结为从那些处理数据的人的角度去了解你所知道的。
一般来说，科学家会尽量避免他们无法直接影响的因素。数据科学家不是贴标签的人，所以通常情况下，他们对数据如何贴标签或由谁贴标签没有发言权。由于这个原因，对于许多 ML 研究者来说，淡化标签的重要性，转而关注模型是有意义的；换句话说，在他们的工作上。
Pablo Merchán Montes 在 Unsplash 上拍摄的照片
打个粗略的比方，作为一个糖果商，你会尽最大努力用你手头的原料做出高质量的巧克力，但你很少自己种植可可豆。
这取决于世界另一端的树农。这种情况下的可可豆就是贴了标签的数据，农民就是贴标签的人。就像糖果制造商一样，数据科学家只是利用提交给他们的东西来制作他们的产品，无论是巧克力还是 ML 模型。
但是，尽管这看似合理并且很有吸引力，但是采用以模型为中心的方法肯定会遇到严重的问题，因为:
💡根据定义，您的输出只能接受您使用的数据。如果数据有噪声，那么再好的模型也只能到此为止。比方说，你正在开发一款帮助用户保持健康饮食的应用。如果你的数据集包含标签错误的项目，比如看起来相似的欧洲萝卜和胡萝卜，那么这个应用注定会表现不佳。因此，如果没有正确的数据，即使您改进了您的模型，整个企业也无法正常工作。不这样想基本上等同于声称新的油漆工作会以某种方式提高你的汽车的性能，更不用说腐烂的发动机了。
💡如果数据是固定的，就不能更新或更改。灵活性是一个好的科学模型(在任何领域)都应该考虑的因素。同样，如果你的第一步是说你永远不会改变你的数据，这是不可能的。换个角度来看，如果你正在开发一个交通控制解决方案，而另一种基本颜色突然必须添加到交通灯的任意红黄绿中，那么你的模型就会过时。为了使您的解决方案有效，您必须重新标记数据以适应这种变化。
💡现在，假设你正在做一个项目，这个项目使用持续更新的数据，比如面部识别软件(新面孔)或语音助手(新口音/方言)。为了保持竞争优势，以模型为中心的方法很可能要么停滞不前，要么彻底改造自己，成为以数据为中心的方法。
💡如果确实需要在以模型为中心的框架内进行更改，那么与简单地更新您的集合相比，任何操作都将花费更长的时间，这是拥有永远无法调整的固定数据的结果。因此，那些在模型上工作的人经常不得不寻找规避问题的方法。回到交通灯的例子，为了适应这种新的变化，而不是更新你的数据集，你必须想出一个巧妙的方法来提高你的模型。这将意味着教会机器识别新颜色，而实际上并没有把它作为集合中的标记颜色。这可能行得通，也可能行不通，而且无论如何都是具有挑战性的。
💡实际上，这意味着以模型为中心的方法是最初采取的较短的道路——假设一切保持不变——但是当需要与模型的初始参数不一致的变化时，这条道路很快变成之字形。
💡因此，可伸缩性也成为一个真正的问题——如果事情在微观层面不稳定，你就无法在宏观层面保持稳定。这就是为什么当原始参数的任何重大变化都可能意味着回到绘图板去思考一种新的方法来解决问题而不接触您的数据时，可伸缩性变得几乎不可能。将它与当今最常见的数据标记方法结合起来——内部途径(当团队使用自己的员工而不是外包来从头开始学习标记数据)——在你能够交付任何可靠的东西之前，你会经历相当长的等待。当你这样做的时候，可能不会持续太久。
同时，以数据为中心的方法具有许多巨大的优势:
💡您的数据可以不断更新和快速验证。这是唯一可能的，因为这种方法是纯数据驱动的。
💡这种方法为您的整个管道带来了相当程度的灵活性和可伸缩性(通常还有弹性)。这是因为你拥有理论上可以无限操纵的数据。自然，在大规模处理人为标注的数据时，这是一项无价的资产。例如，你可能正在处理音频注释，以便训练语音激活的人工智能。如果您已经有 50，000 个记录(这也可以通过以模型为中心的方法实现)，这可能足以发布一个基本产品。但是使用数据驱动的方法，您总是可以向同一个数据集添加另一种口音或方言，甚至包括不同的语言。从质量上来说，这改变了一切。
💡另一方面，在以模型为中心的场景中，您要么必须保持现状(即接受产品的局限性)，要么考虑精心设计的方法来调整您的模型而不触及数据(这在自然语言处理中很少起作用)，或者——可能不承认这一点——切换到以数据为中心的方法，即使是暂时的。
💡普遍性是另一大好处。标签员，特别是在众包的背景下，可以处理几乎每一项任务，并在任务之间切换，为训练模型提供有价值的甚至罕见的数据。比方说，您正在处理地图/导航，以获取最新的商业信息。使用基于模型的固定数据方法，您基本上只能使用当时拥有的数据。但是如果事情已经改变了呢？例如，现在有新的街道标志或一些企业已经搬迁。这可能是一个真正的问题，但如果您的方法是数据驱动的，就不是问题了。特别是如果你使用的是人群工作者:简单地要求他们重新考虑问题点，你就有了一个更新的数据集。
💡如果足够的质量控制机制到位，并且项目得到适当的管理(例如，使用 CSA )，输入数据质量的提高可以极大地促进培训模型的整体结果。
那还有什么可耽搁的？
公平地说，以数据为中心的方法也有一些缺点。也就是说，如果您的团队预算紧张，并且您使用现成的数据集试图完全绕过任何人工处理的标记，那么以模型为中心的方法是唯一的选择。同时，当涉及到您的贴标选择时，上述内部路线可能非常昂贵和耗时，而外包有时可能是一场赌博，通常也花费很多。另一种被称为合成标记的方法需要为 ML 生成人造数据，但需要大量的计算能力，许多较小的公司无法获得。因此，许多团队认为以数据为中心的方法不值得麻烦，主要是因为，事实证明，他们消息不灵通。
以数据为中心的方法会让你走得更远，但前提是你准备好投入时间和/或金钱来处理数据。好消息是，有了众包等方法，数据标注不再需要花费很高的成本，也不再需要几个月才能完成。问题是许多人不知道这些方法的存在，也不知道它们已经变得有效。研究表明几乎 80%的 ML 从业者选择了内部途径,尽管知道它的缺点。这些练习者这样做并不是因为他们特别喜欢这种方法，而是因为他们不知道更好的方法，正如最近的调查所揭示的。
我们只能假设剩下的 20%熟悉一些较新的标记方法，但他们可能对走出熟悉的以模型为中心的方法的舒适区感到不确定和警惕。原因是他们一想到必须处理任何形式的讨厌的数据标签就紧张。因此，这不仅仅是一个转向数据导向方法的完全意识形态的问题，而是实际上学会认识到这种转变并不一定意味着走向绞刑架——它实际上是可以忍受的，甚至是无痛的。
标准化是关键
标准化是我们所追求的。当谈到标准化时，Ng 从行业角度出发，认为所有人工智能项目应该有一个单一的系统来标记数据。但在行业标准建立之前，人工智能开发人员今天已经可以做某些事情来确保他们项目中标签数据的一致性。
首先，我们需要使用一种或多种标准质量保证方法来测量标签的准确性，如黄金标准、共识或样品审查。一个好的开始是为贴标机提供坚实的指导和丰富的例子。重要的是，这些例子不仅要包括要做什么，还要包括不要做什么。它们必须足够详细，以指定什么被认为是可接受的或适当的，从而避免常见的问题 混乱的观察 。例如，当贴标机必须标记人脸时，他们是否也被期望标记真实的卡通人物来代表人？这一点必须在贴标签者开始任务之前向他们说明，因为正如大量研究表明的那样，贴标签者通常会避免问澄清性的问题，而会简单地以他们自己的方式解释任务。
其次，标记过程应该在领域知识和背景的设定框架内进行。这一点至关重要，因为如果贴标签的人了解标签的设置，他们就能更好地在使用具有多重含义的词时正确地贴标签，如“手臂”、“日期”或“起重机”词汇、格式和文本风格可以根据行业的不同而有很大的不同，并且应该始终包含在为特定的 ML 项目建立的上下文中。
这些巩固一致性的步骤有助于防止可能出现的准确性问题，特别是当标记 主观数据 时。这种类型的数据没有真理的黄金标准，这经常使过程暴露于不一致的标签，源于每个贴标签者的经验和对任务的理解。这就是所谓的 标记偏差 ，它不同于犯下个体错误甚至混淆观察结果，因为这种情况下的标记不一致有时可能会遵循特定的群体趋势，往往与个人的文化背景有关。例如，“在照片中认出一个亚洲人”对来自美国和英国的人来说意味着不同的事情，例如，对美国人来说是来自中国或日本这样的远东地区的人，对英国人来说是来自印度或尼泊尔这样的南亚地区的人。
最后，虽然标准可能导致笨拙或未解决的不规则性，但重要的是要记住 ML 本质上是迭代的。随着各种模型的测试及其结果的评估，应该不断引入新的数据集来改进模型。因此，数据标注过程和工作团队都应该保持敏捷和灵活，以结合任何必要的更改来微调 ML 模型。
这些变化可能涉及修改数据的某些方面，如数据量或复杂性。它们还可能涉及到基于来自模型测试和验证的任何相关见解来改变过程本身。这种灵活性应始终使表演者能够在必要时通过在持续的任务中提供见解来做出超出实际标签的贡献，这在众包的背景下可能意味着多数投票。
保持控制
总之，数据驱动的方法有很多优点。数据标注的准确性是它的核心。为了确保这种准确性，人工智能从业者必须规划和配置一个质量控制系统。这个多阶段的过程包括分解数据标注任务、编写说明、设计清晰的界面以及与标注团队建立双向沟通渠道。此外，为了从贴标签者的见解中获得价值，数据贴标签过程涉及一个封闭的反馈回路是至关重要的，这基本上意味着在一个开放的对话中无限地来回，即，直到实现一个期望的目标。
让我们想象一下，你正在开发一个交互式机器人，它与购买电子产品的客户交谈，向他们提问，澄清他们的偏好或发货日期，并结束销售。这种类型的人工智能不是静态的。它不仅像每个 AI 应该的那样训练自己，而且还需要客户反馈来操作和改进。基于此，可能需要对模型或贴标机进行一些调整。在这种情况下，这可能意味着识别新的送货地址，并考虑不同的卸货点来规划最快的路线，或者交叉引用同一客户购买的任何其他产品来解决兼容性问题。只有数据驱动的方法才能完全考虑到这一点。在 Toloka 的案例中，数据驱动的跟踪采取与全球无数贴标机众包的形式，每一步都使用自动化质量控制工具和在 Toloka 学院教授的现代人群科学方法进行监控。
主要外卖
足够数量的高质量数据的可用性仍然是人工智能发展的一个障碍。随着以 Ng 为风向标的运动获得势头，对准确标记的数据的需求预计将大幅上升。因此，前瞻性的人工智能从业者现在开始重新评估他们如何给自己的数据贴标签。由于其非常高的成本以及它提供的可扩展性非常少，他们可能会超越内部标记，或者发现自己的价格超出了外部来源，例如预打包数据、抓取或与数据丰富的实体建立关系。
这为众包数据标签的持续崛起奠定了基础，众包数据标签是一种具有成本/时间效益和可伸缩性的替代方案，具有集成的质量控制和微调的、高度自动化的交付管道。2019 年，分析公司cognelytica 报告称，到 2023 年，第三方数据标签市场将从 2018 年的 1.5 亿美元扩大到 10 亿美元以上。其他研究预测了类似的趋势，包括一些来源，如 Grand View Research 估计到 2028 年数据标签市场价值超过 80 亿美元。
底线是，如果人工智能项目要在现实世界中取得成功，它们必须得到高质量的投入。提高数据的质量，进而提高数据所支持的模型的质量，需要精确，也就是准确的标签。幸运的是，合适的数据标签技术和现成的解决方案是可用的:阿彭，Toloka 和 Scale AI 等等。现在，由人工智能从业者来决定如何有效地将这些解决方案集成到他们现有和未来的 ML 项目中，这归结为朝着数据驱动的方法迈出决定性的一步。这一面向目标的先决条件应该得到满足，以确保无错误标签的存在，从而提高 ML 数据的质量，产生更强大的训练模型，并最终实现成功的人工智能创新，从而改善我们未来的生活。
如何在 Pandas 中读取 CSV 文件时自动检测日期/日期时间列并设置它们的数据类型
小窍门
例如，当 read_csv()将“2021-03-04”和“2021-03-04 21:37:01.123”读取为单纯的“对象”数据类型时，通常可以简单地将它们一次性自动转换为真正的日期时间数据类型，如下所示:
假设我有一个 CSV 数据文件，我想将它读入 Pandas 数据帧，它的一些列是日期或日期时间，但是我不想预先识别/指定这些列的名称。相反，我想自动获取上面图中*、的df.info()输出中显示的数据类型，其中适当的列已经被自动*给定了日期时间数据类型(绿色轮廓框)。以下是实现这一点的方法:
from dt_auto import read_csv
df=read_csv('myfile.csv')
注意，我没有而不是直接调用上面的 PD . read _ CSV(read _ CSV 的熊猫版本)。我的 dt_auto.read_csv 函数(参见下面的代码)调用了 pd.read_csv()本身，然后自动检测并转换两个检测到的 datetime 列的数据类型。(此 df 的内容将在下面显示。)
如果我使用了常规的 Pandas pd.read_csv()，那么默认情况下，我将只获得通用的对象数据类型，如下所示(红色外框):
from pandas import read_csv
df=read_csv('myfile.csv')
df.info()
请注意，与原始代码的唯一区别是在导入语句中，我将“from dt_auto”改为“from pandas”。只要您始终只使用“=read_csv()”，而不是将其限定为“=pd.read_csv()”或“=dt_auto.read_csv()”，这就足够了。
下面是我的dt_auto.py(“日期时间自动”)的内容:
import pandas as pd
def dt_inplace(df):
"""Automatically detect and convert (in place!) each
dataframe column of datatype 'object' to a datetime just
when ALL of its non-NaN values can be successfully parsed
by pd.to_datetime(). Also returns a ref. to df for
convenient use in an expression.
"""
from pandas.errors import ParserError
for c in df.columns[df.dtypes=='object']: #don't cnvt num
try:
df[c]=pd.to_datetime(df[c])
except (ParserError,ValueError): #Can't cnvrt some
pass # ...so leave whole column as-is unconverted
return df
def read_csv(*args, **kwargs):
"""Drop-in replacement for Pandas pd.read_csv. It invokes
pd.read_csv() (passing its arguments) and then auto-
matically detects and converts each column whose datatype
is 'object' to a datetime just when ALL of the column's
non-NaN values can be successfully parsed by
pd.to_datetime(), and returns the resulting dataframe.
"""
return dt_inplace(pd.read_csv(*args, **kwargs))
但是这不是很冒险吗？如果其中一个列不完全是日期时间列，会怎么样？当然，您可能会有一些看起来像日期但实际上不是日期的模糊字符串，但是这段代码不会盲目转换或丢失非日期时间字符串，原因有二:
- 除非 pd.to_datetime 可以成功地解析该列中的每个非 NaN 值并将其转换为日期时间，否则该代码不会转换该列中的任何值。换句话说，我们不会让它将字符串转换成 pd。NaT(“失败”结果),因为它不能将其理解为日期时间。
- 它将而不是尝试转换已经被解释为除 object 以外的任何类型的列，即任何特定类型，如 int64 或 float64，即使 pd.to_datetime 会很乐意(但很可能不希望)将类似 2000 的数字转换为日期 2000-01-01。
根据我目前的经验，dt_auto.read_csv 函数在典型的数据帧上运行并不需要很长时间。即使有许多非 datetime 对象(字符串)列，它几乎总是很快遇到每个此类列顶部附近的一个值，它无法将其解析为 datetime，因此放弃并继续处理下一列，而不尝试解析该列的其余值。
下面是 dt_auto.read_csv()产生的 dataframe 的外观，尽管您不一定能通过查看它来判断这两个适当的列是否确实是 datetime 数据类型。碰巧的是，CSV 文件在 Update_Timestamp 中的秒有不同的小数位数(三位、零位和九位)，但是 datetime 数据类型本身显示了九位这样的数字。csv 文件中的 Birthdate 实际上只有日期(没有时间),但存储为完整的日期时间，小时、分钟和秒都是零(包括小数部分的零),但是列中的所有时间部分都是零导致 Pandas 只显示该列的日期(年-月-日)。
当然，pd.to_datetime 以及 dt_auto.read_csv 在默认情况下不能处理所有可能的日期和日期时间格式，但它可以处理许多常见的明确(通常是年、月、日)格式，例如 dataframe.to_csv 方法和许多其他工具编写的格式，包括许多 ISO 日期时间格式(通常用“T”而不是空格来分隔日期和时间)。我没有试验过包含时区信息的 datetimes，因为我通常不会看到这样的数据，但是请在回复评论中让我知道是否可以通过进一步修改代码来更好地处理这些数据。
你怎么想呢?你觉得这篇小文章有用吗？Pandas 本身是否应该添加(例如 pd.read_csv 函数本身？)为我们选择这样做的能力，这样你就不需要复制/导入我上面的 dt_auto.py 代码了？我很乐意在这里看到你的评论和问题作为回应。
用 Python 中的百里香 Boost 实现自动预测
比较百里香增强剂、Pmdarima 和 Prophet
TLDR: 当我们将百里香与其他一些流行的时间序列方法进行比较时，我们发现它可以生成非常有竞争力的预测。 剧透警告: 百里助推胜。但除了胜利，我们看到了百里香框架的许多好处，即使在它失败的情况下。
更多例子你可以查看百里香增强 Github 。
系列第一帖:用百里香 Boost 进行时间序列预测。如果你还没有看过，那就去看看吧！
介绍
本次竞赛中使用的示例相当流行，但是用于数据争论的一些代码摘自本文(感谢 Tomonori Masui！).您应该看看这篇文章，看看其他一些模型在这些数据集上的表现如何。
第一个例子是一个相当著名的时间序列:航空乘客数据集。这些数据来源广泛，其中一个来源来自 Kaggle 或 Github 。确保你有最新的百里香增强包，可以通过 pip 安装:
pip install ThymeBoost --upgrade
既然是最新的，那就来看看吧！
航空乘客数据集
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from ThymeBoost import ThymeBoost as tb
import seaborn as sns
sns.set_style("darkgrid")#Airlines Data, if your csv is in a different filepath adjust this
df = pd.read_csv('AirPassengers.csv')
df.index = pd.to_datetime(df['Month'])
y = df['#Passengers']
plt.plot(y)
plt.show()
作者图片
这个时间序列挺有意思的！明显的趋势和倍增的季节性。绝对是任何预测方法的好基准。
为了判断预测方法，我们将把数据分割成标准的训练/测试分割，其中保留最后 30%的数据。测试程序的结果可能会因这种分裂而改变。为了保持不偏不倚，将使用上述文章中的训练/测试分割。
任何调整或模型选择都将在训练集上完成，而测试集将用于判断方法。目标(至少对我来说)是看看百里香增强疗法是否能与其他经过审查的方法竞争。如果您要在生产中实现一个预测模型，那么您可能想要使用一个更健壮的方法来判断模型，例如时间序列交叉验证。
test_len = int(len(y) * 0.3)
al_train, al_test = y.iloc[:-test_len], y.iloc[-test_len:]
首先，让我们尝试一个自动 Arima 实现: Pmdarima 。
import pmdarima as pm
# Fit a simple auto_arima model
arima = pm.auto_arima(al_train,
seasonal=True,
m=12,
trace=True,
error_action='warn',
n_fits=50)pmd_predictions = arima.predict(n_periods=len(al_test))
arima_mae = np.mean(np.abs(al_test - pmd_predictions))
arima_rmse = (np.mean((al_test - pmd_predictions)**2))**.5
arima_mape = np.sum(np.abs(pmd_predictions - al_test)) / (np.sum((np.abs(al_test))))
接下来，我们会给先知一个机会。
from fbprophet import Prophetprophet_train_df = al_train.reset_index()
prophet_train_df.columns = ['ds', 'y']prophet = Prophet(seasonality_mode='multiplicative')
prophet.fit(prophet_train_df)
future_df = prophet.make_future_dataframe(periods=len(al_test), freq='M')
prophet_forecast = prophet.predict(future_df)
prophet_predictions = prophet_forecast['yhat'].iloc[-len(al_test):]prophet_mae = np.mean(np.abs(al_test - prophet_predictions.values))
prophet_rmse = (np.mean((al_test - prophet_predictions.values)**2))**.5
prophet_mape = np.sum(np.abs(prophet_predictions.values - al_test)) / (np.sum((np.abs(al_test))))
最后，实现百里香增强。这里我们使用了一种新的方法:从最新版本的包中“自动调整”。考虑到可能的季节性，该方法将尝试几种简单的实现。这是一个实验性的特性，只适用于传统的时间序列。当前的一个问题是，它尝试了几个冗余的参数设置，这将在未来的版本中得到解决，以加快进程！此外，如果您打算传递外部因素，我们建议使用在自述文件中找到的优化方法。
boosted_model = tb.ThymeBoost(verbose=0)output = boosted_model.autofit(al_train,
seasonal_period=12)
predicted_output = boosted_model.predict(output, len(al_test))
tb_mae = np.mean(np.abs(al_test - predicted_output['predictions']))
tb_rmse = (np.mean((al_test - predicted_output['predictions'])**2))**.5
tb_mape = np.sum(np.abs(predicted_output['predictions'] - al_test)) / (np.sum((np.abs(al_test))))
通过在构建该类时设置 verbose=0，它将每个单独模型的日志记录静音。相反，将显示一个进度条，指示不同参数设置以及找到的“最佳”设置的进度。默认情况下，百里香的自动拟合方法将进行 3 轮拟合和预测。该过程遍历训练集的最后 6 个值，以选择“最佳”设置。对于该数据，找到的最佳设置是:
Optimal model configuration: {'trend_estimator': 'linear', 'fit_type': 'local', 'seasonal_period': [12, 0], 'seasonal_estimator': 'fourier', 'connectivity_constraint': True, 'global_cost': 'maicc', 'additive': False, 'seasonality_weights': array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 5., 5., 5., 5., 5., 5., 5., 5.,
5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.]), 'exogenous': None}
Params ensembled: False
一些需要注意的重要事项:
- “加法”设置为 false，这意味着整个过程是“乘法”，即从输入序列中提取对数。正常的“倍增”季节性尚未实现。
- 有一个“季节性权重”数组，其中最后两个“季节性周期”被设置为 5，这意味着这些周期对季节性成分的影响是其他周期的 5 倍。
- “季节性周期”是[12，0]，因此它在衡量季节性和不衡量季节性之间来回循环。这是一个有趣的行为，但它本质上给季节性因素增加了一些规律性。
说到组件，我们来看看:
boosted_model.plot_components(output, predicted_output)
作者图片
总而言之，ThymeBoost 决定采用输入序列的对数，拟合一个线性变点模型，并在季节性成分中添加一个“变点”。
这些决定是正确的吗？让我们来看看误差指标:
作者图片
这些误差指标不言自明，百里香增强优于其他方法全面。但是预测实际上是什么样的呢？
plt.plot(pmd_predictions, label='Pmdarima')
plt.plot(al_test.values, label='Actuals')
plt.plot(prophet_predictions.values, label='Prophet')
plt.plot(predicted_output['predictions'].values, label='ThymeBoost')
plt.legend()
plt.show()
作者图片
显然，所有的方法都获得了非常相似的信号。就季节形状而言，百里香似乎略胜一筹，这可能是因为它决定使用季节权重。
WPI 数据集
下一个数据集是从 1960 年到 1990 年的美国批发价格指数(WPI ),这个例子再次取自前面提到的文章。
不幸的是，这个数据集没有附带百里香增强，但我们可以通过 Statsmodels 访问它:
from statsmodels.datasets import webusedta = webuse('wpi1')
ts_wpi = dta['wpi']
ts_wpi.index = pd.to_datetime(dta['t'])
test_len = int(len(ts_wpi) * 0.25)
ts_wpi = ts_wpi.astype(float)
wpi_train, wpi_test = ts_wpi.iloc[:-test_len], ts_wpi.iloc[-test_len:]
plt.plot(ts_wpi)
plt.show()
作者图片
这个时间序列与以前的有很大不同。它似乎缺乏任何季节性，因此这些设置将被禁用(尽管如果我们不小心将季节性设置添加到百里香增强中，它不会发生太大变化)。
让我们按照与之前相同的过程，首先安装 Pmdarima:
import pmdarima as pm
# Fit a simple auto_arima model
arima = pm.auto_arima(wpi_train,
seasonal=False,
trace=True,
error_action='warn',
n_fits=50)
pmd_predictions = arima.predict(n_periods=len(wpi_test))
arima_mae = np.mean(np.abs(wpi_test - pmd_predictions))
arima_rmse = (np.mean((wpi_test - pmd_predictions)**2))**.5
arima_mape = np.sum(np.abs(pmd_predictions - wpi_test)) / (np.sum((np.abs(wpi_test))))
接下来，先知:
from fbprophet import Prophetprophet_train_df = wpi_train.reset_index()
prophet_train_df.columns = ['ds', 'y']prophet = Prophet(yearly_seasonality=False)
prophet.fit(prophet_train_df)
future_df = prophet.make_future_dataframe(periods=len(wpi_test))
prophet_forecast = prophet.predict(future_df)
prophet_predictions = prophet_forecast['yhat'].iloc[-len(wpi_test):]prophet_mae = np.mean(np.abs(wpi_test - prophet_predictions.values))
prophet_rmse = (np.mean((wpi_test - prophet_predictions.values)**2))**.5
prophet_mape = np.sum(np.abs(prophet_predictions.values - wpi_test)) / (np.sum((np.abs(wpi_test))))
最后，百里香增强剂:
boosted_model = tb.ThymeBoost(verbose=0)output = boosted_model.autofit(wpi_train,
seasonal_period=0)predicted_output = boosted_model.predict(output, forecast_horizon=len(wpi_test))
tb_mae = np.mean(np.abs((wpi_test.values) - predicted_output['predictions']))
tb_rmse = (np.mean((wpi_test.values - predicted_output['predictions'].values)**2))**.5
tb_mape = np.sum(np.abs(predicted_output['predictions'].values - wpi_test.values)) / (np.sum((np.abs(wpi_test.values))))
最佳设置，也可以通过以下方式直接访问:
print(boosted_model.optimized_params)
它返回:
{'trend_estimator': 'linear', 'fit_type': 'local', 'seasonal_period': 0, 'seasonal_estimator': 'fourier', 'connectivity_constraint': False, 'global_cost': 'mse', 'additive': True, 'exogenous': None}
像上次一样，百里香选择了一个局部拟合的线性模型，也就是趋势分量的线性变点模型。除了这次‘connectivity _ constraint’被设置为 False，这放松了趋势线在变点的连接。
让我们来看看误差指标:
作者图片
百里香增强再次胜过其他两种方法。
预测是:
plt.plot(pmd_predictions, label='Pmdarima')
plt.plot(wpi_test.values, label='Actuals')
plt.plot(prophet_predictions.values, label='Prophet')
plt.plot(predicted_output['predictions'].values, label='ThymeBoost')
plt.legend()
plt.show()
作者图片
结论
这篇文章的目的是看看百里香是否能与其他流行的方法竞争，在这些例子中它显然可以。但是不要被骗以为百里香是万能药(虽然我也希望是！).它有很多次被超越，然而，一个主要的好处是任何超越百里香增强的方法都有可能被添加到框架中。一旦添加了一个方法，它就可以通过提升过程访问一些有趣的特性。
这方面的一个例子可以在已经引用的文章中找到。对于太阳黑子数据集，ThymeBoost 的 autofit 没有做任何 ARIMA 建模，因此与 sktime 发现的 ARIMA(8，0，1)相比，它的结果很差。然而，如果我们使用标准拟合方法，并通过局部拟合传递 ARIMA 订单(因此我们允许变点)，我们会优于 sktime 的自动 ARIMA。
我将把它作为一个练习留给您来尝试，只需使用这些设置:
output = boosted_model.fit(sun_train.values,
trend_estimator='arima',
arima_order=(8, 0, 1),
global_cost='maicc',
seasonal_period=0,
fit_type='local'
)
如前所述，这个包仍处于早期开发阶段。大量可能的配置使得调试成为一个复杂的过程，所以使用时风险自担。但是，请在 GitHub 上讨论和公开你遇到的任何问题！
Python 中的自动 HMM
隐马尔可夫模型的自动模型选择、训练和测试
马丁·桑切斯在 Unsplash 上的照片
在加州大学洛杉矶分校攻读博士期间，我开发了各种序列和时间序列数据模型。隐马尔可夫模型(HMM)是我最早使用的模型之一，效果相当好。我在 Python/MATLAB/R 中找不到任何关于 HMM 的教程或工作代码。我正在发布 Auto-HMM，这是一个 Python 包，使用 AIC/BIC 为监督和非监督 HMM 执行自动模型选择。
该软件包使用 hmmlearn 进行隐马尔可夫模型训练和解码，并且它包括用于最佳参数数量(混合成分数量、隐藏状态数量等)的模型选择。我用 MATLAB 和 r 实现了一个类似的包。
如果你想看同一个模型的 R 和 MATLAB 实现，请在这篇文章下评论。
HMM 中的训练是通过 Baum-Welch 完成的，这是 EM 算法的特例。解码是通过维特比算法完成的。我猜除了 ML(维特比)解码器之外，hmmlearn 包还支持 MAP 解码器。
模型选择是通过 AIC 和 BIC 完成的，它们通过惩罚似然函数来运行。这是通过指定您喜欢的隐藏状态的最大数量来自动完成的，并且该算法为离散 HMM 找到隐藏状态的最佳数量、最佳数量混合分量以及为连续 HMM 找到隐藏状态的最佳数量。
要访问代码，请访问我的 GitHub
https://github.com/manitadayon/Auto_HMM
请仔细阅读 DHMM 测试和嗯测试 Python 文件中的例子。它们要求您提供 CSV 文件地址、HMM 模型的迭代次数、训练规模、特征数量(时间序列的维度)。
例如，以下代码对 2000 个观察值执行离散 HMM，每个观察值有 50 个时间点，最多有 3 个隐藏状态。训练大小设置为 0.8 (0.8 * 2000 = 1600)。该功能决定了时间序列的维数(1 表示单变量时间序列)。该标志决定了您是希望按降序还是升序对隐藏状态进行排序。
from Hidden_Markov_Model import *
from Hidden_Markov_Model.DHMM import *
Train_ratio=0.8
Max_state=3
Iter=1000
Feat=1
N=2000
T=50
flag=0
N_symb=3
Path= 'Path to CSV file'
Data=pd.read_csv(Path)
Data=Data.astype(int)
First_DHMM=Supervised_DHMM(Train_ratio,Max_state,Iter,Feat,N,T,Data,N_symb)
First_DHMM.Best_States()
关于我最近的活动和任何问题的更多信息，请访问我的 YouTube 页面。我还编写了 tsBNgen，这是用于生成合成时间序列数据的 Python 包，可以用作 Auto-HMM 模型的输入。要了解更多关于 tsBNgen 的信息，请访问下面我的 YouTube 页面。
https://www.youtube.com/channel/UCjNDIlqrFdKUgSeN9wV-OzQ
如果您有任何问题或疑虑，可以访问我的个人页面
要了解有关 HMM 建模和实现的更多信息，请参考以下视频:
自动导入 Python 库
使用 Pyforest 导入重要的 python 库
克里斯里德在 Unsplash 上的照片
在用 python 编码时，你是否也陷入了导入库的困境？我们中的大多数人都会在编码时忘记导入我们将使用的库，我们陷入了导入不同库的困境，这很令人沮丧，而且我必须说，作为一个懒惰的程序员，我想一劳永逸地解决这个导入问题。
PyForest 是一个开源的 python 库，对于像我这样懒惰的程序员来说真的很有帮助，因为它导入了 python 编程所需的所有主要库，包括机器学习和深度学习。
在本文中，我们将探索 PyForest，看看我们如何使用它。
让我们开始吧…
安装所需的库
我们将从使用 pip 安装 PyForest 开始。下面给出的命令可以做到这一点。
!pip install pyforest
导入所需的库
在这一步中，我们将只导入 PyForest，这是唯一需要的库。
from pyforest import *
探索 PyForest
神奇的事情开始了，让我们看看我们在一行代码中导入了多少 python 库。
lazy_imports()
来源:作者
你可以看到我们多么容易地导入了所有主要的 python 库，包括深度学习、机器学习、图像处理等库。如果你像我一样是一个懒惰的程序员，这些库真的很有帮助。
在本文中，我们看到了 PyForest 对于导入重要的库是多么有用。继续尝试在一行中导入库，并让我知道您在回复部分的评论。
本文是与皮尤什·英格尔合作完成的。
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github简介针对不同的数据科学项目和包教程。还有，随意探索 我的简介 ，阅读我写过的与数据科学相关的不同文章。
Power BI 中的自动页面刷新—您需要知道的一切
您知道 Power BI 可以自动刷新您的报告页面吗？您知道有两种不同类型的自动刷新吗？
自动化任务——这是我们都喜欢的东西！而 Power BI 在这方面做得很出色。尽管其中一些自动化的东西可能会回来困扰你，比如自动日期/时间选项，幸运的是还有更多让我们的生活变得更容易。
我最近研究了自动页面刷新特性，在这篇文章中，我想更多地介绍这个功能——特别是关于特定用例的最佳实践和限制。
什么是自动页面刷新？
简而言之，顾名思义，自动页面刷新功能可以让您设置报告中特定页面的计划刷新！因此，不要将此功能与报告计划刷新混淆，因为自动页面刷新是一个完全不同的故事。第一个至关重要的区别是，自动页面功能仅适用于 DirectQuery 存储模式(以及某种程度上的实时连接)。 不支持导入模式 ，切记！
作者图片
下一个重要的考虑是使用哪种类型的自动页面刷新…哦，是的，有两种不同的类型，所以让我们更深入地研究它们。
固定间隔
这是安排页面自动刷新的基本方式。您可以设置所需的时间间隔(范围从 1 秒到 X 天)，当时间间隔到达时，所有的视觉效果都将被刷新。这意味着，每个单独的可视化将生成一个单独的(直接的)查询，并将其发送到底层数据源。但是，在文章的后面会有更多的介绍。
变化检测
本质上，它在某种程度上类似于固定间隔类型。您将再次设置间隔，但这一次，不同的事情在后台发生。与固定时间间隔相比，关键的区别在于，您必须指定一个将要被监控的度量(就像检查底层表中是否有新记录一样)，在定义的固定时间间隔之后，Power BI 将生成一个单独的查询来检查指定的度量是否发生了变化，如果发生了变化，它将执行剩余的查询来刷新所有的视图…如果没有发生变化，报表页面不会发生任何变化！
现在，让我们来看看在使用这些类型的每一种时会发生什么。
在 Power BI Desktop 中配置自动页面刷新
进入 Power BI Desktop 并使用 DirectQuery 存储模式后，我可以配置页面刷新属性:
作者图片
我使用的是 Contoso 数据库，为了简单起见，我只连接到 DimCustomer 表。如您所见，我在报告页面上放置了三个视觉效果，并设置了自动页面刷新类型(固定间隔)，刷新间隔为 2 秒。
有了这个设置，Power BI Desktop 应该每两秒钟触发三个独立的查询(每个可视化一个)!让我们打开 SQL Server Profiler，并检查后台的运行情况:
作者图片
正如预期的那样，对 DimCustomer 表运行了三个查询，并且每两秒钟重复一次。
让我们切换到 Power BI Desktop 中的性能分析器，并检查该设置背后的具体指标:
作者图片
我已经按照行动顺序对结果进行了分类，以便能够区分不同的行动。而且，您可能会看到我们的表格可视化每次都需要 2 秒多的时间来呈现(为了清楚起见，Performance analyzer 中的值是以毫秒为单位的)！这给我们带来了一个重要的启示:
如果您注意到渲染视觉所需的时间比您在自动页面刷新设置中指定的时间长，您应该增加刷新间隔的值！ 老实说，如果视觉需要比这更多的时间在报表中渲染，那么每两秒刷新一次数据又有什么意义呢？！
Power BI 桌面中的变化检测
现在让我们设置变更检测类型。它比固定时间间隔稍微复杂一些，因为您需要应用一些额外的配置步骤。
我创建了一个非常基本的方法来计算客户总数:
Total Customers = COUNT(DimCustomer[CustomerKey])
作者图片
本质上，一旦我们以这种方式设置了自动刷新，接下来将会发生的是，每隔 2 秒，Power BI 将触发一个查询来检查总客户度量的值。如果 measure 的值改变了，视觉效果将会刷新，否则什么也不会发生！让我们确认我们的假设:
作者图片
正如我们所想的那样:每 2 秒钟，在数据源端执行一次查询来检查总客户度量的值，由于没有检测到任何变化，所以没有刷新报告页面。现在，让我们通过在 DimCustomer 表中插入一个新行来更改度量值:
USE [Contoso]
GO
INSERT INTO [dbo].[DimCustomer]
([FirstName]
,[LastName]
,[Gender]
,[GeographyKey]
,[CustomerLabel]
)
VALUES
('Power'
,'BI'
,'?'
,1
,112233
)
GO
这是用于在表中填充新行的 T-SQL 代码。现在，我将检查一旦底层数据发生更改，更改检测将如何表现:
作者插图
是啊！仔细看看上面的动画:查询检查了又检查，什么也没发生。然后，我在 DimCustomer 表中插入一行，变更检测捕捉到了这一修改，然后执行所有三个查询来填充我们的视觉效果。之后，再次执行一个查询来检查度量中是否有新的变化。
本测试的一个要点: 如果您预计源数据的变化频率低于您在变化检测中指定的值，您应该增加变化检测的间隔。
电源 BI 服务中的配置
现在，我将在 Power BI 服务中将此报告发布到我的工作区。
作者图片
等等，什么？！这是行不通的！正如你在最上面的消息中看到的， 改变检测类型 ，与固定间隔不同，它将在所有容量下工作， 需要高级许可 。
总则
根据上面执行的测试得出的结论，下面列出了在使用自动页面刷新功能时应该记住的一般规则:
- 如果您希望基础表中的数据每 5 分钟更改一次，请不要将自动页面刷新间隔设置为低于 5 分钟
- 当您将刷新间隔设置为较低的值时，例如我们示例中的 2 秒，请考虑您的查询将会产生的工作负载，尤其是使用固定间隔类型时。举例来说，如果有 20 个并发用户运行这个报告，并且我们在报告页面上有 3 个视觉效果，那么每 2 秒钟就有 20×3 = 60 个查询！现在，想象一下如果页面上有 10 个以上的视觉效果会有什么影响…
- 只有在 DirectQuery 存储模式或包含至少一个 DirectQuery 数据源的混合模式下，才支持自动页面刷新。在实时连接模式下，您也可以使用固定时间间隔，但有一些限制
- 变更检测类型需要高级容量
- 对于每个数据集，只能对一个度量设置更改检测类型
- 在 Power BI 租户中，最多可以使用 10 个具有更改检测类型的数据模型
现在，如果您想知道如果您的自动页面刷新工作负载干扰常规工作负载会发生什么——根据微软的官方文档，自动页面刷新查询具有较低的优先级。
另一个合理的问题是:如果执行该查询需要 5 秒，并且我已经将刷新间隔设置为 2 秒，那么会发生什么情况？在前一个周期完成之前，Power BI 不会运行下一个周期。简单地说，Power BI 将等待 5 秒钟来完成查询，然后执行下一次运行。
最后，我很想知道自动页面刷新查询是否可以利用来自缓存的结果。答案是否定的，因为这些查询不是由缓存提供的。
结论
当您需要实时监控一些关键事件并根据 Power BI 报告提供的快速洞察力做出决策时，自动页面刷新是一项非常强大的功能。但是，在什么时候使用这个特性以及使用到什么程度都要非常小心。
感谢阅读！
成为会员，阅读 Medium 上的每一个故事！
自动解析任何文档
用于文档布局解析的基于 Train Detectron2 的定制模型
自从人类首次开发出书面文字以来，文档就无处不在。杂志、协议、历史档案、当地商店的小册子、税单、房契、大学申请表等等。到目前为止，处理这些文档一直是一项相当手工的任务，自动化只是在最近几十年才开始接管。这一自动化之旅在很大程度上受到了一个致命缺陷的阻碍——计算机无法像人类那样直观地理解布局。
随着现代计算机视觉的出现，这一切都改变了。我们现在有了模型，它可以准确地定位、表示和理解文档布局的组件。但是对于一般的自动化爱好者来说，这些模型相当抽象，通常需要全面的 Python 知识才能理解文档，更不用说在项目中使用它了。
学分:布局解析器
在这种程度上，布局解析器，正如在他们非常酷的论文中所解释的，通过一个干净的 API 减轻了这种复杂性，该 API 允许并实现完整的端到端布局检测、解析和理解，只需要几行代码(我的意思是非常少，比如 5 行)。他们有一堆可以直接开箱使用的型号。总之是一个超级酷的工具。
现在，除了预训练模型的功能之外，如何使用该工具来理解和处理定制布局？
作者图片
显而易见的想法是在您的定制布局上微调现有的布局模型。
你是对的，这是最好的办法，特别是考虑到我们并不是所有人都有从头开始训练这种模型所需的硬件火力。
虽然微调过程比仅仅使用预先训练的模型在技术上更复杂一些，但是由布局解析器的作者创建的一个方便的库，通过大量处理训练/微调活动中不合理的部分，有助于缓解这些问题。
Gareth Fowler 在 Tumblr上发布的 GIF
在接下来的章节中，我们将通过一个全面的教程来使用 这个库 来训练你自己的定制模型。
先决条件
图片由纳万舒·阿加瓦尔
- Python ≥ 3.6
- 探测器 2 从主分支分叉或克隆而来。*
- 最新版本的布局解析器及其依赖项。
- Pytorch (Linux: 1.6+或 Windows: 1.6)**
- CUDA 工具包:10+(与 Pytorch 兼容)***
- 数据集:以 COCO 格式标注。
警告
-
Detectron2 不容易安装在 Windows 系统上，请参考 ivanapp 的这篇精彩帖子以获得基于 Windows 的安装过程的指导。
-
*尽管官方文档中推荐使用 1.8，但 Windows 用户应该坚持使用 1.6。
***CUDA 不是强制性的，理论上也可以在 CPU 上训练。尽管如此，这样的训练尝试将会非常缓慢。
步骤 1:基本设置
步骤 2:拆分数据集(可选)
- 打包在布局-模型-训练 repo 中的是一个内置脚本(
utils\cocosplit.py)，用于将数据集分割成测试和训练子集。 - 该脚本确保在数据集中不存在标记区域的图像的情况下，训练和测试子集中标记图像与未标记图像的比率将是相等的。
- 使用以下命令分割数据集(假设工作目录与上一步中的指示一致)。
请注意，以上命令是在基于 Windows 10 的系统上执行的，请根据操作系统更改路径分隔符。
论据解释
- annotation_path :合并数据集所在的路径。
- 训练和测试:训练/测试数据集应该保存的路径。
- 分割比:分配给训练的合并数据集的分数。
步骤 3:下载预训练模型
- 从布局解析器的 模型动物园 下载一个预先训练好的模型及其相关配置文件。
- 下载包含两个文件:
- model_final.pth :这是预训练模型的权重。
- config.yaml :这是预训练模型的配置。有关配置文件的信息，请参考 检测器 2 文档 。
步骤 4:训练模型
既然数据集已被分割，预训练的模型权重也已下载，让我们进入有趣的部分: 模型训练 (或者更确切地说是微调)。
- 使用
tools\train_net.py处的训练脚本完成训练 - 使用下面的命令来训练模型。
请注意，以上命令是在基于 Windows 10 的系统上执行的，请根据操作系统更改路径分隔符。
论据解释
- dataset_name :自定义数据集的名称(可以随意命名)。
- json_annotation_train :训练标注的路径。
- json_annotation_val :测试注释的路径。
- 图像 _ 路径 _ 训练:训练图像的路径。
- image_path_val :测试图像的路径。
- config-file :步骤 3 下载的模型配置文件的路径。
注意，其余的参数-值对实际上是配置修改，并且特定于用例(有时)。为了清楚地了解如何使用和设置它们，请参考 检测器 2 文档 。
- 微调后的模型及其配置文件、训练指标和日志将保存在输出路径中，如上面命令中的
OUTPUT_DIR所示。
第五步:推理
有了 finetuned 模型，使用它来解析文档就成了一项简单的任务。
- 在布局解析器的演示中，用以下代码替换模型初始化。
请注意，以上路径基于基于 Windows 10 的系统，请根据操作系统更改路径分隔符。
custom_label_map是int_label -> text_label的映射。这种映射是根据训练数据的 COCO Json 中存在的'categories'字段以如下方式进行的:每个category对应{'id': 'name'}。例如:
custom_label_map = {0: "layout_class_1", 1: "layout_class_2"}
结论
总而言之，可以使用布局-模型-训练 repo 轻松训练任何数据集上的定制模型。这种模型可以用于解析和理解各种各样的文档，并且在训练后相对容易。
参考
[1] Y. Wu，a . a .，F. Massa，W. Y. Lo 和 R. Girshick， Detectron2 :提供最先进的检测和分割算法的人工智能研究的下一代库(2019)， GitHub Repo
[2]沈，张，戴尔，李，卡尔森和李，【LayoutParser:一个基于深度学习的文档图像分析的统一工具包】(T5)(2021)，arXiv 预印本 arXiv:2103.15348
[3] T. S. Lin，M. Maire，S. Belongie，L. Bourdev，R. Girshick，J. Hays，p .佩罗娜，D. Ramanan，C. L. Zitnick 和 P. Dollár，微软 COCO:上下文中的共同对象 (2015)，arXiv 预印本 arXiv:1405.0312v3
自动 Sklearn:sci kit-学习类固醇
自动化“无聊”的东西。加速您的模型开发生命周期。
亚历山大·雷德尔在 Unsplash 上拍摄的照片
动机
典型的机器学习工作流是数据处理、特征处理、模型训练和评估的迭代循环。想象一下，在我们获得令人满意的模型性能之前，必须试验数据处理方法、模型算法和超参数的不同组合。这项费力费时的任务通常在超参数优化过程中执行。
模型开发生命周期。图片作者。
超参数优化
超参数优化的目标是找到最佳模型管线组件及其相关的超参数。让我们假设一个简单的模型管道，它有两个模型管道组件:一个估算步骤，后面跟着一个随机森林分类器。
作者图片
插补步骤有一个名为“策略”的超参数，用于确定如何进行插补，例如使用均值、中值或众数。随机森林分类器有一个称为“深度”的超参数，它确定森林中单个决策树的最大深度。我们的目标是找到跨模型管道组件的超参数的哪个组合提供最佳结果。进行超参数调整的两种常见方法是使用网格搜索或随机搜索。
网格搜索
对于每个超参数，我们列出一个可能值的列表，并尝试所有可能的值组合。在我们的简单例子中，我们有 3 种估算策略和 3 种不同的随机森林分类器深度可以尝试，因此总共有 9 种不同的组合。
网格搜索。图片作者。
随机搜索
在随机搜索中，我们定义每个超参数的范围和选择，并且在这些边界内随机选择超参数集。在我们的简单示例中，深度的范围在 2 到 6 之间，估算策略的选择有均值、中值或众数。
随机搜索。图片作者。
请注意，网格和随机搜索中的超参数集是彼此独立选择的。这两种方法都不使用先前训练和评估试验的结果来改进下一次试验的结果。进行超参数优化的一个更有效的方法是利用先前试验的结果来改进下一次试验的超参数选择。这种方法被用于贝叶斯优化。
贝叶斯优化
贝叶斯优化存储先前搜索的超参数和预定义目标函数的结果(例如，二进制交叉熵损失)，并使用它来创建代理模型。代理模型的目的是在给定一组特定的候选超参数的情况下，快速估计实际模型的性能。这允许我们决定是否应该使用候选超参数集来训练实际模型。随着试验次数的增加，用附加试验结果更新的替代模型得到改进，并开始推荐更好的候选超参数。
贝叶斯优化存在冷启动问题，因为它需要试验数据来建立替代模型，然后才能为下一次试验推荐好的候选超参数。代理模型在开始时没有要学习的历史试验，因此候选超参数是随机选择的，这导致在寻找性能良好的超参数时启动缓慢。
为了克服冷启动问题，Auto-Sklearn，一个开源的 AutoML 库，通过一个称为元学习的过程，将热启动合并到贝叶斯优化中，以获得比随机更好的超参数的实例化。
自动 Sklearn
自动机器学习(AutoML)是机器学习管道中自动化任务的过程，例如数据预处理、特征预处理、超参数优化、模型选择和评估。Auto-Sklearn 使用流行的 Scikit-Learn 机器学习框架自动执行上述任务。下图简单展示了 Auto-Sklearn 的工作原理。
自动 Sklearn。图片来自[1]。
Auto-Sklearn 使用带有热启动(元学习)的贝叶斯优化来寻找最佳模型管道，并在最后从各个模型管道构建集成。让我们检查一下 Auto-Sklearn 框架中的不同组件。
元学习
元学习的目的是为贝叶斯优化找到好的超参数实例，以便它在开始时比随机的表现更好。元学习背后的直觉很简单:具有相似元特征的数据集在同一组超参数上表现相似。Auto-Sklearn 作者定义的元特征是*“可以有效计算的数据集特征，有助于确定对新数据集使用哪种算法”。*
在离线训练期间，对来自 OpenML 的 140 个参考数据集，共列出了 38 个元特征，如偏度、峰度、特征数、类别数等。使用贝叶斯优化过程训练每个参考数据集，并对结果进行评估。为每个参考数据集给出最佳结果的超参数被存储，并且这些超参数充当具有相似元特征的新数据集的贝叶斯优化器的实例。
在新数据集的模型训练期间，新数据集的元特征被制成表格，并且根据元特征空间中到新数据集的 L1 距离对参考数据集进行排序。来自前 25 个最接近的参考数据集的存储的超参数被用于实例化贝叶斯优化器。
作者在参考数据集上实验了 Auto-Sklearn 的不同变体，并使用不同训练持续时间的平均排名对它们进行了比较。等级越低表示性能越好。由于贝叶斯优化器的良好初始化，元学习的变体(蓝色和绿色)在开始时显示排名急剧下降。
图 1:不同 Auto-Sklearn 变体的比较。图片来自[1]。
数据预处理程序
Auto-Sklearn 按以下顺序预处理数据[2]。
- 分类特征的一种热编码
- 使用平均数、中位数或众数的插补
- 重新缩放要素
- 使用类权重平衡数据集
特色预处理器
在数据预处理之后，可以选择使用一个或多个以下类别的特征预处理程序对特征进行预处理[2]。
- 使用 PCA、截断 SCV、核 PCA 或 ICA 的矩阵分解
- 单变量特征选择
- 基于分类的特征选择
- 特征聚类
- 核近似
- 多项式特征扩展
- 特征嵌入
- 稀疏表示和变换
全体
在训练过程中，Auto-Sklearn 训练多个单独的模型，这些模型可用于构建集合模型。集成模型组合多个训练模型的加权输出，以提供最终预测。众所周知，它们不容易过度拟合，并且通常优于单个模型。
从图 1 中，作者显示了使用集成的变体比没有集成的变体性能更好(黑色对红色和绿色对蓝色)。具有元学习和集成的变体(绿色)表现最好。
密码
让我们来看看 Auto-Sklearn 的一些实际例子。
安装包
pip install auto-sklearn==0.13
进口包装
import pandas as pd
import sklearn.metrics
from sklearn.model_selection import train_test_split, StratifiedKFoldfrom autosklearn.classification import AutoSklearnClassifierfrom autosklearn.metrics import (accuracy,
f1,
roc_auc,
precision,
average_precision,
recall,
log_loss)
加载数据集
我们将使用来自 UCI 的数据集，该数据集描述了一家银行向客户提供定期存款的营销活动。如果客户同意，目标变量为是；如果客户决定不定期存款，目标变量为否。你可以在这里找到原始数据集。
我们将数据集作为熊猫数据帧来读取。
df = pd.read_csv('bank-additional-full.csv', sep = ';')
准备数据
Auto-Sklearn 要求我们在 pandas 数据帧中识别一个列是否是数字分类的，或者我们可以稍后在fit函数中完成。让我们现在转换它。
num_cols = ['ge', 'duration', 'campaign', 'pdays', 'previous', 'emp.var.rate', 'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed']
cat_cols = ['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'day_of_week', 'poutcome']df[num_cols] = df[num_cols].apply(pd.to_numeric)
df[cat_cols] = df[cat_cols].apply(pd.Categorical)y = df.pop('y')
X = df.copy()X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state=1, stratify=y)
实例化分类器
skf = StratifiedKFold(n_splits=5)
clf = AutoSklearnClassifier(time_left_for_this_task=600,
max_models_on_disc=5,
memory_limit = 10240,
resampling_strategy=skf,
ensemble_size = 3,
metric = average_precision,
scoring_functions=[roc_auc, average_precision, accuracy, f1, precision, recall, log_loss])
以下是AutoSklearnClassifier中使用的一些参数。
time_left_for_this_task:限制总训练时间(秒)
max_models_on_disc:限制保留的型号数量
memory_limit:我们想要使用的内存量(MB)
resampling_strategy:维持或不同种类的交叉验证。请参考本文档。
ensemble_size:服装系列中包含的模特数量。Auto-Sklearn 提供了一个选项，通过以加权方式取最大的ensemble_size个模型，在创建单个模型后创建集合。
metric:我们想要优化的指标
scoring_function:我们想要评估模型的一个或多个指标
安装分类器
clf.fit(X = X_train, y = y_train)
在引擎盖下，Auto-Sklearn 在每次试验期间都构建了一个 Scikit-Learn 管道。Scikit-Learn 管道用于组装一系列执行数据处理、特征处理和估计器(分类器或回归器)的步骤。fit函数触发整个 Auto-Sklearn 构建、拟合和评估多个 Scikit-Learn 流水线，直到满足停止标准time_left_for_this_task。
结果
我们可以查看结果和选择的超参数。
df_cv_results = pd.DataFrame(clf.cv_results_).sort_values(by = 'mean_test_score', ascending = False)
df_cv_results
交叉验证结果和参数。图片作者。
我们还可以在排行榜上查看所有试验之间的比较
clf.leaderboard(detailed = True, ensemble_only=False)
排行榜。图片作者。
我们可以使用以下命令查看哪些管道被选择用于集合
clf.get_models_with_weights()
该方法返回元组列表[(weight_1, model_1), …, (weight_n, model_n)]。weight表示它给每个模型的输出多少权重。所有weight值的总和将为 1。
我们还可以查看其他培训统计数据。
clf.sprint_statistics()
用所有训练数据改装
在 k-fold 交叉验证期间，Auto-Sklearn 在数据集上拟合每个模型管道 k 次，仅用于评估，它不保留任何已训练的模型。因此，我们需要调用refit方法，用所有的训练数据来拟合交叉验证期间找到的模型管道。
clf.refit(X = X_train, y = y_train)
保存模型
dump(clf, 'model.joblib')
负荷模型和预测
让我们加载保存的模型管道进行推理。
clf = load('model.joblib')
y_probas = clf.predict_proba(X_test)
pos_label = 'yes'
y_proba = y_probas[:, clf.classes_.tolist().index(pos_label)]
结论
搜索最佳模型管线组件和超参数是一项重要的任务。幸运的是，有 AutoML 解决方案，如 Auto-Sklearn，可以帮助自动化这个过程。在本文中，我们研究了 Auto-Sklearn 如何使用元学习和贝叶斯优化来找到最佳模型管道并构建模型集成。Auto-Sklearn 是众多 AutoML 软件包中的一个。查看其他备选方案，如 H2O 汽车。
你可以在这里找到本文中使用的演示代码。
参考
[1] 高效而健壮的自动化机器学习
[2] 高效稳健的自动化机器学习补充材料
汽车 911:让我们用人工智能自动化 2.4 亿次 911 查询
革新传统 911 紧急响应的一步
平均每年，仅在美国就有大约 2.4 亿个 911 呼叫，全国平均每天超过 60 万个呼叫；由于新冠肺炎，911 紧急响应呼叫中心人手不足，导致紧急情况下等待时间更长。【1】现在，想象一下，如果我们利用人工智能的力量自动化呼叫响应，并允许人们对他们的问题做出自由、直接和即时的响应，会怎么样？
这就是 Auto911 闪耀的地方🌟
📑目录
1\. [🚑 What is Auto911?](#c3ae)2\. [😍 How does it look?](#cf5e)3\. [❓ How does it Work?](#43ca) 3.1 [🎰 Exploring GPT-J API](#92fb) 3.2 [📃 Making requirements.txt](#65d7) 3.3 [🐍 Creating streamlit_app.py](#aed4) 3.4 [🍎 Check the output!](#e3d5)4\. [💡 Other Use Cases](#d0df)5\. [👊 Limitations and Considerations](#5328)6\. [🎆 Conclusion](#1a88)7\. [✏️ About Author](#be77)8\. [✅ References](#826f)
现在，在投入工作之前，我们先简单了解一下这个项目和这个 app 的用途。
🚑什么是 Auto911？
Auto911 是一个 AI for Good solution，旨在通过使用尖端开源 GPT-J 这一 60 亿参数的人工智能模型和 Streamlit Sharing 这一部署、管理和共享应用程序的平台来自动化 911 紧急响应，从而通过提供直接、免费和即时的支持来帮助处于紧急情况下的人们。
😍看起来怎么样？
厉害！既然现在您已经熟悉了什么是 Auto911 及其目标，我相信这也是一个了解应用程序的好时机。这是应用程序的链接:
作者截图
❓:它是如何工作的？
🎰探索 GPT-J API
如上所述，它使用了两个东西:1.GPT J 模型和 2。简化共享。所以让我们从 GPT-J 模型开始。承蒙维克多·加莱戈的好意，我使用了 GPT J 的免费公共 API。现在，如果您想自己探索这个 API，请随意访问GPT-j-APIGithub repository【2】或者如果您喜欢简单的方法，下面是在您自己的项目中使用它的 Pythonic 方法:
作者代码示例
让我们一个变量一个变量地分解它😅
- 上下文:描述对话的字符串
- payload :以模型参数为关键字，自变量为值的字典
+ context : Context 变量将作为值
+ token_max_length :输出响应的最大长度
+Temperature:Temperature 控制模型的随机性
+Top _ p:Top probability 是控制模型随机性的另一种方法 - 响应:模型生成输出文本
有关每个参数的更多信息，请查看 GPT-J API 文档【3】。
📃制作要求. txt
从上面这段代码中，你可以看到该应用程序需要请求 python 包，因为我们即将在 Streamlit 上部署该应用程序，我们也将需要它。
在云实例上运行我们的应用程序之前，让 Streamlit Sharing 知道我们想要安装哪些库的一个简单方法是创建一个 requirements.txt 文件。所以，下面是如何做到这一点:
- 创建一个简单的文本文件，并将其命名为 requirements.txt
- 将下面提到的两个库名复制并粘贴到 requirements.txt 文件中
作者代码示例
现在就到此为止，让我们进入下一个任务！
🐍正在创建 streamlit_app.py
现在这是你的应用程序布局和逻辑将驻留在。Streamlit Sharing 将使用这个 python 脚本来创建您在上面看到的漂亮的应用程序布局。好的，所以我当然不想让你因为阅读这篇文章而感到遗憾，所以让我们避免像如何放置按钮或制作标题这样的微小的前端细节😅为此，您可以阅读我的 streamlit101 文章
https://medium.com/omdena/streamlit101-deploying-an-automl-model-using-streamlit-e86c6508b5c2
好了，开始说主要的吧！
下面是我创建 streamlit_app.py 文件的步骤:
- 创建一个名为 streamlit_app having 的文件。py 扩展。
- 像这样在文件中导入 streamlit 库:
作者代码示例
3.在文件中定义一些上下文、有效负载和响应请求，如下所示:
由 Víctor Gallego 编写的代码示例
5.使用以下内容打印出上述回复:
作者代码示例
🍎检查输出！
太棒了！现在，让我们自己尝试一下这个应用程序，看看输出结果。所以，我在输入提示中输入了一条随机的 911 紧急短信，然后按下*帮助！*按钮。以下是输出结果:
作者截图
可以说，结果对我来说非常直观！😎
💡其他使用案例
由于 GPT-J 是一种语言模型，它的应用仅限于我们的想象。它可以用于从给定的要点生成文本，如电子邮件，或从一些角色对话中生成电影脚本，或根据一些标签对情感进行分类，等等。我个人对使用 GPT-J 感兴趣的是创建一个基于开源人工智能的代码完成引擎，就像 Github 的 Copilot 或 OpenAI 的 Codex 的替代品一样。就像我说的，唯一的限制是你的想象力，尽情发挥吧！
但是就像人类和所有与他们相关的事物一样，它也有自己的局限性，所以为什么不在下一个标题中讨论它们呢😅
👊限制和注意事项
GPT J 的第一个问题是，除了 Eleuther 之外，它没有其他组织的支持，这在资源方面特别是计算、数据和专业人力资源方面严重限制了它。由于没有重要的财政支持，它在 60 亿个参数上进行训练，比 GPT-3 少得多，但看看其他可用的选项。
公开可用的 GPT-2 在 15 亿个参数上进行训练，这大大少于 GPT-J 的 60 亿个参数。此外，拥有 60 亿个参数有助于它的性能与 GPT-3 相当，后者是在 67 亿个参数上训练的。因此，由于这些因素，它可以被认为是迄今为止最准确的公开可用模型。
GPT J 也是像 GPT 3 一样基于大型变压器的模型，这就是为什么它没有长期记忆。因此，它不像人那样从长期的互动中学习。
GPT J 也不例外，所有的模型都是由用来训练它们的数据决定的。本文举例说明，反穆斯林偏见存在于 GPT-3 和其他大的语言模型中。[ 4
在这方面，伊柳瑟在 GPT J 号中做得很好，试图消除 GPT 3 号中存在的偏见。Eleuther 的数据集比 GPT-3 更加多样化，它避免了一些像 Reddit 这样的网站，这些网站更有可能包含有问题的内容。[ 5
最后，关于我们是否应该或可以依靠让人工智能完全处理紧急反应是一个进一步研究和广泛测试的问题。但就目前而言，我可以说，人工智能像其他任何工具一样，可以帮助人类处理紧急响应等情况，提供应该做什么的即时指导，但同样，这是基于人类的判断力，以验证和确认响应对他们来说是否足够，或者他们应该进一步寻求人类的支持。汽车 911 是漫长旅程的第一步，但我希望最终结果会值得努力😇
🎆结论
恭喜你！您刚刚不仅了解了 Auto911，还了解了 GPT-J 和 Streamlit 共享，以及如何使用它们来创建和部署一个使用最复杂和公开可用的 transformer 模型之一的全功能 AI 应用程序。我希望这篇文章能给你必要的知识来理解、创建和部署你自己的基于 GPT-J 模型的应用程序。
如果你想更多地了解 911，这里有一个很好的简短总结。
我还建议查看 GPT-J 的文档，以了解更多关于 GPT-J 的其他应用
您可以在 Victor 的官方 GPT-J-API github 存储库中随意查看样本 streamlit_app 示例
✏️关于作者
穆罕默德·阿里是欧洲最大的创业中心数字产品学校的人工智能工程师。他喜欢学习、教授和撰写关于数据科学和机器学习现实世界的应用和项目。他的主要爱好是玩很酷的开源工具，并用它们来解决现实世界的问题。也可以在 LinkedIn 上和他联系。
通过 Medium 关注他，了解他最新的最先进和最前沿的技术文章，就像你上面读到的那篇。
✅参考
[1]Jiovanni lie ggi911 呼叫中心人手不足导致紧急情况下等待时间延长 (2021)，福克斯新闻频道警察和执法科
[2]维克多·加莱戈 gpt-j-api (2021)，Github
[3]维克多·加莱戈 gpt-j-api 文件 (2021)，Github
[4] Abubakar Abid，Maheen Farooqi，James Zou 大型语言模型中持续的反穆斯林偏见 (2021)，Arxiv
[5]赫里蒂克·罗伊 GPT-J: GPT-3 民主化 (2021)，P3r
[6] Elana Pearl Ben-Joseph 如何使用 911 (2018)，KidsHealth，Nemours 基金会
用于图像去噪的自动编码器
包含动手 Python 代码的实施指南
图片由 Cara Shelton 在 Unsplash 上拍摄
在这篇文章中，你将了解到自动编码器是如何工作的，以及为什么它们被用于医学图像去噪。
正确理解图像信息在医学等领域至关重要。去噪可以专注于清理旧的扫描图像，或者有助于癌症生物学中的特征选择工作。噪音的存在可能会干扰疾病的识别和分析，从而导致不必要的死亡。因此，医学图像去噪是一项必不可少的预处理技术。
所谓的自动编码器技术已经被证明对图像去噪非常有用。
自动编码器由一对两个相连的人工神经网络组成:一个编码器模型和一个解码器模型。自动编码器的目标是找到一种将输入图像编码成压缩形式(也称为潜在空间)的方法，使得解码图像版本尽可能接近输入图像。
自动编码器如何工作
网络提供原始图像 x ，以及它们的嘈杂版本 x~ 。网络试图重建其输出*x’*以尽可能接近原始图像 x 。通过这样做，它学会了如何去噪图像。
如图所示，编码器模型将输入转换为小型密集表示。解码器模型可以被视为能够生成特定特征的生成模型。
编码器和解码器网络通常作为一个整体来训练。损失函数惩罚网络产生不同于原始输入 x 的输出x’。
通过这样做，编码器学会在潜在空间的限制中保留尽可能多的相关信息，并巧妙地丢弃不相关的部分，例如噪声。解码器学习获取压缩的潜在信息，并将其重构为完全无错误的输入。
如何实现自动编码器
让我们实现一个自动编码器来消除手写数字的噪声。输入是 28x28 灰度图像，构建 784 元素向量。
编码器网络是具有 64 个神经元的单一密集层。因此，潜在空间将具有尺寸 64。整流单元(ReLu)激活函数被附加到该层中的每个神经元，并且基于每个神经元的输入是否与自动编码器的预测相关来确定它是否应该被激活(“激发”)。激活函数还有助于将每个神经元的输出标准化到 1 到 0 之间的范围。
解码器网络是具有 784 个神经元的单个密集层，对应于 28×28 灰度输出图像。sigmoid 激活函数用于比较编码器输入和解码器输出。
二进制交叉熵用作损失函数，Adadelta 用作最小化损失函数的优化器。
MNIST 数据集是一个著名的手写数字数据库，广泛用于机器学习领域的训练和测试。我们在这里使用它，通过应用高斯噪声矩阵并在 0 和 1 之间裁剪图像来生成合成噪声数字。
你仍然可以识别数字，但是很难。因此，我们想使用我们的自动编码器来学习恢复原始数字。我们通过在 100 个时期内拟合自动编码器来实现这一点，同时使用有噪声的数字作为输入，并将原始去噪的数字作为目标。
因此，自动编码器将最小化噪声图像和干净图像之间的差异。通过这样做，它将学习如何从任何看不见的手写数字中去除噪声，这些数字是由类似的噪声产生的。
如何用自动编码器去噪
现在，我们可以使用经过训练的 autoencoder 来清理看不见的噪声输入图像，并根据清理后的图像绘制它们。
- 总的来说，噪音消除得非常好。在输入图像上人为引入的白点已经从清洗后的图像中消失。数字可以被视觉识别。例如，有噪声的数字“4”根本不可读，现在，我们可以读取它的干净版本。
- 去噪对信息质量有负面影响。重建的数字有些模糊。解码器添加了一些原始图像中不存在的特征，例如，下面的第 8 位和第 9 位数字几乎无法识别。
图片由印第安纳大学(开放访问)
在本文中，我描述了一种图像去噪技术，并提供了如何用 Python 构建自动编码器的实用指南。放射科医生通常使用自动编码器对 MRI、US、X 射线或皮肤病变图像进行去噪。这些自动编码器在大型数据集上接受训练，例如由 7470 张胸部 x 光图像组成的印第安纳大学的胸部 x 光数据库。降噪自动编码器可以用卷积层来增强，以产生更有效的结果。
感谢阅读。
用于降维的自动编码器网络优化
如何优化隐藏层数和大小？
在之前的文章中，我们看到了如何通过使用线性激活函数和“mse”作为损失度量，利用自动编码器网络(AE)模拟 PCA 降维。
在一个合成数据集上，我们比较了基于分类分数和潜在变量的降维性能。我们看到了如何通过修改网络(添加更多层，堆叠自动编码器)或最终允许激活函数为非线性来改善结果。然而，这些变化是任意的。在这篇文章中，我想进行同样的基本分析，但这一次使用一种随机搜索的方法来寻找最佳的网络结构。我们将通过使用方便的 KerasRegressor 包装器来实现这一点
from tensorflow.keras.wrappers.scikit_learn import KerasRegressor
与前一篇文章不同的是，我们将从一个新的数据集开始:我们将使用一个严格非线性的数据集，它由来自 sk learn . datasets:make _ friendman 2 的 4 个变量组成。为了增加维度，我们也将使用 sklearn 的多项式特征(order=2，interactions_only=True)。这可能会稍微减轻主成分分析的工作，但我们会将 11 个变量的系统减少到 3 个。
在第一部分中，我们将使用浅网络的性能作为起点，就像我们在上一篇文章中所做的那样。在第二部分，我们将优化参数。第一个尝试是优化隐藏层的数量和形状(最多 4 层)。
自动编码器网络结构。图片作者。
基线性能
为了理解优化效果如何，我们将比较自动编码器和 PCA(主成分分析)的维数减少。
我们建立了包含 4 个特征的数据集。我们引入了多项式特征来增加维数，然后我们对所有这些特征应用标准缩放。最后，我们将把数据集的维数减少到 3。
主成分分析解释了该数据集约 77%的方差。
PCA 和编码器前 3 个组件。颜色显示要预测的值。
使用具有最大深度 3 的 RandomForestRegressor ，我们在具有原始 4 个特征的数据集上获得了 0.92 的回归分数。在具有多项式和缩放要素的数据集上为 0.98。
使用具有 3 个成分的 PCA，我们得到 0.67 的回归分数。使用简单的线性自动编码器，1 级 a 分数约为 0.7。使用简单的堆叠 AE:10–10–3，我们可以达到 0.77。
从这些数据中我们已经了解到，构成结果 y 的非线性特征强烈地影响着潜在变量的预测能力。自动编码器已经比 PCA 执行得更好，我们仍然使用线性激活函数。
对不同结构的回归结果进行评分。
优化层数
我们现在要优化堆栈编码器。我们通过导入一个新的库来实现:KerasRegressor。它将允许我们使用 scikit-learn 中的 RandomizedSearchCV。
from tensorflow.keras.wrappers.scikit_learn import KerasRegressor
要生成层的组合，有几种方法。直截了当的方法是用简单的列表理解一些条件句。最终我们可以决定定义一个函数，它的形状与我们数据的输入形状相关联。
output_dim = 3
sizes = [10,10,5,5,0]
shapes = [(i,j,k,q,output_dim) for i in sizes for j in sizes for k in sizes for q in sizes if (i>=j>=2*k>=output_dim)]
以下是从前面的列表理解中输出的一些形状:正如你在代码中注意到的，我们确保最终的维度总是我们的潜在空间维度。
(10, 10, 5, 10, 3),
(10, 10, 5, 10, 3),
(10, 10, 5, 5, 3),
(10, 10, 5, 5, 3),
(10, 10, 5, 0, 3),
(10, 10, 5, 10, 3),
(10, 10, 5, 10, 3),
(10, 10, 5, 5, 3),
(10, 10, 5, 5, 3),
(10, 10, 5, 0, 3),
(10, 10, 5, 10, 3),
(10, 10, 5, 10, 3), ... ]
层结构现在变成如下图所示:
将被优化的堆叠编码器结构。图片作者。
我们定义一个函数，它将使用我们刚刚定义的图层大小作为参数。我们将像上一篇文章一样构建编码器，但这次我们也将解码器的重量与编码器的重量联系起来。这样，我们将减少可训练参数，搜索将会更快。最后，它将连接两个模型，就像我们之前在堆栈自动编码器中所做的那样。
既然我们已经定义了构建自动编码器的函数，我们就定义了参数搜索网格，并利用 RandomizedSearchCV 功能来执行搜索。
请注意，我们正在寻找最能减少重建损失的网络结构。我们不是在寻找最佳的网络参数来改善我们的回归得分问题！
经过一番搜索，最佳结果似乎是(8，8，5，3)层网络。尽管如此，分数都是可比的。看起来至少有一些额外的层会有所帮助，但不会太复杂。
不同网络的平均测试分数。
结果报告如下。左边是到目前为止我们考虑的所有结果。右边是从 0.6 开始的(奇怪的)柱状图。即使在这种规模下，搜索的好处也不明显。
结论
在这篇短文中，我们看到了如何构建一个用于降维的自动编码器，并将其与上一篇文章中的 PCA 等标准算法进行比较，但使用的是强非线性数据集。在这种情况下，我们做了一个回归问题。
我们试图通过使用多项式特征来帮助 PCA 更好地执行，但是与原始数据集结果相比，信息损失仍然很大。一个简单的欠完整自动编码器已经开始比 PCA 表现得更好，增加层数和将解码器的权重与编码器的权重联系起来会使它甚至更好。
我们在 scikit-learn RandomizedSearchCV 和 GridSearchCV 中使用了 Keras 序列模型的包装器。在这个数据集上没有观察到更大的改进。很可能，由于原始维度只有 11，搜索效率并不高。
文献学
[1] A. Géron，用 Scikit-Learn 进行机器学习的实践，Keras & TensorFlow(第二版)。真的吗？
[2] A. Gulli，A. Kapoor，S. Pal，深度学习用 TensorFlow 2 和 Keras。(第二版)。打包。
【3】sk learn . datasets . make _ Friedman 1—scikit-learn 0 . 24 . 1 文档(scikit-learn.org)
【4】用自动编码器降维
使用 JavaScript 自动化和增强 Google Colab
在 Colab 上运行预先安排的 Python 脚本，并在您自己的驱动器上访问结果
Jean-Philippe Delberghe 在 Unsplash 上拍摄的照片
介绍
云计算正迅速成为数据科学家和公司的首选武器，这也是有充分理由的。有了提供给你的资源和与之相关的极小的费用，辨别云和本地计算实际上只是一个基本的算术问题。多年来，像亚马逊网络服务、微软 Azure、谷歌云平台和其他平台都竞相向客户提供最复杂、最先进、但最实惠的服务。具有讽刺意味的是，谷歌作为科技行业的先驱之一，在这场游戏中姗姗来迟，他们仍在弥补失去的时间。但是随着几年前 Google Colab 的推出，他们已经向全世界提供了一种服务，这种服务是无与伦比的，因为你没有为它付费。
可比虚拟机—每小时定价。图片作者。
从资源分配的角度快速查看一下最近的产品，就会发现使用 Colab 每一小时平均可以节省 16.3 美分。事实上，如果您自己进行调配，为每个 Colab 会话调配的实际虚拟机本身每小时会花费您 0.16 美元。下表显示了 Amazon Web Services、Microsoft Azure 和 Google Cloud Platform 提供的与 Colab 最具可比性的虚拟机及其各自的规格和价格。
换句话说，Colab 是一个不花钱的好东西。更不用说 Colab 还为您提供了对 GPU 和 TPU 的访问，这意味着您实际上每小时节省了 16 美分以上。最棒的是，实际上，世界上任何地方的任何人都可以按需访问它。请注意，这种善良也有局限性。您最多可以运行 12 个小时的会话，空闲超时大约为半小时。此外，如果您被发现过度使用 Colab 的一些资源，如 GPU 和 TPU，您可能会面临编程瓶颈。尽管如此，这样的限制还是过于宽松了。然而，为了更好地衡量，我们鼓励您有效地使用资源，不要过度使用，以避免任何服务中断。
Colab 自动化
人们想要自动化 Colab 的原因有很多:
- 运行 Python 脚本时要留出时间间隔，以避免过度利用可用资源。
- 您的脚本是一个时间关键的程序，需要在预先安排的时间运行。
- 确保您的程序在完成时或系统超时/关闭前关闭。
不管有什么原因，您确实可以通过编写 JavaScript 的小片段来自动化 Colab，这些小片段将在您的浏览器控制台上运行，以在 Colab 界面上交互和模拟按钮按压，从而在特定时间或通过特定触发来启动和/或停止您的会话。
要插入并运行 JavaScript 代码片段，请在您选择的浏览器上按 F12 打开控制台。然后将 JavaScript 片段粘贴到命令窗口中，并按 enter 键。随后，浏览器将运行代码，通过模拟按钮点击来自动化 Google Colab。要查找需要点击的按钮的 JavaScript 路径，请右键单击按钮并选择“检查”,或者使用浏览器控制台中的“选择一个元素”光标查找相关路径，如下所示。请注意，Google 可能会动态更改这些路径。
使用“选择一个元素”光标定位按钮元素。图片作者。
右键单击按钮元素复制 JavaScript 路径。图片作者。
场景 1: 在预先安排的时间运行/终止会话
对于我们的第一个场景，我们将立即运行我们的 Python 脚本(或者如果需要，在一定的秒数之后)，然后我们将在指定的秒数之后终止会话。为此，我们将实施以下步骤:
- 激活 Colab 会话
- 运行脚本(在预先安排的时间)
- 终止会话(在预先安排的时间)
下面的视频展示了自动化 Google Colab 的 JavaScript 代码。
作者视频。
请在下面找到该场景的 JavaScript 代码:
场景 2: 迭代地运行/终止会话
对于我们的第二个场景，我们将使用以下步骤根据需要多次迭代运行 Python 脚本:
- 激活 Colab 会话
- 如果迭代次数小于指定次数，则运行脚本
- 终止会话
请在下面找到该场景的 JavaScript 代码:
场景 3: 动态运行/终止会话
对于最后一个场景，我们将动态运行 Python 脚本，直到它提示我们终止它。这对于具有动态或未知运行时的脚本很有用。将为此用例实施以下步骤:
- 激活 Colab 会话
- 运行脚本，直到执行完成
- 向控制台日志发送消息以触发终止
- 终止会话
为了提示我们的 JavaScript 程序终止会话，我们将在 Python 脚本的末尾添加一行，这将产生一个错误。例如，我们可以尝试除以 0，这将提示 Colab 显示一条错误消息，该消息也将记录在浏览器的控制台中。然后，我们可以使用相同的 JavaScript 程序不断检查日志的长度是否超过 0，一旦超过，就会终止会话。
空日志允许程序无限期运行。图片作者。
完整日志将触发 JavaScript 终止会话。图片作者。
请在下面找到该场景的 JavaScript 代码:
持久保存结果
Google Colab 无缝连接到 Google Drive，这使我们能够将执行结果持久保存到我们自己的驱动器中。此外，您可以通过从 Google Drive 中的 csv 文件读取 Python 脚本来进一步自动化您的程序，该文件可以指导您的程序执行某些操作。例如，每次运行脚本时，它将首先检查 Google Drive 电子表格中的第一行，告诉它要操作数据帧中的哪一列，一旦执行完成，Python 脚本将删除第一行并重新保存电子表格，以便下次运行时将移动到数据帧中的下一列。
将 Google Drive 连接到 Colab。图片作者。
使用以下代码从您的 Google Drive 访问“指南”文件。
guide = pd.read_csv('drive/MyDrive/ColabNotebooks/guide.csv')
column_to_manipulate = guide.iloc[0][0]
执行完成后，只需忽略第一行，将文件重新保存到 Google Drive:
guide = guide.iloc[1:]
guide.to_csv('drive/MyDrive/ColabNotebooks/guide.csv',index=False)
结论
Google Colab 和云计算总体上提供了对大量计算资源的无与伦比的访问，直到最近许多人还无法访问这些资源。这样的功能加上一些使用 JavaScript 的自动化可以创造无限的机会，同时以更有效的方式利用资源。具体来说，在 Colab 的情况下，这样一种优秀的产品最好不要过量使用，以使社区中的每个人都能平等地受益于这样一包好东西。
https://github.com/mkhorasani/colab_automation
新到中？您可以在此订阅和解锁无限文章。
使用 Apache Spark 实现阿拉伯语自然语言处理自动化
带代码的教程，使用 Apache Spark 和 Spark NLP 将大数据与阿拉伯语自然语言处理结合起来进行分布式计算
很难概念化“大数据”实际上有多大，以及它对试图利用大数定律进行社会研究的数据科学家来说意味着什么。在《反乌托邦 2020》开始的时候，世界经济论坛估计全世界的数据量是 44 zettabytes(一个 zettabyte 有 21 个零)；这个数字大约是可观测宇宙中恒星数量的 40 倍。在全球范围内，到 2025 年，估计每天将产生 463 艾字节(一个艾字节有 18 个零)。对社会研究感兴趣的数据科学家应该为这一现实做好计划；目前专注于使用大数据工具应对未来是一个务实的决定。
在这个关于阿拉伯语 NLP 的三部分系列的第一篇文章中，我提到了对阿拉伯语特定语言资源日益增长的需求，并介绍了一些可用的前沿工具。这第二部分重点关注在使用像阿拉伯语这样的低资源语言时所必需的创造性，特别是因为最有前途的大数据工具都是为英语构建的。目前， Apache Spark 显然是大数据领域的领跑者，John Snow Labs 的流行开源项目 Spark NLP 提供了构建自动化大数据管道所需的免费 NLP 工具。此外， Apache Spark MLib 提供了可扩展的机器学习算法，可以无缝融入 Spark 的 API，为 Spark NLP 提供了必要的扩展。
在本文中，我将探讨如何使用这些大数据工具来创建 NLP 管道，以实现阿拉伯语 NLP 的自动化。具体来说，我比较了来自 Spark NLP 的三个预训练嵌入，它们与深度学习文本分类器结合使用，创建了一个阿拉伯语情感分析管道，可以在 Spark 集群中运行，用于分布式计算。
面向大数据的 Apache Spark】
Spark 将自己定位为“大规模数据处理的统一分析引擎”。关键卖点是速度(内存比 Apache Hadoop 快 100 倍)以及与其他数据需求的广泛集成，如 SQL、流、机器学习和图形。实际上，Spark 作为数据处理框架的强大之处在于可伸缩性和并行性。Spark 可以在大数据集上快速执行处理任务，重要的是将这些数据处理任务分布在多台计算机上。这种批处理并行化可以通过 Spark 单独完成，也可以与其他分布式计算工具协同完成。例如，它可以与谷歌开发的 kubernetes 和其他 Apache 产品集成，如 Hadoop 、 Cassandra 、 Mesos 和 HBase 。
Medium 上有几个有用的快速入门指南，用于设置 Spark 集群:与 Kubernetes 一起使用，与 Databricks 一起使用，与 Hadoop 一起使用，与 PySpark 和 Spark-submit 一起使用。Spark 框架的核心构建块是弹性分布式数据集 (RDD)，本质上是一个可以并行操作的数据集。Spark 在 RDD 编程指南中提供了大量利用 RDD 的文档。当使用 Python 时，我使用 PySpark，这本全面的指南对于 PySpark 和 RDD 初学者来说是一个很好的起点。对于一个更短的、专注于代码的教程，我建议在 Neptune.ai 博客上发布这个可访问的帖子。
Spark 是用 Scala 编写的，它有一个 Java 虚拟机(JVM)运行时，运行速度比 Python 快 10 倍。此外，Scala 作为静态类型语言还有额外的运行时优势，这意味着代码是在运行时之前编译的，而 Python 是动态类型语言，因此速度较慢，因为代码必须在运行时进行解释。由于速度的原因，Spark 最好与 Scala 一起使用，但是我建议在选择一种语言之前，先阅读这篇比较 Scala 和 Python for Spark 的文章。出于本教程的目的，我将利用 Python 例子来提高可访问性，但是我建议在为生产编写管道时使用 Scala。
Spark NLP for Arabic NLP
Spark NLP 是 John Snow Labs 的一个开源项目，作为第三方产品，成功地将 NLP 集成到 Spark 生态系统中。这是一个很好的做法，以简化效率和质量保证的共同进程，和火花 NLP 的管道，使这成为可能，为经常性的 NLP 任务。Spark NLP 有许多预训练的管道、模型和嵌入，可用于几种不同的语言，用于命名实体识别、依存解析和情感分类等任务。
特别是对于阿拉伯语，Spark NLP 提供了一个阿拉伯语分类器，一个停用字词清洁器和字词嵌入。不幸的是，在撰写本文时(2021 年 1 月), lemmatizer 和单词嵌入是错误的和不可靠的。就个人而言，我发现在使用阿拉伯语时，最有用的 Spark NLP 工具是多语言工具。对于本文，我构建了几个深度学习阿拉伯情感分类器，测试了两种类型的多语言句子嵌入和一种多语言单词嵌入。
阿拉伯情感分类
为了判断前述多语言嵌入的质量，我使用阿拉伯语约旦语通用推文(AJGT)语料库进行二元情感分类。这允许与 AraBERT 情感分类器的结果进行直接比较，我在我的上一篇阿拉伯语 NLP 文章中介绍了该分类器。提醒一下，AJGT 数据集由 1800 条现代标准阿拉伯语或约旦方言的推文组成，标注为正面或负面。当用于训练 AraBERT 模型时，该数据集产生 93.8%的准确率。我测试的三个嵌入包括如下:通用句子编码器句子嵌入(USE) ，语言不可知的 BERT 句子嵌入(LaBSE) 和多语言 BERT 单词嵌入(M-BERT) 。
句子嵌入
句子嵌入是一种将句子映射到向量的文本处理方法，作为一种用适合机器学习的实数表示文本的方法。关于如何训练和部署基于 Transformer 的句子嵌入(如 LaBSE)的更多细节，我建议阅读我关于基于 Transformer 的句子嵌入的文章。
https://medium.com/swlh/transformer-based-sentence-embeddings-cd0935b3b1e0
Spark NLP 提供了两个 Tensorflow Hub 的通用句子编码器模型，默认选项是用深度平均网络(DAN)编码器训练的模型，这是最初使用论文的研究人员提供的两个选项中最受欢迎的一个。关于如何实现 USE 语句嵌入的更多细节，我推荐这篇讨论生产选项的中型文章。
多语言 BERT 单词嵌入
根据我的经验，句子嵌入的主要优势是速度和适合语义文本相似性任务。然而，对于文本分类任务，例如情感分析，BERT 型单词嵌入通常产生更好的结果。Spark NLP 没有用于多语言或阿拉伯语情感分析的预训练管道，用于文本分类的管道组件需要句子嵌入。因此，为了比较 M-BERT 嵌入，我决定修改单词 embedding，以便它们可以以类似于多语言句子嵌入的方式使用。明确地说，我怀疑这种非常规的方法不如预先训练的句子嵌入，因为研究表明这对于语义相似性任务来说是正确的。然而，据我所知，这种比较还没有用于文本分类任务，因此我很好奇。
【Spark NLP 入门
首先，要使用 Spark NLP for Python，需要安装 Spark NLP 和 PySpark。这是通过以下代码行完成的:
pip install spark-nlp==2.6.5 pyspark==2.4.4
下一个需求是为 Spark NLP 安装正确的 Java 环境。这一步可能比较棘手，所以如果在设置 Java 8 运行时环境时遇到困难，我建议使用 Google Colab 而不是本地 IDE。
成功安装后，输出应为:
最后，必须初始化一个 Spark NLP 会话，只需使用下面的代码片段即可完成。
import sparknlpspark = sparknlp.start()
检查是否使用了正确版本的 Spark 和 Spark NLP 是可行的，因此我建议运行以下两个命令作为健全性检查。
Spark.versionsparknlp.version()
最后一步，从 Spark NLP 和 Spark MLib 导入必要的模块。
from pyspark.ml import Pipeline
from sparknlp.annotator import *
from sparknlp.common import *
from sparknlp.base import *
from sparknlp.embeddings import *
from pyspark.sql.functions import *
在 Spark NLP 中使用 rdd
Spark NLP 会话运行后，可以将不同类型的数据加载到 Spark 数据帧(RDD)中。以下命令用于将 json 读入 PySpark RDD:
df_spark = spark.read.option("header",True).json("AJGT_labels.json")
AJGT 数据集中的前五个条目读作 RDD。图片作者。
快速分组命令显示二进制标签的分布。
df_spark.groupBy("label").count().show()
来自 AJGT 数据集的标签计数显示了平衡分布。图片作者。
在准备训练时，有必要分割数据集，对于 RDDs，可以使用以下命令:
df_train, df_test = df_spark.randomSplit([0.8, 0.2], seed=42)
构建 Spark NLP 管道
如前所述，Spark NLP 提供了一个深度学习文本分类器，需要句子嵌入作为输入。对于两个多语言句子嵌入，通过简单地切换出嵌入，可以使用相同的 NLP 管道。我为 M-BERT 单词嵌入构建了一个单独的 NLP 管道，它基于平均池策略产生句子嵌入。管道构建组件包括转换器(不要与转换器架构混淆)和注释器，其细节在 Spark NLP 文档和这篇文章的第三部分中讨论。
如下面的代码片段所示，要构建一个阿拉伯情感分类器，第一步是使用一个名为 DocumentAssembler()的转换器。接下来，标记化和清理(删除停用词)的基本预处理步骤由标记化器()和停用词清理器()注释器处理。请注意，清洁工使用了阿拉伯停用词。
对于 LaBSE 句子嵌入，使用 BERTSentenceEmbeddings()注释器，而一个单独的注释器 UniversalSentenceEncoder()用于使用嵌入。两种嵌入都显示在下面的代码片段中，只需根据所需的管道注释掉不需要的代码块。
对于 M-BERT 单词嵌入，BERTEmbeddings()注释器用于创建单词嵌入，然后用 sentence embeddings()注释器将单词嵌入转换成句子嵌入。
当使用 ClassiferDLApproach()设置文本分类深度学习方法时，可以为深度神经网络的训练分配参数。在下面的代码片段中，我将最大历元数设置为 6，验证拆分为 50%，丢弃为 20%，学习率设置为 5^-4.我选择这些参数是为了避免由于小数据集而导致的过度拟合，并希望提高泛化能力。根据所使用的数据集，可能有必要调整这些参数。
构建管道的最后一步是按照指定的顺序组装组件，用分类器打包预处理步骤。在下面的代码片段中，我展示了两条管道，第一条管道用于 USE 和 LaBSE 嵌入，第二条管道用于 M-BERT 嵌入。如图所示，对于 M-BERT，唯一的区别是将单词嵌入和句子嵌入放在一起。
NLP 管道培训
为了用 NLP 管道训练分类器，我使用了下面的单行代码:
classification_model = nlp_pipeline.fit(df_train)
下面的代码片段显示了访问培训日志和显示培训报告所需的两个命令。培训日志中的每个报告条目都将打上时间戳，并可通过十二位字母数字代码进行识别。
!cd ~/annotator_logs && ls -l# select a report log from output of previous command
!cat ~/annotator_logs/ClassifierDLApproach_xxxxxxxxxxxx.log
最后，为了评估结果，在拆分数据集时，有必要在搁置维持数据的情况下测试模型。下面的代码片段显示了如何在测试 Spark 数据帧上运行预测，将其转换为 Pandas 数据帧，然后使用 Scikit-Learn 构建一个简单的分类报告。
当使用 AJGT 数据集来训练阿拉伯情感分类器时，Spark NLP 提供的预训练嵌入都没有 AraBERT 模型的准确度高。对于 USE、LaBSE 和 M-BERT 嵌入，如下所示的结果分别为 65%、87%和 77%。
使用通用语句编码器 嵌入训练的阿拉伯情感分类器的分类报告。
使用语言不可知的 BERT 句子嵌入训练的阿拉伯情感分类器的分类报告。
使用多语言 BERT 单词嵌入训练的阿拉伯情感分类器的分类报告。
有趣的是，观察到与使用嵌入相比，M-BERT 嵌入导致显著更高的准确度，假定 M-BERT 嵌入旨在作为单词嵌入而不是句子嵌入。对于 LaBSE 嵌入，测试嵌入实现的最高准确度是 87%。然而，正如之前证明的，直接在阿拉伯语上训练的 AraBERT 模型表现得非常好，对于这个特定的情感分类任务，报告的准确率为 93.8%。
此外，从上述结果中可以看出，三种分类报告的计算墙时间存在明显差异。使用报告耗时 3.24 秒，而 LaBSE 和 M-BERT 报告分别耗时 38.1 秒和 48.4 秒。虽然使用嵌入产生了最差的准确度分数，但是使用管道比其他两个管道快 10 倍以上。
最终想法
本教程中的实验允许在 AraBERT 和 Spark NLP 已经采用的最先进的句子嵌入之间进行比较。看起来特定于阿拉伯语的语言模型比 Spark-NLP 提供的多语言选项表现得更好。事实上，AraBERT 背后的研究人员已经针对 M-BERT 单词嵌入对他们的模型进行了基准测试，结果显示 AraBERT 的准确率更高。不幸的是，Spark NLP 尚未将 AraBERT 添加到其预训练模型的阵容中。因此，根据我的结果，最好的选择是保存 LaBSE 管道和经过训练的分类器，以便部署在自动化 Spark 工作流中，用于可扩展和可并行的阿拉伯情感分类。准确性的牺牲将得到可靠而高效地处理大数据的能力的回报。我的希望是 Spark NLP 将为低资源语言添加额外的预训练模型，不仅仅是多语言模型或双语翻译模型，而是针对像阿拉伯语这样学习不足的语言的特定语言模型。
使用 BigQuery 或 Google Sheets 自动生成 BigQuery 数据集和表大小报告
从 BigQuery 项目中自动收集表格大小和行数，并将其全部存储在 BigQuery 和/或 Google Sheets 中。
多说说…？
2021 年 1 月 18 日更新:更新了流程和回购代码，因此您只需指定您的 GCP 项目 id，而无需手动输入您的所有项目和数据集 id。所以…现在更容易了！
我想看看是否有可能轻松地自动化跟踪不同的 BigQuery 数据集和表如何随时间变化的过程。在某个时候，我还会添加在阈值被突破时接收电子邮件或 Google Chat 通知的功能(表格在两次检查之间增加/减少太多)，但那是另外一天的事了。今天，我们只是收集关于表的信息，以便于报告和可视化。
显然有很多不同的方法可以做到这一点，包括 BigQuery 本身的预定查询，但这也不能处理将数据自动推入 Google Sheet 的过程。另外…我想看看这在 AppScript 中是否可行，因为现在我可以重新调整查询函数的用途，以便在将来执行其他事情。
以下是我们要用到的所有东西:
- BigQuery 数据集/表—跨多个项目检查它们的大小
- AppScript —处理代码并安排检查自动运行
- BigQuery 表——存储我们收集的数据，如果我们不想使用工作表
- Google Sheet——存储我们收集的信息，如果我们不想使用 BQ 的话
让我们开始吧。
创建 appscript 项目
- 去 script.google.com创建一个新项目
- 因为没有与 appscript 的 git 集成，所以您只需要手动复制文件(文件的内容)
- 从这里分享的 github 库复制文件内容:【https://github.com/usaussie/appscript-bigquery-reporter
- 您应该得到 3 个文件——jobs . GS、Helpers.gs、Config.gs(根据提供的示例重命名)
更新项目以使用您的 BigQuery / Sheet 信息
- 更新 Config.gs 文件以指向您自己的 BQ 项目和您想要跟踪的数据集，然后还提供一个 BQ 表来存储结果=，最后是一个 google sheet url。
// BigQuery Project ID - all lowercase
const BQ_PROJECT_ID = 'your-gcp-project-id';// Create a dataset in the BigQuery UI (https://bigquery.cloud.google.com)
const BQ_DATASET_ID = 'your-gcp-dataset-id';// Table ID to store the collected stats
const BQ_TABLE_ID = 'your-gcp-table-id';// for storing the metrics in google sheets tooconst SHEET_URL = "https://docs.google.com/spreadsheets/d/your-google-sheet/edit";const MAIN_SHEET_TAB_NAME = "Sheet1";// these are the tables & datasets that you
function project_dataset_list() {
return [
['gcp-project-id-a', 'dataset_one'],
['gcp-project-id-a', 'dataset_two'],
['gcp-project-id-b', 'dataset_one'],
['gcp-project-id-c', 'dataset_one']
];
}
- 就是这样…这就是你要自己编码的所有东西…它甚至真的没有编码…它只是指向您已经管理的 id。
- 如果您还没有 BQ 表来存储结果，不要担心，您也可以从这个项目中这样做。
设置完毕，让我们开始吧…
- 首先，让我们创建 BQ 表—打开 Jobs.gs 文件，运行一次 create_tables_one_time()函数和 set_sheet_headers()函数。
/**
* Only run this once to create the initial tables to hold the collected data.
*/
**function create_tables_one_time() {**
var my_tables = tables_to_create();
for (i = 0; i < my_tables.length; i++) {
// generate correct function / table info from detected string
var tableFunction;
tableFunction = new Function('return ' + my_tables[i]);
var thisTable = tableFunction()();
var tableJson = constructTableJson(thisTable, BQ_PROJECT_ID, BQ_DATASET_ID);
createTable(thisTable.tableId, BQ_PROJECT_ID, BQ_DATASET_ID, tableJson);
}
**}**/*
*
* ONLY RUN THIS ONCE TO SET THE HEADER ROWS FOR THE GOOGLE SHEETS
*/
**function set_sheet_headers() {**
var sheet = SpreadsheetApp.openByUrl(SHEET_URL).getSheetByName(MAIN_SHEET_TAB_NAME);
sheet.appendRow(["timestamp","project","dataset","table", "size_bytes", "row_count"]);
**}**
- 这将使 Google 弹出并提示允许您的新 appscript 项目代表您连接到 BigQuery，并写入 Google Drive/Sheets。注意，这是你的项目…所以你只是授予许可给…你自己:-)
授予自我许可！
- 运行 job_get_bq_stats()函数，并等待几秒钟(取决于您正在检查多少个表)。
**function job_get_bq_stats() {**
var this_timestamp = Utilities.formatDate(new Date(), "UTC", "yyyy-MM-dd'T'HH:mm:ss'Z'");
var projects = project_dataset_list();
// loop the outer array
var stats_array = []
for (let i = 0; i < projects.length; i++) {
var my_query = construct_select_query(projects[i][1]);
var query_data = runQuery(projects[i][0], my_query);
// if there are results, add the extra info (timestamp, project etc) ready for storage/insert into our sheet/bq table
if(query_data.length > 0) {
for (let q = 0; q < query_data.length; q++) {
stats_array.push([
this_timestamp,
projects[i][0],
projects[i][1],
query_data[q][0],
query_data[q][1],
query_data[q][2],
]);
}
}
}
// write to bigquery
var insert_query = construct_insert_query(stats_array);
runQuery(BQ_PROJECT_ID, insert_query);
//write to google sheet now
// write collected rows arrays to the sheet in one operation (quicker than individual appends)
var ss = SpreadsheetApp.openByUrl(SHEET_URL).getSheetByName(MAIN_SHEET_TAB_NAME);
ss.getRange(ss.getLastRow() + 1, 1, stats_array.length, stats_array[0].length).setValues(stats_array);
**}**
- 函数执行完毕后，您可以检查 BigQuery 表或 google sheet 来查看结果。
带有收集的 BQ 数据的 Google Sheets 截图
- 现在您应该看到包含项目 ID、数据集 ID、表 ID 的行，然后是表大小(字节)和行数。
我有数据！
安排它自动运行
- 单击 appscript 项目中的 triggers 部分，按照提示每天(或根据需要每小时)运行 job_get_bq_stats()函数。
在 appscript 中设置触发器以自动运行此作业的屏幕截图
我被触发了！
就是这样！
详述一下…
我想补充的下一点是，当数据集在两次检查之间增长/变化“太多”时会发出警报。
请注意，您显然可以将它连接到 Google Datastudio 仪表板，以绘制一段时间内的表格数据，并识别异常值等。
最后…这是代码的 git repo 的另一个链接……您可以根据自己的需要随意使用、增强、扩充。
https://github.com/usaussie/appscript-bigquery-reporter
我喜欢分享:-)
📧使用 Python 自动发送电子邮件
ETL 管道的权威代码片断集合
作者图片[A.Vaccaro]
0.介绍
通常，当执行复杂的 ETL 管道或简单的脚本时，我们需要从邮箱甚至 中读取，自动发送带有任何类型附件( CSV、PDF、JPEG 等)的 。)图一。
图 1——一个简单的 ETL 管道可能以给涉众的电子邮件通知结束。[图片由作者 A.Vaccaro 提供]
正如我们可以想象的， Python 是在有或没有我们监督的情况下自动发送任何种类电子邮件的理想伴侣 。
问题是，尽管有一个简单的 包来处理这一切 ，但我们在网络上找到的指南往往是支离破碎、不完整的。
有了这篇文章我想 收集并展示 你一劳永逸的 最简单的方法 自动发送邮件 ( HTML 或不 ) 带或不带附件 。
🔖所以…请随意将这篇文章添加到您的 书签中，以备将来使用 ！
1.在后台
我们当中有谁从未需要配置自己的邮箱来阅读电脑/智能手机上的电子邮件？
在那一刻，我们当然意识到发送、接收和存储电子邮件需要使用服务提供商 。其中最常见的当然是谷歌邮件、微软 Outlook 和苹果 iTunes。
因此，不可避免地要谈一下描述电子邮件服务提供商特征的 3 个著名协议 :
- SMTP :是用于发送邮件的 协议。 其首字母缩写代表简单邮件传输协议。这就是我们将在本文中使用的。
- 另一方面， IMAP 和 POP 是另外两个流行的协议，分别用于从/在我们的客户端中 读取 和 下载 电子邮件。
2.流动
图 2 —电子邮件生命周期。[图片由作者 A.Vaccaro 提供]
我们即将实施的流程非常简单:
- 使用 Python，我们将实例化一个与服务提供商的 加密连接(STARTTLS)；
- 收到我们的邮件后，我们的服务商(发件人服务器)会通过 SMTP 发送 给收件人服务商(收件人服务器)；
- 收件人的客户端可以使用收件人的服务器 通过 IMAP 或 POP 阅读电子邮件 。
3.我们需要什么
这就是我们所需要的:
- smtplib:Python 的标准库包之一，用很少几行代码发送电子邮件。我们不需要安装这个软件包。
- SMTP 设置:让我们看看我们的服务提供商(，我们打算从那里发送邮件)的文档，寻找 SMTP 主机名 和 SMTP 主机端口 。下面我给你留了一个表格，总结了最常见的设置:
图 3 — TODO ( 谷歌邮箱、微软 Outlook 、苹果 iCloud e 雅虎邮箱)【图片由作者提供— A.Vaccaro】
在继续之前，让 定义参数 :
注意:收件人和发件人是一样的，因为就本文的目的而言，我们最好给自己发邮件😅*。*
让我们从 代码片段 开始吧！
4.如何发送不带附件的电子邮件
让我们从最简单的例子开始:发送一封没有附件的文本邮件。
在这个例子中，像在其他例子中一样，我们将使用MIME Multipart格式，这将允许我们一次组合电子邮件的一部分。
图 4-带有 MIMEText 对象的简单电子邮件。[图片由作者 A.Vaccaro 提供]
让我们从导入smptlib包以及MIMEMultipart和MIMEText模块开始。然后，我们可以通过输入我们的凭证来实例化与服务提供者的连接。
在创建 MIMEMultipart()对象之后，我们用关于发送者、接收者和主题的数据填充它的头部。
最后，让我们定义并填充 MIMEText()和 发送消息 。
搞定了。极其简单！
5.如何发送不带附件的 HTML 电子邮件
这与前面的例子非常相似。
唯一的区别？MIMEText 对象类型必须是“html ”, mime multipart 必须是“alternative”。
图 5-用 MIMEText 对象实现的 HTML 电子邮件。[图片由作者 A.Vaccaro 提供]
让我们像以前一样重写所有内容，插入刚才提到的两个属性。
超级简单。让我们继续附件…
6.如何发送带附件的电子邮件
MIMEMultipart 的 模块化 终将浮出水面。
图 6 —包含文本和附件的电子邮件。[图片由作者 A.Vaccaro 提供]
在这种情况下，实际上，为文本组件实例化一个 MIMEText 和为附件实例化一个(或多个)mime application就足够了。
我们最后将 把它们放在一起 在一个 MIMEMultipart 对象中。
我们可以看到，要将文件正确地附加到文件中，就必须以“字节格式打开它。因此在open()函数中需要“ rb ”。
最后，为了正确地构造 MIME 对象，我们还向 MIMEApplication 对象添加了“Content-Disposition”属性，以指示附件的名称。
7.结论
IT 工具发展非常迅速。尽管如此，电子邮件仍然是任何一种交流方式的基础(或多或少有些复杂)。
此外，正如我们在本文中看到的，使用 Python 自动发送电子邮件极其简单。
我希望已经阐明了你的想法，并能够适当地综合任何需要。
为了其他的一切…让我们保持联系吧！
🤝 如有任何疑问、反馈或协作要求，请随时 联系我Linkedin。我会很高兴和你聊天！
👉要获得更多像这样的内容，并保持对即将到来的文章的更新，不要忘记 在 Medium 上关注我。
🙏如需参考本文，请联系我。谢谢你。
使用 Python 自动化 Excel
使用 PyWin32 实现自动化
用 Python 自动处理无聊的事情，腾出手来喝咖啡
大多数情况下，一个组织会有多个数据源，数据科学家或数据分析师必须在执行分析或创建模型之前，将不同数据源中的数据提取并编译到一个 Excel 文件中。如果我们手动执行，这将是一项复杂且耗时的任务。
用最著名的 Python 库pandas来做这件事会缩短时间，但是硬编码的 Excel 文件可能不会受到直接访问 Excel 文件的其他领域用户的青睐。因此，创建一个格式良好的交互式 Excel 文件将减轻领域用户的工作，并启发他们。
Excel 允许您以透明的方式处理数据，这意味着当打开 Excel 文件时，数据立即可见，并且数据处理的每个步骤也可见。—周红[1]
此外，Excel 很棒，因为我们可以看到报告是如何生成的，以及各列之间的关系。Excel 文件本身是不言自明的。而pandas生成的硬编码 Excel 文件不具备这些特性。
所以，这就是pywin32的用武之地。Pywin32 允许我们从 Python 访问 Microsoft Excel。我们可以通过pywin32访问 Excel 中的所有对象、方法和属性。(在此查看所有 Excel 对象、方法和属性。)
Excel VBA 参考
pywin32没有官方文档，所以我必须参考 Excel VBA 的官方文档来了解可用的对象、属性和方法。
截图来自微软文档
Excel 对象模型
对象、属性、方法和事件包含在 Excel 对象模型中*(我现在不处理事件，所以在本文中，我将只关注对象、属性和方法)*。下面的流程图说明了它们之间的关系。
作者创建的图像
我经常使用的一个对象是范围对象。区域是指 Excel 工作表中的单元格。Range 对象包含如下图所示的方法和属性。
截图来自微软文档
该文档包含 Excel VBA 的基本语法。幸运的是，将 Excel VBA 中的语法翻译成 Python 是很容易的。在我们进入示例之前，我们需要了解五个项目:
- Excel 对象
- Excel 对象方法
- Excel 对象属性
- Excel 常量
- Excel 宏
Excel 对象
Excel 对象类似于 Python 类模块。
当我们想调用一个定义在类模块中的函数时，我们会调用类模块，后跟一个点，然后是函数名。我们需要导入 class 模块来使用它的函数，但是对于pywin32 模块来说，它已经导入了一切，所以我们可以直接调用任何 Excel 对象、方法和属性。
以下部分是对 Excel 对象、方法和属性的详细解释，并附有示例。为了提供更清晰的信息，该示例将使用由下面的脚本生成的 Excel 文件来运行。
- 定义创建 Excel 文件的函数
def create_test_excel_file(f_path: Path, f_name: str, sheet_name: str):
filename = f_path / f_name
random.seed(365)
np.random.seed(365)
number_of_data_rows = 1000
# create list of 31 dates
dates = pd.bdate_range(datetime(2019, 9, 1), freq='1d', periods=31).tolist()data = {'Date': [random.choice(dates) for _ in range(number_of_data_rows)],
'Gender': [random.choice(['Female', 'Male']) for _ in range(number_of_data_rows)],
'Products': [random.choice(['Shirts', 'Pants', 'Caps', 'Socks']) for _ in range(number_of_data_rows)],
'Price': np.random.normal(15, 5, size=(1, number_of_data_rows))[0]}# create the dataframe and save it to Excel
pd.DataFrame(data).to_excel(filename, index=False, sheet_name=sheet_name, float_format='%.2f')
2.定义参数并执行功能
# sheet name
sheet_name = 'example' # update with sheet name from your file
# file path
f_path = Path.cwd() # file in current working directory
# f_path = Path(r'c:\...\Documents') # file located somewhere else
# excel file name
f_name = 'example.xlsx'
create_test_excel_file(f_path, f_name, sheet_name)
为您创建的 Excel 文件的屏幕截图。
作者创建的图像
Excel 对象方法
Excel 对象模型中的方法与 Python 中的函数相同，都是可调用的，执行任务。用 python 编写函数应该总是以一对包含关键字参数的括号结束，如下面的 Python 脚本所示，函数greet以一对包含名为“name”的参数的括号结束。
# Python Functions:
# create a function
def greet(name):
print(f"Hello {name}")greet(name = "Alisa")
下面的脚本显示了如何在 Excel 中使用一种方法，通过使用pywin32来自动筛选。它与 Python 函数语法非常相似，除了我们不需要定义方法，我们将对象放在方法的前面，就像我们将类模块名称放在我们在类模块中定义的函数之前一样。(这里使用的 Excel 文件是前面章节创建的 Excel 文件。)
import pandas as pd
from pathlib import Path
import win32com.client as win32
f_path = Path.cwd() # change to the path to the Excel file
f_name = 'example.xlsx' # Excel File name
filename = f_path/f_name
sheetname = 'example' # change to the name of the worksheet
# create Excel object
excel = win32.gencache.EnsureDispatch('Excel.Application')
# excel can be visible or not
excel.Visible = True
# open Excel Workbook
wb = excel.Workbooks.Open(filename)# create filter in Excel Worksheet
wb.Sheets(sheetname).Range("A1").AutoFilter(Field = 2, Criteria1="Female", VisibleDropDown=False)
在上面的例子中，wb.Sheets(sheetname).Range(“A1”)是指对象，AutoFilter()是方法，Field = 2, Criteria1="Female", VisibleDropDown=False是参数。字段是指要筛选的列。Field = 2指左数第二列，即 B 列[‘性别’]。该脚本的结果如下图所示，数据根据“性别”过滤，当我们将标准设置为女性时，仅显示“女性”记录。
作者创建的图像
将 Excel VBA 写入 Python 的标准语法是以这种方式组织代码:
对象。方法(参数=参数)
当您查看 Excel VBA 文档时，总会有一些如下的脚本示例(下面的脚本是根据上面提到的 Excel VBA 参考中的示例修改的)。
Worksheets("Sheet1").Range("A1").AutoFilter _
Field:=2, _
Criteria1:="Female", _
VisibleDropDown:=False
Excel VBA 和 Python 的语法只有微小的区别，其中 Excel VBA 不保存括号中的参数，而在 Python 中，我们必须创建 Excel 对象并显式定义工作簿路径和名称。因此，从 Excel VBA 转换到 Python 是可能且容易的。
Excel 对象属性
Excel 对象模型中的属性与 Python 中的变量相同，不可调用，只返回赋值。例如，Excel 表中某列的列宽是用来存储该列的列宽的属性。另一个例子，Excel 表中单元格的值。你可以把它想象成一个变量，你可以改变它的值，就像你在 python 中改变变量的值一样。
# Python Variable:
# assign a value to a variable
x = 5
# change the value assigned to the variable
x = 6
上面显示了如何在 Python 中更新变量值的简单示例。下面的脚本展示了如何使用pywin32来更新 Excel 中单元格的值。
import pandas as pd
from pathlib import Path
import win32com.client as win32
import datetime
today = datetime.date.today()f_path = Path.cwd() # change to the path to the Excel file
f_name = 'example.xlsx' # Excel File name
filename = f_path/f_name
sheetname = 'example' # change to the name of the worksheet
# create Excel object
excel = win32.gencache.EnsureDispatch('Excel.Application')
# excel can be visible or not
excel.Visible = True
# open Excel Workbook
wb = excel.Workbooks.Open(filename)# update value in Excel Worksheet
wb.Sheets(sheetname).Range("F1").Value = f"Today date: {today}"
在上面的例子中，wb.Sheets(sheetname).Range(“F1”)指的是对象，Value是属性，而f”Today date: {today}”是分配给对象的值。简而言之，我们将一个值放入一个单元格中。当我们用 Python 编写脚本时，我们可以应用一些 Python 脚本。在这种情况下，使用 f 字符串。下图显示了脚本的结果。
作者创建的图像
当我运行这个脚本时，从前面的脚本创建的过滤器没有被清除，所以过滤器仍然在文件中。清除过滤器的方法将在下一节中解释。
将 Excel VBA 写入 Python 的标准语法是以这种方式组织代码:
对象。属性=值
下面是根据 Excel VBA 参考修改的脚本。
Worksheets("Sheet1").Range("F1").Value = "2021-05-13"
对于属性，Excel VBA 中的语法在大多数情况下与 Python 中的语法相同。当要分配的值是 Excel 常量时，语法会稍有不同。
Excel 常数
一些对象方法和属性只接受常量列表作为它们的参数。Excel 常量通常以“xl”开头。在这种情况下，我们必须在使用 Python 时导入常量(在使用 Excel VBA 时这是不必要的)。
import pandas as pd
from pathlib import Path
import win32com.client as win32
**win32c = win32.constants**f_path = Path.cwd() # change to the path to the Excel file
f_name = 'example.xlsx' # Excel File name
filename = f_path/f_name
sheetname = 'example' # change to the name of the worksheet
# create Excel object
excel = win32.gencache.EnsureDispatch('Excel.Application')
# excel can be visible or not
excel.Visible = True
# open Excel Workbook
wb = excel.Workbooks.Open(filename)# set cell horizontal alignment
wb.Worksheets("example").Columns("A:D").HorizontalAlignment = **win32c**.xlLeft
在上面的例子中，赋值为xlLeft，因为它是 Excel 常量，我们必须在常量前面添加 win32c (因为我将win32.constants保存为 win32c)。上面脚本的结果如下图所示。
作者创建的图像
标题的水平对齐方式是居中，现在向左对齐。
将 Excel VBA 写入 Python 的标准语法是以这种方式组织代码:
对象。Property = win32c。ExcelConstant
Excel 宏
pywin32 的语法类似于将 Excel VBA 翻译成 Python 语法。因此，您可以随时参考 Excel VBA 文档，了解 Excel 中可用的对象、方法和属性。当文档不够时，您可以简单地记录特定过程的宏并参考步骤信息。
在我的工作中，我使用 Excel 宏来获取特定列的字体颜色(*expression*.Columns.Font.Color)和单元格填充颜色(*expression*.Columns.Interior.Color)的颜色代码。
作者创建的 GIF
在上面的 GIF 中，255 代表红色的颜色代码，我们可以在 Python 脚本中使用它来改变单元格的颜色。
当我们不确定在某种情况下使用哪些方法或属性时，我们总是可以记录 Excel 宏。
例子
在这一节中，我将分享我经常使用的方法和属性。与上面的例子一样，在运行任何执行 excel 方法或修改 Excel 属性的脚本之前，我们需要导入库并创建 Excel 对象。以下示例中使用的 Excel 文件仍然是我们在前面部分创建的文件。
import pandas as pd
from pathlib import Path
import win32com.client as win32
win32c = win32.constantsf_path = Path.cwd() # change to the path to the Excel file
f_name = 'example.xlsx' # Excel File name
filename = f_path/f_name
sheetname = 'example' # change to the name of the worksheet
# create Excel object
excel = win32.gencache.EnsureDispatch('Excel.Application')
# excel can be visible or not
excel.Visible = True
# open Excel Workbook
wb = excel.Workbooks.Open(filename)
方法
- 自动滤镜
向每列添加筛选器。
wb.Sheets(sheetname).Range("A1").AutoFilter(Field = 1)
2。自动调整
根据单词长度调整列宽。
wb.Sheets(sheetname).Columns("A:I").AutoFit()
3。复制
将单元格区域的值复制到另一个位置。
wb.Sheets(sheetname2).Range("A1:E10").Copy(Destination = wb.Sheets(sheetname).Range("F1"))
4。复制+选择性粘贴
将一个工作表的格式复制到另一个工作表。
# copy paste FORMAT only, which include font colour, fill colour, and border
wb2.Sheets(sheetname).Range("A:D").Copy()
wb.Sheets(sheetname).Range("A1").PasteSpecial(Paste=win32c.xlPasteFormats)
5。向下填充(向左填充、向右填充、向上填充)
将公式填入单元格区域。例如，从单元格 A2 填充到 A1000，如下面的脚本所示。
wb.Sheets(sheetname).Range("A2:A1000").FillDown()
6。插入
通过向下移动原始列*(到后面的索引，例如，从 C 列到 D 列)*插入新列。
# insert a new row by shifting the original row down
wb.Sheets(sheetname).Rows("1:2").Insert(win32c.xlShiftDown)
性能
- 列宽
调整列宽。
wb.Sheets(sheetname).Columns("A").ColumnWidth = 10
2。字体/内部颜色
字体包含更多属性，例如字体颜色、字体大小和字体名称。
分配颜色有两种方法，颜色代码和颜色索引。对于颜色代码，它是一个很长的数字，只能通过查阅 Excel 宏步骤信息来获得。而对于颜色索引，您可以在 Excel 中创建一个颜色表，并找到您想要的颜色索引。
wb.Worksheets(sheetname).Columns("K:K").Font.Color = -4165632
wb.Worksheets("sheetname").Columns("K:K").Interior.Color = 10092492
3。公式
将公式分配给单元格。
wb.Sheets(sheetname).Range(f"{column_insert}2").Formula = "=A2+B2"# if you wish to create a function
column1 = "A"
column2 = "B"
operation = "+" # math operation to perform between 2 columnsdef math_op(column1, column2, operation):
wb.Sheets(sheetname).Range(f"{column_insert}2").Formula = f"={column1}2{operation}{column2}2"math_op(column1, column2, operation)
{column1}和{operation}之间的‘2’，{column2}后的‘2’表示第 2 行。
4。水平对齐
调整单元格水平对齐。对准有三种类型，分别是xlLeft、xlCenter 和xlRight。
wb.Worksheets("sheetname").Rows("1:1").HorizontalAlignment = win32c.xlLeft
5。数字格式
设置数值的格式。对于NumberFormat值，可以通过 Excel 宏获取。
wb.Worksheets("sheetname").Columns("O:O").NumberFormat= '_("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_([@_](http://twitter.com/_))'
结论
Pywin32 允许我们像手工一样设置 Excel 报表。我们可以用引用单元格设置公式(例如:O2 = P2+Q2)，创建数据透视表，设置单元格格式(例如:单元格颜色、字体颜色、列宽等)。)，设置滤镜等等。
我们可以通过pywin32自动生成定期生成的格式报告。我们只需在 Python 脚本中创建所有方法或设置属性一次。
此外，我们可以扩大这种自动化。例如，我们可能需要在完成后通过电子邮件发送这份 Excel 报告。我们可以简单地添加脚本的另一行来发送报告。
最后，每当你进退两难时，记住 Python pywin32 的标准语法如下。
对象。方法(参数= 参数
对象。属性=值
对象。Property = win32c。ExcelConstant
如果您是一个视频爱好者，这里有一个视频，介绍了您应该知道的使用 PyWin32 库自动生成 Excel 报表的关键概念。
保持联系
在 YouTube 上订阅
一些旁注
如果您有兴趣了解如何自动化创建数据透视表并从数据透视表中提取过滤后的数据到 pandas DataFrame ，用 Python 自动化数据透视表(创建、过滤和提取)。
如果你有兴趣用 Python 创建图表或数据透视图，并自动导出为图像，那么用 Python 自动化 Excel 图表。
如果你的工作使用的是 Google Sheet 而不是 Microsoft Excel，你可以参考这篇文章，“自动化 Google Sheet Report ”来了解可能的自动化。
如果你有兴趣知道如何使用pywin32访问 Microsoft Outlook 邮件和下载附件，你可以参考这篇文章“用 Python 自动下载邮件附件”。
文献学
[1] H .周，通过 Excel 学习数据挖掘:理解机器学习方法的逐步方法，纽约:新闻媒体，2020 .
[2] 如何用 Python win32com 模块在 Excel 中创建数据透视表 —用 Python 在 Excel 中创建数据透视表的完整示例。
[3] Excel VBA 参考 —关于 Microsoft Excel 中的对象、方法、属性和事件的完整参考。
祝贺并感谢你阅读到最后。希望你喜欢这篇文章。 ☺️
Caleb Chen 在 Unsplash 上拍摄的照片
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
