def test_classicalisingenergy(self):
svecs = np.array([
[-1,1,-1,1,1,-1,-1,1], # E = 4.0
[1,1,1,1,1,-1,1,-1], # E = -8.0
[1,-1,1,1,-1,-1,-1,-1], # E = -4.0
[1,-1,-1,1,1,-1,1,1] # E = 0.0
])
energies = [4.0, -8.0, -4.0, 0.0]
for vec, en in zip(svecs, energies):
print sa.ClassicalIsingEnergy(vec, self.isingJ), en
assert(sa.ClassicalIsingEnergy(vec, self.isingJ) == en)
def test_qmc(self):
configurations = np.tile(np.array([ 2*self.rng.randint(2)-1
for k in range(self.nspins) ],
dtype=np.float64),
(self.trotterslices, 1)).T
annealingsched = np.linspace(self.fieldstart,
self.fieldend,
self.annealingsteps)
qmc.QuantumAnneal(annealingsched,
self.annealingmcsteps,
self.trotterslices,
self.annealingtemp,
self.nspins,
configurations,
self.nbs,
self.rng)
energies = np.array(
[ sa.ClassicalIsingEnergy(configurations[:,k], self.isingJ)
for k in range(self.trotterslices) ]
)
# assert that we found at least one lowest state energy amongst the slices
assert(np.sum(energies) == -8.0*self.trotterslices)
for k in range(self.trotterslices):
assert(np.sum(configurations[:4,k]) == 4.0 or
np.sum(configurations[:,k]) == -8.0)
def test_sa(self):
for i in range(self.trotterslices):
spinVector = np.array([ 2*self.rng.randint(2)-1
for k in range(self.nspins) ],
dtype=np.float64)
tannealingsched = np.linspace(self.preannealingtemp,
self.annealingtemp,
self.annealingsteps)
sa.Anneal(tannealingsched,
self.annealingmcsteps,
spinVector,
self.nbs,
self.rng)
# with the given parameters, they have surely found a ground state
assert(np.sum(spinVector[:4]) == 4 or
np.sum(spinVector) == -8)
assert(sa.ClassicalIsingEnergy(spinVector, self.isingJ) == -8.0)
print "True magnetization: ", np.sum(groundstate)
print "True magnetization per spin: ", np.sum(groundstate) / float(nspins)
print '\n'
# Get list of nearest-neighbors for each spin
# neighbors = tools.GenerateNeighbors(
# nspins,
# isingJ,
# 4,
# 'ising_instances/santoro_80x80_neighbors.npy'
# )
neighbors = np.load('ising_instances/santoro_80x80_neighbors.npy')
# initialize the states
spinVector = np.array([2 * rng.randint(2) - 1 for k in range(nspins)],
dtype=np.float)
configurations = np.tile(spinVector, (trotterslices, 1)).T
print("Initial state energy: ", sa.ClassicalIsingEnergy(spinVector, isingJ))
print '\n'
# Try just using SA
tannealingsched = np.linspace(preannealingtemp, annealingtemp, annealingsteps)
t0 = time.time()
sa.Anneal(tannealingsched, annealingmcsteps, spinVector, neighbors, rng)
t1 = time.time()
print("Final SA energy: ", sa.ClassicalIsingEnergy(spinVector, isingJ))
print str(
np.sum(spinVector == groundstate)) + '/' + str(nspins) + ' spins agree'
print "SA time (seconds): ", str(t1 - t0)
print '\n'
# Now do PIQA
preannealingsched = np.linspace(preannealingtemp, annealingtemp, 100)
annealingsched = np.linspace(fieldstart, fieldend, annealingsteps)
# Print out energies we're supposed to see from QMC sims
print("All possible states and their energies:")
results = []
def bitstr2spins(vec):
""" Take a bitstring and return a spinvector. """
a = [int(k) for k in vec]
return tools.bits2spins(a)
for b in [bin(x)[2:].rjust(nspins, '0') for x in range(2**nspins)]:
bvec = np.array([int(k) for k in b])
svec = bitstr2spins(b)
bstr = reduce(lambda x, y: x + y, [str(k) for k in bvec])
results.append([sa.ClassicalIsingEnergy(svec, isingJ), bstr])
for res in sorted(results):
print res
# Initialize random state
spinVector = np.array([2 * rng.randint(2) - 1 for k in range(nspins)],
dtype=np.float)
spinVector_original = spinVector.copy()
configurations = np.tile(spinVector, (trotterslices, 1)).T
# Generate list of nearest-neighbors for each spin
neighbors = tools.GenerateNeighbors(nspins, isingJ, 4)
# Generate annealing schedules
tannealingsched = np.linspace(preannealingtemp, annealingtemp, annealingsteps)
annealingsched = np.linspace(fieldstart, fieldend, annealingsteps)
# Try using SA (deterministic start)
print("SA results using same starting state:")
# Print out energies we're supposed to see
print("All possible states and their energies:")
results = []
def bitstr2spins(vec):
""" Take a bitstring and return a spinvector. """
a = [int(k) for k in vec]
return tools.bits2spins(a)
for b in [bin(x)[2:].rjust(nspins, '0') for x in range(2**nspins)]:
bvec = np.array([int(k) for k in b])
svec = bitstr2spins(b)
bstr = reduce(lambda x, y: x + y, [str(k) for k in bvec])
results.append([sa.ClassicalIsingEnergy(svec, isingJ), bstr])
for res in sorted(results): #[:100]:
print res
print("\n")
# Generate list of nearest-neighbors for each spin
neighbors = tools.GenerateNeighbors(nspins, isingJ, 5)
# Generate annealing schedules
tannealingsched = np.linspace(preannealingtemp, annealingtemp, annealingsteps)
# Generate random states to compare
svecs = np.asarray([[2 * rng.randint(2) - 1 for k in range(nspins)]
for j in xrange(samples)],
dtype=np.float)
problems = [
'11111000', '11000001', '01100101', '01101000', '00010011', '11110100'
]
problems = np.array([bitstr2spins(k) for k in problems])
[str(int(k)) for k in tools.spins2bits(vec)])
# Construct Ising matrix
memMat = sp.matrix(memories).T
isingJ = sp.triu(memMat * sp.linalg.pinv(memMat))
isingJ -= sp.diag(sp.diag(isingJ))
isingJ = sp.triu(memMat * sp.linalg.pinv(memMat))
isingJ += inpbias * sp.diag(vinput)
isingJ = sps.dok_matrix(isingJ)
# get energies of all states
results = []
energies = np.zeros(2**nspins)
for b in [bin(x)[2:].rjust(nspins, '0') for x in range(2**nspins)]:
svec = tools.bits2spins(np.array([int(k) for k in b]))
energies[int(b, 2)] = sa.ClassicalIsingEnergy(svec, isingJ)
results.append([energies[int(b, 2)], b])
print("All possible states and their energies:")
for res in sorted(results)[:10]:
print("%s %2.4f" % tuple(res[::-1]))
# Initialize random state
spinVector = np.array([2 * rng.randint(2) - 1 for k in range(nspins)],
dtype=np.float)
confs = np.tile(spinVector, (trotterslices, 1)).T
# Generate list of nearest-neighbors for each spin
neighbors = tools.GenerateNeighbors(nspins, isingJ, 8)
# keep a count of the populations
coinc_sa = np.zeros(2**nspins)
coinc_qa = np.zeros(2**nspins)
gsenergy = np.dot(groundstate, -isingJ.dot(groundstate))
print "True groundstate energy: ", gsenergy
print "True energy per spin: ", gsenergy / float(nspins)
print "True magnetization: ", np.sum(groundstate)
print "True magnetization per spin: ", np.sum(groundstate) / float(nspins)
print '\n'
# make a bunch of random binary (non-spin!!) starting states
msvec = np.array([
np.array([rng.randint(2) for k in range(nspins)], dtype=np.float)
for row in xrange(64)
])
# get the spin version
svec = 2 * msvec - 1
print("Initial state energy: ",
sorted([sa.ClassicalIsingEnergy(v, isingJ) for v in svec]))
print '\n'
# Generate list of nearest-neighbors for each spin
neighbors = tools.GenerateNeighbors(nspins, isingJ, 4)
# SA annealing schedule
tannealingsched = np.linspace(preannealingtemp, annealingtemp, annealingsteps)
# Normal annealing routine
t0 = time.time()
for vec in svec:
sa.Anneal(tannealingsched, annealingmcsteps, vec, neighbors, rng)
t1 = time.time()
print("Final SA energy: ",
sorted([sa.ClassicalIsingEnergy(v, isingJ) for v in svec]))
print "SA time (seconds): ", str(t1 - t0)
gstate_sa = 0
exstate_sa = 0
sa_errors = 0
gstate_qmc = 0
exstate_qmc = 0
qmc_errors = 0
qmc_errors_diff = 0
print("")
print("# samples", samples)
# Try using SA (random start)
for sa_itr in xrange(samples):
spinVector = np.array([2 * rng.randint(2) - 1 for k in range(nspins)],
dtype=np.float)
starten, startstate = (sa.ClassicalIsingEnergy(spinVector, isingJ),
getbitstr(spinVector))
sa.Anneal(tannealingsched, preannealingmcsteps, spinVector, neighbors, rng)
bitstr = getbitstr(spinVector)
# print("Start", starten, startstate[:8], startstate[8:])
# print(#sa.ClassicalIsingEnergy(spinVector, isingJ),
# bitstr[:8], bitstr[8:])
if bitstr == '0000000011111111':
exstate_sa += 1
elif (bitstr == '1111111111111111' or bitstr == '0000000000000000'):
gstate_sa += 1
else:
sa_errors += 1
# gstate_sa /= float(samples)
# exstate_sa /= float(samples)
gsenergy = np.dot(groundstate, -isingJ.dot(groundstate))
print "True groundstate energy: ", gsenergy
# Generate list of nearest-neighbors for each spin
neighbors = tools.GenerateNeighbors(nspins, isingJ, 4)
# Try just using SA
tannealingsched = np.linspace(preannealingtemp, annealingtemp, annealingsteps)
spinVector = np.array([2 * rng.randint(2) - 1 for k in range(nspins)],
dtype=np.float)
spinVector2 = spinVector.copy()
# configurations = np.tile(spinVector, (trotterslices, 1)).T
print("")
print("Parallel version:")
print("Initial state energy: ", sa.ClassicalIsingEnergy(spinVector, isingJ))
for i in range(1, 5):
print("Cores: ", i)
spinVector = spinVector2.copy()
t0 = time.time()
sa.Anneal_parallel(tannealingsched, annealingmcsteps, spinVector,
neighbors, i)
t1 = time.time()
print("Final energy: ", sa.ClassicalIsingEnergy(spinVector, isingJ))
print("Residual: ", sa.ClassicalIsingEnergy(spinVector, isingJ) - gsenergy)
print("Time: ", t1 - t0)
print("")
print("\nSequential version:")
print("Initial state energy: ", sa.ClassicalIsingEnergy(spinVector2, isingJ))
t0 = time.time()
# neighbors = tools.GenerateNeighbors(nspins, isingJ, 4, 'ising_instances/santoro_80x80_neighbors.npy')
neighbors = np.load('ising_instances/santoro_80x80_neighbors.npy')
# Try just using SA
tannealingsched = np.linspace(preannealingtemp, annealingtemp, annealingsteps)
annealingsched = np.linspace(fieldstart, fieldend, annealingsteps)
spinVector = np.array([2 * rng.randint(2) - 1 for k in range(nspins)],
dtype=np.float)
spinVector2 = spinVector.copy()
configurations = np.tile(spinVector, (trotterslices, 1)).T
print("")
print("Thermal Annealing")
print("=" * 20)
print("Parallel version:")
print("Initial state energy: ", sa.ClassicalIsingEnergy(spinVector, isingJ))
for i in range(1, 5):
print("Cores: ", i)
spinVector = spinVector2.copy()
t0 = time.time()
sa.Anneal_parallel(tannealingsched, annealingmcsteps, spinVector,
neighbors, i)
t1 = time.time()
print("Final energy: ", sa.ClassicalIsingEnergy(spinVector, isingJ))
print("Residual: ", sa.ClassicalIsingEnergy(spinVector, isingJ) - gsenergy)
print("Time: ", t1 - t0)
print("")
spinVector = spinVector2.copy()
print("\nSequential version:")
print("Initial state energy: ", sa.ClassicalIsingEnergy(spinVector2, isingJ))
t0 = time.time()
