Om een Lama-familie van modellen te implementeren met behulp van NVIDIA NIM op uw eigen cloud of lokale machine, volgt u deze stappen:

1. Stel de omgeving in: Als u op uw lokale machine werkt, installeer dan de Docker-engine en de NVIDIA-containertoolkit. Links hiernaar worden gegeven in de videobeschrijving.

2. Verkrijg API-sleutel: Meld u aan voor een NVIDIA-account om uw API-sleutel en persoonlijke sleutel te genereren. Deze zijn vereist voor interactie met de externe server.

3. Voer de Docker-container uit: Gebruik de opgegeven Docker-opdracht om de container uit te voeren, waarbij u de containernaam, GPU-gebruik, API-sleutel, modelcachelocatie en poort opgeeft. Hiermee wordt het Lama 3 8 miljard instructiemodel gedownload en ingesteld.

4. Interacteer met het model: Gebruik de opgegeven cURL-opdracht om te communiceren met het geïmplementeerde model. Deze opdracht volgt de OpenAI API-standaard, waardoor u de OpenAI-client kunt gebruiken voor interactie.

5. Stresstest de API: Gebruik een Python-script met de requests-bibliotheek om meerdere gelijktijdige verzoeken naar het API-eindpunt te sturen en de GPU-benutting en doorvoer te bewaken.

6. Gebruik de OpenAI API-client: Demonstreer hoe u de OpenAI API-client kunt gebruiken met NVIDIA NIM door de basis-URL en andere parameters bij te werken om overeen te komen met het geïmplementeerde model.

Om toegang te krijgen tot de NVIDIA Launchpad en het GPU-metriekendashboard, volgt u deze stappen:

1. Als onderdeel van de NVIDIA Launchpad krijgt u toegang tot een code-IDE, namelijk Visual Studio Code. U kunt deze IDE gebruiken om te communiceren met de GPU-instantie en het Llama 3 8 miljard instructiemodel te implementeren.

2. Het GPU-metriekendashboard is een Grafana-dashboard dat gedetailleerde informatie geeft over het GPU-gebruik en de prestaties. U kunt dit dashboard gebruiken om de GPU-benutting, CUDA-versie, GPU-stuurprogramma's en andere relevante metrische gegevens te bewaken.

3. Het Grafana-dashboard geeft u een visuele weergave van het GPU-gebruik in de loop van de tijd, waardoor u de prestaties kunt volgen en de implementatie dienovereenkomstig kunt optimaliseren.

4. U kunt de watch-opdracht in de terminal gebruiken om het GPU-gebruik in realtime te bewaken. De opdracht watch -n 1 nvidia-smi zal het GPU-gebruik elke seconde bijwerken, waardoor u een live weergave krijgt van de GPU-benutting.

5. Het GPU-metriekendashboard en de realtime bewakingstools stellen u in staat de prestatiekenmerken van de implementatie van het Llama 3 8 miljard instructiemodel te begrijpen, waardoor u de resourcebenutting kunt optimaliseren en een efficiënte inferentie kunt garanderen.

Om het Llama 3 8 miljard instructiemodel te implementeren met behulp van NVIDIA NIM, volgt u deze stappen:

1. Open de opgegeven IDE en zorg ervoor dat u toegang hebt tot een H100 GPU.
2. Stel uw API-sleutel in door u aan te melden voor een NVIDIA-account en de benodigde sleutels te genereren.
3. Voer de volgende Docker-opdracht uit om de NVIDIA NIM-container te starten:

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

Deze opdracht zal:

• Een Docker-container met de naam "llama-3-8b-instruct" maken
• Alle beschikbare GPU's op het systeem gebruiken
• De omgevingsvariabele NVIDIA_API_KEY instellen
• Poort 8000 openen voor de NIM-server
• Het model "llama-3-8b-instruct" uit de NVIDIA NIM-catalogus gebruiken

4. Zodra de container wordt uitgevoerd, kunt u de opgegeven cURL-opdracht gebruiken om te communiceren met het model:

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

Deze cURL-opdracht stuurt een verzoek naar de NIM-server die op localhost:8000 wordt uitgevoerd om een antwoord te genereren op de prompt "Vertel me een grap."

5. Om de API-eindpunt te stresstest, kunt u het opgegeven Python-script test_server.py uitvoeren. Dit script zal meerdere gelijktijdige verzoeken naar de NIM-server sturen en de GPU-benutting bewaken.

6. Ten slotte kunt u ook de OpenAI API-client gebruiken om te communiceren met de NIM-server door de basis-URL bij te werken om naar het adres en de poort van de NIM-server te wijzen.

Door deze stappen te volgen, kunt u het Llama 3 8 miljard instructiemodel met succes implementeren met behulp van de NVIDIA NIM Docker-container en de prestaties ervan testen.

Om te communiceren met de NVIDIA NIM-API, kunnen we een eenvoudige cURL-opdracht gebruiken. De cURL-opdracht biedt het volgende:

• Maakt een POST-verzoek naar de lokale host op poort 8000, waar de NVIDIA NIM-server wordt uitgevoerd.
• Gebruikt de OpenAI-compatibele API, zodat we de OpenAI-client kunnen gebruiken om te communiceren met de NIM-server.
• Specificeert het Llama 3 8 miljard instructiemodel om te gebruiken.
• Stelt de berichtstructuur in op een manier die vergelijkbaar is met wat OpenAI verwacht.
• Stelt extra parameters in zoals max_tokens en temperature.

Hier is de cURL-opdracht:

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

Deze cURL-opdracht zal een verzoek naar de NVIDIA NIM-server sturen, die vervolgens een antwoord zal genereren met behulp van het Llama 3 8 miljard instructiemodel. Het antwoord zal worden gestreamd, waarbij elk token wordt weergegeven zodra het wordt gegenereerd.

Om de API-eindpunt verder te stresstest, kunnen we een Python-script gebruiken dat de requests-bibliotheek gebruikt om meerdere gelijktijdige verzoeken te doen. Dit script zal 50 grapgeneratieverzoeken parallel versturen en de GPU-benutting en doorvoer bewaken.

import requests
import threading

url = "http://localhost:8000/v1/chat/completions"
headers = {"Content-Type": "application/json"}
payload = {
    "model": "nlp/lama-3-8b-instruct",
    "messages": [{"role": "user", "content": "Vertel me 50 grappen"}],
    "max_tokens": 1000,
    "temperature": 0.7,
    "stream": False
}

def send_requests():
    for _ in range(50):
        response = requests.post(url, headers=headers, json=payload)
        print(response.json())

threads = []
for _ in range(10):
    t = threading.Thread(target=send_requests)
    t.start()
    threads.append(t)

for thread in threads:
    thread.join()

Dit script laat zien hoe u de OpenAI-compatibele API kunt gebruiken met de NVIDIA NIM-server. Het toont aan dat de NVIDIA NIM-server hoogwaardige inferentie kan bieden voor grote taalmodellen, met de mogelijkheid tot een verbetering van maximaal 3 keer in vergelijking met andere implementatieopties.

Om de NVIDIA NIM-API-eindpunt te stresstest, gebruiken we een eenvoudig Python-script dat gebruikmaakt van de requests-bibliotheek om meerdere gelijktijdige verzoeken naar het API-eindpunt te sturen. Hier is hoe het werkt:

1. We definiëren de API-eindpunt-URL, die in dit geval de lokale host is omdat we de server lokaal uitvoeren. Als u dit op een externe server zou implementeren, zou u het externe IP-adres moeten gebruiken en poortdoorschakeling moeten inschakelen.

2. We stellen de noodzakelijke headers in, inclusief de Content-Type-header op application/json.

3. We maken de payload, die de modelnaam ("model": "llama-3-8b-instruct"), de prompt ("prompt": "Vertel me 50 grappen."), en andere parameters zoals max_tokens, temperature en stop bevat.

4. We definiëren een functie send_requests() die de verzoeken verzendt met behulp van de requests.post()-methode en de eerder gedefinieerde URL, headers en payload.

5. We gebruiken multithreading om meerdere instanties van de send_requests()-functie gelijktijdig uit te voeren, waardoor we een hoog volume aan verzoeken naar het API-eindpunt simuleren.

6. We bewaken het GPU-gebruik in realtime met behulp van de watch-opdracht en het nvidia-smi-hulpprogramma, dat inzicht geeft in de GPU-benutting.

De output laat zien dat het API-eindpunt in staat is om een aanzienlijk aantal gelijktijdige verzoeken te verwerken, met een gemiddelde doorvoer van ongeveer 2.500 tokens per seconde. De GPU-benutting blijft ook relatief hoog, wat aangeeft dat de NVIDIA NIM de hardwarebronnen effectief benut om hoogwaardige inferentie te leveren.

Deze stresstest demonstreert de schaalbaarheid en prestaties van de NVIDIA NIM-oplossing, waardoor het een aantrekkelijke optie wordt voor het implementeren van grote taalmodellen in een productieomgeving.

Om de OpenAI API-client te gebruiken met NVIDIA NIM, volgt u deze stappen:

1. Wijzig de basis-URL naar de URL van uw NVIDIA NIM-instantie. In dit voorbeeld voeren we deze uit op localhost:8000:

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

2. U hoeft de API-sleutel niet op te geven, aangezien NVIDIA NIM de authenticatie afhandelt.

3. Stel het model in op het door NVIDIA NIM gehoste model, in dit geval "meta-llama-38b-instruct":

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

4. Stel de andere parameters in, zoals het maximale aantal te genereren tokens, de temperatuur en of de antwoorden moeten worden gestreamd:

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

5. Itereer door de streaming-respons en druk de gegenereerde tekst af:

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

Deze aanpak stelt u in staat om te profiteren van de prestaties en het gemak van implementatie die NVIDIA NIM biedt, terwijl u de vertrouwde OpenAI API-client gebruikt. De streaming-respons zorgt ervoor dat u de gegenereerde tekst in realtime ontvangt, wat een responsieve gebruikerservaring biedt.

In deze video hebben we onderzocht hoe u een Lama 3 8 miljard instructiemodel kunt implementeren met behulp van NVIDIA NIM op uw eigen cloud of lokale machine. NVIDIA NIM is een set microservices ontwikkeld door NVIDIA die de implementatie van basismodellen, waaronder taalmodellen en andere AI-modellen, versnelt.

We hebben de stappen doorlopen om de NVIDIA NIM-omgeving in te stellen, inclusief het genereren van de API-sleutel en het uitvoeren van de Docker-container om het Lama 3-model te implementeren. We hebben ook de prestaties van het geïmplementeerde model getest door meerdere verzoeken tegelijkertijd te verzenden en de GPU-benutting en doorvoer te bewaken.

Bovendien hebben we laten zien hoe u de OpenAI API-client kunt gebruiken om te communiceren met het door NVIDIA NIM geïmplementeerde model, waarmee de compatibiliteit met de OpenAI API-standaard wordt gedemonstreerd.

Over het algemeen biedt NVIDIA NIM een handige en efficiënte manier om grote taalmodellen in een productieomgeving te implementeren. Het vermogen om gebruik te maken van NVIDIA's hardware- en softwarestack kan leiden tot aanzienlijke prestatieverbetering in vergelijking met andere implementatieopties. Als u geïnteresseerd bent in het verkennen van meer implementatieopties voor uw projecten, abonneer u dan zeker op het kanaal voor toekomstige content over VLLM en andere gerelateerde onderwerpen.