Refine search
/** * Adds random instances to the dataset. * * @param dataset the dataset * @param numInstances the number of instances * @param random a random number generator */ protected void addRandomInstances( Instances dataset, int numInstances, Random random ) { int n = dataset.numAttributes(); double [] v = new double[ n ]; for( int i = 0; i < numInstances; i++ ) { for( int j = 0; j < n; j++ ) { Attribute att = dataset.attribute( j ); if( att.isNumeric() ) { v[ j ] = random.nextDouble(); } else if ( att.isNominal() ) { v[ j ] = random.nextInt( att.numValues() ); } } dataset.add( new DenseInstance( 1, v ) ); } }
DenseInstance di = new DenseInstance(3); // Sets all 3 values to missing di.setValue(0, p.getIncludedLength()); di.setValue(1, p.getTimestampSeconds());
//Make a place holder Instances //If you already have access to one, you can skip this step Instances dataset = new Instances("testdata", attr, 1); dataset.setClassIndex(classIdx); DenseInstance newInst = new DenseInstance(1.0,values); //To associate your instance with Instances object, in this case dataset newInst.setDataset(dataset);
double[] instanceValue1 = new double[] { p.getIncludedLength(), p.getTimestampSeconds(), 0.0} DenseInstance di = new DenseInstance(1.0, instanceValue1); di.setMissing(2);
/** * Replaces all missing values in the instance with the values contained in * the given array. A deep copy of the vector of attribute values is performed * before the values are replaced. * * @param array containing the means and modes * @throws IllegalArgumentException if numbers of attributes are unequal */ @Override public void replaceMissingValues(double[] array) { if ((array == null) || (array.length != m_AttValues.length)) { throw new IllegalArgumentException("Unequal number of attributes!"); } freshAttributeVector(); for (int i = 0; i < m_AttValues.length; i++) { if (isMissing(i)) { m_AttValues[i] = array[i]; } } }
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; }
Instances result = new Instances(getOutputFormat(), instances.numInstances()); for (int i = 0; i < instances.numInstances(); i++) { Instance inst = instances.instance(i); double[] newData = new double[instances.numAttributes()]; for (int j = 0; j < instances.numAttributes(); j++) { if (m_AttToBeModified[j] && !inst.isMissing(j)) { newData[j] = m_NewValues[j][(int) inst.value(j)]; } else { newData[j] = inst.value(j); DenseInstance instNew = new DenseInstance(inst.weight(), newData); instNew.setDataset(result);
result = new Instances(getOutputFormat()); for (i = 0; i < instances.numInstances(); i++) { inst = instances.instance(i); values = inst.toDoubleArray(); if (!m_Cols.isInRange(n) || !instances.attribute(n).isNumeric() || inst.isMissing(n)) { continue; if (instances.attribute(n).type() == Attribute.DATE) { value = inst.stringValue(n); } else { value = Utils.doubleToString(inst.value(n), MAX_DECIMALS); int index = result.attribute(n).indexOfValue(value); if (index == -1) { values[n] = Utils.missingValue();; } else { values[n] = index; newInst = new SparseInstance(inst.weight(), values); } else { newInst = new DenseInstance(inst.weight(), values);
double[] vals = new double[outputFormat.numAttributes()]; for(int i = 0; i < vals.length; i++) { if ((i != outputFormat.classIndex()) && (m_SelectedCols.isInRange(i))) { if ((source != null) && !source.isMissing(i) && !dest.isMissing(i)) { vals[i] = dest.value(i) - source.value(i); } else { vals[i] = Utils.missingValue(); inst = new SparseInstance(dest.weight(), vals); } else { inst = new DenseInstance(dest.weight(), vals); inst.setDataset(dest.dataset());
Instances tempInstances = new Instances(convertedInstances, convertedInstances.numInstances()); convertedInstances.insertAttributeAt((Attribute) getInputFormat() .attribute(0).copy(), 0); setOutputFormat(convertedInstances); Instances relation = getInputFormat().instance(origInstanceIndex) .relationalValue(1); if (relation != null) { bagSize = relation.numInstances(); double[] newVals = new double[convertedInstances.numAttributes()]; newVals[0] = getInputFormat().instance(origInstanceIndex).value(0); for (int i = 1; i < newVals.length; i++) { if (i - 1 == tempInstances.classIndex()) { newVals[i] = tempInstances.instance(0).classValue(); // All class && tempInstances.attribute(i - 1).isNumeric()) { for (Instance tempInst : tempInstances) { newVals[i] += tempInst.value(i - 1); DenseInstance insT = new DenseInstance(getInputFormat().instance( origInstanceIndex++).weight(), newVals); insT.setDataset(convertedInstances); push(insT); tempInstances.delete();
intValue[i] = minInt[i]; } else { values[i] = Utils.missingValue(); values[format.classIndex()] = format.classAttribute().indexOfValue(cName); DenseInstance example = new DenseInstance(1.0, values); example.setDataset(format); format.add(example); // Instance will be copied here added++; example.setValue(attr, intValue[attr]); } while (added < numInstances);
public void insertInstance(int index, boolean notify) { if (!m_IgnoreChanges) { addUndoPoint(); } double[] vals = new double[m_Data.numAttributes()]; // set any string or relational attribute values to missing // in the new instance, just in case this is the very first // instance in the dataset. for (int i = 0; i < m_Data.numAttributes(); i++) { if (m_Data.attribute(i).isString() || m_Data.attribute(i).isRelationValued()) { vals[i] = Utils.missingValue(); } } Instance toAdd = new DenseInstance(1.0, vals); if (index < 0) { m_Data.add(toAdd); } else { m_Data.add(index, toAdd); } if (notify) { notifyListener(new TableModelEvent(this, m_Data.numInstances() - 1, m_Data.numInstances() - 1, TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT)); } }
double[] vals = new double[getOutputFormat().numAttributes()]; int index = 0; for (int j = 0; j < current.numAttributes(); j++) { if (j != current.classIndex()) { if (m_unchanged != null && m_unchanged.attribute(current.attribute(j).name()) != null) { vals[index++] = current.value(j); } else { Estimator[] estForAtt = m_estimatorLookup.get(current.attribute(j).name()); for (int k = 0; k < current.classAttribute().numValues(); k++) { if (current.isMissing(j)) { vals[index++] = Utils.missingValue(); } else { double e = estForAtt[k].getProbability(current.value(j)); vals[vals.length - 1] = current.classValue(); DenseInstance instNew = new DenseInstance(current.weight(), vals);
Instances newData = new Instances(instances, instances.numInstances()); Random random = new Random(getSeed()); m_Cols.setUpper(newData.numAttributes() - 1); for (Instance inst : instances) { double[] values = inst.toDoubleArray(); for (int i = 0; i < values.length; i++) { if (m_Cols.isInRange(i) && (i != instances.classIndex() || getIgnoreClass())) { if (random.nextDouble() < getProbability()) { values[i] = Utils.missingValue(); newData.add(new SparseInstance(inst.weight(), values)); } else { newData.add(new DenseInstance(inst.weight(), values));
@Override public void updateFinished() { if (m_canopies == null || m_canopies.numInstances() == 0) { return; double[] densities = new double[m_canopies.size()]; for (int i = 0; i < m_canopies.numInstances(); i++) { double[] density = m_canopyT2Density.get(i); double[][] centerSums = m_canopyCenters.get(i); } else if (m_canopies.attribute(j).isNominal()) { int mode = Utils.maxIndex(centerSums[j]); if (mode == centerSums[j].length - 1) { finalCenter[j] = Utils.missingValue(); } else { finalCenter[j] = mode; Instance finalCenterInst = m_canopies.instance(i) instanceof SparseInstance ? new SparseInstance( 1.0, finalCenter) : new DenseInstance(1.0, finalCenter); m_canopies.set(i, finalCenterInst); m_canopies.instance(i).setWeight(density[0]); densities[i] = density[0];
double[] vals = new double[modelHeader.numAttributes()]; for (int i = 0; i < modelHeader.numAttributes(); i++) { vals[i] = Utils.missingValue(); continue; Attribute modelAtt = modelHeader.attribute(i); Attribute incomingAtt = incoming.dataset().attribute(m_attributeMap[i]); if (incoming.isMissing(incomingAtt.index())) { vals[i] = Utils.missingValue(); continue; if (modelAtt.isNumeric()) { vals[i] = incoming.value(m_attributeMap[i]); } else if (modelAtt.isNominal()) { String incomingVal = incoming.stringValue(m_attributeMap[i]); int modelIndex = modelAtt.indexOfValue(incomingVal); vals[i] = Utils.missingValue(); } else { vals[i] = modelIndex; newInst = new SparseInstance(incoming.weight(), vals); } else { newInst = new DenseInstance(incoming.weight(), vals);
/** * 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; }
/** * Transforms the instance in the prediction process before given to the internal multi-label * or multi-target classifier. The instance is passed having the original set of labels, these * must be replaced with the transformed labels (attributes) so that the internla classifier * can predict them. * * @param x The instance to transform. Consists of features and labels. * @return The transformed instance. Consists of features and transformed labels. */ @Override public Instance transformInstance(Instance x) throws Exception{ Instances tmpInst = new Instances(x.dataset()); tmpInst.delete(); tmpInst.add(x); Instances features = this.extractPart(tmpInst, false); Instances labels = new Instances(this.m_PatternInstances); labels.add(new DenseInstance(labels.numAttributes())); Instances result = Instances.mergeInstances(labels, features); result.setClassIndex(labels.numAttributes()); return result.instance(0); }
if (instances.numAttributes() < result.numAttributes()) { // Do we actually need to add an attribute? double[] newVals = new double[result.numAttributes()]; for (int i = 0; i < inst.numValues(); i++) { newVals[inst.index(i)] = inst.valueSparse(i); for (int i = 0; i < inst.numAttributes(); i++) { if (instances.attribute(i).isNominal() && m_Attributes.isInRange(i) && i != instances.classIndex()) { if (Utils.isMissingValue(newVals[i])) { value = null; break; } else { value += (value.length() > 0) ? "_x_" + instances.attribute(i).value((int) newVals[i]) : instances.attribute(i).value((int) newVals[i]); result.add(new DenseInstance(inst.weight(), newVals)); } else { result.add(new SparseInstance(inst.weight(), newVals));
double[] newVals = new double[instance.numAttributes()]; int[] newIndices = new int[instance.numAttributes()]; double[] vals = instance.toDoubleArray(); int ind = 0; for (int j = 0; j < instance.numAttributes(); j++) { double value; if (instance.attribute(j).isNumeric() && (!Utils.isMissingValue(vals[j])) && (getInputFormat().classIndex() != j)) { System.arraycopy(newVals, 0, tempVals, 0, ind); System.arraycopy(newIndices, 0, tempInd, 0, ind); inst = new SparseInstance(instance.weight(), tempVals, tempInd, instance.numAttributes()); } else { double[] vals = instance.toDoubleArray(); for (int j = 0; j < getInputFormat().numAttributes(); j++) { if (instance.attribute(j).isNumeric() && (!Utils.isMissingValue(vals[j])) && (getInputFormat().classIndex() != j)) { vals[j] = (vals[j] - m_Means[j]); inst = new DenseInstance(instance.weight(), vals);