Imputation_Algorithms_PC/LCR-Opt_for_RPi_and_Laptop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "901f4a83",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import time\n",
    "import pandas\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1fd546ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_mae(var: np.ndarray, var_hat: np.ndarray) -> float:\n",
    "    \"\"\"\n",
    "    Compute the Mean Absolute Error (MAE) between two arrays.\n",
    "\n",
    "    Args:\n",
    "        var (np.ndarray): The true values.\n",
    "        var_hat (np.ndarray): The predicted values.\n",
    "\n",
    "    Returns:\n",
    "        float: The MAE.\n",
    "    \"\"\"\n",
    "    mae = (np.sum(np.abs(var - var_hat) / var) / var.shape[0])/10\n",
    "    return mae\n",
    "\n",
    "def compute_rmse(var: np.ndarray, var_hat: np.ndarray) -> float:\n",
    "    \"\"\"\n",
    "    Compute the Root Mean Square Error (RMSE) between two arrays.\n",
    "\n",
    "    Args:\n",
    "        var (np.ndarray): The true values.\n",
    "        var_hat (np.ndarray): The predicted values.\n",
    "\n",
    "    Returns:\n",
    "        float: The RMSE.\n",
    "    \"\"\"\n",
    "    rmse = (np.sqrt(np.sum((var - var_hat) ** 2) / var.shape[0]))/10\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "79b00d7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplacian(n: int, tau: int) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Compute the discrete Laplacian operator.\n",
    "\n",
    "    Args:\n",
    "        n (int): The size of the Laplacian operator.\n",
    "        tau (int): The parameter for the Laplacian.\n",
    "\n",
    "    Returns:\n",
    "        np.ndarray: The Laplacian operator.\n",
    "    \"\"\"\n",
    "    ell = np.zeros(n)\n",
    "    ell[0] = 2 * tau\n",
    "    for k in range(tau):\n",
    "        ell[k + 1] = -1\n",
    "        ell[-k - 1] = -1\n",
    "    return ell\n",
    "\n",
    "def prox(z: np.ndarray, w: np.ndarray, lmbda: float, denominator: np.ndarray) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Compute the proximal operator.\n",
    "\n",
    "    Args:\n",
    "        z (np.ndarray): Input array.\n",
    "        w (np.ndarray): Input array.\n",
    "        lmbda (float): Regularization parameter.\n",
    "        denominator (np.ndarray): Denominator array.\n",
    "\n",
    "    Returns:\n",
    "        np.ndarray: Result of the proximal operator.\n",
    "    \"\"\"\n",
    "    T = z.shape[0]\n",
    "    temp = np.fft.fft(lmbda * z - w) / denominator\n",
    "    temp1 = 1 - T / (lmbda * np.abs(temp))\n",
    "    temp1[temp1 <= 0] = 0\n",
    "    return np.fft.ifft(temp * temp1).real\n",
    "\n",
    "def update_z(y_train: np.ndarray, pos_train: np.ndarray, x: np.ndarray, w: np.ndarray, lmbda: float, eta: float) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Update the variable z.\n",
    "\n",
    "    Args:\n",
    "        y_train (np.ndarray): The training data.\n",
    "        pos_train (np.ndarray): Boolean array indicating positive training examples.\n",
    "        x (np.ndarray): Input variable.\n",
    "        w (np.ndarray): Weight variable.\n",
    "        lmbda (float): Regularization parameter.\n",
    "        eta (float): Learning rate parameter.\n",
    "\n",
    "    Returns:\n",
    "        np.ndarray: Updated z.\n",
    "    \"\"\"\n",
    "    z = x + w / lmbda\n",
    "    z[pos_train] = (lmbda / (lmbda + eta) * z[pos_train] \n",
    "                    + eta / (lmbda + eta) * y_train)\n",
    "    return z\n",
    "\n",
    "def update_w(x: np.ndarray, z: np.ndarray, w: np.ndarray, lmbda: float) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Update the variable w.\n",
    "\n",
    "    Args:\n",
    "        x (np.ndarray): Input variable.\n",
    "        z (np.ndarray): Input variable.\n",
    "        w (np.ndarray): Weight variable.\n",
    "        lmbda (float): Regularization parameter.\n",
    "\n",
    "    Returns:\n",
    "        np.ndarray: Updated w.\n",
    "    \"\"\"\n",
    "    return w + lmbda * (x - z)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "24ec6bbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LCR(y_true: np.ndarray, y: np.ndarray, lmbda: float, gamma: float, tau: int, maxiter: int = 50) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    LCR (Laplacian Constrained Regression) algorithm.\n",
    "\n",
    "    Args:\n",
    "        y_true (np.ndarray): The true target values.\n",
    "        y (np.ndarray): The input values.\n",
    "        lmbda (float): Regularization parameter.\n",
    "        gamma (float): Gamma parameter.\n",
    "        tau (int): Tau parameter.\n",
    "        maxiter (int, optional): Maximum number of iterations. Default is 50.\n",
    "\n",
    "    Returns:\n",
    "        np.ndarray: The result of the LCR algorithm.\n",
    "    \"\"\"\n",
    "    eta = 100 * lmbda\n",
    "    T = y.shape[0]\n",
    "    pos_train = np.where(y != 0)\n",
    "    y_train = y[pos_train]\n",
    "    pos_test = np.where((y_true != 0) & (y == 0))\n",
    "    y_test = y_true[pos_test]\n",
    "    z = y.copy()\n",
    "    w = y.copy()\n",
    "    denominator = lmbda + gamma * np.fft.fft(laplacian(T, tau)) ** 2\n",
    "    T = y_true.shape[0]\n",
    "    del y_true, y\n",
    "    show_iter = 10\n",
    "    for it in range(maxiter):\n",
    "        x = prox(z, w, lmbda, denominator)\n",
    "        z = update_z(y_train, pos_train, x, w, lmbda, eta)\n",
    "        w = update_w(x, z, w, lmbda)\n",
    "    print(f'lambda: {lmbda/T}, gamma: {gamma/lmbda}, tau: {tau}')\n",
    "    mae_accuracy = compute_mae(y_test, x[pos_test])\n",
    "    rmse_accuracy = compute_rmse(y_test, x[pos_test])\n",
    "    print(f'MAE Accuracy: {mae_accuracy}')\n",
    "    print(f'RMSE Accuracy: {rmse_accuracy}')\n",
    "    print(mae_accuracy)\n",
    "    print(rmse_accuracy)\n",
    "    print()\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f3de5232",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Batch size for data processing\n",
    "batch_size = 20\n",
    "\n",
    "# Percentage of missingness in the data\n",
    "missing_rate = 0.20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "bfe34d5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lambda: 0.005, gamma: 2.0, tau: 3\n",
      "MAE Accuracy: 0.0020405227652069316\n",
      "RMSE Accuracy: None\n",
      "0.0020405227652069316\n",
      "None\n",
      "\n",
      "--- 0.003003835678100586 seconds ---\n",
      "lambda: 0.005, gamma: 2.0, tau: 3\n",
      "MAE Accuracy: 0.0036882427102335968\n",
      "RMSE Accuracy: None\n",
      "0.0036882427102335968\n",
      "None\n",
      "\n",
      "--- 0.002001523971557617 seconds ---\n",
      "lambda: 0.005, gamma: 2.0, tau: 3\n",
      "MAE Accuracy: 0.00864282895832395\n",
      "RMSE Accuracy: None\n",
      "0.00864282895832395\n",
      "None\n",
      "\n",
      "--- 0.001997709274291992 seconds ---\n",
      "lambda: 0.005, gamma: 2.0, tau: 3\n",
      "MAE Accuracy: 0.0066483516483517\n",
      "RMSE Accuracy: None\n",
      "0.0066483516483517\n",
      "None\n",
      "\n",
      "--- 0.0019788742065429688 seconds ---\n"
     ]
    }
   ],
   "source": [
    "# Path to the folder containing datasets\n",
    "dataset_folder = \"./Datasets_Sample\"\n",
    "\n",
    "# Loop through all files in the folder\n",
    "for filename in os.listdir(dataset_folder):\n",
    "    if filename.endswith(\".csv\"):\n",
    "        dataset_path = os.path.join(dataset_folder, filename)\n",
    "\n",
    "        # Load data from CSV using your custom function with specified batch size\n",
    "        df = pandas.read_csv(dataset_path,nrows=batch_size)\n",
    "        original_mat = df.to_numpy()\n",
    "        original_data = original_mat[:,0]\n",
    "\n",
    "        # Measure the start time for execution time calculation\n",
    "        start_time = time.monotonic()\n",
    "\n",
    "        # Find length of input data\n",
    "        L = original_data.shape[0]\n",
    "        np.random.seed(1)\n",
    "\n",
    "        # Introduce missingness\n",
    "        missing_vec = original_data * np.round(np.random.rand(L) + 0.5 - missing_rate)\n",
    "        start_time = time.time()\n",
    "\n",
    "        # Set LCR variable values\n",
    "        lmbda = 5e-3 * L\n",
    "        gamma = 2 * lmbda\n",
    "        tau = 3\n",
    "        maxiter = 100\n",
    "        x = LCR(original_data, missing_vec, lmbda, gamma, tau, maxiter)\n",
    "        end_time = time.monotonic()\n",
    "        elapsed_time_seconds = end_time - start_time\n",
    "        elapsed_time_ms = elapsed_time_seconds * 1000\n",
    "        print(\"--- %s seconds ---\" % (time.time() - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac90b433",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}