使用 Python 的自动化数据剖析
使用 Python 生成带有数据分析输出的 MS Word 文档。
这篇博客是关于自动化探索性数据分析过程(EDA) 的数据剖析阶段的。我们将使用 Python 自动执行数据分析过程，并生成一个 Microsoft Word 文档作为数据分析结果的输出。
将 MS Word 文档作为数据分析结果输出的主要优势在于，它可用于捕捉领域专家关于数据质量、数据转换和特征工程的讨论和决策，以便进一步建模和可视化。
A sample page for numeric column data profiling
Python 代码的优势在于它保持了通用性，使想要修改代码的用户能够轻松地添加更多功能或更改现有功能。例如，更改为数字列数据配置文件生成的图形类型，或从 Excel 文件加载数据。
你可以从我的 GitHub 网站下载完整的代码。将以下文件下载到一个文件夹中，以执行 Python 代码:
01 _ 16 _ av _ automated _ data _ profiling _ MS _ word . ipynb
请注意，您将需要“docx”包来生成 MS Word 文档输出。
什么是探索性数据分析(EDA)
探索性数据分析指的是一套由 John Tukey 开发的技术，以一种有趣的特征将变得明显的方式显示数据。与通常从数据的假设模型开始的经典方法不同，EDA 技术用于 鼓励数据建议可能合适的模型 。
【来源:http://www.statgraphics.com/exploratory-data-analysis】
数据剖析是探索性数据分析过程的第一阶段***。***
什么是数据剖析过程？
数据分析是检查从现有信息源(如数据库或文件)获得的数据，并收集关于该数据的统计数据或信息摘要的过程。
数据剖析的目的是 找出现有数据是否可以方便地用于其他目的 。
数据剖析利用描述性统计的方法，例如最小值、最大值、平均值、模式、百分位数、标准偏差、频率、变化、合计(例如计数和总和)以及在数据剖析期间获得的附加元数据信息，例如数据类型、长度、离散值、唯一性、空值的出现、典型的字符串模式和抽象类型识别。
【来源:https://en.wikipedia.org/wiki/Data_profiling
数据简介 Data frame(DPD)——游戏改变者！
Python 和 Pandas 提供了许多分析数据的函数。但是这些命令必须单独发出，并且信息将是分散的。这是一个重复而繁琐的手动过程。
数据剖析数据框架是一种改变游戏规则的方式，可以在一个数据框架中方便地访问所有数据剖析信息，该数据框架是通过结合 Pandas 包的许多数据剖析功能和 Python 的通用统计功能而生成的。
创建数据概要数据帧
创建 DPD 的代码可以从我的 GitHub 站点 AnalyticsInsightsNinja 下载。
将以下文件下载到一个文件夹中，以执行 Python 代码:
01 _ 16 _ av _ automated _ data _ profiling _ MS _ word . ipynb
请注意，您将需要“docx”包来生成 MS Word 文档输出。
由于代码可以免费下载，所以在本文中，我将只讨论创建 DPD 的关键方面。
首先，创建一个数据帧，其行数等于数据集中的列数。这是因为 DPD 中的行是列的轮廓，因此 DPD 中的行数等于数据集中的列数。所需的列被添加到数据框架中。
源数据中的列与值计数、唯一值计数等详细信息一起作为行添加到 DPD 中。
下一步是使用以下命令生成源数据帧配置文件的数据帧:
df . describe()t . round(2)
这将创建一个源数据概要数据帧，对其进行转置(T)并将数值四舍五入到两位小数。
创建 DPD 的 关键步骤 是将最初创建的 DPD 与上述 describe()函数产生的数据帧合并。
pd.merge(data_qlt_df，raw_num_df，how='left '，left_on='column_name '，right_index=True)
然后将剩余的列添加到 DPD 中。
生成图表/图形
在代码的不同点，生成不同的图/图形并保存到磁盘。这些图像将被插入到 MS Word 文档的适当位置。
数字列的图表/图形
对于数字列，会生成以下图形:
- 列中所有值的箱线图
- 列中所有值的直方图
- 列中所有值的四分位数箱线图
- 无异常值的箱线图
- 小于 95%的值的小提琴图
- 小于 95%的值的直方图
在上图中，小于 95%的值的直方图是一个 自定义版本 直方图，具有不同百分位范围的条形值计数、条形范围值和彩色条形。这个直方图的代码可以从我的 GitHub 站点 AnalyticsInsightsNinja 下载— PythonVisualAnalytics 。
数字列的图表/图形
对于“对象”类型的列，为前二十五(25)个值绘制列的唯一值的标准化值。
相关图
数字列的相关图有助于确定列之间的关系和/或了解列如何受另一列的影响。
最终输出
最终的 Microsoft Word 文档是使用“ docx ”包创建的。
生成带有数据分析细节的 MS Word 文档的代码有些冗长，因为进入 Word 文档的每个细节都必须编码。但是输出值每一行代码！
Sample pages from the final Data Profile MS Word document
Sample numeric column data profile
示例数据配置文件 MS Word 文档可以从我的 GitHub 站点下载(Data _ Profile _ df _ MS _ Word . docx)。
数据分析之后的下一步是什么？
正如本博客前面提到的，数据剖析的目的是 发现现有数据是否可以方便地用于其他目的 。
那么使用 DPD 可以做出什么决定呢？
- 列名和数据类型:了解列是什么，列数据类型是否正确，列是否对用于建模目的的特征工程有用，或者可用于可视化分析，等等。
- 从磁盘到 RAM 的内存增加:可以决定是否需要优化列数据类型以适应 RAM。
- 数字列统计:根据列的最大值和最小值，可以决定列类型是否可以向下转换以优化内存使用。例如从 float64 向下转换到 float16
- 唯一值计数:根据列类型和唯一值的数量，可以决定它是否是要转换为“分类”数据类型的候选列。
- 空值的百分比或数量:可以决定是否可以以有意义的方式填充空值，如果列具有大量空值，该列是否有任何有用的用途，是否可以删除该列，如果该行的列值为空，是否可以删除观察/行，等等。
- 列值分布:可以决定如何处理异常值，是否应该丢弃异常值，什么样的视觉效果可以有效地识别趋势或模式，等等。
- 相关性图:可以决定相关性是否可以用于进行预测，强相关列是否可以用一个列代替多个列而不丢失信息，等等。
注意:需要注意的是，任何关于数据的决策都需要领域知识，或者需要了解领域知识和数据的人。在没有正确理解数据和领域知识的情况下做出的决策可能会导致糟糕的分析和分析。
结论
在本文中，我们探索了如何使用 Python 来自动化探索性数据分析过程(EDA) 的数据剖析阶段。
将 MS Word 文档作为数据分析结果输出的主要优势在于，它可用于捕捉领域专家关于数据质量、数据转换和特征工程的讨论和决策，以便进一步建模和可视化。
虽然有各种现有的软件和软件包来帮助数据分析过程，但是该代码提供了一些非常有用的好处:
- Python 代码是通用的，因此可以对其进行修改，以将用户需要的任何数据源加载到 Pandas 数据框架中。
- 一旦数据被加载到 Pandas 数据帧中，剩下的数据分析代码就可以不加任何修改地执行，以产生最终的 MS Word 输出。
- 数据配置文件的输出是一个完整的 Microsoft Word 文档，可用于记录关于数据的进一步讨论和决策。
使用 Apache Spark 进行大规模自动化数据质量测试
亚马逊的开源库——dee qu
Photo by Stephen Dawson on Unsplash
我一直是一名技术架构师，主要负责数据湖/中心/平台类的项目。每天，我们都会从 100 多个业务系统中获取数据，以便分析和 BI 团队可以在项目中使用这些数据。
问题陈述
在接收数据时，我们避免任何转换。数据从源位置复制。源可以是 MySQL、SQL Server、Oracle、DB2 等类型。目标系统可以是 Hadoop/Hive 或 Big Query。尽管没有对数据进行转换，因为源系统和目标系统是不同的，但有时这些简单的数据接收可能会导致数据质量问题。源系统和目标系统可以有不同的数据类型，这可能会导致更多的问题。数据中的特殊字符可能会导致行/列移位。
可能的解决方案
为了解决这个问题，大多数开发人员在构建数据管道后，使用手工方法进行数据质量测试。这可以通过运行一些简单的测试来完成，比如
- 源和目标之间的样本数据比较
- 主键列上的空检查
- 日期列上的空检查
- 分类列的计数比较
- 等等。
这种方法有时效果很好，但是很耗时并且容易出错。因此，我开始寻找一些自动化的选项。
亚马逊的 Deequ
我对开源数据质量测试框架的搜索止步于来自亚马逊的 Deequ 库。 Deequ 在亚马逊被用于验证许多大型生产数据集的质量。系统会定期计算数据质量指标。
Source — https://aws.amazon.com/blogs/big-data/test-data-quality-at-scale-with-deequ/
Deequ 建立在 Apache Spark之上，因此它可以自然地扩展到海量数据。最棒的是，你不需要详细了解 Spark 就可以使用这个库。 Deequ 提供如下功能
- 约束建议 —测试什么。有时可能很难找到在特定对象中测试什么。Deequ 提供了内置的功能来识别要测试的约束。
- 度量计算 —一旦我们知道要测试什么，我们就可以使用库给出的建议并运行测试来计算度量。
- 约束验证——使用 Deequ，我们还可以放置测试用例，并获得用于报告的结果。
让我们开始行动吧
为了运行 Deequ，我们需要首先准备好我们的工作站。您可以在一台简单的 Windows/Linux/Mac 机器上尝试一下。
先决条件
- 安装 Scala——你可以从——https://www.scala-lang.org/下载安装 Scala
- 安装 Apache Spark——你可以从——https://spark.apache.org/下载安装 Spark
- 下载 Deequ 库 —您可以下载 Deequ JAR，如下所示—
wget http://repo1.maven.org/maven2/com/amazon/deequ/deequ/1.0.1/deequ-1.0.1.jar
- 准备好要测试的数据 —如果你没有要测试的数据，你可以准备一个。对于本教程，我安装了一个 MySQL 实例，并从 http://www.mysqltutorial.org/mysql-sample-database.aspx加载了一些样本数据
- 下载 JDBC Jars —对于您想要运行这些测试的任何类型的数据库，请确保在
$SPARK_HOME/jars中添加 JDBC Jars。因为我要在 MySQL & Hive 上运行我的测试，所以我添加了各自的 JDBC jar。
在交互模式下启动 Spark
为了运行测试，我们将使用上一步下载的库在交互模式下启动 Spark，如下所示
PS D:\work\DataTesting> spark-shell --conf spark.jars=deequ-1.0.1.jar
Spark context Web UI available at [http://localhost:4040](http://SLB-CR3K882.DIR.slb.com:4040)
Spark context available as 'sc' (master = local[*], app id = local-1561783362821).
Spark session available as 'spark'.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/___/ .__/\_,_/_/ /_/\_\ version 2.4.3
/_/Using Scala version 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_171)
Type in expressions to have them evaluated.
Type :help for more information.scala>
约束建议
我计划在前面步骤中加载的customer表上运行测试。您可以使用 MySQL Workbench/CLI 来验证数据是否正确加载。
为了运行约束建议，我们需要首先使用 Spark 连接到 DB。
请注意，使用这种方法，我们将查询下推到底层数据库。所以直接在生产系统上运行时请小心。
import org.apache.spark.sql.SQLContextval sqlcontext = new org.apache.spark.sql.SQLContext(sc)val datasource = sqlcontext.read.format("jdbc").option("url", "jdbc:mysql://<IP>:3306/classicmodels").option("driver", "com.mysql.jdbc.Driver").option("dbtable", "customers").option("user", "<username>").option("password", "<password>").option("useSSL", "false").load()
在有效的连接上，您可以检查表的模式—
scala> datasource.printSchema()
root
|-- customerNumber: integer (nullable = true)
|-- customerName: string (nullable = true)
|-- contactLastName: string (nullable = true)
|-- contactFirstName: string (nullable = true)
|-- phone: string (nullable = true)
|-- addressLine1: string (nullable = true)
|-- addressLine2: string (nullable = true)
|-- city: string (nullable = true)
|-- state: string (nullable = true)
|-- postalCode: string (nullable = true)
|-- country: string (nullable = true)
|-- salesRepEmployeeNumber: integer (nullable = true)
|-- creditLimit: decimal(10,2) (nullable = true)scala>
现在，让我们运行约束建议—
import com.amazon.deequ.suggestions.{ConstraintSuggestionRunner, Rules}
import spark.implicits._ // for toDS method// We ask deequ to compute constraint suggestions for us on the data
val suggestionResult = { ConstraintSuggestionRunner()
// data to suggest constraints for
.onData(datasource)
// default set of rules for constraint suggestion
.addConstraintRules(Rules.DEFAULT)
// run data profiling and constraint suggestion
.run()
}// We can now investigate the constraints that Deequ suggested.
val suggestionDataFrame = suggestionResult.constraintSuggestions.flatMap {
case (column, suggestions) =>
suggestions.map { constraint =>
(column, constraint.description, constraint.codeForConstraint)
}
}.toSeq.toDS()
一旦执行完成，您可以打印如下所示的建议—
scala> suggestionDataFrame.toJSON.collect.foreach(println){"_1":"addressLine1","_2":"'addressLine1' is not null","_3":".isComplete(\"addressLine1\")"}
{"_1":"city","_2":"'city' is not null","_3":".isComplete(\"city\")"}
{"_1":"contactFirstName","_2":"'contactFirstName' is not null","_3":".isComplete(\"contactFirstName\")"}
{"_1":"state","_2":"'state' has less than 69% missing values","_3":".hasCompleteness(\"state\", _ >= 0.31, Some(\"It sho
uld be above 0.31!\"))"}
{"_1":"salesRepEmployeeNumber","_2":"'salesRepEmployeeNumber' has less than 25% missing values","_3":".hasCompleteness(\
"salesRepEmployeeNumber\", _ >= 0.75, Some(\"It should be above 0.75!\"))"}
{"_1":"salesRepEmployeeNumber","_2":"'salesRepEmployeeNumber' has no negative values","_3":".isNonNegative(\"salesRepEmp
loyeeNumber\")"}
{"_1":"customerName","_2":"'customerName' is not null","_3":".isComplete(\"customerName\")"}
{"_1":"creditLimit","_2":"'creditLimit' is not null","_3":".isComplete(\"creditLimit\")"}
{"_1":"creditLimit","_2":"'creditLimit' has no negative values","_3":".isNonNegative(\"creditLimit\")"}
{"_1":"country","_2":"'country' is not null","_3":".isComplete(\"country\")"}
{"_1":"country","_2":"'country' has value range 'USA', 'Germany', 'France', 'Spain', 'UK', 'Australia', 'Italy', 'New Ze
aland', 'Switzerland', 'Singapore', 'Finland', 'Canada', 'Portugal', 'Ireland', 'Norway ', 'Austria', 'Sweden', 'Belgiu
m' for at least 84.0% of values","_3":".isContainedIn(\"country\", Array(\"USA\", \"Germany\", \"France\", \"Spain\", \"
UK\", \"Australia\", \"Italy\", \"New Zealand\", \"Switzerland\", \"Singapore\", \"Finland\", \"Canada\", \"Portugal\",
\"Ireland\", \"Norway \", \"Austria\", \"Sweden\", \"Belgium\"), _ >= 0.84, Some(\"It should be above 0.84!\"))"}
{"_1":"postalCode","_2":"'postalCode' has less than 9% missing values","_3":".hasCompleteness(\"postalCode\", _ >= 0.9,
Some(\"It should be above 0.9!\"))"}
{"_1":"customerNumber","_2":"'customerNumber' is not null","_3":".isComplete(\"customerNumber\")"}
{"_1":"customerNumber","_2":"'customerNumber' has no negative values","_3":".isNonNegative(\"customerNumber\")"}
{"_1":"contactLastName","_2":"'contactLastName' is not null","_3":".isComplete(\"contactLastName\")"}
{"_1":"phone","_2":"'phone' is not null","_3":".isComplete(\"phone\")"}
这意味着你的测试用例已经准备好了。现在让我们运行指标计算。
度量计算
查看列和建议，现在我想运行指标计算。你可以这样做—
import com.amazon.deequ.analyzers.runners.{AnalysisRunner, AnalyzerContext}
import com.amazon.deequ.analyzers.runners.AnalyzerContext.successMetricsAsDataFrame
import com.amazon.deequ.analyzers.{Compliance, Correlation, Size, Completeness, Mean, ApproxCountDistinct, Maximum, Minimum, Entropy, GroupingAnalyzer}val analysisResult: AnalyzerContext = { AnalysisRunner
// data to run the analysis on
.onData(datasource)
// define analyzers that compute metrics
.addAnalyzer(Size())
.addAnalyzer(Completeness("customerNumber"))
.addAnalyzer(ApproxCountDistinct("customerNumber"))
.addAnalyzer(Minimum("creditLimit"))
.addAnalyzer(Mean("creditLimit"))
.addAnalyzer(Maximum("creditLimit"))
.addAnalyzer(Entropy("creditLimit"))
.run()
}
如果运行成功，您可以看到结果
// retrieve successfully computed metrics as a Spark data frame
val metrics = successMetricsAsDataFrame(spark, analysisResult)metrics.show()scala> metrics.show()
+-------+--------------+-------------------+-----------------+
| entity| instance| name| value|
+-------+--------------+-------------------+-----------------+
| Column| creditLimit| Entropy|4.106362796873961|
| Column|customerNumber| Completeness| 1.0|
| Column|customerNumber|ApproxCountDistinct| 119.0|
| Column| creditLimit| Minimum| 0.0|
| Column| creditLimit| Mean|67659.01639344262|
| Column| creditLimit| Maximum| 227600.0|
|Dataset| *| Size| 122.0|
+-------+--------------+-------------------+-----------------+
您还可以存储这些数字以供进一步验证，甚至显示趋势。在本例中，我们运行的是使用超对数算法计算的ApproxCountDistinct,。这通过近似非重复计数来减少源系统的负担。
可用分析器的完整列表可在以下位置找到—https://github . com/aw slabs/de equ/tree/master/src/main/Scala/com/Amazon/de equ/analyzer
约束验证
现在让我们使用验证套件运行测试用例。
import com.amazon.deequ.{VerificationSuite, VerificationResult}
import com.amazon.deequ.VerificationResult.checkResultsAsDataFrame
import com.amazon.deequ.checks.{Check, CheckLevel}val verificationResult: VerificationResult = { VerificationSuite()
// data to run the verification on
.onData(datasource)
// define a data quality check
.addCheck(
Check(CheckLevel.Error, "Data Validation Check")
.hasSize(_ == 122 )
.isComplete("customerNumber") // should never be NULL
.isUnique("customerNumber") // should not contain duplicates
.isNonNegative("creditLimit")) // should not contain negative values
// compute metrics and verify check conditions
.run()
}
运行完成后，您可以查看结果
// convert check results to a Spark data frame
val resultDataFrame = checkResultsAsDataFrame(spark, verificationResult)resultDataFrame.show()scala> resultDataFrame.show()
+-------------------+-----------+------------+--------------------+-----------------+------------------+
| check|check_level|check_status| constraint|constraint_status|constraint_message|
+-------------------+-----------+------------+--------------------+-----------------+------------------+
|Data Validate Check| Error| Success|SizeConstraint(Si...| Success| |
|Data Validate Check| Error| Success|CompletenessConst...| Success| |
|Data Validate Check| Error| Success|UniquenessConstra...| Success| |
|Data Validate Check| Error| Success|ComplianceConstra...| Success| |
+-------------------+-----------+------------+--------------------+-----------------+------------------+
如果某个特定的案例失败了，您可以查看如下所示的详细信息
resultDataFrame.filter(resultDataFrame("constraint_status")==="Failure").toJSON.collect.foreach(println)
增量数据的数据验证
Deequ 还提供了一种验证增量数据加载的方法。你可以在https://github . com/aw slats/dee qu/blob/master/src/main/Scala/com/Amazon/dee qu/examples/algebraic _ States _ example . MD了解更多关于这种方法的信息
异常检测
Deequ 还提供了一种检测异常的方法。GitHub 页面列出了一些方法和策略。详情可以在这里找到——https://github . com/aw slabs/dee qu/tree/master/src/main/Scala/com/Amazon/dee qu/anomaly detection
结论
总的来说，我认为 Deequ 是一个很好的工具，可以用于数据湖/中心/数据仓库类用例中的数据验证和质量测试。亚马逊甚至发表了一篇关于这种方法的研究论文。这可以在 http://www.vldb.org/pvldb/vol11/p1781-schelter.pdf 观看
如果你尝试这个，一定要让我知道你的经历。如果你有一些有趣的想法，请不要忘记在评论中提及。
Hey, if you enjoyed this story, check out [Medium Membership](https://deshpandetanmay.medium.com/membership)! Just $5/month!*Your membership fee directly supports me and other writers you read. You’ll also get full access to every story on Medium.*
自动唇读:简化
看一眼自动化唇读的世界(ALR)
为什么要读唇语？
专业的唇读并不是最近才有的概念。它实际上已经存在了几个世纪。显然，唇读背后的最大动机之一是为听力障碍者提供一种理解对他们说的话的方式。
然而，随着计算机视觉和深度学习领域技术的进步，机器自动唇读现在已经成为现实可能。请注意这个领域的发展，显示为每年发表的关于 ALR 的论文的累积数量。
Cumulative number of papers on ALR systems published between 2007 and 2017 [1]
这些进步开辟了各种新的讨论途径，涉及 ALR 的应用、窥探私人谈话的道德问题，以及最重要的是它对数据隐私的影响。
想想唇语的错综复杂，你就明白了。
medium.com](https://medium.com/datadriveninvestor/automated-lip-reading-may-threaten-data-privacy-but-not-for-a-while-b08392914351)
然而，我今天不是来讨论这个问题的。这个博客是为那些想更深入了解这些 ALR 系统如何工作的好奇的少数人准备的。任何之前完全没有深度学习经验的人都可以肤浅地关注博客。即使是对深度学习的初步了解，也足以充分体会其中的细节。
唇读难吗？
看看这个《行尸走肉》几个短片的烂唇读视频就知道了(把声音关了)。再看一遍，有声音，只是为了好玩:P
滑稽…对吗？对话似乎与视频非常匹配，但显然有些地方感觉不对劲。到底出了什么问题？首先，这些显然不是真正的对话。但是为什么它们看起来如此完美？
这是因为嘴唇运动和音素(语言中最小的声音单位)之间没有直接的一一对应关系。比如/p/和/b/在视觉上是无法区分的。所以，同样的嘴唇动作可能是许多不同句子的结果。
但是专业的唇语读者是怎么做到的呢？专业的唇读是对唇动、肢体语言、手部动作和语境的理解的结合，以解读说话者想要说的话。听起来很复杂…对吗？好吧，让我们看看机器是怎么做的…
ALR、ASR 和 AV-ASR 有什么区别？
首先，让我们了解一下 3 个看似常见的术语 ALR、ASR 和 AV-ASR 之间的区别
- 自动唇读(ALR) :-试图理解仅仅基于视频(视觉)的说话内容。
- 自动语音识别(ASR) :-试图仅根据音频来理解正在说的内容。通常称为语音转文本系统。
- 视听-自动语音识别(AV-ASR) :-使用音频和视觉线索来理解正在说的内容。
字母和数字识别
ALR 早期的工作集中在简单的任务上，如字母或数字识别。这些数据集包含各种说话者的小片段，具有各种空间和时间分辨率，说单个字母(或音素)或数字。这些任务在 ALR 的早期阶段很流行，因为它们允许研究人员在受控的环境和受限的词汇下工作。
Frames from AVLetters, one of the most used alphabet recognition dataset
单词和句子识别
虽然字母和数字识别的受控设置对于在早期设计阶段分析算法的有效性是有用的，但是得到的模型不具有在野外运行的能力。ALR 系统的目的是理解自然语音，自然语音主要是由句子构成的，这使得有必要获取包含单词、短语和语音平衡句子的数据库以及可以有效处理这些内容的模型。
Frames from OuluVS2, a multi dimensional audio-visual dataset for tasks like ALR, ASR and AV-ASR
管道的浅见
典型 ALR 系统主要由三部分组成
- 嘴唇定位，
- 视觉特征的提取，
- 并分类成序列
第一个模块集中在人脸和嘴唇检测上，本质上是一个计算机视觉问题。第二个模块的目标是为每一帧可观察到的视觉信息提供特征值(数学值)，这也是一个计算机视觉问题。最后，分类块旨在将这些特征映射到语音单元，同时确保完整的解码消息是连贯的，这属于自然语言处理(NLP)的领域。这个最后的块通过使用上下文帮助在视觉上相似的语音单元之间消除歧义。
基于深度学习的 ALR 系统
在过去的几年里，ALR 系统的性能有了显著的提高，这要归功于基于深度学习的架构越来越多地参与到管道中。
前两个模块，即嘴唇定位和特征提取是使用 CNN 完成的。一些其他基于 DL 的特征提取架构也包括 3D-CNN 或前馈网络。最后一层由 LSTMs 组成，通过考虑所有单独的帧输出来进行最终分类。其他一些基于 DL 的序列分类体系结构包括 Bi-lstm、GRUs 和 lstm。
An example of a DL based baseline for ALR systems [1]
下一步是什么？
在过去几年中，可以看到从传统架构到端到端 DNN 架构的明显技术转移，目前由 CNN 功能结合 LSTMs 主导。
然而，在大多数这些模型中，系统的输出被限制在预定义数量的可能类别(字母、单词甚至句子)，这与目标是自然语音的连续唇读形成对比。最近生产连续唇读系统的尝试集中于基本语言结构，例如字符或音素。因此，不足为奇的是，ALR 系统目前的主要挑战是能够模拟连续的唇读系统。
这个博客是为机器学习领域创建简化介绍的努力的一部分。点击此处的完整系列
在你一头扎进去之前就知道了
medium.com](https://medium.com/@prakhargannu/machine-learning-simplified-1fe22fec0fac)
或者干脆阅读系列的下一篇博客
看看人类姿势估计的世界
towardsdatascience.com](/human-pose-estimation-simplified-6cfd88542ab3)
参考
[1]费尔南德斯-洛佩兹、阿德里亚娜和费德里科-苏克诺。“深度学习时代的自动唇读调查。”图像与视觉计算(2018)。
【2】钟，俊儿，和安德鲁·齐塞曼。"通过看视频学习唇读单词."计算机视觉与图像理解 173(2018):76–85。
[3] K.L. Moll，R.G. Daniloff，言语过程中帆运动时机的研究，J. Acoust。社会主义者我是。50 (2B) (1971 年)
自动化机器学习
自动机器学习(AutoML)目前是数据科学中爆炸性的子领域之一。对于那些不精通机器学习的人来说，这听起来很棒，对于当前的数据科学家来说，这很可怕。媒体对 AutoML 的描述让它看起来能够彻底改变我们创建模型的方式，不再需要数据科学家。虽然一些公司如 DataRobot 的目标是完全自动化机器学习过程，但该领域的大多数公司都在创建 AutoML 作为一种工具，以增加当前数据科学家的产量，并简化进入该领域的过程，使其更容易获得。
AutoML 作为一个完全自动化过程的工具，在理论上是一个很好的想法，但是在现实世界中，它引入了许多偏见和误解的机会。在过去的几年里，机器学习领域已经开始脱离“黑盒”模型，转而使用更简单、更容易解释的模型。复杂的模型可能难以解读，因此很难知道模型何时引入了偏差。AutoML 现在加剧了黑盒模型的这个问题，它不仅隐藏了模型的数学，还在后台执行以下操作:
- 数据清理
- 特征选择
- 型号选择
- 参数选择。
随着以上所有的自动化，使用这些系统的人还剩下什么呢？除了获取数据集和读取结果，什么都不做。这种程度的自动化给我们的模型和解释它们的人都带来了潜在的问题。在学习成为数据科学家的过程中，有三件事变得尤为重要。
- 模型的好坏取决于给定的数据，如果数据有缺陷，模型很容易产生偏差。
- 机器非常擅长最大化人类给定的目标函数，无论该目标函数是否准确或正确。
- 学习数据科学的很大一部分是为了理解模型的算法及其结果，如果没有这方面的知识，很容易对模型结果做出不正确的推断。
在过去的几年里，我们已经看到了许多关于流通模型的报告，这些模型不断地做出不正确的/有偏见的预测。如果现实世界中存在偏差，那么如果在模型中没有对其进行适当的考虑，这种偏差很容易增加。如果我们用 AutoML 来完全自动化这个过程，可能弊大于利。然而，完全自动化只是少数公司研究人员的目标，还有一个方面可能会使社区受益匪浅。
我看了 Randall Olsen 在 Scipy 2018 的演讲，自动机器学习的过去、现在和未来。在他的演讲中，他强调 AutoML 不是为了取代数据科学家，而是像我上面所说的那样，是为了提高当前数据科学家的生产力，让那些多年来没有研究这些算法的人更容易进入这个领域。
Source: SemanticsScholar.org
作为一名数据科学家，我可以使用这些应用程序快速浏览我的数据，并了解如何开始建模。AutoML 不会告诉我使用哪个模型，而是让我知道什么模型和技术是有效的，节省了我花在探索性数据分析和数据清理上的时间，而这些时间可以花在微调模型上。一个例子是 TPOT，由上位实验室创建，这是一个基于 Scikit-Learn(一个非常流行的机器学习库)构建的 Python 自动语言库。其设计旨在快速运行数据分析，并让您知道哪些模型、功能和参数比其他更有效。
Source: https://epistasislab.github.io/tpot/
TPOT 应该被看作是一个起点或一个比较模型，而不是一个最终产品。它打开了思路和技术，以我们可能没有想到或没有时间深入探索的方式接近我们当前的数据集。可以想象，这些算法具有非常复杂的样本空间/模型，数据集越大，使用的算法越复杂，情况就越复杂。使用非常高级的算法来导航该样本空间，包括:
- 元学习
- 贝叶斯优化
- 遗传表演程序
- 多臂强盗
因为它们非常复杂，所以运行时间非常长，根据问题的不同可能需要几天时间。这只是加强了 AutoML 将被用作帮助数据科学家的工具的想法，因为这些算法可以在后台运行，而我们则在项目的其他方面工作。在接下来的几年里，这些工具将继续改进，但它们不会取代数据科学家。相反，它们将增强我们所能完成的，并允许机器学习随着该领域变得越来越容易接近而发展。
我想看看这些 AutoML 库是如何运行的，所以我按照 Randall Olsen 演讲中的代码，在 MNIST 数据集上运行 TPOT，这是一个包含数字的图像数据集。这只需要 9 行代码，我就可以达到 98%的准确率。
TPOT 能够使用欧氏距离确定 K 个最近邻，K =1 是分类 MNIST 数据集的最佳算法。虽然这种方法快速、简单且准确，但不需要理解它在做什么或告诉我们什么。失去了这一点，我们就失去了对模型的所有解释，也失去了决定我们为什么会得到这些数字的能力。
引用作品:
https://www.youtube.com/watch?v=QrJlj0VCHy
面向数据分析师和业务用户的自动化机器学习
增强人工智能——机器学习
在不到五分钟的时间内构建您的第一个机器学习模型。
Automated Machine Learning for Business Users & Data Analysts
***Automated Machine Learning (AutoML) represents a fundamental shift in the way organizations of all sizes approach machine learning and data science.***
机器学习是人工智能的一个分支，基于这样一种想法，即系统可以从数据中学习，识别模式并在最少的人工干预下做出决策。机器学习为我们在各个行业提供了一些重大突破。金融服务、零售、医疗保健、银行等领域一直在以这样或那样的方式使用机器学习系统，结果非常有希望。
今天的机器学习不仅仅局限于 R&D，而且已经渗透到企业领域。然而，传统的机器学习过程严重依赖于人类，并不是所有的企业都有资源投资于经验丰富的数据科学团队。即使公司拥有资源、数据科学家和工程师，这些专业人员也不得不每月花费数百个小时来构建和维护这些机器学习系统。
我们的研究还表明，当前大多数数据科学家缺乏领域专业知识，因此需要与不同部门的专业人员合作来解决特定问题，例如，预测哪些客户更有可能购买产品。这些部门代表是具有更深层次业务知识和分析技能的专家，但缺乏预测分析技能，特别是机器学习。
***Automated ML democratizes the machine learning model development process, and empowers its users, no matter what their data science expertise is, to identify an end-to-end machine learning pipeline for any problem***
自动化机器学习正在催生公民数据科学家，因为它使在现实世界中构建和使用机器学习模型变得更加容易，而无需编写代码。自动化机器学习融合了来自顶级数据科学家的最佳机器学习实践，最先进的开源库，使机器学习和数据科学在整个组织中更容易获得。
以下是传统的模型构建过程:
图一:
Traditional Machine Learning Model Building Process
从上面的图 1 可以看出，用传统流程开发一个模型是极其耗时、重复和繁琐的。自动化机器学习应用程序自动执行通常需要熟练的数据科学家才能完成的模型构建任务。自动化机器学习系统不是花费几周或几个月的时间，而是快速的，通常需要几天时间让业务用户/数据分析师建立数百个模型，进行预测并产生见解。数据分析师的机器学习自动化使组织能够事半功倍。
AutoML 使医疗保健、金融科技、银行等行业的企业有可能利用先进的机器学习和人工智能技术，这些技术以前仅限于拥有大量资源的组织。通过自动化大多数机器学习建模任务，AutoML 使业务用户和数据分析师能够轻松实现机器学习解决方案，并更加专注于解决复杂的业务问题。
跨行业的数据分析师和业务用户可以使用自动化机器学习来:
***1\. Implement ML-powered solutions without extensive programming knowledge***
***2\. Save time and resources***
***3\. Leverage data science best practices***
***4\. Agile problem-solving***
自动化机器学习是如何工作的？
有许多工具，每个都有自己的内部功能，但我们将只关注 m trons dp2——一种内置数据准备和 AutoML 库的新型应用程序。
通过使用非常直观的 Web 用户界面，用户可以通过五个简单的步骤构建新的项目和运行 ML 实验。
***1\. Identify the use-case: predict demand, customer churn or credit card fraud***
***2\. Identify the ML problem type: Regression, Classification or Time-Serices***
***3\. Upload your data or connect your data source***
***3\. Choose your target variable (the variable you want to predict)***
***4\. Train & evaluation 100s of machine learning algorithms****
***5\. Deploy the best performing algorithm and make predictions*****
- mltrons 自动机器学习管理最先进的库，如 AutoKeras、PyTorch、TensorFlow、H2O、TPOT、Caffe、SageMaker 和 AlphaD3M，以建立最适合数据的模型。Mltrons 内置了支持深度学习的 GPU。
Available libraries within the mltrons framework
** mltrons AutoML for data analysts 允许他们使用“假设”情景模拟器来创建多种结果的策略。这填补了数据分析师/科学家和执行决策者之间的空白。
一切从今天开始！
这是为了快速产生价值，尽可能多地承担你能处理的小项目。借助自动化机器学习，数据分析师可以开始构建机器学习模型，并将他们的技能提升到一个新的水平。另一方面，企业可以获得多项成功，并在更短的时间内完成其组织内的多个使用案例，这将形成势头，并使迭代和扩展数据货币化成为可能。
关于作者
Raheel Ahmad 是 mltrons 的首席执行官和联合创始人。你可以在推特、脸书和 LinkedIn 上和他联系。
自动化机器学习:到底有多少？
我对三位数据科学家和指导自动化专家的采访
Landing page of the Guided Automation web application
目前有很多关于自动机器学习的讨论。也有很高程度的怀疑。
我和数据科学家 Paolo Tamagnini 、 Simon Schmid 和 Christian Dietz 在一起，从他们的角度就这个话题问了几个问题，我发现引导自动化的概念也很有趣，因为它直接涉及自动化机器学习的实践。
Rosaria Silipo: 什么是自动化机器学习？
Christian Dietz: 自动化机器学习是指构建一个系统、流程或应用程序，能够在尽可能少的人工输入下自动创建、训练和测试机器学习模型。 CRISP-DM 周期是在近 20 年前引入的，现在是一个具有标准步骤的既定流程，如数据准备、功能工程和功能优化、模型训练、模型优化、模型测试和部署，这些步骤在大多数数据科学项目中都很常见。自动化的目的是尽可能地从这些步骤中去除人工干预。
有不同的算法和策略可以做到这一点，这些算法和策略因复杂性和性能而异，但主要思想是让业务分析师能够训练大量模型，并通过少量配置提供最佳模型。
我们通常只谈论自动化机器学习，但它实际上是将自动化融入尽可能多的循环步骤中——而不仅仅是模型的训练/选择。例如，自动化数据争论或数据可视化的应用程序也开始出现。
Rosaria: 在没有专家干预的情况下，自动化机器学习真的可以完全自动化数据科学周期吗？
**西蒙·施密德:**这是个棘手的问题！有人说能，有人说不能。
在我看来，对于标准的数据科学问题，自动化机器学习可以完全自动化数据科学周期。你知道这种情况:你有一些数据，这些数据很一般，很好地描述了问题，没有不平衡的类。你选择一个模型，在训练集上训练它，在测试集上评估它。如果性能可以接受，就部署它。没有大的意外。在这种情况下，整个循环可以自动化，甚至引入一些额外的优化步骤。
然而，更复杂的数据科学问题可能需要一定程度的人工或专家的参与。
例如，领域专家可以在继续机器学习过程之前添加一些关于数据处理和过滤的独特知识。此外，当数据领域变得比简单的表格数据更复杂时，例如，包括文本、图像或时间序列，领域专家可以为数据准备、数据划分和特征工程提供定制技术。
基本上，你的问题的答案是“有时”正是因为这个原因，我们的团队使用了一个允许两种选择的框架。您可以运行一个完全自动化的周期，或者您可以决定在过程中的选择点进行干预。这是通过一个叫做引导分析的特性提供的功能。Guided Analytics 允许您在工作流中散布交互点，从而在需要时将数据科学应用转向不同的方向。
**罗萨莉亚:**你已经描述过了，但是我想我们的读者会从一些额外的细节中受益。你能告诉我们更多关于引导式分析的信息吗？
Paolo Tamagnini :引导式分析是指在数据管道中灵活地添加交互点，即在分析过程中数据经过的一系列步骤之间。当你开发一个数据处理或数据分析应用程序时，你不仅仅是为自己开发，也是为其他人开发。因此，为了让任何人都有机会调整分析如何进行，您应该在整个管道的战略位置添加一些交互点。
数据管道也称为工作流，交互点是网页，通过包装的元节点无需任何脚本即可轻松创建。例如，在报告应用程序中，您可以请求用户选择要显示的时间窗口或 KPI 在数据争论应用程序中，你可以询问哪些数据源应该混合在一起，应该构建什么样的特性；在机器学习应用中，您可以要求用户指定目标变量和输入变量、应训练的模型以及是否需要执行特征工程。
Rosaria: 所以，引导自动化是你对自动化机器学习应用的解释。你能简单描述一下它是如何工作的吗？
克里斯蒂安: 引导式自动化是将引导式分析与自动化机器学习相结合的产物。您可以灵活地要求业务分析师在必要的时候加入他们的专业知识，从而自动化分析的标准部分。自动化和交互的适当数量取决于不同的问题。有时，您可以继续使用默认的选择，而有时您需要进一步的输入来改进和控制这个过程。
自动化机器学习应用的引导式分析中的常见交互点是上传数据和选择目标的时间，指定哪些特征将用作输入和训练哪些模型，而自动化主要涉及超参数优化和特征选择。您还可以添加可选的交互点，例如定制功能工程或选择定制可伸缩性的执行环境。
该流程包括自动化和交互点，如下图所示。在为引导式自动化实现蓝图工作流时，我们遵循了这个图表中的一般方法。
Image Credit: KNIME
Rosaria: 这个引导自动化的蓝图…这个蓝图是我可以购买的软件解决方案吗？
**保罗:**买？不，是免费的！就像我们在使用的所有示例和蓝图工作流一样。你所需要做的就是下载一个开源副本，启动它，打开实例服务器，在 50 _ Applications/36 _ Guided _ Analytics _ for _ ML _ Automation 找到蓝图，拖放到你的本地工作区，然后你就可以在你自己的数据上自动化机器学习过程了。请随意定制它。它最终是一个蓝图，您可以根据您的数据科学问题对其进行改进和定制，以实现最佳性能。
**罗莎丽亚:**不错！我需要特殊的软件来正确运行引导自动化的蓝图吗？
绝对不行。在 KNIME Server 上，您可以从任何 web 浏览器远程访问交互点，这非常有用。但是使用开源和免费的分析平台，您还可以运行蓝图，访问交互点，并通过客户端内置的 web 浏览器与工作流进行交互。
Rosaria: 在哪里可以学习如何定制引导式自动化的蓝图？
一般来说，你可以从免费的电子学习课程开始。在那里，您可以了解更多:如何访问数据，如何执行 ETL 操作，以及如何显示绘图和图表。
感谢 Christian、Paolo 和 Simon 的宝贵时间和清晰的回答！现在我更了解自动化机器学习的一般概念，引导式分析，以及您创建的蓝图，引导式自动化。
为首次发表于data versity。
自动电影标记——一个多类分类问题
从电影概要中自动提取标签的多类分类问题。
Photo by: Kyle Hinkson on Unsplash
电影标签揭示了关于电影的各种各样的异质信息，如类型、情节结构、配乐、元数据、视觉和情感体验。这些信息对于构建自动系统来为电影创建标签很有价值。
自动标记系统也有助于推荐引擎改进相似电影的检索，以及帮助观众预先知道对电影的期望。
在这篇文章中，我们将使用广泛的机器学习算法和 NLTK 功能从电影概要中挖掘出电影标签。所以让我们开始吧！
数据来源
我们在本案例研究中使用的数据是从 Kaggle 中的数据集收集的，该数据集包含超过 14k 部电影和大约 142 个独特的标签。
我们来看看数据:
从上表中，我们可以看到每部电影都有概要和与之对应的几个异构标签。此外，数据是从 IMDB 和维基百科收集的。
探索性数据分析
首先，我们尝试从数据集中删除重复项并进行分析:
- 每个问题的标签数。
- 最常见的标签。
- 数据集中标签的频率。
每个问题的标签数量:-
在进行了一些计算后，我们发现大多数电影都有一个标签。每部电影的平均标签数为 2.99。
最常用的标签:-
为此，我们将绘制一个单词云并将其可视化。
标签的频率:-
在分析了上述 EDA 之后，我们得出结论，一些电影有大量的标签，但大多数电影只标记了一两个标签。谋杀、暴力、倒叙和浪漫是语料库中出现频率最高的四个标签。最不常用的标签是愚蠢，聪明，感觉良好，幽闭恐惧症。
情节提要的清理和预处理
现在，我们已经完成了重复数据删除，我们的数据需要一些预处理，然后才能继续分析和建立预测模型。
因此，在预处理阶段，我们按以下顺序执行以下操作
- 从移除 HTML 标签开始
- 删除任何标点符号或有限的一组特殊字符，如、或。或者#，等等。
- 检查单词是否由英文字母组成，并且不是字母数字
- 检查单词的长度是否大于 2(据调查，没有两个字母的形容词)
- 将单词转换成小写
- 移除停用词
- 单词被词汇化——第三人称的单词被改成第一人称，过去时态和将来时态的动词被改成现在时态。
- 最后，雪球用词干这个词(据观察，它比波特用词干要好)
现在，我们已经对标签分析有了简单的了解，并在更大程度上清理了我们的情节概要，让我们开始真正有趣的部分。
利用情节概要预测标签的机器学习方法
最重要的工作是将数据分成训练集和测试集。集合的训练部分将用于训练模型。我们使用测试部分交叉验证并测试训练好的模型。为此，我们根据文本语料库中给定的列split拆分数据。
x_train=new_data.loc[(new_data['split'] == 'train') |(new_data['split'] == 'val')]
x_test=new_data.loc[(new_data['split'] == 'test')]
接下来，我们定义随机基线模型来比较我们提出的模型在预测电影标签的任务中的性能。基线模型将所有标签分配给所有电影。
但在继续之前，让我们先了解几个术语:
Pipeline 类允许将多个进程粘贴到单个 Scikit-learn 估计器中。我们将在开始部分使用相同的。
OneVSRest 分类器 ，对于每个分类器，该类与所有其他类匹配。
计数矢量器 提供了一种简单的方法，既可以标记一组文本文档，构建一个已知单词的词汇表，还可以使用这个词汇表对新文档进行编码。
tfidfttransformer将计数矩阵转换为归一化的 tf 或 tf-idf 表示。CountVectorizer 和 TfidfTransformer(use _ IDF = False)都产生词频，TfidfTransformer 正在对计数进行规范化。
A 宏观平均 计算 精度 ， 召回 和f1-独立地为每个类评分 ，然后取平均值(因此平等地对待所有类)，而 微观平均 将聚集所有类的贡献来计算平均度量。在多类别分类设置中，如果您怀疑可能存在类别不平衡(例如，一个类别的示例可能比其他类别的多得多)，微平均值是更好的选择。
所有上述术语需要更广泛的解释，但那是另一天的故事。
由于这是一个多类分类问题，我们将上述模块用于我们的基线和特征工程(将在下面讨论)模型。
Micro-average quality numbers
Precision: 0.1586, Recall: 0.3639, F1-measure: 0.2209
Macro-average quality numbers
Precision: 0.0733, Recall: 0.1752, F1-measure: 0.0969 precision recall f1-score support
avg / total 0.20 0.36 0.25 9020
我们观察到该模型在只有 25%的微观 f1 分数的情况下表现不佳。让我们尝试使用 网格搜索 超参数调整建立另一个模型。我们将使用逻辑回归和 oneVSRest 分类器作为我们的分类算法。
vectorizer = CountVectorizer(min_df=0.00009, max_features=50000, tokenizer = **lambda** x: x.split())
vectorizer.fit(x_train['preprocessed_data'])
x_train_multilabel = vectorizer.transform(x_train['preprocessed_data'])
x_test_multilabel = vectorizer.transform(x_test['preprocessed_data'])
网格搜索交叉验证:
0.10172648121582308
{'estimator__alpha': 1e-05}
我们现在使用网格搜索得到的最佳超参数1e-05建立模型。
Micro-average quality numbers
Precision: 0.0678, Recall: 0.3704, F1-measure: 0.1146
Macro-average quality numbers
Precision: 0.0471, Recall: 0.3029, F1-measure: 0.0717
precision recall f1-score support
avg / total 0.16 0.37 0.21 9020
我们观察到我们的基线模型仍然没有改进。我们使用不同的模型进行了一些其他的实验，我们可以得到以下结果。
特征工程
现在，为了提高模型的性能，非常需要特征工程。在进行特征工程之前，我们考虑的参数是:-
- 提取单词 n-grams (n=1，2，3)
- 字符 n 元语法(n=3，4)
- 跳过 n 元语法(n=2，3)
我们在情节概要上执行所有上述操作，因为它们是强词汇表示。我们使用术语频率-逆文档频率(TF-IDF)作为加权方案。
我们在上面已经看到，每个大纲的标签分布并不均匀。有些大纲有 20 个标签，而有些只有 1 个标签。但是平均来说，每个大纲的标签数量是 2.9 个(见 EDA)。所以我们会考虑每个情节大纲 4 个标签，并进行我们的操作。
vectorizer = CountVectorizer(tokenizer = **lambda** x: x.split(','), binary='true', max_features = 4)
multilabel_y_train = vectorizer.fit_transform(y_train)
multilabel_y_test = vectorizer.transform(y_test)
什么是 n-gram，uni-gram，bi-gram，tri-gram？
在计算语言学和概率领域，n 元语法是来自给定文本或语音样本的 n 个项目的连续序列。使用拉丁数字前缀，大小为 1 的 n-gram 被称为“unigram”；尺寸 2 是一个“二元组”(或者，不太常见的是，“二元组”)；大小 3 是一个“三元组”。 ( 维基 )
Unigram
0.4297968028569633
{'estimator__alpha': 0.001}
注:- SGDClassifier与log的损失是的 Logistic 回归。现在让我们来构建 unigram 模型。
Micro-average quality numbers
Precision: 0.3311, Recall: 0.6079, F1-measure: 0.4287
Macro-average quality numbers
Precision: 0.3223, Recall: 0.5954, F1-measure: 0.4118
precision recall f1-score support
0 0.20 0.54 0.29 308
1 0.25 0.53 0.34 507
2 0.48 0.64 0.55 844
3 0.36 0.68 0.47 552
micro avg 0.33 0.61 0.43 2211
macro avg 0.32 0.60 0.41 2211
weighted avg 0.36 0.61 0.44 2211
我们观察到模型的 f1 值、精确度和召回率都有显著提高。类似地，我们通过改变ngram_range=(2,2)、三元组ngram_range=(3,3)和ngram_range=(1,3)对二元组执行相同的操作。我们观察到所有的模型都比我们的基线模型表现得更好。一旦我们建立了所有的 n 元模型。我们组合这些特征，并在其上运行我们的分类器。
单字+双字+单字
有一个非常好的方法来组合 Scipy 提供的稀疏矩阵，称为hstack或水平堆叠。我们将使用相同的来组合我们的特征。
**from** **scipy.sparse** **import** coo_matrix, hstack
train_1 = hstack((x_train_multilabe_uni, x_train_multilabe_bi),format="csr",dtype='float64')test_1 = hstack((x_test_multilabel_uni, x_test_multilabel_bi),format="csr",dtype='float64')train_2 = hstack((train_1, x_train_1),format="csr",dtype='float64')
test_2 = hstack((test_1, x_test_1),format="csr",dtype='float64')
型号:
Micro-average quality numbers
Precision: 0.3509, Recall: 0.6065, F1-measure: 0.4446
Macro-average quality numbers
Precision: 0.3358, Recall: 0.5894, F1-measure: 0.4232
precision recall f1-score support
0 0.21 0.55 0.30 308
1 0.28 0.47 0.35 507
2 0.48 0.67 0.56 844
3 0.38 0.68 0.48 552
micro avg 0.35 0.61 0.44 2211
macro avg 0.34 0.59 0.42 2211
weighted avg 0.37 0.61 0.46 2211
我们看到性能再次提高。但是，让我们再深入一点，看看我们能否将 f1 分数提高到 50%以上。
字符 3 克
char n-gram 是来自给定文本或语音样本的 n 个字符的连续序列。在 Char 3-gram 特征化过程中，我们所做的唯一改变是将analyzer = 'char'作为矢量函数的一个参数。
vectorizer = TfidfVectorizer(sublinear_tf=**True**, strip_accents='unicode', analyzer='char', ngram_range=(3, 3), max_features=20000)
x_train_3char = vectorizer.fit_transform(X_train)
x_test_3char = vectorizer.transform(X_test)
同样，我们继续进行网格搜索和建模。
Micro-average quality numbers
Precision: 0.3567, Recall: 0.6680, F1-measure: 0.4651
Macro-average quality numbers
Precision: 0.3408, Recall: 0.6407, F1-measure: 0.4418
precision recall f1-score support
0 0.22 0.52 0.31 308
1 0.28 0.62 0.38 507
2 0.49 0.74 0.59 844
3 0.38 0.68 0.49 552
micro avg 0.36 0.67 0.47 2211
macro avg 0.34 0.64 0.44 2211
weighted avg 0.37 0.67 0.48 2211
我们也对 Char 4-gram 执行相同的操作，但是放置analyzer =char ngram_range = (4,4)，我们得到下面的结果。
precision recall f1-score
weighted avg 0.39 0.65 0.49
我们接近 50%的 f1 分数。我们还试图通过结合 char 3 和 char 4-gram 特性来构建一个模型，但是这个模型并没有显示出任何显著的改进。
我们在上面做 EDA 时已经看到，每个大纲的平均标签数是 2.9。所以现在我们会考虑每个剧情梗概 3 个标签。让我们看看我们能否让性能超过 50%大关。
带 3 个标签的型号
像往常一样，我们从类标签的二进制矢量化开始，这次有 3 个类。
vectorizer = CountVectorizer(tokenizer = **lambda** x: x.split(','), binary='true', max_features = 3)
multilabel_y_train = vectorizer.fit_transform(y_train)
multilabel_y_test = vectorizer.transform(y_test)
正如上面解释的模型，我们建立了一元，二元，三元模型，但它们的行为与我们的 4 类标签模型相同。然后我们尝试了角色级别的模型，嘣！！该车型的性能超过了 f1 得分的 50%。
对于使用 3 个类级别的 char 3-gram，我们得到了以下结果。
precision recall f1-score support
0 0.28 0.58 0.38 507
1 0.50 0.73 0.59 844
2 0.39 0.63 0.48 552
micro avg 0.39 0.66 0.49 1903
macro avg 0.39 0.65 0.48 1903
weighted avg 0.41 0.66 0.50 1903
类似地，对于 char 4-gram:
precision recall f1-score support
0 0.29 0.61 0.40 507
1 0.49 0.74 0.59 844
2 0.41 0.68 0.51 552
micro avg 0.41 0.69 0.51 1903
macro avg 0.40 0.68 0.50 1903
weighted avg 0.42 0.69 0.52 1903
总结和观察
结论和后续步骤:
- 我们最初建立了基线模型。基线模型的主要问题是地块概要不平衡，每个概要的标签数量变化很大。
- 在 EDA 中，我们观察到平均每部电影有 2.9 个标签。所以我们确实选择了 4 个标签和 3 个标签建立了 2 套模型，并对它们进行了很大程度的分析。
- 在 4 标签模型(3char + 4char gram)的情况下，模型表现最佳，微 f1 分数为 49%，这与基线模型相比有显著提高。
- 在 3 标签模型的情况下，再次(3 察尔+4 察尔克)模型表现最佳，微 f1 分数为 51%，这也是从基线模型的显著增加。
- 有一点我注意到，我的模型比他们在研究论文中使用的模型表现得更好，这是一个令人满意的问题。
- 最后，我也使用了语义向量，如 word2vec、手套向量和潜在狄利克雷分配(LDA)来进一步改进我的模型，但它们没有多大帮助。
源代码可以在我的 Github repo 上找到。我期待听到任何反馈或问题。
****研究论文:https://arxiv.org/pdf/1802.07858.pdf
自动化研究及其他:人工智能的进化
你很快就能向机器解释一个研究问题，并得到相应的答案。
欢迎来到演播室…一个装载栏在屏幕上移动……系统扫描你的脸……一个略带东德口音的声音说道:
“早上好，今天你想做什么？”
自 2025 年以来，类似的解决方案在研究界掀起了一场风暴。承诺非常简单；解释你的机器——例如，笔记本电脑或智能手机——研究问题，机器会找到答案。
你首先解释说，你对了解晚期宫颈癌患者死亡率的相关因素感兴趣。
“你想让我从一篇文献综述开始吗？”
每月都有数百篇关于宫颈癌的新论文发表。在自动化研究系统出现之前，研究人员已经放弃了对所有主题进行全面文献综述的尝试，但最新发表的文章数量仍然允许的最小众的主题除外。在过去的 12 个月中，标题中提到“宫颈癌”的论文总共约有 10，000 篇，而这只是潜在相关文章的一小部分。在世纪之交，我们已经失去了包含在某一特定主题的著作纲要中的集体智慧的轨迹。
你决定接受文献综述。
“我应该提供全面的结论还是要点？结论将把你的设备的预计到达时间从大约 3 分钟缩短到几天。对于 300 美元的云计算预算，我们可以将得出结论的预计时间减少到大约一个小时。”
你决定从高光开始，这样你在几分钟后就会看到一些东西。
“收到，我们开始吧？”
你确认后，机器就开始工作了。
自动化文献综述
这台机器能找到几百万篇潜在相关的科学文章。一些文件调查和讨论研究主题。其他人通过引用、作者和其他因素与主题有着有意义的联系。有些信号对人类来说没有意义，它们是隐藏在文章内容深处的潜在倾向，以及其他方面，与其他文章形成微妙的联系。有时最强的联系来自令人惊讶的不同话题。先进的机器智能能力是实用性和惊喜之间的平衡。结果需要几分钟才能出来，尽管事实上一切都发生在不到 1000 美元的平板电脑上。你可以用你的智能手机，这不会花太多时间。
“结果可在您的设备上获得。”
你拿起你的设备，在你打开一个易于阅读的交互式文献综述的发现摘要之前。到 2000 年人类无法完成的事情，任何人都可以在喝杯咖啡的时间内完成。
机器智能的参数化
到 21 世纪 20 年代早期，研究人员已经完全参数化了计算机辅助研究的基本方面。非常粗略地说，基于机器智能的决策系统涉及数据的收集和准备、模型的选择、优化和测试，以及验证和管理最终的解决方案。构成使用数据回答研究问题的各个阶段的所有单个活动，都经过精心规划和参数化，达到了允许所有这些过程完全自动化的程度。
直到最近几年，数据科学家通常将一半的时间用于所谓的 ETL 活动——提取、转换和加载数据——没有人再做数据准备了。机器会以人类无法想象的方式来做这件事，在决定最佳输入数据是什么样子之前，会经历大量不同的变化。机器也可能决定使用相关的公共数据，以努力获得研究问题的最佳结果。
一旦所有涉及的过程都按照它们所包含的参数清晰地表达出来——这只是一个时间问题，而不是像一些人认为的那样是一个可行性问题——自动化相关的过程就成了一个简单的工程问题。没有什么新东西需要构建，所有东西都可以通过已有的开源包获得。人们只需要以创建新的、完全自动化的工作流的方式来组合这些功能。一旦工作流实现自动化，几个人工智能研究小组就明白，为了更好地利用机器智能的承诺，采取更平衡的系统开发方法至关重要。尽管几十年来，诸如新的神经网络架构之类的能力开发受到了研究人员和开发人员的极大关注，但是交互和治理在很大程度上被忽略了。
回到 2020 年，互动和治理方面涉及许多至关重要的未解决问题；例如减少使用通用机器智能 API 所涉及的认知开销，以及人工智能安全性和伦理。这种三大支柱之间的平衡转变引发了创造自动化研究的竞赛。
超越一般性
人工智能的大问题——通用性，在 2020 年之前的几年里已经被 TensorFlow 和 Pytorch 等解决方案解决了。事实上，普遍性到 2015 年已经解决了，没有人只是清楚地知道它已经发生了。TensorFlow 等平台允许精通计算机的研究人员为几乎任何研究问题创建解决方案。随着这些平台的成功，出现了第一个机器智能解决方案 API，例如 Keras 和 fast . ai。解决方案 API从根本上简化了研究人员解释他们正在寻找的解决方案的方式。深度学习解决方案 API将数百行陈旧的计算机代码简化成一个类似儿童玩乐高积木的过程。
解决方案 API没有解决的问题，与人类几十万年来的交流方式有关。我们更擅长用文字来解释一个研究问题，而不是用计算机代码来描述解决方案。接下来，显而易见的进展涉及到自 1962 年所有演示之母以来，人类与信息系统交互方式中最重要的范式转变。这个转变就是问题 API。
问题 API
机器智能领域的重大突破并不是来自新的深度学习模型架构，或者该研究领域关注的任何东西。相反，这是一个安静而艰难的缓慢过程，重点是人类与机器的交互方式。结果就是第一个问题 API。在 2030 年的今天，仍然有很多解决方案 API，但是研究人员很少使用。相反，解决方案 API是问题 API的构建模块，就像差异化引擎是解决方案 API的构建模块一样。问题 API 的想法非常简单；几千年来，研究过程一直专注于提出问题(陈述问题)，然后通过严格的过程，找到答案。回想起来，很明显，未来的研究将遵循相同的已被证实的范式。此外，用人类语言表达问题的能力极大地扩大了受益于机器智能发展的研究人员和其他人的数量。
到 2020 年，超过一百万的研究人员在科学和工业的几乎所有可以想象的领域使用解决方案 API。经过 50 多年的神经网络研究和发展，人工智能终于起飞了。
尽管如此，机器仍然依赖于人——通过编程或拖放构建器——来清晰准确地表达解决方案。机器解决给定问题的能力在很大程度上依赖于高技能的人给它如何做的精确指令。指导解决方案 API需要理解专业语言、统计函数和许多其他复杂的事情。一些这种复杂性被带到了第一个*问题 API 中；*为了充分利用系统的优势，仍然需要适度的技术知识。
声音革命
语音理解和合成方面的发展最近使得除了语音之外不使用任何东西与机器进行有意义的交互成为可能。语音消除了复杂控制的需要，这种控制使高技能的 0.1%和世界其他人口之间的鸿沟永久化。
解决方案 API 的出现及其与语音技术的融合使能够使用最先进人工智能的人数从 2020 年的几百万人增加到 2030 年的几亿人。一个前所未有的科学发现、创新和人类创造力的时代开始了。
自动化研究人员及其他
2030 年，离真正的自动化研究者还有一段路要走。人类研究人员相信，根据我们今天所知道的一切，不出五到十年，基于机器智能的系统就会让 21 世纪初的数据科学家角色变得多余。未来的路线图现在还包括一个自动化研究人员的伪自主版本。
自动化研究人员是伪自主研究系统的先驱，伪自主研究系统不仅能够测试假设，还能够获取已执行研究的结果，并基于发现制定新的假设。这意味着该系统能够无止境地横向和纵向探索研究主题。虽然自主系统的前提很简单——系统的输出需要是同一系统可接受的输入——但在自主研究系统在回答人类最紧迫的问题方面发挥重要作用之前，仍需要做很多工作。
最终，自主研究系统将能够发现全新的科学领域。没有人能够准确地说出发展需要多长时间才能达到这一点。一旦与假设测试相关的流程变得成熟，假设公式的工作无疑会加速，就像我们看到的第一个解决方案 API和第二个*问题 API 一样。*至少在 2032 年之前，我们的研究一直专注于系统从文献综述或定量数据分析中形成有意义的定性见解的能力。
一旦机器能够形成定性的见解，扩展基于可用答案形成新问题的能力——包括以前从未问过的问题——将只是一个时间问题。
点击了解更多关于 autonomi的信息。
点击此处，了解更多与人工智能相关的系统性风险。
如果你♥了这篇文章，请分享它。
如何建立一个自动化的股票新闻收集器
一步一步打造自动化机器！
使用 Python 摆脱无聊的东西(第 3 部分)
你厌倦了重复做同样的事情吗？
感觉你的生活只是一遍又一遍地做着同样的事情？
欢迎来到使用 Python 系列摆脱无聊的东西！请随意访问这个链接，你将能够看到这个正在进行的系列中的所有故事。
*如果您想申请任何网页抓取服务，请随时通过此链接告诉我。😃
要不，我们开始吧！
我将用一个案例来说明。在本案例研究中，我们需要从 SGX(新加坡证券交易所)网站下载文件，并将它们上传到指定的 google drive 文件夹中。
这是我将要分享的议程:
第 1 部分 —从 SGX 获取所有 PDF 文件的链接
第 2 部分—从上述提取的链接下载所有 PDF 文件
第 3 部分—将文件上传到 Google Drive
希望你会喜欢这个系列，让我们把手弄脏。
第一部分 —从 SGX 获取所有 PDF 文件的链接
快速浏览 SGX 网站
让我们看看显示公司新闻(链接)的 SGX 主页，如下面的快照 1 所示:
如果您点击标题列中的每个元素，您将被定向到显示相应新闻的详细信息的页面。
在该页面中，您可能会在页面底部找到一个链接来下载 pdf 格式的指定报告(以紫色框突出显示)，如下面的快照 2 所示。
所以，我们今天的目标是下载所有最新的 pdf 文件并上传到 google drive。
开始刮
让我们浏览到 SGX 公司公告页面，查看该页面。如果你仍然不确定如何检查一个 html 页面，请参考这个链接以获得更详细的说明。
Snapshot 3
经过仔细检查，我们可以看到所有的新闻数据都是通过 api 调用获得的"？periodstart=…”(如快照 3 中突出显示的紫色框所示)。
在 inspect 面板的紫色框中，有一个我用黄色突出显示的框。从那里你将能够找到我们首先需要抓取的 url ，因为每个 url 都将引导我们到显示相应公司新闻的页面(这些页面的一个例子是 snapshot2)。
Snapshot 4
Snapshot 5
参考快照 4 中的紫色方框，API 的基础 url 是https://api.sgx.com/announcements/v1.0/？，之后呢？将是查询字符串参数。
什么是查询字符串参数？你可以把它看作是你需要添加到“？”后面的 url 的扩展查询满足条件的数据。我们这里以 2014 08 09 _ 16000(period start)为例。
20140809_16000 可以看成 date + ‘’ + 16000，意思是我们可以把它改成我们需要的日期。反之亦然，对于 periodend ，可以查看为 date + '’ + 155959。
例如，您想只抓取 2019-01-01 到 2019-02-01 的新闻，您可以将周期开始日期更改为 20190101，将周期结束日期更改为 20190201。
上面的代码首先将查询的开始日期初始化为今天的前一天，将查询的结束日期初始化为今天。通过将它们附加到 base_url，我们可以获得今天的公司公告。注意，我们将收到的数据是 JSON 格式的。因此，通过将 JSON 作为参数直接传递给pd.DataFrame()，我们可以直接将数据从 JSON 格式转换成 pandas dataframe。接下来，过滤 dataframe，使其只包含我们感兴趣的股票的新闻，在我们的例子中，它是“LODHA DEVELOPERS INTERNATIONAL LIMITED”。
第 2 部分— 从上面提取的链接下载所有 PDF 文件
在得到多个公司公告链接后，我们就该下载所有需要的 pdf 文件了。
通过查看详细新闻信息页面，您会发现附件链接是在以下位置捕获的:
节点:a
属性:href
因此，通过使用 parser BeautifulSoup 并获取a标签的属性href中的值，您将能够获得 pdf 的链接。现在，要在指定的 URL 上下载 pdf 文件，我们只需要获取响应的内容，并将其输出到 pdf 格式的文件中。
*注意wb的用法，因为我们将获得的 URL 上的 pdf 内容是二进制格式的，我们需要让 Python 知道我们要将二进制内容写入输出文件。此外，确保你的文件名有。pdf 作为扩展。
基于以上要点， def get_pdf() 函数负责将所有相应的链接下载到我的默认文件夹数据。简而言之，我将遍历熊猫数据帧，检索所有链接，然后下载我们需要的所有 pdf 文件。
在这里跟进，恭喜你！你只剩下最后一步了！
第 3 部分— 将文件上传到 Google Drive
首先，你应该通过这个链接获得你的 google drive 证书。
然后，将凭证文件名保存为 client_secret.json ，并将其放在 python 文件的同一个目录中。
接下来，复制上面的脚本，将current _ Google _ folder _ id填入你的目标文件夹 id。该脚本会将您的令牌保存到外部文件****mycreds . txt中，这样您就不需要每次运行该脚本时都在 google drive 上登录您的帐户。
上面的要点是首先获取当前 google 文件夹中的所有文件夹名称。然后，它将检查指定的股票名称的文件夹是否已经存在，如果不存在，它将创建一个文件夹，并使用股票名称命名。之后，将所有文件上传到与指定股票名称同名的文件夹中。
最后，它将删除数据目录中的所有文件，以保持本地数据文件夹的干净。
终于完成了！如果你从一开始就遵循所有的步骤，你将能够看到你的文件被上传到你的目标谷歌文件夹！
最终想法
非常感谢你一直读到故事的结尾，我真的希望你能从你的业务、日常工作等中受益。自动化对于释放你的时间非常重要，这样你就可以专注于完成其他工作。
欢迎在下面留下你感兴趣的话题的评论。我将在未来发布更多关于我的经历和项目的帖子。
关于作者
低魏宏是 Shopee 的数据科学家。他的经验更多地涉及抓取网站，创建数据管道，以及实施机器学习模型来解决业务问题。
他提供爬行服务，能够为你提供你所需要的准确和干净的数据。你可以访问这个网站查看他的作品集，也可以联系他获取抓取服务。
在媒体上阅读低纬鸿的作品。数据科学家|网络搜集服务:http://datainfinite.mystrikingly.com/…
medium.com](https://medium.com/@lowweihong?source=post_page-----b84d1e9ea595----------------------)**
自动估价模型——它如何在房地产行业发挥作用？
如果你要投资房地产，你会考虑的最重要的因素是什么？会不会是建筑的年龄，它的位置，或者它以前有多少业主？
虽然上述所有因素对你来说肯定很重要(尽管程度不同)，但有一个普遍因素要么会成为交易的破坏者，要么会让你想要全押。
你已经猜到了——价格。
我们都大致了解是什么影响了房产的市场价值，对吗？那么，它实际上是如何计算的呢？
在这个时代，每个房产估价还需要“人的因素”吗——那么，一个在现实生活中考察房产的评估师？
在下面的帖子中，我们将了解什么是自动化估价模型，它是如何计算的，以及哪些行业在日常工作中应用 AVM。
什么是自动估价模型？
最简单地说，自动估价模型(也称为 AVM )是一个用来描述利用数学模型提供房地产价值的服务的术语。它最大限度地减少了亲自检查和审视市场上每一处房产的需要——就像过去(不久前)那样。
The real estate industry is a huge collection of data. AVM allows to make decisions faster and gives a better assessment of the situation.
AVM 利用所有类型的数据，如房龄和状况(我们将在本文中进一步讨论)，并在几秒钟内生成报告。
现在，让我们仔细看看反车辆地雷考虑的是什么，它们能做什么，不能做什么。
自动估价模型的类型
目前市场上使用的反车辆地雷大致有 4 种。这些被称为:享乐、评税、价格指数和综合估价。
出于本文的考虑，让我们讨论后者(组合模型),因为它是最全面的，并且包含了上面的所有模型甚至更多。
复杂估价——计算方式
当一个复杂估价被用来提供一个财产的市场价格时，该软件检查:
- 最近的房契交易(房产已售出多少次)
- 该房产的最新价格(例如，当前所有者购买该房产的价格，以及考虑到自购买以来发生的所有因素，该房产可能获得或损失的金额)
- 类似物业的价格(hedonic 模型，即出售的类似物业的比较分析)
- 任何以前的估价——最重要的是，如果可能的话，税务评估员的估价指示。
正如您所看到的，这种类型的自动估价模型提供了可以由软件处理的所有客观数据的整体概述。
那么，这类报告的潜在局限性或矛盾之处呢？
自动估价模型—局限性
正如你可能已经猜到的，尽管近几十年来技术不断进步，但仍然有相当一部分是软件或人工智能无法做到的。AVM 不能考虑对人类评估者来说显而易见的事情。
例如，AVM 可能会根据一处房产的位置和之前的所有权来给它定价，但它本身并不知道任何潜在的细微差别，比如室内设计使用的材料质量差。
简而言之，在纸上(或屏幕上)好看的东西对人眼来说不一定是一样的。
现在，理解美学并不是 AVM 可能无法实现的唯一领域。
如果一个自动报告不能进行比较分析，也就是说，如果一个房产以前从未被出售过，那么它可能很难反映出房产的价格。
同样，如果一处房产是独一无二的，并且在记录中没有发现类似的情况，那么 AVM 就无法反映准确的价格。
在这种情况下，专业估价人员仍需要对房产进行实地考察或自己进行调查，以提供定制价格。
现在，考虑到以上所有问题，让我们讨论一下哪些行业和职业可以从 AVMs 中受益最多，为什么。
AVMs——行业细分
投资专业人士
一个非常突出的群体是投资公司或投资顾问，他们大规模使用 AVM。首先，他们应用 AVM 报告快速评估市场上的一处房产是否划算，或者仅仅是一个好的投资，考虑到其他因素，如类似房产的投资回报率。
另一方面，投资顾问可以利用 AVM 生成客户可能感兴趣的房产清单。在这个阶段不需要聘请房地产专家，他们可以提供一个更大的投资场所列表，而不是每个都必须亲自考察。
现在，正如你可能已经猜到的那样，AVM 对那些以出售房产为生的人来说同样具有吸引力。
房地产代理/房地产经纪人
当你求助于一家房地产中介来帮你找到梦想中的家时，你期望得到什么？当然是一份不错的潜在地点清单！
为了保持竞争力，房地产经纪人需要一种快速评估待售房产的方法。虽然他们可能仍然会在过程的后期使用评估器，但这可以最大限度地减少向列表添加位置之前的初始工作。更不用说，它给了那些有兴趣通过房地产代理出售一个地方的人一个真实的估价，他们实际上可以期望卖多少钱。
下一组？
贷款机构
类似于房地产机构，这些机构需要 AVM 计算当有人想采取抵押贷款对自己的财产。这是有效风险管理的关键——银行等贷款机构需要一种方法来快速验证他们的潜在客户是否有能力支持他们的贷款。
最后，但同样重要的是…
估价人/评估人
虽然反车辆地雷部分地从评估人员手中夺走了传统的任务，但现在它们也能使他们的工作更容易、更有效。如前所述，贷款机构、投资者和业主仍然聘请评估师来提供一个现实的价格，这个价格包含了即使是最先进的技术也隐藏不了的东西。
最后的想法
AVM 是一项非常有价值的技术，它改变了更多的行业，而不仅仅是与房地产交易直接相关的行业。鉴于其为房地产相关市场带来的时间节约和成本优化，可以预计在未来许多年内，资产负债管理系统仍将是不可或缺的。
在 Twitter 中自动收集# RickyRenuncia 下的图片
使用 Python 和 Twitter API
Source: https://cnnespanol.cnn.com/gallery/fotos-las-mejores-imagenes-de-las-protestas-en-puerto-rico/
示威活动于 2019 年 7 月 13 日在波多黎各开始，当时披露了 889 页的电报聊天记录(昵称为 Telegramgate)，波多黎各总督 Ricardo Roselló与其他 11 名成员(当时包括前任和现任政府雇员)一起参加了这次聊天。示威背后的目的是让州长辞职。
7 月 13 日至 7 月 24 日，波多黎各的别霍圣胡安和其他城市(以及波多黎各以外的地方)发生了各种抗议活动。7 月 24 日，晚上 11 点多，这位波多黎各总督终于向公众让步，辞去了他的职务。他的辞职将于 2019 年 8 月 2 日生效。
现代波多黎各历史上最大的游行之一发生在 2019 年 7 月 22 日星期一。游行发生在美洲快车上。据估计，超过 50 万人参加了游行。
在游行的照片上统计参加人数可能是有用的。为了做到这一点，我们必须首先检索游行的照片。这个博客将专注于照片检索(数据收集)。我们将从 Twitter 上检索一些游行的照片，获取标签为# RickyRenuncia(翻译为“Ricky 辞职”)的推文，这些推文发布于 7 月 20 日至 7 月 23 日(7 月 22 日是最大的游行日)。我们选择只使用# RickyRenuncia 这个标签，因为它是最常用的(有一段时间它在 Twitter 上很流行)。
在后面的博客中，我们将重点讨论在拥挤的游行照片中计算人数的问题。
这里讨论的代码可以在 GitHub 的我的账户meramos下获得，在一个名为RickyRenuncia_Protests的存储库中，在 Jupyter 的名为get_photos.ipynb的笔记本中。
[## mera mos/Ricky renucia _ 抗议
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/meramos/RickyRenuncia_Protests)
注意:本文解释的代码可以用来搜索 Twitter 上的任何其他标签。
如果你想了解更多关于 Telegramgate 文件的信息，这份文件激起了人们对州长及其同事的愤怒，请阅读我的博客“用 Python 分析 Telegramgate”:
处理 889 页聊天信息
medium.com](https://medium.com/@mariaeramosmorales/telegramgate-analysis-in-python-457d4a36164e)
开发要求
要运行代码，您需要在计算机上安装 Python 3。你还需要一个 Twitter 开发者账户，你可以在这里创建。要创建 Twitter 开发者帐户，您需要一个 Twitter 帐户。
这些是您将使用的库:
- python-Twitter:用于轻松连接 Twitter API，搜索包含# RickyRenuncia 标签的推文。通过运行
pip3 install python-twitter进行安装。 - URL lib . request:用于打开和读取 URL 的内容。Python 默认有这个库。
- os :用于操作系统相关功能。我们用它来确保我们不会用同一个 Twitter ID 多次保存图片。Python 默认有。
- 熊猫 :用于创建一个包含已下载图像信息的表格，并从中创建一个 CSV 文件。
连接到 Twitter API
在您的 Twitter 开发者帐户上搜索您的凭证。您需要以下内容:
- 消费者密钥
- 消费者秘密
- 访问令牌
- 访问令牌秘密
要获取这些值，您必须在您的 Twitter 开发人员帐户下创建一个应用程序，然后访问它。要访问您现有的应用程序，首先点击 Twitter 开发者页面最右侧的用户名右侧的向下箭头，然后点击标题为“应用程序”的选项。进入后，点击感兴趣的应用程序上的“详细信息”按钮。然后点击“密钥和令牌”。在“消费者 API”下，您将找到消费者密钥和消费者密码，在“访问令牌和访问令牌密码”下，您将找到访问令牌和访问令牌密码。
如果您将代码保存在版本控制系统(VCS)中，如 GitHub 或 BitBucket，我建议您将 API 凭证保存在与代码不同的文件中，并将该文件添加到。gitignore 文件，这样您就不会意外地将您的凭证推送到您的存储库中。
对于包含 Twitter API 凭证的配置文件，我们将遵循以下格式。该脚本将有一个名为credentials的字典变量，包含键consumer_key、consumer_secret、access_token和access_token_secret。我们将文件命名为config.py，但是它可以有任何其他名称。
Set Twitter API credentials.
要使用库python-twitter和存储在config.py中的凭证连接到 Twitter API，请运行以下命令:
Connect to the Twitter API.
构建搜索查询
您希望使用标准搜索 API ，它返回与指定查询匹配的相关 Tweets 的集合。然后你需要定义你想要搜索什么。
我们想要标签为“rickyrenuncia”的推文。我们想要流行和非流行的推文，我们希望将这些推文限制在 7 月 20 日至 7 月 23 日。我们希望获得 API 每次调用允许的最大 tweets 数，即 100。
调用端点时，您可以指定各种参数。下面是我们使用的查询参数:
q:必选。需要 UTF 8，URL 编码的搜索查询。最多允许 500 个字符。可以包含运算符。我们将其设置为rickyrenuncia。result_type: 可选。您希望收到什么类型的搜索结果。默认值为mixed。有效值为:mixed、recent、popular。mixed在响应中包括流行和实时结果。recent仅包括最近的结果。popular仅包括最受欢迎的结果。我们将其设置为mixed。include_entities: 可选。是否包括写推文的人的用户名。默认值为false。我们将其设置为true。with_twitter_user_id: 可选。是否包括写 tweet 的用户的 Twitter ID。默认值为false。我们将其设置为true。since: 可选。返回给定日期后创建的推文。接受的日期格式为YYYY-MM-DD。我们将其设置为2019-07-20。until: 可选。返回给定日期之前创建的推文。接受的日期格式为YYYY-MM-DD。我们将其设置为2019–07–23。【 重要 :搜索索引有 7 天限制！超过一周的日期将找不到推文。这个问题有一些解决方法，在这篇博客中没有讨论。]count: 可选。每页返回的推文数量。最大允许值为 100。默认值为 15。我们把它设置为 100。
Define query parameters.
Build query.
我们得到的查询是:
q=rickyrenuncia&result_type=mixed&include_entities=true&with_twitter_user_id=true&since=2019–07–20&until=2019–07–23&count=100
运行搜索查询
要运行搜索查询，请运行以下命令:
How to make a call to the search endpoint of the Twitter API.
搜索端点最多只能提供 100 个结果。为了获得更多，我们必须用不同的max_id值多次调用搜索端点。根据文档:
为了正确使用 max_id，应用程序对时间轴端点的第一个请求应该只指定一个计数。在处理此响应和后续响应时，请跟踪收到的最低 ID。这个 id 应该作为 max_id 参数的值传递给下一个请求，该请求将只返回 ID 小于或等于 max_id 参数值的 Tweets。注意，因为 max_id 参数是包含性的，所以实际上将再次返回具有匹配 id 的 Tweet。
正如文档所述，为了检索更多的 tweet，我们需要将max_id指定为返回的最小 tweet ID，并继续重复这一过程，直到我们得到所有想要的 tweet。
我们决定在 Twitter API 允许的情况下尽可能多地进行连续调用。我们发现，我们可以一口气打 180 个背靠背的电话，检索 18000 条推文。随意试验不同的迭代次数。
在下面的代码中，我们初始化了两个空数组，一个名为all_results，我们将在其中存储所有 API 搜索结果，另一个名为IDs，我们将在其中存储 tweets 的 ID，以便跟踪在后续调用中指定max_id的最小 ID。IDs在每个循环中被重新分配。我们将max_id初始化为None，因为在第一个 API 调用中，我们不应该为max_id指定值。第一次迭代后，将使用列表IDs中存在的最小 ID 定义max_id，并且将扩展query字符串以包含max_id参数。在以后的迭代中，包含max_id参数的query字符串部分被替换为新的max_id值。
运行循环后，我们将有 18000 条推文存储在all_results中。大约有 179 条 tweets 将被重复，因为按照文档中的说明，max_id查询参数是包含性的。我们选择保持重复。
Make 180 calls to the search endpoint for a total of 18000 results.
从 Tweets 下载媒体
现在下载每条读入的推文中的媒体(照片)。
all_results中的每个元素都是python-twitter包中Status类的一个对象。Status类表示 twitter API 使用的状态结构。它有各种属性，包含关于 Tweet 的信息。我们只使用media属性来获取 tweet 下图片的 URL。
media属性是来自python-twitter包的Media类对象的列表。Media类表示 tweet 的媒体组件。它包含与媒体相关的各种属性。我们使用属性id和media_url。id是图片在 Twitter 中的 ID，media_url是图片/视频在 tweet 中的 URL。我们使用 id 为我们下载的媒体分配名称，以便跟踪图像的来源。
在运行代码的文件夹中创建一个名为downloaded_media的文件夹，并运行以下代码:
Function for creating URL of tweet where downloaded image comes from.
Download images and keep track of image origins by saving image ID, image URL, and tweet URL.
downloaded_img_ids包含文件夹downloaded_media中的文件名。我们用这个来确保我们不会重新下载图片，因为一些读入的推文可能是分享我们已经下载的媒体的转发。
为了创建一个包含图像来源信息(图像 ID、图像 URL、tweet URL)的 CSV 文件，我们使用 Pandas 库从image_origins字典中创建一个 dataframe，删除包含重复图像 ID 的行(如果有的话),并从中创建一个 CSV 文件。
Create CSV with information on the images’ origins.
生成的 CSV 文件将作为一个名为image_origins.csv的文件保存在您运行代码的位置。
结果
图像现在将出现在您运行代码的文件夹中的download_media文件夹中。我们下载了 895 张图片。
Subset of images downloaded from the Tweets the Search API returned on July 25.
我们下载的图片可以在这里标题为downloaded_media的文件夹下找到。一个 CSV 和一个包含图像来源信息的电子表格(一列是与文件名相关的图像 ID，一列是图像 URL，一列是 tweet URL)也显示在那里，标题为image_origins。
结论
在本文中，我们将展示如何在特定时间范围内检索特定标签下的推文，以及如何下载这些推文下的媒体文件。我们提供了一个链接，链接到 Google Drive 中的一个文件夹，其中包含一个包含下载图像的文件夹和一个包含图像来源信息的电子表格。
不幸的是，我们遇到了一个限制，Twitter API 不允许检索调用端点超过 7 天的帖子。这使得这里讨论的代码的结果不可再现(代码运行并工作，但它不会返回指定时间范围内的图像)。然而，还有其他方法可以检索历史推文。GitHub 中有解决这个问题的库。以下是其中一个存储库:
[## PJHRobles/Twitter-Get-Old-Tweets-Scraper
Twitter 的 API 不再允许使用应用程序检索过去 7 天的推文。一些第三方应用程序可用…
github.com](https://github.com/PJHRobles/Twitter-Get-Old-Tweets-Scraper)
在未来的博客中，我们可能会讨论如何使用这些存储库之一来检索历史 Twitter 数据。
现在我们有了来自 Twitter 上# RickyRenuncia 标签的照片，以及抗议日期的子集，我们可以精心挑选人群的图像，并使用它们来计算其中的人数。
参考
- 新直径:克罗诺吉亚德拉卡达德罗塞洛
- Python-Twitter 文档
- 面向开发者的 Twitter:搜索 Tweets /标准搜索 API
- 面向开发者的 Twitter:获取 Tweet 时间轴
- Stackoverflow: twitter api 计数超过 100，使用 twitter 搜索 api
有毒问题的自动检测
When you are trying to remove toxic questions and comments from a website (“Night cleaning”, photo by Yuri Shchennikov)
Quora 是一个让人们互相学习的平台。在 Quora 上，人们可以提出问题，并与贡献独特见解和权威观点的其他人交流。几个月前，Quora 在 Kaggle 上组织了一场比赛，名为 Quora 不真诚问题分类，旨在解决当今任何主要网站都存在的一个问题——如何处理有毒和分裂性内容。一个关键的挑战是剔除不真诚的问题——那些基于错误前提的问题，或者由用户提出的问题，这些用户宁愿发表声明，而不是寻找有用的答案。
这篇文章将描述我解决这个问题的方法，它帮助我进入了前 3%(在 4000 名参与者中排名第 85 位，个人银牌)。
问题公式化
数据集由 130 万个问题组成，目标是将问题标记为有毒或无毒(二元分类任务)。一个不真诚的问题被定义为一个旨在陈述而不是寻找有用答案的问题。以下迹象可能被用来发现一个不真诚的问题(完整定义):
- 有着非中性的语气
- 是贬低或煽动性的
- 不是基于现实的
- 使用性内容(乱伦，兽交，恋童癖)来寻求震撼，而不是寻求真正的答案
问题示例:
Non-toxic questions:
1\. What are the best rental property calculators?
2\. Apart from wealth, fame, and their tragic ends, what did Anthony Bourdain and Kate Spade have in common that might provide some insight into their choice to take their own lives?
3\. How do you find your true purpose or mission in life?
4\. What is the relation between space and time if they are connected? Are they converting continuously in each other?
5\. Is there an underlying message that can be read into the many multilateral agreement exits of the Trump administration during its first year and a half?____________________________________________________________________Toxic questions:
1\. Lol no disrespect but I think you are ducking smart?
2\. Are Denmark and England destroyed by Muslim immigrants?
3\. How am I supposed to get a girlfriend if every woman thinks every man is a rapist?
4\. How many black friends does a white person need to make what they say 'not racist' on this basis?
5\. Are Russian women more beautiful than Ukrainian women?
比赛使用F1-score指标，计算 56k(公开)和 376k(私人)未公开试题。Quora 的虚假问题分类是只在内核中进行的比赛，所以你不用做预测，而是提交代码，然后在 Kaggle 平台上运行。主办方对两个阶段都设定了内存和时间限制:6 / 2 小时(CPU / CPU+GPU 使用量)。
还有，主办方决定禁止使用任何外部数据(反正也没阻止某人)，除了几个预先训练好的单词嵌入:Google news-vectors-negative 300、 glove.840B.300d 、 paragram_300 sl999 、 wiki-news-300d-1M 。
我们真的需要它吗？
在这场比赛中，我们必须发现有毒的问题。让我们假设这是开始竞争的唯一原因(其他原因可能包括雇用专业的数据科学家、产生宣传或者将生产中的模型分数与竞争中的最高分数进行比较)。在数据驱动项目的准备过程中，最重要但最少被问到的问题可能是:我们真的需要它吗？我们要解决什么问题？
有害行为对 Quora 社区有害。这可能会吓跑一些用户，因为他们觉得与世界分享他们的知识不安全。我们希望我们的用户自由地表达他们的想法，而不用担心被套牢。我们可以通过检测有毒问题并删除它们，或者使它们仅对问题的作者可见来实现这一点— hellban ( 解决方案)。为了检测有毒问题，我们可能会使用人工预审核(由 Quora 版主或机械土耳其人)，但这需要时间来处理所有问题，版主可能会被 Quora 上的大量问题淹没。因此，我们希望通过使用数据驱动的方法来自动化这一过程:在发布问题之前，它将由模型进行检查，这是我们在本次比赛中必须提出的。
这解决了最初的问题吗？我们可以从一个正在努力解决类似问题的领域——视频游戏行业——中吸取经验。据《电子游戏公司能否驯服毒害行为？视频游戏中的大多数有毒评论来自“普通人，他们只是过了糟糕的一天”，禁止所有有毒玩家不会产生任何戏剧性的变化:
《常识》认为，互联网上的大部分残忍行为来自于一小部分网民——巨魔。事实上，林的团队发现，只有大约 1%的球员一直是有毒的。但事实证明，这些巨魔只产生了英雄联盟中约 5%的毒性。“绝大多数是普通人度过了糟糕的一天，”林说。
这意味着，即使 Riot 禁止了所有毒性最强的玩家，也不会有太大的影响。为了减少大多数玩家经历的不良行为，公司必须改变玩家的行为方式。
在我看来，删除有毒评论不会解决问题，但会减少它对社区的影响。它可以被整合到反巨魔战略中，但这只是解决这个问题的一揽子计划的一部分。无论如何，比赛的总体想法对我来说似乎是可行的和重要的，所以我决定参加。
最终解决方案的主要部分
实验测试
在整个比赛中，我在本地(在我的电脑上)和 Kaggle 内核中测试了我的管道。它允许我(1)同时运行更多的实验，(2)确保我的管道符合第二阶段的时间/内存需求。我跟踪了每个实验的结果(时间、验证分数、公共排行榜分数、评论和发现)，然后把它们放到 excel 文件中。
验证策略
我认为这场比赛最重要的部分是不要相信公共排行榜。正如前面提到的，公共排行榜是根据 56k 个问题计算的，这大约是培训部分问题数量的 4%。这是一个非常小的部分，它可能只用于确保您没有在代码中犯任何严重的错误，而不是用于分数检查。
我决定完全信任我的验证，并使用 StratifiedKFold (K=5)策略进行局部验证和参数选择。对于最终提交，我对一次提交使用了相同的策略，对另一次使用了训练验证分割(90/10%)(允许两次最终提交)。
预处理
我的预处理管道由几个步骤组成:
- 干净的数学公式。训练数据集中大约 2%的问题带有“数学”标签。里面的公式没有包含有用的信息，也没有有害的评论，但它极大地增加了问题的长度，所以我决定用单词“数学”代替这些公式。虽然，聪明的巨魔可以利用它，开始在数学公式里侮辱人。
**[math] 2 + 2 = 4 [\math] ->* math*
- 在单词和标点符号之间添加一个空格。事实证明，这是比去掉标点符号更好的策略:
*"Wait... What is the relation between space and time if they are connected? Are they converting continuously in each other?" -> "Wait . . . What is the relation between space and time if they are connected ? Are they converting continuously in each other ?"*
- 如果字典中没有该单词，请尝试将它的首字母小写/大写/大写，然后再试一次。这一简单而有效的举措逐渐减少了“新”单词(即不在 w2v 词汇表中的单词)的数量。比赛结束后，我意识到词干化或词汇化也可能减少缺席单词的数量。
*for word, i in tqdm(word_index.items()):
embedding_vector = embeddings_index.get(word)
# 'ABcd' → 'abcd'
if embedding_vector is None:
embedding_vector = embeddings_index.get(word.lower())
# 'denis' -> 'Denis'
if embedding_vector is None:
embedding_vector = embeddings_index.get(word.capitalize())
# 'usa' -> 'USA'
if embedding_vector is None:
embedding_vector = embeddings_index.get(word.upper())
# deling with numbers in Google News embedding
if word.isdigit() and (embedding_vector is None):
temp_word = len(word) * '#'
embedding_vector = embeddings_index.get(temp_word)
# '1123336548956552515151515151544444444' -> 'number'
if word.isdigit() and (embedding_vector is None):
embedding_vector = embeddings_index.get('number')
if embedding_vector is not None:
embedding_matrix.append(embedding_vector)
in_vocab += 1
else:
non_in_vocab += 1
non_vocab.append(word)
embedding_matrix.append(mean_vector)*
模型和嵌入
我在这场比赛中测试了 CNN 和 LSTM 模型，然而，最好的是下面的 LSTM:
*def get_model(embedding_matrix, nb_words, embedding_size=607):
inp = Input(shape=(max_length,))
x = Embedding(nb_words, embedding_size, weights= [embedding_matrix], trainable=False)(inp)
x = SpatialDropout1D(0.3)(x)
x1 = Bidirectional(CuDNNLSTM(256, return_sequences=True))(x)
x2 = Bidirectional(CuDNNGRU(128, return_sequences=True))(x1)
max_pool1 = GlobalMaxPooling1D()(x1)
max_pool2 = GlobalMaxPooling1D()(x2)
conc = Concatenate()([max_pool1, max_pool2])
predictions = Dense(1, activation='sigmoid')(conc)
model = Model(inputs=inp, outputs=predictions)
adam = optimizers.Adam(lr=learning_rate)
model.compile(optimizer=adam, loss='binary_crossentropy')
return model*
我使用了 google news 和 glove embedding 的串联，并根据句子中的相对位置(顺序号)、问题中的相对位置(顺序号)、 is_upper 、 is_lower 、 is_ number 、is _ 标点符号、单词中大写字母的含义(“单词”→ 1.0、“单词”→ 0.25)、单词在训练数据集中的出现频率，为每个单词的表示添加了额外的功能。
快照集合
快照集合是之前在快照集合:训练 1，免费获得 M中描述的 Kaggle 比赛中常用的技术。其背后的思想非常简单:我们用循环学习率训练单个模型，在每个循环结束时保存模型的权重(一个循环的结束通常处于局部最小值)。最终我们会得到几个模型而不是一个。对集合的预测进行平均会给你一个比单一模型更好的分数。
During training, we are converging to and escaping from multiple local minima. A snapshot is taken in each local minimum
伪标记
伪标注的思想是增加模型训练的可用数据量。在 Kaggle 竞赛中是一种常见的方法，但遗憾的是，在业界并没有那么常用(下面是一些关于这个话题的论文:用自举，伪标签:深度神经网络的简单高效的半监督学习方法)。现在，有几种方法可以用于伪标记:
- 1.添加训练数据的最有把握的例子(置信度≥水平，水平= 0.9 的例子)。我们不应选择最高 N1 %和最低 N0 %的概率并将它们添加到训练数据集(由于类别不平衡)。相反，我们必须确定最佳阈值，并选择带有正面和负面标签的最有把握的示例。在神经网络训练的几个时期中遵循这种方法，我添加了大约 45k 个负样本和 100 个正样本。**
- 添加带有伪标签的完整测试数据，但根据其置信度为每个示例分配一个权重。我尝试了几种权函数，但我发现线性权函数是这项任务的最佳选择。
Assigning weights to pseudo labels (first 1000 data points in the test set). The more confident our predictions are — the bigger weight we assign during training
最佳阈值选择
这个比赛的度量标准是 F1 分数，也就是说我们要提交类(0/1，无毒/有毒)。模型的输出是概率，所以我们需要选择合适的阈值来最大化得分。有许多方法可以做到这一点:
- 训练前选择阈值。我认为这种方式会导致非最优阈值，得分会更低。我已经测试过了，但是从来没有在最终提交中使用过。虽然，竞赛的获胜者使用了这种方法的变体。
- 拟合模型，对训练部分进行预测，选择阈值优化训练部分的得分。直接超负荷。已测试，但未在最终提交中使用。
- 拟合模型，对训练部分进行预测，选择阈值优化训练部分的得分。直接超负荷。我已经测试过了，但是从来没有在最终提交中使用过。
- 拟合模型，对验证部分进行预测，选择阈值优化验证部分的得分。在我的管道中，验证部分用于选择最佳的历元数(这是验证数据的一个轻微的过度拟合)和优化神经网络的超参数(一个主要的过度拟合)。对已经“使用”的数据“按原样”选择阈值不是一个好主意。我们可能会完全过度拟合，在看不见的数据上得低分。相反，我决定在验证部分的子集上选择一个阈值，重复几次，然后汇总结果(这个想法是由统计学中的子采样思想激发的)。它让我在这场比赛和其他一些我必须选择门槛的比赛中取得了好成绩。
- 作出 out of fold (OOF，意味着为每个 fold 建立一个单独的模型)预测，找到一个阈值。这是一个好方法，但有两个问题:(1)我们没有这么多时间来做 OOF 预测，因为我们想尽可能多地拟合不同的模型( CNN/LSTM )。(2)这可能是一种情况，我们的验证分裂是有偏见的，我们将得到我们的预测“转移”。阈值搜索非常敏感，我们不会得到最优解。然而，我使用这种方法对每一次折叠的概率进行排序，以减少“转变”的影响。它对我来说已经足够好了。
什么没有起作用
在比赛期间，我测试了大量的想法，但只有一小部分被用在了最终的流程中。在这一节中，我将概述一些对我无效的技巧。
A lot of stuff did not work during this competition (picture by Schmitz)
数据扩充和测试时间扩充(TTA)
想法是增加训练数据集。有几种方法可以做到这一点，最常用的是重复翻译(将英语句子翻译成法语，然后再翻译成英语)，以及同义词。重复翻译不是一个选项，因为在第二阶段互联网接入不可用，所以我决定专注于同义词。我测试了两种方法:
- 将句子拆分成单词，以预定义的概率通过 w2v 嵌入将一个单词替换为最接近的单词。重复几次得到不同的句子。
- 给句子中的随机单词加上随机噪声。
这两种方法都不太奏效。还有，我试着把问题组合在一起，即无毒+有毒=有毒。也没用。
**Non toxic: Is there an underlying message that can be read into the many multilateral agreement exits of the Trump administration during its first year and a half?Toxic: Lol no disrespect but I think you are ducking smart?____________________________________________________________________New toxic:
Is there an underlying message that can be read into the many multilateral agreement exits of the Trump administration during its first year and a half? Lol no disrespect but I think you are ducking smart?**
附加句子特征
我根据这个句子尝试了不同的功能，但是它们没有多大帮助。他们中的一些人降低了分数，所以我决定不将他们纳入最终模型。以下是我测试过的一些功能:字数、上位字数、数字个数、数字总和/均值/最大/最小值、标点符号个数、词频总和/均值/最大/最小值、一个问题中的句子个数、起始和结束字符等。
神经网络内层输出
想法很简单:我们获取网络的连接层的输出，并在其上训练基于树的模型。我在最近的比赛中测试了这种方法，它总是增加最终合奏的分数。它允许我们使用不同的模型(神经网络和基于树的模型)进行混合，这将增加最终集成的分数。
但在这种情况下，这是一个非常微小的增加，特别是考虑到高输出维度所花费的时间(根据模型的不同，连接层~400 的维度)。
TSNE visualization of NN inner layer output of random 1000 questions in the validation dataset
自动微分，解释
计算机如何计算导数？
Title image: Source
通过梯度下降的过程，神经网络能够在每次训练中逐渐提高精确度。在梯度下降中，我们的目标是通过调整权重和偏差来最小化损失(即模型有多不准确)。
正如在之前的系列文章中所解释的，通过找到损失函数的偏导数，我们知道我们必须调整多少(和在什么方向上)我们的权重和偏差来减少损失。在该系列中，我们手工计算了单神经元神经网络的导数均方误差损失函数。
然而，神经网络——计算机——是如何计算表达式的偏导数的呢？答案在于一个被称为自动微分的过程。让我用上一个系列中的成本函数来说明它，但是做了调整，使它是标量形式的。
Image 1: The cost function in scalar form
此外，由于自动微分只能计算表达式在某一点上的偏导数，所以我们必须为每个变量赋予初始值。我们假设:y = 5；w = 2；x = 1；并且 b=1。
我们来求函数的导数吧！
在我们开始推导这个表达式之前，必须把它转换成一个计算图形。一个计算图简单地将每个操作变成一个节点，并通过线将它们连接起来，称为边。我们的示例函数的计算图如下所示。
Figure 2: Computation graph for the scalar cost function
首先，让我们计算每个节点的值，从底部(输入变量)传播到顶部(输出函数)。这是我们得到的结果:
Figure 3: Values of each node
接下来，我们需要计算运算之间每个连接的偏导数，用边来表示。这些是每条边的偏角的计算:
Figure 4: Values of each edge
注意 max(0，x)分段函数的部分也是分段函数。该函数将所有负值转换为零，并保持所有正值不变。函数的部分(或者用图形表示，它的斜率)，应该在它的图上很清楚:
Figure 5: max(0, x) function. As seen, there is a slope of 1 when x>0, and a slope of 0 when x<0. The slope is undefined when x=0.
现在我们可以继续计算偏导数了！让我们找出相对于重量的偏导数。如图 6 所示，只有一条线将结果与权重联系起来。
Figure 6: The path that connects the function to the weights
现在我们简单地将这些边相乘:
Figure 7: Partial
这是我们的部分！
这整个过程可以自动完成，并允许计算机准确快速地计算函数值的偏导数。正是这个过程，让 AI 能够像今天这样高效。
如果你喜欢这篇文章，或者有任何问题或建议，欢迎在下面留下评论！
基于深度学习的车牌自动检测与识别
Photo by Evgeny Tchebotarev on Unsplash
简介
在现代世界的不同方面，信息技术的大规模集成已经导致将车辆视为信息系统中的概念资源。由于没有任何数据，自主信息系统没有任何意义，因此需要在现实和信息系统之间改革车辆信息。这可以通过人工代理或特殊的智能设备来实现，这些设备将允许在真实环境中通过车辆的牌照来识别车辆。在智能设备中，提到了车辆牌照的检测和识别系统。车牌检测和识别系统用于检测车牌，然后进行车牌识别，即从图像中提取文本，这一切都要归功于使用定位算法、分割车牌和字符识别的计算模块。车牌的检测和读取是一种智能系统，由于其在以下几个领域的潜在应用，所以它是相当重要的:
-
指挥力量:该系统用于检测被盗和被搜查车辆。将检测到的车牌与报告的车牌进行比较。
-
**停车管理:**汽车出入口的管理。
- **道路安全:**该系统用于检测超过一定速度的车牌，将车牌读取系统与道路雷达相结合，穿越野火…
我们的项目将分为 3 个步骤:
第一步:车牌检测
为了检测牌照，我们将使用 Yolo ( You Only Look One)基于卷积神经网络的深度学习对象检测架构。
这种架构是由约瑟夫·雷德蒙、阿里·法尔哈迪、罗斯·吉斯克和桑托什·迪夫瓦拉在 2015 年推出的第一版，以及后来的第 2 版和第 3 版。
Yolo v1:纸张链接。
Yolo v2:纸张链接。
Yolo v3:纸张链接。
Yolo 是一个端到端训练的单一网络，用于执行预测对象边界框和对象类的回归任务。
这个网络非常快，它以每秒 45 帧的速度实时处理图像。一个较小版本的网络，快速 YOLO，每秒处理惊人的 155 帧。
实施 YOLO V3:
首先，我们准备了一个由 700 张包含突尼斯牌照的汽车图像组成的数据集，对于每张图像，我们创建一个 xml 文件(之后改为文本文件，其中包含与 Darknet 配置文件输入兼容的坐标。Darknet:该项目用于使用一个名为 LabelImg 的桌面应用程序重新训练 YOLO 预训练模型。
# First download Darknet project
$ git clone [https://github.com/pjreddie/darknet.git](https://github.com/pjreddie/darknet.git)# in "darknet/Makefile" put affect 1 to OpenCV, CUDNN and GPU if you # want to train with you GPU then time thos two commands
$ cd darknet
$ make# Load convert.py to change labels (xml files) into the appropriate # format that darknet understand and past it under darknet/
[https://github.com/GuiltyNeuron/ANPR](https://github.com/GuiltyNeuron/ANPR)# Unzip the dataset
$ unzip dataset.zip# Create two folders, one for the images and the other for labels
$ mkdir darknet/images
$ mkdir darknet/labels# Convert labels format and create files with location of images
# for the test and the training
$ python convert.py# Create a folder under darknet/ that will contain your data
$ mkdir darknet/custom# Move files train.txt and test.txt that contains data path to
# custom folder
$ mv train.txt custom/
$ mv test.txt custom/# Create file to put licence plate class name "LP"
$ touch darknet/custom/classes.names
$ echo LP > classes.names# Create Backup folder to save weights
$ mkdir custom/weights# Create a file contains information about data and cfg
# files locations
$ touch darknet/custom/darknet.data# in darknet/custom/darknet.data file paste those informations
classes = 1
train = custom/train.txt
valid = custom/test.txt
names = custom/classes.names
backup = custom/weights/# Copy and paste yolo config file in "darknet/custom"
$ cp darknet/cfg/yolov3.cfg darknet/custom# Open yolov3.cfg and change :
# " filters=(classes + 5)*3" just the ones before "Yolo"
# in our case classes=1, so filters=18
# change classes=... to classes=1# Download pretrained model
$ wget https://pjreddie.com/media/files/darknet53.conv.74 -O ~/darknet/darknet53.conv.74# Let's train our model !!!!!!!!!!!!!!!!!!!!!
$ ./darknet detector train custom/darknet.data custom/yolov3.cfg darknet53.conv.74
完成训练后，要从图像中检测车牌，请从 darknet/custom/weights 中选择最新的模型，并将其路径或名称放在 object_detection_yolo.py 文件中，我们也将使用 yolov3.cfg 文件，只是在该文件中在训练前放置#以便我们可以训练，然后运行:
python object-detection_yolo.py --image= image.jpg
这就是我们的结果:
第二步:车牌分割
现在我们要分割我们的车牌号码。输入的是车牌的图像，我们必须能够提取单字符图像。这个步骤的结果被用作识别阶段的输入，这是非常重要的。在车牌自动读取系统中。
分割是车牌自动识别中最重要的过程之一，因为任何其他步骤都以分割为基础。如果分割失败，识别阶段将是不正确的。为了确保正确的分割，必须进行初步处理。
像素投影直方图由寻找每个字符的上下限、左右组成。我们执行水平投影来找到字符的顶部和底部位置。一组直方图的值是沿着水平方向上的特定线的白色像素的总和。当沿着水平方向上的所有线的所有值被计算时，获得水平投影直方图。直方图的平均值然后被用作阈值来确定上限和下限。直方图分段大于阈值的中心区域被记录为由上限和下限界定的区域。然后，我们以同样的方式计算垂直投影直方图，但是通过改变图像的行和列来获得每个字符的两个界限(左和右)。
另一种从车牌中提取数字的方法是使用开/闭形态学对连通区域进行排序，然后使用连通分量算法提取连通区域。
第三步:车牌识别
识别阶段是自动车牌识别系统开发的最后一步。因此，它关闭了所有经过图像采集的过程，接着是车牌的定位，直到分割。识别必须从分割阶段结束时获得的图像字符中进行。用于这种识别的学习模型必须能够读取图像并呈现相应的字符。
为了使大部分数据可用于学习，我们在应用与分割车牌之前使用的相同图像处理步骤之后，通过在正方形中调整大小来单独切割每个字符。结果，我们获得了一组由 11 个类组成的数据，对于每个类，我们有 30-40 个 28X28 像素尺寸 PNG 格式的图像；从 0 到 9 的数字和阿拉伯语单词(突尼斯)。
然后，我们基于比较多层感知器(MLP)和分类器 K 最近邻(KNN)的科学文章进行了一些研究。结果我们发现:如果当使用 MLP 分类器时，隐藏层神经元的数量也增加，并且如果当使用 KNN 时，最近邻居的数量也增加，则性能增加。这里调整 k-NN 分类器性能的能力非常有限。但是可调数量的隐藏层和可调 MLP 连接权重提供了更大的机会来改进决策区域。因此，我们将选择多层感知器用于这一阶段。
Github 项目回购链接
使用 H2O AutoML 的欺诈检测中的自动机器学习
金融中的机器学习自动化
机器学习在金融领域有许多应用，如安全、流程自动化、贷款/保险承保、信用评分、交易等。[1][2].金融欺诈是金融安全的主要问题之一[1][2]。为了对抗日益增加的金融欺诈风险，机器学习已被积极应用于欺诈检测[3][4]。
将机器学习应用于欺诈检测存在许多技术挑战。一个主要的困难是数据集在正负类方面倾向于高度倾斜和不平衡[3][4]。如[3]所示，为了在这种情况下获得血统欺诈检测/预测结果，通常需要领域专业知识和大量人工工作来进行数据探索、数据预处理、特征工程、模型选择、训练、评估等。
为了应对这些挑战，H2O [6]提供了一个用户友好的自动机器学习模块，称为 AutoML [7]，非专家也可以使用。
在本文中，与[3]类似，我使用 Kaggle [5]中相同的高度偏斜和不平衡的合成金融数据集来演示如何使用 AutoML [7]来简化机器学习以进行欺诈预测，与[3]中的机器学习方法相比。
1.没有自动化的机器学习
本节总结了[3]中无自动化的机器学习方法的要点，以建立与第 2 节中的 H2O 自动机器学习方法进行比较的基线。
1.1 数据探索
在[3]中，进行了广泛的数据探索和分析工作，以了解哪些数据记录和特征是必需的，以及哪些数据记录和特征可以被丢弃而不会对机器学习建模和欺诈预测产生重大影响。这类工作往往需要领域专业知识，如[3]所示。[3]中的主要结果可以总结如下:
- 特征类型
响应类is fraud(0-否，1-是)仅在值的特征类型为 CASH_OUT 或 TRANSFER 时设置。因此，唯一相关的数据记录是那些具有值 CASH_OUT 或 TRANSFER [3]的类型的记录。
- 特征isFlaggedFraud
特征 isFlaggedFraud 仅在总共数百万条数据记录中的 16 条数据记录/样本[3]中设置，因此我们可以在不对建模和欺诈预测的结果产生重大影响的情况下删除该特征。
- 特性命名来源和命名最早
如[3]中所指出的，特性命名来源和命名目的没有意义，因为它们没有以预期的方式对商户账户进行编码，因此可以删除。
1.2 数据预处理
根据数据探索的结果，数据集在[3]中进行如下预处理。
- 提取类转账或提现的数据记录
根据数据探索的结果，只有当数据类型为 TRANSFER 或 CASH_OUT 时，才会发生欺诈。因此，只有那些数据记录从原始数据集中提取出来，用于模型训练和欺诈预测[3]。此外，不太有用的功能命名为 Orig 、命名为 Dest 和为 FlaggedFraud 被删除:
X = df.loc[(df.type == ‘TRANSFER’) | (df.type == ‘CASH_OUT’)]
X = X.drop([‘nameOrig’, ‘nameDest’, ‘isFlaggedFraud’], axis = 1)
- 输入缺失值
如[3]中所述，目的地账户余额为零是欺诈的明显迹象。因此，帐户余额不应该用统计值或随后对交易金额进行调整的分布值来估算。这是因为这样做会使欺诈交易看起来像真的。为了避免这个问题，在[3]中，值为 0 的目标帐户余额被替换为-1，以使其更适合用于欺诈检测的机器学习算法:
X.loc[(X.oldBalanceDest == 0) & (X.newBalanceDest == 0) & (X.amount != 0), [‘oldBalanceDest’, ‘newBalanceDest’]] = -1
此外，如[3]中所指出的，在非零金额交易之前和之后，数据还具有发起账户的零余额的若干交易。在这种情况下，与真实交易的比例(47%)相比，欺诈交易的比例(0.3%)要小得多[3]。类似于目的地账户余额为零的处理，起始账户余额 0 被替换为空值而不是输入一个数值来区分欺诈交易和[3]中的真实交易。
X.loc[(X.oldBalanceOrig == 0) & (X.newBalanceOrig == 0) & (X.amount != 0), ['oldBalanceOrig', 'newBalanceOrig']] = np.nan
1.3 特征工程
如[3]所述，目的账户或发起账户的零余额有助于区分欺诈交易和真实交易。这促使作者创建了以下两个新功能来记录每笔交易的起始帐户和目的帐户中的错误[3]。这些新特性对于获得[3]中采用的机器学习算法的最佳性能非常重要。
X[‘errorBalanceOrig’] = X.newBalanceOrig + X.amount - X.oldBalanceOrigX[‘errorBalanceDest’] = X.oldBalanceDest + X.amount — X.newBalanceDest
1.4 型号选择
[3]中考虑的用于模型选择的第一种方法是在应用机器学习算法之前，通过对多数类进行欠采样来平衡不平衡数据。欠采样的缺点是，以这种方式训练的模型在现实世界中看不到的不平衡数据上可能表现不好，因为在模型训练期间几乎所有的不平衡信息都被丢弃了。
[3]中考虑的第二种方法是过采样少数类。作者尝试了各种类型的异常检测和监督学习方法。
如[3]所述，经过多次实验，作者最终得出结论:采用xboost机器学习算法在原始数据集上获得了最好的结果。
1.5 模型培训与评估
数据集分为两部分，如下文[3]所示，80%用于模型训练，20%用于模型测试:
trainX, testX, trainY, testY = train_test_split(X, Y, test_size = 0.2, random_state = randomState)
所选XB classifier模型的超参数设置为特定值:
weights = (Y == 0).sum() / (1.0 * (Y == 1).sum())clf = XGBClassifier(max_depth = 3, scale_pos_weight = weights, n_jobs = 4)
模型训练和测试按以下[3]进行:
probabilities = clf.fit(trainX, trainY).predict_proba(testX)
使用 AUPRC ( 精确-再调用曲线下的区域)而非正常的 AUC 的值来评估模型性能:
print(‘AUPRC = {}’.format(average_precision_score(testY, probabilities[:, 1])))
2.自动机器学习
如前一节和[3]所述，为了从高度倾斜和不平衡的数据中获得血统欺诈预测结果，数据探索、数据预处理、特征工程、模型选择、训练、评估等都需要大量的领域知识和手工工作。
本节将演示如何使用 H2O AutoML [7]通过自动机器学习来减少手动工作量，包括但不限于以下内容:
- 自动数据预处理(例如，处理丢失的数据)
- 自动特征工程
- 自动选型
- 自动模型训练
- 自动模型评估
H2O [6]是基于客户机和服务器的集群架构。在开始任何其他活动之前，H2O 服务器需要启动:
import h2o
from h2o.automl import H2OAutoML
h2o.init()
如果 H2O 服务器在本地计算机上成功启动，将显示以下内容:
2.1 数据加载
一旦将 Kaggle [5]中的合成金融数据集下载到 H2O 服务器机器上，就可以按如下方式将该数据集加载到 H2O 服务器上:
df = h2o.import_file(‘./data/PS_20174392719_1491204439457_log.csv’)
df.head(10)
数据集的摘要描述可通过以下方式获得:
df.describe()
响应类的数据类型为 raud 设置为分类(即因子)，因为它是二进制的(0-否，1-是):
factorslist = [‘isFraud’]
df[factorslist] = df[factorslist].asfactor()
2.2 数据预处理
为与[3]中的方法相比较，与[3]类似，仅从原始数据集中提取 TRANSFER 或 CASH_OUT 类型的数据记录进行模型训练和欺诈预测，去掉不重要的特征 nameOrig 、 nameDest 、is lagged 欺诈。
df1 = df[df[‘type’] == ‘TRANSFER’ or df[‘type’] == ‘CASH_OUT’]
y = “isFraud”
x = df.columns
x.remove(y)
x.remove(“nameOrig”)
x.remove(“nameDest”)
x.remove(“isFlaggedFraud”)
2.3 选型及培训
为了与[3]中的方法相比较，提取的数据集被分成如下两部分，80%用于模型训练，20%用于模型测试:
train, test = df1.split_frame([0.8])
选择了超参数 max_models 值为 10 的 H2O 汽车模型:
aml = H2OAutoML(max_models = 10, seed = 1)
使用默认设置训练选定的模型，如下所示:
aml.train(x = x, y = y, training_frame = train)
2.4 模型评估
- 查看训练模型列表
一旦 H2O AutoML 模型被训练，相应的排行榜方法可用于显示训练模型列表，按 AUC (非 AUPRC )降序排列:
lb = aml.leaderboard
lb.head(rows=lb.nrows)
从上表中我们可以看到，H2O AutoML 自动选择并训练了 12 个不同的模型，包括堆叠系综模型。主导车型为XGBoost _ 3 _ AutoML _ 2019 11 13 _ 110031。
- 获取并评估主导模型
位于训练模型列表顶部的模型可以如下获得:
leader_model = aml.leader
注意，这个领先的模型在模型训练 AUC (不是 AUPRC )分数方面是最好的。
主要模型测试性能的综合总结如下:
leader_model.model_performance(test)
如下图所示，领先车型的测试 AUPRC (即 pr_auc )得分为 0.988。
下面的代码将获取主导模型的特征重要性:
leader_model.varimp_plot()
- 获得并评估具有最佳训练的模型 AUPRC
然而，模型测试 AUPRC 而非 AUC 在【3】中用于模型性能评估。为了进行公平的比较，我们需要用最好的测试 AUPRC 来获取和评估训练好的模型。为此，我们可以首先获得并评估具有最佳训练 AUPRC 的模型，然后将其测试 AUPRC 性能与领先模型进行比较，以确定应该选择哪个模型。
如前所述，H2O AutoML 的排行榜方法按照训练 AUC 而非 AUPRC 的降序显示已训练车型列表。为了找到具有最佳训练 AUPRC 的模型，可以使用以下代码以训练 AUPRC 的降序显示训练过的模型:
import pandas as pdmodel_ids = list(aml.leaderboard['model_id'].as_data_frame().iloc[:,0])model_auprc_map = {'Model Id' : [], 'AUPRC' : []}
for mid in model_ids:
model = h2o.get_model(mid)
model_prauc_map['Model Id'].append(mid)
model_prauc_map['*AUPRC*'].append(model.pr_auc(train))
model_auprc_df = pd.DataFrame(model_auprc_map)
model_auprc_df.sort_values(['*AUPRC*'], ascending=0, inplace=True)
model_auprc_df.head(20)
可以看到最佳训练 AUPRC 为 0.937 的模型 id 为 XGBoost _ 2 _ AutoML _ 2019 11 13 _ 110031。
列表顶部的模型可以通过以下方式获得:
best_auprc_model_id = model_auprc_df.iloc[0, 0]
best_auprc_model = h2o.get_model(best_auprc_model_id)
然后，可以获得模型测试性能的全面总结:
best_auprc_model.model_performance(test)
如下图所示，最佳训练 AUPRC (即 pr_auc )的车型取得了 0.975 的测试 AUPRC 分数。
以下代码用于获取具有最佳训练 AUPRC 分数的模型的特征重要性:
best_prauc_model.varimp_plot()
测试结果表明，在测试 AUPRC 分数方面，领先模型优于具有最佳训练 AUPRC 分数的模型。因此，应该选择领先的模型。
2.5 与没有自动化的机器学习的比较
下表比较了 H2O AutoML [7]和[3]中无自动化的机器学习方法之间的主要机器学习活动。
如第 1 节和[3]中所述，在处理缺失数据、特征工程、模型选择、培训、评估等方面，需要领域专业知识和大量手工工作。所有这些类型的工作都是在 AutoML [7]中自动完成的，无需人工干预。另外，AutoML [7]中的模型超参数设置比[3]中的机器学习方法简单得多。
然而，关于模型测试方面的模型测试性能 AUPRC ，与 AutoML 的 0.988 分相比，[3]中的机器学习方法获得了更高的 0.997 分。
AutoML 的主要优势在于，非专家可以使用它从复杂的数据集(如本文中使用的高度偏斜和不平衡的数据集)中获得相当下降的欺诈检测/预测结果。
摘要
在本文中，正如在[3]中一样，我在 Kaggle [5]中使用了相同的高度偏斜和不平衡的合成金融数据集来展示 H2O 汽车公司[7]在使非专家能够将机器学习应用于金融欺诈检测方面的能力。这是通过数据预处理、特征工程、模型选择、模型训练和模型评估的自动化实现的。体面的模型测试 AUPRC 得分为 0.988。
如第 2.5 节所述，通过手工制作数据预处理、特征工程、模型选择、训练等方法，在[3]中获得了更高的模型测试 AUPRC 分数 0.997。在这种情况下，根据业务需求，可能有理由支持用户定义的机器学习方法而不是 AutoML。我注意到 H2O 提供了一个更强大的端到端自动机器学习工具集，叫做， H2O 无人驾驶 AI [8]。该工具集具有自带方法的功能，使用户能够即插即用自己的方法进行数据预处理、特征工程、建模等。
Github [9]中有一个 Jupyter 笔记本，上面有本文中的所有源代码。
参考
[1].K. Didur，金融中的机器学习:为什么，什么&如何
[2].D. Faggella，金融中的机器学习——现在和未来的应用
[3].a .约书亚，预测金融支付服务中的欺诈
[4].R. Pierre，使用机器学习检测金融欺诈:赢得对不平衡数据的战争
[5].用于欺诈检测的合成金融数据集
[6]. H2O.ai
[7]. H2O 汽车
【8】H2O 无人驾驶 AI
[9].Github 中的 Jupyter 笔记本
披露声明:2019 首创一。观点是作者个人的观点。除非本帖中另有说明，否则 Capital One 不隶属于所提及的任何公司，也不被这些公司认可。使用或展示的所有商标和其他知识产权是其各自所有者的财产。
Etsy 卖家的自动定价
使用无监督学习和线性回归的竞争性产品定价
Jewelry Making (image from pexels.com)
Etsy 是数百万手工产品的全球市场。这些卖家中有许多是网站新手，可能不了解市场或他们的竞争对手以及他们产品的定价技术。
我做了一个工具，可以给卖家的产品估价。该工具将为产品提供有竞争力的价格，并检查产品当前价格是否过高或过低。
注 :我在创建集群时使用了物品的价格。如果它是一个现有的项目，我用的是标价。对于上传新商品的新卖家，我会问他们一个估价，模型会告诉他们是高估还是低估。
数据
我使用 Etsy API 收集数据。截至 2018 年 12 月，Etsy 的市场上有超过 6000 万种产品。为了扩大我的项目范围，我从网站的“珠宝”部分收集了大约 30 万件商品的信息。
Screenshot of a sample listing of silver earrings from Etsy
这些产品横跨大约 20 个国家。我将所有的挂牌价格统一为美元。从产品网页上收集的其他属性是——它们的材质(金、银、珍珠等。)、产品分类(耳环、项链、订婚戒指等。)，无论这款产品是复古的、最近制作的还是定制的，等等。
我还收集了一些现有卖家产品的流行度指标，比如收藏夹和浏览量。
假设
1
2 ***售价<$ 1000—***Etsy 上有很多稀有的复古产品。镶有稀有宝石的老式订婚戒指价格高达 1 万到 2 万美元！！
我选择提供大多数市场的价格估计，忽略了极其昂贵的复古单品(约占产品的 2%)。
3 比如首饰→耳环→吊坠&吊坠。
此功能稍后将在模型中使用，它会影响价格估算。这些物品的不正确分类会导致价格估计的偏差。
思维
每当卖家上传新产品到他们的商店时，我想为他们提供一个价格估计。为此，首先，我想找到“相似”的产品(使用 k-prototypes 算法将产品聚类在一起)。然后，我想在线性回归算法中使用这个“cluster”标签作为一个特征，以及其他属性来预测商品的价格。
聚类-K 原型
我用于聚类的大多数特征都是分类特征。例如，“材料”有许多价值，如金、银、钻石、珍珠等。此外，每个产品可以有一个以上的材料价值。
为了对珠宝项目进行聚类以找到“相似”的项目，我使用了 K 原型 算法。这是更流行的 k-means 算法的变体。两者之间的显著区别在于它们处理分类数据的方式。
K-Prototypes 在数字特征上使用 k-means(欧几里德距离),在分类特征上使用 k-modes(相异度量)。它不是使用平均值来计算聚类的“质心”，而是计算每个聚类的“原型”作为代表。
方法
在我的数据集中，我有许多 1 级子类别——耳环、项链、戒指、手镯、脚链等。每个类别有各种子类别，如耳环有箍耳环，耳钉等。
定义聚类的特征-类别、子类别、材料、产品制造商(卖方、第三方卖方)、产品制造年份(2000 年之后、定制、年份)、项目价格、可定制性、查看次数、收藏数量。
我尝试了两种方法。 第一个 ，将所有子类别聚类在一起。我得到的集群是重叠的，没有很好的定义。
第二个 ，我尝试了两层的方法。我将每个类别的数据集分开，然后分别对每个类别进行聚类。 这种有针对性的聚类给了我更纯粹、更分离的聚类。这是有道理的，因为直觉上，一对金耳环和一条金项链的价格会在不同的范围内。
集群
类似于 k-means，我们可以使用惯性来找到最佳的“k ”,我使用 k-原型的成本函数来找到最佳的集群数。我对 3 到 25 个集群和耳环运行了该算法，得到 20 作为具有最小成本值的“k”。
下面是我得到的一组耳环的例子—
这张照片描述的是一串大多是黄金耳环，由卖家 在 2000 年 之后制作。一般都是 不可定制 ，本簇耳环均价为 $370 。
定价—线性回归
接下来，有了这些集群，我继续回归世界。连同其他特征一起，我在回归模型中使用这些聚类标签作为特征。
我尝试了几种方法。首先，使用 scikit-learn 进行简单的线性回归作为基线。
我得到了 13.1 美元的平均绝对误差。这意味着，我的价格估计会比这些珠宝的最佳价格低大约 13 美元。
这是一个很好的基线。接下来，我使用一个 XGBoost 回归器来看看我是否可以改进基线模型的性能。
确实！XGBoost 模型在平均绝对误差(MAE)和平均绝对百分比误差(MAPE)方面确实稍好一些。
我关注梅和 MAPE 的原因是产品的价格范围很广(1-1000 美元)。让我们更深入地探讨一下。
如果我看的是 500 美元的项链，12 美元的预测误差并不算多。然而，如果我看的是 20 美元的耳环，那就大错特错了。因此，为了研究这种差异，我按照商品的价格范围对误差进行了分解。
Breakdown of the Mean Absolute Error by price range of jewelry products
权衡
因此，XGBoost 比传统的线性回归做得好一点。然而，在选择我的最终模型时有一个权衡。
线性回归更容易解释，而 XGBoost 的预测更准确。
如果卖家可以灵活选择他们可以出售的商品，线性回归会更有帮助。这些系数会告诉你什么卖得最好。然而，如果卖方只是销售他们生产的或库存的产品，预测的准确性对他们来说更重要。考虑到这一点，我决定继续使用 XGBoost 作为我的价格预测模型。
XGBoost 的特性重要性
XGBoost regressor 为模型中使用的所有功能提供功能重要性。它是所有特性的相对排名。
我使用聚类的标记数据进行回归。也就是说，在我的模型中，聚类标签也是其他产品属性的特征。
当我观察特征的重要性时，聚类的排名高于单个属性。
个体特征之间的相互作用很重要。由于集群很好地解释了这些交互，XGBoost 将它们排在比任何单个特性更高的位置。
例如，“可定制性”是一个重要的特性。如果是定制的耳环可能会涨价。但是如果是定制的银耳环和定制的金耳环，价格会有不同的变化。
该应用程序
我使用 Flask 创建了一个工具，它将产品属性作为输入，并实时将其分配给一个集群。回归模型使用这一点，并提供一个建议价格。
结论
这个工具可以帮助 Etsy 上的新企业家为他们的项目定价，并在 Etsy 上开始他们的业务。
定价算法或细分并不仅限于 Etsy 产品。任何市场业务都可以利用这些算法。一些这样的应用是 Airbnb 房产的定价、DoorDash 上餐馆项目的定价等。像 LinkedIn 这样的工作论坛可以使用这些技术来根据工作描述提供估计工资。
资源
k-prototypes 算法， Github ， LinkedIn
自动语音识别作为 AWS 上的微服务
本文将帮助您在 AWS 基础设施上使用 Kaldi Toolkit 建立自己的 ASR 管道，为您提供可伸缩性和高可用性的选择。
本文假设读者对云计算和相关术语有必要的了解，此外，任何实际经验都可以帮助您在一个小时内完成所有工作！
在我开始阅读设置这个管道的指导手册之前，让我们先来看一下三个基本问题
这个工具是做什么的？
简而言之，用户上传任何英语音频文件，该工具将提供相同的转录并存储到数据库中，然后可用于各种用例
为什么要打造这个工具？
对于那些业务围绕音频/音频形式的对话的人来说，构建这样一个工具不仅会在文本分析方面开辟无限的可能性，还能让他们开发自己的自助产品。
请注意，在语音转文本领域，这种技术非常少！
平视
这个工具利用了 Kaldi 预先训练好的神经网络英语模型来转录成文本。虽然这个模型的词汇量相当大，但是仍然不足以为您的用例选择非常罕见/特定的单词。
Kaldi Logo
有没有可能 有，是开源项目。如果你在定制方面需要帮助，请随时联系我
架构
介绍完毕，让我们深入应用程序的数据流。该架构本质上为您提供了我们使用 AWS 基础设施的工具的鸟瞰图
AWS Architecture of the Tool we will develop. Repeated numbers depict that some processes happen in parallel to others. By the time time steps [2 > 3 > 8] happen, [3 > 4 > 5 > 6 > 7] will have finished processing
合适的工具
我们可以在一台服务器上从头到尾执行每一个动作，就这样！当设计作为几乎所有产品核心组件的数据管道时，我们需要开始研究数据工程的基础知识
从技术的角度来看，对于一个产品，并且最终会被大量用户使用的东西来说，这三条规则是必不可少的
- 成本效益:有没有更便宜的方法来做这件事，而又不影响质量？
- **高可用性:**如果其中一台服务器崩溃，那么整个产品会崩溃吗？
- 可伸缩性:我们能让这个工具自己处理峰值负载吗？
即使你的工具只是另一个 MVP，不遵守这 3 条规则可能会成为你的产品的一个昂贵的错误。于是， AWS 云
虽然 AWS 有一套广泛的工具，但明智地选择它们就更有道理了。以下是我们用来开发工具的 AWS 工具列表，其中大多数工具都包含在 AWS 自由层 中。不过，在某些时候，你的使用可能会收费。我建议你在开始实施之前留意一下价格。
- S3: 简单的仓储服务。你能得到的最便宜的存储
- EC2: 计算服务器。 t3a.xlarge 实例
- 动力数据库: NoSQL 数据库
- Lambda: 大规模处理小脚本执行的计算服务
- AWS API: 很好的选择，因为很难编写可伸缩的 API 服务
建立基础设施
你可以利用 GitHub 上的代码让你的 Infra 马上发挥作用！
**Github:**https://github.com/purijs/kaldi-asr-aws
请参考 Github 上的 README.md 文件，它详细解释了如何在 EC2 实例上设置一切。
你可以自由选择任何一种 EC2 机器。然而，我发现下面的配置足以实现这个管道
- EC2: t3a.xlarge
- 50GB 磁盘空间
- 图片:亚马逊 Linux 2 AMI (HVM)
- 安全组:打开端口 80 (HTTP)、8080 (FLASK)和 22 (SSH)
由于这种类型的 EC2 实例不包括在自由层中，您可能会在这一点上产生成本。如果您无论如何都要获得它，请确保它处于停止状态，因为我们不会马上使用它
继续使用上面的配置获取 EC2 实例，并将上面的 Git 存储库克隆到您的服务器中。一旦您做好了设置，我们将在 AWS 控制台上完成以下步骤
-创建一个具有 S3 读/写权限的 IAM 角色并将其附加到您的实例
-为 lambda 函数创建一个 IAM 角色以读取/写入 DynamoDB
-配置 S3 桶
-编写第一个 Lambda 函数以读取音频文件的元数据
-设置 AWS API 以触发我们的第一个 Lambda 函数
-使用 Kaldi ASR 配置 EC2 实例(此时克隆 git 代码！)
-编写第二个 lambda 函数来读取/写入脚本到 DB
-设置 DynamoDB
-用 Flask App 链接管道
实用
- 为 S3 制作 IAM 角色
Go to IAM from AWS Console, select “Create Role” and choose EC2 and “Next” | 2. Choose “S3FullAccess” in Policies | 3. Tags are optional, name this role and click “Create”
To attach this role to your EC2 instance, 1. Go to the EC2 dashboard, select your instance, and choose “Actions” > “Instance Settings” > “Attach/Replace IAM Role” | 2. Select your role and continue.
现在，您可以运行“AWS s3”CLI 命令并从 EC2 访问 S3 存储桶，而无需使用/存储帐户密钥
2。为 Lambda 函数设置 IAM 角色
Similarly, create a role for “Lambda”. Make sure you add permissions for DynamoDBFullAccess and S3FullAccess (Refer the screens above)
**【更新】😗*除了以上两个策略，还要加上这些:
- CloudWatchFullAccess
- LambdaFullAccess
3。配置 S3 铲斗
现在，我们已经为不同的 AWS 服务设置了必要的访问权限，接下来我们将设置第一个服务，即 S3
目的:
**传入:**存储用户上传的音频文件，一经 EC2 处理将被删除
**传出:**存储音频的抄本。txt 文件，稍后 Lambda 函数会读取该文件，然后将内容转储到 DynamoDB 中
Go to S3 from console, create a new S3 Bucket, keeping all other settings to default (Changing region is fine, but make sure your Lambda Functions are also in the same region). Once created, make two directories as explained above
4。第一个λ函数
简单来说，AWS Lambda 允许你运行 Python/NodeJS/Bash/etc。就像在 EC2 机器上运行一样编码。唯一的区别是，除了一些技术上的，你只在这段代码运行时才被收费，也就是说，对于每个触发器，它的伸缩性也很好！
这个 lambda 函数将运行一个 Python 代码，该代码将读取存储在 S3 中的文件名，并将它们转储到 DynamoDB 中。
这是参考架构图的步骤 5、6 和 7
注意我们是如何尽可能地去耦合组件的
从 AWS 控制台的服务部分选择“Lambda”。确保您已经选择了“从头开始创作”框
1. Choose the runtime as “Python 3.6” as our code will be .py file | 2. In execution role, what all permissions your lambda function can have, choose ‘use existing role’ | 3. In the dropdown, select the role you previously created for Lambda in the 2nd step. Once done, you’ll see a screen like on the right
如果向下滚动一点，您会看到一个集成的代码编辑器，其中包含一些虚拟 python 代码。继续替换下面 Git 链接中的代码:
[## 普里吉斯/卡尔迪-阿斯尔-aws
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/purijs/kaldi-asr-aws/blob/master/lambda/incoming-lambda-handler.py)
下一步，我们将有一个 AWS API 作为这个函数的触发器。
由于这是我们管道中的第一个执行阶段，当用户单击我们 web 页面上的“Submit”按钮时，会发生两个系列的事件。
- 文件被上传到你在上面创建的 S3 桶
- AWS API 被称为[POST],其中用户的文件名和电子邮件作为 JSON 值传递
5。部署 AWS API
从 AWS 控制台转到 API 网关部分，并按照下面共享的屏幕进行操作
1. On clicking the “Create API’ button, keep everything default. | 2. Click on ‘Actions” and choose ‘Create Resource’. Give it a name and enable CORS
Once done, click on “Actions” again and choose “Create Method”. A dropdown will appear, select “POST” like in the screen on the left. 1. Set the integration type to “Lambda Function”, enable the “Proxy Integration”, finally, enter your Lambda Function’s name.
再走几步…
Once you’ve created the resource and the screen like on the left is visible, click on “Method Request” and set API Key Required to True
Finally, click on “Actions” and select “Deploy API”. Give this stage a name eg: prod, dev, test. On clicking Deploy, you’ll see your API URL in front of the Invoke URL text
至此，您已经配置好了 API，并将其作为触发器添加到 Lambda 函数中。为了使这个 API 安全，这样你的 API 就不会在一夜之间暴露或耗尽，我们还必须设置一个 API 密钥。
这一点至关重要，因为任何人都可以不断点击 API 的网址，很快，你的成本就会飙升。
1. On the left side Navigation panel, click on “Usage Plan” and then “Create”. Most of the settings are self-explanatory. However, you may choose to keep the settings as in the left image. | 2. Click “Next” and select the correct API & Stage you configured previously. Hit “Next” and then “Create API Key and add to Usage Plan”
Give the Key a name and hit “Next”. You may click “API Keys” on the left navigation panel to view the key
就是这样！我们现在已经完成了管道，直到音频文件被传递到我们的 EC2 机器
这些是参考架构图的步骤 3 和 4
到目前为止，你在 AWS 上设置的所有东西都不会花你一分钱，因为有两个主要原因:
- 你在免费层(如果你第一次注册)
- 如果不是，没问题，服务 S3、Lambda 和 API 是按使用付费的。除非你使用它们，否则你不会被收费。
卡尔迪·阿斯尔
Kaldi 是一个强大的语音识别工具包，作为开源产品提供。该工具包或多或少是用 C/C++/Python 语言编写的，在 google groups 上也有一个非常活跃的支持/讨论社区。如果你有问题的话，这个工具包的创始人丹尼尔·波维是最会回答你的问题的人。
就像任何 ML 模型一样，ASR 模型可以针对您的特定语言/音频进行训练，或者我们可以使用在 Kaldi 网站 上提供的预训练模型
虽然训练一个模型超出了本文的范围，但是我们将利用一个**英语训练的神经网络模型。**对于所有的神经网络爱好者来说，典型的 ASR 模型具有以下训练参数:
- 大约 10 个时代
- 大约 10 到 13 个隐藏层，每个层有 1024 个维度
我们场景中使用的预训练模型的 WER(单词错误率)约为 **15.6%，**的意思，精确度约为 85% 。
ASR 解码
让我们快速了解一下我们的 ASR 模型实际上是如何理解音频，然后能够组成有意义的句子的。ASR 解码利用训练时输入的多种资源，例如:
Source: One of the lectures from https://www.danielpovey.com/
- 词库:带有各自音素的单词列表，将音频与一个音素进行映射。一组音素组成一个单词
- Ngrams :很多上升到 4 克，预测下一个可能的单词
- **WFST:加权有限状态转换器:**组合音素和单词并形成句子
- 好多数学！
虽然 Kaldi 必须提供许多模型，如单音、三音、SAT 模型，但链(神经网络)模型明显优于其他模型。
我们将使用卡迪的 **ASpIRE 链模型和已经编译好的 HCLG。**这个包含在 Github 上的 model.zip 文件中
实用的
让我们快速回到我们的实验室工作，用几个简单的步骤实现这个高度复杂的工作。此时，您应该已经启动 EC2 并进入其中。
请参考 Github 资源库 中任何缺失的资源/链接
- 在您的主目录[ /home/ec2-user ]中，维护以下目录结构
D -> Represents Directory
F -> Represents Filecd /home/ec2-user/ -audios D [ Files from S3 will be synced here ]
-audiosKaldi D
-processing D [ Files ready for Transcription are moved here ]
-sendWavToProcess.sh F
-kaldi D
-Dockerfile F
-models D
-model.zip F (unzip here)
-transcriptMaster.sh F
-transcriptWorker.sh F
-output D [ Transcription in .txt file will be store here]
ffmpeg F
getConvertAudios.sh F
uploadOutput.sh F
帮助您快速入门的命令列表
mkdir audios kaldi models output
mkdir -p audiosKaldi/processingwget -P /home/ec2-user/ [https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz](https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz)tar -xvf ffmpeg-release-amd64-static.tar.xzmv ffmpeg-4.2.1-amd64-static/ffmpeg ~/
sudo chmod 755 ~/ffmpegwget -P /home/ec2-user/models/ [https://crossregionreplpuri.s3.ap-south-1.amazonaws.com/model.zip](https://crossregionreplpuri.s3.ap-south-1.amazonaws.com/model.zip)unzip /home/ec2-user/models/model.zip -d /home/ec2-user/models/sudo yum install -y git
sudo yum install -y docker
sudo service docker start
alias docker='sudo docker'
2。接下来，我们需要在 crontab 中创建一个条目
Crontab 会以固定的时间间隔自动运行我们的一些脚本。
crontab -e# PASTE THESE 2 LINES*/1 * * * * sh ~/getConvertAudios.sh
*/2 * * * * sh ~/uploadOutput.sh
3。卡尔迪很严格
在训练模型时作为输入给出的音频文件的属性需要在对新数据进行测试时得到维护。在我们的例子中，Kaldi 也将接受一种非常特殊的音频文件格式，主要是
- 。wav 声音文件
- 8000 比特率
为了确保我们每次都有正确的格式，因为用户可以上传任何类型的音频文件，我们使用了 ffmpeg 来转换音频文件。
关于正在使用的外壳脚本的一些信息
**getConvertAudios.sh** -> This script syncs files from S3 into audios/ directory and using ffmpeg converted and stored into audiosKaldi/**uploadOutput.sh** -> This script syncs the .txt files in output/ directory into S3 bucket**sendWavToProcess.sh** -> This script limits the number of files for processing to the number of cores on the VM for parallel processing**transcriptMaster.sh** -> This script calls transcriptWorker.sh for every audio file placed in the **processing** folder and ensures at any time only *#no. of cores* amount of files are running**transcriptWorker.sh** -> Where the magic happens, actual transcription happens through this file.
4。设置 Kaldi Docker
我们需要使用 Dockerfile 构建 Kaldi 映像，这意味着安装 Kaldi 运行所需的依赖项。
cd kaldi/
docker build -t kaldi . &
这可能需要一个小时，所以是时候喝杯咖啡了！
完成后，运行这个命令来启动 Kaldi 容器
docker run -d -it --name kaldi -v ~/models:/models/ -v ~/audiosKaldi/processing:/audios/ -v ~/output:/output/ kaldi bash
最后，我们需要启动 sendWavToProcess.sh 脚本，这样脚本就可以继续向 Kaldi 容器发送文件
cd /home/ec2-user/audiosKaldi/
sudo chmod 755 sendWavToProcess.sh
./sendWavToProcess.sh &# Ignore any errors you see on your terminal
确保您已经更新了这些文件中的存储桶名称:
getConvertAudios.sh
uploadOutput.sh
5。第二λ函数
由于 DynamoDB 支持动态模式，这意味着我们可以在数据库中动态创建新的字段/列，该函数将更新数据库中的当前记录，并添加一个名为抄本的新列
如果你还记得，我们创建了两个文件夹传入 &传出**，在我们的 S3 桶中。输出即文本文件存储在外发**文件夹中。我们新的 lambda 函数将和我们的第一个一样，唯一的区别是触发点。
任何时候，一个**。txt** 上传/创建在 s3://bucketname/outgoing 文件夹中，lambda 函数将被触发
Note the configuration in the right-most screen. The trigger is explicitly set for “output/” directory and “.txt” files only
此 lambda 函数的 Python 代码可从以下网址获得:
[## 普里吉斯/卡尔迪-阿斯尔-aws
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/purijs/kaldi-asr-aws/blob/master/lambda/outgoing-lambda-handler.py)
6。DynamoDB:一键 DB 设置
从 AWS 控制台转到 DynamoDB，创建第一个表。将 audioAnalytics 设置为您的表名，或者在两个 Lambda 函数的代码中更改名称
The Table Name & Primary Key you set here should be in sync with the code in both the Lambda Functions
7。最后，网页界面
我们的 web 应用程序只是另一个 Flask 应用程序，您可能想查看 Github 链接，了解如何在 EC2 服务器上设置/安装 Flask/Python。
一旦你在虚拟环境中，尽管不建议用于生产工作流程，你可以简单地将 flask-app 目录克隆到你的工作目录中，例如: /var/www/html/
python app.py &
这将在后台运行 flask 应用程序。
在浏览器中，键入 EC2 的 IP，端口号为 8080
http:// <您的 IP > :8080/
在文本字段中，键入有效的电子邮件，然后上传。wav/.mp3 音频文件
A snapshot of the DynamoDB table, you can see some of the transcripts have started to stream in!
在运行以下两个命令时，一旦音频文件位于***/home/ec2-user/audiosKaldi/processing***文件夹中，Kaldi 将开始转录这些音频文件
docker exec -it kaldi bash# Once you can see some files in the /audios/ folder, run:
/models/transcriptMaster.sh
请随意联系或者把你的问题/反馈贴在这里，因为我相信这是很多实用的东西，通常第一次尝试不会很顺利！
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
