{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Example: Automated feature scaling\n", "------------------------------------\n", "\n", "This example shows how ATOM handles models that require automated feature scaling.\n", "\n", "Import the breast cancer dataset from [sklearn.datasets](https://scikit-learn.org/stable/datasets/index.html#wine-dataset). This is a small and easy to train dataset whose goal is to predict whether a patient has breast cancer or not." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load the data" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Import packages\n", "from sklearn.datasets import load_breast_cancer\n", "from atom import ATOMClassifier" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Load the data\n", "X, y = load_breast_cancer(return_X_y=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Run the pipeline" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "<< ================== ATOM ================== >>\n", "\n", "Configuration ==================== >>\n", "Algorithm task: Binary classification.\n", "\n", "Dataset stats ==================== >>\n", "Shape: (569, 31)\n", "Train set size: 456\n", "Test set size: 113\n", "-------------------------------------\n", "Memory: 141.24 kB\n", "Scaled: False\n", "Outlier values: 167 (1.2%)\n", "\n" ] } ], "source": [ "atom = ATOMClassifier(X, y, verbose=2, random_state=1)" ] }, { "cell_type": "code", "execution_count": 4, "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", "
acronymfullnameestimatormodulehandles_missingneeds_scalingaccepts_sparsenative_multilabelnative_multioutputvalidationsupports_engines
0CatBCatBoostCatBoostClassifiercatboost.coreTrueTrueTrueFalseFalsen_estimatorscatboost
1KNNKNearestNeighborsKNeighborsClassifiersklearn.neighbors._classificationFalseTrueTrueTrueTrueNonesklearn, sklearnex, cuml
2LGBLightGBMLGBMClassifierlightgbm.sklearnTrueTrueTrueFalseFalsen_estimatorslightgbm
3lSVMLinearSVMLinearSVCsklearn.svm._classesFalseTrueTrueFalseFalseNonesklearn, cuml
4LRLogisticRegressionLogisticRegressionsklearn.linear_model._logisticFalseTrueTrueFalseFalseNonesklearn, sklearnex, cuml
5MLPMultiLayerPerceptronMLPClassifiersklearn.neural_network._multilayer_perceptronFalseTrueTrueTrueFalsemax_itersklearn
6PAPassiveAggressivePassiveAggressiveClassifiersklearn.linear_model._passive_aggressiveFalseTrueTrueFalseFalsemax_itersklearn
7PercPerceptronPerceptronsklearn.linear_model._perceptronFalseTrueFalseFalseFalsemax_itersklearn
8RNNRadiusNearestNeighborsRadiusNeighborsClassifiersklearn.neighbors._classificationFalseTrueTrueTrueTrueNonesklearn
9RidgeRidgeRidgeClassifiersklearn.linear_model._ridgeFalseTrueTrueTrueFalseNonesklearn, sklearnex, cuml
10SGDStochasticGradientDescentSGDClassifiersklearn.linear_model._stochastic_gradientFalseTrueTrueFalseFalsemax_itersklearn
11SVMSupportVectorMachineSVCsklearn.svm._classesFalseTrueTrueFalseFalseNonesklearn, sklearnex, cuml
12XGBXGBoostXGBClassifierxgboost.sklearnTrueTrueTrueFalseFalsen_estimatorsxgboost
\n", "
" ], "text/plain": [ " acronym fullname estimator \\\n", "0 CatB CatBoost CatBoostClassifier \n", "1 KNN KNearestNeighbors KNeighborsClassifier \n", "2 LGB LightGBM LGBMClassifier \n", "3 lSVM LinearSVM LinearSVC \n", "4 LR LogisticRegression LogisticRegression \n", "5 MLP MultiLayerPerceptron MLPClassifier \n", "6 PA PassiveAggressive PassiveAggressiveClassifier \n", "7 Perc Perceptron Perceptron \n", "8 RNN RadiusNearestNeighbors RadiusNeighborsClassifier \n", "9 Ridge Ridge RidgeClassifier \n", "10 SGD StochasticGradientDescent SGDClassifier \n", "11 SVM SupportVectorMachine SVC \n", "12 XGB XGBoost XGBClassifier \n", "\n", " module handles_missing \\\n", "0 catboost.core True \n", "1 sklearn.neighbors._classification False \n", "2 lightgbm.sklearn True \n", "3 sklearn.svm._classes False \n", "4 sklearn.linear_model._logistic False \n", "5 sklearn.neural_network._multilayer_perceptron False \n", "6 sklearn.linear_model._passive_aggressive False \n", "7 sklearn.linear_model._perceptron False \n", "8 sklearn.neighbors._classification False \n", "9 sklearn.linear_model._ridge False \n", "10 sklearn.linear_model._stochastic_gradient False \n", "11 sklearn.svm._classes False \n", "12 xgboost.sklearn True \n", "\n", " needs_scaling accepts_sparse native_multilabel native_multioutput \\\n", "0 True True False False \n", "1 True True True True \n", "2 True True False False \n", "3 True True False False \n", "4 True True False False \n", "5 True True True False \n", "6 True True False False \n", "7 True False False False \n", "8 True True True True \n", "9 True True True False \n", "10 True True False False \n", "11 True True False False \n", "12 True True False False \n", "\n", " validation supports_engines \n", "0 n_estimators catboost \n", "1 None sklearn, sklearnex, cuml \n", "2 n_estimators lightgbm \n", "3 None sklearn, cuml \n", "4 None sklearn, sklearnex, cuml \n", "5 max_iter sklearn \n", "6 max_iter sklearn \n", "7 max_iter sklearn \n", "8 None sklearn \n", "9 None sklearn, sklearnex, cuml \n", "10 max_iter sklearn \n", "11 None sklearn, sklearnex, cuml \n", "12 n_estimators xgboost " ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check which models require feature scaling\n", "atom.available_models(needs_scaling=True)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Training ========================= >>\n", "Models: LR, Bag\n", "Metric: f1\n", "\n", "\n", "Results for LogisticRegression:\n", "Fit ---------------------------------------------\n", "Train evaluation --> f1: 0.9913\n", "Test evaluation --> f1: 0.9861\n", "Time elapsed: 0.253s\n", "-------------------------------------------------\n", "Time: 0.253s\n", "\n", "\n", "Results for Bagging:\n", "Fit ---------------------------------------------\n", "Train evaluation --> f1: 0.9982\n", "Test evaluation --> f1: 0.9444\n", "Time elapsed: 0.085s\n", "-------------------------------------------------\n", "Time: 0.085s\n", "\n", "\n", "Final results ==================== >>\n", "Total time: 0.344s\n", "-------------------------------------\n", "LogisticRegression --> f1: 0.9861 !\n", "Bagging --> f1: 0.9444\n" ] } ], "source": [ "# We fit two models: LR needs scaling and Bag doesn't\n", "atom.run([\"LR\", \"Bag\"])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Successfully created new branch: scaling.\n" ] } ], "source": [ "# Now, we create a new branch and scale the features before fitting the model\n", "atom.branch = \"scaling\"" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fitting Scaler...\n", "Scaling features...\n" ] } ], "source": [ "atom.scale()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Training ========================= >>\n", "Models: LR_2\n", "Metric: f1\n", "\n", "\n", "Results for LogisticRegression:\n", "Fit ---------------------------------------------\n", "Train evaluation --> f1: 0.9913\n", "Test evaluation --> f1: 0.9861\n", "Time elapsed: 0.038s\n", "-------------------------------------------------\n", "Time: 0.038s\n", "\n", "\n", "Final results ==================== >>\n", "Total time: 0.042s\n", "-------------------------------------\n", "LogisticRegression --> f1: 0.9861\n" ] } ], "source": [ "atom.run(\"LR_2\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Analyze the results" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Scaler()\n", "None\n", "None\n" ] } ], "source": [ "# Let's compare the differences between the models\n", "print(atom.lr.scaler)\n", "print(atom.bag.scaler)\n", "print(atom.lr_2.scaler)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " x0 x1 x2\n", "0 -0.181875 0.356669 -0.147122\n", "1 1.162216 0.300578 1.159704\n", "2 1.056470 1.212060 0.933833\n", "3 0.277287 2.457753 0.188054\n", "4 -1.442482 -0.825921 -1.343434\n", "-----------------------------\n", " x0 x1 x2\n", "0 13.48 20.82 88.40\n", "1 18.31 20.58 120.80\n", "2 17.93 24.48 115.20\n", "3 15.13 29.81 96.71\n", "4 8.95 15.76 58.74\n", "-----------------------------\n", "True\n" ] } ], "source": [ "# And the data they use is different\n", "print(atom.lr.X.iloc[:5, :3])\n", "print(\"-----------------------------\")\n", "print(atom.bag.X.iloc[:5, :3])\n", "print(\"-----------------------------\")\n", "print(atom.lr_2.X_train.equals(atom.lr.X_train))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pipeline(memory=Memory(location=None),\n", " ('steps', [('AutomatedScaler', Scaler())]),\n", " verbose=False)\n", "-----------------------------\n", "Pipeline(memory=Memory(location=None), steps=[], verbose=False)\n", "-----------------------------\n", "Pipeline(memory=Memory(location=None),\n", " ('steps', [('scaler', Scaler(verbose=2))]),\n", " verbose=False)\n" ] } ], "source": [ "# Note that the scaler is included in the model's pipeline\n", "print(atom.lr.pipeline)\n", "print(\"-----------------------------\")\n", "print(atom.bag.pipeline)\n", "print(\"-----------------------------\")\n", "print(atom.lr_2.pipeline)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "atom.plot_pipeline()" ] } ], "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.11.2" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }