def test_bqm_calc_energy(self):
# Test to calculate energy
# Test Ising energy
bqm = oj.BinaryQuadraticModel(h=self.h, J=self.J)
ising_energy_bqm = bqm.calc_energy(self.spins)
true_ising_e = calculate_ising_energy(self.h, self.J, self.spins)
self.assertEqual(ising_energy_bqm, true_ising_e)
# Test QUBO energy
bqm = oj.BinaryQuadraticModel(Q=self.Q, var_type='BINARY')
qubo_energy_bqm = bqm.calc_energy(self.binaries)
true_qubo_e = calculate_qubo_energy(self.Q, self.binaries)
self.assertEqual(qubo_energy_bqm, true_qubo_e)
# QUBO == Ising
spins = [1, 1, -1, 1]
binary = [1, 1, 0, 1]
qubo_bqm = oj.BinaryQuadraticModel(Q=self.Q, var_type='BINARY')
# ising_mat = qubo_bqm.ising_interactions()
# h, J = {}, {}
# for i in range(len(ising_mat)-1):
# for j in range(i, len(ising_mat)):
# if i == j:
# h[i] = ising_mat[i][i]
# else:
# J[(i, j)] = ising_mat[i][j]
qubo_energy = qubo_bqm.calc_energy(binary)
self.assertEqual(
qubo_energy,
qubo_bqm.calc_energy(spins, need_to_convert_from_spin=True))
def test_chimera(self):
h = {}
J = {(0, 4): -1.0, (6, 2): -3.0}
bqm = oj.BinaryQuadraticModel(h=h, J=J)
self.assertTrue(bqm.validate_chimera(unit_num_L=3))
J = {(0, 1): -1}
bqm = oj.BinaryQuadraticModel(h=h, J=J)
self.assertFalse(bqm.validate_chimera(unit_num_L=3))
def test_interaction_matrix(self):
bqm = oj.BinaryQuadraticModel(h=self.h, J=self.J)
ising_matrix = np.array([[1, -1, 0, 0], [-1, -2, -3, 0],
[0, -3, 0, 0.5], [0, 0, 0.5, 0]])
np.testing.assert_array_equal(bqm.ising_interactions(), ising_matrix)
# check Hij = Jij + Jji
J = self.J.copy()
J[0, 1] /= 3
J[1, 0] = J[0, 1] * 2
bqm = oj.BinaryQuadraticModel(self.h, J)
np.testing.assert_array_equal(bqm.ising_interactions(), ising_matrix)
def test_bqm_constructor(self):
# Test BinaryQuadraticModel constructor
bqm = oj.BinaryQuadraticModel(h=self.h, J=self.J)
self.assertEqual(type(bqm.ising_interactions()), np.ndarray)
self.assertEqual(bqm.var_type, oj.SPIN)
dense_graph = bqm.get_cxxjij_ising_graph(sparse=False)
self.assertTrue(isinstance(dense_graph, cj.graph.Dense))
bqm_qubo = oj.BinaryQuadraticModel(Q=self.Q, var_type='BINARY')
self.assertEqual(bqm_qubo.var_type, oj.BINARY)
def test_openjij_cxxjij_compare(self):
seed_for_mc = 1
Q = {
(0, 0): 1,
(1, 1): -1,
(2, 2): 2,
(0, 1): 1,
(1, 2): -1,
(2, 0): -1
}
# solution is [0, 1, 0]
init_binary = [1, 0, 1]
init_spin = [1, -1, 1]
# openjij
sampler = oj.SASampler(beta_min=0.01,
beta_max=10,
step_length=10,
step_num=100)
res = sampler.sample_qubo(Q=Q,
initial_state=init_binary,
seed=seed_for_mc)
# cxxjij
model = oj.BinaryQuadraticModel(Q=Q, var_type='BINARY')
graph = model.get_cxxjij_ising_graph()
system = cj.system.make_classical_ising_Eigen(init_spin, graph)
sch = cj.utility.make_classical_schedule_list(beta_min=0.01,
beta_max=10,
one_mc_step=10,
num_call_updater=100)
cj.algorithm.Algorithm_SingleSpinFlip_run(system, seed_for_mc, sch)
self.assertListEqual(res.states[0], list((system.spin[:-1] + 1) / 2))
def test_benchmark(self):
h = {0: 1}
J = {(0, 1): -1.0, (1, 2): -1.0}
def solver(time_param, iteration):
sa_samp = oj.SASampler()
sa_samp.step_num = time_param
sa_samp.iteration = iteration
return sa_samp.sample_ising(h, J)
# logger setting
logger = getLogger('openjij')
stream_handler = StreamHandler()
stream_handler.setLevel(INFO)
logger.addHandler(stream_handler)
ground_state = [-1, -1, -1]
ground_energy = oj.BinaryQuadraticModel(h, J).calc_energy(ground_state)
step_num_list = np.linspace(1, 5, 5, dtype=np.int)
bm_res = oj.benchmark([ground_state],
ground_energy,
solver,
time_param_list=step_num_list)
self.assertTrue(
set(bm_res) >=
{'time', 'error', 'e_res', 'tts', 'tts_threshold_prob'})
self.assertEqual(len(bm_res), len(step_num_list))
def test_transfer_to_cxxjij(self):
bqm = oj.BinaryQuadraticModel(self.h, self.J)
# to Dense
ising_graph = bqm.get_cxxjij_ising_graph(sparse=False)
self.assertEqual(ising_graph.size(), len(bqm.indices))
for i in range(len(bqm.indices)):
for j in range(len(bqm.indices)):
if i != j:
self.assertAlmostEqual(
bqm.interaction_matrix()[i, j],
ising_graph.get_interactions()[i, j])
else:
# i == j
self.assertAlmostEqual(
bqm.interaction_matrix()[i, j],
ising_graph.get_interactions()[i, len(bqm.indices)])
self.assertAlmostEqual(
bqm.interaction_matrix()[i, j],
ising_graph.get_interactions()[len(bqm.indices), i])
self.assertEqual(ising_graph.get_interactions()[i, i], 0)
self.assertEqual(
ising_graph.get_interactions()[len(bqm.indices),
len(bqm.indices)], 1)
# to Sparse
ising_graph = bqm.get_cxxjij_ising_graph(sparse=True)
self.assertEqual(ising_graph.size(), len(bqm.indices))
for i in range(ising_graph.size()):
for j in ising_graph.adj_nodes(i):
self.assertEqual(bqm.interaction_matrix()[i, j],
ising_graph[i, j])
def test_benchmark(self):
h = {0: 1}
J = {(0, 1): -1.0, (1, 2): -1.0}
def solver(time_param, *args):
sa_samp = oj.SASampler()
sa_samp.num_sweeps = time_param
return sa_samp.sample_ising(h, J, num_reads=10)
# logger setting
ground_state = [-1, -1, -1]
ground_energy = oj.BinaryQuadraticModel(h, J).calc_energy(ground_state)
step_num_list = np.linspace(1, 9, 9, dtype=np.int)
bm_res = oj.solver_benchmark(
solver=solver,
time_list=step_num_list,
solutions=[ground_state])
self.assertTrue(
set(bm_res) >= {'time', 'success_prob', 'residual_energy', 'tts', 'info'})
self.assertEqual(len(bm_res), len(step_num_list))
bench = oj.solver_benchmark(
solver=solver,
time_list=step_num_list,
ref_energy=ground_energy, measure_with_energy=True)
self.assertTrue(
set(bench) >= {'time', 'success_prob', 'residual_energy', 'tts', 'info'})
def test_bqm_calc_energy(self):
# Test to calculate energy
# Test Ising energy
bqm = oj.BinaryQuadraticModel(self.h, self.J, 'SPIN')
ising_energy_bqm = bqm.energy(self.spins)
true_ising_e = calculate_ising_energy(self.h, self.J, self.spins)
self.assertEqual(ising_energy_bqm, true_ising_e)
# Test QUBO energy
bqm = oj.BinaryQuadraticModel.from_qubo(Q=self.Q)
qubo_energy_bqm = bqm.energy(self.binaries)
true_qubo_e = calculate_qubo_energy(self.Q, self.binaries)
self.assertEqual(qubo_energy_bqm, true_qubo_e)
# QUBO == Ising
spins = {0: 1, 1: 1, 2: -1, 3: 1}
binary = {0: 1, 1: 1, 2: 0, 3: 1}
qubo_bqm = oj.BinaryQuadraticModel.from_qubo(Q=self.Q)
# ising_mat = qubo_bqm.ising_interactions()
# h, J = {}, {}
# for i in range(len(ising_mat)-1):
# for j in range(i, len(ising_mat)):
# if i == j:
# h[i] = ising_mat[i][i]
# else:
# J[(i, j)] = ising_mat[i][j]
qubo_energy = qubo_bqm.energy(binary)
qubo_bqm.change_vartype('SPIN')
self.assertEqual(qubo_energy, qubo_bqm.energy(spins))
def sample_ising(self, h, J,
beta=None, gamma=None,
num_sweeps=None, schedule=None, trotter=None,
num_reads=1,
initial_state=None, updater='single spin flip',
sparse=False,
reinitialize_state=True, seed=None, structure=None):
"""Sampling from the Ising model
Args:
h (dict): Linear term of the target Ising model.
J (dict): Quadratic term of the target Ising model.
beta (float, optional): inverse tempareture.
gamma (float, optional): strangth of transverse field. Defaults to None.
num_sweeps (int, optional): number of sweeps. Defaults to None.
schedule (list[list[float, int]], optional): List of annealing parameter. Defaults to None.
trotter (int): Trotter number.
num_reads (int, optional): number of sampling. Defaults to 1.
initial_state (list[int], optional): Initial state. Defaults to None.
updater (str, optional): update method. Defaults to 'single spin flip'.
reinitialize_state (bool, optional): Re-initilization at each sampling. Defaults to True.
seed (int, optional): Sampling seed. Defaults to None.
structure (dict): specify the structure.
This argument is necessary if the model has a specific structure (e.g. Chimera graph) and the updater algorithm is structure-dependent.
structure must have two types of keys, namely "size" which shows the total size of spins and "dict" which is the map from model index (elements in model.indices) to the number.
Raises:
ValueError:
Returns:
:class:`openjij.sampler.response.Response`: results
Examples:
for Ising case::
>>> h = {0: -1, 1: -1, 2: 1, 3: 1}
>>> J = {(0, 1): -1, (3, 4): -1}
>>> sampler = oj.SQASampler()
>>> res = sampler.sample_ising(h, J)
for QUBO case::
>>> Q = {(0, 0): -1, (1, 1): -1, (2, 2): 1, (3, 3): 1, (4, 4): 1, (0, 1): -1, (3, 4): 1}
>>> sampler = oj.SQASampler()
>>> res = sampler.sample_qubo(Q)
"""
bqm = openjij.BinaryQuadraticModel(
linear=h, quadratic=J, var_type='SPIN'
)
return self._sampling(bqm, beta=beta, gamma=gamma,
num_sweeps=num_sweeps, schedule=schedule, trotter=trotter,
num_reads=num_reads,
initial_state=initial_state, updater=updater,
sparse=sparse,
reinitialize_state=reinitialize_state, seed=seed, structure=structure)
def _dict_to_model(self, var_type, h=None, J=None, Q=None, **kwargs):
if var_type == openjij.SPIN:
bqm = openjij.BinaryQuadraticModel(h, J, 0.0, var_type)
elif var_type == openjij.BINARY:
bqm = openjij.BinaryQuadraticModel.from_qubo(Q)
else:
raise ValueError(
'var_type should be openjij.SPIN or openjij.BINARY')
return bqm
def test_energy_consistency(self):
bqm = oj.BinaryQuadraticModel(self.h,
self.J,
vartype='SPIN',
sparse=False)
dense_ising_graph, offset = bqm.get_cxxjij_ising_graph()
bqm = oj.BinaryQuadraticModel(self.h,
self.J,
vartype='SPIN',
sparse=True)
sparse_ising_graph, offset = bqm.get_cxxjij_ising_graph()
spins = {0: -1, 1: -1, 2: -1, 3: -1}
self.assertAlmostEqual(
dense_ising_graph.calc_energy(
[spins[i] for i in range(len(spins))]), bqm.energy(spins))
self.assertAlmostEqual(
sparse_ising_graph.calc_energy(
[spins[i] for i in range(len(spins))]), bqm.energy(spins))
def sample_ising(self,
h,
J,
initial_state=None,
updater='single spin flip',
reinitilize_state=True,
seed=None,
**kwargs):
"""Sample from the specified Ising model.
Args:
h (dict):
Linear biases of the Ising model.
J (dict):
Quadratic biases of the Ising model.
initial_state (list):
The initial state of simulated annealing
updater (str):
Monte Carlo update algorithm : 'single spin flip' or 'swendsenwang'
reinitilize_state (bool):
Reinitialize the initial state for every anneal-readout cycle.
seed (:obj:`int`, optional):
seed for Monte Carlo step
**kwargs:
Optional keyword arguments for the sampling method.
Returns:
:obj:: `openjij.sampler.response.Response` object.
Examples:
This example submits a two-variable Ising problem.
>>> import openjij as oj
>>> sampler = oj.SASampler()
>>> response = sampler.sample_ising({0: -1, 1: 1}, {})
>>> for sample in response.samples(): # doctest: +SKIP
... print(sample)
...
{0: 1, 1: -1}
"""
var_type = openjij.SPIN
model = openjij.BinaryQuadraticModel(h=h, J=J, var_type=var_type)
return self.sampling(model,
initial_state=initial_state,
updater=updater,
reinitilize_state=reinitilize_state,
seed=seed,
**kwargs)
def sample_ising(
self,
h,
J,
beta_min=None,
beta_max=None,
num_sweeps=None,
num_reads=1,
schedule=None,
initial_state=None,
updater='single spin flip',
reinitialize_state=True,
seed=None,
):
"""sample Ising model.
Args:
h (dict): linear biases
J (dict): quadratic biases
beta_min (float): minimal value of inverse temperature
beta_max (float): maximum value of inverse temperature
num_sweeps (int): number of sweeps
num_reads (int): number of reads
schedule (list): list of inverse temperature
initial_state (dict): initial state
updater(str): updater algorithm
reinitialize_state (bool): if true reinitialize state for each run
seed (int): seed for Monte Carlo algorithm
Returns:
:class:`openjij.sampler.response.Response`: results
Examples:
for Ising case::
>>> h = {0: -1, 1: -1, 2: 1, 3: 1}
>>> J = {(0, 1): -1, (3, 4): -1}
>>> sampler = oj.SASampler()
>>> res = sampler.sample_ising(h, J)
for QUBO case::
>>> Q = {(0, 0): -1, (1, 1): -1, (2, 2): 1, (3, 3): 1, (4, 4): 1, (0, 1): -1, (3, 4): 1}
>>> sampler = oj.SASampler()
>>> res = sampler.sample_qubo(Q)
"""
model = openjij.BinaryQuadraticModel(linear=h,
quadratic=J,
var_type='SPIN')
return self._sampling(model, beta_min, beta_max, num_sweeps, num_reads,
schedule, initial_state, updater,
reinitialize_state, seed)
def test_bqm(self):
h = {}
J = {(0, 1): -1.0, (1, 2): -3.0}
bqm = oj.BinaryQuadraticModel(h, J, 'SPIN')
self.assertEqual(J, bqm.get_quadratic())
self.assertEqual(type(bqm.interaction_matrix()), np.ndarray)
correct_mat = np.array([[0, -1, 0, 0], [0, 0, -3, 0], [0, 0, 0, 0],
[0, 0, 0, 1]])
np.testing.assert_array_equal(bqm.interaction_matrix(),
correct_mat.astype(float))
def sample_qubo(self,
Q,
initial_state=None,
updater='single spin flip',
reinitilize_state=True,
seed=None,
**kwargs):
"""Sample from the specified QUBO.
Args:
Q (dict):
Coefficients of a quadratic unconstrained binary optimization (QUBO) model.
initial_state (list):
The initial state of simulated annealing
updater (str):
Monte Carlo update algorithm : 'single spin flip' or 'swendsenwang'
reinitilize_state (bool):
Reinitialize the initial state for every anneal-readout cycle.
seed (:obj:`int`, optional):
seed for Monte Carlo step
**kwargs:
Optional keyword arguments for the sampling method.
Returns:
:obj:: `openjij.sampler.response.Response` object.
Examples:
This example submits a two-variable QUBO model.
>>> import openjij as oj
>>> sampler = oj.SASampler()
>>> Q = {(0, 0): -1, (4, 4): -1, (0, 4): 2}
>>> response = sampler.sample_qubo(Q)
>>> for sample in response.samples(): # doctest: +SKIP
... print(sample)
...
{0: 0, 4: 1}
"""
var_type = openjij.BINARY
model = openjij.BinaryQuadraticModel(Q=Q, var_type=var_type)
return self.sampling(model,
initial_state=initial_state,
updater=updater,
reinitilize_state=reinitilize_state,
seed=seed,
**kwargs)
def test_bqm_constructor(self):
# Test BinaryQuadraticModel constructor
bqm = oj.BinaryQuadraticModel(self.h, self.J, 'SPIN', sparse=False)
self.assertEqual(type(bqm.interaction_matrix()), np.ndarray)
self.assertEqual(bqm.vartype, oj.SPIN)
dense_graph, offset = bqm.get_cxxjij_ising_graph()
self.assertTrue(isinstance(dense_graph, cj.graph.Dense))
self.assertEqual(offset, 0)
bqm_qubo = oj.BinaryQuadraticModel.from_qubo(Q=self.Q)
self.assertEqual(bqm_qubo.vartype, oj.BINARY)
def test_bqm(self):
h = {}
J = {(0, 1): -1.0, (1, 2): -3.0}
bqm = oj.BinaryQuadraticModel(h=h, J=J)
self.assertEqual(type(bqm.ising_interactions()), np.ndarray)
correct_mat = np.array([[
0,
-1,
0,
], [-1, 0, -3], [0, -3, 0]])
np.testing.assert_array_equal(bqm.ising_interactions(),
correct_mat.astype(np.float))
def sample_ising(self,
h,
J,
beta=None,
gamma=None,
num_sweeps=None,
schedule=None,
num_reads=1,
initial_state=None,
updater='single spin flip',
reinitialize_state=True,
seed=None,
**kwargs):
"""Sampling from the Ising model
Args:
h (dict): Linear term of the target Ising model.
J (dict): Quadratic term of the target Ising model.
beta (float, optional): inverse tempareture.
gamma (float, optional): strangth of transverse field. Defaults to None.
num_sweeps (int, optional): number of sweeps. Defaults to None.
schedule (list[list[float, int]], optional): List of annealing parameter. Defaults to None.
num_reads (int, optional): number of sampling. Defaults to 1.
initial_state (list[int], optional): Initial state. Defaults to None.
updater (str, optional): update method. Defaults to 'single spin flip'.
reinitialize_state (bool, optional): Re-initilization at each sampling. Defaults to True.
seed (int, optional): Sampling seed. Defaults to None.
Raises:
ValueError: [description]
Returns:
[type]: [description]
"""
bqm = openjij.BinaryQuadraticModel(linear=h,
quadratic=J,
var_type='SPIN')
return self._sampling(bqm,
beta=beta,
gamma=gamma,
num_sweeps=num_sweeps,
schedule=schedule,
num_reads=num_reads,
initial_state=initial_state,
updater=updater,
reinitialize_state=reinitialize_state,
seed=seed,
**kwargs)
def test_transfer_to_cxxjij(self):
bqm = oj.BinaryQuadraticModel(self.h, self.J, 'SPIN', sparse=False)
# to Dense
ising_graph, offset = bqm.get_cxxjij_ising_graph()
self.assertEqual(ising_graph.size(), len(bqm.variables))
for i in range(len(bqm.variables) + 1):
for j in range(i + 1, len(bqm.variables) + 1):
self.assertAlmostEqual(bqm.interaction_matrix()[i, j],
ising_graph.get_interactions()[i, j])
self.assertAlmostEqual(ising_graph.get_interactions()[i, j],
ising_graph.get_interactions()[j, i])
#with offset
bqm_qubo = oj.BinaryQuadraticModel.from_qubo(Q=self.Q)
ising_graph, offset = bqm_qubo.get_cxxjij_ising_graph()
bqm = bqm_qubo.change_vartype('SPIN', inplace=False)
self.assertEqual(ising_graph.size(), len(bqm.variables))
for i in range(len(bqm.variables) + 1):
for j in range(i + 1, len(bqm.variables) + 1):
self.assertAlmostEqual(bqm.interaction_matrix()[i, j],
ising_graph.get_interactions()[i, j])
self.assertAlmostEqual(ising_graph.get_interactions()[i, j],
ising_graph.get_interactions()[j, i])
self.assertAlmostEqual(offset, bqm.offset)
# to Sparse
bqm = oj.BinaryQuadraticModel(self.h, self.J, 'SPIN', sparse=True)
ising_graph, offset = bqm.get_cxxjij_ising_graph()
self.assertEqual(ising_graph.size(), len(bqm.variables))
for i in range(ising_graph.size()):
for j in ising_graph.adj_nodes(i):
self.assertEqual(
ising_graph[i, j],
bqm.interaction_matrix()[min(i, j), max(i, j)] if i != j
else bqm.interaction_matrix()[i, len(bqm.variables)])
def reverse_annealing():
initial_state = [0, 0, 0]
qubo = make_qubo()
reverse_schedule = [[10, 3], (1, 3), (0.5, 3), (1, 3), (10, 5)]
sqa = oj.SASampler(schedule=reverse_schedule, iteration=20)
res = sqa.sample_qubo(qubo, initial_state=initial_state)
print(res.min_samples)
model = oj.BinaryQuadraticModel(Q=qubo, vartype='BINARY')
print(model.calc_energy(res.min_samples['min_states'][0]))
print('RQA')
reverse_schedule = [[1, 1], [0.3, 3], [0.1, 5], [0.3, 3], [1, 3]]
rqa_sampler = oj.SQASampler(schedule=reverse_schedule,
iteration=10,
beta=10)
rqa_sampler = SQASampler(schedule=reverse_schedule, iteration=10)
res = rqa_sampler.sample_qubo(qubo, initial_state=initial_state, seed=1)
print(res.min_samples)
def sample_ising(self,
h,
J,
initial_state=None,
updater='single spin flip',
reinitilize_state=True,
seed=None,
**kwargs):
"""Sample from the specified Ising model.
Args:
h (dict):
Linear biases of the Ising model.
J (dict):
Quadratic biases of the Ising model.
**kwargs:
Optional keyword arguments for the sampling method.
Returns:
:obj:: `openjij.sampler.response.Response` object.
Examples:
This example submits a two-variable Ising problem.
>>> import openjij as oj
>>> sampler = oj.SQASampler()
>>> response = sampler.sample_ising({0: -1, 1: 1}, {})
>>> for sample in response.samples(): # doctest: +SKIP
... print(sample)
...
{0: 1, 1: -1}
"""
vartype = openjij.SPIN
bqm = openjij.BinaryQuadraticModel(h=h, J=J, vartype=vartype)
return self.sampling(bqm,
initial_state=initial_state,
updater=updater,
reinitilize_state=reinitilize_state,
seed=seed,
**kwargs)
def sample_ising(self,
h,
J,
beta_min=None,
beta_max=None,
num_sweeps=None,
num_reads=1,
schedule=None,
initial_state=None,
updater='single spin flip',
reinitialize_state=True,
seed=None,
**kwargs):
model = openjij.BinaryQuadraticModel(linear=h,
quadratic=J,
var_type='SPIN')
return self._sampling(model, beta_min, beta_max, num_sweeps, num_reads,
schedule, initial_state, updater,
reinitialize_state, seed, **kwargs)
def sample_qubo(self,
Q,
initial_state=None,
updater='single spin flip',
reinitilize_state=True,
seed=None,
**kwargs):
"""Sample from the specified QUBO.
Args:
Q (dict):
Coefficients of a quadratic unconstrained binary optimization (QUBO) model.
**kwargs:
Optional keyword arguments for the sampling method.
Returns:
:obj:: `openjij.sampler.response.Response` object.
Examples:
This example submits a two-variable QUBO model.
>>> import openjij as oj
>>> sampler = oj.SQASampler()
>>> Q = {(0, 0): -1, (4, 4): -1, (0, 4): 2}
>>> response = sampler.sample_qubo(Q)
>>> for sample in response.samples(): # doctest: +SKIP
... print(sample)
...
{0: 0, 4: 1}
"""
vartype = openjij.BINARY
bqm = openjij.BinaryQuadraticModel(Q=Q, vartype=vartype)
return self.sampling(bqm,
initial_state=initial_state,
updater=updater,
reinitilize_state=reinitilize_state,
seed=seed,
**kwargs)
def test_benchmark(self):
h = {0: 1}
J = {(0, 1): -1.0, (1, 2): -1.0}
sa_samp = oj.SASampler()
def solver(time_param, iteration):
sa_samp.step_num = time_param
sa_samp.iteration = iteration
return sa_samp.sample_ising(h, J)
ground_state = [-1, -1, -1]
ground_energy = oj.BinaryQuadraticModel(h, J).calc_energy(ground_state)
step_num_list = np.linspace(10, 50, 5, dtype=np.int)
bm_res = oj.benchmark([ground_state],
ground_energy,
solver,
time_param_list=step_num_list)
self.assertTrue(
set(bm_res) >=
{'time', 'error', 'e_res', 'tts', 'tts_threshold_prob'})
self.assertEqual(len(bm_res), len(step_num_list))
# make target instance
N = 50
h = {0: 1, 1: 1}
J = {}
for i in range(N - 1):
for j in range(i + 1, N):
J[(i, j)] = -1.0
N = 30
h = {0: -10}
J = {(i, i + 1): 1 for i in range(N - 1)}
ground_state = correct_state = [(-1)**i for i in range(N)] # [-1]*N
sa_samp = oj.SASampler()
ground_energy = oj.BinaryQuadraticModel(h, J).calc_energy(ground_state)
# make benchmark target solver
def solver(time_param):
return sa_samp.sample_ising(h, J, num_reads=100, num_sweeps=time_param)
# benchmarking
time_list = list(range(10, 101, 10))
b_res = oj.solver_benchmark(solver,
time_list=time_list,
solutions=[ground_state])
plt.xlabel('annealing time')
plt.ylabel('TTS')
plt.plot(b_res['time'], np.array(b_res['tts']), '.')
plt.show()
def sample_ising(self,
h,
J,
beta=None,
gamma=None,
num_sweeps=None,
schedule=None,
num_reads=1,
initial_state=None,
updater='swendsenwang',
reinitialize_state=True,
seed=None,
**kwargs):
bqm = openjij.BinaryQuadraticModel(linear=h,
quadratic=J,
var_type='SPIN')
ising_graph = bqm.get_cxxjij_ising_graph()
self._setting_overwrite(beta=beta,
gamma=gamma,
num_sweeps=num_sweeps,
num_reads=num_reads)
self._annealing_schedule_setting(bqm, beta, gamma, num_sweeps,
schedule)
# make init state generator --------------------------------
if initial_state is None:
def init_generator():
n = len(bqm.indices)
init_num_cut = 10
c_spins = ising_graph.gen_spin()
_cut = np.random.uniform(0, 1, (n, init_num_cut))
spin_config = [[(t, s**(_ti + 1))
for _ti, t in enumerate(np.sort(_cut[i]))]
for i, s in enumerate(c_spins)]
return spin_config
else:
def init_generator():
return initial_state
# -------------------------------- make init state generator
# choose updater -------------------------------------------
sqa_system = cxxjij.system.ContinuousTimeIsing_Dense(
init_generator(), ising_graph, self.gamma)
_updater_name = updater.lower().replace('_', '').replace(' ', '')
if _updater_name == 'swendsenwang':
algorithm = cxxjij.algorithm.Algorithm_ContinuousTimeSwendsenWang_run
else:
raise ValueError('updater is one of "swendsen wang"')
# ------------------------------------------- choose updater
response = self._cxxjij_sampling(bqm, init_generator, algorithm,
sqa_system, reinitialize_state, seed,
**kwargs)
response.info['schedule'] = self.schedule_info
return response
def sample(self, bqm,
beta=None, gamma=None,
num_sweeps=None, schedule=None, trotter=None,
num_reads=1,
initial_state=None, updater='single spin flip',
sparse=False,
reinitialize_state=True, seed=None):
"""Sampling from the Ising model
Args:
bqm (oj.BinaryQuadraticModel) binary quadratic model
beta (float, optional): inverse tempareture.
gamma (float, optional): strangth of transverse field. Defaults to None.
num_sweeps (int, optional): number of sweeps. Defaults to None.
schedule (list[list[float, int]], optional): List of annealing parameter. Defaults to None.
trotter (int): Trotter number.
num_reads (int, optional): number of sampling. Defaults to 1.
initial_state (list[int], optional): Initial state. Defaults to None.
updater (str, optional): update method. Defaults to 'single spin flip'.
reinitialize_state (bool, optional): Re-initilization at each sampling. Defaults to True.
seed (int, optional): Sampling seed. Defaults to None.
Raises:
ValueError:
Returns:
:class:`openjij.sampler.response.Response`: results
Examples:
for Ising case::
>>> h = {0: -1, 1: -1, 2: 1, 3: 1}
>>> J = {(0, 1): -1, (3, 4): -1}
>>> sampler = oj.SQASampler()
>>> res = sampler.sample_ising(h, J)
for QUBO case::
>>> Q = {(0, 0): -1, (1, 1): -1, (2, 2): 1, (3, 3): 1, (4, 4): 1, (0, 1): -1, (3, 4): 1}
>>> sampler = oj.SQASampler()
>>> res = sampler.sample_qubo(Q)
"""
if type(bqm) == dimod.BinaryQuadraticModel:
bqm = openjij.BinaryQuadraticModel(dict(bqm.linear), dict(bqm.quadratic), bqm.offset, bqm.vartype)
ising_graph, offset = bqm.get_cxxjij_ising_graph()
self._setting_overwrite(
beta=beta, gamma=gamma,
num_sweeps=num_sweeps, num_reads=num_reads,
trotter=trotter
)
# set annealing schedule -------------------------------
self._annealing_schedule_setting(
bqm, beta, gamma, num_sweeps, schedule)
# ------------------------------- set annealing schedule
# make init state generator --------------------------------
if initial_state is None:
def init_generator(): return [ising_graph.gen_spin(seed) if seed != None else ising_graph.gen_spin()
for _ in range(self.trotter)]
else:
if isinstance(initial_state, dict):
initial_state = [initial_state[k] for k in bqm.variables]
_init_state = np.array(initial_state)
# validate initial_state size
if len(initial_state) != ising_graph.size():
raise ValueError(
"the size of the initial state should be {}"
.format(ising_graph.size()))
trotter_init_state = [_init_state
for _ in range(self.trotter)]
def init_generator(): return trotter_init_state
# -------------------------------- make init state generator
# choose updater -------------------------------------------
_updater_name = updater.lower().replace('_', '').replace(' ', '')
if _updater_name not in self._algorithm:
raise ValueError('updater is one of "single spin flip"')
algorithm = self._algorithm[_updater_name]
sqa_system = self._make_system[_updater_name](
init_generator(), ising_graph, self.gamma
)
# ------------------------------------------- choose updater
response = self._cxxjij_sampling(
bqm, init_generator,
algorithm, sqa_system,
reinitialize_state, seed
)
response.info['schedule'] = self.schedule_info
return response
def test_interaction_matrix(self):
bqm = oj.BinaryQuadraticModel(self.h, self.J, 'SPIN')
ising_matrix = np.array([[0, -1, 0, 0, 1], [0, 0, -3, 0, -2],
[0, 0, 0, 0.5, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 1]])
np.testing.assert_array_equal(bqm.interaction_matrix(), ising_matrix)
def _dict_to_model(self, var_type, h=None, J=None, Q=None, **kwargs):
return openjij.BinaryQuadraticModel(h=h, J=J, Q=Q, var_type=var_type)
