public int getValuesOfNominalAttributes(int attIndex, Instance instance) { return instance.attribute(attIndex).numValues(); }
protected ArrayList<Integer> nominalAttUsed(Instance instance) { SplitNode currentNode = (SplitNode) this.parent; ArrayList<Integer> nomAttUsed = new ArrayList<Integer>(); while (currentNode != null) { if (instance.attribute(currentNode.splitTest.getAttsTestDependsOn()[0]).isNominal()) { nomAttUsed.add(currentNode.splitTest.getAttsTestDependsOn()[0]); } currentNode = (SplitNode) currentNode.parent; } return nomAttUsed; }
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); }
for (int i = 0; i < instance.numAttributes(); i++) { if (instance.classIndex() != i && instance.attribute(i).isNominal()) { if ((!sort.isEmpty()) && (i == sort.first())) { sort.remove(new Integer(sort.first())); && instance.attribute(i).isNumeric()) { virtualChildren.set(i, new AdaptiveNumericVirtualNode((Iadem3) tree, this,
int instAttIndex = modelAttIndexToInstanceAttIndex(z, instance); ArrayList<Double> attribBest = new ArrayList<Double>(); if(instance.attribute(instAttIndex).isNominal()){ this.minEntropyNominalAttrib=Double.MAX_VALUE; AutoExpandVector<DoubleVector> attribNominal = ((NominalAttributeClassObserver)observersParameter.get(z)).attValDistPerClass; findBestValEntropyNominalAtt(attribNominal, instance.attribute(z).numValues()); // The best value (lowest entropy) of a nominal attribute. attribBest.add(this.saveBestEntropyNominalAttrib.getValue(0)); attribBest.add(this.saveBestEntropyNominalAttrib.getValue(1));
protected void createVirtualNodes(IademNumericAttributeObserver numericObserver, boolean onlyMultiwayTest, boolean onlyBinaryTest, Instance instance) { for (int i = 0; i < instance.numAttributes(); i++) { if (instance.classIndex() != i && instance.attribute(i).isNominal()) { this.virtualChildren.set(i, new NominalVirtualNode(this.tree, this, i, onlyMultiwayTest, onlyBinaryTest)); } else if (instance.classIndex() != i && instance.attribute(i).isNumeric()) { this.virtualChildren.set(i, new NumericVirtualNode(this.tree, this, i, numericObserver)); } else { // class attribute this.virtualChildren.set(i, null); } } }
public double updateWeights(Instance inst, double learningRatio ){ // Normalize Instance double[] normalizedInstance = normalizedInstance(inst); // Compute the Normalized Prediction of Perceptron double normalizedPredict= prediction(normalizedInstance); double normalizedY = normalizeActualClassValue(inst); double sumWeights = 0.0; double delta = normalizedY - normalizedPredict; for (int j = 0; j < inst.numAttributes() - 1; j++) { int instAttIndex = modelAttIndexToInstanceAttIndex(j); if(inst.attribute(instAttIndex).isNumeric()) { this.weightAttribute[j] += learningRatio * delta * normalizedInstance[j]; sumWeights += Math.abs(this.weightAttribute[j]); } } this.weightAttribute[inst.numAttributes() - 1] += learningRatio * delta; sumWeights += Math.abs(this.weightAttribute[inst.numAttributes() - 1]); if (sumWeights > inst.numAttributes()) { // Lasso regression for (int j = 0; j < inst.numAttributes() - 1; j++) { int instAttIndex = modelAttIndexToInstanceAttIndex(j); if(inst.attribute(instAttIndex).isNumeric()) { this.weightAttribute[j] = this.weightAttribute[j] / sumWeights; } } this.weightAttribute[inst.numAttributes() - 1] = this.weightAttribute[inst.numAttributes() - 1] / sumWeights; } return denormalizedPrediction(normalizedPredict); }
public double updateWeights(Instance inst, double learningRatio ){ // Normalize Instance double[] normalizedInstance = normalizedInstance(inst); // Compute the Normalized Prediction of Perceptron double normalizedPredict= prediction(normalizedInstance); double normalizedY = normalizeActualClassValue(inst); double sumWeights = 0.0; double delta = normalizedY - normalizedPredict; for (int j = 0; j < inst.numAttributes() - 1; j++) { int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst); if(inst.attribute(instAttIndex).isNumeric()) { this.weightAttribute[j] += learningRatio * delta * normalizedInstance[j]; sumWeights += Math.abs(this.weightAttribute[j]); } } this.weightAttribute[inst.numAttributes() - 1] += learningRatio * delta; sumWeights += Math.abs(this.weightAttribute[inst.numAttributes() - 1]); if (sumWeights > inst.numAttributes()) { // Lasso regression for (int j = 0; j < inst.numAttributes() - 1; j++) { int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst); if(inst.attribute(instAttIndex).isNumeric()) { this.weightAttribute[j] = this.weightAttribute[j] / sumWeights; } } this.weightAttribute[inst.numAttributes() - 1] = this.weightAttribute[inst.numAttributes() - 1] / sumWeights; } return denormalizedPrediction(normalizedPredict); }
public static double[] doNaiveBayesPredictionLog(Instance inst, DoubleVector observedClassDistribution, AutoExpandVector<AttributeClassObserver> observers, AutoExpandVector<AttributeClassObserver> observers2) { AttributeClassObserver obs; double[] votes = new double[observedClassDistribution.numValues()]; double observedClassSum = observedClassDistribution.sumOfValues(); for (int classIndex = 0; classIndex < votes.length; classIndex++) { votes[classIndex] = Math.log10(observedClassDistribution.getValue(classIndex) / observedClassSum); for (int attIndex = 0; attIndex < inst.numAttributes() - 1; attIndex++) { int instAttIndex = modelAttIndexToInstanceAttIndex(attIndex, inst); if (inst.attribute(instAttIndex).isNominal()) { obs = observers.get(attIndex); } else { obs = observers2.get(attIndex); } if ((obs != null) && !inst.isMissing(instAttIndex)) { votes[classIndex] += Math.log10(obs.probabilityOfAttributeValueGivenClass(inst.value(instAttIndex), classIndex)); } } } return votes; }
@Override public void learnFromInstance(Instance inst, HoeffdingOptionTree ht) { this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight()); for (int i = 0; i < inst.numAttributes() - 1; i++) { int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst); AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null) { obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver(); this.attributeObservers.set(i, obs); } obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight()); } }
@Override public void trainOnInstanceImpl(Instance inst) { this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight()); for (int i = 0; i < inst.numAttributes() - 1; i++) { int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst); AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null) { obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver() : newNumericClassObserver(); this.attributeObservers.set(i, obs); } obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight()); } }
@Override public void learnFromInstance(Instance inst, HoeffdingTree ht) { this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight()); if (this.listAttributes == null) { setlistAttributes(((LimAttHoeffdingTree) ht).listAttributes); } for (int j = 0; j < this.numAttributes; j++) { int i = this.listAttributes[j]; int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst); AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null) { obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver(); this.attributeObservers.set(i, obs); } obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight()); } } }
public DoubleVector normalizedInstance(Instance inst) { // Normalize Instance DoubleVector normalizedInstance = new DoubleVector(); for (int j = 0; j < inst.numAttributes() - 1; j++) { int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst); double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen; double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen); if (inst.attribute(instAttIndex).isNumeric() && tree.examplesSeen > 1 && sd > 0) normalizedInstance.setValue(j, (inst.value(instAttIndex) - mean) / (3 * sd)); else normalizedInstance.setValue(j, 0); } if (tree.examplesSeen > 1) normalizedInstance.setValue(inst.numAttributes() - 1, 1.0); // Value to be multiplied with the constant factor else normalizedInstance.setValue(inst.numAttributes() - 1, 0.0); return normalizedInstance; }
if (obs == null) { if (inst.attribute(instAttIndex).isNumeric()) { obs = tree.newNumericClassObserver(); this.attributeObservers.set(i, obs);
@Override public void learnFromInstance(Instance inst, HoeffdingTree ht) { if (this.isInitialized == false) { this.attributeObservers = new AutoExpandVector<AttributeClassObserver>(inst.numAttributes()); this.isInitialized = true; } this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight()); for (int i = 0; i < inst.numAttributes() - 1; i++) { int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst); AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null) { obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver(); this.attributeObservers.set(i, obs); } obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight()); } }
@Override public void trainOnInstanceImpl(Instance inst) { this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight()); for (int i = 0; i < inst.numAttributes() - 1; i++) { int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst); AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null) { obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver() : newNumericClassObserver(); this.attributeObservers.set(i, obs); } obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight()); } if (this.trainingWeightSeenByModel - this.weightSeenAtLastSplit >= this.gracePeriodOption.getValue()) { this.bestSplit = findBestSplit((SplitCriterion) getPreparedClassOption(this.splitCriterionOption)); this.weightSeenAtLastSplit = this.trainingWeightSeenByModel; } }
if (obs == null) { if (inst.attribute(instAttIndex).isNumeric()) //instAttIndex
if (obs == null) { if (inst.attribute(instAttIndex).isNumeric()) //instAttIndex