CPCA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "FFF.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyP3Q/fIFi+JLNYzDnvmwSsq",
      "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/srishti-git1110/Contrastive-PCA/blob/main/FFF.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kfZ3hGHRmwyI"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from numpy import array\n",
        "from numpy import linalg as la\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn import cluster\n",
        "from math import pi\n",
        "from math import sqrt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "VO7XmUPnnszk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Some variable description - \n",
        "\n",
        "*n_components* = no of principal components\n",
        "\n",
        "*n_alphas* = 40 (default) acc to paper no of potential alphas to be tested\n",
        "\n",
        "*max_log_alpha* = 3 (default) acc to paper 40 equally spaces values of alphas between 10^-1 and 10^max_log_alpha\n",
        "\n",
        "*active_labels* = classes/clusters/sources of variation of interest"
      ],
      "metadata": {
        "id": "m2bqLnV4nx6T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#some synthetic data\n",
        "N = 400\n",
        "D = 30\n",
        "\n",
        "#background\n",
        "B = np.zeros((N, D))\n",
        "B[:,0:10] = np.random.normal(0.5,11,(N,10))\n",
        "B[:,10:20] = np.random.normal(0.5,3,(N,10))\n",
        "B[:,20:30] = np.random.normal(0.5,1,(N,10))\n",
        "\n",
        "\n",
        "#target\n",
        "A = np.zeros((N, D))\n",
        "A[:,0:10] = np.random.normal(0.5,11,(N,10))\n",
        "\n",
        "A[0:100, 10:20] = np.random.normal(0.5,1,(100,10))\n",
        "A[0:100, 20:30] = np.random.normal(0.5,1,(100,10))\n",
        "\n",
        "A[100:200, 10:20] = np.random.normal(0.5,1,(100,10))\n",
        "A[100:200, 20:30] = np.random.normal(3.5,1,(100,10))\n",
        "\n",
        "A[200:300, 10:20] = np.random.normal(7,1,(100,10))\n",
        "A[200:300, 20:30] = np.random.normal(0.5,1,(100,10))\n",
        "\n",
        "A[300:400, 10:20] = np.random.normal(7,1,(100,10))\n",
        "A[300:400, 20:30] = np.random.normal(3.5,1,(100,10))\n"
      ],
      "metadata": {
        "id": "y0J-4LzWntBl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class C_PCA(object):\n",
        "    \n",
        "    def __init__(self, standardize = False, n_components = 2):\n",
        "        self.standardize = standardize\n",
        "        self.n_components = n_components\n",
        "    \n",
        "    \n",
        "    def standardize_array(self, array):\n",
        "        #standardize 'array' in the range 0-1\n",
        "        standardized_array =  (array - np.nanmean(array, axis=0)) / np.std(array, axis=0)\n",
        "        return np.nan_to_num(standardized_array)\n",
        "    \n",
        "    \n",
        "    def transform(self, dataset, plot=True, n_alphas=40, alpha_selection='auto', max_log_alpha=3, n_alphas_to_return=5, active_labels=None, colors=None, legend=None, alpha_value=None):\n",
        "        \n",
        "        #checking parameter compatibilty\n",
        "        if (plot==True and not(self.n_components==2)):\n",
        "            raise ValueError(\"Cannot show higher than 2D plots\")\n",
        "        if not(alpha_selection=='auto' or alpha_selection=='manual' or alpha_selection=='all'):\n",
        "            raise ValueError(\"Invalid value for parameter alpha_selection - should be either of 'auto' , 'manual' or 'all'\")\n",
        "        if (alpha_selection=='all' and plot==True):\n",
        "            raise ValueError(\"Plot cannot be True if alpha selection is all: either select another value for alpha_selection or set plot to false\")\n",
        "        if (alpha_value==None and alpha_selection=='manual'):\n",
        "            raise ValueError(\"alpha_value missing in function call\")\n",
        "        if colors is None:\n",
        "                 self.colors = ['b','g','k','r'] #4 colors == atmost 4 labels shall be visually distingushable; used in plotting \n",
        "\n",
        "        if plot:\n",
        "            if active_labels is None:\n",
        "                active_labels = np.ones(dataset.shape[0])\n",
        "            self.active_labels = active_labels\n",
        "            \n",
        "            if (alpha_selection == 'auto'):\n",
        "                transformed_data, best_alphas = self.auto_cpca(dataset, n_alphas, max_log_alpha, n_alphas_to_return) #performs spectral clustering on affinity matrix + cPCA to return\n",
        "                                                                                                                   #a list of alphas and corresponding data projected to cPCs \n",
        "                plt.figure(figsize=[14,4])\n",
        "                for j, data in enumerate(transformed_data):\n",
        "                    data = np.array(data)\n",
        "                    plt.subplot(1,5,j+1)\n",
        "                    unique_labels = np.sort(np.unique(self.active_labels))\n",
        "                    for i, label in enumerate(unique_labels):\n",
        "                        voi = np.where(self.active_labels == label)\n",
        "                        plt.scatter(data[voi,0], data[voi,1], color=self.colors[i], marker='P', alpha=0.5, label='Cateogry- '+str(label))\n",
        "                        \n",
        "                    plt.title('alpha = ' +str(best_alphas[j]))\n",
        "                if (len(unique_labels) > 1):\n",
        "                    plt.legend()\n",
        "                plt.show()\n",
        "                \n",
        "            elif (alpha_selection == 'manual'):\n",
        "                data = self.cpca_alpha(dataset=dataset, alpha=alpha_value)\n",
        "                data = np.array(data)\n",
        "                plt.figure(figsize=[5,5])\n",
        "                for i, label in enumerate(np.sort(np.unique(self.active_labels))):\n",
        "                  voi = np.where(self.active_labels==label)\n",
        "                  plt.scatter(data[voi,0], data[voi,1], color=self.colors[i], alpha=0.5, label='Class '+str(i))\n",
        "                plt.title('alpha = '+str(alpha_value))\n",
        "                if len(np.unique(self.active_labels))>1:\n",
        "                    plt.legend()\n",
        "                plt.show()\n",
        "                \n",
        "\n",
        "            return\n",
        "        \n",
        "        #following else gets executed if plots aren't displayed, plot = False\n",
        "        else:\n",
        "            if (alpha_selection == 'auto'):\n",
        "                transformed_data, best_alphas = self.auto_cpca(dataset, n_alphas, max_log_alpha, n_alphas_to_return)\n",
        "                alphas = best_alphas\n",
        "            elif (alpha_selection == 'all'):\n",
        "                transformed_data, all_alphas = self.all_cpca(dataset, n_alphas, max_log_alpha)\n",
        "                alphas = all_alphas\n",
        "            else:\n",
        "                transformed_data = self.cpca_alpha(dataset, alpha_value)\n",
        "                alphas = alpha_value\n",
        "        return transformed_data, alphas\n",
        "                \n",
        "        \n",
        "    def fit(self, target_set, background_set, preprocess_by_pca_ndim = None):\n",
        "        self.affinity_matrix = None\n",
        "\n",
        "        # Datasets and sizes\n",
        "        self.tg = target_set\n",
        "        self.bg = background_set\n",
        "        self.n_tg, self.dim_tg = target_set.shape\n",
        "        self.n_bg, self.dim_bg = background_set.shape\n",
        "\n",
        "        if not(self.dim_tg == self.dim_bg):\n",
        "            raise ValueError(\"Target and background datasets are of unequal dimensionality/number of features.\")\n",
        "\n",
        "        #Centering & standardizing both datasets\n",
        "        self.tg = self.tg - np.nanmean(self.tg, axis=0)\n",
        "        if self.standardize:\n",
        "            self.tg = self.standardize_array(self.tg)\n",
        "            \n",
        "        self.bg = self.bg - np.nanmean(self.bg, axis=0)\n",
        "        if self.standardize:\n",
        "            self.bg = self.standardize_array(self.bg)\n",
        "            \n",
        "        #if original dimensionality is higher than 1000 or value provided by user, PCA is used on concatenated tg+bg to reduce the dimensionality to\n",
        "        #1000 or value provided by user\n",
        "        \n",
        "        if preprocess_by_pca_ndim is None:\n",
        "            preprocess_by_pca_ndim = 1000\n",
        "\n",
        "        if (self.dim_bg > preprocess_by_pca_ndim):\n",
        "            data = np.concatenate((self.tg, self.bg), axis=0)\n",
        "            pca = PCA(n_components = preprocess_by_pca_ndim) \n",
        "            data = pca.fit_transform(data)\n",
        "            \n",
        "            #separating datasets after std. PCA\n",
        "            self.tg = data[:self.n_tg,:]\n",
        "            self.bg = data[self.n_tg:,:]\n",
        "            self.dim_tg = preprocess_by_pca_ndim\n",
        "\n",
        "        \n",
        "        #covariance matrices of centered data\n",
        "        self.tg_cov = self.tg.T.dot(self.tg) / (self.n_tg - 1)\n",
        "        self.bg_cov = self.bg.T.dot(self.bg) / (self.n_bg - 1)\n",
        "        \n",
        "\n",
        "        \n",
        "    def cpca_alpha(self, dataset, alpha=1):\n",
        "        n_components = self.n_components\n",
        "        optimise = self.tg_cov - alpha*self.bg_cov\n",
        "        optimise = optimise.astype('float64')\n",
        "                      \n",
        "        try:\n",
        "            w, v = la.eig(optimise)             #v-matrix of evec, cols are vectors; w isn't sorted\n",
        "        except np.linalg.LinAlgError:\n",
        "            print(\"The eigenvalue computation does not converge.\")\n",
        "                      \n",
        "        \n",
        "        eig_ = np.argpartition(w, -n_components)[-n_components:]\n",
        "        eig_ = eig_[np.argsort(-w[eig_])]\n",
        "        top_vect = v[:, eig_]\n",
        "        \n",
        "        reduced_set = dataset.dot(top_vect)\n",
        "        reduced_set[:,0] = reduced_set[:,0]*np.sign(reduced_set[0,0])\n",
        "        reduced_set[:,1] = reduced_set[:,1]*np.sign(reduced_set[0,1])\n",
        "        return reduced_set\n",
        "    \n",
        "    \n",
        "                      \n",
        "    def auto_cpca(self, dataset, n_alphas, max_log_alpha, n_alphas_to_return):\n",
        "        best_alphas, all_alphas, _, _ = self.find_spectral_alphas(max_log_alpha, n_alphas, n_alphas_to_return)\n",
        "        best_alphas = np.concatenate(([0], best_alphas)) \n",
        "        data_to_plot = []\n",
        "        for alpha in best_alphas: \n",
        "            data_to_plot.append(self.cpca_alpha(dataset=dataset, alpha=alpha))\n",
        "        return data_to_plot, best_alphas\n",
        "\n",
        "        \n",
        "                      \n",
        "    def find_spectral_alphas(self, max_log_alpha, n_alphas, n_alphas_to_return):\n",
        "        self.create_affinity_matrix(max_log_alpha, n_alphas)\n",
        "        affinity = self.affinity_matrix\n",
        "        spectral = cluster.SpectralClustering(affinity = 'precomputed', n_clusters = n_alphas_to_return)\n",
        "        alphas = list(np.concatenate(([0],np.logspace(-1, max_log_alpha, n_alphas))))\n",
        "        \n",
        "        spectral.fit(affinity)\n",
        "        spec_labels = spectral.labels_\n",
        "        best_alphas = []\n",
        "        for i in range(n_alphas_to_return):\n",
        "            \n",
        "            lst = np.where(spec_labels == i)[0]\n",
        "            if not(0 in lst): #we manually include alpha=0 for PCA in auto_cpca, exclude here\n",
        "                submatrix = affinity[lst][:, lst]\n",
        "                aff_sum = np.nansum(submatrix, axis=0)\n",
        "                l = lst[np.argmax(aff_sum)]\n",
        "                best_alphas = best_alphas + [alphas[l]]\n",
        "                \n",
        "        return np.sort(best_alphas), alphas, affinity[0,:], spec_labels\n",
        "                      \n",
        "                      \n",
        "    def create_affinity_matrix(self, max_log_alpha, n_alphas):\n",
        "        alphas = np.concatenate(([0], np.logspace(start=-1, stop=max_log_alpha, num=n_alphas))) #alpha=0 included to compare with std. PCA\n",
        "        subspaces = list()\n",
        "        k = len(alphas)\n",
        "        affinity = 0.5*np.identity(k)\n",
        "        for alpha in alphas:\n",
        "            space = self.cpca_alpha(dataset=self.tg, alpha=alpha) #stores reduced set for a particular alpha\n",
        "            q, r = la.qr(space) #QR decompose - Q orthonormal matrix R upper triang matrix\n",
        "            subspaces.append(q)\n",
        "        \n",
        "        for i in range(k):\n",
        "            for j in range(i+1, k):\n",
        "                q0 = subspaces[i]\n",
        "                q1 = subspaces[j]\n",
        "                u, s, v = np.linalg.svd(q0.T.dot(q1)) #singular value decomposition\n",
        "                affinity[i,j] = s[0]*s[1]\n",
        "                      \n",
        "        affinity = affinity + affinity.T\n",
        "        self.affinity_matrix = np.nan_to_num(affinity)\n",
        "        \n",
        "\n",
        "                      \n",
        "    def fit_transform(self, target, background, plot=False, alpha_selection='auto', n_alphas=40,  max_log_alpha=3, n_alphas_to_return=5, active_labels = None, colors=None, legend=None, alpha_value=None, return_alphas=False):\n",
        "        self.fit(target, background)\n",
        "        return self.transform(dataset=self.tg, alpha_selection=alpha_selection, n_alphas=n_alphas, max_log_alpha=max_log_alpha, n_alphas_to_return=n_alphas_to_return, plot=plot, active_labels=active_labels, colors=colors, legend=legend, alpha_value=alpha_value)         \n",
        "    \n",
        "                      \n",
        "    #methods to return c_pca object attributes ()\n",
        "    def get_bg_data(self):\n",
        "        return self.bg\n",
        "    def get_tg_data(self):\n",
        "        return self.tg\n",
        "    def get_affinity_matrix(self):\n",
        "        return self.affinity_matrix\n",
        "    def get_active_labels(self):\n",
        "        return self.active_labels\n",
        "    \n",
        "\n",
        "obj1 = C_PCA()\n",
        "active_labels = []\n",
        "for i in range(100):\n",
        "  active_labels.append(0)\n",
        "for i in range(100):\n",
        "  active_labels.append(1)\n",
        "for i in range(100):\n",
        "  active_labels.append(2)\n",
        "for i in range(100):\n",
        "  active_labels.append(3)\n",
        "\n",
        "obj1.fit_transform(target=A, background=B, plot=True, active_labels=np.array(active_labels)) #, alpha_selection='manual', alpha_value=0.0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "XuaU5TLmntEa",
        "outputId": "191220d4-e7b8-4e82-f3d2-28fe3bbb5600"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1008x288 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n"
      ],
      "metadata": {
        "id": "DH2s3b67ntHF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "With alpha=0.0, cPCA reduces to standard PCA.\n",
        "\n",
        "We, hence see that PCA wasn't able to capture the variance between different cateogries, as the first 10 dimensions in target data are significantly larger in variance than the rest; and so PCs are selected from these thus making no difference between subgroups.\n",
        "\n",
        "With small alphas (alpha=0.52233 here), these first 10 features get cancelled by background data (as they are high in variance in the background data as well), and cPCA is able to distinguish green/blue from red/black as it now selects from middle 10 features as these are lesser in variance (in background) than the first 10. Also, middle 10 features are fairly variable in target data.\n",
        "\n",
        "It is of interest to note that the last 10 features are even lesser in variance (in background) as compared to middle 10, but cPCA doesn't select from these ones for mildly higher (than 0) values of alpha. But as we go on to penalise more by increasing alpha, even lesser variance from background would be required and these shall come into the picture.\n",
        "\n",
        "\n",
        "\n",
        "With an intermediate value of alpha (middle scatter plot), cPCA is able to cluster all four cateogries as now it is now selects from last 20 features.\n",
        "It could be because the last 20 features taken together are highly variable in target data while they aren't a lot in background data. this is the sweet spot of the tradeoff.\n",
        "\n",
        "With even higher alphas, those features shall be chosen from, that have the least variance in background data (i.e. last 10), and so we are able to distinguish between red-green and black-blue. Here the algo cares more about selecting features with very small variance in background data as compared to caring about selecting features with high variance in target data, hence the observed behaviour) \n",
        "\n",
        "(It should be clear from the way artifical data is generated that why last 10 are good to cluster red-green from black-blue and the same for middle 10. In the artifical data first 100 points are blue cateogry, next 100 green, next 100 black and last 100 red, also clear from the legend in plots.\n",
        "Middle 10 features have the same distribution for green and blue which is different from the common distribution for red and black.\n",
        "Similarly, last 10 have the same distribution for blue black which is different from the common distribution for red and green.)\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "coF9ppFNBW8A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "Tvmk2hypFnsT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Write up: Discuss what kind of dataset it would make sense to use Contrastive PCA on.**\n",
        "\n",
        "*Intro:*\n",
        "\n",
        "Information of interest lies in variability - The basic assumption/principle Standard PCA is based on. PCA exploits this assumption that the most interesting (i.e. informative) directions of any data are the ones along which the data varies the most.  \n",
        "\n",
        "  \n",
        "   \n",
        "\n",
        "\n",
        "*When does PCA fails to prove useful?* \n",
        "\n",
        "However, there might be cases when the most variable directions aren’t of prime interest to the analyst; and rather some other directions with less dominant variance across the dataset are. In other words, due to the nature of the data source or data collection or any other reasons, there might be some inherent but uninteresting variation present in the data that might dominate over the interesting source of variation.\n",
        "   \n",
        "     \n",
        "      \n",
        "\n",
        "*Why not PCA?*\n",
        "\n",
        "In such (and similar) cases, PCA shall fail to provide the best projections as desired by the analyst as it would choose those directions to project the data along which the data varies the most across the space & that corresponds to the most dominant source of variance.  \n",
        "   \n",
        "    \n",
        "\n",
        "\n",
        "*How to use cPCA to mitigate this?*\n",
        "\n",
        "The key here is to use a background data carrying the same or similar type of universal variation as the target data but free from the variability that needs to be analysed/that’s of interest. \n",
        "This way the background data can be used to cancel out the universal variation in the target data so that the (contrastive) Principal components shall now represent the variability stemming from our source of interest and that is unique to the target data. cPCA captures those components that are high in vaqriance in the target data but low in variance in the background data i.e. information exclusive to target data.\n",
        "\n",
        "\n",
        "   \n",
        "\n",
        "\n",
        "*Summary:*\n",
        "\n",
        "In short, while PCA brings out the most interesting directions in a single dataset, cPCA brings out ‘the most interesting differences across datasets’.\n",
        "\n",
        "Target data = confounders + interesting source of variation\n",
        "Background data = All known confounders matched with target data\n",
        "\n",
        "(confounders = uninteresting/undesired sources of variation)\n",
        "  \n",
        "\n",
        "\n",
        "*Examples/Use cases:*\n",
        "\n",
        "**Treatment control settings -** In an experiment to test the difference in effects of various types of fertiliser treatments on crops (assuming the experimental conditions eg. humidity, temperature, concentration of treatments etc. remain same throughout), the features in the target set, which is the crops subjected to treatment are subjected to two sources of variation - inherent variation in crops (breed etc) and variation due to treatments.\n",
        "\n",
        "If in case, the variation between crops is dominant, then the first few components by standard PCA shall represent a notion of features good enough to classify types of crops rather than types of treatments. (This is just to explain in other words; this shouldn't imply that PCs shall give a good accuracy score if used as features in a supervised classification algo)\n",
        "\n",
        "Here a control set - crops subjected to no treatment - shall also contain the inherent variability in crops and could be used to cancel out this variation & hence to project the data in such dimensions that are capable of differentiating between different classes of treatments. \n",
        "\n",
        "  \n",
        "   \n",
        "\n",
        "**Subgroups in a Population -** We might want to project our data onto such dimensions that are capable of clustering (or classifying) subgroups within a heterogeneous population. But, it might occur that the intra-group variation is dominant over the inter-group variation in which PCA shall be inclined towards the former.\n",
        "\n",
        "cPCA with the background data as one of the groups can be used to cancel out intra-group variation and thus obtain dimensions that are useful as axes to cluster different groups.\n",
        " \n",
        "\n",
        "  \n",
        "\n",
        "**Effect of a single medicine across subjects -** If subjects with different demographic profiles are given a medicine, one might be interested in exploring different ways the same medicine reacts on different subjects. Here there are two sources of variability in the treatment group - variation due to demography and variation due to different effects of medicine.\n",
        " A control group representing similar demographic profiles in subjects can be used to eliminate this source of variation from the target data.\n",
        "  \n",
        "\n",
        "\n",
        "\n",
        "**Change in experimental conditions** - An exactly same treatment can react differently on a single subject under different experimental conditions; this is called variation due to noise that we want to avoid. In order to capture only the signal variation, we can observe the subjects under different experimental conditions as the control data to cancel out the noisy variation in the target data.\n",
        "\n",
        " \n",
        "\n",
        "**Changes in structure of variation over time -** In any experiment setup, we might want to investigate changes in variance structure over time. At time t we might want to visualise data on those projections that have undergone change in variance structure from anytime before, say t - k. We can use the data from time t-k to cancel out the variation that’s persistent from the past & that can help us with any new type of variation that might have been introduced in the setup over time.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "MrOccGzS-qSI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "-tCYLRLAntNC"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}