def build_circuit(self): # params_counter = 0 sgates = [] dgates = [] kgates = [] for gate_structure in self.gates_structure: if gate_structure[0] is Sgate: sgates.append( ParametrizedGate(gate_structure[0], gate_structure[1], [ make_param(**gate_structure[2]), make_param(**gate_structure[3]) ])) if gate_structure[0] is Dgate: dgates.append( ParametrizedGate(gate_structure[0], gate_structure[1], [ make_param(**gate_structure[2]), make_param(**gate_structure[3]) ])) if gate_structure[0] is Kgate: kgates.append( ParametrizedGate(gate_structure[0], gate_structure[1], [make_param(**gate_structure[2])])) eng, q = sf.Engine(self.n_qumodes) rl, U = takagi(self.adj_matrix) initial_squeezings = np.arctanh(rl) with eng: for i, squeeze_value in enumerate(initial_squeezings): Sgate(squeeze_value) | i Interferometer(U) | q for gate in sgates: gate.gate(gate.params[0], gate.params[1]) | gate.qumodes Interferometer(self.interferometer_matrix) | q for gate in dgates: gate.gate(gate.params[0], gate.params[1]) | gate.qumodes Interferometer(self.interferometer_matrix) | q for gate in kgates: gate.gate(gate.params[0]) | gate.qumodes circuit = {} circuit['eng'] = eng circuit['q'] = q return circuit
def circuit(X): params = [ make_param(name='phi', constant=2.), make_param(name="theta", constant=1.), make_param(name="theta2", constant=.1), make_param(name="theta3", constant=.1), make_param(name="theta4", constant=.1), make_param(name="theta5", constant=.1), make_param(name="theta6", constant=.1), make_param(name="theta7", constant=.1), make_param(name="theta8", constant=.1), make_param(name="theta9", constant=.1), ] eng, q = sf.Engine(2) with eng: Dgate(X[:, 0], 0.) | q[0] Dgate(X[:, 1], 0.) | q[1] BSgate(phi=params[0]) | (q[0], q[1]) BSgate() | (q[0], q[1]) Vgate(params[1]) | q[0] Vgate(params[2]) | q[1] num_inputs = X.get_shape().as_list()[0] state = eng.run('tf', cutoff_dim=10, eval=False, batch_size=num_inputs) p0 = state.fock_prob([0, 2]) p1 = state.fock_prob([2, 0]) normalization = p0 + p1 + 1e-10 output1 = p1 / normalization with eng: X1 = output1 Dgate(X1, 0.) | q[0] Dgate(0., X1) | q[1] BSgate(phi=params[1]) | (q[0], q[1]) BSgate() | (q[0], q[1]) Vgate(params[5]) | q[0] Vgate(params[6]) | q[1] num_inputs1 = X1.get_shape().as_list()[0] state2 = eng.run('tf', cutoff_dim=10, eval=False, batch_size=num_inputs1) p00 = state2.fock_prob([0, 2]) p01 = state2.fock_prob([2, 0]) normalization1 = p00 + p01 + 1e-10 circuit_output = p01 / normalization1 return circuit_output
def circuit(X): # Create a parameter with an initial value of 2. params = [make_param(name='phi', constant=2.)] eng, q = sf.Engine(2) with eng: # Note that we are feeding 1-d tensors into gates, not scalars! Dgate(X[:, 0], 0.) | q[0] Dgate(X[:, 1], 0.) | q[1] BSgate(phi=params[0]) | (q[0], q[1]) BSgate() | (q[0], q[1]) # We have to tell the engine how big the batches (first dim of X) are # which we feed into gates num_inputs = X.get_shape().as_list()[0] state = eng.run('tf', cutoff_dim=10, eval=False, batch_size=num_inputs) # Define the output as the probability of measuring |0,2> as opposed to |2,0> p0 = state.fock_prob([0, 2]) p1 = state.fock_prob([2, 0]) normalization = p0 + p1 + 1e-10 circuit_output = p1 / normalization return circuit_output
def circuit(): phi = make_param(name='phi', stdev=0.2, regularize=False) theta = make_param(name='theta', stdev=0.2, regularize=False) a = make_param(name='a', stdev=0.2, regularize=True, monitor=True) rtheta = make_param(name='rtheta', stdev=0.2, regularize=False, monitor=True) r = make_param(name='r', stdev=0.2, regularize=True, monitor=True) kappa = make_param(name='kappa', stdev=0.2, regularize=True, monitor=True) eng, q = sf.Engine(2) with eng: BSgate(phi, theta) | (q[0], q[1]) Dgate(a) | q[0] Rgate(rtheta) | q[0] Sgate(r) | q[0] Kgate(kappa) | q[0] state = eng.run('tf', cutoff_dim=7, eval=False) circuit_output = state.all_fock_probs() return circuit_output
def circuit(X): # Create a parameter with an initial value of 2. params = [make_param(name='phi', constant=2.), make_param(name="theta", constant=1.), make_param(name="theta2", constant=.1), make_param(name="theta3", constant=.1), make_param(name="theta4", constant=.1), make_param(name="theta5", constant=.1), make_param(name="theta6", constant=.1), make_param(name="theta7", constant=.1), make_param(name="theta8", constant=.1), make_param(name="theta9", constant=.1),] eng, q = sf.Engine(2) with eng: # Note that we are feeding 1-d tensors into gates, not scalars! Dgate(X[:, 0], 0.) | q[0] Dgate(X[:, 1], 0.) | q[1] BSgate(phi=params[0]) | (q[0], q[1]) BSgate() | (q[0], q[1]) Vgate(params[1]) | q[0] Vgate(params[2]) | q[1]
def circuit(): # Create a parameter with an initial value of 0.1 params = [make_param(name='alpha', constant=0.1)] eng, q = sf.Engine(1) with eng: Dgate(params[0]) | q[0] state = eng.run('tf', cutoff_dim=7, eval=False) # As the output we take the probability of measuring one photon in the mode prob = state.fock_prob([1]) circuit_output = tf.identity(prob, name="prob") return circuit_output
def circuit(X): phi = make_param('phi', constant=2.) eng, q = sf.Engine(2) with eng: Dgate(X[:, 0], 0.) | q[0] Dgate(X[:, 1], 0.) | q[1] BSgate(phi=phi) | (q[0], q[1]) BSgate() | (q[0], q[1]) num_inputs = X.get_shape().as_list()[0] state = eng.run('tf', cutoff_dim=10, eval=False, batch_size=num_inputs) p0 = state.fock_prob([0, 2]) p1 = state.fock_prob([2, 0]) normalisation = p0 + p1 + 1e-10 circuit_output = p1 / normalisation return circuit_output
def circuit(): # Create parameters for 'depth' number of layers. # Mark some of them to be regularized and some to be monitored. phi = make_param(name='phi', stdev=0.2, shape=[depth], regularize=False) theta = make_param(name='theta', stdev=0.2, shape=[depth], regularize=False) a = make_param(name='a', stdev=0.2, shape=[depth], regularize=True, monitor=True) rtheta = make_param(name='rtheta', stdev=0.2, shape=[depth], regularize=False, monitor=True) r = make_param(name='r', stdev=0.2, shape=[depth], regularize=True, monitor=True) kappa = make_param(name='kappa', stdev=0.2, shape=[depth], regularize=True, monitor=True) # Define a single layer of gates def layer(l): BSgate(phi[l], theta[l]) | (q[0], q[1]) Dgate(a[l]) | q[0] Rgate(rtheta[l]) | q[0] Sgate(r[l]) | q[0] Kgate(kappa[l]) | q[0] eng, q = sf.Engine(2) with eng: # Make depth layers for d in range(depth): layer(d) state = eng.run('tf', cutoff_dim=7, eval=False) circuit_output = state.all_fock_probs() return circuit_output
def circuit(): # This time we want to keep the parameter small via regularization and visualize its evolution in tensorboard params = [ make_param(name='alpha', constant=0.1, regularize=True, monitor=True) ] eng, q = sf.Engine(1) with eng: Dgate(params[0]) | q[0] state = eng.run('tf', cutoff_dim=7, eval=False) circuit_output = state.fock_prob([1]) # The identity() function allows us to give this tensor a name # which we can refer to below circuit_output = tf.identity(circuit_output, name="prob") trace = tf.identity(state.trace(), name='trace') return circuit_output
def circuit(X): num_qubits = X.get_shape().as_list()[1] phi_1 = make_param(name='phi_1', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False) theta_1 = make_param(name='theta_1', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False) a = make_param(name='a', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False, monitor=True) rtheta_1 = make_param(name='rtheta_1', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False, monitor=True) r = make_param(name='r', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False, monitor=True) kappa = make_param(name='kappa', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False, monitor=True) phi_2 = make_param(name='phi_2', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False) theta_2 = make_param(name='theta_2', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False) rtheta_2 = make_param(name='rtheta_2', stdev=np.sqrt(2) / num_qubits, shape=[depth, num_qubits], regularize=False, monitor=True) def layer(i, size): Rgate(rtheta_1[i, 0]) | (q[0]) BSgate(phi_1[i, 0], 0) | (q[0], q[1]) Rgate(rtheta_1[i, 2]) | (q[1]) for j in range(size): Sgate(r[i, j]) | q[j] Rgate(rtheta_2[i, 0]) | (q[0]) BSgate(phi_2[i, 0], 0) | (q[0], q[1]) Rgate(rtheta_2[i, 2]) | (q[2]) BSgate(phi_2[i, 2], theta_2[i, 3]) | (q[2], q[3]) Rgate(rtheta_2[i, 1]) | (q[1]) BSgate(phi_2[i, 1], 0) | (q[1], q[2]) Rgate(rtheta_2[i, 0]) | (q[0]) BSgate(phi_2[i, 0], 0) | (q[0], q[1]) Rgate(rtheta_2[i, 0]) | (q[0]) Rgate(rtheta_2[i, 1]) | (q[1]) Rgate(rtheta_2[i, 2]) | (q[2]) Rgate(rtheta_2[i, 3]) | (q[3]) BSgate(phi_2[i, 2], 0) | (q[2], q[3]) Rgate(rtheta_2[i, 2]) | (q[2]) BSgate(phi_2[i, 1], 0) | (q[1], q[2]) Rgate(rtheta_2[i, 1]) | (q[1]) for j in range(size): Kgate(kappa[i, j]) | q[j] eng, q = sf.Engine(num_qubits) with eng: for i in range(num_qubits): Dgate(X[:, i], 0.) | q[i] for d in range(depth): layer(d, num_qubits) num_inputs = X.get_shape().as_list()[0] state = eng.run('tf', cutoff_dim=10, eval=False, batch_size=num_inputs) circuit_output, var0 = state.quad_expectation(0) return circuit_output
def build_circuit(self, adj_matrix): params_counter = 0 number_of_layers = 2 all_sgates = [[]] * number_of_layers all_dgates = [[]] * number_of_layers all_kgates = [[]] * number_of_layers all_vgates = [[]] * number_of_layers for gate_structure in self.gates_structure: current_layer = int(gate_structure[2]['name'].split('_')[-1][0]) if gate_structure[0] is Sgate: current_gate = ParametrizedGate( gate_structure[0], gate_structure[1], [ make_param(**gate_structure[2]), make_param(**gate_structure[3]) ]) all_sgates[current_layer].append(current_gate) if gate_structure[0] is Dgate: current_gate = ParametrizedGate( gate_structure[0], gate_structure[1], [ make_param(**gate_structure[2]), make_param(**gate_structure[3]) ]) all_dgates[current_layer].append(current_gate) if gate_structure[0] is Kgate: current_gate = ParametrizedGate( gate_structure[0], gate_structure[1], [make_param(**gate_structure[2])]) all_kgates[current_layer].append(current_gate) if gate_structure[0] is Vgate: current_gate = ParametrizedGate( gate_structure[0], gate_structure[1], [make_param(**gate_structure[2])]) all_vgates[current_layer].append(current_gate) eng, q = sf.Engine(self.n_qumodes) rl, U = takagi(adj_matrix) initial_squeezings = np.arctanh(rl) with eng: for i, squeeze_value in enumerate(initial_squeezings): Sgate(squeeze_value) | i Interferometer(U) | q for layer in range(number_of_layers): sgates = all_sgates[layer] dgates = all_dgates[layer] kgates = all_kgates[layer] vgates = all_vgates[layer] if len(sgates) != 0: Interferometer(self.interferometer_matrix) | q for gate in sgates: gate.gate(gate.params[0], gate.params[1]) | gate.qumodes if len(dgates) != 0: Interferometer(self.interferometer_matrix) | q for gate in dgates: gate.gate(gate.params[0], gate.params[1]) | gate.qumodes for gate in kgates: gate.gate(gate.params[0]) | gate.qumodes for gate in vgates: gate.gate(gate.params[0]) | gate.qumodes circuit = {} circuit['eng'] = eng circuit['q'] = q return circuit