Dai un'occhiata al repository del libro di ricette di Gemma per esempi di generazione e ottimizzazione. Scopri di più

Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un assistente basato sull'IA per l'email aziendale con Gemma

La gestione delle richieste dei clienti, incluse le email, è una parte necessaria della gestione molte aziende, ma la situazione può diventare rapidamente faticosa. Con un po' di impegno, modelli di intelligenza artificiale (IA) come Gemma possono contribuire a semplificare questo lavoro.

Ogni attività gestisce le richieste come le email in modo un po' diverso, quindi è importante essere in grado di adattare tecnologie come l'IA generativa alle esigenze la tua attività. Questo progetto affronta il problema specifico dell'estrazione dell'ordine informazioni dalle email alla panetteria in dati strutturati, in modo che possano essere rapidamente a un sistema di gestione degli ordini. Utilizzo di 10-20 esempi di richieste e ottenere l'output desiderato, puoi ottimizzare un modello Gemma per elaborare le email clienti, aiutarti a rispondere rapidamente e a integrare i sistemi aziendali esistenti. Questo progetto è stato creato come pattern di applicazione di IA che puoi estendere e adattare ottenere valore dai modelli Gemma per la tua attività.

Per una panoramica video del progetto e di come estenderlo, inclusi approfondimenti da chi l'ha creato, dai un'occhiata Assistente IA per email aziendali Video sull'IA di Google. Puoi anche rivedere il codice per questo progetto nella Repository di codice del libro di ricette Gemma. In caso contrario, puoi iniziare a estendere il progetto seguendo le seguenti istruzioni.

Panoramica

Questo tutorial illustra come configurare, gestire ed estendere un'attività un'applicazione assistente email creata con Gemma, Python e Flask. Il progetto offre un'interfaccia utente web di base che puoi modificare in base alle tue esigenze. L'applicazione è progettata per estrarre i dati dalle email dei clienti in una struttura per una panetteria fittizia. Puoi utilizzare questo pattern di applicazione per qualsiasi attività aziendale che utilizza input e output di testo.

Screenshot dell'interfaccia utente dell'app web

Figura 1. Interfaccia utente del progetto per l'elaborazione delle richieste di email relative alla panetteria

Requisiti hardware

Esegui questo processo di ottimizzazione su un computer con una GPU (Graphics Processing Unit) o Tensor Processing Unit (TPU) e memoria GPU o TPU sufficiente per contenere modello esistente, oltre ai dati di ottimizzazione. Per eseguire la configurazione di ottimizzazione in questo sono necessari circa 16 GB di memoria GPU, più o meno la stessa quantità e almeno 50 GB di spazio su disco.

Puoi eseguire la parte di ottimizzazione del modello Gemma di questo tutorial utilizzando un ambiente Colab con un runtime GPU T4. Se stai creando questo progetto su una Google Cloud istanza VM, configura l'istanza in base a questi requisiti:

Hardware GPU: per eseguire questo progetto è necessaria una NVIDIA T4 (NVIDIA L4 o superiore è consigliato)
Sistema operativo: scegli un'opzione Deep Learning su Linux, in particolare VM per il deep learning con CUDA 12.3 M124 con i driver software GPU preinstallati.
Dimensioni del disco di avvio: esegui il provisioning di almeno 50 GB di spazio su disco per i tuoi dati, modelli e software di supporto.

Configurazione del progetto

Queste istruzioni ti guidano nella preparazione di questo progetto per lo sviluppo e i test. I passaggi di configurazione generale includono l'installazione del software necessario, la clonazione del progetto dal repository del codice, l'impostazione di alcune variabili di ambiente, l'installazione delle librerie Python e il test dell'applicazione web.

Installa e configura

Questo progetto utilizza Python 3 e ambienti virtuali (venv) per gestire i pacchetti ed eseguire l'applicazione. Le seguenti istruzioni di installazione sono per un ambiente Linux della macchina host.

Per installare il software necessario:

Installa Python 3 e il pacchetto di ambiente virtuale venv per Python:
```
sudo apt update
sudo apt install git pip python3-venv
```

clona il progetto

Scarica il codice del progetto sul computer di sviluppo. Per recuperare il codice sorgente del progetto, hai bisogno del software di controllo del codice sorgente git.

Per scaricare il codice del progetto:

Clona il repository Git utilizzando il seguente comando:

git clone https://github.com/google-gemini/gemma-cookbook.git

Facoltativamente, configura il tuo repository Git locale in modo da utilizzare il controllo sparse, in modo da avere solo i file del progetto:
```
cd gemma-cookbook/
git sparse-checkout set Demos/business-email-assistant/
git sparse-checkout init --cone
```

Installa le librerie Python

Installa le librerie Python con l'ambiente virtuale Python venv attivate per gestire pacchetti e dipendenze Python. Assicurati di attivare il pulsante Ambiente virtuale Python prima di installare le librerie Python con pip . Per ulteriori informazioni sull'utilizzo degli ambienti virtuali Python, consulta la documentazione di venv di Python.

Per installare le librerie Python:

In una finestra del terminale, vai alla directory business-email-assistant:
```
cd Demos/business-email-assistant/
```
Configura e attiva l'ambiente virtuale Python (venv) per questo progetto:
```
python3 -m venv venv
source venv/bin/activate
```
Installa le librerie Python richieste per questo progetto utilizzando lo scriptsetup_python:
```
./setup_python.sh
```

Imposta le variabili di ambiente

Per l'esecuzione di questo progetto sono necessarie alcune variabili di ambiente, tra cui un nome utente Kaggle e un token API Kaggle. Devi avere un Kaggle di fatturazione e richiedere l'accesso ai modelli Gemma per poterli scaricare. Per questo progetto, aggiungi il tuo Username Kaggle e il tuo token API Kaggle a due .env che vengono letti dall'applicazione web e dal programma di ottimizzazione, rispettivamente.

Per impostare le variabili di ambiente:

Ottieni il tuo nome utente Kaggle e la chiave del token seguendo le istruzioni riportate nella documentazione di Kaggle.
Per accedere al modello Gemma, segui le istruzioni riportate nella sezione Accedere a Gemma nella pagina Configurazione di Gemma.
Crea i file delle variabili di ambiente per il progetto, creando un .env file di testo in ognuna queste posizioni nel tuo clone del progetto:
```
email-processing-webapp/.env
model-tuning/.env
```
Dopo aver creato i file di testo .env, aggiungi le seguenti impostazioni a entrambi file:
```
KAGGLE_USERNAME=<YOUR_KAGGLE_USERNAME_HERE>
KAGGLE_KEY=<YOUR_KAGGLE_KEY_HERE>
```

Esegui e testa l'applicazione

Una volta completata l'installazione e la configurazione del progetto, esegui l'applicazione web per verificare di averla configurata correttamente. Ti consigliamo di eseguire questo controllo di base prima di modificare il progetto per uso personale.

Per eseguire e testare il progetto:

In una finestra del terminale, vai alla directory email-processing-webapp:
```
cd business-email-assistant/email-processing-webapp/
```
Esegui l'applicazione utilizzando lo script run_app:
```
./run_app.sh
```
Dopo aver avviato l'applicazione web, il codice del programma elenca un URL che puoi navigare e testare. In genere questo indirizzo è:
```
http://127.0.0.1:5000/
```
Nell'interfaccia web, premi il pulsante Ottieni dati sotto il primo input campo per generare una risposta dal modello.

La prima risposta del modello dopo l'esecuzione dell'applicazione richiede più tempo poiché deve completare i passaggi di inizializzazione nell'esecuzione della prima generazione. Le richieste di prompt e la generazione successive su un'applicazione web già in esecuzione si completano in meno tempo.

Estendi l'applicazione

Una volta avviata l'applicazione, puoi estenderla modificando l'interfaccia utente e la logica di business in modo che funzioni per le attività pertinenti per te o per la tua attività. Puoi anche modificare il comportamento del modello Gemma utilizzando il codice dell'applicazione modificando i componenti del prompt inviato dall'app al modello di IA generativa.

L'applicazione fornisce istruzioni al modello insieme ai dati di input all'utente un prompt completo del modello. Puoi modificare queste istruzioni per modificare il comportamento del modello, ad esempio specificando i nomi dei parametri e la struttura del file JSON da generare. Un modo più semplice per modificare il comportamento del modello è fornire istruzioni o indicazioni aggiuntive per la risposta del modello, ad esempio specificando che le risposte generate non devono includere alcuna formattazione Markdown.

Per modificare le istruzioni del prompt:

Nel progetto di sviluppo, apri business-email-assistant/email-processing-webapp/app.py file di codice.

Nel codice app.py, aggiungi istruzioni di aggiunta alla funzione get_prompt()::

def get_prompt():
  return """
    Extract the relevant details of this request and return them in
    JSON code, with no additional markdown formatting:\n"""

Questo esempio aggiunge la frase "senza formattazione Markdown aggiuntiva" alle istruzioni.

Fornire istruzioni aggiuntive per i prompt può influenzare notevolmente l'output generato e richiede molto meno impegno per l'implementazione. Ti consigliamo di provare prima questo metodo per vedere se riesci a ottenere il comportamento desiderato dal modello. Tuttavia, l'utilizzo di istruzioni prompt per modificare il comportamento di un modello Gemma ha la sua limiti. In particolare, il limite complessivo di token di input del modello, ovvero 8.192 token per Gemma 2, richiede il bilanciamento di istruzioni dettagliate per il prompt con la dimensione dei nuovi dati che fornisci, in modo da rimanere al di sotto di questo limite.

Ottimizza il modello

L'ottimizzazione di un modello Gemma è il modo consigliato per farlo rispondere in modo più affidabile per attività specifiche. In particolare, se vuoi che il modello generi JSON con una struttura specifica, inclusi parametri con nomi specifici, ti consigliamo di ottimizzarlo per questo comportamento. A seconda dell'attività che vuoi che il modello completi, puoi ottenere con un numero di esempi compreso tra 10 e 20. Questa sezione del tutorial spiega come configurare ed eseguire l'ottimizzazione su un modello Gemma per un'attività specifica.

Le istruzioni riportate di seguito spiegano come eseguire l'operazione di ottimizzazione in un ambiente VM, ma puoi anche eseguire questa operazione di ottimizzazione utilizzando il notebook Colab associato per questo progetto.

Requisiti hardware

I requisiti di calcolo per la messa a punto sono gli stessi dei requisiti hardware per il resto del progetto. Puoi Eseguire l'operazione di ottimizzazione in un ambiente Colab con un runtime GPU T4 se si limitano i token di input a 256 e la dimensione del batch a 1.

Preparazione dei dati

Prima di iniziare a ottimizzare un modello Gemma, devi preparare i dati per l'ottimizzazione. Quando ottimizzi un modello per un'attività specifica, hai bisogno di un insieme di esempi di richieste e risposte. Questi esempi dovrebbero mostrare il testo della richiesta, senza alcun istruzioni e il testo della risposta previsto. Per iniziare, devi preparare un set di dati con circa 10 esempi. Questi esempi dovrebbero rappresentare varie richieste e risposte ideali. Assicurati che le richieste e risposte non sono ripetitive, in quanto questo può far sì che le risposte del modello ripetitivi e non si adattano in modo appropriato alle variazioni delle richieste. Se regolare il modello per produrre un formato di dati strutturati, assicurati che le risposte siano rigorosamente conformi al formato di output dei dati desiderato. Le seguenti mostra alcuni record di esempio del set di dati di questo esempio di codice:

Richiesta	Risposta
Gentile Indian Bakery Central,\nper caso hai 10 penda e trenta bundi ladoo? Inoltre, vendi una glassa alla vaniglia e torte al cioccolato. Cerco un dispositivo da 6 pollici	{ "type": "inquiry", "items": [ { "name": "pendas", "quantity": 10 }, { "name": "bundi ladoos", "quantity": 30 }, { "name": "torta", "filling": null, "frosting": "vaniglia", "flavor": "cioccolato", "size": "6 pollici" } ] }
Ho visto la tua attività su Google Maps. Vendi jellabi e gulab jamun?	{ "type": "inquiry", "items": [ { "name": "jellabi", "quantity": null }, { "name": "gulab jamun", "quantity": null } ] }

Tabella 1. Elenco parziale del set di dati di ottimizzazione per i dati email della panetteria estrattore.

Formattazione e caricamento dei dati

Puoi archiviare i dati di ottimizzazione nel formato più comodo, ad esempio: record di database, file JSON, CSV o file di testo normale, purché tu abbia recupera i record con il codice Python. Questo progetto legge i file JSON da una directory data in un array di oggetti di dizionario. In questo esempio di programma di tornitura, il set di dati di ottimizzazione viene caricato nel modulo model-tuning/main.py utilizzando la funzione prepare_tuning_dataset():

def prepare_tuning_dataset():
    # collect data from JSON files
    prompt_data = read_json_files_to_dicts("./data")
    ...

Come accennato in precedenza, puoi archiviare il set di dati in un formato comodo, purché tu possa recuperare le richieste con le risposte associate e assemblarle in una stringa di testo utilizzata come record di ottimizzazione.

Assembla i record di ottimizzazione

Per la procedura di ottimizzazione effettiva, il programma assembla ogni richiesta e risposta in un'unica stringa con le istruzioni del prompt e i contenuti della risposta. Il programma di ottimizzazione tokenizza quindi la stringa per il consumo da parte del modello. Puoi vedere il codice per l'assemblaggio di un record di ottimizzazione nella funzione model-tuning/main.py del modulo prepare_tuning_dataset(), come segue:

def prepare_tuning_dataset():
    ...
    # prepare data for tuning
    tuning_dataset = []
    template = "{instruction}\n{response}"

    for prompt in prompt_data:
        tuning_dataset.append(template.format(instruction=prompt["prompt"],
                                              response=prompt["response"]))

    return tuning_dataset

Questa funzione prende i dati come input e li formatta aggiungendo un'interruzione di riga tra l'istruzione e la risposta.

Genera i pesi del modello

Dopo aver configurato e caricato i dati di ottimizzazione, puoi eseguire . La procedura di ottimizzazione per questa applicazione di esempio utilizza la libreria NLP di Keras per ottimizzare il modello con una tecnica di adattamento a rango ridotto o LoRA per generare nuovi pesi del modello. Rispetto all'ottimizzazione di precisione completa, l'uso di LoRA molto più efficiente in termini di memoria perché approssima le modifiche al i pesi del modello. È quindi possibile sovrapporre queste ponderazioni approssimative sui i pesi del modello per modificarne il comportamento.

Per eseguire l'esecuzione di ottimizzazione e calcolare i nuovi pesi:

In una finestra del terminale, vai alla directory model-tuning/.
```
cd business-email-assistant/model-tuning/
```
Esegui il processo di ottimizzazione utilizzando lo script tune_model:
```
./tune_model.sh
```

Il processo di ottimizzazione richiede diversi minuti a seconda delle risorse di calcolo disponibili Google Cloud. Al termine dell'operazione, il programma di ottimizzazione scrive nuovi file *.h5 weight nella directory model-tuning/weights con il seguente formato:

gemma2-2b_inquiry_tuned_4_epoch##.lora.h5

Risoluzione dei problemi

Se l'ottimizzazione non viene completata correttamente, i motivi possibili sono due:

Memoria esaurita o risorse esaurite: questi errori si verificano quando Il processo di ottimizzazione richiede una memoria superiore alla memoria GPU o alla CPU disponibile la memoria. Assicurati di non eseguire l'applicazione web durante il processo di ottimizzazione. Se esegui l'ottimizzazione su un dispositivo con 16 GB di memoria GPU, assicurati che token_limit sia impostato su 256 e batch_size impostato su 1.
Driver GPU non installati o non compatibili con JAX: la procedura di trasformazione richiede che sul dispositivo di calcolo siano installati driver hardware compatibili con la versione delle librerie JAX. Per ulteriori dettagli, consulta Installazione JAX documentazione.

Esegui il deployment del modello ottimizzato

Il processo di ottimizzazione genera più pesi in base ai dati di ottimizzazione e al numero totale di epoche impostate nell'applicazione di ottimizzazione. Per impostazione predefinita, il programma di ottimizzazione genera 3 file dei pesi del modello, uno per ogni epoca di ottimizzazione. Ogni epocha di ottimizzazione successiva produce pesi che riproducono in modo più accurato i risultati dei dati di ottimizzazione. Puoi vedere i tassi di precisione per ogni epoca in dell'output del terminale del processo di ottimizzazione, come segue:

...
8/8 ━━━━━━━━━━━━━━━━━━━━ 121s 195ms/step - loss: 0.5432 - sparse_categorical_accuracy: 0.5982
Epoch 2/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 194ms/step - loss: 0.3320 - sparse_categorical_accuracy: 0.6966
Epoch 3/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 192ms/step - loss: 0.2135 - sparse_categorical_accuracy: 0.7848

Anche se vuoi che il tasso di accuratezza sia relativamente alto (circa 0, 80), non devi vuoi che il tasso sia troppo alto, o molto vicino a 1,00, perché questo significa che i pesi si sono avvicinati all'overfitting dei dati di ottimizzazione. In questo caso, non ha un buon rendimento sulle richieste che sono significativamente diverse gli esempi di ottimizzazione. Per impostazione predefinita, lo script di deployment seleziona l'epoca 3 , che in genere hanno un tasso di precisione di circa 0,80.

Per eseguire il deployment dei pesi generati nell'applicazione web:

In una finestra del terminale, vai alla directory model-tuning:
```
cd business-email-assistant/model-tuning/
```
Esegui il processo di ottimizzazione utilizzando lo script deploy_weights:
```
./deploy_weights.sh
```

Dopo aver eseguito questo script, dovresti vedere un nuovo file *.h5 nella Directory email-processing-webapp/weights/.

Testa il nuovo modello

Una volta eseguito il deployment dei nuovi pesi nell'applicazione, puoi provare il modello appena ottimizzato. Per farlo, esegui di nuovo l'applicazione web e genera una risposta.

Per eseguire e testare il progetto:

In una finestra del terminale, vai alla directory email-processing-webapp:
```
cd business-email-assistant/email-processing-webapp/
```
Esegui l'applicazione utilizzando lo script run_app:
```
./run_app.sh
```
Dopo aver avviato l'applicazione web, il codice del programma elenca un URL che puoi navigare e testare. In genere, questo indirizzo è:
```
http://127.0.0.1:5000/
```
Nell'interfaccia web, premi il pulsante Ottieni dati sotto il primo input campo per generare una risposta dal modello.

Hai ottimizzato ed eseguito il deployment di un modello Gemma in un'applicazione. Sperimenta con dell'applicazione e cercare di determinare i limiti di generazione del modello ottimizzato la capacità di archiviazione per la tua attività. Se trovi scenari in cui il modello non funziona bene, valuta la possibilità di aggiungere alcune di queste richieste all'elenco di dati di esempio per la regolazione aggiungendo la richiesta e fornendo una risposta ideale. Poi esegui di nuovo l'ottimizzazione eseguire il deployment dei nuovi pesi e testare l'output.

Risorse aggiuntive

Per ulteriori informazioni su questo progetto, consulta Repository di codice del libro di ricette Gemma. Se hai bisogno di aiuto per creare l'applicazione o vuoi collaborare con altri sviluppatori, dai un'occhiata al server di Discord della community degli sviluppatori Google. Per altri progetti di Build with Google AI, dai un'occhiata al playlist video.