lcb_luv_socket_t lcb_luv_socket_new(struct lcb_io_opt_st *iops)
{
/* Find the next 'file descriptor' */
lcb_socket_t idx;
lcb_luv_socket_t newsock;
idx = find_free_idx(IOPS_COOKIE(iops));
if (idx == -1) {
iops->v.v0.error = ENFILE;
return NULL;
}
newsock = calloc(1, sizeof(struct lcb_luv_socket_st));
newsock->idx = idx;
newsock->parent = IOPS_COOKIE(iops);
uv_async_init(newsock->parent->loop, &newsock->async, async_cb);
newsock->async_state = 0;
newsock->async.data = newsock;
newsock->u_req.req.data = newsock;
newsock->refcount = 1;
uv_tcp_init(IOPS_COOKIE(iops)->loop, &newsock->tcp);
IOPS_COOKIE(iops)->socktable[idx] = newsock;
iops->v.v0.error = 0;
log_socket_debug("%p: Created new socket %p(%d)", iops, newsock, idx);
return newsock;
}
bmrm_return_value_T svm_bmrm_solver(
CStructuredModel* model,
float64_t* W,
float64_t TolRel,
float64_t TolAbs,
float64_t _lambda,
uint32_t _BufSize,
bool cleanICP,
uint32_t cleanAfter,
float64_t K,
uint32_t Tmax,
bool verbose)
{
bmrm_return_value_T bmrm;
libqp_state_T qp_exitflag={0, 0, 0, 0};
float64_t *b, *beta, *diag_H, *prevW;
float64_t R, *subgrad, *A, QPSolverTolRel, C=1.0, wdist=0.0;
floatmax_t rsum, sq_norm_W, sq_norm_Wdiff=0.0;
uint32_t *I;
uint8_t S=1;
uint32_t nDim=model->get_dim();
CTime ttime;
float64_t tstart, tstop;
bmrm_ll *CPList_head, *CPList_tail, *cp_ptr, *cp_ptr2, *cp_list=NULL;
float64_t *A_1=NULL, *A_2=NULL;
bool *map=NULL;
tstart=ttime.cur_time_diff(false);
BufSize=_BufSize;
QPSolverTolRel=1e-9;
H=NULL;
b=NULL;
beta=NULL;
A=NULL;
subgrad=NULL;
diag_H=NULL;
I=NULL;
prevW=NULL;
H= (float64_t*) LIBBMRM_CALLOC(BufSize*BufSize, sizeof(float64_t));
if (H==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
A= (float64_t*) LIBBMRM_CALLOC(nDim*BufSize, sizeof(float64_t));
if (A==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
b= (float64_t*) LIBBMRM_CALLOC(BufSize, sizeof(float64_t));
if (b==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
beta= (float64_t*) LIBBMRM_CALLOC(BufSize, sizeof(float64_t));
if (beta==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
subgrad= (float64_t*) LIBBMRM_CALLOC(nDim, sizeof(float64_t));
if (subgrad==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
diag_H= (float64_t*) LIBBMRM_CALLOC(BufSize, sizeof(float64_t));
if (diag_H==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
I= (uint32_t*) LIBBMRM_CALLOC(BufSize, sizeof(uint32_t));
if (I==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
ICP_stats icp_stats;
icp_stats.maxCPs = BufSize;
icp_stats.ICPcounter= (uint32_t*) LIBBMRM_CALLOC(BufSize, sizeof(uint32_t));
if (icp_stats.ICPcounter==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
icp_stats.ICPs= (float64_t**) LIBBMRM_CALLOC(BufSize, sizeof(float64_t*));
if (icp_stats.ICPs==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
icp_stats.ACPs= (uint32_t*) LIBBMRM_CALLOC(BufSize, sizeof(uint32_t));
if (icp_stats.ACPs==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
/* Temporary buffers for ICP removal */
icp_stats.H_buff= (float64_t*) LIBBMRM_CALLOC(BufSize*BufSize, sizeof(float64_t));
if (icp_stats.H_buff==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
map= (bool*) LIBBMRM_CALLOC(BufSize, sizeof(bool));
if (map==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
memset( (bool*) map, true, BufSize);
cp_list= (bmrm_ll*) LIBBMRM_CALLOC(1, sizeof(bmrm_ll));
if (cp_list==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
prevW= (float64_t*) LIBBMRM_CALLOC(nDim, sizeof(float64_t));
if (prevW==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
bmrm.hist_Fp = SGVector< float64_t >(BufSize);
bmrm.hist_Fd = SGVector< float64_t >(BufSize);
bmrm.hist_wdist = SGVector< float64_t >(BufSize);
/* Iinitial solution */
R=model->risk(subgrad, W);
bmrm.nCP=0;
bmrm.nIter=0;
bmrm.exitflag=0;
b[0]=-R;
/* Cutting plane auxiliary double linked list */
LIBBMRM_MEMCPY(A, subgrad, nDim*sizeof(float64_t));
map[0]=false;
cp_list->address=&A[0];
cp_list->idx=0;
cp_list->prev=NULL;
cp_list->next=NULL;
CPList_head=cp_list;
CPList_tail=cp_list;
/* Compute initial value of Fp, Fd, assuming that W is zero vector */
sq_norm_W=0;
bmrm.Fp=R+0.5*_lambda*sq_norm_W;
bmrm.Fd=-LIBBMRM_PLUS_INF;
tstop=ttime.cur_time_diff(false);
/* Verbose output */
if (verbose)
SG_SPRINT("%4d: tim=%.3lf, Fp=%lf, Fd=%lf, R=%lf\n",
bmrm.nIter, tstop-tstart, bmrm.Fp, bmrm.Fd, R);
/* store Fp, Fd and wdist history */
bmrm.hist_Fp[0]=bmrm.Fp;
bmrm.hist_Fd[0]=bmrm.Fd;
bmrm.hist_wdist[0]=0.0;
/* main loop */
while (bmrm.exitflag==0)
{
tstart=ttime.cur_time_diff(false);
bmrm.nIter++;
/* Update H */
if (bmrm.nCP>0)
{
A_2=get_cutting_plane(CPList_tail);
cp_ptr=CPList_head;
for (uint32_t i=0; i<bmrm.nCP; ++i)
{
A_1=get_cutting_plane(cp_ptr);
cp_ptr=cp_ptr->next;
rsum= SGVector<float64_t>::dot(A_1, A_2, nDim);
H[LIBBMRM_INDEX(bmrm.nCP, i, BufSize)]
= H[LIBBMRM_INDEX(i, bmrm.nCP, BufSize)]
= rsum/_lambda;
}
}
A_2=get_cutting_plane(CPList_tail);
rsum = SGVector<float64_t>::dot(A_2, A_2, nDim);
H[LIBBMRM_INDEX(bmrm.nCP, bmrm.nCP, BufSize)]=rsum/_lambda;
diag_H[bmrm.nCP]=H[LIBBMRM_INDEX(bmrm.nCP, bmrm.nCP, BufSize)];
I[bmrm.nCP]=1;
bmrm.nCP++;
beta[bmrm.nCP]=0.0; // [beta; 0]
#if 0
/* TODO: scaling...*/
float64_t scale = SGVector<float64_t>::max(diag_H, BufSize)/(1000.0*_lambda);
SGVector<float64_t> sb(bmrm.nCP);
sb.zero();
sb.vec1_plus_scalar_times_vec2(sb.vector, 1/scale, b, bmrm.nCP);
SGVector<float64_t> sh(bmrm.nCP);
sh.zero();
sb.vec1_plus_scalar_times_vec2(sh.vector, 1/scale, diag_H, bmrm.nCP);
qp_exitflag =
libqp_splx_solver(&get_col, sh.vector, sb.vector, &C, I, &S, beta,
bmrm.nCP, QPSolverMaxIter, 0.0, QPSolverTolRel, -LIBBMRM_PLUS_INF, 0);
#else
/* call QP solver */
qp_exitflag=libqp_splx_solver(&get_col, diag_H, b, &C, I, &S, beta,
bmrm.nCP, QPSolverMaxIter, 0.0, QPSolverTolRel, -LIBBMRM_PLUS_INF, 0);
#endif
bmrm.qp_exitflag=qp_exitflag.exitflag;
/* Update ICPcounter (add one to unused and reset used)
* + compute number of active CPs */
bmrm.nzA=0;
for (uint32_t aaa=0; aaa<bmrm.nCP; ++aaa)
{
if (beta[aaa]>epsilon)
{
++bmrm.nzA;
icp_stats.ICPcounter[aaa]=0;
}
else
{
icp_stats.ICPcounter[aaa]+=1;
}
}
/* W update */
memset(W, 0, sizeof(float64_t)*nDim);
cp_ptr=CPList_head;
for (uint32_t j=0; j<bmrm.nCP; ++j)
{
A_1=get_cutting_plane(cp_ptr);
cp_ptr=cp_ptr->next;
SGVector<float64_t>::vec1_plus_scalar_times_vec2(W, -beta[j]/_lambda, A_1, nDim);
}
/* risk and subgradient computation */
R = model->risk(subgrad, W);
add_cutting_plane(&CPList_tail, map, A,
find_free_idx(map, BufSize), subgrad, nDim);
sq_norm_W=SGVector<float64_t>::dot(W, W, nDim);
b[bmrm.nCP]=SGVector<float64_t>::dot(subgrad, W, nDim) - R;
sq_norm_Wdiff=0.0;
for (uint32_t j=0; j<nDim; ++j)
{
sq_norm_Wdiff+=(W[j]-prevW[j])*(W[j]-prevW[j]);
}
bmrm.Fp=R+0.5*_lambda*sq_norm_W;
bmrm.Fd=-qp_exitflag.QP;
wdist=CMath::sqrt(sq_norm_Wdiff);
/* Stopping conditions */
if (bmrm.Fp - bmrm.Fd <= TolRel*LIBBMRM_ABS(bmrm.Fp))
bmrm.exitflag=1;
if (bmrm.Fp - bmrm.Fd <= TolAbs)
bmrm.exitflag=2;
if (bmrm.nCP >= BufSize)
bmrm.exitflag=-1;
tstop=ttime.cur_time_diff(false);
/* Verbose output */
if (verbose)
SG_SPRINT("%4d: tim=%.3lf, Fp=%lf, Fd=%lf, (Fp-Fd)=%lf, (Fp-Fd)/Fp=%lf, R=%lf, nCP=%d, nzA=%d, QPexitflag=%d\n",
bmrm.nIter, tstop-tstart, bmrm.Fp, bmrm.Fd, bmrm.Fp-bmrm.Fd,
(bmrm.Fp-bmrm.Fd)/bmrm.Fp, R, bmrm.nCP, bmrm.nzA, qp_exitflag.exitflag);
/* Keep Fp, Fd and w_dist history */
bmrm.hist_Fp[bmrm.nIter]=bmrm.Fp;
bmrm.hist_Fd[bmrm.nIter]=bmrm.Fd;
bmrm.hist_wdist[bmrm.nIter]=wdist;
/* Check size of Buffer */
if (bmrm.nCP>=BufSize)
{
bmrm.exitflag=-2;
SG_SERROR("Buffer exceeded.\n");
}
/* keep W (for wdist history track) */
LIBBMRM_MEMCPY(prevW, W, nDim*sizeof(float64_t));
/* Inactive Cutting Planes (ICP) removal */
if (cleanICP)
{
clean_icp(&icp_stats, bmrm, &CPList_head, &CPList_tail, H, diag_H, beta, map, cleanAfter, b, I);
}
} /* end of main loop */
bmrm.hist_Fp.resize_vector(bmrm.nIter);
bmrm.hist_Fd.resize_vector(bmrm.nIter);
bmrm.hist_wdist.resize_vector(bmrm.nIter);
cp_ptr=CPList_head;
while(cp_ptr!=NULL)
{
cp_ptr2=cp_ptr;
cp_ptr=cp_ptr->next;
LIBBMRM_FREE(cp_ptr2);
cp_ptr2=NULL;
}
cp_list=NULL;
cleanup:
LIBBMRM_FREE(H);
LIBBMRM_FREE(b);
LIBBMRM_FREE(beta);
LIBBMRM_FREE(A);
LIBBMRM_FREE(subgrad);
LIBBMRM_FREE(diag_H);
LIBBMRM_FREE(I);
LIBBMRM_FREE(icp_stats.ICPcounter);
LIBBMRM_FREE(icp_stats.ICPs);
LIBBMRM_FREE(icp_stats.ACPs);
LIBBMRM_FREE(icp_stats.H_buff);
LIBBMRM_FREE(map);
LIBBMRM_FREE(prevW);
if (cp_list)
LIBBMRM_FREE(cp_list);
return(bmrm);
}
