From b1796de6fcdb40676526e5643a172f2d0ff5c77a Mon Sep 17 00:00:00 2001 From: Steve Nyemba Date: Thu, 12 Dec 2019 11:04:41 -0600 Subject: [PATCH] bug fix and enhancement --- .ipynb_checkpoints/Untitled-checkpoint.ipynb | 6 + Dockerfile | 8 + Untitled.ipynb | 80 +++ WGAN.py | 17 +- bridge.py | 41 +- bridge.pyc | Bin 0 -> 9712 bytes curation-prod.json | 12 + curation-test-2.json | 12 + curation-test.json | 12 + exports/observation.csv | 511 +++++++++++++++++ exports/observation.sql | 24 + exports/sample.csv | 10 + gan.py | 546 +++++++++++++++++++ multi_GPU.py | 286 ++++++++++ params.py | 18 + params.pyc | Bin 0 -> 596 bytes test.py | 287 ++++++++++ vumc-test.json | 12 + 18 files changed, 1863 insertions(+), 19 deletions(-) create mode 100644 .ipynb_checkpoints/Untitled-checkpoint.ipynb create mode 100644 Dockerfile create mode 100644 Untitled.ipynb create mode 100644 bridge.pyc create mode 100644 curation-prod.json create mode 100644 curation-test-2.json create mode 100644 curation-test.json create mode 100644 exports/observation.csv create mode 100644 exports/observation.sql create mode 100644 exports/sample.csv create mode 100644 gan.py create mode 100644 multi_GPU.py create mode 100644 params.py create mode 100644 params.pyc create mode 100644 test.py create mode 100644 vumc-test.json diff --git a/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..2fd6442 --- /dev/null +++ b/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..dd02d11 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,8 @@ +from ubuntu +RUN ["apt-get","update"] +RUN ["apt-get","upgrade","-y"] +RUN ["apt-get","install","-y","git", "python3-dev","tmux","locales","python3-pip","python3-numpy","python3-pandas","locales"] +RUN ["pip3","install","pandas-gbq","tensorflow"] +RUN ["mkdir","-p","/usr/apps"] +WORKDIR /usr/apps +RUN ["git","clone","https://hiplab.mc.vanderbilt.edu/git/gan.git","aou-gan"] diff --git a/Untitled.ipynb b/Untitled.ipynb new file mode 100644 index 0000000..f7f5a6f --- /dev/null +++ b/Untitled.ipynb @@ -0,0 +1,80 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "x = np.arange(-4,4)\n", + "def sigmoid(x):\n", + " e = np.exp(-x)\n", + " return np.divide(1,e + e)\n", + "df = pd.DataFrame({\"x\":x,\"tanh\":np.tanh(x),\"sigmoid\":sigmoid( np.tanh(x))})" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD4CAYAAAAEhuazAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXhU5d3/8fedhYRAWMKeAAZU9iVgQFRUFHeEQK11o9VatVWx2sVH69NFa31+trVaW63Voq1tBUTRgIpaUSm4IpCw78iShCVk35PJ3L8/zhACJJCQmZyZzOd1Xblytsz9TcRP7nzPmXOMtRYREQkvEW4XICIirU/hLyIShhT+IiJhSOEvIhKGFP4iImEoyu0CGtO9e3ebnJzsdhkiIiFl1apVh6y1PU52XNCGf3JyMitXrnS7DBGRkGKM2d2U49T2EREJQwp/EZEwpPAXEQlDQdvzb0hNTQ1ZWVlUVla6XUrQi42NpW/fvkRHR7tdiogEoZAK/6ysLOLj40lOTsYY43Y5QctaS15eHllZWQwYMMDtckQkCIVU26eyspJu3bop+E/CGEO3bt30F5KINCqkwh9Q8DeRfk4iciIh1fYRERHAUw0VBb6PfOdzue9zEyn8m6mwsJA5c+Zw1113ndLXT5o0iSeeeILU1FQ/VyYiIcdbCxWFDYd4Rf7RyxUFUO4L/OqSFg+t8G+mwsJC/vKXv5xy+ItIG2QtVBX7wvqYoD4q1I8J+MoioJEHapkIiO0CcQnQvit07A09hh5Zb9+13nLCkfVHOjWpZIV/Mz344IPs2LGDlJQULrroItauXUtBQQE1NTX85je/IS0tjV27dnHllVcyceJEPvvsM5KSkli4cCHt27cH4LXXXuOuu+6isLCQF198kfPPP9/l70pE6lSXQ3leI7PvwkZm5gVgaxt/zZjO0P5wkCdA1wENB3f7hCPHxXSGiMCdlg3Z8H/krQ1szCn262sOS+zEr6YOP+Exjz/+OOvXryczMxOPx0N5eTmdOnXi0KFDTJgwgWnTpgGwbds25s6dy9/+9je+9a1vsWDBAmbOnAmAx+NhxYoVLF68mEceeYQlS5b49fsQkWbyemH7EljxgvO5sdl4dAdfUPtm3r2GHxPcx8zG4xKc2Xtk8EVt8FUUQqy1PPTQQyxbtoyIiAiys7M5cOAAAAMGDCAlJQWAs846i127dtV93Te+8Y0Gt4tIK6sogMw5sOJvUPA1dOwFE+9reGbevitEx7pdsd+EbPifbIbeGl555RVyc3NZtWoV0dHRJCcn111bHxMTU3dcZGQkFRUVdeuH90VGRuLxeFq3aBGB/evhq7/B2vlQUw79z4HJv4AhUyGqndvVtYqQDX+3xMfHU1LinGkvKiqiZ8+eREdH8/HHH7N7d5PupCoibqitgc1vO7P83Z9CVHsYdS2Mux36jHK7ulan8G+mbt26cd555zFixAjGjRvH5s2bGTlyJKmpqQwZMsTt8kTkWCUHYPXLsPIlKNkHXU6Dy34DKTc5rZ0wZaxt5MSGy1JTU+2xD3PZtGkTQ4cOdami0KOfl4QtayHrK+cE7oZ08NbA6ZNh/B1w5qUQEel2hQFjjFllrT3pG4k08xeRtqOmAta/ASueh31rIKYTjLvN+eh+htvVBRWFv4iEvsI98NWLsPqfzvX3PYbClCdh1HUQ09Ht6oKSwl9EQpO1sHOpcwJ367uAgSFTnNZO8kTQzQ1PSOEvIqGlshjWzHMu1Ty0FeK6wcQfQeqt0Lmv29WFDIW/iISG3K3OCdw1c6G6FJLOghnPw7DpberNV61F4S8iwctbC1vfc0J/51KIbAcjrnGuze97ltvVhbSQe5hLMLrtttvYuHFjQMe46qqrKCwsPG77ww8/zBNPPBHQsUVaXVkefPIUPJ0C826EQ9th8i/hRxthxl8V/H6gmb8fzJ49O+BjLF68OOBjiLguJ8M5gbvudaitguTz4fLHYPBVQXlztFCmmX8zlZWVMWXKFEaPHs2IESN49dVXmTRpEoffkPbiiy8yaNAgxo8fz+23386sWbMAuOWWW7jzzjuZMGECAwcOZOnSpdx6660MHTqUW265pe71586dy8iRIxkxYgQPPPBA3fbk5GQOHToEwGOPPcagQYOYOHEiW7Zsab1vXiQQPNXOPXZmXwIvTHLelDVmJtz1BdzyNgybpuAPgND9ib77IOxf59/X7D0Srnz8hIe89957JCYm8s477wDO/X2ee+45AHJycnj00UdZvXo18fHxXHzxxYwePbruawsKCvj8889ZtGgR06ZN49NPP2X27NmMGzeOzMxMevbsyQMPPMCqVavo2rUrl112Genp6UyfPr3uNVatWsW8efPqbik9duxYzjpLfwJLCCrOgZV/h1X/gLKDkHA6XPFbSLkBYju7XV2bp5l/M40cOZIPPviABx54gOXLl9O585F/pCtWrODCCy8kISGB6Ohorr322qO+durUqRhjGDlyJL169WLkyJFEREQwfPhwdu3axVdffcWkSZPo0aMHUVFR3HTTTSxbtuyo11i+fDkzZswgLi6OTp061T0/QCQkWAu7PoX5N8NTI2DZ752rdma+AbNWwoQfKPhbSejO/E8yQw+UQYMGsXr1ahYvXszPf/5zJk+e3OSvPXwr54iIiKNu+RwREYHH4yE6Otrv9YoEheoyp7Wz4m9wcIPzgJNz7nJuu9A12e3qwpJm/s2Uk5NDXFwcM2fO5P7772f16tV1+8aNG8d///tfCgoK8Hg8LFiwoFmvPX78eP773/9y6NAhamtrmTt3LhdeeOFRx1xwwQWkp6dTUVFBSUkJb731ll++L5GAyNsB7z0EfxgKb9/nPJd22p/hx5ucO2sq+F0TujN/l6xbt47777+fiIgIoqOjee655/jpT38KQFJSEg899BDjx48nISGBIUOGHNUWOpk+ffrw+OOPc9FFF2GtZcqUKaSlpR11zNixY7nuuusYPXo0PXv2ZNy4cX79/kRazOuFHR861+Zv+8C5g+awNOe2C/3O1m0XgoRu6exnpaWldOzYEY/Hw4wZM7j11luZMWOGK7WEws9L2pjcrc51+XnbnEcipt4KZ90C8b3drixs6JbOLnn44YdZsmQJlZWVXHbZZUddqSPSpuVuhZevdk7qXvMiDJ0WNo9EDEUKfz/Tu20lLB3a5gt+L9z8NvTUU+2CXcid8A3WNlWw0c9JWs2hbfAPBX+o8Uv4G2NeMsYcNMasb2S/Mcb8yRiz3Riz1hgz9lTGiY2NJS8vT8F2EtZa8vLyiI3VnQ4lwOqCv1bBH2L81fb5B/AM8M9G9l8JnOn7OBt4zve5Wfr27UtWVha5ubmnWGb4iI2NpW9f3dtcAujQdif4vR7nNgwK/pDil/C31i4zxiSf4JA04J/WmbJ/YYzpYozpY63d15xxoqOjGTBgQAsqFRG/yNvh9Pjrgl9XlbUGay3l1bWUVnkoqfRQWuWhtNJDaVVN3XpTtdYJ3yRgb731LN+2o8LfGHMHcAdA//79W6k0EWmWvB3wjylQWwM3v6XgbwJPrZeyqlpKqmrqArukLriPrJfV2+bsrzluv9dPXe+gutrHWvsC8AI41/m7XI6IHCtvh9Pqqa12evy9hrldUcBYa6nyeOvNruvNtqtqjg/wBpYP76+oqW3SmB1jopyPWOdzfGwUvTrF1m2Lr9sXfcz6kY+E3zbt+2ut8M8G+tVb7+vbJiKhoi74q5wZfxsKfmstq/cUkJ6Rw/JtuRRVODPumtqTz0EjIwzx9QI4PjaKbh3acVq3DnXr9UM9PiaKDseFeRQd2kUREdF6735urfBfBMwyxszDOdFb1Nx+v4i46LjgH+52RX6x/WAJ6Rk5LFyTzd78CmKiIrhgUA96d4o9avZ9dHhHH7UvJioCE4K3rPBL+Btj5gKTgO7GmCzgV0A0gLX2r8Bi4CpgO1AOfNcf44pIK8jfCS9PBU9lmwj+A8WVLMrMIT0zmw05xUQYOO+M7tw3eRCXj+hNx5ig6oYHjL+u9rnhJPstcLc/xhKRVpS/05nx11Q4wd97hNsVnZLiyhreW7+fhZnZfLYjD2thVN/O/OLqYUwd3Yee8eH3npjw+BUnIs2X/zX8Y6ov+BeFXPBXeWpZuiWXhZnZLNl0kGqPl9O6xXHPxWcyPSWRgT06ul2iqxT+InK8/K99M/4y34x/pNsVNYnXa1mxK5+Fmdm8s3YfxZUeunVox43j+5OWkkhKvy4h2Z8PBIW/iBwtBIN/075i0jOzeSszh5yiSuLaRXL58N6kpSQy8YzuREWG3G3MAk7hLyJHFOxyTu7WlMF3FgV18GcXVjgnbjOy2XKghMgIw4WDevDAlUO4dFgv4top3k5EPx0RcRTscmb8VSVOj7/PKLcrOk5heTWL1+0nPTObFV/nAzC2fxd+nTacKSP70K1jzEleQQ5T+IsIFOx2Tu7WBf9otyuqU1lTy4ebDpKemc3SLQepqbWc3qMDP7l0EGkpSfTvFud2iSFJ4S8S7gp2+2b8xfCdhUER/LVey+c78kjPzOa99fsprfLQMz6Gm89JZvqYJIYndtKJ2xZS+IuEs2ODPzHFtVKstazP9p24XZPDwZIq4mOiuHJEb6aPSWLCwG5EtuLtD9o6hb9IuCrc49yWuarIObnrUvDvySsnPTOb9MxsduaWER1puGhwT6aPSeLiIT2JjY50pa62TuEvEo4K9zi3Za4scmXGn1daxTvr9vFmRjYZewoBGD8ggdsmDuSqkb3pEqcHvweawl8k3BTudVo9lUXw7XRIHNMqw5ZXe/hg4wHSM7JZtu0QtV7LkN7xPHDFEKalJJLUpX2r1CEOhb9IOCnc68z4KwrhO+mQdEqP024yT62X5dsPsTAjm/9sPEB5dS2JnWO5/fyBTB+TyJDenQI6vjRO4S8SLgr3Oj3+ikL4zpsBC35rLRl7C1mYkc3ba/eRV1ZN5/bRpKUkMT0lkXHJCa1633ppmMJfJBwUZTnBX17gC/6zAjJMdmEFN7+0gu0HS2kXFcGlQ3uRlpLIhYN7EBOlE7fBROEv0tYVZTmtnvJ8p8cfoOCvqfVyz5zV7C+q5HfXjOKKkb3pFBsdkLGk5RT+Im1ZUbZzcvdw8PcNTPADPPH+FlbvKeTPN4xh6ujEgI0j/qFb3Ym0VUXZvhl/Hnz7zYAG/0ebD/D8sp3cdHZ/BX+IUPiLtEVF2b4efx7MfAP6pgZsqH1FFfxk/hqG9unEL65uOw91b+sU/iJtTXGOE/yluU7w9xsXsKE8tV7umZNBtcfLszeO0btxQ4h6/iJtSXGO0+opzXVaPQEMfoA/fLCVlbsLePr6lLB/LGKo0cxfpK0oznFO7pbmwrcDO+MHWLrlIM8t3cEN4/uRlpIU0LHE/zTzF2kLivf5gv+Ar9UzPqDD7S+q5Mfz1zCkdzy/mjo8oGNJYGjmLxLqivf5evy+4O9/dkCH89R6+eG8DCprannmxrHq84cozfxFQlnJfif4S/bDzAUBD36APy7Zxoqv83nqutGc0VN9/lClmb9IqCrZ75zcrQv+CQEfcvm2XJ5dup1vpfZlxpi+AR9PAkfhLxKKSvY7Pf7ifXDT660S/AeKK7lvXiZn9uzII9NGBHw8CSy1fURCTckBeHmqc3XPzAVw2jkBH7LWa7l3Xgbl1bW8etNY2rdTnz/UKfxFQknJAafHX5QNM19vleAHePrDbXyxM58nrh3NGT3jW2VMCSy1fURCxeEZf1E23PQanHZuqwz76fZD/PmjbVwzti/fPEt9/rZC4S8SCkoP+oI/ywn+5PNaZdiDJZXcOy+T03t05NHpup6/LVHbRyTYlR50Tu4W7XVO7rZS8Nd6LffNy6S0qoY5t59NXDvFRVui/5oiwaxuxr+3VWf8AM98tJ3PduTxu2tGMaiX+vxtjdo+IsGqNNcJ/sI9cON8SJ7YakN/viOPpz/cyjfGJHFtqvr8bZFfwt8Yc4UxZosxZrsx5sEG9t9ijMk1xmT6Pm7zx7gibdbh4C/Y7QT/gPNbbejckip+OC+DAd078Oj0ERijh623RS1u+xhjIoFngUuBLOArY8wia+3GYw591Vo7q6XjibR5dcG/C25q3eD3ei0/np9JcUUN//reeDrEqDPcVvlj5j8e2G6t3WmtrQbmAWl+eF2R8FLrgXWvw0uX1wv+C1q1hL8s3c7ybYd4eNpwhvTu1KpjS+vyR/gnAXvrrWf5th3rGmPMWmPM68aYfg29kDHmDmPMSmPMytzcXD+UJhICairgq9nw57Gw4HsQEem8gauVg//LnXk8+cFW0lISuX5cg/+LShvSWn/TvQXMtdZWGWO+D7wMXHzsQdbaF4AXAFJTU20r1SbijopCWPkifPEclOVC0llw+f/B4KsgonWvxcgrdfr8yd068NiMkerzhwF/hH82UH+a0Ne3rY61Nq/e6mzgd34YVyQ0leyHL/4CX70E1SVw+mSY+CPnah4XQtfrtfxo/hoKymv4+y3j6ag+f1jwx3/lr4AzjTEDcEL/euDG+gcYY/pYa/f5VqcBm/wwrkhoydsBn/0JMueA1wPDpsPE+6DPaFfL+uuyHSzbmstvpo9gWKL6/OGixeFvrfUYY2YB7wORwEvW2g3GmF8DK621i4AfGmOmAR4gH7ilpeOKhIycTPj0j7BxIUREw5iZcO49kDDQ7cr4alc+f/jPVq4e1Yebzu7vdjnSioy1wdlaT01NtStXrnS7DJFTYy18vcwJ/R0fQUwnGPc9OPtOiO/ldnUA5JdVc9XTy4mNjuCteyYSHxvtdkniB8aYVdba1JMdp+aeiD95vbD5bfjkKchZDR16wiUPQ+qtENvZ7erqeL2Wn8zPJL+smjfuOlfBH4YU/iL+4KmGta/Cp09D3jbomgxXPwWjb4ToWLerO87flu/k4y25PJo2nBFJwfNLSVqPwl+kJapKYNXL8PmzUJIDvUfBN1+CoWkQGZz/e63anc/v3t/CVSN7M3PCaW6XIy4Jzn+dIsGu7BB8+TyseAEqCyH5fEh7Bk6/2JXLNZuqoKyae+ZkkNSlPY9fM0rX84cxhb9IcxTshs+fgdX/Ak8FDLnauUa/70nPr7nOWsv9r68ht7SKBXeeSyf1+cOawl+kKQ5sdK7cWfe6M7MfdT2c90PoMdjtyprsxU++Zsmmgzw8dRij+nZxuxxxmcJf5ET2fOFcubP1PYjuAGf/AM65CzqH1j3uM/YU8Pi7m7lieG9uPjfZ7XIkCCj8RY5lLWz7jxP6ez6H9gkw6SEYfzvEJbhdXbMVldcwa04GvTvH8ttvqs8vDoW/yGG1HtjwBnzyRzi4ATr3gyt+C2O/De06uF3dKbHW8tPX13CwpJLXfnAundurzy8Ohb9IdTlkvuLcd6dwD/QYAjOehxHXQGRoh+XfP93FBxsP8Iurh5HST31+OULhL+GrogBWzIYv/wrlh6DveLjyd3Dm5a1+S+VAWLO3kP/37iYuHdaLW89LdrscCTIKfwk/xTnOm7JW/QOqS+HMy5zLNfufE9TX6DdHUUUNd89ZTc/4WH6vPr80QOEv4ePQNuf2C2vmga112jrn3Qe9R7hdmV9Za3ng9bXsL6pk/g/OoUtcO7dLkiCk8Je2L3uVcxJ301sQFQNn3QLnznLuv9MG/fPz3by3YT//e9VQxvbv6nY5EqQU/tI2WQs7l8InTzq3Vo7pDOf/xLlOv2MPt6sLmHVZRTz2ziYmD+nJbecPcLscCWIKfwld1jo9+/J8qMiH8jwoL3Ceh7v2VdiXCR17w6WPOrP92Lb9lKriSqfP371jO564drT6/HJCCn8JDl6vc4O0uiD3hfnh5frhXn+/t6bh10s4Hab+CUZf77R62jhrLT9bsI7swgrmf38CXTuozy8npvAX//NUO5dRNhje+b59x4R7ZSFYb8OvFxHlvMs2LsH5nDDQuZHa4W1x3Y7ef3hbGM18//3lHt5Zt48HrxzCWaeF3ruQpfUp/KVx1kJNeQOz8YIGAv3w/nyoLmn8NaPa+8LZF9SdR/oCu9sx4V1vOaZTWAV5c63PLuLRtzYyaXAP7jjf/ecCS2gI3vCvLILNi4F6zxg+6nnDzdne3Negge2nUIe31rmk0Hp9y9ZZ9/q21S3bY45r7a/xHnOcF2oqnED3VDb8cwEnlOtCuht0H1RvBt71+EBvnwDt4hp/PWm2ksoaZs1ZTUKHdjz5rRQiIvRLUpomeMM/fyfMu8HtKlqfiQATCRGRR5ZNhPOO07rlevsiIhr5GuNbP+ZrIqIaeO3D6xFHviYqFuK6NtBS6XYk3EP81gehzlrLQ2+uZ29BBfPumECC+vzSDMEb/j0Gwx1znOWj/uSvt9yc7X5/jfq7G3mNw0HalFA+HOQiTTR3xV7eWpPD/ZcPZlyy+vzSPMEb/tFxkJjidhUiQWljTjEPv7WBCwb14M4LT3e7HAlBmmqKhJjSKg+z5qyma1w0T31rtPr8ckqCd+YvIsex1vLzN9exK6+MubdPoFvHtv8eBgkMzfxFQsj8lXtJz8zhR5cM4uyB3dwuR0KYwl8kRGzeX8wvF27g/DO7c9dFZ7hdjoQ4hb9ICCir8nD3K6vp1D6aJ7+VQqT6/NJCCn+RIGet5Rfp6/n6UBlPX59Cj3j1+aXlFP4iQe61VVm8kZHNvZMHce7p3d0uR9oIhb9IENt6oIRfLlzPuad3Y9bF6vOL/yj8RYJUebXT5+8YE80fr1efX/xL1/mLBKlfLdzA9txS/v29s+kZH+t2OdLG+GXmb4y5whizxRiz3RjzYAP7Y4wxr/r2f2mMSfbHuCJt1YJVWby2Kot7Lj6T885Qn1/8r8Xhb4yJBJ4FrgSGATcYY4Ydc9j3gAJr7RnAU8BvWzquSFu1/WAJP09fz4SBCdw7+Uy3y5E2yh8z//HAdmvtTmttNTAPSDvmmDTgZd/y68BkoweMihynorqWu1/JIK5dJE9fP0Z9fgkYf4R/ErC33nqWb1uDx1hrPUARcNx7040xdxhjVhpjVubm5vqhNJHQ8shbG9h6sISnrkuhVyf1+SVwgupqH2vtC9baVGttao8ePdwuR6RVpWdkM++rvdw96QwuGKR//xJY/gj/bKBfvfW+vm0NHmOMiQI6A3l+GFukTdiRW8pDb65jfHIC912iPr8Enj/C/yvgTGPMAGNMO+B6YNExxywCbvYtfxP4yNrGHporEl4qa2q5+5XVxEZH8qcbxhAVGVR/kEsb1eLr/K21HmPMLOB9IBJ4yVq7wRjza2CltXYR8CLwL2PMdiAf5xeEiACPvLWRzftL+Md3x9G7s/r80jr88iYva+1iYPEx235Zb7kSuNYfY4m0JYvW5DB3xR7unHQ6kwb3dLscCSP6+1LEJV8fKuNnC9aSelpXfnLpILfLkTCj8BdxweE+f3RUhPr84grd20fEBb95ZyMb9xXz0i2pJHZp73Y5EoY03RBpZW+vzeHfX+zh+xcM5OIhvdwuR8KUwl+kFe3OK+PBBesY278LP718sNvlSBhT+Iu0kipPLXfPWU1khOHPN44lWn1+cZF6/iKt5P/e2cT67GJmfyeVJPX5xWWaeoi0gnfX7ePlz3dz28QBXDJMfX5xn8JfJMD25JXzPwvWMrpfF/7niiFulyMCKPxFAqrKU8usuasxwDM3jKFdlP6Xk+Cgnr9IAD3+7mbWZhXx/LfPol9CnNvliNTRNEQkQN7fsJ+/f7qL756XzOXDe7tdjshRFP4iAbA3v5z7X1vDqL6d+dmVQ90uR+Q4Cn8RP6v2eJk1NwMLPHPDWPX5JSip5y/iZ797bzNr9hby15lj6d9NfX4JTpqSiPjRBxsPMPuTr7n5nNO4YkQft8sRaZTCX8RPsgrK+elraxiR1ImHpqjPL8FN4S/iBzW1Xu6Zm4HXa3n2xrHEREW6XZLICannL+IHT7y/hYw9hTx741hO69bB7XJETkozf5EW+mjzAZ5ftpOZE/ozZZT6/BIaFP4iLZBTWMGP569hWJ9O/HzKMLfLEWkyhb/IKaqp9fLDuRnUeLw8e9NYYqPV55fQoZ6/yCl68oOtrNxdwJ9uGMOA7urzS2jRzF/kFHy85SDPLd3BDeP7M210otvliDSbwl+kmfYXVfKT+WsY0jueX01Vn19Ck8JfpBk8vj5/ZU2t+vwS0tTzF2mGPy7Zxopd+fzxuhRO79HR7XJETplm/iJNtGxrLs8u3c51qf2YPibJ7XJEWkThL9IEB4or+dGrmQzqGc/D04a7XY5Iiyn8RU7icJ+/vLqWZ28aQ/t26vNL6FPPX+Qk/vThNr78Op8/XDuaM3rGu12OiF9o5i9yAp9sO8SfP97ON8/qyzVn9XW7HBG/UfiLNOJgSSX3vZrJGT068us09fmlbWlR+BtjEowxHxhjtvk+d23kuFpjTKbvY1FLxhRpDbVey33zMimtquHZm8YS104dUmlbWjrzfxD40Fp7JvChb70hFdbaFN/HtBaOKRJwf/5oG5/tyOPXaSMY1Et9fml7Whr+acDLvuWXgektfD0R13224xBPf7iNb4xJ4lr1+aWNamn497LW7vMt7wd6NXJcrDFmpTHmC2NMo78gjDF3+I5bmZub28LSRJovt6SKe+dlMrB7Bx6dPgJjjNsliQTESRuZxpglQO8Gdv1v/RVrrTXG2EZe5jRrbbYxZiDwkTFmnbV2x7EHWWtfAF4ASE1Nbey1RAKi1mv50auZFFfU8K/vjadDjPr80nad9F+3tfaSxvYZYw4YY/pYa/cZY/oABxt5jWzf553GmKXAGOC48Bdx018+3s4n2w/x+DdGMqR3J7fLEQmolrZ9FgE3+5ZvBhYee4AxpqsxJsa33B04D9jYwnFF/OqLnXk8tWQraSmJXDeun9vliARcS8P/ceBSY8w24BLfOsaYVGPMbN8xQ4GVxpg1wMfA49Zahb8EjUOlVdw7L4Pkbh14bMZI9fklLLSoqWmtzQMmN7B9JXCbb/kzYGRLxhEJFK+vz19QXsPfbxlPR/X5JUzoHb4S1p777w6WbzvEr6YOY1ii+vwSPhT+ErZWfJ3Pkx9sZeroRG4c39/tckRalcJfwlJ+WTU/nJtBv67t+b8Zup5fwo8anBJ2vG376TcAAAnGSURBVF7Lj+dnkl9WzRt3nUt8bLTbJYm0Os38Jey8sHwnS7fk8ourhzIiqbPb5Yi4QuEvYWXV7nx+//4Wpozsw8wJp7ldjohrFP4SNgrKqpk1J4OkLu35f9foen4Jb+r5S1iw1vLT19aQV1rNgjvPpZP6/BLmNPOXsDB7+dd8uPkgD101hJF91ecXUfhLm7d6TwG/fW8zVwzvzc3nJrtdjkhQUPhLm1ZYXs09czLo0yWW335zlPr8Ij7q+Uub5fT513KwpJLXf3Aundurzy9ymGb+0ma99Okulmw6wINXDmV0vy5ulyMSVBT+0iZl7i3k8Xc3cemwXtx6XrLb5YgEHYW/tDlFFTXMmrOanvGxPPHN0erzizRAPX9pM8qrPfxnwwH+/tku9hdV8toPzqFznPr8Ig1R+EtIq6n18sm2Q6RnZvOfDQeoqKklsXMsv792FGP6d3W7PJGgpfCXkGOtJWNvIQszsnl77T7yyqrp3D6a6WOSmJ6SyLjkBCIi1OoRORGFv4SMHbmlLMzIZuGaHHbnlRMTFcElQ3uRlpLIpME9aRelU1giTaXwl6B2sLiSRWtyWJiZw7rsIiIMnHt6d2ZddAZXjOite/GLnCKFvwSdksoa3lu/n4WZOXy24xBeCyOTOvPzKUOZNjqRnp1i3S5RJOQp/CUoVHu8LN1ykIWZOSzZdIAqj5f+CXHMuugMpqUkcUbPjm6XKNKmKPzFNV6vZeXuAtIzs1m8bh+F5TUkdGjHdeP6kZaSxNj+XXSNvkiAKPyl1W3ZX0J6ZjaLMnPILqygfXQklw3vxfSUJCae2Z3oSJ24FQk0hb+0ipzCChatySE9I5vN+0uIjDCcf2Z37r98MJcO60WHGP1TFGlN+j9OAqaovIbF6/eRnpHNil35WAtj+nfhkWnDmTKqD907xrhdokjYUviLX1XW1PLR5oOkZ2SzdEsu1bVeBnbvwH2TB5GWkkhy9w5ulygiKPzFD2q9li935pGemc276/dTUumhR3wMMyecxvQxiYxM6qwTtyJBRuEvp8Ray4acYhZmZrNoTQ4HiqvoGBPF5cN7M31MIuee3p1I3WJBJGgp/KVZ9uaXszAzm/TMHLYfLCU60nDhoJ784upELhnai9joSLdLFJEmUPjLSeWXVfPO2hzSM3NYtbsAgPHJCTw2YwRXjehD1w7tXK5QRJpL4S8Nqqiu5T8bnVssLNuai8drGdSrI/dfPpi0lET6do1zu0QRaQGFfxtW67WUVnmcj0oPpVU1lFR6KKuqrVs+ss9DSb3lzfuKKauupU/nWL43cQBpKUkM7ROvE7cibUSLwt8Ycy3wMDAUGG+tXdnIcVcATwORwGxr7eMtGbetq/Z460K5pKqmLpBLqzzHB7Yv1I8cf2RfeXVtk8br0C6SjrFRdIzxfcRGMS0liWmjEzl7gO6NL9IWtXTmvx74BvB8YwcYYyKBZ4FLgSzgK2PMImvtxhaOfUqstVgLXmvx+j4fWXe22UY+Hz6moa8/9piaWkvZUWFdc9zs+tiwLvPtr/Z4T/p9RBjoGBNFfGx0XWB3iWtH34Q44uuFuHNMFB1joo9Zd/Z3aBelq3JEwlCLwt9auwk4WStgPLDdWrvTd+w8IA04YfhvPVDCxX9YenQwe48NWV+Y41v3njzY3dYuKsIJ53oz7cQusfXCOvpIOPu2HT6+Q8yR5fbRkWrBiMgpa42efxKwt956FnB2QwcaY+4A7gDolDiQYX06EWEMEQYijMHUW46IcH7pGKg7xtnvOybCYEy9fZz8mMNjOK95eH+9MY/5etNQXb5joiJMvfCO9oV3JDFRuhRSRNx30vA3xiwBejew63+ttQv9WYy19gXgBYDU1FT7zI1j/fnyIiLic9Lwt9Ze0sIxsoF+9db7+raJiIhLWuPG6V8BZxpjBhhj2gHXA4taYVwREWlEi8LfGDPDGJMFnAO8Y4x537c90RizGMBa6wFmAe8Dm4D51toNLStbRERaoqVX+7wJvNnA9hzgqnrri4HFLRlLRET8R8/LExEJQwp/EZEwpPAXEQlDCn8RkTBkrA2Cex40wBhTAmxxu44W6A4ccruIFlD97lL97gnl2gEGW2vjT3ZQMN/SeYu1NtXtIk6VMWal6neP6ndXKNcfyrWDU39TjlPbR0QkDCn8RUTCUDCH/wtuF9BCqt9dqt9doVx/KNcOTaw/aE/4iohI4ATzzF9ERAJE4S8iEoaCMvyNMVcYY7YYY7YbYx50u57mMMa8ZIw5aIxZ73Ytp8IY088Y87ExZqMxZoMx5l63a2oOY0ysMWaFMWaNr/5H3K6puYwxkcaYDGPM227X0lzGmF3GmHXGmMymXnIYTIwxXYwxrxtjNhtjNhljznG7pqYyxgz2/dwPfxQbY+5r9Phg6/n7Hvi+lXoPfAducOuB781ljLkAKAX+aa0d4XY9zWWM6QP0sdauNsbEA6uA6SH08zdAB2ttqTEmGvgEuNda+4XLpTWZMebHQCrQyVp7tdv1NIcxZheQaq0NyTdJGWNeBpZba2f7nj8SZ60tdLuu5vLlaDZwtrV2d0PHBOPMv+6B79baauDwA99DgrV2GZDvdh2nylq7z1q72rdcgvMMhiR3q2o66yj1rUb7PoJrhnMCxpi+wBRgttu1hBtjTGfgAuBFAGttdSgGv89kYEdjwQ/BGf4NPfA9ZMKnLTHGJANjgC/draR5fG2TTOAg8IG1NpTq/yPwP4DX7UJOkQX+Y4xZZYy5w+1immkAkAv83dd2m22M6eB2UafoemDuiQ4IxvCXIGCM6QgsAO6z1ha7XU9zWGtrrbUpOM+LHm+MCYn2mzHmauCgtXaV27W0wERr7VjgSuBuXxs0VEQBY4HnrLVjgDIgpM45AvjaVdOA1050XDCGvx747jJfr3wB8Iq19g236zlVvj/ZPwaucLuWJjoPmObrm88DLjbG/NvdkprHWpvt+3wQ5yl/492tqFmygKx6fym+jvPLINRcCay21h440UHBGP564LuLfCdMXwQ2WWufdLue5jLG9DDGdPEtt8e5cGCzu1U1jbX2Z9bavtbaZJx/9x9Za2e6XFaTGWM6+C4SwNcuuQwImaverLX7gb3GmMG+TZOBkLjQ4Rg3cJKWDwThXT2ttR5jzOEHvkcCL4XSA9+NMXOBSUB338Ptf2WtfdHdqprlPODbwDpf3xzgId9zmENBH+Bl39UOEcB8a23IXTIZonoBbzrzB6KAOdba99wtqdnuAV7xTTx3At91uZ5m8f3SvRT4/kmPDbZLPUVEJPCCse0jIiIBpvAXEQlDCn8RkTCk8BcRCUMKfxGRMKTwFxEJQwp/EZEw9P8BNZtzVO57r88AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df[['tanh','sigmoid']].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/WGAN.py b/WGAN.py index 0dfdff0..186d5f8 100644 --- a/WGAN.py +++ b/WGAN.py @@ -3,7 +3,7 @@ from tensorflow.contrib.layers import l2_regularizer import numpy as np import time import os - +import pandas as pd os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" #### id of gpu to use @@ -13,7 +13,7 @@ os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #### training data #### shape=(n_sample, n_code=854) -REAL = np.load('') +REAL = None #np.load('') #--diagnosis codes (binary) #### demographic for training data #### shape=(n_sample, 6) @@ -22,16 +22,16 @@ REAL = np.load('') #### elif sample_x's is within 18-44, then LABEL[x,3]=1 #### elif sample_x's is within 45-64, then LABEL[x,4]=1 #### elif sample_x's is within 64-, then LABEL[x,5]=1 -LABEL = np.load('') +LABEL = None #np.load('') #-- demographics 0,5 set it to 1,0,0,0,0,0 #### training parameters NUM_GPUS = 1 BATCHSIZE_PER_GPU = 2000 TOTAL_BATCHSIZE = BATCHSIZE_PER_GPU * NUM_GPUS -STEPS_PER_EPOCH = int(np.load('ICD9/train.npy').shape[0] / 2000) +STEPS_PER_EPOCH = 256 #int(np.load('ICD9/train.npy').shape[0] / 2000) g_structure = [128, 128] -d_structure = [854, 256, 128] +d_structure = [854, 256, 128] #-- change 854 to number of diagnosis z_dim = 128 def _variable_on_cpu(name, shape, initializer=None): @@ -277,6 +277,13 @@ def generate(model_dir, synthetic_dir, demo): if __name__ == '__main__': #### args_1: number of training epochs #### args_2: dir to save the trained model + from bridge import Binary + df = pd.read_csv('exports/observation.csv') + cols = 'observation_source_value' + _map,_df = (Binary()).Export(df) + i = np.arange(_map[cols]['start'],_map[cols]['end']) + REAL = _df[:,i] + LABEL = np.arange(0,_df.shape[0]) train(500, '') #### args_1: dir of trained model diff --git a/bridge.py b/bridge.py index f9489ee..fa323af 100644 --- a/bridge.py +++ b/bridge.py @@ -23,13 +23,12 @@ if len(sys.argv) > 1: value = None if sys.argv[i].startswith('--'): key = sys.argv[i].replace('-','') - + SYS_ARGS[key] = 1 if i + 1 < N: value = sys.argv[i + 1] = sys.argv[i+1].strip() if key and value: SYS_ARGS[key] = value - if key == 'context': - SYS_ARGS[key] = ('/'+value).replace('//','/') + i += 2 @@ -107,7 +106,7 @@ class pseudonym : # print (df.head()[:5]) # sys.stdout.flush() TABLE_NAME = ".".join([args['dataset']+DATASET_SUFFIX,PSEUDO_TABLENAME]) - df.to_gbq(TABLE_NAME,credentials=credentials,if_exists='append') + df.to_gbq(TABLE_NAME,credentials=credentials,if_exists='append',chunksize=10000) # df.to_gbq(TABLE_NAME.replace('.','_pseudo.'),credentials=credentials,if_exists='append') class Builder : @@ -159,18 +158,29 @@ class Binary : This function will convert a column into a binary matrix with the value-space representing each column of the resulting matrix :column a column vector i.e every item is a row """ - values = np.unique(column) + # values = np.unique(column) + + values = column.dropna().unique() values.sort() - + # + # Let's treat the case of missing values i.e nulls + # row_count,col_count = column.size,values.size + matrix = [ np.zeros(col_count) for i in np.arange(row_count)] # # let's create a binary matrix of the feature that was passed in # The indices of the matrix are inspired by classical x,y axis - for yi in np.arange(row_count) : - value = column[yi] - xi = np.where(values == value)[0][0] #-- column index - matrix[yi][xi] = 1 + + if col_count > 0 and values.size > 1: + + for yi in np.arange(row_count) : + value = column[yi] + if value not in values : + continue + xi = np.where(values == value) + xi = xi[0][0] #-- column index + matrix[yi][xi] = 1 return matrix def Export(self,df) : @@ -180,7 +190,9 @@ class Binary : """ # # This will give us a map of how each column was mapped to a bitstream - _map = df.apply(lambda column: self.__stream(column.values),axis=0) + + _map = df.fillna(np.nan).apply(lambda column: self.__stream(column),axis=0) + # # We will merge this to have a healthy matrix _matrix = _map.apply(lambda row: list(list(itertools.chain(*row.values.tolist()))),axis=1) @@ -198,7 +210,7 @@ class Binary : _m[name] = {"start":beg,"end":end} beg = end - return _m,_matrix + return _m,_matrix.astype(np.float32) def Import(self,df,values,_map): """ @@ -216,8 +228,8 @@ class Binary : # has_basic = 'dataset' in SYS_ARGS.keys() and 'table' in SYS_ARGS.keys() and 'key' in SYS_ARGS.keys() # has_action= 'export' in SYS_ARGS.keys() or 'pseudo' in SYS_ARGS.keys() -df = pd.DataFrame({"fname":['james','james','steve','kevin','kevin'],"lname":["bond","dean","nyemba",'james','johnson']}) -df['age'] = (np.random.sample(df.shape[0]) * 100).astype(np.int32) +# df = pd.DataFrame({"fname":['james','james','steve','kevin','kevin'],"lname":["bond","dean","nyemba",'james','johnson']}) +# df['age'] = (np.random.sample(df.shape[0]) * 100).astype(np.int32) if __name__ == '__main__' : """ Run the program from the command line passing the following mandatory arguments @@ -253,6 +265,7 @@ if __name__ == '__main__' : builder.process(**SYS_ARGS) else: print ("") + print (SYS_ARGS.keys()) print ("has basic ",has_basic) print ("has action ",has_action) # pseudonym.apply(table='person',dataset='wgan_original',key='./curation-test-2.json') diff --git a/bridge.pyc b/bridge.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3569b94f201007c66368672f090485a31c227c87 GIT binary patch literal 9712 zcmbtaOK=ofcD-38l|Be0eiGF*-8pmv1qi8u2HHaX5lAqa0nwc$%yfluO{(%q%A%^W zl$j-@2?$S^9(x@2EbN^Z6BFT$KRZWwXYVG$9e$-}`>&o_pUd^8a;k^k4q-_sUUSE$VtPIO0JjBOJzXw zd1(wvvmlj%IP5ndjUj0cOJ&5CF>X{UqrGtlq;jB_ACt;hFMm)f2YdNLQaL2Spj5^s zfZz!UA$LfEVYyy8Ear%qF{vMw7pNVPCj%1ysk67Ta!hu9CFVF=%`thAlf}nBm&zpf zP&v^ZY$l~xFG?^@0x4;>1@?1$tA7Qgii zd4!4pXL4173Hd@e^XHXQ5*(J`eF=_aRc}dfRDx>~9LuWSmH_8*U4qH1$`zB7`nM#+ zolfb$6B6J=in1{%!5eZtz*66o02843EvlE9SJ+&q&}(k=OAp zIaWWbjpul-Xbetc&m{@o(LMhrA7IE~sh{WKpA;neA{U(bQVm4x=~KBN!MS}k?Z3(e zrF}J(i()QF{L8$#sOj63UzzR>#6?V4y?Sd=Xg!bWeF~b!A)G0U>e)c@th#@y3}v<#B#zj zQVcH1)JBd+RQW*62V4@)@wb=_u&Oz<}fQ?*`^&GQT1Sh6hf-5KG(g)Q26(plBes0Ic zPmSA7Oect1yUoOH`fb-w-1Vr@h@K|yoOWZ^)L(0uX?Hy|jbM7)Z*1{{WKhC=6=&t3T{`3!jAZ8QiQRUb)1kk`7>Xwc7HV zrdmx$wa|=$P6I{TOS>{jP9vG!jGAUPNzJyI-3Zg!?M|~c>qnj0wKxnm%uIXNqr@}p zPx%EW9l@XMOtW>d@fLesLt@tj9R&wd*@2Zjp$3xe76-JL>lFvN2_BTnD$y9jWK!nG!ld{~RitlMQ5SZC;Ac^V&Xu9Qb`u>L_E*0((tiNFB99@+?mvGCwTO z2AGG06uk@Ddqkc=GC2PLmYsV(D9_L|1Z<6QG5?4p1I^qMvrF*s=T`UT-F6&q6LoAW zb%Ek`fpWe-H1JbDF)4@kveCMmZW=diwL7T=WWT%OlbyRzb$P-4W{Xp8j@oG$wfqLK zOzgU)@@MzlB*l`Nrj_UulT+AIdFkHL?N#@Jd&hfl-<|8OXl72QRm^s)a89@l zDvKi4O$hXR%lDU8-OGx|-q?iq*ByTV*;;G@%pdxV#L7d?)Y6pT!s=Rq9|t8CJbWbO z5U6i9q=@o*95t&isa_SkG^!-^C~T?Z*t8pd&7=fmJJ1Qh13`6TZL6z&jZU+bl(;}0 z>Bk$1H^CACh~x4O;;(mzH53x8_Z8%L3xJBz||nxozJKpi;tJ(`H-ZC zxH7QVGx#@ya{VV*%`nvswNHj5{uQ;Y1%<;A7Nq!0+vd5+aX|r_bhiFl9zhMuC7wkx zjU>bL>ShR{?zC!zv+K9pjnE{jAXyiWDyf&HR2rg0MFvtx<0;S9DuG89T`BR7JtE5^ z=JjrY33j^;;jJ|NT9nljP&S1$!X!-z4`!-erATlRB8v;F3+1KNYWd-vJImiw>8-Xx zD(N(piM!paVW2=P**=l$! zy}8H}Dj);_*r_N^t7%Hwua9k>Fz;jcCNjwhBr-UjpLC8mhn#Eq6V62Lpfl;X&f!6Y zIT<2@`9EMz7=b#{jJAQo4RA7Qfk^Nz+5i{wGN5H^Er^D*T67tK4-78^xlwtNm$=jG z3;!1&wmqh-l-7|wjqsX#qPr^r!qFWD1n#O`$qibUaW1n5UUb0p*6*RcP{pj<)lR50 z1x>__z*NwF9H#ogt%Wm7D`IsR0-%AAGvA$$r94V-NTD3Zuz=&x;X#3kg|^nQ6S&Y* zy52&sa!fO-lu&AHWzXmn)X5h)hjNQ57n5NIc*Jyw)jL+(xOZ#tXr|H$$+kv$SUwD= z-GsW)*n|T=x?FmjcYYs9riJ?z^=a5>xJhTN8K$o9sx#!Kk=t{O;CjWdaA0w&btc18 zuj)9&b}iB3a(Q)m1t#hCLV301y~SDYAaNJUZh6&PUb%aoS@qPCY4`Snhbyb43+L(F zsY{l8r6qIcEFbK%RH_tv%#{+q$9*bosD@Q-CLi#30dWV zx47i7blFwoIAi%qS?4gt9YLZb6;7N(j$^`qV#6d7r3Cn#QD7`}*}YjMr)Pp1zhQLj9T;-so#9w+@YC|r!^H>H)rDL4mR1(-FKPEQqR}mp04!^r zWOw?c+ONuvYIwaj*+4p4QNmm^8?Q}E9<9eieAGnC;50aB(m9no0wy|z+)1$0q1<8T zxO2rR=1)0l|2^KK#}%a{O}a^84TQNF1!^O_t8Ay_{(3a`ihh7v8xBx>6`b)S<8SBz z-|B>oz{EYKaYY@uRcK9^O)g1gD<~8jWPx^>M@hblaG+7CaEUY8h(bN?v#_4$!gu!?5NtX8UGzbms2(BS-gUghsm7&3eU}$wzSWDhk zp9Cg{7kF(S($>PJq2h_fwjRwbXN|Fb?f28JTEYY0MUFE z{#0i^B*hkvW1KF?&U>W4#m6Oj9&l3-TcDc*UbHp_3^q)TguELNwe>ghh-*5cz0|AG z7LX`vkJ@f1z@HgcqjJJw!!g!iZ8t#taDqV6oJ60%JP-`{+5;+=sN2c+kz{1|6@+Om z|K67>dD3?`!fn&CZvlIId?4U0*$!J9wmQkgCRE06bmZMeNLt?SsDCy6Q5&pkX3V7z zg;IBd9*Xw87rgf|Drq9I9I5Yw56{_Gz&UqeWzjyc-4ES!bM!!Lo#l8-cYFB#L#2K@ zct*ST8{PBx1=nk}a*bVApSG<X_KrH3A|b!Zz**4XyUqz`#3?v$ItQJz1CvO{oTH8s0N*8h&>MpqraQduJm$#pbksO!D=`W1TX{UV;2Sz$#5SQnhkYKz}NPEY6cw@K5|j-#4M zl0QaPBNS4|cEgL*-H<2y8~8nxvNi43#$+?Rjb|#Cw#!#Z~6b>$bp@>Jypc1T_J}?}%X($P44sJed7fe&v#N}yg79Ss{qoRboB=(s zIt|2Qp63Wyjc|q{KPb^2VOB^${XB*}!Z_5}_*(KyY&L`8e(N zM8pTfjByd5#69vA>na%H=xH`C#GV+40HTMHC=`P@YPWpNc3L4GB9@7P7n^||tLy81 z%n>vcKQJ*K*~~rNG_ffWBdVM##4gPv`Kcq0`K$WW&=Oj^C9WdW5q6Ur2-po(t{#?F z?1X*YdquU=NLIB9zux%GpJJATkpLMw;*1U)&0QQknVUp(X$;(c9Io#1T!wS*D9`@C zL1J-koi?Bci2g%FN#MUY@(1e6z|%tjzl(ohb%1UsFol;n>+#6NC{+LrFdd;bU~_%Y zKOp)UmV*9d-kt`b=*&TT6u*4%GGv?MiwIEP`H*hg;^S)yXbW*Z@kiiw4e@&(dUpl6 zPTy<@f1nvaH%fHteg?M=6?l`wrNr_Wy5$!GWrahsiG62S`9{doQ@&(*{mY=wM9jq| z?Zhp&3Quf$53>-@HQqlzWEnoZ5=M)D3|`S#0@hX5uM75kn^3i^*}Gb8_CCiboBIxP z_`GVoUU4$t@SAIa|IyDmj)N8SK3Z^fo1kN%|7-Y4iLwU6>E$GWcViRcWyLS}Bnnk0uOw7?k24DSbc@i%{$?Z44-FK)v~zV&DlK=eJHnAqRTu_cN>|)17Zr zzpk;i6xTC6+0eP}6QSo{&1PRh!6SRg*P7!sK^-*`tY78$4ADJCOXM@U}`DQ4Zl6+wj%z zAiD>{T=gq1Se0s7U9^AZD84DBa1y9J4MTO|Npq6Q~H&s);%%X@Nsxg>shpXEoudNeu42@x{=ndX|DOI`SobC#V-Un z1bovp)OiVcBg!g1Vr0W8Q~|=U1+SYXz=joh1}e__tD3bi)^CYyE!`(P7G_?4fK$t7 zYRR@v9JT_plW0}4)lk>}>BWRT%O)PiYkm^eY*>;--+qho(sAx7eu8m&0d__3sQpBv zg*sQO)5Q0{3TJL*BZ@W}W+w7G>E;!E9c%QgTU~2JoxoGVbJ1B(QNKSKVQG`!#bJYb zP|0qhR2e0nL1X{@tjAaWyj)%I?v^c6!>#0I@nzk%w@67meT_$Ygs8`Nu2*FP&p-`C zLN8S#q87???81w&FVMTparqvYva15~$mtOzezV;$-c7bNS;^@DldD&3%y64^+!2nq zs;8~Oj|<=dM*eI z?2EAi5#A^0q_ac_2&?+8>x!Sou+EypwIE>2r{A7yN9mQdnFlv-|0}^q+)sjM1^zq0 z7=9=4%fI@YgLT3;K*w|A2sae)Ddr}e^Jt@U`cCd}{%HQ_^3l@K2REHd&e+g(ge1lg gk{ELa@jK}pbH)c5t$jB?h`