double MCLR_SM::logit_g(double alpha,vnl_matrix<double> data_with_bias)
{
double gVal = 0;
vnl_matrix<double> w_temp;
w_temp = m.w + direction * alpha;
vnl_matrix<double> f;
f = Get_F_Matrix(data_with_bias,w_temp);
vnl_vector<double> denominator(f.cols(),0);
vnl_vector<double> f_vec(f.cols(),0);
// Get the denominator
for(int i=0;i<f.cols();++i)
{
vnl_vector<double> temp_col = f.get_column(i);
denominator(i) = temp_col.sum();
}
for(int i=0;i<f.cols();++i)
{
vnl_vector<double> temp_col = f.get_column(i);
f_vec(i) = temp_col(y(i)-1)/denominator(i);
if(f_vec(i)==0)
f_vec(i) = 1e-9;
}
// Objective function value
for(int i=0;i<f_vec.size();++i)
{
gVal = gVal+log(f_vec(i));
}
//std::cout<<m.w(0,0)<<" --- " << m.w(0,1)<<"---"<< m.w(0,2)<<std::endl;
//std::cout<<m.w(38,0) <<" --- " << m.w(38,1) <<"---"<< m.w(38,2) <<std::endl;
//g = g - C*sum(sum(sqrt(w.^2+delta))); % consider the sparseness penalty
double diff_term =0;
for(int i=0;i<no_of_features+1;++i)
{
for(int j=0;j<no_of_classes;++j)
{
diff_term += sqrt(w_temp(i,j)*w_temp(i,j)+delta);
}
}
diff_term = diff_term * m.sparsity_control;
gVal = diff_term-gVal;
return gVal;
}
void Basker<Int,Entry,Exe_Space>::btf_blk_amd
(
BASKER_MATRIX &M,
INT_1DARRAY p,
INT_1DARRAY btf_nnz,
INT_1DARRAY btf_work
)
{
// printf("=============BTF_BLK_AMD_CALLED========\n");
if(Options.incomplete == BASKER_TRUE)
{
//We note that AMD on incomplete ILUK
//Seems realy bad and leads to a zero on the diag
//Therefore, we simply return the natural ordering
for(Int i = 0 ; i < M.ncol; i++)
{
p(i) = i;
}
//We will makeup work to be 1,
//Since BTF is not supported in our iluk
for(Int b = 0; b < btf_nblks; b++)
{
btf_nnz(b) = 1;
btf_work(b) =1;
}
//printf("Short amd blk\n");
return;
}
//p == length(M)
//Scan over all blks
//Note, that this needs to be made parallel in the
//future (Future Josh will be ok with this, right?)
//This is a horrible way to do this!!!!!
//KLU does this very nice, but they also make all the little blks
INT_1DARRAY temp_col;
MALLOC_INT_1DARRAY(temp_col, M.ncol+1);
INT_1DARRAY temp_row;
MALLOC_INT_1DARRAY(temp_row, M.nnz);
//printf("Done with btf_blk_amd malloc \n");
//printf("blks: %d \n" , btf_nblks);
for(Int b = 0; b < btf_nblks; b++)
{
Int blk_size = btf_tabs(b+1) - btf_tabs(b);
//printf("blk: %d blk_size: %d \n",
// b, blk_size);
if(blk_size < 3)
{
//printf("debug, blk_size: %d \n", blk_size);
for(Int ii = 0; ii < blk_size; ++ii)
{
//printf("set %d \n", btf_tabs(b)+ii-M.scol);
p(ii+btf_tabs(b)) = btf_tabs(b)+ii-M.scol;
}
btf_work(b) = blk_size*blk_size*blk_size;
btf_nnz(b) = (.5*(blk_size*blk_size) + blk_size);
continue;
}
INT_1DARRAY tempp;
MALLOC_INT_1DARRAY(tempp, blk_size+1);
//Fill in temp matrix
Int nnz = 0;
Int column = 1;
temp_col(0) = 0;
for(Int k = btf_tabs(b); k < btf_tabs(b+1); k++)
{
for(Int i = M.col_ptr(k); i < M.col_ptr(k+1); i++)
{
if(M.row_idx(i) < btf_tabs(b))
continue;
temp_row(nnz) = M.row_idx(i) - btf_tabs(b);
nnz++;
}// end over all row_idx
temp_col(column) = nnz;
column++;
}//end over all columns k
#ifdef BASKER_DEBUG_ORDER_AMD
printf("col_ptr: ");
for(Int i = 0 ; i < blk_size+1; i++)
{
printf("%d, ", temp_col(i));
}
printf("\n");
printf("row_idx: ");
for(Int i = 0; i < nnz; i++)
{
printf("%d, ", temp_row(i));
}
printf("\n");
#endif
double l_nnz = 0;
double lu_work = 0;
BaskerSSWrapper<Int>::amd_order(blk_size, &(temp_col(0)),
&(temp_row(0)),&(tempp(0)),
l_nnz, lu_work);
btf_nnz(b) = l_nnz;
btf_work(b) = lu_work;
#ifdef BASKER_DEBUG_ORDER_AMD
printf("blk: %d order: \n", b);
for(Int ii = 0; ii < blk_size; ii++)
{
printf("%d, ", tempp(ii));
}
#endif
//Add to the bigger perm vector
for(Int ii = 0; ii < blk_size; ii++)
{
//printf("loc: %d val: %d \n",
//ii+btf_tabs(b), tempp(ii)+btf_tabs(b));
p(tempp(ii)+btf_tabs(b)) = ii+btf_tabs(b);
}
FREE_INT_1DARRAY(tempp);
}//over all blk_tabs
#ifdef BASKER_DEBUG_AMD_ORDER
printf("blk amd final order\n");
for(Int ii = 0; ii < M.ncol; ii++)
{
printf("%d, ", p(ii));
}
printf("\n");
#endif
FREE_INT_1DARRAY(temp_col);
FREE_INT_1DARRAY(temp_row);
}//end blk_amd()
void Basker<Int,Entry,Exe_Space>::blk_amd(BASKER_MATRIX &M, INT_1DARRAY p)
{
//p == length(M)
//Scan over all blks
//Note, that this needs to be made parallel in the
//future (Future Josh will be ok with this, right?)
//This is a horrible way to do this!!!!!
//KLU does this very nice, but they also make all the little blks
INT_1DARRAY temp_col;
MALLOC_INT_1DARRAY(temp_col, M.ncol+1);
INT_1DARRAY temp_row;
MALLOC_INT_1DARRAY(temp_row, M.nnz);
for(Int b = btf_tabs_offset; b < btf_nblks; b++)
{
Int blk_size = btf_tabs(b+1) - btf_tabs(b);
if(blk_size < 3)
{
//printf("debug, blk_size: %d \n", blk_size);
for(Int ii = 0; ii < blk_size; ++ii)
{
//printf("set %d \n", btf_tabs(b)+ii-M.scol);
p(ii+btf_tabs(b)) = btf_tabs(b)+ii-M.scol;
}
continue;
}
INT_1DARRAY tempp;
MALLOC_INT_1DARRAY(tempp, blk_size+1);
//Fill in temp matrix
Int nnz = 0;
Int column = 1;
temp_col(0) = 0;
for(Int k = btf_tabs(b); k < btf_tabs(b+1); k++)
{
for(Int i = M.col_ptr(k); i < M.col_ptr(k+1); i++)
{
if(M.row_idx(i) < btf_tabs(b))
continue;
temp_row(nnz) = M.row_idx(i) - btf_tabs(b);
nnz++;
}// end over all row_idx
temp_col(column) = nnz;
column++;
}//end over all columns k
#ifdef BASKER_DEBUG_ORDER_AMD
printf("col_ptr: ");
for(Int i = 0 ; i < blk_size+1; i++)
{
printf("%d, ", temp_col(i));
}
printf("\n");
printf("row_idx: ");
for(Int i = 0; i < nnz; i++)
{
printf("%d, ", temp_row(i));
}
printf("\n");
#endif
BaskerSSWrapper<Int>::amd_order(blk_size, &(temp_col(0)),
&(temp_row(0)),&(tempp(0)));
#ifdef BASKER_DEBUG_ORDER_AMD
printf("blk: %d order: \n", b);
for(Int ii = 0; ii < blk_size; ii++)
{
printf("%d, ", tempp(ii));
}
#endif
//Add to the bigger perm vector
for(Int ii = 0; ii < blk_size; ii++)
{
//printf("loc: %d val: %d \n",
//ii+btf_tabs(b), tempp(ii)+btf_tabs(b));
p(tempp(ii)+btf_tabs(b)) = ii+btf_tabs(b);
}
FREE_INT_1DARRAY(tempp);
}//over all blk_tabs
#ifdef BASKER_DEBUG_AMD_ORDER
printf("blk amd final order\n");
for(Int ii = 0; ii < M.ncol; ii++)
{
printf("%d, ", p(ii));
}
printf("\n");
#endif
FREE_INT_1DARRAY(temp_col);
FREE_INT_1DARRAY(temp_row);
}//end blk_amd()
