Effettuare il deploy di Falcon-7B in produzione

'Deployare Falcon-7B in produzione'

Un tutorial passo-passo

Eseguire Falcon-7B nel cloud come microservizio

Contesto

Finora, abbiamo visto le capacità di ChatGPT e ciò che offre. Tuttavia, per l’uso aziendale, modelli closed-source come ChatGPT possono rappresentare un rischio poiché le aziende non hanno controllo sui loro dati. OpenAI afferma che i dati degli utenti non vengono archiviati o utilizzati per addestrare i modelli, ma non c’è garanzia che i dati non possano essere divulgati in qualche modo.

Per contrastare alcuni dei problemi legati ai modelli closed-source, i ricercatori si stanno affrettando a costruire LLM open-source che possano competere con modelli come ChatGPT. Con modelli open-source, le aziende possono ospitare i modelli stessi in un ambiente cloud sicuro, riducendo il rischio di perdita di dati. Inoltre, si ottiene piena trasparenza sulle modalità di funzionamento del modello, il che aiuta a costruire maggiore fiducia nell’IA in generale.

Con i recenti progressi nei LLM open-source, è tentante provare nuovi modelli e vedere come si confrontano con modelli closed-source come ChatGPT.

Tuttavia, eseguire modelli open-source oggi presenta significativi ostacoli. È molto più facile chiamare l’API di ChatGPT che capire come eseguire un LLM open-source.

• Sfida di classificazione del testo con dataset extra-piccoli affinamento versus ChatGPT
• Apprendimento di operatori tramite Physics-Informed DeepONet Implementiamolo da zero
• Migliora la moderazione dei contenuti con l’API di Moderazione di OpenAI

In questo articolo, il mio obiettivo è superare questi ostacoli mostrando come è possibile eseguire modelli open-source come il modello Falcon-7B nel cloud in un ambiente simile a quello di produzione. Saremo in grado di accedere a questi modelli tramite un endpoint API simile a quello di ChatGPT.

Sfide

Una delle sfide principali per l’esecuzione di modelli open-source è la mancanza di risorse di calcolo. Anche un “piccolo” modello come Falcon 7B richiede una GPU per essere eseguito.

Per risolvere questo problema, possiamo sfruttare le GPU nel cloud. Ma questo pone un’altra sfida. Come containerizzare il nostro LLM? Come abilitare il supporto GPU? Abilitare il supporto GPU può essere complicato perché richiede conoscenze di CUDA. Lavorare con CUDA può essere un problema perché è necessario capire come installare le dipendenze CUDA corrette e quali versioni sono compatibili.

Quindi, per evitare la trappola della morte di CUDA, molte aziende hanno creato soluzioni per containerizzare facilmente i modelli abilitando il supporto GPU. Per questo post del blog, useremo un tool open-source chiamato Truss per aiutarci a containerizzare facilmente il nostro LLM senza troppi problemi.

Truss consente agli sviluppatori di containerizzare facilmente modelli creati utilizzando qualsiasi framework.

Perché usare Truss?

Truss ha molte funzionalità utili già integrate, come:

• Trasformare il tuo modello Python in un microservizio con un endpoint API pronto per la produzione
• Congelamento delle dipendenze tramite Docker
• Supporto all’elaborazione su GPU
• Pre-elaborazione e post-elaborazione semplici per il modello
• Gestione semplice e sicura dei segreti

Ho già utilizzato Truss per distribuire modelli di machine learning e il processo è piuttosto fluido e semplice. Truss crea automaticamente il tuo dockerfile e gestisce le dipendenze Python. Tutto quello che dobbiamo fare è fornire il codice per il nostro modello.

Il motivo principale per cui vogliamo utilizzare uno strumento come Truss è che diventa molto più facile distribuire il nostro modello con il supporto GPU.

Nota: Non ho ricevuto alcun sponsorizzazione da Baseten per promuovere i loro contenuti né sono associato a loro in alcun modo. Non sono influenzato in alcun modo da Baseten o Truss per scrivere questo articolo. Ho semplicemente trovato il loro progetto open-source interessante e utile.

Il piano

Ecco cosa tratterò in questo post del blog:

1. Configurazione locale di Falcon 7B usando Truss
2. Esecuzione del modello in locale se si dispone di una GPU (io ho una RTX 3080)
3. Creazione di un container per il modello e esecuzione usando Docker
4. Creazione di un cluster Kubernetes abilitato alla GPU su Google Cloud per eseguire il nostro modello

Non preoccuparti se non hai una GPU per il passaggio 2, sarai comunque in grado di eseguire il modello nel cloud.

Ecco il repository Github contenente il codice se vuoi seguirmi:

GitHub – htrivedi99/falcon-7b-truss

Contribuisci allo sviluppo di htrivedi99/falcon-7b-truss creando un account su GitHub.

github.com

Cominciamo!

Passaggio 1: Configurazione locale di Falcon 7B usando Truss

Prima di tutto, dovremo creare un progetto con una versione di Python ≥ 3.8

Scaricheremo il modello da Hugging Face e lo confezioneremo usando Truss. Ecco le dipendenze che dovremo installare:

pip install truss

All’interno del tuo progetto Python crea uno script chiamato main.py. Questo è uno script temporaneo che useremo per lavorare con Truss.

Successivamente, configureremo il nostro pacchetto Truss eseguendo il seguente comando nel terminale:

truss init falcon_7b_truss

Se ti viene chiesto di creare un nuovo truss, premi ‘y’. Una volta completato, dovresti vedere una nuova directory chiamata falcon_7b_truss. All’interno di quella directory, ci saranno alcuni file e cartelle generati automaticamente. Ci sono un paio di cose che dobbiamo compilare: model.py che è annidato sotto il pacchetto model e config.yaml.

├── falcon_7b_truss│   ├── config.yaml│   ├── data│   ├── examples.yaml│   ├── model│   │   ├── __init__.py│   │   └── model.py│   └── packages└── main.py

Come ho già detto, Truss ha bisogno solo del codice del nostro modello, si occupa di tutto il resto automaticamente. Scriveremo il codice all’interno di model.py, ma dovrà essere scritto in un formato specifico.

Truss si aspetta che ogni modello supporti almeno tre funzioni: __init__, load e predict.

• __init__ viene utilizzato principalmente per creare variabili di classe
• load è dove scaricheremo il modello da Hugging Face
• predict è dove chiameremo il nostro modello

Ecco il codice completo per model.py:

import torchfrom transformers import AutoTokenizer, AutoModelForCausalLM, pipelinefrom typing import DictMODEL_NAME = "tiiuae/falcon-7b-instruct"DEFAULT_MAX_LENGTH = 128class Model:    def __init__(self, data_dir: str, config: Dict, **kwargs) -> None:        self._data_dir = data_dir        self._config = config        self.device = "cuda" if torch.cuda.is_available() else "cpu"        print("IL DISPOSITIVO SU CUI VIENE ESEGUITA L'INFERENZA È: ", self.device)        self.tokenizer = None        self.pipeline = None    def load(self):        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)        model_8bit = AutoModelForCausalLM.from_pretrained(            MODEL_NAME,            device_map="auto",            load_in_8bit=True,            trust_remote_code=True)        self.pipeline = pipeline(            "text-generation",            model=model_8bit,            tokenizer=self.tokenizer,            torch_dtype=torch.bfloat16,            trust_remote_code=True,            device_map="auto",        )    def predict(self, request: Dict) -> Dict:        with torch.no_grad():            try:                prompt = request.pop("prompt")                data = self.pipeline(                    prompt,                    eos_token_id=self.tokenizer.eos_token_id,                    max_length=DEFAULT_MAX_LENGTH,                    **request                )[0]                return {"data": data}            except Exception as exc:                return {"status": "error", "data": None, "message": str(exc)}

Cosa sta succedendo qui:

• MODEL_NAME è il modello che useremo, nel nostro caso è il modello falcon-7b-instruct
• All’interno di load, scarichiamo il modello da Hugging Face in 8 bit. Il motivo per cui vogliamo 8 bit è che il modello utilizza significativamente meno memoria sulla nostra GPU quando è quantizzato.
• Inoltre, caricare il modello in 8 bit è necessario se si desidera eseguire il modello localmente su una GPU con meno di 13 GB di VRAM.
• La funzione predict accetta una richiesta JSON come parametro e chiama il modello usando self.pipeline. Il comando torch.no_grad indica a Pytorch che siamo in modalità inferenza, non in modalità di addestramento.

Fantastico! Abbiamo configurato il nostro modello.

Passaggio 2: Eseguire il modello in locale (Opzionale)

Se si dispone di una GPU Nvidia con più di 8 GB di VRAM, è possibile eseguire questo modello in locale.

Se non lo si ha, è possibile passare al passaggio successivo.

Dovremo scaricare altre dipendenze per eseguire il modello in locale. Prima di scaricare le dipendenze, assicurarsi di avere CUDA e i driver CUDA corretti installati.

Poiché stiamo cercando di eseguire il modello in locale, Truss non potrà aiutarci a gestire la follia di CUDA.

pip install transformerspip install torchpip install peftpip install bitsandbytespip install einopspip install scipy 

Successivamente, all’interno di main.py, lo script che abbiamo creato al di fuori della directory falcon_7b_truss, dobbiamo caricare la nostra trave.

Ecco il codice per main.py:

import trussfrom pathlib import Pathimport requeststr = truss.load("./falcon_7b_truss")output = tr.predict({"prompt": "Ciao come stai?"})print(output)

Cosa sta succedendo qui:

• Se ricordi, la directory falcon_7b_truss è stata creata da Truss. Possiamo caricare l’intero pacchetto, compreso il modello e le dipendenze, utilizzando truss.load
• Una volta caricato il pacchetto, possiamo semplicemente chiamare il metodo predict per ottenere l’output del modello

Esegui main.py per ottenere l’output del modello.

Questi file del modello sono di dimensioni di circa 15 GB, quindi potrebbe richiedere da 5 a 10 minuti per scaricare il modello. Dopo aver eseguito lo script, dovresti vedere un output del genere:

{'data': {'generated_text': "Ciao come stai?\nSto bene. Sono in mezzo a un trasloco, quindi sono un po' stanco. Sono anche un po' sopraffatto. Non so come iniziare. Non so cosa sto facendo. Non so se lo sto facendo bene. Non so se lo sto facendo male. Non so se lo sto facendo affatto.\nNon so se lo sto facendo bene. Non so se lo sto facendo male. Non"}}

Passaggio 3: Containerizzare il modello usando Docker

Di solito, quando si containerizza un modello, si prende il binario del modello e le dipendenze Python e si avvolge il tutto utilizzando un server Flask o Fast API.

Gran parte di questo è ridondante e non vogliamo farlo noi stessi. Truss si occuperà di tutto. Abbiamo già fornito il modello, Truss creerà il server, quindi l’unica cosa rimasta da fare è fornire le dipendenze Python.

Il file config.yaml contiene la configurazione per il nostro modello. Qui possiamo aggiungere le dipendenze per il nostro modello. Il file di configurazione già contiene la maggior parte delle cose di cui abbiamo bisogno, ma dobbiamo aggiungerne alcune.

Ecco cosa devi aggiungere a config.yaml:

apply_library_patches: truebundled_packages_dir: packagesdata_dir: datadescription: nullenvironment_variables: {}examples_filename: examples.yamlexternal_package_dirs: []input_type: Anylive_reload: falsemodel_class_filename: model.pymodel_class_name: Modelmodel_framework: custommodel_metadata: {}model_module_dir: modelmodel_name: Falcon-7Bmodel_type: custompython_version: py39requirements:- torch- peft- sentencepiece- accelerate- bitsandbytes- einops- scipy- git+https://github.com/huggingface/transformers.gitresources:  use_gpu: true  cpu: "3"  memory: 14Gisecrets: {}spec_version: '2.0'system_packages: []

Quindi la cosa principale che abbiamo aggiunto è il requirements. Tutte le dipendenze elencate sono necessarie per scaricare ed eseguire il modello.

L’altra cosa importante che abbiamo aggiunto è il resources. Il use_gpu: true è essenziale, perché questo dice a Truss di creare un Dockerfile per noi con il supporto GPU abilitato.

Questo è tutto per la configurazione.

Successivamente, containerizzeremo il nostro modello. Se non sai come containerizzare un modello usando Docker, non preoccuparti, Truss ti copre.

All’interno del file main.py, diremo a Truss di imballare tutto insieme. Ecco il codice che ti serve:

import truss
from pathlib import Path
import requests

str = truss.load("./falcon_7b_truss")
command = tr.docker_build_setup(build_dir=Path("./falcon_7b_truss"))
print(command)

Cosa sta succedendo:

• Prima di tutto, carichiamo il nostro falcon_7b_truss
• Successivamente, la funzione docker_build_setup si occupa di tutte le cose complicate come la creazione del Dockerfile e la configurazione del server Fast API.
• Se guardi la tua directory falcon_7b_truss, vedrai che sono stati generati molti altri file. Non dobbiamo preoccuparci di come funzionano questi file perché tutto verrà gestito dietro le quinte.
• Alla fine dell’esecuzione, otteniamo un comando docker per creare la nostra immagine docker: docker build falcon_7b_truss -t falcon-7b-model:latest

Se vuoi creare l’immagine docker, esegui il comando di compilazione. L’immagine ha una dimensione di ~ 9 GB, quindi potrebbe richiedere del tempo per la compilazione. Se non vuoi costruirla ma vuoi seguirne la procedura, puoi usare la mia immagine: htrivedi05/truss-falcon-7b:latest.

Se stai costruendo l’immagine tu stesso, dovrai etichettarla e caricarla su Docker Hub in modo che i nostri contenitori nel cloud possano scaricare l’immagine. Ecco i comandi che dovrai eseguire una volta che l’immagine è stata creata:

docker tag falcon-7b-model <docker_user_id>/falcon-7b-model

docker push <docker_user_id>/falcon-7b-model

Fantastico! Siamo pronti per eseguire il nostro modello nel cloud!

(Passaggi opzionali di seguito per eseguire l’immagine localmente con una GPU)

Se hai una GPU Nvidia e vuoi eseguire il tuo modello containerizzato localmente con il supporto GPU, devi assicurarti che Docker sia configurato per utilizzare la tua GPU.

Apri un terminale e esegui i seguenti comandi:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID) && curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - && curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

apt-get updateapt-get install -y nvidia-docker2

sudo systemctl restart docker

Ora che Docker è stato configurato per accedere alla tua GPU, ecco come eseguire il tuo contenitore:

docker run --gpus all -d -p 8080:8080 falcon-7b-model

Di nuovo, ci vorrà un po’ di tempo per scaricare il modello. Per assicurarti che tutto funzioni correttamente, controlla i log del contenitore e dovresti vedere “THE DEVICE INFERENCE IS RUNNING ON IS: cuda”.

Puoi chiamare il modello tramite un endpoint API in questo modo:

import requests

data = {"prompt": "Ciao, come va?"}
res = requests.post("http://127.0.0.1:8080/v1/models/model:predict", json=data)
print(res.json())

Passo 4: Distribuire il modello in produzione

Sto usando la parola “produzione” in modo abbastanza generico qui. Eseguiremo il nostro modello in Kubernetes dove può facilmente scalare e gestire quantità variabili di traffico.

Detto questo, Kubernetes ha un sacco di configurazioni come le politiche di rete, lo storage, le mappe di configurazione, il bilanciamento del carico, la gestione dei segreti, ecc.

Anche se Kubernetes è progettato per “scalare” ed eseguire carichi di lavoro “in produzione”, molte delle configurazioni di livello di produzione di cui hai bisogno non sono disponibili di default. Coprire questi argomenti avanzati di Kubernetes esce dallo scopo di questo articolo e distoglie l’attenzione da ciò che stiamo cercando di realizzare qui. Quindi per questo post, creeremo un cluster minimale senza fronzoli.

Senza ulteriori indugi, creiamo il nostro cluster!

Prerequisiti:

1. Avere un account Google Cloud con un progetto
2. Avere il CLI gcloud installato sul tuo computer
3. Assicurati di avere abbastanza quota per eseguire una macchina abilitata alla GPU. Puoi controllare le tue quote in IAM & Admin.

Creazione del nostro cluster GKE

Utilizzeremo il motore Kubernetes di Google per creare e gestire il nostro cluster. Ok, è ora di alcune informazioni IMPORTANTI:

Il motore Kubernetes di Google non è gratuito. Google non ci permetterà di utilizzare una potente GPU gratuitamente. Detto questo, stiamo creando un cluster a nodo singolo con una GPU meno potente. Non dovrebbe costarti più di $1-$2 per questo esperimento.

Ecco la configurazione del cluster Kubernetes che eseguiremo:

• 1 nodo, cluster Kubernetes standard (non autopilot)
• 1 GPU Nvidia T4
• macchina n1-standard-4 (4 vCPU, 15 GB di memoria)
• Tutto questo sarà eseguito su un’istanza spot

Nota: Se ti trovi in un’altra regione e non hai accesso alle stesse risorse, sentiti libero di apportare modifiche.

Passaggi per creare il cluster:

1. Vai alla console di Google Cloud e cerca il servizio chiamato Kubernetes Engine

2. Fai clic sul pulsante CREA

• Assicurati di creare un cluster standard, non un cluster autopilot. Dovrebbe dire Crea un cluster Kubernetes in alto.

3. Informazioni di base sul cluster

• All’interno della scheda informazioni di base sul cluster, non vogliamo cambiare molto. Assegna semplicemente un nome al tuo cluster. Non è necessario modificare la zona o il control plane.

4. Fai clic sulla scheda default-pool e cambia il numero di nodi su 1

5. Sotto default-pool, fai clic sulla scheda Nodi nella barra laterale sinistra

• Cambia la Configurazione della macchina da General Purpose a GPU
• Seleziona il tipo di GPU Nvidia T4 e imposta 1 per la quantità
• Abilita la condivisione della GPU (anche se non useremo questa funzionalità)
• Imposta il Numero massimo di client condivisi per GPU su 8
• Per il Tipo di macchina, seleziona il n1-standard-4 (4 vCPU, 15 GB di memoria)
• Cambia la Dimensione del disco di avvio su 50
• Scorri fino in fondo e seleziona la casella di controllo che dice: Abilita i nodi su VM spot

Ecco uno screenshot del prezzo stimato che ho ottenuto per questo cluster:

Una volta configurato il cluster, procedi con la creazione.

Ci vorranno alcuni minuti per impostare tutto su Google. Dopo che il tuo cluster sarà attivo ed in funzione, dovremo connetterci ad esso. Apri il tuo terminale ed esegui i seguenti comandi:

gcloud config set compute/zone us-central1-c

gcloud container clusters get-credentials gpu-cluster-1

Se hai utilizzato una diversa zona o nome del cluster, aggiorna di conseguenza. Per verificare la connessione, esegui il seguente comando:

kubectl get nodes

Dovresti vedere apparire 1 nodo nel tuo terminale. Anche se il nostro cluster ha una GPU, mancano alcuni driver Nvidia che dovremo installare. Fortunatamente, l’installazione è semplice. Esegui il seguente comando per installare i driver:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Perfetto! Siamo finalmente pronti per distribuire il nostro modello.

Distribuzione del modello

Per distribuire il nostro modello sul cluster, dobbiamo creare un deployment Kubernetes. Un deployment Kubernetes ci consente di gestire le istanze del nostro modello containerizzato. Non mi addentrerò troppo in Kubernetes o su come scrivere file yaml poiché esce dallo scopo.

È necessario creare un file chiamato truss-falcon-deployment.yaml. Apri quel file e incolla il seguente contenuto:

apiVersion: apps/v1kind: Deploymentmetadata:  name: truss-falcon-7b  namespace: defaultspec:  replicas: 1  selector:    matchLabels:      component: truss-falcon-7b-layer  template:    metadata:      labels:        component: truss-falcon-7b-layer    spec:      containers:      - name: truss-falcon-7b-container        image: <your_docker_id>/falcon-7b-model:latest        ports:          - containerPort: 8080        resources:          limits:            nvidia.com/gpu: 1---apiVersion: v1kind: Servicemetadata:  name: truss-falcon-7b-service  namespace: defaultspec:  type: ClusterIP  selector:    component: truss-falcon-7b-layer  ports:  - port: 8080    protocol: TCP    targetPort: 8080

Cosa sta accadendo:

<liStiamo dicendo a Kubernetes che vogliamo creare pod con la nostra immagine falcon-7b-model. Assicurati di sostituire <your_docker_id> con il tuo ID effettivo. Se non hai creato la tua immagine Docker e vuoi utilizzare la mia invece, sostituiscila con la seguente: htrivedi05/truss-falcon-7b:latest
• Abilitiamo l’accesso alla GPU per il nostro container impostando un limite di risorse nvidia.com/gpu: 1. Questo dice a Kubernetes di richiedere solo una GPU per il nostro container
• Per interagire con il nostro modello, dobbiamo creare un servizio Kubernetes che funzionerà sulla porta 8080

Crea il deployment eseguendo il seguente comando nel tuo terminale:

kubectl create -f truss-falcon-deployment.yaml

Se esegui il comando:

kubectl get deployments

Dovresti vedere qualcosa di simile a questo:

NOME               PRONTO   AGGIORNATO   DISPONIBILE   ETÀ
truss-falcon-7b     0/1     1            0            8s

Ci vorranno alcuni minuti affinché il deployment passi allo stato di “pronto”. Ricorda che il modello deve essere scaricato da Hugging Face ogni volta che il contenitore si riavvia. Puoi verificare lo stato di avanzamento del contenitore eseguendo il seguente comando:

kubectl get pods

kubectl logs truss-falcon-7b-8fbb476f4-bggts

Cambia il nome del pod di conseguenza.

Ci sono alcune cose che devi cercare nei log:

• Cerca l’istruzione di stampa THE DEVICE INFERENCE IS RUNNING ON IS: cuda. Questo conferma che il nostro contenitore è correttamente connesso alla GPU.
• Successivamente, dovresti vedere alcune istruzioni di stampa relative al download dei file del modello

Downloading (…)model.bin.index.json: 100%|██████████| 16.9k/16.9k [00:00<00:00, 1.92MB/s]Downloading (…)l-00001-of-00002.bin: 100%|██████████| 9.95G/9.95G [02:37<00:00, 63.1MB/s]Downloading (…)l-00002-of-00002.bin: 100%|██████████| 4.48G/4.48G [01:04<00:00, 69.2MB/s]Downloading shards: 100%|██████████| 2/2 [03:42<00:00, 111.31s/it][01:04<00:00, 71.3MB/s]

• Una volta che il modello è stato scaricato e Truss ha creato il microservizio, dovresti vedere il seguente output alla fine dei tuoi log:

{"asctime": "2023-06-29 21:40:40,646", "levelname": "INFO", "message": "Completed model.load() execution in 330588 ms"}

Da questo messaggio, possiamo confermare che il modello è stato caricato e pronto per l’elaborazione.

Inferenza del modello

Non possiamo chiamare direttamente il modello, invece, dobbiamo chiamare il servizio del modello

Esegui il seguente comando per ottenere il nome del tuo servizio:

kubectl get svc

Output:

NOME                      TIPO        CLUSTER-IP   EXTERNAL-IP   PORT(S)    ETÀkubernetes                ClusterIP   10.80.0.1    <none>        443/TCP    46mtruss-falcon-7b-service   ClusterIP   10.80.1.96   <none>        8080/TCP   6m19s

Il truss-falcon-7b-service è quello che vogliamo chiamare. Per rendere il servizio accessibile, dobbiamo inoltrarlo utilizzando il seguente comando:

kubectl port-forward svc/truss-falcon-7b-service 8080

Output:

Inoltramento da 127.0.0.1:8080 -> 8080Inoltramento da [::1]:8080 -> 8080

Perfetto, il nostro modello è disponibile come endpoint di un’API REST a 127.0.0.1:8080. Apri qualsiasi script Python come main.py ed esegui il seguente codice:

import requestsdata = {"prompt": "Cosa c'è di più interessante in un falcone?"}res = requests.post("http://127.0.0.1:8080/v1/models/model:predict", json=data)print(res.json())

Output:

 {'data': {'generated_text': "Cosa c'è di più interessante in un falcone?\nI falchi sono conosciuti per la loro incredibile velocità e agilità in volo, così come per le loro impressionanti abilità di caccia. Sono anche noti per la loro caratteristica piumaggio, che può variare notevolmente a seconda della specie."}}

Whoo-hoo! Abbiamo con successo containerizzato il nostro modello Falcon 7B e lo abbiamo distribuito come microservizio in produzione!

Sentiti libero di giocare con diverse prompt per vedere cosa restituisce il modello.

Spegnimento del cluster

Una volta che ti sei divertito a giocare con Falcon 7B, puoi eliminare la tua distribuzione eseguendo questo comando:

kubectl delete -f truss-falcon-deployment.yaml

In seguito, vai al motore Kubernetes su Google Cloud e elimina il cluster Kubernetes.

Nota: Tutte le immagini, se non diversamente specificato, sono dell’autore

Conclusioni

Eseguire e gestire un modello di produzione come ChatGPT non è facile. Tuttavia, nel tempo, gli strumenti miglioriranno per consentire agli sviluppatori di distribuire il proprio modello nel cloud.

In questo post del blog, abbiamo affrontato tutte le cose necessarie per distribuire un LLM in produzione a un livello di base. Abbiamo confezionato il modello utilizzando Truss, lo abbiamo containerizzato utilizzando Docker e lo abbiamo distribuito nel cloud utilizzando Kubernetes. So che è molto da assimilare e non è stata la cosa più semplice al mondo da fare, ma l’abbiamo comunque fatto.

Spero che tu abbia imparato qualcosa di interessante da questo post del blog. Grazie per la lettura!

Peace.