La partnership Amazon SageMaker e Hugging Face

Amazon SageMaker e Hugging Face hanno una partnership.

Osserva questi sorrisi!

Oggi annunciamo una partnership strategica tra Hugging Face e Amazon per rendere più facile alle aziende sfruttare modelli di apprendimento automatico di ultima generazione e fornire funzionalità di elaborazione del linguaggio naturale all’avanguardia più velocemente.

Attraverso questa partnership, Hugging Face sta utilizzando Amazon Web Services come suo fornitore preferito di cloud per offrire servizi ai suoi clienti.

Come primo passo per consentire ai nostri clienti comuni, Hugging Face e Amazon stanno introducendo nuovi Hugging Face Deep Learning Containers (DLC) per rendere più semplice che mai addestrare modelli Hugging Face Transformer in Amazon SageMaker.

Per scoprire come accedere e utilizzare i nuovi Hugging Face DLC con l’SDK Python di Amazon SageMaker, consulta le guide e le risorse di seguito.

Il 8 luglio 2021 abbiamo esteso l’integrazione di Amazon SageMaker per aggiungere una facile distribuzione e inferenza dei modelli Transformers. Se desideri scoprire come puoi distribuire facilmente modelli Hugging Face con Amazon SageMaker, dai un’occhiata al nuovo post del blog e alla documentazione.


Funzionalità e vantaggi 🔥

Un solo comando è tutto ciò di cui hai bisogno

Con i nuovi Hugging Face Deep Learning Containers disponibili in Amazon SageMaker, l’addestramento di modelli di elaborazione del linguaggio naturale all’avanguardia basati su Transformers non è mai stato così semplice. Ci sono varianti appositamente ottimizzate per TensorFlow e PyTorch, per singola GPU, singolo nodo multi-GPU e cluster multi-nodo.

Accelerare l’apprendimento automatico dalla scienza alla produzione

Oltre ai DLC di Hugging Face, abbiamo creato un’estensione di prima classe di Hugging Face per l’SDK Python di SageMaker per accelerare i team di data science, riducendo il tempo necessario per configurare ed eseguire esperimenti da giorni a minuti.

Puoi utilizzare i DLC di Hugging Face con la funzionalità di ottimizzazione automatica dei modelli di addestramento di Amazon SageMaker, al fine di ottimizzare automaticamente i tuoi iperparametri di addestramento e aumentare rapidamente l’accuratezza dei tuoi modelli.

Grazie all’Ambiente di sviluppo integrato (IDE) basato sul web di SageMaker Studio, puoi facilmente monitorare e confrontare i tuoi esperimenti e i tuoi artefatti di addestramento.

Prestazioni integrate

Con i DLC di Hugging Face, i clienti di SageMaker beneficeranno di ottimizzazioni delle prestazioni integrate per PyTorch o TensorFlow, per addestrare modelli di elaborazione del linguaggio naturale più rapidamente e con la flessibilità di scegliere l’infrastruttura di addestramento con il miglior rapporto prezzo/prestazioni per il tuo carico di lavoro.

I DLC di Hugging Face sono completamente integrati con le librerie di addestramento distribuito di SageMaker, per addestrare modelli più velocemente di quanto fosse mai stato possibile prima, utilizzando la generazione più recente di istanze disponibili su Amazon EC2.


Risorse, documentazione e campioni 📄

Di seguito puoi trovare tutte le risorse importanti per tutti i blog post, i video, la documentazione e i notebook/script pubblicati.

Blog/Video

  • AWS: Abbracciare l’elaborazione del linguaggio naturale con Hugging Face
  • Distribuisci facilmente modelli Hugging Face con Amazon SageMaker
  • AWS e Hugging Face collaborano per semplificare e accelerare l’adozione di modelli di elaborazione del linguaggio naturale
  • Procedura guidata: Classificazione di testo end-to-end
  • Lavorare con modelli Hugging Face su Amazon SageMaker
  • Addestramento distribuito: Addestra BART/T5 per la sommarizzazione utilizzando 🤗 Transformers e Amazon SageMaker
  • Distribuisci un modello Hugging Face Transformers da S3 a Amazon SageMaker
  • Distribuisci un modello Hugging Face Transformers dall’hub dei modelli a Amazon SageMaker

Documentazione

  • Documentazione di Hugging Face per Amazon SageMaker
  • Esegui l’addestramento su Amazon SageMaker
  • Dispiegare modelli su Amazon SageMaker
  • Domande frequenti
  • Documentazione di Amazon SageMaker per Hugging Face
  • Documentazione SDK Python di SageMaker per Hugging Face
  • Container di deep learning
  • Libreria parallela dei dati distribuiti di SageMaker
  • Libreria parallela del modello distribuito di SageMaker

Notebook di esempio

  • Tutti i notebook
  • Introduzione a Pytorch
  • Introduzione a Tensorflow
  • Parallelismo distribuito nell’addestramento dei dati
  • Parallelismo distribuito nell’addestramento del modello
  • Istanze spot e continuare l’addestramento
  • Metriche di SageMaker
  • Parallelismo distribuito con Tensorflow nell’addestramento dei dati
  • Addestramento distribuito per la sommarizzazione
  • Classificazione delle immagini con Vision Transformer
  • Dispiegare uno dei più di 10.000 modelli Hugging Face Transformers su Amazon SageMaker per l’inferenza
  • Dispiegare un modello Hugging Face Transformer da S3 a SageMaker per l’inferenza

Guida introduttiva: Classificazione del testo end-to-end 🧭

In questa guida introduttiva, utilizzeremo le nuove DLC di Hugging Face e l’estensione Amazon SageMaker per addestrare un modello di trasformazione sulla classificazione binaria del testo utilizzando le librerie transformers e datasets.

Utilizzeremo un’istanza di blocco appunti di Amazon SageMaker per l’esempio. Puoi imparare qui come configurare un’istanza di blocco appunti .

Cosa faremo:

  • configurare un ambiente di sviluppo e installare sagemaker
  • creare lo script di addestramento train.py
  • preprocessare i nostri dati e caricarli su Amazon S3
  • creare un Estimator di HuggingFace e addestrare il nostro modello

Configurare un ambiente di sviluppo e installare sagemaker

Come accennato in precedenza, utilizzeremo le istanze di blocco appunti di SageMaker per questo. Per iniziare, devi accedere al tuo Jupyer Notebook o JupyterLab e creare un nuovo blocco appunti con il kernel conda_pytorch_p36.

Nota: L’uso di Jupyter è facoltativo: potremmo anche avviare attività di addestramento di SageMaker da qualsiasi posizione in cui è installato un SDK, connessione al cloud e autorizzazioni appropriate, come un laptop, un altro IDE o un pianificatore di attività come Airflow o AWS Step Functions.

Dopo di che possiamo installare le dipendenze richieste

pip install "sagemaker>=2.31.0" "transformers==4.6.1" "datasets[s3]==1.6.2" --upgrade

Per eseguire l’addestramento su SageMaker, è necessario creare una sessione sagemaker e fornire un ruolo IAM con le autorizzazioni corrette. Questo ruolo IAM verrà successivamente allegato al TrainingJob, consentendogli di scaricare i dati, ad esempio da Amazon S3.

import sagemaker

sess = sagemaker.Session()
# sagemaker session bucket -> utilizzato per caricare dati, modelli e registri
# sagemaker creerà automaticamente questo bucket se non esiste
sagemaker_session_bucket=None
if sagemaker_session_bucket is None and sess is not None:
    # impostato su bucket predefinito se non viene fornito un nome di bucket
    sagemaker_session_bucket = sess.default_bucket()

role = sagemaker.get_execution_role()
sess = sagemaker.Session(default_bucket=sagemaker_session_bucket)

print(f"sagemaker role arn: {role}")
print(f"sagemaker bucket: {sess.default_bucket()}")
print(f"sagemaker session region: {sess.boto_region_name}")

Creare lo script di addestramento train.py

In un TrainingJob di SageMaker eseguiamo uno script Python con argomenti nominati. In questo esempio, utilizziamo PyTorch insieme a transformers. Lo script

  • passa i parametri in ingresso (iperparametri da HuggingFace Estimator)
  • carica il nostro dataset
  • definisce la nostra funzione di calcolo delle metriche
  • configura il nostro Trainer
  • esegue l’addestramento con trainer.train()
  • valuta l’addestramento e salva il nostro modello alla fine su S3.
from transformers import AutoModelForSequenceClassification, Trainer, TrainingArguments
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
from datasets import load_from_disk
import random
import logging
import sys
import argparse
import os
import torch

if __name__ == "__main__":

    parser = argparse.ArgumentParser()

    # gli iperparametri inviati dal client vengono passati come argomenti della riga di comando allo script.
    parser.add_argument("--epochs", type=int, default=3)
    parser.add_argument("--train-batch-size", type=int, default=32)
    parser.add_argument("--eval-batch-size", type=int, default=64)
    parser.add_argument("--warmup_steps", type=int, default=500)
    parser.add_argument("--model_name", type=str)
    parser.add_argument("--learning_rate", type=str, default=5e-5)

    # Directory dei dati, del modello e dell'output
    parser.add_argument("--output-data-dir", type=str, default=os.environ["SM_OUTPUT_DATA_DIR"])
    parser.add_argument("--model-dir", type=str, default=os.environ["SM_MODEL_DIR"])
    parser.add_argument("--n_gpus", type=str, default=os.environ["SM_NUM_GPUS"])
    parser.add_argument("--training_dir", type=str, default=os.environ["SM_CHANNEL_TRAIN"])
    parser.add_argument("--test_dir", type=str, default=os.environ["SM_CHANNEL_TEST"])

    args, _ = parser.parse_known_args()

    # Configura il logging
    logger = logging.getLogger(__name__)

    logging.basicConfig(
        level=logging.getLevelName("INFO"),
        handlers=[logging.StreamHandler(sys.stdout)],
        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    )

    # carica i dataset
    train_dataset = load_from_disk(args.training_dir)
    test_dataset = load_from_disk(args.test_dir)

    logger.info(f" la lunghezza del train_dataset caricato è: {len(train_dataset)}")
    logger.info(f" la lunghezza del test_dataset caricato è: {len(test_dataset)}")

    # funzione di calcolo delle metriche per la classificazione binaria
    def compute_metrics(pred):
        labels = pred.label_ids
        preds = pred.predictions.argmax(-1)
        precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average="binary")
        acc = accuracy_score(labels, preds)
        return {"accuracy": acc, "f1": f1, "precision": precision, "recall": recall}

    # scarica il modello dall'hub dei modelli
    model = AutoModelForSequenceClassification.from_pretrained(args.model_name)

    # definisce gli argomenti di addestramento
    training_args = TrainingArguments(
        output_dir=args.model_dir,
        num_train_epochs=args.epochs,
        per_device_train_batch_size=args.train_batch_size,
        per_device_eval_batch_size=args.eval_batch_size,
        warmup_steps=args.warmup_steps,
        evaluation_strategy="epoch",
        logging_dir=f"{args.output_data_dir}/logs",
        learning_rate=float(args.learning_rate),
    )

    # crea un'istanza di Trainer
    trainer = Trainer(
        model=model,
        args=training_args,
        compute_metrics=compute_metrics,
        train_dataset=train_dataset,
        eval_dataset=test_dataset,
    )

    # addestra il modello
    trainer.train()

    # valuta il modello
    eval_result = trainer.evaluate(eval_dataset=test_dataset)

    # scrive il risultato della valutazione su un file a cui si può accedere successivamente nell'output di s3
    with open(os.path.join(args.output_data_dir, "eval_results.txt"), "w") as writer:
        print(f"***** Risultati della valutazione *****")
        for key, value in sorted(eval_result.items()):
            writer.write(f"{key} = {value}\\n")

    # Salva il modello su s3; il percorso predefinito è /opt/ml/model che SageMaker invia a S3
    trainer.save_model(args.model_dir)

Preelaborazione dei dati e caricamento su s3

Utilizziamo la libreria datasets per scaricare e preelaborare il nostro dataset imdb. Dopo la preelaborazione, il dataset verrà caricato nel bucket s3 predefinito della sessione corrente sess.default_bucket() utilizzato all’interno del nostro job di addestramento. Il dataset imdb è composto da 25000 recensioni di film altamente polarizzate per l’addestramento e 25000 per il testing.

import botocore
from datasets import load_dataset
from transformers import AutoTokenizer
from datasets.filesystems import S3FileSystem

# tokenizer utilizzato nella preelaborazione
tokenizer_name = 'distilbert-base-uncased'

# client filesystem per s3
s3 = S3FileSystem()

# dataset utilizzato
dataset_name = 'imdb'

# prefisso chiave s3 per i dati
s3_prefix = 'datasets/imdb'

# carica il dataset
dataset = load_dataset(dataset_name)

# scarica il tokenizer
tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)

# funzione di aiuto per il tokenizer
def tokenize(batch):
    return tokenizer(batch['text'], padding='max_length', truncation=True)

# carica il dataset
train_dataset, test_dataset = load_dataset('imdb', split=['train', 'test'])
test_dataset = test_dataset.shuffle().select(range(10000)) # riduci le dimensioni del dataset di test a 10k

# tokenizza il dataset
train_dataset = train_dataset.map(tokenize, batched=True, batch_size=len(train_dataset))
test_dataset = test_dataset.map(tokenize, batched=True, batch_size=len(test_dataset))

# imposta il formato per pytorch
train_dataset = train_dataset.rename_column("label", "labels")
train_dataset.set_format('torch', columns=['input_ids', 'attention_mask', 'labels'])
test_dataset = test_dataset.rename_column("label", "labels")
test_dataset.set_format('torch', columns=['input_ids', 'attention_mask', 'labels'])

# salva train_dataset su s3
training_input_path = f's3://{sess.default_bucket()}/{s3_prefix}/train'
train_dataset.save_to_disk(training_input_path,fs=s3)

# salva test_dataset su s3
test_input_path = f's3://{sess.default_bucket()}/{s3_prefix}/test'
test_dataset.save_to_disk(test_input_path,fs=s3)

Crea un Estimator HuggingFace e addestra il nostro modello

Per creare un Trainingjob di SageMaker possiamo utilizzare un Estimator HuggingFace. L’Estimator gestisce l’intero processo di addestramento di Amazon SageMaker. In un Estimator, definiamo quale script di fine-tuning deve essere utilizzato come entry_point, quale instance_type deve essere utilizzato, quali iperparametri devono essere passati. Oltre a ciò, sono disponibili numerosi controlli avanzati, come la personalizzazione delle posizioni di output e checkpoint, la specifica delle dimensioni dello storage locale o la configurazione della rete.

SageMaker si occupa di avviare e gestire tutte le istanze Amazon EC2 necessarie per noi con il DLC Hugging Face, carica lo script di fine-tuning fornito, ad esempio il nostro train.py, quindi scarica i dati dal bucket S3, sess.default_bucket(), nel container. Una volta che i dati sono pronti, il job di addestramento inizierà automaticamente eseguendo il comando.

/opt/conda/bin/python train.py --epochs 1 --model_name distilbert-base-uncased --train_batch_size 32

Gli iperparametri definiti nell’Estimator HuggingFace vengono passati come argomenti con nome.

from sagemaker.huggingface import HuggingFace

# iperparametri, che vengono passati al job di addestramento
hyperparameters={'epochs': 1,
                 'train_batch_size': 32,
                 'model_name':'distilbert-base-uncased'
                 }

# crea l'Estimator
huggingface_estimator = HuggingFace(
      entry_point='train.py',
      source_dir='./scripts',
      instance_type='ml.p3.2xlarge',
      instance_count=1,
      role=role,
      transformers_version='4.6',
      pytorch_version='1.7',
      py_version='py36',
      hyperparameters = hyperparameters
)

Per avviare l’addestramento, chiamiamo il metodo .fit() e passiamo il nostro uri S3 come input.

# avvia il job di addestramento con i nostri dataset caricati come input
huggingface_estimator.fit({'train': training_input_path, 'test': test_input_path})

Ulteriori funzionalità 🚀

Oltre al Contenitore Deep Learning e al SDK di SageMaker, abbiamo implementato altre funzionalità aggiuntive.

Allenamento Distribuito: Data-Parallel

Puoi utilizzare la Libreria di Parallelismo dei Dati di SageMaker pronta all’uso per l’allenamento distribuito. Abbiamo aggiunto la funzionalità del Parallelismo dei Dati direttamente nel Trainer. Se il tuo train.py utilizza l’API del Trainer, è sufficiente definire il parametro di distribuzione nell’Estimator di HuggingFace.

  • Notebook di Esempio PyTorch
  • Notebook di Esempio TensorFlow
# configurazione per eseguire l'allenamento su smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

# crea l'Estimator
huggingface_estimator = HuggingFace(
        entry_point='train.py',
        source_dir='./scripts',
        instance_type='ml.p3dn.24xlarge',
        instance_count=2,
        role=role,
        transformers_version='4.4.2',
        pytorch_version='1.6.0',
        py_version='py36',
        hyperparameters = hyperparameters
        distribution = distribution
)

L’esempio “Getting started: End-to-End Text Classification 🧭” può essere utilizzato per l’allenamento distribuito senza alcuna modifica.

Allenamento Distribuito: Model Parallel

Puoi utilizzare la Libreria di Parallelismo del Modello di SageMaker pronta all’uso per l’allenamento distribuito. Abbiamo aggiunto la funzionalità del Parallelismo del Modello direttamente nel Trainer. Se il tuo train.py utilizza l’API del Trainer, è sufficiente definire il parametro di distribuzione nell’Estimator di HuggingFace. Per informazioni dettagliate sugli aggiustamenti, consulta qui .

  • Notebook di Esempio
# configurazione per eseguire l'allenamento su smdistributed Model Parallel
mpi_options = {
    "enabled" : True,
    "processes_per_host" : 8
}

smp_options = {
    "enabled":True,
    "parameters": {
        "microbatches": 4,
        "placement_strategy": "spread",
        "pipeline": "interleaved",
        "optimize": "speed",
        "partitions": 4,
        "ddp": True,
    }
}

distribution={
    "smdistributed": {"modelparallel": smp_options},
    "mpi": mpi_options
}

# crea l'Estimator
huggingface_estimator = HuggingFace(
        entry_point='train.py',
        source_dir='./scripts',
        instance_type='ml.p3dn.24xlarge',
        instance_count=2,
        role=role,
        transformers_version='4.4.2',
        pytorch_version='1.6.0',
        py_version='py36',
        hyperparameters = hyperparameters,
        distribution = distribution
)

Istanze Spot

Con la creazione dell’estensione del Framework HuggingFace per il SageMaker Python SDK, possiamo anche sfruttare i vantaggi delle istanze EC2 Spot completamente gestite e risparmiare fino al 90% dei costi di addestramento.

Nota: Se il tuo job di addestramento verrà completato rapidamente, ti consigliamo di utilizzare il checkpointing con l’addestramento spot gestito, quindi è necessario definire il checkpoint_s3_uri.

Per utilizzare le istanze Spot con l’Estimator di HuggingFace, è necessario impostare il parametro use_spot_instances su True e definire il tuo tempo massimo di attesa max_wait e il tempo massimo di esecuzione max_run. Puoi leggere di più sul ciclo di vita dell’addestramento spot gestito qui .

  • Notebook di Esempio
# iperparametri, che vengono passati nel job di addestramento
hyperparameters={'epochs': 1,
                 'train_batch_size': 32,
                 'model_name':'distilbert-base-uncased',
                 'output_dir':'/opt/ml/checkpoints'
                 }
# crea l'Estimator

huggingface_estimator = HuggingFace(
        entry_point='train.py',
        source_dir='./scripts',
        instance_type='ml.p3.2xlarge',
        instance_count=1,
          checkpoint_s3_uri=f's3://{sess.default_bucket()}/checkpoints'
        use_spot_instances=True,
        max_wait=3600, # Questo dovrebbe essere uguale o superiore a max_run in secondi'
        max_run=1000,
        role=role,
        transformers_version='4.4',
        pytorch_version='1.6',
        py_version='py36',
        hyperparameters = hyperparameters
)

# Secondi di addestramento: 874
# Secondi fatturabili: 105
# Risparmi sull'Addestramento Spot gestito: 88.0%

Repository Git

Quando crei un Estimator di HuggingFace, puoi specificare uno script di addestramento che è memorizzato in un repository GitHub come punto di ingresso per l’estimatore, in modo da non dover scaricare gli script localmente. Se il supporto Git è abilitato, allora entry_point e source_dir devono essere percorsi relativi nel repository Git se forniti.

Come esempio di utilizzo di git_config con uno script di esempio dal repository transformers.

Sii consapevole che è necessario definire output_dir come un iperparametro per lo script per salvare il tuo modello su S3 dopo l’addestramento. Suggerimento: definisci output_dir come /opt/ml/model poiché è la directory predefinita SM_MODEL_DIR e verrà caricata su S3.

  • Notebook di esempio
# configura le impostazioni di git
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'master'}

 # crea l'Estimator
huggingface_estimator = HuggingFace(
        entry_point='run_glue.py',
        source_dir='./examples/text-classification',
        git_config=git_config,
        instance_type='ml.p3.2xlarge',
        instance_count=1,
        role=role,
        transformers_version='4.4',
        pytorch_version='1.6',
        py_version='py36',
        hyperparameters=hyperparameters
)

Metriche di SageMaker

Le metriche di SageMaker possono analizzare automaticamente i log per le metriche e inviare queste metriche a CloudWatch. Se desideri che SageMaker analizzi i log, devi specificare le metriche che desideri che SageMaker invii a CloudWatch quando configurare il job di addestramento. Specifica il nome delle metriche che desideri inviare e le espressioni regolari che SageMaker utilizza per analizzare i log che il tuo algoritmo emette per trovare quelle metriche.

  • Notebook di esempio
# definisci le definizioni delle metriche
metric_definitions = [
{"Name": "train_runtime", "Regex": "train_runtime.*=\D*(.*?)$"},
{"Name": "eval_accuracy", "Regex": "eval_accuracy.*=\D*(.*?)$"},
{"Name": "eval_loss", "Regex": "eval_loss.*=\D*(.*?)$"},
]

# crea l'Estimator
huggingface_estimator = HuggingFace(
        entry_point='train.py',
        source_dir='./scripts',
        instance_type='ml.p3.2xlarge',
        instance_count=1,
        role=role,
        transformers_version='4.4',
        pytorch_version='1.6',
        py_version='py36',
        metric_definitions=metric_definitions,
        hyperparameters = hyperparameters
)

FAQ 🎯

Puoi trovare le domande frequenti complete nella documentazione.

D: Cosa sono i Deep Learning Containers?

R: I Deep Learning Containers (DLC) sono immagini Docker pre-installate con framework e librerie di deep learning (ad esempio transformers, datasets, tokenizers) per semplificare l’addestramento dei modelli permettendoti di saltare il complicato processo di creazione e ottimizzazione degli ambienti da zero.

D: Devo utilizzare l’SDK Python di SageMaker per utilizzare i Deep Learning Containers di Hugging Face?

R: Puoi utilizzare l’Hugging Face DLC senza l’SDK Python di SageMaker e avviare i job di addestramento di SageMaker con altri SDK, come AWS CLI o boto3. I DLC sono disponibili anche tramite Amazon ECR e possono essere estratti e utilizzati in qualsiasi ambiente a tua scelta.

D: Perché dovrei utilizzare i Deep Learning Containers di Hugging Face?

R: I DLC sono ambienti di deep learning completamente testati, mantenuti e ottimizzati che non richiedono installazione, configurazione o manutenzione.

D: Perché dovrei utilizzare SageMaker Training per addestrare modelli di Hugging Face?

R: SageMaker Training offre numerosi vantaggi che aumenteranno la tua produttività con Hugging Face: (1) è economico: le istanze di addestramento vivono solo per la durata del tuo job e vengono pagate al secondo. Non c’è più il rischio di lasciare le istanze GPU accese tutta la notte: il cluster di addestramento si ferma alla fine del tuo job! Supporta anche la capacità EC2 Spot, che consente una riduzione dei costi fino al 90%. (2) SageMaker offre anche molta automazione integrata che facilita il lavoro di squadra e MLOps: i metadati e i log di addestramento vengono automaticamente salvati in un metastore gestito serverless e l’I/O con S3 (per i dataset, i checkpoint e gli artefatti del modello) è completamente gestito. Infine, SageMaker consente anche di scalare drasticamente: puoi avviare più job di addestramento in parallelo, ma anche avviare job di addestramento distribuito su larga scala.

Q: Una volta addestrato il mio modello con Amazon SageMaker, posso usarlo con 🤗/Transformers?

A: Sì, puoi scaricare il tuo modello addestrato da S3 e utilizzarlo direttamente con transformers o caricarlo nell’Hugging Face Model Hub.

Q: Come vengono protetti i miei dati e il mio codice da Amazon SageMaker?

A: Amazon SageMaker fornisce numerosi meccanismi di sicurezza, tra cui la crittografia a riposo e in transito, la connettività Virtual Private Cloud (VPC) e l’Identity and Access Management (IAM). Per saperne di più sulla sicurezza nel cloud AWS e su Amazon SageMaker, puoi visitare Security in Amazon SageMaker e AWS Cloud Security.

Q: Questo è disponibile nella mia regione?

A: Per un elenco delle regioni supportate, visita la tabella delle regioni AWS per tutta l’infrastruttura globale AWS.

Q: Devo pagare una licenza a Hugging Face per utilizzare i DLC?

A: No, i DLC di Hugging Face sono open source e con licenza Apache 2.0.

Q: Come posso eseguire l’inferenza sui miei modelli addestrati?

A: Hai diverse opzioni per eseguire l’inferenza sui tuoi modelli addestrati. Un’opzione è utilizzare il servizio ospitato Hugging Face Accelerated Inference-API: inizia caricando i modelli addestrati nel tuo account Hugging Face per distribuirli pubblicamente o privatamente. Un’altra ottima opzione è utilizzare SageMaker Inference per eseguire il tuo stesso codice di inferenza in Amazon SageMaker. Stiamo lavorando per offrire in futuro una soluzione integrata per Amazon SageMaker con i DLC di inferenza di Hugging Face: rimani sintonizzato!

Q: Offrite supporto premium o SLA di supporto per questa soluzione?

A: Sono disponibili i livelli di supporto tecnico AWS da AWS e coprono problemi di sviluppo e produzione per prodotti e servizi AWS: consulta AWS Support per i dettagli e la portata.

Se hai domande a cui la comunità di Hugging Face può aiutare a rispondere e/o beneficiare, pubblicale nel forum di Hugging Face.

Se hai bisogno di supporto premium dal team di Hugging Face per accelerare la tua roadmap di NLP, il nostro programma di accelerazione degli esperti offre una guida diretta dal nostro team di open source, scienza e ML Engineering: contattaci per saperne di più.

Q: Quali sono i vostri piani futuri attraverso questa partnership?

A: Il nostro obiettivo comune è democratizzare l’apprendimento automatico all’avanguardia. Continueremo a innovare per rendere più facile per ricercatori, scienziati dei dati e professionisti di ML gestire, addestrare ed eseguire modelli all’avanguardia. Se hai richieste di funzionalità per l’integrazione in AWS con Hugging Face, faccelo sapere nel forum della comunità di Hugging Face.

Q: Uso Hugging Face con Azure Machine Learning o Google Cloud Platform, cosa significa questa partnership per me?

A: Un obiettivo fondamentale per Hugging Face è rendere l’IA più accessibile possibile a quante più persone possibile, indipendentemente dal framework o dall’ambiente di sviluppo in cui lavorano. Mentre stiamo concentrando gli sforzi di integrazione con Amazon Web Services come nostro Preferred Cloud Provider, continueremo a lavorare duramente per servire tutti gli utenti e i clienti di Hugging Face, indipendentemente dall’ambiente di calcolo su cui operano.