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()