def test_parameters(_gamma):
start_time = time_module.clock()
environment = GridEnvironment(n_rows, n_cols, circuit)
agent = SimpleDQNAgent(environment)
train_model(environment,
agent,
training_episodes=training_episodes,
should_print=False)
average_test_time = 0.0
average_circuit_depth_overhead = 0.0
for e in range(test_episodes):
actions, circuit_depth = schedule_swaps(environment,
agent,
experience_db=None)
average_test_time += (1.0 / test_episodes) * len(actions)
average_circuit_depth_overhead += (1.0 /
test_episodes) * (circuit_depth - 1)
end_time = time_module.clock()
total_time = end_time - start_time
return average_circuit_depth_overhead, total_time
def train_model_on_random_circuits(f_model_number):
model_name = "random_circuits_" + str(f_model_number)
def training_circuit_generation_function():
return generate_completely_random_circuit(16, 50).to_dqn_rep()
environment = GridEnvironment(4, 4, training_circuit_generation_function())
agent = DoubleDQNAgent(environment)
train_model(
environment,
agent,
training_episodes=training_episodes,
circuit_generation_function=training_circuit_generation_function,
should_print=False)
agent.save_model(model_name)
def perform_run(f_initial_locations, f_model_number):
model_name = "random_circuits_" + str(f_model_number)
start_time = time_module.clock()
environment = GridEnvironment(4, 4, test_set_circuits[0].to_dqn_rep())
agent = DoubleDQNAgent(environment)
agent.load_model(model_name)
average_test_time = 0.0
average_circuit_depth_overhead = 0.0
average_circuit_depth_ratio = 0.0
test_episodes = len(test_set_circuits)
for e in range(test_episodes):
circuit = test_set_circuits[e]
f_qubit_locations = f_initial_locations[e]
original_depth = circuit.depth()
actions, circuit_depth = schedule_swaps(
environment,
agent,
circuit=circuit,
experience_db=None,
qubit_locations=f_qubit_locations,
safety_checks_on=True)
average_test_time += (1.0 / test_episodes) * len(actions)
average_circuit_depth_overhead += (1.0 / test_episodes) * (
circuit_depth - original_depth)
average_circuit_depth_ratio += (1.0 / test_episodes) * (
float(circuit_depth) / float(original_depth))
end_time = time_module.clock()
time_taken = end_time - start_time
result = (f_model_number, average_test_time,
average_circuit_depth_overhead, average_circuit_depth_ratio,
time_taken)
print('Completed run:', result)
return result
def perform_run(num_rows, num_cols, training_episodes, test_episodes=100):
"""
:param num_rows: dummy arg, number of rows of TODO???
:param num_cols: dummy arg, number of rows of TODO???
:param training_episodes: number of episodes to train for
:param test_episodes: number of episodes to test for
:return: datapoint: TODO what does that mean?
"""
def circuit_generation_function():
return generate_full_layer_circuit(num_rows * num_cols).to_dqn_rep()
environment = GridEnvironment(num_rows, num_cols,
circuit_generation_function())
agent = DoubleDQNAgent(environment)
start_time = time_module.perf_counter()
# Pass the number of training steps and episodes to control how much we train for
train_model(environment,
agent,
training_episodes=training_episodes,
circuit_generation_function=circuit_generation_function,
should_print=True)
average_circuit_depth_overhead = 0.0
for e in range(test_episodes):
actions, circuit_depth = schedule_swaps(
environment,
agent,
circuit=circuit_generation_function(),
experience_db=None)
average_circuit_depth_overhead += (1.0 /
test_episodes) * (circuit_depth - 1)
end_time = time_module.perf_counter()
time_taken = end_time - start_time
datapoint = (num_rows, num_cols, average_circuit_depth_overhead,
time_taken)
print('Completed run:', datapoint)
return datapoint
def perform_run(nrows, ncols, training_episodes):
test_episodes = 100
circuit_generation_function = lambda: generate_full_layer_circuit(
nrows * ncols).to_dqn_rep()
environment = GridEnvironment(nrows, ncols, circuit_generation_function())
agent = DQNAgent(environment)
start_time = time_module.clock()
train_model(environment,
agent,
training_episodes=training_episodes,
circuit_generation_function=circuit_generation_function,
should_print=False)
average_circuit_depth_overhead = 0.0
for e in range(test_episodes):
actions, circuit_depth = schedule_swaps(
environment,
agent,
circuit=circuit_generation_function(),
experience_db=None)
average_circuit_depth_overhead += (1.0 /
test_episodes) * (circuit_depth - 1)
end_time = time_module.clock()
total_time = end_time - start_time
datapoint = (nrows, ncols, average_circuit_depth_overhead, total_time)
print('Completed run:', datapoint)
return datapoint
from agents.model_trainer import train_model
from agents.swap_scheduler import schedule_swaps
start_time = time_module.clock()
experiment_name = "temp"
use_random_circuits = True
use_saved_model = False
nrows = 4
ncols = 4
if use_random_circuits:
circuit = GridEnvironment.generate_random_circuit(nrows*ncols,nrows*ncols)
circuit_generation_function = lambda: GridEnvironment.generate_random_circuit(nrows*ncols,nrows*ncols)
else:
circuit = []
for i in range(nrows*ncols):
if i % 2 == 0:
circuit.append([i+1])
else:
circuit.append([i-1])
if (nrows*ncols) % 2 == 1:
circuit[-1] = []
circuit_generation_function = None
import time as time_module
from multiprocessing import Pool, cpu_count
from agents.single_state_agent import SimpleDQNAgent
from environments.grid_environment import GridEnvironment
from agents.model_trainer import train_model
from agents.swap_scheduler import schedule_swaps
use_random_circuits = False
n_rows = 5
n_cols = 5
if use_random_circuits:
circuit = GridEnvironment.generate_random_circuit(n_rows * n_cols,
n_rows * n_cols)
else:
circuit = []
for i in range(n_rows * n_cols):
if i % 2 == 0:
circuit.append([i + 1])
else:
circuit.append([i - 1])
if (n_rows * n_cols) % 2 == 1:
circuit[-1] = []
print(circuit)
training_episodes = 400 if n_rows * n_cols >= 36 else 200
def circuit_generation_function():
return GridEnvironment.generate_random_circuit(n_rows * n_cols,
n_rows * n_cols)