Cómo crear un clasificador de texto en Azure AI & Machine Learning

João Barros 17 de September de 2026 4 min de lectura

Este tutorial muestra cómo crear un clasificador de texto usando Azure AI & Machine Learning para categorizar mensajes o valoraciones. Aprender a entrenar, registrar y exponer un modelo como endpoint es útil para automatizar la clasificación de contenido, el soporte al cliente o el análisis de feedback.

Requisitos previos

Cuenta Azure con permisos para crear recursos (Azure Machine Learning Workspace).
Azure CLI y la extensión Azure ML instalada o acceso a Azure Machine Learning studio.
Python 3.8+ y pip; paquetes: azure-ai-ml, scikit-learn, pandas.
Conjunto de datos simple de texto con columna "text" y columna "label" (CSV).

Paso 1: Preparar el entorno y el dataset

Por qué: es importante tener un entorno reproducible y un conjunto de datos limpio. Vamos a crear un virtualenv, instalar dependencias y preparar un CSV con ejemplos etiquetados.

python -m venv venv
source venv/bin/activate   # ou venv\Scripts\activate no Windows
pip install --upgrade pip
pip install azure-ai-ml scikit-learn pandas joblib

# Exemplo mínimo de dataset (criar text_labels.csv):
# text,label
# "Entrega atrasada",complaint
# "Excelente produto",praise

Paso 2: Entrenar un modelo localmente (ejemplo con scikit-learn)

Por qué: entrenar localmente permite iterar rápidamente. Usamos un Pipeline con CountVectorizer y LogisticRegression y guardamos el modelo con joblib.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
import joblib

df = pd.read_csv('text_labels.csv')
X_train, X_test, y_train, y_test = train_test_split(df['text'], df['label'], test_size=0.2, random_state=42)
model = make_pipeline(CountVectorizer(), LogisticRegression(max_iter=1000))
model.fit(X_train, y_train)
print('Acurácia:', model.score(X_test, y_test))
joblib.dump(model, 'text_classifier.joblib')

Paso 3: Registrar el modelo en Azure Machine Learning

Por qué: registrar modelos facilita la gestión de versiones y el despliegue. Vamos a usar azure-ai-ml para registrar el archivo del modelo guardado.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
from azure.ai.ml.entities import Model

# Defina estas variables de entorno o sustituya directamente
subscription_id = ''
resource_group = ''
workspace_name = ''

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace_name)
model = Model(path='text_classifier.joblib', name='text-classifier', description='Classifier scikit-learn simple')
registered_model = ml_client.models.create_or_update(model)
print('Model registered:', registered_model.name, registered_model.version)

Paso 4: Crear una imagen de contenedor o endpoint en tiempo real

Por qué: exponer el modelo como endpoint permite invocar predicciones desde aplicaciones. Aquí describo de forma simple cómo crear un endpoint en tiempo real con un script de scoring mínimo.

# scoring_script.py (mínimo)
import json
import joblib

model = None

def init():
    global model
    model = joblib.load('text_classifier.joblib')

def run(raw_data):
    data = json.loads(raw_data)
    texts = data.get('texts', [])
    preds = model.predict(texts)
    return json.dumps({'predictions': preds.tolist()})

Después, en Azure ML, se crea un Deployment (real-time) apuntando al modelo registrado y al script de scoring. En el studio o vía CLI/azure-ai-ml, configure la imagen/contenedor con dependencias (scikit-learn) y suba el archivo del modelo y el scoring.

Paso 5: Probar el endpoint con una solicitud

Por qué: validar el endpoint garantiza que el pipeline de extremo a extremo funciona. Usamos curl o requests en Python para enviar textos y obtener clases.

# Ejemplo en Python usando requests (obtener URL y clave del endpoint en Azure ML)
import requests
import json

endpoint_url = 'https:///score'
api_key = ''
headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {api_key}'}
payload = json.dumps({'texts': ['Entrega atrasada e sin respuesta', 'Adorei a qualidade']})
resp = requests.post(endpoint_url, headers=headers, data=payload)
print(resp.json())

Verificar el resultado

Confirme que el modelo responde al endpoint y que las predicciones tienen sentido: la respuesta JSON debe contener las labels esperadas. Verifique métricas locales (accuracy, matriz de confusión) y los logs del deployment para errores comunes como falta de dependencias o rutas incorrectas.

Conclusión

Ahora tiene un flujo básico: entrenar localmente, registrar el modelo en Azure Machine Learning y exponerlo como endpoint en tiempo real. Siguientes pasos: mejorar el conjunto de datos, usar validación cruzada, probar modelos preentrenados de NLP o convertir el pipeline en un Job en Azure ML para entrenamiento automatizado. Consejo: empiece por etiquetar bien los ejemplos más frecuentes para obtener mejoras rápidas en el rendimiento.