Originalseite

https://github.com/jMetal/jMetalDocumentation/blob/master/solution.md Ich übersetze das nur grob. Der Text unten.

Solution interface Bei der Verwendung von Meta-Huristiken müssen wir zunächst definieren, wie die Lösung des zu lösenden Problems ausgedrückt und codiert werden soll. Der Ausdruck der Lösung hängt stark vom Problem ab, und die anwendbaren Operationen (z. B. Rekombination mit anderen Lösungen, lokales Suchverfahren usw.) werden durch den Ausdruck bestimmt. Daher hat die Wahl der Lösungsausdrucksmethode einen großen Einfluss auf das Verhalten der Metaheristik und damit auf die Qualität der erhaltenen Ergebnisse.

Die folgende Abbildung zeigt die Grundklassen, die zur Darstellung einer Lösung in jMetal 5 verwendet werden.

jMetal_Solution_Class

Diese Abbildung enthält drei Lösungsausdrücke: Binär, Doppel und Ganzzahl. Dieser Ansatz bietet viele Implementierungen für dieselbe Codierung und bietet eine größere Flexibilität. Durch die Verwendung von Generika können bei Kompilierungsfehlern auch falsche Variablenwertzuweisungen gefunden werden. Wenn Sie beispielsweise versuchen, einer int-Variablen den Wert "DoubleSolution" zuzuweisen, tritt ein Fehler auf.

Der Code für die Solution-Schnittstelle lautet wie folgt.

package org.uma.jmetal.solution;

public interface Solution<T> extends Serializable {
  public void setObjective(int index, double value) ;
  public double getObjective(int index) ;

  public T getVariableValue(int index) ;
  public void setVariableValue(int index, T value) ;
  public String getVariableValueString(int index) ;

  public int getNumberOfVariables() ;
  public int getNumberOfObjectives() ;

  public Solution<T> copy() ;

  public void setAttribute(Object id, Object value) ;
  public Object getAttribute(Object id) ;
}

Solution verfügt über eine Methode für den Zugriff auf Variablen und Zielfunktionen, eine Kopiermethode und eine Methode für den Zugriff auf Attribute.

Defining encodings Eine bestimmte Codierung wird durch die Implementierung oder Erweiterung der "Solution" -Schnittstelle definiert. Die Schnittstelle für eine Lösung mit einer Liste von Double- und Integer-Variablen ist wie folgt definiert:

package org.uma.jmetal.solution;

public interface DoubleSolution extends Solution<Double> {
  public Double getLowerBound(int index) ;
  public Double getUpperBound(int index) ;
}

package org.uma.jmetal.solution;

public interface IntegerSolution extends Solution<Integer> {
  public Integer getLowerBound(int index) ;
  public Integer getUpperBound(int index) ;
}

Diese Schnittstellen bieten Methoden zum Abrufen der unteren und oberen Grenzen der Variablen Double und Intefer. Die Methode zum Festlegen dieser Werte bleibt der Implementierungsklasse überlassen.

Im Fall von "BinarySolution" ist es wie folgt.

import org.uma.jmetal.util.binarySet.BinarySet;

public interface BinarySolution extends Solution<BinarySet> {
  public int getNumberOfBits(int index) ;
  public int getTotalNumberOfBits() ;
}

Es wird angenommen, dass es sich um eine Liste von Binärvariablen handelt.

Ermöglicht das Definieren von Codierungen mit gemischten Variablen. Die folgende Schnittstelle definiert beispielsweise eine Lösung, die aus einer Liste von Doppel- und Ganzzahlwerten besteht.

package org.uma.jmetal.solution;

public interface IntegerDoubleSolution extends Solution<Number> {
  public Number getLowerBound(int index) ;
  public Number getUpperBound(int index) ;
  public int getNumberOfIntegerVariables() ;
  public int getNumberOfDoubleVariables() ;
}

Implementing solutions Wir haben Schnittstellen für verschiedene Lösungen definiert. Im Folgenden finden Sie Standardimplementierungen für alle. Beginnen wir mit einer abstrakten Klasse namens "AbstractGenericSolution".

package org.uma.jmetal.solution.impl;

public abstract class AbstractGenericSolution<T, P extends Problem<?>> implements Solution<T> {
  private double[] objectives;
  private List<T> variables;
  protected P problem ;
  protected double overallConstraintViolationDegree ;
  protected int numberOfViolatedConstraints ;
  protected Map<Object, Object> attributes ;
  protected final JMetalRandom randomGenerator ;

AbstractGenericSolution enthält alle Methoden von Solution. Diese Klasse ist eine Oberklasse aller "Solution" -Implementierungen von jMetal5. (DefaultBinarySolution, DefaultIntegerSolution, DefaultDoubleSolution, DefaultIntegerDoubleSolution, DefaultIntegerPermutationSolution, DefaultDoubleBinarySolution .)

Where are the populations? Es gibt keine Klasse, die die Population in jMetal5 ausdrückt. Stattdessen wird "List <Lösung>" als Grundgesamtheit verwendet.

Beispiel:

/* A population of double solutions */
List<DoubleSolution> doublePopulation ;

/* The same population using the generic interface */
List<Solution<Double>> doublePopulation ;

/* A population of binary solutions */
List<BinarySolucion> binaryPopulation ;

Die Dienstprogrammklasse SolutionListUtils bietet eine Reihe von Operationen für List <Lösung>. (Zum Beispiel das Finden der besten / schlechtesten Person, zufällige Auswahl einer Lösung usw.)

Solution attributes Durch Einbeziehen von Attributen können Sie der Lösung bestimmte Felder hinzufügen, die von einigen Algorithmen benötigt werden. In SPEA2 wird beispielsweise der Lösung dieselbe Anpassungsfähigkeit zugewiesen, in NSGA-II ist es jedoch erforderlich, die Lösung zu ordnen und den Wert der Überlastungsentfernung zuzuweisen.

Attribute können direkt bearbeitet werden, es werden jedoch auch die folgenden Schnittstellen definiert.

package org.uma.jmetal.util.solutionattribute;
/**
 * Attributes allows to extend the {@link Solution} classes to incorporate data required by
 * operators or algorithms manipulating them.
 *
 * @author Antonio J. Nebro <[email protected]>
 */
public interface SolutionAttribute <S extends Solution<?>, V> {
  public void setAttribute(S solution, V value) ;
  public V getAttribute(S solution) ;
  public Object getAttributeID() ;
}

Die Standardimplementierung lautet wie folgt.

package org.uma.jmetal.util.solutionattribute.impl;

public class GenericSolutionAttribute <S extends Solution<?>, V> implements SolutionAttribute<S, V>{

  @SuppressWarnings("unchecked")
  @Override
  public V getAttribute(S solution) {
    return (V)solution.getAttribute(getAttributeID());
  }

  @Override
  public void setAttribute(S solution, V value) {
     solution.setAttribute(getAttributeID(), value);
  }

  @Override
  public Object getAttributeID() {
    return this.getClass() ;
  }
}

Beachten Sie, dass in dieser Implementierung getAttributedID () die Klassenkennung zurückgibt. Dies bedeutet, dass die Lösung kein anderes Attribut derselben Klasse haben kann.

Example of attrivute: constraints

Optimierungsprobleme können eingeschränkt werden. Dies bedeutet, dass zur Bewertung der Lösung nicht nur die Zielfunktion, sondern auch die Einschränkungen für die Anwendung eines Einschränkungsverarbeitungsmechanismus bewertet werden müssen. SoluttionAttribute wird verwendet, um Einschränkungsinformationen in Solution zu integrieren.

Der Standardmechanismus für die Behandlung von Einschränkungen von jMetal ist in NSGA-II definiert. Da es sich um "OverallConstraintViolation" handelt, werden die folgenden Klassen vorbereitet.

package org.uma.jmetal.util.solutionattribute.impl;
public class OverallConstraintViolation<S extends Solution<?>> extends GenericSolutionAttribute<S, Double> {
}

Dies ist eine leere Klasse, die GenericSolutionAttribute erweitert, um fortlaufende Werte anzugeben. Normalerweise wird die Einschränkung in der Klasse "Solultion" wie folgt ausgewertet.

package org.uma.jmetal.problem.multiobjective;

/** Class representing problem Binh2 */
public class Binh2 extends AbstractDoubleProblem implements ConstrainedProblem<DoubleSolution> {
  public OverallConstraintViolation<DoubleSolution> overallConstraintViolationDegree ;
  public NumberOfViolatedConstraints<DoubleSolution> numberOfViolatedConstraints ;
  /**
   * Constructor
   * Creates a default instance of the Binh2 problem
   */
  public Binh2() {
    ...
    overallConstraintViolationDegree = new OverallConstraintViolation<DoubleSolution>() ;
    numberOfViolatedConstraints = new NumberOfViolatedConstraints<DoubleSolution>() ;
  }

  /** Evaluate() method */
  @Override
  public void evaluate(DoubleSolution solution) {
     ...
  }

  /** EvaluateConstraints() method */
  @Override
  public void evaluateConstraints(DoubleSolution solution)  {
    double[] constraint = new double[this.getNumberOfConstraints()];

    double x0 = solution.getVariableValue(0) ;
    double x1 = solution.getVariableValue(1) ;

    constraint[0] = -1.0 * (x0 - 5) * (x0 - 5) - x1 * x1 + 25.0;
    constraint[1] = (x0 - 8) * (x0 - 8) + (x1 + 3) * (x1 + 3) - 7.7;

    double overallConstraintViolation = 0.0;
    int violatedConstraints = 0;
    for (int i = 0; i < this.getNumberOfConstraints(); i++) {
      if (constraint[i] < 0.0) {
        overallConstraintViolation += constraint[i];
        violatedConstraints++;
      }
    }

    overallConstraintViolationDegree.setAttribute(solution, overallConstraintViolation);
    numberOfViolatedConstraints.setAttribute(solution, violatedConstraints);
  }

Dieser Code enthält auch ein weiteres Attribut namens "NumberOfViolatedConstraints", mit dem die Anzahl der Einschränkungen festgelegt wird, gegen die die angegebene Lösung verstößt.

(Soweit dieser Code zu sehen ist, scheint der Einschränkungswert so implementiert zu sein, dass er die Einschränkung erfüllt, wenn er positiv ist, und die Einschränkung verletzt, wenn er negativ ist.)

Example of attribute: ranking

Es kann mit SolutionAttribute gekapselt werden. Als Beispiel wird eine Schnittstelle definiert, die den folgenden Lösungen Ränge (NSGA-II-Ranking) zuweist.

package org.uma.jmetal.util.solutionattribute;

import java.util.List;

/**
 * Ranks a list of solutions according to the dominance relationship
 *
 * @author Antonio J. Nebro <[email protected]>
 */
public interface Ranking<S extends Solution<?>> extends SolutionAttribute<S, Integer>{
  public Ranking<S> computeRanking(List<S> solutionList) ;
  public List<S> getSubfront(int rank) ;
  public int getNumberOfSubfronts() ;
}

Daher kann die Client-Klasse (zum Beispiel die NSGA-II-Klasse) einfach wie folgt verwendet werden.

Ranking ranking = computeRanking(jointPopulation);

Auf diese Weise werden die Attribute der Lösung intern von der Klasse verwaltet, die "Ranking" implementiert und vor dem Algorithmus verborgen ist.

[JAVA] jMetal Erläuterung --Lösungsschnittstelle

Originalseite