diff --git a/Prace_domowe/Praca_domowa1/Grupa3/Pawlikowski_Maciej/pd1.ipynb b/Prace_domowe/Praca_domowa1/Grupa3/Pawlikowski_Maciej/pd1.ipynb new file mode 100644 index 000000000..5e2b7dc79 --- /dev/null +++ b/Prace_domowe/Praca_domowa1/Grupa3/Pawlikowski_Maciej/pd1.ipynb @@ -0,0 +1,369 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Praca domowa 1- eksploracja danych" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas_profiling\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import math\n", + "from mpl_toolkits.mplot3d import Axes3D" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data=pd.DataFrame(pd.read_json('https://api.apispreadsheets.com/api/dataset/forest-fires/',orient='split'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f'liczba obserwacji: {data.shape[0]}, Liczba kolumn: {data.shape[1]}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rozpoczniemy od sprawdzenia kompletności danych." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Żadna z kolumn nie zawiera nulli więc dane nie są wybrakowane" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pprzebadania naszego targetu,który chcemy miodelować, czyli daną area." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data['area'].describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Łatwo zauważyć, że większość obserwacji znajduje się blisko zera." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f'Kurtoza: {data[\"area\"].kurt()}')\n", + "print(f'Skośność: {data[\"area\"].skew()}')\n", + "sns.distplot(data['area'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Z wykresu szybko wnioskujemy, że przydałoby się transformować tą zmienną do jej analizy. Skorzystamy z $\\log(x)$ zgodnie z sugestią autorów danych." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data['area(log)']=data['area'].map(lambda x: np.log(x+1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f'Kurtoza: {data[\"area(log)\"].kurt()}')\n", + "print(f'Skośność: {data[\"area(log)\"].skew()}')\n", + "sns.distplot(data['area(log)'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Od razu widać większą przejrzystość" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.boxplot(x='month',y='area(log)',data=data,order=['jan','feb','mar','apr','may','jun','jul','aug','sep','oct','nov','dec'],)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Łatwo zauważyć, że to włąśnie podczas miesięcy letnich miały miejsce najgorsze pożary, co jednak ciekawe to w maju i w grudniu dolny kwartyl nie jest w zerze(bądź bardzo blisko niego)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.boxplot(x='day',y='area(log)',data=data,order=['mon','tue','wed','thu','fri','sat','sun'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.countplot(data=data,x='day',order=['mon','tue','wed','thu','fri','sat','sun'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tu bez większych niespodzianek dzień tygodnia nie wpływa zbytnio na rozmiar, ani na częstotliwość pożarów pożarów." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Następnie spojrzymy na cechy ciągłe w poszukiwaniu większej ilości zależności" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data.hist(bins=10, figsize=(15,10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Co ciekawe partie lasu najczęściej dotykane przez pożary są przedzielone pasmami, w których pożary nie występuję(z rozkładu zmiennych X i Y). Widzimy również, że FFMC oraz rain są skupione blisko jednej wartości. A ISI i temp najbardziej przypominają rozkłąd normalny." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sprawdźmy więc, w których częściach lasu występują najgroźniejsze pożary.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df=data.iloc[:,[0,1,12]]\n", + "\n", + "\n", + "plt.show()\n", + "fig = plt.figure()\n", + "ax = fig.gca(projection='3d')\n", + "ax.bar3d(df['Y'], df['X'],0,0.5,0.5,df['area'], cmap=plt.cm.viridis, linewidth=0.02)\n", + "ax.view_init(90, 0)\n", + "\n", + "\n", + "plt.show()\n", + "fig = plt.figure()\n", + "ax = fig.gca(projection='3d')\n", + "ax.bar3d(df['Y'], df['X'], 0,0.5,0.5,df['area'], cmap=plt.cm.viridis, linewidth=0.02)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Z wykresów widzimy, że najgorsze pożary wybuchają w centralnej części lasu oraz na obrzeżach." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data_subset=data[['FFMC','rain','ISI','temp','area','area(log)']]\n", + "sns.set()\n", + "sns.pairplot(data_subset, height=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zauważamy pewne zależności pomiędzy ISI,a FFMC oraz pomiędzy temp, a FFMC.\n", + "## Sprawdzamy, więc współczynniki korelacji pomiędzy zmiennymi." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure(figsize=(10,10))\n", + "sns.heatmap(data.corr(),annot=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zauważamy, że X i Y są ze sobą dość mocno skorelowane podobnie jak zmienne FFMC, DMC, DC, ISI oraz temp. Niestety nie znajdujemy żadnych korelacji pomiędzy area, a innymi zmiennymi." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure(figsize=(10,10))\n", + "k = 5\n", + "cols = data.corr().nlargest(k, 'area')['area'].index\n", + "cm = np.corrcoef(data[cols].values.T)\n", + "sns.set(font_scale=1.25)\n", + "hm = sns.heatmap(cm, cbar=True, annot=True, square=True, fmt='.2f', annot_kws={'size': 10}, yticklabels=cols.values, xticklabels=cols.values)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zmiennymi najbardziej skorelowanymi do area okazują się temp, DMC i X." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pandas_profiling.ProfileReport(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automatyczny sposób eksploracji danych pozwala szybko zapoznać się ze strukturą danych, jednak nie daje ich pełnej analizy. Jest to dobry punkt początkowy ukazujący podstawowe zależności między danymi. Nie daje on jednak zbytniej sfobody co do zależności, które wyświetla np. nie możemy sprawdzić korelacji zmiennych ciągłych z kategorycznymi. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Prace_domowe/Praca_domowa1/Grupa3/Pawlikowski_Maciej/pd1.pdf b/Prace_domowe/Praca_domowa1/Grupa3/Pawlikowski_Maciej/pd1.pdf new file mode 100644 index 000000000..ed92972e4 Binary files /dev/null and b/Prace_domowe/Praca_domowa1/Grupa3/Pawlikowski_Maciej/pd1.pdf differ diff --git a/Prace_domowe/Praca_domowa2/Grupa3/Pawlikowski_Maciej/Lab2-prdom.ipynb b/Prace_domowe/Praca_domowa2/Grupa3/Pawlikowski_Maciej/Lab2-prdom.ipynb new file mode 100644 index 000000000..289fbedd4 --- /dev/null +++ b/Prace_domowe/Praca_domowa2/Grupa3/Pawlikowski_Maciej/Lab2-prdom.ipynb @@ -0,0 +1,329 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "import math\n", + "import pandas as pd\n", + "from category_encoders import TargetEncoder\n", + "from category_encoders import OneHotEncoder\n", + "from category_encoders import CountEncoder\n", + "from category_encoders import BinaryEncoder\n", + "df=pd.read_csv(\"allegro-api-transactions.csv\")\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zadanie domowe 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zajmiemy się przekształceniem bazy allegro w pierwszej części konując jej zmienne kategoryczne, a w drugiej uzupełniając brakujące dane." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Część pierwsza" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rozpoczniemy od zakodowania zmiennej kategorycznej *it_location* za pomocą target encoding." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df['it_location'].describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zauważamy, że kolumna ta przyjmuje 10056 unikalnych wartości, co świadczy o tym, że metoda *one hot encoding* nie będzie tu najlepszym pomysłem, bowiem stworzyłaby ona włąśnie tyle kolumn. Natomiast *target encoding* pozwoli zmniejszyć ilość zmiennych." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "te=TargetEncoder()\n", + "df1=df.copy()\n", + "df1['it_location_encoded']=te.fit_transform(df1['it_location'],df1['price'])\n", + "df1.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stworzyliśmy w ramce danych nową kolumnę *it_location_encoded*, w której umieszczone są zakodowane wartości *it_location* za pomocą *target encoding*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Target encoding* polega na kodowaniu zmiennej kategorycznej jako: średniej wartości targetu(tu *price*), dla danej kategorii." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zalety:\n", + " - prosty i szybki\n", + " - nie zwiększa wymiaru bazy danych " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wady:\n", + " - jest zależny od rozkładu targetu, co oznacza, że ma skłonności do overfitting-u\n", + " - jest specyficzny co do danych i żadko pokazuje znaczącą poprawę" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ohe=OneHotEncoder(use_cat_names=True)\n", + "df2=df.copy()\n", + "df2=df2.join(ohe.fit_transform(df2.main_category))\n", + "df2.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stworzyliśmy w ramce danych nowe kolumny, które kodują wartości *main_category* za pomocą one hot encoding. Dokonuje tego poprzez stworzenie po jednej kolumnie dla każdej unikalnej wartości w kolumnie *main_category*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zalety:\n", + " - działa dobrze z nominalnymi danymi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wady:\n", + " - może stworzyć naprawdę duże ramki danych" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "be=BinaryEncoder()\n", + "df3=df.copy()\n", + "df3=df3.join(be.fit_transform(df3.main_category))\n", + "df3.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stworzyliśmy w ramce danych nowe kolumny, które kodują wartości *main_category* za pomocą *binary encoding*. Działa ono podobnie jak *one hot*, ale przechowuje wartości jako binarne bitstring-i." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Co prawda metoda ta nie tworzy tak wielu kolumn jak one hot, ale przypomina przez to zbytnio *ordinal encoder* tyle, że w postaci binarnej." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ce=CountEncoder()\n", + "df4=df.copy()\n", + "df4['main_category_encoded']=ce.fit_transform(df4.main_category)\n", + "df4.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stworzyliśmy w ramce danych nowe kolumny, które kodują wartości *main_category* za pomocą *count encoding*. Dokonuje tego zamieniając każdą wartość kategoryczną ilością jej wystąpień." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Metoda ta może powodować wiele problemów np. gdy kolumna zawiera tylko dwie wartości kategoryczne i każda z nich występuje dokładnie tyle samo razy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Część druga" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rozpoczniemy od ograniczenia bazy danych do zmiennych numerycznych." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.experimental import enable_iterative_imputer\n", + "from sklearn.impute import IterativeImputer\n", + "from sklearn.metrics import mean_squared_error\n", + "import seaborn as sns\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def seller_rating():\n", + " answer1=[0 for i in range(10)]\n", + " answer=pd.DataFrame()\n", + " for i in range(10):\n", + " copy=df.loc[:,['price', 'it_seller_rating', 'it_quantity']].copy()\n", + " random_sample1=random.sample(range(0,df.shape[0]),math.floor(df.shape[0]*0.1))\n", + " copy.iloc[random_sample1,1]=None\n", + "\n", + " imp=IterativeImputer(max_iter=10,random_state=21)\n", + " ans=pd.DataFrame(imp.fit_transform(copy),columns=['price', 'it_seller_rating', 'it_quantity'])\n", + " answer1[i] = math.sqrt(mean_squared_error(df['it_seller_rating'], ans['it_seller_rating']))\n", + "\n", + " answer['it_seller_rating']=answer1\n", + " return answer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def both():\n", + " answer1=[0 for i in range(10)]\n", + " answer2=[0 for i in range(10)]\n", + " answer=pd.DataFrame()\n", + " for i in range(10):\n", + " copy=df.loc[:,['price', 'it_seller_rating', 'it_quantity']].copy()\n", + " random_sample1=random.sample(range(0,df.shape[0]),math.floor(df.shape[0]*0.1))\n", + " random_sample2=random.sample(range(0,df.shape[0]),math.floor(df.shape[0]*0.1))\n", + " copy.iloc[random_sample1,1]=None\n", + " copy.iloc[random_sample2,2]=None\n", + " imp=IterativeImputer(max_iter=10,random_state=21)\n", + " ans=pd.DataFrame(imp.fit_transform(copy),columns=['price', 'it_seller_rating', 'it_quantity'])\n", + " answer1[i] = math.sqrt(mean_squared_error(df['it_seller_rating'], ans['it_seller_rating']))\n", + " answer2[i]=math.sqrt(mean_squared_error(df['it_quantity'], ans['it_quantity']))\n", + " answer['it_seller_rating']=answer1\n", + " answer['it_quantity']=answer2\n", + " return answer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "answer1=seller_rating()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "answer=both()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plotdata=pd.DataFrame()\n", + "plotdata['one_variable_missing']=answer1['it_seller_rating']\n", + "plotdata['two_variables_missing']=answer['it_seller_rating']\n", + "sns.boxplot(data=pd.melt(plotdata),x='variable', y='value')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Z powyższego wykresu łatwo wywnioskować, że algorytm gorzej działa, gdy brakuje więcej niż jednego argumentu." + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Prace_domowe/Praca_domowa2/Grupa3/Pawlikowski_Maciej/Lab2-prdom.pdf b/Prace_domowe/Praca_domowa2/Grupa3/Pawlikowski_Maciej/Lab2-prdom.pdf new file mode 100644 index 000000000..df0b3f0dc Binary files /dev/null and b/Prace_domowe/Praca_domowa2/Grupa3/Pawlikowski_Maciej/Lab2-prdom.pdf differ diff --git "a/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/02_modeling.ipynb" "b/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/02_modeling.ipynb" new file mode 100644 index 000000000..4b8af30ba --- /dev/null +++ "b/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/02_modeling.ipynb" @@ -0,0 +1,376 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import math\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn import linear_model\n", + "from sklearn.model_selection import GridSearchCV\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "from category_encoders import OneHotEncoder" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data=pd.DataFrame(pd.read_json('https://api.apispreadsheets.com/api/dataset/school-grades/',orient='split'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inżynieria cech \n", + "### Kodowanie kategoryczne i dodanie kolumny \"Czy dostał 0 pkt\"\n", + "\n", + "Chcąc lepiej przewidywać wyniki postanowiliśmy inaczej potraktować osoby z zerowym wynikiem. Nasz plan jest taki, aby najpierw przewidywać czy osoba dostanie 0 pkt, a następnie, jeśli z przewidywania wyjdzie że nie powinna dostać 0 pkt, przewidujemy jej wynik." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data['schoolsup'].describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wyrzucamy również kolumne dotyczącą edukacji ojca, gdyż z EDA wyszło nam że jest ona mocno skorelowana z edukacją matki. Postanowiliśmy wyrzucić jedną z tych cech." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = data.drop(labels = \"Fedu\", axis = 1)\n", + "data = data.drop(labels = \"Fjob\", axis = 1)\n", + "\n", + "ce_one_hot = OneHotEncoder(cols = (\"Mjob\", \"sex\", \"school\",'famsize',\n", + " \"address\", \"Pstatus\", \"reason\",\n", + " \"guardian\", \"schoolsup\",'famsup', 'paid',\n", + " 'activities', 'nursery', 'higher', 'internet', 'romantic' ))\n", + "df = ce_one_hot.fit_transform(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a=df.shape[1]-3\n", + "df=df.iloc[:,:a]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data['is_zero']=np.where(data['G3']==0,0,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Main grid search" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Na początku dla przetestowania, czy osiągniemy lepsze efekty dzieląc modelowanie na dwa etapy sprawdzamy jakość wybranych modeli bez podziału." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + " x_train2, x_test2, y_train2, y_test2 = train_test_split(df, data[\"G3\"],test_size=0.3, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_params2={\n", + " 'linear_regression':{\n", + " 'model': linear_model.LinearRegression(),\n", + " 'params': {}\n", + " },\n", + " 'lasso':{\n", + " 'model': linear_model.Lasso(random_state=15),\n", + " 'params':{\n", + " 'alpha':[0.1,1,0],\n", + " 'normalize':['True','False']\n", + " }\n", + " },\n", + " 'svm':{\n", + " 'model': svm.SVC(gamma='auto', tol=1e-1, cache_size=2000, max_iter=1500),\n", + " 'params': {\n", + " 'C': [0.001, 0.01, 0.1, 1, 3, 10, 30],\n", + " 'kernel': ['linear', 'rbf']\n", + " }\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "results2=[]\n", + "\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "for name, param in model_params2.items():\n", + " classifier=GridSearchCV(param['model'],param['params'],cv=6,return_train_score=False)\n", + " classifier.fit(x_train2, y_train2)\n", + " model_performance = np.sqrt(mean_squared_error(classifier.predict(x_test2),y_test2, squared=True))\n", + " results2.append({\n", + " 'model': name,\n", + " 'best_score': classifier.best_score_,\n", + " 'best_params': classifier.best_params_,\n", + " 'RMSE': model_performance\n", + " })\n", + "results2 " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.displot(classifier.predict(x_test2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.displot(y_test2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grid search: \"Czy studenci dostali 0?\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + " x_train, x_test, y_train, y_test = train_test_split(df, data[\"is_zero\"],test_size=0.3, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import svm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "model_params={\n", + " 'random_forest':{\n", + " 'model': RandomForestClassifier(random_state=15),\n", + " 'params': {\n", + " 'n_estimators':[1,3,8,13],\n", + " 'min_samples_split': [3,5,10,20]\n", + " }\n", + " },\n", + " 'logistic_regession':{\n", + " 'model': LogisticRegression(random_state=15, solver='liblinear'),\n", + " 'params':{\n", + " 'C':[1,5,10],\n", + " 'penalty':['l1','l2','elasticnet']\n", + " }\n", + " },\n", + " 'svm':{\n", + " 'model': svm.SVC(gamma='auto', tol=1e-1, cache_size=2000, max_iter=1500),\n", + " 'params': {\n", + " 'C': [0.001, 0.01, 0.1, 1, 3, 10, 30],\n", + " 'kernel': ['linear', 'rbf']\n", + " }\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "results=[]\n", + "for name, param in model_params.items():\n", + " classifier=GridSearchCV(param['model'],param['params'],cv=6,return_train_score=False)\n", + " classifier.fit(x_train, y_train)\n", + " results.append({\n", + " 'model': name,\n", + " 'best_score': classifier.best_score_,\n", + " 'best_params': classifier.best_params_\n", + " })\n", + "results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "only_good_data=df.loc[data.is_zero==1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data2=data.loc[data.is_zero==1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + " x_train3, x_test3, y_train3, y_test3 = train_test_split(only_good_data, data2[\"G3\"],test_size=0.3, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "results3=[]\n", + "\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "for name, param in model_params2.items():\n", + " classifier=GridSearchCV(param['model'],param['params'],cv=6,return_train_score=False)\n", + " classifier.fit(x_train3, y_train3)\n", + " model_performance = np.sqrt(mean_squared_error(classifier.predict(x_test3),y_test3, squared=True))\n", + " results3.append({\n", + " 'model': name,\n", + " 'best_score': classifier.best_score_,\n", + " 'best_params': classifier.best_params_,\n", + " 'RMSE': model_performance\n", + " })\n", + "results3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.displot(classifier.predict(x_test2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.displot(y_test3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/02_modeling.pdf" "b/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/02_modeling.pdf" new file mode 100644 index 000000000..848dcbb2e Binary files /dev/null and "b/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/02_modeling.pdf" differ diff --git "a/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/pk2" "b/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/pk2" new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ "b/Projekty/Projekt1/Pawlikowski_Szmajdzi\305\204ski/pk2" @@ -0,0 +1 @@ +