{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":8552606,"sourceType":"datasetVersion","datasetId":4965286}],"dockerImageVersionId":30732,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"Support Vector Machines (SVM) can be adapted for **regression tasks**, referred to as **Support Vector Regression (SVR)**. SVR operates by finding a function that approximates the relationship between input features and the target variable, with a tolerance for errors defined by a margin. The goal is to minimize the deviation from the true values while controlling the complexity of the model through regularization parameters. SVR is effective in **high-dimensional** spaces and is **robust to overfitting**, making it suitable for various regression problems.","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"}},{"cell_type":"markdown","source":"#### Linear SVR\nLinear SVM for regression, often referred to as **Linear SVR**, uses a **linear kernel** to model the relationship between features and the target variable. It aims to fit the best possible straight line (or hyperplane in higher dimensions) within a defined margin of tolerance. Linear SVR is **computationally efficient** and works well when the data is linearly separable or when the relationship between the features and the target can be approximated by a linear function. It is particularly useful for large datasets due to its **simplicity** and **speed**.    \n\n<img src=\"attachment:e27249d7-76cc-4121-b0f6-8b1cd7760503.png\" width=\"400\">","metadata":{},"attachments":{"e27249d7-76cc-4121-b0f6-8b1cd7760503.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"### Read the Dataset","metadata":{}},{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\n\nX_data = pd.read_csv('/kaggle/input/house-price-ready-to-modeling/X_HousePrice.csv')\nX_data = X_data.set_index(['Unnamed: 0', 'Unnamed: 1'])\nX_data.info()\n\nX_train = X_data.loc['train']\nX_test = X_data.loc['test']\n\ny_data = pd.read_csv('/kaggle/input/house-price-ready-to-modeling/y_HousePrice.csv')\ny_data = y_data.set_index(['Unnamed: 0', 'Id'])\ny_data.info()\n\ny_train = y_data.loc['train']\ny_test = y_data.loc['test']\n\ny_train_log = np.log(y_train.copy()).squeeze()\ny_test_log = np.log(y_test.copy()).squeeze()","metadata":{"execution":{"iopub.status.busy":"2024-07-05T20:57:22.319531Z","iopub.execute_input":"2024-07-05T20:57:22.320494Z","iopub.status.idle":"2024-07-05T20:57:22.845316Z","shell.execute_reply.started":"2024-07-05T20:57:22.320444Z","shell.execute_reply":"2024-07-05T20:57:22.844015Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"<class 'pandas.core.frame.DataFrame'>\nMultiIndex: 1439 entries, ('train', 0) to ('test', 437)\nData columns (total 42 columns):\n #   Column                         Non-Null Count  Dtype  \n---  ------                         --------------  -----  \n 0   num__LotFrontage               1439 non-null   float64\n 1   num__LotArea                   1439 non-null   float64\n 2   num__OverallQual               1439 non-null   float64\n 3   num__OverallCond               1439 non-null   float64\n 4   num__BsmtUnfSF                 1439 non-null   float64\n 5   num__TotalBsmtSF               1439 non-null   float64\n 6   num__1stFlrSF                  1439 non-null   float64\n 7   num__GrLivArea                 1439 non-null   float64\n 8   num__BsmtFullBath              1439 non-null   float64\n 9   num__HalfBath                  1439 non-null   float64\n 10  num__TotRmsAbvGrd              1439 non-null   float64\n 11  num__Fireplaces                1439 non-null   float64\n 12  num__GarageCars                1439 non-null   float64\n 13  num__MoSold                    1439 non-null   float64\n 14  num__AgeBuilt                  1439 non-null   float64\n 15  num__AgeRemodAdd               1439 non-null   float64\n 16  num__AgeGarageBlt              1439 non-null   float64\n 17  num__AgeSold                   1439 non-null   float64\n 18  nom__MSZoning_RM               1439 non-null   float64\n 19  nom__LotShape_Reg              1439 non-null   float64\n 20  nom__LandContour_Not Lvl       1439 non-null   float64\n 21  nom__LandSlope_Not Gtl         1439 non-null   float64\n 22  nom__Neighborhood_CollgCr      1439 non-null   float64\n 23  nom__Neighborhood_Sawyer       1439 non-null   float64\n 24  nom__RoofStyle_Not Gable       1439 non-null   float64\n 25  nom__Exterior2nd_Stucco        1439 non-null   float64\n 26  nom__GarageType_Attchd         1439 non-null   float64\n 27  nom__GarageType_Basment        1439 non-null   float64\n 28  nom__Fence_non-existent        1439 non-null   float64\n 29  nom__SaleCondition_Not Normal  1439 non-null   float64\n 30  ord__MSSubClass                1439 non-null   float64\n 31  ord__ExterQual                 1439 non-null   float64\n 32  ord__BsmtQual                  1439 non-null   float64\n 33  ord__BsmtExposure              1439 non-null   float64\n 34  ord__BsmtFinType1              1439 non-null   float64\n 35  ord__BsmtFinSF1                1439 non-null   float64\n 36  ord__BsmtFinType2              1439 non-null   float64\n 37  ord__KitchenQual               1439 non-null   float64\n 38  ord__FireplaceQu               1439 non-null   float64\n 39  ord__GarageArea                1439 non-null   float64\n 40  ord__GarageCond                1439 non-null   float64\n 41  ord__OpenPorchSF               1439 non-null   float64\ndtypes: float64(42)\nmemory usage: 516.7+ KB\n<class 'pandas.core.frame.DataFrame'>\nMultiIndex: 1439 entries, ('train', 708) to ('test', 1121)\nData columns (total 1 columns):\n #   Column     Non-Null Count  Dtype\n---  ------     --------------  -----\n 0   SalePrice  1439 non-null   int64\ndtypes: int64(1)\nmemory usage: 59.2+ KB\n","output_type":"stream"}]},{"cell_type":"code","source":"!pip install --upgrade scikit-learn","metadata":{"execution":{"iopub.status.busy":"2024-07-05T20:47:11.844368Z","iopub.execute_input":"2024-07-05T20:47:11.845134Z","iopub.status.idle":"2024-07-05T20:47:30.520101Z","shell.execute_reply.started":"2024-07-05T20:47:11.845093Z","shell.execute_reply":"2024-07-05T20:47:30.518921Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"Requirement already satisfied: scikit-learn in /opt/conda/lib/python3.10/site-packages (1.2.2)\nCollecting scikit-learn\n  Downloading scikit_learn-1.5.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\nRequirement already satisfied: numpy>=1.19.5 in /opt/conda/lib/python3.10/site-packages (from scikit-learn) (1.26.4)\nRequirement already satisfied: scipy>=1.6.0 in /opt/conda/lib/python3.10/site-packages (from scikit-learn) (1.11.4)\nRequirement already satisfied: joblib>=1.2.0 in /opt/conda/lib/python3.10/site-packages (from scikit-learn) (1.4.2)\nRequirement already satisfied: threadpoolctl>=3.1.0 in /opt/conda/lib/python3.10/site-packages (from scikit-learn) (3.2.0)\nDownloading scikit_learn-1.5.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.4 MB)\n\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.4/13.4 MB\u001b[0m \u001b[31m79.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m:00:01\u001b[0m00:01\u001b[0m\n\u001b[?25hInstalling collected packages: scikit-learn\n  Attempting uninstall: scikit-learn\n    Found existing installation: scikit-learn 1.2.2\n    Uninstalling scikit-learn-1.2.2:\n      Successfully uninstalled scikit-learn-1.2.2\n\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\nspopt 0.6.0 requires shapely>=2.0.1, but you have shapely 1.8.5.post1 which is incompatible.\u001b[0m\u001b[31m\n\u001b[0mSuccessfully installed scikit-learn-1.5.1\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Implement the Linear SVR model","metadata":{}},{"cell_type":"markdown","source":"### LinearSVR Hyperparameters\n\n#### Regularization Parameter\n- **`C`**: float, default=1.0\n  - Regularization parameter. The strength of the regularization is inversely proportional to `C`. Must be strictly positive.\n\n#### Loss Function\n- **`loss`**: {‘epsilon_insensitive’, ‘squared_epsilon_insensitive’}, default=’epsilon_insensitive’\n  - Specifies the loss function. The epsilon-insensitive loss (standard SVR) is the L1 loss, while the squared epsilon-insensitive loss (‘squared_epsilon_insensitive’) is the L2 loss.\n\n#### Fit Intercept\n- **`fit_intercept`**: bool, default=True\n  - Whether or not to fit an intercept. If set to True, the feature vector is extended to include an intercept term: `[x_1, ..., x_n, 1]`, where `1` corresponds to the intercept. If set to False, no intercept will be used in calculations (i.e. data is expected to be already centered).\n\n#### Random State\n- **`random_state`**: int, RandomState instance or None, default=None\n  - Controls the pseudo-random number generation for shuffling the data. Pass an int for reproducible output across multiple function calls. \n\n#### Maximum Iterations\n- **`max_iter`**: int, default=1000\n  - The maximum number of iterations to be run.\n","metadata":{}},{"cell_type":"code","source":"from sklearn.svm import LinearSVR\nfrom sklearn.metrics import r2_score, root_mean_squared_error\n\nlsvr = LinearSVR(C=1, loss='squared_epsilon_insensitive', fit_intercept=True, random_state=111, max_iter=10000000)\nlsvr.fit(X_train, y_train_log)\n\ny_pred_train = lsvr.predict(X_train)\ny_pred_test = lsvr.predict(X_test)\n\n\n# R-squared (R2) score for training set\nr2_train = r2_score(y_train_log, y_pred_train)\n\n# Root Mean Squared Error (RMSE) for training set\nrmse_train = root_mean_squared_error(y_train_log, y_pred_train)\n\n# Mean Absolute Percentage Error (MAPE) for training set\n# Avoiding division by zero\ny_train_values = y_train_log.to_numpy()\ny_train_values = y_train_values.reshape(y_train_values.shape[0])\nmape_train = np.mean(np.abs((y_train_values - y_pred_train) / np.where(y_train_values == 0, 1, y_train_values))) * 100\n\n# Correlation between predicted and real values for training set\ncorr_train = np.corrcoef(y_train_values, y_pred_train.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Training Set:\", r2_train)\nprint(\"Root Mean Squared Error (RMSE) for Training Set:\", rmse_train)\nprint(\"Mean Absolute Percentage Error (MAPE) for Training Set:\", mape_train)\nprint(\"Correlation between predicted and real values for Training Set:\", corr_train)\n\nprint(\"#\"*100)\n#------------------------------------------------------------------------\n\n# R-squared (R2) score\nr2 = r2_score(y_test_log, y_pred_test)\n\n# Root Mean Squared Error (RMSE)\nrmse = root_mean_squared_error(y_test_log, y_pred_test)\n\n# Mean Absolute Percentage Error (MAPE)\n# Avoiding division by zero\ny_test_values = y_test_log.to_numpy()\ny_test_values = y_test_values.reshape(y_test_values.shape[0])\nmape = np.mean(np.abs((y_test_values - y_pred_test) / np.where(y_test_values == 0, 1, y_test_values))) * 100\n\n# Correlation between predicted and real values\ncorr = np.corrcoef(y_test_values, y_pred_test.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Test Set:\", r2)\nprint(\"Root Mean Squared Error (RMSE) for Test Set:\", rmse)\nprint(\"Mean Absolute Percentage Error (MAPE) for Test Set:\", mape)\nprint(\"Correlation between predicted and real values for Test Set:\", corr)\n","metadata":{"execution":{"iopub.status.busy":"2024-07-05T20:59:13.114524Z","iopub.execute_input":"2024-07-05T20:59:13.114895Z","iopub.status.idle":"2024-07-05T20:59:13.775102Z","shell.execute_reply.started":"2024-07-05T20:59:13.114865Z","shell.execute_reply":"2024-07-05T20:59:13.771856Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"R-squared (R2) score for Training Set: 0.9118298369927895\nRoot Mean Squared Error (RMSE) for Training Set: 0.11625489524238353\nMean Absolute Percentage Error (MAPE) for Training Set: 0.711850847198359\nCorrelation between predicted and real values for Training Set: 0.9550213273072164\n####################################################################################################\nR-squared (R2) score for Test Set: 0.8734026594136182\nRoot Mean Squared Error (RMSE) for Test Set: 0.13981019250151114\nMean Absolute Percentage Error (MAPE) for Test Set: 0.8999656646696377\nCorrelation between predicted and real values for Test Set: 0.9487083349379143\n","output_type":"stream"}]},{"cell_type":"code","source":"lsvr.coef_","metadata":{"execution":{"iopub.status.busy":"2024-07-05T20:59:58.608771Z","iopub.execute_input":"2024-07-05T20:59:58.609276Z","iopub.status.idle":"2024-07-05T20:59:58.619007Z","shell.execute_reply.started":"2024-07-05T20:59:58.609244Z","shell.execute_reply":"2024-07-05T20:59:58.617727Z"},"trusted":true},"execution_count":3,"outputs":[{"execution_count":3,"output_type":"execute_result","data":{"text/plain":"array([ 0.00192729,  0.04339639,  0.09369159,  0.06431277, -0.0316098 ,\n        0.07562046,  0.00086348,  0.13519055,  0.01564601,  0.01165182,\n       -0.00983407,  0.00686374,  0.04474408, -0.00208385, -0.08333637,\n       -0.00057728, -0.02672627,  0.00946167, -0.02277424, -0.00553527,\n        0.00015223, -0.00088862, -0.00509301, -0.00523935,  0.00476514,\n        0.00296343, -0.00057666, -0.00423398, -0.00222287, -0.01232656,\n       -0.00081275,  0.0029917 , -0.00632544,  0.0114947 ,  0.01643546,\n       -0.00466217, -0.00797825,  0.01466957,  0.01565072, -0.03119716,\n        0.00745896,  0.0043493 ])"},"metadata":{}}]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.figure(figsize=(6, 4))\nplt.scatter(y_test_log, y_pred_test, color='blue', alpha=0.5)\nplt.plot([y_test_log.min(), y_test_log.max()], [y_test_log.min(), y_test_log.max()], 'k--', lw=2)  # Plot the diagonal line\nplt.xlabel('True Values')\nplt.ylabel('Predicted Values')\nplt.title('Predicted Values vs True Values')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-07-05T21:00:29.147243Z","iopub.execute_input":"2024-07-05T21:00:29.147629Z","iopub.status.idle":"2024-07-05T21:00:29.443557Z","shell.execute_reply.started":"2024-07-05T21:00:29.147601Z","shell.execute_reply":"2024-07-05T21:00:29.442223Z"},"trusted":true},"execution_count":4,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 600x400 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"markdown","source":"### Identify the Optimal Model through Hyperparameter Tuning","metadata":{}},{"cell_type":"code","source":"from sklearn.svm import LinearSVR\nfrom sklearn.metrics import r2_score, root_mean_squared_error\nfrom sklearn.model_selection import GridSearchCV\n\n# Initialize the KNeighborsRegressor\nlsvr = LinearSVR( fit_intercept=True, random_state=111, max_iter=10000000)\n\n# Set up the parameter grid\nparam_grid = {\n    'C': [0.001, 0.01, 0.1, 1, 10, 100],\n    'loss': ['epsilon_insensitive', 'squared_epsilon_insensitive']\n}\n\n\n# Create GridSearchCV object\ngrid_search = GridSearchCV(lsvr, param_grid, scoring='neg_root_mean_squared_error', cv=5)\n\n# Fit the grid search to the data\ngrid_search.fit(X_train, y_train_log)\n\n# Get the best estimator\nbest_lsvr = grid_search.best_estimator_\n\n# Get the best parameters\nbest_params = grid_search.best_params_\nprint(\"Best Parameters:\", best_params)\n","metadata":{"execution":{"iopub.status.busy":"2024-07-05T21:01:51.761054Z","iopub.execute_input":"2024-07-05T21:01:51.761501Z","iopub.status.idle":"2024-07-05T21:04:24.916843Z","shell.execute_reply.started":"2024-07-05T21:01:51.761452Z","shell.execute_reply":"2024-07-05T21:04:24.915742Z"},"trusted":true},"execution_count":5,"outputs":[{"name":"stdout","text":"Best Parameters: {'C': 100, 'loss': 'squared_epsilon_insensitive'}\n","output_type":"stream"}]},{"cell_type":"code","source":"# Train the regressor with the full training data\nbest_lsvr.fit(X_train, y_train_log)\n\n# Predict the target for the train set\ny_pred_train = best_lsvr.predict(X_train)\n\n# Predict the target for the test set\ny_pred = best_lsvr.predict(X_test)\n\n# R-squared (R2) score for training set\nr2_train = r2_score(y_train_log, y_pred_train)\n\n# Root Mean Squared Error (RMSE) for training set\nrmse_train = root_mean_squared_error(y_train_log, y_pred_train)\n\n# Mean Absolute Percentage Error (MAPE) for training set\n# Avoiding division by zero\ny_train_values = y_train_log.to_numpy()\ny_train_values = y_train_values.reshape(y_train_values.shape[0])\nmape_train = np.mean(np.abs((y_train_values - y_pred_train) / np.where(y_train_values == 0, 1, y_train_values))) * 100\n\n# Correlation between predicted and real values for training set\ncorr_train = np.corrcoef(y_train_values, y_pred_train.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Training Set:\", r2_train)\nprint(\"Root Mean Squared Error (RMSE) for Training Set:\", rmse_train)\nprint(\"Mean Absolute Percentage Error (MAPE) for Training Set:\", mape_train)\nprint(\"Correlation between predicted and real values for Training Set:\", corr_train)\n\nprint(\"#\"*100)\n#------------------------------------------------------------------------\n\n# R-squared (R2) score\nr2 = r2_score(y_test_log, y_pred)\n\n# Root Mean Squared Error (RMSE)\nrmse = root_mean_squared_error(y_test_log, y_pred)\n\n# Mean Absolute Percentage Error (MAPE)\n# Avoiding division by zero\ny_test_values = y_test_log.to_numpy()\ny_test_values = y_test_values.reshape(y_test_values.shape[0])\nmape = np.mean(np.abs((y_test_values - y_pred) / np.where(y_test_values == 0, 1, y_test_values))) * 100\n\n# Correlation between predicted and real values\ncorr = np.corrcoef(y_test_values, y_pred.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Test Set:\", r2)\nprint(\"Root Mean Squared Error (RMSE) for Test Set:\", rmse)\nprint(\"Mean Absolute Percentage Error (MAPE) for Test Set:\", mape)\nprint(\"Correlation between predicted and real values for Test Set:\", corr)","metadata":{"execution":{"iopub.status.busy":"2024-07-05T21:04:40.280036Z","iopub.execute_input":"2024-07-05T21:04:40.280421Z","iopub.status.idle":"2024-07-05T21:04:40.310772Z","shell.execute_reply.started":"2024-07-05T21:04:40.280389Z","shell.execute_reply":"2024-07-05T21:04:40.309608Z"},"trusted":true},"execution_count":6,"outputs":[{"name":"stdout","text":"R-squared (R2) score for Training Set: 0.9120655858156824\nRoot Mean Squared Error (RMSE) for Training Set: 0.1160993704115217\nMean Absolute Percentage Error (MAPE) for Training Set: 0.7064417897606079\nCorrelation between predicted and real values for Training Set: 0.9550212657415841\n####################################################################################################\nR-squared (R2) score for Test Set: 0.868724508722601\nRoot Mean Squared Error (RMSE) for Test Set: 0.1423699617958932\nMean Absolute Percentage Error (MAPE) for Test Set: 0.922495287195341\nCorrelation between predicted and real values for Test Set: 0.9486589429968638\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Non-Linear Kernel-Based SVR\nNon-linear kernel-based SVM, such as those using **polynomial**, **radial basis function** (RBF), or **sigmoid** kernels, extends the capability of SVM to capture **complex, non-linear relationships** between features and the target variable. *These kernels transform the input space into a higher-dimensional space where a linear separation is possible*. This approach allows SVM to create flexible decision boundaries, making it powerful for tasks where the relationship between features and the target is not straightforward. While more **computationally intensive**, non-linear SVR models can achieve higher accuracy in capturing intricate patterns in the data.  \n\n<img src=\"attachment:2ced5568-5308-483c-a7ac-ace06777aa93.png\" width=\"400\">","metadata":{},"attachments":{"2ced5568-5308-483c-a7ac-ace06777aa93.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"### Implement the Non-Linear SVR model","metadata":{}},{"cell_type":"markdown","source":"### SVR Hyperparameters\n\n#### Kernel\n- **`kernel`**: {‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’} or callable, default=’rbf’\n  - Specifies the kernel type to be used in the algorithm. If none is given, ‘rbf’ will be used. If a callable is given, it is used to precompute the kernel matrix.\n\n#### Degree\n- **`degree`**: int, default=3\n  - Degree of the polynomial kernel function (‘poly’). Must be non-negative. Ignored by all other kernels.\n\n#### Gamma\n- **`gamma`**: {‘scale’, ‘auto’} or float, default=’scale’\n  - Kernel coefficient for ‘rbf’, ‘poly’, and ‘sigmoid’. If `gamma='scale'` (default) is passed, then it uses `1 / (n_features * X.var())` as the value of gamma. If `‘auto’`, it uses `1 / n_features`. If float, must be non-negative. \n\n#### coef0\n- **`coef0`**: float, default=0.0\n  - Independent term in kernel function. It is only significant in ‘poly’ and ‘sigmoid’.\n\n#### Regularization Parameter\n- **`C`**: float, default=1.0\n  - Regularization parameter. The strength of the regularization is inversely proportional to `C`. Must be strictly positive. The penalty is a squared l2. For an intuitive visualization of the effects of scaling the regularization parameter `C`.\n\n#### Shrinking\n- **`shrinking`**: bool, default=True\n  - Whether to use the shrinking heuristic. \n\n#### Max Iterations\n- **`max_iter`**: int, default=-1\n  - Hard limit on iterations within solver, or -1 for no limit.\n","metadata":{}},{"cell_type":"code","source":"from sklearn.svm import SVR\nfrom sklearn.metrics import r2_score, root_mean_squared_error\n\nsvr = SVR(C=1.0, kernel='rbf', degree=3, gamma='scale', coef0=0.0, shrinking=True, max_iter=-1)\nsvr.fit(X_train, y_train_log)\n\ny_pred_train = svr.predict(X_train)\ny_pred_test = svr.predict(X_test)\n\n\n# R-squared (R2) score for training set\nr2_train = r2_score(y_train_log, y_pred_train)\n\n# Root Mean Squared Error (RMSE) for training set\nrmse_train = root_mean_squared_error(y_train_log, y_pred_train)\n\n# Mean Absolute Percentage Error (MAPE) for training set\n# Avoiding division by zero\ny_train_values = y_train_log.to_numpy()\ny_train_values = y_train_values.reshape(y_train_values.shape[0])\nmape_train = np.mean(np.abs((y_train_values - y_pred_train) / np.where(y_train_values == 0, 1, y_train_values))) * 100\n\n# Correlation between predicted and real values for training set\ncorr_train = np.corrcoef(y_train_values, y_pred_train.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Training Set:\", r2_train)\nprint(\"Root Mean Squared Error (RMSE) for Training Set:\", rmse_train)\nprint(\"Mean Absolute Percentage Error (MAPE) for Training Set:\", mape_train)\nprint(\"Correlation between predicted and real values for Training Set:\", corr_train)\n\nprint(\"#\"*100)\n#------------------------------------------------------------------------\n\n# R-squared (R2) score\nr2 = r2_score(y_test_log, y_pred_test)\n\n# Root Mean Squared Error (RMSE)\nrmse = root_mean_squared_error(y_test_log, y_pred_test)\n\n# Mean Absolute Percentage Error (MAPE)\n# Avoiding division by zero\ny_test_values = y_test_log.to_numpy()\ny_test_values = y_test_values.reshape(y_test_values.shape[0])\nmape = np.mean(np.abs((y_test_values - y_pred_test) / np.where(y_test_values == 0, 1, y_test_values))) * 100\n\n# Correlation between predicted and real values\ncorr = np.corrcoef(y_test_values, y_pred_test.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Test Set:\", r2)\nprint(\"Root Mean Squared Error (RMSE) for Test Set:\", rmse)\nprint(\"Mean Absolute Percentage Error (MAPE) for Test Set:\", mape)\nprint(\"Correlation between predicted and real values for Test Set:\", corr)","metadata":{"execution":{"iopub.status.busy":"2024-07-05T21:06:41.351237Z","iopub.execute_input":"2024-07-05T21:06:41.351854Z","iopub.status.idle":"2024-07-05T21:06:41.455837Z","shell.execute_reply.started":"2024-07-05T21:06:41.351818Z","shell.execute_reply":"2024-07-05T21:06:41.454589Z"},"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"R-squared (R2) score for Training Set: 0.9589568626700499\nRoot Mean Squared Error (RMSE) for Training Set: 0.07931780781602968\nMean Absolute Percentage Error (MAPE) for Training Set: 0.5588621874620392\nCorrelation between predicted and real values for Training Set: 0.9795576075531117\n####################################################################################################\nR-squared (R2) score for Test Set: 0.5850857720521374\nRoot Mean Squared Error (RMSE) for Test Set: 0.25310790327432076\nMean Absolute Percentage Error (MAPE) for Test Set: 1.4822125935498458\nCorrelation between predicted and real values for Test Set: 0.8774062762900077\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Identify the Optimal Model through Hyperparameter Tuning","metadata":{}},{"cell_type":"code","source":"from sklearn.svm import SVR\nfrom sklearn.metrics import r2_score, root_mean_squared_error\nfrom sklearn.model_selection import GridSearchCV\n\n# Initialize the KNeighborsRegressor\nsvr = SVR( max_iter=-1, verbose=False)\n\n# Set up the parameter grid with specific parameters for each kernel\nparam_grid = [\n    {'kernel': ['linear'], 'C': [0.001, 0.01, 0.1, 1, 10, 100]},\n    {'kernel': ['poly'], 'C': [0.001, 0.01, 0.1, 1, 10, 100], 'degree': [2, 3, 4],\n            'gamma': ['scale', 'auto'], 'coef0': [0.0, 0.1, 0.5, 1]},\n    {'kernel': ['rbf'], 'C': [0.001, 0.01, 0.1, 1, 10, 100], 'gamma': ['scale', 'auto']},\n    {'kernel': ['sigmoid'], 'C': [0.001, 0.01, 0.1, 1, 10, 100], 'gamma': ['scale', 'auto'], 'coef0': [0.0, 0.1, 0.5, 1]}\n]\n\n\n# Create GridSearchCV object\ngrid_search = GridSearchCV(svr, param_grid, scoring='neg_root_mean_squared_error', cv=5)\n\n# Fit the grid search to the data\ngrid_search.fit(X_train, y_train_log)\n\n# Get the best estimator\nbest_svr = grid_search.best_estimator_\n\n# Get the best parameters\nbest_params = grid_search.best_params_\nprint(\"Best Parameters:\", best_params)","metadata":{"execution":{"iopub.status.busy":"2024-07-05T21:07:55.910375Z","iopub.execute_input":"2024-07-05T21:07:55.910953Z","iopub.status.idle":"2024-07-05T21:12:32.171064Z","shell.execute_reply.started":"2024-07-05T21:07:55.910913Z","shell.execute_reply":"2024-07-05T21:12:32.169725Z"},"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"Best Parameters: {'C': 0.1, 'coef0': 1, 'degree': 2, 'gamma': 'auto', 'kernel': 'poly'}\n","output_type":"stream"}]},{"cell_type":"code","source":"# Train the regressor with the full training data\nbest_svr.fit(X_train, y_train_log)\n\n# Predict the target for the train set\ny_pred_train = best_svr.predict(X_train)\n\n# Predict the target for the test set\ny_pred = best_svr.predict(X_test)\n\n# R-squared (R2) score for training set\nr2_train = r2_score(y_train_log, y_pred_train)\n\n# Root Mean Squared Error (RMSE) for training set\nrmse_train = root_mean_squared_error(y_train_log, y_pred_train)\n\n# Mean Absolute Percentage Error (MAPE) for training set\n# Avoiding division by zero\ny_train_values = y_train_log.to_numpy()\ny_train_values = y_train_values.reshape(y_train_values.shape[0])\nmape_train = np.mean(np.abs((y_train_values - y_pred_train) / np.where(y_train_values == 0, 1, y_train_values))) * 100\n\n# Correlation between predicted and real values for training set\ncorr_train = np.corrcoef(y_train_values, y_pred_train.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Training Set:\", r2_train)\nprint(\"Root Mean Squared Error (RMSE) for Training Set:\", rmse_train)\nprint(\"Mean Absolute Percentage Error (MAPE) for Training Set:\", mape_train)\nprint(\"Correlation between predicted and real values for Training Set:\", corr_train)\n\nprint(\"#\"*100)\n#------------------------------------------------------------------------\n\n# R-squared (R2) score\nr2 = r2_score(y_test_log, y_pred)\n\n# Root Mean Squared Error (RMSE)\nrmse = root_mean_squared_error(y_test_log, y_pred)\n\n# Mean Absolute Percentage Error (MAPE)\n# Avoiding division by zero\ny_test_values = y_test_log.to_numpy()\ny_test_values = y_test_values.reshape(y_test_values.shape[0])\nmape = np.mean(np.abs((y_test_values - y_pred) / np.where(y_test_values == 0, 1, y_test_values))) * 100\n\n# Correlation between predicted and real values\ncorr = np.corrcoef(y_test_values, y_pred.ravel())[0, 1]\n\nprint(\"R-squared (R2) score for Test Set:\", r2)\nprint(\"Root Mean Squared Error (RMSE) for Test Set:\", rmse)\nprint(\"Mean Absolute Percentage Error (MAPE) for Test Set:\", mape)\nprint(\"Correlation between predicted and real values for Test Set:\", corr)","metadata":{"execution":{"iopub.status.busy":"2024-07-05T21:13:08.513938Z","iopub.execute_input":"2024-07-05T21:13:08.514664Z","iopub.status.idle":"2024-07-05T21:13:08.590929Z","shell.execute_reply.started":"2024-07-05T21:13:08.514626Z","shell.execute_reply":"2024-07-05T21:13:08.589759Z"},"trusted":true},"execution_count":9,"outputs":[{"name":"stdout","text":"R-squared (R2) score for Training Set: 0.9368978387748893\nRoot Mean Squared Error (RMSE) for Training Set: 0.09834958784501799\nMean Absolute Percentage Error (MAPE) for Training Set: 0.61839032405138\nCorrelation between predicted and real values for Training Set: 0.9680377324152151\n####################################################################################################\nR-squared (R2) score for Test Set: 0.7345234666378357\nRoot Mean Squared Error (RMSE) for Test Set: 0.20246017660035937\nMean Absolute Percentage Error (MAPE) for Test Set: 1.4064415114627744\nCorrelation between predicted and real values for Test Set: 0.9468761567777169\n","output_type":"stream"}]}]}