Refine search
if (num == instance.numValues()) { inst = new SparseInstance(instance.weight(), vals, indices, instance.numAttributes()); } else { System.arraycopy(vals, 0, tempVals, 0, num); System.arraycopy(indices, 0, tempInd, 0, num); inst = new SparseInstance(instance.weight(), tempVals, tempInd, instance.numAttributes()); double[] vals = new double[getInputFormat().numAttributes()]; for (int j = 0; j < instance.numAttributes(); j++) { if (instance.isMissing(j) && (getInputFormat().classIndex() != j) && (getInputFormat().attribute(j).isNominal() || getInputFormat() .attribute(j).isNumeric())) { vals[j] = m_meansAndModes[j]; inst = new DenseInstance(instance.weight(), vals); inst.setDataset(instance.dataset());
private weka.core.Instance tcInstanceToMekaInstance(Instance instance, Instances trainingData, List<String> allClassLabels) throws Exception { AttributeStore attributeStore = new AttributeStore(); List<Attribute> outcomeAttributes = createOutcomeAttributes(allClassLabels); // in Meka, class label attributes have to go on top for (Attribute attribute : outcomeAttributes) { attributeStore.addAttributeAtBegin(attribute.name(), attribute); } for (int i = outcomeAttributes.size(); i < trainingData.numAttributes(); i++) { attributeStore.addAttribute(trainingData.attribute(i).name(), trainingData.attribute(i)); } double[] featureValues = getFeatureValues(attributeStore, instance); SparseInstance sparseInstance = new SparseInstance(1.0, featureValues); trainingData.setClassIndex(outcomeAttributes.size()); sparseInstance.setDataset(trainingData); return sparseInstance; }
SparseInstance inst = new SparseInstance(3); inst.setValue(length, 5.3); inst.setValue(weight, 300); inst.setValue(position, "first"); inst.setDataset(race); System.out.println("First attribute: " + inst.attribute(0)); System.out.println("Class attribute: " + inst.classAttribute()); System.out.println("Class index: " + inst.classIndex()); System.out.println("Class is missing: " + inst.classIsMissing()); System.out.println("Class value (internal format): " + inst.classValue()); SparseInstance copy = (SparseInstance) inst.copy(); System.out.println("Shallow copy: " + copy); copy.setDataset(inst.dataset()); System.out.println("Shallow copy with dataset set: " + copy); for (int i = 0; i < inst.numValues(); i++) { if (i > 0) { System.out.print(","); System.out.print(inst.valueSparse(i));
/** * Merges this instance with the given instance and returns the result. * Dataset is set to null. * * @param inst the instance to be merged with this one * @return the merged instances */ @Override public Instance mergeInstance(Instance inst) { double[] values = new double[numValues() + inst.numValues()]; int[] indices = new int[numValues() + inst.numValues()]; int m = 0; for (int j = 0; j < numValues(); j++, m++) { values[m] = valueSparse(j); indices[m] = index(j); } for (int j = 0; j < inst.numValues(); j++, m++) { values[m] = inst.valueSparse(j); indices[m] = numAttributes() + inst.index(j); } return new SparseInstance(1.0, values, indices, numAttributes() + inst.numAttributes()); }
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);
double[] vals = new double[outputFormatPeek().numAttributes()]; int attSoFar = 0; for (int j = 0; j < getInputFormat().numAttributes(); j++) { Attribute att = getInputFormat().attribute(j); if ((!att.isNominal()) || (j == getInputFormat().classIndex())) { vals[attSoFar] = instance.value(j); attSoFar++; } else { if ((att.numValues() <= 2) && (!m_TransformAll)) { vals[attSoFar] = instance.value(j); attSoFar++; } else { if (instance.isMissing(j)) { for (int k = 0; k < att.numValues(); k++) { vals[attSoFar + k] = instance.value(j); inst = new SparseInstance(instance.weight(), vals); } else { inst = new DenseInstance(instance.weight(), vals);
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[outputFormatPeek().numAttributes()]; } else { if (!m_MakeBinary) { if (instance.isMissing(i)) { vals[index] = Utils.missingValue(); } else { for (j = 0; j < m_CutPoints[i].length; j++) { for (j = 0; j < m_CutPoints[i].length; j++) { if (instance.isMissing(i)) { vals[index] = Utils.missingValue(); } else if (currentVal <= m_CutPoints[i][j]) { vals[index] = 0; inst = new SparseInstance(instance.weight(), vals); } else { inst = new DenseInstance(instance.weight(), vals);
&& (!m_SerializedHeader.equalHeaders(instances)) && (!(m_ActualClassifier instanceof InputMappedClassifier))) { throw new WekaException( "Training header of classifier and filter dataset don't match:\n" + m_SerializedHeader.equalHeadersMsg(instances)); for (i = 0; i < instances.numInstances(); i++) { oldInstance = instances.instance(i); oldValues = oldInstance.toDoubleArray(); newValues = new double[result.numAttributes()]; if (instances.classIndex() < 0) { newValues[start] = Utils.missingValue(); } else if (result.classAttribute().isNominal()) { if (inst.classValue() == m_ActualClassifier.classifyInstance(oldInstance)) { newValues[start] = 0; } else { newValues[start] = m_ActualClassifier.classifyInstance(oldInstance) - inst.classValue(); newInstance = new SparseInstance(oldInstance.weight(), newValues); } else { newInstance = new DenseInstance(oldInstance.weight(), newValues);
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);
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());
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[] vals = new double[outputFormatPeek().numAttributes()]; for (int i = 0; i < instance.numAttributes(); i++) { vals[i] = instance.value(i); for (int i = instance.numAttributes(); i < outputFormatPeek() .numAttributes(); i++) { AttributeSpec spec = m_attributeSpecs.get(i - instance.numAttributes()); Attribute outAtt = outputFormat.attribute(i); if (outAtt.isDate()) { vals[i] = spec.getDateValue().getTime(); } else if (outAtt.isNumeric()) { vals[i] = spec.getNumericValue(); } else if (outAtt.isNominal()) { String nomVal = spec.getNominalOrStringValue(); vals[i] = outAtt.indexOfValue(nomVal); inst = new SparseInstance(instance.weight(), vals); } else { inst = new DenseInstance(instance.weight(), vals); inst.setDataset(outputFormat);
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];
weight = (Double) inst.getChild(WEIGHT).getValue(new Double(1.0)); values = inst.getChild(VALUES); vals = new double[data.numAttributes()]; for (i = 0; i < values.getChildCount(); i++) { if (sparse) { vals[index] = Utils.missingValue(); if (data.attribute(index).isNumeric() && !data.attribute(index).isDate()) { vals[index] = Double.parseDouble(value); else if (data.attribute(index).isNominal()) { vals[index] = data.attribute(index).indexOfValue(value); if ((vals[index] == -1) && value.startsWith("'") && value.endsWith("'")) vals[index] = data.attribute(index).indexOfValue(Utils.unquote(value)); vals[index] = data.attribute(index).indexOfValue(Utils.unbackQuoteChars(Utils.unquote(value))); if (vals[index] == -1) { System.err.println("Unknown label '" + value + "' for attribute #" + (index+1) + "!"); result = new SparseInstance(weight, vals); else result = new DenseInstance(weight, vals); result.setDataset(data);
if (getOutputFormat().numAttributes() == 0) { return false; push(instance); } else { double vals[] = new double[getOutputFormat().numAttributes()]; for (int i = 0; i < instance.numAttributes(); i++) { double currentV = instance.value(i); if (currentV == Utils.missingValue()) { vals[i] = currentV; } else { String currentS = instance.attribute(i).value((int) currentV); String replace = m_ignoreCase ? m_renameMap.get(currentS .toLowerCase()) : m_renameMap.get(currentS); vals[i] = currentV; } else { vals[i] = getOutputFormat().attribute(i).indexOfValue(replace); inst = new SparseInstance(instance.weight(), vals); } else { inst = new DenseInstance(instance.weight(), vals);
/** * Convert a single instance over. Selected attributes only are transfered. * The converted instance is added to the end of the output queue. * * @param instance the instance to convert * @throws Exception if something goes wrong */ protected void convertInstance(Instance instance) throws Exception { double[] newVals = new double[getOutputFormat().numAttributes()]; if (m_ASEvaluator instanceof AttributeTransformer) { Instance tempInstance = ((AttributeTransformer) m_ASEvaluator).convertInstance(instance); for (int i = 0; i < m_SelectedAttributes.length; i++) { int current = m_SelectedAttributes[i]; newVals[i] = tempInstance.value(current); } } else { for (int i = 0; i < m_SelectedAttributes.length; i++) { int current = m_SelectedAttributes[i]; newVals[i] = instance.value(current); } } if (instance instanceof SparseInstance) { push(new SparseInstance(instance.weight(), newVals)); } else { push(new DenseInstance(instance.weight(), newVals)); } }
boolean setStringValues, Object[] row, boolean sparse) throws Exception { double[] vals = new double[trainingHeader.numAttributes()]; for (int i = 0; i < trainingHeader.numAttributes(); i++) { if (row[i] == null || row[i].toString().equals(getMissingValue()) || row[i].toString().trim().length() == 0) { vals[i] = Utils.missingValue(); continue; Attribute current = trainingHeader.attribute(i); if (current.isString()) { if (setStringValues) { current.setStringValue(row[i].toString()); vals[i] = 0; } else { vals[i] = current.addStringValue(row[i].toString()); } else if (current.isNominal()) { result = new SparseInstance(1.0, vals); } else { result = new DenseInstance(1.0, vals); result.setDataset(trainingHeader);
if (attribute.isString() && attribute.numValues() == 0) { attribute.addStringValue(UUID.randomUUID().toString()); attributes.add(outcomeAttribute); Instances instances = new Instances(relationTag, attributes, instanceFeatures.size()); instances.setClass(outcomeAttribute); SparseInstance instance = new SparseInstance(instances.numAttributes()); instance.setValue(attribute, attributeValue); } else if (featureValue instanceof Boolean) { double attributeValue = (Boolean) featureValue ? 1.0d : -1.0d; instance.setValue(attribute, attributeValue); } else { instance.setValue(attribute, featureValue.toString()); instance.setValue(outcomeAttribute, instanceOutcomes.get(i)); instances.add(instance);