Redes Neuronales Cuánticas

¿Qué es la computación cuántica?

La computación cuántica es un paradigma de computación que aprovecha fenómenos de la mecánica cuántica — superposición, entrelazamiento e interferencia — para procesar información de formas fundamentalmente imposibles para un ordenador clásico.

¿Qué son las Redes Neuronales Cuánticas?

Una Red Neuronal Cuántica (QNN) es un modelo de aprendizaje automático que se ejecuta (total o parcialmente) en un procesador cuántico. Utiliza circuitos cuánticos parametrizados como el equivalente cuántico de las capas de una red neuronal clásica.

Schuld, M. & Petruccione, F. (2021). "Machine Learning with Quantum Computers". Springer.

Computación clásica vs cuántica

Historia de las redes neuronales cuánticas

Esta evolución muestra cómo la computación cuántica ha pasado de una idea teórica (1982) a un campo experimental con hardware real y frameworks maduros. Las QNNs nacen de la convergencia entre los avances en hardware cuántico y las ideas del machine learning variacional, y representan uno de los campos más activos de la investigación actual en inteligencia artificial.

¿Para qué sirven las QNNs?

Las redes neuronales cuánticas no pretenden reemplazar a las redes clásicas en todas las tareas. Su potencial está en problemas donde la estructura cuántica del espacio de Hilbert ofrece ventaja expresiva o computacional.

Taxonomía de enfoques de QML

El qubit: la unidad fundamental

Un qubit (quantum bit) es la unidad básica de información cuántica. A diferencia del bit clásico (0 o 1), un qubit puede existir en una superposición de ambos estados:

Donde \(\alpha, \beta \in \mathbb{C}\) son amplitudes de probabilidad que satisfacen la normalización:

La esfera de Bloch

Todo estado de un qubit puede representarse como un punto en la esfera de Bloch, una esfera unitaria en 3D:

Estados especiales en la esfera de Bloch

Los estados más importantes en computación cuántica tienen posiciones características en la esfera de Bloch. Entenderlos es esencial para diseñar circuitos cuánticos:

Puertas cuánticas

Las puertas cuánticas son operaciones unitarias que transforman el estado de los qubits. Son el equivalente de las puertas lógicas clásicas, pero siempre reversibles (toda puerta \(U\) tiene inversa \(U^\dagger\)).

Puertas de un qubit

Puertas de dos qubits

Ejemplo de circuito cuántico

Un circuito cuántico se lee de izquierda a derecha. Cada línea horizontal representa un qubit, y las cajas sobre las líneas son puertas cuánticas. Este circuito de ejemplo combina una puerta Hadamard (crea superposición), rotaciones parametrizadas (los "pesos" entrenables de la QNN) y puertas CNOT (crean entrelazamiento entre qubits):

Superposición en detalle

La superposición permite a un qubit estar en una combinación lineal de \(|0\rangle\) y \(|1\rangle\). Para \(n\) qubits, el estado general es:

Entrelazamiento cuántico

El entrelazamiento es el fenómeno más "extraño" de la mecánica cuántica y el recurso más poderoso de la computación cuántica. Dos qubits están entrelazados cuando su estado no puede describirse como el producto de estados individuales.

Medición cuántica

La medición es el proceso por el cual extraemos información clásica de un estado cuántico. Es fundamentalmente probabilístico e irreversible.

¿Cómo se fabrican los qubits?

Notación de Dirac (bra-ket)

La notación de Dirac es el lenguaje estándar de la mecánica cuántica. Es compacta y elegante para expresar estados, operadores y productos internos.

Espacios de Hilbert

Los estados cuánticos viven en un espacio de Hilbert \(\mathcal{H}\): un espacio vectorial complejo con producto interno, completo bajo la norma inducida.

Transformaciones unitarias

Toda evolución cuántica (excepto la medición) es una transformación unitaria: una operación que preserva la norma del estado.

Producto tensorial

El producto tensorial \(\otimes\) combina los espacios de Hilbert de qubits individuales en el espacio del sistema completo.

Matrices de densidad

La matriz de densidad \(\rho\) es una representación más general del estado cuántico que permite describir estados mixtos (mezclas estadísticas de estados puros, como los que resultan del ruido).

Operadores de Pauli

Los operadores de Pauli son la base de las operaciones cuánticas y las mediciones. Toda puerta de un qubit puede descomponerse en Paulis.

Parameter-shift rule: gradientes en QNNs

En redes clásicas usamos backpropagation para calcular gradientes. En QNNs, no podemos hacer backprop porque el estado cuántico no es directamente accesible. En su lugar, usamos la parameter-shift rule:

Circuitos cuánticos parametrizados (PQC)

Un Parameterized Quantum Circuit (PQC) o Variational Quantum Circuit (VQC) es un circuito cuántico cuyos ángulos de rotación son parámetros entrenables, ajustados por un optimizador clásico. Es el corazón de toda QNN.

El paradigma variacional cuántico sigue el mismo esquema conceptual que el entrenamiento de redes neuronales clásicas: se define una función de pérdida, se calculan gradientes respecto a los parámetros, y se actualizan iterativamente. La diferencia crucial es que el forward pass ocurre en un procesador cuántico (o simulador), mientras que la optimización se ejecuta clásicamente. Este bucle híbrido es lo que hace a los VQC compatibles con el hardware NISQ actual: los circuitos pueden ser cortos (resistentes al ruido) mientras que la parte clásica se encarga de la convergencia.

💡 Para comparar con el flujo clásico de entrenamiento (forward + backward + update), consulta Perceptrón y MLP. El análogo cuántico del descenso de gradiente es la parameter-shift rule, detallada en la sección anterior.

Feature maps: codificación de datos clásicos

El feature map (o encoding) transforma datos clásicos \(x \in \mathbb{R}^n\) en estados cuánticos \(|\phi(x)\rangle\). La elección del encoding es crucial y afecta directamente a la expresividad del modelo.

Diseño del ansatz

El ansatz es la arquitectura del circuito variacional: la secuencia de puertas parametrizadas y entrelazamiento que forma las "capas" de la QNN. Es el equivalente cuántico de elegir la arquitectura de una red neuronal.

Barren plateaus: el gran desafío

Los barren plateaus son el mayor problema teórico de las QNNs. Son regiones del paisaje de pérdida donde los gradientes se desvanecen exponencialmente con el número de qubits — análogo al vanishing gradient en redes clásicas profundas, pero mucho peor.

Expresividad y ventaja cuántica

La expresividad de un circuito cuántico mide qué fracción del espacio de estados unitarios puede alcanzar al variar sus parámetros. La ventaja cuántica en ML se refiere a si una QNN puede resolver un problema más eficientemente que cualquier modelo clásico.

Funciones de coste en VQC

La función de coste de una QNN combina la salida cuántica (valores esperados) con métricas de pérdida clásicas.

Modelos híbridos clásico-cuánticos

En la era NISQ, los modelos prácticos son híbridos: combinan capas clásicas (redes neuronales) con capas cuánticas (circuitos parametrizados). El procesamiento pesado lo hace la parte clásica; la parte cuántica aporta expresividad en espacios de alta dimensión.

QCNN — Quantum Convolutional Neural Network

La QCNN (Cong et al., 2019) adapta la estructura de las CNN clásicas al dominio cuántico. Usa capas convolucionales cuánticas (puertas de 2 qubits locales) seguidas de pooling cuántico (medir y descartar qubits).

La analogía con las CNN clásicas es profunda: en una CNN, los filtros convolucionales comparten pesos y se aplican localmente, capturando patrones espaciales jerárquicos. En una QCNN, las puertas de 2 qubits hacen lo mismo: comparten parámetros (weight sharing) y actúan localmente. El pooling cuántico reduce la dimensión midiendo la mitad de los qubits, análogo al max-pooling. Para una revisión de las CNN clásicas que inspiran esta arquitectura, ver el submódulo de Redes Convolucionales.

Quantum Transfer Learning

Quantum Transfer Learning (Mari et al., 2020) combina un modelo clásico pre-entrenado con una capa cuántica de fine-tuning:

Mari, A. et al. (2020). "Transfer learning in hybrid classical-quantum neural networks". Quantum 4, 340.

Implementación: QNN con PennyLane + PyTorch

PennyLane (Xanadu) es el framework más popular para QML. Se integra nativamente con PyTorch y TensorFlow, permitiendo crear modelos híbridos end-to-end differentiable.

import pennylane as qml
import torch
import torch.nn as nn
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler

# ─── 1. Configurar dispositivo cuántico ───
n_qubits = 4
n_layers = 3
dev = qml.device("default.qubit", wires=n_qubits)

# ─── 2. Definir el circuito cuántico ───
@qml.qnode(dev, interface="torch", diff_method="parameter-shift")
def quantum_circuit(inputs, weights):
    """Circuito cuántico parametrizado con data re-uploading."""
    for layer in range(n_layers):
        # Encoding: codificar datos en rotaciones
        for i in range(n_qubits):
            qml.RY(inputs[i], wires=i)

        # Ansatz: rotaciones parametrizadas
        for i in range(n_qubits):
            qml.RY(weights[layer, i, 0], wires=i)
            qml.RZ(weights[layer, i, 1], wires=i)

        # Entrelazamiento: CNOT en cadena
        for i in range(n_qubits - 1):
            qml.CNOT(wires=[i, i + 1])
        qml.CNOT(wires=[n_qubits - 1, 0])  # Circular

    # Medición: valor esperado de Pauli-Z en qubit 0
    return qml.expval(qml.PauliZ(0))

# ─── 3. Modelo híbrido PyTorch ───
class HybridQNN(nn.Module):
    def __init__(self):
        super().__init__()
        # Pesos cuánticos: (n_layers, n_qubits, 2 rotaciones)
        weight_shapes = {"weights": (n_layers, n_qubits, 2)}
        self.q_layer = qml.qnn.TorchLayer(quantum_circuit, weight_shapes)

        # Post-procesamiento clásico
        self.classical = nn.Sequential(
            nn.Linear(1, 2),  # 1 valor esperado → 2 clases
            nn.Softmax(dim=-1)
        )

    def forward(self, x):
        # x: (batch_size, 4)
        q_out = self.q_layer(x).unsqueeze(-1)  # (batch, 1)
        return self.classical(q_out)

# ─── 4. Datos: Iris (solo 2 clases) ───
iris = load_iris()
X = iris.data[iris.target < 2]  # Solo clases 0 y 1
y = iris.target[iris.target < 2]

scaler = MinMaxScaler(feature_range=(0, np.pi))
X = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
X_train = torch.FloatTensor(X_train)
y_train = torch.LongTensor(y_train)
X_test = torch.FloatTensor(X_test)
y_test = torch.LongTensor(y_test)

# ─── 5. Entrenamiento ───
model = HybridQNN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(50):
    optimizer.zero_grad()
    y_pred = model(X_train)
    loss = loss_fn(y_pred, y_train)
    loss.backward()  # Backprop clásico + parameter-shift cuántico
    optimizer.step()

    if (epoch + 1) % 10 == 0:
        acc = (y_pred.argmax(dim=1) == y_train).float().mean()
        print(f"Epoch {epoch+1}: loss={loss.item():.4f}, acc={acc:.3f}")

# ─── 6. Evaluación ───
with torch.no_grad():
    y_pred_test = model(X_test)
    test_acc = (y_pred_test.argmax(dim=1) == y_test).float().mean()
    print(f"\nTest accuracy: {test_acc:.3f}")

import tensorflow as tf
import tensorflow_quantum as tfq
import cirq
import sympy
import numpy as np
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler

# ─── 1. Definir qubits ───
n_qubits = 4
qubits = cirq.GridQubit.rect(1, n_qubits)

# ─── 2. Crear circuito parametrizado ───
def create_qnn_circuit(n_layers=3):
    """Crear circuito VQC con Cirq."""
    params = sympy.symbols(f'theta0:{n_layers * n_qubits * 2}')
    circuit = cirq.Circuit()
    idx = 0

    for layer in range(n_layers):
        # Rotaciones parametrizadas
        for i, qubit in enumerate(qubits):
            circuit.append(cirq.ry(params[idx]).on(qubit))
            idx += 1
            circuit.append(cirq.rz(params[idx]).on(qubit))
            idx += 1

        # Entrelazamiento CNOT en cadena
        for i in range(n_qubits - 1):
            circuit.append(cirq.CNOT(qubits[i], qubits[i + 1]))

    return circuit, list(params)

# ─── 3. Encoding de datos en circuito ───
def encode_data(X):
    """Codificar datos clásicos en circuitos cuánticos."""
    circuits = []
    for x in X:
        circuit = cirq.Circuit()
        for i, qubit in enumerate(qubits):
            circuit.append(cirq.ry(float(x[i])).on(qubit))
        circuits.append(circuit)
    return tfq.convert_to_tensor(circuits)

# ─── 4. Construir modelo ───
vqc, params = create_qnn_circuit(n_layers=3)
readout_op = cirq.Z(qubits[0])  # Medir qubit 0

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(), dtype=tf.string),
    tfq.layers.PQC(vqc, readout_op),
    tf.keras.layers.Dense(2, activation='softmax')
])

model.compile(
    optimizer=tf.keras.optimizers.Adam(0.01),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# ─── 5. Datos ───
iris = load_iris()
X = iris.data[iris.target < 2]
y = iris.target[iris.target < 2]

scaler = MinMaxScaler(feature_range=(0, np.pi))
X_scaled = scaler.fit_transform(X)
X_circuits = encode_data(X_scaled)

# ─── 6. Entrenamiento ───
model.fit(X_circuits, y, epochs=50, batch_size=16, validation_split=0.3)

Quantum Kernels

Los quantum kernels son una alternativa a los VQC que no usa parámetros entrenables en el circuito. En su lugar, usan el circuito como un feature map para calcular un kernel en el espacio de Hilbert.

Si estás familiarizado con las SVM clásicas (Support Vector Machines), el concepto es idéntico: en lugar de proyectar los datos a un espacio de alta dimensión con un kernel RBF o polinomial, se proyectan al espacio de Hilbert de \(2^n\) dimensiones mediante un circuito cuántico. El producto interno en ese espacio es el kernel cuántico. La ventaja potencial es que este espacio de features es exponencialmente grande, y se calcula de forma natural en el hardware cuántico. Para más contexto sobre kernels clásicos, ver el submódulo de Machine Learning clásico.

Havlíček, V. et al. (2019). "Supervised learning with quantum-enhanced feature spaces". Nature 567, 209.

Entrenamiento con ruido (noise-aware)

Los procesadores cuánticos reales son ruidosos. Las QNNs deben ser robustas al ruido o el rendimiento se degrada significativamente.

Frameworks de Quantum Machine Learning

El ecosistema de QML ha madurado significativamente desde 2020. Hoy existen múltiples frameworks de código abierto que permiten diseñar, simular y ejecutar circuitos cuánticos parametrizados con la misma facilidad que se construye una red neuronal con PyTorch o TensorFlow. La mayoría se integra nativamente con los frameworks de deep learning clásico, permitiendo entrenar modelos híbridos end-to-end de manera diferenciable.

Hardware cuántico: estado del arte

Aplicaciones reales y experimentos

QNN vs Red neuronal clásica: resumen

Retos abiertos y futuro

A pesar del enorme progreso teórico y experimental, las redes neuronales cuánticas enfrentan desafíos fundamentales que deben resolverse antes de que el QML sea prácticamente útil para problemas del mundo real. Estos retos no son meramente técnicos: algunos son limitaciones teóricas profundas (como los barren plateaus) que requieren nuevos paradigmas algorítmicos.

Papers y recursos fundamentales