• Python
• Программирование
• Машинное обучение

Нейронные сети довольно популярны. Их главное преимущество в том, что они способны обобщать довольно сложные данные, на которых другие алгоритмы показывают низкое качество. Но что делать, если качество нейронной сети все еще неудовлетворительное?

И тут на помощь приходят ансамбли...

Что такое ансамбли

Ансамбль алгоритмов машинного обучения — это использование нескольких (не обязательно разных) моделей вместо одной. То есть сначала мы обучаем каждую модель, а затем объединяем их предсказания. Получается, что наши модели вместе образуют одну более сложную (в плане обобщающей способности — способности "понимать" данные) модель, которую часто называют метамоделью. Чаще всего метамодель обучается уже не на нашей первоначальной выборке данных, а на предсказаниях других моделей. Она как бы учитывает опыт всех моделей, и это позволяет уменьшить ошибки.

План

1. Сначала мы рассмотрим одну простую PyTorch-модель и получим ее качество
2. Затем соберем несколько моделей с помощью Scikit-learn и узнаем, как добиться более высокого уровня

Одна единственная модель

Итак, будем работать с датасетом Digits из Sklearn, так как его можно довольно просто получить в две строчки кода:

# импортируем библиотеки
from sklearn.datasets import load_digits
import numpy as np
import matplotlib.pyplot as plt

# собственно, загрузка датасета
x, y = load_digits(n_class=10, return_X_y=True)

Посмотрим, как выглядят наши данные:

print(x.shape)
>>> (1797, 64)
print(np.unique(y))
>>> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

index = 0

print(y[index])
plt.imshow(x[index].reshape(8, 8), cmap="Greys")

x[index]
>>> array([ 0.,  0.,  5., 13.,  9.,  1.,  0.,  0.,  0.,  0., 13., 15., 10.,
       15.,  5.,  0.,  0.,  3., 15.,  2.,  0., 11.,  8.,  0.,  0.,  4.,
       12.,  0.,  0.,  8.,  8.,  0.,  0.,  5.,  8.,  0.,  0.,  9.,  8.,
        0.,  0.,  4., 11.,  0.,  1., 12.,  7.,  0.,  0.,  2., 14.,  5.,
       10., 12.,  0.,  0.,  0.,  0.,  6., 13., 10.,  0.,  0.,  0.])

Ага, чиселки принимают значения от 0 до 15. Значит, нужна нормализация:

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# разделим выборку на тренировочную и тестовую
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2,
                                                    shuffle=True, random_state=42)
print(x_train.shape)
>>> (1437, 64)
print(x_test.shape)
>>> (360, 64)

Используем StandardScaler: он переводит все данные в границы от -1 до 1. Обучаем его только на тренировочной выборке, чтобы он не подстраивался под тест — так score модели после теста будет ближе к score'у на реальных данных:

scaler = StandardScaler()
scaler.fit(x_train)

И нормализуем наши данные:

x_train_scaled = scaler.transform(x_train)
x_test_scaled = scaler.transform(x_test)

Время Torch'а!

import torch
from torch.utils.data import TensorDataset, DataLoader
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam

Простой сверточной сети вполне достаточно для демонстрации:

class SimpleCNN(nn.Module):
  def __init__(self):
    super(SimpleCNN, self).__init__()

    # слои свертки
    self.conv1 = nn.Conv2d(in_channels=1, out_channels=3, kernel_size=5, stride=1, padding=2)
    self.conv1_s = nn.Conv2d(in_channels=3, out_channels=3, kernel_size=5, stride=2, padding=2)
    self.conv2 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=1)
    self.conv2_s = nn.Conv2d(in_channels=6, out_channels=6, kernel_size=3, stride=2, padding=1)
    self.conv3 = nn.Conv2d(in_channels=6, out_channels=10, kernel_size=3, stride=1, padding=1)
    self.conv3_s = nn.Conv2d(in_channels=10, out_channels=10, kernel_size=3, stride=2, padding=1)

    self.flatten = nn.Flatten()
    # гордый полносвязный слой
    self.fc1 = nn.Linear(10, 10)

  # функция для "пропускания" данных через модельку
  def forward(self, x):
    x = F.relu(self.conv1(x))
    x = F.relu(self.conv1_s(x))
    x = F.relu(self.conv2(x))
    x = F.relu(self.conv2_s(x))
    x = F.relu(self.conv3(x))
    x = F.relu(self.conv3_s(x))

    x = self.flatten(x)
    x = self.fc1(x)
    x = F.softmax(x)

    return x

Определим некоторые гиперпараметры :

batch_size = 64 # размер батча
learning_rate = 1e-3 # шаг оптимизатора
epochs = 200 # сколько эпох обучаемся

Сперва преобразуем данные в тензоры, с которыми работает PyTorch:

x_train_tensor = torch.tensor(x_train_scaled.reshape(-1, 1, 8, 8).astype(np.float32))
x_test_tensor = torch.tensor(x_test_scaled.reshape(-1, 1, 8, 8).astype(np.float32))

y_train_tensor = torch.tensor(y_train.astype(np.long))
y_test_tensor = torch.tensor(y_test.astype(np.long))

В PyTorch есть очень удобные обертки на случай, если ваши данные — это простые тензоры. Здесь датасет — штука, которая может вернуть пару X и y по индексу (прокачанный массив), а DataLoader — итератор, который будет последовательно возвращать наши пары <X, y> батчами по 64 картинки:

train_dataset = TensorDataset(x_train_tensor, y_train_tensor)
train_loader = DataLoader(train_dataset, batch_size=batch_size)

test_dataset = TensorDataset(x_test_tensor, y_test_tensor)
test_loader = DataLoader(test_dataset, batch_size=batch_size)

Штуки, которые нужны для обучения модельки:

simple_cnn = SimpleCNN().cuda() # перемещаем на gpu, чтобы училось быстрее, жилось веселее
criterion = nn.CrossEntropyLoss()
optimizer = Adam(simple_cnn.parameters(), lr=learning_rate)

И само обучение:

for epoch in range(epochs): # итерируемся 200 эпох
  simple_cnn.train()
  train_samples_count = 0 # общее количество картинок, которые мы прогнали через модельку
  true_train_samples_count = 0 # количество верно предсказанных картинок
  running_loss = 0

  for batch in train_loader:
    x_data = batch[0].cuda() # данные тоже необходимо перемещать на gpu
    y_data = batch[1].cuda()

    y_pred = simple_cnn(x_data)
    loss = criterion(y_pred, y_data)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step() # обратное распространение ошибки

    running_loss += loss.item()

    y_pred = y_pred.argmax(dim=1, keepdim=False)
    true_classified = (y_pred == y_data).sum().item() # количество верно предсказанных картинок в текущем батче
    true_train_samples_count += true_classified
    train_samples_count += len(x_data) # размер текущего батча

  train_accuracy = true_train_samples_count / train_samples_count
  print(f"[{epoch}] train loss: {running_loss}, accuracy: {round(train_accuracy, 4)}") # выводим логи

  # прогоняем тестовую выборку
  simple_cnn.eval()
  test_samples_count = 0
  true_test_samples_count = 0
  running_loss = 0

  for batch in test_loader:
    x_data = batch[0].cuda()
    y_data = batch[1].cuda()

    y_pred = simple_cnn(x_data)
    loss = criterion(y_pred, y_data)

    loss.backward()

    running_loss += loss.item()

    y_pred = y_pred.argmax(dim=1, keepdim=False)
    true_classified = (y_pred == y_data).sum().item()
    true_test_samples_count += true_classified
    test_samples_count += len(x_data)

  test_accuracy = true_test_samples_count / test_samples_count
  print(f"[{epoch}] test loss: {running_loss}, accuracy: {round(test_accuracy, 4)}")

[180] train loss: 40.52328181266785, accuracy: 0.6966
[180] test loss: 10.813781499862671, accuracy: 0.6583
[181] train loss: 40.517325043678284, accuracy: 0.6966
[181] test loss: 10.811877608299255, accuracy: 0.6611
[182] train loss: 40.517088294029236, accuracy: 0.6966
[182] test loss: 10.814386487007141, accuracy: 0.6611
[183] train loss: 40.515315651893616, accuracy: 0.6966
[183] test loss: 10.812204122543335, accuracy: 0.6611
[184] train loss: 40.5108939409256, accuracy: 0.6966
[184] test loss: 10.808713555335999, accuracy: 0.6639
[185] train loss: 40.50885498523712, accuracy: 0.6966
[185] test loss: 10.80833113193512, accuracy: 0.6639
[186] train loss: 40.50892996788025, accuracy: 0.6966
[186] test loss: 10.809209108352661, accuracy: 0.6639
[187] train loss: 40.508036971092224, accuracy: 0.6966
[187] test loss: 10.806900978088379, accuracy: 0.6667
[188] train loss: 40.507275462150574, accuracy: 0.6966
[188] test loss: 10.79791784286499, accuracy: 0.6611
[189] train loss: 40.50368785858154, accuracy: 0.6966
[189] test loss: 10.799399137496948, accuracy: 0.6667
[190] train loss: 40.499858379364014, accuracy: 0.6966
[190] test loss: 10.795265793800354, accuracy: 0.6611
[191] train loss: 40.498780846595764, accuracy: 0.6966
[191] test loss: 10.796114206314087, accuracy: 0.6639
[192] train loss: 40.497228503227234, accuracy: 0.6966
[192] test loss: 10.790620803833008, accuracy: 0.6639
[193] train loss: 40.44325613975525, accuracy: 0.6973
[193] test loss: 10.657087206840515, accuracy: 0.7
[194] train loss: 39.62049174308777, accuracy: 0.7495
[194] test loss: 10.483307123184204, accuracy: 0.7222
[195] train loss: 39.24516046047211, accuracy: 0.7613
[195] test loss: 10.462445378303528, accuracy: 0.7278
[196] train loss: 39.16947162151337, accuracy: 0.762
[196] test loss: 10.488057255744934, accuracy: 0.7222
[197] train loss: 39.196797251701355, accuracy: 0.7634
[197] test loss: 10.502906918525696, accuracy: 0.7222
[198] train loss: 39.395434617996216, accuracy: 0.7537
[198] test loss: 10.354896545410156, accuracy: 0.7472
[199] train loss: 39.331292152404785, accuracy: 0.7509
[199] test loss: 10.367400050163269, accuracy: 0.7389

Так, и что же имеем: только 74% предсказаний оказываются верными. Not great, not terrible.

Время улучшений!

Будем использовать Bagging. Очень кратко этот подход можно описать так: берутся несколько моделей, обучаются независимо, а затем все модели голосуют за результат. И тут могут быть различные варианты реализации: либо все модели имеют одинаковую "цену" голоса, либо у их голосов есть какие-то веса. Предсказанием метамодели считается усредненный результат.

В sklearn есть модуль ensembles, в котором представлено несколько алгоритмов для реализации ансамблей. Наш случай — классификация, используем BaggingClassifier:

import sklearn
from sklearn.ensemble import BaggingClassifier

Ансамбли оперируют базовыми моделями. В случае sklearn, базовая модель — сущность, реализующая методы sklearn.base.BaseEstimator. В зависимости от вида ансамбля, будут нужны различные реализации функций этой сущности. Для нашего случая необходимо описать метод fit (для обучения модели), функцию predict_proba, выдающую вероятность каждого класса (для того, чтобы метамодель смогла по вероятностям оценивать уверенность базовых классификаторов и присваивать их голосам большие или меньшие веса), и функцию predict (которая выдает номер класса), чтобы было удобно оценивать качество модели.

Ради понятности буду описывать каждую часть кода отдельно, потом их просто нужно "склеить" в один класс.

Конструктор класса базовой модели. Из тех граблей, на которые я успел наткнуться, стоит отметить именование параметров и их типы.

Во-первых, если вы не хотите переписывать функции клонирования объекта базового классификатора (а придется переписывать аж 2 функции — get_params и set_params), то нужно давать аргументам в конструкторе те же имена, что и присваиваемым переменным класса. То есть, если вы подаете в конструктор параметр net_type, то в методе __init__ вы должны объявить переменную net_type.

Во-вторых, лучше передавать аргументами в конструктор не объекты, а функции для их создания, потому что при копировании базовых моделей (а sklearn именно копирует переданную вами модель несколько раз, пока не получит нужное число базовых моделей) возникают различные сложности с функциями copy, deepcopy и ссылками на объекты. Например, может оказаться, что переданный и скопированный объект оптимизатора ссылается не на новый (скопированный) объект модели, а на самый первый, использованный при инициализации ансамбля.

class PytorchModel(sklearn.base.BaseEstimator):
  def __init__(self, net_type, net_params, optim_type, optim_params, loss_fn,
               input_shape, batch_size=32, accuracy_tol=0.02, tol_epochs=10,
               cuda=True):
    self.net_type = net_type # конструктор для создания нейронки
    self.net_params = net_params # параметры нейронки
    self.optim_type = optim_type # конструктор для создания оптимизатора
    self.optim_params = optim_params # параметры оптимизатора
    self.loss_fn = loss_fn # функция подсчета loss'а

    self.input_shape = input_shape # размерность входных данных
    self.batch_size = batch_size # размер батча
    self.accuracy_tol = accuracy_tol # порог точности, об его использовании -- позже
    self.tol_epochs = tol_epochs # количество эпох при данном пороге точности
    self.cuda = cuda # обучаем ли на gpu

Самое интересное: метод fit. По сути, он работает как и обучение нашей первой нейросети — пропускаем данные, считаем Loss, делаем обратное распространение ошибки. Вот только вопрос: как нам понять, какое количество эпох надо обучать модель? Первым решением может являться задание определенного количество эпох до обучения. Например, 200 (как в первой модели). Но это может привести к переобучению, а может и к недообучению. Второе решение — смотреть, как изменяется accuracy нашей модели. У первой нейросети можно заметить, что в конце accuracy держится примерно на одном уровне несколько эпох подряд. Тогда мы можем остановить обучение, если модель уже на протяжении нескольких (tol_epochs) эпох не улучшает свое качество (то есть accuracy изменяется не более, чем на accuracy_tol).

  def fit(self, X, y):
    self.net = self.net_type(**self.net_params) # создаем нашу сеть из ее конструктора и параметров
    # `**self.net_params` означает, что пары ключ-значения из словаря будут передаваться в функцию как названия аргументов и их значения
    if self.cuda:
      self.net = self.net.cuda() # перемещаем сеть на gpu, если обучаемся на нем
    self.optim = self.optim_type(self.net.parameters(), **self.optim_params) # как и сеть, создаем оптимизатор
    # в него первым параметром нужно передать обучаемые параметры нейросети

    uniq_classes = np.sort(np.unique(y)) # ищем уникальные классы
    self.classes_ = uniq_classes # одно из требований ансамбля в sklearn -- наличие в базовой модели переменной `classes_`

    X = X.reshape(-1, *self.input_shape) # изменяем размер входных данных под размерность входного слоя нейронки
    # аналогично первой нейросети создаем датасет и DataLoader
    x_tensor = torch.tensor(X.astype(np.float32))
    y_tensor = torch.tensor(y.astype(np.long))
    train_dataset = TensorDataset(x_tensor, y_tensor)
    train_loader = DataLoader(train_dataset, batch_size=self.batch_size,
                              shuffle=True, drop_last=False)
    last_accuracies = [] # тут будут храниться accuracy модели за последние `tol_epochs` эпох
    epoch = 0
    keep_training = True
    while keep_training:
      self.net.train() # для некоторых нейросетей важно вызвать этот метод (например, если вы используете BatchNormalization)
      train_samples_count = 0 # общее количество объектов выборки
      true_train_samples_count = 0 # количество верно предсказанных объектов выборки

      for batch in train_loader:
        x_data, y_data = batch[0], batch[1]
        if self.cuda:
          x_data = x_data.cuda()
          y_data = y_data.cuda()

        # прогоняем данные через модель
        y_pred = self.net(x_data)
        loss = self.loss_fn(y_pred, y_data)

        # обратное распространение ошибки
        self.optim.zero_grad()
        loss.backward()
        self.optim.step()

        y_pred = y_pred.argmax(dim=1, keepdim=False) # ищем индекс максимальной вероятности, это и есть предсказанный класс
        true_classified = (y_pred == y_data).sum().item() # ищем количество верно предсказанных объектов
        true_train_samples_count += true_classified
        train_samples_count += len(x_data)

      train_accuracy = true_train_samples_count / train_samples_count # считаем accuracy
      last_accuracies.append(train_accuracy)

      if len(last_accuracies) > self.tol_epochs:
        last_accuracies.pop(0)

      if len(last_accuracies) == self.tol_epochs:
        accuracy_difference = max(last_accuracies) - min(last_accuracies) # смотрим, какова максимальная разница в accuracy за последние `tol_epochs` эпох
        if accuracy_difference <= self.accuracy_tol:
          keep_training = False # если разница мала, прекращаем обучение

Теперь будем делать функцию для предсказания вероятностей классов. По сути — так же пропускаем данные, только не считаем Loss, а записываем все в какой-нибудь массив:

  def predict_proba(self, X, y=None):
    # точно так же, как и в fit, делаем DataLoader, из которого будем брать батчи
    X = X.reshape(-1, *self.input_shape)
    x_tensor = torch.tensor(X.astype(np.float32))
    if y:
      y_tensor = torch.tensor(y.astype(np.long))
    else:
      y_tensor = torch.zeros(len(X), dtype=torch.long)
    test_dataset = TensorDataset(x_tensor, y_tensor)
    test_loader = DataLoader(test_dataset, batch_size=self.batch_size,
                              shuffle=False, drop_last=False)

    self.net.eval() # еще одна важная функция, как и `train`, нужна для методов вроде BatchNormalization, где слои работают по-разному при обучении и валидации
    predictions = [] # массив, куда сохраняем предсказания
    for batch in test_loader:
      x_data, y_data = batch[0], batch[1]
      if self.cuda:
        x_data = x_data.cuda()
        y_data = y_data.cuda()

      y_pred = self.net(x_data)

      predictions.append(y_pred.detach().cpu().numpy()) # получаем предсказания модели, переводим их в numpy-массив и записываем в список с предсказаниями

    predictions = np.concatenate(predictions) # конкатенируем наши предсказания для батчей в предсказание для всей выборки
    return predictions

Простая и относительно красивая функция:

  def predict(self, X, y=None):
    predictions = self.predict_proba(X, y) # используем написанное ранее
    predictions = predictions.argmax(axis=1) # берем индекс максимальной вероятности, он является предсказанным классом
    return predictions

class PytorchModel(sklearn.base.BaseEstimator):
  def __init__(self, net_type, net_params, optim_type, optim_params, loss_fn,
               input_shape, batch_size=32, accuracy_tol=0.02, tol_epochs=10,
               cuda=True):
    self.net_type = net_type
    self.net_params = net_params
    self.optim_type = optim_type
    self.optim_params = optim_params
    self.loss_fn = loss_fn

    self.input_shape = input_shape
    self.batch_size = batch_size
    self.accuracy_tol = accuracy_tol
    self.tol_epochs = tol_epochs
    self.cuda = cuda

  def fit(self, X, y):
    self.net = self.net_type(**self.net_params)
    if self.cuda:
      self.net = self.net.cuda()
    self.optim = self.optim_type(self.net.parameters(), **self.optim_params)

    uniq_classes = np.sort(np.unique(y))
    self.classes_ = uniq_classes

    X = X.reshape(-1, *self.input_shape)
    x_tensor = torch.tensor(X.astype(np.float32))
    y_tensor = torch.tensor(y.astype(np.long))
    train_dataset = TensorDataset(x_tensor, y_tensor)
    train_loader = DataLoader(train_dataset, batch_size=self.batch_size,
                              shuffle=True, drop_last=False)
    last_accuracies = []
    epoch = 0
    keep_training = True
    while keep_training:
      self.net.train()
      train_samples_count = 0
      true_train_samples_count = 0

      for batch in train_loader:
        x_data, y_data = batch[0], batch[1]
        if self.cuda:
          x_data = x_data.cuda()
          y_data = y_data.cuda()

        y_pred = self.net(x_data)
        loss = self.loss_fn(y_pred, y_data)

        self.optim.zero_grad()
        loss.backward()
        self.optim.step()

        y_pred = y_pred.argmax(dim=1, keepdim=False)
        true_classified = (y_pred == y_data).sum().item()
        true_train_samples_count += true_classified
        train_samples_count += len(x_data)

      train_accuracy = true_train_samples_count / train_samples_count
      last_accuracies.append(train_accuracy)

      if len(last_accuracies) > self.tol_epochs:
        last_accuracies.pop(0)

      if len(last_accuracies) == self.tol_epochs:
        accuracy_difference = max(last_accuracies) - min(last_accuracies)
        if accuracy_difference <= self.accuracy_tol:
          keep_training = False

  def predict_proba(self, X, y=None):
    X = X.reshape(-1, *self.input_shape)
    x_tensor = torch.tensor(X.astype(np.float32))
    if y:
      y_tensor = torch.tensor(y.astype(np.long))
    else:
      y_tensor = torch.zeros(len(X), dtype=torch.long)
    test_dataset = TensorDataset(x_tensor, y_tensor)
    test_loader = DataLoader(test_dataset, batch_size=self.batch_size,
                              shuffle=False, drop_last=False)

    self.net.eval()
    predictions = []
    for batch in test_loader:
      x_data, y_data = batch[0], batch[1]
      if self.cuda:
        x_data = x_data.cuda()
        y_data = y_data.cuda()

      y_pred = self.net(x_data)

      predictions.append(y_pred.detach().cpu().numpy())

    predictions = np.concatenate(predictions)
    return predictions

  def predict(self, X, y=None):
    predictions = self.predict_proba(X, y)
    predictions = predictions.argmax(axis=1)
    return predictions

Итак, протестируем наш новоиспеченный классификатор:

base_model = PytorchModel(net_type=SimpleCNN, net_params=dict(), optim_type=Adam,
                          optim_params={"lr": 1e-3}, loss_fn=nn.CrossEntropyLoss(),
                          input_shape=(1, 8, 8), batch_size=32, accuracy_tol=0.02,
                          tol_epochs=10, cuda=True)

base_model.fit(x_train_scaled, y_train) # обучение модели

preds = base_model.predict(x_test_scaled) # предсказываем на тестовом наборе
true_classified = (preds == y_test).sum() # количество верно предсказанных объектов
test_accuracy = true_classified / len(y_test) # accuracy

print(f"Test accuracy: {test_accuracy}")
>>> Test accuracy: 0.7361111111111112

Все готово для создания ансамбля.

meta_classifier = BaggingClassifier(base_estimator=base_model, n_estimators=10) # заметьте, что в конструктор передаем именно объект базового классификатора

meta_classifier.fit(x_train_scaled.reshape(-1, 64), y_train) # обучаем на тестовой выборке, на вход требуется двумерный массив, поэтому reshape'им
>>> BaggingClassifier(
           base_estimator=PytorchModel(accuracy_tol=0.02, batch_size=32,
              cuda=True, input_shape=(1, 8, 8),
              loss_fn=CrossEntropyLoss(),
              net_params={},
              net_type=<class '__main__.SimpleCNN'>,
              optim_params={'lr': 0.001},
              optim_type=<class 'torch.optim.adam.Adam'>,
              tol_epochs=10),
          bootstrap=True, bootstrap_features=False, max_features=1.0,
          max_samples=1.0, n_estimators=10, n_jobs=None,
          oob_score=False, random_state=None, verbose=0,
          warm_start=False)

Теперь можно с помощью уже реализованной функции score оценить accuracy нашего ансамбля:

print(meta_classifier.score(x_test_scaled.reshape(-1, 64), y_test))
>>> 0.95

Некоторые выводы и куда двигаться дальше

Ансамбль действительно лучше справляется с задачей классификации, чем одна модель. Это происходит благодаря большей обобщающей способности. У ансамблей есть ряд преимуществ по сравнению с обычными моделями. Например, товарищи обнаружили, что ансамбли являются более устойчивыми на новых данных (то есть их предсказания не начинают "скакать" из-за неуверенности модели).

Что можно улучшить?

Во-первых, обучение. Возможно, нужно смотреть на Loss'ы или как-нибудь подбирать параметры для остановки обучения на ходу.

Во-вторых, можно реализовать Boosting. Его отличие от Bagging'а в том, что модели строятся не независимо, а каждая следующая учитывает ошибки предыдущей. То есть при обучении неудачным (неправильно классифицированным) примерам придается больший вес. Тут лучше покопаться в исходном коде sklearn, а потом можно поэлементно умножать Loss нейронки на какие-то веса.

В третьих, можно формировать ансамбль из разных видов нейронок. Тогда увеличивается разница в том, как модели "видят" данные. Как будто у метамодели появляется новая точка зрения, и она может глубже понять ситуацию.

Терпеливому читателю

Спасибо, что дочитали этот пост до конца. Мне было бы очень интересно услышать Ваше мнение по поводу статьи — какие-то замечания, предложения, идеи, в общем, все, что Вас воодушевляет и чем Вы готовы поделиться с миром.

Пару слов об мне. Меня зовут Евгений, Data science'ом я занимаюсь уже полтора года. Сейчас в большей степени погружаюсь в Computer vision, но также интересуюсь нейротехнологиями. (Соединить искусственные и натуральные нейронные сети — моя мечта!) Этот пост создан благодаря нашей команде — FARADAY Lab. Мы — начинающие российские стартаперы и готовы делиться с Вами тем, что узнаем сами.

Удачи c:

Полезные ссылки

• Jupyter-notebook с кодом
• Bagging
• Документация к sklearn.ensemble.BaggingClassifier
• Sklearn: ensemble methods
• Примеры с PyTorch
• Sklearn: StandardScaler
• Sklearn: BaseEstimator