/** * Returns the "class distribution" for the given bag. */ @Override public double[] distributionForInstance(Instance newBag) throws Exception { double[] distribution = new double[2]; Instances contents = newBag.relationalValue(1); boolean positive = false; for (Instance i : contents) { if (tree.isPositive(i)) { positive = true; break; } } distribution[1] = positive ? 1 : 0; distribution[0] = 1 - distribution[1]; return distribution; }
/** * Returns the distribution of "class probabilities" for a new bag. */ public double[] distributionForInstance(Instance newBag) throws Exception { double [] distribution = new double[2]; Instances contents = newBag.relationalValue(1); boolean positive = false; for (Instance i : contents) { for (MultiInstanceDecisionTree tree : rules) { if (tree.isPositive(i)) { positive = true; break; } } } distribution[1] = positive ? 1 : 0; distribution[0] = 1 - distribution[1]; return distribution; }
/** * 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); }
/** * Determines the output format for the filter. */ @Override protected Instances determineOutputFormat(Instances inputFormat) { // Create attributes ArrayList<Attribute> atts = new ArrayList<Attribute>(); m_allInsts = new LinkedList<Instance>(); for (int i = 0; i < getInputFormat().numInstances(); i++) { Instances bag = getInputFormat().instance(i).relationalValue( BAG_ATTRIBUTE); for (int j = 0; j < bag.numInstances(); j++) { m_allInsts.add(bag.instance(j)); } } for (int i = 0; i < m_allInsts.size(); i++) { atts.add(new Attribute("" + i)); } atts.add(inputFormat.attribute(LABEL_ATTRIBUTE)); // class // TODO set relation name properly Instances returner = new Instances("", atts, 0); returner.setClassIndex(returner.numAttributes() - 1); return returner; }
/** * * @param id1 the index of instance 1 * @param id2 the index of instance 2 * @param inst1 the instance 1 object * @return the dot product * @throws Exception if something goes wrong */ protected double evaluate(int id1, int id2, Instance inst1) throws Exception { double result = 0; Instances insts1, insts2; if (id1 == -1) insts1 = new Instances(inst1.relationalValue(1)); else insts1 = new Instances(m_data.instance(id1).relationalValue(1)); insts2 = new Instances (m_data.instance(id2).relationalValue(1)); double precalc1=0; for(int i = 0; i < insts1.numInstances(); i++){ for (int j = 0; j < insts2.numInstances(); j++){ if (id1 == -1) precalc1 = dotProd(insts1.instance(i), insts1.instance(i)); else precalc1 = m_kernelPrecalc[id1][i]; double res = Math.exp(m_gamma*(2. * dotProd(insts1.instance(i), insts2.instance(j)) -precalc1 - m_kernelPrecalc[id2][j] ) ); result += res; } } return result; }
Instances ins = exmp.relationalValue(1); if (m_Filter != null) { ins = Filter.useFilter(ins, m_Filter);
for (int i = 0; i < numBags; i++) { if (train.instance(i).classValue() == 1.0) { // positive bag numInstances = train.instance(i).relationalValue(1).numInstances(); m_Distance[i] = new double[numInstances][]; for (int j = 0; j < numInstances; j++) { tempCenter = train.instance(i).relationalValue(1).instance(j); m_Distance[i][j] = new double[numBags]; // store the distance from one
/** * Scale the given exemplar so that the returned exemplar has the value of 0 * to 1 for each dimension * * @param before the given exemplar * @return the resultant exemplar after scaling * @throws Exception if given exampler cannot be scaled properly */ private Instance scale(Instance before) throws Exception { Instances afterInsts = before.relationalValue(1).stringFreeStructure(); Instance after = new DenseInstance(before.numAttributes()); after.setDataset(m_Attributes); for (int i = 0; i < before.relationalValue(1).numInstances(); i++) { Instance datum = before.relationalValue(1).instance(i); Instance inst = (Instance) datum.copy(); for (int j = 0; j < m_Dimension; j++) { if (before.relationalValue(1).attribute(j).isNumeric()) { inst.setValue(j, (datum.value(j) - m_MinArray[j]) / (m_MaxArray[j] - m_MinArray[j])); } } afterInsts.add(inst); } int attValue = after.attribute(1).addRelation(afterInsts); after.setValue(0, before.value(0)); after.setValue(1, attValue); after.setValue(2, before.value(2)); return after; }
m_NumInstances = 0; for (int i = 0; i < m_NumBags; i++) { if (input.instance(i).relationalValue(1) == null) { m_NumInstances++; } else { int nn = input.instance(i).relationalValue(1).numInstances(); m_NumInstances += nn;
/** * Calculate the distance from one data point to a bag * * @param center the data point in instance space * @param bag the bag * @return the double value as the distance. */ public double minBagDistance(Instance center, Instance bag) { double distance; double minDistance = Double.MAX_VALUE; Instances temp = bag.relationalValue(1); // calculate the distance from the data point to each instance in the bag // and return the minimum distance for (int i = 0; i < temp.numInstances(); i++) { distance = 0; for (int j = 0; j < center.numAttributes(); j++) { distance += (center.value(j) - temp.instance(i).value(j)) * (center.value(j) - temp.instance(i).value(j)); } if (minDistance > distance) { minDistance = distance; } } return Math.sqrt(minDistance); }
Instances data1= new Instances(inst1.relationalValue(1)); Instances data2; if(id1==id2) data2= new Instances(data1); else data2 = new Instances (m_data.instance(id2).relationalValue(1));
Instances exi = ex.relationalValue(1); double[] n = new double[m_Dimension]; double[] xBar = new double[m_Dimension];
/** * Updates the minimum and maximum values for all the attributes based on a * new exemplar. * * @param ex the new exemplar */ private void updateMinMax(Instance ex) { Instances insts = ex.relationalValue(1); for (int j = 0; j < m_Dimension; j++) { if (insts.attribute(j).isNumeric()) { for (int k = 0; k < insts.numInstances(); k++) { Instance ins = insts.instance(k); if (!ins.isMissing(j)) { if (Double.isNaN(m_MinArray[j])) { m_MinArray[j] = ins.value(j); m_MaxArray[j] = ins.value(j); } else { if (ins.value(j) < m_MinArray[j]) { m_MinArray[j] = ins.value(j); } else if (ins.value(j) > m_MaxArray[j]) { m_MaxArray[j] = ins.value(j); } } } } } } }
/** * * @param ex the given test exemplar * @return the classification * @throws Exception if the exemplar could not be classified successfully */ @Override public double classifyInstance(Instance ex) throws Exception { // Instance ex = new Exemplar(e); Instances exi = ex.relationalValue(1); double[] n = new double[m_Dimension]; double[] xBar = new double[m_Dimension]; for (int i = 0; i < exi.numAttributes(); i++) { xBar[i] = exi.meanOrMode(i); } for (int w = 0, t = 0; w < m_Dimension; w++, t++) { // if((t==m_ClassIndex) || (t==m_IdIndex)) // t++; for (int u = 0; u < exi.numInstances(); u++) { if (!exi.instance(u).isMissing(t)) { n[w] += exi.instance(u).weight(); } } } double logOdds = likelihoodRatio(n, xBar); return (logOdds > m_Cutoff) ? 1 : 0; }
public double classifyInstance(Instance ex) throws Exception { Instances exi = ex.relationalValue(1); double[] n = new double[m_Dimension]; double[] xBar = new double[m_Dimension];
/** * builds the kernel with the given data. Initializes the kernel cache. * The actual size of the cache in bytes is (64 * cacheSize). * * @param data the data to base the kernel on * @throws Exception if something goes wrong */ public void buildKernel(Instances data) throws Exception { // does kernel handle the data? if (!getChecksTurnedOff()) getCapabilities().testWithFail(data); initVars(data); for (int i = 0; i < data.numInstances(); i++){ Instances insts = new Instances(data.instance(i).relationalValue(1)); m_kernelPrecalc[i] = new double [insts.numInstances()]; for (int j = 0; j < insts.numInstances(); j++) m_kernelPrecalc[i][j] = dotProd(insts.instance(j), insts.instance(j)); } }
/** * performs a typical test */ public void testTypical() { Instances icopy = new Instances(m_Instances); Instances result = useFilter(); // # of instances int count = 0; for (int i = 0; i < icopy.numInstances(); i++) count += icopy.instance(i).relationalValue(1).numInstances(); assertEquals(result.numInstances(), count); // # of attributes count = icopy.numAttributes() + icopy.attribute(1).relation().numAttributes() - 1; assertEquals(result.numAttributes(), count); }
/** * performs a typical test */ public void testTypical() { Instances icopy = new Instances(m_Instances); Instances result = useFilter(); // # of instances int count = 0; for (int i = 0; i < result.numInstances(); i++) count += result.instance(i).relationalValue(1).numInstances(); assertEquals(icopy.numInstances(), count); // # of attributes count = result.numAttributes() + result.attribute(1).relation().numAttributes() - 1; assertEquals(icopy.numAttributes(), count); }
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; }
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; }