ensemble

组合模型，轻松。

ensemble 允许您组合您的模型并通过单个对象访问它们。您可以使用该组合来在模型之间进行多路复用、调用所有模型并汇总结果。您可以执行 袋装、提升、堆叠 等操作。您甚至可以创建组合的组合！

此包借鉴了来自 TensorFlow 的计算图会话思想，并实现了构建树层次结构的 组合模式。

文档

请参阅ensemble-pkg.readthedocs.io上的文档

安装

pip install ensemble-pkg

案例研究

假设我们有两个模型可以完成二元分类任务。我们想要能够轻松地将两个模型组合成一个组合，然后测试两个模型和组合的精确率和召回率。使用此包非常简单。

我们首先为数据集构建两个模型。在这种情况下，任务是判断一个数字是否能被15整除。我们有两个模型，一个模型说如果数字能被3整除，那么它就能被15整除；另一个模型说如果数字能被5整除，那么它就能被15整除。

def model1(x):
  return x % 3 == 0

def model2(x):
  return x % 5 == 0

def get_dataset():
  return [(i, i % 15 == 0) for i in range(1, 101)]

定义一个函数，用于获取给定数据集和预测集的精确率和召回率

def get_results(dataset, preds):
  labels = [label for _, label in dataset]
  positives = sum(1 for label in labels if label)
  predicted_positives = sum(1 for pred in preds if pred)
  true_positives = sum(1 for label, pred in zip(labels, preds) if label and pred)
  return 100.0 * true_positives / predicted_positives, 100.0 * true_positives / positives

接下来，我们从 model1 和 model2 构建一个模型组合，具体来说是一个只在其所有子节点都输出 True 时才输出 True 的组合。在这种情况下，组合将只在输入既能被3整除也能被5整除时输出 True。

e = Ensemble('ensemble', children=[model1, model2], mode='all')
e(x=3) # returns False
e(x=5) # returns False
e(x=15) # returns True

最后，让我们从我们的两个模型和集成中构建另一个集成，以便轻松汇总每个模型的精度和召回率统计数据。我们通过在每个子模型上装饰一个评估装饰器来完成此操作，该装饰器修改模型以接受数据集并输出精度和召回率，而不是接受一个数字并输出 True 或 False。

def evaluate(model):
  def wrapper(dataset):
    preds = [model(x=x) for x, _ in dataset]
    precision, recall = get_results(dataset, preds)
    return {
      'precision': f'{precision:.1f}%',
      'recall': f'{recall:.1f}%',
    }
  return wrapper

results = Ensemble('results', children=[model1, model2, e])
results.decorate_children(evaluate)

最后，我们运行 results(dataset=get_dataset()) 并获得以下预期的结果！

{'ensemble': {'precision': '100.0%', 'recall': '100.0%'},
 'model1': {'precision': '18.2%', 'recall': '100.0%'},
 'model2': {'precision': '30.0%', 'recall': '100.0%'}}

在几行代码中，我们构建了以下图形结构。

示例

定义您的模型函数并创建您的集成

>>> from ensemble import Ensemble
>>> def square(x):
...     return x**2
>>> def cube(x):
...     return x**3
>>> e = Ensemble(name='e1', children=[square, cube])

调用集成中的所有模型

>>> e(x=2)
{'square': 4, 'cube': 8}
>>> e(x=3)
{'square': 9, 'cube': 27}

在函数之间复用

>>> e.multiplex('square', x=2)
4
>>> e.multiplex('cube', x=3)
27

您还可以使用 @child 装饰您的模型函数，以便将其附加到集成

>>> from ensemble import child
>>> @child('e2')
... def func1(x):
...     return x**2
...
>>> @child('e2')
... def func2(x):
...     return x**3
...
>>> e = Ensemble('e2')
>>> e(x=3)
{'func1': 9, 'func2': 27}

甚至可以将模型附加到多个集成中！

>>> @child('e2', 'e3')
... def func3(x, y):
...     return x**3 + y
...
>>> e2(x=2, y=3)
{'func1': 4, 'func2': 8, 'func3': 11}
>>>
>>> e3 = Ensemble('e3')
>>> e3(x=2, y=3)
{'func3': 11}

从您的集成模型的统计聚合中计算

>>> def a(x):
...   return x + 1
...
>>> def b(y):
...   return y + 2
...
>>> def c(z):
...   return z + 2
...
>>> e = Ensemble('e4', children=[a, b], weights=[3.0, 1.0])
>>> e.mean(x=2, y=3)
4.0
>>> e.weighted_mean(x=2, y=3)
3.5
>>> e.weighted_sum(x=2, y=3)
14.0
>>> e = Ensemble('e6', [a, b, c])
>>> e.vote(x=1, y=1, z=1)
3

构建集成集成！

>>> first_ensemble = Ensemble('first', children=[c])
>>> second_ensemble = Ensemble('second', children=[a, b])
>>> parent_ensemble = Ensemble('parent', children=[first_ensemble, second_ensemble])
>>> parent_ensemble(x=1, y=1, z=1)
{'first': {'c': 3}, 'second': {'a': 2, 'b': 3}}
>>> parent_ensemble.multiplex('second', x=3, y=1)
{'a': 4, 'b': 3}

使用该思想来链式聚合计算！计算每个集成中模型输出的总和的均值

>>> first_ensemble.set_mode('sum')
Ensemble(name='first', children=['c'], weights=None, mode='sum')
>>> second_ensemble.set_mode('sum')
Ensemble(name='second', children=['a', 'b'], weights=None, mode='sum')
>>> parent_ensemble.mean(x=1, y=1, z=1)
4.0

如果您忘记了集成中的模型，只需检查即可

>>> print(parent_ensemble)
Ensemble(name='parent', children=['first', 'second'], weights=None, mode='all')
  Ensemble(name='first', children=['c'], weights=None, mode='sum')
    Model(name='c', func=c(z))
  Ensemble(name='second', children=['a', 'b'], weights=None, mode='sum')
    Model(name='a', func=a(x))
    Model(name='b', func=b(y))

在上面的示例中，显示了一个树形图，该图显示了哪些模型和集成是哪些集成的子集！