 View on QuantumAI
|
 Run in Google Colab
|
 View source on GitHub
|
 Download notebook
|
Setup
Install the ReCirq package:
try:
import recirq
except ImportError:
!pip install git+https://github.com/quantumlib/ReCirq
And import ReCirq:
import recirq
Problem generation
First, we generate and save all of the random instances of the problem. This is not computationally intensive but very important to do first so we have a fixed set of random instances.
from recirq.qaoa.experiments.problem_generation_tasks import \
SKProblemGenerationTask, HardwareGridProblemGenerationTask, ThreeRegularProblemGenerationTask, \
generate_3_regular_problem, generate_sk_problem, generate_hardware_grid_problem
pgen_dataset_id = '2020-03-tutorial'
hardware_grid_problem_tasks = [
HardwareGridProblemGenerationTask(
dataset_id=pgen_dataset_id,
device_name='Sycamore23',
instance_i=i,
n_qubits=n
)
for i in range(5)
for n in range(2, 8 + 1, 2)
]
recirq.display_markdown_docstring(HardwareGridProblemGenerationTask)
HardwareGridProblemGenerationTask
Generate 'Hardware Grid' problems for a named device.
This is a subgraph of the device's hardware topology with random +-1 weights on edges.
See Also
generate_hardware_grid_problem
Attributes
dataset_id: A unique identifier for this dataset.device_name: The device to generate problems for.instance_i: Generate random instances indexed by this number.n_qubits: Generate an n-qubit instance.
sk_problem_tasks = [
SKProblemGenerationTask(
dataset_id=pgen_dataset_id,
instance_i=i,
n_qubits=n
)
for i in range(5)
for n in range(3, 7 + 1, 2)
]
recirq.display_markdown_docstring(SKProblemGenerationTask)
SKProblemGenerationTask
Generate a Sherrington-Kirkpatrick problem.
This is a complete (fully-connected) graph with random +-1 weights on edges.
See Also
generate_sk_problem
Attributes
dataset_id: A unique identifier for this dataset.instance_i: Generate random instances indexed by this number.n_qubits: Generate an n-qubit instance.
three_regular_problem_tasks = [
ThreeRegularProblemGenerationTask(
dataset_id=pgen_dataset_id,
instance_i=i,
n_qubits=n
)
for i in range(5)
for n in range(3, 8 + 1) if 3 * n % 2 == 0
]
Run the tasks
for task in hardware_grid_problem_tasks:
generate_hardware_grid_problem(task)
for task in sk_problem_tasks:
generate_sk_problem(task)
for task in three_regular_problem_tasks:
generate_3_regular_problem(task)
Angle precomputation
from recirq.qaoa.experiments.angle_precomputation_tasks import \
AnglePrecomputationTask, precompute_angles
apre_dataset_id = '2020-03-tutorial'
precompute_tasks = [
AnglePrecomputationTask(
dataset_id=apre_dataset_id,
generation_task=gen_task,
p=p)
for gen_task in recirq.roundrobin(
hardware_grid_problem_tasks,
sk_problem_tasks,
three_regular_problem_tasks,
)
for p in range(1, 3 + 1)
]
recirq.display_markdown_docstring(AnglePrecomputationTask)
AnglePrecomputationTask
Pre-compute optimized angles classically for a given problem.
See Also
precompute_angles
Attributes
dataset_id: A unique identifier for this dataset.generation_task: The input task which specifies the problem.p: QAOA depth hyperparameter p. The number of parameters is 2*p.
for task in precompute_tasks:
precompute_angles(task)
Precomputed angle data collection
from recirq.qaoa.experiments.precomputed_execution_tasks import \
PrecomputedDataCollectionTask, collect_data
dcol_dataset_id = '2020-03-tutorial'
data_collection_tasks = [
PrecomputedDataCollectionTask(
dataset_id=dcol_dataset_id,
precomputation_task=pre_task,
device_name='Syc23-simulator',
n_shots=50_000,
structured=True,
)
for pre_task in precompute_tasks
]
recirq.display_markdown_docstring(PrecomputedDataCollectionTask)
PrecomputedDataCollectionTask
PrecomputedDataCollectionTask(dataset_id: str, precomputation_task: recirq.qaoa.experiments.angle_precomputation_tasks.AnglePrecomputationTask, device_name: str, n_shots: int, structured: bool = False, echoed: bool = False)
await recirq.execute_in_queue(collect_data, data_collection_tasks, num_workers=2)
Landscape data collection
from recirq.qaoa.experiments.p1_landscape_tasks import \
P1LandscapeDataCollectionTask, \
get_data_collection_tasks_on_a_grid, \
collect_either_landscape_or_cal
recirq.display_markdown_docstring(P1LandscapeDataCollectionTask)
P1LandscapeDataCollectionTask
Collect data for a p=1 landscape
This task does exactly one (beta, gamma) point. You will have to run many of these tasks to get a full landscape
See Also
collect_p1_landscape_data
Attributes
dataset_id: A unique identifier for this dataset.generation_task: The task specifying the problem to collect data fordevice_name: The device to run onn_shots: The number of shots to takegamma: The problem unitary parameter gammabeta: The driver unitary parameter betaline_placement_strategy: Only used for SK model problems. Options include 'brute_force', 'random', 'greedy', 'anneal', 'mst', and 'mixed'.
hardware_grid_problem_task = HardwareGridProblemGenerationTask(
dataset_id=pgen_dataset_id,
device_name='Sycamore23',
instance_i=0,
n_qubits=4
)
data_collection_tasks = get_data_collection_tasks_on_a_grid(
pgen_task=hardware_grid_problem_task,
dataset_id=dcol_dataset_id,
gamma_res=11,
beta_res=11,
device_name='Syc23-simulator',
epoch="grid")
await recirq.execute_in_queue(collect_either_landscape_or_cal,
data_collection_tasks,
num_workers=2)
sk_problem_task = SKProblemGenerationTask(
dataset_id=pgen_dataset_id,
instance_i=0,
n_qubits=3,
)
data_collection_tasks = get_data_collection_tasks_on_a_grid(
pgen_task=sk_problem_task,
dataset_id=dcol_dataset_id,
gamma_res=11,
beta_res=11,
device_name='Syc23-simulator',
epoch="sk")
await recirq.execute_in_queue(collect_either_landscape_or_cal,
data_collection_tasks,
num_workers=2)
three_regular_problem_task = ThreeRegularProblemGenerationTask(
dataset_id=pgen_dataset_id,
instance_i=0,
n_qubits=4
)
data_collection_tasks = get_data_collection_tasks_on_a_grid(
pgen_task=three_regular_problem_task,
dataset_id=dcol_dataset_id,
device_name='Syc23-simulator',
gamma_res=11,
beta_res=11,
epoch="tr")
await recirq.execute_in_queue(collect_either_landscape_or_cal,
data_collection_tasks,
num_workers=2)
Optimization Data Collection
from recirq.qaoa.experiments.optimization_tasks import \
OptimizationAlgorithm, \
OptimizationTask, \
collect_optimization_data
recirq.display_markdown_docstring(OptimizationTask)
optimization_algorithm = OptimizationAlgorithm(
method='MGD',
n_shots=25000,
options={
'max_iterations': 10,
'rate': 0.3,
'sample_radius': 0.1,
'n_sample_points_ratio': 1.0,
'rate_decay_exponent': 0.4,
'stability_constant': 250,
'sample_radius_decay_exponent': 0.08,
})
hardware_grid_optimization_task = OptimizationTask(
dataset_id=dcol_dataset_id,
generation_task=hardware_grid_problem_task,
device_name='Syc23-simulator',
p=1,
algorithm=optimization_algorithm,
x0=[0.3, 0.2])
collect_optimization_data(hardware_grid_optimization_task)
optimization_algorithm = OptimizationAlgorithm(
method='MGD',
n_shots=25000,
options={
'max_iterations': 10,
'rate': 0.3,
'sample_radius': 0.1,
'n_sample_points_ratio': 1.0,
'rate_decay_exponent': 0.3,
'stability_constant': 200,
'sample_radius_decay_exponent': 0.08,
})
sk_optimization_task = OptimizationTask(
dataset_id=dcol_dataset_id,
generation_task=sk_problem_task,
device_name='Syc23-simulator',
p=1,
algorithm=optimization_algorithm,
x0=[0.3, 0.2])
collect_optimization_data(sk_optimization_task)
optimization_algorithm = OptimizationAlgorithm(
method='MGD',
n_shots=25000,
options={
'max_iterations': 10,
'rate': 0.2,
'sample_radius': 0.1,
'n_sample_points_ratio': 1.0,
'rate_decay_exponent': 0.4,
'stability_constant': 250,
'sample_radius_decay_exponent': 0.08,
})
three_regular_optimization_task = OptimizationTask(
dataset_id=dcol_dataset_id,
generation_task=three_regular_problem_task,
device_name='Syc23-simulator',
p=1,
algorithm=optimization_algorithm,
x0=[0.3, 0.2])
collect_optimization_data(three_regular_optimization_task)