MItoC_clip.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "306f0a3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os.path as osp\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "from focal_loss.focal_loss import FocalLoss\n",
    "\n",
    "from torch.nn import TransformerEncoder, TransformerEncoderLayer\n",
    "import os\n",
    "from torch_geometric.data import Dataset, download_url\n",
    "from torch_geometric.loader import DataLoader\n",
    "import pandas as pd\n",
    "from performance import performances_val\n",
    "from PIL import Image\n",
    "from torch.nn import Linear\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "from torch_geometric.nn import GCNConv\n",
    "from torch_geometric.nn import global_mean_pool, global_max_pool\n",
    "from torch_geometric.nn.norm import BatchNorm\n",
    "from torch_geometric.data import Data\n",
    "from sklearn import metrics\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "from torch_geometric.nn import ChebConv, GraphSAGE,GraphUNet ,TransformerConv\n",
    "\n",
    "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n",
    "# os.environ[\"CUDA_LAUNCH_BLOCKING\"] = \"1\"\n",
    "seed = 1378\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n",
    "landmark_colors = np.load(\"landmark_colors.npy\")\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "one_hot_list=[]\n",
    "enc = OneHotEncoder()\n",
    "enc.fit(np.expand_dims(landmark_colors,axis=1))  \n",
    "for x in landmark_colors:\n",
    "    one_hot_list.append(enc.transform([[x]]).toarray()[0])\n",
    "one_hot_arr  = np.array(one_hot_list)\n",
    "one_hot_arr = torch.FloatTensor(one_hot_arr)\n",
    "\n",
    "m = torch.nn.Softmax(dim=-1)\n",
    "\n",
    "class landmark_dataset(Dataset):\n",
    "    def __init__(self, info_list, transform=None, pre_transform=None, pre_filter=None):\n",
    "        super().__init__(None, transform, pre_transform, pre_filter)\n",
    "        \n",
    "        self.graphs = pd.read_csv(info_list, delimiter=\",\", header=None)\n",
    "\n",
    "\n",
    "    def len(self):\n",
    "        return len(self.graphs)\n",
    "\n",
    "    def get(self, idx):\n",
    "        \n",
    "        graph_path = self.graphs.iloc[idx]\n",
    "        graph_path = graph_path[0]\n",
    "        \n",
    "        \n",
    "        data = torch.load(graph_path)\n",
    "        #data.x =data.x.t()\n",
    "        return data \n",
    "class landmark_dataset_train(Dataset):\n",
    "    def __init__(self, info_list, transform=None, pre_transform=None, pre_filter=None):\n",
    "        super().__init__(None, transform, pre_transform, pre_filter)\n",
    "        \n",
    "        self.graphs = pd.read_csv(info_list, delimiter=\",\", header=None)\n",
    "\n",
    "\n",
    "    def len(self):\n",
    "        return len(self.graphs)\n",
    "\n",
    "    def get(self, idx):\n",
    "        \n",
    "        graph_path = self.graphs.iloc[idx]\n",
    "        graph_path = graph_path[0]\n",
    "        \n",
    "        data = torch.load(graph_path)\n",
    "        \n",
    " \n",
    "        \n",
    "        domain_name = graph_path.split(\"/\")[-4]\n",
    "        \n",
    "            \n",
    "        if domain_name == \"MSU_MFSD\" :\n",
    "            \n",
    "            domain_label = 0\n",
    "            \n",
    "        elif domain_name == \"Replay_attack_dataset\" :\n",
    "            \n",
    "            domain_label = 1\n",
    "        else :\n",
    "            print(graph_path,domain_name )\n",
    "            raise \"error\"\n",
    "            \n",
    "        \n",
    "        data = Data(x=data.x, edge_index=data.edge_index,y =data.y,data = domain_label,y_node = one_hot_arr)\n",
    "\n",
    "        #data.x =data.x.t()\n",
    "        return data \n",
    "train_dataset = landmark_dataset_train(\"/home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Clip_graph_train_M_I.txt\")\n",
    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True,num_workers=16,pin_memory=True)\n",
    "\n",
    "test_dataset = landmark_dataset(\"/home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Clip_graph_test_C.txt\")\n",
    "test_loader = DataLoader(test_dataset, batch_size=64,num_workers=16)\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import TransformerEncoder, TransformerEncoderLayer\n",
    "\n",
    "# فرض کنید که داده‌های ورودی شما یک توالی از ۶۸۰ ویژگی دارد.\n",
    "#sequence_length = 128\n",
    "#feature_dim = 4  # هر ویژگی تک‌بعدی است\n",
    "\n",
    "# نمونه داده ورودی (تعداد نمونه‌ها × طول توالی × بعد ویژگی)\n",
    "#inputs = torch.rand(32, sequence_length, feature_dim)  # 32 نمونه با 680 ویژگی تک‌بعدی\n",
    "\n",
    "# تعریف یک لایه ترنسفورمر انکودر\n",
    "class SimpleTransformer(nn.Module):\n",
    "    def __init__(self, embed_dim, num_layers, nhead,n_out):\n",
    "        super(SimpleTransformer, self).__init__()\n",
    "        self.linear = nn.Linear(4, embed_dim)  # افزایش بعد ویژگی‌ها\n",
    "        self.encoder_layer = TransformerEncoderLayer(d_model=embed_dim, nhead=nhead)\n",
    "        self.transformer_encoder = TransformerEncoder(self.encoder_layer, num_layers=num_layers)\n",
    "        self.fc = nn.Linear(128 * embed_dim, n_out)  # فرضا 10 کلاس خروجی داریم\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.linear(x)  # تغییر بعد ویژگی‌ها\n",
    "        x = self.transformer_encoder(x)\n",
    "        x = x.view(x.size(0), -1)  # فشرده‌سازی به یک بردار برای طبقه‌بندی\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "# # ایجاد مدل و ارسال ورودی\n",
    "# # model = SimpleTransformer(embed_dim=embed_dim, num_layers=2, nhead=4)\n",
    "# # output = model(inputs)\n",
    "\n",
    "# #print(output.shape)\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import TransformerEncoder, TransformerEncoderLayer\n",
    "\n",
    "# فرض کنید که داده‌های ورودی شما یک توالی از ۶۸۰ ویژگی دارد.\n",
    "sequence_length = 128\n",
    "feature_dim = 1  # هر ویژگی تک‌بعدی است\n",
    "\n",
    "# نمونه داده ورودی (تعداد نمونه‌ها × طول توالی × بعد ویژگی)\n",
    "#inputs = torch.rand(32, sequence_length, feature_dim)  # 32 نمونه با 680 ویژگی تک‌بعدی\n",
    "\n",
    "# تعریف یک لایه ترنسفورمر انکودر\n",
    "class SimpleTransformer_2(nn.Module):\n",
    "    def __init__(self, embed_dim, num_layers, nhead):\n",
    "        super(SimpleTransformer_2, self).__init__()\n",
    "        self.linear = nn.Linear(feature_dim, embed_dim)  # افزایش بعد ویژگی‌ها\n",
    "        self.encoder_layer = TransformerEncoderLayer(d_model=embed_dim, nhead=nhead)\n",
    "        self.transformer_encoder = TransformerEncoder(self.encoder_layer, num_layers=num_layers)\n",
    "        self.fc = nn.Linear(sequence_length * embed_dim, 7)  # فرضا 10 کلاس خروجی داریم\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.linear(x)  # تغییر بعد ویژگی‌ها\n",
    "        x = self.transformer_encoder(x)\n",
    "        x = x.view(x.size(0), -1)  # فشرده‌سازی به یک بردار برای طبقه‌بندی\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "# # ایجاد مدل و ارسال ورودی\n",
    "# # model = SimpleTransformer(embed_dim=embed_dim, num_layers=2, nhead=4)\n",
    "# # output = model(inputs)\n",
    "\n",
    "# #print(output.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f8e97875",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCN(\n",
      "  (conv1): ChebConv(768, 128, K=2, normalization=sym)\n",
      "  (conv2): ChebConv(128, 128, K=2, normalization=sym)\n",
      "  (conv3): ChebConv(128, 128, K=2, normalization=sym)\n",
      "  (conv4): ChebConv(128, 128, K=2, normalization=sym)\n",
      "  (conv5): ChebConv(256, 128, K=2, normalization=sym)\n",
      "  (conv6): ChebConv(128, 128, K=2, normalization=sym)\n",
      "  (conv7): ChebConv(128, 128, K=2, normalization=sym)\n",
      "  (conv8): ChebConv(128, 128, K=2, normalization=sym)\n",
      "  (lin): SimpleTransformer(\n",
      "    (linear): Linear(in_features=4, out_features=8, bias=True)\n",
      "    (encoder_layer): TransformerEncoderLayer(\n",
      "      (self_attn): MultiheadAttention(\n",
      "        (out_proj): NonDynamicallyQuantizableLinear(in_features=8, out_features=8, bias=True)\n",
      "      )\n",
      "      (linear1): Linear(in_features=8, out_features=2048, bias=True)\n",
      "      (dropout): Dropout(p=0.1, inplace=False)\n",
      "      (linear2): Linear(in_features=2048, out_features=8, bias=True)\n",
      "      (norm1): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "      (norm2): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "      (dropout1): Dropout(p=0.1, inplace=False)\n",
      "      (dropout2): Dropout(p=0.1, inplace=False)\n",
      "    )\n",
      "    (transformer_encoder): TransformerEncoder(\n",
      "      (layers): ModuleList(\n",
      "        (0): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=8, out_features=8, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=8, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=8, bias=True)\n",
      "          (norm1): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (1): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=8, out_features=8, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=8, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=8, bias=True)\n",
      "          (norm1): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (2): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=8, out_features=8, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=8, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=8, bias=True)\n",
      "          (norm1): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (3): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=8, out_features=8, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=8, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=8, bias=True)\n",
      "          (norm1): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (4): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=8, out_features=8, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=8, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=8, bias=True)\n",
      "          (norm1): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (fc): Linear(in_features=1024, out_features=2, bias=True)\n",
      "  )\n",
      "  (drop_1): RandomNodeDropout()\n",
      "  (drop_2): RandomNodeDropout()\n",
      "  (drop_3): RandomNodeDropout()\n",
      "  (drop_4): RandomNodeDropout()\n",
      "  (drop_5): RandomNodeDropout()\n",
      "  (drop_6): RandomNodeDropout()\n",
      "  (b1): BatchNorm(128)\n",
      "  (b2): BatchNorm(128)\n",
      "  (b3): BatchNorm(128)\n",
      "  (b4): BatchNorm(128)\n",
      "  (b5): BatchNorm(128)\n",
      "  (b6): BatchNorm(128)\n",
      "  (b7): BatchNorm(128)\n",
      "  (dis): Discriminator(\n",
      "    (conv1): GraphSAGE(128, 128, num_layers=2)\n",
      "    (conv2): GraphSAGE(128, 128, num_layers=2)\n",
      "    (conv3): GraphSAGE(128, 128, num_layers=2)\n",
      "    (conv4): GraphSAGE(128, 128, num_layers=2)\n",
      "    (drop_1): RandomNodeDropout()\n",
      "    (drop_2): RandomNodeDropout()\n",
      "    (grl_layer): GRL()\n",
      "    (fc2): Linear(in_features=128, out_features=2, bias=True)\n",
      "  )\n",
      "  (conv1_node_class): GraphSAGE(128, 128, num_layers=2)\n",
      "  (conv2_node_class): GraphSAGE(128, 128, num_layers=2)\n",
      "  (lin_node_class): SimpleTransformer_2(\n",
      "    (linear): Linear(in_features=1, out_features=64, bias=True)\n",
      "    (encoder_layer): TransformerEncoderLayer(\n",
      "      (self_attn): MultiheadAttention(\n",
      "        (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "      )\n",
      "      (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "      (dropout): Dropout(p=0.1, inplace=False)\n",
      "      (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "      (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "      (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "      (dropout1): Dropout(p=0.1, inplace=False)\n",
      "      (dropout2): Dropout(p=0.1, inplace=False)\n",
      "    )\n",
      "    (transformer_encoder): TransformerEncoder(\n",
      "      (layers): ModuleList(\n",
      "        (0): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (1): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (2): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (3): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (4): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (5): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (6): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (7): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (8): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "        (9): TransformerEncoderLayer(\n",
      "          (self_attn): MultiheadAttention(\n",
      "            (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
      "          )\n",
      "          (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
      "          (dropout): Dropout(p=0.1, inplace=False)\n",
      "          (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
      "          (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "          (dropout1): Dropout(p=0.1, inplace=False)\n",
      "          (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (fc): Linear(in_features=8192, out_features=7, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class RandomNodeDropout(nn.Module):\n",
    "    def __init__(self, drop_prob=0.3):\n",
    "        super(RandomNodeDropout, self).__init__()\n",
    "        self.drop_prob = drop_prob\n",
    "\n",
    "    def forward(self, x, enabled=True):\n",
    "        if not self.training or not enabled:\n",
    "            return x\n",
    "        \n",
    "        num_rows = x.size(0)\n",
    "        mask = torch.rand(num_rows, device=x.device) > self.drop_prob\n",
    "        mask = mask.float().unsqueeze(1).expand_as(x)\n",
    "        x = x * mask\n",
    "        \n",
    "        return x\n",
    "\n",
    "soft = torch.nn.Softmax(dim=1)\n",
    "\n",
    "num_domain = 2\n",
    "class GRL(nn.Module):\n",
    "\n",
    "    def __init__(self, max_iter):\n",
    "        super(GRL, self).__init__()\n",
    "        self.iter_num = 0\n",
    "        self.alpha = 10\n",
    "        self.low = 0.0\n",
    "        self.high = 1.0\n",
    "        self.max_iter = max_iter\n",
    "\n",
    "    def forward(self, input):\n",
    "        self.iter_num += 1\n",
    "        return input * 1.0\n",
    "\n",
    "    def backward(self, gradOutput):\n",
    "        coeff = np.float(2.0 * (self.high - self.low) / (1.0 + np.exp(-self.alpha * self.iter_num / self.max_iter))\n",
    "                         - (self.high - self.low) + self.low)\n",
    "        return -coeff*10* gradOutput\n",
    "\n",
    "num_node  =train_dataset.num_node_features\n",
    "class Discriminator(torch.nn.Module):\n",
    "    def __init__(self,hidden_channels ,max_iter):\n",
    "        super(Discriminator, self).__init__()\n",
    "        torch.manual_seed(12345)\n",
    "        self.conv1 = GraphSAGE(hidden_channels, hidden_channels,2,dropout=0.5)\n",
    "        self.conv2 = GraphSAGE(hidden_channels, hidden_channels,2,dropout=0.5)\n",
    "        self.conv3 = GraphSAGE(hidden_channels, hidden_channels,2,dropout=0.5)\n",
    "        self.conv4 = GraphSAGE(hidden_channels, hidden_channels,2,dropout=0.5)\n",
    "        self.drop_1 = RandomNodeDropout(drop_prob=0.3)\n",
    "        self.drop_2 = RandomNodeDropout(drop_prob=0.3)\n",
    "        self.grl_layer = GRL(max_iter)\n",
    "        self.fc2 = nn.Linear(hidden_channels, num_domain)\n",
    "        \n",
    "    def forward(self, x, edge_index, batch,drop_en):\n",
    "        #print(\"graph fea :\",graph_level_feature.shape ,edge_index.shape )\n",
    "        \n",
    "        x = self.grl_layer(x)\n",
    "        x = self.conv1(x, edge_index)\n",
    "        x = x.relu()\n",
    "        x = self.drop_1(x,drop_en)\n",
    "        \n",
    "        x = self.conv2(x, edge_index)\n",
    "        x = x.relu()\n",
    "        x = self.drop_2(x,drop_en)\n",
    "        \n",
    "        x = self.conv3(x, edge_index)\n",
    "        x = x.relu()\n",
    "        x = self.conv4(x, edge_index)\n",
    "        x = x.relu()\n",
    "        \n",
    "        x = global_mean_pool(x, batch)\n",
    "        \n",
    "        x = self.fc2(x)\n",
    "        \n",
    "        x = m(x)\n",
    "         \n",
    "        return x \n",
    "\n",
    "\n",
    "\n",
    "class GCN(torch.nn.Module):\n",
    "    def __init__(self, hidden_channels,max_iter=4000):\n",
    "        super(GCN, self).__init__()\n",
    "        torch.manual_seed(12345)\n",
    "        self.conv1 = ChebConv(num_node, hidden_channels,2)\n",
    "        self.conv2 = ChebConv(hidden_channels, hidden_channels,2)\n",
    "        self.conv3 = ChebConv(hidden_channels, hidden_channels,2)\n",
    "        self.conv4 = ChebConv(hidden_channels, hidden_channels,2)\n",
    "        self.conv5 = ChebConv(hidden_channels*2, hidden_channels,2)\n",
    "        self.conv6 = ChebConv(hidden_channels, hidden_channels,2)\n",
    "        self.conv7 = ChebConv(hidden_channels, hidden_channels,2)\n",
    "        self.conv8 = ChebConv(hidden_channels, hidden_channels,2)\n",
    "        self.lin = SimpleTransformer(8,5,8,2)\n",
    "        \n",
    "        self.drop_1 = RandomNodeDropout(drop_prob=0.3)\n",
    "        self.drop_2 = RandomNodeDropout(drop_prob=0.3)\n",
    "        self.drop_3 = RandomNodeDropout(drop_prob=0.3)\n",
    "        self.drop_4 = RandomNodeDropout(drop_prob=0.3)\n",
    "        self.drop_5 = RandomNodeDropout(drop_prob=0.3)\n",
    "        self.drop_6 = RandomNodeDropout(drop_prob=0.3)\n",
    "        \n",
    "        \n",
    "        self.b1 = BatchNorm(hidden_channels)\n",
    "        self.b2 = BatchNorm(hidden_channels)\n",
    "        self.b3 = BatchNorm(hidden_channels)\n",
    "        self.b4 = BatchNorm(hidden_channels)\n",
    "        self.b5 = BatchNorm(hidden_channels)\n",
    "        self.b6 = BatchNorm(hidden_channels)\n",
    "        self.b7 = BatchNorm(hidden_channels)\n",
    "        \n",
    "        self.dis = Discriminator(hidden_channels,max_iter)\n",
    "        \n",
    "        self.conv1_node_class = GraphSAGE(hidden_channels, hidden_channels,2,dropout=0.5)\n",
    "        \n",
    "        self.conv2_node_class = GraphSAGE(hidden_channels, hidden_channels,2,dropout=0.5)\n",
    "        \n",
    "        self.lin_node_class = SimpleTransformer_2(64,10,8)\n",
    "        \n",
    "\n",
    "        \n",
    "        #self.tcn = Simple1DCNN()\n",
    "        \n",
    "    def forward(self, x, edge_index, batch,drop_en,index_arr):\n",
    "        #print(\"graph fea :\",graph_level_feature.shape ,edge_index.shape )\n",
    "        \n",
    "\n",
    "        x = self.conv1(x, edge_index)\n",
    "        x  = self.b1(x)\n",
    "        x = x.relu()\n",
    "        \n",
    "        x = self.drop_1(x,drop_en)\n",
    "        \n",
    "        \n",
    "\n",
    "        x = self.conv2(x, edge_index)\n",
    "        x  = self.b2(x)\n",
    "        x = x.relu()\n",
    "        \n",
    "        x = self.drop_2(x,drop_en)\n",
    "                \n",
    "        dicriminator = x\n",
    "        \n",
    "        x_1 = global_mean_pool(x, batch)\n",
    "        \n",
    "        x = self.conv3(x, edge_index)\n",
    "        x  = self.b3(x)\n",
    "        x = x.relu()\n",
    "        \n",
    "        x = self.drop_3(x,drop_en)\n",
    "        \n",
    "        x_3 = global_mean_pool(x, batch)\n",
    "        \n",
    "        \n",
    "        x = self.conv4(x, edge_index)\n",
    "        x  = self.b4(x)\n",
    "        x = x.relu()\n",
    "        \n",
    "        x = self.drop_4(x,drop_en)\n",
    "        \n",
    "        \n",
    "        x = torch.cat((x,dicriminator),dim=1) #skip connection\n",
    "        \n",
    "        x = self.conv5(x, edge_index)\n",
    "        x  = self.b5(x)\n",
    "        x = x.relu()\n",
    "        \n",
    "        x = self.drop_5(x,drop_en)\n",
    "        \n",
    "        x_5 = global_mean_pool(x, batch)\n",
    "        \n",
    "        x = self.conv6(x, edge_index)\n",
    "        x  = self.b6(x)\n",
    "        x = x.relu()\n",
    "        \n",
    "        x = self.drop_6(x,drop_en)\n",
    "        \n",
    "        x = self.conv7(x, edge_index)\n",
    "        x  = self.b7(x)\n",
    "        x = x.relu()\n",
    "        \n",
    "        \n",
    "        x = self.conv8(x, edge_index)\n",
    "        # 2. Readout layer\n",
    "        x = global_mean_pool(x, batch)  # [batch_size, hidden_channels]\n",
    "        \n",
    "        x = torch.stack([x,x_1,x_5,x_3],dim=2)\n",
    "        \n",
    "        x = F.dropout(x, p=0.5, training=self.training)\n",
    "        \n",
    "        #x = torch.unsqueeze(x,2)\n",
    "        #print(x.shape)\n",
    "        \n",
    "        x = self.lin(x)\n",
    "        \n",
    "        x= m(x)\n",
    "        \n",
    "        \n",
    "        node_class_hidden = self.conv1_node_class(dicriminator,edge_index)\n",
    "        node_class_hidden = node_class_hidden.relu()\n",
    "        \n",
    "        node_class_hidden = self.conv2_node_class(node_class_hidden,edge_index)\n",
    "        node_class_hidden = node_class_hidden.relu()\n",
    "        \n",
    "        #print(index_arr.shape , node_class_hidden.shape)\n",
    "        \n",
    "        node_class_hidden = node_class_hidden[index_arr]\n",
    "        \n",
    "        #print(node_class_hidden.shape)\n",
    "        node_class_hidden = torch.unsqueeze(node_class_hidden, dim=2)\n",
    "        \n",
    "        node_pre = self.lin_node_class(node_class_hidden)\n",
    "        \n",
    "            \n",
    "        #print(\"hiiii :\" , dicriminator.shape)\n",
    "        dis_invariant = self.dis(dicriminator,edge_index,batch,drop_en)\n",
    "        \n",
    "        return x ,dis_invariant ,node_pre\n",
    "\n",
    "model = GCN(hidden_channels=128).to(device)\n",
    "print(model)\n",
    "\n",
    "def check_folder(log_dir):\n",
    "    if not os.path.exists(log_dir):\n",
    "        os.makedirs(log_dir)\n",
    "    return log_dir\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
    "#criterion = torch.nn.CrossEntropyLoss()\n",
    "criterion= FocalLoss(gamma=2)\n",
    "criterion_node_class=  torch.nn.CrossEntropyLoss()\n",
    "criterion_2 = FocalLoss(gamma=2)\n",
    "def train(epoch):\n",
    "    model.train()\n",
    "    losses_adv_loss=0\n",
    "    losses_loss_cls=0\n",
    "    total_loss = 0\n",
    "    losses_node_cls_loss = 0\n",
    "    progress_bar = tqdm(train_loader, desc=f'Epoch {epoch+1}', unit='batch')\n",
    "    for graph in progress_bar:  # Iterate in batches over the training dataset.\n",
    "        graph = graph.to(device)  # Move data to the device\n",
    "        \n",
    "        drop_en = bool(np.random.binomial(1, 0.5))\n",
    "        \n",
    "        if graph.x.shape[0] < 29952 :\n",
    "            \n",
    "            if graph.x.shape[0] < 64:\n",
    "            \n",
    "                index_arr = torch.randint(0, int(graph.x.shape[0]), (int(graph.x.shape[0]),)).to(device)\n",
    "            else :\n",
    "                \n",
    "                index_arr = torch.randint(0, int(graph.x.shape[0]), (64,)).to(device)\n",
    "        else :\n",
    "                \n",
    "            index_arr = torch.randint(0, 29952, (64,)).to(device)\n",
    "        \n",
    "        \n",
    "        \n",
    "        out,domain_invariant,node_pre = model(graph.x, graph.edge_index, graph.batch,drop_en,index_arr)  # Perform a single forward pass.\n",
    "        \n",
    "        adv_loss = criterion_2(domain_invariant, graph.data)\n",
    "        \n",
    "        node_cls_loss = criterion_node_class(node_pre.squeeze(),graph.y_node.float()[index_arr])\n",
    "        #print(out.shape , graph.y.long().shape)\n",
    "        loss_cls = criterion(out.squeeze(), graph.y)  # Compute the loss.\n",
    "        \n",
    "        loss_all = adv_loss + loss_cls + node_cls_loss\n",
    "        loss_all.backward()  # Derive gradients.\n",
    "        optimizer.step()  # Update parameters based on gradients.\n",
    "        optimizer.zero_grad()  # Clear gradients.\n",
    "        total_loss = loss_all + total_loss\n",
    "        losses_adv_loss = adv_loss + losses_adv_loss\n",
    "        losses_loss_cls = loss_cls + losses_loss_cls\n",
    "        losses_node_cls_loss = node_cls_loss + losses_node_cls_loss\n",
    "\n",
    "\n",
    "    print(\"/////////////////////////\")\n",
    "    print(\"adverserial loss : \" ,losses_adv_loss/len(train_loader.dataset))  \n",
    "    print(\"classification loss : \" , losses_loss_cls/len(train_loader.dataset))\n",
    "    print(\"classification node loss : \" , losses_node_cls_loss/len(train_loader.dataset))\n",
    "    print(\"total loss : \" ,total_loss/len(train_loader.dataset) )\n",
    "    print(\"////////////////////////////////////\")\n",
    "def test(loader,epoch):\n",
    "    score_path = os.path.join(\"/home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores\", \"epoch_{}\".format(epoch+1))\n",
    "    check_folder(score_path)\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        scores_list = []\n",
    "\n",
    "        correct = 0\n",
    "        s= 0\n",
    "        progress_bar = tqdm(loader, desc=f'Epoch {epoch+1}', unit='batch')\n",
    "        for graph in progress_bar:  # Iterate in batches over the training/test dataset.\n",
    "            if graph.x.shape[0] < 29952 :\n",
    "\n",
    "                if graph.x.shape[0] < 64:\n",
    "\n",
    "                    index_arr = torch.randint(0, int(graph.x.shape[0]), (int(graph.x.shape[0]),)).to(device)\n",
    "                else :\n",
    "\n",
    "                    index_arr = torch.randint(0, int(graph.x.shape[0]), (64,)).to(device)\n",
    "            else :\n",
    "\n",
    "                index_arr = torch.randint(0, 29952, (64,)).to(device)\n",
    "                \n",
    "            graph = graph.to(device)  # Move data to the device\n",
    "            logit,_ ,_= model(graph.x, graph.edge_index, graph.batch,False,index_arr)\n",
    "            #print(logit.shape)\n",
    "            logit = logit[:,1]\n",
    "            live_label = graph.y.float()\n",
    "            for i in range(len(logit)):\n",
    "                        scores_list.append(\"{} {}\\n\".format(logit[i].item(), live_label[i].item()))\n",
    "  # Check against ground-truth labels.\n",
    "    map_score_val_filename = os.path.join(score_path, \"score.txt\")\n",
    "    with open(map_score_val_filename, 'w') as file:\n",
    "                file.writelines(scores_list)\n",
    "    print(\"score: write test scores to {}\".format(map_score_val_filename))\n",
    "    test_ACC, fpr, FRR, HTER, auc_test, test_err, tpr = performances_val(map_score_val_filename)\n",
    "    print(\"epoch:{:d}, test:  val_ACC={:.4f}, HTER={:.4f}, AUC={:.4f}, val_err={:.4f}, ACC={:.4f}, TPR={:.4f}\".format(\n",
    "        epoch + 1, test_ACC, HTER, auc_test, test_err, test_ACC, tpr))  \n",
    "    return auc_test\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4d2cf616",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:05<00:00,  6.54batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0167, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0171, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.06batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_1/score.txt\n",
      "epoch:1, test:  val_ACC=0.5005, HTER=0.4995, AUC=0.5373, val_err=0.4995, ACC=0.5005, TPR=0.1314\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7381e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.7377e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0080, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0080, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.26batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_2/score.txt\n",
      "epoch:2, test:  val_ACC=0.5447, HTER=0.4554, AUC=0.5924, val_err=0.4554, ACC=0.5447, TPR=0.1705\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.4499e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.7391e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0064, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0064, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  6.98batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_3/score.txt\n",
      "epoch:3, test:  val_ACC=0.5436, HTER=0.4565, AUC=0.5994, val_err=0.4565, ACC=0.5436, TPR=0.1770\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.3727e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.3827e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0056, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0057, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_4/score.txt\n",
      "epoch:4, test:  val_ACC=0.6040, HTER=0.3960, AUC=0.6555, val_err=0.3960, ACC=0.6040, TPR=0.1199\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.8020e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.6877e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0049, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0049, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.23batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_5/score.txt\n",
      "epoch:5, test:  val_ACC=0.5032, HTER=0.4968, AUC=0.5425, val_err=0.4968, ACC=0.5032, TPR=0.0759\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.1185e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0191e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0046, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0046, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_6/score.txt\n",
      "epoch:6, test:  val_ACC=0.5675, HTER=0.4325, AUC=0.6191, val_err=0.4325, ACC=0.5675, TPR=0.1199\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8850e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.4849e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0042, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0043, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.25batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_7/score.txt\n",
      "epoch:7, test:  val_ACC=0.6059, HTER=0.3941, AUC=0.6543, val_err=0.3942, ACC=0.6059, TPR=0.1525\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.9224e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.2691e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0039, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0039, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.09batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_8/score.txt\n",
      "epoch:8, test:  val_ACC=0.5712, HTER=0.4288, AUC=0.6098, val_err=0.4288, ACC=0.5712, TPR=0.1006\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|████████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.4045e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.3686e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0036, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0036, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.04batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_9/score.txt\n",
      "epoch:9, test:  val_ACC=0.5338, HTER=0.4662, AUC=0.6070, val_err=0.4662, ACC=0.5338, TPR=0.1542\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.9675e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0274e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0035, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0035, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_10/score.txt\n",
      "epoch:10, test:  val_ACC=0.5811, HTER=0.4188, AUC=0.6111, val_err=0.4189, ACC=0.5811, TPR=0.0790\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7006e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.9060e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0033, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0033, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_11/score.txt\n",
      "epoch:11, test:  val_ACC=0.6523, HTER=0.3477, AUC=0.7164, val_err=0.3477, ACC=0.6523, TPR=0.1622\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.4790e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.5436e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0030, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0031, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_12/score.txt\n",
      "epoch:12, test:  val_ACC=0.6558, HTER=0.3442, AUC=0.7186, val_err=0.3442, ACC=0.6558, TPR=0.1030\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.0540e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(7.5935e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0028, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0028, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.11batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_13/score.txt\n",
      "epoch:13, test:  val_ACC=0.7137, HTER=0.2863, AUC=0.7940, val_err=0.2863, ACC=0.7137, TPR=0.3392\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0902e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(7.5968e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0027, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0027, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.18batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_14/score.txt\n",
      "epoch:14, test:  val_ACC=0.7302, HTER=0.2698, AUC=0.8003, val_err=0.2698, ACC=0.7302, TPR=0.2873\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.6335e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.9834e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0026, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0026, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_15/score.txt\n",
      "epoch:15, test:  val_ACC=0.7208, HTER=0.2793, AUC=0.8169, val_err=0.2793, ACC=0.7208, TPR=0.4181\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.2783e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.2762e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0024, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0024, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_16/score.txt\n",
      "epoch:16, test:  val_ACC=0.7212, HTER=0.2789, AUC=0.7811, val_err=0.2789, ACC=0.7212, TPR=0.3520\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0078e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.3845e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0023, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0023, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_17/score.txt\n",
      "epoch:17, test:  val_ACC=0.6668, HTER=0.3333, AUC=0.7378, val_err=0.3333, ACC=0.6668, TPR=0.2596\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.9221e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.7591e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0023, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0023, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.17batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_18/score.txt\n",
      "epoch:18, test:  val_ACC=0.6825, HTER=0.3175, AUC=0.7427, val_err=0.3175, ACC=0.6825, TPR=0.3902\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8123e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.8636e-05, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0021, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0021, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.95batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_19/score.txt\n",
      "epoch:19, test:  val_ACC=0.6727, HTER=0.3273, AUC=0.7464, val_err=0.3273, ACC=0.6727, TPR=0.2375\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7786e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.4148e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0020, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0020, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.05batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_20/score.txt\n",
      "epoch:20, test:  val_ACC=0.7154, HTER=0.2847, AUC=0.7688, val_err=0.2847, ACC=0.7154, TPR=0.4264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.83batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.2213e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.2591e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0020, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0020, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.98batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_21/score.txt\n",
      "epoch:21, test:  val_ACC=0.6848, HTER=0.3153, AUC=0.7469, val_err=0.3153, ACC=0.6848, TPR=0.2744\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.2374e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.2465e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0019, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0019, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.96batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_22/score.txt\n",
      "epoch:22, test:  val_ACC=0.6780, HTER=0.3220, AUC=0.7593, val_err=0.3220, ACC=0.6780, TPR=0.2221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 23: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.9107e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(7.1748e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0018, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0018, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 23: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.14batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_23/score.txt\n",
      "epoch:23, test:  val_ACC=0.6113, HTER=0.3888, AUC=0.6488, val_err=0.3888, ACC=0.6113, TPR=0.1195\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 24: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8657e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.1535e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0017, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0017, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 24: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_24/score.txt\n",
      "epoch:24, test:  val_ACC=0.6406, HTER=0.3594, AUC=0.7132, val_err=0.3594, ACC=0.6406, TPR=0.2279\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 25: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.3334e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.6729e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0017, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0017, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 25: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.10batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_25/score.txt\n",
      "epoch:25, test:  val_ACC=0.7321, HTER=0.2679, AUC=0.8158, val_err=0.2679, ACC=0.7321, TPR=0.4507\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 26: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.1418e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.5802e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0016, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0016, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 26: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_26/score.txt\n",
      "epoch:26, test:  val_ACC=0.6871, HTER=0.3129, AUC=0.7493, val_err=0.3129, ACC=0.6871, TPR=0.2334\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 27: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.1461e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.8853e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0016, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0016, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 27: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_27/score.txt\n",
      "epoch:27, test:  val_ACC=0.6085, HTER=0.3915, AUC=0.6674, val_err=0.3916, ACC=0.6085, TPR=0.1483\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 28: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.3674e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.2851e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0015, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0015, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 28: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_28/score.txt\n",
      "epoch:28, test:  val_ACC=0.7068, HTER=0.2932, AUC=0.7667, val_err=0.2933, ACC=0.7068, TPR=0.3307\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 29: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.1042e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.8941e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0014, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0014, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 29: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.73batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_29/score.txt\n",
      "epoch:29, test:  val_ACC=0.5932, HTER=0.4068, AUC=0.6645, val_err=0.4068, ACC=0.5932, TPR=0.1464\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 30: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:03<00:00,  6.61batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.4256e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.9742e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0014, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0014, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 30: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_30/score.txt\n",
      "epoch:30, test:  val_ACC=0.5632, HTER=0.4368, AUC=0.6068, val_err=0.4369, ACC=0.5632, TPR=0.1002\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 31: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.75batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.3300e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.0069e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0014, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0014, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 31: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.83batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_31/score.txt\n",
      "epoch:31, test:  val_ACC=0.6388, HTER=0.3613, AUC=0.7118, val_err=0.3613, ACC=0.6388, TPR=0.2106\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 32: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7913e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.0400e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0013, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0013, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 32: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_32/score.txt\n",
      "epoch:32, test:  val_ACC=0.6687, HTER=0.3313, AUC=0.7049, val_err=0.3313, ACC=0.6687, TPR=0.1160\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 33: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0444e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.1986e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0013, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0013, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 33: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_33/score.txt\n",
      "epoch:33, test:  val_ACC=0.6599, HTER=0.3401, AUC=0.7318, val_err=0.3402, ACC=0.6599, TPR=0.4042\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 34: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.2561e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.5467e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0013, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0013, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 34: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.14batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_34/score.txt\n",
      "epoch:34, test:  val_ACC=0.6946, HTER=0.3054, AUC=0.7644, val_err=0.3054, ACC=0.6946, TPR=0.4405\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 35: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.0223e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.1298e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 35: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.87batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_35/score.txt\n",
      "epoch:35, test:  val_ACC=0.6458, HTER=0.3542, AUC=0.7131, val_err=0.3542, ACC=0.6458, TPR=0.2941\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 36: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.9352e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.6416e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0012, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0012, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 36: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_36/score.txt\n",
      "epoch:36, test:  val_ACC=0.6686, HTER=0.3314, AUC=0.7270, val_err=0.3314, ACC=0.6686, TPR=0.2982\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 37: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.6850e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.8495e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 37: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.93batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_37/score.txt\n",
      "epoch:37, test:  val_ACC=0.6737, HTER=0.3264, AUC=0.6893, val_err=0.3264, ACC=0.6737, TPR=0.1811\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 38: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:00<00:00,  6.73batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(8.2690e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.1049e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 38: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_38/score.txt\n",
      "epoch:38, test:  val_ACC=0.7434, HTER=0.2566, AUC=0.7999, val_err=0.2566, ACC=0.7434, TPR=0.3552\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 39: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.1670e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.1229e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 39: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.91batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_39/score.txt\n",
      "epoch:39, test:  val_ACC=0.7184, HTER=0.2816, AUC=0.7825, val_err=0.2816, ACC=0.7184, TPR=0.2806\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 40: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.74batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.8285e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.5862e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 40: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  6.99batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_40/score.txt\n",
      "epoch:40, test:  val_ACC=0.6485, HTER=0.3515, AUC=0.7170, val_err=0.3515, ACC=0.6485, TPR=0.1776\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 41: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.5678e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.2137e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0011, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 41: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_41/score.txt\n",
      "epoch:41, test:  val_ACC=0.7466, HTER=0.2533, AUC=0.8123, val_err=0.2534, ACC=0.7466, TPR=0.3182\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 42: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.9521e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.3435e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 42: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.11batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_42/score.txt\n",
      "epoch:42, test:  val_ACC=0.6624, HTER=0.3376, AUC=0.7119, val_err=0.3376, ACC=0.6624, TPR=0.1744\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 43: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.5997e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.4321e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 43: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.98batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_43/score.txt\n",
      "epoch:43, test:  val_ACC=0.7583, HTER=0.2418, AUC=0.8446, val_err=0.2418, ACC=0.7583, TPR=0.4567\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 44: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.5020e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.6287e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0010, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 44: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.83batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_44/score.txt\n",
      "epoch:44, test:  val_ACC=0.6944, HTER=0.3056, AUC=0.7520, val_err=0.3056, ACC=0.6944, TPR=0.2654\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 45: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.0126e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.6357e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 45: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.93batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_45/score.txt\n",
      "epoch:45, test:  val_ACC=0.7072, HTER=0.2928, AUC=0.7708, val_err=0.2928, ACC=0.7072, TPR=0.1449\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 46: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.75batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.6772e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.1855e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 46: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_46/score.txt\n",
      "epoch:46, test:  val_ACC=0.7225, HTER=0.2776, AUC=0.7925, val_err=0.2776, ACC=0.7225, TPR=0.2115\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 47: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.4472e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.3013e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 47: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:47<00:00,  7.28batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_47/score.txt\n",
      "epoch:47, test:  val_ACC=0.6790, HTER=0.3210, AUC=0.7418, val_err=0.3210, ACC=0.6790, TPR=0.1659\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 48: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8712e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0685e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 48: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.21batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_48/score.txt\n",
      "epoch:48, test:  val_ACC=0.6946, HTER=0.3054, AUC=0.7524, val_err=0.3054, ACC=0.6946, TPR=0.2342\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 49: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0739e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.9912e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0009, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 49: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_49/score.txt\n",
      "epoch:49, test:  val_ACC=0.7321, HTER=0.2679, AUC=0.8079, val_err=0.2679, ACC=0.7321, TPR=0.5279\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 50: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.74batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.9950e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.4720e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 50: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.22batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_50/score.txt\n",
      "epoch:50, test:  val_ACC=0.6193, HTER=0.3808, AUC=0.6522, val_err=0.3808, ACC=0.6193, TPR=0.1609\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 51: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.3052e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.7098e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 51: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_51/score.txt\n",
      "epoch:51, test:  val_ACC=0.7009, HTER=0.2991, AUC=0.7609, val_err=0.2991, ACC=0.7009, TPR=0.2720\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 52: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.9399e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.1465e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 52: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.84batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_52/score.txt\n",
      "epoch:52, test:  val_ACC=0.6886, HTER=0.3114, AUC=0.7469, val_err=0.3114, ACC=0.6886, TPR=0.1930\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 53: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.4246e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.4327e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 53: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_53/score.txt\n",
      "epoch:53, test:  val_ACC=0.7086, HTER=0.2914, AUC=0.7719, val_err=0.2914, ACC=0.7086, TPR=0.4019\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 54: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.6980e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.9259e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 54: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_54/score.txt\n",
      "epoch:54, test:  val_ACC=0.7088, HTER=0.2912, AUC=0.7783, val_err=0.2912, ACC=0.7088, TPR=0.3151\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 55: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8548e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.1140e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 55: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  6.99batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_55/score.txt\n",
      "epoch:55, test:  val_ACC=0.6001, HTER=0.3999, AUC=0.6340, val_err=0.4000, ACC=0.6001, TPR=0.0933\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 56: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.4845e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.2838e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0008, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 56: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.16batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_56/score.txt\n",
      "epoch:56, test:  val_ACC=0.6525, HTER=0.3475, AUC=0.7028, val_err=0.3475, ACC=0.6525, TPR=0.1455\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 57: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.6369e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0842e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 57: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.04batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_57/score.txt\n",
      "epoch:57, test:  val_ACC=0.7132, HTER=0.2868, AUC=0.7695, val_err=0.2868, ACC=0.7132, TPR=0.2351\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 58: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.6889e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.2958e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 58: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.14batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_58/score.txt\n",
      "epoch:58, test:  val_ACC=0.6728, HTER=0.3272, AUC=0.7239, val_err=0.3272, ACC=0.6728, TPR=0.1676\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 59: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.1421e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.9752e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 59: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.89batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_59/score.txt\n",
      "epoch:59, test:  val_ACC=0.6618, HTER=0.3383, AUC=0.7412, val_err=0.3383, ACC=0.6618, TPR=0.2945\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 60: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.6144e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.8342e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 60: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.87batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_60/score.txt\n",
      "epoch:60, test:  val_ACC=0.7102, HTER=0.2898, AUC=0.7874, val_err=0.2898, ACC=0.7102, TPR=0.2878\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 61: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.4590e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.6106e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 61: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.92batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_61/score.txt\n",
      "epoch:61, test:  val_ACC=0.6089, HTER=0.3912, AUC=0.6581, val_err=0.3911, ACC=0.6089, TPR=0.2622\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 62: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(8.1377e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.8185e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 62: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_62/score.txt\n",
      "epoch:62, test:  val_ACC=0.6262, HTER=0.3738, AUC=0.6628, val_err=0.3738, ACC=0.6262, TPR=0.1878\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 63: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.3766e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.1499e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 63: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  6.99batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_63/score.txt\n",
      "epoch:63, test:  val_ACC=0.6237, HTER=0.3763, AUC=0.6464, val_err=0.3764, ACC=0.6237, TPR=0.1974\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 64: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.4057e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.9976e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 64: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.84batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_64/score.txt\n",
      "epoch:64, test:  val_ACC=0.7701, HTER=0.2299, AUC=0.8444, val_err=0.2299, ACC=0.7701, TPR=0.6419\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 65: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.8391e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.8837e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0007, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 65: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.92batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_65/score.txt\n",
      "epoch:65, test:  val_ACC=0.6542, HTER=0.3459, AUC=0.7065, val_err=0.3459, ACC=0.6542, TPR=0.2576\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 66: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.3476e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.5458e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 66: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.84batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_66/score.txt\n",
      "epoch:66, test:  val_ACC=0.7119, HTER=0.2882, AUC=0.7840, val_err=0.2882, ACC=0.7119, TPR=0.4476\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 67: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.7123e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.7723e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 67: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_67/score.txt\n",
      "epoch:67, test:  val_ACC=0.7681, HTER=0.2319, AUC=0.8307, val_err=0.2319, ACC=0.7681, TPR=0.2410\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 68: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.2244e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2484e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 68: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_68/score.txt\n",
      "epoch:68, test:  val_ACC=0.7826, HTER=0.2175, AUC=0.8774, val_err=0.2174, ACC=0.7826, TPR=0.5261\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 69: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.7576e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2089e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 69: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.92batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_69/score.txt\n",
      "epoch:69, test:  val_ACC=0.7050, HTER=0.2950, AUC=0.7832, val_err=0.2950, ACC=0.7050, TPR=0.2693\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 70: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.0355e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.4409e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 70: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_70/score.txt\n",
      "epoch:70, test:  val_ACC=0.7290, HTER=0.2711, AUC=0.8315, val_err=0.2711, ACC=0.7290, TPR=0.4448\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 71: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.9591e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.9255e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 71: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_71/score.txt\n",
      "epoch:71, test:  val_ACC=0.7083, HTER=0.2917, AUC=0.7933, val_err=0.2917, ACC=0.7083, TPR=0.5444\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 72: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7468e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.5650e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 72: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.93batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_72/score.txt\n",
      "epoch:72, test:  val_ACC=0.6844, HTER=0.3157, AUC=0.7472, val_err=0.3157, ACC=0.6844, TPR=0.2182\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 73: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0446e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.5269e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 73: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.84batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_73/score.txt\n",
      "epoch:73, test:  val_ACC=0.7050, HTER=0.2950, AUC=0.7833, val_err=0.2950, ACC=0.7050, TPR=0.3984\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 74: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.0156e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0403e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 74: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_74/score.txt\n",
      "epoch:74, test:  val_ACC=0.7253, HTER=0.2748, AUC=0.7819, val_err=0.2747, ACC=0.7253, TPR=0.2516\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 75: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.7774e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.8823e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 75: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_75/score.txt\n",
      "epoch:75, test:  val_ACC=0.6278, HTER=0.3722, AUC=0.6821, val_err=0.3722, ACC=0.6278, TPR=0.1123\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 76: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.5595e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.3108e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 76: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_76/score.txt\n",
      "epoch:76, test:  val_ACC=0.6597, HTER=0.3403, AUC=0.7226, val_err=0.3403, ACC=0.6597, TPR=0.1974\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 77: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.6547e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.6849e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0006, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 77: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.06batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_77/score.txt\n",
      "epoch:77, test:  val_ACC=0.5837, HTER=0.4164, AUC=0.6226, val_err=0.4163, ACC=0.5837, TPR=0.0996\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 78: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.9365e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.9528e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 78: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.95batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_78/score.txt\n",
      "epoch:78, test:  val_ACC=0.7082, HTER=0.2917, AUC=0.7963, val_err=0.2918, ACC=0.7082, TPR=0.2963\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 79: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.6184e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.4808e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 79: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.95batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_79/score.txt\n",
      "epoch:79, test:  val_ACC=0.6149, HTER=0.3851, AUC=0.6616, val_err=0.3851, ACC=0.6149, TPR=0.1650\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 80: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.0069e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.9364e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 80: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_80/score.txt\n",
      "epoch:80, test:  val_ACC=0.6614, HTER=0.3387, AUC=0.7342, val_err=0.3387, ACC=0.6614, TPR=0.2704\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 81: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.0261e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.1006e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 81: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.91batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_81/score.txt\n",
      "epoch:81, test:  val_ACC=0.6829, HTER=0.3171, AUC=0.7396, val_err=0.3171, ACC=0.6829, TPR=0.2605\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 82: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.3202e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.2603e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 82: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.04batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_82/score.txt\n",
      "epoch:82, test:  val_ACC=0.7411, HTER=0.2589, AUC=0.8260, val_err=0.2589, ACC=0.7411, TPR=0.4279\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 83: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.0884e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.6089e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 83: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_83/score.txt\n",
      "epoch:83, test:  val_ACC=0.7392, HTER=0.2607, AUC=0.8101, val_err=0.2608, ACC=0.7392, TPR=0.1826\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 84: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.6301e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.1077e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 84: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.90batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_84/score.txt\n",
      "epoch:84, test:  val_ACC=0.6984, HTER=0.3016, AUC=0.7916, val_err=0.3016, ACC=0.6984, TPR=0.3626\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 85: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.9966e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.4649e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 85: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.06batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_85/score.txt\n",
      "epoch:85, test:  val_ACC=0.6657, HTER=0.3344, AUC=0.7381, val_err=0.3344, ACC=0.6657, TPR=0.4253\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 86: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.6113e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.9290e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 86: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.89batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_86/score.txt\n",
      "epoch:86, test:  val_ACC=0.6968, HTER=0.3032, AUC=0.7756, val_err=0.3032, ACC=0.6968, TPR=0.2444\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 87: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.5208e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.8015e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 87: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.04batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_87/score.txt\n",
      "epoch:87, test:  val_ACC=0.7338, HTER=0.2663, AUC=0.8085, val_err=0.2662, ACC=0.7338, TPR=0.3613\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 88: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.0840e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.4946e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 88: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.10batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_88/score.txt\n",
      "epoch:88, test:  val_ACC=0.7542, HTER=0.2458, AUC=0.8225, val_err=0.2458, ACC=0.7542, TPR=0.3661\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 89: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.8832e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2317e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 89: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.97batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_89/score.txt\n",
      "epoch:89, test:  val_ACC=0.7911, HTER=0.2089, AUC=0.8706, val_err=0.2089, ACC=0.7911, TPR=0.4626\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 90: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.3212e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.2599e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 90: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_90/score.txt\n",
      "epoch:90, test:  val_ACC=0.7115, HTER=0.2886, AUC=0.7950, val_err=0.2886, ACC=0.7115, TPR=0.2817\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 91: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.2770e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.3705e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 91: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.98batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_91/score.txt\n",
      "epoch:91, test:  val_ACC=0.6835, HTER=0.3166, AUC=0.7617, val_err=0.3166, ACC=0.6835, TPR=0.1384\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 92: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.0300e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.2848e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 92: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.92batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_92/score.txt\n",
      "epoch:92, test:  val_ACC=0.7753, HTER=0.2247, AUC=0.8525, val_err=0.2248, ACC=0.7753, TPR=0.4192\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 93: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.4881e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.6327e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 93: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.17batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_93/score.txt\n",
      "epoch:93, test:  val_ACC=0.7057, HTER=0.2943, AUC=0.7797, val_err=0.2943, ACC=0.7057, TPR=0.3570\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 94: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7597e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.2264e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 94: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.88batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_94/score.txt\n",
      "epoch:94, test:  val_ACC=0.7024, HTER=0.2976, AUC=0.7613, val_err=0.2976, ACC=0.7024, TPR=0.4186\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 95: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.9439e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.8198e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 95: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_95/score.txt\n",
      "epoch:95, test:  val_ACC=0.7306, HTER=0.2694, AUC=0.8283, val_err=0.2694, ACC=0.7306, TPR=0.4463\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 96: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.0757e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.8742e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 96: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.10batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_96/score.txt\n",
      "epoch:96, test:  val_ACC=0.6865, HTER=0.3136, AUC=0.7680, val_err=0.3135, ACC=0.6865, TPR=0.3140\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 97: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.6247e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0385e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 97: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.83batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_97/score.txt\n",
      "epoch:97, test:  val_ACC=0.7384, HTER=0.2616, AUC=0.8135, val_err=0.2616, ACC=0.7384, TPR=0.3283\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 98: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.5248e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.7591e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 98: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.96batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_98/score.txt\n",
      "epoch:98, test:  val_ACC=0.7143, HTER=0.2858, AUC=0.7864, val_err=0.2857, ACC=0.7143, TPR=0.1958\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 99: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0717e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.7056e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 99: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_99/score.txt\n",
      "epoch:99, test:  val_ACC=0.7459, HTER=0.2542, AUC=0.8214, val_err=0.2542, ACC=0.7459, TPR=0.3348\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 100: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.0224e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.4130e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 100: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.14batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_100/score.txt\n",
      "epoch:100, test:  val_ACC=0.7853, HTER=0.2147, AUC=0.8425, val_err=0.2147, ACC=0.7853, TPR=0.1841\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 101: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.9695e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.9191e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0005, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 101: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_101/score.txt\n",
      "epoch:101, test:  val_ACC=0.7343, HTER=0.2657, AUC=0.8141, val_err=0.2657, ACC=0.7343, TPR=0.2880\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 102: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.4738e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(7.1568e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 102: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.88batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_102/score.txt\n",
      "epoch:102, test:  val_ACC=0.7543, HTER=0.2457, AUC=0.8145, val_err=0.2458, ACC=0.7543, TPR=0.1926\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 103: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0300e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0056e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 103: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.98batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_103/score.txt\n",
      "epoch:103, test:  val_ACC=0.7516, HTER=0.2485, AUC=0.8237, val_err=0.2485, ACC=0.7516, TPR=0.2518\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 104: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.3821e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.4638e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 104: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.87batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_104/score.txt\n",
      "epoch:104, test:  val_ACC=0.6816, HTER=0.3184, AUC=0.7723, val_err=0.3184, ACC=0.6816, TPR=0.2861\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 105: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.7705e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.6123e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 105: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.13batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_105/score.txt\n",
      "epoch:105, test:  val_ACC=0.7270, HTER=0.2730, AUC=0.8135, val_err=0.2730, ACC=0.7270, TPR=0.2115\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 106: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.1718e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.3189e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 106: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:47<00:00,  7.29batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_106/score.txt\n",
      "epoch:106, test:  val_ACC=0.7289, HTER=0.2711, AUC=0.8072, val_err=0.2711, ACC=0.7289, TPR=0.2193\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 107: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.1959e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.9258e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 107: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_107/score.txt\n",
      "epoch:107, test:  val_ACC=0.7913, HTER=0.2087, AUC=0.8716, val_err=0.2087, ACC=0.7913, TPR=0.3739\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 108: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7734e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.2627e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 108: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_108/score.txt\n",
      "epoch:108, test:  val_ACC=0.7172, HTER=0.2828, AUC=0.7900, val_err=0.2828, ACC=0.7172, TPR=0.1635\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 109: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.2591e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.4900e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 109: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.93batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_109/score.txt\n",
      "epoch:109, test:  val_ACC=0.6556, HTER=0.3444, AUC=0.7351, val_err=0.3444, ACC=0.6556, TPR=0.2212\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 110: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.5658e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.3424e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 110: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_110/score.txt\n",
      "epoch:110, test:  val_ACC=0.7071, HTER=0.2930, AUC=0.7898, val_err=0.2930, ACC=0.7071, TPR=0.2474\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 111: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.1480e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.7110e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 111: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.93batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_111/score.txt\n",
      "epoch:111, test:  val_ACC=0.7328, HTER=0.2672, AUC=0.8052, val_err=0.2672, ACC=0.7328, TPR=0.3374\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 112: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.6811e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.0512e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 112: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_112/score.txt\n",
      "epoch:112, test:  val_ACC=0.7708, HTER=0.2292, AUC=0.8433, val_err=0.2293, ACC=0.7708, TPR=0.4880\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 113: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.7659e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.4604e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 113: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.93batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_113/score.txt\n",
      "epoch:113, test:  val_ACC=0.7246, HTER=0.2754, AUC=0.8066, val_err=0.2754, ACC=0.7246, TPR=0.2911\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 114: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.4451e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.1212e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 114: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.04batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_114/score.txt\n",
      "epoch:114, test:  val_ACC=0.7383, HTER=0.2617, AUC=0.8167, val_err=0.2617, ACC=0.7383, TPR=0.2910\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 115: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.8029e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.5472e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 115: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.90batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_115/score.txt\n",
      "epoch:115, test:  val_ACC=0.7063, HTER=0.2937, AUC=0.7835, val_err=0.2937, ACC=0.7063, TPR=0.2373\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 116: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.3980e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0976e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 116: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_116/score.txt\n",
      "epoch:116, test:  val_ACC=0.6584, HTER=0.3416, AUC=0.7215, val_err=0.3416, ACC=0.6584, TPR=0.0952\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 117: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.8395e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.5811e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 117: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_117/score.txt\n",
      "epoch:117, test:  val_ACC=0.7571, HTER=0.2429, AUC=0.8426, val_err=0.2429, ACC=0.7571, TPR=0.3101\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 118: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(8.8866e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.4117e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 118: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_118/score.txt\n",
      "epoch:118, test:  val_ACC=0.6832, HTER=0.3169, AUC=0.7538, val_err=0.3169, ACC=0.6832, TPR=0.2177\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 119: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7715e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.0569e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 119: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.97batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_119/score.txt\n",
      "epoch:119, test:  val_ACC=0.6837, HTER=0.3164, AUC=0.7580, val_err=0.3164, ACC=0.6837, TPR=0.2821\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 120: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0366e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.4866e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 120: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.09batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_120/score.txt\n",
      "epoch:120, test:  val_ACC=0.7439, HTER=0.2561, AUC=0.8269, val_err=0.2560, ACC=0.7439, TPR=0.3656\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 121: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(8.0994e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.2405e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 121: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_121/score.txt\n",
      "epoch:121, test:  val_ACC=0.6695, HTER=0.3305, AUC=0.7660, val_err=0.3305, ACC=0.6695, TPR=0.2824\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 122: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.3594e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2759e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 122: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.18batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_122/score.txt\n",
      "epoch:122, test:  val_ACC=0.7538, HTER=0.2462, AUC=0.8517, val_err=0.2462, ACC=0.7538, TPR=0.5329\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 123: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.7424e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.4974e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 123: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_123/score.txt\n",
      "epoch:123, test:  val_ACC=0.7213, HTER=0.2787, AUC=0.8075, val_err=0.2787, ACC=0.7213, TPR=0.3798\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 124: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.1557e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.4721e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 124: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_124/score.txt\n",
      "epoch:124, test:  val_ACC=0.7377, HTER=0.2624, AUC=0.8410, val_err=0.2624, ACC=0.7377, TPR=0.5504\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 125: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.9293e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.3597e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0004, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 125: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.05batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_125/score.txt\n",
      "epoch:125, test:  val_ACC=0.7365, HTER=0.2635, AUC=0.8248, val_err=0.2635, ACC=0.7365, TPR=0.4448\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 126: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.2224e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.6083e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 126: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_126/score.txt\n",
      "epoch:126, test:  val_ACC=0.6365, HTER=0.3635, AUC=0.7135, val_err=0.3635, ACC=0.6365, TPR=0.2331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 127: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.4349e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.6998e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 127: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.04batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_127/score.txt\n",
      "epoch:127, test:  val_ACC=0.6943, HTER=0.3058, AUC=0.7807, val_err=0.3058, ACC=0.6943, TPR=0.4199\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 128: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7327e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2581e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 128: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.94batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_128/score.txt\n",
      "epoch:128, test:  val_ACC=0.7618, HTER=0.2383, AUC=0.8514, val_err=0.2382, ACC=0.7618, TPR=0.5341\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 129: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.8558e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.2228e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 129: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.22batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_129/score.txt\n",
      "epoch:129, test:  val_ACC=0.6840, HTER=0.3160, AUC=0.7662, val_err=0.3160, ACC=0.6840, TPR=0.2904\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 130: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.0829e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.6475e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 130: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_130/score.txt\n",
      "epoch:130, test:  val_ACC=0.7100, HTER=0.2900, AUC=0.7930, val_err=0.2900, ACC=0.7100, TPR=0.2826\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 131: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.1255e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(7.4938e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 131: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.10batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_131/score.txt\n",
      "epoch:131, test:  val_ACC=0.6732, HTER=0.3268, AUC=0.7514, val_err=0.3268, ACC=0.6732, TPR=0.1852\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 132: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.1685e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.6727e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 132: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_132/score.txt\n",
      "epoch:132, test:  val_ACC=0.7921, HTER=0.2079, AUC=0.8708, val_err=0.2079, ACC=0.7921, TPR=0.4335\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 133: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.9529e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.5127e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 133: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.16batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_133/score.txt\n",
      "epoch:133, test:  val_ACC=0.7950, HTER=0.2050, AUC=0.8734, val_err=0.2050, ACC=0.7950, TPR=0.4272\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 134: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.1271e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.7537e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 134: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.04batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_134/score.txt\n",
      "epoch:134, test:  val_ACC=0.8141, HTER=0.1859, AUC=0.8863, val_err=0.1859, ACC=0.8141, TPR=0.5094\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 135: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.2382e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.2339e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 135: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.05batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_135/score.txt\n",
      "epoch:135, test:  val_ACC=0.7568, HTER=0.2433, AUC=0.8472, val_err=0.2433, ACC=0.7568, TPR=0.3515\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 136: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.6659e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.4508e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 136: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  6.99batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_136/score.txt\n",
      "epoch:136, test:  val_ACC=0.7753, HTER=0.2247, AUC=0.8675, val_err=0.2247, ACC=0.7753, TPR=0.4828\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 137: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.6913e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.1839e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 137: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:47<00:00,  7.31batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_137/score.txt\n",
      "epoch:137, test:  val_ACC=0.7850, HTER=0.2150, AUC=0.8860, val_err=0.2150, ACC=0.7850, TPR=0.5758\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 138: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.3839e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.1510e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 138: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.13batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_138/score.txt\n",
      "epoch:138, test:  val_ACC=0.7428, HTER=0.2572, AUC=0.8071, val_err=0.2572, ACC=0.7428, TPR=0.2368\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 139: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.3409e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.0881e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 139: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_139/score.txt\n",
      "epoch:139, test:  val_ACC=0.7180, HTER=0.2821, AUC=0.8083, val_err=0.2821, ACC=0.7180, TPR=0.2730\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 140: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.3191e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.3445e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 140: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_140/score.txt\n",
      "epoch:140, test:  val_ACC=0.6896, HTER=0.3105, AUC=0.7687, val_err=0.3105, ACC=0.6896, TPR=0.1642\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 141: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.7868e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.1019e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 141: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_141/score.txt\n",
      "epoch:141, test:  val_ACC=0.7857, HTER=0.2143, AUC=0.8557, val_err=0.2143, ACC=0.7857, TPR=0.4192\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 142: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.6755e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.8998e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 142: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.90batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_142/score.txt\n",
      "epoch:142, test:  val_ACC=0.7080, HTER=0.2921, AUC=0.7765, val_err=0.2921, ACC=0.7080, TPR=0.2657\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 143: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.2201e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.3527e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 143: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.09batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_143/score.txt\n",
      "epoch:143, test:  val_ACC=0.7674, HTER=0.2325, AUC=0.8465, val_err=0.2326, ACC=0.7674, TPR=0.4715\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 144: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.75batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7967e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.9762e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 144: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_144/score.txt\n",
      "epoch:144, test:  val_ACC=0.7130, HTER=0.2871, AUC=0.7966, val_err=0.2870, ACC=0.7130, TPR=0.3195\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 145: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.6276e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.3689e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 145: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_145/score.txt\n",
      "epoch:145, test:  val_ACC=0.7365, HTER=0.2635, AUC=0.8390, val_err=0.2635, ACC=0.7365, TPR=0.4179\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 146: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.4334e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.5201e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 146: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.96batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_146/score.txt\n",
      "epoch:146, test:  val_ACC=0.8042, HTER=0.1958, AUC=0.8759, val_err=0.1958, ACC=0.8042, TPR=0.5255\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 147: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.5799e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.0660e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 147: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.23batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_147/score.txt\n",
      "epoch:147, test:  val_ACC=0.8670, HTER=0.1330, AUC=0.9482, val_err=0.1330, ACC=0.8670, TPR=0.7604\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 148: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.2387e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.9286e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 148: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.75batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_148/score.txt\n",
      "epoch:148, test:  val_ACC=0.8223, HTER=0.1778, AUC=0.9066, val_err=0.1778, ACC=0.8223, TPR=0.5749\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 149: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.7338e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.3965e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 149: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_149/score.txt\n",
      "epoch:149, test:  val_ACC=0.8216, HTER=0.1785, AUC=0.9135, val_err=0.1784, ACC=0.8216, TPR=0.6782\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 150: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.8785e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.9490e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 150: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.82batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_150/score.txt\n",
      "epoch:150, test:  val_ACC=0.7959, HTER=0.2041, AUC=0.8687, val_err=0.2041, ACC=0.7959, TPR=0.5656\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 151: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.2834e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.3656e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 151: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_151/score.txt\n",
      "epoch:151, test:  val_ACC=0.7997, HTER=0.2004, AUC=0.8703, val_err=0.2003, ACC=0.7997, TPR=0.3880\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 152: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.75batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.2815e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.6896e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 152: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_152/score.txt\n",
      "epoch:152, test:  val_ACC=0.7169, HTER=0.2832, AUC=0.8055, val_err=0.2832, ACC=0.7169, TPR=0.2882\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 153: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.5905e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.9988e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 153: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:47<00:00,  7.34batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_153/score.txt\n",
      "epoch:153, test:  val_ACC=0.5961, HTER=0.4040, AUC=0.6807, val_err=0.4040, ACC=0.5961, TPR=0.2010\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 154: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.6031e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.3358e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 154: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_154/score.txt\n",
      "epoch:154, test:  val_ACC=0.7156, HTER=0.2845, AUC=0.7995, val_err=0.2845, ACC=0.7156, TPR=0.2603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 155: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7092e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.2822e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 155: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_155/score.txt\n",
      "epoch:155, test:  val_ACC=0.7765, HTER=0.2236, AUC=0.8599, val_err=0.2236, ACC=0.7765, TPR=0.3297\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 156: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.9816e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.9194e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 156: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.09batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_156/score.txt\n",
      "epoch:156, test:  val_ACC=0.8284, HTER=0.1716, AUC=0.9074, val_err=0.1716, ACC=0.8284, TPR=0.6536\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 157: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.5616e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.4633e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 157: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_157/score.txt\n",
      "epoch:157, test:  val_ACC=0.7922, HTER=0.2078, AUC=0.8638, val_err=0.2078, ACC=0.7922, TPR=0.3923\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 158: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.83batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8882e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.3095e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 158: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.14batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_158/score.txt\n",
      "epoch:158, test:  val_ACC=0.8031, HTER=0.1969, AUC=0.8708, val_err=0.1970, ACC=0.8031, TPR=0.3869\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 159: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7722e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.4232e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 159: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.21batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_159/score.txt\n",
      "epoch:159, test:  val_ACC=0.7500, HTER=0.2500, AUC=0.8283, val_err=0.2500, ACC=0.7500, TPR=0.5472\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 160: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.9867e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.8263e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 160: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_160/score.txt\n",
      "epoch:160, test:  val_ACC=0.8123, HTER=0.1878, AUC=0.8891, val_err=0.1878, ACC=0.8123, TPR=0.5784\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 161: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.2558e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2775e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 161: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.18batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_161/score.txt\n",
      "epoch:161, test:  val_ACC=0.8397, HTER=0.1603, AUC=0.9068, val_err=0.1603, ACC=0.8397, TPR=0.5847\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 162: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8673e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.6880e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 162: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_162/score.txt\n",
      "epoch:162, test:  val_ACC=0.8553, HTER=0.1447, AUC=0.9228, val_err=0.1447, ACC=0.8553, TPR=0.5452\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 163: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:59<00:00,  6.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.8338e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.9811e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 163: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_163/score.txt\n",
      "epoch:163, test:  val_ACC=0.8059, HTER=0.1941, AUC=0.8805, val_err=0.1941, ACC=0.8059, TPR=0.4916\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 164: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.4838e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.2944e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 164: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_164/score.txt\n",
      "epoch:164, test:  val_ACC=0.7635, HTER=0.2366, AUC=0.8369, val_err=0.2366, ACC=0.7635, TPR=0.3557\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 165: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.1158e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2520e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 165: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.96batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_165/score.txt\n",
      "epoch:165, test:  val_ACC=0.7965, HTER=0.2036, AUC=0.8684, val_err=0.2036, ACC=0.7965, TPR=0.3821\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 166: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7716e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.9131e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 166: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_166/score.txt\n",
      "epoch:166, test:  val_ACC=0.7920, HTER=0.2080, AUC=0.8738, val_err=0.2080, ACC=0.7920, TPR=0.4943\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 167: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.6382e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.9027e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 167: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.18batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_167/score.txt\n",
      "epoch:167, test:  val_ACC=0.7998, HTER=0.2002, AUC=0.8768, val_err=0.2002, ACC=0.7998, TPR=0.5120\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 168: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.8637e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0226e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 168: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.95batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_168/score.txt\n",
      "epoch:168, test:  val_ACC=0.7432, HTER=0.2568, AUC=0.8206, val_err=0.2568, ACC=0.7432, TPR=0.3567\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 169: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7569e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.1200e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 169: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.10batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_169/score.txt\n",
      "epoch:169, test:  val_ACC=0.7536, HTER=0.2464, AUC=0.8421, val_err=0.2464, ACC=0.7536, TPR=0.4634\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 170: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.4883e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.6723e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 170: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.23batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_170/score.txt\n",
      "epoch:170, test:  val_ACC=0.7645, HTER=0.2355, AUC=0.8481, val_err=0.2355, ACC=0.7645, TPR=0.4786\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 171: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.9290e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.9709e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 171: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_171/score.txt\n",
      "epoch:171, test:  val_ACC=0.7226, HTER=0.2774, AUC=0.8035, val_err=0.2774, ACC=0.7226, TPR=0.4641\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 172: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.9797e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.6320e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 172: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_172/score.txt\n",
      "epoch:172, test:  val_ACC=0.6698, HTER=0.3303, AUC=0.7554, val_err=0.3303, ACC=0.6698, TPR=0.3489\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 173: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0122e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.2919e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 173: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.18batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_173/score.txt\n",
      "epoch:173, test:  val_ACC=0.7321, HTER=0.2679, AUC=0.8140, val_err=0.2679, ACC=0.7321, TPR=0.4325\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 174: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7779e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.2461e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 174: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.94batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_174/score.txt\n",
      "epoch:174, test:  val_ACC=0.7868, HTER=0.2132, AUC=0.8580, val_err=0.2132, ACC=0.7868, TPR=0.5860\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 175: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.8823e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.8243e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 175: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.06batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_175/score.txt\n",
      "epoch:175, test:  val_ACC=0.7529, HTER=0.2471, AUC=0.8344, val_err=0.2471, ACC=0.7529, TPR=0.5322\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 176: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.7347e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.2358e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0003, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 176: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_176/score.txt\n",
      "epoch:176, test:  val_ACC=0.8178, HTER=0.1822, AUC=0.9014, val_err=0.1822, ACC=0.8178, TPR=0.6732\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 177: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.9469e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(7.9726e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 177: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_177/score.txt\n",
      "epoch:177, test:  val_ACC=0.8243, HTER=0.1757, AUC=0.8963, val_err=0.1757, ACC=0.8243, TPR=0.6487\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 178: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.5675e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.6157e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 178: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.27batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_178/score.txt\n",
      "epoch:178, test:  val_ACC=0.8165, HTER=0.1835, AUC=0.8959, val_err=0.1835, ACC=0.8165, TPR=0.6300\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 179: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7029e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.3952e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 179: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.20batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_179/score.txt\n",
      "epoch:179, test:  val_ACC=0.8357, HTER=0.1643, AUC=0.9016, val_err=0.1643, ACC=0.8357, TPR=0.6736\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 180: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.2362e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.3139e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 180: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.14batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_180/score.txt\n",
      "epoch:180, test:  val_ACC=0.7959, HTER=0.2041, AUC=0.8824, val_err=0.2041, ACC=0.7959, TPR=0.5739\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 181: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.2658e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.2981e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 181: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_181/score.txt\n",
      "epoch:181, test:  val_ACC=0.7525, HTER=0.2475, AUC=0.8364, val_err=0.2475, ACC=0.7525, TPR=0.3062\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 182: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.1030e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.5551e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 182: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.94batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_182/score.txt\n",
      "epoch:182, test:  val_ACC=0.7717, HTER=0.2284, AUC=0.8650, val_err=0.2284, ACC=0.7717, TPR=0.3921\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 183: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0501e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.0581e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 183: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.11batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_183/score.txt\n",
      "epoch:183, test:  val_ACC=0.7313, HTER=0.2687, AUC=0.8225, val_err=0.2688, ACC=0.7313, TPR=0.2930\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 184: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.4897e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0889e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 184: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.01batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_184/score.txt\n",
      "epoch:184, test:  val_ACC=0.7430, HTER=0.2570, AUC=0.8076, val_err=0.2570, ACC=0.7430, TPR=0.2399\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 185: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.5870e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.5041e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 185: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.91batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_185/score.txt\n",
      "epoch:185, test:  val_ACC=0.7287, HTER=0.2713, AUC=0.8064, val_err=0.2714, ACC=0.7287, TPR=0.2936\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 186: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(8.5310e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.4570e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 186: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.03batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_186/score.txt\n",
      "epoch:186, test:  val_ACC=0.7306, HTER=0.2694, AUC=0.8243, val_err=0.2694, ACC=0.7306, TPR=0.4374\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 187: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.4661e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.7903e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 187: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.10batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_187/score.txt\n",
      "epoch:187, test:  val_ACC=0.7496, HTER=0.2505, AUC=0.8302, val_err=0.2505, ACC=0.7496, TPR=0.3914\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 188: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.9022e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(8.3840e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 188: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_188/score.txt\n",
      "epoch:188, test:  val_ACC=0.7595, HTER=0.2405, AUC=0.8384, val_err=0.2405, ACC=0.7595, TPR=0.5342\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 189: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(4.7523e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.5072e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 189: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.90batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_189/score.txt\n",
      "epoch:189, test:  val_ACC=0.7979, HTER=0.2021, AUC=0.8793, val_err=0.2021, ACC=0.7979, TPR=0.5886\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 190: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(9.7236e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.6812e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 190: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_190/score.txt\n",
      "epoch:190, test:  val_ACC=0.8183, HTER=0.1817, AUC=0.8853, val_err=0.1818, ACC=0.8183, TPR=0.5457\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 191: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.3484e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(2.3317e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 191: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_191/score.txt\n",
      "epoch:191, test:  val_ACC=0.7894, HTER=0.2106, AUC=0.8654, val_err=0.2106, ACC=0.7894, TPR=0.4461\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 192: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.6306e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(9.8942e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 192: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.16batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_192/score.txt\n",
      "epoch:192, test:  val_ACC=0.7557, HTER=0.2444, AUC=0.8349, val_err=0.2444, ACC=0.7557, TPR=0.3516\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 193: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.8840e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.8012e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 193: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:51<00:00,  6.83batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_193/score.txt\n",
      "epoch:193, test:  val_ACC=0.7973, HTER=0.2028, AUC=0.8701, val_err=0.2028, ACC=0.7973, TPR=0.4478\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 194: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.77batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.9894e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.6027e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 194: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.18batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_194/score.txt\n",
      "epoch:194, test:  val_ACC=0.7918, HTER=0.2082, AUC=0.8774, val_err=0.2083, ACC=0.7918, TPR=0.5912\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 195: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.0400e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(3.8687e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 195: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.20batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_195/score.txt\n",
      "epoch:195, test:  val_ACC=0.7547, HTER=0.2453, AUC=0.8280, val_err=0.2453, ACC=0.7547, TPR=0.3485\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 196: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.7047e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.1876e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 196: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.00batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_196/score.txt\n",
      "epoch:196, test:  val_ACC=0.7749, HTER=0.2251, AUC=0.8320, val_err=0.2251, ACC=0.7749, TPR=0.4964\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 197: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.2490e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.9151e-08, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 197: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:48<00:00,  7.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_197/score.txt\n",
      "epoch:197, test:  val_ACC=0.7620, HTER=0.2381, AUC=0.8119, val_err=0.2381, ACC=0.7620, TPR=0.3828\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 198: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.5151e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.4991e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 198: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.09batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_198/score.txt\n",
      "epoch:198, test:  val_ACC=0.7679, HTER=0.2321, AUC=0.8456, val_err=0.2322, ACC=0.7679, TPR=0.3375\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 199: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:57<00:00,  6.81batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.4553e-09, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.3462e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 199: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:49<00:00,  7.02batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_199/score.txt\n",
      "epoch:199, test:  val_ACC=0.7273, HTER=0.2728, AUC=0.8090, val_err=0.2728, ACC=0.7273, TPR=0.3485\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 200: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.80batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(8.8690e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.0143e-06, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 200: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:50<00:00,  6.92batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_200/score.txt\n",
      "epoch:200, test:  val_ACC=0.7206, HTER=0.2795, AUC=0.8079, val_err=0.2795, ACC=0.7206, TPR=0.4567\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 201: 100%|██████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [02:58<00:00,  6.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(5.8638e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(1.5870e-07, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:0', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 201: 100%|████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:47<00:00,  7.37batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_201/score.txt\n",
      "epoch:201, test:  val_ACC=0.7369, HTER=0.2631, AUC=0.8148, val_err=0.2631, ACC=0.7369, TPR=0.3474\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 202:   3%|██▌                                                                                     | 36/1212 [00:09<05:10,  3.79batch/s]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Input \u001b[0;32mIn [3]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m best_auc \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1000\u001b[39m):\n\u001b[0;32m----> 3\u001b[0m     \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mepoch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m***************************\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;66;03m#print(\"train : \")\u001b[39;00m\n\u001b[1;32m      6\u001b[0m     \u001b[38;5;66;03m#train_auc = test(train_loader,epoch)\u001b[39;00m\n",
      "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mtrain\u001b[0;34m(epoch)\u001b[0m\n\u001b[1;32m    251\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m :\n\u001b[1;32m    253\u001b[0m     index_arr \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m29952\u001b[39m, (\u001b[38;5;241m64\u001b[39m,))\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[0;32m--> 257\u001b[0m out,domain_invariant,node_pre \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43medge_index\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43mdrop_en\u001b[49m\u001b[43m,\u001b[49m\u001b[43mindex_arr\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Perform a single forward pass.\u001b[39;00m\n\u001b[1;32m    259\u001b[0m adv_loss \u001b[38;5;241m=\u001b[39m criterion_2(domain_invariant, graph\u001b[38;5;241m.\u001b[39mdata)\n\u001b[1;32m    261\u001b[0m node_cls_loss \u001b[38;5;241m=\u001b[39m criterion_node_class(node_pre\u001b[38;5;241m.\u001b[39msqueeze(),graph\u001b[38;5;241m.\u001b[39my_node\u001b[38;5;241m.\u001b[39mfloat()[index_arr])\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/module.py:1130\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1126\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1127\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1129\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1130\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m   1132\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mGCN.forward\u001b[0;34m(self, x, edge_index, batch, drop_en, index_arr)\u001b[0m\n\u001b[1;32m    207\u001b[0m \u001b[38;5;66;03m#print(node_class_hidden.shape)\u001b[39;00m\n\u001b[1;32m    208\u001b[0m node_class_hidden \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39munsqueeze(node_class_hidden, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m--> 210\u001b[0m node_pre \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlin_node_class\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnode_class_hidden\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    213\u001b[0m \u001b[38;5;66;03m#print(\"hiiii :\" , dicriminator.shape)\u001b[39;00m\n\u001b[1;32m    214\u001b[0m dis_invariant \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdis(dicriminator,edge_index,batch,drop_en)\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/module.py:1130\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1126\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1127\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1129\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1130\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m   1132\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "Input \u001b[0;32mIn [1]\u001b[0m, in \u001b[0;36mSimpleTransformer_2.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    158\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[1;32m    159\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlinear(x)  \u001b[38;5;66;03m# تغییر بعد ویژگی‌ها\u001b[39;00m\n\u001b[0;32m--> 160\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtransformer_encoder\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    161\u001b[0m     x \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mview(x\u001b[38;5;241m.\u001b[39msize(\u001b[38;5;241m0\u001b[39m), \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)  \u001b[38;5;66;03m# فشرده‌سازی به یک بردار برای طبقه‌بندی\u001b[39;00m\n\u001b[1;32m    162\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfc(x)\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/module.py:1130\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1126\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1127\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1129\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1130\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m   1132\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/transformer.py:238\u001b[0m, in \u001b[0;36mTransformerEncoder.forward\u001b[0;34m(self, src, mask, src_key_padding_mask)\u001b[0m\n\u001b[1;32m    236\u001b[0m         output \u001b[38;5;241m=\u001b[39m mod(output, src_mask\u001b[38;5;241m=\u001b[39mmask)\n\u001b[1;32m    237\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 238\u001b[0m         output \u001b[38;5;241m=\u001b[39m \u001b[43mmod\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msrc_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmask\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msrc_key_padding_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msrc_key_padding_mask\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    240\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m convert_to_nested:\n\u001b[1;32m    241\u001b[0m     output \u001b[38;5;241m=\u001b[39m output\u001b[38;5;241m.\u001b[39mto_padded_tensor(\u001b[38;5;241m0.\u001b[39m)\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/module.py:1130\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1126\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1127\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1129\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1130\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m   1132\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/transformer.py:464\u001b[0m, in \u001b[0;36mTransformerEncoderLayer.forward\u001b[0;34m(self, src, src_mask, src_key_padding_mask)\u001b[0m\n\u001b[1;32m    462\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    463\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnorm1(x \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sa_block(x, src_mask, src_key_padding_mask))\n\u001b[0;32m--> 464\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnorm2(x \u001b[38;5;241m+\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_ff_block\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    466\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/transformer.py:479\u001b[0m, in \u001b[0;36mTransformerEncoderLayer._ff_block\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    478\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_ff_block\u001b[39m(\u001b[38;5;28mself\u001b[39m, x: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 479\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlinear2(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdropout\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mactivation\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinear1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    480\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdropout2(x)\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/module.py:1130\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1126\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1127\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1129\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1130\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m   1132\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/dropout.py:58\u001b[0m, in \u001b[0;36mDropout.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m     57\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m---> 58\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdropout\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtraining\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minplace\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/functional.py:1252\u001b[0m, in \u001b[0;36mdropout\u001b[0;34m(input, p, training, inplace)\u001b[0m\n\u001b[1;32m   1250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m p \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0.0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m p \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1.0\u001b[39m:\n\u001b[1;32m   1251\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdropout probability has to be between 0 and 1, \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbut got \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(p))\n\u001b[0;32m-> 1252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _VF\u001b[38;5;241m.\u001b[39mdropout_(\u001b[38;5;28minput\u001b[39m, p, training) \u001b[38;5;28;01mif\u001b[39;00m inplace \u001b[38;5;28;01melse\u001b[39;00m \u001b[43m_VF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdropout\u001b[49m(\u001b[38;5;28minput\u001b[39m, p, training)\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/_VF.py:25\u001b[0m, in \u001b[0;36mVFModule.__getattr__\u001b[0;34m(self, attr)\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[38;5;28msuper\u001b[39m(VFModule, \u001b[38;5;28mself\u001b[39m)\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(name)\n\u001b[1;32m     23\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvf \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39m_C\u001b[38;5;241m.\u001b[39m_VariableFunctions\n\u001b[0;32m---> 25\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, attr):\n\u001b[1;32m     26\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvf, attr)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "best_auc = 0\n",
    "for epoch in range(0, 1000):\n",
    "    train(epoch)\n",
    "    print(\"***************************\")\n",
    "    #print(\"train : \")\n",
    "    #train_auc = test(train_loader,epoch)\n",
    "    print(\"test : \")\n",
    "    test_auc = test(test_loader,epoch)\n",
    "    if test_auc > best_auc:\n",
    "        print(\"improve acc .. .. ..\")\n",
    "        torch.save(model.state_dict(), 'Clip_two_domain_M_I_to_C_domain_generalization_tuning.pth')\n",
    "        best_auc = test_auc\n",
    "        continue  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a8f82e4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 83: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:48<00:00,  5.31batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.1684e-09, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.0146e-07, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 83: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [01:03<00:00,  5.51batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_83/score.txt\n",
      "epoch:83, test:  val_ACC=0.7612, HTER=0.2388, AUC=0.8384, val_err=0.2388, ACC=0.7612, TPR=0.3544\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 84: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [04:05<00:00,  4.95batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.1389e-07, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(6.3766e-07, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 84: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [01:02<00:00,  5.63batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_84/score.txt\n",
      "epoch:84, test:  val_ACC=0.8163, HTER=0.1837, AUC=0.8961, val_err=0.1837, ACC=0.8163, TPR=0.5366\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 85: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [04:13<00:00,  4.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(1.0456e-06, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.5979e-08, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 85: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [01:01<00:00,  5.68batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_85/score.txt\n",
      "epoch:85, test:  val_ACC=0.8317, HTER=0.1683, AUC=0.8995, val_err=0.1683, ACC=0.8317, TPR=0.5942\n",
      "improve acc .. .. ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 86: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:52<00:00,  5.20batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(3.6325e-08, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.3668e-10, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 86: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [01:01<00:00,  5.64batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_86/score.txt\n",
      "epoch:86, test:  val_ACC=0.8232, HTER=0.1768, AUC=0.8907, val_err=0.1768, ACC=0.8232, TPR=0.5585\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 87: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:53<00:00,  5.19batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(6.8489e-09, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(5.1000e-08, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 87: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:59<00:00,  5.88batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_87/score.txt\n",
      "epoch:87, test:  val_ACC=0.7876, HTER=0.2125, AUC=0.8630, val_err=0.2125, ACC=0.7876, TPR=0.5183\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 88: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:51<00:00,  5.23batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(7.9722e-09, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(4.4630e-06, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0002, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 88: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [01:00<00:00,  5.76batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_88/score.txt\n",
      "epoch:88, test:  val_ACC=0.8112, HTER=0.1888, AUC=0.8866, val_err=0.1888, ACC=0.8112, TPR=0.5955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 89: 100%|███████████████████████████████████████████████████████████████████████████████████████| 1212/1212 [03:55<00:00,  5.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/////////////////////////\n",
      "adverserial loss :  tensor(2.2009e-09, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification loss :  tensor(7.3312e-07, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "classification node loss :  tensor(0.0001, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "total loss :  tensor(0.0001, device='cuda:1', grad_fn=<DivBackward0>)\n",
      "////////////////////////////////////\n",
      "***************************\n",
      "test : \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 89: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 349/349 [00:57<00:00,  6.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: write test scores to /home/hassan-hossein/single_image_graph_face_anti_spoofing/train/Scores/epoch_89/score.txt\n",
      "epoch:89, test:  val_ACC=0.8160, HTER=0.1840, AUC=0.8867, val_err=0.1840, ACC=0.8160, TPR=0.5949\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 90:   3%|██▋                                                                                      | 37/1212 [00:10<05:41,  3.44batch/s]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Input \u001b[0;32mIn [3]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m best_auc \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.8606\u001b[39m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m82\u001b[39m, \u001b[38;5;241m1000\u001b[39m):\n\u001b[0;32m----> 4\u001b[0m     \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mepoch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m***************************\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      6\u001b[0m     \u001b[38;5;66;03m#print(\"train : \")\u001b[39;00m\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;66;03m#train_auc = test(train_loader,epoch)\u001b[39;00m\n",
      "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mtrain\u001b[0;34m(epoch)\u001b[0m\n\u001b[1;32m    251\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m :\n\u001b[1;32m    253\u001b[0m     index_arr \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m29952\u001b[39m, (\u001b[38;5;241m64\u001b[39m,))\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[0;32m--> 257\u001b[0m out,domain_invariant,node_pre \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43medge_index\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43mdrop_en\u001b[49m\u001b[43m,\u001b[49m\u001b[43mindex_arr\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Perform a single forward pass.\u001b[39;00m\n\u001b[1;32m    259\u001b[0m adv_loss \u001b[38;5;241m=\u001b[39m criterion_2(domain_invariant, graph\u001b[38;5;241m.\u001b[39mdata)\n\u001b[1;32m    261\u001b[0m node_cls_loss \u001b[38;5;241m=\u001b[39m criterion_node_class(node_pre\u001b[38;5;241m.\u001b[39msqueeze(),graph\u001b[38;5;241m.\u001b[39my_node\u001b[38;5;241m.\u001b[39mfloat()[index_arr])\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch/nn/modules/module.py:1130\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1126\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1127\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1129\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1130\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m   1132\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mGCN.forward\u001b[0;34m(self, x, edge_index, batch, drop_en, index_arr)\u001b[0m\n\u001b[1;32m    164\u001b[0m x \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mrelu()\n\u001b[1;32m    166\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdrop_5(x,drop_en)\n\u001b[0;32m--> 168\u001b[0m x_5 \u001b[38;5;241m=\u001b[39m \u001b[43mglobal_mean_pool\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    170\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconv6(x, edge_index)\n\u001b[1;32m    171\u001b[0m x  \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mb6(x)\n",
      "File \u001b[0;32m~/anaconda3/envs/Wav2Lip/lib/python3.8/site-packages/torch_geometric/nn/pool/glob.py:62\u001b[0m, in \u001b[0;36mglobal_mean_pool\u001b[0;34m(x, batch, size)\u001b[0m\n\u001b[1;32m     60\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m batch \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     61\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m x\u001b[38;5;241m.\u001b[39mmean(dim\u001b[38;5;241m=\u001b[39mdim, keepdim\u001b[38;5;241m=\u001b[39mx\u001b[38;5;241m.\u001b[39mdim() \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m---> 62\u001b[0m size \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[43mbatch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01mif\u001b[39;00m size \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m size\n\u001b[1;32m     63\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m scatter(x, batch, dim\u001b[38;5;241m=\u001b[39mdim, dim_size\u001b[38;5;241m=\u001b[39msize, reduce\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmean\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "model.load_state_dict(torch.load(\"two_domain_M_I_to_C_domain_generalization_tuning.pth\",map_location='cuda'))\n",
    "best_auc = 0.8606\n",
    "for epoch in range(82, 1000):\n",
    "    train(epoch)\n",
    "    print(\"***************************\")\n",
    "    #print(\"train : \")\n",
    "    #train_auc = test(train_loader,epoch)\n",
    "    print(\"test : \")\n",
    "    test_auc = test(test_loader,epoch)\n",
    "    if test_auc > best_auc:\n",
    "        print(\"improve acc .. .. ..\")\n",
    "        torch.save(model.state_dict(), 'two_domain_M_I_to_C_domain_generalization_tuning.pth')\n",
    "        best_auc = test_auc\n",
    "        continue  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "040a7655",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (Wav2Lip)",
   "language": "python",
   "name": "wav2lip"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}