int main(int argc,char*argv[]) { if(argc<2){ LOG("usage: "<<argv[0]<<" data.csv"); return -1; } if(argc==3) print_only_best=true; Concrete::CData cdata(argv[1]); cdata.init(); Concrete::CData bt_cdata=cdata;//.bootstrap(resize_data,0.05); Tree::FunctionDB* fdb=Tree::std_functions_db(); fdb->add_variables(bt_cdata.x_count()); //for(double i=-10.0;i<10.0;i+=0.5) // fdb->add_constant(i); Tree::Generator*gnrt=new Tree::Generator(fdb,max_depth); Tree::Crossover*crossover=new Tree::Crossover; Tree::Mutator mtr(gnrt,crossover); GpGenerator *dg=new GpGenerator(gnrt); //bin_dna_generator *dg=new GpGeneratorHist(fdb,max_depth); selector *sel_r=new rnd_selector; GpMutator *gp_mtn=new GpMutator(gnrt,crossover,fdb); GpCrossover*c=new GpCrossover(fdb,crossover); //std_ga* sg=new hist_gp(sel_r,gp_mtn,c,dg,10); std_ga* sg=new std_ga(sel_r,gp_mtn,c,dg); GpFitness*ftn=new GpFitness(percent_to_learn,&bt_cdata,fdb); sg->set_params(make_params(mtn_raiting,0.4,psize)); sg->setFitness(ftn); sg->init(); solution sln=sg->getSolution(max_steps,target_value,true,print_only_best); LOG("results: "<<sln.first); ftn->check_solution(sln.second,&cdata); }
int main(int argc,char*argv[]) { if(argc<2){ LOG("usage: "<<argv[0]<<" data.csv"); return -1; } if(argc==3) print_only_best=true; Concrete::CData cdata(argv[1]); cdata.init(); Concrete::CData bt_cdata=cdata.bootstrap(resize_data,0.05); // Создаем список случайных индексов для обучения системы ivector numbers=Concrete::make_learn_indexes(cdata.size(),percent_to_learn); // Этап 1 - натройка с помощью ГА LOG("Этап 1"); fitness *sugeno_ftn=new bin_sugeno(&bt_cdata,numbers); bin_crossover *b_crv=new bin_crossover(true); bin_mutator *b_mtn=new bin_mutator(mtn_bit_count); bin_dna_generator *b_dg=new bin_dna_generator(0.0,1.0,sugeno_ftn->size()); LOG("Длина ДНК: "<<sugeno_ftn->size()); selector* sel_r=new rnd_selector; std_ga* sg=new std_ga(sel_r,b_mtn,b_crv,b_dg); sg->set_params(make_params(0.99,0.5,30)); sg->setFitness(sugeno_ftn); sg->init(); solution sln=sg->getSolution(max_steps_ga,10.0,true); // Этап 2 - натройка с помощью ГП LOG("Этап 2"); fuzzy::MinMax minmax=fuzzy::find_min_max(bt_cdata,numbers); fuzzy::MyuFunctions mf_old=fuzzy::make_myu_functions(bt_cdata,numbers,minmax); fuzzy::MyuFunctions mf={fuzzy::fvector(0),mf_old.y_function}; // Построение функций принадлжености const int x_count=bt_cdata.x_count(); int i=0; for(int k=0;k<bt_cdata.size();++k) for(int x=0;x<x_count;++x){ fuzzy::ExpFunction*ff=new fuzzy::ExpFunction(sln.second->get(i),sln.second->get(i+1)); mf.x_funcs.push_back(ff); i+=2; } fuzzy::rule_vector rules=fuzzy::make_rules(bt_cdata,mf,numbers); LOG("Количество функций для X: "<<mf.x_funcs.size()); // Настраиваем базу функций ГП dvector y(rules.size()); for(int i=0;i<rules.size();++i){ y[i]=rules[i].y(); } Tree::FuzzyFDB *fuzzy_fdb=Tree::fuzzy_function_db(y,cdata.x_count()); Tree::FunctionDB* fdb=fuzzy_fdb->fdb; for(int i=0;i<rules.size();++i){ int j=0; for(fuzzy::fvector::const_iterator pos=rules[i].begin(); pos!=rules[i].end();++pos,j++){ std::string func_name="f_"+boost::lexical_cast<std::string>(i); std::string var_name="x-"+boost::lexical_cast<std::string>(j); NewFuzzyFunction ff(*pos); fdb->add_function(new Tree::VarFuncNode(func_name,var_name,1,ff)); } } // sugeno_out+ // количество_if(количество правил) + // количество акцедентов. max_depth=1+rules.size()+cdata.x_count(); Tree::Generator*gnrt=new Tree::RootGenerator(fdb,max_depth,fuzzy_fdb->root_number,fuzzy_fdb->second_layer); ivector limits; limits<<fuzzy_fdb->root_number<<fuzzy_fdb->second_layer; Tree::Crossover*crossover=new Tree::LimitCrossover(limits); Tree::Mutator mtr(gnrt,crossover); GpGenerator *dg=new GpGenerator(gnrt); GpMutator *gp_mtn=new GpMutator(gnrt,crossover,fdb); GpCrossover*c=new GpCrossover(fdb,crossover); std_ga* gp_sg=new std_ga(sel_r,gp_mtn,c,dg); GpFitness*gp_ftn=new GpFitness(percent_to_learn,&bt_cdata,fdb); gp_ftn->set_numbers(numbers); gp_sg->set_params(make_params(mtn_raiting,0.4,psize)); gp_sg->setFitness(gp_ftn); gp_sg->init(); solution gp_sln=sg->getSolution(max_steps,target_value,true,print_only_best); LOG("results: "<<gp_sln.first); gp_ftn->check_solution(gp_sln.second,&cdata); }
int parse_cmd(char* cmd, run_params* par, run_params* parent_par, int wait) { //printf("*** %s ***\n", cmd); int pos, i; int return_val = 0; char* cmd_itself = (char*)malloc(sizeof(char) * MAX_CMD_LEN); char* input = (char*)malloc(sizeof(char) * MAX_PATH_LEN); char* output = (char*)malloc(sizeof(char) * MAX_PATH_LEN); char* err_output = (char*)malloc(sizeof(char) * MAX_PATH_LEN); int out_append = 0; for (i = 0; i < MAX_PATH_LEN; i++) { input[i] = '\0'; output[i] = '\0'; err_output[i] = '\0'; } char** args = (char**)malloc(sizeof(char*) * MAX_ARGC); char* arg = (char*)malloc(sizeof(char) * MAX_PARAM_LEN); int argc = 0; pos = 0; int ret; ret = fill_string(cmd, &pos, cmd_itself); if (ret != 0) { return_val = 0; // empty command goto end; } while (1) { ret = fill_string(cmd, &pos, arg); if (ret != 0) break; ret = parse_redirects(cmd, &pos, arg, input, output, err_output, &out_append); if (ret == 0) { continue; } else if (ret == 1) { break; } else { if (argc >= MAX_ARGC) { return_val = 2; goto end; } args[argc] = arg; argc++; arg = (char*)malloc(sizeof(char) * MAX_PARAM_LEN); } } run_params* nParams = make_params(par, input, output, err_output, out_append, args, argc, cmd_itself); if (nParams == NULL) return 3; if (strcmp(cmd_itself, "exit") == 0) { if (par->secret_params == 2) { return 1; } if (par->secret_params == 1) { par->in->autoclose = 1; par->err->autoclose = 1; par->out->autoclose = 1; c_run((LPTHREAD_START_ROUTINE)(c_exit), nParams, wait); } } else if (strcmp(cmd_itself, "dir") == 0) { c_run((LPTHREAD_START_ROUTINE)(dir), nParams, wait); } else if (strcmp(cmd_itself, "echo") == 0) { c_run((LPTHREAD_START_ROUTINE)(echo), nParams, wait); } else if (strcmp(cmd_itself, "scan") == 0) { c_run((LPTHREAD_START_ROUTINE)(scan), nParams, wait); } else if (strcmp(cmd_itself, "rand") == 0) { c_run((LPTHREAD_START_ROUTINE)(random), nParams, wait); } else if (strcmp(cmd_itself, "cd") == 0) { cd(nParams, parent_par); } else if (strcmp(cmd_itself, "tree") == 0) { c_run((LPTHREAD_START_ROUTINE)(tree), nParams, wait); } else if (strcmp(cmd_itself, "pipe") == 0) { c_run((LPTHREAD_START_ROUTINE)(c_pipe), nParams, wait); } else if (strcmp(cmd_itself, "type") == 0) { c_run((LPTHREAD_START_ROUTINE)(type), nParams, wait); } else if (strcmp(cmd_itself, "info") == 0) { c_run((LPTHREAD_START_ROUTINE)(info), nParams, wait); } else if (strcmp(cmd_itself, "rm") == 0 || strcmp(cmd_itself, "rd") == 0) { c_run((LPTHREAD_START_ROUTINE)(rm), nParams, wait); } else if (strcmp(cmd_itself, "sort") == 0) { c_run((LPTHREAD_START_ROUTINE)(sort), nParams, wait); } else if (strcmp(cmd_itself, "mkdir") == 0 || strcmp(cmd_itself, "md") == 0) { c_run((LPTHREAD_START_ROUTINE)(mkdir), nParams, wait); } else if (strcmp(cmd_itself, "freq") == 0) { c_run((LPTHREAD_START_ROUTINE)(freq), nParams, wait); } else if (strcmp(cmd_itself, "wc") == 0) { c_run((LPTHREAD_START_ROUTINE)(wc), nParams, wait); } else if (strcmp(cmd_itself, "cmd") == 0) { nParams->secret_params = 2; c_run((LPTHREAD_START_ROUTINE)(c_cmd_run), nParams, wait); } else { c_run((LPTHREAD_START_ROUTINE)(c_non_existent), nParams, wait); } end: return return_val; }
static quik_err_t get_params(char **kernel, char **initrd, char **params, env_dev_t *cur_dev) { char *p; char *q; int n; char *buf; char *endp; key_t lastkey; char *label = NULL; int timeout = DEFAULT_TIMEOUT; if ((bi->flags & TRIED_AUTO) == 0) { bi->flags ^= TRIED_AUTO; *params = bi->bootargs; *kernel = *params; word_split(kernel, params); if (!*kernel) { *kernel = cfg_get_default(); /* * Timeout only makes sense * if we don't have an image name already * passed. */ if ((bi->flags & CONFIG_VALID) && (q = cfg_get_strg(0, "timeout")) != 0 && *q != 0) { timeout = strtol(q, NULL, 0); } } else { /* * We have something, boot immediately. */ timeout = 0; } } printk(PROMPT); lastkey = KEY_NONE; if (timeout != -1) { lastkey = wait_for_key(timeout, '\n'); } if (lastkey == '\n') { printk("%s", *kernel); if (*params) { printk(" %s", *params); } printk("\n"); } else { *kernel = NULL; buf = cmd_edit(maintabfunc, lastkey); if (buf == NULL) { return ERR_NOT_READY; } *kernel = buf; word_split(kernel, params); } if (bi->flags & CONFIG_VALID) { *initrd = cfg_get_strg(0, "initrd"); p = cfg_get_strg(*kernel, "image"); if (p && *p) { label = *kernel; *kernel = p; p = cfg_get_strg(label, "device"); if (p) { cur_dev->device = p; } p = cfg_get_strg(label, "partition"); if (p) { n = strtol(p, &endp, 10); if (endp != p && *endp == 0) { env_dev_set_part(cur_dev, n); } } p = cfg_get_strg(label, "initrd"); if (p) { *initrd = p; } if (cfg_get_strg(label, "old-kernel")) { bi->flags |= BOOT_PRE_2_4; } else { bi->flags &= ~BOOT_PRE_2_4; } *params = make_params(label, *params); if (*params == NULL) { return ERR_NO_MEM; } } } if (*kernel == NULL) { printk("<TAB> for list of bootable images, or !help\n"); return ERR_NOT_READY; } /* * If we manually entered kernel path, the initrd could * be following in the param list... */ if (label == NULL) { *params = chomp(*params); if (memcmp(*params, "-- ", 3) != 0) { *initrd = *params; word_split(initrd, params); } else { /* * No initrd, just kernel args. */ *params = *params + 3; } } return ERR_NONE; }