std::vector<flexible_type> pylambda_evaluator::bulk_eval_dict_rows( size_t lambda_hash, const std::vector<std::string>& keys, const sframe_rows& rows, bool skip_undefined, int seed) { python_thread_guard py_thread_guard; set_lambda(lambda_hash); py_set_random_seed(seed); std::vector<flexible_type> ret(rows.num_rows()); python::dict input; size_t cnt = 0; try { std::vector<flexible_type> row(rows.num_columns()); for (const auto& row_iter: rows) { for (size_t j = 0; j < row.size(); ++j) row[j] = row_iter[j]; PyDict_UpdateFromFlex(input, keys, row); python::object output = m_current_lambda->operator()(input); PyObject_AsFlex(output, ret[cnt]); cnt++; } } catch (python::error_already_set const& e) { std::string error_string = parse_python_error(); throw(error_string); } catch (std::exception& e) { throw(std::string(e.what())); } catch (...) { throw("Unknown exception from python lambda evaluation."); } return ret; }
void librandom::PoissonRandomDev::set_status( const DictionaryDatum& d ) { /* Limits on mu: - mu >= 0 trivial - As shown in comments in ldev(), the maximum absolute value that can be chosen as a candidate is mu + 710 * sqrt(mu). - We thus must require mu + 710 * sqrt(mu) < max(long). - This is equivalent to mu < ( 2 N + a^2 - sqrt(4 N + a^2) ) / 2 where N is the largest representable integer and a = 710. - Numerical evaluation shows that mu < 0.999 N is safe for 32 and 64 bit doubles with a good margin. */ const double MU_MAX = 0.999 * std::numeric_limits< long >::max(); double new_mu = mu_; if ( updateValue< double >( d, "lambda", new_mu ) ) { if ( new_mu < 0 ) throw BadParameterValue( "Poisson RDV: lambda >= 0 required." ); if ( new_mu > MU_MAX ) throw BadParameterValue( String::compose( "Poisson RDV: lambda < %1 required.", MU_MAX ) ); set_lambda( new_mu ); } }
flexible_type pylambda_evaluator::eval(size_t lambda_hash, const flexible_type& arg) { set_lambda(lambda_hash); try { python::object input = PyObject_FromFlex(arg); python::object output = m_current_lambda->operator()(input); return PyObject_AsFlex(output); } catch (python::error_already_set const& e) { std::string error_string = parse_python_error(); throw(error_string); } catch (std::exception& e) { throw(std::string(e.what())); } catch (...) { throw("Unknown exception from python lambda evaluation."); } }
void Cluster::Load(string filename) { //open and read file to memory if(_Read(filename) != 0) { cout <<"Error reading file"<<endl; exit; }; //parse term-doc count file _Parse(terms); //Weight by tf*idf, return total number of food items this->N = _Weight(); //normalize indices to unit vector _Norm(); set_lambda(0.5); }
std::vector<flexible_type> pylambda_evaluator::bulk_eval_rows( size_t lambda_hash, const sframe_rows& rows, bool skip_undefined, int seed) { python_thread_guard py_thread_guard; set_lambda(lambda_hash); py_set_random_seed(seed); std::vector<flexible_type> ret(rows.num_rows()); size_t i = 0; for (const auto& x : rows) { if (skip_undefined && x[0] == FLEX_UNDEFINED) { ret[i++] = FLEX_UNDEFINED; } else { ret[i++] = eval(lambda_hash, x[0]); } } return ret; }
/** * Bulk version of eval. */ std::vector<flexible_type> pylambda_evaluator::bulk_eval( size_t lambda_hash, const std::vector<flexible_type>& args, bool skip_undefined, int seed) { python_thread_guard py_thread_guard; set_lambda(lambda_hash); py_set_random_seed(seed); std::vector<flexible_type> ret(args.size()); size_t i = 0; for (const auto& x : args) { if (skip_undefined && x == FLEX_UNDEFINED) { ret[i++] = FLEX_UNDEFINED; } else { ret[i++] = eval(lambda_hash, x); } } return ret; }
// Sets hyperparameters from vector containing logs of hyperparameters void Sampler::SetHyperparameters(const vector<double>& hyperparameters) { assert(hyperparameters.size() == 2); set_alpha(exp(hyperparameters[0])); set_lambda(exp(hyperparameters[1])); }
void HomogeneousPoissonProcess::mle(){ double lambda_hat = suf()->count() / suf()->exposure(); set_lambda(lambda_hat); }
static SRM_binning option_assign(int argc, char **argv) { SRM_binning args; int c,option_index; static struct option long_options[] = { {"multiplicity", required_argument ,0,0}, {"binOut",required_argument,0,2}, {"inb",required_argument,0,3}, {"perm",no_argument,0,4}, {0,0,0,0} }; char *insert=NULL; args.multple = 2.0; args.quantile = 0.95; args.bin_size = 100; args.win_size = 200; args.output_file = NULL; args.binout_file = NULL; args.inbin_file = NULL; args.outlier_file=NULL; args.autoselect_lambda = 0; args.FP = 1; args.B = 10; args.fdr = 0; args.lambda = 2; args.paired = 0; args.tumor_file = NULL; args.normal_file = NULL; args.insert = 220; args.sd = 20; args.tumor_freq = 0.5; args.resampling = 1; args.in_tmor = NULL; args.in_nml = NULL; args.output = NULL; args.inbin = NULL; args.outbin = NULL; args.outlier = NULL; while((c=getopt_long(argc,argv,"2q:b:w:o:R:hf:p:B:l:",long_options,&option_index))!=-1){ switch(c){ case 0: args.multple = atoi(optarg); if(args.multple<1.0) { fprintf(stderr,"Error,multiplicity must be larger than or equal to 1.0\n"); exit(1);} break; case 2: args.binout_file = strdup(optarg); break; case 3: args.inbin_file = strdup(optarg); break; case 4: args.resampling = 0; break; case 'l': args.lambda = atof(optarg); if(args.lambda<=0.0) { fprintf(stderr,"Parameter misspecification: Lambda must be positive number.\n"); exit(1);} break; case 'f': args.FP = atof(optarg); args.autoselect_lambda = 1; if(args.FP<=0.0) {fprintf(stderr,"Expected number of type I error must be postive\n");exit(1);} break; case 'I': insert = strdup(optarg); args.paired = 1; break; case 'q': args.quantile = atof(optarg); if(args.quantile<=0.0 || args.quantile>1.0) { fprintf(stderr,"Quantile should be between 0 and 1.\n"); exit(1);} break; case 'b': args.bin_size = atoi(optarg); if(args.bin_size<1) {fprintf(stderr,"Bin size should be at least 1.\n");exit(1);} break; case 'w': args.win_size = atoi(optarg); if(args.win_size<1) {fprintf(stderr,"The window size must be positive.\n");exit(1);} break; case '2': args.paired = 1; break; case 'o': args.output_file = strdup(optarg); break; case 'R': args.outlier_file = strdup(optarg); case 'p': args.tumor_freq = atof(optarg); if(args.tumor_freq<0.0||args.tumor_freq>=1.0){fprintf(stderr,"The probabilty of a read being a tumor read must be between 0 and 1\n");exit(1);} args.fdr = 1; break; case 'B': args.B = atoi(optarg); if(args.B<=0) {fprintf(stderr,"The option -B must be a positve number\n");exit(1);} break; case 'h': explain_command(argv); exit(0); case '?': /* getopt_long already printed an error message. */ exit(1); break; default: abort (); } } if (argc - optind!=2&&args.inbin_file==NULL){ explain_command(argv); exit(1); } if(args.inbin_file==NULL){ args.tumor_file = strdup(argv[optind]); args.normal_file = strdup(argv[optind+1]); args.in_tmor = fopen(args.tumor_file,"r"); if(args.in_tmor == NULL) { fprintf(stderr,"fopen %s: %s\n", args.tumor_file,strerror(errno)); exit(1); } args.in_nml = fopen(args.normal_file,"r"); if(args.in_nml == NULL) { fprintf(stderr,"fopen %s: %s\n", args.normal_file,strerror(errno)); exit(1); } } else{ args.inbin = fopen(args.inbin_file,"r"); if(args.inbin==NULL){ fprintf(stderr,"fopen %s: %s\n", args.inbin_file,strerror(errno)); exit(1); } } if(args.outlier_file!=NULL) { args.outlier = fopen(args.outlier_file,"w"); if(args.outlier==NULL) {fprintf(stderr,"fopen %s: %s\n",args.outlier_file,strerror(errno));exit(1);} } if(args.output_file!=NULL){ args.output = fopen(args.output_file,"w"); if(args.output==NULL) { fprintf(stderr,"fopen %s: cannot create the file.\n",args.output_file); exit(1);} }else{ args.output = stdout; } if(args.binout_file!=NULL){ args.outbin = fopen(args.binout_file,"w"); if(args.outbin==NULL) { fprintf(stderr,"fopen %s: cannot create the file.\n",args.binout_file); exit(1);} } if(insert!=NULL){ char *substr; substr = strtok(insert,","); args.insert = atoi(substr); substr=strtok(NULL,","); if(substr==NULL){fprintf(stderr,"Incorrect format for option -I\n");exit(1);} args.sd = atoi(substr); if(args.insert<0||args.sd<0) {fprintf(stderr,"Error, insert size and its standard deviaiton must be positive\n");} } set_lambda(args.lambda); return args; }