AssociationMeasures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this page we compare performance of 4 different measures of associations. \n",
    "Pearson and tau show only correlation; if they're zero, it does not mean the covariates are independent.'\n",
    "Distance correlation and tau-star, on the other hand, are zero iff the covariates are independent.\n",
    "The tau star is not available in python (to best of my knowledge), but we can use R functions by calling R into\n",
    "python. For this, we would need python 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import scipy as sp\n",
    "import scipy.stats as stats\n",
    "from scipy.spatial.distance import pdist, squareform\n",
    "import copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The distance correlation (https://projecteuclid.org/download/pdfview_1/euclid.aos/1201012979) is a measure of \n",
    "dependence between two variables. The quantity is zero iff the variables are independent. The permutation test pvalues can be evaluated too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "def distcorr(u, v, pval, nruns=500):\n",
    "    \"\"\" Compute the distance correlation function, returning the (permutation) p-value.\n",
    "    reference: https://gist.github.com/wladston/c931b1495184fbb99bec\n",
    "    \"\"\"\n",
    "    X = u.flatten().reshape(-1, 1)\n",
    "    Y = v.flatten().reshape(-1, 1)\n",
    "    n = X.shape[0]\n",
    "    if Y.shape[0] != X.shape[0]:\n",
    "        raise ValueError('Number of samples must match')\n",
    "    a = squareform(pdist(X))\n",
    "    b = squareform(pdist(Y))\n",
    "    A = a - a.mean(axis=0)[None, :] - a.mean(axis=1)[:, None] + a.mean()\n",
    "    B = b - b.mean(axis=0)[None, :] - b.mean(axis=1)[:, None] + b.mean()\n",
    "\n",
    "    dcov2_xy = (A * B).sum() / float(n * n)\n",
    "    dcov2_xx = (A * A).sum() / float(n * n)\n",
    "    dcov2_yy = (B * B).sum() / float(n * n)\n",
    "    dcor = np.sqrt(dcov2_xy) / np.sqrt(np.sqrt(dcov2_xx) * np.sqrt(dcov2_yy))\n",
    "\n",
    "    if pval:\n",
    "        greater = 0.\n",
    "        Y_r = Y.copy()\n",
    "        for i in range(nruns):\n",
    "            np.random.shuffle(Y_r)\n",
    "            if distcorr(X, Y_r, pval=False) >= dcor:\n",
    "                greater += 1\n",
    "        return ([dcor, greater / nruns])\n",
    "    else:\n",
    "        return dcor\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.04922592084371134, 0.8]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.normal(size=(1000,))\n",
    "y = np.random.normal(size=(1000,))\n",
    "print(distcorr(x, y, pval=True, nruns=10))# nruns should be of order of 10000, but say 5 here for quick computations.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tau-star, also known as signed distance correlation, is a measure of dependence. We use R codes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "#####################################################################\n",
    "from rpy2.robjects.packages import importr\n",
    "import rpy2.robjects as ro\n",
    "utils = importr(\"TauStar\")\n",
    "ro.r('library(\"TauStar\")')\n",
    "\n",
    "def taustar(u, v, pval):\n",
    "    \"\"\"\n",
    "    u and v are two columns of continuous variables.\n",
    "    pval is a boolian indicating if the pvalue of the tau_star is interested to be evaluated.\n",
    "    \"\"\"\n",
    "    ro.r('x = c{}'.format(tuple(u)))\n",
    "    ro.r('y = c{}'.format(tuple(v)))\n",
    "    tau_star = ro.r('tStar(x, y)')[0]\n",
    "    if pval == False:\n",
    "        return(tau_star)\n",
    "    elif pval == True:\n",
    "        ro.r('testResults = tauStarTest(x,y)')\n",
    "        pvalue = ro.r('testResults$pVal[1]')[0]\n",
    "        return([float(tau_star), float(pvalue)])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example using the above function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.0001384570762604664, 0.480547183146005]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.normal(size=(1000,))\n",
    "y = np.random.normal(size=(1000,))\n",
    "print(taustar(x, y, pval=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can directly simulate variables in R and run the codes in python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.20851458333092898"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ro.r('x = rnorm(1000)')\n",
    "ro.r('y = rnorm(1000)')\n",
    "ro.r('testResults = tauStarTest(x,y)')\n",
    "ro.r('testResults$pVal')[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pearson correlation is very common but is a measure of statistical correlation not necessarily dependence. The pvalues are easy to calculate without using permutation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def pearson(u, v, pval):\n",
    "    if pval == True:\n",
    "        corr, pval = sp.stats.pearsonr(u, v)\n",
    "        return([float(corr), float(pval)])\n",
    "    else:\n",
    "        return(np.dot(u, v) / (np.linalg.norm(u) * np.linalg.norm(v)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.05027041437360486, 0.11212670182974116]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.normal(size=(1000,))\n",
    "y = np.random.normal(size=(1000,))\n",
    "print(pearson(x, y, pval=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tau measure of signed correlation is another measure of statistical correlation not necessarily dependence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def tau(u, v, pval):\n",
    "    tau, pval = stats.stats.kendalltau(u, v)\n",
    "    if pval == True:\n",
    "        return([float(tau), float(pval)])\n",
    "    else:\n",
    "        return(float(tau))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0059899899899899895\n"
     ]
    }
   ],
   "source": [
    "x = np.random.normal(size=(1000,))\n",
    "y = np.random.normal(size=(1000,))\n",
    "print(tau(x, y, pval=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}