Cómo construir tu primer modelo de aprendizaje automático en Python (2026)

La mejor forma de comprender el aprendizaje automático es construir un modelo usted mismo. Es mucho menos intimidante de lo que parece: con Python y la biblioteca adecuada, su primer modelo funcional consta de aproximadamente 20 líneas de código. Este tutorial explica cada paso, no solo qué escribir, sino también por qué.

Qué construirá

Construirá un clasificador —un modelo que clasifica elementos en categorías. Utilizaremos el clásico conjunto de datos para principiantes: el conjunto de datos Iris: mediciones de flores de iris (longitud y anchura del pétalo y del sépalo), donde la tarea consiste en predecir la especie de la flor. Es pequeño, limpio y está integrado en scikit-learn, por lo que resulta ideal para crear su primer modelo.

Los mismos cinco pasos que aprenderá aquí son aplicables a casi cualquier proyecto de aprendizaje automático, sin importar su tamaño.

Paso 1: Configurar sus herramientas

Necesita Python y dos bibliotecas. scikit-learn es la biblioteca principal: proporciona conjuntos de datos, algoritmos y herramientas de evaluación mediante una interfaz coherente y fácil de usar para principiantes.

Instálelas desde su terminal:

pip install scikit-learn pandas

Puede escribir el código en un archivo simple con extensión .py pero un cuaderno Jupyter (o un cuaderno en la nube gratuito como Google Colab) es ideal para aprender, ya que permite ejecutar el código en fragmentos pequeños y ver inmediatamente cada resultado.

Paso 2: Cargar los datos

Todo proyecto de aprendizaje automático comienza con los datos. Aquí cargamos el conjunto de datos Iris integrado:

from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data      # las mediciones (las entradas / características)
y = iris.target    # las especies (las etiquetas / respuestas)

print("Forma de X:", X.shape)   # (150, 4) — 150 flores, 4 mediciones cada una
print("Clases:", iris.target_names)

Aquí importan dos variables, y su nomenclatura es una convención universal:

• X contiene las características — las entradas de las que el modelo aprende (las cuatro mediciones).
• y contiene las etiquetas — las respuestas correctas (la especie).

Como disponemos de las respuestas, esto es aprendizaje supervisado.

Paso 3: Dividir los datos

Este es el paso más importante para obtener un resultado honesto. Debe dividir sus datos en dos partes:

• A conjunto de entrenamiento del que aprende el modelo.
• A conjunto de prueba que el modelo nunca ve durante el entrenamiento y que se usa únicamente para evaluarlo.

Si realizara la prueba con los mismos datos empleados para el entrenamiento, simplemente estaría midiendo la memorización, no un aprendizaje real. (Así es como detecta el sobreajuste.)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

test_size=0.2 reserva el 20 % de los datos para pruebas y entrena con el restante 80 %. random_state=42 simplemente garantiza que la división aleatoria sea reproducible, de modo que obtenga el mismo resultado en cada ejecución.

Paso 4: Elegir y entrenar un modelo

Ahora comienza el aprendizaje automático propiamente dicho. Usaremos un bosque aleatorio (Random Forest) — un algoritmo preciso, fiable y adecuado para principiantes (consulte nuestra guía de algoritmos).

En scikit-learn, entrenar un modelo requiere solo dos líneas:

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

Esa llamada a .fit() realiza es el entrenamiento. El modelo analiza las características del conjunto de entrenamiento y sus etiquetas, y aprende los patrones que relacionan las mediciones con la especie. scikit-learn se encarga de todas las matemáticas subyacentes a esa única línea.

Paso 5: Evaluar el modelo

Ahora compruebe qué tan bien ha aprendido, utilizando el conjunto de prueba que nunca ha visto:

from sklearn.metrics import accuracy_score

predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)

print(f"Precisión: {accuracy:.2%}")

.predict() le pide al modelo que clasifique las flores del conjunto de prueba; accuracy_score compara sus predicciones con las respuestas reales. En el conjunto de datos Iris, normalmente obtendrá una precisión del 95–100 %: su modelo identifica correctamente casi todas las flores que nunca había visto antes.

Paso 6: Realizar una predicción con nuevos datos

El beneficio real: usar el modelo con entradas completamente nuevas. Proporcione un conjunto de mediciones y el modelo predecirá la especie:

new_flower = [[5.1, 3.5, 1.4, 0.2]]   # mediciones del sépalo y el pétalo
prediction = model.predict(new_flower)

print("Especie predicha:", iris.target_names[prediction[0]])

Ese es un modelo completo de aprendizaje automático: entrenado, probado y capaz de realizar predicciones sobre datos que nunca ha encontrado.

Flujo de trabajo completo

Esos cinco pasos no son solo un ejercicio: constituyen la estructura básica de prácticamente cualquier proyecto de ML supervisado:

Los proyectos más grandes incorporan limpieza de datos, preparación de características y ajuste del modelo, pero este ciclo fundamental permanece inalterado.

¿Hacia dónde avanzar a continuación?

Para seguir construyendo:

• Pruebe otros algoritmos — sustituya RandomForestClassifier para LogisticRegression o SVC y comparar. La interfaz coherente de scikit-learn hace esto trivial.
• Pruebe otros conjuntos de datos — practique con conjuntos de datos gratuitos los que le interesen.
• Aprenda la preparación de datos — los datos reales son desordenados; limpiarlos y prepararlos constituye la mayor parte del trabajo.
• Explore la evaluación — la precisión (accuracy) es solo una métrica; aprenda sobre precisión (precision), exhaustividad (recall) y validación cruzada (cross-validation).

Errores comunes que rompen silenciosamente su primer modelo

Su modelo se entrenó e imprimió una puntuación de precisión (accuracy), pero un número que parece bueno no equivale necesariamente a un modelo funcional. Estas son las trampas en las que caen con más frecuencia los principiantes, y todas ellas son fáciles de evitar una vez que se conocen.

• Evaluar el modelo con datos que ya ha visto. Si mide la precisión con los datos de entrenamiento, está calificando al modelo según las respuestas que simplemente memorizó. Una puntuación del 100 % en ese caso no significa nada. Evalúe siempre en el conjunto de prueba reservado que creó al dividir los datos: esa es la única cifra que estima el rendimiento en condiciones reales.
• Fuga de datos (data leakage): permitir que los datos de prueba influyan en el entrenamiento. Este es el error más grave y menos evidente. Si escala, normaliza o rellena valores faltantes antes de antes de dividir los datos, estadísticas procedentes del conjunto de prueba (como la media de una columna) se filtran al proceso de entrenamiento y distorsionan su puntuación. La solución consiste en seguir un orden estricto: primero divida los datos y luego ajuste (fit) cualquier transformador únicamente sobre el conjunto de entrenamiento, y simplemente aplique (apply) dicho transformador al conjunto de prueba. La documentación de scikit-learn señala esta situación como una de las trampas más comunes en el aprendizaje automático.
• Olvidar escalar los datos cuando el algoritmo lo requiere. Los modelos basados en distancia o en gradientes (k-vecinos más cercanos, SVM, regresión logística) se ven afectados negativamente si una característica varía entre 0 y 1 mientras otra lo hace entre 0 y 100 000. En cambio, los modelos basados en árboles, como los bosques aleatorios, no se ven afectados por esta disparidad. Conozca a qué categoría pertenece su algoritmo.
• Confíe ciegamente en la precisión (accuracy) cuando los datos están desbalanceados. Si el 95 % de sus ejemplos pertenecen a una sola clase, un modelo que siempre prediga dicha clase obtendrá una precisión del 95 %, aunque sea completamente inútil. Cuando las clases están desequilibradas, examine la precisión (precision), la exhaustividad (recall) y la puntuación F1 obtenidas mediante classification_report en lugar de confiar únicamente en la precisión (accuracy).

La defensa más limpia contra la fuga de datos es una PipelinePipeline.

• from sklearn.pipeline import make_pipeline
• model = make_pipeline(StandardScaler(), LogisticRegression())
• Luego llame a model.fit(X_train, y_train) exactamente como antes.

Un último hábito que vale la pena desarrollar desde el principio: una única división entre conjuntos de entrenamiento y prueba es una estimación ruidosa. Volver a ejecutar el proceso con una división aleatoria distinta puede hacer variar tu puntuación varios puntos. Una vez que te sientas cómodo, sustituye esa única división por cross_val_score, que entrena y evalúa mediante varias particiones (folds) y reporta la media: una lectura mucho más honesta sobre si tu modelo ha aprendido realmente algo.

Preguntas frecuentes

¿Cómo construyo un modelo de aprendizaje automático en Python?

Utilice la biblioteca scikit-learn. El flujo de trabajo es el siguiente: cargue sus datos en características (X) y etiquetas (y), divídalos en conjuntos de entrenamiento y prueba, cree un modelo y llame a .fit() para entrenarlo, evalúelo en el conjunto de prueba y use .predict() para realizar predicciones con nuevos datos. Un primer modelo consta de aproximadamente 20 líneas de código.

¿Qué biblioteca deberían usar los principiantes para aprendizaje automático?

scikit-learn. Ofrece una amplia gama de algoritmos, conjuntos de datos integrados y herramientas de evaluación mediante una única interfaz sencilla y coherente, y se encarga de las matemáticas subyacentes por usted. Es el punto de partida estándar antes de avanzar a frameworks de aprendizaje profundo.

¿Necesito tener buenos conocimientos matemáticos para construir un modelo de ML?

No. Para construir modelos con scikit-learn basta con conocer los fundamentos de Python y comprender el flujo de trabajo. La biblioteca se encarga de las matemáticas. Los conocimientos matemáticos más profundos resultan útiles más adelante si desea ajustar los modelos con pericia o realizar investigación.

¿Por qué debo dividir los datos en conjuntos de entrenamiento y prueba?

Para poder medir su rendimiento real. Si prueba un modelo con los mismos datos con los que se entrenó, solo estará midiendo su capacidad de memorización. Un conjunto de prueba independiente, que el modelo nunca haya visto, muestra si realmente ha aprendido el patrón y puede generalizar a nuevos datos.

¿Qué hace model.fit()?

.fit() es el paso de entrenamiento. Proporciona al algoritmo las características y etiquetas de entrenamiento, lo que permite que este ajuste sus parámetros internos para aprender los patrones que relacionan las entradas con las respuestas correctas. Tras .fit(), el modelo queda entrenado y listo para realizar predicciones.

Mi modelo obtuvo una alta precisión: ¿eso significa que es bueno?

No necesariamente. Una alta precisión solo tiene sentido si se midió sobre el conjunto de prueba reservado (held-out test set), no sobre los datos de entrenamiento, y si tus clases están razonablemente balanceadas. En un conjunto de datos donde una clase predomina, una puntuación alta puede deberse simplemente a que el modelo adivina sistemáticamente la clase mayoritaria. Revisa la precisión (precision), la exhaustividad (recall) y la puntuación F1 con classification_report, y asegúrate de que dicha cifra proviene de datos que el modelo nunca vio durante el entrenamiento.

¿Cómo guardo mi modelo entrenado y lo uso después?

Usa la biblioteca joblib de Python, que se incluye con scikit-learn. Llama a joblib.dump(modelo, "modelo.joblib") para guardar el modelo entrenado en disco, y a joblib.load("modelo.joblib") para cargarlo nuevamente en otro script: ¡no se requiere volver a entrenarlo! Guarda toda la tubería (Pipeline), no solo el estimador final, para que las transformaciones de escalado y preprocesamiento viajen junto con el modelo y los nuevos datos de entrada se procesen de forma idéntica.

¿Cómo paso de un conjunto de datos integrado a mis propios datos?

Carga tus datos con pandas — pandas.read_csv("tufichero.csv") — y luego separa tus columnas de entrada (características o features, normalmente denominadas X) de la columna que deseas predecir (el objetivo o target, y). A partir de ahí, el flujo de trabajo es idéntico: división, entrenamiento y evaluación. El nuevo trabajo consiste principalmente en limpieza: gestionar valores faltantes, codificar categorías de texto como números y seleccionar qué columnas son realmente útiles. Justamente esta etapa de preparación de los datos es donde se invierte la mayor parte del tiempo en aplicaciones reales de aprendizaje automático.

Conclusión

Construir su primer modelo de aprendizaje automático es, efectivamente, un proyecto breve y alcanzable: instale scikit-learn y luego cargue, divida, entrene, evalúe y realice predicciones. Estos cinco pasos constituyen la base de casi todo proyecto supervisado de aprendizaje automático que construya en el futuro.

No se limite a leer esto: abra un cuaderno (notebook) y ejecute el código. Cambie el algoritmo, pruebe un conjunto de datos distinto, provoque errores y corríjalos. Los conceptos del aprendizaje automático se asimilan mucho más rápido una vez que ha entrenado un modelo con sus propias manos. Cuando esté listo para seguir avanzando, descargue un conjunto de datos gratuito y construya algo propio.