Guest User

Untitled

a guest
Dec 9th, 2019
94
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import csv
  2.  
  3. from numpy import mean, std, var
  4. from pandas import read_csv
  5. from pandas import DataFrame
  6. from pandas import concat
  7. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  8. from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, \
  9.     RandomForestClassifier
  10. from sklearn.linear_model import LogisticRegression
  11. from sklearn.neighbors import KNeighborsClassifier
  12. from sklearn.model_selection import train_test_split,  KFold
  13. from sklearn.naive_bayes import BernoulliNB, GaussianNB
  14. ### load data ###
  15. # ładujemy dane z pliku.tab
  16. # 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)
  17. from sklearn.neural_network import MLPClassifier
  18. from sklearn.tree import DecisionTreeClassifier
  19.  
  20. raw_data_without_headers = []  # robimy pustą listę, do której będziemy sobie wrzucać dane
  21. with open(
  22.         '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",
  23.     # ś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.
  24.     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
  25.     for i in rows:  # przechodzimy po kolejnych linijkach
  26.         if len(
  27.                 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
  28.             print("header ommiting")
  29.         else:
  30.             i[0] = i[0].split(' ')[
  31.                 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)
  32.             Mfz, res = i[6].split(
  33.                 ' ')  # 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"
  34.             i[6] = Mfz  # napistdey "-1 normal" -> "-1"
  35.             i.append(
  36.                 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"
  37.             raw_data_without_headers.append(i)  # wrzucamy kolejno naprawione linijki do wczesniej utworzonej listy
  38.  
  39. # w tym miejscu mamy już naprawioną listę robotow w zmiennej o nazwie raw_data_without_headers.
  40.  
  41. data_frame = DataFrame(
  42.     raw_data_without_headers)  # tworzymy "ramke danych", żeby zobaczyć dane do uczenia (nie musimy tego robić w ten sposób, ale zajrzyjmy do zbioru)
  43. data_frame.columns = ['t', 'Fx', 'Fy', 'Fz', 'MFx', 'MFy', 'MFz',
  44.                       'res']  # dodajemy opisy kolumn według opisu zbioru, żeby wiedzieć co jest czym
  45. del data_frame[
  46.     '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.
  47. print(data_frame.head(5))  # zobaczmy pierwsze 5 // pierwszy: 0  -1  -1  63  -3  -1   0  normal
  48. print(data_frame.tail(15))  # zobaczmy ostatnie 15 // ostatni: 1319  -13  2  15  -25  -25   6  fr_collision
  49. # 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ć
  50.  
  51.  
  52. 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ć)
  53.  
  54. # utorzymy puste listy na dane, każda na końcu powinna mieć wielkość: długość_pliku_bez_nagówka/liczba_zapisów_dla_robota
  55. # 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).
  56.  
  57.  
  58. # listy, które są zerowane gdy osiągną rozmiar 15 (czyli jak mamy 15 robotow to coś znich liczymy i potem zerujemy)
  59. Fx_15_values_arr = []
  60. Fy_15_values_arr = []
  61. Fz_15_values_arr = []
  62. MFx_15_values_arr = []
  63. MFy_15_values_arr = []
  64. MFz_15_values_arr = []
  65.  
  66. # Listy std (odchylenie standardowe) dla każdgo z robotow
  67. Fx_std_arr = []
  68. Fy_std_arr = []
  69. Fz_std_arr = []
  70. MFx_std_arr = []
  71. MFy_std_arr = []
  72. MFz_std_arr = []
  73.  
  74. # Listy średnich dla każdgo z robotow
  75. Fx_avg_arr = []
  76. Fy_avg_arr = []
  77. Fz_avg_arr = []
  78. MFx_avg_arr = []
  79. MFy_avg_arr = []
  80. MFz_avg_arr = []
  81.  
  82. # Listy minimów dla każdgo z robotow
  83. Fx_min_arr = []
  84. Fy_min_arr = []
  85. Fz_min_arr = []
  86. MFx_min_arr = []
  87. MFy_min_arr = []
  88. MFz_min_arr = []
  89.  
  90. # Listy maximow dla każdgo z robotow
  91. Fx_max_arr = []
  92. Fy_max_arr = []
  93. Fz_max_arr = []
  94. MFx_max_arr = []
  95. MFy_max_arr = []
  96. MFz_max_arr = []
  97.  
  98. # Rezultaty, tutaj pamiętamy, że dana wynikowa (np"collision" czy tam "normal") jest w zbiorze taka sama dla każdych 15 kolejnych pomiarów
  99. res_arr = []
  100.  
  101. # Przystąpmy do wygenerowania danych agregacyjnych:
  102. for i, trial in data_frame.iterrows():
  103.     iter_15 = iter_15 + 1
  104.  
  105.     Fx_15_values_arr.append(int(data_frame.loc[i, "Fx"]))
  106.     Fy_15_values_arr.append(int(data_frame.loc[i, "Fy"]))
  107.     Fz_15_values_arr.append(int(data_frame.loc[i, "Fz"]))
  108.     MFx_15_values_arr.append(int(data_frame.loc[i, "MFx"]))
  109.     MFy_15_values_arr.append(int(data_frame.loc[i, "MFy"]))
  110.     MFz_15_values_arr.append(int(data_frame.loc[i, "MFz"]))
  111.  
  112.     if iter_15 == 15:  # tutaj ootraliśmy do 15 linijki danych, czyli cały robot zstdowany. Czyli co 15 linijek liczmy stdy itd
  113.         print("Iteracji:", iter_15)
  114.         Fx_avg_arr.append(float(mean(Fx_15_values_arr)))
  115.         Fy_avg_arr.append(float(mean(Fy_15_values_arr)))
  116.         Fz_avg_arr.append(float(mean(Fz_15_values_arr)))
  117.         MFx_avg_arr.append(float(mean(MFx_15_values_arr)))
  118.         MFy_avg_arr.append(float(mean(MFy_15_values_arr)))
  119.         MFz_avg_arr.append(float(mean(MFz_15_values_arr)))
  120.  
  121.         Fx_min_arr.append(float(min(Fx_15_values_arr)))
  122.         Fy_min_arr.append(float(min(Fy_15_values_arr)))
  123.         Fz_min_arr.append(float(min(Fz_15_values_arr)))
  124.         MFx_min_arr.append(float(min(MFx_15_values_arr)))
  125.         MFy_min_arr.append(float(min(MFy_15_values_arr)))
  126.         MFz_min_arr.append(float(min(MFz_15_values_arr)))
  127.  
  128.         Fx_max_arr.append(float(max(Fx_15_values_arr)))
  129.         Fy_max_arr.append(float(max(Fy_15_values_arr)))
  130.         Fz_max_arr.append(float(max(Fz_15_values_arr)))
  131.         MFx_max_arr.append(float(max(MFx_15_values_arr)))
  132.         MFy_max_arr.append(float(max(MFy_15_values_arr)))
  133.         MFz_max_arr.append(float(max(MFz_15_values_arr)))
  134.  
  135.         # Compute the standard deviation.
  136.         Fx_std_arr.append(float(std(Fx_15_values_arr)))
  137.         Fy_std_arr.append(float(std(Fy_15_values_arr)))
  138.         Fz_std_arr.append(float(std(Fz_15_values_arr)))
  139.         MFx_std_arr.append(float(std(MFx_15_values_arr)))
  140.         MFy_std_arr.append(float(std(MFy_15_values_arr)))
  141.         MFz_std_arr.append(float(std(MFz_15_values_arr)))
  142.  
  143.         iter_15 = 0
  144.  
  145.         # Skoro mamy juz wszystkie dane zapisane w tablicach to zerujmy dane tymczasowe
  146.         Fx_15_values_arr = []
  147.         Fy_15_values_arr = []
  148.         Fz_15_values_arr = []
  149.         MFx_15_values_arr = []
  150.         MFy_15_values_arr = []
  151.         MFz_15_values_arr = []
  152.  
  153.         res_arr.append(str(data_frame.loc[
  154.                                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
  155.  
  156. # A poniżej zobczmy czy wszystkie zbiory są równe (każdy ma tyle ile jest robotów)
  157. print("Dlugosci kilku wybranych list:")
  158. print(len(Fx_avg_arr))
  159. print(len(Fx_max_arr))
  160. print(len(Fx_min_arr))
  161. print(len(MFx_avg_arr))
  162. print(len(res_arr))
  163.  
  164. print("Pierwsza średnia danej Fx, czyli dla robota 1")
  165. print(Fx_avg_arr[0])
  166.  
  167. data_tab = []  # nowa pusta lista, tutaj na postawie tych powyższych list zbudujemy jedną, taka która powoli na proste wygenerwanie poprawnego "DataFrame"
  168. for i in range(len(
  169.         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
  170.     data_tab.append([Fx_avg_arr[i], Fy_avg_arr[i], Fz_avg_arr[i],
  171.                      Fx_max_arr[i], Fy_max_arr[i], Fz_max_arr[i],
  172.                      Fx_min_arr[i], Fy_min_arr[i], Fz_min_arr[i],
  173.                      Fx_std_arr[i], Fy_std_arr[i], Fz_std_arr[i],
  174.  
  175.                      MFx_avg_arr[i], MFy_avg_arr[i], MFz_avg_arr[i],
  176.                      MFx_max_arr[i], MFy_max_arr[i], MFz_max_arr[i],
  177.                      MFx_min_arr[i], MFy_min_arr[i], MFz_min_arr[i],
  178.                      MFx_std_arr[i], MFy_std_arr[i], MFz_std_arr[i],
  179.  
  180.                      res_arr[i]])
  181.  
  182. print("Lista data_Tab")  # zobaczmy jak to wygląda
  183. print(data_tab[0])  # zobaczmy jak to wygląda, iterujemy od zera
  184. print(data_tab[1])
  185. print(data_tab[2])
  186. # print(data_tab[87])  # linika ostatnia
  187.  
  188. # Dane juz mamy, teraz to opakujmy w specjalne typy żeby móc wrzucić do klasyfikatorów
  189.  
  190. df = DataFrame(
  191.     data_tab)  # generujemy obiekt (zbior danych) DataFrame, który jest przeznaczony do uczenia maszynowgo w bilbiotekach ktorych uzywamy.
  192. df.columns = ["Fx_avg", "Fy_avg", "Fz_avg",
  193.               "Fx_max", "Fy_max", "Fz_max",
  194.               "Fx_min", "Fy_min", "Fz_min",
  195.               "Fx_std", "Fy_std", "Fz_std",
  196.  
  197.               "MFx_avg", "MFy_avg", "MFz_avg",
  198.               "MFx_max", "MFy_max", "MFz_max",
  199.               "MFx_min", "MFy_min", "MFz_min",
  200.               "MFx_std", "MFy_std", "MFz_std",
  201.  
  202.               "res"]  # dodajmy opisy kolumn żeby wiedzieć co jest czym
  203.  
  204. print("Ramka danych z danymi aggr:")  # zobaczmy jak to wgyląda
  205. print(df.head(5))
  206. print(df.tail(5))
  207.  
  208. #zapisywanie poniżej pomijam, bo juz zapisalem ten plik i recznie dodałem numeracje robota, nie ma sensu nadpisywać bez potrzeby
  209. #export_csv = df.to_csv("robot_lp_1_features.csv", sep=",", line_terminator='\n')
  210.  
  211.  
  212. Y = df["res"]  # zapisyjemy etykiety do uczenia, "normal" "colision" itd do osobnej zmiennej
  213. del df["res"]  # wyrzucamy etykiety z wektorów cech bo to musza być w osobnmy zbiorze
  214. X = df  # zapisujemy wektory cech do X
  215.  
  216. print("Split data...")
  217.  # dzielimy zbiór na 88 podzbiorów, czyli 1 robot = 1 zbiór
  218. # co nam to da? możemy dzięki temu osobno testować każdego robota, czyli będzie to metoda leave-one-out
  219. # leave-one-out jest to jedna z walidacji kfold (jej specjalny przypadek, gdzie właśnie zbiór ma tylko 1 elemencie).
  220. # wiecej o walidacjach: https://pl.wikipedia.org/wiki/Sprawdzian_krzy%C5%BCowy
  221. # najważniejszy fragment o tej walidacji:  'próba jest dzielona na N (u nas 88) podzbiorów, zawierających po jednym elemencie'
  222. kf = KFold(n_splits=88)
  223.  
  224. print("Init classifiers...")
  225. #Inicjalizujemy obiektu klasyfikatorow
  226. ada = AdaBoostClassifier(n_estimators=100)
  227. knn_1 = KNeighborsClassifier(n_neighbors=1)
  228. d_tress = DecisionTreeClassifier()
  229. # brn = BernoulliNB()
  230. gauss = GaussianNB()
  231. gbc = GradientBoostingClassifier()
  232. extra_tress = ExtraTreesClassifier(n_estimators = 100)
  233. lr = LogisticRegression(solver="lbfgs", multi_class="auto", max_iter = 5000)
  234. mlp = MLPClassifier( max_iter = 5000)
  235. rand_fores = RandomForestClassifier(n_estimators = 100)
  236. linear = LinearDiscriminantAnalysis(solver='lsqr')
  237.  
  238. # Tworzymy sobie listy do przechowywania wynikow uczenia.
  239. # Każada lista będzie miała 88 wynikow. Bo każdy robot będzie testsowany na zasadzie:
  240. # 1 robot testujący : 97 robotow uczących
  241. print("Init outpusts...")
  242. output_ada = []
  243. output_knn_1 = []
  244. output_d_tress = []
  245. output_gauss = []
  246. output_gbc = []
  247. output_extra_tress = []
  248. output_lr = []
  249. output_mlp = []
  250. output_rand_fores = []
  251. output_linear = []
  252.  
  253. # Teraz będziemy robić pętle o 88 powótrzeniach, tak, żeby każdego robota walidować dokładnie raz.
  254. # Tutaj w kazej iteracji od nowa uczony jest klasyfikator wszystkimi robotami poza tym, za pomocą którego będziemy testować.
  255. class_iterator = 1
  256. for train_indexes, test_indexes in kf.split(X): # Zapis "kf.split(x)" zwroci nam jakis obiekt o 88 wartościach.
  257.     # W tych warościach będą indeksy konkretnych obiektów. Podział tutaj zachodzi automatycznie.
  258.     print("\n\n\n################ ada ", class_iterator, '/', kf.n_splits, "################") # wypisujemy którą lecimy pętle oraz ile  ma być w sumie
  259.     print("train idexes:", train_indexes, "\n test indexes:", test_indexes) # podejrzyjmy indeksy których danych będziemy testować.
  260.     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
  261.     print("\n test X:", X.loc[test_indexes])
  262.  
  263.     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
  264.     Y_train = Y.loc[train_indexes] # tutaj etykiety uczące
  265.     X_test = X.loc[test_indexes]
  266.     Y_test = Y.loc[test_indexes]
  267.  
  268.     ada.fit(X_train, Y_train) # tutaj trenujemy sobie wszytkie klasfikatory, jeden po drugim, wszystkie mają te same dane
  269.     knn_1.fit(X_train, Y_train)
  270.     d_tress.fit(X_train, Y_train)
  271.     gauss.fit(X_train, Y_train)
  272.     gbc.fit(X_train, Y_train)
  273.     extra_tress.fit(X_train, Y_train)
  274.     lr.fit(X_train, Y_train)
  275.     mlp.fit(X_train, Y_train)
  276.     rand_fores.fit(X_train, Y_train)
  277.     linear.fit(X_train, Y_train)
  278.  
  279.     output_ada.append( ada.score(X_test, Y_test)*100) # dodajemy wynik z każdej klasyfikacji do listy. Na przyklad:
  280.     # W 1 iteracji będzie testowany robot 1, wiec wynik jego testtu zostanie wrzucone do tej zmiennej jako 1.
  281.     # Mnozymy *100 zeby miec w [%]
  282.     output_knn_1.append( knn_1.score(X_test, Y_test)*100)
  283.     output_d_tress.append(d_tress.score(X_test, Y_test)*100)
  284.     output_gauss.append(gauss.score(X_test, Y_test)*100)
  285.     output_gbc.append(gbc.score(X_test, Y_test)*100)
  286.     output_extra_tress.append(extra_tress.score(X_test, Y_test)*100)
  287.     output_lr.append(lr.score(X_test, Y_test)*100)
  288.     output_mlp.append(mlp.score(X_test, Y_test)*100)
  289.     output_rand_fores.append(rand_fores.score(X_test, Y_test)*100)
  290.     output_linear.append(linear.score(X_test, Y_test)*100)
  291.  
  292.     class_iterator += 1 # zwiekszamy zmianna, żeby wiedziec którą robimy iteracje.
  293.  
  294.     # W tym miejscu kodu mamy już coś w listach "output_costam" z wynikami, zobaczymy więc jak wygląda wynik obecnej iteracja.
  295.     # Czyli interesuje nas ostatni wynik, właśnie z obecnej iteracji, który sie dodał do listy pare linijek wyżej.
  296.     # Zapis [-1] daje nam ostatni element z danej listy. -1 to indeks ostatniej wartosci.
  297.     print("################",
  298.           "output_ada=", output_ada[-1], "% ",
  299.           "output_knn_1=", output_knn_1[-1], "% ",
  300.           "output_d_tress=", output_d_tress[-1], "% ",
  301.           "output_gauss=", output_gauss[-1], "% ",
  302.           "output_gbc=", output_gbc[-1], "% ",
  303.           "output_extra_tress=", output_extra_tress[-1], "% ",
  304.           "output_lr=", output_lr[-1], "% ",
  305.           "output_mlp=", output_mlp[-1], "% ",
  306.           "output_rand_fores=", output_rand_fores[-1], "% ",
  307.           "output_linear=", output_linear[-1], "% ",
  308.           "################")
  309.  
  310. print("\n\n\n################ ############ #########")
  311. print("################ Output data ################")
  312. print("################ ################ ###########")
  313.  
  314. # Niżej to co nas najbardziej interesuje.
  315. # są tutaj średnie da danych klasyfikatorow. to jest wynik końcowy.
  316. # 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ą.
  317. print("output_ada ", mean(output_ada ))
  318. print("output_knn_1 ", mean(output_knn_1 ))
  319. print("output_d_tress ", mean(output_d_tress ))
  320. print("output_gauss ", mean(output_gauss ))
  321. print("output_gbc ", mean(output_gbc ))
  322. print("output_extra_tress ", mean(output_extra_tress ))
  323. print("output_lr ", mean(output_lr ))
  324. print("output_mlp ", mean(output_mlp ))
  325. print("output_rand_fores ", mean( output_rand_fores))
  326. print("output_linear ", mean(output_linear ))
RAW Paste Data