diff --git a/NON IITK/Assignments/Assignment 2/Avantika_Chauhan_IITBHU.ipynb b/NON IITK/Assignments/Assignment 2/Avantika_Chauhan_IITBHU.ipynb new file mode 100644 index 00000000..b10d6b83 --- /dev/null +++ b/NON IITK/Assignments/Assignment 2/Avantika_Chauhan_IITBHU.ipynb @@ -0,0 +1,803 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LinearRegression, Ridge, Lasso\n", + "from sklearn.metrics import mean_squared_error, r2_score" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " X1 X2 X3 X4 X5 X6 X7 X8 Y1 Y2\n", + "0 0.98 514.5 294.0 110.25 7.0 2 0.0 0 15.55 21.33\n", + "1 0.98 514.5 294.0 110.25 7.0 3 0.0 0 15.55 21.33\n", + "2 0.98 514.5 294.0 110.25 7.0 4 0.0 0 15.55 21.33\n", + "3 0.98 514.5 294.0 110.25 7.0 5 0.0 0 15.55 21.33\n", + "4 0.90 563.5 318.5 122.50 7.0 2 0.0 0 20.84 28.28\n", + "\n", + "RangeIndex: 768 entries, 0 to 767\n", + "Data columns (total 10 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 X1 768 non-null float64\n", + " 1 X2 768 non-null float64\n", + " 2 X3 768 non-null float64\n", + " 3 X4 768 non-null float64\n", + " 4 X5 768 non-null float64\n", + " 5 X6 768 non-null int64 \n", + " 6 X7 768 non-null float64\n", + " 7 X8 768 non-null int64 \n", + " 8 Y1 768 non-null float64\n", + " 9 Y2 768 non-null float64\n", + "dtypes: float64(8), int64(2)\n", + "memory usage: 60.1 KB\n", + "None\n", + " X1 X2 X3 X4 X5 X6 \\\n", + "count 768.000000 768.000000 768.000000 768.000000 768.00000 768.000000 \n", + "mean 0.764167 671.708333 318.500000 176.604167 5.25000 3.500000 \n", + "std 0.105777 88.086116 43.626481 45.165950 1.75114 1.118763 \n", + "min 0.620000 514.500000 245.000000 110.250000 3.50000 2.000000 \n", + "25% 0.682500 606.375000 294.000000 140.875000 3.50000 2.750000 \n", + "50% 0.750000 673.750000 318.500000 183.750000 5.25000 3.500000 \n", + "75% 0.830000 741.125000 343.000000 220.500000 7.00000 4.250000 \n", + "max 0.980000 808.500000 416.500000 220.500000 7.00000 5.000000 \n", + "\n", + " X7 X8 Y1 Y2 \n", + "count 768.000000 768.00000 768.000000 768.000000 \n", + "mean 0.234375 2.81250 22.307195 24.587760 \n", + "std 0.133221 1.55096 10.090204 9.513306 \n", + "min 0.000000 0.00000 6.010000 10.900000 \n", + "25% 0.100000 1.75000 12.992500 15.620000 \n", + "50% 0.250000 3.00000 18.950000 22.080000 \n", + "75% 0.400000 4.00000 31.667500 33.132500 \n", + "max 0.400000 5.00000 43.100000 48.030000 \n" + ] + } + ], + "source": [ + "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx\"\n", + "data = pd.read_excel(url)\n", + "\n", + "# Inspect first few rows\n", + "print(data.head())\n", + "print(data.info()) # Check for missing values\n", + "print(data.describe()) # Get statistics" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "notebookRunGroups": { + "groupValue": "1" + } + }, + "source": [ + "1- Handle Missing Values and Correlation:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Missing Values:\n", + " X1 0\n", + "X2 0\n", + "X3 0\n", + "X4 0\n", + "X5 0\n", + "X6 0\n", + "X7 0\n", + "X8 0\n", + "Y1 0\n", + "Y2 0\n", + "dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Missing Values:\\n\", data.isnull().sum())\n", + "\n", + "# If any missing values exist, fill them (e.g., mean imputation)\n", + "data = data.fillna(data.mean())\n", + "\n", + "# Correlation matrix\n", + "plt.figure(figsize=(10, 8))\n", + "sns.heatmap(data.corr(), annot=True, cmap=\"coolwarm\")\n", + "plt.title(\"Correlation Matrix\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2-Energy Efficiency Dataset into an 80:20 ratio for training and testing.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset Preview:\n", + " X1 X2 X3 X4 X5 X6 X7 X8 Y1 Y2\n", + "0 0.98 514.5 294.0 110.25 7.0 2 0.0 0 15.55 21.33\n", + "1 0.98 514.5 294.0 110.25 7.0 3 0.0 0 15.55 21.33\n", + "2 0.98 514.5 294.0 110.25 7.0 4 0.0 0 15.55 21.33\n", + "3 0.98 514.5 294.0 110.25 7.0 5 0.0 0 15.55 21.33\n", + "4 0.90 563.5 318.5 122.50 7.0 2 0.0 0 20.84 28.28\n", + "Training Data Shape: (614, 8)\n", + "Testing Data Shape: (154, 8)\n", + "Number of training samples: 614\n", + "Number of testing samples: 154\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split\n", + "dataset_url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx\"\n", + "df = pd.read_excel(dataset_url)\n", + "print(\"Dataset Preview:\")\n", + "print(df.head())\n", + "X = df.iloc[:, :-2] \n", + "y = df['Y1'] \n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "print(\"Training Data Shape:\", X_train.shape)\n", + "print(\"Testing Data Shape:\", X_test.shape)\n", + "print(f\"Number of training samples: {X_train.shape[0]}\")\n", + "print(f\"Number of testing samples: {X_test.shape[0]}\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3-Train a multivairate linear regression model from scratch using numpy,pandas ,matplotlib." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LinearRegression, Ridge, Lasso\n", + "from sklearn.metrics import mean_squared_error, r2_score" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset Sample:\n", + " X1 X2 X3 X4 X5 X6 X7 X8 Y1 Y2\n", + "0 0.98 514.5 294.0 110.25 7.0 2 0.0 0 15.55 21.33\n", + "1 0.98 514.5 294.0 110.25 7.0 3 0.0 0 15.55 21.33\n", + "2 0.98 514.5 294.0 110.25 7.0 4 0.0 0 15.55 21.33\n", + "3 0.98 514.5 294.0 110.25 7.0 5 0.0 0 15.55 21.33\n", + "4 0.90 563.5 318.5 122.50 7.0 2 0.0 0 20.84 28.28\n", + "Training and Testing Sets:\n", + "X_train shape: (614, 8)\n", + "X_test shape: (154, 8)\n", + "Weights (from scratch):\n", + "[-2.24050721e+14 1.45935912e+14 1.55091748e+11 1.24984647e+10\n", + " 2.75030437e+10 5.23609528e+00 -3.15918688e-02 2.02860108e+01\n", + " 2.13458715e-01]\n", + "Manual Linear Regression Results:\n", + "Mean Squared Error (MSE): 4.680725826662243e+24\n", + "R2 Score: -4.490662605721778e+22\n" + ] + } + ], + "source": [ + "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx\"\n", + "df = pd.read_excel(url)\n", + "print(\"Dataset Sample:\")\n", + "print(df.head())\n", + "features = ['X1', 'X2', 'X3', 'X4', 'X5', 'X6', 'X7', 'X8'] \n", + "target = 'Y1' \n", + "X = df[features]\n", + "y = df[target]\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "print(\"Training and Testing Sets:\")\n", + "print(\"X_train shape:\", X_train.shape)\n", + "print(\"X_test shape:\", X_test.shape)\n", + "def linear_regression_scratch(X, y):\n", + " X_b = np.c_[np.ones((X.shape[0], 1)), X]\n", + " \n", + " weights = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y\n", + " return weights\n", + "\n", + "weights = linear_regression_scratch(X_train, y_train)\n", + "\n", + "print(\"Weights (from scratch):\")\n", + "print(weights)\n", + "def predict_scratch(X, weights):\n", + " X_b = np.c_[np.ones((X.shape[0], 1)), X]\n", + " return X_b @ weights\n", + "\n", + "# Predict on the test set\n", + "y_pred_scratch = predict_scratch(X_test, weights)\n", + "\n", + "# Calculate Mean Squared Error and R2 Score\n", + "mse_scratch = mean_squared_error(y_test, y_pred_scratch)\n", + "r2_scratch = r2_score(y_test, y_pred_scratch)\n", + "\n", + "print(\"Manual Linear Regression Results:\")\n", + "print(\"Mean Squared Error (MSE):\", mse_scratch)\n", + "print(\"R2 Score:\", r2_scratch)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sklearn Linear Regression Results:\n", + "Mean Squared Error (MSE): 9.1591333894591\n", + "R2 Score: 0.9121277781779598\n" + ] + } + ], + "source": [ + "lr_model = LinearRegression()\n", + "lr_model.fit(X_train, y_train)\n", + "\n", + "y_pred_lr = lr_model.predict(X_test)\n", + "\n", + "# Calculate metrics\n", + "mse_lr = mean_squared_error(y_test, y_pred_lr)\n", + "r2_lr = r2_score(y_test, y_pred_lr)\n", + "\n", + "print(\"Sklearn Linear Regression Results:\")\n", + "print(\"Mean Squared Error (MSE):\", mse_lr)\n", + "print(\"R2 Score:\", r2_lr)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ridge Regression Results:\n", + "Mean Squared Error (MSE): 9.653457869919276\n", + "R2 Score: 0.9073852563091275\n" + ] + } + ], + "source": [ + "ridge_model = Ridge(alpha=1.0) # alpha is the regularization strength\n", + "ridge_model.fit(X_train, y_train)\n", + "\n", + "# Predict on the test set\n", + "y_pred_ridge = ridge_model.predict(X_test)\n", + "\n", + "# Calculate metrics\n", + "mse_ridge = mean_squared_error(y_test, y_pred_ridge)\n", + "r2_ridge = r2_score(y_test, y_pred_ridge)\n", + "\n", + "print(\"Ridge Regression Results:\")\n", + "print(\"Mean Squared Error (MSE):\", mse_ridge)\n", + "print(\"R2 Score:\", r2_ridge)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lasso Regression Results:\n", + "Mean Squared Error (MSE): 10.08905322937284\n", + "R2 Score: 0.9032061783960788\n" + ] + } + ], + "source": [ + "lasso_model = Lasso(alpha=0.1) # alpha is the regularization strength\n", + "lasso_model.fit(X_train, y_train)\n", + "\n", + "# Predict on the test set\n", + "y_pred_lasso = lasso_model.predict(X_test)\n", + "\n", + "# Calculate metrics\n", + "mse_lasso = mean_squared_error(y_test, y_pred_lasso)\n", + "r2_lasso = r2_score(y_test, y_pred_lasso)\n", + "\n", + "print(\"Lasso Regression Results:\")\n", + "print(\"Mean Squared Error (MSE):\", mse_lasso)\n", + "print(\"R2 Score:\", r2_lasso)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Model Comparison:\n", + "Manual Linear Regression - MSE: 4680725826662242824749056.0000, R2: -44906626057217784152064.0000\n", + "Sklearn Linear Regression - MSE: 9.1591, R2: 0.9121\n", + "Ridge Regression - MSE: 9.6535, R2: 0.9074\n", + "Lasso Regression - MSE: 10.0891, R2: 0.9032\n" + ] + } + ], + "source": [ + "print(\"\\nModel Comparison:\")\n", + "print(f\"Manual Linear Regression - MSE: {mse_scratch:.4f}, R2: {r2_scratch:.4f}\")\n", + "print(f\"Sklearn Linear Regression - MSE: {mse_lr:.4f}, R2: {r2_lr:.4f}\")\n", + "print(f\"Ridge Regression - MSE: {mse_ridge:.4f}, R2: {r2_ridge:.4f}\")\n", + "print(f\"Lasso Regression - MSE: {mse_lasso:.4f}, R2: {r2_lasso:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 6))\n", + "\n", + "plt.scatter(y_test, y_pred_lr, label='Linear Regression', alpha=0.7)\n", + "plt.scatter(y_test, y_pred_ridge, label='Ridge Regression', alpha=0.7)\n", + "plt.scatter(y_test, y_pred_lasso, label='Lasso Regression', alpha=0.7)\n", + "plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')\n", + "\n", + "plt.xlabel(\"Actual Heating Load\")\n", + "plt.ylabel(\"Predicted Heating Load\")\n", + "plt.title(\"Actual vs Predicted Heating Load\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4-Energy Efficiency Datase.comparing actual and sklearn graph" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset Preview:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X1X2X3X4X5X6X7X8Y1Y2
00.98514.5294.0110.257.020.0015.5521.33
10.98514.5294.0110.257.030.0015.5521.33
20.98514.5294.0110.257.040.0015.5521.33
30.98514.5294.0110.257.050.0015.5521.33
40.90563.5318.5122.507.020.0020.8428.28
\n", + "
" + ], + "text/plain": [ + " X1 X2 X3 X4 X5 X6 X7 X8 Y1 Y2\n", + "0 0.98 514.5 294.0 110.25 7.0 2 0.0 0 15.55 21.33\n", + "1 0.98 514.5 294.0 110.25 7.0 3 0.0 0 15.55 21.33\n", + "2 0.98 514.5 294.0 110.25 7.0 4 0.0 0 15.55 21.33\n", + "3 0.98 514.5 294.0 110.25 7.0 5 0.0 0 15.55 21.33\n", + "4 0.90 563.5 318.5 122.50 7.0 2 0.0 0 20.84 28.28" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd \n", + "import numpy as np \n", + "import matplotlib.pyplot as plt \n", + "import seaborn as sns \n", + "from sklearn.model_selection import train_test_split \n", + "from sklearn.linear_model import LinearRegression \n", + "from sklearn.metrics import mean_squared_error, r2_score \n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx\"\n", + "data = pd.read_excel(url)\n", + "print(\"Dataset Preview:\")\n", + "data.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset Information:\n", + "\n", + "RangeIndex: 768 entries, 0 to 767\n", + "Data columns (total 10 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Relative_Compactness 768 non-null float64\n", + " 1 Surface_Area 768 non-null float64\n", + " 2 Wall_Area 768 non-null float64\n", + " 3 Roof_Area 768 non-null float64\n", + " 4 Overall_Height 768 non-null float64\n", + " 5 Orientation 768 non-null int64 \n", + " 6 Glazing_Area 768 non-null float64\n", + " 7 Glazing_Area_Distribution 768 non-null int64 \n", + " 8 Heating_Load 768 non-null float64\n", + " 9 Cooling_Load 768 non-null float64\n", + "dtypes: float64(8), int64(2)\n", + "memory usage: 60.1 KB\n", + "\n", + "Summary Statistics:\n", + "Number of samples: 768, Number of features: 8\n", + "Training set size: (614, 8)\n", + "Testing set size: (154, 8)\n" + ] + } + ], + "source": [ + "data.columns = ['Relative_Compactness', 'Surface_Area', 'Wall_Area', 'Roof_Area',\n", + " 'Overall_Height', 'Orientation', 'Glazing_Area', \n", + " 'Glazing_Area_Distribution', 'Heating_Load', 'Cooling_Load']\n", + "\n", + "print(\"\\nDataset Information:\")\n", + "data.info()\n", + "print(\"\\nSummary Statistics:\")\n", + "data.describe()\n", + "X = data[['Relative_Compactness', 'Surface_Area', 'Wall_Area', 'Roof_Area',\n", + " 'Overall_Height', 'Orientation', 'Glazing_Area', 'Glazing_Area_Distribution']]\n", + "\n", + "y = data['Heating_Load'] \n", + "\n", + "\n", + "print(f\"Number of samples: {X.shape[0]}, Number of features: {X.shape[1]}\")\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "print(\"Training set size:\", X_train.shape)\n", + "print(\"Testing set size:\", X_test.shape)\n", + "class ManualLinearRegression:\n", + " def __init__(self):\n", + " self.coefficients = None\n", + " self.intercept = None\n", + "\n", + " def fit(self, X, y):\n", + " X = np.c_[np.ones(X.shape[0]), X] \n", + " theta = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)\n", + " self.intercept = theta[0]\n", + " self.coefficients = theta[1:]\n", + "\n", + " def predict(self, X):\n", + " X = np.c_[np.ones(X.shape[0]), X]\n", + " return X.dot(np.r_[self.intercept, self.coefficients])\n", + "\n", + "# Train manual model\n", + "manual_model = ManualLinearRegression()\n", + "manual_model.fit(X_train, y_train)\n", + "\n", + "# Predictions\n", + "y_pred_manual = manual_model.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Manual Linear Regression Performance:\n", + "R² Score: -44906626057217784152064.0000\n", + "Mean Squared Error (MSE): 4680725826662242824749056.0000\n", + "Root Mean Squared Error (RMSE): 2163498515521.1553\n", + "\n", + "Sklearn Linear Regression Performance:\n", + "R² Score: 0.9121\n", + "Mean Squared Error (MSE): 9.1591\n", + "Root Mean Squared Error (RMSE): 3.0264\n", + "\n" + ] + } + ], + "source": [ + "sklearn_model = LinearRegression()\n", + "sklearn_model.fit(X_train, y_train)\n", + "y_pred_sklearn = sklearn_model.predict(X_test)\n", + "from math import sqrt\n", + "\n", + "def evaluate_model(y_true, y_pred, model_name):\n", + " r2 = r2_score(y_true, y_pred)\n", + " mse = mean_squared_error(y_true, y_pred)\n", + " rmse = sqrt(mse)\n", + " print(f\"{model_name} Performance:\")\n", + " print(f\"R² Score: {r2:.4f}\")\n", + " print(f\"Mean Squared Error (MSE): {mse:.4f}\")\n", + " print(f\"Root Mean Squared Error (RMSE): {rmse:.4f}\")\n", + " print()\n", + "\n", + "# Evaluate Manual Model\n", + "evaluate_model(y_test, y_pred_manual, \"Manual Linear Regression\")\n", + "\n", + "# Evaluate Sklearn Model\n", + "evaluate_model(y_test, y_pred_sklearn, \"Sklearn Linear Regression\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 6))\n", + "\n", + "# Manual Model\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(y_test, y_pred_manual, color='blue', alpha=0.7)\n", + "plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--', lw=2)\n", + "plt.xlabel(\"Actual Heating Load\")\n", + "plt.ylabel(\"Predicted Heating Load\")\n", + "plt.title(\"Manual Model: Predicted vs Actual\")\n", + "\n", + "# Sklearn Model\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(y_test, y_pred_sklearn, color='green', alpha=0.7)\n", + "plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--', lw=2)\n", + "plt.xlabel(\"Actual Heating Load\")\n", + "plt.ylabel(\"Predicted Heating Load\")\n", + "plt.title(\"Sklearn Model: Predicted vs Actual\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5- Energy Efficiency Improvement Suggestions" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature Importance (from Sklearn Linear Regression):\n", + " Feature Coefficient\n", + "1 Surface_Area 1.103078e+11\n", + "6 Glazing_Area 2.014144e+01\n", + "4 Overall_Height 4.120392e+00\n", + "7 Glazing_Area_Distribution 2.113307e-01\n", + "5 Orientation -3.265578e-02\n", + "0 Relative_Compactness -6.209089e+01\n", + "2 Wall_Area -1.103078e+11\n", + "3 Roof_Area -2.206156e+11\n" + ] + } + ], + "source": [ + "coefficients = pd.DataFrame({\n", + " 'Feature': X.columns,\n", + " 'Coefficient': sklearn_model.coef_\n", + "}).sort_values(by='Coefficient', ascending=False)\n", + "\n", + "print(\"Feature Importance (from Sklearn Linear Regression):\")\n", + "print(coefficients)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}