fastai-genomic / Git / Diff of /ipynb/BacteriaClassifier.ipynb

Models:
MarcoTheBlack/
fastai-genomic
Downloads: 1
Diff of /ipynb/BacteriaClassifier.ipynb [000000] .. [98867e]
Switch to side-by-side view

--- a
+++ b/ipynb/BacteriaClassifier.ipynb
@@ -0,0 +1,1789 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## basic classifier for Dna2Vec represenation\n",
+    "\n",
+    "Basic bacterial genome classification using Dna2Vec representation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#export\n",
+    "import sys\n",
+    "sys.path.append(\"..\")\n",
+    "from faigen.data import sequence \n",
+    "from faigen.data.sequence import regex_filter, count_filter, Dna2VecDataBunch\n",
+    "from functools import partial\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from sklearn.decomposition import PCA\n",
+    "from sklearn import manifold,neighbors\n",
+    "from scipy.cluster.hierarchy import dendrogram, linkage  \n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns; sns.set(color_codes=True)\n",
+    "import plotly.plotly as py\n",
+    "import plotly.graph_objs as go\n",
+    "from fastai import *\n",
+    "from fastai.data_block import *\n",
+    "from fastai.basic_train import *\n",
+    "from fastai.layers import *\n",
+    "from fastai.metrics import *\n",
+    "from gensim.models import Word2Vec\n",
+    "import torch \n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import gc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "unexpected EOF while parsing (<ipython-input-3-eb05e039e64b>, line 2)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-3-eb05e039e64b>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    if __name__=='__main__':\u001b[0m\n\u001b[0m                            ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unexpected EOF while parsing\n"
+     ]
+    }
+   ],
+   "source": [
+    "#export\n",
+    "if __name__=='__main__':"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading embedding\n"
+     ]
+    }
+   ],
+   "source": [
+    "#export\n",
+    "print(\"Loading embedding\")\n",
+    "word_vectors = Word2Vec.load_word2vec_format('../faigen/pretrained/embeddings/dna2vec-20190611-1940-k8to8-100d-10c-4870Mbp-sliding-LmP.w2v') "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  1%|          | 2/241 [00:00<00:13, 17.97it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting sequence metadata\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 241/241 [00:10<00:00, 23.12it/s]\n",
+      "  2%|▏         | 2/82 [00:00<00:04, 17.44it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting sequence metadata\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 82/82 [00:03<00:00, 24.88it/s]\n",
+      "  2%|▏         | 4/241 [00:00<00:07, 33.40it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading sequences\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 241/241 [00:06<00:00, 39.11it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tokenizing\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vectorizing\n",
+      "606\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "  0%|          | 0/82 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading sequences\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 82/82 [00:04<00:00, 18.72it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tokenizing\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vectorizing\n",
+      "194\n"
+     ]
+    }
+   ],
+   "source": [
+    "#export\n",
+    "# DB=\"/data/genomes/GenSeq_fastas\"\n",
+    "# DB='/home/serge/development/genomes/ncbi-genomes-2019-04-07/bacterial genomes'\n",
+    "DB=\"/home/serge/database/data/genomes/ncbi-genomes-2019-04-07/Bacillus\"\n",
+    "\n",
+    "bunch=None\n",
+    "learner=None\n",
+    "gc.collect()\n",
+    "\n",
+    "#filters=[partial(regex_filter, rx=\"Streptomyces|Staphylococcus|Vibrio|Rhizobium\"),partial(regex_filter, rx=\"plasmid?\\s\", keep=False)]    \n",
+    "#        partial(count_filter,num_fastas=(1,1), keep=1)]\n",
+    "\n",
+    "bunch = Dna2VecDataBunch.from_folder(DB,\n",
+    "             filters=[],\n",
+    "             labeler=lambda x: \" \".join(x.split()[1:3]),\n",
+    "             emb=word_vectors,ngram=11,skip=0,\n",
+    "             n_cpus=7,agg=partial(np.mean, axis=0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bunch.export(\"Bacillus.pkl\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.feature_selection import SelectKBest"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((194,), 194)"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bunch.valid_ds.y.items.shape, len(bunch.valid_ds.x.items)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = list(bunch.train_ds.x.items)+list(bunch.valid_ds.x.items)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y = list(bunch.train_ds.y.items)+list(bunch.valid_ds.y.items)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "bacillus_df = pd.DataFrame(data=X)\n",
+    "bacillus_df[\"target\"] = y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bacillus_df.to_csv(\"../data/Bacillus-8mer.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scorer = SelectKBest()\n",
+    "X_10 = scorer.fit_transform(X, y)\n",
+    "bacillus_10_df = pd.DataFrame(data=X_10)\n",
+    "bacillus_10_df[\"target\"] = y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fastai.tabular import * "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dep_var = 'target'\n",
+    "valid_idx = range(len(bacillus_10_df)-80, len(bacillus_10_df))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = TabularDataBunch.from_df(\"../data\", bacillus_10_df, dep_var, valid_idx=valid_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "learn = tabular_learner(data, layers=[20,10], metrics=accuracy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
+     ]
+    }
+   ],
+   "source": [
+    "learn.lr_find()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAESCAYAAADe2fNYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XlY1WX+//HnOcBhkR0PyhFcETB3RUtTTHAhATG1bAaXNKlxpuVbU07WTKuz0DIzlZbVr7RmnKUyNc3M3KNccoU0QFFTWRRQhMNyzuGcz+8P80wmKuBZ4f24rq5Lzmd7nZPyPvd9fz73rVIURUEIIYSwEbWzAwghhGhdpLAIIYSwKSksQgghbEoKixBCCJuSwiKEEMKmpLAIIYSwKSksQgghbEoKixBCCJuSwiKEEMKmpLAIIYSwKSksQgghbEoKixBCCJuSwiKEEMKmPJ0dwJHOn6/BYrHPZM5hYf5UVOjtcm57ktyOJbkdyx1zu1JmtVpFSEi7Zh/XpgqLxaLYrbBcOr87ktyOJbkdyx1zu2Pmn5KuMCGEEDYlhUUIIYRNSWERQghhU1JYhBBC2JQUFiGEEDYlhUUIIYRNSWERQohWymAy89Q7O8k/ed6h15XCIoQQrVRltYGSiloqquodel0pLEII0UrVGRsA8NU49ll4KSxCCNFK1dX/WFi8pbAIIYSwgVqDGZDCIoQQwkbqL3WF+UhhEUIIYQO1hktjLB4Ova4UFiGEaKXqDDLGIoQQwobqDA1oPNV4ejj2V71DylhWVhZffPEFRUVFrFmzhpiYmCv2mT9/Pvn5+daf8/PzWbx4MUlJSQCsW7eON998E0VRUKlULF26lPbt2zsivhBCuKU6gxkfB7dWwEGFJSkpiZkzZ5KRkXHVfV588UXrn/Py8pg1axYjR44EIDc3l0WLFvH++++j1Wqprq5Go9HYPbcQQrizOkODw7vBwEGFJT4+vln7f/zxx6SlpVmLx7Jly5gzZw5arRaAgIAAm2cUQojWps7QgJ+3YwfuwQXHWIxGI2vWrGHKlCnW1woLCzl16hQZGRnccccdvPHGGyiKey/dKYQQ9lZnbMUtlubYuHEjOp2OXr16WV8zm83k5+ezdOlSjEYjc+fORafTMWnSpGadOyzM39ZxL6PVumdLSnI7luR2LHfMbavMxgaF8FAfh38GLldYVqxYcVlrBUCn05GcnIxGo0Gj0ZCUlEROTk6zC0tFhR6LxT4tHa02gLKyaruc254kt2NJbsdyx9y2zKyvNeIBLT6fWq1q0Rdyl+oKKy0tZe/evaSmpl72empqKtnZ2SiKgslkYufOncTFxTkppRBCuIdaJw3eO6SwLFy4kISEBEpLS5k9ezYpKSkAZGZmkpuba91v5cqVjB49muDg4MuOT0lJISwsjAkTJjBp0iSio6OZOnWqI6ILIYRbslgUDEYzvk4YvFcpbWgUXLrCriS5HUtyO5Y75rZV5tp6Ew/8/SumJUYzfmjnFp2jVXSFCSGEsI1aJ03nAlJYhBCiVar/ccp8PyksQgghbOFSi8VHHpAUQghhC86a2RiksAghRKt0qbBIV5gQQgibqDM6Z1likMIihBCtkrUrTCOFRQghhA3UGRpQq1RovBz/a14KixBCtEIX12LxQKVSOfzaUliEEKIVctYiXyCFRQghWqU6g1kKixBCCNuRFosQQgiburgssRQWIYQQNlJraHDKdC4ghUUIIVol6QoTQghhM4qiUG80S1eYEEII2zA2WDBbFGmxCCGEsI3/TefSisdYsrKySExMJDY2loKCgkb3mT9/Punp6db/4uLi2LRp02X7HDt2jP79+5OVleWI2EII4ZacOWU+gEOumpSUxMyZM8nIyLjqPi+++KL1z3l5ecyaNYuRI0daXzObzTzzzDOMGTPGrlmFEMLd1RmcN7MxOKiwxMfHN2v/jz/+mLS0NDQajfW1t99+m9tuu43a2lpqa2ttHVEIIVoNZ7dYXG6MxWg0smbNGqZMmWJ9LS8vj+zsbO655x7nBRNCCDfh7MLinKtew8aNG9HpdPTq1QsAk8nEH/7wB/785z/j4XFjA1FhYf62iHhVWm2AXc9vL5LbsSS3Y7lj7hvN7HnsHACREUFoQ/1sEal513f4Fa9jxYoVl7VWysrKOHnyJPfddx8AVVVVKIqCXq/nhRdeaNa5Kyr0WCyKTfNeotUGUFZWbZdz25PkdizJ7VjumNsWmc+W6wGoq6mnzGxu8XnUalWLvpC7VGEpLS1l7969vPLKK9bXdDodu3btsv78+uuvU1tby+9+9ztnRBRCCJdX+2NXmI8TVo8EB42xLFy4kISEBEpLS5k9ezYpKSkAZGZmkpuba91v5cqVjB49muDgYEfEEkKIVqneaMZb44Fa7fhFvgBUiqLYp2/IBUlX2JUkt2NJbsdyx9y2yPzeuu85dPwcr/zm1hs6T0u7wlzurjAhhBA3xpkTUIIUFiGEaHXqDA1Om84FpLAIIUSr48xliUEKixBCtDrSFSaEEMKmpLAIIYSwqTpjA75OWpYYpLAIIUSr0mC2YDRZpMUihBDCNuqNzp0yH6SwCCFEq1JrXT1SCosQQggbqHfylPkghUUIIVqVS2ux+MngvRBCCFuwdoX5SItFCCGEDdRfWu9exliEEELYQq2MsQghhLAlZ693D1JYhBCiVakzNuDpocbL03m/3qWwCCFEK3JxZmPn3REGUliEEKJVcfYElAAOuXpWVhZffPEFRUVFrFmzhpiYmCv2mT9/Pvn5+daf8/PzWbx4MUlJSSxevJh169bh4eGBp6cnjzzyCCNHjnREdCGEcCttprAkJSUxc+ZMMjIyrrrPiy++aP1zXl4es2bNshaPfv36MWfOHHx9fcnLy2P69OlkZ2fj4+Nj9+xCCOFOnL16JDiosMTHxzdr/48//pi0tDQ0Gg3AZa2T2NhYFEWhsrKSjh072jSnEEK4O4PRTGigc790O7e91Aij0ciaNWtYtmxZo9tXrVpF586dW1RUwsL8bzDdtWm1AXY9v71IbseS3I7ljrlvJLPJohAU4OPU9+1yhWXjxo3odDp69ep1xbbdu3fz6quv8t5777Xo3BUVeiwW5UYjNkqrDaCsrNou57Ynye1Yktux3DH3jWauqTOBYrHJ+1arVS36Qu5yhWXFihVMmTLlitf379/P448/zhtvvEH37t2dkEwIIVyfwWjGx8ljLC51u3FpaSl79+4lNTX1stdzcnJ45JFHeO211+jdu7eT0gkhhGuzKAoGkxlvrzZQWBYuXEhCQgKlpaXMnj2blJQUADIzM8nNzbXut3LlSkaPHk1wcPBlxz/33HPU19fz9NNPk56eTnp6+mW3JgshhACj6eIElD5OnIASQKUoin0GHVyQjLFcSXI7luR2LHfMfSOZK/UGHl30NTPGxzJ6YKcbztLSMRaX6goTQgjRcgbjpRZLG+gKE0IIYX/1lwpLWxhjEUIIYX+GH8dYvKXFIoQQwhbqjRfXYpHCIoQQwiakK0wIIYRN/W/w3rm3G0thEUKIVqJexliEEELYktxuLIQQwqbqjWY81Co8PZz7q10KixBCtBKuMAElSGERQohWo97UIIVFCCGE7RiMZrydfEcYSGERQohWo97o/CnzQQqLEEK0GvUmGWMRQghhQzJ4L4QQwqYujrFIYRFCCGEj9Saz0+cJAwcVlqysLBITE4mNjaWgoKDRfebPn29ddjg9PZ24uDg2bdoEgNls5rnnnmPMmDGMHTuWjz76yBGxhRDCrdQbG9yrxbJ06VK+//57AA4cOMBtt91GUlIS+/fvv+6xSUlJLF++nE6drr5U5osvvsjq1atZvXo1WVlZBAUFMXLkSADWrFnDyZMn2bBhA//97395/fXXOX36dFOjCyFEq2exKBhNFqdPQAnNKCzLli0jMjISgFdeeYV77rmHX/3qV/zpT3+67rHx8fFEREQ0OdTHH39MWloaGo0GgHXr1nHnnXeiVqsJDQ1lzJgxrF+/vsnnE0KI1s66yJc7dYVVV1cTEBCAXq8nPz+fGTNmcOedd3L8+HGbBjIajaxZs4YpU6ZYXyspKUGn01l/joiIoLS01KbXFUIId3apsLjCXWFNbjNFRESwb98+jh49Snx8PB4eHuj1ejw8bPsmNm7ciE6no1evXjY9L0BYmL/Nz/lTWm2AXc9vL5LbsSS3Y7lj7pZkNqK6eGxYO6e/5yYXlvnz5/PQQw+h0Wh47bXXANiyZQt9+/a1aaAVK1Zc1lqBi0WtuLiYfv36AVe2YJqqokKPxaLYJOfPabUBlJVV2+Xc9mJRFHz8vDHWGS97XVEU9uaXsXnfaYIDvImJDKZnVDC6MD9UKpWT0l7OHT/vnMIK2oe2Qxfi4+wozeaOnze4Z+6WZi4pvXiM0WCy2XtWq1Ut+kLe5MIyatQosrOzL3stOTmZ5OTkZl/0akpLS9m7dy+vvPLKFdf56KOPGDduHJWVlWzcuJHly5fb7Lpt1afZx/n06xN0iwjklt4dGBoXTnF5DR9vK+R4STXaYB9KKmrZeegMAO2DfHhoaj8itfZt+dnC2fO1HDhSzpghUaidXAwtisLK7cf4bMcPAEwa0Y3UW7teluuH0mryT1XSr0cYHUP9nBVVuLFL6927wu3GTS4sR48eJTg4mPbt21NTU8O7776LWq3m3nvvxcvL65rHLly4kA0bNlBeXs7s2bMJDg7ms88+IzMzk4ceesja6lm5ciWjR48mODj4suPT09M5ePAg48aNA+A3v/kNUVFRzX2v4ifKL9Tx+a6TxHYJoa7OxL83HuE/G4+gAKGB3syeEMetfSJQqeBsZR35JytZ9dUxspbv45G7BtBdF+jst3BVZouFN1Z9x8kzerw81YweFGmzcxtNZo6XVKEN9iUkwPu6Lbg6QwPvrDnMgaPlJPSPQO3pwars45w6q+fe1F5U1Zr4ZFshu78/C8B/Nh2ha8cAbrmpA7f07khgO43NsovWzTp47wJ3hakURWlS31B6ejp/+9vf6N69O08//TTHjx/H29ubkJAQXnrpJXvntAnpCvufJau/48CRcpY8MQYaGigqr2FP3lna+XgyaoAOL88rv/WUVdbx8n/2U1Vr4uEp/YjrEuKE5Bdd6/P+bMcJVmw7RvsgH2rqTSycewshAd43fM2qGiN/++ggP/zY5dDOx5NIrT86bTsiQv2ICGtHeIgvdYYGzlUbOF9Vz+Z9RZRU1HJ3UjRJgyPRagNYvu4wH245SmiAD5V6Ax5qFeOGRjGsd0dyCyvYcfgMP5RW4+WpZmS/CJJv7kz7IF8sFoWcwgq27C/ieEkV3SICie0cTGznYLp2DMBDbb/H0tzt7/cl7pi7pZl3f3+GJasP8cLcm+nUvp1Nsti9K6yoqIju3bujKAobN25k7dq1+Pj4kJSU1OyLisudrzawed9pIsL8GN6n6bdlt9TR0xfY/f1ZJt7aFW2IL2Vl1XRq345OI7pd8zhtsC9PZAzmlf8e4K8fHiRteBfCQ/wICfAm2F9DgJ8GH40HKpUKi6JwrLiK/QVlHCysQK2CAT21DIppT5cOAXYbqympqGF19gkGx2iZOroHT7+7m399WcBvJjc+FmixKKz86hjbDhTj7+tFsL+GYH9venQKYnifjvh6X/wncrayjr/+9wCV1QZmJcfSYFY4Xabn9Fk9Ow+VUmcwN3r+AD8vHpnWn95dQwFQqVSMH9qZSK0/76/P49a+EaSP6GYtfBFh7Rg3tDPF5TV8sfsk2w4Us+1AMQN6tudESTUVVfUE+Wvo2z2UE6XV5G6tAKCHLpBHpw2w5hVtT/2lZYndqStMo9Gg1+spLCykY8eOhIaG0tDQgMFgsGe+VkVfZ8L44+yj3hoPzp6vY/2uk3zzXSlmi4JapaJDiB89OgXZLYNFUfj3piME+2u4/eYuzT4+JMCbJzIG8drHOaz86spbzb081QT4eWFqsFBda8JDrSK2czBms8JnO06w9psThAZ6MzBay6BYLTFRQTb7pm1RFJZ9nofGU830cTEE+Xsz8daurNh2jH0FZQyK0V62v77OxFurv+PQifMMiG6Pp6eaSr2BI6cvsPPwGVZsK2REvwhu6hrKss/zMJstPPaLgUT/7P+PoihcqDFSUlFLWWUdvt6ehAZ4ExroQ1A7DWr1lUW0d7dQXpw3/KrvRde+HbMn9CJ9RDfW7zrJ19+V0LVjINMSoxnQs7116dkLegP7CspY/uURFn2Sy//d2a/R1qZo/azr3Xs7//9/kwtLamoqs2bNoqamhunTpwNw+PBh60OT4tqOl1Txl+X7MDVYLnvdy1NNwgAdCf10LPokl7c+PcSzs4fi59P8b56KonDo+DkOnzhPSIA32hBfwoN9CQvysT40tevQGY6XVHFvSq8WT/3g7+vFgumDqDM0cF5vpLLaQKXeQFWtkepaE9W1RhQF+nQPpV/3MPx8Lo7BVdcaySmsYF9BGdtzitm07zT+vl7Ex4UzZVR32vlce6zuerbuL+LI6QvMmdCLIP+LLYDxQzuz6/AZln9ZQK8uIfh6e6IoCifP6Fm8MpdKvYF7bo8jof/ldxkeL6niyz2n2LKviI17ThMa6M38XwxG10gXg0qlItjfm2B/b3rZuHswNNCHX46N4ZdjYxrdHuTvzehBkfhoPHln7WGWrD7Er+/oY9duMeGa6l3oAckmj7EAZGdn4+npyS233AJAbm4uer2eYcOG2S2gLbV0jEVRlOt23VyrX9SiKPzxgz2cqzIwaWQ3DEYz9UYzXl5qbu0TYR2gPXr6An9Zvo+hvcLJTLupyd1FiqJw+IfzrP7qOEeLLqD+sSvqp3y9PQn211CpN9IhxJffz4pHrVI5rQ/aYDTz3fEK9uaX8W3eWUICvPlVep8m3RSgKAoNajW7c4opKq+hrLKOsso6ispqiOsczKPTBlz22RUWX+BPH+wl0F+DYlGoqW/AbFEICfDmN3f0veY1z1cb2JN/lvjYcJuM09jz89609zTLvyxgeJ+OzEnpZdO74dxxrALcM3dLM3+8tZAN357k7cdH2yyL3cdYAEaMGEFxcTH79++nQ4cONn+GxRV9d7yCf288wpMzBrf4G/VXB4s5XlJNZtpNDOvd8ar7RUcGkT6iKyu/Ok7vbqHc2vf64y36OhNvrMwl72QlIQHezBgfy4i+EdQZGyg7X8fZyjrOVdVTqTdyQW8gqJ2GO0dHO/0WXG+NB4NjwxkcG07S4EiWrD7En/+5l6m39WDckKgrimqD2cK+gotF6MjpC1TVXHz2xtNDjTbYB22wLzFRwaTc0uWKY3vogph1exzfHaugna8Xfj6eBPhqGN7n+nddhQR4MzbePe5ATBocSU29iVVfHUdfZ2L27XHWlpto/eqNDS7RWoFmFJazZ8/y6KOPcuDAAYKDg6msrGTAgAG88sordOjQwZ4ZnSrQT0NJRS2b9xWRNrzrFdvLL9RRUlGL+dg5TpVcwNNTTeLASGs3k77OxMdbC4mJCuaWm67/OaUM68rhE+f554YCojsF0eEazzQ0mC28sTKXo0UX+OWYnowa0Akvz4tdIF6eGgL9NHYdr7GVHp2CeHbOEN777Hv+u/koX+WUEBMZRHddEBFhfhw4Ws5XB4upqjUREuBN764hDOzVkYggbyLat2tSkUzor7uiu6s1ShvelXY+Xny45Sh/eHc3s5LjGByrvf6Bwu1dXOTLNW7eaHKKZ599lri4ON5++238/Pyora3lr3/9K8888wxLliyxZ0an6twhgL7dw/jy21OMGxJ12TeCo6cvkPWvfZh/1r227UAxc1NuIjoyiBXbCqkzmJk+LqZJXVtqtYrMtJt45r3dvLP2MAumD2q0v1xRFD5Yn0/eyUoyU29iWJ+rt4TcQTsfLx6Y3JftB4vZk3eWXd+fYeuBYgBUKujfoz2jB3Wid7dQp3bhuTqVSkXS4Eh6dQnhnTWHWbwyl/i4cHp1CUEX5oeufTva+XphNlswNSiAYh0DE+7NVZYlhmYUlr179/Lqq69aH4b08/Nj/vz51qntW7OUYV34y/J9fHWwmDE/dos0mC188EUege003D+xN9FdwzAbjBQWVfHeuu/58/K9DO/TkW9ySxk7JKpZT6uHBvowY3wsS1Yf4rNvfmBiI7cBr9v5A9m5JUy8tavbF5VLVCoVowZ0YtSATlgUhdKKWk6X6emhCyIsyP2mQXEmXft2PDVzMJ9+fYKNe06xJ+/sVfcdEhfOjPGx+PtKgXFnrrJ6JDSjsAQFBVFYWEhcXJz1tWPHjhEY6LpPYNtKTFQw0ZFBfLH7JLcN7ISnh5qNe05zuqyGByb3JSYqGG2oH2VlZuK6hPDcnKH8d/MRth8sIaidhvTrPB/SmKG9OnDgaDmffn2CPt3DLhtg/ua7ElZsO8bNN3Vo0bndgVqlQte+XaN3YYmm8fRQMzmhO3eM7Ma5KgPFFTUUl9dQbzTj6aHC00PNhRojX357ioJTlcyeEEe/Hu2dHVu0UL3R7H5jLHPnzuWee+5h6tSp6HQ6iouL+eSTT3j44Yftmc9lpNzShVc/zmHX4TPEdQ5hVfYxBkS3Z2DPK/8h+np7cs/tvRjeJwI/b88WP7Q2fWwMBacqeWfNxVuQyy/U8d8tR/nu2Dl6RgYxZ0Kcy0wKKVyXSqUiLMiHsCAf+nYPu2L7LTd14J21h/n7RzncNrAT08fGNPrsjXBt9UYzAX6u0eps8m+8u+66i6ioKNauXUt+fj7h4eG8+OKL7N271575XEa/HmFEav1Zt/MH9hWUAfDLsT2v+Ys9Jir4qtuaws/Hi3tTbuLlf+/nj//YS1G5Hl+NJ3cnRpM4ONL6kJwQN6JzhwCenjWEFdsK2fDtKUL8NaTd2jpbwq2ZwdTgfmMsAMOGDbvsmRWj0UhmZmabaLWoVComDOvM258epqSiljtv60H7IF+7X7dXlxCSb+7MF7tPkTgokvQR3aQvXNicl6eaaYnRVNUYWZV9nJioYGI7O28uONF8F8dYXOOusBv+ytuM5yvd3pC4cDqE+hGpbcfYIY57tmHqbT147eGRZIyNkaIi7EalUjFjfCzhIX4s+fSQ9Vkh4R7qTWaXmCcMbFBY2lIfv4dazVMzBvPkjMEO7YZSqVQtmuJFiOby9fZkXnpvauoaeGft4StmcBCuyWJRMJos7nNX2I4dO666zWQy2TSMO5AWg2jtOncI4JdjevLBF/l8vvMHUoZ1dXYkcR2utN49NKGwPPXUU9fcHhFh/2nehRCONWqAjryT51m5/ThxXUKcvoa6uLZLU+a7TYtl8+bNjsghhHAhKpWKmeNjKSyq4u1PD9EvtvVO29QaWFssrWWMRQjROvn5eJGZdhPlF+p5a2Wus+OIa7i03r2rtFgcUliysrJITEwkNjaWgoKCq+63bt060tLSSE1NJS0tjfLycgAqKiq47777SEtLIzk5mWeffZaGhgZHRBeiTYuJCiZ1WFc27znFrsNnnB1HXIXBhVaPBAcVlqSkJJYvX06nTp2uuk9ubi6LFi3ivffeY+3atfzrX/8iIOBiv+6SJUvo0aMHa9asYc2aNRw6dIgNGzY4IroQbd7EEV2J6xLCB1/kUVZZ5+w4ohHWZYldZGlqhxSW+Pj46w7yL1u2jDlz5qDVXpziOyAgAG/vi2tJqFQqampqsFgsGI1GTCZTq56qXwhX4qFW89uMwYCKv390EH1d27sb1NUZXGj1SGjmk/f2VFhYSGRkJBkZGdTW1jJ27FjmzZuHSqXi17/+NQ8++CAjRoygrq6OjIwMBg8e3OxrtGQltOZw1ztnJLdjuWvuP9x7M0+/tYM3Vx/ihV8Nd5lfYtfjjp93czN7Fp4DQNcxCG2I/WcEuR6XKSxms5n8/HyWLl2K0Whk7ty56HQ6Jk2axPr164mNjeX999+npqaGzMxM1q9fT3JycrOu0dKliZvCXdcHkdyO5c65OwZ6Mze1F2+tPsSf39vFvEl9XH6ySnf8vFuSufxcDQA1+jqw4fhzS5cmdpm7wnQ6HcnJyWg0Gvz9/UlKSiInJweAf/7zn0ycOBG1Wk1AQACJiYns2rXLyYmFaHuG9urAtKSe7C0o4x8b8qkzyE00rsBw6a4wF2lFukxhSU1NJTs7G0VRMJlM7Ny507r2S2RkJNu3bwcuTny5Y8cOevbs6cy4QrRZ44ZEkXxzZ7YdKObRxV/z/vo8fih1r1ZBa1NvMuPpoXaZGc8dkmLhwoUkJCRQWlrK7NmzSUlJASAzM5Pc3Iv3x6ekpBAWFsaECROYNGkS0dHRTJ06FYAnn3ySvXv3kpaWxqRJk+jatSt33XWXI6ILIRpx5209eHLGYOJjtez4rpTnln3LXz88QHWtTFzpDBfXu3eN1gqASmlD0xPLGMuVJLdjtcbctfUmth8s4ZPtxwhqp+GByX3p0tE1Bszd8fNuSeb/t/Yw+ScreenXw22axe3HWIQQ7snPx4vkmzuzYPogFBT+9M+9fJ1b4uxYbYqrtViksAghbKJbRCBPzxpCD10g7372PVv2nXZ2pDaj3iSFRQjRSgW20/DbuwfQt3sY/950lNNlemdHahMurh4phUUI0Up5qNXcm9ILPx9P3lp9COOPT4UL+6k3NrjMrcYghUUIYQeB7TTMTelFUXkNH2456uw4rV69jLEIIdqCPt3DGDckis37ijhwpNzZcVo1g8mMj8ZlJlKRwiKEsJ8po3rQuYM/7352WB6itCMZYxFCtBlenmp+PakPPhoPsv61j8Mnzjk7UqtjtlgwNlhcZi0WkMIihLCz8BA/npwRT1iQD3/78KAsGGZjBqMFcJ3VI0EKixDCAUICvFmQMYgenYJ469NDbD1Q5OxIrYZ1LRYpLEKItsbPx4vfTutPn26h/HvjEc7KapQ2cWm9e7krTAjRJnl5ejB7Qi/UahX/+rKANjRVod1carH4eMldYUKINiokwJs7RnQjp7CCfQVlzo7j9uoN0hUmhBAkxUcSqfXnXxuPWLtyRMvUX2qxSGERQrRlHmo1M8fHcr7awKfZJ5wdx60ZjFJYhBACgOjIIBL6R7Dh21OcPiuTVbaU9a4weY5FCCFg6m3R+Pl48v76PCwykN8itfXinZdSAAAZ30lEQVQXuxJ9vdvY4H1WVhaJiYnExsZSUFBw1f3WrVtHWloaqamppKWlUV5e3qRtQgj35O/rxd1J0RQWV7Flnzzb0hKVegMaT7VLdYU5pMQlJSUxc+ZMMjIyrrpPbm4uixYt4v3330er1VJdXY1Go7nuNiGEexvWuyM7vitlxbZCBvZsT2igj7MjuZULNUaC/DWoVCpnR7FySIslPj6eiIiIa+6zbNky5syZg1arBSAgIABvb+/rbhNCuDeVSsWM5DgsFoXl8mxLs13QGwjyd63fhy4zxlJYWMipU6fIyMjgjjvu4I033rD+BbvWNiGE+wsP9iV9ZDf2Hylnb74829IclXojwS5WWFxmtMdsNpOfn8/SpUsxGo3MnTsXnU7HpEmTrrmtOcLC/O2U/iKtNsCu57cXye1YkrtxGbffxN78cv6z+QijhnTGz8fLJud1x8+7OZmrao1EaP1d6n26TGHR6XQkJyej0WjQaDQkJSWRk5PDpEmTrrmtOSoq9Fgs9mnpaLUBlJW533oTktuxJPe1/WJMNH/8YC/L1x1m0sjuN3w+d/y8m5PZYDJTW9+ARo1d3qdarWrRF3KX6QpLTU0lOzsbRVEwmUzs3LmTuLi4624TQrQePXRBDIkLZ/3uk1TqDc6O4/Iu/PgZuVpXmEMKy8KFC0lISKC0tJTZs2eTkpICQGZmJrm5uQCkpKQQFhbGhAkTmDRpEtHR0UydOvW624QQrcuUUd0xmxVWZx93dhSXV6k3AhDk71p3yaqUNjQKLl1hV5LcjiW5m+ZfXxaweV8Rz987FF37di0+jzt+3s3JvPv7MyxZfYjn5wwlMtz2Y8hu3xUmhBCXpN7aFW+NmhXbCp0dxaVdcNEWixQWIYTLCfTTMOGWLuw/Uk7BqUpnx3FZlTUGPNQq/H1tcwedrUhhEUK4pDHxUYQEePOPL/Jlav2ruKB3vafuQQqLEMJFeXt5MGdCL4oravh/a7+XSSobcUFvIKida90RBlJYhBAurHe3UKaNjmZfQRlrvz7h7Dgup7LGSLCLja+AFBYhhIsbOySK4X06sir7uCxl/DMXu8KkxSKEEM2iUqmYlRxLt4gA3ll7mKOnLzg7kktoMFvQ15kIbictFiGEaDYvTw8emNyPAF8v/rJ8H5/tOGG3Z9LchaveagxSWIQQbiIkwJtnZw8lPk7Lim3HeOW/Bzhf3XanfamsufjepStMCCFugJ+PJ/dP7M3s2+MoLL7Ac8u+RV9ncnYsp7jUYpHBeyGEuEEqlYqR/XX87peDqKoxsnHPKWdHcopLE1DK7cZCCGEj3SICGRSj5cs9p6mtb3sPUFbqjaiAwHau9dQ9SGERQrix1OFdqDM0sHnfaWdHcbgLNQYC2mnwULver3HXSySEEE3UtWMg/XqEseHbU21u2pdKvdElbzUGKSxCCDeXOrwr+joTW/cXOzuKQ1XqDS55RxhIYRFCuLnoTkH06hLC+t0nMZrMzo7jMBf0rjmdC0hhEUK0AhNv7UpVjZGtB9pGq8ViUaiqdc3pXEAKixCiFYiJCqZXlxA+3HyUTXtP09oXxq2qNaIorvkMCziosGRlZZGYmEhsbCwFBQVX3W/dunWkpaWRmppKWloa5eXll20/duwY/fv3Jysry96RhRBuRKVS8cDkvvTrEcbyLwtY9nkepgaLs2PZjXU6Fxd8hgXA0xEXSUpKYubMmWRkZFx1n9zcXBYtWsT777+PVquluroajeZ/1dhsNvPMM88wZswYR0QWQrgZX29PHpjSl1VfHWftNycoqajlmcxhzo5lF5U/PhzZplss8fHxREREXHOfZcuWMWfOHLRaLQABAQF4e/+vGr/99tvcdtttdO3a1Z5RhRBuTK1SMTmhO/Mm9eHkmWqeWvI1VTVGZ8eyuQs1rjsBJTioxdIUhYWFREZGkpGRQW1tLWPHjmXevHmoVCry8vLIzs7mgw8+4I033mjxNcLC/G2Y+EpabYBdz28vktuxJLf9TdAGEBURxLP/byd//eggf/zVrQQHuGa3UWOu91mbfhxCiu4ahpenhwMSNY/LFBaz2Ux+fj5Lly7FaDQyd+5cdDodKSkp/OEPf+DPf/4zHh439gFWVOjtNtW2VhtAWVm1Xc5tT5LbsSS343QM8ubZubfw7Ds7eGLRVzz+i4EEuugDhT/VlM+6+Ew17Xw8qTxfa9csarWqRV/IXaaw6HQ6kpOT0Wg0aDQakpKSyMnJYejQoZw8eZL77rsPgKqqKhRFQa/X88ILLzg5tRDClfWNbs//3dmfv390kJf+vZ/fZQzC39f15tZqrkq9gWAXvdUYXOh249TUVLKzs1EUBZPJxM6dO4mLi0On07Fr1y42b97M5s2bmTVrFnfddZcUFSFEk8R1CeHhO/tz5nwdr63IaRUPUV6oMbrs+Ao4qLAsXLiQhIQESktLmT17NikpKQBkZmaSm5sLQEpKCmFhYUyYMIFJkyYRHR3N1KlTHRFPCNHK9eoSwn1pN1F4+gJvrzns9qtPXtAbXPZWYwCV0tqfJPoJGWO5kuR2LMntWD/P/eWeU/x74xFGD+rE9LExqFQqJ6Zr3PU+a0VRuP/lrYyNj+LO0dF2zeL2YyxCCGFvY+OjOF9tYP2uk4QH+zJ+aGdnR2q2YyVVNJgVGWMRQghXMfW2HgyIbs+q7ONut6zxD6XV/P3Dg4QF+hAfF+7sOFclhUUI0aaoVSomj+qOwWhm0173WSDs5JlqXv7Pfnw0Hsz/5UBCXPi5HCksQog2J1Lrz8Ce7dm45xR1BtdfIOz0WT0v/+cAGi8PHv/lILTBvs6OdE1SWIQQbVLq8K7U1Dew9UCRs6NcU4PZwuKVuXh5qvndLwcS7uJFBaSwCCHaqG4RgfTuGsIXu0+59LMt2TklnDlfx4zxsYSH+Dk7TpNIYRFCtFmpwy8uEPZVTomzozTKYDKz+uvjREcG0b9HmLPjNJkUFiFEmxUTFUx0ZBDrd/1Ag9n11m/ZtPc0F/RGpo7q4ZLP3FyNFBYhRJulUqlIHdaViioD33xX6uw4l6mpN7Fuxw/06xFGTFSws+M0ixQWIUSb1rd7KN11gXz69XFMDa4z1vL5zpPUGRqYMqqHs6M0mxQWIUSbplKpmJLQnXNVBrbsL3Z2HADOVxvYuOcUN/fuQFS4fdeRsgcpLEKINq9X11B6dQnhsx0nrvlci9liIf/kebu3bNZ8cwKzRWHSyO52vY69SGERQghgyqgeVNea+HLPqSu2GU1mtuwv4sm3d5L1r/28+9n32Gv+3uIyPdsPFDNqgM4tnllpjExCKYQQQHddIINitHyx+ySJgyLx9/WiqsbItgNFbNp7mqpaE90iAonrHMJXOSVEdwpiTHyUzXP84/Pv8fJUk3ZrN5uf21GksAghxI/uGNmN/QVl/HtjAaDi27wzNJgV+nQLZcItXYjtHIwCVNea+O/mo3SLCKRHpyCbXf9EaRXZB4tJHd6VIDdYRvlqpCtMCCF+1Enrz7A+Hdlx6Az7jpSR0F/HHzNv5tFpA4jrEoJKpUKtUnFvai9CArx5c/V3VNcabXb9FVsLCfDTcPvN7jed/09Ji0UIIX7iF2N60rtbKAOi2+Pr3fivyHY+Xvz6jj786R97eXPVd0xL7EnnDv7Whxhr6xv4+rsS9heU0a9He8YOicRDfe3v8YdPnOPQifPcO7HPVa/rLhySPisriy+++IKioiLWrFlDTExMo/utW7eON998E0VRUKlULF26lPbt27N48WLWrVuHh4cHnp6ePPLII4wcOdIR0YUQbUw7Hy+G9e543f26dgxk5vg43l+fx3PLviU8xJchceHU1JnYcegMBpOZsEAfPtxylJ2HS5mVHEe3iMBGz1VvbODjrYWEBnozYXhXLlTW2vptOZRDCktSUhIzZ84kIyPjqvvk5uayaNEi3n//fbRaLdXV1Wg0F/sY+/Xrx5w5c/D19SUvL4/p06eTnZ2Nj4+PI+ILIUSjRvSLYEDP9uwrKOPb78/w+c6TeHiouLlXBxIHd6JLhwD25pexfGMBCz/Yw+iBnUjoryMq/GLrRlEUdn1/ho+2FHK+2sB9E29C4+Xh7Ld1wxxSWOLj46+7z7Jly5gzZw5arRaAgIAA67aftk5iY2NRFIXKyko6drz+twohhLAnf18vEvrrSOivQ19nQq1S4efzv1+t8XHh3NQ1lBXbCtmyv4jN+4rQBvswODacY0UXKDh9gS4dApiX3ofoSNvdCOBMLtORV1hYSGRkJBkZGdTW1jJ27FjmzZt3xcRrq1atonPnzlJUhBAux9/Xq9HX/Xw8mTE+lvSR3ThwpJw9eWf58ttT+Hp7Mis5lpH9dKjV7jPJ5PW4TGExm83k5+ezdOlSjEYjc+fORafTMWnSJOs+u3fv5tVXX+W9995r0TXCwuw7NYJWG3D9nVyQ5HYsye1YrpRbC/ToEsaUMbHU1pvw8FDj3UjXlytlbgmXKSw6nY7k5GQ0Gg0ajYakpCRycnKshWX//v08/vjjvPHGG3Tv3rJpDioq9Fgs9nlaVqsNoKys2i7ntifJ7ViS27HcMbcrZVarVS36Qu4yz7GkpqaSnZ2NoiiYTCZ27txJXFwcADk5OTzyyCO89tpr9O7d28lJhRBCXItDCsvChQtJSEigtLSU2bNnk5KSAkBmZia5ubkApKSkEBYWxoQJE5g0aRLR0dFMnToVgOeee476+nqefvpp0tPTSU9PJz8/3xHRhRBCNJNKsddMai5IusKuJLkdS3I7ljvmdqXMbt8VJoQQonWQwiKEEMKmpLAIIYSwKZe53dgR7P0Akrs+4CS5HUtyO5Y75naVzC3N0aYG74UQQtifdIUJIYSwKSksQgghbEoKixBCCJuSwiKEEMKmpLAIIYSwKSksQgghbEoKixBCCJuSwiKEEMKmpLAIIYSwKSksP5OVlUViYiKxsbEUFBS06BwHDhxg4sSJjB8/njlz5lBRUWHdVllZyaOPPsr48eNJSUlh0aJFbpE7NjaWtLQ0m66HY+/MlyxYsIDY2FhqampuNDJg39wWi4Vp06YxceJEJk6cyL333svp06ddPvfx48eZMWMGycnJpKamsmDBAurr610+N8Bvf/tbRowYYZO/I7bI2pjjx48zbdo0xo8fz7Rp0zhx4kSTtjmNIi7z7bffKsXFxcro0aOV/Pz8Zh9vsViUMWPGKN9++62iKIqyePFi5YknnrBuv//++5WlS5dafy4rK7vhzIpi/9wxMTGKXq+3SdZL7J1ZURRl06ZNyoIFC2ya3965q6qqrH9etmyZ8pvf/ObGQyv2zX3q1Cnl0KFDiqIoitlsVh5++GFl0aJFLp9bURTlm2++UcrLy23yd+RGs44ePbrR12fMmKGsWrVKURRFWbVqlTJjxowmbXMWabH8THx8PBEREVe8fvDgQWbMmMHkyZOZPHkyW7dubfT43NxcvL29iY+PB+Duu+9m/fr1AJw4cYKCggJmzZpl3b99+/Yun9te7J35/PnzLFq0iAULFrhV7oCAAOuf9Xo9arVt/pnaM3dkZCQ33XQTAGq1mn79+lFcXOzyuQGGDRtGWFiYS2RtTEVFBYcPHyY1NRW4uIz74cOHOXfu3DW3OVObmt24paqqqnjmmWd4++23CQ8P5+zZs0ydOpW1a9cSGBh42b4lJSXodDrrz6GhoVgsFiorKzl69CgdOnTgqaee4vvvv6d9+/bMnz+fnj17unTu4OBgAGbMmIHZbCYhIYEHH3wQjUbj0pmff/55Hnzwwct+UduLrT/rzMxMDh8+TEhICO+++67b5Aaor69nxYoVPProo26V2xWyNqakpIQOHTrg4eEBgIeHB+Hh4ZSUlKAoylW3hYaG2vV9XYsUlibYv38/p0+fJjMz0/qaSqXihx9+oG/fvk0+j9ls5uDBg/z2t78lPj6eDRs2MG/ePDZu3GiP2DbLDbB161YiIiLQ6/U8/vjjLF68mEceecTWkW2W+fPPP8fLy4vRo0fbPGNjbPlZA7zzzjtYLBbeeust3nzzTZ599lkbpv0fW+duaGjgkUce4ZZbbiEpKcmWUS9j69z2dL2skydPxmw2A3D27FnS09MBiIiIYMmSJU7JfKOksDSBoijExsayfPnyK7a9+eab1mb1ggULiIiIuKwL4Ny5c6hUKoKDg9HpdERERFib5OPGjePxxx/n3Llzdvl2YavcgLV57+/vz5133snSpUttnteWmXft2sXOnTtJTEy0bk9NTeWdd94hOjraZXP/lFqtZurUqYwbN85uhcWWuc1mM4899hhBQUH8/ve/t0tee+S2t2tlBfjkk0+sf05MTGT16tWXbY+IiODMmTOYzWY8PDwwm82cPXuWiIgIFEW56janctrojov76eBbZWWlcuuttyo7duywbj948KBisViuOM5sNitJSUmNDhRaLBYlNTVVKSgoUBRFUXbv3q2MHDmy0fO4Uu7Kykqlrq5OURRFMZlMyvz585U//vGPLp355+xx84E9cldUVCjnzp2z7vvBBx8o06ZNc/ncZrNZeeyxx5RHH31UaWhosGlee+b+KVv+HWlp1qsN3k+fPv2yAfrp06c3aZuzyEJfP7Nw4UI2bNhAeXk5ISEhBAcH89lnn5GTk8NLL73EhQsXMJlMREVFsWTJkkYHVvft28czzzyDwWCgU6dOvPTSS9ZB+tzcXJ577jmMRiO+vr489dRT9OvXz6Vz79+/n6effhqVSkVDQwMDBw7kySefpF27di6b+ediY2PZt2/fDWe2d+78/HwWLFiAyWQCoFOnTjz11FNERUW5dO6tW7dy//33ExMTYz1u0KBBPPPMMy6dG+CBBx4gJyeHM2fOEB4eTkxMTIvHtW40a2JiIps3b77ivIWFhTzxxBNUVVURGBhIVlYW3bt3v+42Z5HCIoQQwqbkdmMhhBA2JYVFCCGETUlhEUIIYVNSWIQQQtiUFBYhhBA2JYVFCAeYO3cuK1eudHYMIRxCbjcWrVpiYiILFy5k+PDhzo5iF7t27WLWrFn4+voCEB4ezn333ceUKVOadPzrr7/ODz/8wMsvv2zPmKKNkSldhLhBDQ0NeHo6759SeHg427dvR1EUtm/fzrx58xg4cKDTH5ITbZd0hYk2a8uWLaSnpxMfH8/dd99NXl6eddvbb7/NmDFjGDhwIBMmTODLL7+0bvvkk0+4++67+dOf/sTQoUN5/fXX+eSTT/jFL35BVlYWQ4YMITExkW3btlmPmTFjBh999JH1+Gvte+rUKTIyMhg4cCD33HMPzz33HI899th1349KpWLUqFEEBQVdthDbwoULGTVqFIMGDWLy5Mns2bMHgO3bt/PWW2/x+eefM3DgQCZOnAhAdXU1Tz75JCNGjGDkyJH87W9/s06SKERTSGERbdKhQ4d48sknef7559m1axfTpk3j17/+NUajEYCoqCiWL1/O3r17eeCBB3j88cc5e/as9ficnByioqL45ptvmDdvnvW1bt26sXPnTubOnctTTz3F1Xqar7XvY489Rr9+/di1axcPPPDAFZMSXo3FYmHTpk2cP3+eLl26WF/v27cvq1atYvfu3aSmpvLwww9jMBhISEjg/vvv5/bbb2f//v18+umnAPzud7/D09OTDRs2sGrVKr7++mtrURSiKaSwiDbpww8/ZNq0afTv3x8PDw/uuOMOvLy8OHDgAAC33347HTp0QK1WM2HCBLp06UJOTo71+PDwcGbMmIGnpyc+Pj4A6HQ67rrrLuv5ysrKKC8vb/T6V9u3uLiY3NxcHnroITQaDfHx8ZfN0NyYs2fPEh8fT79+/XjggQd44oknrItuAaSnpxMSEoKnpydz5szBaDRy/PjxRs9VXl7O9u3befLJJ/Hz8yMsLIx77rmHzz77rFmfr2jbZIxFtEnFxcWsWrWKf/7zn9bXTCaTtVWyatUqli5dSlFREQC1tbWcP3/eum/Hjh2vOOdPJ7+8NJheW1vb6PWvtu/58+cJCgqyvgYXp00vKSm56nu5NMZiNBp5+eWX2blzJ/fcc491+3vvvcdHH33E2bNnUalU6PX6y97LTxUXF9PQ0MCIESOsr1ksFudPwy7cihQW0SZFRETwq1/9ytqN9VNFRUX8/ve/Z9myZQwcOBAPDw/r4kuXqFQqu+TSarVcuHCBuro6a3G5VlH5KY1Gw2OPPUZycjIbN25kzJgx7Nmzh3feeYdly5bRs2dP1Go1Q4YMsXa7/fx9dOzYEY1Gw86dO516Q4Jwb9IVJlo9k8mEwWCw/tfQ0MCdd97Jf/7zHw4ePIiiKNTW1rJ161b0ej11dXWoVCrr4msrVqzgyJEjDsnaqVMn+vTpw+uvv47RaGT//v1s2bKlycdrNBrmzJnD4sWLAaipqcHDw4PQ0FAaGhpYtGgRer3eun9YWBhFRUVYLBbgYuvn1ltv5S9/+Qt6vR6LxcLJkyfZvXu3bd+oaNWksIhW77777qNfv37W/15//XX69u3LCy+8wPPPP8+QIUMYN26cdSW/6Oho5syZw913383w4cMpKChg0KBBDsv78ssvc+DAAW6++Wb+/ve/M2HCBDQaTZOPnzJlCsXFxWzevJkRI0aQkJDA+PHjSUxMxNvb+7JureTkZABuvvlm7rjjDgBefPFFTCYTEyZMYMiQITz00EOUlZXZ9k2KVk0ekBTCxf3f//0f3bt356GHHnJ2FCGaRFosQriYnJwcTp48icViYfv27WzatIkxY8Y4O5YQTSajc0K4mPLych588EEqKyvp2LEjzz777GW3Dwvh6qQrTAghhE1JV5gQQgibksIihBDCpqSwCCGEsCkpLEIIIWxKCosQQgibksIihBDCpv4/bpbE3C1eenIAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn.recorder.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>1.692085</td>\n",
+       "      <td>1.568736</td>\n",
+       "      <td>0.262500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.678345</td>\n",
+       "      <td>1.565937</td>\n",
+       "      <td>0.262500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.653293</td>\n",
+       "      <td>1.565222</td>\n",
+       "      <td>0.262500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.623039</td>\n",
+       "      <td>1.574800</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>1.592699</td>\n",
+       "      <td>1.607689</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>1.562963</td>\n",
+       "      <td>1.645548</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>1.536528</td>\n",
+       "      <td>1.654057</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>1.511987</td>\n",
+       "      <td>1.677109</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>1.494778</td>\n",
+       "      <td>1.736768</td>\n",
+       "      <td>0.237500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>1.481087</td>\n",
+       "      <td>1.711942</td>\n",
+       "      <td>0.262500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>1.468670</td>\n",
+       "      <td>1.715516</td>\n",
+       "      <td>0.262500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>11</td>\n",
+       "      <td>1.456905</td>\n",
+       "      <td>1.733213</td>\n",
+       "      <td>0.262500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>12</td>\n",
+       "      <td>1.447268</td>\n",
+       "      <td>1.739656</td>\n",
+       "      <td>0.262500</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>13</td>\n",
+       "      <td>1.439297</td>\n",
+       "      <td>1.713681</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>14</td>\n",
+       "      <td>1.433239</td>\n",
+       "      <td>1.731828</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>15</td>\n",
+       "      <td>1.424000</td>\n",
+       "      <td>1.749282</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>16</td>\n",
+       "      <td>1.418525</td>\n",
+       "      <td>1.750285</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>17</td>\n",
+       "      <td>1.414353</td>\n",
+       "      <td>1.748751</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>18</td>\n",
+       "      <td>1.409602</td>\n",
+       "      <td>1.748361</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn.fit_one_cycle(19, 1e-2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "max(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "run_control": {
+     "marked": false
+    },
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Creating Learner\n",
+      "SequentialEx(\n",
+      "  (layers): ModuleList(\n",
+      "    (0): Linear(in_features=100, out_features=100, bias=True)\n",
+      "    (1): ReLU6()\n",
+      "    (2): Linear(in_features=100, out_features=100, bias=True)\n",
+      "    (3): ReLU6()\n",
+      "    (4): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (5): Linear(in_features=100, out_features=21, bias=True)\n",
+      "    (6): ReLU6()\n",
+      "    (7): BatchNorm1d(21, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (8): Dropout(p=0.5)\n",
+      "    (9): Linear(in_features=21, out_features=5, bias=True)\n",
+      "  )\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Creating Learner\")\n",
+    "layers=[\n",
+    "        nn.Linear(bunch.train_dl.x.c,100),nn.ReLU6(),\n",
+    "        nn.Linear(100,100),nn.ReLU6(),\n",
+    "        nn.BatchNorm1d(100),\n",
+    "        nn.Linear(100,21),nn.ReLU6(),\n",
+    "        nn.BatchNorm1d(21),\n",
+    "        nn.Dropout(0.5),\n",
+    "        nn.Linear(21,bunch.train_dl.y.c)]\n",
+    "bac_classifier = SequentialEx(*layers)\n",
+    "print(bac_classifier)\n",
+    "learn = Learner(bunch, bac_classifier, metrics=[accuracy])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bunch.train_dl.y.c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "run_control": {
+     "marked": false
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn.lr_find();learn.recorder.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>1.680021</td>\n",
+       "      <td>1.568475</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.644321</td>\n",
+       "      <td>1.557220</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.615756</td>\n",
+       "      <td>1.543324</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.585456</td>\n",
+       "      <td>1.537052</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>1.564552</td>\n",
+       "      <td>1.532194</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>1.538424</td>\n",
+       "      <td>1.551517</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>1.526740</td>\n",
+       "      <td>1.541531</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>1.512003</td>\n",
+       "      <td>1.538530</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>1.498191</td>\n",
+       "      <td>1.544300</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>1.487355</td>\n",
+       "      <td>1.560631</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print (\"Training\")\n",
+    "learn.fit_one_cycle(10,5e-3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b=bunch.one_batch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['__class__',\n",
+       " '__delattr__',\n",
+       " '__dict__',\n",
+       " '__dir__',\n",
+       " '__doc__',\n",
+       " '__eq__',\n",
+       " '__format__',\n",
+       " '__ge__',\n",
+       " '__getattribute__',\n",
+       " '__getitem__',\n",
+       " '__gt__',\n",
+       " '__hash__',\n",
+       " '__init__',\n",
+       " '__init_subclass__',\n",
+       " '__le__',\n",
+       " '__len__',\n",
+       " '__lt__',\n",
+       " '__module__',\n",
+       " '__ne__',\n",
+       " '__new__',\n",
+       " '__post_init__',\n",
+       " '__reduce__',\n",
+       " '__reduce_ex__',\n",
+       " '__repr__',\n",
+       " '__setattr__',\n",
+       " '__sizeof__',\n",
+       " '__str__',\n",
+       " '__subclasshook__',\n",
+       " '__weakref__',\n",
+       " '_bunch',\n",
+       " '_get_by_folder',\n",
+       " '_label_cls',\n",
+       " '_label_from_list',\n",
+       " '_label_list',\n",
+       " '_processor',\n",
+       " '_relative_item_path',\n",
+       " '_relative_item_paths',\n",
+       " '_split',\n",
+       " '_square_show',\n",
+       " '_square_show_res',\n",
+       " 'add',\n",
+       " 'analyze_pred',\n",
+       " 'c',\n",
+       " 'c2i',\n",
+       " 'classes',\n",
+       " 'copy_new',\n",
+       " 'databunch',\n",
+       " 'filter_by_folder',\n",
+       " 'filter_by_func',\n",
+       " 'filter_by_rand',\n",
+       " 'filter_missing_y',\n",
+       " 'from_csv',\n",
+       " 'from_df',\n",
+       " 'from_folder',\n",
+       " 'get',\n",
+       " 'get_label_cls',\n",
+       " 'ignore_empty',\n",
+       " 'inner_df',\n",
+       " 'items',\n",
+       " 'label_cls',\n",
+       " 'label_const',\n",
+       " 'label_empty',\n",
+       " 'label_from_df',\n",
+       " 'label_from_folder',\n",
+       " 'label_from_func',\n",
+       " 'label_from_re',\n",
+       " 'loss_func',\n",
+       " 'new',\n",
+       " 'no_split',\n",
+       " 'num_parts',\n",
+       " 'path',\n",
+       " 'process',\n",
+       " 'process_one',\n",
+       " 'processor',\n",
+       " 'random_split_by_pct',\n",
+       " 'reconstruct',\n",
+       " 'split_by_files',\n",
+       " 'split_by_fname_file',\n",
+       " 'split_by_folder',\n",
+       " 'split_by_idx',\n",
+       " 'split_by_idxs',\n",
+       " 'split_by_list',\n",
+       " 'split_by_rand_pct',\n",
+       " 'split_by_valid_func',\n",
+       " 'split_from_df',\n",
+       " 'split_none',\n",
+       " 'split_subsets',\n",
+       " 'to_text',\n",
+       " 'use_partial_data',\n",
+       " 'x']"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dir(bunch.train_dl.y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'Bacillus anthracis': 0,\n",
+       " 'Bacillus subtilis': 1,\n",
+       " 'Bacillus cereus': 2,\n",
+       " 'Bacillus velezensis': 3,\n",
+       " 'Bacillus thuringiensis': 4}"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bunch.train_dl.y.c2i"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>1.517771</td>\n",
+       "      <td>1.536819</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.518076</td>\n",
+       "      <td>1.537140</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.521607</td>\n",
+       "      <td>1.564627</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.569962</td>\n",
+       "      <td>3.361804</td>\n",
+       "      <td>0.185567</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>1.631927</td>\n",
+       "      <td>1.762733</td>\n",
+       "      <td>0.365979</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>1.666953</td>\n",
+       "      <td>218.889984</td>\n",
+       "      <td>0.185567</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>1.675805</td>\n",
+       "      <td>130.557251</td>\n",
+       "      <td>0.185567</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>1.667572</td>\n",
+       "      <td>101.857735</td>\n",
+       "      <td>0.185567</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>1.649913</td>\n",
+       "      <td>50.720848</td>\n",
+       "      <td>0.185567</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>1.623518</td>\n",
+       "      <td>21.495054</td>\n",
+       "      <td>0.185567</td>\n",
+       "      <td>00:00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print (\"Training\")\n",
+    "learn.fit_one_cycle(10,5e-1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn.recorder.plot_metrics()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[tensor(0.1546)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)],\n",
+       " [tensor(0.3660)]]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "learn.recorder.metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Category 3"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "learn.predict(10)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 176,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor(2)"
+      ]
+     },
+     "execution_count": 176,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "i"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 184,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "../exp/nb_BacteriaClassifier.py\r\n",
+      "Converted BacteriaClassifier.ipynb to ../exp/nb_BacteriaClassifier.py\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!python notebook2script.py BacteriaClassifier.ipynb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
+     ]
+    }
+   ],
+   "source": [
+    "learn.lr_find()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn.recorder.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "> \u001b[0;32m/home/serge/anaconda3/envs/bio-2/lib/python3.6/site-packages/torch/utils/data/dataloader.py\u001b[0m(608)\u001b[0;36m_process_next_batch\u001b[0;34m()\u001b[0m\n",
+      "\u001b[0;32m    606 \u001b[0;31m                \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"KeyError:\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexc_msg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0m\u001b[0;32m    607 \u001b[0;31m            \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0m\u001b[0;32m--> 608 \u001b[0;31m                \u001b[0;32mraise\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexc_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexc_msg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0m\u001b[0;32m    609 \u001b[0;31m        \u001b[0;32mreturn\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0m\u001b[0;32m    610 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0m\n",
+      "ipdb> batch\n",
+      "<torch.utils.data._utils.ExceptionWrapper object at 0x7ff4d40b8b38>\n"
+     ]
+    }
+   ],
+   "source": [
+    "%debug"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1686"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(data.items)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "###  Genome vectors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Genome Inventory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 156,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inv=pd.read_pickle('/home/serge/database/data/genomes/ncbi-genomes-2019-04-07/inventory/sequences_by_label.pkl').reset_index()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 157,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>label</th>\n",
+       "      <th>seq_count</th>\n",
+       "      <th>id</th>\n",
+       "      <th>lengths</th>\n",
+       "      <th>min</th>\n",
+       "      <th>max</th>\n",
+       "      <th>median</th>\n",
+       "      <th>files</th>\n",
+       "      <th>file_count</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>'Catharanthus roseus'</td>\n",
+       "      <td>1</td>\n",
+       "      <td>[NZ_CP035949.1]</td>\n",
+       "      <td>[600116]</td>\n",
+       "      <td>600116</td>\n",
+       "      <td>600116</td>\n",
+       "      <td>600116.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>'Deinococcus soli'</td>\n",
+       "      <td>1</td>\n",
+       "      <td>[NZ_CP011389.1]</td>\n",
+       "      <td>[3236984]</td>\n",
+       "      <td>3236984</td>\n",
+       "      <td>3236984</td>\n",
+       "      <td>3236984.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>'Nostoc azollae'</td>\n",
+       "      <td>1</td>\n",
+       "      <td>[NC_014248.1]</td>\n",
+       "      <td>[5354700]</td>\n",
+       "      <td>5354700</td>\n",
+       "      <td>5354700</td>\n",
+       "      <td>5354700.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>18,711,729 reads</td>\n",
+       "      <td>1</td>\n",
+       "      <td>[NZ_CP033612.1]</td>\n",
+       "      <td>[2899315]</td>\n",
+       "      <td>2899315</td>\n",
+       "      <td>2899315</td>\n",
+       "      <td>2899315.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Acaryochloris marina</td>\n",
+       "      <td>1</td>\n",
+       "      <td>[NC_009925.1]</td>\n",
+       "      <td>[6503724]</td>\n",
+       "      <td>6503724</td>\n",
+       "      <td>6503724</td>\n",
+       "      <td>6503724.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   label  seq_count               id    lengths      min  \\\n",
+       "0  'Catharanthus roseus'          1  [NZ_CP035949.1]   [600116]   600116   \n",
+       "1     'Deinococcus soli'          1  [NZ_CP011389.1]  [3236984]  3236984   \n",
+       "2       'Nostoc azollae'          1    [NC_014248.1]  [5354700]  5354700   \n",
+       "3       18,711,729 reads          1  [NZ_CP033612.1]  [2899315]  2899315   \n",
+       "4   Acaryochloris marina          1    [NC_009925.1]  [6503724]  6503724   \n",
+       "\n",
+       "       max     median                                              files  \\\n",
+       "0   600116   600116.0  [/home/serge/database/data/genomes/ncbi-genome...   \n",
+       "1  3236984  3236984.0  [/home/serge/database/data/genomes/ncbi-genome...   \n",
+       "2  5354700  5354700.0  [/home/serge/database/data/genomes/ncbi-genome...   \n",
+       "3  2899315  2899315.0  [/home/serge/database/data/genomes/ncbi-genome...   \n",
+       "4  6503724  6503724.0  [/home/serge/database/data/genomes/ncbi-genome...   \n",
+       "\n",
+       "   file_count  \n",
+       "0           1  \n",
+       "1           1  \n",
+       "2           1  \n",
+       "3           1  \n",
+       "4           1  "
+      ]
+     },
+     "execution_count": 157,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inv.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 161,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def filter_by_count(df:pd.DataFrame, min=1)->pd.DataFrame:\n",
+    "    res=df.copy()\n",
+    "    drop = res.index[res.index.values[np.asarray(res.seq_count.values) < min]]\n",
+    "    res.drop(drop, axis=0,inplace=True)\n",
+    "    return res.reset_index(drop=True)\n",
+    "\n",
+    "\n",
+    "def filter_by_label(df:pd.DataFrame, word:str)->pd.DataFrame:\n",
+    "    res,mask=df.copy(),[]\n",
+    "    for x in df.label.values: mask.append(False if word in x else True)\n",
+    "    drop = res.index[mask]\n",
+    "    res.drop(drop, axis=0,inplace=True)\n",
+    "    return res.reset_index(drop=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 172,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "short_list = filter_by_count(filter_by_label(inv,\"Bacillus \"), 40)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 173,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>label</th>\n",
+       "      <th>seq_count</th>\n",
+       "      <th>id</th>\n",
+       "      <th>lengths</th>\n",
+       "      <th>min</th>\n",
+       "      <th>max</th>\n",
+       "      <th>median</th>\n",
+       "      <th>files</th>\n",
+       "      <th>file_count</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Bacillus anthracis</td>\n",
+       "      <td>51</td>\n",
+       "      <td>[NZ_CP018903.1, NZ_AP018443.1, NZ_CP009325.1, ...</td>\n",
+       "      <td>[5227565, 5219278, 5221627, 5210966, 5231857, ...</td>\n",
+       "      <td>5200082</td>\n",
+       "      <td>5321900</td>\n",
+       "      <td>5227565.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>51</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Bacillus cereus</td>\n",
+       "      <td>49</td>\n",
+       "      <td>[NZ_CP009605.1, NZ_CP015589.1, NZ_CP016595.1, ...</td>\n",
+       "      <td>[5271178, 5160326, 5329684, 5498820, 5417196, ...</td>\n",
+       "      <td>5083176</td>\n",
+       "      <td>5561815</td>\n",
+       "      <td>5329684.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>49</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Bacillus subtilis</td>\n",
+       "      <td>107</td>\n",
+       "      <td>[NZ_CP021507.1, NZ_CP021498.1, NZ_CP021499.1, ...</td>\n",
+       "      <td>[4190134, 3988602, 3988649, 4293706, 4184648, ...</td>\n",
+       "      <td>3876276</td>\n",
+       "      <td>4350498</td>\n",
+       "      <td>4122154.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>107</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Bacillus thuringiensis</td>\n",
+       "      <td>44</td>\n",
+       "      <td>[NZ_CP013055.1, NC_018693.1, NZ_CP009351.1, NC...</td>\n",
+       "      <td>[5674369, 5414494, 5491311, 5486830, 5330088, ...</td>\n",
+       "      <td>5213295</td>\n",
+       "      <td>6002284</td>\n",
+       "      <td>5491623.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>44</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Bacillus velezensis</td>\n",
+       "      <td>72</td>\n",
+       "      <td>[NZ_CP017747.1, NZ_CP030150.1, NZ_CP023075.1, ...</td>\n",
+       "      <td>[3884433, 4258978, 4047350, 4226250, 4090582, ...</td>\n",
+       "      <td>3713516</td>\n",
+       "      <td>4326822</td>\n",
+       "      <td>3999832.0</td>\n",
+       "      <td>[/home/serge/database/data/genomes/ncbi-genome...</td>\n",
+       "      <td>72</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                    label  seq_count  \\\n",
+       "0      Bacillus anthracis         51   \n",
+       "1         Bacillus cereus         49   \n",
+       "2       Bacillus subtilis        107   \n",
+       "3  Bacillus thuringiensis         44   \n",
+       "4     Bacillus velezensis         72   \n",
+       "\n",
+       "                                                  id  \\\n",
+       "0  [NZ_CP018903.1, NZ_AP018443.1, NZ_CP009325.1, ...   \n",
+       "1  [NZ_CP009605.1, NZ_CP015589.1, NZ_CP016595.1, ...   \n",
+       "2  [NZ_CP021507.1, NZ_CP021498.1, NZ_CP021499.1, ...   \n",
+       "3  [NZ_CP013055.1, NC_018693.1, NZ_CP009351.1, NC...   \n",
+       "4  [NZ_CP017747.1, NZ_CP030150.1, NZ_CP023075.1, ...   \n",
+       "\n",
+       "                                             lengths      min      max  \\\n",
+       "0  [5227565, 5219278, 5221627, 5210966, 5231857, ...  5200082  5321900   \n",
+       "1  [5271178, 5160326, 5329684, 5498820, 5417196, ...  5083176  5561815   \n",
+       "2  [4190134, 3988602, 3988649, 4293706, 4184648, ...  3876276  4350498   \n",
+       "3  [5674369, 5414494, 5491311, 5486830, 5330088, ...  5213295  6002284   \n",
+       "4  [3884433, 4258978, 4047350, 4226250, 4090582, ...  3713516  4326822   \n",
+       "\n",
+       "      median                                              files  file_count  \n",
+       "0  5227565.0  [/home/serge/database/data/genomes/ncbi-genome...          51  \n",
+       "1  5329684.0  [/home/serge/database/data/genomes/ncbi-genome...          49  \n",
+       "2  4122154.0  [/home/serge/database/data/genomes/ncbi-genome...         107  \n",
+       "3  5491623.0  [/home/serge/database/data/genomes/ncbi-genome...          44  \n",
+       "4  3999832.0  [/home/serge/database/data/genomes/ncbi-genome...          72  "
+      ]
+     },
+     "execution_count": 173,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "short_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 171,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import os\n",
+    "from shutil import copy\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "out=Path('/home/serge/database/data/genomes/ncbi-genomes-2019-04-07')\n",
+    "folders ={\n",
+    "    'train': out / \"Bacillus\" / \"train\",\n",
+    "    'valid': out / \"Bacillus\" /\"valid\",\n",
+    "    'test' :  out / \"Bacillus\" /\"test\"\n",
+    "}\n",
+    "for k in folders:\n",
+    "    if not os.path.exists(folders[k]):\n",
+    "        os.makedirs(folders[k])\n",
+    "\n",
+    "\n",
+    "for i in tqdm(range(short_list.shape[0])):\n",
+    "    cnt = short_list.loc[i,\"seq_count\"]\n",
+    "    train = int(0.75 * cnt)\n",
+    "    valid = cnt - train\n",
+    "    files = short_list.loc[i, \"files\"]\n",
+    "    for i in range(cnt):\n",
+    "        copy(files[i], folders[\"train\"]) if i < train else copy(files[i], folders[\"valid\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for k,v in folders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 128,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res=inv.copy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "drop = res.index[res.index.values[np.asarray(res.seq_count.values) < 10]] "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Int64Index([ 1,  3,  4, 13, 15, 16, 19, 20, 21, 23, 25, 26, 27, 28, 30, 31, 32,\n",
+       "            34, 35, 39, 40, 41, 42, 43, 46, 47, 50, 52, 54, 57, 59, 60, 61, 62,\n",
+       "            63, 64, 65, 66, 68, 69, 70, 74, 78, 80, 82, 85, 88],\n",
+       "           dtype='int64')"
+      ]
+     },
+     "execution_count": 135,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "drop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 133,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ True, False,  True,  True, ...,  True,  True,  True,  True])"
+      ]
+     },
+     "execution_count": 133,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res.seq_count.values > 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def filter_by_length(inv, percentiles=[50.,100.]):\n",
+    "    p = np.percentiles()\n",
+    "    for "
+   ]
+  }
+ ],
+ "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.8"
+  },
+  "varInspector": {
+   "cols": {
+    "lenName": 16,
+    "lenType": 16,
+    "lenVar": 40
+   },
+   "kernels_config": {
+    "python": {
+     "delete_cmd_postfix": "",
+     "delete_cmd_prefix": "del ",
+     "library": "var_list.py",
+     "varRefreshCmd": "print(var_dic_list())"
+    },
+    "r": {
+     "delete_cmd_postfix": ") ",
+     "delete_cmd_prefix": "rm(",
+     "library": "var_list.r",
+     "varRefreshCmd": "cat(var_dic_list()) "
+    }
+   },
+   "types_to_exclude": [
+    "module",
+    "function",
+    "builtin_function_or_method",
+    "instance",
+    "_Feature"
+   ],
+   "window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}