mlops course
1.0.0
Aprenda a combinar aprendizado de máquina com engenharia de software para projetar, desenvolver, implantar e iterar em aplicativos de ML de grau de produção.
Neste curso, iremos de experimentação (design do modelo + desenvolvimento) à produção (implantação do modelo + iteração). Faremos isso iterativamente, motivando os componentes que nos permitirão construir um sistema de produção confiável .
Certifique -se de assistir ao vídeo abaixo para uma rápida visão geral do que estaremos construindo.
O aprendizado de máquina não é um setor separado; em vez disso, é uma maneira poderosa de pensar sobre dados que não são reservados para nenhum tipo de pessoa.
Certifique -se de seguir o curso para obter um passo a passo muito mais detalhado do conteúdo deste repositório. Teremos instruções para laptop local e clusters de qualquer escala para as seções abaixo; portanto, altere o suspensão ► com base no que você está usando (as instruções de qualquer escala serão ativadas por padrão). Se você deseja executar este curso com qualquer escala, onde forneceremos a estrutura , computaremos (GPUs) e a comunidade para aprender tudo em um fim de semana, participe de nossa próxima coorte ao vivo → Inscreva -se aqui!
Começaremos configurando nosso cluster com o ambiente e calcular as configurações.
Podemos criar um espaço de trabalho qualquer escala usando a interface do usuário da página da web.
- Workspace name: ` madewithml `
- Project: ` madewithml `
- Cluster environment name: ` madewithml-cluster-env `
# Toggle ` Select from saved configurations `
- Compute config: ` madewithml-cluster-compute `Como alternativa, podemos usar a CLI para criar o espaço de trabalho por meio de
anyscale workspace create ...
Se você não quiser fazer este curso localmente ou por meio de qualquer escala, você tem as seguintes opções:
Crie um repositório seguindo estas instruções: Crie um novo repositório → Nome que ele Made-With-ML → Alterna Add a README file ( muito importante à medida que isso cria uma ramificação main ) → Clique em Create repository (role para baixo)
Agora estamos prontos para clonar o repositório que tem todo o nosso código:
git clone https://github.com/GokuMohandas/Made-With-ML.git .
git remote set-url origin https://github.com/GITHUB_USERNAME/Made-With-ML.git # <-- CHANGE THIS to your username
git checkout -b dev 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 autoupdateRecomendo usar o Python
3.10e usar Pyenv (Mac) ou Pyenv-WIN (Windows).
Nosso ambiente com a versão e bibliotecas Python apropriadas já está definida para nós através do ambiente de cluster que usamos ao configurar nosso espaço de trabalho Anyscale. Então, só precisamos executar esses comandos:
export PYTHONPATH= $PYTHONPATH : $PWD
pre-commit install
pre-commit autoupdateComece explorando o notebook Jupyter para acaso interativamente as cargas de trabalho de aprendizado de máquina principal.
# Start notebook
jupyter lab notebooks/madewithml.ipynb Clique no ícone Jupyter no canto superior direito da nossa página de espaço de trabalho Anyscale e isso abrirá nossa instância do JupyterLab em uma nova guia. Em seguida, navegue até o diretório notebooks e abra o notebook madewithml.ipynb .
Agora, executaremos as mesmas cargas de trabalho usando os scripts limpos do Python seguindo as melhores práticas de engenharia de software (testes, documentação, log, porção, versão etc.) O código que implementamos em nosso notebook será reformado nos seguintes scripts:
madewithml
├── config.py
├── data.py
├── evaluate.py
├── models.py
├── predict.py
├── serve.py
├── train.py
├── tune.py
└── utils.py NOTA : Altere os valores de argumento de entrada --num-workers --cpu-per-worker e --gpu-per-worker abaixo com base nos recursos do seu sistema. Por exemplo, se você estiver em um laptop local, uma configuração razoável seria --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 o MLFlow para rastrear nossos experimentos e armazenar nossos modelos e a interface do usuário de rastreamento do MLFlow para visualizar nossos experimentos. Estamos salvando nossos experimentos em um diretório local, mas observe que, em um ambiente de produção real, teríamos um local central para armazenar todos os nossos experimentos. É fácil/barato aumentar seu próprio servidor MLFlow para todos os membros da sua equipe rastrear seus experimentos ou usar uma solução gerenciada como pesos e preconceitos, cometa 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_REGISTRYSe você estiver executando este notebook no seu laptop local, vá para http: // localhost: 8080/para visualizar o painel MLFlow.
Se você estiver em AnyScale Workspace, precisamos expor primeiro a porta do servidor MLFlow. Execute o seguinte comando no seu terminal de espaço de trabalho Anyscale para gerar o URL público para o seu 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
},
... # Get run ID
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_IDEnquanto o aplicativo estiver em execução, podemos usá -lo via Curl, Python, etc.:
# via cURL
curl -X POST -H " Content-Type: application/json " -d ' {
"title": "Transfer learning with transformers",
"description": "Using transformers for transfer learning on text classification tasks."
} ' http://127.0.0.1:8000/predict # 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 # shutdown export HOLDOUT_LOC= " https://raw.githubusercontent.com/GokuMohandas/Made-With-ML/main/datasets/holdout.csv "
curl -X POST -H " Content-Type: application/json " -d ' {
"dataset_loc": "https://raw.githubusercontent.com/GokuMohandas/Made-With-ML/main/datasets/holdout.csv"
} ' http://127.0.0.1:8000/evaluateEm qualquer espaços de trabalho de qualquer escala, Ray já está em execução, então não precisamos iniciar/desligar manualmente como teremos que fazer 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_IDEnquanto o aplicativo estiver em execução, podemos usá -lo via Curl, Python, etc.:
# via cURL
curl -X POST -H " Content-Type: application/json " -d ' {
"title": "Transfer learning with transformers",
"description": "Using transformers for transfer learning on text classification tasks."
} ' http://127.0.0.1:8000/predict # 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 --cov madewithml --cov-report htmlA partir deste ponto, para implantar nosso aplicativo na produção, precisaremos estar em qualquer escala ou em um cluster de nuvem VM / On-Prem que você gerencia (com raio). Se não estiver em qualquer escala, os comandos serão um pouco diferentes, mas os conceitos serão os mesmos.
Se você não deseja configurar tudo isso, é altamente recomendável ingressar em nossa próxima coorte ao vivo {: Target = "_ Blank"}, onde forneceremos um ambiente com toda essa infraestrutura já configurada para você, para que você se concentre no aprendizado de máquina.
Essas credenciais abaixo são definidas automaticamente para nós se estamos usando os espaços de trabalho AnyScale. Não precisamos definir essas credenciais explicitamente em espaços de trabalho, mas fazemos se estivermos executando isso localmente ou em um cluster fora de onde nossos trabalhos e serviços de qualquer escala estão configurados para executar.
export ANYSCALE_HOST=https://console.anyscale.com
export ANYSCALE_CLI_TOKEN= $YOUR_CLI_TOKEN # retrieved from Anyscale credentials pageO ambiente de cluster determina onde nossas cargas de trabalho serão executadas (OS, dependências etc.) já criamos esse ambiente de cluster para nós, mas é assim que podemos criar/atualizar um.
export CLUSTER_ENV_NAME= " madewithml-cluster-env "
anyscale cluster-env build deploy/cluster_env.yaml --name $CLUSTER_ENV_NAMEA configuração de computação determina quais recursos nossas cargas de trabalho serão executadas. Já criamos essa configuração de computação para nós, mas é assim que podemos criá -la.
export CLUSTER_COMPUTE_NAME= " madewithml-cluster-compute "
anyscale cluster-compute create deploy/cluster_compute.yaml --name $CLUSTER_COMPUTE_NAME Agora estamos prontos para executar nossas cargas de trabalho em ML. Decidimos combiná -los todos em um emprego, mas também poderíamos ter criado trabalhos separados para cada carga de trabalho (treinar, avaliar etc.) Vamos começar editando os slots $GITHUB_USERNAME dentro do nosso arquivo 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) O runtime_env aqui especifica que devemos fazer upload de nosso working_dir atual em um balde S3 para que todos os nossos trabalhadores quando executamos um trabalho de qualquer escala tenham acesso ao código para usar. O GITHUB_USERNAME é usado posteriormente para salvar resultados de nossas cargas de trabalho para S3, para que possamos recuperá -las posteriormente (por exemplo, para servir).
Agora estamos prontos para enviar nosso trabalho para executar nossas cargas de trabalho de ML:
anyscale job submit deploy/jobs/workloads.yaml E depois que nossas cargas de trabalho de ML foram executadas, estamos prontos para lançar nosso modelo para a produção. Semelhante às nossas configurações de trabalhos de qualquer escala, altere o $GITHUB_USERNAME em 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)Agora estamos prontos para lançar nosso serviço:
# 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_NAMENão vamos implantar manualmente nosso aplicativo toda vez que fazemos uma alteração. Em vez disso, automatizaremos esse processo usando ações do GitHub!
/settings/secrets/actions do nosso repositório do GitHub. export ANYSCALE_HOST=https://console.anyscale.com
export ANYSCALE_CLI_TOKEN= $YOUR_CLI_TOKEN # retrieved from https://console.anyscale.com/o/madewithml/credentialsmain ) e empurrá -las para o GitHub. Mas, para empurrar nosso código para o Github, precisaremos primeiro autenticar com nossas credenciais antes de pressionar para o nosso repositório: git config --global user.name " Your Name " # <-- CHANGE THIS to your name
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 Agora você será solicitado a inserir seu nome de usuário e senha (token de acesso pessoal). Siga estas etapas para obter o token de acesso pessoal: novo token de acesso pessoal do GitHub → Adicione um nome → alternância repo e workflow → clique em Generate token (rolar para baixo) → copiar o token e colá -lo quando solicitado a sua senha.
main e isso acionará o fluxo de trabalho das cargas de trabalho. Se o fluxo de trabalho (trabalhos de qualquer escala) for bem -sucedido, isso produzirá comentários com os resultados de treinamento e avaliação diretamente no PR.main . Isso desencadeará o fluxo de trabalho de servir que lançará nosso novo serviço para a produção!Com o nosso fluxo de trabalho CI/CD para implantar nosso aplicativo, agora podemos nos concentrar em melhorar continuamente nosso modelo. Torna -se realmente fácil de estender sobre essa base conectar a execuções programadas (cron), pipelines de dados, deriva detectada através de monitoramento, avaliação on -line etc. e podemos adicionar facilmente contexto adicional, como comparar qualquer experimento com o que está atualmente em produção (diretamente no PR par), etc.
Problemas em configurar os notebooks com Jupyter? Por padrão, Jupyter usará o kernel com nosso ambiente virtual, mas também podemos adicioná -lo manualmente a Jupyter:
python3 -m ipykernel install --user --name=venv Agora, podemos abrir um notebook → kernel (barra de menu superior) → alterar o kernel → venv . Para excluir este kernel, podemos fazer o seguinte:
jupyter kernelspec list
jupyter kernelspec uninstall venv
