machine_learning_from_scratch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1FF9iGjkbCXAPH6cEHt_Ou3jIsjvgkw23",
      "authorship_tag": "ABX9TyPT+HDm/bvKmNgfFjqpx0OY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/TengGao/Machine-Learning-From-Scratch/blob/main/machine_learning_from_scratch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import math\n",
        "from collections import Counter\n",
        "from sklearn.preprocessing import LabelEncoder"
      ],
      "metadata": {
        "id": "1OO2TcXLSF9H"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Oridnary Least Square Fit Using Matrix Inversion Pesudo Code\n",
        "\n",
        "1. Initializes an instance of the OrdinaryLeastSquares class, setting the beta attribute to None. This attribute will store the model coefficients after fitting.\n",
        "2. Fitting the Model:\n",
        "* Computes the matrix $X^tX$ and its inverse;\n",
        "* Calculates $X^ty$;\n",
        "* Derive the coefficient $\\beta$ by $$\\beta = (X^tX)^{-1}X^ty$$\n",
        "3. Prediction by $y = X^t\\beta$."
      ],
      "metadata": {
        "id": "OM6dyn4oTQ-n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class OrdinaryLeastSquares:\n",
        "    def __init__(self):\n",
        "        self.beta = None  # Coefficients will be set after fitting the model\n",
        "\n",
        "    def fit(self, X, y):\n",
        "        # Step 1: Calculate X^T X\n",
        "        XTX = np.dot(X.T, X)\n",
        "\n",
        "        # Step 2: Calculate the inverse of X^T X\n",
        "        XTX_inv = np.linalg.inv(XTX)\n",
        "\n",
        "        # Step 3: Calculate X^T y\n",
        "        XTy = np.dot(X.T, y)\n",
        "\n",
        "        # Step 4: Calculate the coefficients (beta)\n",
        "        self.beta = np.dot(XTX_inv, XTy)\n",
        "\n",
        "    def predict(self, X):\n",
        "        # Make predictions using the learned coefficients\n",
        "        return np.dot(X, self.beta)\n",
        "\n",
        "# Test\n",
        "X = np.array([\n",
        "    [1, 1],  # Added a column of ones already for the intercept\n",
        "    [1, 2],\n",
        "    [1, 3],\n",
        "    [1, 4],\n",
        "    [1, 5]\n",
        "])\n",
        "y = np.array([1, 2, 1.3, 3.75, 2.25])\n",
        "\n",
        "model = OrdinaryLeastSquares()\n",
        "model.fit(X, y)\n",
        "print(\"Coefficients:\", model.beta)\n",
        "\n",
        "# Predicting values\n",
        "predicted_y = model.predict(X)\n",
        "print(\"Predicted values:\", predicted_y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fH5cwimaL8jQ",
        "outputId": "57e2fbb8-62af-4f9b-8b48-49c2fd6ed827"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Coefficients: [0.785 0.425]\n",
            "Predicted values: [1.21  1.635 2.06  2.485 2.91 ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class LinearRegressionGD:\n",
        "    def __init__(self, learning_rate=0.1, n_iterations=1000):\n",
        "        self.learning_rate = learning_rate\n",
        "        self.n_iterations = n_iterations\n",
        "        self.beta = None  # Coefficients will be set after fitting the model\n",
        "\n",
        "    def fit(self, X, y):\n",
        "        m = len(X)\n",
        "        X_b = np.c_[np.ones((m, 1)), X]  # Add intercept term\n",
        "        self.beta = np.random.randn(X_b.shape[1], 1)  # Random initialization of parameters\n",
        "\n",
        "        for iteration in range(self.n_iterations):\n",
        "            gradients = -2/m * X_b.T @ (y - X_b @ self.beta)  # Using @ for matrix multiplication\n",
        "            self.beta -= self.learning_rate * gradients\n",
        "\n",
        "    def predict(self, X):\n",
        "        X_b = np.c_[np.ones((len(X), 1)), X]  # Add intercept term\n",
        "        return X_b @ self.beta  # Using @ for matrix multiplication\n",
        "\n",
        "# Sample Data Generation\n",
        "np.random.seed(0)\n",
        "X = 2 * np.random.rand(100, 1)\n",
        "y = 4 + 3 * X + np.random.randn(100, 1)\n",
        "\n",
        "# Create an instance of the LinearRegressionGD class\n",
        "model = LinearRegressionGD(learning_rate=0.1, n_iterations=1000)\n",
        "model.fit(X, y)  # Fit the model\n",
        "\n",
        "# Make predictions\n",
        "X_new = np.array([[0], [2]])\n",
        "y_predict = model.predict(X_new)\n",
        "\n",
        "print(\"Estimated coefficients:\", model.beta)\n",
        "print(\"Predictions:\", y_predict)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AgWczsyGZaKJ",
        "outputId": "4f38edcb-42d6-47f8-a1e1-b7300882da8c"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estimated coefficients: [[4.22215108]\n",
            " [2.96846751]]\n",
            "Predictions: [[ 4.22215108]\n",
            " [10.1590861 ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementing Decision Tree Classifier\n",
        "# 1. Start at the root node with the whole dataset.\n",
        "# 1. For each feature, calculate the potential information gain of splitting on that feature.\n",
        "# 1. Choose the feature with the highest information gain.\n",
        "# 1. Split the dataset into subsets using the chosen feature.\n",
        "# 1. Recursively repeat the process for each subset until one of the stopping criteria is met (e.g., all members of a subset have the same class, the subset reaches a minimum size, or maximum depth is reached).\n",
        "class DecisionTree:\n",
        "    def __init__(self, max_depth=3):\n",
        "        self.max_depth = max_depth\n",
        "        self.tree = None\n",
        "\n",
        "    def fit(self, X, y):\n",
        "        self.features = X.shape[1]\n",
        "        self.tree = self._build_tree(X, y, 0)\n",
        "\n",
        "    def _build_tree(self, X, y, depth):\n",
        "        num_samples, num_features = X.shape\n",
        "        # Stop criteria\n",
        "        if depth == self.max_depth or len(np.unique(y)) == 1:\n",
        "            most_common_label = np.bincount(y).argmax()\n",
        "            return {'label': most_common_label}\n",
        "\n",
        "        # Find the best split\n",
        "        best_gain = -1\n",
        "        best_feature = None\n",
        "        best_threshold = None\n",
        "        for feature_index in range(num_features):\n",
        "            thresholds = np.unique(X[:, feature_index])\n",
        "            for threshold in thresholds:\n",
        "                gain = self._information_gain(X, y, feature_index, threshold)\n",
        "                if gain > best_gain:\n",
        "                    best_gain = gain\n",
        "                    best_feature = feature_index\n",
        "                    best_threshold = threshold\n",
        "\n",
        "        # Grow the tree recursively\n",
        "        left_mask = X[:, best_feature] <= best_threshold\n",
        "        right_mask = X[:, best_feature] > best_threshold\n",
        "        left_child = self._build_tree(X[left_mask], y[left_mask], depth + 1)\n",
        "        right_child = self._build_tree(X[right_mask], y[right_mask], depth + 1)\n",
        "        return {'feature_index': best_feature, 'threshold': best_threshold, 'left': left_child, 'right': right_child, 'info_gain': best_gain}\n",
        "\n",
        "    def _entropy(self, y):\n",
        "        _, counts = np.unique(y, return_counts=True)\n",
        "        probabilities = counts / counts.sum()\n",
        "        return -np.sum(probabilities * np.log2(probabilities))\n",
        "\n",
        "    def _information_gain(self, X, y, feature_index, threshold):\n",
        "        parent_entropy = self._entropy(y)\n",
        "        left_mask = X[:, feature_index] <= threshold\n",
        "        right_mask = X[:, feature_index] > threshold\n",
        "        left_entropy = self._entropy(y[left_mask])\n",
        "        right_entropy = self._entropy(y[right_mask])\n",
        "        n = len(y)\n",
        "        n_left, n_right = left_mask.sum(), right_mask.sum()\n",
        "        child_entropy = (n_left / n) * left_entropy + (n_right / n) * right_entropy\n",
        "        return parent_entropy - child_entropy\n",
        "\n",
        "    def predict(self, X):\n",
        "        predictions = [self._predict(inputs, self.tree) for inputs in X]\n",
        "        return np.array(predictions)\n",
        "\n",
        "    def _predict(self, inputs, tree):\n",
        "        if 'label' in tree:\n",
        "            return tree['label']\n",
        "        feature_index = tree['feature_index']\n",
        "        threshold = tree['threshold']\n",
        "        if inputs[feature_index] <= threshold:\n",
        "            return self._predict(inputs, tree['left'])\n",
        "        else:\n",
        "            return self._predict(inputs, tree['right'])\n",
        "\n",
        "# Example Usage\n",
        "from sklearn.datasets import load_iris\n",
        "data = load_iris()\n",
        "X, y = data.data, data.target\n",
        "dt = DecisionTree(max_depth=3)\n",
        "dt.fit(X, y)\n",
        "\n",
        "Predicting\n",
        "print(dt.predict(X[:5]))\n",
        "\n",
        "# Example Usage 2\n",
        "data = {\n",
        "    'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rain', 'Rain', 'Rain', 'Overcast', 'Sunny', 'Sunny', 'Rain', 'Sunny', 'Overcast', 'Overcast', 'Rain'],\n",
        "    'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Cool', 'Mild', 'Cool', 'Mild', 'Mild', 'Mild', 'Hot', 'Mild'],\n",
        "    'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'High'],\n",
        "    'Wind': ['Weak', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Strong'],\n",
        "    'Play Tennis': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No']\n",
        "}\n",
        "\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Encoding categorical data\n",
        "label_encoder = LabelEncoder()\n",
        "for column in df.columns:\n",
        "    df[column] = label_encoder.fit_transform(df[column])\n",
        "\n",
        "# Split features and target\n",
        "X = df.drop('Play Tennis', axis=1).values\n",
        "y = df['Play Tennis'].values\n",
        "\n",
        "dt = DecisionTree(max_depth=3)\n",
        "dt.fit(X, y)\n",
        "\n",
        "# Predicting\n",
        "print(dt.predict(X[:5]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9VaqkvFCvU2i",
        "outputId": "15dd20e7-e53b-461f-baf8-825cb325204c"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0 0 1 0 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Python Implementation Of Support Vector Machine\n",
        "class LinearSVM:\n",
        "    def __init__(self, learning_rate=0.01, lambda_param=0.01, n_iterations=1000):\n",
        "        self.learning_rate = learning_rate\n",
        "        self.lambda_param = lambda_param\n",
        "        self.n_iterations = n_iterations\n",
        "        self.w = None\n",
        "        self.b = 0\n",
        "\n",
        "    def fit(self, X, y):\n",
        "        n, d = X.shape\n",
        "        y_ = np.where(y <= 0, -1, 1)\n",
        "        self.w = np.zeros(d)\n",
        "\n",
        "        for _ in range(self.n_iterations):\n",
        "            for idx, x_i in enumerate(X):\n",
        "                condition = y_[idx] * (np.dot(x_i, self.w) - self.b) >= 1\n",
        "                if condition:\n",
        "                    self.w -= self.learning_rate * (2 * self.lambda_param * self.w)\n",
        "                else:\n",
        "                    self.w -= self.learning_rate * (2 * self.lambda_param * self.w - np.dot(x_i, y_[idx]))\n",
        "                    self.b -= self.learning_rate * y_[idx]\n",
        "\n",
        "    def predict(self, X):\n",
        "        return np.sign(np.dot(X, self.w) - self.b)\n",
        "\n",
        "# Example usage\n",
        "from sklearn import datasets\n",
        "X, y = datasets.make_blobs(n_samples=50, n_features=2, centers=2, cluster_std=1.05, random_state=40)\n",
        "y = np.where(y == 0, -1, 1)  # Convert to -1, 1\n",
        "\n",
        "# Training the model\n",
        "model = LinearSVM()\n",
        "model.fit(X, y)\n",
        "\n",
        "# Predicting new data\n",
        "predictions = model.predict(X)"
      ],
      "metadata": {
        "id": "SYd0hIT9qEXh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class KNearestNeighbors:\n",
        "    def __init__(self, k=3):\n",
        "        self.k = k\n",
        "\n",
        "    def fit(self, X, y):\n",
        "        self.X_train = X\n",
        "        self.y_train = y\n",
        "\n",
        "    def predict(self, X):\n",
        "        y_pred = [self._predict(x) for x in X]\n",
        "        return np.array(y_pred)\n",
        "\n",
        "    def _predict(self, x):\n",
        "        # Compute distances between x and all examples in the training set\n",
        "        distances = [np.sqrt(np.sum((x_train - x) ** 2)) for x_train in self.X_train]\n",
        "        # Sort by distance and return indices of the first k neighbors\n",
        "        k_indices = np.argsort(distances)[:self.k]\n",
        "        # Extract the labels of the k nearest neighbors\n",
        "        k_nearest_labels = [self.y_train[i] for i in k_indices]\n",
        "        # Majority vote, most common class label\n",
        "        most_common = Counter(k_nearest_labels).most_common(1)\n",
        "        return most_common[0][0]\n",
        "\n",
        "# Example usage\n",
        "from sklearn.datasets import load_iris\n",
        "iris = load_iris()\n",
        "X, y = iris.data, iris.target\n",
        "\n",
        "# Splitting the dataset for the demonstration (normally use train-test split)\n",
        "X_train, X_test = X[:100], X[100:]\n",
        "y_train, y_test = y[:100], y[100:]\n",
        "\n",
        "# Creating an instance of KNearestNeighbors with k=3\n",
        "knn = KNearestNeighbors(k=3)\n",
        "knn.fit(X_train, y_train)\n",
        "\n",
        "# Making predictions\n",
        "predictions = knn.predict(X_test)\n",
        "print(\"Predicted labels:\", predictions)\n"
      ],
      "metadata": {
        "id": "J2Nhi2tYxbly"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Implement K-Mean Clustering\n",
        "# Key Concepts of k-Means\n",
        "# 1. Initialization:  Randomly select 𝑘. k points as the initial centroids or use smart initialization techniques like k-means++.\n",
        "# 1. Assignment: Assign each point to the nearest centroid based on the Euclidean distance.\n",
        "# 1. Update: Recalculate the centroids as the mean of the points assigned to each cluster.\n",
        "# 1. Iteration: Repeat the assignment and update steps until convergence (i.e., when the assignments no longer change or the changes are minimal).\n",
        "\n",
        "class KMeans:\n",
        "    def __init__(self, k=3, tol=0.0001, max_iter=300):\n",
        "        self.k = k\n",
        "        self.tol = tol\n",
        "        self.max_iter = max_iter\n",
        "\n",
        "    def fit(self, data):\n",
        "        self.centroids = {}\n",
        "\n",
        "        # Initialize centroids by picking random data points\n",
        "        for i in range(self.k):\n",
        "            self.centroids[i] = data[np.random.randint(len(data))]\n",
        "\n",
        "        for i in range(self.max_iter):\n",
        "            self.clusters = {i: [] for i in range(self.k)}\n",
        "\n",
        "            # Assign each data point to the closest centroid\n",
        "            for point in data:\n",
        "                distances = [np.linalg.norm(point - self.centroids[centroid]) for centroid in self.centroids]\n",
        "                cluster = np.argmin(distances)\n",
        "                self.clusters[cluster].append(point)\n",
        "\n",
        "            prev_centroids = dict(self.centroids)\n",
        "\n",
        "            # Recalculate centroids\n",
        "            for cluster in self.clusters:\n",
        "                self.centroids[cluster] = np.average(self.clusters[cluster], axis=0)\n",
        "\n",
        "            optimized = True\n",
        "            for c in self.centroids:\n",
        "                original_centroid = prev_centroids[c]\n",
        "                current_centroid = self.centroids[c]\n",
        "                if np.sum((current_centroid - original_centroid) / original_centroid * 100.0) > self.tol:\n",
        "                    optimized = False\n",
        "\n",
        "            if optimized:\n",
        "                break\n",
        "\n",
        "    def predict(self, data):\n",
        "        predictions = []\n",
        "        for point in data:\n",
        "            distances = [np.linalg.norm(point - self.centroids[centroid]) for centroid in self.centroids]\n",
        "            prediction = distances.index(min(distances))\n",
        "            predictions.append(prediction)\n",
        "        return predictions\n",
        "\n",
        "# Example usage\n",
        "from sklearn.datasets import make_blobs\n",
        "X, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=0)\n",
        "\n",
        "# Creating an instance of KMeans with k=3\n",
        "model = KMeans(k=3)\n",
        "model.fit(X)\n",
        "\n",
        "# Making predictions\n",
        "predictions = model.predict(X)\n",
        "\n",
        "# Optionally, plotting the results\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.scatter(X[:, 0], X[:, 1], c=predictions, s=50, cmap='viridis')\n",
        "centers = np.array(list(model.centroids.values()))\n",
        "plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.5)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "SA6RXKFd1FBU",
        "outputId": "cd332b78-dccd-48f2-af4b-29491c79fbc4"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class NeuralNetwork:\n",
        "    def __init__(self, x, y):\n",
        "        self.input      = x\n",
        "        self.weights1   = np.random.rand(self.input.shape[1], 4)  # Weights for the hidden layer (4 neurons)\n",
        "        self.weights2   = np.random.rand(4, 1)                   # Weights for the output layer\n",
        "        self.y          = y\n",
        "        self.output     = np.zeros(self.y.shape)  # Output layer results\n",
        "\n",
        "    def sigmoid(self, z):\n",
        "        return 1 / (1 + np.exp(-z))\n",
        "\n",
        "    def sigmoid_derivative(self, z):\n",
        "        return z * (1 - z)\n",
        "\n",
        "    def feedforward(self):\n",
        "        self.layer1 = self.sigmoid(np.dot(self.input, self.weights1))\n",
        "        self.output = self.sigmoid(np.dot(self.layer1, self.weights2))\n",
        "\n",
        "    def backprop(self):\n",
        "        # Application of the chain rule to find derivative of the loss function with respect to weights2 and weights1\n",
        "        d_weights2 = np.dot(self.layer1.T, (2*(self.y - self.output) * self.sigmoid_derivative(self.output)))\n",
        "        d_weights1 = np.dot(self.input.T,  (np.dot(2*(self.y - self.output) * self.sigmoid_derivative(self.output), self.weights2.T) * self.sigmoid_derivative(self.layer1)))\n",
        "\n",
        "        # Update the weights with the derivative (slope) of the loss function\n",
        "        self.weights1 += d_weights1\n",
        "        self.weights2 += d_weights2\n",
        "\n",
        "    def train(self, iterations):\n",
        "        for i in range(iterations):\n",
        "            self.feedforward()\n",
        "            self.backprop()\n",
        "\n",
        "\n",
        "X = np.array([[0,0,1],\n",
        "                [0,1,1],\n",
        "                [1,0,1],\n",
        "                [1,1,1]])\n",
        "y = np.array([[0],[1],[1],[0]])\n",
        "nn = NeuralNetwork(X,y)\n",
        "\n",
        "nn.train(iterations=1500)\n",
        "print(nn.output)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k_NUG7cW1pAs",
        "outputId": "8f667a9c-175e-424b-b8e3-3a95079ea261"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.00887877]\n",
            " [0.9700102 ]\n",
            " [0.97001992]\n",
            " [0.0367412 ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_pO0Y7rpGhT4"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}