/** * Returns an enumeration of all the attribute's values if the * attribute is nominal, null otherwise. * * @return enumeration of all the attribute's values */ public final /*@ pure @*/ Enumeration enumerateValues() { if (this.isNominal()) { return Collections.enumeration(this.attributeValues); } return null; } }
/** * * @param value * @return */ public final int indexOfValue(String value) { if (isNominal() == false) { return -1; } if (this.valuesStringAttribute == null) { this.valuesStringAttribute = new HashMap<String, Integer>(); int count = 0; for (String stringValue : attributeValues) { this.valuesStringAttribute.put(stringValue, count); count++; } } Integer val = (Integer) this.valuesStringAttribute.get(value); if (val == null) { return -1; } else { return val.intValue(); } }
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; }
/** * Text representation of a InstanceImpl. */ @Override public String toString() { StringBuilder str = new StringBuilder(); for (int attIndex = 0; attIndex < this.numAttributes(); attIndex++) { if (!this.isMissing(attIndex)) { if (this.attribute(attIndex).isNominal()) { int valueIndex = (int) this.value(attIndex); String stringValue = this.attribute(attIndex).value(valueIndex); str.append(stringValue).append(","); } else if (this.attribute(attIndex).isNumeric()) { str.append(this.value(attIndex)).append(","); } else if (this.attribute(attIndex).isDate()) { SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); str.append(dateFormatter.format(this.value(attIndex))).append(","); } } else { str.append("?,"); } } return str.toString(); }
/** * Weka attribute. * * @param index the index * @param attribute the attribute * @return the weka.core. attribute */ protected weka.core.Attribute wekaAttribute(int index, Attribute attribute) { weka.core.Attribute wekaAttribute; if (attribute.isNominal()) { wekaAttribute = new weka.core.Attribute(attribute.name(), attribute.getAttributeValues(), index); } else { wekaAttribute = new weka.core.Attribute(attribute.name(), index); } //System.out.println(wekaAttribute.name()); //System.out.println(wekaAttribute.isNominal()); return wekaAttribute; } }
/** * Trains the classifier with the given instance. * * @param instance the new training instance to include in the model */ @Override public void trainOnInstanceImpl(Instance instance) { if (m_weights == null) { int length; if (instance.classAttribute().isNominal()) { length = instance.numClasses(); } else { length = 1; } m_weights = new DoubleVector[length]; m_bias = new double[length]; for (int i = 0; i < m_weights.length; i++){ m_weights[i] = new DoubleVector(); m_bias[i] = 0.0; } } for (int i = 0; i < m_weights.length; i++){ this.trainOnInstanceImpl(instance, i); } m_t++; } public void trainOnInstanceImpl(Instance instance, int classLabel) {
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;
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; }
public void initHeader(Instances dataset) { int numLabels = this.numOldLabelsOption.getValue(); Attribute target = dataset.classAttribute(); List<String> possibleValues = new ArrayList<String>(); int n = target.numValues(); for (int i = 0; i < n; i++) { possibleValues.add(target.value(i)); } ArrayList<Attribute> attrs = new ArrayList<Attribute>(numLabels + dataset.numAttributes()); for (int i = 0; i < numLabels; i++) { attrs.add(new Attribute(target.name() + "_" + i, possibleValues)); } for (int i = 0; i < dataset.numAttributes(); i++) { Attribute attr = dataset.attribute(i); Attribute newAttribute = null; if (attr.isNominal() == true) { newAttribute = new Attribute(attr.name(), attr.getAttributeValues()); } if (attr.isNumeric() == true) { newAttribute = new Attribute(attr.name()); } if (newAttribute != null) { attrs.add(newAttribute); } } this.header = new Instances("extended_" + dataset.getRelationName(), attrs, 0); this.header.setClassIndex(numLabels + dataset.classIndex()); }
AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null) { obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver(); this.attributeObservers.set(i, obs);
/** * Computes the utility of a single child with respect to this node * * @param child the child for which to compute the utility * @return the utility of the child with respect to this node * @throws Exception if something goes wrong */ protected double categoryUtilityChild(CNode child) {//throws Exception { double sum = 0; for (int i = 0; i < m_numAttributes; i++) { if (m_clusterInstances.attribute(i).isNominal()) { for (int j = 0; j < m_clusterInstances.attribute(i).numValues(); j++) { double x = child.getProbability(i, j); double y = getProbability(i, j); sum += (x * x) - (y * y); } } else { // numeric attribute sum += ((m_normal / child.getStandardDev(i)) - (m_normal / getStandardDev(i))); } } return (child.m_totalInstances / m_totalInstances) * sum; }
AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null) { obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver(); this.attributeObservers.set(i, obs);
@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) { 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, 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()); } }
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); } } }
/** * Stratify. * * @param numFolds the num folds */ public void stratify(int numFolds) { if (classAttribute().isNominal()) { // sort by class int index = 1; while (index < numInstances()) { Instance instance1 = instance(index - 1); for (int j = index; j < numInstances(); j++) { Instance instance2 = instance(j); if ((instance1.classValue() == instance2.classValue()) || (instance1.classIsMissing() && instance2.classIsMissing())) { swap(index, j); index++; } } index++; } stratStep(numFolds); } }
@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()); } } }
@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; } }