Skip to content

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.0 for pinned versions.

  • Slow simulation: Use lightning.qubit instead of default.qubit for 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.