Example #1
0
    def setUp(self):

        # wavefunction
        self.wf = RBF_HO1D(ndim=1, nelec=1, ncenter=5)

        #sampler
        self.mh_sampler = METROPOLIS(nwalkers=250,
                                     nstep=1000,
                                     step_size=3.,
                                     nelec=self.wf.nelec,
                                     ndim=self.wf.ndim,
                                     domain={
                                         'min': -5,
                                         'max': 5
                                     })

        #sampler
        self.hmc_sampler = HAMILTONIAN(nwalkers=250,
                                       nstep=1000,
                                       step_size=0.01,
                                       nelec=self.wf.nelec,
                                       ndim=self.wf.ndim,
                                       domain={
                                           'min': -5,
                                           'max': 5
                                       },
                                       L=5)

        # optimizer
        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)

        # network
        self.net = DeepQMC(wf=self.wf,
                           sampler=self.mh_sampler,
                           optimizer=self.opt)
Example #2
0
    def setUp(self):

        # optimal parameters
        self.opt_r = 0.97 # the two h are at +0.97 and -0.97
        self.opt_sigma = 1.20

        # wavefunction
        centers = torch.tensor([[0.,0.,-self.opt_r],[0.,0.,self.opt_r]])
        sigma = torch.tensor([self.opt_sigma,self.opt_sigma])

        self.wf = RBF_H2p(centers = centers,
                          sigma   = sigma )

        #sampler
        self.mh_sampler = METROPOLIS(nwalkers=1000, nstep=1000, 
                             step_size = 0.5, nelec = self.wf.nelec, 
                             ndim = self.wf.ndim, domain = {'min':-5,'max':5})

        #sampler
        self.hmc_sampler = HAMILTONIAN(nwalkers=1000, nstep=200, 
                             step_size = 0.1, nelec = self.wf.nelec, 
                             ndim = self.wf.ndim, domain = {'min':-5,'max':5}, L=5)

        # optimizer
        self.opt = optim.Adam(self.wf.parameters(),lr=0.001)

        # network
        self.net = DeepQMC(wf=self.wf,sampler=self.mh_sampler,optimizer=self.opt)


        # ground state energy
        self.ground_state_energy = -0.597
Example #3
0
    def setUp(self):

        # wavefunction
        self.wf = RBF_H(centers=torch.tensor([[0., 0., 0.]]),
                        sigma=torch.tensor([1.]))

        #sampler
        self.mh_sampler = METROPOLIS(nwalkers=1000,
                                     nstep=1000,
                                     step_size=3.,
                                     nelec=self.wf.nelec,
                                     ndim=self.wf.ndim,
                                     domain={
                                         'min': -5,
                                         'max': 5
                                     })

        #sampler
        self.hmc_sampler = HAMILTONIAN(nwalkers=1000,
                                       nstep=1000,
                                       step_size=0.01,
                                       nelec=self.wf.nelec,
                                       ndim=self.wf.ndim,
                                       domain={
                                           'min': -5,
                                           'max': 5
                                       },
                                       L=5)

        # optimizer
        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)

        # network
        self.net = DeepQMC(wf=self.wf,
                           sampler=self.mh_sampler,
                           optimizer=self.opt)

        # ground state energy
        self.ground_state_energy = -0.5
Example #4
0
#sampler
sampler = METROPOLIS(nwalkers=250,
                     nstep=1000,
                     step_size=3.,
                     nelec=wf.nelec,
                     ndim=wf.ndim,
                     domain={
                         'min': -5,
                         'max': 5
                     })

# optimizer
opt = optim.Adam(wf.parameters(), lr=0.01)

# network
net = DeepQMC(wf=wf, sampler=sampler, optimizer=opt)
pos, obs_dict = None, None

# set up the plotter
plt.ion()
plot2D = plotter2d(wf, domain, [25, 25], sol=ho2d_sol, kinetic=False)

# train the wavefunction
pos, obs_dict = net.train(100,
                          batchsize=250,
                          pos=pos,
                          obs_dict=obs_dict,
                          resample=100,
                          ntherm=-1,
                          loss='variance',
                          plot=plot2D)