diff --git a/InsurAutoML/VERSION b/InsurAutoML/VERSION index 7179039..abd4105 100644 --- a/InsurAutoML/VERSION +++ b/InsurAutoML/VERSION @@ -1 +1 @@ -0.2.3 +0.2.4 diff --git a/InsurAutoML/hpo/base.py b/InsurAutoML/hpo/base.py index fac7d6c..06a7d63 100644 --- a/InsurAutoML/hpo/base.py +++ b/InsurAutoML/hpo/base.py @@ -5,13 +5,13 @@ Mathematics Department, University of Illinois at Urbana-Champaign (UIUC) Project: InsurAutoML -Latest Version: 0.2.3 +Latest Version: 0.2.4 Relative Path: /InsurAutoML/hpo/base.py File: _base.py Author: Panyi Dong (panyid2@illinois.edu) ----- -Last Modified: Monday, 28th November 2022 11:36:14 pm +Last Modified: Friday, 3rd February 2023 12:32:28 am Modified By: Panyi Dong (panyid2@illinois.edu) ----- @@ -121,7 +121,7 @@ device_count = 0 -class AutoTabularBase(MetaData): +class AutoTabularBase: """ " Base class module for AutoTabular (for classification and regression tasks) @@ -330,7 +330,11 @@ def get_hyperparameter_space( # Encoding: convert string types to numerical type # all encoders available from InsurAutoML.encoding import encoders - from additional import add_encoders + # if additional exists, import, otherwise set to default + try : + from additional import add_encoders + except: + add_encoders = {} # include original encoders self._all_encoders = copy.deepcopy(encoders) @@ -361,7 +365,11 @@ def get_hyperparameter_space( # Imputer: fill missing values # all imputers available from InsurAutoML.imputation import imputers - from additional import add_imputers + # if additional exists, import, otherwise set to default + try : + from additional import add_imputers + except : + add_imputers = {} # include original imputers self._all_imputers = copy.deepcopy(imputers) @@ -401,7 +409,11 @@ def get_hyperparameter_space( # Balancing: deal with imbalanced dataset, using over-/under-sampling methods # all balancings available from InsurAutoML.balancing import balancings - from additional import add_balancings + # if additional exists, import, otherwise set to default + try : + from additional import add_balancings + except : + add_balancings = {} # include original balancings self._all_balancings = copy.deepcopy(balancings) @@ -426,7 +438,11 @@ def get_hyperparameter_space( # Scaling # all scalings available from InsurAutoML.scaling import scalings - from additional import add_scalings + # if additional exists, import, otherwise set to default + try : + from additional import add_scalings + except : + add_scalings = {} # include original scalings self._all_scalings = copy.deepcopy(scalings) @@ -451,7 +467,11 @@ def get_hyperparameter_space( # Feature selection: Remove redundant features, reduce dimensionality # all feature selections available from InsurAutoML.feature_selection import feature_selections - from additional import add_feature_selections + # if additional exists, import, otherwise set to default + try : + from additional import add_feature_selections + except : + add_feature_selections = {} # include original feature selections self._all_feature_selection = copy.deepcopy(feature_selections) @@ -502,7 +522,11 @@ def get_hyperparameter_space( # if mode is regression, use regression models if self.task_mode == "classification": from InsurAutoML.model import classifiers - from additional import add_classifiers + # if additional exists, import, otherwise set to default + try : + from additional import add_classifiers + except : + add_classifiers = {} # include original classifiers self._all_models = copy.deepcopy(classifiers) @@ -510,7 +534,11 @@ def get_hyperparameter_space( self._all_models.update(add_classifiers) elif self.task_mode == "regression": from InsurAutoML.model import regressors - from additional import add_regressors + # if additional exists, import, otherwise set to default + try : + from additional import add_regressors + except : + add_regressors = {} # include original regressors self._all_models = copy.deepcopy(regressors) @@ -560,15 +588,25 @@ def get_hyperparameter_space( regressor_hyperparameter, ) - from additional import ( - add_encoder_hyperparameter, - add_imputer_hyperparameter, - add_scaling_hyperparameter, - add_balancing_hyperparameter, - add_feature_selection_hyperparameter, - add_classifier_hyperparameter, - add_regressor_hyperparameter, - ) + # if additional exists, import, otherwise set to default + try : + from additional import ( + add_encoder_hyperparameter, + add_imputer_hyperparameter, + add_scaling_hyperparameter, + add_balancing_hyperparameter, + add_feature_selection_hyperparameter, + add_classifier_hyperparameter, + add_regressor_hyperparameter, + ) + except : + add_encoder_hyperparameter = {} + add_imputer_hyperparameter = {} + add_scaling_hyperparameter = {} + add_balancing_hyperparameter = {} + add_feature_selection_hyperparameter = {} + add_classifier_hyperparameter = {} + add_regressor_hyperparameter = {} # if needed, modify default hyperparameter space # like model hyperparameter space below @@ -1188,7 +1226,8 @@ def fit( type(y))) # get data metadata - super(AutoTabularBase, self).__init__(X) + if not hasattr(self, "metadata") : + self.metadata = MetaData(X).metadata # check if there's unsupported data type # if datetime ,recommend to remove if ("Datetime", "") in self.metadata.keys(): diff --git a/doc/Automated Machine Learning (AutoML) in Insurance.pdf b/doc/Automated Machine Learning (AutoML) in Insurance.pdf index c37ee88..d214540 100644 Binary files a/doc/Automated Machine Learning (AutoML) in Insurance.pdf and b/doc/Automated Machine Learning (AutoML) in Insurance.pdf differ diff --git a/example/Heart Failure Prediction.ipynb b/example/Heart Failure Prediction.ipynb index da4ad9a..b3fca6f 100644 --- a/example/Heart Failure Prediction.ipynb +++ b/example/Heart Failure Prediction.ipynb @@ -2,13 +2,13 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import InsurAutoML\n", "from InsurAutoML import load_data, AutoTabular\n", - "from InsurAutoML._utils import train_test_split" + "from InsurAutoML.utils import train_test_split" ] }, { @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -32,152 +32,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "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", - "
AgeSexChestPainTypeRestingBPCholesterolFastingBSRestingECGMaxHRExerciseAnginaOldpeakST_SlopeHeartDisease
040MATA1402890Normal172N0.0Up0
149FNAP1601800Normal156N1.0Flat1
237MATA1302830ST98N0.0Up0
348FASY1382140Normal108Y1.5Flat1
454MNAP1501950Normal122N0.0Up0
\n", - "
" - ], - "text/plain": [ - " Age Sex ChestPainType RestingBP Cholesterol FastingBS RestingECG MaxHR \\\n", - "0 40 M ATA 140 289 0 Normal 172 \n", - "1 49 F NAP 160 180 0 Normal 156 \n", - "2 37 M ATA 130 283 0 ST 98 \n", - "3 48 F ASY 138 214 0 Normal 108 \n", - "4 54 M NAP 150 195 0 Normal 122 \n", - "\n", - " ExerciseAngina Oldpeak ST_Slope HeartDisease \n", - "0 N 0.0 Up 0 \n", - "1 N 1.0 Flat 1 \n", - "2 N 0.0 Up 0 \n", - "3 Y 1.5 Flat 1 \n", - "4 N 0.0 Up 0 " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "database['heart'].head(5)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -201,20 +65,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# fit AutoML model\n", "mol = AutoTabular(seed = 1)\n", @@ -223,20 +76,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.8686131386861314" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from sklearn.metrics import accuracy_score\n", "y_pred = mol.predict(test_X)\n", @@ -245,11 +87,8 @@ } ], "metadata": { - "interpreter": { - "hash": "ffd44db24f7f67a4f281ba15796957bca8144b3dee6ef1a3a74893a61c2c4db7" - }, "kernelspec": { - "display_name": "Python 3.8.8 64-bit ('base': conda)", + "display_name": "Python 3.8.10 64-bit", "language": "python", "name": "python3" }, @@ -263,9 +102,14 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.10" }, - "orig_nbformat": 4 + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/example/Insurance Premium Prediction.ipynb b/example/Insurance Premium Prediction.ipynb index 542de11..db7afb4 100644 --- a/example/Insurance Premium Prediction.ipynb +++ b/example/Insurance Premium Prediction.ipynb @@ -2,13 +2,13 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import InsurAutoML\n", "from InsurAutoML import load_data, AutoTabular\n", - "from InsurAutoML._utils import train_test_split" + "from InsurAutoML.utils import train_test_split" ] }, { @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -32,115 +32,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "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", - "
agesexbmichildrensmokerregionexpenses
019female27.90yessouthwest16884.92
118male33.81nosoutheast1725.55
228male33.03nosoutheast4449.46
333male22.70nonorthwest21984.47
432male28.90nonorthwest3866.86
\n", - "
" - ], - "text/plain": [ - " age sex bmi children smoker region expenses\n", - "0 19 female 27.9 0 yes southwest 16884.92\n", - "1 18 male 33.8 1 no southeast 1725.55\n", - "2 28 male 33.0 3 no southeast 4449.46\n", - "3 33 male 22.7 0 no northwest 21984.47\n", - "4 32 male 28.9 0 no northwest 3866.86" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "database['insurance'].head(5)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -164,20 +65,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# fit AutoML model\n", "mol = AutoTabular(seed = 1)\n", @@ -186,20 +76,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "21309279.613129355" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# predict using AutoML model\n", "from sklearn.metrics import mean_squared_error\n", @@ -209,22 +88,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "plt.figure()\n", @@ -236,20 +102,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.8551737495890323" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from sklearn.metrics import r2_score\n", "r2_score(y_pred, test_y)" @@ -257,11 +112,8 @@ } ], "metadata": { - "interpreter": { - "hash": "ffd44db24f7f67a4f281ba15796957bca8144b3dee6ef1a3a74893a61c2c4db7" - }, "kernelspec": { - "display_name": "Python 3.8.8 64-bit ('base': conda)", + "display_name": "Python 3.9.12 ('AutoML')", "language": "python", "name": "python3" }, @@ -275,9 +127,14 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.16" }, - "orig_nbformat": 4 + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "6365bc95598d2ccdc3eaf3eec35e934e6114e45fdcf8688d41365438acebce2c" + } + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/requirements.txt b/requirements.txt index c1aece0..a179487 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,28 +1,27 @@ -tensorboardX -pandas -pyarrow -scipy -bayesian_optimization==1.4.0 -threadpoolctl>2.2.0 -flaml -rpy2 -tqdm cython -ray[tune] -pygam +optuna +threadpoolctl>2.2.0 +seaborn>=0.11.0 +pyarrow +tensorboardX +matplotlib hyperopt +ray[tune] +flaml +nevergrad +setuptools==59.5.0 +colorama==0.4.4 +scikit-learn>=1.1.0 +pandas lightgbm ray<2.0.0 -seaborn>=0.11.0 xgboost -optuna -matplotlib +fastparquet mlflow -colorama==0.4.4 +scipy +bayesian_optimization==1.4.0 +gensim +pygam redis -nevergrad -scikit-learn>=1.1.0 -fastparquet -setuptools==59.5.0 numpy<1.24.0 -gensim +tqdm diff --git a/requirements_nn.txt b/requirements_nn.txt index 4a7b191..cae8a5f 100644 --- a/requirements_nn.txt +++ b/requirements_nn.txt @@ -1,22 +1,21 @@ -tensorboardX -pandas -pyarrow +cython nni -scipy threadpoolctl>2.2.0 -rpy2 -tqdm -cython -ray[tune] -hyperopt -ray<2.0.0 seaborn>=0.11.0 +pyarrow +tensorboardX matplotlib -redis -pytorch_lightning -scikit-learn>=1.1.0 -fastparquet +hyperopt +ray[tune] setuptools==59.5.0 -numpy<1.24.0 +scikit-learn>=1.1.0 +pandas torch +pytorch_lightning +ray<2.0.0 +fastparquet +scipy gensim +redis +numpy<1.24.0 +tqdm diff --git a/setup.py b/setup.py index 4cb40d9..0779e62 100644 --- a/setup.py +++ b/setup.py @@ -5,13 +5,13 @@ Mathematics Department, University of Illinois at Urbana-Champaign (UIUC) Project: InsurAutoML -Latest Version: 0.2.3 +Latest Version: <> Relative Path: /setup.py File Created: Wednesday, 16th November 2022 7:39:46 pm Author: Panyi Dong (panyid2@illinois.edu) ----- -Last Modified: Thursday, 2nd February 2023 10:00:46 pm +Last Modified: Friday, 3rd February 2023 12:09:23 am Modified By: Panyi Dong (panyid2@illinois.edu) ----- @@ -259,10 +259,10 @@ def get_r_home() -> Optional[str]: # otherwise, do not install rpy2 R_HOME = get_r_home() if not R_HOME: - raise RuntimeError("""The R home directory could not be determined.""") + log.info("""The R home directory could not be determined.""") # only install for Linux -if not os.environ.get("R_HOME") and sys.platform == "linux": +if R_HOME and not os.environ.get("R_HOME") and sys.platform == "linux": os.environ["R_HOME"] = R_HOME EXTRA_DICT["extended"].append("rpy2") EXTRA_DICT["nn"].append("rpy2")