Azure Machine Learning: Del Código a la Producción en la Nube es una guía esencial para desarrolladores, científicos de datos y entusiastas de la IA que buscan llevar sus modelos desde un script local hasta un servicio escalable en la nube. Basado en el tutorial oficial de Microsoft, Inicio rápido: Introducción a Azure Machine Learning, este recorrido no solo explica el “cómo”, sino también el “por qué” detrás de cada etapa del ciclo de vida de un proyecto de Machine Learning. Más allá de ser un simple manual, es una hoja de ruta para entender el flujo de trabajo de la IA de principio a fin.
El tutorial está diseñado para llevarnos rápidamente desde un script de entrenamiento local a la implementación de un modelo en la nube. Su enfoque no es solo enseñar a usar una plataforma, sino a comprender el ciclo de vida de un proyecto de Machine Learning, desde la preparación hasta la implementación.
Los Pilares del Tutorial: Una Hoja de Ruta Clara y Concisa
El recorrido se centra en tres etapas clave que, en mi opinión, resumen la esencia de un proyecto de ML exitoso:
Entrenamiento del modelo en la nube: Aquí aprendemos a mover nuestro código de entrenamiento a un entorno escalable y gestionado. El tutorial nos enseña a:
- Configurar un área de trabajo: El punto de partida, nuestro “laboratorio” virtual donde todo sucede.
- Crear un script de entrenamiento: El corazón de nuestro modelo, la lógica que aprende de los datos.
- Utilizar clústeres de cómputo escalables: Para que nuestro entrenamiento no se limite a la potencia de nuestra máquina local, sino que aproveche el poder de la nube.
- Ejecutar “trabajos de comandos”: Esto nos permite ejecutar nuestro script en el clúster, con el entorno de trabajo y las dependencias adecuadas.
Implementación del modelo: Una vez que el modelo está entrenado, el siguiente paso es hacerlo accesible. Esto se logra implementándolo como un “punto de conexión en línea”. Esto es crucial, ya que convierte nuestro modelo estático en un servicio web dinámico al que las aplicaciones pueden hacer peticiones para obtener predicciones en tiempo real.
Creación de canalizaciones de ML: La automatización es el futuro. El tutorial nos introduce al concepto de “canalizaciones” (pipelines), que nos permiten dividir una tarea compleja de ML en un flujo de trabajo de varios pasos. Por ejemplo, un pipeline puede incluir pasos para la preparación de datos, el entrenamiento del modelo y, finalmente, la implementación. Esto no solo organiza nuestro trabajo, sino que lo hace reproducible y fácil de mantener.
Entrena, Registra e Implementa un Modelo en Azure Machine Learning
Azure Machine Learning (Azure ML) es mucho más que un servicio para entrenar modelos: es un ecosistema completo para gestionar datasets, escalar cómputo, registrar modelos y desplegarlos como servicios en la nube. En este recorrido, vamos a:
- Conectar con tu área de trabajo (Workspace)
- Crear y ejecutar un script de entrenamiento
- Registrar el modelo
- Implementarlo como un endpoint online
- Probarlo con datos reales
Conectando con tu Workspace
El Workspace es el núcleo de Azure ML: allí viven tus datasets, modelos, entornos y trabajos. Para interactuar con él, usamos MLClient del SDK azure-ai-ml junto con DefaultAzureCredential para autenticación.
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
# Autenticación
credential = DefaultAzureCredential()
# Datos de tu suscripción y workspace
SUBSCRIPTION = "<SUBSCRIPTION_ID>"
RESOURCE_GROUP = "<RESOURCE_GROUP>"
WS_NAME = "<AML_WORKSPACE_NAME>"
# Conexión al workspace
ml_client = MLClient(
credential=credential,
subscription_id=SUBSCRIPTION,
resource_group_name=RESOURCE_GROUP,
workspace_name=WS_NAME
)
# Verificación
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location, ":", ws.resource_group)Lenguaje del código: PHP (php)Tip: Si falla la conexión, revisa que los valores de SUBSCRIPTION, RESOURCE_GROUP y WS_NAME sean correctos.
Creando el Script de Entrenamiento
Vamos a entrenar un Gradient Boosting Classifier para predecir defaults de tarjetas de crédito. El script (main.py) se encargará de:
- Preprocesar datos
- Dividir en entrenamiento y prueba
- Entrenar el modelo
- Registrar métricas y el modelo con MLflow
%%writefile ./src/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--data", type=str, help="path to input data")
parser.add_argument("--test_train_ratio", type=float, default=0.25)
parser.add_argument("--n_estimators", type=int, default=100)
parser.add_argument("--learning_rate", type=float, default=0.1)
parser.add_argument("--registered_model_name", type=str, help="model name")
args = parser.parse_args()
mlflow.start_run()
mlflow.sklearn.autolog()
# 📊 Cargar datos
credit_df = pd.read_csv(args.data, header=1, index_col=0)
mlflow.log_metric("num_samples", credit_df.shape[0])
mlflow.log_metric("num_features", credit_df.shape[1] - 1)
# 🔀 División train/test
train_df, test_df = train_test_split(credit_df, test_size=args.test_train_ratio)
y_train = train_df.pop("default payment next month")
X_train = train_df.values
y_test = test_df.pop("default payment next month")
X_test = test_df.values
# 🤖 Entrenamiento
clf = GradientBoostingClassifier(
n_estimators=args.n_estimators,
learning_rate=args.learning_rate
)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))
# 💾 Registro del modelo
mlflow.sklearn.log_model(
sk_model=clf,
registered_model_name=args.registered_model_name,
artifact_path=args.registered_model_name
)
mlflow.end_run()
if __name__ == "__main__":
main()Lenguaje del código: PHP (php)
Configurando y Ejecutando el Trabajo
Usamos command() para definir cómo se ejecutará el script en Azure ML, incluyendo:
- Entradas (dataset remoto)
- Entorno (librerías necesarias)
- Comando (parámetros del script)
from azure.ai.ml import command, Input
registered_model_name = "credit_defaults_model"
job = command(
inputs=dict(
data=Input(
type="uri_file",
path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv"
),
test_train_ratio=0.2,
learning_rate=0.25,
registered_model_name=registered_model_name
),
code="./src/",
command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
display_name="credit_default_prediction"
)
ml_client.create_or_update(job)Lenguaje del código: JavaScript (javascript)Implementando el Modelo como Endpoint Online
Creamos un endpoint único y desplegamos el modelo más reciente.
import uuid
from azure.ai.ml.entities import ManagedOnlineEndpoint, ManagedOnlineDeployment
# Endpoint único
online_endpoint_name = f"credit-endpoint-{str(uuid.uuid4())[:8]}"
endpoint = ManagedOnlineEndpoint(
name=online_endpoint_name,
description="Endpoint para predicción de defaults",
auth_mode="key"
)
ml_client.online_endpoints.begin_create_or_update(endpoint).result()
# Última versión del modelo
latest_model_version = max(
int(m.version) for m in ml_client.models.list(name=registered_model_name)
)
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)
# Despliegue
blue_deployment = ManagedOnlineDeployment(
name="blue",
endpoint_name=online_endpoint_name,
model=model,
instance_type="Standard_DS3_v2",
instance_count=1
)
ml_client.begin_create_or_update(blue_deployment).result()Lenguaje del código: PHP (php)Probando el Endpoint
Creamos un archivo JSON con datos de prueba y lo enviamos al endpoint.
%%writefile ./deploy/sample-request.json
{
"input_data": {
"columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
"index": [0, 1],
"data": [
[20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
[10,9,8,7,6,5,4,3,2,1,10,9,8,7,6,5,4,3,2,1,10,9,8]
]
}
}
# Invocación
ml_client.online_endpoints.invoke(
endpoint_name=online_endpoint_name,
request_file="./deploy/sample-request.json",
deployment_name="blue"
)Lenguaje del código: PHP (php)Este tutorial, no se queda solo en el “cómo hacer”, sino que nos da una perspectiva del “por qué”. Nos anima a pensar en la escalabilidad, la reproducibilidad y la automatización desde el principio. Entender estos conceptos es lo que diferencia a un simple script de un proyecto de Machine Learning profesional y listo para producción.
Es un excelente punto de partida. Nos demuestra que con las herramientas adecuadas, podemos pasar de una idea a una solución en la nube de manera eficiente y estructurada. Si eres un desarrollador, científico de datos o simplemente un entusiasta del ML, te animo a explorar esta guía.
