Para comenzar con machine learning con Python, elija una tarea pequeña, separe los datos de entrenamiento y prueba y compare un modelo simple con una referencia básica. No necesita alquilar una GPU para el primer ejercicio. En esta guía, construiremos un clasificador completo en CPU, interpretaremos sus errores y decidiremos cuándo tiene sentido cambiar la infraestructura.
El objetivo es terminar con un experimento que pueda repetir y explicar. Acertar una predicción aislada es menos útil que saber qué datos vio el modelo, cómo se evaluó y dónde falla.
Qué aprender primero en machine learning con Python
Un proyecto de aprendizaje supervisado tiene entradas, llamadas atributos, y una respuesta conocida, llamada objetivo. En el ejemplo de este artículo, los atributos son medidas de flores y el objetivo es la especie. El modelo aprende una relación usando el conjunto de entrenamiento y luego intenta clasificar ejemplos que quedaron separados.
Antes de elegir una biblioteca, escriba la pregunta que desea responder:
| Tarea | Tipo de respuesta | Posible primer experimento |
|---|---|---|
| Clasificar una observación | Una categoría | Regresión logística o árbol de decisión |
| Estimar una cantidad | Un número | Regresión lineal y análisis de errores |
| Encontrar grupos sin etiquetas | Agrupamientos | Un método de clustering e inspección de los grupos |
| Trabajar con imágenes o lenguaje a gran escala | Representaciones y predicciones más complejas | Una biblioteca adecuada de deep learning, después de definir la evaluación |
No elija una red neuronal solo porque parece más avanzada. Si una solución simple resuelve la tarea dentro del costo y el plazo necesarios, es una referencia importante para cualquier alternativa posterior.
Prepare un entorno aislado
Necesita una instalación de Python compatible con scikit-learn y acceso a la terminal. Cree una carpeta de trabajo y un entorno virtual para evitar conflictos con otros proyectos:
python -m venv .venv
En macOS o Linux, actívelo con source .venv/bin/activate. En PowerShell de Windows, use .venv\Scripts\Activate.ps1, según las políticas locales de la terminal. Luego instale la biblioteca y registre las versiones:
python -m pip install scikit-learn
python -m pip freeze > requirements.txt
Use python3 en lugar de python si ese es el nombre del ejecutable en su computadora. El archivo de dependencias ayuda a recrear el entorno; guarde también la versión de Python, el código y la configuración del experimento.
Un primer modelo completo: clasificación de flores
El conjunto Iris de scikit-learn contiene 150 observaciones, cuatro atributos numéricos y tres clases. Es pequeño y adecuado para aprender el flujo de trabajo, pero no demuestra que un sistema esté listo para datos reales.
Guarde el código siguiente como exemplo_iris.py y ejecute python exemplo_iris.py. Usa 120 observaciones para entrenamiento y 30 para prueba. La división estratificada mantiene la representación de las clases; la semilla fija permite repetir la misma división.
import platform
from time import perf_counter
import sklearn
from sklearn.datasets import load_iris
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=42, stratify=y
)
models = {
"baseline": DummyClassifier(strategy="most_frequent"),
"logistica": make_pipeline(
StandardScaler(), LogisticRegression(max_iter=1000)
),
}
for name, model in models.items():
start = perf_counter()
model.fit(X_train, y_train)
train_seconds = perf_counter() - start
pred = model.predict(X_test)
print(name, "acuracia=", round(accuracy_score(y_test, pred), 3),
"f1_macro=", round(f1_score(
y_test, pred, average="macro", zero_division=0
), 3))
print("matriz de confusao:", confusion_matrix(y_test, pred).tolist())
print("tempo de treino (s):", round(train_seconds, 6))
print("Python:", platform.python_version(),
"scikit-learn:", sklearn.__version__)
El DummyClassifier proporciona una comparación que no aprende una relación entre los atributos y la clase. Con la estrategia utilizada aquí, predice la clase más frecuente del entrenamiento. Si un modelo más elaborado no mejora una referencia así, investigue los datos, el objetivo y la evaluación antes de gastar más recursos. Consulte las estrategias en la documentación de DummyClassifier.
La regresión logística recibe los datos a través de una Pipeline: primero la estandarización, después el clasificador. Las transformaciones se ajustan en el entrenamiento y se vuelven a aplicar a la prueba. Esto evita calcular la escala usando información que debería estar reservada para la evaluación, una forma común de fuga de datos. La documentación de buenas prácticas de scikit-learn explica esta precaución.
Cómo interpretar la salida sin engañarse
En la ejecución de este ejemplo en CPU, con Python 3.14.4 y scikit-learn 1.9.1, obtuvimos los resultados a continuación. Son resultados del ejercicio y de esta división de los datos, no una promesa para otro conjunto.
| Modelo | Precisión en la prueba | F1 macro |
|---|---|---|
| Referencia de la clase más frecuente | 0,333 | 0,167 |
| Estandarización + regresión logística | 0,933 | 0,933 |
La matriz del segundo modelo fue [[10, 0, 0], [0, 9, 1], [0, 1, 9]]: dos de las 30 flores de la prueba se confundieron entre las dos últimas clases. Esto es más informativo que decir solo que el modelo acertó alrededor del 93%.
La precisión indica la proporción de predicciones correctas en el conjunto evaluado. El F1 macro calcula el F1 de cada clase y obtiene un promedio sin dar mayor peso a la clase más frecuente. La matriz de confusión muestra qué clases se confundieron. Use las tres lecturas para comprender el comportamiento, en lugar de buscar solo el número más alto.
El tiempo impreso es solo el tiempo de entrenamiento de esa ejecución en su computadora. En un conjunto tan pequeño, varía según la máquina y el ruido de medición. No use este número para prometer ahorros en la nube ni para comparar CPU y GPU.
El resultado de Iris tampoco debe convertirse en una expectativa de precisión para su producto. En datos propios, la distribución, la calidad de las etiquetas y el costo de los errores pueden ser completamente diferentes. Un fallo poco frecuente puede ser más importante que decenas de aciertos fáciles.
Antes de cambiar el algoritmo, responda:
- ¿El modelo superó la referencia básica usando exactamente la misma prueba?
- ¿Qué clase concentra los errores y cuál es su impacto en la tarea?
- ¿Hay información en las entradas que solo estaría disponible después de la predicción?
- ¿La prueba representa ejemplos nuevos o contiene duplicados y observaciones relacionadas con el entrenamiento?
- ¿El rendimiento se mantiene en otras divisiones válidas de los datos?
Del ejercicio a un conjunto de datos real
La división aleatoria es conveniente para Iris. Puede ser inadecuada si predice eventos futuros, tiene varias filas por cliente o encuentra copias de la misma observación. En estos casos, considere una separación temporal o por grupos, según la forma en que se usará el modelo. El parámetro random_state no corrige una división conceptualmente errónea. La referencia de train_test_split describe los controles disponibles para esta división simple.
Reserve la validación para elegir configuraciones y mantenga una prueba final separada. Si consulta la prueba repetidamente para decidir el siguiente ajuste, pasa a influir en sus decisiones. Para un proyecto pequeño, una hoja de cálculo de experimentos ya ayuda:
| Registro | Qué anotar |
|---|---|
| Datos | Origen, fecha, tamaño, columnas y regla de exclusión |
| División | Temporal, por grupos o aleatoria; semilla cuando corresponda |
| Modelo | Algoritmo, parámetros y versión de las dependencias |
| Evaluación | Métrica principal, errores por clase y comparación con la referencia |
| Operación | Tiempo, memoria, tamaño del artefacto y costo medido |
| Decisión | Qué mejoró y qué problema sigue abierto |
Cuando sustituya Iris por una tabla propia, valide los tipos, los campos ausentes y las categorías antes de entrenar. Mantenga las transformaciones junto al modelo para que la predicción use la misma preparación de los datos. Una columna cuya unidad cambió puede causar problemas incluso si el código sigue ejecutándose.
Cuándo ayuda una GPU — y cuándo no ayuda
El ejemplo de esta guía funciona en CPU. Añadir una tarjeta a la máquina no hace que todo el código de scikit-learn la use automáticamente. El proyecto documenta compatibilidad con GPU para un conjunto limitado de estimadores y configuraciones, incluso mediante entradas y opciones específicas. Verifique la ruta exacta del algoritmo elegido.
Una GPU merece un experimento cuando hay una implementación compatible y una carga que puede aprovecharla, como determinados entrenamientos de redes neuronales o el procesamiento por lotes. Aun así, la ganancia debe compensar la transferencia de datos, la preparación del entorno y el costo de la infraestructura.
| Situación observada | Próxima acción recomendada |
|---|---|
| Pocos datos y entrenamiento rápido en CPU | Priorizar la calidad de los datos y la evaluación |
| La lectura o preparación consume la mayor parte del tiempo | Medir almacenamiento, carga y transformaciones |
| Algoritmo sin una vía compatible con GPU | Revisar la biblioteca o mantener la CPU |
| El entrenamiento compatible con GPU ocupa gran parte del ciclo | Ejecutar una prueba controlada en la configuración candidata |
| Modelo grande o alto volumen de inferencia | Medir memoria, latencia y concurrencia con la carga real |
Compare el tiempo total hasta obtener un resultado útil, y no solo la ejecución de una operación. Incluya instalación, transferencia, entrenamiento, validación, almacenamiento y períodos de inactividad. Una alternativa más rápida por época puede ser peor si exige más intentos para alcanzar la calidad necesaria.
Cuando el proyecto llegue a esta etapa, Flatkey Cloud GPU permite evaluar opciones de alquiler de GPU NVIDIA. Confirme la configuración, la región, la disponibilidad y las condiciones para la carga prevista. Lleve el tamaño del conjunto, la biblioteca, la memoria necesaria y el objetivo de la prueba; este tutorial no exige contratar una GPU para completarse.
Antes de poner el modelo en uso
Defina el formato de entrada aceptado, el comportamiento para campos no válidos y cómo supervisar los errores después de la publicación. Guarde juntas la versión del modelo y la preparación de los datos. Pruebe una predicción con datos representativos fuera del notebook antes de pensar en la escala.
Si el siguiente paso es servir un modelo de lenguaje con infraestructura propia, la guía de implementación de vLLM aborda otro tipo de carga. No confunda un clasificador tabular pequeño con la operación de un LLM: los requisitos de memoria, evaluación y servidor son diferentes.
Preguntas frecuentes
¿Necesito una GPU para aprender machine learning con Python?
No. El ejemplo presentado puede ejecutarse en CPU. Elija una infraestructura mayor cuando exista un cuello de botella medido y una implementación que pueda aprovecharla.
¿Por qué usar una referencia básica antes de un modelo más complejo?
Muestra lo que es posible obtener con una regla simple. Esto permite evaluar si el modelo aprendió algo útil y si la complejidad adicional está justificada.
¿La misma semilla garantiza el mismo resultado en cualquier entorno?
Fija las elecciones aleatorias controladas por ese parámetro. Registre también las versiones y el entorno; las diferencias de implementación y ejecución pueden afectar los resultados. No confunda la repetibilidad de una división con una garantía universal de rendimiento.
¿Cuál es el próximo proyecto después de Iris?
Elija una tarea pequeña con datos que entienda, un objetivo verificable y un criterio de éxito. Repita el proceso: referencia, división correcta, modelo, análisis de errores y medición. Este hábito es la base para progresar en machine learning con Python sin aumentar el costo antes de que sea necesario.
