Singular Value Decomposition Example 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8f38e99f",
   "metadata": {},
   "source": [
    "### Singular Value Decomposition Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "54d38faf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.linalg import svd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a1c79dfa-e8ec-4bb6-906e-0d633441d59e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.498160</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.927976</td>\n",
       "      <td>3.394634</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.623978</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.404460</td>\n",
       "      <td>3.83229</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.082338</td>\n",
       "      <td>4.879639</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.849356</td>\n",
       "      <td>1.72730</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2.216969</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.727780</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.447412</td>\n",
       "      <td>1.557975</td>\n",
       "      <td>2.168579</td>\n",
       "      <td>2.465447</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2         3        4\n",
       "0  2.498160       NaN  3.927976  3.394634      NaN\n",
       "1  1.623978       NaN       NaN  3.404460  3.83229\n",
       "2  1.082338  4.879639       NaN  1.849356  1.72730\n",
       "3       NaN  2.216969       NaN  2.727780      NaN\n",
       "4  3.447412  1.557975  2.168579  2.465447      NaN"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a sample matrix with uniform random float numbers between 1 and 5\n",
    "np.random.seed(42)\n",
    "matrix = np.random.uniform(1, 5, size = (5, 5))\n",
    "\n",
    "# Randomly assign NaN values\n",
    "matrix[np.random.random(matrix.shape) < 0.3] = np.nan\n",
    "\n",
    "# Create a DataFrame from the matrix\n",
    "df = pd.DataFrame(matrix)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d503f7cb-8a21-4ed5-a17a-a6f0ba3e5cd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def svd_impute(matrix, k):\n",
    "\n",
    "    \"\"\"\n",
    "    Impute missing values in a matrix using Singular Value Decomposition.\n",
    "\n",
    "    Parameters:\n",
    "    - matrix: Input matrix with missing values\n",
    "    - k: Number of singular values and vectors to use for reconstruction\n",
    "    \n",
    "    Returns:\n",
    "    - Matrix with imputed values\n",
    "    \"\"\"\n",
    "\n",
    "    # Fill NaN values in the matrix with the mean of each column\n",
    "    filled_matrix = np.where(np.isnan(matrix), np.nanmean(matrix, axis = 0), matrix)\n",
    "    \n",
    "    # Perform Singular Value Decomposition\n",
    "    U, s, Vt = svd(filled_matrix, full_matrices = False)\n",
    "\n",
    "    print(\"\\nSigma matrix:\")\n",
    "    print(s)\n",
    "\n",
    "    # Reconstruct matrix using top k singular values and vactors\n",
    "    reconstructed = np.dot(U[:, :k], np.dot(np.diag(s[:k]), Vt[:k, :]))\n",
    "\n",
    "    # Replace the NaN values in the filled_matrix with the corresponding values from the reconstructed matrix\n",
    "    filled_matrix[np.isnan(matrix)] = reconstructed[np.isnan(matrix)]\n",
    "    \n",
    "    return filled_matrix, s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "50fd0689-48af-4bcb-aa68-9232b2f18b67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Sigma matrix:\n",
      "[13.79267417  3.16189592  1.46989499  0.95074141  0.15299826]\n",
      "\n",
      "Imputed matrix:\n",
      "          0         1         2         3         4\n",
      "0  2.498160  3.102215  3.927976  3.394634  3.231569\n",
      "1  1.623978  2.991536  3.330003  3.404460  3.832290\n",
      "2  1.082338  4.879639  3.200333  1.849356  1.727300\n",
      "3  2.266037  2.216969  2.839124  2.727780  2.791106\n",
      "4  3.447412  1.557975  2.168579  2.465447  2.967974\n",
      "\n",
      "Imputed matrix (imputed values in brackets):\n",
      "         0        1        2      3        4\n",
      "0    2.498  [3.102]    3.928  3.395  [3.232]\n",
      "1    1.624  [2.992]  [3.330]  3.404    3.832\n",
      "2    1.082    4.880  [3.200]  1.849    1.727\n",
      "3  [2.266]    2.217  [2.839]  2.728  [2.791]\n",
      "4    3.447    1.558    2.169  2.465  [2.968]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\wodnj\\AppData\\Local\\Temp\\ipykernel_16628\\3386823579.py:40: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '2.498' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n",
      "  highlight_df.iloc[i, j] = f\"{highlight_df.iloc[i, j]:.3f}\"\n",
      "C:\\Users\\wodnj\\AppData\\Local\\Temp\\ipykernel_16628\\3386823579.py:38: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '[3.102]' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n",
      "  highlight_df.iloc[i, j] = f\"[{highlight_df.iloc[i, j]:.3f}]\"\n",
      "C:\\Users\\wodnj\\AppData\\Local\\Temp\\ipykernel_16628\\3386823579.py:40: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '3.928' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n",
      "  highlight_df.iloc[i, j] = f\"{highlight_df.iloc[i, j]:.3f}\"\n",
      "C:\\Users\\wodnj\\AppData\\Local\\Temp\\ipykernel_16628\\3386823579.py:40: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '3.395' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n",
      "  highlight_df.iloc[i, j] = f\"{highlight_df.iloc[i, j]:.3f}\"\n",
      "C:\\Users\\wodnj\\AppData\\Local\\Temp\\ipykernel_16628\\3386823579.py:38: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '[3.232]' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n",
      "  highlight_df.iloc[i, j] = f\"[{highlight_df.iloc[i, j]:.3f}]\"\n"
     ]
    }
   ],
   "source": [
    "# Perform Singular Value Decomposition imputation\n",
    "k = 2  # Number of singular values to use\n",
    "imputed_matrix, Sigma = svd_impute(matrix, k) # Impute the missing values in the matrix using SVD\n",
    "\n",
    "# Clip values to ensure they stay within 1 to 5\n",
    "imputed_matrix = np.clip(imputed_matrix, 1, 5)\n",
    "\n",
    "# Convert the imputed matrix into a DataFrame\n",
    "df_imputed = pd.DataFrame(imputed_matrix)\n",
    "\n",
    "print(\"\\nImputed matrix:\")\n",
    "print(df_imputed)\n",
    "\n",
    "# Create a mask to identify the positions of the original NaN values in the matrix\n",
    "imputed_mask = np.isnan(matrix)\n",
    "\n",
    "def highlight_imputed(matrix, imputed_matrix, mask):\n",
    "        \n",
    "    \"\"\"\n",
    "    Highlight imputed values in the DataFrame.\n",
    "\n",
    "    Parameters:\n",
    "    - matrix: Original DataFrame with NaN values\n",
    "    - imputed_matrix: Imputed matrix with filled values\n",
    "    - mask: Boolean mask identifying original NaN positions\n",
    "\n",
    "    Returns:\n",
    "    - DataFrame with imputed values highlighted\n",
    "    \"\"\"\n",
    "\n",
    "    # Create a new DataFrame for highlighting\n",
    "    highlight_df = pd.DataFrame(imputed_matrix, columns = matrix.columns)\n",
    "    \n",
    "    # If the original value was NaN, format it with brackets\n",
    "    for i in range(matrix.shape[0]):\n",
    "        for j in range(matrix.shape[1]):\n",
    "            if mask[i, j]:\n",
    "                highlight_df.iloc[i, j] = f\"[{highlight_df.iloc[i, j]:.3f}]\"\n",
    "            else:\n",
    "                highlight_df.iloc[i, j] = f\"{highlight_df.iloc[i, j]:.3f}\"\n",
    "\n",
    "    return highlight_df\n",
    "\n",
    "# Highlight imputed values in the DataFrame\n",
    "highlighted_imputed_matrix = highlight_imputed(df, df_imputed, imputed_mask)\n",
    "print(\"\\nImputed matrix (imputed values in brackets):\")\n",
    "print(highlighted_imputed_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "379511ea",
   "metadata": {},
   "source": [
    "Way to determine K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "74707eab-4c1a-4180-b4ed-131fe2080b40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9.35641949e-01 4.91708678e-02 1.06263802e-02 4.44567339e-03\n",
      " 1.15129265e-04]\n",
      "[0.93564195 0.98481282 0.9954392  0.99988487 1.        ]\n"
     ]
    }
   ],
   "source": [
    "squared_values = Sigma ** 2 # Square the singular values\n",
    "total_variance = np.sum(squared_values) # Calculate the total variance\n",
    "variance_explained = squared_values / total_variance # Calculate the variance explained by each singular value\n",
    "cumulative_variance = np.cumsum(variance_explained) # Calculate the cumulative variance explained by the singular values\n",
    "\n",
    "print(variance_explained)\n",
    "print(cumulative_variance)"
   ]
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}