Note:

• Este tutorial requiere acceso a Oracle Cloud. Para registrarse en una cuenta gratuita, consulte Introducción a la cuenta gratuita de Oracle Cloud Infrastructure.
• Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al completar el laboratorio, sustituya estos valores por otros específicos de su entorno en la nube.

Ejecución del modelo de LLM de Mistral en la instancia A10 de OCI Compute con Oracle Resource Manager mediante el despliegue con un clic

Introducción

Oracle Cloud Infrastructure (OCI) Compute permite crear diferentes tipos de unidades para probar los modelos de unidad de procesamiento de gráficos (GPU) para inteligencia artificial (IA) desplegados localmente. En este tutorial, utilizaremos la unidad A10 con recursos de subred y VCN preexistentes que puede seleccionar de Oracle Resource Manager.

El código de Terraform también incluye la configuración de la instancia para ejecutar un modelo local de lenguaje grande virtual (vLLM) Mistral para tareas de procesamiento de lenguaje natural.

Objetivos

• Cree una unidad A10 en OCI Compute, descargue el modelo de LLM de Mistral AI y consulte el modelo de vLLM local.

Requisitos

• Asegúrese de tener una red virtual en la nube (VCN) de OCI y una subred en la que se desplegará la máquina virtual (VM).

• Comprensión de los componentes de red y sus relaciones. Para obtener más información, consulte Visión general de Networking.

• Descripción de las redes en la nube. Para obtener más información, consulte el siguiente vídeo: Video for Networking in the Cloud EP.01: Virtual Cloud Networks.

• Requisitos:

  • Tipo de instancia: unidad A10 con una GPU Nvidia.
  • Sistema operativo: Oracle Linux.
  • Selección de imagen: el script de despliegue selecciona la última imagen de Oracle Linux con soporte de GPU.
  • Etiquetas: agrega una etiqueta de formato libre GPU_TAG = "A10-1".
  • Tamaño del volumen de inicio: 250GB.
  • Inicialización: utiliza cloud-init para descargar y configurar los modelos de vLLM Mistral.

Tarea 1: Descarga del código de Terraform para el despliegue con un solo clic

Descargue el código de Terraform de ORM desde aquí: orm_stack_a10_gpu-main.zip para implantar modelos de Mistral vLLM de forma local, lo que le permitirá seleccionar una VCN existente y una subred para probar el despliegue local de modelos de Mistral vLLM en una unidad de instancia A10.

Una vez que haya descargado el código de Terraform de ORM de forma local, siga los pasos que se indican a continuación: Creación de una pila a partir de una carpeta para cargar la pila y ejecutar la aplicación del código de Terraform.

Nota: Asegúrese de haber creado una red virtual en la nube (VCN) de OCI y una subred en la que se desplegará la VM.

Tarea 2: Creación de una VCN en OCI (opcional si aún no se ha creado)

Para crear una VCN en Oracle Cloud Infrastructure, consulte: Vídeo para descubrir cómo crear una red virtual en la nube en OCI.

o bien,

Para crear una VCN, realice los siguientes pasos:

1. Conéctese a la consola de OCI, introduzca Nombre de inquilino en la nube, Nombre de usuario y Contraseña.

2. Haga clic en el menú de hamburguesa (≡) en la esquina superior izquierda.

3. Vaya a Red, Redes virtuales en la nube y seleccione el compartimento adecuado en la sección Ámbito de lista.

4. Seleccione VCN con conexión a Internet, y haga clic en Iniciar asistente de VCN.

5. En la página Crear una VCN con conexión a Internet, introduzca la siguiente información y haga clic en Siguiente.

   • NOMBRE de VCN: introduzca OCI_HOL_VCN.
   • COMPARTMENT: seleccione el compartimento adecuado.
   • Bloqueo de CIDR de VCN: introduzca 10.0.0.0/16.
   • BLOQUE de CIDR de la SUBRED PÚBLICA: introduzca 10.0.2.0/24.
   • BLOQUE DE CIDR DE SUBNET PRIVADA: introduzca 10.0.1.0/24.
   • Resolución de DNS: seleccione Usar nombres de host de DNS en esta VCN.

   

   Descripción de la ilustración setupVCN3.png

6. En la página Revisar, revise su configuración y haga clic en Crear.

   

   Descripción de la ilustración setupVCN4.png

   Tardará un momento en crear la VCN y una pantalla de progreso le mantendrá informado sobre el flujo de trabajo.

   

   Descripción de la ilustración workflow.png

7. Una vez creada la VCN, haga clic en View Virtual Cloud Network (Ver red virtual en la nube).

   En situaciones reales, creará varias redes virtuales en la nube en función de su necesidad de acceso (qué puertos abrir) y quién puede acceder a ellas.

Tarea 3: Consulte los detalles de configuración de cloud-init

El script cloud-init instala todas las dependencias necesarias, inicia Docker, descarga e inicia los modelos de vLLM Mistral. Puede encontrar el siguiente código en el archivo cloudinit.sh descargado en la tarea 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 descargará todos los archivos necesarios para ejecutar el modelo de Mistral basado en su token de API predefinido en Hugging Face.

La creación de token de API seleccionará el modelo de Mistral en función de su entrada desde la GUI de ORM, lo que permitirá la autenticación necesaria para descargar los archivos de modelo localmente. Para obtener más información, consulte Tokens de acceso de usuario.

Tarea 4: Supervisión del sistema

Realice un seguimiento de la finalización del script cloud-init y el uso de recursos de GPU con los siguientes comandos (si es necesario).

• Supervise la finalización de cloud-init: tail -f /var/log/cloud-init-output.log.

• Supervise el uso de GPU: nvidia-smi dmon -s mu -c 100.

• Desplegar e interactuar con el modelo de Mistral vLLM mediante Python: (cambie los parámetros solo si es necesario (el comando ya está incluido en el 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 &
  

Tarea 5: Prueba de la integración del modelo

Interactúe con el modelo de las siguientes formas mediante los comandos o los detalles de Jupyter Notebook.

• Pruebe el modelo desde la interfaz de línea de comandos (CLI) una vez que se haya completado la secuencia de comandos 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
  }'
  

• Pruebe el modelo desde el bloc de notas de Jupyter (asegúrese de abrir el puerto 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 el chatbot para consultar el modelo.

  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)
  

Tarea 6: Despliegue del modelo con Docker (si es necesario)

También puede desplegar el modelo mediante Docker y el origen externo.

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

Puede consultar el modelo de las siguientes formas:

• Consulte el modelo iniciado con Docker y el origen externo mediante la 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
  }'
  

• Consulte el modelo con Docker de origen externo mediante el bloc de notas de Jupyter.

  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)
  

• Consulte el modelo con Docker de origen externo mediante el bloc de notas de Jupyter y el bot conversacional de 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)
  

• Modelo que se ejecuta con docker mediante los archivos locales ya descargados (se inicia más rápido).

  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
  

• Consulte el modelo con Docker mediante los archivos locales y la 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
  >  }'
  
  

• Consulte el modelo con Docker mediante los archivos locales y el bloc de notas de Jupyter.

  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)
  

• Consulte el modelo con Docker de origen externo mediante el bloc de notas de Jupyter y el bot conversacional de 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)
  

  Nota: Comandos de firewall para abrir el puerto 8888 para el bloc de notas de Jupyter.

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

Agradecimientos

• Autor: Bogdan Bazarca (ingeniero sénior en la nube)

• Contribuyentes: equipo de Oracle NACI-AI-CN-DEV

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.

---

Título e Información de Copyright

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

G11821-01

July 2024

Copyright ©2024,

Oracle y/o sus filiales.