DCEC.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "57dd0f0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import libs\n",
    "import pandas as pd\n",
    "import os\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import cv2\n",
    "from torchvision import transforms\n",
    "from time import time\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import torch\n",
    "from utils import CFG as utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "acd70369",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "    \n",
    "utils.seed_everything(42)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d7b5c29",
   "metadata": {},
   "source": [
    "# Distribution of the target variable & Preprocces with DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "942551b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = pd.read_csv('./data/train.csv')\n",
    "test_df = pd.read_csv('./data/test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df19dafd",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df.info()\n",
    "train_df.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1681741",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df.item_nm.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "85d0a17d",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert(len(train_df) == len(os.listdir('./data/train')))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9f8faa0",
   "metadata": {},
   "source": [
    "# DataModule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ed1d1493",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImageData(Dataset):\n",
    "    '''\n",
    "    Main DataModule\n",
    "    '''\n",
    "    def __init__(self,df ,test = True ,transform = None):\n",
    "        self.df = df\n",
    "        self.transform = transform\n",
    "        self.test = test\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.df)\n",
    "    \n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        path = ['./data/queries','./data/test/']\n",
    "        img_path = path[self.test] + f'{self.df.idx.iloc[index]}' + '.png'\n",
    "        img = Image.open(img_path)\n",
    "        img = self.transform(img)\n",
    "        if img.size(0) != 3:\n",
    "            to_rgb = transforms.Lambda(lambda x: x[:3])\n",
    "            img = to_rgb(img)\n",
    "        \n",
    "        return img\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a69aa96d",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose([transforms.Resize((128,128)),\n",
    "                                transforms.ToTensor()])\n",
    "data = ImageData(test_df,transform=transform)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "de207b4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloader = utils.loader(data,utils.batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9e808c5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "next(iter(dataloader)).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26dcd0d4",
   "metadata": {},
   "source": [
    "# MODEL DCEC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0714962",
   "metadata": {},
   "source": [
    "![Image of Yaktocat](https://www.researchgate.net/profile/Xifeng-Guo/publication/320658590/figure/fig2/AS:614154637410315@1523437284434/The-structure-of-deep-convolutional-embedded-clustering-DCEC-It-is-composed-of-a.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "8e5b6c97",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClusterlingLayer(nn.Module):\n",
    "    def __init__(self, in_features=10, out_features=10, alpha=1.0):\n",
    "        super(ClusterlingLayer, self).__init__()\n",
    "        self.in_features = in_features\n",
    "        self.out_features = out_features\n",
    "        self.alpha = alpha\n",
    "        self.weight = nn.Parameter(torch.Tensor(self.out_features, self.in_features))\n",
    "        self.weight = nn.init.xavier_uniform_(self.weight)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.unsqueeze(1) - self.weight\n",
    "        x = torch.mul(x, x)\n",
    "        x = torch.sum(x)\n",
    "        x = 1.0 + (x / self.alpha)\n",
    "        x = 1.0 / x\n",
    "        x = x ** ((self.alpha +1.0) / 2.0)\n",
    "        x = torch.t(x) / torch.sum(x)\n",
    "        x = torch.t(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "826130a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DCEC(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size=[3, 128, 128], channels=[32, 64, 128],\n",
    "                 num_clusters=10, activation_out = False):\n",
    "        super(DCEC, self).__init__()\n",
    "        self.params = input_size\n",
    "        self.channels = channels\n",
    "        self.num_clusters = num_clusters\n",
    "        self.cluster = ClusterlingLayer()\n",
    "        self.relu = nn.ReLU(inplace=False)\n",
    "        #ENCODER\n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Conv2d(self.params[0], self.channels[0], 5, stride=2,\n",
    "                       padding=2),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.Conv2d(self.channels[0], self.channels[1], 5, stride=2,\n",
    "                      padding=2),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.Conv2d(self.channels[1], self.channels[2], 3, stride=2,\n",
    "                      padding=0)\n",
    "        )\n",
    "        \n",
    "        \n",
    "        # EMBED\n",
    "        self.lin_features_len = ((self.params[1] // 2 // 2 - 1) // 2) * (\n",
    "                    (self.params[1] // 2 // 2 - 1) // 2) * channels[2]\n",
    "        self.embedding = nn.Linear(self.lin_features_len, self.num_clusters)\n",
    "        self.deembedding = nn.Linear(self.num_clusters, self.lin_features_len)\n",
    "\n",
    "        # DECODER\n",
    "        out_pad = 1 if self.params[1] // 2 // 2 % 2 == 0 else 0\n",
    "        self.deconv3 = nn.ConvTranspose2d(self.channels[2], self.channels[1],\n",
    "                                          3, stride=2, padding=0,\n",
    "                                          output_padding=out_pad)\n",
    "        out_pad = 1 if self.params[1] // 2 % 2 == 0 else 0\n",
    "        self.deconv2 = nn.ConvTranspose2d(self.channels[1], self.channels[0],\n",
    "                                          5, stride=2, padding=2,\n",
    "                                          output_padding=out_pad)\n",
    "        out_pad = 1 if self.params[1] % 2 == 0 else 0\n",
    "        self.deconv1 = nn.ConvTranspose2d(self.channels[0], self.params[0], 5,\n",
    "                                          stride=2, padding=2,\n",
    "                                          output_padding=out_pad)\n",
    "\n",
    "        # LOSS_FUNC\n",
    "        self.relu1_1 = self.relu\n",
    "        self.relu2_1 = self.relu\n",
    "        self.relu3_1 = self.relu\n",
    "        self.relu1_2 = self.relu\n",
    "        self.relu2_2 = self.relu\n",
    "        self.relu3_2 = self.relu\n",
    "        self.tanh = nn.Tanh()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # ENCODE\n",
    "        \n",
    "        x = self.encoder(x)\n",
    "        # matrix to array & clustering_out\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.embedding(x)\n",
    "        \n",
    "        clustering_out = self.cluster(x)\n",
    "        \n",
    "        # decode\n",
    "        x = self.deembedding(x)\n",
    "        \n",
    "        x = self.relu1_2(x)\n",
    "        x = x.reshape(x.shape[0], self.channels[-1],\n",
    "                      (self.params[1] // 2 // 2 - 1) // 2,\n",
    "                      (self.params[1] // 2 // 2 - 1) // 2)\n",
    "        x = self.deconv3(x)\n",
    "        x = self.relu2_2(x)\n",
    "        \n",
    "        x = self.deconv2(x)\n",
    "        x = self.relu3_2(x)\n",
    "        \n",
    "        x = self.deconv1(x)\n",
    "        return x, clustering_out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "547a00aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}