net.sourceforge.cilib.tuning.FRaceIterationStrategy Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cilib-library Show documentation
A library of composable components enabling simpler Computational Intelligence
There is a newer version: 0.8
/**           __  __
 *    _____ _/ /_/ /_    Computational Intelligence Library (CIlib)
 *   / ___/ / / / __ \   (c) CIRG @ UP
 *  / /__/ / / / /_/ /   http://cilib.net
 *  \___/_/_/_/_.___/
 */
package net.sourceforge.cilib.tuning;

import static fj.Function.flip;
import fj.*;
import fj.data.List;
import static fj.data.List.*;
import static fj.data.List.iterableList;
import static fj.function.Doubles.add;
import static fj.Ord.*;
import net.sourceforge.cilib.algorithm.population.AbstractIterationStrategy;
import net.sourceforge.cilib.controlparameter.ConstantControlParameter;
import net.sourceforge.cilib.controlparameter.ControlParameter;
import net.sourceforge.cilib.math.Stats;
import net.sourceforge.cilib.math.StatsTests;
import net.sourceforge.cilib.problem.solution.OptimisationSolution;
import net.sourceforge.cilib.type.types.container.Vector;
import static net.sourceforge.cilib.util.functions.Fitnesses.getValue;
import static net.sourceforge.cilib.util.functions.Solutions.getFitness;
import net.sourceforge.cilib.util.functions.Utils;
import static net.sourceforge.cilib.util.functions.Utils.*;

public class FRaceIterationStrategy extends AbstractIterationStrategy {
    
    private List> results;
    private ControlParameter minProblems;
    private ControlParameter minSolutions;
    
    public FRaceIterationStrategy() {
        this.minProblems = ConstantControlParameter.of(4.0);
        this.minSolutions = ConstantControlParameter.of(2.0);
        this.results = List.>nil();
    }
    
    public FRaceIterationStrategy(FRaceIterationStrategy copy) {
        this.minProblems = copy.minProblems.getClone();
        this.minSolutions = copy.minSolutions.getClone();
        this.results = iterableList(copy.results);
    }

    @Override
    public FRaceIterationStrategy getClone() {
        return new FRaceIterationStrategy(this);
    }

    @Override
    public void performIteration(final TuningAlgorithm alg) {
        final List parameterList = alg.getParameterList();
        
        //TODO: deal with maximisation problems
        results = results.snoc(parameterList.map(new F() {
            @Override
            public OptimisationSolution f(Vector a) {
                return new OptimisationSolution(a, alg.evaluate(a));
            }
        }));
        
        // (+1 because iterations start at 0)
        if (alg.getIterations() + 1 >= minProblems.getParameter() && parameterList.length() > 1) {
            List> data = results
                .map(List.map_().f(getFitness().andThen(getValue())));
            P2 friedman = StatsTests.friedman(0.05, data);

            if (friedman._1() > friedman._2()) {
                final List indexes = StatsTests.postHoc(0.05, friedman._1(), data);
                
                if (indexes.isNotEmpty() && indexes.length() >= minSolutions.getParameter()) {
                    alg.setParameterList(indexes.map(flip(Utils.index()).f(parameterList)));

                    results = results.map(new F,List>() {
                        @Override
                        public List f(final List a) {
                            return indexes.map(flip(Utils.index()).f(a));
                        }
                    });
                } else {
                    final List> ranks = iterableList(data)
                        .map(Stats.rank.andThen(Utils.iterableList()));
                    final List newIndexes = ranks.foldLeft(Utils.pairwise(add), replicate(data.head().length(), 0.0))
                        .zipIndex()
                        .sort(p2Ord(doubleOrd, intOrd))
                        .take((int)minSolutions.getParameter())
                        .map(P2.__2());
                    
                    alg.setParameterList(newIndexes.map(flip(Utils.index()).f(parameterList)));
                    
                    results = results.map(new F,List>() {
                        @Override
                        public List f(final List a) {
                            return newIndexes.map(flip(Utils.index()).f(a));
                        }
                    });
                }   
            }
        }
    }

    public void setMinProblems(ControlParameter r) {
        this.minProblems = r;
    }

    public ControlParameter getMinProblems() {
        return minProblems;
    }
    
    public void setMinSolutions(ControlParameter r) {
        this.minSolutions = r;
    }

    public ControlParameter getMinSolutions() {
        return minSolutions;
    }
    
    public void resetResults() {
        results = List.nil();
    }
}