bitwise_weight_value BitwiseWeight::guided_mutation( bitwise_weight_value elite_value, bitwise_weight_value new_value, RandomNumberGenerator& rng )
{
	int i;
	bitwise_weight_value weight;
	weight.integer = 0;
	int elite = elite_value.integer, newv = new_value.integer;
	bool is_neg;
	if( rng.getRandom() > config->gm_prob_of_mutation )
		is_neg = elite < 0;
	else 
		is_neg = newv < 0;
	if( elite < 0 ) elite *= -1;
	if( newv < 0 ) newv *= -1;
	int num = 0x1;

	for( i = 0; i < number_of_elements - 1; i++ )
	{
		bool gm = rng.getRandom() < config->gm_prob_of_mutation;
		if(		( gm && elite % 2 )
			||  (!gm && newv % 2 ) )
			weight.integer += num;
		num <<= 1;
		elite >>= 1;
		newv >>= 1;
	}
	if( is_neg )
		weight.integer *= -1;
	weight.decimal = get_decimal_value( weight.integer );
	return weight;
}
Beispiel #2
0
void Experiment::run( DataCollector& dc, RandomNumberGenerator& rng )
{
    // INITIALIZE
	double prob_learning_type;  // ELITE or BEST OF GENERATION
	int i;

	for( int run = 0; run < config->number_of_runs; run++ )
	{
        std::cout << "" << (run+1) << ",";
        std::cout.flush();

        dc.start_new_run( run );

		prob_learning_type = 1.;

        dc.run << "Run seed = " << rng.getCurrentSeed() << endline;

        //INITIALIZE THE MODEL
        Model model;
        model.set_data_collector( dc );

        // RUN FOR N GENERATIONS
		for( i = 0; i < config->number_of_generations; i++ )
		{
            //std::cout << (run+1) << "." << i << "," << std::flush;

			// ELITIST LEARNING
			if(     config->structural_learning == PIPE
                &&  prob_learning_type < config->pipe_prob_elitist_learn )
			{
				model.is_elitist_learning = true;
				model.adapt( model.get_elite() );
			}
			else
			{
				// BEST OF LEARNING
				// GENERATION BASED LEARNING
                model.sample( rng );

				if(		config->fitness_test == RETINA_SWITCHING 
					&&	( i % config->retina_switch_after ) == 0 
					&&	i != 0 )
					retina_test_switch();

                // MEASURE FITNESS + INDEX BEST and ELITE
                model.measure_fitness( dc.run );

				// ADAPT PPC TOWARD BEST
                model.adapt( model.get_best() );

			}

            // MUTATE
			model.mutate( rng );

			prob_learning_type = rng.getRandom();

            dc.log_generation( run, i, model );

			dc.flush_debug();
			if(		( model.stop_condition_met() && config->stop_on_target_reached )
                ||	( i + 1 ) == config->number_of_generations )
			{
			    dc.log_run( run, i, model );
				break;
			}

		}



		// RANDOM FITNESS TEST (to confirm findings)
        dc.log_random_fitness( model );
		
	}

    dc.log_experiment();
}