def test_soft_num_reads(self): """Number of reads adapts to initial_states size, if provided.""" bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': 1, 'ac': 1 }) init = dimod.SampleSet.from_samples_bqm([{ 'a': 1, 'b': 1, 'c': 1 }, { 'a': -1, 'b': -1, 'c': -1 }], bqm) # default num_reads == 1 self.assertEqual(len(tabu.TabuSampler().sample(bqm)), 1) # with initial_states, num_reads == len(initial_states) self.assertEqual( len(tabu.TabuSampler().sample(bqm, initial_states=init)), 2) # if explicitly given, with initial_states, they are expanded self.assertEqual( len(tabu.TabuSampler().sample(bqm, initial_states=init, num_reads=3)), 3) # if explicitly given, without initial_states, they are generated self.assertEqual(len(tabu.TabuSampler().sample(bqm, num_reads=4)), 4)
def test_initial_states_smoketest(self): bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': 1, 'ac': 1 }) resp = tabu.TabuSampler().sample( bqm, initial_states=tabu.TabuSampler().sample(bqm)) dimod.testing.assert_response_energies(resp, bqm)
def test_empty(self): resp = tabu.TabuSampler().sample(dimod.BinaryQuadraticModel.empty(dimod.SPIN)) dimod.testing.assert_response_energies(resp, dimod.BinaryQuadraticModel.empty(dimod.SPIN)) resp = tabu.TabuSampler().sample(dimod.BinaryQuadraticModel.empty(dimod.BINARY)) dimod.testing.assert_response_energies(resp, dimod.BinaryQuadraticModel.empty(dimod.BINARY)) resp = tabu.TabuSampler().sample_qubo({}) dimod.testing.assert_response_energies(resp, dimod.BinaryQuadraticModel.empty(dimod.BINARY)) resp = tabu.TabuSampler().sample_ising({}, {}) dimod.testing.assert_response_energies(resp, dimod.BinaryQuadraticModel.empty(dimod.SPIN))
def test_seed(self): sampler = tabu.TabuSampler() bqm = dimod.generators.random.randint(1000, 'SPIN', seed=123) tenure = 5 all_samples = [] for seed in (1, 25, 2352): response0 = sampler.sample(bqm, num_reads=1, tenure=tenure, num_restarts=1, timeout=None, seed=seed) response1 = sampler.sample(bqm, num_reads=1, tenure=tenure, num_restarts=1, timeout=None, seed=seed) samples0 = response0.record.sample samples1 = response1.record.sample self.assertTrue(np.array_equal(samples0, samples1), "Same seed returned different results") for previous_sample in all_samples: self.assertFalse(np.array_equal(samples0, previous_sample), "Different seed returned same results") all_samples.append(samples0)
def test_seed(self): sampler = tabu.TabuSampler() # use a bqm with a huge plateau (extreme ground state degeneracy) # to give the tabu sampler many chances of flipping (exercising rng) bqm = dimod.generators.random.randint(10, dimod.SPIN, low=1, high=1) tenure = 5 all_samples = [] for seed in (1, 25, 2352): response0 = sampler.sample(bqm, num_reads=1, tenure=tenure, num_restarts=1, timeout=None, seed=seed) response1 = sampler.sample(bqm, num_reads=1, tenure=tenure, num_restarts=1, timeout=None, seed=seed) samples0 = response0.record.sample samples1 = response1.record.sample self.assertTrue(np.array_equal(samples0, samples1), "Same seed returned different results") for previous_sample in all_samples: self.assertFalse(np.array_equal(samples0, previous_sample), "Different seed returned same results") all_samples.append(samples0)
def start_annealing(layers: list, input_data, output_data, lagrange_propagation=1, qpu=False, stitch_kwargs=None): if qpu: sampler = EmbeddingComposite( DWaveSampler(solver={'topology__type': 'pegasus', 'qpu': True})) else: sampler = tabu.TabuSampler() bqm = get_qnn_bqm(layers, input_data, output_data, lagrange_propagation, stitch_kwargs) # Check elements in the BQM # for q in bqm.linear: # if bqm.linear[q] != -1: # print(q) # for q in bqm.quadratic: # if bqm.quadratic[q] != 2: # print(q, bqm.quadratic[q]) # Run BQM and get the solution and the energy sampleset = sampler.sample(bqm, num_reads=1000) solution1 = sampleset.first.sample energy1 = sampleset.first.energy print("Nodes chosen ('layer_n.o'): ") pprint(solution1) print("Solution energy: ", energy1)
def test_sample_basic(self): sampler = tabu.TabuSampler() bqm = dimod.BinaryQuadraticModel.from_ising({}, {'ab': -1, 'bc': +1, 'ac': +1}) resp = sampler.sample(bqm) dimod.testing.assert_response_energies(resp, bqm)
def test_sample_num_reads(self): bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': +1, 'ac': +1 }) resp = tabu.TabuSampler().sample(bqm, num_reads=57) dimod.testing.assert_response_energies(resp, bqm) self.assertEqual(sum(resp.record.num_occurrences), 57)
def test_initial_states(self): bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': 1, 'ac': 1 }) init = dimod.SampleSet.from_samples({ 'a': 0, 'b': 0, 'c': 0 }, vartype=dimod.BINARY, energy=0) resp = tabu.TabuSampler().sample(bqm, initial_states=init) dimod.testing.assert_response_energies(resp, bqm) # test the deprecated syntax too resp = tabu.TabuSampler().sample(bqm, init_solution=init) dimod.testing.assert_response_energies(resp, bqm)
def test_energy_threshold(self): sampler = tabu.TabuSampler() bqm = dimod.generators.random.randint(100, 'SPIN', seed=123) energy_threshold = -400 with self.assertRuntimeWithin(0, 1000): # Expect that energy_threshold is met before timeout response = sampler.sample(bqm, timeout=100000, energy_threshold=energy_threshold, seed=345)
def test_energy_threshold(self): sampler = tabu.TabuSampler() bqm = dimod.generators.random.randint(100, 'SPIN', seed=123) energy_threshold = -400 # Expect that energy_threshold is met before timeout with tictoc() as tt: response = sampler.sample(bqm, timeout=100000, energy_threshold=energy_threshold, seed=345) self.assertLessEqual(tt.dt, 1.0)
def test_num_restarts(self): sampler = tabu.TabuSampler() bqm = dimod.generators.random.randint(10, 'SPIN', seed=123) target_restarts = 100 response = sampler.sample(bqm, num_reads=1, timeout=None, num_restarts=target_restarts, seed=345) num_restarts = response.record['num_restarts'] self.assertEqual(target_restarts, num_restarts)
def test_timeout(self): sampler = tabu.TabuSampler() bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': 1, 'ac': 1 }) with tictoc() as tt: response = sampler.sample(bqm, num_reads=1, timeout=500, seed=123) self.assertAlmostEqual(tt.dt, 0.5, places=1) with tictoc() as tt: response = sampler.sample(bqm, num_reads=3, timeout=200, seed=123) self.assertAlmostEqual(tt.dt, 0.6, places=1)
def test_disconnected_problem(self): h = {} J = { # K_3 (0, 1): -1, (1, 2): -1, (0, 2): -1, # disonnected K_3 (3, 4): -1, (4, 5): -1, (3, 5): -1, } bqm = dimod.BinaryQuadraticModel.from_ising(h, J) resp = tabu.TabuSampler().sample(bqm) dimod.testing.assert_response_energies(resp, bqm)
def test_timeout(self): sampler = tabu.TabuSampler() bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': 1, 'ac': 1 }) start_time = time.perf_counter() response = sampler.sample(bqm, num_reads=1, timeout=500, seed=123) run_time = time.perf_counter() - start_time self.assertAlmostEqual(run_time, 0.5, places=1) start_time = time.perf_counter() response = sampler.sample(bqm, num_reads=3, timeout=200, seed=123) run_time = time.perf_counter() - start_time self.assertAlmostEqual(run_time, 0.6, places=1)
def test_input_validation(self): bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': 1, 'ac': 1 }) empty = dimod.BinaryQuadraticModel.empty(dimod.SPIN) # empty bqm self.assertEqual(len(tabu.TabuSampler().sample(empty)), 0) # invalid tenure type with self.assertRaises(TypeError): tabu.TabuSampler().sample(bqm, tenure=2.0) # invalid tenure range with self.assertRaises(ValueError): tabu.TabuSampler().sample(bqm, tenure=100) # invalid num_reads type with self.assertRaises(TypeError): tabu.TabuSampler().sample(bqm, num_reads=10.0) # invalid num_reads range with self.assertRaises(ValueError): tabu.TabuSampler().sample(bqm, num_reads=0) # invalid initial_states type with self.assertRaises(ValueError): tabu.TabuSampler().sample(bqm, initial_states=[]) with self.assertRaises(ValueError): tabu.TabuSampler().sample(bqm, initial_states_generator='non-existing') # invalid initial_states length with self.assertRaises(ValueError): tabu.TabuSampler().sample(bqm, initial_states=[1, 1])
def test_linear_problem(self): bqm = dimod.BinaryQuadraticModel.from_ising( {v: -1 for v in range(100)}, {}) resp = tabu.TabuSampler().sample(bqm) dimod.testing.assert_response_energies(resp, bqm)
def test_initial_states_generator(self): bqm = dimod.BinaryQuadraticModel.from_ising({}, { 'ab': -1, 'bc': 1, 'ac': 1 }) init = dimod.SampleSet.from_samples_bqm([{ 'a': 1, 'b': 1, 'c': 1 }, { 'a': -1, 'b': -1, 'c': -1 }], bqm) # 2 fixed initial state, 8 random resp = tabu.TabuSampler().sample(bqm, initial_states=init, num_reads=10) self.assertEqual(len(resp), 10) # 2 fixed initial states, 8 random, explicit resp = tabu.TabuSampler().sample(bqm, initial_states=init, initial_states_generator='random', num_reads=10) self.assertEqual(len(resp), 10) # all random resp = tabu.TabuSampler().sample(bqm, initial_states_generator='random', num_reads=10) self.assertEqual(len(resp), 10) # all random resp = tabu.TabuSampler().sample(bqm, num_reads=10) self.assertEqual(len(resp), 10) # initial_states truncated to num_reads? resp = tabu.TabuSampler().sample(bqm, initial_states=init, initial_states_generator='none', num_reads=1) self.assertEqual(len(resp), 1) resp = tabu.TabuSampler().sample(bqm, initial_states=init, initial_states_generator='tile', num_reads=1) self.assertEqual(len(resp), 1) resp = tabu.TabuSampler().sample(bqm, initial_states=init, initial_states_generator='random', num_reads=1) self.assertEqual(len(resp), 1) # 2 fixed initial states, repeated 5 times resp = tabu.TabuSampler().sample(bqm, initial_states=init, initial_states_generator='tile', num_reads=10) self.assertEqual(len(resp), 10) # can't tile empty states with self.assertRaises(ValueError): resp = tabu.TabuSampler().sample(bqm, initial_states_generator='tile', num_reads=10) # not enough initial states with self.assertRaises(ValueError): resp = tabu.TabuSampler().sample(bqm, initial_states_generator='none', num_reads=3) # initial_states incompatible with the bqm init = dimod.SampleSet.from_samples({ 'a': 1, 'b': 1 }, vartype='SPIN', energy=0) with self.assertRaises(ValueError): resp = tabu.TabuSampler().sample(bqm, initial_states=init)
def test_single_variable_problem(self): bqm = dimod.BinaryQuadraticModel({'a': 1}, {}, 0.0, dimod.SPIN) resp = tabu.TabuSampler().sample(bqm) dimod.testing.assert_response_energies(resp, bqm) self.assertEqual(resp.first.energy, -1)
def test_instantiation(self): sampler = tabu.TabuSampler() dimod.testing.assert_sampler_api(sampler)