Refine search
@Override public String classify(Instance instance) throws Exception { weka.core.Instance wekaInstance = new weka.core.Instance(wekaTrainingData.numAttributes()); wekaInstance.setDataset(wekaTrainingData); double[] histogramPercent = instance.getHistogramPercent(); for (int i = 0; i < histogramPercent.length; i++) { wekaInstance.setValue(i, histogramPercent[i]); } wekaInstance.setMissing(wekaTrainingData.attribute("class")); double wekaClassification = classifier.classifyInstance(wekaInstance); String classification = wekaTrainingData.attribute("class").value((int)wekaClassification); return classification; }
private Instance makeOutputInstance(Instances output, Instance source) { double[] newVals = new double[output.numAttributes()]; for (int i = 0; i < newVals.length; i++) { newVals[i] = Utils.missingValue(); } for (int i = 0; i < source.numAttributes(); i++) { if (!source.isMissing(i)) { Attribute s = source.attribute(i); int outputIndex = output.attribute(s.name()).index(); if (s.isNumeric()) { newVals[outputIndex] = source.value(s); } else if (s.isString()) { String sVal = source.stringValue(s); newVals[outputIndex] = output.attribute(outputIndex).addStringValue( sVal); } else if (s.isRelationValued()) { Instances rVal = source.relationalValue(s); newVals[outputIndex] = output.attribute(outputIndex) .addRelation(rVal); } else if (s.isNominal()) { String nomVal = source.stringValue(s); newVals[outputIndex] = output.attribute(outputIndex).indexOfValue( nomVal); } } } Instance newInst = new DenseInstance(source.weight(), newVals); newInst.setDataset(output); return newInst; }
/** * The constructor. */ public Bag(Instance bagInstance) { instances = bagInstance.relationalValue(1); positive = bagInstance.classValue() == 1.0; bagWeight = 1.0 / instances.numInstances(); bagWeightMultiplied = bagWeight; id = bagInstance.stringValue(0); }
/** * The constructor. * * @param vals The instance whose value we want to copy. */ public UnsafeInstance(Instance vals) { super(vals.numAttributes()); for (int i = 0; i < vals.numAttributes(); i++) { m_AttValues[i] = vals.value(i); } m_Weight = vals.weight(); }
/** Clear Labels -- set the value of all label attributes to 0.0 */ public static void clearLabels(Instance x) { int L = x.classIndex(); for(int j = 0; j < L; j++) x.setValue(j,0.0); }
/** * Initialize the classifier. * * @param data the training data to be used for generating the boosted * classifier. * @throws Exception if the classifier could not be built successfully */ public void initializeClassifier(Instances data) throws Exception { super.buildClassifier(data); // can classifier handle the data? getCapabilities().testWithFail(data); // remove instances with missing class data = new Instances(data); data.deleteWithMissingClass(); m_ZeroR = new weka.classifiers.rules.ZeroR(); m_ZeroR.buildClassifier(data); m_NumClasses = data.numClasses(); m_Betas = new double[m_Classifiers.length]; m_NumIterationsPerformed = 0; m_TrainingData = new Instances(data); m_RandomInstance = new Random(m_Seed); if ((m_UseResampling) || (!(m_Classifier instanceof WeightedInstancesHandler))) { // Normalize weights so that they sum to one and can be used as sampling probabilities double sumProbs = m_TrainingData.sumOfWeights(); for (int i = 0; i < m_TrainingData.numInstances(); i++) { m_TrainingData.instance(i).setWeight(m_TrainingData.instance(i).weight() / sumProbs); } } }
newInst = new DenseInstance(model.numAttributes()); newInst.setDataset(model); for (int i = 0, j = 0; i < model.numAttributes(); i++) { if (model.attribute(i).isNumeric()) { if (j >= m_Elements.length) throw new Exception("Datatypes are not compatible."); newInst.setValue(i, m_Elements[j++]); if (model.attribute(i).isNominal()) { int newVal = (int) (random.nextDouble() * (double) (model.attribute(i).numValues())); if (newVal == (int) model.attribute(i).numValues()) newVal -= 1; newInst.setValue(i, newVal);
double value = random.nextDouble(); if (format.attribute(i).isNumeric()) { attributes[i] = value; } else { if (format.attribute(i).isNominal()) { attributes[i] = (value > 0.5) ? 1.0 : 0.0; } else { example = new DenseInstance(1.0, attributes); example.setDataset(format); example.setClassMissing();
/** * Generate an example of the dataset. * * @param format the dataset format * @param randomG the random number generator * @param stdDev the standard deviation to use * @param center the centers * @param cName the class value * @return the instance generated examples one by one is not possible, because * voting is chosen */ private Instance generateInstance(Instances format, Random randomG, double stdDev, double[] center, String cName) { Instance example; int numAtts = getNumAttributes(); if (getClassFlag()) { numAtts++; } double[] data = new double[numAtts]; for (int i = 0; i < getNumAttributes(); i++) { data[i] = randomG.nextGaussian() * stdDev + center[i]; } if (getClassFlag()) { data[format.classIndex()] = format.classAttribute().indexOfValue(cName); } example = new DenseInstance(1.0, data); example.setDataset(format); return example; }
/** * Updates the perturbed values for the plots when the jitter value is changed */ private void updatePturb() { double xj = 0; double yj = 0; for (int j = 0; j < m_plots.size(); j++) { PlotData2D temp_plot = (m_plots.get(j)); for (int i = 0; i < temp_plot.m_plotInstances.numInstances(); i++) { if (temp_plot.m_plotInstances.instance(i).isMissing(m_xIndex) || temp_plot.m_plotInstances.instance(i).isMissing(m_yIndex)) { } else { if (m_JitterVal > 0) { xj = m_JRand.nextGaussian(); yj = m_JRand.nextGaussian(); } temp_plot.m_pointLookup[i][2] = pturbX(temp_plot.m_pointLookup[i][0], xj); temp_plot.m_pointLookup[i][3] = pturbY(temp_plot.m_pointLookup[i][1], yj); } } } }
protected Instances convert(Instances D, int j, int k) { int L = D.classIndex(); D = new Instances(D); D.insertAttributeAt(classAttribute,0); D.setClassIndex(0); for(int i = 0; i < D.numInstances(); i++) { String c = (String)((int)Math.round(D.instance(i).value(j+1))+""+(int)Math.round(D.instance(i).value(k+1))); D.instance(i).setClassValue(c); } for (int i = 0; i < L; i++) D.deleteAttributeAt(1); m_InstancesTemplate = new Instances(D,0); return D; }
/** * Sets split point to greatest value in given data smaller or equal to old * split point. (C4.5 does this for some strange reason). */ public final void setSplitPoint(Instances allInstances) { double newSplitPoint = -Double.MAX_VALUE; if ((allInstances.attribute(m_attIndex).isNumeric()) && (m_numSubsets > 1)) { for (int i = 0; i < allInstances.numInstances(); i++) { Instance instance = allInstances.instance(i); double tempValue = instance.value(m_attIndex); if (!Utils.isMissingValue(tempValue)) { if ((tempValue > newSplitPoint) && (tempValue <= m_splitPoint)) { newSplitPoint = tempValue; } } } m_splitPoint = newSplitPoint; } }
/** * Make an output instance given an input one * * @param inputI the input instance to process * @return the output instance with substrings replaced */ public Instance makeOutputInstance(Instance inputI) { double[] vals = new double[m_outputStructure.numAttributes()]; String[] stringVals = new String[m_outputStructure.numAttributes()]; for (int i = 0; i < inputI.numAttributes(); i++) { if (inputI.attribute(i).isString() && !inputI.isMissing(i)) { stringVals[i] = inputI.stringValue(i); } else { vals[i] = inputI.value(i); } } for (SubstringReplacerMatchRule mr : m_matchRules) { mr.apply(stringVals); } for (int i = 0; i < m_outputStructure.numAttributes(); i++) { if (m_outputStructure.attribute(i).isString() && stringVals[i] != null) { m_outputStructure.attribute(i).setStringValue(stringVals[i]); } } Instance result = new DenseInstance(inputI.weight(), vals); result.setDataset(m_outputStructure); return result; }
public void testSubtract() { m_Filter = getFilter("a3-a6"); Instances result = useFilter(); for (int i = 0; i < result.numInstances(); i++) { Instance inst = result.instance(i); assertEquals("Instance " + (i + 1), inst.value(2) - inst.value(5), inst.value(inst.numAttributes() - 1), EXPR_DELTA); } }
/** * Makes a level-1 instance from the given instance. * * @param instance the instance to be transformed * @return the level-1 instance * @throws Exception if the instance generation fails */ protected Instance metaInstance(Instance instance) throws Exception { double[] values = new double[m_MetaFormat.numAttributes()]; Instance metaInstance; int i = 0; for (int k = 0; k < m_Classifiers.length; k++) { Classifier classifier = getClassifier(k); if (m_BaseFormat.classAttribute().isNumeric()) { values[i++] = classifier.classifyInstance(instance); } else { double[] dist = classifier.distributionForInstance(instance); for (int j = 0; j < dist.length; j++) { values[i++] = dist[j]; } } } values[i] = instance.classValue(); metaInstance = new DenseInstance(1, values); metaInstance.setDataset(m_MetaFormat); return metaInstance; }
@Override public Instances getDataSet() throws IOException { if (m_sourceFile == null) { throw new IOException("No source has been specified"); } if (getRetrieval() == INCREMENTAL) { throw new IOException("This loader cannot load instances incrementally."); } setRetrieval(BATCH); if (m_structure == null) { getStructure(); } Instances result = new Instances(m_structure); for (String word : vec.getVocab().words()) { double[] values = new double[result.numAttributes()]; for (int i = 0; i < this.vec.getWordVector(word).length; i++) values[i] = this.vec.getWordVector(word)[i]; values[result.numAttributes() - 1] = result.attribute("word_id").addStringValue(word); Instance inst = new DenseInstance(1, values); inst.setDataset(result); result.add(inst); } return result; }
protected MultiLabelOutput makePredictionInternal(Instance instance) throws Exception { double[] confidences = new double[numLabels]; boolean[] bipartition = new boolean[numLabels]; Instance newInstance = pt6Trans.transformInstance(instance); //calculate confidences //debug(instance.toString()); for (int i = 0; i < numLabels; i++) { newInstance.setDataset(transformed); newInstance.setValue(newInstance.numAttributes() - 2, instance.dataset().attribute(labelIndices[i]).name()); //debug(newInstance.toString()); double[] temp = baseClassifier.distributionForInstance(newInstance); //debug(temp.toString()); confidences[i] = temp[transformed.classAttribute().indexOfValue("1")]; //debug("" + confidences[i]); bipartition[i] = temp[transformed.classAttribute().indexOfValue("1")] >= temp[transformed.classAttribute().indexOfValue("0")] ? true : false; //debug("" + bipartition[i]); } MultiLabelOutput mlo = new MultiLabelOutput(bipartition, confidences); return mlo; } }
/** * Convert a list of Results into an Instances. * @param results An ArrayList of Results * @return Instances */ public static Instances getResultsAsInstances(ArrayList<HashMap<String,Object>> metrics) { HashMap<String,Object> o_master = metrics.get(0); ArrayList<Attribute> attInfo = new ArrayList<Attribute>(); for (String key : o_master.keySet()) { if (o_master.get(key) instanceof Double) { //System.out.println("key="+key); attInfo.add(new Attribute(key)); } } Instances resultInstances = new Instances("Results",attInfo,metrics.size()); for (HashMap<String,Object> o : metrics) { Instance rx = new DenseInstance(attInfo.size()); for (Attribute att : attInfo) { String name = att.name(); rx.setValue(att,(double)o.get(name)); } resultInstances.add(rx); } //System.out.println(""+resultInstances); return resultInstances; }