Integraciones de plataformas de aprendizaje automático #1: Pesos y sesgos

El seguimiento de la experimentación es un aspecto fundamental del desarrollo del aprendizaje automático, ya que permite a los profesionales gestionar y realizar un seguimiento del progreso de sus experimentos de manera eficiente. El seguimiento de los experimentos implica registrar y supervisar varios factores, como el rendimiento del modelo, los hiperparámetros y los datos de entrenamiento, para obtener información sobre el rendimiento del modelo de aprendizaje automático.

Desafíos enfrentados en la gestión de experimentos

La gestión de los experimentos y el seguimiento de los resultados puede ser una tarea difícil para los profesionales del aprendizaje automático debido a la complejidad de los modelos, la gran cantidad de datos involucrados y la variedad de herramientas y marcos utilizados en el desarrollo del aprendizaje automático. Estos son algunos de los principales desafíos a los que se enfrentan los profesionales a la hora de gestionar los experimentos y hacer un seguimiento de los resultados:

1. Reproducibilidad: La reproducción de los experimentos es esencial para verificar los resultados y garantizar que los modelos funcionen bien en escenarios del mundo real. Sin embargo, reproducir experimentos puede ser un desafío, especialmente cuando se trata de modelos complejos, múltiples marcos y diferentes entornos informáticos.
2. Escalabilidad: Los profesionales del aprendizaje automático suelen trabajar con grandes conjuntos de datos y, por lo tanto, los modelos de entrenamiento pueden ser un proceso lento que requiere una cantidad significativa de potencia informática. La gestión de los experimentos y el seguimiento de los resultados a escala requieren herramientas e infraestructuras que puedan gestionar grandes cantidades de datos y cálculos.
3. Colaboración: La colaboración es esencial en el desarrollo del aprendizaje automático, pero la gestión de los experimentos y el seguimiento de los resultados entre varios miembros del equipo puede ser un desafío. Requiere una infraestructura sólida para compartir datos, códigos y resultados de experimentos y garantizar que todos tengan acceso a los mismos recursos.
4. Administración de datos: Los modelos de aprendizaje automático se basan en gran medida en los datos, y la gestión eficaz de los datos es fundamental para el éxito del modelo. Sin embargo, la administración de datos implica varios desafíos, como la limpieza de los datos, el etiquetado de los datos y el control de versiones de los datos, que pueden llevar mucho tiempo y ser complejos.
5. Optimización de hiperparámetros: Encontrar los mejores hiperparámetros para un modelo puede ser un proceso desafiante e iterativo que implica ejecutar varios experimentos con diferentes hiperparámetros. La gestión de estos experimentos y el seguimiento de los resultados pueden llevar mucho tiempo y ser complejos.

Explorando las características de los pesos y los sesgos

Pesos y sesgos (W&B) es una plataforma diseñada para ayudar a los profesionales del aprendizaje automático a gestionar y realizar un seguimiento de sus experimentos de forma eficaz. Proporciona un conjunto de herramientas para el seguimiento, la visualización y la colaboración de los experimentos, lo que facilita a los profesionales el desarrollo de modelos de aprendizaje automático sólidos y escalables.

Las principales características y ventajas de la plataforma W&B son:

1. Seguimiento de experimentos: W&B permite a los usuarios realizar un seguimiento de sus experimentos registrando automáticamente los hiperparámetros, las métricas y los artefactos de salida del modelo. Esto permite a los profesionales realizar un seguimiento de sus experimentos y comparar fácilmente diferentes modelos e hiperparámetros.
2. Visualizaciones: W&B ofrece un conjunto de herramientas de visualización que permiten a los usuarios visualizar sus experimentos y resultados. Estas incluyen visualizaciones 3D, matrices de confusión y diagramas de dispersión, entre otras. Esto ayuda a los profesionales a comprender mejor sus datos e identificar patrones y tendencias en los resultados de los experimentos.
3. Colaboración: W&B facilita la colaboración con los miembros del equipo al proporcionar funciones para compartir experimentos, datos y resultados. También proporciona control de versiones para el código y los datos, lo que garantiza que todos trabajen con los mismos recursos.
4. Integración: W&B se puede integrar fácilmente con una amplia gama de marcos de aprendizaje automático, incluidos TensorFlow, PyTorch, Keras y Scikit-learn. Esto permite a los profesionales utilizar W&B con sus flujos de trabajo y marcos existentes, sin necesidad de realizar ningún cambio significativo en su proceso de desarrollo.
5. Organización: W&B ofrece funciones para organizar experimentos, como proyectos, ejecuciones y etiquetas. Esto facilita la gestión y el seguimiento de los experimentos entre varios miembros del equipo y proyectos.

Guía paso a paso: configurar pesos y sesgos de forma sencilla

La configuración de W&B para el seguimiento de experimentos implica varios pasos:

1. Crea una cuenta de W&B: el primer paso es crear una cuenta gratuita en el sitio web de W&B. Esto se puede hacer visitando el sitio web y siguiendo el proceso de registro.
2. Instala la biblioteca de W&B: Tras crear una cuenta, el siguiente paso es instalar la biblioteca de W&B en el entorno de desarrollo. La biblioteca de W&B se puede instalar mediante pip o conda, según las preferencias del usuario y el entorno de desarrollo.
3. Inicializar W&B: una vez instalada la biblioteca, el usuario debe inicializar W&B en el código llamando al wandb.init () función. Esta función inicializa la biblioteca de W&B y configura una nueva ejecución.
4. Registrar métricas: el usuario puede registrar métricas como la pérdida y la precisión durante el entrenamiento llamando al wandb.log () función. Esta función toma como entrada un diccionario de métricas y las registra en el panel de control de W&B.
5. Registrar hiperparámetros: el usuario también puede registrar hiperparámetros, como la tasa de aprendizaje y el tamaño del lote, llamando al wandb.config función. Esta función toma como entrada un diccionario de hiperparámetros y los registra en el panel de control de W&B.
6. Visualizaciones de registro: Por último, el usuario puede registrar visualizaciones, como imágenes y gráficos, llamando al wandb.log () funcionan con los datos de visualización apropiados. W&B proporciona una amplia gama de herramientas de visualización, que incluyen visualizaciones 3D, matrices de confusión y diagramas de dispersión, entre otras.

Ejemplo:

Este es un ejemplo de cómo registrar métricas, modelos, hiperparámetros y visualizaciones con W&B:

importar wandb
importar numpy como np
importar matplotlib.pyplot como gráfico
importar tensorflow como tf

# Paso 1: Inicializar W&B
wandb.init (project="mi-proyecto»)

# Paso 2: Registrar hiperparámetros
configuración = {
«tasa de aprendizaje»: 0.001,
«tamaño_lote»: 32,
«épocas»: 10
}
wandb.config.update (configuración)

# Paso 3: Entrene el modelo y las métricas de registro
modelo = tf.keras.models.Sequential ([
tf.keras.layers.Dense (10, activación='relu', input_shape =( 10,)),
tf.keras.Layers.Dense (1)
])
model.compile (optimizer=tf.keras.optimizers.adam (config ['learning_rate']),
loss=tf.keras.losses.meanSquaredError (),
métricas = [tf.keras.metrics.meanAbsoluteError ()])
para la época en el rango (config ['epochs']):
#... modelo de tren...
history = model.fit (x_train, y_train, batch_size=config ['batch_size'])
pérdida = historia.historia ['pérdida'] [-1]
mae = history.history ['mean_absolute_error'] [-1]
wandb.log ({"epoch»: época, «pérdida»: pérdida, «mae»: mae})

# Paso 4: Registrar visualizaciones y modelo
x = np.linspace (0, 10, 100)
y = np.sin (x)
fig, ax = plt.subplots ()
diagrama axial (x, y)
wandb.log ({"my_plot»: wandb.image (fig)})
wandb.save ('mi_model.h5')

# Paso 5: Finalizar la ejecución
wandb.finish ()

c

Integración perfecta: el enfoque de TrueFoundry sobre las ponderaciones y los sesgos

TrueFoundry se integra perfectamente con el registro de modelos de Weights & Biases para permitirle implementar modelos registrados en Weights & Biases en su clúster de Kubernetes mediante TrueFoundry.

📌

Además de usar Weights & Biases para la gestión de modelos y el seguimiento de la experimentación, también puedes usar MLFoundy, el seguimiento de experimentos de Truefoundry.

📌

También puedes seguir el siguiente código a través del siguiente cuaderno de colaboración:
Cuaderno Colab

Paso 1: Instalación y configuración:

• Instalar wandb

pip install wandb -qU

• Inicia sesión en tu cuenta de W&B

importar wandb
wandb.login ()

• Instalar servicefoundry

pip install -U «servicefoundry»

• Inicia sesión en Truefoundry

inicio de sesión sfy

Paso 2: Entrene y registre el modelo:

Primero usaremos wandb.init () para iniciar el proyecto
Luego entrenaremos nuestro modelo ML y lo guardaremos como un archivo joblib
Luego guardaremos nuestro archivo joblib en wandb a través de wandb.save ()

importar wandb
desde sklearn.datasets importar load_iris
desde sklearn.model_selection importar train_test_split
desde sklearn.linear_model importar LogisticRegression
desde sklearn.metrics import classification_report
importar joblib

# Inicializar W&B
wandb.init (project="regresión logística de iris»)

# Cargar y preprocesar los datos
X, y = load_iris (as_frame = verdadero, return_x_y = verdadero)
X = x.Rename (columnas= {
«longitud del sépalo (cm)»: «longitud del sépalo»,
«ancho del sépalo (cm)»: «ancho del sépalo»,
«longitud del pétalo (cm)»: «longitud del pétalo»,
«ancho del pétalo (cm)»: «ancho del pétalo»,
})

X_train, X_test, y_train, y_test = train_test_split (
X, y, tamaño_de_prueba=0.2, estado_aleatorio = 42, estratificación = y
)

# Inicializar el modelo
clf = Regresión logística (solver="liblinear»)

# Se ajusta al modelo
clf.fit (tren X, tren y)

# Evalúe el modelo
preds = clf.predict (x_test)

# Registre el modelo y las métricas de evaluación en W&B
joblib.dump (clf, «model.joblib»)
wandb.save («model.joblib»)

# Termina la carrera
wandb.finish ()

Paso 3: Cree una aplicación de inferencia y un archivo de dependencia:

Tendremos que crear dos archivos para desplegarlos en truefoundry, un app.py archivo que contiene el código de nuestra aplicación y un requirements.txt archivo que contiene nuestras dependencias.

.
├── app.py
├── deploy.py
── requirements.txt


c

• app.py:
  Aquí debe pasar el siguiente argumento en el wandb.restore () : <name_of_saved_file> y «nombre de usuario/proyecto/run_id»
  Por ejemplo: wandb.restore («model.joblib», «adityajha-tfy/iris-logistic-regresion/00r5xvyv»)

sistema operativo de importación
importar wandb
importar joblib
importar pandas como pdf
desde fastapi import FastAPI

wandb.login (clave=os.environ ["WANDB_API_KEY"])

# Recupere el modelo de W&B
model_joblib = wandb.restore (
'model.joblib',
run_path="adityajha-tfy/iris-regresión-logística/00r5xvyy»,
)

modelo = joblib.load (model_joblib.name)

# Cargue el modelo
aplicación = FastAPI (root_path=os.getenv («TFY_SERVICE_ROOT_PATH»))

@app .post («/predecir»)
sin embargo, predecir (
sepal_length: float, sepal_width: float, petal_length: float, petal_width: float
):
datos = dict (
sepal_length=sepal_length,
sepal_width=sepal_width,
petal_length=petal_length,
petal_width=petal_width,
)
predicción = int (model.predict (pd.DataFrame ([datos])) [0])
return {"predicción»: predicción}

• requirements.txt:

API rápida
joblib
lleno de nudos
pandas
scikit-learn
uvicornio
varita

Paso 4: Usa el SDK de python de truefoundry y configura la implementación

• deploy.py:

importar argparse
registro de importación
de servicefoundry import Build, PythonBuild, Service, Resources, Port

# Configurar el registrador
Logging.basicConfig (nivel=Logging.info)

# Configurar el analizador de argumentos
analizador = argParse.ArgumentParser ()
parser.add_argument («--workspace_fqn», obligatorio=True, type=str)
parser.add_argument («--wandb_api_key», obligatorio=verdadero, tipo=str)
args = parser.parse_args ()

servicio = Servicio (
nombre = «fastapi»,
image=construir (
build_spec=PythonBuild (
command="uvicorn app:app --port 8000 --host 0.0.0.0",
requirements_path=» requirements.txt «,
)
),
puertos= [
Puerto (
puerto=8000,
host="ml-deploy-aditya-ws-8000.demo.truefoundry.com»,
)
],
resources=Recursos (
cpu_request=0.25,
cpu_limit=0.5,
memory_request=200,
memory_limit=400,
ephemeral_storage_request=200,
límite de almacenamiento_efímero=400,
),
env= {
«WANDB_API_KEY»: args.wandb_api_key
}
)
service.deploy (workspace_fqn=args.workspace_fqn)

Paso 5: Implemente su servicio a través de Truefoundry

Ejecute el siguiente comando y pase su

• FQN del espacio de trabajo: que puedes encontrar en el tablero
• Clave de API de Wandb

<Your Workspace FQN><Your Wandb API Key>python deploy.py --workspace_fqn «» --wandb_api_key «»

¡¡¡Y listo!!! En los registros puede encontrar el panel de control de su servicio desplegado. A continuación, en la esquina superior derecha, encontrará el punto final de las aplicaciones implementadas.

True Foundry es un PaaS de implementación de aprendizaje automático sobre Kubernetes para acelerar los flujos de trabajo de los desarrolladores y, al mismo tiempo, permitirles una flexibilidad total a la hora de probar e implementar modelos, al tiempo que garantiza una seguridad y un control totales para el equipo de Infra. A través de nuestra plataforma, permitimos a los equipos de aprendizaje automático implementar y supervisar modela en 15 minutos con un 100% de confiabilidad, escalabilidad y la capacidad de revertirse en segundos, lo que les permite ahorrar costos y lanzar los modelos a la producción más rápido, lo que permite obtener un verdadero valor empresarial.