spatial_stream_cnn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7ff3c55f",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dbe10128",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import random\n",
    "import cv2\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import Model\n",
    "from tensorflow.keras.utils import plot_model\n",
    "from IPython.core.display import Image\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "from pathlib import Path\n",
    "import os\n",
    "\n",
    "from keras.layers.core import Dense,Flatten\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6f4a195c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Users\\giorg\\Desktop\\deep-learning-video-classification\n"
     ]
    }
   ],
   "source": [
    "# path dove si trova il dataframe hmdb51\n",
    "path = Path.cwd()\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4c48d39",
   "metadata": {},
   "source": [
    "Testing if cuda is on GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9bff241e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default GPU Device:/device:GPU:0\n"
     ]
    }
   ],
   "source": [
    "if tf.test.gpu_device_name(): \n",
    "    print('Default GPU Device:{}'.format(tf.test.gpu_device_name()))\n",
    "else:\n",
    "   print(\"Please install GPU version of TF\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b802b407",
   "metadata": {},
   "source": [
    "# Spatial Data Generation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "27cab245",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = './data/hmdb51'\n",
    "path_rowframes = './data/hmdb51/rawframes/'\n",
    "path_annotations = './data/hmdb51/annotations/'\n",
    "\n",
    "img_height = 224\n",
    "img_width = 224\n",
    "batch_size = 128\n",
    "num_classes = 51\n",
    "\n",
    "num_frames_desired = 17     #number of frames per clip\n",
    "type_frame = 'img'          #img / flow_x / flow_y\n",
    "epochs = 150\n",
    "# partition = 'train'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c4dc9ecb",
   "metadata": {},
   "outputs": [],
   "source": [
    "resize_and_rescale = tf.keras.Sequential([\n",
    "  # layers.Resizing(img_height, img_height),\n",
    "  tf.keras.layers.Rescaling(1./127.5, offset=-1),\n",
    "  #tf.keras.layers.Resizing(img_height, img_width)\n",
    "])\n",
    "\n",
    "resize = tf.keras.Sequential([\n",
    "  tf.keras.layers.Resizing(img_height, img_width)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a2e047eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_augmentation = tf.keras.Sequential([\n",
    "    layers.RandomFlip(\"horizontal\"),\n",
    "    layers.RandomRotation(0.20, fill_mode = \"nearest\"),\n",
    "    # layers.RandomZoom(0.2),\n",
    "    layers.RandomCrop(img_height,img_width),\n",
    "    # layers.RandomHeight(0.2),\n",
    "    # layers.RandomWidth(0.2),\n",
    "    # layers.Resizing(224,224)\n",
    "    layers.Resizing(img_height, img_width)\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8eb40a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sampling(list, num_frames_desired):\n",
    "    step = len(list) // (num_frames_desired)\n",
    "    #selected_frames = list(range(0, len(list), step))[:num_frames_desired]\n",
    "    sampled_list = list[0:len(list):step][:num_frames_desired]\n",
    "    return(sampled_list)\n",
    "\n",
    "def parse_image(filename):\n",
    "    image = tf.io.read_file(filename)\n",
    "    image = tf.image.decode_jpeg(image, channels=3)\n",
    "    # image = tf.image.random_flip_left_right(image)\n",
    "    # image = tf.image.resize(image, [img_height, img_width])\n",
    "    return image\n",
    "\n",
    "\"\"\"def configure_for_performance(ds):\n",
    "    ds = ds.cache()\n",
    "    ds = ds.shuffle(buffer_size=1000)\n",
    "    ds = ds.batch(batch_size)\n",
    "    ds = ds.repeat() # repeat determines how many times the samples can be repeated in the given dataset. (def = 0)\n",
    "    ds = ds.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\n",
    "    return ds\"\"\"\n",
    "    \n",
    "def prepare(ds, shuffle=False, augment=False):\n",
    "  # Resize and rescale all datasets.\n",
    "  ds = ds.cache()\n",
    "  ds = ds.map(lambda x, y: (resize_and_rescale(x), y), \n",
    "              num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
    "  if shuffle:\n",
    "    ds = ds.shuffle(1000)\n",
    "  if augment:\n",
    "    ds = ds.map(lambda x, y: (data_augmentation(x, training=True), y), \n",
    "                num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
    "  else: \n",
    "    ds = ds.map(lambda x, y: (resize(x), y), \n",
    "              num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
    "  # Batch all datasets.\n",
    "  ds = ds.batch(batch_size)\n",
    "  ds = ds.repeat() # repeat determines how many times the samples can be repeated in the given dataset. (def = 0)\n",
    "  # Use data augmentation only on the training set.\n",
    "  #if augment:\n",
    "  #  ds = ds.map(lambda x, y: (data_augmentation(x, training=True), y), \n",
    "  #              num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
    "  # Use buffered prefetching on all datasets.\n",
    "  return ds.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\n",
    "\n",
    "def find_paths(partition, type_frame, num_frames_desired):\n",
    "    if partition == 'train':\n",
    "        video_list = pd.read_csv(f'{path_annotations}/hmdb51_train_split_1_rawframes.txt', sep=\" \", header=None) #train\n",
    "        video_list.columns = [\"path\", \"num_frames_tot\", \"class\"]\n",
    "    elif partition == 'val':\n",
    "        video_list = pd.read_csv(f'{path_annotations}/hmdb51_val_split_1_rawframes.txt', sep=\" \", header=None) #test\n",
    "        video_list.columns = [\"path\", \"num_frames_tot\", \"class\"]\n",
    "    else:\n",
    "        raise Exception(\"invalid partition\")\n",
    "\n",
    "    #temp_path = video_list.loc[0]['path'] #da togliere!!!\n",
    "\n",
    "    paths = []\n",
    "    classes = []\n",
    "    for index, row in video_list.iterrows(): #da togliere [:1]\n",
    "        temp_path = row['path']                    #da rimuovere il commentato\n",
    "        frame_list = os.listdir(os.path.join(f'./{temp_path}'))\n",
    "\n",
    "        frame_list_type = [i for i in frame_list if i.startswith(f'{type_frame}')]\n",
    "\n",
    "        filename = sampling(frame_list_type, num_frames_desired)\n",
    "\n",
    "        paths.extend([os.path.join('.\\\\', temp_path, file) for file in filename])\n",
    "        temp = [row['class']] * num_frames_desired\n",
    "        classes.extend(temp)\n",
    "\n",
    "    #return(list(zip(paths, classes)))\n",
    "    return(list(zip(paths, classes)), video_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bb6384ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ------- create train set\n",
    "filenames, video_list = find_paths(partition='train', type_frame=type_frame, num_frames_desired=num_frames_desired)\n",
    "video_list[['cose', 'class', 'vid']] = video_list[\"path\"].str.rsplit(\"\\\\\", n = 2, expand = True)\n",
    "\n",
    "random.shuffle(filenames)\n",
    "\n",
    "zipped = [list(t) for t in zip(*filenames)]\n",
    "\n",
    "filenames = zipped[0]\n",
    "labels = zipped[1]\n",
    "\n",
    "filenames_ds = tf.data.Dataset.from_tensor_slices(filenames)\n",
    "images_ds = filenames_ds.map(parse_image, num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
    "\n",
    "labels_ds = tf.data.Dataset.from_tensor_slices(labels)\n",
    "ds = tf.data.Dataset.zip((images_ds, labels_ds))\n",
    "# train_ds = configure_for_performance(ds)\n",
    "train_ds = prepare(ds, shuffle=True, augment=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "71781ba8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60690\n"
     ]
    }
   ],
   "source": [
    "frame_number_train = len(filenames)\n",
    "print(frame_number_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "75a40fcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ------- create val test\n",
    "filenames, video_list = find_paths(partition='val', type_frame=type_frame, num_frames_desired=num_frames_desired)\n",
    "\n",
    "random.shuffle(filenames)\n",
    "\n",
    "zipped = [list(t) for t in zip(*filenames)]\n",
    "\n",
    "filenames = zipped[0]\n",
    "labels = zipped[1]\n",
    "\n",
    "filenames_ds = tf.data.Dataset.from_tensor_slices(filenames)\n",
    "images_ds = filenames_ds.map(parse_image, num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
    "labels_ds = tf.data.Dataset.from_tensor_slices(labels)\n",
    "ds = tf.data.Dataset.zip((images_ds, labels_ds))\n",
    "# val_ds = configure_for_performance(ds)\n",
    "val_ds = prepare(ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5bdd738a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26010\n"
     ]
    }
   ],
   "source": [
    "frame_number_val = len(filenames)\n",
    "print(frame_number_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dbf13314",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "474\n",
      "203\n"
     ]
    }
   ],
   "source": [
    "step_per_epoch_train = frame_number_train // batch_size\n",
    "step_per_epoch_val = frame_number_val // batch_size\n",
    "print(step_per_epoch_train)\n",
    "print(step_per_epoch_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "584c56de",
   "metadata": {},
   "source": [
    "# Spatial Stream Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "af1139c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "version = \"v4\"\n",
    "arc = \"a3\"\n",
    "\n",
    "early_stopper = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=50)\n",
    "csv_logger = tf.keras.callbacks.CSVLogger(f'./Models/spatial_stream_CNN/{version}/spatial_model_{version}_{arc}_val_acc_best.csv', append=True)\n",
    "\n",
    "checkpoint_filepath = f'./Models/spatial_stream_CNN/{version}/spatial_model_{version}_{arc}_val_acc_best.hdf5'\n",
    "model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath=checkpoint_filepath,\n",
    "    monitor='val_sparse_categorical_accuracy',\n",
    "    mode='max',\n",
    "    save_best_only=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b3abfa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "def prep_fn(img):\n",
    "    img = img / 255.0\n",
    "    img = (img - 0.5) * 2\n",
    "    return img\n",
    "\n",
    "def random_crop(img, random_crop_size):\n",
    "    # Note: image_data_format is 'channel_last'\n",
    "    assert img.shape[2] == 3\n",
    "    height, width = img.shape[0], img.shape[1]\n",
    "    dy, dx = random_crop_size\n",
    "    x = np.random.randint(0, width - dx + 1)\n",
    "    y = np.random.randint(0, height - dy + 1)\n",
    "    if width >= dy:\n",
    "        top = int((height - dy) * random.random())\n",
    "        left = int((width - dx) * random.random())\n",
    "        right = left + width\n",
    "        bottom = top + height\n",
    "    else: \n",
    "        top = int((height - dy) * random.random())\n",
    "        bottom = top + height\n",
    "        left = 0\n",
    "        right = width\n",
    "    img = img[top : bottom, left : right] \n",
    "    return img\n",
    "\n",
    "\n",
    "def crop_generator(batches, crop_length):\n",
    "    while True:\n",
    "        batch_x, batch_y = next(batches)\n",
    "        batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\n",
    "        for i in range(batch_x.shape[0]):\n",
    "            batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\n",
    "        yield (batch_crops, batch_y)\n",
    "\n",
    "train_image_generator = ImageDataGenerator(\n",
    "    preprocessing_function=prep_fn,\n",
    "    horizontal_flip=True,\n",
    "    rotation_range=20, fill_mode='nearest'\n",
    "    \n",
    ") \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "54af4cb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"data_augmentation = tf.keras.Sequential([\n",
    "    layers.RandomFlip(\"horizontal\"),\n",
    "    layers.RandomRotation(0.15),\n",
    "    # layers.RandomZoom(0.2),\n",
    "    layers.RandomCrop(224,224)\n",
    "    # layers.RandomHeight(0.2),\n",
    "    # layers.RandomWidth(0.2),\n",
    "    # layers.Resizing(224,224)\n",
    "])\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e9a260b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_classes = 51\n",
    "\n",
    "# model_spat = keras.models.Sequential(tf.keras.layers.Rescaling(1./127.5, offset=-1))\n",
    "model_spat = keras.models.Sequential()\n",
    "\n",
    "#data_augmentation\n",
    "\n",
    "model_spat.add(keras.layers.Conv2D(96, (7,7), strides = 2, input_shape=(224, 224, 3), activation = \"relu\"))\n",
    "model_spat.add(keras.layers.BatchNormalization())\n",
    "model_spat.add(keras.layers.MaxPooling2D((3,3), strides=2, padding=\"same\"))\n",
    "\n",
    "model_spat.add(keras.layers.ZeroPadding2D(padding = (1,1)))\n",
    "model_spat.add(keras.layers.Conv2D(256, (5,5), strides = 2, activation='relu'))\n",
    "model_spat.add(keras.layers.BatchNormalization())\n",
    "model_spat.add(keras.layers.MaxPooling2D((3,3), strides=2, padding=\"same\"))\n",
    "          \n",
    "model_spat.add(keras.layers.ZeroPadding2D(padding = (1,1)))\n",
    "model_spat.add(keras.layers.Conv2D(512, (3,3), strides = 1, activation='relu'))\n",
    "\n",
    "model_spat.add(keras.layers.ZeroPadding2D(padding = (1,1)))\n",
    "model_spat.add(keras.layers.Conv2D(512, (3,3), strides = 1, activation='relu'))\n",
    "\n",
    "model_spat.add(keras.layers.ZeroPadding2D(padding = (1,1)))\n",
    "model_spat.add(keras.layers.Conv2D(512, (3,3), strides = 1, activation='relu'))\n",
    "model_spat.add(keras.layers.MaxPooling2D((3,3), strides=2, padding=\"same\"))\n",
    "\n",
    "model_spat.add(keras.layers.Flatten())\n",
    "\n",
    "model_spat.add(keras.layers.Dense(2048, activation='relu'))\n",
    "model_spat.add(keras.layers.Dropout(0.5))      #valore dropout 0.5 oppure 0.9? paper li usa entrambi \n",
    "\n",
    "model_spat.add(keras.layers.Dense(1024, activation='relu'))\n",
    "model_spat.add(keras.layers.Dropout(0.5))\n",
    "\n",
    "model_spat.add(keras.layers.Dense(num_classes, activation=\"softmax\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d15246a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 109, 109, 96)      14208     \n",
      "                                                                 \n",
      " batch_normalization (BatchN  (None, 109, 109, 96)     384       \n",
      " ormalization)                                                   \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 55, 55, 96)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " zero_padding2d (ZeroPadding  (None, 57, 57, 96)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 27, 27, 256)       614656    \n",
      "                                                                 \n",
      " batch_normalization_1 (Batc  (None, 27, 27, 256)      1024      \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 14, 14, 256)      0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " zero_padding2d_1 (ZeroPaddi  (None, 16, 16, 256)      0         \n",
      " ng2D)                                                           \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 14, 14, 512)       1180160   \n",
      "                                                                 \n",
      " zero_padding2d_2 (ZeroPaddi  (None, 16, 16, 512)      0         \n",
      " ng2D)                                                           \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 14, 14, 512)       2359808   \n",
      "                                                                 \n",
      " zero_padding2d_3 (ZeroPaddi  (None, 16, 16, 512)      0         \n",
      " ng2D)                                                           \n",
      "                                                                 \n",
      " conv2d_4 (Conv2D)           (None, 14, 14, 512)       2359808   \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 7, 7, 512)        0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 25088)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 4096)              102764544 \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 4096)              0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 2048)              8390656   \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 2048)              0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 51)                104499    \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 117,789,747\n",
      "Trainable params: 117,789,043\n",
      "Non-trainable params: 704\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model_spat.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "48c12682",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# plot architettura\n",
    "plot_model(model_spat, to_file=f'./Report/Plots/spatial_stream_CNN/{version}/spatial_stream_schema{version}_{arc}.png', show_shapes=True, show_layer_names=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "36e69ae4",
   "metadata": {
    "id": "950cdb45"
   },
   "outputs": [],
   "source": [
    "#model_spat.compile(loss=keras.losses.sparse_categorical_crossentropy, metrics=['accuracy','sparse_categorical_accuracy'], \n",
    "#              optimizer=keras.optimizers.Adam(learning_rate=0.001))\n",
    "\n",
    "learning_rate = 1e-3 # -2\n",
    "momentum = 0.9\n",
    "#optimizer = keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum, nesterov=True)\n",
    "optimizer = Adam(learning_rate=learning_rate)\n",
    "\n",
    "model_spat.compile(loss=keras.losses.sparse_categorical_crossentropy, \n",
    "                   metrics=['sparse_categorical_accuracy','sparse_top_k_categorical_accuracy'], \n",
    "                   optimizer=optimizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ed9a1bc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "474\n",
      "203\n"
     ]
    }
   ],
   "source": [
    "step_per_epoch_train = frame_number_train // batch_size\n",
    "step_per_epoch_val = frame_number_val // batch_size\n",
    "print(step_per_epoch_train)\n",
    "print(step_per_epoch_val)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4fc456a9",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "34d7d98d",
    "outputId": "e39004e4-5c77-4d59-b9b7-054d2a29254f",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/150\n",
      "474/474 [==============================] - 551s 1s/step - loss: 3.6655 - sparse_categorical_accuracy: 0.0758 - sparse_top_k_categorical_accuracy: 0.2704 - val_loss: 3.6816 - val_sparse_categorical_accuracy: 0.0767 - val_sparse_top_k_categorical_accuracy: 0.2597\n",
      "Epoch 2/150\n",
      "474/474 [==============================] - 1112s 2s/step - loss: 3.1673 - sparse_categorical_accuracy: 0.1707 - sparse_top_k_categorical_accuracy: 0.4462 - val_loss: 3.7146 - val_sparse_categorical_accuracy: 0.0952 - val_sparse_top_k_categorical_accuracy: 0.3171\n",
      "Epoch 3/150\n",
      "474/474 [==============================] - 1025s 2s/step - loss: 2.7839 - sparse_categorical_accuracy: 0.2619 - sparse_top_k_categorical_accuracy: 0.5614 - val_loss: 3.9881 - val_sparse_categorical_accuracy: 0.0946 - val_sparse_top_k_categorical_accuracy: 0.2891\n",
      "Epoch 4/150\n",
      "474/474 [==============================] - 1032s 2s/step - loss: 2.4619 - sparse_categorical_accuracy: 0.3410 - sparse_top_k_categorical_accuracy: 0.6418 - val_loss: 4.0136 - val_sparse_categorical_accuracy: 0.0981 - val_sparse_top_k_categorical_accuracy: 0.3332\n",
      "Epoch 5/150\n",
      "474/474 [==============================] - 1065s 2s/step - loss: 2.2312 - sparse_categorical_accuracy: 0.3982 - sparse_top_k_categorical_accuracy: 0.6885 - val_loss: 4.3020 - val_sparse_categorical_accuracy: 0.1000 - val_sparse_top_k_categorical_accuracy: 0.3073\n",
      "Epoch 6/150\n",
      "474/474 [==============================] - 1085s 2s/step - loss: 2.0353 - sparse_categorical_accuracy: 0.4466 - sparse_top_k_categorical_accuracy: 0.7284 - val_loss: 4.4111 - val_sparse_categorical_accuracy: 0.1073 - val_sparse_top_k_categorical_accuracy: 0.3312\n",
      "Epoch 7/150\n",
      "474/474 [==============================] - 1062s 2s/step - loss: 1.8880 - sparse_categorical_accuracy: 0.4828 - sparse_top_k_categorical_accuracy: 0.7592 - val_loss: 4.3745 - val_sparse_categorical_accuracy: 0.1063 - val_sparse_top_k_categorical_accuracy: 0.3014\n",
      "Epoch 8/150\n",
      "474/474 [==============================] - 1051s 2s/step - loss: 1.7728 - sparse_categorical_accuracy: 0.5128 - sparse_top_k_categorical_accuracy: 0.7797 - val_loss: 4.4372 - val_sparse_categorical_accuracy: 0.1055 - val_sparse_top_k_categorical_accuracy: 0.3250\n",
      "Epoch 9/150\n",
      "474/474 [==============================] - 1082s 2s/step - loss: 1.6763 - sparse_categorical_accuracy: 0.5346 - sparse_top_k_categorical_accuracy: 0.7981 - val_loss: 4.3903 - val_sparse_categorical_accuracy: 0.1016 - val_sparse_top_k_categorical_accuracy: 0.3229\n",
      "Epoch 10/150\n",
      "474/474 [==============================] - 1087s 2s/step - loss: 1.5917 - sparse_categorical_accuracy: 0.5578 - sparse_top_k_categorical_accuracy: 0.8124 - val_loss: 4.4862 - val_sparse_categorical_accuracy: 0.1192 - val_sparse_top_k_categorical_accuracy: 0.3182\n",
      "Epoch 11/150\n",
      "474/474 [==============================] - 1061s 2s/step - loss: 1.5161 - sparse_categorical_accuracy: 0.5752 - sparse_top_k_categorical_accuracy: 0.8268 - val_loss: 4.6495 - val_sparse_categorical_accuracy: 0.1113 - val_sparse_top_k_categorical_accuracy: 0.3371\n",
      "Epoch 12/150\n",
      "474/474 [==============================] - 1067s 2s/step - loss: 1.4258 - sparse_categorical_accuracy: 0.5997 - sparse_top_k_categorical_accuracy: 0.8393 - val_loss: 4.7343 - val_sparse_categorical_accuracy: 0.1213 - val_sparse_top_k_categorical_accuracy: 0.3440\n",
      "Epoch 13/150\n",
      "474/474 [==============================] - 1081s 2s/step - loss: 1.3884 - sparse_categorical_accuracy: 0.6114 - sparse_top_k_categorical_accuracy: 0.8456 - val_loss: 4.6906 - val_sparse_categorical_accuracy: 0.1098 - val_sparse_top_k_categorical_accuracy: 0.3307\n",
      "Epoch 14/150\n",
      "474/474 [==============================] - 1088s 2s/step - loss: 1.3379 - sparse_categorical_accuracy: 0.6228 - sparse_top_k_categorical_accuracy: 0.8533 - val_loss: 4.8749 - val_sparse_categorical_accuracy: 0.1104 - val_sparse_top_k_categorical_accuracy: 0.3364\n",
      "Epoch 15/150\n",
      "474/474 [==============================] - 1086s 2s/step - loss: 1.3006 - sparse_categorical_accuracy: 0.6357 - sparse_top_k_categorical_accuracy: 0.8589 - val_loss: 4.7361 - val_sparse_categorical_accuracy: 0.1164 - val_sparse_top_k_categorical_accuracy: 0.3377\n",
      "Epoch 16/150\n",
      "474/474 [==============================] - 1075s 2s/step - loss: 1.2483 - sparse_categorical_accuracy: 0.6472 - sparse_top_k_categorical_accuracy: 0.8674 - val_loss: 4.9198 - val_sparse_categorical_accuracy: 0.1079 - val_sparse_top_k_categorical_accuracy: 0.3264\n",
      "Epoch 17/150\n",
      "474/474 [==============================] - 1082s 2s/step - loss: 1.2079 - sparse_categorical_accuracy: 0.6575 - sparse_top_k_categorical_accuracy: 0.8743 - val_loss: 5.1536 - val_sparse_categorical_accuracy: 0.1096 - val_sparse_top_k_categorical_accuracy: 0.3266\n",
      "Epoch 18/150\n",
      "474/474 [==============================] - 1075s 2s/step - loss: 1.1696 - sparse_categorical_accuracy: 0.6685 - sparse_top_k_categorical_accuracy: 0.8808 - val_loss: 5.3155 - val_sparse_categorical_accuracy: 0.1108 - val_sparse_top_k_categorical_accuracy: 0.3190\n",
      "Epoch 19/150\n",
      "474/474 [==============================] - 1082s 2s/step - loss: 1.1391 - sparse_categorical_accuracy: 0.6783 - sparse_top_k_categorical_accuracy: 0.8838 - val_loss: 5.0433 - val_sparse_categorical_accuracy: 0.0989 - val_sparse_top_k_categorical_accuracy: 0.3072\n",
      "Epoch 20/150\n",
      "474/474 [==============================] - 1092s 2s/step - loss: 1.1196 - sparse_categorical_accuracy: 0.6814 - sparse_top_k_categorical_accuracy: 0.8895 - val_loss: 5.1523 - val_sparse_categorical_accuracy: 0.1151 - val_sparse_top_k_categorical_accuracy: 0.3449\n",
      "Epoch 21/150\n",
      "474/474 [==============================] - 1108s 2s/step - loss: 1.0796 - sparse_categorical_accuracy: 0.6902 - sparse_top_k_categorical_accuracy: 0.8949 - val_loss: 5.1038 - val_sparse_categorical_accuracy: 0.1039 - val_sparse_top_k_categorical_accuracy: 0.3037\n",
      "Epoch 22/150\n",
      "474/474 [==============================] - 1084s 2s/step - loss: 1.0280 - sparse_categorical_accuracy: 0.7055 - sparse_top_k_categorical_accuracy: 0.9030 - val_loss: 5.2676 - val_sparse_categorical_accuracy: 0.1073 - val_sparse_top_k_categorical_accuracy: 0.3279\n",
      "Epoch 23/150\n",
      "474/474 [==============================] - 1080s 2s/step - loss: 1.0246 - sparse_categorical_accuracy: 0.7082 - sparse_top_k_categorical_accuracy: 0.9026 - val_loss: 5.2956 - val_sparse_categorical_accuracy: 0.1111 - val_sparse_top_k_categorical_accuracy: 0.3129\n",
      "Epoch 24/150\n",
      "474/474 [==============================] - 1085s 2s/step - loss: 0.9903 - sparse_categorical_accuracy: 0.7142 - sparse_top_k_categorical_accuracy: 0.9065 - val_loss: 5.5571 - val_sparse_categorical_accuracy: 0.1021 - val_sparse_top_k_categorical_accuracy: 0.3179\n",
      "Epoch 25/150\n",
      "474/474 [==============================] - 1328s 3s/step - loss: 0.9730 - sparse_categorical_accuracy: 0.7216 - sparse_top_k_categorical_accuracy: 0.9099 - val_loss: 5.3560 - val_sparse_categorical_accuracy: 0.1139 - val_sparse_top_k_categorical_accuracy: 0.3329\n",
      "Epoch 26/150\n",
      "101/474 [=====>........................] - ETA: 12:09 - loss: 0.9279 - sparse_categorical_accuracy: 0.7352 - sparse_top_k_categorical_accuracy: 0.9188"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_21456\\842284358.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m                                             \u001b[0mepochs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mepochs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m                                             \u001b[0msteps_per_epoch\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mstep_per_epoch_train\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m                                             callbacks=[model_checkpoint_callback, early_stopper])\n\u001b[0m",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\keras\\utils\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     62\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     63\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 64\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     65\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint: disable=broad-except\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m   1382\u001b[0m                 _r=1):\n\u001b[0;32m   1383\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1384\u001b[1;33m               \u001b[0mtmp_logs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1385\u001b[0m               \u001b[1;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1386\u001b[0m                 \u001b[0mcontext\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    149\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 150\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    151\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    913\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    914\u001b[0m       \u001b[1;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 915\u001b[1;33m         \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    916\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    917\u001b[0m       \u001b[0mnew_tracing_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m_call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    945\u001b[0m       \u001b[1;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    946\u001b[0m       \u001b[1;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 947\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_stateless_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pylint: disable=not-callable\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    948\u001b[0m     \u001b[1;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    949\u001b[0m       \u001b[1;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   2955\u001b[0m        filtered_flat_args) = self._maybe_define_function(args, kwargs)\n\u001b[0;32m   2956\u001b[0m     return graph_function._call_flat(\n\u001b[1;32m-> 2957\u001b[1;33m         filtered_flat_args, captured_inputs=graph_function.captured_inputs)  # pylint: disable=protected-access\n\u001b[0m\u001b[0;32m   2958\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2959\u001b[0m   \u001b[1;33m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[1;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[0;32m   1852\u001b[0m       \u001b[1;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1853\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[1;32m-> 1854\u001b[1;33m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[0;32m   1855\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[0;32m   1856\u001b[0m         \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36mcall\u001b[1;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[0;32m    502\u001b[0m               \u001b[0minputs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    503\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 504\u001b[1;33m               ctx=ctx)\n\u001b[0m\u001b[0;32m    505\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    506\u001b[0m           outputs = execute.execute_with_cancellation(\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m     53\u001b[0m     \u001b[0mctx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     54\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[1;32m---> 55\u001b[1;33m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[0;32m     56\u001b[0m   \u001b[1;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     57\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "history_cnn_spatial_stream = model_spat.fit(train_ds, \n",
    "                                            validation_data = val_ds, \n",
    "                                            validation_steps=step_per_epoch_val, \n",
    "                                            batch_size=batch_size, \n",
    "                                            epochs=epochs, \n",
    "                                            steps_per_epoch=step_per_epoch_train, \n",
    "                                            callbacks=[model_checkpoint_callback, early_stopper])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2c0f3e73",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_21456\\1080642022.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mscore\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel_spat\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mval_ds\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_size\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mstep_per_epoch_val\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Loss val:'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscore\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Sparse_categorical_accuracy:'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscore\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\keras\\utils\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     62\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     63\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 64\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     65\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint: disable=broad-except\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mevaluate\u001b[1;34m(self, x, y, batch_size, verbose, sample_weight, steps, callbacks, max_queue_size, workers, use_multiprocessing, return_dict, **kwargs)\u001b[0m\n\u001b[0;32m   1714\u001b[0m             \u001b[1;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprofiler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexperimental\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTrace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'test'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstep_num\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0m_r\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1715\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mon_test_batch_begin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1716\u001b[1;33m               \u001b[0mtmp_logs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtest_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1717\u001b[0m               \u001b[1;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1718\u001b[0m                 \u001b[0mcontext\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    149\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 150\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    151\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    913\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    914\u001b[0m       \u001b[1;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 915\u001b[1;33m         \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    916\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    917\u001b[0m       \u001b[0mnew_tracing_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m_call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    952\u001b[0m       \u001b[1;31m# In this case we have not created variables on the first call. So we can\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    953\u001b[0m       \u001b[1;31m# run the first trace but we should fail if variables are created.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 954\u001b[1;33m       \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    955\u001b[0m       \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_created_variables\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mALLOW_DYNAMIC_VARIABLE_CREATION\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    956\u001b[0m         raise ValueError(\"Creating variables on a non-first call to a function\"\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   2955\u001b[0m        filtered_flat_args) = self._maybe_define_function(args, kwargs)\n\u001b[0;32m   2956\u001b[0m     return graph_function._call_flat(\n\u001b[1;32m-> 2957\u001b[1;33m         filtered_flat_args, captured_inputs=graph_function.captured_inputs)  # pylint: disable=protected-access\n\u001b[0m\u001b[0;32m   2958\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2959\u001b[0m   \u001b[1;33m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[1;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[0;32m   1852\u001b[0m       \u001b[1;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1853\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[1;32m-> 1854\u001b[1;33m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[0;32m   1855\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[0;32m   1856\u001b[0m         \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36mcall\u001b[1;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[0;32m    502\u001b[0m               \u001b[0minputs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    503\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 504\u001b[1;33m               ctx=ctx)\n\u001b[0m\u001b[0;32m    505\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    506\u001b[0m           outputs = execute.execute_with_cancellation(\n",
      "\u001b[1;32mc:\\Users\\giorg\\Documents\\venv\\deepL37\\lib\\site-packages\\tensorflow\\python\\eager\\execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m     53\u001b[0m     \u001b[0mctx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     54\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[1;32m---> 55\u001b[1;33m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[0;32m     56\u001b[0m   \u001b[1;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     57\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "score = model_spat.evaluate(val_ds, verbose=1, batch_size = batch_size, steps=step_per_epoch_val)\n",
    "print('Loss val:', score[0])\n",
    "print('Sparse_categorical_accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c36a163",
   "metadata": {},
   "source": [
    "### History e grafici"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecc05efb",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(f'./Models/spatial_stream_CNN/{version}/spatial_stream_CNN_{version}_{arc}_epoch{epochs}_batch{batch_size}_optSDG_{learning_rate}_{momentum}.npy',\n",
    "        history_cnn_spatial_stream.history)\n",
    "#history=np.load('my_history.npy',allow_pickle='TRUE').item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "103a9286",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(history_cnn_spatial_stream.history.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9e0ffaa6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig1 = plt.gcf()\n",
    "sparse_categorical_accuracy = [0.0758, 0.1707, 0.2619, 0.3410, 0.3982, 0.4466, 0.4828, 0.5128, 0.5346, 0.5578, 0.5752, 0.5997, 0.6114, 0.6228, 0.6357, 0.6472, 0.6575, 0.6685, 0.6783, 0.6814, 0.6902, 0.7055, 0.7082, 0.7142, 0.7216]\n",
    "val_sparse_categorical_accuracy = [0.0767, 0.0952, 0.0946, 0.0981, 0.1000, 0.1073, 0.1063, 0.1055, 0.1016, 0.1192, 0.1113, 0.1213, 0.1098, 0.1104, 0.1164, 0.1079, 0.1096, 0.1108, 0.0989, 0.1151, 0.1039, 0.1073, 0.1111, 0.1021, 0.1139]\n",
    "plt.plot(sparse_categorical_accuracy)\n",
    "plt.plot(val_sparse_categorical_accuracy)\n",
    "plt.axis(ymin=0,ymax=1)\n",
    "plt.grid()\n",
    "plt.title('Sparse Categorical Accuracy')\n",
    "metric_plot = 'Accuracy'\n",
    "plt.ylabel('Sparse Categorical Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.legend(['train', 'validation'])\n",
    "plt.savefig(f'./Report/Plots/spatial_stream_CNN/{version}/spatial_stream_CNN_{version}_{arc}_epoch{epochs}_batch{batch_size}_optSDG_{learning_rate}_{momentum}_metric{metric_plot}.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17fb39ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1 = plt.gcf()\n",
    "plt.plot(history_cnn_spatial_stream.history['sparse_top_k_categorical_accuracy'])\n",
    "plt.plot(history_cnn_spatial_stream.history['val_sparse_top_k_categorical_accuracy'])\n",
    "plt.axis(ymin=0,ymax=1)\n",
    "plt.grid()\n",
    "plt.title('Sparse Top 5 Categorical Accuracy')\n",
    "metric_plot = 'Top 5 Categorical_accuracy'\n",
    "plt.ylabel('Sparse Top 5 Categorical Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.legend(['train', 'validation'])\n",
    "plt.savefig(f'./Report/Plots/spatial_stream_CNN/{version}/spatial_stream_CNN_{version}_{arc}_epoch{epochs}_batch{batch_size}_optSDG_{learning_rate}_{momentum}_metric{metric_plot}.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cb62ca4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1 = plt.gcf()\n",
    "plt.plot(history_cnn_spatial_stream.history['loss'])\n",
    "plt.plot(history_cnn_spatial_stream.history['val_loss'])\n",
    "#plt.axis(ymin=0,ymax=1)\n",
    "plt.grid()\n",
    "plt.title('Loss (sparse categorical crossentropy)')\n",
    "metric_plot = 'loss'\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.legend(['train', 'validation'])\n",
    "plt.savefig(f'./Report/Plots/spatial_stream_CNN/{version}/spatial_stream_CNN_{version}_{arc}_epoch{epochs}_batch{batch_size}_optSDG_{learning_rate}_{momentum}_metric{metric_plot}_train.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1618ed62",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(history_cnn_spatial_stream.history).plot(figsize=(8,5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "782d9c17",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_spat.save(f'./Models/spatial_stream_CNN/{version}/spatial_stream_CNN_{version}_{arc}_epoch{epochs}_batch{batch_size}_optSDG_{learning_rate}_{momentum}.h5')\n",
    "# model_mot.save_weights('./Models/model_mot_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceef9dc9",
   "metadata": {},
   "source": [
    "### Modello Migliore Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "059504f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "best_model_motion = keras.models.load_model(f'./Models/spatial_stream_CNN/{version}/spatial_model_{version}_{arc}_val_acc_best.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c78f5621",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "203/203 [==============================] - 257s 1s/step - loss: 4.7343 - sparse_categorical_accuracy: 0.1213 - sparse_top_k_categorical_accuracy: 0.3440\n"
     ]
    }
   ],
   "source": [
    "score = best_model_motion.evaluate(val_ds, verbose=1, batch_size = batch_size, steps=step_per_epoch_val)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "DataExploration.ipynb",
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3.7.9 ('deepL37')",
   "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.7.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "5f73b1806a9ec290aebb7f16dd5394fd2c9a0b8bec90a8791426b7ef5a3d9604"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}