SO Model with kMers.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9c1d77e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-08-24 10:18:45.820106: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-08-24 10:18:46.312780: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num GPUs Available:  1\n",
      "/mnt/e/ML/cafa-5-protein-function-prediction\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-08-24 10:18:47.101557: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:18:47.122385: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:18:47.122712: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from dotenv import load_dotenv\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "import datetime\n",
    "\n",
    "physical_devices = tf.config.list_physical_devices('GPU')\n",
    "print(\"Num GPUs Available: \", len(physical_devices))\n",
    "# try:\n",
    "#   tf.config.experimental.set_memory_growth(physical_devices[0], True)\n",
    "# except:\n",
    "#   # Invalid device or cannot modify virtual devices once initialized.\n",
    "#   pass\n",
    "\n",
    "load_dotenv(override=True)\n",
    "\n",
    "DATA_PATH = os.getenv('DATA_PATH')\n",
    "print(DATA_PATH)\n",
    "\n",
    "# Choose subontology (CCO, MFO or BPO)\n",
    "SO = 'MFO'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e3544f8a",
   "metadata": {},
   "source": [
    "## Reading fasta, obo and tsv files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c8b515f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "\n",
    "sequences = [rec.seq for rec in SeqIO.parse(os.path.join(DATA_PATH, \"Train/train_sequences.fasta\"),\"fasta\")]\n",
    "ids = [rec.id for rec in SeqIO.parse(os.path.join(DATA_PATH, \"Train/train_sequences.fasta\"),\"fasta\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2898414e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx\n",
    "import obonet\n",
    "\n",
    "# Read the taxrank ontology\n",
    "url = os.path.join(DATA_PATH, \"Train/go-basic.obo\")\n",
    "graph = obonet.read_obo(url)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9f4bf949",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(670114, 3)\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv(os.path.join(DATA_PATH, \"Train/train_terms.tsv\"), sep='\\t')\n",
    "\n",
    "dfSO = df.loc[df[\"aspect\"]==SO]\n",
    "uniqueTerms = dfSO[\"term\"].unique()\n",
    "termsArr = list(dfSO[\"term\"].to_numpy())\n",
    "\n",
    "uniqueTermsDict={}\n",
    "for i,el in enumerate(uniqueTerms):\n",
    "    uniqueTermsDict[el] = i\n",
    "    \n",
    "print(dfSO.shape)\n",
    "df=dfSO\n",
    "\n",
    "df.set_index(\"EntryID\", inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e4dec705",
   "metadata": {},
   "outputs": [],
   "source": [
    "testID = df.index.to_list()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7fff067f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dfGo = pd.read_csv(os.path.join(DATA_PATH, \"Train/train_terms.tsv\"), sep='\\t')\n",
    "\n",
    "dfGo = dfGo.loc[dfGo[\"aspect\"]==SO]\n",
    "\n",
    "dfGo.set_index(\"term\", inplace=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5338b7f8",
   "metadata": {},
   "source": [
    "## GO analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1058ef1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "item_counts = df[\"term\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "eb35584f",
   "metadata": {},
   "outputs": [],
   "source": [
    "id_to_name = {id_: data.get('name') for id_, data in graph.nodes(data=True)}\n",
    "name_to_id = {data['name']: id_ for id_, data in graph.nodes(data=True) if 'name' in data}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7651a3ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "relevantNodes=[]\n",
    "for layer, nodes in enumerate(networkx.topological_generations(graph)):\n",
    "    if layer<20:\n",
    "        relevantNodes = relevantNodes + nodes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3c099fc2",
   "metadata": {},
   "source": [
    "## Label encoding"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cae9a3b0",
   "metadata": {},
   "source": [
    "The task is a multilabel classification: The output has several possible targets (Gene Ontologies) but each can only be 1 (existing) or 0 (non existing)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c8e63ed9",
   "metadata": {},
   "source": [
    "Extract label weights from IA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c7e3c316",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not found GOs: 0 (set to 0)\n"
     ]
    }
   ],
   "source": [
    "dfIa = pd.read_csv(os.path.join(DATA_PATH, \"IA.txt\"), sep='\\t', header=None)\n",
    "\n",
    "dfIa.set_index(0, inplace=True)\n",
    "\n",
    "labelWeights=[]\n",
    "allIndices = dfIa.index.tolist()\n",
    "\n",
    "\n",
    "\n",
    "notFound=0\n",
    "for go in item_counts.index.to_list():\n",
    "    if go in allIndices:\n",
    "        labelWeights.append(dfIa.loc[go].to_numpy()[0])\n",
    "    else:\n",
    "        notFound += 1\n",
    "        labelWeights.append(0)\n",
    "\n",
    "print(\"Not found GOs: {} (set to 0)\".format(notFound))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "caeee590",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading presaved data\n"
     ]
    }
   ],
   "source": [
    "topGOs=item_counts.index.to_list()\n",
    "\n",
    "threshold=0\n",
    "labelWeights=np.array(labelWeights)\n",
    "selection = labelWeights>threshold\n",
    "topGOs=np.array(topGOs)[selection]\n",
    "\n",
    "if os.path.exists(os.path.join(DATA_PATH, \"GODataSizes_\"+SO+\".npy\")):\n",
    "    print(\"Loading presaved data\")\n",
    "    GODataSizes = np.load(os.path.join(DATA_PATH, \"GODataSizes_\"+SO+\".npy\"))\n",
    "else:\n",
    "    GODataSizes= [dfGo.loc[g].size for g in topGOs]\n",
    "    np.save(os.path.join(DATA_PATH, \"GODataSizes_\"+SO), GODataSizes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3e87f301",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2099\n"
     ]
    }
   ],
   "source": [
    "#At least 10 samples\n",
    "print(np.count_nonzero(np.array(GODataSizes)>20))\n",
    "GODataSizes= np.array(GODataSizes)\n",
    "GOsWithSufficientData = topGOs[GODataSizes>20]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "61e2ef95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2099\n"
     ]
    }
   ],
   "source": [
    "#Reduce to relevant GOs (see Data Exploration.ipynb)\n",
    "\n",
    "finalGOSet =[]\n",
    "for g in GOsWithSufficientData:\n",
    "    if g in relevantNodes:\n",
    "        finalGOSet.append(g)\n",
    "\n",
    "print(len(finalGOSet))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "99f6a6ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['GO:0003674' 'GO:0003953' 'GO:0016787' 'GO:0016799' 'GO:0016798'\n",
      " 'GO:0003824']\n",
      "[[0 0 0 ... 0 0 0]]\n",
      "2099\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/manuel/miniconda3/envs/tf/lib/python3.9/site-packages/sklearn/preprocessing/_label.py:895: UserWarning: unknown class(es) ['GO:0003674'] will be ignored\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import MultiLabelBinarizer\n",
    "import pickle\n",
    "\n",
    "\n",
    "mlb = MultiLabelBinarizer()\n",
    "mlb.fit([finalGOSet])\n",
    "\n",
    "dftest=df.loc[testID]\n",
    "indices = dftest[\"term\"].to_numpy()\n",
    "print(indices)\n",
    "print(mlb.transform([indices]))\n",
    "print(len(mlb.classes_))\n",
    "\n",
    "with open(os.path.join(DATA_PATH,'MLB_'+SO+'.pkl'), 'wb') as f:\n",
    "    pickle.dump(mlb, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fb189ff8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not found GOs: 0 (set to 0)\n"
     ]
    }
   ],
   "source": [
    "labelWeightsCorr=[]\n",
    "\n",
    "notFound=0\n",
    "for go in mlb.classes_:\n",
    "    if go in allIndices:\n",
    "        labelWeightsCorr.append(dfIa.loc[go].to_numpy()[0])\n",
    "    else:\n",
    "        notFound += 1\n",
    "        labelWeightsCorr.append(0)\n",
    "\n",
    "print(\"Not found GOs: {} (set to 0)\".format(notFound))\n",
    "labelWeightsCorr=np.array(labelWeightsCorr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "92019f8c",
   "metadata": {},
   "source": [
    "## Amino acids encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6e42462e",
   "metadata": {},
   "outputs": [],
   "source": [
    "aa_dict = {'A': 1, 'B':24, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'K': 9, 'L': 10, 'M': 11, 'N': 12, 'O': 21, 'P': 13, 'Q': 14, 'R': 15, 'S': 16, 'T': 17, 'U': 22, 'V': 18, 'W': 19, 'Y': 20, 'X':30, 'Z':23}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bfd823ba",
   "metadata": {},
   "source": [
    "## Build Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "431f9df8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The max. length of the sequences is 35375\n"
     ]
    }
   ],
   "source": [
    "seqLengths = [len(seq) for seq in sequences]\n",
    "maxLen = max(seqLengths)\n",
    "print(\"The max. length of the sequences is {}\".format(maxLen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e581e06c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A0A009IHW8' 'A0A023FBW4' 'A0A023FBW7' ... 'X5L1L5' 'X5L565' 'X5M5N0']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "dfAll=pd.read_csv(os.path.join(DATA_PATH, \"Train/train_terms.tsv\"), sep='\\t')\n",
    "\n",
    "soEntries = dfAll.loc[dfAll[\"aspect\"]==SO]\n",
    "soEntryIds = soEntries[\"EntryID\"].unique()\n",
    "\n",
    "# print(len(seqEntries))\n",
    "print(soEntryIds)\n",
    "\n",
    "# SoSequences = []\n",
    "# for entry in soEntryIds:\n",
    "#     SoSequences.append(sequences[ids.index(entry)])\n",
    "\n",
    "# print(len(SoSequences))\n",
    "dfAll.set_index(\"EntryID\", inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "44f722e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99572\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "from itertools import product\n",
    "from tqdm import tqdm\n",
    "import os\n",
    "\n",
    "TRAIN_VAL_SPLIT = 0.7\n",
    "nonRelevantThreshold=0.01\n",
    "k = 3\n",
    "\n",
    "allAA = list(aa_dict.keys())\n",
    "allAA.sort()\n",
    "allCombinations= list(product(*(allAA for i in range(k))))\n",
    "allCombinations=np.array([''.join(el) for el in allCombinations])\n",
    "\n",
    "positionDict = dict(zip(allCombinations, np.arange(0,allCombinations.size).T))\n",
    "\n",
    "#Use numpy vectorize to speed up the mapping (hopefully)\n",
    "mapping = lambda x: aa_dict[x]\n",
    "vectMapping = np.vectorize(mapping)\n",
    "\n",
    "# Shuffle the data\n",
    "import random\n",
    "random.seed(516213)\n",
    "c = list(zip(sequences, ids))\n",
    "random.shuffle(c)\n",
    "sequencesShuffle, idsShuffle = zip(*c)\n",
    "\n",
    "\n",
    "#Train Validation Split\n",
    "split = int(np.floor(len(sequencesShuffle)*TRAIN_VAL_SPLIT))\n",
    "print(split)\n",
    "trainSeq = sequencesShuffle[0:split]\n",
    "valSeq = sequencesShuffle[split+1:]\n",
    "trainIds = idsShuffle[0:split]\n",
    "valIds = idsShuffle[split+1:]\n",
    "\n",
    "\n",
    "def generator():\n",
    "  for i,seq in enumerate(trainSeq):\n",
    "      entryId = trainIds[i]\n",
    "      if entryId in soEntryIds:\n",
    "        labelData = df.loc[entryId]\n",
    "        # indices = labelData[\"termToken\"].to_numpy()\n",
    "        indices = labelData[\"term\"].to_numpy()\n",
    "      else: \n",
    "        indices=[]\n",
    "\n",
    "      with warnings.catch_warnings():\n",
    "          #supress the warnings for unknown classes\n",
    "          warnings.simplefilter(\"ignore\")\n",
    "          y = mlb.transform([indices])\n",
    "\n",
    "      # if np.count_nonzero(y)==0 and np.random.random()>nonRelevantThreshold:\n",
    "      #   continue\n",
    "\n",
    "      \n",
    "      kmers = [seq[j:j+k] if j < len(seq)-(k-1) else 0 for j,el in enumerate(seq)]\n",
    "      kmers = kmers[0:-(k-1)]\n",
    "      kmers = [str(el) for el in kmers]\n",
    "      values, counts = np.unique(kmers, return_counts=True)\n",
    "      freqVector=np.zeros(allCombinations.shape)\n",
    "      for l,v in enumerate(values):\n",
    "          freqVector[positionDict[v]] = counts[l]\n",
    "      yield (freqVector,y[0])\n",
    "\n",
    "\n",
    "def generatorVal():\n",
    "  for i,seq in enumerate(valSeq):\n",
    "      entryId = valIds[i]\n",
    "      if entryId in soEntryIds:\n",
    "        labelData = df.loc[entryId]\n",
    "        # indices = labelData[\"termToken\"].to_numpy()\n",
    "        indices = labelData[\"term\"].to_numpy()\n",
    "      else:\n",
    "        indices=[]\n",
    "\n",
    "      with warnings.catch_warnings():\n",
    "          #supress the warnings for unknown classes\n",
    "          warnings.simplefilter(\"ignore\")\n",
    "          y = mlb.transform([indices])\n",
    "\n",
    "      # if np.count_nonzero(y)==0 and np.random.random()>nonRelevantThreshold:\n",
    "      #   continue\n",
    "      \n",
    "      kmers = [seq[j:j+k] if j < len(seq)-(k-1) else 0 for j,el in enumerate(seq)]\n",
    "      kmers = kmers[0:-(k-1)]\n",
    "      kmers = [str(el) for el in kmers]\n",
    "      values, counts = np.unique(kmers, return_counts=True)\n",
    "      freqVector=np.zeros(allCombinations.shape)\n",
    "      for l,v in enumerate(values):\n",
    "          freqVector[positionDict[v]] = counts[l]\n",
    "      yield (freqVector,y[0])\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2727338a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first sample: \n",
      "(15625,)\n",
      "[0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 1. 0. 1. 0.]\n",
      "The first sample has 5 classes\n"
     ]
    }
   ],
   "source": [
    "g = generator()\n",
    "test = next(g)\n",
    "print(\"The first sample: \\n{}\\n{}\".format(test[0].shape, test[0][0:100]))\n",
    "print(\"The first sample has {} classes\".format(np.count_nonzero(test[1])))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "10c4a51a",
   "metadata": {},
   "source": [
    "## Tensorflow Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "63f0d2e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-08-24 10:19:05.492976: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:19:05.493440: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:19:05.493846: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:19:06.294355: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:19:06.294733: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:19:06.294745: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1726] Could not identify NUMA node of platform GPU id 0, defaulting to 0.  Your kernel may not have been built with NUMA support.\n",
      "2023-08-24 10:19:06.295083: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] could not open file to read NUMA node: /sys/bus/pci/devices/0000:2b:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-08-24 10:19:06.295120: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1639] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 5949 MB memory:  -> device: 0, name: NVIDIA GeForce GTX 1070, pci bus id: 0000:2b:00.0, compute capability: 6.1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(<tf.Tensor: shape=(15625,), dtype=int32, numpy=array([0, 0, 0, ..., 0, 0, 0], dtype=int32)>, <tf.Tensor: shape=(2099,), dtype=int32, numpy=array([0, 0, 0, ..., 0, 0, 0], dtype=int32)>)]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "xSize = allCombinations.shape[0]\n",
    "\n",
    "dataset = tf.data.Dataset.from_generator(generator, output_signature=(\n",
    "         tf.TensorSpec(shape=(xSize,), dtype=tf.int32),\n",
    "         tf.TensorSpec(shape=(len(mlb.classes_),), dtype=tf.int32)))\n",
    "print(list(dataset.take(1)))\n",
    "\n",
    "datasetVal = tf.data.Dataset.from_generator(generatorVal, output_signature=(\n",
    "         tf.TensorSpec(shape=(None,), dtype=tf.int32),\n",
    "         tf.TensorSpec(shape=(len(mlb.classes_),), dtype=tf.int32)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f0a554f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext tensorboard\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "98752d7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import layers\n",
    "\n",
    "VOCAB_SIZE=len(aa_dict)\n",
    "EMBED_DIM=10\n",
    "\n",
    "def createModel():\n",
    "    inputs = tf.keras.Input(shape=(xSize,))\n",
    "    # x=layers.Embedding(VOCAB_SIZE, EMBED_DIM, name=\"embedding\")(inputs)\n",
    "    x = layers.BatchNormalization()(tf.expand_dims(inputs,2))\n",
    "\n",
    "    x=layers.Conv1D(16, 7)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "\n",
    "    x=layers.Conv1D(16, 7)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "    \n",
    "    x=layers.Conv1D(16, 7)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "\n",
    "    x=layers.Conv1D(32, 7)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "\n",
    "    x=layers.Conv1D(32, 7,strides=2)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "\n",
    "    x=layers.Conv1D(32, 7,strides=2)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "    \n",
    "    x=layers.Conv1D(32, 7, strides=2)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "    \n",
    "    x=layers.Conv1D(32, 7, strides=2)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "    \n",
    "    \n",
    "\n",
    "    # x=layers.Conv1D(32, 5, activation=tf.keras.activations.relu)(x)\n",
    "    # x=layers.Conv1D(32, 5, activation=tf.keras.activations.relu)(x)\n",
    "    # x=layers.Conv1D(32, 5, activation=tf.keras.activations.relu)(x)\n",
    "    x=layers.Flatten()(x)\n",
    "    x=layers.Dense(64)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x=layers.Dense(64)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    x=layers.Dense(64)(x)\n",
    "    x=layers.LeakyReLU()(x)\n",
    "    outputs=layers.Dense(len(mlb.classes_), activation=tf.keras.activations.sigmoid)(x)\n",
    "\n",
    "    return tf.keras.Model(inputs=inputs, outputs=outputs, name=\"embedConvModel\")\n",
    "\n",
    "# model = createModel()\n",
    "\n",
    "# model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a8d56de9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"DenseModelKmer\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 15625)]           0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 128)               2000128   \n",
      "                                                                 \n",
      " batch_normalization (Batch  (None, 128)               512       \n",
      " Normalization)                                                  \n",
      "                                                                 \n",
      " leaky_re_lu (LeakyReLU)     (None, 128)               0         \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 128)               0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 128)               16512     \n",
      "                                                                 \n",
      " batch_normalization_1 (Bat  (None, 128)               512       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " leaky_re_lu_1 (LeakyReLU)   (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 2099)              270771    \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 2288435 (8.73 MB)\n",
      "Trainable params: 2287923 (8.73 MB)\n",
      "Non-trainable params: 512 (2.00 KB)\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tensorflow.keras import layers\n",
    "\n",
    "VOCAB_SIZE=len(aa_dict)\n",
    "EMBED_DIM=10\n",
    "\n",
    "def createModel():\n",
    "    inputs = tf.keras.Input(shape=(xSize,))\n",
    "    # x=layers.Embedding(VOCAB_SIZE, EMBED_DIM, name=\"embedding\")(inputs)\n",
    "    # x = layers.BatchNormalization()(tf.expand_dims(inputs,2))\n",
    "\n",
    "    x = layers.Dense(128)(inputs)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "    x = layers.LeakyReLU()(x)\n",
    "    x = layers.Dropout(0.1)(x)\n",
    "\n",
    "    x = layers.Dense(128)(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "    x = layers.LeakyReLU()(x)\n",
    "    x = layers.Dropout(0.1)(x)\n",
    "\n",
    "    outputs=layers.Dense(len(mlb.classes_), activation=tf.keras.activations.sigmoid)(x)\n",
    "\n",
    "    return tf.keras.Model(inputs=inputs, outputs=outputs, name=\"DenseModelKmer\")\n",
    "\n",
    "model = createModel()\n",
    "\n",
    "model.summary()\n",
    "\n",
    "dot_img_file = './'+model.name +'.png'\n",
    "tf.keras.utils.plot_model(model, to_file=dot_img_file, show_shapes=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5a3ddc20",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "#Learning rate schedule\n",
    "initial_learning_rate = 0.001\n",
    "decaySteps=5000\n",
    "lr_schedule = tf.keras.optimizers.schedules.CosineDecayRestarts(initial_learning_rate, first_decay_steps=decaySteps,\n",
    "                                                                t_mul=2.0, m_mul=0.7)\n",
    "# lr_schedule = tf.keras.optimizers.schedules.CosineDecay(\n",
    "#     initial_learning_rate, decay_steps=decaySteps, alpha=0.01)\n",
    "# lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n",
    "#     initial_learning_rate,decay_steps=decaySteps,decay_rate=0.9,staircase=False)\n",
    "step = np.linspace(0,decaySteps*3)\n",
    "lr = lr_schedule(step)\n",
    "# plt.figure(figsize = (8,6))\n",
    "# # plt.yscale(\"log\")\n",
    "# plt.plot(step, lr)\n",
    "# plt.ylim([0,max(plt.ylim())])\n",
    "# plt.xlabel('step')\n",
    "# _ = plt.ylabel('Learning Rate')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d2f43e7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9113c4a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Start of epoch 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-28 23:58:41.365292: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'Placeholder/_0' with dtype int32\n",
      "\t [[{{node Placeholder/_0}}]]\n",
      "2023-07-28 23:58:43.302180: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0x7fa993db0580 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2023-07-28 23:58:43.302236: I tensorflow/compiler/xla/service/service.cc:177]   StreamExecutor device (0): NVIDIA GeForce GTX 1070, Compute Capability 6.1\n",
      "2023-07-28 23:58:43.305099: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2023-07-28 23:58:43.414928: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:424] Loaded cuDNN version 8600\n",
      "2023-07-28 23:58:43.502746: I ./tensorflow/compiler/jit/device_compiler.h:180] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/Step 0, Loss: 0.00388, Accuracy: 0.50109, F1: 0.0017, Prec: 0.2887, Rec: 0.0009, lr: 0.00060\n",
      "Epoch 1/Step 20, Loss: 0.00404, Accuracy: 0.50577, F1: 0.0022, Prec: 0.3082, Rec: 0.0011, lr: 0.00060\n",
      "Epoch 1/Step 40, Loss: 0.00323, Accuracy: 0.51492, F1: 0.0024, Prec: 0.3271, Rec: 0.0012, lr: 0.00060\n",
      "Epoch 1/Step 60, Loss: 0.00330, Accuracy: 0.52782, F1: 0.0026, Prec: 0.3446, Rec: 0.0013, lr: 0.00060\n",
      "Epoch 1/Step 80, Loss: 0.00270, Accuracy: 0.55014, F1: 0.0029, Prec: 0.3582, Rec: 0.0015, lr: 0.00060\n",
      "Epoch 1/Step 100, Loss: 0.00211, Accuracy: 0.58160, F1: 0.0034, Prec: 0.3644, Rec: 0.0017, lr: 0.00060\n",
      "Epoch 1/Step 120, Loss: 0.00081, Accuracy: 0.62315, F1: 0.0046, Prec: 0.3693, Rec: 0.0023, lr: 0.00060\n",
      "Epoch 1/Step 140, Loss: -0.00038, Accuracy: 0.66462, F1: 0.0069, Prec: 0.3707, Rec: 0.0035, lr: 0.00060\n",
      "Epoch 1/Step 160, Loss: -0.00156, Accuracy: 0.69986, F1: 0.0096, Prec: 0.3715, Rec: 0.0049, lr: 0.00060\n",
      "Epoch 1/Step 180, Loss: -0.00646, Accuracy: 0.72907, F1: 0.0130, Prec: 0.3741, Rec: 0.0067, lr: 0.00060\n",
      "Epoch 1/Step 200, Loss: -0.00616, Accuracy: 0.75323, F1: 0.0160, Prec: 0.3743, Rec: 0.0084, lr: 0.00060\n",
      "Epoch 1/Step 220, Loss: -0.01560, Accuracy: 0.77351, F1: 0.0194, Prec: 0.3759, Rec: 0.0102, lr: 0.00060\n",
      "Epoch 1/Step 240, Loss: -0.03352, Accuracy: 0.79090, F1: 0.0234, Prec: 0.3772, Rec: 0.0124, lr: 0.00060\n",
      "Epoch 1/Step 260, Loss: -0.05203, Accuracy: 0.80614, F1: 0.0283, Prec: 0.3747, Rec: 0.0154, lr: 0.00060\n",
      "Epoch 1/Step 280, Loss: -0.08982, Accuracy: 0.81957, F1: 0.0353, Prec: 0.3689, Rec: 0.0201, lr: 0.00060\n",
      "Epoch 1/Step 300, Loss: -0.12426, Accuracy: 0.83136, F1: 0.0422, Prec: 0.3598, Rec: 0.0255, lr: 0.00060\n",
      "Epoch 1/Step 320, Loss: -0.14058, Accuracy: 0.84174, F1: 0.0499, Prec: 0.3501, Rec: 0.0329, lr: 0.00060\n",
      "Epoch 1/Step 340, Loss: -0.14910, Accuracy: 0.85093, F1: 0.0597, Prec: 0.3419, Rec: 0.0447, lr: 0.00060\n",
      "Epoch 1/Step 360, Loss: -0.13081, Accuracy: 0.85911, F1: 0.0681, Prec: 0.3327, Rec: 0.0575, lr: 0.00060\n",
      "Epoch 1/Step 380, Loss: -0.16290, Accuracy: 0.86644, F1: 0.0765, Prec: 0.3253, Rec: 0.0697, lr: 0.00060\n",
      "Epoch 1/Step 400, Loss: -0.13853, Accuracy: 0.87304, F1: 0.0839, Prec: 0.3183, Rec: 0.0807, lr: 0.00060\n",
      "Epoch 1/Step 420, Loss: -0.14063, Accuracy: 0.87901, F1: 0.0914, Prec: 0.3124, Rec: 0.0928, lr: 0.00060\n",
      "Epoch 1/Step 440, Loss: -0.15419, Accuracy: 0.88444, F1: 0.0980, Prec: 0.3069, Rec: 0.1032, lr: 0.00060\n",
      "Epoch 1/Step 460, Loss: -0.14298, Accuracy: 0.88940, F1: 0.1042, Prec: 0.3018, Rec: 0.1133, lr: 0.00060\n",
      "Epoch 1/Step 480, Loss: -0.14498, Accuracy: 0.89395, F1: 0.1097, Prec: 0.2972, Rec: 0.1220, lr: 0.00060\n",
      "Epoch 1/Step 500, Loss: -0.19193, Accuracy: 0.89813, F1: 0.1153, Prec: 0.2932, Rec: 0.1310, lr: 0.00060\n",
      "Epoch 1/Step 520, Loss: -0.13790, Accuracy: 0.90200, F1: 0.1201, Prec: 0.2893, Rec: 0.1387, lr: 0.00060\n",
      "Epoch 1/Step 540, Loss: -0.18412, Accuracy: 0.90557, F1: 0.1254, Prec: 0.2864, Rec: 0.1468, lr: 0.00060\n",
      "Epoch 1/Step 560, Loss: -0.12994, Accuracy: 0.90889, F1: 0.1306, Prec: 0.2839, Rec: 0.1547, lr: 0.00060\n",
      "Epoch 1/Step 580, Loss: -0.18185, Accuracy: 0.91199, F1: 0.1350, Prec: 0.2810, Rec: 0.1621, lr: 0.00060\n",
      "Epoch 1/Step 600, Loss: -0.17861, Accuracy: 0.91488, F1: 0.1394, Prec: 0.2787, Rec: 0.1694, lr: 0.00060\n",
      "Epoch 1/Step 620, Loss: -0.18378, Accuracy: 0.91758, F1: 0.1440, Prec: 0.2769, Rec: 0.1769, lr: 0.00060\n",
      "Epoch 1/Step 640, Loss: -0.14428, Accuracy: 0.92012, F1: 0.1471, Prec: 0.2741, Rec: 0.1824, lr: 0.00060\n",
      "Epoch 1/Step 660, Loss: -0.16834, Accuracy: 0.92249, F1: 0.1497, Prec: 0.2712, Rec: 0.1874, lr: 0.00060\n",
      "Epoch 1/Step 680, Loss: -0.17763, Accuracy: 0.92473, F1: 0.1526, Prec: 0.2691, Rec: 0.1919, lr: 0.00060\n",
      "Epoch 1/Step 700, Loss: -0.17191, Accuracy: 0.92685, F1: 0.1553, Prec: 0.2669, Rec: 0.1965, lr: 0.00060\n",
      "Epoch 1/Step 720, Loss: -0.18614, Accuracy: 0.92884, F1: 0.1583, Prec: 0.2655, Rec: 0.2004, lr: 0.00060\n",
      "Epoch 1/Step 740, Loss: -0.12802, Accuracy: 0.93073, F1: 0.1607, Prec: 0.2636, Rec: 0.2044, lr: 0.00060\n",
      "Epoch 1/Step 760, Loss: -0.18006, Accuracy: 0.93252, F1: 0.1631, Prec: 0.2620, Rec: 0.2081, lr: 0.00060\n",
      "Epoch 1/Step 780, Loss: -0.15013, Accuracy: 0.93422, F1: 0.1656, Prec: 0.2604, Rec: 0.2124, lr: 0.00060\n",
      "Epoch 1/Step 800, Loss: -0.18483, Accuracy: 0.93583, F1: 0.1674, Prec: 0.2584, Rec: 0.2160, lr: 0.00060\n",
      "Epoch 1/Step 820, Loss: -0.17130, Accuracy: 0.93737, F1: 0.1695, Prec: 0.2569, Rec: 0.2197, lr: 0.00060\n",
      "Epoch 1/Step 840, Loss: -0.17069, Accuracy: 0.93883, F1: 0.1716, Prec: 0.2555, Rec: 0.2234, lr: 0.00060\n",
      "Epoch 1/Step 860, Loss: -0.16723, Accuracy: 0.94022, F1: 0.1733, Prec: 0.2541, Rec: 0.2263, lr: 0.00060\n",
      "Epoch 1/Step 880, Loss: -0.15753, Accuracy: 0.94155, F1: 0.1752, Prec: 0.2528, Rec: 0.2293, lr: 0.00060\n",
      "Epoch 1/Step 900, Loss: -0.21650, Accuracy: 0.94282, F1: 0.1771, Prec: 0.2519, Rec: 0.2322, lr: 0.00060\n",
      "Epoch 1/Step 920, Loss: -0.17701, Accuracy: 0.94404, F1: 0.1787, Prec: 0.2506, Rec: 0.2351, lr: 0.00060\n",
      "Epoch 1/Step 940, Loss: -0.14458, Accuracy: 0.94520, F1: 0.1803, Prec: 0.2495, Rec: 0.2376, lr: 0.00060\n",
      "Epoch 1/Step 960, Loss: -0.16775, Accuracy: 0.94632, F1: 0.1819, Prec: 0.2485, Rec: 0.2403, lr: 0.00060\n",
      "Epoch 1/Step 980, Loss: -0.17350, Accuracy: 0.94739, F1: 0.1835, Prec: 0.2475, Rec: 0.2431, lr: 0.00060\n",
      "Epoch 1/Step 1000, Loss: -0.19083, Accuracy: 0.94841, F1: 0.1848, Prec: 0.2463, Rec: 0.2457, lr: 0.00060\n",
      "Epoch 1/Step 1020, Loss: -0.13841, Accuracy: 0.94940, F1: 0.1859, Prec: 0.2450, Rec: 0.2481, lr: 0.00060\n",
      "Epoch 1/Step 1040, Loss: -0.15854, Accuracy: 0.95035, F1: 0.1875, Prec: 0.2444, Rec: 0.2506, lr: 0.00060\n",
      "Epoch 1/Step 1060, Loss: -0.19931, Accuracy: 0.95126, F1: 0.1886, Prec: 0.2433, Rec: 0.2530, lr: 0.00060\n",
      "Epoch 1/Step 1080, Loss: -0.13801, Accuracy: 0.95214, F1: 0.1900, Prec: 0.2425, Rec: 0.2555, lr: 0.00060\n",
      "Epoch 1/Step 1100, Loss: -0.21552, Accuracy: 0.95299, F1: 0.1916, Prec: 0.2420, Rec: 0.2581, lr: 0.00060\n",
      "Epoch 1/Step 1120, Loss: -0.15725, Accuracy: 0.95381, F1: 0.1926, Prec: 0.2412, Rec: 0.2599, lr: 0.00060\n",
      "Epoch 1/Step 1140, Loss: -0.18602, Accuracy: 0.95460, F1: 0.1940, Prec: 0.2407, Rec: 0.2622, lr: 0.00060\n",
      "Epoch 1/Step 1160, Loss: -0.14350, Accuracy: 0.95536, F1: 0.1953, Prec: 0.2402, Rec: 0.2640, lr: 0.00060\n",
      "Epoch 1/Step 1180, Loss: -0.17822, Accuracy: 0.95610, F1: 0.1962, Prec: 0.2394, Rec: 0.2657, lr: 0.00060\n",
      "Epoch 1/Step 1200, Loss: -0.13565, Accuracy: 0.95681, F1: 0.1973, Prec: 0.2388, Rec: 0.2676, lr: 0.00060\n",
      "Epoch 1/Step 1220, Loss: -0.16779, Accuracy: 0.95750, F1: 0.1984, Prec: 0.2382, Rec: 0.2693, lr: 0.00060\n",
      "Epoch 1/Step 1240, Loss: -0.19529, Accuracy: 0.95816, F1: 0.1991, Prec: 0.2374, Rec: 0.2708, lr: 0.00060\n",
      "Epoch 1/Step 1260, Loss: -0.16789, Accuracy: 0.95881, F1: 0.2002, Prec: 0.2370, Rec: 0.2725, lr: 0.00060\n",
      "Epoch 1/Step 1280, Loss: -0.17287, Accuracy: 0.95943, F1: 0.2011, Prec: 0.2363, Rec: 0.2742, lr: 0.00060\n",
      "Epoch 1/Step 1300, Loss: -0.15213, Accuracy: 0.96004, F1: 0.2021, Prec: 0.2360, Rec: 0.2756, lr: 0.00060\n",
      "Epoch 1/Step 1320, Loss: -0.13307, Accuracy: 0.96063, F1: 0.2030, Prec: 0.2355, Rec: 0.2771, lr: 0.00060\n",
      "Epoch 1/Step 1340, Loss: -0.17290, Accuracy: 0.96120, F1: 0.2042, Prec: 0.2353, Rec: 0.2790, lr: 0.00060\n",
      "Epoch 1/Step 1360, Loss: -0.14916, Accuracy: 0.96175, F1: 0.2049, Prec: 0.2346, Rec: 0.2804, lr: 0.00060\n",
      "Epoch 1/Step 1380, Loss: -0.18779, Accuracy: 0.96229, F1: 0.2058, Prec: 0.2342, Rec: 0.2820, lr: 0.00060\n",
      "Epoch 1/Step 1400, Loss: -0.13607, Accuracy: 0.96281, F1: 0.2065, Prec: 0.2337, Rec: 0.2831, lr: 0.00060\n",
      "Epoch 1/Step 1420, Loss: -0.17054, Accuracy: 0.96332, F1: 0.2070, Prec: 0.2331, Rec: 0.2840, lr: 0.00060\n",
      "Epoch 1/Step 1440, Loss: -0.18267, Accuracy: 0.96381, F1: 0.2078, Prec: 0.2327, Rec: 0.2854, lr: 0.00060\n",
      "Epoch 1/Step 1460, Loss: -0.17813, Accuracy: 0.96429, F1: 0.2084, Prec: 0.2322, Rec: 0.2864, lr: 0.00060\n",
      "Epoch 1/Step 1480, Loss: -0.17545, Accuracy: 0.96475, F1: 0.2090, Prec: 0.2316, Rec: 0.2878, lr: 0.00060\n",
      "Epoch 1/Step 1500, Loss: -0.19312, Accuracy: 0.96521, F1: 0.2098, Prec: 0.2313, Rec: 0.2891, lr: 0.00060\n",
      "Epoch 1/Step 1520, Loss: -0.15055, Accuracy: 0.96565, F1: 0.2104, Prec: 0.2309, Rec: 0.2898, lr: 0.00060\n",
      "Epoch 1/Step 1540, Loss: -0.18689, Accuracy: 0.96608, F1: 0.2110, Prec: 0.2305, Rec: 0.2910, lr: 0.00060\n",
      "Epoch finished. Start validation\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-29 00:01:55.676678: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'Placeholder/_0' with dtype int32\n",
      "\t [[{{node Placeholder/_0}}]]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation acc: 0.9989\n",
      "Validation f1: 0.2607\n",
      "Validation precision: 0.1996\n",
      "Validation recall: 0.3853\n",
      "\n",
      "Start of epoch 2\n",
      "Epoch 2/Step 0, Loss: -0.17515, Accuracy: 0.99889, F1: 0.2885, Prec: 0.2429, Rec: 0.3553, lr: 0.00060\n",
      "Epoch 2/Step 20, Loss: -0.16600, Accuracy: 0.99888, F1: 0.2640, Prec: 0.2087, Rec: 0.3686, lr: 0.00060\n",
      "Epoch 2/Step 40, Loss: -0.16332, Accuracy: 0.99885, F1: 0.2570, Prec: 0.2003, Rec: 0.3662, lr: 0.00060\n",
      "Epoch 2/Step 60, Loss: -0.16713, Accuracy: 0.99886, F1: 0.2631, Prec: 0.2053, Rec: 0.3738, lr: 0.00060\n",
      "Epoch 2/Step 80, Loss: -0.16860, Accuracy: 0.99886, F1: 0.2609, Prec: 0.2024, Rec: 0.3752, lr: 0.00060\n",
      "Epoch 2/Step 100, Loss: -0.15744, Accuracy: 0.99887, F1: 0.2591, Prec: 0.2006, Rec: 0.3730, lr: 0.00060\n",
      "Epoch 2/Step 120, Loss: -0.13181, Accuracy: 0.99886, F1: 0.2590, Prec: 0.1998, Rec: 0.3755, lr: 0.00060\n",
      "Epoch 2/Step 140, Loss: -0.16940, Accuracy: 0.99886, F1: 0.2590, Prec: 0.1999, Rec: 0.3758, lr: 0.00060\n",
      "Epoch 2/Step 160, Loss: -0.16950, Accuracy: 0.99885, F1: 0.2598, Prec: 0.2009, Rec: 0.3756, lr: 0.00060\n",
      "Epoch 2/Step 180, Loss: -0.19152, Accuracy: 0.99885, F1: 0.2614, Prec: 0.2024, Rec: 0.3773, lr: 0.00060\n",
      "Epoch 2/Step 200, Loss: -0.17315, Accuracy: 0.99885, F1: 0.2609, Prec: 0.2021, Rec: 0.3758, lr: 0.00060\n",
      "Epoch 2/Step 220, Loss: -0.23312, Accuracy: 0.99884, F1: 0.2616, Prec: 0.2025, Rec: 0.3777, lr: 0.00060\n",
      "Epoch 2/Step 240, Loss: -0.16506, Accuracy: 0.99884, F1: 0.2625, Prec: 0.2034, Rec: 0.3785, lr: 0.00060\n",
      "Epoch 2/Step 260, Loss: -0.16256, Accuracy: 0.99884, F1: 0.2630, Prec: 0.2038, Rec: 0.3789, lr: 0.00060\n",
      "Epoch 2/Step 280, Loss: -0.18118, Accuracy: 0.99883, F1: 0.2640, Prec: 0.2047, Rec: 0.3800, lr: 0.00060\n",
      "Epoch 2/Step 300, Loss: -0.19419, Accuracy: 0.99883, F1: 0.2632, Prec: 0.2041, Rec: 0.3791, lr: 0.00060\n",
      "Epoch 2/Step 320, Loss: -0.21571, Accuracy: 0.99884, F1: 0.2626, Prec: 0.2035, Rec: 0.3786, lr: 0.00060\n",
      "Epoch 2/Step 340, Loss: -0.20312, Accuracy: 0.99884, F1: 0.2635, Prec: 0.2042, Rec: 0.3800, lr: 0.00060\n",
      "Epoch 2/Step 360, Loss: -0.17343, Accuracy: 0.99884, F1: 0.2629, Prec: 0.2034, Rec: 0.3802, lr: 0.00060\n",
      "Epoch 2/Step 380, Loss: -0.20513, Accuracy: 0.99884, F1: 0.2634, Prec: 0.2040, Rec: 0.3800, lr: 0.00060\n",
      "Epoch 2/Step 400, Loss: -0.17433, Accuracy: 0.99885, F1: 0.2632, Prec: 0.2040, Rec: 0.3796, lr: 0.00060\n",
      "Epoch 2/Step 420, Loss: -0.18218, Accuracy: 0.99885, F1: 0.2634, Prec: 0.2041, Rec: 0.3798, lr: 0.00060\n",
      "Epoch 2/Step 440, Loss: -0.16851, Accuracy: 0.99885, F1: 0.2637, Prec: 0.2044, Rec: 0.3800, lr: 0.00060\n",
      "Epoch 2/Step 460, Loss: -0.16091, Accuracy: 0.99885, F1: 0.2641, Prec: 0.2048, Rec: 0.3802, lr: 0.00060\n",
      "Epoch 2/Step 480, Loss: -0.16485, Accuracy: 0.99885, F1: 0.2642, Prec: 0.2049, Rec: 0.3804, lr: 0.00060\n",
      "Epoch 2/Step 500, Loss: -0.21408, Accuracy: 0.99885, F1: 0.2646, Prec: 0.2051, Rec: 0.3811, lr: 0.00060\n",
      "Epoch 2/Step 520, Loss: -0.19292, Accuracy: 0.99885, F1: 0.2648, Prec: 0.2054, Rec: 0.3814, lr: 0.00060\n",
      "Epoch 2/Step 540, Loss: -0.21194, Accuracy: 0.99885, F1: 0.2657, Prec: 0.2061, Rec: 0.3823, lr: 0.00060\n",
      "Epoch 2/Step 560, Loss: -0.16194, Accuracy: 0.99885, F1: 0.2668, Prec: 0.2070, Rec: 0.3835, lr: 0.00060\n",
      "Epoch 2/Step 580, Loss: -0.20577, Accuracy: 0.99885, F1: 0.2672, Prec: 0.2074, Rec: 0.3840, lr: 0.00060\n",
      "Epoch 2/Step 600, Loss: -0.20924, Accuracy: 0.99885, F1: 0.2679, Prec: 0.2081, Rec: 0.3847, lr: 0.00060\n",
      "Epoch 2/Step 620, Loss: -0.22510, Accuracy: 0.99885, F1: 0.2693, Prec: 0.2092, Rec: 0.3866, lr: 0.00060\n",
      "Epoch 2/Step 640, Loss: -0.16478, Accuracy: 0.99885, F1: 0.2690, Prec: 0.2088, Rec: 0.3864, lr: 0.00060\n",
      "Epoch 2/Step 660, Loss: -0.19113, Accuracy: 0.99885, F1: 0.2687, Prec: 0.2084, Rec: 0.3867, lr: 0.00060\n",
      "Epoch 2/Step 680, Loss: -0.19955, Accuracy: 0.99885, F1: 0.2689, Prec: 0.2085, Rec: 0.3870, lr: 0.00060\n",
      "Epoch 2/Step 700, Loss: -0.20088, Accuracy: 0.99885, F1: 0.2689, Prec: 0.2085, Rec: 0.3870, lr: 0.00060\n",
      "Epoch 2/Step 720, Loss: -0.21655, Accuracy: 0.99886, F1: 0.2693, Prec: 0.2090, Rec: 0.3871, lr: 0.00060\n",
      "Epoch 2/Step 740, Loss: -0.15405, Accuracy: 0.99886, F1: 0.2693, Prec: 0.2089, Rec: 0.3871, lr: 0.00060\n",
      "Epoch 2/Step 760, Loss: -0.19609, Accuracy: 0.99886, F1: 0.2693, Prec: 0.2089, Rec: 0.3874, lr: 0.00060\n",
      "Epoch 2/Step 780, Loss: -0.14787, Accuracy: 0.99886, F1: 0.2694, Prec: 0.2089, Rec: 0.3877, lr: 0.00060\n",
      "Epoch 2/Step 800, Loss: -0.18849, Accuracy: 0.99886, F1: 0.2690, Prec: 0.2085, Rec: 0.3877, lr: 0.00060\n",
      "Epoch 2/Step 820, Loss: -0.20015, Accuracy: 0.99886, F1: 0.2691, Prec: 0.2084, Rec: 0.3879, lr: 0.00060\n",
      "Epoch 2/Step 840, Loss: -0.17940, Accuracy: 0.99886, F1: 0.2693, Prec: 0.2086, Rec: 0.3883, lr: 0.00060\n",
      "Epoch 2/Step 860, Loss: -0.18438, Accuracy: 0.99886, F1: 0.2692, Prec: 0.2085, Rec: 0.3880, lr: 0.00060\n",
      "Epoch 2/Step 880, Loss: -0.19934, Accuracy: 0.99886, F1: 0.2693, Prec: 0.2086, Rec: 0.3883, lr: 0.00060\n",
      "Epoch 2/Step 900, Loss: -0.23119, Accuracy: 0.99886, F1: 0.2695, Prec: 0.2089, Rec: 0.3883, lr: 0.00060\n",
      "Epoch 2/Step 920, Loss: -0.18157, Accuracy: 0.99886, F1: 0.2695, Prec: 0.2088, Rec: 0.3884, lr: 0.00060\n",
      "Epoch 2/Step 940, Loss: -0.18184, Accuracy: 0.99886, F1: 0.2694, Prec: 0.2088, Rec: 0.3882, lr: 0.00060\n",
      "Epoch 2/Step 960, Loss: -0.18636, Accuracy: 0.99886, F1: 0.2697, Prec: 0.2090, Rec: 0.3884, lr: 0.00060\n",
      "Epoch 2/Step 980, Loss: -0.19165, Accuracy: 0.99886, F1: 0.2697, Prec: 0.2089, Rec: 0.3890, lr: 0.00060\n",
      "Epoch 2/Step 1000, Loss: -0.20165, Accuracy: 0.99886, F1: 0.2696, Prec: 0.2087, Rec: 0.3891, lr: 0.00060\n",
      "Epoch 2/Step 1020, Loss: -0.15973, Accuracy: 0.99886, F1: 0.2694, Prec: 0.2083, Rec: 0.3895, lr: 0.00060\n",
      "Epoch 2/Step 1040, Loss: -0.17796, Accuracy: 0.99886, F1: 0.2697, Prec: 0.2086, Rec: 0.3899, lr: 0.00060\n",
      "Epoch 2/Step 1060, Loss: -0.21953, Accuracy: 0.99886, F1: 0.2696, Prec: 0.2084, Rec: 0.3900, lr: 0.00060\n",
      "Epoch 2/Step 1080, Loss: -0.15888, Accuracy: 0.99886, F1: 0.2696, Prec: 0.2084, Rec: 0.3901, lr: 0.00060\n",
      "Epoch 2/Step 1100, Loss: -0.23121, Accuracy: 0.99887, F1: 0.2701, Prec: 0.2088, Rec: 0.3907, lr: 0.00060\n",
      "Epoch 2/Step 1120, Loss: -0.17398, Accuracy: 0.99887, F1: 0.2700, Prec: 0.2087, Rec: 0.3907, lr: 0.00060\n",
      "Epoch 2/Step 1140, Loss: -0.19312, Accuracy: 0.99887, F1: 0.2703, Prec: 0.2090, Rec: 0.3913, lr: 0.00060\n",
      "Epoch 2/Step 1160, Loss: -0.17351, Accuracy: 0.99887, F1: 0.2705, Prec: 0.2092, Rec: 0.3913, lr: 0.00060\n",
      "Epoch 2/Step 1180, Loss: -0.20015, Accuracy: 0.99887, F1: 0.2704, Prec: 0.2090, Rec: 0.3913, lr: 0.00060\n",
      "Epoch 2/Step 1200, Loss: -0.15265, Accuracy: 0.99887, F1: 0.2705, Prec: 0.2091, Rec: 0.3915, lr: 0.00060\n",
      "Epoch 2/Step 1220, Loss: -0.19666, Accuracy: 0.99887, F1: 0.2707, Prec: 0.2092, Rec: 0.3917, lr: 0.00060\n",
      "Epoch 2/Step 1240, Loss: -0.22026, Accuracy: 0.99887, F1: 0.2705, Prec: 0.2090, Rec: 0.3917, lr: 0.00060\n",
      "Epoch 2/Step 1260, Loss: -0.18181, Accuracy: 0.99887, F1: 0.2706, Prec: 0.2091, Rec: 0.3919, lr: 0.00060\n",
      "Epoch 2/Step 1280, Loss: -0.19300, Accuracy: 0.99887, F1: 0.2707, Prec: 0.2091, Rec: 0.3920, lr: 0.00060\n",
      "Epoch 2/Step 1300, Loss: -0.15612, Accuracy: 0.99887, F1: 0.2709, Prec: 0.2094, Rec: 0.3921, lr: 0.00060\n",
      "Epoch 2/Step 1320, Loss: -0.15175, Accuracy: 0.99887, F1: 0.2710, Prec: 0.2095, Rec: 0.3923, lr: 0.00060\n",
      "Epoch 2/Step 1340, Loss: -0.19125, Accuracy: 0.99887, F1: 0.2714, Prec: 0.2098, Rec: 0.3927, lr: 0.00060\n",
      "Epoch 2/Step 1360, Loss: -0.16833, Accuracy: 0.99887, F1: 0.2713, Prec: 0.2096, Rec: 0.3928, lr: 0.00060\n",
      "Epoch 2/Step 1380, Loss: -0.19758, Accuracy: 0.99887, F1: 0.2714, Prec: 0.2097, Rec: 0.3931, lr: 0.00060\n",
      "Epoch 2/Step 1400, Loss: -0.15557, Accuracy: 0.99887, F1: 0.2714, Prec: 0.2097, Rec: 0.3930, lr: 0.00060\n",
      "Epoch 2/Step 1420, Loss: -0.19630, Accuracy: 0.99887, F1: 0.2712, Prec: 0.2095, Rec: 0.3926, lr: 0.00060\n",
      "Epoch 2/Step 1440, Loss: -0.18520, Accuracy: 0.99887, F1: 0.2712, Prec: 0.2096, Rec: 0.3928, lr: 0.00060\n",
      "Epoch 2/Step 1460, Loss: -0.19382, Accuracy: 0.99887, F1: 0.2713, Prec: 0.2096, Rec: 0.3929, lr: 0.00060\n",
      "Epoch 2/Step 1480, Loss: -0.18719, Accuracy: 0.99887, F1: 0.2712, Prec: 0.2095, Rec: 0.3929, lr: 0.00060\n",
      "Epoch 2/Step 1500, Loss: -0.19860, Accuracy: 0.99887, F1: 0.2713, Prec: 0.2096, Rec: 0.3931, lr: 0.00060\n",
      "Epoch 2/Step 1520, Loss: -0.16594, Accuracy: 0.99887, F1: 0.2713, Prec: 0.2096, Rec: 0.3930, lr: 0.00060\n",
      "Epoch 2/Step 1540, Loss: -0.20462, Accuracy: 0.99887, F1: 0.2714, Prec: 0.2096, Rec: 0.3931, lr: 0.00060\n",
      "Epoch finished. Start validation\n",
      "Validation acc: 0.9989\n",
      "Validation f1: 0.2598\n",
      "Validation precision: 0.1960\n",
      "Validation recall: 0.3946\n",
      "\n",
      "Start of epoch 3\n",
      "Epoch 3/Step 0, Loss: -0.19620, Accuracy: 0.99899, F1: 0.3012, Prec: 0.2496, Rec: 0.3795, lr: 0.00060\n",
      "Epoch 3/Step 20, Loss: -0.19368, Accuracy: 0.99894, F1: 0.2788, Prec: 0.2185, Rec: 0.3949, lr: 0.00060\n",
      "Epoch 3/Step 40, Loss: -0.17643, Accuracy: 0.99891, F1: 0.2701, Prec: 0.2091, Rec: 0.3898, lr: 0.00060\n",
      "Epoch 3/Step 60, Loss: -0.18968, Accuracy: 0.99891, F1: 0.2758, Prec: 0.2141, Rec: 0.3947, lr: 0.00060\n",
      "Epoch 3/Step 80, Loss: -0.16860, Accuracy: 0.99892, F1: 0.2734, Prec: 0.2111, Rec: 0.3954, lr: 0.00060\n",
      "Epoch 3/Step 100, Loss: -0.16377, Accuracy: 0.99892, F1: 0.2715, Prec: 0.2096, Rec: 0.3920, lr: 0.00060\n",
      "Epoch 3/Step 120, Loss: -0.15574, Accuracy: 0.99891, F1: 0.2711, Prec: 0.2087, Rec: 0.3939, lr: 0.00060\n",
      "Epoch 3/Step 140, Loss: -0.19555, Accuracy: 0.99891, F1: 0.2713, Prec: 0.2090, Rec: 0.3941, lr: 0.00060\n",
      "Epoch 3/Step 160, Loss: -0.18388, Accuracy: 0.99890, F1: 0.2725, Prec: 0.2103, Rec: 0.3945, lr: 0.00060\n",
      "Epoch 3/Step 180, Loss: -0.21404, Accuracy: 0.99890, F1: 0.2741, Prec: 0.2116, Rec: 0.3967, lr: 0.00060\n",
      "Epoch 3/Step 200, Loss: -0.19374, Accuracy: 0.99890, F1: 0.2732, Prec: 0.2112, Rec: 0.3943, lr: 0.00060\n",
      "Epoch 3/Step 220, Loss: -0.24551, Accuracy: 0.99889, F1: 0.2738, Prec: 0.2116, Rec: 0.3960, lr: 0.00060\n",
      "Epoch 3/Step 240, Loss: -0.18342, Accuracy: 0.99889, F1: 0.2749, Prec: 0.2124, Rec: 0.3974, lr: 0.00060\n",
      "Epoch 3/Step 260, Loss: -0.17944, Accuracy: 0.99889, F1: 0.2754, Prec: 0.2128, Rec: 0.3982, lr: 0.00060\n",
      "Epoch 3/Step 280, Loss: -0.19589, Accuracy: 0.99888, F1: 0.2761, Prec: 0.2133, Rec: 0.3992, lr: 0.00060\n",
      "Epoch 3/Step 300, Loss: -0.20686, Accuracy: 0.99889, F1: 0.2755, Prec: 0.2128, Rec: 0.3986, lr: 0.00060\n",
      "Epoch 3/Step 320, Loss: -0.22378, Accuracy: 0.99889, F1: 0.2750, Prec: 0.2124, Rec: 0.3979, lr: 0.00060\n",
      "Epoch 3/Step 340, Loss: -0.20931, Accuracy: 0.99889, F1: 0.2758, Prec: 0.2129, Rec: 0.3993, lr: 0.00060\n",
      "Epoch 3/Step 360, Loss: -0.19116, Accuracy: 0.99889, F1: 0.2750, Prec: 0.2120, Rec: 0.3992, lr: 0.00060\n",
      "Epoch 3/Step 380, Loss: -0.21636, Accuracy: 0.99889, F1: 0.2752, Prec: 0.2124, Rec: 0.3988, lr: 0.00060\n",
      "Epoch 3/Step 400, Loss: -0.18974, Accuracy: 0.99890, F1: 0.2751, Prec: 0.2124, Rec: 0.3985, lr: 0.00060\n",
      "Epoch 3/Step 420, Loss: -0.19953, Accuracy: 0.99890, F1: 0.2753, Prec: 0.2125, Rec: 0.3988, lr: 0.00060\n",
      "Epoch 3/Step 440, Loss: -0.18476, Accuracy: 0.99890, F1: 0.2756, Prec: 0.2128, Rec: 0.3990, lr: 0.00060\n",
      "Epoch 3/Step 460, Loss: -0.16752, Accuracy: 0.99890, F1: 0.2761, Prec: 0.2131, Rec: 0.3996, lr: 0.00060\n",
      "Epoch 3/Step 480, Loss: -0.17484, Accuracy: 0.99890, F1: 0.2759, Prec: 0.2130, Rec: 0.3997, lr: 0.00060\n",
      "Epoch 3/Step 500, Loss: -0.22525, Accuracy: 0.99890, F1: 0.2764, Prec: 0.2133, Rec: 0.4001, lr: 0.00060\n",
      "Epoch 3/Step 520, Loss: -0.19935, Accuracy: 0.99890, F1: 0.2764, Prec: 0.2134, Rec: 0.4005, lr: 0.00060\n",
      "Epoch 3/Step 540, Loss: -0.22342, Accuracy: 0.99890, F1: 0.2773, Prec: 0.2141, Rec: 0.4015, lr: 0.00060\n",
      "Epoch 3/Step 560, Loss: -0.17785, Accuracy: 0.99890, F1: 0.2782, Prec: 0.2148, Rec: 0.4025, lr: 0.00060\n",
      "Epoch 3/Step 580, Loss: -0.21394, Accuracy: 0.99890, F1: 0.2786, Prec: 0.2152, Rec: 0.4028, lr: 0.00060\n",
      "Epoch 3/Step 600, Loss: -0.20801, Accuracy: 0.99890, F1: 0.2791, Prec: 0.2158, Rec: 0.4031, lr: 0.00060\n",
      "Epoch 3/Step 620, Loss: -0.24015, Accuracy: 0.99890, F1: 0.2805, Prec: 0.2169, Rec: 0.4048, lr: 0.00060\n",
      "Epoch 3/Step 640, Loss: -0.17106, Accuracy: 0.99890, F1: 0.2800, Prec: 0.2164, Rec: 0.4045, lr: 0.00060\n",
      "Epoch 3/Step 660, Loss: -0.20575, Accuracy: 0.99890, F1: 0.2797, Prec: 0.2160, Rec: 0.4047, lr: 0.00060\n",
      "Epoch 3/Step 680, Loss: -0.21705, Accuracy: 0.99890, F1: 0.2800, Prec: 0.2162, Rec: 0.4052, lr: 0.00060\n",
      "Epoch 3/Step 700, Loss: -0.20074, Accuracy: 0.99890, F1: 0.2800, Prec: 0.2162, Rec: 0.4055, lr: 0.00060\n",
      "Epoch 3/Step 720, Loss: -0.21900, Accuracy: 0.99890, F1: 0.2804, Prec: 0.2166, Rec: 0.4054, lr: 0.00060\n",
      "Epoch 3/Step 740, Loss: -0.15633, Accuracy: 0.99890, F1: 0.2802, Prec: 0.2164, Rec: 0.4053, lr: 0.00060\n",
      "Epoch 3/Step 760, Loss: -0.20824, Accuracy: 0.99890, F1: 0.2801, Prec: 0.2163, Rec: 0.4054, lr: 0.00060\n",
      "Epoch 3/Step 780, Loss: -0.14746, Accuracy: 0.99890, F1: 0.2801, Prec: 0.2163, Rec: 0.4052, lr: 0.00060\n",
      "Epoch 3/Step 800, Loss: -0.19695, Accuracy: 0.99890, F1: 0.2797, Prec: 0.2159, Rec: 0.4051, lr: 0.00060\n",
      "Epoch 3/Step 820, Loss: -0.21558, Accuracy: 0.99890, F1: 0.2796, Prec: 0.2158, Rec: 0.4052, lr: 0.00060\n",
      "Epoch 3/Step 840, Loss: -0.19702, Accuracy: 0.99890, F1: 0.2798, Prec: 0.2159, Rec: 0.4054, lr: 0.00060\n",
      "Epoch 3/Step 860, Loss: -0.19053, Accuracy: 0.99891, F1: 0.2796, Prec: 0.2158, Rec: 0.4050, lr: 0.00060\n",
      "Epoch 3/Step 880, Loss: -0.20819, Accuracy: 0.99891, F1: 0.2796, Prec: 0.2158, Rec: 0.4052, lr: 0.00060\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[27], line 76\u001b[0m\n\u001b[1;32m     73\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39mStart of epoch \u001b[39m\u001b[39m%d\u001b[39;00m\u001b[39m\"\u001b[39m \u001b[39m%\u001b[39m (epoch\u001b[39m+\u001b[39m\u001b[39m1\u001b[39m,))\n\u001b[1;32m     75\u001b[0m \u001b[39m# Iterate over the batches of the dataset.\u001b[39;00m\n\u001b[0;32m---> 76\u001b[0m \u001b[39mfor\u001b[39;00m step, (x_batch_train, y_batch_train) \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(batchedDataset):\n\u001b[1;32m     78\u001b[0m     loss_value \u001b[39m=\u001b[39mtrainStep(x_batch_train,y_batch_train)\n\u001b[1;32m     80\u001b[0m     \u001b[39m# Log \u001b[39;00m\n",
      "File \u001b[0;32m~/miniconda3/envs/tf/lib/python3.9/site-packages/tensorflow/python/data/ops/iterator_ops.py:797\u001b[0m, in \u001b[0;36mOwnedIterator.__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    795\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__next__\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m    796\u001b[0m   \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 797\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_next_internal()\n\u001b[1;32m    798\u001b[0m   \u001b[39mexcept\u001b[39;00m errors\u001b[39m.\u001b[39mOutOfRangeError:\n\u001b[1;32m    799\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mStopIteration\u001b[39;00m\n",
      "File \u001b[0;32m~/miniconda3/envs/tf/lib/python3.9/site-packages/tensorflow/python/data/ops/iterator_ops.py:780\u001b[0m, in \u001b[0;36mOwnedIterator._next_internal\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    777\u001b[0m \u001b[39m# TODO(b/77291417): This runs in sync mode as iterators use an error status\u001b[39;00m\n\u001b[1;32m    778\u001b[0m \u001b[39m# to communicate that there is no more data to iterate over.\u001b[39;00m\n\u001b[1;32m    779\u001b[0m \u001b[39mwith\u001b[39;00m context\u001b[39m.\u001b[39mexecution_mode(context\u001b[39m.\u001b[39mSYNC):\n\u001b[0;32m--> 780\u001b[0m   ret \u001b[39m=\u001b[39m gen_dataset_ops\u001b[39m.\u001b[39;49miterator_get_next(\n\u001b[1;32m    781\u001b[0m       \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_iterator_resource,\n\u001b[1;32m    782\u001b[0m       output_types\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_flat_output_types,\n\u001b[1;32m    783\u001b[0m       output_shapes\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_flat_output_shapes)\n\u001b[1;32m    785\u001b[0m   \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m    786\u001b[0m     \u001b[39m# Fast path for the case `self._structure` is not a nested structure.\u001b[39;00m\n\u001b[1;32m    787\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_element_spec\u001b[39m.\u001b[39m_from_compatible_tensor_list(ret)  \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n",
      "File \u001b[0;32m~/miniconda3/envs/tf/lib/python3.9/site-packages/tensorflow/python/ops/gen_dataset_ops.py:3011\u001b[0m, in \u001b[0;36miterator_get_next\u001b[0;34m(iterator, output_types, output_shapes, name)\u001b[0m\n\u001b[1;32m   3009\u001b[0m \u001b[39mif\u001b[39;00m tld\u001b[39m.\u001b[39mis_eager:\n\u001b[1;32m   3010\u001b[0m   \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 3011\u001b[0m     _result \u001b[39m=\u001b[39m pywrap_tfe\u001b[39m.\u001b[39;49mTFE_Py_FastPathExecute(\n\u001b[1;32m   3012\u001b[0m       _ctx, \u001b[39m\"\u001b[39;49m\u001b[39mIteratorGetNext\u001b[39;49m\u001b[39m\"\u001b[39;49m, name, iterator, \u001b[39m\"\u001b[39;49m\u001b[39moutput_types\u001b[39;49m\u001b[39m\"\u001b[39;49m, output_types,\n\u001b[1;32m   3013\u001b[0m       \u001b[39m\"\u001b[39;49m\u001b[39moutput_shapes\u001b[39;49m\u001b[39m\"\u001b[39;49m, output_shapes)\n\u001b[1;32m   3014\u001b[0m     \u001b[39mreturn\u001b[39;00m _result\n\u001b[1;32m   3015\u001b[0m   \u001b[39mexcept\u001b[39;00m _core\u001b[39m.\u001b[39m_NotOkStatusException \u001b[39mas\u001b[39;00m e:\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "\n",
    "BATCH_SIZE=64\n",
    "LOG_INTERVAL=20\n",
    "epochs = 15\n",
    "saveModel=False\n",
    "\n",
    "\n",
    "log_dir = \"./logs/\"+model.name+\"/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")+\"_\"+SO\n",
    "tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1,\n",
    "                                                      write_graph=True, update_freq=5)\n",
    "\n",
    "\n",
    "summary_writer = tf.summary.create_file_writer(log_dir)\n",
    "\n",
    "# Instantiate an optimizer .\n",
    "# optimizer = tf.keras.optimizers.SGD(learning_rate=lr_schedule)\n",
    "# optimizer = tf.keras.optimizers.SGD(learning_rate=1e-3)\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=6e-4)\n",
    "\n",
    "# Instantiate a loss function.\n",
    "# loss_fn = tf.keras.losses.BinaryCrossentropy()\n",
    "# loss_fn = WeightedBinaryCE(np.ones(len(mlb.classes_)))\n",
    "# loss_fn = WeightedBinaryCE(labelWeightsCorr)\n",
    "# loss_fn = WeightedComboLoss(labelWeightsCorr, alpha=0.5, beta=0.5, labelSmoothing=0.05)\n",
    "loss_fn = WeightedComboLoss(labelWeightsCorr, alpha=0.5, beta=0.5)\n",
    "\n",
    "train_acc_metric = WeightedAccuracy(classWeights=labelWeightsCorr)\n",
    "train_f1_metric = WeightedF1(classWeights=labelWeightsCorr, threshold=0.5)\n",
    "train_prec = WeightedPrecision(classWeights=labelWeightsCorr)\n",
    "train_rec = WeightedRecall(classWeights=labelWeightsCorr)\n",
    "\n",
    "val_acc_metric = WeightedAccuracy(classWeights=labelWeightsCorr)\n",
    "val_f1_metric = WeightedF1(classWeights=labelWeightsCorr, threshold=0.5)\n",
    "val_prec = WeightedPrecision(classWeights=labelWeightsCorr)\n",
    "val_rec = WeightedRecall(classWeights=labelWeightsCorr)\n",
    "\n",
    "batchedDataset = dataset.batch(BATCH_SIZE, drop_remainder=False)\n",
    "batchedDatasetVal = datasetVal.batch(BATCH_SIZE, drop_remainder=False)\n",
    "\n",
    "# batchedDataset = batchedDataset.cache(os.path.join(DATA_PATH, \"datasetCache\"+SO))\n",
    "# batchedDatasetVal = batchedDatasetVal.cache(os.path.join(DATA_PATH, \"datasetCacheVal\"+SO))\n",
    "\n",
    "@tf.function()\n",
    "def trainStep(x_batch_train, y_batch_train):\n",
    "    with tf.GradientTape() as tape:\n",
    "\n",
    "        probs = model(x_batch_train, training=True) \n",
    "        loss_value = loss_fn(y_batch_train, probs)\n",
    "\n",
    "    grads = tape.gradient(loss_value, model.trainable_weights)\n",
    "    #Gradient clipping\n",
    "    # grads = [tf.clip_by_norm(g, 2.0) for g in grads]\n",
    "\n",
    "    train_acc_metric.update_state(y_batch_train, probs)\n",
    "    train_f1_metric.update_state(y_batch_train, probs)\n",
    "    train_prec.update_state(y_batch_train, probs)\n",
    "    train_rec.update_state(y_batch_train, probs)\n",
    "\n",
    "    optimizer.apply_gradients(zip(grads, model.trainable_weights)) \n",
    "    return loss_value\n",
    "\n",
    "@tf.function()\n",
    "def valStep(x_batch_val, y_batch_val):\n",
    "    valProbs = model(x_batch_val, training=False)\n",
    "    # Update val metrics\n",
    "    val_acc_metric.update_state(y_batch_val, valProbs)\n",
    "    val_f1_metric.update_state(y_batch_val, valProbs)\n",
    "    val_prec.update_state(y_batch_val, valProbs)\n",
    "    val_rec.update_state(y_batch_val, valProbs)\n",
    "\n",
    "maxStep=0\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    print(\"\\nStart of epoch %d\" % (epoch+1,))\n",
    "\n",
    "    # Iterate over the batches of the dataset.\n",
    "    for step, (x_batch_train, y_batch_train) in enumerate(batchedDataset):\n",
    "\n",
    "        loss_value =trainStep(x_batch_train,y_batch_train)\n",
    "\n",
    "        # Log \n",
    "        if step % LOG_INTERVAL == 0:\n",
    "            template = 'Epoch {}/Step {}, Loss: {:.5f}, Accuracy: {:.5f}, F1: {:.4f}, Prec: {:.4f}, Rec: {:.4f}, lr: {:.5f}'\n",
    "            print(template.format(epoch+1, step,loss_value.numpy(), \n",
    "                                    train_acc_metric.result(),train_f1_metric.result(),\n",
    "                                    train_prec.result(), train_rec.result(), optimizer.learning_rate.numpy()))\n",
    "            \n",
    "            with summary_writer.as_default():\n",
    "                tf.summary.scalar('loss', loss_value, step=maxStep*epoch+step)\n",
    "                tf.summary.scalar('accuracy', train_acc_metric.result(), step=maxStep*epoch+step)\n",
    "                tf.summary.scalar('f1', train_f1_metric.result(), step=maxStep*epoch+step)\n",
    "                tf.summary.scalar('prec', train_prec.result(), step=maxStep*epoch+step)\n",
    "                tf.summary.scalar('rec', train_rec.result(), step=maxStep*epoch+step)\n",
    "                tf.summary.scalar('learning rate', optimizer.learning_rate.numpy(), step=maxStep*epoch+step)\n",
    "                summary_writer.flush()\n",
    "\n",
    "    \n",
    "    train_acc_metric.reset_states()\n",
    "    train_f1_metric.reset_states()\n",
    "    train_prec.reset_states()\n",
    "    train_rec.reset_states()\n",
    "\n",
    "    maxStep=step\n",
    "\n",
    "    print(\"Epoch finished. Start validation\")\n",
    "    for x_batch_val, y_batch_val in batchedDatasetVal:\n",
    "        valStep(x_batch_val, y_batch_val)\n",
    "    val_acc = val_acc_metric.result()\n",
    "    val_acc_metric.reset_states()\n",
    "    val_f1 = val_f1_metric.result()\n",
    "    val_f1_metric.reset_states()\n",
    "    val_precision = val_prec.result()\n",
    "    val_prec.reset_states()\n",
    "    val_recall = val_rec.result()\n",
    "    val_rec.reset_states()\n",
    "    print(\"Validation acc: %.4f\" % (float(val_acc),))\n",
    "    print(\"Validation f1: %.4f\" % (float(val_f1),))\n",
    "    print(\"Validation precision: %.4f\" % (float(val_precision),))\n",
    "    print(\"Validation recall: %.4f\" % (float(val_recall),))\n",
    "    with summary_writer.as_default():\n",
    "        tf.summary.scalar('valAcc', float(val_acc), step=epoch)\n",
    "        tf.summary.scalar('valF1', float(val_f1), step=epoch)\n",
    "        tf.summary.scalar('valPrecision', float(val_precision), step=epoch)\n",
    "        tf.summary.scalar('valRecall', float(val_recall), step=epoch)\n",
    "        summary_writer.flush()\n",
    "    if saveModel:\n",
    "      model.save(os.path.join(DATA_PATH, \"model_\"+SO+\"_epoch_{}_valF1Score{:.3f}\".format(epoch, float(val_f1))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "374f7234",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# model.save(os.path.join(DATA_PATH, \"model_\"+SO+\"_epoch_{}_valf1Score{:.3f}\".format(epoch, float(val_f1))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cefc1f6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-27 15:01:50.530641: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'Placeholder/_0' with dtype int32\n",
      "\t [[{{node Placeholder/_0}}]]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 295ms/step\n",
      "[('GO:0005622', 'GO:0005634', 'GO:0005737', 'GO:0005829', 'GO:0005886', 'GO:0031410', 'GO:0031981', 'GO:0043226', 'GO:0043227', 'GO:0043229', 'GO:0043231', 'GO:0071944', 'GO:0110165', 'GO:0120025')]\n",
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "probs= model.predict(tf.expand_dims(list(datasetVal.take(32))[10][0], 0))\n",
    "prediction= [1 if p > 0.5 else 0 for p in probs[0]]\n",
    "probabilities= probs[probs>0.5]\n",
    "# classes = np.argwhere(prediction)\n",
    "print(mlb.inverse_transform(np.array([prediction])))\n",
    "print(probabilities)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}