예제 #1
0
  /**
   * This public static method runs the algorithm that this class concerns with.
   *
   * @param args Array of strings to sent parameters to the main program. The path of the
   *     algorithm's parameters file must be given.
   */
  public static void main(String args[]) {

    boolean tty = false;
    ProcessConfig pc = new ProcessConfig();
    System.out.println("Reading configuration file: " + args[0]);
    if (pc.fileProcess(args[0]) < 0) return;
    int algo = pc.parAlgorithmType;
    rand = new Randomize();
    rand.setSeed(pc.parSeed);
    ModelFuzzyPittsBurgh pi = new ModelFuzzyPittsBurgh();
    pi.fuzzyPittsburghModelling(tty, pc);
  }
예제 #2
0
  /**
   *
   *
   * <pre>
   * This private static method extract the dataset and the method's parameters
   * from the KEEL environment, carries out with the partitioning of the
   * input and output spaces, learn the FRBS regression model --which is a
   * {@link PittsburghClassifier} instance-- using the   GP algorithm --which is an instance
   * of the GeneticAlgorithm class-- and prints out the results with the validation
   * dataset.
   *
   * If the parameter Steady is not fixed then the genetic algorithm used is the
   * {@link GeneticAlgorithmGenerational}. If that parameter is fixed then the GP
   * used is the {@link GeneticAlgorithmSteady}.
   * </pre>
   *
   * @param tty unused boolean parameter, kept for compatibility
   * @param pc ProcessConfig object to obtain the train and test datasets and the method's
   *     parameters.
   */
  private static void fuzzyPittsburghModelling(boolean tty, ProcessConfig pc) {

    try {

      String readALine = new String();
      int lOption = 0;

      int defaultNumberInputPartitions = 0;
      int numberOfCrossovers = 0;

      ProcessDataset pd = new ProcessDataset();

      readALine = (String) pc.parInputData.get(ProcessConfig.IndexTrain);

      if (pc.parNewFormat) pd.processModelDataset(readALine, true);
      else pd.oldClassificationProcess(readALine);

      int nData = pd.getNdata(); // Number of examples
      int nVariables = pd.getNvariables(); // Number of variables
      int nInputs = pd.getNinputs(); // Number of inputs

      double[][] X = pd.getX(); // Input data
      double[] Y = pd.getY(); // Output data
      double[] Yt = new double[Y.length];
      pd.showDatasetStatistics();

      double[] inputMaximum = pd.getImaximum(); // Maximum and Minimum for input data
      double[] inputMinimum = pd.getIminimum();

      double outputMaximum = pd.getOmaximum(); // Maximum and Minimum for output data
      double outputMinimum = pd.getOminimum();

      int[] nInputPartitions = new int[nInputs]; // Linguistic partition terms
      int nOutputPartitions;

      // Partitions definition
      // Check the number of rules
      int nrules = 1;
      FuzzyPartition[] inputPartitions = new FuzzyPartition[nInputs];
      for (int i = 0; i < nInputs; i++) {
        nInputPartitions[i] = pc.parPartitionLabelNum;
        inputPartitions[i] =
            new FuzzyPartition(inputMinimum[i], inputMaximum[i], nInputPartitions[i]);
        nrules *= nInputPartitions[i];
        if (nrules > MAXFUZZYRULES) break;
      }
      nOutputPartitions = pc.parPartitionLabelNum;
      FuzzyPartition outputPartitions =
          new FuzzyPartition(outputMinimum, outputMaximum, nOutputPartitions);
      System.out.println("Number of rules = " + nrules);

      if (nrules < MAXFUZZYRULES) {
        int lPopulation = pc.parPopSize;
        int localnPopulations = pc.parIslandNumber;

        boolean STEADY = pc.parSteady;

        int defuzzificationType = RuleBase.DEFUZCDM;

        // Rule base
        FuzzyModel sistema =
            new FuzzyModel(
                inputPartitions,
                outputPartitions,
                RuleBase.product,
                RuleBase.sum,
                defuzzificationType);

        // Genetic Algorithm Optimization
        PittsburghModel p = new PittsburghModel(sistema, pc.parFitnessType, rand);

        p.setExamples(X, Y);

        int nIterations = pc.parIterNumber;

        GeneticAlgorithm AG;
        int crossoverID = OperatorIdent.GENERICROSSOVER;
        int mutationID = OperatorIdent.GENERICMUTATION;

        int lTournament = 4;
        double mutacion = 0.05;
        double lmutationAmpl = 0.1;
        double migrationProb = 0.001;
        double localOptProb = 0.0;
        int localOptIterations = 0;
        lTournament = pc.parTourSize;
        mutacion = pc.parMutProb;
        lmutationAmpl = pc.parMutAmpl;
        migrationProb = pc.parMigProb;
        localOptProb = pc.parLoProb;
        localOptIterations = pc.parLoIterNumber;

        if (STEADY)
          AG =
              new GeneticAlgorithmSteady(
                  p,
                  lPopulation,
                  localnPopulations,
                  lTournament,
                  mutacion,
                  lmutationAmpl,
                  migrationProb,
                  localOptProb,
                  localOptIterations,
                  OperatorIdent.AMEBA,
                  rand,
                  crossoverID,
                  mutationID);
        else
          AG =
              new GeneticAlgorithmGenerational(
                  p,
                  lPopulation,
                  localnPopulations,
                  mutacion,
                  lmutationAmpl,
                  migrationProb,
                  localOptProb,
                  localOptIterations,
                  OperatorIdent.AMEBA,
                  rand,
                  crossoverID,
                  mutationID);

        p = (PittsburghModel) AG.evolve(nIterations);

        // Result is printed
        p.debug();
        pc.trainingResults(Y, p.getYo());
        System.out.println("RMS Train = " + p.fitness());

        ProcessDataset pdt = new ProcessDataset();
        int nTest, nTestInputs, nTestVariables;
        readALine = (String) pc.parInputData.get(ProcessConfig.IndexTest);

        if (pc.parNewFormat) pdt.processModelDataset(readALine, false);
        else pdt.oldClassificationProcess(readALine);

        nTest = pdt.getNdata();
        nTestVariables = pdt.getNvariables();
        nTestInputs = pdt.getNinputs();
        pdt.showDatasetStatistics();

        if (nTestInputs != nInputs) throw new IOException("IOERR Test file");

        double[][] Xp = pdt.getX();
        double[] Yp = pdt.getY();

        p.setExamples(Xp, Yp);
        System.out.println("RMS test = " + p.fitness());
        pc.results(Yp, p.getYo());

      } else {

        pc.trainingResults(Y, Yt);

        ProcessDataset pdt = new ProcessDataset();
        int nTest, nTestInputs, nTestVariables;
        readALine = (String) pc.parInputData.get(ProcessConfig.IndexTest);

        if (pc.parNewFormat) pdt.processModelDataset(readALine, false);
        else pdt.oldClassificationProcess(readALine);

        nTest = pdt.getNdata();
        nTestVariables = pdt.getNvariables();
        nTestInputs = pdt.getNinputs();
        pdt.showDatasetStatistics();

        if (nTestInputs != nInputs) throw new IOException("IOERR test file");

        double[][] Xp = pdt.getX();
        double[] Yp = pdt.getY();

        double[] Yo = new double[Yp.length];
        System.out.println("Generating constant output (0)");

        // Yo = 0

        pc.results(Yp, Yo);
      }

    } catch (FileNotFoundException e) {
      System.err.println(e + " Input file not found");
    } catch (IOException e) {
      System.err.println(e + " Read Error");
    } catch (invalidFitness e) {
      System.err.println(e);
    } catch (invalidCrossover e) {
      System.err.println(e);
    } catch (invalidMutation e) {
      System.err.println(e);
    } catch (invalidOptim e) {
      System.err.println(e);
    }
  }