Introducción

El machine learning, o aprendizaje automático, es una rama de la inteligencia artificial que permite a los sistemas aprender patrones a partir de datos sin estar programados explícitamente para cada caso concreto.

En lugar de escribir reglas manuales como:

if cliente_edad > 40 and ingresos > 30000:    aprobar = True

un modelo de machine learning aprende esas relaciones automáticamente a partir de ejemplos históricos.

Esto lo convierte en una herramienta muy útil para tareas como:

• Clasificación de correos como spam o no spam.
• Predicción de precios de viviendas.
• Detección de fraude.
• Recomendación de productos.
• Diagnóstico asistido.
• Segmentación de clientes.
• Análisis de imágenes o texto.

La clave está en los datos. Un modelo no “piensa” como una persona, sino que identifica patrones estadísticos y los utiliza para hacer predicciones sobre casos nuevos.

Qué es machine learning

Machine learning es el proceso mediante el cual un algoritmo analiza datos, detecta patrones y construye un modelo capaz de generalizar.

Dicho de forma sencilla:

1. Le damos ejemplos al sistema.
2. El algoritmo aprende relaciones entre las variables.
3. El modelo resultante se usa para hacer predicciones.

Por ejemplo, si queremos predecir si un cliente abandonará una suscripción, podríamos usar datos como:

• Antigüedad del cliente.
• Número de compras.
• Uso mensual del servicio.
• Incidencias abiertas.
• Tipo de plan contratado.
• Historial de pagos.

A partir de esos datos, el modelo intentará estimar si un cliente tiene alta o baja probabilidad de marcharse.

Tipos principales de machine learning

Aprendizaje supervisado

Es el tipo más común. Trabajamos con datos que ya tienen una respuesta conocida.

Ejemplos:

• Predecir si un email es spam.
• Estimar el precio de una vivienda.
• Clasificar una imagen como perro o gato.
• Detectar si una transacción es fraudulenta.

En este caso, el conjunto de datos contiene tanto las variables de entrada como la salida esperada.

Aprendizaje no supervisado

Aquí no tenemos una respuesta previa. El algoritmo busca patrones ocultos en los datos.

Ejemplos:

• Agrupar clientes por comportamiento.
• Detectar anomalías.
• Reducir la dimensionalidad de un conjunto de datos.
• Encontrar estructuras internas en grandes volúmenes de información.

Aprendizaje por refuerzo

El modelo aprende mediante prueba y error. Recibe recompensas o penalizaciones según las decisiones que toma.

Se usa en áreas como:

• Robótica.
• Videojuegos.
• Optimización de rutas.
• Sistemas autónomos.

Ejemplo completo de machine learning en Python

Vamos a crear un ejemplo sencillo pero completo: un modelo que predice si una flor pertenece a una especie concreta usando el famoso dataset Iris.

Este conjunto de datos contiene medidas de flores, como:

• Longitud del sépalo.
• Anchura del sépalo.
• Longitud del pétalo.
• Anchura del pétalo.

A partir de esas características, el modelo debe clasificar la flor en una de estas especies:

• Setosa.
• Versicolor.
• Virginica.

Instalación de dependencias

Para ejecutar el ejemplo necesitamos Python y algunas librerías habituales:

pip install pandas scikit-learn matplotlib seaborn

Usaremos:

• pandas para trabajar con datos.
• scikit-learn para entrenar el modelo.
• matplotlib y seaborn para visualizar resultados.

Código completo del ejemplo

import pandas as pdimport seaborn as snsimport matplotlib.pyplot as pltfrom sklearn.datasets import load_irisfrom sklearn.model_selection import train_test_splitfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.metrics import classification_report, confusion_matrix, accuracy_scoreimport joblib# 1. Cargar el dataset Irisiris = load_iris()# 2. Crear un DataFrame con los datosdf = pd.DataFrame(    iris.data,    columns=iris.feature_names)# 3. Añadir la variable objetivodf["target"] = iris.targetdf["species"] = df["target"].apply(lambda x: iris.target_names[x])# 4. Mostrar las primeras filasprint("Primeras filas del dataset:")print(df.head())# 5. Separar variables de entrada y salidaX = df[iris.feature_names]y = df["target"]# 6. Dividir los datos en entrenamiento y pruebaX_train, X_test, y_train, y_test = train_test_split(    X,    y,    test_size=0.2,    random_state=42,    stratify=y)# 7. Crear el modelomodel = RandomForestClassifier(    n_estimators=100,    random_state=42)# 8. Entrenar el modelomodel.fit(X_train, y_train)# 9. Hacer prediccionesy_pred = model.predict(X_test)# 10. Evaluar el modeloaccuracy = accuracy_score(y_test, y_pred)print("\nAccuracy del modelo:")print(accuracy)print("\nInforme de clasificación:")print(classification_report(y_test, y_pred, target_names=iris.target_names))print("\nMatriz de confusión:")print(confusion_matrix(y_test, y_pred))# 11. Visualizar la matriz de confusiónplt.figure(figsize=(6, 4))sns.heatmap(    confusion_matrix(y_test, y_pred),    annot=True,    cmap="Blues",    fmt="d",    xticklabels=iris.target_names,    yticklabels=iris.target_names)plt.xlabel("Predicción")plt.ylabel("Valor real")plt.title("Matriz de confusión - Clasificación Iris")plt.tight_layout()plt.show()# 12. Probar con una nueva flornew_flower = pd.DataFrame(    [[5.1, 3.5, 1.4, 0.2]],    columns=iris.feature_names)prediction = model.predict(new_flower)predicted_species = iris.target_names[prediction[0]]print("\nNueva flor clasificada como:")print(predicted_species)# 13. Guardar el modelo entrenadojoblib.dump(model, "modelo_iris.pkl")print("\nModelo guardado como modelo_iris.pkl")

Explicación paso a paso

1. Carga del dataset

iris = load_iris()

scikit-learn incluye algunos datasets de ejemplo. En este caso usamos Iris porque es pequeño, limpio y perfecto para aprender los fundamentos.

Después convertimos los datos en un DataFrame de pandas para trabajar de forma más cómoda:

df = pd.DataFrame(    iris.data,    columns=iris.feature_names)

Esto nos permite visualizar los datos en formato tabular.

2. Variables de entrada y variable objetivo

En machine learning distinguimos entre:

• X: variables de entrada.
• y: variable que queremos predecir.

En este ejemplo:

X = df[iris.feature_names]y = df["target"]

X contiene las medidas de la flor.

y contiene la especie.

3. División entre entrenamiento y prueba

Uno de los errores más comunes al empezar es evaluar el modelo con los mismos datos que se han usado para entrenarlo.

Por eso separamos los datos:

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

Usamos el 80 % de los datos para entrenar y el 20 % para probar.

El parámetro stratify=y ayuda a mantener la misma proporción de clases en ambos conjuntos.

4. Entrenamiento del modelo

Usamos un modelo llamado RandomForestClassifier:

model = RandomForestClassifier(    n_estimators=100,    random_state=42)

Un Random Forest combina varios árboles de decisión para mejorar la precisión y reducir errores.

Luego entrenamos:

model.fit(X_train, y_train)

En este punto, el modelo aprende relaciones entre las medidas de las flores y sus especies.

5. Predicción

Una vez entrenado, usamos el modelo sobre datos que no ha visto antes:

y_pred = model.predict(X_test)

El resultado es una lista de predicciones que después comparamos con los valores reales.

6. Evaluación del modelo

Calculamos la precisión:

accuracy = accuracy_score(y_test, y_pred)

El accuracy indica qué porcentaje de predicciones han sido correctas.

También generamos un informe más completo:

classification_report(y_test, y_pred, target_names=iris.target_names)

Este informe incluye métricas como:

Precision

De todas las veces que el modelo predijo una clase, cuántas acertó.

Recall

De todos los casos reales de una clase, cuántos detectó correctamente.

F1-score

Una media equilibrada entre precision y recall.

Support

Número de ejemplos reales de cada clase.

7. Matriz de confusión

La matriz de confusión muestra de forma visual dónde acierta y dónde falla el modelo.

confusion_matrix(y_test, y_pred)

Por ejemplo, permite ver si el modelo confunde mucho versicolor con virginica, o si identifica bien todas las clases.

Es una herramienta muy útil porque no basta con saber que el modelo acierta mucho: también interesa saber en qué se equivoca.

8. Predicción con un caso nuevo

Creamos una nueva flor:

new_flower = pd.DataFrame(    [[5.1, 3.5, 1.4, 0.2]],    columns=iris.feature_names)

Y la clasificamos:

prediction = model.predict(new_flower)

El modelo devuelve una clase numérica, que convertimos en nombre:

predicted_species = iris.target_names[prediction[0]]

Así obtenemos una predicción comprensible.

9. Guardar el modelo

Finalmente, guardamos el modelo entrenado:

joblib.dump(model, "modelo_iris.pkl")

Esto permite reutilizarlo más adelante sin tener que entrenarlo de nuevo.

Para cargarlo en otro programa:

model = joblib.load("modelo_iris.pkl")

Buenas prácticas al trabajar con machine learning

Revisa la calidad de los datos

Un modelo no puede compensar datos mal recogidos, incompletos o sesgados. Antes de entrenar, conviene revisar valores nulos, duplicados, rangos extraños y posibles errores.

Separa siempre entrenamiento y prueba

Evaluar con los mismos datos de entrenamiento da una imagen falsa del rendimiento. El modelo puede memorizar los ejemplos en lugar de aprender patrones generales.

No te quedes solo con el accuracy

La precisión global puede ser engañosa, especialmente si hay clases desbalanceadas. En problemas reales conviene analizar precision, recall, F1-score y matriz de confusión.

Evita modelos innecesariamente complejos

No siempre el modelo más avanzado es el mejor. En muchos casos, un modelo sencillo, interpretable y bien evaluado es más útil que uno complejo difícil de mantener.

Documenta el proceso

Conviene registrar:

• Fuente de los datos.
• Variables utilizadas.
• Limpieza aplicada.
• Modelo entrenado.
• Métricas obtenidas.
• Limitaciones conocidas.

Piensa en el uso real

Un modelo no termina cuando alcanza buenas métricas. También hay que considerar cómo se integrará, cómo se monitorizará y qué pasará si los datos cambian con el tiempo.

Conclusión

El machine learning permite crear sistemas capaces de aprender patrones a partir de datos y hacer predicciones sobre casos nuevos. En este artículo hemos visto los conceptos básicos y un ejemplo completo en Python usando scikit-learn, desde la carga de datos hasta el entrenamiento, evaluación, predicción y guardado del modelo.

El punto más importante es entender que el valor de un modelo no depende solo del algoritmo. Depende también de la calidad de los datos, de una buena evaluación y de una interpretación responsable de los resultados.

Toni Domenech