为极具竞争力的公司增强车辆路线和车队优化
企业可以削减与“最后一英里”相关的供应链成本。图片来自 Pixabay 的 wiggijo 。
所谓的“最后一英里”会导致整个供应链成本的 30%,这使得它成为创新新技术的主要目标。
众所周知，车辆路线问题很难解决，但近年来，大量路线优化服务涌现出来，有望提高效率和降低成本。
问题是，
所有的路线优化系统都是平等的吗？
绝对不行。
解决相对平凡的日常问题的巨大复杂性迫使路线规划系统走捷径。虽然它们提供的解决方案比您手工或使用简单的路线优化软件所能实现的更好，但您仍有可能获得更好的结果。
一个只有一辆车和 50 个站点的简单路线优化问题的排列比太阳中的氢原子多 3000 万倍。
如果与送货和取件相关的运输成本占了您成本的很大一部分，那么您需要将这些整合到您的系统中(我们将通过一些例子来说明为什么需要这些功能，以及您从拥有这些功能中获得的竞争优势)。
基本车队优化要求
为了确保您的业务尽可能简化和高效，任何优化都必须考虑以下影响成本和执行能力的条件:
- 满足固定的时间&距离相关成本 ( 仅使用时间或距离成本可能导致次优结果，因为只有一半的真实成本生成器被考虑)
- 考虑车辆的容量类型和限制 ( 使用一条最佳路线是没有意义的，这条路线要求车辆运送远远超过它所能承载的东西，或者装载它所不能承载的东西——比如冷冻食品
- 允许在行程中及行程之间进行提货和交货 ( 即从该地点提货并将其交付至该地点，或将其带回仓库
- 允许在一天内多次往返停车场 ( 在再次出发之前，必须允许车辆返回停车场补充货物
- 满足位置的灵活时间限制(即包裹必须在上午 11 点之前到达，或者取件时间必须在下午 2 点到 4 点之间)
- 考虑车辆限制 ( 即本次取货需要冷链车，或者本次交付需要多人搬运等
无论您使用的是第三方基于网络的系统、路线优化 API 还是集成到车队跟踪中的路线优化系统，上述列表都代表了对实际的“黑盒”数字处理后端至关重要的功能，该后端可为您的业务提供优化的交付时间表。
增强的路线优化优势
除了避免不必要的长途旅行之外，还有许多不太明显的好处，不仅可以降低路上的成本，还可以提高整个组织的效率(在车辆离开停车场之前*)。*
利用时间和距离成本因素提高效率
现实世界的路线规划必须考虑与您的车队相关的一系列成本，以便根据车队的具体特征准确描绘最佳解决方案。
任何只考虑距离或时间的系统(而不是两者都考虑)都无法计算出最佳可能的解决方案，因为它忽略了一半的成本生成因素。
考虑以下场景，其中一辆车的距离成本较高，而另一辆车的时间成本较高。
路线优化时间表由 Optergon 提供
您希望解决方案是什么样的？一个不考虑这两种成本的系统不可能给出答案。
这是结果。
基于最佳时间和距离成本的解决方案由 Optergon 提供
具有较高距离成本的车辆选择了保持其距离最小的路线(尽管它最终在路上花费了更长的时间，而具有较高时间成本的车辆行驶得更远(但是用了更少的时间)。
对于在市区和大城市运营的公司来说，同时计算时间和距离的基于成本的路线优化绝对至关重要。
增强的虚拟车队优化
用更小、更轻、更便宜的车来完成接送会更好吗？还是用载重量更大的车会更有效率？
较小的车辆可能必须返回到车厂，并做多次旅行，花费更长的时间，走得更远。这比更大、更贵、载重量更大的汽车更好还是更差？
多行程最佳路线由 Optergon 提供
试错是一项相当昂贵的工作，因为你至少要租用和运行不同的车队来比较它们的成本。
有了路线规划，你可以输入你的车辆的虚拟版本，对照历史时间表运行，看看从长远来看哪个最终更便宜。
虚拟测试不同的车队(及其相关的成本和容量限制)要快得多，也便宜得多，最终意味着你会购买和维护尽可能最便宜的车队。
关键业务洞察力
假设您的业务正在快速增长，因此您需要扩大车队以满足不断增长的需求。
为了便于讨论，让我们假设你一天在 3 个邻近的城镇完成超过 300 次送货，并想购买 3 辆新车。
你真的需要三个吗？还是两个？或者任何？
知道如何更有效地利用你所拥有的可能会带来一些令人惊讶的见解。
在扩张(以巨大的成本)之前，使用现有车队对历史交付进行路线优化。
优化的路线可以很好地表明，不仅昂贵的车队扩张和就业活动(雇用新司机)是不必要的，而且你可以实际减少你的车辆数量，仍然履行所有义务。
提高竞争力
良好的交付计划不仅能降低成本，还有一个额外的好处，那就是它能告诉你某件事情是否有可能实现。
如果您今天安排了 100 次提货和交付，有 5 辆车可用，您如何知道在没有运行全面的交付计划优化的情况下是否有可能呢？
100 个位置，5 条车辆路线优化由 Optergon 提供
通过预先运行优化，可以了解您的预期工作负载实际上是否可行——考虑到您业务的实际限制。
这可以帮助你变得更有竞争力，因为它允许你比竞争对手更好地计划，竞争对手可能:
- 承担比他们能提供的更多的工作——最终惹恼客户和顾客
- 为了安全地完成他们的订单，所承担的远远少于他们的资源所允许的
额外的组织效率
考虑到车队车辆的容量限制，提前了解最佳配送路线会带来额外的优势。
您现在还知道哪些车辆正在交付什么，更重要的是，它们执行这些交付的顺序。
与您的仓库人员分享这些路线可以让他们更好地计划、储存和包装仓库和车辆，从而在车辆离开仓库之前降低成本并进一步简化流程。
更好的沟通
你有多少次等着公司上门取货或送货，甚至是上门提供服务，却被告知“我们会在周一或者周二的某个时候到那里”。
这并不理想——但是公司通常没有能力明确他们什么时候到达。
通过提前优化路线，你可以确定地知道(不包括不可抗力事件)司机将在什么时候到达他们计划中的每个地点。
这让你的组织有能力告诉客户类似这样的话，“我们将在周一 11:45 到达。
更好的服务和体验。
对于大中型企业来说，确保您拥有所有必要的功能可以大幅降低成本，这远远超出了您已经从更基本的车辆路线、交付计划或路线优化系统中获得的成本。
用实体嵌入增强分类特征
首先，我们来谈谈卖啤酒
假设你是一家酒馆的老板，你想根据两个变量来预测你的店在某一天要卖多少啤酒:星期几和当前天气。我们可以在某种程度上想象，与一周开始和寒冷的日子相比，周末和温暖的日子会卖出更多的啤酒。
面对这个问题，我们通常首先将我们的分类数据(在这个例子中，星期几和天气)编码成虚拟变量，以便为我们的分类器提供输入，而在现有的分类值之间没有任何层次。
对于一周中的某一天功能，我们的数据如下所示(对于天气功能，您可以想象类似的情况):
但是这真的有意义吗，将每个分类值视为彼此完全不同，例如当使用一个热编码时？或者我们可以利用某种技术来“学习”每个可能值和我们的目标变量之间的关系和内在联系吗？
实体嵌入拯救
考虑到这个给定的场景，我们可以继续采用 NLP(自然语言处理)领域中众所周知的技术作为实体嵌入，这允许我们将给定的特征集映射到一个具有较少维数的新特征集中。在我们的例子中，它还允许我们从分类数据中提取有意义的信息。
实体嵌入的使用基于用分类数据训练神经网络的过程，目的是检索嵌入层的权重。与单一的热编码方法相比，这允许我们有更重要的输入。通过采用实体嵌入，我们还能够缓解两个主要问题:
- 不需要领域专家，一旦我们能够训练一个神经网络，它可以有效地学习模式和相同分类特征的值之间的关系。这导致避免了特征工程步骤(例如手动给一周中的每一天或每种天气赋予权重)；
- 计算资源的缩减，一旦我们不再用一次热编码来编码我们可能的分类值，这可能意味着巨大的资源使用。假设您有一个包含一万个可能唯一值的分类特征。这将转化为具有相同数量的空位置的特征向量，仅仅表示给定值。
实体嵌入的定义
嵌入层相当于一个神经网络层，它将具有相似输出值的分类值分组到一个 N 维空间中。这种空间表示允许我们获得每个分类值的内在属性，这可以在以后用作旧的虚拟编码变量的替代。如果我们以一种更简单的方式来考虑它，这将意味着一周中具有相似产量(在我们的例子中，是售出啤酒的数量)的日子将彼此接近。如果你不明白，也许一张图可以帮助你:
在这里，我们可以看到我们有四个主要组:组 1，周一和周二，可能与低销量的啤酒有关，因为这是一周的开始；第二组，周三和周四，与第一组有一段距离；第 3 组，星期五和星期六相对接近第 2 组，表明它们比第 1 组显示出更多的相似性；第四组是周日，与其他组相比没有太多相似之处。这个简单的例子可以向我们展示嵌入层可以从现实世界中学习信息，比如最常见的外出和喝酒的日子。很酷，不是吗？
把它和 Keras 放在一起
首先，我们需要知道，为了使用嵌入层，我们必须指定我们希望用于给定嵌入的维数。正如您所注意到的，这是一个超参数，应该逐个案例地进行测试和实验。但是作为一个经验法则，您可以采用维度的数量等于类别的唯一值的数量的平方根。所以在我们的例子中，我们对一周中某一天的表示不是七个不同的位置，而是三个位置(四舍五入)。下面我们给出了两个提到的特征的例子，并在我们的模型中添加了一些隐藏层，以便有更多的参数来捕捉细微的数据差异。
# Embedding layer for the 'Day of Week' feature
n_unique_day = df['Day'].nunique()
n_dim_day = int(sqrt(n_unique_day))input_week = Input(shape=(1, ))
output_week = Embedding(input_dim=n_unique_day,
output_dim=n_dim_day, name="day")(input_week)
output_week = Reshape(target_shape=(n_dim_day, ))(output_week)# Embedding layer for the 'Weather' feature
n_unique_weather = df['Weather'].nunique()
n_dim_weather = int(sqrt(n_unique_weather))input_weather = Input(shape=(1, ))
output_weather = Embedding(input_dim=n_unique_weather,
output_dim=n_dim_weather,
name="weather")(input_weather)output_weather = Reshape(target_shape=(n_dim_weather,))(output_weather)input_layers = [input_week, input_weather]
output_layers = [output_week, output_weather]model = Concatenate()(output_layers)# Add a few hidden layers
model = Dense(200, kernel_initializer="uniform")(model)
model = Activation('relu')(model)model = Dense(100, kernel_initializer="uniform")(model)
model = Activation('relu')(model)# And finally our output layer
model = Dense(1)(model)
model = Activation('sigmoid')(model)# Put it all together and compile the model
model = KerasModel(inputs=input_layers, outputs=model)
model.summary()opt = SGD(lr=0.05)
model.compile(loss='mse', optimizer=opt, metrics=['mse'])
从图形上看，我们的神经网络将具有以下表示形式:
就是这样！我们可以看到，我们的架构最初由每个分类值的输入层组成，接着是嵌入层，然后是整形层。然后全部放在一起。最后，我们添加一些隐藏层来捕捉任何额外的信息。
以 0.05 的学习率训练我们的网络 200 个时期，我们可以看到损失和均方误差的一些相当好的结果:
结论
在这个简单的例子中，这听起来可能很傻，但是我们可以再次考虑我们的一万个唯一值的场景。当我们考虑计算资源时，一个具有一万个位置的特征向量(通过使用 One-Hot-Encoding)和另一个只有 100 个位置的特征向量(当使用实体嵌入时，通过经验法则测量)之间的差异是巨大的。这只是单个要素的单个记录的差异，但您可以想象这对于真实世界的数据集会变得多么复杂，类别有时会变得非常庞大。
如果你毫无疑问地达到了这一步，那么恭喜你！但是如果你有任何问题、建议或抱怨，请随时联系我。我还创建了一个 GitHub 存储库，其中包含一个库，可以帮助任何希望在自己的数据上执行实体嵌入的人，请随意查看:
https://github . com/Rodrigo bressan/entity _ embeddings _ categorial。
下次见，编码快乐！
增强优化的 PySpark 查询
梦想成真的故事
亚历山大·雷德尔在 Unsplash 上拍摄的照片
随着我们不断增加处理和存储的数据量，随着技术进步的速度从线性转变为对数，从对数转变为水平渐近，改进我们软件和分析运行时间的创新方法是必要的。
这些必要的创新方法包括利用两个非常流行的框架:Apache Spark 和 Apache Arrow。这两个框架使用户能够以分布式方式处理大量数据。这两个框架也使用户能够通过使用矢量化方法更快地处理大量数据。这两个框架可以轻松促进大数据分析。然而，尽管有这两个框架和它们赋予用户的能力，仍然有改进的空间，特别是在 python 生态系统中。为什么我们可以自信地确定在 python 中利用这些框架的改进之处？让我们研究一下 python 的一些特性。
Python 的特性
作为一种编程语言，python 实现了纯粹的灵活性。开发人员不需要在实例化或定义变量之前指定变量的类型。开发者不需要指定函数的返回类型。Python 在运行时解释每个对象的类型，这允许这些限制(或护栏)被移除。python 的这些特性缩短了开发时间，提高了生产率。然而，众所周知，这些相同的特性对程序运行时间有负面影响。由于 python 在运行时解释每个对象的类型，所以一些软件需要很长时间才能运行，尤其是那些需要过多循环的软件。即使在利用向量化操作的程序中，考虑到一些编程逻辑的复杂性，仍然会对运行时性能产生一些影响。我们能做些什么来减轻这些与性能相关的影响吗？让我们把注意力转向我选择的解决方案:Numba
Numba 来救援了
Numba 对 python 函数执行即时编译，与 C/C++和 Java 编译的执行方式非常相似。仅包含标准内置函数或一组 NumPy 函数的 Python 函数可以使用 Numba 进行改进。这里有一个例子:
from time import time
from numba import jit
import numpy as np@jit(nopython=True, fastmath=True)
def numba_sum(x):
return np.sum(x)# this returns the median time of execution
def profileFunct(funct, arraySize, nTimes):_times = []
for _ in range(nTimes):
start = time()
funct(np.random.random((arraySize,)))
end = time()
_times.append(end - start)return np.median(_times)# this is the numba time
numba_times = [profileFunct(numba_sum, i, 1000) for i in range(100, 1001, 100)]# this is the standard numpy timing
numpy_times = [profileFunct(np.sum, i, 1000) for i in range(100, 1001, 100)]speed_up_lst = list(map(lambda x: x[1] / x[0], zip(numba_times, numpy_times)))
在上面的例子中，我们只计算一个 numpy.array 的和，然后相互比较性能。在这个简单的例子中，我们看到了适度的性能提升。根据您的本地机器，您可以看到 10%到 150%的性能提升。通常，您会看到类似的性能提升，或者如果您在函数中迭代，甚至会更多。
如果我们可以加速一个简单的加法示例，让我们来看一个使用 Numba + Apache Arrow + Apache Spark 的示例。
三个火枪手
下面是一个简单的例子，展示了创建实时编译函数，然后通过 pandas_udf 使用它们的可能性。
from numba import jit
import numpy as np
import pandas as pdimport pyspark.sql.functions as F
from pyspark.sql import SparkSession
from pyspark.sql.types import DoubleTypespark = SparkSession.builder.appName("test").getOrCreate()spark.conf.set("spark.sql.execution.arrow.enabled", "true")df = pd.DataFrame(data=np.random.random((100,)), columns=["c1"])sdf = spark.createDataFrame(df)# JIT compiled function
@jit(nopython=True, fastmath=True)
def numba_add_one(x):
return x + np.ones(x.shape)# this is needed to use apache arrow
@F.pandas_udf(DoubleType())
def add_one(x):
return pd.Series(numba_add_one(x.values))sdf = sdf.withColumn("c1_add_one", add_one(F.col("c1")))sdf.toPandas()
如前所述，这是一个简单的例子。然而，对于更复杂的应用程序，这是非常有价值的，将使它加速，即使是最基本的 Apache Spark SQL 查询。
我希望你喜欢你的阅读！如果您对此感兴趣，那么您会对下面的文章感兴趣:
[## 使用 Apache Airflow 扩展 DAG 创建
数据科学社区中最困难的任务之一不是设计一个结构良好的模型…
towardsdatascience.com](/scaling-dag-creation-with-apache-airflow-a7b34ba486ac)
如果您想了解更多信息，请在 LinkedIn 上关注我，或者访问我的主页，在那里联系我
[## 爱德华·特纳——数据科学家——pay locity | LinkedIn
爱德华·特纳(Edward Turner)是一名多语言开发人员，懂 Python、R 和 Scala，懂 Java 和 C/C++的语法。他…
www.linkedin.com](https://www.linkedin.com/in/edward-turner-polygot/) [## 主页
在这里，您将找到有关 Edward Turner 所做工作的信息，以及…
ed-特纳. github.io](https://ed-turner.github.io/)
再次感谢！一如既往#happycoding
使用 imblearn 管道中的自定义采样器丰富您的火车文件夹
在交叉验证中使用扩充数据并不像看起来那么简单。这是如何在 sklearn 中做到的。
艾德亚多·桑奇兹在 Unsplash 上拍摄的照片
当涉及到小数据集时，生活会变得复杂。在医学中，一个数据集很容易包含不到 100 个患者/行。但是在另一个维度上，它可以变得非常大——轻松超过 3000 个特征。
但是，有时您会找到扩充数据的方法，在我的例子中，这意味着您将数据集乘以稍微不同的特征值。这样你就可以增加你的训练数据。当然这是我真正做的事情的简化版本，但那是另外一个故事了。有不同的方法来扩充您的数据，但是本文并不打算涵盖数据扩充的广泛领域。
但你必须小心，数据增强是一种强大的武器，必须谨慎使用。即使正确使用，也不能保证提高估计器的性能。
顺便说一句，如果没有我的同事和 StackOverflow 的人的帮助，我是写不出这篇文章的！
在您的流程中何处使用增强数据
一旦你有了一组扩充的数据来丰富你的原始数据集，你就会问自己如何以及在哪个点上合并它们。通常，您使用 sklearn 及其模块来评估您的估计器或搜索最佳超参数。包括RandomizedSearchCV 或cross_validate 在内的流行模块可以选择通过类似KFold的交叉验证方法。通过利用交叉验证方法来测量估计器的性能，您的数据被分成一个训练集和一个测试集。这是在 sklearn 方法下动态完成的。
这通常是好的，这意味着你不需要过多的麻烦。当您想要将扩充数据用于交叉验证方法时，只有一个问题——您不希望在您的测试文件夹中有扩充数据。这是为什么呢？你想知道你的估计器在现实中表现如何，而你的增广数据并没有反映现实。此外，您希望只增加训练集中的数据，而不希望在训练文件夹中增加数据。
如何只在需要扩充的地方扩充
回到问题，在你的交叉验证中，有没有可能影响训练测试拆分？是的，imblearn.pipeline.Pipeline 来救援了。这个管道类似于你可能从 sklearn 了解到的管道，你可以在一个所谓的管道中链接处理步骤和估计器。对我们来说，的巨大差异和优势在于它在交叉验证中的工作方式。它只在列车上运行！
这是一个好消息，但是您仍然需要定义一个方法来丰富您的原始数据并在管道中传递它。最简单的方法是使用 imblearn 的FunctionSampler 将任何函数转换成可以在管道中传递的采样器。imblearn 网站上有大量的文档。但是，也许你想做一些更复杂的事情，并建立自己的采样器。这就是 sklearn 的BaseEstimator 发挥作用的地方，它是一个定制估算器的基类。我们可以用它来构建我们的采样器。
import pandas as pd
from sklearn.base import BaseEstimatorclass EnrichWithAugmentedData(BaseEstimator):
"""
Resampler to pass augmented data in a imblearn pipeline
In this example I pass a list of augmented data frames with identical endpoints y to be merged with the original data X
"""
def __init__(self, augmented_sets):
self.augmented_sets = augmented_sets
def fit_resample(self, X, y):
return self.resample(X, y)
def resample(self, X, y):
self.data = []
for i, df in enumerate(self.augmented_sets):
self.data.append(self.augmented_sets[i].copy())
for i, df in enumerate(self.data):
self.data[i] = self.data[i].loc[X.index, :]
X = pd.concat([X, *self.data], axis=0)
n = len(self.data) + 1
y = pd.concat([y]*n, axis=0)
return X, y# Feel free to comment my code, I am a physicist :D
现在，我们可以使用我们的采样器来构建具有任何估计器的管道:
from xgboost import XGBClassifier
from imblearn.pipeline import Pipelineaugmented_sets = [df_augmented_01, df_augmented_02]model = XGBClassifier()
ewad = EnrichWithAugmentedData(augmented_sets)
pipeline = Pipeline([('ewad', ewad), ('model', model)])
假设我们想利用管道中的RepeatedStratifiedKFold 进行一次RandomizedSearchCV:
cv = RepeatedStratifiedKFold(
n_splits=5,
n_repeats=10,
random_state=101
)# make sure that you have the suffix with the name of your pipeline step in front of your parameter name!
parameter_grid = {
'model__max_depth':[2, 3, 4],
'model__learning_rate':np.arange(0.005, 0.5, 0.05),
}# make sure that you do not refit, because the refit will be without your augmented data!
gs = RandomizedSearchCV(
estimator=pipeline,
n_iter=3000,
param_distributions=parameter_grid,
scoring='roc_auc',
n_jobs=-1,
cv=cv,
verbose=1,
random_state=101,
refit=False
)
grid_result = gs.fit(X, y)print("Best: {:.2f} using {}".format(
grid_result.best_score_,
grid_result.best_params_
))
您也可以用cross_validate使用相同的程序，用pipeline.steps[1][1]获得最佳模型和特征重要性，作为特征选择方法。如果您使用扩充数据进行训练，那么它很有可能会影响评估者选择的特征。
我希望这篇文章能帮助一些数据科学家同行。
用 Akka 流丰富 OCR
马丁·桑切斯在 Unsplash 上的照片
Tesseract 文档列出了一些预处理步骤以获得更好的 OCR 结果。由于我不知道如何执行这些步骤，所以我决定创建一个可插拔的流架构，以便在进行过程中添加它们。在 Akka Streams 世界中，这最终看起来像一个带有 sub Flow[Mat]的Flow[BufferedImage]——其中 Mat 是一个 OpenCV 构造。然后将BufferedImage传递给宇宙魔方，宇宙魔方返回一个字符串。这就是我们在 OCR 与 Akka、Tesseract 和 JavaCV 中讨论的内容。这篇文章着眼于获取 OCR 结果，并通过几个处理阶段来丰富它。
先前系统的图示
如果你想继续的话，所有的代码都已经在 Github Repo 中更新了！
理解这篇文章不需要上一篇文章。它只是用来显示我们是如何得到 OCR 文本结果的。
快速洞察
以上给了我一些不错的结果，但如果能看到图像随着每个阶段的变化会更好。计划是连接一个ImageSink将图像写入文件。
当我们运行应用程序并上传样本文件时，我们可以在项目的根目录中看到预处理的 3 个不同阶段:
原始、二进制、增强、消除倾斜
从 Tesseract 的 OCR 过程返回的文本是:
CHAPTER 1 THE COMPOUND EFFECT IN ACTION You know that expression, “Slow and steady wins the race”? Ever heard the story of the tortoise and the hare? Ladies and gentlemen, I’m the tortoise. Give me enough time, and I will beat virtually anybody, anytime, in any competition. Why? Not because I’m the best or the smartest or the fastest. I’ll win because of the positive habits I’ve developed, and because of the consistency J use in applying those habits. I’m the world’s biggest believer in consistency. I'm living proof that it’s the ultimate key to success, yet it’s one of the biggest pitfalls for people struggling to achieve. Most people don’t know how to sustain it. I do. Ihave my father to thank for that. In essence, he was my first coach for igniting the power of the Compound Effect. My parents divorced when I was eighteen months old, and my dad raised me as a single father. He wasn’t exactly
通过扫描，我们可以看到两个错误，consistency **J** use in applying和**Ihave** my father to thank。不错的成绩！但是，让我们通过更多的处理阶段来运行 OCR 结果，从而变得更加智能；拼写检查、自然语言处理和日期提取。😎
OCR 后处理
我们的 OCR 流程将变成:
新的 OCR 后处理阶段
拼写检查
首先，我们将添加一个拼写检查器。我在这里买了 100 本英语词典。我们可以将它们添加到我们的资源目录中，并创建这个拼写特征:
我们确保我们的主要对象扩展了这一特性:
object Main extends App with OCR with Spell
现在我们可以添加一个遵循Flow[String]协议的拼写检查方法。它删除换行符、大部分标点符号，并过滤拼写错误的单词。对于每个拼写错误的单词，我们会添加一个建议列表。
如果你运行 OCR 应用程序(sbt run)并上传一张图片，你会看到潜在的拼写错误和建议列表。对于上面的图像，我们得到以下结果:
{
**"ocr"**:"...",
**"suggestions"**:[
{
**"Ihave"**:["Have", "Shave", "I have"]
}
]
}
命名实体识别
接下来，我们将添加一个阶段来尝试和识别命名实体，特别是人。对于 NLP，我们将按字符进行标记，但是让我们也添加一个句子模型。我们使用以下模型创建 NLP 特征:
我们的主要对象也扩展了 NLP…
object Main extends App with OCR with Spell with NLP
我们现在可以建造我们的提取者Flow。注意，这个流接收一个类型的OcrSuggestions，输出一个OcrSuggestionsPersons类型。该类型与OcrSuggestions相同，但也包含一个“Persons”字符串列表。
我们已经构建了 3 个附加流中的 2 个，最后需要添加一些数据提取:
日期提取
从文本中提取日期有许多选择。我决定使用 Natty ，但对试用 diggamma . ia 的 timeextractor 很感兴趣。
我决定使用 OpenNLP 将 Tesseract 返回的整个文本拆分成句子，然后将这些句子传递给 Natty。让我们来看看我们简单整洁的特点:
我们和我们的主要目标结合得很好
object Main extends App with OCR with Spell with NLP with Natty
然后我们可以构建一个Flow，它接受一个OcrSuggestionsPersons类型并输出一个OcrSuggestionsPersonsDates类型:
我们现在已经完成了 OCR 流程！
最终 OCR 流程
我们对上图的最新回应是:
{ **"suggestions"**:[{
**"Ihave"**:["Have", "Shave", "I have"]
}],
**"persons"**:["Ladies"],
**"dates"**:[[
["Wed Aug 11 16:20:57 PDT 2021"],
"eighteen months"
]]}
我们可以看到，Natty 将“十八个月”解析为“从现在起十八个月”NLP 将“女士”标记为人称代词。我们可以争论这些元数据有多有用，但最终它比我们以前拥有的数据更多。
如果你上传一张图片，同时我们的应用程序的网页在 http://localhost:8080，运行，你会看到我高亮显示的各种结果的 HTML:
让我们尝试不同的图像…
如果你能说出这本书的名字，加分:)
这会产生以下内容作为 JSON 响应的一部分:
**"persons"**:["Gamble","Duncan"],
**"dates"**:[["Tue Feb 11 12:00:00 PST 2020"], "afternoon"]
我们的简单网页上的输出如下:
OpenNLP 决定将“Duncan”和“Gamble”标记为 people，Hunspell 将“go-getters”标记为潜在的拼写错误，Natty 决定“午后”是 2020 年 2 月 11 日这一天的午后。
😎希望你喜欢这第二个帖子！和往常一样，所有代码都在 Github Repo 中进行了更新。
用位置信息丰富 shapelets 用于时间序列分类
一个简洁的技巧如何提高预测性能和可解释性。
时间序列分类
许多现实世界的流程会随着时间的推移产生数据，从而产生时态数据或时间序列。与表格数据相反，相邻观测值(即时间上接近的观测值)高度相关，在分析时间序列时需要特别的努力。可以对时间序列执行的一个可能的任务是对它们进行分类。示例用例包括基于加速度计数据的表面检测、基于用电量的电气设备类型分类或基于轮廓信息的树叶类型分类。
使用加速度计数据的 X 轴检测机器人(索尼 AIBO)行走的表面。图片取自http://www.timeseriesclassification.com/description.php?dataset = sonyaiborobotsurface 1
Shapelets
Shapelets 是小的子序列，或者时间序列的一部分，对于某个类是有信息的或者有区别的。通过计算要分类到 shapelet 的每个时间序列的距离，它们可用于将时间序列转换为要素。
从 ItalyPowerDemand 数据集中提取两个 shapelets，以便将时间序列转换到二维特征空间。特征空间中的每个轴代表到两个 shapelets 之一的距离。可以看出，使用这两个 shapelets 已经可以实现良好的线性分离。
位置信息
Guillemé等人最近发表了“局部随机 shape let”，其中他们提出了一种提取 shape let 的方法，可用于创建由基于距离的特征和基于位置的特征组成的特征矩阵，从而获得更好的预测性能。
他们提出的技术将挖掘 K 个 shapelets，以便将 N 个时间序列转换成 N×2K 特征矩阵。该特征矩阵包括到每个小形状的距离(d(Ti，Si))和位置(l(Ti，Si))。
每个时间序列的特征通过在时间序列上滑动 shapelet 并计算每个位置的 shape let 到时间序列的欧几里德距离来计算。最后，返回最小距离和相应的位置。指定的距离和位置纯粹是概念上的，远非精确。
GENDIS:有效地提取精确的 shapelets
我们扩展了我们的技术，GENDIS(shape let 的基因发现)来提取除了到 shape let 的距离之外的位置信息。由于 GENDIS 是一种遗传算法，它可以优化任何东西(它的目标函数不需要可微)。因此，这需要最少的努力，但初步的实验表明，预测性能显著提高。通过这一新的更新，GENDIS 能够提取非常容易解释的 shapelets，并能够在输入机器学习分类器时实现最先进的预测性能。此外，与实现类似性能的技术相反，GENDIS 不需要执行强力搜索，并且不需要调整 shapelets 的数量和相应的长度。
让我们通过创建一个位置信息是关键区别属性的人工数据集来演示新功能(因为两个类的模式是相同的):
生成的时间序列。这两个类的模式是相同的。区分这两个类的唯一方法是使用发现模式的位置。
我们使用这两个版本提取 shapelet，并测量我们使用具有逻辑回归分类器和默认超参数的单个 shape let 所能达到的准确度。旧版本只能达到 81%的准确率，而新版本达到 100%的准确率。我们还在三个较小的数据集上快速比较了新版本和旧版本，每一次，位置信息都显著提高了准确性。
shapelets 的可解释性
shapelets 最有趣的特性之一是它们非常容易解释。提取的 shapelets 可以很容易地呈现给领域专家，以显示时间序列的哪些部分被准确地使用，以便做出决定。此外，通过优化小形状的位置和距离信息，提取的小形状也更容易解释。没有位置信息，GENDIS 和相关技术，如学习时间序列 Shapelets ，能够经常“破解”那里的位置信息。Guillemé等人在他们的论文中证明:
在上面的图像中，我们看到一个长时间序列(浅蓝色)，对应于地震读数，以及由 LS 学习的 shapelets，它不包含位置信息，以彩色显示。提取的 shapelet 确实实现了优秀的预测性能，但是与原始时间序列没有任何关系，使得它们难以解释(它们位于从时间序列到 shape let 的距离最小的位置)。另一方面，对位置信息进行编码的 LRS 实现了出色的预测性能，并提取了与原始时间序列非常相关的 shapelets(正如我们可以看到的，彩色子序列与原始浅蓝色时间序列非常匹配)。
这篇短文到此结束！通过扩展我们的 shapelet 提取框架，除了提取到每个 shape let 的距离之外，还提取位置信息，我们能够以有限的努力在预测性能方面获得一些显著的收益！
如果您对 shapelets 有更多问题，或者您有一个涉及时间序列分类的用例？与我们取得联系！
来源
[1] 叶，李，&等(2009 年 6 月)。一种新的数据挖掘原语。第 15 届 ACM SIGKDD 知识发现和数据挖掘国际会议论文集*。* 【2】Lines，j .，Davis，L. M .，Hills，j .，& Bagnall，A. (2012，8 月)。用于时间序列分类的 shapelet 变换。第 18 届 ACM SIGKDD 知识发现和数据挖掘国际会议论文集*。*
【3】格拉博卡，j .，席林，n .，威斯特巴，m .，&施密特-蒂梅，L. (2014 年 8 月)。学习时序 shapelets。第 20 届 ACM SIGKDD 知识发现和数据挖掘国际会议论文集*。*
【4】m .吉列梅，s .马林诺夫斯基，r .&x .勒纳尔(2019，9 月)。局部随机形状。在时态数据高级分析和学习国际研讨会上。斯普林格，查姆。
【5】范德维尔(Vandewiele，g .)，翁格纳内(Ongenae，f .)，&德图尔克(De Turck，f .)(2019)。GENDIS:身材的基因发现。 arXiv 预印本 arXiv:1910.12948 。
www.timeseriesclassification.com
基于 OptimalFlow 的机器学习集成特征选择
用简单的代码选择顶级特性的简单方法
特征选择是机器学习工作流的关键部分。特征选择的好坏直接关系到模型的性能。数据科学家通常会遇到两个难题:
- 哪种特征选择算法比较好？
- 需要保留输入数据集中的多少列？
因此，我编写了一个名为 OptimalFlow 的 Python 库，其中包含一个集合特征选择模块，名为 autoFS 以轻松简化这一过程。
OptimalFlow 是一个 Omni-ensemble 自动化机器学习工具包，它基于流水线簇遍历实验(PCTE) 方法，帮助数据科学家以简单的方式构建最优模型，并使用简单的代码自动化机器学习工作流。
为什么我们使用 OptimalFlow ？你可以读另一个关于它的介绍的故事:一个全方位的自动化机器学习——optimal flow。
autoFS 模块将通过流行的特征选择算法(选择器)，如 kBest、RFE 等。并且选择从它们的输出中选择的多数特征作为最重要的特征。以下是 autoFS 模块和默认选择器的详细链接:
您可以阅读optimal flowoptimal flowautoFS模块的 文档。此外， OptimalFlow 还提供了特征预处理、模型选择、模型评估、流水线簇遍历实验(PCTE) 自动化机器学习模块。
这里我们将有一个演示，使用 OptimalFLow ，在几分钟内完成一个回归问题的特征选择。我们使用经典的波士顿住房数据集作为输入。
第一步:安装 OptimalFlow :
*pip install optimalflow*
第二步:导入 OptimalFlow 模块:
*import pandas as pd
from optimalflow.autoFS import dynaFS_reg*
第三步:导入输入数据集:
*tr_features = pd.read_csv('./data/regression/train_features.csv')
tr_labels = pd.read_csv('./data/regression/train_labels.csv')*
我们使用波士顿住房数据集作为输入文件，它有 506 行和 14 列。你可以在这里找到关于它的细节。
波士顿住房数据集 train _ features.csv
波士顿住房数据集 train _ labels.csv
第四步:运行 autoFS 模块:
我们希望为进一步的建模过程提供前 5 个重要特征。我们使用的是 autoFS 的默认选择器，但是你也可以通过它的 custom_selectors 属性自定义设置你只想通过的选择器。
**# Set input_form_file = False, when label values are array. Select 'True' from Pandas dataframe.*
reg_fs_demo **=** dynaFS_reg**(** fs_num **=** **5,**random_state **=** **13,**cv **=** **5,**input_from_file **=** True**)**
*# You can find details of each selector's choice in autoFS_logxxxxx.log file in the ./test folder*
reg_fs_demo**.**fit**(**tr_features**,**tr_labels**)***
一切就绪！以下是输出结果:
******optimalflow***** autoFS Module **===>** Selector kbest_f gets outputs**:** **[**'INDUS'**,** 'NOX'**,** 'RM'**,** 'PTRATIO'**,** 'LSTAT'**]**
Progress**:** **[***###-----------------] 14.3%*
*****optimalflow***** autoFS Module **===>** Selector rfe_svm gets outputs**:** **[**'CHAS'**,** 'NOX'**,** 'RM'**,** 'PTRATIO'**,** 'LSTAT'**]**
Progress**:** **[***######--------------] 28.6%*
*****optimalflow***** autoFS Module **===>** Selector rfe_tree gets outputs**:** **[**'CRIM'**,** 'RM'**,** 'DIS'**,** 'TAX'**,** 'LSTAT'**]**
Progress**:** **[***#########-----------] 42.9%*
*****optimalflow***** autoFS Module **===>** Selector rfe_rf gets outputs**:** **[**'CRIM'**,** 'RM'**,** 'DIS'**,** 'PTRATIO'**,** 'LSTAT'**]**
Progress**:** **[***###########---------] 57.1%*
*****optimalflow***** autoFS Module **===>** Selector rfecv_svm gets outputs**:** **[**'CRIM'**,** 'ZN'**,** 'INDUS'**,** 'CHAS'**,** 'NOX'**,** 'RM'**,** 'AGE'**,** 'DIS'**,** 'RAD'**,** 'TAX'**,** 'PTRATIO'**,** 'B'**,** 'LSTAT'**]**
Progress**:** **[***##############------] 71.4%*
*****optimalflow***** autoFS Module **===>** Selector rfecv_tree gets outputs**:** **[**'CRIM'**,** 'CHAS'**,** 'NOX'**,** 'RM'**,** 'AGE'**,** 'DIS'**,** 'TAX'**,** 'PTRATIO'**,** 'B'**,** 'LSTAT'**]**
Progress**:** **[***#################---] 85.7%*
*****optimalflow***** autoFS Module **===>** Selector rfecv_rf gets outputs**:** **[**'CRIM'**,** 'ZN'**,** 'NOX'**,** 'RM'**,** 'AGE'**,** 'DIS'**,** 'RAD'**,** 'TAX'**,** 'PTRATIO'**,** 'B'**,** 'LSTAT'**]**
Progress**:** **[***####################] 100.0%*
The optimalflow autoFS identify the top **5** important features **for** regression are**:** **[**'RM'**,** 'LSTAT'**,** 'PTRATIO'**,** 'NOX'**,** 'CRIM'**].***
您会发现[‘RM ‘，’ LSTAT ‘，’ PTRATIO ‘，’ NOX ‘，’ CRIM’]列是为我们选择的五大功能 autoFS ！简单容易，对吧？
关于 OptimalFlow 的相关阅读:
集成模型选择&使用 OptimalFlow 在机器学习中进行评估——使用简单代码选择最佳模型的简单方法
端到端 OptimalFlow 自动化机器学习教程结合真实项目-公式 E 圈数预测第 1 部分
关于我:
我是一名医疗保健和制药数据科学家以及大数据分析和人工智能爱好者。我开发了 OptimalFlow 库，帮助数据科学家以简单的方式构建最优模型，用简单的代码实现机器学习工作流程的自动化。
作为一名拥有多年分析经验的大数据洞察寻求者、流程优化者和人工智能专家，我使用数据科学中的机器学习和问题解决技能将数据转化为可操作的洞察，同时提供战略和量化产品作为最佳结果的解决方案。
你可以在我的 LinkedIn 或者 GitHub 上和我联系。
在 3 分钟内解释集成学习、打包和增强
直观的解释和揭开基本概念的神秘面纱
作者创建的图像
在之前的另一篇文章中，我解释了什么是 bootstrap sampling 以及它为什么有用。如果你不知道什么是 bootstrap 抽样，我建议你看看我写的关于 bootstrap 抽样的文章，因为这篇文章将建立在它的基础上！
当您开始数据科学之旅时，您肯定会听说“集成学习”、“打包”和“助推”。因为我没有任何指导或方向，我花了一段时间才明白装袋和助推实际上是什么意思。因此，我的目标是尽可能简单直观地解释这些术语！
什么是集成学习？
集成学习是一种多种学习算法联合使用的方法。这样做的目的是让您获得比单独使用单个算法更高的预测性能。
例 1:“三个臭皮匠胜过一个诸葛亮”
作者创建的图像
一种简单的思考方式是，如果一个人在解决一个数学问题，而一群人在解决一个数学问题。如果一个人解决了错误的问题，他/她将没有其他人来检查他/她的答案。另一方面，这群人可以协作解决，互相寻找对方的错误，并对最终答案进行投票。
示例 2:随机森林
随机森林是一种基于决策树的集成学习技术。随机森林涉及使用原始数据的自举数据集创建多个决策树。然后，该模型选择每个决策树的所有预测的模式(大多数)。这有什么意义？依靠“多数获胜”模型，它降低了单个树出错的风险。
例如，如果我们创建一个决策树，第三个，它会预测 0。但是如果我们依赖所有 4 个决策树的模式，预测值将是 1。这就是集成学习的力量！
现在你知道什么是集成学习，让我们来介绍两种流行的集成方法:bagging 和 boosting。
什么是装袋？
Bagging 又称 bootstrap aggregating ，是用原始数据集的自举样本对同一学习算法的多个模型进行训练的过程。然后，像上面的随机森林示例一样，对所有模型的输出进行投票。
装袋过程
什么是助推？
Boosting 是 bagging 的一种变体，其中每个单独的模型都是按顺序构建的，并迭代上一个模型。具体来说，任何被前一个模型错误分类的数据点都会在后一个模型中得到强调。这样做是为了提高模型的整体准确性。这里有一个图表，可以更好地理解这个过程:
一旦建立了第一模型，除了第二自举样本之外，还采用错误分类/预测的点来训练第二模型。然后，针对测试数据集使用集合模型(模型 1 和 2 ),并且该过程继续。
而这就是合奏学习的精髓，装袋，助推！
感谢阅读！
如果你想学习更多的机器学习基础知识，了解我的最新内容，你可以在这里学习。
特伦斯·申
- 查看 我的免费数据科学资源 每周都有新素材！
- 如果你喜欢这个， 在 Medium 上关注我 了解更多
- 我们来连线上LinkedIn
从零开始的集成学习
引入集成学习，这是一种通过组合训练好的模型来提高性能的强大工具。
图片来自来源。
对于许多数据科学和应用机器学习的初学者来说，找到符合手头数据的最佳模型通常意味着尝试尽可能多的合理选项，保留最佳模型，而其余的则被丢弃。集成学习提供了一种替代方案，即通过所有经过训练的模型形成一个集成，其性能可以与最好的模型一样好，如果不是更好！
集成学习力量的一个合法代表是随机森林，在本文中，我们将揭示一些可以用来建立集成模型的方法，并直观地解释其背后的原理。
本文的结构遵循 第 7 章--集成学习与随机森林 ，出自 **用 Scikit-Learn 的动手机器学习，Keras 和 TensorFlow，第 2 版，作者 Aurélien Géron (O’Reilly)。
大数定律
“三个臭皮匠，顶个诸葛亮”
当我第一次看到大数定律时，我在学校里学到的这句古老的中文谚语突然出现在我的脑海里。它解释了被称为群众的智慧——一大群人的集体智慧可能比一个专家的智慧更好。
集成学习通过组合独立的模型(称为预测器)来应用该定理，以形成强学习器(实现高精度)。它甚至在所有预测者都是弱学习者时也能工作(表现仅比随机猜测稍好)。
“用 Scikit-Learn、Keras 和 TensorFlow 实践机器学习，第二版，作者 Aurélien Géron (O’Reilly)。”，第七章。
但是为什么会这样呢？群众的智慧可能听起来很“聪明”，但它仍然有点违反直觉。为了回答这个问题，下面的类比可能有助于揭示这个秘密:假设你投掷一枚略有偏差的硬币，有 51%的机会正面朝上。如果你做 100 次，不太可能会有正好 51 个头，甚至有可能你最后没有多数个头。但随着你不断折腾，你会观察到人头的比 会越来越接近 51% 。您进行的试验越多，平均****值就越接近预期值**，获得多数人头**的概率就越大。
集成学习在本质上做着同样的事情——弱学习者在分类任务中只有微小的机会预测正确的类别，但是如果我们使用许多独立的预测器做出同样的预测，聚集的结果将更有可能预测正确的类别。
集合模型的输出是关于分类任务时最频繁的预测**。对于一个回归任务，使用平均值代替。**
集成方法
训练一个集成时的关键要素是，它的所有分类器必须完全独立，这可以通过使用不同的算法来实现，或者使用相同的算法，但在训练集的不同子集上进行训练。在这里，我们探索这两种方法来构建集成分类器。
“用 Scikit-Learn，Keras & TensorFlow 进行动手机器学习”，第 7 章。
1.投票分类器
训练不同的预测器算法以形成集成被称为投票分类器**，其机制很简单——一组不同的算法在同一个训练集上训练，当进行预测时，集成的输出被聚集，取最多投票的类别作为集成的预测。**
当通过每个预测器的输出类进行聚合时，称为硬投票**，当使用输出概率时，称为软投票。软投票通常表现更好，因为它捕捉了更多的细微差别(逻辑上它要求所有的预测器都能够输出概率)。**
2.装袋和粘贴
另一方面，代替训练不同的算法来实现多样性**，一个替代方案是使用相同类型的预测器，但是在训练集的不同随机采样子集上进行训练。**
装袋和粘贴是对这些子集进行抽样的两种不同方式，它们的区别在于有无替换的抽样。
当通过打包**(带替换)进行采样时，随机选择一个实例并立即将其返回给训练集，因此在每次选择时，源数据仍具有其所有实例，并且可以再次选择相同的实例。粘贴反过来，同一个实例不能在同一个子集中出现超过一次。**
对于打包和粘贴，同一个实例可以出现在不同的子集中，但是只有打包允许同一个实例在同一个子集中出现两次或更多次**。由于所有子集都具有相同大小的**，具有替换的采样可以实现更多的子集多样性**，并且它们对应的预测器将更少相关。这种方法的另一个优点是，每个预测器都有不在它们的训练子集中的实例，它们可以直接用于验证，而不必保存验证数据。******
随机森林是集成学习器家族的著名成员，它由一组在不同子集采样 到 打包上训练的决策 树(与训练集大小相同)。当分割给定的节点时，所使用的特征是从随机生成的特征子空间中选择的最合适的一个，而不是从所有可用特征的空间中选择的。多余的 树，各种随机森林，更进一步——不仅特征来自随机选择的子空间，而且使用的阈值也是**随机生成的**。****
3.增强——连续训练
增强使用与之前相同的预测器用于集合，但不是在并行中采样不同的** 子集和训练预测器，而是顺序完成，每个预测器试图纠正其前任的错误。******
再来看看 AdaBoost 和渐变提升。
— AdaBoost
当对集合中给定的预测器进行训练时，算法对实例权重进行重新加权，使得错误分类的实例能够从下一个预测器获得更多的 关注 ，并且有希望将其正确分类。实例权重定义了实例被选择为子集的一部分的机会-给定实例的实例权重越高，越多， 可能它会在采样时出现在子集中。****
AdaBoost Algorithm:1\. Set the initial **instance weights**(w)to *1/m*, with *m* being the number of training instances in the training set.2\. Compute the **predictor weight**(⍺) of the current predictor using its **weighted error rate**(r).
3\. To train the next predictor, the instance weights are updated.
4\. Finally, a new predictor is trained using the updated weights, steps 2 to 4 are repeated until the number of predictors is reached or a perfect predictor is found.
在推断时间期间，集合的预测是其输出的加权 平均值。使用的权重是步骤 2 中的预测权重。作为随机猜测的，预测器是执行更好、更差还是确切地说 决定了其对集合预测的贡献的类型:
—梯度增强
梯度 增强处理训练迭代作为 AdaBoost，但是每个预测器不是调整实例权重，而是通过拟合其残差 误差来校正其前任。
但是为什么要拟合残差呢？假设我们正在用 N 预测器*训练一个集成模型。*对于每个预测器 P n ，1<N<N，我们假设它是不完美的，它的性能可以通过增加一个估计器 h 来改善:
现在，为了找到 h ，我们先来看看一个完美的 h 应该是怎样的:
一个完美的估计器将填充目标和当前预测【Pn(x)之间的*。本质上，它试图通过插入一个额外的预测器来使最小化一个成本 功能。*****
4.立桩标界
图片来自来源。
完成拼图的最后一块是立桩。如果我们训练 一个 模型来为我们做这件事，而不是使用一个给定的函数来处理预测器的输出，会不会增加 的准确性？答案是是的。这些模型通常被称为混音器，它们可以找到方法校正和组合合奏的输出，以实现增强的 性能。
训练搅拌机的常见方法是首先将训练数据分成训练集和保持集。第一种用于训练预测器，采用任何上述方法。然后，坚持组用于训练搅拌机。当预测器被训练时，我们将它们的预测放在保留集上，并将其用作混合器的输入。如果集合中有 N 个预测值，那么混合器将在一个N维数据加上原始目标上被训练。**
当完成训练时，混合器被期望获得集合的输出，并且以最大化整体模型的准确性的方式’ 混合 '它们。
最后的话
你已经坚持到最后了！我希望你能愉快地阅读这篇文章，也希望你能对合奏 学习有所了解。这是一个强大的工具，关于它的写作帮助我巩固了对这个话题的许多理解。它仅仅触及了集成学习的基础理论的表面，并且没有给出实际的实现。我强烈推荐浏览 这篇文章 来自 机器学习掌握 ，它带你浏览如何从开始构建一个超级工薪族合奏(堆叠)**！**
集成学习技术
合奏可以让事情变得简单
图片来源:pixabay
当你在读这篇关于集成学习的文章时，我希望你至少熟悉一些机器学习模型及其实现。当我们在任何数据集上训练 ML 模型时，我们都面临着称为偏差和方差的错误同伴。大多数时候，要么我们没有得到令人满意的精度结果，要么数据过度拟合到模型中。然后我们再次调整数据，创建/删除特征，重新训练模型，这个过程可以重复几次。在接下来的几节中，我将解释什么是集成学习，它如何与偏差和方差相关，以及什么是集成学习的技术。
什么是集成学习？
集成学习是一个过程，其中多个基本模型(最常被称为“弱学习者”)被组合和训练来解决同一问题。该方法基于这样的概念，弱学习者单独执行任务很差，但是当与其他弱学习者结合时，他们形成强学习者，并且这些集成模型产生更准确的结果。
这就是集成学习方法在许多在线比赛中最常被信任的原因。
集成学习是一种结合多种机器学习算法来产生一个最佳预测模型的技术，该模型具有降低的方差(使用 bagging)、偏差(使用 boosting)和改进的预测(使用 stacking)。
带有偏差和方差的集成学习关系
最大似然模型的预测误差是下列各项之和
1。偏差误差 —偏差是模型预测结果与实际结果之间的差异。高偏差意味着模型拟合不足。因此，我们必须使用更复杂的模型。
2。方差误差 —方差是模型对训练数据中微小波动的敏感度。高方差意味着模型过度拟合。因此，我们必须获得更多的训练数据(如果训练数据较少)或使用不太复杂的模型(如果该模型的数据简单)
3。噪声通常被称为不可约误差
以平衡的方式管理偏差和方差是集成学习的核心，这可以通过使用多种模型(简单和复杂模型的混合)并在不欠拟合或过拟合数据的情况下组合它们来完成。
简单的集成学习方法
基于投票和平均的集成方法是非常简单和最容易的集成学习形式。投票用于分类问题，平均用于回归问题。
- 平均
顾名思义，在这种技术中，我们取所有模型预测的平均值。
例如，如果我们预测房价，如果有 3 个基础模型预测房价为 45 万，50 万，55 万。对于平均，我们取平均值为(450000+500000+550000)/ 3 = 500000，这是最终预测。
让我们看看代码:
现在，为了证明集成(或平均预测)是否比基础模型做得更好，我们将比较基础模型和最终模型的平均绝对误差。
Average Ensembler Mean Absolute Error: 0.48709255488962744
KNN Mean Absolute Error: 0.5220880505643672
Lasso Mean Absolute Error: 0.7568088178180192
SVR Mean Absolute Error: 0.5015218832952784
集成模型的平均绝对误差远小于单个模型。
2。最大投票分类器
最大投票与平均投票非常相似，唯一的区别是它用于分类问题。在这种技术中，来自多个模型的预测被收集(这通常被称为投票),并且来自大多数模型的预测被认为是最终预测。
例如， 如果从多个模型得到的一组最终房价预测值分别为— 50 万、45 万、60 万、45 万、65 万、45 万、60 万。然后使用最大投票分类器，最终预测将是 450000。
Max Voted Ensembler Accuracy: 72.0
KNN Accuracy: 67.2
Logistic Regression Accuracy: 74.4
SVC Accuracy: 70.39999999999999
Sklearn 库有一个用于 Max Voting 的类，叫做 VotingClassifier，你可以在这里传递分类器列表，它会选择 max voted 预测。让我们看看代码-
Sklearn Max Voting Classifier Accuracy: 72.0
3。加权平均
加权平均是平均的延伸。在平均中，所有基础模型被赋予同等的重要性，但是在该技术中，具有较高预测能力的基础模型被赋予比其他基础模型更大的重要性/更高的权重。
模型的权重是总和等于 1 的十进制数。
例如， 如果 3 个模型预测房价为 45 万，60 万，65 万。并且这些模型的权重为 25%、50%和 25%，则最终预测将是-
0.25 * 450000+0.50 * 600000+0.25 * 650000 = 575000
Weightage Average Ensembler Mean Absolute Error: 0.46186097145642674
KNN Mean Absolute Error: 0.5220880505643672
Lasso Mean Absolute Error: 0.7568088178180192
SVR Mean Absolute Error: 0.5015218832952784
结论
正如我们在上面的例子中看到的，简单的集成技术可以减少误差，并在最终的预测中产生巨大的差异。在下一篇文章中，我将分享一些先进的合奏技术，如装袋、助推和堆叠。
要访问简单合奏技术的完整代码，请查看这个 Github 链接。
谢谢你的阅读。如果你喜欢这个故事，请喜欢，分享和关注更多这样的内容。如往常一样，请联系我们以获得任何问题/评论/反馈。
Github:https://github.com/charumakhijaniLinkedIn:https://www.linkedin.com/in/charu-makhijani-23b18318/
集合机器学习:群体的智慧
尼古拉斯·格林在 Unsplash 上的照片
假设你想买一部新手机。你不太可能走进一家商店只买一部手机。你在网上浏览产品，阅读评论，比较型号，价格。你征求家人和朋友的意见。简而言之，在做出明智的决定之前，你要进行大量的研究，寻求大众的智慧。众所周知，收集各种观点和意见可以改善决策过程。
什么是集成学习？
照片由 Clarisse Croset 在 Unsplash 上拍摄
整体机器学习的运作方式类似于图中所示的移动购买体验。它是一种结合多种方法的决策以产生最佳结果的技术。传统机器学习技术中误差的主要原因是噪声、偏差和方差。集成机器学习有助于最小化这些错误，提高稳定性和准确性。
基本集成技术
- 模式:在这种技术中，使用多个模型进行预测。每个模型的预测都被视为单独的投票。获得最多票数的人将作为结果。回到手机购买体验，我们寻求对多个手机的评论——苹果、三星、诺基亚、Moto G。获得最多票数的手机就是赢家。
图片来源:克里希南·斯里纳斯
2。Mean: 在这种技术中，我们从多个模型中获取预测的平均值，并使用它们来进行最终预测。回到手机购买体验，我们将多部手机的评分相加，并根据我们征求意见的人来划分数字。
均值=(不同人的评分总和)/(人数)
**3。加权平均值:**这是平均法的扩展。所有模型被赋予不同的权重，定义每个模型对于预测的重要性。例如，你给那些有更多手机使用经验的人更多的权重，而给那些没有手机使用经验的人更少的权重。
图片来源:克里希南·斯里纳斯
高级集成技术
- Bagging — Bagging 代表引导聚合。我们创建训练数据集的随机样本。然后，我们为每个样本建立一个模型(分类器或决策树)。最后，使用平均或多数投票来组合这些多个模型的结果。组合来自多个模型的输出减少了方差，产生了比单个模型更可靠的预测。
图片来源:克里希南·斯里纳斯
2.增强— 增强是一种迭代技术，它根据上一次分类调整观察的权重。如果一个观察被错误地分类，它会试图增加这个观察的权重，反之亦然。它降低了偏置误差。它受到先前建造的性能的影响。
结束语
正如肯·布兰查德的名言所说“没有人比我们所有人都聪明”。集成方法符合这一说法，利用不同方法的智慧来预测更好的结果。
感谢您的阅读。我希望你从阅读这篇文章中学到的和我写这篇文章时学到的一样多。
集成方法编码
为数据科学初学者提供的随机森林、AdaBoosting 和梯度增强方法的代码。
这是给谁的:
正如副标题所暗示的，这篇代码文章是为有兴趣制作他们的第一个更高级的监督机器学习模型的初学者准备的。也许你想知道如何提高你在 Kaggle 上的 Titanic 分数——这段代码将向你展示一种可以直接显著提高你分数的方法。
这是给那些通过 做 学得最好的人的。
我的目的是揭开机器学习应用的神秘面纱。是的，机器学习背后的理论可能相当复杂，我强烈鼓励你深入研究，让自己接触你所做和使用的事物的潜在“数学”。然而，我们都需要从某个地方开始，有时感受一下事情是如何运作的，看到结果可以激发你更深层次的学习。
我不喜欢重复在 Medium 等平台上已经饱和的内容。因此，我不会深究这些算法是如何工作的。
我将提供非常简短的*“简而言之，这是正在发生的事情”*对每种方法的解释，并将为您指出一些相关文章、博客和论文的方向(我真的鼓励您深入研究)。
先决条件:
这段代码旨在帮助您直接使用三种不同的集成方法构建机器学习模型:随机森林、AdaBoosting 和梯度增强。
我假设你对监督学习和非监督学习有一个大致的了解，并且对基本的决策树模型有一些了解。
我将使用:
- Kaggle 电信数据集中的流失
- 用于数据清理的熊猫
- sci kit-为建模而学习
我们现在要做的是:
- 快速 EDA
- 创建 4 个模型(有限状态机和 3 个集合模型)
- 比较每个模型的准确性和召回指标
集合模型:
不要想太多了—
系综模特是 系综模特！
惊呆了。
集合方法背后的思想是“群体的智慧”。我认为
“我的屁股穿这条裙子好看吗？”
我可以肯定地说
“地狱耶女孩！”
但是也许你想确定我不只是出于礼貌，所以你问了另外 5 个人，他们给了你同样的回答。在问了 20 多个人之后，你对自己很有信心(你应该这样！).
这个就是集成方法背后的思想。
集合模型通过结合大量单一模型的预测给出更好的预测。这可以通过汇总预测结果或改进模型预测来实现。出于这个原因，集合方法往往会赢得比赛。关于这一点的更多信息，请看这篇文章和这篇博客。
随机森林、AdaBoosting 和梯度增强只是我今天选择的 3 种集成方法，但还有许多其他方法！
随机森林:
随机森林是一种用于分类和回归问题的监督学习算法。
简而言之 ，随机森林算法是决策树模型的集合。
决策树算法基于在每个阶段最大化信息增益来选择其分裂，因此在同一个数据集上创建多个决策树将产生同一个树。为了使我们的集合方法有效，我们需要个体模型的可变性。随机森林算法利用装袋和子空间采样方法来创造这种可变性。
请参见 Leo Breiman 的论文和网站了解随机森林的基本细节。或者，如果你更喜欢博客/文章，请看这里。
AdaBoosting(自适应升压):
AdaBoosting 又名自适应增强，是发明的第一个增强算法，所以出于怀旧，我在这里提到它。自那以后，出现了许多基于 AdaBoosting 的 Boosting 算法，但这仍然是开始学习 boosting 算法的好地方。
简而言之 ，AdaBoost 模型在数据集的子样本上进行训练，为数据集中的每个点分配权重，并在每次模型迭代时改变这些权重。如果学习者(当前模型)正确地分类了一个点，则该点的权重减小，如果学习者错误地分类了一个点，则该点的权重增大。
点击查看更多关于 AdaBoosting 的信息。
梯度提升:
梯度增强是一种更高级的增强算法，它利用了梯度下降，您可能还记得线性回归。
简而言之 ，梯度增强以类似于 AdaBoosting 算法的方式对每个弱学习器进行改进，除了梯度增强计算每个点的残差并将其与损失函数相结合。因此，该算法使用梯度下降来最小化总损失，并使用梯度和损失作为预测器来训练下一个学习者。
好吧好吧！让我们开始有趣的部分吧！
EDA:
让我们做一些超级快速的探索性数据分析。我特意选择了这个数据集，因为当你从 Kaggle 下载它时，它已经非常干净了。但是，作为新的数据科学家，继续磨练我们的 EDA 技能对我们来说很重要。
数据问题:
正如您可能从数据集的标题中猜到的那样，该模型旨在预测客户流失，这是企业面临的一个非常常见的问题。
考虑我们想要使用哪些指标来评估我们的模型，让我们考虑我们希望我们的模型预测什么，以及什么更糟:假阴性预测或假阳性预测。
我们的模型应该预测数据集中的客户是会留在公司(False)还是会离开(True)。
在这个场景中，我们有:
假阴性: 模型预测一个客户会留在公司(
*False*)，而实际上那个客户在翻盘(*True*)。误报: 模型预测某个客户会流失(
*True*)，而实际上他们会留下来(*False*)。
鉴于此，我们可能会说，假阴性对公司来说成本更高，因为这将是一个错过的保持这些客户的营销机会。出于这个原因，我们将使用准确性和召回分数来评估我们的模型性能。*
加载和预览数据:
首先，将数据下载到您的目录这里。
进口:
import pandas as pdfrom .model_selection import train_test_split
from sklearn.metrics import accuracy_score, recall_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier
加载和预览:
df = pd.read_csv('data/raw/telecom_churn_data.csv')
df.head()
前 5 行数据
从这里我们可以看到，一行代表一个电信客户。
我们可以很快确定我们的目标变量是什么:churn。
我不喜欢列标题中的空格，所以我们将改变它，检查我们的数据类型并检查任何丢失的数据(空值)。
df.columns = df.columns.str.replace(' ', '_')
df.info()
检查列
正如我提到的，我选择这个数据集是因为它已经相当干净了。我们的数据类型是有意义的，你可以看到我们没有null值。当然，看到3333 non-null并不一定意味着我们没有空值——有时我们的数据集中有伪装的空值。我已经检查了每一列的唯一值，并且可以确认数据在这一点上看起来是完整的(当然，如果您确实发现了我遗漏的可疑之处，请务必通知我！).
创建目标和特征变量:
# our target, 'y' variable:
y = df.churn# df of our features data 'X' - drop target
X = df.drop("churn", axis=1)
处理分类特征:
你可能已经注意到我们之前的df.info()，我们有 4 个object类型的柱子。这些列中有 3 列是有用的类别:state、international_plan和voice_mail_plan。
另一个对象列是phone_number，您猜对了，这是一个客户的电话号码。我认为，一个人的电话号码不应该对他们是否决定继续使用电话公司有任何大的影响，因此，出于这个原因，我选择简单地从我们的功能集中删除这个专栏。**
# drop phone_number column
X = X.drop('phone_number', axis = 1)
因此，现在让我们虚拟出剩余的 3 个分类列。这将会给我们的特性集增加很多列，反过来也会给我们的模型增加一些复杂性，但是为了我们的例子，我们现在不会太担心这个。
# create dummy variables for categorical columns
X = pd.get_dummies(X, drop_first = True)
要了解更多关于虚拟变量、一次热编码方法以及为什么我指定了drop_first = True(虚拟陷阱)，请阅读本文。
这是一个再做一次X.head()的好机会，看看你的数据框现在是什么样子。
列车测试分离:
首先，我们将我们的X和y数据分成一个用于训练模型的训练集，和一个用于(你猜对了)测试模型的测试集。我选择在这里做一个0.25分裂。
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.25,
random_state=15)
系统模型化
在我们的建模过程中，我主要是在实例化模型对象时使用它们的默认参数。我将在最后谈到超参数调整，但简而言之，所有的乐趣都在于调整参数，所以我想让你去探索。我想重点向你展示模型是如何通过使用它们的默认值来改变的。
为了简洁起见，我将简单地拟合模型，并给出一些指标来比较每个模型。
如上所述，我们将使用accuracy_score和recall_score作为我们的衡量标准进行比较。
FSM——第一个低劣模型:单一决策树
要想知道我们的集成方法是否有效，我们首先需要知道一个单一的基础模型如何处理我们的数据。由于这是一个分类问题，我们将使用决策树作为我们的有限状态机。由于决策树有过度拟合的习惯，我将把max_depth设为 5。
# instantiate decision tree object with default params
dtc = DecisionTreeClassifier(max_depth = 5) # fit the model to our training data
dtc.fit(X_train, y_train)
结果:
精确度:
# calculate accuracy_score for training data:
print(accuracy_score(y_train, dtc.predict(X_train)))0.9559823929571829# calculate accuracy_score for test data:
print(accuracy_score(y_test, dtc.predict(X_test)))0.934052757793765
这是可疑的高，并强调了一些问题，我们有与准确性评分…
但是，就这里的准确性而言，这个模型做得并不太差，训练和测试分数之间也没有很大的差异。
# calculate recall_score for train data:
print(recall_score(y_train, dtc.predict(X_train)))0.7388888888888889# calculate recall_score for test data:
print(recall_score(y_test, dtc.predict(X_test)))0.6422764227642277
我们可以看到，训练和测试回忆分数之间的差别稍大一些。尽管如此，对于第一个模特来说，这些分数已经很不错了。
记住，对于这个问题，我们更关心召回分数，因为我们想抓住假阴性。召回是我们试图从这个模型中最大化的。
模型 2:随机森林
接下来，我们创建一个 max_depth 为 5 的随机森林模型。如果我们将n_estimators留空，一些版本的 sklearn 会发出警告，所以我在这里将其设置为 100。
# instantiate random forest classifier object
rft = RandomForestClassifier(n_estimators=100, max_depth= 5)# fit the model to the training data:
rft.fit(X_train, y_train)
结果:
精确度:
# calculate accuracy_score for training data:
print(accuracy_score(y_train, rft.predict(X_train)))0.8855542216886755# calculate accuracy_score for test data:
print(accuracy_score(y_test, rft.predict(X_test)))0.86810551558753
从我们的第一个模型开始，我们的准确度分数实际上已经下降了。让我们检查回忆:
# calculate recall_score for train data:
print(recall_score(y_train, rft.predict(X_train)))0.20555555555555555# calculate recall_score for test data:
print(recall_score(y_test, rft.predict(X_test)))0.1056910569105691
哇，我们的随机福里斯特模型的召回分数下降了！乍一看，这似乎很奇怪，但这可能是由多种原因造成的。需要记住的一个概念性原因是，单决策树模型是一个模型，而随机森林模型本质上是根据森林中所有树的投票做出最终预测的。由于这个原因，我们得到了比一棵树的‘意见’更准确的预测。
我们也没有考虑职业不平衡或者超参数，所以这个例子有点做作。
让我们以同样的方式继续，看看如何实现 AdaBoosting 和 Gradient Boosting 模型，并比较它们的性能:
模型 3: AdaBoosting
# instantiate adaboost classifier object
abc = AdaBoostClassifier(random_state = 15)# fit the model to the training data:
abc.fit(X_train, y_train)
结果:
精确度:
# calculate accuracy_score for training data:
print(accuracy_score(y_train, abc.predict(X_train)))0.8979591836734694# calculate accuracy_score for test data:
print(accuracy_score(y_test, abc.predict(X_test)))0.86810551558753
令人惊讶的是，我们对测试数据的准确性分数保持不变，但我们对测试数据的准确性分数有所提高。
回忆:
# calculate recall_score for train data:
print(recall_score(y_train, abc.predict(X_train)))0.4638888888888889# calculate recall_score for test data:
print(recall_score(y_test, abc.predict(X_test)))0.3333333333333333
与随机森林模型相比，我们的回忆分数有了显著的提高。
让我们看看梯度增强的表现。
模型 4:梯度推进
# instantiate gradient boost classifier object
gbc = GradientBoostingClassifier(random_state = 15)# fit the model to the training data:
gbc.fit(X_train, y_train)
结果:
精确度:
# calculate accuracy_score for training data:
print(accuracy_score(y_train, gbc.predict(X_train)))0.9731892757102841# calculate accuracy_score for test data:
print(accuracy_score(y_test, gbc.predict(X_test)))0.9508393285371702
目前为止我们最高的准确率。他们离我们的第一个决策树模型不远了。初步检查也没有明显的过度装配迹象。
回忆:
# calculate recall_score for train data:
print(recall_score(y_train, gbc.predict(X_train)))0.8194444444444444# calculate recall_score for test data:
print(recall_score(y_test, gbc.predict(X_test)))0.7235772357723578
再一次，这是我们目前为止最高的召回分数，这确实比我们的第一个模型好很多。
给定这 4 个模型，我们将选择梯度推进模型作为我们的最佳选择。
最后注意事项和后续步骤:
正如你所看到的，使用这些模型并不困难——我们只是简单地创建模型对象并比较结果——我们没有太深入地思考幕后发生了什么。很容易创建和试验这些不同的方法，看看哪种方法更好。
然而，应该注意的是，这是一个非常人为的例子，仅仅是为了向你展示你可以如何使用这些模型，并且集成方法通常比单一模型做得更好。由于我们使用了所有的默认参数，这些模型中呈现的指标不一定会产生有意义的影响，因此下面是开始思考和了解的一些后续步骤…
超参数调谐:
超参数是在学习过程之前设置的参数值。这不同于我们在训练模型后发现的模型参数。
如果您熟悉线性回归，那么斜率和截距参数就是我们试图通过训练模型来优化的模型参数。
我们在这个例子中调整的超参数的一个例子是当我们设置max_depth = 5时，我们在拟合模型之前设置这个*。*
我知道你可能没有接触过很多这些概念，所以随着你的接触，这些概念会变得更加清晰。但是我鼓励您尝试不同的超参数，看看模型如何随着不同的参数调整而变化。
**提示:**在 Jupyter 和其他 ide 中，任何方法或类的括号内的
shift + tab允许您快速检查对象所采用的参数。对于模型类，这将显示您可以使用的大多数超参数。
不要低估“修修补补”的价值
阶级不平衡:
我可以用一行代码来解释什么是阶级不平衡:
y.value_counts()False 2850
True 483
Name: churn, dtype: int64
正如您在这里看到的，我们将近 86%的数据被标记为False。这意味着我们的模型可能变得不公平地偏向False预测，仅仅是因为我们数据中那个标签的比率。这就是我们所说的“阶级不平衡”问题。
有很多方法可以处理职业不平衡，包括职业权重和 SMOTE。将这一点与我们的数据集一起考虑将会极大地改进我们的模型。
包扎
我希望您已经看到了这些集成方法如何改进您的模型的价值，并且我鼓励您在不同的数据集上尝试它们以获得对它们的感觉。随着您对这些算法背后的理论、它们的超参数、应用正则化和类平衡方法的了解越来越多，您将对这些功能如何发挥以及它们对您的模型有何影响有一个良好的开端。
快乐学习！
脚注
- *有些人可能会说，误报对公司来说也是昂贵的，因为你在留住客户上花了钱，而客户无论如何都会留下来。我让您来思考这个问题，并尝试不同的评分标准。这里有一篇文章介绍了您可以研究的一些不同指标。
- **我让您来探索您可能想要如何处理
phone_number功能。 - ***注意，在这个例子中，我没有进行特征工程。调整正则化超参数对此也有帮助。
引文
感谢我向读者推荐的博客和论文的作者，来补充这个博客。
集成方法:比较 Scikit Learn 的投票分类器和堆叠分类器
使用 Titanic 数据集比较 scikit 学习投票分类器和堆叠分类器。
他们说，两个脑袋比一个要好。有时在许多机器学习项目中，我们希望使用集成方法来利用协同的力量。投票和堆叠分类器为我们带来了结合 2 个或更多机器学习模型以获得更高预测性能的好处。
投票分类器
投票分类器的工作方式类似于选举系统，其中基于一组机器学习模型成员的投票系统对新数据点进行预测。根据 scikit_learn 的文档，可以在硬投票和软投票类型之间进行选择。
硬投票类型应用于多数规则投票的预测类标签。这使用了“多数决定投票”的思想，即做出有利于拥有半数以上投票的人的决定。
软表决基于组成集合的各个估计器的预测概率之和的 argmax 来预测类别标签。在良好校准/拟合的分类器的集成的情况下，经常推荐软投票。
例如:如果模型 1 预测 A ，而模型 2 预测 B ，而模型 3 预测 A 。投票分类器(withvoting =‘hard’)返回 A 。在平局的情况下，投票分类器将基于升序选择类别。
堆垛分级机
堆叠包括在同一数据集上组合来自多个机器学习模型的预测。我们首先在我们的数据集上指定/建立一些称为基础估计器的机器学习模型，来自这些基础学习器的结果然后作为我们的堆叠分类器的输入。堆叠分类器能够了解我们的基本估计值何时可信或不可信。叠加允许我们通过将每个估计量的输出作为最终估计量的输入来利用每个估计量的强度。
在使用堆叠分类器时，可以选择在基础学习者级别或在最终估计器上应用交叉验证。使用 scikit learn stacking 分类器，基础学习器适用于全 X，而最终估计器使用基础学习器的交叉验证预测来训练。
多层堆叠也是可能的，其中在构建最终估计器之前构建基础学习器的层。
值得注意的是，在考虑集合方法来改进我们的预测之前，建议:
- 在可能的情况下，获取更多的数据。我们输入到模型中的数据越多，模型需要学习的学习示例就越多。
- 特征工程。
- 我们模型的超参数调整。
方式和方法
在这个例子中，我们考虑了“泰坦尼克号:机器从灾难中学习”。我们分割训练数据集，以便能够对我们的模型进行自己的评估。数据集也可以在这里找到:【https://www.kaggle.com/c/titanic/data】T2。然后，我们构建一个逻辑回归、最近邻和随机森林算法。
我们使用上述 3 种算法作为 scikit learn 的投票和堆叠分类器的估计器，并比较它们预测的 f1 分数。
注意:堆叠分类器仅在 0.22 版本的 Scikit-Learn 中可用，而投票分类器从 0.17 版本开始可用。
观察结果
本例中投票和堆叠分类器的 f1_score 相同。
- 在投票分类器和堆叠分类器中，重要的是要确保基本估计量能够很好地给出准确的预测。正如人们所说的，‘垃圾进，垃圾出’，如果估计器放入垃圾，那么任何一种集成方法都会产生垃圾。
- 重要的是要注意，堆叠分类器在基础模型(或估计器)上建立模型，从而增加对数据集的拟合。这也增加了堆积分类器过度装配的趋势，尤其是在多层堆积的情况下。
- 投票分类器的性能很大程度上取决于基本模型的结果。因此，为了更好地预测，建议使用合适的估计量作为软投票类型的基础模型。
- 有时候，集合方法并不是真的需要。😉
结论
很难确定投票或堆叠分类器哪个更好。明智的做法是了解它们中每一个的用途/工作原理。这种理解将有助于决定在什么时候应用它们是最好的。
我希望这篇文章对你有帮助。这里是我的 Twitter 句柄和 Linkedin 页面。链接到 github repo 这里。
如果你喜欢这篇文章，你可以考虑给我买☕️.咖啡
Vielen Dank😊
基于 OptimalFlow 的机器学习集成模型选择与评估
用简单的代码选择最佳模型的简单方法
Artem Sapegin 在 Unsplash 上拍摄的照片
在机器学习工作流中，模型选择是创建基线模型的重要步骤。这个步骤通常是一个耗费时间的过程，并且需要更多的模型调整实验。
因此，我编写了一个名为 OptimalFlow 的软件包，其中有一个集成模型选择模块 autoCV ，它可以通过流行的监督建模算法进行交叉验证，还可以在超参数上应用“懒惰”搜索来选择最佳模型。
为什么我们使用 OptimalFlow ？你可以阅读另一个关于它的介绍的故事:一个 Omni-ensemble 自动化机器学习——optimal flow。
autoCV 模块目前覆盖了大多数主流的监督模型，包括 11 个分类和 14 个回归估计量，即 XGBoost、Random Forest、MLP 和 SVM 等。
您可以阅读optimal flowoptimal flow 的* autoCV 模块的 文档。此外， OptimalFlow 还提供了特征预处理、模型选择、模型评估、流水线簇遍历实验(PCTE) 自动机器学习模块。*
你可以阅读它的集成特征选择实现的另一个故事:通过 optimal flow在机器学习中进行集成特征选择的简单方法。
这里我们将有一个演示，使用 OptimalFlow ，在几分钟内完成一个分类问题的模型选择。我们使用一个干净的泰坦尼克号数据集作为输入。
第一步:通过 pip: 安装 OptimalFlow
*pip install OptimalFlow*
第二步:导入库:
*import pandas as pd
from OptimalFlow.autoCV import dynaClassifier,evaluate_clf_model
import joblib*
注意:这个演示使用的是基于网格搜索的动态分类器类；或者，您可以使用基于随机搜索的 fastClassifier 类，尽管这是一种在运行时间和解决方案质量之间的权衡(参见 autoCV 模块的 文档 中的更多细节)。
第三步:导入输入数据集:
*tr_features = pd.read_csv('./data/classification/train_features.csv')
tr_labels = pd.read_csv('./data/classification/train_labels.csv')#Splitting validate data sets for models evaluation
val_features = pd.read_csv('./data/classification/val_features.csv')
val_labels = pd.read_csv('./data/classification/val_labels.csv')*
清理过的泰坦尼克号数据集 train _ features.csv
清理过的泰坦尼克号数据集 train _ label.csv
第四步:运行 autoCV 模块:
我们将交叉验证拆分策略确定为 5 个文件夹。并且使用 fit_clf() 方法来训练集成方法中的模型，并且自动保存每个模型的具有最高 CV 分数的参数调整估计器。然后，优化的估计量全部保存到。/plk 文件夹进行进一步的模型验证。
*# We customize models cadidates for this demo:
custom_cv = ['lgr','svm','mlp','rf','ada','gb','xgb']*# Set input_form_file = False, when label values are array. Select 'True' from Pandas dataframe.*clf_cv_demo **=** dynaClassifier**(**custom_estimators = custom_cv, random_state **=** **13,**cv_num **=** **5,**input_from_file **=** True**)***# Select detail_info = True, when you want to see the detail of the iteration*clf_cv_demo**.**fit**(**tr_features**,**tr_labels**)***
然后，我们添加一些模型验证的代码，从保存的模型 pickles 中选择最优的模型。
*models = {}for mdl in ['lgr','svm','mlp','rf','ada','gb','xgb']:
models[mdl] = joblib.load('./pkl/{}_clf_model.pkl'.format(mdl))for name, mdl in models.items():
evaluate_clf_model(name, mdl, val_features, val_labels)*
一切就绪！以下是输出结果:
******OptimalFlow***** autoCV Module **===>** lgr_CrossValidation **with** **5** folds**:**
Best Parameters**:** **{**'C'**:** **1,** 'random_state'**:** **13}**
Best CV Score**:** **0.7997178628107917**
Progress**:** **[***###-----------------] 14.3%*
*****OptimalFlow***** autoCV Module **===>** svm_CrossValidation **with** **5** folds**:**
Best Parameters**:** **{**'C'**:** **0.1,** 'kernel'**:** 'linear'**}**
Best CV Score**:** **0.7959619114794568**
Progress**:** **[***######--------------] 28.6%*
*****OptimalFlow***** autoCV Module **===>** mlp_CrossValidation **with** **5** folds**:**
Best Parameters**:** **{**'activation'**:** 'tanh'**,** 'hidden_layer_sizes'**:** **(50,),** 'learning_rate'**:** 'constant'**,** 'random_state'**:** **13,** 'solver'**:** 'lbfgs'**}**
Best CV Score**:** **0.8184094515958386**
Progress**:** **[***#########-----------] 42.9%*
*****OptimalFlow***** autoCV Module **===>** rf_CrossValidation **with** **5** folds**:**
Best Parameters**:** **{**'max_depth'**:** **4,** 'n_estimators'**:** **250,** 'random_state'**:** **13}**
Best CV Score**:** **0.8240521953800035**
Progress**:** **[***###########---------] 57.1%*
*****OptimalFlow***** autoCV Module **===>** ada_CrossValidation **with** **5** folds**:**
Best Parameters**:** **{**'learning_rate'**:** **0.1,** 'n_estimators'**:** **100,** 'random_state'**:** **13}**
Best CV Score**:** **0.824034561805678**
Progress**:** **[***##############------] 71.4%*
*****OptimalFlow***** autoCV Module **===>** gb_CrossValidation **with** **5** folds**:**
Best Parameters**:** **{**'learning_rate'**:** **0.01,** 'max_depth'**:** **3,** 'n_estimators'**:** **300,** 'random_state'**:** **13}**
Best CV Score**:** **0.8408746252865456**
Progress**:** **[***#################---] 85.7%*
*****OptimalFlow***** autoCV Module **===>** xgb_CrossValidation **with** **5** folds**:**
Best Parameters**:** **{**'learning_rate'**:** **0.1,** 'max_depth'**:** **3,** 'n_estimators'**:** **200,** 'verbosity'**:** **0}**
Best CV Score**:** **0.8464292011990832**
Progress**:** **[***####################] 100.0%*
lgr **--** Accuracy**:** **0.775** **/** Precision**:** **0.712** **/** Recall**:** **0.646** **/** Latency**:** **0.0**ms
svm **--** Accuracy**:** **0.747** **/** Precision**:** **0.672** **/** Recall**:** **0.6** **/** Latency**:** **2.0**ms
mlp **--** Accuracy**:** **0.787** **/** Precision**:** **0.745** **/** Recall**:** **0.631** **/** Latency**:** **4.1**ms
rf **--** Accuracy**:** **0.809** **/** Precision**:** **0.83** **/** Recall**:** **0.6** **/** Latency**:** **37.0**ms
ada **--** Accuracy**:** **0.792** **/** Precision**:** **0.759** **/** Recall**:** **0.631** **/** Latency**:** **21.4**ms
gb **--** Accuracy**:** **0.815** **/** Precision**:** **0.796** **/** Recall**:** **0.662** **/** Latency**:** **2.0**ms
xgb **--** Accuracy**:** **0.815** **/** Precision**:** **0.786** **/** Recall**:** **0.677** **/** Latency**:** **5.0**ms*
现在，我们可以找到带有{‘learning_rate’: 0.01，’ max_depth’: 3，’ n_estimators’: 300，’ random_state’: 13}的 GradientBoost 是由 autoCV 选择的最优模型，其中具有最高的准确度和精确度分数，具有较低的召回率。
当您需要了解型号选择过程的更多细节时，您可以通过 autoFlow 模块找到自动生成的日志文件。
一切就绪！ OptimalFlow 的 autoCV 模块完成繁琐的选型&超参数实验。简单容易，对吧？😎
关于**的相关阅读optimal flow*😗**
使用 OptimalFlow 在机器学习中进行集成特征选择——使用简单代码选择顶级特征的简单方法
端到端 OptimalFlow 自动化机器学习教程结合真实项目-公式 E 圈数预测第 1 部分
关于我:
我是一名医疗保健和制药数据科学家以及大数据分析和人工智能爱好者。我开发了 OptimalFlow 库，帮助数据科学家以一种简单的方式构建最佳模型，并通过简单的代码实现机器学习工作流的自动化。
作为一名拥有多年分析经验的大数据洞察寻求者、流程优化者和人工智能专家，我使用数据科学中的机器学习和问题解决技能将数据转化为可操作的洞察，同时提供战略和量化产品作为最佳结果的解决方案。
你可以在我的 LinkedIn 或者 GitHub 上和我联系。
用于分类的集成模型
堆叠表现不佳的模型以创建更强的模型。他们从彼此的错误中吸取教训
您已经清理了数据并移除了所有相关要素。您还可视化了数据集，并且知道类标签是可分离的。你也调整了你的超参数。太好了，但是为什么你的模型表现不好呢？
什么是模型堆叠？
你试过叠模型吗？传统上，我们用单一的算法来模拟我们的数据。这可能是逻辑回归、高斯朴素贝叶斯或 XGBoost。
作者图片:传统 ML 模型
系综叠加模型的作用如下:
作者图片:堆叠 ML 模型
元学习者
用于组合基本估计器的算法被称为元学习器。我们可以确定我们希望该算法如何响应来自其他模型(本例中为分类器)的不同预测。它可以是:
- 估计量的预测
- 预测以及原始训练数据
但是这仅仅是最后一类**预测吗？**不，您可以选择推动决策的指标:
- 可能是
'predict_proba'或'predict'或者两者都是 - 也可以使用 sklearn 中的其他
'decision_function'
最终的元学习者可以是任何估计者(默认情况下，sklearn 有逻辑回归)
我们采用基线高斯朴素贝叶斯估计器，并将所有未来结果与其预测准确度进行比较:
rf = OneVsRestClassifier(estimator = GaussianNB())cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=20)n_scores = cross_val_score(rf, X, y, scoring='f1_weighted', cv=cv, error_score='raise')print(n_scores)
print('Baseline scores \n mean f1 weighted: %.3f with a %.3f standard deviation in scores ' % (np.mean(n_scores), np.std(n_scores)))
作者图片:基本模型分数
创建多层调优估值器，并将它们堆叠在一起
图片作者:堆叠模型胜过其他模型！
作者图片:堆叠模型优于所有分类器
最终，我们想要一个 F1 值高于 81.1%的分类器，我们最终用堆叠模型得到了 96.7%的 F1 值。
在医疗保健设置中，我将接受相对于 SVC 模型的 0.1%的改进，并且不会牺牲堆叠模型的复杂性！
现在就去堆栈…
对对立例子的集成鲁棒性
具有不同梯度关系的模型对
去年夏天，我有幸与一位才华横溢的本科生研究员 Romain Speciel 合作了一个项目，该项目旨在研究如何以一种提高对抗样本鲁棒性的方式来规范模型集合。我们主要关心的是减少模型之间对立例子的可移植性，因为这是黑盒设置中的一个主要威胁。这篇文章旨在展示在预印本中进一步详述的工作，同时提供额外的直觉。
对抗性例子的背景
我们将用 f 来指代一个模型，它的输出应该通过上下文显而易见:有时是预测的标签，有时是预测的概率。
图像分类模型的一个相反的例子是通过以人类不可察觉的方式扰动输入图像而获得的图像，然而这导致模型对输入进行错误分类。给定样本-标签对 x，y 的对立输入集被精确定义为
其中 x 是原始图像，𝜀被选择为使得人类不能辨别原始图像和扰动图像之间的差异，并且 p 通常被选择为 1、2 或∞。因此，为了找到对抗输入，必须解决下面的优化问题
这种受约束的优化试图最大化给定样本-标签对的损失函数，同时还保持制作的输入 x’足够接近 x，使得人类不能区分这两个图像。
在 ImageNet 上训练的 ResNet-50 模型的典型对抗示例
这不是一个要解决的简单的优化问题，但是我们可以通过获取约束并将其嵌入到 x '的构造中来简化它。神经网络通常用某种梯度下降的变体来训练，以最小化关于模型参数的期望损失函数
类似于优化模型参数以适应数据集(即学习)，我们可以通过利用模型的可区分性来优化输入。我们使用损失相对于输入图像的梯度在像素空间方向上移动，使得损失最大化，如下
其中 sgn 是符号函数，1 表示正值，-1 表示负值，否则为 0。通过使用 signum 函数，我们控制 L-∞范数的大小，使得扰动图像和原始图像之间的最大像素差至多为𝜀.这被称为 f ast 梯度符号(FGS)攻击,是一种非常有效的制造对抗例子的方法。然而，这是最弱的攻击，并且假设模型的输出表面是线性的。我们注意到，对抗性扰动不是唯一的，对于一个给定的输入，可能存在多个扰动，所有这些都会导致分类器对它进行错误分类。此外，对立的例子特定于给定的模型，尽管可转移现象表明对立的例子跨网络体系结构转移，甚至跨模型类转移。
梯度的重要性
考虑精度差不多的两个型号 f 和 g 。如果 f 和 g 的损失梯度之间的角度大于𝛑/2，那么在 f 的梯度方向上扰动输入 x 将降低 f 的预测置信度，但增加 g 的置信度。这在这个故事的封面图的子图 c)中得到最好的说明，在红色箭头的底部，模型输出表面相交并具有相同的值，而梯度指向相反的方向。如果我们可以假设
那么理论上 FGS 的攻击不可能同时愚弄 f 和 g。此外， f 和 g 之间的不一致，假设它们都具有相似的测试集性能，可以用来标记潜在的敌对输入。这不是对对抗性例子的直接防御，但是检测也很重要，并且让对抗性例子不在模型之间转移也可以降低黑盒设置中的攻击成功率。在实践中实现这样的梯度关系仅仅需要将正则化项添加到期望的损失函数(例如交叉熵损失)中。如果所讨论的集合仅由两个模型组成，则最佳正则化项将最小化余弦相似性
模型渐变之间。梯度的正则化相当抽象，所以让我们从模型使用的特征的角度来讨论这意味着什么。正交梯度意味着模型在进行分类时使用不相交的特征集，使得扰动模型 f 的最显著特征对模型 g 的预测几乎没有影响。请注意，这并不限制模型所使用的特征之间的关联。比如对汽车的图像进行分类时， f 可能会使用轮胎作为特征， g 可能会使用车门。即使这些特征可能在图像中同时出现(即这些特征是相关的)，扰动图像使得 g 不再检测图像中的门也不会影响 f 的预测。
继续以汽车为例，当 f 的输出随着轮胎的存在而增加，但随着车门的存在而减少，反之亦然 g 的情况下，可以实现余弦相似度小于 0 的坡度。在任一情况下，梯度正则化都是有代价的，因为集合中的模型不使用相同的特征，因此不能在个体基础上实现最大性能。在标准精度和敌对干扰下的精度之间有一个基本的权衡。在有许多与标签弱相关但在一起使用时具有高度预测性的特征的情况下，如果这些特征不稳健，那么对它们的微小改变会显著改变输出。
在实践中，既优化两个模型集合的精度又调整模型梯度的损失函数看起来像
第三项使梯度正则化，进一步的检查表明它需要二阶优化，因为我们优化的是梯度而不是参数。
测量集合合作
涉及的模型多了会怎么样？最小化模型之间的成对余弦相似性已经不够了。相反，我们必须考虑所有模型的对立子空间的交集，并以最小化该子空间的方式正则化模型梯度。完整的细节可以在预印本中找到，因此我们在这里重点关注该方法背后的动机，并证明为什么成对余弦相似性在考虑两个以上模型时不理想，正如 Kariyappa 和 Quershi 所做的那样。假设我们的组合由三个模型组成。然后，最大化成对余弦相似性将导致接近下面的蓝色渐变排列
三模型系综的梯度排列
请注意，对于具有 2D 梯度的三个模型，即𝛑/3.，只有一个成对角度最大化成对余弦相似性然而，我们不需要如此强的条件，因为绿色和黄色梯度的可视化也会降低模型之间的可转移性。我们的方法能够获得更少的限制条件，这使得优化更容易。为了进一步说明模型梯度如何影响对立子空间的大小，下图用橙色显示了两个模型集合的对立子空间。
两模型集成的敌对子空间依赖于梯度
位于橙色区域的任何扰动都负向投射到 f 和 g 的梯度上，从而降低两个模型的预测置信度。为了测量集成中的模型如何合作来减少可以同时欺骗所有模型的敌对子空间，我们引入了梯度多样性评级(GDR):
简而言之，该评级测量敌对子空间的体积，该子空间以相同的方式同时愚弄集合中的所有模型(即，它们都错误地预测了相同的错误类别)，通过与模型相同维数的单位球体的体积来归一化。看一下预印本看看如何最小化不同大小的系综的 GDR。在这里，我们只展示了表明 GDR 和对抗性攻击成功率之间存在相关性的结果，因此最小化 GDR 是系综的期望属性。
GRD 与时尚达人的攻击成功率
总之，由于 ML 工程师能够控制模型梯度，并创建攻击不会从一个模型转移到另一个模型的集合，因此黑盒防御设置具有更好的防御对手的可能性，从而为敌对示例创建了一种可能的检测机制。关于这些结果如何推广到其他数据集，以及 GDR 正则化有效的一些假设有多现实，还有更多需要了解。在这两种情况下，我们认为这是一个值得追求的途径，并且对对抗性例子的几何理解可以产生更有原则的防御方法。
集成技术
集成技术的高级概述
我们知道决策树是一种非常强大的技术，但是我们可以使用集成建模技术来改进它。
Ensemble 的基本意思是‘在一起’，所以 ensemble 模型就是一组一起工作的基础模型。
为了使集合模型更好地工作，你应该选择不同的基础模型，也就是说，这些模型越不同，你就越能更好地组合它们。
在这篇博客中，我将向你介绍以下合奏技巧:
- 装袋
- 助推
使用集合技术的好处
每个模型都有自己的优点和缺点，所以通过使用这种技术，我们得到的最终模型具有模型的所有优点，而掩盖了单个模型的缺点。所以，模型表现更好。
制袋材料
Bagging 也被称为 Bootstrap Aggregation ，用于提高机器学习算法的准确性。
装袋的主要目的是在不影响偏差的情况下减少方差，并有助于避免过度拟合。
在上图中，Dn 是我们的训练数据，包含我们的类标签和预测标签 yi。每个模型 Mi 是使用大小为 m (m
First step of the Bagging is **自举，**的每个 Di 构建的，这只不过是带有替换的随机采样。因此，每个模型接收具有不同数据子集的样本。
打包的第二步是**聚合，**这一步是组合我们从每个模型获得的输出。对于每个问题，这一步是不同的，取决于您遇到的问题类型。
- 对于分类问题，我们只是采用多数投票来预测它属于哪个类标签。
- 对于回归问题，我们采用均值/中值来预测值，因为输出可以是任何实数。
最流行的套袋技术之一是随机森林。
增压
Boosting 指的是将弱学习者转化为强学习者的一系列机器学习算法。
提升的主要目的是在保持我们的方差较低的同时，增加组合并减少模型的偏差。
boosting 算法将数据输入到第一个模型，然后第一个模型的输出作为第二个模型的输入。这里，我们在第一个模型中得到的误差被第二个模型减小了。
在上图中，每个模型都能够对负点或正点进行分类，但是每个模型的误分类误差都非常高。因此，在 boosting 的帮助下，我们将所有掩盖了彼此缺点的模型结合起来。所以，我们通过组合弱模型得到了一个强模型。
我们得到的最终模型能够对这些点进行最佳分类。
XGBoost 是最流行的提升技术之一。
我希望你对什么是合奏技术以及它们有多强大有了一个高层次的了解。
集成:机器学习中唯一(几乎)免费的午餐
用 PyTorch 和 NumPy 建立神经网络的最佳集成
照片由 Riho Kroll 在 Unsplash 上拍摄
这篇文章附带的笔记本可以在这里找到。
感谢 捷季扬娜德罗博特 和 伊戈尔波兹杰耶夫 的评论和建议。
摘要
在这篇文章中，我将讨论集成优化这个有些被忽视的话题。我首先简要概述了一些常见的合奏技术，并概述了它们的弱点。然后，我介绍了一个简单的集成优化算法，并演示了如何用 Python 和 PyTorch 将它应用于构建神经网络集成。在这篇文章的最后，我讨论了集成方法在深度学习中的有效性，这是在当前关于神经网络损失曲面几何的文献的背景下进行的。
关键要点:
- 强集成由既准确又多样的模型组成
- 存在允许不适合作为 ML 模型的直接优化目标的现实目标函数的集成方法(考虑使用交叉熵进行训练，同时对一些其他度量感兴趣，如准确性)
- 集成不仅通过抑制神经网络对噪声的固有敏感性，而且通过组合质量上不同且不相关的解来提高神经网络的性能
帖子组织如下:
一、简介
二、帖子。集成优化
III。构建神经网络集成
IV。神经网络集成:损失面几何形状的作用
五、结论
一.导言
集合是模型的集合，通过组合它们的预测来超越其中的每一个。强集成包括精确的模型，它们本身表现良好，但在犯不同错误的意义上是多样化的。这让我产生了深深的共鸣，因为我是一名金融专业人士——组合类似于建立一个由许多单个资产组成的稳健投资组合，并牺牲其中一些资产的更高预期回报，以通过分散投资来整体降低风险。“多元化是金融领域唯一的免费午餐”这句话出自现代投资组合理论之父哈里·马科维茨。鉴于集合和多样化在概念上是相关的，而且在某些问题上，两者在数学上是等价的，我决定给这篇文章起个名字。
为什么差点不过呢？因为考虑到最强大的模型(是的，神经网络)对资源的渴求，计算成本总是一个挥之不去的问题。除此之外，集成还会模糊单个模型的决策边界，从而损害决策树等更透明的机器学习算法的可解释性——这一点并不真正适用于神经网络，因为可解释性问题已经在单个模型层面上出现了。
构建合奏有几种方法:
- Bagging 引导训练集，在产生的样本上估计模型的许多副本，然后平均它们的预测。
- 增强依次对训练样本重新加权，迫使模型关注具有较高损失值的训练样本。
- S 跟踪使用一个单独的验证集来训练一个结合多个模型预测的元模型。
例如，参见Gilbert Tanner的这篇文章或Joseph Rocca的文章或 Juhi Ramzai 的文章以获得这些方法的广泛概述。
当然，上面的方法都有一些共同的问题。首先，给定一组训练好的模型，如何选择最有可能概括得好的模型？在堆叠的情况下，这个问题将读作“如何将集合候选的数量减少到可管理的数量，以便堆叠模型可以处理它们，而没有大的验证集或高的过度拟合风险？”好吧，只需选择表现最好的模型，并应用与它们的损失成反比的权重，对吗？不对。尽管这通常是一个很好的起点。回想一下，一个好的集合由精确的和多样的模型组成:将几个高度精确的模型与强相关的预测结合在一起通常会导致所有的模型都采用相同的 rake。
第二个问题更微妙。通常，我们训练的机器学习算法几乎都是美化的特征提取器，即现实生活应用中的目标可能与用于训练模型的损失函数明显不同。例如，交叉熵损失是深度学习中分类任务的主要内容，因为它在优化期间具有可微性和稳定的数值行为，然而，根据我们可能对准确性、F1 分数或假阴性率感兴趣的领域。作为一个具体的例子，考虑对洪水或飓风等极端天气事件进行分类，在这种情况下，产生第二类错误(假阴性)的成本可能会高得惊人，甚至会导致准确性，更不用说交叉熵作为评估指标了。类似地，在回归设置中，常见的损失函数是均方误差。例如，在金融领域，为样本中的每项资产训练相同的模型来预测下一阶段的回报是很常见的，而在现实中，多个投资组合中有数百项资产的优化目标与强化学习和最优控制中遇到的目标类似:多个时间范围以及状态和路径依赖。在任何情况下，你既不被低 MSE 评判，也不被低 MSE 补偿(除非你在学术界)。
在这篇文章中，我详细讨论了卡鲁阿纳等人(2004) 提出的集成优化算法，它解决了上述问题。该算法可以广义地描述为无模型的贪婪堆叠，即在每个优化步骤，该算法或者向集合添加新的模型，或者改变当前成分的权重，从而最小化总损失，而没有任何支配性的可训练模型来指导选择过程。卡鲁阿纳等人(2004) 的方法配备了几个功能，可以缓解过拟合问题，还可以构建集成优化自定义指标，这些指标可能不同于用于训练单个模型的指标，从而解决了第二个问题。我进一步演示了如何应用该算法:首先，一个具有封闭形式解决方案的简单示例，接下来，通过为 MNIST 数据集构建一个最佳神经网络集合来解决一个现实问题(完整的 PyTorch 实现可以在这里找到)。在这篇文章的结尾，我探索了支持深度学习中集成有效性的机制，并讨论了当前关于损失曲面几何在神经网络泛化属性中的作用的文献。
本文的其余部分结构如下:第二节介绍了卡鲁阿纳等人(2004) 的总体优化方法，并用一个简单的数值例子加以说明。在第三部分的中，我为 MNIST 数据集优化了一组神经网络( PyTorch 实现)。第四节简要讨论了深度学习中优化前景的文献及其对集成的影响。第五节结束。
二。集成优化: 卡鲁阿纳等人(2004) 算法
卡鲁阿纳等人(2004 年) 的方法相当简单。给定一组训练模型和它们在验证集上的预测，它们的集成构造算法的变体如下:
- 设置
inint_size— 初始集合中模型的数量和max_iter—最大迭代次数 - 通过平均它们的预测和计算总集合损失，初始化具有
init_size最佳性能模型的集合 - 将集合中的模型(带有替换)添加到集合中，这最小化了总集合损失
- 重复步骤 3，直到到达
max_iter
这个版本的算法包括几个旨在防止验证集过拟合的特性。首先，用几个性能良好的模型初始化集成，形成一个强初始集成；第二，用替换来绘制模型实际上保证了验证集上的集合损失不会随着算法迭代的进行而增加——如果添加另一个模型不能进一步改善集合损失，则算法添加现有模型的副本，实质上调整它们在最终预测中的权重。这种权重调整属性允许将该算法视为无模型堆叠。这种方法的另一个有趣的特征是，用于集合构建和用于训练单个模型的损失函数不需要相同:如前所述，我们通常用特定的损失函数来训练模型，因为它在数学或计算上方便,(合理地)希望模型能够很好地用难以直接优化的相关性能度量来概括。事实上，与例如假阴性率相比，在恶性肿瘤分类任务中测试集上的交叉熵值不应该是我们主要关心的。
以下 Python 函数实现了该算法:
卡鲁阿纳等人(2004) 集成选择算法
考虑下面的玩具例子:假设我们有 10 个零均值正态分布不相关预测的模型。此外，假设预测的方差从 10 线性减少到 1，即第一个模型具有最高的方差，而最后一个模型具有最低的方差。给定一个数据样本，目标是建立一个集合，使相对于地面真实值 0 的均方误差最小化。请注意，在卡鲁阿纳等人(2004) 算法的上下文中,“构建一个集合”意味着为每个模型的预测分配一个介于 0 和 1 之间的权重，以便加权预测使 MSE 最小化，服从所有权重总和为 1 的约束。
通过将模型的预测视为某些资产的回报，并将优化目标视为最小化投资组合方差，金融爱好者会认识到最小方差优化问题的特殊情况。这个问题有一个封闭的解:
其中 w 是模型权重的向量，σ是预测的方差-协方差矩阵。在我们的例子中，预测是不相关的，并且的非对角元素为零。以下代码片段通过使用ensemble_selector函数和分析方法解决了这个玩具问题，它还通过平均预测构建了一个简单的集合:
下面的图 1 比较了集合优化(蓝色)和封闭形式解决方案(橙色)隐含的权重。结果非常接近，特别是考虑到我们使用真实方差而不是样本估计来计算解析解。请注意，尽管预测不确定性较低的模型获得了较高的权重，但高不确定性模型的权重不会变为零:预测是不相关的，我们总是可以通过添加不相关的变量(当然是有限方差)来降低随机变量加权和的方差。
图 1:估计的与理论的最佳重量
下一张图中的蓝色实线描绘了算法的前 25 次迭代的总体损失。黑色虚线和红色虚线分别表示由最佳单一模型和平均所有模型预测的简单集合获得的损失。在大约五次迭代之后，优化的集合击败了原始集合，此后获得显著更低的 MSE 值。
图 2:系综损失与优化步骤
如果池中模型数量非常多怎么办？
如果模型池非常大，一些模型可能会完全偶然地超过验证集。卡鲁阿纳等人(2004 年)建议使用装袋来解决这个问题。在这种情况下，该算法应用于从池中随机抽取的 M 个模型的行李，并替换为单个行李的平均最终预测。例如，抽取一个模型和 20 个袋子的概率为 25%，任何特定模型不在任何一个袋子中的概率仅为 0.3%左右。
三。构建神经网络集成:MNIST 实例
配备了上一节中的技术，在这一节中，我们将把它们应用到一个实际的任务中，在 MNIST 数据集上构建和优化一个神经网络集成。使用随附的笔记本可以完全复制本节的结果，因此我将本节中的代码片段限制为最少，主要集中在集成上，而不是模型定义和培训上。
我们从一个简单的 MLP 开始，它有 3 个隐藏层，每层 100 个单位，每个都有 ReLU 激活。自然，MNIST 数据集的输入是一个 28x28 像素的图像，展平为一个 784 维的矢量，输出图层有 10 个对应于位数的单元。因此，PyTorch 中实现的MNISTMLP类指定的架构如下所示:
*MNISTMLP(
(layers): Sequential(
(0): Linear(in_features=784, out_features=100, bias=True)
(1): ReLU()
(2): Linear(in_features=100, out_features=100, bias=True)
(3): ReLU()
(4): Linear(in_features=100, out_features=100, bias=True)
(5): ReLU()
(6): Linear(in_features=100, out_features=10, bias=True)
)
)*
然后，我们使用独立的权重初始化(即，除了起始权重之外，一切都是相同的)对模型的 10 个实例进行 3 个时期的训练，每个时期的批量大小为 32，学习率为 0.001，保留 60，000 幅图像的训练集的 25%用于验证，最后的 10，000 幅图像构成测试集。目标是最小化交叉熵(等价地，负对数似然)。请注意，只有 3 个时期的训练以及每个模型相当小的容量可能会导致数据拟合不足，从而允许以更生动的方式展示集合的好处。
训练完成后，我们恢复 10 个模型中每个模型的最佳检查点(通过验证损失)。下图左侧面板显示了从M0 到M9的每个型号的验证(蓝色)和测试(橙色)损失。类似地，右边的面板显示了验证和测试的准确性。
图 3:模型的验证和测试集性能
正如所料，所有模型的表现都很差，其中最好的一个模型M7，在测试集上仅达到 96.8%的准确率。
为了构建一个最优集合，让我们首先调用上一节定义的ensemble_selector函数，然后在当前问题的上下文中检查各个参数:
y_hats_val是一个字典，其中模型名称作为关键字，验证集的预测类概率作为项目:
*>>> y_hats_val["M0"].round(3)
array([[0\. , 0\. , 0\. , ..., 0.998, 0\. , 0.001],
[0\. , 0.003, 0.995, ..., 0\. , 0.001, 0\. ],
[0\. , 0\. , 0\. , ..., 0.004, 0\. , 0.975],
...,
[0.999, 0\. , 0\. , ..., 0\. , 0\. , 0\. ],
[0\. , 0\. , 1\. , ..., 0\. , 0\. , 0\. ],
[0\. , 0\. , 0\. , ..., 0\. , 0.007, 0\. ]])>>> y_hats_val["M7"].round(3)
array([[0\. , 0\. , 0\. , ..., 1\. , 0\. , 0\. ],
[0\. , 0\. , 1\. , ..., 0\. , 0\. , 0\. ],
[0\. , 0\. , 0\. , ..., 0.003, 0\. , 0.981],
...,
[0.997, 0\. , 0.002, ..., 0\. , 0\. , 0\. ],
[0\. , 0\. , 1\. , ..., 0\. , 0\. , 0\. ],
[0\. , 0\. , 0\. , ..., 0\. , 0.002, 0\. ]])*
y_true_one_hot_val是对应的真独热编码标签的 numpy 数组:
*>>> y_true_one_hot_val
array([[0., 0., 0., ..., 1., 0., 0.],
[0., 0., 1., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 1.],
...,
[1., 0., 0., ..., 0., 0., 0.],
[0., 0., 1., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.]])*
loss_function是一个可调用的映射数组，将预测和标签映射到一个标量:
*>>> cross_entropy(y_hats_val["M7"].round(3), y_true_one_hot_val)
0.010982255936197028*
最后，init_size=1表示我们从单一模型的系综开始；replacement=True表示模型加入集成后不从模型池中移除，允许算法多次加入同一个模型，从而调整集成成分的权重；max_iter=10设置算法的步数。
现在让我们检查输出。model_weights是一个 pandas 数据帧，包含每个优化步骤的每个模型的总体权重。在每个优化步骤中删除所有权重为零的模型会产生:
*>>> model_weights.loc[:, (model_weights != 0).any()] M1 M4 M5 M7 M9
0 0.000000 0.000000 0.000000 1.000000 0.000000
1 0.000000 0.000000 0.500000 0.500000 0.000000
2 0.000000 0.000000 0.333333 0.333333 0.333333
3 0.000000 0.250000 0.250000 0.250000 0.250000
4 0.200000 0.200000 0.200000 0.200000 0.200000
5 0.166667 0.166667 0.166667 0.333333 0.166667
6 0.142857 0.142857 0.285714 0.285714 0.142857
7 0.125000 0.250000 0.250000 0.250000 0.125000
8 0.111111 0.222222 0.222222 0.222222 0.222222
9 0.100000 0.200000 0.200000 0.300000 0.200000
10 0.181818 0.181818 0.181818 0.272727 0.181818*
下图绘制了作为优化步骤函数的总体成分权重，其中较暗的色调对应于模型在所有优化步骤中获得的较高平均权重。在步骤 0，集合以单个最强的模型M7初始化，然后逐步添加更多的模型，给每个模型分配相等的权重:在步骤 1，有两个模型M7和M5，每个模型具有 50%的权重，在步骤 2，集合包括模型M7、M5和M9，每个模型具有三分之一的权重。在步骤 4 之后，没有新的模型可以进一步改进集合预测，并且算法开始调整其成分的权重。
图 4:总体权重
另一个输出——ensemble_loss——包含每个优化步骤的系综损失。与上一节中的图 2相似，下图的左面绘制了优化过程中验证集的总体损失(蓝色实线)。黑色虚线和红色虚线分别表示最佳单一模型和简单集合(对所有模型分配相同的权重)所达到的验证损失。集合损失下降得非常快，在几次迭代后超过了其简单对应物的性能，并且在算法进入权重调整模式后稳定下来，这在模型池相当小的情况下并不令人惊讶。右边的面板报告了测试集的结果:在每次迭代中，我使用当前的集合权重来产生预测并测量测试集的损失。该集成在测试样本上概括得很好，有效地重复了在验证集上观察到的模式。
图 5:MNIST 的系综损失
卡鲁阿纳等人(2004) 算法非常灵活，我们可以很容易地调整ensemble_selector，例如，通过改变loss_function参数直接优化精度:
其中accuracy定义如下:
下图重复了前面的分析，但这次是为了验证和测试准确性。结论是相似的，尽管在两个样本中集合的精度路径更不稳定。
图 6:集合精度，MNIST
四。更多关于神经网络中的集合:损失表面几何的重要性
为什么随机初始化有效？
简而言之，这完全是关于损失面的。当前的深度学习研究强调优化前景的重要性。例如，批量标准化( Ioffe 和 Szegedy (2015) )传统上被认为是通过减少内部协变量移位*——训练期间网络激活分布的变化，来加速和规范训练。然而， Santurkar 等人(2018) 提供了一个令人信服的论点，即该技术的成功源于另一个属性:批处理规范化使优化前景明显更加平滑，从而稳定梯度并加快训练。类似地， Keskar 等人(2016) 认为，与地形较平坦区域的最小值相比，损失面上的尖锐最小值具有较差的泛化属性。*
在训练期间，神经网络可以被视为将参数映射到给定训练数据的损失值的函数。下图描绘了(非常)简化的网络损耗图:解的空间和损耗分别沿水平轴和垂直轴。 x 轴上的每个点代表产生相应损耗的网络的所有权重和偏差(蓝色实线)。红点表示我们可能使用基于梯度的优化结束的局部最小值(最左边的两个点是全局最小值)。
在集合的上下文中，这意味着我们想要探索许多局部最小值。在上一节中，我们已经看到，同一神经网络结构的不同初始化的组合产生了更好的泛化能力。事实上，在他们最近的论文中，Fort 等人(2019) 证明了随机初始化最终会达到遥远的最优，因此能够探索完全不同的模型，具有相似的准确性和相对不相关的预测，从而形成强集成组件。这一发现补充了神经网络的标准直觉，即神经网络是最终的低偏差高方差算法，能够以几乎外科手术的精度拟合任何东西，尽管受到噪声敏感性的困扰，因此受益于方差减少带来的集成。
但是如果训练同一个模型的几个副本是不可行的，该怎么办呢？
黄等(2018) 提出在单次训练运行期间使用循环学习率和退火构建集成，并在每个循环结束时存储模型检查点或快照。直观上，增加学习速率可以允许模型避开上图中的任何局部最小值，并以不同的局部最小值落在邻近区域，最终收敛到该区域，随后学习速率降低。下图说明了快照集成技术。左图显示了模型在具有恒定学习速率的标准训练体系期间穿过损失景观的路径，并且最终停止点用蓝色旗帜标记。右图描绘了循环学习率时间表和用红旗标记的定期快照。
快照集，来源:黄等(2017)
但是，请记住，在前面的两个图中，整个参数空间分别被压缩到 x 轴和 xy 平面上的一个点中，这意味着图形上的一对相邻点在实际参数空间中可能相距很远，因此， 梯度下降算法遍历多个最小值而不被卡住的能力取决于损失表面上的对应谷是否被非常高损失的区域分开，使得学习中没有有意义的增加会导致到新谷的过渡。
幸运的是， Garipov 等人(2018) 证明了在优化景观上存在连接局部最小值的低损耗路径，并提出了利用这些连接的快速几何组合(FGE)过程。伊兹迈洛夫等人(2018) 提出了 FGE 的进一步细化——随机加权平均(SWA)。
Max Pechyonkin 为提供了快照集FGE 和西南威尔士州。
动词 （verb 的缩写）结论
让我们回顾一下这篇文章的要点:
- 强集成由既准确又多样的模型组成
- 一些无模型集成方法，如卡鲁阿纳等人(2004) 算法，允许不适合作为 ML 模型优化目标的实际目标函数
- 集成不仅通过抑制神经网络对噪声的固有敏感性，而且通过组合质量上不同且不相关的解来提高神经网络的性能
总而言之，集成学习技术应该是每个机器学习实践者的武器库中最重要的工具之一。不要把所有的鸡蛋放在一个篮子里这句古老的格言到底走了多远，确实令人着迷。
感谢您的阅读。我们热切期待您的评论和反馈。还有，在LinkedIn上联系我。
进一步阅读
* [## 随机加权平均——一种获得深度学习最新结果的新方法
更新:你现在可以在我的个人博客上欣赏这篇文章，这里的数学排版要好得多(Medium 不支持…
towardsdatascience.com](/stochastic-weight-averaging-a-new-way-to-get-state-of-the-art-results-in-deep-learning-c639ccf36a) [## 集成学习指南
没有人能知道所有的事情，但是在帮助下，我们可以克服每一个障碍。这正是合奏背后的理念…
towardsdatascience.com](/a-guide-to-ensemble-learning-d3686c9bed9a)
参考
Caruana，r .，Niculescu-Mizil，a .，Crew，g .，& Ksikes，A. (2004 年 7 月)。模型库中的集成选择。第二十一届机器学习国际会议论文集(第 18 页)。
Fort，s .，Hu，h .，& Lakshminarayanan，B. (2019)。损失景观透视。 arXiv 预印本arXiv:1912.02757
茨韦塔纳·加里波夫、伊兹迈洛夫、波多普里欣、维特罗夫和威尔逊(2018 年)。损耗面、模式连接性和 dnn 的快速组装。在神经信息处理系统的进展(第 8789-8798 页)。在T3 可用 arXiv:1802.10026
黄，李，杨，普莱斯，刘，郑，霍普克罗夫特，J. E .，，温伯格，K. Q. (2017)。快照合集:火车 1，免费获得 m。 arXiv 预印本arXiv:1704.00109
Ioffe，s .，& Szegedy，C. (2015 年)。批量标准化:通过减少内部协变量转移加速深度网络训练。 arXiv 预印本arXiv:1502.03167。
伊兹迈洛夫、波多普里欣、加里波夫、维特罗夫和威尔逊(2018 年)。平均权重导致更宽的最优值和更好的泛化能力。 arXiv 预印本arXiv:1803.05407。
Keskar，N. S .，Mudigere，d .，Nocedal，j .，Smelyanskiy，m .，，Tang，P. T. P. (2016)。深度学习的大批量训练:泛化差距和尖锐极小值。 arXiv 预印本arXiv:1609.04836。
桑图尔卡尔、齐普拉斯、易勒雅斯和马德瑞(2018 年)。批量规范化对优化有什么帮助？。在神经信息处理系统的进展(第 2483-2493 页)。可在arXiv:1805.11604获得。*
组装 HuggingFaceTransformer 模型
照片由 @jeetdhanoa 在 unsplash 上拍摄
使用一个简单的线性层将两个或更多的变形金刚组合在一起。
最近，当我使用 BERT 进行问答研究时，有人建议我集成两个 BERT 模型。我选择了一条显而易见的路线——谷歌搜索。但令我惊讶的是，什么都没有出现。有很多关于变形金刚的文章，但是没有关于如何组合变形金刚模型的。本文讨论的正是这个问题——如何集成两个 PyTorch 拥抱脸变压器模型。
什么是模型组装？
在很多情况下，一个单一的模型可能不会给出最好的结果。然而，如果我们将“几个弱”分类器组合在一起，并以一种有意义的方式组合这些弱分类器的结果，我们可能会得到更好的结果。
例如，假设我们正在使用 BERT 进行问答—如果我们将两个句子send _ 1和send _ 2传递给 BERT 模型，该模型应该预测这两个句子是否形成问答对，即send _ 2answerssend _ 1。
通常的技术是以两种方式向模型提供问答对—
【CLS】+sent _ 1+【SEP】+sent _ 2+【SEP】和
【CLS】+sent _ 2+【SEP】+sent _ 1+【SEP】
到一个单一模型，并训练该模型。
如果我们宁愿集合 2 个模型——以如下方式训练 2 个模型，而不是这样做:
模型 1 获得输入，
【CLS】+sent _ 1+[SEP]+sent _ 2+[SEP]，
模型 2 获得输入，
【CLS】+sent _ 2+[SEP]+sent _ 1+[SEP]
然后，使用一个简单的前馈网络，我们可以结合模型的结果(不要在如何做上敲你的头，只是假设它现在可以做。我将展示如何做到这一点，这是本文的关键)。
- 为什么组装更好？ *嗯，这不！至少不总是这样。*在某些情况下，集成的结果可能优于单个大模型。这是可行的，因为手头的任务可能太复杂，一个单一的模型无法理解。
这与一个有 100 个神经元的深度 CNN 比一个有 1 层和 100 个神经元的 CNN 工作得更好的原因是一样的——每一层都学到不同的东西，使整个模型变得更好。这和一个人比一头狮子弱是一个道理，但是作为一个社会，我们是地球上最优越的物种。这和 5 个我比 1 个梅西强是一个道理(至少我昨天是这么想的😆).这和悟吉塔比布罗利强是一个道理。但是最主要的原因是他们没有过度适应。
单一模型方法
让我们回到问答的例子。让我们考虑 3 个句子，
句子 _1 =谁杀了弗里扎？
句子 _2 =弗里扎被小悟空杀死
句子 _3 =弗里扎消灭了玛雅人却放过了玛雅人。
我们馈入模型，
输入:【CLS】+句子 _ 1+【SEP】+句子 _ 2+【SEP】
输出 : 1
输入:【CLS】+句子 _ 1+【SEP】+句子 _ 3+【SEP】
输出 : 0
如前所述，如果我们有一个单一的模型，那么训练模型的正常方式是，
【CLS】+问题+【SEP】+答案+【SEP】
【CLS】+答案+【SEP】+问题+【SEP】
具体到我们的情况，
【CLS】+句子 _ 1+【SEP】+句子 _ 2+【SEP】
【CLS】+句子 _ 2+【SEP】+句子 _ 1+【SEP】
变形金刚合奏
在这种方法中，我们有两种模式
- 模型 1
输入:【CLS】+提问+【SEP】+回答+【SEP】 - 模型 2
输入:【CLS】+回答+【九月】+提问+【九月】
现在的问题变成了如何将两个模型的输出合并成一个，即系综？
嗯，空谈是廉价的，所以让我们编码。由于代码并不便宜，我将尝试解释它的大部分。
作者提供的图片(使用 Paint S 创建)
代码
首先，我创建了一个名为BertEnsembleForNextSentencePrediction 的新模型。
self.bert_model_1 = BertModel(config)
self.bert_model_2 = BertModel(config)
self.cls = nn.Linear(self.n_models * self.config.hidden_size, 2)
BertEnsembleForNextSentencePrediction以 2 个 BertModel 作为输入(在 init 中可以看到)并增加一个 nn。线性在它们上面。 *nn。线性，*如前面提到的这里的 *，*应用线性变换就像:
在输入端。我来解释一下为什么 nn。使用了线性(尽管任何看过一点变形金刚代码的人应该能够立即看到许多 nn。线性如*bertonlynshead，BertForSequenceClassification，*等。).
input_ids_1 = input_ids[0]
attention_mask_1 = attention_mask[0]
token_type_ids_1 = token_type_ids[0]input_ids_2 = input_ids[1]
attention_mask_2 = attention_mask[1]
token_type_ids_2 = token_type_ids[1]
接下来是主前进功能。转发函数的参数 input_ids、attention_mask、token_type_ids 为元组，第 0 个索引用于第一个模型，第 1 个索引用于第二个模型。因此，第一个模型将 T28 输入 _ 标识[0]，注意 _ 屏蔽[0]，令牌 _ 类型 _ 标识[0]作为输入。(我不会详细说明这些术语的含义，因为它们是标准的 BERT 术语)。以上 6 行正是这么做的。
outputs.append(self.bert_model_1(input_ids_1, attention_mask=attention_mask_1, token_type_ids=token_type_ids_1))outputs.append(self.bert_model_2(input_ids_2, attention_mask=attention_mask_2, token_type_ids=token_type_ids_2))
然后，我们将上面的左侧变量，即输入 _ 标识 _1、注意 _ 屏蔽 _1、令牌 _ 类型 _ 标识 _1、输入 _ 标识 _2、注意 _ 屏蔽 _2、令牌 _ 类型 _ 标识 _2 传递给 BERT 模型— BertModel 。
如此处所示， BertModel 返回 last_hidden_state 和 pooler_output 作为前两个输出。我们对这里的池 _ 输出感兴趣。这里所说的和中的 pooler_output 是
L 由线性层和双曲正切激活函数进一步处理的序列的第一个标记(分类标记)的 ast 层隐藏状态。在预训练期间，根据下一句预测(分类)目标来训练线性层权重。
对于给定的输入， pooler_output 的大小为( batch_size，hidden_size )。默认情况下 hidden_size = 768。
last_hidden_states = torch.cat([output[1] for output in outputs], dim=1)
logits = self.cls(last_hidden_states)
现在进入使用 nn.Linear. 的主要组合部分，如何组合模型 1 和模型 2 的输出？很简单——每个模型中的*【CLS】*令牌都是大小( batch_size * 768 )。所以基本上对于每个问答配对，我们都有一个大小为 768 的向量。因此，对于每个给定的问答配对，将有分别从 2 个模型中的每一个生成的每个大小为 768 的 2 个向量。比如
【cls 1】+谁杀了 Freeza？+ [SEP] +弗里扎被悟空+[SEP]
【cls 2】+弗里扎被悟空+ [SEP] +谁杀了弗里扎？+ [SEP]
nn。线性接受输出数组元素的串联，即展平输出数组并执行线性运算*。因此，线性层将大小为(2 * 768)的向量作为输入，并输出 0 或 1 的概率，即逻辑值*(逻辑值并不完全是概率，但如果我们对逻辑值应用 softmax，我们会得到概率，所以它足够接近)。
因此，线性层将大小为(2 * 768)的向量作为输入，并输出 0 或 1。
这是一个完整的工作示例。
https://colab . research . Google . com/drive/1 syrrbaudjhikjhnxxazt 5 w _ uka 0 bmk 9 x？usp =分享
请注意，代码中使用的数据集非常小，代码的编写方式对于这样小的数据集来说是一个巨大的破坏。但是我编写代码的方式使得任何更大的数据集都可以使用。此外，PyTorch 的通用模式已用于编写代码。我发现保存这个模板并根据用例稍微调整一下代码很有用。
就是这样！
参考和链接:
- 为什么集合更好:https://www . quora . com/How-do-ensemble-methods-work-and-why-be-superior-to-individual-models
- PyTorch nn。线性:https://py torch . org/docs/master/generated/torch . nn . linear . html
企业人工智能/机器学习:经验教训
从帮助企业加速 AI/ML 之旅中获得的浅见。
从我的人工智能/机器学习之旅中学到的经验教训
我最近有幸参加了几位人工智能/机器学习专家的小组讨论。有许多很棒的问题，但大多数都与如何在大型组织中最有效地建立人工智能/机器学习(AI/ML)有关。
这让我有机会反思我自己帮助大型企业加速人工智能/机器学习之旅的经历，更具体地说，评估什么可行，或许同样重要的是，什么不可行。我把这些浓缩成了几个简单的“经验教训”,希望在你的组织的 AI/ML 之旅中对你有用。
第一课:不要让完美成为足够好的敌人
根据我的经验，你的模型永远不会完美。所以，不要试图让他们完美。现在，不要误解我的意思——模型的准确性(或任何适用于您的情况的指标)很重要，但获得绝对最佳的模型可能只在 Kaggle 比赛中有效。
相反，您的重点应该是使您的模型足够好，以满足业务需求。事实是，几乎所有的企业都认为获得一个完美的模型远远次于将一个“足够好”的模型投入生产，在生产中它可以交付价值。所以，我的建议很简单:弄清楚什么对你的组织来说是“足够好的”,并专注于将模型投入生产。
第二课:建立模型只是工作的 10%
这是一个基本但在很大程度上未被认识到的事实:今天，企业在数据科学方面的绝大多数时间并没有真正花在数据科学上。相反，大部分时间——根据我的经验，超过 90%的时间——都花在了做其他的事情,包括:获取数据、工程数据和特性集、解决安全问题、设置基础设施(云或数据中心)或工作站、打包生产模型，以及创建 DEVOPS 脚本以将完成的模型迁移到产品中……这还不是一个完整的列表！
不幸的是，在大多数不成熟的组织中(也就是说大多数组织认识到相对的“新”或 AI/ML ),这种额外的非数据科学工作实际上在每个项目中都经历过。
这是件大事吗？绝对是。假设你的团队的预算是 100 万美元(一个很好的整数，这使得计算非常简单)，这意味着有人——在许多情况下是你的高价数据科学家——在与你雇用他们的目的没有直接关系的任务上花费了 90%，或 90 万美元。那是一大笔钱！这不仅听起来很痛苦，而且经历起来更痛苦！
那么，如何才能避免这种痛苦呢？嗯，这引出了我的下一课…
约书亚·索蒂诺在 Unsplash 上拍摄的照片
第三课:秘方:人工智能/人工智能平台
正如我之前强调的，太多的项目在与 AI/ML 没有直接关系的任务上花费了太多的时间。
解决方案:一个“ AI/ML 平台”。
首先，让我们不要混淆我所说的“人工智能/人工智能平台”的含义。不仅仅是云供应商提供的环境和工具包。不要误解我，我喜欢 AWS、Azure 和 Google 提供的工具——没有它们你真的无法有效地做 AI/ML。然而，云供应商工具没有解决一些重要的考虑因素。换句话说，云供应商工具是必要的，但还不够。
那么，什么是“人工智能/人工智能平台”呢？简单地说，AI/ML 平台的目的是加速将 AI/ML 模型投入生产。它是在 AI/ML 环境和工具之上实现的“粘合剂”——脚本、安全策略、可操作性问题和自我供应基础设施。
让我们来解决关键因素:
- 安全性:解决访问敏感数据所需的安全性问题需要大量的尽职调查。在大多数组织中，这种情况的根本原因是，对于每个项目，几乎相同的安全问题被讨论、辩论，并且可能被实现。另一方面，AI/ML 平台基于你的组织的安全状态实现了一个安全模型，只需做一次，就可以用于所有的项目。大多数组织，尤其是那些受到高度监管的组织，需要远远超出云供应商通常提供的“虚拟公共云”能力的安全控制。应分层的附加功能的最小集合包括基于身份的访问控制(这将解决几乎所有黑客问题)、配置漂移管理(例如，捕捉 Capital One 发生的错误防火墙规则更改)和单向数据流(例如，数据可以存储在平台上，但只能使用“类似 Citrix”的门户来可视化，以使用工具—数据永远不能离开平台)
- 可操作性:所有大型企业对生产代码都有严格的要求。今天，AI/ML 模型被认为是可部署的代码，并且受到与其他产品代码相同的需求的约束。不幸的是，在大多数不成熟的组织中，这些需求是在每个项目的基础上实现的。相比之下，AI/ML 平台提供了生产级工具，这些工具通过常见的日志记录、警报、异常处理、统计和指标捕获以及与企业操作控制台的集成来增强准系统模型，从而确保 AI/ML 模型也解决了基本的企业问题
- 自我调配的基础架构:我看到当组织迁移到云时会发生一件不幸的事情:他们带着旧的数据中心包袱——大部分是乏味的手动流程——在云上实施同样低效的流程。回答错误！云供应商花费了数年时间来优化工具和流程，以允许数据科学家自行调配工具和环境，而无需额外的监督或流程。AI/ML 平台整合了必要的开发操作程序和安全功能，允许数据科学家和数据工程师快速获取数据并提供培训环境。
第四课:“人工智能/人工智能市场”是现代人工智能/人工智能的基本要求
简单来说， AI/ML Marketplace 是与 AI/ML 模型相关的所有工件的目录，支持模型的可再现性、可追溯性、可解释性和可验证性:
- 为了解决再现性问题，AI/ML 市场提供了对模型源代码的引用——包括当前和以前的版本——并且用于训练它的数据被保存在清单中
- 为了解决可追溯性问题，AI/ML Marketplace 维护对原始源系统数据和数据工程脚本的引用，这些数据工程脚本用于转换和丰富，从而提供对交付生命周期中所有数据更改的可见性。
- 为了解决可验证性问题，对训练输出、日志和相关工件(包括与模型的偏差和“道德”检查相关的输出日志)的引用由 AI/ML 市场管理，从而捕获模型功效的证据。
- 为了自动化信息捕获过程，AI/ML 市场将与 AI/OPS (DEVOPS for AI/ML)过程集成，以自动捕获上述工件。有趣的是，主要的云提供商、传统的 DEVOPS 供应商以及较新的 AI/OPS 初创公司正在提供工具和功能，这些工具和功能可以缝合在一起，以捕获许多所需的指标和元数据。
简而言之，AI/ML Marketplace 是一个目录和存储库，它通过充分解决可再现性、可追溯性、可验证性和可解释性来促进现代 AI/ML 开发、管理和治理。
第 5 课:让您的云原生 AI/ML 程序现在就开始吧！
在大多数企业中，我看到计算平台和数据/存储容量远远超出了内部数据中心的能力。GPU 农场不在议程上。三倍和四倍的储存农场正在进行中。但事实是，即使是大型组织也无法跟上。
大型国际咨询公司埃森哲(Accenture)表示，有几个问题:首先，“到目前为止，还没有一个经过验证的扩展蓝图，组织可能会陷入一些常见的陷阱。”第二，“人工智能的陌生景观也意味着企业可能会倾向于回到他们历史悠久的行为，重新发明轮子，从头开始建设。”最后，“有许多经过验证的低成本人工智能选项，可以购买现成的并立即开始使用。”
那么，当大型云供应商有其他更强大、更具成本效益、可扩展和最新的选项可用时，为什么还要与之对抗呢？我的简单建议是:撇开批评者，让你的云原生 AI/ML 项目开始吧！
第六课:民主化人工智能/人工智能
大多数组织，尤其是那些将 AI/ML 迁移到云的组织，都有一个千载难逢的机会来构建他们的组织以取得成功。我的愿景是“使人工智能/人工智能民主化”，这也是我在大型企业中看到的。我的意思是，任何团队(假设他们有技能)都应该能够在任何时间，以任何速度，使用他们需要的任何工具和库来构建 AI/ML 模型。
但是，如何扩展和管理这种类型的组织结构呢？简而言之，基本要求是在 AI/ML 平台和 AI/ML 市场中实现规模和管理所需的必要护栏。考虑到这一点，下面是 AI/ML 组织内的一组实用的组:
- AI/ML 平台团队:该团队对建立、操作、支持和发展所有组件(包括基础设施、云环境、安全性、工具和 DEVOPS)负有完全的端到端责任。该团队不仅负责平台，还培训、支持和指导数据科学团队
- 分布式数据科学团队:由于许多跨领域的问题都被纳入了 AI/ML 平台，这使得数据科学家可以从事数据科学工作，同时也使整个组织的数据科学家能够快速、无缝地入职。这一指导原则允许任何拥有数据科学技能的团队按照其团队需求和业务需求所决定的速度进行数据科学研究。没有集中的群体。没有象牙塔。
乔希·卡拉布雷斯在 Unsplash 上的照片
正在总结…
我在这篇文章中的目标是提供一些简单的经验教训，帮助您加速您的企业的 AI/ML 之旅，并避免我所经历的一些减速带和坑洞。希望我已经达到了这个目标。
但有一点我可以肯定的是，事情进展得很快。技术和方法很可能会发展，很有可能，我应该考虑在一年后写一个新版本。或者，一年后，你将能够写一些从你的组织 AI/ML 旅程中学到的经验教训！
带有 Google Dialogflow & Flutter 的企业级聊天机器人(第一部分)
参见第二部分此处。
1)人工智能和虚拟助手革命
图片经 Canva 授权给 Catherine Torchy ( 我的妻子)
消费级虚拟助手(如谷歌助手、Alexa、Siri)已经深刻改变了人们在个人生活中与技术打交道的方式。但我是相信有一天，虚拟助理和人工智能将被大规模用于改变员工在工作中与系统互动的方式，并自动化他们的日常任务的人之一。
目前，挑战主要是与现有业务解决方案(如 ERP)的集成、与用户系统上不存在的外部数据连接的能力，以及在各种平台(包括 web 和移动设备)上获得一致的用户体验的能力。
这一系列 3 篇技术文章的想法是在对市场上提出的几个聊天机器人和对话引擎进行评估后产生的。它们中的大多数都提供了与语言(NodeJS、Java、Python…)、消息系统(Facebook Messenger、Slack、Telegram、Hangouts……)但要想知道如何将它们集成到一个商业解决方案中并不容易。此外，它们的渲染通常非常有限，无法为业务需求提供可接受的用户体验。
我读过很多提供部分解决方案的文章。然后开始了三重挑战:
- 如何将对话引擎与外部 API 轻松集成
- 如何通过使用自定义消息和一组丰富的组件来解决默认呈现引擎的布局限制(例如，Google Assistant 的限制),以获得更好的用户体验
- 如何用相同的代码管理多平台/移动前端
所以，我选择了最强大的 NLP 对话引擎之一，Google Dialogflow，但它也可能是微软 Bot 或亚马逊 Lex。然后我结合一个 Google Flutter 应用，突破 Google Assistant、Slack 等的布局限制。
如果你已经读过我的文章，那么答案是……“是的”，这篇文章是为那些打算继续实践的人提供的又一个简单的循序渐进的教程。它将集中于超越虚拟助理的基本设计所需的知识。还需要一些关于 Dialogflow、NodeJS、API/web services 和 Flutter 的知识。像往常一样，这些文章(Dialogflow & Flutter 项目)的全部源代码将会发布在我的 git lab(【https://gitlab.com/osadey】)上
有大量的教程描述了如何在 Dialogflow 中配置意图。这一篇将关注与业务 API 使用相关的 dialog flow Intents & Fulfillment NodeJS 代码。下一步将在 Google Assistant 集成中使用相同的意图，然后在定制的 Flutter 移动应用程序中使用相同的意图。
2)欧拉·爱马仕金融开放数据 API 介绍
作者图片
本节的目的是让您在询问财务数据时配置理解用户请求的对话。每个请求都可以用不同的方式表达，并且有参数。如果缺少，将要求用户完成它们。一旦满足要求，就会调用 Opendata API，并将财务数据返回给用户。
我们的财务虚拟助理将从 Euler Hermes Economics Open Data 获得一些财务数据，并将它们显示给用户(参见https://opendata.eulerhermes.com/pages/home-page/),但它也可能是令人印象深刻的数据库。经济学数据提供商。(【https://db.nomics.world/】T2
你在这两个网站上看到的大部分东西都可以通过 RESTful APIs 查询。
现在我们来探究一下欧拉·赫尔墨斯的一些国际贸易数据。在我们的例子中，我们将连接到一个数据集，该数据集提供了进口国和出口国之间的贸易流和支付默认值(参见:https://open data . Euler Hermes . com/explore/dataset/exports-vs-claims/information/)
数据集由 8 个数据元素组成:
- 年/月
- 进口商/购买国
- 出口商/销售国
- 进口商公司贸易部门 NACE 代码
- 给定月份向 Euler Hermes 申报的贸易流量总额(€)
- 给定月份向 Euler Hermes 申报的拖欠付款总额(€)
- 交通灯是给定购买人群的风险指示器
- 给定人群的损失率代理
3)配置您的对话流代理和意图
作者图片
3.1。我们的使用案例
代理是关于相同主题的一组会话的配置，共享相同的目标。我们的代理将显示一个贸易流和付款违约的清单，从一个出口国到一个进口国之间的两个日期。然后，用户将能够通过几个标准过滤列表。(例如“建筑”)
用户可以使用不同的短语来提问，应该会给出相同的结果。
以下部分假设您已经对 Dialogflow 有了基本的了解。
3.2。创建代理
让我们创建一个基本的对话流代理
一旦登录到谷歌对话流控制台(https://dialogflow.cloud.google.com/)
- 创建一个新代理，并将其命名为 BusinessAPIBot
- 在“常规”选项卡上添加描述
您可以保留其他选项卡上的其他默认值。
3.2。创建意图
意图代表用户和虚拟助理之间的典型对话。
让我们创建我们的第一个意图。
- 点击左侧菜单中的“+”按钮添加意向
- 将其命名为’生态出口与索赔’
- 输入您的第一个训练短语如下“由过滤器过滤的 2018-05-01 至 2018-05-02 前 10 大出口国家的对外贸易额是多少？”
正如您所注意到的，训练短语有一些以不同颜色突出显示的参数。可以选择训练短语的每个元素，然后作为参数添加。参数可以有多种类型:例如整数、日期或用户定义。
参数需要与实体相关联。
如果 Dialogflow 无法自动创建它们，您将首先需要使用左侧的“实体”菜单手动创建它们，然后将它们添加到实体列表中。
现在，我们将向我们的训练短语添加参数:
- 选择“从”日期(此处为“2018–05–01”)
- 将出现一个弹出窗口。选择一个“@sys.date”实体
- 将参数命名为“日期-期间-自”
- 对“至”日期“2018–05–01”执行相同的操作，并将其命名为“日期-期间-至”
- 对“10”值执行相同的操作，并将其分配给“@sys.number-integer”实体。把它命名为‘topnn’
- 最后，对“filter”值执行相同的操作，并将其分配给一个“@sys.any”实体。将其命名为“过滤器”
你的第一个训练短语应该是这样的:
作者图片
现在，让我们添加另外两个训练短语，以便当对话引擎提出不同的请求时，能够更好地理解它的请求。
输入您的第二个训练短语如下:“在 2018-05-01 至 2018-05-02 期间，由过滤器过滤的法国和德国之间的前 10 大对外贸易额是多少”
你可以注意到这个有点不同。“topnn”参数出现在开头，有两个新的附加参数:出口国和进口国。
- 选择“FR”国家值，并将其分配给新的“@geo-country-code-export”实体。将参数命名为“地理国家代码导出”
- 选择“DE”国家值，并将其分配给新的“@geo-country-code-import”实体。将参数命名为“地理国家代码导入”
- 对第一个训练短语进行相同的操作，以确定其他参数
你的第二个训练短语应该是这样的:
作者图片
最后，将第三个训练短语添加到列表中，如下所示:“我希望获得由过滤器过滤的 2018–05–01 至 2018–05–02 期间 FR 和 en 之间的贸易流量和付款默认值。”
如您所见，它与之前的训练短语具有相同的参数。我们只是用“获取贸易流量”取代了“对外贸易额”。
然后，对第二个训练短语进行同样的操作，以识别所有参数。
NLP 对话流引擎允许你只用一小组训练短语来训练 AI。理想情况下，你最好增加一些训练短语，让你的代理表现更好。
在下面的屏幕上，您可以看到您定义的所有参数:
作者图片
参数可以是可选的，也可以是强制的。如果它们丢失，Dialogflow 将要求用户自动完成它们。
- 在顶部字段中，请键入以下内容:“input.getTradeFlows”
- 选中“地理位置-国家代码-出口”、“日期-期间-自”和“日期-期间-至”的“必填”框
- 添加提示文本“从哪个时期开始？”“日期-期间-自”参数
- 添加提示文本“到哪个期间？”到“日期-周期-到”参数
- 在“地理国家代码-出口”参数中添加提示文本“出口国家代码是什么(de，FR，SP…)”
您还可以发送回一个响应，其中包含您的输入参数的格式化值。
为此，在响应部分添加以下文本:
好的，这是我为你选择的数据: —出口国 地理 − 国家代码 − 出口 ∗ ∗ —进口国 地理-国家代码-出口* *—进口国 地理−国家代码−出口∗∗—进口国地理-国家代码-进口 —期间从 日期 − 期间 − 自 . 原始到 日期-期间-自.原始到 日期−期间−自.原始到日期-期间-至.原始
单击“保存”按钮保存您的意向并创建您的代理。
现在，我们能够对代理进行非常基本的测试。
3.3。我方代理人的基本测试
作者图片
在右边的屏幕框中，您可以测试您的代理，并查看训练短语是否被识别，参数是否被正确识别和解析。
如果缺少强制参数，Dialogflow 应该询问其他问题。
对于我们最基本的测试，让我们键入以下内容:
- “获得从法国到德国的贸易流量”
- 代理应询问缺失的强制日期“从哪个时间段开始？”
- 输入“20200101”
- 代理应询问缺失的强制日期“截止到哪个时间段？”
- 输入“20201231”
那么代理的回答应该如下:
"好的，这是我为你选择的数据:
-出口国 FR-进口国 DE
-从 20200101 到 20201231 期间
作者图片
下一篇文章(第二部分)将向您展示如何:
- 使用 NodeJS 将新代理与 Euler Hermes API 集成
- 将数据呈现给用户
- 使用代理跟进意图过滤数据
- 配置闲聊
扫一扫
722
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
