| package com.yahoo.labs.samoa.moa.streams.clustering; |
| |
| /* |
| * #%L |
| * SAMOA |
| * %% |
| * Copyright (C) 2010 RWTH Aachen University, Germany |
| * %% |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * #L% |
| */ |
| |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Enumeration; |
| import java.util.LinkedList; |
| import java.util.Random; |
| import java.util.Vector; |
| |
| import com.yahoo.labs.samoa.moa.cluster.Clustering; |
| import com.yahoo.labs.samoa.moa.cluster.SphereCluster; |
| import com.yahoo.labs.samoa.moa.core.AutoExpandVector; |
| import com.yahoo.labs.samoa.moa.core.InstanceExample; |
| import com.yahoo.labs.samoa.instances.InstancesHeader; |
| import com.yahoo.labs.samoa.moa.core.ObjectRepository; |
| import com.yahoo.labs.samoa.moa.core.DataPoint; |
| import com.github.javacliparser.FlagOption; |
| import com.github.javacliparser.FloatOption; |
| import com.github.javacliparser.IntOption; |
| import com.yahoo.labs.samoa.moa.streams.InstanceStream; |
| import com.yahoo.labs.samoa.moa.tasks.TaskMonitor; |
| import com.yahoo.labs.samoa.instances.Attribute; |
| import com.yahoo.labs.samoa.instances.DenseInstance; |
| import com.yahoo.labs.samoa.moa.core.FastVector; |
| import com.yahoo.labs.samoa.instances.Instance; |
| import com.yahoo.labs.samoa.instances.Instances; |
| |
| |
| public class RandomRBFGeneratorEvents extends ClusteringStream { |
| private transient Vector listeners; |
| |
| private static final long serialVersionUID = 1L; |
| |
| public IntOption modelRandomSeedOption = new IntOption("modelRandomSeed", |
| 'm', "Seed for random generation of model.", 1); |
| |
| public IntOption instanceRandomSeedOption = new IntOption( |
| "instanceRandomSeed", 'i', |
| "Seed for random generation of instances.", 5); |
| |
| public IntOption numClusterOption = new IntOption("numCluster", 'K', |
| "The average number of centroids in the model.", 5, 1, Integer.MAX_VALUE); |
| |
| public IntOption numClusterRangeOption = new IntOption("numClusterRange", 'k', |
| "Deviation of the number of centroids in the model.", 3, 0, Integer.MAX_VALUE); |
| |
| public FloatOption kernelRadiiOption = new FloatOption("kernelRadius", 'R', |
| "The average radii of the centroids in the model.", 0.07, 0, 1); |
| |
| public FloatOption kernelRadiiRangeOption = new FloatOption("kernelRadiusRange", 'r', |
| "Deviation of average radii of the centroids in the model.", 0, 0, 1); |
| |
| public FloatOption densityRangeOption = new FloatOption("densityRange", 'd', |
| "Offset of the average weight a cluster has. Value of 0 means all cluster " + |
| "contain the same amount of points.", 0, 0, 1); |
| |
| public IntOption speedOption = new IntOption("speed", 'V', |
| "Kernels move a predefined distance of 0.01 every X points", 500, 1, Integer.MAX_VALUE); |
| |
| public IntOption speedRangeOption = new IntOption("speedRange", 'v', |
| "Speed/Velocity point offset", 0, 0, Integer.MAX_VALUE); |
| |
| public FloatOption noiseLevelOption = new FloatOption("noiseLevel", 'N', |
| "Noise level", 0.1, 0, 1); |
| |
| public FlagOption noiseInClusterOption = new FlagOption("noiseInCluster", 'n', |
| "Allow noise to be placed within a cluster"); |
| |
| public IntOption eventFrequencyOption = new IntOption("eventFrequency", 'E', |
| "Event frequency. Enable at least one of the events below and set numClusterRange!", 30000, 0, Integer.MAX_VALUE); |
| |
| public FlagOption eventMergeSplitOption = new FlagOption("eventMergeSplitOption", 'M', |
| "Enable merging and splitting of clusters. Set eventFrequency and numClusterRange!"); |
| |
| public FlagOption eventDeleteCreateOption = new FlagOption("eventDeleteCreate", 'C', |
| "Enable emering and disapperaing of clusters. Set eventFrequency and numClusterRange!"); |
| |
| |
| private double merge_threshold = 0.7; |
| private int kernelMovePointFrequency = 10; |
| private double maxDistanceMoveThresholdByStep = 0.01; |
| private int maxOverlapFitRuns = 50; |
| private double eventFrequencyRange = 0; |
| |
| private boolean debug = false; |
| |
| private AutoExpandVector<GeneratorCluster> kernels; |
| protected Random instanceRandom; |
| protected InstancesHeader streamHeader; |
| private int numGeneratedInstances; |
| private int numActiveKernels; |
| private int nextEventCounter; |
| private int nextEventChoice = -1; |
| private int clusterIdCounter; |
| private GeneratorCluster mergeClusterA; |
| private GeneratorCluster mergeClusterB; |
| private boolean mergeKernelsOverlapping = false; |
| |
| |
| |
| private class GeneratorCluster implements Serializable{ |
| //TODO: points is redundant to microclusterpoints, we need to come |
| //up with a good strategy that microclusters get updated and |
| //rebuild if needed. Idea: Sort microclusterpoints by timestamp and let |
| // microclusterdecay hold the timestamp for when the last point in a |
| //microcluster gets kicked, then we rebuild... or maybe not... could be |
| //same as searching for point to be kicked. more likely is we rebuild |
| //fewer times then insert. |
| |
| private static final long serialVersionUID = -6301649898961112942L; |
| |
| SphereCluster generator; |
| int kill = -1; |
| boolean merging = false; |
| double[] moveVector; |
| int totalMovementSteps; |
| int currentMovementSteps; |
| boolean isSplitting = false; |
| |
| LinkedList<DataPoint> points = new LinkedList<DataPoint>(); |
| ArrayList<SphereCluster> microClusters = new ArrayList<SphereCluster>(); |
| ArrayList<ArrayList<DataPoint>> microClustersPoints = new ArrayList(); |
| ArrayList<Integer> microClustersDecay = new ArrayList(); |
| |
| |
| public GeneratorCluster(int label) { |
| boolean outofbounds = true; |
| int tryCounter = 0; |
| while(outofbounds && tryCounter < maxOverlapFitRuns){ |
| tryCounter++; |
| outofbounds = false; |
| double[] center = new double [numAttsOption.getValue()]; |
| double radius = kernelRadiiOption.getValue()+(instanceRandom.nextBoolean()?-1:1)*kernelRadiiRangeOption.getValue()*instanceRandom.nextDouble(); |
| while(radius <= 0){ |
| radius = kernelRadiiOption.getValue()+(instanceRandom.nextBoolean()?-1:1)*kernelRadiiRangeOption.getValue()*instanceRandom.nextDouble(); |
| } |
| for (int j = 0; j < numAttsOption.getValue(); j++) { |
| center[j] = instanceRandom.nextDouble(); |
| if(center[j]- radius < 0 || center[j] + radius > 1){ |
| outofbounds = true; |
| break; |
| } |
| } |
| generator = new SphereCluster(center, radius); |
| } |
| if(tryCounter < maxOverlapFitRuns){ |
| generator.setId(label); |
| double avgWeight = 1.0/numClusterOption.getValue(); |
| double weight = avgWeight + (instanceRandom.nextBoolean()?-1:1)*avgWeight*densityRangeOption.getValue()*instanceRandom.nextDouble(); |
| generator.setWeight(weight); |
| setDesitnation(null); |
| } |
| else{ |
| generator = null; |
| kill = 0; |
| System.out.println("Tried "+maxOverlapFitRuns+" times to create kernel. Reduce average radii." ); |
| } |
| } |
| |
| public GeneratorCluster(int label, SphereCluster cluster) { |
| this.generator = cluster; |
| cluster.setId(label); |
| setDesitnation(null); |
| } |
| |
| public int getWorkID(){ |
| for(int c = 0; c < kernels.size(); c++){ |
| if(kernels.get(c).equals(this)) |
| return c; |
| } |
| return -1; |
| } |
| |
| private void updateKernel(){ |
| if(kill == 0){ |
| kernels.remove(this); |
| } |
| if(kill > 0){ |
| kill--; |
| } |
| //we could be lot more precise if we would keep track of timestamps of points |
| //then we could remove all old points and rebuild the cluster on up to date point base |
| //BUT worse the effort??? so far we just want to avoid overlap with this, so its more |
| //konservative as needed. Only needs to change when we need a thighter representation |
| for (int m = 0; m < microClusters.size(); m++) { |
| if(numGeneratedInstances-microClustersDecay.get(m) > decayHorizonOption.getValue()){ |
| microClusters.remove(m); |
| microClustersPoints.remove(m); |
| microClustersDecay.remove(m); |
| } |
| } |
| |
| if(!points.isEmpty() && numGeneratedInstances-points.getFirst().getTimestamp() >= decayHorizonOption.getValue()){ |
| // if(debug) |
| // System.out.println("Cleaning up macro cluster "+generator.getId()); |
| points.removeFirst(); |
| } |
| |
| } |
| |
| private void addInstance(Instance instance){ |
| DataPoint point = new DataPoint(instance, numGeneratedInstances); |
| points.add(point); |
| |
| int minMicroIndex = -1; |
| double minHullDist = Double.MAX_VALUE; |
| boolean inserted = false; |
| //we favour more recently build clusters so we can remove earlier cluster sooner |
| for (int m = microClusters.size()-1; m >=0 ; m--) { |
| SphereCluster micro = microClusters.get(m); |
| double hulldist = micro.getCenterDistance(point)-micro.getRadius(); |
| //point fits into existing cluster |
| if(hulldist <= 0){ |
| microClustersPoints.get(m).add(point); |
| microClustersDecay.set(m, numGeneratedInstances); |
| inserted = true; |
| break; |
| } |
| //if not, check if its at least the closest cluster |
| else{ |
| if(hulldist < minHullDist){ |
| minMicroIndex = m; |
| minHullDist = hulldist; |
| } |
| } |
| } |
| //Reseting index choice for alternative cluster building |
| int alt = 1; |
| if(alt == 1) |
| minMicroIndex = -1; |
| if(!inserted){ |
| //add to closest cluster and expand cluster |
| if(minMicroIndex!=-1){ |
| microClustersPoints.get(minMicroIndex).add(point); |
| //we should keep the miniball instances and just check in |
| //new points instead of rebuilding the whole thing |
| SphereCluster s = new SphereCluster(microClustersPoints.get(minMicroIndex),numAttsOption.getValue()); |
| //check if current microcluster is bigger then generating cluster |
| if(s.getRadius() > generator.getRadius()){ |
| //remove previously added point |
| microClustersPoints.get(minMicroIndex).remove(microClustersPoints.get(minMicroIndex).size()-1); |
| minMicroIndex = -1; |
| } |
| else{ |
| microClusters.set(minMicroIndex, s); |
| microClustersDecay.set(minMicroIndex, numGeneratedInstances); |
| } |
| } |
| //minMicroIndex might have been reset above |
| //create new micro cluster |
| if(minMicroIndex == -1){ |
| ArrayList<DataPoint> microPoints = new ArrayList<DataPoint>(); |
| microPoints.add(point); |
| SphereCluster s; |
| if(alt == 0) |
| s = new SphereCluster(microPoints,numAttsOption.getValue()); |
| else |
| s = new SphereCluster(generator.getCenter(),generator.getRadius(),1); |
| |
| microClusters.add(s); |
| microClustersPoints.add(microPoints); |
| microClustersDecay.add(numGeneratedInstances); |
| int id = 0; |
| while(id < kernels.size()){ |
| if(kernels.get(id) == this) |
| break; |
| id++; |
| } |
| s.setGroundTruth(id); |
| } |
| } |
| |
| } |
| |
| |
| private void move(){ |
| if(currentMovementSteps < totalMovementSteps){ |
| currentMovementSteps++; |
| if( moveVector == null){ |
| return; |
| } |
| else{ |
| double[] center = generator.getCenter(); |
| boolean outofbounds = true; |
| while(outofbounds){ |
| double radius = generator.getRadius(); |
| outofbounds = false; |
| center = generator.getCenter(); |
| for ( int d = 0; d < center.length; d++ ) { |
| center[d]+= moveVector[d]; |
| if(center[d]- radius < 0 || center[d] + radius > 1){ |
| outofbounds = true; |
| setDesitnation(null); |
| break; |
| } |
| } |
| } |
| generator.setCenter(center); |
| } |
| } |
| else{ |
| if(!merging){ |
| setDesitnation(null); |
| isSplitting = false; |
| } |
| } |
| } |
| |
| void setDesitnation(double[] destination){ |
| |
| if(destination == null){ |
| destination = new double [numAttsOption.getValue()]; |
| for (int j = 0; j < numAttsOption.getValue(); j++) { |
| destination[j] = instanceRandom.nextDouble(); |
| } |
| } |
| double[] center = generator.getCenter(); |
| int dim = center.length; |
| |
| double[] v = new double[dim]; |
| |
| for ( int d = 0; d < dim; d++ ) { |
| v[d]=destination[d]-center[d]; |
| } |
| setMoveVector(v); |
| } |
| |
| void setMoveVector(double[] vector){ |
| //we are ignoring the steps, otherwise we have to change |
| //speed of the kernels, do we want that? |
| moveVector = vector; |
| int speedInPoints = speedOption.getValue(); |
| if(speedRangeOption.getValue() > 0) |
| speedInPoints +=(instanceRandom.nextBoolean()?-1:1)*instanceRandom.nextInt(speedRangeOption.getValue()); |
| if(speedInPoints < 1) speedInPoints = speedOption.getValue(); |
| |
| |
| double length = 0; |
| for ( int d = 0; d < moveVector.length; d++ ) { |
| length+=Math.pow(vector[d],2); |
| } |
| length = Math.sqrt(length); |
| |
| totalMovementSteps = (int)(length/(maxDistanceMoveThresholdByStep*kernelMovePointFrequency)*speedInPoints); |
| for ( int d = 0; d < moveVector.length; d++ ) { |
| moveVector[d]/=(double)totalMovementSteps; |
| } |
| |
| |
| currentMovementSteps = 0; |
| // if(debug){ |
| // System.out.println("Setting new direction for C"+generator.getId()+": distance " |
| // +length+" in "+totalMovementSteps+" steps"); |
| // } |
| } |
| |
| private String tryMerging(GeneratorCluster merge){ |
| String message = ""; |
| double overlapDegree = generator.overlapRadiusDegree(merge.generator); |
| if(overlapDegree > merge_threshold){ |
| SphereCluster mcluster = merge.generator; |
| double radius = Math.max(generator.getRadius(), mcluster.getRadius()); |
| generator.combine(mcluster); |
| |
| // //adjust radius, get bigger and bigger with high dim data |
| generator.setRadius(radius); |
| // double[] center = generator.getCenter(); |
| // double[] mcenter = mcluster.getCenter(); |
| // double weight = generator.getWeight(); |
| // double mweight = generator.getWeight(); |
| //// for (int i = 0; i < center.length; i++) { |
| //// center[i] = (center[i] * weight + mcenter[i] * mweight) / (mweight + weight); |
| //// } |
| // generator.setWeight(weight + mweight); |
| message = "Clusters merging: "+mergeClusterB.generator.getId()+" into "+mergeClusterA.generator.getId(); |
| |
| //clean up and restet merging stuff |
| //mark kernel so it gets killed when it doesn't contain any more instances |
| merge.kill = decayHorizonOption.getValue(); |
| //set weight to 0 so no new instances will be created in the cluster |
| mcluster.setWeight(0.0); |
| normalizeWeights(); |
| numActiveKernels--; |
| mergeClusterB = mergeClusterA = null; |
| merging = false; |
| mergeKernelsOverlapping = false; |
| } |
| else{ |
| if(overlapDegree > 0 && !mergeKernelsOverlapping){ |
| mergeKernelsOverlapping = true; |
| message = "Merge overlapping started"; |
| } |
| } |
| return message; |
| } |
| |
| private String splitKernel(){ |
| isSplitting = true; |
| //todo radius range |
| double radius = kernelRadiiOption.getValue(); |
| double avgWeight = 1.0/numClusterOption.getValue(); |
| double weight = avgWeight + avgWeight*densityRangeOption.getValue()*instanceRandom.nextDouble(); |
| SphereCluster spcluster = null; |
| |
| double[] center = generator.getCenter(); |
| spcluster = new SphereCluster(center, radius, weight); |
| |
| if(spcluster !=null){ |
| GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++, spcluster); |
| gc.isSplitting = true; |
| kernels.add(gc); |
| normalizeWeights(); |
| numActiveKernels++; |
| return "Split from Kernel "+generator.getId(); |
| } |
| else{ |
| System.out.println("Tried to split new kernel from C"+generator.getId()+ |
| ". Not enough room for new cluster, decrease average radii, number of clusters or enable overlap."); |
| return ""; |
| } |
| } |
| |
| private String fadeOut(){ |
| kill = decayHorizonOption.getValue(); |
| generator.setWeight(0.0); |
| numActiveKernels--; |
| normalizeWeights(); |
| return "Fading out C"+generator.getId(); |
| } |
| |
| |
| } |
| |
| public RandomRBFGeneratorEvents() { |
| noiseInClusterOption.set(); |
| // eventDeleteCreateOption.set(); |
| // eventMergeSplitOption.set(); |
| } |
| |
| public InstancesHeader getHeader() { |
| return streamHeader; |
| } |
| |
| public long estimatedRemainingInstances() { |
| return -1; |
| } |
| |
| public boolean hasMoreInstances() { |
| return true; |
| } |
| |
| public boolean isRestartable() { |
| return true; |
| } |
| |
| @Override |
| public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) { |
| monitor.setCurrentActivity("Preparing random RBF...", -1.0); |
| generateHeader(); |
| restart(); |
| } |
| |
| public void restart() { |
| instanceRandom = new Random(instanceRandomSeedOption.getValue()); |
| nextEventCounter = eventFrequencyOption.getValue(); |
| nextEventChoice = getNextEvent(); |
| numActiveKernels = 0; |
| numGeneratedInstances = 0; |
| clusterIdCounter = 0; |
| mergeClusterA = mergeClusterB = null; |
| kernels = new AutoExpandVector<GeneratorCluster>(); |
| |
| initKernels(); |
| } |
| |
| protected void generateHeader() { // 2013/06/02: Noise label |
| ArrayList<Attribute> attributes = new ArrayList<Attribute>(); |
| for (int i = 0; i < this.numAttsOption.getValue(); i++) { |
| attributes.add(new Attribute("att" + (i + 1))); |
| } |
| |
| ArrayList<String> classLabels = new ArrayList<String>(); |
| for (int i = 0; i < this.numClusterOption.getValue(); i++) { |
| classLabels.add("class" + (i + 1)); |
| } |
| if (noiseLevelOption.getValue() > 0) classLabels.add("noise"); // The last label = "noise" |
| |
| attributes.add(new Attribute("class", classLabels)); |
| streamHeader = new InstancesHeader(new Instances(getCLICreationString(InstanceStream.class), attributes, 0)); |
| streamHeader.setClassIndex(streamHeader.numAttributes() - 1); |
| } |
| |
| |
| protected void initKernels() { |
| for (int i = 0; i < numClusterOption.getValue(); i++) { |
| kernels.add(new GeneratorCluster(clusterIdCounter)); |
| numActiveKernels++; |
| clusterIdCounter++; |
| } |
| normalizeWeights(); |
| } |
| |
| public InstanceExample nextInstance() { |
| numGeneratedInstances++; |
| eventScheduler(); |
| |
| //make room for the classlabel |
| double[] values_new = new double [numAttsOption.getValue()]; //+1 |
| double[] values = null; |
| int clusterChoice = -1; |
| |
| if(instanceRandom.nextDouble() > noiseLevelOption.getValue()){ |
| clusterChoice = chooseWeightedElement(); |
| values = kernels.get(clusterChoice).generator.sample(instanceRandom).toDoubleArray(); |
| } |
| else{ |
| //get ranodm noise point |
| values = getNoisePoint(); |
| } |
| |
| if(Double.isNaN(values[0])){ |
| System.out.println("Instance corrupted:"+numGeneratedInstances); |
| } |
| System.arraycopy(values, 0, values_new, 0, values.length); |
| |
| Instance inst = new DenseInstance(1.0, values_new); |
| inst.setDataset(getHeader()); |
| if(clusterChoice == -1){ |
| // 2013/06/02 (Yunsu Kim) |
| // Noise instance has the last class value instead of "-1" |
| // Preventing ArrayIndexOutOfBoundsException in WriteStreamToARFFFile |
| inst.setClassValue(numClusterOption.getValue()); |
| } |
| else{ |
| inst.setClassValue(kernels.get(clusterChoice).generator.getId()); |
| //Do we need micro cluster representation if have overlapping clusters? |
| //if(!overlappingOption.isSet()) |
| kernels.get(clusterChoice).addInstance(inst); |
| } |
| // System.out.println(numGeneratedInstances+": Overlap is"+updateOverlaps()); |
| |
| return new InstanceExample(inst); |
| } |
| |
| |
| public Clustering getGeneratingClusters(){ |
| Clustering clustering = new Clustering(); |
| for (int c = 0; c < kernels.size(); c++) { |
| clustering.add(kernels.get(c).generator); |
| } |
| return clustering; |
| } |
| |
| public Clustering getMicroClustering(){ |
| Clustering clustering = new Clustering(); |
| int id = 0; |
| |
| for (int c = 0; c < kernels.size(); c++) { |
| for (int m = 0; m < kernels.get(c).microClusters.size(); m++) { |
| kernels.get(c).microClusters.get(m).setId(id); |
| kernels.get(c).microClusters.get(m).setGroundTruth(kernels.get(c).generator.getId()); |
| clustering.add(kernels.get(c).microClusters.get(m)); |
| id++; |
| } |
| } |
| |
| //System.out.println("numMicroKernels "+clustering.size()); |
| return clustering; |
| } |
| |
| /**************************** EVENTS ******************************************/ |
| private void eventScheduler(){ |
| |
| for ( int i = 0; i < kernels.size(); i++ ) { |
| kernels.get(i).updateKernel(); |
| } |
| |
| nextEventCounter--; |
| //only move kernels every 10 points, performance reasons???? |
| //should this be randomized as well??? |
| if(nextEventCounter%kernelMovePointFrequency == 0){ |
| //move kernels |
| for ( int i = 0; i < kernels.size(); i++ ) { |
| kernels.get(i).move(); |
| //overlapControl(); |
| } |
| } |
| |
| |
| if(eventFrequencyOption.getValue() == 0){ |
| return; |
| } |
| |
| String type =""; |
| String message =""; |
| boolean eventFinished = false; |
| switch(nextEventChoice){ |
| case 0: |
| if(numActiveKernels > 1 && numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()){ |
| message = mergeKernels(nextEventCounter); |
| type = "Merge"; |
| } |
| if(mergeClusterA==null && mergeClusterB==null && message.startsWith("Clusters merging")){ |
| eventFinished = true; |
| } |
| break; |
| case 1: |
| if(nextEventCounter<=0){ |
| if(numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()){ |
| type = "Split"; |
| message = splitKernel(); |
| } |
| eventFinished = true; |
| } |
| break; |
| case 2: |
| if(nextEventCounter<=0){ |
| if(numActiveKernels > 1 && numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()){ |
| message = fadeOut(); |
| type = "Delete"; |
| } |
| eventFinished = true; |
| } |
| break; |
| case 3: |
| if(nextEventCounter<=0){ |
| if(numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()){ |
| message = fadeIn(); |
| type = "Create"; |
| } |
| eventFinished = true; |
| } |
| break; |
| |
| } |
| if (eventFinished){ |
| nextEventCounter = (int)(eventFrequencyOption.getValue()+(instanceRandom.nextBoolean()?-1:1)*eventFrequencyOption.getValue()*eventFrequencyRange*instanceRandom.nextDouble()); |
| nextEventChoice = getNextEvent(); |
| //System.out.println("Next event choice: "+nextEventChoice); |
| } |
| if(!message.isEmpty()){ |
| message+=" (numKernels = "+numActiveKernels+" at "+numGeneratedInstances+")"; |
| if(!type.equals("Merge") || message.startsWith("Clusters merging")) |
| fireClusterChange(numGeneratedInstances, type, message); |
| } |
| } |
| |
| private int getNextEvent() { |
| int choice = -1; |
| boolean lowerLimit = numActiveKernels <= numClusterOption.getValue() - numClusterRangeOption.getValue(); |
| boolean upperLimit = numActiveKernels >= numClusterOption.getValue() + numClusterRangeOption.getValue(); |
| |
| if(!lowerLimit || !upperLimit){ |
| int mode = -1; |
| if(eventDeleteCreateOption.isSet() && eventMergeSplitOption.isSet()){ |
| mode = instanceRandom.nextInt(2); |
| } |
| |
| if(mode==0 || (mode==-1 && eventMergeSplitOption.isSet())){ |
| //have we reached a limit? if not free choice |
| if(!lowerLimit && !upperLimit) |
| choice = instanceRandom.nextInt(2); |
| else |
| //we have a limit. if lower limit, choose split |
| if(lowerLimit) |
| choice = 1; |
| //otherwise we reached upper level, choose merge |
| else |
| choice = 0; |
| } |
| |
| if(mode==1 || (mode==-1 && eventDeleteCreateOption.isSet())){ |
| //have we reached a limit? if not free choice |
| if(!lowerLimit && !upperLimit) |
| choice = instanceRandom.nextInt(2)+2; |
| else |
| //we have a limit. if lower limit, choose create |
| if(lowerLimit) |
| choice = 3; |
| //otherwise we reached upper level, choose delete |
| else |
| choice = 2; |
| } |
| } |
| |
| |
| return choice; |
| } |
| |
| private String fadeOut(){ |
| int id = instanceRandom.nextInt(kernels.size()); |
| while(kernels.get(id).kill!=-1) |
| id = instanceRandom.nextInt(kernels.size()); |
| |
| String message = kernels.get(id).fadeOut(); |
| return message; |
| } |
| |
| private String fadeIn(){ |
| GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++); |
| kernels.add(gc); |
| numActiveKernels++; |
| normalizeWeights(); |
| return "Creating new cluster"; |
| } |
| |
| |
| private String changeWeight(boolean increase){ |
| double changeRate = 0.1; |
| int id = instanceRandom.nextInt(kernels.size()); |
| while(kernels.get(id).kill!=-1) |
| id = instanceRandom.nextInt(kernels.size()); |
| |
| int sign = 1; |
| if(!increase) |
| sign = -1; |
| double weight_old = kernels.get(id).generator.getWeight(); |
| double delta = sign*numActiveKernels*instanceRandom.nextDouble()*changeRate; |
| kernels.get(id).generator.setWeight(weight_old+delta); |
| |
| normalizeWeights(); |
| |
| String message; |
| if(increase) |
| message = "Increase "; |
| else |
| message = "Decrease "; |
| message+=" weight on Cluster "+id+" from "+weight_old+" to "+(weight_old+delta); |
| return message; |
| |
| |
| } |
| |
| private String changeRadius(boolean increase){ |
| double maxChangeRate = 0.1; |
| int id = instanceRandom.nextInt(kernels.size()); |
| while(kernels.get(id).kill!=-1) |
| id = instanceRandom.nextInt(kernels.size()); |
| |
| int sign = 1; |
| if(!increase) |
| sign = -1; |
| |
| double r_old = kernels.get(id).generator.getRadius(); |
| double r_new =r_old+sign*r_old*instanceRandom.nextDouble()*maxChangeRate; |
| if(r_new >= 0.5) return "Radius to big"; |
| kernels.get(id).generator.setRadius(r_new); |
| |
| String message; |
| if(increase) |
| message = "Increase "; |
| else |
| message = "Decrease "; |
| message+=" radius on Cluster "+id+" from "+r_old+" to "+r_new; |
| return message; |
| } |
| |
| private String splitKernel(){ |
| int id = instanceRandom.nextInt(kernels.size()); |
| while(kernels.get(id).kill!=-1) |
| id = instanceRandom.nextInt(kernels.size()); |
| |
| String message = kernels.get(id).splitKernel(); |
| |
| return message; |
| } |
| |
| private String mergeKernels(int steps){ |
| if(numActiveKernels >1 && ((mergeClusterA == null && mergeClusterB == null))){ |
| |
| //choose clusters to merge |
| double diseredDist = steps / speedOption.getValue() * maxDistanceMoveThresholdByStep; |
| double minDist = Double.MAX_VALUE; |
| // System.out.println("DisredDist:"+(2*diseredDist)); |
| for(int i = 0; i < kernels.size(); i++){ |
| for(int j = 0; j < i; j++){ |
| if(kernels.get(i).kill!=-1 || kernels.get(j).kill!=-1){ |
| continue; |
| } |
| else{ |
| double kernelDist = kernels.get(i).generator.getCenterDistance(kernels.get(j).generator); |
| double d = kernelDist-2*diseredDist; |
| // System.out.println("Dist:"+i+" / "+j+" "+d); |
| if(Math.abs(d) < minDist && |
| (minDist != Double.MAX_VALUE || d>0 || Math.abs(d) < 0.001)){ |
| minDist = Math.abs(d); |
| mergeClusterA = kernels.get(i); |
| mergeClusterB = kernels.get(j); |
| } |
| } |
| } |
| } |
| |
| if(mergeClusterA!=null && mergeClusterB!=null){ |
| double[] merge_point = mergeClusterA.generator.getCenter(); |
| double[] v = mergeClusterA.generator.getDistanceVector(mergeClusterB.generator); |
| for (int i = 0; i < v.length; i++) { |
| merge_point[i]= merge_point[i]+v[i]*0.5; |
| } |
| |
| mergeClusterA.merging = true; |
| mergeClusterB.merging = true; |
| mergeClusterA.setDesitnation(merge_point); |
| mergeClusterB.setDesitnation(merge_point); |
| |
| if(debug){ |
| System.out.println("Center1"+Arrays.toString(mergeClusterA.generator.getCenter())); |
| System.out.println("Center2"+Arrays.toString(mergeClusterB.generator.getCenter())); |
| System.out.println("Vector"+Arrays.toString(v)); |
| |
| System.out.println("Try to merge cluster "+mergeClusterA.generator.getId()+ |
| " into "+mergeClusterB.generator.getId()+ |
| " at "+Arrays.toString(merge_point)+ |
| " time "+numGeneratedInstances); |
| } |
| return "Init merge"; |
| } |
| } |
| |
| if(mergeClusterA != null && mergeClusterB != null){ |
| |
| //movekernels will move the kernels close to each other, |
| //we just need to check and merge here if they are close enough |
| return mergeClusterA.tryMerging(mergeClusterB); |
| } |
| |
| return ""; |
| } |
| |
| |
| |
| |
| /************************* TOOLS **************************************/ |
| |
| public void getDescription(StringBuilder sb, int indent) { |
| |
| } |
| |
| private double[] getNoisePoint(){ |
| double [] sample = new double [numAttsOption.getValue()]; |
| boolean incluster = true; |
| int counter = 20; |
| while(incluster){ |
| for (int j = 0; j < numAttsOption.getValue(); j++) { |
| sample[j] = instanceRandom.nextDouble(); |
| } |
| incluster = false; |
| if(!noiseInClusterOption.isSet() && counter > 0){ |
| counter--; |
| for(int c = 0; c < kernels.size(); c++){ |
| for(int m = 0; m < kernels.get(c).microClusters.size(); m++){ |
| Instance inst = new DenseInstance(1, sample); |
| if(kernels.get(c).microClusters.get(m).getInclusionProbability(inst) > 0){ |
| incluster = true; |
| break; |
| } |
| } |
| if(incluster) |
| break; |
| } |
| } |
| } |
| |
| // double [] sample = new double [numAttsOption.getValue()]; |
| // for (int j = 0; j < numAttsOption.getValue(); j++) { |
| // sample[j] = instanceRandom.nextDouble(); |
| // } |
| |
| return sample; |
| } |
| |
| private int chooseWeightedElement() { |
| double r = instanceRandom.nextDouble(); |
| |
| // Determine index of choosen element |
| int i = 0; |
| while (r > 0.0) { |
| r -= kernels.get(i).generator.getWeight(); |
| i++; |
| } |
| --i; // Overcounted once |
| //System.out.println(i); |
| return i; |
| } |
| |
| private void normalizeWeights(){ |
| double sumWeights = 0.0; |
| for (int i = 0; i < kernels.size(); i++) { |
| sumWeights+=kernels.get(i).generator.getWeight(); |
| } |
| for (int i = 0; i < kernels.size(); i++) { |
| kernels.get(i).generator.setWeight(kernels.get(i).generator.getWeight()/sumWeights); |
| } |
| } |
| |
| |
| |
| /*************** EVENT Listener *********************/ |
| // should go into the superclass of the generator, create new one for cluster streams? |
| |
| /** Add a listener */ |
| synchronized public void addClusterChangeListener(ClusterEventListener l) { |
| if (listeners == null) |
| listeners = new Vector(); |
| listeners.addElement(l); |
| } |
| |
| /** Remove a listener */ |
| synchronized public void removeClusterChangeListener(ClusterEventListener l) { |
| if (listeners == null) |
| listeners = new Vector(); |
| listeners.removeElement(l); |
| } |
| |
| /** Fire a ClusterChangeEvent to all registered listeners */ |
| protected void fireClusterChange(long timestamp, String type, String message) { |
| // if we have no listeners, do nothing... |
| if (listeners != null && !listeners.isEmpty()) { |
| // create the event object to send |
| ClusterEvent event = |
| new ClusterEvent(this, timestamp, type , message); |
| |
| // make a copy of the listener list in case |
| // anyone adds/removes listeners |
| Vector targets; |
| synchronized (this) { |
| targets = (Vector) listeners.clone(); |
| } |
| |
| // walk through the listener list and |
| // call the sunMoved method in each |
| Enumeration e = targets.elements(); |
| while (e.hasMoreElements()) { |
| ClusterEventListener l = (ClusterEventListener) e.nextElement(); |
| l.changeCluster(event); |
| |
| } |
| } |
| } |
| |
| @Override |
| public String getPurposeString() { |
| return "Generates a random radial basis function stream."; |
| } |
| |
| |
| public String getParameterString(){ |
| return ""; |
| } |
| |
| |
| |
| |
| } |
