简单 VQE 算法实现：横场 Ising 模型¶
本教程使用 DeepQuantum 实现一个简洁的 VQE 算法，求解横场 Ising 模型（Transverse Field Ising Model）的基态能量。
为什么选择横场 Ising 模型？¶
- 物理意义明确：描述量子磁性系统的经典模型
- 可解析求解：基态能量可通过精确对角化验证
- 可调参数：横场强度 h 可调节
- 直观展示：可展示量子纠缠和优化过程
- 教学友好：适合初学者理解 VQE
横场 Ising 模型哈密顿量¶
$$H = -J\sum_{i=0}^{N-2} Z_i Z_{i+1} - h\sum_{i=0}^{N-1} X_i$$
其中：
- $Z_i Z_{i+1}$：相邻量子比特的 ZZ 相互作用（耦合项）
- $X_i$：每个量子比特的横向磁场项
- $J$：耦合强度（通常设为 1）
- $h$：横场强度（可调参数）
极限情况：
- $h=0$：经典 Ising 模型，基态为所有自旋平行
- $h \gg J$：自由费米子系统，基态趋向极化态
参考资料¶
In [1]:
Copied!
# ========================================
# 1. 导入必要的库
# ========================================
import numpy as np
import torch
import matplotlib.pyplot as plt
from scipy.linalg import eigh
# DeepQuantum
import deepquantum as dq
from deepquantum import Observable
# 设置随机种子
np.random.seed(42)
torch.manual_seed(42)
print("✅ 库导入成功！")
print(f"DeepQuantum 可用")
# ========================================
# 1. 导入必要的库
# ========================================
import numpy as np
import torch
import matplotlib.pyplot as plt
from scipy.linalg import eigh
# DeepQuantum
import deepquantum as dq
from deepquantum import Observable
# 设置随机种子
np.random.seed(42)
torch.manual_seed(42)
print("✅ 库导入成功！")
print(f"DeepQuantum 可用")
✅ 库导入成功！ DeepQuantum 可用
In [2]:
Copied!
# 配置 matplotlib 支持中文显示
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'DejaVu Sans'] # 指定默认字体
plt.rcParams['axes.unicode_minus'] = False
#解决负号'-'显示为方块的问题
# 配置 matplotlib 支持中文显示
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'DejaVu Sans'] # 指定默认字体
plt.rcParams['axes.unicode_minus'] = False
#解决负号'-'显示为方块的问题
2. 定义横场 Ising 模型¶
In [3]:
Copied!
class TransverseIsingModel:
"""
横场 Ising 模型
哈密顿量: H = -J * Σ Z_i Z_{i+1} - h * Σ X_i
"""
def __init__(self, n_qubits, J=1.0, h=1.0):
"""
初始化横场 Ising 模型
参数:
- n_qubits: 量子比特数
- J: 耦合强度（默认 1.0）
- h: 横场强度（默认 1.0）
"""
self.n_qubits = n_qubits
self.J = J
self.h = h
def build_hamiltonian_matrix(self):
"""
构建完整的哈密顿量矩阵（用于精确对角化）
返回:
- 2^n x 2^n 的哈密顿量矩阵
"""
from scipy.sparse import kron
from scipy.sparse import identity
import scipy.linalg as la
# Pauli 矩阵
X = np.array([[0, 1], [1, 0]])
Z = np.array([[1, 0], [0, -1]])
I2 = np.eye(2)
# 初始化哈密顿量
H = np.zeros((2**self.n_qubits, 2**self.n_qubits))
# 构建 ZZ 相互作用项: -J * Σ Z_i Z_{i+1}
for i in range(self.n_qubits - 1):
# 构造 Z_i Z_{i+1} 算符
op_list = [I2] * self.n_qubits
op_list[i] = Z
op_list[i + 1] = Z
# Kronecker 积
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * op
# 构建横向磁场项: -h * Σ X_i
for i in range(self.n_qubits):
# 构造 X_i 算符
op_list = [I2] * self.n_qubits
op_list[i] = X
# Kronecker 积
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.h * op
return H
def get_exact_ground_state_energy(self):
"""
通过精确对角化计算基态能量
返回:
- 基态能量
- 基态波函数
"""
H = self.build_hamiltonian_matrix()
# 对角化
eigenvalues, eigenvectors = eigh(H)
# 基态是最小本征值
ground_state_idx = np.argmin(eigenvalues)
return eigenvalues[ground_state_idx], eigenvectors[:, ground_state_idx]
def build_observable_list(self):
"""
构建 DeepQuantum Observable 列表
返回:
- observable_list: [(coefficient, Observable), ...]
"""
observable_list = []
# ZZ 相互作用项: -J * Σ Z_i Z_{i+1}
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i + 1],
basis='zz'
)
observable_list.append((-self.J, obs))
# 横向磁场项: -h * Σ X_i
for i in range(self.n_qubits):
obs = Observable(
nqubit=self.n_qubits,
wires=[i],
basis='x'
)
observable_list.append((-self.h, obs))
return observable_list
# 测试模型
print("测试横场 Ising 模型...")
print("=" * 50)
# 创建 3 量子比特的模型
model = TransverseIsingModel(n_qubits=3, J=1.0, h=1.0)
print(f"模型参数：")
print(f" 量子比特数: {model.n_qubits}")
print(f" 耦合强度 J: {model.J}")
print(f" 横场强度 h: {model.h}")
# 计算精确基态能量
exact_energy, exact_state = model.get_exact_ground_state_energy()
print(f"\n精确对角化结果：")
print(f" 基态能量: {exact_energy:.6f}")
print(f" 基态维度: {exact_state.shape}")
# 构建 Observable 列表
observable_list = model.build_observable_list()
print(f"\nVQE Observable 数量: {len(observable_list)}")
print(" 前 3 个观测项：")
for i, (coeff, obs) in enumerate(observable_list[:3]):
print(f" {i+1}. 系数={coeff:+.2f}, wires={obs.wires}, basis={obs.basis}")
class TransverseIsingModel:
"""
横场 Ising 模型
哈密顿量: H = -J * Σ Z_i Z_{i+1} - h * Σ X_i
"""
def __init__(self, n_qubits, J=1.0, h=1.0):
"""
初始化横场 Ising 模型
参数:
- n_qubits: 量子比特数
- J: 耦合强度（默认 1.0）
- h: 横场强度（默认 1.0）
"""
self.n_qubits = n_qubits
self.J = J
self.h = h
def build_hamiltonian_matrix(self):
"""
构建完整的哈密顿量矩阵（用于精确对角化）
返回:
- 2^n x 2^n 的哈密顿量矩阵
"""
from scipy.sparse import kron
from scipy.sparse import identity
import scipy.linalg as la
# Pauli 矩阵
X = np.array([[0, 1], [1, 0]])
Z = np.array([[1, 0], [0, -1]])
I2 = np.eye(2)
# 初始化哈密顿量
H = np.zeros((2**self.n_qubits, 2**self.n_qubits))
# 构建 ZZ 相互作用项: -J * Σ Z_i Z_{i+1}
for i in range(self.n_qubits - 1):
# 构造 Z_i Z_{i+1} 算符
op_list = [I2] * self.n_qubits
op_list[i] = Z
op_list[i + 1] = Z
# Kronecker 积
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * op
# 构建横向磁场项: -h * Σ X_i
for i in range(self.n_qubits):
# 构造 X_i 算符
op_list = [I2] * self.n_qubits
op_list[i] = X
# Kronecker 积
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.h * op
return H
def get_exact_ground_state_energy(self):
"""
通过精确对角化计算基态能量
返回:
- 基态能量
- 基态波函数
"""
H = self.build_hamiltonian_matrix()
# 对角化
eigenvalues, eigenvectors = eigh(H)
# 基态是最小本征值
ground_state_idx = np.argmin(eigenvalues)
return eigenvalues[ground_state_idx], eigenvectors[:, ground_state_idx]
def build_observable_list(self):
"""
构建 DeepQuantum Observable 列表
返回:
- observable_list: [(coefficient, Observable), ...]
"""
observable_list = []
# ZZ 相互作用项: -J * Σ Z_i Z_{i+1}
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i + 1],
basis='zz'
)
observable_list.append((-self.J, obs))
# 横向磁场项: -h * Σ X_i
for i in range(self.n_qubits):
obs = Observable(
nqubit=self.n_qubits,
wires=[i],
basis='x'
)
observable_list.append((-self.h, obs))
return observable_list
# 测试模型
print("测试横场 Ising 模型...")
print("=" * 50)
# 创建 3 量子比特的模型
model = TransverseIsingModel(n_qubits=3, J=1.0, h=1.0)
print(f"模型参数：")
print(f" 量子比特数: {model.n_qubits}")
print(f" 耦合强度 J: {model.J}")
print(f" 横场强度 h: {model.h}")
# 计算精确基态能量
exact_energy, exact_state = model.get_exact_ground_state_energy()
print(f"\n精确对角化结果：")
print(f" 基态能量: {exact_energy:.6f}")
print(f" 基态维度: {exact_state.shape}")
# 构建 Observable 列表
observable_list = model.build_observable_list()
print(f"\nVQE Observable 数量: {len(observable_list)}")
print(" 前 3 个观测项：")
for i, (coeff, obs) in enumerate(observable_list[:3]):
print(f" {i+1}. 系数={coeff:+.2f}, wires={obs.wires}, basis={obs.basis}")
测试横场 Ising 模型...
==================================================
模型参数：
量子比特数: 3
耦合强度 J: 1.0
横场强度 h: 1.0
精确对角化结果：
基态能量: -3.493959
基态维度: (8,)
VQE Observable 数量: 5
前 3 个观测项：
1. 系数=-1.00, wires=[[0], [1]], basis=zz
2. 系数=-1.00, wires=[[1], [2]], basis=zz
3. 系数=-1.00, wires=[[0]], basis=x
In [4]:
Copied!
def simple_ansatz(qc, params, n_qubits, layers=1):
"""
简单的硬件高效 Ansatz
结构：
1. 旋转层：RY（每个量子比特）
2. 纠缠层：CZ（线性链）
参数:
- qc: DeepQuantum 电路
- params: 参数数组
- n_qubits: 量子比特数
- layers: 层数
"""
param_idx = 0
n_params = n_qubits * layers
if len(params) != n_params:
raise ValueError(f"需要 {n_params} 个参数，得到 {len(params)}")
# 构建多层
for layer in range(layers):
# 旋转层：RY
for q in range(n_qubits):
qc.ry(q, params[param_idx])
param_idx += 1
# 纠缠层：CZ 线性链
for q in range(n_qubits - 1):
qc.cz(q, q + 1)
return qc
# 测试 Ansatz
print("测试 Ansatz 构建...\n")
n_qubits = 3
layers = 2
n_params = n_qubits * layers
params_test = np.random.uniform(0, 2*np.pi, n_params)
qc_test = dq.QubitCircuit(n_qubits)
qc_test = simple_ansatz(qc_test, params_test, n_qubits, layers)
state_test = qc_test()
print(f"Ansatz 测试成功！")
print(f" 量子比特: {n_qubits}")
print(f" 层数: {layers}")
print(f" 参数数量: {n_params}")
print(f" 状态形状: {state_test.shape}")
print(f" 状态归一化: {torch.norm(state_test):.6f}")
def simple_ansatz(qc, params, n_qubits, layers=1):
"""
简单的硬件高效 Ansatz
结构：
1. 旋转层：RY（每个量子比特）
2. 纠缠层：CZ（线性链）
参数:
- qc: DeepQuantum 电路
- params: 参数数组
- n_qubits: 量子比特数
- layers: 层数
"""
param_idx = 0
n_params = n_qubits * layers
if len(params) != n_params:
raise ValueError(f"需要 {n_params} 个参数，得到 {len(params)}")
# 构建多层
for layer in range(layers):
# 旋转层：RY
for q in range(n_qubits):
qc.ry(q, params[param_idx])
param_idx += 1
# 纠缠层：CZ 线性链
for q in range(n_qubits - 1):
qc.cz(q, q + 1)
return qc
# 测试 Ansatz
print("测试 Ansatz 构建...\n")
n_qubits = 3
layers = 2
n_params = n_qubits * layers
params_test = np.random.uniform(0, 2*np.pi, n_params)
qc_test = dq.QubitCircuit(n_qubits)
qc_test = simple_ansatz(qc_test, params_test, n_qubits, layers)
state_test = qc_test()
print(f"Ansatz 测试成功！")
print(f" 量子比特: {n_qubits}")
print(f" 层数: {layers}")
print(f" 参数数量: {n_params}")
print(f" 状态形状: {state_test.shape}")
print(f" 状态归一化: {torch.norm(state_test):.6f}")
测试 Ansatz 构建... Ansatz 测试成功！ 量子比特: 3 层数: 2 参数数量: 6 状态形状: torch.Size([8, 1]) 状态归一化: 1.000000
4. 定义能量计算函数¶
In [5]:
Copied!
def calculate_energy(state, observable_list):
"""
计算给定量子态的能量期望值
参数:
- state: 量子态向量
- observable_list: 观测项列表 [(coeff, Observable), ...]
返回:
- 能量期望值
"""
energy = 0.0
for coeff, obs in observable_list:
# 计算期望值
exp_val = dq.expectation(state, obs).item()
energy += coeff * exp_val
return energy
def calculate_energy_from_circuit(qc, observable_list):
"""
从量子电路计算能量
"""
state = qc()
return calculate_energy(state, observable_list)
# 测试能量计算
print("测试能量计算...\n")
test_energy = calculate_energy_from_circuit(qc_test, observable_list)
print(f"测试能量: {test_energy:.6f}")
print(f"精确能量: {exact_energy:.6f}")
print(f"能量差: {abs(test_energy - exact_energy):.6f}")
def calculate_energy(state, observable_list):
"""
计算给定量子态的能量期望值
参数:
- state: 量子态向量
- observable_list: 观测项列表 [(coeff, Observable), ...]
返回:
- 能量期望值
"""
energy = 0.0
for coeff, obs in observable_list:
# 计算期望值
exp_val = dq.expectation(state, obs).item()
energy += coeff * exp_val
return energy
def calculate_energy_from_circuit(qc, observable_list):
"""
从量子电路计算能量
"""
state = qc()
return calculate_energy(state, observable_list)
# 测试能量计算
print("测试能量计算...\n")
test_energy = calculate_energy_from_circuit(qc_test, observable_list)
print(f"测试能量: {test_energy:.6f}")
print(f"精确能量: {exact_energy:.6f}")
print(f"能量差: {abs(test_energy - exact_energy):.6f}")
测试能量计算... 测试能量: -0.979339 精确能量: -3.493959 能量差: 2.514620
5. VQE 优化循环¶
使用梯度下降优化参数
In [6]:
Copied!
def vqe_optimization(model, n_layers, learning_rate=0.1, max_iter=100, verbose=True):
"""
VQE 优化循环
参数:
- model: 横场 Ising 模型
- n_layers: Ansatz 层数
- learning_rate: 学习率
- max_iter: 最大迭代次数
- verbose: 是否打印进度
返回:
- loss_history: 能量历史
- final_params: 最优参数
"""
n_qubits = model.n_qubits
n_params = n_qubits * n_layers
# 初始化参数
params = np.random.uniform(0, 2*np.pi, n_params)
# 获取 Observable 列表
observable_list = model.build_observable_list()
# 获取精确能量作为参考
exact_energy, _ = model.get_exact_ground_state_energy()
loss_history = []
if verbose:
print(f"\n开始 VQE 优化")
print(f"=" * 50)
print(f" 量子比特: {n_qubits}")
print(f" 层数: {n_layers}")
print(f" 参数数量: {n_params}")
print(f" 学习率: {learning_rate}")
print(f" 最大迭代: {max_iter}")
print(f"\n 精确基态能量: {exact_energy:.6f}")
print(f"\n{'迭代':>6s} | {'VQE能量':>12s} | {'误差':>12s}")
print("-" * 36)
for i in range(max_iter):
# 构建电路并计算能量
qc = dq.QubitCircuit(n_qubits)
qc = simple_ansatz(qc, params, n_qubits, n_layers)
current_energy = calculate_energy_from_circuit(qc, observable_list)
loss_history.append(current_energy)
# 计算梯度（数值微分）
grad = np.zeros_like(params)
eps = 0.01
for j in range(len(params)):
params_plus = params.copy()
params_plus[j] += eps
qc_plus = dq.QubitCircuit(n_qubits)
qc_plus = simple_ansatz(qc_plus, params_plus, n_qubits, n_layers)
energy_plus = calculate_energy_from_circuit(qc_plus, observable_list)
params_minus = params.copy()
params_minus[j] -= eps
qc_minus = dq.QubitCircuit(n_qubits)
qc_minus = simple_ansatz(qc_minus, params_minus, n_qubits, n_layers)
energy_minus = calculate_energy_from_circuit(qc_minus, observable_list)
grad[j] = (energy_plus - energy_minus) / (2 * eps)
# 更新参数
params = params - learning_rate * grad
# 打印进度
if verbose and (i % 10 == 0 or i == max_iter - 1):
error = abs(current_energy - exact_energy)
print(f"{i:>6d} | {current_energy:>12.6f} | {error:>12.6f}")
return loss_history, params
def vqe_optimization(model, n_layers, learning_rate=0.1, max_iter=100, verbose=True):
"""
VQE 优化循环
参数:
- model: 横场 Ising 模型
- n_layers: Ansatz 层数
- learning_rate: 学习率
- max_iter: 最大迭代次数
- verbose: 是否打印进度
返回:
- loss_history: 能量历史
- final_params: 最优参数
"""
n_qubits = model.n_qubits
n_params = n_qubits * n_layers
# 初始化参数
params = np.random.uniform(0, 2*np.pi, n_params)
# 获取 Observable 列表
observable_list = model.build_observable_list()
# 获取精确能量作为参考
exact_energy, _ = model.get_exact_ground_state_energy()
loss_history = []
if verbose:
print(f"\n开始 VQE 优化")
print(f"=" * 50)
print(f" 量子比特: {n_qubits}")
print(f" 层数: {n_layers}")
print(f" 参数数量: {n_params}")
print(f" 学习率: {learning_rate}")
print(f" 最大迭代: {max_iter}")
print(f"\n 精确基态能量: {exact_energy:.6f}")
print(f"\n{'迭代':>6s} | {'VQE能量':>12s} | {'误差':>12s}")
print("-" * 36)
for i in range(max_iter):
# 构建电路并计算能量
qc = dq.QubitCircuit(n_qubits)
qc = simple_ansatz(qc, params, n_qubits, n_layers)
current_energy = calculate_energy_from_circuit(qc, observable_list)
loss_history.append(current_energy)
# 计算梯度（数值微分）
grad = np.zeros_like(params)
eps = 0.01
for j in range(len(params)):
params_plus = params.copy()
params_plus[j] += eps
qc_plus = dq.QubitCircuit(n_qubits)
qc_plus = simple_ansatz(qc_plus, params_plus, n_qubits, n_layers)
energy_plus = calculate_energy_from_circuit(qc_plus, observable_list)
params_minus = params.copy()
params_minus[j] -= eps
qc_minus = dq.QubitCircuit(n_qubits)
qc_minus = simple_ansatz(qc_minus, params_minus, n_qubits, n_layers)
energy_minus = calculate_energy_from_circuit(qc_minus, observable_list)
grad[j] = (energy_plus - energy_minus) / (2 * eps)
# 更新参数
params = params - learning_rate * grad
# 打印进度
if verbose and (i % 10 == 0 or i == max_iter - 1):
error = abs(current_energy - exact_energy)
print(f"{i:>6d} | {current_energy:>12.6f} | {error:>12.6f}")
return loss_history, params
6. 运行 VQE 优化¶
In [7]:
Copied!
# ========================================
# VQE 优化示例 1：3 量子比特
# ========================================
print("\n" + "=" * 70)
print("示例 1：横场 Ising 模型 (3 量子比特)")
print("=" * 70)
# 创建模型
model_3q = TransverseIsingModel(n_qubits=3, J=1.0, h=1.0)
# 运行 VQE
loss_history_3q, final_params_3q = vqe_optimization(
model=model_3q,
n_layers=4,
learning_rate=0.1,
max_iter=100,
verbose=True
)
# 结果总结
exact_energy_3q, _ = model_3q.get_exact_ground_state_energy()
vqe_energy_3q = loss_history_3q[-1]
error_3q = abs(vqe_energy_3q - exact_energy_3q)
print(f"\n" + "=" * 70)
print("结果总结")
print("=" * 70)
print(f"VQE 能量: {vqe_energy_3q:.6f}")
print(f"精确能量: {exact_energy_3q:.6f}")
print(f"绝对误差: {error_3q:.6f}")
print(f"相对误差: {error_3q / abs(exact_energy_3q) * 100:.4f}%")
if error_3q < 0.01:
print("\n✅ 优秀！VQE 成功找到基态能量！")
elif error_3q < 0.1:
print("\n✓ 良好！接近基态能量。")
else:
print("\n⚠ 需要更多优化（增加层数或迭代次数）")
# ========================================
# VQE 优化示例 1：3 量子比特
# ========================================
print("\n" + "=" * 70)
print("示例 1：横场 Ising 模型 (3 量子比特)")
print("=" * 70)
# 创建模型
model_3q = TransverseIsingModel(n_qubits=3, J=1.0, h=1.0)
# 运行 VQE
loss_history_3q, final_params_3q = vqe_optimization(
model=model_3q,
n_layers=4,
learning_rate=0.1,
max_iter=100,
verbose=True
)
# 结果总结
exact_energy_3q, _ = model_3q.get_exact_ground_state_energy()
vqe_energy_3q = loss_history_3q[-1]
error_3q = abs(vqe_energy_3q - exact_energy_3q)
print(f"\n" + "=" * 70)
print("结果总结")
print("=" * 70)
print(f"VQE 能量: {vqe_energy_3q:.6f}")
print(f"精确能量: {exact_energy_3q:.6f}")
print(f"绝对误差: {error_3q:.6f}")
print(f"相对误差: {error_3q / abs(exact_energy_3q) * 100:.4f}%")
if error_3q < 0.01:
print("\n✅ 优秀！VQE 成功找到基态能量！")
elif error_3q < 0.1:
print("\n✓ 良好！接近基态能量。")
else:
print("\n⚠ 需要更多优化（增加层数或迭代次数）")
======================================================================
示例 1：横场 Ising 模型 (3 量子比特)
======================================================================
开始 VQE 优化
==================================================
量子比特: 3
层数: 4
参数数量: 12
学习率: 0.1
最大迭代: 100
精确基态能量: -3.493959
迭代 | VQE能量 | 误差
------------------------------------
0 | 1.556862 | 5.050822
10 | -3.428739 | 0.065220
20 | -3.472986 | 0.020973
30 | -3.479867 | 0.014092
40 | -3.482556 | 0.011404
50 | -3.483661 | 0.010299
60 | -3.484116 | 0.009844
70 | -3.484303 | 0.009656
80 | -3.484380 | 0.009579
90 | -3.484412 | 0.009547
99 | -3.484425 | 0.009534
======================================================================
结果总结
======================================================================
VQE 能量: -3.484425
精确能量: -3.493959
绝对误差: 0.009534
相对误差: 0.2729%
✅ 优秀！VQE 成功找到基态能量！
7. 绘制收敛曲线¶
In [8]:
Copied!
plt.figure(figsize=(10, 6))
plt.plot(loss_history_3q, 'b-', linewidth=2, label='VQE Energy')
plt.axhline(y=exact_energy_3q, color='r', linestyle='--',
linewidth=2, label='Exact Ground State Energy')
plt.xlabel('Iteration', fontsize=12)
plt.ylabel('Energy', fontsize=12)
plt.title('VQE Optimization: Transverse Ising Model (3 Qubits)', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_tfim_3qubits.png', dpi=300)
plt.show()
print("\n图表已保存为 'vqe_tfim_3qubits.png'")
plt.figure(figsize=(10, 6))
plt.plot(loss_history_3q, 'b-', linewidth=2, label='VQE Energy')
plt.axhline(y=exact_energy_3q, color='r', linestyle='--',
linewidth=2, label='Exact Ground State Energy')
plt.xlabel('Iteration', fontsize=12)
plt.ylabel('Energy', fontsize=12)
plt.title('VQE Optimization: Transverse Ising Model (3 Qubits)', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_tfim_3qubits.png', dpi=300)
plt.show()
print("\n图表已保存为 'vqe_tfim_3qubits.png'")
图表已保存为 'vqe_tfim_3qubits.png'
8. 探索不同参数的影响¶
In [9]:
Copied!
# ========================================
# 探索不同横场强度 h 的影响
# ========================================
print("\n探索不同横场强度的影响...\n")
print("=" * 70)
h_values = [0.1, 0.5, 1.0, 1.5, 2.0]
results = []
for h in h_values:
print(f"\nh = {h}")
print("-" * 30)
# 创建模型
model = TransverseIsingModel(n_qubits=3, J=1.0, h=h)
# 运行 VQE（减少迭代次数以加快速度）
loss_hist, _ = vqe_optimization(
model=model,
n_layers=2,
learning_rate=0.1,
max_iter=50,
verbose=False
)
# 获取精确能量
exact_e, _ = model.get_exact_ground_state_energy()
vqe_e = loss_hist[-1]
results.append({
'h': h,
'exact': exact_e,
'vqe': vqe_e,
'error': abs(vqe_e - exact_e)
})
print(f" 精确能量: {exact_e:.6f}")
print(f" VQE 能量: {vqe_e:.6f}")
print(f" 误差: {abs(vqe_e - exact_e):.6f}")
# 绘制结果对比
plt.figure(figsize=(10, 6))
h_vals = [r['h'] for r in results]
exact_vals = [r['exact'] for r in results]
vqe_vals = [r['vqe'] for r in results]
plt.plot(h_vals, exact_vals, 'r-o', linewidth=2, markersize=8, label='Exact')
plt.plot(h_vals, vqe_vals, 'b-s', linewidth=2, markersize=8, label='VQE')
plt.xlabel('Transverse Field Strength (h)', fontsize=12)
plt.ylabel('Ground State Energy', fontsize=12)
plt.title('Transverse Ising Model: Exact vs VQE', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_tfim_h_scan.png', dpi=300)
plt.show()
print("\n图表已保存为 'vqe_tfim_h_scan.png'")
# ========================================
# 探索不同横场强度 h 的影响
# ========================================
print("\n探索不同横场强度的影响...\n")
print("=" * 70)
h_values = [0.1, 0.5, 1.0, 1.5, 2.0]
results = []
for h in h_values:
print(f"\nh = {h}")
print("-" * 30)
# 创建模型
model = TransverseIsingModel(n_qubits=3, J=1.0, h=h)
# 运行 VQE（减少迭代次数以加快速度）
loss_hist, _ = vqe_optimization(
model=model,
n_layers=2,
learning_rate=0.1,
max_iter=50,
verbose=False
)
# 获取精确能量
exact_e, _ = model.get_exact_ground_state_energy()
vqe_e = loss_hist[-1]
results.append({
'h': h,
'exact': exact_e,
'vqe': vqe_e,
'error': abs(vqe_e - exact_e)
})
print(f" 精确能量: {exact_e:.6f}")
print(f" VQE 能量: {vqe_e:.6f}")
print(f" 误差: {abs(vqe_e - exact_e):.6f}")
# 绘制结果对比
plt.figure(figsize=(10, 6))
h_vals = [r['h'] for r in results]
exact_vals = [r['exact'] for r in results]
vqe_vals = [r['vqe'] for r in results]
plt.plot(h_vals, exact_vals, 'r-o', linewidth=2, markersize=8, label='Exact')
plt.plot(h_vals, vqe_vals, 'b-s', linewidth=2, markersize=8, label='VQE')
plt.xlabel('Transverse Field Strength (h)', fontsize=12)
plt.ylabel('Ground State Energy', fontsize=12)
plt.title('Transverse Ising Model: Exact vs VQE', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_tfim_h_scan.png', dpi=300)
plt.show()
print("\n图表已保存为 'vqe_tfim_h_scan.png'")
探索不同横场强度的影响... ====================================================================== h = 0.1 ------------------------------ 精确能量: -2.013500 VQE 能量: -2.010885 误差: 0.002615 h = 0.5 ------------------------------ 精确能量: -2.403212 VQE 能量: -2.297155 误差: 0.106057 h = 1.0 ------------------------------ 精确能量: -3.493959 VQE 能量: -3.106462 误差: 0.387497 h = 1.5 ------------------------------ 精确能量: -4.832415 VQE 能量: -4.773595 误差: 0.058820 h = 2.0 ------------------------------ 精确能量: -6.249771 VQE 能量: -6.247885 误差: 0.001886
图表已保存为 'vqe_tfim_h_scan.png'
9. 总结¶
In [10]:
Copied!
print("\n" + "=" * 70)
print("VQE 算法实现总结")
print("=" * 70)
print("""
本教程实现了一个简洁的 VQE 算法，用于求解横场 Ising 模型的基态能量。
关键要点：
1. ✅ 使用了简单的哈密顿量（横场 Ising 模型）
2. ✅ 实现了硬件高效的 Ansatz（RY + CZ）
3. ✅ 使用了梯度下降优化
4. ✅ 可以验证结果（与精确对角化对比）
5. ✅ 探索了参数的影响（横场强度 h）
横场 Ising 模型的优势：
- 物理意义明确（量子磁性系统）
- 可解析求解（验证结果）
- 可调参数（探索相变）
- 适合教学演示
下一步：
- 尝试更多量子比特（4, 5, ...）
- 使用不同的 Ansatz（增加表达能力）
- 实现更高级的优化器（Adam, L-BFGS）
- 应用到真实的分子系统
""")
print("\n" + "=" * 70)
print("恭喜！您已成功实现 VQE 算法！")
print("=" * 70)
print("\n" + "=" * 70)
print("VQE 算法实现总结")
print("=" * 70)
print("""
本教程实现了一个简洁的 VQE 算法，用于求解横场 Ising 模型的基态能量。
关键要点：
1. ✅ 使用了简单的哈密顿量（横场 Ising 模型）
2. ✅ 实现了硬件高效的 Ansatz（RY + CZ）
3. ✅ 使用了梯度下降优化
4. ✅ 可以验证结果（与精确对角化对比）
5. ✅ 探索了参数的影响（横场强度 h）
横场 Ising 模型的优势：
- 物理意义明确（量子磁性系统）
- 可解析求解（验证结果）
- 可调参数（探索相变）
- 适合教学演示
下一步：
- 尝试更多量子比特（4, 5, ...）
- 使用不同的 Ansatz（增加表达能力）
- 实现更高级的优化器（Adam, L-BFGS）
- 应用到真实的分子系统
""")
print("\n" + "=" * 70)
print("恭喜！您已成功实现 VQE 算法！")
print("=" * 70)
====================================================================== VQE 算法实现总结 ====================================================================== 本教程实现了一个简洁的 VQE 算法，用于求解横场 Ising 模型的基态能量。 关键要点： 1. ✅ 使用了简单的哈密顿量（横场 Ising 模型） 2. ✅ 实现了硬件高效的 Ansatz（RY + CZ） 3. ✅ 使用了梯度下降优化 4. ✅ 可以验证结果（与精确对角化对比） 5. ✅ 探索了参数的影响（横场强度 h） 横场 Ising 模型的优势： - 物理意义明确（量子磁性系统） - 可解析求解（验证结果） - 可调参数（探索相变） - 适合教学演示 下一步： - 尝试更多量子比特（4, 5, ...） - 使用不同的 Ansatz（增加表达能力） - 实现更高级的优化器（Adam, L-BFGS） - 应用到真实的分子系统 ====================================================================== 恭喜！您已成功实现 VQE 算法！ ======================================================================
In [ ]:
Copied!