paintatron::paintatron(int population)
{
int i;
sensors = 6 + (sensor_image_inputs*image_itterations);
actuators = initial_actuator + (actuator_image_inputs*image_itterations);
/*sensors = 21, actuators = 25;*/
this->population = population;
run_steps = 1;
rows = 4;
columns = 10;
connections_per_gene = 6;
modules = 0;
chromosomes=1;
min_value = -1000;
max_value = 1000;
elitism = 4.0f / population;
mutation_prob = 0.4f;
use_crossover = 1;
dropout_rate = 0.1f;
random_seed = (unsigned int)time(NULL);
integers_only = 0;
data_size=5;
data_fields=1;
sensor_names = (char**)malloc(sensors*sizeof(char*));
for (i = 0; i < sensors; i++) {
sensor_names[i] = (char*)malloc(32*sizeof(char));
}
actuator_names = (char**)malloc(actuators*sizeof(char*));
for (i = 0; i < actuators; i++) {
actuator_names[i] = (char*)malloc(32*sizeof(char));
}
// create an image used for previews
preview_img_width = 64;
preview_img_height = 64;
preview_img = (unsigned char*)malloc(preview_img_width*preview_img_height*3*sizeof(unsigned char));
no_of_instructions = gprcm_default_instruction_set((int*)instruction_set);
/* create a population */
gprcm_init_system(&sys, 1,
population,
rows, columns,
sensors, actuators,
connections_per_gene,
modules,
chromosomes,
min_value, max_value,
integers_only,
data_size, data_fields,
&random_seed,
instruction_set, no_of_instructions);
}
static void slump_test()
{
int islands = 2;
int migration_interval = 200;
int population_per_island = 512;
int rows = 9, columns = 10;
int i, gen=0;
int connections_per_gene = GPRC_MAX_ADF_MODULE_SENSORS+1;
int modules = 0;
int chromosomes=3;
gprcm_system sys;
float min_value = -100;
float max_value = 100;
float elitism = 0.1f;
float mutation_prob = 0.1f;
int trials = 100;
int use_crossover = 1;
unsigned int random_seed = (unsigned int)time(NULL);
int sensors=4, actuators=3;
int integers_only = 0;
int no_of_test_examples;
float test_performance;
FILE *fp;
char compile_command[256];
int instruction_set[64], no_of_instructions=0;
int data_size=0, data_fields=0;
char * sensor_names[] = {
"Cement",
"Slag",
"Fly Ash",
"Water",
"Sand",
"Coarse Aggr.",
"Fine Aggr."
};
char * actuator_names[] = { "Slump", "Flow", "Compressive Strength" };
/* load the data */
no_of_examples =
load_data("slump_test.data", concrete_data, MAX_EXAMPLES,
&fields_per_example);
/* create a test data set */
no_of_test_examples = create_test_data(concrete_data, &no_of_examples,
fields_per_example,
test_data);
sensors = fields_per_example-4;
trials = no_of_examples;
printf("Number of training examples: %d\n",no_of_examples);
printf("Number of test examples: %d\n",no_of_test_examples);
printf("Number of fields: %d\n",fields_per_example);
/* create an instruction set */
no_of_instructions = gprcm_default_instruction_set(instruction_set);
/* create a population */
gprcm_init_system(&sys, islands,
population_per_island,
rows, columns,
sensors, actuators,
connections_per_gene,
modules,
chromosomes,
min_value, max_value,
integers_only,
data_size, data_fields,
&random_seed,
instruction_set, no_of_instructions);
gpr_xmlrpc_server("server.rb","concreteslump",3573,
"./agent",
sensors, actuators);
test_performance = 0;
while (test_performance < 99) {
/* use the training data */
current_data_set = concrete_data;
/* evaluate each individual */
gprcm_evaluate_system(&sys,
trials,0,
(*evaluate_features));
/* produce the next generation */
gprcm_generation_system(&sys,
migration_interval,
elitism,
mutation_prob,
use_crossover, &random_seed,
instruction_set, no_of_instructions);
/* evaluate the test data set */
current_data_set = test_data;
test_performance = evaluate_features(no_of_test_examples,
&sys.island[0],
0,1);
/* show the best fitness value calculated from the test data set */
printf("Generation %05d Fitness %.2f/%.2f%% ",
gen, gprcm_best_fitness(&sys.island[0]),test_performance);
for (i = 0; i < islands; i++) {
printf(" %.3f",gprcm_average_fitness(&sys.island[i]));
}
printf("\n");
if (((gen % 100 == 0) && (gen>0)) || (test_performance > 99)) {
gprcm_draw_population("population.png",
640, 640, &sys.island[0]);
gprcm_plot_history_system(&sys,
GPR_HISTORY_FITNESS,
"fitness.png",
"Concrete Slump Performance",
640, 480);
gprcm_plot_history_system(&sys,
GPR_HISTORY_AVERAGE,
"fitness_average.png",
"Concrete Slump Average Performance",
640, 480);
gprcm_plot_history_system(&sys,
GPR_HISTORY_DIVERSITY,
"diversity.png",
"Concrete Slump Diversity",
640, 480);
gprcm_plot_fitness(&sys.island[0],
"fitness_histogram.png",
"Fitness Histogram",
640, 480);
fp = fopen("agent.c","w");
if (fp) {
/* save the best program */
gprcm_c_program(&sys,
gprcm_best_individual_system(&sys),
RUN_STEPS, 0, fp);
fclose(fp);
/* compile the program */
sprintf(compile_command,
"gcc -Wall -std=c99 -pedantic -o agent agent.c -lm");
assert(system(compile_command)==0);
}
fp = fopen("fittest.dot","w");
if (fp) {
gprcm_dot(gprcm_best_individual_system(&sys),
&sys.island[0],
sensor_names, actuator_names,
fp);
fclose(fp);
}
}
if (test_performance > 99) break;
gen++;
}
/* free memory */
gprcm_free_system(&sys);
}
