def add_sample(self, sample, energy=None, data=None, h=None, J=None):
"""Loads a sample and associated energy into the response.
Args:
sample (dict): A sample as would be returned by a discrete
model solver. Should be a dict of the form
{var: value, ...}. The values should be spin-valued, that is
-1 or 1.
energy (float/int, optional): The energy associated with the
given sample.
data (dict, optional): A dict containing any additional
data about the sample. Default {}.
h (dict) and J (dict): Define an Ising problem that can be
used to calculate the energy associated with `sample`.
Notes:
Solutions are stored in order of energy, lowest first.
Raises:
TypeError: If `sample` is not a dict.
TypeError: If `energy` is not an int or float.
TypeError: If `data` is not a dict.
ValueError: If any of the values in `sample` are not -1
or 1.
TypeError: If energy is not provided, h and J must be.
Examples:
>>> response = SpinResponse()
>>> response.add_sample({0: -1}, 1)
>>> response.add_sample({0: 1}, -1, data={'n': 1})
>>> response.add_sample({0: 1}, h={0: -1}, J={})
>>> list(response.energies())
[-1, -1]
"""
if not isinstance(sample, dict):
raise TypeError("expected 'sample' to be a dict")
# check that the sample is spin-valued
if any(val not in (-1, 1) for val in itervalues(sample)):
raise ValueError(
'given sample is not spin-valued. Values should be -1 or 1')
# if energy is not provided, but h, J are, then we can calculate
# the energy for the sample.
if energy is None:
if h is None or J is None:
raise TypeError("most provide 'energy' or 'h' and 'J'")
energy = ising_energy(h, J, sample)
if data is None:
data = {}
TemplateResponse.add_sample(self, sample, energy, data)
def add_sample(self,
sample,
energy=None,
num_occurences=1,
h=None,
J=None,
**kwargs):
"""Loads a sample and associated energy into the response.
Args:
todo
Notes:
Solutions are stored in order of energy, lowest first.
Raises:
TypeError: If `sample` is not a dict.
TypeError: If `energy` is not an int or float.
TypeError: If `data` is not a dict.
ValueError: If any of the values in `sample` are not -1
or 1.
TypeError: If energy is not provided, h and J must be.
Examples:
>>> response = SpinResponse()
>>> response.add_sample({0: -1}, 1)
>>> response.add_sample({0: 1}, -1, data={'n': 1})
>>> response.add_sample({0: 1}, h={0: -1}, J={})
>>> list(response.energies())
[-1, -1]
"""
if not isinstance(sample, dict):
raise TypeError("expected 'sample' to be a dict")
# if energy is not provided, but h, J are, then we can calculate
# the energy for the sample.
if energy is None:
if h is None or J is None:
raise TypeError("most provide 'energy' or 'h' and 'J'")
energy = ising_energy(sample, h, J)
TemplateResponse.add_sample(self,
sample,
energy,
num_occurences=num_occurences,
**kwargs)
def ising_simulated_annealing(h, J, beta_range=None, num_sweeps=1000):
"""Tries to find the spins that minimize the given Ising problem.
Args:
h (dict): A dictionary of the linear biases in the Ising
problem. Should be of the form {v: bias, ...} for each
variable v in the Ising problem.
J (dict): A dictionary of the quadratic biases in the Ising
problem. Should be a dict of the form {(u, v): bias, ...}
for each edge (u, v) in the Ising problem. If J[(u, v)] and
J[(v, u)] exist then the biases are added.
beta_range (tuple, optional): A 2-tuple defining the
beginning and end of the beta schedule (beta is the
inverse temperature). The schedule is applied linearly
in beta. Default is chosen based on the total bias associated
with each node.
num_sweeps (int, optional): The number of sweeps or steps.
Default is 1000.
Returns:
dict: A sample as a dictionary of spins.
float: The energy of the returned sample.
Raises:
TypeError: If the values in `beta_range` are not numeric.
TypeError: If `num_sweeps` is not an int.
TypeError: If `beta_range` is not a tuple.
ValueError: If the values in `beta_range` are not positive.
ValueError: If `beta_range` is not a 2-tuple.
ValueError: If `num_sweeps` is not positive.
https://en.wikipedia.org/wiki/Simulated_annealing
"""
if beta_range is None:
beta_init = .1
sigmas = {v: abs(h[v]) for v in h}
for u, v in J:
sigmas[u] += abs(J[(u, v)])
sigmas[v] += abs(J[(u, v)])
if sigmas:
beta_final = 2. * max(itervalues(sigmas))
else:
beta_final = 0.0
else:
if not isinstance(beta_range, (tuple, list)):
raise TypeError("'beta_range' should be a tuple of length 2")
if any(not isinstance(b, (int, float)) for b in beta_range):
raise TypeError("values in 'beta_range' should be numeric")
if any(b <= 0 for b in beta_range):
raise ValueError("beta values in 'beta_range' should be positive")
if len(beta_range) != 2:
raise ValueError("'beta_range' should be a tuple of length 2")
beta_init, beta_final = beta_range
if not isinstance(num_sweeps, int):
raise TypeError("'sweeps' should be a positive int")
if num_sweeps <= 0:
raise ValueError("'sweeps' should be a positive int")
# We want the schedule to be linear in beta (inverse temperature)
betas = [
beta_init + i * (beta_final - beta_init) / (num_sweeps - 1.)
for i in range(num_sweeps)
]
# set up the adjacency matrix. We can rely on every node in J already being in h
adj = {n: set() for n in h}
for n0, n1 in J:
adj[n0].add(n1)
adj[n1].add(n0)
# we will use a vertex coloring for the graph and update the nodes by color. A quick
# greedy coloring will be sufficient.
__, colors = greedy_coloring(adj)
# let's make our initial guess (randomly)
spins = {v: random.choice((-1, 1)) for v in h}
# there are exactly as many betas as sweeps
for beta in betas:
# we want to know the gain in energy for flipping each of the spins.
# We can calculate all of the linear terms simultaneously
energy_diff_h = {v: -2 * spins[v] * h[v] for v in h}
# for each color, do updates
for color in colors:
nodes = colors[color]
# we now want to know the energy change for flipping the spins within
# the color class
energy_diff_J = {}
for v0 in nodes:
ediff = 0
for v1 in adj[v0]:
if (v0, v1) in J:
ediff += spins[v0] * spins[v1] * J[(v0, v1)]
if (v1, v0) in J:
ediff += spins[v0] * spins[v1] * J[(v1, v0)]
energy_diff_J[v0] = -2. * ediff
# now decide whether to flip spins according to the
# following scheme:
# p ~ Uniform(0, 1)
# log(p) < -beta * (energy_diff)
for v in nodes:
logp = math.log(random.uniform(0, 1))
if logp < -1. * beta * (energy_diff_h[v] + energy_diff_J[v]):
# flip the variable in the spins
spins[v] *= -1
return spins, ising_energy(spins, h, J)
def sample_ising(self, h, J):
"""Solves the Ising problem exactly.
Args:
h (dict/list): The linear terms in the Ising problem. If a
dict, should be of the form {v: bias, ...} where v is
a variable in the Ising problem, and bias is the linear
bias associated with v. If a list, should be of the form
[bias, ...] where the indices of the biases are the
variables in the Ising problem.
J (dict): A dictionary of the quadratic terms in the Ising
problem. Should be of the form {(u, v): bias} where u,
v are variables in the Ising problem and bias is the
quadratic bias associated with u, v.
Returns:
:obj:`SpinResponse`
Notes:
Becomes slow for problems with 18 or more variables.
"""
# it will be convenient to have J in a nested-dict form.
adjJ = {v: {} for v in h}
for (u, v), bias in iteritems(J):
if v not in adjJ[u]:
adjJ[u][v] = bias
else:
adjJ[u][v] += bias
if u not in adjJ[v]:
adjJ[v][u] = bias
else:
adjJ[v][u] += bias
# initialize the response
response = SpinResponse()
# generate the first sample and add it to the response
sample = {v: -1 for v in h}
energy = ising_energy(h, J, sample)
response.add_sample(sample.copy(), energy)
# now we iterate, flipping one bit at a time until we have
# traversed all samples. This is a gray code.
# https://en.wikipedia.org/wiki/Gray_code
for i in range(1, 1 << len(h)):
v = _ffs(i)
# flip the bit in the sample
sample[v] *= -1
# get the energy difference
quad_diff = sum(adjJ[v][u] * sample[u] for u in adjJ[v])
# calculate the new energy as a difference from the old
energy += 2 * sample[v] * (h[v] + quad_diff)
response.add_sample(sample.copy(), energy)
return response
def add_samples_from(self,
samples,
energies=None,
num_occurences=1,
h=None,
J=None,
**kwargs):
"""Loads samples and associated energies from iterators.
Args:
todo
Notes:
Solutions are stored in order of energy, lowest first.
Raises:
TypeError: If any `sample` in `samples` is not a dict.
TypeError: If any `energy` in `energies` is not an int
or float.
TypeError: If any `data` in `sample_data` is not a dict.
ValueError: If any of the values in `sample` are not -1
or 1.
TypeError: If energy is not provided, h and J must be.
Examples:
>>> samples = [{0: -1}, {0: 1}, {0: -1}]
>>> energies = [1, -1, 1]
>>> sample_data = [{'t': .2}, {'t': .5}, {'t': .1}]
>>> response = SpinResponse()
>>> response.add_samples_from(samples, energies)
>>> list(response.samples())
[{0: 1}, {0: -1}, {0: -1}]
>>> response = SpinResponse()
>>> response.add_samples_from(samples, energies, sample_data)
>>> list(response.samples())
[{0: 1}, {0: -1}, {0: -1}]
>>> items = [({0: -1}, -1), ({0: -1}, 1)]
>>> response = SpinResponse()
>>> response.add_samples_from(*zip(*items))
>>> list(response.samples())
[{0: 1}, {0: -1}]
>>> response = SpinResponse()
>>> response.add_samples_from(samples, h={0: -1}, J={}})
>>> list(response.energies())
[-1, 1, 1]
"""
samples = list(samples)
if not all(isinstance(sample, dict) for sample in samples):
raise TypeError("expected each sample in 'samples' to be a dict")
if energies is None:
if h is None or J is None:
raise TypeError("most provide 'energy' or 'h' and 'J'")
energies = [ising_energy(sample, h, J) for sample in samples]
TemplateResponse.add_samples_from(self,
samples,
energies,
num_occurences=num_occurences,
**kwargs)
def add_samples_from(self,
samples,
energies=None,
sample_data=None,
h=None,
J=None):
"""Loads samples and associated energies from iterators.
Args:
samples (iterator): An iterable object that yields
samples. Each sample should be a dict of the form
{var: value, ...}.
energies (iterator): An iterable object that yields
energies associated with each sample.
sample_data (iterator, optional): An iterable object
that yields data about each sample as dict. Default
empty dicts.
h (dict) and J (dict): Define an Ising problem that can be
used to calculate the energy associated with `sample`.
Notes:
Solutions are stored in order of energy, lowest first.
Raises:
TypeError: If any `sample` in `samples` is not a dict.
TypeError: If any `energy` in `energies` is not an int
or float.
TypeError: If any `data` in `sample_data` is not a dict.
ValueError: If any of the values in `sample` are not -1
or 1.
TypeError: If energy is not provided, h and J must be.
Examples:
>>> samples = [{0: -1}, {0: 1}, {0: -1}]
>>> energies = [1, -1, 1]
>>> sample_data = [{'t': .2}, {'t': .5}, {'t': .1}]
>>> response = SpinResponse()
>>> response.add_samples_from(samples, energies)
>>> list(response.samples())
[{0: 1}, {0: -1}, {0: -1}]
>>> response = SpinResponse()
>>> response.add_samples_from(samples, energies, sample_data)
>>> list(response.samples())
[{0: 1}, {0: -1}, {0: -1}]
>>> items = [({0: -1}, -1), ({0: -1}, 1)]
>>> response = SpinResponse()
>>> response.add_samples_from(*zip(*items))
>>> list(response.samples())
[{0: 1}, {0: -1}]
>>> response = SpinResponse()
>>> response.add_samples_from(samples, h={0: -1}, J={}})
>>> list(response.energies())
[-1, 1, 1]
"""
samples = list(samples)
if not all(isinstance(sample, dict) for sample in samples):
raise TypeError("expected each sample in 'samples' to be a dict")
if any(
any(val not in (-1, 1) for val in itervalues(sample))
for sample in samples):
raise ValueError(
'given sample is not spin-valued. Values should be -1 or 1')
if energies is None:
if h is None or J is None:
raise TypeError("most provide 'energy' or 'h' and 'J'")
energies = [ising_energy(h, J, sample) for sample in samples]
TemplateResponse.add_samples_from(self, samples, energies, sample_data)
