Cómo Crear tu Primer Modelo de IA con Python paso a paso

Llegó el momento. Ya sabes qué es la Inteligencia Artificial. Ya entiendes la diferencia entre Machine Learning y Deep Learning. Ahora viene la parte que realmente te convierte en alguien que hace IA: escribir el código y ver cómo un modelo aprende.

En este artículo vas a crear tu primer modelo de Machine Learning con Python desde cero. No es un ejemplo de juguete: al final del tutorial tendrás un modelo funcional que predice si un tumor es maligno o benigno basándose en datos médicos reales.

Todo el código es ejecutable. No necesitas una computadora potente. Solo necesitas Python instalado o una cuenta gratuita en Google Colab.

¿Listo? Vamos paso a paso.

¿Qué vamos a construir?

Nuestro modelo va a aprender a clasificar tumores como malignos o benignos usando el dataset Breast Cancer Wisconsin, uno de los datasets más clásicos en Machine Learning. Viene incluido directamente en scikit-learn, así que no necesitas descargar nada.

El modelo recibirá 30 características médicas de un tumor (tamaño, textura, forma...) y predecirá si es maligno (peligroso) o benigno (no peligroso). Este es exactamente el tipo de problema que los sistemas de IA ayudan a resolver en hospitales reales.

Al terminar este tutorial habrás completado el flujo completo de Machine Learning:

1. ⚙️ Configurar el entorno
2. 📦 Cargar y explorar los datos
3. 🔪 Dividir datos en entrenamiento y prueba
4. 🤖 Entrenar el modelo
5. 📊 Evaluar su rendimiento
6. 🔮 Hacer predicciones con datos nuevos
7. 💾 Guardar el modelo para usarlo después

Paso 1: Configura tu entorno

Tienes dos opciones para seguir este tutorial:

Opción A: Google Colab (recomendada para principiantes)

Google Colab es un entorno de notebooks de Python gratuito que corre en la nube. No necesitas instalar nada. Solo ve a colab.research.google.com, inicia sesión con tu cuenta de Google y crea un nuevo notebook.

Todas las librerías que necesitamos ya están instaladas. Es perfecto para empezar.

Opción B: En tu computadora

Si prefieres trabajar localmente, abre la terminal e instala las librerías necesarias:

pip install scikit-learn pandas numpy matplotlib seaborn

Luego puedes usar VS Code, Jupyter Notebook o cualquier editor de Python.

💡 Tip: Si es tu primera vez, ve con Google Colab. Evitas problemas de instalación y puedes empezar en 30 segundos.

Paso 2: Importa las librerías

Lo primero en cualquier proyecto de Machine Learning es importar las herramientas. Copia y ejecuta este bloque:

# ============================================
# LIBRERÍAS ESENCIALES
# ============================================

# Manipulación de datos
import numpy as np
import pandas as pd

# Visualización
import matplotlib.pyplot as plt
import seaborn as sns

# El corazón de este proyecto: scikit-learn
from sklearn.datasets import load_breast_cancer        # nuestro dataset
from sklearn.model_selection import train_test_split   # dividir datos
from sklearn.preprocessing import StandardScaler       # normalizar datos
from sklearn.linear_model import LogisticRegression    # nuestro modelo
from sklearn.metrics import (
    accuracy_score,       # precisión general
    classification_report,# reporte detallado
    confusion_matrix      # matriz de confusión
)

print("✅ Todas las librerías importadas correctamente")
print(f"Versión de scikit-learn: {__import__('sklearn').__version__}")

¿Para qué sirve cada librería?

• NumPy — operaciones matemáticas con arrays
• Pandas — manipulación y análisis de datos en tablas
• Matplotlib / Seaborn — visualización de datos
• scikit-learn — el motor de Machine Learning: datasets, modelos, métricas

Paso 3: Carga y explora los datos

Antes de entrenar cualquier modelo, necesitas entender con qué datos estás trabajando. Nunca te saltes este paso.

# ============================================
# CARGAR EL DATASET
# ============================================

# Cargamos el dataset de cáncer de mama
cancer = load_breast_cancer()

# Convertimos a DataFrame de pandas para verlo mejor
df = pd.DataFrame(
    data=cancer.data,
    columns=cancer.feature_names
)
df['objetivo'] = cancer.target

print("📊 Primeras 5 filas del dataset:")
print(df.head())

print(f"\n📐 Dimensiones: {df.shape}")
print(f"   → {df.shape[0]} pacientes")
print(f"   → {df.shape[1]} columnas ({df.shape[1]-1} características + 1 objetivo)")

print(f"\n🎯 Distribución de clases:")
print(f"   Benignos (1):  {(df['objetivo'] == 1).sum()} casos")
print(f"   Malignos (0):  {(df['objetivo'] == 0).sum()} casos")

Verás que el dataset tiene:

• 569 pacientes
• 30 características médicas por tumor (radio, textura, perímetro, área...)
• 2 clases: 0 = maligno, 1 = benigno

# ============================================
# EXPLORACIÓN BÁSICA
# ============================================

print("📈 Estadísticas descriptivas:")
print(df.describe().round(2))

print("\n🔍 ¿Hay valores nulos?")
print(df.isnull().sum().sum(), "valores nulos en total")
# Si el resultado es 0, ¡perfecto! No hay limpieza que hacer.

💡 En proyectos reales, la exploración y limpieza de datos puede llevar el 80% del tiempo total. Aquí usamos un dataset ya limpio para enfocarnos en el flujo del modelo.

Paso 4: Prepara los datos para el modelo

Los modelos de Machine Learning necesitan los datos en un formato específico: X (características de entrada) e y (lo que queremos predecir).

# ============================================
# SEPARAR CARACTERÍSTICAS Y OBJETIVO
# ============================================

X = df.drop('objetivo', axis=1)  # todas las columnas menos el objetivo
y = df['objetivo']                # solo la columna objetivo

print(f"Forma de X (características): {X.shape}")
print(f"Forma de y (objetivo):        {y.shape}")

Dividir en entrenamiento y prueba

Este es uno de los conceptos más importantes del Machine Learning: nunca evalúes tu modelo con los mismos datos con los que lo entrenaste. Si lo haces, el modelo parece funcionar bien pero en realidad solo memorizó los datos. Necesitas probar con datos que no ha visto antes.

# ============================================
# DIVIDIR EN ENTRENAMIENTO Y PRUEBA
# ============================================

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.20,     # 20% para prueba, 80% para entrenamiento
    random_state=42,    # semilla para reproducibilidad
    stratify=y          # mantener la proporción de clases en ambos conjuntos
)

print(f"📚 Datos de entrenamiento: {X_train.shape[0]} pacientes")
print(f"🧪 Datos de prueba:        {X_test.shape[0]} pacientes")

Normalizar los datos

Las características del dataset tienen escalas muy diferentes: el radio mide entre 6 y 28, mientras que el área mide entre 143 y 2501. Muchos algoritmos funcionan mucho mejor cuando todas las características están en la misma escala. A esto se le llama normalización.

# ============================================
# NORMALIZACIÓN (ESCALADO)
# ============================================

scaler = StandardScaler()

# IMPORTANTE: ajustamos el scaler SOLO con datos de entrenamiento
# para evitar "data leakage" (filtración de información del test)
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)  # solo transformamos, no ajustamos

print("✅ Datos normalizados correctamente")
print(f"Media antes de escalar: {X_train.mean().mean():.2f}")
print(f"Media después de escalar: {X_train_scaled.mean():.4f} (≈ 0)")

⚠️ Error común: Muchos principiantes aplican el scaler a todo el dataset antes de dividirlo. Eso hace que el modelo "vea" información del test durante el entrenamiento (data leakage), lo que da resultados artificialmente buenos que no se repiten en producción.

Paso 5: Entrena el modelo

Aquí es donde ocurre la magia. Vamos a usar Regresión Logística, que a pesar de su nombre es un algoritmo de clasificación. Es el modelo ideal para empezar: simple, interpretable y sorprendentemente poderoso.

# ============================================
# CREAR Y ENTRENAR EL MODELO
# ============================================

# Crear el modelo
modelo = LogisticRegression(
    max_iter=1000,   # número máximo de iteraciones para converger
    random_state=42
)

# Entrenar el modelo con los datos de entrenamiento
print("🏋️ Entrenando el modelo...")
modelo.fit(X_train_scaled, y_train)
print("✅ ¡Modelo entrenado exitosamente!")

¿Qué pasó en esas dos líneas? El modelo analizó los 455 pacientes de entrenamiento, encontró los patrones que distinguen tumores malignos de benignos y ajustó sus parámetros internos para hacer las mejores predicciones posibles.

En scikit-learn, entrenar un modelo siempre sigue el mismo patrón:

1. modelo = NombreDelAlgoritmo() — crear el modelo
2. modelo.fit(X_train, y_train) — entrenarlo
3. modelo.predict(X_test) — usarlo para predecir

Esa consistencia es una de las grandes ventajas de scikit-learn.

Paso 6: Evalúa el rendimiento

Entrenar el modelo es solo la mitad del trabajo. Ahora necesitas saber qué tan bueno es con datos que nunca ha visto.

# ============================================
# EVALUACIÓN DEL MODELO
# ============================================

# Predecimos con los datos de prueba
y_predicciones = modelo.predict(X_test_scaled)

# Métrica 1: Precisión general (accuracy)
precision = accuracy_score(y_test, y_predicciones)
print(f"🎯 Precisión del modelo: {precision:.4f} ({precision*100:.2f}%)")

# Métrica 2: Reporte detallado
print("\n📋 Reporte de clasificación:")
print(classification_report(
    y_test, y_predicciones,
    target_names=['Maligno', 'Benigno']
))

El resultado será algo así:

🎯 Precisión del modelo: 0.9737 (97.37%)

📋 Reporte de clasificación:
              precision    recall  f1-score   support

     Maligno       0.97      0.95      0.96        43
     Benigno       0.97      0.99      0.98        71

    accuracy                           0.97       114
   macro avg       0.97      0.97      0.97       114
weighted avg       0.97      0.97      0.97       114

¡97.37% de precisión! Pero antes de celebrar, entendamos qué significan estas métricas:

• Precision — de todos los que el modelo predijo como malignos, ¿cuántos realmente lo eran? (falsos positivos)
• Recall — de todos los malignos reales, ¿cuántos detectó el modelo? (falsos negativos)
• F1-score — media entre precision y recall. Útil cuando las clases están desbalanceadas

💡 En medicina, el Recall es crítico: es peor decirle a un paciente maligno que está sano (falso negativo) que decirle a uno sano que podría tener cáncer (falso positivo). Dependiendo del contexto, optimizarás métricas diferentes.

Visualizar la matriz de confusión

# ============================================
# MATRIZ DE CONFUSIÓN
# ============================================

cm = confusion_matrix(y_test, y_predicciones)

plt.figure(figsize=(8, 6))
sns.heatmap(
    cm,
    annot=True,
    fmt='d',
    cmap='Blues',
    xticklabels=['Maligno', 'Benigno'],
    yticklabels=['Maligno', 'Benigno']
)
plt.title('Matriz de Confusión', fontsize=14, fontweight='bold')
plt.ylabel('Valor Real')
plt.xlabel('Predicción del Modelo')
plt.tight_layout()
plt.show()

# Interpretación
print("\n📊 Interpretación:")
print(f"   ✅ Verdaderos Positivos (Benigno real → Benigno predicho): {cm[1][1]}")
print(f"   ✅ Verdaderos Negativos (Maligno real → Maligno predicho): {cm[0][0]}")
print(f"   ❌ Falsos Positivos (Maligno real → Benigno predicho):     {cm[0][1]}")
print(f"   ❌ Falsos Negativos (Benigno real → Maligno predicho):     {cm[1][0]}")

Paso 7: Haz predicciones con datos nuevos

Un modelo que no se puede usar en producción no sirve de mucho. Veamos cómo hacer predicciones con un nuevo paciente que el modelo nunca ha visto:

# ============================================
# PREDICCIÓN CON DATOS NUEVOS
# ============================================

# Tomamos el primer paciente del conjunto de prueba como ejemplo
nuevo_paciente = X_test.iloc[0:1]

# IMPORTANTE: normalizar con el mismo scaler
nuevo_paciente_scaled = scaler.transform(nuevo_paciente)

# Hacer la predicción
prediccion = modelo.predict(nuevo_paciente_scaled)
probabilidad = modelo.predict_proba(nuevo_paciente_scaled)

resultado = "BENIGNO ✅" if prediccion[0] == 1 else "MALIGNO ⚠️"
confianza = max(probabilidad[0]) * 100

print(f"🔮 Diagnóstico del modelo: {resultado}")
print(f"📊 Confianza: {confianza:.1f}%")
print(f"   Probabilidad de benigno:  {probabilidad[0][1]*100:.1f}%")
print(f"   Probabilidad de maligno:  {probabilidad[0][0]*100:.1f}%")

# Verificamos si acertó
real = "BENIGNO ✅" if y_test.iloc[0] == 1 else "MALIGNO ⚠️"
print(f"\n✔️  Diagnóstico real: {real}")
print(f"{'✅ ¡Correcto!' if prediccion[0] == y_test.iloc[0] else '❌ Incorrecto'}")

Paso 8: Guarda el modelo para usarlo después

En el mundo real, entrenas el modelo una vez y lo usas muchas veces. Para eso necesitas guardarlo.

# ============================================
# GUARDAR Y CARGAR EL MODELO
# ============================================

import joblib

# Guardar el modelo y el scaler
joblib.dump(modelo, 'modelo_cancer.pkl')
joblib.dump(scaler, 'scaler_cancer.pkl')
print("💾 Modelo guardado en 'modelo_cancer.pkl'")
print("💾 Scaler guardado en 'scaler_cancer.pkl'")

# ----- Cómo cargarlo después -----

# modelo_cargado = joblib.load('modelo_cancer.pkl')
# scaler_cargado = joblib.load('scaler_cancer.pkl')
#
# nuevos_datos_scaled = scaler_cargado.transform(nuevos_datos)
# prediccion = modelo_cargado.predict(nuevos_datos_scaled)

print("\n✅ El modelo está listo para usarse en producción")

Código completo en un solo bloque

Aquí tienes todo el proyecto listo para copiar y ejecutar de una vez:

# ============================================
# MI PRIMER MODELO DE IA CON PYTHON
# Detector de tumores: maligno vs benigno
# ============================================

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import joblib

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# 1. CARGAR DATOS
cancer = load_breast_cancer()
X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y = pd.Series(cancer.target)
print(f"Dataset: {X.shape[0]} pacientes, {X.shape[1]} características")

# 2. DIVIDIR EN ENTRENAMIENTO Y PRUEBA
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=42, stratify=y
)

# 3. NORMALIZAR
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled  = scaler.transform(X_test)

# 4. ENTRENAR EL MODELO
modelo = LogisticRegression(max_iter=1000, random_state=42)
modelo.fit(X_train_scaled, y_train)
print("✅ Modelo entrenado")

# 5. EVALUAR
y_pred    = modelo.predict(X_test_scaled)
precision = accuracy_score(y_test, y_pred)
print(f"🎯 Precisión: {precision*100:.2f}%")
print(classification_report(y_test, y_pred, target_names=['Maligno','Benigno']))

# 6. MATRIZ DE CONFUSIÓN
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=['Maligno','Benigno'],
            yticklabels=['Maligno','Benigno'])
plt.title('Matriz de Confusión')
plt.ylabel('Real')
plt.xlabel('Predicción')
plt.show()

# 7. PREDICCIÓN CON NUEVO DATO
nuevo = scaler.transform(X_test.iloc[0:1])
pred  = modelo.predict(nuevo)
prob  = modelo.predict_proba(nuevo)
print(f"\n🔮 Predicción: {'BENIGNO ✅' if pred[0]==1 else 'MALIGNO ⚠️'}")
print(f"📊 Confianza: {max(prob[0])*100:.1f}%")

# 8. GUARDAR
joblib.dump(modelo, 'modelo_cancer.pkl')
joblib.dump(scaler, 'scaler_cancer.pkl')
print("💾 Modelo guardado exitosamente")

¿Qué aprendiste hoy? El flujo completo de ML

Acabas de completar el ciclo completo de un proyecto de Machine Learning real. Este mismo flujo se repite en proyectos profesionales, independientemente del algoritmo o el dominio:

DATOS → EXPLORACIÓN → PREPARACIÓN → ENTRENAMIENTO → EVALUACIÓN → PREDICCIÓN → PRODUCCIÓN

¿Qué sigue? Próximos pasos recomendados

Ahora que ya sabes crear un modelo básico, aquí van los pasos naturales para seguir creciendo:

• 🔁 Prueba otros algoritmos — cambia LogisticRegression por RandomForestClassifier, SVC o KNeighborsClassifier y compara resultados. La API de scikit-learn es la misma para todos.
• 📊 Explora Kaggle — la plataforma de competencias de Machine Learning más grande del mundo. Tiene miles de datasets reales y notebooks públicos para aprender.
• 🧹 Aprende feature engineering — crear y seleccionar las características correctas es lo que marca la diferencia entre un modelo mediocre y uno excelente.
• 🧠 Avanza a Deep Learning — una vez que domines ML clásico con scikit-learn, el siguiente paso es TensorFlow o PyTorch para redes neuronales.
• 🐙 Sube tus proyectos a GitHub — es tu portafolio. Los reclutadores lo miran.

Errores comunes que debes evitar

• ❌ Data leakage — aplicar el scaler a todos los datos antes de dividirlos. Siempre ajusta el scaler solo con el conjunto de entrenamiento.
• ❌ Evaluar con datos de entrenamiento — el modelo siempre parece perfecto con datos que ya conoce. Evalúa siempre con el conjunto de prueba.
• ❌ Ignorar el desbalance de clases — si tienes 95% de clase A y 5% de clase B, un modelo que predice siempre A tiene 95% de precisión pero es inútil. Usa F1-score y recall.
• ❌ Saltar la exploración de datos — entender tus datos antes de modelar es lo que separa a los buenos de los malos científicos de datos. "Basura dentro, basura fuera."
• ❌ Obsesionarse con el algoritmo — el 80% del impacto viene de buenos datos y buenas características, no de elegir el algoritmo más sofisticado.

Resumen: lo que construiste hoy

• ✅ Configuraste un entorno de Machine Learning con Python
• ✅ Cargaste y exploraste un dataset médico real
• ✅ Dividiste los datos en entrenamiento y prueba correctamente
• ✅ Normalizaste las características con StandardScaler
• ✅ Entrenaste un modelo de Regresión Logística
• ✅ Evaluaste el modelo con accuracy, precision, recall y F1-score
• ✅ Visualizaste la matriz de confusión
• ✅ Hiciste predicciones con datos nuevos con porcentaje de confianza
• ✅ Guardaste el modelo para usarlo en producción

🧪 ¿Tienes las bases de Python para seguir avanzando en IA?

Crear modelos de IA con Python requiere tener bien sólidos los fundamentos del lenguaje. Si en algún punto del tutorial te sentiste perdido con la sintaxis, las listas o las funciones, es una señal de que vale la pena reforzar primero las bases.

Tenemos dos tests perfectos para verificar dónde estás:

👉 Test: Python Básico 👉 Test: Python Intermedio 

¿Lograste ejecutar el código completo? ¿Qué precisión obtuviste? ¿Cambiaste el algoritmo para ver si mejoraba? Cuéntanos en los comentarios 👇 — la comunidad aprende de tus experimentos tanto como de los tutoriales. 🚀