From 224b835c09cd2f7d917305a52d326722263604f4 Mon Sep 17 00:00:00 2001 From: sfc-gh-oazarmanesh Date: Wed, 23 Aug 2023 14:20:48 -0700 Subject: [PATCH] Changes made to match updates to snowflake.ml package --- ...MO_model_building_scoring-checkpoint.ipynb | 672 ++++++++ ...additional_models_xgboost-checkpoint.ipynb | 219 +++ ...dditional_models_lightgbm-checkpoint.ipynb | 216 +++ ...rameter_tuning_gridsearch-checkpoint.ipynb | 236 +++ ...asic_data_exploration_transformation.ipynb | 749 ++++++++- ...full_data_exploration_transformation.ipynb | 1434 +++++++++++++++-- hol/2_1_DEMO_model_building_scoring.ipynb | 327 +++- ...1_SOLUTION_additional_models_xgboost.ipynb | 109 +- ..._SOLUTION_additional_models_lightgbm.ipynb | 162 +- ...EMO_hyperparameter_tuning_gridsearch.ipynb | 70 +- 10 files changed, 3901 insertions(+), 293 deletions(-) create mode 100644 hol/.ipynb_checkpoints/2_1_DEMO_model_building_scoring-checkpoint.ipynb create mode 100644 hol/.ipynb_checkpoints/3_1_SOLUTION_additional_models_xgboost-checkpoint.ipynb create mode 100644 hol/.ipynb_checkpoints/3_2_SOLUTION_additional_models_lightgbm-checkpoint.ipynb create mode 100644 hol/.ipynb_checkpoints/4_1_DEMO_hyperparameter_tuning_gridsearch-checkpoint.ipynb diff --git a/hol/.ipynb_checkpoints/2_1_DEMO_model_building_scoring-checkpoint.ipynb b/hol/.ipynb_checkpoints/2_1_DEMO_model_building_scoring-checkpoint.ipynb new file mode 100644 index 0000000..7bf0f3c --- /dev/null +++ b/hol/.ipynb_checkpoints/2_1_DEMO_model_building_scoring-checkpoint.ipynb @@ -0,0 +1,672 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2e339e77", + "metadata": {}, + "source": [ + "# DEMO: Model Building and Scoring (Logistic Regression)" + ] + }, + { + "cell_type": "markdown", + "id": "73ac09a3", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "a7d72538", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2cb04fd9", + "metadata": {}, + "outputs": [], + "source": [ + "from snowflake.snowpark.session import Session\n", + "import snowflake.snowpark.functions as F\n", + "import snowflake.snowpark.types as T\n", + "\n", + "from snowflake.ml.modeling.linear_model import LogisticRegression\n", + "\n", + "import json\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "id": "22a0aaa1", + "metadata": {}, + "source": [ + "Get installed versions of the libraries we will use later when deploying to Snowflake" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e3b512a8", + "metadata": {}, + "outputs": [], + "source": [ + "with open('packages_version.json') as f:\n", + " packages_version = json.load(f)" + ] + }, + { + "cell_type": "markdown", + "id": "11413743", + "metadata": {}, + "source": [ + "## Create Snowpark Session" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "381310d7", + "metadata": {}, + "outputs": [], + "source": [ + "with open('creds.json') as f:\n", + " connection_parameters = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9cc080c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Database and schema: \"HOL_DB\".\"PUBLIC\"\n", + "Current Warehouse: \"HOL_WH\"\n" + ] + } + ], + "source": [ + "session = Session.builder.configs(connection_parameters).create()\n", + "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", + "print(f\"Current Warehouse: {session.get_current_warehouse()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2a42a5d2", + "metadata": {}, + "source": [ + "## Prepare Snowflake Stage to store Models" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d264e18c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Row(status='Stage area ML_MODELS successfully created.')]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "session.sql('CREATE OR REPLACE STAGE ML_MODELS').collect()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7c293f32", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
created_onnamedatabase_nameschema_nameurlhas_credentialshas_encryption_keyownercommentregiontypecloudnotification_channelstorage_integrationowner_role_type
02023-08-15 10:26:49.058000-07:00ML_MODELSHOL_DBPUBLICNNACCOUNTADMINNoneINTERNALNoneNoneNoneROLE
12023-08-15 10:26:15.749000-07:00ML_PROCSHOL_DBPUBLICNNACCOUNTADMINNoneINTERNALNoneNoneNoneROLE
22023-08-14 20:24:28.304000-07:00MODEL_STAGEHOL_DBPUBLICNNACCOUNTADMINNoneINTERNALNoneNoneNoneROLE
\n", + "
" + ], + "text/plain": [ + " created_on name database_name schema_name url \\\n", + "0 2023-08-15 10:26:49.058000-07:00 ML_MODELS HOL_DB PUBLIC \n", + "1 2023-08-15 10:26:15.749000-07:00 ML_PROCS HOL_DB PUBLIC \n", + "2 2023-08-14 20:24:28.304000-07:00 MODEL_STAGE HOL_DB PUBLIC \n", + "\n", + " has_credentials has_encryption_key owner comment region type \\\n", + "0 N N ACCOUNTADMIN None INTERNAL \n", + "1 N N ACCOUNTADMIN None INTERNAL \n", + "2 N N ACCOUNTADMIN None INTERNAL \n", + "\n", + " cloud notification_channel storage_integration owner_role_type \n", + "0 None None None ROLE \n", + "1 None None None ROLE \n", + "2 None None None ROLE " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(session.sql('SHOW STAGES').collect())" + ] + }, + { + "cell_type": "markdown", + "id": "24d093ad", + "metadata": {}, + "source": [ + "# Model Building\n", + "\n", + "We will use the balanced data set we created in the last part." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "570a3776", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|0 |29819 |\n", + "|1 |29819 |\n", + "----------------------\n", + "\n" + ] + } + ], + "source": [ + "application_record_balanced_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED')\n", + "application_record_balanced_sdf.group_by('TARGET').count().show()" + ] + }, + { + "cell_type": "markdown", + "id": "dd19116e", + "metadata": {}, + "source": [ + "We are going to use stratified sampling of the data. Using **sample_by** allows us to sample based on one column and also specify the fractions of each value in the column." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d91ebf56", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|1 |23868 |\n", + "|0 |23843 |\n", + "----------------------\n", + "\n" + ] + } + ], + "source": [ + "train_sdf = application_record_balanced_sdf.sample_by(\"TARGET\", {1: 0.8, 0: 0.8})\n", + "train_sdf = train_sdf.cache_result()\n", + "train_sdf.group_by('TARGET').count().show()" + ] + }, + { + "cell_type": "markdown", + "id": "ca734c35", + "metadata": {}, + "source": [ + "The test data set is the rest of the rows, by using **minus** we can exclude the rows from the train_sdf DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0297ff43", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|0 |5976 |\n", + "|1 |4850 |\n", + "----------------------\n", + "\n" + ] + } + ], + "source": [ + "test_sdf = application_record_balanced_sdf.minus(train_sdf)\n", + "test_sdf.group_by('TARGET').count().show()" + ] + }, + { + "cell_type": "markdown", + "id": "c3fe042a", + "metadata": {}, + "source": [ + "Save the training and test data into tables" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f455553a", + "metadata": {}, + "outputs": [], + "source": [ + "train_sdf.write.save_as_table(table_name='CREDIT_RISK_PREPARED_BALANCED_TRAIN', mode='overwrite')\n", + "test_sdf.write.save_as_table(table_name='CREDIT_RISK_PREPARED_BALANCED_TEST', mode='overwrite')\n", + "\n", + "train_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TRAIN')\n", + "test_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TEST')" + ] + }, + { + "cell_type": "markdown", + "id": "a4083f48", + "metadata": {}, + "source": [ + "Fit a LogisticRegression model using snowpark-ml, the fitting is pushed down to Snowflake and is using scikit-learn behind the scene." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6983af6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feature_cols = train_sdf.columns\n", + "feature_cols.remove('TARGET')\n", + "feature_cols.remove('ID')\n", + "target_col = 'TARGET'\n", + "\n", + "lm = LogisticRegression(C=0.8, solver='lbfgs',random_state=0, input_cols=feature_cols, label_cols=target_col, output_cols=['PREDICTION'])\n", + "lm.fit(train_sdf)" + ] + }, + { + "cell_type": "markdown", + "id": "b9e4c195", + "metadata": {}, + "source": [ + "Plot Feature Coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5e951c2f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feature_coefficients = pd.DataFrame(lm.to_sklearn().coef_.T,lm.to_sklearn().feature_names_in_,columns=['Coefficient'])\n", + "feature_coefficients.sort_values('Coefficient').plot.barh(y='Coefficient', figsize=(5,15))" + ] + }, + { + "cell_type": "markdown", + "id": "8097c837", + "metadata": {}, + "source": [ + "The fitted model can be retrived as a scickit-learn object if it would be used outside Snwoflake." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b1fbbbaf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sklearn.linear_model._logistic.LogisticRegression" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "skl_ml = lm.to_sklearn()\n", + "type(skl_ml)" + ] + }, + { + "cell_type": "markdown", + "id": "19a60347", + "metadata": {}, + "source": [ + "# Model Scoring" + ] + }, + { + "cell_type": "markdown", + "id": "95c5ff7a", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "acbb5608", + "metadata": {}, + "source": [ + "Using the predict method of the snowpark-ml model will push down the scoring into Snowflake, it can be applied on a Snowpark DataFrame or a Pandas DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c28783e5", + "metadata": {}, + "outputs": [], + "source": [ + "scored_snowml_sdf = lm.predict(test_sdf)\n", + "# Saving it as a table so we do not call the predict function when using the scored DataFrame\n", + "scored_snowml_sdf.write.save_as_table(table_name='CREDIT_RISK_PREPARED_BALANCED_TRAIN_SCORED', mode='overwrite')" + ] + }, + { + "cell_type": "markdown", + "id": "98cac9aa", + "metadata": {}, + "source": [ + "# Model Evaluation" + ] + }, + { + "cell_type": "markdown", + "id": "e90db3e5", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5381ced6", + "metadata": {}, + "outputs": [], + "source": [ + "scored_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TRAIN_SCORED')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5990a3f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------\n", + "|\"TARGET\" |\"CAST('0.0' AS FLOAT)\" |\"CAST('1.0' AS FLOAT)\" |\n", + "--------------------------------------------------------------\n", + "|1 |2182 |2668 |\n", + "|0 |3805 |2171 |\n", + "--------------------------------------------------------------\n", + "\n" + ] + } + ], + "source": [ + "# Obtaining a simple confusion matrix\n", + "scored_sdf.crosstab('TARGET','PREDICTION').show()" + ] + }, + { + "cell_type": "markdown", + "id": "34e1289f", + "metadata": {}, + "source": [ + "Calculate the Accuracy, Precision, Recall and F1 metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a21ddd7f", + "metadata": {}, + "outputs": [], + "source": [ + "def calc_metrics(snf_df):\n", + " return snf_df.group_by(['TARGET','PREDICTION']).count()\\\n", + " .with_column(\"type\", F.when((F.col(\"TARGET\") == 0) & (F.col(\"PREDICTION\") == 0), \"tn\")\\\n", + " .when((F.col(\"TARGET\") == 0) & (F.col(\"PREDICTION\") == 1), \"fp\")\\\n", + " .when((F.col(\"TARGET\") == 1) & (F.col(\"PREDICTION\") == 0), \"fn\")\\\n", + " .when((F.col(\"TARGET\") == 1) & (F.col(\"PREDICTION\") == 1), \"tp\"))\\\n", + " .select([\"TYPE\", \"COUNT\"]).pivot(\"TYPE\", ['tn', 'tp', 'fn', 'fp']).sum(\"COUNT\")\\\n", + " .with_columns([\"accuracy\", \"precision\", \"recall\"],\n", + " [((F.col(\"'tp'\") + F.col(\"'tn'\")) / (F.col(\"'tp'\") + F.col(\"'tn'\") + F.col(\"'fn'\") + F.col(\"'fp'\")))\n", + " , (F.col(\"'tp'\") / (F.col(\"'tp'\") + F.col(\"'fp'\")))\n", + " ,(F.col(\"'tp'\") / (F.col(\"'tp'\") + F.col(\"'fn'\")))])\\\n", + " .with_column(\"f1\", (F.lit(2)*F.col(\"precision\")*F.col(\"recall\")) / (F.col(\"precision\")+F.col(\"recall\")))\\\n", + " .select([\"ACCURACY\",\"PRECISION\", \"RECALL\",\"F1\"]).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "16087bac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------\n", + "|\"ACCURACY\" |\"PRECISION\" |\"RECALL\" |\"F1\" |\n", + "--------------------------------------------------------\n", + "|0.597912 |0.551354 |0.550103 |0.550727789577 |\n", + "--------------------------------------------------------\n", + "\n" + ] + } + ], + "source": [ + "calc_metrics(scored_sdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f246388b", + "metadata": {}, + "outputs": [], + "source": [ + "session.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a81b7cd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/hol/.ipynb_checkpoints/3_1_SOLUTION_additional_models_xgboost-checkpoint.ipynb b/hol/.ipynb_checkpoints/3_1_SOLUTION_additional_models_xgboost-checkpoint.ipynb new file mode 100644 index 0000000..11f4bf0 --- /dev/null +++ b/hol/.ipynb_checkpoints/3_1_SOLUTION_additional_models_xgboost-checkpoint.ipynb @@ -0,0 +1,219 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2e339e77", + "metadata": {}, + "source": [ + "# SOLUTION: Model Building and Scoring (XGBoost)" + ] + }, + { + "cell_type": "markdown", + "id": "73ac09a3", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "a7d72538", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2cb04fd9", + "metadata": {}, + "outputs": [], + "source": [ + "from snowflake.snowpark.session import Session\n", + "import snowflake.snowpark.types as T\n", + "\n", + "from snowflake.ml.modeling.xgboost import XGBClassifier\n", + "\n", + "import json\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "1f47f8e9", + "metadata": {}, + "source": [ + "Get installed versions of the libraries we will use later when deploying to Snowflake" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f82010d6", + "metadata": {}, + "outputs": [], + "source": [ + "with open('packages_version.json') as f:\n", + " packages_version = json.load(f)\n", + "\n", + "packages_version" + ] + }, + { + "cell_type": "markdown", + "id": "11413743", + "metadata": {}, + "source": [ + "## Create Snowpark Session" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25a54f72", + "metadata": {}, + "outputs": [], + "source": [ + "with open('creds.json') as f:\n", + " connection_parameters = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9cc080c0", + "metadata": {}, + "outputs": [], + "source": [ + "session = Session.builder.configs(connection_parameters).create()\n", + "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", + "print(f\"Current Warehouse: {session.get_current_warehouse()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "24d093ad", + "metadata": {}, + "source": [ + "# Model Building" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4df6c514", + "metadata": {}, + "outputs": [], + "source": [ + "train_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TRAIN')\n", + "test_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TEST')" + ] + }, + { + "cell_type": "markdown", + "id": "74d762b8", + "metadata": {}, + "source": [ + "# SOLUTION: Train an XGBoost Model with ml-snowpark" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0053ffc1", + "metadata": {}, + "outputs": [], + "source": [ + "feature_cols = train_sdf.columns\n", + "feature_cols.remove('TARGET')\n", + "feature_cols.remove('ID')\n", + "target_col = 'TARGET'\n", + "\n", + "xgbmodel = XGBClassifier(random_state=123, input_cols=feature_cols, label_cols=target_col, output_cols='PREDICTION')\n", + "xgbmodel.fit(train_sdf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "794aab3b", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot feature importance\n", + "feat_importance = pd.DataFrame(xgbmodel.get_sklearn_object().feature_importances_,feature_cols,columns=['FeatImportance'])\n", + "feat_importance.sort_values('FeatImportance').plot.barh(y='FeatImportance', figsize=(5,15))" + ] + }, + { + "cell_type": "markdown", + "id": "19a60347", + "metadata": {}, + "source": [ + "# Model Scoring" + ] + }, + { + "cell_type": "markdown", + "id": "95c5ff7a", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "5046b342", + "metadata": {}, + "source": [ + "# SOLUTION: Use the fitted XGBoost Model to score a Snowpark DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fda8e99d", + "metadata": {}, + "outputs": [], + "source": [ + "# Score the data using the fitted xgbmodel\n", + "scored_sdf = xgbmodel.predict(test_sdf)\n", + "scored_sdf.write.save_as_table(table_name='CREDIT_RISK_PREPARED_BALANCED_TEST_SCORED', mode='overwrite')\n", + "session.table('CREDIT_RISK_PREPARED_BALANCED_TEST_SCORED').show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1ffaf68", + "metadata": {}, + "outputs": [], + "source": [ + "session.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/hol/.ipynb_checkpoints/3_2_SOLUTION_additional_models_lightgbm-checkpoint.ipynb b/hol/.ipynb_checkpoints/3_2_SOLUTION_additional_models_lightgbm-checkpoint.ipynb new file mode 100644 index 0000000..b64256c --- /dev/null +++ b/hol/.ipynb_checkpoints/3_2_SOLUTION_additional_models_lightgbm-checkpoint.ipynb @@ -0,0 +1,216 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2e339e77", + "metadata": {}, + "source": [ + "# SOLUTION: Model Building and Scoring (LightGBM)" + ] + }, + { + "cell_type": "markdown", + "id": "73ac09a3", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "a7d72538", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2cb04fd9", + "metadata": {}, + "outputs": [], + "source": [ + "from snowflake.snowpark.session import Session\n", + "import snowflake.snowpark.types as T\n", + "\n", + "from snowflake.ml.modeling.lightgbm import LGBMClassifier\n", + "\n", + "import json\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "c4442706", + "metadata": {}, + "source": [ + "Get installed versions of the libraries we will use later when deploying to Snowflake" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53eceb1b", + "metadata": {}, + "outputs": [], + "source": [ + "with open('packages_version.json') as f:\n", + " packages_version = json.load(f)" + ] + }, + { + "cell_type": "markdown", + "id": "11413743", + "metadata": {}, + "source": [ + "## Create Snowpark Session" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04bad29b", + "metadata": {}, + "outputs": [], + "source": [ + "with open('creds.json') as f:\n", + " connection_parameters = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9cc080c0", + "metadata": {}, + "outputs": [], + "source": [ + "session = Session.builder.configs(connection_parameters).create()\n", + "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", + "print(f\"Current Warehouse: {session.get_current_warehouse()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "24d093ad", + "metadata": {}, + "source": [ + "# Model Building" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4df6c514", + "metadata": {}, + "outputs": [], + "source": [ + "train_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TRAIN')\n", + "test_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TEST')" + ] + }, + { + "cell_type": "markdown", + "id": "b36c435c", + "metadata": {}, + "source": [ + "# SOLUTION: Train a LightGBM Model on a Snowpark DataFrame using snowpark-ml" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "584b35e7", + "metadata": {}, + "outputs": [], + "source": [ + "feature_cols = train_sdf.columns\n", + "feature_cols.remove('TARGET')\n", + "feature_cols.remove('ID')\n", + "target_col = 'TARGET'\n", + "\n", + "lgbmodel = LGBMClassifier(input_cols=feature_cols, label_cols=target_col, output_cols='PREDICTION')\n", + "lgbmodel.fit(train_sdf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bedab745", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot feature importance\n", + "feat_importance = pd.DataFrame(lgbmodel.get_sklearn_object().feature_importances_,feature_cols,columns=['FeatImportance'])\n", + "feat_importance.sort_values('FeatImportance').plot.barh(y='FeatImportance', figsize=(5,15))" + ] + }, + { + "cell_type": "markdown", + "id": "19a60347", + "metadata": {}, + "source": [ + "# Model Scoring" + ] + }, + { + "cell_type": "markdown", + "id": "95c5ff7a", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "3f2baa9c", + "metadata": {}, + "source": [ + "# SOLUTION: Use the fitted LightGBM Model to score a Snowpark DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a31b8cc", + "metadata": {}, + "outputs": [], + "source": [ + "scored_sdf = lgbmodel.predict(test_sdf)\n", + "scored_sdf.write.save_as_table(table_name='CREDIT_RISK_PREPARED_BALANCED_TEST_SCORED', mode='overwrite')\n", + "session.table('CREDIT_RISK_PREPARED_BALANCED_TEST_SCORED').show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f81857e0", + "metadata": {}, + "outputs": [], + "source": [ + "session.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/hol/.ipynb_checkpoints/4_1_DEMO_hyperparameter_tuning_gridsearch-checkpoint.ipynb b/hol/.ipynb_checkpoints/4_1_DEMO_hyperparameter_tuning_gridsearch-checkpoint.ipynb new file mode 100644 index 0000000..6cae8a0 --- /dev/null +++ b/hol/.ipynb_checkpoints/4_1_DEMO_hyperparameter_tuning_gridsearch-checkpoint.ipynb @@ -0,0 +1,236 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2e339e77", + "metadata": {}, + "source": [ + "# DEMO: Hyperparameter Tuning via GridSearchCV" + ] + }, + { + "cell_type": "markdown", + "id": "73ac09a3", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "a7d72538", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2cb04fd9", + "metadata": {}, + "outputs": [], + "source": [ + "from snowflake.snowpark.session import Session\n", + "import snowflake.snowpark.functions as F\n", + "import snowflake.snowpark.types as T\n", + "\n", + "from snowflake.ml.modeling.xgboost import XGBClassifier\n", + "from snowflake.ml.modeling.model_selection import GridSearchCV\n", + "\n", + "import json\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "91955f46", + "metadata": {}, + "source": [ + "Get installed versions of the libraries we will use later when deploying to Snowflake" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e640693e", + "metadata": {}, + "outputs": [], + "source": [ + "with open('packages_version.json') as f:\n", + " packages_version = json.load(f)" + ] + }, + { + "cell_type": "markdown", + "id": "11413743", + "metadata": {}, + "source": [ + "## Create Snowpark Session" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "04bad29b", + "metadata": {}, + "outputs": [], + "source": [ + "with open('creds.json') as f:\n", + " connection_parameters = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9cc080c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Database and schema: \"HOL_DB\".\"PUBLIC\"\n", + "Current Warehouse: \"HOL_WH\"\n" + ] + } + ], + "source": [ + "session = Session.builder.configs(connection_parameters).create()\n", + "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", + "print(f\"Current Warehouse: {session.get_current_warehouse()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "24d093ad", + "metadata": {}, + "source": [ + "# Model Building" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4df6c514", + "metadata": {}, + "outputs": [], + "source": [ + "train_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TRAIN')\n", + "test_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED_TEST')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "442a5131", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feature_cols = train_sdf.columns\n", + "feature_cols.remove('TARGET')\n", + "feature_cols.remove('ID')\n", + "target_col = 'TARGET'\n", + "\n", + "grid_search = GridSearchCV(\n", + " estimator=XGBClassifier(),\n", + " param_grid={\n", + " 'n_estimators':[10,50,100],\n", + " 'max_depth':[2,3,4]\n", + " },\n", + " n_jobs = -1,\n", + " input_cols = feature_cols,\n", + " label_cols = target_col,\n", + " output_cols = 'PREDICTION',\n", + " scoring=\"f1\",\n", + " )\n", + "\n", + "grid_search.fit(train_sdf)" + ] + }, + { + "cell_type": "markdown", + "id": "55c233ba", + "metadata": {}, + "source": [ + "## Analyze GridSearch Results" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "46794ab5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze grid search results\n", + "gs_results = grid_search.to_sklearn().cv_results_\n", + "n_estimators_val = []\n", + "max_depth_val = []\n", + "for param_dict in gs_results[\"params\"]:\n", + " n_estimators_val.append(param_dict[\"n_estimators\"])\n", + " max_depth_val.append(param_dict[\"max_depth\"])\n", + "\n", + "f1_val = gs_results[\"mean_test_score\"]\n", + "gs_results_df = pd.DataFrame(data={\"n_estimators\":n_estimators_val,\n", + " \"max_depth\":max_depth_val, \n", + " 'f1_val':f1_val})\n", + "sns.relplot(data=gs_results_df, x=\"max_depth\", y=\"f1_val\", hue=\"n_estimators\", kind='line')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db5c6afd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/hol/1_1_DEMO_basic_data_exploration_transformation.ipynb b/hol/1_1_DEMO_basic_data_exploration_transformation.ipynb index 14b3c9d..05ac526 100644 --- a/hol/1_1_DEMO_basic_data_exploration_transformation.ipynb +++ b/hol/1_1_DEMO_basic_data_exploration_transformation.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "3b648ee8", "metadata": {}, @@ -10,7 +9,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "2e5d9443", "metadata": {}, @@ -19,7 +17,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "1ed15903", "metadata": {}, @@ -29,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "7410ce0d", "metadata": {}, "outputs": [], @@ -38,7 +35,8 @@ "import snowflake.snowpark.functions as F\n", "import snowflake.snowpark.types as T\n", "from snowflake.snowpark.window import Window\n", - "from snowflake.ml.preprocessing import *\n", + "from snowflake.ml.modeling.preprocessing import *\n", + "from snowflake.ml.modeling.impute import *\n", "\n", "import sys\n", "import json\n", @@ -48,7 +46,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a1f95920", "metadata": {}, @@ -58,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "9a7da15f", "metadata": {}, "outputs": [], @@ -69,10 +66,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "49090e02", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Database and schema: \"HOL_DB\".\"PUBLIC\"\n", + "Current Warehouse: \"HOL_WH\"\n" + ] + } + ], "source": [ "session = Session.builder.configs(connection_parameters).create()\n", "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", @@ -80,7 +86,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "ba1c0c26", "metadata": {}, @@ -90,10 +95,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "8e6d1164", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "# Creating a Pandas DataFrame\n", "pandas_df = pd.read_csv('data/application_record.csv.zip')\n", @@ -102,10 +115,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "623695f6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "# Creating a Snowpark DataFrame\n", "snowpark_df = session.table('APPLICATION_RECORD')\n", @@ -114,10 +135,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "b2d4f6b3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Size in MB of Pandas DataFrame in Memory:\n", + " 251.15\n", + "Size in MB of Snowpark DataFrame in Memory:\n", + " 0.0\n" + ] + } + ], "source": [ "# Compare size\n", "print('Size in MB of Pandas DataFrame in Memory:\\n', np.round(sys.getsizeof(pandas_df) / (1024.0**2), 2))\n", @@ -125,7 +157,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "03ea0fc5", "metadata": {}, @@ -135,16 +166,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "43db7633", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'queries': ['SELECT * FROM (APPLICATION_RECORD)'], 'post_actions': []}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "snowpark_df.queries" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "d3cf44c3", "metadata": {}, @@ -154,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "e1ec1ddc", "metadata": {}, "outputs": [], @@ -163,7 +204,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a7e707de", "metadata": {}, @@ -173,16 +213,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "db95baaf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "((438557, 18), (438557, 18))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "pandas_df.shape, pandas_df2.shape" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "327f42bc", "metadata": {}, @@ -192,17 +242,209 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "aa02b8e8", "metadata": {}, - "outputs": [], + "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", + " \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", + "
IDCODE_GENDERFLAG_OWN_CARFLAG_OWN_REALTYCNT_CHILDRENAMT_INCOME_TOTALNAME_INCOME_TYPENAME_EDUCATION_TYPENAME_FAMILY_STATUSNAME_HOUSING_TYPEDAYS_BIRTHDAYS_EMPLOYEDFLAG_MOBILFLAG_WORK_PHONEFLAG_PHONEFLAG_EMAILOCCUPATION_TYPECNT_FAM_MEMBERS
05008804MYY0427500.0WorkingHigher educationCivil marriageRented apartment-12005-45421100None2.0
15008805MYY0427500.0WorkingHigher educationCivil marriageRented apartment-12005-45421100None2.0
25008806MYY0112500.0WorkingSecondary / secondary specialMarriedHouse / apartment-21474-11341000Security staff2.0
35008808FNY0270000.0Commercial associateSecondary / secondary specialSingle / not marriedHouse / apartment-19110-30511011Sales staff1.0
45008809FNY0270000.0Commercial associateSecondary / secondary specialSingle / not marriedHouse / apartment-19110-30511011Sales staff1.0
\n", + "
" + ], + "text/plain": [ + " ID CODE_GENDER FLAG_OWN_CAR FLAG_OWN_REALTY CNT_CHILDREN \\\n", + "0 5008804 M Y Y 0 \n", + "1 5008805 M Y Y 0 \n", + "2 5008806 M Y Y 0 \n", + "3 5008808 F N Y 0 \n", + "4 5008809 F N Y 0 \n", + "\n", + " AMT_INCOME_TOTAL NAME_INCOME_TYPE NAME_EDUCATION_TYPE \\\n", + "0 427500.0 Working Higher education \n", + "1 427500.0 Working Higher education \n", + "2 112500.0 Working Secondary / secondary special \n", + "3 270000.0 Commercial associate Secondary / secondary special \n", + "4 270000.0 Commercial associate Secondary / secondary special \n", + "\n", + " NAME_FAMILY_STATUS NAME_HOUSING_TYPE DAYS_BIRTH DAYS_EMPLOYED \\\n", + "0 Civil marriage Rented apartment -12005 -4542 \n", + "1 Civil marriage Rented apartment -12005 -4542 \n", + "2 Married House / apartment -21474 -1134 \n", + "3 Single / not married House / apartment -19110 -3051 \n", + "4 Single / not married House / apartment -19110 -3051 \n", + "\n", + " FLAG_MOBIL FLAG_WORK_PHONE FLAG_PHONE FLAG_EMAIL OCCUPATION_TYPE \\\n", + "0 1 1 0 0 None \n", + "1 1 1 0 0 None \n", + "2 1 0 0 0 Security staff \n", + "3 1 0 1 1 Sales staff \n", + "4 1 0 1 1 Sales staff \n", + "\n", + " CNT_FAM_MEMBERS \n", + "0 2.0 \n", + "1 2.0 \n", + "2 2.0 \n", + "3 1.0 \n", + "4 1.0 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# snowpark_df.show() <- also possible\n", "snowpark_df.limit(5).to_pandas() # <- collects first 5 rows and displays as pandas-dataframe" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "de7848e9", "metadata": {}, @@ -213,10 +455,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "79a577f5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------\n", + "|\"CODE_GENDER\" |\"NAME_INCOME_TYPE\" |\"DAYS_BIRTH\" |\n", + "-------------------------------------------------------\n", + "|M |Working |-12005 |\n", + "|M |Working |-12005 |\n", + "|M |Working |-21474 |\n", + "|F |Commercial associate |-19110 |\n", + "|F |Commercial associate |-19110 |\n", + "|F |Commercial associate |-19110 |\n", + "|F |Commercial associate |-19110 |\n", + "|F |Pensioner |-22464 |\n", + "|F |Pensioner |-22464 |\n", + "|F |Pensioner |-22464 |\n", + "-------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# snowpark_df = snowpark_df.select('CODE_GENDER','NAME_INCOME_TYPE','DAYS_BIRTH',)\n", "snowpark_df = snowpark_df[['CODE_GENDER','NAME_INCOME_TYPE','DAYS_BIRTH']] # -> pandas-like selection\n", @@ -224,7 +488,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "16c88906", "metadata": {}, @@ -235,10 +498,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "e207ac8f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------\n", + "|\"CODE_GENDER\" |\"NAME_INCOME_TYPE\" |\"DAYS_BIRTH\" |\"AGE\" |\n", + "---------------------------------------------------------------\n", + "|M |Working |-12005 |32 |\n", + "|M |Working |-12005 |32 |\n", + "|M |Working |-21474 |58 |\n", + "|F |Commercial associate |-19110 |52 |\n", + "|F |Commercial associate |-19110 |52 |\n", + "|F |Commercial associate |-19110 |52 |\n", + "|F |Commercial associate |-19110 |52 |\n", + "|F |Pensioner |-22464 |61 |\n", + "|F |Pensioner |-22464 |61 |\n", + "|F |Pensioner |-22464 |61 |\n", + "---------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# Create a new column\n", "# Formula: Absolute Value of DAYS_BIRTH divided by 365 days rounded down\n", @@ -247,7 +532,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "ed4eabd5", "metadata": {}, @@ -258,10 +542,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "8b6057de", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------------------\n", + "|\"CODE_GENDER\" |\"NAME_INCOME_TYPE\" |\"AGE\" |\n", + "------------------------------------------------\n", + "|M |Working |32 |\n", + "|M |Working |32 |\n", + "|M |Working |58 |\n", + "|F |Commercial associate |52 |\n", + "|F |Commercial associate |52 |\n", + "|F |Commercial associate |52 |\n", + "|F |Commercial associate |52 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# Drop a column\n", "snowpark_df = snowpark_df.drop('DAYS_BIRTH')\n", @@ -269,7 +575,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "ea617ddf", "metadata": {}, @@ -279,10 +584,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "7abe304d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------------\n", + "|\"CODE_GENDER\" |\"NAME_INCOME_TYPE\" |\"AGE\" |\n", + "----------------------------------------------\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |55 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "|F |Pensioner |61 |\n", + "----------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# Filter data\n", "snowpark_df = snowpark_df.filter(F.col('NAME_INCOME_TYPE').in_(['Pensioner','Student']))\n", @@ -290,7 +617,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "cbc21227", "metadata": {}, @@ -300,17 +626,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "1a56c822", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "|\"CODE_GENDER\" |\"NAME_INCOME_TYPE\" |\"AVG_AGE\" |\n", + "--------------------------------------------------\n", + "|F |Pensioner |59.188624 |\n", + "|M |Pensioner |57.685482 |\n", + "|F |Student |46.090909 |\n", + "|M |Student |27.166667 |\n", + "--------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "snowpark_df = snowpark_df.group_by(['CODE_GENDER','NAME_INCOME_TYPE']).agg([F.avg('AGE').as_('AVG_AGE')])\n", "snowpark_df.show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "11a1235e", "metadata": {}, @@ -320,10 +661,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "2196027d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "|\"CODE_GENDER\" |\"NAME_INCOME_TYPE\" |\"AVG_AGE\" |\n", + "--------------------------------------------------\n", + "|F |Pensioner |59.188624 |\n", + "|M |Pensioner |57.685482 |\n", + "|F |Student |46.090909 |\n", + "|M |Student |27.166667 |\n", + "--------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# Sort data\n", "snowpark_df = snowpark_df.sort(F.col('AVG_AGE').desc())\n", @@ -331,7 +688,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "8c5f63dc", "metadata": {}, @@ -343,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "9f2173fb", "metadata": {}, "outputs": [], @@ -353,7 +709,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b7e32fd8", "metadata": {}, @@ -363,17 +718,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "4d4433a5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "438557" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Number of rows in dataset\n", "snowpark_df.count()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5150f9f8", "metadata": {}, @@ -383,10 +748,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "bba56dd6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "438510" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Lets drop duplicates based on ID\n", "snowpark_df = snowpark_df.drop_duplicates('ID')\n", @@ -394,7 +770,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "ae98139b", "metadata": {}, @@ -404,16 +779,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "2f3846b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SELECT \"ID\", \"CODE_GENDER\", \"FLAG_OWN_CAR\", \"FLAG_OWN_REALTY\", \"CNT_CHILDREN\", \"AMT_INCOME_TOTAL\", \"NAME_INCOME_TYPE\", \"NAME_EDUCATION_TYPE\", \"NAME_FAMILY_STATUS\", \"NAME_HOUSING_TYPE\", \"DAYS_BIRTH\", \"DAYS_EMPLOYED\", \"FLAG_MOBIL\", \"FLAG_WORK_PHONE\", \"FLAG_PHONE\", \"FLAG_EMAIL\", \"OCCUPATION_TYPE\", \"CNT_FAM_MEMBERS\" FROM ( SELECT \"ID\", \"CODE_GENDER\", \"FLAG_OWN_CAR\", \"FLAG_OWN_REALTY\", \"CNT_CHILDREN\", \"AMT_INCOME_TOTAL\", \"NAME_INCOME_TYPE\", \"NAME_EDUCATION_TYPE\", \"NAME_FAMILY_STATUS\", \"NAME_HOUSING_TYPE\", \"DAYS_BIRTH\", \"DAYS_EMPLOYED\", \"FLAG_MOBIL\", \"FLAG_WORK_PHONE\", \"FLAG_PHONE\", \"FLAG_EMAIL\", \"OCCUPATION_TYPE\", \"CNT_FAM_MEMBERS\", row_number() OVER (PARTITION BY \"ID\" ORDER BY \"ID\" ASC NULLS FIRST ) AS \"LCUKWNN3E5\" FROM APPLICATION_RECORD) WHERE (\"LCUKWNN3E5\" = 1 :: INT)\n" + ] + } + ], "source": [ "print(snowpark_df.queries['queries'][0])" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "00849069", "metadata": {}, @@ -423,17 +805,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "3ff508f7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|\"SUMMARY\" |\"ID\" |\"CODE_GENDER\" |\"FLAG_OWN_CAR\" |\"FLAG_OWN_REALTY\" |\"CNT_CHILDREN\" |\"AMT_INCOME_TOTAL\" |\"NAME_INCOME_TYPE\" |\"NAME_EDUCATION_TYPE\" |\"NAME_FAMILY_STATUS\" |\"NAME_HOUSING_TYPE\" |\"DAYS_BIRTH\" |\"DAYS_EMPLOYED\" |\"FLAG_MOBIL\" |\"FLAG_WORK_PHONE\" |\"FLAG_PHONE\" |\"FLAG_EMAIL\" |\"OCCUPATION_TYPE\" |\"CNT_FAM_MEMBERS\" |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|mean |6022034.963688 |NULL |NULL |NULL |0.427381 |187525.41572477252 |NULL |NULL |NULL |NULL |-15998.022996 |60566.188769 |1.0 |0.206128 |0.28777 |0.1082 |NULL |2.1944630681170327 |\n", + "|stddev |571496.2397764492 |NULL |NULL |NULL |0.7248737821165834 |110089.27958266277 |NULL |NULL |NULL |NULL |4185.016222145262 |138770.07283492736 |0.0 |0.4045231760974889 |0.45272397771710743 |0.3106332242372023 |NULL |0.8971920109742918 |\n", + "|min |5008804.0 |F |N |N |0.0 |26100.0 |Commercial associate |Academic degree |Civil marriage |Co-op apartment |-25201.0 |-17531.0 |1.0 |0.0 |0.0 |0.0 |Accountants |1.0 |\n", + "|count |438510.0 |438510 |438510 |438510 |438510.0 |438510.0 |438510 |438510 |438510 |438510 |438510.0 |438510.0 |438510.0 |438510.0 |438510.0 |438510.0 |304317 |438510.0 |\n", + "|max |7999952.0 |M |Y |Y |19.0 |6750000.0 |Working |Secondary / secondary special |Widow |With parents |-7489.0 |365243.0 |1.0 |1.0 |1.0 |1.0 |Waiters/barmen staff |20.0 |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# Calculating various statistics per column\n", "snowpark_df.describe().show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "d8b0fef7", "metadata": {}, @@ -443,10 +841,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "9fefe311", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------\n", + "|\"NAME_INCOME_TYPE\" |\"CODE_GENDER\" |\"AVG_INCOME\" |\n", + "-------------------------------------------------------------\n", + "|Commercial associate |M |249208.08642289176 |\n", + "|Commercial associate |F |206579.17463258584 |\n", + "|Pensioner |M |169049.77416737832 |\n", + "|Pensioner |F |150729.61255448588 |\n", + "|State servant |M |237034.15414285715 |\n", + "|State servant |F |186152.9842904419 |\n", + "|Student |F |165272.72727272726 |\n", + "|Student |M |149250.0 |\n", + "|Working |M |202170.82427397132 |\n", + "|Working |F |168679.56899413437 |\n", + "-------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# Average Income per Income Type and Gender\n", "analysis_df = snowpark_df.group_by(['NAME_INCOME_TYPE','CODE_GENDER']).agg([F.mean('AMT_INCOME_TOTAL').as_('AVG_INCOME')])\n", @@ -455,7 +875,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "32f3d751", "metadata": {}, @@ -465,10 +884,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "61273d48", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|\"SUMMARY\" |\"OCCUPATION_TYPE\" |\"ID\" |\"CODE_GENDER\" |\"FLAG_OWN_CAR\" |\"FLAG_OWN_REALTY\" |\"CNT_CHILDREN\" |\"AMT_INCOME_TOTAL\" |\"NAME_INCOME_TYPE\" |\"NAME_EDUCATION_TYPE\" |\"NAME_FAMILY_STATUS\" |\"NAME_HOUSING_TYPE\" |\"DAYS_BIRTH\" |\"DAYS_EMPLOYED\" |\"FLAG_MOBIL\" |\"FLAG_WORK_PHONE\" |\"FLAG_PHONE\" |\"FLAG_EMAIL\" |\"CNT_FAM_MEMBERS\" |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|mean |NULL |6022034.963688 |NULL |NULL |NULL |0.427381 |187525.41572477252 |NULL |NULL |NULL |NULL |-15998.022996 |60566.188769 |1.0 |0.206128 |0.28777 |0.1082 |2.1944630681170327 |\n", + "|min |Accountants |5008804.0 |F |N |N |0.0 |26100.0 |Commercial associate |Academic degree |Civil marriage |Co-op apartment |-25201.0 |-17531.0 |1.0 |0.0 |0.0 |0.0 |1.0 |\n", + "|stddev |NULL |571496.2397764492 |NULL |NULL |NULL |0.7248737821165834 |110089.27958266277 |NULL |NULL |NULL |NULL |4185.016222145262 |138770.07283492736 |0.0 |0.4045231760974889 |0.45272397771710743 |0.3106332242372023 |0.8971920109742918 |\n", + "|count |438510 |438510.0 |438510 |438510 |438510 |438510.0 |438510.0 |438510 |438510 |438510 |438510 |438510.0 |438510.0 |438510.0 |438510.0 |438510.0 |438510.0 |438510.0 |\n", + "|max |Waiters/barmen staff |7999952.0 |M |Y |Y |19.0 |6750000.0 |Working |Secondary / secondary special |Widow |With parents |-7489.0 |365243.0 |1.0 |1.0 |1.0 |1.0 |20.0 |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "my_imputer = SimpleImputer(input_cols=['OCCUPATION_TYPE'], output_cols=['OCCUPATION_TYPE'] ,strategy='most_frequent')\n", "my_imputer.fit(snowpark_df)\n", @@ -477,7 +913,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "991beaa4", "metadata": {}, @@ -487,16 +922,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "bac12f72", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SELECT iff(\"OCCUPATION_TYPE\" IS NULL, 'Laborers', \"OCCUPATION_TYPE\") AS \"OCCUPATION_TYPE\", \"ID\", \"CODE_GENDER\", \"FLAG_OWN_CAR\", \"FLAG_OWN_REALTY\", \"CNT_CHILDREN\", \"AMT_INCOME_TOTAL\", \"NAME_INCOME_TYPE\", \"NAME_EDUCATION_TYPE\", \"NAME_FAMILY_STATUS\", \"NAME_HOUSING_TYPE\", \"DAYS_BIRTH\", \"DAYS_EMPLOYED\", \"FLAG_MOBIL\", \"FLAG_WORK_PHONE\", \"FLAG_PHONE\", \"FLAG_EMAIL\", \"CNT_FAM_MEMBERS\" FROM ( SELECT \"ID\", \"CODE_GENDER\", \"FLAG_OWN_CAR\", \"FLAG_OWN_REALTY\", \"CNT_CHILDREN\", \"AMT_INCOME_TOTAL\", \"NAME_INCOME_TYPE\", \"NAME_EDUCATION_TYPE\", \"NAME_FAMILY_STATUS\", \"NAME_HOUSING_TYPE\", \"DAYS_BIRTH\", \"DAYS_EMPLOYED\", \"FLAG_MOBIL\", \"FLAG_WORK_PHONE\", \"FLAG_PHONE\", \"FLAG_EMAIL\", \"CNT_FAM_MEMBERS\", \"OCCUPATION_TYPE\" AS \"OCCUPATION_TYPE\" FROM ( SELECT \"ID\", \"CODE_GENDER\", \"FLAG_OWN_CAR\", \"FLAG_OWN_REALTY\", \"CNT_CHILDREN\", \"AMT_INCOME_TOTAL\", \"NAME_INCOME_TYPE\", \"NAME_EDUCATION_TYPE\", \"NAME_FAMILY_STATUS\", \"NAME_HOUSING_TYPE\", \"DAYS_BIRTH\", \"DAYS_EMPLOYED\", \"FLAG_MOBIL\", \"FLAG_WORK_PHONE\", \"FLAG_PHONE\", \"FLAG_EMAIL\", \"OCCUPATION_TYPE\", \"CNT_FAM_MEMBERS\", row_number() OVER (PARTITION BY \"ID\" ORDER BY \"ID\" ASC NULLS FIRST ) AS \"LCUKWNN3E5\" FROM APPLICATION_RECORD) WHERE (\"LCUKWNN3E5\" = 1 :: INT))\n" + ] + } + ], "source": [ "print(snowpark_df.queries['queries'][0])" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5b8d26f8", "metadata": {}, @@ -506,16 +948,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "13cca9d1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "StructType([StructField('OCCUPATION_TYPE', StringType(16777216), nullable=True), StructField('ID', LongType(), nullable=True), StructField('CODE_GENDER', StringType(16777216), nullable=True), StructField('FLAG_OWN_CAR', StringType(16777216), nullable=True), StructField('FLAG_OWN_REALTY', StringType(16777216), nullable=True), StructField('CNT_CHILDREN', LongType(), nullable=True), StructField('AMT_INCOME_TOTAL', DoubleType(), nullable=True), StructField('NAME_INCOME_TYPE', StringType(16777216), nullable=True), StructField('NAME_EDUCATION_TYPE', StringType(16777216), nullable=True), StructField('NAME_FAMILY_STATUS', StringType(16777216), nullable=True), StructField('NAME_HOUSING_TYPE', StringType(16777216), nullable=True), StructField('DAYS_BIRTH', LongType(), nullable=True), StructField('DAYS_EMPLOYED', LongType(), nullable=True), StructField('FLAG_MOBIL', LongType(), nullable=True), StructField('FLAG_WORK_PHONE', LongType(), nullable=True), StructField('FLAG_PHONE', LongType(), nullable=True), StructField('FLAG_EMAIL', LongType(), nullable=True), StructField('CNT_FAM_MEMBERS', DoubleType(), nullable=True)])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "snowpark_df.schema" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5b2ae444", "metadata": {}, @@ -525,10 +977,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "17735cdb", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['OCCUPATION_TYPE',\n", + " 'CODE_GENDER',\n", + " 'FLAG_OWN_CAR',\n", + " 'FLAG_OWN_REALTY',\n", + " 'NAME_INCOME_TYPE',\n", + " 'NAME_EDUCATION_TYPE',\n", + " 'NAME_FAMILY_STATUS',\n", + " 'NAME_HOUSING_TYPE']" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Get all categorical columns\n", "categorical_types = [T.StringType]\n", @@ -537,7 +1007,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "e1c1ba4c", "metadata": {}, @@ -547,10 +1016,97 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "682ae682", "metadata": {}, - "outputs": [], + "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", + "
COLUMN_NAMENUM_UNIQUE_VALUES
0OCCUPATION_TYPE18
1CODE_GENDER2
2FLAG_OWN_CAR2
3FLAG_OWN_REALTY2
4NAME_INCOME_TYPE5
5NAME_EDUCATION_TYPE5
6NAME_FAMILY_STATUS5
7NAME_HOUSING_TYPE6
\n", + "
" + ], + "text/plain": [ + " COLUMN_NAME NUM_UNIQUE_VALUES\n", + "0 OCCUPATION_TYPE 18\n", + "1 CODE_GENDER 2\n", + "2 FLAG_OWN_CAR 2\n", + "3 FLAG_OWN_REALTY 2\n", + "4 NAME_INCOME_TYPE 5\n", + "5 NAME_EDUCATION_TYPE 5\n", + "6 NAME_FAMILY_STATUS 5\n", + "7 NAME_HOUSING_TYPE 6" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Number of unique values per categorical column\n", "unique_values = []\n", @@ -560,7 +1116,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "bc3c3a6a", "metadata": {}, @@ -573,10 +1128,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "995c4a8d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|\"OCCUPATION_TYPE\" |\"ID\" |\"CODE_GENDER\" |\"FLAG_OWN_CAR\" |\"FLAG_OWN_REALTY\" |\"CNT_CHILDREN\" |\"AMT_INCOME_TOTAL\" |\"NAME_INCOME_TYPE\" |\"NAME_EDUCATION_TYPE\" |\"NAME_FAMILY_STATUS\" |\"NAME_HOUSING_TYPE\" |\"DAYS_BIRTH\" |\"DAYS_EMPLOYED\" |\"FLAG_MOBIL\" |\"FLAG_WORK_PHONE\" |\"FLAG_PHONE\" |\"FLAG_EMAIL\" |\"CNT_FAM_MEMBERS\" |\n", + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|Core staff |6754942 |F |N |Y |0 |135000.0 |Working |Higher education |Civil marriage |House / apartment |-11745 |-101 |1 |0 |1 |0 |2.0 |\n", + "|Sales staff |6736592 |F |N |Y |0 |112500.0 |Commercial associate |Secondary / secondary special |Single / not married |House / apartment |-8398 |-578 |1 |1 |1 |1 |1.0 |\n", + "|Laborers |5474464 |F |N |N |0 |135000.0 |Pensioner |Secondary / secondary special |Widow |House / apartment |-22064 |365243 |1 |0 |0 |0 |1.0 |\n", + "|Sales staff |6460419 |F |N |Y |1 |67500.0 |Commercial associate |Secondary / secondary special |Separated |House / apartment |-13510 |-3852 |1 |0 |0 |0 |2.0 |\n", + "|Sales staff |6448814 |M |N |Y |0 |166500.0 |Commercial associate |Secondary / secondary special |Civil marriage |House / apartment |-8137 |-610 |1 |1 |1 |0 |2.0 |\n", + "|Managers |7097047 |M |Y |Y |1 |450000.0 |Working |Secondary / secondary special |Married |House / apartment |-15862 |-1463 |1 |0 |0 |0 |3.0 |\n", + "|Laborers |5090669 |F |Y |Y |0 |225000.0 |Working |Secondary / secondary special |Married |House / apartment |-17821 |-1830 |1 |0 |0 |0 |2.0 |\n", + "|Sales staff |5901250 |F |N |N |0 |292500.0 |Working |Higher education |Married |House / apartment |-14458 |-3882 |1 |0 |0 |1 |2.0 |\n", + "|Security staff |6652097 |M |N |Y |0 |144000.0 |Working |Secondary / secondary special |Married |House / apartment |-12652 |-845 |1 |1 |0 |0 |2.0 |\n", + "|Laborers |6231048 |F |N |Y |1 |130500.0 |Working |Higher education |Married |House / apartment |-11646 |-218 |1 |0 |0 |0 |3.0 |\n", + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "snowpark_df.write.save_as_table(table_name='MY_FIRST_ANALYSIS', mode='overwrite')\n", "session.table('MY_FIRST_ANALYSIS').show()" @@ -584,13 +1161,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "a4dc8b69", "metadata": {}, "outputs": [], "source": [ "session.close()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "816763ea-f410-4f25-a7ca-b60f3d32d897", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -609,7 +1194,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.8.17" } }, "nbformat": 4, diff --git a/hol/1_3_DEMO_full_data_exploration_transformation.ipynb b/hol/1_3_DEMO_full_data_exploration_transformation.ipynb index 395ce78..4fb8ea0 100644 --- a/hol/1_3_DEMO_full_data_exploration_transformation.ipynb +++ b/hol/1_3_DEMO_full_data_exploration_transformation.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "3b648ee8", "metadata": {}, @@ -10,7 +9,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "2e5d9443", "metadata": {}, @@ -19,7 +17,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "1ed15903", "metadata": {}, @@ -29,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "7410ce0d", "metadata": {}, "outputs": [], @@ -39,7 +36,7 @@ "import snowflake.snowpark.functions as F\n", "import snowflake.snowpark.types as T\n", "from snowflake.snowpark.window import Window\n", - "from snowflake.ml.preprocessing import *\n", + "from snowflake.ml.modeling.preprocessing import *\n", "\n", "import json\n", "import pandas as pd\n", @@ -47,7 +44,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "183ef59f", "metadata": {}, @@ -57,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "e0abcd13", "metadata": {}, "outputs": [], @@ -68,16 +64,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "f4274fc5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'snowflake-snowpark-python': '1.5.1',\n", + " 'pandas': '1.5.3',\n", + " 'scikit-learn': '1.2.2',\n", + " 'lightgbm': '3.3.5',\n", + " 'xgboost': '1.7.3',\n", + " 'joblib': '1.2.0',\n", + " 'imbalanced-learn': '0.10.1'}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "packages_version" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a1f95920", "metadata": {}, @@ -87,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "d2c8fbaa", "metadata": {}, "outputs": [], @@ -98,10 +110,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "49090e02", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Database and schema: \"HOL_DB\".\"PUBLIC\"\n", + "Current Warehouse: \"HOL_WH\"\n" + ] + } + ], "source": [ "session = Session.builder.configs(connection_parameters).create()\n", "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", @@ -109,7 +130,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "fd745008", "metadata": {}, @@ -120,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "2242ced2", "metadata": {}, "outputs": [], @@ -131,7 +151,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "f2be07e3", "metadata": {}, @@ -141,17 +160,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "57c73d02", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "438557" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# How many records do we have?\n", "application_record_sdf.count()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "399d3874", "metadata": {}, @@ -162,17 +191,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "8f236685", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number Duplicates: 47\n" + ] + } + ], "source": [ "duplicates_sdf = application_record_sdf.group_by('ID').agg(F.count(('ID'))).filter(F.col('COUNT(ID)') > 1)\n", "print('Number Duplicates:', duplicates_sdf.count())" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a4a0c268", "metadata": {}, @@ -182,17 +218,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "98a1205b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "438510" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "application_record_sdf = application_record_sdf.drop_duplicates('ID')\n", "application_record_sdf.count()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "7ec5d998", "metadata": {}, @@ -208,38 +254,254 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "567aff66", "metadata": {}, - "outputs": [], - "source": [ - "application_record_sdf.describe().show()" + "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", + " \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", + "
SUMMARYIDCODE_GENDERFLAG_OWN_CARFLAG_OWN_REALTYCNT_CHILDRENAMT_INCOME_TOTALNAME_INCOME_TYPENAME_EDUCATION_TYPENAME_FAMILY_STATUSNAME_HOUSING_TYPEDAYS_BIRTHDAYS_EMPLOYEDFLAG_MOBILFLAG_WORK_PHONEFLAG_PHONEFLAG_EMAILOCCUPATION_TYPECNT_FAM_MEMBERS
0mean6.022035e+06NoneNoneNone0.4273811.875254e+05NoneNoneNoneNone-15998.02299660566.1887691.00.2061280.2877700.108200None2.194463
1count4.385100e+05438510438510438510438510.0000004.385100e+05438510438510438510438510438510.000000438510.000000438510.0438510.000000438510.000000438510.000000304317438510.000000
2stddev5.714962e+05NoneNoneNone0.7248741.100893e+05NoneNoneNoneNone4185.016222138770.0728350.00.4045230.4527240.310633None0.897192
3min5.008804e+06FNN0.0000002.610000e+04Commercial associateAcademic degreeCivil marriageCo-op apartment-25201.000000-17531.0000001.00.0000000.0000000.000000Accountants1.000000
4max7.999952e+06MYY19.0000006.750000e+06WorkingSecondary / secondary specialWidowWith parents-7489.000000365243.0000001.01.0000001.0000001.000000Waiters/barmen staff20.000000
\n", + "
" + ], + "text/plain": [ + " SUMMARY ID CODE_GENDER FLAG_OWN_CAR FLAG_OWN_REALTY \\\n", + "0 mean 6.022035e+06 None None None \n", + "1 count 4.385100e+05 438510 438510 438510 \n", + "2 stddev 5.714962e+05 None None None \n", + "3 min 5.008804e+06 F N N \n", + "4 max 7.999952e+06 M Y Y \n", + "\n", + " CNT_CHILDREN AMT_INCOME_TOTAL NAME_INCOME_TYPE \\\n", + "0 0.427381 1.875254e+05 None \n", + "1 438510.000000 4.385100e+05 438510 \n", + "2 0.724874 1.100893e+05 None \n", + "3 0.000000 2.610000e+04 Commercial associate \n", + "4 19.000000 6.750000e+06 Working \n", + "\n", + " NAME_EDUCATION_TYPE NAME_FAMILY_STATUS NAME_HOUSING_TYPE \\\n", + "0 None None None \n", + "1 438510 438510 438510 \n", + "2 None None None \n", + "3 Academic degree Civil marriage Co-op apartment \n", + "4 Secondary / secondary special Widow With parents \n", + "\n", + " DAYS_BIRTH DAYS_EMPLOYED FLAG_MOBIL FLAG_WORK_PHONE FLAG_PHONE \\\n", + "0 -15998.022996 60566.188769 1.0 0.206128 0.287770 \n", + "1 438510.000000 438510.000000 438510.0 438510.000000 438510.000000 \n", + "2 4185.016222 138770.072835 0.0 0.404523 0.452724 \n", + "3 -25201.000000 -17531.000000 1.0 0.000000 0.000000 \n", + "4 -7489.000000 365243.000000 1.0 1.000000 1.000000 \n", + "\n", + " FLAG_EMAIL OCCUPATION_TYPE CNT_FAM_MEMBERS \n", + "0 0.108200 None 2.194463 \n", + "1 438510.000000 304317 438510.000000 \n", + "2 0.310633 None 0.897192 \n", + "3 0.000000 Accountants 1.000000 \n", + "4 1.000000 Waiters/barmen staff 20.000000 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# application_record_sdf.describe().show()\n", + "application_record_sdf.describe().to_pandas()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "8fcd6862", "metadata": {}, "source": [ "### Missing Value Imputation\n", "The describe output show that we have missing values in OCCUPATION_TYPE, it's count are less (304317) than the total count (438557) \n", - "We will use the **fillna** ,ethod to replace missing values in OCCUPATION_TYPE with 'OTHER', since they are so many we creates a new category for it." + "We will use the **fillna** method to replace missing values in OCCUPATION_TYPE with 'OTHER', since they are so many we creates a new category for it." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "b292ddf9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|\"SUMMARY\" |\"ID\" |\"CODE_GENDER\" |\"FLAG_OWN_CAR\" |\"FLAG_OWN_REALTY\" |\"CNT_CHILDREN\" |\"AMT_INCOME_TOTAL\" |\"NAME_INCOME_TYPE\" |\"NAME_EDUCATION_TYPE\" |\"NAME_FAMILY_STATUS\" |\"NAME_HOUSING_TYPE\" |\"DAYS_BIRTH\" |\"DAYS_EMPLOYED\" |\"FLAG_MOBIL\" |\"FLAG_WORK_PHONE\" |\"FLAG_PHONE\" |\"FLAG_EMAIL\" |\"OCCUPATION_TYPE\" |\"CNT_FAM_MEMBERS\" |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|count |438510.0 |438510 |438510 |438510 |438510.0 |438510.0 |438510 |438510 |438510 |438510 |438510.0 |438510.0 |438510.0 |438510.0 |438510.0 |438510.0 |438510 |438510.0 |\n", + "|min |5008804.0 |F |N |N |0.0 |26100.0 |Commercial associate |Academic degree |Civil marriage |Co-op apartment |-25201.0 |-17531.0 |1.0 |0.0 |0.0 |0.0 |Accountants |1.0 |\n", + "|stddev |571496.2397764492 |NULL |NULL |NULL |0.7248737821165834 |110089.27958266283 |NULL |NULL |NULL |NULL |4185.016222145262 |138770.07283492736 |0.0 |0.4045231760974889 |0.45272397771710743 |0.3106332242372023 |NULL |0.8971920109742918 |\n", + "|mean |6022034.963688 |NULL |NULL |NULL |0.427381 |187525.41572477252 |NULL |NULL |NULL |NULL |-15998.022996 |60566.188769 |1.0 |0.206128 |0.28777 |0.1082 |NULL |2.1944630681170327 |\n", + "|max |7999952.0 |M |Y |Y |19.0 |6750000.0 |Working |Secondary / secondary special |Widow |With parents |-7489.0 |365243.0 |1.0 |1.0 |1.0 |1.0 |Waiters/barmen staff |20.0 |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "application_record_sdf = application_record_sdf.fillna(value='OTHER', subset=['OCCUPATION_TYPE'])\n", - "application_record_sdf.describe().show()" + "application_record_sdf.describe().show()\n", + "# application_record_sdf.describe().to_pandas() # for better display format" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "8ab67b19", "metadata": {}, @@ -252,10 +514,157 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "724dd8a1", "metadata": {}, - "outputs": [], + "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", + " \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", + "
COLUMN_NAMENUM_UNIQUE_VALUES
0ID438510
1CODE_GENDER2
2FLAG_OWN_CAR2
3FLAG_OWN_REALTY2
4CNT_CHILDREN12
5AMT_INCOME_TOTAL866
6NAME_INCOME_TYPE5
7NAME_EDUCATION_TYPE5
8NAME_FAMILY_STATUS5
9NAME_HOUSING_TYPE6
10DAYS_BIRTH16379
11DAYS_EMPLOYED9406
12FLAG_MOBIL1
13FLAG_WORK_PHONE2
14FLAG_PHONE2
15FLAG_EMAIL2
16OCCUPATION_TYPE19
17CNT_FAM_MEMBERS13
\n", + "
" + ], + "text/plain": [ + " COLUMN_NAME NUM_UNIQUE_VALUES\n", + "0 ID 438510\n", + "1 CODE_GENDER 2\n", + "2 FLAG_OWN_CAR 2\n", + "3 FLAG_OWN_REALTY 2\n", + "4 CNT_CHILDREN 12\n", + "5 AMT_INCOME_TOTAL 866\n", + "6 NAME_INCOME_TYPE 5\n", + "7 NAME_EDUCATION_TYPE 5\n", + "8 NAME_FAMILY_STATUS 5\n", + "9 NAME_HOUSING_TYPE 6\n", + "10 DAYS_BIRTH 16379\n", + "11 DAYS_EMPLOYED 9406\n", + "12 FLAG_MOBIL 1\n", + "13 FLAG_WORK_PHONE 2\n", + "14 FLAG_PHONE 2\n", + "15 FLAG_EMAIL 2\n", + "16 OCCUPATION_TYPE 19\n", + "17 CNT_FAM_MEMBERS 13" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "unique_values = []\n", "for column in application_record_sdf.columns:\n", @@ -264,7 +673,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "4b361107", "metadata": {}, @@ -274,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "b004a868", "metadata": {}, "outputs": [], @@ -283,7 +691,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "c232616e", "metadata": {}, @@ -310,16 +717,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "5e765eec", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"STATUS\" |\"COUNT\" |\n", + "----------------------\n", + "|0 |383120 |\n", + "|1 |11090 |\n", + "|2 |868 |\n", + "|3 |320 |\n", + "|4 |223 |\n", + "|5 |1693 |\n", + "|C |442031 |\n", + "|X |209230 |\n", + "----------------------\n", + "\n" + ] + } + ], "source": [ "credit_record_sdf.group_by('STATUS').count().sort('STATUS').show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "8c78128a", "metadata": {}, @@ -331,10 +757,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "1fb73f51", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"ID\" |\"TARGET\" |\n", + "----------------------\n", + "|5001711 |0 |\n", + "|5001712 |0 |\n", + "|5001713 |0 |\n", + "|5001714 |0 |\n", + "|5001715 |0 |\n", + "|5001717 |0 |\n", + "|5001718 |0 |\n", + "|5001719 |0 |\n", + "|5001720 |0 |\n", + "|5001723 |0 |\n", + "----------------------\n", + "\n" + ] + } + ], "source": [ "cpunt = credit_record_sdf.group_by('ID')\\\n", " .agg(F.sum(F.iff(F.col('STATUS').in_(['2', '3','4','5']), 1, 0)).as_(\"CNT_LATE\"))\\\n", @@ -344,7 +792,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "68100059", "metadata": {}, @@ -355,16 +802,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "212c2392", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "|\"TARGET\" |\"COUNT(TARGET)\" |\n", + "------------------------------\n", + "|0 |45318 |\n", + "|1 |667 |\n", + "------------------------------\n", + "\n" + ] + } + ], "source": [ "cpunt.group_by('TARGET').agg(F.count('TARGET')).show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "668c30ff", "metadata": {}, @@ -374,10 +834,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "05e2e118", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "36457" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "application_record_sdf = application_record_sdf.join(cpunt, using_columns='ID', join_type='inner')\n", "\n", @@ -386,16 +857,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "b84a77a5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|\"ID\" |\"CODE_GENDER\" |\"FLAG_OWN_CAR\" |\"FLAG_OWN_REALTY\" |\"CNT_CHILDREN\" |\"AMT_INCOME_TOTAL\" |\"NAME_INCOME_TYPE\" |\"NAME_EDUCATION_TYPE\" |\"NAME_FAMILY_STATUS\" |\"NAME_HOUSING_TYPE\" |\"DAYS_BIRTH\" |\"DAYS_EMPLOYED\" |\"FLAG_WORK_PHONE\" |\"FLAG_PHONE\" |\"FLAG_EMAIL\" |\"OCCUPATION_TYPE\" |\"CNT_FAM_MEMBERS\" |\"TARGET\" |\n", + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|5111190 |F |N |Y |2 |247500.0 |Commercial associate |Secondary / secondary special |Married |House / apartment |-13019 |-2307 |0 |0 |0 |OTHER |4.0 |0 |\n", + "|5140183 |F |N |Y |0 |67500.0 |State servant |Secondary / secondary special |Married |Municipal apartment |-15161 |-7190 |0 |0 |0 |Core staff |2.0 |0 |\n", + "|5033998 |F |N |N |0 |112500.0 |Commercial associate |Secondary / secondary special |Separated |Municipal apartment |-16417 |-1615 |0 |1 |0 |Laborers |1.0 |0 |\n", + "|5099974 |F |N |N |0 |180000.0 |Working |Secondary / secondary special |Civil marriage |House / apartment |-10218 |-1740 |0 |1 |0 |Security staff |2.0 |0 |\n", + "|5095056 |F |Y |Y |0 |157500.0 |Pensioner |Secondary / secondary special |Married |House / apartment |-22684 |365243 |0 |0 |0 |OTHER |2.0 |0 |\n", + "|5105697 |F |Y |N |0 |225000.0 |Working |Secondary / secondary special |Married |Municipal apartment |-12155 |-667 |0 |0 |0 |Laborers |2.0 |0 |\n", + "|5024230 |F |Y |Y |0 |540000.0 |Commercial associate |Higher education |Married |House / apartment |-15702 |-185 |0 |1 |0 |OTHER |2.0 |0 |\n", + "|5029014 |F |N |Y |0 |112500.0 |Working |Secondary / secondary special |Married |House / apartment |-13868 |-415 |0 |0 |0 |Laborers |2.0 |0 |\n", + "|5149342 |F |Y |Y |0 |292500.0 |Commercial associate |Higher education |Single / not married |House / apartment |-16930 |-8995 |0 |0 |0 |High skill tech staff |1.0 |0 |\n", + "|5061967 |F |N |Y |0 |225000.0 |Commercial associate |Secondary / secondary special |Married |House / apartment |-22897 |-1812 |0 |0 |0 |Managers |2.0 |0 |\n", + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "application_record_sdf.show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "39a059e3", "metadata": {}, @@ -425,7 +917,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "171e11d9", "metadata": {}, @@ -436,10 +927,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "bfceb0de", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------------\n", + "|\"CNT_CHILDREN\" |\"COUNT\" |\"HIGH_RISK\" |\n", + "------------------------------------------\n", + "|0 |25201 |431 |\n", + "|1 |7492 |120 |\n", + "|2 |3256 |52 |\n", + "|3 |419 |12 |\n", + "|4 |63 |1 |\n", + "|5 |20 |0 |\n", + "|7 |2 |0 |\n", + "|14 |3 |0 |\n", + "|19 |1 |0 |\n", + "------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# High Risk Ratio for CNT_CHILDREN\n", "var_analysis = application_record_sdf.group_by('CNT_CHILDREN')\n", @@ -449,7 +961,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5e9776df", "metadata": {}, @@ -459,10 +970,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "b5e05ace", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------\n", + "|\"ID\" |\"CNT_CHILDREN_IND\" |\n", + "--------------------------------\n", + "|5088857 |2More |\n", + "|5115581 |0 |\n", + "|5068783 |0 |\n", + "|5137375 |1 |\n", + "|5085814 |0 |\n", + "|5150182 |0 |\n", + "|5024092 |0 |\n", + "|5088820 |0 |\n", + "|5056032 |0 |\n", + "|5028780 |0 |\n", + "--------------------------------\n", + "\n" + ] + } + ], "source": [ "application_record_sdf = application_record_sdf.with_column('CNT_CHILDREN_IND', \n", " F.iff(F.col('CNT_CHILDREN') >= 2, \n", @@ -475,7 +1008,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b5aa79fb", "metadata": {}, @@ -486,10 +1018,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "261296ae", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------\n", + "|\"CNT_FAM_MEMBERS\" |\"COUNT\" |\"HIGH_RISK\" |\n", + "---------------------------------------------\n", + "|1.0 |6987 |139 |\n", + "|2.0 |19463 |313 |\n", + "|3.0 |6421 |105 |\n", + "|4.0 |3106 |46 |\n", + "|5.0 |397 |12 |\n", + "|6.0 |58 |1 |\n", + "|7.0 |19 |0 |\n", + "|9.0 |2 |0 |\n", + "|15.0 |3 |0 |\n", + "|20.0 |1 |0 |\n", + "---------------------------------------------\n", + "\n", + "-----------------------------------\n", + "|\"ID\" |\"CNT_FAM_MEMBERS_IND\" |\n", + "-----------------------------------\n", + "|5088857 |3More |\n", + "|5115581 |2 |\n", + "|5068783 |1 |\n", + "|5137375 |3More |\n", + "|5085814 |2 |\n", + "|5150182 |2 |\n", + "|5024092 |1 |\n", + "|5088820 |1 |\n", + "|5056032 |2 |\n", + "|5028780 |2 |\n", + "-----------------------------------\n", + "\n" + ] + } + ], "source": [ "var_analysis = application_record_sdf.group_by('CNT_FAM_MEMBERS')\n", "var_analysis = var_analysis.agg([F.count('CNT_FAM_MEMBERS').as_('COUNT'), \n", @@ -509,7 +1078,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "f8379a5e", "metadata": {}, @@ -524,10 +1092,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "7fa5667c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Calculate the age given the number of days\n", "application_record_sdf = application_record_sdf.with_column('AGE', F.abs(F.floor(F.col('DAYS_BIRTH') / 365)))\n", @@ -539,7 +1128,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "3225a9ff", "metadata": {}, @@ -549,10 +1137,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "d5a4ce19", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Calculate the workyears given the number of days of employment\n", "application_record_sdf = application_record_sdf.with_column('WORKYEAR', F.abs(F.floor(F.col('DAYS_EMPLOYED') / 365)))\n", @@ -565,7 +1164,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a673e237", "metadata": {}, @@ -576,10 +1174,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "e0ae6250", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------\n", + "|\"OCCUPATION_TYPE\" |\"COUNT\" |\n", + "-----------------------------------\n", + "|IT staff |60 |\n", + "|Realty agents |79 |\n", + "|HR staff |85 |\n", + "|Secretaries |151 |\n", + "|Waiters/barmen staff |174 |\n", + "|Low-skill Laborers |175 |\n", + "|Private service staff |344 |\n", + "|Cleaning staff |551 |\n", + "|Security staff |592 |\n", + "|Cooking staff |655 |\n", + "-----------------------------------\n", + "\n", + "---------------------\n", + "|\"OCCUPATION_TYPE\" |\n", + "---------------------\n", + "|OTHER |\n", + "|OTHER |\n", + "|LABOURWORK |\n", + "|OFFICEWORK |\n", + "|OFFICEWORK |\n", + "|OFFICEWORK |\n", + "|OFFICEWORK |\n", + "|LABOURWORK |\n", + "|LABOURWORK |\n", + "|LABOURWORK |\n", + "---------------------\n", + "\n" + ] + } + ], "source": [ "var_analysis = application_record_sdf.group_by('OCCUPATION_TYPE').agg(F.count('OCCUPATION_TYPE').as_('COUNT'))\n", "var_analysis = var_analysis.sort('COUNT').show()\n", @@ -617,7 +1252,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "8b7436dd", "metadata": {}, @@ -627,7 +1261,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "33e55255", "metadata": {}, "outputs": [], @@ -637,7 +1271,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "6385ad52", "metadata": {}, "outputs": [], @@ -651,10 +1285,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "a5034017", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/oazarmanesh/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/session.py:1383: UserWarning: Pandas Dataframe has non-standard index of type which will not be written. Consider changing the index to pd.RangeIndex(start=0,...,step=1) or call reset_index() to keep index as column(s)\n", + " success, nchunks, nrows, ci_output = write_pandas(\n", + "/Users/oazarmanesh/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/session.py:1383: UserWarning: Pandas Dataframe has non-standard index of type which will not be written. Consider changing the index to pd.RangeIndex(start=0,...,step=1) or call reset_index() to keep index as column(s)\n", + " success, nchunks, nrows, ci_output = write_pandas(\n" + ] + } + ], "source": [ "# Prepare values for One-Hot-Encoding\n", "ohe_cols = ['CODE_GENDER','NAME_INCOME_TYPE', 'NAME_EDUCATION_TYPE', 'NAME_FAMILY_STATUS', 'CNT_CHILDREN_IND', 'CNT_FAM_MEMBERS_IND', 'OCCUPATION_TYPE','NAME_HOUSING_TYPE']\n", @@ -672,7 +1317,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "5f8d0cf5", "metadata": {}, "outputs": [], @@ -686,16 +1331,442 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "73ddfb03", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|\"AMT_INCOME_TOTAL\" |\"AGE\" |\"WORKYEAR\" |\"CODE_GENDER_F\" |\"CODE_GENDER_M\" |\"NAME_INCOME_TYPE_COMMERCIAL_ASSOCIATE\" |\"NAME_INCOME_TYPE_PENSIONER\" |\"NAME_INCOME_TYPE_STATE_SERVANT\" |\"NAME_INCOME_TYPE_STUDENT\" |\"NAME_INCOME_TYPE_WORKING\" |\"NAME_EDUCATION_TYPE_ACADEMIC_DEGREE\" |\"NAME_EDUCATION_TYPE_HIGHER_EDUCATION\" |\"NAME_EDUCATION_TYPE_INCOMPLETE_HIGHER\" |\"NAME_EDUCATION_TYPE_LOWER_SECONDARY\" |\"NAME_EDUCATION_TYPE_SECONDARY_SECONDARY_SPECIAL\" |\"NAME_FAMILY_STATUS_CIVIL_MARRIAGE\" |\"NAME_FAMILY_STATUS_MARRIED\" |\"NAME_FAMILY_STATUS_SEPARATED\" |\"NAME_FAMILY_STATUS_SINGLE_NOT_MARRIED\" |\"NAME_FAMILY_STATUS_WIDOW\" |\"CNT_CHILDREN_IND_0\" |\"CNT_CHILDREN_IND_1\" |\"CNT_CHILDREN_IND_2MORE\" |\"CNT_FAM_MEMBERS_IND_1\" |\"CNT_FAM_MEMBERS_IND_2\" |\"CNT_FAM_MEMBERS_IND_3MORE\" |\"OCCUPATION_TYPE_HIGHTECHWORK\" |\"OCCUPATION_TYPE_LABOURWORK\" |\"OCCUPATION_TYPE_OFFICEWORK\" |\"OCCUPATION_TYPE_OTHER\" |\"NAME_HOUSING_TYPE_CO_OP_APARTMENT\" |\"NAME_HOUSING_TYPE_HOUSE_APARTMENT\" |\"NAME_HOUSING_TYPE_MUNICIPAL_APARTMENT\" |\"NAME_HOUSING_TYPE_OFFICE_APARTMENT\" |\"NAME_HOUSING_TYPE_RENTED_APARTMENT\" |\"NAME_HOUSING_TYPE_WITH_PARENTS\" |\"FLAG_OWN_CAR\" |\"FLAG_OWN_REALTY\" |\"ID\" |\"TARGET\" |\n", + "-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "|0.723608095562434 |1.2441583640019152 |0.19336128058914914 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |5008810 |0 |\n", + "|-0.7837771442667844 |1.660494591017464 |0.8118155727798374 |0.0 |1.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |1.0 |5008844 |0 |\n", + "|-0.7837771442667844 |1.660494591017464 |0.8118155727798374 |0.0 |1.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |1.0 |5008849 |0 |\n", + "|-0.6545726951385656 |-0.629354657568054 |-0.42509301160153906 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |5008873 |0 |\n", + "|0.723608095562434 |-0.629354657568054 |-0.5797065846492111 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |1.0 |5008837 |0 |\n", + "|-0.6545726951385656 |-0.629354657568054 |-0.42509301160153906 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |5008880 |0 |\n", + "|0.5082673470154029 |0.6196540234785921 |-0.5797065846492111 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |5008888 |0 |\n", + "|0.5082673470154029 |0.6196540234785921 |-0.5797065846492111 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |5008889 |0 |\n", + "|0.9820169938188714 |0.20331779646304343 |0.19336128058914914 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |5008909 |0 |\n", + "|0.9820169938188714 |0.20331779646304343 |0.19336128058914914 |1.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |1.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |0.0 |0.0 |0.0 |0.0 |1.0 |0.0 |0.0 |1.0 |5008915 |0 |\n", + "-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "application_record_sdf.show()" ] }, { - "attachments": {}, + "cell_type": "code", + "execution_count": 30, + "id": "9b89e7e1", + "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", + " \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", + " \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", + " \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", + "
AMT_INCOME_TOTALAGEWORKYEARCODE_GENDER_FCODE_GENDER_MNAME_INCOME_TYPE_COMMERCIAL_ASSOCIATENAME_INCOME_TYPE_PENSIONERNAME_INCOME_TYPE_STATE_SERVANTNAME_INCOME_TYPE_STUDENTNAME_INCOME_TYPE_WORKING...NAME_HOUSING_TYPE_CO_OP_APARTMENTNAME_HOUSING_TYPE_HOUSE_APARTMENTNAME_HOUSING_TYPE_MUNICIPAL_APARTMENTNAME_HOUSING_TYPE_OFFICE_APARTMENTNAME_HOUSING_TYPE_RENTED_APARTMENTNAME_HOUSING_TYPE_WITH_PARENTSFLAG_OWN_CARFLAG_OWN_REALTYIDTARGET
00.7236081.2441580.1933611.00.01.00.00.00.00.0...0.01.00.00.00.00.00.01.050088100
1-0.7837771.6604950.8118160.01.01.00.00.00.00.0...0.01.00.00.00.00.01.01.050088440
2-0.7837771.6604950.8118160.01.01.00.00.00.00.0...0.01.00.00.00.00.01.01.050088490
3-0.654573-0.629355-0.4250931.00.01.00.00.00.00.0...0.01.00.00.00.00.00.01.050088730
40.723608-0.629355-0.5797070.01.00.00.00.00.01.0...0.01.00.00.00.00.01.01.050088370
5-0.654573-0.629355-0.4250931.00.01.00.00.00.00.0...0.01.00.00.00.00.00.01.050088800
60.5082670.619654-0.5797071.00.01.00.00.00.00.0...0.00.00.00.01.00.00.01.050088880
70.5082670.619654-0.5797071.00.01.00.00.00.00.0...0.00.00.00.01.00.00.01.050088890
80.9820170.2033180.1933611.00.01.00.00.00.00.0...0.00.00.00.01.00.00.01.050089090
90.9820170.2033180.1933611.00.01.00.00.00.00.0...0.00.00.00.01.00.00.01.050089150
\n", + "

10 rows × 40 columns

\n", + "
" + ], + "text/plain": [ + " AMT_INCOME_TOTAL AGE WORKYEAR CODE_GENDER_F CODE_GENDER_M \\\n", + "0 0.723608 1.244158 0.193361 1.0 0.0 \n", + "1 -0.783777 1.660495 0.811816 0.0 1.0 \n", + "2 -0.783777 1.660495 0.811816 0.0 1.0 \n", + "3 -0.654573 -0.629355 -0.425093 1.0 0.0 \n", + "4 0.723608 -0.629355 -0.579707 0.0 1.0 \n", + "5 -0.654573 -0.629355 -0.425093 1.0 0.0 \n", + "6 0.508267 0.619654 -0.579707 1.0 0.0 \n", + "7 0.508267 0.619654 -0.579707 1.0 0.0 \n", + "8 0.982017 0.203318 0.193361 1.0 0.0 \n", + "9 0.982017 0.203318 0.193361 1.0 0.0 \n", + "\n", + " NAME_INCOME_TYPE_COMMERCIAL_ASSOCIATE NAME_INCOME_TYPE_PENSIONER \\\n", + "0 1.0 0.0 \n", + "1 1.0 0.0 \n", + "2 1.0 0.0 \n", + "3 1.0 0.0 \n", + "4 0.0 0.0 \n", + "5 1.0 0.0 \n", + "6 1.0 0.0 \n", + "7 1.0 0.0 \n", + "8 1.0 0.0 \n", + "9 1.0 0.0 \n", + "\n", + " NAME_INCOME_TYPE_STATE_SERVANT NAME_INCOME_TYPE_STUDENT \\\n", + "0 0.0 0.0 \n", + "1 0.0 0.0 \n", + "2 0.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + "5 0.0 0.0 \n", + "6 0.0 0.0 \n", + "7 0.0 0.0 \n", + "8 0.0 0.0 \n", + "9 0.0 0.0 \n", + "\n", + " NAME_INCOME_TYPE_WORKING ... NAME_HOUSING_TYPE_CO_OP_APARTMENT \\\n", + "0 0.0 ... 0.0 \n", + "1 0.0 ... 0.0 \n", + "2 0.0 ... 0.0 \n", + "3 0.0 ... 0.0 \n", + "4 1.0 ... 0.0 \n", + "5 0.0 ... 0.0 \n", + "6 0.0 ... 0.0 \n", + "7 0.0 ... 0.0 \n", + "8 0.0 ... 0.0 \n", + "9 0.0 ... 0.0 \n", + "\n", + " NAME_HOUSING_TYPE_HOUSE_APARTMENT NAME_HOUSING_TYPE_MUNICIPAL_APARTMENT \\\n", + "0 1.0 0.0 \n", + "1 1.0 0.0 \n", + "2 1.0 0.0 \n", + "3 1.0 0.0 \n", + "4 1.0 0.0 \n", + "5 1.0 0.0 \n", + "6 0.0 0.0 \n", + "7 0.0 0.0 \n", + "8 0.0 0.0 \n", + "9 0.0 0.0 \n", + "\n", + " NAME_HOUSING_TYPE_OFFICE_APARTMENT NAME_HOUSING_TYPE_RENTED_APARTMENT \\\n", + "0 0.0 0.0 \n", + "1 0.0 0.0 \n", + "2 0.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + "5 0.0 0.0 \n", + "6 0.0 1.0 \n", + "7 0.0 1.0 \n", + "8 0.0 1.0 \n", + "9 0.0 1.0 \n", + "\n", + " NAME_HOUSING_TYPE_WITH_PARENTS FLAG_OWN_CAR FLAG_OWN_REALTY ID \\\n", + "0 0.0 0.0 1.0 5008810 \n", + "1 0.0 1.0 1.0 5008844 \n", + "2 0.0 1.0 1.0 5008849 \n", + "3 0.0 0.0 1.0 5008873 \n", + "4 0.0 1.0 1.0 5008837 \n", + "5 0.0 0.0 1.0 5008880 \n", + "6 0.0 0.0 1.0 5008888 \n", + "7 0.0 0.0 1.0 5008889 \n", + "8 0.0 0.0 1.0 5008909 \n", + "9 0.0 0.0 1.0 5008915 \n", + "\n", + " TARGET \n", + "0 0 \n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "5 0 \n", + "6 0 \n", + "7 0 \n", + "8 0 \n", + "9 0 \n", + "\n", + "[10 rows x 40 columns]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "application_record_sdf.limit(10).to_pandas()" + ] + }, + { "cell_type": "markdown", "id": "37522d7a", "metadata": {}, @@ -705,7 +1776,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "6d490980", "metadata": {}, "outputs": [], @@ -714,7 +1785,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "eb7ad64f", "metadata": {}, @@ -724,7 +1794,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "70485380", "metadata": {}, @@ -734,17 +1803,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "id": "09156afe", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|1 |503 |\n", + "|0 |29819 |\n", + "----------------------\n", + "\n" + ] + } + ], "source": [ "# We have highly imbalanced data\n", "application_record_sdf.group_by('TARGET').count().show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "45620b74", "metadata": {}, @@ -756,10 +1838,134 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "21de1b91", "metadata": {}, - "outputs": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
created_onnamedatabase_nameschema_nameurlhas_credentialshas_encryption_keyownercommentregiontypecloudnotification_channelstorage_integrationowner_role_type
02023-08-16 10:35:54.364000-07:00ML_PROCSHOL_DBPUBLICNNACCOUNTADMINNoneINTERNALNoneNoneNoneROLE
12023-08-16 10:35:37.919000-07:00nnycqaafpyHOL_DBPUBLICNNACCOUNTADMINNoneINTERNAL TEMPORARYNoneNoneNoneROLE
22023-08-16 10:35:31.311000-07:00ogozsusnsxHOL_DBPUBLICNNACCOUNTADMINNoneINTERNAL TEMPORARYNoneNoneNoneROLE
\n", + "
" + ], + "text/plain": [ + " created_on name database_name schema_name url \\\n", + "0 2023-08-16 10:35:54.364000-07:00 ML_PROCS HOL_DB PUBLIC \n", + "1 2023-08-16 10:35:37.919000-07:00 nnycqaafpy HOL_DB PUBLIC \n", + "2 2023-08-16 10:35:31.311000-07:00 ogozsusnsx HOL_DB PUBLIC \n", + "\n", + " has_credentials has_encryption_key owner comment region \\\n", + "0 N N ACCOUNTADMIN None \n", + "1 N N ACCOUNTADMIN None \n", + "2 N N ACCOUNTADMIN None \n", + "\n", + " type cloud notification_channel storage_integration \\\n", + "0 INTERNAL None None None \n", + "1 INTERNAL TEMPORARY None None None \n", + "2 INTERNAL TEMPORARY None None None \n", + "\n", + " owner_role_type \n", + "0 ROLE \n", + "1 ROLE \n", + "2 ROLE " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "session.sql('CREATE OR REPLACE STAGE ML_PROCS').collect()\n", "pd.DataFrame(session.sql('SHOW STAGES').collect())" @@ -767,7 +1973,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "9b84d879", "metadata": {}, "outputs": [], @@ -802,7 +2008,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b69672f5", "metadata": {}, @@ -812,7 +2017,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "8e9c5743", "metadata": {}, "outputs": [], @@ -829,10 +2034,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "6a764741", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\"Successfully oversampled\"'" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "training_table = 'CREDIT_RISK_PREPARED'\n", "# get feature columns\n", @@ -852,10 +2068,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "dee18f0c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|0 |29819 |\n", + "|1 |29819 |\n", + "----------------------\n", + "\n" + ] + } + ], "source": [ "# Now our training data is balanced\n", "train_data_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED')\n", @@ -864,13 +2094,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "02c1803e", "metadata": {}, "outputs": [], "source": [ "session.close()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19ba2471", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -889,7 +2127,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.8.17" } }, "nbformat": 4, diff --git a/hol/2_1_DEMO_model_building_scoring.ipynb b/hol/2_1_DEMO_model_building_scoring.ipynb index e2cd7d6..019600b 100644 --- a/hol/2_1_DEMO_model_building_scoring.ipynb +++ b/hol/2_1_DEMO_model_building_scoring.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "2e339e77", "metadata": {}, @@ -10,7 +9,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "73ac09a3", "metadata": {}, @@ -19,7 +17,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a7d72538", "metadata": {}, @@ -29,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "2cb04fd9", "metadata": {}, "outputs": [], @@ -47,7 +44,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "22a0aaa1", "metadata": {}, @@ -57,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "e3b512a8", "metadata": {}, "outputs": [], @@ -67,7 +63,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "11413743", "metadata": {}, @@ -77,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "381310d7", "metadata": {}, "outputs": [], @@ -88,10 +83,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "9cc080c0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Database and schema: \"HOL_DB\".\"PUBLIC\"\n", + "Current Warehouse: \"HOL_WH\"\n" + ] + } + ], "source": [ "session = Session.builder.configs(connection_parameters).create()\n", "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", @@ -99,7 +103,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "2a42a5d2", "metadata": {}, @@ -109,26 +112,134 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "d264e18c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[Row(status='Stage area ML_MODELS successfully created.')]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "session.sql('CREATE OR REPLACE STAGE ML_MODELS').collect()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "7c293f32", "metadata": {}, - "outputs": [], + "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", + "
created_onnamedatabase_nameschema_nameurlhas_credentialshas_encryption_keyownercommentregiontypecloudnotification_channelstorage_integrationowner_role_type
02023-08-16 10:36:55.179000-07:00ML_MODELSHOL_DBPUBLICNNACCOUNTADMINNoneINTERNALNoneNoneNoneROLE
12023-08-16 10:35:54.364000-07:00ML_PROCSHOL_DBPUBLICNNACCOUNTADMINNoneINTERNALNoneNoneNoneROLE
\n", + "
" + ], + "text/plain": [ + " created_on name database_name schema_name url \\\n", + "0 2023-08-16 10:36:55.179000-07:00 ML_MODELS HOL_DB PUBLIC \n", + "1 2023-08-16 10:35:54.364000-07:00 ML_PROCS HOL_DB PUBLIC \n", + "\n", + " has_credentials has_encryption_key owner comment region type \\\n", + "0 N N ACCOUNTADMIN None INTERNAL \n", + "1 N N ACCOUNTADMIN None INTERNAL \n", + "\n", + " cloud notification_channel storage_integration owner_role_type \n", + "0 None None None ROLE \n", + "1 None None None ROLE " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "pd.DataFrame(session.sql('SHOW STAGES').collect())" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "24d093ad", "metadata": {}, @@ -140,17 +251,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "570a3776", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|0 |29819 |\n", + "|1 |29819 |\n", + "----------------------\n", + "\n" + ] + } + ], "source": [ "application_record_balanced_sdf = session.table('CREDIT_RISK_PREPARED_BALANCED')\n", "application_record_balanced_sdf.group_by('TARGET').count().show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "dd19116e", "metadata": {}, @@ -160,10 +284,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "d91ebf56", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|1 |23960 |\n", + "|0 |23819 |\n", + "----------------------\n", + "\n" + ] + } + ], "source": [ "train_sdf = application_record_balanced_sdf.sample_by(\"TARGET\", {1: 0.8, 0: 0.8})\n", "train_sdf = train_sdf.cache_result()\n", @@ -171,7 +309,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "ca734c35", "metadata": {}, @@ -181,17 +318,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "0297ff43", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------\n", + "|\"TARGET\" |\"COUNT\" |\n", + "----------------------\n", + "|0 |6000 |\n", + "|1 |4886 |\n", + "----------------------\n", + "\n" + ] + } + ], "source": [ "test_sdf = application_record_balanced_sdf.minus(train_sdf)\n", "test_sdf.group_by('TARGET').count().show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "c3fe042a", "metadata": {}, @@ -201,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "f455553a", "metadata": {}, "outputs": [], @@ -214,7 +364,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a4083f48", "metadata": {}, @@ -224,10 +373,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "6983af6f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "feature_cols = train_sdf.columns\n", "feature_cols.remove('TARGET')\n", @@ -239,7 +399,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b9e4c195", "metadata": {}, @@ -249,17 +408,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "5e951c2f", "metadata": {}, - "outputs": [], - "source": [ - "feature_coefficients = pd.DataFrame(lm.get_sklearn_object().coef_.T,lm.get_sklearn_object().feature_names_in_,columns=['Coefficient'])\n", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feature_coefficients = pd.DataFrame(lm.to_sklearn().coef_.T,lm.to_sklearn().feature_names_in_,columns=['Coefficient'])\n", "feature_coefficients.sort_values('Coefficient').plot.barh(y='Coefficient', figsize=(5,15))" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "8097c837", "metadata": {}, @@ -269,17 +448,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "b1fbbbaf", "metadata": {}, - "outputs": [], - "source": [ - "skl_ml = lm.get_sklearn_object()\n", + "outputs": [ + { + "data": { + "text/plain": [ + "sklearn.linear_model._logistic.LogisticRegression" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "skl_ml = lm.to_sklearn()\n", "type(skl_ml)" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "19a60347", "metadata": {}, @@ -288,7 +477,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "95c5ff7a", "metadata": {}, @@ -297,7 +485,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "acbb5608", "metadata": {}, @@ -307,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "c28783e5", "metadata": {}, "outputs": [], @@ -318,7 +505,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "98cac9aa", "metadata": {}, @@ -327,7 +513,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "e90db3e5", "metadata": {}, @@ -337,7 +522,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "5381ced6", "metadata": {}, "outputs": [], @@ -347,17 +532,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "5990a3f3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------\n", + "|\"TARGET\" |\"CAST('0.0' AS FLOAT)\" |\"CAST('1.0' AS FLOAT)\" |\n", + "--------------------------------------------------------------\n", + "|1 |2132 |2754 |\n", + "|0 |3708 |2292 |\n", + "--------------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "# Obtaining a simple confusion matrix\n", "scored_sdf.crosstab('TARGET','PREDICTION').show()" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "34e1289f", "metadata": {}, @@ -367,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "a21ddd7f", "metadata": {}, "outputs": [], @@ -389,23 +587,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "16087bac", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------\n", + "|\"ACCURACY\" |\"PRECISION\" |\"RECALL\" |\"F1\" |\n", + "--------------------------------------------------------\n", + "|0.593606 |0.545779 |0.563651 |0.554571048428 |\n", + "--------------------------------------------------------\n", + "\n" + ] + } + ], "source": [ "calc_metrics(scored_sdf)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "f246388b", "metadata": {}, "outputs": [], "source": [ "session.close()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7973a12", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -424,7 +643,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.8.17" } }, "nbformat": 4, diff --git a/hol/3_1_SOLUTION_additional_models_xgboost.ipynb b/hol/3_1_SOLUTION_additional_models_xgboost.ipynb index 5b8b924..9f039ee 100644 --- a/hol/3_1_SOLUTION_additional_models_xgboost.ipynb +++ b/hol/3_1_SOLUTION_additional_models_xgboost.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "2e339e77", "metadata": {}, @@ -10,7 +9,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "73ac09a3", "metadata": {}, @@ -19,7 +17,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a7d72538", "metadata": {}, @@ -29,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "2cb04fd9", "metadata": {}, "outputs": [], @@ -44,7 +41,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "1f47f8e9", "metadata": {}, @@ -54,10 +50,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "f82010d6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'snowflake-snowpark-python': '1.5.1',\n", + " 'pandas': '1.5.3',\n", + " 'scikit-learn': '1.2.2',\n", + " 'lightgbm': '3.3.5',\n", + " 'xgboost': '1.7.3',\n", + " 'joblib': '1.2.0',\n", + " 'imbalanced-learn': '0.10.1'}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "with open('packages_version.json') as f:\n", " packages_version = json.load(f)\n", @@ -66,7 +79,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "11413743", "metadata": {}, @@ -76,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "25a54f72", "metadata": {}, "outputs": [], @@ -87,10 +99,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "9cc080c0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Database and schema: \"HOL_DB\".\"PUBLIC\"\n", + "Current Warehouse: \"HOL_WH\"\n" + ] + } + ], "source": [ "session = Session.builder.configs(connection_parameters).create()\n", "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", @@ -98,7 +119,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "24d093ad", "metadata": {}, @@ -108,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "4df6c514", "metadata": {}, "outputs": [], @@ -118,7 +138,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "74d762b8", "metadata": {}, @@ -128,10 +147,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "0053ffc1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "SnowparkSQLException", + "evalue": "(1304): 01ae54b3-0001-b953-002c-cb070008c562: 002003 (42S02): SQL compilation error:\nObject 'CREDIT_RISK_PREPARED_BALANCED_TRAIN' does not exist or not authorized.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mSnowparkSQLException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m feature_cols \u001b[38;5;241m=\u001b[39m \u001b[43mtrain_sdf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\n\u001b[1;32m 2\u001b[0m feature_cols\u001b[38;5;241m.\u001b[39mremove(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mTARGET\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 3\u001b[0m feature_cols\u001b[38;5;241m.\u001b[39mremove(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mID\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/dataframe.py:931\u001b[0m, in \u001b[0;36mDataFrame.columns\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 915\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[1;32m 916\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcolumns\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m List[\u001b[38;5;28mstr\u001b[39m]:\n\u001b[1;32m 917\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Returns all column names as a list.\u001b[39;00m\n\u001b[1;32m 918\u001b[0m \n\u001b[1;32m 919\u001b[0m \u001b[38;5;124;03m The returned column names are consistent with the Snowflake database object `identifier syntax `_.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 929\u001b[0m \u001b[38;5;124;03m ================================== ==========================\u001b[39;00m\n\u001b[1;32m 930\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 931\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mschema\u001b[49m\u001b[38;5;241m.\u001b[39mnames\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/functools.py:967\u001b[0m, in \u001b[0;36mcached_property.__get__\u001b[0;34m(self, instance, owner)\u001b[0m\n\u001b[1;32m 965\u001b[0m val \u001b[38;5;241m=\u001b[39m cache\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mattrname, _NOT_FOUND)\n\u001b[1;32m 966\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m val \u001b[38;5;129;01mis\u001b[39;00m _NOT_FOUND:\n\u001b[0;32m--> 967\u001b[0m val \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43minstance\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 968\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 969\u001b[0m cache[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mattrname] \u001b[38;5;241m=\u001b[39m val\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/dataframe.py:3638\u001b[0m, in \u001b[0;36mDataFrame.schema\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 3633\u001b[0m \u001b[38;5;129m@cached_property\u001b[39m\n\u001b[1;32m 3634\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mschema\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m StructType:\n\u001b[1;32m 3635\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"The definition of the columns in this DataFrame (the \"relational schema\" for\u001b[39;00m\n\u001b[1;32m 3636\u001b[0m \u001b[38;5;124;03m the DataFrame).\u001b[39;00m\n\u001b[1;32m 3637\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 3638\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m StructType\u001b[38;5;241m.\u001b[39m_from_attributes(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_plan\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattributes\u001b[49m)\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/functools.py:967\u001b[0m, in \u001b[0;36mcached_property.__get__\u001b[0;34m(self, instance, owner)\u001b[0m\n\u001b[1;32m 965\u001b[0m val \u001b[38;5;241m=\u001b[39m cache\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mattrname, _NOT_FOUND)\n\u001b[1;32m 966\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m val \u001b[38;5;129;01mis\u001b[39;00m _NOT_FOUND:\n\u001b[0;32m--> 967\u001b[0m val \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43minstance\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 968\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 969\u001b[0m cache[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mattrname] \u001b[38;5;241m=\u001b[39m val\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/_internal/analyzer/snowflake_plan.py:249\u001b[0m, in \u001b[0;36mSnowflakePlan.attributes\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 247\u001b[0m \u001b[38;5;129m@cached_property\u001b[39m\n\u001b[1;32m 248\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mattributes\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m List[Attribute]:\n\u001b[0;32m--> 249\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43manalyze_attributes\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mschema_query\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msession\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 250\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mschema_query \u001b[38;5;241m=\u001b[39m schema_value_statement(output)\n\u001b[1;32m 251\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/_internal/analyzer/schema_utils.py:82\u001b[0m, in \u001b[0;36manalyze_attributes\u001b[0;34m(sql, session)\u001b[0m\n\u001b[1;32m 79\u001b[0m session\u001b[38;5;241m.\u001b[39m_run_query(sql)\n\u001b[1;32m 80\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m convert_result_meta_to_attribute(session\u001b[38;5;241m.\u001b[39m_conn\u001b[38;5;241m.\u001b[39m_cursor\u001b[38;5;241m.\u001b[39mdescription)\n\u001b[0;32m---> 82\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msession\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_result_attributes\u001b[49m\u001b[43m(\u001b[49m\u001b[43msql\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/session.py:1247\u001b[0m, in \u001b[0;36mSession._get_result_attributes\u001b[0;34m(self, query)\u001b[0m\n\u001b[1;32m 1246\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_get_result_attributes\u001b[39m(\u001b[38;5;28mself\u001b[39m, query: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m List[Attribute]:\n\u001b[0;32m-> 1247\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_conn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_result_attributes\u001b[49m\u001b[43m(\u001b[49m\u001b[43mquery\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/_internal/analyzer/snowflake_plan.py:180\u001b[0m, in \u001b[0;36mSnowflakePlan.Decorator.wrap_exception..wrap\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 177\u001b[0m ne \u001b[38;5;241m=\u001b[39m SnowparkClientExceptionMessages\u001b[38;5;241m.\u001b[39mSQL_EXCEPTION_FROM_PROGRAMMING_ERROR(\n\u001b[1;32m 178\u001b[0m e\n\u001b[1;32m 179\u001b[0m )\n\u001b[0;32m--> 180\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ne\u001b[38;5;241m.\u001b[39mwith_traceback(tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/_internal/analyzer/snowflake_plan.py:110\u001b[0m, in \u001b[0;36mSnowflakePlan.Decorator.wrap_exception..wrap\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrap\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m snowflake\u001b[38;5;241m.\u001b[39mconnector\u001b[38;5;241m.\u001b[39merrors\u001b[38;5;241m.\u001b[39mProgrammingError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 112\u001b[0m query \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/snowpark/_internal/server_connection.py:206\u001b[0m, in \u001b[0;36mServerConnection.get_result_attributes\u001b[0;34m(self, query)\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;129m@SnowflakePlan\u001b[39m\u001b[38;5;241m.\u001b[39mDecorator\u001b[38;5;241m.\u001b[39mwrap_exception\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_result_attributes\u001b[39m(\u001b[38;5;28mself\u001b[39m, query: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m List[Attribute]:\n\u001b[0;32m--> 206\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m convert_result_meta_to_attribute(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cursor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdescribe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mquery\u001b[49m\u001b[43m)\u001b[49m)\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/connector/cursor.py:926\u001b[0m, in \u001b[0;36mSnowflakeCursor.describe\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 917\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Obtain the schema of the result without executing the query.\u001b[39;00m\n\u001b[1;32m 918\u001b[0m \n\u001b[1;32m 919\u001b[0m \u001b[38;5;124;03mThis function takes the same arguments as execute, please refer to that function\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 923\u001b[0m \u001b[38;5;124;03m The schema of the result.\u001b[39;00m\n\u001b[1;32m 924\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 925\u001b[0m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_describe_only\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_is_internal\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m--> 926\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 927\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_description\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/connector/cursor.py:904\u001b[0m, in \u001b[0;36mSnowflakeCursor.execute\u001b[0;34m(self, command, params, _bind_stage, timeout, _exec_async, _no_retry, _do_reset, _put_callback, _put_azure_callback, _put_callback_output_stream, _get_callback, _get_azure_callback, _get_callback_output_stream, _show_progress_bar, _statement_params, _is_internal, _describe_only, _no_results, _is_put_get, _raise_put_get_error, _force_put_overwrite, _skip_upload_on_content_match, file_stream, num_statements)\u001b[0m\n\u001b[1;32m 900\u001b[0m is_integrity_error \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 901\u001b[0m code \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m100072\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 902\u001b[0m ) \u001b[38;5;66;03m# NULL result in a non-nullable column\u001b[39;00m\n\u001b[1;32m 903\u001b[0m error_class \u001b[38;5;241m=\u001b[39m IntegrityError \u001b[38;5;28;01mif\u001b[39;00m is_integrity_error \u001b[38;5;28;01melse\u001b[39;00m ProgrammingError\n\u001b[0;32m--> 904\u001b[0m \u001b[43mError\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43merrorhandler_wrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconnection\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merror_class\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merrvalue\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 905\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/connector/errors.py:290\u001b[0m, in \u001b[0;36mError.errorhandler_wrapper\u001b[0;34m(connection, cursor, error_class, error_value)\u001b[0m\n\u001b[1;32m 267\u001b[0m \u001b[38;5;129m@staticmethod\u001b[39m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21merrorhandler_wrapper\u001b[39m(\n\u001b[1;32m 269\u001b[0m connection: SnowflakeConnection \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 272\u001b[0m error_value: \u001b[38;5;28mdict\u001b[39m[\u001b[38;5;28mstr\u001b[39m, Any],\n\u001b[1;32m 273\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 274\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Error handler wrapper that calls the errorhandler method.\u001b[39;00m\n\u001b[1;32m 275\u001b[0m \n\u001b[1;32m 276\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 287\u001b[0m \u001b[38;5;124;03m exception to the first handler in that order.\u001b[39;00m\n\u001b[1;32m 288\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 290\u001b[0m handed_over \u001b[38;5;241m=\u001b[39m \u001b[43mError\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhand_to_other_handler\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 291\u001b[0m \u001b[43m \u001b[49m\u001b[43mconnection\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 292\u001b[0m \u001b[43m \u001b[49m\u001b[43mcursor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[43merror_class\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 294\u001b[0m \u001b[43m \u001b[49m\u001b[43merror_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 296\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m handed_over:\n\u001b[1;32m 297\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m Error\u001b[38;5;241m.\u001b[39merrorhandler_make_exception(\n\u001b[1;32m 298\u001b[0m error_class,\n\u001b[1;32m 299\u001b[0m error_value,\n\u001b[1;32m 300\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/connector/errors.py:345\u001b[0m, in \u001b[0;36mError.hand_to_other_handler\u001b[0;34m(connection, cursor, error_class, error_value)\u001b[0m\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cursor \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 344\u001b[0m cursor\u001b[38;5;241m.\u001b[39mmessages\u001b[38;5;241m.\u001b[39mappend((error_class, error_value))\n\u001b[0;32m--> 345\u001b[0m \u001b[43mcursor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43merrorhandler\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconnection\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcursor\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merror_class\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merror_value\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 347\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m connection \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/anaconda3/envs/pysnowpark/lib/python3.8/site-packages/snowflake/connector/errors.py:221\u001b[0m, in \u001b[0;36mError.default_errorhandler\u001b[0;34m(connection, cursor, error_class, error_value)\u001b[0m\n\u001b[1;32m 219\u001b[0m errno \u001b[38;5;241m=\u001b[39m error_value\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124merrno\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 220\u001b[0m done_format_msg \u001b[38;5;241m=\u001b[39m error_value\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdone_format_msg\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 221\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m error_class(\n\u001b[1;32m 222\u001b[0m msg\u001b[38;5;241m=\u001b[39merror_value\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmsg\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 223\u001b[0m errno\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m errno \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mint\u001b[39m(errno),\n\u001b[1;32m 224\u001b[0m sqlstate\u001b[38;5;241m=\u001b[39merror_value\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msqlstate\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 225\u001b[0m sfqid\u001b[38;5;241m=\u001b[39merror_value\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msfqid\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 226\u001b[0m query\u001b[38;5;241m=\u001b[39merror_value\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mquery\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 227\u001b[0m done_format_msg\u001b[38;5;241m=\u001b[39m(\n\u001b[1;32m 228\u001b[0m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m done_format_msg \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mbool\u001b[39m(done_format_msg)\n\u001b[1;32m 229\u001b[0m ),\n\u001b[1;32m 230\u001b[0m connection\u001b[38;5;241m=\u001b[39mconnection,\n\u001b[1;32m 231\u001b[0m cursor\u001b[38;5;241m=\u001b[39mcursor,\n\u001b[1;32m 232\u001b[0m )\n", + "\u001b[0;31mSnowparkSQLException\u001b[0m: (1304): 01ae54b3-0001-b953-002c-cb070008c562: 002003 (42S02): SQL compilation error:\nObject 'CREDIT_RISK_PREPARED_BALANCED_TRAIN' does not exist or not authorized." + ] + } + ], "source": [ "feature_cols = train_sdf.columns\n", "feature_cols.remove('TARGET')\n", @@ -150,12 +196,11 @@ "outputs": [], "source": [ "# Plot feature importance\n", - "feat_importance = pd.DataFrame(xgbmodel.get_sklearn_object().feature_importances_,feature_cols,columns=['FeatImportance'])\n", + "feat_importance = pd.DataFrame(xgbmodel.to_xgboost().feature_importances_,feature_cols,columns=['FeatImportance'])\n", "feat_importance.sort_values('FeatImportance').plot.barh(y='FeatImportance', figsize=(5,15))" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "19a60347", "metadata": {}, @@ -164,7 +209,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "95c5ff7a", "metadata": {}, @@ -173,7 +217,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5046b342", "metadata": {}, @@ -194,6 +237,30 @@ "session.table('CREDIT_RISK_PREPARED_BALANCED_TEST_SCORED').show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "61102c2c", + "metadata": {}, + "outputs": [], + "source": [ + "import snowflake.snowpark.functions as F\n", + "\n", + "def calc_metrics(snf_df):\n", + " return snf_df.group_by(['TARGET','PREDICTION']).count()\\\n", + " .with_column(\"type\", F.when((F.col(\"TARGET\") == 0) & (F.col(\"PREDICTION\") == 0), \"tn\")\\\n", + " .when((F.col(\"TARGET\") == 0) & (F.col(\"PREDICTION\") == 1), \"fp\")\\\n", + " .when((F.col(\"TARGET\") == 1) & (F.col(\"PREDICTION\") == 0), \"fn\")\\\n", + " .when((F.col(\"TARGET\") == 1) & (F.col(\"PREDICTION\") == 1), \"tp\"))\\\n", + " .select([\"TYPE\", \"COUNT\"]).pivot(\"TYPE\", ['tn', 'tp', 'fn', 'fp']).sum(\"COUNT\")\\\n", + " .with_columns([\"accuracy\", \"precision\", \"recall\"],\n", + " [((F.col(\"'tp'\") + F.col(\"'tn'\")) / (F.col(\"'tp'\") + F.col(\"'tn'\") + F.col(\"'fn'\") + F.col(\"'fp'\")))\n", + " , (F.col(\"'tp'\") / (F.col(\"'tp'\") + F.col(\"'fp'\")))\n", + " ,(F.col(\"'tp'\") / (F.col(\"'tp'\") + F.col(\"'fn'\")))])\\\n", + " .with_column(\"f1\", (F.lit(2)*F.col(\"precision\")*F.col(\"recall\")) / (F.col(\"precision\")+F.col(\"recall\")))\\\n", + " .select([\"ACCURACY\",\"PRECISION\", \"RECALL\",\"F1\"]).show()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -221,7 +288,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.8.17" } }, "nbformat": 4, diff --git a/hol/3_2_SOLUTION_additional_models_lightgbm.ipynb b/hol/3_2_SOLUTION_additional_models_lightgbm.ipynb index 8b27192..4cbd527 100644 --- a/hol/3_2_SOLUTION_additional_models_lightgbm.ipynb +++ b/hol/3_2_SOLUTION_additional_models_lightgbm.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "2e339e77", "metadata": {}, @@ -10,7 +9,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "73ac09a3", "metadata": {}, @@ -19,7 +17,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a7d72538", "metadata": {}, @@ -37,6 +34,7 @@ "from snowflake.snowpark.session import Session\n", "import snowflake.snowpark.types as T\n", "\n", + "import joblib\n", "from snowflake.ml.modeling.lightgbm import LGBMClassifier\n", "\n", "import json\n", @@ -44,7 +42,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "c4442706", "metadata": {}, @@ -64,7 +61,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "11413743", "metadata": {}, @@ -96,7 +92,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "24d093ad", "metadata": {}, @@ -116,7 +111,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b36c435c", "metadata": {}, @@ -124,36 +118,152 @@ "# SOLUTION: Train a LightGBM Model on a Snowpark DataFrame using snowpark-ml" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "91221b05", + "metadata": {}, + "outputs": [], + "source": [ + "# This local Python-function will be registered as a Stored Procedure and runs in Snowflake\n", + "sk_version = \"1.2.2\"\n", + "snowpark_version = \"1.3.0\"\n", + "pandas_version = \"1.5.3\"\n", + "lightgbm_version = \"3.3.5\"\n" + ] + }, { "cell_type": "code", "execution_count": null, "id": "584b35e7", "metadata": {}, "outputs": [], + "source": [ + "def sproc_train_lightgbm_model(session: Session, \n", + " training_table: str, \n", + " feature_cols: list,\n", + " target_col: str,\n", + " model_name: str) -> T.Variant:\n", + " \n", + " # WORKFLOW\n", + " # 1: Load data into Pandas DataFrame\n", + " # 2: Define features and Label\n", + " # 3: Train the model\n", + " # 4: (Optional) Return feature importance\n", + " # 5: Save the model and upload to Snowflake Stage\n", + " # 6: Return feature importance or success-message\n", + " # Hint: Make sure return is json-compatible (e.g. via calling to_dict())\n", + "\n", + " # 1: Load data into Pandas DataFrame\n", + " local_training_data = training_table.to_pandas()\n", + "\n", + " # 2: Define features and Label\n", + " X = local_training_data[feature_cols]\n", + " y = local_training_data[target_col]\n", + " \n", + " # 3: Train the model\n", + " lgbmodel = LGBMClassifier(input_cols=feature_cols, label_cols=target_col, output_cols='PREDICTION')\n", + " lgbmodel.fit(training_table)\n", + " \n", + " # 4: (Optional) Return feature importance\n", + " feat_importance = pd.DataFrame(lgbmodel.to_lightgbm().feature_importances_,feature_cols,columns=['FeatImportance'])\n", + "\n", + " # 5: Save the model and upload to Snowflake Stage\n", + " joblib.dump(lgbmodel, \"/tmp/\" + model_name)\n", + " session.file.put(\"/tmp/\" + model_name, \"@MODEL_STAGE\", auto_compress=False, overwrite=True)\n", + " \n", + " # 6: Return feature importance or success-message\n", + " feat_importance.sort_values('FeatImportance').plot.barh(y='FeatImportance', figsize=(5,15))\n", + "\n", + "\n", + " return feat_importance" + ] + }, + { + "cell_type": "markdown", + "id": "e38d9398", + "metadata": {}, + "source": [ + "# SOLUTION: Register your Stored Procedure to train an LightGBM Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27de1ca9", + "metadata": {}, + "outputs": [], + "source": [ + "session.sql(\"CREATE STAGE IF NOT EXISTS model_stage\").collect()\n", + "pd.DataFrame(session.sql(\"LIST @MODEL_STAGE\").collect())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d578865", + "metadata": {}, + "outputs": [], + "source": [ + "session.add_packages(\"snowflake-snowpark-python==1.5.1\",\n", + " \"pandas==1.5.3\", \"scikit-learn==1.2.2\", \"lightgbm==3.3.5\",\n", + " \"xgboost==1.7.3\", \"joblib==1.2.0\", \"imbalanced-learn==0.10.1\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03b45ce7", + "metadata": {}, + "outputs": [], + "source": [ + "# Registering the function as a Stored Procedure\n", + "sproc_train_lightgbm_model = session.sproc.register(func=sproc_train_lightgbm_model, \n", + " name='sproc_train_lgbm_model', \n", + " is_permanent=True, \n", + " replace=True, \n", + " stage_location='MODEL_STAGE')" + ] + }, + { + "cell_type": "markdown", + "id": "979b1b1c", + "metadata": {}, + "source": [ + "# SOLUTION: Run your Stored Procedure to train an LightGBM Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "01b72e16", + "metadata": {}, + "outputs": [], "source": [ "feature_cols = train_sdf.columns\n", "feature_cols.remove('TARGET')\n", "feature_cols.remove('ID')\n", - "target_col = 'TARGET'\n", "\n", - "lgbmodel = LGBMClassifier(input_cols=feature_cols, label_cols=target_col, output_cols='PREDICTION')\n", - "lgbmodel.fit(train_sdf)" + "result = sproc_train_lightgbm_model(training_table=train_sdf, \n", + " feature_cols=feature_cols, \n", + " target_col='TARGET',\n", + " model_name=\"train_lgbm_model\", \n", + " session=session)\n", + "result" ] }, { "cell_type": "code", "execution_count": null, - "id": "bedab745", + "id": "c1239449", "metadata": {}, "outputs": [], "source": [ - "# Plot feature importance\n", - "feat_importance = pd.DataFrame(lgbmodel.get_sklearn_object().feature_importances_,feature_cols,columns=['FeatImportance'])\n", - "feat_importance.sort_values('FeatImportance').plot.barh(y='FeatImportance', figsize=(5,15))" + "# The model is now stored in a Snowflake stage\n", + "pd.DataFrame(session.sql('LIST @MODEL_STAGE').collect()) " ] }, { - "attachments": {}, "cell_type": "markdown", "id": "19a60347", "metadata": {}, @@ -162,7 +272,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "95c5ff7a", "metadata": {}, @@ -171,12 +280,27 @@ ] }, { - "attachments": {}, + "cell_type": "markdown", + "id": "64569d68", + "metadata": {}, + "source": [ + "# SOLUTION: Define your UDF to Score an LightGBM Model" + ] + }, + { "cell_type": "markdown", "id": "3f2baa9c", "metadata": {}, "source": [ - "# SOLUTION: Use the fitted LightGBM Model to score a Snowpark DataFrame" + "# SOLUTION: Register your UDF to Score an LightGBM Model" + ] + }, + { + "cell_type": "markdown", + "id": "b9ecebe0", + "metadata": {}, + "source": [ + "# SOLUTION: Run your UDF to Score an LightGBM Model" ] }, { @@ -218,7 +342,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.8.17" } }, "nbformat": 4, diff --git a/hol/4_1_DEMO_hyperparameter_tuning_gridsearch.ipynb b/hol/4_1_DEMO_hyperparameter_tuning_gridsearch.ipynb index ad7c5fe..6cae8a0 100644 --- a/hol/4_1_DEMO_hyperparameter_tuning_gridsearch.ipynb +++ b/hol/4_1_DEMO_hyperparameter_tuning_gridsearch.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "2e339e77", "metadata": {}, @@ -10,7 +9,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "73ac09a3", "metadata": {}, @@ -19,7 +17,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a7d72538", "metadata": {}, @@ -29,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "2cb04fd9", "metadata": {}, "outputs": [], @@ -48,7 +45,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "91955f46", "metadata": {}, @@ -58,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "e640693e", "metadata": {}, "outputs": [], @@ -68,7 +64,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "11413743", "metadata": {}, @@ -78,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "04bad29b", "metadata": {}, "outputs": [], @@ -89,10 +84,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "9cc080c0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Database and schema: \"HOL_DB\".\"PUBLIC\"\n", + "Current Warehouse: \"HOL_WH\"\n" + ] + } + ], "source": [ "session = Session.builder.configs(connection_parameters).create()\n", "print(f\"Current Database and schema: {session.get_fully_qualified_current_schema()}\")\n", @@ -100,7 +104,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "24d093ad", "metadata": {}, @@ -110,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "4df6c514", "metadata": {}, "outputs": [], @@ -121,10 +124,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "442a5131", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "feature_cols = train_sdf.columns\n", "feature_cols.remove('TARGET')\n", @@ -148,7 +162,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "55c233ba", "metadata": {}, @@ -158,13 +171,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "46794ab5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Analyze grid search results\n", - "gs_results = grid_search.get_sklearn_object().cv_results_\n", + "gs_results = grid_search.to_sklearn().cv_results_\n", "n_estimators_val = []\n", "max_depth_val = []\n", "for param_dict in gs_results[\"params\"]:\n", @@ -178,6 +202,14 @@ "sns.relplot(data=gs_results_df, x=\"max_depth\", y=\"f1_val\", hue=\"n_estimators\", kind='line')\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db5c6afd", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -196,7 +228,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.8.17" } }, "nbformat": 4,