def refinement(target,
num_qubits,
gate_size,
fun_vals,
loc_fixed,
refinement_distance=1e-7,
learning_rate=1e-6):
"""
Refines synthesized circuit to better implement the target unitary.
This is achieved by using fixed circuit structure (gate location)
and a more fine-grained optimizer.
Args:
target (np.ndarray): Target unitary
num_qubits (int): The target unitary's number of qubits
gate_size (int): number of active qubits in a gate
fun_vals (List[List[float]]): Gate function values
loc_fixed (List[Tuple[int]]): Gate locations
refinement_distance (float): Refinement's goal distance
learning_rate (float): Learning rate of the optimizer
Returns:
(List[List[float]]): Refined gate function values
"""
# #can read the arguments like this. python3 synthesize_qft4_refinement.py -n 1
# print("All arguments")
# print(sys.argv) # synthesize_qft4_refinement.py -n 1
# print("-n arguments")
# print(sys.argv[-1]) # 1
## n_cpus = sys.argv[-1];
tf.reset_default_graph()
reset_tensor_cache()
with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
layers = FixedGate("Gate%d" % 0,
num_qubits,
gate_size,
loc=loc_fixed[0],
fun_vals=fun_vals[0])
tensor = layers.get_tensor()
for i in range(1, len(fun_vals)):
with tf.device("/job:localhost/replica:0/task:%d/device:CPU:0" %
(i % n_cpus)):
layers = FixedGate("Gate%d" % i,
num_qubits,
gate_size,
loc=loc_fixed[i],
fun_vals=fun_vals[i])
tensor = tf.matmul(layers.get_tensor(), tensor)
"""
layers = [ FixedGate( "Gate%d" % i, num_qubits, gate_size,
loc = loc_fixed[i], fun_vals = fun_vals[i] )
for i in range( len( fun_vals ) ) ]
tensor = layers[0].get_tensor()
for layer in layers[1:]:
tensor = tf.matmul( layer.get_tensor(), tensor )
"""
with tf.device(tf.train.replica_device_setter(ps_tasks=n_cpus)):
loss_fn = hilbert_schmidt_distance(target, tensor)
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(loss_fn)
init_op = tf.global_variables_initializer()
loss_values = []
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
with tf.Session(config=tf.ConfigProto(
device_count={"CPU": n_cpus},
inter_op_parallelism_threads=n_cpus,
intra_op_parallelism_threads=1,
)) as sess:
#writer = tf.summary.FileWriter('./graphs', sess.graph) #visualize tensorflow graph
sess.run(init_op, options=run_options, run_metadata=run_metadata)
loss = sess.run(loss_fn,
options=run_options,
run_metadata=run_metadata)
logger.info("Starting refinement at %f distance." % loss)
for i in range(10000):
for j in range(50):
loss = sess.run([train_op, loss_fn],
options=run_options,
run_metadata=run_metadata)[1]
if loss < refinement_distance:
break
loss_values.append(loss)
logger.log(0, loss)
if len(loss_values) > 100:
min_value = np.min(loss_values[-100:])
max_value = np.max(loss_values[-100:])
# Plateau Detected
if max_value - min_value < 1e-5:
break
if len(loss_values) > 500:
min_value = np.min(loss_values[-500:])
max_value = np.max(loss_values[-500:])
# Plateau Detected
if max_value - min_value < 1e-3:
break
logger.info("Ending refinement at %f distance." % loss)
for device in run_metadata.step_stats.dev_stats:
device_name = device.device
print(device.device)
for node in device.node_stats:
print(" ", node.node_name)
return [l.get_fun_vals(sess) for l in layers]
def fixed_depth_exploration(target,
num_qubits,
gate_size,
fun_vals,
loc_vals,
lm,
exploration_distance=0.01,
learning_rate=0.01):
"""
Attempts to synthesize the target unitary with a fixed number
of gates of size gate_size.
Args:
target (np.ndarray): Target unitary
num_qubits (int): The target unitary's number of qubits
gate_size (int): number of active qubits in a gate
fun_vals (List[List[float]]): Gate function values
loc_vals (List[List[float]]): Gate location values
lm (LocationModel): The model that maps loc_vals to locations
exploration_distance (float): Exploration's goal distance
learning_rate (float): Learning rate of the optimizer
Returns:
(Tuple[bool, List[List[float]], List[List[float]]]):
True if succeeded in hitting exploration distance
and the final fun_vals and loc_vals
"""
tf.reset_default_graph()
reset_tensor_cache()
layers = [
GenericGate("Gate%d" % i,
num_qubits,
gate_size,
lm,
fun_vals[i],
loc_vals[i],
parity=(i + 1) % lm.num_buckets)
for i in range(len(fun_vals))
]
tensor = layers[0].get_tensor()
for layer in layers[1:]:
tensor = tf.matmul(layer.get_tensor(), tensor)
loss_fn = hilbert_schmidt_distance(target, tensor)
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(loss_fn)
init_op = tf.global_variables_initializer()
loss_values = []
with tf.Session() as sess:
sess.run(init_op)
while (True):
for i in range(20):
loss = sess.run([train_op, loss_fn])[1]
if loss < exploration_distance:
logger.info("Ending exploration at %f distance." % loss)
return (True, [l.get_fun_vals(sess) for l in layers],
[l.get_loc_vals(sess) for l in layers])
loss_values.append(loss)
logger.debug("Loss: %f" % loss)
if len(loss_values) > 100:
min_value = np.min(loss_values[-100:])
max_value = np.max(loss_values[-100:])
# Plateau Detected
if max_value - min_value < learning_rate / 10:
logger.debug("Ending exploration at %f distance." % loss)
return (False, [l.get_fun_vals(sess) for l in layers],
[l.get_loc_vals(sess) for l in layers])
if len(loss_values) > 500:
min_value = np.min(loss_values[-500:])
max_value = np.max(loss_values[-500:])
# Plateau Detected
if max_value - min_value < learning_rate:
logger.debug("Ending exploration at %f distance." % loss)
return (False, [l.get_fun_vals(sess) for l in layers],
[l.get_loc_vals(sess) for l in layers])
def refinement(target,
num_qubits,
gate_size,
fun_vals,
loc_fixed,
refinement_distance=1e-7,
learning_rate=1e-6):
"""
Refines synthesized circuit to better implement the target unitary.
This is achieved by using fixed circuit structure (gate location)
and a more fine-grained optimizer.
Args:
target (np.ndarray): Target unitary
num_qubits (int): The target unitary's number of qubits
gate_size (int): number of active qubits in a gate
fun_vals (List[List[float]]): Gate function values
loc_fixed (List[Tuple[int]]): Gate locations
refinement_distance (float): Refinement's goal distance
learning_rate (float): Learning rate of the optimizer
Returns:
(List[List[float]]): Refined gate function values
"""
tf.reset_default_graph()
reset_tensor_cache()
layers = [
FixedGate("Gate%d" % i,
num_qubits,
gate_size,
loc=loc_fixed[i],
fun_vals=fun_vals[i]) for i in range(len(fun_vals))
]
tensor = layers[0].get_tensor()
for layer in layers[1:]:
tensor = tf.matmul(layer.get_tensor(), tensor)
loss_fn = hilbert_schmidt_distance(target, tensor)
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(loss_fn)
init_op = tf.global_variables_initializer()
loss_values = []
with tf.Session() as sess:
sess.run(init_op)
loss = sess.run(loss_fn)
logger.info("Starting refinement at %f distance." % loss)
for i in range(10000):
for j in range(50):
loss = sess.run([train_op, loss_fn])[1]
if loss < refinement_distance:
break
loss_values.append(loss)
logger.log(0, loss)
if len(loss_values) > 100:
min_value = np.min(loss_values[-100:])
max_value = np.max(loss_values[-100:])
# Plateau Detected
if max_value - min_value < 1e-5:
break
if len(loss_values) > 500:
min_value = np.min(loss_values[-500:])
max_value = np.max(loss_values[-500:])
# Plateau Detected
if max_value - min_value < 1e-3:
break
logger.info("Ending refinement at %f distance." % loss)
return [l.get_fun_vals(sess) for l in layers]
def refinement ( target, num_qubits, gate_size, fun_vals, loc_fixed,
refinement_distance = 1e-7, learning_rate = 1e-6 ):
"""
Refines synthesized circuit to better implement the target unitary.
This is achieved by using fixed circuit structure (gate location)
and a more fine-grained optimizer.
Args:
target (np.ndarray): Target unitary
num_qubits (int): The target unitary's number of qubits
gate_size (int): number of active qubits in a gate
fun_vals (List[List[float]]): Gate function values
loc_fixed (List[Tuple[int]]): Gate locations
refinement_distance (float): Refinement's goal distance
learning_rate (float): Learning rate of the optimizer
Returns:
(List[List[float]]): Refined gate function values
"""
# #can read the arguments like this. python3 synthesize_qft4_refinement.py -n 1
# print("All arguments")
# print(sys.argv) # synthesize_qft4_refinement.py -n 1
# print("-n arguments")
# print(sys.argv[-1]) # 1
## n_cpus = sys.argv[-1];
if task_index != 0:
#1 set up server Done in front
#2 set up session_config
logger.info("set up ps session_config task index %f TODO:" %task_index)
sess = tf.Session(server.target,
config=tf.ConfigProto(
device_count={ "CPU": n_cpus },
inter_op_parallelism_threads=n_cpus,
intra_op_parallelism_threads=1,
))
logger.info("set up ps session_config task index %f Done:" %task_index)
'''#3 initialize variable on this shard
tf.reset_default_graph()
reset_tensor_cache()
layers = []
with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
layers.append(FixedGate( "Gate%d" % 0, num_qubits, gate_size, loc = loc_fixed[0], fun_vals = fun_vals[0] ))
tensor = layers[0].get_tensor()
each_num = np.ceil(len(fun_vals)/n_cpus)
for i in range(1, len(fun_vals)):
with tf.device("/job:localhost/replica:0/task:%d/device:CPU:0" % (i // each_num)):
layers.append( FixedGate( "Gate%d" % i, num_qubits, gate_size, loc = loc_fixed[i], fun_vals = fun_vals[i] ))
tensor = tf.matmul(layers[-1].get_tensor(), tensor)
# with tf.device(tf.train.replica_device_setter(ps_tasks = n_cpus)):
#with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
with tf.device(tf.train.replica_device_setter(worker_device="/job:localhost/replica:0/task:%d/device:CPU:0" % task_index, cluster=cluster)):
loss_fn = hilbert_schmidt_distance( target, tensor )
optimizer = tf.train.AdamOptimizer( learning_rate )
train_op = optimizer.minimize( loss_fn )
init_op = tf.global_variables_initializer()
loss_values = []
#4 sess.run(initizlizer)
with tf.Session(server.target, config=tf.ConfigProto( device_count={ "CPU": n_cpus }, inter_op_parallelism_threads=n_cpus, intra_op_parallelism_threads=1,)) as sess:
logger.info("server.target:%s" %server.target)
sess.run( init_op )
loss = sess.run( loss_fn )'''
#5 create done queue
queue = create_done_queue(task_index)
#6 dequeu all worker
sess.run(queue.dequeue())
logger.info("ps %d received done chief" %task_index)
else:
logger.info("task index %f inside refinement:" %task_index)
tf.reset_default_graph()
reset_tensor_cache()
layers = []
with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
layers.append(FixedGate( "Gate%d" % 0, num_qubits, gate_size, loc = loc_fixed[0], fun_vals = fun_vals[0] ))
tensor = layers[0].get_tensor()
each_num = np.ceil(len(fun_vals)/n_cpus)
for i in range(1, len(fun_vals)):
with tf.device("/job:localhost/replica:0/task:%d/device:CPU:0" % (i // each_num)):
layers.append( FixedGate( "Gate%d" % i, num_qubits, gate_size, loc = loc_fixed[i], fun_vals = fun_vals[i] ))
tensor = tf.matmul(layers[-1].get_tensor(), tensor)
"""
layers = [ FixedGate( "Gate%d" % i, num_qubits, gate_size,
loc = loc_fixed[i], fun_vals = fun_vals[i] )
for i in range( len( fun_vals ) ) ]
tensor = layers[0].get_tensor()
for layer in layers[1:]:
tensor = tf.matmul( layer.get_tensor(), tensor )
"""
# with tf.device(tf.train.replica_device_setter(ps_tasks = n_cpus)):
#with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
with tf.device(tf.train.replica_device_setter(worker_device="/job:localhost/replica:0/task:%d/device:CPU:0" % task_index, cluster=cluster)):
loss_fn = hilbert_schmidt_distance( target, tensor )
optimizer = tf.train.AdamOptimizer( learning_rate )
train_op = optimizer.minimize( loss_fn )
init_op = tf.global_variables_initializer()
loss_values = []
# run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
# run_metadata = tf.RunMetadata()
with tf.Session(server.target,
config=tf.ConfigProto(
device_count={ "CPU": n_cpus },
inter_op_parallelism_threads=n_cpus,
intra_op_parallelism_threads=1,
)) as sess:
#with tf.Session() as sess:
#writer = tf.summary.FileWriter('./graphs', sess.graph) #visualize tensorflow graph
#sess.run( init_op, options=run_options, run_metadata=run_metadata )
#loss = sess.run( loss_fn, options=run_options, run_metadata=run_metadata )
logger.info("server.target:%s" %server.target)
sess.run( init_op )
loss = sess.run( loss_fn )
logger.info( "Starting refinement at %f distance,task index %f" % (loss,task_index))
for i in range( 10000 ):
for j in range( 50 ):
loss = sess.run( [ train_op, loss_fn ] )[1]
#loss = sess.run( [ train_op, loss_fn ], options=run_options, run_metadata=run_metadata )[1]
if loss < refinement_distance:
break
loss_values.append( loss )
logger.log( 0, loss )
if len( loss_values ) > 100:
min_value = np.min( loss_values[-100:] )
max_value = np.max( loss_values[-100:] )
# Plateau Detected
if max_value - min_value < 1e-5:
break
if len( loss_values ) > 500:
min_value = np.min( loss_values[-500:] )
max_value = np.max( loss_values[-500:] )
# Plateau Detected
if max_value - min_value < 1e-3:
break
logger.info( "Ending refinement at %f distance.task index %f" % (loss,task_index) )
# for device in run_metadata.step_stats.dev_stats:
# device_name = device.device
# print(device.device)
# for node in device.node_stats:
# print(" ", node.node_name)"
logger.info("reach the end in refinement")
result = [ l.get_fun_vals( sess ) for l in layers ]
q_result = []
for r in range(n_cpus):
if r==0:
continue
else:
q_result.append(create_done_queue(r))
for q in q_result:
sess.run(q.enqueue(1))
return result
def fixed_depth_exploration(target,
num_qubits,
gate_size,
fun_vals,
loc_vals,
lm,
exploration_distance=0.01,
learning_rate=0.01):
"""
Attempts to synthesize the target unitary with a fixed number
of gates of size gate_size.
Args:
target (np.ndarray): Target unitary
num_qubits (int): The target unitary's number of qubits
gate_size (int): number of active qubits in a gate
fun_vals (List[List[float]]): Gate function values
loc_vals (List[List[float]]): Gate location values
lm (LocationModel): The model that maps loc_vals to locations
exploration_distance (float): Exploration's goal distance
learning_rate (float): Learning rate of the optimizer
Returns:
(Tuple[bool, List[List[float]], List[List[float]]]):
True if succeeded in hitting exploration distance
and the final fun_vals and loc_vals
"""
if rank != 0:
#1 set up server Done in front
#2 set up session_config
logger.info("set up ps session_config task index %f TODO:" %
task_index)
sess = tf.Session(server.target,
config=tf.ConfigProto(
device_count={"CPU": n_cpus},
inter_op_parallelism_threads=n_cpus,
intra_op_parallelism_threads=1,
))
logger.info("set up ps session_config task index %f Done:" %
task_index)
'''#3 initialize variable on this shard
tf.reset_default_graph()
reset_tensor_cache()
layers = []
with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
layers.append(FixedGate( "Gate%d" % 0, num_qubits, gate_size, loc = loc_fixed[0], fun_vals = fun_vals[0] ))
tensor = layers[0].get_tensor()
each_num = np.ceil(len(fun_vals)/n_cpus)
for i in range(1, len(fun_vals)):
with tf.device("/job:localhost/replica:0/task:%d/device:CPU:0" % (i // each_num)):
layers.append( FixedGate( "Gate%d" % i, num_qubits, gate_size, loc = loc_fixed[i], fun_vals = fun_vals[i] ))
tensor = tf.matmul(layers[-1].get_tensor(), tensor)
# with tf.device(tf.train.replica_device_setter(ps_tasks = n_cpus)):
#with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
with tf.device(tf.train.replica_device_setter(worker_device="/job:localhost/replica:0/task:%d/device:CPU:0" % task_index, cluster=cluster)):
loss_fn = hilbert_schmidt_distance( target, tensor )
optimizer = tf.train.AdamOptimizer( learning_rate )
train_op = optimizer.minimize( loss_fn )
init_op = tf.global_variables_initializer()
loss_values = []
#4 sess.run(initizlizer)
with tf.Session(server.target, config=tf.ConfigProto( device_count={ "CPU": n_cpus }, inter_op_parallelism_threads=n_cpus, intra_op_parallelism_threads=1,)) as sess:
logger.info("server.target:%s" %server.target)
sess.run( init_op )
loss = sess.run( loss_fn )'''
#5 create done queue
queue = create_done_queue(task_index)
#6 dequeu all worker
sess.run(queue.dequeue())
logger.info("ps %d received done chief" % task_index)
req = comm.irecv(source=0, tag=12)
result = req.wait()
return result
else:
tf.reset_default_graph()
reset_tensor_cache()
layers = []
with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
layers.append(
GenericGate("Gate%d" % 0,
num_qubits,
gate_size,
lm,
fun_vals[0],
loc_vals[0],
parity=(1) % lm.num_buckets))
tensor = layers[0].get_tensor()
#ceil(5/4) = 2
each_num = np.ceil(len(fun_vals) / n_cpus)
for i in range(1, len(fun_vals)):
#i // each_num = 0,0,1,1,2,2,3
with tf.device("/job:localhost/replica:0/task:%d/device:CPU:0" %
(i // each_num)):
layers.append(
GenericGate("Gate%d" % i,
num_qubits,
gate_size,
lm,
fun_vals[i],
loc_vals[i],
parity=(i + 1) % lm.num_buckets))
tensor = tf.matmul(layers[-1].get_tensor(), tensor)
"""
layers = [ GenericGate( "Gate%d" % i, num_qubits, gate_size, lm,
fun_vals[i], loc_vals[i],
parity = (i + 1) % lm.num_buckets )
for i in range( len( fun_vals ) ) ]
tensor = layers[0].get_tensor()
for layer in layers[1:]:
tensor = tf.matmul( layer.get_tensor(), tensor )
"""
with tf.device(
tf.train.replica_device_setter(
worker_device=
"/job:localhost/replica:0/task:%d/device:CPU:0" %
task_index,
cluster=cluster)):
#with tf.device("/job:localhost/replica:0/task:0/device:CPU:0"):
loss_fn = hilbert_schmidt_distance(target, tensor)
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(loss_fn)
init_op = tf.global_variables_initializer()
loss_values = []
#with tf.Session() as sess:
with tf.Session(server.target,
config=tf.ConfigProto(
device_count={"CPU": n_cpus},
inter_op_parallelism_threads=n_cpus,
intra_op_parallelism_threads=1,
)) as sess:
sess.run(init_op)
while (True):
for i in range(20):
loss = sess.run([train_op, loss_fn])[1]
if loss < exploration_distance:
logger.info("Ending exploration at %f distance." % loss)
result = (True, [l.get_fun_vals(sess) for l in layers],
[l.get_loc_vals(sess) for l in layers])
q_result = []
for r in range(n_cpus):
if r == 0:
continue
else:
q_result.append(create_done_queue(r))
for q in q_result:
sess.run(q.enqueue(1))
for rank_ in range(n_cpus):
if rank_ == 0:
continue
else:
req = comm.isend(result, dest=rank_, tag=12)
req.wait()
return result
loss_values.append(loss)
logger.debug("Loss: %f" % loss)
if len(loss_values) > 100:
min_value = np.min(loss_values[-100:])
max_value = np.max(loss_values[-100:])
# Plateau Detected
if max_value - min_value < learning_rate / 10:
logger.debug("Ending exploration at %f distance." %
loss)
result = (False,
[l.get_fun_vals(sess) for l in layers
], [l.get_loc_vals(sess) for l in layers])
q_result = []
for r in range(n_cpus):
if r == 0:
continue
else:
q_result.append(create_done_queue(r))
for q in q_result:
sess.run(q.enqueue(1))
for rank_ in range(n_cpus):
if rank_ == 0:
continue
else:
req = comm.isend(result, dest=rank_, tag=12)
req.wait()
return result
if len(loss_values) > 500:
min_value = np.min(loss_values[-500:])
max_value = np.max(loss_values[-500:])
# Plateau Detected
if max_value - min_value < learning_rate:
logger.debug("Ending exploration at %f distance." %
loss)
result = (False,
[l.get_fun_vals(sess) for l in layers
], [l.get_loc_vals(sess) for l in layers])
q_result = []
for r in range(n_cpus):
if r == 0:
continue
else:
q_result.append(create_done_queue(r))
for q in q_result:
sess.run(q.enqueue(1))
for rank_ in range(n_cpus):
if rank_ == 0:
continue
else:
req = comm.isend(result, dest=rank_, tag=12)
req.wait()
return result