Attività nelle lingue parlate con Gemma

L'utilizzo della tecnologia di intelligenza artificiale (IA) in una lingua parlata specifica è una necessità critica per molte aziende per poterla utilizzare in modo efficace. La famiglia di modelli Gemma ha alcune funzionalità multilingue, ma il suo utilizzo in lingue diverse dall'inglese spesso produce risultati non ideali.

Fortunatamente, non è necessario insegnare a Gemma un'intera lingua parlata per poter completare le attività in quella lingua. Inoltre, puoi ottimizzare i modelli Gemma per completare attività specifiche in una lingua con meno dati e meno sforzo di quanto potresti pensare. Utilizzando circa 20 esempi di richieste e risposte previste nella lingua di destinazione, puoi chiedere a Gemma di aiutarti a risolvere molti diversi problemi aziendali nella lingua più adatta a te e ai tuoi clienti.

Per una panoramica video del progetto e su come estenderlo, inclusi approfondimenti da parte di chi lo sviluppa, guarda il video Assistente AI per il linguaggio parlato Realizza con l'AI di Google. Puoi anche esaminare il codice di questo progetto nel repository del codice di Gemma Cookbook. In caso contrario, puoi iniziare a estendere il progetto seguendo queste istruzioni.

Panoramica

Questo tutorial illustra come configurare, eseguire ed estendere un'applicazione per attività in linguaggio parlato creata con Gemma e Python. L'applicazione fornisce un'interfaccia utente web di base che puoi modificare in base alle tue esigenze. L'applicazione è progettata per generare risposte alle email dei clienti per una panetteria coreana fittizia e tutto l'input e l'output in lingua viene gestito interamente in coreano. Puoi utilizzare questo pattern di applicazione con qualsiasi lingua e qualsiasi attività aziendale che utilizza input di testo e output di testo.

Figura 1. Interfaccia utente del progetto per richieste via email di panetterie coreane

Requisiti hardware

Esegui questa procedura di ottimizzazione su un computer con una GPU (unità di elaborazione grafica) o una TPU (unità di elaborazione tensoriale) e memoria sufficiente per contenere il modello esistente, oltre ai dati di ottimizzazione. Per eseguire la configurazione di ottimizzazione in questo progetto, sono necessari circa 16 GB di memoria GPU, circa la stessa quantità di RAM normale 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 un'istanza VM Google Cloud, configura l'istanza in base ai seguenti requisiti:

• Hardware GPU: per eseguire questo progetto è necessaria una NVIDIA T4 ed è consigliata una NVIDIA L4 o versioni successive.
• Sistema operativo: seleziona un'opzione Deep Learning su Linux, in particolare la 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 illustrano come preparare il progetto per lo sviluppo e il 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.

Installazione e configurazione

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

Per installare il software necessario:

• Installa Python 3 e il pacchetto dell'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:

1. Clona il repository Git utilizzando il seguente comando.

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

2. 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 Gemma/spoken-language-tasks/
   git sparse-checkout init --cone
   

Installa le librerie Python

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

Per installare le librerie Python:

1. In una finestra del terminale, vai alla directory spoken-language-tasks:

   cd Gemma/spoken-language-tasks/
   

2. Configura e attiva l'ambiente virtuale Python (venv) per questo progetto:

   python3 -m venv venv
   source venv/bin/activate
   

3. Installa le librerie Python richieste per questo progetto utilizzando lo scriptsetup_python.

   ./setup_python.sh
   

Imposta le variabili di ambiente

Imposta alcune variabili di ambiente necessarie per consentire l'esecuzione di questo progetto di codice, tra cui un nome utente e una chiave token Kaggle. Per poterli scaricare, devi avere un account Kaggle e richiedere l'accesso ai modelli Gemma. Per questo progetto, aggiungi il tuo nome utente Kaggle e la chiave del token Kaggle a due file .env, che vengono letti rispettivamente dall'applicazione web e dal programma di ottimizzazione.

Per impostare le variabili di ambiente:

1. Ottieni il tuo nome utente Kaggle e la chiave del token seguendo le istruzioni riportate nella documentazione di Kaggle.
2. Per accedere al modello Gemma, segui le istruzioni Accedi a Gemma nella pagina Configurazione di Gemma.
3. Crea i file delle variabili di ambiente per il progetto creando un .env file di testo in ogni una di queste posizioni nel clone del progetto:

   k-mail-replier/k_mail_replier/.env
   k-gemma-it/.env
   

4. Dopo aver creato i file di testo .env, aggiungi le seguenti impostazioni a entrambi i 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:

1. In una finestra del terminale, vai alla directory /k_mail_replier/:

   cd spoken-language-tasks/k-mail-replier/
   

2. Esegui l'applicazione utilizzando lo script run_flask_app.sh:

   ./run_flask_app.sh
   

3. 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/
   

4. Nell'interfaccia web, premi il pulsante 답변 작성 sotto il primo campo di input per generare una risposta del 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 successive richieste di prompt e la generazione su un'applicazione web già in esecuzione vengono completate 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 dall'utente un prompt completo del modello. Puoi modificare queste istruzioni per cambiare il comportamento del modello, ad esempio specificando che deve estrarre le informazioni dalla richiesta e metterle in formato di dati strutturati, ad esempio JSON. 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 devono essere scritte in un tono educato.

Per modificare le istruzioni del prompt:

1. Nel progetto di task di lingua parlata, apri il k-mail-replier/k_mail_replier/app.py file di codice.

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

   def get_prompt():
       return "발신자에게 요청에 대한 감사를 전하고, 곧 자세한 내용을
           알려드리겠다고 정중하게 답장해 주세요. 정중하게 답변해 주세요!:\n"
   

Questo esempio aggiunge la frase "Scrivi una risposta educata" alle istruzioni in coreano.

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 i suoi limiti. In particolare, il limite complessivo di token di input del modello, ovvero 8192 token per Gemma 2,richiede di bilanciare istruzioni dettagliate dei prompt con la dimensione dei nuovi dati forniti, in modo da rimanere al di sotto di questo limite.

Inoltre, quando vuoi che Gemma esegua attività in una lingua diversa dall'inglese, il semplice prompt del modello di base non produrrà risultati affidabili e utili. Dovresti invece ottimizzare il modello con esempi nella lingua di destinazione e poi prendere in considerazione la modifica delle istruzioni del prompt per apportare aggiustamenti più piccoli all'output del modello ottimizzato.

Ottimizza il modello

L'ottimizzazione di un modello Gemma è il modo consigliato per farlo rispondere in modo efficace in una lingua parlata diversa dall'inglese. Tuttavia, non è necessario puntare alla piena padronanza della lingua di destinazione affinché il modello possa completare le attività in quella lingua. Puoi ottenere funzionalità di base nella lingua di destinazione per un'attività con circa 20 esempi. Questa sezione del tutorial spiega come configurare ed eseguire l'ottimizzazione su un modello Gemma per un'attività specifica, in un linguaggio specifico.

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 limiti 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à e una lingua specifiche, hai bisogno di un insieme di esempi di richieste e risposte nella lingua di destinazione. Questi esempi devono mostrare il testo della richiesta, senza istruzioni, e il testo della risposta prevista. Per iniziare, devi preparare un set di dati con circa 20 esempi. Questi esempi devono rappresentare una gamma completa di richieste e le risposte ideali. Assicurati che le richieste e le risposte non siano ripetitive, poiché ciò può causare risposte ripetitive dei modelli e non adeguarsi in modo appropriato alle variazioni delle richieste. La tabella seguente mostra alcuni record di esempio del set di dati di questo esempio di codice:

Tabella 1. Elenco parziale del set di dati di ottimizzazione per il rispondente alle email della panetteria coreana.

Formattazione e caricamento dei dati

Puoi memorizzare i dati di ottimizzazione in qualsiasi formato pratico, inclusi record di database, file JSON, CSV o file di testo normale, purché tu abbia i mezzi per recuperare i record con codice Python. Per comodità, il programma di ottimizzazione di esempio recupera i record da un repository online. In questo esempio di programma di tornitura, il set di dati di ottimizzazione viene caricato nel modulo k-gemma-it/main.py utilizzando la funzione prepare_tuning_dataset():

def prepare_tuning_dataset():
    tokenizer = keras_nlp.models.GemmaTokenizer.from_preset(model_id)

    # load data from repository (or local directory)
    from datasets import load_dataset
    ds = load_dataset(
        # Dataset : https://huggingface.co/datasets/bebechien/korean_cake_boss
        "bebechien/korean_cake_boss",
        split="train",
    )
    ...

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.

Assemblare i record di ottimizzazione

Per la procedura di ottimizzazione effettiva, ogni richiesta e risposta viene assemblata in una singola stringa con le istruzioni e i tag del prompt per indicare i contenuti della richiesta e della risposta. Questo 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 k-gemma-it/main.py del modulo prepare_tuning_dataset(), come segue:

def prepare_tuning_dataset():
    ...
    prompt_instruction = "다음에 대한 이메일 답장을 작성해줘."

    for x in data:
        item = f"<start_of_turn>user\n{prompt_instruction}\n\"{x['input']}\"<end_of_turn>\n<start_of_turn>model\n{x['output']}<end_of_turn>"
        length = len(tokenizer(item))
        # skip data if the token length is longer than our limit
        if length < token_limit:
            tuning_dataset.append(item)
            if(len(tuning_dataset)>=num_data_limit):
                break
    ...

Questa funzione legge i dati e li formatta aggiungendo i tag start_of_turn e end_of_turn, che rappresentano il formato richiesto quando fornisci i dati per la messa a punto di un modello Gemma. Questo codice inserisce anche un prompt_instruction per ogni richiesta, che devi modificare in base alle esigenze della tua applicazione.

Genera pesi del modello

Una volta che i dati di ottimizzazione sono stati caricati, puoi eseguire il programma di ottimizzazione. 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 basso ranking (LoRA) per generare nuovi pesi del modello. Rispetto alla regolazione con precisione completa, l'utilizzo di LoRA è molto più efficiente in termini di memoria perché approssima le modifiche ai pesi del modello. Puoi quindi sovrapporre questi pesi approssimativi ai pesi del modello esistente per modificarne il comportamento.

Per eseguire l'ottimizzazione e calcolare nuovi pesi:

1. In una finestra del terminale, vai alla directory k-gemma-it/.

   cd spoken-language-tasks/k-gemma-it/
   

2. Esegui la procedura di ottimizzazione utilizzando lo script tune_model:

   ./tune_model.sh
   

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

gemma2-2b_k-tuned_4_epoch##.lora.h5

Risoluzione dei problemi

Se la regolazione non viene completata correttamente, i motivi sono due:

1. Memoria insufficiente/risorse esaurite: questi errori si verificano quando la procedura di ottimizzazione richiede una memoria superiore a quella disponibile della GPU o della CPU. 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 di avere token_limit impostato su 256 e batch_size impostato su 1.
2. 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 la documentazione sull'installazione di JAX.

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 20 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 visualizzare i tassi di accuratezza per ogni epoca nell'output del terminale del processo di ottimizzazione, come segue:

...
Epoch 14/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 567ms/step - loss: 0.4026 - sparse_categorical_accuracy: 0.8235
Epoch 15/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 569ms/step - loss: 0.3659 - sparse_categorical_accuracy: 0.8382
Epoch 16/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 571ms/step - loss: 0.3314 - sparse_categorical_accuracy: 0.8538
Epoch 17/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 572ms/step - loss: 0.2996 - sparse_categorical_accuracy: 0.8686
Epoch 18/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 574ms/step - loss: 0.2710 - sparse_categorical_accuracy: 0.8801
Epoch 19/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 575ms/step - loss: 0.2451 - sparse_categorical_accuracy: 0.8903
Epoch 20/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 575ms/step - loss: 0.2212 - sparse_categorical_accuracy: 0.9021

Sebbene sia consigliabile che il tasso di accuratezza sia relativamente elevato, intorno a 0,80-0,90, non deve essere troppo elevato o molto vicino a 1,00, perché ciò significa che i pesi sono vicini a un adattamento eccessivo dei dati di ottimizzazione. In questi casi, il modello non ha un buon rendimento per le richieste molto diverse dagli esempi di ottimizzazione. Per impostazione predefinita, lo script di deployment sceglie i pesi della epoch 17, che in genere hanno un tasso di accuratezza di circa 0,90.

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

1. In una finestra del terminale, vai alla directory k-gemma-it/.

   cd spoken-language-tasks/k-gemma-it/
   

2. Esegui la procedura di ottimizzazione utilizzando lo script deploy_weights:

   ./deploy_weights.sh
   

Dopo aver eseguito questo script, dovresti vedere un nuovo file *.h5 nella directory k-mail-replier/k_mail_replier/weights/.

Testa il nuovo modello

Dopo aver implementato i nuovi pesi nell'applicazione, è il momento di provare il nuovo modello ottimizzato. Per farlo, esegui di nuovo l'applicazione web e genera una risposta.

Per eseguire e testare il progetto:

1. In una finestra del terminale, vai alla directory /k_mail_replier/.

   cd spoken-language-tasks/k-mail-replier/
   

2. Esegui l'applicazione utilizzando lo script run_flask_app.sh:

   ./run_flask_app.sh
   

3. 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/
   

4. Nell'interfaccia web, premi il pulsante 답변 작성 sotto il primo campo di input per generare una risposta dal modello.

Ora hai ottimizzato e implementato un modello Gemma in un'applicazione. Fai esperimenti con l'applicazione e prova a determinare i limiti della capacità di generazione del modello ottimizzato per la tua attività. Se trovi scenari in cui il modello non funziona bene, valuta la possibilità di aggiungere alcune di queste richieste al tuo elenco di dati di esempio di ottimizzazione aggiungendo la richiesta e fornendo una risposta ideale. Quindi, esegui nuovamente il processo di ottimizzazione, ridistribuisci i nuovi pesi e testa l'output.

Risorse aggiuntive

Per ulteriori informazioni su questo progetto, consulta il repository del codice di Gemma Cookbook. 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 alla playlist video.