Ансамблирование моделей нейронных сетей

---

Введение

Ансамблирование моделей – это популярный подход в машинном обучении, который помогает улучшить производительность моделей, особенно на новых, не виденных данных. В своей основе он заключается в объединении сильных сторон нескольких моделей для достижения лучших результатов, чем любая отдельная модель могла бы получить самостоятельно. Эта техника повышает точность, увеличивает устойчивость и улучшает способность модели к обобщению.

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

Существуют различные способы комбинирования моделей в ансамбле, начиная с простых методов, таких как усреднение их прогнозов, и заканчивая более сложными техниками, такими как бэггинг, бустинг или стекинг. Каждый метод предлагает свой способ объединения моделей для того, чтобы сделать окончательное решение более надежным.

Основные выводы

• Ансамблевое обучение объединяет несколько нейронных сетей для повышения точности предсказаний, устойчивости и обобщаемости.

• Рабочий процесс обычно включает в себя подготовку набора данных, обучение нескольких моделей и интеграцию их выходов с использованием ансамблевых стратегий.

• Общие ансамблевые методы включают:

  • Конкатенационное ансамблирование: Объединяет признаки из нескольких моделей для создания более насыщенного представления.
• Среднее ансамбля: Берёт среднее значений предсказаний от всех моделей, просто, но эффективно.
• Взвешенный средний ансамбль: Назначает различную важность (веса) моделям в зависимости от их индивидуальной производительности.

Сравнение между одиночными и ансамблевыми моделями показывает, что ансамбли часто превосходят одиночные модели в сложных задачах, но могут добавить больше вычислительных затрат.

Ансамблевые методы особенно полезны, когда отдельные модели делают разнообразные ошибки, которые можно исправить коллективно.

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

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

Тем не менее, для более крупных задач объединение нескольких нейронных сетей, особенно тех, которые обучены на схожих задачах, может оказаться весьма полезным и улучшить производительность окончательной модели, а также её способность обобщать на более широкие случаи использования.

Часто возникает необходимость попробовать несколько моделей с разными конфигурациями, чтобы выбрать модель с наилучшей производительностью для данной задачи. Ансамблирование нейронных сетей предлагает возможность использовать информацию различных моделей для разработки более сбалансированной и эффективной модели.

Например, комбинирование нескольких сетевых моделей, которые были обучены на конкретном наборе данных (например, наборе данных Imagenet), может оказаться полезным для улучшения производительности модели, обучаемой на наборе данных с похожими классами. Разная информация, полученная моделями, может быть объединена с помощью ансаблирования моделей, что улучшает общую производительность и надежность агрегированной модели. Перед объединением таких моделей важно обучить и тонко настроить членов ансамбля, чтобы гарантировать, что каждая модель вносит актуальную информацию в финальную модель.

Датасет

Для этого учебника мы будем использовать классификацию изображений природных объектов. Мы будем использовать набор данных о природных изображениях, который содержит 6899 изображений, представляющих 8 классов. Классы, представленные в наборе данных: самолет, автомобиль, кошка, собака, фрукт, мотоцикл и человек.

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

Рабочий процесс

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

Установите начальное значение для воспроизводимости и предварительного просмотра образцов изображений по классам

Seed environment  seed_value = 1 # seed value   Set`PYTHONHASHSEED` environment variable at a fixed value  import os os.environ['PYTHONHASHSEED']=str(seed_value)  rti Set the `python` built-in pseudo-random generator at a fixed value  import random  random.seed = seed_value   Set the `numpy` pseudo-random generator at a fixed value  import numpy as np  np.random.seed = seed_value   Set the `tensorflow` pseudo-random generator at a fixed value import tensorflow as tf tf.seed = seed_value 

Настройте конфигурации данных и получите классы

set configs  base_path = './natural_images'  target_size = (224,224,3)   define shape for all images # get classes classes = os.listdir(base_path) print(classes) 

Построить образцы изображений из набора данных

plot sample images   import matplotlib.pyplot as plt import cv2  f, axes = plt.subplots(2, 4, sharex=True, sharey=True, figsize = (16,7))  for ax, label in zip(axes.ravel(), classes):     img = np.random.choice(os.listdir(os.path.join(base_path, label)))     img = cv2.imread(os.path.join(base_path, label, img))     img = cv2.resize(img, target_size[:2])     ax.imshow(cv2.cvtColor(img, cv2.COLOR_BGRA2RGB))     ax.set_title(label)     ax.axis(False) 

Загрузите изображения

Мы загружаем изображения партиями, используя Keras Image Generator, и указываем разделение для валидации, чтобы разделить набор данных на обучающую и валидационную части.

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

from keras.preprocessing.image import ImageDataGenerator  batch_size = 32  datagen = ImageDataGenerator(rescale=1./255,                                    rotation_range=20,                                    shear_range=0.2,                                    zoom_range=0.2,                                    width_shift_range = 0.2,                                    height_shift_range = 0.2,                                    vertical_flip = True,                                    validation_split=0.25) 

train_gen = datagen.flow_from_directory(base_path,                                                target_size=target_size[:2],                                                batch_size=batch_size,                                                class_mode='categorical',                                                subset='training') val_gen =  datagen.flow_from_directory(base_path,                                                target_size=target_size[:2],                                                batch_size=batch_size,                                                class_mode='categorical',                                                subset='validation',                                                shuffle=False) 

1. Создайте и обучите пользовательскую модель

Для нашей первой модели мы создали пользовательскую модель, используя функциональный метод Tensorflow.

Build model  input = Input(shape= target_size)   x = Conv2D(filters=32, kernel_size=(3,3), activation='relu')(input)  x = MaxPool2D(2,2)(x)   x = Conv2D(filters=64, kernel_size=(3,3), activation='relu')(x)  x = MaxPool2D(2,2)(x)   x = Conv2D(filters=128, kernel_size=(3,3), activation='relu')(x)  x = MaxPool2D(2,2)(x)   x = Conv2D(filters=256, kernel_size=(3,3), activation='relu')(x)  x = MaxPool2D(2,2)(x)   x = Dropout(0.25)(x)  x = Flatten()(x)  x = Dense(units=128, activation='relu')(x)  x = Dense(units=64, activation='relu')(x)  output = Dense(units=8, activation='softmax')(x)   custom_model  = Model(input, output, name= 'Custom_Model') 

Следующим шагом мы компилируем пользовательскую модель и настраиваем обратные вызовы для управления обучением. Мы используем уменьшение скорости обучения на плоскости, EarlyStopping для остановки обучения, когда не наблюдается дальнейших улучшений, и ModelCheckpoint для сохранения лучшей модели на каждой эпохе. Это стандартные практики для эффективного обучения глубоким нейронным сетям.

compile model custom_model.compile(loss= 'categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])   initialize callbacks  reduceLR = ReduceLROnPlateau(monitor='val_loss', patience= 3, verbose= 1,                                  mode='min', factor=  0.2, min_lr = 1e-6)   early_stopping = EarlyStopping(monitor='val_loss', patience = 5 , verbose=1,                                  mode='min', restore_best_weights= True)   checkpoint = ModelCheckpoint('CustomModel.weights.hdf5', monitor='val_loss',                               verbose=1,save_best_only=True, mode= 'min')   callbacks= [reduceLR, early_stopping,checkpoint] 

Теперь мы можем определить наши конфигурации обучения и обучить нашу собственную модель.

define training config  TRAIN_STEPS = 5177 // batch_size  VAL_STEPS = 1722 //batch_size  epochs = 80   train model custom_model.fit(train_gen, steps_per_epoch= TRAIN_STEPS, validation_data=val_gen, validation_steps=VAL_STEPS, epochs= epochs, callbacks= callbacks) 

После обучения нашей кастомной модели мы можем оценить ее эффективность. Я оценю модель на валидационном наборе. На практике предпочтительно выделить отдельный тестовый набор для оценки модели.

Evaluate the model  custom_model.evaluate(val_gen) 

Потеря на валидации и точность

Мы также можем получить предсказания и фактические метки валидации, чтобы проверить отчет о классификации и оценки матрицы ошибок для пользовательской модели.

get validation labels val_labels = []  for i in range(VAL_STEPS + 1):   val_labels.extend(val_gen[i][1])  val_labels = np.argmax(val_labels, axis=1) 

show classification report   from sklearn.metrics import classification_report   print(classification_report(val_labels, predicted_labels, target_names=classes)) 

Отчет по классификации

function to plot confusion matrix  import itertools  def plot_confusion_matrix(actual, predicted):      cm = confusion_matrix(actual, predicted)     cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]      plt.figure(figsize=(7,7))     cmap=plt.cm.Blues     plt.imshow(cm, interpolation='nearest', cmap=cmap)     plt.title('Confusion matrix', fontsize=25)        tick_marks = np.arange(len(classes))     plt.xticks(tick_marks, classes, rotation=90, fontsize=15)     plt.yticks(tick_marks, classes, fontsize=15)      thresh = cm.max() / 2.     for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):         plt.text(j, i, format(cm[i, j], '.2f'),         horizontalalignment="center",         color="white" if cm[i, j] > thresh else "black", fontsize = 14)      plt.ylabel('True label', fontsize=20)     plt.xlabel('Predicted label', fontsize=20)     plt.show() 

plot confusion matrix plot_confusion_matrix(val_labels, predicted_labels) 

Матрица путаницы с использованием пользовательской модели

Из оценки модели мы замечаем, что пользовательская модель не смогла правильно идентифицировать изображения котов и цветов. Она также демонстрирует субоптимальную точность при идентификации самолетов.

Затем мы попробуем другую технику построения модели: использовать веса, изученные сетями, предварительно обученными на наборе данных Imagenet, чтобы повысить производительность нашей модели в классах с низкими баллами точности.

2. Использование предобученной модели VGG16.

Для нашей второй модели мы будем использовать модель VGG16, предварительно обученную на наборе данных Imagenet, чтобы обучить модель для нашего случая использования. Это позволяет нам унаследовать веса, полученные в результате обучения на аналогичном наборе данных, чтобы повысить производительность нашей модели.

Инициализация и дообучение модели VGG16

Import the VGG16 pretrained model  from tensorflow.keras.applications import VGG16   initialize the model vgg16 = VGG16(input_shape=(224,224,3), weights='imagenet', include_top=False)   Freeze all but the last 3 layers for layer in vgg16.layers[:-3]: layer.trainable = False   build model  input = vgg16.layers[-1].output # input is the last output from vgg16   x = Dropout(0.25)(input)  x = Flatten()(x)  output = Dense(8, activation='softmax')(x)   create the model  vgg16_model = Model(vgg16.input, output, name='VGG16_Model') 

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

Затем мы можем обучить нашу настроенную модель VGG16, используя аналогичные настройки обучения, что и для нашей пользовательской модели.

compile the model  vgg16_model.compile(optimizer= SGD(learning_rate=1e-3), loss= 'categorical_crossentropy', metrics= ['accuracy'])   reinitialize callbacks  checkpoint = ModelCheckpoint('VggModel.weights.hdf5', monitor='val_loss', verbose=1,save_best_only=True, mode= 'min')   callbacks= [reduceLR, early_stopping,checkpoint]   Train model  vgg16_model.fit(train_gen, steps_per_epoch= TRAIN_STEPS, validation_data=val_gen, validation_steps=VAL_STEPS, epochs= epochs, callbacks= callbacks) 

После обучения мы можем оценить эффективность модели, используя аналогичные сценарии из последней оценки модели.

Evaluate the model  vgg16_model.evaluate(val_gen)  get the model predictions  predicted_labels = np.argmax(vgg16_model.predict(val_gen), axis=1)   show classification report  print(classification_report(val_labels, predicted_labels, target_names=classes))   plot confusion matrix  plot_confusion_matrix(val_labels, predicted_labels) 

Отчет о классификации с использованием предварительно обученной модели VGG

Отчет матрицы путаницы с использованием предобученной модели VGG

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

Наконец, перед объединением, мы будем использовать еще одну предварительно обученную модель с гораздо меньшим количеством параметров, чем VGG16. Цель состоит в том, чтобы использовать различные архитектуры, чтобы мы могли извлечь пользу из их различных свойств и улучшить качество нашей финальной модели. Мы будем использовать модель Mobilenet, предварительно обученную на том же наборе данных Imagenet.

3. Используя предобученную модель Mobilenet.

Для нашей финальной модели мы будем донастраивать модель MobileNet.

initializing the mobilenet model mobilenet = MobileNet(input_shape=(224,224,3), weights='imagenet', include_top=False)  freezing all but the last 5 layers for layer in mobilenet.layers[:-5]:   layer.trainable = False  add few mor layers x = mobilenet.layers[-1].output x = Dropout(0.5)(x) x = Flatten()(x)  x = Dense(32, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(16, activation='relu')(x) output = Dense(8, activation='softmax')(x)  Create the model mobilenet_model = Model(mobilenet.input, output, name= "Mobilenet_Model") 

Для обучения модели мы сохраняем некоторые из предыдущих конфигураций из нашего предыдущего обучения.

compile the model  mobilenet_model.compile(optimizer= SGD(learning_rate=1e-3), loss= 'categorical_crossentropy', metrics= ['accuracy'])   reinitialize callbacks  checkpoint = ModelCheckpoint('MobilenetModel.weights.hdf5', monitor='val_loss', verbose=1,save_best_only=True, mode= 'min')   callbacks= [reduceLR, early_stopping,checkpoint]   model training  mobilenet_model.fit(train_gen, steps_per_epoch= TRAIN_STEPS, validation_data=val_gen, validation_steps=VAL_STEPS, epochs=epochs, callbacks= callbacks) 

После обучения нашей дообученной модели Mobilenet мы можем оценить ее производительность.

Evaluate the model  mobilenet_model.evaluate(val_gen)   get the model's predictions  predicted_labels = np.argmax(mobilenet_model.predict(val_gen), axis=1)   show the classification report  print(classification_report(val_labels, predicted_labels, target_names=classes))   plot the confusion matrix  plot_confusion_matrix(val_labels, predicted_labels) 

Точно настроенная модель Mobilenet показывает лучшие результаты по сравнению с предыдущими моделями и заметно улучшает идентификацию собак и цветов.

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

Ансамблирование моделей

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

Методы имеют свои плюсы и минусы, которые часто рассматриваются для определения выбора для конкретного варианта использования.

Конкатенация ансамбля

Это включает в себя объединение параметров нескольких моделей в одну модель. Это осуществляется в Tensorflow с помощью слоя конкатенации, который принимает входные тензоры одинаковой формы (за исключением оси конкатенации) и объединяет их в один. Следовательно, этот слой может использоваться для объединения всей информации, полученной различными моделями, бок о бок на одной оси в единую модель.

Чтобы объединить наши модели, мы просто введем наши модели в слой конкатенации.

concatenate the models  import concatenate layer from tensorflow.keras.layers import Concatenate  get list of models models = [custom_model, vgg16_model, mobilenet_model]   input = Input(shape=(224, 224, 3), name='input') # input layer  get output for each model input outputs = [model(input) for model in models]  contenate the ouputs x = Concatenate()(outputs)   add further layers x = Dropout(0.5)(x)  output = Dense(8, activation='softmax', name='output')(x) # output layer  create concatenated model conc_model = Model(input, output, name= 'Concatenated_Model') 

После конкатенации мы добавили дополнительные слои, как это было необходимо для нашей задачи. В этом примере я добавил слой регуляризации (dropout) и финальный выходной слой с соответствующими выходными размерами для нашего случая использования.

Давайте проверим структуру нашей конкатенированной модели.

show model structure  from tensorflow.keras.utils import plot_model  plot_model(conc_model)  

Структура конкатенированной модели

Мы можем увидеть, как три различных функциональных модели, которые мы построили, объединяются в одну с дальнейшими слоями отбора и вывода.

Это может оказаться полезным в некоторых случаях, поскольку мы используем всю информацию, полученную от различных моделей. Проблема с этим методом заключается в том, что размер нашей финальной модели является конкатенацией размеров всех членов ансамбля, что может привести к взрыву размерности, включению неактуальной информации и, следовательно, к переобучению.

Средний ансамбль

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

На этот раз мы будем использовать слой Average из Tensorflow, который принимает входные данные и выводит их среднее значение. Таким образом, наша финальная модель является средним значением параметров наших входных моделей.

Чтобы объединить нашу модель методом усреднения, мы просто комбинируем наши модели на слое усреднения.

average ensemble model   import Average layer from tensorflow.keras.layers import Average   input = Input(shape=(224, 224, 3), name='input')  # input layer  get output for each input model outputs = [model(input) for model in models]   take average of the outputs x = Average()(outputs)   x = Dense(16, activation='relu')(x)  x = Dropout(0.3)(x)  output = Dense(8, activation='softmax', name='output')(x) # output layer  create average ensembled model avg_model = Model(input, output) 

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

show model structure  plot_model(avg_model) 

Этот подход к объединению моделей особенно полезен, поскольку, беря среднее значение, модели с низкой производительностью для определенных классов усиливаются моделями с высокой производительностью для таких классов, тем самым улучшая общую производительность и обобщение модели.

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

Это можно решить, используя взвешенное среднее моделей при ансамблировании, так чтобы оно отражало важность каждой модели для окончательного решения.

Взвешенное среднее объединение

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

Хотя TensorFlow не имеет встроенного слоя для взвешенного среднего ансамблирования, мы можем использовать атрибуты встроенного класса Layer, чтобы реализовать пользовательский слой взвешенного среднего ансамбля. Для взвешенного среднего ансамбля необходимо, чтобы суммы весов равнялись одному; мы можем обеспечить это, применяя функцию softmax к весам перед ансамблированием. Вы можете узнать больше о создании пользовательских слоев в TensorFlow здесь.

Реализация пользовательского слоя с взвешенным средним

Сначала мы определяем пользовательскую функцию для задания наших весов.

function for setting weights  import numpy as np  def weight_init(shape =(1,1,3), weights=[1,2,3], dtype=tf.float32):     return tf.constant(np.array(weights).reshape(shape), dtype=dtype) 

Здесь мы установили веса наших моделей на 1, 2 и 3 соответственно. Затем мы можем построить наш пользовательский слой с взвешенным среднем.

implement custom weighted average layer  import tensorflow as tf from tensorflow.keras.layers import Layer, Concatenate  class WeightedAverage(Layer):      def __init__(self):         super(WeightedAverage, self).__init__()              def build(self, input_shape):                  self.W = self.add_weight(                     shape=(1,1,len(input_shape)),                     initializer=weighted_init,                     dtype=tf.float32,                     trainable=True)     def call(self, inputs):              inputs = [tf.expand_dims(i, -1) for i in inputs]         inputs = Concatenate(axis=-1)(inputs)          weights = tf.nn.softmax(self.W, axis=-1)          return tf.reduce_mean(weights*inputs, axis=-1)     

Чтобы создать наш собственный слой с взвешенной средней, мы унаследовали атрибуты встроенного класса Layer и добавили веса, используя нашу функцию инициализации весов. Мы применяем softmax к инициализированным весам, чтобы они в сумме давали один, прежде чем умножить их на модели. Наконец, мы получаем среднее значение взвешенных входных данных, чтобы получить нашу финальную модель.

Затем мы можем объединить нашу модель, используя пользовательский слой взвешенного среднего.

input = Input(shape=(224, 224, 3), name='input')  # input layer  get output for each input model outputs = [model(input) for model in models]   get weighted average of outputs x = WeightedAverage()(outputs)  output = Dense(8, activation='softmax')(x) # output layer  weighted_avg_model = Model(input, output, name= 'Weighted_AVerage_Model') 

Давайте проверим структуру нашей модели взвешенного среднего.

plot model plot_model(weighted_avg_model) 

Структура модели взвешенного среднего ансамбля Как и в предыдущих методах, наши модели объединены в ансамбль, но на этот раз в виде взвешенного среднего трех моделей. Степень выхода объединенной модели также соответствует необходимой степени выхода для нашей задачи без добавления дополнительных слоев.

Также, вместо того чтобы вручную устанавливать наши веса с помощью функции инициализации весов, мы могли бы использовать встроенные инициализаторы весов Tensorflow для инициализации весов, которые оптимизируются во время обучения. Смотрите здесь доступные встроенные инициализаторы весов в Tensorflow.

Единая модель против ансамбля

Метрическая система	Единая модель	Энсембл (Стекинг)
Точность	~85%	~89–91%
Время тренировки	Низкий	Высокий (Несколько моделей)
Время вывода	Быстро	Медленнее (несколько проходов)
Обобщение	Умеренный	Высокий
Устойчивость	Ниже	Выше

Ансиблирование улучшает точность и надежность, но увеличивает время обучения/вывода и использование памяти. Ансиблирование полезно, когда производительность важнее задержки.

Часто задаваемые вопросы

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

2. Можете ли вы объединить разные типы нейронных сетей?
Да, вы можете объединить модели, такие как CNN, LSTM и MLP. Это особенно полезно, когда каждая модель захватывает разные аспекты данных.

3. Сколько моделей мне следует использовать в ансамбле?
Нет фиксированного числа — это зависит от вашего набора данных, вычислительной мощности и целей производительности. Даже 2-3 хорошо выбранные модели могут обеспечить заметные улучшения.

4. В чем разница между Бэггингом и Стэкингом?
Бэггинг обучает модели независимо на разных подмножеках данных и усредняет их предсказания, в то время как Стэкинг комбинирует различные модели с использованием мета-обучателя, обученного на их выходах.

5. Как используется ансемблирование в больших языковых моделях (LLMs)?
В больших языковых моделях (LLMs) ансемблирование используется для объединения выводов из нескольких контрольных точек модели или версий, что улучшает точность и снижает предвзятость или галлюцинации.

Резюме

Ансамблирование моделей улучшает производительность и обобщение моделей машинного обучения, объединяя несколько моделей в единую архитектуру. В нейронных сетях TensorFlow позволяет применять различные стратегии ансамблирования, такие как конкатенация, усреднение и пользовательское взвешенное усреднение. Хотя конкатенация сохраняет все признаки (за счет увеличения размерности), усреднение упрощает модель, но может упустить важность модели. Пользовательское взвешенное усреднение решает эту проблему, обучая оптимальные веса во время тренировки. Эти техники также могут быть расширены более сложными или специфическими для задачи операциями, что делает ансамблирование гибким и мощным инструментом в глубоком обучении.

Связанные ресурсы

• Что такое глубокое обучение
• https://linux-console.net/community/tutorials/constructing-neural-networks-from-scratch
• Глобальное объединение в сверточных нейронных сетях
• Случайный лес в машинном обучении
• https://linux-console.net/community/tutorials/decision-trees-machine-learning-explained