def test_rbm_fim(self):
j = np.random.normal(0, 1)
visbias = np.random.normal()
hidbias = np.random.normal()
model = IsingModel(2)
model.import_rbm01(1, 1, [visbias], [hidbias], [[j]])
z = (np.exp(visbias) + np.exp(hidbias) +
np.exp(visbias + hidbias + j) + 1)
def f(x):
return x / z * (1 - x / z)
exp0 = np.exp(visbias + hidbias + j)
exp1 = np.exp(visbias) + exp0
exp2 = np.exp(hidbias) + exp0
varvis = f(exp1)
varhid = f(exp2)
varprod = f(exp0)
cov_vishid = exp0 / z - exp1 * exp2 / z ** 2
cov_visprod = exp0 / z * (1 - exp1 / z)
cov_hidprod = exp0 / z * (1 - exp2 / z)
sample = model.sample(20000)
fim = model.fisher_information(sample, model.fimfunction_rbm)
self.assertAlmostEqual(fim[0, 0], varvis, places=2)
self.assertAlmostEqual(fim[1, 1], varhid, places=2)
self.assertAlmostEqual(fim[2, 2], varprod, places=2)
self.assertAlmostEqual(fim[1, 0], cov_vishid, places=2)
self.assertAlmostEqual(fim[2, 0], cov_visprod, places=2)
self.assertAlmostEqual(fim[1, 2], cov_hidprod, places=2)
def test_physical(self):
n = 35
h = -0.5
j = 1 / n
model = IsingModel(n)
# disordered phase, should be .5 on average
beta = 1
model.import_uniform01(beta * h, beta * j)
sample = from_shaped_iter(model.sample(5000), bool, [5000, n])[200:]
self.assertAlmostEqual(np.mean(sample), .5, places=1)
# ordered phase, sol can be 0 or 1
beta = 16
model.import_uniform01(beta * h, beta * j)
sample = from_shaped_iter(model.sample(2000), bool, [2000, n])[200:]
self.assertAlmostEqual(abs(2 * np.mean(sample) - 1), 1, places=2)
def test_probabilities_onlyfields(self):
h = [np.random.normal()]
j_matrix = [[0]]
model = IsingModel(1)
model.import_ising01(h, j_matrix)
res = from_shaped_iter(model.sample(30000), bool, (30000, 1))
p1 = 1 / (1 + np.exp(-h[0]))
obs_prob = np.mean(res, axis=0)[0]
self.assertAlmostEqual(p1, obs_prob, places=2)
def test_probabilities_onlyinter(self):
h = [0, 0]
j = np.random.normal()
j_matrix = [[0, j], [j, 0]]
model = IsingModel(2)
model.import_ising01(h, j_matrix)
res = from_shaped_iter(model.sample(30000), bool, (30000, 2))
prod = res[:, 0] * res[:, 1]
p1 = np.mean(prod)
self.assertAlmostEqual(p1, 1 / (3 * np.exp(-j) + 1), places=2)
def test_input_data(self):
with self.assertRaises(ValueError):
model = IsingModel(3)
model.import_ising01([0, 0, 0], [[0, 0], [0, 0]])
with self.assertRaises(ValueError):
model = IsingModel(2)
model.import_ising01([0, 0, 0], [[0, 0], [0, 0]])
with self.assertRaises(ValueError):
model = IsingModel(0)
with self.assertRaises(ValueError):
model = IsingModel(2)
list(model.sample(-1))
def sample_e_with_beta(beta):
model = IsingModel(numspin)
model.import_uniform01(beta * h, beta * j)
sampled_states = model.sample(n)
states = np.empty([n, numspin], dtype=bool)
energies = np.empty(n)
for i, state in enumerate(sampled_states):
states[i] = state
energies[i] = model.hamiltonian(state)
np.save(resdir + "states_" + "beta" + str(beta) + "_n" +
str(numspin) + ".npy", states)
np.save(resdir + "energies_" + "beta" + str(beta) + "_n" +
str(numspin) + ".npy", energies)
def test_shape_null(self):
model = IsingModel(1)
model.import_ising01([0], [[0]])
res = from_shaped_iter(model.sample(1), bool, (1, 1))
self.assertEqual(res.shape[0], 1)
self.assertEqual(res.shape[1], 1)
def test_res_shapes(self):
model = IsingModel(2)
model.import_ising01([0, 0], [[0, 0], [0, 0]])
res = from_shaped_iter(model.sample(3), bool, (3, 2))
self.assertEqual(len(res[0]), 2)
self.assertEqual(len(res[:, 0]), 3)
import numpy as np
from time import time
# from pycallgraph import PyCallGraph
# from pycallgraph.output import GraphvizOutput
# with PyCallGraph(output=GraphvizOutput()):
numspin = 30
n = 1000
np.random.seed(56426481)
h = np.random.normal(size=numspin)
j = np.random.normal(size=(numspin, numspin))
j += j.T
j[np.diag_indices_from(j)] = np.zeros(numspin)
# np.random.seed()
ntrials = 20
t = time()
for _ in range(10):
model = IsingModel(numspin)
model.import_ising01(h, j)
for x in model.sample(n):
pass
t = time() - t
print('Time taken, ' + str(ntrials) + ' trials:')
print(str(t) + ' seconds.')
from time import time
numspin = 300
n = 100
seed = np.random.choice(1000)
j0 = np.random.random()
h0 = np.random.normal()
j = np.ones((numspin, numspin)) * j0
h = np.ones(numspin) * h0
j[np.diag_indices_from(j)] = np.zeros(numspin)
model_full = IsingModel(numspin)
model_full.import_ising01(h, j)
np.random.seed(seed)
t = time()
for x in model_full.sample(n):
pass
print(time() - t)
model_mf = IsingModel(numspin)
model_mf.import_uniform01(h0, j0)
np.random.seed(seed)
t = time()
for x in model_mf.sample(n):
pass
print(time() - t)
