Exemple #1
0
def runTcheby():
    global param, approx_pareto_front, archiveOK, NO_FILE_TO_WRITE

    ############################################################################
    # PARAMETER

    # clf = SVR(C=1.0, epsilon=0.1, kernel="rbf")
    clf = NuSVR()
    clf2 = -1
    two_models_bool = False

    isReals = True
    start_fct, nb_functions = param[0:2]
    nb_iterations, neighboring_size = param[2:4]
    init_decisions, problem_size = param[4:6]
    max_decisions_maj, delta_neighbourhood = param[6:8]
    CR, search_space = param[8:10]
    F, distrib_index_n = param[10:12]
    pm, operator_fct = param[12:14]
    nb_samples, training_neighborhood_size = param[14:16]
    strategy, file_to_write = param[16:18]
    filter_strat, free_eval = param[18:20]
    param_print_every, file_to_writeR2 = param[20:22]
    filenameDIR, filenameSCORE = param[22:24]

    nb_objectives = len(start_fct)

    # get separatly offspring operator fct
    crossover_fct, mutation_fct, repair_fct = operator_fct

    best_decisions = copy.deepcopy(init_decisions)

    sampling_param = [
        crossover_fct,
        mutation_fct,
        repair_fct,
        best_decisions,
        F,
        problem_size,
        CR,
        search_space,
        distrib_index_n,
        pm,
    ]

    ############################################################################
    # INITIALISATION

    qual_tools.resetGlobalVariables(filenameDIR, filenameSCORE, nb_iterations, nb_functions)

    eval_to.resetEval()

    # get the directions weight for both starting functions
    directions = dec.getDirections(nb_functions, nb_objectives)

    # init the neighboring constant
    nt.initNeighboringTab(nb_functions, neighboring_size, directions, nb_objectives)

    # giving global visibility to the best_decisions to get the result at the end
    approx_pareto_front = best_decisions

    # initial best decisions scores
    best_decisions_scores = [eval_to.free_eval(start_fct, best_decisions[i], problem_size) for i in range(nb_functions)]

    pop_size = nb_functions

    # current optimal scores for both axes
    z_opt_scores = gt.getMinTabOf(best_decisions_scores)

    eval_to.initZstar(z_opt_scores)

    # get the first training part of the item we will learn on
    model_directions = train_to.getDirectionsTrainingMatrix(directions)

    # if the data shall be write in a file
    writeOK = False
    if file_to_write != NO_FILE_TO_WRITE:
        writeOK = True

    writeR2OK = False
    if file_to_writeR2 != NO_FILE_TO_WRITE:
        writeR2OK = True

    ############################################################################
    # MAIN ALGORITHM

    if writeOK:
        iot.printObjectives(file_to_write, eval_to.getNbEvals(), 0, best_decisions_scores, problem_size, nb_objectives)

    # IDs tab to allow a random course through the directions in the main loop
    id_directions = [i for i in range(nb_functions)]

    # iterations loop
    for itera in range(nb_iterations):
        if not free_eval:
            # Update model
            training_inputs, training_outputs, training_set_size, training_scores = train_to.getTrainingSet(
                model_directions,
                best_decisions,
                best_decisions_scores,
                eval_to.getZstar_with_decal(),
                strategy,
                nb_functions,
                training_neighborhood_size,
            )

            clf.fit(training_inputs, training_outputs)

        """
        if(writeR2OK and not free_eval):
            training_inputs_tcheby      = eval_to.getManyTcheby(training_inputs, training_scores, eval_to.getZstar_with_decal(), training_set_size)

            random_index = numpy.arange(0,training_set_size)
            numpy.random.shuffle(random_index)
            n_folds = 10
            folds_sizes = (training_set_size // n_folds) * numpy.ones(n_folds, dtype=numpy.int)
            folds_sizes[:training_set_size % n_folds] += 1

            training_inputs_array = numpy.array(training_inputs)
            training_tcheby_array = numpy.array(training_inputs_tcheby)

            R2_cv = []
            MSE_cv = []
            MAE_cv = []
            MDAE_cv = []

            clfCV = NuSVR()

            current = 0
            for fold_size in folds_sizes:
                start, stop = current, current + fold_size
                mask = numpy.ones(training_set_size, dtype=bool)
                mask[start:stop] = 0
                current = stop

                clfCV.fit(training_inputs_array[random_index[mask]], training_tcheby_array[random_index[mask]])

                test_fold_tcheby = training_tcheby_array[random_index[start:stop]]
                test_fold_predict = clfCV.predict(training_inputs_array[random_index[start:stop]])

                R2_cv  .append(r2_score             (test_fold_tcheby, test_fold_predict))
                MSE_cv .append(mean_squared_error   (test_fold_tcheby, test_fold_predict))
                MAE_cv .append(mean_absolute_error  (test_fold_tcheby, test_fold_predict))
                MDAE_cv.append(median_absolute_error(test_fold_tcheby, test_fold_predict))

            R2 = clf.score(training_inputs, training_outputs)
            MSE_cv_mean = numpy.mean(MSE_cv)
            RMSE_cv_mean = math.sqrt(MSE_cv_mean)
            MAE_cv_mean = numpy.mean(MAE_cv)
            MDAE_cv_mean = numpy.mean(MDAE_cv)
            R2_cv_mean = numpy.mean(R2_cv)

            iot.printR2(file_to_writeR2, eval_to.getNbEvals(), itera,  R2, R2_cv_mean, MSE_cv_mean , MAE_cv_mean, MDAE_cv_mean, RMSE_cv_mean, problem_size, print_every=1)

        """

        # random course through the directions
        random.shuffle(id_directions)

        # functions loop
        for f in id_directions:

            # get all the indice of neighbors of a function in a certain distance of f and include f in
            f_neighbors, current_neighbourhing_size = nt.getNeighborsOf(f, delta_neighbourhood)

            # get a list of offspring from the neighbors
            list_offspring = samp_to.extended_sampling(f, f_neighbors, sampling_param, nb_samples)

            # apply a filter on the offspring list and select the best one
            filter_param = [
                itera,
                f,
                clf,
                clf2,
                two_models_bool,
                f_neighbors,
                list_offspring,
                model_directions,
                start_fct,
                problem_size,
                eval_to.getZstar_with_decal(),
                best_decisions_scores,
                best_decisions,
                nb_objectives,
            ]
            best_candidate = filt_to.model_based_filtring(filter_strat, free_eval, filter_param)

            # evaluation of the newly made solution
            mix_scores = eval_to.eval(start_fct, best_candidate, problem_size)

            # MAJ of the z_star point
            has_changed = eval_to.min_update_Z_star(mix_scores, nb_objectives)

            # retraining of the model with the new z_star
            if has_changed and not free_eval:
                train_to.updateTrainingZstar(eval_to.getZstar_with_decal())
                training_outputs = train_to.retrainSet(
                    training_inputs, training_scores, eval_to.getZstar_with_decal(), training_set_size, nb_objectives
                )
                clf.fit(training_inputs, training_outputs)

            # boolean that is True if the offspring has been add to the archive
            added_to_S = False

            # count how many best decisions has been changed by the newly offspring
            cmpt_best_maj = 0

            # random course through the neighbors list
            random.shuffle(f_neighbors)

            # course through the neighbors list
            for j in f_neighbors:

                # stop if already max number of remplacement reach
                if cmpt_best_maj >= max_decisions_maj:
                    break

                # compute g_tcheby
                # wj = (directions[0][j],directions[1][j])
                wj = [directions[obj][j] for obj in range(0, nb_objectives)]
                g_mix = eval_to.g_tcheby(wj, mix_scores, eval_to.getZstar_with_decal())
                g_best = eval_to.g_tcheby(wj, best_decisions_scores[j], eval_to.getZstar_with_decal())

                # if the g_tcheby of the new solution is less distant from the z_optimal solution than the current best solution of the function j
                if g_mix < g_best:
                    cmpt_best_maj += 1
                    best_decisions[j] = best_candidate
                    best_decisions_scores[j] = mix_scores

                    # if we manage the archive and the solution have not been add already
                    if archiveOK and not (added_to_S):
                        arch_to.archivePut(best_candidate, mix_scores)
                        added_to_S = True
        # print("Update", itera, "done.")

        # if manage archive
        if archiveOK:
            arch_to.maintain_archive()

        # if write the result in a file
        if writeOK:
            iot.printObjectives(
                file_to_write,
                eval_to.getNbEvals(),
                itera + 1,
                best_decisions_scores,
                problem_size,
                nb_objectives,
                print_every=param_print_every,
            )
            continue

        # graphic update
        # yield arch_to.getArchiveScore(), best_decisions_scores, itera+1, eval_to.getNbEvals(), eval_to.getZstar_with_decal(), pop_size, isReals
    if not free_eval and writeR2OK:
        qual_tools.computeQualityEvaluation()
        qual_tools.generateDiffPredFreeFile()
    return
def runTcheby():
    global param, approx_pareto_front, archiveOK, NO_FILE_TO_WRITE

    ############################################################################
    # PARAMETER

    isReals = True
    start_fct, nb_functions                = param[0:2]
    nb_iterations, neighboring_size        = param[2:4]
    init_decisions, problem_size           = param[4:6]
    max_decisions_maj, delta_neighbourhood = param[6:8]
    CR, search_space                       = param[8:10]
    F, distrib_index_n                     = param[10:12]
    pm, operator_fct                       = param[12:14]
    file_to_write, param_print_every       = param[14:16]


    nb_objectives = len(start_fct)

    #get separatly offspring operator fct
    crossover_fct, mutation_fct, repair_fct = operator_fct

    best_decisions = copy.deepcopy(init_decisions)

    sampling_param = [crossover_fct, mutation_fct, repair_fct, best_decisions, F, problem_size, CR, search_space, distrib_index_n, pm]

    ############################################################################
    # INITIALISATION

    eval_to.resetEval()

    #get the directions weight for both starting functions
    directions = dec.getDirections(nb_functions, nb_objectives)

    #init the neighboring constant
    nt.initNeighboringTab(nb_functions, neighboring_size, directions, nb_objectives)

    #giving global visibility to the best_decisions to get the result at the end
    approx_pareto_front = best_decisions

    #initial best decisions scores
    best_decisions_scores = [eval_to.free_eval(start_fct, best_decisions[i], problem_size) for i in range(nb_functions)]

    pop_size = nb_functions

    #current optimal scores for both axes
    z_opt_scores = gt.getMinTabOf(best_decisions_scores)

    eval_to.initZstar(z_opt_scores)

    #if the data shall be write in a file
    writeOK = False
    if(file_to_write != NO_FILE_TO_WRITE):
        writeOK = True

    ############################################################################
    # MAIN ALGORITHM

    if(writeOK):
        iot.printObjectives(file_to_write, eval_to.getNbEvals(), 0, best_decisions_scores, problem_size, nb_objectives)

    #IDs tab to allow a random course through the directions in the main loop
    id_directions = [i for i in range(nb_functions)]

    #iterations loop
    for itera in range(nb_iterations):

        #random course through the directions
        random.shuffle(id_directions)

        #functions loop
        for f in id_directions:

            #get all the indice of neighbors of a function in a certain distance of f and include f in
            f_neighbors, current_neighbourhing_size = nt.getNeighborsOf(f, delta_neighbourhood)

            #generate a new valide offspring
            mix_ter = samp_to.sampling(f, f_neighbors, sampling_param)

            #evaluation of the newly made solution
            mix_scores = eval_to.eval(start_fct, mix_ter, problem_size)

            #MAJ of the z_star point
            has_changed = eval_to.min_update_Z_star(mix_scores, nb_objectives)

            #boolean that is True if the offspring has been add to the archive
            added_to_S = False

            #count how many best decisions has been changed by the newly offspring
            cmpt_best_maj = 0

            #random course through the neighbors list
            random.shuffle(f_neighbors)

            #course through the neighbors list
            for j in f_neighbors:

                #stop if already max number of remplacement reach
                if(cmpt_best_maj >= max_decisions_maj):
                    break

                #compute g_tcheby
                #wj = (directions[0][j],directions[1][j])
                wj = [directions[obj][j] for obj in range(0,nb_objectives)]
                g_mix = eval_to.g_tcheby(wj, mix_scores, eval_to.getZstar_with_decal())
                g_best = eval_to.g_tcheby(wj, best_decisions_scores[j], eval_to.getZstar_with_decal())
                #if the g_tcheby of the new solution is less distant from the z_optimal solution than the current best solution of the function j
                if( g_mix < g_best):
                    cmpt_best_maj += 1
                    best_decisions[j] = mix_ter
                    best_decisions_scores[j] = mix_scores
                    #if we manage the archive and the solution have not been add already
                    if(archiveOK and not(added_to_S)):
                       arch_to.archivePut(mix_ter, mix_scores)
                       added_to_S = True
        #print("Update", itera, "done.")

        #if manage archive
        if(archiveOK):
           arch_to.maintain_archive()

        #if write the result in a file
        if(writeOK):
            iot.printObjectives(file_to_write, eval_to.getNbEvals(), itera+1, best_decisions_scores, problem_size, nb_objectives, print_every=param_print_every)
            continue

        #graphic update
        #yield arch_to.getArchiveScore(), best_decisions_scores, itera, eval_to.getNbEvals(), eval_to.getZstar_with_decal(), pop_size, isReals

    return