Java Dataset.size方法代码示例

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
/**
 * Assign all instances from the data set to the medoids.
 * 
 * @param medoids candidate medoids
 * @param data the data to assign to the medoids
 * @return best cluster indices for each instance in the data set
 */
private int[] assign(Instance[] medoids, Dataset data) {
	int[] out = new int[data.size()];
	for (int i = 0; i < data.size(); i++) {
		double bestDistance = dm.measure(data.instance(i), medoids[0]);
		int bestIndex = 0;
		for (int j = 1; j < medoids.length; j++) {
			double tmpDistance = dm.measure(data.instance(i), medoids[j]);
			if (dm.compare(tmpDistance, bestDistance)) {
				bestDistance = tmpDistance;
				bestIndex = j;
			}
		}
		out[i] = bestIndex;

	}
	return out;

}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
/**
 * Assign all instances from the data set to the medoids.
 * 
 * @param medoids candidate medoids
 * @param data the data to assign to the medoids
 * @return best cluster indices for each instance in the data set
 */
private int[] assign(Instance[] medoids, Dataset data) {
	LOGGER.log( Level.INFO, "Assign all instances from the data set to the medoids.");
	int[] out = new int[data.size()];
	for (int i = 0; i < data.size(); i++) {
		double bestDistance = dm.measure(data.instance(i), medoids[0]);
		int bestIndex = 0;
		for (int j = 1; j < medoids.length; j++) {
			double tmpDistance = dm.measure(data.instance(i), medoids[j]);
			LOGGER.log(Level.FINE, "Distance:{0}",tmpDistance);
			if (dm.compare(tmpDistance, bestDistance)) {
				bestDistance = tmpDistance;
				bestIndex = j;
			}
		}
		out[i] = bestIndex;

	}
	return out;

}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
public Dataset[] cluster(Dataset data) {

        filter.filter(data);
        m_numberOfClusters = -1;
        m_cobwebTree = null;
        m_numberSplits = 0;
        m_numberMerges = 0;
        for (int i = 0; i < data.size(); i++) {
            updateClusterer(data.instance(i));
        }
        determineNumberOfClusters();
        // printNode(m_cobwebTree, 0);

        Vector<Dataset> clusters = new Vector<Dataset>();
        createClusters(m_cobwebTree, clusters);
        Dataset[] out = new Dataset[clusters.size()];
        clusters.toArray(out);
        return out;
    }
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
public double logLikelihood(Dataset cluster) {
	double instanceLength = cluster.instance(0).size();
	this.count = instanceLength * cluster.size();
	sum = 0;
	sum2 = 0;

	for (int row = 0; row < cluster.size(); row++) {
		for (int column = 0; column < instanceLength; column++) {
			sum += cluster.instance(row).value(column);
			sum2 += cluster.instance(row).value(column)
					* cluster.instance(row).value(column);
		}
	}

	double loglikelihood = logLikelihoodFunction(count, sum, sum2);
	if (loglikelihood == Double.NEGATIVE_INFINITY
			|| loglikelihood == Double.POSITIVE_INFINITY) {
		loglikelihood = 0;
	}
	return (loglikelihood);
}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
private static svm_problem transformDataset(Dataset data) {
	svm_problem p = new svm_problem();
	p.l = data.size();
	p.y = new double[data.size()];
	p.x = new svm_node[data.size()][];
	int tmpIndex = 0;
	for (int j = 0; j < data.size(); j++) {
		Instance tmp = data.instance(j);
		p.y[tmpIndex] = data.classIndex(tmp.classValue());
		p.x[tmpIndex] = new svm_node[tmp.keySet().size()];
		int i = 0;
		SortedSet<Integer> tmpSet = tmp.keySet();
		for (int index : tmpSet) {
			p.x[tmpIndex][i] = new svm_node();
			p.x[tmpIndex][i].index = index;
			p.x[tmpIndex][i].value = tmp.value(index);
			i++;
		}
		tmpIndex++;
	}
	return p;
}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
@Override
public void build(Dataset data) {
	int numAtt = data.noAttributes();
	/* [i] contains the sum of ranks of feature i */
	double[] sum = new double[numAtt];
	for (FeatureRanking ae : aes) {
		Dataset bootstrapData = new DefaultDataset();
		while (bootstrapData.size() < data.size()) {
			int random = rg.nextInt(data.size());
			bootstrapData.add(data.get(random));
		}
		Dataset copy = bootstrapData.copy();
		ae.build(copy);
		for (int i = 0; i < numAtt; i++)
			sum[i] += ae.rank(i);
	}
	toRank(sum);

}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
@Override
public void build(Dataset data) {
    weights = new double[data.noAttributes()];

    /* Normalize the data to [0,1] */

    NormalizeMidrange dnm = new NormalizeMidrange(0.5, 1);
    dnm.filter(data);

    /* Number of iterations */
    int m = data.size();

    for (int i = 0; i < m; i++) {
        Instance random = data.instance(rg.nextInt(data.size()));
        findNearest(data, random);
        for (int j = 0; j < weights.length; j++)
            weights[j] = weights[j] - diff(j, random, nearestHit) / m + diff(j, random, nearestMiss) / m;

    }
}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
@Override
public Dataset[] cluster(Dataset data) {
    // hexa || rect
    wV = new WeightVectors(xdim, ydim, data.noAttributes(), gridType.toString());
    InputVectors iV = convertDataset(data);
    JSomTraining jst = new JSomTraining(iV);
    // exponential || inverse || linear
    // gaussian || step
    jst.setTrainingInstructions(iterations, learningRate, initialRadius, learningType.toString(),
            neighbourhoodFunction.toString());
    // WeightVectors out = jst.doTraining();
    jst.doTraining();
    Vector<Dataset> clusters = new Vector<Dataset>();
    for (int i = 0; i < wV.size(); i++) {
        clusters.add(new DefaultDataset());
    }

    wV = doLabeling(wV, iV, data, clusters);

    // Filter empty clusters out;
    int nonEmptyClusterCount = 0;
    for (int i = 0; i < clusters.size(); i++) {
        if (clusters.get(i).size() > 0)
            nonEmptyClusterCount++;
    }
    Dataset[] output = new Dataset[nonEmptyClusterCount];
    int index = 0;
    for (Dataset tmp : clusters) {
        if (tmp.size() > 0) {
            output[index] = tmp;
            index++;
        }
    }
    return output;

}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
/**
 * Does the labeling phase.
 * 
 * @return WeightVectors - Returns the labeled weight vectors.
 */
private WeightVectors doLabeling(WeightVectors wVector, InputVectors iVector, Dataset data, Vector<Dataset> clusters) {

    for (int i = 0; i < data.size(); i++) {
        int index = resolveIndexOfWinningNeuron(iVector.getNodeValuesAt(i));
        clusters.get(index).add(data.instance(i));
        wVector.setNodeLabelAt(index, iVector.getNodeLabelAt(i));
    }
    return wVector;
}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
private InputVectors convertDataset(Dataset data) {
    InputVectors iVS = new InputVectors();
    for (int i = 0; i < data.size(); i++) {
        Double[] values = data.instance(i).values().toArray(new Double[0]);
        SomNode tmp = new SomNode("node_" + i, values);
        iVS.add(tmp);
    }
    return iVS;
}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
@SuppressWarnings({ "unused", "rawtypes" })
public ClusterPair(Dataset set, List inputs, List outputs) {
	super();
	this.inputs = inputs;
	this.outputs = outputs;
	for (int i = 0; i < set.size(); i++) {
		average += set.get(i).get(0);
	}
	
	average = average/set.size();
}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
/**
 * Normalizes the data to mean 0 and standard deviation 1. This method
 * discards all instances that cannot be normalized, i.e. they have the same
 * value for all attributes.
 * 
 * @param data
 * @return
 */
private Vector<TaggedInstance> dontnormalize(Dataset data) {
	Vector<TaggedInstance> out = new Vector<TaggedInstance>();

	for (int i = 0; i < data.size(); i++) {
		// Double[] old = data.instance(i).values().toArray(new Double[0]);
		// double[] conv = new double[old.length];
		// for (int j = 0; j < old.length; j++) {
		// conv[j] = old[j];
		// }
		//
		// Mean m = new Mean();
		//
		// double MU = m.evaluate(conv);
		// // System.out.println("MU = "+MU);
		// StandardDeviation std = new StandardDeviation();
		// double SIGM = std.evaluate(conv, MU);
		// System.out.println("SIGM = "+SIGM);
		// if (!MathUtils.eq(SIGM, 0)) {
		// double[] val = new double[old.length];
		// for (int j = 0; j < old.length; j++) {
		// val[j] = (float) ((old[j] - MU) / SIGM);
		//
		// }
		// System.out.println("VAL "+i+" = "+Arrays.toString(val));
		out.add(new TaggedInstance(data.instance(i), i));
		// }
	}
	// System.out.println("FIRST = "+out.get(0));

	return out;
}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
@Override
public void filter(Dataset data) {
    if (data.size() == 0)
        return;
    if (mean == null || std == null)
        build(data);
    super.filter(data);

}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
@Override
public Dataset[] cluster(Dataset data) {
    this.originalData = data;
    if (dm == null) {
        dm = new NormalizedEuclideanDistance(this.originalData);
    }
    this.clusterID = 0;
    dataset = new Vector<DataObject>();
    for (int i = 0; i < data.size(); i++) {
        dataset.add(new DataObject(data.instance(i)));

    }

    Collections.shuffle(dataset);// make clustering algorithm random
    ArrayList<Dataset> output = new ArrayList<Dataset>();
    for (DataObject dataObject : dataset) {
        if (dataObject.clusterIndex == DataObject.UNCLASSIFIED) {
            if (expandCluster(dataObject)) {
                /* Extract cluster here */
                /* Cluster ids may be overwritten in further iterations */
                output.add(extract(clusterID));
                clusterID++;
            }
        }
    }

    return output.toArray(new Dataset[0]);

}
 

import net.sf.javaml.core.Dataset; //导入方法依赖的package包/类
private void createClusters(CNode tree, Vector<Dataset> clusters) {
    if (tree.m_children != null) {
        for (CNode y : tree.m_children) {
            createClusters(y, clusters);
        }
    } else {
        Dataset tmp = new DefaultDataset();
        Dataset fromTree = tree.m_clusterInstances;
        for (int i = 0; i < fromTree.size(); i++) {
            tmp.add(fromTree.instance(i));
        }
        clusters.add(tmp);
    }

}