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:br.com.ufu.lsi.rebfnetwork.RBFModel.java

License:Open Source License

/**
 * Calculates partial derivatives in the case of one sigma (either globally or per unit).
 *//* ww w  .  ja v a  2s .co m*/
protected double derivativeOneScale(double[] grad, double[] deltaHidden, double scale, Instance inst,
        int unitIndex) {

    double constant = deltaHidden[unitIndex] / (scale * scale);
    double sumDiffSquared = 0;
    int offsetC = OFFSET_CENTERS + (unitIndex * m_numAttributes);
    double attWeight = 1.0;
    for (int j = 0; j < m_classIndex; j++) {
        double diff = (inst.value(j) - m_RBFParameters[offsetC + j]);
        double diffSquared = diff * diff;
        if (m_useAttributeWeights) {
            attWeight = m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j]
                    * m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j];
            grad[OFFSET_ATTRIBUTE_WEIGHTS + j] -= m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j] * constant
                    * diffSquared;
        }
        sumDiffSquared += attWeight * diffSquared;
        grad[offsetC + j] += constant * attWeight * diff;
    }
    for (int j = m_classIndex + 1; j < m_numAttributes; j++) {
        double diff = (inst.value(j) - m_RBFParameters[offsetC + j]);
        double diffSquared = diff * diff;
        if (m_useAttributeWeights) {
            attWeight = m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j]
                    * m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j];
            grad[OFFSET_ATTRIBUTE_WEIGHTS + j] -= m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j] * constant
                    * diffSquared;
        }
        sumDiffSquared += attWeight * diffSquared;
        grad[offsetC + j] += constant * attWeight * diff;
    }
    return constant * sumDiffSquared / scale;
}

---

From source file:br.com.ufu.lsi.rebfnetwork.RBFModel.java

License:Open Source License

/**
 * The exponent of the RBF in the case of a different sigma per attribute and unit.
 *//*from w  w  w . ja  va 2 s  .  c  o  m*/
protected double sumSquaredDiffScalePerAttribute(Instance inst, int unitIndex) {

    int offsetS = OFFSET_SCALES + unitIndex * m_numAttributes;
    int offsetC = OFFSET_CENTERS + unitIndex * m_numAttributes;
    double sumSquaredDiff = 0;
    for (int j = 0; j < m_classIndex; j++) {
        double diff = m_RBFParameters[offsetC + j] - inst.value(j);
        if (m_useAttributeWeights) {
            diff *= m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j];
        }
        sumSquaredDiff += diff * diff / (2 * m_RBFParameters[offsetS + j] * m_RBFParameters[offsetS + j]);
    }
    for (int j = m_classIndex + 1; j < m_numAttributes; j++) {
        double diff = m_RBFParameters[offsetC + j] - inst.value(j);
        if (m_useAttributeWeights) {
            diff *= m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j];
        }
        sumSquaredDiff += diff * diff / (2 * m_RBFParameters[offsetS + j] * m_RBFParameters[offsetS + j]);
    }
    return sumSquaredDiff;
}

---

From source file:br.com.ufu.lsi.rebfnetwork.RBFModel.java

License:Open Source License

/**
 * The exponent of the RBF in the case of a fixed sigma per unit.
 *//*from   w  w w  .  j  a v  a2  s .co  m*/
protected double sumSquaredDiffOneScale(double scale, Instance inst, int unitIndex) {

    int offsetC = OFFSET_CENTERS + unitIndex * m_numAttributes;
    double sumSquaredDiff = 0;
    for (int j = 0; j < m_classIndex; j++) {
        double diff = m_RBFParameters[offsetC + j] - inst.value(j);
        if (m_useAttributeWeights) {
            diff *= m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j];
        }
        sumSquaredDiff += diff * diff;
    }
    for (int j = m_classIndex + 1; j < m_numAttributes; j++) {
        double diff = m_RBFParameters[offsetC + j] - inst.value(j);
        if (m_useAttributeWeights) {
            diff *= m_RBFParameters[OFFSET_ATTRIBUTE_WEIGHTS + j];
        }
        sumSquaredDiff += diff * diff;
    }
    return sumSquaredDiff / (2 * scale * scale);
}

---

From source file:br.preprocess.forms.ReducaoPCA.java

public void changeChart(int indexX, int indexY) {
    if (indexX > -1 && indexY > -1) {
        this.ch.clear();
        for (int i = 0; i < this.pca.getDataset().getNumClass(); i++)
            for (Instance sample : this.pca.getDataset().getDataset())
                if (sample.value(sample.classIndex()) == i)
                    this.ch.update(sample.value(indexX), sample.value(indexY), i);
        Utils.addPlot(this.redChart, this.ch);
    }// w  ww  . ja  v  a2  s  .  com
}

---

From source file:br.ufrn.ia.core.clustering.EMIaProject.java

License:Open Source License

private void EM_Init(Instances inst) throws Exception {
    int i, j, k;//from w w  w.  java 2s.co m

    // run k means 10 times and choose best solution
    SimpleKMeans bestK = null;
    double bestSqE = Double.MAX_VALUE;
    for (i = 0; i < 10; i++) {
        SimpleKMeans sk = new SimpleKMeans();
        sk.setSeed(m_rr.nextInt());
        sk.setNumClusters(m_num_clusters);
        sk.setDisplayStdDevs(true);
        sk.buildClusterer(inst);
        if (sk.getSquaredError() < bestSqE) {
            bestSqE = sk.getSquaredError();
            bestK = sk;
        }
    }

    // initialize with best k-means solution
    m_num_clusters = bestK.numberOfClusters();
    m_weights = new double[inst.numInstances()][m_num_clusters];
    m_model = new DiscreteEstimator[m_num_clusters][m_num_attribs];
    m_modelNormal = new double[m_num_clusters][m_num_attribs][3];
    m_priors = new double[m_num_clusters];
    Instances centers = bestK.getClusterCentroids();
    Instances stdD = bestK.getClusterStandardDevs();
    double[][][] nominalCounts = bestK.getClusterNominalCounts();
    double[] clusterSizes = bestK.getClusterSizes();

    for (i = 0; i < m_num_clusters; i++) {
        Instance center = centers.instance(i);
        for (j = 0; j < m_num_attribs; j++) {
            if (inst.attribute(j).isNominal()) {
                m_model[i][j] = new DiscreteEstimator(m_theInstances.attribute(j).numValues(), true);
                for (k = 0; k < inst.attribute(j).numValues(); k++) {
                    m_model[i][j].addValue(k, nominalCounts[i][j][k]);
                }
            } else {
                double minStdD = (m_minStdDevPerAtt != null) ? m_minStdDevPerAtt[j] : m_minStdDev;
                double mean = (center.isMissing(j)) ? inst.meanOrMode(j) : center.value(j);
                m_modelNormal[i][j][0] = mean;
                double stdv = (stdD.instance(i).isMissing(j))
                        ? ((m_maxValues[j] - m_minValues[j]) / (2 * m_num_clusters))
                        : stdD.instance(i).value(j);
                if (stdv < minStdD) {
                    stdv = inst.attributeStats(j).numericStats.stdDev;
                    if (Double.isInfinite(stdv)) {
                        stdv = minStdD;
                    }
                    if (stdv < minStdD) {
                        stdv = minStdD;
                    }
                }
                if (stdv <= 0) {
                    stdv = m_minStdDev;
                }

                m_modelNormal[i][j][1] = stdv;
                m_modelNormal[i][j][2] = 1.0;
            }
        }
    }

    for (j = 0; j < m_num_clusters; j++) {
        // m_priors[j] += 1.0;
        m_priors[j] = clusterSizes[j];
    }
    Utils.normalize(m_priors);
}

---

From source file:br.ufrn.ia.core.clustering.EMIaProject.java

License:Open Source License

public double[] logDensityPerClusterForInstance(Instance inst) throws Exception {

    int i, j;/*from  w w  w.ja  va2 s.  c  o m*/
    double logprob;
    double[] wghts = new double[m_num_clusters];

    m_replaceMissing.input(inst);
    inst = m_replaceMissing.output();

    for (i = 0; i < m_num_clusters; i++) {
        // System.err.println("Cluster : "+i);
        logprob = 0.0;

        for (j = 0; j < m_num_attribs; j++) {
            if (!inst.isMissing(j)) {
                if (inst.attribute(j).isNominal()) {
                    logprob += Math.log(m_model[i][j].getProbability(inst.value(j)));
                } else { // numeric attribute
                    logprob += logNormalDens(inst.value(j), m_modelNormal[i][j][0], m_modelNormal[i][j][1]);
                    /*
                     * System.err.println(logNormalDens(inst.value(j),
                     * m_modelNormal[i][j][0], m_modelNormal[i][j][1]) +
                     * " ");
                     */
                }
            }
        }
        // System.err.println("");

        wghts[i] = logprob;
    }
    return wghts;
}

---

From source file:br.ufrn.ia.core.clustering.EMIaProject.java

License:Open Source License

private void M(Instances inst) throws Exception {

    int i, j, l;/*  w  ww .j a  v  a  2s .co m*/

    new_estimators();

    for (i = 0; i < m_num_clusters; i++) {
        for (j = 0; j < m_num_attribs; j++) {
            for (l = 0; l < inst.numInstances(); l++) {
                Instance in = inst.instance(l);
                if (!in.isMissing(j)) {
                    if (inst.attribute(j).isNominal()) {
                        m_model[i][j].addValue(in.value(j), in.weight() * m_weights[l][i]);
                    } else {
                        m_modelNormal[i][j][0] += (in.value(j) * in.weight() * m_weights[l][i]);
                        m_modelNormal[i][j][2] += in.weight() * m_weights[l][i];
                        m_modelNormal[i][j][1] += (in.value(j) * in.value(j) * in.weight() * m_weights[l][i]);
                    }
                }
            }
        }
    }

    // calcualte mean and std deviation for numeric attributes
    for (j = 0; j < m_num_attribs; j++) {
        if (!inst.attribute(j).isNominal()) {
            for (i = 0; i < m_num_clusters; i++) {
                if (m_modelNormal[i][j][2] <= 0) {
                    m_modelNormal[i][j][1] = Double.MAX_VALUE;
                    // m_modelNormal[i][j][0] = 0;
                    m_modelNormal[i][j][0] = m_minStdDev;
                } else {

                    // variance
                    m_modelNormal[i][j][1] = (m_modelNormal[i][j][1]
                            - (m_modelNormal[i][j][0] * m_modelNormal[i][j][0] / m_modelNormal[i][j][2]))
                            / (m_modelNormal[i][j][2]);

                    if (m_modelNormal[i][j][1] < 0) {
                        m_modelNormal[i][j][1] = 0;
                    }

                    // std dev
                    double minStdD = (m_minStdDevPerAtt != null) ? m_minStdDevPerAtt[j] : m_minStdDev;

                    m_modelNormal[i][j][1] = Math.sqrt(m_modelNormal[i][j][1]);

                    if ((m_modelNormal[i][j][1] <= minStdD)) {
                        m_modelNormal[i][j][1] = inst.attributeStats(j).numericStats.stdDev;
                        if ((m_modelNormal[i][j][1] <= minStdD)) {
                            m_modelNormal[i][j][1] = minStdD;
                        }
                    }
                    if ((m_modelNormal[i][j][1] <= 0)) {
                        m_modelNormal[i][j][1] = m_minStdDev;
                    }
                    if (Double.isInfinite(m_modelNormal[i][j][1])) {
                        m_modelNormal[i][j][1] = m_minStdDev;
                    }

                    // mean
                    m_modelNormal[i][j][0] /= m_modelNormal[i][j][2];
                }
            }
        }
    }
}

---

From source file:br.ufrn.ia.core.clustering.EMIaProject.java

License:Open Source License

private void updateMinMax(Instance instance) {

    for (int j = 0; j < m_theInstances.numAttributes(); j++) {
        if (!instance.isMissing(j)) {
            if (Double.isNaN(m_minValues[j])) {
                m_minValues[j] = instance.value(j);
                m_maxValues[j] = instance.value(j);
            } else {
                if (instance.value(j) < m_minValues[j]) {
                    m_minValues[j] = instance.value(j);
                } else {
                    if (instance.value(j) > m_maxValues[j]) {
                        m_maxValues[j] = instance.value(j);
                    }//  www. jav  a 2 s  . com
                }
            }
        }
    }
}

---

From source file:cba.ItemSet.java

License:Open Source License

/**
 * Checks if an instance contains an item set.
 *
 * @param instance the instance to be tested
 * @return true if the given instance contains this item set
 *///  w w w.  j a v a2 s  .  com

public boolean containedBy(Instance instance) {

    if (instance instanceof weka.core.SparseInstance && m_treatZeroAsMissing) {
        int numInstVals = instance.numValues();
        int numItemSetVals = m_items.length;

        for (int p1 = 0, p2 = 0; p1 < numInstVals || p2 < numItemSetVals;) {
            int instIndex = Integer.MAX_VALUE;
            if (p1 < numInstVals) {
                instIndex = instance.index(p1);
            }
            int itemIndex = p2;

            if (m_items[itemIndex] > -1) {
                if (itemIndex != instIndex) {
                    return false;
                } else {
                    if (instance.isMissingSparse(p1)) {
                        return false;
                    }
                    if (m_items[itemIndex] != (int) instance.valueSparse(p1)) {
                        return false;
                    }
                }

                p1++;
                p2++;
            } else {
                if (itemIndex < instIndex) {
                    p2++;
                } else if (itemIndex == instIndex) {
                    p2++;
                    p1++;
                }
            }
        }
    } else {
        for (int i = 0; i < instance.numAttributes(); i++)
            if (m_items[i] > -1) {
                if (instance.isMissing(i) || (m_treatZeroAsMissing && (int) instance.value(i) == 0))
                    return false;
                if (m_items[i] != (int) instance.value(i))
                    return false;
            }
    }

    return true;
}

---

From source file:cerebro.Id3.java

License:Open Source License

/**
 * Classifies a given test instance using the decision tree.
 *
 * @param instance the instance to be classified
 * @return the classification//from   w w  w. jav a 2 s .com
 * @throws NoSupportForMissingValuesException if instance has missing values
 */
public double classifyInstance(Instance instance) throws NoSupportForMissingValuesException {

    if (instance.hasMissingValue()) {
        throw new NoSupportForMissingValuesException("Id3: no missing values, " + "please.");
    }
    if (m_Attribute == null) {
        return m_ClassValue;
    } else {
        return m_Successors[(int) instance.value(m_Attribute)].classifyInstance(instance);
    }
}

---

• «
• 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
• »