void LinRegSubsolver::writeModel(char* fname, double* model){
ofstream model_out(fname);
model_out << D << endl;
for(int i=0;i<D;i++){
model_out << model[i] << endl;
}
model_out.close();
}
int L1rlrOwlqnAlgorithm::save_model(std::string filename)
{
std::ofstream model_out(filename.c_str());
if (!model_out.is_open())
{
std::cout << "Open model file [" << filename << "] failed!" << std::endl;
}
model_out << _data->feature_num() << " " << _l1weight << std::endl;
std::cout << "saveing model! " << _data->feature_num() << std::endl;
for (uint32_t i = 0; i < _data->feature_num(); ++i )
{
model_out << " " << _x_k[i];
}
model_out.close();
return 0;
}
vector<double> linearModel(const vector<double>& t, const vector<double>& params)
{
int n = t.size();
vector<double> model_out(n);
double m = params[0];
double c = params[1];
//cout << "M = " << m << ", C = " << c << endl;
for (int i=0; i<n; i++) {
model_out[i] = m * t[i] + c;
}
return model_out;
}
vector<double> logisticModel(const vector<double>& t, const vector<double>& params) {
// cout << "Running logisticModel" << endl;
// cout << "P: " << params[0] << endl;
int n = t.size();
vector<double> model_out(n);
double par1 = params[0];
double par2 = params[1];
double par3 = params[2];
for (int i=0; i<n; i++) {
model_out[i] = par1 + (par3 * t[i] - log(1 + (exp(par3 * t[i]) - 1)/exp(par2 - par1)));
}
return model_out;
}
vector<double> Bar4Par(const vector<double>& t, const vector<double>& params) {
double par1 = params[0];
double par2 = params[1];
double par3 = params[2];
double par4 = params[3];
int n = t.size();
vector<double> model_out(n);
double a1 = 1;
double a2 = 1;
double a3 = 1;
double A;
for (int i=0; i<n; i++) {
A = a2 * (t[i] - par4/par3 +
log(1 - a2 * (exp(-par3 * t[i]) + a3 * exp(-(par3 * t[i] - par4))))/par3);
}
return model_out;
}
int main (int argc, char ** argv) {
if (argc < 5) {
cerr << "Usage: " << endl;
cerr << "\tHDP_MEDOIDS [dataFile] [nRuns] [lambda_global] [lambda_local]" << endl;
exit(-1);
}
// PARSE arguments
char* dataFile = argv[1];
int nRuns = atoi(argv[2]);
vector<double> LAMBDAs (2, 0.0);
LAMBDAs[0] = atof(argv[3]); // lambda_global
LAMBDAs[1] = atof(argv[4]); // lambda_local
objmin_trace << "time objective" << endl;
// read in data
int FIX_DIM;
Parser parser;
vector<Instance*>* pdata;
vector<Instance*> data;
pdata = parser.parseSVM(dataFile, FIX_DIM);
data = *pdata;
// init lookup_tables
vector< pair<int,int> > doc_lookup;
get_doc_lookup (data, doc_lookup);
Lookups lookup_tables;
lookup_tables.doc_lookup = &doc_lookup;
lookup_tables.nWords = data.size();
lookup_tables.nDocs = lookup_tables.doc_lookup->size();
int seed = time(NULL);
srand (seed);
cerr << "###########################################" << endl;
cerr << "nDocs = " << lookup_tables.nDocs << endl; // # documents
cerr << "nWords = " << lookup_tables.nWords << endl; // # words
cerr << "lambda_global = " << LAMBDAs[0] << endl;
cerr << "lambda_local = " << LAMBDAs[1] << endl;
cerr << "TRIM_THRESHOLD = " << TRIM_THRESHOLD << endl;
cerr << "seed = " << seed << endl;
cerr << "###########################################" << endl;
// Run sparse convex clustering
int N = lookup_tables.nWords;
int D = lookup_tables.nDocs;
double** W = mat_init (N, N);
// dist_mat computation and output
dist_func df = L2norm;
double** dist_mat = mat_init (N, N);
compute_dist_mat (data, dist_mat, N, FIX_DIM, df, true);
start_time = omp_get_wtime();
double min_obj = INF;
vector< vector<double> > min_means;
for (int j = 0; j < nRuns; j ++) {
vector< vector<double> > means;
// inner-doc shuffle
for (int d = 0; d < D; d++) {
int begin_i = doc_lookup[d].first;
int end_i = doc_lookup[d].second;
random_shuffle(data.begin()+begin_i, data.begin()+end_i);
}
// between-doc shuffle
vector<pair<int,int> > s_doc_lookup (doc_lookup);
random_shuffle(s_doc_lookup.begin(), s_doc_lookup.end());
vector<Instance*> s_data (N, NULL);
int p = 0;
for (int d = 0; d < D; d ++) {
for (int i = s_doc_lookup[d].first; i < s_doc_lookup[d].second; i ++) {
s_data[p] = data[i];
p ++;
}
}
lookup_tables.doc_lookup = &s_doc_lookup;
double obj = HDP_MEDOIDS (s_data, means, &lookup_tables, LAMBDAs, df, FIX_DIM);
lookup_tables.doc_lookup = &doc_lookup;
cerr << "###################################################" << endl;
if (obj < min_obj) {
min_obj = obj;
min_means = means;
}
}
/* Output objective */
output_objective (min_obj);
ofstream model_out ("opt_model");
for (int i = 0; i < min_means.size(); i ++) {
model_out << "mean[" << i << "] ";
for (int j = 0; j < min_means[i].size(); j ++) {
model_out << min_means[i][j] << " " ;
}
model_out << endl;
}
model_out.close();
/* Output cluster centroids */
// output_model (W, &lookup_tables);
/* Output assignment */
// output_assignment (W, &lookup_tables);
/* reallocation */
mat_free (W, N, N);
mat_free (dist_mat, N, N);
objmin_trace.close();
}
