Quin paper té l'abandonament en la prevenció del sobreajust durant la formació d'un model d'aprenentatge profund i com s'implementa a Keras?

/ / Publicat a Intel·ligència Artificial, EITC/AI/DLTF Deep Learning amb TensorFlow, Aprenentatge profund al navegador amb TensorFlow.js, Model d'entrenament a Python i càrrega a TensorFlow.js, Revisió de l'examen

L'abandonament és una tècnica de regularització utilitzada en l'entrenament de models d'aprenentatge profund per evitar el sobreajustament. El sobreajust es produeix quan un model aprèn els detalls i el soroll de les dades d'entrenament fins al punt que funciona malament amb dades noves i no vistes. L'abandonament aborda aquest problema "abandonant" aleatòriament una proporció de neurones durant el procés d'entrenament, cosa que obliga el model a aprendre característiques més robustes que no depenen de neurones específiques.

La base teòrica de l'abandonament està arrelada en el concepte d'aprenentatge conjunt, on s'entrenen diversos models i es promedian les seves prediccions per millorar la generalització. L'abandonament es pot veure com una aproximació eficient i pràctica a l'entrenament i la mitjana d'un gran nombre de xarxes neuronals diferents. Durant cada pas d'entrenament, cada neurona té una probabilitat p (taxa d'abandonament) de ser ignorat o "abandonat". Això vol dir que durant un pas endavant, la sortida de la neurona es posa a zero amb probabilitat p, i durant el pas enrere, no s'actualitzen els gradients corresponents.

Matemàticament, si h és la sortida d'una neurona, durant l'entrenament, l'operació d'abandonament es pot representar com:

    \[ h' = h \cdot \text{màscara} \]

where \text{màscara} és un vector binari de la mateixa forma que h, amb entrades extretes d'una distribució de Bernoulli amb paràmetre (1 - p). Durant l'entrenament, la màscara garanteix que només un subconjunt de neurones estigui actiu en un moment donat. Això evita que el model depengui massa de qualsevol neurona en particular i fomenta el desenvolupament de representacions redundants.

La tècnica d'abandonament s'implementa a Keras, una API de xarxes neuronals d'alt nivell, escrita en Python i capaç d'executar-se a sobre de TensorFlow. Per utilitzar l'abandonament a Keras, es pot afegir una capa "Dropout" al model. Aquí teniu un exemple de com implementar l'abandonament en un model Keras:

python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout

# Define the model
model = Sequential()

# Add input layer and first hidden layer with dropout
model.add(Dense(64, activation='relu', input_shape=(input_dim,)))
model.add(Dropout(0.5))

# Add second hidden layer with dropout
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))

# Add output layer
model.add(Dense(output_dim, activation='softmax'))

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

En aquest exemple, la capa "Dropout" s'afegeix després de cada capa densa (totalment connectada). L'argument de "Dropout" especifica la taxa d'abandonament, que és la fracció de neurones a deixar caure durant l'entrenament. Una taxa d'abandonament de 0.5 significa que cada neurona té un 50% de possibilitats de ser caiguda a cada pas d'entrenament.

Quan el model està en mode d'avaluació (per exemple, durant la validació o la prova), no s'aplica l'abandonament i s'utilitzen totes les neurones. Per garantir que la sortida de la xarxa sigui coherent entre l'entrenament i la prova, les sortides de les neurones s'escalen pel factor (1 - p) durant l'entrenament. Aquesta escala assegura que la suma esperada de les sortides segueixi sent la mateixa.

L'abandonament pot ser especialment eficaç per prevenir el sobreajustament en models amb molts paràmetres, com ara xarxes neuronals profundes. En deixar caure les neurones de manera aleatòria durant l'entrenament, l'abandonament ajuda a trencar les coadaptacions entre neurones, animant la xarxa a aprendre característiques més generals que són útils per a una varietat d'entrades. Això pot conduir a un rendiment de generalització millorat en dades noves i no vistes.

A més de la tècnica bàsica d'abandonament descrita anteriorment, hi ha diverses variacions i extensions de l'abandonament que s'han proposat a la literatura. Alguns d'aquests inclouen:

1. Abandona espacial: Aquesta variació s'utilitza a les xarxes neuronals convolucionals (CNN) i deixa caure mapes de característiques sencers en lloc de neurones individuals. Això es pot implementar a Keras mitjançant la capa `SpatialDropout2D`.

2. DropConnect: en lloc d'abandonar les neurones, DropConnect elimina les connexions individuals entre neurones. Això es pot veure com una generalització de l'abandonament.

3. Abandonament variacional: Aquest enfocament utilitza un marc bayesià per conèixer les taxes d'abandonament de cada neurona durant l'entrenament.

4. Abandó del formigó: Aquest mètode utilitza una relaxació contínua de la màscara d'abandonament i aprèn les taxes d'abandonament com a part del procés d'entrenament.

5. AlphaDropout: Dissenyat per a xarxes neuronals autonormalitzants (SNN) que utilitzen unitats lineals exponencials escalades (SELU), AlphaDropout manté la mitjana i la variància de les entrades durant l'entrenament.

L'elecció de la taxa d'abandonament és un hiperparàmetre important que pot afectar el rendiment del model. Els valors típics de la taxa d'abandonament oscil·len entre 0.2 i 0.5. Tanmateix, la taxa d'abandonament òptima pot variar segons el conjunt de dades i l'arquitectura específics. Sovint es determina mitjançant l'experimentació i la validació creuada.

Un cop el model s'ha entrenat en Python amb Keras i TensorFlow, es pot exportar i carregar a TensorFlow.js per al desplegament en un navegador web. TensorFlow.js és una biblioteca de JavaScript per entrenar i desplegar models d'aprenentatge automàtic al navegador i a Node.js. El procés d'exportar un model des de Python i carregar-lo a TensorFlow.js implica els passos següents:

1. Deseu el model en format TensorFlow.js: Utilitzeu l'eina `tensorflowjs_converter` per convertir el model Keras al format TensorFlow.js. Aquesta eina forma part del paquet TensorFlow.js i es pot instal·lar mitjançant pip:

bash
   pip install tensorflowjs

A continuació, utilitzeu l'ordre següent per convertir el model:

bash
   tensorflowjs_converter --input_format keras model.h5 model_js

Aquesta ordre converteix el model Keras desat a `model.h5` en un model TensorFlow.js desat al directori `model_js`.

2. Carregueu el model a TensorFlow.js: A l'aplicació web, utilitzeu la biblioteca TensorFlow.js per carregar el model convertit. Aquí teniu un exemple de com carregar i utilitzar el model en una aplicació JavaScript:

html
   <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script>
   <script>
     async function loadModel() {
       const model = await tf.loadLayersModel('model_js/model.json');
       console.log('Model loaded successfully');
       
       // Use the model for predictions
       const input = tf.tensor([/* input data */]);
       const prediction = model.predict(input);
       prediction.print();
     }

     loadModel();
   </script>

Seguint aquests passos, es pot entrenar un model d'aprenentatge profund en Python mitjançant Keras i TensorFlow i, a continuació, desplegar el model en un navegador web mitjançant TensorFlow.js. Això permet la creació d'aplicacions web interactives i intel·ligents que poden aprofitar el poder de l'aprenentatge profund.

Altres preguntes i respostes recents sobre Aprenentatge profund al navegador amb TensorFlow.js:

Consulteu més preguntes i respostes a Aprenentatge profund al navegador amb TensorFlow.js

Més preguntes i respostes:

Etiquetat sota: , , , , ,