Operazionalizzare la valutazione di LLM su larga scala utilizzando i servizi Amazon SageMaker Clarify e MLOps

Implementare l'analisi di LLM su larga scala con l'ausilio dei servizi Amazon SageMaker Clarify e MLOps

Negli ultimi anni, i Large Language Models (LLM) hanno guadagnato importanza come strumenti eccezionali capaci di comprendere, generare e manipolare testo con una competenza senza precedenti. Le loro potenziali applicazioni spaziano dagli agenti di conversazione alla generazione di contenuti e al recupero delle informazioni, promettendo di rivoluzionare tutte le industrie. Tuttavia, sfruttare questo potenziale garantendo nel contempo un uso responsabile ed efficace di questi modelli è strettamente legato al processo critico di valutazione degli LLM. Una valutazione è un’operazione utilizzata per misurare la qualità e la responsabilità delle uscite di un LLM o di un servizio generativo di IA. Valutare gli LLM non è solo motivato dal desiderio di comprendere le prestazioni di un modello, ma anche dalla necessità di implementare l’IA responsabile e di mitigare il rischio di fornire informazioni errate o contenuti parziali e di minimizzare la generazione di contenuti dannosi, non sicuri, maliziosi ed eticamente discutibili. Inoltre, valutare gli LLM può aiutare a mitigare i rischi di sicurezza, in particolare nel contesto della manipolazione illegale dei dati di input. Per le applicazioni basate su LLM, è fondamentale identificare le vulnerabilità e implementare garanzie che proteggano da eventuali violazioni e manipolazioni non autorizzate dei dati.

Fornendo strumenti essenziali per la valutazione degli LLM con una configurazione semplice e un approccio “one-click”, Amazon SageMaker Clarify offre ai clienti accesso alla maggior parte dei benefici sopra menzionati. Con questi strumenti a disposizione, la sfida successiva consiste nell’integrare la valutazione degli LLM nel ciclo di vita del Machine Learning e delle Operazioni (MLOps) per ottenere l’automazione e la scalabilità del processo. In questo post, ti mostreremo come integrare la valutazione degli LLM di Amazon SageMaker Clarify con Amazon SageMaker Pipelines per consentire la valutazione degli LLM su larga scala. Inoltre, forniamo un esempio di codice in questo repository GitHub per consentire agli utenti di effettuare valutazioni parallele su più modelli su larga scala, utilizzando esempi come i modelli Llama2-7b-f, Falcon-7b e Llama2-7b sintonizzati.

Chi ha bisogno di effettuare la valutazione degli LLM?

Chiunque addestri, sintonizzi o semplicemente utilizzi un LLM preaddestrato ha bisogno di valutarlo accuratamente per valutare il comportamento dell’applicazione alimentata da quel LLM. Sulla base di questo principio, possiamo classificare gli utenti di IA generativa che necessitano di capacità di valutazione degli LLM in 3 gruppi come mostrato nella figura seguente: fornitori di modelli, sintonizzatori e fruitori.

• Evitare il sovradattamento nelle reti neurali un approfondimento
• Accelerare la preparazione dei dati per ML in Amazon SageMaker Canvas
• Accelerare l’addestramento dei modelli di deep learning fino al 35% con l’utilizzo di Amazon SageMaker e il suo smart sifting

• I fornitori dei modelli fondamentali (FM) formano modelli che sono a uso generale. Questi modelli possono essere utilizzati per molteplici compiti successivi, come l’estrazione delle caratteristiche o la generazione dei contenuti. Ogni modello addestrato deve essere confrontato con molti compiti, non solo per valutarne le prestazioni, ma anche per confrontarlo con altri modelli esistenti, identificare le aree che necessitano di miglioramenti e infine monitorare i progressi nel campo. I fornitori dei modelli devono inoltre verificare la presenza di eventuali pregiudizi per garantire la qualità del dataset di partenza e il corretto comportamento del loro modello. Raccogliere dati di valutazione è vitale per i fornitori dei modelli. Inoltre, questi dati e le metriche devono essere raccolti per conformarsi alle future normative. ISO 42001, l’Ordine esecutivo dell’amministrazione Biden e il EU AI Act sviluppano standard, strumenti e test per garantire che i sistemi di intelligenza artificiale siano sicuri, protetti e affidabili. Ad esempio, l’EU AI Act ha il compito di fornire informazioni sui dataset utilizzati per l’addestramento, sulla potenza di calcolo necessaria per eseguire il modello, di fornire risultati del modello rispetto a benchmark pubblici o standard del settore e di condividere i risultati dei test interni ed esterni.
• I sintonizzatori dei modelli desiderano risolvere compiti specifici (ad esempio classificazione dei sentimenti, riassunto, risposta alle domande) nonché utilizzare modelli preaddestrati per adattarsi a compiti specifici di dominio. Hanno bisogno di metriche di valutazione generate dai fornitori dei modelli per selezionare il modello preaddestrato più adatto come punto di partenza. Devono valutare i loro modelli sintonizzati rispetto al caso d’uso desiderato con dataset specifici per il compito o il dominio. Spesso, devono curare e creare i propri dataset privati poiché i dataset disponibili pubblicamente, anche quelli progettati per un compito specifico, potrebbero non essere adeguati per catturare le sfumature richieste per il loro caso d’uso specifico. La sintonizzazione è più veloce ed economica rispetto ad un addestramento completo e richiede iterazioni operative più rapide per il rilascio e il testing, poiché di solito vengono generati molti modelli candidati. Valutare questi modelli consente un miglioramento continuo del modello, la calibrazione e il debugging. Si noti che i sintonizzatori possono diventare fruitori dei propri modelli quando sviluppano applicazioni nel mondo reale.
• Le fruizioni dei modelli o i distribuenti dei modelli servono e monitorano modelli a uso generale o sintonizzati in produzione, con l’obiettivo di migliorare le proprie applicazioni o servizi tramite l’adozione di LLM. La prima sfida che devono affrontare è assicurarsi che il LLM scelto sia in linea con le loro esigenze specifiche, il costo e le aspettative di prestazioni. Interpretare e comprendere le uscite del modello è una preoccupazione persistente, soprattutto quando sono coinvolte privacy e sicurezza dei dati (ad esempio per l’audit del rischio e della conformità nelle industrie regolamentate, come il settore finanziario). La valutazione continua del modello è essenziale per prevenire la propagazione di pregiudizi o contenuti dannosi. Attraverso l’implementazione di un solido framework di monitoraggio e valutazione, i fruitori dei modelli possono identificare e affrontare in modo proattivo la regressione negli LLM, garantendo che questi modelli mantengano nel tempo la loro efficacia e affidabilità.

Come eseguire la valutazione LLM

Una valutazione efficace del modello comporta tre componenti fondamentali: uno o più FM o modelli tarati per valutare i set di dati di input (prompts, conversazioni o input regolari) e la logica di valutazione.

Per selezionare i modelli per la valutazione, è necessario considerare diversi fattori, tra cui le caratteristiche dei dati, la complessità del problema, le risorse computazionali disponibili e l’obiettivo desiderato. Il datastore di input fornisce i dati necessari per formare, tarare e testare il modello selezionato. È fondamentale che questo datastore sia ben strutturato, rappresentativo e di alta qualità, poiché le prestazioni del modello dipendono fortemente dai dati da cui apprende. Infine, le logiche di valutazione definiscono i criteri e le metriche utilizzate per valutare le prestazioni del modello.

Insieme, questi tre componenti formano un quadro coerente che garantisce una valutazione rigorosa e sistematica dei modelli di apprendimento automatico, portando infine a decisioni informate e miglioramenti dell’efficacia del modello.

Le tecniche di valutazione dei modelli sono ancora un campo di ricerca attivo. Negli ultimi anni la comunità di ricercatori ha creato molti benchmark pubblici e framework per coprire una vasta gamma di compiti e scenari come GLUE, SuperGLUE, HELM, MMLU e BIG-bench. Questi benchmark hanno delle classifiche che possono essere utilizzate per confrontare e confrontare modelli valutati. I benchmark, come HELM, mirano anche a valutare metriche oltre alle misure di precisione, come la precisione o lo score F1. Il benchmark HELM include metriche per equità, bias e tossicità, che hanno un’importanza altrettanto significativa nel punteggio complessivo della valutazione del modello.

Tutti questi benchmark includono un set di metriche che misurano le prestazioni del modello su un determinato compito. Le metriche più famose e comuni sono ROUGE (Recall-Oriented Understudy for Gisting Evaluation), BLEU (BiLingual Evaluation Understudy) o METEOR (Metric for Evaluation of Translation with Explicit ORdering). Queste metriche servono come strumento utile per la valutazione automatizzata, fornendo misure quantitative di somiglianza lessicale tra il testo generato e il testo di riferimento. Tuttavia, non catturano tutta l’ampiezza della generazione di linguaggio simile all’essere umano, che include la comprensione semantica, il contesto o le sfumature stilistiche. Ad esempio, HELM non fornisce dettagli di valutazione pertinenti a casi d’uso specifici, soluzioni per testare prompt personalizzati e risultati facilmente interpretati utilizzati da non esperti, perché il processo può essere costoso, difficile da scalare e limitato a compiti specifici.

Inoltre, per raggiungere una generazione di linguaggio simile all’essere umano, spesso è necessario incorporare l’interazione umana per fornire valutazioni qualitative e giudizi umani a complemento delle metriche di accuratezza automatizzate. La valutazione umana è un metodo prezioso per valutare gli output LLM, ma può anche essere soggettiva e soggetta a bias perché diversi valutatori umani possono avere opinioni e interpretazioni diverse della qualità del testo. Inoltre, la valutazione umana può essere intensiva in termini di risorse e costosa e può richiedere tempo ed impegno significativi.

Approfondiamo come Amazon SageMaker Clarify collega in modo fluido i punti, aiutando i clienti a condurre una valutazione e selezione completa del modello.

Valutazione LLM con Amazon SageMaker Clarify

Amazon SageMaker Clarify aiuta i clienti ad automatizzare le metriche, comprese ma non limitate alla precisione, robustezza, tossicità, stereotipazione e conoscenza fattuale per la valutazione automatica e lo stile, la coerenza, la rilevanza per la valutazione basata sull’essere umano e i metodi di valutazione fornendo un framework per valutare LLM e servizi basati su LLM come Amazon Bedrock. Come servizio completamente gestito, SageMaker Clarify semplifica l’utilizzo dei framework di valutazione open-source in Amazon SageMaker. I clienti possono selezionare set di dati di valutazione rilevanti e metriche per i loro scenari ed estenderli con i propri set di dati di prompt e algoritmi di valutazione. SageMaker Clarify fornisce risultati di valutazione in diversi formati per supportare ruoli diversi nel flusso di lavoro LLM. I data scientist possono analizzare i risultati dettagliati con le visualizzazioni di SageMaker Clarify in Notebooks, le schede dei modelli di SageMaker e i report in formato PDF. Nel frattempo, i team operativi possono utilizzare Amazon SageMaker GroundTruth per rivedere e annotare gli elementi ad alto rischio identificati da SageMaker Clarify. Ad esempio, identificando stereotipi, tossicità, PII sfuggiti o bassa accuratezza.

Le annotazioni e l’apprendimento di rinforzo vengono successivamente impiegati per mitigare i potenziali rischi. Spiegazioni descrittive dei rischi identificati accelerano il processo di revisione manuale, riducendo così i costi. I rapporti di sintesi offrono indicatori di confronto tra modelli e versioni diversi ai dirigenti aziendali, facilitando la presa di decisioni informate.

La figura seguente mostra il framework per valutare LLM e servizi basati su LLM:

La valutazione di Amazon SageMaker Clarify LLM è una libreria Foundation Model Evaluation (FMEval) open-source sviluppata da AWS per aiutare i clienti a valutare facilmente LLM. Tutte le funzionalità sono state anche incorporate in Amazon SageMaker Studio per consentire la valutazione di LLM per i suoi utenti. Nelle seguenti sezioni, presentiamo l’integrazione delle capacità di valutazione di Amazon SageMaker Clarify LLM con SageMaker Pipelines per consentire la valutazione di LLM su larga scala utilizzando i principi di MLOps.

Ciclo di vita di Amazon SageMaker MLOps

Come descritto nell’articolo “MLOps foundation roadmap for enterprises with Amazon SageMaker”, MLOps è la combinazione di processi, persone e tecnologia per produrre casi d’uso di ML in modo efficiente.

La figura seguente mostra il ciclo di vita end-to-end di MLOps:

Un percorso tipico inizia con un data scientist che crea un notebook di prova concettuale (PoC) per dimostrare che l’IA può risolvere un problema aziendale. Durante lo sviluppo del Proof of Concept (PoC), il data scientist deve convertire gli Indicatori Chiave di Prestazione (KPI) aziendali in metriche di modelli di apprendimento automatico, come la precisione o il tasso di falsi positivi, e utilizzare un set di dati di test limitato per valutare queste metriche. I data scientist collaborano con gli ingegneri di apprendimento automatico per trasferire il codice dai notebook ai repository, creando pipeline di apprendimento automatico utilizzando Amazon SageMaker Pipelines, che collegano vari passaggi di elaborazione e attività, inclusi preelaborazione, addestramento, valutazione e post-elaborazione, tutto continuando a incorporare nuovi dati di produzione. Il deployment di Amazon SageMaker Pipelines si basa sulle interazioni con il repository e sull’attivazione della pipeline CI/CD. La pipeline di apprendimento automatico mantiene i modelli più performanti, le immagini dei contenitori, i risultati delle valutazioni e le informazioni sullo stato in un registro dei modelli, dove gli stakeholder dei modelli valutano le prestazioni e decidono la progressione verso la produzione basandosi sui risultati delle prestazioni e sui benchmark, seguiti dall’attivazione di un’altra pipeline CI/CD per lo staging e il deployment in produzione. Una volta in produzione, i consumatori di IA utilizzano il modello tramite inferenza innescata dall’applicazione tramite invocazione diretta o chiamate API, con ciclo di feedback verso i proprietari del modello per una valutazione continua delle prestazioni.

Integrazione di Amazon SageMaker Clarify e MLOps

Seguendo il ciclo di vita di MLOps, i perfezionatori o gli utenti dei modelli open-source producono modelli perfezionati o FM utilizzando Amazon SageMaker Jumpstart e servizi MLOps, come descritto in Implementare pratiche di MLOps con modelli pre-addestrati di Amazon SageMaker JumpStart. Questo porta a un nuovo dominio per le operazioni dei modelli di base (FMOps) e le operazioni LLM (LLMOps) FMOps/LLMOps: Operationalize generative AI e differenze con MLOps.

La figura seguente mostra il ciclo di vita LLMOps end-to-end:

In LLMOps le principali differenze rispetto a MLOps sono la selezione del modello e la valutazione del modello che coinvolgono processi e metriche diverse. Nella fase iniziale di sperimentazione, i data scientist (o i perfezionatori) selezionano il FM che verrà utilizzato per un caso d’uso specifico di Generative AI. Questo spesso comporta la prova e la messa a punto di vari FM, alcuni dei quali possono fornire risultati comparabili. Dopo la selezione del/i modello/i, gli ingegneri delle richieste sono responsabili della preparazione dei dati di input necessari e degli output attesi per la valutazione (ad es. richieste di input che comprendono dati di input e query) e definiscono metriche come somiglianza e tossicità. Oltre a tali metriche, i data scientist o i perfezionatori devono convalidare i risultati e scegliere l’FM appropriato non solo in base alle metriche di precisione, ma anche ad altre capacità come latenza e costo. Quindi, possono distribuire un modello su un endpoint di SageMaker e testarne le prestazioni su piccola scala. Sebbene la fase di sperimentazione possa comportare un processo semplice, la transizione alla produzione richiede ai clienti di automatizzare il processo e migliorare la robustezza della soluzione. Pertanto, è necessario approfondire come automatizzare la valutazione, consentendo ai tester di effettuare una valutazione efficiente su larga scala e implementare il monitoraggio in tempo reale degli input e degli output del modello.

Automatizza la valutazione FM

Amazon SageMaker Pipelines automatizza tutte le fasi di pre-elaborazione, messa a punto FM (opzionalmente) e valutazione su larga scala. Dati i modelli selezionati durante l’esperimento, gli ingegneri del prompt devono coprire un set più ampio di casi preparando molti prompt e archiviandoli in un repository di archiviazione designato chiamato catalogo dei prompt. Per ulteriori informazioni, consulta FMOps/LLMOps: Operazionalizzare l’IA generativa e differenze con MLOps. Quindi, Amazon SageMaker Pipelines può essere strutturato come segue:

Scenario 1 – Valutazione di più FM: In questo scenario, le FM possono coprire il caso d’uso aziendale senza messa a punto. Il flusso di lavoro di Amazon SageMaker è composto dai seguenti passaggi: pre-elaborazione dei dati, valutazione parallela di più FM, confronto dei modelli e selezione in base all’accuratezza e altre proprietà come costo o latenza, registrazione degli artefatti del modello selezionato e dei metadati.

Il diagramma seguente illustra questa architettura.

Scenario 2 – Messa a punto e valutazione di più FM: In questo scenario, il flusso di lavoro di Amazon SageMaker è strutturato in modo simile allo Scenario 1, ma esegue in parallelo sia la messa a punto che i passaggi di valutazione per ciascuna FM. Il miglior modello messo a punto sarà registrato nel Model Registry.

Il diagramma seguente illustra questa architettura.

Scenario 3 – Valutazione di più FM e FM messi a punto: Questo scenario è una combinazione di valutazione di FM a uso generale e FM messi a punto. In questo caso, i clienti vogliono verificare se un modello messo a punto può funzionare meglio di una FM a uso generale.

La figura seguente mostra i passaggi risultanti di SageMaker Pipeline.

Si noti che la registrazione del modello segue due modelli: (a) archivia un modello e artefatti open source o (b) archivia un riferimento a una FM proprietaria. Per ulteriori informazioni, consulta FMOps/LLMOps: Operazionalizzare l’IA generativa e differenze con MLOps.

Panoramica della soluzione

Per accelerare il tuo percorso verso la valutazione di LLM su larga scala, abbiamo creato una soluzione che implementa gli scenari utilizzando sia Amazon SageMaker Clarify che il nuovo Amazon SageMaker Pipelines SDK. L’esempio di codice, compresi i set di dati, i notebook di origine e le SageMaker Pipelines (passaggi e pipeline di ML), è disponibile su GitHub. Per sviluppare questa soluzione di esempio, abbiamo utilizzato due FM: Llama2 e Falcon-7B. In questo post, il nostro focus principale è sugli elementi chiave della soluzione SageMaker Pipeline che riguardano il processo di valutazione.

Configurazione della valutazione: Al fine di standardizzare la procedura di valutazione, abbiamo creato un file di configurazione YAML (evaluation_config.yaml) che contiene i dettagli necessari per il processo di valutazione, inclusi il set di dati, il/i modello/i e gli algoritmi da eseguire durante il passaggio di valutazione di SageMaker Pipeline. L’esempio seguente illustra il file di configurazione:

pipeline:    name: "llm-evaluation-multi-models-hybrid"dataset:    dataset_name: "trivia_qa_sampled"    input_data_location: "evaluation_dataset_trivia.jsonl"    dataset_mime_type: "jsonlines"    model_input_key: "question"    target_output_key: "answer"models:  - name: "llama2-7b-f"    model_id: "meta-textgeneration-llama-2-7b-f"    model_version: "*"    endpoint_name: "llm-eval-meta-textgeneration-llama-2-7b-f"    deployment_config:      instance_type: "ml.g5.2xlarge"      num_instances: 1    evaluation_config:      output: '[0].generation.content'      content_template: [[{"role":"user", "content": "PROMPT_PLACEHOLDER"}]]      inference_parameters:         max_new_tokens: 100        top_p: 0.9        temperature: 0.6      custom_attributes:        accept_eula: True      prompt_template: "$feature"    cleanup_endpoint: True  - name: "falcon-7b"    ...  - name: "llama2-7b-finetuned"    ...    finetuning:      train_data_path: "train_dataset"      validation_data_path: "val_dataset"      parameters:        instance_type: "ml.g5.12xlarge"        num_instances: 1        epoch: 1        max_input_length: 100        instruction_tuned: True        chat_dataset: False    ...algorithms:  - algorithm: "FactualKnowledge"     module: "fmeval.eval_algorithms.factual_knowledge"    config: "FactualKnowledgeConfig"    target_output_delimiter: "<OR>"

Passaggio di valutazione: Il nuovo SDK di SageMaker Pipeline offre agli utenti la flessibilità di definire passaggi personalizzati nel flusso di lavoro di machine learning utilizzando il decoratore Python ‘@step’. Pertanto, gli utenti devono creare uno script Python di base che esegue la valutazione, come segue:

def valutazione(percorso_data_s3, nome_endpoint, config_data, config_modello, config_algoritmo, percorso_dati_output,):
   from fmeval.data_loaders.data_config import DataConfig
   from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner
   from fmeval.reporting.eval_output_cells import EvalOutputCell
   from fmeval.constants import MIME_TYPE_JSONLINES
   s3 = boto3.client("s3")
   bucket, chiave_oggetto = parse_s3_url(percorso_data_s3)
   s3.download_file(bucket, chiave_oggetto, "dataset.jsonl")
   config = DataConfig(
       dataset_name = config_data["nome_dataset"],
       dataset_uri = "dataset.jsonl",
       dataset_mime_type = MIME_TYPE_JSONLINES,
       model_input_location = config_data["model_input_key"],
       target_output_location = config_data["target_output_key"],
   )
   evaluation_config = config_modello["evaluation_config"]
   content_dict = {
       "inputs": evaluation_config["content_template"],
       "parameters": evaluation_config["inference_parameters"],
   }
   serializer = JSONSerializer()
   dati_serializzati = serializer.serialize(content_dict)
   content_template = dati_serializzati.replace('"PROMPT_PLACEHOLDER"', "$prompt")
   print(content_template)
   js_model_runner = JumpStartModelRunner(
       endpoint_name = nome_endpoint,
       model_id = config_modello["model_id"],
       model_version = config_modello["model_version"],
       output = evaluation_config["output"],
       content_template = content_template,
       custom_attributes = "accept_eula=true",
   )
   eval_output_all = []
   s3 = boto3.resource("s3")
   output_bucket, output_index = parse_s3_url(percorso_dati_output)
   for algoritmo in config_algoritmo:
       nome_algoritmo = algoritmo["algoritmo"]
       modulo = importlib.import_module(algoritmo["modulo"])
       classe_algoritmo = getattr(modulo, nome_algoritmo)
       classe_config_algoritmo = getattr(modulo, algoritmo["config"])
       eval_algo = classe_algoritmo(classe_config_algoritmo(target_output_delimiter=algoritmo["target_output_delimiter"]))
       eval_output = eval_algo.evaluate(model=js_model_runner, dataset_config=config, prompt_template=evaluation_config["prompt_template"], save=True,)
       print(f"eval_output: {eval_output}")
       eval_output_all.append(eval_output)
       html = markdown.markdown(str(EvalOutputCell(eval_output[0])))
       file_index = (output_index + "/" + config_modello["nome"] + "_" + eval_algo.eval_name + ".html")
       s3_object = s3.Object(bucket_name = output_bucket, key = file_index)
       s3_object.put(Body = html)
   eval_result = {"config_modello": config_modello, "eval_output": eval_output_all}
   print(f"eval_result: {eval_result}")
   return eval_result

SageMaker Pipeline: Dopo aver creato i passaggi necessari, come la pre-elaborazione dei dati, il deployment del modello e la valutazione del modello, l’utente deve collegare i passaggi utilizzando SageMaker Pipeline SDK. Il nuovo SDK genera automaticamente il flusso di lavoro interpretando le dipendenze tra i diversi passaggi quando viene invocata l’API di creazione della pipeline di SageMaker, come mostrato nell’esempio seguente:

import os
import argparse
from datetime import datetime
import sagemaker
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.function_step import step
from sagemaker.workflow.step_outputs import get_step
# Importare i passaggi necessari
from steps.preprocess import preprocess
from steps.evaluation import valutazione
from steps.cleanup import cleanup
from steps.deploy import deploy
from lib.utils import ConfigParser
from lib.utils import find_model_by_name

if __name__ == "__main__":
    os.environ["SAGEMAKER_USER_CONFIG_OVERRIDE"] = os.getcwd()
    sagemaker_session = sagemaker.session.Session()
    # Definire la posizione dei dati, fornendola come argomento o utilizzando il bucket predefinito
    default_bucket = sagemaker.Session().default_bucket()
    parser = argparse.ArgumentParser()
    parser.add_argument("-input-data-path", "--input-data-path", dest="input_data_path", default=f"s3://{default_bucket}/llm-evaluation-at-scale-example", help="Il percorso S3 dei dati di input",)
    parser.add_argument("-config", "--config", dest="config", default="", help="Il percorso al file di configurazione .yaml",)
    args = parser.parse_args()
    # Inizializzare la configurazione dei dati, del modello e dell'algoritmo
    if args.config:
        config = ConfigParser(args.config).get_config()
    else:
        config = ConfigParser("pipeline_config.yaml").get_config()
    evalaution_exec_id = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
    pipeline_name = config["pipeline"]["nome"]
    dataset_config = config["dataset"]  # Ottenere la configurazione del dataset
    input_data_path = args.input_data_path + "/" + dataset_config["percorso_dati_input"]
    output_data_path = (args.input_data_path + "/output_" + pipeline_name + "_" + evalaution_exec_id)
    print("Posizione input dati:", input_data_path)
    print("Posizione output dati:", output_data_path)
    config_algoritmi = config["algoritmi"]  # Ottenere la configurazione degli algoritmi
    config_modello = find_model_by_name(config["modelli"], "llama2-7b")
    model_id = config_modello["model_id"]
    model_version = config_modello["model_version"]
    evaluation_config = config_modello["evaluation_config"]
    nome_endpoint = config_modello["nome_endpoint"]
    model_deploy_config = config_modello["deployment_config"]
    deploy_instance_type = model_deploy_config["instance_type"]
    deploy_num_instances = model_deploy_config["num_instances"]
    # Costruire i passaggi
    processed_data_path = step(preprocess, nome="preprocess")(input_data_path, output_data_path)
    endpoint_name = step(deploy, nome=f"deploy_{model_id}")(model_id, model_version, endpoint_name, deploy_instance_type, deploy_num_instances,)
    evaluation_results = step(valutazione, nome=f"evaluation_{model_id}", keep_alive_period_in_seconds=1200)(processed_data_path, endpoint_name, dataset_config, config_modello, config_algoritmi, output_data_path,)
    last_pipeline_step = evaluation_results
    if config_modello["cleanup_endpoint"]:
        cleanup = step(cleanup, nome=f"cleanup_{model_id}")(model_id, endpoint_name)
        get_step(cleanup).add_depends_on([evaluation_results])
        last_pipeline_step = cleanup
    # Definire SageMaker Pipeline
    pipeline = Pipeline(
        nome=pipeline_name,
        steps=[last_pipeline_step],
    )
    # Creare ed eseguire la SageMaker Pipeline
    pipeline.upsert(role_arn=sagemaker.get_execution_role())
    # pipeline.upsert(role_arn="arn:aws:iam::<...>:role/service-role/AmazonSageMaker-ExecutionRole-<...>")
    pipeline.start()

L’esempio implementa l’valutazione di un singolo FM mediante pre-elaborazione del set di dati iniziale, il deploy del modello e l’esecuzione della valutazione. Il grafo aciclico diretto (DAG) generato del flusso di lavoro è mostrato nella figura seguente.

Seguendo un approccio simile e utilizzando e adattando l’esempio in Raffina i modelli LLaMA 2 su SageMaker JumpStart, abbiamo creato il flusso di lavoro per valutare un modello raffinato, come mostrato nella figura seguente.

Utilizzando i passaggi precedenti del flusso di lavoro di SageMaker come blocchi “Lego”, abbiamo sviluppato la soluzione per lo Scenario 1 e lo Scenario 3, come mostrato nelle seguenti figure. In particolare, il repository GitHub permette all’utente di valutare più FM contemporaneamente o di eseguire valutazioni più complesse combinando la valutazione di modelli fondamentali e raffinati.

Le funzionalità aggiuntive disponibili nel repository includono le seguenti:

• Generazione dinamica dei passaggi di valutazione: La nostra soluzione genera dinamicamente tutti i passaggi di valutazione necessari in base al file di configurazione per consentire agli utenti di valutare qualsiasi numero di modelli. Abbiamo esteso la soluzione per supportare un’integrazione facile di nuovi tipi di modelli, come Hugging Face o Amazon Bedrock.
• Prevenzione del ridispiegamento dell’endpoint: Se un endpoint è già presente, saltiamo il processo di deploy. Questo consente all’utente di riutilizzare gli endpoint con i FM per la valutazione, ottenendo risparmi di costi e tempi di deploy ridotti.
• Pulizia dell’endpoint: Dopo il completamento della valutazione, il flusso di lavoro di SageMaker decommissona gli endpoint deployati. Questa funzionalità può essere estesa per mantenere attivo l’endpoint del miglior modello.
• Passaggio di selezione del modello: Abbiamo aggiunto un segnaposto per il passaggio di selezione del modello che richiede la logica aziendale della selezione finale del modello, compresi criteri come costo o latenza.
• Passaggio di registrazione del modello: Il miglior modello può essere registrato nel Registro dei modelli Amazon SageMaker come una nuova versione di un gruppo di modelli specifico.
• Piscina riscaldata: Le piscine riscaldate gestite da SageMaker ti consentono di conservare e riutilizzare l’infrastruttura fornita dopo il completamento di un lavoro per ridurre la latenza per i carichi di lavoro ripetitivi.

La figura seguente illustra queste capacità e un esempio di valutazione multi-modello che gli utenti possono creare facilmente e dinamicamente utilizzando la nostra soluzione in questo repository GitHub.

Volutamente abbiamo escluso la preparazione dei dati poiché verrà descritta in un post separato in modo approfondito, inclusi i design del catalogo delle istruzioni, i template delle istruzioni, l’ottimizzazione delle istruzioni. Per ulteriori informazioni e definizioni dei componenti correlati, fare riferimento a FMOps/LLMOps: Operationalize generative AI and differences with MLOps.

Conclusion

In questo post, ci siamo concentrati su come automatizzare e operazionalizzare la valutazione di LLM su grande scala utilizzando le capacità di valutazione di LLM di Amazon SageMaker Clarify e Amazon SageMaker Pipelines. Oltre ai design di architettura teorica, abbiamo del codice di esempio in questo repository di GitHub (con Llama2 e Falcon-7B FMs) per consentire ai clienti di sviluppare i propri meccanismi di valutazione scalabili.

La seguente illustrazione mostra l’architettura di valutazione del modello.

In questo post, ci siamo concentrati sull’operazionalizzazione della valutazione di LLM su grande scala come mostrato sul lato sinistro dell’illustrazione. In futuro, ci concentreremo nello sviluppare esempi che coprano il ciclo di vita completo dei FMs fino alla produzione, seguendo la linea guida descritta in FMOps/LLMOps: Operazionalizzare l’AI generativa e le differenze con MLOps. Ciò include il servizio LLM, il monitoraggio, la memorizzazione dei rating di output che alla lunga attiveranno una riesecuzione automatica e un ottimizzazione, e infine l’utilizzo di esseri umani nel processo di lavoro sui dati etichettati o nel catalogo di prompt.