Clasificador cuántico con PennyLane: tutorial de QML paso a paso

📅 Última actualización: once de abril de dos mil veintiséis

📑 Índice de contenidos

Qué es un clasificador cuántico y por qué PennyLane

Un clasificador cuántico es un modelo de machine learning cuántico que utiliza un circuito cuántico parametrizado como función de clasificación. Los datos de entrada se codifican en el estado cuántico de los qubits, el circuito los transforma mediante puertas cuánticas parametrizadas, y las mediciones producen la predicción de clase. Los parámetros se optimizan exactamente como en una red neuronal clásica: con gradiente descendente sobre una función de pérdida.

PennyLane es la biblioteca ideal para QML porque se diseñó desde cero para diferenciación automática cuántica. Se integra nativamente con PyTorch y TensorFlow, lo que permite combinar capas cuánticas y clásicas en el mismo modelo. Para profesionales de datos que ya dominan ML clásico, PennyLane es la transición más natural al QML.

Instalación y setup del entorno

# Instalar PennyLane
pip install pennylane pennylane-qiskit numpy scikit-learn

# Verificar instalacion
import pennylane as qml
print(f"PennyLane v{qml.version()}")
dev = qml.device("default.qubit", wires=2)
print("Simulador listo")

PennyLane incluye simuladores locales de alto rendimiento que permiten entrenar modelos QML sin acceso a hardware cuántico. El dispositivo default.qubit simula un procesador cuántico ideal sin ruido, perfecto para desarrollo y aprendizaje.

Preparar los datos: dataset Iris simplificado

from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
import numpy as np

# Cargar Iris (solo 2 clases, 2 features para 2 qubits)
iris = load_iris()
mask = iris.target < 2  # setosa vs versicolor
X = iris.data[mask, :2]  # sepal length, sepal width
y = iris.target[mask]

# Normalizar a [0, pi] para codificacion angular
scaler = MinMaxScaler(feature_range=(0, np.pi))
X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.3, random_state=42
)
print(f"Train: {len(X_train)}, Test: {len(X_test)}")

Usamos solo dos features y dos clases para que el circuito de dos qubits sea suficiente. La normalización a [0, pi] es crucial: las rotaciones cuánticas RY aceptan ángulos en este rango, y una buena codificación de datos determina en gran medida el rendimiento del clasificador.

Diseñar el circuito cuántico clasificador

import pennylane as qml
from pennylane import numpy as np

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def quantum_classifier(inputs, weights):
    # Codificacion de datos (angle embedding)
    qml.RY(inputs[0], wires=0)
    qml.RY(inputs[1], wires=1)
    
    # Capa variacional 1
    qml.RY(weights[0], wires=0)
    qml.RY(weights[1], wires=1)
    qml.CNOT(wires=[0, 1])
    
    # Capa variacional 2
    qml.RY(weights[2], wires=0)
    qml.RY(weights[3], wires=1)
    qml.CNOT(wires=[1, 0])
    
    # Medicion: expectacion de Z en qubit 0
    return qml.expval(qml.PauliZ(0))

El circuito tiene tres secciones. La codificación mapea los datos de entrada a rotaciones RY (codificación angular). Las capas variacionales transforman el estado con rotaciones parametrizadas y entrelazamiento CNOT. La medición extrae la predicción como valor esperado de Pauli-Z, un número entre menos uno y más uno que mapearemos a las dos clases.

Codificación de datos: del vector clásico al estado cuántico

La codificación angular (angle embedding) que usamos transforma cada feature en una rotación de qubit. Con dos features y dos qubits, el espacio de estados accesible es la esfera de Bloch bidimensional, que permite separar las dos clases de Iris si las rotaciones parametrizadas encuentran la orientación correcta.

Existen otras estrategias de codificación: amplitude embedding (codifica dos elevado a N features en N qubits), IQP embedding (rotaciones seguidas de entrelazamiento para más expresividad) y data reuploading (inyectar datos en múltiples capas). Cada estrategia tiene trade-offs entre expresividad, número de qubits y profundidad de circuito. Para datos con estructura cuántica natural, la elección de codificación puede determinar si el clasificador cuántico supera o no al clásico.

Entrenamiento con gradientes automáticos

# Inicializar pesos aleatorios
weights = np.random.uniform(0, 2*np.pi, 4, requires_grad=True)
opt = qml.GradientDescentOptimizer(stepsize=0.4)

def cost(weights, X, Y):
    predictions = [quantum_classifier(x, weights) for x in X]
    # MSE loss: mapear [-1,1] a [0,1] y comparar con etiqueta
    preds_01 = [(p + 1) / 2 for p in predictions]
    return np.mean([(p - y)**2 for p, y in zip(preds_01, Y)])

# Entrenamiento
for epoch in range(50):
    weights = opt.step(lambda w: cost(w, X_train, y_train), weights)
    if (epoch + 1) % 10 == 0:
        c = cost(weights, X_train, y_train)
        print(f"Epoch {epoch+1}: loss = {c:.4f}")

PennyLane calcula gradientes automáticamente usando el parameter-shift rule, una técnica exclusiva de circuitos cuánticos que obtiene gradientes exactos (no aproximados) evaluando el circuito con pequeñas perturbaciones de parámetros. Esto es equivalente a la diferenciación automática de PyTorch pero para circuitos cuánticos.

Evaluación y métricas del clasificador

def predict(weights, X):
    preds = [quantum_classifier(x, weights) for x in X]
    return [1 if p > 0 else 0 for p in preds]

# Evaluar en test set
y_pred = predict(weights, X_test)
accuracy = np.mean([p == t for p, t in zip(y_pred, y_test)])
print(f"Accuracy en test: {accuracy:.2%}")
# Resultado esperado: ~95-100% para Iris setosa vs versicolor

Para el dataset Iris simplificado (setosa vs versicolor con dos features), el clasificador cuántico de dos qubits alcanza fácilmente precisión superior al noventa y cinco por ciento. Este resultado es comparable a un clasificador clásico simple (SVM lineal o regresión logística) porque el problema es linealmente separable. La ventaja del QML se manifiesta en problemas más complejos con estructura cuántica.

Visualizar la frontera de decisión

Para entender qué ha aprendido el clasificador cuántico, podemos evaluar la predicción en una malla de puntos y visualizar la frontera de decisión. Esta frontera separa las regiones del espacio donde el modelo predice cada clase, revelando la geometría que el circuito cuántico ha aprendido de los datos.

Comparar con clasificador clásico equivalente

La comparación honesta muestra que para este problema simple, el clasificador clásico es igual o mejor y mil veces más rápido. Esto es esperado y no invalida el QML: los clasificadores cuánticos demuestran su potencial en problemas con muchas más features, relaciones no lineales complejas y especialmente datos con estructura cuántica natural como los que aparecen en simulación molecular o ciencia de materiales.

La lección clave es que el QML no reemplaza al ML clásico sino que lo complementa en nichos específicos. Para una perspectiva más amplia sobre el futuro de la IA cuántica, consulta nuestro roadmap de predicciones.

Próximos pasos y ejercicios avanzados

Para consolidar lo aprendido: primero, añade una tercera clase de Iris y un tercer qubit. Segundo, experimenta con diferentes codificaciones (IQP, amplitude). Tercero, incrementa el número de capas variacionales y observa el efecto en accuracy y tiempo de entrenamiento. Cuarto, añade ruido al simulador con qml.device("default.mixed") y cuantifica la degradación.

Para más tutoriales, consulta nuestras guías de Qiskit, Cirq y simuladores gratuitos.

Preguntas frecuentes