Copilota personale addestra il tuo assistente di codifica

Guida personale per addestrare il tuo assistente di codifica

Nel paesaggio in continua evoluzione della programmazione e dello sviluppo software, la ricerca di efficienza e produttività ha portato a notevoli innovazioni. Una di queste innovazioni è l’emergere di modelli di generazione del codice come Codex, StarCoder e Code Llama. Questi modelli hanno dimostrato capacità notevoli nella generazione di frammenti di codice simili a quelli scritti dagli esseri umani, mostrando così un enorme potenziale come assistenti di codifica.

Tuttavia, mentre questi modelli preaddestrati possono ottenere prestazioni impressionanti in una serie di compiti, c’è una possibilità affascinante oltre l’orizzonte: la capacità di adattare un modello di generazione del codice alle proprie esigenze specifiche. Pensate ad assistenti di codifica personalizzati che potrebbero essere sfruttati su scala aziendale.

In questo articolo mostreremo come abbiamo creato HugCoder 🤗, un modello di codifica LLM ottimizzato sugli elementi di codice provenienti dai repository pubblici dell’organizzazione GitHub huggingface. Discuteremo il nostro flusso di lavoro per la raccolta dei dati, i nostri esperimenti di addestramento e alcuni risultati interessanti. Ciò vi consentirà di creare il vostro copilota personale basato sul vostro codice proprietario. Vi forniremo anche un paio di ulteriori estensioni di questo progetto per scopi sperimentali.

Cominciamo 🚀

• Potenziate le vostre soluzioni di marketing con Amazon Personalize e l’IA generativa
• Incontra Llemma il modello di linguaggio matematico di prossima generazione che supera i risultati attuali
• 2023 ACM-IEEE CS George Michael Memorial HPC Fellowship I destinatari sono stati nominati

Flusso di lavoro della raccolta dati

Il nostro dataset desiderato è concettualmente semplice, è strutturato come segue:

Scaricare i contenuti di codice da GitHub è semplice con l’aiuto del GitHub API di Python. Tuttavia, a seconda del numero di repository e del numero di file di codice presenti in un repository, potreste facilmente avere problemi di limitazione del tasso di API.

Per evitare tali problemi, abbiamo deciso di clonare tutti i repository pubblici localmente ed estrarre i contenuti da essi invece di farlo attraverso l’API. Abbiamo utilizzato il modulo multiprocessing di Python per scaricare tutti i repository in parallelo, come mostrato in questo script di download.

Un repository può contenere spesso file non di codice come immagini, presentazioni e altri elementi. Non siamo interessati a estrarli. Abbiamo creato un elenco di estensioni per filtrarli. Per analizzare i file di codice diversi dai quaderni Jupyter, abbiamo semplicemente utilizzato la codifica “utf-8”. Per i quaderni, abbiamo considerato solo le celle di codice.

Abbiamo anche escluso tutti i percorsi dei file che non erano direttamente correlati al codice. Questi includono: .git, __pycache__ e xcodeproj.

Per mantenere la serializzazione di questo contenuto relativamente “memory-friendly”, abbiamo utilizzato il concetto di “chunking” e il formato feather. Fare riferimento a questo script per l’implementazione completa.

Il dataset finale è disponibile sull’Hub, ed è così strutturato:

Per questo articolo consideriamo i primi 10 repository pubblici di Hugging Face, basati sul numero di stargazer. Essi sono i seguenti:

[‘transformers’, ‘pytorch-image-models’, ‘datasets’, ‘diffusers’, ‘peft’, ‘tokenizers’, ‘accelerate’, ‘text-generation-inference’, ‘chat-ui’, ‘deep-rl-class’]

Questo è il codice che abbiamo utilizzato per generare questo dataset, e questo è il dataset nell’Hub. Ecco uno snapshot di come appare:

Per ridurre la complessità del progetto, non abbiamo considerato la deduplicazione del dataset. Se sei interessato ad applicare tecniche di deduplicazione per un’applicazione di produzione, questo post del blog è una risorsa eccellente sull’argomento nel contesto di code LLM.

Affina il tuo Personal Co-Pilot

In questa sezione, mostriamo come affinare i seguenti modelli: bigcode/starcoder (15.5B parametri), bigcode/starcoderbase-1b (1B parametri), Deci/DeciCoder-1b (1B parametri). Utilizzeremo un singolo notebook Colab A100 40GB usando 🤗 PEFT (Parameter-Efficient Fine-Tuning) per tutti gli esperimenti. Inoltre, mostreremo come affinare completamente il bigcode/starcoder (15.5B parametri) su una macchina con 8 GPU A100 80GB utilizzando l’integrazione 🤗 Accelerate’s FSDP. L’obiettivo dell’addestramento è riempi nel mezzo (FIM), in cui parti di una sequenza di addestramento vengono spostate alla fine e la sequenza riordinata viene predetta auto-regressivamente.

Perché PEFT? L’affinamento completo è costoso. Vediamo alcuni numeri per mettere le cose in prospettiva:

Memoria GPU minima richiesta per l’affinamento completo:

1. Peso: 2 byte (addestramento a precisione mista)
2. Gradiente del peso: 2 byte
3. Stato dell’ottimizzatore quando si utilizza Adam: 4 byte per il peso FP32 originale + 8 byte per le stime del primo e secondo momento
4. Costo per parametro aggiungendo tutto quanto sopra: 16 byte per parametro
5. Modello da 15.5B -> 248GB di memoria GPU senza nemmeno considerare i grandi requisiti di memoria per memorizzare attivazioni intermedie -> richiesti almeno 4X A100 80GB GPU

Poiché i requisiti hardware sono enormi, utilizzeremo un affinamento efficiente dei parametri utilizzando QLoRA. Ecco i requisiti minimi di memoria GPU per l’affinamento di StarCoder utilizzando QLoRA:

parametri addestrabili: 110.428.160 || tutti i parametri: 15.627.884.544 || percentuale addestrabile: 0,7066097761926236

1. Peso del modello di base: 0,5 byte * 15,51B parametri congelati = 7,755 GB
2. Peso dell’adattatore: 2 byte * 0,11B parametri addestrabili = 0,22GB
3. Gradiente del peso: 2 byte * 0,11B parametri addestrabili = 0,12GB
4. Stato dell’ottimizzatore quando si utilizza Adam: 4 byte * 0,11B parametri addestrabili * 3 = 1,32GB
5. Aggiungendo tutto quanto sopra -> 9,51 GB ~10GB -> richiesta 1 GPU A100 40GB 🤯. Il motivo per cui è richiesta una GPU A100 40GB è che le attivazioni intermedie per lunghezze di sequenza di 2048 e dimensione batch di 4 per l’addestramento portano a requisiti di memoria più elevati. Come vedremo di seguito, la memoria GPU richiesta è di 26GB che può essere accolta su una GPU A100 40GB. Inoltre, le GPU A100 hanno una migliore compatibilità con Flash Attention 2.

Nelle precedenti calcolazioni, non abbiamo considerato la memoria richiesta per il controllo delle attivazioni intermedie, che è considerevolmente grande. Utilizziamo Flash Attention V2 e Gradient Checkpointing per superare questo problema.

1. Per QLoRA insieme a Flash Attention V2 e Gradient Checkpointing, la memoria totale occupata dal modello su una singola GPU A100 da 40 GB è di 26 GB con una dimensione del batch di 4.
2. Per il fine-tuning completo utilizzando FSDP insieme a Flash Attention V2 e Gradient Checkpointing, la memoria occupata per GPU varia tra 70 GB e 77,6 GB con una dimensione del batch per_gpu di 1.

Fai riferimento al uso della memoria del modello per calcolare facilmente quanta vRAM è necessaria per allenare e eseguire l’infrazione di un grande modello su un modello ospitato su 🤗 Hugging Face Hub.

Fine Tuning Completo

Esamineremo come eseguire il fine-tuning completo di bigcode/starcoder (15B di parametri) su 8 GPU A100 da 80 GB utilizzando la tecnica di Parallello Completo dei Dati Sharded di PyTorch (FSDP). Per ulteriori informazioni su FSDP, fare riferimento a Fine-tuning Llama 2 70B usando PyTorch FSDP e Accelerare la formazione di modelli di grandi dimensioni utilizzando il Parallello Completo dei Dati Sharded di PyTorch.

Risorse

1. Codebase: link. Utilizza il supporto Flash Attention V2 recentemente aggiunto in Transformers.
2. Configurazione FSDP: fsdp_config.yaml
3. Modello: bigcode/stacoder
4. Dataset: smangrul/hf-stack-v1
5. Modello Fine-tuned: smangrul/peft-lora-starcoder15B-v2-personal-copilot-A100-40GB-colab

Il comando per avviare l’addestramento è fornito al seguente link.

accelerate launch --config_file "configs/fsdp_config.yaml"  train.py \    --model_path "bigcode/starcoder" \    --dataset_name "smangrul/hf-stack-v1" \    --subset "data" \    --data_column "content" \    --split "train" \    --seq_length 2048 \    --max_steps 2000 \    --batch_size 1 \    --gradient_accumulation_steps 2 \    --learning_rate 5e-5 \    --lr_scheduler_type "cosine" \    --weight_decay 0.01 \    --num_warmup_steps 30 \    --eval_freq 100 \    --save_freq 500 \    --log_freq 25 \    --num_workers 4 \    --bf16 \    --no_fp16 \    --output_dir "starcoder-personal-copilot-A100-40GB-colab" \    --fim_rate 0.5 \    --fim_spm_rate 0.5 \    --use_flash_attn

Il tempo totale di addestramento è stato di 9 ore. Considerando il costo di $12.00 / ora basato su lambdalabs per 8 GPU A100 da 80 GB, il costo totale sarebbe di $108.

PEFT

Esamineremo come utilizzare QLoRA per affinare ulteriormente bigcode/starcoder (15B di parametri) su una singola GPU A100 da 40 GB usando 🤗 PEFT. Per ulteriori informazioni sui metodi QLoRA e PEFT, fare riferimento a Rendere gli LLM ancora più accessibili con bitsandbytes, quantizzazione a 4 bit e QLoRA e 🤗 PEFT: Affinamento efficiente dei parametri dei modelli su larga scala su hardware a bassa risorsa.

Risorse

1. Codice sorgente: link. Utilizza il supporto di Flash Attention V2 recentemente aggiunto in Transformers.
2. Notebook di Colab: link. Assicurarsi di scegliere la GPU A100 con impostazioni di RAM elevate.
3. Modello: bigcode/stacoder
4. Insieme di dati: smangrul/hf-stack-v1
5. Modello affinato QLoRA: smangrul/peft-lora-starcoder15B-v2-personal-copilot-A100-40GB-colab

Il comando per avviare l’addestramento è presente in run_peft.sh. Il tempo totale di addestramento è stato di 12,5 ore. Considerando il costo di $1,10 / ora basato su lambdalabs, il costo totale sarà di $13,75. Molto buono 🚀! In termini di costo, è 7,8 volte inferiore rispetto al costo per un completo affinamento.

Confronto

Il grafico seguente mostra la perdita di valutazione, la perdita di addestramento e il programmatore del tasso di apprendimento per QLoRA rispetto all’affinamento completo. Osserviamo che l’affinamento completo porta a una leggermente inferiore perdita e converge un po’ più velocemente rispetto a QLoRA. Il tasso di apprendimento per l’affinamento di PEFT è 10 volte superiore a quello dell’affinamento completo.

Per assicurarci che il nostro modello QLoRA non conduca a un dimenticamento catastrofico, eseguiamo la valutazione umana in Python. Di seguito riportiamo i risultati ottenuti. Pass@1 misura il tasso di riuscita delle completamenti considerando solo un candidato di codice generato per problema. Possiamo notare che le prestazioni su humaneval-python sono comparabili tra la base bigcode/starcoder (15B di parametri) e il modello PEFT affinato smangrul/peft-lora-starcoder15B-v2-personal-copilot-A100-40GB-colab.

Esaminiamo ora alcuni esempi qualitativi. Nella nostra analisi manuale, abbiamo notato che QLoRA ha portato a un leggero overfitting e per questo lo riduciamo di peso creando un nuovo adattatore pesato con peso 0.8 tramite l’utilità add_weighted_adapter di PEFT.

Esamineremo 2 esempi di completamento di codice in cui il compito del modello è completare la parte indicata dal segnaposto <FILL_ME>. Considereremo completamenti di infilling da GitHub Copilot, dal modello QLoRA affinato e dal modello affinato completo.

Esempio qualitativo 1

Nell’esempio precedente, il completamento da GitHub Copilot è sulla strada giusta ma non è molto utile. D’altra parte, i completamenti da QLoRA e dai modelli completamente aggiustati riempiono correttamente l’intera chiamata di funzione con i parametri necessari. Tuttavia, aggiungono anche molto più rumore successivamente. Questo potrebbe essere controllato con un passaggio di post-elaborazione per limitare i completamenti a parentesi chiuse o nuove righe. Si noti che sia QLoRA che i modelli completamente aggiustati producono risultati di qualità simile.

Esempio qualitativo 2

Nel secondo esempio precedente, GitHub Copilot non ha dato alcun completamento. Questo può essere dovuto al fatto che 🤗 PEFT è una libreria recente e ancora non fa parte dei dati di addestramento di Copilot, il che è esattamente il tipo di problema che stiamo cercando di affrontare. D’altra parte, i completamenti da QLoRA e dai modelli completamente aggiustati riempiono correttamente l’intera chiamata di funzione con i parametri necessari. Di nuovo, si noti che sia QLoRA che i modelli completamente aggiustati stanno dando generazioni di qualità simile. Il codice di inferenza con vari esempi per il modello completamente aggiustato e il modello PEFT è disponibile rispettivamente all’indirizzo Full_Finetuned_StarCoder_Inference.ipynb e PEFT_StarCoder_Inference.ipynb .

Pertanto, possiamo osservare che le generazioni da entrambe le varianti sono conformi alle aspettative. Fantastico! 🚀

Come posso usarlo in VS Code?

Puoi facilmente configurare un LLM di completamento del codice personalizzato in VS Code utilizzando 🤗 llm-vscode Estensione VS Code, insieme all’hosting del modello tramite 🤗 Inference EndPoints. Vedremo i passaggi necessari di seguito. Puoi trovare ulteriori dettagli su come distribuire un punto di accesso nella documentazione dei punti di accesso di inferenza.

Impostare un punto di accesso di inferenza

Di seguito sono riportate le schermate con i passaggi che abbiamo seguito per creare il nostro punto di accesso di inferenza personalizzato. Abbiamo utilizzato il nostro modello QLoRA, esportato come un modello unito di dimensioni complete che può essere facilmente caricato in transformers.

Configurazione dell’estensione VS Code

Basta seguire i passaggi di installazione. Nelle impostazioni, sostituisci il punto di accesso nel campo sottostante, in modo che punti al punto di accesso di inferenza di HF che hai distribuito.

L’utilizzo apparirà come segue:

Fino ad ora, i modelli che abbiamo addestrato sono stati specificamente addestrati come assistenti personali per il completamento del codice. Non sono addestrati per svolgere conversazioni o per rispondere alle domande. Octocoder e StarChat sono ottimi esempi di tali modelli. Questa sezione descrive brevemente come raggiungere questo obiettivo.

Risorse

1. Codebase: link. Utilizza il supporto Flash Attention V2 recentemente aggiunto nei Transformers.
2. Quaderno di Colab: link. Assicurati di scegliere la GPU A100 con impostazione High RAM.
3. Modello: bigcode/stacoderplus
4. Dataset: smangrul/code-chat-assistant-v1. Mix di LIMA+GUANACO con formattazione corretta in un formato pronto per il training.
5. Modello addestrato: smangrul/peft-lora-starcoderplus-chat-asst-A100-40GB-colab

Se hai sperimentato con modelli Stable Diffusion e LoRA per creare i tuoi modelli Dreambooth, potresti essere familiare con i concetti di combinazione di diversi LoRA con diversi pesi, usando un modello LoRA con un modello di base diverso rispetto a quello su cui è stato addestrato. Nel dominio del testo/codice, questo rimane un territorio inesplorato. Abbiamo condotto esperimenti al riguardo e abbiamo osservato risultati molto promettenti. Sei pronto? Andiamo! 🚀

Combina e Abbinare LoRA

PEFT supporta attualmente 3 modi per combinare i modelli LoRA, linear, svd e cat. Per ulteriori dettagli, consulta tuners#peft.LoraModel.add_weighted_adapter.

Il nostro quaderno Dance_of_LoRAs.ipynb include tutto il codice di inferenza e varie combinazioni di caricamento di LoRA, come il caricamento dell’assistente chat su starcoder invece di starcodeplus, che è il modello di base su cui l’abbiamo addestrato.

Qui, considereremo 2 abilità (chatting/QA e code-completion) su 2 distribuzioni di dati (top 10 codici pubblici hf e generic codebase). Ciò ci offre 4 assi su cui effettueremo alcune analisi qualitative di valutazione.

Innanzitutto, consideriamo il compito chatting/QA.

Se disabilitiamo gli adapter, osserviamo che il compito fallisce per entrambi i dataset, in quanto il modello di base (starcoder) è destinato solo al completamento del codice e non adatto al chatting/question-answering. Abilitare l’adapter copilot produce risultati simili al caso disabilitato perché anche questo LoRA è stato specificamente addestrato per il completamento del codice.

Ora, abilitiamo l’adapter assistant.

Risposta a domande basate su codice generico

Risposta a domande basate su codice HF

Possiamo osservare che le domande generiche relative a scrapy vengono risposte correttamente. Tuttavia, falliscono per le domande relative al codice HF che non facevano parte dei dati di pretraining.

Consideriamo ora il compito di code-completion.

Disabilitando gli adapter, osserviamo che il completamento del codice per la funzione generica two-sum funziona come previsto. Tuttavia, il completamento del codice HF fallisce con parametri errati per LoraConfig, perché il modello di base non li ha mai visti nei dati di pretraining. Abilitare l’adapter assistant produce risultati simili al caso disabilitato in quanto è stato addestrato su conversazioni in linguaggio naturale che non contenevano repository di codice di Hugging Face.

Ora, abilitiamo l’adattatore copilot.

Possiamo osservare che l’adattatore copilot funziona correttamente in entrambi i casi. Pertanto, si comporta come previsto per il completamento del codice quando si lavora con un codebase specifico HF così come con codebase generici.

Adesso, come utente, desidero combinarlo con le capacità dell’ assistant così come del copilot. Ciò mi consentirà di utilizzarlo per il completamento del codice durante la programmazione in un IDE e di farne un chatbot per rispondere alle mie domande riguardo alle API, classi, metodi e documentazione. Dovrebbe essere in grado di fornire risposte a domande come “Come utilizzo x” o “Scrivi un frammento di codice per Y” nel mio codebase.

PEFT ti consente di farlo tramite l’aggiunta di add_weighted_adapter. Creiamo un nuovo adattatore chiamato code_buddy con lo stesso peso per gli adattatori assistant e copilot.

Combinazione di più adattatori

Adesso, vediamo come si comporta code_buddy nei compiti di chatting e question_answering.

Possiamo osservare che code_buddy si comporta molto meglio rispetto agli adattatori assistant o copilot da soli! È in grado di rispondere alla richiesta di un frammento di codice per mostrare come utilizzare una specifica API di HF. Tuttavia, storpia anche i link/spiegazioni sbagliate, che rimane una sfida aperta per LLM.

Ecco le prestazioni di code_buddy nei compiti di completamento del codice.

Possiamo osservare che code_buddy si comporta allo stesso livello del copilot, che è stato specificamente ottimizzato per questo compito.

Trasferimento dei LoRAs su diversi base model

Possiamo anche trasferire i modelli LoRA su diversi base model. Prenderemo il modello Octocoder, appena pubblicato, e applicheremo su di esso il LoRA che abbiamo addestrato in precedenza con il modello base starcoder. Si prega di consultare il seguente notebook PEFT_Personal_Code_CoPilot_Adapter_Transfer_Octocoder.ipynb per l’intero codice.

Prestazioni nel compito di completamento del codice

Possiamo osservare che octocoder si comporta molto bene. È in grado di completare frammenti di codice specifici di HF. È anche in grado di completare frammenti di codice generici, come mostrato nel notebook.

Prestazioni nel compito di chat/QA

Poiché Octocoder è stato addestrato per rispondere alle domande e svolgere conversazioni sulla programmazione, vediamo se può utilizzare il nostro adattatore LoRA per rispondere alle domande specifiche di HF.

Yay! Risponde correttamente in dettaglio su come creare LoraConfig e il modello PEFT correlato, utilizzando correttamente il nome del modello, il nome del dataset e i valori dei parametri di LoraConfig. Se si disabilita l’adattatore, non riesce ad utilizzare correttamente l’API di LoraConfig o a creare un modello PEFT, suggerendo che non fa parte dei dati di addestramento di Octocoder.

Lo so, dopo tutto questo, vuoi ottimizzare starcoder sul tuo codice e usarlo localmente sul tuo hardware di consumo come i laptop Mac con GPU M1, i computer Windows con GPU RTX 4090/3090 … Non preoccuparti, abbiamo pensato a tutto.

Utilizzeremo questa libreria open source super cool mlc-llm🔥. In particolare, utilizzeremo questo fork pacman100/mlc-llm che ha le modifiche per farlo funzionare con l’estensione di completamento del codice Hugging Face per VS Code. Sul mio laptop Mac con GPU Metal M1, il modello da 15B era estremamente lento. Quindi, andremo con una versione più piccola e addestreremo una versione PEFT LoRA e una versione completamente ottimizzata di bigcode/starcoderbase-1b. I notebook di addestramento di Colab sono collegati di seguito:

1. Notebook di Colab per l’ottimizzazione completa e l’ottimizzazione PEFT LoRA di starcoderbase-1b: link

Di seguito sono rappresentate le perdite di addestramento, le perdite di valutazione e le pianificazioni dei tassi di apprendimento:

Ora, vedremo i passaggi dettagliati per ospitare localmente il modello unito smangrul/starcoder1B-v2-personal-copilot-merged e usarlo con l’estensione 🤗 llm-vscode di VS Code.

1. Clona il repository

git clone --recursive https://github.com/pacman100/mlc-llm.git && cd mlc-llm/

1. Installa mlc-ai e mlc-chat (in modalità modificabile):

pip install --pre --force-reinstall mlc-ai-nightly mlc-chat-nightly -f https://mlc.ai/wheelscd pythonpip uninstall mlc-chat-nightlypip install -e "."

1. Compila il modello tramite:

time python3 -m mlc_llm.build --hf-path smangrul/starcoder1B-v2-personal-copilot-merged --target metal  --use-cache=0

1. Aggiorna la configurazione con i seguenti valori in dist/starcoder1B-v2-personal-copilot-merged-q4f16_1/params/mlc-chat-config.json:

{    "model_lib": "starcoder7B-personal-copilot-merged-q4f16_1",    "local_id": "starcoder7B-personal-copilot-merged-q4f16_1",    "conv_template": "code_gpt",-    "temperature": 0.7,+    "temperature": 0.2,-    "repetition_penalty": 1.0,    "top_p": 0.95,-    "mean_gen_len": 128,+    "mean_gen_len": 64,-    "max_gen_len": 512,+    "max_gen_len": 64,     "shift_fill_factor": 0.3,    "tokenizer_files": [        "tokenizer.json",        "merges.txt",        "vocab.json"    ],    "model_category": "gpt_bigcode",    "model_name": "starcoder1B-v2-personal-copilot-merged"}

1. Esegui il server locale:

 python -m mlc_chat.rest --model dist/starcoder1B-v2-personal-copilot-merged-q4f16_1/params --lib-path dist/starcoder1B-v2-personal-copilot-merged-q4f16_1/starcoder1B-v2-personal-copilot-merged-q4f16_1-metal.so

1. Cambia il punto di arrivo dell’estensione HF Code Completion in VS Code in modo che punti al server locale:

1. Apri un nuovo file in VS code, incolla il codice qui sotto e posiziona il cursore tra le virgolette, in modo che il modello cerchi di completare la stringa di documentazione:

Voilà! ⭐️

La demo all’inizio di questo post è eseguita localmente sul mio laptop Mac con il modello da 1B.

Conclusione

In questo post del blog, abbiamo visto come perfezionare starcoder per creare un assistente personale che conosce il nostro codice. L’abbiamo chiamato 🤗 HugCoder, poiché lo abbiamo addestrato sul codice di Hugging Face 🙂 Dopo aver analizzato il flusso di raccolta dati, abbiamo confrontato l’addestramento utilizzando QLoRA con il fine-tuning completo. Abbiamo anche sperimentato combinando diverse LoRA, che è ancora una tecnica inesplorata nel dominio del testo/codice. Per il deployment, abbiamo esaminato l’inferenza remota utilizzando gli 🤗 Inference Endpoints e abbiamo anche mostrato l’esecuzione on-device di un modello più piccolo con VS Code e MLC.

Per favore, fateci sapere se utilizzate questi metodi per la vostra base di codice!

Ringraziamenti

Vorremmo ringraziare Pedro Cuenca, Leandro von Werra, Benjamin Bossan, Sylvain Gugger e Loubna Ben Allal per il loro aiuto nella stesura di questo post del blog.