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:machinelearningcw.perceptronClassifier.java

@Override
public double classifyInstance(Instance instnc) throws Exception {
    double y = 0;
    for (int i = 0; i < instnc.numAttributes() - 1; i++) {
        y += (w[i] * (instnc.value(i)));

    }//from ww w.j  ava 2s. co m

    return (y >= 0) ? 1 : 0;
}

From source file:machinelearningcw.perceptronClassifier.java

public double perceptron(Instances ins) {
    double error_count = 0;//count the number of errors
    for (int h = 0; h < numberofiterations; h++) {
        error_count = 0;//w w w.j  a  va  2  s. c o m
        for (Instance instance : ins) {
            double y = 0;
            for (int i = 0; i < ins.numAttributes() - 1; i++) {
                //   System.out.println("Y: "+ w[i]+"  "+instance.value(i));
                y += (w[i] * (instance.value(i)));
            }

            //   System.out.println(y);

            double match;
            if (y >= 0) {
                match = 1;
            } else {
                match = 0;
            }

            double difference = instance.classValue() - match;

            //  System.out.println("class value: " + instance.classValue() 
            //+ "  "+match+"  " + difference + "difference");
            //System.out.println(match);
            for (int j = 0; j < ins.numAttributes() - 1; j++) {

                //   System.out.println("w[" + j + "] = " + w[j] + " 
                //+ " + "0.5 " + " * " + learning_rate + " * " + difference
                //+ " * " + instance.value(j));
                w[j] = w[j] + (0.5 * learning_rate * difference * instance.value(j));

                /*   System.out.println("w[" + j + "] = " + w[j] + " +
                    " + "0.5 " + " * " + learning_rate + " * " 
                    + difference + " * " + instance.value(j));*/

            }
            error_count += (difference * difference);
        }
    }
    //System.out.println(match);
    for (int j = 0; j < ins.numAttributes() - 1; j++) {

        //  System.out.print("w[" + j + "]: " + w[j] + "|");
    }

    //  System.out.println("");
    return error_count;

}

From source file:machinelearninglabs.OENaiveBayesClassifier.java

@Override
public double[] distributionForInstance(Instance instance) throws Exception {
    // return an array with a size of the number of classes
    double[] jointProbabilities = new double[instance.attribute(instance.classIndex()).numValues()];
    double[] result = new double[instance.attribute(instance.classIndex()).numValues()];

    // calculate un-normaalized probs
    for (int cls = 0; cls < jointProbabilities.length; cls++) {
        double p = classProbs[cls];
        for (int att = 0; att < instance.numAttributes() - 1; att++) {
            int value = (int) instance.value(att);
            p *= conditionalProbabilities[att][cls][value];
        }//from  w  w w  .j a v  a  2s.c  o m
        jointProbabilities[cls] = p;
    }

    // Find normalized probabilities
    for (int i = 0; i < jointProbabilities.length; i++) {
        double denominator = 0;
        for (int j = 0; j < jointProbabilities.length; j++) {
            denominator += jointProbabilities[j];
        }
        result[i] = jointProbabilities[i] / denominator;
    }
    return result;
}

From source file:machinelearninglabs.OENaiveBayesClassifier.java

/***************************** HELPER METHODS  ************************************/

public void classDistribution(Instances data) {

    classCount = new int[data.firstInstance().numClasses()];
    classProbs = new double[data.firstInstance().numClasses()];

    // Get the frequency/count of each class in the data
    for (Instance eachInstance : data) {
        double classValue = eachInstance.value(eachInstance.classIndex());
        classCount[(int) classValue]++;
    }//from  www .  j ava  2s.  c  o m

    // Get the probability of the occurence of each class
    for (int i = 0; i < classProbs.length; i++) {
        classProbs[i] = (double) classCount[i] / data.numInstances();
    }

    printIntArray(classCount);
    System.out.println(data.firstInstance().value(0));
    printDoubleArray(classProbs);
}

From source file:machinelearninglabs.OENaiveBayesClassifier.java

public int[][] attributeCounts(Instances data, int att) {
    int numberOfPossibleValuesForAttribute = data.firstInstance().attribute(att).numValues();
    int[][] result = new int[data.numClasses()][numberOfPossibleValuesForAttribute];

    // for each class
    for (Instance eachInstance : data) {
        double classValue = eachInstance.value(eachInstance.classIndex());
        result[(int) classValue][(int) eachInstance.value(att)]++;
    }/*from  w  w w  .j  a v a 2  s  .c  o m*/
    //printIntMatrix(result);
    return result;
}

From source file:machinelearninglabs.OENaiveBayesClassifier.java

public double[][] attributeProbs(Instances data, int att) {
    int numberOfPossibleValuesForAttribute = data.firstInstance().attribute(att).numValues();
    double[][] result = new double[data.numClasses()][numberOfPossibleValuesForAttribute];

    // for each class
    for (Instance eachInstance : data) {
        double classValue = eachInstance.value(eachInstance.classIndex());
        result[(int) classValue][(int) eachInstance.value(att)]++;
    }/*from   ww w .j  av a 2 s . com*/

    // Get conditional probabilities ie probability that attribute = x given some class
    for (int i = 0; i < result.length; i++) {
        for (int j = 0; j < result[i].length; j++) {
            result[i][j] = (double) result[i][j] / classCount[i];
        }
    }
    //printDoubleMatrix(result);
    return result;
}

From source file:machinelearningq2.BasicNaiveBayesV1.java

/**
 *
 * This initial classifier will contain a two dimension array of counts
 *
 * @param ins/*from w  ww .j  ava 2s  .c om*/
 * @throws Exception
 */
@Override
public void buildClassifier(Instances ins) throws Exception {
    ins.setClassIndex(ins.numAttributes() - 1);
    countData = ins.size();
    // assigns the class position of the instance 
    classValueCounts = new int[ins.numClasses()];
    System.out.println(ins);
    if (laplace == true) {
        laplaceCorrection(ins);
    }
    // store the values
    for (Instance line : ins) {
        double classValue = line.classValue();
        classValueCounts[(int) classValue]++;
        for (int i = 0; i < line.numAttributes() - 1; i++) {
            double attributeValue = line.value(i);
            DataFound d = new DataFound(attributeValue, classValue, i);
            int index = data.indexOf(d);
            // then it doesn't exist
            if (index == -1) {
                data.add(d);
            } else {
                data.get(index).incrementCount();
            }
        }
    }
    System.out.println("");

    System.out.println(Arrays.toString(classValueCounts));

}

From source file:machinelearningq2.BasicNaiveBayesV1.java

/**
 *
 * The method distributionForInstance should work out the probabilities of
 * class membership for a single instance.
 *
 * @param instnc/* w w  w . j a va 2  s  .c  om*/
 * @return
 * @throws Exception
 */
@Override
public double[] distributionForInstance(Instance instnc) throws Exception {

    // creates a double array for storing the naive calculations for each class
    double[] naiveBayes = new double[classValueCounts.length];

    // loops through each class and computes the naive bayes 
    for (int c = 0; c < naiveBayes.length; c++) {

        // stores all conditional probabilities for class membership such:
        // P(struct=0|crime=1), P(security=1|crime=1), P(area=1|crime=1)
        // and also it stores the prior probability: P(crime=1)
        ArrayList<Double> conditionalProbs = new ArrayList<>();
        double priorProbability = classValueCounts[c] / countData;
        conditionalProbs.add(priorProbability);
        for (int i = 0; i < instnc.numValues() - 1; i++) {
            double attributeValue = instnc.value(i);
            DataFound d = new DataFound(attributeValue, c, i);

            int index = data.indexOf(d);
            if (index != -1) {
                double classValueCount = classValueCounts[(int) d.getClassValue()];
                conditionalProbs.add(data.get(index).getConditionalProbability((int) classValueCount));
            }
        }
        System.out.println(conditionalProbs);
        // compute the naive bayes
        double total = 1;
        for (Double x : conditionalProbs) {
            total *= x;
        }
        naiveBayes[c] = total;
    }
    prettyPrintProbabilities(naiveBayes);
    return naiveBayes;
}

From source file:machinelearningq2.ExtendedNaiveBayes.java

/**
 *
 * Build classifier will either build a gaussian or a discrete classifier
 * dependent on user input/*from   w  ww .j a v  a  2  s .  c  o  m*/
 *
 * @param ins
 * @throws Exception
 */
@Override
public void buildClassifier(Instances ins) throws Exception {
    if ("d".equals(gausianOrDiscretise)) {
        buildDiscreteClassifier(ins);
    } else {
        countData = ins.size();
        // assigns the class position of the instance 
        ins.setClassIndex(ins.numAttributes() - 1);
        classValueCounts = new int[ins.numClasses()];
        attributeMeans = new double[ins.numClasses()][ins.numAttributes() - 1];
        attributeVariance = new double[ins.numClasses()][ins.numAttributes() - 1];

        // store the values
        for (Instance line : ins) {
            double classValue = line.classValue();
            classValueCounts[(int) classValue]++;
            for (int i = 0; i < line.numAttributes() - 1; i++) {
                double attributeValue = line.value(i);
                attributeMeans[(int) classValue][i] += attributeValue;
                DataFound d = new DataFound(attributeValue, classValue, i);

                int index = data.indexOf(d);
                // then it doesn't exist
                if (index == -1) {
                    data.add(d);
                } else {
                    data.get(index).incrementCount();
                }
            }
        }
        System.out.println("Attribute Totals: " + Arrays.deepToString(attributeMeans));
        // computes the means
        for (int j = 0; j < classValueCounts.length; j++) {
            for (int i = 0; i < ins.numAttributes() - 1; i++) {
                attributeMeans[j][i] = attributeMeans[j][i] / classValueCounts[j];
            }
        }

        // calculate the variance
        for (int i = 0; i < data.size(); i++) {
            double cv = data.get(i).getClassValue();
            double atIn = data.get(i).getAttributeIndex();
            double squareDifference = Math
                    .pow(data.get(i).getAttributeValue() - attributeMeans[(int) cv][(int) atIn], 2);
            attributeVariance[(int) cv][(int) atIn] += squareDifference;
        }
        for (int j = 0; j < classValueCounts.length; j++) {
            for (int i = 0; i < ins.numAttributes() - 1; i++) {
                attributeVariance[j][i] = attributeVariance[j][i] / (classValueCounts[j] - 1);
                attributeVariance[j][i] = Math.sqrt(attributeVariance[j][i]);
            }
        }
        System.out.println("Attribute Means: " + Arrays.deepToString(attributeMeans));
        System.out.println("Variance: " + Arrays.deepToString(attributeVariance));
    }
}

From source file:machinelearningq2.ExtendedNaiveBayes.java

/**
 * The method buildDiscreteClassifier discretizes the data and then builds a
 * classifer/*from   ww  w .  j  a  v a 2  s  . co  m*/
 *
 * @param instnc
 * @return
 * @throws Exception
 */
public void buildDiscreteClassifier(Instances ins) throws Exception {
    ins = discretize(ins);
    ins.setClassIndex(ins.numAttributes() - 1);
    countData = ins.size();
    // assigns the class position of the instance 
    classValueCounts = new int[ins.numClasses()];
    // store the values
    for (Instance line : ins) {
        double classValue = line.classValue();
        classValueCounts[(int) classValue]++;
        for (int i = 0; i < line.numAttributes() - 1; i++) {
            double attributeValue = line.value(i);
            DataFound d = new DataFound(attributeValue, classValue, i);
            int index = data.indexOf(d);
            // then it doesn't exist
            if (index == -1) {
                data.add(d);
            } else {
                data.get(index).incrementCount();
            }
        }
    }

}