diff --git a/ConfusionMatrixAcc.png b/ConfusionMatrixAcc.png
new file mode 100644
index 0000000000000000000000000000000000000000..f9589c8d3e0b809363f5de3a21e6452169a9507c
Binary files /dev/null and b/ConfusionMatrixAcc.png differ
diff --git a/ResNeXt-101-32x8d.ipynb b/ResNeXt-101-32x8d.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..799cd6ef93d674e49e8c55dfbc9d6623265574f6
--- /dev/null
+++ b/ResNeXt-101-32x8d.ipynb
@@ -0,0 +1,1927 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "17767f9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "import torchvision\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import torch.optim as optim\n",
+ "import os\n",
+ "from distutils.version import LooseVersion as Version\n",
+ "from itertools import product\n",
+ "from helper_evaluation import set_all_seeds, set_deterministic, compute_confusion_matrix\n",
+ "from helper_plotting import plot_training_loss, plot_accuracy, show_examples, plot_confusion_matrix\n",
+ "import torchvision.models as models"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "d01df462",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "net = models.resnext101_32x8d()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "754cb9a3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "net.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d2b4c59",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "net.fc = nn.Linear(in_features=2048, out_features=3, bias=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "f0f91921",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "net.aux_logits=False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "fd36529f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "ResNet(\n",
+ " (conv1): Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+ " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+ " (layer1): Sequential(\n",
+ " (0): Bottleneck(\n",
+ " (conv1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " (downsample): Sequential(\n",
+ " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " )\n",
+ " (1): Bottleneck(\n",
+ " (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (2): Bottleneck(\n",
+ " (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " (layer2): Sequential(\n",
+ " (0): Bottleneck(\n",
+ " (conv1): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " (downsample): Sequential(\n",
+ " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+ " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " )\n",
+ " (1): Bottleneck(\n",
+ " (conv1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (2): Bottleneck(\n",
+ " (conv1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (3): Bottleneck(\n",
+ " (conv1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " (layer3): Sequential(\n",
+ " (0): Bottleneck(\n",
+ " (conv1): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " (downsample): Sequential(\n",
+ " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+ " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " )\n",
+ " (1): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (2): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (3): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (4): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (5): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (6): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (7): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (8): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (9): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (10): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (11): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (12): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (13): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (14): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (15): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (16): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (17): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (18): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (19): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (20): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (21): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (22): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " (layer4): Sequential(\n",
+ " (0): Bottleneck(\n",
+ " (conv1): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " (downsample): Sequential(\n",
+ " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+ " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " )\n",
+ " (1): Bottleneck(\n",
+ " (conv1): Conv2d(2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " (2): Bottleneck(\n",
+ " (conv1): Conv2d(2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv2): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n",
+ " (bn2): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (conv3): Conv2d(2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
+ " (fc): Linear(in_features=2048, out_features=3, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "net"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "35ed82d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if torch.cuda.is_available():\n",
+ " net = net.cuda()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "9039d0ba",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "criterion = nn.CrossEntropyLoss()\n",
+ "optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "82f5a0c9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torchvision import datasets, transforms\n",
+ "from torch.utils.data import DataLoader, random_split"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "25136ecd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def UploadData(path, train):\n",
+ " #set up transforms for train and test datasets\n",
+ " train_transforms = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize(512), transforms.CenterCrop(511), transforms.RandomRotation(30),transforms.RandomHorizontalFlip(), transforms.transforms.ToTensor()]) \n",
+ " valid_transforms = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize(512), transforms.CenterCrop(511), transforms.transforms.ToTensor()]) \n",
+ " #test_transforms = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize(512), transforms.CenterCrop(511), transforms.ToTensor()])\n",
+ " \n",
+ " #set up datasets from Image Folders\n",
+ " train_dataset = datasets.ImageFolder(path + '/train', transform=train_transforms)\n",
+ " valid_dataset = datasets.ImageFolder(path + '/validation', transform=valid_transforms)\n",
+ " #test_dataset = datasets.ImageFolder(path + '/test', transform=test_transforms)\n",
+ "\n",
+ " #set up dataloaders with batch size of 32\n",
+ " trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=1, shuffle=True)\n",
+ " validloader = torch.utils.data.DataLoader(valid_dataset, batch_size=1, shuffle=True)\n",
+ " #testloader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=True)\n",
+ " \n",
+ " return trainloader, validloader #, testloader"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "36c1e09d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trainloader, validloader = UploadData(\"D:/DATASET/CXR_Covid-19_Challenge\", True) #, testloader"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "291f8643",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'covid': 0, 'normal': 1, 'pneumonia': 2}"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "trainloader.dataset.class_to_idx"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "8955b17d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class_dict = {0: 'covid',\n",
+ " 1: 'normal',\n",
+ " 2: 'pneumonia',\n",
+ " }\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "b1234549",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "from tqdm import tqdm\n",
+ "from playsound import playsound\n",
+ "def convert(seconds):\n",
+ " return time.strftime(\"%H:%M:%S\", time.gmtime(seconds))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "9e3b169f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#net.load_state_dict(torch.load(\"/home/user/research/resnet18/resent_model_100_e.pth\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "c0cb959e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "f1 = open(\"loss_train.txt\",\"r\")\n",
+ "f2 = open(\"loss_valid.txt\",\"r\")\n",
+ "f3 = open(\"acc_train.txt\",\"r\")\n",
+ "f4 = open(\"acc_valid.txt\",\"r\")\n",
+ "loss_train_list = list(map(float,f1.read().split(\",\")[:-1]))\n",
+ "loss_valid_list = list(map(float,f2.read().split(\",\")[:-1]))\n",
+ "acc_train_list = list(map(float,f3.read().split(\",\")[:-1]))\n",
+ "acc_valid_list = list(map(float,f4.read().split(\",\")[:-1]))\n",
+ "f1.close()\n",
+ "f2.close()\n",
+ "f3.close()\n",
+ "f4.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "ec8191c8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "100\n",
+ "100\n",
+ "100\n",
+ "100\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(len(loss_train_list))\n",
+ "print(len(loss_valid_list))\n",
+ "print(len(acc_train_list))\n",
+ "print(len(acc_valid_list))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "dbc639ac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "min_valid_loss = 672.7049195090892"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "963b21cf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "max_valid_acc = 93.26923370361328"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "f4740bf5",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<All keys matched successfully>"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "net.load_state_dict(torch.load(\"ResNeXt-101-32x8d_accmodel_weights_temp.pth\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "4de4f21c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:26:20<00:00, 3.47it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:03<00:00, 11.31it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 51 \tTraining Loss: 0.12465473153218823 \tValidation Loss: 0.2977102491172977 \t time: 01:31:23\n",
+ "Train Accuracy : 95.64539337158203 \tValidation Accuracy : 90.90909576416016\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:32:37<00:00, 3.23it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:32<00:00, 10.32it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 52 \tTraining Loss: 0.12458281043755953 \tValidation Loss: 0.24426537342271099 \t time: 01:38:10\n",
+ "Train Accuracy : 95.47276306152344 \tValidation Accuracy : 91.84149169921875\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:57<00:00, 3.15it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:36<00:00, 10.21it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 53 \tTraining Loss: 0.12583701085459417 \tValidation Loss: 0.2006746857402278 \t time: 01:40:34\n",
+ "Train Accuracy : 95.52845001220703 \tValidation Accuracy : 92.365966796875\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:35:30<00:00, 3.13it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:48<00:00, 9.84it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 54 \tTraining Loss: 0.12078126396844543 \tValidation Loss: 0.23114277685680634 \t time: 01:41:18\n",
+ "Train Accuracy : 95.52845001220703 \tValidation Accuracy : 92.5407943725586\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:36:34<00:00, 3.10it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:44<00:00, 9.96it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 55 \tTraining Loss: 0.11752649889293526 \tValidation Loss: 0.24057136845139254 \t time: 01:42:19\n",
+ "Train Accuracy : 95.82915496826172 \tValidation Accuracy : 91.4918441772461\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:35<00:00, 3.16it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:38<00:00, 10.13it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 56 \tTraining Loss: 0.11277882383394554 \tValidation Loss: 0.21746990292304813 \t time: 01:40:14\n",
+ "Train Accuracy : 96.04632568359375 \tValidation Accuracy : 92.1620101928711\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:35:53<00:00, 3.12it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:33<00:00, 10.29it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 57 \tTraining Loss: 0.11948975813920147 \tValidation Loss: 0.2862748984602406 \t time: 01:41:26\n",
+ "Train Accuracy : 95.71778106689453 \tValidation Accuracy : 90.67599487304688\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:35:36<00:00, 3.13it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:39<00:00, 10.11it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 58 \tTraining Loss: 0.10928025554048873 \tValidation Loss: 0.3233131564010586 \t time: 01:41:15\n",
+ "Train Accuracy : 95.99620819091797 \tValidation Accuracy : 90.4428939819336\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:35:23<00:00, 3.14it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:38<00:00, 10.13it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 59 \tTraining Loss: 0.1101513097995423 \tValidation Loss: 0.21627007317376498 \t time: 01:41:01\n",
+ "Train Accuracy : 95.99620819091797 \tValidation Accuracy : 92.62820434570312\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:32:24<00:00, 3.24it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:36<00:00, 10.20it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 60 \tTraining Loss: 0.1072427072874185 \tValidation Loss: 0.25643430890566415 \t time: 01:38:01\n",
+ "Train Accuracy : 96.03518676757812 \tValidation Accuracy : 92.30769348144531\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:36:34<00:00, 3.10it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:47<00:00, 9.88it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 61 \tTraining Loss: 0.10498023688244645 \tValidation Loss: 0.20945875643086684 \t time: 01:42:22\n",
+ "Train Accuracy : 96.30805206298828 \tValidation Accuracy : 92.65734100341797\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:32:29<00:00, 3.24it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:42<00:00, 10.02it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 62 \tTraining Loss: 0.10462284573691344 \tValidation Loss: 0.21245421723172994 \t time: 01:38:11\n",
+ "Train Accuracy : 96.34146118164062 \tValidation Accuracy : 92.74475860595703\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:30:27<00:00, 3.31it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:34<00:00, 10.26it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 63 \tTraining Loss: 0.09872543376594212 \tValidation Loss: 0.2148629846910652 \t time: 01:36:01\n",
+ "Train Accuracy : 96.42498779296875 \tValidation Accuracy : 92.77389526367188\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:33:09<00:00, 3.21it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:29<00:00, 10.40it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 64 \tTraining Loss: 0.09820417331192464 \tValidation Loss: 0.3243163596621455 \t time: 01:38:39\n",
+ "Train Accuracy : 96.55863189697266 \tValidation Accuracy : 91.28787994384766\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:31:29<00:00, 3.27it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:06<00:00, 11.19it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 65 \tTraining Loss: 0.09795922332438017 \tValidation Loss: 0.2702059426412549 \t time: 01:36:36\n",
+ "Train Accuracy : 96.39714813232422 \tValidation Accuracy : 91.66667175292969\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:25:34<00:00, 3.50it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:00<00:00, 11.41it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 66 \tTraining Loss: 0.09609485179876395 \tValidation Loss: 0.22482439400996804 \t time: 01:30:35\n",
+ "Train Accuracy : 96.5196533203125 \tValidation Accuracy : 92.45338439941406\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:26:31<00:00, 3.46it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:00<00:00, 11.42it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 67 \tTraining Loss: 0.09263355523182513 \tValidation Loss: 0.3511400450086041 \t time: 01:31:32\n",
+ "Train Accuracy : 96.6532974243164 \tValidation Accuracy : 90.26806640625\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:30:54<00:00, 3.29it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:48<00:00, 9.84it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 68 \tTraining Loss: 0.09505591612271555 \tValidation Loss: 0.2190237346490954 \t time: 01:36:43\n",
+ "Train Accuracy : 96.56977081298828 \tValidation Accuracy : 93.12354278564453\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:31<00:00, 3.17it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:35<00:00, 10.22it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 69 \tTraining Loss: 0.09501890058573212 \tValidation Loss: 0.237628198885936 \t time: 01:40:08\n",
+ "Train Accuracy : 96.56420135498047 \tValidation Accuracy : 92.56993103027344\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:35:07<00:00, 3.15it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:38<00:00, 10.13it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 70 \tTraining Loss: 0.08970765910222754 \tValidation Loss: 0.2264831099950734 \t time: 01:40:45\n",
+ "Train Accuracy : 96.88160705566406 \tValidation Accuracy : 93.0361328125\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:33:10<00:00, 3.21it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:36<00:00, 10.19it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 71 \tTraining Loss: 0.09018740322434292 \tValidation Loss: 0.2079608070881265 \t time: 01:38:49\n",
+ "Train Accuracy : 96.70341491699219 \tValidation Accuracy : 93.29837036132812\n",
+ "Validation Accuracy Increased ( 93.26923370361328 ---> 93.29837036132812 ) \t Saving The Model\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:33:42<00:00, 3.19it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:31<00:00, 10.34it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 72 \tTraining Loss: 0.08239734819780702 \tValidation Loss: 0.22216346640058174 \t time: 01:39:14\n",
+ "Train Accuracy : 96.96514129638672 \tValidation Accuracy : 93.00699615478516\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:35:00<00:00, 3.15it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:32<00:00, 10.32it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 73 \tTraining Loss: 0.08362456638444654 \tValidation Loss: 0.28239475783906615 \t time: 01:40:33\n",
+ "Train Accuracy : 97.06536865234375 \tValidation Accuracy : 92.10372924804688\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:45<00:00, 3.16it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:37<00:00, 10.17it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 74 \tTraining Loss: 0.08102248205369815 \tValidation Loss: 0.26418044798666174 \t time: 01:40:22\n",
+ "Train Accuracy : 97.1600341796875 \tValidation Accuracy : 92.51165771484375\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:15<00:00, 3.18it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:36<00:00, 10.20it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 75 \tTraining Loss: 0.08001411776692194 \tValidation Loss: 0.22620331011669226 \t time: 01:39:52\n",
+ "Train Accuracy : 97.18231201171875 \tValidation Accuracy : 92.45338439941406\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:36:55<00:00, 3.09it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:21<00:00, 10.66it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 76 \tTraining Loss: 0.07598924971602479 \tValidation Loss: 0.27000583141857226 \t time: 01:42:17\n",
+ "Train Accuracy : 97.41619110107422 \tValidation Accuracy : 91.9871826171875\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:28:40<00:00, 3.38it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:34<00:00, 10.27it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 77 \tTraining Loss: 0.07733592949135287 \tValidation Loss: 0.251588890947167 \t time: 01:34:14\n",
+ "Train Accuracy : 97.29368591308594 \tValidation Accuracy : 92.83216857910156\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:36:33<00:00, 3.10it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:47<00:00, 9.86it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 78 \tTraining Loss: 0.07399454910434476 \tValidation Loss: 0.27754054779393544 \t time: 01:42:23\n",
+ "Train Accuracy : 97.34379577636719 \tValidation Accuracy : 92.71562194824219\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:41<00:00, 3.16it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:57<00:00, 9.61it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 79 \tTraining Loss: 0.07457704520987171 \tValidation Loss: 0.2323013670180305 \t time: 01:40:38\n",
+ "Train Accuracy : 97.44960021972656 \tValidation Accuracy : 93.32750701904297\n",
+ "Validation Accuracy Increased ( 93.29837036132812 ---> 93.32750701904297 ) \t Saving The Model\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:39<00:00, 3.03it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [06:01<00:00, 9.48it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 80 \tTraining Loss: 0.07125280350744331 \tValidation Loss: 0.23997898969221185 \t time: 01:44:41\n",
+ "Train Accuracy : 97.43289947509766 \tValidation Accuracy : 92.62820434570312\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:58<00:00, 3.02it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [06:13<00:00, 9.18it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 81 \tTraining Loss: 0.07192173151721275 \tValidation Loss: 0.23554573422305 \t time: 01:45:12\n",
+ "Train Accuracy : 97.29368591308594 \tValidation Accuracy : 93.12354278564453\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:39:56<00:00, 2.99it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [06:10<00:00, 9.27it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 82 \tTraining Loss: 0.06847493004207773 \tValidation Loss: 0.22967168733962653 \t time: 01:46:06\n",
+ "Train Accuracy : 97.51642608642578 \tValidation Accuracy : 93.12354278564453\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:45<00:00, 3.03it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:58<00:00, 9.56it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 83 \tTraining Loss: 0.06685938147717393 \tValidation Loss: 0.2951450040759133 \t time: 01:44:44\n",
+ "Train Accuracy : 97.57767486572266 \tValidation Accuracy : 92.04545593261719\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:52<00:00, 3.03it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [06:02<00:00, 9.48it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 84 \tTraining Loss: 0.06471119520416692 \tValidation Loss: 0.27707491707843634 \t time: 01:44:54\n",
+ "Train Accuracy : 97.68347930908203 \tValidation Accuracy : 92.42424774169922\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:33:36<00:00, 3.20it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:56<00:00, 9.63it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 85 \tTraining Loss: 0.06485769636863178 \tValidation Loss: 0.26122983316212023 \t time: 01:39:33\n",
+ "Train Accuracy : 97.64450073242188 \tValidation Accuracy : 92.45338439941406\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:39:13<00:00, 3.02it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [06:07<00:00, 9.33it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 86 \tTraining Loss: 0.06418363091737304 \tValidation Loss: 0.29838124849108816 \t time: 01:45:21\n",
+ "Train Accuracy : 97.72802734375 \tValidation Accuracy : 92.42424774169922\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:04<00:00, 3.18it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:52<00:00, 9.74it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 87 \tTraining Loss: 0.061524608360768104 \tValidation Loss: 0.2648963750311954 \t time: 01:39:56\n",
+ "Train Accuracy : 97.75030517578125 \tValidation Accuracy : 92.65734100341797\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:35<00:00, 3.04it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [06:10<00:00, 9.27it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 88 \tTraining Loss: 0.06058979770634497 \tValidation Loss: 0.3295398499295751 \t time: 01:44:45\n",
+ "Train Accuracy : 97.75587463378906 \tValidation Accuracy : 91.8123550415039\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:32:53<00:00, 3.22it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [06:02<00:00, 9.48it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 89 \tTraining Loss: 0.06585391181688098 \tValidation Loss: 0.23902215037268257 \t time: 01:38:55\n",
+ "Train Accuracy : 97.71688842773438 \tValidation Accuracy : 92.94872283935547\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:32<00:00, 3.17it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:38<00:00, 10.13it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 90 \tTraining Loss: 0.055028726398643424 \tValidation Loss: 0.286649247088852 \t time: 01:40:11\n",
+ "Train Accuracy : 98.02316284179688 \tValidation Accuracy : 93.12354278564453\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:13<00:00, 3.05it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:52<00:00, 9.73it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 91 \tTraining Loss: 0.05975194464160974 \tValidation Loss: 0.35882579068839787 \t time: 01:44:05\n",
+ "Train Accuracy : 97.81712341308594 \tValidation Accuracy : 90.53030395507812\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:37:26<00:00, 3.07it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:43<00:00, 9.98it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 92 \tTraining Loss: 0.0599008649223611 \tValidation Loss: 0.25900215703982915 \t time: 01:43:10\n",
+ "Train Accuracy : 97.87281036376953 \tValidation Accuracy : 93.35664367675781\n",
+ "Validation Accuracy Increased ( 93.32750701904297 ---> 93.35664367675781 ) \t Saving The Model\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:06<00:00, 3.18it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:22<00:00, 10.65it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 93 \tTraining Loss: 0.05709496795508489 \tValidation Loss: 0.2705009880293762 \t time: 01:39:28\n",
+ "Train Accuracy : 97.98418426513672 \tValidation Accuracy : 93.61888122558594\n",
+ "Validation Accuracy Increased ( 93.35664367675781 ---> 93.61888122558594 ) \t Saving The Model\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:33:20<00:00, 3.21it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:45<00:00, 9.92it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 94 \tTraining Loss: 0.05766486765136572 \tValidation Loss: 0.2565385557600787 \t time: 01:39:06\n",
+ "Train Accuracy : 97.8616714477539 \tValidation Accuracy : 93.5314712524414\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:11<00:00, 3.05it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:50<00:00, 9.79it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 95 \tTraining Loss: 0.054930648156863174 \tValidation Loss: 0.31085957835092326 \t time: 01:44:02\n",
+ "Train Accuracy : 98.01759338378906 \tValidation Accuracy : 92.97785949707031\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:38<00:00, 3.03it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:50<00:00, 9.80it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 96 \tTraining Loss: 0.05127397875899723 \tValidation Loss: 0.27991100824806486 \t time: 01:44:29\n",
+ "Train Accuracy : 98.09555053710938 \tValidation Accuracy : 92.365966796875\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:49<00:00, 3.03it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:50<00:00, 9.79it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 97 \tTraining Loss: 0.05242086741305976 \tValidation Loss: 0.23991687505220038 \t time: 01:44:39\n",
+ "Train Accuracy : 98.07884979248047 \tValidation Accuracy : 93.61888122558594\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:38:56<00:00, 3.03it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:51<00:00, 9.76it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 98 \tTraining Loss: 0.050860148066809725 \tValidation Loss: 0.26092023393313396 \t time: 01:44:48\n",
+ "Train Accuracy : 98.21249389648438 \tValidation Accuracy : 93.38578033447266\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:35:15<00:00, 3.14it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:43<00:00, 9.99it/s]\n",
+ " 0%| | 0/17958 [00:00<?, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 99 \tTraining Loss: 0.04951858215308075 \tValidation Loss: 0.2572366293034437 \t time: 01:40:59\n",
+ "Train Accuracy : 98.19021606445312 \tValidation Accuracy : 93.26923370361328\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████| 17958/17958 [1:34:48<00:00, 3.16it/s]\n",
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [05:31<00:00, 10.35it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 100 \tTraining Loss: 0.04919409598988188 \tValidation Loss: 0.28010848450492276 \t time: 01:40:20\n",
+ "Train Accuracy : 98.17908477783203 \tValidation Accuracy : 93.706298828125\n",
+ "Validation Accuracy Increased ( 93.61888122558594 ---> 93.706298828125 ) \t Saving The Model\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ " Error 263 for command:\n",
+ " open C:/Users/mrper/Documents/research/audio\n",
+ " The specified device is not open or is not recognized by MCI.\n",
+ "\n",
+ " Error 263 for command:\n",
+ " close C:/Users/mrper/Documents/research/audio\n",
+ " The specified device is not open or is not recognized by MCI.\n",
+ "Failed to close the file: C:/Users/mrper/Documents/research/audio\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "total time : 11:45:33\n"
+ ]
+ },
+ {
+ "ename": "PlaysoundException",
+ "evalue": "\n Error 263 for command:\n open C:/Users/mrper/Documents/research/audio\n The specified device is not open or is not recognized by MCI.",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mPlaysoundException\u001b[0m Traceback (most recent call last)",
+ "\u001b[1;32m<ipython-input-21-efb6aaf1c8f1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m 113\u001b[0m \u001b[1;32mbreak\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 114\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"total time : \"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mconvert\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mtotal_time\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--> 115\u001b[1;33m \u001b[0mplaysound\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'C:/Users/mrper/Documents/research/audio'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[1;32mD:\\ProgramData\\lib\\site-packages\\playsound.py\u001b[0m in \u001b[0;36m_playsoundWin\u001b[1;34m(sound, block)\u001b[0m\n\u001b[0;32m 70\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[0;32m 71\u001b[0m \u001b[0mlogger\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Starting'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 72\u001b[1;33m \u001b[0mwinCommand\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mu'open {}'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msound\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[0m\u001b[0;32m 73\u001b[0m \u001b[0mwinCommand\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mu'play {}{}'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msound\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m' wait'\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mblock\u001b[0m \u001b[1;32melse\u001b[0m \u001b[1;34m''\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 74\u001b[0m \u001b[0mlogger\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Returning'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+ "\u001b[1;32mD:\\ProgramData\\lib\\site-packages\\playsound.py\u001b[0m in \u001b[0;36mwinCommand\u001b[1;34m(*command)\u001b[0m\n\u001b[0;32m 62\u001b[0m '\\n ' + errorBuffer.raw.decode('utf-16').rstrip('\\0'))\n\u001b[0;32m 63\u001b[0m \u001b[0mlogger\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0merror\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mexceptionMessage\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;32mraise\u001b[0m \u001b[0mPlaysoundException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mexceptionMessage\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;32mreturn\u001b[0m \u001b[0mbuf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 66\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
+ "\u001b[1;31mPlaysoundException\u001b[0m: \n Error 263 for command:\n open C:/Users/mrper/Documents/research/audio\n The specified device is not open or is not recognized by MCI."
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# loss_train_list = []\n",
+ "# loss_valid_list = []\n",
+ "# acc_train_list = []\n",
+ "# acc_valid_list = []\n",
+ "\n",
+ "epochs = 50\n",
+ "total_time = time.time()\n",
+ "for e in range(epochs):\n",
+ " start_time=time.time()\n",
+ " train_loss = 0.0\n",
+ " right_train = 0\n",
+ " total_train = 0\n",
+ " for data, labels in tqdm(trainloader):\n",
+ " # Transfer Data to GPU if available\n",
+ " if torch.cuda.is_available():\n",
+ " data, labels = data.cuda(), labels.cuda()\n",
+ " \n",
+ " # Clear the gradients\n",
+ " optimizer.zero_grad()\n",
+ " net.train()\n",
+ " # Forward Pass\n",
+ " target = net(data)\n",
+ " _, predicted = torch.max(target, 1)\n",
+ " # Find the Loss\n",
+ " loss = criterion(target,labels)\n",
+ " # Calculate gradients\n",
+ " loss.backward()\n",
+ " # Update Weights\n",
+ " optimizer.step()\n",
+ " # Calculate Loss\n",
+ " train_loss += loss.item()\n",
+ " correct = (predicted == labels).float().sum()\n",
+ " right_train+=correct.float()\n",
+ " total_train+=len(predicted)\n",
+ " \n",
+ " valid_loss = 0.0\n",
+ " right_valid = 0\n",
+ " total_valid = 0\n",
+ " #net.eval() # Optional when not using Model Specific layer\n",
+ " all_targets, all_predictions = [], []\n",
+ " for data, labels in tqdm(validloader):\n",
+ " # Transfer Data to GPU if available\n",
+ " if torch.cuda.is_available():\n",
+ " data, labels = data.cuda(), labels.cuda()\n",
+ " \n",
+ " # Forward Pass\n",
+ " target = net(data)\n",
+ " _, predicted = torch.max(target, 1)\n",
+ " # Find the Loss\n",
+ " loss = criterion(target,labels)\n",
+ " # Calculate Loss\n",
+ " valid_loss += loss.item()\n",
+ " correct = (predicted == labels).float().sum()\n",
+ " right_valid+=correct.float()\n",
+ " total_valid+=len(predicted)\n",
+ " all_targets.extend(labels.to('cpu'))\n",
+ " all_predictions.extend(predicted.to('cpu'))\n",
+ " ftloss = train_loss / len(trainloader)\n",
+ " fvloss = valid_loss / len(validloader)\n",
+ " ftacc = float(right_train*100/total_train)\n",
+ " fvacc = float(right_valid*100/total_valid)\n",
+ " loss_train_list.append(ftloss)\n",
+ " loss_valid_list.append(fvloss)\n",
+ " acc_train_list.append(ftacc)\n",
+ " acc_valid_list.append(fvacc)\n",
+ " print('Epoch',e+101, '\\tTraining Loss:',ftloss,'\\tValidation Loss:',fvloss,\"\\t time:\",convert(time.time()-start_time))\n",
+ " print(\"Train Accuracy :\",ftacc,\"\\tValidation Accuracy :\",fvacc)\n",
+ " if (min_valid_loss > valid_loss):\n",
+ " print(\"Validation Loss Decreased (\",min_valid_loss,\"--->\",valid_loss,\") \\t Saving The Model\")\n",
+ " min_valid_loss = valid_loss\n",
+ " all_predictions = np.array(all_predictions)\n",
+ " all_targets = np.array(all_targets)\n",
+ " class_labels = np.unique(np.concatenate((all_targets, all_predictions)))\n",
+ " if class_labels.shape[0] == 1:\n",
+ " if class_labels[0] != 0:\n",
+ " class_labels = np.array([0, class_labels[0]])\n",
+ " else:\n",
+ " class_labels = np.array([class_labels[0], 1])\n",
+ " n_labels = class_labels.shape[0]\n",
+ " lst = []\n",
+ " z = list(zip(all_targets, all_predictions))\n",
+ " for combi in product(class_labels, repeat=2):\n",
+ " lst.append(z.count(combi))\n",
+ " mat = np.asarray(lst)[:, None].reshape(n_labels, n_labels)\n",
+ " plot_confusion_matrix(mat, class_names=class_dict.values())\n",
+ " plt.savefig(\"ConfusionMatrixLoss.png\")\n",
+ " # Saving State Dict\n",
+ " torch.save(net.state_dict(), 'ResNeXt-101-32x8d_lossmodel_weights.pth')\n",
+ " torch.save(net,\"ResNeXt-101-32x8d_lossmodel.pt\")\n",
+ " if (max_valid_acc < fvacc):\n",
+ " print(\"Validation Accuracy Increased (\",max_valid_acc,\"--->\",fvacc,\") \\t Saving The Model\")\n",
+ " max_valid_acc = fvacc\n",
+ " all_predictions = np.array(all_predictions)\n",
+ " all_targets = np.array(all_targets)\n",
+ " class_labels = np.unique(np.concatenate((all_targets, all_predictions)))\n",
+ " if class_labels.shape[0] == 1:\n",
+ " if class_labels[0] != 0:\n",
+ " class_labels = np.array([0, class_labels[0]])\n",
+ " else:\n",
+ " class_labels = np.array([class_labels[0], 1])\n",
+ " n_labels = class_labels.shape[0]\n",
+ " lst = []\n",
+ " z = list(zip(all_targets, all_predictions))\n",
+ " for combi in product(class_labels, repeat=2):\n",
+ " lst.append(z.count(combi))\n",
+ " mat = np.asarray(lst)[:, None].reshape(n_labels, n_labels)\n",
+ " plot_confusion_matrix(mat, class_names=class_dict.values())\n",
+ " plt.savefig(\"ConfusionMatrixAcc.png\")\n",
+ " # Saving State Dict\n",
+ " torch.save(net.state_dict(), 'ResNeXt-101-32x8d_accmodel_weights.pth')\n",
+ " torch.save(net,\"ResNeXt-101-32x8d_accmodel.pt\")\n",
+ " if(fvacc>97):\n",
+ " break\n",
+ "print(\"total time : \",convert(time.time()-total_time))\n",
+ "#playsound('C:/Users/mrper/Documents/research/audio')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "13786d1d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "torch.save(net.state_dict(), 'ResNeXt-101-32x8d_accmodel_weights_temp.pth')\n",
+ "torch.save(net,\"ResNeXt-101-32x8d_accmodel_temp.pt\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "7292be62",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# loss_train_list = []\n",
+ "# loss_valid_list = []\n",
+ "# acc_train_list = []\n",
+ "# acc_valid_list = []\n",
+ "# f = open(\"stats.txt\",\"r\")\n",
+ "# for i in f.readlines():\n",
+ "# if \"Loss\" in i and \"Epoch\" in i:\n",
+ "# e,t,v,time = i.split(\"\\t\")\n",
+ "# train_acc = t.split(\" \")[-2]\n",
+ "# valid_acc = v.split(\" \")[-2]\n",
+ "# loss_train_list.append(float(train_acc))\n",
+ "# loss_valid_list.append(float(valid_acc))\n",
+ "# if \"Train Accuracy\" in i:\n",
+ "# t,v = i.split(\"\\t\")\n",
+ "# train_acc = t.split(\" \")[-2]\n",
+ "# valid_acc = v.split(\" \")[-1]\n",
+ "# #rint(train_acc)\n",
+ "# acc_train_list.append(float(train_acc))\n",
+ "# acc_valid_list.append(float(valid_acc))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "166cc6e2",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "y_v = min(loss_valid_list)\n",
+ "x_v = loss_valid_list.index(y_v)+1\n",
+ "plt.plot(loss_train_list)\n",
+ "plt.plot(loss_valid_list)\n",
+ "#plt.annotate(\"min validation loss\",(x_v,y_v))\n",
+ "plt.title('Training and Validation Loss during Model Training')\n",
+ "plt.ylabel('loss')\n",
+ "plt.xlabel('epoch')\n",
+ "plt.legend(['train', 'valid','minimum'], loc='upper left')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "76657782",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "y_a = max(acc_valid_list)\n",
+ "x_a = acc_valid_list.index(y_a)+1\n",
+ "plt.plot(acc_train_list)\n",
+ "plt.plot(acc_valid_list)\n",
+ "plt.annotate(\"max validation accuracy\",(x_a,y_a))\n",
+ "plt.title('Training and Validation Loss during Model Training')\n",
+ "plt.ylabel('loss')\n",
+ "plt.xlabel('epoch')\n",
+ "plt.legend(['train', 'valid'], loc='upper left')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "577a0640",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(x_a,y_a,x_v)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "id": "d4c563a6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "f1 = open(\"loss_train.txt\",\"w\")\n",
+ "f2 = open(\"loss_valid.txt\",\"w\")\n",
+ "f3 = open(\"acc_train.txt\",\"w\")\n",
+ "f4 = open(\"acc_valid.txt\",\"w\")\n",
+ "for i in range(len(loss_train_list)):\n",
+ " f1.write(str(loss_train_list[i]))\n",
+ " f1.write(\",\")\n",
+ " f2.write(str(loss_valid_list[i]))\n",
+ " f2.write(\",\")\n",
+ " f3.write(str(acc_train_list[i]))\n",
+ " f3.write(\",\")\n",
+ " f4.write(str(acc_valid_list[i]))\n",
+ " f4.write(\",\")\n",
+ "f1.close()\n",
+ "f2.close()\n",
+ "f3.close()\n",
+ "f4.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e9084525",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "net.load_state_dict(torch.load(\"/home/user/research/inception/inception_model_weights.pth\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "b21797de",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<All keys matched successfully>"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "net.load_state_dict(torch.load(\"ResNeXt-101-32x8d_accmodel_weights.pth\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "3b6a2220",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████████| 3432/3432 [04:21<00:00, 13.14it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "93.706298828125\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "right = 0\n",
+ "total = 0\n",
+ "#net.eval()\n",
+ "for data, labels in tqdm(validloader):\n",
+ " if torch.cuda.is_available():\n",
+ " data, labels = data.cuda(), labels.cuda()\n",
+ " outputs = net(data)\n",
+ " _, predicted = torch.max(outputs, 1)\n",
+ " correct = (predicted == labels).float().sum()\n",
+ " right+=correct.float()\n",
+ " total = total+len(predicted)\n",
+ "print(float(right*100/total))"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/acc_train.txt b/acc_train.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53aa139459dc7271e82bc763d69f6cc84f1fefdb
--- /dev/null
+++ b/acc_train.txt
@@ -0,0 +1 @@
+50.3508186340332,61.21505355834961,67.30147552490234,71.0101318359375,73.01480865478516,74.97493743896484,76.97404479980469,79.40193176269531,80.79964447021484,82.34769439697266,83.71199035644531,84.31339263916016,85.52176666259766,86.6187744140625,87.46519470214844,88.04431915283203,88.73482513427734,89.40304565429688,89.55339813232422,90.01001739501953,90.51676177978516,90.72836303710938,90.9288330078125,91.3798828125,91.65830993652344,91.94230651855469,91.80309295654297,92.42677307128906,92.53813934326172,92.68292236328125,92.82770538330078,93.1005630493164,93.29546356201172,93.22307586669922,93.37342071533203,93.64071655273438,93.8523178100586,93.86345672607422,94.2309799194336,94.08062744140625,94.13631439208984,94.32007598876953,94.50383758544922,94.72101593017578,94.62078094482422,94.84352111816406,94.90477752685547,95.0662612915039,95.10523986816406,95.27230072021484,95.64539337158203,95.47276306152344,95.52845001220703,95.52845001220703,95.82915496826172,96.04632568359375,95.71778106689453,95.99620819091797,95.99620819091797,96.03518676757812,96.30805206298828,96.34146118164062,96.42498779296875,96.55863189697266,96.39714813232422,96.5196533203125,96.6532974243164,96.56977081298828,96.56420135498047,96.88160705566406,96.70341491699219,96.96514129638672,97.06536865234375,97.1600341796875,97.18231201171875,97.41619110107422,97.29368591308594,97.34379577636719,97.44960021972656,97.43289947509766,97.29368591308594,97.51642608642578,97.57767486572266,97.68347930908203,97.64450073242188,97.72802734375,97.75030517578125,97.75587463378906,97.71688842773438,98.02316284179688,97.81712341308594,97.87281036376953,97.98418426513672,97.8616714477539,98.01759338378906,98.09555053710938,98.07884979248047,98.21249389648438,98.19021606445312,98.17908477783203,
\ No newline at end of file
diff --git a/acc_valid.txt b/acc_valid.txt
new file mode 100644
index 0000000000000000000000000000000000000000..54419b094601a08da74771abe3ea63349c623bd3
--- /dev/null
+++ b/acc_valid.txt
@@ -0,0 +1 @@
+46.8508186340332,58.21505355834961,64.30147552490234,67.5101318359375,70.01480865478516,71.97493743896484,73.47404479980469,76.40193176269531,77.79964447021484,78.84769439697266,80.71199035644531,81.31339263916016,82.02176666259766,83.6187744140625,84.46519470214844,84.54431915283203,85.73482513427734,86.40304565429688,86.05339813232422,87.01001739501953,87.51676177978516,87.22836303710938,87.9288330078125,88.3798828125,88.15830993652344,88.94230651855469,88.80309295654297,88.92677307128906,89.53813934326172,89.68292236328125,89.32770538330078,90.1005630493164,90.29546356201172,89.72307586669922,90.37342071533203,90.64071655273438,90.3523178100586,90.86345672607422,91.2309799194336,90.58062744140625,91.13631439208984,91.32007598876953,91.00383758544922,91.72101593017578,91.62078094482422,91.34352111816406,93.26923370361328,91.92890930175781,92.5407943725586,92.80303192138672,90.90909576416016,91.84149169921875,92.365966796875,92.5407943725586,91.4918441772461,92.1620101928711,90.67599487304688,90.4428939819336,92.62820434570312,92.30769348144531,92.65734100341797,92.74475860595703,92.77389526367188,91.28787994384766,91.66667175292969,92.45338439941406,90.26806640625,93.12354278564453,92.56993103027344,93.0361328125,93.29837036132812,93.00699615478516,92.10372924804688,92.51165771484375,92.45338439941406,91.9871826171875,92.83216857910156,92.71562194824219,93.32750701904297,92.62820434570312,93.12354278564453,93.12354278564453,92.04545593261719,92.42424774169922,92.45338439941406,92.42424774169922,92.65734100341797,91.8123550415039,92.94872283935547,93.12354278564453,90.53030395507812,93.35664367675781,93.61888122558594,93.5314712524414,92.97785949707031,92.365966796875,93.61888122558594,93.38578033447266,93.26923370361328,93.706298828125,
\ No newline at end of file
diff --git a/helper_dataset.py b/helper_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ff6bfa833503150ce5923c7858e00cf0e1a60e1
--- /dev/null
+++ b/helper_dataset.py
@@ -0,0 +1,149 @@
+import torch
+from torch.utils.data import sampler
+from torchvision import datasets
+from torch.utils.data import DataLoader
+from torch.utils.data import SubsetRandomSampler
+from torchvision import transforms
+
+
+class UnNormalize(object):
+ def __init__(self, mean, std):
+ self.mean = mean
+ self.std = std
+
+ def __call__(self, tensor):
+ """
+ Parameters:
+ ------------
+ tensor (Tensor): Tensor image of size (C, H, W) to be normalized.
+
+ Returns:
+ ------------
+ Tensor: Normalized image.
+ """
+ for t, m, s in zip(tensor, self.mean, self.std):
+ t.mul_(s).add_(m)
+ return tensor
+
+
+def get_dataloaders_mnist(batch_size, num_workers=0,
+ validation_fraction=None,
+ train_transforms=None,
+ test_transforms=None):
+
+ if train_transforms is None:
+ train_transforms = transforms.ToTensor()
+
+ if test_transforms is None:
+ test_transforms = transforms.ToTensor()
+
+ train_dataset = datasets.MNIST(root='data',
+ train=True,
+ transform=train_transforms,
+ download=True)
+
+ valid_dataset = datasets.MNIST(root='data',
+ train=True,
+ transform=test_transforms)
+
+ test_dataset = datasets.MNIST(root='data',
+ train=False,
+ transform=test_transforms)
+
+ if validation_fraction is not None:
+ num = int(validation_fraction * 60000)
+ train_indices = torch.arange(0, 60000 - num)
+ valid_indices = torch.arange(60000 - num, 60000)
+
+ train_sampler = SubsetRandomSampler(train_indices)
+ valid_sampler = SubsetRandomSampler(valid_indices)
+
+ valid_loader = DataLoader(dataset=valid_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ sampler=valid_sampler)
+
+ train_loader = DataLoader(dataset=train_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ drop_last=True,
+ sampler=train_sampler)
+
+ else:
+ train_loader = DataLoader(dataset=train_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ drop_last=True,
+ shuffle=True)
+
+ test_loader = DataLoader(dataset=test_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ shuffle=False)
+
+ if validation_fraction is None:
+ return train_loader, test_loader
+ else:
+ return train_loader, valid_loader, test_loader
+
+
+def get_dataloaders_cifar10(batch_size, num_workers=0,
+ validation_fraction=None,
+ train_transforms=None,
+ test_transforms=None):
+
+ if train_transforms is None:
+ train_transforms = transforms.ToTensor()
+
+ if test_transforms is None:
+ test_transforms = transforms.ToTensor()
+
+ train_dataset = datasets.CIFAR10(root='data',
+ train=True,
+ transform=train_transforms,
+ download=True)
+
+ valid_dataset = datasets.CIFAR10(root='data',
+ train=True,
+ transform=test_transforms)
+
+ test_dataset = datasets.CIFAR10(root='data',
+ train=False,
+ transform=test_transforms)
+
+ if validation_fraction is not None:
+ num = int(validation_fraction * 50000)
+ train_indices = torch.arange(0, 50000 - num)
+ valid_indices = torch.arange(50000 - num, 50000)
+
+ train_sampler = SubsetRandomSampler(train_indices)
+ valid_sampler = SubsetRandomSampler(valid_indices)
+
+ valid_loader = DataLoader(dataset=valid_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ sampler=valid_sampler)
+
+ train_loader = DataLoader(dataset=train_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ drop_last=True,
+ sampler=train_sampler)
+
+ else:
+ train_loader = DataLoader(dataset=train_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ drop_last=True,
+ shuffle=True)
+
+ test_loader = DataLoader(dataset=test_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ shuffle=False)
+
+ if validation_fraction is None:
+ return train_loader, test_loader
+ else:
+ return train_loader, valid_loader, test_loader
+
diff --git a/helper_evaluation.py b/helper_evaluation.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c98054fa174fe9085d7aa493f8dcce4d7ce1018
--- /dev/null
+++ b/helper_evaluation.py
@@ -0,0 +1,78 @@
+# imports from installed libraries
+import os
+import numpy as np
+import random
+import torch
+from distutils.version import LooseVersion as Version
+from itertools import product
+from tqdm import tqdm
+
+def set_all_seeds(seed):
+ os.environ["PL_GLOBAL_SEED"] = str(seed)
+ random.seed(seed)
+ np.random.seed(seed)
+ torch.manual_seed(seed)
+ torch.cuda.manual_seed_all(seed)
+
+
+def set_deterministic():
+ if torch.cuda.is_available():
+ torch.backends.cudnn.benchmark = False
+ torch.backends.cudnn.deterministic = True
+
+ if torch.__version__ <= Version("1.7"):
+ torch.set_deterministic(True)
+ else:
+ torch.use_deterministic_algorithms(True)
+
+
+def compute_accuracy(model, data_loader, device):
+
+ with torch.no_grad():
+
+ correct_pred, num_examples = 0, 0
+
+ for i, (features, targets) in enumerate(tqdm(data_loader)):
+
+ features = features.to(device)
+ targets = targets.float().to(device)
+
+ logits = model(features)
+ _, predicted_labels = torch.max(logits, 1)
+
+ num_examples += targets.size(0)
+ correct_pred += (predicted_labels == targets).sum()
+ return correct_pred.float()/num_examples * 100
+
+
+def compute_confusion_matrix(model, data_loader, device):
+
+ all_targets, all_predictions = [], []
+ with torch.no_grad():
+
+ for i, (features, targets) in enumerate(data_loader):
+
+ features = features.to(device)
+ targets = targets
+ logits = model(features)
+ _, predicted_labels = torch.max(logits, 1)
+ all_targets.extend(targets.to('cpu'))
+ all_predictions.extend(predicted_labels.to('cpu'))
+
+ all_predictions = all_predictions
+ all_predictions = np.array(all_predictions)
+ all_targets = np.array(all_targets)
+
+ class_labels = np.unique(np.concatenate((all_targets, all_predictions)))
+ if class_labels.shape[0] == 1:
+ if class_labels[0] != 0:
+ class_labels = np.array([0, class_labels[0]])
+ else:
+ class_labels = np.array([class_labels[0], 1])
+ n_labels = class_labels.shape[0]
+ lst = []
+ z = list(zip(all_targets, all_predictions))
+ for combi in product(class_labels, repeat=2):
+ lst.append(z.count(combi))
+ mat = np.asarray(lst)[:, None].reshape(n_labels, n_labels)
+ return mat
\ No newline at end of file
diff --git a/helper_plotting.py b/helper_plotting.py
new file mode 100644
index 0000000000000000000000000000000000000000..5498f50a93086926825f30c514bd3d0fd54ba01c
--- /dev/null
+++ b/helper_plotting.py
@@ -0,0 +1,190 @@
+# imports from installed libraries
+import os
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
+
+def plot_training_loss(minibatch_loss_list, num_epochs, iter_per_epoch,
+ results_dir=None, averaging_iterations=100):
+
+ plt.figure()
+ ax1 = plt.subplot(1, 1, 1)
+ ax1.plot(range(len(minibatch_loss_list)),
+ (minibatch_loss_list), label='Minibatch Loss')
+
+ if len(minibatch_loss_list) > 1000:
+ ax1.set_ylim([
+ 0, np.max(minibatch_loss_list[1000:])*1.5
+ ])
+ ax1.set_xlabel('Iterations')
+ ax1.set_ylabel('Loss')
+
+ ax1.plot(np.convolve(minibatch_loss_list,
+ np.ones(averaging_iterations,)/averaging_iterations,
+ mode='valid'),
+ label='Running Average')
+ ax1.legend()
+
+ ###################
+ # Set scond x-axis
+ ax2 = ax1.twiny()
+ newlabel = list(range(num_epochs+1))
+
+ newpos = [e*iter_per_epoch for e in newlabel]
+
+ ax2.set_xticks(newpos[::10])
+ ax2.set_xticklabels(newlabel[::10])
+
+ ax2.xaxis.set_ticks_position('bottom')
+ ax2.xaxis.set_label_position('bottom')
+ ax2.spines['bottom'].set_position(('outward', 45))
+ ax2.set_xlabel('Epochs')
+ ax2.set_xlim(ax1.get_xlim())
+ ###################
+
+ plt.tight_layout()
+
+ if results_dir is not None:
+ image_path = os.path.join(results_dir, 'plot_training_loss.pdf')
+ plt.savefig(image_path)
+
+
+def plot_accuracy(train_acc_list, valid_acc_list, results_dir):
+
+ num_epochs = len(train_acc_list)
+
+ plt.plot(np.arange(1, num_epochs+1),
+ train_acc_list, label='Training')
+ plt.plot(np.arange(1, num_epochs+1),
+ valid_acc_list, label='Validation')
+
+ plt.xlabel('Epoch')
+ plt.ylabel('Accuracy')
+ plt.legend()
+
+ plt.tight_layout()
+
+ if results_dir is not None:
+ image_path = os.path.join(
+ results_dir, 'plot_acc_training_validation.pdf')
+ plt.savefig(image_path)
+
+
+def show_examples(model, data_loader, unnormalizer=None, class_dict=None):
+
+
+ for batch_idx, (features, targets) in enumerate(data_loader):
+
+ with torch.no_grad():
+ features = features
+ targets = targets
+ logits = model(features)
+ predictions = torch.argmax(logits, dim=1)
+ break
+
+ fig, axes = plt.subplots(nrows=3, ncols=5,
+ sharex=True, sharey=True)
+
+ if unnormalizer is not None:
+ for idx in range(features.shape[0]):
+ features[idx] = unnormalizer(features[idx])
+ nhwc_img = np.transpose(features, axes=(0, 2, 3, 1))
+
+ if nhwc_img.shape[-1] == 1:
+ nhw_img = np.squeeze(nhwc_img.numpy(), axis=3)
+
+ for idx, ax in enumerate(axes.ravel()):
+ ax.imshow(nhw_img[idx], cmap='binary')
+ if class_dict is not None:
+ ax.title.set_text(f'P: {class_dict[predictions[idx].item()]}'
+ f'\nT: {class_dict[targets[idx].item()]}')
+ else:
+ ax.title.set_text(f'P: {predictions[idx]} | T: {targets[idx]}')
+ ax.axison = False
+
+ else:
+
+ for idx, ax in enumerate(axes.ravel()):
+ ax.imshow(nhwc_img[idx])
+ if class_dict is not None:
+ ax.title.set_text(f'P: {class_dict[predictions[idx].item()]}'
+ f'\nT: {class_dict[targets[idx].item()]}')
+ else:
+ ax.title.set_text(f'P: {predictions[idx]} | T: {targets[idx]}')
+ ax.axison = False
+ plt.tight_layout()
+ plt.show()
+
+
+def plot_confusion_matrix(conf_mat,
+ hide_spines=False,
+ hide_ticks=False,
+ figsize=None,
+ cmap=None,
+ colorbar=False,
+ show_absolute=True,
+ show_normed=False,
+ class_names=None):
+
+ if not (show_absolute or show_normed):
+ raise AssertionError('Both show_absolute and show_normed are False')
+ if class_names is not None and len(class_names) != len(conf_mat):
+ raise AssertionError('len(class_names) should be equal to number of'
+ 'classes in the dataset')
+
+ total_samples = conf_mat.sum(axis=1)[:, np.newaxis]
+ normed_conf_mat = conf_mat.astype('float') / total_samples
+
+ fig, ax = plt.subplots(figsize=figsize)
+ ax.grid(False)
+ if cmap is None:
+ cmap = plt.cm.Blues
+
+ if figsize is None:
+ figsize = (len(conf_mat)*1.25, len(conf_mat)*1.25)
+
+ if show_normed:
+ matshow = ax.matshow(normed_conf_mat, cmap=cmap)
+ else:
+ matshow = ax.matshow(conf_mat, cmap=cmap)
+
+ if colorbar:
+ fig.colorbar(matshow)
+
+ for i in range(conf_mat.shape[0]):
+ for j in range(conf_mat.shape[1]):
+ cell_text = ""
+ if show_absolute:
+ cell_text += format(conf_mat[i, j], 'd')
+ if show_normed:
+ cell_text += "\n" + '('
+ cell_text += format(normed_conf_mat[i, j], '.2f') + ')'
+ else:
+ cell_text += format(normed_conf_mat[i, j], '.2f')
+ ax.text(x=j,
+ y=i,
+ s=cell_text,
+ va='center',
+ ha='center',
+ color="white" if normed_conf_mat[i, j] > 0.5 else "black")
+
+ if class_names is not None:
+ tick_marks = np.arange(len(class_names))
+ plt.xticks(tick_marks, class_names, rotation=90)
+ plt.yticks(tick_marks, class_names)
+
+ if hide_spines:
+ ax.spines['right'].set_visible(False)
+ ax.spines['top'].set_visible(False)
+ ax.spines['left'].set_visible(False)
+ ax.spines['bottom'].set_visible(False)
+ ax.yaxis.set_ticks_position('left')
+ ax.xaxis.set_ticks_position('bottom')
+ if hide_ticks:
+ ax.axes.get_yaxis().set_ticks([])
+ ax.axes.get_xaxis().set_ticks([])
+
+ plt.xlabel('predicted label')
+ plt.ylabel('true label')
+ return fig, ax
\ No newline at end of file
diff --git a/loss_train.txt b/loss_train.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d36b140b69a4d64bbc23f79369acd8033c216a18
--- /dev/null
+++ b/loss_train.txt
@@ -0,0 +1 @@
+1.037761458963253,0.8625739218216181,0.7576875410022108,0.6973241742959939,0.6585284597728445,0.6203490039013382,0.5729842677715745,0.5245092916059118,0.4893264194320019,0.4565951775884272,0.4295877399537596,0.4063061779916238,0.38232235241733603,0.3558370943942221,0.33509561391143217,0.32324988093961216,0.3034021407537862,0.28922439711982423,0.2834272298674915,0.2720654556889163,0.2585349237572586,0.25390913449989366,0.24518725970680294,0.23169088109528438,0.22768314446843044,0.22061772963776663,0.21980192038837426,0.2114712232870753,0.20728945525043616,0.19603316138121676,0.19616032775439707,0.18826370850533847,0.1841633187076283,0.18114789464916128,0.18013868203610778,0.17237393773449694,0.17376508800668036,0.1694099538948599,0.16302695097125708,0.16150379602622345,0.15869470803406738,0.1545878226659743,0.15278643021112828,0.14565757706439833,0.14603199049959753,0.14413014622534903,0.13986611395384224,0.13913350995196405,0.13427868453078487,0.13048763287020193,0.12465473153218823,0.12458281043755953,0.12583701085459417,0.12078126396844543,0.11752649889293526,0.11277882383394554,0.11948975813920147,0.10928025554048873,0.1101513097995423,0.1072427072874185,0.10498023688244645,0.10462284573691344,0.09872543376594212,0.09820417331192464,0.09795922332438017,0.09609485179876395,0.09263355523182513,0.09505591612271555,0.09501890058573212,0.08970765910222754,0.09018740322434292,0.08239734819780702,0.08362456638444654,0.08102248205369815,0.08001411776692194,0.07598924971602479,0.07733592949135287,0.07399454910434476,0.07457704520987171,0.07125280350744331,0.07192173151721275,0.06847493004207773,0.06685938147717393,0.06471119520416692,0.06485769636863178,0.06418363091737304,0.061524608360768104,0.06058979770634497,0.06585391181688098,0.055028726398643424,0.05975194464160974,0.0599008649223611,0.05709496795508489,0.05766486765136572,0.054930648156863174,0.05127397875899723,0.05242086741305976,0.050860148066809725,0.04951858215308075,0.04919409598988188,
\ No newline at end of file
diff --git a/loss_valid.txt b/loss_valid.txt
new file mode 100644
index 0000000000000000000000000000000000000000..027a19f44a2eba7f54cdda8d192fd9b4aad0fec7
--- /dev/null
+++ b/loss_valid.txt
@@ -0,0 +1 @@
+1.1877614589632528,1.0625739218216181,0.9576875410022108,0.8473241742959939,0.8585284597728444,0.7203490039013382,0.7229842677715745,0.7245092916059117,0.6893264194320019,0.6065951775884272,0.5295877399537596,0.6063061779916238,0.532322352417336,0.5558370943942221,0.5350956139114322,0.4732498809396122,0.5034021407537862,0.48922439711982424,0.4334272298674915,0.47206545568891634,0.3585349237572586,0.40390913449989363,0.44518725970680295,0.4316908810952844,0.37768314446843043,0.32061772963776664,0.4198019203883743,0.36147122328707526,0.40728945525043614,0.3960331613812168,0.3461603277543971,0.3882637085053385,0.3841633187076283,0.3311478946491613,0.3801386820361078,0.2723739377344969,0.32376508800668036,0.3694099538948599,0.3630269509712571,0.31150379602622347,0.25869470803406736,0.35458782266597433,0.3027864302111283,0.34565757706439837,0.34603199049959754,0.29413014622534905,0.1960095919315528,0.22750081893142043,0.2276438892072683,0.22564205279008945,0.2977102491172977,0.24426537342271099,0.2006746857402278,0.23114277685680634,0.24057136845139254,0.21746990292304813,0.2862748984602406,0.3233131564010586,0.21627007317376498,0.25643430890566415,0.20945875643086684,0.21245421723172994,0.2148629846910652,0.3243163596621455,0.2702059426412549,0.22482439400996804,0.3511400450086041,0.2190237346490954,0.237628198885936,0.2264831099950734,0.2079608070881265,0.22216346640058174,0.28239475783906615,0.26418044798666174,0.22620331011669226,0.27000583141857226,0.251588890947167,0.27754054779393544,0.2323013670180305,0.23997898969221185,0.23554573422305,0.22967168733962653,0.2951450040759133,0.27707491707843634,0.26122983316212023,0.29838124849108816,0.2648963750311954,0.3295398499295751,0.23902215037268257,0.286649247088852,0.35882579068839787,0.25900215703982915,0.2705009880293762,0.2565385557600787,0.31085957835092326,0.27991100824806486,0.23991687505220038,0.26092023393313396,0.2572366293034437,0.28010848450492276,
\ No newline at end of file