2D_CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2bdebafd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numpy library for use in ...\n",
    "import numpy as np\n",
    "\n",
    "amino_acids = {\n",
    "    \"A\":0, \"R\":1, \"N\":2, \"D\":3, \"C\":4, \"Q\":5, \"E\":6, \"G\":7, \"H\":8, \"I\":9, \"L\":10, \"K\":11, \"M\":12, \"F\":13, \"P\":14, \"S\":15, \"T\":16, \"W\":17, \"Y\":18, \"V\":19\n",
    "}\n",
    "\n",
    "VHSE_descriptors = {\n",
    "    0:{\"A\":0.15, \"R\":-1.47, \"N\":-0.99, \"D\":-1.15, \"C\":0.18, \"Q\":-.96, \"E\":-1.18, \"G\":-0.2, \"H\":-0.43, \"I\":1.27, \"L\":11.36, \"K\":-1.17, \"M\":1.01, \"F\":1.52, \"P\":0.22, \"S\":-0.67, \"T\":-0.34, \"W\":1.5, \"Y\":0.61, \"V\":0.76},\n",
    "    1:{\"A\":-1.11, \"R\":1.45, \"N\":0,     \"D\":0.67, \"C\":-1.67, \"Q\":0.12, \"E\":0.4, \"G\":-1.53, \"H\":-0.25, \"I\":-0.14, \"L\":0.07, \"K\":0.7, \"M\":-0.53, \"F\":0.61, \"P\":-0.17, \"S\":-0.86, \"T\":-0.51, \"W\":2.06, \"Y\":1.6, \"V\":-0.92},\n",
    "    2:{\"A\":-1.35, \"R\":1.24, \"N\":-0.37, \"D\":-0.41, \"C\":-0.46, \"Q\":0.18, \"E\":0.1, \"G\":-2.63, \"H\":0.37, \"I\":0.3, \"L\":0.26, \"K\":0.7, \"M\":0.43, \"F\":0.96, \"P\":-0.5, \"S\":-1.07, \"T\":-0.55, \"W\":1.79, \"Y\":1.17, \"V\":0.17},\n",
    "    3:{\"A\":-0.92, \"R\":1.27, \"N\":0.69, \"D\":-0.01, \"C\":-.021, \"Q\":0.16, \"E\":0.36, \"G\":2.28, \"H\":0.19, \"I\":-1.8, \"L\":-0.8, \"K\":0.8, \"M\":0, \"F\":-0.16, \"P\":0.05, \"S\":-0.41, \"T\":-1.06, \"W\":0.75, \"Y\":0.73, \"V\":-1.91},\n",
    "    4:{\"A\":0.02, \"R\":1.55, \"N\":-0.55, \"D\":-2.68, \"C\":0, \"Q\":0.09, \"E\":-2.16, \"G\":-0.53, \"H\":0.51, \"I\":0.3, \"L\":0.22, \"K\":1.64, \"M\":0.23, \"F\":0.25, \"P\":-0.01, \"S\":-0.32, \"T\":0.01, \"W\":0.75, \"Y\":0.53, \"V\":0.22},\n",
    "    5:{\"A\":-0.91, \"R\":1.47, \"N\":0.85, \"D\":1.31, \"C\":1.2, \"Q\":0.42, \"E\":-0.17, \"G\":-1.18, \"H\":1.28, \"I\":-1.61, \"L\":-1.37, \"K\":0.67, \"M\":0.1, \"F\":0.28, \"P\":-1.43, \"S\":0.27, \"T\":-0.01, \"W\":-0.13, \"Y\":0.25, \"V\":-1.4},\n",
    "    6:{\"A\":0.36, \"R\":1.3, \"N\":0.73, \"D\":0.03, \"C\":-1.61, \"Q\":-0.2, \"E\":0.91, \"G\":2.01, \"H\":0.93, \"I\":-0.16, \"L\":0.08, \"K\":1.63, \"M\":-0.86, \"F\":-1.33, \"P\":-0.19, \"S\":-0.64, \"T\":-0.79, \"W\":-1.06, \"Y\":-0.96, \"V\":-0.24},\n",
    "    7:{\"A\":-0.48, \"R\":0.83, \"N\":-0.8, \"D\":0.56, \"C\":-0.19, \"Q\":-0.41, \"E\":0.02, \"G\":-1.34, \"H\":0.65, \"I\":-0.13, \"L\":-0.62, \"K\":0.13, \"M\":-0.68, \"F\":-0.2, \"P\":3.56, \"S\":0.11, \"T\":0.39, \"W\":-0.85, \"Y\":-0.52, \"V\":-0.03}\n",
    "}\n",
    "\n",
    "# Function info here ...\n",
    "def import_fa(file_name, return_labels=False):\n",
    "    print(\"Importing \"+file_name)\n",
    "    # List storage for file contents (sequences) and sequene labels\n",
    "    sequences = []\n",
    "    labels = []\n",
    "    num_classes = 0\n",
    "    class_counts = [0]\n",
    "    # Try to open the file as read only\n",
    "    try:\n",
    "        file = open(file_name, \"r\")\n",
    "    # If the file would not open, print error message and exit\n",
    "    except:\n",
    "        print(\"\\nError: Could not open file\")\n",
    "        print(\"File name given: \"+file_name+\"\\n\")\n",
    "        raise SystemExit\n",
    "    # Iterate over all the lines in the file\n",
    "    for line in file.readlines():\n",
    "        # If this character is at the start of the line, it is a sequence label\n",
    "        if line[0] == \">\":\n",
    "            # If the argument 'return_labels' is True, append the label to a list\n",
    "            if return_labels:\n",
    "                labels.append(str(line)[1:-1])\n",
    "            else:\n",
    "                continue\n",
    "        elif \"class\" in line:\n",
    "            class_counts.append(0)\n",
    "            num_classes += 1\n",
    "        else:\n",
    "            class_counts[num_classes] += 1\n",
    "        # Append the sequence to the list of sequences\n",
    "        sequences.append(str(line)[:-1])\n",
    "    print(\"    \"+str(num_classes)+\" classes\")\n",
    "    print(\"    \"+str(len(sequences)-num_classes)+\" sequences\")\n",
    "    print(\"    \"+str(np.array(class_counts)[1:])+\" class counts\")\n",
    "    # If the argument 'return_labels' is True, return arrays of the sequences and labels\n",
    "    if return_labels:\n",
    "        return np.array(sequences), np.array(labels)\n",
    "    # If False, only return an array of the sequences\n",
    "    else:\n",
    "        return np.array(sequences)\n",
    "\n",
    "# Function info here ...\n",
    "def raw_to_features(data,resample=1.0,balance=False):\n",
    "    print(\"\\nConverting to features:\")\n",
    "    num_VHSE = len(VHSE_descriptors)\n",
    "    num_AA = len(amino_acids)\n",
    "    num_features = num_AA + num_VHSE\n",
    "    n = len(data)\n",
    "    # Find basic data stats for function use:\n",
    "    #   the max length sequence in the data\n",
    "    #   the number of classes\n",
    "    #   count of each class\n",
    "    max_seq_len = 0\n",
    "    class_counts = [0]\n",
    "    num_classes = -1\n",
    "    # Iterate over all sequences to count num classes, class frequencies, and the max sequence length\n",
    "    for line in data:\n",
    "        # Look out for a new class\n",
    "        if \"class\" in line:\n",
    "            class_counts.append(0)\n",
    "            num_classes += 1\n",
    "            continue\n",
    "        # Skip labels\n",
    "        elif line[0] == \">\":\n",
    "            continue\n",
    "        # Update max sequence length\n",
    "        if len(line) > max_seq_len:\n",
    "            max_seq_len = len(line)\n",
    "        # Update class counts\n",
    "        class_counts[num_classes+1] += 1\n",
    "    \n",
    "    # Since this was -1 based, increment to convert to 0 based count\n",
    "    num_classes += 1\n",
    "    n -= num_classes\n",
    "    \n",
    "    # Print stats found above\n",
    "    print(\"  Num Classes:\", num_classes)\n",
    "    print(\"  Class Counts:\")\n",
    "    frmt = \"{:>7}\"*num_classes\n",
    "    print(\" \"+frmt.format(*[i for i in range(num_classes)]))\n",
    "    print(\"   \",end=\"\")\n",
    "    frmt = \"{:>7}\"*num_classes\n",
    "    print(\" \"+frmt.format(*[class_counts[i] for i in range(1,num_classes+1)]))\n",
    "\n",
    "    # Split data by class for resampling\n",
    "    data_by_class = []\n",
    "    start_idx = 1\n",
    "    end_idx = start_idx + class_counts[1]\n",
    "    for i in range(num_classes):\n",
    "        new_class = data[start_idx+1:end_idx]\n",
    "        np.random.shuffle(new_class)\n",
    "        data_by_class.append( new_class )\n",
    "        if i < num_classes-1:\n",
    "          #print(start_idx, end_idx, class_counts[i+2], class_counts)\n",
    "          start_idx += end_idx\n",
    "          end_idx = start_idx + class_counts[i+2]\n",
    "\n",
    "    #print(\"data by class:\",data_by_class)\n",
    "\n",
    "    # Init variables for resampling\n",
    "    total_per_class = 0\n",
    "    num_samples = n\n",
    "    # If resampling:\n",
    "    if resample != 1.0:\n",
    "        # Calculate the size of the resampled dataset\n",
    "        num_samples = int(n*resample)\n",
    "        # If balanced classs coutns are required:\n",
    "        if balance:\n",
    "            # Calculate a balanced total number of instances per class\n",
    "            total_per_class = int(num_samples/num_classes)\n",
    "            if total_per_class > min(np.array(class_counts)[1:]):\n",
    "                total_per_class = min(np.array(class_counts)[1:])\n",
    "            #print(\"\\ntotal/class:\", total_per_class, \"\\n\")\n",
    "            for i in range(len(data_by_class)):\n",
    "                indexes = np.random.default_rng().choice(len(data_by_class[i]), size=total_per_class-1, replace=False)\n",
    "                #print(\"idxs:\",indexes)\n",
    "                data_by_class[i] = data_by_class[i][indexes]\n",
    "            \n",
    "        # If imbalanced class counts are acceptable\n",
    "        else:\n",
    "            # Calculate the total number of instances per class in the same ratio as class counts\n",
    "            total_per_class = [int(num_samples*class_counts[i+1]/n) for i in range(num_classes)]\n",
    "            #print(\"total/class:\",total_per_class)\n",
    "            for i in range(len(data_by_class)):\n",
    "                indexes = np.random.default_rng().choice(len(data_by_class[i]), size=total_per_class[i]-1, replace=False)\n",
    "                data_by_class[i] = data_by_class[i][indexes]\n",
    "            \n",
    "        print(\"  Resampling:\")\n",
    "        print(\"    Dataset size :\",n)\n",
    "        print(\"    Total/class  :\",total_per_class)\n",
    "        print(\"    Total samples:\",total_per_class*num_classes)\n",
    "        print()\n",
    "    # If not resampling\n",
    "    # TODO:  Complete - could the above be used instead of conditional?\n",
    "    else:\n",
    "        total_per_class = int(n/num_classes)\n",
    "    \n",
    "    #print(\"data by class:\",data_by_class)\n",
    "    \n",
    "    # Instantiate storage of features and labels\n",
    "    X = []\n",
    "    y = []\n",
    "      \n",
    "    # Convert from strings to arrays and pad the sequences with zeros to \n",
    "    # the length of the maximum length sequence; this is the number of features\n",
    "    index = 0\n",
    "    for i in range(len(data_by_class)):\n",
    "        for j in range(len(data_by_class[i])):\n",
    "            # Instantiate new array of zeros\n",
    "            new_instance = []\n",
    "            for k in range(num_VHSE):\n",
    "                new_instance.append([-999 for acid in range(max_seq_len)])\n",
    "            for k in range(num_AA):\n",
    "                new_instance.append([0 for acid in range(max_seq_len)])\n",
    "            # Fill in sequence\n",
    "            for k in range(len(data_by_class[i][j])):\n",
    "                acid_char = data_by_class[i][j][k]\n",
    "                if acid_char in amino_acids:\n",
    "                    for l in range(num_VHSE):\n",
    "                        new_instance[l][k] = VHSE_descriptors[l][acid_char]\n",
    "                    new_instance[amino_acids[acid_char]+num_VHSE][k] = 1\n",
    "            # Store new sequence in features store X\n",
    "            X.append(new_instance)\n",
    "            y.append(i)\n",
    "            index += 1\n",
    "\n",
    "    # Return features and labels\n",
    "    return np.array(X),np.array(y),max_seq_len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4d5d7ed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-12-14 14:37:16.054459: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:37:16.054484: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n"
     ]
    }
   ],
   "source": [
    "# For one-hot encoding\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "# For the loss function and optimizer\n",
    "import tensorflow.keras as keras\n",
    "# For the model\n",
    "from tensorflow.keras.models import Sequential,Model\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D\n",
    "from tensorflow.keras.layers import Input, Dense, Dropout, Flatten\n",
    "from tensorflow.keras.layers import LeakyReLU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9d8b990a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Importing data/ubl_zinc.fa\n",
      "    2 classes\n",
      "    29800 sequences\n",
      "    [ 3740 26060] class counts\n",
      "\n",
      "Converting to features:\n",
      "  Num Classes: 2\n",
      "  Class Counts:\n",
      "       0      1\n",
      "       3740  26060\n",
      "  Resampling:\n",
      "    Dataset size : 29800\n",
      "    Total/class  : 3740\n",
      "    Total samples: 7480\n",
      "\n",
      "Time taken: 176.595 sec\n",
      "shape of X: (7478, 28, 5537)\n",
      "shape of y: (7478,)\n"
     ]
    }
   ],
   "source": [
    "# Import the data and extract features\n",
    "import time\n",
    "start = time.time()\n",
    "data = import_fa(\"data/ubl_zinc.fa\")\n",
    "X, y, seq_len = raw_to_features(data, resample=0.3, balance=True)\n",
    "end = time.time()\n",
    "\n",
    "print(\"Time taken:\", round(end-start,3),\"sec\")\n",
    "print(\"shape of X:\",np.shape(X))\n",
    "print(\"shape of y:\",np.shape(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d3cab548",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert y to one-hot encoding for the CNN \n",
    "y_one_hot = to_categorical(y)\n",
    "\n",
    "# Split the data into train, test, and validation\n",
    "from sklearn.model_selection import train_test_split\n",
    "X, valid_X, y_one_hot, valid_y = train_test_split(X, y_one_hot, test_size=0.2, random_state=0)\n",
    "train_X, test_X, train_y, test_y = train_test_split(X, y_one_hot, test_size=0.2, random_state=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3bc0cd2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "train_class_counts = [0,0]\n",
    "for i in range(len(y_one_hot)):\n",
    "  for j in range(len(y_one_hot[0])):\n",
    "    if y_one_hot[i][j]==1:\n",
    "      train_class_counts[j] += 1\n",
    "valid_class_counts = [0,0]\n",
    "for i in range(len(valid_y)):\n",
    "  for j in range(len(valid_y[0])):\n",
    "    if valid_y[i][j]==1:\n",
    "      valid_class_counts[j] += 1\n",
    "\n",
    "# Number of data instances\n",
    "n = len(train_X)\n",
    "# Number of features\n",
    "m = len(train_X[0])\n",
    "# Length of sequence\n",
    "o = len(train_X[0][0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5491a0e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of X      : (5982, 28, 5537)\n",
      "Shape of train_X: (4785, 28, 5537)\n",
      "Shape of valid_X: (1496, 28, 5537)\n",
      "\n",
      "Class distributions:\n",
      "  Train/Test: [3000, 2982]\n",
      "  Validation: [739, 757]\n",
      "\n",
      "n (no. train samples): 4785\n",
      "m (num features)     : 28\n",
      "o (length of seqs)   : 5537\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Print some data info\n",
    "print(\"Shape of X      :\",np.shape(X))\n",
    "print(\"Shape of train_X:\",np.shape(train_X))\n",
    "print(\"Shape of valid_X:\", np.shape(valid_X))\n",
    "print()\n",
    "print(\"Class distributions:\")\n",
    "print(\"  Train/Test:\",train_class_counts)\n",
    "print(\"  Validation:\", valid_class_counts)\n",
    "print()\n",
    "print('n (no. train samples):',n)\n",
    "print('m (num features)     :',m)\n",
    "print('o (length of seqs)   :',o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cd7e5f80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 28, 5537, 32)      2720      \n",
      "                                                                 \n",
      " leaky_re_lu (LeakyReLU)     (None, 28, 5537, 32)      0         \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 14, 2769, 32)     0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 14, 2769, 64)      6208      \n",
      "                                                                 \n",
      " leaky_re_lu_1 (LeakyReLU)   (None, 14, 2769, 64)      0         \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 7, 1385, 64)      0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 620480)            0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 2)                 1240962   \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1,249,890\n",
      "Trainable params: 1,249,890\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-12-14 14:40:18.146571: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2021-12-14 14:40:18.146898: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.146965: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.147020: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.147074: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.147131: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.147185: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.147237: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.147290: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n",
      "2021-12-14 14:40:18.147298: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n",
      "2021-12-14 14:40:18.147540: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "# Some model parameters\n",
    "batch_size = 64\n",
    "epochs = 30\n",
    "num_classes = 2\n",
    "\n",
    "# Instantiate the model\n",
    "model = Sequential()\n",
    "\n",
    "# Add layers\n",
    "model.add(Conv2D(filters=32, kernel_size=(m,3),activation='linear',input_shape=(m,o,1),padding='same'))\n",
    "model.add(LeakyReLU(alpha=0.1))\n",
    "model.add(MaxPooling2D(pool_size=2,padding='same'))\n",
    "\n",
    "model.add(Conv2D(filters=64, kernel_size=(1,3),activation='linear',padding='same'))\n",
    "model.add(LeakyReLU(alpha=0.1))\n",
    "model.add(MaxPooling2D(pool_size=2,padding='same'))\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(num_classes, activation='softmax'))\n",
    "\n",
    "# Compile the model\n",
    "# For now, this gives errors about loading the dynamic library for GPU use\n",
    "model.compile(\n",
    "    loss=keras.losses.categorical_crossentropy, \n",
    "    optimizer=keras.optimizers.Adam(),\n",
    "    metrics=['accuracy']\n",
    ")\n",
    "\n",
    "# Print a summary of the model\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "32ec3109",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-12-14 14:40:18.893031: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 2967389040 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/30\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-12-14 14:40:20.616810: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 1270054912 exceeds 10% of free system memory.\n",
      "2021-12-14 14:40:21.894234: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 1270054912 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 1/75 [..............................] - ETA: 9:15 - loss: 6.4918 - accuracy: 0.5156"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-12-14 14:40:27.799220: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 1270054912 exceeds 10% of free system memory.\n",
      "2021-12-14 14:40:29.047368: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 1270054912 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "75/75 [==============================] - 567s 8s/step - loss: 1015.3623 - accuracy: 0.5223 - val_loss: 21.6769 - val_accuracy: 0.6366\n",
      "Epoch 2/30\n",
      "75/75 [==============================] - 567s 8s/step - loss: 30.3101 - accuracy: 0.6215 - val_loss: 6.9905 - val_accuracy: 0.7126\n",
      "Epoch 3/30\n",
      "75/75 [==============================] - 567s 8s/step - loss: 13.9567 - accuracy: 0.6627 - val_loss: 22.4612 - val_accuracy: 0.5990\n",
      "Epoch 4/30\n",
      "75/75 [==============================] - 568s 8s/step - loss: 18.1798 - accuracy: 0.6349 - val_loss: 4.8116 - val_accuracy: 0.7510\n",
      "Epoch 5/30\n",
      "75/75 [==============================] - 567s 8s/step - loss: 6.9161 - accuracy: 0.7367 - val_loss: 10.3651 - val_accuracy: 0.6901\n",
      "Epoch 6/30\n",
      "75/75 [==============================] - 568s 8s/step - loss: 6.6048 - accuracy: 0.7266 - val_loss: 3.0316 - val_accuracy: 0.8154\n",
      "Epoch 7/30\n",
      "75/75 [==============================] - 568s 8s/step - loss: 2.9251 - accuracy: 0.7994 - val_loss: 1.7531 - val_accuracy: 0.8429\n",
      "Epoch 8/30\n",
      "75/75 [==============================] - 571s 8s/step - loss: 2.5842 - accuracy: 0.8054 - val_loss: 1.8933 - val_accuracy: 0.8154\n",
      "Epoch 9/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 1.6067 - accuracy: 0.8378 - val_loss: 1.2935 - val_accuracy: 0.8630\n",
      "Epoch 10/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 2.0716 - accuracy: 0.8278 - val_loss: 5.8084 - val_accuracy: 0.6433\n",
      "Epoch 11/30\n",
      "75/75 [==============================] - 579s 8s/step - loss: 2.5673 - accuracy: 0.8073 - val_loss: 4.2994 - val_accuracy: 0.6992\n",
      "Epoch 12/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 1.9331 - accuracy: 0.8336 - val_loss: 3.4662 - val_accuracy: 0.7485\n",
      "Epoch 13/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 1.8961 - accuracy: 0.8332 - val_loss: 2.1458 - val_accuracy: 0.7903\n",
      "Epoch 14/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 1.2812 - accuracy: 0.8562 - val_loss: 1.1729 - val_accuracy: 0.8262\n",
      "Epoch 15/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 1.1974 - accuracy: 0.8631 - val_loss: 1.1694 - val_accuracy: 0.8906\n",
      "Epoch 16/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 1.1384 - accuracy: 0.8619 - val_loss: 1.0370 - val_accuracy: 0.8630\n",
      "Epoch 17/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 0.7998 - accuracy: 0.8805 - val_loss: 0.9213 - val_accuracy: 0.8914\n",
      "Epoch 18/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 0.9684 - accuracy: 0.8740 - val_loss: 0.9094 - val_accuracy: 0.8605\n",
      "Epoch 19/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 0.7549 - accuracy: 0.8915 - val_loss: 0.7243 - val_accuracy: 0.8989\n",
      "Epoch 20/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 0.6622 - accuracy: 0.9011 - val_loss: 1.4502 - val_accuracy: 0.8630\n",
      "Epoch 21/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 1.0170 - accuracy: 0.8706 - val_loss: 0.7435 - val_accuracy: 0.8764\n",
      "Epoch 22/30\n",
      "75/75 [==============================] - 577s 8s/step - loss: 122.8972 - accuracy: 0.6006 - val_loss: 219.9411 - val_accuracy: 0.5196\n",
      "Epoch 23/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 94.7663 - accuracy: 0.6439 - val_loss: 8.9758 - val_accuracy: 0.8087\n",
      "Epoch 24/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 21.2215 - accuracy: 0.7302 - val_loss: 4.2488 - val_accuracy: 0.8296\n",
      "Epoch 25/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 5.5609 - accuracy: 0.8134 - val_loss: 7.6551 - val_accuracy: 0.7059\n",
      "Epoch 26/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 2.4614 - accuracy: 0.8759 - val_loss: 2.2683 - val_accuracy: 0.8864\n",
      "Epoch 27/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 2.5953 - accuracy: 0.8646 - val_loss: 1.5676 - val_accuracy: 0.8881\n",
      "Epoch 28/30\n",
      "75/75 [==============================] - 578s 8s/step - loss: 2.8230 - accuracy: 0.8612 - val_loss: 4.0680 - val_accuracy: 0.8530\n",
      "Epoch 29/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 1.5823 - accuracy: 0.8897 - val_loss: 1.0895 - val_accuracy: 0.9206\n",
      "Epoch 30/30\n",
      "75/75 [==============================] - 576s 8s/step - loss: 1.2651 - accuracy: 0.9037 - val_loss: 0.9822 - val_accuracy: 0.8981\n"
     ]
    }
   ],
   "source": [
    "# Specify log files\n",
    "#from datetime import datetime\n",
    "#logdir = \"logs/scalars/\" + datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "#tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)\n",
    "\n",
    "# Train the model\n",
    "history = model.fit(train_X, train_y, batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(test_X, test_y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e44cdb3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-12-14 19:27:32.945488: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: 21.12.13_model_ubl-zinc/assets\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Save the model\n",
    "model.save(\"21.12.13_model_ubl-zinc\")\n",
    "\n",
    "# Print some of the results\n",
    "import matplotlib.pyplot as plt\n",
    "# Loss over epochs\n",
    "plt.plot(history.history['loss'], label='Train')\n",
    "plt.plot(history.history['val_loss'], label='Test')\n",
    "plt.title('MAE')\n",
    "plt.ylabel('MAE value')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "# Accuracy over epochs\n",
    "plt.plot(history.history['accuracy'], label='Train Accuracy')\n",
    "plt.plot(history.history['val_accuracy'], label='Test Accuracy')\n",
    "plt.title('% Classification Accuracy')\n",
    "plt.ylabel('% Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "84f94e12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of validation samples: 1496\n",
      "47/47 [==============================] - 42s 899ms/step - loss: 1.3562 - accuracy: 0.8924\n",
      "[[637 102]\n",
      " [ 59 698]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of validation samples:\",len(valid_X))\n",
    "\n",
    "# Evaluate the model with the final evaluation testing set\n",
    "model.evaluate(valid_X, valid_y)\n",
    "\n",
    "# Get predictions and print confusion matrix\n",
    "results = model.predict(valid_X)\n",
    "\n",
    "predictions = np.zeros(len(results))\n",
    "observed = np.zeros(len(valid_y))\n",
    "\n",
    "threshold = 0.5\n",
    "for i in range(len(results)):\n",
    "    if results[i][0] > threshold:\n",
    "        predictions[i] = 0\n",
    "    else:\n",
    "        predictions[i] = 1\n",
    "    if valid_y[i][1] == 1:\n",
    "        observed[i] = 1\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "print( confusion_matrix(observed, predictions) )"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}