Beispiel #1
1
    def infer_x(self, y, sigma = 1.0, tolerance = 1e-2):
        """Infer probable x from input y
        @param y  the desired output for infered x.
        @return   a list of probable x
        """
        OptimizedInverseModel.infer_x(self, y)
        if self.fmodel.size() == 0:
            return self._random_x()

        x_guesses = [self._guess_x_simple(y)[0]]
        #x_guesses = self._guess_x_kmeans(y)
        
        if CMA_IMPLEM == "C++":

        # C++ IMPLEM
        
            result = []
            for xg in x_guesses:
                sigma = 0.05
                #print self.lower, self.upper
                p = lci.to_params(list(xg),
                                  sigma, 
                                lbounds=self.lower, 
                                ubounds=self.upper, 
                                max_fevals=20
                                  )
                objfunc = lci.to_fitfunc(self._error)
                cmasols = lci.pcmaes(objfunc, p)
                # collect and inspect results
                bcand = cmasols.best_candidate()
                error = bcand.get_fvalue()
                x = lcmaes.get_candidate_x(bcand)
                result.append((error, x))
            #print "x", [xi for fi, xi in sorted(result)]
            return [xi for fi, xi in sorted(result)]
    
        elif CMA_IMPLEM == "python":
                
            # PYTHON IMPLEM
            result = []
            for xg in x_guesses:
                res = cma.fmin(self._error, xg, 0.05, 
                               options={'bounds':[self.lower, self.upper],
                               'verb_log':0,
                               'verb_disp':False,
                               #'ftarget':tolerance/2,
                               'maxfevals':20})
                result.append((res[1], res[0]))
     
    #        return [xi for fi, i, xi in sorted(result)[:min(N_RESULT, len(result))]]
            return [xi for fi, xi in sorted(result)]
Beispiel #2
0
def ncsurrfunc(c,m):
    x = []
    y = []
    for ci in c:
        x.append(lcmaes.get_candidate_x(ci))
        y.append(ci.get_fvalue())
    #nx = encode(x,m)
    traindt(x,y)
    return 1
Beispiel #3
0
def ncsurrfunc(c, m):
    x = []
    y = []
    for ci in c:
        x.append(lcmaes.get_candidate_x(ci))
        y.append(ci.get_fvalue())
    #nx = encode(x,m)
    traindt(x, y)
    return 1
Beispiel #4
0
def nsurrfunc(c,m):
    x = []
    for ci in c:
        x.append(lcmaes.get_candidate_x(ci))
    #nx = encode(x,m)
    y = predict(x)
    i = 0
    for ci in c:
        ci.set_fvalue(y[i])
        i = i + 1
    return 1
Beispiel #5
0
def nsurrfunc(c, m):
    x = []
    for ci in c:
        x.append(lcmaes.get_candidate_x(ci))
    #nx = encode(x,m)
    y = predict(x)
    i = 0
    for ci in c:
        ci.set_fvalue(y[i])
        i = i + 1
    return 1
Beispiel #6
0
    def fit(self, X, y, opt_fit=False, libcma=False, **params):
        if opt_fit:

            def err_function(params):
                mdl = NrmModel(bias=params[0],
                               conf_threshold=params[1],
                               mu0=params[2],
                               kappa0=params[3],
                               alpha0=params[4],
                               beta0=params[5])
                return -mdl.score(X, y)

            start = np.array([self.bias, self.conf_threshold] +
                             list(self.prior))
            if not libcma:
                import cma
                x = cma.fmin(err_function,
                             start,
                             1.5,
                             restarts=5,
                             options={'verbose': -9})[0]
            else:
                import lcmaes
                import lcmaes_interface as lci
                print(('Start:', err_function(start)))
                ffunc = lci.to_fitfunc(err_function)
                lbounds = [-np.inf, 0, -np.inf] + 3 * [0]

                fopt = lci.to_params(
                    list(start),
                    1.5,
                    str_algo=b'aipop',
                    lbounds=lbounds,
                    restarts=5,
                )

                res = lci.pcmaes(ffunc, fopt)
                bcand = res.best_candidate()
                print(('End:', bcand.get_fvalue()))
                x = lcmaes.get_candidate_x(bcand)
            return self.set_params(bias=x[0],
                                   conf_threshold=x[1],
                                   mu0=x[2],
                                   kappa0=x[3],
                                   alpha0=x[4],
                                   beta0=x[5])
        return self
Beispiel #7
0
# input parameters for a 10-D problem
x = [10]*10
olambda = 10 # lambda is a reserved keyword in python, using olambda instead.
seed = 0 # 0 for seed auto-generated within the lib.
sigma = 0.1
p = lcmaes.make_simple_parameters(x,sigma,olambda,seed)
p.set_str_algo("acmaes")

# objective function.
def nfitfunc(x,n):
    val = 0.0
    for i in range(0,n):
        val += x[i]*x[i]
    return val

# generate a function object
objfunc = lcmaes.fitfunc_pbf.from_callable(nfitfunc);

# pass the function and parameter to cmaes, run optimization and collect solution object.
cmasols = lcmaes.pcmaes(objfunc,p)

# collect and inspect results
bcand = cmasols.best_candidate()
bx = lcmaes.get_candidate_x(bcand)
print "best x=",bx
print "distribution mean=",lcmaes.get_solution_xmean(cmasols)
cov = lcmaes.get_solution_cov(cmasols) # numpy array
print "cov=",cov
print "elapsed time=",cmasols.elapsed_time(),"ms"
Beispiel #8
0
seed = 0  # 0 for seed auto-generated within the lib.
sigma = 0.1
scaling = [int(1000 * random.random()) for i in xrange(10)]
shift = [int(1000 * random.random()) for i in xrange(10)]
gp = lcmaes.make_genopheno_ls(scaling, shift)
p = lcmaes.make_parameters_ls(x, sigma, gp, lambda_, seed)


# objective function.
def nfitfunc(x, n):
    val = 0.0
    for i in range(0, n):
        val += x[i] * x[i]
    return val


# generate a function object
objfunc = lcmaes.fitfunc_pbf.from_callable(nfitfunc)

# pass the function and parameter to cmaes, run optimization and collect solution object.
cmasols = lcmaes.pcmaes_ls(objfunc, p)

# collect and inspect results
bcand = cmasols.best_candidate()
bx = lcmaes.get_candidate_x(bcand)
print("best x=", bx)
print("distribution mean=", lcmaes.get_solution_xmean(cmasols))
cov = lcmaes.get_solution_cov(cmasols)  # numpy array
print("cov=", cov)
print("elapsed time=", cmasols.elapsed_time(), "ms")