Python Environment Setup¶
This appendix provides step-by-step instructions for setting up a complete Python environment for quantum machine learning, covering all packages used in this book.
System Requirements¶
Hardware:
-
CPU: Any modern x86-64 processor (multi-core recommended)
-
RAM: 8 GB minimum; 16 GB recommended for large simulations
-
GPU: Optional (CUDA-compatible NVIDIA GPU for PyTorch acceleration)
-
Disk: 10 GB free for packages and datasets
Operating System: Linux (recommended), macOS, or Windows 10/11.
Conda Environment Setup¶
We recommend using Miniconda to manage Python environments:
# 1. Install Miniconda from https://docs.conda.io/en/latest/miniconda.html
# 2. Create a dedicated QML environment (Python 3.10 recommended)
conda create -n qml_book python=3.10 -y
conda activate qml_book
# 3. Install core scientific stack
conda install numpy scipy matplotlib pandas scikit-learn jupyter -y
# 4. Install PyTorch (CPU only, for development)
pip install torch torchvision
# 5. Install PennyLane and plugins
pip install pennylane pennylane-lightning pennylane-qiskit
# 6. Install Qiskit ecosystem
pip install qiskit qiskit-aer qiskit-ibm-runtime
pip install qiskit-machine-learning
# 7. Install quantum chemistry tools
pip install openfermion openfermionpyscf pyscf
# 8. Install additional QML tools
pip install mitiq # error mitigation
pip install rdkit # molecular fingerprints (drug discovery)
# 9. Install visualization tools
pip install plotly seaborn tqdm
# 10. Verify installation
python -c "import pennylane; print('PennyLane version:', pennylane.__version__)"
python -c "import qiskit; print('Qiskit version:', qiskit.__version__)"
python -c "import torch; print('PyTorch version:', torch.__version__)"
IBM Quantum Account Setup¶
To run circuits on real IBM quantum hardware:
# 1. Create free account at https://quantum.ibm.com/
# 2. Copy your API token from the account page
from qiskit_ibm_runtime import QiskitRuntimeService
# Save credentials (one-time setup)
QiskitRuntimeService.save_account(
channel="ibm_quantum",
token="YOUR_IBM_QUANTUM_TOKEN_HERE",
set_as_default=True
)
# List available backends
service = QiskitRuntimeService()
backends = service.backends(simulator=False, operational=True)
print("Available QPUs:")
for b in backends:
print(f" {b.name}: {b.num_qubits} qubits")
# Run on simulator (free tier)
from qiskit_ibm_runtime import Sampler
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
sampler = Sampler(backend=service.backend("ibmq_qasm_simulator"))
job = sampler.run(qc, shots=1000)
result = job.result()
print("Bell state counts:", dict(result.quasi_dists[0]))
PennyLane Device Configuration¶
import pennylane as qml
# 1. Default qubit simulator (exact statevector, CPU)
dev_default = qml.device("default.qubit", wires=10)
# 2. Lightning qubit (faster C++ simulator)
dev_lightning = qml.device("lightning.qubit", wires=20)
# 3. Qiskit Aer simulator (noise-aware)
dev_aer = qml.device("qiskit.aer", wires=5,
backend='qasm_simulator', shots=2048)
# 4. IBM Quantum real hardware via PennyLane-Qiskit
# dev_ibm = qml.device("qiskit.ibmq", wires=5,
# backend="ibm_nairobi",
# ibmqx_token="YOUR_TOKEN")
# 5. Default mixed (density matrix simulator, for noisy circuits)
dev_mixed = qml.device("default.mixed", wires=5)
# Verify all devices work
@qml.qnode(dev_default)
def test_circuit():
qml.Hadamard(0)
qml.CNOT(wires=[0, 1])
return qml.probs(wires=[0, 1])
print("Bell state probabilities:", test_circuit())
Jupyter Notebook Configuration¶
# Launch Jupyter Lab (recommended over classic Notebook)
# pip install jupyterlab
# Configure matplotlib for inline display
# In notebook cell 1:
import matplotlib
matplotlib.use('inline')
import matplotlib.pyplot as plt
import pennylane as qml
import numpy as np
# Enable circuit drawing in notebooks
qml.drawer.use_style("black_white")
# Example: Draw a 4-qubit circuit
dev = qml.device("default.qubit", wires=4)
@qml.qnode(dev)
def my_circuit(params):
for i in range(4):
qml.RY(params[i], wires=i)
qml.CNOT(wires=[0, 1])
qml.CNOT(wires=[2, 3])
qml.CNOT(wires=[1, 2])
return qml.state()
params = np.array([0.5, 1.0, 1.5, 2.0])
print(qml.draw(my_circuit)(params))
Troubleshooting¶
Common issues and solutions:
-
PennyLane interface error: Ensure PyTorch and PennyLane versions are compatible:
pip install pennylane --upgrade. -
Qiskit version conflicts: Use
pip install qiskit==1.0.0 qiskit-aer==0.14.0for pinned versions. -
Slow simulation: Use
lightning.qubitinstead ofdefault.qubitfor circuits with \(>15\) qubits. -
CUDA out of memory: Reduce batch size or use CPU:
torch.device("cpu"). -
IBM API timeout: IBM Quantum imposes 10-minute timeout on circuit jobs; split large sweeps into smaller batches.
Tip
For reproducibility, pin your package versions in a requirements.txt: pip freeze > requirements.txt. Recreate the environment with: pip install -r requirements.txt.