Ajuste su propio LLM personalizado utilizando Canonical Charmed Kubeflow y Feast

¿Entonces quieres tu propio LLM para mascotas?

Saber por dónde empezar puede ser bastante complicado, así que afortunadamente he elaborado esta guía de principio a fin. Le permitirá no sólo empezar; terminará con un chatbot completamente funcional que habrá ajustado en el conjunto de datos `nampdn-ai/tiny-webtext`, Este es un conjunto de entrenamiento diseñado para mejorar las habilidades de pensamiento crítico de su modelo. Abróchate el cinturón, esto será divertido y profundo.

Usaremos Canonical para todo Kubeflow fascinante – Plataforma Enterprise MLOps para el ajuste de modelos de un extremo a otro en entornos soberanos. Puede implementarlo en una computadora portátil de alto rendimiento o en el laboratorio de su hogar que ejecute Kubernetes. Si planea hacer esto a escala, puede incluso ejecutarlo en una fábrica de IA a escala de centro de datos con muchos nodos, aceleradores de GPU y estructuras de red de rendimiento ultraalto. Ver Kubeflow encantado Página del producto en canonical.com o Regístrese para recibir servicios de alojamiento, Ejecuta Charmed Kubeflow en su propio arrendamiento de Microsoft Azure y está respaldado por la gestión operativa 24 horas al día, 7 días a la semana de Canonical.

Todos los archivos que necesitas se pueden encontrar en el mío. repositorio de GitHubpero primero verifiquemos las especificaciones de su sistema. Para este proyecto necesitarás:

• Una o más computadoras con Ubuntu 24.04 LTS o superior, 32 GB de RAM y 16 núcleos, cuanto más, mejor
• Una conexión a Internet buena y estable puede descargar contenido más grande
• Tener algunos conocimientos de Linux y Kubernetes, al menos los suficientes para poder seguir y ejecutar comandos.
• Cuenta en Hugging Face para que puedas descargar el conjunto de datos que usaremos.

¿Suena bien? Fresco. Saquemos a relucir el sistema.

Abre tu terminal y asegúrate de tener instalado el software básico. Ejecute el siguiente comando:

sudo snap install microk8s --channel 1.34-strict/stable
sudo microk8s enable storage dns
sudo microk8s enable metallb 10.64.140.43-10.64.140.49
sudo snap install juju --channel 3.6/stable
sudo microk8s.config | juju add-k8s my-k8s --client
juju bootstrap my-k8s
sudo snap install terraform
sudo apt install git -y
git clone 
pushd charmed-kubeflow-solutions
git checkout track/1.11-rc
pushd terraform/products/kubeflow

Vale, genial. Esto le permite configurar un clúster de Kubernetes ultracompacto de un solo nodo que ejecute Canonical Micro K8con el motor de gestión de operaciones de Canonical Zhu Zhuy Terraform.

Ahora comencemos Charmed Kubeflow. Habilitaremos el sistema base Kubeflow, Kubeflow Trainer v2, el servidor modelo KServe y Feast. Retiraremos todos los demás módulos, como Katib, MLFlow, TensorBoard, Federated Login y Canonical Observability Stack. Puedes habilitarlos en cualquier momento si lo deseas.

DEX_USERNAME=username
DEX_PASSWORD=password
terraform init
terraform apply -auto-approve -var dex_static_username="${DEX_USERNAME}" -var dex_static_password="${DEX_PASSWORD}" -var enable_feast=true -var enable_katib=false -var enable_kserve=true -var enable_training_v2=true -var enable_training_v1=false -var enable_observability=false -var enable_tensorboard=false 
popd
popd

Una vez completado el plan Terraform, es posible que aún tarde hasta 10 minutos en aparecer en el clúster de Kubernetes. Puedes usar el comando «juju status» para monitorear cómo se están preparando las cosas. Cuando todo dice «Disponible», tendrá éxito y podrá intentar iniciar sesión en Kubeflow.

Abra una nueva pestaña en su navegador y establezca la dirección en http://10.64.140.43. Deberías ver una pantalla de inicio de sesión. Aquí podrá introducir el nombre de usuario y contraseña previamente establecidos en las variables «DEX_USERNAME» y «DEX_PASSWORD». Una vez que haya iniciado sesión, siga el asistente de configuración y debería ver la pantalla del panel de Kubeflow.

Ahora, vaya a Cuadernos en el menú de la izquierda e inicie un nuevo Jupyter Notebook. Asegúrese de darle a su computadora portátil un máximo de al menos 3 núcleos de CPU y 6 GB de RAM, ya que aquí realizará mucho trabajo. devolver, muy importantehay una configuración de «Opciones avanzadas», expándala y luego en la configuración, asegúrese de que «Permitir acceso a Kubeflow Pipelines» y «Permitir acceso a Feast» estén marcados antes de hacer clic en el botón de inicio. Esto inyectará toda la información necesaria en su Jupyter Notebook para poder acceder a estos servicios como archivos o variables de entorno.

Una vez que su computadora portátil esté disponible, verá un ícono de marca de verificación verde junto a ella en la lista de computadoras portátiles en su panel y el botón Conectar se activará. Presione Conectar y debería ver una nueva pestaña abierta en su navegador que contiene el servidor de su computadora portátil. En el iniciador, inicie una nueva sesión de terminal. Vamos a ejecutar algunos comandos.

Pero primero, familiaricémonos con la arquitectura de entrenamiento del modelo que usaremos para ajustar LLM.

Descripción general de la arquitectura

Como puede ver en la figura, extraeremos el conjunto de datos de Hugging Face, lo cargaremos en un repositorio de Postgres, lo registraremos como un almacén de funciones fuera de línea reutilizable en Feast y luego ejecutaremos el trabajo de capacitación usando Kubeflow Trainer v2. Conservaremos el punto de control del modelo en un volumen persistente de Kubernetes y luego lo ejecutaremos en un KServe para que podamos chatear con el nuevo LLM personalizado.

documentos del proyecto

La siguiente tabla enumera todos los archivos del proyecto. Puede encontrarlos en el repositorio de GitHub que acompaña a este artículo.

Obtenga todos los archivos en el repositorio de GitHub ejecutando el siguiente comando en una sesión de terminal de Jupyter Notebook:

git clone 

Recuperar un conjunto de datos en un almacén de características

Dado que elegimos implementar el módulo de almacenamiento de funciones Feast cuando configuramos inicialmente Charmed Kubeflow, en realidad no hay mucho que configurar. Necesitará las credenciales de la base de datos `offline_store` de Postgres, que puede encontrar en el archivo `/feast/feature_store.yaml` en su instancia de Jupyter Notebook. ¿Entiendo? Excelente. En una sesión de terminal de Jupyter Notebook, ingrese las siguientes variables de entorno, asegurándose de reemplazar los valores «su_usuario» y «su_contraseña» con valores adecuados para el almacenamiento fuera de línea de Postgres.

export POSTGRES_HOST="postgres.default.svc.cluster.local"
export POSTGRES_PORT="5432"
export POSTGRES_DB="offline_store"
export POSTGRES_USER="your_user"
export POSTGRES_PASSWORD="your_password"

Algunas dependencias que necesitamos faltan en la imagen estándar de Jupyter Notebook. Resolvamos este problema. Ejecute el siguiente comando en una sesión de terminal de Jupyter Notebook:

conda install gcc gxx_linux-64
mv fine-tune-your-own-custom-llm-with-canonical-charmed-kubeflow-and-feast kubeflow-feast-finetune
pushd kubeflow-feast-finetune
pip install -r requirements.txt
popd

Ahora debes iniciar sesión en tu cuenta de Hugging Face y autorizar la sesión. Puede hacer esto ejecutando el siguiente comando en una sesión de terminal de computadora portátil y siguiendo las instrucciones en pantalla.

hf auth login

Es posible que también tengas que aceptar los términos de uso del perfil si aún no lo has hecho. Necesitas hacer esto durante De lo contrario, recibirá un error cuando intente ejecutar el script de extracción.

Bien, ahora ejecute el siguiente comando en la sesión del terminal de su computadora portátil para descargar el conjunto de datos de Hugging Face y cargarlo en la base de datos PostgreSQL.

python kubeflow-feast-finetune/ingest_data.py

Registrar funcionalidad con Feast

El script `features.py` registrará las funciones en Feast. No necesitamos ejecutarlo directamente, el comando «fiesta» obtendrá el script y lo ejecutará por nosotros. Solo necesitamos copiar el archivo de configuración YAML de Feast en este directorio de antemano. Ejecute el siguiente comando en una sesión de terminal portátil:

pushd kubeflow-feast-finetune
cp /feast/feature_store.yaml .
feast apply
popd

Guión de entrenamiento del paquete

El siguiente comando creará un mapa de configuración de Kubernetes que carga todos los scripts y perfiles necesarios para el trabajo de capacitación. Ejecútelos en una sesión de terminal portátil como antes:

pushd kubeflow-feast-finetune
python3 -c '
import yaml

cm = {
    "apiVersion": "v1",
    "kind": "ConfigMap",
    "metadata": {"name": "feast-train-code", "namespace": "kubeflow"},
    "data": {
        "feature_store.yaml": open("feature_store.yaml").read(),
        "features.py": open("features.py").read(),
        "train.py": open("train.py").read()
    }
}
print(yaml.dump(cm))
' | kubectl apply -f -
popd

Crear una reclamación de volumen persistente (PVC) de Kubernetes

Cree un volumen de almacenamiento persistente de 20 GB en el espacio de nombres «kubeflow» utilizando el manifiesto «create_pvc.yaml». Lo necesitará más tarde porque sin él, su trabajo desaparecerá cuando complete su trabajo de capacitación. Ejecute el siguiente comando en una sesión de terminal portátil:

cat kubeflow-feast-finetune/create_pvc.yaml | kubectl apply -f -

Envíe un trabajo de ajuste para ejecutarlo en su clúster

El siguiente comando iniciará un trabajo de entrenamiento «distribuido con antorcha» en el clúster, utilizando solo una instancia de entrenamiento. Continúe y ejecute el comando en una sesión de terminal de Jupyter Notebook.

cat kubeflow-feast-finetune/train_job_no_registry.yaml | kubectl apply -f -

Debería ver un mensaje de confirmación de que el trabajo de capacitación se creó correctamente.

Capacitación en seguimiento

El entrenamiento tarda un poco en completarse, tal vez una hora o más, dependiendo de su hardware. Puede monitorearlo usando los siguientes comandos. Ejecútelo nuevamente en una sesión de terminal de Jupyter Notebook:

kubectl logs -f -l batch.kubernetes.io/job-name=feast-tiny-webtext-finetune -n kubeflow -f

El comando anterior le permitirá seguir el progreso de su trabajo de entrenamiento. Una vez completado, verá un mensaje en el resultado como «Trabajo de capacitación completado». Cuando vea esto, puede usar Control-C para dejar de rastrear el archivo de registro. Los pesos del modelo ajustados se almacenan en su disco de persistencia configurado.

Todo hecho. Ahora vamos a probarlo

Usando KServe para servir modelos

Implementemos un servidor modelo KServe en Kubernetes que apunte a su ruta PVC para que podamos chatear con él a través de una API REST como OpenAI, tal como usamos ChatGPT. El URI de almacenamiento en la siguiente lista de códigos apunta al volumen de almacenamiento («PVC») que creamos para la operación de capacitación para que el servidor modelo KServe pueda usar su salida para servir nuestro nuevo LLM ajustado. Ejecute el siguiente comando en una sesión de terminal de notebook Jupyter:

echo "apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  name: tiny-webtext-llm
  namespace: kubeflow
spec:
  predictor:
    model:
      modelFormat:
        name: huggingface
      storageUri: "pvc://model-checkpoint-pvc/"
      resources:
        limits:
          cpu: "4"
          memory: "8Gi"
        requests:
          cpu: "2"
          memory: "4Gi"
      args:
        - --model_id=/mnt/models
        - --backend=huggingface
        - --task=text_generation
" | kubectl apply -f -

Debe obtener la IP del servicio de razonamiento KServe para chatear con nuevos LL.M.s. Para simplificar las cosas, usaremos la dirección IP interna y chatearemos desde una sesión de terminal Jupyter Notebook. Podemos usar este comando de una línea para encontrar la dirección IP.

KSERVE_IP=$(kubectl get services -n kubeflow | grep tiny-webtext-llm-predictor | grep private | awk '{ print $3 }')

Ahora que tenemos la dirección IP, podemos chatear con el LLM personalizado.

curl -i    -H "Content-Type: application/json"   -d '{
    "model": "tiny-webtext-llm",
    "messages": [
      {"role": "user", "content": "What is your favorite color?"}
    ],
    "max_tokens": 80,
    "temperature": 0.2,
    "top_p": 0.9,
    "stop": ["\nHuman:", ""]
  }'

Deberías obtener algún tipo de respuesta:

«Me gusta el color de este auto. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia. Me gusta su apariencia».

Para ser justos, esto es un poco decepcionante. El modelo que hemos estado usando como modelo base para el ajuste fino (GPT-2) es un modelo muy temprano, lanzado públicamente en 2019. Para obtener mejores respuestas, puede intentar entrenar un modelo base más complejo usando el parámetro «-model-name» enviado a «train.py». Por ejemplo, puedes probar el modelo Qwen2.5-0.5B-Instruct, que es muy avanzado:

python train.py --model-name=Qwen/Qwen2.5-0.5B-Instruct

Haciendo la misma pregunta «¿Cuál es tu color favorito?» a este modelo más complejo se obtienen resultados muy diferentes:

«Lo más importante es encontrar algo que te guste y con lo que te sientas cómodo. Si te gusta un determinado color, ¡genial! Si no te gusta un determinado color, está bien. Solo recuerda elegir algo con lo que te sientas cómodo y que te guste. Esto te ayudará a sentirte más seguro y cómodo contigo mismo. Recuerda, está bien».

Sin embargo, tenga en cuenta que es posible que el modelo tarde más en ajustarse. Cuando intenté usar exactamente el mismo conjunto de datos, mi sistema tardó todo el día (sin GPU). Puedes solucionar este problema ajustando `train_job_no_registry.yaml`, pero me detendré aquí por ahora. Ya tienes todo lo que necesitas para seguir desarrollándote.