def __init__(self, name='hamiltonian', **kwargs):
super(HamiltonianBase, self).__init__()
# lattice
if 'lattice' in kwargs:
ltc = kwargs.pop('lattice')
if islattice(ltc):
self.lattice = ltc
elif isinstance(ltc, dict):
self.lattice = Lattice(**ltc)
else:
lattice_kwargs = self.__get_lattice_kwargs(kwargs)
self.lattice = Lattice(ltc, **lattice_kwargs)
self.size = self.lattice.size()
elif self.__has_shape(kwargs):
lattice_kwargs = self.__get_lattice_kwargs(kwargs)
self.lattice = Chain(**lattice_kwargs)
self.size = self.lattice.size()
if len(self.size) is not 1:
raise ValueError("Wrong size, default lattice"
" is chain lattice")
else:
self.lattice = None
self.size = 1
self.name = name
self.params = kwargs
def test_tfi(self):
test = TFI(Chain(3, pbc=True), mag=1.0)
exact = - kronsum(sigmax, sigmax, sigmax) -\
kronprod(sigmaz, sigmaz, iden) - \
kronprod(sigmaz, iden, sigmaz) - \
kronprod(iden, sigmaz, sigmaz)
self.assertEqual((test != exact).nnz, 0)
def test_j1j2(self):
for i in range(4, 10):
lattice = Chain(i, pbc=True)
interaction = (1, 0.5)
test_h = J1J2(J=interaction, pbc=True, lattice=lattice)
exact = testutils.J1J2(lattice, J=interaction)
testutils.assertEqualSparse(self, test_h.mat(), exact)
self._test_energy(test_h)
for x in range(2, 4):
for y in range(2, 4):
lattice = Square(x, y, pbc=True)
test_h = J1J2(J=interaction, pbc=True, lattice=lattice)
exact = testutils.J1J2(lattice)
testutils.assertEqualSparse(self, test_h.mat(), exact)
self._test_energy(test_h)
def test_nlocal(self):
for k in range(1, 3):
self._test_chain(sigmax, k)
self._test_chain(sigmay, k)
self._test_chain(sigmaz, k)
# test square
for k in range(1, 3):
self._test_square(sigmax, k)
self._test_square(sigmay, k)
self._test_square(sigmaz, k)
# test J1J2
gen = J1J2(Chain(3, pbc=True))
def local(op, J=(1.0, 0.5)):
return J[0] * (kronprod(op, op, iden) +
kronprod(iden, op, op) +
kronprod(op, iden, op)) + \
J[1] * (kronprod(op, iden, op) +
kronprod(op, op, iden) +
kronprod(iden, op, op))
exact = local(sigmax) + local(sigmay) + local(sigmaz)
self.assertEqual((gen != exact).nnz, 0)
self.layers = nn.ModuleList(
[nn.Linear(x, y) for x, y in zip(sizes[0:-1], sizes[1:])])
def forward(self, x):
for i, layer in enumerate(self.layers):
if i is not len(self.layers) - 1:
x = F.relu(layer(x))
x = self.layers[-1](x)
return x
lattice = configurations['hamiltonian']['lattice']
size = configurations['hamiltonian']['lattice']['size']
model = MLP(*tuple(model['size']))
lattice = Chain(lattice['size'], pbc=lattice['pbc'])
hamiltonian = TFI(hamiltonain['mag'], lattice=lattice)
# model = FakeModel(hamiltonian)
# TODO: cuda support
# if device == 'cuda':
# model.cuda()
eigs, vecs = ed(hamiltonian.mat())
print(eigs[0])
def eloc(x):
ret = sum(val * model(Variable(config))
for config, val in hamiltonian.nnz(x))
return ret / model(Variable(x))
def __init__(self, *sizes):
super(MLP, self).__init__()
self.sizes = sizes
self.layers = nn.ModuleList(
[nn.Linear(x, y) for x, y in zip(sizes[0:-1], sizes[1:])])
def forward(self, x):
for i, layer in enumerate(self.layers):
if i is not len(self.layers) - 1:
x = F.relu(layer(x))
x = self.layers[-1](x)
return x
model = MLP(3, 12, 12, 1)
lattice = Chain(3, pbc=True)
hamiltonian = TFI(mag=1.0, lattice=lattice)
def eloc(x):
ret = sum(val * model(Variable(config))
for config, val in hamiltonian.nnz(x))
return ret / model(Variable(x))
def exact_energy():
return sum(torch.abs(model(Variable(config)))**2 * eloc(config))
def proposal(x):
amp = model(Variable(x))
def test_general_constructor(self):
lattice = Chain(3, pbc=True)
for name in __traits__.keys():
h = Ham(name, lattice=lattice)
self.assertIsInstance(h, __traits__[name])
def test_tfi(self):
for i in range(4, 10):
lattice = Chain(i, pbc=True)
test_h = TFI(mag=1.0, pbc=True, lattice=lattice)
exact = testutils.TFI(lattice, mag=1.0)
testutils.assertEqualSparse(self, test_h.mat(), exact)
def _test_chain(self, op, k):
gen = nlocal(op, Chain(3, pbc=True), k)
exact = sp.kron(sp.kron(op, op), iden) + \
sp.kron(sp.kron(op, iden), op) + \
sp.kron(sp.kron(iden, op), op)
self.assertEqual((gen != exact).nnz, 0)
class HamiltonianBase(object):
"""Hamiltonian Base"""
@staticmethod
def __has_shape(kwargs):
return any(['size' in kwargs, 'shape' in kwargs, 'length' in kwargs])
@staticmethod
def __get_lattice_kwargs(kwargs):
lattice_kwargs = {}
if 'size' in kwargs:
lattice_kwargs['shape'] = kwargs.pop('size')
elif 'shape' in kwargs:
lattice_kwargs['shape'] = kwargs.pop('shape')
elif 'length' in kwargs:
lattice_kwargs['length'] = kwargs.pop('length')
else:
raise TypeError("missing shape of the hamiltonian")
if 'pbc' in kwargs:
lattice_kwargs['pbc'] = kwargs.pop('pbc')
if 'lattice_params' in kwargs:
ltc_params = kwargs.pop('lattice_params')
if isinstance(ltc_params, dict):
lattice_kwargs.update(ltc_params)
else:
raise ValueError("lattice parameters should be dict"
"not %s" % type(ltc_params))
return lattice_kwargs
def __init__(self, name='hamiltonian', **kwargs):
super(HamiltonianBase, self).__init__()
# lattice
if 'lattice' in kwargs:
ltc = kwargs.pop('lattice')
if islattice(ltc):
self.lattice = ltc
elif isinstance(ltc, dict):
self.lattice = Lattice(**ltc)
else:
lattice_kwargs = self.__get_lattice_kwargs(kwargs)
self.lattice = Lattice(ltc, **lattice_kwargs)
self.size = self.lattice.size()
elif self.__has_shape(kwargs):
lattice_kwargs = self.__get_lattice_kwargs(kwargs)
self.lattice = Chain(**lattice_kwargs)
self.size = self.lattice.size()
if len(self.size) is not 1:
raise ValueError("Wrong size, default lattice"
" is chain lattice")
else:
self.lattice = None
self.size = 1
self.name = name
self.params = kwargs
def nnz(self, config):
"""
return the non-zero values in a hamiltonian H,
with its related configurations
"""
RHS = config.clone()
if self.lattice.dim is not config.dim():
raise ValueError('config size should meets hamiltonian')
return self.nnz_iter(RHS)
def nnz_iter(self, RHS):
raise NotImplementedError
def __str__(self):
ret = '%s:' % (self.name)
ret += '\n size: %s' % self.size
for param_key, param_val in self.params.items():
ret += '\n %s: %s' % (param_key, param_val)
return ret
def mat(self):
"""get the matrix form
Returns:
hamiltonian matrix: a scipy.sparse.lil_matrix
Raises:
Warning: when number of elements in the hamiltonian
is too large (> 25) a waring will raises.
"""
numel = 2**_prod(self.size)
if _prod(self.size) > 25:
raise Warning('this hamiltonian could be too large')
data = lil_matrix((numel, numel), dtype='complex128')
for lhs in IterateAll(size=self.size):
for rhs, val in self.nnz(lhs):
data[utils.bin(lhs), utils.bin(rhs)] += val
return data