Guida all'inferenza LLM

L'API LLM Inference ti consente di eseguire modelli linguistici di grandi dimensioni (LLM) completamente sul dispositivo, che puoi utilizzare per svolgere un'ampia gamma di attività, come la generazione di testo, il recupero di informazioni in forma di linguaggio naturale e il riepilogo dei documenti. L'attività fornisce il supporto integrato per più modelli linguistici di grandi dimensioni text-to-text, in modo da poter applicare i modelli di IA generativa on-device più recenti alle tue app e ai tuoi prodotti.

Prova!arrow_forward

L'attività supporta le seguenti varianti di Gemma: Gemma-2 2B, Gemma 2B e Gemma 7B. Gemma è una famiglia di modelli aperti leggeri e all'avanguardia creati sulla base della stessa ricerca e tecnologia utilizzata per creare i modelli Gemini. Supporta inoltre i seguenti modelli esterni: Phi-2, Falcon-RW-1B e StableLM-3B.

Oltre ai modelli supportati, puoi utilizzare AI Edge Torch di Google per esportare i modelli PyTorch in modelli LiteRT (tflite) con più firme, che sono raggruppati con i parametri del tokenizzatore per creare pacchetti di attività compatibili con l'API di inferenza LLM. I modelli convertiti con AI Edge Torch possono essere eseguiti solo sul backend della CPU e sono quindi limitati ad Android e iOS.

Inizia

Per iniziare a utilizzare questa attività, segui una di queste guide all'implementazione per la tua piattaforma di destinazione. Queste guide specifiche per la piattaforma illustrano un'implementazione di base di questa attività, con esempi di codice che utilizzano un modello disponibile e le opzioni di configurazione consigliate:

• Web:

  • Guida
  • Esempio di codice

• Android:

  • Guida
  • Esempio di codice

• iOS

  • Guida
  • Esempio di codice

Dettagli attività

Questa sezione descrive le funzionalità, gli input, gli output e le opzioni di configurazione di questa attività.

Funzionalità

L'API LLM Inference contiene le seguenti funzionalità chiave:

1. Generare testo da testo: genera testo in base a un prompt di testo di input.
2. Selezione LLM: applica più modelli per personalizzare l'app in base ai tuoi casi d'uso specifici. Puoi anche addestrare nuovamente il modello e applicare pesi personalizzati.
3. Supporto LoRA: espandi e personalizza la funzionalità LLM con il modello LoRA addestrandolo sull'intero set di dati o utilizzando modelli LoRA predefiniti preparati dalla community open source (non compatibile con i modelli convertiti con l'API AI Edge Torch Generative).

Opzioni di configurazione

Questa attività ha le seguenti opzioni di configurazione:

Modelli

L'API LLM Inference supporta molti modelli linguistici di grandi dimensioni di tipo testo a testo, incluso il supporto integrato per diversi modelli ottimizzati per l'esecuzione su browser e dispositivi mobili. Questi modelli leggeri possono essere utilizzati per eseguire inferenze completamente sul dispositivo.

Prima di inizializzare l'API di inferenza LLM, scarica un modello e archivia il file nella directory del progetto. Puoi utilizzare un modello preconvertito o convertire un modello in un formato compatibile con MediaPipe.

L'API LLM Inference è compatibile con due tipi di categorie di modelli, alcuni dei quali richiedono la conversione del modello. Utilizza la tabella per identificare il metodo di procedura richiesto per il tuo modello.

Stiamo ospitando i file .bin convertiti per Gemma 2B, Gemma 7B e Gemma-2 2B su Kaggle. Questi modelli possono essere implementati direttamente utilizzando la nostra API di inferenza LLM. Per scoprire come convertire altri modelli, consulta la sezione Conversione di modelli.

Gemma-2 2B

Gemma-2 2B è il modello più recente della famiglia Gemma di modelli aperti leggeri e all'avanguardia creati sulla base della stessa ricerca e tecnologia utilizzata per creare i modelli Gemini. Il modello contiene parametri 2B e pesi aperti. Gemma-2 2B è nota per le sue capacità di ragionamento all'avanguardia per i modelli della sua classe.

Scarica Gemma-2 2B

I modelli Gemma-2 2B sono disponibili nelle seguenti varianti:

• gemma2-2b-it-cpu-int8: modello Gemma-2 2B a 8 bit con compatibilità con la CPU.
• gemma2-2b-it-gpu-int8: modello Gemma-2 2B a 8 bit con compatibilità GPU.

Puoi anche ottimizzare il modello e aggiungere nuovi pesi prima di aggiungerlo all'app. Per maggiori informazioni sull'ottimizzazione e sulla personalizzazione di Gemma, consulta Ottimizzazione di Gemma. Dopo aver scaricato Gemma-2B da Kaggle Models, il modello è già nel formato appropriato per l'utilizzo con MediaPipe Tasks.

Gemma 2B

Gemma 2B fa parte di una famiglia di modelli aperti leggeri e all'avanguardia creati sulla base della stessa ricerca e tecnologia utilizzata per creare i modelli Gemini. Il modello contiene 2 miliardi di parametri e pesi aperti. Questo modello è adatto a una serie di attività di generazione di testo, tra cui risposta alle domande, riassunto e ragionamento.

Scarica Gemma 2B

I modelli Gemma 2B sono disponibili nelle seguenti varianti:

• gemma-2b-it-cpu-int4: modello Gemma 2B a 4 bit con compatibilità con la CPU.
• gemma-2b-it-cpu-int8: modello Gemma 2B a 8 bit con compatibilità con la CPU.
• gemma-2b-it-gpu-int4: modello Gemma 2B a 4 bit con compatibilità GPU.
• gemma-2b-it-gpu-int8: modello Gemma 2B a 8 bit con compatibilità GPU.

Puoi anche ottimizzare il modello e aggiungere nuovi pesi prima di aggiungerlo all'app. Per maggiori informazioni sull'ottimizzazione e sulla personalizzazione di Gemma, consulta Ottimizzazione di Gemma. Dopo aver scaricato Gemma 2B da Kaggle Models, il modello è già nel formato appropriato per l'utilizzo con MediaPipe Tasks.

Gemma 7B

Gemma 7B è un modello Gemma più grande con parametri di 7 miliardi e pesi aperti. Il modello è più efficace per una serie di attività di generazione di testo, tra cui risposta alle domande, riassunto e ragionamento. Gemma 7B è supportato solo sul web.

Scarica Gemma 7B

Il modello Gemma 7B è disponibile in una variante:

• gemma-1.1-7b-it-gpu-int8: modello Gemma 7B a 8 bit con compatibilità GPU.

Dopo aver scaricato Gemma 7B da Kaggle Models, il modello è già nel formato appropriato per l'utilizzo con MediaPipe.

Falcon 1B

Falcon-1B è un modello causale solo con decoder di 1 miliardo di parametri addestrato su 350 miliardi di token di RefinedWeb.

Scarica Falcon 1B

L'API LLM Inference richiede che i seguenti file vengano scaricati e archiviati localmente:

• tokenizer.json
• tokenizer_config.json
• pytorch_model.bin

Dopo aver scaricato i file del modello Falcon, il modello è pronto per essere convertito nel formato MediaPipe con uno script di conversione. Segui i passaggi descritti nella sezione Script di conversione per i modelli supportati.

StableLM 3B

StableLM-3B è un modello linguistico solo con decoder di 3 miliardi di parametri preaddestrato su 1 triliardo di token di diversi set di dati in inglese e codice per 4 epoche.

Scarica StableLM 3B

L'API LLM Inference richiede che i seguenti file vengano scaricati e archiviati localmente:

• tokenizer.json
• tokenizer_config.json
• model.safetensors

Dopo aver scaricato i file del modello StableLM, il modello è pronto per essere convertito nel formato MediaPipe con uno script di conversione. Segui i passaggi descritti nella sezione Script di conversione per i modelli supportati.

Phi-2

Phi-2 è un modello Transformer con 2,7 miliardi di parametri. È stato addestrato utilizzando vari testi sintetici di NLP e siti web filtrati. Il modello è più adatto per i prompt che utilizzano il formato di domanda e risposta, chat e codice.

Scarica Phi-2

L'API LLM Inference richiede che i seguenti file vengano scaricati e archiviati localmente:

• tokenizer.json
• tokenizer_config.json
• model-00001-of-00002.safetensors
• model-00002-of-00002.safetensors

Dopo aver scaricato i file del modello Phi-2, il modello è pronto per essere convertito nel formato MediaPipe con uno script di conversione. Segui i passaggi descritti nella sezione Script di conversione per i modelli supportati.

Modelli PyTorch generativi

I modelli generativi PyTorch possono essere convertiti in un formato compatibile con MediaPipe con l'API AI Edge Torch Generative. Puoi utilizzare l'API per convertire i modelli PyTorch in modelli LiteRT (TensorFlow Lite) con più firme. Per maggiori dettagli sulla mappatura ed esportazione dei modelli, consulta la pagina GitHub di AI Edge Torch.

Se intendi utilizzare l'API AI Edge Torch Generative per convertire un modello PyTorch, segui i passaggi descritti nella sezione Convertitore Torch Generative per i modelli PyTorch.

Conversione del modello

L'API MediaPipe LLM Inference ti consente di eseguire un'ampia gamma di modelli linguistici di grandi dimensioni (LLM) on-device. Sono inclusi i modelli che sono stati preconvertiti in un formato compatibile con MediaPipe, nonché altri modelli che possono essere convertiti con uno script di conversione o la libreria Torch per l'IA Edge.

L'API LLM Inference accetta modelli nei formati file .bin e .task. I modelli preconvertiti e quelli convertiti con lo script di conversione saranno file .bin, mentre i modelli convertiti con la libreria Torch per l'IA Edge saranno file .task. Non modificare manualmente i formati file dei modelli convertiti.

L'API LLM Inference contiene tre percorsi di conversione del modello:

• Modelli preconvertiti (Gemma 2B, Gemma 7B, Gemma-2 2B): nessuna conversione richiesta.
• Modelli supportati (Phi-2, StableLM, Falcon): script di conversione MediaPipe.
• Altri modelli PyTorch (tutti i modelli LLM PyTorch): API AI Edge Torch Generative.

Modelli preconvertiti

I modelli Gemma-2 2B, Gemma 2B e Gemma 7B sono disponibili come modelli pre-convertiti nel formato MediaPipe. Questi modelli non richiedono alcun passaggio di conversione aggiuntivo da parte dell'utente e possono essere eseguiti così come sono con l'API LLM Inference.

Puoi scaricare Gemma-2 2B da Modelli Kaggle:

• gemma2-2b-it-cpu-int8: modello Gemma-2 2B a 8 bit con compatibilità con la CPU.
• gemma2-2b-it-gpu-int8: modello Gemma-2 2B a 8 bit con compatibilità GPU.

Puoi scaricare le varianti di Gemma 2B da Kaggle Models:

• gemma-2b-it-cpu-int4: modello Gemma 2B a 4 bit con compatibilità con la CPU.
• gemma-2b-it-cpu-int8: modello Gemma 2B a 8 bit con compatibilità con la CPU.
• gemma-2b-it-gpu-int4: modello Gemma 2B a 4 bit con compatibilità GPU.
• gemma-2b-it-gpu-int8: modello Gemma 2B a 8 bit con compatibilità GPU.

Puoi scaricare Gemma 7B da Kaggle Models:

• gemma-1.1-7b-it-gpu-int8: modello Gemma 7B a 8 bit con compatibilità GPU.

Per ulteriori informazioni sui modelli Gemma, consulta la documentazione su Gemma-2 2B, Gemma 2B e Gemma 7B.

Script di conversione per i modelli supportati

Il pacchetto MediaPipe offre uno script di conversione per convertire i seguenti modelli esterni in un formato compatibile con MediaPipe:

• Falcon 1B
• StableLM 3B
• Phi-2

Per ulteriori informazioni sui modelli esterni supportati, consulta la documentazione su Falcon 1B, StableLM 3B e Phi-2.

Il processo di conversione del modello richiede il pacchetto MediaPipe PyPI. Lo script di conversione è disponibile in tutti i pacchetti MediaPipe dopo 0.10.11.

Installa e importa le dipendenze con quanto segue:

$ python3 -m pip install mediapipe

Utilizza la libreria genai.converter per convertire il modello:

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Per convertire il modello LoRA, ConversionConfig deve specificare le opzioni del modello di base nonché opzioni LoRA aggiuntive. Tieni presente che, poiché l'API supporta solo l'inferenza LoRa con GPU, il backend deve essere impostato su 'gpu'.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Il convertitore produrrà due file flatbuffer TFLite, uno per il modello di base e l'altro per il modello LoRA.

Torch Generative Converter per i modelli PyTorch

I modelli generativi PyTorch possono essere convertiti in un formato compatibile con MediaPipe con l'API AI Edge Torch Generative. Puoi utilizzare l'API per creare, convertire e quantizzare i modelli LLM di PyTorch da utilizzare con l'API di inferenza LLM. Il convertitore Torch Generative esegue la conversione solo per la CPU e richiede una macchina Linux con almeno 64 GB di RAM.

La conversione di un modello PyTorch con l'API AI Edge Torch Generative prevede quanto segue:

1. Scarica i checkpoint del modello PyTorch
2. Utilizza l'API AI Edge Torch Generative per creare, convertire e quantizzare il modello in un formato file compatibile con MediaPipe (.tflite).
3. Crea un Task Bundle (.task) dal file tflite e dal tokenizzatore del modello.

Per creare un Task Bundle, utilizza lo script di aggregazione per creare un Task Bundle. Il processo di raggruppamento pacchettizza il modello mappato con metadati aggiuntivi (ad es. Tokenizer Parameters) necessari per eseguire l'inferenza end-to-end.

La procedura di raggruppamento dei modelli richiede il pacchetto PyPI MediaPipe. Lo script di conversione è disponibile in tutti i pacchetti MediaPipe dopo 0.10.14.

Installa e importa le dipendenze con quanto segue:

$ python3 -m pip install mediapipe

Utilizza la libreria genai.bundler per raggruppare il modello:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Personalizzazione LoRA

Il supporto LoRA dell'API LLM Inference funziona per tutte le varianti di Gemma e per i modelli Phi-2 per il backend GPU, con i pesi LoRA applicabili solo ai livelli di attenzione. Questa implementazione iniziale funge da API sperimentale per sviluppi futuri, con piani per supportare più modelli e vari tipi di livelli nei prossimi aggiornamenti.

Prepara i modelli LoRA

Segui le istruzioni su HuggingFace per addestrare un modello LoRA ottimizzato sul tuo set di dati con i tipi di modelli supportati, Gemma o Phi-2. I modelli Gemma-2 2B, Gemma 2B e Phi-2 sono entrambi disponibili su HuggingFace nel formato safetensors. Poiché l'API LLM Inference supporta solo LoRA nei livelli di attenzione, specifica solo i livelli di attenzione durante la creazione di LoraConfig come segue:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Per i test, sono disponibili modelli LoRA ottimizzati e accessibili al pubblico che si adattano all'API di inferenza LLM su HuggingFace. Ad esempio, monsterapi/gemma-2b-lora-maths-orca-200k per Gemma-2B e lole25/phi-2-sft-ultrachat-lora per Phi-2.

Dopo l'addestramento sul set di dati preparato e il salvataggio del modello, ottieni un file adapter_model.safetensors contenente i pesi del modello LoRA perfezionato. Il file safetensors è il checkpoint LoRA utilizzato nella conversione del modello.

Come passaggio successivo, devi convertire i pesi del modello in un Flatbuffer di TensorFlow Lite utilizzando il pacchetto Python MediaPipe. ConversionConfig deve specificare le opzioni del modello di base e altre opzioni LoRa. Tieni presente che, poiché l'API supporta l'inferenza LoRa solo con GPU, il backend deve essere impostato su 'gpu'.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Il convertitore produrrà due file flatbuffer TFLite, uno per il modello di base e l'altro per il modello LoRA.

Inferenza del modello LoRA

L'API di inferenza LLM per web, Android e iOS è stata aggiornata per supportare l'inferenza del modello LoRA.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Per eseguire l'inferenza LLM con LoRA, utilizza gli stessi metodi generateResponse() o generateResponseAsync() del modello di base.