def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, fortran=True, debug=True)
ret = minimizer.run()
m2 = LBFGS(self.x.copy(), self.pot, fortran=False, debug=True)
ret2 = m2.run()
print("fortran", ret.nfev, ret2.nfev)
# self.assertEqual(ret.nfev, ret2.nfev)
self.assertAlmostEqual(ret.energy, ret2.energy, 5)
def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, fortran=True, debug=True)
ret = minimizer.run()
m2 = LBFGS(self.x.copy(), self.pot, fortran=False, debug=True)
ret2 = m2.run()
print "fortran", ret.nfev, ret2.nfev
# self.assertEqual(ret.nfev, ret2.nfev)
self.assertAlmostEqual(ret.energy, ret2.energy, 5)
def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, armijo=True, debug=True)
ret = minimizer.run()
self.assertTrue(ret.success)
print "\n\n"
minimizer = LBFGS(self.x.copy(), self.pot, armijo=False, debug=True)
ret_nowolfe = minimizer.run()
self.assertTrue(ret_nowolfe.success)
print "nfev armijo, noarmijo", ret.nfev, ret_nowolfe.nfev, ret.energy, ret_nowolfe.energy
def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, debug=True)
minimizer._cython = True
ret = minimizer.run()
m2 = LBFGS(self.x.copy(), self.pot, debug=True)
minimizer._cython = True
ret2 = m2.run()
print("cython", ret.nfev, ret2.nfev)
self.assertEqual(ret.nfev, ret2.nfev)
self.assertAlmostEqual(ret.energy, ret2.energy, 5)
def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, debug=True)
minimizer._cython = True
ret = minimizer.run()
m2 = LBFGS(self.x.copy(), self.pot, debug=True)
minimizer._cython = True
ret2 = m2.run()
print "cython", ret.nfev, ret2.nfev
self.assertEqual(ret.nfev, ret2.nfev)
self.assertAlmostEqual(ret.energy, ret2.energy, 5)
def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, debug=True)
minimizer._use_wolfe = True
ret = minimizer.run()
self.assertTrue(ret.success)
print "\n\n"
minimizer = LBFGS(self.x.copy(), self.pot, debug=True)
ret_nowolfe = minimizer.run()
self.assertTrue(ret_nowolfe.success)
print "nfev wolfe, nowolfe", ret.nfev, ret_nowolfe.nfev, ret.energy, ret_nowolfe.energy
def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, debug=True)
minimizer._use_wolfe = True
ret = minimizer.run()
self.assertTrue(ret.success)
print "\n\n"
minimizer = LBFGS(self.x.copy(), self.pot, debug=True)
ret_nowolfe = minimizer.run()
self.assertTrue(ret_nowolfe.success)
print "nfev wolfe, nowolfe", ret.nfev, ret_nowolfe.nfev, ret.energy, ret_nowolfe.energy
def test(self):
minimizer = LBFGS(self.x.copy(), self.pot, armijo=True, debug=True)
ret = minimizer.run()
self.assertTrue(ret.success)
print "\n\n"
minimizer = LBFGS(self.x.copy(), self.pot, armijo=False, debug=True)
ret_nowolfe = minimizer.run()
self.assertTrue(ret_nowolfe.success)
self.assertAlmostEqual(ret.energy, ret_nowolfe.energy, delta=1e-3)
print "nfev armijo, noarmijo", ret.nfev, ret_nowolfe.nfev, ret.energy, ret_nowolfe.energy
def runtest(X, pot, natoms = 100, iprint=-1):
from _lbfgs_py import PrintEvent
tol = 1e-5
maxstep = 0.005
Xinit = np.copy(X)
e, g = pot.getEnergyGradient(X)
print "energy", e
lbfgs = LBFGS(X, pot, maxstep = 0.1, nsteps=10000, tol=tol,
iprint=iprint, H0=2.)
printevent = PrintEvent( "debugout.xyz")
lbfgs.attachEvent(printevent)
ret = lbfgs.run()
print ret
print ""
print "now do the same with scipy lbfgs"
from pele.optimize import lbfgs_scipy as quench
ret = quench(Xinit, pot, tol = tol)
print ret
#print ret[1], ret[2], ret[3]
if False:
print "now do the same with scipy bfgs"
from pele.optimize import bfgs as oldbfgs
ret = oldbfgs(Xinit, pot, tol = tol)
print ret
if False:
print "now do the same with gradient + linesearch"
import _bfgs
gpl = _bfgs.GradientPlusLinesearch(Xinit, pot, maxstep = 0.1)
ret = gpl.run(1000, tol = 1e-6)
print ret
if False:
print "calling from wrapper function"
from pele.optimize import lbfgs_py
ret = lbfgs_py(Xinit, pot, tol = tol)
print ret
if True:
print ""
print "now do the same with lbfgs_py"
from pele.optimize import lbfgs_py
ret = lbfgs_py(Xinit, pot, tol = tol)
print ret
try:
import pele.utils.pymolwrapper as pym
pym.start()
for n, coords in enumerate(printevent.coordslist):
coords=coords.reshape(natoms, 3)
pym.draw_spheres(coords, "A", n)
except ImportError:
print "error loading pymol"
def lbfgs_py(coords, pot, **kwargs):
if not hasattr(pot, "getEnergyGradient"):
# for compatibility with old quenchers.
# assume pot is a getEnergyGradient function
pot = _getEnergyGradientWrapper(pot)
lbfgs = LBFGS(coords, pot, **kwargs)
return lbfgs.run()
def test1(self):
pot = DiscontinuousHarmonic()
x0 = np.array([-10, 1])
opt = LBFGS(x0, pot, debug=True)
print('this runnnns')
res = opt.run()
self.assertFalse(res.success)
def _lbfgs_py(coords, pot, **kwargs):
lbfgs = LBFGS(coords, pot, **kwargs)
ret = lbfgs.run()
coords = ret.coords
e = ret.energy
rms = ret.rms
funcalls = ret.nfev
return coords, e, rms, funcalls, ret
def run(X_train):
# fit a Gaussian Mixture Model with two components
clf = mixture.GMM(n_components=2, covariance_type='full')
pot = GMMPotential(clf, X_train)
params = pot.get_random_coords()
print params
e, g = pot.getEnergyGradient(params)
print "energy", e
print "grad", g
opt = LBFGS(params, pot, tol=1e-5, maxstep=1., iprint=1)#, events=[print_event])
res = opt.run()
print "finished"
e, g = pot.getEnergyGradient(res.coords)
print "energy", e
print "grad"
print "grad", g
# raise Exception("exiting early")
# clf.fit(X_train)
print "weights"
print clf.covars_
print "\nmeans"
print clf.means_
print "\ncovariances"
print clf.covars_
# display predicted scores by the model as a contour plot
x = np.linspace(-20.0, 30.0)
y = np.linspace(-20.0, 40.0)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)[0]
Z = Z.reshape(X.shape)
CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)
plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
make_ellipses(clf, plt.gca())
plt.show()
def test1(self):
pot = DiscontinuousHarmonic()
x0 = np.array([-10, 1])
opt = LBFGS(x0, pot, debug=True)
res = opt.run()
self.assertFalse(res.success)
def lbfgs_py(coords, pot, **kwargs):
lbfgs = LBFGS(coords, pot, **kwargs)
return lbfgs.run()
def lbfgs_py(coords, pot, **kwargs):
lbfgs = LBFGS(coords, pot, **kwargs)
return lbfgs.run()
class TestMYLBFGS_LBFGS(unittest.TestCase):
def setUp(self):
self.setUp1(verbose=False)
def setUp1(self, verbose=False, **kwargs):
np.random.seed(0)
natoms = 18
self.system = LJCluster(natoms)
self.pot = self.system.get_potential()
x = self.system.get_random_configuration()
ret = lbfgs_py(x, self.pot, tol=10)
self.x = ret.coords
self.kwargs = kwargs
self.verbose = verbose
self.M = 4
if self.verbose: iprint = 1
else: iprint = -1
self.myo = MYLBFGS(self.x,
self.pot,
iprint=iprint,
debug=True,
M=self.M)
self.o = LBFGS(self.x,
self.pot,
iprint=iprint,
debug=True,
M=self.M,
**self.kwargs)
def test(self):
N = self.x.size
M = self.M
myo = self.myo
o = self.o
# do one iteration
for i in range(3 * self.M):
myo.one_iteration()
o.one_iteration()
if self.verbose:
print("")
print("H0", myo.H0, o.H0)
print("rho ", o.rho[:])
print("myrho", myo.W[N:N + M])
myret = myo.get_result()
ret = o.get_result()
self.assertAlmostEqual(ret.energy, myret.energy, 4)
self.assertLess(np.max(np.abs(myret.coords - ret.coords)), 1e-6)
# do a second iteration
for i in range(1):
myo.one_iteration()
o.one_iteration()
myret = myo.get_result()
ret = o.get_result()
if self.verbose:
print("H0", myret.H0, ret.H0)
print("rho ", o.rho[:])
print("myrho", myo.W[N:N + M])
self.assertAlmostEqual(ret.energy, myret.energy, 4)
self.assertLess(np.max(np.abs(myret.coords - ret.coords)), 1e-6)
def test_complete(self):
myret = self.myo.run()
ret = self.o.run()
self.assertEqual(ret.nfev, myret.nfev)
self.assertEqual(ret.nsteps, myret.nsteps)
self.assertAlmostEqual(ret.energy, myret.energy, 4)
self.assertLess(np.max(np.abs(myret.coords - ret.coords)), 1e-6)
class TestMYLBFGS_LBFGS(unittest.TestCase):
def setUp(self):
self.setUp1(verbose=False)
def setUp1(self, verbose=False, **kwargs):
np.random.seed(0)
natoms = 18
self.system = LJCluster(natoms)
self.pot = self.system.get_potential()
x = self.system.get_random_configuration()
ret = lbfgs_py(x, self.pot, tol=10)
self.x = ret.coords
self.kwargs = kwargs
self.verbose = verbose
self.M = 4
if self.verbose: iprint=1
else: iprint = -1
self.myo = MYLBFGS(self.x, self.pot, iprint=iprint, debug=True, M=self.M)
self.o = LBFGS(self.x, self.pot, iprint=iprint, debug=True, M=self.M, **self.kwargs)
def test(self):
N = self.x.size
M = self.M
myo = self.myo
o = self.o
# do one iteration
for i in xrange(3 * self.M):
myo.one_iteration()
o.one_iteration()
if self.verbose:
print ""
print "H0", myo.H0, o.H0
print "rho ", o.rho[:]
print "myrho", myo.W[N:N+M]
myret = myo.get_result()
ret = o.get_result()
self.assertAlmostEqual(ret.energy, myret.energy, 4)
self.assertLess(np.max(np.abs(myret.coords - ret.coords)), 1e-6)
# do a second iteration
for i in xrange(1):
myo.one_iteration()
o.one_iteration()
myret = myo.get_result()
ret = o.get_result()
if self.verbose:
print "H0", myret.H0, ret.H0
print "rho ", o.rho[:]
print "myrho", myo.W[N:N+M]
self.assertAlmostEqual(ret.energy, myret.energy, 4)
self.assertLess(np.max(np.abs(myret.coords - ret.coords)), 1e-6)
def test_complete(self):
myret = self.myo.run()
ret = self.o.run()
self.assertEqual(ret.nfev, myret.nfev)
self.assertEqual(ret.nsteps, myret.nsteps)
self.assertAlmostEqual(ret.energy, myret.energy, 4)
self.assertLess(np.max(np.abs(myret.coords - ret.coords)), 1e-6)
