Prześlij pliki do 'images'

Main.cpp

@@ -1,4 +1,4 @@
-#include<iostream>
+#include<iostream>
 #include<stdlib.h>
 #include<windows.h>
 #include<conio.h>
@@ -8,9 +8,22 @@
 #include<math.h>
 #include<stack>
 
+#include <stdio.h>
+#include <cstdlib> 
+#include <ctime>
+#include<bits/stdc++.h>
+#include <algorithm>
+#include <utility>
+
 using namespace std;
 
-const float maxFloat=FLT_MAX;
+int score = 0; 
+int rozmiarPopulacji = 50;
+string * zebrane = new string[rozmiarPopulacji];
+string * doSadzenia = new string[20];
+int gmoLeft;
+
+const float maxFloat=100000000000;
 const int ROW = 27;
 const int COL = 27;
 typedef pair<int, int> Pair;
@@ -25,6 +38,286 @@ char pole[27][27][2];
 int pozycjaTraktoraX = 1, pozycjaTraktoraY = 1;
 char currentWay = 'S';
 
+string kod_genetyczny[27][27];
+
+
+//algorytm genetyczny
+string generateValue() {
+	
+	char trash[100];
+	string x = itoa(rand() % 1000,trash,10);
+	if (x.size() == 2) {
+		x = "0" + x;
+	}
+	else if (x.size() == 1) {
+		x = "00" + x;
+	}
+	
+	return x;
+	
+}
+
+
+string generateVegetable() {
+	
+	string taste = generateValue(); 
+	string colour = generateValue();
+	string size = generateValue();
+	
+	return taste + colour + size;
+	
+}
+
+
+void generatePopulation(string * population,int length) {
+	
+	int i;
+	for(i=0;i<length;i++) {
+		population[i] = generateVegetable();
+	}
+}
+
+
+int power(int x, int y) {
+	
+  if (y == 0) return 1;
+  if (y == 1) return x;
+  
+  int temp = power(x, y/2);
+  if (y%2 == 0) return temp * temp;
+  else return x * temp * temp;
+}
+
+
+int stringToInt(string str,int size) {
+	
+	int x = 0;
+	int i;
+	reverse(str.begin(),str.end());
+	
+	for(i=0;i<size;i++) {
+		x += (str[i] - '0') * power(10,i);
+	}
+	
+	reverse(str.begin(),str.end());
+	
+	return x;	
+}
+
+
+int fitness(string vegetable) {
+	
+	int taste = stringToInt(vegetable.substr(0,3),3);
+	int colour = stringToInt(vegetable.substr(3,3),3);
+	int size = stringToInt(vegetable.substr(6,3),3);
+	
+	return (taste+colour+size)/3;
+}
+
+
+bool comparePair(const pair<int, string>&i, const pair<int, string>&j)
+{
+   	return i.first > j.first;
+}
+
+    
+void ranking(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	for(i=0;i<parentsNumber;i++) {
+		parents[i] = fitnessTable[i].second;
+	}	
+}
+
+
+bool exists(int len, int * array, int element) {
+	
+	int i;
+	for(i=0;i<len;i++) {
+		if (array[i] == element) return true;
+	}
+	return false;
+}
+
+
+void selection(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i,j,k;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	int roulette;
+	int taken[parentsNumber];
+	int sum = 0;
+	for(i=0;i<parentsNumber;i++) {
+		for(j = populationSize - 1;j>=0;j--) {
+			if(not exists(parentsNumber,taken,j)) {
+				sum += 	fitnessTable[j].first;
+				fitnessTable[j].first = sum;
+			}
+			
+		}
+		roulette = rand() % fitnessTable[0].first;
+		j = 0;
+		while(exists(parentsNumber,taken,j)) {
+			j += 1;
+		}
+		while(roulette > fitnessTable[j].first and j<populationSize) {
+			if(not exists(parentsNumber,taken,j)) {
+				roulette -= fitnessTable[j].first;
+			}
+			j+=1;
+		}
+		parents[i] = fitnessTable[j].second;
+		taken[i] = j;
+	}
+	
+	
+		
+}
+
+
+int newton(int n,int k) {
+	
+	if (k==0 or n==k) return 1;
+	else return newton(n-1,k-1) + newton(n-1,k);
+}
+
+
+string mutate(string child) {
+	
+	int d3 = rand() % 3;
+	string mutation = generateValue();
+	switch(d3) {
+		case 0:
+			child = mutation + child.substr(3,6);
+			break;
+		case 1:
+			child = child.substr(0,3) + mutation + child.substr(6,3);
+			break;
+		case 2:
+			child = child.substr(0,6) + mutation;
+			break;
+	}
+	
+	return child;
+}
+
+
+string cross(string parent[2]) {
+	
+	int i;
+	string child = "";
+	for(i=0;i<3;i++) {
+		child += parent[rand() % 2].substr(i*3,3);
+	}
+	if (child == parent[0] or child == parent[1]) {
+		string other;
+		if (child == parent[0]) other = parent[1];
+		else other = parent[0];
+		int d3 = rand() % 3;
+		switch(d3) {
+			case 0:
+				child = other.substr((rand() % 3)*3,3) + child.substr(3,6);
+				break;
+			case 1:
+				child = child.substr(0,3) + other.substr((rand() % 3)*3,3) + child.substr(6,3);
+				break;
+			case 2:
+				child = child.substr(0,6) + other.substr((rand() % 3)*3,3);
+				break;
+		}
+	}
+	int d1000 = rand() % 1000;
+	if (rand() % 100 == 0) {
+		child = mutate(child);
+	}
+	return child;
+}
+
+
+void crossover(string * parents,string * nextGen,int parentsNumber,int nextGenSize) {
+	
+	int counter = 0;
+	int i,j;
+	for(i=0;i<parentsNumber;i++) {
+		if (counter >= nextGenSize) {
+			break;
+		}
+		else {
+			nextGen[counter] = parents[i];
+		counter +=1;
+		}
+	}
+	while(counter < nextGenSize) {
+		for(i=0;i<parentsNumber;i++) {
+			if (counter >= nextGenSize) {
+				break;
+			}
+			else {
+				for(j=i;j<parentsNumber;j++) {
+					if (counter >= nextGenSize) {
+					break;
+					}
+					else {
+						string couple[2];
+						couple[0] = parents[i];
+						couple[1] = parents[j];
+						nextGen[counter] = cross(couple);
+						counter += 1;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+void genetic_algorithm(string * population, int populationSize, int parentsNumber,string * outcome, int outcomeSize) {
+	
+	int iteration,i;
+	for(iteration=0;iteration<5;iteration++) {
+		string * parents = new string[parentsNumber];
+		selection(population,parents,populationSize,parentsNumber);
+		
+		string * nextGen = new string[populationSize];
+		crossover(parents,nextGen,parentsNumber,populationSize);
+		
+		delete[] population;
+		
+		population = new string[populationSize];
+		for(i=0;i<populationSize;i++) {
+			population[i] = nextGen[i];
+		}
+		delete[] nextGen;
+	}
+	ranking(population,outcome,populationSize,outcomeSize);
+}
+
+
+string przypiszKod() {
+	if (gmoLeft > 0) {
+		string temp = doSadzenia[gmoLeft - 1];
+		gmoLeft -= 1; 
+		return temp;
+	}
+	else {
+		return generateVegetable();
+	}
+}
+//---------------------------------------------------------------------
+
 void color(string foregroundColor, string backgroundColor)
 {
 	HANDLE hOut;
@@ -196,25 +489,50 @@ void Move(char kierunek)
 {	
 	switch (kierunek)
 	{
-		//góra-(w)
+		//gA3ra-(w)
 		case 'w':
 		{
 			if (pole[pozycjaTraktoraY - 1][pozycjaTraktoraX][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY - 1][pozycjaTraktoraX][0] == 'B') {
+					zebrane[score] = kod_genetyczny[pozycjaTraktoraY - 1][pozycjaTraktoraX];
+					score+=1;
+					kod_genetyczny[pozycjaTraktoraY - 1][pozycjaTraktoraX] = "000000000";
+					
 					correctMovement('N');
 					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
+					}
+					
+				else {
+					correctMovement('N');
+					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'B';
+					kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX] = przypiszKod();
+				}
+					
 				pozycjaTraktoraY--;
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'T';
 			}
 			updatePola();
 		}break;
-		//dół-(s)
+		//dA3A‚-(s)
 		case 's':
 		{
 			if (pole[pozycjaTraktoraY + 1][pozycjaTraktoraX][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY +1][pozycjaTraktoraX][0] == 'B') {
+					zebrane[score] = kod_genetyczny[pozycjaTraktoraY + 1][pozycjaTraktoraX];
+					score+=1;
+					kod_genetyczny[pozycjaTraktoraY + 1][pozycjaTraktoraX] = "000000000";
 					correctMovement('S');
 					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
+					}
+					
+				else {
+					correctMovement('S');
+					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'B';
+					kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX] = przypiszKod();
+				}
+					
 				pozycjaTraktoraY++;
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'T';
 			}
@@ -225,8 +543,20 @@ void Move(char kierunek)
 		{
 			if (pole[pozycjaTraktoraY][pozycjaTraktoraX - 1][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY][pozycjaTraktoraX - 1][0] == 'B') {
+					zebrane[score] = kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX - 1];
+					score+=1;
+					kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX - 1] = "000000000";
 						correctMovement('W');
 					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
+					}
+					
+				else {
+					correctMovement('W');
+					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'B';
+					kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX] = przypiszKod();
+				}
+					
 				pozycjaTraktoraX--;
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'T';
 			}
@@ -237,8 +567,20 @@ void Move(char kierunek)
 		{
 			if (pole[pozycjaTraktoraY][pozycjaTraktoraX + 1][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY][pozycjaTraktoraX + 1][0] == 'B') {
+					zebrane[score] = kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX + 1];
+					score+=1;
+					kod_genetyczny[pozycjaTraktoraY ][pozycjaTraktoraX + 1] = "000000000";
 						correctMovement('E');
 					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
+					}
+					
+				else {
+					correctMovement('E');
+					pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'B';
+					kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX] = przypiszKod();
+				}
+					
 				pozycjaTraktoraX++;
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'T';
 			}
@@ -299,7 +641,7 @@ void tracePath(cell cellDetails[][COL], Pair dest)
 		if (p.second < pozycjaTraktoraY)
 			Move('w');
 		
-		//printf("-> (%d,%d) ", p.first, p.second);  //---- informacja wierzchołku
+		//printf("-> (%d,%d) ", p.first, p.second);  //---- informacja wierzchoA‚ku
 		Sleep(1000);
 	}
 
@@ -516,6 +858,14 @@ void test2()
 	}
 	test1();
 	updatePola();
+	//generowanie kodów dla buraków
+	for(int i=0;i<27;i++) {
+		for(int j=0;j<27;j++) {
+			if (pole[i][j][0] == 'B') {
+				kod_genetyczny[i][j] = przypiszKod(); 
+				}
+		}
+	}
 }
 
 void start1()
@@ -549,8 +899,13 @@ void start3()
 	gogo(goalX, goalY);
 }
 
+
+
+
 int main()
 {	
+	srand(time(0));
+	
 	SetWindow(50, 30);
 	//create pola//
 	for (int i = 0; i < 27; i++)
@@ -581,6 +936,8 @@ int main()
 
 	updatePola();
 	
+	//UWAGA - generowanie kodow dla burakow jest w test2!
+
 	start3();  // testy start 1-3
 
 	//---------start---------//
@@ -599,6 +956,23 @@ int main()
 		{
 			traktorDziala = false;
 		}
+		
+		cout << "Zebrane buraki: " << score << endl;
+		if(score>=rozmiarPopulacji) {
+			score = 0;
+			delete[] doSadzenia;
+			string * doSadzenia = new string[20];
+			for(int i = 0;i<20;i++) {
+				doSadzenia[i] = "000000000";
+			}
+			genetic_algorithm(zebrane, rozmiarPopulacji, rozmiarPopulacji - 5, doSadzenia, 20);
+			gmoLeft = 20;
+			delete[] zebrane;
+			string * zebrane = new string[rozmiarPopulacji];
+			for(int i=0;i<20;i++) {
+				cout << doSadzenia[i] << endl;
+			}
+		 }		
 	} while (traktorDziala);
 	//---------end---------//
 

algorytm_genetyczny.md

@@ -0,0 +1,47 @@
+# Opis dokumentu  
+Ten dokument to raport z wykonanego podprojektu na przedmiot Sztuczna Inteligencja. Celem
+zadania jest implementacja algorytmu genetycznego w projekcie o tematyce inteligentny traktor.
+
+# Zastosowanie algorytmu
+Algorytm został wykorzystany do wygenerowania zbioru roślin do zasadzenia na bazie zebranych wcześniej roślin
+
+# Skrócony opis implementacji w projekcie wspólnym
+* Na początku dla każdego pola zawierającego buraki, zostanie wygenerowany kod genetyczny roślin z tego pola.
+
+![](images/test2_generowanie_burakow.png)
+
+* Funkcja Move teraz zajmuje się również zbieraniem i wywoływaniem sadzenia roślin
+
+![](images/move_zbieranie.png)
+
+* Funkcja przypiszKod decyduje czy należy zasadzić jedną z modyfikowanych genetycznie roślin, czy należy zasadzić nową (losową).
+
+![](images/przypiszKod.png)
+
+* Gdy liczba zebranych buraków osiągnie określoną wartość, zostanie przeprowadzony algorytm genetyczny i powstanie tablica roślin do zasadzenia
+
+![](images/wykonanie_algorytmu_gen.png)
+
+# Opis algorytmu genetycznego
+* Algorytm wykonuje 5 iteracji, w których dokonuje selekcji osobników populacji, które zostaną poddane rozrodowi i wytwarza kolejne pokolenie populacji. Po wyjściu z pętli metodą rankingu selekcjonuje najlepszą część ostatniego pokolenia.
+
+![](images/genetic_algorithm.png)
+
+* Selekcja odbywa się metodą ruletki. Obliczana jest wartość funkcji dostosowania dla każdego osobnika. Im lepsza wartość, tym większa szansa na wylosowanie.
+
+![](images/selection.png)
+
+* Funkcja dostosowania polega na wyliczeniu średniej arytmetycznej trzech wartości: smaku, rozmiaru i koloru rośliny, które są zakodowane w łańcuchu znaków.
+
+![](images/fitness.png)
+
+* Funkcja crossover zajmuje się wywołaniem krzyżowania odpowiedniej liczby osobników
+
+![](images/crossover.png)
+
+* Zastosowana została metoda krzyżowania równomiernego (uniform crossover) z małą modyfikacją, zmniejszającą szansę na to, że dziecko będzie "klonem" rodzica. Istnieje również mała szansa, że dojdzie do równomiernej mutacji (uniform mutation), w której losowa cecha dziecka zostaje wygenerowana na nowo.
+
+![](images/cross.png)
+
+ 
+

gmo.cpp

@@ -0,0 +1,299 @@
+#include <stdio.h>
+#include <cstdlib> 
+#include <iostream>
+#include <ctime>
+#include <string>
+#include <math.h>
+#include<bits/stdc++.h>
+#include <algorithm>
+#include <utility>
+using namespace std;
+
+string generateValue() {
+	
+	char trash[100];
+	string x = itoa(rand() % 1000,trash,10);
+	if (x.size() == 2) {
+		x = "0" + x;
+	}
+	else if (x.size() == 1) {
+		x = "00" + x;
+	}
+	
+	return x;
+	
+}
+
+
+string generateVegetable() {
+	
+	string taste = generateValue(); 
+	string colour = generateValue();
+	string size = generateValue();
+	
+	return taste + colour + size;
+	
+}
+
+
+void generatePopulation(string * population,int length) {
+	
+	int i;
+	for(i=0;i<length;i++) {
+		population[i] = generateVegetable();
+	}
+}
+
+
+int power(int x, int y) {
+	
+  if (y == 0) return 1;
+  if (y == 1) return x;
+  
+  int temp = power(x, y/2);
+  if (y%2 == 0) return temp * temp;
+  else return x * temp * temp;
+}
+
+
+int stringToInt(string str,int size) {
+	
+	int x = 0;
+	int i;
+	reverse(str.begin(),str.end());
+	
+	for(i=0;i<size;i++) {
+		x += (str[i] - '0') * power(10,i);
+	}
+	
+	reverse(str.begin(),str.end());
+	
+	return x;	
+}
+
+
+int fitness(string vegetable) {
+	
+	int taste = stringToInt(vegetable.substr(0,3),3);
+	int colour = stringToInt(vegetable.substr(3,3),3);
+	int size = stringToInt(vegetable.substr(6,3),3);
+	
+	return (taste+colour+size)/3;
+}
+
+
+bool comparePair(const pair<int, string>&i, const pair<int, string>&j)
+{
+   	return i.first > j.first;
+}
+
+    
+void ranking(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	for(i=0;i<parentsNumber;i++) {
+		parents[i] = fitnessTable[i].second;
+	}	
+}
+
+
+bool exists(int len, int * array, int element) {
+	
+	int i;
+	for(i=0;i<len;i++) {
+		if (array[i] == element) return true;
+	}
+	return false;
+}
+
+
+void selection(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i,j,k;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	int roulette;
+	int taken[parentsNumber];
+	int sum = 0;
+	for(i=0;i<parentsNumber;i++) {
+		for(j = populationSize - 1;j>=0;j--) {
+			if(not exists(parentsNumber,taken,j)) {
+				sum += 	fitnessTable[j].first;
+				fitnessTable[j].first = sum;
+			}
+			
+		}
+		roulette = rand() % fitnessTable[0].first;
+		j = 0;
+		while(exists(parentsNumber,taken,j)) {
+			j += 1;
+		}
+		while(roulette > fitnessTable[j].first and j<populationSize) {
+			if(not exists(parentsNumber,taken,j)) {
+				roulette -= fitnessTable[j].first;
+			}
+			j+=1;
+		}
+		parents[i] = fitnessTable[j].second;
+		taken[i] = j;
+	}
+	
+	
+		
+}
+
+
+int newton(int n,int k) {
+	
+	if (k==0 or n==k) return 1;
+	else return newton(n-1,k-1) + newton(n-1,k);
+}
+
+
+string mutate(string child) {
+	
+	int d3 = rand() % 3;
+	string mutation = generateValue();
+	switch(d3) {
+		case 0:
+			child = mutation + child.substr(3,6);
+			break;
+		case 1:
+			child = child.substr(0,3) + mutation + child.substr(6,3);
+			break;
+		case 2:
+			child = child.substr(0,6) + mutation;
+			break;
+	}
+	
+	return child;
+}
+
+
+string cross(string parent[2]) {
+	
+	int i;
+	string child = "";
+	for(i=0;i<3;i++) {
+		child += parent[rand() % 2].substr(i*3,3);
+	}
+	if (child == parent[0] or child == parent[1]) {
+		string other;
+		if (child == parent[0]) other = parent[1];
+		else other = parent[0];
+		int d3 = rand() % 3;
+		switch(d3) {
+			case 0:
+				child = other.substr((rand() % 3)*3,3) + child.substr(3,6);
+				break;
+			case 1:
+				child = child.substr(0,3) + other.substr((rand() % 3)*3,3) + child.substr(6,3);
+				break;
+			case 2:
+				child = child.substr(0,6) + other.substr((rand() % 3)*3,3);
+				break;
+		}
+	}
+	int d1000 = rand() % 1000;
+	if (rand() % 100 == 0) {
+		child = mutate(child);
+	}
+	return child;
+}
+
+
+void crossover(string * parents,string * nextGen,int parentsNumber,int nextGenSize) {
+	
+	int counter = 0;
+	int i,j;
+	for(i=0;i<parentsNumber;i++) {
+		if (counter >= nextGenSize) {
+			break;
+		}
+		else {
+			nextGen[counter] = parents[i];
+		counter +=1;
+		}
+	}
+	while(counter < nextGenSize) {
+		for(i=0;i<parentsNumber;i++) {
+			if (counter >= nextGenSize) {
+				break;
+			}
+			else {
+				for(j=i;j<parentsNumber;j++) {
+					if (counter >= nextGenSize) {
+					break;
+					}
+					else {
+						string couple[2];
+						couple[0] = parents[i];
+						couple[1] = parents[j];
+						nextGen[counter] = cross(couple);
+						counter += 1;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+void genetic_algorithm(string * population, int populationSize, int parentsNumber,string * outcome, int outcomeSize) {
+	
+	int iteration,i;
+	for(iteration=0;iteration<5;iteration++) {
+		string * parents = new string[parentsNumber];
+		selection(population,parents,populationSize,parentsNumber);
+		
+		string * nextGen = new string[populationSize];
+		crossover(parents,nextGen,parentsNumber,populationSize);
+		
+		delete[] population;
+		
+		population = new string[populationSize];
+		for(i=0;i<populationSize;i++) {
+			population[i] = nextGen[i];
+		}
+		delete[] nextGen;
+	}
+	ranking(population,outcome,populationSize,outcomeSize);
+}
+int main() {
+	
+	
+	srand(time(0));
+	
+	int i;
+	int populationSize = 500;
+	int parentsNumber = populationSize - 5;
+	string * population = new string[populationSize];
+	
+	generatePopulation(population,populationSize);
+	
+	string vegetablesForPlanting[20]; 
+	genetic_algorithm(population, populationSize, parentsNumber,vegetablesForPlanting, 20);
+	
+	
+	
+	cout << "Wynik:" <<endl;
+	for(i=0;i<20;i++) {
+		cout << vegetablesForPlanting[i] << endl;
+	}
+	
+	
+	
+	return 0;
+}