5.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6fecf6f9-b589-47ee-a713-62c1b8a94714",
   "metadata": {},
   "source": [
    "# Supervised Learning - Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7feffd1f-2c21-4d47-a3f3-94b7ee773a65",
   "metadata": {},
   "source": [
    "## 5.1.1 Linear regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4c872be-0ab2-45b3-9250-f9c14ebd1e5d",
   "metadata": {},
   "source": [
    "![Image of Runcode](https://static.javatpoint.com/tutorial/machine-learning/images/linear-regression-in-machine-learning.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e75ed6fd-c53d-4e53-8d8a-2bc7885048df",
   "metadata": {},
   "source": [
    "<b>Linear regression</b> is a supervised machine learning algorithm that is used for predicting a continuous value. It assumes that there is a linear relationship between the input features (also known as predictors or independent variables) and the target value (also known as the dependent variable). \n",
    "\n",
    "The goal of linear regression is to find the line of best fit, which is the line that minimizes the difference between the predicted values and the true values. The line of best fit is found by minimizing the sum of the squared errors between the predicted values and the true values. This is known as the least squares method.\n",
    "\n",
    "The equation for a simple linear regression model with one input feature (x) and one target value (y) is given by:\n",
    "\n",
    "y = mx + b\n",
    "\n",
    "where m is the slope of the line and b is the y-intercept. These parameters, m and b, are learned from the data.\n",
    "\n",
    "Linear regression can be extended to handle multiple input features (known as multiple linear regression) by using the following equation:\n",
    "\n",
    "$y = b + m_1x_1 + m_2x_2 + ... + m_nx_n$\n",
    "\n",
    "where $x_1$, $x_2$, ..., $x_n$ are the input features and $m_1$, $m_2$, ..., $m_n$ are the corresponding model parameters.\n",
    "\n",
    "Linear regression is sensitive to outliers, and it can be prone to overfitting if there are a large number of input features. To address these issues, linear regression can be regularized by adding a penalty term to the objective function. This penalty term helps to prevent overfitting by reducing the magnitude of the model parameters.\n",
    "\n",
    "Linear regression is a simple and widely used method for predicting a continuous value, and it is a good starting point for many machine learning problems. It can be implemented using various libraries and frameworks in Python, such as scikit-learn, TensorFlow, and Keras."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3285b4b-df6f-4134-bb06-f4abdbacb305",
   "metadata": {},
   "source": [
    "<b>scikit-learn (sklearn):</b> scikit-learn (sklearn) is a free, open-source library for machine learning in Python. It provides a range of supervised and unsupervised learning algorithms in Python. It is built on top of other popular Python libraries such as NumPy, pandas, and Matplotlib.\n",
    "\n",
    "Some of the main features of scikit-learn include:\n",
    "\n",
    "* Simple and efficient tools for data mining and data analysis.\n",
    "* Accessible to everybody and reusable in various contexts.\n",
    "* Built on the top of NumPy, SciPy, and matplotlib.\n",
    "* Provides many tuning parameters but with sensible defaults.\n",
    "\n",
    "To use scikit-learn, you will need to install it first. You can install it using pip install scikit-learn.\n",
    "\n",
    "To use scikit-learn, you will also need to have NumPy and SciPy installed. You can install them using pip install numpy and pip install scipy.\n",
    "\n",
    "Once you have scikit-learn installed, you can import it in your Python code using import sklearn. You can then use the various functions and classes provided by scikit-learn to build and train machine learning models."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8abac0e0-28d5-4147-9c89-2aa8fc2997c4",
   "metadata": {},
   "source": [
    "\n",
    "Here is an example of linear regression in Python using the scikit-learn library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fba7e25-b696-4f66-90a6-355645799f9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9.]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "# Training data\n",
    "X = [[1, 1], [2, 3], [3, 5], [4, 7]]\n",
    "y = [1, 3, 5, 7]\n",
    "\n",
    "# Create the model\n",
    "model = LinearRegression()\n",
    "\n",
    "# Train the model on the training data\n",
    "model.fit(X, y)\n",
    "\n",
    "# Make a prediction using the trained model\n",
    "prediction = model.predict([[5, 9]])\n",
    "print(prediction)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd671e14-1cbb-4f14-98b2-c36c2cc4b4b5",
   "metadata": {},
   "source": [
    "This code will fit a linear regression model to the training data, which consists of four examples with two input features (X) and one continuous target value (y). The model is then used to make a prediction for a new example with input features [5, 9]. The output will be the predicted continuous value for this example.\n",
    "\n",
    "In this example, the linear regression model will learn a line of the form y = mx + b, where m and b are the model parameters that are learned from the data. The line of best fit is found by minimizing the sum of the squared errors between the predicted values and the true values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc344601-72c7-4f71-8040-4705fbde51d5",
   "metadata": {},
   "source": [
    "## 5.1.2 Bias, Variance and trade-off"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25927690-ee04-4d29-972c-a00000aaa3d2",
   "metadata": {},
   "source": [
    "Bias and variance are two important concepts in machine learning that describe the performance of a model on the training data and on new, unseen data.\n",
    "\n",
    "<b>Bias</b> refers to the error that is introduced by the assumptions of a model. A model with a high bias pays little attention to the training data and makes predictions based on a simple and rigid assumption, resulting in a high error on the training data. This is known as underfitting.\n",
    "\n",
    "On the other hand, <b>variance</b> refers to the sensitivity of a model to the specifics of the training data. A model with a high variance pays too much attention to the training data and is sensitive to the noise and random fluctuations in the data, resulting in a high error on new, unseen data. This is known as overfitting.\n",
    "\n",
    "The <b>bias-variance trade-off</b> refers to the trade-off between a model's ability to fit the training data well (low bias) and its ability to generalize to new, unseen data (low variance). In general, a model with a low bias and a low variance will have a good performance on both the training data and new, unseen data.\n",
    "\n",
    "To achieve a good bias-variance trade-off, it is important to choose an appropriate model complexity for the given problem. This can be done by using techniques such as cross-validation, regularization, and model selection."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "496662c5-208f-49f9-8423-5f7c4a3c4d35",
   "metadata": {},
   "source": [
    "![Image of runcode](https://static.javatpoint.com/tutorial/machine-learning/images/bias-and-variance-in-machine-learning6.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76d68b19-37d2-4ebf-b0ed-1aa9d81ee56b",
   "metadata": {},
   "source": [
    "Here is an example of how to calculate and plot bias, variance, and the bias-variance trade-off in Python using synthetic data and a simple linear regression model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7e88e80-88d6-4d1e-b7cc-de0059fe4f45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "# Generate synthetic data\n",
    "np.random.seed(0)\n",
    "X = np.sort(5 * np.random.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel() + np.random.normal(0, 0.3, len(X))\n",
    "\n",
    "# Fit a linear regression model to the data\n",
    "model = LinearRegression()\n",
    "model.fit(X, y)\n",
    "\n",
    "# Calculate the predictions and the errors\n",
    "predictions = model.predict(X)\n",
    "bias = np.mean((predictions - y) ** 2)\n",
    "variance = np.var(predictions)\n",
    "\n",
    "# Plot the bias-variance trade-off\n",
    "plt.plot([1, 2, 3, 4], [bias, variance, bias + variance, 0], '-o')\n",
    "plt.xlabel(\"Bias\")\n",
    "plt.ylabel(\"Variance\")\n",
    "plt.title(\"Bias-variance trade-off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c92fe52e-8d52-4f7e-9640-f50b456766ae",
   "metadata": {},
   "source": [
    "## 5.1.3 Regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a1063d2-09a0-4bee-8beb-52a26072f458",
   "metadata": {},
   "source": [
    "![Image of runcode](https://qph.cf2.quoracdn.net/main-qimg-4fd3db5549d6a0287e7494b933e783d0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8553bf91-a8ec-4cac-97ed-9a484412defc",
   "metadata": {},
   "source": [
    "<b>Regularization</b> is a technique used in machine learning to prevent overfitting and improve the generalization of a model to new, unseen data. It does this by adding a penalty term to the objective function of the model, which helps to reduce the magnitude of the model parameters and make the model simpler and more robust.\n",
    "\n",
    "There are two types of regularization commonly used in machine learning: L1 regularization and L2 regularization.\n",
    "\n",
    "<b>L1 regularization</b>, also known as <b>Lasso</b> regularization, adds a penalty term to the objective function that is proportional to the absolute value of the model parameters. It results in a sparse model, where some of the model parameters are exactly equal to zero.\n",
    "\n",
    "<b>L2 regularization</b>, also known as <b>Ridge</b> regularization, adds a penalty term to the objective function that is proportional to the square of the model parameters. It results in a model with small, non-zero parameter values.\n",
    "\n",
    "The regularization term is controlled by a hyperparameter, known as the regularization strength or regularization parameter, which determines the magnitude of the penalty applied to the objective function.\n",
    "\n",
    "Here is an example of L2 regularization in a linear regression model using scikit-learn:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b753a54f-6450-453f-ad59-558eaf4d1109",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import Ridge\n",
    "\n",
    "# Initialize the model\n",
    "model = Ridge(alpha=0.1)\n",
    "\n",
    "# Fit the model to the data\n",
    "model.fit(X, y)\n",
    "\n",
    "# Make predictions using the trained model\n",
    "y_pred = model.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "789e5fec-5f44-4c1a-96a4-5f305a14fed8",
   "metadata": {},
   "source": [
    "In this example, we initialize a Ridge model with a regularization strength of 0.1 and fit it to the data. The model is then used to make predictions on the training data.\n",
    "\n",
    "Regularization is an important technique for improving the generalization of a machine learning model, and it is commonly used in a wide range of models, including linear regression, logistic regression, and neural networks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2db7674-27c3-4947-84d6-c8830e9e2a39",
   "metadata": {},
   "source": [
    "## 5.1.4 Gradient descent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f362df8c-93e6-4611-bf01-46e73a627f57",
   "metadata": {},
   "source": [
    "<b>Gradient descent</b> is an optimization algorithm used to minimize a loss function. It works by iteratively adjusting the parameters of a model in the direction that reduces the loss.\n",
    "\n",
    "The loss function is a measure of how well the model fits the training data. It is defined as the difference between the predicted values and the true values. The goal of gradient descent is to find the set of model parameters that minimizes the loss function.\n",
    "\n",
    "The basic idea of gradient descent is to start with some initial set of parameters, compute the loss function and its gradient with respect to the parameters, and then update the parameters in the opposite direction of the gradient. This process is repeated until the loss function converges to a minimum."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a86fad77-0025-412d-95a1-642abd8e530e",
   "metadata": {},
   "source": [
    "![Image of runcode](https://static.javatpoint.com/tutorial/machine-learning/images/gradient-descent-in-machine-learning1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "273f5ebc-bfa8-4f30-94f4-b612d7c14091",
   "metadata": {},
   "source": [
    "Gradient descent is a simple and widely used optimization algorithm that is used in many machine learning models, including linear regression, logistic regression, and neural networks. It is an iterative algorithm, and the number of iterations (also known as the epochs) and the learning rate (eta) are hyperparameters that need to be set manually. It is important to choose appropriate values for these hyperparameters to ensure that the algorithm converges to a good solution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6de2b701-1892-4f01-8e10-4d5df03746aa",
   "metadata": {},
   "source": [
    "## 5.1.5 Learning rate and Cost function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca1e740c-3303-4a62-806f-86f8fe6af267",
   "metadata": {},
   "source": [
    "<b>Learning rate</b> is a hyperparameter in machine learning that determines the step size at which the algorithm makes updates to the model parameters. It controls the speed at which the algorithm learns, and it is an important factor in the performance of the model.\n",
    "\n",
    "A high learning rate can cause the algorithm to converge quickly, but it may also result in a suboptimal solution or cause the algorithm to oscillate and never converge. On the other hand, a low learning rate can cause the algorithm to converge slowly, but it may result in a more accurate solution.\n",
    "\n",
    "The learning rate is often chosen by trial and error, and it can be adjusted during training if the performance of the model is not satisfactory."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c664e74e-5856-4751-82f2-62380292db19",
   "metadata": {},
   "source": [
    "<b>Cost function</b>, also known as the loss function, is a measure of how well the model fits the training data. It is defined as the difference between the predicted values and the true values. The goal of the learning algorithm is to minimize the cost function, and the learning rate determines the step size at which the algorithm makes updates to the model parameters in order to minimize the cost.\n",
    "\n",
    "Here is an example of the cost function for a simple linear regression model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4b24a7f-7bda-4d65-a48f-543cfadec81c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost_function(X, y, theta):\n",
    "    m = len(y)\n",
    "    y_pred = X.dot(theta)\n",
    "    error = (y_pred - y) ** 2\n",
    "    return 1 / (2 * m) * np.sum(error)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9af0a67-f621-4180-a98a-4100a0d7dff1",
   "metadata": {},
   "source": [
    "In this example, the cost function is defined as the mean squared error between the predicted values (y_pred) and the true values (y). The goal of the learning algorithm is to minimize this cost function by adjusting the model parameters (theta).\n",
    "\n",
    "The cost function is an important component of many machine learning algorithms, and it is often used to evaluate the performance of a model and to choose the best model for a given problem."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}