Example usage for weka.core Instances instance

List of usage examples for weka.core Instances instance

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

Introduction

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

Prototype



publicInstance instance(int index)

Source Link

Document

Returns the instance at the given position.

Usage

From source file:cezeri.utils.FactoryInstance.java

/**
 *
 * @param m tm dataset/*w  w  w.  ja v  a  2 s  .  c  om*/
 * @param val class value deeri val olanlar filtrele
 * @return
 */
public static Instances[] getSpecificInstancesBasedOnClassValue(Instances m, String[] cl) {
    Instances[] ret = new Instances[cl.length];
    for (int i = 0; i < ret.length; i++) {
        ret[i] = FactoryInstance.generateInstances(m.relationName() + "_class=" + cl[i], m.numAttributes());
        //            ret[i] = m.resampleWithWeights(new Random());
        ret[i].delete();
    }
    for (int i = 0; i < m.numInstances(); i++) {
        Instance ins = m.instance(i);
        for (int j = 0; j < cl.length; j++) {
            if (("" + (int) ins.classValue()).equals(cl[j])) {
                ret[j].add(ins);
            }
        }
    }
    return ret;
}

From source file:cezeri.utils.FactoryInstance.java

public static double[] getClassData(Instances m) {
    double[] ret = new double[m.numInstances()];
    for (int i = 0; i < m.numInstances(); i++) {
        Instance ins = m.instance(i);
        ret[i] = ins.classValue();/*from   www  .  java 2 s  .  c  o  m*/
    }
    return ret;
}

From source file:cezeri.utils.FactoryInstance.java

public static double[] getClassData(Instances m, int val) {
    Vector v = new Vector();
    for (int i = 0; i < m.numInstances(); i++) {
        Instance ins = m.instance(i);
        if ((int) ins.classValue() == val) {
            v.add(ins.classValue());/*w  ww  .j  ava2 s.com*/
        }
    }
    double[] ret = FactoryUtils.toDoubleArray(v);
    return ret;
}

From source file:ChiSquare.ChiSquaredAttributeEval.java

License:Open Source License

/**
 * Initializes a chi-squared attribute evaluator.
 * Discretizes all attributes that are numeric.
 *
 * @param data set of instances serving as training data 
 * @throws Exception if the evaluator has not been 
 * generated successfully//from  www.  ja v  a 2 s  .  c o m
 */
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 {
        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 chi-squared values
    m_ChiSquareds = new double[data.numAttributes()];
    for (int i = 0; i < data.numAttributes(); i++) {
        if (i != classIndex) {
            m_ChiSquareds[i] = ContingencyTables.chiVal(ContingencyTables.reduceMatrix(counts[i]), false);
        }
    }
}

From source file:Clases.RedNeuronal.RedNeuronal.java

public void redNeuronal(int puntaje, int tiempo, int error) throws Exception {
    //si puntaje >= 200 entonces aprendido
    //si tiempo <= 240 (4 minutos) entonces aprendido
    //si errores <= 3 entonces aprendido
    String[] dato = { obtnerPuntaje(puntaje), obtenerTiempo(tiempo), obtenerErrores(error) };

    ConverterUtils.DataSource con = new ConverterUtils.DataSource(
            "C:\\Users\\USUARIO\\Documents\\SILVIIS\\10 Modulo\\2.ANTEPROYECTOS DE TESIS\\Proyecto\\Aplicacion\\redeAprendizaje.arff");
    //        ConverterUtils.DataSource con = new ConverterUtils.DataSource("E:\\Unl\\10 Modulo\\2.ANTEPROYECTOS DE TESIS\\Proyecto\\Aplicacion\\redeAprendizaje.arff");

    Instances instances = con.getDataSet();
    System.out.println(instances);
    instances.setClassIndex(instances.numAttributes() - 1);

    MultilayerPerceptron mp = new MultilayerPerceptron();
    mp.buildClassifier(instances);//from  ww w.j av  a  2  s  .  c  o m

    Evaluation evalucion = new Evaluation(instances);
    evalucion.evaluateModel(mp, instances);
    System.out.println(evalucion.toSummaryString());
    System.out.println(evalucion.toMatrixString());

    String datosEntrada = null;
    String datosSalida = "no se puede predecir";
    for (int i = 0; i < instances.numInstances(); i++) {
        double predecido = mp.classifyInstance(instances.instance(i));
        datosEntrada = dato[0] + " " + dato[1] + " " + dato[2];
        if ((int) instances.instance(i).value(0) == Integer.parseInt(dato[0])
                && (int) instances.instance(i).value(1) == Integer.parseInt(dato[1])
                && (int) instances.instance(i).value(2) == Integer.parseInt(dato[2])) {
            datosSalida = instances.classAttribute().value((int) predecido);
        }
    }
    System.out.println("DATOS DE ENTRADA: " + datosEntrada);
    System.out.println("SALIDA PREDECIDA: " + datosSalida);

    switch (datosSalida) {
    case "0":
        resultado = "Excelente ha aprendido";
        imgResultado = "Excelente.jpg";
        imgREDneuronal = "0.png";
        System.out.println("Excelente ha aprendido");
        break;
    case "1":
        resultado = "Disminuir Errores";
        imgResultado = "Bueno.jpg";
        imgREDneuronal = "1.png";
        System.out.println("Disminuir Errores");
        break;
    case "2":
        resultado = "Disminuir Tiempo";
        imgResultado = "Bueno.jpg";
        imgREDneuronal = "2.png";
        System.out.println("Disminuir Tiempo");
        break;
    case "3":
        resultado = "Disminuir Errores y tiempo";
        imgResultado = "Bueno.jpg";
        imgREDneuronal = "3.png";
        System.out.println("Disminuir Errores y tiempo");
        break;
    case "4":
        resultado = "Subir Puntaje";
        imgResultado = "pensando.jpg";
        imgREDneuronal = "4.png";
        System.out.println("Subir Puntaje");
        break;
    case "5":
        resultado = "Subir Puntaje y disminuir Errores";
        imgResultado = "pensando.jpg";
        imgREDneuronal = "5.png";
        System.out.println("Subir Puntaje y disminuir Errores");
        break;
    case "6":
        resultado = "Subir Puntaje y disminuir Tiempo";
        imgResultado = "pensando.jpg";
        imgREDneuronal = "6.png";
        System.out.println("Subir Puntaje y disminuir Tiempo");
        break;
    case "7":
        resultado = "Ponle mas Empeo";
        imgResultado = "pensando.jpg";
        imgREDneuronal = "7.png";
        System.out.println("Ponle mas Empeo");
        break;
    default:
        resultado = "Verifique entradas, no se puede predecir";
        imgResultado = "Error.jpg";
        System.out.println("Verifique entradas, no se puede predecir");
        break;
    }
}

From source file:clasificacion.Clasificacion.java

public String clasificar(String[] testCases) throws Exception {
    String ruta = "nursery_model.model";

    InputStream classModelStream;
    classModelStream = getClass().getResourceAsStream(ruta);
    //classModel = (Classifier)SerializationHelper.read(classModelStream);
    Classifier clasify = (Classifier) SerializationHelper.read(classModelStream);

    FastVector parents = new FastVector();
    parents.addElement("usual");
    parents.addElement("pretentious");
    parents.addElement("great_pret");
    Attribute _parent = new Attribute("parents", parents);

    FastVector nurs = new FastVector();
    nurs.addElement("proper");
    nurs.addElement("less_proper");
    nurs.addElement("improper");
    nurs.addElement("critical");
    nurs.addElement("very_crit");
    Attribute _has_nurs = new Attribute("has_nurs", nurs);

    FastVector form = new FastVector();
    form.addElement("complete");
    form.addElement("completed");
    form.addElement("incomplete");
    form.addElement("foster");
    Attribute _form = new Attribute("form", form);

    FastVector children = new FastVector();
    children.addElement("1");
    children.addElement("2");
    children.addElement("3");
    children.addElement("more");
    Attribute _children = new Attribute("children", children);

    FastVector housing = new FastVector();
    housing.addElement("convenient");
    housing.addElement("less_conv");
    housing.addElement("critical");
    Attribute _housing = new Attribute("housing", housing);

    FastVector finance = new FastVector();
    finance.addElement("convenient");
    finance.addElement("inconv");
    Attribute _finance = new Attribute("finance", finance);

    FastVector social = new FastVector();
    social.addElement("nonprob");
    social.addElement("slightly_prob");
    social.addElement("problematic");
    Attribute _social = new Attribute("social", social);

    FastVector health = new FastVector();
    health.addElement("recommended");
    health.addElement("priority");
    health.addElement("not_recom");
    Attribute _health = new Attribute("health", health);

    FastVector Class = new FastVector();
    Class.addElement("not_recom");
    Class.addElement("recommend");
    Class.addElement("very_recom");
    Class.addElement("priority");
    Class.addElement("spec_prior");
    Attribute _Class = new Attribute("class", Class);

    FastVector atributos = new FastVector(9);
    atributos.addElement(_parent);/*from  ww w.j a  v a 2 s . c  om*/
    atributos.addElement(_has_nurs);
    atributos.addElement(_form);
    atributos.addElement(_children);
    atributos.addElement(_housing);
    atributos.addElement(_finance);
    atributos.addElement(_social);
    atributos.addElement(_health);
    atributos.addElement(_Class);

    ArrayList<Attribute> atributs = new ArrayList<>();
    atributs.add(_parent);
    atributs.add(_has_nurs);
    atributs.add(_form);
    atributs.add(_children);
    atributs.add(_housing);
    atributs.add(_finance);
    atributs.add(_social);
    atributs.add(_health);
    atributs.add(_Class);

    //Aqu se crea la instacia, que tiene todos los atributos del modelo
    Instances dataTest = new Instances("TestCases", atributos, 1);
    dataTest.setClassIndex(8);

    Instance setPrueba = new Instance(9);

    int index = -1;
    for (int i = 0; i < 8; i++) {
        index = atributs.get(i).indexOfValue(testCases[i]);
        //System.out.println(i + " " + atributs.get(i)  + " " + index + " " + testCases[i]);
        setPrueba.setValue(atributs.get(i), index);
    }

    //Agregando el set que se desea evaluar.
    dataTest.add(setPrueba);

    //Realizando la Prediccin
    //La instancia es la 0 debido a que es la unica que se encuentra.
    double valorP = clasify.classifyInstance(dataTest.instance(0));
    //get the name of the class value
    String prediccion = dataTest.classAttribute().value((int) valorP);

    return prediccion;
}

From source file:classif.Prototyper.java

License:Open Source License

@Override
public void buildClassifier(Instances data) throws Exception {
    trainingData = data;// ww  w  .  j ava  2  s .  c om
    Attribute classAttribute = data.classAttribute();
    prototypes = new ArrayList<>();

    classedData = new HashMap<String, ArrayList<Sequence>>();
    indexClassedDataInFullData = new HashMap<String, ArrayList<Integer>>();
    for (int c = 0; c < data.numClasses(); c++) {
        classedData.put(data.classAttribute().value(c), new ArrayList<Sequence>());
        indexClassedDataInFullData.put(data.classAttribute().value(c), new ArrayList<Integer>());
    }

    sequences = new Sequence[data.numInstances()];
    classMap = new String[sequences.length];
    for (int i = 0; i < sequences.length; i++) {
        Instance sample = data.instance(i);
        MonoDoubleItemSet[] sequence = new MonoDoubleItemSet[sample.numAttributes() - 1];
        int shift = (sample.classIndex() == 0) ? 1 : 0;
        for (int t = 0; t < sequence.length; t++) {
            sequence[t] = new MonoDoubleItemSet(sample.value(t + shift));
        }
        sequences[i] = new Sequence(sequence);
        String clas = sample.stringValue(classAttribute);
        classMap[i] = clas;
        classedData.get(clas).add(sequences[i]);
        indexClassedDataInFullData.get(clas).add(i);
        //         System.out.println("Element "+i+" of train is classed "+clas+" and went to element "+(indexClassedDataInFullData.get(clas).size()-1));
    }

    buildSpecificClassifier(data);

    if (fillPrototypes)
        addMissingPrototypesRandom();
}

From source file:classif.Prototyper.java

License:Open Source License

public static ClassedSequence[] convertWekaSetToClassedSequence(Instances test) {

    Attribute classAttribute = test.classAttribute();
    ClassedSequence[] testSequences = new ClassedSequence[test.numInstances()];
    for (int i = 0; i < testSequences.length; i++) {
        Instance sample = test.instance(i);
        MonoDoubleItemSet[] sequence = new MonoDoubleItemSet[sample.numAttributes() - 1];
        int shift = (sample.classIndex() == 0) ? 1 : 0;
        for (int t = 0; t < sequence.length; t++) {
            sequence[t] = new MonoDoubleItemSet(sample.value(t + shift));
        }//from w  w  w  . ja  v a 2s . c om
        String clas = sample.stringValue(classAttribute);
        testSequences[i] = new ClassedSequence(new Sequence(sequence), clas);
    }

    return testSequences;

}

From source file:classification.classifiers.LDA.java

License:Open Source License

/**
 * Modification on Dr. Wolfgang Lenhard's code.
 * This was necessary because this classifier had to implements
 * "buildClassifier" and "classifyInstance" to be like a classifier of WEKA(R).
 * /*from  w  w w  .  j a  v  a 2  s .c o m*/
 * @param data
 * @throws Exception
 */
public void buildClassifier(Instances data) throws Exception {
    int n = data.numInstances();
    int a = data.numAttributes();
    int k = data.numClasses();
    int[] g = new int[n];

    double[][] d = new double[n][a];
    for (int i = 0; i < n; i++) {
        double[] d_i = data.instance(i).toDoubleArray();
        d[i] = d_i;

        /**
         * To print the attribute with the correspondent double
         *
         * System.out.print("\n"); for(int j=0; j<a; j++){
         * System.out.print(data.instance(i).stringValue(data.attribute(j))
         * + " = ");
         * System.out.print(data.instance(i).value(data.attribute(j)) +
         * ";  "); } System.out.print("\n"); /
         **/
    }

    // Gives the number of objects belonging to class i in the trainingSet.
    int classIndex = a - 1;
    valueClass = new double[k];

    data.setClassIndex(classIndex);

    for (int i = 0; i < k; i++) {
        // Reference class
        String refClass = data.classAttribute().value(i);
        //
        // System.out.println("refClass: " + refClass + " ");

        for (int j = 0; j < n; j++) {
            // Object class
            String objectClass = data.instance(j).stringValue(classIndex);
            //
            // System.out.println("objectClass: " + objectClass + " - value:
            // " + data.instance(j).value(data.attribute(classIndex)));

            // Building two vectors of classes, one in int format and
            // another in double format.
            if (objectClass == refClass) {

                // Object class as a double
                valueClass[i] = data.instance(j).value(data.attribute(classIndex));
                // Object class as an int
                g[j] = i;

                //
                // System.out.println("value of class (int): " + g[j] + "
                // ___ value (double): " + valueClass[i]);
            }
        }

    }

    this.BuildLDA(d, g, true);
}

From source file:Classifiers.BRkNN.java

License:Open Source License

/**
 * Select the best value for k by hold-one-out cross-validation. Hamming
 * Loss is minimized//from  w w w. ja va  2  s  .c o m
 *
 * @throws Exception Potential exception thrown. To be handled in an upper level.
 */
private void crossValidate() throws Exception {
    try {
        // the performance for each different k
        double[] hammingLoss = new double[cvMaxK];

        for (int i = 0; i < cvMaxK; i++) {
            hammingLoss[i] = 0;
        }

        Instances dataSet = train;
        Instance instance; // the hold out instance
        Instances neighbours; // the neighboring instances
        double[] origDistances, convertedDistances;
        for (int i = 0; i < dataSet.numInstances(); i++) {
            if (getDebug() && (i % 50 == 0)) {
                debug("Cross validating " + i + "/" + dataSet.numInstances() + "\r");
            }
            instance = dataSet.instance(i);
            neighbours = lnn.kNearestNeighbours(instance, cvMaxK);
            origDistances = lnn.getDistances();

            // gathering the true labels for the instance
            boolean[] trueLabels = new boolean[numLabels];
            for (int counter = 0; counter < numLabels; counter++) {
                int classIdx = labelIndices[counter];
                String classValue = instance.attribute(classIdx).value((int) instance.value(classIdx));
                trueLabels[counter] = classValue.equals("1");
            }
            // calculate the performance metric for each different k
            for (int j = cvMaxK; j > 0; j--) {
                convertedDistances = new double[origDistances.length];
                System.arraycopy(origDistances, 0, convertedDistances, 0, origDistances.length);
                double[] confidences = this.getConfidences(neighbours, convertedDistances);
                boolean[] bipartition = null;

                switch (extension) {
                case NONE: // BRknn
                    MultiLabelOutput results;
                    results = new MultiLabelOutput(confidences, 0.5);
                    bipartition = results.getBipartition();
                    break;
                case EXTA: // BRknn-a
                    bipartition = labelsFromConfidences2(confidences);
                    break;
                case EXTB: // BRknn-b
                    bipartition = labelsFromConfidences3(confidences);
                    break;
                }

                double symmetricDifference = 0; // |Y xor Z|
                for (int labelIndex = 0; labelIndex < numLabels; labelIndex++) {
                    boolean actual = trueLabels[labelIndex];
                    boolean predicted = bipartition[labelIndex];

                    if (predicted != actual) {
                        symmetricDifference++;
                    }
                }
                hammingLoss[j - 1] += (symmetricDifference / numLabels);

                neighbours = new IBk().pruneToK(neighbours, convertedDistances, j - 1);
            }
        }

        // Display the results of the cross-validation
        if (getDebug()) {
            for (int i = cvMaxK; i > 0; i--) {
                debug("Hold-one-out performance of " + (i) + " neighbors ");
                debug("(Hamming Loss) = " + hammingLoss[i - 1] / dataSet.numInstances());
            }
        }

        // Check through the performance stats and select the best
        // k value (or the lowest k if more than one best)
        double[] searchStats = hammingLoss;

        double bestPerformance = Double.NaN;
        int bestK = 1;
        for (int i = 0; i < cvMaxK; i++) {
            if (Double.isNaN(bestPerformance) || (bestPerformance > searchStats[i])) {
                bestPerformance = searchStats[i];
                bestK = i + 1;
            }
        }
        numOfNeighbors = bestK;
        if (getDebug()) {
            System.err.println("Selected k = " + bestK);
        }

    } catch (Exception ex) {
        throw new Error("Couldn't optimize by cross-validation: " + ex.getMessage());
    }
}