diff --git a/zajecia3/sklearn cz. 1.ipynb b/zajecia3/sklearn cz. 1.ipynb new file mode 100644 index 0000000..4c343a8 --- /dev/null +++ b/zajecia3/sklearn cz. 1.ipynb @@ -0,0 +1,587 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Kkolejna część zajęć będzie wprowadzeniem do drugiej, szeroko używanej biblioteki w Pythonie: `sklearn`. Zajęcia będą miały charaktere case-study poprzeplatane zadaniami do wykonania. Zacznijmy od załadowania odpowiednich bibliotek." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zacznijmy od załadowania danych. Na dzisiejszych zajęciach będziemy korzystać z danych z portalu [gapminder.org](https://www.gapminder.org/data/)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv('gapminder.csv', index_col=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dane zawierają różne informacje z większość państw świata (z roku 2008). Poniżej znajduje się opis kolumn:\n", + " * female_BMI - średnie BMI u kobiet\n", + " * male_BMI - średnie BMI u mężczyzn\n", + " * gdp - PKB na obywatela\n", + " * population - wielkość populacji\n", + " * under5mortality - wskaźnik śmiertelności dzieni pon. 5 roku życia (na 1000 urodzonych dzieci)\n", + " * life_expectancy - średnia długość życia\n", + " * fertility - wskaźnik dzietności" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 1**\n", + "Na podstawie danych zawartych w `df` odpowiedz na następujące pytania:\n", + " * Jaki był współczynniki dzietności w Polsce w 2018?\n", + " * W którym kraju ludzie żyją najdłużej?\n", + " * Z ilu krajów zostały zebrane dane?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 2** Stwórz kolumnę `gdp_log`, która powstanie z kolumny `gdp` poprzez zastowanie funkcji `log` (logarytm). \n", + "\n", + "Hint 1: Wykorzystaj funkcję `apply` (https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.apply.html#pandas.Series.apply).\n", + "\n", + "Hint 2: Wykorzystaj fukcję `log` z pakietu `np`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Naszym zadaniem będzie oszacowanie długości życia (kolumna `life_expectancy`) na podstawie pozostałych zmiennych. Na samym początku, zastosujemy regresje jednowymiarową na `fertility`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y shape: (175,)\n", + "X shape: (175,)\n" + ] + } + ], + "source": [ + "y = df['life_expectancy'].values\n", + "X = df['fertility'].values\n", + "\n", + "print(\"Y shape:\", y.shape)\n", + "print(\"X shape:\", X.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Będziemy korzystać z gotowej implementacji regreji liniowej z pakietu sklearn. Żeby móc wykorzystać, musimy napierw zmienić shape na dwuwymiarowy." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y shape: (175, 1)\n", + "X shape: (175, 1)\n" + ] + } + ], + "source": [ + "y = y.reshape(-1, 1)\n", + "X = X.reshape(-1, 1)\n", + "\n", + "print(\"Y shape:\", y.shape)\n", + "print(\"X shape:\", X.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Jeszcze przed właściwą analizą, narysujmy wykres i zobaczny czy istnieje \"wizualny\" związek pomiędzy kolumnami." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.plot.scatter('fertility', 'life_expectancy')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 3** Zaimportuj `LinearRegression` z pakietu `sklearn.linear_model`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tworzymy obiekt modelu regresji liniowej." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "model = LinearRegression()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Trening modelu ogranicza się do wywołania metodu `fit`, która przyjmuje dwa argumenty:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Współczynniki modelu:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wyraz wolny (bias): [83.2025629]\n", + "Współczynniki cech: [[-4.41400624]]\n" + ] + } + ], + "source": [ + "print(\"Wyraz wolny (bias):\", model.intercept_)\n", + "print(\"Współczynniki cech:\", model.coef_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 4** Wytrenuj nowy model `model2`, który będzie jako X przyjmie kolumnę `gdp_log`. Wyświetl parametry nowego modelu." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mając wytrenowany model możemy wykorzystać go do predykcji. Wystarczy wywołać metodę `predict`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input: 6.2\t predicted: 55.835724214829476\t expected: 52.8\n", + "input: 1.76\t predicted: 75.43391191760767\t expected: 76.8\n", + "input: 2.73\t predicted: 71.15232586542415\t expected: 75.5\n", + "input: 6.43\t predicted: 54.82050277977565\t expected: 56.7\n", + "input: 2.16\t predicted: 73.66830942186188\t expected: 75.5\n" + ] + } + ], + "source": [ + "X_test = X[:5,:]\n", + "y_test = y[:5,:]\n", + "output = model.predict(X_test)\n", + "\n", + "for i in range(5):\n", + " print(\"input: {}\\t predicted: {}\\t expected: {}\".format(X_test[i,0], output[i,0], y_test[i,0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sprawdzenie jakości modelu - metryki: $R^2$ i $MSE$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Istnieją 3 metryki, które określają jak dobry jest nasz model:\n", + " * $R^2$: [Współczynnik determinacji](https://pl.wikipedia.org/wiki/Wsp%C3%B3%C5%82czynnik_determinacji)\n", + " * $MSE$: [błąd średnio-kwadratowy](https://pl.wikipedia.org/wiki/B%C5%82%C4%85d_%C5%9Bredniokwadratowy) \n", + " * $RMSE = \\sqrt{MSE}$" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.5955222955385271\n", + "Root Mean Squared Error: 5.682032704570357\n" + ] + } + ], + "source": [ + "from sklearn.metrics import mean_squared_error\n", + "\n", + "print(\"R^2: {}\".format(model.score(X, y)))\n", + "rmse = np.sqrt(mean_squared_error(y, model.predict(X)))\n", + "print(\"Root Mean Squared Error: {}\".format(rmse))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.6742169953190864\n", + "Root Mean Squared Error: 4.874062378427941\n" + ] + } + ], + "source": [ + "# Import necessary modules\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.metrics import mean_squared_error\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Create training and test sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)\n", + "\n", + "# Create the regressor: reg_all\n", + "reg_all = LinearRegression()\n", + "\n", + "# Fit the regressor to the training data\n", + "reg_all.fit(X_train, y_train)\n", + "\n", + "# Predict on the test data: y_pred\n", + "y_pred = reg_all.predict(X_test)\n", + "\n", + "# Compute and print R^2 and RMSE\n", + "print(\"R^2: {}\".format(reg_all.score(X_test, y_test)))\n", + "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n", + "print(\"Root Mean Squared Error: {}\".format(rmse))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Regresja wielu zmiennych" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model regresji liniowej wielu zmiennych nie różni się istotnie od modelu jednej zmiennej. Np. chcąc zbudować model oparty o dwie kolumny: `fertility` i `gdp` wystarczy zmienić X (cechy wejściowe):" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(175,)\n", + "(175, 1)\n" + ] + }, + { + "data": { + "text/plain": [ + "0.6566838211706549" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X = df[['fertility', 'gdp']]\n", + "print(df['fertility'].shape)\n", + "print(df[['fertility']].shape)\n", + "\n", + "model_mv = LinearRegression()\n", + "model_mv.fit(X, y)\n", + "\n", + "model_mv.score(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 6** Która kombinacja dwóch kolumn daje najlepszy wynik w metryce $R^2$? Tak jak poprzednio, próbujemy przewidzieć zawartosć kolumny `life_expectancy`.\n", + "\n", + "Uwaga: Należy wyłączyć kolumnę `life_expectancy` spośród szukanych." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 7** \n", + " * Zbuduj model regresji liniowej, która oszacuje wartność kolumny `life_expectancy` na podstawie pozostałych kolumn.\n", + " * Wyświetl współczynniki modelu? Dla jakich cech współczynniki modelu są bliskie 0? Dlaczego?\n", + " * Oblicz wartości obu metryk na zbiorze trenującym.\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 6**\n", + "Wykonaj jedno z zadań 6.1 lub 6.2." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 6.1** Zaimplementuj metrykę $R^2$ jako fukcję `r2` (szablon poniżej). Fukcja `r2` przyjmuje dwa parametry typu *list* i ma zwrócić wartość metryki $R^2$." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real R2: 0.6566838211706549\n", + "Calculated: None\n" + ] + } + ], + "source": [ + "def r2(expected, predicted):\n", + " \"\"\"\n", + " argumenty:\n", + " expected (type: list): poprawne wartości\n", + " predicted (type: list): oszacowanie z modelu\n", + " \"\"\"\n", + " pass\n", + "\n", + "y = df['life_expectancy'].values\n", + "X = df[['fertility', 'gdp']].values\n", + "\n", + "test_model = LinearRegression()\n", + "test_model.fit(X, y)\n", + "\n", + "print(\"Real R2:\", test_model.score(X, y))\n", + "\n", + "predicted = list(test_model.predict(X))\n", + "expected = list(y)\n", + "\n", + "print(\"Calculated:\", r2(expected, predicted))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Zaimplementuj metrykę $RMSE$ jako fukcję rmse (szablon poniżej). Fukcja rmse przyjmuje dwa parametry typu list i ma zwrócić wartość metryki $RMSE$ ." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real R2: 5.234841906276239\n", + "Calculated: None\n" + ] + } + ], + "source": [ + "def rmse(expected, predicted):\n", + " \"\"\"\n", + " argumenty:\n", + " expected (type: list): poprawne wartości\n", + " predicted (type: list): oszacowanie z modelu\n", + " \"\"\"\n", + " pass\n", + "\n", + "y = df['life_expectancy'].values\n", + "X = df[['fertility', 'gdp']].values\n", + "\n", + "test_model = LinearRegression()\n", + "test_model.fit(X, y)\n", + "\n", + "print(\"Real R2:\", np.sqrt(mean_squared_error(y, test_model.predict(X))))\n", + "\n", + "predicted = list(test_model.predict(X))\n", + "expected = list(y)\n", + "\n", + "print(\"Calculated:\", r2(expected, predicted))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/zajecia3/sklearn cz. 2.ipynb b/zajecia3/sklearn cz. 2.ipynb new file mode 100644 index 0000000..7898bcc --- /dev/null +++ b/zajecia3/sklearn cz. 2.ipynb @@ -0,0 +1,376 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Klasyfikacja w Pythonie" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 1** Które z poniższych problemów jest problemem regresji, a które klasyfikacji?\n", + " 1. Sprawdzenie, czy wiadomość jest spamem.\n", + " 1. Przewidzenie oceny (od 1 do 5 gwiazdek) na podstawie komentarza.\n", + " 1. OCR cyfr: rozpoznanie cyfry z obrazka.\n", + " \n", + " Jeżeli problem jest klasyfikacyjny, to jakie mamy klasy?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Miary dla klasyfikacji" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Istnieje wieje miar (metryk), na podstawie których możemy ocenić jakość modelu. Podobnie jak w przypadku regresji liniowej potrzebne są dwie listy: lista poprawnych klas i lista predykcji z modelu. Najpopularniejszą z metryk jest trafność, którą definiuje się w następujący sposób:\n", + " $$ACC = \\frac{k}{N}$$ \n", + " \n", + " gdzie: \n", + " * $k$ to liczba poprawnie zaklasyfikowanych przypadków,\n", + " * $N$ liczebność zbioru testującego." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zadanie** Napisz funkcję, która jako parametry przyjmnie dwie listy (lista poprawnych klas i wyjście z klasyfikatora) i zwróci trafność." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ACC: None\n" + ] + } + ], + "source": [ + "def accuracy_measure(true, predicted):\n", + " pass\n", + "\n", + "true_label = [1, 1, 1, 0, 0]\n", + "predicted = [0, 1, 0, 1, 0]\n", + "print(\"ACC:\", accuracy_measure(true_label, predicted))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Klasyfikator $k$ najbliższych sąsiadów *(ang. k-nearest neighbors, KNN)*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Klasyfikator [KNN](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm), który został wprowadzony na ostatnim wykładzie, jest bardzo intuicyjny. Pomysł, który stoi za tym klasyfikatorem jest bardzo prosty: Jeżeli mamy nowy obiekt do zaklasyfikowania, to szukamy wśród danych trenujących $k$ najbardziej podobnych do niego przykładów i na ich podstawie decydujemy (np. biorąc większość) do jakie klasy powinien należeć dany obiekt." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "** Przykład 1** Mamy za zadanie przydzielenie obiektów do dwóch klas: trójkątów lub kwadratów. Rozpatrywany obiekt jest zaznaczony zielonym kółkiem. Przyjmując $k=3$, mamy wśród sąsiadów 2 trójkąty i 1 kwadrat. Stąd obiekt powinienm zostać zaklasyfikowany jako trójkąt. Jak zmienia się sytuacja, gdy przyjmiemy $k=5$?\n", + "\n", + "![Przykład 1](./220px-KnnClassification.svg.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Herbal Iris" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Herbal Iris* jest klasycznym zbiorem danych w uczeniu maszynowym, który powstał w 1936 roku. Zawiera on informacje na 150 egzemplarzy roślin, które należą do jednej z 3 odmian." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 2** Wczytaj do zmiennej ``data`` zbiór *Herbal Iris*, który znajduje się w pliku ``iris.data``. Jest to plik csv." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 3** Odpowiedz na poniższe pytania:\n", + " 1. Które atrybuty są wejściowe, a w której kolumnie znajduje się klasa wyjściowa?\n", + " 1. Ile jest różnych klas? Wypisz je ekran.\n", + " 1. Jaka jest średnia wartość w kolumnie ``sepal_length``? Jak zachowuje się średnia, jeżeli policzymy ją dla każdej z klas osobno?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wytrenujmy klasyfikator *KNN*, ale najpierw przygotujmy dane. Fukcja ``train_test_split`` dzieli zadany zbiór danych na dwie części. My wykorzystamy ją do podziału na zbiór treningowy (66%) i testowy (33%), służy do tego parametr ``test_size``." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'data' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel_selection\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtrain_test_split\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sepal_length'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m'petal_width'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mY\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'class'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "X = data.loc[:, 'sepal_length':'petal_width']\n", + "Y = data['class']\n", + "\n", + "(train_X, test_X, train_Y, test_Y) = train_test_split(X, Y, test_size=0.33, random_state=42)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Trenowanie klasyfikatora wygląda bardzo podobnie do treningi modelu regresji liniowej:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.neighbors import KNeighborsClassifier\n", + "\n", + "model = KNeighborsClassifier(n_neighbors=3)\n", + "model.fit(train_X, train_Y)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mając wytrenowany model możemy wykorzystać go do predykcji na zbiorze testowym." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "predicted = model.predict(test_X)\n", + "\n", + "for i in range(10):\n", + " print(\"Zaklasyfikowane: {}, Orginalne: {}\".format(predicted[i], test_Y.reset_index()['class'][i]))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Możemy obliczyć *accuracy*:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "\n", + "print(accuracy_score(test_Y, predicted))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 4** Wytrenuj nowy model ``model_2`` zmieniając liczbę sąsiadów na 20. Czy zmieniły się wyniki?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 5** Wytrenuj model z $k=1$. Przeprowadź walidację na zbiorze trenującym zamiast na zbiorze testowym? Jakie wyniki otrzymałeś? Czy jest to wyjątek? Dlaczego tak się dzieje?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Walidacja krzyżowa" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zbiór *herbal Iris* jest bardzo małym zbiorem. Wydzielenie z niego zbioru testowego jest obciążone dużą wariancją wyników, tj. w zależności od sposoby wyboru zbioru testowego wyniki mogą się bardzo różnic. Żeby temu zaradzić, stosuje się algorytm [walidacji krzyżowej](https://en.wikipedia.org/wiki/Cross-validation_(statistics). Algorytm wygląda następująco:\n", + " 1. Podziel zbiór danych na $n$ części (losowo).\n", + " 1. Dla każdego i od 1 do $n$ wykonaj:\n", + " 1. Weź $i$-tą część jako zbiór testowy, pozostałe dane jako zbiór trenujący.\n", + " 1. Wytrenuj model na zbiorze trenującym.\n", + " 1. Uruchom model na danych testowych i zapisz wyniki.\n", + " 1. Ostateczne wyniki to średnia z $n$ wyników częściowych. \n", + " \n", + " W Pythonie służy do tego funkcja ``cross_val_score``, która przyjmuje jako parametry (kolejno) model, zbiór X, zbiór Y. Możemy ustawić parametr ``cv``, który określa na ile części mamy podzielić zbiór danych oraz parametr ``scoring`` określający miarę.\n", + " \n", + " W poniższym przykładzie dzielimy zbiór danych na 10 części (10-krotna walidacja krzyżowa) i jako miarę ustawiany celność (ang. accuracy)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import cross_val_score\n", + "\n", + "knn = KNeighborsClassifier(n_neighbors=k)\n", + "scores = cross_val_score(knn, X, Y, cv=10, scoring='accuracy')\n", + "print(\"Wynik walidacji krzyżowej:\", scores.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**zad. 6** Klasyfikator $k$ najbliższych sąsiadów posiada jeden parametr: $k$, który określa liczbę sąsiadów podczas klasyfikacji. Jak widzieliśmy, wybór $k$ może mieć duże znaczenie dla jakości klasyfikatora. Wykonaj:\n", + " 1. Stwórz listę ``neighbors`` wszystkich liczb nieparzystych od 1 do 50.\n", + " 1. Dla każdego elementu ``i`` z listy ``neighbors`` zbuduj klasyfikator *KNN* o liczbie sąsiadów równej ``i``. Nastepnie przeprowadz walidację krzyżową (parametry takie same jak powyżej) i zapisz wyniki do tablicy ``cv_scores``.\n", + " 1. Znajdź ``k``, dla którego klasyfikator osiąga najwyższy wynik." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wykres przedstawiający precent błedów w zależnosci od liczby sąsiadów." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "# changing to misclassification error\n", + "MSE = [1 - x for x in cv_scores]\n", + "\n", + "# plot misclassification error vs k\n", + "plt.plot(neighbors, MSE)\n", + "plt.xlabel('Liczba sąsiadów')\n", + "plt.ylabel('Procent błędów')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Przejdź teraz do arkusza z zadaniem domowym, gdzie zastosujemy klasyfikator *kNN* na zbiorze danych z pierwszych zajęć." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/zajecia4/gapminder.csv b/zajecia4/gapminder.csv new file mode 100644 index 0000000..5fa5074 --- /dev/null +++ b/zajecia4/gapminder.csv @@ -0,0 +1,176 @@ +Country,female_BMI,male_BMI,gdp,population,under5mortality,life_expectancy,fertility +Afghanistan,21.07402,20.62058,1311.0,26528741.0,110.4,52.8,6.2 +Albania,25.65726,26.44657,8644.0,2968026.0,17.9,76.8,1.76 +Algeria,26.368409999999997,24.5962,12314.0,34811059.0,29.5,75.5,2.73 +Angola,23.48431,22.25083,7103.0,19842251.0,192.0,56.7,6.43 +Antigua and Barbuda,27.50545,25.76602,25736.0,85350.0,10.9,75.5,2.16 +Argentina,27.46523,27.5017,14646.0,40381860.0,15.4,75.4,2.24 +Armenia,27.1342,25.355420000000002,7383.0,2975029.0,20.0,72.3,1.4 +Australia,26.87777,27.56373,41312.0,21370348.0,5.2,81.6,1.96 +Austria,25.09414,26.467409999999997,43952.0,8331465.0,4.6,80.4,1.41 +Azerbaijan,27.50879,25.65117,14365.0,8868713.0,43.3,69.2,1.99 +Bahamas,29.13948,27.24594,24373.0,348587.0,14.5,72.2,1.89 +Bahrain,28.790940000000003,27.83721,42507.0,1115777.0,9.4,77.6,2.23 +Bangladesh,20.54531,20.39742,2265.0,148252473.0,55.9,68.3,2.38 +Barbados,29.221690000000002,26.384390000000003,16075.0,277315.0,15.4,75.3,1.83 +Belarus,26.641859999999998,26.16443,14488.0,9526453.0,7.2,70.0,1.42 +Belgium,25.1446,26.75915,41641.0,10779155.0,4.7,79.6,1.82 +Belize,29.81663,27.02255,8293.0,306165.0,20.1,70.7,2.91 +Benin,23.74026,22.41835,1646.0,8973525.0,116.3,59.7,5.27 +Bhutan,22.88243,22.8218,5663.0,694990.0,48.1,70.7,2.51 +Bolivia,26.8633,24.43335,5066.0,9599916.0,52.0,71.2,3.48 +Bosnia and Herzegovina,26.35874,26.611629999999998,9316.0,3839749.0,8.1,77.5,1.22 +Botswana,26.09156,22.129839999999998,13858.0,1967866.0,63.8,53.2,2.86 +Brazil,25.99113,25.78623,13906.0,194769696.0,18.6,73.2,1.9 +Brunei,22.892310000000002,24.18179,72351.0,380786.0,9.0,76.9,2.1 +Bulgaria,25.51574,26.542859999999997,15368.0,7513646.0,13.7,73.2,1.43 +Burkina Faso,21.63031,21.27157,1358.0,14709011.0,130.4,58.0,6.04 +Burundi,21.27927,21.50291,723.0,8821795.0,108.6,59.1,6.48 +Cambodia,21.69608,20.80496,2442.0,13933660.0,51.5,66.1,3.05 +Cameroon,24.9527,23.681729999999998,2571.0,19570418.0,113.8,56.6,5.17 +Canada,26.698290000000004,27.4521,41468.0,33363256.0,5.8,80.8,1.68 +Cape Verde,24.96136,23.515220000000003,6031.0,483824.0,28.4,70.4,2.57 +Chad,21.95424,21.485689999999998,1753.0,11139740.0,168.0,54.3,6.81 +Chile,27.92807,27.015420000000002,18698.0,16645940.0,8.9,78.5,1.89 +China,22.91041,22.92176,7880.0,1326690636.0,18.5,73.4,1.53 +Colombia,26.22529,24.94041,10489.0,44901660.0,19.7,76.2,2.43 +Comoros,22.444329999999997,22.06131,1440.0,665414.0,91.2,67.1,5.05 +"Congo, The Democratic Republic of the",21.6677,19.86692,607.0,61809278.0,124.5,57.5,6.45 +"Congo",23.10824,21.87134,5022.0,3832771.0,72.6,58.8,5.1 +Costa Rica,27.03497,26.47897,12219.0,4429506.0,10.3,79.8,1.91 +Ivory Coast,23.82088,22.56469,2854.0,19261647.0,116.9,55.4,4.91 +Croatia,25.17882,26.596290000000003,21873.0,4344151.0,5.9,76.2,1.43 +Cuba,26.576140000000002,25.06867,17765.0,11290239.0,6.3,77.6,1.5 +Cyprus,25.92587,27.41899,35828.0,1077010.0,4.2,80.0,1.49 +Denmark,25.106270000000002,26.13287,45017.0,5495302.0,4.3,78.9,1.89 +Djibouti,24.38177,23.38403,2502.0,809639.0,81.0,61.8,3.76 +Ecuador,27.062690000000003,25.58841,9244.0,14447600.0,26.8,74.7,2.73 +Egypt,30.099970000000003,26.732429999999997,9974.0,78976122.0,31.4,70.2,2.95 +El Salvador,27.84092,26.36751,7450.0,6004199.0,21.6,73.7,2.32 +Equatorial Guinea,24.528370000000002,23.7664,40143.0,686223.0,118.4,57.5,5.31 +Eritrea,21.082320000000003,20.885089999999998,1088.0,4500638.0,60.4,60.1,5.16 +Estonia,25.185979999999997,26.264459999999996,24743.0,1339941.0,5.5,74.2,1.62 +Ethiopia,20.71463,20.247,931.0,83079608.0,86.9,60.0,5.19 +Fiji,29.339409999999997,26.53078,7129.0,843206.0,24.0,64.9,2.74 +Finland,25.58418,26.733390000000004,42122.0,5314170.0,3.3,79.6,1.85 +France,24.82949,25.853289999999998,37505.0,62309529.0,4.3,81.1,1.97 +Gabon,25.95121,24.0762,15800.0,1473741.0,68.0,61.7,4.28 +Gambia,24.82101,21.65029,1566.0,1586749.0,87.4,65.7,5.8 +Georgia,26.45014,25.54942,5900.0,4343290.0,19.3,71.8,1.79 +Germany,25.73903,27.165090000000003,41199.0,80665906.0,4.4,80.0,1.37 +Ghana,24.33014,22.842470000000002,2907.0,23115919.0,79.9,62.0,4.19 +Greece,24.92026,26.33786,32197.0,11161755.0,4.9,80.2,1.46 +Grenada,27.31948,25.179879999999997,12116.0,103934.0,13.5,70.8,2.28 +Guatemala,26.84324,25.29947,6960.0,14106687.0,36.9,71.2,4.12 +Guinea,22.45206,22.52449,1230.0,10427356.0,121.0,57.1,5.34 +Guinea-Bissau,22.92809,21.64338,1326.0,1561293.0,127.6,53.6,5.25 +Guyana,26.470190000000002,23.68465,5208.0,748096.0,41.9,65.0,2.74 +Haiti,23.27785,23.66302,1600.0,9705130.0,83.3,61.0,3.5 +Honduras,26.73191,25.10872,4391.0,7259470.0,26.5,71.8,3.27 +"Hong Kong",23.71046,25.057470000000002,46635.0,6910384.0,3.06,82.49,1.04 +Hungary,25.97839,27.115679999999998,23334.0,10050699.0,7.2,73.9,1.33 +Iceland,26.02599,27.206870000000002,42294.0,310033.0,2.7,82.4,2.12 +India,21.31478,20.95956,3901.0,1197070109.0,65.6,64.7,2.64 +Indonesia,22.986929999999997,21.85576,7856.0,235360765.0,36.2,69.4,2.48 +Iran,27.236079999999998,25.310029999999998,15955.0,72530693.0,21.4,73.1,1.88 +Iraq,28.411170000000002,26.71017,11616.0,29163327.0,38.3,66.6,4.34 +Ireland,26.62176,27.65325,47713.0,4480145.0,4.5,80.1,2.0 +Israel,27.301920000000003,27.13151,28562.0,7093808.0,4.9,80.6,2.92 +Italy,24.79289,26.4802,37475.0,59319234.0,4.1,81.5,1.39 +Jamaica,27.22601,24.00421,8951.0,2717344.0,18.9,75.1,2.39 +Japan,21.87088,23.50004,34800.0,127317900.0,3.4,82.5,1.34 +Jordan,29.218009999999996,27.47362,10897.0,6010035.0,22.1,76.9,3.59 +Kazakhstan,26.65065,26.290779999999998,18797.0,15915966.0,25.9,67.1,2.51 +Kenya,23.06181,21.592579999999998,2358.0,38244442.0,71.0,60.8,4.76 +Kiribati,31.30769,29.2384,1803.0,98437.0,64.5,61.5,3.13 +Kuwait,31.161859999999997,29.172109999999996,91966.0,2705290.0,11.3,77.3,2.68 +Latvia,25.615129999999997,26.45693,20977.0,2144215.0,10.5,72.4,1.5 +Lebanon,27.70471,27.20117,14158.0,4109389.0,11.3,77.8,1.57 +Lesotho,26.780520000000003,21.90157,2041.0,1972194.0,114.2,44.5,3.34 +Liberia,23.21679,21.89537,588.0,3672782.0,100.9,59.9,5.19 +Libya,29.19874,26.54164,29853.0,6123022.0,18.8,75.6,2.64 +Lithuania,26.01424,26.86102,23223.0,3219802.0,8.2,72.1,1.42 +Luxembourg,26.09326,27.434040000000003,95001.0,485079.0,2.8,81.0,1.63 +Macao,24.895039999999998,25.713820000000002,80191.0,507274.0,6.72,79.32,0.94 +Macedonia,25.37646,26.34473,10872.0,2055266.0,11.8,74.5,1.47 +Madagascar,20.73501,21.403470000000002,1528.0,19926798.0,66.7,62.2,4.79 +Malawi,22.91455,22.034679999999998,674.0,13904671.0,101.1,52.4,5.78 +Malaysia,25.448320000000002,24.73069,19968.0,27197419.0,8.0,74.5,2.05 +Maldives,26.4132,23.219910000000002,12029.0,321026.0,16.0,78.5,2.38 +Mali,23.07655,21.78881,1602.0,14223403.0,148.3,58.5,6.82 +Malta,27.04993,27.683609999999998,27872.0,406392.0,6.6,80.7,1.38 +Mauritania,26.26476,22.62295,3356.0,3414552.0,103.0,67.9,4.94 +Mauritius,26.09824,25.15669,14615.0,1238013.0,15.8,72.9,1.58 +Mexico,28.737509999999997,27.42468,15826.0,114972821.0,17.9,75.4,2.35 +Micronesia,31.28402,28.10315,3197.0,104472.0,43.1,68.0,3.59 +Moldova,27.05617,24.2369,3890.0,4111168.0,17.6,70.4,1.49 +Mongolia,25.71375,24.88385,7563.0,2629666.0,34.8,64.8,2.37 +Montenegro,25.70186,26.55412,14183.0,619740.0,8.1,76.0,1.72 +Morocco,26.223090000000003,25.63182,6091.0,31350544.0,35.8,73.3,2.44 +Mozambique,23.317339999999998,21.93536,864.0,22994867.0,114.4,54.0,5.54 +Myanmar,22.47733,21.44932,2891.0,51030006.0,87.2,59.4,2.05 +Namibia,25.14988,22.65008,8169.0,2115703.0,62.2,59.1,3.36 +Nepal,20.72814,20.76344,1866.0,26325183.0,50.7,68.4,2.9 +Netherlands,25.47269,26.01541,47388.0,16519862.0,4.8,80.3,1.77 +New Zealand,27.36642,27.768929999999997,32122.0,4285380.0,6.4,80.3,2.12 +Nicaragua,27.57259,25.77291,4060.0,5594524.0,28.1,77.0,2.72 +Niger,21.95958,21.21958,843.0,15085130.0,141.3,58.0,7.59 +Nigeria,23.674020000000002,23.03322,4684.0,151115683.0,140.9,59.2,6.02 +Norway,25.73772,26.934240000000003,65216.0,4771633.0,3.6,80.8,1.96 +Oman,26.66535,26.241090000000003,47799.0,2652281.0,11.9,76.2,2.89 +Pakistan,23.44986,22.299139999999998,4187.0,163096985.0,95.5,64.1,3.58 +Panama,27.67758,26.26959,14033.0,3498679.0,21.0,77.3,2.61 +Papua New Guinea,25.77189,25.015060000000002,1982.0,6540267.0,69.7,58.6,4.07 +Paraguay,25.90523,25.54223,6684.0,6047131.0,25.7,74.0,3.06 +Peru,25.98511,24.770410000000002,9249.0,28642048.0,23.2,78.2,2.58 +Philippines,23.4671,22.872629999999997,5332.0,90297115.0,33.4,69.8,3.26 +Poland,25.918870000000002,26.6738,19996.0,38525752.0,6.7,75.4,1.33 +Portugal,26.183020000000003,26.68445,27747.0,10577458.0,4.1,79.4,1.36 +Puerto Rico,30.2212,28.378040000000002,35855.0,3728126.0,8.78,77.0,1.69 +Qatar,28.912509999999997,28.13138,126076.0,1388962.0,9.5,77.9,2.2 +Romania,25.22425,25.41069,18032.0,20741669.0,16.1,73.2,1.34 +Russia,27.21272,26.01131,22506.0,143123163.0,13.5,67.9,1.49 +Rwanda,22.07156,22.55453,1173.0,9750314.0,78.3,64.1,5.06 +Samoa,33.659079999999996,30.42475,5731.0,183440.0,18.8,72.3,4.43 +Sao Tome and Principe,24.88216,23.51233,2673.0,163595.0,61.0,66.0,4.41 +Saudi Arabia,29.598779999999998,27.884320000000002,44189.0,26742842.0,18.1,78.3,2.97 +Senegal,24.30968,21.927429999999998,2162.0,12229703.0,75.8,63.5,5.11 +Serbia,25.669970000000003,26.51495,12522.0,9109535.0,8.0,74.3,1.41 +Seychelles,27.973740000000003,25.56236,20065.0,91634.0,14.2,72.9,2.28 +Sierra Leone,23.93364,22.53139,1289.0,5521838.0,179.1,53.6,5.13 +Singapore,22.86642,23.83996,65991.0,4849641.0,2.8,80.6,1.28 +Slovak Republic,26.323729999999998,26.92717,24670.0,5396710.0,8.8,74.9,1.31 +Slovenia,26.582140000000003,27.43983,30816.0,2030599.0,3.7,78.7,1.43 +Solomon Islands,28.8762,27.159879999999998,1835.0,503410.0,33.1,62.3,4.36 +Somalia,22.66607,21.969170000000002,615.0,9132589.0,168.5,52.6,7.06 +South Africa,29.4803,26.85538,12263.0,50348811.0,66.1,53.4,2.54 +Spain,26.30554,27.49975,34676.0,45817016.0,5.0,81.1,1.42 +Sri Lanka,23.11717,21.96671,6907.0,19949553.0,11.7,74.0,2.32 +Sudan,23.16132,22.40484,3246.0,34470138.0,84.7,65.5,4.79 +Suriname,27.749859999999998,25.49887,13470.0,506657.0,26.4,70.2,2.41 +Swaziland,28.448859999999996,23.16969,5887.0,1153750.0,112.2,45.1,3.7 +Sweden,25.1466,26.37629,43421.0,9226333.0,3.2,81.1,1.92 +Switzerland,24.07242,26.20195,55020.0,7646542.0,4.7,82.0,1.47 +Syria,28.87418,26.919690000000003,6246.0,20097057.0,16.5,76.1,3.17 +Tajikistan,23.84799,23.77966,2001.0,7254072.0,56.2,69.6,3.7 +Tanzania,23.0843,22.47792,2030.0,42844744.0,72.4,60.4,5.54 +Thailand,24.38577,23.008029999999998,12216.0,66453255.0,15.6,73.9,1.48 +Togo,22.73858,21.87875,1219.0,6052937.0,96.4,57.5,4.88 +Tonga,34.25969,30.99563,4748.0,102816.0,17.0,70.3,4.01 +Trinidad and Tobago,28.27587,26.396690000000003,30875.0,1315372.0,24.9,71.7,1.8 +Tunisia,27.93706,25.15699,9938.0,10408091.0,19.4,76.8,2.04 +Turkey,28.247490000000003,26.703709999999997,16454.0,70344357.0,22.2,77.8,2.15 +Turkmenistan,24.66154,25.24796,8877.0,4917541.0,63.9,67.2,2.48 +Uganda,22.48126,22.35833,1437.0,31014427.0,89.3,56.0,6.34 +Ukraine,26.23317,25.42379,8762.0,46028476.0,12.9,67.8,1.38 +United Arab Emirates,29.614009999999997,28.053590000000003,73029.0,6900142.0,9.1,75.6,1.95 +United Kingdom,26.944490000000002,27.392490000000002,37739.0,61689620.0,5.6,79.7,1.87 +United States,28.343590000000003,28.456979999999998,50384.0,304473143.0,7.7,78.3,2.07 +Uruguay,26.593040000000002,26.39123,15317.0,3350832.0,13.0,76.0,2.11 +Uzbekistan,25.43432,25.32054,3733.0,26952719.0,49.2,69.6,2.46 +Vanuatu,28.458759999999998,26.78926,2944.0,225335.0,28.2,63.4,3.61 +Venezuela,28.134079999999997,27.445,17911.0,28116716.0,17.1,74.2,2.53 +Vietnam,21.065,20.9163,4085.0,86589342.0,26.2,74.1,1.86 +Palestine,29.026429999999998,26.5775,3564.0,3854667.0,24.7,74.1,4.38 +Zambia,23.05436,20.68321,3039.0,13114579.0,94.9,51.1,5.88 +Zimbabwe,24.645220000000002,22.0266,1286.0,13495462.0,98.3,47.3,3.85