s444423/SI_Traktor
3
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

pełen odświeżony algorytm genetyczny wraz z integracją z całym projektem

Browse Source
This commit is contained in:
Piotr Rychlicki 2020-05-13 07:16:59 +00:00
parent 615a76acca
commit d57428a5e0
1 changed files with 43 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
Piotrek.py
View File

@ -11,57 +11,42 @@ class main():
self.pathfinding_tractorless = pathfinding_tractorless.pathfinding_tractorless() self.pathfinding_tractorless = pathfinding_tractorless.pathfinding_tractorless()
self.pathfinding_tractor = pathfinding_tractor.pathfinding_tractor() self.pathfinding_tractor = pathfinding_tractor.pathfinding_tractor()
def zliczanie_wystapien(self): #zlicza wystepowanie kazdego z rodzajow pol na planszy
tabela_wystapien = [0,0,0,0]
for i in self.field.field_matrix:
for j in i:
if j == 1 or j == 3 or j == 5 or j == 7: #zliczanie zachwaszczonych pól
tabela_wystapien[0] = tabela_wystapien[0] + 1
elif j == 1 or j == 2 or j == 3: #zliczanie nienawodnionych pól
tabela_wystapien[1] = tabela_wystapien[1] + 1
elif j == 4: #zliczanie pól gotowych do zasadzenia
tabela_wystapien[2] = tabela_wystapien[2] + 1
elif j == 8: #zliczanie pól gotowych do zbiorów
tabela_wystapien[3] = tabela_wystapien[3] + 1
else:
pass
def wspolrzedne(self): #wyznacza wspolrzedne pol danego rodzaju na planszy def wspolrzedne(self): #wyznacza wspolrzedne pol danego rodzaju na planszy
pola_buraczane = [] znalezione_pola = []
k = 0 k = 0
ktore_pole = self.traktor.get_modes_values() ktore_pole = self.traktor.get_modes_values() #rodzaj pól zależy od ustawionego trybu pracy agenta
for i in self.field.field_matrix: for i in self.field.field_matrix:
l = 0 l = 0
for j in i: for j in i:
if j in ktore_pole: #w tym przypadku pol z burakami, stąd 8 if j in ktore_pole:
pola_buraczane.append(k*10+l) znalezione_pola.append(k*10+l)
l = l + 1 l = l + 1
k = k + 1 k = k + 1
pierwsze_szukane_pole = pola_buraczane[0] #początkowa współrzędna, w każdym przypadku pole startowe [0,0] pierwsze_szukane_pole = znalezione_pola[0] #początkowa współrzędna, w każdym przypadku pole startowe [0,0]
pola_buraczane.append(pierwsze_szukane_pole) znalezione_pola.append(pierwsze_szukane_pole)
print("Współrzędne szukanych pól: " + str(pola_buraczane)) print("Współrzędne szukanych pól: " + str(znalezione_pola))
return pola_buraczane return znalezione_pola
def trasa_buraczana(self,pola_buraczane): #wyznacza koszt trasy przez pola danego rodzaju w zadanej kolejnosci def koszt_przejazdu(self,znalezione_pola): #wyznacza koszt trasy przez pola danego rodzaju w zadanej kolejnosci
self.liczba_pol = len(pola_buraczane) self.liczba_pol = len(znalezione_pola)
total_cost = 0 total_cost = 0
i = 0 i = 0
while i < (self.liczba_pol - 1): while i < (self.liczba_pol - 1):
# print(str(self.pathfinding_tractorless.pathfinding_tractorless(self.field,pola_buraczane,i))) # print(str(self.pathfinding_tractorless.pathfinding_tractorless(self.field,znalezione_pola,i)))
total_cost = total_cost + self.pathfinding_tractorless.pathfinding_tractorless(self.field,pola_buraczane,i) total_cost = total_cost + self.pathfinding_tractorless.pathfinding_tractorless(self.field,znalezione_pola,i)
# print(str(total_cost)) # print(str(total_cost))
i = i + 1 i = i + 1
# print("Koszt przejścia przez pola buraczane w zadanej kolejności: " + str(total_cost)) # print("Koszt przejścia przez pola w zadanej kolejności: " + str(total_cost))
# print("###################") # print("###################")
return total_cost return total_cost
def tworzenie_pokolenia(self,pola_buraczane,i): def tworzenie_pokolenia(self,znalezione_pola,i):
x = len(pola_buraczane) - 2 x = len(znalezione_pola) - 2
wspolrzedne_shuffle = [] wspolrzedne_shuffle = []
while x > 0: while x > 0:
wspolrzedne_shuffle.append(pola_buraczane[x]) wspolrzedne_shuffle.append(znalezione_pola[x])
x = x - 1 x = x - 1
x = len(pola_buraczane) - 1 x = len(znalezione_pola) - 1
lista_osobnikow = [] lista_osobnikow = []
while i > 0: #liczebność pierwszego pokolenia (domyślnie 10) while i > 0: #liczebność pierwszego pokolenia (domyślnie 10)
nowy_osobnik = random.sample(wspolrzedne_shuffle, len(wspolrzedne_shuffle)) nowy_osobnik = random.sample(wspolrzedne_shuffle, len(wspolrzedne_shuffle))
@ -77,19 +62,19 @@ class main():
ile_osobnikow = 0 ile_osobnikow = 0
koszty_tras_osobnikow = [] koszty_tras_osobnikow = []
y = 0 y = 0
pierwszy_koszt = self.trasa_buraczana(pokolenia[y]) pierwszy_koszt = self.koszt_przejazdu(pokolenia[y])
najtanszy_osobnik = pokolenia[y] najtanszy_osobnik = pokolenia[y]
najnizszy_koszt = pierwszy_koszt najnizszy_koszt = pierwszy_koszt
najwyzszy_koszt = pierwszy_koszt najwyzszy_koszt = pierwszy_koszt
for i in pokolenia: for i in pokolenia:
koszty_tras_osobnikow.append(self.trasa_buraczana(i)) koszty_tras_osobnikow.append(self.koszt_przejazdu(i))
suma_kosztow_tras = suma_kosztow_tras + self.trasa_buraczana(i) suma_kosztow_tras = suma_kosztow_tras + self.koszt_przejazdu(i)
ile_osobnikow = ile_osobnikow + 1 ile_osobnikow = ile_osobnikow + 1
if self.trasa_buraczana(i) < najnizszy_koszt: if self.koszt_przejazdu(i) < najnizszy_koszt:
najnizszy_koszt = self.trasa_buraczana(i) najnizszy_koszt = self.koszt_przejazdu(i)
najtanszy_osobnik = i najtanszy_osobnik = i
if self.trasa_buraczana(i) > najwyzszy_koszt: if self.koszt_przejazdu(i) > najwyzszy_koszt:
najwyzszy_koszt = self.trasa_buraczana(i) najwyzszy_koszt = self.koszt_przejazdu(i)
# print("Najtansza trasa w danym pokoleniu: " + str(najnizszy_koszt)) # print("Najtansza trasa w danym pokoleniu: " + str(najnizszy_koszt))
# print("Najdrozsza trasa w danym pokoleniu: " + str(najwyzszy_koszt)) # print("Najdrozsza trasa w danym pokoleniu: " + str(najwyzszy_koszt))
srednie_przystosowanie = suma_kosztow_tras/ile_osobnikow #parametr potrzebny do oceny przystosowania osobnikow srednie_przystosowanie = suma_kosztow_tras/ile_osobnikow #parametr potrzebny do oceny przystosowania osobnikow
@ -141,7 +126,7 @@ class main():
dziecko_1 = [] dziecko_1 = []
dziecko_2 = [] dziecko_2 = []
czy_krzyzowac = random.randint(1,100) #losowanie czy krzyzowac rodzicow, czy nie (szanse 10%) czy_krzyzowac = random.randint(1,100) #losowanie czy krzyzowac rodzicow, czy nie (szanse 10%)
if (czy_krzyzowac < 10) and (rodzic_1 != rodzic_2): #jesli krzyzowanie nastepuje if (czy_krzyzowac < 11) and (rodzic_1 != rodzic_2): #jesli krzyzowanie nastepuje
miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3)) #wybor miejsca krzyzowania miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3)) #wybor miejsca krzyzowania
l = 0 l = 0
k = miejsce_krzyzowania k = miejsce_krzyzowania
@ -187,7 +172,7 @@ class main():
dziecko_1 = [] dziecko_1 = []
dziecko_2 = [] dziecko_2 = []
czy_krzyzowac = random.randint(1,100) #losowanie czy krzyzowac rodzicow, czy nie (szanse 10%) czy_krzyzowac = random.randint(1,100) #losowanie czy krzyzowac rodzicow, czy nie (szanse 10%)
if (czy_krzyzowac < 10) and (rodzic_1 != rodzic_2): #jesli krzyzowanie nastepuje if (czy_krzyzowac < 11) and (rodzic_1 != rodzic_2): #jesli krzyzowanie nastepuje
miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3)) #wybor miejsca krzyzowania miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3)) #wybor miejsca krzyzowania
l = 0 l = 0
k = miejsce_krzyzowania k = miejsce_krzyzowania
@ -232,7 +217,7 @@ class main():
kogo_mutujemy = populacja_po_krzyzowaniu[k] kogo_mutujemy = populacja_po_krzyzowaniu[k]
populacja_po_krzyzowaniu.remove(kogo_mutujemy) populacja_po_krzyzowaniu.remove(kogo_mutujemy)
l = len(kogo_mutujemy) - 1 l = len(kogo_mutujemy) - 1
#print("Osobnik przed mutacją: " + str(kogo_mutujemy)) # print("Osobnik przed mutacją: " + str(kogo_mutujemy))
x = random.randint(1,l) x = random.randint(1,l)
y = random.randint(1,l) y = random.randint(1,l)
while x == y: while x == y:
@ -240,7 +225,7 @@ class main():
zamiennik = kogo_mutujemy[x] zamiennik = kogo_mutujemy[x]
kogo_mutujemy[x] = kogo_mutujemy[y] kogo_mutujemy[x] = kogo_mutujemy[y]
kogo_mutujemy[y] = zamiennik kogo_mutujemy[y] = zamiennik
#print("Osobnik po mutacji: " + str(kogo_mutujemy)) # print("Osobnik po mutacji: " + str(kogo_mutujemy))
populacja_po_krzyzowaniu.insert(k,kogo_mutujemy) populacja_po_krzyzowaniu.insert(k,kogo_mutujemy)
else: else:
pass pass
@ -249,7 +234,7 @@ class main():
# print("Populacja po mutacji: " + str(populacja_po_mutacji)) # print("Populacja po mutacji: " + str(populacja_po_mutacji))
return populacja_po_mutacji return populacja_po_mutacji
def optymalizacja(self,populacja_po_mutacji,pola_buraczane): #polega na eliminacji powtarzających się tras def optymalizacja(self,populacja_po_mutacji,znalezione_pola): #polega na eliminacji powtarzających się tras
populacja_po_optymalizacji = populacja_po_mutacji populacja_po_optymalizacji = populacja_po_mutacji
i = len(populacja_po_mutacji) i = len(populacja_po_mutacji)
l = 1 l = 1
@ -258,12 +243,12 @@ class main():
while k >= 0: while k >= 0:
if populacja_po_mutacji[l] == populacja_po_mutacji[k-1]: if populacja_po_mutacji[l] == populacja_po_mutacji[k-1]:
populacja_po_optymalizacji.remove(populacja_po_mutacji[k-1]) populacja_po_optymalizacji.remove(populacja_po_mutacji[k-1])
x = len(pola_buraczane) - 2 x = len(znalezione_pola) - 2
wspolrzedne_shuffle = [] wspolrzedne_shuffle = []
while x > 0: while x > 0:
wspolrzedne_shuffle.append(pola_buraczane[x]) wspolrzedne_shuffle.append(znalezione_pola[x])
x = x - 1 x = x - 1
x = len(pola_buraczane) - 1 x = len(znalezione_pola) - 1
nowy_osobnik = random.sample(wspolrzedne_shuffle, len(wspolrzedne_shuffle)) nowy_osobnik = random.sample(wspolrzedne_shuffle, len(wspolrzedne_shuffle))
nowy_osobnik.insert(0,0) #dodanie na początek listy 0, jako współrzenej startowej nowy_osobnik.insert(0,0) #dodanie na początek listy 0, jako współrzenej startowej
nowy_osobnik.insert(x,0) nowy_osobnik.insert(x,0)
@ -277,11 +262,10 @@ class main():
return populacja_po_optymalizacji return populacja_po_optymalizacji
def algorytm_genetyczny(self): def algorytm_genetyczny(self):
self.zliczanie_wystapien() self.znalezione_pola = self.wspolrzedne()
self.pola_buraczane = self.wspolrzedne() self.koszt_trasy = self.koszt_przejazdu(self.znalezione_pola)
self.koszt_trasy = self.trasa_buraczana(self.pola_buraczane)
# Utworzenie pokolenia # Utworzenie pokolenia
self.pierwsze_pokolenie = self.tworzenie_pokolenia(self.pola_buraczane,10) self.pierwsze_pokolenie = self.tworzenie_pokolenia(self.znalezione_pola,10)
# Funkcja przystosowania # Funkcja przystosowania
self.przystosowanie, self.najnizszy_koszt, self.najwyzszy_koszt, self.srednie_przystosowanie_pierwszego_pokolenia, self.najtanszy_osobnik = self.ocena_przystosowania(self.pierwsze_pokolenie) self.przystosowanie, self.najnizszy_koszt, self.najwyzszy_koszt, self.srednie_przystosowanie_pierwszego_pokolenia, self.najtanszy_osobnik = self.ocena_przystosowania(self.pierwsze_pokolenie)
# Populacja pośrednia wybrana metodą ruletki # Populacja pośrednia wybrana metodą ruletki
@ -291,7 +275,7 @@ class main():
# Mutacja populacji pośredniej # Mutacja populacji pośredniej
self.populacja_po_mutacji = self.mutacja(self.populacja_po_krzyzowaniu) self.populacja_po_mutacji = self.mutacja(self.populacja_po_krzyzowaniu)
# Optymalizacja populacji pośredniej # Optymalizacja populacji pośredniej
self.populacja_po_optymalizacji = self.optymalizacja(self.populacja_po_mutacji,self.pola_buraczane) self.populacja_po_optymalizacji = self.optymalizacja(self.populacja_po_mutacji,self.znalezione_pola)
self.maks_koszt = self.najwyzszy_koszt self.maks_koszt = self.najwyzszy_koszt
self.min_koszt = self.najnizszy_koszt self.min_koszt = self.najnizszy_koszt
self.najtansza_trasa = self.najtanszy_osobnik self.najtansza_trasa = self.najtanszy_osobnik
@ -322,7 +306,7 @@ class main():
# Mutacja populacji pośredniej # Mutacja populacji pośredniej
self.populacja_po_mutacji = self.mutacja(self.populacja_po_krzyzowaniu) self.populacja_po_mutacji = self.mutacja(self.populacja_po_krzyzowaniu)
# Optymalizacja populacji pośredniej # Optymalizacja populacji pośredniej
self.populacja_po_optymalizacji = self.optymalizacja(self.populacja_po_mutacji,self.pola_buraczane) self.populacja_po_optymalizacji = self.optymalizacja(self.populacja_po_mutacji,self.znalezione_pola)
i = i + 1 i = i + 1
if (self.min_koszt)/(self.srednie_przystosowanie_pierwszego_pokolenia) < (0.69): if (self.min_koszt)/(self.srednie_przystosowanie_pierwszego_pokolenia) < (0.69):
print("Zakończono wykonywanie algorytmu po " + str(i) + " pokoleniach") print("Zakończono wykonywanie algorytmu po " + str(i) + " pokoleniach")
@ -333,10 +317,13 @@ class main():
print("Najtansza znaleziona trasa to " + str(self.najtansza_trasa)) print("Najtansza znaleziona trasa to " + str(self.najtansza_trasa))
# print("Najwyzszy znaleziony koszt: " + str(self.maks_koszt)) # print("Najwyzszy znaleziony koszt: " + str(self.maks_koszt))
def main(self): def wykonanie_trasy(self):
self.algorytm_genetyczny()
i = len(self.najtansza_trasa) - 1 i = len(self.najtansza_trasa) - 1
l = 0 l = 0
while l < i: while l < i:
self.pathfinding_tractor.pathfinding_tractor(self.field, self.traktor, self.ui, self.najtansza_trasa, l) self.pathfinding_tractor.pathfinding_tractor(self.field, self.traktor, self.ui, self.najtansza_trasa, l)
l = l + 1 l = l + 1
def main(self):
self.algorytm_genetyczny()
self.wykonanie_trasy()