Nota

• Questa esercitazione richiede l'accesso a Oracle Cloud. Per iscriverti a un account gratuito, consulta Inizia a utilizzare Oracle Cloud Infrastructure Free Tier.
• Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Al termine del laboratorio, sostituisci questi valori con quelli specifici del tuo ambiente cloud.

Esegui modello LLM Mistral sull'istanza di OCI Compute A10 con Oracle Resource Manager utilizzando la distribuzione con un clic

Introduzione

Oracle Cloud Infrastructure (OCI) Compute ti consente di creare diversi tipi di forme per testare i modelli GPU (Graphics Processing Unit) per l'intelligenza artificiale (AI) distribuiti localmente. In questa esercitazione verrà utilizzata la forma A10 con una VCN e risorse di subnet preesistenti che è possibile selezionare da Oracle Resource Manager.

Il codice Terraform include anche la configurazione dell'istanza per l'esecuzione di un modello o di modelli Mistral Virtual Large Language Model (vLLM) locale per i task di elaborazione del linguaggio naturale.

Obiettivi

• Creare una forma A10 su OCI Compute, scaricare il modello LLM AI Mistral ed eseguire query sul modello vLLM locale.

Prerequisiti

• Assicurarsi di disporre di una rete cloud virtuale (VCN) OCI e di una subnet in cui verrà distribuita la virtual machine (VM).

• Comprensione dei componenti della rete e delle loro relazioni. Per ulteriori informazioni, vedere Panoramica della rete.

• Comprensione del networking nel cloud. Per ulteriori informazioni, guarda il video seguente: Video for Networking in the Cloud EP.01: Virtual Cloud Networks.

• Requisiti:

  • Tipo di istanza: forma A10 con una GPU Nvidia.
  • Sistema operativo: Oracle Linux.
  • Selezione dell'immagine: lo script di distribuzione seleziona l'immagine Oracle Linux più recente con supporto GPU.
  • Tag: aggiunge un tag in formato libero GPU_TAG = "A10-1".
  • Dimensione volume di avvio: 250GB.
  • Inizializzazione: utilizza cloud-init per scaricare e configurare il modello o i modelli di Mistral vLLM.

Task 1: scaricare il codice Terraform per la distribuzione con un clic

Scarica il codice Terraform ORM da qui: orm_stack_a10_gpu-main.zip, per implementare localmente i modelli vLLM Mistral che ti consentiranno di selezionare una VCN e una subnet esistenti per eseguire il test della distribuzione locale dei modelli vLLM Mistral in una forma di istanza A10.

Dopo aver scaricato localmente il codice Terraform ORM, seguire la procedura descritta di seguito: Creazione di uno stack da una cartella per caricare lo stack ed eseguire l'applicazione del codice Terraform.

Nota: assicurarsi di aver creato una rete cloud virtuale (VCN) OCI e una subnet in cui verrà distribuita la VM.

Task 2: creare una VCN su OCI (facoltativo se non è già stata creata)

Per creare una VCN in Oracle Cloud Infrastructure, consulta: Video per scoprire come creare una rete cloud virtuale su OCI.

o

Per creare una VCN, effettuare le operazioni riportate di seguito.

1. Eseguire il login a OCI Console, immettere Nome tenant cloud, Nome utente e Password.

2. Clicca sul menu hamburger (≡) dall'angolo in alto a sinistra.

3. Andare a Rete di rete, Reti cloud virtuali e selezionare il compartimento appropriato dalla sezione Elenco ambito.

4. Selezionare VCN con connettività Internet e fare clic su Avvia procedura guidata VCN.

5. Nella pagina Crea una VCN con connettività Internet, immettere le informazioni riportate di seguito e fare clic su Avanti.

   • NOME della VCN: immettere OCI_HOL_VCN.
   • COMPARTMENT: selezionare il compartimento appropriato.
   • Bloc CIDR VCN: immettere 10.0.0.0/16.
   • BLOC CIDR SUBNET PUBLIC: immettere 10.0.2.0/24.
   • BLOC CIDR PRIVATE SUBNET: immettere 10.0.1.0/24.
   • Risoluzione DNS: selezionare USI HOSTNAMES DNS IN questa VCN.

   

   Descrizione dell'immagine setupVCN3.png

6. Nella pagina Rivedi, rivedere le impostazioni e fare clic su Crea.

   

   Descrizione dell'immagine setupVCN4.png

   La creazione della VCN richiederà un momento e una schermata di avanzamento ti manterrà al corrente del flusso di lavoro.

   

   Descrizione dell'immagine workflow.png

7. Dopo aver creato la VCN, fare clic su Visualizza rete cloud virtuale.

   In situazioni reali, creerai più VCN in base alla loro necessità di accesso (quali porte aprire) e a chi può accedervi.

Task 3: vedere i dettagli di configurazione di cloud-init

Lo script cloud-init installa tutte le dipendenze necessarie, avvia Docker, scarica e avvia il modello o i modelli Mistral vLLM. È possibile trovare il codice seguente nel file cloudinit.sh scaricato nel task 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 scaricherà tutti i file necessari per eseguire il modello Mistral in base al token API predefinito in Hugging Face.

La creazione del token API selezionerà il modello Mistral in base all'input fornito dalla GUI di ORM, consentendo l'autenticazione necessaria per scaricare localmente i file del modello. Per ulteriori informazioni, vedere Token di accesso utente.

Task 4: Monitorare il sistema

Traccia il completamento dello script cloud-init e l'uso delle risorse GPU con i seguenti comandi (se necessario).

• Monitora il completamento dell'inizializzazione cloud: tail -f /var/log/cloud-init-output.log.

• Monitorare l'utilizzo delle GPU: nvidia-smi dmon -s mu -c 100.

• Distribuire e interagire con il modello Mistral vLLM utilizzando Python: (modificare i parametri solo se necessario (il comando è già incluso nello 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 &
  

Task 5: Test dell'integrazione del modello

Interagire con il modello nei modi seguenti utilizzando i comandi o i dettagli di Jupyter Notebook.

• Eseguire il test del modello dall'interfaccia CLI (Command Line Interface) una volta completato lo script cloud-init.

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

• Eseguire il test del modello da Jupyter Notebook (assicurarsi di aprire la porta 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)
  

• Integra Gradio con Chatbot per eseguire query sul modello.

  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)
  

Task 6: distribuire il modello utilizzando Docker (se necessario)

In alternativa, distribuisci il modello utilizzando Docker e un'origine esterna.

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

È possibile eseguire una query sul modello nei modi riportati di seguito.

• Esegui una query sul modello avviato con Docker e un'origine esterna utilizzando l'interfaccia CLI.

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

• Esegui una query sul modello con Docker da un'origine esterna utilizzando 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)
  

• Esegui una query sul modello con Docker da un'origine esterna utilizzando Jupyter Notebook e Gradio Chatbot.

  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)
  

• Modello in esecuzione con docker utilizzando i file locali già scaricati (avvia più rapidamente).

  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
  

• Esegui una query sul modello con Docker utilizzando i file locali e l'interfaccia CLI.

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

• Esegui una query sul modello con Docker utilizzando i file locali e 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)
  

• Esegui una query sul modello con Docker da un'origine esterna utilizzando Jupyter Notebook e Gradio Chatbot.

  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)
  

  Nota: i comandi del firewall per aprire la porta 8888 per Jupyter Notebook.

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

Conferme

• Autore - Bogdan Bazarca (ingegnere senior del cloud)

• Contributori: team Oracle NACI-AI-CN-DEV

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.

---

Titolo e informazioni sul copyright

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

G11815-01

July 2024

Copyright ©2024,

Oracle e/o relative consociate.