Treinamento e implantação de um modelo de classificação de flores Iris usando o TrueFoundry

Neste exemplo, treinamos um modelo que pode classificar uma flor do gênero íris em uma de três espécies com base em medições de tamanho de sua pétala e sépala.

Você também pode seguir este exemplo em um notebook do Google Colaboratory.

O Dataset Iris contém três espécies diferentes:

• Iris Setosa
• Iris Versicolor
• Iris Virginica

Precisamos construir um classificador que possa identificar a espécie da flor dados os seguintes parâmetros:

• Comprimento da Sépala
• Largura da Sépala
• Comprimento da Pétala
• Largura da Pétala

Sobre a TrueFoundry

TrueFoundry fornece duas bibliotecas para simplificar seus fluxos de trabalho de ML:

MLFoundry

mlfoundry biblioteca é usada para rastrear experimentos de treinamento de ML.

Por que você precisa de rastreamento de experimentos? Se você está treinando múltiplos modelos de ML para resolver um problema, provavelmente treinará múltiplos modelos com múltiplos frameworks, hiperparâmetros e múltiplos conjuntos de dados. Rastrear seu experimento usando uma biblioteca como mlfoundry pode ajudar você a organizar seus experimentos de ML.

Você pode usar o MLFoundry para registrar hiperparâmetros, métricas, conjuntos de dados e modelos. Você pode então comparar diferentes experimentos no painel do TrueFoundry e escolher um modelo para implantar em produção ou decidir retreinar o modelo.

Usaremos 5 APIs diferentes do MLFoundry neste exemplo. Elas são:

1. log_params - use-o para registrar os hiperparâmetros do experimento atual
2. log_dataset - usado para registrar o conjunto de dados completo
3. log_metrics - registrar métricas como pontuações de precisão, pontuações f1
4. set_tags - adicione tags ao seu experimento para facilitar a filtragem posteriormente
5. log_model - para salvar um modelo, incluindo os pesos treinados

ServiceFoundry

Utilizando a servicefoundry biblioteca, você pode empacotar, conteinerizar e implantar um modelo em um cluster Kubernetes facilmente.

Vamos treinar um modelo e registrá-lo usando o MLFoundry

Abra um notebook IPython - você pode usar o Jupyter rodando localmente em sua máquina ou um notebook Google Colab que roda na nuvem.

Instale as bibliotecas necessárias.

 
!pip install mlfoundry
!pip install pandas
!pip install sklearn

Faça login no TrueFoundry. Crie e copie uma chave de API da página de configurações. Use esta chave de API para inicializar o cliente MLFoundry e criar uma execução (run). Uma execução (run) é uma entidade que representa um único experimento.

 
import mlfoundry as mlf
client = mlf.get_client(api_key='<TFY_API_KEY>')
run = client.create_run('iris-classifier'))

Busque o conjunto de dados Iris usando o sklearn.datasets módulo. Em seguida, dividimos em conjuntos de dados de teste e treinamento.

 
from sklearn import datasets
from sklearn.model_selection import train_test_split

data = datasets.load_iris()

X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, stratify=y, random_state=42)

Vamos dar uma olhada nos nomes dos alvos. Usaremos isso para mapear a saída inteira do modelo para os nomes reais das espécies

 
print(data.target_names)

# Output
# ['setosa' 'versicolor' 'virginica']

Inicialize um modelo. Em seguida, use o MLFoundry para registrar os parâmetros do modelo e crie algumas tags para esta execução de experimento atual.

 
from sklearn.svm import SVC

clf = SVC(gamma='scale', kernel='rbf', probability=True, C=1.2)

run.set_tags({
	'framework': 'sklearn',
  'task': 'classification'
})

run.log_params(clf.get_params())

Em seguida, treinamos o modelo em nosso conjunto de dados de treinamento. Uma vez concluído o treinamento, calculamos as várias métricas e as registramos no MLFoundry usando log_metrics.

 
from sklearn.svm import SVC

clf = SVC(gamma='scale', kernel='rbf', probability=True, C=1.2)

run.set_tags({
	'framework': 'sklearn',
  'task': 'classification'
})

run.log_params(clf.get_params())

 
clf.fit(X_train, y_train)

y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)

metrics = {
  'train/accuracy_score': accuracy_score(y_train, y_pred_train),
  'train/f1_weighted': f1_score(y_train, y_pred_train, average='weighted'),
  'train/f1_micro': f1_score(y_train, y_pred_train, average='micro'),
  'train/f1_macro': f1_score(y_train, y_pred_train, average='macro'),
  'test/accuracy_score': accuracy_score(y_test, y_pred_test),
  'test/f1_weighted': f1_score(y_test, y_pred_test, average='weighted'),
  'test/f1_micro': f1_score(y_test, y_pred_test, average='micro'),
  'test/f1_macro': f1_score(y_test, y_pred_test, average='macro'),
}

run.log_metrics(metrics)

Se estivermos satisfeitos com as pontuações de precisão e outras métricas, podemos optar por implantar o modelo atual. Para isso, precisamos salvar o modelo e copiar o ID da execução atual.

 
run.log_model(clf, framework=mlf.ModelFramework.SKLEARN)
print(run.run_id)
run.end()

Você pode ver todas as suas execuções e comparar métricas através do painel de acompanhamento de experimentos do TrueFoundry.

Implantando nosso modelo como um serviço de API

Para implantar o modelo usando o ServiceFoundry, precisamos criar um arquivo Python contendo a função que queremos expor como um endpoint.

Dentro desse arquivo Python, buscaremos o modelo que acabamos de treinar e salvar usando o ID da execução, utilizando mlfoundry. Observe que a chave de API exigida por mlfoundry estará disponível como a variável de ambiente TFY_API_KEY.

No seu notebook IPython, crie um bloco com o seguinte conteúdo e execute-o para criar um arquivo Python chamado predict.py. Usamos o comando mágico do Jupyter %%writefile para criar o arquivo no ambiente do notebook.

 
%%writefile predict.py
import os
import json
import pandas as pd
import mlfoundry as mlf

client = mlf.get_client(api_key=os.environ.get('TFY_API_KEY'))
run = client.get_run('79e71482643f46dfa5bfef256dba5dc5') # replace with your run id
model = run.get_model()

def species(features):
 features = json.loads(features)
 df = pd.DataFrame.from_dict([features])
 prediction = model.predict(df)[0]
 return ['setosa', 'versicolor', 'virginica'][prediction]

Dentro da função de espécies, carregamos as características em um pandas DataFrame e faça a previsão usando o modelo. Traduzimos da classe inteira para os nomes das espécies usando os target_names que imprimimos durante o treinamento.

Isso é praticamente todo o trabalho que você precisará fazer. Agora, vamos implantar este modelo como um serviço de API. Primeiro, instale e importe servicefoundry no seu notebook. Faça login em servicefoundry.

 
!pip install servicefoundry
import servicefoundry.core as sfy
sfy.login()

Acesse o painel do TrueFoundry e crie um espaço de trabalho para implantar o serviço. Espaços de trabalho são uma forma de agrupar projetos relacionados dentro do TrueFoundry. Assim que o espaço de trabalho for criado, copie o FQN para que possamos informar servicefoundry onde implantar o modelo.

‍servicefoundry permite que você reúna todas as dependências do arquivo que você acabou de criar usando a gather_requirements função.

 
requirements = sfy.gather_requirements("predict.py")

Agora crie um sfy.Service objeto, forneça o FQN do workspace e implante-o chamando .deploy()

 
auto_service = sfy.Service("predict.py", requirements, sfy.Parameters( name="iris-service", workspace="" )) auto_service.deploy()

Você pode acompanhar o progresso desta implantação no dashboard. Assim que a implantação for concluída, você poderá acessar o serviço implantado a partir daí e testá-lo.

O dashboard do TrueFoundry também inclui links para métricas e logs que vêm prontos para uso com as implantações do TrueFoundry, na forma de dashboards do Grafana. Você pode ler mais sobre eles aqui.

Mais recursos

Você também pode implantar aplicativos de UI interativos e aplicativos Gradio facilmente a partir de um notebook IPython usando servicefoundry. Leia este guia para ver como.

Estamos trabalhando para tornar a integração entre o rastreamento de experimentos e a implantação ainda mais estreita e a experiência, mais agradável. Você pode ler sobre outras coisas que você pode fazer com o TrueFoundry em nossa documentaçãoSe você está treinando modelos de machine learning para resolver um problema, o TrueFoundry ajuda você a rastrear diferentes experimentos e torna fácil e intuitivo implantar modelos com as melhores práticas, disponibilizando-os para uso público em questão de minutos.