In [1]:

    

import numpy as np

from deap.tools import sortLogNondominated 
from pykalman import KalmanFilter


    

In [2]:

    

class StoppingCriterion(object):
    '''
    classdocs
    '''

    def __init__(self, progress_indicators, evidence_gatherers, stop_decisors, voting=np.all):
        '''
        Constructor
        '''
        self.progress_indicators = progress_indicators
        self.evidence_gatherers = evidence_gatherers
        self.stop_decisors = stop_decisors
        self.voting = voting

        self.internal_state = InternalState

    def is_end_condition_met(self, population):
        '''Decides if the evolution can/must/should be stopped.'''
        prog_inds_values = [indicator.compute_indicator(population) for indicator in self.progress_indicators]
        evidences = [gatherer.gather_evidence(prog_inds_values) for gatherer in self.evidence_gatherers]
        decisions = [decisor.must_stop(evidences) for decisor in self.stop_decisors]

        return self.voting(decisions), (prog_ind_values, evidences, decisions)


    

In [3]:

    

class EvidenceGatherer():

    def gather_evidence(self, prog_inds_values):
        raise NotImplementedError('Method belongs to abstract class')

class ProgressIndicator():

    def compute_indicator(self, population):
        raise NotImplementedError('Method belongs to abstract class')

class StopDecisor():

    def must_stop(self, evidences):
        raise NotImplementedError('Method belongs to abstract class')


    

In [4]:

    

class MutualDominationRateIndicator(ProgressIndicator):

    def compute_indicator(self, population):
        if not self._previous_pop:
          self.previous_pop = population
          return np.nan
        
        res = self._norm_delta(self._previous_pop, population) - self._norm_delta(population, self._previous_pop)
        self._previous_pop = population
        
        return res

    def _norm_delta(pop_a, pop_b):
        fronts_a = SortLogNonDominated(pop_a)
        
        count_a = 0
        for front_a in fronts_a:
            front_with_b = SortLogNonDominated(front_a+pop_b,  first_front_only=True)
            dominators = [ind for ind in front_a if ind in front_with_b]
            count_a += len(dominators)
        
        return count_a/len(pop_a)


    

In [ ]:

    

class MGBMEvidenceGatherer(EvidenceGatherer):
    
    def __init__(self, r):
        self.r = r
        
    def gather_evidence(self, prog_inds_values):
        for ind_value in prog_inds_values:


    

In [ ]:

    

for j = 1:length(state.PI)
    M = state.(state.PI{j});
    if ~isfield(state, 'kalman') || ...
            size(state.kalman,1) < length(state.PI) || ...
            any(isnan(state.kalman(j,:)))
        % first generation: initialize Kalman filter with first value and
        % initial guess of the noise
        if ~isnan(M(end))
            state.kalman(j,:) = [M(end) params.R 1];
        else
            state.kalman(j,:) = [NaN NaN NaN];
        end;
    elseif ~isnan(M(end))
        % configure the Kalman filter
        s.x = state.kalman(j,1);
        s.z = M(end);
        s.A = 1;
        s.B = 0;
        s.Q = 0;
        s.R = params.R;
        s.P = state.kalman(j,2);
        
        % compute Kalman filter
        out = kalmanf(s);
        
        % update state
        state.kalman(j,:) = [out.x out.P state.kalman(j,3)+1];
    end;
end;


    

In [ ]:

    

KalmanFilter(transition_matrices=[1.], # A
             observation_matrices=None, 
             transition_covariance=[0.], # Q
             observation_covariance=[self.r], 
             transition_offsets= [0.], # b
             observation_offsets=None, # d
             initial_state_mean=None, # mu_0
             initial_state_covariance=None, 
             random_state=None, 
             em_vars=['transition_covariance', 'observation_covariance', 'initial_state_mean', 'initial_state_covariance'], 
             n_dim_state=None, n_dim_obs=None))