bool Solver_MCSVM_CS::be_shrunk(int i, int m, int yi, double alpha_i, double minG)
{
double bound = 0;
if(m == yi)
bound = C[GETI(i)];
if(alpha_i == bound && G[m] < minG)
return true;
return false;
}
int agc_naive(char *s1, char *s2, int r1, int r2, int c1, int c2) {
// fprintf(stderr, "[1] r1: %d, r2: %d, c1: %d, c2: %d\n", r1, r2, c1, c2);
for (; r1 < r2 + 1; ++r1) {
// fprintf(stderr, "R1: %d\n", r1);
for(int c = c1; c < c2 + 1; ++c) {
// fprintf(stderr, "(r1, c1) == (%d, %d)\n", r1, c1);
GETD(s1, s2, r1, c);
GETI(s1, s2, r1, c);
GETG(s1, s2, r1, c);
}
}
// fprintf(stderr, "[2] r1: %d, r2: %d, c1: %d, c2: %d\n", r1, r2, c1, c2);
return G[r2][c2];
}
/* Wrapper over uvread_c to deal with numpy arrays, conversion of baseline
* and polarization codes, and returning a tuple of all results.
*/
PyObject * UVObject_read(UVObject *self, PyObject *args) {
PyArrayObject *data, *flags, *uvw;
PyObject *rv;
int nread, n2read, i, j;
double preamble[PREAMBLE_SIZE];
if (!PyArg_ParseTuple(args, "i", &n2read)) return NULL;
// Make numpy arrays to hold the results
npy_intp data_dims[1] = {n2read};
data = (PyArrayObject *) PyArray_SimpleNew(1, data_dims, PyArray_CFLOAT);
CHK_NULL(data);
flags = (PyArrayObject *) PyArray_SimpleNew(1, data_dims, PyArray_INT);
CHK_NULL(flags);
while (1) {
// Here is the MIRIAD call
try {
uvread_c(self->tno, preamble,
(float *)data->data, (int *)flags->data, n2read, &nread);
} catch (MiriadError &e) {
PyErr_Format(PyExc_RuntimeError, e.get_message());
return NULL;
}
if (preamble[3] != self->curtime) {
self->intcnt += 1;
self->curtime = preamble[3];
}
if ((self->intcnt-self->decphase) % self->decimate == 0 || nread==0) {
break;
}
}
// Now we build a return value of ((uvw,t,(i,j)), data, flags, nread)
npy_intp uvw_dims[1] = {3};
uvw = (PyArrayObject *) PyArray_SimpleNew(1, uvw_dims, PyArray_DOUBLE);
CHK_NULL(uvw);
IND1(uvw,0,double) = preamble[0];
IND1(uvw,1,double) = preamble[1];
IND1(uvw,2,double) = preamble[2];
i = GETI(preamble[4]);
j = GETJ(preamble[4]);
rv = Py_BuildValue("((Od(ii))OOi)",
(PyObject *)uvw, preamble[3], i, j,
(PyObject *)data, (PyObject *)flags, nread);
CHK_NULL(rv);
Py_DECREF(uvw); Py_DECREF(data); Py_DECREF(flags);
return rv;
}
void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, double Cn)
{
int l = prob->l;
int w_size = prob->n;
int i, s, iter = 0;
double *xTx = new double[l];
int max_iter = 1000;
int *index = new int[l];
double *alpha = new double[2*l]; // store alpha and C - alpha
schar *y = new schar[l];
int max_inner_iter = 100; // for inner Newton
double innereps = 1e-2;
double innereps_min = min(1e-8, eps);
double upper_bound[3] = {Cn, 0, Cp};
for(i=0; i<w_size; i++)
w[i] = 0;
for(i=0; i<l; i++)
{
if(prob->y[i] > 0)
{
y[i] = +1;
}
else
{
y[i] = -1;
}
alpha[2*i] = min(0.001*upper_bound[GETI(i)], 1e-8);
alpha[2*i+1] = upper_bound[GETI(i)] - alpha[2*i];
xTx[i] = 0;
feature_node *xi = prob->x[i];
while (xi->index != -1)
{
xTx[i] += (xi->value)*(xi->value);
w[xi->index-1] += y[i]*alpha[2*i]*xi->value;
xi++;
}
index[i] = i;
}
while (iter < max_iter)
{
for (i=0; i<l; i++)
{
int j = i+rand()%(l-i);
swap(index[i], index[j]);
}
int newton_iter = 0;
double Gmax = 0;
for (s=0; s<l; s++)
{
i = index[s];
schar yi = y[i];
double C = upper_bound[GETI(i)];
double ywTx = 0, xisq = xTx[i];
feature_node *xi = prob->x[i];
while (xi->index != -1)
{
ywTx += w[xi->index-1]*xi->value;
xi++;
}
ywTx *= y[i];
double a = xisq, b = ywTx;
// Decide to minimize g_1(z) or g_2(z)
int ind1 = 2*i, ind2 = 2*i+1, sign = 1;
if(0.5*a*(alpha[ind2]-alpha[ind1])+b < 0)
{
ind1 = 2*i+1;
ind2 = 2*i;
sign = -1;
}
// g_t(z) = z*log(z) + (C-z)*log(C-z) + 0.5a(z-alpha_old)^2 + sign*b(z-alpha_old)
double alpha_old = alpha[ind1];
double z = alpha_old;
if(C - z < 0.5 * C)
z = 0.1*z;
double gp = a*(z-alpha_old)+sign*b+log(z/(C-z));
Gmax = max(Gmax, fabs(gp));
// Newton method on the sub-problem
const double eta = 0.1; // xi in the paper
int inner_iter = 0;
while (inner_iter <= max_inner_iter)
{
if(fabs(gp) < innereps)
break;
double gpp = a + C/(C-z)/z;
double tmpz = z - gp/gpp;
if(tmpz <= 0)
z *= eta;
else // tmpz in (0, C)
z = tmpz;
gp = a*(z-alpha_old)+sign*b+log(z/(C-z));
newton_iter++;
inner_iter++;
}
if(inner_iter > 0) // update w
{
alpha[ind1] = z;
alpha[ind2] = C-z;
xi = prob->x[i];
while (xi->index != -1)
{
w[xi->index-1] += sign*(z-alpha_old)*yi*xi->value;
xi++;
}
}
}
iter++;
if(iter % 10 == 0)
info(".");
if(Gmax < eps)
break;
if(newton_iter < l/10)
innereps = max(innereps_min, 0.1*innereps);
}
info("\noptimization finished, #iter = %d\n",iter);
if (iter >= max_iter)
info("\nWARNING: reaching max number of iterations\nUsing -s 0 may be faster (also see FAQ)\n\n");
// calculate objective value
double v = 0;
for(i=0; i<w_size; i++)
v += w[i] * w[i];
v *= 0.5;
for(i=0; i<l; i++)
v += alpha[2*i] * log(alpha[2*i]) + alpha[2*i+1] * log(alpha[2*i+1])
- upper_bound[GETI(i)] * log(upper_bound[GETI(i)]);
info("Objective value = %lf\n", v);
delete [] xTx;
delete [] alpha;
delete [] y;
delete [] index;
}
static void solve_l2r_l1l2_svc(
const problem *prob, double *w, double eps,
double Cp, double Cn, int solver_type)
{
int l = prob->l;
int w_size = prob->n;
int i, s, iter = 0;
double C, d, G;
double *QD = new double[l];
int max_iter = 1000;
int *index = new int[l];
double *alpha = new double[l];
schar *y = new schar[l];
int active_size = l;
// PG: projected gradient, for shrinking and stopping
double PG;
double PGmax_old = INF;
double PGmin_old = -INF;
double PGmax_new, PGmin_new;
// default solver_type: L2R_L2LOSS_SVC_DUAL
double diag[3] = {0.5/Cn, 0, 0.5/Cp};
double upper_bound[3] = {INF, 0, INF};
if(solver_type == L2R_L1LOSS_SVC_DUAL)
{
diag[0] = 0;
diag[2] = 0;
upper_bound[0] = Cn;
upper_bound[2] = Cp;
}
for(i=0; i<w_size; i++)
w[i] = 0;
for(i=0; i<l; i++)
{
alpha[i] = 0;
if(prob->y[i] > 0)
{
y[i] = +1;
}
else
{
y[i] = -1;
}
QD[i] = diag[GETI(i)];
feature_node *xi = prob->x[i];
while (xi->index != -1)
{
QD[i] += (xi->value)*(xi->value);
xi++;
}
index[i] = i;
}
while (iter < max_iter)
{
PGmax_new = -INF;
PGmin_new = INF;
for (i=0; i<active_size; i++)
{
int j = i+rand()%(active_size-i);
swap(index[i], index[j]);
}
for (s=0; s<active_size; s++)
{
i = index[s];
G = 0;
schar yi = y[i];
feature_node *xi = prob->x[i];
while(xi->index!= -1)
{
G += w[xi->index-1]*(xi->value);
xi++;
}
G = G*yi-1;
C = upper_bound[GETI(i)];
G += alpha[i]*diag[GETI(i)];
PG = 0;
if (alpha[i] == 0)
{
if (G > PGmax_old)
{
active_size--;
swap(index[s], index[active_size]);
s--;
continue;
}
else if (G < 0)
PG = G;
}
else if (alpha[i] == C)
{
if (G < PGmin_old)
{
active_size--;
swap(index[s], index[active_size]);
s--;
continue;
}
else if (G > 0)
PG = G;
}
else
PG = G;
PGmax_new = max(PGmax_new, PG);
PGmin_new = min(PGmin_new, PG);
if(fabs(PG) > 1.0e-12)
{
double alpha_old = alpha[i];
alpha[i] = min(max(alpha[i] - G/QD[i], 0.0), C);
d = (alpha[i] - alpha_old)*yi;
xi = prob->x[i];
while (xi->index != -1)
{
w[xi->index-1] += d*xi->value;
xi++;
}
}
}
iter++;
if(iter % 10 == 0)
info(".");
if(PGmax_new - PGmin_new <= eps)
{
if(active_size == l)
break;
else
{
active_size = l;
info("*");
PGmax_old = INF;
PGmin_old = -INF;
continue;
}
}
PGmax_old = PGmax_new;
PGmin_old = PGmin_new;
if (PGmax_old <= 0)
PGmax_old = INF;
if (PGmin_old >= 0)
PGmin_old = -INF;
}
info("\noptimization finished, #iter = %d\n",iter);
if (iter >= max_iter)
info("\nWARNING: reaching max number of iterations\nUsing -s 2 may be faster (also see FAQ)\n\n");
// calculate objective value
double v = 0;
int nSV = 0;
for(i=0; i<w_size; i++)
v += w[i]*w[i];
for(i=0; i<l; i++)
{
v += alpha[i]*(alpha[i]*diag[GETI(i)] - 2);
if(alpha[i] > 0)
++nSV;
}
info("Objective value = %lf\n",v/2);
info("nSV = %d\n",nSV);
delete [] QD;
delete [] alpha;
delete [] y;
delete [] index;
}
void Solver_MCSVM_CS::Solve(double *w)
{
int i, m, s;
int iter = 0;
double *alpha = new double[l*nr_class];
double *alpha_new = new double[nr_class];
int *index = new int[l];
double *QD = new double[l];
int *d_ind = new int[nr_class];
double *d_val = new double[nr_class];
int *alpha_index = new int[nr_class*l];
int *y_index = new int[l];
int active_size = l;
int *active_size_i = new int[l];
double eps_shrink = max(10.0*eps, 1.0); // stopping tolerance for shrinking
bool start_from_all = true;
// initial
for(i=0;i<l*nr_class;i++)
alpha[i] = 0;
for(i=0;i<w_size*nr_class;i++)
w[i] = 0;
for(i=0;i<l;i++)
{
for(m=0;m<nr_class;m++)
alpha_index[i*nr_class+m] = m;
feature_node *xi = prob->x[i];
QD[i] = 0;
while(xi->index != -1)
{
QD[i] += (xi->value)*(xi->value);
xi++;
}
active_size_i[i] = nr_class;
y_index[i] = prob->y[i];
index[i] = i;
}
while(iter < max_iter)
{
double stopping = -INF;
for(i=0;i<active_size;i++)
{
int j = i+rand()%(active_size-i);
swap(index[i], index[j]);
}
for(s=0;s<active_size;s++)
{
i = index[s];
double Ai = QD[i];
double *alpha_i = &alpha[i*nr_class];
int *alpha_index_i = &alpha_index[i*nr_class];
if(Ai > 0)
{
for(m=0;m<active_size_i[i];m++)
G[m] = 1;
if(y_index[i] < active_size_i[i])
G[y_index[i]] = 0;
feature_node *xi = prob->x[i];
while(xi->index!= -1)
{
double *w_i = &w[(xi->index-1)*nr_class];
for(m=0;m<active_size_i[i];m++)
G[m] += w_i[alpha_index_i[m]]*(xi->value);
xi++;
}
double minG = INF;
double maxG = -INF;
for(m=0;m<active_size_i[i];m++)
{
if(alpha_i[alpha_index_i[m]] < 0 && G[m] < minG)
minG = G[m];
if(G[m] > maxG)
maxG = G[m];
}
if(y_index[i] < active_size_i[i])
if(alpha_i[prob->y[i]] < C[GETI(i)] && G[y_index[i]] < minG)
minG = G[y_index[i]];
for(m=0;m<active_size_i[i];m++)
{
if(be_shrunk(i, m, y_index[i], alpha_i[alpha_index_i[m]], minG))
{
active_size_i[i]--;
while(active_size_i[i]>m)
{
if(!be_shrunk(i, active_size_i[i], y_index[i],
alpha_i[alpha_index_i[active_size_i[i]]], minG))
{
swap(alpha_index_i[m], alpha_index_i[active_size_i[i]]);
swap(G[m], G[active_size_i[i]]);
if(y_index[i] == active_size_i[i])
y_index[i] = m;
else if(y_index[i] == m)
y_index[i] = active_size_i[i];
break;
}
active_size_i[i]--;
}
}
}
if(active_size_i[i] <= 1)
{
active_size--;
swap(index[s], index[active_size]);
s--;
continue;
}
if(maxG-minG <= 1e-12)
continue;
else
stopping = max(maxG - minG, stopping);
for(m=0;m<active_size_i[i];m++)
B[m] = G[m] - Ai*alpha_i[alpha_index_i[m]] ;
solve_sub_problem(Ai, y_index[i], C[GETI(i)], active_size_i[i], alpha_new);
int nz_d = 0;
for(m=0;m<active_size_i[i];m++)
{
double d = alpha_new[m] - alpha_i[alpha_index_i[m]];
alpha_i[alpha_index_i[m]] = alpha_new[m];
if(fabs(d) >= 1e-12)
{
d_ind[nz_d] = alpha_index_i[m];
d_val[nz_d] = d;
nz_d++;
}
}
xi = prob->x[i];
while(xi->index != -1)
{
double *w_i = &w[(xi->index-1)*nr_class];
for(m=0;m<nz_d;m++)
w_i[d_ind[m]] += d_val[m]*xi->value;
xi++;
}
}
}
iter++;
if(iter % 10 == 0)
{
info(".");
}
if(stopping < eps_shrink)
{
if(stopping < eps && start_from_all == true)
break;
else
{
active_size = l;
for(i=0;i<l;i++)
active_size_i[i] = nr_class;
info("*");
eps_shrink = max(eps_shrink/2, eps);
start_from_all = true;
}
}
else
start_from_all = false;
}
info("\noptimization finished, #iter = %d\n",iter);
if (iter >= max_iter)
info("\nWARNING: reaching max number of iterations\n");
// calculate objective value
double v = 0;
int nSV = 0;
for(i=0;i<w_size*nr_class;i++)
v += w[i]*w[i];
v = 0.5*v;
for(i=0;i<l*nr_class;i++)
{
v += alpha[i];
if(fabs(alpha[i]) > 0)
nSV++;
}
for(i=0;i<l;i++)
v -= alpha[i*nr_class+prob->y[i]];
info("Objective value = %lf\n",v);
info("nSV = %d\n",nSV);
delete [] alpha;
delete [] alpha_new;
delete [] index;
delete [] QD;
delete [] d_ind;
delete [] d_val;
delete [] alpha_index;
delete [] y_index;
delete [] active_size_i;
}
static void solve_l1r_lr(
const problem *prob_col, double *w, double eps,
double Cp, double Cn)
{
int l = prob_col->l;
int w_size = prob_col->n;
int j, s, iter = 0;
int max_iter = 1000;
int active_size = w_size;
int max_num_linesearch = 20;
double x_min = 0;
double sigma = 0.01;
double d, G, H;
double Gmax_old = INF;
double Gmax_new;
double Gmax_init;
double sum1, appxcond1;
double sum2, appxcond2;
double cond;
int *index = new int[w_size];
schar *y = new schar[l];
double *exp_wTx = new double[l];
double *exp_wTx_new = new double[l];
double *xj_max = new double[w_size];
double *C_sum = new double[w_size];
double *xjneg_sum = new double[w_size];
double *xjpos_sum = new double[w_size];
feature_node *x;
double C[3] = {Cn,0,Cp};
for(j=0; j<l; j++)
{
exp_wTx[j] = 1;
if(prob_col->y[j] > 0)
y[j] = 1;
else
y[j] = -1;
}
for(j=0; j<w_size; j++)
{
w[j] = 0;
index[j] = j;
xj_max[j] = 0;
C_sum[j] = 0;
xjneg_sum[j] = 0;
xjpos_sum[j] = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
double val = x->value;
x_min = min(x_min, val);
xj_max[j] = max(xj_max[j], val);
C_sum[j] += C[GETI(ind)];
if(y[ind] == -1)
xjneg_sum[j] += C[GETI(ind)]*val;
else
xjpos_sum[j] += C[GETI(ind)]*val;
x++;
}
}
while(iter < max_iter)
{
Gmax_new = 0;
for(j=0; j<active_size; j++)
{
int i = j+rand()%(active_size-j);
swap(index[i], index[j]);
}
for(s=0; s<active_size; s++)
{
j = index[s];
sum1 = 0;
sum2 = 0;
H = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
double exp_wTxind = exp_wTx[ind];
double tmp1 = x->value/(1+exp_wTxind);
double tmp2 = C[GETI(ind)]*tmp1;
double tmp3 = tmp2*exp_wTxind;
sum2 += tmp2;
sum1 += tmp3;
H += tmp1*tmp3;
x++;
}
G = -sum2 + xjneg_sum[j];
double Gp = G+1;
double Gn = G-1;
double violation = 0;
if(w[j] == 0)
{
if(Gp < 0)
violation = -Gp;
else if(Gn > 0)
violation = Gn;
else if(Gp>Gmax_old/l && Gn<-Gmax_old/l)
{
active_size--;
swap(index[s], index[active_size]);
s--;
continue;
}
}
else if(w[j] > 0)
violation = fabs(Gp);
else
violation = fabs(Gn);
Gmax_new = max(Gmax_new, violation);
// obtain Newton direction d
if(Gp <= H*w[j])
d = -Gp/H;
else if(Gn >= H*w[j])
d = -Gn/H;
else
d = -w[j];
if(fabs(d) < 1.0e-12)
continue;
d = min(max(d,-10.0),10.0);
double delta = fabs(w[j]+d)-fabs(w[j]) + G*d;
int num_linesearch;
for(num_linesearch=0; num_linesearch < max_num_linesearch; num_linesearch++)
{
cond = fabs(w[j]+d)-fabs(w[j]) - sigma*delta;
if(x_min >= 0)
{
double tmp = exp(d*xj_max[j]);
appxcond1 = log(1+sum1*(tmp-1)/xj_max[j]/C_sum[j])*C_sum[j] + cond - d*xjpos_sum[j];
appxcond2 = log(1+sum2*(1/tmp-1)/xj_max[j]/C_sum[j])*C_sum[j] + cond + d*xjneg_sum[j];
if(min(appxcond1,appxcond2) <= 0)
{
x = prob_col->x[j];
while(x->index != -1)
{
exp_wTx[x->index-1] *= exp(d*x->value);
x++;
}
break;
}
}
cond += d*xjneg_sum[j];
int i = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
double exp_dx = exp(d*x->value);
exp_wTx_new[i] = exp_wTx[ind]*exp_dx;
cond += C[GETI(ind)]*log((1+exp_wTx_new[i])/(exp_dx+exp_wTx_new[i]));
x++; i++;
}
if(cond <= 0)
{
int i = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
exp_wTx[ind] = exp_wTx_new[i];
x++; i++;
}
break;
}
else
{
d *= 0.5;
delta *= 0.5;
}
}
w[j] += d;
// recompute exp_wTx[] if line search takes too many steps
if(num_linesearch >= max_num_linesearch)
{
info("#");
for(int i=0; i<l; i++)
exp_wTx[i] = 0;
for(int i=0; i<w_size; i++)
{
if(w[i]==0) continue;
x = prob_col->x[i];
while(x->index != -1)
{
exp_wTx[x->index-1] += w[i]*x->value;
x++;
}
}
for(int i=0; i<l; i++)
exp_wTx[i] = exp(exp_wTx[i]);
}
}
if(iter == 0)
Gmax_init = Gmax_new;
iter++;
if(iter % 10 == 0)
info(".");
if(Gmax_new <= eps*Gmax_init)
{
if(active_size == w_size)
break;
else
{
active_size = w_size;
info("*");
Gmax_old = INF;
continue;
}
}
Gmax_old = Gmax_new;
}
info("\noptimization finished, #iter = %d\n", iter);
if(iter >= max_iter)
info("\nWARNING: reaching max number of iterations\n");
// calculate objective value
double v = 0;
int nnz = 0;
for(j=0; j<w_size; j++)
if(w[j] != 0)
{
v += fabs(w[j]);
nnz++;
}
for(j=0; j<l; j++)
if(y[j] == 1)
v += C[GETI(j)]*log(1+1/exp_wTx[j]);
else
v += C[GETI(j)]*log(1+exp_wTx[j]);
info("Objective value = %lf\n", v);
info("#nonzeros/#features = %d/%d\n", nnz, w_size);
delete [] index;
delete [] y;
delete [] exp_wTx;
delete [] exp_wTx_new;
delete [] xj_max;
delete [] C_sum;
delete [] xjneg_sum;
delete [] xjpos_sum;
}
static void solve_l1r_l2_svc(
problem *prob_col, double *w, double eps,
double Cp, double Cn)
{
int l = prob_col->l;
int w_size = prob_col->n;
int j, s, iter = 0;
int max_iter = 1000;
int active_size = w_size;
int max_num_linesearch = 20;
double sigma = 0.01;
double d, G_loss, G, H;
double Gmax_old = INF;
double Gmax_new;
double Gmax_init;
double d_old, d_diff;
double loss_old, loss_new;
double appxcond, cond;
int *index = new int[w_size];
schar *y = new schar[l];
double *b = new double[l]; // b = 1-ywTx
double *xj_sq = new double[w_size];
feature_node *x;
double C[3] = {Cn,0,Cp};
for(j=0; j<l; j++)
{
b[j] = 1;
if(prob_col->y[j] > 0)
y[j] = 1;
else
y[j] = -1;
}
for(j=0; j<w_size; j++)
{
w[j] = 0;
index[j] = j;
xj_sq[j] = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
double val = x->value;
x->value *= y[ind]; // x->value stores yi*xij
xj_sq[j] += C[GETI(ind)]*val*val;
x++;
}
}
while(iter < max_iter)
{
Gmax_new = 0;
for(j=0; j<active_size; j++)
{
int i = j+rand()%(active_size-j);
swap(index[i], index[j]);
}
for(s=0; s<active_size; s++)
{
j = index[s];
G_loss = 0;
H = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
if(b[ind] > 0)
{
double val = x->value;
double tmp = C[GETI(ind)]*val;
G_loss -= tmp*b[ind];
H += tmp*val;
}
x++;
}
G_loss *= 2;
G = G_loss;
H *= 2;
H = max(H, 1e-12);
double Gp = G+1;
double Gn = G-1;
double violation = 0;
if(w[j] == 0)
{
if(Gp < 0)
violation = -Gp;
else if(Gn > 0)
violation = Gn;
else if(Gp>Gmax_old/l && Gn<-Gmax_old/l)
{
active_size--;
swap(index[s], index[active_size]);
s--;
continue;
}
}
else if(w[j] > 0)
violation = fabs(Gp);
else
violation = fabs(Gn);
Gmax_new = max(Gmax_new, violation);
// obtain Newton direction d
if(Gp <= H*w[j])
d = -Gp/H;
else if(Gn >= H*w[j])
d = -Gn/H;
else
d = -w[j];
if(fabs(d) < 1.0e-12)
continue;
double delta = fabs(w[j]+d)-fabs(w[j]) + G*d;
d_old = 0;
int num_linesearch;
for(num_linesearch=0; num_linesearch < max_num_linesearch; num_linesearch++)
{
d_diff = d_old - d;
cond = fabs(w[j]+d)-fabs(w[j]) - sigma*delta;
appxcond = xj_sq[j]*d*d + G_loss*d + cond;
if(appxcond <= 0)
{
x = prob_col->x[j];
while(x->index != -1)
{
b[x->index-1] += d_diff*x->value;
x++;
}
break;
}
if(num_linesearch == 0)
{
loss_old = 0;
loss_new = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
if(b[ind] > 0)
loss_old += C[GETI(ind)]*b[ind]*b[ind];
double b_new = b[ind] + d_diff*x->value;
b[ind] = b_new;
if(b_new > 0)
loss_new += C[GETI(ind)]*b_new*b_new;
x++;
}
}
else
{
loss_new = 0;
x = prob_col->x[j];
while(x->index != -1)
{
int ind = x->index-1;
double b_new = b[ind] + d_diff*x->value;
b[ind] = b_new;
if(b_new > 0)
loss_new += C[GETI(ind)]*b_new*b_new;
x++;
}
}
cond = cond + loss_new - loss_old;
if(cond <= 0)
break;
else
{
d_old = d;
d *= 0.5;
delta *= 0.5;
}
}
w[j] += d;
// recompute b[] if line search takes too many steps
if(num_linesearch >= max_num_linesearch)
{
info("#");
for(int i=0; i<l; i++)
b[i] = 1;
for(int i=0; i<w_size; i++)
{
if(w[i]==0) continue;
x = prob_col->x[i];
while(x->index != -1)
{
b[x->index-1] -= w[i]*x->value;
x++;
}
}
}
}
if(iter == 0)
Gmax_init = Gmax_new;
iter++;
if(iter % 10 == 0)
info(".");
if(Gmax_new <= eps*Gmax_init)
{
if(active_size == w_size)
break;
else
{
active_size = w_size;
info("*");
Gmax_old = INF;
continue;
}
}
Gmax_old = Gmax_new;
}
info("\noptimization finished, #iter = %d\n", iter);
if(iter >= max_iter)
info("\nWARNING: reaching max number of iterations\n");
// calculate objective value
double v = 0;
int nnz = 0;
for(j=0; j<w_size; j++)
{
x = prob_col->x[j];
while(x->index != -1)
{
x->value *= prob_col->y[x->index-1]; // restore x->value
x++;
}
if(w[j] != 0)
{
v += fabs(w[j]);
nnz++;
}
}
for(j=0; j<l; j++)
if(b[j] > 0)
v += C[GETI(j)]*b[j]*b[j];
info("Objective value = %lf\n", v);
info("#nonzeros/#features = %d/%d\n", nnz, w_size);
delete [] index;
delete [] y;
delete [] b;
delete [] xj_sq;
}
static void ConvertRuneAnimations(UMeshAnimation &Anim, const TArray<RJoint> &Bones,
const TArray<FRSkelAnimSeq> &Seqs)
{
guard(ConvertRuneAnimations);
int i, j;
int numBones = Bones.Num();
// create RefBones
Anim.RefBones.Empty(Bones.Num());
for (i = 0; i < Bones.Num(); i++)
{
const RJoint &SB = Bones[i];
FNamedBone *B = new(Anim.RefBones) FNamedBone;
B->Name = SB.name;
B->Flags = 0;
B->ParentIndex = SB.parent;
}
// create AnimSeqs
Anim.AnimSeqs.Empty(Seqs.Num());
Anim.Moves.Empty(Seqs.Num());
for (i = 0; i < Seqs.Num(); i++)
{
// create FMeshAnimSeq
const FRSkelAnimSeq &SS = Seqs[i];
FMeshAnimSeq *S = new(Anim.AnimSeqs) FMeshAnimSeq;
S->Name = SS.Name;
CopyArray(S->Groups, SS.Groups);
S->StartFrame = 0;
S->NumFrames = SS.NumFrames;
S->Rate = SS.Rate;
//?? S->Notifys
// create MotionChunk
MotionChunk *M = new(Anim.Moves) MotionChunk;
M->TrackTime = SS.NumFrames;
// dummy bone remap
M->AnimTracks.Empty(numBones);
// convert animation data
const byte *data = &SS.animdata[0];
for (j = 0; j < numBones; j++)
{
// prepare AnalogTrack
AnalogTrack *A = new(M->AnimTracks) AnalogTrack;
A->KeyQuat.Empty(SS.NumFrames);
A->KeyPos.Empty(SS.NumFrames);
A->KeyTime.Empty(SS.NumFrames);
}
for (int frame = 0; frame < SS.NumFrames; frame++)
{
for (int joint = 0; joint < numBones; joint++)
{
AnalogTrack &A = M->AnimTracks[joint];
FVector pos, scale;
pos.Set(0, 0, 0);
scale.Set(1, 1, 1);
FRotator rot;
rot.Set(0, 0, 0);
byte f = *data++;
int16 d;
#define GET d = data[0] + (data[1] << 8); data += 2;
#define GETF(v) { GET; v = (float)d / 256.0f; }
#define GETI(v) { GET; v = d; }
// decode position
if (f & 1) GETF(pos.X);
if (f & 2) GETF(pos.Y);
if (f & 4) GETF(pos.Z);
// decode scale
if (f & 8) { GETF(scale.X); GETF(scale.Z); }
if (f & 0x10) GETF(scale.Y);
// decode rotation
if (f & 0x20) GETI(rot.Pitch);
if (f & 0x40) GETI(rot.Yaw);
if (f & 0x80) GETI(rot.Roll);
#undef GET
#undef GETF
#undef GETI
A.KeyQuat.Add(EulerToQuat(rot));
A.KeyPos.Add(pos);
//?? notify about scale!=(1,1,1)
}
}
assert(data == &SS.animdata[0] + SS.animdata.Num());
}
unguard;
}
