ELKI 的 WeightedCorePredicate 實現 - 一個例子

Question

我最近嘗試通過修改 CorePredicate（例如，使用 MinPointCorePredicate 作為構建的基礎）在 ELKI 中實現加權 DBSCAN 的示例，我只是想知道是否有人可以批評這是否是正確的實現這個情況：

import de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.*;
import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansLloyd;
import de.lmu.ifi.dbs.elki.data.Cluster;
import de.lmu.ifi.dbs.elki.data.Clustering;
import de.lmu.ifi.dbs.elki.data.NumberVector;
import de.lmu.ifi.dbs.elki.data.model.KMeansModel;
import de.lmu.ifi.dbs.elki.data.type.TypeUtil;
import de.lmu.ifi.dbs.elki.database.Database;
import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase;
import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore;
import de.lmu.ifi.dbs.elki.database.ids.DBID;
import de.lmu.ifi.dbs.elki.database.ids.DBIDIter;
import de.lmu.ifi.dbs.elki.database.ids.DBIDRange;
import de.lmu.ifi.dbs.elki.database.relation.Relation;
import de.lmu.ifi.dbs.elki.datasource.ArrayAdapterDatabaseConnection;
import de.lmu.ifi.dbs.elki.datasource.DatabaseConnection;
import de.lmu.ifi.dbs.elki.logging.Logging;
import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration;
import de.lmu.ifi.dbs.elki.datasource.DatabaseConnection;
import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction;
import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans;
//import de.lmu.ifi.dbs.elki.math.random.RandomFactory;
import de.lmu.ifi.dbs.elki.data.model.Model;
import de.lmu.ifi.dbs.elki.algorithm.clustering.DBSCAN;
import de.lmu.ifi.dbs.elki.data.Clustering;
import de.lmu.ifi.dbs.elki.data.model.Model;
import de.lmu.ifi.dbs.elki.database.Database;
import de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.RadialBasisFunctionKernelFunction;
import de.lmu.ifi.dbs.elki.data.Clustering;
import de.lmu.ifi.dbs.elki.algorithm.AbstractAlgorithm;
import de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.EpsilonNeighborPredicate;
import de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.MinPtsCorePredicate;
import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore;
import de.lmu.ifi.dbs.elki.database.datastore.WritableDoubleDataStore;

// Imports for generalized dbscan
import de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.CorePredicate;
import de.lmu.ifi.dbs.elki.data.model.Model;
import de.lmu.ifi.dbs.elki.utilities.ELKIServiceLoader;



public class SampleELKI2 {

    public static void main(String[] args) {

        double[][] data = new double[1000][3]; // The third column refers to the weights
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                data[i][j] = Math.random();
                //System.out.println(i + " and " + j + " and " + data[i][j]);
            }
            //System.out.println(i + " and " + data[i][0] + " " + data[i][1] + " " + data[i][2]);
        }

        // Adapter to load data from an existing array
        DatabaseConnection dbc = new ArrayAdapterDatabaseConnection(data);
        //  Create a database (which may contain multiple relations
        Database db = new StaticArrayDatabase(dbc, null);
        // Load the data into the database (do NOT forget to initialize)
        db.initialize();
        // Relation containing the number vectors
        Relation<NumberVector> rel = db.getRelation(TypeUtil.NUMBER_VECTOR_FIELD);
        // We know that the ids must be a continuous range
        DBIDRange ids = (DBIDRange) rel.getDBIDs();
        SquaredEuclideanDistanceFunction dist = SquaredEuclideanDistanceFunction.STATIC;
        // Default initialization, using global random:
        // To fix the random seed, use: new RandomFactory(seed);
        // Compute the neighbourhood and core predicates here for generalized gdbscan
        // --------------------------------------------------------------------- //
        EpsilonNeighborPredicate ENP = new EpsilonNeighborPredicate(0.3, dist); // Generic Neighbourhoodpredicate
        WeightedCorePredicate WCP = new WeightedCorePredicate(330, db, 2); // WeightedCorePredicate with the db  (db) and column index variable containing the weights (2)
        // The Implementation of the predicates in the GDBSCAN - predicates can be replaced for conditionals
        Clustering<Model> result = new GeneralizedDBSCAN(ENP, WCP, false).run(db);
        int i = 0;

        for (Cluster<Model> clu : result.getAllClusters()) {
            for (DBIDIter it = clu.getIDs().iter(); it.valid(); it.advance()) {
                NumberVector v = rel.get(it);
                final int offset = ids.getOffset(it);
            }
            ++i;
        }
    }
}

新的 WeightedCorePredicate 看起來像這樣，來自對 ELKI 源文件中的 MinPtCorePredicate class 的輕微修改。

public class WeightedCorePredicate implements CorePredicate<DBIDs> {

   /**
   * Class logger.
   */
  public static final Logging LOG = Logging.getLogger(MinPtsCorePredicate.class);

  /**
   * The minpts parameter.
   */
  protected int minpts;
  static Database db;
  static int WeightColumn;
  static int WeightSum;
    /**
   * Default constructor.
   *
   * @param minpts Minimum number of neighbors to be a core point.
   */
  public WeightedCorePredicate(int minpts, Database db, int WeightColumn) {
    super();
    this.minpts = minpts;
    this.db = db;
    this.WeightColumn = WeightColumn;
  }

  @Override
  public Instance instantiate(Database database) {
      return new Instance(minpts, db, WeightColumn);
  }

  @Override
  public boolean acceptsType(SimpleTypeInformation<? extends DBIDs> type) {
    return TypeUtil.DBIDS.isAssignableFromType(type) //
        || TypeUtil.NEIGHBORLIST.isAssignableFromType(type);
  }

  /**
   * Instance for a particular data set.
   *
   * @author Erich Schubert
   */
  public static class Instance implements CorePredicate.Instance<DBIDs> {
    /**
     * The minpts parameter.
     */
    protected int minpts;
    protected Database db;
    protected int WeightColumn;
    protected double WeightSum;
    /**
     * Constructor for this predicate.
     *
     * @param minpts MinPts parameter
     */
    public Instance(int minpts, Database db, int WeightColumn) {
      super();
      this.minpts = minpts;
      this.db = db;
      this.WeightColumn = WeightColumn;
    }

    @Override
    public boolean isCorePoint(DBIDRef point, DBIDs neighbors) {
    db.initialize(); // Initialize database 
    Relation<NumberVector> rel = db.getRelation(TypeUtil.NUMBER_VECTOR_FIELD); // db relation to get to the datapoints 
    WeightSum = 0; // Make sure to initialize the weights as 0 
    // DBIDS contain the indices of the points - so just need a database relation to access the points at the index 

    for (DBIDIter it = neighbors.iter(); it.valid(); it.advance()) {
        //    System.out.print("The weights are " + rel.get(it).doubleValue(WeightColumn) + "\n");
        WeightSum += rel.get(it).doubleValue(WeightColumn); // Sum the weights 
    }

    return WeightSum >= minpts;
    }
  }
    
  /**
   * Parameterization class
   *
   * @author Erich Schubert
   */
  public static class Parameterizer extends AbstractParameterizer {
    /**
     * Minpts value
     */
    protected int minpts;

    @Override
    protected void makeOptions(Parameterization config) {
      super.makeOptions(config);
      // Get the minpts parameter
      IntParameter minptsP = new IntParameter(DBSCAN.Parameterizer.MINPTS_ID) //
          .addConstraint(CommonConstraints.GREATER_EQUAL_ONE_INT);
      if(config.grab(minptsP)) {
        minpts = minptsP.intValue();
        if(minpts <= 2) {
          LOG.warning("DBSCAN with minPts <= 2 is equivalent to single-link clustering at a single height. Consider using larger values of minPts.");
        }
      }
    }

    @Override
    protected WeightedCorePredicate makeInstance() {
    return new WeightedCorePredicate(minpts, db, WeightColumn);
    }
  }
}

本質上，我在 WeightedCorePredicate 中添加了輸入，它引用了數據庫，我可以使用索引從 rel 中挑選出 db 的元素，並使用 this.WeightColumn 挑選出權重與 X 一起列出的列/Y 列。 這源於此處指出的討論： Elki GDBSCAN Java/Scala - 如何修改DBSCAN 的 ELKI 實現中的 CorePredicate 和 sample_weight 選項。

對此的任何反饋將不勝感激。 我不是來自 Java 背景，主要來自 Python/Scala，所以我完全明白它不是最優雅的 Java 代碼。

謝謝

Answer 1

不要將static變量用於應該是本地或實例變量的東西！

在 99.99% 的情況下，他們的做法是錯誤的。

C.f.， 為什么 static 變量被認為是邪惡的？