Ensemble de modèles de réseaux neuronaux

Introduction

L'assemblage de modèles est une approche populaire en apprentissage automatique qui aide à améliorer la performance des modèles, notamment sur de nouvelles données non vues. Au cœur du concept, il s'agit de combiner les forces de plusieurs modèles pour obtenir de meilleurs résultats que n'importe quel modèle unique ne pourrait le faire seul. Cette technique améliore la précision, augmente la robustesse et renforce la capacité du modèle à généraliser.

Les algorithmes basés sur des arbres, par exemple, brillent souvent dans certaines tâches car ils fonctionnent naturellement en combinant les résultats de plusieurs arbres de décision pour créer une prédiction globale plus forte.

Il existe différentes façons de combiner des modèles dans un ensemble, allant de méthodes simples comme la moyenne de leurs prédictions à des techniques plus sophistiquées comme le bagging, le boosting ou le stacking. Chaque méthode offre sa propre manière de mélanger les modèles pour rendre la décision finale plus fiable.

Principales conclusions

• L'apprentissage d'ensemble combine plusieurs réseaux neuronaux pour améliorer la précision des prédictions, la robustesse et la généralisation.

• Le flux de travail implique généralement de préparer le jeu de données, de former plusieurs modèles et d'intégrer leurs résultats en utilisant des stratégies d'ensemble.

• Les méthodes d'assemblage courantes comprennent :

  • Ensemble de concaténation : Fusionne les caractéristiques de plusieurs modèles pour une représentation plus riche.
  • Ensemble Moyenne: Prend la moyenne des prédictions de tous les modèles, simple mais efficace.
  • Moyenne Pondérée d'Ensemble : Assigne différentes importances (pondérations) aux modèles en fonction de leur performance individuelle.

• Une comparaison entre des modèles simples et des modèles d'ensemble montre que les ensembles surpassent souvent les modèles simples dans des tâches complexes, mais peuvent introduire plus de surcharge computationnelle.

• Les méthodes d'ensemble sont particulièrement bénéfiques lorsque les modèles individuels commettent des erreurs diverses qui peuvent être corrigées collectivement.

• Choisir la bonne technique d'ensemble dépend de votre type de données, architecture de modèle et objectifs d'évaluation.

Contrairement aux algorithmes classiques, il n'est pas courant d'assembler plusieurs modèles de réseaux de neurones pour une seule tâche. Cela est principalement dû au fait que les modèles uniques sont souvent suffisants pour établir la relation entre les caractéristiques et les cibles, et l'assemblage de plusieurs réseaux de neurones peut compliquer le modèle pour des tâches plus petites et conduire à un surajustement. Il est plus fréquent que les praticiens augmentent la taille d'un seul modèle de réseau de neurones pour s'adapter correctement aux données plutôt que d'assembler plusieurs modèles de réseaux de neurones en un.

Cependant, pour des tâches plus importantes, l'assemblage de plusieurs réseaux de neurones, en particulier ceux formés sur des problèmes similaires, pourrait s'avérer très utile et améliorer la performance du modèle final ainsi que sa capacité à se généraliser à des cas d'utilisation plus larges.

Il est souvent nécessaire d'essayer plusieurs modèles avec différentes configurations pour sélectionner le modèle le plus performant pour un problème. L'assemblage de réseaux de neurones offre la possibilité d'utiliser les informations des différents modèles pour développer un modèle plus équilibré et efficace.

Par exemple, combiner plusieurs modèles de réseau qui ont été entraînés sur un ensemble de données particulier (tel que l'ensemble de données Imagenet) pourrait s'avérer utile pour améliorer la performance d'un modèle entraîné sur un ensemble de données avec des classes similaires. Les différentes informations apprises par les modèles pourraient être combinées par l'assemblage de modèles pour améliorer la performance globale et la robustesse d'un modèle agrégé. Avant d'assembler de tels modèles, il est important d'entraîner et d'affiner les membres de l'ensemble pour s'assurer que chaque modèle apporte des informations pertinentes au modèle final.

Le jeu de données

Pour ce tutoriel, nous allons utiliser la classification d'images d'images naturelles. Nous utiliserons le jeu de données des images naturelles, qui contient 6899 images d'images naturelles représentant 8 classes. Les classes représentées dans le jeu de données sont avion, voiture, chat, chien, fruit, moto et personne.

Notre objectif est de développer un modèle de réseau de neurones capable d'identifier des images appartenant à différentes classes et de classer avec précision de nouvelles images de chaque classe.

Flux de travail

Nous développerions trois modèles différents pour notre tâche, puis nous les combinerions en utilisant différentes méthodes. Il est important de configurer nos modèles pour fournir des informations pertinentes à notre modèle final.

Définir une graine pour la reproductibilité et prévisualiser des images d'échantillons par classe

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

Configurer les données et obtenir les classes

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)

Tracer des échantillons d'images du jeu de données

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)

Charger les images

Nous chargeons les images par lots en utilisant le générateur d'images Keras et spécifions une division de validation pour séparer l'ensemble de données en ensembles d'entraînement et de validation.

Nous appliquons également une augmentation aléatoire des images pour élargir l'ensemble de données d'entraînement, améliorant ainsi les performances du modèle et sa capacité de généralisation.

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. Créez et entraînez un modèle personnalisé

Pour notre premier modèle, nous avons construit un modèle personnalisé en utilisant la méthode fonctionnelle de 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')

Ensuite, nous compilons le modèle personnalisé et mettons en place des rappels pour gérer l'entraînement. Nous utilisons la réduction du taux d'apprentissage en plateau, l'EarlyStopping pour interrompre l'entraînement lorsqu'aucune amélioration supplémentaire n'est observée, et le ModelCheckpoint pour sauvegarder le meilleur modèle à chaque époque. Ce sont des pratiques standard pour un entraînement efficace en apprentissage profond.

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]

Maintenant, nous pouvons définir nos configurations d'entraînement et former notre modèle personnalisé.

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)

Après avoir entraîné notre modèle personnalisé, nous pouvons évaluer ses performances. J'évaluerai le modèle sur l'ensemble de validation. En pratique, il est préférable de réserver un ensemble de test séparé pour l'évaluation du modèle.

Evaluate the model 
custom_model.evaluate(val_gen)

Perte de validation et précision

Nous pouvons également récupérer les prévisions et les étiquettes de validation réelles afin de vérifier le rapport de classification et les évaluations de la matrice de confusion pour le modèle personnalisé.

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))

Rapport de classification

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)

Matrice de confusion utilisant le modèle personnalisé

D'après l'évaluation du modèle, nous remarquons que le modèle personnalisé ne parvient pas à identifier correctement les images de chats et de fleurs. Il donne également une précision sub-optimale pour l'identification des avions.

Ensuite, nous essaierons une autre technique de construction de modèle : utiliser des poids appris par des réseaux pré-entraînés sur le jeu de données Imagenet pour améliorer les performances de notre modèle dans les classes avec des scores de précision plus bas.

2. Utiliser un modèle VGG16 pré-entraîné.

Pour notre deuxième modèle, nous utiliserons le modèle VGG16 pré-entraîné sur le jeu de données Imagenet pour entraîner un modèle adapté à notre cas d'utilisation. Cela nous permet d'hériter des poids appris lors de l'entraînement sur un jeu de données similaire pour améliorer les performances de notre modèle.

Initialisation et ajustement du modèle 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')

Nous initialisons le modèle pré-entraîné et gelons tous les calques sauf les trois derniers afin de pouvoir utiliser les poids des modèles et apprendre de nouvelles informations dans les trois derniers calques qui sont spécifiques à notre cas d'utilisation. Nous ajoutons également une couche de régularisation pour empêcher le modèle de surajuster notre ensemble de données avant d'ajouter notre couche de sortie finale.

Nous pouvons ensuite entraîner notre modèle VGG16 affiné en utilisant des configurations d'entraînement similaires à notre modèle personnalisé.

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)

Après l'entraînement, nous pouvons évaluer la performance du modèle en utilisant des scripts similaires à ceux de la dernière évaluation du modèle.

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)

Rapport de classification utilisant le modèle VGG pré-entraîné

Rapport de matrice de confusion utilisant le modèle VGG pré-entraîné

L'utilisation d'un modèle VGG16 pré-entraîné a produit de meilleures performances, en particulier pour les classes avec des scores plus faibles.

Enfin, avant l'assemblage, nous utiliserions un autre modèle pré-entraîné avec beaucoup moins de paramètres que le VGG16. L'objectif est d'utiliser différentes architectures afin de pouvoir tirer parti de leurs propriétés variées pour améliorer la qualité de notre modèle final. Nous utiliserions le modèle Mobilenet pré-entraîné sur le même ensemble de données Imagenet.

3. Utiliser un modèle Mobilenet pré-entraîné.

Pour notre modèle final, nous allons affiner le modèle 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")

Pour entraîner le modèle, nous maintenons certaines des configurations précédentes de notre formation précédente.

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)

Après avoir entraîné notre modèle Mobilenet affiné, nous pouvons ensuite évaluer ses performances.

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)

Le modèle Mobilenet affiné fonctionne mieux que les modèles précédents et améliore notamment l'identification des chiens et des fleurs.

Bien qu'il soit acceptable d'utiliser le modèle Mobilenet entraîné ou l'un de nos modèles comme choix final, combiner la structure et les poids des trois modèles pourrait s'avérer meilleur pour développer un modèle unique et plus généralisable en production.

Ensemble des modèles

Comme mentionné précédemment, nous utiliserions trois méthodes d'ensemblage différentes pour combiner les modèles : la concaténation, la moyenne et la moyenne pondérée.

Les méthodes ont leurs avantages et leurs inconvénients, qui sont souvent considérés pour déterminer le choix d'un cas d'utilisation particulier.

Ensemble de concaténation

Cela implique de fusionner les paramètres de plusieurs modèles en un seul modèle. Cela est rendu possible dans Tensorflow par la couche concaténation qui reçoit des entrées de tenseurs de la même forme (sauf pour l'axe de concaténation) et les fusionne en un. Cette couche peut donc être utilisée pour fusionner toutes les informations apprises par les différents modèles côte à côte sur un seul axe en un seul modèle.

Pour fusionner nos modèles, nous n'aurions qu'à les insérer dans la couche de concaténation.

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')

Après la concaténation, nous avons ajouté d'autres couches jugées appropriées pour notre tâche. Dans cet exemple, j'ai ajouté une couche de dropout et une couche de sortie finale avec les dimensions de sortie appropriées à notre cas d'utilisation.

Vérifions la structure de notre modèle concaténé.

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

Structure du Modèle Concaténé

Nous pouvons voir comment les trois différents modèles fonctionnels que nous avons construits sont fusionnés en un seul avec des couches de dropout et de sortie supplémentaires.

Cela peut s'avérer utile dans certains cas, car nous utilisons toutes les informations acquises par les différents modèles. Le problème avec cette méthode est que la dimension de notre modèle final est une concaténation des dimensions de tous les membres de l'ensemble, ce qui pourrait entraîner une explosion dimensionnelle, l'inclusion d'informations non pertinentes et, par conséquent, un surapprentissage.

Ensemble moyen

Plutôt que de risquer d'exploser la dimension du modèle et de surajuster des tâches plus simples en concaténant plusieurs modèles, nous pourrions simplement faire de notre modèle final la moyenne de tous nos modèles. De cette manière, nous pouvons maintenir une dimension moyenne raisonnable pour notre modèle final tout en utilisant les informations de tous nos modèles.

Cette fois, nous utiliserons la couche Average de Tensorflow, qui reçoit des entrées et renvoie leur moyenne. Par conséquent, notre modèle final est une moyenne des paramètres de nos modèles d'entrée.

Pour regrouper notre modèle par la moyenne, nous combinons simplement nos modèles au niveau de la moyenne.

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)

Comme vu précédemment, d'autres couches peuvent être ajoutées au réseau si cela est jugé approprié. Nous pouvons également voir la structure du modèle ensemblé moyen.

show model structure 
plot_model(avg_model)

Cette approche de l'ensemblage est particulièrement utile car, en prenant une moyenne, les modèles avec des performances inférieures pour certaines classes sont renforcés par des modèles avec de meilleures performances pour ces classes, améliorant ainsi la performance globale et la généralisation du modèle.

L'inconvénient de cette approche est qu'en prenant la moyenne, certaines informations des modèles ne seraient pas incluses dans le modèle final. Un autre problème est que, comme nous prenons une moyenne simple, la supériorité et la pertinence de certains modèles sont perdues. Comme dans notre cas d'utilisation, la supériorité de performance du modèle Mobilenet par rapport aux autres modèles est perdue.

Cela pourrait être résolu en prenant une moyenne pondérée des modèles lors de l'assemblage, de manière à refléter l'importance de chaque modèle dans la décision finale.

Ensemble par moyenne pondérée

Dans l'assemblage par moyenne pondérée, les sorties des modèles sont multipliées par un poids attribué, et une moyenne est prise pour obtenir un modèle final. En attribuant des poids aux modèles lors de l'assemblage de cette manière, nous préservons leur importance et leur contribution à la décision finale.

Bien que TensorFlow n'ait pas de couche intégrée pour l'assemblage par moyenne pondérée, nous pourrions utiliser des attributs de la classe intégrée Layer pour implémenter une couche d'assemblage par moyenne pondérée personnalisée. Pour un assemblage par moyenne pondérée, il est nécessaire que les poids s'additionnent à un, nous pouvons garantir cela en appliquant une fonction softmax sur les poids avant l'assemblage. Vous pouvez en savoir plus sur la création de couches personnalisées dans TensorFlow ici.

Mise en œuvre d'une couche moyenne pondérée personnalisée

Tout d'abord, nous définissons une fonction personnalisée pour définir nos poids.

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)

Ici, nous avons défini les poids de nos modèles à 1, 2 et 3, respectivement. Nous pouvons ensuite créer notre couche d'average pondérée personnalisée.

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)
   

Pour construire notre couche personnalisée de moyenne pondérée, nous avons hérité des attributs de la classe Layer intégrée et ajouté des poids en utilisant notre fonction d'initialisation des poids. Nous appliquons un softmax à nos poids initialisés afin qu'ils s'additionnent à un avant de les multiplier par les modèles. Enfin, nous obtenons la réduction moyenne des entrées pondérées pour obtenir notre modèle final.

Nous pouvons ensuite assembler notre modèle en utilisant la couche de moyenne pondérée personnalisée.

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')

Vérifions la structure de notre modèle de moyenne pondérée.

plot model
plot_model(weighted_avg_model)

Structure du Modèle d'Ensemble en Moyenne Pondérée Comme dans les méthodes précédentes, nos modèles sont regroupés, mais cette fois, en tant que moyenne pondérée des trois modèles. La dimension de sortie du modèle ensemblé est également compatible avec la dimension de sortie requise pour notre tâche sans ajouter d'autres couches.

De plus, plutôt que de définir manuellement nos poids en utilisant une fonction d'initialisation de poids personnalisée, nous pourrions utiliser les initialisateurs de poids intégrés de Tensorflow pour initialiser des poids qui sont optimisés pendant l'entraînement. Voir ici les initialisateurs de poids intégrés disponibles dans Tensorflow.

Modèle unique vs Ensemble

L'assemblage améliore l'exactitude et la robustesse mais augmente le temps d'entraînement/de déduction et l'utilisation de la mémoire. L'assemblage est utile lorsque la performance importe plus que la latence.

FAQ

1. Qu'est-ce que l'assemblage avec des réseaux de neurones ?
L'assemblage avec des réseaux de neurones implique de combiner les prévisions de plusieurs modèles neuronaux pour améliorer la précision, la robustesse et la généralisation sur des données non vues.

2. Pouvez-vous assembler différents types de réseaux neuronaux ?
Oui, vous pouvez assembler des modèles comme des CNN, des LSTM et des MLP ensemble. Cela est particulièrement utile lorsque chaque modèle capture différents aspects des données.

3. Combien de modèles devrais-je utiliser dans un ensemble ?
Il n'y a pas de nombre fixe - cela dépend de votre jeu de données, de votre puissance de calcul et de vos objectifs de performance. Même 2 à 3 modèles bien choisis peuvent offrir des améliorations notables.

4. Quelle est la différence entre bagging et stacking ?
Le bagging forme des modèles de manière indépendante sur différents sous-ensembles de données et fait la moyenne des prédictions, tandis que le stacking combine des modèles divers à l'aide d'un méta-apprenant formé sur leurs sorties.

5. Comment l'ensemblage est-il utilisé dans les LLM ?
Dans les grands modèles de langue (LLM), l'ensemblage est utilisé pour combiner les résultats de plusieurs points de contrôle ou versions de modèles, améliorant ainsi la précision et réduisant le biais ou les hallucinations.

Résumé

L'assemblage de modèles améliore les performances et la généralisation des modèles d'apprentissage automatique en combinant plusieurs modèles dans une architecture unifiée. Dans les réseaux de neurones, TensorFlow permet diverses stratégies d'assemblage telles que la concaténation, la moyenne et la moyenne pondérée personnalisée. Alors que la concaténation préserve toutes les caractéristiques (au prix d'une dimensionalité accrue), la moyenne simplifie le modèle mais peut négliger l'importance du modèle. La moyenne pondérée personnalisée aborde cela en apprenant des poids optimaux pendant l'entraînement. Ces techniques peuvent également être étendues avec des opérations plus avancées ou spécifiques à la tâche, faisant de l'assemblage un outil flexible et puissant en apprentissage profond.

Ressources connexes

• Qu'est-ce que l'apprentissage profond
• https://linux-console.net/community/tutorials/constructing-neural-networks-from-scratch
• https://linux-console.net/community/tutorials/global-pooling-in-convolutional-neural-networks
• https://linux-console.net/community/tutorials/random-forest-in-machine-learning
• https://linux-console.net/community/tutorials/decision-trees-machine-learning-explained