Add tests for TR subproblem. Make curvature calc more robust.

Author: mjhough

dfols/tests/test_trust_region.py

@@ -30,6 +30,8 @@
 from dfols.trust_region import ctrsbox, ctrsbox_geometry, trsbox, trsbox_geometry
 from dfols.util import model_value
 
+import pdb
+
 
 def cauchy_pt(g, H, delta):
     # General expression for the Cauchy point
@@ -73,167 +75,8 @@ def cauchy_pt_box(g, H, delta, lower, upper):
 def p_box(x,l,u):
     return np.minimum(np.maximum(x,l), u)
 
-class TestUncInternalCDFO(unittest.TestCase):
-    def runTest(self):
-        n = 3
-        g = np.array([1.0, 0.0, 1.0])
-        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
-        Delta = 2.0
-        xopt = np.ones((n,))  # trying nonzero (since bounds inactive)
-        sl = -1e20 * np.ones((n,))
-        su = 1e20 * np.ones((n,))
-        d, gnew, crvmin = ctrsbox(xopt, g, H, sl, su, [], Delta)
-        true_d = np.array([-1.0, 0.0, -0.5])
-        est_min = model_value(g, H, d)
-        true_min = model_value(g, H, true_d)
-        # Hope to get actual correct answer for internal minimum?
-        # self.assertTrue(np.all(d == true_d), 'Wrong answer')
-        # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
-        s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
-        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
-        print(crvmin)
-        self.assertAlmostEqual(crvmin, 1.2, 'Wrong crvmin')
-
-class TestUncBdryCDFO(unittest.TestCase):
-    def runTest(self):
-        n = 3
-        g = np.array([1.0, 0.0, 1.0])
-        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
-        Delta = 5.0 / 12.0
-        xopt = np.zeros((n,))
-        sl = -1e20 * np.ones((n,))
-        su = 1e20 * np.ones((n,))
-        pbox = lambda x: p_box(x,sl,su)
-        d, gnew, crvmin = ctrsbox(xopt, g, H, sl, su, [], Delta)
-        true_d = np.array([-1.0 / 3.0, 0.0, -0.25])
-        est_min = model_value(g, H, d)
-        true_min = model_value(g, H, true_d)
-        # Hope to get actual correct answer
-        # self.assertTrue(np.all(d == true_d), 'Wrong answer')
-        # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
-        s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
-        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
-        self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
-
-class TestUncBdry2CDFO(unittest.TestCase):
-    def runTest(self):
-        n = 3
-        g = np.array([1.0, 0.0, 1.0])
-        H = np.array([[-2.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, -1.0]])
-        Delta = 5.0 / 12.0
-        xopt = np.zeros((n,))
-        sl = -1e20 * np.ones((n,))
-        su = 1e20 * np.ones((n,))
-        pbox = lambda x: p_box(x,sl,su)
-        d, gnew, crvmin = ctrsbox(xopt, g, H, sl, su, [], Delta)
-        true_d = np.array([-1.0 / 3.0, 0.0, -0.25])
-        est_min = model_value(g, H, d)
-        true_min = model_value(g, H, true_d)
-        # Hope to get actual correct answer
-        # self.assertTrue(np.all(d == true_d), 'Wrong answer')
-        # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
-        s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
-        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
-        self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
-
-class TestUncBdry3CDFO(unittest.TestCase):
-    def runTest(self):
-        n = 3
-        g = np.array([0.0, 0.0, 1.0])
-        H = np.array([[-2.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, -1.0]])
-        Delta = 0.5
-        xopt = np.zeros((n,))
-        sl = -1e20 * np.ones((n,))
-        su = 1e20 * np.ones((n,))
-        pbox = lambda x: p_box(x,sl,su)
-        d, gnew, crvmin = ctrsbox(xopt, g, H, sl, su, [], Delta)
-        true_d = np.array([0.0, 0.0, -0.5])
-        est_min = model_value(g, H, d)
-        true_min = model_value(g, H, true_d)
-        # Hope to get actual correct answer
-        # self.assertTrue(np.all(d == true_d), 'Wrong answer')
-        # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
-        s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
-        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
-        self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
-        # self.assertAlmostEqual(crvmin, crvmin_cauchy, 'Wrong crvmin')
-
-class TestUncHardCDFO(unittest.TestCase):
-    def runTest(self):
-        n = 3
-        g = np.array([0.0, 0.0, 1.0])
-        H = np.array([[-2.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, -1.0]])
-        Delta = sqrt(2.0)
-        xopt = np.zeros((n,))
-        sl = -1e20 * np.ones((n,))
-        su = 1e20 * np.ones((n,))
-        pbox = lambda x: p_box(x,sl,su)
-        d, gnew, crvmin = ctrsbox(xopt, g, H, sl, su, [], Delta)
-        true_d = np.array([1.0, 0.0, -1.0])  # non-unique solution
-        est_min = model_value(g, H, d)
-        true_min = model_value(g, H, true_d)
-        # Hope to get actual correct answer
-        # self.assertTrue(np.all(d == true_d), 'Wrong answer')
-        # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
-        s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
-        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
-        self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
-
-class TestConInternalCDFO(unittest.TestCase):
-    def runTest(self):
-        n = 3
-        g = np.array([1.0, 0.0, 1.0])
-        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
-        Delta = 2.0
-        xopt = np.ones((n,))  # trying nonzero (since bounds inactive)
-        sl = xopt + np.array([-0.5, -10.0, -10.0])
-        su = xopt + np.array([10.0, 10.0, 10.0])
-        pbox = lambda x: p_box(x,sl,su)
-        d, gnew, crvmin = ctrsbox(xopt, g, H, sl, su, [], Delta)
-        true_d = np.array([-1.0, 0.0, -0.5])
-        est_min = model_value(g, H, d)
-        true_min = model_value(g, H, true_d)
-        # Hope to get actual correct answer for internal minimum?
-        # self.assertTrue(np.all(d == true_d), 'Wrong answer')
-        # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
-        s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt_box(g, H, Delta, sl-xopt, su-xopt)
-        # print(s_cauchy)
-        # print(d)
-        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
-        print(crvmin)
-        self.assertAlmostEqual(crvmin, -1.0, 'Wrong crvmin')
-
-
-# Notes: Gets correct min and gnew. Incorrect crvmin (1.0999999999999999).
-class TestConBdryCDFO(unittest.TestCase):
-    def runTest(self):
-        n = 3
-        g = np.array([1.0, 0.0, 1.0])
-        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
-        Delta = 5.0 / 12.0
-        xopt = np.zeros((n,))
-        sl = xopt + np.array([-0.3, -0.01, -0.1])
-        su = xopt + np.array([10.0, 1.0, 10.0])
-        pbox = lambda x: p_box(x,sl,su)
-        d, gnew, crvmin = ctrsbox(xopt, g, H, sl, su, [], Delta)
-        true_d = np.array([-1.0 / 3.0, 0.0, -0.25])
-        est_min = model_value(g, H, d)
-        true_min = model_value(g, H, true_d)
-        # Hope to get actual correct answer
-        # self.assertTrue(np.all(d == true_d), 'Wrong answer')
-        # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
-        s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt_box(g, H, Delta, sl - xopt, su - xopt)
-        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.max(np.abs(gnew - g - H.dot(d))) < 1e-10, 'Wrong gnew')
-        print(crvmin)
-        self.assertAlmostEqual(crvmin, -1.0, 'Wrong crvmin')
-        # self.assertAlmostEqual(crvmin, crvmin_cauchy, 'Wrong crvmin')
+def p_ball(x,c,r):
+    return c + (r/np.max([np.linalg.norm(x-c),r]))*(x-c)
 
 
 class TestUncInternal(unittest.TestCase):
@@ -507,108 +350,133 @@ def runTest(self):
         self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
 
 
-class TestGeomCDFO(unittest.TestCase):
-    def runTest(self):
-        xbase = np.array([0.0, 0.0])
-        g = np.array([1.0, -1.0])
-        a = np.array([-2.0, -2.0])
-        b = np.array([1.0, 2.0])
-        delta = 2.0
-        c = -1.0
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = np.array([-sqrt(2.0), sqrt(2.0)])
-        self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
-
-
-class TestGeom2CDFO(unittest.TestCase):
-    def runTest(self):
-        xbase = np.array([0.0, 0.0])
-        g = np.array([1.0, -1.0])
-        a = np.array([-2.0, -2.0])
-        b = np.array([1.0, 2.0])
-        delta = 5.0
-        c = -1.0
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = np.array([-2.0, 2.0])
-        self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
-
-
+# DFO-LS with arbitrary constraints
 class TestGeom3CDFO(unittest.TestCase):
     def runTest(self):
         xbase = np.array([0.0, 0.0]) + 1
         g = np.array([1.0, -1.0])
         a = np.array([-2.0, -2.0]) + 1
         b = np.array([1.0, 2.0]) + 1
+        proj = lambda x: p_box(x,a,b)
         delta = 5.0
         c = 3.0  # may want to max instead
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = np.array([1.0, -2.0]) + 1
+        x = ctrsbox_geometry(xbase, c, g, [proj], delta)
+        xtrue = np.array([1.0, -2.0])
         self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
 
+class TestUncInternalCDFO(unittest.TestCase):
+    def runTest(self):
+        n = 3
+        g = np.array([1.0, 0.0, 1.0])
+        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
+        Delta = 2.0
+        xopt = np.ones((n,))  # trying nonzero (since bounds inactive)
+        d, gnew, _crvmin = ctrsbox(xopt, g, H, [], Delta)
+        true_d = np.array([-1.0, 0.0, -0.5])
+        est_min = model_value(g, H, d)
+        true_min = model_value(g, H, true_d)
+        s_cauchy, red_cauchy, _crvmin_cauchy = cauchy_pt(g, H, Delta)
+        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
+        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
 
-class TestGeomOldBugCDFO(unittest.TestCase):
+class TestUncBdryCDFO(unittest.TestCase):
     def runTest(self):
-        xbase = np.array([0.0, 0.0])
-        g = np.array([-1.0, -1.0])
-        a = np.array([-2.0, -2.0])
-        b = np.array([0.1, 0.9])
-        delta = sqrt(2.0)
-        c = -1.0  # may want to max instead
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = b
-        self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
-        # self.assertFalse(True, "bad")
+        n = 3
+        g = np.array([1.0, 0.0, 1.0])
+        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
+        Delta = 5.0 / 12.0
+        xopt = np.zeros((n,))
+        d, gnew, _crvmin = ctrsbox(xopt, g, H, [], Delta)
+        true_d = np.array([-1.0 / 3.0, 0.0, -0.25])
+        est_min = model_value(g, H, d)
+        true_min = model_value(g, H, true_d)
+        s_cauchy, red_cauchy, _crvmin_cauchy = cauchy_pt(g, H, Delta)
+        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
 
 
-class TestGeomOldBug2CDFO(unittest.TestCase):
+class TestUncHardCDFO(unittest.TestCase):
     def runTest(self):
-        xbase = np.array([0.0, 0.0, 0.0])
-        g = np.array([-1.0, -1.0, -1.0])
-        a = np.array([-2.0, -2.0, -2.0])
-        b = np.array([0.9, 0.1, 5.0])
-        delta = sqrt(3.0)
-        c = -1.0  # may want to max instead
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = np.array([0.9, 0.1, sqrt(3.0 - 0.81 - 0.01)])
-        self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
-        # self.assertFalse(True, "bad")
+        n = 3
+        g = np.array([0.0, 0.0, 1.0])
+        H = np.array([[-2.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, -1.0]])
+        Delta = sqrt(2.0)
+        xopt = np.zeros((n,))
+        d, gnew, _crvmin = ctrsbox(xopt, g, H, [], Delta)
+        true_d = np.array([1.0, 0.0, -1.0])  # non-unique solution
+        est_min = model_value(g, H, d)
+        true_min = model_value(g, H, true_d)
+        s_cauchy, red_cauchy, _crvmin_cauchy = cauchy_pt(g, H, Delta)
+        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
 
-class TestGeom2WithZerosCDFO(unittest.TestCase):
+class TestConInternalCDFO(unittest.TestCase):
     def runTest(self):
-        xbase = np.array([0.0, 0.0])
-        g = np.array([0.0, -1.0])
-        a = np.array([-2.0, -2.0])
-        b = np.array([1.0, 2.0])
-        delta = 5.0
-        c = 0.0
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = np.array([0.0, 2.0])
-        self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
+        n = 3
+        g = np.array([1.0, 0.0, 1.0])
+        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
+        Delta = 2.0
+        xopt = np.ones((n,))  # trying nonzero (since bounds inactive)
+        sl = xopt + np.array([-0.5, -10.0, -10.0])
+        su = xopt + np.array([10.0, 10.0, 10.0])
+        proj = lambda x: p_box(x,sl,su)
+        d, gnew, _crvmin = ctrsbox(xopt, g, H, [proj], Delta)
+        true_d = np.array([-1.0, 0.0, -0.5])
+        est_min = model_value(g, H, d)
+        true_min = model_value(g, H, true_d)
+        s_cauchy, red_cauchy, _crvmin_cauchy = cauchy_pt_box(g, H, Delta, sl-xopt, su-xopt)
+        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
+        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
 
+class TestConBdryCDFO(unittest.TestCase):
+    def runTest(self):
+        n = 3
+        g = np.array([1.0, 0.0, 1.0])
+        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
+        Delta = 5.0 / 12.0
+        xopt = np.zeros((n,))
+        sl = xopt + np.array([-0.3, -0.01, -0.1])
+        su = xopt + np.array([10.0, 1.0, 10.0])
+        proj = lambda x: p_box(x,sl,su)
+        d, gnew, _crvmin = ctrsbox(xopt, g, H, [proj], Delta)
+        true_d = np.array([-1.0 / 3.0, 0.0, -0.25])
+        est_min = model_value(g, H, d)
+        true_min = model_value(g, H, true_d)
+        s_cauchy, red_cauchy, _crvmin_cauchy = cauchy_pt_box(g, H, Delta, sl - xopt, su - xopt)
+        self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
+        self.assertTrue(np.max(np.abs(gnew - g - H.dot(d))) < 1e-10, 'Wrong gnew')
 
-class TestGeom2WithAlmostZerosCDFO(unittest.TestCase):
+class TestBoxBallInternalCDFO(unittest.TestCase):
     def runTest(self):
-        xbase = np.array([0.0, 0.0])
-        g = np.array([1e-15, -1.0])
-        a = np.array([-2.0, -2.0])
-        b = np.array([1.0, 2.0])
-        delta = 5.0
-        c = 0.0
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = np.array([0.0, 2.0])
-        self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
+        n = 3
+        g = np.array([1.0, 0.0, 1.0])
+        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
+        Delta = 2.0
+        xopt = np.ones((n,))  # trying nonzero (since bounds inactive)
+        sl = xopt + np.array([-0.5, -10.0, -10.0])
+        su = xopt + np.array([10.0, 10.0, 10.0])
+        boxproj = lambda x: p_box(x,sl,su)
+        ballproj = lambda x: p_ball(x,xopt,5)
+        d, gnew, _crvmin = ctrsbox(xopt, g, H, [boxproj,ballproj], Delta)
+        true_d = np.array([-0.5, 0.0, -0.5])
+        est_min = model_value(g, H, d)
+        true_min = model_value(g, H, true_d)
+        self.assertTrue(est_min <= true_min + 1e-3, 'Sufficient decrease not achieved')
 
 
-class TestGeom2WithAlmostZeros2CDFO(unittest.TestCase):
+class TestBoxBallBdryCDFO(unittest.TestCase):
     def runTest(self):
-        xbase = np.array([0.0, 0.0])
-        g = np.array([1e-15, 0.0])
-        a = np.array([-2.0, -2.0])
-        b = np.array([1.0, 2.0])
-        delta = 5.0
-        c = 0.0
-        x = ctrsbox_geometry(xbase, c, g, a, b, [], delta)
-        xtrue = np.array([0.0, 0.0])
-        # print(x)
-        # print(xtrue)
-        self.assertTrue(np.max(np.abs(x - xtrue)) < 1e-10, 'Wrong step')
+        n = 3
+        g = np.array([1.0, 0.0, 1.0])
+        H = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]])
+        Delta = 5.0 / 12.0
+        xopt = np.zeros((n,))
+        sl = xopt + np.array([-0.3, -0.01, -0.1])
+        su = xopt + np.array([10.0, 1.0, 10.0])
+        boxproj = lambda x: p_box(x,sl,su)
+        ballproj = lambda x: p_ball(x,xopt,0.25)
+        d, gnew, _crvmin = ctrsbox(xopt, g, H, [boxproj,ballproj], Delta)
+        true_d = np.array([-0.22913085, 0.0, -0.09999527])
+        est_min = model_value(g, H, d)
+        true_min = model_value(g, H, true_d)
+        self.assertTrue(est_min <= true_min + 1e-3, 'Sufficient decrease not achieved')