s444391/SzIProjekt
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Dodaj 'Kinga Jagodzińska_Algorytm genetyczny.md'

Browse Source
This commit is contained in:
Kinga Jagodzińska 2020-05-20 09:11:37 +00:00
parent 9fec1f41a8
commit a049664f20
1 changed files with 133 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
Kinga Jagodzińska_Algorytm genetyczny.md Normal file
View File

@ -0,0 +1,133 @@
# *Sztuczna inteligencja - projekt zespołowy - Autonomiczny Traktor*
#### autorzy: Aleksandra Werda, Natalia Wiśniewska, Kinga Jagodzińska, Aleksandra Jonas
***
## Kinga Jagodzińska - podprojekt: Sadzenie przy użyciu algorytmu genetycznego
___
Zadaniem tego podprojektu było dobranie nasion do zasadzenia na pustych polach przy użyciu algorytmu genetycznego, tak aby bazując na ich dopasowaniu do sadzonek na sąsiednich polach, wybór był jak najbardziej optymalny.
Najpierw używamy stworzonej funkcji *empty()* do przeliczenia ilości pustych pól na planszy (*length*) oraz ich położenia na planszy (*index_gen*). Jest to konieczne, ponieważ rodzaje sadzonek na polach w programie są dobierane losowo i liczba pustych pól przy każdym uruchomieniu programu się zmienia.
```
def empty(self):
for x in range(25):
if self.game.fields[x] == "puste":
self.length = self.length + 1
self.index_gen.append(x)
```
Następnie tworzymy pierwszą generację rodziców. Każdy rodzic jest tablicą o długości równej liczbie pustych pól i do tej tablicy losowo zostają przydzielone sadzonki. Każdego nowo wygenerowanego rodzica dodajemy do tablicy tablic *dna*.
```
def dna_create(self):
self.dna = []
for x in range(self.max_gen):
temp = []
for y in range(self.length):
temp.append(random.choice(["żyto", "jęczmień", "owies", "marchew", "rzodkiew", "pietruszka"]))
self.dna.append(temp)
```
W funkcji *algorytm()* tworzymy tablicę *l*, która będzie zawierać sumę dopasowania dobranych sadzonek do sąsiednich pól. Definiujemy zmienną *first* jako True. Reszta funkcji znajduje się w pętli *while*. Jeśli w tablicy tablic *dna* mamy pierwszą generację rodziców, dodajemy do tablicy *l* odpowiadający im wynik używając funkcji *l_score*. Jeśli jest to późniejsza generacja do tablicy dodajemy tylko potomstwo, którego wynik jeszcze nie został dodany.
```
def algorytm(self):
l = []
first = True
self.empty()
self.dna_create()
while True:
if first == True:
for x in range(len(self.dna)):
l.append(self.l_score(self.dna[x]))
first = False
elif first == False:
for x in range(int(self.max_gen * 1 / 3)):
l.append(self.l_score(self.dna[x + int(self.max_gen * 2 / 3)]))
```
Jeśli algorytm odnajdzie możliwie najbardziej optymalną możliwość lub przejdziemy przez 200 generacji, algorytm się kończy, zwracając nam odpowiadającą tablicę z tablicy *dna*.
```
if max(l) >= self.length or self.pokolenie > 200:
return self.dna[l.index(max(l))]
```
Następnie pozbywamy się 1/3 wszystkich tablic z tablicy *dna* pozostawiając te, które mają najwyższy odpowiadający im wynik w *l*.
```
for x in range(int(self.max_gen * 1 / 3)):
del self.dna[l.index(min(l))]
l.remove(min(l))
```
Dla każdej pary rodziców w *dna* tworzymy potomstwo, którego elementy są dobierane naprzemiennie.
```
for x in range(int(self.max_gen * 1 / 3)):
temp = []
for y in range(self.length):
if y % 2 == 0:
temp.append(self.dna[x][y])
if y % 2 == 1:
temp.append(self.dna[int(self.max_gen * 2 / 3) - 1 - x][y])
```
Każdy potomek ma 40% szansy na zmianę maksymalnie trzech elementów.
```
if random.randint(0, 100) <= 40:
for x in range(3):
temp[random.randint(0, self.length - 1)] = random.choice(["żyto", "jęczmień", "owies", "marchew", "rzodkiew", "pietruszka"])
```
Następnie dodajemy potomka do tablicy tablic *dna* oraz zwiększamy numer kolejnego pokolenia.
```
self.dna.append(temp)
self.pokolenie = self.pokolenie + 1
```
Wcześniej wspomniana funkcja l_score sumuje iloczyny dopasowania wybranego rodzaju nasion do posadzenia na wybranym polu do rodzaju sadzonek na sąsiednich polach, także tych, które mają dopiero zostać zasadzone. Dopasowanie pomiędzy konkretnymi roślinami zostało ustalone odgórnie.
```
def l_score(self, tab):
suma1 = 0
for x in range(len(tab)):
suma = 1
for y in self.game.neighbours[self.index_gen[x]]:
if y in self.index_gen:
som = tab[self.index_gen.index(y)]
else:
som = self.game.fields[y]
if tab[x] == "żyto":
if som == "żyto":
suma = suma * 0.5
...
```
Funkcję *algorytm()* wywołujemy w *init()* znajdującym się w *tractor. py*, by później wykorzystać ją w sadzeniu podczas poruszania się traktorem po planszy.
```
self.sadzonka = self.gen.algorytm()
```
if pygame.key.get_pressed()[pygame.K_SPACE]:
pole = int(self.pos.y // 144 * 5 + self.pos.x // 144)
if pole in self.gen.index_gen and pole not in self.road:
self.game.fields[pole] = self.sadzonka[self.gen.index_gen.index(pole)]
if len(self.road) != 0:
if self.road[0] == pole + 1:
self.pos.x = self.pos.x + 144
elif self.road[0] == pole - 1:
self.pos.x = self.pos.x - 144
elif self.road[0] == pole + 5:
self.pos.y = self.pos.y + 144
elif self.road[0] == pole - 5:
self.pos.y = self.pos.y - 144
self.road.pop(0)
Dodatkowo została stworzona funkcja *best_path()*, która wybiera najlepszą drogę pomiędzy pustymi polami zwracając szczególną uwagę na kolejność przejścia.
```
def best_path(self):
best = 999999
best_route = []
for x in permutations(self.gen.index_gen, self.gen.length):
# punkt początkowy
start = 0
droga = [0]
dlug = 0
for y in x:
temp1 = self.algo(start, y)
if temp1[0] == droga[len(droga)-1]:
del temp1[0]
droga.extend(temp1)
start = y
for z in temp1:
dlug = dlug + self.f_score[z]
if dlug < best:
best_route = droga
best = dlug
return best_route