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;
}
