dogs-vs-cats-inceptionnet-pytorch.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"tpu1vmV38","dataSources":[{"sourceId":3362,"databundleVersionId":31148,"sourceType":"competition"}],"dockerImageVersionId":30698,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"'!unzip \"/kaggle/input/dogs-vs-cats/train.zip\"'","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:30.949814Z","iopub.execute_input":"2024-05-16T18:02:30.951036Z","iopub.status.idle":"2024-05-16T18:02:30.958860Z","shell.execute_reply.started":"2024-05-16T18:02:30.950986Z","shell.execute_reply":"2024-05-16T18:02:30.957896Z"},"trusted":true},"execution_count":2,"outputs":[{"execution_count":2,"output_type":"execute_result","data":{"text/plain":"'!unzip \"/kaggle/input/dogs-vs-cats/train.zip\"'"},"metadata":{}}]},{"cell_type":"code","source":"import pandas as pd\nimport torch\nimport os\nimport random\nimport torch.nn as nn\nfrom PIL import Image\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision.transforms import transforms","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-05-16T18:02:33.324587Z","iopub.execute_input":"2024-05-16T18:02:33.324973Z","iopub.status.idle":"2024-05-16T18:02:39.457430Z","shell.execute_reply.started":"2024-05-16T18:02:33.324930Z","shell.execute_reply":"2024-05-16T18:02:39.456535Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"train_path = \"/kaggle/working/train\"\ndirs = os.listdir(train_path)\n\nrandom.shuffle(dirs)\ntrain_paths = dirs[5000:] \nval_paths = dirs[:5000] ","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.459087Z","iopub.execute_input":"2024-05-16T18:02:39.459713Z","iopub.status.idle":"2024-05-16T18:02:39.505842Z","shell.execute_reply.started":"2024-05-16T18:02:39.459685Z","shell.execute_reply":"2024-05-16T18:02:39.504635Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"class dataset(Dataset):\n    def __init__(self, paths, transform = None) :\n        self.paths = paths\n        self.transform = transform\n        \n    \n    def __getitem__(self, index):\n        full_path = os.path.join(train_path, self.paths[index])\n        img = Image.open(full_path)\n        img = img.resize((224, 224))\n        label = self.paths[index][:3]\n        \n        if self.transform:\n            img = self.transform(img)\n            img = img.type(torch.float32)/255 \n            \n        return img, int(label == \"cat\")\n    \n    def __len__(self):\n        return len(self.paths)","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.507118Z","iopub.execute_input":"2024-05-16T18:02:39.507393Z","iopub.status.idle":"2024-05-16T18:02:39.515642Z","shell.execute_reply.started":"2024-05-16T18:02:39.507369Z","shell.execute_reply":"2024-05-16T18:02:39.514468Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"code","source":"transform = transforms.Compose([\n    transforms.PILToTensor(),\n])","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.518735Z","iopub.execute_input":"2024-05-16T18:02:39.519619Z","iopub.status.idle":"2024-05-16T18:02:39.527977Z","shell.execute_reply.started":"2024-05-16T18:02:39.519586Z","shell.execute_reply":"2024-05-16T18:02:39.525800Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"train_data = dataset(train_paths, transform)\nval_data = dataset(val_paths, transform)","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.529281Z","iopub.execute_input":"2024-05-16T18:02:39.529616Z","iopub.status.idle":"2024-05-16T18:02:39.538742Z","shell.execute_reply.started":"2024-05-16T18:02:39.529587Z","shell.execute_reply":"2024-05-16T18:02:39.537397Z"},"trusted":true},"execution_count":7,"outputs":[]},{"cell_type":"code","source":"train_loader = DataLoader(train_data, shuffle = True, batch_size = 32)\nval_loader = DataLoader(val_data, shuffle = False, batch_size = 32)","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.540235Z","iopub.execute_input":"2024-05-16T18:02:39.540498Z","iopub.status.idle":"2024-05-16T18:02:39.551122Z","shell.execute_reply.started":"2024-05-16T18:02:39.540476Z","shell.execute_reply":"2024-05-16T18:02:39.548410Z"},"trusted":true},"execution_count":8,"outputs":[]},{"cell_type":"code","source":"class ConvBlock(nn.Module):\n    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=True):\n        super(ConvBlock, self).__init__()\n        \n        self.Conv_layer = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride = stride, padding=padding, bias=bias)\n        self.batchnorm2d = nn.BatchNorm2d(out_channels)\n        self.relu = nn.ReLU()\n        \n    def forward(self, x):\n        return self.relu(self.batchnorm2d(self.Conv_layer(x)))","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.552409Z","iopub.execute_input":"2024-05-16T18:02:39.552688Z","iopub.status.idle":"2024-05-16T18:02:39.562989Z","shell.execute_reply.started":"2024-05-16T18:02:39.552664Z","shell.execute_reply":"2024-05-16T18:02:39.562018Z"},"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"code","source":"class InceptionBlock(nn.Module):\n    def __init__(self, in_channels, output_1x1, reduc_3x3, output_3x3, reduc_5x5, output5x5, out_1x1_mxpooling):\n        super(InceptionBlock, self).__init__()\n        \n        self.branch1 = ConvBlock(in_channels, output_1x1, kernel_size=1)\n        \n        self.branch2 = nn.Sequential(ConvBlock(in_channels, reduc_3x3, kernel_size=1), ConvBlock(reduc_3x3, output_3x3, kernel_size=3, stride=1, padding=1))\n        \n        self.branch3 = nn.Sequential(ConvBlock(in_channels, reduc_5x5, kernel_size=1), ConvBlock(reduc_5x5, output5x5, kernel_size=5, stride=1, padding=2))\n        \n        self.branch4 = nn.Sequential(nn.MaxPool2d(kernel_size=3, stride=1, padding=1), ConvBlock(in_channels, out_1x1_mxpooling, kernel_size=1, stride=1))\n        \n    def forward(self, x):\n        return torch.cat([self.branch1(x), self.branch2(x), self.branch3(x), self.branch4(x)], dim=1)","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.564056Z","iopub.execute_input":"2024-05-16T18:02:39.564287Z","iopub.status.idle":"2024-05-16T18:02:39.574723Z","shell.execute_reply.started":"2024-05-16T18:02:39.564266Z","shell.execute_reply":"2024-05-16T18:02:39.573926Z"},"trusted":true},"execution_count":10,"outputs":[]},{"cell_type":"code","source":"class Auxiliary(nn.Module):\n    def __init__(self, in_channels, num_classes):\n        super(Auxiliary, self).__init__()\n        \n        self.avg = nn.AvgPool2d(kernel_size=5, stride=3)\n        self.conv1 = ConvBlock(in_channels, 128, kernel_size=1)\n        \n        self.flatten = nn.Flatten()\n        \n        self.fc1 = nn.Linear(2048, 1024)\n        self.fc2 = nn.Linear(1024, num_classes)\n        \n        self.dropout = nn.Dropout(.7)\n        \n    def forward(self, x):\n        x = self.avg(x)\n        x = self.conv1(x)\n        \n        x = self.flatten(x)\n        \n        x = nn.ReLU()(self.fc1(x))\n        x = self.dropout(x)\n        x = self.fc2(x)\n        \n        return x     ","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.575613Z","iopub.execute_input":"2024-05-16T18:02:39.575841Z","iopub.status.idle":"2024-05-16T18:02:39.587852Z","shell.execute_reply.started":"2024-05-16T18:02:39.575821Z","shell.execute_reply":"2024-05-16T18:02:39.587123Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"class Inception(nn.Module):\n    def __init__(self, num_classes):\n        super(Inception, self).__init__()\n        \n        self.conv1 = ConvBlock(3, 64, kernel_size=7, stride=2)\n        self.conv2 = ConvBlock(64, 192, kernel_size=3, stride=1)\n        \n        self.inception3a = InceptionBlock(192, 64, 96, 128, 16, 32, 32)\n        self.inception3b = InceptionBlock(256, 128, 128, 192, 32, 96, 64)\n        self.inception4a = InceptionBlock(480, 192, 96, 208, 16, 48, 64)\n        self.inception4b = InceptionBlock(512, 160, 112, 224, 24, 64, 64)\n        self.inception4c = InceptionBlock(512, 128, 128, 256, 24, 64, 64)\n        self.inception4d = InceptionBlock(512, 112, 144, 288, 32, 64, 64)\n        self.inception4e = InceptionBlock(528, 256, 160, 320, 32, 128, 128)\n        self.inception5a = InceptionBlock(832, 256, 160, 320, 32, 128, 128)\n        self.inception5b = InceptionBlock(832, 384, 192, 384, 48, 128, 128)\n        \n        self.mx = nn.MaxPool2d(kernel_size=3, stride =2, padding=1)\n        self.avg = nn.AvgPool2d(kernel_size=7, stride =1)\n        \n        self.dropout = nn.Dropout(.4)\n        self.linear1 = nn.Linear(1024, 1000)\n        self.linear2 = nn.Linear(1000, num_classes)\n        \n        self.aux_1 = Auxiliary(in_channels = 512, num_classes = num_classes)\n        self.aux_2 = Auxiliary(in_channels = 528, num_classes = num_classes)\n\n    def forward(self, x):\n        \n        x = self.conv1(x)\n        x = self.mx(x)\n        \n        x = self.conv2(x)\n        x = self.mx(x)        \n        \n        x = self.inception3a(x)\n        x = self.inception3b(x)\n        x = self.mx(x)\n        x = self.inception4a(x)\n        \n        if self.training:\n            aux1 = self.aux_1(x)\n            \n        x = self.inception4b(x)\n        x = self.inception4c(x)\n        x = self.inception4d(x)\n        \n        if self.training:\n            aux2 = self.aux_2(x)\n            \n        x = self.inception4e(x)\n        x = self.mx(x)\n        x = self.inception5a(x)\n        x = self.inception5b(x)\n        x = self.avg(x)\n        \n        x = nn.Flatten()(x)\n        x = self.dropout(x)\n        x = nn.ReLU()(self.linear1(x))\n        \n        x = self.linear2(x)\n        \n        if self.training:\n            return x ,aux1, aux2\n        else:\n            return x","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.811065Z","iopub.execute_input":"2024-05-16T18:02:39.811416Z","iopub.status.idle":"2024-05-16T18:02:39.828645Z","shell.execute_reply.started":"2024-05-16T18:02:39.811389Z","shell.execute_reply":"2024-05-16T18:02:39.827702Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"code","source":"device = torch.device('cuda' if torch.cuda.is_available() else \"cpu\")\ndevice","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.830624Z","iopub.execute_input":"2024-05-16T18:02:39.831227Z","iopub.status.idle":"2024-05-16T18:02:39.869393Z","shell.execute_reply.started":"2024-05-16T18:02:39.831192Z","shell.execute_reply":"2024-05-16T18:02:39.868363Z"},"trusted":true},"execution_count":13,"outputs":[{"execution_count":13,"output_type":"execute_result","data":{"text/plain":"device(type='cuda')"},"metadata":{}}]},{"cell_type":"code","source":"model = Inception(2).to(device)\n\nepochs = 10\nlr = .005\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(model.parameters(), lr=lr)","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:39.870491Z","iopub.execute_input":"2024-05-16T18:02:39.870835Z","iopub.status.idle":"2024-05-16T18:02:40.231395Z","shell.execute_reply.started":"2024-05-16T18:02:39.870802Z","shell.execute_reply":"2024-05-16T18:02:40.230573Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"train_loss_history = []\nval_loss_history = []\nbest_score = float(\"inf\")\ntol = 0\n\n\ndef train_epoch():\n    epoch_loss = 0\n    for i, (images, labels) in enumerate(train_loader):\n        \n        images = images.to(device)\n        labels = labels.to(device)\n        \n        # forward pass\n        out, aux1, aux2 = model(images)\n        \n        loss_out = criterion(out, labels)\n        aux1_loss = criterion(aux1, labels)\n        aux2_loss = criterion(aux2, labels)\n        loss = loss_out + .3*(aux1_loss + aux2_loss)\n        epoch_loss += loss\n        \n        # backward pass\n        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n        \n        if(i%100 ==0):\n            print(f\"   step[{i+1} / {len(train_loader)}]\")\n    return epoch_loss / len(train_loader)\n\ndef get_val_loss():\n    epoch_loss = 0\n    with torch.no_grad():\n        for i, (images, labels) in enumerate(val_loader):\n\n            images = images.to(device)\n            labels = labels.to(device)\n\n            # forward pass\n            out = model(images)\n            loss = criterion(out, labels)\n            epoch_loss += loss\n            \n    return epoch_loss / len(val_loader)\n\nfor epoch in range(epochs):\n    print(f\"epoch {epoch+1}:\")\n    \n    model.train(True)\n    avg_train_epoch_loss = train_epoch()\n    \n    model.eval()\n    avg_val_epoch_loss = get_val_loss()\n    \n    if(avg_val_epoch_loss < best_score):\n        best_score = avg_val_epoch_loss\n        torch.save(model.state_dict(), f\"model_{epoch+1}\")\n    else:\n        tol += 1\n        if(tol == 4):\n            break\n    \n    \n    train_loss_history.append(avg_train_epoch_loss)\n    val_loss_history.append(avg_val_epoch_loss)\n    \n    \n    print(f\"epoch: {epoch+1} --- avg_train_loss = {avg_train_epoch_loss} --- avg_val_loss = {avg_val_epoch_loss}\") \n    print(\"#\"*100)","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:02:40.233416Z","iopub.execute_input":"2024-05-16T18:02:40.233787Z","iopub.status.idle":"2024-05-16T18:23:28.629681Z","shell.execute_reply.started":"2024-05-16T18:02:40.233753Z","shell.execute_reply":"2024-05-16T18:23:28.628629Z"},"trusted":true},"execution_count":15,"outputs":[{"name":"stdout","text":"epoch 1:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 1 --- avg_train_loss = 1.1638718843460083 --- avg_val_loss = 0.6972315311431885\n####################################################################################################\nepoch 2:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 2 --- avg_train_loss = 0.8985034227371216 --- avg_val_loss = 0.6894651651382446\n####################################################################################################\nepoch 3:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 3 --- avg_train_loss = 0.6393473744392395 --- avg_val_loss = 0.601358950138092\n####################################################################################################\nepoch 4:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 4 --- avg_train_loss = 0.47263646125793457 --- avg_val_loss = 0.2564932405948639\n####################################################################################################\nepoch 5:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 5 --- avg_train_loss = 0.38559460639953613 --- avg_val_loss = 0.26467591524124146\n####################################################################################################\nepoch 6:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 6 --- avg_train_loss = 0.33259162306785583 --- avg_val_loss = 0.6121662855148315\n####################################################################################################\nepoch 7:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 7 --- avg_train_loss = 0.2957369089126587 --- avg_val_loss = 0.23196737468242645\n####################################################################################################\nepoch 8:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 8 --- avg_train_loss = 0.2534405589103699 --- avg_val_loss = 0.25849649310112\n####################################################################################################\nepoch 9:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\nepoch: 9 --- avg_train_loss = 0.21979784965515137 --- avg_val_loss = 0.20457813143730164\n####################################################################################################\nepoch 10:\n   step[1 / 625]\n   step[101 / 625]\n   step[201 / 625]\n   step[301 / 625]\n   step[401 / 625]\n   step[501 / 625]\n   step[601 / 625]\n","output_type":"stream"}]},{"cell_type":"code","source":"train_losses = [ x.item() for x in train_loss_history]\nval_losses = [ x.item() for x in val_loss_history]","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:23:28.631226Z","iopub.execute_input":"2024-05-16T18:23:28.631528Z","iopub.status.idle":"2024-05-16T18:23:28.637246Z","shell.execute_reply.started":"2024-05-16T18:23:28.631501Z","shell.execute_reply":"2024-05-16T18:23:28.636246Z"},"trusted":true},"execution_count":16,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.plot(train_losses, \"b--\", label = \"Train_loss\")\nplt.plot(val_losses, \"r-\", label = \"Val_loss\")\nplt.title(\"Train VS Val\")\nplt.legend()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-05-16T18:23:28.638248Z","iopub.execute_input":"2024-05-16T18:23:28.638516Z","iopub.status.idle":"2024-05-16T18:23:28.965063Z","shell.execute_reply.started":"2024-05-16T18:23:28.638495Z","shell.execute_reply":"2024-05-16T18:23:28.964154Z"},"trusted":true},"execution_count":17,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]}]}