SHARE
TWEET

Untitled

a guest Dec 9th, 2019 74 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
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top