def test_state_shape_and_dtype(backend): state = states.VectorState.zero_state(3) assert state.shape == (8, ) assert state.dtype == K.dtypes('DTYPECPX') state = states.MatrixState.zero_state(3) assert state.shape == (8, 8) assert state.dtype == K.dtypes('DTYPECPX')
def test_state_shape_and_dtype(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) state = states.VectorState.zero_state(3) assert state.shape == (8, ) assert state.dtype == K.dtypes('DTYPECPX') state = states.MatrixState.zero_state(3) assert state.shape == (8, 8) assert state.dtype == K.dtypes('DTYPECPX') qibo.set_backend(original_backend)
def test_variable_backpropagation(backend): if backend == "custom": pytest.skip("Custom gates do not support automatic differentiation.") original_backend = qibo.get_backend() qibo.set_backend(backend) if K.name != "tensorflow": qibo.set_backend(original_backend) pytest.skip("Backpropagation is not supported by {}.".format(K.name)) theta = K.optimization.Variable(0.1234, dtype=K.dtypes('DTYPE')) # TODO: Fix parametrized gates so that `Circuit` can be defined outside # of the gradient tape with K.optimization.GradientTape() as tape: c = Circuit(1) c.add(gates.X(0)) c.add(gates.RZ(0, theta)) loss = K.real(c()[-1]) grad = tape.gradient(loss, theta) target_loss = np.cos(theta / 2.0) np.testing.assert_allclose(loss, target_loss) target_grad = -np.sin(theta / 2.0) / 2.0 np.testing.assert_allclose(grad, target_grad) qibo.set_backend(original_backend)
def test_two_variables_backpropagation(backend): if backend == "custom": pytest.skip("Custom gates do not support automatic differentiation.") original_backend = qibo.get_backend() qibo.set_backend(backend) if "numpy" in K.name: qibo.set_backend(original_backend) pytest.skip("Backpropagation is not supported by {}.".format(K.name)) theta = K.optimization.Variable([0.1234, 0.4321], dtype=K.dtypes('DTYPE')) # TODO: Fix parametrized gates so that `Circuit` can be defined outside # of the gradient tape with K.optimization.GradientTape() as tape: c = Circuit(2) c.add(gates.RX(0, theta[0])) c.add(gates.RY(1, theta[1])) loss = K.real(c()[0]) grad = tape.gradient(loss, theta) t = np.array([0.1234, 0.4321]) / 2.0 target_loss = np.cos(t[0]) * np.cos(t[1]) np.testing.assert_allclose(loss, target_loss) target_grad1 = -np.sin(t[0]) * np.cos(t[1]) target_grad2 = -np.cos(t[0]) * np.sin(t[1]) target_grad = np.array([target_grad1, target_grad2]) / 2.0 np.testing.assert_allclose(grad, target_grad) qibo.set_backend(original_backend)
def test_variable_theta(backend): """Check that parametrized gates accept `tf.Variable` parameters.""" backend = qibo.get_backend() if backend != "tensorflow": pytest.skip("Numpy backends do not support variable parameters.") theta1 = K.optimization.Variable(0.1234, dtype=K.dtypes('DTYPE')) theta2 = K.optimization.Variable(0.4321, dtype=K.dtypes('DTYPE')) cvar = Circuit(2) cvar.add(gates.RX(0, theta1)) cvar.add(gates.RY(1, theta2)) final_state = cvar() c = Circuit(2) c.add(gates.RX(0, 0.1234)) c.add(gates.RY(1, 0.4321)) target_state = c() K.assert_allclose(final_state, target_state)
def plus_state(cls, circuit): """Creates ``|++...+>`` as a distributed state.""" state = cls(circuit) with K.on_cpu(): n = K.cast(2**state.nlocal, dtype=K.dtypes('DTYPEINT')) norm = K.cast(2**float(state.nqubits / 2.0)) state.pieces = [ K.cpu_tensor(K.ones(n) / norm) for _ in range(state.ndevices) ] return state
def test_state_set_measurements(registers): from qibo import gates state = states.VectorState.zero_state(3) samples = K.cast(50 * [0] + 50 * [1], dtype=K.dtypes("DTYPEINT")) state.set_measurements([0, 2], samples, registers) target_samples = np.array(50 * [[0, 0]] + 50 * [[0, 1]]) K.assert_allclose(state.samples(), target_samples) assert state.frequencies() == {"00": 50, "01": 50} if registers is not None: target_freqs = {"a": {"0": 100}, "b": {"0": 50, "1": 50}} else: target_freqs = {"00": 50, "01": 50} assert state.frequencies(registers=True) == target_freqs
def test_variable_theta(backend): """Check that parametrized gates accept `tf.Variable` parameters.""" if "numpy" in backend: pytest.skip("Numpy backends do not support variable parameters.") from qibo import K original_backend = qibo.get_backend() qibo.set_backend(backend) theta1 = K.optimization.Variable(0.1234, dtype=K.dtypes('DTYPE')) theta2 = K.optimization.Variable(0.4321, dtype=K.dtypes('DTYPE')) cvar = Circuit(2) cvar.add(gates.RX(0, theta1)) cvar.add(gates.RY(1, theta2)) final_state = cvar() c = Circuit(2) c.add(gates.RX(0, 0.1234)) c.add(gates.RY(1, 0.4321)) target_state = c() np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_set_precision(backend, precision): original_precision = backends.get_precision() backends.set_precision(precision) if precision == "single": expected_dtype = K.backend.complex64 else: expected_dtype = K.backend.complex128 assert backends.get_precision() == precision assert K.dtypes('DTYPECPX') == expected_dtype # Test that circuits use proper precision circuit = models.Circuit(2) circuit.add([gates.H(0), gates.H(1)]) final_state = circuit() assert final_state.dtype == expected_dtype backends.set_precision(original_precision)
def test_hamiltonian_initialization(): """Testing hamiltonian initialization errors.""" import tensorflow as tf dtype = K.dtypes('DTYPECPX') with pytest.raises(TypeError): H = Hamiltonian(2, "test") H1 = Hamiltonian(2, np.eye(4)) H1 = Hamiltonian(2, np.eye(4), numpy=True) H1 = Hamiltonian(2, tf.eye(4, dtype=dtype)) H1 = Hamiltonian(2, tf.eye(4, dtype=dtype), numpy=True) with pytest.raises(ValueError): H1 = Hamiltonian(-2, np.eye(4)) with pytest.raises(RuntimeError): H2 = Hamiltonian(np.eye(2), np.eye(4)) with pytest.raises(ValueError): H3 = Hamiltonian(4, np.eye(10))
def tensor(self, x): if not isinstance(x, K.Tensor): if isinstance(x, K.qnp.tensor_types): x = K.cast(x) else: raise_error( TypeError, "Initial state type {} is not recognized." "".format(type(x))) if x.dtype != K.dtypes('DTYPECPX'): x = K.cast(x) shape = tuple(x.shape) if self._nqubits is None: self.nqubits = int(K.np.log2(shape[0])) if shape != self.shape: raise_error( ValueError, "Invalid tensor shape {} for state of {} " "qubits.".format(shape, self.nqubits)) self._tensor = x
def test_variable_backpropagation(backend): if not K.supports_gradients: pytest.skip("Backpropagation is not supported by {}.".format(K.name)) theta = K.optimization.Variable(0.1234, dtype=K.dtypes('DTYPE')) # TODO: Fix parametrized gates so that `Circuit` can be defined outside # of the gradient tape with K.optimization.GradientTape() as tape: c = Circuit(1) c.add(gates.X(0)) c.add(gates.RZ(0, theta)) loss = K.real(c()[-1]) grad = tape.gradient(loss, theta) target_loss = np.cos(theta / 2.0) K.assert_allclose(loss, target_loss) target_grad = -np.sin(theta / 2.0) / 2.0 K.assert_allclose(grad, target_grad)
def test_two_variables_backpropagation(backend): if not K.supports_gradients: pytest.skip("Backpropagation is not supported by {}.".format(K.name)) theta = K.optimization.Variable([0.1234, 0.4321], dtype=K.dtypes('DTYPE')) # TODO: Fix parametrized gates so that `Circuit` can be defined outside # of the gradient tape with K.optimization.GradientTape() as tape: c = Circuit(2) c.add(gates.RX(0, theta[0])) c.add(gates.RY(1, theta[1])) loss = K.real(c()[0]) grad = tape.gradient(loss, theta) t = np.array([0.1234, 0.4321]) / 2.0 target_loss = np.cos(t[0]) * np.cos(t[1]) K.assert_allclose(loss, target_loss) target_grad1 = -np.sin(t[0]) * np.cos(t[1]) target_grad2 = -np.cos(t[0]) * np.sin(t[1]) target_grad = np.array([target_grad1, target_grad2]) / 2.0 K.assert_allclose(grad, target_grad)
def _convert_to_decimal(self): _range = K.range(self.nqubits - 1, -1, -1, dtype=K.dtypes('DTYPEINT')) _range = K.pow(2, _range)[:, K.newaxis] return K.matmul(self.binary, _range)[:, 0]
def _convert_to_binary(self): _range = K.range(self.nqubits - 1, -1, -1, dtype=K.dtypes('DTYPEINT')) return K.mod(K.right_shift(self.decimal[:, K.newaxis], _range), 2)