Fine-tuning e inferenza sul modello Gemma di Google usando le TPU per velocità e prestazioni migliori

Questo articolo è un tutorial completo sul fine-tuning dei large language model usando tecniche avanzate. Vedremo esempi con Tensor Processing Unit, una tecnica chiamata LoRA e il calcolo distribuito — tutto per aumentare velocità ed efficienza. Per illustrare le tecniche, accederemo ai modelli Gemma e li faremo il fine-tuning: una nuova famiglia di LLM leggeri e all’avanguardia creata da Google.

Al termine del tutorial, avrai le competenze per fare fine-tuning ed eseguire inferenza su qualsiasi large language model utilizzando le TPU disponibili su Google Cloud. Per arrivarci, tratteremo nell’ordine i seguenti argomenti:

• Introduzione ai tipi di compute: capiremo cosa sono le TPU e perché sono importanti. 

• Uso di Gemma con le TPU: vedremo come configurare un ambiente Kaggle per usare le TPU.

• Setup del modello e inferenza: eseguiremo Gemma usando la libreria Keras in Python.

• Fine-tuning: eseguiremo il fine-tuning del modello Gemma con una tecnica chiamata LoRA. 

• Addestramento distribuito: eseguiremo il fine-tuning distribuito per migliorare l’efficienza dell’addestramento. 

Se sei alle prime armi con l’AI e gli LLM, valuta di seguire il percorso AI Fundamentals per familiarizzare con i termini usati in questo tutorial. 

Iniziamo!

Che cos’è il modello Gemma di Google?

Logo di Google Gemma

Il modello Gemma di Google fa parte di una famiglia di large language model open source e leggeri sviluppati da Google e presentati nel 2024. Gemma è stato creato con la stessa ricerca e tecnologia dei modelli Google Gemini e, come Gemini, è compatibile con i principali framework di machine learning come Keras e Pytorch. È disponibile in due dimensioni, con 2B o 7B parametri.

Mentre Gemini è stato pensato principalmente per gli utenti finali tramite applicazioni e API, Gemma è open source per un’ampia modifica e integrazione da parte degli sviluppatori. I modelli Gemma sono anche più piccoli, quindi più portatili ed economici. 

Cosa sono le Tensor Processing Unit?

Immagini di CPU, GPU, TPU di Freepik e Flaticon

Confrontiamo le diverse opzioni hardware per il machine learning per dare contesto. L’hardware è suddiviso in tipologie distinte, ognuna progettata per ruoli specifici di elaborazione e calcolo. 

• Central Processing Unit: le CPU eseguono i sistemi operativi nella quasi totalità dei dispositivi. Sono note per elaborare i task in sequenza.

• Graphics Processing Unit: le GPU elaborano più task in parallelo, rendendole ideali per il rendering grafico.

• Tensor Processing Unit: le TPU sono processori specializzati sviluppati da Google per il machine learning. Sono progettate per eseguire rapidamente i calcoli matriciali critici nell’addestramento e nell’esecuzione delle reti neurali.

L’ultima categoria, le TPU, è importante per questo tutorial. Le TPU sono più veloci delle GPU nell’addestramento e nell’inferenza delle reti neurali profonde e consumano anche meno energia. Di contro, l’ecosistema TPU è meno maturo, con meno strumenti e framework disponibili. Tra i framework disponibili ci sono Google Cloud Platform, Colab e Kaggle.

Tabella di confronto dell’hardware per il machine learning

Accedere a Google Gemma con le TPU

I modelli Gemma sono progettati per essere altamente scalabili ed efficienti quando usati con setup di calcolo distribuito, che può migliorare sensibilmente prestazioni e velocità, soprattutto con grandi volumi di dati e architetture complesse.

La libreria Keras è adatta a questo scenario perché supporta l’addestramento distribuito dei modelli Gemma, sfruttando un’implementazione multi-backend che include TensorFlow e PyTorch.

In questa sezione, configureremo il nostro notebook Kaggle per supportare le TPU, assicurandoci che tutte le librerie e dipendenze necessarie siano installate per un funzionamento senza intoppi. Caricheremo quindi il modello Gemma 2B o 7B usando il pacchetto keras-nlp. Infine, distribuiremo il modello per svolgere compiti sfruttando la potenza di calcolo della TPU per elaborare e generare risposte in modo efficiente. 

Configurazione

Per preparare l’ambiente, dobbiamo integrare la versione Keras del modello Gemma e impostare la nostra accelerator su TPU per ottenere prestazioni migliori. Installeremo pacchetti essenziali come keras-nlp, configureremo Keras per usare TensorFlow come backend e ottimizzeremo l’allocazione della memoria della TPU per garantire addestramento ed esecuzione fluidi del modello.

Aggiungi l’implementazione Keras al modello Gemma

Per preparare l’ambiente, dobbiamo aggiungere l’implementazione Keras al modello Gemma. In pratica, significa incorporare la versione del modello Gemma compatibile con Keras per un’integrazione fluida con le API di TensorFlow.

Per aggiungere l’implementazione Keras, segui questi passaggi:

• Crea un nuovo notebook in Kaggle.

• Vai alla sezione "Input" nel pannello di destra.

• Clicca su “+ Add Input” per aggiungere l’implementazione Keras del modello Gemma.

Aggiunta dell’implementazione Keras al modello Gemma

Cambia l’accelerator in TPU

Successivamente, dovremo cambiare l’accelerator in TPU, ovvero selezionare la TPU nelle impostazioni del notebook per sfruttarne la potenza di calcolo per addestramento e inferenza.

Per cambiare l’accelerator, segui questi passaggi. È normale che l’ambiente impieghi alcuni minuti a ricaricarsi.

• Vai alla sezione "Session options".
• Cambia l’accelerator da "None" a "TPU VM v3-8".

Impostazione della TPU come accelerator

Installa i pacchetti Python necessari per fine-tuning e inferenza

Ora installiamo i pacchetti Python aggiornati che useremo per fine-tuning e inferenza, inclusi TensorFlow e keras-nlp. 

!pip install -q tensorflow-cpu!pip install -q -U keras-nlp tensorflow-hub!pip install -q -U keras==3.1.1Offerto da

Imposta il backend di Keras

Impostiamo il backend di Keras su JAX per un accesso fluido alle TPU. Puoi provare anche TensorFlow o PyTorch.  

Pre-alloca la memoria della TPU

Infine, pre-allocchiamo la memoria della TPU per ottimizzare le prestazioni ed evitare problemi in esecuzione. Qui pre-allocchiamo il 100% della memoria totale della TPU per evitare la frammentazione della memoria sul backend JAX. 

import osos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"]="1.00"Offerto da

Caricamento del modello

Carichiamo i pacchetti Python necessari per l’inferenza del modello. 

import kerasimport keras_nlpOfferto da

Quindi carichiamo il modello e mostriamo il riepilogo del modello. 

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_instruct_2b_en")gemma_lm.summary()Offerto da

Abbiamo caricato con successo tokenizer e modello con un solo comando. È notevole, perché anche il modello Gemma più piccolo ha 2,5 miliardi di parametri e una dimensione di 9,34 GB. 

Riepilogo del modello Gemma

Potresti dover attendere alcuni minuti per eseguire il notebook e poi sperimentare prestazioni super rapide. Le TPU sono molto richieste. Se esegui il notebook di notte, potresti non dover aspettare. 

In coda per l’accesso alle TPU

Inferenza del modello

Eseguire inferenza significa usare il nostro modello per generare output a partire da nuovi input mai visti. Nel nostro caso forniremo questi input come testo usando la funzione .generate(). Riceveremo subito la risposta. 

print(gemma_lm.generate("What is DataCamp?", max_length=30))Offerto da

What is DataCamp?DataCamp is a leading online data science education platform that empowers individuals and organizations to build data-driven careers. TheyOfferto da

Possiamo anche provare l’inferenza in batch, ovvero fornire più prompt per generare più risposte. L’output arriva sotto forma di lista. 

print(gemma_lm.generate(["How far is the Sun from earth", "What is the Sun made of?"], max_length=30))Offerto da

['How far is the Sun from earth?\n\nThe Sun is about 149.6 million kilometers (93 million miles) away from', 'What is the Sun made of?\n\nThe Sun is primarily composed of hydrogen and helium. Hydrogen makes up about 73.4% of']Offerto da

Ora proveremo a creare un template con istruzioni e risposte per guidare il nostro modello. Puoi aggiungere un prompt di sistema o qualsiasi comando iniziale aggiuntivo per modificare la risposta generata. 

Useremo la funzione .format() per compilare il testo del template con gli argomenti dell’utente. Di conseguenza, otteniamo un elenco di passaggi da seguire per imparare Python.

template = "Instruction:\n{instruction}\n\nResponse:\n{response}"prompt = template.format(    instruction="How do I start learning Python?",    response="",)print(gemma_lm.generate(prompt, max_length=250))Offerto da

Instruction:How do I start learning Python?Response:**Step 1: Choose a learning path*** **Online Courses:**    * DataCamp    * Codecademy    * Coursera    * edX    * Udemy* **Books:**    * "Automate the Boring Stuff with Python" by Al Sweigart    * "Python Crash Course" by Eric Matthes    * "Head First Python" by Kathy Sierra and Bert Bates* **Video Tutorials.........Offerto da

Se hai difficoltà a caricare il modello e generare una risposta usando le TPU, puoi consultare questo notebook Kaggle: Accessing Gemma-instruct-2b-en using TPUs.

Se inizi a sentirti a tuo agio con Gemma, scopri come migliorarlo con istruzioni personalizzate dando un’occhiata al nostro tutorial Fine Tuning Google Gemma: Enhancing LLMs with Customized Instructions.

Fine-tuning di Gemma con le TPU

Ora impariamo come fare il fine-tuning del modello Gemma utilizzando un dataset pubblico chiamato OpenHermes. Il dataset OpenHermes ha 242.000 righe con due colonne, una per le istruzioni e una per le risposte, tutte generate con il modello GPT-4.

Come vedremo, eseguire il fine-tuning di questo dataset richiederebbe molto tempo, anche con le TPU. Per agevolare il processo, incorporeremo una tecnica chiamata LoRA.

LoRA, o Low-Rank Adaptation, è progettata per rendere più efficiente e accessibile il fine-tuning dei large language model. Affronta le sfide dei metodi tradizionali di fine-tuning, spesso costosi in termini computazionali e di risorse.

A livello tecnico, LoRA funziona congelando i pesi pre-addestrati del modello e introducendo matrici a rango ridotto che modificano parti specifiche dell’architettura. Concentrandosi su queste matrici a basso rango, LoRA riduce al minimo le risorse necessarie, rendendo praticabile il fine-tuning di modelli grandi anche su hardware meno potente.

Configurazione

Come per la configurazione dell’ambiente del modello fatta in precedenza, imposteremo il backend Keras e la pre-allocazione della memoria. Possiamo anche usare la funzione jax. devices() per verificare la disponibilità dei dispositivi TPU. 

import osimport jaxos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.9"jax.devices()Offerto da

Numero di dispositivi di calcolo

Caricamento del modello e del dataset

Carichiamo il modello e mostriamo il riepilogo. Abbiamo 2,5B parametri addestrabili.

import kerasimport keras_nlpgemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_2b_en")gemma_lm.summary()Offerto da

Riepilogo del modello Gemma

Ora carichiamo il dataset nel notebook. Il processo è simile all’aggiunta del modello. Seguiamo questi passaggi:

• Vai alla sezione "Add input". 
• Cerca il dataset OpenHermes. 
• Aggiungi il dataset. Per chiarezza, scegliamo quello ospitato da Volodymyr Pivoshenko.

Aggiunta del dataset OpenHermes

Ora usiamo la libreria pandas per leggere il dataset e mostrare le prime 5 righe. Vediamo che ci sono 2 colonne, una per le istruzioni e una per l’output.

import pandas as pddf = pd.read_csv('/kaggle/input/openhermes/openhermes.csv')df.head()Offerto da

Dataset OpenHermes

Ora che abbiamo caricato modello e dataset, dobbiamo passare un dataset al nostro modello. Per farlo, dobbiamo convertire il dataset in un elenco di stringhe con il formato istruzione e risposta.

A quanto pare, addestrare l’intero dataset richiede quasi 23 ore, anche su TPU. Per questo motivo selezioneremo solo i primi 1.000 campioni dall’elenco per ridurre i tempi di addestramento.

template = "Instruction:\n{instruction}\n\nResponse:\n{output}"data = [template.format(**row) for index, row in df.iterrows()]Offerto da

data = data[:1000]print(data[0])Offerto da

Primo campione del dataset OpenHermes

Inferenza prima del fine-tuning

Creiamo innanzitutto una baseline con cui confrontare il successo dell’uso di LoRA. Per farlo, genereremo la risposta usando la funzione template.format().

Osservando bene, il seguente output mostra che la risposta di base non è molto dettagliata. Gemma inizia persino a ripetersi dopo la fine della prima risposta. Non è un gran risultato, ma illustra bene la necessità di fare fine-tuning del modello per fornire risposte migliori.

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Offerto da

Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-dayOfferto da

Compilazione del modello per il fine-tuning

Miglioriamo ora il nostro modello con LoRA, che riduce il numero di parametri addestrabili per i task a valle. 

Nel nostro esempio, faremo il fine-tuning con LoRA rank 4, il rango computazionalmente più leggero. LoRA rank 8 o 16 sono opzioni se vuoi migliorare le prestazioni del modello. Leggi la guida Fine-Tuning LLaMA 2 per saperne di più su LoRA e quantizzazione.

Specifichiamo poi ottimizzatore, funzione di loss e metrica di accuratezza da usare.

gemma_lm.backbone.enable_lora(rank=4)Offerto da

gemma_lm.preprocessor.sequence_length = 512optimizer = keras.optimizers.AdamW(    learning_rate=5e-5,    weight_decay=0.01,)optimizer.exclude_from_weight_decay(var_names=["bias", "scale"])gemma_lm.compile(    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),    optimizer=optimizer,    weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],)gemma_lm.summary()Offerto da

I nostri parametri addestrabili sono diminuiti in modo significativo da 2,5 miliardi a 1,3 milioni. E la dimensione del layer adattatore è di soli 5,2 MB. 

Modello Gemma: parametri totali vs addestrabili

Addestramento del modello

Ora effettueremo il fit dei dati sul modello. Qui scegliamo 1 epoca ed una batch size di 1. Puoi migliorare le prestazioni addestrando il dataset completo per almeno 5 epoche. 

gemma_lm.fit(data, epochs=1, batch_size=1)Offerto da

Inferenza dopo il fine-tuning

Proviamo ora lo stesso prompt usato nell’esperimento di baseline per vedere se il modello è migliorato. Questa volta, invece di risposte di una riga e ripetizioni, il modello fornisce un piano dettagliato per un viaggio alle Bahamas.

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Offerto da

Instruction:Plan a 5-day Bahamas trip.Response:Day 1: Arrive in Nassau, BahamasUpon arrival in Nassau, you will be greeted by a local guide who will take you on a tour of the city. Visit the famous Straw Market, where you can shop for souvenirs and local crafts. Enjoy lunch at a local restaurant before heading to the Atlantis Resort for a day of fun and relaxation. Spend the afternoon exploring the resort's world-class amenities, including the Aquaventure Water Park, Dolphin Cay, and the massive marine habitat, The Dig.Day 2: Explore Paradise IslandOn day 2, you will explore Paradise Island, home to the world-famous Atlantis Resort. Visit the famous Atlantis Casino and enjoy a round of blackjack or roulette. Take a stroll along the beach and enjoy the crystal-clear waters of the Atlantic Ocean. Visit the Dolphin Cay, where you can swim with dolphins and other marine animals.Day 3: Snorkel at Cabbage BeachOn day 3, you will head to Cabbage Beach, a secluded beach located on Paradise Island. Snorkel in the crystal-clear waters and explore the coral reefs. Enjoy a delicious lunch at a local restaurant before heading back to Nassau.Offerto da

Puoi salvare i pesi del modello per l’inferenza e distribuire il modello in produzione. 

gemma_lm.save_weights('gemma_2b_openhermes.weights.h5')Offerto da

La dimensione totale del nostro modello fine-tuned è 10,04 GB. 

File del modello Gemma sottoposto a fine-tuning e salvato

Se hai problemi con il fine-tuning del modello, puoi consultare questo notebook Kaggle come riferimento: Finetuning Gemma using TPUs

Fine-tuning e inferenza distribuiti di Gemma con TPU

Come sezione finale, daremo uno sguardo da vicino al fine-tuning distribuito. Il fine-tuning distribuito si ottiene tramite il parallelismo del modello, che distribuisce i pesi di un singolo modello su più dispositivi, abilita lo scaling orizzontale e accelera l’addestramento.

In questa parte ridurremo sensibilmente il tempo di addestramento su un modello grande. In particolare useremo Keras con backend JAX per fare fine-tuning di Gemma con LoRA e addestramento distribuito su TPU. 

Configurazione

Qui avviamo un nuovo notebook Kaggle e installiamo le librerie necessarie. Quindi impostiamo il backend Keras e pre-allocchiamo la memoria.

!pip install -q tensorflow-cpu!pip install -q -U keras-nlp tensorflow-hub!pip install -q -U keras==3.1.1Offerto da

import osos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.9"Offerto da

Impostare la distribuzione per 8 TPU

Per prima cosa creeremo una DeviceMesh per aiutarci a caricare pesi e tensori del modello distribuiti su più dispositivi TPU. Consente data e model parallelism, permettendo di scalare in modo efficiente gli LLM su più accelerator.

Crea una DeviceMesh con forma (1, 8), così i pesi del modello saranno shardati su tutte e 8 le TPU.

import kerasimport keras_nlpdevice_mesh = keras.distribution.DeviceMesh(    (1, 8), ["batch", "model"], devices=keras.distribution.list_devices())Offerto da

Successivamente, creeremo una mappa di layout che specifica come shardarli o replicarli usando le RegEx.

Tieni a mente i seguenti punti:

• I pesi che corrispondono a token_embedding/embeddings saranno condivisi.

• Usa RegEx per trovare le matrici query, key e value nel decoder attention, attention_output, ffw_gating e ffw_linear.

• I tensori corrispondenti vengono shardati usando la DeviceMesh, mentre il resto sarà completamente replicato.

model_dim = "model"layout_map = keras.distribution.LayoutMap(device_mesh)layout_map["token_embedding/embeddings"] = (None, model_dim)layout_map["decoder_block.*attention.*(query|key|value).*kernel"] = (    None,    model_dim,    None,)layout_map["decoder_block.*attention_output.*kernel"] = (None, None, model_dim)layout_map["decoder_block.*ffw_gating.*kernel"] = (model_dim, None)layout_map["decoder_block.*ffw_linear.*kernel"] = (None, model_dim)Offerto da

Ora attiveremo il parallelismo del modello usando device_mesh e layout_map. 

model_parallel = keras.distribution.ModelParallel(    device_mesh, layout_map, batch_dim_name="batch")keras.distribution.set_distribution(model_parallel)Offerto da

Caricamento del modello

Dopo aver impostato il parallelismo del modello, carichiamo il nostro modello. 

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_7b_en")gemma_lm.summary()Offerto da

Questa volta, poiché usiamo il modello Gemma 7B, vediamo 8,5 miliardi di parametri addestrabili. 

Riepilogo del modello Gemma 7B

Per verificare che il modello sia stato shardato correttamente, stamperemo path, shape e spec dei pesi del layer decoder_block_1. 

decoder_block_1 = gemma_lm.backbone.get_layer('decoder_block_1')print(type(decoder_block_1))for variable in decoder_block_1.weights:  print(f'{variable.path:<58}  {str(variable.shape):<16}  {str(variable.value.sharding.spec)}')Offerto da

Decoder block

Caricamento del dataset

Carichiamo il dataset OpenHermes. Anche qui convertiamo il dataframe in un elenco di stringhe usando il template di istruzione e risposta e, per velocizzare l’addestramento, selezioniamo solo i primi 1.000 campioni. 

import pandas as pddf = pd.read_csv('/kaggle/input/openhermes/openhermes.csv')# Format and convert the dataframe into a list of strings.template = "Instruction:\n{instruction}\n\nResponse:\n{output}"data = [template.format(**row) for index, row in df.iterrows()]# Select a subset of the dataset. data = data[:1000]Offerto da

Inferenza prima del fine-tuning

Genereremo ora la risposta per la baseline fornendo il prompt formattato. Curiosamente, la risposta è persino peggiore di quella del modello più piccolo, ma andiamo avanti. 

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Offerto da

 Risultato dell’inferenza prima del fine-tuning

Compilazione del modello per il fine-tuning

Compileremo il modello usando le stesse configurazioni, il rank di LoRA, l’ottimizzatore, la funzione di loss e la metrica di accuratezza. Ora abbiamo 11 milioni di parametri addestrabili con una dimensione di 42,22 MB.

gemma_lm.backbone.enable_lora(rank=4)gemma_lm.preprocessor.sequence_length = 512optimizer = keras.optimizers.AdamW(    learning_rate=5e-5,    weight_decay=0.01,)optimizer.exclude_from_weight_decay(var_names=["bias", "scale"])gemma_lm.compile(    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),    optimizer=optimizer,    weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],)gemma_lm.summary()Offerto da

Riepilogo del modello Gemma 7B LoRA

Addestramento del modello

Ci sono voluti 305 secondi per effettuare il fine-tuning di un’epoca: ottimo, considerando la dimensione del modello. 

gemma_lm.fit(data, epochs=1, batch_size=1)Offerto da

Se trovi il fine-tuning impegnativo, puoi imparare a usare l’API di OpenAI e seguire una guida passo passo per fare il fine-tuning di GPT-4. 

Inferenza dopo il fine-tuning

Generiamo la risposta e confrontiamola con il risultato di baseline. 

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Offerto da

Il modello sottoposto a fine-tuning è perfetto. Ha generato una risposta con l’elenco delle cose da fare per goderti un viaggio di cinque giorni alle Bahamas. 

Nota: puoi disattivare LoRA per un tuning a pieno parametro più lento ma più accurato con il parallelismo del modello.

Risultato dell’inferenza dopo il fine-tuning

gemma_lm.save_weights('gemma_7b_openhermes.weights.h5')Offerto da

Ancora una volta, se hai difficoltà con il fine-tuning distribuito, puoi consultare questo notebook Kaggle come risorsa aggiuntiva: Accessing Gemma-instruct-2b-en using TPUs. 

Conclusione

In questo tutorial abbiamo visto cosa sono le TPU e come usarle per accelerare la generazione di risposte degli LLM. Inoltre, abbiamo imparato a fare il fine-tuning dei modelli Gemma sul dataset OpenHermes usando TPU e addestramento distribuito.

Eseguire il fine-tuning degli LLM su TPU e usare il parallelismo del modello per l’apprendimento distribuito sono modi importanti per accelerare i tempi di addestramento. Con l’apprendimento distribuito puoi fare il fine-tuning anche di modelli molto grandi come Gemma 7B. Sfruttando le TPU, progettate specificamente per attività di machine learning ad alte prestazioni, puoi ottenere notevoli velocizzazioni sia nelle fasi di addestramento che di inferenza.

Se il tutorial ti è piaciuto e vuoi approfondire il mondo dei large language model, segui il corso Master Large Language Models (LLMs) Concepts per scoprire il pieno potenziale delle applicazioni LLM, le metodologie di addestramento, le considerazioni etiche e le ricerche più recenti. Se ti interessano altri large language model in competizione con Gemma, dai un’occhiata al tutorial Guida introduttiva a Mixtral 8X22B per saperne di più sul nuovo modello di Mistral AI e sulla sua architettura SMoE (sparse mixture of experts).