siamesNet_function.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "25ad8a3a90464321b55cb42a46dd499e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.14068768918514252\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd \n",
    "import glob\n",
    "import cv2 as cv\n",
    "import random\n",
    "import os\n",
    "import numpy as np\n",
    "import random\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import albumentations as A\n",
    "from albumentations.pytorch.transforms import ToTensorV2\n",
    "from tqdm.auto import tqdm\n",
    "import timm\n",
    "\n",
    "def pred_distance(review_img_path, product_img_path):\n",
    "    df = pd.DataFrame(columns=['review_img_path','product_img_path', 'label'])\n",
    "    df['review_img_path'] = [review_img_path]\n",
    "    df['product_img_path'] = [product_img_path]\n",
    "    df['label'] = [0]\n",
    "    \n",
    "    device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
    "    \n",
    "    CFG = {\n",
    "        'IMG_SIZE':224,\n",
    "        'EPOCHS':1,\n",
    "        'LEARNING_RATE':3e-4,\n",
    "        # 'LEARNING_RATE':10,\n",
    "        'BATCH_SIZE':1,\n",
    "        'SEED':41\n",
    "    }\n",
    "    \n",
    "    class SiameseNetworkDataset(Dataset):\n",
    "        def __init__(self,review_img_path,product_img_path,label,transform=None):\n",
    "            self.review_img_path = review_img_path\n",
    "            self.product_img_path = product_img_path\n",
    "            self.label = label\n",
    "            self.transform = transform\n",
    "\n",
    "        def __getitem__(self,index):\n",
    "            review_img = cv.imread(self.review_img_path[index])\n",
    "            product_img = cv.imread(self.product_img_path[index])\n",
    "            review_img = cv.resize(review_img, (CFG['IMG_SIZE'], CFG['IMG_SIZE']))\n",
    "            product_img = cv.resize(product_img, (CFG['IMG_SIZE'], CFG['IMG_SIZE']))\n",
    "\n",
    "            if self.transform is not None:\n",
    "                review_img  = self.transform(image=review_img)['image']\n",
    "                product_img  = self.transform(image=product_img)['image']\n",
    "\n",
    "            return review_img, product_img, self.label[index]\n",
    "\n",
    "        def __len__(self):\n",
    "            return len(self.review_img_path)\n",
    "        \n",
    "    train_transform = A.Compose([\n",
    "                            A.Resize(CFG['IMG_SIZE'],CFG['IMG_SIZE']),\n",
    "                            ToTensorV2()\n",
    "                            ])\n",
    "    \n",
    "    val_dataset = SiameseNetworkDataset(df[\"review_img_path\"].values, df[\"product_img_path\"].values, df[\"label\"].values, train_transform)\n",
    "    val_loader = DataLoader(val_dataset, batch_size = CFG['BATCH_SIZE'], shuffle=False, num_workers=0)\n",
    "\n",
    "    class BaseModel(nn.Module):\n",
    "        def __init__(self):\n",
    "            super(BaseModel, self).__init__()\n",
    "            self.backbone = timm.create_model('efficientnet_b0', pretrained=False)\n",
    "            self.classifier = nn.Linear(1000, 50)\n",
    "            self.dropout = nn.Dropout(0.1)\n",
    "            self.ReLU = nn.ReLU(inplace=False)\n",
    "\n",
    "        def forward(self, x, y):\n",
    "            x = self.backbone(x)\n",
    "            x = self.classifier(x)\n",
    "\n",
    "            y = self.backbone(y)\n",
    "            y = self.classifier(y)\n",
    "\n",
    "            z = F.pairwise_distance(x, y, keepdim = True)\n",
    "            return z\n",
    "        \n",
    "    def validation(model, val_loader, device):\n",
    "        model.eval()\n",
    "        pred_list = []\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            for review_img, product_img, labels in tqdm(iter(val_loader)):\n",
    "                review_img = review_img.float().to(device)\n",
    "                product_img = product_img.float().to(device)\n",
    "    \n",
    "                \n",
    "                pred = model(review_img, product_img)\n",
    "                pred = pred.detach().cpu().numpy().tolist()\n",
    "                pred_list += pred\n",
    "            \n",
    "        return pred_list \n",
    "        \n",
    "    def train(model,  val_loader,  device):\n",
    "        model = model.to(device)\n",
    "\n",
    "        model.train()\n",
    "        prediction = validation(model, val_loader, device)\n",
    "\n",
    "        return prediction\n",
    "        \n",
    "    \n",
    "    model = BaseModel()\n",
    "    model.load_state_dict(torch.load('./distance_VGGBase_E_Contra.pt'))\n",
    "    model.eval()\n",
    "\n",
    "    prediction = train(model,  val_loader, device)\n",
    "    \n",
    "    return prediction[0][0]\n",
    "    \n",
    "print(pred_distance(\"./masked_data/review_img/0_review_img/O/404.jpg\", \"./masked_data/product_img/0.jpg\" ))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d664b78d130647cf809f30f1cb811a83",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "0.0\n",
      "0.0\n",
      "0.0\n",
      "Epoch [0], Train Loss : [nan] Val Loss : [0.01979] Val accuracy score : [100.00000]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/SAM/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3464: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/opt/conda/envs/SAM/lib/python3.9/site-packages/numpy/core/_methods.py:192: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    }
   ],
   "source": [
    "optimizer = torch.optim.Adam(params = model.parameters(), lr = CFG[\"LEARNING_RATE\"])\n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=2, threshold_mode='abs', min_lr=1e-8, verbose=True)\n",
    "\n",
    "prediction, prediction_list = train(model, optimizer, None, val_loader, scheduler, device)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.14068756997585297]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SAM",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}