CSimpleFeatures<float64_t>* CKernelLocallyLinearEmbedding::embed_kernel(CKernel* kernel)
{
CTime* time = new CTime();
time->start();
SGMatrix<float64_t> kernel_matrix = kernel->get_kernel_matrix();
SG_DEBUG("Kernel matrix computation took %fs\n",time->cur_time_diff());
time->start();
SGMatrix<int32_t> neighborhood_matrix = get_neighborhood_matrix(kernel_matrix,m_k);
SG_DEBUG("Neighbors finding took %fs\n",time->cur_time_diff());
time->start();
SGMatrix<float64_t> M_matrix = construct_weight_matrix(kernel_matrix,neighborhood_matrix);
SG_DEBUG("Weights computation took %fs\n",time->cur_time_diff());
kernel_matrix.destroy_matrix();
neighborhood_matrix.destroy_matrix();
time->start();
SGMatrix<float64_t> nullspace = construct_embedding(M_matrix,m_target_dim);
SG_DEBUG("Embedding construction took %fs\n",time->cur_time_diff());
M_matrix.destroy_matrix();
delete time;
return new CSimpleFeatures<float64_t>(nullspace);
}
SGVector<complex128_t> CCGMShiftedFamilySolver::solve_shifted_weighted(
CLinearOperator<SGVector<float64_t>, SGVector<float64_t> >* A, SGVector<float64_t> b,
SGVector<complex128_t> shifts, SGVector<complex128_t> weights)
{
SG_DEBUG("Entering\n");
// sanity check
REQUIRE(A, "Operator is NULL!\n");
REQUIRE(A->get_dimension()==b.vlen, "Dimension mismatch! [%d vs %d]\n",
A->get_dimension(), b.vlen);
REQUIRE(shifts.vector,"Shifts are not initialized!\n");
REQUIRE(weights.vector,"Weights are not initialized!\n");
REQUIRE(shifts.vlen==weights.vlen, "Number of shifts and number of "
"weights are not equal! [%d vs %d]\n", shifts.vlen, weights.vlen);
// the solution matrix, one column per shift, initial guess 0 for all
MatrixXcd x_sh=MatrixXcd::Zero(b.vlen, shifts.vlen);
MatrixXcd p_sh=MatrixXcd::Zero(b.vlen, shifts.vlen);
// non-shifted direction
SGVector<float64_t> p_(b.vlen);
// the rest of the part hinges on eigen3 for computing norms
Map<VectorXd> b_map(b.vector, b.vlen);
Map<VectorXd> p(p_.vector, p_.vlen);
// residual r_i=b-Ax_i, here x_0=[0], so r_0=b
VectorXd r=b_map;
// initial direction is same as residual
p=r;
p_sh=r.replicate(1, shifts.vlen).cast<complex128_t>();
// non shifted initializers
float64_t r_norm2=r.dot(r);
float64_t beta_old=1.0;
float64_t alpha=1.0;
// shifted quantities
SGVector<complex128_t> alpha_sh(shifts.vlen);
SGVector<complex128_t> beta_sh(shifts.vlen);
SGVector<complex128_t> zeta_sh_old(shifts.vlen);
SGVector<complex128_t> zeta_sh_cur(shifts.vlen);
SGVector<complex128_t> zeta_sh_new(shifts.vlen);
// shifted initializers
zeta_sh_old.set_const(1.0);
zeta_sh_cur.set_const(1.0);
// the iterator for this iterative solver
IterativeSolverIterator<float64_t> it(r, m_max_iteration_limit,
m_relative_tolerence, m_absolute_tolerence);
// start the timer
CTime time;
time.start();
// set the residuals to zero
if (m_store_residuals)
m_residuals.set_const(0.0);
// CG iteration begins
for (it.begin(r); !it.end(r); ++it)
{
SG_DEBUG("CG iteration %d, residual norm %f\n",
it.get_iter_info().iteration_count,
it.get_iter_info().residual_norm);
if (m_store_residuals)
{
m_residuals[it.get_iter_info().iteration_count]
=it.get_iter_info().residual_norm;
}
// apply linear operator to the direction vector
SGVector<float64_t> Ap_=A->apply(p_);
Map<VectorXd> Ap(Ap_.vector, Ap_.vlen);
// compute p^{T}Ap, if zero, failure
float64_t p_dot_Ap=p.dot(Ap);
if (p_dot_Ap==0.0)
break;
// compute the beta parameter of CG_M
float64_t beta=-r_norm2/p_dot_Ap;
// compute the zeta-shifted parameter of CG_M
compute_zeta_sh_new(zeta_sh_old, zeta_sh_cur, shifts, beta_old, beta,
alpha, zeta_sh_new);
// compute beta-shifted parameter of CG_M
compute_beta_sh(zeta_sh_new, zeta_sh_cur, beta, beta_sh);
// update the solution vector and residual
for (index_t i=0; i<shifts.vlen; ++i)
x_sh.col(i)-=beta_sh[i]*p_sh.col(i);
// r_{i}=r_{i-1}+\beta_{i}Ap
r+=beta*Ap;
// compute new ||r||_{2}, if zero, converged
float64_t r_norm2_i=r.dot(r);
if (r_norm2_i==0.0)
break;
// compute the alpha parameter of CG_M
alpha=r_norm2_i/r_norm2;
// update ||r||_{2}
r_norm2=r_norm2_i;
// update direction
p=r+alpha*p;
compute_alpha_sh(zeta_sh_new, zeta_sh_cur, beta_sh, beta, alpha, alpha_sh);
for (index_t i=0; i<shifts.vlen; ++i)
{
p_sh.col(i)*=alpha_sh[i];
p_sh.col(i)+=zeta_sh_new[i]*r;
}
// update parameters
for (index_t i=0; i<shifts.vlen; ++i)
{
zeta_sh_old[i]=zeta_sh_cur[i];
zeta_sh_cur[i]=zeta_sh_new[i];
}
beta_old=beta;
}
float64_t elapsed=time.cur_time_diff();
if (!it.succeeded(r))
SG_WARNING("Did not converge!\n");
SG_INFO("Iteration took %d times, residual norm=%.20lf, time elapsed=%f\n",
it.get_iter_info().iteration_count, it.get_iter_info().residual_norm, elapsed);
// compute the final result vector multiplied by weights
SGVector<complex128_t> result(b.vlen);
result.set_const(0.0);
Map<VectorXcd> x(result.vector, result.vlen);
for (index_t i=0; i<x_sh.cols(); ++i)
x+=x_sh.col(i)*weights[i];
SG_DEBUG("Leaving\n");
return result;
}
bool CShareBoost::train_machine(CFeatures* data)
{
if (data)
set_features(data);
if (m_features == NULL)
SG_ERROR("No features given for training\n")
if (m_labels == NULL)
SG_ERROR("No labels given for training\n")
if (m_nonzero_feas <= 0)
SG_ERROR("Set a valid (> 0) number of non-zero features to seek before training\n")
if (m_nonzero_feas >= dynamic_cast<CDenseFeatures<float64_t>*>(m_features)->get_num_features())
SG_ERROR("It doesn't make sense to use ShareBoost with num non-zero features >= num features in the data\n")
m_fea = dynamic_cast<CDenseFeatures<float64_t> *>(m_features)->get_feature_matrix();
m_rho = SGMatrix<float64_t>(m_multiclass_strategy->get_num_classes(), m_fea.num_cols);
m_rho_norm = SGVector<float64_t>(m_fea.num_cols);
m_pred = SGMatrix<float64_t>(m_fea.num_cols, m_multiclass_strategy->get_num_classes());
m_pred.zero();
m_activeset = SGVector<int32_t>(m_fea.num_rows);
m_activeset.vlen = 0;
m_machines->reset_array();
for (int32_t i=0; i < m_multiclass_strategy->get_num_classes(); ++i)
m_machines->push_back(new CLinearMachine());
CTime *timer = new CTime();
float64_t t_compute_pred = 0; // t of 1st round is 0, since no pred to compute
for (int32_t t=0; t < m_nonzero_feas; ++t)
{
timer->start();
compute_rho();
int32_t i_fea = choose_feature();
m_activeset.vector[m_activeset.vlen] = i_fea;
m_activeset.vlen += 1;
float64_t t_choose_feature = timer->cur_time_diff();
timer->start();
optimize_coefficients();
float64_t t_optimize = timer->cur_time_diff();
SG_SDEBUG(" SB[round %03d]: (%8.4f + %8.4f) sec.\n", t,
t_compute_pred + t_choose_feature, t_optimize);
timer->start();
compute_pred();
t_compute_pred = timer->cur_time_diff();
}
SG_UNREF(timer);
// release memory
m_fea = SGMatrix<float64_t>();
m_rho = SGMatrix<float64_t>();
m_rho_norm = SGVector<float64_t>();
m_pred = SGMatrix<float64_t>();
return true;
}
SGVector<float64_t> CConjugateGradientSolver::solve(
CLinearOperator<float64_t>* A, SGVector<float64_t> b)
{
SG_DEBUG("CConjugateGradientSolve::solve(): Entering..\n");
// sanity check
REQUIRE(A, "Operator is NULL!\n");
REQUIRE(A->get_dimension()==b.vlen, "Dimension mismatch!\n");
// the final solution vector, initial guess is 0
SGVector<float64_t> result(b.vlen);
result.set_const(0.0);
// the rest of the part hinges on eigen3 for computing norms
Map<VectorXd> x(result.vector, result.vlen);
Map<VectorXd> b_map(b.vector, b.vlen);
// direction vector
SGVector<float64_t> p_(result.vlen);
Map<VectorXd> p(p_.vector, p_.vlen);
// residual r_i=b-Ax_i, here x_0=[0], so r_0=b
VectorXd r=b_map;
// initial direction is same as residual
p=r;
// the iterator for this iterative solver
IterativeSolverIterator<float64_t> it(b_map, m_max_iteration_limit,
m_relative_tolerence, m_absolute_tolerence);
// CG iteration begins
float64_t r_norm2=r.dot(r);
// start the timer
CTime time;
time.start();
// set the residuals to zero
if (m_store_residuals)
m_residuals.set_const(0.0);
for (it.begin(r); !it.end(r); ++it)
{
SG_DEBUG("CG iteration %d, residual norm %f\n",
it.get_iter_info().iteration_count,
it.get_iter_info().residual_norm);
if (m_store_residuals)
{
m_residuals[it.get_iter_info().iteration_count]
=it.get_iter_info().residual_norm;
}
// apply linear operator to the direction vector
SGVector<float64_t> Ap_=A->apply(p_);
Map<VectorXd> Ap(Ap_.vector, Ap_.vlen);
// compute p^{T}Ap, if zero, failure
float64_t p_dot_Ap=p.dot(Ap);
if (p_dot_Ap==0.0)
break;
// compute the alpha parameter of CG
float64_t alpha=r_norm2/p_dot_Ap;
// update the solution vector and residual
// x_{i}=x_{i-1}+\alpha_{i}p
x+=alpha*p;
// r_{i}=r_{i-1}-\alpha_{i}p
r-=alpha*Ap;
// compute new ||r||_{2}, if zero, converged
float64_t r_norm2_i=r.dot(r);
if (r_norm2_i==0.0)
break;
// compute the beta parameter of CG
float64_t beta=r_norm2_i/r_norm2;
// update direction, and ||r||_{2}
r_norm2=r_norm2_i;
p=r+beta*p;
}
float64_t elapsed=time.cur_time_diff();
if (!it.succeeded(r))
SG_WARNING("Did not converge!\n");
SG_INFO("Iteration took %ld times, residual norm=%.20lf, time elapsed=%lf\n",
it.get_iter_info().iteration_count, it.get_iter_info().residual_norm, elapsed);
SG_DEBUG("CConjugateGradientSolve::solve(): Leaving..\n");
return result;
}
int main()
{
init_shogun(&print_message, &print_warning,
&print_error);
try
{
uint256_t* a;
uint32_t* b;
CTime t;
t.io->set_loglevel(MSG_DEBUG);
SG_SPRINT("gen data..");
t.start();
gen_ints(a,b, LEN);
t.cur_time_diff(true);
SG_SPRINT("qsort..");
t.start();
CMath::qsort_index(a, b, LEN);
t.cur_time_diff(true);
SG_SPRINT("\n\n");
for (uint32_t i=0; i<10; i++)
{
SG_SPRINT("a[%d]=", i);
a[i].print_hex();
SG_SPRINT("\n");
}
SG_SPRINT("\n\n");
a[0]=(uint64_t[4]) {1,2,3,4};
uint64_t val[4]={5,6,7,8};
a[1]=val;
a[2]=a[0];
CMath::swap(a[0],a[1]);
printf("a[0]==a[1] %d\n", (int) (a[0] == a[1]));
printf("a[0]<a[1] %d\n", (int) (a[0] < a[1]));
printf("a[0]<=a[1] %d\n", (int) (a[0] <= a[1]));
printf("a[0]>a[1] %d\n", (int) (a[0] > a[1]));
printf("a[0]>=a[1] %d\n", (int) (a[0] >= a[1]));
printf("a[0]==a[0] %d\n", (int) (a[0] == a[0]));
printf("a[0]<a[0] %d\n", (int) (a[0] < a[0]));
printf("a[0]<=a[0] %d\n", (int) (a[0] <= a[0]));
printf("a[0]>a[0] %d\n", (int) (a[0] > a[0]));
printf("a[0]>=a[0] %d\n", (int) (a[0] >= a[0]));
SG_SPRINT("\n\n");
for (uint32_t i=0; i<10 ; i++)
{
SG_SPRINT("a[%d]=", i);
a[i].print_hex();
printf("\n");
}
delete[] a;
delete[] b;
}
catch(ShogunException & sh)
{
SG_SPRINT("%s",sh.get_exception_string());
}
exit_shogun();
}
CFeatures* CLocallyLinearEmbedding::apply(CFeatures* features)
{
ASSERT(features);
// check features
if (!(features->get_feature_class()==C_DENSE &&
features->get_feature_type()==F_DREAL))
{
SG_ERROR("Given features are not of SimpleRealFeatures type.\n");
}
// shorthand for simplefeatures
CDenseFeatures<float64_t>* simple_features = (CDenseFeatures<float64_t>*) features;
SG_REF(features);
// get and check number of vectors
int32_t N = simple_features->get_num_vectors();
if (m_k>=N)
SG_ERROR("Number of neighbors (%d) should be less than number of objects (%d).\n",
m_k, N);
// compute distance matrix
SG_DEBUG("Computing distance matrix\n");
ASSERT(m_distance);
CTime* time = new CTime();
time->start();
m_distance->init(simple_features,simple_features);
SGMatrix<float64_t> distance_matrix = m_distance->get_distance_matrix();
m_distance->remove_lhs_and_rhs();
SG_DEBUG("Distance matrix computation took %fs\n",time->cur_time_diff());
SG_DEBUG("Calculating neighborhood matrix\n");
SGMatrix<int32_t> neighborhood_matrix;
time->start();
if (m_auto_k)
{
neighborhood_matrix = get_neighborhood_matrix(distance_matrix,m_max_k);
m_k = estimate_k(simple_features,neighborhood_matrix);
SG_DEBUG("Estimated k with value of %d\n",m_k);
}
else
neighborhood_matrix = get_neighborhood_matrix(distance_matrix,m_k);
SG_DEBUG("Neighbors finding took %fs\n",time->cur_time_diff());
// init W (weight) matrix
float64_t* W_matrix = SG_CALLOC(float64_t, N*N);
// construct weight matrix
SG_DEBUG("Constructing weight matrix\n");
time->start();
SGMatrix<float64_t> weight_matrix = construct_weight_matrix(simple_features,W_matrix,neighborhood_matrix);
SG_DEBUG("Weight matrix construction took %.5fs\n", time->cur_time_diff());
// find null space of weight matrix
SG_DEBUG("Finding nullspace\n");
time->start();
SGMatrix<float64_t> new_feature_matrix = construct_embedding(weight_matrix,m_target_dim);
SG_DEBUG("Eigenproblem solving took %.5fs\n", time->cur_time_diff());
delete time;
SG_UNREF(features);
return (CFeatures*)(new CDenseFeatures<float64_t>(new_feature_matrix));
}
