Example usage for weka.core Instance value

Introduction

In this page you can find the example usage for weka.core Instance value.

Prototype

public double value(Attribute att);

Source Link

Document

Returns an instance's attribute value in internal format.

Usage

From source file:moa.classifiers.rules.AMRules.java

License:Apache License

public void updateRuleStatistics(Instance inst, Rule rl, int ruleIndex) {
    rl.instancesSeen++;/*from  w  w w  .j a va2s  .c o m*/
    double targetValueSize = this.numTargetValue.get(ruleIndex) + 1.0;
    double targetVal = this.targetValue.get(ruleIndex) + inst.classValue();
    this.targetValue.set(ruleIndex, targetVal);
    this.numTargetValue.set(ruleIndex, targetValueSize);
    setRuleTarget(this.targetValue.get(ruleIndex), this.numTargetValue.get(ruleIndex), ruleIndex);
    rl.ValorTargetRule = this.ruleTargetMean.get(ruleIndex);
    for (int s = 0; s < inst.numAttributes() - 1; s++) {
        rl.attributeStatistics.addToValue(s, inst.value(s));
        rl.squaredAttributeStatistics.addToValue(s, inst.value(s) * inst.value(s));
    }
    rl.actualClassStatistics += inst.classValue();
    rl.squaredActualClassStatistics += inst.classValue() * inst.classValue();
}

---

From source file:moa.classifiers.rules.AMRules.java

License:Apache License

public void updatedefaultRuleStatistics(Instance inst) {
    this.instancesSeenDefault++;
    for (int j = 0; j < inst.numAttributes() - 1; j++) {
        this.attributeStatisticsDefault.addToValue(j, inst.value(j));
        this.squaredAttributeStatisticsDefault.addToValue(j, inst.value(j) * inst.value(j));
    }//  w  ww.  j  a  va 2s  .c  o m
    this.actualClassStatisticsDefault += inst.classValue();
    this.squaredActualClassStatisticsDefault += inst.classValue() * inst.classValue();
}

---

From source file:moa.classifiers.rules.core.conditionaltests.NumericAttributeBinaryRulePredicate.java

License:Apache License

@Override
public int branchForInstance(Instance inst) {
    int instAttIndex = this.attIndex < inst.classIndex() ? this.attIndex : this.attIndex + 1;
    if (inst.isMissing(instAttIndex)) {
        return -1;
    }/* w ww .  jav a 2  s. c o  m*/
    double v = inst.value(instAttIndex);
    int ret = 0;
    switch (this.operator) {
    case 0:
        ret = (v == this.attValue) ? 0 : 1;
        break;
    case 1:
        ret = (v <= this.attValue) ? 0 : 1;
        break;
    case 2:
        ret = (v > this.attValue) ? 0 : 1;
    }
    return ret;
}

---

From source file:moa.classifiers.rules.functions.Perceptron.java

License:Apache License

/**
 * Update the model using the provided instance
 *///w  w w. j  a  v  a2s . c o m
public void trainOnInstanceImpl(Instance inst) {
    accumulatedError = Math.abs(this.prediction(inst) - inst.classValue()) + fadingFactor * accumulatedError;
    nError = 1 + fadingFactor * nError;
    // Initialise Perceptron if necessary   
    if (this.initialisePerceptron == true) {
        this.fadingFactor = this.fadingFactorOption.getValue();
        this.classifierRandom.setSeed(randomSeedOption.getValue());
        this.initialisePerceptron = false; // not in resetLearningImpl() because it needs Instance!
        this.weightAttribute = new double[inst.numAttributes()];
        for (int j = 0; j < inst.numAttributes(); j++) {
            weightAttribute[j] = 2 * this.classifierRandom.nextDouble() - 1;
        }
        // Update Learning Rate
        learningRatio = learningRatioOption.getValue();
        this.learningRateDecay = learningRateDecayOption.getValue();

    }

    // Update attribute statistics
    this.perceptronInstancesSeen++;
    this.perceptronYSeen++;

    for (int j = 0; j < inst.numAttributes() - 1; j++) {
        perceptronattributeStatistics.addToValue(j, inst.value(j));
        squaredperceptronattributeStatistics.addToValue(j, inst.value(j) * inst.value(j));
    }
    this.perceptronsumY += inst.classValue();
    this.squaredperceptronsumY += inst.classValue() * inst.classValue();

    if (constantLearningRatioDecayOption.isSet() == false) {
        learningRatio = learningRatioOption.getValue() / (1 + perceptronInstancesSeen * learningRateDecay);
    }

    //double prediction = this.updateWeights(inst,learningRatio);
    //accumulatedError= Math.abs(prediction-inst.classValue()) + fadingFactor*accumulatedError;

    this.updateWeights(inst, learningRatio);

}

---

From source file:moa.classifiers.rules.functions.Perceptron.java

License:Apache License

public double[] normalizedInstance(Instance inst) {
    // Normalize Instance
    double[] normalizedInstance = new double[inst.numAttributes()];
    for (int j = 0; j < inst.numAttributes() - 1; j++) {
        int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst);
        double mean = perceptronattributeStatistics.getValue(j) / perceptronYSeen;
        double sd = computeSD(squaredperceptronattributeStatistics.getValue(j),
                perceptronattributeStatistics.getValue(j), perceptronYSeen);
        if (sd > SD_THRESHOLD)
            normalizedInstance[j] = (inst.value(instAttIndex) - mean) / sd;
        else/*from w w w  .  jav  a2s  .  com*/
            normalizedInstance[j] = inst.value(instAttIndex) - mean;
    }
    return normalizedInstance;
}

---

From source file:moa.classifiers.rules.Predicates.java

License:Apache License

public boolean evaluate(Instance inst) {
    boolean result = false;
    double attributeValue = inst.value((int) this.attributeValue);
    if (this.symbol == 0.0 && attributeValue == this.value) {
        result = true;//from  ww w.  j  a va  2  s  .co m
    } else if (this.symbol == -1.0 && attributeValue <= this.value) {
        result = true;
    } else if (this.symbol == 1.0 && attributeValue > this.value) {
        result = true;
    }
    return result;
}

---

From source file:moa.classifiers.rules.RuleClassifier.java

License:Apache License

@Override
public void trainOnInstanceImpl(Instance inst) {
    int countRuleFiredTrue = 0;
    boolean ruleFired = false;
    this.instance = inst;
    this.numAttributes = instance.numAttributes() - 1;
    this.numClass = instance.numClasses();
    this.numInstance = numInstance + 1;
    int conta1 = 0;
    for (int j = 0; j < ruleSet.size(); j++) {
        if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
            countRuleFiredTrue = countRuleFiredTrue + 1;

            double anomaly = 0.0;
            if (this.Supervised.isSet()) {
                anomaly = computeAnomalySupervised(this.ruleSet.get(j), j, inst); // compute anomaly (Supervised method)
            } else if (this.Unsupervised.isSet()) {
                anomaly = computeAnomalyUnsupervised(this.ruleSet.get(j), j, inst); // compute anomaly (Unsupervised method)
            }// w ww.  j  a  v a 2s . c o  m

            if (anomaly >= this.anomalyProbabilityThresholdOption.getValue()) {
                conta1 = conta1 + 1;
            }
            //   System.out.print(numInstance+";"+anomaly+"\n");
            try {

                File dir = new File("SeaAnomaliesUnsupervised.txt");
                FileWriter fileWriter = new FileWriter(dir, true);
                PrintWriter printWriter = new PrintWriter(fileWriter);
                printWriter.println(numInstance + ";" + anomaly);
                printWriter.flush();
                printWriter.close();

            } catch (IOException e) {
                e.printStackTrace();
            }
            if ((this.ruleSet.get(j).instancesSeen <= this.anomalyNumInstThresholdOption.getValue())
                    || (anomaly < this.anomalyProbabilityThresholdOption.getValue()
                            && this.anomalyDetectionOption.isSet())
                    || !this.anomalyDetectionOption.isSet()) {
                this.ruleSet.get(j).obserClassDistrib.addToValue((int) inst.classValue(), inst.weight());
                for (int i = 0; i < inst.numAttributes() - 1; i++) {
                    int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);

                    if (!inst.isMissing(instAttIndex)) {
                        AttributeClassObserver obs = this.ruleSet.get(j).observers.get(i); // Nominal and binary tree.
                        AttributeClassObserver obsGauss = this.ruleSet.get(j).observersGauss.get(i); // Gaussian.
                        if (obs == null) {
                            obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
                                    : newNumericClassObserver();
                            this.ruleSet.get(j).observers.set(i, obs);
                        }
                        if (obsGauss == null) {
                            obsGauss = inst.attribute(instAttIndex).isNumeric() ? newNumericClassObserver2()
                                    : null;
                            this.ruleSet.get(j).observersGauss.set(i, obsGauss);
                        }
                        obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(),
                                inst.weight());
                        if (inst.attribute(instAttIndex).isNumeric()) {
                            obsGauss.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(),
                                    inst.weight());
                        }
                    }
                }
                expandeRule(this.ruleSet.get(j), inst, j); // This function expands the rule
            }
            if (this.orderedRulesOption.isSet()) { // Ordered rules
                break;
            }
        }
    }
    if (countRuleFiredTrue > 0) {
        ruleFired = true;
    } else {
        ruleFired = false;
    }
    if (ruleFired == false) { //If none of the rules cover the example update sufficient statistics of the default rule
        this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
        for (int i = 0; i < inst.numAttributes() - 1; i++) {
            int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
            if (!inst.isMissing(instAttIndex)) {
                AttributeClassObserver obs = this.attributeObservers.get(i);
                AttributeClassObserver obsGauss = this.attributeObserversGauss.get(i);
                if (obs == null) {
                    obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
                            : newNumericClassObserver();
                    this.attributeObservers.set(i, obs);
                }
                if (obsGauss == null) {
                    obsGauss = inst.attribute(instAttIndex).isNumeric() ? newNumericClassObserver2() : null;
                    this.attributeObserversGauss.set(i, obsGauss);
                }
                obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
                if (inst.attribute(instAttIndex).isNumeric()) {
                    obsGauss.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(),
                            inst.weight());
                }
            }
        }
        createRule(inst); //This function creates a rule
    }
}

---

From source file:moa.classifiers.rules.RuleClassifier.java

License:Apache License

public void updateRuleAttribStatistics(Instance inst, Rule rl, int ruleIndex) {
    rl.instancesSeen++;//w  w  w . j  a  va 2  s  . c o  m
    if (rl.squaredAttributeStatisticsSupervised.size() == 0 && rl.attributeStatisticsSupervised.size() == 0) {
        for (int s = 0; s < inst.numAttributes() - 1; s++) {
            ArrayList<Double> temp1 = new ArrayList<Double>();
            ArrayList<Double> temp2 = new ArrayList<Double>();
            rl.attributeStatisticsSupervised.add(temp1);
            rl.squaredAttributeStatisticsSupervised.add(temp2);
            int instAttIndex = modelAttIndexToInstanceAttIndex(s, inst);
            if (instance.attribute(instAttIndex).isNumeric()) {
                for (int i = 0; i < inst.numClasses(); i++) {
                    rl.attributeStatisticsSupervised.get(s).add(0.0);
                    rl.squaredAttributeStatisticsSupervised.get(s).add(1.0);
                }
            }
        }
    }
    for (int s = 0; s < inst.numAttributes() - 1; s++) {
        int instAttIndex = modelAttIndexToInstanceAttIndex(s, inst);
        if (!inst.isMissing(instAttIndex)) {
            if (instance.attribute(instAttIndex).isNumeric()) {
                rl.attributeStatistics.addToValue(s, inst.value(s));
                rl.squaredAttributeStatistics.addToValue(s, inst.value(s) * inst.value(s));
                double sumValue = rl.attributeStatisticsSupervised.get(s).get((int) inst.classValue())
                        + inst.value(s);
                rl.attributeStatisticsSupervised.get(s).set((int) inst.classValue(), sumValue);
                double squaredSumvalue = rl.squaredAttributeStatisticsSupervised.get(s)
                        .get((int) inst.classValue()) + (inst.value(s) * inst.value(s));
                rl.squaredAttributeStatisticsSupervised.get(s).set((int) inst.classValue(), squaredSumvalue);
            }
        } else {
            rl.attributeMissingValues.addToValue(s, 1);
        }
    }
}

---

From source file:moa.classifiers.rules.RuleClassifier.java

License:Apache License

public double computeAnomalyUnsupervised(Rule rl, int ruleIndex, Instance inst) { //Unsupervised
    ArrayList<Integer> caseAnomalyTemp = new ArrayList<Integer>();
    ArrayList<ArrayList<Double>> AttribAnomalyStatisticTemp2 = new ArrayList<ArrayList<Double>>();
    double D = 0.0;
    double N = 0.0;

    if (rl.instancesSeen > this.anomalyNumInstThresholdOption.getValue()
            && this.anomalyDetectionOption.isSet()) {
        for (int x = 0; x < inst.numAttributes() - 1; x++) {
            if (!inst.isMissing(x)) {
                ArrayList<Double> AttribAnomalyStatisticTemp = new ArrayList<Double>();
                if (inst.attribute(x).isNumeric()) { //Numeric Attributes
                    if ((rl.instancesSeen - rl.attributeMissingValues.getValue(x)) > 30) {
                        double mean = computeMean(rl.attributeStatistics.getValue(x), rl.instancesSeen);
                        double sd = computeSD(rl.squaredAttributeStatistics.getValue(x),
                                rl.attributeStatistics.getValue(x), rl.instancesSeen);
                        double probability = computeProbability(mean, sd, inst.value(x));
                        if (probability != 0.0) {
                            D = D + Math.log(probability);
                            if (probability < this.probabilityThresholdOption.getValue()) { //0.10
                                N = N + Math.log(probability);
                                AttribAnomalyStatisticTemp.add((double) x);
                                AttribAnomalyStatisticTemp.add(inst.value(x));
                                AttribAnomalyStatisticTemp.add(mean);
                                AttribAnomalyStatisticTemp.add(sd);
                                AttribAnomalyStatisticTemp.add(probability);
                                AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
                            }/*from w ww.  j av  a2 s. c o  m*/
                        }
                    }
                } else { //Nominal Attributes
                    AutoExpandVector<DoubleVector> attribNominal = ((NominalAttributeClassObserver) rl.observers
                            .get(x)).attValDistPerClass; //Attributes values distribution per class
                    double numbAttribValue = 0.0;
                    double attribVal = inst.value(x); //Attribute value
                    for (int i = 0; i < attribNominal.size(); i++) {
                        if (attribNominal.get(i) != null) {
                            numbAttribValue = numbAttribValue + attribNominal.get(i).getValue((int) attribVal);
                        }
                    }
                    double probability = numbAttribValue / rl.instancesSeen;
                    if (probability != 0.0) {
                        D = D + Math.log(probability);
                        if (probability < this.probabilityThresholdOption.getValue()) { //0.10
                            N = N + Math.log(probability);
                            AttribAnomalyStatisticTemp.add((double) x);
                            AttribAnomalyStatisticTemp.add(inst.value(x));
                            AttribAnomalyStatisticTemp.add(probability);
                            AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
                        }
                    }
                }
            }
        }
    }
    double anomaly = 0.0;
    if (D != 0) {
        anomaly = Math.abs(N / D);
    }
    if (anomaly >= this.anomalyProbabilityThresholdOption.getValue()) {
        caseAnomalyTemp.add(this.numInstance);
        double val = anomaly * 100;
        caseAnomalyTemp.add((int) val);
        this.caseAnomaly.add(caseAnomalyTemp);
        Rule x = new Rule(this.ruleSet.get(ruleIndex));
        this.ruleSetAnomalies.add(x);
        this.ruleAnomaliesIndex.add(ruleIndex + 1);
        this.ruleAttribAnomalyStatistics.add(AttribAnomalyStatisticTemp2);

    }
    return anomaly;
}

---

From source file:moa.classifiers.rules.RuleClassifier.java

License:Apache License

public double computeAnomalySupervised(Rule rl, int ruleIndex, Instance inst) { //Not supervised
    ArrayList<Integer> caseAnomalyTemp = new ArrayList<Integer>();
    ArrayList<ArrayList<Double>> AttribAnomalyStatisticTemp2 = new ArrayList<ArrayList<Double>>();
    double D = 0.0;
    double N = 0.0;
    if (rl.instancesSeen > this.anomalyNumInstThresholdOption.getValue()
            && this.anomalyDetectionOption.isSet()) {
        for (int x = 0; x < inst.numAttributes() - 1; x++) {
            if (!inst.isMissing(x)) {
                ArrayList<Double> AttribAnomalyStatisticTemp = new ArrayList<Double>();
                if (inst.attribute(x).isNumeric()) { //Numeric Attributes
                    if ((rl.instancesSeen - rl.attributeMissingValues.getValue(x)) > 30) {
                        double mean = computeMean(
                                (double) rl.attributeStatisticsSupervised.get(x).get((int) inst.classValue()),
                                (int) rl.obserClassDistrib.getValue((int) inst.classValue()));
                        double sd = computeSD(
                                (double) rl.squaredAttributeStatisticsSupervised.get(x)
                                        .get((int) inst.classValue()),
                                (double) rl.attributeStatisticsSupervised.get(x).get((int) inst.classValue()),
                                (int) rl.obserClassDistrib.getValue((int) inst.classValue()));
                        double probability = computeProbability(mean, sd, inst.value(x));
                        if (probability != 0.0) {
                            D = D + Math.log(probability);
                            if (probability < this.probabilityThresholdOption.getValue()) { //0.10
                                N = N + Math.log(probability);
                                AttribAnomalyStatisticTemp.add((double) x);
                                AttribAnomalyStatisticTemp.add(inst.value(x));
                                AttribAnomalyStatisticTemp.add(mean);
                                AttribAnomalyStatisticTemp.add(sd);
                                AttribAnomalyStatisticTemp.add(probability);
                                AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
                            }/*from  w w w  . j ava  2 s  .c  om*/
                        }
                    }
                } else { //Nominal
                    double attribVal = inst.value(x); //Attribute value
                    double classVal = inst.classValue(); //Attribute value
                    double probability = rl.observers.get(x).probabilityOfAttributeValueGivenClass(attribVal,
                            (int) classVal);
                    if (probability != 0.0) {
                        D = D + Math.log(probability);
                        if (probability < this.probabilityThresholdOption.getValue()) { //0.10
                            N = N + Math.log(probability);
                            AttribAnomalyStatisticTemp.add((double) x);
                            AttribAnomalyStatisticTemp.add(inst.value(x));
                            AttribAnomalyStatisticTemp.add(probability);
                            AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
                        }
                    }
                }
            }
        }
    }
    double anomaly = 0.0;
    if (D != 0) {
        anomaly = Math.abs(N / D);
    }
    if (anomaly >= this.anomalyProbabilityThresholdOption.getValue()) {
        caseAnomalyTemp.add(this.numInstance);
        double val = anomaly * 100;
        caseAnomalyTemp.add((int) val);
        this.caseAnomalySupervised.add(caseAnomalyTemp);
        Rule y = new Rule(this.ruleSet.get(ruleIndex));
        this.ruleSetAnomaliesSupervised.add(y);
        this.ruleAnomaliesIndexSupervised.add(ruleIndex + 1);
        this.ruleAttribAnomalyStatisticsSupervised.add(AttribAnomalyStatisticTemp2);
    }
    return anomaly;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »