void CMath::display_vector(const float32_t* vector, int32_t n, const char* name,
const char* prefix)
{
ASSERT(n>=0);
SG_SPRINT("%s%s=[", prefix, name);
for (int32_t i=0; i<n; i++)
SG_SPRINT("%s%g%s", prefix, vector[i], i==n-1? "" : ",");
SG_SPRINT("%s]\n", prefix);
}
void CMath::display_matrix(
const float64_t* matrix, int32_t rows, int32_t cols, const char* name)
{
ASSERT(rows>=0 && cols>=0);
SG_SPRINT("%s=[\n", name);
for (int32_t i=0; i<rows; i++)
{
SG_SPRINT("[");
for (int32_t j=0; j<cols; j++)
SG_SPRINT("\t%lf%s", (double) matrix[j*rows+i],
j==cols-1? "" : ",");
SG_SPRINT("]%s\n", i==rows-1? "" : ",");
}
SG_SPRINT("]\n");
}
void SGMatrix<bool>::display_matrix(
const bool* matrix, int32_t rows, int32_t cols, const char* name,
const char* prefix)
{
ASSERT(rows>=0 && cols>=0);
SG_SPRINT("%s%s=[\n", prefix, name);
for (int32_t i=0; i<rows; i++)
{
SG_SPRINT("%s[", prefix);
for (int32_t j=0; j<cols; j++)
SG_SPRINT("%s\t%d%s", prefix, matrix[j*rows+i] ? 1 : 0,
j==cols-1? "" : ",");
SG_SPRINT("%s]%s\n", prefix, i==rows-1? "" : ",");
}
SG_SPRINT("%s]\n", prefix);
}
void SGMatrix<floatmax_t>::display_matrix(
const floatmax_t* matrix, int32_t rows, int32_t cols, const char* name,
const char* prefix)
{
ASSERT(rows>=0 && cols>=0);
SG_SPRINT("%s%s=[\n", prefix, name);
for (int32_t i=0; i<rows; i++)
{
SG_SPRINT("%s[", prefix);
for (int32_t j=0; j<cols; j++)
SG_SPRINT("%s\t%.18g%s", prefix, (double) matrix[j*rows+i],
j==cols-1? "" : ",");
SG_SPRINT("%s]%s\n", prefix, i==rows-1? "" : ",");
}
SG_SPRINT("%s]\n", prefix);
}
void fImgSvm::test_libsvm()
{
init_shogun(&print_message);
index_t num_vec=imgvec.size();
index_t num_feat=SIFTN;
index_t num_class=2;
// create some data
SGMatrix<float64_t> matrix(num_feat, num_vec);
for(int i = 0 ; i < num_vec ; i ++ ) {
for(int j = 0 ; j < num_feat ; j ++ ) {
matrix(j,i) = imgvec[i][j];
}
}
//SGVector<float64_t>::range_fill_vector(matrix.matrix, num_feat*num_vec);
// create vectors
// shogun will now own the matrix created
CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(matrix);
// create three labels
CMulticlassLabels* labels=new CMulticlassLabels(num_vec);
for (index_t i=0; i<num_vec; ++i)
labels->set_label(i,imgtrainlabelvec[i]);
// create gaussian kernel with cache 10MB, width 0.5
CGaussianKernel* kernel = new CGaussianKernel(10, 0.5);
kernel->init(features, features);
// create libsvm with C=10 and train
CMulticlassLibSVM* svm = new CMulticlassLibSVM(10, kernel, labels);
svm->train();
// classify on training examples
CMulticlassLabels* output=CMulticlassLabels::obtain_from_generic(svm->apply());
SGVector<float64_t>::display_vector(output->get_labels().vector, output->get_num_labels(),
"初始的 output");
/* assert that batch apply and apply(index_t) give same result */
for (index_t i=0; i<output->get_num_labels(); ++i) {
float64_t label=svm->apply_one(i);
SG_SPRINT("result output[%d]=%f\n", i, label);
ASSERT(output->get_label(i)==label);
}
SG_UNREF(output);
// free up memory
SG_UNREF(svm);
exit_shogun();
}
bmrm_return_value_T svm_bmrm_solver(
bmrm_data_T* data,
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,
CRiskFunction* risk_function)
{
bmrm_return_value_T bmrm = {0, 0, 0, 0, 0, 0, 0};
libqp_state_T qp_exitflag;
float64_t *b, *beta, *diag_H, sq_norm_W;
float64_t R, *subgrad, *A, QPSolverTolRel, rsum, C=1.0;
uint32_t *I, *ICPcounter, *ICPs, cntICP=0;
uint8_t S = 1;
uint32_t nDim=data->w_dim;
CTime ttime;
float64_t tstart, tstop;
float64_t *b2, *beta2, *diag_H2, *A2, *H2;
uint32_t *I2, *ICPcounter2, nCP_new=0, idx=0, idx2=0, icp_iter=0, icp_iter2=0;
int32_t idx_icp=0, idx_icp2=0;
bool flag1=true, flag2=true;
tstart=ttime.cur_time_diff(false);
BufSize=_BufSize;
QPSolverTolRel=TolRel*0.5;
H=NULL;
b=NULL;
beta=NULL;
A=NULL;
subgrad=NULL;
diag_H=NULL;
I=NULL;
ICPcounter=NULL;
ICPs=NULL;
b2=NULL;
beta2=NULL;
H2=NULL;
I2=NULL;
ICPcounter2=NULL;
A2=NULL;
diag_H2=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;
}
ICPcounter=(uint32_t*)LIBBMRM_CALLOC(BufSize, sizeof(uint32_t));
if (ICPcounter==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
ICPs=(uint32_t*)LIBBMRM_CALLOC(BufSize, sizeof(uint32_t));
if (ICPs==NULL)
{
bmrm.exitflag=-2;
goto cleanup;
}
/* Temporary buffers for ICP removal */
b2=(float64_t*)LIBBMRM_CALLOC(BufSize, sizeof(float64_t));
beta2=(float64_t*)LIBBMRM_CALLOC(BufSize, sizeof(float64_t));
ICPcounter2=(uint32_t*)LIBBMRM_CALLOC(BufSize, sizeof(uint32_t));
I2=(uint32_t*)LIBBMRM_CALLOC(BufSize, sizeof(uint32_t));
diag_H2=(float64_t*)LIBBMRM_CALLOC(BufSize, sizeof(float64_t));
A2=(float64_t*)LIBBMRM_CALLOC(nDim*BufSize, sizeof(float64_t));
H2=(float64_t*)LIBBMRM_CALLOC(BufSize*BufSize, sizeof(float64_t));
if (b2==NULL || beta2==NULL || ICPcounter2==NULL || I2==NULL || diag_H2==NULL || A2==NULL || H2==NULL)
{
bmrm.exitflag=-2;
}
/* Iinitial solution */
risk_function->risk(data, &R, subgrad, W);
bmrm.nCP=0;
bmrm.nIter=0;
bmrm.exitflag=0;
b[0]=-R;
LIBBMRM_MEMCPY(A, subgrad, nDim*sizeof(float64_t));
/* 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 */
SG_SPRINT("%4d: tim=%.3lf, Fp=%lf, Fd=%lf, R=%lf\n",
bmrm.nIter, tstop-tstart, bmrm.Fp, bmrm.Fd, R);
/* main loop */
while (bmrm.exitflag==0)
{
tstart=ttime.cur_time_diff(false);
bmrm.nIter++;
/* Update H */
if (bmrm.nCP>0)
{
for (uint32_t i=0; i<bmrm.nCP; ++i)
{
rsum=0.0;
for (uint32_t j=0; j<nDim; ++j)
{
rsum+=A[LIBBMRM_INDEX(j, i, nDim)]*A[LIBBMRM_INDEX(j, bmrm.nCP, nDim)];
}
H[LIBBMRM_INDEX(i, bmrm.nCP, BufSize)]=rsum/lambda;
}
for (uint32_t i=0; i<bmrm.nCP; ++i)
{
H[LIBBMRM_INDEX(bmrm.nCP, i, BufSize)]=H[LIBBMRM_INDEX(i, bmrm.nCP, BufSize)];
}
}
H[LIBBMRM_INDEX(bmrm.nCP, bmrm.nCP, BufSize)]=0.0;
for (uint32_t i=0; i<nDim; ++i)
H[LIBBMRM_INDEX(bmrm.nCP, bmrm.nCP, BufSize)]+=A[LIBBMRM_INDEX(i, bmrm.nCP, nDim)]*A[LIBBMRM_INDEX(i, bmrm.nCP, nDim)]/lambda;
diag_H[bmrm.nCP]=H[LIBBMRM_INDEX(bmrm.nCP, bmrm.nCP, BufSize)];
I[bmrm.nCP]=1;
bmrm.nCP++;
/* 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);
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+=1;
ICPcounter[aaa]=0;
} else {
ICPcounter[aaa]+=1;
}
}
/* W update */
for (uint32_t i=0; i<nDim; ++i)
{
rsum = 0.0;
for (uint32_t j=0; j<bmrm.nCP; ++j)
{
rsum += A[LIBBMRM_INDEX(i, j, nDim)]*beta[j];
}
W[i] = -rsum/lambda;
}
/* risk and subgradient computation */
risk_function->risk(data, &R, subgrad, W);
LIBBMRM_MEMCPY(A+bmrm.nCP*nDim, subgrad, nDim*sizeof(float64_t));
b[bmrm.nCP]=-R;
for (uint32_t j=0; j<nDim; ++j)
b[bmrm.nCP]+=subgrad[j]*W[j];
sq_norm_W = 0;
for (uint32_t j=0; j<nDim; ++j)
sq_norm_W+=W[j]*W[j];
bmrm.Fp=R+0.5*lambda*sq_norm_W;
bmrm.Fd=-qp_exitflag.QP;
/* 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 */
SG_SPRINT("%4d: tim=%.3lf, Fp=%lf, Fd=%lf, (Fp-Fd)=%lf, (Fp-Fd)/Fp=%lf, R=%lf, nCP=%d, nzA=%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);
/* Check size of Buffer */
if (bmrm.nCP>=BufSize)
{
bmrm.exitflag=-2;
SG_SERROR("Buffer exceeded.\n");
}
/* Inactive Cutting Planes (ICP) removal */
if (cleanICP)
{
/* find ICP */
cntICP = 0;
for (uint32_t aaa=0; aaa<bmrm.nCP; ++aaa)
if (ICPcounter[aaa]>=cleanAfter)
{
ICPs[cntICP++]=aaa;
}
/* do ICP */
if (cntICP > 0)
{
nCP_new=bmrm.nCP-cntICP;
idx=0;
idx2=0;
icp_iter=0;
icp_iter2=0;
idx_icp=ICPs[icp_iter];
idx_icp2=ICPs[icp_iter2];
flag1=true; flag2=true;
for (uint32_t i=0; i<bmrm.nCP; ++i)
{
if ((int32_t)i != idx_icp)
{
b2[idx]=b[i];
beta2[idx]=beta[i];
ICPcounter2[idx]=ICPcounter[i];
I2[idx]=I[i];
diag_H2[idx]=diag_H[i];
LIBBMRM_MEMCPY(A2+idx*nDim, A+i*nDim, nDim*sizeof(float64_t));
idx2=0;
icp_iter2=0;
idx_icp2=ICPs[icp_iter2];
flag2=true;
for (uint32_t j=0; j<bmrm.nCP; ++j)
{
if ((int32_t)j != idx_icp2)
{
H2[LIBBMRM_INDEX(idx, idx2, BufSize)]=H[LIBBMRM_INDEX(i, j, BufSize)];
idx2++;
} else {
if (flag2 && icp_iter2+1 < cntICP)
{
idx_icp2=ICPs[++icp_iter2];
} else {
flag2=false;
idx_icp2=-1;
}
}
}
idx++;
} else {
if (flag1 && icp_iter+1 < cntICP)
{
idx_icp=ICPs[++icp_iter];
} else {
flag1=false;
idx_icp=-1;
}
}
}
/* copy data from tmps back to original */
LIBBMRM_MEMCPY(b, b2, nCP_new*sizeof(float64_t));
LIBBMRM_MEMCPY(beta, beta2, nCP_new*sizeof(float64_t));
LIBBMRM_MEMCPY(ICPcounter, ICPcounter2, nCP_new*sizeof(uint32_t));
LIBBMRM_MEMCPY(I, I2, nCP_new*sizeof(uint32_t));
LIBBMRM_MEMCPY(diag_H, diag_H2, nCP_new*sizeof(float64_t));
LIBBMRM_MEMCPY(A, A2, nDim*nCP_new*sizeof(float64_t));
for (uint32_t i=0; i<nCP_new; ++i)
for (uint32_t j=0; j<nCP_new; ++j)
H[LIBBMRM_INDEX(i, j, BufSize)]=H2[LIBBMRM_INDEX(i, j, BufSize)];
bmrm.nCP=nCP_new;
}
}
} /* end of main loop */
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(ICPcounter);
LIBBMRM_FREE(ICPs);
LIBBMRM_FREE(H2);
LIBBMRM_FREE(b2);
LIBBMRM_FREE(beta2);
LIBBMRM_FREE(A2);
LIBBMRM_FREE(diag_H2);
LIBBMRM_FREE(I2);
LIBBMRM_FREE(ICPcounter2);
return(bmrm);
}
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);
}
void fImgSvm::test_libsvm2()
{
init_shogun(&print_message);
const int32_t feature_cache=0;
const int32_t kernel_cache=0;
const float64_t rbf_width=10;
const float64_t svm_C=10;
const float64_t svm_eps=0.001;
int32_t num=mtrainimgsum;
int32_t dims=SIFTN;
float64_t dist=0.5;
SGVector<float64_t> lab(num); //标签
SGMatrix<float64_t> feat(dims, num);
//gen_rand_data(lab, feat, dist);
for(int i = 0 ; i < num ; i ++ ) {
for(int j = 0 ; j < dims ; j ++ ) {
feat(j,i) = imgvec[i][j];
}
}
for(int i = 0 ; i < num ; i ++ ) {
//lab[i] = imglabelvec[i]*1.0;
if(imgtrainlabelvec[i] == 1)
lab[i] = -1.0;
else
lab[i] = 1.0;
}
// create train labels
CLabels* labels=new CBinaryLabels(lab);
// create train features
CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(feature_cache);
SG_REF(features);
features->set_feature_matrix(feat);
// create gaussian kernel
CGaussianKernel* kernel=new CGaussianKernel(kernel_cache, rbf_width);
SG_REF(kernel);
kernel->init(features, features);
// create svm via libsvm and train
CLibSVM* svm=new CLibSVM(svm_C, kernel, labels);
SG_REF(svm);
svm->set_epsilon(svm_eps);
svm->train();
SG_SPRINT("num_sv:%d b:%f\n", svm->get_num_support_vectors(),
svm->get_bias());
// classify + display output
CBinaryLabels* out_labels=CBinaryLabels::obtain_from_generic(svm->apply());
for (int32_t i=0; i<num; i++) {
SG_SPRINT("out[%d]=%f (%f)\n", i, out_labels->get_label(i),
out_labels->get_confidence(i));
}
CBinaryLabels* result = CBinaryLabels::obtain_from_generic (svm->apply(features) );
for (int32_t i=0; i<3; i++)
SG_SPRINT("output[%d]=%f\n", i, result->get_label(i));
// update
// predict the
printf("----------------test -----------------\n");
getTestImg(imgtestvec);
int32_t testnum = mtestingsum;
SGMatrix<float64_t> testfeat(dims, testnum);
for(int i = 0 ; i < testnum ; i ++ ) {
for(int j = 0 ; j < dims ; j ++ ) {
testfeat(j,i) = imgtestvec[i][j];
}
}
CDenseFeatures<float64_t>* testfeatures=new CDenseFeatures<float64_t>(feature_cache);
SG_REF(testfeatures);
testfeatures->set_feature_matrix(testfeat);
CBinaryLabels* testresult = CBinaryLabels::obtain_from_generic (svm->apply(testfeatures) );
int32_t rightnum1 = 0;
int32_t rightsum1 = 0;
int32_t rightnum2 = 0;
for (int32_t i=0; i<testnum; i++) {
SG_SPRINT("output[%d]=%f\n", i, testresult->get_label(i));
if(imgtestlabelvec[i] == 1 ) {
if( (testresult->get_label(i)) < 0.0) {
rightnum1 ++;
}
rightsum1 ++ ;
} else
if(imgtestlabelvec[i] == 2 && testresult->get_label(i) > 0.0) {
rightnum2 ++ ;
}
}
printf(" %lf\n ",(rightnum1+rightnum2)*1.0 / testnum);
printf("class 1 : %lf\n",rightnum1 *1.0 / rightsum1);
printf("class 2 : %lf\n",rightnum2 *1.0 / (testnum - rightsum1));
SG_UNREF(out_labels);
SG_UNREF(kernel);
SG_UNREF(features);
SG_UNREF(svm);
exit_shogun();
}
bool COctaveInterface::run_octave_helper(CSGInterface* from_if)
{
from_if->SG_DEBUG("Entering Octave\n");
octave_save_signal_mask ();
if (octave_set_current_context)
{
#if defined (USE_EXCEPTIONS_FOR_INTERRUPTS)
panic_impossible ();
#else
unwind_protect::run_all ();
raw_mode (0);
octave_restore_signal_mask ();
#endif
}
can_interrupt = true;
octave_catch_interrupts ();
octave_initialized = true;
try
{
int parse_status;
char* octave_code=NULL;
clear_octave_globals();
for (int i=0; i<from_if->get_nrhs(); i++)
{
int len=0;
char* var_name = from_if->get_string(len);
from_if->SG_DEBUG("var_name = '%s'\n", var_name);
if (strmatch(var_name, "octavecode"))
{
len=0;
octave_code=from_if->get_string(len);
from_if->SG_DEBUG("octave_code = '%s'\n", octave_code);
break;
}
else
{
octave_value_list args;
COctaveInterface* in = new COctaveInterface(args, 1, false);
in->create_return_values(1);
from_if->translate_arg(from_if, in);
#if OCTAVE_APIVERSION >= 37
symbol_table::varref (var_name) = in->get_return_values()(0);
#else
set_global_value(var_name, in->get_return_values()(0));
#endif
delete[] var_name;
SG_UNREF(in);
}
}
#if OCTAVE_APIVERSION >= 37
#else
symbol_table* old=curr_sym_tab;
curr_sym_tab = global_sym_tab;
#endif
reset_error_handler ();
eval_string(octave_code, false, parse_status);
delete[] octave_code;
int32_t sz=0;
octave_value_list results;
#if OCTAVE_APIVERSION >= 37
if (symbol_table::is_variable("results"))
{
results = symbol_table::varval("results");
//results = get_global_value("results", false);
sz=results.length();
}
#else
if (curr_sym_tab->lookup("results"))
{
results = get_global_value("results", false);
sz=results.length();
}
#endif
if (sz>0)
{
if (results(0).is_list())
{
from_if->SG_DEBUG("Found return list of length %d\n", results(0).length());
results=results(0).list_value();
sz=results.length();
}
}
if (sz>0 && from_if->create_return_values(sz))
{
from_if->SG_DEBUG("Found %d args\n", sz);
COctaveInterface* out = new COctaveInterface(results, sz, false);
//process d
for (int32_t i=0; i<sz; i++)
from_if->translate_arg(out, from_if);
SG_UNREF(out);
}
else
{
if (sz!=from_if->get_nlhs())
{
from_if->SG_ERROR("Number of return values (%d) does not match number of expected"
" return values (%d).\n", sz, from_if->get_nlhs());
}
}
#if OCTAVE_APIVERSION >= 37
#else
curr_sym_tab=old;
#endif
}
catch (octave_interrupt_exception)
{
recover_from_exception ();
SG_SPRINT("%\n");
}
catch (std::bad_alloc)
{
recover_from_exception ();
SG_SPRINT("%\n");
}
octave_restore_signal_mask();
octave_initialized = false;
from_if->SG_DEBUG("Leaving Octave.\n");
return true;
}
