From 8d4ceded8decde128a2e200cab8ab90901b4b788 Mon Sep 17 00:00:00 2001 From: Steve Nyemba Date: Thu, 12 Dec 2019 11:07:31 -0600 Subject: [PATCH] removing stuff --- Untitled.ipynb | 80 ------------ curation-prod.json | 12 -- curation-test-2.json | 12 -- curation-test.json | 12 -- multi_GPU.py | 286 ------------------------------------------- vumc-test.json | 12 -- 6 files changed, 414 deletions(-) delete mode 100644 Untitled.ipynb delete mode 100644 curation-prod.json delete mode 100644 curation-test-2.json delete mode 100644 curation-test.json delete mode 100644 multi_GPU.py delete mode 100644 vumc-test.json diff --git a/Untitled.ipynb b/Untitled.ipynb deleted file mode 100644 index f7f5a6f..0000000 --- a/Untitled.ipynb +++ /dev/null @@ -1,80 +0,0 @@ -{ - "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/curation-prod.json b/curation-prod.json deleted file mode 100644 index 2c75f66..0000000 --- a/curation-prod.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "type": "service_account", - "project_id": "aou-res-curation-prod", - "private_key_id": "ecbf77975c5b7b1f4d4b1680bf67a5e0fd11dfaf", - "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDcDBFIIOYtSlKU\njA5xBaRYk6+jccisNrvfBT3Lue9Kqy6ad35V+gUGqZ18bIKAgziQy8m5Iiw5VDFm\nZslN4yUFy05g0k+XY0HYq2rqeMeThH9pQ/xfN6XsOy8ED9eONzvnhuX2Jbevm9qr\n0xSIAkFsBYGNs+NjgU4fSmLfptAt2rVs19BI1qRPVBBzA640+hWIATVqr0ibnpE7\ndl7ONzWPWgmgHfhu2A1MjYO5obNJ4NyZ8Y86aAa7N098r+388QGX3XN2I9rWfKIj\nUGEpapmEKwnb8zC92v9GaT2qfbO2vdNsRYE930LGmxlmW+Ji7YO5FRaitvuk2iMU\n7g8d/GZZAgMBAAECggEAIUXi3Bb7byhAne0ipuTtQaaNRafoKeA53sJ+Yl6aaB5D\n1QASFqKQXX5KzbxjrFaLOFvURB3+dWm9cYhD0rbwy3Q/RQUwG0pbM83RxCQgu3Xq\nxSpOUECMIpEdbh4OIFdKQ9tiTOrNoGxu75HiliFPLqwTd6+Wh96Ox0z6b+qbqn8S\nqcEK0JQXvzC1BbR7vhsySIFP5hz8F0JThm94B3tiClzsixGCk6wydXuPs64x3rGt\nZ57dxBQBUVxYmaI3LQ/1cm7nv7uqfbUHDZrpLzE6/AevP5iNyzY1bkdUJ45mj2Ay\nWhqW9ftOhyRE9C2djPcopgrjRPbH/U0491tTLuc2XQKBgQDyp08o7mEz97/aGWmr\nNj3+QjBwNoDkdiR3qUrgohLwSNahSpiPv9+yjGvfXHQUxNyJfJ2Zei5bSTCjqKTk\nNq4QmvO4gsEhABOuqU0U0NlrpGSj0amwrCrqh7gxG/tnSuVEOzEKbY9g0CaXlg1O\nbJtP8yvicJc7m/5RxLKI8LoW1QKBgQDoJnKv8+JZc/16FI/4bU8BwUUHRiazWDIt\n9aCt63h+Fs6PAAFuGo04lobQEukbwU3EB63jWKCaxGJkjh+/lLkTelzRlVyVs0N0\nOb9WL4vYtwMrmtXKPfqKmJS81qwlLHA0+YBeE56uElwyFMAEsIIRb4YjffZd3Cy9\nT19cMSmbdQKBgBo046HCDRF1wmylrfnlw9BACcc0u7rw34Nk70dPecgltbh5u/xa\ndqhr7gKTk53inQbkRIkc3wDQ6MXkItra5PW6JnRY+s67mWSVuFN1MuYjPRNMQ41n\nKsNloQj8wqwnNJen5OYBayjDkkdw10MPC78YvjaYflzbvh3KppWPmil5AoGBAKID\nWxyynrABA9A0E3mzh2TZJbx6171n+rUaa8WUxKVycztXLKhTfWUVoAYMfISzNftt\nxIwaKRN5pJU6nquMNlGCns5hZ5jN33B4cLDMQ9O9fUfsKfGXqYcaDwtu4fqbdb9y\ntIRzOtWO2KrW0l8zc8KJS1rvqIU+iDah8xIa+UeVAoGBAKagVX0AN1RwoRg7LKdZ\n9eMQeYfaeVrfbxMDqEluEJzAQbvRoPZ75UNMre+vTOHLZuPF9uT+N71amgkKaL1T\nV1qWzNBU0bvpD9xvdCJWmypoccV2by1Nj2rPll5wfg1CPhmEQuNB30YLOTAws9Tc\nmb0kWAwnL39cUQyXJ5zBGd3K\n-----END PRIVATE KEY-----\n", - "client_email": "aou-res-curation-prod@appspot.gserviceaccount.com", - "client_id": "", - "auth_uri": "https://accounts.google.com/o/oauth2/auth", - "token_uri": "https://oauth2.googleapis.com/token", - "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", - "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/aou-res-curation-prod%40appspot.gserviceaccount.com" -} diff --git a/curation-test-2.json b/curation-test-2.json deleted file mode 100644 index a021dba..0000000 --- a/curation-test-2.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "type": "service_account", - "project_id": "aou-res-curation-test", - "private_key_id": "be9cb7427212dea882379d125530f5339ba854a7", - "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCljt1hxwqInD2U\nKLv9SQX08tE0+APKzOH4Cw3vZt495aAlmKpsRt0ze3HdobouOQXzySqJZqHqgK3k\n5oqjlXOEFVrupIO5WnujGA3Ln7SP9vK1fjiNeKFvX/W+ePULRsOp1pZts53p5OzU\nS2PU2UowAVip9iJAjTeLpoF4cYjHG1jM4oYIRq8mCtuBNmsNE6peY4lWrlouHIvy\nPKJOAQ0kwEbtxsVfEBYqvcb8X5NSFi4/gwP5y1z8ALjQ3eLJjcqPfsAGI2Lpf7Ah\nM+RbW3rkT0FKCbUjUY1NNhQKguDdzeTGModjGyQxp3Y7qT1LHOvRKIZXb3Ft3f1C\nHyUsytJlAgMBAAECggEAEk8TXS3VlLgFTgOXOUfrGGSwuDU5Y3h3APxlT8rGMdLZ\nfBmUYfcQSBI9zG8x7MyyQ3yaxKk3Uidlk8E0fH9u+qDLS/BLqk2UYLwB7Tk95FyW\nCMuVq3ziCt7HiYdM6jCq5iHCGbhZyApgxTWKgSPVQtZ98gXd/IThgK3VoaFEqWgc\nsVDO/AokZF56luDHzISALh3+LhsoYxerTP43XA4jDv4i/qzmDAwUcBf1mI76qaOZ\nOwoETJre+kaI61ZqVcnGteSVnvfb8Z5e5Gvwtig2akiNbT+E/HeTfQiCTJ9r5dUA\n5U1r4O4Veu0gLENvK4NE0kdn3k6BTLeOljuxIXzHPQKBgQDk2/0SdhZYScAsXts+\nFl3FJbVU409szRX/uUWtBjD2sIm9GRYmBv07Kk3MV+Egh8e9Ps/wjb6fxbhlEVGf\nvbPuR9pn4Ci+fllH7TWsy1atcyZaZXD22/eHOXOjiE+rFUAfO94fXIxVXtB0yuxe\nf+zQ6rltpn5ttZBQghYsm0weawKBgQC5MRftZqf+d7AzP5Pj4mPUhxmwrHNWaryw\nHAqer4X9kjS/zBlHWQjdqA9rpFgXzaETRY5sbC9ef2FgCG2mSAYEvyYBA4L8t71s\ntUO/v3VgSs0xheOnAI8RFnq5g5Bbzd4IPZB+dEq9gPph+P/QLCFpRX0LFzhOwkrx\nvaicvMFmbwKBgHFL5tEI3K8Ac76Dhw4JjIpYzJgln+BA9y8NzUyG0B6P7uBKVwik\nVSDBJJqQtsaf8WXifpab1U7LVynRlRL7muPPdnQOKJ2FdzWAXR4Z2+MqKkZ+CZpr\n8vJiorjGdoo/jurnfGMSMfbhZVksTC/MLLSQPxPlZJlzVOpGPCwBBYHZAoGALmKE\nirresxcJdByljzuiI5ZfMehPz0JW1ol/g3WVSwj2219kqYE8fkBc9GoqgnPHt4sB\nfFiwmKuxGRujUzXRBBlYjIJzqZbgBD12pa1v2dmCgbf2aFr0eqQ1wweX/daXmVrK\nOVIpckO+8xEqCdsz1ylHg6KiQN/bY6dMd02z51MCgYAZRr+hutgjPOQEdWujFgkL\noTypuWmqvdQmOj8L0o3wee2D5ScMx7obtoKhYP+FpC4U9xgoImiS9hLL3FurwVNi\n36GEodFO7iTFnBowJFp+COW5xX8ISEc0LVKkFoHyMfXZa+zxFWRTRRRwzmnHGBq+\nRY2vrlcCx36QEcQdwFR72Q==\n-----END PRIVATE KEY-----\n", - "client_email": "aou-res-curation-test@appspot.gserviceaccount.com", - "client_id": "", - "auth_uri": "https://accounts.google.com/o/oauth2/auth", - "token_uri": "https://oauth2.googleapis.com/token", - "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", - "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/aou-res-curation-test%40appspot.gserviceaccount.com" -} diff --git a/curation-test.json b/curation-test.json deleted file mode 100644 index f48f64d..0000000 --- a/curation-test.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "type": "service_account", - "project_id": "aou-res-curation-test", - "private_key_id": "1ed8d298e4b5572e7556b2f079133ea04568396a", - "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCwf6bQeRLpKhlh\nvFIjiZvdu68mm/6x37zmH5jBoCv8fWteUbqSwyPzz3954qLpENvad/ob+ELHMOnU\n9LNgRwKTYNuBpRRPELdh95lF7zmHyat6GRA0Y6ofIU1ScjzJlQlFQ8+PnYNTrpgh\nqOtmgLAbI7S0mMsQodXsZwuPyHW0nf5CCY7gnXuThxmTt46hY7Zd9WCKH7ra+P9W\nqzHRRQyuC/43bQIFuHP1wWUrmnJCbypWcgRQEKfoWyXKVEsNGcbUMYLFOixraQuk\n8mhRgncMe2dR7R2M60Q0fLKAF4CZDfG2N70ACoIY8sFGkXSjFG2rlok7spYwdYIX\nafKQHbZ1AgMBAAECggEAAzb7NfSs/5psACFuFsY3+xFvyF9ZNvcxMx9wzyU/BKg2\n9buKXCFgY12S3+72jBIDcL0ns2CE76jet9zFjNbheQeJTmXp2UjS9kTywaXXIYSI\nWL7h6/pdJZg1ltW/pEvp8WnuewCukC5WO6K4HiCKh9Jq+H3uxCMWfB0iX+BevuC4\n4FEC0eJ6BD5rI8gUr5HO8VtCgxW99dJHgrdx+rRlJEaeY5FwGLW/ITBjsV0S48Pl\nvxcpHWbUCn13tE1EWR0QhFyazUWw8xqdY1+H++ku45pAZuMxYlFGkhssBbVJqYwP\nMjkjy9z4n/xXUVj7iwTWweQ2dvZracKEmBP2szAJkQKBgQDeGXMRJ9UK79Anewm/\nqXQWKzMYzwcWT+1hTfUweL5SMzTjO/tuqMsDqndCeAacpLUOxXjIcINWP/P1+VDH\nIFj8JpQMw86t2JUwMqcmSk44he85wfT3qgoxe6LglQIbWgV6cZY1OKnkuKIln2FW\nlpGdiSRRM430+wN2Fq9YsFRimQKBgQDLcFlBVL0NTC+wlD72I6/dSKeWNpz50epp\ng4qOg3zq7rMa8S/O/m1w3ZFyeAz+E4LA1Mi42MQPr6vhGFPczQgoPboe2rCnIPqR\nnFhkWqLBTk7BgmqnZV1lzrdvosmGscOdfQwnw8gNDe1KjAmPQvdP95qGcYKh5kKu\nxz3P3S74PQKBgAZ9YeJfcpc2OLPeoYNLNUwsiPqxmfhp73rHZ2G6NX17Z5E4QHmU\nTxJVWdTEYxUSrwO2e3gH6Z6MkdlfJqAa7t63Vd4lnpVv3bQh1saEp1J5f2sFot3V\nxyR5A2JimEQqVjykswntFPHM/1fwF00La0faKQiCZCSDbS93LDqANIcJAoGBAJmE\nc2YweuVA+6/lfsmhToHO5OAe4EBI3vq2j+VRZf+nFzMalDhAmPeVy780xqEouf+n\n0rxinzkzGKIpCIfTlPdA9WV5I9tKsKsW70DzgGQdIqM2NiOSA3PjFVvB3Q+ur231\nwilzvU/UlZ8uo7wfDZ+julD/8VMY/nMD2So1v88FAoGACPUobP69SukbZIl4rYLL\nAZEcxlQCOP/2nWGY7spReiIZKqXCkwMElR8r41//Kb6/h0knKlW8NsC2vpvOBgHO\nG7ZYooscHP8v203lPtGykaBA1xeFY5NKD0gGAG+CmSLorM8cYMUv4RXrIOtmAgrG\nXdLo0jPwQXGSTqOdPvNqBi0=\n-----END PRIVATE KEY-----\n", - "client_email": "aou-res-curation-test@appspot.gserviceaccount.com", - "client_id": "", - "auth_uri": "https://accounts.google.com/o/oauth2/auth", - "token_uri": "https://oauth2.googleapis.com/token", - "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", - "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/aou-res-curation-test%40appspot.gserviceaccount.com" -} diff --git a/multi_GPU.py b/multi_GPU.py deleted file mode 100644 index 0dfdff0..0000000 --- a/multi_GPU.py +++ /dev/null @@ -1,286 +0,0 @@ -import tensorflow as tf -from tensorflow.contrib.layers import l2_regularizer -import numpy as np -import time -import os - -os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" - -#### id of gpu to use -os.environ['CUDA_VISIBLE_DEVICES'] = "0" - -os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' - -#### training data -#### shape=(n_sample, n_code=854) -REAL = np.load('') - -#### demographic for training data -#### shape=(n_sample, 6) -#### if sample_x is male, then LABEL[x,0]=1, else LABEL[x,1]=1 -#### if sample_x's is within 0-17, then LABEL[x,2]=1 -#### 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('') - -#### 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) - -g_structure = [128, 128] -d_structure = [854, 256, 128] -z_dim = 128 - -def _variable_on_cpu(name, shape, initializer=None): - with tf.device('/cpu:0'): - var = tf.get_variable(name, shape, initializer=initializer) - return var - - -def batchnorm(inputs, name, labels=None, n_labels=None): - mean, var = tf.nn.moments(inputs, [0], keep_dims=True) - shape = mean.shape[1].value - offset_m = _variable_on_cpu(shape=[n_labels,shape], name='offset'+name, - initializer=tf.zeros_initializer) - scale_m = _variable_on_cpu(shape=[n_labels,shape], name='scale'+name, - initializer=tf.ones_initializer) - offset = tf.nn.embedding_lookup(offset_m, labels) - scale = tf.nn.embedding_lookup(scale_m, labels) - result = tf.nn.batch_normalization(inputs, mean, var, offset, scale, 1e-8) - return result - - -def layernorm(inputs, name, labels=None, n_labels=None): - mean, var = tf.nn.moments(inputs, [1], keep_dims=True) - shape = inputs.shape[1].value - offset_m = _variable_on_cpu(shape=[n_labels,shape], name='offset'+name, - initializer=tf.zeros_initializer) - scale_m = _variable_on_cpu(shape=[n_labels,shape], name='scale'+name, - initializer=tf.ones_initializer) - offset = tf.nn.embedding_lookup(offset_m, labels) - scale = tf.nn.embedding_lookup(scale_m, labels) - result = tf.nn.batch_normalization(inputs, mean, var, offset, scale, 1e-8) - return result - - -def input_fn(): - features_placeholder = tf.placeholder(shape=REAL.shape, dtype=tf.float32) - labels_placeholder = tf.placeholder(shape=LABEL.shape, dtype=tf.float32) - dataset = tf.data.Dataset.from_tensor_slices((features_placeholder, labels_placeholder)) - dataset = dataset.repeat(10000) - dataset = dataset.batch(batch_size=BATCHSIZE_PER_GPU) - dataset = dataset.prefetch(1) - iterator = dataset.make_initializable_iterator() - # next_element = iterator.get_next() - # init_op = iterator.initializer - return iterator, features_placeholder, labels_placeholder - - -def generator(z, label): - x = z - tmp_dim = z_dim - with tf.variable_scope('G', reuse=tf.AUTO_REUSE, regularizer=l2_regularizer(0.00001)): - for i, dim in enumerate(g_structure[:-1]): - kernel = _variable_on_cpu('W_' + str(i), shape=[tmp_dim, dim]) - h1 = batchnorm(tf.matmul(x, kernel), name='cbn' + str(i), labels=label, n_labels=8) - h2 = tf.nn.relu(h1) - x = x + h2 - tmp_dim = dim - i = len(g_structure) - 1 - kernel = _variable_on_cpu('W_' + str(i), shape=[tmp_dim, g_structure[-1]]) - h1 = batchnorm(tf.matmul(x, kernel), name='cbn' + str(i), - labels=label, n_labels=8) - h2 = tf.nn.tanh(h1) - x = x + h2 - - kernel = _variable_on_cpu('W_' + str(i+1), shape=[128, 854]) - bias = _variable_on_cpu('b_' + str(i+1), shape=[854]) - x = tf.nn.sigmoid(tf.add(tf.matmul(x, kernel), bias)) - return x - - -def discriminator(x, label): - with tf.variable_scope('D', reuse=tf.AUTO_REUSE, regularizer=l2_regularizer(0.00001)): - for i, dim in enumerate(d_structure[1:]): - kernel = _variable_on_cpu('W_' + str(i), shape=[d_structure[i], dim]) - bias = _variable_on_cpu('b_' + str(i), shape=[dim]) - x = tf.nn.relu(tf.add(tf.matmul(x, kernel), bias)) - x = layernorm(x, name='cln' + str(i), labels=label, n_labels=8) - i = len(d_structure) - kernel = _variable_on_cpu('W_' + str(i), shape=[d_structure[-1], 1]) - bias = _variable_on_cpu('b_' + str(i), shape=[1]) - y = tf.add(tf.matmul(x, kernel), bias) - return y - - -def compute_dloss(real, fake, label): - epsilon = tf.random_uniform( - shape=[BATCHSIZE_PER_GPU, 1], - minval=0., - maxval=1.) - x_hat = real + epsilon * (fake - real) - y_hat_fake = discriminator(fake, label) - y_hat_real = discriminator(real, label) - y_hat = discriminator(x_hat, label) - - grad = tf.gradients(y_hat, [x_hat])[0] - slopes = tf.sqrt(tf.reduce_sum(tf.square(grad), 1)) - gradient_penalty = tf.reduce_mean((slopes - 1.) ** 2) - all_regs = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) - w_distance = -tf.reduce_mean(y_hat_real) + tf.reduce_mean(y_hat_fake) - loss = w_distance + 10 * gradient_penalty + sum(all_regs) - tf.add_to_collection('dlosses', loss) - - return w_distance, loss - - -def compute_gloss(fake, label): - y_hat_fake = discriminator(fake, label) - all_regs = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) - loss = -tf.reduce_mean(y_hat_fake) + sum(all_regs) - tf.add_to_collection('glosses', loss) - return loss, loss - - -def tower_loss(scope, stage, real, label): - label = tf.cast(label, tf.int32) - label = label[:, 1] * 4 + tf.squeeze( - tf.matmul(label[:, 2:], tf.constant([[0], [1], [2], [3]], dtype=tf.int32))) - z = tf.random_normal(shape=[BATCHSIZE_PER_GPU, z_dim]) - fake = generator(z, label) - if stage == 'D': - w, loss = compute_dloss(real, fake, label) - losses = tf.get_collection('dlosses', scope) - else: - w, loss = compute_gloss(fake, label) - losses = tf.get_collection('glosses', scope) - - total_loss = tf.add_n(losses, name='total_loss') - - # loss_averages = tf.train.ExponentialMovingAverage(0.9, name='avg') - # loss_averages_op = loss_averages.apply(losses + [total_loss]) - # - # with tf.control_dependencies([loss_averages_op]): - # total_loss = tf.identity(total_loss) - - return total_loss, w - - -def average_gradients(tower_grads): - average_grads = [] - for grad_and_vars in zip(*tower_grads): - grads = [] - for g, _ in grad_and_vars: - expanded_g = tf.expand_dims(g, 0) - grads.append(expanded_g) - - grad = tf.concat(axis=0, values=grads) - grad = tf.reduce_mean(grad, 0) - - v = grad_and_vars[0][1] - grad_and_var = (grad, v) - average_grads.append(grad_and_var) - return average_grads - - -def graph(stage, opt): - # global_step = tf.get_variable(stage+'_step', [], initializer=tf.constant_initializer(0), trainable=False) - tower_grads = [] - per_gpu_w = [] - iterator, features_placeholder, labels_placeholder = input_fn() - with tf.variable_scope(tf.get_variable_scope()): - for i in range(NUM_GPUS): - with tf.device('/gpu:%d' % i): - with tf.name_scope('%s_%d' % ('TOWER', i)) as scope: - (real, label) = iterator.get_next() - loss, w = tower_loss(scope, stage, real, label) - tf.get_variable_scope().reuse_variables() - vars_ = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=stage) - grads = opt.compute_gradients(loss, vars_) - tower_grads.append(grads) - per_gpu_w.append(w) - - grads = average_gradients(tower_grads) - apply_gradient_op = opt.apply_gradients(grads) - - mean_w = tf.reduce_mean(per_gpu_w) - train_op = apply_gradient_op - return train_op, mean_w, iterator, features_placeholder, labels_placeholder - - -def train(max_epochs, train_dir): - with tf.device('/cpu:0'): - opt_d = tf.train.AdamOptimizer(1e-4) - opt_g = tf.train.AdamOptimizer(1e-4) - train_d, w_distance, iterator_d, features_placeholder_d, labels_placeholder_d = graph('D', opt_d) - train_g, _, iterator_g, features_placeholder_g, labels_placeholder_g = graph('G', opt_g) - saver = tf.train.Saver() - init = tf.global_variables_initializer() - - with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)) as sess: - sess.run(init) - sess.run(iterator_d.initializer, - feed_dict={features_placeholder_d: REAL, labels_placeholder_d: LABEL}) - sess.run(iterator_g.initializer, - feed_dict={features_placeholder_g: REAL, labels_placeholder_g: LABEL}) - - for epoch in range(1, max_epochs + 1): - start_time = time.time() - w_sum = 0 - for i in range(STEPS_PER_EPOCH): - for _ in range(2): - _, w = sess.run([train_d, w_distance]) - w_sum += w - sess.run(train_g) - duration = time.time() - start_time - - assert not np.isnan(w_sum), 'Model diverged with loss = NaN' - - format_str = 'epoch: %d, w_distance = %f (%.1f)' - print(format_str % (epoch, -w_sum/(STEPS_PER_EPOCH*2), duration)) - if epoch % 500 == 0: - # checkpoint_path = os.path.join(train_dir, 'multi') - saver.save(sess, train_dir, write_meta_graph=False, global_step=epoch) - # saver.save(sess, train_dir, global_step=epoch) - - -def generate(model_dir, synthetic_dir, demo): - tf.reset_default_graph() - z = tf.random_normal(shape=[BATCHSIZE_PER_GPU, z_dim]) - y = tf.placeholder(shape=[BATCHSIZE_PER_GPU, 6], dtype=tf.int32) - label = y[:, 1] * 4 + tf.squeeze(tf.matmul(y[:, 2:], tf.constant([[0], [1], [2], [3]], dtype=tf.int32))) - fake = generator(z, label) - saver = tf.train.Saver() - with tf.Session() as sess: - saver.restore(sess, model_dir) - for m in range(2): - for n in range(2, 6): - idx1 = (demo[:, m] == 1) - idx2 = (demo[:, n] == 1) - idx = [idx1[j] and idx2[j] for j in range(len(idx1))] - num = np.sum(idx) - nbatch = int(np.ceil(num / BATCHSIZE_PER_GPU)) - label_input = np.zeros((nbatch*BATCHSIZE_PER_GPU, 6)) - label_input[:, n] = 1 - label_input[:, m] = 1 - output = [] - for i in range(nbatch): - f = sess.run(fake,feed_dict={y: label_input[i*BATCHSIZE_PER_GPU:(i+1)*BATCHSIZE_PER_GPU]}) - output.extend(np.round(f)) - output = np.array(output)[:num] - np.save(synthetic_dir + str(m) + str(n), output) - - -if __name__ == '__main__': - #### args_1: number of training epochs - #### args_2: dir to save the trained model - train(500, '') - - #### args_1: dir of trained model - #### args_2: dir to save synthetic data - #### args_3, label of data-to-be-generated - generate('', '', demo=LABEL) - diff --git a/vumc-test.json b/vumc-test.json deleted file mode 100644 index a525699..0000000 --- a/vumc-test.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "type": "service_account", - "project_id": "aou-res-deid-vumc-test", - "private_key_id": "8b7acef9a1f1137799011cf13cf0906e331c472e", - "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCYRPv0ZMGLXjva\nVZjJlcApDpXhJl2iDghhG0JqUH1PmuLjMtmhuMSgweq+M3KNF92Wft9Ree+fTN6m\nVtyqZMgz1qXi6I1WJHyT+ndtk4eWlE4O1AxE0QkfLqtj1kafU6Yu2tGpZ23jHFG9\nc7oq1tqPwC39pKE3ScShcpbZxFqvOFwW7ZSHEQ2Zk0/9lA0bfQH+Vaq1JqBbMkCO\nh1p1ptXPHyIoTjgbtQ/3N6JHA9XpqF1DHFQTe6H/4Zc+GUBV8kb/9pdeybcrhd1K\nVzuT6pAkOLQ7Wtq9Hwl3zAF3jyhlEpirYt4tjcw1pq0phhUuDGcLS37cTzWkqekr\nFEp8NkSnAgMBAAECggEAI16Kw+cPigb2ki2l0tVlEGRh7i2SPE1UJvJFCBrwMKiC\noVGzebxIeCrzEwEyT5HGl+mah/tx7KfXY/3zPeUxF9F5MO7hvau2AE2CpkJJkXGb\nfBhHTUjc/JBDoWopd2LfzCxp3Ra4ULPITOBv0vmbRR7Xz/4IsKYC9Zl/btAMXHy4\nJZZuifK8mCD4BDXxG6W2p+jqeKFjKYTuHyCKWy9u8NnnH6eoNMLvewr/P3pPZK9l\nSFQDV0nWU0yZoR4cccYHtq/9Uw1pY7A9iNYI4JnAnPam8Rka0OEgZbqMVsk3FUmA\nG+SOtiJ9iopQsW5g/HTG7Q420gijnfe5IWQK6yLBOQKBgQDNCuGexHMUGB+/bxFK\nnQ+AiktFib76PbMYFSGdsQQYHGcNHXmXRnJbpj/llO7tiWk/akOA0UrjtipXERTP\nYoXRDlghvnluxUYDm+mD94jSe7rE45b+sNH8FyqgrHWJVHSPBcIz0YXCUxRmE9eq\n4BcNfTqtjAl7hasWhGUVlXppawKBgQC+HJn1Lpvp89h+7ge09p6SU6RhAbOygrtA\nBD3Odr6WV6SGXEKyFHSHLkRVA1BFzzTXl3nEJvHFe7I5RNnVzWSqmf4LkBcIDqQO\nmiNb2TbA/h4utlMJvTrit03qdzngvgmoWyKqNpxmj6afNU/up4ck0hqBkJae/FBQ\nkoSwXcA0tQKBgDJzE/JZiasPCHi0nj+Kh27sF/sjGj8+ARvSzzOag1RfYKekce9b\noPWV4TDexS7i2WeGANfoJxICF0bW6BTiu+QlMGAVGpG7ri9jJECZHiwTz290RAmk\nffYVySJBbKX+hrNOCmtviQa4JFO9XBoqCuIBxvc+dnLS/7aJmsmFvtnDAoGAfQRf\n9gzdeN7i+q1bIhSfuIgKa8RrwDMaIgHoBxKtSD6AMd8P+P1cl9zEEMeqDQ4yqKey\n6lvV19D9JY3yVhfIYCv+FOp/Sswd9IBGSkswJ3+0p3E8cAYhaB+0vEAFLpap0S2F\nQTvCY+uJXd74Hm/KflswFQ3ZDtnLkwCXA0fTcpUCgYBMkcE6Bn0tIShaXsaaufIW\nXrJ6gtEUDtUXP85lNO7hUxBWTu2dF6OsgBniNfWypmRecaZsFl/sD6YKT0bV1vvv\nU0uhYTDx5z7o8ahvjBwOqF5sDDVX02umFBoG16zd3hpOJrGSh+ESpJhWw5dV6m5J\n530zPFObyt2kI9+E75+G/w==\n-----END PRIVATE KEY-----\n", - "client_email": "dev-deid-600@aou-res-deid-vumc-test.iam.gserviceaccount.com", - "client_id": "104228831510203920964", - "auth_uri": "https://accounts.google.com/o/oauth2/auth", - "token_uri": "https://oauth2.googleapis.com/token", - "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", - "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/dev-deid-600%40aou-res-deid-vumc-test.iam.gserviceaccount.com" -}