How to use cma - 10 common examples

Given the first values are the earliest, this is a useful policy
        also with a time changing objective.

        """
        ## meta_parameters.noise_reeval_multiplier == 1.0
        lam_reev = 1.0 * (self.lam_reeval if self.lam_reeval
                            else 2 + len(fit) / 20)
        lam_reev = int(lam_reev) + ((lam_reev % 1) > np.random.rand())
        ## meta_parameters.noise_choose_reeval == 1
        choice = 1
        if choice == 1:
            # take n_first first and reev - n_first best of the remaining
            n_first = lam_reev - lam_reev // 2
            sort_idx = np.argsort(np.array(fit, copy=False)[n_first:]) + n_first
            return np.array(list(range(0, n_first)) +
                            list(sort_idx[0:lam_reev - n_first]), copy=False)
        elif choice == 2:
            idx_sorted = np.argsort(np.array(fit, copy=False))
            # take lam_reev equally spaced, starting with best
            linsp = np.linspace(0, len(fit) - len(fit) / lam_reev, lam_reev)
            return idx_sorted[[int(i) for i in linsp]]
        # take the ``lam_reeval`` best from the first ``2 * lam_reeval + 2`` values.
        elif choice == 3:
            return np.argsort(np.array(fit, copy=False)[:2 * (lam_reev + 1)])[:lam_reev]
        else:
            raise ValueError('unrecognized choice value %d for noise reev'
                             % choice)

`CMAEvolutionStrategy` object instance, in particular
            mean and variances and the methods from the attribute
            `gp` of type `GenoPheno` are used.

        """
        if self.bounds is None or (self.bounds[0] is None and
                                   self.bounds[1] is None):
            return self

        N = es.N
        # ## prepare
        # compute varis = sigma**2 * C_ii
        if 11 < 3:  # old
            varis = es.sigma**2 * np.array(N * [es.C] if np.isscalar(es.C) else (# scalar case
                                    es.C if np.isscalar(es.C[0]) else  # diagonal matrix case
                                    [es.C[i][i] for i in range(N)]))  # full matrix case
        else:
            varis = es.sigma**2 * es.sm.variances

        # relative violation in geno-space
        dmean = (es.mean - es.gp.geno(self.repair(es.gp.pheno(es.mean)))) / varis**0.5

        # ## Store/update a history of delta fitness value
        fvals = sorted(function_values)
        l = 1 + len(fvals)
        val = fvals[3 * l // 4] - fvals[l // 4]  # exact interquartile range apart interpolation
        val = val / np.mean(varis)  # new: val is normalized with sigma of the same iteration
        # insert val in history
        if np.isfinite(val) and val > 0:
            self.hist.insert(0, val)
        elif val == np.inf and len(self.hist) > 1:
            self.hist.insert(0, max(self.hist))

def call_cma(self):
        w1=  self.controller.get_weight(layer_nb, numpoids1)[0]
        w2=  self.controller.get_weight(layer_nb, numpoids2)[0]
        x = np.array([w1,w2])
        self.green_x.append(w1)
        self.green_y.append(w2)
        fx = cma.fmin(self.run_episode, x, sigma, options = self.options)
        self.final_draw()

def __init__(self,env):
        '''
	Input:
        '''
        self.env = env
        self.env.reset(False)
        self.controller = Keras_NN(env.observation_space.low.shape[0],env.action_space.low.shape[0])
        self.nb_episodes = 0
        self.options = cma.CMAOptions()
        self.options['maxiter']=200
        self.options['popsize']=50
        self.options['CMA_diagonal']=True
        self.options['verb_log']=50
        self.options['verb_disp']=1
        self.best_perf = -10000.0

def __init__(self,env):
        '''
	Input:
        '''
        self.env = env
        self.env.reset(False)
        self.controller = Keras_NN(env.observation_space.low.shape[0],env.action_space.low.shape[0])
        self.controller.load_theta('cma_agents/best_agent.theta-2772.2691621')
        self.nb_episodes = 0
        self.options = cma.CMAOptions()
        self.options['maxiter']=40
        self.options['popsize']=50
#        self.options['CMA_diagonal']=True
        self.options['verb_log']=50
        self.options['verb_disp']=1
        self.best_perf = -10000.0

        self.start_x = 0.73
        self.start_y = -0.26
        self.controller.set_param(layer_nb, numpoids1, self.start_x)
        self.controller.set_param(layer_nb, numpoids2, self.start_y)
        
        self.white_x = []
        self.white_y = []
        
        self.best_x = []

"ERROR: Test %s timed out waiting for %s [timeout:%s]"
                % (self.__class__.__name__, str(watcher.unmatched), timeout)
            )
            return self._record(AssimSysTest.FAIL)
        if debug:
            print("DEBUG: Test %s found regex %s" % (self.__class__.__name__, str(watcher.regexes)))
        if query.check(
            (nano, self.testenviron.cma, service), validator, minrows=minrows, maxrows=maxrows
        ):
            if debug:
                print("DEBUG: Test %s passed query %s" % (self.__class__.__name__, querystring))
            return self._record(AssimSysTest.SUCCESS)

        print("DEBUG: query.check() FAILED", file=sys.stderr)
        logger("ERROR: Test %s failed query %s" % (self.__class__.__name__, querystring))
        return self._record(AssimSysTest.FAIL)

rc = StopNanoprobe(self.store, self.logfilename, self.testenviron).run(
            nano, debug=self.debug, timeout=timeout
        )
        if rc != AssimSysTest.SUCCESS:
            return self._record(rc)
        if self.delay > 0:
            time.sleep(self.delay)
        return self._record(
            StartNanoprobe(self.store, self.logfilename, self.testenviron).run(
                nano, debug=self.debug, timeout=timeout
            )
        )


@AssimSysTest.register
class RestartCMA(AssimSysTest):
    "A restart CMA test: stop then restart the CMA.  Scary stuff!"

    def __init__(self, store, logfilename, testenviron, debug=False, delay=0):
        AssimSysTest.__init__(self, store, logfilename, testenviron, debug)
        self.delay = delay

    def run(self, nano=None, debug=None, timeout=60):
        "Actually stop and start (restart) the CMA and see if it worked"
        if debug is None:
            debug = self.debug
        cma = self.testenviron.cma
        cma.stopservice(SystemTestEnvironment.CMASERVICE)
        regexes = self.cma_start_regexes()
        watch = LogWatcher(self.logfilename, regexes, timeout=timeout, debug=debug)
        watch.setwatch()
        if self.delay > 0:

def run(self, nano=None, debug=None, timeout=180):
        "Actually stop the nanoprobe and see if it worked"
        if debug is None:
            debug = self.debug
        if nano is None:
            nanozero = self.testenviron.select_nano_service()
            if len(nanozero) > 0:
                nano = nanozero[0]
        if (
            nano is None
            or nano.status != TestSystem.RUNNING
            or SystemTestEnvironment.NANOSERVICE not in nano.runningservices
        ):
            return self._record(AssimSysTest.SKIPPED)
        regexes = self.nano_kill9_regexes(nano)
        print("KILL9_REGEXES ARE:", regexes, file=sys.stderr)
        watch = LogWatcher(self.logfilename, regexes, timeout=timeout, debug=debug)
        watch.setwatch()
        qstr = (
            """START drone=node:Drone('*:*') """
            """WHERE drone.designation = "{0.hostname}" and drone.status = "dead" """
            """and drone.reason = "HBDEAD packet received"       RETURN drone"""
        )
        nano.kill9service(SystemTestEnvironment.NANOSERVICE)
        # print >> sys.stderr, 'NANO NEIGHBORS', get_nano_neighbors(self.store, None, nano)
        return self.checkresults(watch, timeout, qstr, None, nano)

):
            return self._record(AssimSysTest.SKIPPED)
        regexes = self.nano_stop_regexes(nano)
        watch = LogWatcher(self.logfilename, regexes, timeout=timeout, debug=debug)
        watch.setwatch()
        qstr = (
            """START drone=node:Drone('*:*') """
            """WHERE drone.designation = "{0.hostname}" and drone.status = "dead" """
            """and drone.reason = "HBSHUTDOWN"       RETURN drone"""
        )
        nano.stopservice(SystemTestEnvironment.NANOSERVICE)
        return self.checkresults(watch, timeout, qstr, None, nano)


@AssimSysTest.register
class KillNanoprobe(AssimSysTest):
    "A kill -9 nanoprobe test"

    def run(self, nano=None, debug=None, timeout=180):
        "Actually stop the nanoprobe and see if it worked"
        if debug is None:
            debug = self.debug
        if nano is None:
            nanozero = self.testenviron.select_nano_service()
            if len(nanozero) > 0:
                nano = nanozero[0]
        if (
            nano is None
            or nano.status != TestSystem.RUNNING
            or SystemTestEnvironment.NANOSERVICE not in nano.runningservices
        ):
            return self._record(AssimSysTest.SKIPPED)

regexes = self.nano_start_regexes(nano)

        watch = LogWatcher(self.logfilename, regexes, timeout=timeout, debug=debug)
        watch.setwatch()
        qstr = (
            """START drone=node:Drone('*:*') """
            """WHERE drone.designation = "{0.hostname}" and drone.status = "up" """
            """RETURN drone"""
        )
        nano.startservice(SystemTestEnvironment.NANOSERVICE)
        return self.checkresults(watch, timeout, qstr, None, nano)


@AssimSysTest.register
class FlipNanoprobe(AssimSysTest):
    """A flip nanoprobe test - if it's up, bring it down -- and vice versa"""

    def run(self, nano=None, debug=None, timeout=240):
        "Actually flip the nanoprobe and see if it worked"
        if debug is None:
            debug = self.debug
        if nano is None:
            nanozero = self.testenviron.select_nanoprobe()
            if len(nanozero) > 0:
                nano = nanozero[0]
        if nano is None:
            return self._record(AssimSysTest.SKIPPED)
        if SystemTestEnvironment.NANOSERVICE in nano.runningservices:
            return self._record(
                StopNanoprobe(self.store, self.logfilename, self.testenviron).run(
                    nano, debug=self.debug, timeout=timeout