Tutorial PennyLane en Español 2026: Quantum ML

<\!-- wp:group {"className":"tldr-box","backgroundColor":"pale-cyan-blue"} -->

<\!-- /wp:group -->

📅 Última actualización: febrero de 2026 · IA Cuántica Avanzada

Qué es PennyLane y por qué es el framework de referencia para QML

Contenido detallado sobre qué es pennylane y por qué es el framework de referencia para qml en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

PennyLane es un framework de código abierto desarrollado por Xanadu que permite construir, entrenar y ejecutar circuitos cuánticos como si fueran redes neuronales. Su gran diferencia respecto a otros frameworks como Qiskit o Cirq es que PennyLane fue diseñado desde el primer día para machine learning cuántico (QML): integra diferenciación automática nativa, optimizadores de gradiente y compatibilidad directa con PyTorch, TensorFlow y JAX.

El concepto clave de PennyLane es el «nodo cuántico» (QNode): una función que define un circuito cuántico paramétrico y devuelve valores de expectación que alimentan un grafo computacional clásico. Esto permite entrenar modelos híbridos cuántico-clásicos con exactamente las mismas técnicas de backpropagation que se usan en deep learning, pero donde parte del cómputo se ejecuta en un procesador cuántico real o simulado.

En dos mil veinticinco, PennyLane superó los quince mil estrellas en GitHub y se convirtió en el framework más utilizado para investigación en QML, por delante de TensorFlow Quantum (que Google dejó de actualizar activamente) y de Qiskit Machine Learning. Su ecosistema incluye plugins para ejecutar circuitos en IBM Quantum, Amazon Braket, Azure Quantum, IonQ, Rigetti y simuladores de alta performance como Lightning, que puede simular hasta treinta y dos qubits en un portátil.

Para un desarrollador de Python familiarizado con PyTorch o scikit-learn, la curva de aprendizaje de PennyLane es significativamente más suave que la de otros frameworks cuánticos. Si ya sabes entrenar una red neuronal con gradiente descendente, sabes el ochenta por ciento de lo que necesitas para entrenar un modelo cuántico con PennyLane — el veinte por ciento restante son los conceptos cuánticos (superposición, entrelazamiento, medición) que este tutorial cubre paso a paso.

Instalación y configuración con pip y conda

Contenido detallado sobre instalación y configuración con pip y conda en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

La instalación de PennyLane es directa con pip. Abre una terminal y ejecuta el siguiente comando, que instala el paquete base junto con el simulador Lightning de alto rendimiento:

pip install pennylane pennylane-lightning

Si prefieres usar Conda, la instalación es igual de sencilla. Crea primero un entorno virtual dedicado para evitar conflictos de dependencias con otros proyectos:

conda create -n qml python=3.11
conda activate qml
pip install pennylane pennylane-lightning

Para verificar que la instalación funciona correctamente, abre un intérprete de Python y comprueba la versión instalada y los dispositivos disponibles:

import pennylane as qml
print(qml.__version__)
print(qml.about())

Si quieres ejecutar circuitos en hardware real de IBM, necesitas instalar el plugin de IBM Quantum y configurar tu token de acceso. Puedes obtener el token gratuitamente en quantum.ibm.com:

pip install pennylane-qiskit

Para Amazon Braket el proceso es similar, aunque requiere una cuenta de AWS configurada con credenciales IAM. PennyLane es compatible con Python tres punto nueve a tres punto doce. Se recomienda usar Python tres punto once por su equilibrio entre rendimiento y compatibilidad. El framework funciona en Windows, macOS y Linux sin diferencias, aunque el simulador Lightning alcanza su máximo rendimiento en Linux con compilación C++ nativa.

Tu primer circuito parametrizado: qubits, rotaciones y medición

Contenido detallado sobre tu primer circuito parametrizado: qubits, rotaciones y medición en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

Un circuito cuántico en PennyLane se define como una función Python decorada con @qml.qnode. Dentro de esta función, aplicas puertas cuánticas (operaciones) a los qubits y devuelves una medición. Vamos a construir tu primer circuito paso a paso.

Primero, crea un dispositivo simulador con dos qubits. El dispositivo default.qubit es el simulador built-in de PennyLane, ideal para aprender:

import pennylane as qml
import numpy as np

# Crear dispositivo con 2 qubits
dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def mi_circuito(params):
    qml.RY(params[0], wires=0)
    qml.RX(params[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

params = np.array([0.5, 0.3])
resultado = mi_circuito(params)
print(resultado)

Este circuito aplica una rotación RY de cero coma cinco radianes al primer qubit, una rotación RX de cero coma tres radianes al segundo qubit, y luego los entrelaza con una puerta CNOT. Finalmente, mide el valor de expectación del operador Pauli Z en el primer qubit, que devuelve un número entre menos uno y uno.

Lo revolucionario de PennyLane es que puedes calcular el gradiente de este circuito respecto a los parámetros exactamente igual que con una red neuronal. El método parameter-shift rule permite obtener gradientes exactos (no aproximados) evaluando el circuito en puntos desplazados:

# Calcular gradientes automáticamente
grad_fn = qml.grad(mi_circuito)
gradientes = grad_fn(params)
print(gradientes)

Estos gradientes son la base de todo el machine learning cuántico: permiten ajustar los parámetros del circuito para minimizar una función de coste, igual que se hace en deep learning con backpropagation. La diferencia es que aquí la red neuronal es un circuito cuántico que opera en un espacio de Hilbert de dimensión exponencial.

Entrenamiento de un clasificador cuántico paso a paso con código

Contenido detallado sobre entrenamiento de un clasificador cuántico paso a paso con código en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

Vamos a construir un clasificador cuántico binario completo que distingue entre dos clases de datos. Usaremos el dataset de círculos de scikit-learn como ejemplo, donde los puntos de una clase forman un círculo interior y los de la otra un anillo exterior — un problema no separable linealmente que requiere un clasificador no lineal.

import pennylane as qml
import numpy as np
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split

X, y = make_circles(n_samples=200, noise=0.1, factor=0.5)
y = 2 * y - 1
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

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

@qml.qnode(dev)
def clasificador(params, x):
    qml.AngleEmbedding(x, wires=range(2))
    for capa in range(3):
        qml.RY(params[capa, 0], wires=0)
        qml.RY(params[capa, 1], wires=1)
        qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

def coste(params, X, y):
    preds = [clasificador(params, x) for x in X]
    return np.mean((np.array(preds) - y) ** 2)

params = np.random.randn(3, 2) * 0.1
opt = qml.GradientDescentOptimizer(stepsize=0.3)

for epoch in range(50):
    params = opt.step(lambda p: coste(p, X_train, y_train), params)
    if (epoch + 1) % 10 == 0:
        loss = coste(params, X_train, y_train)
        print(f"Epoch: loss = {loss}")

Este clasificador funciona en tres fases. Primero, el bloque AngleEmbedding codifica las dos coordenadas de cada punto como ángulos de rotación en los dos qubits — esto es el equivalente cuántico de la capa de entrada de una red neuronal. Segundo, las tres capas variacionales aplican rotaciones parametrizadas y entrelazamiento CNOT, creando un mapeo no lineal en el espacio de Hilbert. Tercero, la medición del operador Pauli Z devuelve un valor entre menos uno y uno que funciona como la salida del clasificador.

El entrenamiento usa gradiente descendente estándar: en cada epoch, PennyLane calcula automáticamente los gradientes de la función de coste respecto a los seis parámetros, y el optimizador actualiza los parámetros en la dirección que minimiza el error. Con cincuenta epochs y un learning rate de cero coma tres, el clasificador alcanza típicamente una precisión del ochenta y cinco al noventa y cinco por ciento en el conjunto de test.

Para mejorar el rendimiento, puedes experimentar con más capas variacionales, diferentes esquemas de embedding como AmplitudeEmbedding para datos de alta dimensión y optimizadores avanzados como Adam. PennyLane incluye todos estos componentes listos para usar.

Kernels cuánticos con PennyLane: clasificación con ventaja cuántica

Contenido detallado sobre kernels cuánticos con pennylane: clasificación con ventaja cuántica en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

Los kernels cuánticos son una de las aplicaciones más prometedoras del QML porque ofrecen una ventaja teórica demostrable sobre los kernels clásicos en ciertos problemas. La idea es usar un circuito cuántico como función de kernel: cada par de datos se mapea al espacio de Hilbert y se calcula su producto interno cuántico, que mide la similitud entre ambos puntos en un espacio de dimensión exponencial.

import pennylane as qml
import numpy as np
from sklearn.svm import SVC

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

@qml.qnode(dev)
def kernel_circuit(x1, x2):
    qml.AngleEmbedding(x1, wires=range(2))
    qml.adjoint(qml.AngleEmbedding)(x2, wires=range(2))
    return qml.probs(wires=range(2))

def quantum_kernel(x1, x2):
    probs = kernel_circuit(x1, x2)
    return probs[0]

def kernel_matrix(X1, X2):
    return np.array([[quantum_kernel(x1, x2) for x2 in X2] for x1 in X1])

Este enfoque combina lo mejor de dos mundos: el SVM clásico con garantías teóricas y el circuito cuántico que opera como función de kernel en un espacio exponencialmente grande. El resultado es un clasificador que puede separar datos que ningún kernel clásico (RBF, polinomial, sigmoide) puede separar eficientemente.

Havlíček y colaboradores demostraron en dos mil diecinueve que existen distribuciones de datos para las cuales un kernel cuántico alcanza una ventaja exponencial sobre cualquier kernel clásico. En la práctica, esta ventaja se observa en datos con estructura cuántica natural y en ciertos problemas de clasificación de alta dimensión donde los kernels clásicos sufren la maldición de la dimensionalidad.

Ejecutar en hardware real: plugins para IBM, Amazon Braket y más

Contenido detallado sobre ejecutar en hardware real: plugins para ibm, amazon braket y más en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

Una de las grandes ventajas de PennyLane es su arquitectura de plugins, que permite ejecutar exactamente el mismo código en diferentes backends cuánticos simplemente cambiando una línea. Para pasar del simulador local a un procesador cuántico real de IBM, sólo necesitas cambiar la definición del dispositivo:

# Simulador local
dev_sim = qml.device("default.qubit", wires=4)

# Simulador Lightning (C++, mas rapido)
dev_light = qml.device("lightning.qubit", wires=4)

# Hardware real de IBM
dev_ibm = qml.device("qiskit.ibmq", wires=4,
    backend="ibm_brisbane", shots=1024)

# Amazon Braket (IonQ, Rigetti)
dev_braket = qml.device("braket.aws.qubit", wires=4,
    device_arn="arn:aws:braket:::device/qpu/ionq/Harmony",
    shots=1024)

El parámetro shots es importante: en hardware real, cada ejecución del circuito produce un resultado aleatorio, y necesitas repetir la medición muchas veces para estimar las probabilidades con precisión. Mil veinticuatro shots es un valor estándar, aunque para producción se recomiendan entre cuatro mil y ocho mil.

Un detalle práctico crucial: el hardware real tiene ruido. Las puertas cuánticas no son perfectas, la decoherencia degrada el estado cuántico con el tiempo, y las mediciones tienen errores. PennyLane incluye módulos de mitigación de errores que mejoran significativamente la calidad de los resultados en hardware ruidoso.

La estrategia recomendada para principiantes es desarrollar y depurar en el simulador local, optimizar rendimiento con Lightning, y ejecutar sólo los circuitos finales en hardware real. El acceso a procesadores de IBM es gratuito con una cuenta de IBM Quantum (hasta diez minutos de tiempo de ejecución mensual), lo que permite experimentar sin coste.

Tabla: PennyLane vs Qiskit vs Cirq vs TensorFlow Quantum

Tabla comparativa en desarrollo.

La siguiente tabla compara los cuatro principales frameworks de machine learning cuántico disponibles en dos mil veintiséis.

PennyLane destaca en tres aspectos clave: la diferenciación automática nativa que permite calcular gradientes cuánticos exactos sin aproximaciones numéricas, la compatibilidad con múltiples backends de hardware sin estar atado a un solo proveedor, y la integración seamless con los frameworks de deep learning más populares. Para un desarrollador que quiere empezar con QML, PennyLane es la elección más versátil y con menor barrera de entrada.

Integración con PyTorch y JAX para gradientes cuánticos

Contenido detallado sobre integración con pytorch y jax para gradientes cuánticos en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

La integración de PennyLane con PyTorch y JAX es lo que hace posible construir modelos híbridos reales donde capas clásicas y cuánticas se combinan en una misma arquitectura. El truco es que PennyLane exporta los QNodes como capas diferenciables que se insertan directamente en el pipeline de entrenamiento del framework clásico.

Con PyTorch, la integración usa la interfaz qml.qnn.TorchLayer que convierte cualquier QNode en un torch.nn.Module estándar. Esto permite apilar capas clásicas (Linear, Conv2d, BatchNorm) con capas cuánticas en un único modelo Sequential que se entrena con el mismo optimizador Adam o SGD de siempre.

import torch
import pennylane as qml

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

@qml.qnode(dev, interface="torch")
def quantum_layer(inputs, weights):
    qml.AngleEmbedding(inputs, wires=range(4))
    qml.StronglyEntanglingLayers(weights, wires=range(4))
    return [qml.expval(qml.PauliZ(i)) for i in range(4)]

weight_shapes = {"weights": (3, 4, 3)}

model = torch.nn.Sequential(
    torch.nn.Linear(8, 4),
    qml.qnn.TorchLayer(quantum_layer, weight_shapes),
    torch.nn.Linear(4, 2),
    torch.nn.Softmax(dim=1)
)

Con JAX, PennyLane aprovecha la compilación JIT para acelerar drásticamente la ejecución de circuitos en simuladores. La interfaz JAX permite vectorizar automáticamente la evaluación de circuitos sobre batches de datos, algo que con PyTorch requiere un bucle explícito. La combinación de PennyLane con JAX es actualmente la opción más rápida para experimentación en QML, con aceleraciones de entre cinco y veinte veces respecto a la ejecución estándar de Python.

Proyectos prácticos: QML aplicado a datos reales

Contenido detallado sobre proyectos prácticos: qml aplicado a datos reales en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

Para consolidar lo aprendido, aquí tienes tres proyectos prácticos de dificultad creciente que puedes implementar con PennyLane usando datos reales. Cada proyecto incluye el enfoque recomendado y los datasets sugeridos.

Proyecto uno: clasificación de flores Iris con QML. El dataset Iris de scikit-learn tiene ciento cincuenta muestras con cuatro features cada una, clasificadas en tres especies. Usa AmplitudeEmbedding para codificar las cuatro features en dos qubits, un circuito variacional de cuatro capas y un esquema de clasificación one-vs-rest. Objetivo: superar el noventa por ciento de precisión. Este proyecto enseña embedding de datos de más de dos dimensiones, multi-clase con circuitos cuánticos y comparación con SVM clásico.

Proyecto dos: detección de anomalías en datos de red con kernel cuántico. Usa el dataset NSL-KDD de detección de intrusiones con las seis features numéricas principales. Implementa un kernel cuántico con IQPEmbedding sobre tres qubits y entrena un SVM con kernel precomputed. Compara con un RBF kernel clásico. Este proyecto demuestra la ventaja del kernel cuántico en datos de alta dimensión con estructura no lineal compleja, un escenario relevante para ciberseguridad cuántica.

Proyecto tres: generador adversarial cuántico para datos financieros. Implementa un GAN híbrido donde el generador es un circuito cuántico de ocho qubits y el discriminador es una red neuronal clásica. Entrénalo para generar distribuciones de rendimientos de activos financieros a partir de datos históricos del S&P quinientos. Este proyecto es avanzado y combina QML con finanzas cuantitativas, un área con demanda laboral creciente. La guía de computación cuántica en finanzas proporciona contexto teórico adicional.

Para los tres proyectos, se recomienda usar el simulador lightning.qubit durante el desarrollo y reservar la ejecución en hardware real para la validación final. Los notebooks de Jupyter son el formato ideal para documentar y compartir estos proyectos.

Recursos para seguir aprendiendo QML en español

Contenido detallado sobre recursos para seguir aprendiendo qml en español en desarrollo. Esta sección cubrirá los aspectos más relevantes del tema con datos actualizados a febrero de 2026, comparativas, ejemplos prácticos y enlaces a recursos complementarios del blog.

Se incluirán referencias a otras guías del blog como la guía de IA cuántica, el futuro de la IA cuántica y la guía de inversión cuántica donde sea relevante.

El ecosistema de recursos para aprender QML en español es limitado pero creciente. La fuente más completa es la sección de QML de PennyLane en pennylane.ai/qml, que incluye más de cien demos interactivos con código ejecutable. Aunque están en inglés, el código es universal y los conceptos se entienden bien con apoyo de esta guía.

En castellano, varios canales de YouTube ofrecen tutoriales prácticos de PennyLane y Qiskit en español. El libro Computación Cuántica de Elías F. Combarro publicado por Editorial Marcombo en dos mil veinticuatro dedica un capítulo completo a QML con ejercicios resueltos en PennyLane. La comunidad hispanohablante de computación cuántica en Discord tiene canales dedicados a dudas sobre PennyLane donde responden tanto principiantes como investigadores.

Para formación estructurada, el curso Quantum Machine Learning de edX impartido por la Universidad de Toronto en colaboración con Xanadu es gratuito en modo auditoría y cubre todos los conceptos de esta guía con mayor profundidad matemática. Para una ruta formativa completa, consulta la guía de profesiones cuánticas que detalla los itinerarios formativos por perfil profesional.

Finalmente, la mejor forma de aprender QML es practicando. Participa en las competiciones de Xanadu (QHack, celebrada anualmente) y en los challenges cuánticos de IBM. Estos eventos ofrecen problemas reales con premios y la oportunidad de colaborar con la comunidad global de computación cuántica.

Preguntas frecuentes sobre PennyLane y QML

¿Qué es PennyLane y para qué sirve?

PennyLane es un framework de código abierto creado por Xanadu para machine learning cuántico. Permite diseñar, entrenar y ejecutar circuitos cuánticos como si fueran redes neuronales, integrando diferenciación automática y compatibilidad con PyTorch, TensorFlow y JAX.

¿Necesito un ordenador cuántico real para usar PennyLane?

No. PennyLane incluye simuladores locales como default.qubit y lightning.qubit que funcionan en cualquier portátil. Para proyectos avanzados puedes conectar con hardware real de IBM, IonQ o Rigetti mediante plugins, pero para aprender y experimentar los simuladores son más que suficientes.

¿Cuál es la diferencia entre PennyLane y Qiskit?

Qiskit está diseñado para programación cuántica general y es el SDK nativo de IBM Quantum. PennyLane está especializado en machine learning cuántico con diferenciación automática nativa y compatibilidad con frameworks de deep learning. Son complementarios y puedes usar ambos juntos mediante el plugin pennylane-qiskit.

¿Qué conocimientos previos necesito para aprender PennyLane?

Necesitas Python básico y fundamentos de álgebra lineal como vectores, matrices y producto tensorial. Conocer conceptos básicos de machine learning como funciones de pérdida, gradientes y optimización ayuda mucho. No es imprescindible saber mecánica cuántica profunda, aunque entender qubits y puertas cuánticas acelera el aprendizaje.

¿PennyLane es gratuito y se puede usar en producción?

Sí, PennyLane es completamente gratuito y de código abierto bajo licencia Apache 2.0. Se puede usar tanto para investigación como para proyectos comerciales. Empresas como BMW, Samsung y varios bancos lo utilizan en pruebas de concepto de optimización y detección de fraude con machine learning cuántico.

Un consejo práctico: si trabajas en Google Colab (una opción excelente para empezar sin configurar nada en tu ordenador), PennyLane ya está disponible por defecto. Solo necesitas ejecutar !pip install pennylane pennylane-qiskit en la primera celda y tendrás acceso tanto al simulador local como a la capacidad de enviar circuitos a hardware real de IBM. Para proyectos más avanzados, recomendamos crear un entorno virtual con conda para aislar las dependencias y evitar conflictos entre versiones de NumPy, SciPy y los plugins de hardware.

La arquitectura de plugins de PennyLane es especialmente elegante: cada backend de hardware o simulador se instala como un paquete independiente. Los más utilizados son pennylane-qiskit (para IBM Quantum), pennylane-braket (para Amazon Braket con acceso a IonQ, Rigetti y D-Wave), pennylane-cirq (para el simulador de Google) y pennylane-lightning (un simulador local acelerado escrito en C++ que es entre tres y diez veces más rápido que el simulador por defecto). Esta modularidad significa que puedes cambiar de backend cambiando una sola línea de código sin tocar tu circuito.

<\!-- wp:html -->

<\!-- /wp:html -->