/**
* Copy the current partition into T
*
* @param T the target partition object
*/
private void copy(Partition T) {
if (T == null) {
T = new Partition();
}
System.arraycopy(Pt_x, 0, T.Pt_x, 0, Pt_x.length);
System.arraycopy(Pt, 0, T.Pt, 0, Pt.length);
T.L = L;
T.counter = counter;
double[][] mArray = Py_t.getArray();
double[][] tgtArray = T.Py_t.getArray();
for (int i = 0; i < mArray.length; i++) {
System.arraycopy(mArray[i], 0, tgtArray[i], 0, mArray[0].length);
}
}
/**
* Put an instance into a new cluster and update.
*
* @param instIdx instance to be updated
* @param newt index of the new cluster this instance has been assigned to
* @param T the current working partition
* @param Px an array of prior probabilities of the instances
*/
private void updateAssignment(int instIdx, int newt, Partition T, double Px, Matrix Py_x) {
T.Pt_x[instIdx] = newt;
// update probability of attributes in the cluster
double mass = Px + T.Pt[newt];
double pi1 = Px / mass;
double pi2 = T.Pt[newt] / mass;
for (int i = 0; i < m_numAttributes; i++) {
T.Py_t.set(i, newt, pi1 * Py_x.get(i, instIdx) + pi2 * T.Py_t.get(i, newt));
}
T.Pt[newt] = mass;
}
/**
* Draw a instance out from a cluster.
*
* @param instIdx index of the instance to be drawn out
* @param t index of the cluster which the instance previously belong to
* @param T the current working partition
* @param input the input statistics
*/
private void reduce_x(int instIdx, int t, Partition T, Input input) {
// Update the prior probability of the cluster
ArrayList<Integer> indices = T.find(t);
double sum = 0.0;
for (int i = 0; i < indices.size(); i++) {
if (indices.get(i) == instIdx) {
continue;
}
sum += input.Px[indices.get(i)];
}
T.Pt[t] = sum;
if (T.Pt[t] < 0) {
System.out.format("Warning: probability < 0 (%s)\n", T.Pt[t]);
T.Pt[t] = 0;
}
// Update prob of each attribute in the cluster
double[][] mArray = input.Pyx.getArray();
for (int i = 0; i < m_numAttributes; i++) {
sum = 0.0;
for (int j = 0; j < indices.size(); j++) {
if (indices.get(j) == instIdx) {
continue;
}
sum += mArray[i][indices.get(j)];
}
T.Py_t.set(i, t, sum / T.Pt[t]);
}
}
/**
* Compute the JS divergence between an instance and a cluster, used for training data
*
* @param instIdx index of the instance
* @param input statistics of the input data
* @param T the whole partition
* @param t index of the cluster
* @param pi1
* @param pi2
* @return the JS divergence
*/
private double JS(int instIdx, Input input, Partition T, int t, double pi1, double pi2) {
if (Math.min(pi1, pi2) <= 0) {
System.out.format(
"Warning: zero or negative weights in JS calculation! (pi1 %s, pi2 %s)\n", pi1, pi2);
return 0;
}
Instance inst = m_data.instance(instIdx);
double kl1 = 0.0, kl2 = 0.0, tmp = 0.0;
for (int i = 0; i < inst.numValues(); i++) {
tmp = input.Py_x.get(inst.index(i), instIdx);
if (tmp != 0) {
kl1 += tmp * Math.log(tmp / (tmp * pi1 + pi2 * T.Py_t.get(inst.index(i), t)));
}
}
for (int i = 0; i < m_numAttributes; i++) {
if ((tmp = T.Py_t.get(i, t)) != 0) {
kl2 += tmp * Math.log(tmp / (input.Py_x.get(i, instIdx) * pi1 + pi2 * tmp));
}
}
return pi1 * kl1 + pi2 * kl2;
}
/**
* Initialize the partition
*
* @param input object holding the statistics of the training data
* @return the initialized partition
*/
private Partition sIB_InitT(Input input) {
Partition T = new Partition();
int avgSize = (int) Math.ceil((double) m_numInstances / m_numCluster);
ArrayList<Integer> permInstsIdx = new ArrayList<Integer>();
ArrayList<Integer> unassigned = new ArrayList<Integer>();
for (int i = 0; i < m_numInstances; i++) {
unassigned.add(i);
}
while (unassigned.size() != 0) {
int t = random.nextInt(unassigned.size());
permInstsIdx.add(unassigned.get(t));
unassigned.remove(t);
}
for (int i = 0; i < m_numCluster; i++) {
int r2 = avgSize > permInstsIdx.size() ? permInstsIdx.size() : avgSize;
for (int j = 0; j < r2; j++) {
T.Pt_x[permInstsIdx.get(j)] = i;
}
for (int j = 0; j < r2; j++) {
permInstsIdx.remove(0);
}
}
// initialize the prior prob of each cluster, and the probability
// for each attribute within the cluster
for (int i = 0; i < m_numCluster; i++) {
ArrayList<Integer> indices = T.find(i);
for (int j = 0; j < indices.size(); j++) {
T.Pt[i] += input.Px[indices.get(j)];
}
double[][] mArray = input.Pyx.getArray();
for (int j = 0; j < m_numAttributes; j++) {
double sum = 0.0;
for (int k = 0; k < indices.size(); k++) {
sum += mArray[j][indices.get(k)];
}
sum /= T.Pt[i];
T.Py_t.set(j, i, sum);
}
}
if (m_verbose) {
System.out.println("Initializing...");
}
return T;
}
