======= ML i sieci neuronowe: Wstęp======= ====== Wprowadzenie do przetwarzania danych z pakietami numpy i pandas ====== import numpy as np import pandas as pd # Wprowadzenie do numpy lista=[4,6,7,6,5,43,12,3,7,11,3,6] [x**2 for x in lista] tablica=np.array(lista) print(tablica,type(tablica), tablica.dtype) tablica**2 [ 4 6 7 6 5 43 12 3 7 11 3 6] int64 array([ 16, 36, 49, 36, 25, 1849, 144, 9, 49, 121, 9, 36]) # Tablice wielowymiarowe m1=np.array([[4,7,2],[3,5,8]]) m1 array([[4, 7, 2], [3, 5, 8]]) # TAblice specjalne np.zeros((4,6)) array([[0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0.]]) # TAblice specjalne np.ones((4,6)) array([[1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1.]]) # genowanie sekwencji jako tablicy t1=np.arange(-8,8,0.01) t1 array([-8. , -7.99, -7.98, ..., 7.97, 7.98, 7.99]) t2=np.linspace(-1,1,10) t2 array([-1. , -0.77777778, -0.55555556, -0.33333333, -0.11111111, 0.11111111, 0.33333333, 0.55555556, 0.77777778, 1. ]) # Indeksowanie tablicy print(tablica[2]) print(tablica[2:5]) 7 [7 6 5] # zmiana kształtu tablicy m1=tablica.reshape((3,4)) m1 array([[ 4, 6, 7, 6], [ 5, 43, 12, 3], [ 7, 11, 3, 6]]) m1**2 array([[ 16, 36, 49, 36], [ 25, 1849, 144, 9], [ 49, 121, 9, 36]]) m1[0:2,0:2] array([[ 4, 6], [ 5, 43]]) # Operacje na tablicach tb1=np.array([5,3,9]) tb2=np.array([3,1,7]) print(tb1+tb2) print(tb1*tb2) print(tb1**2) print(tb1>5) [ 8 4 16] [15 3 63] [25 9 81] [False False True] # Funkcje statystyczne na tablicach print(tablica) np.mean(tablica) [ 4 6 7 6 5 43 12 3 7 11 3 6] np.float64(9.416666666666666) print(tablica) print(tablica.mean()) print(tablica.std()) [ 4 6 7 6 5 43 12 3 7 11 3 6] 9.416666666666666 10.467874134173035 # Wygenerowanie tablicy losowej np.random.seed(33) m1=np.random.randint(0,10,(5,5)) m1 array([[4, 7, 8, 2, 2], [9, 9, 3, 6, 3], [3, 1, 7, 6, 0], [0, 6, 6, 0, 4], [8, 8, 3, 7, 9]]) # Statystyki z wierszy print(m1.mean(axis=1)) print(m1.max(axis=1)) [4.6 6. 3.4 3.2 7. ] [8 9 7 6 9] # Statystyki z kolumn print(m1.mean(axis=0)) print(m1.max(axis=0)) [4.8 6.2 5.4 4.2 3.6] [9 9 8 7 9] ====== Wprowadzenie do pakietu pandas ====== import numpy as np import pandas as pd # Typ danych series s1=pd.Series([5,7,3,2,8,9]) print(s1,type(s1)) 0 5 1 7 2 3 3 2 4 8 5 9 dtype: int64 print(s1[2]) print(s1[1:4]) 3 1 7 2 3 3 2 dtype: int64 s1=pd.Series([5,7,3,2,8,9],index=['a','a','b','c','b','a']) print(s1,type(s1)) a 5 a 7 b 3 c 2 b 8 a 9 dtype: int64 s1['a'] a 5 a 7 a 9 dtype: int64 s1[1:4] a 7 b 3 c 2 dtype: int64 # Operacje na sieriach s1**2 a 25 a 49 b 9 c 4 b 64 a 81 dtype: int64 # Typ DataFrame dane={ 'Imię':['Ola','Tola','Ula','Ala','Zula','Ela'], 'Wiek':[23,18,34,27,17,32], 'Miasto' : ['Warszawa','Opole','Opole','Sopot','Warszawa','Sopot'], 'Pensja' : [6700,5432,8760,6450,5670,8245] } tb=pd.DataFrame(dane) tb.to_csv(".\Dane2.csv") tb=pd.read_csv(".\Dane2.csv") tb Unnamed: 0 Imię Wiek Miasto Pensja 0 0 Ola 23 Warszawa 6700 1 1 Tola 18 Opole 5432 2 2 Ula 34 Opole 8760 3 3 Ala 27 Sopot 6450 4 4 Zula 17 Warszawa 5670 5 5 Ela 32 Sopot 8245 #Wstępne badanie DataFrame tb.info() RangeIndex: 6 entries, 0 to 5 Data columns (total 5 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Unnamed: 0 6 non-null int64 1 Imię 6 non-null object 2 Wiek 6 non-null int64 3 Miasto 6 non-null object 4 Pensja 6 non-null int64 dtypes: int64(3), object(2) memory usage: 368.0+ bytes tb.shape (6, 5) tb.describe() Unnamed: 0 Wiek Pensja count 6.000000 6.000000 6.000000 mean 2.500000 25.166667 6876.166667 std 1.870829 7.082843 1354.669025 min 0.000000 17.000000 5432.000000 25% 1.250000 19.250000 5865.000000 50% 2.500000 25.000000 6575.000000 75% 3.750000 30.750000 7858.750000 max 5.000000 34.000000 8760.000000 #Filtrowanie danych w=tb['Wiek']>20 tb[w] Unnamed: 0 Imię Wiek Miasto Pensja 0 0 Ola 23 Warszawa 6700 2 2 Ula 34 Opole 8760 3 3 Ala 27 Sopot 6450 5 5 Ela 32 Sopot 8245 # Grupowanie danych tb Unnamed: 0 Imię Wiek Miasto Pensja 0 0 Ola 23 Warszawa 6700 1 1 Tola 18 Opole 5432 2 2 Ula 34 Opole 8760 3 3 Ala 27 Sopot 6450 4 4 Zula 17 Warszawa 5670 5 5 Ela 32 Sopot 8245 tb.groupby('Miasto')['Pensja'].mean() Miasto Opole 7096.0 Sopot 7347.5 Warszawa 6185.0 Name: Pensja, dtype: float64 # Indeksowanie za pomocą metod iloc i loc dane= { 'Imię': ['Anna', 'Marek', 'Ewa', 'Piotr', 'Kasia'], 'Wiek': [28, 35, 22, 45, 30], 'Miasto': ['Warszawa', 'Kraków', 'Warszawa', 'Gdańsk', 'Kraków'], 'Dochód': [3500, 4000, 2800, 5000, 4200] } tb1=pd.DataFrame(dane,index=['a','a','b','c','d']) tb1 Imię Wiek Miasto Dochód a Anna 28 Warszawa 3500 a Marek 35 Kraków 4000 b Ewa 22 Warszawa 2800 c Piotr 45 Gdańsk 5000 d Kasia 30 Kraków 4200 tb1.head(3) Imię Wiek Miasto Dochód a Anna 28 Warszawa 3500 a Marek 35 Kraków 4000 b Ewa 22 Warszawa 2800 tb1.tail(2) Imię Wiek Miasto Dochód c Piotr 45 Gdańsk 5000 d Kasia 30 Kraków 4200 #Indeksowanie metodą loc tb1.loc['a'] Imię Wiek Miasto Dochód a Anna 28 Warszawa 3500 a Marek 35 Kraków 4000 tb1['Wiek'] a 28 a 35 b 22 c 45 d 30 Name: Wiek, dtype: int64 tb1.loc[['a','c'],['Wiek','Miasto']] Wiek Miasto a 28 Warszawa a 35 Kraków c 45 Gdańsk tb1.loc['a':'c','Wiek':'Dochód'] Wiek Miasto Dochód a 28 Warszawa 3500 a 35 Kraków 4000 b 22 Warszawa 2800 c 45 Gdańsk 5000 #Indeksowanie metod iloc tb1.iloc[2] Imię Ewa Wiek 22 Miasto Warszawa Dochód 2800 Name: b, dtype: object tb1.iloc[2,3] np.int64(2800) tb1.iloc[1:3,0:2] Imię Wiek a Marek 35 b Ewa 22 tb1.iloc[[0,2],[2,3]] Miasto Dochód a Warszawa 3500 b Warszawa 2800 tb1['Wiek'].plot(color='red') {{output_45_1.png|png}} png ====== Spotkanie 3 ====== ====== Tutorial do wizualizacji danych ====== ==== Autor: Chat GPT 4.5 ==== ====== Wykres liniowy ====== - Opis wykresu liniowego (Line plot) Wykres liniowy jest podstawowym i najczęściej wykorzystywanym rodzajem wykresu do przedstawiania danych ciągłych, które zmieniają się w czasie lub wzdłuż osi niezależnej. Pozwala w prosty i czytelny sposób pokazać trendy, wzrosty lub spadki oraz porównać kilka zbiorów danych jednocześnie. Podstawowymi elementami wykresu liniowego są: Oś pozioma (x) reprezentująca dane niezależne (np. czas, daty, numery indeksów). Oś pionowa (y) reprezentująca dane zależne. Punkty danych, które są połączone linią, pokazujące trend. - Typowe zastosowania Analiza trendów – obserwacja zmian wartości w czasie (np. ceny akcji, zmiany temperatury). Porównywanie zbiorów danych – zestawienie wielu serii danych, np. wyniki eksperymentów lub porównanie różnych produktów. Prognozowanie – obserwacja dotychczasowego rozwoju oraz przewidywanie przyszłych wartości. Analiza danych finansowych – prezentowanie trendów cen, indeksów giełdowych, walut, kryptowalut. Monitorowanie procesów technicznych – np. wydajność systemu komputerowego lub procesów produkcyjnych. - Maksymalny potencjał wykresu liniowego – przykład w Pythonie Poniżej kompleksowy przykład ukazujący pełnię możliwości wykresu liniowego, wykorzystujący bibliotekę Matplotlib: import matplotlib.pyplot as plt import numpy as np import pandas as pd # Generowanie realistycznych danych np.random.seed(42) dni = pd.date_range(start='2024-01-01', periods=30) # generowanie temperatur wokół zadanych średnich temperatura_warszawa = np.random.normal(loc=2, scale=3, size=30) temperatura_gdansk = np.random.normal(loc=0, scale=2, size=30) temperatura_krakow = np.random.normal(loc=1, scale=4, size=30) # Tworzenie DataFrame df = pd.DataFrame({ 'Data': dni, 'Warszawa': temperatura_warszawa, 'Gdańsk': temperatura_gdansk, 'Kraków': temperatura_krakow }) # Rysowanie wykresu plt.figure(figsize=(12, 6),dpi=100,facecolor='lime') # Linie z różnymi stylami plt.plot(df['Data'], df['Warszawa'], label='Warszawa', linestyle='-', linewidth=2, marker='o',color='magenta') plt.plot(df['Data'], df['Gdańsk'], label='Gdańsk', linestyle='--', linewidth=2, marker='s') plt.plot(df['Data'], df['Kraków'], label='Kraków', linestyle='-.', linewidth=2, marker='^') # Tytuł i opisy osi plt.title('Temperatura w styczniu 2024 w wybranych miastach Polski', fontsize=16, fontweight='bold') plt.xlabel('Data', fontsize=14) plt.ylabel('Temperatura [°C]', fontsize=14) # Siatka pomocnicza plt.grid(True, linestyle='--', alpha=0.5) # Adnotacje – oznacz najwyższą temperaturę w Warszawie i najniższą w Gdańsku max_warszawa = df['Warszawa'].idxmax() min_gdansk = df['Gdańsk'].idxmin() plt.annotate(f"Max Warszawa ({df['Warszawa'].max():.1f}°C)", xy=(df['Data'][max_warszawa], df['Warszawa'][max_warszawa]), xytext=(df['Data'][max_warszawa], df['Warszawa'][max_warszawa]+4), arrowprops=dict(facecolor='green', arrowstyle='->')) plt.annotate(f"Min Gdańsk ({df['Gdańsk'].min():.1f}°C)", xy=(df['Data'][min_gdansk], df['Gdańsk'][min_gdansk]), xytext=(df['Data'][min_gdansk], df['Gdańsk'][min_gdansk]-5), arrowprops=dict(facecolor='red', arrowstyle='->')) # Poprawienie czytelności osi x plt.xticks(rotation=45) # Legenda plt.legend(title='Miasta', fontsize=12) # Dopasowanie layoutu plt.tight_layout() # Wyświetlenie wykresu plt.show() {{output_3_0.png|png}} png - Omówienie uzyskanego efektu Kilka serii danych: Wyraźnie zaprezentowane trzy serie danych (temperatura w trzech miastach). Różne style linii: Rozróżnienie serii za pomocą koloru, stylu linii oraz markerów punktów. Adnotacje: Podkreślenie ważnych informacji (najwyższa/najniższa wartość). Czytelność: Wyraźnie oznaczone osie, legenda i siatka pomagają w interpretacji. Wizualizacja czasowa: Oś pozioma z datami ułatwia interpretację zmiany danych w czasie. ====== Wykresy słupkowe ====== . 📌 1. Opis wykresów słupkowych Wykres słupkowy (bar chart) pozwala porównać wartości danych dla różnych kategorii. Każdy słupek reprezentuje wartość liczbową przypisaną do określonej kategorii. Wykres słupkowy skumulowany (stacked bar chart) umożliwia porównanie sumarycznych wartości dla kategorii, jednocześnie pokazując wkład poszczególnych składowych w te sumy. Cechy charakterystyczne: Wizualizacja danych kategorycznych Czytelne porównanie wartości Pokazanie udziałów części składowych (słupki skumulowane) 📌 2. Typowe zastosowania 🔹 Wykres słupkowy: Porównanie sprzedaży według kategorii produktów. Wyniki wyborów lub badań opinii publicznej. Porównywanie wyników finansowych firm. 🔹 Wykres słupkowy skumulowany: Struktura kosztów lub przychodów firmy. Podział populacji według wieku w różnych regionach. Prezentacja wyników ankiet wielokrotnego wyboru. import matplotlib.pyplot as plt import pandas as pd import numpy as np # Tworzenie przykładowych danych produkty = ['Laptop', 'Smartfon', 'Tablet', 'Smartwatch'] sprzedaz_2023 = [1200, 2500, 900, 400] sprzedaz_2024 = [1500, 2700, 1100, 600] # Pozycja słupków na osi x x = np.arange(len(produkty)) # Rysowanie wykresu plt.figure(figsize=(10,6),facecolor='lightgray') # Słupki dla 2023 i 2024 obok siebie plt.bar(x - 0.2, sprzedaz_2023, width=0.4, label='2023', edgecolor='black') plt.bar(x + 0.2, sprzedaz_2024, width=0.4, label='2024', edgecolor='black') # Tytuł, etykiety, siatka plt.title('Porównanie sprzedaży produktów (2023 vs 2024)', fontsize=16) plt.xlabel('Kategoria produktu', fontsize=14) plt.ylabel('Liczba sprzedanych sztuk', fontsize=14) plt.xticks(x, produkty, fontsize=12) plt.grid(axis='y', linestyle='--', alpha=0.7) # Dodanie wartości liczbowych na słupkach for i in x: plt.text(i - 0.2, sprzedaz_2023[i] + 50, sprzedaz_2023[i], ha='center', fontsize=11) plt.text(i + 0.2, sprzedaz_2024[i] + 50, sprzedaz_2024[i], ha='center', fontsize=11) # Legenda plt.legend(title='Rok') # Wyświetlenie wykresu plt.tight_layout() plt.show() {{output_7_0.png|png}} png import matplotlib.pyplot as plt import pandas as pd import numpy as np # Tworzenie przykładowych danych miasta = ['Warszawa', 'Kraków', 'Gdańsk', 'Poznań'] zarobki_niskie = [25, 35, 30, 28] zarobki_srednie = [50, 45, 48, 52] zarobki_wysokie = [25, 20, 22, 20] # Tworzenie DataFrame df = pd.DataFrame({ 'Miasto': miasta, 'Niskie': zarobki_niskie, 'Średnie': zarobki_srednie, 'Wysokie': zarobki_wysokie }) # Pozycja słupków na osi x x = np.arange(len(df)) # Rysowanie wykresu plt.figure(figsize=(10,6),facecolor='lightgreen') # Skumulowane słupki plt.bar(df['Miasto'], df['Niskie'], label='Niskie', edgecolor='black') plt.bar(df['Miasto'], df['Średnie'], bottom=df['Niskie'], label='Średnie', edgecolor='black') plt.bar(df['Miasto'], df['Wysokie'], bottom=df['Niskie'] + df['Średnie'], label='Wysokie', edgecolor='black') # Tytuł, etykiety, siatka plt.title('Rozkład wynagrodzeń w wybranych miastach [%]', fontsize=16) plt.xlabel('Miasto', fontsize=14) plt.ylabel('Udział procentowy [%]', fontsize=14) plt.grid(axis='y', linestyle='--', alpha=0.7) # Dodanie wartości liczbowych na słupkach for i in range(len(df)): plt.text(x[i], zarobki_niskie[i]/2, f"{zarobki_niskie[i]}%", ha='center', va='center', fontsize=11, color='white') plt.text(x[i], zarobki_niskie[i] + zarobki_srednie[i]/2, f"{zarobki_srednie[i]}%", ha='center', va='center', fontsize=11, color='white') plt.text(x[i], zarobki_niskie[i] + zarobki_srednie[i] + zarobki_wysokie[i]/2, f"{zarobki_wysokie[i]}%", ha='center', va='center', fontsize=11, color='white') # Legenda plt.legend(title='Poziom zarobków') # Wyświetlenie wykresu plt.tight_layout() plt.show() {{output_8_0.png|png}} png ====== 📌 4. Podsumowanie możliwości wykresów słupkowych: ====== Dzięki zaawansowanym opcjom wizualizacyjnym Python oferuje potężne narzędzia do prezentowania danych kategorycznych w przejrzysty i estetyczny sposób. Dodając szczegółowe opisy, dane liczbowe, różnorodne style graficzne oraz układy skumulowane, wykresy słupkowe stają się niezwykle skuteczne w komunikacji wizualnej, zwiększając ich informacyjny i analityczny potencjał. ====== Wykres kołowy ====== 📌 1. Opis wykresu kołowego Wykres kołowy (ang. pie chart) jest wykresem używanym do prezentowania proporcji, czyli udziału poszczególnych kategorii w całości. Każdy fragment (wycinek koła) reprezentuje jedną kategorię, a rozmiar tego fragmentu odzwierciedla jego udział procentowy w całkowitej sumie wartości wszystkich kategorii. Charakterystyczne cechy: Wizualizacja danych procentowych. Przedstawienie relacji między częścią a całością. Prosty, intuicyjny odbiór. 📌 2. Typowe zastosowania Wykresy kołowe są używane głównie do: Prezentacji struktury przychodów lub kosztów firmy. Analizy wyników ankiet i badań rynkowych. Pokazania udziału różnych produktów w sprzedaży. Prezentacji udziałów rynkowych firm w sektorze. Ważne, by liczba kategorii była umiarkowana (najlepiej do 6-8), ponieważ duża liczba kategorii zmniejsza czytelność. 📌 3. Zaawansowany przykład wykresu kołowego w Pythonie (pełny potencjał) Poniższy przykład maksymalnie wykorzystuje możliwości biblioteki Matplotlib do stworzenia atrakcyjnego i czytelnego wykresu kołowego. import matplotlib.pyplot as plt import pandas as pd import numpy as np # Dane – udział firm na rynku smartfonów udzialy = [28, 35, 17, 13, 10, 7] firmy = ['Samsung', 'Apple', 'Xiaomi', 'OPPO', 'Vivo', 'Inne'] # Automatyczne wyróżnienie największego kawałka explode = [0.1 if val == max(udzialy) else 0 for val in udzialy] # Kolory (opcjonalnie) colors = plt.cm.Paired.colors # Tworzenie wykresu kołowego plt.figure(figsize=(9, 9),facecolor='lightgray') wedges, texts, autotexts = plt.pie( udzialy, labels=firmy, autopct='%1.1f%%', startangle=140, explode=explode, # automatyczne wyróżnienie colors=colors, shadow=True, wedgeprops=dict(edgecolor='black', linewidth=1), textprops={'fontsize': 13} ) # Tytuł wykresu plt.title('Udziały producentów smartfonów na rynku (2024)', fontsize=16, fontweight='bold') # Dodanie legendy plt.legend(wedges, firmy, title="Firmy", loc="best", bbox_to_anchor=(1, 0, 0.5, 1), fontsize=11) # Zapewnienie równego koła (nie elipsy) plt.axis('equal') # Wyświetlenie wykresu plt.tight_layout() plt.show() {{output_12_0.png|png}} png 📌 4. Omówienie efektów tego wykresu: Powyższy wykres demonstruje, jak maksymalnie wykorzystać potencjał wykresu kołowego: Eksplozja (explode) – wyróżnia szczególnie ważną kategorię. Wyświetlanie procentów – czytelna prezentacja udziałów każdej kategorii. Cienie i krawędzie – estetyczne dodatki poprawiające odbiór. Kolorystyka – wyraźne i różnorodne kolory zwiększają atrakcyjność wizualną. Legenda i opisy – ułatwiają szybkie odniesienie do kategorii danych. Dzięki temu wykres kołowy staje się czytelny, estetyczny, profesjonalny, a przede wszystkim bardzo skuteczny w przekazywaniu kluczowych informacji. ⚠️ Ważna wskazówka na koniec: Używaj wykresów kołowych z rozwagą – pamiętaj, że ich największą zaletą jest prezentacja niewielkiej liczby kategorii. Przy dużej liczbie kategorii rozważ inne wykresy (np. słupkowe poziome lub wykresy typu donut). ====== Wykres pudełkowy i skrzypcowy ====== 📌 1. Opis wykresów 🟢 Wykres pudełkowy (Boxplot) Wykres pudełkowy (boxplot) wizualizuje rozkład danych za pomocą kilku kluczowych statystyk opisowych: mediana (linia środkowa pudełka) pierwszy i trzeci kwartyl (Q1 i Q3 – brzegi pudełka) wąsy (rozstęp danych: min/max lub wartości odstające) wartości odstające, zaznaczane jako punkty poza pudełkiem. Dzięki temu umożliwia on szybkie porównanie rozkładów wielu grup danych oraz identyfikację wartości odstających. 🟢 Wykres violinowy (Violin plot) Wykres violinowy łączy zalety wykresu pudełkowego z wykresem gęstości (KDE). Pokazuje nie tylko podstawowe statystyki rozkładu (mediana, kwartyle), ale też szczegółowy kształt rozkładu, uwypuklając takie cech jak wielomodalność, asymetria czy zagęszczenie danych. 📌 2. Typowe zastosowania Oba typy wykresów są powszechnie stosowane do: Analizy porównawczej kilku grup danych. Identyfikacji wartości odstających (boxplot). Badania rozkładów danych liczbowych (czas oczekiwania, wyniki testów, pensje). Wizualizacji rozkładów danych numerycznych dla poszczogólnych kategorii. Przykładowe obszary zastosowań: Analizy statystyczne i badania naukowe. Wizualizacja danych w finansach (np. zmienność cen akcji). Badania satysfakcji, ocenianie wyników testów itp. 📌 3. Zaawansowany przykład realizacji wykresów w Pythonie import matplotlib.pyplot as plt import seaborn as sns import numpy as np import pandas as pd # Generowanie danych przykładowych np.random.seed(0) df = pd.DataFrame({ 'Grupa': np.repeat(['Grupa A', 'Grupa B', 'Grupa C'], 100), 'Wynik': np.concatenate([ np.random.normal(70, 10, 100), np.random.normal(75, 15, 100), np.random.normal(65, 20, 100) ]) }) # Rozmiar figur plt.figure(figsize=(14, 6),facecolor='lightblue') # --------------- Wykres pudełkowy ---------------- plt.subplot(1, 2, 1) sns.boxplot(x='Grupa', y='Wynik', data=df, palette='Pastel1', linewidth=2) # Dodanie punktów indywidualnych obserwacji sns.stripplot(x='Grupa', y='Wynik', data=df, color='black', alpha=0.5, jitter=True) # Tytuł i opisy plt.title('Wykres pudełkowy (Boxplot) z punktami danych', fontsize=15, fontweight='bold') plt.xlabel('Grupa', fontsize=13) plt.ylabel('Wynik', fontsize=13) plt.grid(axis='y', linestyle='--', alpha=0.6) # --------------- Violin Plot ---------------- plt.subplot(1, 2, 2) sns.violinplot(x='Grupa', y='Wynik', data=df, palette='Pastel2', inner='quartile', linewidth=2) # Dodanie mediany sns.pointplot(x='Grupa', y='Wynik', data=df, estimator=np.median, color='black', markers='D', scale=0.5) plt.title('Rozkład wyników - Violin Plot', fontsize=15, fontweight='bold') plt.xlabel('Grupa', fontsize=13) plt.ylabel('Wynik', fontsize=13) plt.grid(axis='y', linestyle='--', alpha=0.6) # Poprawienie układu wykresów plt.tight_layout() # Wyświetlenie wykresów plt.show() /tmp/ipykernel_170226/2987352356.py:22: FutureWarning: Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect. sns.boxplot(x='Grupa', y='Wynik', data=df, palette='Pastel1', linewidth=2) /tmp/ipykernel_170226/2987352356.py:35: FutureWarning: Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect. sns.violinplot(x='Grupa', y='Wynik', data=df, palette='Pastel2', inner='quartile', linewidth=2) /tmp/ipykernel_170226/2987352356.py:38: UserWarning: The `scale` parameter is deprecated and will be removed in v0.15.0. You can now control the size of each plot element using matplotlib `Line2D` parameters (e.g., `linewidth`, `markersize`, etc.). sns.pointplot(x='Grupa', y='Wynik', data=df, estimator=np.median, color='black', markers='D', scale=0.5) {{output_16_1.png|png}} png ====== Wykresy funkcji dwóch zmiennych ====== 📌 Opis wykresu przestrzennego (3D Surface Plot) Wykres przestrzenny (ang. 3D surface plot) przedstawia zależność wartości jednej zmiennej od dwóch innych zmiennych. Dzięki trójwymiarowej reprezentacji łatwo można zaobserwować wzajemne powiązania oraz szybko zidentyfikować trendy, wzory lub ekstremalne wartości. Wykresy powierzchniowe doskonale sprawdzają się przy analizie danych złożonych, które zmieniają się wraz z dwoma niezależnymi zmiennymi. 📌 Zastosowania wykresów przestrzennych Wizualizacja danych naukowych (np. fizyka, chemia, biologia). Analiza funkcji matematycznych (np. rozkłady prawdopodobieństwa). Badanie efektywności modeli predykcyjnych (ML, Deep Learning). Prezentacja danych meteorologicznych (np. temperatury, opady w terenie). Wizualizacja potencjałów lub ryzyka w analizach finansowych import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D #%matplotlib notebook %matplotlib ipympl # Generowanie danych x = np.linspace(-5, 5, 50) y = np.linspace(-5, 5, 50) X, Y = np.meshgrid(x, y) # Funkcja Z zależna od X i Y Z = np.sin(np.sqrt(X**2 + Y**2)) # Tworzenie wykresu fig = plt.figure(figsize=(10, 7)) ax = fig.add_subplot(111, projection='3d') # Tworzenie powierzchni (surface plot) surf = ax.plot_surface(X, Y, Z, cmap='viridis', edgecolor='none', alpha=0.9) # Dodanie paska kolorów fig.colorbar(surf, shrink=0.5, aspect=10) # Tytuł oraz opisy osi ax.set_title('Wykres funkcji przestrzennej Z = sin(√(X² + Y²))', fontsize=15, fontweight='bold') ax.set_xlabel('Oś X', fontsize=12) ax.set_ylabel('Oś Y', fontsize=12) ax.set_zlabel('Oś Z', fontsize=12) # Zmiana kąta widzenia ax.view_init(elev=25, azim=15) # Wyświetlenie wykresu plt.tight_layout() plt.show()
Figure
====== Spotkanie 5 ====== import numpy as np import matplotlib.pyplot as plt from sklearn.linear_model import LinearRegression # Generowanie przykładowych danych np.random.seed(6767) X = np.linspace(0, 10, 200) y = 2.5 * X + 3+np.random.normal(0, 2, size=X.shape) # dane z szumem X= X.reshape(-1, 1) model = LinearRegression() model.fit(X,y) y_pred = model.predict(X) print(model.coef_) print(model.intercept_) # Wizualizacja wyników plt.figure(figsize=(10, 6)) plt.scatter(X, y, color='blue', alpha=0.6, label='Dane rzeczywiste') plt.plot(X, y_pred, color='red', linewidth=2, label='Regresja liniowa') plt.xlabel('X') plt.ylabel('y') plt.title('Regresja liniowa - dopasowanie modelu') plt.legend() plt.grid(True) plt.show() [2.54483697] 2.870468659238794 {{output_0_1.png|png}} png # CZy widać ocieplenie klimatu import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.linear_model import LinearRegression from sqlalchemy import create_engine connection_string = ( "mssql+pyodbc://student:ciekawski@analityk.wwsi.edu.pl,50221/Synop?driver=ODBC+Driver+17+for+SQL+Server" ) engine = create_engine(connection_string) query = """ Select year(data) as Rok, round(avg(TemperaturaPowietrza),2) as [Średnia temperatura] from Depesze where stacja=12375 and data between'20000101' and '20241231' and godzina='12:00' group by year(data) order by 1 """ dane=pd.read_sql(query, engine) X=dane['Rok'].values.reshape(-1, 1) y=dane['Średnia temperatura'] model=LinearRegression().fit(X,y) y_pred=model.predict(X) # Wizualizacja danych wraz z linią regresji plt.figure(figsize=(10, 6)) plt.scatter(dane['Rok'], dane['Średnia temperatura'], color='blue', alpha=0.6, label='Dane rzeczywiste') plt.plot(dane['Rok'], y_pred, color='red', linewidth=2, label='Linia regresji') plt.title('Średnia temperatura w Warszawie (2000-2023)') plt.xlabel('Rok') plt.ylabel('Średnia temperatura (°C)') plt.legend() plt.grid(True) plt.show() {{output_1_0.png|png}} png ====== Spotkanie 6 ====== # Import bibliotek import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.datasets import load_wine from sklearn.model_selection import cross_val_score # Algorytmy klasyfikacji from sklearn.tree import DecisionTreeClassifier from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import SVC from sklearn.ensemble import RandomForestClassifier data = load_wine() X = data.data y = data.target #print(X) #print(y) # Lista modeli do porównania models = [ ('Drzewo Decyzyjne', DecisionTreeClassifier()), ('k-NN', KNeighborsClassifier()), ('SVM', SVC()), ('Las Losowy', RandomForestClassifier()) ] # Walidacja krzyżowa i przechowywanie wyników results = [] names = [] for name, model in models: cv_scores = cross_val_score(model, X, y, cv=10, scoring='accuracy') results.append(cv_scores) names.append(name) print(f'{name}: średnia dokładność = {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})') # Wykres pudełkowy wyników walidacji krzyżowej plt.figure(figsize=(10, 6)) plt.boxplot(results, tick_labels=names) plt.title('Porównanie modeli klasyfikacji (walidacja krzyżowa)') plt.ylabel('Dokładność') plt.grid(True) plt.show() Drzewo Decyzyjne: średnia dokładność = 0.859 (+/- 0.095) k-NN: średnia dokładność = 0.675 (+/- 0.070) SVM: średnia dokładność = 0.681 (+/- 0.087) Las Losowy: średnia dokładność = 0.977 (+/- 0.028) {{output_0_1.png|png}} png ======= Spotkanie 8 ======= import numpy as np import matplotlib.pyplot as plt from keras.layers import Dense, Flatten,Dropout,Conv2D,MaxPooling2D from keras.models import Sequential from keras.utils import to_categorical from keras.datasets import mnist (X_train, y_train), (X_test, y_test) = mnist.load_data() obraz, obszary = plt.subplots(ncols=5, sharex=False, sharey=True, figsize=(10, 4)) for i in range(5): obszary[i].set_title(y_train[i]) obszary[i].imshow(X_train[i], cmap='gray') obszary[i].get_xaxis().set_visible(False) obszary[i].get_yaxis().set_visible(False) X_train.shape (60000, 28, 28) temp = [] for i in range(len(y_train)): temp.append(to_categorical(y_train[i], num_classes=10)) y_train = np.array(temp) temp = [] for i in range(len(y_test)): temp.append(to_categorical(y_test[i], num_classes=10)) y_test = np.array(temp) y_test array([[0., 0., 0., ..., 1., 0., 0.], [0., 0., 1., ..., 0., 0., 0.], [0., 1., 0., ..., 0., 0., 0.], ..., [0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.]]) model=Sequential() model.add(Flatten(input_shape=(28,28))) model.add(Dense(30,activation='sigmoid')) model.add(Dense(10,activation='softmax')) C:\Users\user\anaconda3\envs\tf-env\lib\site-packages\keras\src\layers\reshaping\flatten.py:37: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead. super().__init__(**kwargs) model.summary() model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) model.fit(X_train, y_train, epochs=30, validation_data=(X_test,y_test)) Epoch 1/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.6591 - loss: 1.1976 - val_acc: 0.8627 - val_loss: 0.4906 Epoch 2/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8586 - loss: 0.4965 - val_acc: 0.8737 - val_loss: 0.4288 Epoch 3/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8715 - loss: 0.4334 - val_acc: 0.8783 - val_loss: 0.3984 Epoch 4/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m2s[0m 1ms/step - acc: 0.8731 - loss: 0.4181 - val_acc: 0.8837 - val_loss: 0.3994 Epoch 5/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8804 - loss: 0.3992 - val_acc: 0.8867 - val_loss: 0.3678 Epoch 6/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 2ms/step - acc: 0.8810 - loss: 0.3967 - val_acc: 0.8823 - val_loss: 0.3897 Epoch 7/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 2ms/step - acc: 0.8860 - loss: 0.3771 - val_acc: 0.8923 - val_loss: 0.3606 Epoch 8/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8867 - loss: 0.3791 - val_acc: 0.8945 - val_loss: 0.3498 Epoch 9/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8910 - loss: 0.3633 - val_acc: 0.8944 - val_loss: 0.3601 Epoch 10/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8910 - loss: 0.3698 - val_acc: 0.9007 - val_loss: 0.3241 Epoch 11/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8986 - loss: 0.3333 - val_acc: 0.8960 - val_loss: 0.3465 Epoch 12/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8965 - loss: 0.3349 - val_acc: 0.9051 - val_loss: 0.3203 Epoch 13/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.8987 - loss: 0.3334 - val_acc: 0.9017 - val_loss: 0.3273 Epoch 14/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9017 - loss: 0.3230 - val_acc: 0.9012 - val_loss: 0.3284 Epoch 15/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9048 - loss: 0.3170 - val_acc: 0.8981 - val_loss: 0.3411 Epoch 16/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9016 - loss: 0.3239 - val_acc: 0.9087 - val_loss: 0.3094 Epoch 17/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 2ms/step - acc: 0.9080 - loss: 0.3062 - val_acc: 0.9084 - val_loss: 0.3149 Epoch 18/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9085 - loss: 0.3071 - val_acc: 0.9080 - val_loss: 0.3014 Epoch 19/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9118 - loss: 0.2924 - val_acc: 0.9091 - val_loss: 0.3022 Epoch 20/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9124 - loss: 0.2905 - val_acc: 0.9110 - val_loss: 0.2999 Epoch 21/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9065 - loss: 0.3072 - val_acc: 0.9124 - val_loss: 0.2897 Epoch 22/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9131 - loss: 0.2855 - val_acc: 0.9063 - val_loss: 0.3060 Epoch 23/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9117 - loss: 0.2928 - val_acc: 0.9152 - val_loss: 0.2822 Epoch 24/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9166 - loss: 0.2763 - val_acc: 0.9173 - val_loss: 0.2861 Epoch 25/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 2ms/step - acc: 0.9142 - loss: 0.2826 - val_acc: 0.9085 - val_loss: 0.3033 Epoch 26/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 1ms/step - acc: 0.9140 - loss: 0.2870 - val_acc: 0.9129 - val_loss: 0.2918 Epoch 27/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m2s[0m 1ms/step - acc: 0.9162 - loss: 0.2756 - val_acc: 0.9175 - val_loss: 0.2661 Epoch 28/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m2s[0m 1ms/step - acc: 0.9210 - loss: 0.2651 - val_acc: 0.9173 - val_loss: 0.2832 Epoch 29/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m2s[0m 1ms/step - acc: 0.9164 - loss: 0.2777 - val_acc: 0.9134 - val_loss: 0.2857 Epoch 30/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m3s[0m 2ms/step - acc: 0.9212 - loss: 0.2649 - val_acc: 0.9152 - val_loss: 0.2803 predictions = model.predict(X_test) predictions = np.argmax(predictions, axis=1) predictions [1m313/313[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m0s[0m 977us/step array([7, 2, 1, ..., 4, 5, 6]) obraz, obszary = plt.subplots(ncols=10,nrows=4, sharex=False, sharey=True, figsize=(20, 14)) for i in range(40): obraz.axes[i].set_title(predictions[i]) obraz.axes[i].imshow(X_test[i], cmap='gray') obraz.axes[i].get_xaxis().set_visible(False) obraz.axes[i].get_yaxis().set_visible(False) plt.show() {{output_9_0.png|png}} png model = Sequential([ Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1)), MaxPooling2D(pool_size=(2, 2)), Dropout(0.35), Flatten(), Dense(128, activation='relu'), Dropout(0.3), Dense(10, activation='softmax')]) C:\Users\user\anaconda3\envs\tf-env\lib\site-packages\keras\src\layers\convolutional\base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead. super().__init__(activity_regularizer=activity_regularizer, **kwargs) model.summary() model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) model.fit(X_train, y_train, epochs=30, validation_data=(X_test,y_test)) Epoch 1/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.7554 - loss: 2.4505 - val_acc: 0.9637 - val_loss: 0.1204 Epoch 2/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9412 - loss: 0.2183 - val_acc: 0.9777 - val_loss: 0.0829 Epoch 3/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9584 - loss: 0.1487 - val_acc: 0.9740 - val_loss: 0.0873 Epoch 4/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9639 - loss: 0.1251 - val_acc: 0.9797 - val_loss: 0.0889 Epoch 5/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9683 - loss: 0.1132 - val_acc: 0.9800 - val_loss: 0.0841 Epoch 6/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9723 - loss: 0.1024 - val_acc: 0.9757 - val_loss: 0.0832 Epoch 7/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9732 - loss: 0.0952 - val_acc: 0.9822 - val_loss: 0.0841 Epoch 8/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9768 - loss: 0.0841 - val_acc: 0.9804 - val_loss: 0.0834 Epoch 9/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m17s[0m 9ms/step - acc: 0.9760 - loss: 0.0881 - val_acc: 0.9817 - val_loss: 0.0753 Epoch 10/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 9ms/step - acc: 0.9788 - loss: 0.0755 - val_acc: 0.9834 - val_loss: 0.0765 Epoch 11/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m15s[0m 8ms/step - acc: 0.9796 - loss: 0.0740 - val_acc: 0.9806 - val_loss: 0.0878 Epoch 12/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9793 - loss: 0.0710 - val_acc: 0.9830 - val_loss: 0.0877 Epoch 13/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9795 - loss: 0.0760 - val_acc: 0.9823 - val_loss: 0.0970 Epoch 14/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9812 - loss: 0.0727 - val_acc: 0.9834 - val_loss: 0.0954 Epoch 15/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9816 - loss: 0.0699 - val_acc: 0.9826 - val_loss: 0.0867 Epoch 16/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9816 - loss: 0.0655 - val_acc: 0.9823 - val_loss: 0.0938 Epoch 17/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9815 - loss: 0.0727 - val_acc: 0.9823 - val_loss: 0.0904 Epoch 18/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9835 - loss: 0.0632 - val_acc: 0.9825 - val_loss: 0.1071 Epoch 19/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9828 - loss: 0.0639 - val_acc: 0.9817 - val_loss: 0.1091 Epoch 20/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9843 - loss: 0.0574 - val_acc: 0.9833 - val_loss: 0.1257 Epoch 21/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9844 - loss: 0.0643 - val_acc: 0.9828 - val_loss: 0.1115 Epoch 22/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9838 - loss: 0.0656 - val_acc: 0.9847 - val_loss: 0.0853 Epoch 23/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9837 - loss: 0.0650 - val_acc: 0.9836 - val_loss: 0.0992 Epoch 24/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9831 - loss: 0.0692 - val_acc: 0.9836 - val_loss: 0.1028 Epoch 25/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9851 - loss: 0.0630 - val_acc: 0.9851 - val_loss: 0.1152 Epoch 26/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9852 - loss: 0.0602 - val_acc: 0.9853 - val_loss: 0.1016 Epoch 27/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9850 - loss: 0.0641 - val_acc: 0.9832 - val_loss: 0.1014 Epoch 28/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9857 - loss: 0.0597 - val_acc: 0.9839 - val_loss: 0.1153 Epoch 29/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 9ms/step - acc: 0.9864 - loss: 0.0586 - val_acc: 0.9834 - val_loss: 0.1218 Epoch 30/30 [1m1875/1875[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m16s[0m 8ms/step - acc: 0.9865 - loss: 0.0571 - val_acc: 0.9829 - val_loss: 0.1139 predictions = model.predict(X_test) predictions = np.argmax(predictions, axis=1) predictions [1m313/313[0m [32m━━━━━━━━━━━━━━━━━━━━[0m[37m[0m [1m1s[0m 2ms/step array([7, 2, 1, ..., 4, 5, 6]) obraz, obszary = plt.subplots(ncols=10,nrows=4, sharex=False, sharey=True, figsize=(20, 14)) for i in range(40): obraz.axes[i].set_title(predictions[i]) obraz.axes[i].imshow(X_test[i], cmap='gray') obraz.axes[i].get_xaxis().set_visible(False) obraz.axes[i].get_yaxis().set_visible(False) plt.show() {{output_15_0.png|png}} png