pełen odświeżony algorytm genetyczny wraz z integracją z całym projektem
This commit is contained in:
parent
615a76acca
commit
d57428a5e0
93
Piotrek.py
93
Piotrek.py
@ -11,57 +11,42 @@ class main():
|
||||
self.pathfinding_tractorless = pathfinding_tractorless.pathfinding_tractorless()
|
||||
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
|
||||
pola_buraczane = []
|
||||
znalezione_pola = []
|
||||
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:
|
||||
l = 0
|
||||
for j in i:
|
||||
if j in ktore_pole: #w tym przypadku pol z burakami, stąd 8
|
||||
pola_buraczane.append(k*10+l)
|
||||
if j in ktore_pole:
|
||||
znalezione_pola.append(k*10+l)
|
||||
l = l + 1
|
||||
k = k + 1
|
||||
pierwsze_szukane_pole = pola_buraczane[0] #początkowa współrzędna, w każdym przypadku pole startowe [0,0]
|
||||
pola_buraczane.append(pierwsze_szukane_pole)
|
||||
print("Współrzędne szukanych pól: " + str(pola_buraczane))
|
||||
return pola_buraczane
|
||||
pierwsze_szukane_pole = znalezione_pola[0] #początkowa współrzędna, w każdym przypadku pole startowe [0,0]
|
||||
znalezione_pola.append(pierwsze_szukane_pole)
|
||||
print("Współrzędne szukanych pól: " + str(znalezione_pola))
|
||||
return znalezione_pola
|
||||
|
||||
def trasa_buraczana(self,pola_buraczane): #wyznacza koszt trasy przez pola danego rodzaju w zadanej kolejnosci
|
||||
self.liczba_pol = len(pola_buraczane)
|
||||
def koszt_przejazdu(self,znalezione_pola): #wyznacza koszt trasy przez pola danego rodzaju w zadanej kolejnosci
|
||||
self.liczba_pol = len(znalezione_pola)
|
||||
total_cost = 0
|
||||
i = 0
|
||||
while i < (self.liczba_pol - 1):
|
||||
# print(str(self.pathfinding_tractorless.pathfinding_tractorless(self.field,pola_buraczane,i)))
|
||||
total_cost = total_cost + 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,znalezione_pola,i)
|
||||
# print(str(total_cost))
|
||||
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("###################")
|
||||
return total_cost
|
||||
|
||||
def tworzenie_pokolenia(self,pola_buraczane,i):
|
||||
x = len(pola_buraczane) - 2
|
||||
def tworzenie_pokolenia(self,znalezione_pola,i):
|
||||
x = len(znalezione_pola) - 2
|
||||
wspolrzedne_shuffle = []
|
||||
while x > 0:
|
||||
wspolrzedne_shuffle.append(pola_buraczane[x])
|
||||
wspolrzedne_shuffle.append(znalezione_pola[x])
|
||||
x = x - 1
|
||||
x = len(pola_buraczane) - 1
|
||||
x = len(znalezione_pola) - 1
|
||||
lista_osobnikow = []
|
||||
while i > 0: #liczebność pierwszego pokolenia (domyślnie 10)
|
||||
nowy_osobnik = random.sample(wspolrzedne_shuffle, len(wspolrzedne_shuffle))
|
||||
@ -77,19 +62,19 @@ class main():
|
||||
ile_osobnikow = 0
|
||||
koszty_tras_osobnikow = []
|
||||
y = 0
|
||||
pierwszy_koszt = self.trasa_buraczana(pokolenia[y])
|
||||
pierwszy_koszt = self.koszt_przejazdu(pokolenia[y])
|
||||
najtanszy_osobnik = pokolenia[y]
|
||||
najnizszy_koszt = pierwszy_koszt
|
||||
najwyzszy_koszt = pierwszy_koszt
|
||||
for i in pokolenia:
|
||||
koszty_tras_osobnikow.append(self.trasa_buraczana(i))
|
||||
suma_kosztow_tras = suma_kosztow_tras + self.trasa_buraczana(i)
|
||||
koszty_tras_osobnikow.append(self.koszt_przejazdu(i))
|
||||
suma_kosztow_tras = suma_kosztow_tras + self.koszt_przejazdu(i)
|
||||
ile_osobnikow = ile_osobnikow + 1
|
||||
if self.trasa_buraczana(i) < najnizszy_koszt:
|
||||
najnizszy_koszt = self.trasa_buraczana(i)
|
||||
if self.koszt_przejazdu(i) < najnizszy_koszt:
|
||||
najnizszy_koszt = self.koszt_przejazdu(i)
|
||||
najtanszy_osobnik = i
|
||||
if self.trasa_buraczana(i) > najwyzszy_koszt:
|
||||
najwyzszy_koszt = self.trasa_buraczana(i)
|
||||
if self.koszt_przejazdu(i) > najwyzszy_koszt:
|
||||
najwyzszy_koszt = self.koszt_przejazdu(i)
|
||||
# print("Najtansza trasa w danym pokoleniu: " + str(najnizszy_koszt))
|
||||
# print("Najdrozsza trasa w danym pokoleniu: " + str(najwyzszy_koszt))
|
||||
srednie_przystosowanie = suma_kosztow_tras/ile_osobnikow #parametr potrzebny do oceny przystosowania osobnikow
|
||||
@ -141,7 +126,7 @@ class main():
|
||||
dziecko_1 = []
|
||||
dziecko_2 = []
|
||||
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
|
||||
l = 0
|
||||
k = miejsce_krzyzowania
|
||||
@ -187,7 +172,7 @@ class main():
|
||||
dziecko_1 = []
|
||||
dziecko_2 = []
|
||||
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
|
||||
l = 0
|
||||
k = miejsce_krzyzowania
|
||||
@ -249,7 +234,7 @@ class main():
|
||||
# print("Populacja po mutacji: " + str(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
|
||||
i = len(populacja_po_mutacji)
|
||||
l = 1
|
||||
@ -258,12 +243,12 @@ class main():
|
||||
while k >= 0:
|
||||
if populacja_po_mutacji[l] == 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 = []
|
||||
while x > 0:
|
||||
wspolrzedne_shuffle.append(pola_buraczane[x])
|
||||
wspolrzedne_shuffle.append(znalezione_pola[x])
|
||||
x = x - 1
|
||||
x = len(pola_buraczane) - 1
|
||||
x = len(znalezione_pola) - 1
|
||||
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(x,0)
|
||||
@ -277,11 +262,10 @@ class main():
|
||||
return populacja_po_optymalizacji
|
||||
|
||||
def algorytm_genetyczny(self):
|
||||
self.zliczanie_wystapien()
|
||||
self.pola_buraczane = self.wspolrzedne()
|
||||
self.koszt_trasy = self.trasa_buraczana(self.pola_buraczane)
|
||||
self.znalezione_pola = self.wspolrzedne()
|
||||
self.koszt_trasy = self.koszt_przejazdu(self.znalezione_pola)
|
||||
# Utworzenie pokolenia
|
||||
self.pierwsze_pokolenie = self.tworzenie_pokolenia(self.pola_buraczane,10)
|
||||
self.pierwsze_pokolenie = self.tworzenie_pokolenia(self.znalezione_pola,10)
|
||||
# Funkcja przystosowania
|
||||
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
|
||||
@ -291,7 +275,7 @@ class main():
|
||||
# Mutacja populacji pośredniej
|
||||
self.populacja_po_mutacji = self.mutacja(self.populacja_po_krzyzowaniu)
|
||||
# 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.min_koszt = self.najnizszy_koszt
|
||||
self.najtansza_trasa = self.najtanszy_osobnik
|
||||
@ -322,7 +306,7 @@ class main():
|
||||
# Mutacja populacji pośredniej
|
||||
self.populacja_po_mutacji = self.mutacja(self.populacja_po_krzyzowaniu)
|
||||
# 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
|
||||
if (self.min_koszt)/(self.srednie_przystosowanie_pierwszego_pokolenia) < (0.69):
|
||||
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("Najwyzszy znaleziony koszt: " + str(self.maks_koszt))
|
||||
|
||||
def main(self):
|
||||
self.algorytm_genetyczny()
|
||||
def wykonanie_trasy(self):
|
||||
i = len(self.najtansza_trasa) - 1
|
||||
l = 0
|
||||
while l < i:
|
||||
self.pathfinding_tractor.pathfinding_tractor(self.field, self.traktor, self.ui, self.najtansza_trasa, l)
|
||||
l = l + 1
|
||||
|
||||
def main(self):
|
||||
self.algorytm_genetyczny()
|
||||
self.wykonanie_trasy()
|
||||
Loading…
Reference in New Issue
Block a user