Entrenamiento e implementación de un modelo de clasificación de flores de iris con TrueFoundry

En este ejemplo, entrenamos un modelo que puede clasificar una flor del género del iris en una de las tres especies según las medidas de tamaño de sus pétalos y sépalos.

También puedes seguir este ejemplo en Cuaderno colaboratorio de Google.

El Conjunto de datos Iris contiene tres especies diferentes:

• Iris Setosa
• Iris versicolor
• Iris Virginica

Necesitamos construir un clasificador que pueda identificar la especie de la flor teniendo en cuenta los siguientes parámetros:

• Longitud del sépalo
• Ancho del sépalo
• Longitud del pétalo
• Ancho del pétalo

Acerca de TrueFoundry

True Foundry proporciona dos bibliotecas para simplificar los flujos de trabajo de aprendizaje automático:

Fundición ML

fundición ml la biblioteca se usa para rastrear los experimentos de entrenamiento de ML.

¿Por qué necesitas el seguimiento de los experimentos? Si está entrenando varios modelos de aprendizaje automático para resolver un problema, es probable que entrene varios modelos con varios marcos, hiperparámetros y varios conjuntos de datos. Haz un seguimiento de tu experimento con una biblioteca como fundición ml puede ayudarle a organizar sus experimentos de aprendizaje automático.

Puede usar MLFoundry para registrar hiperparámetros, métricas, conjuntos de datos y modelos. A continuación, puede comparar diferentes experimentos en Panel de control de TrueFoundry y elija un modelo para implementarlo en producción o decida volver a entrenar el modelo.

Usaremos 5 API diferentes de MLFoundry en este ejemplo. Son:

1. parámetros de registro - úselo para registrar los hiperparámetros del experimento actual
2. log_dataset - se utiliza para registrar todo el conjunto de datos
3. log_metrics - registra métricas como puntuaciones de precisión, puntuaciones f1
4. establecer etiquetas - añada etiquetas a su experimento para filtrarlo fácilmente más adelante
5. modelo_registro - para guardar un modelo que incluya las pesas entrenadas

Fundición de servicio

Uso del fundicion de servicio biblioteca, puede empaquetar, contenedorizar e implementar un modelo en un clúster de Kubernetes fácilmente.

Vamos a entrenar un modelo y registrarlo usando MLFoundry

Abra un cuaderno de IPython: puede usar Jupyter que se ejecuta localmente en su máquina o un cuaderno de Google Colab que se ejecuta en la nube.

Instale las bibliotecas necesarias.

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

Inicie sesión en TrueFoundry. Crea y copia una clave de API desde la página de configuración. Usa esta clave de API para inicializar el cliente de MLFoundry y crear una ejecución. Una ejecución es una entidad que representa un único experimento.

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

Obtenga el conjunto de datos de Iris utilizando el sklearn.datasets módulo. Luego lo dividimos en conjuntos de datos de prueba y entrenamiento.

 
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)

Echemos un vistazo a los nombres de los objetivos. Usaremos esto para mapear desde el resultado entero del modelo hasta los nombres reales de las especies

 
print(data.target_names)

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

Inicialice un modelo. A continuación, utilice MLFoundry para registrar los parámetros del modelo y crear algunas etiquetas para la ejecución del experimento actual.

 
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())

A continuación, entrenamos el modelo en nuestro conjunto de datos de trenes. Una vez finalizada la capacitación, calculamos las distintas métricas y las registramos en MLFoundry utilizando 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)

Si estamos satisfechos con las puntuaciones de precisión y otras métricas, podemos optar por implementar el modelo actual. Para ello, necesitamos guardar el modelo y copiar el identificador de ejecución actual.

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

Puedes ver todas tus carreras y comparar las métricas a través del Panel de seguimiento de experimentos de TrueFoundry.

Implementación de nuestro modelo como un servicio de API

Para implementar el modelo usando ServiceFoundry, necesitamos crear un archivo Python que contenga la función que queremos exponer como punto final.

Dentro de ese archivo de Python, buscaremos el modelo que acabamos de entrenar y guardar usando el identificador de ejecución, usando fundición ml. Tenga en cuenta que la clave de API es requerida por fundición ml estará disponible como variable de entorno TFY_API_KEY.

En su bloc de notas de IPython, cree un bloque con el siguiente contenido y ejecútelo para crear un archivo de Python llamado predict.py. Usamos el comando mágico de Jupyter %s escribir archivo para crear el archivo en el entorno del bloc de notas.

 
%%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 de la función de especie, cargamos las características en un pandas DataFrame y haga la predicción utilizando el modelo. Traducimos de la clase entera a los nombres de las especies utilizando el nombres_objetivo imprimimos durante el entrenamiento.

Eso es prácticamente todo el trabajo que tendrás que hacer. Ahora vamos a implementar este modelo como un servicio de API. En primer lugar, instale e importe fundicion de servicio en tu cuaderno. Inicie sesión en fundicion de servicio.

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

Ir a la Panel de control de TrueFoundry y cree un espacio de trabajo para implementar el servicio. Los espacios de trabajo son una forma de agrupar proyectos relacionados dentro de TrueFoundry. Una vez creado el espacio de trabajo, copia el FQN para que podamos saberlo fundicion de servicio dónde implementar el modelo.

‍fundicion de servicio la biblioteca te permite recopilar todas las dependencias del archivo que acabas de crear usando recopilar requisitos función.

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

Ahora crea un Servicio SFY objeto, proporcione el FQN del espacio de trabajo e impleméntelo llamando .implementar ()

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

Puede realizar un seguimiento del progreso de esta implementación en la salpicadero. Una vez finalizada la implementación, puede acceder al servicio desplegado desde allí y probarlo.

El panel de TrueFoundry también enlaza con las métricas y los registros que vienen listos para usar con las implementaciones de TrueFoundry en forma de paneles de Grafana. Puedes leer más sobre ellos aquí.

Más funciones

También puede implementar aplicaciones de interfaz de usuario interactivas y aplicaciones de Gradio fácilmente desde un cuaderno IPython mediante fundicion de servicio. Lee esto guía para ver cómo.

Estamos trabajando para que la integración entre el seguimiento y el despliegue de los experimentos sea aún más estrecha y que la experiencia sea más agradable. Puedes leer sobre otras cosas que puedes hacer con TrueFoundry en nuestros documentos.Si está entrenando modelos de aprendizaje automático para resolver un problema, TrueFoundry lo ayuda a realizar un seguimiento de diferentes experimentos y hace que sea fácil e intuitivo implementar modelos con las mejores prácticas y ponerlos a disposición del público en cuestión de minutos.