示例#1
0
    def partition_dag(self):
        """
        Returns a tuple of:
            1. the # of partitions formed (int)
            2. the parallel time (longest path, int)
            3. partition time (seconds, float)
            4. a list of partitions (Partition)
        """
        # trigger the PSO algorithm
        G = self._dag
        lb = [0.99] * self._leng
        ub = [3.01] * self._leng
        stt = time.time()
        if (self._deadline is None):
            xopt, fopt = pso(self.objective_func, lb, ub, swarmsize=self._swarm_size)
        else:
            xopt, fopt = pso(self.objective_func, lb, ub, ieqcons=[self.constrain_func], swarmsize=self._swarm_size)

        curr_lpl, num_parts, parts, g_dict = self._partition_G(G, xopt)
        edt = time.time()
        #print "PSO scheduler took {0} seconds".format(edt - stt)
        st_gid = len(self._drop_list) + 1 + num_parts
        for n in G.nodes(data=True):
            if (not n[1].has_key('gid')):
                n[1]['gid'] = st_gid
                part = Partition(st_gid, self._max_dop)
                part.add_node(n[0], n[1].get('weight', 1))
                g_dict[st_gid] = part
                parts.append(part) # will it get rejected?
                num_parts += 1
        self._parts = parts
        #print "call counts ", self._call_counts
        return (num_parts, curr_lpl, edt - stt, parts)
    def swarm(self):

        params = self.params_class(**self.params_kwargs)
        lb, ub = params.create_vector_bounds()

        def objective_function(vector):
            params.receive_vector(vector=vector)
            instance_generation_function = 'player'

            return - score_params(params=params, objective=self.objective,
                                  opponents_information=self.opponents_information,
                                  weights=self.weights,
                                  sample_count=self.sample_count,
                                  instance_generation_function=instance_generation_function
                                 )

        # TODO remove check once v 0.7 is pip installable
        # There is a multiprocessing version (0.7) of pyswarm available at
        # https://github.com/tisimst/pyswarm, just pass processes=X
        # Pip installs version 0.6
        if pyswarm.__version__ == "0.7":
            xopt, fopt = pyswarm.pso(objective_function, lb, ub,
                                     swarmsize=self.population,
                                     maxiter=self.generations, debug=self.debug,
                                     phip=self.phip, phig=self.phig,
                                     omega=self.omega, processes=self.processes)
        else:
            xopt, fopt = pyswarm.pso(objective_function, lb, ub,
                                     swarmsize=self.population,
                                     maxiter=self.generations, debug=self.debug,
                                     phip=self.phip, phig=self.phig,
                                     omega=self.omega)
        return xopt, fopt
def optimise():
    testCases = testcollection.readTests()
    #grouping.redefineGroupingConditions(dataselect.conditionBreakHigh)
    #grouping.redefineGroupingConditions(dataselect.conditionDoubleTopsFiltered)

    ### Objective Function.
    ### An input for pyswarm.pso. Returns a float utility score from testing with a set of weights.
    def testWithWeights(weights):
        arrLen = len(parametersToOptimise)
        weightDict = {}
        for i in range(0,arrLen):
            weightDict[parametersToOptimise[i]] = weights[i]
        result = testAlgorithmsForAverageScore(testCases, weightDict)
        print(str(result) + ' <- ' + str(weights)) # print as we go.
        return (result - 1)*100
   
    ### Uncomment this to test the running time of weight optimisation.
    # testWeightOptimisationRunningTime(testWithWeights)

    ub = [1]*5 # Upper bound = 1
    lb = [0]*5 # Lower bound = 0
    xopt, fopt = pyswarm.pso(testWithWeights, lb, ub, maxiter=20)
    
    # If we reach this point, it means the weight optimisation process is complete.
    print('Final Weights:')
    print(xopt)
    print('Score = ' + str(fopt))
示例#4
0
 def optimize(self):
     self._favor_context = True
     with nostdout():
         self._x, _ = pso(
             self._funcwrapped, self._lower, self._upper,
             maxiter=MAX_IT, )
     self._favor_context = False
     self.lsearch()
示例#5
0
 def optimize(self, control):
     """Run PSO optimization on the automata using custom PSO configuration."""
     xopt, fopt = pso(
         func=self._classifier_error, lb=self.automata.vector_lb, ub=self.automata.vector_ub,
         maxiter=control["maxit"],
         swarmsize=control["s"],
         debug=control["trace"])
     print('xopt (optymalny znaleziony wektor) = \n', xopt)
     print('fopt (najmniejsza znaleziona wartość dla wektora) = ', fopt)
     self.automata.vector = xopt
def run_pso_multiple_times():
    swarm_size = 100
    indi_results = []
    for max_iter in [100,150,200,300,400,500]:
        print("Current number of Iteration", str(max_iter))
        start_time = time.time()
        xopt, fopt = pso(banana,lb, ub,f_ieqcons=con,swarmsize=swarm_size,maxiter=max_iter)
        rmse = calculate_mse(xopt)
        finish_time = time.time() - start_time
        pso_param = [swarm_size, max_iter, finish_time, rmse]
        indi_results.append(pso_param + xopt.tolist())
    indi_results = np.array(indi_results)
    np.savetxt("pso.csv", indi_results, delimiter=",")
def main():


    filename=sys.argv[1]
    data=readfile(filename)
    row,col=data.shape
    #print max(data[row-4])
    newbigger=[]
    for rownum in xrange(row):
         newbigger.append(data[rownum][col-1])
    midnum=caculatemidnum(newbigger)
    data=data/midnum
    if row>0:
        file_result=open('result.txt','w')
        file_result.write(repr('para_a').rjust(10)+repr('para_b').rjust(10)+repr('para_c').rjust(10)+repr('para_d').rjust(10)+repr('para_e').rjust(10)+repr('para_f').rjust(10)+repr('para_g').rjust(10)+repr('error').rjust(10)+'\n')
    for rownum in xrange(row):
        '''print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()'''
        args=data[rownum]
        length=len(args)
        iteration=constraint(args,length)
        print('iterations={}'.format(iteration))
        print("please wait a moment....")
        minNum=args.min()
        maxNum=args.max()
        meanNum=args.mean()
        lb=[-maxNum,0,-meanNum,-1,-maxNum,-1,-maxNum]
        ub=[1,0.5,maxNum,1.1,maxNum+meanNum,1.1,maxNum+meanNum]
        initialData=[0,0.01,meanNum,-1,maxNum,0.7,maxNum]
        initialData2=[minNum,0.03,meanNum+4,0.1,maxNum,-1,maxNum] 
        xopt4,fopt4=pso(myfunction,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration)
        print('The optimum is at:')
        print('    {}'.format(xopt4))
        print('Optimal function values:')
        #print('    R-square : {}'.format(fopt4))
        print('ajusted R-squared:{}'.format(-fopt4)) 
        file_result.write(repr(xopt4[0]).rjust(10)+repr(xopt4[1]).rjust(10)+repr(xopt4[2]).rjust(10)+repr(xopt4[3]).rjust(10)+repr(xopt4[4]).rjust(10)+repr(xopt4[5]).rjust(10)+repr(xopt4[6]).rjust(10)+repr(fopt4).rjust(10)+'\n')
        x=np.linspace(1,length,10000)
        y=xopt4[0]+xopt4[1]*x+xopt4[2]/((1+np.exp(-xopt4[3]*(x-xopt4[4])))*(1+np.exp(-xopt4[5]*(x-xopt4[6]))))
        plt.figure(rownum)
        for i in xrange(length):
            plt.plot(i+1,args[i],'blue',linestyle='dashed',marker='.')
        plt.plot(x,y,'r',linewidth=2)
        plt.xlabel("circle(Time)")
        plt.ylabel("fluorescence")
        plt.legend()
        plt.show()
    if row>0:
        file_result.close()
示例#8
0
 def optimize(self):
     self._favor_context = True
     while (self._nbcall < MAX_FN_CALL):
         with nostdout():
             x, v = pso(
                 self._funcwrapped, self._lower, self._upper,
                 maxiter=MAX_IT, )
         if self._xmini is None:
             self._xmini = x
         if self._fmini is None:
             self._fmini = v
         if v < self._fmini:
             self._fmini = v
             self._xmini = x
def select_params_with_pso(ks):
    for k in ks:
        MODEL_PARAM['k'] = k
        kwargs = {
            'trn_xs': trn_xs,
            'trn_ys': trn_ys,
            'tst_xs': tst_xs,
            'tst_ys': tst_ys,
            'model_name': MODEL_NAME,
            'model_param': MODEL_PARAM,
            'model_repeat': MODEL_REPEAT,
        }
        # print '@@@@@@@@@@@@', MODEL_PARAM['k']
        xopt, fopt = pso(objective, lb, ub, maxiter=200, swarmsize=80, debug=False, processes=8, kwargs=kwargs)
        # print xopt, fopt
        # print 'result:'
        print k, fopt,
        for wi in xopt:
            print '%.8f' % wi,
        print ''
        sys.stdout.flush()
def gprSwarmOptim_helper(train,target,max_evals,lb,ub,swarmsize=100):
    """
    optimizer for hyperOptim. Runs a GP and if it fails (which happens if two points have the same input but differen output) tries a random forest.
    Then estimates the optimum using PSO.
    :param train:
    :param target:
    :param max_evals:
    :param lb:
    :param ub:
    :param swarmsize:
    :return:
    """
    try:
        gp = GaussianProcess(regr='quadratic', corr='squared_exponential',nugget=1e-2, optimizer='Welch')
        gp.fit(train,target)
    except:
        gp=RandomForestRegressor(n_estimators=(50+2*len(train)))
        gp.fit(train,target)
    
    
    xopt = pso(lambda x:-1.0*gp.predict([x]), lb, ub,swarmsize=swarmsize)
    return (xopt[0],-1*xopt[1])
示例#11
0
文件: superplus.py 项目: sarocu/smpc
    def deterministic(self):
        # create upper and lower bound matrices:
        setpointList = self.model.setpoints
        upperbounds = numpy.zeros((self.horizon, len(setpointList)))
        upperbounds.fill(self.upperbound)
        lowerbounds = numpy.zeros((self.horizon, len(setpointList)))
        lowerbounds.fill(self.lowerbound)

        def cost(setpoints):
            # get weather vector:
            self.determine = self.create_weather_vectors(1)[0]

            # create a dataframe using the weather vector and setpoint matrix:
            weather = pandas.DataFrame(self.determine, columns=self.generator.predictor_variables)
            sp = pandas.DataFrame(setpoints, columns=setpointList)
            data = pandas.concat([weather, sp], axis=1)
            prediction = self.model.predict(data)
            total_cost = numpy.sum(prediction)
            return total_cost


        # run the optimiztion:
        return pso(cost, lowerbounds, upperbounds)
示例#12
0
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 30 16:51:01 2015

@author: 8
"""

from pyswarm import pso
import numpy as np
from math import pi, exp, sqrt


#
def ackley(chrom):
    chrom = np.array(chrom)
    sum1 = np.sum(chrom**2)
    sum2 = np.sum(np.cos(2 * pi * chrom))
    n = len(chrom)
    f = -20 * exp(-.2 * sqrt(sum1 / n)) - exp(sum2 / n) + 20 + exp(1)
    return f


dim = 4
x, f = pso(ackley, [-30] * dim, [30] * dim,
           maxiter=10000,
           minfunc=1e-15,
           minstep=1e-16)

print f
示例#13
0
 def optimize(self):
     while self._nbcall < MAX_FN_CALL:
         with nostdout():
             xopt, fopt = pso(
                 self._funcwrapped, self._lower, self._upper,
                 maxiter=MAX_IT)
示例#14
0
        cons_water_upper = 150 - X[3]
        cons_age_upper = 30 - X[-1]
        return [cons_str_lower, cons_water_upper, cons_age_upper]

    # Log info
    logging.info(objective.__doc__)
    logging.info(constraints.__doc__)

    # Run PSO 5 times with some generic hyper-parameters
    X_opts = []
    n_runs = 5
    for n in range(n_runs):
        logging.info('Run %d' % (n))
        X_opt, _ = pso(objective,
                       lower_bounds,
                       upper_bounds,
                       f_ieqcons=constraints,
                       swarmsize=100,
                       maxiter=200)
        X_opts.append(X_opt)
    X_opts = np.asarray(X_opts)
    y_hat_opts = regressor.predict(X_opts).reshape(-1, 1)
    data_opt = np.concatenate([X_opts, y_hat_opts], axis=1)
    df_predict = pd.DataFrame(columns=df.columns, data=data_opt)
    logging.info('Particle swarm optimization completed...\n\n')

    # Display Results
    for n in range(5):
        print('Run: %d' % n)
        print(df_predict.loc[n], '\n\n')

    # Compare with unseen data
示例#15
0
    "KappaP11G", "KappaP22D", "KappaP33D", "LambdaD", "RSigmaST", "RSigmaMT",
    "RSigmaLT", "Sigma22F", "Sigma33F", "ThetaP2F", "ThetaP3F", "KappaP22F",
    "KappaP33F", "LambdaF"
]
llh_best = np.inf
list_parameters = []
list_factors = []
list_llh = []

for i in range(iterations):
    # res = minimize(kalman_afns, initial_guess, args=other_args, method="SLSQP", bounds=bnds, constraints=cons,
    #                options=opt)
    res, fopt = pso(kalman_afns,
                    args=other_args,
                    lb=lbnds,
                    ub=ubnds,
                    maxiter=50,
                    debug=False,
                    swarmsize=100,
                    minstep=1e-3)
    llh, df_factor_ts = kalman_afns(res, delta_t, tenors, rates_dict, True)
    df_parameters = pd.DataFrame(np.reshape(res, (1, 20)),
                                 columns=parameter_columns,
                                 index=[i])
    df_parameters = df_parameters.assign(loglh=[llh])
    if llh < llh_best:
        # df_factors_ts = df_factors_ts.assign(it=[i]*df_factors_ts.shape[0])
        llh_best = llh
        print("Best: %s" % llh_best)
        df_factor_results = df_factor_ts
        df_parameters_best = df_parameters
    list_parameters.append(df_parameters_best)
        fout.close()
        
        def minfunc(pars):
            if model.mark3LogPrior(pars) != -np.inf:
                ll = model.mark6LogLikelihood(pars, incJitter=incJitterEquad)
                return -ll 
            else:
                return 1e80
            
        p0 = model.initParameters(fixpstart=False, startEfacAtOne=False)
            
        #maxpars = fmin(minfunc, p0, ftol=1e-8, maxiter=10000, maxfun=1000, disp=True)
        #x = minimize(minfunc, p0, method='CG', tol=1e-3)
        #maxpars = x.x
        maxpars, maxf = pyswarm.pso(minfunc, model.pmin, model.pmax, swarmsize=500, \
                        omega=0.5, phip=0.5, phig=0.5, maxiter=1000, debug=False, \
                        minfunc=1e-3)

        
        pars = np.loadtxt(outdir + '/chains/{0}'.format(model.psr[0].name)+ \
                          '/pars.txt', dtype='S42')
        fout = open(outdir + '/noisefiles/{0}_noise.txt'.format(model.psr[0].name), 'w')
        for ii,pp in enumerate(pars):
            fout.write('{0} {1}\n'.format(pp, maxpars[ii]))
        fout.close()
        print psr, maxpars, model.mark6LogLikelihood(maxpars, incJitter=incJitterEquad)
    

# setup full model
if args.pname[0] != 'all':
    model = PALmodels.PTAmodels(h5filename, pulsars=args.pname)
示例#17
0
                                    individual[21]) + "," + str(
                                        individual[22]) + "," + str(
                                            individual[23]) + "," + str(
                                                individual[24]) + "," + str(
                                                    individual[25]) + " ]"
    print "------------------------"

    return y


#----------------------------------------------------------------------
##PySwarm
print('*' * 65)
print('Example minimization of 4th-order banana function (no constraints)')
#xopt1, fopt1 = pso(example_fitness, min_ind, max_ind)
xopt1, fopt1 = pso(example_fitness, min_ind, max_ind, maxiter=200)
#xopt1, fopt1 = pso(example_fitness, min_ind, max_ind, ieqcons=[],
#                   f_ieqcons=None, args=(), kwargs={},
#                   swarmsize=100, omega=0.5, phip=0.5, phig=0.5, maxiter=100,
#                   minstep=1e-8, minfunc=1e-8, debug=False)
# https://pythonhosted.org/pyswarm/
print('The optimum is at:')
print('    {}'.format(xopt1))
print('Optimal function value:')
print('    myfunc: {}'.format(fopt1))
#----------------------------------------------------------------------
##PySwarm
#print ('*'*65)
#print ('Example minimization of 4th-order banana function (with constraint)')
#def mycon(x):
#    x1 = x[0]
示例#18
0
    opt_prob.addObj('f')
    #opt_prob.addCon('g1','i') #possibility to add constraintes
    #opt_prob.addCon('g2','i')

    ##############################################################################
    ##############################################################################
    # solving the problem with the function in scipy.optimize
    ##############################################################################
    ##############################################################################
    if algo == 1:
        xopt, fopt = pso(monerreur,
                         lb,
                         up,
                         swarmsize=swarmsize,
                         minfunc=1e-18,
                         minstep=1e-8,
                         debug=1,
                         phip=0.5,
                         phig=0.5,
                         maxiter=maxiter)
    ##############################################################################
    ##############################################################################
    # solving the problem with yopt
    ##############################################################################
    ##############################################################################
swarmsize = comm.bcast(swarmsize, root=0)
maxiter = comm.bcast(maxiter, root=0)

if algo == 2:
    # Solve Problem (No-Parallelization)
    alpso_none = ALPSO()  #pll_type='SPM')
示例#19
0
def particle_search(min_var,
                    max_var,
                    deltas,
                    initial_structure_obj,
                    lateral_pressure,
                    init_filter=float('inf'),
                    side='p',
                    const_chk=(True, True, True, True),
                    pso_options=(100, 0.5, 0.5, 0.5, 100, 1e-8, 1e-8),
                    fat_dict=None,
                    fat_press=None,
                    slamming_press=0):
    '''
    Searchin using Particle Swarm Search (http://pythonhosted.org/pyswarm/)

    :param min_var:
    :param max_var:
    :param deltas:
    :param initial_structure_obj:
    :param lateral_pressure:
    :param side:
    :param const_chk:
        :param pso_options:
    :return:
    '''

    args = (initial_structure_obj, lateral_pressure, init_filter, side,
            const_chk, min_var[6], min_var[7], fat_dict, fat_press,
            slamming_press)
    # Multiprocessing is not efficient if the swarm size is below 500 (approximatly).
    if pso_options[0] < 500:
        xopt, fopt = pso(calc_weight_pso,
                         min_var[0:6],
                         max_var[0:6],
                         f_ieqcons=any_constraints_all_number,
                         swarmsize=pso_options[0],
                         omega=pso_options[1],
                         phip=pso_options[2],
                         phig=pso_options[3],
                         maxiter=pso_options[4],
                         minstep=pso_options[5],
                         minfunc=pso_options[6],
                         args=args)
    else:
        xopt, fopt = pso(calc_weight_pso,
                         min_var[0:6],
                         max_var[0:6],
                         f_ieqcons=any_constraints_all_number,
                         swarmsize=pso_options[0],
                         omega=pso_options[1],
                         phip=pso_options[2],
                         phig=pso_options[3],
                         maxiter=pso_options[4],
                         minstep=pso_options[5],
                         minfunc=pso_options[6],
                         args=args,
                         processes=cpu_count())

    ass_var = xopt
    np.append(ass_var, [args[5], args[6]])
    new_structure_obj = create_new_structure_obj(
        initial_structure_obj, [round(item, 5) for item in ass_var])
    new_calc_obj = create_new_calc_obj(initial_structure_obj,
                                       [round(item, 5) for item in ass_var])[0]

    args = list(args)
    args[0] = new_structure_obj

    return new_structure_obj, new_calc_obj, fat_dict, True if any_constraints_all_number(
        xopt, *args) == 0 else False
示例#20
0
#def con(x):
#   x1 = x[0]
#  x2 = x[1]
# return [-(x1 + 0.25)**2 + 0.75*x2]

lb = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0
]
ub = [
    300, 5, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
    1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
    1000, 1000, 1000, 1000, 1000
]
xopt, fopt = pso(transposer, lb, ub)

# Optimum should be around x=[0.5, 0.76] with banana(x)=4.5 and con(x)=0

# import kivy module
import kivy

# this restrict the kivy version i.e
# below this kivy version you cannot
# use the app or software
kivy.require("1.9.1")

# base Class of your App inherits from the App class.
# app:always refers to the instance of your application
from kivy.app import App
            f = 0
            for j in range(0, 7):
                f = f + 100 * (xx[j + 1] - xx[j]**2)**2 + (1.0 - xx[j])**2
            return f

        comparetol = 1e-4

        maxevals = 80
        delta = .1
        nsamp = round(maxevals / 3)

        # compute optimum/optimizer by PSO
        from pyswarm import pso  # https://pythonhosted.org/pyswarm/
        xopt0, fopt0 = pso(fun,
                           lb,
                           ub,
                           swarmsize=200,
                           minfunc=1e-12,
                           maxiter=10000)
        use_linear_constraints = 0
        use_nl_constraints = 0

    elif benchmark == "ackley":
        nvars = 2
        lb = -5 * ones((nvars, 1)).flatten("c")
        ub = -lb
        fun = lambda x: array([
            -20.0 * exp(-.2 * sqrt(0.5 * (x[0]**2 + x[1]**2))) - exp(0.5 * (
                cos(2.0 * pi * x[0]) + cos(2.0 * pi * x[1]))) + exp(1.0) + 20.0
        ])
        comparetol = 1e-4
示例#22
0
from pyswarm import pso

def banana(x):
    x1 = x[0]
    x2 = x[1]
    return x1**4 - 2*x2*x1**2 + x2**2 + x1**2 - 2*x1 + 5

def con(x):
    x1 = x[0]
    x2 = x[1]
    return [-(x1 + 0.25)**2 + 0.75*x2]

lb = [-10, -10]
ub = [10, 10]

xopt, fopt = pso(banana, lb, ub, debug=True)
print xopt, fopt
示例#23
0
    loss = log_loss(testY, preds, labels=classes)

    return loss


if __name__ == '__main__':
    # Load dataset
    train_texts, train_targets, validation_texts, validation_targets = get_dataset_partitions(
    )

    # Convert dataset to feature representation
    build_featureset(train_texts, train_targets, validation_texts,
                     validation_targets)

    # Dictate upper and lower bounds of a particle
    lower_bound = [0.01, 0.1]
    upper_bound = [1.2, 2]

    # Run PSO
    xopt, fopt = pso(loss,
                     lower_bound,
                     upper_bound,
                     swarmsize=5,
                     maxiter=5,
                     omega=0.75,
                     phip=0.75,
                     phig=0.75,
                     debug=True)
    print("OPTIMAL HYPERPARAMETER SETUP: {}\nMINIMUM LOSS OBTAINED: {}".format(
        xopt, fopt))
示例#24
0
    def fit(self, X, y):
        #X_train_inner, X_test_inner, y_train_inner, y_test_inner = model_selection.train_test_split(X, y, test_size = 0.2, random_state = 40, shuffle = True)
        X = np.array(X)
        y = np.array(y)

        # Define Objective function
        def obj(x):
            params = {
                self.hyperparameters[0]: int(x[0]),
                self.hyperparameters[1]: int(x[1]),
                self.hyperparameters[2]: x[2],
                self.hyperparameters[3]: x[3],
                self.hyperparameters[4]: x[4],
                self.hyperparameters[5]: int(x[5])
            }

            kf = model_selection.KFold(n_splits=self.cv)
            kf.get_n_splits(X)

            rmse = []
            for train_index, test_index in kf.split(np.array(X)):
                X_train_inner, X_test_inner = np.array(
                    X)[train_index], np.array(X)[test_index]
                y_train_inner, y_test_inner = np.array(
                    y)[train_index], np.array(y)[test_index]

                model = lgb.LGBMRegressor(**params).fit(
                    X_train_inner, y_train_inner)

                rmse.append(
                    metrics.mean_squared_error(y_test_inner,
                                               model.predict(X_test_inner)))

            rmse = np.mean(rmse)

            return rmse

        # Perform Model Optimization
        xopt, fopt = pyswarm.pso(func=obj,
                                 lb=self.lb,
                                 ub=self.ub,
                                 swarmsize=self.pop,
                                 phip=self.phip,
                                 phig=self.phig,
                                 omega=self.omega,
                                 maxiter=self.maxiter,
                                 minstep=self.minstep,
                                 minfunc=self.minfunc,
                                 debug=self.debug)

        # Fit the best model
        hyperpara_optimized = {
            self.hyperparameters[0]: int(xopt[0]),
            self.hyperparameters[1]: int(xopt[1]),
            self.hyperparameters[2]: xopt[2],
            self.hyperparameters[3]: xopt[3],
            self.hyperparameters[4]: xopt[4],
            self.hyperparameters[5]: int(xopt[5])
        }

        self.fitted_model = lgb.LGBMRegressor(**hyperpara_optimized).fit(X, y)
        return self
def main():

    filename = sys.argv[1]
    data = readfile(filename)
    row, col = data.shape
    #print max(data[row-4])
    newbigger = []
    for rownum in xrange(row):
        newbigger.append(data[rownum][col - 1])
    midnum = caculatemidnum(newbigger)
    data = data / midnum
    if row > 0:
        file_result = open('result.txt', 'w')
        file_result.write(
            repr('para_a').rjust(10) + repr('para_b').rjust(10) +
            repr('para_c').rjust(10) + repr('para_d').rjust(10) +
            repr('para_e').rjust(10) + repr('para_f').rjust(10) +
            repr('para_g').rjust(10) + repr('error').rjust(10) + '\n')
    for rownum in xrange(row):
        '''print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()'''
        args = data[rownum]
        length = len(args)
        iteration = constraint(args, length)
        print('iterations={}'.format(iteration))
        print("please wait a moment....")
        minNum = args.min()
        maxNum = args.max()
        meanNum = args.mean()
        lb = [-maxNum, 0, -meanNum, -1, -maxNum, -1, -maxNum]
        ub = [1, 0.5, maxNum, 1.1, maxNum + meanNum, 1.1, maxNum + meanNum]
        initialData = [0, 0.01, meanNum, -1, maxNum, 0.7, maxNum]
        initialData2 = [minNum, 0.03, meanNum + 4, 0.1, maxNum, -1, maxNum]
        xopt4, fopt4 = pso(myfunction,
                           lb,
                           ub,
                           args=args,
                           initialData=initialData,
                           initialData2=initialData2,
                           swarmsize=250,
                           maxiter=iteration)
        print('The optimum is at:')
        print('    {}'.format(xopt4))
        print('Optimal function values:')
        #print('    R-square : {}'.format(fopt4))
        print('ajusted R-squared:{}'.format(-fopt4))
        file_result.write(
            repr(xopt4[0]).rjust(10) + repr(xopt4[1]).rjust(10) +
            repr(xopt4[2]).rjust(10) + repr(xopt4[3]).rjust(10) +
            repr(xopt4[4]).rjust(10) + repr(xopt4[5]).rjust(10) +
            repr(xopt4[6]).rjust(10) + repr(fopt4).rjust(10) + '\n')
        x = np.linspace(1, length, 10000)
        y = xopt4[0] + xopt4[1] * x + xopt4[2] / (
            (1 + np.exp(-xopt4[3] * (x - xopt4[4]))) *
            (1 + np.exp(-xopt4[5] * (x - xopt4[6]))))
        plt.figure(rownum)
        for i in xrange(length):
            plt.plot(i + 1, args[i], 'blue', linestyle='dashed', marker='.')
        plt.plot(x, y, 'r', linewidth=2)
        plt.xlabel("circle(Time)")
        plt.ylabel("fluorescence")
        plt.legend()
        plt.show()
    if row > 0:
        file_result.close()
                         "KappaP33D", "LambdaD",
                         "RSigmaST", "RSigmaMT", "RSigmaLT", "Sigma22F", "Sigma33F", "ThetaP2F",
                         "ThetaP3F", "KappaP22F",
                         "KappaP33F", "LambdaF"]
    llh_best = np.inf

    curr_rates_dict = {"eur": rates_dict["eur"].truncate(before=begin_estimation_window, after=fc_date),
                       "gbp": rates_dict["gbp"].truncate(before=begin_estimation_window, after=fc_date),
                       "fxgbpeur": rates_dict["fxgbpeur"].truncate(before=begin_estimation_window, after=fc_date)}

    # other arguments to transfer to kalman_afns
    other_args = (delta_t, tenors, curr_rates_dict, False)

    for i in range(iterations):
        res, fopt = pso(kalman_afns, args=other_args, lb=lbnds, ub=ubnds, maxiter=pso_maxiter, debug=False,
                        swarmsize=n_swarm,
                        minstep=pso_minstep)
        llh, df_factor_ts = kalman_afns(res, delta_t, tenors, curr_rates_dict, True)
        df_parameters = pd.DataFrame(np.reshape(res, (1, 20)), columns=parameter_columns, index=[fc_date])
        df_parameters = df_parameters.assign(loglh=[llh])
        if llh < llh_best:
            df_factor_ts["fcdate"] = fc_date
            df_factor_ts.set_index('fcdate', append=True, inplace=True)
            df_factors_best = df_factor_ts
            df_parameters_best = df_parameters
            llh_best = llh
        print((i + 1) / iterations * 100, "%")
        print("---Elapsed time: %s seconds ---" % (time.time() - start_time))
    list_factors_best.append(df_factors_best)
    list_parameters_best.append(df_parameters_best)
    print(llh_best)
示例#27
0
def pyswarm_library():
    """PSO using Pysmwarm library"""

    # PARAMETERS DEFINITION
    pop_size = 500
    iteration = 1000
    w = 0.5
    c1 = 0.5
    c2 = 0.5
    minstep = 1e-3
    minfunc = 1e-3
    debug = False

    # Default parameters
    print("Use default parameters:\n"
          "\t\t\tpop_size =", pop_size, "\n", "\t\t\titeration =", iteration,
          "\n", "\t\t\tw =", w, "\n", "\t\t\tc1 =", c1, "\n", "\t\t\tc2 =", c2,
          "\n", "\t\t\tminstep =", minstep, "\n", "\t\t\tminfunc =", minfunc,
          "\n", "\t\t\tdebug =", debug, "\n\n",
          "or set personal ones? [D for default|P for personal]")

    # Set personal parameters
    param = input()
    if param == "P":
        print("Size of population = [int]")
        pop_size = eval(input())
        print("Number of interation = [int]")
        iteration = eval(input())
        print("Inertial weight = [float]")
        w = eval(input())
        print("Cognitive coefficient = [float]")
        c1 = eval(input())
        print("Social coefficient [float]")
        c2 = eval(input())
        print(
            "The minimum stepsize of swarm’s best position before the search terminates = [int]"
        )
        minstep = eval(input())
        print(
            "Minimum change of swarm’s best objective value before the search terminates = [int]"
        )
        minfunc = eval(input())
        print("Active debyg = [boolean]")
        debug = eval(input())

    def constraints(x):
        """Pick the constraints from benchmarck_function file"""
        for k in range(len(x)):
            locals()[f"x{k+1}"] = x[k]
        constraints = eval("bf." + opt_func + ".inequal_constraints")
        positive_constraints = []
        for k in range(len(constraints)):
            # Library use >= notation
            positive_constraints.extend([eval(constraints[k]) * -1])
        return positive_constraints

    lb = []
    ub = []
    # Pick the bounds of the fitting function
    for k in range(len(eval("bf." + opt_func + ".bounds"))):
        lb.extend([eval("bf." + opt_func + ".bounds")[k][0]])
        ub.extend([eval("bf." + opt_func + ".bounds")[k][1]])

    # Compute gbest with library function
    start_time = time.time()
    gbest_pos, gbest = pso(eval("bf." + opt_func + ".function"),
                           lb,
                           ub,
                           f_ieqcons=constraints,
                           swarmsize=pop_size,
                           omega=w,
                           phip=c1,
                           phig=c2,
                           maxiter=iteration,
                           minstep=minstep,
                           minfunc=minfunc,
                           debug=debug)

    end_time = time.time()
    print("ELAPSED TIME:", f"{end_time-start_time:.0f}", "sec for", runs,
          "runs")

    return gbest, gbest_pos
示例#28
0
def preparation():
    project_path = 'C:\\Users\\FrancescoBaldi\\switchdrive\\Work in progress\\Paper 0\\Ecos2015PaperExtension\\'
    path_files = project_path + os.sep
    sys.path.append(path_files)
    filenames = input.filenames(project_path)  # Note: this is just a test
    CONSTANTS = kk.constantsSetting()
    CONSTANTS["filenames"] = filenames
    processed_temp = pd.read_hdf(CONSTANTS["filenames"]["dataset_output"],
                                 'processed')
    dataset_raw = pd.read_hdf(filenames["dataset_raw"], 'table')
    data = pd.DataFrame(index=processed_temp.index)
    indexes_2_save_processed = {
        "Passengers_calc",
        "Demands:Electricity:HVAC:Edot",
        "T_air",
        "AE1:Cyl:FuelPh_in:mdot",
        "AE2:Cyl:FuelPh_in:mdot",
        "AE3:Cyl:FuelPh_in:mdot",
        "AE4:Cyl:FuelPh_in:mdot",
        "ME1:Cyl:FuelPh_in:mdot",
        "ME2:Cyl:FuelPh_in:mdot",
        "ME3:Cyl:FuelPh_in:mdot",
        "ME4:Cyl:FuelPh_in:mdot",
        "ME2:HRSG:Steam_in:mdot",
        "ME3:HRSG:Steam_in:mdot",
        "AE1:HRSG:Steam_in:mdot",
        "AE2:HRSG:Steam_in:mdot",
        "AE3:HRSG:Steam_in:mdot",
        "AE4:HRSG:Steam_in:mdot",
        "CoolingSystems:HTcollector24:HTWater_out:mdot",
        "CoolingSystems:HTcollector13:HTWater_out:mdot",
        "CoolingSystems:HTcollector24:HTWater_out:T",
        "CoolingSystems:HTcollector13:HTWater_out:T",
        "ME1:on",
        "ME2:on",
        "ME3:on",
        "ME4:on",
        "AE1:on",
        "AE2:on",
        "AE3:on",
        "AE4:on",
    }
    indexes_2_save_raw = {
        "SBO 1 OUTLET PRESSUR:7313:bar:Average:900",
        "SBO 2 OUTLET PRESSUR:7333:bar:Average:900", "Boiler_Port",
        "Boiler_starbord"
    }
    for idx in indexes_2_save_processed:
        data[idx] = processed_temp[idx]
    for idx in indexes_2_save_raw:
        data[idx] = dataset_raw[idx]
    # Prepare the input
    constant_input = (data, CONSTANTS, "optimization")
    # Set the boundaries
    lb = [0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 0.2, 343, 0.5, 1e4, 2000]
    ub = [1000, 1000, 1.0, 1.0, 1.0, 1.0, 1.0, 353, 0.9, 1e7, 8000]
    # param[0] = Constant demand to the HTHR systems
    # param[1] = Constant steam demand
    # param[2] = a1 factor of the HVAC re-heater     (HVAC,RH)
    # param[3] = a1 factor of the hot water heater   (HWH)
    # param[4] = a1 factor of the HVAC pre-heater    (HVAC,PH)
    # param[5] = a1 factor of the Galley             (G)
    # param[6] = a1 factor of the Other users        (TH, OT, HFOT)
    # param[7] = Fixed temperature of the HRHT
    # param[8] = Effectiveness of the HTHR heat exchangers
    # param[9] = Boiler drum steam storage capacity [MJ, energy]
    # param[10] = Boiler heat rate when in use [kW]

    # Launch the optimization
    xopt, fopt = pso(fitnessFunction, lb, ub, args=constant_input, debug=True)
    # Test 1
    # xopt = [0.00000000e+00, 0.00000000e+00, 2.54803569e-01, 9.99957005e-01, 1.00000000e+00, 5.48135386e-01, 2.02497633e-01, 3.46800156e+02, 5.00000000e-01, 9.91841867e+06, 7.92913650e+03]
    # xopt = [1.11658780e+02, 1.01578823e+01, 2.58777430e-01, 7.33523799e-01, 1.00000000e+00, 7.31005444e-01, 2.00407605e-01, 3.43000000e+02, 5.00000000e-01, 1.00000000e+07, 2.83632523e+03]
    # fopt = 0.3632706766877296
    fitnessFunction(xopt, data, CONSTANTS, "test")
    return (xopt, fopt)
def main():

    filename = sys.argv[1]
    data = readfile(filename)
    row, col = data.shape
    # print max(data[row-4])
    newbigger = []
    for rownum in xrange(row):
        newbigger.append(data[rownum][col - 1])
    midnum = caculatemidnum(newbigger)
    data = data / midnum
    if row > 0:
        file_result = open("result.txt", "w")
        file_result.write(
            repr("para_a").rjust(10)
            + repr("para_b").rjust(10)
            + repr("para_c").rjust(10)
            + repr("para_d").rjust(10)
            + repr("para_e").rjust(10)
            + repr("para_f").rjust(10)
            + repr("para_g").rjust(10)
            + repr("error").rjust(10)
            + "\n"
        )
    for rownum in xrange(row):
        """print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()"""
        print("please wait a moment....")
        args = data[rownum]
        length = len(args)
        minNum = args.min()
        maxNum = args.max()
        meanNum = args.mean()
        lb = [minNum - maxNum, 0, meanNum - maxNum, -1, minNum, -1, minNum]
        ub = [meanNum, 0.5, meanNum + maxNum, 1.1, meanNum + maxNum, 1.1, meanNum + maxNum]
        initialData = [minNum, 0.01, meanNum, -0.1, maxNum, 0.7, maxNum]
        xopt4, fopt4 = pso(myfunction, lb, ub, args=args, initialData=initialData)
        print("The optimum is at:")
        print("    {}".format(xopt4))
        print("Optimal function values:")
        # print('    R-square : {}'.format(fopt4))
        print("ajusted R-squared:{}".format(fopt4))
        file_result.write(
            repr(xopt4[0]).rjust(10)
            + repr(xopt4[1]).rjust(10)
            + repr(xopt4[2]).rjust(10)
            + repr(xopt4[3]).rjust(10)
            + repr(xopt4[4]).rjust(10)
            + repr(xopt4[5]).rjust(10)
            + repr(xopt4[6]).rjust(10)
            + repr(fopt4).rjust(10)
            + "\n"
        )
        x = np.linspace(1, length, 10000)
        y = (
            xopt4[0]
            + xopt4[1] * x
            + xopt4[2] / ((1 + np.exp(-xopt4[3] * (x - xopt4[4]))) * (1 + np.exp(-xopt4[5] * (x - xopt4[6]))))
        )
        plt.figure(rownum)
        for i in xrange(length):
            plt.plot(i + 1, args[i], "blue", linestyle="dashed", marker="*")
        plt.plot(x, y, "r", linewidth=2)
        plt.xlabel("circle(Time)")
        plt.ylabel("fluorescence")
        plt.legend()
        plt.show()
    if row > 0:
        file_result.close()
示例#30
0
 def optimize(self):
     with nostdout():
         xopt, fopt = pso(
             self._funcwrapped, self._lower, self._upper,
             maxiter=MAX_IT)
示例#31
0
    def fit(self, X, y):
        # Get split indices
        kf = model_selection.StratifiedKFold(n_splits=self.cv, random_state=0)
        kf.get_n_splits(X)

        # initialize model list
        self.model_list = []
        self.score = []
        self.model_name = []
        print('\n\n Tuning Models \n\n')

        split_index = 1
        # Split into train test
        for train_index, test_index in kf.split(X, y):
            X_train, X_test = np.array(X)[train_index], np.array(X)[test_index]
            y_train, y_test = np.array(y).ravel()[train_index], np.array(
                y).ravel()[test_index]

            if self.sample == 'oversample':
                X_train, y_train = over_sampling.SMOTE(
                    random_state=12).fit_resample(X_train, y_train)
            if self.sample == 'undersample':
                X_train, y_train = under_sampling.EditedNearestNeighbours(
                    random_state=12).fit_resample(X_train, y_train)
            if self.sample == 'balance':
                X_train, y_train = combine.SMOTEENN(
                    random_state=12).fit_resample(X_train, y_train)

            # Define objective function
            def obj(x):
                params = {
                    'n_estimators': int(x[0]),
                    'max_depth': int(x[1]),
                    'min_data_in_leaf': int(x[2]),
                    'learning_rate': x[3],
                    'subsample': x[4],
                    'feature_fraction': x[5],
                    'reg_lambda': x[6],
                    'num_leaves': int(x[7])
                }

                # Fit required model:
                model_sel = lgb.LGBMClassifier(**params).fit(
                    X_train,
                    y_train,
                    eval_set=[(X_test, y_test)],
                    eval_metric='multi_logloss',
                    verbose=False)

                # Evaluate rmse
                score = -metrics.accuracy_score(y_test,
                                                model_sel.predict(X_test))

                return score

            if split_index == 1:
                ## Optimize

                pso = pyswarm.pso(func=obj,
                                  lb=[val[0] for val in self.bounds],
                                  ub=[val[1] for val in self.bounds],
                                  swarmsize=self.swarmsize,
                                  omega=self.omega,
                                  phip=self.phip,
                                  phig=self.phig,
                                  maxiter=self.maxiter,
                                  minstep=self.minstep,
                                  minfunc=self.minfunc,
                                  debug=self.debug)

                # Get tuned hyperparameters
                x = pso[0]
                params_tuned = {
                    'n_estimators': int(x[0]),
                    'max_depth': int(x[1]),
                    'min_data_in_leaf': int(x[2]),
                    'learning_rate': x[3],
                    'subsample': x[4],
                    'feature_fraction': x[5],
                    'reg_lambda': x[6],
                    'num_leaves': int(x[7])
                }

            # Get Fitted, tuned model
            fitted_model = lgb.LGBMClassifier(**params_tuned).fit(
                X_train,
                y_train,
                eval_set=[(X_test, y_test)],
                eval_metric='multi_logloss',
                verbose=False)
            self.model_name.append('model' + str(split_index))

            # Calculate Score
            score_temp = metrics.accuracy_score(y_test,
                                                fitted_model.predict(X_test))
            self.score.append(score_temp)
            print('Metric: ', score_temp, '\n\n')

            # Append model to final list of models
            self.model_list.append(fitted_model)

            # Print fold errors
            print(self.score)
            split_index = split_index + 1
        model_rank = pd.DataFrame(data=list(zip(self.model_list, self.score)),
                                  index=self.model_name,
                                  columns=['model', 'score'])

        self.top_n_model_list = model_rank.sort_values(
            'score')[:self.top_n].model.values.tolist()
        print('\n All Models trained: \n', model_rank['score'])
        #print('\n \n Models Selected by voting: \n \n', model_rank.sort_values('score')[:self.top_n]['score'])

        self.voting_classifier = ensemble.VotingClassifier(
            estimators=list(zip(self.model_name, self.model_list)),
            voting='soft').fit(X, y)

        self.fitted_status = True
        return self
示例#32
0
 def optimize(self):
     while (self._nbcall < MAX_FN_CALL):
         with nostdout():
             xopt, fopt = pso(
                 self._funcwrapped, self._lower, self._upper,
                 maxiter=MAX_IT)
示例#33
0
文件: PSO.py 项目: amir9979/sfl
    for comp, h_score in zip(d, h):
        h_dict[comp] = h_score
    #print("h_dict",h,h_dict,matrix[0])
    p_d = 1.0
    all_s = ""
    for activity_vec, e in zip(matrix, error_vec):
        p_e_d = 1
        s = ""
        for comp in d:
            if activity_vec[comp] == 1:
                p_e_d = p_e_d * h_dict[comp]
                s = s + "h" + str(comp)
        if e == 1:
            p_e_d = 1 - p_e_d
            s = "1-" + s
        all_s = all_s + "(" + s
        p_d = p_d * p_e_d
    #print(all_s)
    return -p_d


lb = [0 for _ in d]
# ub=[1 for _ in d]
#ub=[1 for x,ind in enumerate(matrix[0]) if ind ]

xopt, fopt = pso(probabilty_TF, lb, ub, swarmsize=1000, maxiter=10000000)
print(-fopt)

# print -probabilty_TF([0.47,0.19])
# print -probabilty_TF([0.41,0.5])
示例#34
0
        for i in range(2):
            lb.append(-2.048)
            ub.append(2.048)
    elif fu == "DJF3":
        for i in range(4):
            lb.append(-5.12)
            ub.append(5.12)
    elif fu == "GP":
        for i in range(2):
            lb.append(-2)
            ub.append(2)
    elif fu == "R":
        for i in range(4):
            lb.append(-2.048)
            ub.append(2.048)
    elif fu == "Z":
        for i in range(4):
            lb.append(-5)
            ub.append(10)
    elif fu == "SH":
        for i in range(6):
            lb.append(-500)
            ub.append(500)

    # xopt, fopt = pso(locals()[fu], lb, ub, maxiter=300, minfunc=1e-8, minstep=1e-8)
    xopt, fopt = pso(locals()[fu], lb, ub, \
            maxiter=9000, minfunc=1e-16, minstep=1e-16, \
            swarmsize=460, omega=0.9, phip=0.7, phig=0.2)
    print "Result: " + str(fopt)
    print "Parameters:\n" + str(xopt)
示例#35
0
    sleep(0.05)
    print x,y,z
    #X.append(x)
    #Y.append(y)
    #Z.append(z)
    return z

print f([0,0])
print f([-3.263,-3.186])
print f([-3.186,-3.263])

print "busqueda PSO"
lb = [0.045, 2200]
ub = [0.085, 3800]

xopt, fopt = pso(f_robot, lb, ub, swarmsize=5, minstep=30)

X = []
Y = []
Z = []

print len(X)
print xopt
print fopt


fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for i in range(len(X)):
    xs = X[i]
    ys = Y[i]
示例#36
0
        print(D.love)
        print(d.name)
    elif test == 10:
        # pso
        def myfun(x):
            x1 = x[0]
            x2 = x[1]
            return x1**2 + x2**2

        def mycon(x):
            x1 = x[0]
            x2 = x[1]
            return [x1**2 - 10, math.exp(x2) - 6e6]

        from pyswarm import pso
        g, fg = pso(myfun, [2, 6], [100, 100], f_ieqcons=mycon)
        print(f'Extreme point is {g} and corresponding value is {fg}')

    elif test == 9:
        # decorator and partial function
        from functools import wraps

        def decorator(func):
            @wraps(func)
            def new_func(*args):
                print('Hi, xiongdi')
                print('Jianghu')
                return (func(*args) + 10)

            return new_func
示例#37
0
print "\n Your initial parameters are {0}\n".format(x0)

print "\n Running a quick profile on the likelihood to estimate evaluation speed...\n"
cProfile.run('ln_prob(x0)')

##################################
# Now, we sample or maximize.....
##################################

if args.sample_or_maximize == 'maximize':

    def swarm_prob(x):
        return -ln_prob(x)

    xopt, fopt = pso(swarm_prob, pmin, pmax, swarmsize=100, omega=0.5, phip=0.5, phig=0.5, maxiter=1000, debug=True)

    print "\n Printing out the ML noise values for {0}...\n".format(psr.name)
    fil = open("{0}_MLnoise_nmode{1}.txt".format(psr.name,nmode),'w')
    for ii in range(len(xopt)):
        print "{0} = {1}".format(parameters[ii],xopt[ii])
        print >>fil, "{0} {1}".format(parameters[ii],xopt[ii])
    print "\n Values saved in {0}_MLnoise_nmode{1}.txt".format(psr.name,nmode)

else:

    cov_diag = np.array([0.5,0.5,0.5,0.5])
    cov_diag = np.append(cov_diag,0.2*np.ones(len(backends)))
    cov_diag = np.append(cov_diag,0.5*np.ones(len(backends)))
    
    print "\n Now, we sample... \n"
示例#38
0
    y_train.append(l[-1])
    del l[-1]
    x_train.append(l)

y_train = np.array(y_train, dtype='f')
x_train = np.array(x_train, dtype='f')

#Parameters to optimize:
# eta range: [0,1] [0]
# gamma range: [0,10] [1]
# max_depth range: [1,10] [2]
# min_child_weight range: [0,10] [3]
# subsample range: (0,1] [4]
# colsample_bytree range: (0,1] [5]
# num_round sem range ,por opcao, [0,300] [6]
# scale_pos_weight sem range ,por opcao, [0,10] [7]
# max_delta_step range: [0,10] [8]
# Lower-bound:
lb = [0, 0, 1, 0, 0, 0.1, 0, 0, 0]
# Upper-bound:
ub = [1, 10, 10, 10, 1, 1, 300, 10, 10]
pso(objective_function,
    lb,
    ub,
    swarmsize=200,
    omega=0.6,
    phip=0.6,
    phig=0.4,
    maxiter=1000,
    debug=False)
示例#39
0
 def optimize(self):
     with nostdout():
         xopt, fopt = pso(
             self._funcwrapped, self._lower, self._upper,
             maxiter=MAX_IT)
示例#40
0
def main(events_fpath,
         tables_dir,
         geom_file=None,
         start_index=None,
         stop_index=None):
    """Perform scans and minimization for events.

    Parameters
    ----------
    events_fpath : string
        Path to events HDF5 file

    tables_dir : string
        Path to directory containing the retro tables

    geom_file : string
        File containing detector geometry

    start_index : None or int
        Event index (as ordered in events file) to start on. Specify 0 or
        `None` to start with the first event. I.e., iterate over
        `range(start_index, stop_index)`.

    stop_index : None or int
        Event index (as ordered in events file) to stop before. I.e., iterate
        over `range(start_index, stop_index)`.

    """
    # pylint: disable=no-member

    print('Instantiate a hypo class...')
    discrete_hypo = DiscreteHypo(
        hypo_kernels=[const_energy_loss_muon, point_cascade])

    # Load events
    print('Loading events...')
    events = Events(events_fpath)
    print('  %d events found' % len(events))

    # Load detector geometry array
    print('Loading detector geometry from "%s"...' % retro.expand(geom_file))
    detector_geometry = np.load(retro.expand(geom_file))

    # Load tables
    print('Loading DOM tables...')
    dom_tables = DOMTimePolarTables(tables_dir=tables_dir,
                                    hash_val=None,
                                    geom=detector_geometry,
                                    use_directionality=False)
    dom_tables.load_tables()

    tdi_table = None
    #print('Loading TDI table...')
    #tdi_table = TDICartTable(
    #    tables_dir=tables_dir,
    #    use_directionality=False,
    #    #proto_tile_hash='0e28683a74ebea92', # 14^3 tiles, 1 m gridsize, +/- 700 m in x and y, -800 to +600 in z
    #    #proto_tile_hash='8c4770c8371a4025', # single tile, 10 m gridsize +/- 700 m in x and y, -800 to +600 in z
    #    proto_tile_hash='fd29bc306d29bc83', # single tile, QE used; 10 m gridsize +/- 700 m in x and y, -800 to +600 in z
    #    scale=1,
    #)

    neg_llh_func_kwargs = dict(dom_tables=dom_tables,
                               tdi_table=tdi_table,
                               noise_charge=NOISE_CHARGE)

    # Iterate through events
    for idx, event in enumerate(events[start_index:stop_index]):
        primary_interaction_str = retro.get_primary_interaction_str(event)

        print('Working on event #%i / event UID %d' % (idx, event.uid))
        print('  %s, %.1f GeV' %
              (primary_interaction_str, event.neutrino.energy))
        print('    track   :', event.track)
        print('    cascade :', event.cascade)

        truth_params = retro.event_to_hypo_params(event)
        pinfo_gen_truth = discrete_hypo.get_pinfo_gen(truth_params)
        neg_llh_truth = get_neg_llh(pinfo_gen=pinfo_gen_truth,
                                    event=event,
                                    **neg_llh_func_kwargs)
        print('llh at truth = %.2f' % neg_llh_truth)

        if MIN_DIMS:
            print('Will minimize following dimension(s): %s' % MIN_DIMS)

            min_results = None

            variable_dims = []
            fixed_dims = []
            for dim in retro.HYPO_PARAMS_T._fields:
                if dim in MIN_DIMS:
                    variable_dims.append(dim)
                else:
                    fixed_dims.append(dim)

            lower_bounds = []
            upper_bounds = []
            for dim in MIN_DIMS:
                if (MIN_USE_RELATIVE_BOUNDS
                        and getattr(REL_BOUNDS, dim) is not None):
                    nom_val = getattr(truth_params, dim)
                    lower = nom_val + getattr(REL_BOUNDS, dim)[0]
                    upper = nom_val + getattr(REL_BOUNDS, dim)[1]
                else:
                    lower, upper = getattr(ABS_BOUNDS, dim)
                lower_bounds.append(lower)
                upper_bounds.append(upper)

            def get_neg_llh_partial(args):
                """Minimizer callable that only includes free params as args"""
                pass

            xopt1, fopt1 = pso(get_neg_llh_partial,
                               lower_bounds,
                               upper_bounds,
                               kwargs=neg_llh_func_kwargs,
                               minstep=1e-5,
                               minfunc=1e-1,
                               debug=True)

        if SCAN_DIM_SETS:
            print('Will scan following sets of dimensions: %s' %
                  str(SCAN_DIM_SETS))
            time_to_scan = 0
            num_likelihoods = 0
            t0 = time.time()
            for dims in SCAN_DIM_SETS:
                print('Scanning dimension(s): %s...' % str(dims))

                if isinstance(dims, string_types):
                    dims = [dims]

                nominal_params = deepcopy(truth_params)
                scan_values = []
                for dim in dims:
                    if (SCAN_USE_RELATIVE_BOUNDS
                            and getattr(REL_BOUNDS, dim) is not None):
                        nom_val = getattr(nominal_params, dim)
                        lower = nom_val + getattr(REL_BOUNDS, dim)[0]
                        upper = nom_val + getattr(REL_BOUNDS, dim)[1]
                    else:
                        lower, upper = getattr(ABS_BOUNDS, dim)
                    scan_values.append(
                        np.linspace(lower, upper, NUM_SCAN_POINTS))

                ts0 = time.time()
                neg_llh = scan(hypo_obj=discrete_hypo,
                               event=event,
                               neg_llh_func=get_neg_llh,
                               dims=dims,
                               scan_values=scan_values,
                               nominal_params=nominal_params,
                               neg_llh_func_kwargs=neg_llh_func_kwargs)
                ts1 = time.time()
                time_to_scan += ts1 - ts0

                num_likelihoods += len(neg_llh)

                datadump = OrderedDict([
                    ('filename', event.filename),
                    ('event', event.event),
                    ('uid', event.uid),
                    ('neutrino_energy', event.neutrino.energy),
                    ('primary_interaction', primary_interaction_str),
                    ('dims', dims),
                    ('scan_values', scan_values),
                    ('neg_llh', neg_llh),
                    ('truth', tuple(getattr(truth_params, d) for d in dims)),
                    ('LLH_USE_NOHIT', LLH_USE_NOHIT),
                    ('CASCADE_E_SCALE', CASCADE_E_SCALE),
                    ('TRACK_E_SCALE', TRACK_E_SCALE),
                    ('NOISE_CHARGE', NOISE_CHARGE),
                ])
                fname = ('scan_results_event_%d_uid_%d_dims_%s.pkl' %
                         (event.event, event.uid, '_'.join(dims)))
                fpath = join(RESULTS_DIR, fname)
                pickle.dump(datadump, file(fpath, 'wb'),
                            pickle.HIGHEST_PROTOCOL)
                print('saved scan to "%s"' % fpath)

            plot_1d_scan(dir=RESULTS_DIR, event=event.event, uid=event.uid)
            print('')
            print('Time to scan ({:d} likelihoods): {} s'.format(
                num_likelihoods, np.round(time_to_scan, 3)))
            print('Time to scan, dump, and plot: {} s'.format(
                np.round(time.time() - t0, 3)))
            print('')
示例#41
0
    # pickle.dump(simulations, open(os.getcwd() + '/test005_1000_1000_50_' + str(starting_num) + '.obj', 'wb'))

    # Extract simulations
    list_of_simulations = [pickle.load(open(os.getcwd() + '/test005_1000_1000_50_' + str(15 + num*50) + '.obj', 'rb'))
                           for num in np.arange(10)]


    # PSO
    betas = np.array([sim[1] for simulations in list_of_simulations for sim in simulations])
    indices = np.array([sim[1] for simulations in list_of_simulations for sim in simulations])
    training_hours = np.arange(1000)
    Ec = np.reshape(ubem.city_electricity_scaled[training_hours], (ubem.modeling_hours,))

    all_buildings = create_all_buildings(ubem=ubem, total_simulations=1, sim_num=6)
    for i in np.arange(2):
        cost, pos = pso(ubem=ubem, all_buildings=all_buildings, betas=betas, Ec=Ec, n_particles=10, iters=10,
                        global_pso=False)

    # for r in np.arange(betas.shape[0]):
    #     print(r)
    #     for r_1 in np.arange(r+1, betas.shape[0]):
    #         print(np.linalg.norm(betas[r] - betas[r_1]))

    # Extract errors from log files
    # all_errors = get_simulation_errors()
    # all_errors = np.array(all_errors).flatten()
    #
    # ax = sns.distplot(all_errors, kde=False, hist=True, color='#274a5c', hist_kws={"alpha":1})
    # ax.axvline(np.mean(all_errors), color='black', linestyle='-')
    # plt.xlabel('Mean Absolute Percentage Error')
    # plt.ylabel('Count')
    # plt.savefig('/Users/jonathanroth/PycharmProjects/UBEM/Error_Distribution.pdf')
示例#42
0
times = []

for executions in range(0, 100):

    print(str(executions) + "%")

    start_time = time.time()


    km = KMeans()

    min_clusters = 2
    max_clusters = 7

    lb = [min_clusters, ]
    lb.extend([0 for i in range(0, km.dimens * max_clusters)])

    up = [max_clusters, ]
    up.extend([10 for i in range(0, km.dimens * max_clusters)])

    xopt, fopt = pso(km.execute, lb, up, swarmsize=128, maxiter=8, omega=0.125)

    end_time = time.time()
    elapsed_time = end_time - start_time

    times.append(elapsed_time)
    precisions.append(fopt)


print(times)
print(precisions)
示例#43
0
    # MERGE
    # ds = [res, res2]
    # res3 = {}
    # for k in res.keys():
    #     res3[k] = list(np.concatenate(np.array(list(d[k] for d in ds))))

    # PREPARE DATA
    res = pickle.load(open('/Users/jonathanroth/PycharmProjects/UBEM/5sims_1000T_500B.obj', 'rb'))
    error_vec = [np.mean(err) for err in res['error_vec']]
    betas = res['betas_vec']
    all_buildings = np.concatenate(res['prepared_buildings_vec'], axis=0)
    training_hours = res['training_hours_vec'][0]
    Ec = np.reshape(ubem.city_electricity_scaled[training_hours], (ubem.modeling_hours,))

    # RUN PARTICLE SWARM OPTIMIZER
    cost, pos = pso(all_buildings=all_buildings, betas=betas, n_particles=25, iters=3, global_pso=True)
    random_results = random_betas_new(all_buildings=all_buildings, betas=betas, iters=20)
    # check_error(pos=pos, one_mc_simulation=False, sim_num=0, sim_buildings=500)

    # # TEST PSO WITH DUMMY EXAMPLE
    # def rosenbrock_with_args(x, a, b, c=0):
    #     print('shape of x: ', x.shape)
    #     f = (a - x[:, 0]) ** 2 + b * (x[:, 1] - x[:, 0] ** 2) ** 2 + c
    #     print('shape of f: ', f.shape)
    #     return f
    # x_max = 10 * np.ones(2)
    # x_min = -1 * x_max
    # bounds = (x_min, x_max)
    # options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}
    # optimizer = GlobalBestPSO(n_particles=10, dimensions=2, options=options, bounds=bounds)
    # cost, pos = optimizer.optimize(rosenbrock_with_args, 1000, a=1, b=100, c=0)
import numpy as np
from pyswarm import pso

###############################################################################

print('*'*65)
print('Example minimization of 4th-order banana function (no constraints)')
def myfunc(x):
    x1 = x[0]
    x2 = x[1]
    return x1**4 - 2*x2*x1**2 + x2**2 + x1**2 - 2*x1 + 5

lb = [-3, -1]
ub = [2, 6]

xopt1, fopt1 = pso(myfunc, lb, ub)

print('The optimum is at:')
print('    {}'.format(xopt1))
print('Optimal function value:')
print('    myfunc: {}'.format(fopt1))

###############################################################################

print('*'*65)
print('Example minimization of 4th-order banana function (with constraint)')
def mycon(x):
    x1 = x[0]
    x2 = x[1]
    return [-(x1 + 0.25)**2 + 0.75*x2]
示例#45
0
    def pso_evaluate(self,lb,ub,args={}):
        """
        Optimization using Particle swarm optimization (PSO) algorithm.
        One function would be considered as the minimization function (with priority).
        Other cost functions, would be considered as constraints.
        All functions return mean squared distance between sample and simulated curves

        Optional inputs for pso:

        swarmsize : int
        The number of particles in the swarm (Default: 100)
        omega : scalar
        Particle velocity scaling factor (Default: 0.5)
        phip : scalar
        Scaling factor to search away from the particles best known position (Default: 0.5)
        phig : scalar
        Scaling factor to search away from the swarms best known position (Default: 0.5)
        maxiter : int
        The maximum number of iterations for the swarm to search (Default: 100)
        minstep : scalar
        The minimum stepsize of swarms best position before the search terminates (Default: 1e-8)
        minfunc : scalar
        The minimum change of swarms best objective value before the search terminates (Default: 1e-8)
        debug : boolean
        If True, progress statements will be displayed every iteration (Default: False)

        :param lb: Lower bound values
        :param ub: Upper bound values
        :param args: Optional arguments for pso function
        :return: optimized values
        """

        self.scale = False
        self.pso_flag = True
        self.func = self.vclamp_cost
        func_flag = False
        cons = list()

        # Initialize pso optional arguments
        if 'swarmsize' in args:
            swarmsize = args['swarmsize']
        else:
            swarmsize = 100
        if 'maxiter' in args:
            maxiter = args['maxiter']
        else:
            maxiter = 100
        if 'minstep' in args:
            minstep = args['minstep']
        else:
            minstep = 1e-8
        if 'minfunc' in args:
            minfunc = args['minfunc']
        else:
            minfunc = 1e-8
        if 'debug' in args:
            debug = args['debug']
        else:
            debug = False

        # Define minimum acceptable cost value for constrains
        if 'func' in args:
            self.func = args['func']
        else:
            self.func = self.vclamp_cost

        if 'IV_dist' in args:
            self.IV_dist = args['IV_dist']
        else:
            self.IV_dist = 1e-20

        if 'POV_dist' in args:
            self.POV_dist = args['POV_dist']
        else:
            self.POV_dist = 25e-4

        if 'I_dist' in args:
            self.I_dist = args['I_dist']
        else:
            self.I_dist = 1e-8

        if 'V_dist' in args:
            self.V_dist = args['V_dist']
        else:
            self.V_dist = 1e-20

        # Define minimization function and constraints
        if 'VClamp' in self.sampleData:
            self.func = self.vclamp_cost
            func_flag = True

        if 'IClamp' in self.sampleData:
            if func_flag == False:
                self.func = self.iclamp_cost
                func_flag = True
            else:
                cons.append(self.iclamp_cost)

        if 'IV' in self.sampleData:
            if func_flag == False:
                self.func = self.iv_cost
                func_flag = True
            else:
                cons.append(self.iv_cost)

        if 'POV' in self.sampleData:
            if func_flag == False:
                self.func = self.pov_cost
                func_flag = True
            else:
                cons.append(self.pov_cost)

        xopt, fopt = pso(func=self.func,
                         lb=lb,
                         ub=ub,
                         ieqcons=cons,
                         debug=debug,
                         swarmsize=swarmsize,
                         maxiter=maxiter,
                         minfunc=minfunc,
                         minstep=minstep)

        return xopt,fopt
def main():
   
    global Xmax
    global Xmin 
    filename=sys.argv[1]
    function=sys.argv[2]
    data=readfile(filename)
    row,col=data.shape
    #print max(data[row-4])
    newbigger=[]
    for rownum in xrange(row):
         newbigger.append(data[rownum][col-1])
    midnum=caculatemidnum(newbigger)
    data=data/midnum
    if row>0:
        file_result=open('./result/result_select_2.txt','w')
        file_result.write(repr('para_a').rjust(40)+repr('para_b').rjust(40)+repr('para_c').rjust(40)+repr('para_d').rjust(40)+repr('para_e').rjust(40)+repr('para_f').rjust(40)+repr('para_g').rjust(40)+repr('error').rjust(40)+'\n')
    for rownum in xrange(row):
        '''print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()'''
        args=data[rownum]
        length=len(args)
        maxPosition=getX(args,length)
        if maxPosition<30:
            Xmin=0
            Xmax=maxPosition+40-(maxPosition-Xmin)
        elif maxPosition>length-10:
            Xmax=length-1
            Xmin=maxPosition-40+(Xmax-maxPosition)
        else:
            Xmax=maxPosition+10
            Xmin=maxPosition-30
        iteration=constraint(args,Xmin,Xmax)
        print('iterations={}'.format(iteration))
        print('maxPosition={}'.format(maxPosition))
        minNum=args.min()
        maxNum=args.max()
        meanNum=args.mean()
        general=meanNum+maxNum
        radio=getArrange(args,length)/10
        radiomax=radio*maxNum
        radiomean=radio*meanNum
        lb=[-1,0,minNum,-1,0,-1,0]
        ub=[1,0.5,general+radiomean-maxNum,1.1,general+radiomax,1.1,general+radiomax]
        initialData=[0,0.01,meanNum,-1,maxNum,0.7,maxNum]
        initialData2=[0,0.03,meanNum,0.1,maxNum,-1,radiomax] 
        print("please wait a moment....")
        if function=="SSE": 
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration)
            print('Optimal function values:')
            print('SSE:{}'.format(fopt4)) 
        elif function=="RMSE":
            xopt4,fopt4=pso(RMSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration)
            print('Optimal function values:')
            print('RMSE:{}'.format(-fopt4)) 
        elif function=="RScore":
            xopt4,fopt4=pso(RScore,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration)
            print('Optimal function values:')
            print(' R-squared:{}'.format(-fopt4)) 
        elif function=="RERS":
            xopt4,fopt4=pso(RMSE_RS,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration)
            print('Optimal function values:')
            print('1/2*RMSE+1/2*R-squared:{}'.format(-fopt4)) 
        else:
            xopt4,fopt4=pso(AdjustRS,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration)
            print('Optimal function values:')
            print('ajusted R-squared:{}'.format(-fopt4)) 
        print('The optimum is at:')
        print('    {}'.format(xopt4))
        file_result.write(repr(xopt4[0]).rjust(40)+repr(xopt4[1]).rjust(40)+repr(xopt4[2]).rjust(40)+repr(xopt4[3]).rjust(40)+repr(xopt4[4]).rjust(40)+repr(xopt4[5]).rjust(40)+repr(xopt4[6]).rjust(40)+repr(fopt4).rjust(40)+'\n')
        x=np.linspace(Xmin-2,Xmax+2,10000)
        y=xopt4[0]+xopt4[1]*x+xopt4[2]/((1+np.exp(-xopt4[3]*(x-xopt4[4])))*(1+np.exp(-xopt4[5]*(x-xopt4[6]))))
        plt.figure(rownum)
        for i in xrange(Xmin,Xmax):
            plt.plot(i+1,args[i],'blue',linestyle='dashed',marker='.')
        plt.plot(x,y,'r',linewidth=2)
        plt.plot(maxPosition,args[maxPosition-1],'red',linestyle='dashed',marker='*')
        plt.xlabel("circle(Time)")
        plt.ylabel("fluorescence")
        plt.legend()
        plt.show()
    if row>0:
        file_result.close()
        print("***********************attention************************************")
        print('please go to the dir of result to save result_select_2.txt\n')
示例#47
0
from pyswarm import pso

def banana(x):
    x1 = x[0]
    x2 = x[1]
    return x1**4 - 2*x2*x1**2 + x2**2 + x1**2 - 2*x1 + 5

def con(x):
    x1 = x[0]
    x2 = x[1]
    return [-(x1 + 0.25)**2 + 0.75*x2]

lb = [-3, -1]
ub = [2, 6]

xopt, fopt = pso(banana, lb, ub, f_ieqcons=con)

print(xopt)
print(fopt)

# Optimum should be around x=[0.5, 0.76] with banana(x)=4.5 and con(x)=0
def main():

    global length
    filename = sys.argv[1]
    function = sys.argv[2]
    data = readfile(filename)
    row, col = data.shape
    newbigger = []
    for rownum in xrange(row):
        newbigger.append(data[rownum][col - 1])
    midnum = caculatemidnum(newbigger)
    data = data / midnum
    if row > 0:
        os.system("clear")
        file_result = open('./result/result_only.txt', 'w')
        file_result.write(
            repr('para_a').rjust(40) + repr('para_b').rjust(40) +
            repr('para_c').rjust(40) + repr('para_d').rjust(40) +
            repr('para_e').rjust(40) + repr('para_f').rjust(40) +
            repr('para_g').rjust(40) + repr('error').rjust(40) + '\n')
    for rownum in xrange(row):
        '''print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()'''
        args = data[rownum]
        array = data[rownum]
        length = len(args)
        iteration = constraint(args, 0, length - 1)
        print('iterations={}'.format(iteration))
        minNum = args.min()
        maxNum = args.max()
        #general=maxNum
        meanNum = args.mean()
        radio = getX(args, length)
        Xmin, Xmax = getMinMax(length, radio)
        quick_sort(array, 0, length - 1)
        initial_a = array[2]
        initial_g = array[length - 3]

        #arrange=getArrangea(args,length)
        #radiomax=radio*maxNum
        #radiomean=radio*meanNum
        lb = [minNum, 0, meanNum, -1, Xmin, -1, Xmin]
        #ub=[initial_a,0.5,initial_g,1.1,Xmax,1.1,Xmax]
        ub = [meanNum, 0.5, maxNum, 1.1, Xmax, 1.1, Xmax]
        #ub=[meanNum,0.5,maxNum,1.1,Xmax,1.1,Xmax]
        #ub=[minNum+5,0.5,general+radiomax,1.1,general+radiomax,1.1,general+radiomax]
        initialData = [
            initial_a, 0.01, initial_g - initial_a, -1, radio, 0.7, radio
        ]
        initialData2 = [
            initial_a + 1, 0.03, initial_g - initial_a + 2, 0.1, radio, -1,
            radio
        ]
        print("please wait a moment....")
        if function == "SSE":
            xopt4, fopt4 = pso(SSE,
                               lb,
                               ub,
                               args=args,
                               initialData=initialData,
                               initialData2=initialData2,
                               swarmsize=250,
                               maxiter=iteration,
                               minstep=1e-12,
                               minfunc=1e-12)
            print('Optimal function values:')
            print('SSE:{}'.format(fopt4))
        elif function == "RMSE":
            xopt4, fopt4 = pso(RMSE,
                               lb,
                               ub,
                               args=args,
                               initialData=initialData,
                               initialData2=initialData2,
                               swarmsize=250,
                               maxiter=iteration,
                               minstep=1e-12,
                               minfunc=1e-12)
            print('Optimal function values:')
            print('RMSE:{}'.format(fopt4))
        elif function == "RScore":
            xopt4, fopt4 = pso(RScore,
                               lb,
                               ub,
                               args=args,
                               initialData=initialData,
                               initialData2=initialData2,
                               swarmsize=250,
                               maxiter=iteration,
                               minstep=1e-12,
                               minfunc=1e-12)
            print('Optimal function values:')
            print(' R-squared:{}'.format(-fopt4))
        elif function == "RERS":
            xopt4, fopt4 = pso(RMSE_RS,
                               lb,
                               ub,
                               args=args,
                               initialData=initialData,
                               initialData2=initialData2,
                               swarmsize=250,
                               maxiter=iteration,
                               minstep=1e-12,
                               minfunc=1e-12)
            print('Optimal function values:')
            print('1/2*RMSE+1/2*R-squared:{}'.format(-fopt4))
        else:
            xopt4, fopt4 = pso(AdjustRS,
                               lb,
                               ub,
                               args=args,
                               initialData=initialData,
                               initialData2=initialData2,
                               swarmsize=250,
                               maxiter=iteration,
                               minstep=1e-12,
                               minfunc=1e-12)
            print('Optimal function values:')
            print('ajusted R-squared:{}'.format(-fopt4))
        file_result.write(
            repr(xopt4[0]).rjust(40) + repr(xopt4[1]).rjust(40) +
            repr(xopt4[2]).rjust(40) + repr(xopt4[3]).rjust(40) +
            repr(xopt4[4]).rjust(40) + repr(xopt4[5]).rjust(40) +
            repr(xopt4[6]).rjust(40) + repr(fopt4).rjust(40) + '\n')
        x = np.linspace(1, length, 10000)
        y = xopt4[0] + xopt4[1] * x + xopt4[2] / (
            (1 + np.exp(-xopt4[3] * (x - xopt4[4]))) *
            (1 + np.exp(-xopt4[5] * (x - xopt4[6]))))
        plt.figure(rownum)
        for i in xrange(length):
            plt.plot(i + 1, args[i], 'blue', linestyle='dashed', marker='.')
        plt.plot(x, y, 'r', linewidth=2)
        plt.xlabel("circle(Time)")
        plt.ylabel("fluorescence")
        plt.legend()
        plt.show()
        printfresult(xopt4, args, 0, length)
    if row > 0:
        file_result.close()
        print(
            "***********************attention************************************"
        )
        print('please go to dir of result to save result_only.txt file ')
def main():

    global length
    filename=sys.argv[1]
    function=sys.argv[2] 
    method=sys.argv[3]
    data=readfile(filename)
    row,col=data.shape
    #print max(data[row-4])
    newbigger=[]
    for rownum in xrange(row):
         newbigger.append(data[rownum][col-1])
    midnum=caculatemidnum(newbigger)
    data=data/midnum
    if row>0:
        os.system("clear")
        file_result_itera=open('./result/result_all_itera.txt','w')
        file_result_itera.close()
        file_result=open('./result/result_all.txt','w')
        file_result.write(repr('para_a').rjust(40)+repr('para_b').rjust(40)+repr('para_c').rjust(40)+repr('para_d').rjust(40)+repr('para_e').rjust(40)+repr('para_f').rjust(40)+repr('para_g').rjust(40)+repr('error').rjust(40)+'\n')
    for rownum in xrange(row):
        '''print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()'''
        args=data[rownum]
        array=data[rownum]
        length=len(args)
        iteration=constraint(args,0,length-1)
        print('iterations={}'.format(iteration))
        minNum=args.min()
        maxNum=args.max()
        meanNum=args.mean()
        #general=maxNum
        radio=getX(args,length)
        Xmin,Xmax=getMinMax(length,radio)
        quick_sort(array,0,length-1)
        initial_a=array[2]
        initial_g=array[length-3]
        lb=[minNum,0,meanNum,-1,Xmin,-1,Xmin]
        ub=[meanNum,0.5,maxNum,1.1,Xmax,1.1,Xmax]
        initialData=[initial_a,0.01,initial_g-initial_a,-1,radio,0.7,radio]
        initialData2=[initial_a+1,0.03,initial_g-initial_a+2,0.1,radio,-1,radio] 
        print("please wait a moment....")
        if function=="SSE": 
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('SSE:{}'.format(fopt4)) 
        elif function=="RMSE":
            xopt4,fopt4=pso(RMSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('RMSE:{}'.format(-fopt4)) 
        elif function=="RScore":
            xopt4,fopt4=pso(RScore,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print(' R-squared:{}'.format(-fopt4)) 
        elif function=="RERS":
            xopt4,fopt4=pso(RMSE_RS,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('1/2*RMSE+1/2*R-squared:{}'.format(-fopt4)) 
        else:
            xopt4,fopt4=pso(AdjustRS,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('ajusted R-squared:{}'.format(-fopt4)) 
        file_result.write(repr(xopt4[0]).rjust(40)+repr(xopt4[1]).rjust(40)+repr(xopt4[2]).rjust(40)+repr(xopt4[3]).rjust(40)+repr(xopt4[4]).rjust(40)+repr(xopt4[5]).rjust(40)+repr(xopt4[6]).rjust(40)+repr(fopt4).rjust(40)+'\n')
        print('The optimum is at:')
        print('    {}'.format(xopt4))
        print('please wait a moment again,it\'s next to minimize the function')
        fitfunction(xopt4,length,args,method=method)
    if row>0:
        file_result.close()
        print("***********************attention************************************")
        print('please go to dir of result to save result_all.txt file and result_all_itera.txt')
示例#50
0
fun = lambda x: sum([
    100 * (x[i + 1] - x[i]**2)**2 + (1 - x[i])**2 for i in range(NumVars - 1)
])
cons = [{'type': 'ineq', 'fun': lambda x: 9 - x[i]**2} for i in range(NumVars)]
x0 = tuple([0 for _ in range(NumVars)])
sol1 = minimize(fun, x0, method='COBYLA', constraints=cons)
sol2 = minimize(fun, x0, method='SLSQP', constraints=cons)
print sol1
print sol2
# solve with pso
print "PSO:"
from pyswarm import pso
lb = [-3 for i in range(NumVars)]
ub = [3 for i in range(NumVars)]
cns = [cn['fun'] for cn in cons]
print pso(fun, lb, ub, ieqcons=cns)
"""
Relaxation method:
Solution of a Semidefinite Program:
                Solver: CVXOPT
                Status: Optimal
   Initialization Time: 750.234924078 seconds
              Run Time: 8.43369 seconds
Primal Objective Value: 1.67774267808e-08
  Dual Objective Value: 1.10015692778e-08
Feasible solution for moments of order 2

scipy.optimize:
     fun: 4.4963584556077389
   maxcv: 0.0
 message: 'Maximum number of function evaluations has been exceeded.'
    con_index = []
    final_index_limit = [21, 2, 4, 4, 3, 4, 3, 5, 7, 7, 7, 3, 2, 2]
    start_index=0
    con_index = []
    for index in final_index_limit:
        temp = []
        temp.append(sum(x[start_index:start_index+index]) - 1)
        temp = temp*index
        con_index=con_index + temp
        start_index = index
    return con_index

lb = [0]*74
ub = [1]*74

xopt, fopt = pso(banana,lb, ub,f_ieqcons=con,swarmsize=740,maxiter=1000)
print("--- %s seconds ---" % (time.time() - start_time))


# In[ ]:

##Rating
fopt


# In[ ]:

print("----------------------Difference Between Ratings---------------------")
for i in range(10):
    rating = 0
    count = 0
示例#52
0
文件: PSO.py 项目: mandes95/CMOFPA
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 30 16:51:01 2015

@author: 8
"""

from pyswarm import pso
import numpy as np
from math import pi, exp, sqrt
#
def ackley(chrom):
    chrom = np.array(chrom)
    sum1 = np.sum(chrom**2)
    sum2 = np.sum(np.cos(2*pi*chrom))
    n = len(chrom)
    f = -20 * exp(-.2 * sqrt(sum1/n)) - exp(sum2/n) + 20 + exp(1)
    return f

dim = 4
x, f = pso(ackley, [-30]*dim, [30]*dim, maxiter=10000,
    minfunc=1e-15, minstep=1e-16)

print f
示例#53
0
    excel_to_csv(calibration_range_file)
    Range = csv_to_data(os.path.join(output_folder,"Range.csv"))
    lb= np.zeros(len(CB))
    ub= np.zeros(len(CB))
    for i in range(len(CB)):
        lb[i] = Range[CB[i]-1,2]
        ub[i] = Range[CB[i]-1,3]
    
    
    if RB==1:
#   Runoff
        print("Starting Runoff Callibration")
        #lb = [0.65, 0.65, 0.19, 0.77, 1.92, 0.65, 0.65];
        #ub = [1.35, 1.35, 23.08, 73.08, 96.15, 1.35, 1.35]; 

        xopt, fopt = pso(MMMF_Cal, lb, ub,args=(), kwargs={},swarmsize=2, omega=0.5, phip=0.5, phig=0.5, maxiter=4, minstep=1e-8,minfunc=1e-8, debug=False)
        #print (xopt)
        #print (fopt)
        log_file.write(xopt,fopt)
    if RB ==2:
#   Soil Loss
#    GC, VSc, DRc
#        lb = [0.65, 0.00009, 0.02];
#        ub = [1.35, 0.00035, 2];
        print("Starting soil loss Callibration")
        xopt, fopt = pso(MMMF_Cal, lb, ub,args=(), kwargs={}, swarmsize=2, omega=0.5, phip=0.5, phig=0.5, maxiter=4, minstep=1e-8, minfunc=1e-8, debug=False)
        #print (xopt)
        #print (fopt)
        log_file.write(str(xopt))
    Parameter=['MS','BD','LP', 'EHD', 'per_incp','Et/Eo','CC','GC','PH','NV','D','VSc','VSs','VSz','Kc','Kz','Ks','DRc','DRz','DRs']
示例#54
0
 def optimizer():
     return pyswarm.pso(pso_gsa_fitness, index_lower_bounds, index_upper_bounds, 
                              kwargs=kwargs, swarmsize=20)
示例#55
0
    svm.train(reader.training_attributes, reader.training_labels)

    train_rate = svm.test(reader.training_attributes, reader.training_labels)
    test_rate = svm.test(reader.testing_attributes, reader.testing_labels)

    # output summmary statistics
    print("")
    print("C, Gamma : %s" % params)
    print("Testing Data Set Performance Summary")
    print("Training Rate : {}%".format(round(train_rate * 100, 2)))
    print("Testing Rate : {}%".format(round(test_rate * 100, 2)))

    results.append([list(params), test_rate])

    log = -np.log(test_rate)
    print(log)
    return log

lb = [1, 0.000001]
ub = [200, 0.2]

xopt, fopt = pso(optimize, lb, ub, swarmsize=100, maxiter=100)

print(xopt, fopt)

with open('data/' + str(dataset_number) + '_bar/svm_optimize_results.csv', 'wb') as csvfile:
    writer = csv.writer(csvfile, delimiter=',')
    for row in results:
        writer.writerow(row)
    writer.writerow([xopt, optimize(xopt)])
示例#56
0
    # Save best
    if totalfitness < -best_fitness:
        best_fitness = -totalfitness
        best_solution = parameter_matrix
    print(best_fitness)
    print(best_solution)
    list_of_best_fitness.append(best_fitness)

    return totalfitness


lb = [3, 2, 3, 2, 3, 2, 3, 2]
ub = [23, 29, 23, 29, 23, 29, 23, 29]

for runs in range(1):
    best_solution = np.zeros(len(lb))
    best_fitness = 0
    list_of_best_fitness = []
    xopt, fopt = pso(objfnc, lb, ub, maxiter=20, swarmsize=10)
    np.savetxt('PSO_Supply2_Best.out', best_solution, delimiter=',')
    print("DONE! xopt:{} ,fopt:{}".format(xopt, fopt))

    # # Save the list of best fitness to a text file
    # print(len(list_of_best_fitness))
    # with open("list_of_bests_PSO.tsv", "a+") as write_f:
    #     for value in list_of_best_fitness:
    #         s = str(value)
    #         write_f.write(s[:s.index('.')] + "\t")
    #     write_f.write("\n")
def main():

    global length
    filename=sys.argv[1]
    function=sys.argv[2] 
    data=readfile(filename)
    row,col=data.shape
    newbigger=[]
    for rownum in xrange(row):
         newbigger.append(data[rownum][col-1])
    midnum=caculatemidnum(newbigger)
    data=data/midnum
    if row>0:
        os.system("clear")
        file_result=open('./result/result_only.txt','w')
        file_result.write(repr('para_a').rjust(40)+repr('para_b').rjust(40)+repr('para_c').rjust(40)+repr('para_d').rjust(40)+repr('para_e').rjust(40)+repr('para_f').rjust(40)+repr('para_g').rjust(40)+repr('error').rjust(40)+'\n')
    for rownum in xrange(row):
        '''print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()'''
        args=data[rownum]
        array=data[rownum]
        length=len(args)
        iteration=constraint(args,0,length-1)
        print('iterations={}'.format(iteration))
        minNum=args.min()
        maxNum=args.max()
        #general=maxNum
        meanNum=args.mean()
        radio=getX(args,length)
        Xmin,Xmax=getMinMax(length,radio)
        quick_sort(array,0,length-1)
        initial_a=array[2]
        initial_g=array[length-3]

        #arrange=getArrangea(args,length)
        #radiomax=radio*maxNum
        #radiomean=radio*meanNum
        lb=[minNum,0,meanNum,-1,Xmin,-1,Xmin]
        #ub=[initial_a,0.5,initial_g,1.1,Xmax,1.1,Xmax]
        ub=[meanNum,0.5,maxNum,1.1,Xmax,1.1,Xmax]
        #ub=[meanNum,0.5,maxNum,1.1,Xmax,1.1,Xmax]
        #ub=[minNum+5,0.5,general+radiomax,1.1,general+radiomax,1.1,general+radiomax]
        initialData=[initial_a,0.01,initial_g-initial_a,-1,radio,0.7,radio]
        initialData2=[initial_a+1,0.03,initial_g-initial_a+2,0.1,radio,-1,radio] 
        print("please wait a moment....")
        if function=="SSE": 
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('SSE:{}'.format(fopt4)) 
        elif function=="RMSE":
            xopt4,fopt4=pso(RMSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('RMSE:{}'.format(fopt4)) 
        elif function=="RScore":
            xopt4,fopt4=pso(RScore,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print(' R-squared:{}'.format(-fopt4)) 
        elif function=="RERS":
            xopt4,fopt4=pso(RMSE_RS,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('1/2*RMSE+1/2*R-squared:{}'.format(-fopt4)) 
        else:
            xopt4,fopt4=pso(AdjustRS,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('ajusted R-squared:{}'.format(-fopt4)) 
        file_result.write(repr(xopt4[0]).rjust(40)+repr(xopt4[1]).rjust(40)+repr(xopt4[2]).rjust(40)+repr(xopt4[3]).rjust(40)+repr(xopt4[4]).rjust(40)+repr(xopt4[5]).rjust(40)+repr(xopt4[6]).rjust(40)+repr(fopt4).rjust(40)+'\n')
        x=np.linspace(1,length,10000)
        y=xopt4[0]+xopt4[1]*x+xopt4[2]/((1+np.exp(-xopt4[3]*(x-xopt4[4])))*(1+np.exp(-xopt4[5]*(x-xopt4[6]))))
        plt.figure(rownum)
        for i in xrange(length):
            plt.plot(i+1,args[i],'blue',linestyle='dashed',marker='.')
        plt.plot(x,y,'r',linewidth=2)
        plt.xlabel("circle(Time)")
        plt.ylabel("fluorescence")
        plt.legend()
        plt.show()
        printfresult(xopt4,args,0,length) 
    if row>0:
        file_result.close()
        print("***********************attention************************************")
        print('please go to dir of result to save result_only.txt file ')
        action = select_action(observation, weights)
        observation, reward, done, _ = env.step(action)
        reward = -20 if done and t < 499 else reward
        cum_reward += reward
        if done:
            break
    return -cum_reward


weights_dim = 19
lb = np.full(weights_dim, -10)
ub = np.full(weights_dim, 10)
# print lb, ub
xopt, fopt = pso(func=evaluate_weights,
                 lb=lb,
                 ub=ub,
                 maxiter=10,
                 debug=True,
                 swarmsize=100)

print xopt, fopt


def test(weights):
    observation = env.reset()
    cum_reward = 0
    for t in range(5000):
        env.render()
        action = select_action(observation, weights)
        observation, reward, done, _ = env.step(action)
        reward = -20 if done and t < 499 else reward
        cum_reward += reward
def main():

    global length
    filename=sys.argv[1]
    function=sys.argv[2]
    data=readfile(filename)
    row,col=data.shape
    #print max(data[row-4])
    newbigger=[]
    for rownum in xrange(row):
         newbigger.append(data[rownum][col-1])
    midnum=caculatemidnum(newbigger)
    data=data/midnum
    if row>0:
        #file_result_itera=open('./result/result_all_itera.txt','w')
        #file_result_itera.close()
        file_result=open('./result/result_all_low.txt','w')
        file_result.write(repr('para_a').rjust(40)+repr('para_b').rjust(40)+repr('para_c').rjust(40)+repr('para_d').rjust(40)+repr('para_e').rjust(40)+repr('para_f').rjust(40)+repr('para_g').rjust(40)+repr('error').rjust(40)+'\n')
    for rownum in xrange(row):
        '''print data[rownum].min()
        print data[rownum].max()
        print data[rownum].mean()'''
        args=data[rownum]
        length=len(args)
        iteration=constraint(args,0,length-1)
        print('iterations={}'.format(iteration))
        minNum=args.min()
        maxNum=args.max()
        meanNum=args.mean()
        #general=meanNum+maxNum
        #radio=getArrange(args,length)/10
        #arrange=getArrangea(args,length)
        #radiomax=radio*maxNum
        #radiomean=radio*meanNum
        lb=[-1,0,minNum,-1,0,-1,0]
        ub=[1,0.5,2*meanNum,1.1,maxNum,1.1,maxNum]
        #ub=[1,0.5,general+radiomean-maxNum,1.1,general+radiomax,1.1,general+radiomax]
        initialData=[0,0.01,meanNum,-1,maxNum,0.7,maxNum]
        initialData2=[0,0.03,meanNum,0.1,meanNum,-1,meanNum] 
        print("please wait a moment....")
        if function=="SSE": 
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('SSE:{}'.format(fopt4)) 
        elif function=="RMSE":
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('RMSE:{}'.format(-fopt4)) 
        elif function=="RScore":
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print(' R-squared:{}'.format(-fopt4)) 
        elif function=="REandRS":
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('1/2*RMSE+1/2*R-squared:{}'.format(-fopt4)) 
        else:
            xopt4,fopt4=pso(SSE,lb,ub,args=args,initialData=initialData,initialData2=initialData2,swarmsize=250,maxiter=iteration,minstep=1e-12,minfunc=1e-12)
            print('Optimal function values:')
            print('ajusted R-squared:{}'.format(-fopt4)) 
        #fitfunction(xopt4,length,args)
        file_result.write(repr(xopt4[0]).rjust(40)+repr(xopt4[1]).rjust(40)+repr(xopt4[2]).rjust(40)+repr(xopt4[3]).rjust(40)+repr(xopt4[4]).rjust(40)+repr(xopt4[5]).rjust(40)+repr(xopt4[6]).rjust(40)+repr(fopt4).rjust(40)+'\n')
        print('The optimum is at:')
        print('    {}'.format(xopt4))
        print('please wait a moment again,it\'s next to minimize the function')
        #xopt4=minimizefunction(xopt4,length,args)
        #fitfunction(xopt4,length,args)
        print("after iteration is at:")
        print("   {}".format(xopt4))
        file_result.write(repr(xopt4[0]).rjust(40)+repr(xopt4[1]).rjust(40)+repr(xopt4[2]).rjust(40)+repr(xopt4[3]).rjust(40)+repr(xopt4[4]).rjust(40)+repr(xopt4[5]).rjust(40)+repr(xopt4[6]).rjust(40)+repr(fopt4).rjust(40)+'\n')
        fitfunction(xopt4,length,args)
        '''x=np.linspace(1,length,10000)
        y=xopt4[0]+xopt4[1]*x+xopt4[2]/((1+np.exp(-xopt4[3]*(x-xopt4[4])))*(1+np.exp(-xopt4[5]*(x-xopt4[6]))))
        plt.figure(rownum)
        for i in xrange(length):
            plt.plot(i+1,args[i],'blue',linestyle='dashed',marker='.')
        plt.plot(x,y,'r',linewidth=2)
        plt.xlabel("circle(Time)")
        plt.ylabel("fluorescence")
        plt.legend()
        plt.show()'''
    if row>0:
        file_result.close()
        print("***********************attention************************************")
        print('please go to dir of result to save result_all_high.txt file ')
示例#60
0
                #######################################################################################
                ################################## OPTIMISATION #######################################
                #######################################################################################
                if (initVmax >= 252 or initVmin <= 216):
                    print('Peak voltage of ' + str(round(initVmax, 3)) +
                          'V detected, proceeding to optimise with Volt-VAr.')

                    lb = [249, 251, 0.8]
                    ub = [250, 253, 1]

                    xopt, fopt = pso(fitnessFunction,
                                     lb,
                                     ub,
                                     f_ieqcons=constraintFunction,
                                     swarmsize=24,
                                     maxiter=25,
                                     omega=0.9,
                                     phip=0.5,
                                     phig=0.3,
                                     minfunc=0.01,
                                     debug=True)

                    optCurve = pfAuto.generateCurve2(pvSize, vNom, xopt)

                    for line in PV:
                        pfAuto.setVVcurve(optCurve, line)

                    pfAuto.runSim()
                    pfAuto.deratePV2(PV, user)

                    pfAuto.runSim()