Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- import csv
- from numpy import mean, std, var
- from pandas import read_csv
- from pandas import DataFrame
- from pandas import concat
- from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
- from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, \
- RandomForestClassifier
- from sklearn.linear_model import LogisticRegression
- from sklearn.neighbors import KNeighborsClassifier
- from sklearn.model_selection import train_test_split, KFold
- from sklearn.naive_bayes import BernoulliNB, GaussianNB
- ### load data ###
- # ładujemy dane z pliku.tab
- # format lini: 56(nr robota) 15(nr pomiaru) 14(siła 1) 15(siła 2) -35(siła 3) -38(moment 1) 35(moment 2) 1(moement 3) fr_collision(rezultat)
- from sklearn.neural_network import MLPClassifier
- from sklearn.tree import DecisionTreeClassifier
- raw_data_without_headers = [] # robimy pustą listę, do której będziemy sobie wrzucać dane
- with open(
- 'data/robot_lp1_modIdTp.tab') as data_tab: # taki zapis w pythonie "jeśli otworzysz plik <jakis plik> i wrzucisz treść do <jakaś_zmienna> to wykonaj poniższe linijki",
- # śmiało możesz mowić, ze znalazłeś taki zapis w dokumentacji i go wykorzystałeś. Taki zapis jest wygodny bo nie trzeba psrawdzać czy udało się otworzyć plik.
- rows = csv.reader(data_tab, dialect='excel-tab') # opakowujemy dane w specjalny format za pomocą funkcji csv.reader(), bo wygodnie sie przechodzi do kolejnych linijek, delimiter to znak odstępu pomiędzy danymi, '\t' to tabulator
- for i in rows: # przechodzimy po kolejnych linijkach
- if len(
- i) == 1: # jeśli nasza linijka ma tylko jedną daną np i=["tresc"] to tylko wypisujemy ze jest to header, pewnie da sie to zrobic bardziej elegancko, no ale tak mi było szybciej bez patrzenia w dokumentacje
- print("header ommiting")
- else:
- i[0] = i[0].split(' ')[
- 1] # [id, time] -> time # jako, ze zamiasta tablulatora są też spacje (to jest jakiś błąd zapisu w pliku pewnie) to naprawiamy: dzielimy string pomiędzy spacjami i bieżemy ten z indexem 1 (czyli drugi od lewej)
- Mfz, res = i[6].split(
- ' ') # tu od razy wrzucamy do 2 zmienych, bo i[6].split(' ') to ciąg na przykład "-1 normal", więc da nam 2 ciągi: "-1" oraz "normal"
- i[6] = Mfz # napistdey "-1 normal" -> "-1"
- i.append(
- res) # dodajemy kolejną kolumne z rezultatami takimi jak "normal", wtedy z "-1 1 51 -4 -1 -1" zrobi sie "-1 1 51 -4 -1 -1 normal"
- raw_data_without_headers.append(i) # wrzucamy kolejno naprawione linijki do wczesniej utworzonej listy
- # w tym miejscu mamy już naprawioną listę robotow w zmiennej o nazwie raw_data_without_headers.
- data_frame = DataFrame(
- raw_data_without_headers) # tworzymy "ramke danych", żeby zobaczyć dane do uczenia (nie musimy tego robić w ten sposób, ale zajrzyjmy do zbioru)
- data_frame.columns = ['t', 'Fx', 'Fy', 'Fz', 'MFx', 'MFy', 'MFz',
- 'res'] # dodajemy opisy kolumn według opisu zbioru, żeby wiedzieć co jest czym
- del data_frame[
- 't'] # kasujemy daną która opisuje "kolejną informacje w czasie". Dla każdego robota jest 15 takich pomiarów, ich iteracja raczej nie jest potrzeba do uczenia.
- print(data_frame.head(5)) # zobaczmy pierwsze 5 // pierwszy: 0 -1 -1 63 -3 -1 0 normal
- print(data_frame.tail(15)) # zobaczmy ostatnie 15 // ostatni: 1319 -13 2 15 -25 -25 6 fr_collision
- # czyli jak widać dane udało sie naprawić i byłby gotowe do uczenia, ale ze my chcemy z nich zrobić dane agregacyjne, które za chwile będziemy generować
- iter_15 = 0 # zmienna za pomoca której będziemy sprawdzać każde 15 linijek w liście (co 15 iteracji będziemy cośtam liczyć)
- # utorzymy puste listy na dane, każda na końcu powinna mieć wielkość: długość_pliku_bez_nagówka/liczba_zapisów_dla_robota
- # czyli dla pliku robot_lp1_modIdTp bez nagłówka: 1320/15= 88. Zatem będziemy mieli 88 danych w kazej liście (czyli 1 robot = 1 linijka w każdym zbiorze).
- # listy, które są zerowane gdy osiągną rozmiar 15 (czyli jak mamy 15 robotow to coś znich liczymy i potem zerujemy)
- Fx_15_values_arr = []
- Fy_15_values_arr = []
- Fz_15_values_arr = []
- MFx_15_values_arr = []
- MFy_15_values_arr = []
- MFz_15_values_arr = []
- # Listy std (odchylenie standardowe) dla każdgo z robotow
- Fx_std_arr = []
- Fy_std_arr = []
- Fz_std_arr = []
- MFx_std_arr = []
- MFy_std_arr = []
- MFz_std_arr = []
- # Listy średnich dla każdgo z robotow
- Fx_avg_arr = []
- Fy_avg_arr = []
- Fz_avg_arr = []
- MFx_avg_arr = []
- MFy_avg_arr = []
- MFz_avg_arr = []
- # Listy minimów dla każdgo z robotow
- Fx_min_arr = []
- Fy_min_arr = []
- Fz_min_arr = []
- MFx_min_arr = []
- MFy_min_arr = []
- MFz_min_arr = []
- # Listy maximow dla każdgo z robotow
- Fx_max_arr = []
- Fy_max_arr = []
- Fz_max_arr = []
- MFx_max_arr = []
- MFy_max_arr = []
- MFz_max_arr = []
- # Rezultaty, tutaj pamiętamy, że dana wynikowa (np"collision" czy tam "normal") jest w zbiorze taka sama dla każdych 15 kolejnych pomiarów
- res_arr = []
- # Przystąpmy do wygenerowania danych agregacyjnych,
- # jak osiagamy iteracje 15 to z tych 15 wartosci obliczmay sobie srednie, miny maxy etc, a potem lecimy kolejne 15
- for i, trial in data_frame.iterrows():
- iter_15 = iter_15 + 1
- Fx_15_values_arr.append(int(data_frame.loc[i, "Fx"]))
- Fy_15_values_arr.append(int(data_frame.loc[i, "Fy"]))
- Fz_15_values_arr.append(int(data_frame.loc[i, "Fz"]))
- MFx_15_values_arr.append(int(data_frame.loc[i, "MFx"]))
- MFy_15_values_arr.append(int(data_frame.loc[i, "MFy"]))
- MFz_15_values_arr.append(int(data_frame.loc[i, "MFz"]))
- if iter_15 == 15: # tutaj ootraliśmy do 15 linijki danych, czyli cały robot zstdowany. Czyli co 15 linijek liczmy stdy itd
- print("Iteracji:", iter_15)
- Fx_avg_arr.append(float(mean(Fx_15_values_arr)))
- Fy_avg_arr.append(float(mean(Fy_15_values_arr)))
- Fz_avg_arr.append(float(mean(Fz_15_values_arr)))
- MFx_avg_arr.append(float(mean(MFx_15_values_arr)))
- MFy_avg_arr.append(float(mean(MFy_15_values_arr)))
- MFz_avg_arr.append(float(mean(MFz_15_values_arr)))
- Fx_min_arr.append(float(min(Fx_15_values_arr)))
- Fy_min_arr.append(float(min(Fy_15_values_arr)))
- Fz_min_arr.append(float(min(Fz_15_values_arr)))
- MFx_min_arr.append(float(min(MFx_15_values_arr)))
- MFy_min_arr.append(float(min(MFy_15_values_arr)))
- MFz_min_arr.append(float(min(MFz_15_values_arr)))
- Fx_max_arr.append(float(max(Fx_15_values_arr)))
- Fy_max_arr.append(float(max(Fy_15_values_arr)))
- Fz_max_arr.append(float(max(Fz_15_values_arr)))
- MFx_max_arr.append(float(max(MFx_15_values_arr)))
- MFy_max_arr.append(float(max(MFy_15_values_arr)))
- MFz_max_arr.append(float(max(MFz_15_values_arr)))
- # Compute the standard deviation.
- Fx_std_arr.append(float(std(Fx_15_values_arr)))
- Fy_std_arr.append(float(std(Fy_15_values_arr)))
- Fz_std_arr.append(float(std(Fz_15_values_arr)))
- MFx_std_arr.append(float(std(MFx_15_values_arr)))
- MFy_std_arr.append(float(std(MFy_15_values_arr)))
- MFz_std_arr.append(float(std(MFz_15_values_arr)))
- iter_15 = 0
- # Skoro mamy juz wszystkie dane zapisane w tablicach to zerujmy dane tymczasowe
- Fx_15_values_arr = []
- Fy_15_values_arr = []
- Fz_15_values_arr = []
- MFx_15_values_arr = []
- MFy_15_values_arr = []
- MFz_15_values_arr = []
- res_arr.append(str(data_frame.loc[
- i, "res"])) # jesze zbudujmy sobie listę wyników, Skoro dla każdych 15 warości mamy to samo, to możemy zapisywac rezulttat z 15 liniki
- # A poniżej zobczmy czy wszystkie zbiory są równe (każdy ma tyle ile jest robotów)
- print("Dlugosci kilku wybranych list:")
- print(len(Fx_avg_arr))
- print(len(Fx_max_arr))
- print(len(Fx_min_arr))
- print(len(MFx_avg_arr))
- print(len(res_arr))
- print("Pierwsza średnia danej Fx, czyli dla robota 1")
- print(Fx_avg_arr[0])
- data_tab = [] # nowa pusta lista, tutaj na postawie tych powyższych list zbudujemy jedną, taka która powoli na proste wygenerwanie poprawnego "DataFrame"
- for i in range(len(
- Fx_avg_arr)): # len(Fx_avg_arr),czyli długość(Fx_avg_arr) da nam 88,a range(88) sprawi, że for będzie iterować od 0 do 88
- data_tab.append([Fx_avg_arr[i], Fy_avg_arr[i], Fz_avg_arr[i],
- Fx_max_arr[i], Fy_max_arr[i], Fz_max_arr[i],
- Fx_min_arr[i], Fy_min_arr[i], Fz_min_arr[i],
- Fx_std_arr[i], Fy_std_arr[i], Fz_std_arr[i],
- MFx_avg_arr[i], MFy_avg_arr[i], MFz_avg_arr[i],
- MFx_max_arr[i], MFy_max_arr[i], MFz_max_arr[i],
- MFx_min_arr[i], MFy_min_arr[i], MFz_min_arr[i],
- MFx_std_arr[i], MFy_std_arr[i], MFz_std_arr[i],
- res_arr[i]])
- print("Lista data_Tab") # zobaczmy jak to wygląda
- print(data_tab[0]) # zobaczmy jak to wygląda, iterujemy od zera
- print(data_tab[1])
- print(data_tab[2])
- # print(data_tab[87]) # linika ostatnia
- # Dane juz mamy, teraz to opakujmy w specjalne typy żeby móc wrzucić do klasyfikatorów
- df = DataFrame(
- data_tab) # generujemy obiekt (zbior danych) DataFrame, który jest przeznaczony do uczenia maszynowgo w bilbiotekach ktorych uzywamy.
- df.columns = ["Fx_avg", "Fy_avg", "Fz_avg",
- "Fx_max", "Fy_max", "Fz_max",
- "Fx_min", "Fy_min", "Fz_min",
- "Fx_std", "Fy_std", "Fz_std",
- "MFx_avg", "MFy_avg", "MFz_avg",
- "MFx_max", "MFy_max", "MFz_max",
- "MFx_min", "MFy_min", "MFz_min",
- "MFx_std", "MFy_std", "MFz_std",
- "res"] # dodajmy opisy kolumn żeby wiedzieć co jest czym
- print("Ramka danych z danymi aggr:") # zobaczmy jak to wgyląda
- print(df.head(5))
- print(df.tail(5))
- #zapisywanie poniżej pomijam, bo juz zapisalem ten plik i recznie dodałem numeracje robota, nie ma sensu nadpisywać bez potrzeby
- #export_csv = df.to_csv("robot_lp_1_features.csv", sep=",", line_terminator='\n')
- Y = df["res"] # zapisyjemy etykiety do uczenia, "normal" "colision" itd do osobnej zmiennej
- del df["res"] # wyrzucamy etykiety z wektorów cech bo to musza być w osobnmy zbiorze
- X = df # zapisujemy wektory cech do X
- print("Split data...")
- # dzielimy zbiór na 88 podzbiorów, czyli 1 robot = 1 zbiór
- # co nam to da? możemy dzięki temu osobno testować każdego robota, czyli będzie to metoda leave-one-out
- # leave-one-out jest to jedna z walidacji kfold (jej specjalny przypadek, gdzie właśnie zbiór ma tylko 1 elemencie).
- # wiecej o walidacjach: https://pl.wikipedia.org/wiki/Sprawdzian_krzy%C5%BCowy
- # najważniejszy fragment o tej walidacji: 'próba jest dzielona na N (u nas 88) podzbiorów, zawierających po jednym elemencie'
- kf = KFold(n_splits=88)
- print("Init classifiers...")
- #Inicjalizujemy obiektu klasyfikatorow
- ada = AdaBoostClassifier(n_estimators=100)
- knn_1 = KNeighborsClassifier(n_neighbors=1)
- d_tress = DecisionTreeClassifier()
- # brn = BernoulliNB()
- gauss = GaussianNB()
- gbc = GradientBoostingClassifier()
- extra_tress = ExtraTreesClassifier(n_estimators = 100)
- lr = LogisticRegression(solver="lbfgs", multi_class="auto", max_iter = 5000)
- mlp = MLPClassifier( max_iter = 5000)
- rand_fores = RandomForestClassifier(n_estimators = 100)
- linear = LinearDiscriminantAnalysis(solver='lsqr')
- # Tworzymy sobie listy do przechowywania wynikow uczenia.
- # Każada lista będzie miała 88 wynikow. Bo każdy robot będzie testsowany na zasadzie:
- # 1 robot testujący : 97 robotow uczących
- print("Init outpusts...")
- output_ada = []
- output_knn_1 = []
- output_d_tress = []
- output_gauss = []
- output_gbc = []
- output_extra_tress = []
- output_lr = []
- output_mlp = []
- output_rand_fores = []
- output_linear = []
- # Teraz będziemy robić pętle o 88 powótrzeniach, tak, żeby każdego robota walidować dokładnie raz.
- # Tutaj w kazej iteracji od nowa uczony jest klasyfikator wszystkimi robotami poza tym, za pomocą którego będziemy testować.
- class_iterator = 1
- for train_indexes, test_indexes in kf.split(X): # Zapis "kf.split(x)" zwroci nam jakis obiekt o 88 wartościach.
- # W tych warościach będą indeksy konkretnych obiektów. Podział tutaj zachodzi automatycznie.
- print("\n\n\n################ ada ", class_iterator, '/', kf.n_splits, "################") # wypisujemy którą lecimy pętle oraz ile ma być w sumie
- print("train idexes:", train_indexes, "\n test indexes:", test_indexes) # podejrzyjmy indeksy których danych będziemy testować.
- print("\n test Y:", Y.loc[test_indexes]) # .loc[test_indexes] zwróci element o danym indeksie. Indexowanie w zbiorze jest od 0, wiec np. ".loc[0]" zwróci nam 1 element
- print("\n test X:", X.loc[test_indexes])
- X_train = X.loc[train_indexes] # za pomocą indeksów które przygotowała nam funkcja, wybieramy sobie dane które nas interesują, tutaj cechy uczące
- Y_train = Y.loc[train_indexes] # tutaj etykiety uczące
- X_test = X.loc[test_indexes]
- Y_test = Y.loc[test_indexes]
- ada.fit(X_train, Y_train) # tutaj trenujemy sobie wszytkie klasfikatory, jeden po drugim, wszystkie mają te same dane
- knn_1.fit(X_train, Y_train)
- d_tress.fit(X_train, Y_train)
- gauss.fit(X_train, Y_train)
- gbc.fit(X_train, Y_train)
- extra_tress.fit(X_train, Y_train)
- lr.fit(X_train, Y_train)
- mlp.fit(X_train, Y_train)
- rand_fores.fit(X_train, Y_train)
- linear.fit(X_train, Y_train)
- output_ada.append( ada.score(X_test, Y_test)*100) # dodajemy wynik z każdej klasyfikacji do listy. Na przyklad:
- # W 1 iteracji będzie testowany robot 1, wiec wynik jego testtu zostanie wrzucone do tej zmiennej jako 1.
- # Mnozymy *100 zeby miec w [%]
- output_knn_1.append( knn_1.score(X_test, Y_test)*100)
- output_d_tress.append(d_tress.score(X_test, Y_test)*100)
- output_gauss.append(gauss.score(X_test, Y_test)*100)
- output_gbc.append(gbc.score(X_test, Y_test)*100)
- output_extra_tress.append(extra_tress.score(X_test, Y_test)*100)
- output_lr.append(lr.score(X_test, Y_test)*100)
- output_mlp.append(mlp.score(X_test, Y_test)*100)
- output_rand_fores.append(rand_fores.score(X_test, Y_test)*100)
- output_linear.append(linear.score(X_test, Y_test)*100)
- class_iterator += 1 # zwiekszamy zmianna, żeby wiedziec którą robimy iteracje.
- # W tym miejscu kodu mamy już coś w listach "output_costam" z wynikami, zobaczymy więc jak wygląda wynik obecnej iteracja.
- # Czyli interesuje nas ostatni wynik, właśnie z obecnej iteracji, który sie dodał do listy pare linijek wyżej.
- # Zapis [-1] daje nam ostatni element z danej listy. -1 to indeks ostatniej wartosci.
- print("################",
- "output_ada=", output_ada[-1], "% ",
- "output_knn_1=", output_knn_1[-1], "% ",
- "output_d_tress=", output_d_tress[-1], "% ",
- "output_gauss=", output_gauss[-1], "% ",
- "output_gbc=", output_gbc[-1], "% ",
- "output_extra_tress=", output_extra_tress[-1], "% ",
- "output_lr=", output_lr[-1], "% ",
- "output_mlp=", output_mlp[-1], "% ",
- "output_rand_fores=", output_rand_fores[-1], "% ",
- "output_linear=", output_linear[-1], "% ",
- "################")
- print("\n\n\n################ ############ #########")
- print("################ Output data ################")
- print("################ ################ ###########")
- # Niżej to co nas najbardziej interesuje.
- # są tutaj średnie da danych klasyfikatorow. to jest wynik końcowy.
- # w każej z list mamy 88 wynikow, bo testowaliśmy każdego z robota osobno, a musimy mieć 1 wynik, dlatego liczmy z nich średnią.
- # %.2f zonacza formatowanie dla flaota z 2 miejscami po przecinku, zeby wynik był ładny
- print("output_ada %.2f" % mean(output_ada ), "%")
- print("output_knn_1 %.2f" % mean(output_knn_1 ), "%")
- print("output_d_tress %.2f" % mean(output_d_tress ), "%")
- print("output_gauss %.2f" % mean(output_gauss ), "%")
- print("output_gbc %.2f" % mean(output_gbc ), "%")
- print("output_extra_tress %.2f" % mean(output_extra_tress ), "%")
- print("output_lr %.2f" % mean(output_lr ), "%")
- print("output_mlp %.2f" % mean(output_mlp ), "%")
- print("output_rand_fores %.2f" % mean( output_rand_fores), "%")
- print("output_linear %.2f" % mean(output_linear ), "%")
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement