För att distribuera en Lama-familj av modeller med hjälp av NVIDIA NIM på din egen moln- eller lokala dator, följ dessa steg:

1. Konfigurera miljön: Om du kör på din lokala dator, installera Docker-motor och NVIDIA-containertoolkit. Länkar till dessa finns i videobeskrivningen.

2. Hämta API-nyckel: Registrera dig för ett NVIDIA-konto för att generera din API-nyckel och personliga nyckel. Dessa kommer att krävas för att interagera med den fjärranslutna servern.

3. Kör Docker-containern: Använd det angivna Docker-kommandot för att köra containern, och ange containernamn, GPU-användning, API-nyckel, plats för modellcache och port. Detta kommer att ladda ner och konfigurera Lama 3 8 miljarder instruktionsmodellen.

4. Interagera med modellen: Använd det angivna cURL-kommandot för att interagera med den distribuerade modellen. Detta kommando följer OpenAI API-standarden, vilket gör att du kan använda OpenAI-klienten för interaktion.

5. Stresstest API:et: Använd ett Python-skript med requests-biblioteket för att skicka flera samtidiga förfrågningar till API-slutpunkten och övervaka GPU-utnyttjandet och genomflödet.

6. Använd OpenAI API-klient: Visa hur du använder OpenAI API-klienten med NVIDIA NIM genom att uppdatera bas-URL:en och andra parametrar för att matcha den distribuerade modellen.

För att komma åt NVIDIA Launchpad och GPU-mätarens instrumentpanel, följ dessa steg:

1. Som en del av NVIDIA Launchpad får du tillgång till en kod-IDE, som är Visual Studio Code. Du kan använda denna IDE för att interagera med GPU-instansen och distribuera Llama 3 8 miljarder instruktionsmodellen.

2. GPU-mätarens instrumentpanel är en Grafana-instrumentpanel som ger detaljerad information om GPU-användningen och prestandan. Du kan komma åt denna instrumentpanel för att övervaka GPU-utnyttjandet, CUDA-versionen, GPU-drivrutiner och andra relevanta mätvärden.

3. Grafana-instrumentpanelen ger dig en visuell representation av GPU-användningen över tid, vilket gör att du kan spåra prestandan och optimera distributionen därefter.

4. Du kan använda watch-kommandot i terminalen för att övervaka GPU-användningen i realtid. Kommandot watch -n 1 nvidia-smi kommer att uppdatera GPU-användningen varje sekund och ge dig en direktvy över GPU-utnyttjandet.

5. GPU-mätarens instrumentpanel och realtidsövervakningsverktygen låter dig förstå prestationsegenskaperna hos Llama 3 8 miljarder instruktionsmodellens distribution, vilket hjälper dig att optimera resursanvändningen och säkerställa effektiv inferens.

För att distribuera Llama 3 8 miljarder instruktionsmodellen med hjälp av NVIDIA NIM, följ dessa steg:

1. Öppna den angivna IDE:n och se till att du har tillgång till ett H100-GPU.
2. Konfigurera din API-nyckel genom att registrera dig för ett NVIDIA-konto och generera de nödvändiga nycklarna.
3. Kör följande Docker-kommando för att starta NVIDIA NIM-containern:

docker run -it --gpus all -e NVIDIA_API_KEY=$NVIDIA_API_KEY -p 8000:8000 --name llama-3-8b-instruct nvcr.io/nvidia/nim:latest --model-name llama-3-8b-instruct

Detta kommando kommer att:

• Skapa en Docker-container med namnet "llama-3-8b-instruct"
• Använda alla tillgängliga GPU:er på systemet
• Ställa in NVIDIA_API_KEY-miljövariabeln
• Exponera port 8000 för NIM-servern
• Använda "llama-3-8b-instruct"-modellen från NVIDIA NIM-katalogen

4. När containern körs kan du använda det angivna cURL-kommandot för att interagera med modellen:

curl -X POST -H "Content-Type: application/json" -d '{"model": "llama-3-8b-instruct", "prompt": "Tell me a joke.", "max_tokens": 1000, "temperature": 0.7, "top_p": 0.95, "stop": ["\n"]}' http://localhost:8000/v1/completions

Detta cURL-kommando skickar en förfrågan till NIM-servern som körs på localhost:8000 för att generera ett svar på prompten "Tell me a joke."

5. För att stresstest API-slutpunkten kan du köra det angivna Python-skriptet test_server.py. Detta skript kommer att skicka flera samtidiga förfrågningar till NIM-servern och övervaka GPU-utnyttjandet.

6. Slutligen kan du också använda OpenAI API-klienten för att interagera med NIM-servern genom att uppdatera bas-URL:en för att peka på NIM-serverns adress och port.

För att interagera med NVIDIA NIM-API:et kan vi använda ett enkelt cURL-kommando. cURL-kommandot ger följande:

• Gör en POST-förfrågan till den lokala värden på port 8000, där NVIDIA NIM-servern körs.
• Använder den OpenAI-kompatibla API:et, så vi kan använda OpenAI-klienten för att interagera med NIM-servern.
• Anger Llama 3 8 miljarder instruktionsmodellen som ska användas.
• Ställer in meddelandestrukturen på ett sätt som liknar det som OpenAI förväntar sig.
• Tillåter inställning av ytterligare parametrar som max_tokens och temperature.

Här är cURL-kommandot:

curl -X POST -H "Content-Type: application/json" -d '{"model": "nlp/lama-3-8b-instruct", "messages": [{"role": "user", "content": "Tell me a joke"}], "max_tokens": 1000, "temperature": 0.7}' http://localhost:8000/v1/chat/completions

Detta cURL-kommando kommer att skicka en förfrågan till NVIDIA NIM-servern, som sedan kommer att generera ett svar från Llama 3 8 miljarder instruktionsmodellen. Svaret kommer att strömmas tillbaka, där varje token visas när den genereras.

För att ytterligare stresstest API-slutpunkten kan vi använda ett Python-skript som använder requests-biblioteket för att göra flera samtidiga förfrågningar. Detta skript kommer att skicka 50 skämtgenereringsförfrågningar parallellt och övervaka GPU-utnyttjandet och genomflödet.

För att stresstest NVIDIA NIM API-slutpunkten kommer vi att använda ett enkelt Python-skript som utnyttjar requests-biblioteket för att göra flera samtidiga förfrågningar till API:et. Så här fungerar det:

1. Vi definierar API-slutpunktens URL, som i det här fallet är den lokala värden eftersom vi kör servern lokalt. Om du skulle distribuera detta på en fjärrserver skulle du behöva använda den externa IP-adressen och aktivera portvidarebefordran.

2. Vi ställer in nödvändiga rubriker, inklusive Content-Type-rubriken till application/json.

3. Vi skapar nyttolasten, som innehåller modellnamnet ("model": "llama-3-8b-instruct"), prompten ("prompt": "Tell me 50 jokes.") och andra parametrar som max_tokens, temperature och stop.

4. Vi definierar en funktion send_requests() som skickar förfrågningarna med hjälp av requests.post()-metoden och den URL, rubriker och nyttolast som vi definierat tidigare.

5. Vi använder multitrådar för att köra flera instanser av send_requests()-funktionen samtidigt, vilket simulerar ett högt antal förfrågningar till API-slutpunkten.

6. Vi övervakar GPU-användningen i realtid med hjälp av watch-kommandot och nvidia-smi-verktyget, som ger insikter om GPU-utnyttjandet.

Utdatan visar att API-slutpunkten kan hantera ett betydande antal samtidiga förfrågningar, med en genomsnittlig genomströmning på cirka 2 500 tokens per sekund. GPU-utnyttjandet förblir också relativt högt, vilket indikerar att NVIDIA NIM effektivt utnyttjar hårdvaruressurserna för att leverera högpresterande inferens.

Detta stresstest demonstrerar skalerbarheten och prestandan hos NVIDIA NIM-lösningen, vilket gör den till ett attraktivt alternativ för att distribuera stora språkmodeller i en produktionsmiljö.

För att använda OpenAI API-klienten med NVIDIA NIM, följ dessa steg:

1. Ändra bas-URL:en till URL:en för din NVIDIA NIM-instans. I det här exemplet kör vi den på localhost:8000:

openai.api_base = "http://localhost:8000"

2. Du behöver inte ange API-nyckeln, eftersom NVIDIA NIM hanterar autentiseringen.

3. Ställ in modellen till den NVIDIA NIM-värdbaserade modellen, i det här fallet "meta-llama-38b-instruct":

model = "meta-llama-38b-instruct"

4. Ställ in andra parametrar, som det maximala antalet tokens som ska genereras, temperatur och om du vill strömma svaren:

response = openai.ChatCompletion.create(
    model=model,
    messages=[{"role": "user", "content": "Tell me 50 different jokes"}],
    max_tokens=1024,
    temperature=0.7,
    stream=True,
)

5. Iterera genom det strömmande svaret och skriv ut den genererade texten:

for chunk in response:
    print(chunk.choices[0].text, end="")

Denna metod låter dig dra nytta av den prestanda och enkla distribution som NVIDIA NIM erbjuder, samtidigt som du använder den välbekanta OpenAI API-klienten. Den strömmande svarshanteringen säkerställer att du får den genererade texten i realtid, vilket ger en responsiv användarupplevelse.