Neurális hálózat modellek egyesítése

Bevezetés

A model ensembling egy népszerű megközelítés a gépi tanulásban, amely segít javítani a modellek teljesítményét, különösen új, eddig nem látott adatokon. Alapvetően arról szól, hogy a több modell erősségeit ötvözzük, hogy jobb eredményeket érjünk el, mint amit bármelyik egyedül képes lenne nyújtani. Ez a technika növeli a pontosságot, fokozza a robusztusságot, és javítja a modell általánosító képességét.

A fá alapú algoritmusok, például, gyakran kiemelkednek bizonyos feladatokban, mert természetüknél fogva úgy működnek, hogy több döntési fa kimeneteit kombinálják, hogy egy erősebb összesített előrejelzést hozzanak létre.

Különböző módok léteznek a modellek egyesítésére egy együttessel, a legegyszerűbb módszerektől, mint például az előrejelzéseik átlagolása, a bonyolultabb technikákig, mint a bagging, boosting vagy stacking. Minden módszer saját módot kínál a modellek összevonására, hogy a végső döntés megbízhatóbbá váljon.

Főbb megállapítások

• Ensemble tanulás több neurális hálózat kombinálásával javítja a predikció pontosságát, robosztusságát és általánosíthatóságát.

• A munkafolyamat jellemzően magában foglalja az adathalmaz előkészítését, több modell betanítását és kimeneteik integrálását egyesítési stratégiák alkalmazásával.

• A szokásos ansamble módszerek a következők:

  • Összekapcsolásos Ensembe: Több modell jellemzőit egyesíti a gazdagabb reprezentáció érdekében.
  • Átlagos együttes: Az összes modell előrejelzésének átlagát veszi, egyszerű, de hatékony.
  • Súlyozott Átlagos Egyesítés: Különböző fontosságot (súlyokat) rendel a modellekhez azok egyéni teljesítménye alapján.

• A összehasonlítás az egyedi és az ensemble modellek között azt mutatja, hogy az ensemble-ek gyakran felülmúlják az egyedi modelleket a bonyolult feladatokban, de több számítási terhet jelenthetnek.

• Az együttes módszerek különösen hasznosak, amikor az egyes modellek változatos hibákat követnek el, amelyeket közösen lehet kijavítani.

• A megfelelő együttes technika kiválasztása attól függ, hogy mi a adat típus, a modell architektúra és az értékelési célok.

A klasszikus algoritmusokkal ellentétben nem szokás, hogy több neurális hálózat modellt egyesítsenek egyetlen feladatra. Ennek oka legtöbbször az, hogy az egyes modellek gyakran elegendőek a jellemzők és a célok közötti kapcsolat leképezésére, és a több neurális hálózat egyesítése bonyolultabbá teheti a modellt kisebb feladatok esetén, valamint túltanuláshoz vezethet. Leggyakrabban a gyakorlók a méretét növelik egyetlen neurális hálózati modellnek, hogy megfelelően illeszkedjenek az adatokhoz, ahelyett, hogy több neurális hálózat modellt egybeolvasztanának.

azonban nagyobb feladatok esetén, több neurális hálózat egyesítése, különösen olyanoké, amelyek hasonló problémákon lettek betanítva, nagyon hasznosnak bizonyulhat, és javíthatja a végső modell teljesítményét, valamint a szélesebb körű alkalmazásokra való általánosítási képességét.

Gyakran szükség van arra, hogy különböző konfigurációkkal több modellt is kipróbáljunk, hogy kiválasszuk a legjobban teljesítő modellt egy problémához. A neurális hálózatok egyesítése lehetővé teszi, hogy különböző modellek információit felhasználva egy kiegyensúlyozottabb és hatékonyabb modellt fejlesszünk ki.

Például, több, egy adott adathalmazon (például az Imagenet adathalmazon) betanított hálózati modell kombinálása hasznos lehet egy hasonló osztályokkal rendelkező adathalmazon betanított modell teljesítményének javításához. A modellek által tanult különböző információk kombinálhatók a modellek összesítésével, hogy javítsák az aggregált modell általános teljesítményét és robusztusságát. Mielőtt ilyen modelleket egyesítenénk, fontos, hogy az egyes tagokat betanítsuk és finomhangoljuk, hogy biztosítsuk, hogy minden modell releváns információt hozzon a végső modellhez.

A Datasets

Ehhez a bemutatóhoz a természetes képek osztályozását fogjuk használni. A Természetes Képek Adatbázisát fogjuk használni, amely 6899 természetes képet tartalmaz, amelyek 8 osztályt képviselnek. Az adatbázisban képviselt osztályok a következők: repülőgép, autó, macska, kutya, gyümölcs, motor, és ember.

Célunk egy olyan neurális hálózati modell kifejlesztése, amely képes azonosítani a különböző osztályokba tartozó képeket, és pontosan osztályozni az egyes osztály új képeit.

Munkafolyamat

Három különböző modellt fejlesztenénk a feladatunkhoz, majd különböző módszerekkel egyesítenénk őket. Fontos, hogy a modelljeinket úgy konfiguráljuk, hogy releváns információkat nyújtsanak a végső modellünk számára.

Állítsa be a magot a reprodukálhatóság érdekében és előnézeti minta képek osztályonként

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

Állítsa be az adatkonfigurációkat, és szerezze be az osztályokat

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)

A készlet mintaképeinek ábrázolása

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)

Töltsd be a képeket

A képeket tömegekben töltjük be a Keras Kép Generátor használatával, és megadunk egy validációs részesedést, hogy a készletet edzésre és validációra osszuk.

Véletlenszerű képkiegészítést is alkalmazunk a tanulási adathalmoz bővítésére, javítva a modell teljesítményét és általánosítási képességét.

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. Építs és taníts egy egyedi modellt

Az első modellünkhöz egy egyedi modellt építettünk a Tensorflow funkcionális módszerével.

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

Ezután összeállítjuk a testreszabott modellt, és beállítjuk a visszahívásokat a képzés kezelésére. A tanulási sebesség csökkentését alkalmazzuk az egyensúlyi állapotban, az EarlyStopping-ot, hogy leállítsuk a képzést, amikor nincs további javulás, és a ModelCheckpoint-ot, hogy minden egyes epoch végén elmentsük a legjobb modellt. Ezek a hatékony mélytanulás tréning szokásos gyakorlatai.

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]

Most meghatározhatjuk a képzési konfigurációinkat, és kiképezhetjük saját modellünket.

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)

A saját modellünk betanítása után értékelhetjük a teljesítményét. A modellt a validációs készleten fogom értékelni. A gyakorlatban előnyös, ha külön tesztkészletet különítünk el a modell értékelésére.

Evaluate the model 
custom_model.evaluate(val_gen)

Érvényesítési veszteség és pontosság

A predikciót és a tényleges validációs címkéket is vissza tudjuk szerezni, hogy ellenőrizzük a klasszifikációs jelentést és a zűrzavar mátrix értékeléseit az egyedi modellhez.

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

Osztályozási Jelentés

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)

Konfúziós mátrix a testreszabott modell használatával

A modell értékelése alapján észrevesszük, hogy a testreszabott modell nem tudta megfelelően azonosítani a macskák és virágok képeit. Emellett nem optimális pontossággal azonosítja a repülőgépeket.

A következő lépésben egy másik modelltanítási technikát próbálunk ki: előképzett hálózatok által az Imagenet adathalmazon tanult súlyok felhasználásával növeljük modellünk teljesítményét az alacsonyabb pontszámú osztályokban.

2. Előképzett VGG16 modell használata.

A második modellünkhöz az Imagenet adathalmazon előképzett VGG16 modellt fogjuk használni, hogy egy modellt képezzünk az általunk használt esethez. Ez lehetővé teszi számunkra, hogy örököljük a hasonló adathalmazon végzett képzés során megtanult súlyokat, így javítva a modellünk teljesítményét.

A VGG16 modell inicializálása és finomhangolása

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

Inicializáljuk az előképzett modellt, és lefagyasztjuk az utolsó három rétegen kívül az összes réteget, így kihasználhatjuk a modellek súlyait, és új információkat tanulhatunk az utolsó három rétegben, amelyek a mi alkalmazásunkra jellemzőek. Emellett hozzáadunk egy dropout réteget, hogy megakadályozzuk a modell túltanulását az adatainkon, mielőtt hozzáadnánk a végső kimeneti réteget.

Ezután hasonló képzési konfigurációkkal taníthatjuk a VGG16 finomhangolt modellünket, mint a saját modellünket.

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)

A képzés után értékelhetjük a modell teljesítményét a korábbi modellértékelés során használt hasonló szkriptek segítségével.

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)

Osztályozási jelentés az előképzett VGG modell használatával

Zavartsági mátrix jelentés a már betanított VGG modell használatával

A már előképzett VGG16 modell használata jobb teljesítményt eredményezett, különösen az alacsonyabb pontszámú osztályok esetében.

Végül, az összevonás előtt egy másik, a VGG16-nál sokkal kevesebb paraméterrel rendelkező, előképzett modellt használnánk. A cél az eltérő architektúrák kihasználása, hogy jussunk a változó tulajdonságaikból, és javítsuk a végső modellünk minőségét. A Mobilenet modellt használnánk, amelyet ugyanazon Imagenet adathalmazon előképzettek.

3. Egy előképzett Mobilenet modellt használva.

A végső modellünkhöz a MobileNet modellt finomhangolnánk.

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

A modell képzéséhez fenntartjuk néhány korábbi konfigurációt korábbi képzésünkből.

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)

A finomhangolt Mobilenet modellünk kiképzése után értékelhetjük a teljesítményét.

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)

A finomhangolt Mobilenet modell jobban teljesít, mint a korábbi modellek, és jelentősen javítja a kutyák és virágok azonosítását.

Bár rendben lenne használni a betanított Mobilenet modellt vagy bármelyik másik modellünket végső választásként, a három modell struktúrájának és súlyának kombinálása jobb megoldást jelenthet egyetlen, általánosíthatóbb modell kifejlesztésében a gyártás során.

A modellek egyesítése

Ahogy korábban említettük, három különböző összesítő módszert fogunk használni a modellek kombinálására: Összefűzés, Átlag és Súlyozott átlag.

A módszereknek megvannak a előnyeik és hátrányaik, amelyeket gyakran figyelembe vesznek egy adott felhasználási eset választásának meghatározásakor.

Kombinált együttes

Ez magában foglalja a több modell paramétereinek egyetlen modellbe való egyesítését. Ez a Tensorflow-ban a összefűző réteg által valósul meg, amely azonos alakú (kivéve az összefűzési tengelyt) tenzorok bemeneteit fogadja és egyesíti őket egybe. Ez a réteg tehát felhasználható arra, hogy a különböző modellek által tanult összes információt egyetlen tengely mentén, egymás mellett egyesítse egyetlen modellbe.

A modeljaink egyesítéséhez egyszerűen csak be kell vinnünk a modelljeinket a fúziós rétegbe.

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

A fúzió után további rétegeket adtunk hozzá, ahogy az feladatunkhoz megfelelőnek ítéltük. Ebben a példában egy dropout réteget és egy végső kimeneti réteget adtam hozzá, a felhasználási esetünk megfelelő kimeneti dimenzióival.

Nézzük meg a fűzött modellünk szerkezetét.

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

A Fűzött Modell Felépítése

Láthatjuk, hogyan olvad össze a három különböző funkcionális modell, amelyet megépítettünk, egyetlen modellé további leejtési és kimeneti rétegekkel.

Ez hasznosnak bizonyulhat bizonyos esetekben, mivel kihasználjuk a különböző modellek által szerzett összes információt. A módszer problémája az, hogy a végső modellünk dimenziója az összes együttes tag dimenzióinak összekapcsolása, ami dimenzionalitási robbanáshoz, irreleváns információk bevonásához és következésképpen túltanuláshoz vezethet.

Átlagos Együttes

Ahelyett, hogy kockáztatnánk a modell dimenziójának felrobbanását és egyszerűbb feladatok esetén túlillesztést tapasztalnánk, ha több modellt összefűznénk, egyszerűen az összes modellünkből készült átlagot tehetnénk a végső modellünkké. Így fenntarthatjuk a végső modellünk ésszerű átlagdimenzióját, miközben kihasználjuk az összes modellünk információját.

Ezúttal a Tensorflow Átlag réteget fogjuk használni, amely bemeneteket fogad és azok átlagát adja vissza. Ezért a végső modellünk a bemeneti modellek paramétereinek átlaga.

A modellünk átlagolásához egyszerűen kombináljuk a modelljeinket az átlag rétegben.

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)

Mint korábban láttuk, további rétegek adhatók a hálózathoz az igényeknek megfelelően. Azt is láthatjuk, hogy néz ki az átlagos összevont modell struktúrája.

show model structure 
plot_model(avg_model)

Ez az ensemble-kozási megközelítés különösen hasznos, mert az átlagolással az alacsonyabb teljesítményű modellek bizonyos osztályok esetében feljavulnak a jobb teljesítményű modellek által, ezáltal javítva a modell általános teljesítményét és általánosítását.

Ennek az megközelítésnek a hátránya, hogy az átlagolás révén bizonyos információk a modellekből nem kerülnek be a végső modellbe. Egy másik probléma, hogy mivel egyszerű átlagolást alkalmazunk, egyes modellek fölénye és relevanciája elveszik. Például a mi esetünkben a Mobilenet modell teljesítményének fölénye más modellekhez képest elvész.

Ez úgy oldható meg, hogy a modellek súlyozott átlagát vesszük, amikor azokat összevonjuk, így tükrözve minden modell fontosságát a végső döntéshez.

Súlyozott Átlagos Egyesítés

A súlyozott átlagos egyesítés során a modellek kimeneteit egy hozzárendelt súllyal szorozzuk, majd átlagot számítunk, hogy megkapjuk a végső modellt. Azáltal, hogy súlyokat rendelünk a modellekhez ezen a módon történő egyesítéskor, megőrizzük a fontosságukat és hozzájárulásukat a végső döntéshez.

Bár a TensorFlow-nak nincs beépített rétege a súlyozott átlagos egyesítésre, kihasználhatjuk a beépített Layer osztály attribútumait egyéni súlyozott átlagos egyesítő réteg megvalósításához. A súlyozott átlagos egyesítéshez szükséges, hogy a súlyok összege egy legyen, ezt úgy biztosíthatjuk, hogy az összesítés előtt egy softmax függvényt alkalmazunk a súlyokra. További információkat a TensorFlow-ban történő egyéni rétegek létrehozásáról itt talál.

Egyedi súlyozott átlag réteg implementálása

Először definiálunk egy egyedi függvényt, hogy beállítsuk a súlyainkat.

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)

Itt a modellek súlyait 1, 2 és 3 értékekre állítottuk be. Ezután felépíthetjük saját súlyozott átlag rétegünket.

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)
   

A saját testreszabott súlyozott átlag rétegünk létrehozásához örököltük a beépített Layer osztály tulajdonságait, és súlyokat adtunk hozzá a súlyaink inicializáló függvényével. Alkalmazunk egy softmax-ot az inicializált súlyainkra, hogy azok egybe adhassanak, mielőtt megszoroznánk őket a modellekkel. Végül a súlyozott bemenetek átlagos csökkentését végezzük el, hogy megkapjuk a végső modellemet.

Akkor az egyedi súlyozott átlagréteget használva összesíthetjük a modellünket.

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

Nézzük meg a súlyozott átlag modellünk szerkezetét.

plot model
plot_model(weighted_avg_model)

A Súlyozott Átlag Egyesített Modell Szerkezete Mint az előző módszerekben, a modelljeink egyesítettek, de ezúttal a három modell súlyozott átlagaként. Az egyesített modell kimeneti dimenziója szintén kompatibilis a feladatunk számára szükséges kimeneti dimenzióval, további rétegek hozzáadása nélkül.

Ezenkívül ahelyett, hogy kézzel állítanánk be a súlyainkat egy egyedi súly inicializáló függvénnyel, kihasználhatnánk a Tensorflow beépített súly inicializálóit, hogy azokat az edzés során optimalizáljuk. Itt megtalálhatók a Tensorflow-ban elérhető beépített súly inicializálók.

Egységes Modell vs Szeremény

Az egyesítés növeli a pontosságot és a robusztusságot, de növeli a betanítási/értelmezési időt és a memóriahasználatot. Az egyesítés hasznos, amikor a teljesítmény fontosabb, mint a késleltetés.

GYIK

1. Mi az ensembles a neurális hálózatokkal?
A neurális hálózatokkal végzett ensembling a több neurális modell előrejelzéseinek kombinálását jelenti a pontosság, a robusztusság és a még nem látott adatokra való általánosítás javítása érdekében.

2. Össze lehet állítani különböző típusú neurális hálózatokat?
Igen, össze lehet állítani olyan modelleket, mint a CNN-ek, LSTM-ek és MLP-k. Ez különösen hasznos, amikor minden modell a data különböző aspektusait ragadja meg.

3. Hány modellt kell használnom egy együttesben?
Nincs rögzített szám - ez a te adathalmazon, számítási teljesítményeden és teljesítménycéljaidon múlik. Még 2-3 jól megválasztott modell is észlelhető javulásokat nyújthat.

4. Mi a különbség a bagging és a stacking között?
A bagging különböző adat-alsorozatokon függetlenül képezi a modelleket, és átlagolja a jóslatokat, míg a stacking eltérő modelleket kombinál egy meta-tanulón keresztül, amelyet az outputjaikon képeznek.

5. Hogyan használják az aggregációt a nagy nyelvi modellekben (LLM-ekben)?
A nagy nyelvi modellekben (LLM-ekben) az aggregáció arra szolgál, hogy egyesítse a kimeneteket több modell ellenőrzési pontból vagy verzióból, javítva ezáltal a pontosságot és csökkentve az elfogultságot vagy a hallucinációt.

Összefoglaló

A modellek egyesítése javítja a gépi tanulási modellek teljesítményét és általánosítását, azáltal, hogy több modellt egyesít egy egységes architektúrába. A neurális hálózatokban a TensorFlow számos egyesítési stratégiát lehetővé tesz, mint például a fűzés, az átlagolás és a testreszabott súlyozott átlagolás. Míg a fűzés megőrzi az összes jellemzőt (a dimenzionalitás növekedésének ára), az átlagolás egyszerűsíti a modellt, de figyelmen kívül hagyhatja a modellek fontosságát. A testreszabott súlyozott átlagolás ezt a tréning során megtanulandó optimális súlyokkal kezeli. Ezek a technikák továbbfejleszthetők fejlettebb vagy feladat-specifikus műveletekkel is, így az egyesítés rugalmas és erőteljes eszközzé válik a mélytanulásban.

Kapcsolódó források

• A mélytanulás egy gépi tanulási ág, amely a neurális hálózatok mély struktúráit használja, hogy az adatokat feldolgozza és megértse.
• Neurális hálók építése a nulláról
• Globális poolozás konvolúciós neurális hálózatokban
• A gépi tanulásban a véletlen erdő technika
• Döntési fák - a gépi tanulás magyarázata