Riduci i costi e i tempi di sviluppo con la modalità locale di Amazon SageMaker Pipelines

La creazione di pipeline di machine learning (ML) robuste e riutilizzabili può essere un processo complesso e dispendioso in termini di tempo. Gli sviluppatori di solito testano i loro script di elaborazione e training in locale, ma le pipeline stesse vengono in genere testate nel cloud. La creazione e l'esecuzione di una pipeline completa durante la sperimentazione aggiunge costi e spese generali indesiderati al ciclo di vita dello sviluppo. In questo post, descriviamo in dettaglio come puoi usarlo Amazon SageMaker Pipelines in modalità locale per eseguire pipeline ML in locale per ridurre sia lo sviluppo della pipeline che il tempo di esecuzione riducendo i costi. Dopo che la pipeline è stata completamente testata in locale, puoi facilmente eseguirla nuovamente con Amazon Sage Maker risorse gestite con poche righe di modifiche al codice.

Panoramica del ciclo di vita del ML

Uno dei principali fattori trainanti per nuove innovazioni e applicazioni in ML è la disponibilità e la quantità di dati insieme a opzioni di calcolo più economiche. In diversi ambiti, il ML si è dimostrato in grado di risolvere problemi precedentemente irrisolvibili con i big data classici e le tecniche analitiche, e la domanda di data science e professionisti del ML è in costante aumento. Da un livello molto alto, il ciclo di vita di ML è costituito da molte parti diverse, ma la creazione di un modello ML di solito consiste nei seguenti passaggi generali:

1. Pulizia e preparazione dei dati (ingegneria delle funzionalità)
2. Formazione e messa a punto del modello
3. Valutazione del modello
4. Distribuzione del modello (o trasformazione batch)

Nella fase di preparazione dei dati, i dati vengono caricati, modificati e trasformati nel tipo di input o funzionalità previsto dal modello ML. La scrittura degli script per trasformare i dati è in genere un processo iterativo, in cui i cicli di feedback rapidi sono importanti per accelerare lo sviluppo. Normalmente non è necessario utilizzare l'intero set di dati durante il test degli script di progettazione delle funzionalità, motivo per cui è possibile utilizzare il funzione in modalità locale di elaborazione SageMaker. Ciò consente di eseguire localmente e aggiornare il codice in modo iterativo, utilizzando un set di dati più piccolo. Quando il codice finale è pronto, viene inviato al processo di elaborazione remota, che utilizza il set di dati completo e viene eseguito su istanze gestite da SageMaker.

Il processo di sviluppo è simile alla fase di preparazione dei dati sia per l'addestramento del modello che per le fasi di valutazione del modello. I data scientist usano il funzione in modalità locale di SageMaker Training per eseguire rapidamente l'iterazione con set di dati più piccoli in locale, prima di utilizzare tutti i dati in un cluster gestito da SageMaker di istanze ottimizzate per il ML. Ciò velocizza il processo di sviluppo ed elimina i costi di esecuzione delle istanze ML gestite da SageMaker durante la sperimentazione.

Con l'aumentare della maturità ML di un'organizzazione, puoi utilizzare Pipeline di Amazon SageMaker per creare pipeline ML che uniscono questi passaggi, creando flussi di lavoro ML più complessi che elaborano, addestrano e valutano modelli ML. SageMaker Pipelines è un servizio completamente gestito per automatizzare le diverse fasi del flusso di lavoro ML, inclusi caricamento dei dati, trasformazione dei dati, training e ottimizzazione del modello e distribuzione del modello. Fino a poco tempo, potevi sviluppare e testare i tuoi script in locale, ma dovevi testare le tue pipeline ML nel cloud. Ciò ha reso l'iterazione del flusso e della forma delle condutture ML un processo lento e costoso. Ora, con l'aggiunta della funzionalità in modalità locale di SageMaker Pipelines, puoi iterare e testare le tue pipeline ML in modo simile a come esegui il test e l'iterazione degli script di elaborazione e addestramento. È possibile eseguire e testare le pipeline sul computer locale, utilizzando un piccolo sottoinsieme di dati per convalidare la sintassi e le funzionalità della pipeline.

Pipeline SageMaker

SageMaker Pipelines fornisce un modo completamente automatizzato per eseguire flussi di lavoro ML semplici o complessi. Con SageMaker Pipelines, puoi creare flussi di lavoro ML con un SDK Python di facile utilizzo, quindi visualizzare e gestire il tuo flusso di lavoro utilizzando Amazon Sage Maker Studio. I tuoi team di data science possono essere più efficienti e scalare più velocemente archiviando e riutilizzando i passaggi del flusso di lavoro che crei in SageMaker Pipelines. Puoi anche utilizzare modelli predefiniti che automatizzano l'infrastruttura e la creazione di repository per creare, testare, registrare e distribuire modelli all'interno del tuo ambiente ML. Questi modelli sono automaticamente disponibili per la tua organizzazione e vengono forniti utilizzando Catalogo dei servizi AWS quando creo i miei prodotti.

SageMaker Pipelines introduce pratiche di integrazione continua e distribuzione continua (CI/CD) nel ML, come il mantenimento della parità tra gli ambienti di sviluppo e produzione, il controllo della versione, i test su richiesta e l'automazione end-to-end, che ti aiuta a scalare il ML in tutto il tuo organizzazione. I professionisti di DevOps sanno che alcuni dei principali vantaggi dell'utilizzo delle tecniche CI/CD includono un aumento della produttività tramite componenti riutilizzabili e un aumento della qualità tramite test automatizzati, che portano a un ROI più rapido per i tuoi obiettivi aziendali. Questi vantaggi sono ora disponibili per i professionisti MLOps utilizzando SageMaker Pipelines per automatizzare la formazione, il test e l'implementazione dei modelli ML. Con la modalità locale, ora puoi eseguire iterazioni molto più rapidamente durante lo sviluppo di script da utilizzare in una pipeline. Tieni presente che le istanze della pipeline locale non possono essere visualizzate o eseguite all'interno dell'IDE di Studio; tuttavia, presto saranno disponibili ulteriori opzioni di visualizzazione per le pipeline locali.

SageMaker SDK fornisce uno scopo generale configurazione in modalità locale che consente agli sviluppatori di eseguire e testare processori e stimatori supportati nel loro ambiente locale. Puoi utilizzare l'addestramento in modalità locale con più immagini del framework supportate da AWS (TensorFlow, MXNet, Chainer, PyTorch e Scikit-Learn) e immagini fornite da te.

SageMaker Pipelines, che crea un grafico aciclico diretto (DAG) di passaggi del flusso di lavoro orchestrati, supporta molte attività che fanno parte del ciclo di vita del ML. In modalità locale, sono supportati i seguenti passaggi:

• Fasi del lavoro di elaborazione – Un'esperienza gestita e semplificata su SageMaker per eseguire carichi di lavoro di elaborazione dati, come progettazione delle funzionalità, convalida dei dati, valutazione del modello e interpretazione del modello
• Fasi del lavoro di formazione – Un processo iterativo che insegna a un modello a fare previsioni presentando esempi da un set di dati di addestramento
• Lavori di ottimizzazione degli iperparametri – Un modo automatizzato per valutare e selezionare gli iperparametri che producono il modello più accurato
• Passaggi di esecuzione condizionali – Un passaggio che fornisce un'esecuzione condizionale di diramazioni in una pipeline
• Passo modello – Utilizzando gli argomenti CreateModel, questo passaggio può creare un modello da utilizzare nei passaggi di trasformazione o nella successiva distribuzione come endpoint
• Trasforma le fasi del lavoro – Un processo di trasformazione batch che genera stime da set di dati di grandi dimensioni ed esegue l'inferenza quando non è necessario un endpoint persistente
• Passi falliti – Un passaggio che interrompe un'esecuzione della pipeline e contrassegna l'esecuzione come non riuscita

Panoramica della soluzione

La nostra soluzione illustra i passaggi essenziali per creare ed eseguire SageMaker Pipelines in modalità locale, il che significa utilizzare CPU, RAM e risorse disco locali per caricare ed eseguire i passaggi del flusso di lavoro. Il tuo ambiente locale potrebbe essere in esecuzione su un laptop, utilizzando IDE popolari come VSCode o PyCharm, oppure potrebbe essere ospitato da SageMaker utilizzando istanze notebook classiche.

La modalità locale consente ai data scientist di unire i passaggi, che possono includere processi di elaborazione, formazione e valutazione, ed eseguire l'intero flusso di lavoro in locale. Al termine del test in locale, è possibile eseguire nuovamente la pipeline in un ambiente gestito da SageMaker sostituendo il file LocalPipelineSession oggetto con PipelineSession, che conferisce coerenza al ciclo di vita di ML.

Per questo esempio di notebook, utilizziamo un set di dati standard disponibile pubblicamente, il Set di dati Abalone di apprendimento automatico UCI. L'obiettivo è addestrare un modello ML per determinare l'età di una lumaca abalone dalle sue misurazioni fisiche. In sostanza, questo è un problema di regressione.

Tutto il codice necessario per eseguire questo esempio di notebook è disponibile su GitHub nel file amazon-sagemaker-esempi deposito. In questo esempio di notebook, ogni passaggio del flusso di lavoro della pipeline viene creato in modo indipendente e quindi collegato insieme per creare la pipeline. Creiamo i seguenti passaggi:

• Fase di elaborazione (ingegneria delle funzionalità)
• Fase di formazione (formazione del modello)
• Fase di elaborazione (valutazione del modello)
• Fase condizione (accuratezza del modello)
• Fase Crea modello (modello)
• Passaggio di trasformazione (trasformazione batch)
• Registra il passaggio del modello (pacchetto del modello)
• Passaggio non riuscito (esecuzione non riuscita)

Il diagramma seguente illustra la nostra pipeline.

Prerequisiti

Per seguire questo post, hai bisogno di quanto segue:

Una volta impostati questi prerequisiti, è possibile eseguire il notebook di esempio come descritto nelle sezioni seguenti.

Costruisci la tua pipeline

In questo esempio di notebook, utilizziamo Modalità script SageMaker per la maggior parte dei processi ML, il che significa che forniamo il codice Python effettivo (script) per eseguire l'attività e passare un riferimento a questo codice. La modalità script offre una grande flessibilità per controllare il comportamento all'interno dell'elaborazione di SageMaker consentendo di personalizzare il codice sfruttando al contempo i contenitori predefiniti di SageMaker come XGBoost o Scikit-Learn. Il codice personalizzato viene scritto in un file di script Python utilizzando le celle che iniziano con il comando magic %%writefile, come il seguente:

%%writefile code/evaluation.py

Il principale abilitatore della modalità locale è il LocalPipelineSession oggetto, che viene istanziato da Python SDK. I seguenti segmenti di codice mostrano come creare una pipeline SageMaker in modalità locale. Sebbene sia possibile configurare un percorso dati locale per molte delle fasi della pipeline locale, Amazon S3 è la posizione predefinita in cui archiviare l'output dei dati dalla trasformazione. Il nuovo LocalPipelineSession l'oggetto viene passato all'SDK Python in molte delle chiamate API del flusso di lavoro SageMaker descritte in questo post. Nota che puoi usare il local_pipeline_session per recuperare i riferimenti al bucket predefinito S3 e al nome della regione corrente.

from sagemaker.workflow.pipeline_context import LocalPipelineSession

# Create a `LocalPipelineSession` object so that each 
# pipeline step will run locally
# To run this pipeline in the cloud, you must change 
# the `LocalPipelineSession()` to `PipelineSession()`
local_pipeline_session = LocalPipelineSession()
region = local_pipeline_session.boto_region_name

default_bucket = local_pipeline_session.default_bucket()
prefix = "sagemaker-pipelines-local-mode-example"

Prima di creare i singoli passaggi della pipeline, impostiamo alcuni parametri utilizzati dalla pipeline. Alcuni di questi parametri sono valori letterali stringa, mentre altri vengono creati come tipi enumerati speciali forniti dall'SDK. La tipizzazione enumerata garantisce che alla pipeline vengano fornite impostazioni valide, come questa, che viene passata a ConditionLessThanOrEqualTo passo più in basso:

mse_threshold = ParameterFloat(name="MseThreshold", default_value=7.0)

Per creare una fase di elaborazione dei dati, che viene utilizzata qui per eseguire l'ingegneria delle funzionalità, utilizziamo il SKLearnProcessor per caricare e trasformare il set di dati. Passiamo il local_pipeline_session variabile al costruttore della classe, che indica al passaggio del flusso di lavoro di essere eseguito in modalità locale:

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=local_pipeline_session,
)

Successivamente, creiamo il nostro primo passaggio effettivo della pipeline, a ProcessingStep oggetto, come importato da SageMaker SDK. Gli argomenti del processore vengono restituiti da una chiamata a SKLearnProcessor metodo run(). Questo passaggio del flusso di lavoro è combinato con altri passaggi verso la fine del notebook per indicare l'ordine delle operazioni all'interno della pipeline.

from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep

processor_args = sklearn_processor.run(
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="code/preprocessing.py",
)

step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args)

Successivamente, forniamo il codice per stabilire una fase di addestramento creando prima un'istanza di uno stimatore standard utilizzando SageMaker SDK. Passiamo lo stesso local_pipeline_session variabile allo stimatore, denominata xgb_train, come sagemaker_session discussione. Poiché vogliamo addestrare un modello XGBoost, dobbiamo generare un URI immagine valido specificando i seguenti parametri, incluso il framework e diversi parametri di versione:

from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput

model_path = f"s3://{default_bucket}/{prefix}/model"
image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.5-1",
    py_version="py3",
    instance_type=instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    entry_point="code/abalone.py",
    instance_type=instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    role=role,
    sagemaker_session=local_pipeline_session,
)

Possiamo facoltativamente chiamare metodi di stima aggiuntivi, ad esempio set_hyperparameters(), per fornire le impostazioni dell'iperparametro per il processo di addestramento. Ora che abbiamo configurato uno stimatore, siamo pronti per creare la fase di formazione vera e propria. Ancora una volta, importiamo il file TrainingStep classe dalla libreria SageMaker SDK:

from sagemaker.workflow.steps import TrainingStep

step_train = TrainingStep(name="AbaloneTrain", step_args=train_args)

Successivamente, costruiamo un'altra fase di elaborazione per eseguire la valutazione del modello. Questo viene fatto creando un ScriptProcessor istanza e passando il local_pipeline_session oggetto come parametro:

from sagemaker.processing import ScriptProcessor

script_eval = ScriptProcessor(
    image_uri=image_uri,
    command=["python3"],
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="script-abalone-eval",
    role=role,
    sagemaker_session=local_pipeline_session,
)

Per abilitare la distribuzione del modello addestrato, a Endpoint in tempo reale di SageMaker o per una trasformazione batch, dobbiamo creare a Model oggetto passando gli artefatti del modello, l'URI dell'immagine corretto e, facoltativamente, il nostro codice di inferenza personalizzato. Quindi passiamo questo Model obiettare a ModelStep, che viene aggiunto alla pipeline locale. Vedere il codice seguente:

from sagemaker.model import Model

model = Model(
    image_uri=image_uri,
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir="code",
    entry_point="inference.py",
    role=role,
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.model_step import ModelStep

step_create_model = ModelStep(name="AbaloneCreateModel", 
    step_args=model.create(instance_type=instance_type)
)

Successivamente, creiamo un passaggio di trasformazione batch in cui inviamo una serie di vettori di funzionalità ed eseguiamo l'inferenza. Dobbiamo prima creare un Transformer oggetto e passare il local_pipeline_session parametro ad esso. Quindi creiamo un TransformStep, passando gli argomenti richiesti e aggiungilo alla definizione della pipeline:

from sagemaker.transformer import Transformer

transformer = Transformer(
    model_name=step_create_model.properties.ModelName,
    instance_type=instance_type,
    instance_count=transform_instance_count,
    output_path=f"s3://{default_bucket}/{prefix}/transform",
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.steps import TransformStep

transform_args = transformer.transform(transform_data, content_type="text/csv")

step_transform = TransformStep(name="AbaloneTransform", step_args=transform_args)

Infine, vogliamo aggiungere una condizione branch al flusso di lavoro in modo da eseguire la trasformazione batch solo se i risultati della valutazione del modello soddisfano i nostri criteri. Possiamo indicare questo condizionale aggiungendo a ConditionStep con un tipo di condizione particolare, come ConditionLessThanOrEqualTo. Elenchiamo quindi i passaggi per i due rami, definendo essenzialmente i rami if/else o true/false della pipeline. I passaggi if forniti in ConditionStep (passo_crea_modello, passo_trasformare) vengono eseguiti ogni volta che la condizione restituisce True.

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet

cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step_name=step_eval.name,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",),
    right=mse_threshold,
)

step_cond = ConditionStep(
    name="AbaloneMSECond",
    conditions=[cond_lte],
    if_steps=[step_create_model, step_transform],
    else_steps=[step_fail],
)

Il diagramma seguente illustra questo ramo condizionale e i passaggi if/else associati. Viene eseguito un solo ramo, in base all'esito della fase di valutazione del modello rispetto alla fase della condizione.

Ora che abbiamo tutti i nostri passaggi definiti e le istanze della classe sottostanti create, possiamo combinarle in una pipeline. Forniamo alcuni parametri e definiamo in modo cruciale l'ordine delle operazioni semplicemente elencando i passaggi nell'ordine desiderato. Si noti che il TransformStep non viene mostrato qui perché è la destinazione del passaggio condizionale ed è stato fornito come argomento del passaggio a ConditionalStep in precedenza.

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=local_pipeline_session,
)

Per eseguire la pipeline, devi chiamare due metodi: pipeline.upsert(), che carica la pipeline nel servizio sottostante e pipeline.start(), che avvia l'esecuzione della pipeline. È possibile utilizzare vari altri metodi per interrogare lo stato dell'esecuzione, elencare i passaggi della pipeline e altro ancora. Poiché abbiamo utilizzato la sessione della pipeline in modalità locale, questi passaggi vengono tutti eseguiti localmente sul processore. L'output della cella sotto il metodo di avvio mostra l'output della pipeline:

pipeline.upsert(role_arn=role)
execution = pipeline.start()

Dovresti vedere un messaggio nella parte inferiore dell'output della cella simile al seguente:

Pipeline execution d8c3e172-089e-4e7a-ad6d-6d76caf987b7 SUCCEEDED

Torna alle risorse gestite

Dopo aver confermato che la pipeline funziona senza errori e siamo soddisfatti del flusso e della forma della pipeline, possiamo ricreare la pipeline ma con le risorse gestite da SageMaker ed eseguirla di nuovo. L'unica modifica richiesta è utilizzare il PipelineSession oggetto invece di LocalPipelineSession:

da sagemaker.workflow.pipeline_context importa LocalPipelineSession
from sagemaker.workflow.pipeline_context import PipelineSession

local_pipeline_session = LocalPipelineSession()
pipeline_session = PipelineSession()

Questo informa il servizio di eseguire ogni passaggio facendo riferimento a questo oggetto sessione sulle risorse gestite da SageMaker. Data la piccola modifica, illustriamo solo le modifiche al codice richieste nella cella di codice seguente, ma la stessa modifica dovrebbe essere implementata su ciascuna cella utilizzando il local_pipeline_session oggetto. Le modifiche sono, tuttavia, identiche in tutte le celle perché stiamo solo sostituendo il local_pipeline_session oggetto con il pipeline_session oggetto.

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=pipeline_session,  # non-local session
)

Dopo che l'oggetto sessione locale è stato sostituito ovunque, ricreiamo la pipeline e la eseguiamo con le risorse gestite da SageMaker:

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=pipeline_session, # non-local session
)

pipeline.upsert(role_arn=role)
execution = pipeline.start()

ripulire

Se si desidera mantenere in ordine l'ambiente Studio, è possibile utilizzare i metodi seguenti per eliminare la pipeline SageMaker e il modello. Il codice completo può essere trovato nell'esempio taccuino.

# delete models 
sm_client = boto3.client("sagemaker")
model_prefix="AbaloneCreateModel"
delete_models(sm_client, model_prefix)

# delete managed pipeline
pipeline_to_delete = 'SM-Managed-Pipeline'
delete_sagemaker_pipeline(sm_client, pipeline_to_delete)

Conclusione

Fino a poco tempo, era possibile utilizzare la funzione in modalità locale di SageMaker Processing e SageMaker Training per eseguire iterazioni sugli script di elaborazione e formazione in locale, prima di eseguirli su tutti i dati con le risorse gestite da SageMaker. Con la nuova funzionalità in modalità locale di SageMaker Pipelines, i professionisti del ML possono ora applicare lo stesso metodo durante l'iterazione sulle loro pipeline ML, unendo insieme i diversi flussi di lavoro ML. Quando la pipeline è pronta per la produzione, eseguirla con le risorse gestite da SageMaker richiede solo poche righe di modifiche al codice. Ciò riduce il tempo di esecuzione della pipeline durante lo sviluppo, portando a uno sviluppo più rapido della pipeline con cicli di sviluppo più rapidi, riducendo al contempo il costo delle risorse gestite da SageMaker.

Per ulteriori informazioni, visitare il sito Pipeline di Amazon SageMaker or Usa SageMaker Pipelines per eseguire i tuoi lavori in locale.

Circa gli autori

Paolo Hargis ha concentrato i suoi sforzi sull'apprendimento automatico in diverse aziende, tra cui AWS, Amazon e Hortonworks. Gli piace costruire soluzioni tecnologiche e insegnare alle persone come sfruttarle al meglio. Prima del suo ruolo in AWS, è stato Lead Architect per Amazon Exports and Expansions, aiutando amazon.com a migliorare l'esperienza per gli acquirenti internazionali. A Paul piace aiutare i clienti a espandere le loro iniziative di machine learning per risolvere i problemi del mondo reale.

Niklas Palma è un Solutions Architect presso AWS a Stoccolma, Svezia, dove aiuta i clienti dei paesi nordici ad avere successo nel cloud. È particolarmente appassionato di tecnologie serverless insieme a IoT e machine learning. Al di fuori del lavoro, Niklas è un appassionato sciatore di fondo e snowboarder, nonché un maestro della caldaia.

Kirit Tadaka è un ML Solutions Architect che lavora nel team SageMaker Service SA. Prima di entrare in AWS, Kirit ha lavorato in start-up di intelligenza artificiale, seguite da un po' di consulenza in vari ruoli nella ricerca sull'IA, MLOps e leadership tecnica.