public double getLogLikelihood() {
double logSum = Double.NEGATIVE_INFINITY;
for (int i = 0; i < likelihoodList.size(); ++i) {
double pi = mixtureWeights.getParameterValue(i);
if (pi > 0.0) {
logSum = LogTricks.logSum(logSum, Math.log(pi) + likelihoodList.get(i).getLogLikelihood());
}
}
return logSum;
}
public DistanceDependentCRPGibbsOperator(
Parameter links,
Parameter assignments,
Parameter chiParameter,
NPAntigenicLikelihood Likelihood,
double weight) {
this.links = links;
this.assignments = assignments;
this.modelLikelihood = Likelihood;
this.chiParameter = chiParameter;
this.depMatrix = Likelihood.getLogDepMatrix();
for (int i = 0; i < links.getDimension(); i++) {
links.setParameterValue(i, i);
}
setWeight(weight);
// double[][] x=modelLikelihood.getData();
// modelLikelihood.printInformtion(x[0][0]);
this.m = new double[2];
m[0] = modelLikelihood.priorMean.getParameterValue(0);
m[1] = modelLikelihood.priorMean.getParameterValue(1);
this.v0 = 2;
this.k0 =
modelLikelihood.priorPrec.getParameterValue(0)
/ modelLikelihood.clusterPrec.getParameterValue(0);
this.T0Inv = new double[2][2];
T0Inv[0][0] = v0 / modelLikelihood.clusterPrec.getParameterValue(0);
T0Inv[1][1] = v0 / modelLikelihood.clusterPrec.getParameterValue(0);
T0Inv[1][0] = 0.0;
T0Inv[0][1] = 0.0;
this.logDetT0 = -Math.log(T0Inv[0][0] * T0Inv[1][1]);
}
public void proposeTree() throws OperatorFailedException {
TreeModel tree = c2cLikelihood.getTreeModel();
BranchMapModel branchMap = c2cLikelihood.getBranchMap();
NodeRef i;
double oldMinAge, newMinAge, newRange, oldRange, newAge, q;
// choose a random node avoiding root, and nodes that are ineligible for this move because they
// have nowhere to
// go
final int nodeCount = tree.getNodeCount();
do {
i = tree.getNode(MathUtils.nextInt(nodeCount));
} while (tree.getRoot() == i || !eligibleForMove(i, tree, branchMap));
final NodeRef iP = tree.getParent(i);
// this one can go anywhere
NodeRef j = tree.getNode(MathUtils.nextInt(tree.getNodeCount()));
NodeRef k = tree.getParent(j);
while ((k != null && tree.getNodeHeight(k) <= tree.getNodeHeight(i)) || (i == j)) {
j = tree.getNode(MathUtils.nextInt(tree.getNodeCount()));
k = tree.getParent(j);
}
if (iP == tree.getRoot() || j == tree.getRoot()) {
throw new OperatorFailedException("Root changes not allowed!");
}
if (k == iP || j == iP || k == i) throw new OperatorFailedException("move failed");
final NodeRef CiP = getOtherChild(tree, iP, i);
NodeRef PiP = tree.getParent(iP);
newMinAge = Math.max(tree.getNodeHeight(i), tree.getNodeHeight(j));
newRange = tree.getNodeHeight(k) - newMinAge;
newAge = newMinAge + (MathUtils.nextDouble() * newRange);
oldMinAge = Math.max(tree.getNodeHeight(i), tree.getNodeHeight(CiP));
oldRange = tree.getNodeHeight(PiP) - oldMinAge;
q = newRange / Math.abs(oldRange);
// need to account for the random repainting of iP
if (branchMap.get(PiP.getNumber()) != branchMap.get(CiP.getNumber())) {
q *= 0.5;
}
if (branchMap.get(k.getNumber()) != branchMap.get(j.getNumber())) {
q *= 2;
}
tree.beginTreeEdit();
if (j == tree.getRoot()) {
// 1. remove edges <iP, CiP>
tree.removeChild(iP, CiP);
tree.removeChild(PiP, iP);
// 2. add edges <k, iP>, <iP, j>, <PiP, CiP>
tree.addChild(iP, j);
tree.addChild(PiP, CiP);
// iP is the new root
tree.setRoot(iP);
} else if (iP == tree.getRoot()) {
// 1. remove edges <k, j>, <iP, CiP>, <PiP, iP>
tree.removeChild(k, j);
tree.removeChild(iP, CiP);
// 2. add edges <k, iP>, <iP, j>, <PiP, CiP>
tree.addChild(iP, j);
tree.addChild(k, iP);
// CiP is the new root
tree.setRoot(CiP);
} else {
// 1. remove edges <k, j>, <iP, CiP>, <PiP, iP>
tree.removeChild(k, j);
tree.removeChild(iP, CiP);
tree.removeChild(PiP, iP);
// 2. add edges <k, iP>, <iP, j>, <PiP, CiP>
tree.addChild(iP, j);
tree.addChild(k, iP);
tree.addChild(PiP, CiP);
}
tree.setNodeHeight(iP, newAge);
tree.endTreeEdit();
//
logq = Math.log(q);
// repaint the parent to match either its new parent or its new child (50% chance of each).
if (MathUtils.nextInt(2) == 0) {
branchMap.set(iP.getNumber(), branchMap.get(k.getNumber()), true);
} else {
branchMap.set(iP.getNumber(), branchMap.get(j.getNumber()), true);
}
if (DEBUG) {
c2cLikelihood.checkPartitions();
}
}
public static void main(String[] args) {
final double l1 = -10;
final double l2 = -2;
AbstractModelLikelihood like1 =
new AbstractModelLikelihood("dummy") {
public Model getModel() {
return null;
}
public double getLogLikelihood() {
return l1;
}
public void makeDirty() {}
public String prettyName() {
return null;
}
public boolean isUsed() {
return false;
}
@Override
protected void handleModelChangedEvent(Model model, Object object, int index) {}
@Override
protected void handleVariableChangedEvent(
Variable variable, int index, Variable.ChangeType type) {}
@Override
protected void storeState() {}
@Override
protected void restoreState() {}
@Override
protected void acceptState() {}
public void setUsed() {}
public LogColumn[] getColumns() {
return new LogColumn[0];
}
public String getId() {
return null;
}
public void setId(String id) {}
};
AbstractModelLikelihood like2 =
new AbstractModelLikelihood("dummy") {
public Model getModel() {
return null;
}
public double getLogLikelihood() {
return l2;
}
public void makeDirty() {}
public String prettyName() {
return null;
}
public boolean isUsed() {
return false;
}
@Override
protected void handleModelChangedEvent(Model model, Object object, int index) {}
@Override
protected void handleVariableChangedEvent(
Variable variable, int index, Variable.ChangeType type) {}
@Override
protected void storeState() {}
@Override
protected void restoreState() {}
@Override
protected void acceptState() {}
public void setUsed() {}
public LogColumn[] getColumns() {
return new LogColumn[0];
}
public String getId() {
return null;
}
public void setId(String id) {}
};
List<AbstractModelLikelihood> likelihoodList = new ArrayList<AbstractModelLikelihood>();
likelihoodList.add(like1);
likelihoodList.add(like2);
Parameter weights = new Parameter.Default(2);
double p1 = 0.05;
weights.setParameterValue(0, p1);
weights.setParameterValue(1, 1.0 - p1);
WeightedMixtureModel mixture = new WeightedMixtureModel(likelihoodList, weights);
System.err.println("getLogLikelihood() = " + mixture.getLogLikelihood());
double test = Math.log(p1 * Math.exp(l1) + (1.0 - p1) * Math.exp(l2));
System.err.println("correct = " + test);
}
public double getCoercableParameter() {
return Math.log(scaleFactor);
}
/** change the parameter and return the hastings ratio. */
public final double doOperation() {
int index = MathUtils.nextInt(links.getDimension());
int oldGroup = (int) assignments.getParameterValue(index);
/*
* Set index customer link to index and all connected to it to a new assignment (min value empty)
*/
int minEmp = minEmpty(modelLikelihood.getLogLikelihoodsVector());
links.setParameterValue(index, index);
int[] visited = connected(index, links);
int ii = 0;
while (visited[ii] != 0) {
assignments.setParameterValue(visited[ii] - 1, minEmp);
ii++;
}
/*
* Adjust likvector for group separated
*/
modelLikelihood.setLogLikelihoodsVector(oldGroup, getLogLikGroup(oldGroup));
modelLikelihood.setLogLikelihoodsVector(minEmp, getLogLikGroup(minEmp));
int maxFull = maxFull(modelLikelihood.getLogLikelihoodsVector());
double[] liks = modelLikelihood.getLogLikelihoodsVector();
/*
* computing likelihoods of joint groups
*/
double[] crossedLiks = new double[maxFull + 1];
for (int ll = 0; ll < maxFull + 1; ll++) {
if (ll != minEmp) {
crossedLiks[ll] = getLogLik2Group(ll, minEmp);
}
}
/*
* Add logPrior
*/
double[] logP = new double[links.getDimension()];
for (int jj = 0; jj < links.getDimension(); jj++) {
logP[jj] += depMatrix[index][jj];
int n = (int) assignments.getParameterValue(jj);
if (n != minEmp) {
logP[jj] += crossedLiks[n] - liks[n] - liks[minEmp];
}
}
logP[index] = Math.log(chiParameter.getParameterValue(0));
/*
* possibilidade de mandar p zero as probs muito pequenas
*/
/*
* Gibbs sampling
*/
this.rescale(logP); // Improve numerical stability
this.exp(logP); // Transform back to probability-scale
int k = MathUtils.randomChoicePDF(logP);
links.setParameterValue(index, k);
int newGroup = (int) assignments.getParameterValue(k);
ii = 0;
while (visited[ii] != 0) {
assignments.setParameterValue(visited[ii] - 1, newGroup);
ii++;
}
/*
* updating conditional likelihood vector
*/
modelLikelihood.setLogLikelihoodsVector(newGroup, getLogLikGroup(newGroup));
if (newGroup != minEmp) {
modelLikelihood.setLogLikelihoodsVector(minEmp, 0);
}
sampleMeans(maxFull);
return 0.0;
}
public double getLogLik2Group(int group1, int group2) {
double L = 0.0;
int ngroup1 = 0;
for (int i = 0; i < assignments.getDimension(); i++) {
if ((int) assignments.getParameterValue(i) == group1) {
ngroup1++;
}
}
int ngroup2 = 0;
for (int i = 0; i < assignments.getDimension(); i++) {
if ((int) assignments.getParameterValue(i) == group2) {
ngroup2++;
}
}
int ngroup = (ngroup1 + ngroup2);
if (ngroup != 0) {
double[][] group = new double[ngroup][2];
double mean[] = new double[2];
int count = 0;
for (int i = 0; i < assignments.getDimension(); i++) {
if ((int) assignments.getParameterValue(i) == group1) {
group[count][0] = modelLikelihood.getData()[i][0];
group[count][1] = modelLikelihood.getData()[i][1];
mean[0] += group[count][0];
mean[1] += group[count][1];
count += 1;
}
}
for (int i = 0; i < assignments.getDimension(); i++) {
if ((int) assignments.getParameterValue(i) == group2) {
group[count][0] = modelLikelihood.getData()[i][0];
group[count][1] = modelLikelihood.getData()[i][1];
mean[0] += group[count][0];
mean[1] += group[count][1];
count += 1;
}
}
mean[0] /= ngroup;
mean[1] /= ngroup;
double kn = k0 + ngroup;
double vn = v0 + ngroup;
double[][] sumdif = new double[2][2];
for (int i = 0; i < ngroup; i++) {
sumdif[0][0] += (group[i][0] - mean[0]) * (group[i][0] - mean[0]);
sumdif[0][1] += (group[i][0] - mean[0]) * (group[i][1] - mean[1]);
sumdif[1][0] += (group[i][0] - mean[0]) * (group[i][1] - mean[1]);
sumdif[1][1] += (group[i][1] - mean[1]) * (group[i][1] - mean[1]);
}
double[][] TnInv = new double[2][2];
TnInv[0][0] =
T0Inv[0][0] + ngroup * (k0 / kn) * (mean[0] - m[0]) * (mean[0] - m[0]) + sumdif[0][0];
TnInv[0][1] =
T0Inv[0][1] + ngroup * (k0 / kn) * (mean[1] - m[1]) * (mean[0] - m[0]) + sumdif[0][1];
TnInv[1][0] =
T0Inv[1][0] + ngroup * (k0 / kn) * (mean[0] - m[0]) * (mean[1] - m[1]) + sumdif[1][0];
TnInv[1][1] =
T0Inv[1][1] + ngroup * (k0 / kn) * (mean[1] - m[1]) * (mean[1] - m[1]) + sumdif[1][1];
double logDetTn = -Math.log(TnInv[0][0] * TnInv[1][1] - TnInv[0][1] * TnInv[1][0]);
L += -(ngroup) * Math.log(Math.PI);
L += Math.log(k0) - Math.log(kn);
L += (vn / 2) * logDetTn - (v0 / 2) * logDetT0;
L += GammaFunction.lnGamma(vn / 2) + GammaFunction.lnGamma((vn / 2) - 0.5);
L += -GammaFunction.lnGamma(v0 / 2) - GammaFunction.lnGamma((v0 / 2) - 0.5);
}
return L;
}