Come puoi convertire un modello Keras addestrato in un formato compatibile con TensorFlow.js per la distribuzione del browser?

/ / Pubblicato in Intelligenza Artificiale, Apprendimento approfondito EITC/AI/DLTF con TensorFlow, Apprendimento approfondito nel browser con TensorFlow.js, Modello di addestramento in Python e caricamento in TensorFlow.js, Revisione d'esame

Per convertire un modello Keras addestrato in un formato compatibile con TensorFlow.js per la distribuzione del browser, è necessario seguire una serie di passaggi metodici che trasformano il modello dal suo ambiente originale basato su Python in un formato compatibile con JavaScript. Questo processo prevede l'utilizzo di strumenti e librerie specifici forniti da TensorFlow.js per garantire che il modello possa essere caricato ed eseguito in modo efficiente all'interno di un browser web. La seguente spiegazione fornisce una guida dettagliata e completa per ottenere questa conversione.

Processo di conversione passo dopo passo

1. Addestra il tuo modello Keras in Python

Innanzitutto, assicurati che il tuo modello Keras sia addestrato e salvato in Python. Ciò comporta la definizione dell'architettura del modello, la compilazione e l'adattamento al set di dati. Di seguito è riportato un semplice esempio di definizione del modello Keras e processo di formazione:

python
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Define a simple sequential model
model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

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

# Train the model
model.fit(x_train, y_train, epochs=5)

# Save the model
model.save('my_model.h5')

In questo esempio, "x_train" e "y_train" sono rispettivamente i dati e le etichette di addestramento. Il modello viene salvato nel formato HDF5, che è un formato comune per i modelli Keras.

2. Installa il convertitore TensorFlow.js

Per convertire il modello Keras salvato in un formato compatibile con TensorFlow.js, è necessario installare il convertitore TensorFlow.js. Questo può essere fatto usando pip:

{{EJS11}}
3. Converti il ​​modello


Una volta installato il convertitore TensorFlow.js, puoi procedere alla conversione del modello Keras salvato. A questo scopo viene utilizzato lo strumento da riga di comando `tensorflowjs_converter`. Ecco il comando per convertire il modello:


sh
tensorflowjs_converter --input_format keras my_model.h5 /path/to/tfjs_model

In questo comando:
 - `--input_format keras` specifica che il modello di input è in formato Keras.
 - `my_model.h5` è il percorso al modello Keras salvato.
 - `/path/to/tfjs_model` è la directory in cui verrà salvato il modello TensorFlow.js convertito.
Il convertitore genererà una serie di file nella directory specificata. Questi file includono:
 - `model.json`: questo file contiene l'architettura e i pesi del modello.
 - File di pesi binari: questi file memorizzano i pesi del modello in un formato caricabile da TensorFlow.js.
4. Carica il modello in TensorFlow.js
Dopo aver convertito il modello, puoi caricarlo nella tua applicazione web utilizzando TensorFlow.js. Assicurati di includere la libreria TensorFlow.js nel tuo file HTML:
html
<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script>

Quindi, puoi caricare il modello utilizzando la funzione `tf.loadLayersModel`. Di seguito è riportato un esempio di come caricare e utilizzare il modello in un file JavaScript:
javascript
async function loadModel() {
    const model = await tf.loadLayersModel('/path/to/tfjs_model/model.json');
    console.log('Model loaded successfully');

    // Example: Making a prediction
    const input = tf.tensor2d([/* your input data */], [1, 784]);
    const prediction = model.predict(input);
    prediction.print();
}

loadModel();

In questo esempio, la funzione "loadModel" carica il modello dal percorso specificato e registra un messaggio di successo. Quindi crea un tensore dai dati di input ed effettua una previsione utilizzando il modello caricato.
Ulteriori considerazioni
Ottimizzazione del modello
Quando si distribuiscono modelli nel browser, è importante considerare le prestazioni e le dimensioni del modello. TensorFlow.js fornisce strumenti per l'ottimizzazione dei modelli, come la quantizzazione, che riduce le dimensioni del modello e può migliorare la velocità di inferenza. Il convertitore TensorFlow.js supporta la quantizzazione durante il processo di conversione. Ad esempio, è possibile applicare la quantizzazione del peso aggiungendo il flag `--quantize_float16`:
sh
tensorflowjs_converter --input_format keras --quantize_float16 my_model.h5 /path/to/tfjs_model

Questo flag quantizza i pesi in float a 16 bit, riducendo la dimensione del modello.
Gestione di diversi formati di modello
TensorFlow.js supporta vari formati di modello, inclusi i moduli TensorFlow SavedModel e TensorFlow Hub. Se il tuo modello non è in formato Keras, puoi comunque convertirlo utilizzando il flag del formato di input appropriato. Ad esempio, per convertire un TensorFlow SavedModel, utilizza il seguente comando:
sh
tensorflowjs_converter --input_format=tf_saved_model --output_format=tfjs_graph_model /path/to/saved_model /path/to/tfjs_model

In questo comando:
 - `--input_format=tf_saved_model` specifica che il modello di input è un TensorFlow SavedModel.
 - `--output_format=tfjs_graph_model` specifica che l'output dovrebbe essere un modello grafico TensorFlow.js.
Esempio: flusso di lavoro end-to-end
Per fornire una comprensione completa, consideriamo un esempio di flusso di lavoro end-to-end. Supponiamo di aver addestrato una rete neurale convoluzionale (CNN) sul set di dati MNIST in Python e di volerla distribuire nel browser.
Codice Python: addestra e salva il modello
{{EJS17}}
Converti il ​​modello nel formato TensorFlow.js



{{EJS18}}
Codice JavaScript: carica e utilizza il modello nel browser



html
<!DOCTYPE html>
<html>
<head>
    <title>MNIST CNN in TensorFlow.js</title>
    <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script>
    <script>
        async function loadModel() {
            const model = await tf.loadLayersModel('/path/to/tfjs_model/model.json');
            console.log('Model loaded successfully');

            // Example: Making a prediction with a sample input
            const input = tf.tensor4d([/* your input data */], [1, 28, 28, 1]);
            const prediction = model.predict(input);
            prediction.print();
        }

        loadModel();
    </script>
</head>
<body>
    <h1>MNIST CNN in TensorFlow.js</h1>
</body>
</html>

In questo esempio, il codice Python addestra una CNN sul set di dati MNIST e salva il modello come "mnist_cnn.h5". Il convertitore TensorFlow.js viene quindi utilizzato per convertire il modello in un formato adatto alla distribuzione del browser. Infine, il codice JavaScript carica il modello nel browser ed effettua una previsione con un input di esempio. La conversione di un modello Keras addestrato in un formato compatibile con TensorFlow.js per la distribuzione del browser è un processo sistematico che prevede l'addestramento e il salvataggio del modello in Python, utilizzando il convertitore TensorFlow.js per trasformare il modello e caricando il modello in un'applicazione Web utilizzando TensorFlow.js. Questo processo consente l'implementazione di sofisticati modelli di deep learning direttamente nel browser, consentendo un'ampia gamma di applicazioni interattive e in tempo reale. Seguendo i passaggi dettagliati e le considerazioni sopra descritte, è possibile eseguire efficacemente questa conversione e sfruttare la potenza del deep learning negli ambienti basati sul web.
Altre domande e risposte recenti riguardanti Apprendimento approfondito nel browser con TensorFlow.js:
Visualizza altre domande e risposte in Deep learning nel browser con TensorFlow.js
Altre domande e risposte:
Etichettato sotto: , , , , ,