| package org.apache.samoa.moa.classifiers.core.attributeclassobservers; |
| |
| /* |
| * #%L |
| * SAMOA |
| * %% |
| * Copyright (C) 2014 - 2015 Apache Software Foundation |
| * %% |
| * 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.List; |
| |
| import org.apache.samoa.moa.classifiers.core.AttributeSplitSuggestion; |
| import org.apache.samoa.moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest; |
| import org.apache.samoa.moa.classifiers.core.splitcriteria.SplitCriterion; |
| import org.apache.samoa.moa.core.DoubleVector; |
| import org.apache.samoa.moa.core.ObjectRepository; |
| import org.apache.samoa.moa.core.Utils; |
| import org.apache.samoa.moa.options.AbstractOptionHandler; |
| import org.apache.samoa.moa.tasks.TaskMonitor; |
| |
| import com.github.javacliparser.IntOption; |
| |
| /** |
| * Class for observing the class data distribution for a numeric attribute as in VFML. Used in naive Bayes and decision |
| * trees to monitor data statistics on leaves. |
| * |
| * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz) |
| * @version $Revision: 7 $ |
| */ |
| public class VFMLNumericAttributeClassObserver extends AbstractOptionHandler implements NumericAttributeClassObserver { |
| |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void observeAttributeTarget(double attVal, double target) { |
| throw new UnsupportedOperationException("Not supported yet."); |
| } |
| |
| protected class Bin implements Serializable { |
| |
| private static final long serialVersionUID = 1L; |
| |
| public double lowerBound, upperBound; |
| |
| public DoubleVector classWeights = new DoubleVector(); |
| |
| public int boundaryClass; |
| |
| public double boundaryWeight; |
| } |
| |
| protected List<Bin> binList = new ArrayList<>(); |
| |
| public IntOption numBinsOption = new IntOption("numBins", 'n', |
| "The number of bins.", 10, 1, Integer.MAX_VALUE); |
| |
| @Override |
| public void observeAttributeClass(double attVal, int classVal, double weight) { |
| if (!Utils.isMissingValue(attVal)) { |
| if (this.binList.size() < 1) { |
| // create the first bin |
| Bin newBin = new Bin(); |
| newBin.classWeights.addToValue(classVal, weight); |
| newBin.boundaryClass = classVal; |
| newBin.boundaryWeight = weight; |
| newBin.upperBound = attVal; |
| newBin.lowerBound = attVal; |
| this.binList.add(newBin); |
| } else { |
| // find bin containing new example with binary search |
| int index = 0; |
| boolean found = false; |
| int min = 0; |
| int max = this.binList.size() - 1; |
| while ((min <= max) && !found) { |
| int i = (min + max) / 2; |
| Bin bin = this.binList.get(i); |
| if (((attVal >= bin.lowerBound) && (attVal < bin.upperBound)) |
| || ((i == this.binList.size() - 1) |
| && (attVal >= bin.lowerBound) && (attVal <= bin.upperBound))) { |
| found = true; |
| index = i; |
| } else if (attVal < bin.lowerBound) { |
| max = i - 1; |
| } else { |
| min = i + 1; |
| } |
| } |
| boolean first = false; |
| boolean last = false; |
| if (!found) { |
| // determine if it is before or after the existing range |
| Bin bin = this.binList.get(0); |
| if (bin.lowerBound > attVal) { |
| // go before the first bin |
| index = 0; |
| first = true; |
| } else { |
| // if we haven't found it yet value must be > last bins |
| // upperBound |
| index = this.binList.size() - 1; |
| last = true; |
| } |
| } |
| Bin bin = this.binList.get(index); // VLIndex(ct->bins, index); |
| if ((bin.lowerBound == attVal) |
| || (this.binList.size() >= this.numBinsOption.getValue())) {// Option.getValue()) |
| // {//1000) |
| // { |
| // if this is the exact same boundary and class as the bin |
| // boundary or we aren't adding new bins any more then |
| // increment |
| // boundary counts |
| bin.classWeights.addToValue(classVal, weight); |
| if ((bin.boundaryClass == classVal) |
| && (bin.lowerBound == attVal)) { |
| // if it is also the same class then special case it |
| bin.boundaryWeight += weight; |
| } |
| } else { |
| // create a new bin |
| Bin newBin = new Bin(); |
| newBin.classWeights.addToValue(classVal, weight); |
| newBin.boundaryWeight = weight; |
| newBin.boundaryClass = classVal; |
| newBin.upperBound = bin.upperBound; |
| newBin.lowerBound = attVal; |
| |
| double percent = 0.0; |
| // estimate initial counts with a linear interpolation |
| if (!((bin.upperBound - bin.lowerBound == 0) || last || first)) { |
| percent = 1.0 - ((attVal - bin.lowerBound) / (bin.upperBound - bin.lowerBound)); |
| } |
| |
| // take out the boundry points, they stay with the old bin |
| bin.classWeights.addToValue(bin.boundaryClass, |
| -bin.boundaryWeight); |
| DoubleVector weightToShift = new DoubleVector( |
| bin.classWeights); |
| weightToShift.scaleValues(percent); |
| newBin.classWeights.addValues(weightToShift); |
| bin.classWeights.subtractValues(weightToShift); |
| // put the boundry examples back in |
| bin.classWeights.addToValue(bin.boundaryClass, |
| bin.boundaryWeight); |
| |
| // insert the new bin in the right place |
| if (last) { |
| bin.upperBound = attVal; |
| newBin.upperBound = attVal; |
| this.binList.add(newBin); |
| } else if (first) { |
| newBin.upperBound = bin.lowerBound; |
| this.binList.add(0, newBin); |
| } else { |
| newBin.upperBound = bin.upperBound; |
| bin.upperBound = attVal; |
| this.binList.add(index + 1, newBin); |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| public double probabilityOfAttributeValueGivenClass(double attVal, |
| int classVal) { |
| // TODO: NaiveBayes broken until implemented |
| return 0.0; |
| } |
| |
| @Override |
| public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion( |
| SplitCriterion criterion, double[] preSplitDist, int attIndex, |
| boolean binaryOnly) { |
| AttributeSplitSuggestion bestSuggestion = null; |
| DoubleVector rightDist = new DoubleVector(); |
| for (Bin bin : this.binList) { |
| rightDist.addValues(bin.classWeights); |
| } |
| DoubleVector leftDist = new DoubleVector(); |
| for (Bin bin : this.binList) { |
| leftDist.addValues(bin.classWeights); |
| rightDist.subtractValues(bin.classWeights); |
| double[][] postSplitDists = new double[][] { |
| leftDist.getArrayCopy(), rightDist.getArrayCopy() }; |
| double merit = criterion.getMeritOfSplit(preSplitDist, |
| postSplitDists); |
| if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) { |
| bestSuggestion = new AttributeSplitSuggestion( |
| new NumericAttributeBinaryTest(attIndex, |
| bin.upperBound, false), postSplitDists, merit); |
| } |
| } |
| return bestSuggestion; |
| } |
| |
| @Override |
| public void getDescription(StringBuilder sb, int indent) { |
| // TODO Auto-generated method stub |
| } |
| |
| @Override |
| protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) { |
| // TODO Auto-generated method stub |
| } |
| } |
