Example #1
0
    def test_vector_none_fitting(self):
        """
        Fit to a vector model with one var's data set to None
        """
        a, b, c = parameters('a, b, c')
        a_i, b_i, c_i = variables('a_i, b_i, c_i')

        model = {a_i: a, b_i: b, c_i: c}

        xdata = np.array([
            [10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
            [102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
            [71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
        ])

        fit_none = NumericalLeastSquares(
            model=model,
            a_i=xdata[0],
            b_i=xdata[1],
            c_i=None,
        )
        fit = NumericalLeastSquares(
            model=model,
            a_i=xdata[0],
            b_i=xdata[1],
            c_i=xdata[2],
        )
        fit_none_result = fit_none.execute()
        fit_result = fit.execute()

        self.assertAlmostEqual(fit_none_result.params.a, fit_result.params.a, 4)
        self.assertAlmostEqual(fit_none_result.params.b, fit_result.params.b, 4)
        self.assertAlmostEqual(fit_none_result.params.c, 1.0)
Example #2
0
    def test_model_from_dict(self):
        x, y_1, y_2 = variables('x, y_1, y_2')
        a, b = parameters('a, b')

        model = Model({
            y_1: 2 * a * x,
            y_2: b * x**2
        })
Example #3
0
    def test_gaussian(self):
        x0, sig = parameters('x0, sig')
        x = Variable()

        new = sympy.exp(-(x - x0)**2/(2*sig**2))
        self.assertIsInstance(new, sympy.exp)
        g = Gaussian(x, x0, sig)
        self.assertTrue(issubclass(g.__class__, sympy.exp))
Example #4
0
    def test_callable(self):
        a, b = parameters('a, b')
        x, y = variables('x, y')
        func = a*x**2 + b*y**2
        result = func(x=2, y=3, a=3, b=9)
        self.assertEqual(result, 3*2**2 + 9*3**2)

        xdata = np.arange(1,10)
        ydata = np.arange(1,10)
        result = func(x=ydata, y=ydata, a=3, b=9)
        self.assertTrue(np.array_equal(result, 3*xdata**2 + 9*ydata**2))
Example #5
0
    def test_jacobian_matrix(self):
        """
        The jacobian matrix of a model should be a 2D list (matrix) containing all the partial derivatives.

        :return:
        """
        a, b, c = parameters('a, b, c')
        a_i, b_i, c_i = variables('a_i, b_i, c_i')
        # a_i, b_i, c_i, s_a, s_b, s_c = variables('a_i, b_i, c_i, s_a, s_b, s_c')

        model = Model({a_i: 2 * a + 3 * b, b_i: 5 * b, c_i: 7 * c})
        self.assertEqual([[2, 3, 0], [0, 5, 0], [0, 0, 7]], model.jacobian)
Example #6
0
    def test_likelihood_fitting_gaussian(self):
        """
        Fit using the likelihood method.
        """
        mu, sig = parameters('mu, sig')
        sig.min = 0.01
        sig.value = 3.0
        mu.value = 50.
        x = Variable()
        pdf = Gaussian(x, mu, sig)
        # pdf = sympy.exp(-(x - mu)**2/(2*sig**2))/sympy.sqrt(2*sympy.pi*sig**2)

        np.random.seed(10)
        xdata = np.random.normal(51., 3.5, 100000)

        fit = Likelihood(pdf, xdata)
        fit_result = fit.execute()
        print(fit_result)

        self.assertAlmostEqual(fit_result.params.mu, np.mean(xdata), 5)
        self.assertAlmostEqual(fit_result.params.sig, np.std(xdata), 5)
Example #7
0
        def __get_grad(ar,n): # grad at different scales, see test_symfit_0707.ipynb
            m = n - 1
            (M,N) = ar.shape
    
            # output grad matrix with size (M-m)x(N-m)
            gd180 = np.zeros((M-m,N-m))
            gd360 = np.zeros((M-m,N-m))
    
            # initial values for fitting parameters
            ## Goodman et al. 1993 (doi:10.1086/172465)
            v0 = Parameter(value=5.)
            al = Parameter(value=0.)
            b1 = Parameter(value=0.) 

            v_0, a, b = parameters('v0, al, bl')
            x, y, z   = variables('x, y, z')      

            md = {z: v_0 + a * x + b * y}
    
            for (x,y),i in np.ndenumerate(ar):
                if x >= ar.shape[0]-m or y >= ar.shape[1]-m:
                    # fit grad from (x,y) (to (x+n, y+n)), so right/bottom edges are neglected
                    continue
                else:
                    ap = ar[slice(x,x+n),slice(y,y+n)]
                    # array of indices
                    xx,yy = np.where(~np.isnan(ap))
                    zz    = ap.flatten()
                    zz    = zz[~np.isnan(zz)]
                    
                    ft = Fit(md, x=xx, y=yy, z=zz)
                    ft_result = ft.execute()
            
                    (a,b) = (ft_result.params.al,ft_result.params.bl)
            
                    gd180[x,y] = np.mod(np.mod(360-np.degrees(np.arctan(b/a)), 360),180)
                    gd360[x,y] = np.mod(360-np.degrees(np.arctan(b/a)), 360)
                
            return gd180,gd360
Example #8
0
    def test_vector_fitting(self):
        a, b, c = parameters('a, b, c')
        a_i, b_i, c_i = variables('a_i, b_i, c_i')

        model = {a_i: a, b_i: b, c_i: c}

        xdata = np.array([
            [10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
            [102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
            [71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
        ])

        fit = NumericalLeastSquares(
            model=model,
            a_i=xdata[0],
            b_i=xdata[1],
            c_i=xdata[2],
        )
        fit_result = fit.execute()

        self.assertAlmostEqual(fit_result.params.a, 9.985691, 6)
        self.assertAlmostEqual(fit_result.params.b, 1.006143e+02, 4)
        self.assertAlmostEqual(fit_result.params.c, 7.085713e+01, 5)
Example #9
0
    def test_model_callable(self):
        """
        Tests if Model objects are callable in the way expected. Calling a model should evaluate it's
        expression(s) with the given values. The return value is a namedtuple.

        The signature should also work so inspection is saved.
        """
        a, b = parameters('a, b')
        x, y = variables('x, y')
        new = a*x**2 + b*y**2
        model = Model(new)
        z, = model(3, 3, 2, 2)

        self.assertEqual(z, 36)
        for arg_name, name in zip(('x', 'y', 'a', 'b'), inspect_sig.signature(model).parameters):
            self.assertEqual(arg_name, name)

        # From Model __init__ directly
        model = Model([a*x**2, 4*b*y**2, a*x**2 + b*y**2])
        z_1, z_2, z_3 = model(3, 3, 2, 2)

        self.assertEqual(z_1, 18)
        self.assertEqual(z_2, 72)
        self.assertEqual(z_3, 36)
        for arg_name, name in zip(('x', 'y', 'a', 'b'), inspect_sig.signature(model).parameters):
            self.assertEqual(arg_name, name)

        # From dict
        z_1, z_2, z_3 = variables('z_1, z_2, z_3')
        model = Model({z_1: a*x**2, z_2: 4*b*y**2, z_3: a*x**2 + b*y**2})
        z_1, z_2, z_3 = model(3, 3, 2, 2)

        self.assertEqual(z_1, 18)
        self.assertEqual(z_2, 72)
        self.assertEqual(z_3, 36)
        for arg_name, name in zip(('x', 'y', 'a', 'b'), inspect_sig.signature(model).parameters):
            self.assertEqual(arg_name, name)