Example usage for weka.core Instances attribute

List of usage examples for weka.core Instances attribute

  1. HOME
  2. Java
  3. weka
  4. weka.core.*
  5. Instances
  6. attribute

Introduction

In this page you can find the example usage for weka.core Instances attribute.

Prototype

publicAttribute attribute(String name)

Source Link

Document

Returns an attribute given its name.

Usage

From source file:facebookpostpuller.SpecificUserModel.java

public void convertToArff(File file) throws Exception {

    FastVector atts;/*ww w. ja  v  a2 s . co  m*/
    FastVector attVals;
    Instances data;
    double[] vals;

    file = new File(file + ".arff");

    atts = new FastVector();
    atts.addElement(new Attribute(("name"), (FastVector) null)); // 5/27/2014
    atts.addElement(new Attribute(("message"), (FastVector) null));

    attVals = new FastVector();
    attVals.addElement("13-17");
    attVals.addElement("18-24");
    attVals.addElement("25-34");
    attVals.addElement("35-44");
    attVals.addElement("45-54");
    atts.addElement(new Attribute("age-group", attVals));

    data = new Instances("predict_age", atts, 0);

    Iterator it = posts.entrySet().iterator();

    while (it.hasNext()) {
        Map.Entry pairs = (Map.Entry) it.next();

        vals = new double[data.numAttributes()];
        User user = (User) pairs.getValue();
        String name = user.getName(); // 5/27/2014
        String message = ((Post) (pairs.getKey())).getMessage();

        Preprocess pre = new Preprocess();
        message = pre.emoticons(message);
        message = pre.emoji(message);
        message = pre.url(message);

        //StringFilter filter = new StringFilter(message);
        vals[0] = data.attribute(0).addStringValue(name); // 5/27/2014
        vals[1] = data.attribute(1).addStringValue(message);

        if (ageGroup.equals("13-17")) {
            vals[2] = attVals.indexOf("13-17");
        } else if (ageGroup.equals("18-24")) {
            vals[2] = attVals.indexOf("18-24");
        } else if (ageGroup.equals("25-34")) {
            vals[2] = attVals.indexOf("25-34");
        } else if (ageGroup.equals("35-44")) {
            vals[2] = attVals.indexOf("35-44");
        } else if (ageGroup.equals("45-54")) { // Modified 6/11/2014 
            vals[2] = attVals.indexOf("45-54");
        }

        data.add(new Instance(1.0, vals));

        it.remove();
    }

    ArffSaver saver = new ArffSaver();
    saver.setInstances(data);
    saver.setFile(file);
    saver.writeBatch();
}

From source file:fantail.algorithms.BinaryART.java

License:Open Source License

private void makeTree(Instances data, java.util.Random r, int depth) throws Exception {
    if (m_K > data.numAttributes()) {
        m_K = data.numAttributes() - 1;//from ww w  . j av a  2 s  .c  om
    }

    if (m_K < 1) {
        m_K = (int) weka.core.Utils.log2(data.numAttributes()) + 1;
    }

    int[] randAtts = new int[data.numAttributes() - 1];
    //TODO: handle class target att
    for (int i = 0; i < randAtts.length; i++) {
        randAtts[i] = i;
    }
    for (int i = 0; i < randAtts.length; i++) {
        int randomPosition = r.nextInt(randAtts.length);
        int temp = randAtts[i];
        randAtts[i] = randAtts[randomPosition];
        randAtts[randomPosition] = temp;
    }

    int bestAttIndex = -1;

    AttScorePair[] attScorePair = new AttScorePair[m_K];

    //double currentR2 = estimateAvgDistanceSpearman(data);
    for (int i = 0; i < m_K; i++) {
        int attIndex = randAtts[i];

        double splitPoint = Double.NaN;

        if (!m_UseMedian) {
            splitPoint = data.meanOrMode(attIndex);
        } else {
            splitPoint = getMedian(data, attIndex);
        }

        double r2 = estimateR2(data, attIndex, splitPoint);
        attScorePair[i] = new AttScorePair(attIndex, r2);
    }

    Arrays.sort(attScorePair);

    bestAttIndex = attScorePair[0].index;
    double maxR2 = attScorePair[0].score;
    boolean stop1 = false;

    //        for (int kk = 0; kk < attScorePair.length; kk++) {
    //            System.out.println(attScorePair[kk].score);
    //        }
    //        if (true) {
    //            throw new Exception("stop");
    //        }
    if (attScorePair[0].score <= attScorePair[m_K - 1].score) {
        stop1 = true;
    }

    if (data.numInstances() <= m_MiniLeaf || (depth >= m_MaxDepth && m_MaxDepth != 0)
    //|| maxR2 <= 0.01 // removed 10/01/2013
            || maxR2 >= 0.95 || stop1 // 11/01/13 the paper version doesn't have this
            || data.variance(bestAttIndex) <= 0) {

        m_Attribute = null;
        m_Prototype = AbstractRanker.getAvgRanking(data);
        //m_Prototype = AbstractRanker.getCenterRanking(data, m_ApproxCenterMethod);
        return;
    }

    m_Attribute = data.attribute(bestAttIndex);
    if (!m_UseMedian) {
        m_SplitPoint = data.meanOrMode(bestAttIndex);
    } else {
        m_SplitPoint = getMedian(data, bestAttIndex);
    }
    Instances[] splitData = splitData(data, bestAttIndex, m_SplitPoint);

    m_Successors = new BinaryART[2];
    for (int j = 0; j < 2; j++) {
        m_Successors[j] = new BinaryART();
        m_Successors[j].setMiniLeaf(m_MiniLeaf);
        m_Successors[j].setK(m_K);
        m_Successors[j].setUseMedian(m_UseMedian);
        m_Successors[j].setNumObjects(m_NumObjects);

        m_Successors[j].makeTree(splitData[j], r, depth + 1);
    }
}

From source file:fantail.algorithms.RankingViaRegression.java

License:Open Source License

@Override
public void buildRanker(Instances data) throws Exception {

    Instances workingData = new Instances(data);
    //Instance instTemp = workingData.instance(0);

    //m_LastFeatureIndex = workingData.numAttributes() - 1;
    m_NumFeatures = workingData.numAttributes() - 1;
    m_NumTargets = Tools.getNumberTargets(data);
    m_Classifiers = new AbstractClassifier[m_NumTargets];

    for (int i = 0; i < m_NumTargets; i++) {
        weka.classifiers.functions.LinearRegression lr = new weka.classifiers.functions.LinearRegression();
        m_Classifiers[i] = AbstractClassifier.makeCopy(lr);
    }//from  w ww  .j  a  va2 s  . c  o m

    Instances[] trainingSets = new Instances[m_NumTargets];

    for (int t = 0; t < m_NumTargets; t++) {

        ArrayList attributes = new ArrayList();
        for (int i = 0; i < m_NumFeatures; i++) {
            attributes.add(new Attribute(workingData.attribute(i).name()));
        }

        String targetName = "att-" + (t + 1);
        attributes.add(new Attribute(targetName));

        trainingSets[t] = new Instances("data-" + targetName, attributes, 0);

        for (int j = 0; j < workingData.numInstances(); j++) {
            Instance metaInst = workingData.instance(j);
            double[] ranking = Tools.getTargetVector(metaInst);
            double[] values = new double[trainingSets[t].numAttributes()];

            for (int m = 0; m < (trainingSets[t].numAttributes() - 1); m++) {
                values[m] = metaInst.value(m);
            }
            values[values.length - 1] = ranking[t];
            trainingSets[t].add(new DenseInstance(1.0, values));
        }

        trainingSets[t].setClassIndex(trainingSets[t].numAttributes() - 1);
        m_Classifiers[t].buildClassifier(trainingSets[t]);
    }

    m_TempHeader = new Instances(trainingSets[0], 0);
}

From source file:fantail.algorithms.RankingWithBinaryPCT.java

License:Open Source License

private void makeTree(Instances data, Random r, int depth) throws Exception {

    if (data.numInstances() <= m_MiniLeaf || (depth >= m_MaxDepth && m_MaxDepth != 0)
            || computeVariance(data) <= m_MinVariancea) {
        //|| maxVarianceaReduction <= 0
        //|| data.variance(bestAttIndex) <= 0) { // || data.variance(bestAttIndex) <= 0 ) {   copied from ART, 

        m_Attribute = null;//w  w  w .ja v  a2 s. c om
        m_Prototype = AbstractRanker.getAvgRanking(data);
        return;
    }

    //
    if (m_K > data.numAttributes()) {
        m_K = data.numAttributes();
    }
    if (m_K < 1) {
        m_K = (int) weka.core.Utils.log2(data.numAttributes()) + 1;
    }

    // TODO:
    int[] attIndice = new int[data.numAttributes() - 1];
    for (int i = 0; i < attIndice.length; i++) {
        attIndice[i] = i;
    }
    for (int i = 0; i < attIndice.length; i++) {
        //int randomPosition = getRandomPosition(r, attIndice);
        int randomPosition = r.nextInt(attIndice.length);
        int temp = attIndice[i];
        attIndice[i] = attIndice[randomPosition];
        attIndice[randomPosition] = temp;
    }

    AttScorePair[] attScorePair = new AttScorePair[m_K];

    for (int i = 0; i < m_K; i++) {
        int attIndex = attIndice[i];

        double splitPoint = Double.NaN;
        if (!m_UseMedian) {
            splitPoint = data.meanOrMode(attIndex);
        } else {
            splitPoint = getMedian(data, attIndex);
        }
        double varianceReduction = computeVarianceReduction(data, attIndex, splitPoint);
        attScorePair[i] = new AttScorePair(attIndex, varianceReduction);

    }

    Arrays.sort(attScorePair);
    int randAttIndex = 0;
    int bestAttIndex = attScorePair[randAttIndex].index;

    double maxVarianceaReduction = attScorePair[randAttIndex].score;

    //        if (data.numInstances() <= 1 * m_MiniLeaf
    //                || (depth >= m_MaxDepth && m_MaxDepth != 0)
    //                || computeVariance(data) <= m_MinVariancea) {
    //                //|| maxVarianceaReduction <= 0
    //                //|| data.variance(bestAttIndex) <= 0) { // || data.variance(bestAttIndex) <= 0 ) {   copied from ART, 
    //
    //            m_Attribute = null;
    //            m_Prototype = AbstractRanker.getAvgRanking(data);
    //            return;
    //        }
    m_Attribute = data.attribute(bestAttIndex);

    if (!m_UseMedian) {
        m_SplitPoint = data.meanOrMode(bestAttIndex);
    } else {
        m_SplitPoint = getMedian(data, bestAttIndex);
    }

    //m_SplitPoint = data.meanOrMode(m_Attribute);
    Instances[] splitData = splitData(data, bestAttIndex, m_SplitPoint);

    //System.out.println(splitData[0].numInstances());
    //System.out.println(splitData[1].numInstances());
    //System.out.println();

    m_Successors = new RankingWithBinaryPCT[2];

    for (int j = 0; j < 2; j++) {
        m_Successors[j] = new RankingWithBinaryPCT();
        m_Successors[j].setMiniLeaf(m_MiniLeaf);
        m_Successors[j].setK(m_K);
        m_Successors[j].setUseMedian(m_UseMedian);
        m_Successors[j].setNumTargetLabels(m_NumTargetLabels);
        m_Successors[j].makeTree(splitData[j], r, depth + 1);
    }
}

From source file:fantail.core.Tools.java

License:Open Source License

public static String[] getTargetNames(Instance inst) {
    Instances targetBag = inst.relationalValue(inst.classIndex());
    String[] names = new String[targetBag.numAttributes()];
    for (int i = 0; i < names.length; i++) {
        names[i] = targetBag.attribute(i).name();
    }//from w w  w. j av  a 2  s .co  m
    return names;
}

From source file:fantail.core.WekaLRHelper.java

License:Open Source License

public static Instances covertArff2Xarff(Instances data) {

    Instances xarffData = null;//from w  w  w  .  java2s. c o m

    try {
        String userDIR = System.getProperty("user.dir");
        String randFileName = Long.toString(System.nanoTime()).substring(10)
                + ".fantail.algorithms.LRT.temp.xarff";
        String path_separator = System.getProperty("file.separator");
        String xarffPath = userDIR + path_separator + randFileName;
        //System.out.println(m_xarffPath);
        int numObjects = Tools.getNumberTargets(data);

        StringBuilder sb = new StringBuilder();
        sb.append("@relation arff2xarff").append(System.getProperty("line.separator"));
        for (int i = 0; i < data.numAttributes() - 1; i++) {
            sb.append("@attribute ");
            sb.append(data.attribute(i).name());
            sb.append(" numeric").append(System.getProperty("line.separator"));
        }
        sb.append("@attribute L RANKING {");
        for (int i = 0; i < numObjects; i++) {
            String spr = ",";
            if (i == numObjects - 1) {
                spr = "";
            }
            String targetName = "T" + (i);
            sb.append(targetName).append(spr);
        }
        sb.append("}").append(System.getProperty("line.separator"));
        sb.append("@data ").append(System.getProperty("line.separator"));

        for (int i = 0; i < data.numInstances(); i++) {
            Instance inst = data.instance(i);
            for (int j = 0; j < data.numAttributes() - 1; j++) {
                sb.append(inst.value(j)).append(",");
            }
            for (int x = 1; x <= numObjects; x++) {
                int rank = x;

                String[] names = Tools.getTargetNames(inst);
                String algo = getName(rank, Tools.getTargetVector(inst), names);

                System.out.println("\t algo: " + algo + ". rank: " + rank + ", Tools.getTargetVector(inst):"
                        + Arrays.toString(Tools.getTargetVector(inst)) + ", " + "names:"
                        + Arrays.toString(names));

                String sprr = ">";
                if (x == names.length) {
                    sprr = "";
                }
                sb.append(algo).append(sprr);
            }
            sb.append(System.getProperty("line.separator"));
        }

        File file = new File(xarffPath);
        Writer output = new BufferedWriter(new FileWriter(file));
        output.write(sb.toString());
        output.close();

        System.out.println(file.getAbsoluteFile());

        weka.core.converters.XArffLoader xarffLoader = new weka.core.converters.XArffLoader();
        xarffLoader.setSource(new File(xarffPath));
        xarffData = xarffLoader.getDataSet();
        //
        File tmpxarffFile = new File(xarffPath);
        if (tmpxarffFile.exists()) {
            tmpxarffFile.delete();
        }
    } catch (Exception e) {
        e.printStackTrace();
        System.exit(-1);
    }

    return xarffData;
}

From source file:fantail.core.WekaLRHelper.java

License:Open Source License

public static Instances covertArff2Xarff2(DATA_TYPE data_type, Instances data) {

    Instances xarffData = null;//  ww w.  j  a  v  a2  s .c  om

    try {
        String userDIR = System.getProperty("user.dir");
        //String randFileName = Long.toString(System.nanoTime()).substring(10) + ".LRT.temp.xarff";
        String randFileName = UUID.randomUUID().toString() + ".LRT.temp.xarff";
        String path_separator = System.getProperty("file.separator");
        String xarffPath = userDIR + path_separator + randFileName;
        //System.out.println(m_xarffPath);
        int numObjects = Tools.getNumberTargets(data);

        StringBuilder sb = new StringBuilder();
        sb.append("@relation arff2xarff").append(System.getProperty("line.separator"));
        for (int i = 0; i < data.numAttributes() - 1; i++) {
            sb.append("@attribute ");
            sb.append(data.attribute(i).name());
            sb.append(" numeric").append(System.getProperty("line.separator"));
        }
        sb.append("@attribute L RANKING {");
        for (int i = 0; i < numObjects; i++) {
            String spr = ",";
            if (i == numObjects - 1) {
                spr = "";
            }
            String targetName = "T" + (i);
            sb.append(targetName).append(spr);
        }
        sb.append("}").append(System.getProperty("line.separator"));
        sb.append("@data ").append(System.getProperty("line.separator"));

        for (int i = 0; i < data.numInstances(); i++) {
            Instance inst = data.instance(i);

            // determine a ranking of the class labels
            String ranking_result = determineRanking(Tools.getTargetObjects(inst));
            if (ranking_result == null)
                continue;
            //System.out.println("\t ranking_result:" + ranking_result);

            // looking at a>b>c, if the 'a' part consists of more than two partial relations, we need to split them.
            List<ArrayList<String>> label_collection = new ArrayList<ArrayList<String>>();

            // generate feature string
            String attr_set_str = "";
            for (int j = 0; j < data.numAttributes() - 1; j++) {
                attr_set_str += (inst.value(j) + ",");
            }

            // split label string via ">"
            String items[] = ranking_result.split(">");
            for (int j = 0; j < items.length; j++) {

                String labels[] = items[j].split("\\|");

                // if the first label has more than or equal to 2 partial relations, we split it.
                ArrayList<String> label_list = new ArrayList<String>();
                if (j == 0) {
                    if (labels.length >= 2) {
                        for (int k = 0; k < labels.length; k++) {
                            label_list.add(labels[k]);
                        }
                    } else {
                        label_list.add(items[j]);
                    }
                    label_collection.add(label_list);
                } else {
                    if (labels.length >= 3) {
                        for (int k = 0; k < labels.length; k++) {
                            label_list.add(labels[k]);
                        }

                    } else {
                        label_list.add(items[j]);
                    }
                    label_collection.add(label_list);
                }
            }

            List<String> prev_items_in_label_collection = new ArrayList<String>();
            for (int j = 0; j < label_collection.size(); j++) {
                List<String> items_in_label_collection = new ArrayList<String>();
                if (j == 0) {
                    for (int k = 0; k < label_collection.get(j).size(); k++) {
                        items_in_label_collection.add(label_collection.get(j).get(k));
                    }
                } else {
                    for (int k = 0; k < label_collection.get(j).size(); k++) {
                        for (int l = 0; l < prev_items_in_label_collection.size(); l++) {
                            items_in_label_collection.add(prev_items_in_label_collection.get(l) + ">"
                                    + label_collection.get(j).get(k));
                        }
                    }
                }
                prev_items_in_label_collection = items_in_label_collection;
            }

            for (int j = 0; j < prev_items_in_label_collection.size(); j++) {
                //System.out.println("\t\t line:" + prev_items_in_label_collection.get(j));
                sb.append(attr_set_str + prev_items_in_label_collection.get(j) + "\n");
            }

            InputStream is = new ByteArrayInputStream(sb.toString().getBytes());
            weka.core.converters.XArffLoader xarffLoader = new weka.core.converters.XArffLoader();
            xarffLoader.setSource(is);
            xarffData = xarffLoader.getDataSet();
        }
    } catch (Exception e) {
        e.printStackTrace();
        System.exit(-1);
    }

    return xarffData;
}

From source file:feature.InfoGainEval.java

License:Open Source License

/**
 * Initializes an information gain attribute evaluator. Discretizes all
 * attributes that are numeric./*www  .ja va2 s  .co m*/
 *
 * @param data
 *            set of instances serving as training data
 * @throws Exception
 *             if the evaluator has not been generated successfully
 */
public double computeInfoGain(Instances data, int att) throws Exception {

    // can evaluator handle data?
    getCapabilities().testWithFail(data);

    int classIndex = data.classIndex();
    int numInstances = data.numInstances();

    if (!m_Binarize) {
        Discretize disTransform = new Discretize();
        disTransform.setUseBetterEncoding(true);
        disTransform.setInputFormat(data);
        data = Filter.useFilter(data, disTransform);
    } else {
        NumericToBinary binTransform = new NumericToBinary();
        binTransform.setInputFormat(data);
        data = Filter.useFilter(data, binTransform);
    }
    int numClasses = data.attribute(classIndex).numValues();

    // Reserve space and initialize counters
    double[][][] counts = new double[data.numAttributes()][][];
    for (int k = 0; k < data.numAttributes(); k++) {
        if (k != classIndex) {
            int numValues = data.attribute(k).numValues();
            counts[k] = new double[numValues + 1][numClasses + 1];
        }
    }

    // Initialize counters
    double[] temp = new double[numClasses + 1];
    for (int k = 0; k < numInstances; k++) {
        Instance inst = data.instance(k);
        if (inst.classIsMissing()) {
            temp[numClasses] += inst.weight();
        } else {
            temp[(int) inst.classValue()] += inst.weight();
        }
    }
    for (int k = 0; k < counts.length; k++) {
        if (k != classIndex) {
            for (int i = 0; i < temp.length; i++) {
                counts[k][0][i] = temp[i];
            }
        }
    }

    // Get counts
    for (int k = 0; k < numInstances; k++) {
        Instance inst = data.instance(k);
        for (int i = 0; i < inst.numValues(); i++) {
            if (inst.index(i) != classIndex) {
                if (inst.isMissingSparse(i) || inst.classIsMissing()) {
                    if (!inst.isMissingSparse(i)) {
                        counts[inst.index(i)][(int) inst.valueSparse(i)][numClasses] += inst.weight();
                        counts[inst.index(i)][0][numClasses] -= inst.weight();
                    } else if (!inst.classIsMissing()) {
                        counts[inst.index(i)][data.attribute(inst.index(i)).numValues()][(int) inst
                                .classValue()] += inst.weight();
                        counts[inst.index(i)][0][(int) inst.classValue()] -= inst.weight();
                    } else {
                        counts[inst.index(i)][data.attribute(inst.index(i)).numValues()][numClasses] += inst
                                .weight();
                        counts[inst.index(i)][0][numClasses] -= inst.weight();
                    }
                } else {
                    counts[inst.index(i)][(int) inst.valueSparse(i)][(int) inst.classValue()] += inst.weight();
                    counts[inst.index(i)][0][(int) inst.classValue()] -= inst.weight();
                }
            }
        }
    }

    // distribute missing counts if required
    if (m_missing_merge) {

        for (int k = 0; k < data.numAttributes(); k++) {
            if (k != classIndex) {
                int numValues = data.attribute(k).numValues();

                // Compute marginals
                double[] rowSums = new double[numValues];
                double[] columnSums = new double[numClasses];
                double sum = 0;
                for (int i = 0; i < numValues; i++) {
                    for (int j = 0; j < numClasses; j++) {
                        rowSums[i] += counts[k][i][j];
                        columnSums[j] += counts[k][i][j];
                    }
                    sum += rowSums[i];
                }

                if (Utils.gr(sum, 0)) {
                    double[][] additions = new double[numValues][numClasses];

                    // Compute what needs to be added to each row
                    for (int i = 0; i < numValues; i++) {
                        for (int j = 0; j < numClasses; j++) {
                            additions[i][j] = (rowSums[i] / sum) * counts[k][numValues][j];
                        }
                    }

                    // Compute what needs to be added to each column
                    for (int i = 0; i < numClasses; i++) {
                        for (int j = 0; j < numValues; j++) {
                            additions[j][i] += (columnSums[i] / sum) * counts[k][j][numClasses];
                        }
                    }

                    // Compute what needs to be added to each cell
                    for (int i = 0; i < numClasses; i++) {
                        for (int j = 0; j < numValues; j++) {
                            additions[j][i] += (counts[k][j][i] / sum) * counts[k][numValues][numClasses];
                        }
                    }

                    // Make new contingency table
                    double[][] newTable = new double[numValues][numClasses];
                    for (int i = 0; i < numValues; i++) {
                        for (int j = 0; j < numClasses; j++) {
                            newTable[i][j] = counts[k][i][j] + additions[i][j];
                        }
                    }
                    counts[k] = newTable;
                }
            }
        }
    }

    // Compute info gains
    m_InfoGains = new double[data.numAttributes()];
    m_InfoGains[att] = (ContingencyTables.entropyOverColumns(counts[att])
            - ContingencyTables.entropyConditionedOnRows(counts[att]));

    return m_InfoGains[att];
}

From source file:feature.InfoGainEval.java

License:Open Source License

public void buildEvaluator(Instances data) throws Exception {

    // can evaluator handle data?
    getCapabilities().testWithFail(data);

    int classIndex = data.classIndex();
    int numInstances = data.numInstances();

    if (!m_Binarize) {
        Discretize disTransform = new Discretize();
        disTransform.setUseBetterEncoding(true);
        disTransform.setInputFormat(data);
        data = Filter.useFilter(data, disTransform);
    } else {//from  www. j  a  v a 2  s  .  c om
        NumericToBinary binTransform = new NumericToBinary();
        binTransform.setInputFormat(data);
        data = Filter.useFilter(data, binTransform);
    }
    int numClasses = data.attribute(classIndex).numValues();

    // Reserve space and initialize counters
    double[][][] counts = new double[data.numAttributes()][][];
    for (int k = 0; k < data.numAttributes(); k++) {
        if (k != classIndex) {
            int numValues = data.attribute(k).numValues();
            counts[k] = new double[numValues + 1][numClasses + 1];
        }
    }

    // Initialize counters
    double[] temp = new double[numClasses + 1];
    for (int k = 0; k < numInstances; k++) {
        Instance inst = data.instance(k);
        if (inst.classIsMissing()) {
            temp[numClasses] += inst.weight();
        } else {
            temp[(int) inst.classValue()] += inst.weight();
        }
    }
    for (int k = 0; k < counts.length; k++) {
        if (k != classIndex) {
            for (int i = 0; i < temp.length; i++) {
                counts[k][0][i] = temp[i];
            }
        }
    }

    // Get counts
    for (int k = 0; k < numInstances; k++) {
        Instance inst = data.instance(k);
        for (int i = 0; i < inst.numValues(); i++) {
            if (inst.index(i) != classIndex) {
                if (inst.isMissingSparse(i) || inst.classIsMissing()) {
                    if (!inst.isMissingSparse(i)) {
                        counts[inst.index(i)][(int) inst.valueSparse(i)][numClasses] += inst.weight();
                        counts[inst.index(i)][0][numClasses] -= inst.weight();
                    } else if (!inst.classIsMissing()) {
                        counts[inst.index(i)][data.attribute(inst.index(i)).numValues()][(int) inst
                                .classValue()] += inst.weight();
                        counts[inst.index(i)][0][(int) inst.classValue()] -= inst.weight();
                    } else {
                        counts[inst.index(i)][data.attribute(inst.index(i)).numValues()][numClasses] += inst
                                .weight();
                        counts[inst.index(i)][0][numClasses] -= inst.weight();
                    }
                } else {
                    counts[inst.index(i)][(int) inst.valueSparse(i)][(int) inst.classValue()] += inst.weight();
                    counts[inst.index(i)][0][(int) inst.classValue()] -= inst.weight();
                }
            }
        }
    }

    // distribute missing counts if required
    if (m_missing_merge) {

        for (int k = 0; k < data.numAttributes(); k++) {
            if (k != classIndex) {
                int numValues = data.attribute(k).numValues();

                // Compute marginals
                double[] rowSums = new double[numValues];
                double[] columnSums = new double[numClasses];
                double sum = 0;
                for (int i = 0; i < numValues; i++) {
                    for (int j = 0; j < numClasses; j++) {
                        rowSums[i] += counts[k][i][j];
                        columnSums[j] += counts[k][i][j];
                    }
                    sum += rowSums[i];
                }

                if (Utils.gr(sum, 0)) {
                    double[][] additions = new double[numValues][numClasses];

                    // Compute what needs to be added to each row
                    for (int i = 0; i < numValues; i++) {
                        for (int j = 0; j < numClasses; j++) {
                            additions[i][j] = (rowSums[i] / sum) * counts[k][numValues][j];
                        }
                    }

                    // Compute what needs to be added to each column
                    for (int i = 0; i < numClasses; i++) {
                        for (int j = 0; j < numValues; j++) {
                            additions[j][i] += (columnSums[i] / sum) * counts[k][j][numClasses];
                        }
                    }

                    // Compute what needs to be added to each cell
                    for (int i = 0; i < numClasses; i++) {
                        for (int j = 0; j < numValues; j++) {
                            additions[j][i] += (counts[k][j][i] / sum) * counts[k][numValues][numClasses];
                        }
                    }

                    // Make new contingency table
                    double[][] newTable = new double[numValues][numClasses];
                    for (int i = 0; i < numValues; i++) {
                        for (int j = 0; j < numClasses; j++) {
                            newTable[i][j] = counts[k][i][j] + additions[i][j];
                        }
                    }
                    counts[k] = newTable;
                }
            }
        }
    }

    // Compute info gains
    m_InfoGains = new double[data.numAttributes()];
    for (int i = 0; i < data.numAttributes(); i++) {
        if (i != classIndex) {
            m_InfoGains[i] = (ContingencyTables.entropyOverColumns(counts[i])
                    - ContingencyTables.entropyConditionedOnRows(counts[i]));
        }
    }
}

From source file:ffnn.FFNN.java

/**
 * @param args the command line arguments
 *///w ww  .ja va 2s .co  m
public static void main(String[] args) throws Exception {
    FFNNTubesAI cls;
    Scanner scan = new Scanner(System.in);
    System.out.print("new / read? (n/r)");
    if (scan.next().equals("n")) {
        cls = new FFNNTubesAI();
    } else {
        cls = (FFNNTubesAI) TucilWeka.readModel();
    }
    int temp;
    Instances data = TucilWeka.readDataSet("C:\\Program Files\\Weka-3-8\\data\\Team.arff");
    //Tampilkan opsi
    for (int i = 0; i < data.numAttributes(); i++) {
        System.out.println(i + ". " + data.attribute(i));
    }
    System.out.print("Class Index : ");
    temp = scan.nextInt();
    data.setClassIndex(temp);
    data = preprocess(data);
    System.out.println(data);

    System.out.print("full train? (y/n)");
    if (scan.next().equals("y")) {
        try {
            cls.buildClassifier(data);
        } catch (Exception ex) {
            Logger.getLogger(FFNNTubesAI.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    int fold = 10;

    //FFNNTubesAI.printMatrix(cls.weight1, cls.input_layer+1, cls.hidden_layer);
    //FFNNTubesAI.printMatrix(cls.weight2, cls.hidden_layer, cls.output_layer);
    //FFNNTubesAI.printMatrix(cls.bias2, 1, cls.output_layer);
    Evaluation eval = new Evaluation(data);
    System.out.print("eval/10-fold? (e/f)");
    if (scan.next().equals("e")) {
        eval.evaluateModel(cls, data);
    } else {
        eval.crossValidateModel(cls, data, fold, new Random(1));
    }
    System.out.println(eval.toSummaryString());
    System.out.println(eval.toMatrixString());
    System.out.println(eval.toClassDetailsString());
}