int sub1(Quadrotor* r, int* arr, double* coeff, int choices, int repeat) {
int len = pow(choices, repeat);
double C[repeat];
int N = 10000;
//Quadrotor* r = new Quadrotor(0.01, N);
int b = -1;
double ts = 1e10;
// previous winner
set_C(coeff, arr, choices, repeat, (len-1)/2, C);
sub2(r, C, ts, N, (len-1)/2, b);
for(int a = 0; a < len; a++) {
set_C(coeff, arr, choices, repeat, a, C);
//printf("%i %f %f %f %f %f\n",a,C[0],C[1],C[2],C[3],C[4]);
sub2(r, C, ts, N, a, b);
}
return b;
}
Tensor5D CVX_ADMM_MSA (SequenceSet& allSeqs, vector<int>& lenSeqs, int T2, string& dir_path) {
// 1. initialization
int numSeq = allSeqs.size();
vector<Tensor4D> C (numSeq, Tensor4D(0, Tensor(T2, Matrix(NUM_DNA_TYPE,
vector<double>(NUM_MOVEMENT, 0.0)))));
vector<Tensor4D> W_1 (numSeq, Tensor4D(0, Tensor(T2, Matrix(NUM_DNA_TYPE,
vector<double>(NUM_MOVEMENT, 0.0)))));
vector<Tensor4D> W_2 (numSeq, Tensor4D(0, Tensor(T2, Matrix(NUM_DNA_TYPE,
vector<double>(NUM_MOVEMENT, 0.0)))));
vector<Tensor4D> Y (numSeq, Tensor4D(0, Tensor(T2, Matrix(NUM_DNA_TYPE,
vector<double>(NUM_MOVEMENT, 0.0)))));
tensor5D_init (C, allSeqs, lenSeqs, T2);
tensor5D_init (W_1, allSeqs, lenSeqs, T2);
tensor5D_init (W_2, allSeqs, lenSeqs, T2);
tensor5D_init (Y, allSeqs, lenSeqs, T2);
set_C (C, allSeqs);
// 2. ADMM iteration
int iter = 0;
double mu = MU;
double prev_CoZ = MAX_DOUBLE;
while (iter < MAX_ADMM_ITER) {
// 2a. Subprogram: FrankWolf Algorithm
// NOTE: parallelize this for to enable parallelism
#ifdef PARRALLEL_COMPUTING
#pragma omp parallel for
#endif
for (int n = 0; n < numSeq; n++)
first_subproblem (W_1[n], W_2[n], Y[n], C[n], mu, allSeqs[n]);
// 2b. Subprogram:
second_subproblem (W_1, W_2, Y, mu, allSeqs, lenSeqs);
// 2d. update Y: Y += mu * (W_1 - W_2)
for (int n = 0; n < numSeq; n ++)
tensor4D_lin_update (Y[n], W_1[n], W_2[n], mu);
// 2e. print out tracking info
double CoZ = 0.0;
for (int n = 0; n < numSeq; n++)
CoZ += tensor4D_frob_prod(C[n], W_2[n]);
double W1mW2 = 0.0;
for (int n = 0; n < numSeq; n ++) {
int T1 = W_1[n].size();
for (int i = 0; i < T1; i ++)
for (int j = 0; j < T2; j ++)
for (int d = 0; d < NUM_DNA_TYPE; d ++)
for (int m = 0; m < NUM_MOVEMENT; m ++) {
double value = (W_1[n][i][j][d][m] - W_2[n][i][j][d][m]);
W1mW2 = max( fabs(value), W1mW2 ) ;
}
}
///////////////////////////////////Copy from Main/////////////////////////////////////////
int T2m = T2;
Tensor tensor (T2m, Matrix (NUM_DNA_TYPE, vector<double>(NUM_DNA_TYPE, 0.0)));
Matrix mat_insertion (T2m, vector<double> (NUM_DNA_TYPE, 0.0));
for (int n = 0; n < numSeq; n ++) {
int T1 = W_2[n].size();
for (int i = 0; i < T1; i ++) {
for (int j = 0; j < T2m; j ++) {
for (int d = 0; d < NUM_DNA_TYPE; d ++) {
for (int m = 0; m < NUM_MOVEMENT; m ++) {
if (m == DELETION_A or m == MATCH_A)
tensor[j][d][dna2T3idx('A')] += max(0.0, W_2[n][i][j][d][m]);
else if (m == DELETION_T or m == MATCH_T)
tensor[j][d][dna2T3idx('T')] += max(0.0, W_2[n][i][j][d][m]);
else if (m == DELETION_C or m == MATCH_C)
tensor[j][d][dna2T3idx('C')] += max(0.0, W_2[n][i][j][d][m]);
else if (m == DELETION_G or m == MATCH_G)
tensor[j][d][dna2T3idx('G')] += max(0.0, W_2[n][i][j][d][m]);
else if (m == DELETION_START or m == MATCH_START)
tensor[j][d][dna2T3idx('*')] += max(0.0, W_2[n][i][j][d][m]);
else if (m == DELETION_END or m == MATCH_END)
tensor[j][d][dna2T3idx('#')] += max(0.0, W_2[n][i][j][d][m]);
else if (m == INSERTION)
mat_insertion[j][d] += max(0.0, W_2[n][i][j][d][m]);
}
}
}
}
}
Trace trace (0, Cell(2)); // 1d: j, 2d: ATCG
refined_viterbi_algo (trace, tensor, mat_insertion);
Sequence recSeq;
for (int i = 0; i < trace.size(); i ++)
if (trace[i].action != INSERTION) {
recSeq.push_back(trace[i].acidB);
if (trace[i].acidB == '#') break;
}
////////////////////////////////END copy from MAIN/////////////////////////////////////////////////////
SequenceSet allModelSeqs, allDataSeqs;
double obj_rounded = 0.0;
for (int n = 0; n < numSeq; n ++) {
Sequence model_seq = recSeq, data_seq = allSeqs[n];
data_seq.erase(data_seq.begin());
model_seq.erase(model_seq.begin());
data_seq.erase(data_seq.end()-1);
model_seq.erase(model_seq.end()-1);
// align sequences locally
Plane plane (data_seq.size()+1, Trace(model_seq.size()+1, Cell(2)));
Trace trace (0, Cell(2));
smith_waterman (model_seq, data_seq, plane, trace);
// get the objective of rounded result
for (int i = 0; i < trace.size(); i ++) {
if (trace[i].acidA == '-' && trace[i].acidB != '-')
obj_rounded += 1.0;//C_I;
else if (trace[i].acidA != '-' && trace[i].acidB == '-')
obj_rounded += 1.0;//C_D;
else if (trace[i].acidA == trace[i].acidB)
obj_rounded += 0.0;//C_M;
else if (trace[i].acidA != trace[i].acidB)
obj_rounded += 1.0;//C_MM;
}
model_seq.clear(); data_seq.clear();
for (int i = 0; i < trace.size(); i ++)
model_seq.push_back(trace[i].acidA);
for (int i = 0; i < trace.size(); i ++)
data_seq.push_back(trace[i].acidB);
allModelSeqs.push_back(model_seq);
allDataSeqs.push_back(data_seq);
}
//writeClusterView( dir_path+to_string(iter), allModelSeqs, allDataSeqs );
// cerr << "=============================================================================" << endl;
char COZ_val [50], w1mw2_val [50];
sprintf(COZ_val, "%6f", CoZ);
sprintf(w1mw2_val, "%6f", W1mW2);
cerr << "ADMM_iter = " << iter
<< ", C o Z = " << COZ_val
<< ", Wdiff_max = " << w1mw2_val
<< ", obj_rounded = " << obj_rounded
<< endl;
// cerr << "sub1_Obj = CoW_1+0.5*mu*||W_1-Z+1/mu*Y_1||^2 = " << sub1_cost << endl;
// cerr << "sub2_Obj = ||W_2-Z+1/mu*Y_2||^2 = " << sub2_cost << endl;
// 2f. stopping conditions
if (ADMM_EARLY_STOP_TOGGLE and iter > MIN_ADMM_ITER)
if ( W1mW2 < EPS_Wdiff ) {
cerr << "CoZ Converges. ADMM early stop!" << endl;
break;
}
prev_CoZ = CoZ;
iter ++;
}
cout << "W_1: " << endl;
for (int i = 0; i < numSeq; i ++) tensor4D_dump(W_1[i]);
cout << "W_2: " << endl;
for (int i = 0; i < numSeq; i ++) tensor4D_dump(W_2[i]);
return W_2;
}
NHERD::NHERD (storage::storage_base* storage) : classifier_base(storage) {
classifier_base::use_covars_ = true;
set_C(0.1f);
}