def test_job_get_results(self):
ws = self.create_workspace()
problem = Problem(name="test")
count = 4
for i in range(count):
problem.add_term(c=i, indices=[i, i + 1])
with unittest.mock.patch.object(Job,
self.mock_create_job_id_name,
return_value=self.get_dummy_job_id()):
solver = SimulatedAnnealing(ws)
job = solver.submit(problem)
actual = job.get_results()
expected = {
'version': '1.0',
'configuration': {
'0': 1,
'1': 1,
'2': -1,
'3': 1,
'4': -1
},
'cost': -6.0,
'parameters': {
'beta_start': 0.2,
'beta_stop': 1.9307236000000003,
'restarts': 360,
'sweeps': 50
}
}
self.assertEqual(expected, actual)
def __test_upload_problem(
self,
count: int,
terms_thresh: int,
size_thresh: int,
compress: bool,
problem_type: ProblemType = ProblemType.ising,
initial_terms: List[Term] = [],
**kwargs
):
if not (self.in_recording or self.is_live):
# Temporarily disabling this test in playback mode
# due to multiple calls to the storage API
# that need to have a request id to distinguish
# them while playing back
print("Skipping this test in playback mode")
return
ws = self.create_workspace()
sProblem = StreamingProblem(
ws, name="test", problem_type=problem_type, terms=initial_terms
)
rProblem = Problem(
"test", problem_type=problem_type, terms=initial_terms
)
sProblem.upload_terms_threshold = terms_thresh
sProblem.upload_size_threshold = size_thresh
sProblem.compress = compress
for i in range(count):
sProblem.add_term(c=i, indices=[i, i + 1])
rProblem.add_term(c=i, indices=[i, i + 1])
self.assertEqual(problem_type, sProblem.problem_type)
self.assertEqual(problem_type.name, sProblem.stats["type"])
self.assertEqual(
count + len(initial_terms), sProblem.stats["num_terms"]
)
self.assertEqual(
self.__kwarg_or_value(kwargs, "avg_coupling", 2),
sProblem.stats["avg_coupling"],
)
self.assertEqual(
self.__kwarg_or_value(kwargs, "max_coupling", 2),
sProblem.stats["max_coupling"],
)
self.assertEqual(
self.__kwarg_or_value(kwargs, "min_coupling", 2),
sProblem.stats["min_coupling"],
)
uri = sProblem.upload(ws)
uploaded = json.loads(sProblem.download().serialize())
local = json.loads(rProblem.serialize())
self.assertEqual(uploaded, local)
def test_problem_large(self):
problem = Problem(name="test", terms=[], problem_type=ProblemType.pubo)
self.assertTrue(not problem.is_large())
problem.add_term(5.0, [])
self.assertTrue(not problem.is_large())
problem.add_term(6.0, list(range(3000)))
self.assertTrue(not problem.is_large())
problem.add_terms(
[Term(indices=[9999], c=1.0)] * int(1e6)
) # create 1mil dummy terms
self.assertTrue(problem.is_large())
def test_job_refresh(self):
ws = self.create_workspace()
problem = Problem(name="test")
count = 4
for i in range(count):
problem.add_term(c=i, indices=[i, i + 1])
with unittest.mock.patch.object(Job,
self.mock_create_job_id_name,
return_value=self.get_dummy_job_id()):
solver = SimulatedAnnealing(ws)
job = solver.submit(problem)
job.refresh()
def test_job_wait_unit_completed(self):
ws = self.create_workspace()
problem = Problem(name="test")
count = 4
for i in range(count):
problem.add_term(c=i, indices=[i, i + 1])
with unittest.mock.patch.object(Job,
self.mock_create_job_id_name,
return_value=self.get_dummy_job_id()):
solver = SimulatedAnnealing(ws)
job = solver.submit(problem)
job.wait_until_completed()
self.assertEqual(True, job.has_completed())
def test_add_terms_cterms(self):
problem = Problem(name="test")
count = 4
for i in range(count):
problem.add_term(c=i, indices=[i, i+1])
self.assertEqual(ProblemType.ising, problem.problem_type)
self.assertEqual(count, len(problem.terms))
self.assertEqual(Term(c=1, indices=[1, 2]), problem.terms[1])
more = []
for i in range(count + 1):
more.append(Term(c=i, indices=[i, i-1]))
problem.add_terms(more)
self.assertEqual((count * 2) + 1, len(problem.terms))
self.assertEqual(Term(c=count, indices=[count, count - 1]), problem.terms[count * 2])
def test_add_terms_cterms(self):
problem = Problem(name="test")
count = 4
for i in range(count):
problem.add_term(c=i, indices=[i, i + 1])
self.assertEqual(ProblemType.ising, problem.problem_type)
self.assertEqual(count, len(problem.terms))
self.assertEqual(Term(c=1, indices=[1, 2]), problem.terms[1])
more = []
for i in range(1, count + 1):
more.append(Term(c=i, indices=[i - 1, i]))
problem.add_terms(more)
self.assertEqual(2 * count, len(problem.terms))
self.assertEqual(Term(c=count, indices=[count - 1, count]),
problem.terms[-1])
subterms = [Term(c=1, indices=[i]) for i in range(count)]
subterms.append(Term(c=-5, indices=[]))
problem.add_slc_term(terms=[(1, i)
for i in range(count)] + [(-5, None)],
c=2)
self.assertEqual(2 * count, len(problem.terms))
self.assertEqual(1, len(problem.terms_slc))
self.assertEqual(SlcTerm(subterms, c=2), problem.terms_slc[-1])
problem.add_terms(subterms,
term_type=GroupType.squared_linear_combination,
c=2)
self.assertEqual(2 * count, len(problem.terms))
self.assertEqual(2, len(problem.terms_slc))
self.assertEqual(SlcTerm(subterms, c=2), problem.terms_slc[-1])
problem.add_terms(subterms, term_type=GroupType.combination, c=0.5)
self.assertEqual(3 * count + 1, len(problem.terms))
self.assertEqual(
[Term(subterm.ids, c=subterm.c) for subterm in subterms],
problem.terms[-len(subterms):])
problem.add_slc_term(subterms, c=3)
self.assertEqual(3 * count + 1, len(problem.terms))
self.assertEqual(3, len(problem.terms_slc))
self.assertEqual(SlcTerm(subterms, c=3), problem.terms_slc[-1])
def __test_upload_problem(
self,
count: int,
terms_thresh: int,
size_thresh: int,
compress: bool,
problem_type: ProblemType = ProblemType.ising,
initial_terms: List[Term] = [],
**kwargs
):
ws = create_workspace()
sProblem = StreamingProblem(
ws,
name="test",
problem_type=problem_type,
terms=initial_terms
)
rProblem = Problem('test', problem_type=problem_type, terms=initial_terms)
sProblem.upload_terms_threshold = terms_thresh
sProblem.upload_size_threshold = size_thresh
sProblem.compress = compress
for i in range(count):
sProblem.add_term(c = i, indices = [i, i+1])
rProblem.add_term(c = i, indices = [i, i+1])
self.assertEqual(problem_type, sProblem.problem_type)
self.assertEqual(problem_type.name, sProblem.stats['type'])
self.assertEqual(count + len(initial_terms), sProblem.stats['num_terms'])
self.assertEqual(self.__kwarg_or_value(kwargs, 'avg_coupling', 2), sProblem.stats['avg_coupling'])
self.assertEqual(self.__kwarg_or_value(kwargs, 'max_coupling', 2), sProblem.stats['max_coupling'])
self.assertEqual(self.__kwarg_or_value(kwargs, 'min_coupling', 2), sProblem.stats['min_coupling'])
uri = sProblem.upload(ws)
uploaded = json.loads(sProblem.download().serialize())
local = json.loads(rProblem.serialize())
self.assertEqual(uploaded, local)