コード例 #1
0
ファイル: FuzzerMutate.cpp プロジェクト: cms-externals/llvm
size_t MutationDispatcher::Mutate_CrossOver(uint8_t *Data, size_t Size,
                                            size_t MaxSize) {
  if (Size > MaxSize) return 0;
  if (!Corpus || Corpus->size() < 2 || Size == 0) return 0;
  size_t Idx = Rand(Corpus->size());
  const Unit &O = (*Corpus)[Idx];
  if (O.empty()) return 0;
  MutateInPlaceHere.resize(MaxSize);
  auto &U = MutateInPlaceHere;
  size_t NewSize = 0;
  switch(Rand(3)) {
    case 0:
      NewSize = CrossOver(Data, Size, O.data(), O.size(), U.data(), U.size());
      break;
    case 1:
      NewSize = InsertPartOf(O.data(), O.size(), U.data(), U.size(), MaxSize);
      if (NewSize)
        break;
      // LLVM_FALLTHROUGH;
    case 2:
      NewSize = CopyPartOf(O.data(), O.size(), U.data(), U.size());
      break;
    default: assert(0);
  }
  assert(NewSize > 0 && "CrossOver returned empty unit");
  assert(NewSize <= MaxSize && "CrossOver returned overisized unit");
  memcpy(Data, U.data(), NewSize);
  return NewSize;
}
コード例 #2
0
void MainWindow::EvolutionaryLoop()
{
    m_GenerationNumber++;

    for(int i = 0; i < ui->sbChildren->value(); i++)
    {
        float r = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);

        //80 percent of the time we do a crossover.
        if (r < 0.8)
        {
            int father_index = rand() % population.size();
            int mother_index = rand() % population.size();
            CrossOver(population.at(father_index), population.at(mother_index));
            ComputeFitness(population.back());
        }
        // we clone the rest of the time (10%)
        else
        {
            int clone_index = rand() % population.size();
            population.push_back(population.at(clone_index));
        }

        Mutation(population.at(i));
    }

    MakeFights();

    fs = GetPhenotypeStatsInAGeneration();
    int best_index = fs.bestFitnessIndex;

    if (population.at(best_index)->GetFitness() <= ui->dsbFitnessThreshold->value()
            && population.at(best_index)->IsValid() == true)
    {
        timer->stop();
        statusLabel->setText(QString("Found best phenotype (number %2) at generation %0 with a fitness of %1")
                             .arg(fs.noOfGeneration)
                             .arg(population.at(best_index)->GetFitness())
                             .arg(best_index));
        //statusProgressBar->setValue(statusProgressBar->maximum());
    }

    //population.at(best_index)->Mutate();
    ComputeFitness(population.at(best_index));
    int row = AddRow(population.at(best_index));
    bool green = population.at(best_index)->IsValid();
    SetRowColor(row, green);
    PopulatePlot(ui->tableWidget, fs);
    ShowPhenotype(population.at(best_index));

    ui->lGeneration->setText(QString("Generation %0").arg(m_GenerationNumber));
}
コード例 #3
0
ファイル: FuzzerMutate.cpp プロジェクト: AnachroNia/llvm
size_t MutationDispatcher::Mutate_CrossOver(uint8_t *Data, size_t Size,
                                            size_t MaxSize) {
  if (!Corpus || Corpus->size() < 2 || Size == 0) return 0;
  size_t Idx = Rand(Corpus->size());
  const Unit &Other = (*Corpus)[Idx];
  if (Other.empty()) return 0;
  MutateInPlaceHere.resize(MaxSize);
  auto &U = MutateInPlaceHere;
  size_t NewSize =
      CrossOver(Data, Size, Other.data(), Other.size(), U.data(), U.size());
  assert(NewSize > 0 && "CrossOver returned empty unit");
  assert(NewSize <= MaxSize && "CrossOver returned overisized unit");
  memcpy(Data, U.data(), NewSize);
  return NewSize;
}
コード例 #4
0
int main(){
	
	int poblacion[N][M];
    double Fitness[10];
	int Nueva_Poblacion [10][M];
	double SumatoriaFObj;
	unsigned long int valor_Cromosomas_Elegidos[10];
	int cromosomas_Elegidos[10]; //cromosomas elegidos inicialmente 
	
	srand(time(0));

	for(int i=0; i<N ; i++)
	{
		for(int j=0; j<M ; j++)
			 poblacion[i][j] = rand()%2;
	}
	
	for(int k=0;k<10;k++)
		cromosomas_Elegidos[k]=-1;

	for(int j=0; j<10 ; j++)
	{
		int m=(rand()%M);
		while(Ya_esta(m,cromosomas_Elegidos)==false)
			m = (rand()%M);
		cromosomas_Elegidos[j]=m;
	}
	for(int k=0;k<10;k++){
		for(int j=0;j<M;j++){
			Nueva_Poblacion[k][j] = poblacion[cromosomas_Elegidos[k]][j] ;}
	}
	for(int i=0;i<20;i++){
		printf("\nEJECUCION NUMERO %d \n\n", i);
		A_Valor_Decimal(valor_Cromosomas_Elegidos,Nueva_Poblacion);
		SumatoriaFObj = Sumatoria_Funcion_Objetivo(valor_Cromosomas_Elegidos);
		Funcion_Fitness(valor_Cromosomas_Elegidos,SumatoriaFObj,Fitness);
		Mostrar_Lista(valor_Cromosomas_Elegidos,Nueva_Poblacion,SumatoriaFObj,Fitness);
		CrossOver(Fitness,cromosomas_Elegidos,Nueva_Poblacion);
		system("PAUSE");
		system("CLS");
	}		
	system("PAUSE");
	
	return 0;
}
コード例 #5
0
ファイル: FuzzerLoop.cpp プロジェクト: stevedrake/llvm
void Fuzzer::Loop(size_t NumIterations) {
  for (size_t i = 1; i <= NumIterations; i++) {
    for (size_t J1 = 0; J1 < Corpus.size(); J1++) {
      RereadOutputCorpus();
      if (TotalNumberOfRuns >= Options.MaxNumberOfRuns)
        return;
      // First, simply mutate the unit w/o doing crosses.
      CurrentUnit = Corpus[J1];
      MutateAndTestOne(&CurrentUnit);
      // Now, cross with others.
      if (Options.DoCrossOver) {
        for (size_t J2 = 0; J2 < Corpus.size(); J2++) {
          CurrentUnit.clear();
          CrossOver(Corpus[J1], Corpus[J2], &CurrentUnit, Options.MaxLen);
          MutateAndTestOne(&CurrentUnit);
        }
      }
    }
  }
}
コード例 #6
0
ファイル: FuzzerLoop.cpp プロジェクト: A2-Collaboration/root
size_t Fuzzer::Loop(size_t NumIterations) {
  size_t NewUnits = 0;
  for (size_t i = 1; i <= NumIterations; i++) {
    if (Options.DoCrossOver) {
      for (size_t J1 = 0; J1 < Corpus.size(); J1++) {
        for (size_t J2 = 0; J2 < Corpus.size(); J2++) {
          CurrentUnit.clear();
          CrossOver(Corpus[J1], Corpus[J2], &CurrentUnit, Options.MaxLen);
          NewUnits += MutateAndTestOne(&CurrentUnit);
        }
      }
    } else {  // No CrossOver
      for (size_t J = 0; J < Corpus.size(); J++) {
        CurrentUnit = Corpus[J];
        NewUnits += MutateAndTestOne(&CurrentUnit);
      }
    }
  }
  return NewUnits;
}
コード例 #7
0
ファイル: GeneticAlg.cpp プロジェクト: mrG7/GeneticNeuralNet
TArray<FGenome> GeneticAlg::Epoch(TArray<FGenome> &OldPop)
{
	PopArray = OldPop;
	Reset();
	PopArray.Sort(); //sorts Fgenomes by fitness
	CalculateBestWorstAvTot();
	TArray<FGenome> NewPop;
	if (!(NumCopiesElite * NumElites % 2))
	{
		GrabNBest(NumElites, NumCopiesElite, NewPop);
	}
	while (NewPop.Num() < PopulationSize)
	{
		//grab two chromosones
		FGenome mum = GetChromoRoulette();
		FGenome dad = GetChromoRoulette();

		//create some offspring via crossover
		TArray<float>		baby1, baby2;

		CrossOver(mum.WeightsArray, dad.WeightsArray, baby1, baby2);

		//now we mutate
		Mutate(baby1);
		Mutate(baby2);

		//now copy into vecNewPop population
		NewPop.Add(FGenome(baby1, 0));
		NewPop.Add(FGenome(baby2, 0));
	}

	//finished so assign new pop back into m_vecPop
	PopArray = NewPop;

	return PopArray;
	
}
コード例 #8
0
int main() {
  // Declare GA parameters - pop. size, variables, etc
  const int populationSize = 30;
  const int numberOfGenerations = 100;
  const int tournamentSize = 2;
  const double tournamentSelectionParameter = 0.75;
  const float crossOverProbability = 0.7;
  const float creepRateMutation = 0.1;
  const double mutationProbability = 0.05;

  // Vehicle related parameters for chromosome construction
  int numberOfUnits = 4; 			// Including Tractor
  std::vector<int> numberOfAxlesOnEachUnit{3,3,2,3};   // Can be made inputs later
  int numberOfEngines = 3;			// D11, D13, D16
  int numberOfElectricMotors = 3;
  int numberOfElectricBuffers = 3;

  std::vector<int> machineParameters{numberOfEngines, numberOfElectricMotors, numberOfElectricBuffers};
  std::vector<std::vector<int>> vehicleConfigurationParameters{machineParameters, numberOfAxlesOnEachUnit};

  // Initialise the population
  Population population = InitialisePopulation(populationSize, vehicleConfigurationParameters);
  // Check if population is correctly initialised
  std::cout<<"Population initialised"<<std::endl;
  PrintMembersOfPopulation(population);

  // Create files for storing population of each generation & fitnesses of each individual in each generation
  std::fstream populationEachGeneration;
  std::fstream fitnessEachGeneration;   

  //Delete any existing instances of the files to be created
  remove("PopulationEachGeneration.txt");
  remove("FitnessEachGeneration.txt");

  std::vector<double> bestFitnessOverGenerations;

  std::vector<std::vector<double>> missionData;
  LoadMission(missionData);

  // Loop begins - generation evolution start
  for(int generationIndex=0;generationIndex<numberOfGenerations;generationIndex++) {
    std::cout<<"GENERATION NUMBER : "<<generationIndex<<std::endl;
    // Store current population in file PopulationEachGeneration.txt
    //StoreCurrentPopulationInFile(population, populationEachGeneration, rangeAllVariables);

    // Declare variables required for fitness evaluation
    Fitnesses fitness;	// Keep inside scope of each generation
    double tempFitness;     // Keep inside scope of each generation

    // Evaluate the fitness of each member in the population and assign to 'fitness' vector
    fitness = EvaluatePopulationFitness(population, missionData);
    StoreCurrentFitnessInPopulation(fitness, fitnessEachGeneration);

    // Declare variables required for best individual search
    long double maximumFitness;
    int bestIndividualIndex;
    Individual bestIndividual;       

    // Find best individual in the current population
    bestIndividualIndex = GetBestIndividualIndex(fitness); //, population, rangeAllVariables); 
    bestIndividual = population[bestIndividualIndex];
    maximumFitness = fitness[bestIndividualIndex];
    bestFitnessOverGenerations.push_back(maximumFitness);

    //PrintFitness(fitness);
    //std::cout<<"The best Individual is "<<bestIndividualIndex<<std::endl;
    std::cout<<"The optimal function value is "<<maximumFitness<<std::endl;

    // Based on fitness, perform selection & crossover without replacement
    Population tempPopulation;
    tempPopulation = population;

    for(int i=0;i<populationSize;i=i+2) { // i=i+2 since 2 individuals are crossed over
      // Select two random individuals using tournament selection
      std::vector<Individual> individualsToCrossover;  // Both individuals to be crossed over placed in a vector
      for(int j=0;j<tournamentSize;j++) {
        int temporaryIndex=TournamentSelection(fitness, tournamentSelectionParameter, tournamentSize);
        //std::cout<<"Chosen Individual :"<<temporaryIndex<<std::endl;
        individualsToCrossover.push_back(population[temporaryIndex]);
      } // end of Tournament Selection

      // Perform crossover
      // ALGORITHM ONE - INDIVIDUAL UNIT GENE CONSIDERATION FOR CROSSOVER
      std::vector<Individual> crossedOverIndividuals = CrossOver(individualsToCrossover, crossOverProbability);
      tempPopulation[i]=crossedOverIndividuals[0];
      tempPopulation[i+1]=crossedOverIndividuals[1];
	   
      // ALGORITHM TWO - CROSSOVER AT UNIT GENE BOUNDARIES FOR WHOLE INDIVIDUALS
      /*double randomDouble = GetRandomDouble();
      if(randomDouble < crossOverProbability) {
        //std::cout<<"CrossOver Initiated"<<std::endl;
        std::vector<Individual> crossedOverIndividuals = CrossOver(individualsToCrossover);
        tempPopulation[i]=crossedOverIndividuals[0];
        tempPopulation[i+1]=crossedOverIndividuals[1];
      } 
      else {
        // Place original pair of individuals in corresponding (consecutive) locations in tempPopulation
        //std::cout<<"No Crossover"<<std::endl;	
        tempPopulation[i]=individualsToCrossover[0];
        tempPopulation[i+1]=individualsToCrossover[1];
      }  // end of Crossover*/
    } // End of Selection and Crossover

    //std::cout<<std::endl<<"After Crossover"<<std::endl;
    //PrintMembersOfPopulation(tempPopulation);

    // Mutate each individual
    MutatePopulation(tempPopulation, mutationProbability); // Population mutated

    //std::cout<<std::endl<<"After Mutation"<<std::endl;
    //PrintMembersOfPopulation(tempPopulation);

    // Elitism
    tempPopulation[0]=population[bestIndividualIndex];

    for(int i=0;i<tempPopulation.size();i++)
      population[i]=tempPopulation[i];
  } // end of generation loop


  // Declare variables required for final fitness evaluation
  Fitnesses finalFitness;      // Keep inside scope of each generation
  double tempFitness;     // Keep inside scope of each generation

  // Evaluate the fitness of each member in the population and assign to 'fitness' vector
  finalFitness = EvaluatePopulationFitness(population, missionData);
  //PrintFitness(finalFitness);

  // Declare variables required for best individual search
  long double finalMaximumFitness;
  int finalBestIndividualIndex;
  Individual finalBestIndividual;

  // Find best individual in the current population
  finalBestIndividualIndex = GetBestIndividualIndex(finalFitness); //, population, rangeAllVariables); 
  finalBestIndividual = population[finalBestIndividualIndex];
  finalMaximumFitness = finalFitness[finalBestIndividualIndex];

  PrintMembersOfPopulation(population);
  // Check if the best individual is being correctly calculated
  std::cout<<"The best Individual is "<<finalBestIndividualIndex<<std::endl;
  PrintIndividual(population[finalBestIndividualIndex]);
  std::cout<<"The optimal function value is "<<finalMaximumFitness<<std::endl;
  //std::cout<<std::endl;

  std::ofstream fileOperation;
  remove("fitness_vs_generation.txt");
  fileOperation.open("fitness_vs_generation.txt");
  if (fileOperation.is_open()) {
    for(int i=0;i<bestFitnessOverGenerations.size();i++) {
      fileOperation << bestFitnessOverGenerations[i] << '\n';
    }
    fileOperation.close();
  }
}// end of main()