| { |
| "nbformat": 4, |
| "nbformat_minor": 2, |
| "metadata": { |
| "colab": { |
| "name": "Untitled8.ipynb", |
| "provenance": [], |
| "collapsed_sections": [] |
| }, |
| "kernelspec": { |
| "name": "python3", |
| "display_name": "Python 3", |
| "language": "python" |
| }, |
| "metadata": { |
| "interpreter": { |
| "hash": "434fba307fd1171c9cfc17821a2afcf8929f30379beeaab9e3fdf8c6db2d1c93" |
| } |
| } |
| }, |
| "cells": [ |
| { |
| "cell_type": "code", |
| "execution_count": 1, |
| "source": [ |
| "import joblib\r\n", |
| "import numpy as np\r\n", |
| "import pandas as pd\r\n", |
| "\r\n", |
| "from sklearn.preprocessing import LabelEncoder\r\n", |
| "from sklearn.preprocessing import StandardScaler\r\n", |
| "from sklearn.model_selection import train_test_split\r\n", |
| "\r\n", |
| "test_size = 0.20\r\n", |
| "\r\n", |
| "processed_data = None\r\n", |
| "categorical = None\r\n", |
| "label_encoders = {}\r\n", |
| "\r\n", |
| "def preprocessing(dataset, data, test_size):\r\n", |
| " \"\"\"\r\n", |
| " Preprocess dataset\r\n", |
| "\r\n", |
| " Parameters\r\n", |
| " ----------\r\n", |
| " data: DataFrame\r\n", |
| " Pandas dataframe containing German dataset.\r\n", |
| " \"\"\"\r\n", |
| " \r\n", |
| " global processed_data\r\n", |
| " global categorical\r\n", |
| " global label_encoders\r\n", |
| "\r\n", |
| " # Reset global variables\r\n", |
| " \r\n", |
| " processed_data = None\r\n", |
| " categorical = None\r\n", |
| " label_encoders = {}\r\n", |
| "\r\n", |
| "\r\n", |
| " if dataset == \"German\":\r\n", |
| " # Drop savings account and checkings account columns as they contain a lot\r\n", |
| " # of NaN values and may not always be available in real life scenarios\r\n", |
| " data = data.drop(columns = ['Saving accounts', 'Checking account'])\r\n", |
| " \r\n", |
| " dat_dict = data.to_dict()\r\n", |
| " new_dat_dict = {}\r\n", |
| "\r\n", |
| " # rename columns(Make them lowercase and snakecase)\r\n", |
| " for key, value in dat_dict.items():\r\n", |
| " newKey = key\r\n", |
| " if type(key) == str:\r\n", |
| " newKey = newKey.lower().replace(' ', '_')\r\n", |
| " # if newKey != key:\r\n", |
| " new_dat_dict[newKey] = dat_dict[key]\r\n", |
| " del dat_dict\r\n", |
| "\r\n", |
| " data = pd.DataFrame.from_dict(new_dat_dict)\r\n", |
| " del new_dat_dict\r\n", |
| "\r\n", |
| "\r\n", |
| " # print(data.describe())\r\n", |
| " # print(data.describe(include='O'))\r\n", |
| "\r\n", |
| " cols = data.columns\r\n", |
| " num_cols = data._get_numeric_data().columns\r\n", |
| " categorical = list(set(cols) - set(num_cols))\r\n", |
| "\r\n", |
| " # Drop null rows\r\n", |
| " data = data.dropna()\r\n", |
| "\r\n", |
| " # Encode text columns to number values\r\n", |
| " for category in categorical:\r\n", |
| " le = LabelEncoder()\r\n", |
| " data[category] = le.fit_transform(data[category])\r\n", |
| " label_encoders[category] = le\r\n", |
| "\r\n", |
| " for col in data.columns:\r\n", |
| " if(col not in categorical):\r\n", |
| " data[col] = (data[col].astype('float') - np.mean(data[col].astype('float')))/np.std(data[col].astype('float'))\r\n", |
| "\r\n", |
| " # print(data.describe())\r\n", |
| " # print(data.describe(include='O'))\r\n", |
| "\r\n", |
| " processed_data = data\r\n", |
| "\r\n", |
| " # Get Training parameters\r\n", |
| " if dataset == \"German\":\r\n", |
| " target_col = data.columns[-1]\r\n", |
| " x = data.drop(columns=target_col, axis=1)\r\n", |
| " y = data[target_col].astype('int')\r\n", |
| " elif dataset == \"Australian\":\r\n", |
| " x = data.drop(14, axis=1)\r\n", |
| " y = data[14].astype('int')\r\n", |
| " elif dataset == \"Japanese\":\r\n", |
| " x = data.drop(15, axis=1)\r\n", |
| " y = data[15].astype('int')\r\n", |
| " elif dataset == \"Taiwan\":\r\n", |
| " x = data.drop('default_payment_next_month', axis=1)\r\n", |
| " y = data['default_payment_next_month'].astype('int')\r\n", |
| " elif dataset == \"Polish\":\r\n", |
| " x = data.drop('class', axis=1)\r\n", |
| " y = data['class'].astype('int')\r\n", |
| "\r\n", |
| "\r\n", |
| " x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = test_size)\r\n", |
| " x_train = pd.DataFrame(x_train)\r\n", |
| " y_train = pd.DataFrame(y_train)\r\n", |
| "\r\n", |
| " sc = StandardScaler()\r\n", |
| " x_train = sc.fit_transform(x_train)\r\n", |
| " x_test = sc.transform(x_test)\r\n", |
| "\r\n", |
| " return (x_train, x_test, y_train, y_test)\r\n" |
| ], |
| "outputs": [], |
| "metadata": { |
| "id": "Z5EFqHxB-zEn" |
| } |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": 2, |
| "source": [ |
| "from sklearn.svm import SVC\r\n", |
| "from sklearn.neural_network import MLPClassifier\r\n", |
| "from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier\r\n", |
| "from sklearn.model_selection import GridSearchCV, ShuffleSplit\r\n", |
| "from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, recall_score, precision_score\r\n", |
| "\r\n", |
| "class Model(object):\r\n", |
| " \"\"\"\r\n", |
| " Basic Scorecard Model\r\n", |
| "\r\n", |
| " Warning: This class should not be used directly. Use derived classes\r\n", |
| " instead.\r\n", |
| " \"\"\"\r\n", |
| "\r\n", |
| " def __init__(self,\r\n", |
| " classifier=None,\r\n", |
| " test_size=test_size,\r\n", |
| " n_splits=1,\r\n", |
| " random_state=None,\r\n", |
| " n_jobs=None,\r\n", |
| " params=None):\r\n", |
| " \r\n", |
| " self.classifier = classifier\r\n", |
| " self.params = params\r\n", |
| " self.random_state = random_state\r\n", |
| " self.test_size = test_size\r\n", |
| " self.n_splits = n_splits\r\n", |
| " self.n_jobs = n_jobs\r\n", |
| "\r\n", |
| " self.model = GridSearchCV(estimator=classifier,\r\n", |
| " param_grid=params,\r\n", |
| " n_jobs=n_jobs,\r\n", |
| " cv=ShuffleSplit(test_size=test_size,\r\n", |
| " n_splits=n_splits,\r\n", |
| " random_state=0))\r\n", |
| " \r\n", |
| " def __str__(self):\r\n", |
| " return f\"\"\"\r\n", |
| " Model Object\r\n", |
| " ----------------------------------------------------------------\r\n", |
| "\r\n", |
| " Classifier: {self.classifier.__class__.__name__}\r\n", |
| " Test Size: {self.test_size}\r\n", |
| " Random State: {self.random_state}\r\n", |
| " Number of Splits: {self.n_splits}\r\n", |
| " Parameter Grid: {self.params}\r\n", |
| "\r\n", |
| " {self.model}\r\n", |
| " \"\"\"\r\n", |
| " \r\n", |
| " def __repr__(self):\r\n", |
| " return self.__str__()\r\n", |
| "\r\n", |
| " def train(self, x_train, y_train):\r\n", |
| " \"\"\"\r\n", |
| " Train scorecard model\r\n", |
| " \r\n", |
| " Args:\r\n", |
| " x_train:\r\n", |
| " array of training parameters\r\n", |
| " y_train:\r\n", |
| " pandas dataframe with training labels\r\n", |
| " \"\"\"\r\n", |
| "\r\n", |
| " self.model = self.model.fit(x_train, y_train.values.ravel())\r\n", |
| " return self\r\n", |
| "\r\n", |
| " def predict(self, data):\r\n", |
| " \"\"\"\r\n", |
| " Predict scorecard model\r\n", |
| "\r\n", |
| " Args:\r\n", |
| " data: array\r\n", |
| " Data to perform prediction on.\r\n", |
| " \"\"\"\r\n", |
| "\r\n", |
| " return self.model.predict(data)\r\n", |
| "\r\n", |
| " def accuracy(self, x_test, y_test):\r\n", |
| " \"\"\"\r\n", |
| " Compute scorecard model accuracy\r\n", |
| "\r\n", |
| " Args:\r\n", |
| " x_test: array\r\n", |
| " The test parameters.\r\n", |
| " y_test: array\r\n", |
| " The labels\r\n", |
| " \"\"\"\r\n", |
| "\r\n", |
| " y_pred = self.predict(x_test)\r\n", |
| " return accuracy_score(y_test, y_pred, normalize=False)\r\n", |
| "\r\n", |
| " def metrics(self, x_test, y_test):\r\n", |
| " \"\"\"\r\n", |
| " Comput scorecard model metrics\r\n", |
| " \r\n", |
| " Args:\r\n", |
| " x_test: array\r\n", |
| " The test parameters.\r\n", |
| " y_test: array\r\n", |
| " The labels\r\n", |
| " \"\"\"\r\n", |
| "\r\n", |
| " y_pred = self.predict(x_test)\r\n", |
| " \r\n", |
| " cm = confusion_matrix(y_pred, y_test)\r\n", |
| " accuracy = accuracy_score(y_test, y_pred, normalize=True)\r\n", |
| " f1 = f1_score(y_test, y_pred, average=\"macro\")\r\n", |
| " recall = recall_score(y_test, y_pred, average=\"macro\")\r\n", |
| " precision = precision_score(y_test, y_pred, average=\"macro\")\r\n", |
| "\r\n", |
| " return {\"accuracy\" : accuracy,\r\n", |
| " \"f1_score\" : f1,\r\n", |
| " \"recall_score\" : recall,\r\n", |
| " \"precision_score\": precision}\r\n", |
| "\r\n", |
| "class RandomForest(Model):\r\n", |
| " def __init__(self,\r\n", |
| " classifier=RandomForestClassifier(),\r\n", |
| " test_size=test_size,\r\n", |
| " n_splits=1,\r\n", |
| " random_state=0,\r\n", |
| " n_jobs=None,\r\n", |
| " params={'n_estimators' : [20, 30, 40], 'random_state' : [0]}): \r\n", |
| " super(RandomForest, self).__init__(classifier,\r\n", |
| " test_size,\r\n", |
| " n_splits,\r\n", |
| " random_state,\r\n", |
| " n_jobs,\r\n", |
| " params)\r\n", |
| "\r\n", |
| "class SVC(Model):\r\n", |
| " def __init__(self,\r\n", |
| " classifier=SVC(),\r\n", |
| " test_size=test_size,\r\n", |
| " n_splits=1,\r\n", |
| " random_state=0,\r\n", |
| " n_jobs=None,\r\n", |
| " params={'kernel' : ['poly'], 'degree' : [2, 3, 4]}):\r\n", |
| " super(SVC, self).__init__(classifier,\r\n", |
| " test_size,\r\n", |
| " n_splits,\r\n", |
| " random_state,\r\n", |
| " n_jobs,\r\n", |
| " params)\r\n", |
| "\r\n", |
| "class MLP(Model):\r\n", |
| " def __init__(self,\r\n", |
| " classifier=MLPClassifier(),\r\n", |
| " test_size=test_size,\r\n", |
| " n_splits=1,\r\n", |
| " random_state=0,\r\n", |
| " n_jobs=-1,\r\n", |
| " params={'hidden_layer_sizes' : [(100, 50 ,10)],\r\n", |
| " 'max_iter' : [500],\r\n", |
| " 'activation' : ['relu'],\r\n", |
| " 'solver' : ['adam'],\r\n", |
| " 'random_state' : [1]}):\r\n", |
| " super(MLP, self).__init__(classifier,\r\n", |
| " test_size,\r\n", |
| " n_splits,\r\n", |
| " random_state,\r\n", |
| " n_jobs,\r\n", |
| " params)\r\n", |
| "\r\n", |
| "class GradientBoost(Model):\r\n", |
| " def __init__(self,\r\n", |
| " classifier=GradientBoostingClassifier(),\r\n", |
| " test_size=test_size,\r\n", |
| " n_splits=1,\r\n", |
| " random_state=0,\r\n", |
| " n_jobs=None,\r\n", |
| " params={'n_estimators' : [100, 200, 50],\r\n", |
| " 'random_state' : [0],\r\n", |
| " 'learning_rate' : [1.0],\r\n", |
| " 'max_depth' : [1, 2, 3]}):\r\n", |
| " super(GradientBoost, self).__init__(classifier,\r\n", |
| " test_size,\r\n", |
| " n_splits,\r\n", |
| " random_state,\r\n", |
| " n_jobs,\r\n", |
| " params)\r\n", |
| "\r\n" |
| ], |
| "outputs": [], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": 3, |
| "source": [ |
| "# GERMAN DATASET\r\n", |
| "german = pd.read_csv('./zoo/data/german.csv', index_col=0)\r\n", |
| "x_train, x_test, y_train, y_test = preprocessing(\"German\", german, test_size)\r\n", |
| "\r\n", |
| "# Print Encoders\r\n", |
| "print(categorical)\r\n", |
| "print(label_encoders)\r\n", |
| "\r\n", |
| "# Set and Train the models\r\n", |
| "print('\\nRF')\r\n", |
| "RFmodel = RandomForest().train(x_train, y_train)\r\n", |
| "print(f\"Random Forest: {RFmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nSVC\")\r\n", |
| "SVCmodel = SVC().train(x_train, y_train)\r\n", |
| "print(f\"SVM: {SVCmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nMLP\")\r\n", |
| "MLPmodel = MLP().train(x_train, y_train)\r\n", |
| "print(f\"MLP: {MLPmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nGB\")\r\n", |
| "GBmodel = GradientBoost().train(x_train, y_train)\r\n", |
| "print(f\"Gradient Boost: {GBmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "# Save Training Data\r\n", |
| "joblib.dump(categorical, \"zoo/models/german/categorical.joblib\", compress=True)\r\n", |
| "joblib.dump(label_encoders, \"zoo/models/german/label_encoders.joblib\", compress=True)\r\n", |
| "\r\n", |
| "joblib.dump(RFmodel.model, \"zoo/models/german/rf_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(SVCmodel.model, \"zoo/models/german/svc_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(MLPmodel.model, \"zoo/models/german/mlp_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(GBmodel.model, \"zoo/models/german/gb_classifier.joblib\", compress=True)" |
| ], |
| "outputs": [ |
| { |
| "output_type": "stream", |
| "name": "stdout", |
| "text": [ |
| "['sex', 'risk', 'purpose', 'housing']\n", |
| "{'sex': LabelEncoder(), 'risk': LabelEncoder(), 'purpose': LabelEncoder(), 'housing': LabelEncoder()}\n", |
| "\n", |
| "RF\n", |
| "Random Forest: {'accuracy': 0.675, 'f1_score': 0.5226029157944989, 'recall_score': 0.5362070998938554, 'precision_score': 0.5678603006189213}\n", |
| "\n", |
| "SVC\n", |
| "SVM: {'accuracy': 0.69, 'f1_score': 0.4859890565412038, 'recall_score': 0.5240004717537445, 'precision_score': 0.583710407239819}\n", |
| "\n", |
| "MLP\n", |
| "MLP: {'accuracy': 0.7, 'f1_score': 0.6101871101871102, 'recall_score': 0.6047883005071353, 'precision_score': 0.6316101318323212}\n", |
| "\n", |
| "GB\n", |
| "Gradient Boost: {'accuracy': 0.705, 'f1_score': 0.5736840203764586, 'recall_score': 0.5761882297440736, 'precision_score': 0.6341362126245846}\n" |
| ] |
| }, |
| { |
| "output_type": "execute_result", |
| "data": { |
| "text/plain": [ |
| "['zoo/german/gb_classifier.joblib']" |
| ] |
| }, |
| "metadata": {}, |
| "execution_count": 3 |
| } |
| ], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": null, |
| "source": [], |
| "outputs": [], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": 4, |
| "source": [ |
| "# Australian DATASET\r\n", |
| "australian = [i.strip().split() for i in open(\"./zoo/data/australian.dat\").readlines()]\r\n", |
| "australian = pd.DataFrame(australian)\r\n", |
| "x_train, x_test, y_train, y_test = preprocessing(\"Australian\", australian, test_size)\r\n", |
| "\r\n", |
| "# Print Encoders\r\n", |
| "print(categorical)\r\n", |
| "print(label_encoders)\r\n", |
| "\r\n", |
| "# Set and Train the models\r\n", |
| "print('\\nRF')\r\n", |
| "RFmodel = RandomForest().train(x_train, y_train)\r\n", |
| "print(f\"Random Forest: {RFmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nSVC\")\r\n", |
| "SVCmodel = SVC().train(x_train, y_train)\r\n", |
| "print(f\"SVM: {SVCmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nMLP\")\r\n", |
| "MLPmodel = MLP().train(x_train, y_train)\r\n", |
| "print(f\"MLP: {MLPmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nGB\")\r\n", |
| "GBmodel = GradientBoost().train(x_train, y_train)\r\n", |
| "print(f\"Gradient Boost: {GBmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "# Save Training Data\r\n", |
| "joblib.dump(categorical, \"zoo/models/australian/categorical.joblib\", compress=True)\r\n", |
| "joblib.dump(label_encoders, \"zoo/australian/label_encoders.joblib\", compress=True)\r\n", |
| "\r\n", |
| "joblib.dump(RFmodel.model, \"zoo/models/australian/rf_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(SVCmodel.model, \"zoo/models/australian/svc_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(MLPmodel.model, \"zoo/models/australian/mlp_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(GBmodel.model, \"zoo/models/australian/gb_classifier.joblib\", compress=True)" |
| ], |
| "outputs": [ |
| { |
| "output_type": "stream", |
| "name": "stdout", |
| "text": [ |
| "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]\n", |
| "{0: LabelEncoder(), 1: LabelEncoder(), 2: LabelEncoder(), 3: LabelEncoder(), 4: LabelEncoder(), 5: LabelEncoder(), 6: LabelEncoder(), 7: LabelEncoder(), 8: LabelEncoder(), 9: LabelEncoder(), 10: LabelEncoder(), 11: LabelEncoder(), 12: LabelEncoder(), 13: LabelEncoder(), 14: LabelEncoder()}\n", |
| "\n", |
| "RF\n", |
| "Random Forest: {'accuracy': 0.855072463768116, 'f1_score': 0.8549505991170906, 'recall_score': 0.8562697576396207, 'precision_score': 0.855072463768116}\n", |
| "\n", |
| "SVC\n", |
| "SVM: {'accuracy': 0.8623188405797102, 'f1_score': 0.8623116105655622, 'recall_score': 0.8648050579557429, 'precision_score': 0.8642676767676767}\n", |
| "\n", |
| "MLP\n", |
| "MLP: {'accuracy': 0.855072463768116, 'f1_score': 0.8549505991170906, 'recall_score': 0.8562697576396207, 'precision_score': 0.855072463768116}\n", |
| "\n", |
| "GB\n", |
| "Gradient Boost: {'accuracy': 0.8695652173913043, 'f1_score': 0.8691253951527924, 'recall_score': 0.8691253951527924, 'precision_score': 0.8691253951527924}\n" |
| ] |
| }, |
| { |
| "output_type": "execute_result", |
| "data": { |
| "text/plain": [ |
| "['zoo/australian/gb_classifier.joblib']" |
| ] |
| }, |
| "metadata": {}, |
| "execution_count": 4 |
| } |
| ], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": null, |
| "source": [], |
| "outputs": [], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": 5, |
| "source": [ |
| "# Japanese DATASET\r\n", |
| "japanese = [i.strip().split(\",\") for i in open(\"./zoo/data/japanese/japanese.data\").readlines()]\r\n", |
| "japanese = pd.DataFrame(japanese)\r\n", |
| "x_train, x_test, y_train, y_test = preprocessing(\"Japanese\", japanese, test_size)\r\n", |
| "\r\n", |
| "# Print Encoders\r\n", |
| "print(categorical)\r\n", |
| "print(label_encoders)\r\n", |
| "\r\n", |
| "# Set and Train the models\r\n", |
| "print('\\nRF')\r\n", |
| "RFmodel = RandomForest().train(x_train, y_train)\r\n", |
| "print(f\"Random Forest: {RFmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nSVC\")\r\n", |
| "SVCmodel = SVC().train(x_train, y_train)\r\n", |
| "print(f\"SVM: {SVCmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nMLP\")\r\n", |
| "MLPmodel = MLP().train(x_train, y_train)\r\n", |
| "print(f\"MLP: {MLPmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nGB\")\r\n", |
| "GBmodel = GradientBoost().train(x_train, y_train)\r\n", |
| "print(f\"Gradient Boost: {GBmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "# Save Training Data\r\n", |
| "joblib.dump(categorical, \"zoo/models/japanese/categorical.joblib\", compress=True)\r\n", |
| "joblib.dump(label_encoders, \"zoo/models/japanese/label_encoders.joblib\", compress=True)\r\n", |
| "\r\n", |
| "joblib.dump(RFmodel.model, \"zoo/models/japanese/rf_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(SVCmodel.model, \"zoo/models/japanese/svc_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(MLPmodel.model, \"zoo/models/japanese/mlp_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(GBmodel.model, \"zoo/models/japanese/gb_classifier.joblib\", compress=True)" |
| ], |
| "outputs": [ |
| { |
| "output_type": "stream", |
| "name": "stdout", |
| "text": [ |
| "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n", |
| "{0: LabelEncoder(), 1: LabelEncoder(), 2: LabelEncoder(), 3: LabelEncoder(), 4: LabelEncoder(), 5: LabelEncoder(), 6: LabelEncoder(), 7: LabelEncoder(), 8: LabelEncoder(), 9: LabelEncoder(), 10: LabelEncoder(), 11: LabelEncoder(), 12: LabelEncoder(), 13: LabelEncoder(), 14: LabelEncoder(), 15: LabelEncoder()}\n", |
| "\n", |
| "RF\n", |
| "Random Forest: {'accuracy': 0.9057971014492754, 'f1_score': 0.9020475020475021, 'recall_score': 0.9130143112701252, 'precision_score': 0.8962668955159837}\n", |
| "\n", |
| "SVC\n", |
| "SVM: {'accuracy': 0.8478260869565217, 'f1_score': 0.8442186744073537, 'recall_score': 0.8627012522361359, 'precision_score': 0.8418335089567967}\n", |
| "\n", |
| "MLP\n", |
| "MLP: {'accuracy': 0.8115942028985508, 'f1_score': 0.8057179987004548, 'recall_score': 0.8184257602862254, 'precision_score': 0.8022071307300509}\n", |
| "\n", |
| "GB\n", |
| "Gradient Boost: {'accuracy': 0.8695652173913043, 'f1_score': 0.8639649507119387, 'recall_score': 0.8725402504472272, 'precision_score': 0.8590517241379311}\n" |
| ] |
| }, |
| { |
| "output_type": "execute_result", |
| "data": { |
| "text/plain": [ |
| "['zoo/japanese/gb_classifier.joblib']" |
| ] |
| }, |
| "metadata": {}, |
| "execution_count": 5 |
| } |
| ], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": null, |
| "source": [], |
| "outputs": [], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": 6, |
| "source": [ |
| "# Taiwan DATASET\r\n", |
| "taiwan = pd.read_excel('./zoo/data/taiwan.xls', index_col=0, header=1)\r\n", |
| "x_train, x_test, y_train, y_test = preprocessing(\"Taiwan\", taiwan, test_size)\r\n", |
| "\r\n", |
| "# Print Encoders\r\n", |
| "print(categorical)\r\n", |
| "print(label_encoders)\r\n", |
| "\r\n", |
| "# Set and Train the models\r\n", |
| "print('\\nRF')\r\n", |
| "RFmodel = RandomForest().train(x_train, y_train)\r\n", |
| "print(f\"Random Forest: {RFmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nSVC\")\r\n", |
| "SVCmodel = SVC().train(x_train, y_train)\r\n", |
| "print(f\"SVM: {SVCmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nMLP\")\r\n", |
| "MLPmodel = MLP().train(x_train, y_train)\r\n", |
| "print(f\"MLP: {MLPmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nGB\")\r\n", |
| "GBmodel = GradientBoost().train(x_train, y_train)\r\n", |
| "print(f\"Gradient Boost: {GBmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "# Save Training Data\r\n", |
| "joblib.dump(categorical, \"zoo/models/taiwan/categorical.joblib\", compress=True)\r\n", |
| "joblib.dump(label_encoders, \"zoo/models/taiwan/label_encoders.joblib\", compress=True)\r\n", |
| "\r\n", |
| "joblib.dump(RFmodel.model, \"zoo/models/taiwan/rf_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(SVCmodel.model, \"zoo/models/taiwan/svc_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(MLPmodel.model, \"zoo/models/taiwan/mlp_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(GBmodel.model, \"zoo/models/taiwan/gb_classifier.joblib\", compress=True)" |
| ], |
| "outputs": [ |
| { |
| "output_type": "stream", |
| "name": "stdout", |
| "text": [ |
| "[]\n", |
| "{}\n", |
| "\n", |
| "RF\n", |
| "Random Forest: {'accuracy': 0.8181666666666667, 'f1_score': 0.681903656460614, 'recall_score': 0.6583642128492948, 'precision_score': 0.7439043272511898}\n", |
| "\n", |
| "SVC\n", |
| "SVM: {'accuracy': 0.81, 'f1_score': 0.616125081264749, 'recall_score': 0.6001113663459882, 'precision_score': 0.7597362173568979}\n", |
| "\n", |
| "MLP\n", |
| "MLP: {'accuracy': 0.7716666666666666, 'f1_score': 0.628088225074129, 'recall_score': 0.6176235046432739, 'precision_score': 0.6493170130422868}\n", |
| "\n", |
| "GB\n", |
| "Gradient Boost: {'accuracy': 0.8228333333333333, 'f1_score': 0.6804605216188897, 'recall_score': 0.6544810313636326, 'precision_score': 0.7611662244399562}\n" |
| ] |
| }, |
| { |
| "output_type": "execute_result", |
| "data": { |
| "text/plain": [ |
| "['zoo/taiwan/gb_classifier.joblib']" |
| ] |
| }, |
| "metadata": {}, |
| "execution_count": 6 |
| } |
| ], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": null, |
| "source": [], |
| "outputs": [], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": 15, |
| "source": [ |
| "# Polish DATASET\r\n", |
| "from scipy.io import arff\r\n", |
| "\r\n", |
| "year_1 = pd.DataFrame(arff.loadarff('./zoo/data/polish/1year.arff')[0])\r\n", |
| "year_2 = pd.DataFrame(arff.loadarff('./zoo/data/polish/2year.arff')[0])\r\n", |
| "year_3 = pd.DataFrame(arff.loadarff('./zoo/data/polish/3year.arff')[0])\r\n", |
| "year_4 = pd.DataFrame(arff.loadarff('./zoo/data/polish/4year.arff')[0])\r\n", |
| "year_5 = pd.DataFrame(arff.loadarff('./zoo/data/polish/5year.arff')[0])\r\n", |
| "polish = pd.concat([year_1, year_2, year_3, year_4, year_5], ignore_index=True)\r\n", |
| "x_train, x_test, y_train, y_test = preprocessing(\"Polish\", polish, test_size)\r\n", |
| "\r\n", |
| "# Print Encoders\r\n", |
| "print(categorical)\r\n", |
| "print(label_encoders)\r\n", |
| "\r\n", |
| "# Set and Train the models\r\n", |
| "print('\\nRF')\r\n", |
| "RFmodel = RandomForest().train(x_train, y_train)\r\n", |
| "print(f\"Random Forest: {RFmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nSVC\")\r\n", |
| "SVCmodel = SVC().train(x_train, y_train)\r\n", |
| "print(f\"SVM: {SVCmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nMLP\")\r\n", |
| "MLPmodel = MLP().train(x_train, y_train)\r\n", |
| "print(f\"MLP: {MLPmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "print(\"\\nGB\")\r\n", |
| "GBmodel = GradientBoost().train(x_train, y_train)\r\n", |
| "print(f\"Gradient Boost: {GBmodel.metrics(x_test, y_test)}\")\r\n", |
| "\r\n", |
| "# Save Training Data\r\n", |
| "joblib.dump(categorical, \"zoo/models/polish/categorical.joblib\", compress=True)\r\n", |
| "joblib.dump(label_encoders, \"zoo/models/polish/label_encoders.joblib\", compress=True)\r\n", |
| "\r\n", |
| "joblib.dump(RFmodel.model, \"zoo/models/polish/rf_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(SVCmodel.model, \"zoo/models/polish/svc_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(MLPmodel.model, \"zoo/models/polish/mlp_classifier.joblib\", compress=True)\r\n", |
| "joblib.dump(GBmodel.model, \"zoo/models/polish/gb_classifier.joblib\", compress=True)" |
| ], |
| "outputs": [ |
| { |
| "output_type": "stream", |
| "name": "stdout", |
| "text": [ |
| "['class']\n", |
| "{'sex': LabelEncoder(), 'risk': LabelEncoder(), 'housing': LabelEncoder(), 'purpose': LabelEncoder(), 0: LabelEncoder(), 1: LabelEncoder(), 2: LabelEncoder(), 3: LabelEncoder(), 4: LabelEncoder(), 5: LabelEncoder(), 6: LabelEncoder(), 7: LabelEncoder(), 8: LabelEncoder(), 9: LabelEncoder(), 10: LabelEncoder(), 11: LabelEncoder(), 12: LabelEncoder(), 13: LabelEncoder(), 14: LabelEncoder(), 15: LabelEncoder(), 'class': LabelEncoder()}\n", |
| "Random Forest: {'accuracy': 0.9802203304957436, 'f1_score': 0.5073501054699149, 'recall_score': 0.5059245566321038, 'precision_score': 0.5466471490310888}\n", |
| "SVM: {'accuracy': 0.9817225838758137, 'f1_score': 0.49538850284270375, 'recall_score': 0.4998725140234574, 'precision_score': 0.49098422238918105}\n", |
| "MLP: {'accuracy': 0.9799699549323986, 'f1_score': 0.71321171997573, 'recall_score': 0.7103058246926172, 'precision_score': 0.7162043104703655}\n", |
| "Gradient Boost: {'accuracy': 0.9819729594391587, 'f1_score': 0.566873915558126, 'recall_score': 0.5409017508074112, 'precision_score': 0.7417127071823204}\n" |
| ] |
| }, |
| { |
| "output_type": "execute_result", |
| "data": { |
| "text/plain": [ |
| "['zoo/polish/gb_classifier.joblib']" |
| ] |
| }, |
| "metadata": {}, |
| "execution_count": 15 |
| } |
| ], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": null, |
| "source": [], |
| "outputs": [], |
| "metadata": {} |
| }, |
| { |
| "cell_type": "code", |
| "execution_count": null, |
| "source": [], |
| "outputs": [], |
| "metadata": {} |
| } |
| ] |
| } |
