// compute the MCR on the test set
private double GetMCRTestSet() {
int numErrors = 0;
for (int i = NTrain; i < NTrain + NTest; i++) {
double label_i = Sigmoid.Calculate(Predict(i));
if ((Y.get(i) == 1 && label_i < 0.5) || (Y.get(i) == 0 && label_i >= 0.5)) numErrors++;
}
return (double) numErrors / (double) NTest;
}
// predict the label of the i-th instance
public double PredictLabel(int i) {
double label = 0;
double maxConfidence = 0;
for (int l = 0; l < numLabels; l++) {
double confidence =
Sigmoid.Calculate(MatrixUtilities.getRowByColumnProduct(S, i, W, l)); // + biasW[l]);
if (confidence > maxConfidence) {
maxConfidence = confidence;
label = (double) l;
}
}
return label;
}
// get the log loss of the target prediction
public double GetLossY(int startIndex, int endIndex) {
double YTrainLoss = 0;
int numObservedCells = 0;
for (int i = startIndex; i < endIndex; i++)
for (int l = 0; l < numLabels; l++)
if (YExtended.get(i, l) != GlobalValues.MISSING_VALUE) {
double y_hat_i =
Sigmoid.Calculate(
MatrixUtilities.getRowByColumnProduct(S, i, W, l)); // + biasW[l]);
double y_i = YExtended.get(i, l);
YTrainLoss += -y_i * Math.log(y_hat_i) - (1 - y_i) * Math.log(1 - y_hat_i);
numObservedCells++;
}
return YTrainLoss / (double) numObservedCells;
}
public void LearnLA(boolean updateOnlyW) {
if (beta == 1) return;
double e_i = 0, F_ik = 0;
double regWConst = (2 * lambdaW) / NTrain;
for (int i = 0; i < NTrain; i++) {
e_i = Y.get(i) - Sigmoid.Calculate(Predict(i));
for (int k = 0; k < K; k++) {
F_ik = 0;
for (int j = 0; j < NSegments; j++) {
D[i][j][k] -= eta * ((1 - beta) * -2 * e_i * W[k] + lambdaD * D[i][j][k]);
F_ik += D[i][j][k];
}
W[k] -= eta * ((1 - beta) * -2 * e_i * F_ik + regWConst * W[k]);
}
}
}
public double Optimize() {
// initialize the data structures
Initialize();
Random rand = new Random();
double prevLossH = Double.MAX_VALUE;
int YUpdatefrequency = HObserved.size() / numTotalInstances, i, l, idxY = 0;
for (int epoch = 0; epoch < maxEpochs; epoch++) {
// update H loss
if (alphaH > 0) {
double err_il;
for (int idx = 0; idx < HObserved.size(); idx++) {
i = HObserved.get(idx).row;
l = HObserved.get(idx).col;
err_il = H.cells[i][l] - MatrixUtilities.getRowByColumnProduct(S, i, P, l) - biasP[l];
for (int k = 0; k < D; k++) {
S.cells[i][k] -= eta * (-2 * alphaH * err_il * P.cells[k][l] + lambdaS * S.cells[i][k]);
P.cells[k][l] -= eta * (-2 * alphaH * err_il * S.cells[i][k] + lambdaP * P.cells[k][l]);
}
biasP[l] -= eta * (-2 * alphaH * err_il);
if (idx % YUpdatefrequency == 0) {
if (alphaY > 0) {
i = YObserved.get(idxY).row;
l = YObserved.get(idxY).col;
double err_i =
YExtended.cells[i][l]
- Sigmoid.Calculate(
MatrixUtilities.getRowByColumnProduct(S, i, W, l)); // + biasW[l]);
for (int k = 0; k < D; k++) {
S.cells[i][k] -= eta * (alphaY * -err_i * W.cells[k][l] + lambdaS * S.cells[i][k]);
W.cells[k][l] -= eta * (alphaY * -err_i * S.cells[i][k] + lambdaW * W.cells[k][l]);
}
biasW[l] -= eta * (-alphaY * err_i);
idxY = (idxY + 1) % YObserved.size();
}
}
}
}
double lossH = GetLossH();
if (epoch % 3 == 0) {
// compute the losses of each relation and print the result
double lossYTrain = GetLossY(0, numTrainInstances),
lossYTest = GetLossY(numTrainInstances, numTotalInstances),
mcrTrain = GetErrorRate(0, numTrainInstances),
mcrTest = GetErrorRate(numTrainInstances, numTotalInstances),
mcrNN = GetTestErrorNN();
Logging.println(
"Epoch="
+ df.format(epoch)
+ ", Eta="
+ df.format(eta)
+ ", LH="
+ df.format(lossH)
+ ", LY="
+ df.format(lossYTrain)
+ "/"
+ df.format(lossYTest)
+ ", MCR="
+ df.format(mcrTrain)
+ "/"
+ df.format(mcrTest)
+ "/"
+ df.format(mcrNN),
LogLevel.DEBUGGING_LOG);
// Logging.println("LX="+lossX+", LH="+lossH + ", LY="+lossY+", MCR=["+
// mcrTrain+","+mcrTest+"]", LogLevel.DEBUGGING_LOG);
}
if (lossH < prevLossH) {
// eta *= 1.01;
prevLossH = lossH;
} else {
// eta *= 0.7;
}
}
// return the ultimate MCR
return GetErrorRate(numTrainInstances, numTotalInstances);
// return GetTestErrorNN();
}
// compute the accuracy loss of instance i according to the
// smooth hinge loss
public double AccuracyLoss(int i) {
double Y_hat_i = Predict(i);
double sig_y_i = Sigmoid.Calculate(Y_hat_i);
return -Y.get(i) * Math.log(sig_y_i) - (1 - Y.get(i)) * Math.log(1 - sig_y_i);
}