Ottimizza Falcon 7B e altri LLM su Amazon SageMaker con @remote decorator

Oggi, i modelli di intelligenza artificiale generativa coprono una varietà di attività, dal riepilogo del testo, alle domande e risposte e alla generazione di immagini e video. Per migliorare la qualità dell'output, vengono utilizzati approcci come n-short learning, Prompt engineering, Retrieval Augmented Generation (RAG) e fine tuning. La messa a punto ti consente di adattare questi modelli di intelligenza artificiale generativa per ottenere prestazioni migliori nelle attività specifiche del tuo dominio.

Con Amazon SageMaker, ora puoi eseguire un processo di formazione SageMaker semplicemente annotando il tuo codice Python con @remote decorator. IL SDK Python di SageMaker traduce automaticamente l'ambiente di lavoro esistente e qualsiasi codice di elaborazione dati e set di dati associati in un lavoro di formazione SageMaker eseguito sulla piattaforma di formazione. Ciò ha il vantaggio di scrivere il codice in un modo più naturale e orientato agli oggetti e utilizza comunque le funzionalità di SageMaker per eseguire processi di formazione su un cluster remoto con modifiche minime.

In questo post, mostriamo come ottimizzare a Falcon-7B Foundation Models (FM) utilizzando il decoratore @remote di SageMaker Python SDK. Utilizza anche Messa a punto efficiente dei parametri di Hugging Face (PEFT) libreria e tecniche di quantizzazione attraverso bitsandbytes per supportare la messa a punto. Il codice presentato in questo blog può essere utilizzato anche per mettere a punto altri FM, come Lama-2 13b.

Le rappresentazioni completamente precise di questo modello potrebbero avere difficoltà ad adattarsi alla memoria su uno o anche più Unità di elaborazione grafica (GPU) - o potrebbe anche aver bisogno di un'istanza più grande. Pertanto, per mettere a punto questo modello senza aumentare i costi, utilizziamo la tecnica nota come LLM quantizzati con adattatori di basso rango (QLoRA). QLoRA è un approccio efficiente di perfezionamento che riduce l'utilizzo della memoria degli LLM mantenendo prestazioni molto buone.

Vantaggi dell'utilizzo di @remote decorator

Prima di andare oltre, capiamo come il decoratore remoto migliora la produttività degli sviluppatori mentre lavora con SageMaker:

• @remote decorator attiva un processo di formazione direttamente utilizzando il codice Python nativo, senza l'invocazione esplicita di SageMaker Estimators e dei canali di input SageMaker
• Barriera bassa per l'ingresso per i modelli di formazione degli sviluppatori su SageMaker.
• Non è necessario cambiare Ambienti di sviluppo integrati (IDE). Continua a scrivere il codice nell'IDE che preferisci e richiama i processi di formazione di SageMaker.
• Non è necessario conoscere i contenitori. Continua a fornire le dipendenze in a requisiti.txt e fornirlo al decoratore remoto.

Prerequisiti

È necessario un account AWS con un ruolo AWS Identity and Access Management (AWS IAM) che disponga delle autorizzazioni per gestire le risorse create come parte della soluzione. Per i dettagli, fai riferimento a Creazione di un account AWS.

In questo post utilizziamo Amazon SageMaker Studio con il file Scienza dei dati 3.0 immagine e a ml.t3.medio istanza di avvio veloce. Tuttavia, puoi utilizzare qualsiasi ambiente di sviluppo integrato (IDE) di tua scelta. Devi solo configurare correttamente le credenziali dell'AWS Command Line Interface (AWS CLI). Per ulteriori informazioni, fai riferimento a Configurare AWS CLI.

Per la messa a punto, il Falcon-7B, an ml.g5,12xgrande l'istanza è utilizzata in questo post. Assicurati che la capacità dell'account AWS sia sufficiente per questa istanza.

Devi clonare questo Deposito Github per aver replicato la soluzione mostrata in questo post.

Panoramica della soluzione

1. Installa i prerequisiti per mettere a punto il modello Falcon-7B
2. Configura le configurazioni del decoratore remoto
3. Preelaborare il set di dati contenente le domande frequenti sui servizi AWS
4. Ottimizza Falcon-7B sulle domande frequenti sui servizi AWS
5. Testa i modelli di ottimizzazione su domande di esempio relative ai servizi AWS

1. Installare i prerequisiti per mettere a punto il modello Falcon-7B

Avvia il taccuino falcon-7b-qlora-remote-decorator_qa.ipynb in SageMaker Studio selezionando l'opzione Imago COME Scienza dei dati E Nocciolo COME Pitone 3. Installa tutte le librerie richieste menzionate nel file requisiti.txt. Alcune librerie devono essere installate sull'istanza del notebook stessa. Esegui altre operazioni necessarie per l'elaborazione del set di dati e l'attivazione di un processo di formazione SageMaker.

%pip installa -r requisiti.txt %pip installa -q -U trasformatori==4.31.0 %pip installa -q -U set di dati==2.13.1 %pip installa -q -U peft==0.4.0 %pip installa -q -U accelera ==0.21.0 %pip install -q -U bitsandbytes==0.40.2 %pip install -q -U boto3 %pip install -q -U sagemaker==2.154.0 %pip install -q -U scikit-learn

2. Configurare le configurazioni del decoratore remoto

Crea un file di configurazione in cui sono specificate tutte le configurazioni relative al processo di formazione di Amazon SageMaker. Questo file viene letto da @remote decorator durante l'esecuzione del processo di training. Questo file contiene impostazioni come dipendenze, immagine di training, istanza e ruolo di esecuzione da utilizzare per il processo di training. Per un riferimento dettagliato di tutte le impostazioni supportate dal file di configurazione, consulta Configurazione e utilizzo delle impostazioni predefinite con SageMaker Python SDK.

SchemaVersion: '1.0' SageMaker: PythonSDK: Moduli: RemoteFunction: Dipendenze: ./requirements.txt ImageUri: '{aws_account_id}.dkr.ecr.{region}.amazonaws.com/huggingface-pytorch-training:2.0.0-transformers4 .28.1-gpu-py310-cu118-ubuntu20.04' InstanceType: ml.g5.12xlarge RoleArn: arn:aws:iam::111122223333:role/ExampleSageMakerRole

Non è obbligatorio utilizzare il config.yaml file per poter lavorare con il decoratore @remote. Questo è semplicemente un modo più semplice per fornire tutte le configurazioni al decoratore @remote. Ciò mantiene i parametri relativi a SageMaker e AWS fuori dal codice con un unico sforzo per impostare il file di configurazione utilizzato da tutti i membri del team. Tutte le configurazioni potrebbero anche essere fornite direttamente negli argomenti del decoratore, ma ciò riduce la leggibilità e la manutenibilità delle modifiche a lungo termine. Inoltre, il file di configurazione può essere creato da un amministratore e condiviso con tutti gli utenti in un ambiente.

Preelaborare il set di dati contenente le domande frequenti sui servizi AWS

Il passaggio successivo consiste nel caricare e preelaborare il set di dati per renderlo pronto per il processo di training. Innanzitutto, diamo un'occhiata al set di dati:

Mostra le domande frequenti per uno dei servizi AWS. Oltre a QLoRA, bitsanbytes viene utilizzato per convertire in precisione a 4 bit per quantizzare LLM congelato in 4 bit e allegarlo LoRA adattatori su di esso.

Crea un modello di prompt per convertire ogni esempio di domande frequenti in un formato di prompt:

da importazione casuale randint # istruzione personalizzata prompt avvia prompt_template = f"{{question}}\n---\nRisposta:\n{{answer}}{{eos_token}}" # template dataset per aggiungere prompt a ciascun campione def template_dataset (esempio): esempio["testo"] = prompt_template.format(domanda=esempio["domanda"], risposta=esempio["risposte"], eos_token=tokenizer.eos_token) restituire esempio

Il passaggio successivo consiste nel convertire gli input (testo) in ID token. Questo viene fatto da a Tokenizer di Transformers con il volto abbracciato.

from Transformers import AutoTokenizer model_id = "tiiuae/falcon-7b" tokenizer = AutoTokenizer.from_pretrained(model_id) # Imposta il tokenizer Falcon tokenizer.pad_token = tokenizer.eos_token

Ora usa semplicemente il file modello_prompt funzione per convertire tutte le domande frequenti nel formato prompt e impostare il training e il test dei set di dati.

4. Ottimizzare Falcon-7B sulle domande frequenti sui servizi AWS

Ora puoi preparare lo script di allenamento e definire la funzione di allenamento treno_fn e inserisci @remote decorator nella funzione.

La funzione di formazione effettua le seguenti operazioni:

• tokenizza e suddivide in blocchi il set di dati
• impostare BitsAndBytesConfig, che specifica che il modello deve essere caricato a 4 bit ma mentre il calcolo deve essere convertito in bfloat16.
• Carica il modello
• Trova i moduli di destinazione e aggiorna le matrici necessarie utilizzando il metodo di utilità trova_tutti_nomi_lineari
• Creare LoRA configurazioni che specificano la classificazione delle matrici di aggiornamento (S), fattore di scala (lora_alpha), i moduli per applicare le matrici di aggiornamento LoRA (target_modules), probabilità di abbandono per gli strati Lora(lora_dropout), tipo_attività, eccetera.
• Avviare la formazione e la valutazione

import bitsandbytes as bnb

def find_all_linear_names(hf_model):
    lora_module_names = set()
    for name, module in hf_model.named_modules():
        if isinstance(module, bnb.nn.Linear4bit):
            names = name.split(".")
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])

    if "lm_head" in lora_module_names:
        lora_module_names.remove("lm_head")
    return list(lora_module_names)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from sagemaker.remote_function import remote
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import transformers

# Start training
@remote(volume_size=50)
def train_fn(
        model_name,
        train_ds,
        test_ds,
        lora_r=8,
        lora_alpha=32,
        lora_dropout=0.05,
        per_device_train_batch_size=8,
        per_device_eval_batch_size=8,
        learning_rate=2e-4,
        num_train_epochs=1
):
    # tokenize and chunk dataset
    lm_train_dataset = train_ds.map(
        lambda sample: tokenizer(sample["text"]), batched=True, batch_size=24, remove_columns=list(train_dataset.features)
    )


    lm_test_dataset = test_ds.map(
        lambda sample: tokenizer(sample["text"]), batched=True, remove_columns=list(test_dataset.features)
    )

    # Print total number of samples
    print(f"Total number of train samples: {len(lm_train_dataset)}")

    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_use_double_quant=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.bfloat16
    )
    # Falcon requires you to allow remote code execution. This is because the model uses a new architecture that is not part of transformers yet.
    # The code is provided by the model authors in the repo.
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        trust_remote_code=True,
        quantization_config=bnb_config,
        device_map="auto")

    model.gradient_checkpointing_enable()
    model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)

    # get lora target modules
    modules = find_all_linear_names(model)
    print(f"Found {len(modules)} modules to quantize: {modules}")

    config = LoraConfig(
        r=lora_r,
        lora_alpha=lora_alpha,
        target_modules=modules,
        lora_dropout=lora_dropout,
        bias="none",
        task_type="CAUSAL_LM"
    )

    model = get_peft_model(model, config)
    print_trainable_parameters(model)

    trainer = transformers.Trainer(
        model=model,
        train_dataset=lm_train_dataset,
        eval_dataset=lm_test_dataset,
        args=transformers.TrainingArguments(
            per_device_train_batch_size=per_device_train_batch_size,
            per_device_eval_batch_size=per_device_eval_batch_size,
            logging_steps=2,
            num_train_epochs=num_train_epochs,
            learning_rate=learning_rate,
            bf16=True,
            save_strategy="no",
            output_dir="outputs"
        ),
        data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
    )
    model.config.use_cache = False

    trainer.train()
    trainer.evaluate()

    model.save_pretrained("/opt/ml/model")

E invocare il treno_fn()

train_fn(model_id, train_dataset, test_dataset)

Il processo di ottimizzazione verrà eseguito sul cluster di formazione Amazon SageMaker. Attendi il completamento del lavoro di ottimizzazione.

5. Testare i modelli di messa a punto su domande di esempio relative ai servizi AWS

Ora è il momento di eseguire alcuni test sul modello. Per prima cosa carichiamo il modello:

da peft import PeftModel, PeftConfig importa torcia da trasformatori import AutoModelForCausalLM device="cuda" if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu' config = PeftConfig.from_pretrained(" ./model") modello = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, trust_remote_code=True) modello = PeftModel.from_pretrained(model, "./model") model.to(dispositivo)

Ora carica una domanda di esempio dal set di dati di addestramento per vedere la risposta originale, quindi poni la stessa domanda dal modello ottimizzato per vedere la risposta a confronto.

Ecco un esempio di domanda dal set di formazione e la risposta originale:

Ora, la stessa domanda viene posta per mettere a punto il modello Falcon-7B:

Ciò conclude l'implementazione della messa a punto di Falcon-7B sul set di dati delle domande frequenti sui servizi AWS utilizzando il decoratore @remote dell'SDK Python di Amazon SageMaker.

Pulire

Completa i seguenti passaggi per ripulire le tue risorse:

• Arresta le istanze di Amazon SageMaker Studio per evitare di incorrere in costi aggiuntivi.
• Pulisci la directory Amazon Elastic File System (Amazon EFS) cancellando la directory della cache di Hugging Face:

  rm -R ~/.cache/huggingface/hub

Conclusione

In questo post, ti abbiamo mostrato come utilizzare in modo efficace le capacità del decoratore @remote per mettere a punto il modello Falcon-7B utilizzando QLoRA, Hugging Face PEFT con bitsandbtyes senza applicare modifiche significative nel notebook di formazione e ha utilizzato le funzionalità di Amazon SageMaker per eseguire processi di formazione su un cluster remoto.

Tutto il codice mostrato come parte di questo post per mettere a punto Falcon-7B è disponibile nel file Repositorio GitHub. Il repository contiene anche un taccuino che mostra come mettere a punto Llama-13B.

Come passaggio successivo, ti invitiamo a verificare la funzionalità @remote decorator e API dell'SDK Python e utilizzalo nell'ambiente e nell'IDE che preferisci. Ulteriori esempi sono disponibili in amazon-sagemaker-esempi repository per iniziare rapidamente. Puoi anche consultare i seguenti post:

Riguardo agli Autori

Bruno Pistone è un AI/ML Specialist Solutions Architect per AWS con sede a Milano. Lavora con grandi clienti aiutandoli a comprendere a fondo le loro esigenze tecniche e a progettare soluzioni di intelligenza artificiale e machine learning che sfruttano al meglio il cloud AWS e lo stack Amazon Machine Learning. Le sue competenze includono: machine learning end-to-end, industrializzazione del machine learning e intelligenza artificiale generativa. Gli piace passare il tempo con i suoi amici ed esplorare nuovi posti, oltre a viaggiare verso nuove destinazioni.

Vikesh Pandey è un Machine Learning Specialist Solutions Architect presso AWS, aiuta i clienti dei settori finanziari a progettare e realizzare soluzioni su AI generativa e ML. Al di fuori del lavoro, a Vikesh piace provare diverse cucine e praticare sport all'aria aperta.