Machine Learning con Python

El Machine Learning (aprendizaje automático) es uno de los campos más apasionantes de la informática moderna. Python se ha consolidado como el lenguaje de referencia para desarrollar modelos de IA gracias a su rico ecosistema y a sus bibliotecas especializadas.

¿Qué es el Machine Learning?

El Machine Learning es una rama de la inteligencia artificial que permite a los ordenadores aprender a partir de datos sin haber sido programados explícitamente. Los algoritmos de ML identifican patrones en los datos y toman decisiones con una intervención humana mínima.

Las bibliotecas esenciales

Python ofrece un ecosistema completo para el Machine Learning:

• NumPy: cálculo numérico y manipulación de matrices multidimensionales
• Pandas: manipulación y análisis de datos
• Scikit-learn: biblioteca completa para el ML clásico
• TensorFlow: framework de deep learning desarrollado por Google
• PyTorch: framework de deep learning flexible e intuitivo
• Keras: API de alto nivel para redes neuronales
• XGBoost: implementación optimizada del gradient boosting

Instalación del entorno

Empieza configurando tu entorno:

# Crear un entorno virtual
python -m venv ml-env
source ml-env/bin/activate  # En Windows: ml-env\Scripts\activate

# Instalar las bibliotecas esenciales
pip install numpy pandas matplotlib scikit-learn tensorflow keras

Tipos de aprendizaje automático

Aprendizaje supervisado

El algoritmo aprende a partir de datos etiquetados:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Cargar y preparar los datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Crear y entrenar el modelo
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Evaluar el modelo
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"Precisión del modelo: {accuracy:.2f}")

Aprendizaje no supervisado

El algoritmo identifica estructuras en datos no etiquetados:

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Crear y entrenar el modelo
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X)

# Visualizar los clústeres
plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], 
            s=300, c='red', marker='X')
plt.title('Clustering K-means')
plt.show()

Aprendizaje por refuerzo

El algoritmo aprende por ensayo y error interactuando con un entorno:

import gym
import numpy as np

# Crear el entorno
env = gym.make('CartPole-v1')

# Parámetros
learning_rate = 0.1
discount_factor = 0.99
episodes = 1000
max_steps = 500

# Tabla Q
q_table = np.zeros([env.observation_space.n, env.action_space.n])

# Bucle de aprendizaje
for episode in range(episodes):
    state = env.reset()
    done = False
    
    for step in range(max_steps):
        # Elegir una acción
        action = np.argmax(q_table[state, :])
        
        # Ejecutar la acción
        new_state, reward, done, _ = env.step(action)
        
        # Actualizar la tabla Q
        q_table[state, action] = q_table[state, action] + learning_rate * (
            reward + discount_factor * np.max(q_table[new_state, :]) - q_table[state, action])
        
        state = new_state
        
        if done:
            break

Deep Learning con TensorFlow

El deep learning utiliza redes neuronales profundas para resolver problemas complejos:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, Flatten, MaxPooling2D

# Cargar los datos
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()

# Preprocesamiento
X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0

# Crear el modelo CNN
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# Compilar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Entrenar el modelo
model.fit(X_train, y_train, epochs=5, validation_data=(X_test, y_test))

# Evaluar el modelo
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Precisión en los datos de prueba: {test_acc:.4f}")

Procesamiento del lenguaje natural (NLP)

El NLP es un campo del ML que trabaja con el lenguaje humano:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

# Ejemplo de datos
X = ["J'adore ce film", "Ce film est terrible", "Un excellent film", "Je déteste ce film"]
y = [1, 0, 1, 0]  # 1 = positivo, 0 = negativo

# Crear un pipeline
text_clf = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('clf', MultinomialNB())
])

# Entrenar el modelo
text_clf.fit(X, y)

# Predecir el sentimiento
nouvelles_critiques = ["C'était un film incroyable", "Je n'ai pas aimé ce film"]
predictions = text_clf.predict(nouvelles_critiques)
print(predictions)  # [1, 0]

Visión por ordenador

La visión por ordenador permite a las máquinas «ver» e interpretar imágenes:

import cv2
import numpy as np
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions

# Cargar el modelo preentrenado
model = MobileNetV2(weights='imagenet')

# Cargar y preprocesar la imagen
image = cv2.imread('chat.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = cv2.resize(image, (224, 224))
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)

# Predecir la clase
predictions = model.predict(image)
results = decode_predictions(predictions, top=3)[0]

# Mostrar los resultados
for i, (imagenet_id, label, score) in enumerate(results):
    print(f"{i+1}: {label} ({score:.2f})")

Buenas prácticas en Machine Learning

Preprocesamiento de los datos

from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer

# Definir las transformaciones
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['education', 'marital_status']

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ])

# Crear el pipeline completo
model = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier())
])

# Utilizar el pipeline
model.fit(X_train, y_train)

Validación cruzada

from sklearn.model_selection import cross_val_score, KFold

# Definir la validación cruzada
cv = KFold(n_splits=5, shuffle=True, random_state=42)

# Evaluar el modelo
scores = cross_val_score(model, X, y, cv=cv, scoring='accuracy')
print(f"Precisión media: {scores.mean():.2f} (±{scores.std():.2f})")

Optimización de hiperparámetros

from sklearn.model_selection import GridSearchCV

# Definir los hiperparámetros que se van a probar
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, 10]
}

# Crear el modelo de búsqueda
grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)

# Encontrar los mejores hiperparámetros
grid_search.fit(X_train, y_train)
print(f"Mejores parámetros: {grid_search.best_params_}")
print(f"Mejor precisión: {grid_search.best_score_:.2f}")

Aplicaciones prácticas del Machine Learning

• Sistemas de recomendación: Netflix, Amazon, Spotify
• Reconocimiento de imágenes: detección de objetos, reconocimiento facial
• Procesamiento del lenguaje natural: chatbots, traducción automática
• Detección de fraudes: transacciones bancarias sospechosas
• Diagnóstico médico: detección de enfermedades en imágenes médicas
• Vehículos autónomos: percepción del entorno y toma de decisiones
• Predicción de series temporales: predicción de cotizaciones bursátiles, meteorología

Conclusión

El Machine Learning con Python ofrece posibilidades infinitas para resolver problemas complejos y crear aplicaciones inteligentes. Con las bibliotecas y técnicas adecuadas, puedes desarrollar modelos potentes que aprenden de los datos y mejoran con el tiempo.

Para ir más lejos, explora ámbitos específicos como el deep learning, el NLP o la visión por ordenador, y participa en competiciones en plataformas como Kaggle para poner a prueba tus habilidades.