/** * Returns the Euclidean distance. */ private double getDistance(Instance sample, Instance sample2) { double sum=0; for (int i=0; i<sample.numInputAttributes(); i++) { double diff = sample.valueInputAttribute(i)-sample2.valueInputAttribute(i); sum += diff*diff; } return Math.sqrt(sum); }
@Override public int branchForInstance(Instance inst) { int instAttIndex = this.attIndex ; // < inst.classIndex() ? this.attIndex // : this.attIndex + 1; if (inst.isMissing(instAttIndex)) { return -1; } double v = inst.valueInputAttribute(instAttIndex); // if the attIndex is not calculated above this is the correct method call if (v == this.attValue) { return this.equalsPassesTest ? 0 : 1; } return v < this.attValue ? 0 : 1; }
public double prediction(Instance inst, int classVal) { double sum = 0.0; for (int i = 0; i < inst.numAttributes() - 1; i++) { sum += weightAttribute[classVal][i] * inst.valueInputAttribute(i); } sum += weightAttribute[classVal][inst.numAttributes() - 1]; return 1.0 / (1.0 + Math.exp(-sum)); }
protected void printAnomaly(Instance inst, double anomaly) { StringBuffer sb= new StringBuffer(); for(int i=0; i<inst.numInputAttributes(); i++){ if(inst.attribute(i).isNumeric()){ double [] stats; //Attribute name sb.append("Attribute " + i +" (" + inst.attribute(i).name()+ ") - "); //Val for instance double val=inst.valueInputAttribute(i); sb.append("Value: ").append(val); stats=sufficientStatistics.get(i); double mean=stats[0]/weightSeen; double std=Utils.computeSD(stats[1], stats[0], weightSeen); double prob=probabilityFunction.getProbability(mean, Utils.computeSD(stats[1], stats[0], weightSeen), val); //Mean sb.append(" - Prob: ").append(prob); //Mean sb.append(" - Mean: ").append(mean); //SD sb.append(" - Std: ").append(std).append("\n"); } } sb.append("Score - ").append(anomaly); System.out.println(sb); }
@Override public Instance sourceInstanceToTarget(Instance sourceInstance) { double [] attValues = new double[targetInstances.numAttributes()]; Instance newInstance=new InstanceImpl(sourceInstance.weight(),attValues); for (int i=0; i<this.targetInputIndices.length; i++){ newInstance.setValue(i, sourceInstance.valueInputAttribute(targetInputIndices[i])); } for (int i=0; i<this.targetOutputIndices.length; i++){ newInstance.setValue(i, sourceInstance.valueOutputAttribute(targetOutputIndices[i])); } newInstance.setDataset(targetInstances); return newInstance; }
@Override public Instance sourceInstanceToTarget(Instance sourceInstance) { double [] attValues = new double[targetInstances.numAttributes()]; Instance newInstance=new InstanceImpl(sourceInstance.weight(),attValues); int numInputs=this.targetInstances.numInputAttributes(); for (int i=0; i<numInputs; i++){ newInstance.setValue(i, sourceInstance.valueInputAttribute(i)); } for (int i=0; i<this.targetOutputIndices.length; i++){ newInstance.setValue(numInputs+i, sourceInstance.valueOutputAttribute(targetOutputIndices[i])); } newInstance.setDataset(targetInstances); return newInstance; }
@Override public void learnFromInstance(Instance inst, HoeffdingTree ht) { //It uses different class values, not only one this.classifier.trainOnInstance(inst); MultilabelHoeffdingTree mht = ((MultilabelHoeffdingTree) ht); List<Integer> labels = mht.getRelevantLabels(inst); for (int l : labels){ this.observedClassDistribution.addToValue( l, inst.weight()); } for (int i = 0; i < inst.numInputAttributes(); i++) { int instAttIndex = i; AttributeClassObserver obs = this.attributeObservers.get(instAttIndex); //i if (obs == null) { obs = inst.inputAttribute(i).isNominal() ? mht.newNominalClassObserver() : mht.newNumericClassObserver(); this.attributeObservers.set(i, obs); } for (int l : labels){ obs.observeAttributeClass(inst.valueInputAttribute(i), l, inst.weight()); } } }
@Override public void trainOnInstanceImpl(Instance inst) { //Init Perceptron if (this.reset == true) { this.reset = false; this.numberAttributes = inst.numAttributes(); this.numberClasses = inst.numClasses(); this.weightAttribute = new double[inst.numClasses()][inst.numAttributes()]; for (int i = 0; i < inst.numClasses(); i++) { for (int j = 0; j < inst.numAttributes(); j++) { weightAttribute[i][j] = 0.2 * this.classifierRandom.nextDouble() - 0.1; } } } double[] preds = new double[inst.numClasses()]; for (int i = 0; i < inst.numClasses(); i++) { preds[i] = prediction(inst, i); } double learningRatio = learningRatioOption.getValue(); int actualClass = (int) inst.classValue(); for (int i = 0; i < inst.numClasses(); i++) { double actual = (i == actualClass) ? 1.0 : 0.0; double delta = (actual - preds[i]) * preds[i] * (1 - preds[i]); for (int j = 0; j < inst.numAttributes() - 1; j++) { this.weightAttribute[i][j] += learningRatio * delta * inst.valueInputAttribute(j); } this.weightAttribute[i][inst.numAttributes() - 1] += learningRatio * delta; } }