Hinweis:

Dieses Tutorial erfordert Zugriff auf Oracle Cloud. Informationen zum Registrieren eines kostenlosen Accounts finden Sie unter Erste Schritte mit Oracle Cloud Infrastructure Free Tier.
Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Wenn Sie Ihre Übung abgeschlossen haben, ersetzen Sie diese Werte durch spezifische Werte für Ihre Cloud-Umgebung.

Mistral LLM-Modell auf OCI Compute A10-Instanz mit Oracle Resource Manager mit einem One-Click-Deployment ausführen

Einführung

Mit Oracle Cloud Infrastructure (OCI) Compute können Sie verschiedene Ausprägungstypen erstellen, um die Grafikprozessoreinheit (GPU) für lokal bereitgestellte KI-Modelle (Artificial Intelligence) zu testen. In diesem Tutorial verwenden wir die Ausprägung A10 mit einem bereits vorhandenen VCN und Subnetzressourcen, die Sie in Oracle Resource Manager auswählen können.

Der Terraform-Code umfasst auch die Konfiguration der Instanz zur Ausführung eines lokalen Virtual Large Language Model (vLLM)-Mistralmodells für Verarbeitungsaufgaben in natürlicher Sprache.

Ziele

Erstellen Sie eine A10-Ausprägung auf OCI Compute, laden Sie das Mistral AI LLM-Modell herunter, und fragen Sie das lokale vLLM-Modell ab.

Voraussetzungen

Stellen Sie sicher, dass Sie über ein virtuelles OCI-Cloud-Netzwerk (VCN) und ein Subnetz verfügen, in dem die virtuelle Maschine (VM) bereitgestellt wird.
Verständnis der Netzwerkkomponenten und ihrer Beziehungen. Weitere Informationen finden Sie unter Networking - Überblick.
Verstehen von Netzwerken in der Cloud. Weitere Informationen finden Sie im folgenden Video: Video für Networking in der Cloud EP.01: Virtuelle Cloud-Netzwerke.
Anforderungen:
- Instanztyp: A10-Ausprägung mit einer Nvidia-GPU.
- Betriebssystem: Oracle Linux.
- Imageauswahl: Das Deployment-Skript wählt das neueste Oracle Linux-Image mit GPU-Unterstützung aus.
- Tags: Fügt ein Freiformtag hinzu, GPU_TAG = "A10-1".
- Boot-Volume-Größe: 250GB.
- Initialisierung: Mit cloud-init können Sie die vLLM Mistral-Modelle herunterladen und konfigurieren.

Aufgabe 1: Terraform-Code für Deployment mit einem Klick herunterladen

Laden Sie den ORM-Terraform-Code von hier herunter: orm_stack_a10_gpu-main.zip, um Mistral vLLM-Modelle lokal zu implementieren. Dadurch können Sie ein vorhandenes VCN und ein Subnetz auswählen, um das lokale Deployment von Mistral vLLM-Modellen in einer A10-Instanzausprägung zu testen.

Nachdem Sie den ORM-Terraform-Code lokal heruntergeladen haben, führen Sie die folgenden Schritte aus: Stack aus einem Ordner erstellen, um den Stack hochzuladen und die Anwendung des Terraform-Codes auszuführen.

Hinweis: Stellen Sie sicher, dass Sie ein virtuelles OCI-Cloud-Netzwerk (VCN) und ein Subnetz erstellt haben, in dem die VM bereitgestellt wird.

Aufgabe 2: VCN auf OCI erstellen (optional, wenn noch nicht erstellt)

Informationen zum Erstellen eines VCN in Oracle Cloud Infrastructure finden Sie unter: Video zum Erstellen eines virtuellen Cloud-Netzwerks auf OCI.

oder

So erstellen Sie ein VCN:

Melden Sie sich bei der OCI-Konsole an, und geben Sie Cloud-Mandantenname, Benutzername und Kennwort ein.
Klicken Sie in der oberen linken Ecke auf das Hamburger-Menü (≡).
Gehen Sie zu Networking, Virtuelle Cloud-Netzwerke, und wählen Sie das entsprechende Compartment im Abschnitt Listengeltungsbereich aus.
Wählen Sie VCN mit Internetverbindung, aus, und klicken Sie auf VCN-Assistenten starten.
Geben Sie auf der Seite VCN mit Internetverbindung erstellen die folgenden Informationen ein, und klicken Sie auf Weiter.
- VCN-NAME: Geben Sie OCI_HOL_VCN ein.
- COMPARTMENT: Wählen Sie das entsprechende COMPARTMENT aus.
- VCN-CIDR-BLOCK: Geben Sie 10.0.0.0/16 ein.
- Untergeordneter PUBNET-CIDR-BLOCK: Geben Sie 10.0.2.0/24 ein.
- PRIVATE SUBNET CIDR BLOCK: Geben Sie 10.0.1.0/24 ein.
- DNS-Auflösung: Wählen Sie DNS-Hostnamen IN diesem VCN verwenden aus.
Beschreibung der Abbildung setupVCN3.png
Prüfen Sie auf der Seite Prüfen Ihre Einstellungen, und klicken Sie auf Erstellen.

Beschreibung der Abbildung setupVCN4.png

Es dauert einen Moment, das VCN zu erstellen, und ein Fortschrittsbildschirm informiert Sie über den Workflow.

Beschreibung der Abbildung workflow.png
Klicken Sie nach der Erstellung des VCN auf Virtuelles Cloud-Netzwerk anzeigen.

In realen Situationen erstellen Sie mehrere VCNs, je nachdem, welcher Zugriff erforderlich ist (welche Ports geöffnet werden müssen) und wer darauf zugreifen kann.

Aufgabe 3: Details zur cloud-init-Konfiguration anzeigen

Das Skript cloud-init installiert alle erforderlichen Abhängigkeiten, startet Docker, lädt die vLLM Mistral-Modelle herunter und startet sie. Sie finden den folgenden Code in der Datei cloudinit.sh, die in Aufgabe 1 heruntergeladen wurde.

dnf install -y dnf-utils zip unzip
dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
dnf remove -y runc
dnf install -y docker-ce --nobest
systemctl enable docker.service
dnf install -y nvidia-container-toolkit
systemctl start docker.service
...

Cloud-init lädt alle Dateien herunter, die für die Ausführung des Mistral-Modells basierend auf Ihrem in Hugging Face vordefinierten API-Token erforderlich sind.

Beim Erstellen des API-Tokens wird das Mistral-Modell basierend auf Ihrer Eingabe aus der ORM-GUI ausgewählt, sodass die erforderliche Authentifizierung zum lokalen Herunterladen der Modelldateien möglich ist. Weitere Informationen finden Sie unter Benutzerzugriffstoken.

Aufgabe 4: System überwachen

Verfolgen Sie den Abschluss des Skripts cloud-init und die GPU-Ressourcennutzung mit den folgenden Befehlen (falls erforderlich).

Cloud-Init-Abschluss überwachen: tail -f /var/log/cloud-init-output.log.
GPUs-Auslastung überwachen: nvidia-smi dmon -s mu -c 100.

Bereitstellen und mit dem vLLM Mistral-Modell mit Python interagieren: (Ändern Sie die Parameter nur bei Bedarf (der Befehl ist bereits im Skript cloud-init enthalten):

python -O -u -m vllm.entrypoints.openai.api_server \
    --host 0.0.0.0 \
    --model "/home/opc/models/${MODEL}" \
    --tokenizer hf-internal-testing/llama-tokenizer \
    --max-model-len 16384 \
    --enforce-eager \
    --gpu-memory-utilization 0.8 \
    --max-num-seqs 2 \
    >> "${MODEL}.log" 2>&1 &

Aufgabe 5: Modellintegration testen

Interagieren Sie mit den Befehlen oder Jupyter Notebook-Details auf folgende Weise mit dem Modell.

Testen Sie das Modell über die Befehlszeilenschnittstelle (CLI), nachdem das Skript cloud-init abgeschlossen ist.

curl -X 'POST' 'http://0.0.0.0:8000/v1/chat/completions' \
-H 'accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
    "model": "/home/opc/models/'"$MODEL"'",
    "messages": [{"role":"user", "content":"Write a small poem."}],
    "max_tokens": 64
}'

Testen Sie das Modell aus Jupyter Notebook (Öffnen Sie Port 8888).

import requests
import json
import os

# Retrieve the MODEL environment variable
model = os.environ.get('MODEL')

url = 'http://0.0.0.0:8000/v1/chat/completions'
headers = {
    'accept': 'application/json',
    'Content-Type': 'application/json',
}

data = {
    "model": f"/home/opc/models/{model}",
    "messages": [{"role": "user", "content": "Write a short conclusion."}],
    "max_tokens": 64
}

response = requests.post(url, headers=headers, json=data)

if response.status_code == 200:
    result = response.json()
    # Pretty print the response for better readability
    formatted_response = json.dumps(result, indent=4)
    print("Response:", formatted_response)
else:
    print("Request failed with status code:", response.status_code)
    print("Response:", response.text)

Integrieren Sie Gradio mit Chatbot, um das Modell abzufragen.

import requests
import gradio as gr
import os

def interact_with_model(prompt):
    model = os.getenv("MODEL")  # Retrieve the MODEL environment variable within the function
    url = 'http://0.0.0.0:8000/v1/chat/completions'
    headers = {
        'accept': 'application/json',
        'Content-Type': 'application/json',
    }

    data = {
        "model": f"/home/opc/models/{model}",
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 64
    }

    response = requests.post(url, headers=headers, json=data)

    if response.status_code == 200:
        result = response.json()
        completion_text = result["choices"][0]["message"]["content"].strip()  # Extract the generated text
        return completion_text
    else:
        return {"error": f"Request failed with status code {response.status_code}"}

# Example Gradio interface
iface = gr.Interface(
    fn=interact_with_model,
    inputs=gr.Textbox(lines=2, placeholder="Write a prompt..."),
    outputs=gr.Textbox(type="text", placeholder="Response..."),
    title="Mistral 7B Chat Interface",
    description="Interact with the Mistral 7B model deployed locally via Gradio.",
    live=True
)

# Launch the Gradio interface
iface.launch(share=True)

Aufgabe 6: Modell mit Docker bereitstellen (falls erforderlich)

Alternativ können Sie das Modell mit Docker und einer externen Quelle bereitstellen.

docker run --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HUGGING_FACE_HUB_TOKEN=$ACCESS_TOKEN" \
    -p 8000:8000 \
    --ipc=host \
    --restart always \
    vllm/vllm-openai:latest \
    --model mistralai/$MODEL \
    --max-model-len 16384

Sie können das Modell wie folgt abfragen:

Fragen Sie das mit Docker und externer Quelle gestartete Modell mit der CLI ab.

curl -X 'POST' 'http://0.0.0.0:8000/v1/chat/completions' \
-H 'accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"model": "mistralai/'"$MODEL"'",
"messages": [{"role": "user", "content": "Write a small poem."}],
"max_tokens": 64
}'

Fragen Sie das Modell mit Docker aus einer externen Quelle mit Jupyter Notebook ab.

import requests
import json
import os

# Retrieve the MODEL environment variable
model = os.environ.get('MODEL')

url = 'http://0.0.0.0:8000/v1/chat/completions'
headers = {
    'accept': 'application/json',
    'Content-Type': 'application/json',
}

data = {
    "model": f"mistralai/{model}",
    "messages": [{"role": "user", "content": "Write a short conclusion."}],
    "max_tokens": 64
}

response = requests.post(url, headers=headers, json=data)

if response.status_code == 200:
    result = response.json()
    # Pretty print the response for better readability
    formatted_response = json.dumps(result, indent=4)
    print("Response:", formatted_response)
else:
    print("Request failed with status code:", response.status_code)
    print("Response:", response.text)

Fragen Sie das Modell mit Docker aus einer externen Quelle mit Jupyter Notebook und Gradio Chatbot ab.

import requests
import gradio as gr
import os

# Function to interact with the model via API
def interact_with_model(prompt):
    url = 'http://0.0.0.0:8000/v1/chat/completions'
    headers = {
        "accept": "application/json",
        "Content-Type": "application/json",
    }

    # Retrieve the MODEL environment variable
    model = os.environ.get('MODEL')

    data = {
        "model": f"mistralai/{model}",
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 64
    }

    response = requests.post(url, headers=headers, json=data)

    if response.status_code == 200:
        result = response.json()
        completion_text = result["choices"][0]["message"]["content"].strip()  # Extract the generated text
        return completion_text
    else:
        return {"error": f"Request failed with status code {response.status_code}"}

# Example Gradio interface
iface = gr.Interface(
    fn=interact_with_model,
    inputs=gr.Textbox(lines=2, placeholder="Write a prompt..."),
    outputs=gr.Textbox(type="text", placeholder="Response..."),
    title="Model Interface",  # Set a title for your Gradio interface
    description="Interact with the model deployed via Gradio.",  # Set a description
    live=True
)

# Launch the Gradio interface
iface.launch(share=True)

Modell, das mit dem Docker mit den bereits heruntergeladenen lokalen Dateien ausgeführt wird (startet schneller).

docker run --gpus all \
-v /home/opc/models/$MODEL/:/mnt/model/ \
--env "HUGGING_FACE_HUB_TOKEN=$TOKEN_ACCESS" \
-p 8000:8000 \
--env "TRANSFORMERS_OFFLINE=1" \
--env "HF_DATASET_OFFLINE=1" \
--ipc=host vllm/vllm-openai:latest \
--model="/mnt/model/" \
--max-model-len 16384 \
--tensor-parallel-size 2

Fragen Sie das Modell mit Docker mit den lokalen Dateien und der CLI ab.

curl -X 'POST' 'http://0.0.0.0:8000/v1/chat/completions' -H 'accept: application/json' -H 'Content-Type: application/json' -d '{
>     "model": "/mnt/model/",
>     "messages": [{"role": "user", "content": "Write a humorous limerick about the wonders of GPU computing."}],
>      "max_tokens": 64,
>     "temperature": 0.7,
>      "top_p": 0.9
>  }'

Fragen Sie das Modell mit den lokalen Dateien und dem Jupyter Notebook mit Docker ab.

import requests
import json
import os

url = "http://0.0.0.0:8000/v1/chat/completions"
headers = {
    "accept": "application/json",
    "Content-Type": "application/json",
}

# Assuming `MODEL` is an environment variable set appropriately
model = f"/mnt/model/"  # Adjust this based on your specific model path or name

data = {
    "model": model,
    "messages": [{"role": "user", "content": "Write a humorous limerick about the wonders of GPU computing."}],
    "max_tokens": 64,
    "temperature": 0.7,
    "top_p": 0.9
}

response = requests.post(url, headers=headers, json=data)

if response.status_code == 200:
    result = response.json()
    # Extract the generated text from the response
    completion_text = result["choices"][0]["message"]["content"].strip()
    print("Generated Text:", completion_text)
else:
    print("Request failed with status code:", response.status_code)
    print("Response:", response.text)

Fragen Sie das Modell mit Docker aus einer externen Quelle mit Jupyter Notebook und Gradio Chatbot ab.

import requests
import gradio as gr
import os

# Function to interact with the model via API
def interact_with_model(prompt):
    url = 'http://0.0.0.0:8000/v1/chat/completions'  # Update the URL to match the correct endpoint
    headers = {
        "accept": "application/json",
        "Content-Type": "application/json",
    }

    # Assuming `MODEL` is an environment variable set appropriately
    model = "/mnt/model/"  # Adjust this based on your specific model path or name

    data = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 64,
        "temperature": 0.7,
        "top_p": 0.9
    }

    response = requests.post(url, headers=headers, json=data)

    if response.status_code == 200:
        result = response.json()
        completion_text = result["choices"][0]["message"]["content"].strip()
        return completion_text
    else:
        return {"error": f"Request failed with status code {response.status_code}"}

# Example Gradio interface
iface = gr.Interface(
    fn=interact_with_model,
    inputs=gr.Textbox(lines=2, placeholder="Write a humorous limerick about the wonders of GPU computing."),
    outputs=gr.Textbox(type="text", placeholder="Response..."),
    title="Model Interface",  # Set your desired title here
    description="Interact with the model deployed locally via Gradio.",
    live=True
)

# Launch the Gradio interface
iface.launch(share=True)

Hinweis: Firewallbefehle zum Öffnen des 8888-Ports für Jupyter Notebook.
sudo firewall-cmd --zone=public --permanent --add-port 8888/tcp
sudo firewall-cmd --reload
sudo firewall-cmd --list-all

Danksagungen

Autor - Bogdan Bazarca (Senior Cloud Engineer)
Mitwirkende - Oracle NACI-AI-CN-DEV-Team

Weitere Lernressourcen

Lernen Sie andere Übungen auf docs.oracle.com/learn kennen, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube Channel zu. Außerdem können Sie education.oracle.com/learning-explorer besuchen, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Run Mistral LLM Model on OCI Compute A10 Instance with Oracle Resource Manager using One Click Deployment

G11812-01

July 2024

Oracle und/oder verbundene Unternehmen.