Made With ML
1.0.0
Aprenda a combinar el aprendizaje automático con la ingeniería de software para diseñar, desarrollar, implementar e iterar aplicaciones de aprendizaje automático de nivel de producción.
En este curso pasaremos de la experimentación (diseño + desarrollo) a la producción (implementación + iteración). Haremos esto de forma iterativa motivando los componentes que nos permitirán construir un sistema de producción confiable .
Asegúrese de ver el vídeo a continuación para obtener una descripción general rápida de lo que crearemos.
El aprendizaje automático no es una industria separada; más bien, es una forma poderosa de pensar sobre los datos que no está reservada para ningún tipo de persona en particular.
Asegúrese de seguir el curso para obtener un recorrido mucho más detallado del contenido de este repositorio. Tendremos instrucciones para las computadoras portátiles locales y los clústeres de Anyscale para las secciones siguientes, así que asegúrese de alternar el menú desplegable ► según lo que esté utilizando (las instrucciones de Anyscale se activarán de forma predeterminada). Si desea realizar este curso con Anyscale, donde le brindaremos la estructura , la computación (GPU) y la comunidad para aprender todo en un día, únase a nuestra próxima cohorte en vivo → ¡regístrese aquí!
Comenzaremos configurando nuestro clúster con el entorno y las configuraciones informáticas.
Podemos crear un espacio de trabajo a cualquier escala utilizando la interfaz de usuario de la página web.
- Workspace name: ` madewithml `
- Project: ` madewithml `
- Cluster environment name: ` madewithml-cluster-env `
# Toggle ` Select from saved configurations `
- Compute config: ` madewithml-cluster-compute-g5.4xlarge `Alternativamente, podemos usar la CLI para crear el espacio de trabajo mediante
anyscale workspace create ...
Si no deseas realizar este curso localmente o a través de Anyscale, tienes las siguientes opciones:
Cree un repositorio siguiendo estas instrucciones: Cree un nuevo repositorio → asígnele el nombre Made-With-ML → Alternar Add a README file ( muy importante ya que esto crea una rama main ) → Haga clic en Create repository (desplácese hacia abajo)
Ahora estamos listos para clonar el repositorio que tiene todo nuestro código:
git clone https://github.com/GokuMohandas/Made-With-ML.git .touch .env # Inside .env
GITHUB_USERNAME= " CHANGE_THIS_TO_YOUR_USERNAME " # ← CHANGE THIS source .env export PYTHONPATH= $PYTHONPATH : $PWD
python3 -m venv venv # recommend using Python 3.10
source venv/bin/activate # on Windows: venvScriptsactivate
python3 -m pip install --upgrade pip setuptools wheel
python3 -m pip install -r requirements.txt
pre-commit install
pre-commit autoupdateRecomiendo encarecidamente usar Python
3.10y pyenv (mac) o pyenv-win (windows).
Nuestro entorno con la versión y las bibliotecas de Python adecuadas ya está configurado para nosotros a través del entorno de clúster que utilizamos al configurar nuestro Anyscale Workspace. Entonces solo necesitamos ejecutar estos comandos:
export PYTHONPATH= $PYTHONPATH : $PWD
pre-commit install
pre-commit autoupdateComience explorando el cuaderno de jupyter para recorrer de forma interactiva las cargas de trabajo principales de aprendizaje automático.
# Start notebook
jupyter lab notebooks/madewithml.ipynb Haga clic en el ícono de Jupyter en la esquina superior derecha de nuestra página Anyscale Workspace y esto abrirá nuestra instancia de JupyterLab en una nueva pestaña. Luego navegue hasta el directorio notebooks y abra el cuaderno madewithml.ipynb .
Ahora ejecutaremos las mismas cargas de trabajo utilizando los scripts limpios de Python siguiendo las mejores prácticas de ingeniería de software (pruebas, documentación, registro, servicio, control de versiones, etc.). El código que hemos implementado en nuestro cuaderno se refactorizará en los siguientes scripts:
madewithml
├── config.py
├── data.py
├── evaluate.py
├── models.py
├── predict.py
├── serve.py
├── train.py
├── tune.py
└── utils.py Nota : Cambie los valores de los argumentos de entrada --num-workers , --cpu-per-worker y --gpu-per-worker a continuación según los recursos de su sistema. Por ejemplo, si está en una computadora portátil local, una configuración razonable sería --num-workers 6 --cpu-per-worker 1 --gpu-per-worker 0 .
export EXPERIMENT_NAME= " llm "
export DATASET_LOC= " https://raw.githubusercontent.com/GokuMohandas/Made-With-ML/main/datasets/dataset.csv "
export TRAIN_LOOP_CONFIG= ' {"dropout_p": 0.5, "lr": 1e-4, "lr_factor": 0.8, "lr_patience": 3} '
python madewithml/train.py
--experiment-name " $EXPERIMENT_NAME "
--dataset-loc " $DATASET_LOC "
--train-loop-config " $TRAIN_LOOP_CONFIG "
--num-workers 1
--cpu-per-worker 3
--gpu-per-worker 1
--num-epochs 10
--batch-size 256
--results-fp results/training_results.json export EXPERIMENT_NAME= " llm "
export DATASET_LOC= " https://raw.githubusercontent.com/GokuMohandas/Made-With-ML/main/datasets/dataset.csv "
export TRAIN_LOOP_CONFIG= ' {"dropout_p": 0.5, "lr": 1e-4, "lr_factor": 0.8, "lr_patience": 3} '
export INITIAL_PARAMS= " [{ " train_loop_config " : $TRAIN_LOOP_CONFIG }] "
python madewithml/tune.py
--experiment-name " $EXPERIMENT_NAME "
--dataset-loc " $DATASET_LOC "
--initial-params " $INITIAL_PARAMS "
--num-runs 2
--num-workers 1
--cpu-per-worker 3
--gpu-per-worker 1
--num-epochs 10
--batch-size 256
--results-fp results/tuning_results.jsonUsaremos MLflow para realizar un seguimiento de nuestros experimentos y almacenar nuestros modelos y la interfaz de usuario de seguimiento de MLflow para ver nuestros experimentos. Hemos estado guardando nuestros experimentos en un directorio local, pero tenga en cuenta que en un entorno de producción real, tendríamos una ubicación central para almacenar todos nuestros experimentos. Es fácil y económico crear su propio servidor MLflow para que todos los miembros de su equipo realicen un seguimiento de sus experimentos o utilicen una solución administrada como Weights & Biases, Comet, etc.
export MODEL_REGISTRY= $( python -c " from madewithml import config; print(config.MODEL_REGISTRY) " )
mlflow server -h 0.0.0.0 -p 8080 --backend-store-uri $MODEL_REGISTRYSi está ejecutando este cuaderno en su computadora portátil local, diríjase a http://localhost:8080/ para ver su panel de MLflow.
Si está en Anyscale Workspaces, primero debemos exponer el puerto del servidor MLflow. Ejecute el siguiente comando en su terminal Anyscale Workspace para generar la URL pública a su servidor MLflow.
APP_PORT=8080
echo https:// $APP_PORT -port- $ANYSCALE_SESSION_DOMAIN export EXPERIMENT_NAME= " llm "
export RUN_ID= $( python madewithml/predict.py get-best-run-id --experiment-name $EXPERIMENT_NAME --metric val_loss --mode ASC )
export HOLDOUT_LOC= " https://raw.githubusercontent.com/GokuMohandas/Made-With-ML/main/datasets/holdout.csv "
python madewithml/evaluate.py
--run-id $RUN_ID
--dataset-loc $HOLDOUT_LOC
--results-fp results/evaluation_results.json{
"timestamp" : " June 09, 2023 09:26:18 AM " ,
"run_id" : " 6149e3fec8d24f1492d4a4cabd5c06f6 " ,
"overall" : {
"precision" : 0.9076136428670714 ,
"recall" : 0.9057591623036649 ,
"f1" : 0.9046792827719773 ,
"num_samples" : 191.0
},
... export EXPERIMENT_NAME= " llm "
export RUN_ID= $( python madewithml/predict.py get-best-run-id --experiment-name $EXPERIMENT_NAME --metric val_loss --mode ASC )
python madewithml/predict.py predict
--run-id $RUN_ID
--title " Transfer learning with transformers "
--description " Using transformers for transfer learning on text classification tasks. " [{
"prediction" : [
" natural-language-processing "
],
"probabilities" : {
"computer-vision" : 0.0009767753 ,
"mlops" : 0.0008223939 ,
"natural-language-processing" : 0.99762577 ,
"other" : 0.000575123
}
}] # Start
ray start --head # Set up
export EXPERIMENT_NAME= " llm "
export RUN_ID= $( python madewithml/predict.py get-best-run-id --experiment-name $EXPERIMENT_NAME --metric val_loss --mode ASC )
python madewithml/serve.py --run_id $RUN_IDUna vez que la aplicación se esté ejecutando, podemos usarla mediante cURL, Python, etc.:
# via Python
import json
import requests
title = "Transfer learning with transformers"
description = "Using transformers for transfer learning on text classification tasks."
json_data = json . dumps ({ "title" : title , "description" : description })
requests . post ( "http://127.0.0.1:8000/predict" , data = json_data ). json ()ray stop # shutdownEn Anyscale Workspaces, Ray ya se está ejecutando, por lo que no tenemos que iniciarlo/apagarlo manualmente como lo tenemos que hacer localmente.
# Set up
export EXPERIMENT_NAME= " llm "
export RUN_ID= $( python madewithml/predict.py get-best-run-id --experiment-name $EXPERIMENT_NAME --metric val_loss --mode ASC )
python madewithml/serve.py --run_id $RUN_IDUna vez que la aplicación se esté ejecutando, podemos usarla mediante cURL, Python, etc.:
# via Python
import json
import requests
title = "Transfer learning with transformers"
description = "Using transformers for transfer learning on text classification tasks."
json_data = json . dumps ({ "title" : title , "description" : description })
requests . post ( "http://127.0.0.1:8000/predict" , data = json_data ). json () # Code
python3 -m pytest tests/code --verbose --disable-warnings
# Data
export DATASET_LOC= " https://raw.githubusercontent.com/GokuMohandas/Made-With-ML/main/datasets/dataset.csv "
pytest --dataset-loc= $DATASET_LOC tests/data --verbose --disable-warnings
# Model
export EXPERIMENT_NAME= " llm "
export RUN_ID= $( python madewithml/predict.py get-best-run-id --experiment-name $EXPERIMENT_NAME --metric val_loss --mode ASC )
pytest --run-id= $RUN_ID tests/model --verbose --disable-warnings
# Coverage
python3 -m pytest tests/code --cov madewithml --cov-report html --disable-warnings # html report
python3 -m pytest tests/code --cov madewithml --cov-report term --disable-warnings # terminal report A partir de este momento, para implementar nuestra aplicación en producción, necesitaremos estar en Anyscale o en una máquina virtual en la nube o un clúster local que administre usted mismo (con Ray). Si no está en Anyscale, los comandos serán ligeramente diferentes pero los conceptos serán los mismos.
Si no desea configurar todo esto usted mismo, le recomendamos unirse a nuestro próximo grupo en vivo{:target="_blank"} donde le brindaremos un entorno con toda esta infraestructura ya configurada para que pueda Simplemente centrado en el aprendizaje automático.
Estas credenciales a continuación se configuran automáticamente para nosotros si utilizamos Anyscale Workspaces. No necesitamos configurar estas credenciales explícitamente en los espacios de trabajo, pero sí lo hacemos si lo ejecutamos localmente o en un clúster fuera de donde están configurados para ejecutarse nuestros trabajos y servicios de Anyscale.
export ANYSCALE_HOST=https://console.anyscale.com
export ANYSCALE_CLI_TOKEN= $YOUR_CLI_TOKEN # retrieved from Anyscale credentials pageEl entorno del clúster determina dónde se ejecutarán nuestras cargas de trabajo (SO, dependencias, etc.). Ya hemos creado este entorno de clúster, pero así es como podemos crear/actualizar uno nosotros mismos.
export CLUSTER_ENV_NAME= " madewithml-cluster-env "
anyscale cluster-env build deploy/cluster_env.yaml --name $CLUSTER_ENV_NAMELa configuración informática determina en qué recursos se ejecutarán nuestras cargas de trabajo. Ya hemos creado esta configuración informática, pero así es como podemos crearla nosotros mismos.
export CLUSTER_COMPUTE_NAME= " madewithml-cluster-compute-g5.4xlarge "
anyscale cluster-compute create deploy/cluster_compute.yaml --name $CLUSTER_COMPUTE_NAME Ahora estamos listos para ejecutar nuestras cargas de trabajo de ML. Hemos decidido combinarlos todos en un solo trabajo, pero también podríamos haber creado trabajos separados para cada carga de trabajo (entrenar, evaluar, etc.). Comenzaremos editando las ranuras $GITHUB_USERNAME dentro de nuestro archivo workloads.yaml :
runtime_env :
working_dir : .
upload_path : s3://madewithml/$GITHUB_USERNAME/jobs # <--- CHANGE USERNAME (case-sensitive)
env_vars :
GITHUB_USERNAME : $GITHUB_USERNAME # <--- CHANGE USERNAME (case-sensitive) runtime_env aquí especifica que debemos cargar nuestro working_dir actual en un depósito de S3 para que todos nuestros trabajadores cuando ejecutemos un trabajo a cualquier escala tengan acceso al código a usar. GITHUB_USERNAME se usa más adelante para guardar los resultados de nuestras cargas de trabajo en S3 para que podamos recuperarlos más tarde (por ejemplo, para publicarlos).
Ahora estamos listos para enviar nuestro trabajo para ejecutar nuestras cargas de trabajo de ML:
anyscale job submit deploy/jobs/workloads.yaml Y una vez ejecutadas nuestras cargas de trabajo de ML, estamos listos para lanzar nuestro modelo a producción. De manera similar a nuestras configuraciones de Anyscale Jobs, asegúrese de cambiar $GITHUB_USERNAME serve_model.yaml .
ray_serve_config :
import_path : deploy.services.serve_model:entrypoint
runtime_env :
working_dir : .
upload_path : s3://madewithml/$GITHUB_USERNAME/services # <--- CHANGE USERNAME (case-sensitive)
env_vars :
GITHUB_USERNAME : $GITHUB_USERNAME # <--- CHANGE USERNAME (case-sensitive)Ahora estamos listos para lanzar nuestro servicio:
# Rollout service
anyscale service rollout -f deploy/services/serve_model.yaml
# Query
curl -X POST -H " Content-Type: application/json " -H " Authorization: Bearer $SECRET_TOKEN " -d ' {
"title": "Transfer learning with transformers",
"description": "Using transformers for transfer learning on text classification tasks."
} ' $SERVICE_ENDPOINT /predict/
# Rollback (to previous version of the Service)
anyscale service rollback -f $SERVICE_CONFIG --name $SERVICE_NAME
# Terminate
anyscale service terminate --name $SERVICE_NAMENo implementaremos manualmente nuestra aplicación cada vez que hagamos un cambio. En lugar de eso, ¡automatizaremos este proceso usando GitHub Actions!
git remote set-url origin https://github.com/ $GITHUB_USERNAME /Made-With-ML.git # <-- CHANGE THIS to your username
git checkout -b dev/settings/secrets/actions de nuestro repositorio de GitHub. export ANYSCALE_HOST=https://console.anyscale.com
export ANYSCALE_CLI_TOKEN= $YOUR_CLI_TOKEN # retrieved from https://console.anyscale.com/o/madewithml/credentialsmain ) y enviarlos a GitHub. Pero para enviar nuestro código a GitHub, primero necesitaremos autenticarnos con nuestras credenciales antes de enviarlo a nuestro repositorio: git config --global user.name $GITHUB_USERNAME # <-- CHANGE THIS to your username
git config --global user.email [email protected] # <-- CHANGE THIS to your email
git add .
git commit -m " " # <-- CHANGE THIS to your message
git push origin dev Ahora se le pedirá que ingrese su nombre de usuario y contraseña (token de acceso personal). Siga estos pasos para obtener un token de acceso personal: Nuevo token de acceso personal de GitHub → Agregar un nombre → Alternar repo y workflow → Haga clic en Generate token (desplácese hacia abajo) → Copie el token y péguelo cuando se le solicite su contraseña.
main y esto activará el flujo de trabajo de las cargas de trabajo. Si el flujo de trabajo (trabajos a cualquier escala) tiene éxito, se producirán comentarios con los resultados de la capacitación y la evaluación directamente en el RP.main . ¡Esto activará el flujo de trabajo de servicio que implementará nuestro nuevo servicio en producción!Con nuestro flujo de trabajo CI/CD implementado para implementar nuestra aplicación, ahora podemos concentrarnos en mejorar continuamente nuestro modelo. Se vuelve realmente fácil ampliar esta base para conectarse a ejecuciones programadas (cron), canalizaciones de datos, desviaciones detectadas a través del monitoreo, evaluación en línea, etc. Y podemos agregar fácilmente contexto adicional, como comparar cualquier experimento con lo que está actualmente en producción (directamente). en el PR incluso), etc.
¿Problemas con la configuración de los cuadernos con jupyter? De forma predeterminada, jupyter usará el kernel con nuestro entorno virtual, pero también podemos agregarlo manualmente a jupyter:
python3 -m ipykernel install --user --name=venv Ahora podemos abrir un cuaderno → Kernel (barra de menú superior) → Cambiar Kernel → venv . Para eliminar alguna vez este kernel, podemos hacer lo siguiente:
jupyter kernelspec list
jupyter kernelspec uninstall venv
