Changeset 176


Ignore:
Timestamp:
08/09/09 13:45:49 (7 years ago)
Author:
altafang
Message:

Fixing termination, gradient call counter

Location:
branches/alta/mystic-0.1a2/mystic
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/alta/mystic-0.1a2/mystic/scipy_bfgs.py

    r169 r176  
    367367      epsilon : int or ndarray 
    368368          If fprime is approximated, use this value for the step size. 
    369       callback : callable 
    370           An optional user-supplied function to call after each 
    371           iteration.  Called as callback(xk), where xk is the 
    372           current parameter vector. 
    373369 
    374370        """ 
     
    376372        args = ExtraArgs 
    377373        x0 = self.population[0] 
     374 
    378375        fprime=None 
    379376        epsilon=_epsilon 
    380         disp=1 
    381         callback=None 
     377        self.disp = 0 
     378        self.callback = None 
    382379 
    383380        if kwds.has_key('fprime'): fprime = kwds['fprime'] 
    384381        if kwds.has_key('epsilon'): epsilon = kwds['epsilon'] 
    385         if kwds.has_key('callback'): callback = kwds['callback'] 
    386         if kwds.has_key('disp'): disp = kwds['disp'] 
     382        if kwds.has_key('disp'): self.disp = kwds['disp'] 
     383        if kwds.has_key('callback'): self.callback = kwds['callback'] 
     384 
    387385        #------------------------------------------------------------- 
    388386 
     
    407405            self._maxiter = len(x0)*200 
    408406 
    409         # Wrap gradient monitor         
    410         # ok to set monitor to Null here, or is there another way to do this? 
     407        # Wrap gradient monitor 
    411408        if fprime is None: 
    412409            gcalls, myfprime = wrap_function(approx_fprime, (func, epsilon), Null) 
     
    424421        xk = x0 
    425422        #sk = [2*gtol] 
    426         sk = [2*1e-5] 
    427423        warnflag = 0 
    428424        while k < self._maxiter: 
     
    455451            yk = gfkp1 - gfk 
    456452            gfk = gfkp1 
    457             if callback is not None: 
    458                 callback(xk) 
     453            if self.callback is not None: 
     454                self.callback(xk) 
    459455            k += 1 
    460456 
     
    465461            # Pass the gradient value to self.gfk for termination 
    466462            self.gfk = gfk 
    467      
     463 
     464            # Calculate the inverse Hessian     
    468465            try: # this was handled in numeric, let it remaines for more safety 
    469466                rhok = 1.0 / (numpy.dot(yk,sk)) 
     
    485482 
    486483        self.generations = k  
    487         signal.signal(signal.SIGINT,signal.default_int_handler)     
    488  
    489         if disp: 
     484        signal.signal(signal.SIGINT,signal.default_int_handler)  
     485 
     486        # Fix me? 
     487        self.gcalls = gcalls[0] 
     488 
     489        # Print messages if self.disp is non-zero 
     490        if self.disp: 
    490491            fval = old_fval 
    491492        if warnflag == 2: 
    492             if disp: 
     493            if self.disp: 
    493494                print "Warning: Desired error not necessarily achieved" \ 
    494495                      "due to precision loss" 
     
    499500     
    500501        elif k >= self._maxiter: 
    501             if disp: 
     502            if self.disp: 
    502503                print "Warning: Maximum number of iterations has been exceeded" 
    503504                print "         Current function value: %f" % fval 
     
    506507                print "         Gradient evaluations: %d" % gcalls[0] 
    507508        else: 
    508             if disp: 
     509            if self.disp: 
    509510                print "Optimization terminated successfully." 
    510511                print "         Current function value: %f" % fval 
     
    583584 
    584585    solver = BFGSSolver(len(x0)) 
     586 
     587    solver.disp = disp 
     588    solver.callback = callback 
     589 
    585590    solver.SetInitialPoints(x0) 
    586591    solver.enable_signal_handler() 
     
    588593    solver.Solve(func,termination=GradientTermination(gtol, norm),\ 
    589594                 EvaluationMonitor=evalmon,StepMonitor=stepmon,\ 
    590                  disp=disp, ExtraArgs=args, callback=callback,\ 
    591                  epsilon=epsilon, fprime=fprime) 
     595                 ExtraArgs=args, epsilon=epsilon, fprime=fprime) 
    592596    solution = solver.Solution() 
    593597 
     
    598602    warnflag = 0 
    599603    fcalls = len(evalmon.x) 
     604    iterations = len(stepmon.x) 
     605 
     606    # fix me? 
    600607    #gcalls = len(gradmon.x) 
    601     iterations = len(stepmon.x) 
    602     gcalls = iterations + 1 # fix me? 
     608    gcalls = solver.gcalls 
     609 
    603610    allvecs = [] 
    604611    for i in range(iterations): 
  • branches/alta/mystic-0.1a2/mystic/scipy_ncg.py

    r169 r176  
    1818   - StepMonitor = CustomSow() with 4 columns 
    1919   - enable_signal_handler() 
     20   - termination = SolutionImprovement(tolerance) 
    2021 
    2122Usage 
     
    130131 
    131132 
    132     def Solve(self, func, fprime, termination, sigint_callback=None, 
    133               EvaluationMonitor=Null, StepMonitor=Null, GradMonitor=Null, 
    134               HessianMonitor=Null, ExtraArgs=(), **kwds): 
     133    def Solve(self, func, termination, sigint_callback=None, 
     134              EvaluationMonitor=Null, StepMonitor=Null, #GradientMonitor=Null, 
     135              ExtraArgs=(), **kwds): 
    135136        """Minimize a function using NCG. 
    136137 
     
    143144 
    144145    func -- the Python function or method to be minimized. 
    145     fprime -- callable f'(x,*args) 
    146             Gradient of f. 
    147146    termination -- callable object providing termination conditions. 
    148147 
     
    158157Further Inputs: 
    159158 
     159    fprime -- callable f'(x,*args) 
     160            Gradient of f. 
    160161    fhess_p : callable fhess_p(x,p,*args) 
    161162        Function which computes the Hessian of f times an 
     
    186187        x0 = self.population[0] 
    187188        x0 = asarray(x0).flatten() 
     189 
    188190        epsilon = _epsilon 
    189         disp = 1 
    190         callback = None 
     191        self.disp = 1 
     192        self.callback = None 
    191193        fhess_p = None 
    192194        fhess = None 
    193195 
    194196        if kwds.has_key('epsilon'): epsilon = kwds['epsilon'] 
    195         if kwds.has_key('callback'): callback = kwds['callback'] 
    196         if kwds.has_key('disp'): disp = kwds['disp'] 
     197        if kwds.has_key('callback'): self.callback = kwds['callback'] 
     198        if kwds.has_key('disp'): self.disp = kwds['disp'] 
    197199        if kwds.has_key('fhess'): fhess = kwds['fhess'] 
    198200        if kwds.has_key('fhess_p'): fhess_p = kwds['fhess_p'] 
     201 
     202        # fprime is actually required. Temporary fix?: 
     203        if kwds.has_key('fprime'): fprime = kwds['fprime'] 
    199204        #------------------------------------------------------------- 
    200205 
     
    216221            self._maxiter = len(x0)*200 
    217222 
    218         # Wrap gradient function?         
     223        # Wrap gradient function?  
     224        # gcalls, fprime = wrap_function(fprime, args, GradientMonitor)    
    219225        gcalls, fprime = wrap_function(fprime, args, Null) 
    220226 
     
    286292            update = alphak * pk 
    287293 
     294            # Put last solution in trialSolution for termination() 
    288295            self.trialSolution = xk 
    289296 
    290297            xk = xk + update        # upcast if necessary 
    291             if callback is not None: 
    292                 callback(xk) 
     298            if self.callback is not None: 
     299                self.callback(xk) 
    293300            k += 1 
    294301 
     
    304311        self.generations = k 
    305312 
     313        # Fix me? 
    306314        self.hcalls = hcalls 
     315        self.gcalls = gcalls[0] 
    307316 
    308317        signal.signal(signal.SIGINT,signal.default_int_handler) 
    309318     
    310         if disp: 
     319        if self.disp: 
    311320            fval = old_fval 
    312321        if k >= self._maxiter: 
    313             if disp: 
     322            if self.disp: 
    314323                print "Warning: Maximum number of iterations has been exceeded" 
    315324                print "         Current function value: %f" % fval 
     
    319328                print "         Hessian evaluations: %d" % hcalls 
    320329        else: 
    321             if disp: 
     330            if self.disp: 
    322331                print "Optimization terminated successfully." 
    323332                print "         Current function value: %f" % fval 
     
    402411  
    403412    from mystic.tools import Sow, CustomSow 
    404     from mystic.termination import XTermination 
     413    from mystic.termination import SolutionImprovement 
    405414    #stepmon = Sow() 
    406415    stepmon = CustomSow('x','y','g','h', x='x', y='fval', \ 
     
    413422    solver.SetEvaluationLimits(maxiter,None) 
    414423    # Does requiring fprime break abstract_solver interface? 
    415     solver.Solve(func, fprime, termination=XTermination(xtol),\ 
     424    solver.Solve(func, SolutionImprovement(tolerance=xtol),\ 
    416425                 EvaluationMonitor=evalmon,StepMonitor=stepmon,\ 
    417426                 disp=disp, ExtraArgs=args, callback=callback,\ 
    418427                 epsilon=epsilon, fhess_p=fhess_p,\ 
    419                  fhess=fhess) 
     428                 fhess=fhess, fprime=fprime) 
    420429    solution = solver.Solution() 
    421430 
     
    427436    fcalls = len(evalmon.x) 
    428437    iterations = len(stepmon.x) 
    429     gcalls = iterations   # Fix me? 
     438 
     439    # Fix me? 
     440    gcalls = solver.gcalls   
    430441    hcalls = solver.hcalls 
     442 
    431443    allvecs = [] 
    432444    for i in range(iterations): 
Note: See TracChangeset for help on using the changeset viewer.