project_ph252.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "PeJvpVD--LqL"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.sparse.construct import random\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import requests\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.linear_model import Lasso\n",
    "from sklearn.linear_model import ElasticNet\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.svm import LinearSVR\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.ensemble import ExtraTreesRegressor\n",
    "from sklearn.ensemble import AdaBoostRegressor\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import learning_curve\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "seed=1337"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U6vFlG_qc_5u"
   },
   "source": [
    "## Import Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "ElcC0txT-PiM"
   },
   "outputs": [],
   "source": [
    "def fetch_OEC_data(data_url=\"https://raw.githubusercontent.com/OpenExoplanetCatalogue/oec_tables/master/comma_separated/open_exoplanet_catalogue.txt\",\n",
    "                   dir_path=os.path.join(\"datasets\", \"OEC\")):\n",
    "    '''\n",
    "    Downloads the current version of the Open Exoplanet Catalog\n",
    "    from github and creates a directory to store the csv file. It\n",
    "    returns the data as a pandas dataframe.\n",
    "    ---------------------------------------\n",
    "    INPUTS: data_url = The url to fetch the data from\n",
    "            dir_path = The directory to save the csv file.\n",
    "    OUTPUTS: Pandas.DataFrame()\n",
    "    ---------------------------------------\n",
    "    Columns names are based on the documentation provided\n",
    "    at https://github.com/OpenExoplanetCatalogue/oec_tables.\n",
    "    The names of the planets are used as indeces of the dataframe.\n",
    "    '''\n",
    "    \n",
    "    os.makedirs(dir_path, exist_ok=True)\n",
    "    data_path = os.path.join(dir_path, \"oec.csv\")\n",
    "    r = requests.get(data_url)\n",
    "    with open(data_path, \"wb\") as f:\n",
    "        f.write(r.content)\n",
    "    columns = [\n",
    "        \"Identifier\", \n",
    "        \"BinaryFlag\",\n",
    "        \"MassJpt\", \n",
    "        \"RadiusJpt\", \n",
    "        \"PeriodDays\", \n",
    "        \"SemiMajorAxisAU\",\n",
    "        \"Eccentricity\", \n",
    "        \"PeriastronDeg\", \n",
    "        \"LongitudeDeg\", \n",
    "        \"AscendingNodeDeg\", \n",
    "        \"InclinationDeg\", \n",
    "        \"EquilibriumTempK\", \n",
    "        \"AgeGyr\", \n",
    "        \"DiscoveryMethod\", \n",
    "        \"DiscoveryYear\", \n",
    "        \"LastUpdated\", \n",
    "        \"RA\", \n",
    "        \"Dec\", \n",
    "        \"DistParsec\", \n",
    "        \"StarMass\", \n",
    "        \"StarRadius\", \n",
    "        \"StarMetallicity\", \n",
    "        \"StarTempK\", \n",
    "        \"StarAgeGyr\", \n",
    "        \"ListPlanetIsOn\"]\n",
    "    return pd.read_csv(data_path, delimiter=',', skiprows=31, names=columns, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "IMjF8_xv-SIn"
   },
   "outputs": [],
   "source": [
    "def prepare_data(df):\n",
    "    '''\n",
    "    Prepares the dataframe for the regressor. It does so by either\n",
    "    dropping features that don't contain useful information for\n",
    "    the regressor, or are not physically motivated. It also calculates\n",
    "    the equilibrium temperature of planets that have the necessary\n",
    "    information, and fills the missing values of the 'EquilibriumTempK'\n",
    "    feature. Finally it calculates the stellar luminosity of the star\n",
    "    of each system and appends the feature column to the rest of the\n",
    "    dataframe.\n",
    "    ---------------------------------------\n",
    "    INPUTS: df = pandas.DataFrame The OEC dataframe\n",
    "    OUTPUTS: df = pandas.DataFrame The processed OEC dataframe \n",
    "    ---------------------------------------\n",
    "\n",
    "    Columns names are based on the documentation provided\n",
    "    at https://github.com/OpenExoplanetCatalogue/oec_tables\n",
    "    '''\n",
    "\n",
    "    df.loc[df['ListPlanetIsOn'] == 'Confirmed planets']\n",
    "    df = df.drop([\n",
    "        'BinaryFlag', \n",
    "        'DiscoveryMethod', \n",
    "        'DiscoveryYear', \n",
    "        'LastUpdated', \n",
    "        'RA', \n",
    "        'Dec', \n",
    "        'DistParsec', \n",
    "        'ListPlanetIsOn', \n",
    "        'PeriastronDeg', \n",
    "        'LongitudeDeg', \n",
    "        'AscendingNodeDeg',\n",
    "        'AgeGyr',\n",
    "        'InclinationDeg', \n",
    "        'StarAgeGyr'],\n",
    "        axis=1,\n",
    "        )\n",
    "    # Kelvins\n",
    "    df[\"EquilibriumTempK\"] = df[\"EquilibriumTempK\"].fillna((df[\"StarRadius\"]*0.00465047/(2*df[\"SemiMajorAxisAU\"]))**(1/2)*df[\"StarTempK\"]/(1-df[\"Eccentricity\"]**2)**(1/8))\n",
    "    # Solar luminosities\n",
    "    df.insert(len(df.columns), \"StarLuminosity\", 4*np.pi*(df[\"StarRadius\"]*6.957E+8)**2*5.670374419E-8*df[\"StarTempK\"]**4/(3.848E+26))\n",
    "    # We drop any planets that have missing values\n",
    "    df = df.dropna(axis=0, how=\"any\")\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "iyV-Wv33ZnzD"
   },
   "outputs": [],
   "source": [
    "def prepare_data_mass_only(df):\n",
    "    '''\n",
    "    Prepares the dataframe for the regressor. It does so by either\n",
    "    dropping features that don't contain useful information for\n",
    "    the regressor, or are not physically motivated. It also calculates\n",
    "    the equilibrium temperature of planets that have the necessary\n",
    "    information, and fills the missing values of the 'EquilibriumTempK'\n",
    "    feature. Finally it calculates the stellar luminosity of the star\n",
    "    of each system and appends the feature column to the rest of the\n",
    "    dataframe.\n",
    "    ---------------------------------------\n",
    "    INPUTS: df = The OEC dataframe.\n",
    "    OUTPUTS: df = The processed OEC dataframe.\n",
    "    ---------------------------------------\n",
    "\n",
    "    Columns names are based on the documentation provided\n",
    "    at https://github.com/OpenExoplanetCatalogue/oec_tables\n",
    "    '''\n",
    "\n",
    "    # Use only Confirmed Planets\n",
    "    df.loc[df['ListPlanetIsOn'] == 'Confirmed planets']\n",
    "    # Remove \n",
    "    df = df.drop([\n",
    "        'BinaryFlag', \n",
    "        'DiscoveryMethod', \n",
    "        'DiscoveryYear', \n",
    "        'LastUpdated', \n",
    "        'RA', \n",
    "        'Dec', \n",
    "        'DistParsec', \n",
    "        'ListPlanetIsOn', \n",
    "        'PeriastronDeg', \n",
    "        'LongitudeDeg', \n",
    "        'AscendingNodeDeg',\n",
    "        'AgeGyr',\n",
    "        'InclinationDeg', \n",
    "        'StarAgeGyr'],\n",
    "        axis=1)\n",
    "    # Kelvins\n",
    "    df[\"EquilibriumTempK\"] = df[\"EquilibriumTempK\"].fillna((df[\"StarRadius\"]*0.00465047/(2*df[\"SemiMajorAxisAU\"]))**(1/2)*df[\"StarTempK\"]/(1-df[\"Eccentricity\"]**2)**(1/8))\n",
    "    # Solar luminosities\n",
    "    df.insert(len(df.columns), \"StarLuminosity\", 4*np.pi*(df[\"StarRadius\"]*6.957E+8)**2*5.670374419E-8*df[\"StarTempK\"]**4/(3.848E+26))\n",
    "    # We drop any planets that have missing values\n",
    "    df = df[['MassJpt', 'RadiusJpt']].dropna(axis=0, how=\"any\")\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HPrY0JDbdDmV"
   },
   "source": [
    "## Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "I-4cGzlGAbs4"
   },
   "outputs": [],
   "source": [
    "def split(df):\n",
    "    '''\n",
    "    Creates a random split of the data to a training set and a test set.\n",
    "    The split is 75-25.\n",
    "    ---------------------------------------\n",
    "    INPUTS: df = pandas.DataFrame() The OEC dataframe\n",
    "    OUTPUTS: X_train = numpy.ndarray() with shape (number of features\n",
    "        other than radius, number of planets) containing the training\n",
    "        set samples.\n",
    "             y_train = numpy.ndarray() with shape (1,) containing the\n",
    "        radius training labels\n",
    "             X_test = numpy.ndarray() with shape (number of features\n",
    "        other than radius, number of planets) containing the training\n",
    "        set samples.\n",
    "             y_test = numpy.ndarray() with shape (1,) containing the\n",
    "        radius test labels\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        df.loc[:, df.columns != 'RadiusJpt'].to_numpy(), \n",
    "        np.ravel(df[\"RadiusJpt\"]),\n",
    "        test_size=0.25, \n",
    "        shuffle=True, \n",
    "        random_state=seed)\n",
    "    \n",
    "    return X_train, y_train, X_test, y_test\n",
    "\n",
    "def learning_curves(model, X, y):\n",
    "    '''\n",
    "    Creates the learning curves of our data and plots them.\n",
    "    Returns the cv-scores for several different training set\n",
    "    sizes.\n",
    "    ---------------------------------------\n",
    "    INPUTS: model = Sklearn estimator object.\n",
    "            X = np.ndarray() with the shape training data.\n",
    "            y = np.ndarray() with the shape of the training data's labels.\n",
    "    OUTPUTS: val_scores_mean = np.ndarray() containing the mean cross\n",
    "            validation score of the model for each training set size.\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    train_sizes, train_scores, valid_scores = learning_curve(\n",
    "        model, \n",
    "        X, \n",
    "        y, \n",
    "        train_sizes=np.linspace(0.1, 1.0, 8), \n",
    "        cv=5, \n",
    "        scoring='r2', \n",
    "        n_jobs=-1, \n",
    "        random_state=seed)\n",
    "    train_scores_mean = np.mean(train_scores, axis=1)\n",
    "    val_scores_mean = np.mean(valid_scores, axis=1)\n",
    "    train_scores_std = np.std(train_scores, axis=1)\n",
    "    val_scores_std = np.std(valid_scores, axis=1)\n",
    "    plt.fill_between(train_sizes, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.1, color=\"r\")\n",
    "    plt.fill_between(train_sizes, val_scores_mean - val_scores_std, val_scores_mean + val_scores_std, alpha=0.1, color=\"b\")\n",
    "    plt.plot(train_sizes, train_scores_mean, \"r-o\", linewidth=2, label=\"Training Score\")\n",
    "    plt.plot(train_sizes, val_scores_mean, \"b-o\", linewidth=3, label=\"Cross-Validation Score\")\n",
    "    plt.title(type(model).__name__)\n",
    "    plt.xlabel(\"Training Set Size\")\n",
    "    plt.ylabel(\"Score\")\n",
    "    plt.legend()\n",
    "    plt.xticks(train_sizes)\n",
    "    return val_scores_mean\n",
    "\n",
    "def evaluate(model, X_train, y_train):\n",
    "    '''\n",
    "    Creates a validation set composed of 25% of the training data\n",
    "    to compute the RMSE of the estimator and stores it with the cv score\n",
    "    computed from the learing_curves function to return them.\n",
    "    ---------------------------------------\n",
    "    INPUTS: model = Sklearn estimator object.\n",
    "            X_train = np.ndarray() containing the training data.\n",
    "            y = np.ndarray() containing the labels of the training data.\n",
    "    OUTPUTS: scores = tuple containing the RMSE and cv scores.\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_val, y_val = X_train[int(len(X_train)*75/100):,:], y_train[int(len(X_train)*75/100):]\n",
    "    cv_score = learning_curves(model, X_train, y_train)\n",
    "    y_predict = model.predict(X_val)\n",
    "    RMSE = mean_squared_error(y_val, y_predict, squared=False)\n",
    "    scores = RMSE, cv_score\n",
    "    return scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printScores(RMSE_val, cv, r2, RMSE):\n",
    "    print('Validation set RMSE:', RMSE_val)\n",
    "    print('CV score:', cv)\n",
    "    print('Test set R2 score:', r2)\n",
    "    print('Test set RMSE:', RMSE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ene00xcbdHgq"
   },
   "source": [
    "## Ensemble Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "JFCYjXPRAWDn"
   },
   "outputs": [],
   "source": [
    "def decision_tree_regressor(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    CART based decision trees regression algorithm. If the necessery input\n",
    "    parameters are provided it is able to optimize the model using \n",
    "    RandomizedSearchCV and GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    if fit==True:\n",
    "        dt = DecisionTreeRegressor()\n",
    "        # RandomSerchCV\n",
    "        random_grid = {'max_features': np.arange(0.1, 11, 0.1)}\n",
    "        dt_random = RandomizedSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_distributions=random_grid, \n",
    "            n_iter=100, \n",
    "            cv=5, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        dt_random.fit(X_train, y_train)\n",
    "\n",
    "        # GridSearchCV\n",
    "        grid = dt_random.best_params_.copy()\n",
    "        grid['max_features'] = np.arange(grid['max_features']-1,grid['max_features']+1,1)\n",
    "        grid['max_depth'] = np.arange(10, 100, 10)\n",
    "        grid['min_samples_split'] = np.arange(2,11)\n",
    "        grid['min_samples_leaf'] = np.arange(1,5)\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=3, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        model = DecisionTreeRegressor(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = DecisionTreeRegressor(random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test)), mean_squared_error(y_test, model.predict(X_test), squared=False)\n",
    "    else:\n",
    "        return model\n",
    "\n",
    "def random_forest_regressor(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Random Forest ensemble method utilizing CART based decision trees regression algorithms. \n",
    "    If the necessery input parameters are provided it is able to optimize the model using \n",
    "    RandomizedSearchCV and GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    if fit==True:\n",
    "        rf = RandomForestRegressor()\n",
    "        # RandomSerchCV\n",
    "        random_grid = {\n",
    "            'n_estimators': np.arange(100, 1000, 10),\n",
    "            'max_depth': np.arange(10, 100, 10),\n",
    "            'max_features': np.arange(0.1, 10, 0.1),\n",
    "            'min_samples_split': np.arange(2,11),\n",
    "            'min_samples_leaf': np.arange(1,5)}\n",
    "        rf_random = RandomizedSearchCV(\n",
    "            estimator = rf, \n",
    "            scoring='r2', \n",
    "            param_distributions=random_grid, \n",
    "            n_iter = 300, \n",
    "            cv=3, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        rf_random.fit(X_train, y_train)\n",
    "\n",
    "        #GridSearchCV\n",
    "        grid = rf_random.best_params_.copy()\n",
    "        grid['n_estimators'] = np.linspace(grid['n_estimators']-10, grid['n_estimators']+10, 10, dtype=int)\n",
    "        grid['max_depth'] = np.linspace(grid['max_depth']-10, grid['max_depth']+10, 10, dtype=int)\n",
    "        grid['min_samples_split'] = [grid['min_samples_split']]\n",
    "        grid['min_samples_leaf'] = [grid['min_samples_leaf']]\n",
    "        grid['max_features'] = np.linspace(grid['max_features']-1, grid['max_features']+1, 3)\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = rf, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=3, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        model = RandomForestRegressor(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = RandomForestRegressor(random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test)), mean_squared_error(y_test, model.predict(X_test), squared=False)\n",
    "    else:\n",
    "        return model\n",
    "\n",
    "def extra_trees_regressor(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Extra Trees ensemble method utilizing CART based decision trees regression algorithms. \n",
    "    If the necessery input parameters are provided it is able to optimize the model using \n",
    "    GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    if fit==True:\n",
    "        et = ExtraTreesRegressor()\n",
    "        #GridSearchCV\n",
    "        grid = {\n",
    "            'n_estimators': np.arange(10, 110, 10),\n",
    "            'max_depth': [1, 5, 10, 20], # Limited max depth to prevent overfitting\n",
    "            'max_features': [1, 2, 3, 4, 5, 6],\n",
    "            'min_impurity_decrease': [0.0001, 0.001, 0.01, 0.1, 0],\n",
    "            'bootstrap': [True]}\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = et, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=3, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        model = ExtraTreesRegressor(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = ExtraTreesRegressor(bootstrap=True, random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test)), mean_squared_error(y_test, model.predict(X_test), squared=False)\n",
    "    else:\n",
    "        return model\n",
    "\n",
    "def adaboost(dataset, base_model, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    AdaBoost algorithm that performs adaptive boosting using base_model as the\n",
    "    base estimator. If the necessery input parameters are provided it is able to \n",
    "    optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    if fit==True:\n",
    "        ad = AdaBoostRegressor()\n",
    "        #GridSearchCV\n",
    "        grid = {\n",
    "            'n_estimators': np.arange(10, 70, 10),\n",
    "            'learning_rate': np.arange(0.1, 1.1, 0.1),\n",
    "            'loss': ['linear', 'square', 'exponential'],\n",
    "            'base_estimator': [base_model]\n",
    "            }\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = ad, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=3, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        model = AdaBoostRegressor(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = AdaBoostRegressor(base_estimator=base_model, random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test)), mean_squared_error(y_test, model.predict(X_test), squared=False)\n",
    "    else:\n",
    "        return model\n",
    "\n",
    "def gradientboost(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Gradient Boosted Regression Tree algorithm that performs gradient boosting. \n",
    "    If the necessery input parameters are provided it is able to optimize the model using \n",
    "    RandomizedSearchCV and GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    if fit==True:\n",
    "        gd = GradientBoostingRegressor()\n",
    "        # RandomSerchCV\n",
    "        random_grid = {\n",
    "            'n_estimators': np.arange(10, 100, 10),\n",
    "            'max_depth': np.linspace(1, 10, 4, dtype=int),\n",
    "            'max_features': np.arange(0.1, 10, 0.1),\n",
    "            'min_samples_split': np.arange(2,11),\n",
    "            'min_samples_leaf': np.arange(1,5),\n",
    "            'learning_rate': np.arange(0.1, 1.1, 0.1),\n",
    "            'subsample': [0.1, 0.5, 1.0]}\n",
    "        gd_random = RandomizedSearchCV(\n",
    "            estimator = gd, \n",
    "            scoring='r2', \n",
    "            param_distributions=random_grid, \n",
    "            n_iter = 1000, \n",
    "            cv = 5, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        gd_random.fit(X_train, y_train)\n",
    "\n",
    "        #GridSearchCV\n",
    "        grid = gd_random.best_params_.copy()\n",
    "        grid['n_estimators'] = np.linspace(grid['n_estimators']-10, grid['n_estimators']+10, 10, dtype=int)\n",
    "        grid['max_depth'] = np.linspace(grid['max_depth']-10, grid['max_depth']+10, 10, dtype=int)\n",
    "        grid['min_samples_split'] = [grid['min_samples_split']]\n",
    "        grid['min_samples_leaf'] = [grid['min_samples_leaf']]\n",
    "        grid['max_features'] = np.linspace(grid['max_features']-1, grid['max_features']+1, 3)\n",
    "        grid['subsample'] = [grid['subsample']]\n",
    "        grid['learning_rate'] = [grid['learning_rate']]\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = gd, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=10, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        model = GradientBoostingRegressor(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = GradientBoostingRegressor(random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test)), mean_squared_error(y_test, model.predict(X_test), squared=False)\n",
    "    else:\n",
    "        return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ycjrEOZ4STXu"
   },
   "source": [
    "# Regression Models with Regularization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "XkKRULbuLo8M"
   },
   "outputs": [],
   "source": [
    "def linridge(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Linear Ridge Regression model. If the necessery input parameters are provided \n",
    "    it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt = Ridge()\n",
    "        # GridSearchCV\n",
    "        grid = {'alpha': [0.01, 0.1, 1],\n",
    "                'max_iter': np.arange(100,1000,100)}\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=3, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        model = Ridge(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = Ridge(random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        plt.ylim(0.001,5)\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test))\n",
    "    else:\n",
    "        return model\n",
    "    \n",
    "def linlasso(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Linear LASSO Regression model. If the necessery input parameters are provided \n",
    "    it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt = Lasso()\n",
    "        # GridSearchCV\n",
    "        grid = {'alpha': [0.001,0.01, 0.1, 1,10],\n",
    "                'max_iter': np.arange(100,1000,100)}\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=3,\n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        grid_search.best_params_['selection'] = 'random'\n",
    "        model = Lasso(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = Lasso(alpha=0.01,max_iter=100,random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        plt.ylim(0.001,5)\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test))\n",
    "    else:\n",
    "        return model\n",
    "    \n",
    "def linelastic(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Linear Elastic Regression model. If the necessery input parameters are provided \n",
    "    it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt = ElasticNet()\n",
    "        # GridSearchCV\n",
    "        grid = {'alpha': [0.01, 0.1, 1, 10],\n",
    "                'l1_ratio': np.arange(0,1,0.1),\n",
    "                'max_iter': np.arange(100,1000,100)}\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=3, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        grid_search.best_params_['selection'] = 'random'\n",
    "        model = ElasticNet(**grid_search.best_params_)\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = ElasticNet(alpha=0.1,max_iter=100,l1_ratio=0.2,random_state=seed)\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        plt.ylim(0.001,5)\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test))\n",
    "    else:\n",
    "        return model\n",
    "    \n",
    "def polyridge(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Polynomial Ridge Regression model. If the necessery input parameters are provided \n",
    "    it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt = Ridge()\n",
    "        # GridSearchCV\n",
    "        grid = {'alpha': [ 1, 10, 100],\n",
    "                'max_iter': np.arange(100,1000,100)}\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=10, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        model = Ridge(**grid_search.best_params_)\n",
    "        model= Pipeline([\n",
    "                         (\"poly_features\",PolynomialFeatures(degree =2, include_bias = False)),\n",
    "                         (\"ridge\", model)                            \n",
    "        ])\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = Ridge(alpha=100, max_iter=100,random_state=seed)\n",
    "        model = Pipeline([\n",
    "                    (\"poly_features\", PolynomialFeatures(degree =2, include_bias = False)),\n",
    "                    (\"ridge\", model)\n",
    "                ])\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        plt.ylim(0.001,5)\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test))\n",
    "    else:\n",
    "        return model\n",
    "    \n",
    "def polylasso(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Polynomial LASSO Regression model. If the necessery input parameters are provided \n",
    "    it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt = Lasso()\n",
    "        # GridSearchCV\n",
    "        grid = {'alpha': [1, 10, 100],\n",
    "                'max_iter': np.arange(100,1000,100)}\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=10, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        grid_search.best_params_['selection'] = 'random'\n",
    "        model = Lasso(**grid_search.best_params_)\n",
    "        model= Pipeline([\n",
    "                         (\"poly_features\", PolynomialFeatures(degree=2,include_bias=False)),\n",
    "                         (\"lasso\", model)\n",
    "        ])\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = Lasso(max_iter=100,random_state=seed)\n",
    "        model = Pipeline([\n",
    "                    (\"poly_features\", PolynomialFeatures(degree =2, include_bias = False)),\n",
    "                    (\"lasso\", model)\n",
    "                ])\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        plt.ylim(0.001,5)\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test))\n",
    "    else:\n",
    "        return model\n",
    "    \n",
    "def polyelastic(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Polynomial Elastic Regression model. If the necessery input parameters are provided \n",
    "    it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt = ElasticNet()\n",
    "        # GridSearchCV\n",
    "        grid = {'alpha': [10, 100],\n",
    "                'l1_ratio': np.arange(0,1,0.1),\n",
    "                'max_iter': np.arange(100,1000,100)}\n",
    "        grid_search = GridSearchCV(\n",
    "            estimator = dt, \n",
    "            scoring='r2', \n",
    "            param_grid=grid, \n",
    "            cv=10, \n",
    "            verbose=2, \n",
    "            n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        grid_search.best_params_['random_state'] = seed\n",
    "        grid_search.best_params_['selection'] = 'random'\n",
    "        model = ElasticNet(**grid_search.best_params_)\n",
    "        model= Pipeline ([\n",
    "                          (\"poly_features\", PolynomialFeatures(degree=2, include_bias=False)),\n",
    "                          (\"elastic\", model)\n",
    "        ])\n",
    "        model.fit(X_train, y_train)\n",
    "    else:\n",
    "        model = ElasticNet(l1_ratio=0.0,alpha=10,max_iter=100,random_state=seed)\n",
    "        model = Pipeline([\n",
    "                    (\"poly_features\", PolynomialFeatures(degree =2, include_bias = False)),\n",
    "                    (\"elastic\", model)\n",
    "                ])\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "    if plot==True:\n",
    "        y_predict = model.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(model).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[:, 0], y=y_predict, hue=X_train[:, 4], palette='RdBu_r', edgecolor=None)\n",
    "        norm = plt.Normalize(X_train[:, 4].min(), X_train[:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        plt.ylim(0.001,5)\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "\n",
    "    if scores==True:\n",
    "        evaluation_scores = evaluate(model, X_train, y_train)\n",
    "        return model, evaluation_scores[0] , evaluation_scores[1], r2_score(y_test, model.predict(X_test))\n",
    "    else:\n",
    "        return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "--tseB9iSXcn"
   },
   "source": [
    "# SVM Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "FsztNlA9XR8D"
   },
   "outputs": [],
   "source": [
    "#linear SVR\n",
    "from sklearn.svm import LinearSVR\n",
    "def linear_SVR(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Linear SVM regressor model. If the necessery input parameters are provided \n",
    "    it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt = LinearSVR()\n",
    "              # GridSearchCV\n",
    "        grid = {'C':np.append(np.linspace(1, 100, dtype=int),\n",
    "                              [0.001, 0.01, 0.1]), \n",
    "                'epsilon': [0.001, 0.01, 0.1, 1, 10]\n",
    "            }\n",
    "        grid_search = GridSearchCV(\n",
    "          estimator = dt, \n",
    "          scoring='r2', \n",
    "          param_grid=grid, \n",
    "          cv=5, \n",
    "          verbose=2, \n",
    "          n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        svm_reg =LinearSVR(**grid_search.best_params_)\n",
    "        svm_reg.fit(X_train, y_train)\n",
    "    else:\n",
    "        svm_reg =LinearSVR()\n",
    "        svm_reg.fit(X_train, y_train)\n",
    "    #plots\n",
    "    if plot==True:\n",
    "        y_predict =svm_reg.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(svm_reg).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[0:, 0], y=y_predict, hue=X_train[0:, 4], palette='RdBu_r', edgecolor=\"none\")\n",
    "        norm = plt.Normalize(X_train[0:, 4].min(), X_train[0:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "    #learning curves\n",
    "    if scores==True:\n",
    "        RMSE_SVR, CV_SVR = evaluate(svm_reg, X_train, y_train)\n",
    "        return svm_reg, RMSE_SVR, CV_SVR, r2_score(y_test, svm_reg.predict(X_test))\n",
    "    else:\n",
    "        return svm_reg\n",
    "\n",
    "def poly_SVR(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Kernelized SVM regressor model with a polynomial kernel. If the necessery \n",
    "    input parameters are provided it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt =SVR()\n",
    "              # GridSearchCV\n",
    "        grid = {'C': np.arange(10, 210, 10), \n",
    "                'epsilon': [0.001, 0.01, 0.1, 1, 10],\n",
    "                'kernel': ['poly'],\n",
    "                'degree': [2,3]}\n",
    "        grid_search = GridSearchCV(\n",
    "          estimator = dt, \n",
    "          scoring='r2', \n",
    "          param_grid=grid, \n",
    "          cv=3, \n",
    "          verbose=2, \n",
    "          n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        svm_poly_reg =SVR(**grid_search.best_params_)\n",
    "        svm_poly_reg.fit(X_train, y_train) \n",
    "    else:\n",
    "        svm_poly_reg = SVR(C=200, degree=2, epsilon=0.01)\n",
    "        svm_poly_reg.fit(X_train, y_train) \n",
    "    #plots\n",
    "    if plot==True:\n",
    "        y_predict =svm_poly_reg.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(svm_poly_reg).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[0:, 0], y=y_predict, palette='RdBu_r', edgecolor=\"none\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "    if scores==True:\n",
    "        #learning curves\n",
    "        RMSE_SVR, CV_SVR = evaluate(svm_poly_reg, X_train, y_train)\n",
    "        return svm_poly_reg, RMSE_SVR, CV_SVR, r2_score(y_test, svm_poly_reg.predict(X_test))\n",
    "    else:\n",
    "        return svm_poly_reg\n",
    "\n",
    "def gauss_SVR(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Kernelized SVM regressor model with aN RBF kernel. If the necessery \n",
    "    input parameters are provided it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt =SVR()\n",
    "        # GridSearchCV\n",
    "        grid = {\n",
    "          'C': [0.01, 0.1, 1, 10, 100],\n",
    "          'kernel': ['rbf'] ,\n",
    "          'gamma': [0.001, 0.01, 0.1, 1], \n",
    "          'epsilon': np.linspace(0.001, 0.1, 100)\n",
    "        }\n",
    "        grid_search = GridSearchCV(\n",
    "          estimator = dt, \n",
    "          scoring='r2', \n",
    "          param_grid=grid, \n",
    "          cv=3, \n",
    "          verbose=2, \n",
    "          n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        rbf_kernel_svr =SVR(**grid_search.best_params_)\n",
    "        rbf_kernel_svr.fit(X_train, y_train)\n",
    "    else:\n",
    "        rbf_kernel_svr =SVR(C=100, gamma=0.1, epsilon=0.01, kernel='rbf')\n",
    "        rbf_kernel_svr.fit(X_train, y_train)\n",
    "    #plots\n",
    "    if plot==True:\n",
    "        y_predict =rbf_kernel_svr.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        truevspred.set_xlim(0, 2.15)\n",
    "        truevspred.set_ylim(0.3, 1.175)\n",
    "        plt.title(type(rbf_kernel_svr).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train.flatten(), y=y_predict,palette='RdBu_r', edgecolor=\"none\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Normalised Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "    if scores==True:\n",
    "    #learning curves\n",
    "        RMSE_SVR, CV_SVR = evaluate(rbf_kernel_svr, X_train, y_train, X_test, y_test)\n",
    "        return rbf_kernel_svr, RMSE_SVR, CV_SVR, r2_score(y_test, rbf_kernel_svr.predict(X_test))\n",
    "    else:\n",
    "        return rbf_kernel_svr\n",
    "    \n",
    "def sigmoid_SVR(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Kernelized SVM regressor model with a sigmoid kernel. If the necessery \n",
    "    input parameters are provided it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt =SVR()\n",
    "        # GridSearchCV\n",
    "        grid = {\n",
    "          'C': [0.01, 0.1, 1, 10, 100],\n",
    "          'kernel': ['sigmoid'] ,\n",
    "          'gamma': [0.001, 0.01, 0.1, 1], \n",
    "          'epsilon': np.linspace(0.001, 0.1, 100)\n",
    "        }\n",
    "        grid_search = GridSearchCV(\n",
    "          estimator = dt, \n",
    "          scoring='r2', \n",
    "          param_grid=grid, \n",
    "          cv=3, \n",
    "          verbose=2, \n",
    "          n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        sigmoid_kernel_svr =SVR(**grid_search.best_params_)\n",
    "        sigmoid_kernel_svr.fit(X_train, y_train)\n",
    "    else:\n",
    "        sigmoid_kernel_svr =SVR(kernel='sigmoid')\n",
    "        sigmoid_kernel_svr.fit(X_train, y_train) \n",
    "        #plots\n",
    "    if plot==True:\n",
    "        y_predict =sigmoid_kernel_svr.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(sigmoid_kernel_svr).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[0:, 0], y=y_predict, palette='RdBu_r', edgecolor=\"none\")\n",
    "        # norm = plt.Normalize(X_train[0:, 4].min(), X_train[0:, 4].max())\n",
    "        # sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        # mr.get_legend().remove()\n",
    "        # mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "    if scores==True:\n",
    "        #learning curves\n",
    "        RMSE_SVR, CV_SVR = evaluate(sigmoid_kernel_svr, X_train, y_train)\n",
    "        return sigmoid_kernel_svr, RMSE_SVR, CV_SVR, r2_score(y_test, sigmoid_kernel_svr.predict(X_test))\n",
    "    else:\n",
    "        return sigmoid_kernel_svr\n",
    "\n",
    "def linear_SVR(dataset, fit=False, scores=False, plot=False):\n",
    "    '''\n",
    "    Kernelized SVM regressor model with a linear kernel. If the necessery \n",
    "    input parameters are provided it is able to optimize the model using GridSeachCV.\n",
    "    ---------------------------------------\n",
    "    INPUTS: dataset = pandas.DataFrame containig the OEC data.\n",
    "            fit = boolean, Default==False, variable dictating \n",
    "        if the model will do hyperparameter optimization for training\n",
    "            scores = boolean, Default==False, variable dictating \n",
    "        if functino will return the evalution score and plot the\n",
    "        learing curves of the model.\n",
    "            plot = boolean, Default==False, variable dictating\n",
    "        if the function will create the True-Predicted Radius plots\n",
    "        and the Mass-Radius-Eq.Temp. plots\n",
    "    OUTPUTS: model = Sklearn estimator object\n",
    "             scores = tuple containing the RMSE and cv scores\n",
    "             r2_score = sklearn.metrics.r2_score function\n",
    "        that calculates the R2 score of the model on the\n",
    "        test set\n",
    "             mean_squared_errot = sklearn.metrics.mean_square_error\n",
    "        function tha calculates the RMSE of the model on the\n",
    "        test set\n",
    "    ---------------------------------------\n",
    "    '''\n",
    "    X_train, y_train, X_test, y_test = split(dataset)\n",
    "    scaler = StandardScaler(with_mean=False)\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    if fit==True:\n",
    "        dt =SVR()\n",
    "              # GridSearchCV\n",
    "        grid = {'C':np.arange(0.1,10),'kernel':['linear'] , 'epsilon':np.arange(0.01,0.1,0.01)\n",
    "            }\n",
    "        grid_search = GridSearchCV(\n",
    "          estimator = dt, \n",
    "          scoring='r2', \n",
    "          param_grid=grid, \n",
    "          cv=3, \n",
    "          verbose=2, \n",
    "          n_jobs=-1)\n",
    "        grid_search.fit(X_train, y_train)\n",
    "        linear_kernel_svr =SVR(**grid_search.best_params_)\n",
    "        linear_kernel_svr.fit(X_train, y_train)\n",
    "    else:\n",
    "        linear_kernel_svr = SVR(kernel='linear')\n",
    "        linear_kernel_svr.fit(X_train, y_train)\n",
    "    if plot==True:\n",
    "        #plots\n",
    "        y_predict =linear_kernel_svr.predict(X_train)\n",
    "        truevspred = sns.regplot(x=y_train, y=y_predict, scatter_kws={\"color\": \"b\", \"alpha\": 0.75}, line_kws={\"color\": \"r\"})\n",
    "        truevspred.set(xlabel=r\"True Radius ($R_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.title(type(linear_kernel_svr).__name__)\n",
    "        plt.show()\n",
    "        mr = sns.scatterplot(x=X_train[0:, 0], y=y_predict, hue=X_train[0:, 4], palette='RdBu_r', edgecolor=\"none\")\n",
    "        norm = plt.Normalize(X_train[0:, 4].min(), X_train[0:, 4].max())\n",
    "        sm = plt.cm.ScalarMappable(cmap='RdBu_r', norm=norm)\n",
    "        mr.get_legend().remove()\n",
    "        mr.figure.colorbar(sm).set_label(\"Equilibrium Temperature (K)\")\n",
    "        mr.set(xscale=\"log\", yscale=\"log\")\n",
    "        mr.set(xlabel=r\"Mass ($M_{Jpt}$)\", ylabel=r\"Predicted Radius ($R_{Jpt}$)\")\n",
    "        plt.show()\n",
    "    if scores==True:\n",
    "        #learning curves\n",
    "        RMSE_SVR, CV_SVR = evaluate(linear_kernel_svr, X_train, y_train)\n",
    "        return linear_kernel_svr, RMSE_SVR, CV_SVR, r2_score(y_test, linear_kernel_svr.predict(X_test))\n",
    "    else:\n",
    "        return linear_kernel_svr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The models can be tested here by calling them with their respective function calls and setting any necessery arguments to \"`True`\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "ap5QlnBt-UT2"
   },
   "outputs": [],
   "source": [
    "# This cell is necessary for loading the correct\n",
    "# dataframes. Variable names can be changed.\n",
    "\n",
    "df = fetch_OEC_data()\n",
    "prepared_df = prepare_data(df)\n",
    "prepared_df_mass = prepare_data_mass_only(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of using the random forest is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 300 candidates, totalling 900 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 12 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  17 tasks      | elapsed:    0.8s\n",
      "[Parallel(n_jobs=-1)]: Done 138 tasks      | elapsed:    3.9s\n",
      "[Parallel(n_jobs=-1)]: Done 341 tasks      | elapsed:    8.5s\n",
      "[Parallel(n_jobs=-1)]: Done 624 tasks      | elapsed:   15.4s\n",
      "[Parallel(n_jobs=-1)]: Done 900 out of 900 | elapsed:   22.6s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 12 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 300 candidates, totalling 900 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done  17 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=-1)]: Done 432 tasks      | elapsed:    3.4s\n",
      "[Parallel(n_jobs=-1)]: Done 900 out of 900 | elapsed:    6.9s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rf, RMSE_rf_val, cv_rf, r2_rf, RMSE_rf = random_forest_regressor(prepared_df, fit=True, scores=True, plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method BaseEstimator.get_params of RandomForestRegressor(max_depth=72, max_features=0.7000000000000001,\n",
       "                      min_samples_split=9, n_estimators=117, random_state=1337)>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf.get_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set RMSE: 0.11831678965173976\n",
      "CV score: [0.72741087 0.83763961 0.85096202 0.85267119 0.85787955 0.86703195\n",
      " 0.86923956 0.86839664]\n",
      "Test set R2 score: 0.8558678741688177\n",
      "Test set RMSE: 0.17862830252004075\n"
     ]
    }
   ],
   "source": [
    "printScores(RMSE_rf_val, cv_rf, r2_rf, RMSE_rf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "U6vFlG_qc_5u",
    "HPrY0JDbdDmV",
    "ene00xcbdHgq"
   ],
   "name": "project_convolutional.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}