emp_and_sims_nb_pgls.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Phylogenetic generalized least squares model fit for quartet data\n",
    "\n",
    "--------------------------\n",
    "\n",
    "```\n",
    "Manuscript: \"Misconceptions on Missing Data in RAD-seq Phylogenetics\"\n",
    "Notebook author: Deren Eaton \n",
    "Contact: deren.eaton@yale.edu\n",
    "Date: 8/16/2016\n",
    "```\n",
    "\n",
    "------------------------\n",
    "\n",
    "This analysis is similar to a standard phylogenetic generalized least squares model fit in that we are trying to perform a regression on data for which there is a lot of non-independence of the data points. If we were comparing species the phylogeny would provide an estimate of the covariance structure where shared branch lengths among species represent their shared history. Here we are not comparing species as our data points but rather quartets of species. Our covariance structure is thus the length of shared branch lengths among sets of four taxa. The code below sets up a framework for doing this. Although the model is not perfect it provides a first step in the right direction and we show it performs better than when we do not account for the non-independence among quartets at all when analyzing them. Below you will find the following: \n",
    "\n",
    "--------------------\n",
    "\n",
    "1. A test of pgls in R using a simulated tree and data.\n",
    "2. Code for measuring a covariance matrix from quartet data.\n",
    "3. Code for building a large data set of variables for our quartet regressions from pyrad outputs.\n",
    "4. A test of our pgls quartet regression code on simulated RAD data.\n",
    "5. Fits of our pgls quartet regression code on 10 empirical data sets. \n",
    "\n",
    "____________________________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Python libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## import Python libraries\n",
    "from scipy.optimize import fminbound\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import itertools\n",
    "import ete3\n",
    "import rpy2\n",
    "import copy\n",
    "import glob\n",
    "import gzip\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We're gonna be running R code as well, so we need the following:\n",
    "\n",
    "The R code is run using 'rmagic' commands in IPython, so to copy this code it would be easiest if you also ran it in a Jupyter/IPython notebook. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## requires rpy2\n",
    "%load_ext rpy2.ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%R\n",
    "\n",
    "## load a few R libraries\n",
    "library(ape)\n",
    "library(ade4)\n",
    "library(nlme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To run parallel Python code using ipyparallel\n",
    "In a separate terminal run the command below to start N engines for doing parallel computing. This requires the Python package 'ipyparallel'. \n",
    "\n",
    "```\n",
    "ipcluster start --n 20\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Then we connect to these Engines and populate the namespace with our libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AsyncResult: execute>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## import ipyparallel\n",
    "import ipyparallel as ipp\n",
    "\n",
    "## start a parallel client\n",
    "ipyclient = ipp.Client()\n",
    "\n",
    "## create a loadbalanced view to distribute jobs\n",
    "lbview = ipyclient.load_balanced_view()\n",
    "\n",
    "## import Python and R packages into parallel namespace\n",
    "ipyclient[:].execute(\"\"\"\n",
    "\n",
    "from scipy.optimize import fminbound\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import itertools\n",
    "import ete3\n",
    "import rpy2\n",
    "import copy\n",
    "import os\n",
    "\n",
    "%load_ext rpy2.ipython\n",
    "\n",
    "%R library(ape)\n",
    "%R library(nlme)\n",
    "\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. An example pgls fit for simulated data. \n",
    "The code to fit a phylogenetic generalized least squares model is adapted from http://www.mpcm-evolution.org/OPM/Chapter5_OPM/OPM_chap5.pdf. Below we first fit a model for simulated data to see how large of data matrices this method can handle. Then we will run on our real data, which is a more complex case. We'll get to that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generate some data and plot it\n",
    "This cell is an example of R code (notice the %%R header). Google \"R in Jupyter notebooks\" for more info. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAX90lE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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAdI0lE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\nAABJRU5ErkJggg==\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "\n",
    "## matrix size (can it handle big data?)\n",
    "n = 500\n",
    "\n",
    "## simulate random data, log-transformed large values\n",
    "set.seed(54321999)\n",
    "simdata = data.frame('nloci'=log(rnorm(n, 50000, 10000)), \n",
    "                     'pdist'=rnorm(n, 1, 0.2), \n",
    "                     'inputreads'=log(abs(rnorm(n, 500000, 100000))))\n",
    "\n",
    "## simulate a tree of same size\n",
    "simtree = rtree(n)\n",
    "\n",
    "## match names of tree to simdata idxs\n",
    "simtree$tip.label = 1:n\n",
    "\n",
    "## plot the data\n",
    "plot(simtree)\n",
    "plot(simdata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pass objects between R and Python "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       nloci     pdist  inputreads\n",
      "1  10.812131  0.854690   13.181553\n",
      "2  10.809799  1.223541   13.216016\n",
      "3  10.955710  0.836004   13.191727\n",
      "4  11.088318  1.047190   13.310152\n",
      "5  10.630199  1.131851   13.390310\n"
     ]
    }
   ],
   "source": [
    "## as an example of what we'll be doing with the real data (Python objects)\n",
    "## let's export them (-o) from R back to Python objects\n",
    "%R newick <- write.tree(simtree)\n",
    "%R -o newick\n",
    "%R -o simdata\n",
    "\n",
    "## Now we have the tree from R as a string in Python\n",
    "## and the data frame from R as a pandas data frame in Python\n",
    "newick = newick.tostring()\n",
    "simdata = simdata\n",
    "\n",
    "print simdata.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model fitting functions\n",
    "I know this is a bit convoluted, but these are _Python_ functions which call mostly _R_ code to do model fitting. This is because I couldn't find a Python library capable of doing pgls. The funtions take in Python objects, convert them to R objects, compute results, and return values as Python objects. The lines with \"%R\" execute as R code in IPython. The function rModelFitPhy uses a phylogeny to estimate a covariance matrix and perform model fitting using GLS. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def rModelFit(pydat, covmat=np.zeros(0), newick=\"\"):\n",
    "    \"\"\" \n",
    "    send PyObjects to R and runs pgls using either an \n",
    "    input covariance matrix or an input tree. Returns\n",
    "    the model fit as a dataframe, and the Log likelhiood\n",
    "    \"\"\"\n",
    "    \n",
    "    ## reconstitute Python data frame as R data frame\n",
    "    %R -i pydat\n",
    "    %R data <- data.frame(pydat)\n",
    "    \n",
    "    ## which model to use...\n",
    "    if (not np.any(covmat)) and (not newick):\n",
    "        %R fit <- gls(nloci ~ inputreads + pdist, data=data)\n",
    "        \n",
    "    else:\n",
    "        ## get covariance (correlation) matrix from tree\n",
    "        if newick:\n",
    "            %R -i newick\n",
    "            %R tre <- read.tree(text=newick)\n",
    "            %R simmat <- vcv(tre, corr=TRUE)\n",
    "\n",
    "        ## get covariance matrix from input\n",
    "        else:\n",
    "            %R -i covmat\n",
    "            %R simmat <- cov2cor(covmat)\n",
    "        \n",
    "        ## fit the model\n",
    "        %R tip.heights <- diag(simmat)  \n",
    "        %R fit <- gls(nloci ~ inputreads + pdist, data=data, \\\n",
    "                      correlation=corSymm(simmat[lower.tri(simmat)], fixed=TRUE), \\\n",
    "                      weights=varFixed(~tip.heights))\n",
    "\n",
    "    ## return results as data frame\n",
    "    %R df <- as.data.frame(summary(fit)$tTable)\n",
    "    %R LL <- fit$logLik\n",
    "    %R -o df,LL\n",
    "    \n",
    "    return df, LL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def rModelFit2(pydat, covmat=np.zeros(0), newick=\"\"):\n",
    "    \"\"\" \n",
    "    Send PyObjects to R and run pgls with covariance mat. \n",
    "    In contrast to the model above this one only fits the\n",
    "    model to inputreads, not pdist. We use the likelihood\n",
    "    fit of this model to estimate estimate lamda by using\n",
    "    maximum likelihood in the func estimate_lambda. \n",
    "    \"\"\"\n",
    "    \n",
    "    ## reconstitute Python data frame as R data frame\n",
    "    %R -i pydat\n",
    "    %R data <- data.frame(pydat)\n",
    "    \n",
    "    ## which model to use...\n",
    "    if (not np.any(covmat)) and (not newick):\n",
    "        %R fit <- gls(nloci ~ inputreads, data=data)\n",
    "        \n",
    "    else:\n",
    "        ## get covariance (correlation) matrix from tree\n",
    "        if newick:\n",
    "            %R -i newick\n",
    "            %R tre <- read.tree(text=newick)\n",
    "            %R simmat <- vcv(tre, corr=TRUE)\n",
    "\n",
    "        ## get covariance matrix from input\n",
    "        else:\n",
    "            %R -i covmat\n",
    "            %R simmat <- cov2cor(covmat)\n",
    "        \n",
    "        ## fit the model\n",
    "        %R tip.heights <- diag(simmat)  \n",
    "        %R fit <- gls(nloci ~ inputreads, data=data, \\\n",
    "                      correlation=corSymm(simmat[lower.tri(simmat)], fixed=TRUE), \\\n",
    "                      weights=varFixed(~tip.heights))\n",
    "\n",
    "    ## return results as data frame\n",
    "    %R df <- as.data.frame(summary(fit)$tTable)\n",
    "    %R LL <- fit$logLik\n",
    "    %R -o df,LL\n",
    "    \n",
    "    return df, LL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model fits to random data\n",
    "Here we did four different model fits to check that our covariacne structure is working correctly. We expect that in all model fits the two variables (inputreads and pdist) will be poor predictors of nloci, since all values were randomly generated. In the first model fit we use no covariance structure and the LL=158. In the second we enforce a covariance structure by getting a VCV from the phylogeny. This gives a much worse fit to the data, as we might expect since the data were not generated with any regard to the phylogeny. The third test checks that when we input a VCV directly we get the same answer as when we put in a tree. We do. This is good since in our quartet analysis below we will be entering just the VCV. Finally, We fit a model that includes a VCV, but where all off-diagonal elements are zero (no covariance). This is equivalent to tranforming the tree by Pagel's lambda = 0. It is encouraging that when we remove the covariance structure in this way we get the same LL=158 as when no covariance structure is present at all. This means that in our real data set we can try to estimate Pagel's lambda for our covariance matrices computed from quartet data and if the covariance structure we create does not fit our data at all then a zero lambda will be estimated and the effect of our covariance structure will be removed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "no VCV\n",
      "                Value  Std.Error    t-value       p-value\n",
      "(Intercept)  9.922016   0.533357  18.602940  5.166341e-59\n",
      "inputreads   0.068718   0.040775   1.685281  9.256210e-02\n",
      "pdist       -0.023346   0.046925  -0.497514  6.190467e-01\n",
      "log-likelihood [ 76.13063426]\n",
      "------------------------------------------------------------\n",
      "\n",
      "VCV from tree -- entered as tree\n",
      "                Value  Std.Error    t-value       p-value\n",
      "(Intercept)  9.989510   0.530265  18.838714  3.853246e-60\n",
      "inputreads   0.058181   0.039488   1.473389  1.412792e-01\n",
      "pdist       -0.004097   0.044443  -0.092186  9.265878e-01\n",
      "log-likelihood [-43.82137587]\n",
      "------------------------------------------------------------\n",
      "\n",
      "VCV from tree -- entered as VCV\n",
      "                Value  Std.Error    t-value       p-value\n",
      "(Intercept)  9.989510   0.530265  18.838714  3.853246e-60\n",
      "inputreads   0.058181   0.039488   1.473389  1.412792e-01\n",
      "pdist       -0.004097   0.044443  -0.092186  9.265878e-01\n",
      "log-likelihood [-43.82137587]\n",
      "------------------------------------------------------------\n",
      "\n",
      "VCV from tree -- entered as VCV -- transformed so no VCV structure\n",
      "                Value  Std.Error    t-value       p-value\n",
      "(Intercept)  9.922016   0.533357  18.602940  5.166341e-59\n",
      "inputreads   0.068718   0.040775   1.685281  9.256210e-02\n",
      "pdist       -0.023346   0.046925  -0.497514  6.190467e-01\n",
      "log-likelihood [ 76.13063426]\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print \"\\nno VCV\"\n",
    "df, LL = rModelFit(simdata)\n",
    "print df\n",
    "print \"log-likelihood\", LL\n",
    "print \"---\"*20\n",
    "\n",
    "\n",
    "print \"\\nVCV from tree -- entered as tree\"\n",
    "df, LL = rModelFit(simdata, newick=newick)\n",
    "print df\n",
    "print \"log-likelihood\", LL\n",
    "print \"---\"*20\n",
    "\n",
    "\n",
    "print \"\\nVCV from tree -- entered as VCV\"\n",
    "%R -o simmat\n",
    "df, LL = rModelFit(simdata, covmat=simmat)  ## <- uses the simmat from the tree\n",
    "print df\n",
    "print \"log-likelihood\", LL\n",
    "print \"---\"*20\n",
    "\n",
    "\n",
    "print \"\\nVCV from tree -- entered as VCV -- transformed so no VCV structure\"\n",
    "df, LL = rModelFit(simdata, covmat=np.eye(simdata.shape[0]))  ## <- no covar == lambda=0\n",
    "print df\n",
    "print \"log-likelihood\", LL\n",
    "print \"---\"*20\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A function to optimize lambda\n",
    "On this simulated data there is little power to detect any covariance structure (lambda fit) in the data because the data is basically just noise. But you'll see below on our simulated data that it fits very well. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def get_lik_lambda(lam, data, covmat):\n",
    "    \"\"\" a function that can be optimized with ML to find lambda\"\"\"\n",
    "    tmat = covmat*lam\n",
    "    np.fill_diagonal(tmat, 1.0)\n",
    "    _, LL = rModelFit2(data, covmat=tmat)\n",
    "    ## return as the NEGATIVE LL to minimze func\n",
    "    return -1*LL\n",
    "\n",
    "\n",
    "def estimate_lambda(data, covmat):\n",
    "    \"\"\" uses fminbound to estimate lambda in [0, 1]\"\"\"\n",
    "    return fminbound(get_lik_lambda, \n",
    "                     0, 1, \n",
    "                     args=(data, covmat), \n",
    "                     xtol=0.001, maxfun=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fit with lambda\n",
    "When we fit the model using our estimated lambda, which in this case is \n",
    "zero since the data were simulated random (no respect to phylogeny) the \n",
    "model fit is the same as above when there is no covariance structure. \n",
    "This is good news. We will penalize this model for the extra parameter\n",
    "using AIC when comparing models. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "VCV from tree -- entered as VCV -- transformed by estimated lambda\n",
      "                Value  Std.Error    t-value       p-value\n",
      "(Intercept)  9.922079   0.533376  18.602408  5.196621e-59\n",
      "inputreads   0.068709   0.040777   1.685011  9.261411e-02\n",
      "pdist       -0.023326   0.046924  -0.497104  6.193356e-01\n",
      "lambda 0.00039980409165\n",
      "log-likelihood [ 76.12267266]\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print \"\\nVCV from tree -- entered as VCV -- transformed by estimated lambda\"\n",
    "lam = estimate_lambda(simdata, simmat)\n",
    "mat = simmat * lam\n",
    "np.fill_diagonal(mat, 1.0)\n",
    "\n",
    "df, LL = rModelFit(simdata, covmat=mat)\n",
    "print df\n",
    "print \"lambda\", lam\n",
    "print \"log-likelihood\", LL\n",
    "print \"---\"*20\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Write functions to get stats info from pyrad outputs\n",
    "\n",
    "Here we build a large data frame that will store how many loci are shared among all sets of quartets, what the phylogenetic distance spanned by each quartet is (pdist), and how much input data each quartet sample had (inputreads). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parse nloci (shared) from pyrad output "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def getarray(locifile, treefile):\n",
    "    \"\"\" get presence/absence matrix from .loci file \n",
    "    (pyrad v3 format) ordered by tips on the tree\"\"\"\n",
    "    \n",
    "    ## parse the loci file\n",
    "    infile = open(locifile)\n",
    "    loci = infile.read().split(\"\\n//\")[:-1]\n",
    "    \n",
    "    ## order (ladderize) the tree\n",
    "    tree = ete3.Tree(treefile, format=3)\n",
    "    tree.ladderize()\n",
    "    \n",
    "    ## assign numbers to internal nodes\n",
    "    nodes = tree.iter_descendants()\n",
    "    nodenum = 0\n",
    "    for node in nodes:\n",
    "        if not node.is_leaf():\n",
    "            node.name = nodenum\n",
    "            nodenum += 1\n",
    "    \n",
    "    ## get tip names\n",
    "    names = tree.get_leaf_names()\n",
    "    \n",
    "    ## make empty matrix\n",
    "    lxs = np.zeros((len(names), len(loci)), dtype=np.uint32)\n",
    "    \n",
    "    ## fill the matrix\n",
    "    for loc in xrange(len(loci)):\n",
    "        for seq in loci[loc].split(\"\\n\"):\n",
    "            if \">\" in seq:\n",
    "                ## drop _0 from sim names if present\n",
    "                seq = seq.rsplit(\"_0 \", 1)[0]\n",
    "                lxs[names.index(seq.split()[0][1:]),loc] += 1\n",
    "    infile.close()\n",
    "    \n",
    "    return lxs, tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get pdist and median inputreads for all(!) quartets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def build_df4_parallel(tree, lxs, s2file, lbview):\n",
    "    \"\"\" \n",
    "    Builds a data frame for quartets in parallel. A less generalized \n",
    "    form of the 'buildarray' function, and much faster. Returns a \n",
    "    data frame with n-shared-loci, median-input-reads, phylo-dist. \n",
    "    \"\"\"\n",
    "    \n",
    "    ## get number of taxa\n",
    "    names = tree.get_leaf_names()\n",
    "      \n",
    "    ## read in step2 stats to get inputreads info, correct _0 in names for simdata\n",
    "    res2 = pd.read_table(s2file, header=0, index_col=0, nrows=len(names))\n",
    "    res2.index = [i[:-2] if i.endswith(\"_0\") else i for i in res2.index]\n",
    "    inputdat = res2[\"passed.total\"].reindex(tree.get_leaf_names())\n",
    "    \n",
    "    ## create empty array of nquart rows and 7 columns\n",
    "    nsets = sum(1 for _ in itertools.combinations(xrange(len(names)), 4))\n",
    "    taxonset = itertools.combinations(xrange(len(names)), 4) \n",
    "    arr = np.zeros((nsets, 7), dtype=np.float32)\n",
    "    \n",
    "    ## iterate over sampled sets and fill array. \n",
    "    asyncs = {}\n",
    "    sub = 0\n",
    "    while 1:\n",
    "        ## grab 100 rows\n",
    "        hund = np.array(list(itertools.islice(taxonset, 100)))\n",
    "        \n",
    "        ## submit to engine\n",
    "        if np.any(hund):\n",
    "            asyncs[sub] = lbview.apply(fillrows, *[tree, names, inputdat, hund, lxs])\n",
    "            sub += 100\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    ## wait for jobs to finish and enter into the results array\n",
    "    lbview.wait()\n",
    "    taxonset = itertools.combinations(xrange(len(names)), 4) \n",
    "    for idx in xrange(nsets):\n",
    "        arr[idx, :4] = taxonset.next()\n",
    "    for idx in xrange(0, sub, 100):\n",
    "        arr[idx:idx+100, 4:] = asyncs[idx].get()     \n",
    "        \n",
    "    ## dress up the array as a dataframe\n",
    "    columns=[\"p1\", \"p2\", \"p3\", \"p4\", \"nloci\", \"inputreads\", \"pdist\"]\n",
    "    df = pd.DataFrame(arr, columns=columns)\n",
    "   \n",
    "    ## convert quartet indices to ints for prettier printing\n",
    "    df[[\"p1\", \"p2\", \"p3\", \"p4\"]] = df[[\"p1\", \"p2\", \"p3\", \"p4\"]].astype(int)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fillrows(tree, names, inputdat, tsets, lxs):\n",
    "    \"\"\" takes 100 row elements in build df4 \"\"\"\n",
    "    \n",
    "    ## output array \n",
    "    arr = np.zeros((tsets.shape[0], 3), dtype=np.float64)\n",
    "    \n",
    "    ## get number of loci shared by the set\n",
    "    for ridx in xrange(tsets.shape[0]):   \n",
    "        tset = tsets[ridx]\n",
    "        colsums = lxs[tset, :].sum(axis=0)\n",
    "        lshare = np.sum(colsums==4)\n",
    "        \n",
    "        ## get total tree length separating these four taxa\n",
    "        t = copy.deepcopy(tree)\n",
    "        t.prune([names[i] for i in tset], preserve_branch_length=True)\n",
    "        pdist = sum([i.dist for i in t])\n",
    "        \n",
    "        ## get min input reads \n",
    "        inputreads = np.median([inputdat[i] for i in tset])\n",
    "        \n",
    "        ## fill arr (+1 ensures no log(0) = -inf)\n",
    "        arr[ridx] = [np.log(lshare+1), np.log(inputreads+1), pdist]\n",
    "        \n",
    "    ## return array with 100 values\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A simple Class object to store our results in "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## define a class object to store data in\n",
    "class dataset():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.files = fileset()\n",
    "        \n",
    "        \n",
    "## define a class object to store file locations\n",
    "class fileset(dict):\n",
    "    \"\"\" checks that data handles exist and stores them\"\"\"\n",
    "    def __getattr__(self, name):\n",
    "        if name in self:\n",
    "            return self[name]\n",
    "        else:\n",
    "            raise AttributeError(\"No such attribute: \" + name)\n",
    "\n",
    "    def __setattr__(self, name, value):\n",
    "        if os.path.exists(value):\n",
    "            self[name] = value\n",
    "        else:\n",
    "            raise AttributeError(\"bad file name \" + value)\n",
    "        \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate a covariance matrix from shared edges among quartets\n",
    "This is of course different from the VCV we inferred from a tree structure in the example at the beginning of this notebook. Here our data points are not tips of a tree but rather quartets. And we create a covariance matrix that measures the amount of shared edges among sampled quartets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_path(node, mrca):\n",
    "    \"\"\" get branch length path from tip to chosen node (mrca)\"\"\"\n",
    "    path = set()\n",
    "    while 1:\n",
    "        ## check that tips have not coalesced\n",
    "        if not node == mrca:\n",
    "            path.add((node, node.up))\n",
    "            node = node.up\n",
    "        else:\n",
    "            return path\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calculate_covariance(intree, maxarr=1000):\n",
    "    \"\"\"\n",
    "    get covariance matrix measuring shared branch lengths among quartets, \n",
    "    if total number of quartets for a tree is >1000 then randomly sample\n",
    "    1000 quartets instead. \n",
    "    \"\"\"\n",
    "    ## tree copy\n",
    "    tree = copy.deepcopy(intree)\n",
    "    tree.unroot()\n",
    "    \n",
    "    ## create a large empty matrix\n",
    "    tt = tree.get_leaves()\n",
    "    nsets = sum(1 for _ in itertools.combinations(range(len(tt)), 4))\n",
    "    \n",
    "    ## we're not gonna worry about memory for now, and so make a list\n",
    "    ## otherwise we would work with iterators\n",
    "    fullcombs = list(itertools.combinations(range(len(tt)), 4))\n",
    "                     \n",
    "    ## either sample all quarets or a random maxarr\n",
    "    if nsets <= maxarr:\n",
    "        quarts = np.zeros((nsets, 4), dtype=np.uint16)\n",
    "        arr = np.zeros((nsets, nsets), dtype=np.float64)\n",
    "        ridx = np.arange(nsets)\n",
    "        for i in xrange(nsets):\n",
    "            quarts[i] = fullcombs[i]\n",
    "        arrsize = nsets\n",
    "            \n",
    "    else:\n",
    "        quarts = np.zeros((maxarr, 4), dtype=np.uint16)\n",
    "        arr = np.zeros((maxarr, maxarr), dtype=np.float64)\n",
    "        ## randomly sample 1000 indices within maxarr\n",
    "        ridx = np.random.choice(nsets, maxarr)\n",
    "        for i in xrange(maxarr):\n",
    "            quarts[i] = fullcombs[ridx[i]]\n",
    "        arrsize = maxarr\n",
    "    \n",
    "    ## iterate over each comb to compare\n",
    "    for idx in xrange(arrsize):\n",
    "        \n",
    "        ## get path to quartet tips\n",
    "        set1 = [tt[i] for i in quarts[idx]]  \n",
    "        mrca1 = set1[0].get_common_ancestor(set1)\n",
    "        edges1 = [get_path(node, mrca1) for node in set1]\n",
    "                \n",
    "        for cdx in xrange(idx, arrsize):         \n",
    "            ## get path to quartet tips\n",
    "            set2 = [tt[i] for i in quarts[cdx]]  \n",
    "            mrca2 = set2[0].get_common_ancestor(set2)\n",
    "            edges2 = [get_path(node, mrca2) for node in set2]\n",
    "                    \n",
    "            ## which edges are shared\n",
    "            a = set([tuple(i) for i in itertools.chain(*edges1)])\n",
    "            b = set([tuple(i) for i in itertools.chain(*edges2)])\n",
    "            shared = set.intersection(a, b)\n",
    "            \n",
    "            ## save the branch lengths\n",
    "            sumshare = sum([tree.get_distance(edg[0], edg[1]) for edg in shared])\n",
    "            arr[idx, cdx] = sumshare\n",
    "        #print idx,\n",
    "            \n",
    "    return arr, ridx\n",
    "                         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def check_covariance(covar):\n",
    "    \"\"\" tests covariance matrix for positive definite\"\"\"\n",
    "\n",
    "    ## fill the lower triangle of matrix symmetrically\n",
    "    mat = np.array(covar)\n",
    "    upidx = np.triu_indices_from(covar)\n",
    "    mat[(upidx[1], upidx[0])] = covar[upidx]\n",
    "\n",
    "    ## is the matrix symmetric?\n",
    "    assert np.allclose(mat, mat.T), \"matrix is not symmetric\"\n",
    "    \n",
    "    ## is it positive definite?\n",
    "    test = 0\n",
    "    while 1:\n",
    "        if not np.all(np.linalg.eigvals(mat) > 0):\n",
    "            didx = np.diag_indices_from(mat)\n",
    "            mat[didx] = np.diag(mat) *1.1\n",
    "            test += 1\n",
    "        elif test > 20:\n",
    "            assert np.all(np.linalg.eigvals(mat) > 0), \"matrix is not positive definite\"\n",
    "        else:\n",
    "            break\n",
    "    assert np.all(np.linalg.eigvals(mat) > 0), \"matrix is not positive definite\"\n",
    "            \n",
    "    return mat        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function to run model functions together\n",
    "This allows us to make one call to run jobs in parallel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fitmodels(tree, df4, nsamples):\n",
    "    \"\"\" \n",
    "    Calculates covar, checks matrix, fits models, \n",
    "    and return arrays for with and without covar\n",
    "    \"\"\"\n",
    "    ## calculate covariance of (nsamples) random data points\n",
    "    covar, ridx = calculate_covariance(tree, nsamples)\n",
    "\n",
    "    ## get symmetric matrix and test for positive definite\n",
    "    mat = check_covariance(covar)\n",
    "    \n",
    "    ## subsample a reasonable number of data points\n",
    "    subdf4 = df4.loc[ridx, :]\n",
    "    \n",
    "    ## estimate lambda to be used in model fits\n",
    "    ## I'm using R to convert cov2cor\n",
    "    %R -i mat\n",
    "    %R mm <-cov2cor(mat)\n",
    "    %R -o mm\n",
    "    lam = estimate_lambda(subdf4, mm)\n",
    "\n",
    "    ## transform corr matrix with lambda\n",
    "    mat = mm*lam\n",
    "    np.fill_diagonal(mat, 1.0)    \n",
    "    \n",
    "    ## fit models with covar\n",
    "    ndf, nLL = rModelFit(subdf4)\n",
    "    wdf, wLL = rModelFit(subdf4, covmat=mat)\n",
    "    \n",
    "    ## return two arrays\n",
    "    return wdf, wLL, nLL, lam #ndf, nLL, wdf, wLL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 3. Testing on a simulated RAD data set \n",
    "In this case we know what the source of missing data is, either mutation (drop) or random (rand). \n",
    "\n",
    "For a large tree like this (64) tips this takes quite a while to run (~20 minutes). This is the case even when we only randomly sample 200 quartets out of the possible ~650K. Our solution will be to do many repetitions of subsampling and to parallelize this to get a good estimate quickly. Fortunately our largest empirical data set is about the same size as these simulated data sets, so this gives us a good idea for run times (still pretty long). To repeat this analysis you will have to change the file paths. The files are created in the simulation notebook. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simulate a new data set variable missing data\n",
    "I'm simulating a new data set for this since the 'random' missing data sets we made in the sim notebook all have very similar amounts of input data. To get signal from the data we need the input data to vary more significantly among samples. So I simulate some new data here with greater variance. \n",
    "\n",
    "More specifically, I will take data from the 'fullcov' data sets which had no missing data\n",
    "and randomly remove some DIFFERENT proportion of data from each sample. This is different\n",
    "from our low coverage simulations in which we removed the same proportion of data from \n",
    "each sample, but it was randomly missing from different loci. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### New balanced tree data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s109_0_R1.fq.gz sampled at p=0.63 kept 12740 reads\n",
      "s89_0_R1.fq.gz sampled at p=0.53 kept 10523 reads\n",
      "s77_0_R1.fq.gz sampled at p=0.47 kept 9367 reads\n",
      "s71_0_R1.fq.gz sampled at p=0.54 kept 10833 reads\n",
      "s83_0_R1.fq.gz sampled at p=0.83 kept 16676 reads\n",
      "s78_0_R1.fq.gz sampled at p=0.75 kept 15139 reads\n",
      "s116_0_R1.fq.gz sampled at p=0.67 kept 13577 reads\n",
      "s70_0_R1.fq.gz sampled at p=0.61 kept 12380 reads\n",
      "s98_0_R1.fq.gz sampled at p=0.12 kept 2451 reads\n",
      "s120_0_R1.fq.gz sampled at p=0.86 kept 17273 reads\n",
      "s101_0_R1.fq.gz sampled at p=0.68 kept 13807 reads\n",
      "s92_0_R1.fq.gz sampled at p=0.24 kept 4640 reads\n",
      "s108_0_R1.fq.gz sampled at p=0.88 kept 17540 reads\n",
      "s86_0_R1.fq.gz sampled at p=0.18 kept 3619 reads\n",
      "s91_0_R1.fq.gz sampled at p=0.66 kept 13325 reads\n",
      "s125_0_R1.fq.gz sampled at p=0.50 kept 10001 reads\n",
      "s124_0_R1.fq.gz sampled at p=0.90 kept 17931 reads\n",
      "s95_0_R1.fq.gz sampled at p=0.43 kept 8791 reads\n",
      "s105_0_R1.fq.gz sampled at p=0.81 kept 16275 reads\n",
      "s102_0_R1.fq.gz sampled at p=0.22 kept 4335 reads\n",
      "s115_0_R1.fq.gz sampled at p=0.32 kept 6523 reads\n",
      "s93_0_R1.fq.gz sampled at p=0.19 kept 3659 reads\n",
      "s88_0_R1.fq.gz sampled at p=0.78 kept 15741 reads\n",
      "s100_0_R1.fq.gz sampled at p=0.24 kept 4800 reads\n",
      "s113_0_R1.fq.gz sampled at p=0.31 kept 6312 reads\n",
      "s65_0_R1.fq.gz sampled at p=0.69 kept 13891 reads\n",
      "s97_0_R1.fq.gz sampled at p=0.53 kept 10559 reads\n",
      "s82_0_R1.fq.gz sampled at p=0.67 kept 13317 reads\n",
      "s106_0_R1.fq.gz sampled at p=0.36 kept 7176 reads\n",
      "s117_0_R1.fq.gz sampled at p=0.38 kept 7756 reads\n",
      "s111_0_R1.fq.gz sampled at p=0.16 kept 3098 reads\n",
      "s104_0_R1.fq.gz sampled at p=0.22 kept 4463 reads\n",
      "s87_0_R1.fq.gz sampled at p=0.70 kept 13952 reads\n",
      "s69_0_R1.fq.gz sampled at p=0.56 kept 11282 reads\n",
      "s85_0_R1.fq.gz sampled at p=0.50 kept 10059 reads\n",
      "s73_0_R1.fq.gz sampled at p=0.72 kept 14355 reads\n",
      "s80_0_R1.fq.gz sampled at p=0.86 kept 17152 reads\n",
      "s79_0_R1.fq.gz sampled at p=0.66 kept 13153 reads\n",
      "s74_0_R1.fq.gz sampled at p=0.46 kept 9285 reads\n",
      "s90_0_R1.fq.gz sampled at p=0.79 kept 15678 reads\n",
      "s66_0_R1.fq.gz sampled at p=0.21 kept 4111 reads\n",
      "s114_0_R1.fq.gz sampled at p=0.68 kept 13643 reads\n",
      "s112_0_R1.fq.gz sampled at p=0.12 kept 2430 reads\n",
      "s99_0_R1.fq.gz sampled at p=0.83 kept 16547 reads\n",
      "s84_0_R1.fq.gz sampled at p=0.21 kept 4166 reads\n",
      "s96_0_R1.fq.gz sampled at p=0.13 kept 2473 reads\n",
      "s81_0_R1.fq.gz sampled at p=0.63 kept 12531 reads\n",
      "s72_0_R1.fq.gz sampled at p=0.43 kept 8472 reads\n",
      "s67_0_R1.fq.gz sampled at p=0.24 kept 4781 reads\n",
      "s63_0_R1.fq.gz sampled at p=0.25 kept 4957 reads\n",
      "s75_0_R1.fq.gz sampled at p=0.21 kept 4323 reads\n",
      "s122_0_R1.fq.gz sampled at p=0.53 kept 10407 reads\n",
      "s68_0_R1.fq.gz sampled at p=0.79 kept 15859 reads\n",
      "s76_0_R1.fq.gz sampled at p=0.46 kept 9036 reads\n",
      "s94_0_R1.fq.gz sampled at p=0.12 kept 2483 reads\n",
      "s64_0_R1.fq.gz sampled at p=0.21 kept 4174 reads\n",
      "s121_0_R1.fq.gz sampled at p=0.48 kept 9485 reads\n",
      "s118_0_R1.fq.gz sampled at p=0.85 kept 16924 reads\n",
      "s103_0_R1.fq.gz sampled at p=0.56 kept 11128 reads\n",
      "s126_0_R1.fq.gz sampled at p=0.58 kept 11479 reads\n",
      "s110_0_R1.fq.gz sampled at p=0.16 kept 3193 reads\n",
      "s119_0_R1.fq.gz sampled at p=0.23 kept 4595 reads\n",
      "s123_0_R1.fq.gz sampled at p=0.12 kept 2462 reads\n",
      "s107_0_R1.fq.gz sampled at p=0.40 kept 8048 reads\n"
     ]
    }
   ],
   "source": [
    "## make a new directory for the subsampled fastqs\n",
    "! mkdir -p /home/deren/Documents/RADsims/Tbal_rad_varcov/fastq/\n",
    "\n",
    "## grab the no-missing fastqs\n",
    "fastqs = glob.glob(\"/home/deren/Documents/RADsims/Tbal_rad_covfull/fastq/s*\")\n",
    "for fastq in fastqs:\n",
    "    ## create a new output file\n",
    "    _, handle = os.path.split(fastq)\n",
    "    outfile = gzip.open(\n",
    "                os.path.join(\n",
    "                    \"/home/deren/Documents/RADsims/Tbal_rad_varcov/fastq\",\n",
    "                    handle), 'w')\n",
    "    ## grab a random proportion of reads from this data set (0-100%)\n",
    "    p = np.random.uniform(0.1, 0.9)\n",
    "    ## iterate over file 4-lines at a time. \n",
    "    infile = gzip.open(fastq, 'r')\n",
    "    qiter = itertools.izip(*[iter(infile)]*4)\n",
    "    ## sample read with probability p\n",
    "    kept = 0\n",
    "    while 1:\n",
    "        try:\n",
    "            if np.random.binomial(1, p):\n",
    "                outfile.write(\"\".join(qiter.next()))\n",
    "                kept += 1\n",
    "            else:\n",
    "                _ = qiter.next()\n",
    "        except StopIteration:\n",
    "            break\n",
    "    print '{} sampled at p={:.2f} kept {} reads'.format(handle, p, kept)\n",
    "    infile.close()\n",
    "    outfile.close()\n",
    "                                             "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 583,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "## assemble the data set in pyrad\n",
    "rm params.txt \n",
    "pyrad -n >> log.txt 2>&1  \n",
    "sed -i '/## 1. /c\\Tbal_rad_varcov       ## 1. working dir ' params.txt\n",
    "sed -i '/## 2. /c\\                      ## 2. data loc ' params.txt\n",
    "sed -i '/## 3. /c\\                      ## 3. Bcode ' params.txt\n",
    "sed -i '/## 6. /c\\TGCAG               ## 6. cutters ' params.txt\n",
    "sed -i '/## 7. /c\\20                  ## 7. Nproc ' params.txt\n",
    "sed -i '/## 10. /c\\.82                ## 10. clust thresh' params.txt\n",
    "sed -i '/## 11. /c\\rad                ## 11. datatype ' params.txt\n",
    "sed -i '/## 12. /c\\2                  ## 12. minCov ' params.txt\n",
    "sed -i '/## 13. /c\\10                 ## 13. maxSH' params.txt\n",
    "sed -i '/## 14. /c\\Tbal               ## 14. outname' params.txt\n",
    "sed -i '/## 18./c\\Tbal_rad_varcov/fastq/*.gz   ## sorted data ' params.txt\n",
    "sed -i '/## 24./c\\99                  ## 24. maxH' params.txt\n",
    "sed -i '/## 30./c\\n,p,s               ## 30. out format' params.txt\n",
    "pyrad -p params.txt -s 234567 >> log.txt 2>&1  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## load the data files\n",
    "Tbalvarcov = dataset(\"Tbalvarcov\")\n",
    "Tbalvarcov.files.loci4 = \"/home/deren/Documents/RADsims/Tbal_rad_varcov/outfiles/Tbal.loci\"\n",
    "Tbalvarcov.files.tree = \"/home/deren/Documents/RADsims/Tbal.tre\"\n",
    "Tbalvarcov.files.s2 = \"/home/deren/Documents/RADsims/Tbal_rad_varcov/stats/s2.rawedit.txt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For the mutation-disruption data set we can re-use the sim data from notebook 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## balanced tree with only phylo missing data. \n",
    "Tbaldrop = dataset(\"Tbaldrop\")\n",
    "Tbaldrop.files.loci4 = \"/home/deren/Documents/RADsims/Tbal_rad_drop/outfiles/Tbal.loci\"\n",
    "Tbaldrop.files.tree = \"/home/deren/Documents/RADsims/Tbal.tre\"\n",
    "Tbaldrop.files.s2 = \"/home/deren/Documents/RADsims/Tbal_rad_drop/stats/s2.rawedit.txt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### New Imbalanced tree data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 587,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s109_0_R1.fq.gz sampled at p=0.29 kept 5642 reads\n",
      "s89_0_R1.fq.gz sampled at p=0.72 kept 14463 reads\n",
      "s77_0_R1.fq.gz sampled at p=0.78 kept 15533 reads\n",
      "s7_0_R1.fq.gz sampled at p=0.39 kept 7707 reads\n",
      "s71_0_R1.fq.gz sampled at p=0.68 kept 13722 reads\n",
      "s1_0_R1.fq.gz sampled at p=0.36 kept 7219 reads\n",
      "s83_0_R1.fq.gz sampled at p=0.70 kept 13935 reads\n",
      "s13_0_R1.fq.gz sampled at p=0.90 kept 17865 reads\n",
      "s25_0_R1.fq.gz sampled at p=0.13 kept 2582 reads\n",
      "s53_0_R1.fq.gz sampled at p=0.89 kept 17799 reads\n",
      "s101_0_R1.fq.gz sampled at p=0.44 kept 8844 reads\n",
      "s91_0_R1.fq.gz sampled at p=0.43 kept 8623 reads\n",
      "s125_0_R1.fq.gz sampled at p=0.11 kept 2075 reads\n",
      "s39_0_R1.fq.gz sampled at p=0.31 kept 6213 reads\n",
      "s41_0_R1.fq.gz sampled at p=0.50 kept 10181 reads\n",
      "s95_0_R1.fq.gz sampled at p=0.73 kept 14769 reads\n",
      "s105_0_R1.fq.gz sampled at p=0.76 kept 15280 reads\n",
      "s9_0_R1.fq.gz sampled at p=0.39 kept 7662 reads\n",
      "s31_0_R1.fq.gz sampled at p=0.42 kept 8500 reads\n",
      "s115_0_R1.fq.gz sampled at p=0.74 kept 14700 reads\n",
      "s27_0_R1.fq.gz sampled at p=0.21 kept 4197 reads\n",
      "s93_0_R1.fq.gz sampled at p=0.65 kept 13037 reads\n",
      "s113_0_R1.fq.gz sampled at p=0.77 kept 15406 reads\n",
      "s65_0_R1.fq.gz sampled at p=0.17 kept 3414 reads\n",
      "s17_0_R1.fq.gz sampled at p=0.78 kept 15667 reads\n",
      "s5_0_R1.fq.gz sampled at p=0.90 kept 17993 reads\n",
      "s57_0_R1.fq.gz sampled at p=0.72 kept 14391 reads\n",
      "s97_0_R1.fq.gz sampled at p=0.90 kept 17933 reads\n",
      "s59_0_R1.fq.gz sampled at p=0.30 kept 6011 reads\n",
      "s117_0_R1.fq.gz sampled at p=0.68 kept 13651 reads\n",
      "s3_0_R1.fq.gz sampled at p=0.47 kept 9403 reads\n",
      "s111_0_R1.fq.gz sampled at p=0.66 kept 13268 reads\n",
      "s61_0_R1.fq.gz sampled at p=0.68 kept 13601 reads\n",
      "s87_0_R1.fq.gz sampled at p=0.56 kept 11276 reads\n",
      "s69_0_R1.fq.gz sampled at p=0.87 kept 17432 reads\n",
      "s85_0_R1.fq.gz sampled at p=0.46 kept 9227 reads\n",
      "s73_0_R1.fq.gz sampled at p=0.55 kept 10982 reads\n",
      "s79_0_R1.fq.gz sampled at p=0.53 kept 10657 reads\n",
      "s15_0_R1.fq.gz sampled at p=0.28 kept 5732 reads\n",
      "s33_0_R1.fq.gz sampled at p=0.71 kept 14277 reads\n",
      "s49_0_R1.fq.gz sampled at p=0.69 kept 13753 reads\n",
      "s19_0_R1.fq.gz sampled at p=0.60 kept 12072 reads\n",
      "s43_0_R1.fq.gz sampled at p=0.81 kept 16299 reads\n",
      "s99_0_R1.fq.gz sampled at p=0.39 kept 7724 reads\n",
      "s29_0_R1.fq.gz sampled at p=0.22 kept 4333 reads\n",
      "s81_0_R1.fq.gz sampled at p=0.24 kept 4795 reads\n",
      "s67_0_R1.fq.gz sampled at p=0.24 kept 4746 reads\n",
      "s63_0_R1.fq.gz sampled at p=0.66 kept 13150 reads\n",
      "s75_0_R1.fq.gz sampled at p=0.25 kept 5027 reads\n",
      "s47_0_R1.fq.gz sampled at p=0.35 kept 6961 reads\n",
      "s51_0_R1.fq.gz sampled at p=0.58 kept 11464 reads\n",
      "s37_0_R1.fq.gz sampled at p=0.28 kept 5651 reads\n",
      "s55_0_R1.fq.gz sampled at p=0.49 kept 9696 reads\n",
      "s11_0_R1.fq.gz sampled at p=0.80 kept 15942 reads\n",
      "s23_0_R1.fq.gz sampled at p=0.77 kept 15395 reads\n",
      "s121_0_R1.fq.gz sampled at p=0.13 kept 2581 reads\n",
      "s21_0_R1.fq.gz sampled at p=0.71 kept 14161 reads\n",
      "s103_0_R1.fq.gz sampled at p=0.38 kept 7731 reads\n",
      "s35_0_R1.fq.gz sampled at p=0.83 kept 16519 reads\n",
      "s126_0_R1.fq.gz sampled at p=0.17 kept 3490 reads\n",
      "s119_0_R1.fq.gz sampled at p=0.44 kept 8727 reads\n",
      "s123_0_R1.fq.gz sampled at p=0.29 kept 5866 reads\n",
      "s107_0_R1.fq.gz sampled at p=0.52 kept 10382 reads\n",
      "s45_0_R1.fq.gz sampled at p=0.35 kept 7079 reads\n"
     ]
    }
   ],
   "source": [
    "## make a new directory for the subsampled fastqs\n",
    "! mkdir -p /home/deren/Documents/RADsims/Timb_rad_varcov/fastq/\n",
    "\n",
    "## grab the no-missing fastqs\n",
    "fastqs = glob.glob(\"/home/deren/Documents/RADsims/Timb_rad_covfull/fastq/s*\")\n",
    "for fastq in fastqs:\n",
    "    ## create a new output file\n",
    "    _, handle = os.path.split(fastq)\n",
    "    outfile = gzip.open(\n",
    "                os.path.join(\n",
    "                    \"/home/deren/Documents/RADsims/Timb_rad_varcov/fastq\",\n",
    "                    handle), 'w')\n",
    "    ## grab a random proportion of reads from this data set (0-100%)\n",
    "    p = np.random.uniform(0.1, 0.9)\n",
    "    ## iterate over file 4-lines at a time. \n",
    "    infile = gzip.open(fastq, 'r')\n",
    "    qiter = itertools.izip(*[iter(infile)]*4)\n",
    "    ## sample read with probability p\n",
    "    kept = 0\n",
    "    while 1:\n",
    "        try:\n",
    "            if np.random.binomial(1, p):\n",
    "                outfile.write(\"\".join(qiter.next()))\n",
    "                kept += 1\n",
    "            else:\n",
    "                _ = qiter.next()\n",
    "        except StopIteration:\n",
    "            break\n",
    "    print '{} sampled at p={:.2f} kept {} reads'.format(handle, p, kept)\n",
    "    infile.close()\n",
    "    outfile.close()\n",
    "                                                     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "## assemble the data set in pyrad\n",
    "rm params.txt\n",
    "pyrad -n >> log.txt 2>&1  \n",
    "sed -i '/## 1. /c\\Timb_rad_varcov       ## 1. working dir ' params.txt\n",
    "sed -i '/## 2. /c\\                      ## 2. data loc ' params.txt\n",
    "sed -i '/## 3. /c\\                      ## 3. Bcode ' params.txt\n",
    "sed -i '/## 6. /c\\TGCAG               ## 6. cutters ' params.txt\n",
    "sed -i '/## 7. /c\\20                  ## 7. Nproc ' params.txt\n",
    "sed -i '/## 10. /c\\.82                ## 10. clust thresh' params.txt\n",
    "sed -i '/## 11. /c\\rad                ## 11. datatype ' params.txt\n",
    "sed -i '/## 12. /c\\2                  ## 12. minCov ' params.txt\n",
    "sed -i '/## 13. /c\\10                 ## 13. maxSH' params.txt\n",
    "sed -i '/## 14. /c\\Timb               ## 14. outname' params.txt\n",
    "sed -i '/## 18./c\\Timb_rad_varcov/fastq/*.gz   ## sorted data ' params.txt\n",
    "sed -i '/## 24./c\\99                  ## 24. maxH' params.txt\n",
    "sed -i '/## 30./c\\n,p,s               ## 30. out format' params.txt\n",
    "pyrad -p params.txt -s 234567 >> log.txt 2>&1  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## imbalanced tree with only phylo missind data. \n",
    "Timbvarcov = dataset(\"Timbvarcov\")\n",
    "Timbvarcov.files.loci4 = \"/home/deren/Documents/RADsims/Timb_rad_varcov/outfiles/Timb.loci\"\n",
    "Timbvarcov.files.tree = \"/home/deren/Documents/RADsims/Timb.tre\"\n",
    "Timbvarcov.files.s2 = \"/home/deren/Documents/RADsims/Timb_rad_varcov/stats/s2.rawedit.txt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imbalanced tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## balanced tree with only phylo missind data. \n",
    "Timbdrop = dataset(\"Timbdrop\")\n",
    "Timbdrop.files.loci4 = \"/home/deren/Documents/RADsims/Timb_rad_drop/outfiles/Timb.loci\"\n",
    "Timbdrop.files.tree = \"/home/deren/Documents/RADsims/Timb.tre\"\n",
    "Timbdrop.files.s2 = \"/home/deren/Documents/RADsims/Timb_rad_drop/stats/s2.rawedit.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## list of dsets\n",
    "dsets = [Tbaldrop, Timbdrop, Tbalvarcov, Timbvarcov]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get array of shared loci for each data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tbaldrop \n",
      "[[1 1 1 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " [1 0 1 ..., 1 1 1]\n",
      " ..., \n",
      " [0 1 1 ..., 1 1 1]\n",
      " [0 1 1 ..., 1 1 1]\n",
      " [0 1 1 ..., 1 1 1]] \n",
      "\n",
      "Timbdrop \n",
      "[[1 1 1 ..., 1 0 1]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 0 1]\n",
      " ..., \n",
      " [1 1 1 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 1 1]] \n",
      "\n",
      "Tbalvarcov \n",
      "[[0 0 0 ..., 0 1 1]\n",
      " [1 0 0 ..., 0 1 1]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " ..., \n",
      " [1 1 1 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 1 1]] \n",
      "\n",
      "Timbvarcov \n",
      "[[1 1 0 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " ..., \n",
      " [1 1 1 ..., 0 0 1]\n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "## submit parallel [getarray] jobs\n",
    "asyncs = {}\n",
    "for dset in dsets:\n",
    "    asyncs[dset.name] = lbview.apply(getarray, *[dset.files.loci4, dset.files.tree])\n",
    "    \n",
    "## collect results\n",
    "ipyclient.wait()\n",
    "for dset in dsets:\n",
    "    dset.lxs4, dset.tree = asyncs[dset.name].get()\n",
    "    print dset.name, \"\\n\", dset.lxs4, \"\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build array of model stats for each data set\n",
    "This takes a few minutes depending on how many CPUs you're running in parallel. One of the arguments to 'build_df4_parallel' is 'lbview', our load_balanced_view of the parallel processors. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   p1  p2  p3  p4     nloci  inputreads      pdist\n",
      "0   0   1   2   3  6.498282    9.054388  23.523808\n",
      "1   0   1   2   4  6.453625    9.051755  23.523806\n",
      "2   0   1   2   5  6.643790    9.447268  23.523804\n",
      "3   0   1   2   6  6.643790    9.520395  23.523802\n",
      "4   0   1   2   7  6.025866    9.025455  23.523800\n"
     ]
    }
   ],
   "source": [
    "## submit parallel [buildarray] jobs\n",
    "for dset in dsets:\n",
    "     dset.df4 = build_df4_parallel(dset.tree, dset.lxs4, dset.files.s2, lbview)\n",
    "\n",
    "## peek at one of the data sets\n",
    "print dsets[3].df4.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean standardize the arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   p1  p2  p3  p4     nloci  inputreads     pdist\n",
      "0   0   1   2   3  0.759856   -0.598282  2.647565\n",
      "1   0   1   2   4  0.731862   -0.607247  2.647564\n",
      "2   0   1   2   5  0.851071    0.739461  2.647563\n",
      "3   0   1   2   6  0.851071    0.988455  2.647563\n",
      "4   0   1   2   7  0.463710   -0.696796  2.647563\n"
     ]
    }
   ],
   "source": [
    "for dset in dsets:\n",
    "    for var in [\"nloci\", \"inputreads\", \"pdist\"]:\n",
    "        dset.df4[var] = (dset.df4[var] - dset.df4[var].mean()) / dset.df4[var].std()\n",
    "    \n",
    "## peek again\n",
    "print dsets[3].df4.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To parallelize the next step we need to send our functions to the remote namespace\n",
    "A much cleaner way to do this would have been to collect all the functions into a Python module and then just import that. Since I'm writing everything out in this notebook to be more didactic, though, we need to perform this step instead. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AsyncResult: _push>"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ipyclient[:].push(\n",
    "    dict(\n",
    "        calculate_covariance=calculate_covariance, \n",
    "        check_covariance=check_covariance,\n",
    "        get_path=get_path,\n",
    "        rModelFit=rModelFit,\n",
    "        rModelFit2=rModelFit2,\n",
    "        estimate_lambda=estimate_lambda,\n",
    "        get_lik_lambda=get_lik_lambda\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot sim data set with a random 1000 quartets sampled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## pass objects into R\n",
    "rdf0 = dsets[0].df4.loc[np.random.choice(range(630000), 1000), :]\n",
    "rdf1 = dsets[1].df4.loc[np.random.choice(range(630000), 1000), :]\n",
    "rdf2 = dsets[2].df4.loc[np.random.choice(range(630000), 1000), :]\n",
    "rdf3 = dsets[3].df4.loc[np.random.choice(range(630000), 1000), :]\n",
    "\n",
    "baltre = dsets[0].tree.write()\n",
    "imbtre = dsets[1].tree.write()\n",
    "%R -i rdf0,rdf1,rdf2,rdf3,baltre,imbtre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAVX0lE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\nbGSuBQAAAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAV3klE\nQVR4nO2dgXrkKAiA8f1f+r7bRgVFBWOUZKC33UyGCOEX0Ey7B8HFlMBpB1yoOBBj4kCMiQMxJg7E\nmDgQY+JAjIkDMSYOxJg4EGPiQIyJAzEmDsSYOBBj4kCMyUEg8E/yq5G2YuDxdcVpxegPy3EgkF6N\ntCVa9VAORG4aAorEZiBmxQCQvzRBB+kv9D1qX2r4XTwiGiEN+nd9Ugi1ufQS2zokx0sWil88yH/R\nUyGEpI/eLUZMAycgWa24FL8kdn8bSEgzGU9pHPlc2/Bsxu+lYfIIITKhl5P0SBWN2P3dDAmoVuAD\nFK7ngNQly4GEooQzGYIU4yFOp3rEHPMAVYxpa6FnHQgp6AEdkLyhdR3FutdD8p+yh3A5hoF4D2Ga\nOi7yUSNN5rzeSt/piDWQrDYuWb8MZL0UgZyOqwNZJFW+TI3hGbJMSiBzYxzl8S0gXxAHYkwciDFx\nIMbEgRgTB2JMHIgxcSDGxIEYEwdiTByIMXEgxsSBGBMHYkwciDGxDqT+bGL0qeDg/bOfdozFtnf/\nfo6nOAM33zd+y7a9+1+qKV686L7PvDZ+y8a9K+YzlADGQF7Gw7p7jH86IMz92b5l295xPVjb1Kse\nY/uWbXv3g+JAjIkDMSYOxJg4EGPiQIyJAzEm5oHcfjIyvMCWGHfPgZgTB2JMHEhbdYN83dZaIHLV\nWYHq4GO2rn9eQqSqGPUx2RQkIJ+rcLZUk1pgEB0xnxjwqopRH5M9QCCQT3IbH5msdCGXLQfSsLIZ\nCDn0ksVYOQbkjOqsfL+HHFKdle+vsg6pzooDcSAORGTiq7ZOqc6KA3EgDkRk4qu2xgYdyOaHi6OH\nv+8HItvD1VrSjeGKPSKmMPh9iNcDkT3lYLSEj06WPEXBAwwAO5DdQI6ozsrzQHDpaNtqAZktX78E\nRNdDikg3bfE9ZDpbfgqI2oAEyPBqvdmjqrPiQH4NiLCHjK9WWj2tOiuPAIHrH5W/ZQu4f9pc7sJp\n1Vl5AggEvtaobP0N4CULvTP/D7mHEH8WjoyDbQ1H/7v8wqJ3JV8A6f8rMFRVjPqYNIHc2J5dl/59\njM439fHoKENmXAF81H928n0g6UdFbwG5BoC5uoV+Lmt0+aeBpOKiyBC+IBXXzWfIIdVZWdtDcBRj\nlox6SCvc9x7/fhDI7GjQfVnbagC5UzJ1l74QCJrO4yfZq4DkHjIjnwaSQzactjR+IiDdHjKdJ98H\nkn4YVOgUM78FtkgurtmHHFKdFU2GaCYspzm2VS2t/uaC2Cpj65TqrEh7SMySwb+9lJe9VHX8w9bV\nVXmfP9NOjqvOinSVBSH/jwqvM6mGIVxpIDqr83Tv20JA0po5jqr7zcHPAwnlLKVRgr+vnAc0fDNA\n8vi4najv65TqrAxWPhgACkzq8am9QAkEvaEAkt/EGZIP9fd1SnVW+CBB8SdcNQtXqRyukP4Hqvwq\nKWmxtohdvmRhIEIqpH8NOqRkPLVqrStfDdXqOIS4hAA6uAKO/x+6JK3oBW1bxTOSARApFuQNSc5e\nCMZyDkj6KnrCdZd/oQkoPhkSoNJFqfazEVnJhzWQkFtXj0rRvywAUV5WZ0hAMxHdfTld0YoYMqTr\n6pQ+HVvoxLiHICzdLn++h6wFkvMjpkSuRChVcDqQEob1EVXelipD0OneXR8EAnmupEB0feVNVHUd\nL49i4HN1ikACiRcOYaCx7tpijnEqvAwIhDRHrxZWRkJiolCPmVFUowAo5ug9Opvp66Et6o04Q4Q9\nRB6CRaqxLsRCnQKpM4FmZh4UlSCgjTsTQXUrcctnOBMaICEP+2ogYjtlkPJocTg66ykQ9Id5G+4D\nyaMzJYukX+u+FCFYpPookHz33fKEEuYWENxDQsHm1UDi8l9hggLJqyih1Kp4Ncbb6juWw/1eICua\nOolgim21qkohZ5GgHUrPVtexDwBZuOy9zkkygeODWrLUFmsbH84C6esJvdGrzkpVspDz7dh3JZe7\ngS3OnWIfgg6VQNDl0hCMZT+QtFb9e8FEu4EpFK8EthoadJWVD1tAeCoHS9Y94YFUERZAOASkUZ2/\nBeTvJidAEI1Qzl4dkFCwaQHJ4LC5rwAJaNZ1I15u2muFUM3eR3pIcoea+wyQv+O7EmaBUGU5kLjG\nVG6LH1SdFRykeDuCeHfP4Scp00CqZOkDyScUJp5UnRUUpBg+fKPKrUi8CBcS1pbOx18H8vclWWd1\nuVTeTwMJmfHPASlu7w6OdUDKyP8IELRWhfI2RQiKo64tlY8X4SJPpEBYXzi3BJ7oHJ+Rch8SFqyx\n+Py4CyTEb0ogMLJoHYh4oz6CMrKl8pFZcfWBpON3A5nmUMSI9f1mhqDjLpDSPD87GLcEnugcn5E6\nSPeToxWCPUCu7xMhWKo6KwyQ+yK2JfRRByTEJaN0+EdUZ4UDkp5CKJIl71vaXu/pIQMnOm4tVZ2V\nVRkSMkCFLaGPaNRfBDKNZBSLWSD4CUwuSD8CpLgxPYwngJBB4hrqN4AwWy8ZkXxlADKl27am/b0M\n/BQQreAMo124bWvaX5zMPwFkCko5qAOZE66HTPCoB30ICKqGQiCcg7xbAuNTLqukClJ5gzNAHuwh\n1IgoQ0bWbAO5FkzaJ+8tBl1bd13vAmGmycitpaqzwgKZSJBGlerauuu6MENG9t4CZEiFJMUJICHt\nYj8MRNdD6OVnMiTQhwtfW2WFMGghgb4gV+lt3XX9F4CUd8hkRTrUebgYyDUHgG6cvg6kIINvX5IU\nA1vL5NNAGA4USkgHd20tk+8DEXSRBbaWyaeBhGYPSY8hpng4EJUJtOz9AxJCbOAhUgi5iS6xtU56\nQEb+2gaSd1p/BOLdQeQA0P0QSmNroXSAQBj4ax1IXk2mJyJ51xcL1hJbKyU7hrFEYy9+2lvuuBEW\nXuGGrWekLlmvf3TCaOGnVpP5sQsI0+TWAdkgX7cliLJc1WWHOBBj4kCMiQMxJg7EmDgQY+JAjIkD\nMSYOxJj4Tv29O/X5ZJJ4BOSZz5EPw0pvxKfltk6p1heOLs5P1u/ZkkvPVsPj6WfLDkQgvwrkqqCf\nA7K9McD1yenUqPQiUVd7WQ/RJcsSINWHW/NA8Ov4UeaO39noyowtyB/Nqi5ckyH4XeXajY4P9ctO\nTei7tU4mbP2le4hTdS+QW6p/+unHE/KVnwGCf5RXYWu/al1laaZxJxkT5oHUedJjcw4I8hCnR+4b\nb+0hKCHiN4Dqdoe2FG6tUWU8TKcECy6zQKpUqDLEPpC0A0lJEQZuvwPIhQJytpQaHVsKtxapXh4C\n+hlcrqmMTNgHElBr/ztvsodkVSBM0iu06GLuwCIQvJxKd0EKV1RrEzEAJEEIFx7c5XNLaZmwA6Ra\nVOHIozwxWbKSs+n3BiogIf20+muBoEvq04PVo8KtBaoxmQPO7ZjgnwQSgKR+c2OyDQjtafEXOdLL\nlDA5zelh04QdIFUPKQONZh7XVNJprVszqmTtkZ1CjZxpdb1iaxFI0oHqkPz2Bw8kp5bWrRlVaj7k\n+JNfVSku/BSQ0O4hZa3TulW/U6baCEhLvgkEyKRLcxEBWZwhQAZiSs91Ompnj1KDS6caF3W8sQak\n2gGS+U/n3kM9JOXhQBW3DsBcWj1E5I05INzVdb883dSjY+1iRfN4CMcAkPEEQtOvBpInID6xFQit\noiyWEMgfgYljQFo+Zk6oTNU9BHHC974TSJtGnDpp2rwOSEkBHVZYSPxLQhuBNHDQXEZ39CYg9dLq\n32EZeXNAOk2E5MvrekjymzvMM65e9h4BQh1sZUn2U2fCxCqrXjLlsyTcZNaFM0BKZxtZkX3SmbAB\npKSAzjZKFlI5CCQQ69iRvC1RmrABJKB7nAUSNq2yUpPGgafe4ddaEyaAVNvzeATtkkWjsXPZC0CY\nNESytOJM2ADCX9cDUq2ydu/URUsswe63NGEDCOt3H0iVMgMTbbcmVKE0z6FAqaQwYQII2ZOUJSvw\n+5AKyLIMIYRZ1cETE+RSzw7vjTUg1aE0QzI+rVv9dyo68dwPAkkhJs+rqtPLgQxVRyRKMBoTJoBU\ndQo/NOwmhEkg2bMA0pVfN0h6SN0rVPDR/H8vkBC/fQFIiNsJDgh7eisQoNufNhCcIxoTmuAL2+At\nWxhIPjSTIWXrGoN5sodsAQJxDiqXvbuAyEiE67veRGsTmiZofghwHcYlP/or1pIJW7U219/tAOli\nAJIU8YzORAvIH5GLxrUWjWGPZ4GoXkVGaavWhkQX3c0rgBA4MUlW7EMoglTH0x7hqvBQq+ptccqo\nTgVTGSLG8efKPiBoDmTVZnJON/Uy8qeBqHAAqjAab2YzJJT1rI1kBkhCPmjqoQQnMKHwhqqKKFQT\nRunN0pK1rIfgOws9IBwhocwAGTd1+qoVkRqTFEhKAgACA5+91dT5KWSxZHVZMGT6JaN8R5whADkf\nUkWEvN69pnNom+/aqn2DhB7QbW0FAuWtEC/aFMr3e5ZVQCROK0QFJKVmWtFvBwLVu5C+5InSqhfc\nTQf7QP4dphCTTrIZCJn9oQ8E+xPSZKprR3XCDpDKt3Q3TPc4WLLkz6+QR2QySb1ZEvKFtnJc68g3\nTi8HwqlSa2MYAKkFvxFInpJoUjFAqvhvA5LXlBIY1+Coaom9MQEEN45QAgmpe5xf9qrWvvEe2utP\nzhtrQFAfrCJ/emOoWGEFvFZWeWMDSJxRzOEbgUDKc7FPdoFkPTzZ0HEZ/21A6AwYALluCd2Z0Btz\nQNKNcEDKG65PTLglVNWufEOuvRpvbAAJXFogNueBgCI9suMgW2IFc0Auz4NZIH/NWcoiOh7oekXk\njQ0ggc2QUBQrPv67gEzs1dMNvW3ZizeGcXbZWvZOACGGXrwxzPdyCkg9p0FDI+4gubsTeONABO/M\nF6zi7gTeGAXCojhSsqJDaiJkCLk3JoBUPaRu1nuBQPVSByRv09Xe2ABClVuRfw8QSAsBtTfmgKS4\nngTCqKpwXEi+AATtA20BuXzrQkjH6aoPAEmaAyCBL20TbolVezwIm5D09d7YBGJolZVUpThaPPp4\nTgFRzR8onmKd7SEh0GIKpQuZBzAtZFDADgHBG46h8SryjUoGaOiHgTRSAgJyhawUqzGG3pgDku+i\nDPTZHtIBknODAgmKByhmgVQadUKcARKIIXKETpWO4xR5Zw/BQIpAk/gXDSaO9+yyN7pdcigyJPpG\nMkRqwtoqqwWkzBCswtlSuCVUxVOBwoiQijFL32TeWAPCP9aqmzpRgZnbaavWoQ15wqenVPE/PEnm\no2kXCL2uqk1FhoSrLOATWreYN6ACAghITJRAkiNTUSRG7Y05IFU9SrUAmPijqbmshyQryIsY+exF\n1UtoSmvFGJBizqeTRclCG3ikgmAtKlnle7FMobiTHhK7DHJEK7aAYApID+dGptDoIQuBVO/RKJd5\n+jtA0IkWsvL0IiC1Km4MRWHKQFCN1YpZIPXtoPlfKVf7mseA1OeKNjPdzgsTJoAI7qSM/MiWwq0F\nqnNlijVhA4hoDMnlDmSTLQeyUH4AyJ3uUZh4CRDpHT8EZIN83dZSIC47xIEYEwdiTByIMXEgxsSB\nGBMHYkwciDFxIMbEd+rv3alDz3f5MCJvqs+FlHdfvpDYelCeAtKJwZq7KoOEP4ZUMIkfbsYv9jYd\niMYbByJSdSCT4j2kfCGx9aA8+AGVLB6zwgSpDPCcyGw9JuR2+iFSApHc+82PROuD8seHJT4Qf1if\ntgLJFEbWHMi7S5YDmRLvIQKfPgLkWTkSpHcDeTRB2GUvaOuV0JlvABGEYGXJAuWOUOOMA9F440CE\nqg5kSryHCJz5CJB43I2SfMyWiXKIORDpmPPpU0D61Wv+FltBAuGWNH6/sjngX1CV2npCHIgDcSA9\n8R6CrwqmesgoPvNARGFR0qmWvWvkCgN15gwQoC97qopRg3ghqrNQBumv5mijz54JoXRmKxCIk8GB\n2ACCDuGJkuVAdLKlqYtwgPcQpYlnVGflSJC+BkQwP/UmiqK7JEsEtp6SnUBGRT5M/aQxXifmfx9N\nEHYg2mmr+PmNITrrQMbiQH4YiPcQgewDAnFNuYYIDhLc+qwwm77+zt8YW0/LNiDphhvhaP6U2shE\nekLLFKtQGmmaRV9/ngaOgwMRmHAgc6oORHlf+ROBsapiVHTOe4jqvsbWVibTfShVkJrAAx6axL5S\nof4lKLNAuCX08JqJENxXjREoA/g313UmIP8VS1AxXixnIWAbf3/hlEBwU/0EzpZUpoA0X/RVFaOy\n7/8KkMaLJdc4kO1A9qlCR5QmrPWQeNmFHXmmu69TqrNyZOUjAgJ5ER7bCPuEbGBrj2ovM8ok6c8p\nJkhsUvDDN2ySV9m+MkNCQJsjUlOll29TRaFqxSzNJuiME7ggpfZQjx3qY3oqQJrI0QNk/yYQoI1I\ncPk21Z8EEpuI4FqhiXWqPwkEoxFevk+1QaEK4KUrMWGuh7yqqTcvKMMVz4YWmEGQSqzor96o+I3s\nijJDkoGYHnEZLBEbQOKMQvFKfxqlqx+kuNPD9QIEo6JKmYIIWiC3xIEw4zoQB8JdPuo83kPuBlsi\ngI/6D/aWA2kugtD35khVkKqlETdsVCyWVhUvangrkDyVwmAlsBpIsSdJ+4P01c3ZMkhlJYphRU98\nAypbkOZ+XdhysWvYelKI2b49B7IZyMieA9kOZLOq9xBGTgK5JUeC5EDieHWmPBek2pgDYYbbFiTG\nmANhhnMgm1SlwzmQTaqy8byH7FFN9x7Xmv2lLmsCj8CN3xkzL3aFO7CvA0nV4dqNoT2h3ATQoarx\n2xvMuB28/ohtPSrZRNzQClQVow7VHEjD1t+jAwcisPWo4AwZWPQesgWINACGVllAZrzGLemtLrA1\nK9B80VdVjHpfaO7+vZoI0qgENC9xIMxwPwnkhKp0OAeySVU23o/2kBOqs3IkSD8GBE/g4WRuBmki\nDUZX/SgQXOLH5b4VpIlGMbzKgTiQc6r0IgdiCIj3EKUJX2U5EImJr9oaG3Qge4EMn3w7kN0ZMvhk\nyIFssYXSYrA+2Q1EmK+V0twyq+tJ09Z6geaLvqpi1EkZbCjay95F9iW2HhAHInSFtfWA2F32OpAz\nqp1BvIecUJ2Vz66ynlHdIF+3tRRIpS58MXfRfuH61j2FmVtyIE37DkTnynJxIA5E4IXLYXEgxsSB\nGBMHYkwciDFxIMZEBwSa61lormCLd/h/AKZ654QU9kuHOr/FLVSYcGKo3Ag1NOmU14QGkNM0aheK\nD79hBGCoMOOETr8FpLcxxBdBA+8RYTJ0tBMcAXk6QwBINKVA2mWuC26vABS5W4YXyoSp4r8fCJPU\nDWfa2VJkSHOE/cI8JR/NFwNAmr2719Q7r8g7KlcekGFTH8R7f1N3eV4ciDFxIMbEgRgTB2JMHIgx\ncSDGxIEYEwdiTByIMXEgxsSBGBMHYkwciDFxIMbEgRgTB2JMHIgxcSDGxIEYEwdiTByIMXEgxsSB\nGBMHYkwciDH5D0wnHLeg4A/BAAAAAElFTkSuQmCC\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAWx0lE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\nkwDiTAKIMwkgziSAOJN//4YOjFvgtVQAAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAY00lE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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAYeklE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\nsKsAAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAdt0lE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\nmRwgm8kBspkcIJvJAbKZHCCbyQGymfwDZjgGqudc3vAAAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "#pdf(\"simulation_model_fits.pdf\")\n",
    "tre <- read.tree(text=baltre)\n",
    "plot(tre, 'u', no.margin=TRUE)\n",
    "plot(rdf0[,c(5,6,7)], main=\"Balanced tree - phylo missing\")\n",
    "plot(rdf2[,c(5,6,7)], main=\"Balanced tree - low-cov missing\")\n",
    "\n",
    "tre <- read.tree(text=imbtre)\n",
    "plot(tre, 'u', no.margin=TRUE)\n",
    "plot(rdf1[,c(5,6,7)], main=\"Imbalanced tree - phylo missing\")\n",
    "plot(rdf3[,c(5,6,7)], main=\"Imbalanced tree - low-cov missing\")\n",
    "#dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tbaldrop\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(                Value  Std.Error    t-value       p-value\n",
       " (Intercept)  1.316493   0.325814   4.040626  7.638131e-05\n",
       " inputreads   0.108283   0.049725   2.177644  3.062066e-02\n",
       " pdist       -0.723854   0.035767 -20.238321  5.347518e-50,\n",
       " array([-86.29341942]),\n",
       " array([-98.23571647]),\n",
       " 0.99960021071899874)"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset = dsets[0]\n",
    "print dset.name\n",
    "fitmodels(dset.tree, dset.df4, nsamples=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timbdrop\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(                Value  Std.Error    t-value       p-value\n",
       " (Intercept)  0.357928   0.118206   3.027992  2.791243e-03\n",
       " inputreads   0.077981   0.029384   2.653831  8.608192e-03\n",
       " pdist       -0.775967   0.033450 -23.197634  3.084181e-58,\n",
       " array([ 6.62460087]),\n",
       " array([-41.82783388]),\n",
       " 0.99960021071899874)"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset = dsets[1]\n",
    "print dset.name\n",
    "fitmodels(dset.tree, dset.df4, nsamples=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tbalvarcov\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(                Value  Std.Error   t-value       p-value\n",
       " (Intercept) -0.005006   0.378422 -0.013229  9.894588e-01\n",
       " inputreads   0.438420   0.050747  8.639289  1.932216e-15\n",
       " pdist        0.022305   0.039779  0.560736  5.756146e-01,\n",
       " array([-115.62919649]),\n",
       " array([-218.92689998]),\n",
       " 0.99960021071899874)"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset = dsets[2]\n",
    "print dset.name\n",
    "fitmodels(dset.tree, dset.df4, nsamples=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timbvarcov\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(                Value  Std.Error   t-value   p-value\n",
       " (Intercept)  0.292225   0.296549  0.985420  0.325626\n",
       " inputreads   0.278069   0.066178  4.201821  0.000040\n",
       " pdist        0.015019   0.083815  0.179189  0.857973,\n",
       " array([-169.63423911]),\n",
       " array([-250.95969846]),\n",
       " 0.99960021071899874)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset = dsets[3]\n",
    "print dset.name\n",
    "fitmodels(dset.tree, dset.df4, nsamples=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 871,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def AICc(LL, k, n):\n",
    "    return (-2*LL) + 2*k + ((2*k * (k+1))/float(n-k-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run 100 replicate subsample models for each data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## store results in this array\n",
    "ntests = 100\n",
    "nsamples = 200\n",
    "\n",
    "## for each test\n",
    "for dset in dsets:\n",
    "    \n",
    "    ## create output storage arrays\n",
    "    dset.tab = np.zeros((ntests, 3, 4), dtype=np.float64)\n",
    "    dset.LL = np.zeros((2, ntests), dtype=np.float64)\n",
    "    dset.lam = np.zeros(ntests, dtype=np.float64)\n",
    "    dset.asyncs = {}\n",
    "\n",
    "    ## send jobs to get results in parallel\n",
    "    for tidx in xrange(ntests):\n",
    "        dset.asyncs[tidx] = lbview.apply(fitmodels, *[dset.tree, dset.df4, nsamples])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 400/400 tasks finished after 2532 s\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "## check progress on running jobs\n",
    "ipyclient.wait_interactive()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## enter results into results array when finished\n",
    "for dset in dsets:\n",
    "    ## create empty results arrays\n",
    "    dset.tab = np.zeros((ntests, 3, 4), dtype=np.float64)\n",
    "    dset.LL = np.zeros((ntests, 2), dtype=np.float64)\n",
    "    dset.lam = np.zeros(ntests, dtype=np.float64)\n",
    "    \n",
    "    for tidx in range(ntests):\n",
    "        if dset.asyncs[tidx].ready():\n",
    "            res = dset.asyncs[tidx].get()\n",
    "            dset.tab[tidx] = res[0]\n",
    "            dset.LL[tidx] = res[1], res[2]\n",
    "            dset.lam[tidx] = res[3]\n",
    "        else:\n",
    "            print \"job: [{}, {}] is still running\".format(dset.name, tidx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulated data sets results\n",
    "In all of the data sets the phylo corrected model was a better fit to the data by 30-90 AIC points. When data was missing from low sequence coverage it was best predicted by the inputreads, and when data was missing from mutation-disruption it was best explained by phylo distances. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def results_table(dset):\n",
    "    \n",
    "    tdat = dset.tab.mean(axis=0)\n",
    "    \n",
    "    df = pd.DataFrame(\n",
    "            index=[\"fit\"],\n",
    "            data=[\n",
    "             pd.Series([np.mean(dset.LL[:, 0] - dset.LL[:, 1]),\n",
    "                        dset.lam.mean(),\n",
    "                        tdat[1, 0],\n",
    "                        tdat[1, 3],\n",
    "                        tdat[2, 0], \n",
    "                        tdat[2, 3]],\n",
    "                        index=[\"deltaAIC\", \"lambda\", \n",
    "                               \"raw_coeff\", \"raw_P\",\n",
    "                               \"phy_coeff\", \"phy_P\"\n",
    "                               ]), \n",
    "            ])\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for dset in dsets:\n",
    "    print dset.name, \"---\"*23\n",
    "    print results_table(dset)\n",
    "    print \"---\"*27, \"\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## confidence intervals\n",
    "The fit for this data set yields a negative AIC both with and without a covariance matrix. This shows that the amount of input data (raw) is a better predictor of shared data bewteen samples than is their phylogenetic distance. See the plot below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## get a stats module\n",
    "import scipy.stats as st\n",
    "\n",
    "\n",
    "def get_CI(a):\n",
    "    mean = np.mean(a)\n",
    "    interval = st.t.interval(0.95, len(a)-1, loc=np.mean(a), scale=st.sem(a))\n",
    "    return mean, interval[0], interval[1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tbaldrop\n",
      "LL  (23.856759534274129, 21.829749489780468, 25.88376957876779)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.13568239558264156, 0.12812141652035028, 0.14324337464493284)\n",
      "raw_P (0.024666691324290207, 0.014585128766543148, 0.034748253882037269)\n",
      "phy_coeff (-0.6769798951303041, -0.68335711359863527, -0.67060267666197293)\n",
      "phy_P (2.5749563846554715e-40, -2.1841376927471948e-40, 7.3340504620581375e-40)\n",
      "\n",
      "Timbdrop\n",
      "LL  (65.677319469030465, 63.130619443668124, 68.224019494392806)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.057643349844981484, 0.052702255250656013, 0.062584444439306955)\n",
      "raw_P (0.078935644079727127, 0.05246785465072315, 0.1054034335087311)\n",
      "phy_coeff (-0.77709373560218054, -0.78286652717051897, -0.7713209440338421)\n",
      "phy_P (2.1047686953953927e-59, -4.7643012141171706e-60, 4.6859675122025025e-59)\n",
      "\n",
      "Tbalvarcov\n",
      "LL  (78.160889279028424, 76.068056338898998, 80.253722219157851)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.35128825560093851, 0.34082473460307039, 0.36175177659880664)\n",
      "raw_P (1.3183899732423276e-07, -5.5784128110233774e-08, 3.1946212275869927e-07)\n",
      "phy_coeff (-0.00612831649171527, -0.012117164720679634, -0.00013946826275090547)\n",
      "phy_P (0.60362763190802926, 0.55326502361874741, 0.65399024019731111)\n",
      "\n",
      "Timbvarcov\n",
      "LL  (76.682759432397859, 74.920532620064662, 78.444986244731055)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.34023863918167563, 0.32905835388085114, 0.35141892448250012)\n",
      "raw_P (7.3272761061072709e-05, -1.6711962605099048e-05, 0.00016325748472724447)\n",
      "phy_coeff (0.052547183798245793, 0.038303516368061272, 0.066790851228430315)\n",
      "phy_P (0.4136614928394971, 0.35713627283852079, 0.47018671284047342)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for dset in dsets:\n",
    "    print dset.name\n",
    "    print \"LL \", get_CI(dset.LL[:,0]-dset.LL[:,1])\n",
    "    print \"lambda\", get_CI(dset.lam)\n",
    "    print \"raw_coeff\", get_CI(dset.tab[:, 1, 0])\n",
    "    print \"raw_P\", get_CI(dset.tab[:, 1, 3])\n",
    "    print \"phy_coeff\", get_CI(dset.tab[:, 2, 0])\n",
    "    print \"phy_P\", get_CI(dset.tab[:, 2, 3])\n",
    "    print \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to deal with large matrices (absurd run times)\n",
    "OK, so in our test example it takes about 10 minutes to compute a matrix with only 4000 elements, meaning we can expect that a matrix of several hundred thousand elements will pretty much never finish. One work around for this is to take a sub-sampling approach. The full matrix for 13 taxa is ~700 induced quartets, while the full data set for 65 taxa is ~700K. For the latter we will subsample 100 matrices composed of 1000 random quartets. Then we will compute the covariance matrix of the sampled quartets and fit a regression model. Finally, the results over all 100 subsampled replicates will be reported as a 95% confidence interval. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get all 10 empirical data sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## data set 1 (Viburnum)\n",
    "data1 = dataset(\"data1\")\n",
    "data1.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_1/fullrun/outfiles/empirical_1_full_m4.loci\"\n",
    "data1.files.tree = \"/home/deren/Documents/RADmissing/empirical_1/fullrun/RAxML_bipartitions.empirical_1_full_m4\"\n",
    "data1.files.s2 = \"/home/deren/Documents/RADmissing/empirical_1/fullrun/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 2 (Phrynosomatidae)\n",
    "data2 = dataset(\"data2\")\n",
    "data2.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_2/outfiles/empirical_2_m4.loci\"\n",
    "data2.files.tree = \"/home/deren/Documents/RADmissing/empirical_2/RAxML_bipartitions.empirical_2\"\n",
    "data2.files.s2 = \"/home/deren/Documents/RADmissing/empirical_2/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 3 (Quercus)\n",
    "data3 = dataset(\"data3\")\n",
    "data3.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_3/outfiles/empirical_3_m4.loci\"\n",
    "data3.files.tree = \"/home/deren/Documents/RADmissing/empirical_3/RAxML_bipartitions.empirical_3\"\n",
    "data3.files.s2 = \"/home/deren/Documents/RADmissing/empirical_3/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 4 (Orestias)\n",
    "data4 = dataset(\"data4\")\n",
    "data4.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_4/outfiles/empirical_4_m4.loci\"\n",
    "data4.files.tree = \"/home/deren/Documents/RADmissing/empirical_4/RAxML_bipartitions.empirical_4\"\n",
    "data4.files.s2 = \"/home/deren/Documents/RADmissing/empirical_4/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 5 (Heliconius)\n",
    "data5 = dataset(\"data5\")\n",
    "data5.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_5/outfiles/empirical_5_m4.loci\"\n",
    "data5.files.tree = \"/home/deren/Documents/RADmissing/empirical_5/RAxML_bipartitions.empirical_5\"\n",
    "data5.files.s2 = \"/home/deren/Documents/RADmissing/empirical_5/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 6 (Finches)\n",
    "data6 = dataset(\"data6\")\n",
    "data6.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_6/outfiles/empirical_6_m4.loci\"\n",
    "data6.files.tree = \"/home/deren/Documents/RADmissing/empirical_6/RAxML_bipartitions.empirical_6\"\n",
    "data6.files.s2 = \"/home/deren/Documents/RADmissing/empirical_6/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 7 (Danio)\n",
    "data7 = dataset(\"data7\")\n",
    "data7.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_7/outfiles/empirical_7_m4.loci\"\n",
    "data7.files.tree = \"/home/deren/Documents/RADmissing/empirical_7/RAxML_bipartitions.empirical_7\"\n",
    "data7.files.s2 = \"/home/deren/Documents/RADmissing/empirical_7/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 8 (Barnacles)\n",
    "data8 = dataset(\"data8\")\n",
    "data8.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_8/outfiles/empirical_8_m4.loci\"\n",
    "data8.files.tree = \"/home/deren/Documents/RADmissing/empirical_8/RAxML_bipartitions.empirical_8\"\n",
    "data8.files.s2 = \"/home/deren/Documents/RADmissing/empirical_8/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 9 (Ohomopterus)\n",
    "data9 = dataset(\"data9\")\n",
    "data9.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_9/outfiles/empirical_9_m4.loci\"\n",
    "data9.files.tree = \"/home/deren/Documents/RADmissing/empirical_9/RAxML_bipartitions.empirical_9\"\n",
    "data9.files.s2 = \"/home/deren/Documents/RADmissing/empirical_9/stats/s2.rawedit.txt\"\n",
    "\n",
    "## data set 10 (Pedicularis)\n",
    "data10 = dataset(\"data10\")\n",
    "data10.files.loci4 = \"/home/deren/Documents/RADmissing/empirical_10/outfiles/empirical_10_m4.loci\"\n",
    "data10.files.tree = \"/home/deren/Documents/RADmissing/empirical_10/RAxML_bipartitions.empirical_10_m4\"\n",
    "data10.files.s2 = \"/home/deren/Documents/RADmissing/empirical_10/stats/s2.rawedit.txt\"\n",
    "\n",
    "## put all in a list\n",
    "datasets = [data1, data2, data3, data4, data5,\n",
    "            data6, data7, data8, data9, data10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create large data frames for each data set\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data1 \n",
      "[[0 0 0 ..., 0 0 0]\n",
      " [0 1 0 ..., 1 1 0]\n",
      " [0 1 0 ..., 1 0 0]\n",
      " ..., \n",
      " [0 1 0 ..., 1 0 0]\n",
      " [0 0 0 ..., 0 0 1]\n",
      " [0 0 0 ..., 1 0 0]] \n",
      "\n",
      "data2 \n",
      "[[0 1 0 ..., 0 0 0]\n",
      " [0 0 1 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]\n",
      " ..., \n",
      " [1 1 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 1 0]\n",
      " [1 0 0 ..., 0 1 0]] \n",
      "\n",
      "data3 \n",
      "[[0 0 1 ..., 1 1 1]\n",
      " [1 1 0 ..., 1 1 0]\n",
      " [1 1 1 ..., 1 1 1]\n",
      " ..., \n",
      " [1 0 0 ..., 1 1 1]\n",
      " [1 1 1 ..., 0 1 1]\n",
      " [1 0 1 ..., 1 1 1]] \n",
      "\n",
      "data4 \n",
      "[[1 1 0 ..., 1 1 0]\n",
      " [0 1 0 ..., 1 1 0]\n",
      " [0 1 0 ..., 0 1 0]\n",
      " ..., \n",
      " [0 0 0 ..., 1 1 1]\n",
      " [1 0 1 ..., 1 1 0]\n",
      " [1 0 1 ..., 1 1 0]] \n",
      "\n",
      "data5 \n",
      "[[1 0 0 ..., 0 0 0]\n",
      " [1 0 0 ..., 1 0 0]\n",
      " [1 0 0 ..., 1 0 0]\n",
      " ..., \n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]] \n",
      "\n",
      "data6 \n",
      "[[1 0 1 ..., 1 0 0]\n",
      " [1 0 1 ..., 1 0 0]\n",
      " [1 0 1 ..., 1 0 0]\n",
      " ..., \n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]] \n",
      "\n",
      "data7 \n",
      "[[0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]\n",
      " ..., \n",
      " [0 0 1 ..., 0 0 0]\n",
      " [0 0 1 ..., 1 0 1]\n",
      " [0 0 1 ..., 1 0 0]] \n",
      "\n",
      "data8 \n",
      "[[1 0 0 ..., 0 0 1]\n",
      " [0 0 1 ..., 0 0 0]\n",
      " [1 1 1 ..., 0 1 1]\n",
      " ..., \n",
      " [0 0 1 ..., 1 0 1]\n",
      " [1 0 0 ..., 1 0 0]\n",
      " [0 0 0 ..., 0 0 0]] \n",
      "\n",
      "data9 \n",
      "[[0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 1 0 0]\n",
      " ..., \n",
      " [0 0 0 ..., 0 0 0]\n",
      " [0 1 0 ..., 0 1 0]\n",
      " [0 0 0 ..., 0 0 0]] \n",
      "\n",
      "data10 \n",
      "[[1 0 1 ..., 0 1 0]\n",
      " [1 0 0 ..., 0 1 1]\n",
      " [1 1 0 ..., 0 1 1]\n",
      " ..., \n",
      " [1 0 1 ..., 0 1 1]\n",
      " [1 0 1 ..., 1 1 1]\n",
      " [1 0 1 ..., 1 1 1]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "## submit parallel [getarray] jobs\n",
    "asyncs = {}\n",
    "for dset in datasets:\n",
    "    asyncs[dset.name] = lbview.apply(getarray, *[dset.files.loci4, dset.files.tree])\n",
    "    \n",
    "## collect results\n",
    "ipyclient.wait()\n",
    "for dset in datasets:\n",
    "    dset.lxs4, dset.tree = asyncs[dset.name].get()\n",
    "    print dset.name, \"\\n\", dset.lxs4, \"\\n\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   p1  p2  p3  p4     nloci  inputreads     pdist\n",
      "0   0   1   2   3  9.480062   14.934133  0.032760\n",
      "1   0   1   2   4  9.824553   14.934133  0.031800\n",
      "2   0   1   2   5  9.613269   15.142473  0.046649\n",
      "3   0   1   2   6  9.850772   15.052855  0.045819\n",
      "4   0   1   2   7  9.711237   14.934133  0.045416\n"
     ]
    }
   ],
   "source": [
    "## submit parallel [buildarray] jobs\n",
    "for dset in datasets:\n",
    "    dset.df4 = build_df4_parallel(dset.tree, dset.lxs4, dset.files.s2, lbview)\n",
    "\n",
    "## peek at one of the data sets\n",
    "print datasets[0].df4.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   p1  p2  p3  p4     nloci  inputreads     pdist\n",
      "0   0   1   2   3  1.741054    0.721897 -3.258168\n",
      "1   0   1   2   4  2.278262    0.721897 -3.306778\n",
      "2   0   1   2   5  1.948780    1.565089 -2.555040\n",
      "3   0   1   2   6  2.319149    1.202390 -2.597063\n",
      "4   0   1   2   7  2.101554    0.721897 -2.617438\n"
     ]
    }
   ],
   "source": [
    "for dset in datasets:\n",
    "    for var in [\"nloci\", \"inputreads\", \"pdist\"]:\n",
    "        dset.df4[var] = (dset.df4[var] - dset.df4[var].mean()) / dset.df4[var].std()\n",
    "    \n",
    "## peek again\n",
    "print datasets[0].df4.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## pass objects into R\n",
    "rdf0 = datasets[0].df4.loc[np.random.choice(range(630000), 1000), :]\n",
    "\n",
    "rdftre = datasets[0].tree.write()\n",
    "%R -i rdf0,rdftre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAARrklE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\nTAcImA4QMB0gYDpAwHSAgOkAAdN/dKdiUMfdpUAAAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAcsklE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\nAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "#pdf(\"simulation_model_fits.pdf\")\n",
    "tre <- read.tree(text=rdftre)\n",
    "plot(tre, 'u', no.margin=TRUE, show.tip.label=FALSE)\n",
    "plot(rdf0[,c(5,6,7)], main=\"Viburnum tree -- empirical\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## store results in this array\n",
    "ntests = 100\n",
    "nsamples = 200\n",
    "\n",
    "## for each test\n",
    "for dset in datasets:\n",
    "    \n",
    "    ## create output storage arrays\n",
    "    dset.tab = np.zeros((ntests, 3, 4), dtype=np.float64)\n",
    "    dset.LL = np.zeros((2, ntests), dtype=np.float64)\n",
    "    dset.lam = np.zeros(ntests, dtype=np.float64)\n",
    "    dset.asyncs = {}\n",
    "\n",
    "    ## send jobs to get results in parallel\n",
    "    for tidx in xrange(ntests):\n",
    "        dset.asyncs[tidx] = lbview.apply(fitmodels, *[dset.tree, dset.df4, nsamples])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000/1000 tasks finished after 3106 s\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "ipyclient.wait_interactive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collect the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## enter results into results array when finished\n",
    "for dset in datasets:\n",
    "    ## create empty results arrays\n",
    "    dset.tab = np.zeros((ntests, 3, 4), dtype=np.float64)\n",
    "    dset.LL = np.zeros((ntests, 2), dtype=np.float64)\n",
    "    dset.lam = np.zeros(ntests, dtype=np.float64)\n",
    "    \n",
    "    for tidx in range(ntests):\n",
    "        if dset.asyncs[tidx].ready():\n",
    "            res = dset.asyncs[tidx].get()\n",
    "            dset.tab[tidx] = res[0]\n",
    "            dset.LL[tidx] = res[1], res[2]\n",
    "            dset.lam[tidx] = res[3]\n",
    "        else:\n",
    "            print \"job: [{}, {}] is still running\".format(dset.name, tidx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print results means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data1 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff         raw_P  phy_coeff     phy_P\n",
      "fit  130.698514  0.9996   0.308544  2.284103e-08  -0.101696  0.026328\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data2 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff     raw_P  phy_coeff         phy_P\n",
      "fit  139.766655  0.9996   0.171828  0.000001  -0.437113  7.029035e-15\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data3 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff     raw_P  phy_coeff     phy_P\n",
      "fit  196.594784  0.9996   0.147195  0.006394  -0.126762  0.104418\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data4 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff         raw_P  phy_coeff    phy_P\n",
      "fit  135.528055  0.9996    0.26352  3.206787e-07  -0.038706  0.37362\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data5 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff     raw_P  phy_coeff     phy_P\n",
      "fit  206.681699  0.9996   0.041942  0.035345  -0.131127  0.000046\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data6 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff     raw_P  phy_coeff    phy_P\n",
      "fit  262.789548  0.9996  -0.065005  0.057379   0.071715  0.01649\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data7 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff     raw_P  phy_coeff         phy_P\n",
      "fit  310.781023  0.9996  -0.009397  0.451061  -0.211941  1.866769e-18\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data8 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff         raw_P  phy_coeff     phy_P\n",
      "fit  126.584662  0.9996   0.209495  4.947476e-07  -0.275779  0.005751\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data9 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff     raw_P  phy_coeff     phy_P\n",
      "fit  195.862972  0.9996   0.085873  0.036113  -0.099374  0.017746\n",
      "--------------------------------------------------------------------------------- \n",
      "\n",
      "data10 ---------------------------------------------------------------------\n",
      "       deltaAIC  lambda  raw_coeff         raw_P  phy_coeff     phy_P\n",
      "fit  234.039394  0.9996   0.239064  7.795647e-13  -0.073352  0.041957\n",
      "--------------------------------------------------------------------------------- \n",
      "\n"
     ]
    }
   ],
   "source": [
    "for dset in datasets:\n",
    "    print dset.name, \"---\"*23\n",
    "    print results_table(dset)\n",
    "    print \"---\"*27, \"\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### So, for example, why is this one a poor fit for pdist?\n",
    "There are three clouds of points corresponding to comparisons within and between the major clades. Some with little phylo distance between them have tons of data, while some with tons of data between them have very few data. It comes down to whether those data points include the same few samples or not. When we control for their non-independence, those clouds of points represent much less information, and in essence the pattern disappears. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## pass objects into R\n",
    "rdf0 = datasets[5].df4.loc[np.random.choice(range(10000), 1000), :]\n",
    "rdftre = datasets[5].tree.write()\n",
    "%R -i rdf0,rdftre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAKTElE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\nYwwixhhEjDGIGP8BYwJtIbfpVasAAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAMAAAC3Ycb+AAAABlBMVEUAAAD///+l2Z/dAAAcIUlE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\nMdlAFpMNZDHZQBaTDWQx+Qe3mhYT1Nnu3AAAAABJRU5ErkJggg==\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "#pdf(\"simulation_model_fits.pdf\")\n",
    "tre <- read.tree(text=rdftre)\n",
    "plot(tre, 'u', no.margin=TRUE, show.tip.label=FALSE)\n",
    "plot(rdf0[,c(5,6,7)], main=\"Finch tree -- empirical\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confidence intervals "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data1\n",
      "LL  (130.69851434371012, 128.12865718594313, 133.26837150147711)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.30854365419893531, 0.30269096411409419, 0.31439634428377644)\n",
      "raw_P (2.2841026613240539e-08, 5.1787065617999179e-09, 4.050334666468116e-08)\n",
      "phy_coeff (-0.10169604278335902, -0.10569554280416416, -0.097696542762553878)\n",
      "phy_P (0.026328111852941694, 0.019620024893717718, 0.033036198812165671)\n",
      "\n",
      "data2\n",
      "LL  (139.76665526389243, 137.16253099018172, 142.37077953760314)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.1718278777600889, 0.16635506033100297, 0.17730069518917482)\n",
      "raw_P (1.0950423602466082e-06, -1.3680492412632838e-07, 2.3268896446195447e-06)\n",
      "phy_coeff (-0.43711285751896845, -0.44358870600769951, -0.43063700903023738)\n",
      "phy_P (7.0290350999570793e-15, -6.4202800228952231e-16, 1.4700098202203681e-14)\n",
      "\n",
      "data3\n",
      "LL  (196.59478360519438, 194.66975703591095, 198.51981017447781)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.14719506453520051, 0.14028677047834764, 0.15410335859205337)\n",
      "raw_P (0.0063935572171347557, 0.0036684884902602865, 0.009118625944009225)\n",
      "phy_coeff (-0.12676238705894194, -0.13719789743782845, -0.11632687668005542)\n",
      "phy_P (0.10441833760088796, 0.073900276473389051, 0.13493639872838686)\n",
      "\n",
      "data4\n",
      "LL  (135.52805468003675, 132.67624437123467, 138.37986498883882)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.26351986100513658, 0.25728172262366594, 0.26975799938660722)\n",
      "raw_P (3.2067865675438907e-07, -2.1990739295284825e-09, 6.4355638743830667e-07)\n",
      "phy_coeff (-0.03870593530451398, -0.055583095172031929, -0.021828775436996028)\n",
      "phy_P (0.37361999871579521, 0.31809628380959681, 0.42914371362199361)\n",
      "\n",
      "data5\n",
      "LL  (206.68169885465852, 201.01657316843801, 212.34682454087903)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.041942499113223945, 0.039909247897479877, 0.043975750328968014)\n",
      "raw_P (0.03534488855256359, 0.023335990347855898, 0.047353786757271282)\n",
      "phy_coeff (-0.13112695471720004, -0.13754131524753868, -0.1247125941868614)\n",
      "phy_P (4.6392639014248775e-05, 5.3599213896538041e-06, 8.7425356638843753e-05)\n",
      "\n",
      "data6\n",
      "LL  (262.7895477377449, 260.35762250508805, 265.22147297040175)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (-0.065005132598861023, -0.067689178891608345, -0.062321086306113695)\n",
      "raw_P (0.057378601069832239, 0.044727990466165699, 0.070029211673498779)\n",
      "phy_coeff (0.071714773239201848, 0.068207978646457904, 0.075221567831945793)\n",
      "phy_P (0.016489653303115658, -0.0026715439419844368, 0.035650850548215748)\n",
      "\n",
      "data7\n",
      "LL  (310.78102326794919, 308.6602926482326, 312.90175388766579)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (-0.0093974359164832617, -0.010722344879289978, -0.0080725269536765457)\n",
      "raw_P (0.45106129377420656, 0.39970571751418538, 0.50241687003422775)\n",
      "phy_coeff (-0.21194119911559028, -0.21774941789933386, -0.20613298033184671)\n",
      "phy_P (1.8667686042943388e-18, -1.1380494220794838e-19, 3.847342150796626e-18)\n",
      "\n",
      "data8\n",
      "LL  (126.5846616914564, 124.78518046742393, 128.38414291548887)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.20949452219050829, 0.20407068105651655, 0.21491836332450004)\n",
      "raw_P (4.947475888155329e-07, -1.2778890822446486e-07, 1.1172840858555307e-06)\n",
      "phy_coeff (-0.27577900649771864, -0.28547720748731853, -0.26608080550811875)\n",
      "phy_P (0.005750858194484643, 0.0039643420687927181, 0.0075373743201765679)\n",
      "\n",
      "data9\n",
      "LL  (195.86297214326871, 194.14778727715162, 197.57815700938579)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.085872822908420993, 0.080099509284979276, 0.09164613653186271)\n",
      "raw_P (0.036113227639180609, 0.021862046685472765, 0.050364408592888453)\n",
      "phy_coeff (-0.099374460281192831, -0.10352087258740293, -0.09522804797498273)\n",
      "phy_P (0.017745757128756447, 0.012845123520333958, 0.022646390737178938)\n",
      "\n",
      "data10\n",
      "LL  (234.03939402349206, 231.89340956837788, 236.18537847860625)\n",
      "lambda (0.99960021071899863, 0.99960021071899863, 0.99960021071899863)\n",
      "raw_coeff (0.23906407694948115, 0.23492930914565108, 0.24319884475331122)\n",
      "raw_P (7.7956469838770013e-13, -3.853505698290987e-13, 1.9444799666044991e-12)\n",
      "phy_coeff (-0.073351588882280938, -0.07606481681668574, -0.070638360947876136)\n",
      "phy_P (0.041956727259696083, 0.032847918489072245, 0.051065536030319922)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for dset in datasets:\n",
    "    print dset.name\n",
    "    print \"LL \", get_CI(dset.LL[:,0]-dset.LL[:,1])\n",
    "    print \"lambda\", get_CI(dset.lam)\n",
    "    print \"raw_coeff\", get_CI(dset.tab[:, 1, 0])\n",
    "    print \"raw_P\", get_CI(dset.tab[:, 1, 3])\n",
    "    print \"phy_coeff\", get_CI(dset.tab[:, 2, 0])\n",
    "    print \"phy_P\", get_CI(dset.tab[:, 2, 3])\n",
    "    print \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make all plots for supp fig 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## pass objects into R\n",
    "dset = datasets[0]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Vib.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Viburnum\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[1]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Phryn.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Phrynosomatidae\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[2]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Quer.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Quercus\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dset = datasets[3]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Orest.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Orestias\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[4]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Helic.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Heliconius\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[5]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Finch.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Finches\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[6]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Danio.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Danio\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[7]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Barnacles.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Barnacles\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[8]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Ohomo.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Ohomopterus\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dset = datasets[9]\n",
    "rdf = dset.df4.loc[np.random.choice(dset.df4.shape[0], 1000), :]\n",
    "%R -i rdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PNG \n",
       "  2 \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%R -w 400 -h 400\n",
    "## make tree and plot data\n",
    "pdf(\"empscatter_Pedi.pdf\", height=5, width=5)\n",
    "plot(rdf[,c(5,6,7)], main=\"Pedicularis\")\n",
    "dev.off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}