/** * Joins in the given spatial database to each object its k-nearest neighbors. * * @param relation Relation to process * @return result */ public Relation<KNNList> run(Relation<V> relation) { DBIDs ids = relation.getDBIDs(); WritableDataStore<KNNList> knnLists = run(relation, ids); // Wrap as relation: return new MaterializedRelation<>("k nearest neighbors", "kNNs", TypeUtil.KNNLIST, knnLists, ids); }
private Relation<NumberVector> mockRelation(final int dimension) { return new MaterializedRelation<>(VectorFieldTypeInformation.typeRequest(NumberVector.class, dimension, dimension), DBIDUtil.EMPTYDBIDS); } }
/** * Constructor * * @param ids Object IDs included * @param name The long name (for pretty printing) * @param shortname the short name (for filenames etc.) */ public ClusterOrder(String name, String shortname, ArrayModifiableDBIDs ids, WritableDoubleDataStore reachability, WritableDBIDDataStore predecessor) { super(name, shortname); this.ids = ids; this.reachability = reachability; this.predecessor = predecessor; addChildResult(new MaterializedDoubleRelation("Reachability distance", "reachdist", reachability, ids)); if(predecessor != null) { addChildResult(new MaterializedRelation<DBID>("OPTICS predecessor", "predecessor", TypeUtil.DBID, predecessor, ids)); } }
/** * Constructor * * @param ids Object IDs included * @param name The long name (for pretty printing) * @param shortname the short name (for filenames etc.) */ public ClusterOrder(String name, String shortname, ArrayModifiableDBIDs ids, WritableDoubleDataStore reachability, WritableDBIDDataStore predecessor) { super(name, shortname); this.ids = ids; this.reachability = reachability; this.predecessor = predecessor; addChildResult(new MaterializedDoubleRelation("Reachability distance", "reachdist", reachability, ids)); if(predecessor != null) { addChildResult(new MaterializedRelation<DBID>("OPTICS predecessor", "predecessor", TypeUtil.DBID, predecessor, ids)); } }
/** * Constructor * * @param ids Object IDs included * @param name The long name (for pretty printing) * @param shortname the short name (for filenames etc.) */ public ClusterOrder(String name, String shortname, ArrayModifiableDBIDs ids, WritableDoubleDataStore reachability, WritableDBIDDataStore predecessor) { super(name, shortname); this.ids = ids; this.reachability = reachability; this.predecessor = predecessor; addChildResult(new MaterializedDoubleRelation("Reachability distance", "reachdist", reachability, ids)); if(predecessor != null) { addChildResult(new MaterializedRelation<DBID>("OPTICS predecessor", "predecessor", TypeUtil.DBID, predecessor, ids)); } }
/** * Constructor * * @param ids Object IDs included * @param name The long name (for pretty printing) * @param shortname the short name (for filenames etc.) */ public ClusterOrder(DBIDs ids, String name, String shortname) { super(name, shortname); this.ids = DBIDUtil.newArray(ids.size()); reachability = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_HOT, Double.POSITIVE_INFINITY); predecessor = DataStoreUtil.makeDBIDStorage(ids, DataStoreFactory.HINT_HOT); addChildResult(new MaterializedDoubleRelation("Reachability distance", "reachdist", reachability, ids)); addChildResult(new MaterializedRelation<DBID>("OPTICS predecessor", "predecessor", TypeUtil.DBID, predecessor, ids)); }
/** * Constructor * * @param ids Object IDs included * @param name The long name (for pretty printing) * @param shortname the short name (for filenames etc.) */ public ClusterOrder(DBIDs ids, String name, String shortname) { super(name, shortname); this.ids = DBIDUtil.newArray(ids.size()); reachability = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_HOT, Double.POSITIVE_INFINITY); predecessor = DataStoreUtil.makeDBIDStorage(ids, DataStoreFactory.HINT_HOT); addChildResult(new MaterializedDoubleRelation("Reachability distance", "reachdist", reachability, ids)); addChildResult(new MaterializedRelation<DBID>("OPTICS predecessor", "predecessor", TypeUtil.DBID, predecessor, ids)); }
/** * Constructor * * @param ids Object IDs included * @param name The long name (for pretty printing) * @param shortname the short name (for filenames etc.) */ public ClusterOrder(DBIDs ids, String name, String shortname) { super(name, shortname); this.ids = DBIDUtil.newArray(ids.size()); reachability = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_HOT, Double.POSITIVE_INFINITY); predecessor = DataStoreUtil.makeDBIDStorage(ids, DataStoreFactory.HINT_HOT); addChildResult(new MaterializedDoubleRelation("Reachability distance", "reachdist", reachability, ids)); addChildResult(new MaterializedRelation<DBID>("OPTICS predecessor", "predecessor", TypeUtil.DBID, predecessor, ids)); }
/** * Preprocess the dataset, precomputing the parameterization functions. * * @param db Database * @param vrel Vector relation * @return Preprocessed relation */ private Relation<ParameterizationFunction> preprocess(Database db, Relation<V> vrel) { DBIDs ids = vrel.getDBIDs(); SimpleTypeInformation<ParameterizationFunction> type = new SimpleTypeInformation<>(ParameterizationFunction.class); WritableDataStore<ParameterizationFunction> prep = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_HOT, ParameterizationFunction.class); // Project for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { prep.put(iter, new ParameterizationFunction(vrel.get(iter))); } return new MaterializedRelation<>(type, ids, null, prep); }
public Relation<DoubleVector> run(Database database, Relation<O> relation) { AffinityMatrix neighbors = affinity.computeAffinityMatrix(relation, EARLY_EXAGGERATION); double[][] solution = randomInitialSolution(neighbors.size(), dim, random.getSingleThreadedRandom()); projectedDistances = 0L; optimizetSNE(neighbors, solution); LOG.statistics(new LongStatistic(getClass().getName() + ".projected-distances", projectedDistances)); // Remove the original (unprojected) data unless configured otherwise. removePreviousRelation(relation); DBIDs ids = relation.getDBIDs(); WritableDataStore<DoubleVector> proj = DataStoreFactory.FACTORY.makeStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_SORTED, DoubleVector.class); VectorFieldTypeInformation<DoubleVector> otype = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); for(DBIDArrayIter it = neighbors.iterDBIDs(); it.valid(); it.advance()) { proj.put(it, DoubleVector.wrap(solution[it.getOffset()])); } return new MaterializedRelation<>("tSNE", "t-SNE", otype, proj, ids); }
/** * Preprocess the dataset, precomputing the parameterization functions. * * @param db Database * @param vrel Vector relation * @return Preprocessed relation */ private Relation<ParameterizationFunction> preprocess(Database db, Relation<V> vrel) { DBIDs ids = vrel.getDBIDs(); SimpleTypeInformation<ParameterizationFunction> type = new SimpleTypeInformation<>(ParameterizationFunction.class); WritableDataStore<ParameterizationFunction> prep = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_HOT, ParameterizationFunction.class); // Project for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { prep.put(iter, new ParameterizationFunction(vrel.get(iter))); } MaterializedRelation<ParameterizationFunction> prel = new MaterializedRelation<>(type, ids, null, prep); return prel; }
/** * Run a clustering algorithm on a single instance. * * @param parent Parent result to attach to * @param ids Object IDs to process * @param store Input data * @param dim Dimensionality * @param title Title of relation * @return Clustering result */ protected C runClusteringAlgorithm(ResultHierarchy hierarchy, Result parent, DBIDs ids, DataStore<DoubleVector> store, int dim, String title) { SimpleTypeInformation<DoubleVector> t = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); Relation<DoubleVector> sample = new MaterializedRelation<>(t, ids, title, store); ProxyDatabase d = new ProxyDatabase(ids, sample); C clusterResult = inner.run(d); d.getHierarchy().remove(sample); d.getHierarchy().remove(clusterResult); hierarchy.add(parent, sample); hierarchy.add(sample, clusterResult); return clusterResult; }
/** * Run a clustering algorithm on a single instance. * * @param parent Parent result to attach to * @param ids Object IDs to process * @param store Input data * @param dim Dimensionality * @param title Title of relation * @return Clustering result */ protected Clustering<?> runClusteringAlgorithm(ResultHierarchy hierarchy, Result parent, DBIDs ids, DataStore<DoubleVector> store, int dim, String title) { SimpleTypeInformation<DoubleVector> t = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); Relation<DoubleVector> sample = new MaterializedRelation<>(t, ids, title, store); ProxyDatabase d = new ProxyDatabase(ids, sample); Clustering<?> clusterResult = samplesAlgorithm.run(d); d.getHierarchy().remove(sample); d.getHierarchy().remove(clusterResult); hierarchy.add(parent, sample); hierarchy.add(sample, clusterResult); return clusterResult; }
/** * Run a clustering algorithm on a single instance. * * @param parent Parent result to attach to * @param ids Object IDs to process * @param store Input data * @param dim Dimensionality * @param title Title of relation * @return Clustering result */ protected Clustering<?> runClusteringAlgorithm(ResultHierarchy hierarchy, Result parent, DBIDs ids, DataStore<DoubleVector> store, int dim, String title) { SimpleTypeInformation<DoubleVector> t = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); Relation<DoubleVector> sample = new MaterializedRelation<>(t, ids, title, store); ProxyDatabase d = new ProxyDatabase(ids, sample); Clustering<?> clusterResult = samplesAlgorithm.run(d); d.getHierarchy().remove(sample); d.getHierarchy().remove(clusterResult); hierarchy.add(parent, sample); hierarchy.add(sample, clusterResult); return clusterResult; }
/** * Run a clustering algorithm on a single instance. * * @param parent Parent result to attach to * @param ids Object IDs to process * @param store Input data * @param dim Dimensionality * @param title Title of relation * @return Clustering result */ protected C runClusteringAlgorithm(ResultHierarchy hierarchy, Result parent, DBIDs ids, DataStore<DoubleVector> store, int dim, String title) { SimpleTypeInformation<DoubleVector> t = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); Relation<DoubleVector> sample = new MaterializedRelation<>(t, ids, title, store); ProxyDatabase d = new ProxyDatabase(ids, sample); C clusterResult = inner.run(d); d.getHierarchy().remove(sample); d.getHierarchy().remove(clusterResult); hierarchy.add(parent, sample); hierarchy.add(sample, clusterResult); return clusterResult; }
public Relation<DoubleVector> run(Relation<O> relation) { AffinityMatrix pij = affinity.computeAffinityMatrix(relation, 1.); // Create initial solution. final int size = pij.size(); double[][] sol = randomInitialSolution(size, dim, random.getSingleThreadedRandom()); projectedDistances = 0L; optimizeSNE(pij, sol); LOG.statistics(new LongStatistic(getClass().getName() + ".projected-distances", projectedDistances)); // Remove the original (unprojected) data unless configured otherwise. removePreviousRelation(relation); // Transform into output data format. DBIDs ids = relation.getDBIDs(); WritableDataStore<DoubleVector> proj = DataStoreFactory.FACTORY.makeStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_SORTED, DoubleVector.class); VectorFieldTypeInformation<DoubleVector> otype = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); for(DBIDArrayIter it = pij.iterDBIDs(); it.valid(); it.advance()) { proj.put(it, DoubleVector.wrap(sol[it.getOffset()])); } return new MaterializedRelation<>("SNE", "SNE", otype, proj, ids); }
public Relation<DoubleVector> run(Relation<O> relation) { AffinityMatrix pij = affinity.computeAffinityMatrix(relation, EARLY_EXAGGERATION); // Create initial solution. final int size = pij.size(); double[][] sol = randomInitialSolution(size, dim, random.getSingleThreadedRandom()); projectedDistances = 0L; optimizetSNE(pij, sol); LOG.statistics(new LongStatistic(getClass().getName() + ".projected-distances", projectedDistances)); // Remove the original (unprojected) data unless configured otherwise. removePreviousRelation(relation); // Transform into output data format. DBIDs ids = relation.getDBIDs(); WritableDataStore<DoubleVector> proj = DataStoreFactory.FACTORY.makeStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_SORTED, DoubleVector.class); VectorFieldTypeInformation<DoubleVector> otype = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); for(DBIDArrayIter it = pij.iterDBIDs(); it.valid(); it.advance()) { proj.put(it, DoubleVector.wrap(sol[it.getOffset()])); } return new MaterializedRelation<>("tSNE", "t-SNE", otype, proj, ids); }
/** * Run a clustering algorithm on a single instance. * * @param parent Parent result to attach to * @param ids Object IDs to process * @param store Input data * @param dim Dimensionality * @param title Title of relation * @return Clustering result */ protected Clustering<?> runClusteringAlgorithm(ResultHierarchy hierarchy, Result parent, DBIDs ids, DataStore<DoubleVector> store, int dim, String title) { SimpleTypeInformation<DoubleVector> t = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); Relation<DoubleVector> sample = new MaterializedRelation<>(t, ids, title, store); ProxyDatabase d = new ProxyDatabase(ids, sample); Clustering<?> clusterResult = samplesAlgorithm.run(d); d.getHierarchy().remove(sample); d.getHierarchy().remove(clusterResult); hierarchy.add(parent, sample); hierarchy.add(sample, clusterResult); return clusterResult; }
/** * Builds a database for the derivator consisting of the ids in the specified * interval. * * @param relation the database storing the parameterization functions * @param ids the ids to build the database from * @return a database for the derivator consisting of the ids in the specified * interval */ private Database buildDerivatorDB(Relation<ParameterizationFunction> relation, DBIDs ids) { ProxyDatabase proxy = new ProxyDatabase(ids); int dim = dimensionality(relation); SimpleTypeInformation<DoubleVector> type = new VectorFieldTypeInformation<>(DoubleVector.FACTORY, dim); MaterializedRelation<DoubleVector> prep = new MaterializedRelation<>(type, ids); proxy.addRelation(prep); // Project for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { prep.insert(iter, DoubleVector.wrap(relation.get(iter).getColumnVector())); } return proxy; }
@Override public ProjectedIndex<O, O> instantiate(Relation<O> relation) { if(!proj.getInputDataTypeInformation().isAssignableFromType(relation.getDataTypeInformation())) { return null; } proj.initialize(relation.getDataTypeInformation()); final Relation<O> view; if(materialize) { DBIDs ids = relation.getDBIDs(); WritableDataStore<O> content = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_DB, proj.getOutputDataTypeInformation().getRestrictionClass()); for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { content.put(iter, proj.project(relation.get(iter))); } view = new MaterializedRelation<>("ECEF Projection", "ecef-projection", proj.getOutputDataTypeInformation(), content, ids); } else { view = new ProjectedView<>(relation, proj); } Index inneri = inner.instantiate(view); if(inneri == null) { return null; } return new LatLngAsECEFIndex<>(relation, proj, view, inneri, norefine); }