From 002c0158f597fbafd745133d1e900672d6557233 Mon Sep 17 00:00:00 2001 From: Petra Vidnerova Date: Sun, 10 Nov 2024 11:02:06 +0100 Subject: [PATCH 1/5] zprehledneni transformaci sloupcu oprava testovaciho prikladu --- lessons/pydata/scikitlearn_api/index.ipynb | 1574 +++++++++++++++----- 1 file changed, 1204 insertions(+), 370 deletions(-) diff --git a/lessons/pydata/scikitlearn_api/index.ipynb b/lessons/pydata/scikitlearn_api/index.ipynb index b40fad0..98663e3 100644 --- a/lessons/pydata/scikitlearn_api/index.ipynb +++ b/lessons/pydata/scikitlearn_api/index.ipynb @@ -473,61 +473,61 @@ " 165\n", " 1\n", " 0\n", - " 0\n", - " 1\n", - " 0\n", - " 0\n", - " 1\n", - " 0\n", - " 1\n", + " False\n", + " True\n", + " False\n", + " False\n", + " True\n", + " False\n", + " True\n", " \n", " \n", " 197\n", " 4\n", " 4\n", - " 0\n", - " 1\n", - " 0\n", - " 0\n", - " 1\n", - " 0\n", - " 1\n", + " False\n", + " True\n", + " False\n", + " False\n", + " True\n", + " False\n", + " True\n", " \n", " \n", " 78\n", " 26\n", " 19\n", - " 0\n", - " 0\n", - " 1\n", - " 0\n", - " 1\n", - " 0\n", - " 1\n", + " False\n", + " False\n", + " True\n", + " False\n", + " True\n", + " False\n", + " True\n", " \n", " \n", " 64\n", " 11\n", " 11\n", - " 1\n", - " 0\n", - " 0\n", - " 0\n", - " 1\n", - " 1\n", - " 0\n", + " True\n", + " False\n", + " False\n", + " False\n", + " True\n", + " True\n", + " False\n", " \n", " \n", " 166\n", " 21\n", " 8\n", - " 0\n", - " 0\n", - " 1\n", - " 0\n", - " 1\n", - " 0\n", - " 1\n", + " False\n", + " False\n", + " True\n", + " False\n", + " True\n", + " False\n", + " True\n", " \n", " \n", "\n", @@ -535,18 +535,18 @@ ], "text/plain": [ " yrs.since.phd yrs.service rank_AssocProf rank_AsstProf rank_Prof \\\n", - "165 1 0 0 1 0 \n", - "197 4 4 0 1 0 \n", - "78 26 19 0 0 1 \n", - "64 11 11 1 0 0 \n", - "166 21 8 0 0 1 \n", + "165 1 0 False True False \n", + "197 4 4 False True False \n", + "78 26 19 False False True \n", + "64 11 11 True False False \n", + "166 21 8 False False True \n", "\n", " discipline_A discipline_B sex_Female sex_Male \n", - "165 0 1 0 1 \n", - "197 0 1 0 1 \n", - "78 0 1 0 1 \n", - "64 0 1 1 0 \n", - "166 0 1 0 1 " + "165 False True False True \n", + "197 False True False True \n", + "78 False True False True \n", + "64 False True True False \n", + "166 False True False True " ] }, "execution_count": 7, @@ -634,6 +634,342 @@ "cell_type": "code", "execution_count": 12, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<138x5 sparse matrix of type ''\n", + "\twith 276 stored elements in Compressed Sparse Row format>" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "encoder.transform(X_train_raw[categorical_columns])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [1., 0., 0., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [1., 0., 0., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 1., 0., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [1., 0., 0., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [1., 0., 0., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [1., 0., 0., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 1., 0.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [1., 0., 0., 1., 0.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [1., 0., 0., 1., 0.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [1., 0., 0., 1., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 1., 0., 1.]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "encoder1 = OneHotEncoder(sparse_output=False)\n", + "encoder1.fit(X_train_raw[categorical_columns])\n", + "encoder1.transform(X_train_raw[categorical_columns])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.compose import make_column_transformer" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "transformer = make_column_transformer(\n", + " (OneHotEncoder(sparse_output=False, handle_unknown=\"ignore\"),categorical_columns),\n", + " remainder=\"passthrough\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.0, 1.0, 0.0, ..., 1, 0, 'Male'],\n", + " [0.0, 1.0, 0.0, ..., 4, 4, 'Male'],\n", + " [0.0, 0.0, 1.0, ..., 26, 19, 'Male'],\n", + " ...,\n", + " [0.0, 1.0, 0.0, ..., 3, 3, 'Female'],\n", + " [0.0, 0.0, 1.0, ..., 25, 25, 'Female'],\n", + " [0.0, 0.0, 1.0, ..., 15, 14, 'Male']], dtype=object)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transformer.fit(X_train_raw)\n", + "transformer.transform(X_train_raw)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['onehotencoder__rank_AssocProf', 'onehotencoder__rank_AsstProf',\n", + " 'onehotencoder__rank_Prof', 'onehotencoder__discipline_A',\n", + " 'onehotencoder__discipline_B', 'remainder__yrs.since.phd',\n", + " 'remainder__yrs.service', 'remainder__sex'], dtype=object)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transformer.get_feature_names_out()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import OrdinalEncoder" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "transformer = make_column_transformer(\n", + " (OneHotEncoder(sparse_output=False, handle_unknown=\"ignore\"), categorical_columns),\n", + " (OrdinalEncoder(), [\"sex\"]),\n", + " remainder=\"passthrough\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "X_train_transformed = transformer.fit_transform(X_train_raw)\n", + "X_test_transformed = transformer.transform(X_test_raw)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array(['onehotencoder__rank_AssocProf', 'onehotencoder__rank_AsstProf',\n", + " 'onehotencoder__rank_Prof', 'onehotencoder__discipline_A',\n", + " 'onehotencoder__discipline_B', 'ordinalencoder__sex',\n", + " 'remainder__yrs.since.phd', 'remainder__yrs.service'], dtype=object),\n", + " 0 1 2 3 4 5 6 7\n", + " 0 1.0 0.0 0.0 1.0 0.0 1.0 19.0 16.0\n", + " 1 0.0 0.0 1.0 1.0 0.0 1.0 35.0 23.0\n", + " 2 0.0 0.0 1.0 0.0 1.0 1.0 17.0 3.0\n", + " 3 0.0 1.0 0.0 0.0 1.0 1.0 3.0 1.0\n", + " 4 1.0 0.0 0.0 0.0 1.0 1.0 8.0 8.0\n", + " 5 0.0 1.0 0.0 0.0 1.0 1.0 5.0 5.0\n", + " 6 1.0 0.0 0.0 0.0 1.0 1.0 12.0 8.0\n", + " 7 0.0 0.0 1.0 1.0 0.0 1.0 56.0 57.0\n", + " 8 0.0 1.0 0.0 1.0 0.0 0.0 3.0 1.0\n", + " 9 0.0 0.0 1.0 0.0 1.0 1.0 37.0 37.0)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transformer.get_feature_names_out(), pd.DataFrame(X_test_transformed).head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Škálování" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Přeškálování není vždy nutné, ale některým modelům to může pomoci. Řiďte se tedy pravidlem, že rozhodně neuškodí.\n", + "Využijeme [StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html#sklearn.preprocessing.StandardScaler).\n", + "\n", + "StandardScaler nám hodnoty přeškáluje, aby zhruba odpovídaly normálnímu rozdělení. Některé algoritmy to předpokládají. Pokud bychom neškálovali, mohlo by se stát, že příznak (sloupeček), která má výrazně větší rozptyl než ostatní, je brán jako významnější. \n", + "\n", + "Nejprve si ukažme jednoduchý příklad." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, "outputs": [ { "data": { @@ -656,143 +992,258 @@ " \n", " \n", " \n", - " yrs.since.phd\n", - " yrs.service\n", - " sex\n", - " rank_AssocProf\n", - " rank_AsstProf\n", - " rank_Prof\n", - " discipline_A\n", - " discipline_B\n", + " a\n", + " b\n", " \n", " \n", " \n", " \n", - " 165\n", - " 1\n", - " 0\n", - " 0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", + " 0\n", + " 100.888984\n", + " -260.878801\n", " \n", " \n", - " 197\n", - " 4\n", - " 4\n", - " 0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", + " 1\n", + " 100.496064\n", + " -65.508528\n", " \n", " \n", - " 78\n", - " 26\n", - " 19\n", - " 0\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 1.0\n", + " 2\n", + " 100.055572\n", + " 59.374218\n", + " \n", + " \n", + " 3\n", + " 100.060233\n", + " 121.281507\n", + " \n", + " \n", + " 4\n", + " 98.560538\n", + " 20.311355\n", + " \n", + " \n", + " 5\n", + " 99.616512\n", + " 4.957273\n", + " \n", + " \n", + " 6\n", + " 100.886202\n", + " 161.057846\n", + " \n", + " \n", + " 7\n", + " 99.766297\n", + " 127.399339\n", + " \n", + " \n", + " 8\n", + " 100.044351\n", + " -86.858194\n", + " \n", + " \n", + " 9\n", + " 98.823873\n", + " 11.641098\n", + " \n", + " \n", + " 10\n", + " 100.445507\n", + " 36.016900\n", + " \n", + " \n", + " 11\n", + " 98.538243\n", + " 171.859937\n", + " \n", + " \n", + " 12\n", + " 100.289883\n", + " 86.607052\n", + " \n", + " \n", + " 13\n", + " 99.812775\n", + " -10.357610\n", + " \n", + " \n", + " 14\n", + " 98.256715\n", + " 22.007433\n", + " \n", + " \n", + " 15\n", + " 101.069478\n", + " -188.388349\n", + " \n", + " \n", + " 16\n", + " 99.836135\n", + " 96.862848\n", + " \n", + " \n", + " 17\n", + " 101.860778\n", + " 64.573279\n", + " \n", + " \n", + " 18\n", + " 101.478252\n", + " 121.215643\n", + " \n", + " \n", + " 19\n", + " 99.120532\n", + " -14.404930\n", + " \n", + " \n", + "\n", + "" + ], + "text/plain": [ + " a b\n", + "0 100.888984 -260.878801\n", + "1 100.496064 -65.508528\n", + "2 100.055572 59.374218\n", + "3 100.060233 121.281507\n", + "4 98.560538 20.311355\n", + "5 99.616512 4.957273\n", + "6 100.886202 161.057846\n", + "7 99.766297 127.399339\n", + "8 100.044351 -86.858194\n", + "9 98.823873 11.641098\n", + "10 100.445507 36.016900\n", + "11 98.538243 171.859937\n", + "12 100.289883 86.607052\n", + "13 99.812775 -10.357610\n", + "14 98.256715 22.007433\n", + "15 101.069478 -188.388349\n", + "16 99.836135 96.862848\n", + "17 101.860778 64.573279\n", + "18 101.478252 121.215643\n", + "19 99.120532 -14.404930" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import StandardScaler \n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns \n", + "\n", + "# vygeneruje 20 náhodných bodů\n", + "example = pd.DataFrame({\"a\": 100+np.random.randn(100), \"b\": 100*np.random.randn(100)})\n", + "example.head(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
ab
count100.000000100.000000
mean99.914380-1.182795
std0.967421107.772840
min97.540807-260.878801
25%99.252158-75.710666
64111111.00.00.00.01.050%99.8464265.370076
16621800.00.01.00.01.075%100.74027366.216316
max101.860778217.284230
\n", "
" ], "text/plain": [ - " yrs.since.phd yrs.service sex rank_AssocProf rank_AsstProf \\\n", - "165 1 0 0 0.0 1.0 \n", - "197 4 4 0 0.0 1.0 \n", - "78 26 19 0 0.0 0.0 \n", - "64 11 11 1 1.0 0.0 \n", - "166 21 8 0 0.0 0.0 \n", - "\n", - " rank_Prof discipline_A discipline_B \n", - "165 0.0 0.0 1.0 \n", - "197 0.0 0.0 1.0 \n", - "78 1.0 0.0 1.0 \n", - "64 0.0 0.0 1.0 \n", - "166 1.0 0.0 1.0 " + " a b\n", + "count 100.000000 100.000000\n", + "mean 99.914380 -1.182795\n", + "std 0.967421 107.772840\n", + "min 97.540807 -260.878801\n", + "25% 99.252158 -75.710666\n", + "50% 99.846426 5.370076\n", + "75% 100.740273 66.216316\n", + "max 101.860778 217.284230" ] }, - "execution_count": 12, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "def transform_data(X_raw):\n", - " # vytvoříme nový dataframe obsahující z původního všechny číselné sloupce\n", - " transformed = X_raw[numerical_columns].copy()\n", - " # přidáme sloupec \"sex\" jednoduchým překódováním původního sloupce \n", - " transformed[\"sex\"] = X_raw[\"sex\"].replace({\"Male\": 0, \"Female\": 1})\n", - " # z OneHotEncoderu dostaneme pouze matici hodnot, připravíme si pro ni v dataframe volné sloupce,\n", - " # t.j. přidáme sloupce ze seznamu column_names\n", - " transformed = transformed.reindex(columns=list(transformed.columns)+list(column_names))\n", - " # do těchto sloupců nasypeme výstup OneHotEncoderu aplikovaného na kategorické sloupce\n", - " transformed[column_names] = encoder.transform(X_raw[categorical_columns]).toarray() \n", - " return transformed\n", - "\n", - "X_train_transformed = transform_data(X_train_raw)\n", - "X_test_transformed = transform_data(X_test_raw)\n", - "\n", - "X_train_transformed.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Škálování" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Přeškálování není vždy nutné, ale některým modelům to může pomoci. Řiďte se tedy pravidlem, že rozhodně neuškodí.\n", - "Využijeme [StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html#sklearn.preprocessing.StandardScaler).\n", - "\n", - "StandardScaler nám hodnoty přeškáluje, aby zhruba odpovídaly normálnímu rozdělení. Některé algoritmy to předpokládají. Může se pak např. stát, že příznak (sloupeček), která má výrazně větší rozptyl než ostatní, je brán jako významnější. \n", - "\n", - "Nejprve si ukažme jednoduchý příklad." + "example.describe()" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -802,13 +1253,6 @@ } ], "source": [ - "from sklearn.preprocessing import StandardScaler \n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns \n", - "\n", - "# vygeneruje 20 náhodných bodů\n", - "example = pd.DataFrame({\"x\": 100+np.random.randn(100), \"y\": 100*np.random.randn(100)})\n", - "\n", "example_scaler = StandardScaler()\n", "transformed_example = example_scaler.fit_transform(example)\n", "\n", @@ -819,53 +1263,105 @@ "sns.histplot(transformed_example, ax=ax2);" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Zpátky k našim datům. Transformaci musíme nastavit (fit) pouze na trénovacích datech, škálovat pak budeme stejným způsobem trénovací i testovací data." - ] - }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
count1.000000e+021.000000e+02
mean8.699708e-155.551115e-18
std1.005038e+001.005038e+00
min-2.465865e+00-2.421800e+00
25%-6.879710e-01-6.950112e-01
50%-7.059610e-026.110893e-02
75%8.580067e-016.285318e-01
max2.022080e+002.037319e+00
\n", + "
" + ], "text/plain": [ - "array([[-1.52392312, -1.3377031 , -0.37482778, ..., -1.21007674,\n", - " -0.58292866, 0.58292866],\n", - " [-1.27246669, -0.98473364, -0.37482778, ..., -1.21007674,\n", - " -0.58292866, 0.58292866],\n", - " [ 0.57154709, 0.33890184, -0.37482778, ..., 0.82639387,\n", - " -0.58292866, 0.58292866],\n", - " ...,\n", - " [-1.3562855 , -1.072976 , 2.66789188, ..., -1.21007674,\n", - " -0.58292866, 0.58292866],\n", - " [ 0.48772828, 0.86835603, 2.66789188, ..., 0.82639387,\n", - " -0.58292866, 0.58292866],\n", - " [-0.3504598 , -0.10230999, -0.37482778, ..., 0.82639387,\n", - " -0.58292866, 0.58292866]])" + " 0 1\n", + "count 1.000000e+02 1.000000e+02\n", + "mean 8.699708e-15 5.551115e-18\n", + "std 1.005038e+00 1.005038e+00\n", + "min -2.465865e+00 -2.421800e+00\n", + "25% -6.879710e-01 -6.950112e-01\n", + "50% -7.059610e-02 6.110893e-02\n", + "75% 8.580067e-01 6.285318e-01\n", + "max 2.022080e+00 2.037319e+00" ] }, - "execution_count": 14, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "scaler = StandardScaler()\n", - "\n", - "X_train = scaler.fit_transform(X_train_transformed)\n", - "X_test = scaler.transform(X_test_transformed)\n", - "\n", - "X_train" + "pd.DataFrame(transformed_example).describe()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -889,180 +1385,100 @@ " \n", " \n", " \n", - " yrs.since.phd\n", - " yrs.service\n", - " sex\n", - " rank_AssocProf\n", - " rank_AsstProf\n", - " rank_Prof\n", - " discipline_A\n", - " discipline_B\n", + " 0\n", + " 1\n", " \n", " \n", " \n", " \n", " 0\n", - " -1.523923\n", - " -1.337703\n", - " -0.374828\n", - " -0.470360\n", - " 1.857852\n", - " -1.210077\n", - " -0.582929\n", - " 0.582929\n", + " 1.012500\n", + " -2.421800\n", " \n", " \n", " 1\n", - " -1.272467\n", - " -0.984734\n", - " -0.374828\n", - " -0.470360\n", - " 1.857852\n", - " -1.210077\n", - " -0.582929\n", - " 0.582929\n", + " 0.604302\n", + " -0.599871\n", " \n", " \n", " 2\n", - " 0.571547\n", - " 0.338902\n", - " -0.374828\n", - " -0.470360\n", - " -0.538256\n", - " 0.826394\n", - " -0.582929\n", - " 0.582929\n", + " 0.146683\n", + " 0.564726\n", " \n", " \n", " 3\n", - " -0.685735\n", - " -0.367037\n", - " 2.667892\n", - " 2.126029\n", - " -0.538256\n", - " -1.210077\n", - " -0.582929\n", - " 0.582929\n", + " 0.151525\n", + " 1.142043\n", " \n", " \n", " 4\n", - " 0.152453\n", - " -0.631764\n", - " -0.374828\n", - " -0.470360\n", - " -0.538256\n", - " 0.826394\n", - " -0.582929\n", - " 0.582929\n", - " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " \n", - " \n", - " 133\n", - " 0.739185\n", - " 1.839022\n", - " -0.374828\n", - " -0.470360\n", - " -0.538256\n", - " 0.826394\n", - " -0.582929\n", - " 0.582929\n", - " \n", - " \n", - " 134\n", - " 0.487728\n", - " 0.250659\n", - " -0.374828\n", - " -0.470360\n", - " -0.538256\n", - " 0.826394\n", - " -0.582929\n", - " 0.582929\n", - " \n", - " \n", - " 135\n", - " -1.356286\n", - " -1.072976\n", - " 2.667892\n", - " -0.470360\n", - " 1.857852\n", - " -1.210077\n", - " -0.582929\n", - " 0.582929\n", - " \n", - " \n", - " 136\n", - " 0.487728\n", - " 0.868356\n", - " 2.667892\n", - " -0.470360\n", - " -0.538256\n", - " 0.826394\n", - " -0.582929\n", - " 0.582929\n", - " \n", - " \n", - " 137\n", - " -0.350460\n", - " -0.102310\n", - " -0.374828\n", - " -0.470360\n", - " -0.538256\n", - " 0.826394\n", - " -0.582929\n", - " 0.582929\n", + " -1.406483\n", + " 0.200444\n", " \n", " \n", "\n", - "

138 rows × 8 columns

\n", "" ], "text/plain": [ - " yrs.since.phd yrs.service sex rank_AssocProf rank_AsstProf \\\n", - "0 -1.523923 -1.337703 -0.374828 -0.470360 1.857852 \n", - "1 -1.272467 -0.984734 -0.374828 -0.470360 1.857852 \n", - "2 0.571547 0.338902 -0.374828 -0.470360 -0.538256 \n", - "3 -0.685735 -0.367037 2.667892 2.126029 -0.538256 \n", - "4 0.152453 -0.631764 -0.374828 -0.470360 -0.538256 \n", - ".. ... ... ... ... ... \n", - "133 0.739185 1.839022 -0.374828 -0.470360 -0.538256 \n", - "134 0.487728 0.250659 -0.374828 -0.470360 -0.538256 \n", - "135 -1.356286 -1.072976 2.667892 -0.470360 1.857852 \n", - "136 0.487728 0.868356 2.667892 -0.470360 -0.538256 \n", - "137 -0.350460 -0.102310 -0.374828 -0.470360 -0.538256 \n", - "\n", - " rank_Prof discipline_A discipline_B \n", - "0 -1.210077 -0.582929 0.582929 \n", - "1 -1.210077 -0.582929 0.582929 \n", - "2 0.826394 -0.582929 0.582929 \n", - "3 -1.210077 -0.582929 0.582929 \n", - "4 0.826394 -0.582929 0.582929 \n", - ".. ... ... ... \n", - "133 0.826394 -0.582929 0.582929 \n", - "134 0.826394 -0.582929 0.582929 \n", - "135 -1.210077 -0.582929 0.582929 \n", - "136 0.826394 -0.582929 0.582929 \n", - "137 0.826394 -0.582929 0.582929 \n", - "\n", - "[138 rows x 8 columns]" + " 0 1\n", + "0 1.012500 -2.421800\n", + "1 0.604302 -0.599871\n", + "2 0.146683 0.564726\n", + "3 0.151525 1.142043\n", + "4 -1.406483 0.200444" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(transformed_example).head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zpátky k našim datům. Transformaci musíme nastavit (fit) pouze na trénovacích datech, škálovat pak budeme stejným způsobem trénovací i testovací data." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.47036043, 1.85785169, -1.21007674, ..., 0.37482778,\n", + " -1.52392312, -1.3377031 ],\n", + " [-0.47036043, 1.85785169, -1.21007674, ..., 0.37482778,\n", + " -1.27246669, -0.98473364],\n", + " [-0.47036043, -0.5382561 , 0.82639387, ..., 0.37482778,\n", + " 0.57154709, 0.33890184],\n", + " ...,\n", + " [-0.47036043, 1.85785169, -1.21007674, ..., -2.66789188,\n", + " -1.3562855 , -1.072976 ],\n", + " [-0.47036043, -0.5382561 , 0.82639387, ..., -2.66789188,\n", + " 0.48772828, 0.86835603],\n", + " [-0.47036043, -0.5382561 , 0.82639387, ..., 0.37482778,\n", + " -0.3504598 , -0.10230999]])" ] }, - "execution_count": 15, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "pd.DataFrame(X_train, columns=X_train_transformed.columns)" + "scaler = StandardScaler()\n", + "\n", + "X_train = scaler.fit_transform(X_train_transformed)\n", + "X_test = scaler.transform(X_test_transformed)\n", + "\n", + "X_train" ] }, { @@ -1115,7 +1531,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -1140,9 +1556,427 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "model.fit(X_train, y_train)" ] @@ -1163,7 +1997,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -1180,7 +2014,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1218,7 +2052,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -1242,71 +2076,71 @@ " \n", " \n", " \n", + " rank\n", + " discipline\n", " yrs.since.phd\n", " yrs.service\n", " sex\n", - " AssocProf\n", - " AsstProf\n", - " Prof\n", - " A\n", - " B\n", " \n", " \n", " \n", " \n", " 0\n", - " 5\n", - " 4\n", - " 0\n", - " 0\n", - " 1\n", - " 0\n", - " 0\n", - " 1\n", + " Prof\n", + " B\n", + " 15\n", + " 10\n", + " Male\n", " \n", " \n", "\n", "" ], "text/plain": [ - " yrs.since.phd yrs.service sex AssocProf AsstProf Prof A B\n", - "0 5 4 0 0 1 0 0 1" + " rank discipline yrs.since.phd yrs.service sex\n", + "0 Prof B 15 10 Male" ] }, - "execution_count": 20, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dotaz = pd.DataFrame({\n", - " \"yrs.since.phd\": 5,\n", - " \"yrs.service\": 4,\n", - " \"sex\": 0,\n", - " \"AssocProf\": 0,\n", - " \"AsstProf\": 1,\n", - " \"Prof\": 0,\n", - " \"A\": 0,\n", - " \"B\": 1\n", + " \"rank\": \"Prof\",\n", + " \"discipline\": \"B\",\n", + " \"yrs.since.phd\": 15,\n", + " \"yrs.service\": 10,\n", + " \"sex\": \"Male\",\n", "}, index=[0])\n", "dotaz" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "X_query = scaler.transform(transformer.transform(dotaz))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Odhadovaný plat vašeho pracovníka je: 92517.39403735907\n" + "Odhadovaný plat vašeho pracovníka je: 132301.01\n" ] } ], "source": [ - "print(\"Odhadovaný plat vašeho pracovníka je: \", model.predict(dotaz.values)[0])" + "print(f\"Odhadovaný plat vašeho pracovníka je: {model.predict(X_query)[0]:.2f}\")" ] }, { @@ -1325,7 +2159,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -1333,7 +2167,7 @@ "output_type": "stream", "text": [ "R2 na trénovací množině: 0.5135908532845631\n", - "R2 na testovací množině: 0.5444018189943944\n" + "R2 na testovací množině: 0.5444018189943942\n" ] } ], @@ -1352,7 +2186,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -1401,16 +2235,16 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.5444018189943944" + "0.5444018189943942" ] }, - "execution_count": 24, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -1456,9 +2290,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.12.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 79800ddb17c427288ed87603bce2b487ad42e367 Mon Sep 17 00:00:00 2001 From: Petra Vidnerova Date: Sun, 10 Nov 2024 14:08:05 +0100 Subject: [PATCH 2/5] visualization fixed transformation changed --- lessons/pydata/homework_revisited/index.ipynb | 362 ++++++++++-------- 1 file changed, 203 insertions(+), 159 deletions(-) diff --git a/lessons/pydata/homework_revisited/index.ipynb b/lessons/pydata/homework_revisited/index.ipynb index fc82691..7923668 100644 --- a/lessons/pydata/homework_revisited/index.ipynb +++ b/lessons/pydata/homework_revisited/index.ipynb @@ -19,6 +19,17 @@ "np.random.seed(42)" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "from sklearn.exceptions import ConvergenceWarning\n", + "warnings.filterwarnings(\"ignore\", category=ConvergenceWarning)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -28,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -194,7 +205,7 @@ "[123 rows x 7 columns]" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -216,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -235,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -254,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -278,73 +289,83 @@ " \n", " \n", " \n", - " Length1\n", - " Length2\n", - " Length3\n", - " Height\n", - " Width\n", - " Species_Bream\n", - " Species_Parkki\n", - " Species_Perch\n", - " Species_Pike\n", - " Species_Roach\n", - " Species_Smelt\n", - " Species_Whitefish\n", + " onehotencoder__Species_Bream\n", + " onehotencoder__Species_Parkki\n", + " onehotencoder__Species_Perch\n", + " onehotencoder__Species_Pike\n", + " onehotencoder__Species_Roach\n", + " onehotencoder__Species_Smelt\n", + " onehotencoder__Species_Whitefish\n", + " remainder__Length1\n", + " remainder__Length2\n", + " remainder__Length3\n", + " remainder__Height\n", + " remainder__Width\n", " \n", " \n", " \n", " \n", - " 11\n", + " 0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", " 28.7\n", " 31.0\n", " 36.2\n", " 14.3714\n", " 4.8146\n", - " 1.0\n", + " \n", + " \n", + " 1\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 45\n", " 20.5\n", " 22.5\n", " 25.3\n", " 7.0334\n", " 3.8203\n", + " \n", + " \n", + " 2\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 26\n", " 32.0\n", " 35.0\n", " 40.6\n", " 16.3618\n", " 6.0900\n", - " 1.0\n", + " \n", + " \n", + " 3\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 87\n", " 20.0\n", " 22.0\n", " 23.5\n", " 5.6400\n", " 3.5250\n", + " \n", + " \n", + " 4\n", " 0.0\n", " 0.0\n", " 1.0\n", @@ -352,21 +373,11 @@ " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 74\n", " 13.8\n", " 15.0\n", " 16.0\n", " 3.8240\n", " 2.4320\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", " \n", " \n", " ...\n", @@ -384,79 +395,79 @@ " ...\n", " \n", " \n", - " 123\n", + " 81\n", + " 0.0\n", + " 0.0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", " 39.0\n", " 42.0\n", " 44.6\n", " 12.8002\n", " 6.8684\n", + " \n", + " \n", + " 82\n", + " 1.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 29\n", " 33.5\n", " 37.0\n", " 42.6\n", " 18.9570\n", " 6.6030\n", - " 1.0\n", + " \n", + " \n", + " 83\n", " 0.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 130\n", " 32.7\n", " 35.0\n", " 38.8\n", " 5.9364\n", " 4.3844\n", + " \n", + " \n", + " 84\n", " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", - " \n", - " \n", - " 153\n", " 11.4\n", " 12.0\n", " 13.2\n", " 2.2044\n", " 1.1484\n", + " \n", + " \n", + " 85\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", - " \n", - " \n", - " 101\n", " 25.0\n", " 26.5\n", " 28.0\n", " 7.1680\n", " 4.1440\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", " \n", " \n", "\n", @@ -464,71 +475,94 @@ "" ], "text/plain": [ - " Length1 Length2 Length3 Height Width Species_Bream \\\n", - "11 28.7 31.0 36.2 14.3714 4.8146 1.0 \n", - "45 20.5 22.5 25.3 7.0334 3.8203 0.0 \n", - "26 32.0 35.0 40.6 16.3618 6.0900 1.0 \n", - "87 20.0 22.0 23.5 5.6400 3.5250 0.0 \n", - "74 13.8 15.0 16.0 3.8240 2.4320 0.0 \n", - ".. ... ... ... ... ... ... \n", - "123 39.0 42.0 44.6 12.8002 6.8684 0.0 \n", - "29 33.5 37.0 42.6 18.9570 6.6030 1.0 \n", - "130 32.7 35.0 38.8 5.9364 4.3844 0.0 \n", - "153 11.4 12.0 13.2 2.2044 1.1484 0.0 \n", - "101 25.0 26.5 28.0 7.1680 4.1440 0.0 \n", + " onehotencoder__Species_Bream onehotencoder__Species_Parkki \\\n", + "0 1.0 0.0 \n", + "1 0.0 0.0 \n", + "2 1.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + ".. ... ... \n", + "81 0.0 0.0 \n", + "82 1.0 0.0 \n", + "83 0.0 0.0 \n", + "84 0.0 0.0 \n", + "85 0.0 0.0 \n", + "\n", + " onehotencoder__Species_Perch onehotencoder__Species_Pike \\\n", + "0 0.0 0.0 \n", + "1 0.0 0.0 \n", + "2 0.0 0.0 \n", + "3 1.0 0.0 \n", + "4 1.0 0.0 \n", + ".. ... ... \n", + "81 1.0 0.0 \n", + "82 0.0 0.0 \n", + "83 0.0 1.0 \n", + "84 0.0 0.0 \n", + "85 1.0 0.0 \n", + "\n", + " onehotencoder__Species_Roach onehotencoder__Species_Smelt \\\n", + "0 0.0 0.0 \n", + "1 1.0 0.0 \n", + "2 0.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + ".. ... ... \n", + "81 0.0 0.0 \n", + "82 0.0 0.0 \n", + "83 0.0 0.0 \n", + "84 0.0 1.0 \n", + "85 0.0 0.0 \n", "\n", - " Species_Parkki Species_Perch Species_Pike Species_Roach \\\n", - "11 0.0 0.0 0.0 0.0 \n", - "45 0.0 0.0 0.0 1.0 \n", - "26 0.0 0.0 0.0 0.0 \n", - "87 0.0 1.0 0.0 0.0 \n", - "74 0.0 1.0 0.0 0.0 \n", - ".. ... ... ... ... \n", - "123 0.0 1.0 0.0 0.0 \n", - "29 0.0 0.0 0.0 0.0 \n", - "130 0.0 0.0 1.0 0.0 \n", - "153 0.0 0.0 0.0 0.0 \n", - "101 0.0 1.0 0.0 0.0 \n", + " onehotencoder__Species_Whitefish remainder__Length1 remainder__Length2 \\\n", + "0 0.0 28.7 31.0 \n", + "1 0.0 20.5 22.5 \n", + "2 0.0 32.0 35.0 \n", + "3 0.0 20.0 22.0 \n", + "4 0.0 13.8 15.0 \n", + ".. ... ... ... \n", + "81 0.0 39.0 42.0 \n", + "82 0.0 33.5 37.0 \n", + "83 0.0 32.7 35.0 \n", + "84 0.0 11.4 12.0 \n", + "85 0.0 25.0 26.5 \n", "\n", - " Species_Smelt Species_Whitefish \n", - "11 0.0 0.0 \n", - "45 0.0 0.0 \n", - "26 0.0 0.0 \n", - "87 0.0 0.0 \n", - "74 0.0 0.0 \n", - ".. ... ... \n", - "123 0.0 0.0 \n", - "29 0.0 0.0 \n", - "130 0.0 0.0 \n", - "153 1.0 0.0 \n", - "101 0.0 0.0 \n", + " remainder__Length3 remainder__Height remainder__Width \n", + "0 36.2 14.3714 4.8146 \n", + "1 25.3 7.0334 3.8203 \n", + "2 40.6 16.3618 6.0900 \n", + "3 23.5 5.6400 3.5250 \n", + "4 16.0 3.8240 2.4320 \n", + ".. ... ... ... \n", + "81 44.6 12.8002 6.8684 \n", + "82 42.6 18.9570 6.6030 \n", + "83 38.8 5.9364 4.3844 \n", + "84 13.2 2.2044 1.1484 \n", + "85 28.0 7.1680 4.1440 \n", "\n", "[86 rows x 12 columns]" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.compose import make_column_transformer\n", "\n", "categorical_columns = [\"Species\"] \n", "\n", - "encoder = OneHotEncoder()\n", - "encoder.fit(X_train_raw[categorical_columns])\n", - "column_names = encoder.get_feature_names_out()\n", - " \n", - "def transform_species(X_raw):\n", - " X_res = X_raw.drop(columns=[\"Species\"])\n", - " X_res = X_res.reindex(columns=list(X_res.columns)+list(column_names))\n", - " X_res[list(column_names)] = encoder.transform(X_raw[categorical_columns]).toarray() \n", - " return X_res\n", + "transformer = make_column_transformer(\n", + " (OneHotEncoder(sparse_output=False), [\"Species\"]),\n", + " remainder=\"passthrough\"\n", + ")\n", "\n", - "X_train_onehot = transform_species(X_train_raw)\n", - "X_test_onehot = transform_species(X_test_raw)\n", - "X_train_onehot" + "X_train_onehot = transformer.fit_transform(X_train_raw)\n", + "X_test_onehot = transformer.transform(X_test_raw)\n", + "\n", + "pd.DataFrame(X_train_onehot, columns=transformer.get_feature_names_out())" ] }, { @@ -540,7 +574,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -590,7 +624,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -600,7 +634,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -631,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -658,19 +692,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/petra/pydata-course/podzim_2022/venv/lib/python3.9/site-packages/sklearn/linear_model/_coordinate_descent.py:648: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations, check the scale of the features or consider increasing regularisation. Duality gap: 1.667e+03, tolerance: 1.127e+03\n", - " model = cd_fast.enet_coordinate_descent(\n", - "/home/petra/pydata-course/podzim_2022/venv/lib/python3.9/site-packages/sklearn/linear_model/_coordinate_descent.py:648: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations, check the scale of the features or consider increasing regularisation. Duality gap: 3.308e+05, tolerance: 1.127e+03\n", - " model = cd_fast.enet_coordinate_descent(\n" - ] - }, { "data": { "text/html": [ @@ -710,18 +734,18 @@ " \n", " \n", " 1\n", - " 65.457444\n", - " 7999.732745\n", - " 67.698824\n", - " 7481.296957\n", + " 65.461029\n", + " 8000.189809\n", + " 67.699174\n", + " 7481.774269\n", " lasso_var1\n", " \n", " \n", " 2\n", - " 65.143581\n", - " 7723.470509\n", - " 66.929641\n", - " 7734.792363\n", + " 65.162065\n", + " 7730.766645\n", + " 66.984117\n", + " 7743.530561\n", " lasso_var2\n", " \n", " \n", @@ -747,13 +771,13 @@ "text/plain": [ " MAE_train MSE_train MAE_test MSE_test model\n", "0 65.075967 7438.347512 64.076083 7327.508225 linear_regression\n", - "1 65.457444 7999.732745 67.698824 7481.296957 lasso_var1\n", - "2 65.143581 7723.470509 66.929641 7734.792363 lasso_var2\n", + "1 65.461029 8000.189809 67.699174 7481.774269 lasso_var1\n", + "2 65.162065 7730.766645 66.984117 7743.530561 lasso_var2\n", "3 14.885810 1083.558622 29.440300 1983.156024 SVR_rbf\n", "4 15.792914 1263.177350 37.137981 3351.282774 SVR_poly" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -778,7 +802,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -813,7 +837,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -823,13 +847,13 @@ "y_real_test = test_data.pop(\"Weight\")\n", "X_real_test = test_data \n", "\n", - "X_real_test = transform_species(X_real_test)\n", - "X_real_test_scaled = scaler.transform(X_real_test)" + "X_real_test_transformed = transformer.transform(X_real_test)\n", + "X_real_test_scaled = scaler.transform(X_real_test_transformed)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -837,7 +861,8 @@ "output_type": "stream", "text": [ "MAE 37.263\n", - "MSE 4050.929\n" + "MSE 4050.929\n", + "R2 0.972\n" ] } ], @@ -845,12 +870,13 @@ "y_pred_test = best_model.predict(X_real_test_scaled)\n", "\n", "print(f\"MAE {mean_absolute_error(y_real_test, y_pred_test):.3f}\")\n", - "print(f\"MSE {mean_squared_error(y_real_test, y_pred_test):.3f}\")" + "print(f\"MSE {mean_squared_error(y_real_test, y_pred_test):.3f}\")\n", + "print(f\"R2 {r2_score(y_real_test, y_pred_test):.3f}\")" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -917,17 +943,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "is_bream = X_real_test[\"Species_Bream\"] == 1 \n", + "is_bream = X_real_test[\"Species\"] == \"Bream\"\n", "bream = X_real_test[is_bream][\"Length3\"]\n", "\n", "bream_weights = y_real_test[is_bream]\n", "predicted_bream_weights = best_model.predict(X_real_test_scaled[is_bream])\n", "\n", - "is_roach = X_real_test[\"Species_Roach\"] == 1\n", + "is_roach = X_real_test[\"Species\"] == \"Roach\"\n", "roach = X_real_test[is_roach][\"Length3\"]\n", "roach_weights = y_real_test[is_roach]\n", "predicted_roach_weights = best_model.predict(X_real_test_scaled[is_roach])" @@ -935,12 +961,31 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "result_bream = pd.DataFrame()\n", + "result_bream[\"length\"] = bream\n", + "result_bream[\"weight\"] = bream_weights\n", + "result_bream[\"predicted\"] = predicted_bream_weights\n", + "result_bream = result_bream.sort_values(\"length\")\n", + "\n", + "result_roach = pd.DataFrame()\n", + "result_roach[\"length\"] = roach\n", + "result_roach[\"weight\"] = roach_weights\n", + "result_roach[\"predicted\"] = predicted_roach_weights\n", + "result_roach = result_roach.sort_values(\"length\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -951,17 +996,16 @@ ], "source": [ "import matplotlib.pyplot as plt \n", - "%matplotlib inline\n", "\n", "fig, ax = plt.subplots(1, 2)\n", "\n", - "ax[0].scatter(bream, bream_weights, label=\"true weight\");\n", - "ax[0].scatter(bream, predicted_bream_weights, label=\"prediction\");\n", + "ax[0].plot(result_bream[\"length\"], result_bream[\"weight\"], label=\"true weight\", marker=\"o\");\n", + "ax[0].plot(result_bream[\"length\"], result_bream[\"predicted\"], label=\"prediction\", marker=\"o\");\n", "ax[0].legend()\n", "ax[0].set_title(\"Bream\")\n", "\n", - "ax[1].scatter(roach, roach_weights, label=\"true weight\");\n", - "ax[1].scatter(roach, predicted_roach_weights, label=\"prediction\");\n", + "ax[1].plot(result_roach[\"length\"], result_roach[\"weight\"], label=\"true weight\", marker=\"o\");\n", + "ax[1].plot(result_roach[\"length\"], result_roach[\"predicted\"], label=\"prediction\", marker=\"o\");\n", "ax[1].legend()\n", "ax[1].set_title(\"Roach\");" ] @@ -983,9 +1027,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.12.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 174a67b2c1e8d2f79d946232831f0f5937104611 Mon Sep 17 00:00:00 2001 From: Petra Vidnerova Date: Sun, 10 Nov 2024 14:15:56 +0100 Subject: [PATCH 3/5] kosmeticka uprava --- lessons/pydata/homework_revisited/index.ipynb | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/lessons/pydata/homework_revisited/index.ipynb b/lessons/pydata/homework_revisited/index.ipynb index 7923668..1b2cebe 100644 --- a/lessons/pydata/homework_revisited/index.ipynb +++ b/lessons/pydata/homework_revisited/index.ipynb @@ -948,14 +948,9 @@ "outputs": [], "source": [ "is_bream = X_real_test[\"Species\"] == \"Bream\"\n", - "bream = X_real_test[is_bream][\"Length3\"]\n", - "\n", - "bream_weights = y_real_test[is_bream]\n", "predicted_bream_weights = best_model.predict(X_real_test_scaled[is_bream])\n", "\n", "is_roach = X_real_test[\"Species\"] == \"Roach\"\n", - "roach = X_real_test[is_roach][\"Length3\"]\n", - "roach_weights = y_real_test[is_roach]\n", "predicted_roach_weights = best_model.predict(X_real_test_scaled[is_roach])" ] }, @@ -966,14 +961,14 @@ "outputs": [], "source": [ "result_bream = pd.DataFrame()\n", - "result_bream[\"length\"] = bream\n", - "result_bream[\"weight\"] = bream_weights\n", + "result_bream[\"length\"] = X_real_test[is_bream][\"Length3\"]\n", + "result_bream[\"weight\"] = y_real_test[is_bream]\n", "result_bream[\"predicted\"] = predicted_bream_weights\n", "result_bream = result_bream.sort_values(\"length\")\n", "\n", "result_roach = pd.DataFrame()\n", - "result_roach[\"length\"] = roach\n", - "result_roach[\"weight\"] = roach_weights\n", + "result_roach[\"length\"] = X_real_test[is_roach][\"Length3\"]\n", + "result_roach[\"weight\"] = y_real_test[is_roach]\n", "result_roach[\"predicted\"] = predicted_roach_weights\n", "result_roach = result_roach.sort_values(\"length\")" ] From 64eb53ca3074ebcdb9189480379f8012fe68f326 Mon Sep 17 00:00:00 2001 From: Petra Vidnerova Date: Sun, 10 Nov 2024 15:19:14 +0100 Subject: [PATCH 4/5] aktualizovana pracovni verze notebooku --- .../homework_revisited/index_na_hodinu.ipynb | 131 ++++++++++++------ 1 file changed, 91 insertions(+), 40 deletions(-) diff --git a/lessons/pydata/homework_revisited/index_na_hodinu.ipynb b/lessons/pydata/homework_revisited/index_na_hodinu.ipynb index 8f34a53..2b829a8 100644 --- a/lessons/pydata/homework_revisited/index_na_hodinu.ipynb +++ b/lessons/pydata/homework_revisited/index_na_hodinu.ipynb @@ -19,6 +19,24 @@ "np.random.seed(42)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "from sklearn.exceptions import ConvergenceWarning\n", + "warnings.filterwarnings(\"ignore\", category=ConvergenceWarning)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**ÚKOL 1**: Načtěte data, vyhoďte přebytečné sloupce, vyberte vstupy a výstupy a připravte rozdělení na trénovací a testovací množinu.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -33,7 +51,7 @@ "outputs": [], "source": [ "fish_data = pd.read_csv(\"fish_data.csv\", index_col=0)\n", - "# fish_data = fish_data.drop(columns=[____])\n", + "# fish_data = fish_data.drop(columns=[___])\n", "fish_data" ] }, @@ -73,8 +91,14 @@ "source": [ "from sklearn.model_selection import train_test_split \n", "\n", - "X_train_raw, X_test_raw, y_train, y_test = train_test_split(X, y)\n", - "# X_train_raw, X_test_raw, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=X[\"Species\"])" + "X_train_raw, X_test_raw, y_train, y_test = ..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**ÚKOL 2**: Překódujte kategorické proměnné a přeškálujte všechny sloupce." ] }, { @@ -91,22 +115,19 @@ "outputs": [], "source": [ "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.compose import make_column_transformer\n", "\n", - "categorical_columns = [____] \n", + "categorical_columns = ___ \n", "\n", - "encoder = OneHotEncoder()\n", - "encoder.fit(X_train_raw[categorical_columns])\n", - "column_names = encoder.get_feature_names_out()\n", - " \n", - "def transform_species(X_raw):\n", - " X_res = X_raw.drop(columns=[\"Species\"])\n", - " X_res = X_res.reindex(columns=list(X_res.columns)+list(column_names))\n", - " X_res[list(column_names)] = encoder.transform(X_raw[categorical_columns]).toarray() \n", - " return X_res\n", + "transformer = make_column_transformer(\n", + " (_______, _____),\n", + " remainder=\"passthrough\"\n", + ")\n", "\n", - "X_train_onehot = transform_species(X_train_raw)\n", - "X_test_onehot = transform_species(X_test_raw)\n", - "X_train_onehot" + "X_train_onehot = transformer._______(X_train_raw)\n", + "X_test_onehot = transformer.________(X_test_raw)\n", + "\n", + "pd.DataFrame(X_train_onehot, columns=transformer.get_feature_names_out())" ] }, { @@ -124,11 +145,11 @@ "source": [ "from sklearn.preprocessing import StandardScaler\n", "\n", - "scaler = StandardScaler()\n", - "scaler.____(X_train_onehot)\n", + "scaler = ______\n", + "scaler._____(_____)\n", "\n", - "X_train = scaler.____(X_train_onehot)\n", - "X_test = scaler.____(X_test_onehot)" + "X_train = scaler.transform(X_train_onehot)\n", + "X_test = scaler.transform(X_test_onehot)" ] }, { @@ -151,6 +172,13 @@ " * C, float, optional (default=1.0)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -207,6 +235,13 @@ "``` " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**ÚKOL 3**: Dopište funkci `fit_and_eval` dle instrukcí." + ] + }, { "cell_type": "code", "execution_count": null, @@ -218,11 +253,13 @@ "def fit_and_eval(X_train, y_train, X_test, y_test, model, name):\n", " \"\"\" 1. Natrénuje model na trénovací množině.\n", " 2. Spočte hodnoty metrik na trénovací i testovací množině.\n", - " vrátí slovník ve tvaru {\"název metriky train\": hodnota , \"název metriky test\": hodnota} \n", + " vrátí slovník ve tvaru {\"název metriky\": hodnota} \n", " \"\"\" \n", - " ...\n", + " # zde dopiš kód\n", + " ... \n", " return {\n", - " .... \n", + " \"MSE_test\": ____,\n", + " \"MSE_train\": ____\n", " }" ] }, @@ -296,8 +333,8 @@ "y_real_test = test_data.pop(\"Weight\")\n", "X_real_test = test_data \n", "\n", - "X_real_test = transform_species(X_real_test)\n", - "X_real_test_scaled = scaler.transform(X_real_test)" + "X_real_test_transformed = _____\n", + "X_real_test_scaled = _______" ] }, { @@ -309,7 +346,8 @@ "y_pred_test = best_model.predict(X_real_test_scaled)\n", "\n", "print(f\"MAE {mean_absolute_error(y_real_test, y_pred_test):.3f}\")\n", - "print(f\"MSE {mean_squared_error(y_real_test, y_pred_test):.3f}\")" + "print(f\"MSE {mean_squared_error(y_real_test, y_pred_test):.3f}\")\n", + "print(f\"R2 {r2_score(y_real_test, y_pred_test):.3f}\")" ] }, { @@ -342,18 +380,32 @@ "metadata": {}, "outputs": [], "source": [ - "is_bream = X_real_test[\"Species_Bream\"] == 1 \n", - "bream = X_real_test[is_bream][\"Length3\"]\n", - "\n", - "bream_weights = y_real_test[is_bream]\n", + "is_bream = X_real_test[\"Species\"] == \"Bream\"\n", "predicted_bream_weights = best_model.predict(X_real_test_scaled[is_bream])\n", "\n", - "is_roach = X_real_test[\"Species_Roach\"] == 1\n", - "roach = X_real_test[is_roach][\"Length3\"]\n", - "roach_weights = y_real_test[is_roach]\n", + "is_roach = X_real_test[\"Species\"] == \"Roach\"\n", "predicted_roach_weights = best_model.predict(X_real_test_scaled[is_roach])" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "result_bream = pd.DataFrame()\n", + "result_bream[\"length\"] = X_real_test[is_bream][\"Length3\"]\n", + "result_bream[\"weight\"] = y_real_test[is_bream]\n", + "result_bream[\"predicted\"] = predicted_bream_weights\n", + "result_bream = result_bream.sort_values(\"length\")\n", + "\n", + "result_roach = pd.DataFrame()\n", + "result_roach[\"length\"] = X_real_test[is_roach][\"Length3\"]\n", + "result_roach[\"weight\"] = y_real_test[is_roach]\n", + "result_roach[\"predicted\"] = predicted_roach_weights\n", + "result_roach = result_roach.sort_values(\"length\")" + ] + }, { "cell_type": "code", "execution_count": null, @@ -361,17 +413,16 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt \n", - "%matplotlib inline\n", "\n", "fig, ax = plt.subplots(1, 2)\n", "\n", - "ax[0].scatter(bream, bream_weights, label=\"true weight\");\n", - "ax[0].scatter(bream, predicted_bream_weights, label=\"prediction\");\n", + "ax[0].plot(result_bream[\"length\"], result_bream[\"weight\"], label=\"true weight\", marker=\"o\");\n", + "ax[0].plot(result_bream[\"length\"], result_bream[\"predicted\"], label=\"prediction\", marker=\"o\");\n", "ax[0].legend()\n", "ax[0].set_title(\"Bream\")\n", "\n", - "ax[1].scatter(roach, roach_weights, label=\"true weight\");\n", - "ax[1].scatter(roach, predicted_roach_weights, label=\"prediction\");\n", + "ax[1].plot(result_roach[\"length\"], result_roach[\"weight\"], label=\"true weight\", marker=\"o\");\n", + "ax[1].plot(result_roach[\"length\"], result_roach[\"predicted\"], label=\"prediction\", marker=\"o\");\n", "ax[1].legend()\n", "ax[1].set_title(\"Roach\");" ] @@ -393,9 +444,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.12.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From d5aebd6fbe392bd44f6b2a88513c8749a8d53914 Mon Sep 17 00:00:00 2001 From: Petra Vidnerova Date: Sun, 10 Nov 2024 15:22:02 +0100 Subject: [PATCH 5/5] ML2 do obsahu kurzu --- course.yml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/course.yml b/course.yml index bfefe21..fa4b503 100644 --- a/course.yml +++ b/course.yml @@ -63,6 +63,14 @@ plan: - lesson: pydata/regression_exercises - lesson: pydata/regression_resume + - title: "Strojové učení - Scikit-learn, ML workflow" + slug: ml2 + date: 2024-11-11 + materials: + - lesson: pydata/scikitlearn_api + - lesson: pydata/homework_revisited + - lesson: pydata/scikitlearn_resume + - title: "Svátky klidu a konce kurzu" slug: konec serial: null