Linear Regression step-by-step Guide with Explaination.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "82ac06cd",
   "metadata": {
    "papermill": {
     "duration": 0.00658,
     "end_time": "2023-10-22T17:26:48.082365",
     "exception": false,
     "start_time": "2023-10-22T17:26:48.075785",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Introduction of Linear Regression**\n",
    "\n",
    "Linear Regression is one of the cornerstone algorithms of supervised learning in the realm of Machine Learning and Statistics. Rooted in simplicity yet powerful in its applicability, Linear Regression strives to establish a linear relationship between the dependent and independent variables by finding the best fit straight line that accurately predict the output values within a range.\n",
    "\n",
    "In mathematical terms, Linear Regression aims to minimize the differences between the actual and predicted values by finding the best coefficients that multiply with the input features, thereby rendering a line that is the closest to the actual data points. Represented as:\n",
    "\n",
    "> **Y = aX + b**\n",
    "\n",
    "**where:**\n",
    "- Y is the output/dependent variable,\n",
    "- X is the input/independent variable,\n",
    "- a is the slope of the line (coefficient), and\n",
    "- b is the y-intercept.\n",
    "\n",
    "A primary advantage of Linear Regression lies in its interpretability and ease of implementation. It is extensively utilized in various domains such as finance, economics, environmental science, and many more, due to its capability to determine the significance and impact of different independent variables on the dependent variable.\n",
    "\n",
    "As we traverse through this notebook, we will delve deeper into the intricacies of Linear Regression, exploring its mathematical foundations, assumptions, and practical implementation. Together, we will unravel the nuances that make Linear Regression an essential tool in the data scientist’s arsenal, and apply this knowledge to make accurate predictions on real-world data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5685426",
   "metadata": {
    "papermill": {
     "duration": 0.004123,
     "end_time": "2023-10-22T17:26:48.091184",
     "exception": false,
     "start_time": "2023-10-22T17:26:48.087061",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 1:** Import necessary libraries\n",
    "\n",
    "* Import NumPy for numerical operations.\n",
    "* Import Matplotlib for data visualization.\n",
    "* Import train_test_split and LinearRegression from scikit-learn for dataset splitting and linear regression modeling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6af4299a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:48.101281Z",
     "iopub.status.busy": "2023-10-22T17:26:48.100887Z",
     "iopub.status.idle": "2023-10-22T17:26:49.557889Z",
     "shell.execute_reply": "2023-10-22T17:26:49.556822Z"
    },
    "papermill": {
     "duration": 1.465289,
     "end_time": "2023-10-22T17:26:49.560704",
     "exception": false,
     "start_time": "2023-10-22T17:26:48.095415",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 1: Import necessary libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34aa828e",
   "metadata": {
    "papermill": {
     "duration": 0.004506,
     "end_time": "2023-10-22T17:26:49.570274",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.565768",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 2:** Generate or load your dataset\n",
    "\n",
    "Create a synthetic dataset with random data points. Replace this step with loading your own dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab6cc0e8",
   "metadata": {
    "papermill": {
     "duration": 0.004974,
     "end_time": "2023-10-22T17:26:49.579489",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.574515",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### **Random Seed:** \n",
    "NumPy is a popular Python library for numerical computations, and it includes a sub-module called `numpy.random` that provides various functions for generating random numbers. When working with random numbers, it's often crucial to set a seed value for reproducibility, ensuring that your code produces the same random values each time it's run. The `numpy.random.seed()` function is used to set the seed for the random number generator in NumPy. Here's a step-by-step explanation of how to use it:\n",
    "\n",
    "1. **Import NumPy**:\n",
    "   Before you can use any NumPy functions, including the random number generator, you need to import the NumPy library. You can do this by adding the following line at the beginning of your Python script:\n",
    "\n",
    "   ```python\n",
    "   import numpy as np\n",
    "   ```\n",
    "\n",
    "   Here, we use the common alias \"np\" to refer to the NumPy library.\n",
    "\n",
    "2. **Set the Random Seed**:\n",
    "   To set the random seed, you need to call the `numpy.random.seed()` function. This function takes an integer value (the seed) as an argument. The seed value is the initial state for the random number generator. Here's how to set the seed to a specific integer (e.g., 42):\n",
    "\n",
    "   ```python\n",
    "   np.random.seed(42)\n",
    "   ```\n",
    "\n",
    "   By setting the seed to the same value in different runs of your code, you ensure that the random numbers generated are the same each time.\n",
    "\n",
    "3. **Generate Random Numbers**:\n",
    "   With the seed set, you can use the various random number generation functions provided by NumPy. For example, you can generate random integers, random floats, or random arrays. Here's an example of generating a random integer between 0 and 100:\n",
    "\n",
    "   ```python\n",
    "   random_int = np.random.randint(0, 101)  # Generates a random integer between 0 and 100 (inclusive).\n",
    "   ```\n",
    "\n",
    "4. **Reproducibility**:\n",
    "   The key advantage of setting the seed is reproducibility. When you run the same code with the same seed, it will produce the same random numbers. This can be immensely useful in research, testing, and debugging, where you want to ensure that the code's behavior remains consistent.\n",
    "\n",
    "5. **Changing the Seed**:\n",
    "   If you want to generate a different set of random numbers, you can simply change the seed value. For instance, setting the seed to 123 instead of 42 would yield a different sequence of random numbers:\n",
    "\n",
    "   ```python\n",
    "   np.random.seed(123)\n",
    "   ```\n",
    "\n",
    "   After changing the seed, any subsequent calls to random number generation functions will produce different values.\n",
    "\n",
    "6. **Not Setting the Seed**:\n",
    "   If you don't set the seed explicitly, NumPy will use a system-generated seed (usually based on the system time), which will result in different random values each time you run your code. This is useful when true randomness is required.\n",
    "\n",
    "``` the `numpy.random.seed()` function allows you to control the randomness in your code by setting the initial state of the random number generator. This can be crucial for reproducibility and consistency in various scientific and data analysis applications.```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b8bea0d3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:49.591119Z",
     "iopub.status.busy": "2023-10-22T17:26:49.590265Z",
     "iopub.status.idle": "2023-10-22T17:26:49.596030Z",
     "shell.execute_reply": "2023-10-22T17:26:49.594763Z"
    },
    "papermill": {
     "duration": 0.013803,
     "end_time": "2023-10-22T17:26:49.598014",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.584211",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 2: Generate or load your dataset\n",
    "# In this example, we'll create a synthetic dataset.\n",
    "# You can replace this with your own dataset.\n",
    "np.random.seed(0)\n",
    "X = 2 * np.random.rand(100, 1)\n",
    "y = 4 + 3 * X + np.random.rand(100, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e814183",
   "metadata": {
    "papermill": {
     "duration": 0.004356,
     "end_time": "2023-10-22T17:26:49.607216",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.602860",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 3:** Split the data into training and testing sets:\n",
    "\n",
    "Split the dataset into training and testing sets using the train_test_split function. In this example, 80% of the data is used for training, and 20% is used for testing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c6e62ca",
   "metadata": {
    "papermill": {
     "duration": 0.004365,
     "end_time": "2023-10-22T17:26:49.616180",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.611815",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### **Different Types Of Datasets Splitting Methods**\n",
    "\n",
    "There are several methods for splitting datasets for machine learning and data analysis. Each method serves different purposes and has its advantages and disadvantages. Here are some common dataset splitting methods, along with step-by-step explanations for each:\n",
    "\n",
    "1. **Train-Test Split (Holdout Method)**:\n",
    "   - Purpose: To create two separate sets, one for training and one for testing the model.\n",
    "   - Steps:\n",
    "     1. Randomly shuffle the dataset to ensure the data is well-distributed.\n",
    "     2. Split the data into two parts, typically with a ratio like 70-30 or 80-20, where one part is for training and the other for testing.\n",
    "     3. Train your machine learning model on the training set.\n",
    "     4. Evaluate the model's performance on the test set.\n",
    "\n",
    "2. **K-Fold Cross-Validation**:\n",
    "   - Purpose: To assess the model's performance by training and testing it on different subsets of the data.\n",
    "   - Steps:\n",
    "     1. Divide the dataset into k equal-sized folds.\n",
    "     2. For each fold (1 to k), treat it as a test set, and the remaining (k-1) folds as the training set.\n",
    "     3. Train and evaluate the model on each of the k iterations.\n",
    "     4. Calculate performance metrics (e.g., accuracy) by averaging the results from all iterations.\n",
    "\n",
    "3. **Stratified Sampling**:\n",
    "   - Purpose: To ensure that the proportion of different classes in the dataset is maintained in the train and test sets.\n",
    "   - Steps:\n",
    "     1. Identify the target variable (e.g., class labels).\n",
    "     2. Stratify the data by the target variable to create representative subsets.\n",
    "     3. Perform a train-test split on these stratified subsets to maintain class balance in both sets.\n",
    "\n",
    "4. **Time Series Split**:\n",
    "   - Purpose: For time series data, where the order of data points matters.\n",
    "   - Steps:\n",
    "     1. Sort the dataset based on the time or date variable.\n",
    "     2. Divide the data into training and testing sets such that the training set consists of past data, and the testing set contains future data.\n",
    "\n",
    "5. **Leave-One-Out Cross-Validation (LOOCV)**:\n",
    "   - Purpose: To leave out a single data point as the test set in each iteration.\n",
    "   - Steps:\n",
    "     1. For each data point in the dataset, create a training set with all other data points.\n",
    "     2. Train and test the model for each data point separately.\n",
    "     3. Calculate the performance metrics based on the predictions from each iteration.\n",
    "\n",
    "6. **Group K-Fold Cross-Validation**:\n",
    "   - Purpose: To account for groups or clusters in the data.\n",
    "   - Steps:\n",
    "     1. Identify the group or cluster variable (e.g., patient ID).\n",
    "     2. Divide the data into folds while ensuring that each fold contains all data points from a specific group.\n",
    "     3. Train and test the model using group-based cross-validation.\n",
    "\n",
    "7. **Bootstrapping**:\n",
    "   - Purpose: To create multiple subsets of the data with replacement for estimating model performance.\n",
    "   - Steps:\n",
    "     1. Randomly sample data points with replacement to create multiple bootstrap samples.\n",
    "     2. Train and evaluate the model on each bootstrap sample.\n",
    "     3. Calculate performance metrics based on the results of each sample.\n",
    "\n",
    "The choice of dataset splitting method depends on the specific problem, data characteristics, and the goal of your analysis. It's important to select an appropriate method to ensure reliable model evaluation and generalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "db551130",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:49.626666Z",
     "iopub.status.busy": "2023-10-22T17:26:49.626326Z",
     "iopub.status.idle": "2023-10-22T17:26:49.634451Z",
     "shell.execute_reply": "2023-10-22T17:26:49.633377Z"
    },
    "papermill": {
     "duration": 0.016079,
     "end_time": "2023-10-22T17:26:49.636709",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.620630",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 3: Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f87047c5",
   "metadata": {
    "papermill": {
     "duration": 0.004301,
     "end_time": "2023-10-22T17:26:49.645637",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.641336",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 4:** Create a Linear Regression model\n",
    "Initialize a Linear Regression model using ```LinearRegression().```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb31ed70",
   "metadata": {
    "papermill": {
     "duration": 0.004131,
     "end_time": "2023-10-22T17:26:49.654064",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.649933",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "#### **Here are the key steps to understand a linear regression model:**\n",
    "\n",
    "1. **Data Collection**: Gather the dataset containing the relevant information you want to model. For simple linear regression, you typically have one dependent variable (the target) and one independent variable (the predictor). In multiple linear regression, you have multiple independent variables.\n",
    "\n",
    "2. **Data Preprocessing**:\n",
    "\n",
    "   a. **Data Cleaning**: Check for missing values and outliers. Handle them appropriately, e.g., by imputing missing data or removing outliers.\n",
    "   \n",
    "   b. **Feature Selection/Engineering**: Determine which independent variables are relevant for your model. You might need to transform or engineer features to make them suitable for regression.\n",
    "\n",
    "3. **Scatterplot**: Visualize the data by creating a scatterplot of the dependent variable against the independent variable(s) to get an initial sense of the relationship.\n",
    "\n",
    "4. **Assumption Check**: Linear regression makes several assumptions, including linearity, independence of errors, homoscedasticity, and normality of errors. You should check if your data satisfies these assumptions. If not, you may need to apply transformations or consider different modeling techniques.\n",
    "\n",
    "5. **Split Data**: Divide your dataset into a training set and a testing set. The training set is used to train the model, and the testing set is used to evaluate its performance.\n",
    "\n",
    "6. **Model Building**:\n",
    "\n",
    "   a. **Choose the Model**: Select either simple linear regression (one independent variable) or multiple linear regression (more than one independent variable).\n",
    "\n",
    "   b. **Fit the Model**: Use the training data to estimate the coefficients (slope and intercept for simple linear regression) that minimize the sum of squared differences between the observed and predicted values.\n",
    "\n",
    "   c. **Interpret the Coefficients**: Understand the meaning of the coefficients for each independent variable. They represent the change in the dependent variable for a one-unit change in the corresponding independent variable, assuming all other variables are held constant.\n",
    "\n",
    "7. **Model Evaluation**:\n",
    "\n",
    "   a. **Assess Model Fit**: Use appropriate metrics like Mean Squared Error (MSE), Root Mean Squared Error (RMSE), or R-squared to evaluate how well your model fits the training data.\n",
    "\n",
    "   b. **Test the Model**: Apply the model to the testing set to assess its predictive accuracy on unseen data.\n",
    "\n",
    "8. **Model Interpretation**:\n",
    "\n",
    "   a. **Coefficient Significance**: Determine if the coefficients are statistically significant using hypothesis tests.\n",
    "   \n",
    "   b. **Coefficient Interpretation**: Interpret the coefficients in the context of your problem to make meaningful conclusions.\n",
    "\n",
    "9. **Prediction and Inference**: Use the model to make predictions or draw inferences about the relationship between the dependent and independent variables.\n",
    "\n",
    "10. **Model Deployment** (if applicable): If the model performs well and is valuable, it can be deployed in production for real-world predictions.\n",
    "\n",
    "11. **Regularization** (if needed): In some cases, you might apply regularization techniques like Ridge or Lasso regression to prevent overfitting or handle multicollinearity.\n",
    "\n",
    "12. **Continuous Improvement**: As new data becomes available, you may need to retrain the model to keep it accurate and relevant.\n",
    "\n",
    "These steps outline the process of building and using a linear regression model. The actual implementation in Python or any other programming language involves writing code to carry out these steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "758d79bf",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:49.664632Z",
     "iopub.status.busy": "2023-10-22T17:26:49.663925Z",
     "iopub.status.idle": "2023-10-22T17:26:49.668941Z",
     "shell.execute_reply": "2023-10-22T17:26:49.668122Z"
    },
    "papermill": {
     "duration": 0.013371,
     "end_time": "2023-10-22T17:26:49.671690",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.658319",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 4: Create a Linear Regression model\n",
    "model = LinearRegression()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e776e653",
   "metadata": {
    "papermill": {
     "duration": 0.004359,
     "end_time": "2023-10-22T17:26:49.680971",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.676612",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 5:** Train the model on the training data\n",
    "\n",
    "Fit the model to the training data using the fit method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "54005b0b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:49.691880Z",
     "iopub.status.busy": "2023-10-22T17:26:49.691500Z",
     "iopub.status.idle": "2023-10-22T17:26:49.723319Z",
     "shell.execute_reply": "2023-10-22T17:26:49.722042Z"
    },
    "papermill": {
     "duration": 0.040187,
     "end_time": "2023-10-22T17:26:49.725730",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.685543",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Step 5: Train the model on the training data\n",
    "model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a729a22b",
   "metadata": {
    "papermill": {
     "duration": 0.004841,
     "end_time": "2023-10-22T17:26:49.736384",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.731543",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 6:** Make predictions using the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "817d82f1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:49.747731Z",
     "iopub.status.busy": "2023-10-22T17:26:49.747425Z",
     "iopub.status.idle": "2023-10-22T17:26:49.752390Z",
     "shell.execute_reply": "2023-10-22T17:26:49.751297Z"
    },
    "papermill": {
     "duration": 0.012848,
     "end_time": "2023-10-22T17:26:49.754210",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.741362",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 6: Make predictions using the test data\n",
    "y_pred = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bdc9653",
   "metadata": {
    "papermill": {
     "duration": 0.004832,
     "end_time": "2023-10-22T17:26:49.764193",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.759361",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 7:** Visualize the data and the regression line\n",
    "Create a scatter plot of the test data and the regression line to visualize the model's performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5ff05b6e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:49.775507Z",
     "iopub.status.busy": "2023-10-22T17:26:49.775140Z",
     "iopub.status.idle": "2023-10-22T17:26:50.054862Z",
     "shell.execute_reply": "2023-10-22T17:26:50.053995Z"
    },
    "papermill": {
     "duration": 0.287802,
     "end_time": "2023-10-22T17:26:50.056894",
     "exception": false,
     "start_time": "2023-10-22T17:26:49.769092",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_test, y_test, color='b', label='Actual Data')\n",
    "plt.plot(X_test, y_pred, color='r', label='Regression Line')\n",
    "plt.xlabel('X-axis')\n",
    "plt.ylabel('Y-axis')\n",
    "plt.legend()\n",
    "plt.title('Linear Regression')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf2cbdc8",
   "metadata": {
    "papermill": {
     "duration": 0.00556,
     "end_time": "2023-10-22T17:26:50.067830",
     "exception": false,
     "start_time": "2023-10-22T17:26:50.062270",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Step 8:** Evaluate the model\n",
    "Calculate Mean Squared Error (MSE) and R-squared (R2) to evaluate the model's performance on the test data and print the results."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c013af5",
   "metadata": {
    "papermill": {
     "duration": 0.005175,
     "end_time": "2023-10-22T17:26:50.078815",
     "exception": false,
     "start_time": "2023-10-22T17:26:50.073640",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### **1. Mean Squared Error (MSE):**\n",
    "\n",
    "Mean Squared Error (MSE) is a common mathematical metric used in statistics and machine learning to measure the average squared difference between predicted values and actual (observed) values. It is particularly useful for evaluating the accuracy and performance of regression models. Here, I will explain the concept of MSE step by step:\n",
    "\n",
    "**Step 1: Define Your Objective**\n",
    "The first step in understanding and using MSE is to establish your objective. You should have a set of observed or actual values (often denoted as \"y\") and a set of predicted values (often denoted as \"ŷ\"). The goal is to quantify how well your predictions match the actual values.\n",
    "\n",
    "**Step 2: Calculate the Residuals**\n",
    "Residuals, also known as errors, are the differences between the actual values (y) and the predicted values (ŷ) for each data point. You calculate residuals for each data point using the following formula:\n",
    "```\n",
    "Residual = y - ŷ\n",
    "```\n",
    "For each data point, subtract the predicted value from the actual value.\n",
    "\n",
    "**Step 3: Square the Residuals**\n",
    "To eliminate the positive and negative differences, you square each residual. Squaring the residuals ensures that all values are positive and gives more weight to larger errors, making the metric sensitive to outliers.\n",
    "\n",
    "**Step 4: Calculate the Mean**\n",
    "Calculate the mean (average) of the squared residuals. This is done by summing up all the squared residuals and dividing by the total number of data points (n):\n",
    "```\n",
    "MSE = (1/n) * Σ(Residual_i^2)\n",
    "```\n",
    "Here, \"Σ\" denotes the sum from i = 1 to n.\n",
    "\n",
    "**Step 5: Interpretation**\n",
    "The MSE provides a single number that quantifies the overall quality of your predictions. It measures the average squared difference between predicted and actual values. A smaller MSE indicates a better fit of the model to the data, while a larger MSE suggests a poorer fit.\n",
    "\n",
    "**Step 6: Practical Application**\n",
    "MSE is commonly used for model evaluation in various fields, such as:\n",
    "\n",
    "- **Regression Analysis:** It assesses the goodness of fit of a regression model.\n",
    "- **Machine Learning:** It serves as a loss function for training models like linear regression, neural networks, and support vector machines.\n",
    "- **Forecasting:** It measures the accuracy of time series forecasts.\n",
    "- **Image and Signal Processing:** It quantifies the quality of image reconstruction or signal denoising.\n",
    "\n",
    "**Step 7: Limitations**\n",
    "While MSE is a valuable metric, it has some limitations:\n",
    "\n",
    "- It heavily penalizes large errors due to squaring, making it sensitive to outliers.\n",
    "- The MSE value is not in the same unit as the original data, which can make it challenging to interpret.\n",
    "- In cases where the prediction errors are not normally distributed, alternative metrics like Mean Absolute Error (MAE) or Root Mean Squared Error (RMSE) might be more appropriate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "515afa05",
   "metadata": {
    "papermill": {
     "duration": 0.005018,
     "end_time": "2023-10-22T17:26:50.089330",
     "exception": false,
     "start_time": "2023-10-22T17:26:50.084312",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### **2. R-squared (R²):**\n",
    "R-squared (R²) is a statistical measure used in regression analysis to evaluate the goodness of fit of a model. It helps us understand how well the independent variables in a regression model explain the variation in the dependent variable. R-squared is often used in fields such as economics, finance, and social sciences, but it can be applied in a wide range of disciplines. Here's a step-by-step explanation of what R-squared is and how it is calculated:\n",
    "\n",
    "1. **Understand the Basics of Regression Analysis:**\n",
    "   Before delving into R-squared, it's essential to understand the basics of regression analysis. Regression is a statistical technique used to model the relationship between one or more independent variables (predictors) and a dependent variable (the outcome). There are different types of regression, but the most common one is linear regression.\n",
    "\n",
    "2. **Formulate a Hypothesis:**\n",
    "   In a regression analysis, you start with a hypothesis or a belief that certain independent variables have an effect on the dependent variable. For example, you might believe that factors like age, income, and education level influence a person's health.\n",
    "\n",
    "3. **Collect Data:**\n",
    "   To test your hypothesis, you need data. Collect data for the dependent variable and the independent variables. In our health example, you'd gather data on individuals' health status, age, income, and education level.\n",
    "\n",
    "4. **Build a Regression Model:**\n",
    "   Use a statistical software or tool to create a regression model. For simple linear regression, you'll have one independent variable, and for multiple linear regression, you'll have more than one. The model's equation might look like this:\n",
    "   `Health = β₀ + β₁ * Age + β₂ * Income + β₃ * Education`\n",
    "\n",
    "5. **Calculate the Sum of Squares Total (SST):**\n",
    "   SST represents the total variation in the dependent variable. It's calculated as the sum of the squared differences between each data point and the mean of the dependent variable.\n",
    "\n",
    "6. **Calculate the Sum of Squares Regression (SSR):**\n",
    "   SSR represents the variation in the dependent variable that your model explains. It's calculated as the sum of the squared differences between the predicted values from your model and the mean of the dependent variable.\n",
    "\n",
    "7. **Calculate the Residual Sum of Squares (SSE):**\n",
    "   SSE represents the unexplained variation or error in your model. It's calculated as the sum of the squared differences between the actual data points and the predicted values from your model.\n",
    "\n",
    "8. **Compute R-squared (R²):**\n",
    "   R-squared is calculated as the ratio of SSR to SST. In other words, it tells you what proportion of the total variation in the dependent variable is explained by your model. The formula for R-squared is:\n",
    "   `R² = 1 - (SSE / SST)`\n",
    "\n",
    "9. **Interpret R-squared:**\n",
    "   R-squared values range from 0 to 1. A higher R-squared indicates that a larger proportion of the variation in the dependent variable is explained by the independent variables. An R-squared of 1 means that the model perfectly explains all the variation.\n",
    "\n",
    "10. **Consider the Implications:**\n",
    "    While R-squared is a valuable metric, it's important to use it in context. A high R-squared doesn't necessarily mean your model is good; it might overfit the data. Conversely, a low R-squared doesn't necessarily mean your model is bad; it may still provide valuable insights.\n",
    "\n",
    "11. **Assess Model Fit:**\n",
    "    It's advisable to complement R-squared with other statistical tests, such as hypothesis testing for individual coefficients and residual analysis, to ensure that your regression model is valid and appropriate for your data.\n",
    "\n",
    "```R-squared is a fundamental metric in regression analysis that helps you assess how well your model explains the variation in the dependent variable. By following the steps above and interpreting the R-squared value in the context of your research, you can gain insights into the relationships between variables and the predictive power of your model.```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e9bbf907",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T17:26:50.102214Z",
     "iopub.status.busy": "2023-10-22T17:26:50.101569Z",
     "iopub.status.idle": "2023-10-22T17:26:50.108556Z",
     "shell.execute_reply": "2023-10-22T17:26:50.107001Z"
    },
    "papermill": {
     "duration": 0.015867,
     "end_time": "2023-10-22T17:26:50.110569",
     "exception": false,
     "start_time": "2023-10-22T17:26:50.094702",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 0.07\n",
      "R-squared: 0.97\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "mse = mean_squared_error(y_test, y_pred)\n",
    "r2 = r2_score(y_test, y_pred)\n",
    "print(f\"Mean Squared Error: {mse:.2f}\")\n",
    "print(f\"R-squared: {r2:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25c57c2c",
   "metadata": {
    "papermill": {
     "duration": 0.005068,
     "end_time": "2023-10-22T17:26:50.121242",
     "exception": false,
     "start_time": "2023-10-22T17:26:50.116174",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Learn More\n",
    "Here are a few more basic and fundamental Python topics I tried to cover.\n",
    "\n",
    "- **[Comprehensive Guide on NumPy for Beginners](https://www.kaggle.com/code/tanvirnwu/boolean-in-python-with-example-and-explanation)**\n",
    "- **[Dictionary in Python with Examples & Explanations](https://www.kaggle.com/code/tanvirnwu/dictionary-in-python-with-examples-explanationsn)**\n",
    "- **[Boolean in Python with Example and Explanation](https://www.kaggle.com/code/tanvirnwu/boolean-in-python-with-example-and-explanation#Learn-More)**\n",
    "- **[List in Python for Beginners](https://www.kaggle.com/code/tanvirnwu/list-in-python-for-beginners)**\n",
    "\n",
    "\n",
    "#### I love to connect with new people. Let's connect on **[Linkedin.](https://www.linkedin.com/in/tanvirislamnwu/)**\n",
    "#### ***Please leave an upvote if you think these are some helpful materials for the beginners. Thank you!!***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a64423fe",
   "metadata": {
    "papermill": {
     "duration": 0.004899,
     "end_time": "2023-10-22T17:26:50.131316",
     "exception": false,
     "start_time": "2023-10-22T17:26:50.126417",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d577b86",
   "metadata": {
    "papermill": {
     "duration": 0.00498,
     "end_time": "2023-10-22T17:26:50.141715",
     "exception": false,
     "start_time": "2023-10-22T17:26:50.136735",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.10.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 5.32873,
   "end_time": "2023-10-22T17:26:50.567651",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2023-10-22T17:26:45.238921",
   "version": "2.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}