/** * The update rule for the basis matrix W. * The function takes in all the matrices and only changes the * value of the W matrix. * * @param V Input matrix to be factorized. * @param W Basis matrix to be updated. * @param H Encoding matrix. */ inline void WUpdate(const arma::sp_mat& V, arma::mat& W, const arma::mat& H) { if(!isStart) (*it)++; else isStart = false; if(*it == V.end()) { delete it; it = new arma::sp_mat::const_iterator(V.begin()); } size_t currentUserIndex = it->col(); size_t currentItemIndex = it->row(); arma::mat deltaW(1, W.n_cols); deltaW.zeros(); deltaW += (**it - arma::dot(W.row(currentItemIndex), H.col(currentUserIndex))) * arma::trans(H.col(currentUserIndex)); if(kw != 0) deltaW -= kw * W.row(currentItemIndex); W.row(currentItemIndex) += u*deltaW; }
inline void WUpdate(const MatType& V, arma::mat& W, const arma::mat& H) { arma::mat deltaW(n, W.n_cols); deltaW.zeros(); for(size_t i = 0;i < n;i++) { double val; if((val = V(i, currentUserIndex)) != 0) deltaW.row(i) += (val - arma::dot(W.row(i), H.col(currentUserIndex))) * arma::trans(H.col(currentUserIndex)); if(kw != 0) deltaW.row(i) -= kw * W.row(i); } W += u*deltaW; }
inline void SVDIncompleteIncrementalLearning:: WUpdate<arma::sp_mat>(const arma::sp_mat& V, arma::mat& W, const arma::mat& H) { arma::mat deltaW(n, W.n_cols); deltaW.zeros(); for(arma::sp_mat::const_iterator it = V.begin_col(currentUserIndex); it != V.end_col(currentUserIndex);it++) { double val = *it; size_t i = it.row(); deltaW.row(i) += (val - arma::dot(W.row(i), H.col(currentUserIndex))) * arma::trans(H.col(currentUserIndex)); if(kw != 0) deltaW.row(i) -= kw * W.row(i); } W += u*deltaW; }
int main(int argc, char *argv[]) { MPI_Init(&argc, &argv); mpi::environment env(argc, argv); mpi::communicator world; DistributedSettings distributedSettings; Context ctx(distributedSettings); consoleHelper::parseDistributedOptions(ctx, distributedSettings, argc, argv); ctx.settings.verbose = true; if (world.rank() != 0) { ctx.settings.verbose = false; } ProblemData<unsigned int, double> instance; instance.theta = ctx.tmp; cout << "XXXXXXXx " << instance.theta << endl; cout << world.rank() << " going to load data" << endl; //ctx.matrixAFile = "/Users/Schemmy/Desktop/ac-dc/cpp/data/a1a.4/a1a"; //cout<< ctx.matrixAFile<<endl; loadDistributedSparseSVMRowData(ctx.matrixAFile, world.rank(), world.size(), instance, false); unsigned int finalM; vall_reduce_maximum(world, &instance.m, &finalM, 1); // cout << "Local m " << instance.m << " global m " << finalM << endl; instance.m = finalM; // for (unsigned int i = 0; i < instance.m; i++) { // for (unsigned int j = instance.A_csr_row_ptr[i]; // j < instance.A_csr_row_ptr[i + 1]; j++) { // instance.A_csr_values[j] = instance.A_csr_values[j] * instance.b[i]; // } // instance.b[i] = 1; // } instance.lambda = ctx.lambda; std::vector<double> wBuffer(instance.m); std::vector<double> deltaW(instance.m); std::vector<double> deltaAlpha(instance.n); std::vector<double> w(instance.m); instance.x.resize(instance.n); cblas_set_to_zero(instance.x); cblas_set_to_zero(w); cblas_set_to_zero(deltaW); // compute local w vall_reduce(world, deltaW, w); // cout << " Local n " << instance.n << endl; vall_reduce(world, &instance.n, &instance.total_n, 1); instance.oneOverLambdaN = 1 / (0.0 + instance.total_n * instance.lambda); double gamma; if (distributedSettings.APPROX) { gamma = 1; instance.penalty = world.size() + 0.0; } else { gamma = 1 / (world.size() + 0.0); instance.penalty = 1; } LossFunction<unsigned int, double> * lf; instance.experimentName = ctx.experimentName; int loss = distributedSettings.lossFunction; // + distributedSettings.APPROX * 100; switch (loss) { case 0: lf = new LogisticLossCD<unsigned int, double>(); break; case 1: lf = new HingeLossCD<unsigned int, double>(); break; case 2: lf = new SquareHingeLossCD<unsigned int, double>(); break; case 3: lf = new QuadraticLossCD<unsigned int, double>(); break; default: break; } lf->init(instance); std::stringstream ss; int localsolver = distributedSettings.LocalMethods; // ss << ctx.matrixAFile << "_" << instance.lambda << "_" // << distributedSettings.lossFunction << "_" // << distributedSettings.iters_communicate_count << "_" // << distributedSettings.iterationsPerThread << "_" // << instance.experimentName << "_" << distributedSettings.APPROX // << "_" << instance.theta << "_.log"; ss << ctx.matrixAFile << "_" << distributedSettings.lossFunction << "_" << localsolver << "_" << distributedSettings.iters_communicate_count << "_" << distributedSettings.iterationsPerThread << "_" << instance.lambda << "_" << distributedSettings.APPROX << ".log"; std::ofstream logFile; if (ctx.settings.verbose) { logFile.open(ss.str().c_str()); } distributedSettings.iters_bulkIterations_count = 1; // distributedSettings.iters_communicate_count = // distributedSettings.iters_communicate_count // / distributedSettings.iters_bulkIterations_count; // cout << "BULK "<<distributedSettings.iters_bulkIterations_count<<" "<< distributedSettings.iters_communicate_count<<endl; // cout<< instance.A_csr_row_ptr[instance.A_csr_row_ptr.size()-1] <<endl; switch (localsolver) { case 0: lf->subproblem_solver_SDCA(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; case 1: lf->subproblem_solver_accelerated_SDCA(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; case 2: lf->subproblem_solver_steepestdescent(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; case 3: lf->subproblem_solver_LBFGS(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; case 4: lf->subproblem_solver_CG(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; case 5: lf->subproblem_solver_BB(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; case 6: lf->subproblem_solver_FISTA(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; case 7: lf->subproblem_solver_SDCA_without_duality(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); case 8: lf->Acce_subproblem_solver_SDCA(instance, deltaAlpha, w, wBuffer, deltaW, distributedSettings, world, gamma, ctx, logFile); break; default: break; } // std::vector<double> trainLabel(instance.n); // std::vector<unsigned int> trainError(2); // std::vector<unsigned int> totalTrainError(2); // for (unsigned int idx = 0; idx < instance.n; idx++) { // for (unsigned int i = instance.A_csr_row_ptr[idx]; i < instance.A_csr_row_ptr[idx + 1]; i++) { // trainLabel[idx] += w[instance.A_csr_col_idx[i]] * instance.A_csr_values[i]; // } // if (trainLabel[idx] * instance.b[idx] <= 0 ) // trainError[0] += 1; // } // vall_reduce(world, trainError, totalTrainError); // cout << 1.0*totalTrainError[0] /instance.total_n << endl; //------------------------------------------------------- if (ctx.settings.verbose) { logFile.close(); } MPI::Finalize(); return 0; }