def test_parameter_wrapping_parameters(): """Tests that ensure wrapping works with other parameters""" var = 5 var = Parameter(var) res = Parameter._wrap(var) assert isinstance(res, Parameter) assert res.x == var
def test_parameter_wrapping(self): """Tests that ensure wrapping occurs as expected""" self.logTestName() var = 5 res = Parameter._wrap(var) self.assertTrue(isinstance(res, Parameter)) self.assertEqual(res.x, var) var = Parameter(var) res = Parameter._wrap(var) self.assertTrue(isinstance(res, Parameter)) self.assertEqual(res.x, var)
def test_parameter_shape(self): """Tests that ensure wrapping occurs as expected""" self.logTestName() var = Parameter(5) res = var.shape self.assertTrue(res is None) var = np.array([[1, 2, 3], [4, 5, 6]]) p = Parameter(var) res = p.shape self.assertEqual(res, (2, 3)) p = Parameter(tf.convert_to_tensor(var)) res = p.shape self.assertEqual(res, (2, 3))
def f(q): if np.any(q.x == np.inf): # detect the HACK if f.v is None: # only construct one instance, only when needed f.v = Parameter( tf.Variable(0.8, name="sf_parameter")) return f.v return q
def test_init(self): "Parameter initialization and arithmetic." self.logTestName() # at the moment RR-inputs cannot be arithmetically combined with the others # immediate Parameter class inputs: # ints, floats and complex numbers # numpy arrays # TensorFlow objects of various types par_inputs = [ 3, 0.14, 4.2 + 0.5j, random(3), tf.Variable(2), tf.Variable(0.4), tf.Variable(0.8 + 1.1j) ] pars = [Parameter(k) for k in par_inputs] # wrapped versions def check(p, q): "Check all arithmetic operations on a two-Parameter combination." #print(p, q) self.assertTrue(isinstance(p + q, Parameter)) self.assertTrue(isinstance(p - q, Parameter)) self.assertTrue(isinstance(p * q, Parameter)) self.assertTrue(isinstance(p / q, Parameter)) self.assertTrue(isinstance(p**q, Parameter)) ## binary methods # all combinations of two Parameter types for p in itertools.product(pars, repeat=2): check(*p) # all combinations a Parameter and an unwrapped input for p in itertools.product(pars, par_inputs): check(*p) for p in itertools.product(par_inputs, pars): check(*p) ## unary methods for p in pars: self.assertTrue(isinstance(-p, Parameter))
def test_parameters_with_operations(batch_size, setup_eng, backend, hbar): """Test using different types of Parameters with different classes of ParOperations.""" # TODO: this test is very hard to understand. Should be split up, # and separated into many individual tests that do one thing only. # TODO: In the original test suite, this test appears to 'work' on the # Gaussian backend, even though it never explicitly ignores non-Gaussian # operations. It even worked on the Fock backends, even though the Fock # backend doesn't support the ThermalLoss channel?! # TODO: This test doesn't assert anything!!!!! eng, prog = setup_eng(2) r = prog.register @sf.convert def func1(x): return abs(2 * x**2 - 3 * x + 1) @sf.convert def func2(x, y): return abs(2 * x * y - y**2 + 0.5) kwargs = {} # RegRefTransforms for deferred measurements (note that some operations # expect nonnegative parameter values) rr_inputs = [ops.RR(r[0], lambda x: x**2), func1(r[0]), func2(*r)] rr_pars = tuple(Parameter(k) for k in rr_inputs) # other types of parameters other_inputs = [0.14] if isinstance(eng.backend, TFBackend): # HACK: add placeholders for tf.Variables other_inputs.append(np.inf) if batch_size is not None: # test batched input other_inputs.append(np.random.uniform(size=(batch_size, ))) other_pars = tuple(Parameter(k) for k in other_inputs) def check(G, par, measure=False): """Check a ParOperation/Parameters combination""" # construct the op using the given tuple of Parameters as args G = G(*par) with prog: if measure: r[0].val = 0.1 r[1].val = 0.2 if G.ns == 1: G | r[0] else: G | (r[0], r[1]) prog.optimize() try: eng.run(prog, **kwargs) except NotApplicableError as err: # catch unapplicable op/backend combinations here logging.debug(err) # unsuccessful run means the queue was not emptied. eng.reset_queue() except NotImplementedError as err: # catch not yet implemented op/backend combinations here logging.debug(err) # unsuccessful run means the queue was not emptied. eng.reset_queue() prog.locked = False scalar_arg_preparations = ( ops.Coherent, ops.Squeezed, ops.DisplacedSqueezed, ops.Thermal, ops.Catstate, ) # Fock requires an integer parameter testset = set(ops.one_args_gates + ops.two_args_gates + ops.channels + scalar_arg_preparations) - {ops.ThermalLossChannel} print(testset) for G in testset: sig = inspect.signature(G.__init__) n_args = (len(sig.parameters) - 1 ) # number of parameters __init__ takes, minus self if n_args < 1: logging.debug( "Unexpected number of args ({}) for {}, check the testset.". format(n_args, G)) # shortcut, only test cartesian products up to two parameter types # n_args = min(n_args, 2) # check all combinations of Parameter types for p in itertools.product(rr_pars + other_pars, repeat=n_args): # TODO: For now decompose() works on unevaluated Parameters. # This causes an error if a :class:`.RegRefTransform`-based Parameter is used, and # decompose() tries to do arithmetic on it. if isinstance(p[0].x, ops.RR): continue if isinstance(eng.backend, TFBackend): # declare tensorflow Variables here (otherwise they will be on a different graph when we do backend.reset below) # replace placeholders with tf.Variable instances def f(q): if np.any(q.x == np.inf): # detect the HACK if f.v is None: # only construct one instance, only when needed f.v = Parameter( tf.Variable(0.8, name="sf_parameter")) return f.v return q f.v = None # kind of like a static variable in a function in C p = tuple(map(f, p)) # create new tf.Session (which will be associated with the default graph) and initialize variables session = tf.Session() kwargs["session"] = session session.run(tf.global_variables_initializer()) check(G, p, measure=True) session.close() else: check(G, p, measure=True) eng.backend.reset()
def test_parameter_shape_tf(): """Tests that ensure wrapping occurs as expected""" var = np.array([[1, 2, 3], [4, 5, 6]]) p = Parameter(tf.convert_to_tensor(var)) res = p.shape assert res == (2, 3)
def test_parameter_no_shape(): """Tests that ensure wrapping occurs as expected""" var = Parameter(5) res = var.shape assert res is None
def test_parameter_wrapping_integer(): """Tests that ensure wrapping works with integers""" var = 5 res = Parameter._wrap(var) assert isinstance(res, Parameter) assert res.x == var
np.random.random(32) TEST_VALUES = [3, 0.14, 4.2 + 0.5j, np.random.random(3)] try: import tensorflow as tf except (ImportError, ModuleNotFoundError) as e: tf_available = False else: tf_available = True TEST_VALUES.extend( [tf.Variable(2), tf.Variable(0.4), tf.Variable(0.8 + 1.1j)]) TEST_PARAMETERS = [Parameter(i) for i in TEST_VALUES] def test_parameter_wrapping_integer(): """Tests that ensure wrapping works with integers""" var = 5 res = Parameter._wrap(var) assert isinstance(res, Parameter) assert res.x == var def test_parameter_wrapping_parameters(): """Tests that ensure wrapping works with other parameters""" var = 5 var = Parameter(var) res = Parameter._wrap(var)