Java tutorial
/* * RandomRBFGenerator.java * Copyright (C) 2007 University of Waikato, Hamilton, New Zealand * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ package tr.gov.ulakbim.jDenetX.streams.clustering; import tr.gov.ulakbim.jDenetX.cluster.Clustering; import tr.gov.ulakbim.jDenetX.cluster.SphereCluster; import tr.gov.ulakbim.jDenetX.core.AutoExpandVector; import tr.gov.ulakbim.jDenetX.core.InstancesHeader; import tr.gov.ulakbim.jDenetX.core.ObjectRepository; import tr.gov.ulakbim.jDenetX.gui.visualization.DataPoint; import tr.gov.ulakbim.jDenetX.options.FloatOption; import tr.gov.ulakbim.jDenetX.options.IntOption; import tr.gov.ulakbim.jDenetX.streams.InstanceStream; import tr.gov.ulakbim.jDenetX.tasks.TaskMonitor; import weka.core.*; import java.util.*; 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.", 1); public IntOption numClusterOption = new IntOption("numCluster", 'K', "The average number of centroids in the model.", 4, 1, Integer.MAX_VALUE); public IntOption numClusterRangeOption = new IntOption("numClusterRange", 'k', "Deviation of the number of centroids in the model.", 3, 1, Integer.MAX_VALUE); public FloatOption kernelRadiiOption = new FloatOption("kernelRadius", 'R', "The average radii of the centroids in the model.", 0.05, 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", 100, 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 IntOption eventFrequencyOption = new IntOption("eventFrequency", 'E', "Event frequency", 15000, 0, Integer.MAX_VALUE); public FloatOption eventMergeWeightOption = new FloatOption("eventMergeWeight", 'M', "", 0.5, 0, 1); public FloatOption eventSplitWeightOption = new FloatOption("eventSplitWeight", 'P', "Influences the probablity of SplitClusterChange events relative to the total sum of all event-weights." + "SplitClusterChange Events will split a cluster into two clusters.", 0.5, 0, 1); // public FloatOption eventSizeWeightOption = new FloatOption("eventSizeWeight", 'S', // "Influences the probablity of SizeClusterChange events relative to the total sum of all event-weights." + // "SizeClusterChange Events will increase/decrease the clusters radius.", 0.5, 0, 1); // // public FloatOption eventDensityWeightOption = new FloatOption("eventDensityWeight", 'D', // "Influences the probablity of DensityClusterChange events relative to the total sum of all event-weights." + // "DensityClusterChange Events will increase/decrease the amount of points contained by a cluster.", 0.5, 0, 1); private double merge_threshold = 0.7; private int kernelMovePointFrequency = 10; private double maxDistanceMoveThresholdByStep = 0.01; private int maxOverlapFitRuns = 50; private double eventFrequencyRange = 0.25; //double test = (2.0/5.0) + (2.0/5.0) - 0.6; private boolean debug = true; private AutoExpandVector<GeneratorCluster> kernels; protected Random instanceRandom; protected InstancesHeader streamHeader; private int numGeneratedInstances; private int numActiveKernels; private int nextEventCounter; private int nextEventChoice; private int clusterIdCounter; private GeneratorCluster mergeClusterA; private GeneratorCluster mergeClusterB; private class GeneratorCluster { //TODO: points is redundant to microclusterpoints, we need to come //up with a good strategie 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 //micro cluster 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. SphereCluster generator; int kill = -1; boolean merging = false; double[] moveVector; int totalMovementSteps; int currentMovementSteps; 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 + avgWeight * densityRangeOption.getValue() * instanceRandom.nextDouble(); generator.setWeight(weight); setDesitnation(null, 0); } 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, 0); } 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, 0); break; } } } generator.setCenter(center); } } else { if (!merging) { setDesitnation(null, 0); } } } void setDesitnation(double[] destination, int steps) { 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, steps); } void setMoveVector(double[] vector, int steps) { 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); } totalMovementSteps = (int) (length / maxDistanceMoveThresholdByStep * 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 " // +Math.sqrt(length)+" in "+totalMovementSteps+" steps"); // } } private String tryMerging(GeneratorCluster merge) { String message = ""; if (generator.overlapRadiusDegree(merge.generator) > 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; } return message; } private String splitKernel() { //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); 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 ""; } } } public RandomRBFGeneratorEvents() { } 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 = instanceRandom.nextInt(2); numActiveKernels = 0; numGeneratedInstances = 0; clusterIdCounter = 0; mergeClusterA = mergeClusterB = null; kernels = new AutoExpandVector<GeneratorCluster>(); initKernels(); } protected void generateHeader() { FastVector attributes = new FastVector(); for (int i = 0; i < this.numAttsOption.getValue(); i++) { attributes.addElement(new Attribute("att" + (i + 1))); } FastVector classLabels = new FastVector(); for (int i = 0; i < this.numClusterOption.getValue(); i++) { classLabels.addElement("class" + (i + 1)); } attributes.addElement(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(); //updateOverlaps(); } public Instance nextInstance() { numGeneratedInstances++; eventScheduler(); //make room for thge 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 = getNewSample(); } 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) { inst.setClassValue(-1); } 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 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 getClustering() { 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); 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(); } } String type = ""; String message = ""; switch (nextEventChoice) { case 0: if (nextEventCounter <= 0) { if (numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()) { type = "Split"; message = splitKernel(); message += " -> numKernels = " + numActiveKernels; } else { nextEventChoice = -1; } } break; case 1: if (numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()) { message = mergeKernels(false); type = "Merge"; if (!message.equals("")) message += " -> numKernels = " + numActiveKernels; } else { nextEventChoice = -1; } break; case 2: if (nextEventCounter <= 0) { message = changeWeight(true); type = "Increase Weight"; } break; case 3: if (nextEventCounter <= 0) { message = changeWeight(false); type = "Decrease Weight"; } break; case 4: if (nextEventCounter <= 0) { message = changeRadius(true); type = "Increase Radius"; } break; case 5: if (nextEventCounter <= 0) { message = changeRadius(false); type = "Decrease Radius"; } break; } if ((nextEventCounter <= 0 && !message.isEmpty()) || nextEventChoice == -1) { nextEventCounter = (int) (eventFrequencyOption.getValue() + (instanceRandom.nextBoolean() ? -1 : 1) * eventFrequencyOption.getValue() * eventFrequencyRange * instanceRandom.nextDouble()); nextEventChoice = instanceRandom.nextInt(2); } if (!message.isEmpty()) fireClusterChange(numGeneratedInstances, type, message); } 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; //TODO generateHeader(); does that do anything? Ref on dataset in instances? } private String mergeKernels(boolean reset) { if (numActiveKernels > 1 && ((mergeClusterA == null && mergeClusterB == null) || reset)) { // if(reset){ // System.out.println("Reset merging, wasn't possible to merge C"+mergeClusterA+" and C"+mergeClusterB); // if(mergeClusterA!=-1) // kernels.get(mergeClusterA).merging = false; // if(mergeClusterA!=-1) // kernels.get(mergeClusterB).merging = false; // mergeClusterA = mergeClusterB = -1; // // } //choose clusters to merge mergeClusterA = kernels.get(instanceRandom.nextInt(kernels.size())); while (mergeClusterA.kill != -1) mergeClusterA = kernels.get(instanceRandom.nextInt(kernels.size())); mergeClusterB = mergeClusterA; while (mergeClusterB == mergeClusterA || mergeClusterB.kill != -1) { mergeClusterB = kernels.get(instanceRandom.nextInt(kernels.size())); } boolean outofbound = true; double[] merge_point = new double[numAttsOption.getValue()]; double maxradius = Math.max(mergeClusterA.generator.getRadius(), mergeClusterB.generator.getRadius()); int counter = maxOverlapFitRuns; while (outofbound && counter > 0) { counter--; outofbound = false; for (int j = 0; j < numAttsOption.getValue(); j++) { merge_point[j] = instanceRandom.nextDouble(); if (merge_point[j] - maxradius < 0 || merge_point[j] + maxradius > 1) { outofbound = true; break; } } } if (counter <= 0) return ""; mergeClusterA.merging = true; mergeClusterB.merging = true; mergeClusterA.setDesitnation(merge_point, nextEventCounter); mergeClusterB.setDesitnation(merge_point, nextEventCounter); if (debug) System.out.println( "Try to merge cluster " + mergeClusterA.getWorkID() + " into " + mergeClusterB.getWorkID() + " at " + Arrays.toString(merge_point) + " time " + numGeneratedInstances); return ""; } 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) { // TODO Auto-generated method stub } private double[] getNewSample() { 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 ""; } }