Pennylane

PennyLane

Visão Geral

PennyLane é uma biblioteca de computação quântica que permite treinar computadores quânticos como redes neurais. Ela fornece diferenciação automática de circuitos quânticos, programação independente de dispositivo e integração perfeita com frameworks clássicos de aprendizado de máquina.

Instalação

Instale usando uv:

uv pip install pennylane

Para acesso a hardware quântico, instale plugins de dispositivos:

# IBM Quantum
uv pip install pennylane-qiskit

# Amazon Braket
uv pip install amazon-braket-pennylane-plugin

# Google Cirq
uv pip install pennylane-cirq

# Rigetti Forest
uv pip install pennylane-rigetti

# IonQ
uv pip install pennylane-ionq

Início Rápido

Construa um circuito quântico e otimize seus parâmetros:

import pennylane as qml
from pennylane import numpy as np

# Criar dispositivo
dev = qml.device('default.qubit', wires=2)

# Definir circuito quântico
@qml.qnode(dev)
def circuit(params):
    qml.RX(params[0], wires=0)
    qml.RY(params[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Otimizar parâmetros
opt = qml.GradientDescentOptimizer(stepsize=0.1)
params = np.array([0.1, 0.2], requires_grad=True)

for i in range(100):
    params = opt.step(circuit, params)

Capacidades Principais

1. Construção de Circuitos Quânticos

Construa circuitos com portas, medições e preparação de estado. Consulte references/quantum_circuits.md para:

• Portas de um e múltiplos qubits
• Operações controladas e lógica condicional
• Medições mid-circuit e circuitos adaptativos
• Vários tipos de medição (expectativa, probabilidade, amostras)
• Inspeção e depuração de circuitos

2. Aprendizado de Máquina Quântico

Crie modelos híbridos quântico-clássicos. Consulte references/quantum_ml.md para:

• Integração com PyTorch, JAX, TensorFlow
• Redes neurais quânticas e classificadores variacionais
• Estratégias de codificação de dados (ângulo, amplitude, base, IQP)
• Treinamento de modelos híbridos com retropropagação
• Transfer learning com circuitos quânticos

3. Química Quântica

Simule moléculas e compute energias do estado fundamental. Consulte references/quantum_chemistry.md para:

• Geração de Hamiltoniano molecular
• Variational Quantum Eigensolver (VQE)
• Ansatz UCCSD para química
• Otimização de geometria e curvas de dissociação
• Cálculos de propriedades moleculares

4. Gerenciamento de Dispositivos

Execute em simuladores ou hardware quântico. Consulte references/devices_backends.md para:

• Simuladores integrados (default.qubit, lightning.qubit, default.mixed)
• Plugins de hardware (IBM, Amazon Braket, Google, Rigetti, IonQ)
• Seleção e configuração de dispositivos
• Otimização de desempenho e cache
• Aceleração por GPU e compilação JIT

5. Otimização

Treine circuitos quânticos com vários otimizadores. Consulte references/optimization.md para:

• Otimizadores integrados (Adam, descida de gradiente, momentum, RMSProp)
• Métodos de computação de gradiente (backprop, parameter-shift, adjunto)
• Algoritmos variacionais (VQE, QAOA)
• Estratégias de treinamento (agendas de taxa de aprendizado, mini-lotes)
• Lidando com planaltos áridos e mínimos locais

6. Recursos Avançados

Aproveite templates, transformações e compilação. Consulte references/advanced_features.md para:

• Templates e camadas de circuito
• Transformações e otimização de circuitos
• Programação em nível de pulso
• Compilação JIT Catalyst
• Modelos de ruído e mitigação de erros
• Estimativa de recursos

Fluxos de Trabalho Comuns

Treinar um Classificador Variacional

# 1. Definir ansatz
@qml.qnode(dev)
def classifier(x, weights):
    # Codificar dados
    qml.AngleEmbedding(x, wires=range(4))

    # Camadas variacionais
    qml.StronglyEntanglingLayers(weights, wires=range(4))

    return qml.expval(qml.PauliZ(0))

# 2. Treinar
opt = qml.AdamOptimizer(stepsize=0.01)
weights = np.random.random((3, 4, 3))  # 3 camadas, 4 wires

for epoch in range(100):
    for x, y in zip(X_train, y_train):
        weights = opt.step(lambda w: (classifier(x, w) - y)**2, weights)

Executar VQE para Estado Fundamental Molecular

from pennylane import qchem

# 1. Construir Hamiltoniano
symbols = ['H', 'H']
coords = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.74])
H, n_qubits = qchem.molecular_hamiltonian(symbols, coords)

# 2. Definir ansatz
@qml.qnode(dev)
def vqe_circuit(params):
    qml.BasisState(qchem.hf_state(2, n_qubits), wires=range(n_qubits))
    qml.UCCSD(params, wires=range(n_qubits))
    return qml.expval(H)

# 3. Otimizar
opt = qml.AdamOptimizer(stepsize=0.1)
params = np.zeros(10, requires_grad=True)

for i in range(100):
    params, energy = opt.step_and_cost(vqe_circuit, params)
    print(f"Step {i}: Energy = {energy:.6f} Ha")

Alternar Entre Dispositivos

# Mesmo circuito, diferentes backends
circuit_def = lambda dev: qml.qnode(dev)(circuit_function)

# Testar em simulador
dev_sim = qml.device('default.qubit', wires=4)
result_sim = circuit_def(dev_sim)(params)

# Executar em hardware quântico
dev_hw = qml.device('qiskit.ibmq', wires=4, backend='ibmq_manila')
result_hw = circuit_def(dev_hw)(params)

Documentação Detalhada

Para cobertura abrangente de tópicos específicos, consulte os arquivos de referência:

• Primeiros passos: references/getting_started.md - Instalação, conceitos básicos, primeiros passos
• Circuitos quânticos: references/quantum_circuits.md - Portas, medições, padrões de circuito
• ML quântico: references/quantum_ml.md - Modelos híbridos, integração de frameworks, QNNs
• Química quântica: references/quantum_chemistry.md - VQE, Hamiltonianos moleculares, fluxos de química
• Dispositivos: references/devices_backends.md - Simuladores, plugins de hardware, configuração de dispositivos
• Otimização: references/optimization.md - Otimizadores, gradientes, algoritmos variacionais
• Avançado: references/advanced_features.md - Templates, transformações, compilação JIT, ruído

Melhores Práticas

1. Comece com simuladores - Teste em default.qubit antes de implantar em hardware
2. Use parameter-shift para hardware - Retropropagação funciona apenas em simuladores
3. Escolha codificações apropriadas - Combine codificação de dados com estrutura do problema
4. Inicialize com cuidado - Use pequenos valores aleatórios para evitar planaltos áridos
5. Monitore gradientes - Verifique se há gradientes desaparecendo em circuitos profundos
6. Cache de dispositivos - Reutilize objetos de dispositivo para reduzir sobrecarga de inicialização
7. Analise circuitos - Use qml.specs() para analisar complexidade do circuito
8. Teste localmente - Valide em simuladores antes de enviar para hardware
9. Use templates - Aproveite templates integrados para padrões de circuito comuns
10. Compile quando possível - Use Catalyst JIT para código crítico de desempenho

Recursos

• Documentação oficial: https://docs.pennylane.ai
• Codebook (tutoriais): https://pennylane.ai/codebook
• Demonstrações QML: https://pennylane.ai/qml/demonstrations
• Fórum da comunidade: https://discuss.pennylane.ai
• GitHub: https://github.com/PennyLaneAI/pennylane