StructuredSparsityDataGeneration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_feats = 1000\n",
    "num_obsvs = 150\n",
    "\n",
    "mod_size = 10\n",
    "\n",
    "num_causl = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adjacency matrix\n",
    "W = np.zeros((num_feats, num_feats))\n",
    "for i in range(num_feats/mod_size):\n",
    "    W[i*mod_size:(i+1)*mod_size, i*mod_size:(i+1)*mod_size] = np.ones((mod_size, mod_size))\n",
    "    if not i == (num_feats/mod_size - 1):\n",
    "        W[(i+1)*mod_size-1, (i+1)*mod_size] = 1\n",
    "        W[(i+1)*mod_size, (i+1)*mod_size-1] = 1\n",
    "        \n",
    "# remove the diagonal\n",
    "W = W - np.eye(num_feats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SNPs\n",
    "X = np.random.binomial(1, 0.1, size=(num_obsvs, num_feats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Phenotype\n",
    "w_causl = np.random.normal(loc=0.2, scale=0.05, size=(num_causl))\n",
    "print w_causl\n",
    "\n",
    "w = np.zeros((num_feats, ))\n",
    "w[:num_causl] = w_causl\n",
    "\n",
    "y = np.dot(X, w) + np.random.normal(loc=0., scale=0.1, size=(num_obsvs, ))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "### Shuffle"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "map_indices_l = range(num_feats)\n",
    "np.random.shuffle(map_indices_l)\n",
    "map_indices = dict(zip(range(num_feats), map_indices_l))\n",
    "map_indices_r = dict(zip(map_indices_l, range(num_feats)))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "X = X[:, map_indices_l]\n",
    "\n",
    "W_new = W[map_indices_l, :]\n",
    "W_new = W_new[:, map_indices_l]\n",
    "W = W_new\n",
    "\n",
    "causl = [map_indices_r[ix] for ix in range(num_causl)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save generated data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data used in the StructuredSparsity.ipnb notebook is saved under data/struct_spars. Here it will be generated under data/my_struct_spars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_rep = 'data/my_struct_spars'\n",
    "X_fname = '%s/X.data' % data_rep\n",
    "y_fname = '%s/y.data' % data_rep\n",
    "W_fname = '%s/W.data' % data_rep\n",
    "causl_fname = '%s/causl.data' % data_rep\n",
    "wghts_fname = '%s/w_causl.data' % data_rep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(X_fname, X, fmt='%d')\n",
    "np.savetxt(y_fname, y)\n",
    "np.savetxt(W_fname, W, fmt='%.1f')\n",
    "np.savetxt(causl_fname, causl, fmt='%d')\n",
    "np.savetxt(wghts_fname, w_causl)"
   ]
  }
 ],
 "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": 2
}