Add: All Training and Deployment files

Author: asagar60

EDA-v1.ipynb

@@ -0,0 +1,9 @@
+import torch
+
+SEED = 0
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+LEARNING_RATE = 0.0001
+EPOCHS = 100
+BATCH_SIZE = 2
+WEIGHT_DECAY = 3e-4
+DATAPATH = 'F:/Deep Learning/appliedai_submissions/Self Case Study/Case Study 2/processed_data_v2.csv'

EDA-v2.ipynb

@@ -0,0 +1,128 @@
+import torch
+import torch.nn as nn
+import pandas as pd
+import numpy as np
+from glob import glob
+from sklearn.model_selection import train_test_split
+from PIL import Image
+from torch.utils.data import DataLoader
+from torchvision.utils import save_image
+from tqdm import tqdm
+import albumentations as A 
+from albumentations.pytorch import ToTensorV2
+import tqdm
+import config
+import cv2
+import os
+import sys
+
+class ImageFolder(nn.Module):
+    def __init__(self, df, isTrain = True, transform = None):
+        super(ImageFolder, self).__init__()
+        self.df = df
+        """
+        if transform is None:
+            if isTrain == True:
+                self.transform = A.Compose([
+                        A.HorizontalFlip(),
+                        A.VerticalFlip(),
+                        A.Normalize(),
+                        ToTensorV2()
+                    ])
+            else:
+                self.test_transform = A.Compose([
+                        A.Normalize(),
+                        ToTensorV2()
+                    ])
+        """
+        if transform is None:
+            self.transform = A.Compose([
+                        #A.Resize(width=200, height = 50),
+                        #ToTensor --> Normalize(mean, std) 
+                        A.Normalize(
+                            mean=[0.485, 0.456, 0.406],
+                            std=[0.229, 0.224, 0.225],
+                            max_pixel_value = 255,
+                        ),
+                        ToTensorV2()
+                    ])
+
+    def __len__(self):
+        return len(self.df)
+
+    def __getitem__(self, index):
+
+        img_path, table_mask_path, col_mask_path = self.df.iloc[index, 0], self.df.iloc[index, 1], self.df.iloc[index, 2]
+        image = np.array(Image.open("../" + img_path))
+        table_image = torch.FloatTensor(np.array(Image.open("../" + table_mask_path))/255.0).reshape(1,1024,1024)
+        column_image = torch.FloatTensor(np.array(Image.open("../" + col_mask_path))/255.0).reshape(1,1024,1024)
+
+        """
+        augmentations = self.transform(
+            image = image, 
+            table_mask = table_image,
+            column_mask = column_image
+        )
+        image = augmentations['image']
+        table_image = augmentations['table_mask']
+        column_image = augmentations['column_mask']
+        """
+        
+        image = self.transform(image = image)['image']
+
+
+        return {"image":image,"table_image":table_image, "column_image": column_image}
+
+
+def get_mean_std(train_data, transform):
+    dataset = ImageFolder(train_data , transform)
+
+    train_loader = DataLoader(dataset, batch_size=128)
+
+    mean = 0.
+    std = 0.
+    for img_dict in tqdm.tqdm(train_loader):
+        batch_samples = img_dict["image"].size(0) # batch size (the last batch can have smaller size!)
+        images = img_dict["image"].view(batch_samples, img_dict["image"].size(1), -1)
+        mean += images.mean(2).sum(0)
+        std += images.std(2).sum(0)
+
+    mean /= len(train_loader.dataset)
+    std /= len(train_loader.dataset)
+
+    print(mean)  #tensor([0.4194, 0.4042, 0.3910])
+    print(std) #tensor([0.2439, 0.2402, 0.2372])
+
+#get_mean_std()
+
+if __name__ == '__main__':
+
+
+    df = pd.read_csv('F:/Deep Learning/appliedai_submissions/Self Case Study/Case Study 2/processed_data_v2.csv')
+    dataset = ImageFolder(df[df['hasTable']==1])
+
+    img_num = 0
+    for img_dict in dataset:
+        save_image(img_dict["image"], f'image_{img_num}.png')
+        save_image(img_dict["table_image"], f'table_image_{img_num}.png')
+        save_image(img_dict["column_image"], f'column_image_{img_num}.png')
+
+        img_num += 1
+
+        if img_num == 6:
+            break
+
+    """
+    df = pd.read_csv(config.DATAPATH)
+    train_data, test_data  = train_test_split(df, test_size = 0.2, random_state = config.SEED, stratify = df.hasTable)
+
+    dataset = ImageFolder(train_data , isTrain= True)
+
+    train_loader = DataLoader(dataset, batch_size=2)
+    for img_dict in train_loader:
+
+        image, table_image, column_image = img_dict['image'], img_dict['table_image'], img_dict['column_image']
+        print(image.shape)
+        print(table_image.shape)
+        print(column_image.shape)
+    """

Output.avi

@@ -0,0 +1,159 @@
+import torch
+import torch.nn as nn
+import torchvision
+from efficientnet_pytorch import EfficientNet
+
+class VGG19(nn.Module):
+    def __init__(self, pretrained = True, requires_grad = True):
+        super(VGG19, self).__init__()
+        _vgg = torchvision.models.vgg19(pretrained=pretrained).features
+        self.vgg_pool3 = torch.nn.Sequential()
+        self.vgg_pool4 = torch.nn.Sequential()
+        self.vgg_pool5 = torch.nn.Sequential()
+
+        for x in range(19):
+            self.vgg_pool3.add_module(str(x), _vgg[x])
+        for x in range(19, 28):
+            self.vgg_pool4.add_module(str(x), _vgg[x])
+        for x in range(28, 37):
+            self.vgg_pool5.add_module(str(x), _vgg[x])
+
+        
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+    
+    def forward(self, x): 
+        pool_3_out = self.vgg_pool3(x) #torch.Size([1, 256, 128, 128])
+        pool_4_out = self.vgg_pool4(pool_3_out) #torch.Size([1, 512, 64, 64])
+        pool_5_out = self.vgg_pool5(pool_4_out) #torch.Size([1, 512, 32, 32])
+        return (pool_3_out, pool_4_out, pool_5_out)
+
+class ResNet(nn.Module):
+    def __init__(self, pretrained = True, requires_grad = True):
+        super(ResNet, self).__init__()
+        resnet18 = torchvision.models.resnet34(pretrained=True)
+
+        self.layer_1 = nn.Sequential(
+            resnet18.conv1,
+            resnet18.bn1,
+            resnet18.relu,
+            resnet18.maxpool,
+            resnet18.layer1
+        )
+        self.layer_2 = resnet18.layer2
+        self.layer_3 = resnet18.layer3
+        self.layer_4 = resnet18.layer4
+
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+
+    def forward(self, x):
+        
+        out_1 = self.layer_2(self.layer_1(x)) #torch.Size([1, 128, 128, 128])
+        out_2 = self.layer_3(out_1) #torch.Size([1, 256, 64, 64])
+        out_3 = self.layer_4(out_2) #torch.Size([1, 512, 32, 32])
+        return out_1, out_2, out_3
+
+
+class DenseNet(nn.Module):
+    def __init__(self, pretrained = True, requires_grad = True):
+        super(DenseNet, self).__init__()
+        denseNet = torchvision.models.densenet121(pretrained=True).features
+        self.densenet_out_1 = torch.nn.Sequential()
+        self.densenet_out_2 = torch.nn.Sequential()
+        self.densenet_out_3 = torch.nn.Sequential()
+
+        for x in range(8):
+            self.densenet_out_1.add_module(str(x), denseNet[x])
+        for x in range(8,10):
+            self.densenet_out_2.add_module(str(x), denseNet[x])
+        
+        self.densenet_out_3.add_module(str(10), denseNet[10])
+        
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+
+    def forward(self, x):
+        
+        out_1 = self.densenet_out_1(x) #torch.Size([1, 256, 64, 64])
+        out_2 = self.densenet_out_2(out_1) #torch.Size([1, 512, 32, 32])
+        out_3 = self.densenet_out_3(out_2) #torch.Size([1, 1024, 32, 32])
+        return out_1, out_2, out_3
+
+class efficientNet_B0(nn.Module):
+    def __init__(self, pretrained = True, requires_grad = True):
+        super(efficientNet_B0, self).__init__()
+        eNet = EfficientNet.from_pretrained('efficientnet-b0')
+        
+        self.eNet_out_1 = torch.nn.Sequential()
+        self.eNet_out_2 = torch.nn.Sequential()
+        self.eNet_out_3 = torch.nn.Sequential()
+
+        blocks = eNet._blocks
+
+        self.eNet_out_1.add_module('_conv_stem', eNet._conv_stem)
+        self.eNet_out_1.add_module('_bn0', eNet._bn0)
+
+        for x in range(14):
+            self.eNet_out_1.add_module(str(x), blocks[x])
+        
+        self.eNet_out_2.add_module(str(14), blocks[14])
+        self.eNet_out_3.add_module(str(15), blocks[15])
+
+
+    def forward(self, x):
+        out_1 = self.eNet_out_1(x) #torch.Size([1, 192, 32, 32])
+        out_2 = self.eNet_out_2(out_1) #torch.Size([1, 192, 32, 32])
+        out_3 = self.eNet_out_3(out_2) #torch.Size([1, 320, 32, 32])
+        return out_1, out_2, out_3
+
+class efficientNet(nn.Module):
+    def __init__(self, model_type = 'efficientnet-b0',  pretrained = True, requires_grad = True):
+        super(efficientNet, self).__init__()
+        eNet = EfficientNet.from_pretrained(model_type)
+
+        self.eNet_out_1 = torch.nn.Sequential()
+        self.eNet_out_2 = torch.nn.Sequential()
+        self.eNet_out_3 = torch.nn.Sequential()
+
+        blocks = eNet._blocks
+
+        self.eNet_out_1.add_module('_conv_stem', eNet._conv_stem)
+        self.eNet_out_1.add_module('_bn0', eNet._bn0)
+
+        for x in range(len(blocks)-3):
+            self.eNet_out_1.add_module(str(x), blocks[x])
+        
+        self.eNet_out_2.add_module(str(len(blocks)-2), blocks[len(blocks)-2])
+        self.eNet_out_3.add_module(str(len(blocks)-1), blocks[len(blocks)-1])
+
+
+    def forward(self, x):
+        out_1 = self.eNet_out_1(x) #torch.Size([1, 192, 32, 32])
+        out_2 = self.eNet_out_2(out_1) #torch.Size([1, 192, 32, 32])
+        out_3 = self.eNet_out_3(out_2) #torch.Size([1, 320, 32, 32])
+        
+
+        """
+        shapes of b1
+        torch.Size([1, 192, 32, 32])
+        torch.Size([1, 320, 32, 32])
+        torch.Size([1, 320, 32, 32])
+
+        shapes of b2
+        torch.Size([1, 208, 32, 32])
+        torch.Size([1, 352, 32, 32])
+        torch.Size([1, 352, 32, 32])
+        """
+
+        return out_1, out_2, out_3
+
+
+
+if __name__ == '__main__':
+    model = efficientNet()
+    x = torch.randn(1,3,1024,1024)
+    model(x)

Output.ipynb

@@ -0,0 +1,13 @@
+import torch
+import torch.nn as nn
+
+class TableNetLoss(nn.Module):
+    def __init__(self):
+        super(TableNetLoss, self).__init__()
+        self.bce = nn.BCEWithLogitsLoss()
+    
+    def forward(self, table_pred, table_gt, col_pred = None, col_gt = None, ):
+
+        table_loss = self.bce(table_pred, table_gt)
+        column_loss = self.bce(col_pred, col_gt)
+        return table_loss, column_loss