Remarques :

• Ce tutoriel nécessite un accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, reportez-vous à Introduction au niveau gratuit d'Oracle Cloud Infrastructure.
• Il utilise des exemples de valeur pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. A la fin de l'exercice, remplacez ces valeurs par des valeurs propres à votre environnement cloud.

Exécuter un modèle LLM Mistral sur une instance OCI Compute A10 avec Oracle Resource Manager à l'aide d'un déploiement en un clic

Introduction

Oracle Cloud Infrastructure (OCI) Compute vous permet de créer différents types de formes pour tester les modèles d'unité de traitement graphique (GPU) pour l'intelligence artificielle (IA) déployés localement. Dans ce tutoriel, nous allons utiliser la forme A10 avec un VCN et des ressources de sous-réseau préexistants que vous pouvez sélectionner dans Oracle Resource Manager.

Le code Terraform inclut également la configuration de l'instance afin qu'elle exécute un ou plusieurs modèles Mistral vLLM (Virtual Large Language Model) locaux pour les tâches de traitement du langage naturel.

Objectifs

• Créez une forme A10 sur OCI Compute, téléchargez le modèle Mistral AI LLM et interrogez le modèle vLLM local.

Prérequis

• Assurez-vous que vous disposez d'un réseau cloud virtuel OCI (VCN) et d'un sous-réseau où la machine virtuelle sera déployée.

• Compréhension des composants réseau et de leurs relations. Pour plus d'informations, reportez-vous à Présentation de Networking.

• Compréhension de la mise en réseau dans le cloud. Pour plus d'informations, regardez la vidéo suivante : Vidéo for Networking in the Cloud EP.01 : Virtual Cloud Networks.

• Exigences :

  • Type d'instance : forme A10 avec un GPU Nvidia.
  • Système d'exploitation : Oracle Linux.
  • Sélection d'image : le script de déploiement sélectionne la dernière image Oracle Linux avec prise en charge des GPU.
  • Balises : ajoute une balise à format libre GPU_TAG = "A10-1".
  • Taille de volume d'initialisation : 250 Go.
  • Initialisation : utilise cloud-init pour télécharger et configurer les modèles Mistral vLLM.

Tâche 1 : téléchargement du code Terraform pour un déploiement en un clic

Téléchargez le code ORM Terraform à partir d'ici : orm_stack_a10_gpu-main.zip, pour implémenter localement des modèles Mistral vLLM qui vous permettront de sélectionner un VCN et un sous-réseau existants afin de tester le déploiement local de modèles Mistral vLLM dans une forme d'instance A10.

Une fois le code Terraform ORM téléchargé en local, suivez les étapes ci-après : Création d'une pile à partir d'un dossier pour télécharger la pile et exécuter l'application du code Terraform.

Remarque : assurez-vous d'avoir créé un réseau cloud virtuel (VCN) OCI et un sous-réseau où la machine virtuelle sera déployée.

Tâche 2 : création d'un VCN sur OCI (facultatif s'il n'est pas déjà créé)

Pour créer un VCN dans Oracle Cloud Infrastructure, reportez-vous à : Vidéo pour découvrir comment créer un réseau cloud virtuel sur OCI.

ou

Pour créer un VCN, procédez comme suit :

1. Connectez-vous à la console OCI, entrez Nom de locataire cloud, Nom utilisateur et Mot de passe.

2. Cliquez sur le menu hamburger (≡) dans le coin supérieur gauche.

3. Accédez à Fonctions de réseau, à Réseaux cloud virtuels et sélectionnez le compartiment approprié dans la section Portée de la liste.

4. Sélectionnez Réseau cloud virtuel avec connectivité Internet, et cliquez sur Lancer l'assistant de réseau cloud virtuel.

5. Sur la page Créer un VCN avec une connectivité Internet, entrez les informations suivantes et cliquez sur Suivant.

   • NOM du VCN : entrez OCI_HOL_VCN.
   • COMPARTMENT : sélectionnez le compartiment approprié.
   • Bloc CIDR VCN : entrez 10.0.0.0/16.
   • BLOCK de CIDR de sous-réseau PUBLIC : entrez 10.0.2.0/24.
   • Bloc CIDR de sous-réseau privé : entrez 10.0.1.0/24.
   • Résolution DNS : sélectionnez Utiliser des hôtes DNS dans ce VCN.

   

   Description de l'illustration setupVCN3.png

6. Sur la page Vérifier, vérifiez les paramètres et cliquez sur Créer.

   

   Description de l'illustration setupVCN4.png

   Il vous faudra un moment pour créer le VCN et un écran de progression vous tiendra au courant du workflow.

   

   Description de l'illustration workflow.png

7. Une fois le VCN créé, cliquez sur Visualiser le réseau cloud virtuel.

   Dans des situations réelles, vous allez créer plusieurs réseaux cloud virtuels en fonction de leur besoin d'accès (les ports à ouvrir) et des utilisateurs autorisés à y accéder.

Tâche 3 : voir les détails de configuration de cloud-init

Le script cloud-init installe toutes les dépendances nécessaires, démarre Docker, télécharge et démarre le ou les modèles Mistral vLLM. Vous pouvez trouver le code suivant dans le fichier cloudinit.sh téléchargé dans la tâche 1.

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 téléchargera tous les fichiers nécessaires pour exécuter le modèle Mistral basé sur votre jeton API prédéfini dans Hugging Face.

La création de jeton d'API sélectionnera le modèle Mistral en fonction de votre entrée dans l'interface graphique ORM, ce qui permettra l'authentification nécessaire pour télécharger les fichiers de modèle localement. Pour plus d'informations, reportez-vous à Jetons d'accès utilisateur.

Tâche 4 : surveiller le système

Suivez l'exécution du script cloud-init et l'utilisation des ressources GPU à l'aide des commandes suivantes (si nécessaire).

• Surveiller l'achèvement de cloud-init : tail -f /var/log/cloud-init-output.log.

• Surveiller l'utilisation des GPU : nvidia-smi dmon -s mu -c 100.

• Déployez le modèle vLLM Mistral et interagissez avec lui à l'aide de Python : (modifiez les paramètres uniquement si nécessaire (la commande est déjà incluse dans le script cloud-init) :

  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 &
  

Tâche 5 : tester l'intégration du modèle

Interagissez avec le modèle de la manière suivante à l'aide des commandes ou des détails de Jupyter Notebook.

• Testez le modèle à partir de l'interface de ligne de commande (CLI) une fois le script cloud-init terminé.

  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
  }'
  

• Testez le modèle à partir de Jupyter Notebook (assurez-vous d'ouvrir le 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)
  

• Intégrez Gradio au chatbot pour interroger le modèle.

  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)
  

Tâche 6 : déployer le modèle à l'aide de Docker (si nécessaire)

Vous pouvez également déployer le modèle à l'aide de Docker et d'une source externe.

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

Vous pouvez interroger le modèle de l'une des manières suivantes :

• Interrogez le modèle démarré avec Docker et une source externe à l'aide de l'interface de ligne de commande.

  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
  }'
  

• Interrogez le modèle avec Docker à partir d'une source externe à l'aide de Jupyter Notebook.

  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)
  

• Interrogez le modèle avec Docker à partir d'une source externe à l'aide de Jupyter Notebook et du chatbot Gradio.

  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)
  

• Modèle exécuté avec docker utilisant les fichiers locaux déjà téléchargés (démarre plus rapidement).

  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
  

• Interrogez le modèle avec Docker à l'aide des fichiers locaux et de l'interface de ligne de commande.

  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
  >  }'
  
  

• Interrogez le modèle avec Docker à l'aide des fichiers locaux et de Jupyter Notebook.

  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)
  

• Interrogez le modèle avec Docker à partir d'une source externe à l'aide de Jupyter Notebook et du chatbot Gradio.

  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)
  

  Remarque : commandes de pare-feu permettant d'ouvrir le port 8888 pour Jupyter Notebook.

  sudo firewall-cmd --zone=public --permanent --add-port 8888/tcp
  sudo firewall-cmd --reload
  sudo firewall-cmd --list-all
  

Remerciements

• Auteur - Bogdan Bazarca (ingénieur cloud senior)

• Contributeurs - Équipe Oracle NACI-AI-CN-DEV

Ressources de formation supplémentaires

Parcourez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, rendez-vous sur education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.

---

Informations relatives au titre et au copyright

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

G11814-01

July 2024

Copyright ©2024,

Oracle et/ou ses affiliés.