convlstm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sanjaymoto75/.conda/envs/env/lib/python3.7/site-packages/tqdm/autonotebook/__init__.py:14: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n",
      "  \" (e.g. in jupyter console)\", TqdmExperimentalWarning)\n"
     ]
    }
   ],
   "source": [
    "#!pip install torch===1.2.0 torchvision===0.4.0 -f https://download.pytorch.org/whl/torch_stable.html\n",
    "import torchvision\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision.models as models\n",
    "import torch.optim as optim\n",
    "import copy\n",
    "import os\n",
    "import torch\n",
    "from tqdm.autonotebook import tqdm\n",
    "from torch.optim.lr_scheduler import _LRScheduler\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "from torch.utils.data import Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def frame_extract(path):\n",
    "    vidObj = cv2.VideoCapture(path) \n",
    "    success = 1\n",
    "    while success:\n",
    "        success, image = vidObj.read()\n",
    "        if success:\n",
    "            yield image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "train_label = pd.read_csv('./DAiSEE/Labels/TrainLabels.csv')\n",
    "valid_label = pd.read_csv('./DAiSEE/Labels/ValidationLabels.csv')\n",
    "test_label = pd.read_csv('./DAiSEE/Labels/TestLabels.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.dataset import Dataset\n",
    "import os\n",
    "from tqdm.autonotebook import tqdm\n",
    "import numpy as np\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "import cv2\n",
    "import sys\n",
    "im_size = 224"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "class video_dataset(Dataset):\n",
    "    def __init__(self,frame_dir,id,label,sequence_length = 60,transform = None):\n",
    "        self.folder = os.listdir(frame_dir)\n",
    "        self.id =id\n",
    "        self.engagement = label\n",
    "        self.frame_dir = frame_dir\n",
    "        self.transform = transform\n",
    "        self.count = sequence_length\n",
    "    def __len__(self):\n",
    "        return len(self.id)-self.count\n",
    "    def __getitem__(self,idx):\n",
    "        video_path = self.id[idx]\n",
    "        frames = []\n",
    "        i = np.random.randint(0,int(300/self.count))\n",
    "        a = int(300/self.count)\n",
    "        hp = np.random.randint(0,2)\n",
    "        for idx,frame in enumerate(frame_extract(video_path)):\n",
    "            if(idx%a == i):\n",
    "                if(hp == 1):\n",
    "                    frame = cv2.flip(frame,1)\n",
    "                frames.append(self.transform(frame))\n",
    "        frames = frames[:100]\n",
    "        frames = torch.stack(frames)\n",
    "        frames = frames.reshape(-1,3,im_size,im_size)\n",
    "        label = self.engagement[idx]\n",
    "        return frames,label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "id_1 = train_label['ClipID']\n",
    "label = train_label['Engagement']\n",
    "id_train = []\n",
    "label_train = []\n",
    "for id in range(len(id_1)):\n",
    "    path1 = os.path.join('./DataSet/Train',id_1[id][:6])\n",
    "    id_2 = id_1[id][:-4]\n",
    "    video_path = os.path.join(path1,id_2)\n",
    "    if(os.path.exists(video_path)):\n",
    "        if(os.path.exists(os.path.join(video_path,os.listdir(video_path)[0]))):\n",
    "            id_train.append(os.path.join(video_path,os.listdir(video_path)[0]))\n",
    "            label_train.append(label[id])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "id_1 = valid_label['ClipID']\n",
    "label = valid_label['Engagement']\n",
    "id_val = []\n",
    "label_val = []\n",
    "for id in range(len(id_1)):\n",
    "    path1 = os.path.join('./DataSet/Validation',id_1[id][:6])\n",
    "    id_2 = id_1[id][:-4]\n",
    "    video_path = os.path.join(path1,id_2)\n",
    "    if(os.path.exists(video_path)):\n",
    "        try:\n",
    "            if(os.path.exists(os.path.join(video_path,os.listdir(video_path)[0]))):\n",
    "                id_val.append(os.path.join(video_path,os.listdir(video_path)[0]))\n",
    "                label_val.append(label[id])\n",
    "        except:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "id_1 = test_label['ClipID']\n",
    "label = test_label['Engagement']\n",
    "id_test = []\n",
    "label_test = []\n",
    "for id in range(len(id_1)):\n",
    "    path1 = os.path.join('./DataSet/Test',id_1[id][:6])\n",
    "    id_2 = id_1[id][:-4]\n",
    "    video_path = os.path.join(path1,id_2)\n",
    "    if(os.path.exists(video_path)):\n",
    "        try:\n",
    "            if(os.path.exists(os.path.join(video_path,os.listdir(video_path)[0]))):\n",
    "                id_test.append(os.path.join(video_path,os.listdir(video_path)[0]))\n",
    "                label_test.append(label[id])\n",
    "        except:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "id_val = id_val + id_test\n",
    "label_val = label_val + label_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean = [0.43216, 0.394666, 0.37645]\n",
    "std = [0.22803, 0.22145, 0.216989]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_transforms = transforms.Compose([\n",
    "                                        transforms.ToPILImage(),\n",
    "                                        transforms.Resize((im_size,im_size)),\n",
    "                                        transforms.ToTensor(),\n",
    "                                        transforms.Normalize(mean,std)])\n",
    "train_data = video_dataset('./DataSet/Train',id_train,label_train,sequence_length = 100,transform = train_transforms)\n",
    "val_data = video_dataset('./DataSet/Validation',id_val,label_val,sequence_length = 100,transform = train_transforms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cv2\n",
    "import random\n",
    "image,_ = train_data[3900]\n",
    "def im_plot(tensor):\n",
    "    image = tensor.cpu().numpy().transpose(1,2,0)\n",
    "    b,g,r = cv2.split(image)\n",
    "    image = cv2.merge((r,g,b))\n",
    "    image = image*[0.22803, 0.22145, 0.216989] +  [0.43216, 0.394666, 0.37645]\n",
    "    image = image*255.0\n",
    "    plt.imshow(image.astype(int))\n",
    "    plt.show()\n",
    "im_plot(image[10,:,:,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_lr(optimizer, lr):\n",
    "    for g in optimizer.param_groups:\n",
    "        g['lr'] = lr\n",
    "def update_mom(optimizer, mom):\n",
    "    for g in optimizer.param_groups:\n",
    "        g['momentum'] = mom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Modular_code.lr_finder import *\n",
    "from RAdam.radam import RAdam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lr_finder(model,train_loader):\n",
    "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimizer_ft = RAdam(model.parameters(), lr=1e-6)\n",
    "    lr_finder = LRFinder(model, optimizer_ft, criterion, device=device)\n",
    "    lr_finder.range_test(train_loader, end_lr=1, num_iter=1000)\n",
    "    lr_finder.reset()\n",
    "    lr_finder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs('./weights_att1',exist_ok = True)\n",
    "import sys\n",
    "import cv2\n",
    "import torch.optim as optim\n",
    "from torch.autograd import Variable\n",
    "device = 'cuda'\n",
    "criterion = nn.CrossEntropyLoss().to(device)\n",
    "def update_lr(optimizer, lr):\n",
    "    for g in optimizer.param_groups:\n",
    "        g['lr'] = lr\n",
    "def update_mom(optimizer, mom):\n",
    "    for g in optimizer.param_groups:\n",
    "        g['momentum'] = mom\n",
    "\n",
    "def train(model,dataloaders,num_epochs,lr):\n",
    "    i = 0\n",
    "    phase1 = dataloaders.keys()\n",
    "    losses = list()\n",
    "    acc_all = list()\n",
    "    train_loader = dataloaders['train']\n",
    "    iteration = 0\n",
    "    total = 0\n",
    "    correct = 0\n",
    "    iteration1 = 0\n",
    "    onecyc = OneCycle(len(train_loader)*num_epochs,lr)\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "    for epoch in range(num_epochs):\n",
    "        print('------------------Epoch: {} ------------------'.format(epoch))\n",
    "        if(epoch%10==0 and epoch!=0):\n",
    "            lr = 0.9*lr\n",
    "            num_epochs = num_epochs-10\n",
    "            onecyc = OneCycle(len(train_loader)*num_epochs,lr)\n",
    "            optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "        \n",
    "        epoch_metrics = {\"loss\": [], \"acc\": []}\n",
    "        for phase in phase1:\n",
    "            if(phase  == 'train'):\n",
    "                model = model.train()\n",
    "                print('')\n",
    "                print('-------------------{}------------------'.format(phase))\n",
    "            \n",
    "            else:\n",
    "                model = model.eval()\n",
    "                print('')\n",
    "                print('-------------------{}------------------'.format(phase))\n",
    "            for batch_idx,(data,target) in enumerate(dataloaders[phase]):\n",
    "                if(data.size(0)<4):\n",
    "                    break\n",
    "                with torch.no_grad():\n",
    "                    data = data.reshape(-1,3,im_size,im_size)\n",
    "                data, target = Variable(data), Variable(target)\n",
    "                data = data.type(torch.FloatTensor).to(device)\n",
    "                target = target.type(torch.LongTensor).to(device)\n",
    "                optimizer.zero_grad()\n",
    "                output = model(data)\n",
    "                del data\n",
    "                loss = criterion(output, target)\n",
    "                if(phase =='train'):\n",
    "                    loss.cuda().backward()\n",
    "                    optimizer.step()\n",
    "                    lr,_ = onecyc.calc()\n",
    "                    update_lr(optimizer, lr)\n",
    "                acc = 100 * (output.detach().argmax(1) == target).cpu().numpy().mean()\n",
    "                epoch_metrics[\"loss\"].append(loss.detach().item())\n",
    "                epoch_metrics[\"acc\"].append(acc)\n",
    "                total += target.size(0)\n",
    "                correct += (output.argmax(1) == target).sum().item()\n",
    "                del output,target\n",
    "                sys.stdout.write(\n",
    "                \"\\r[Epoch %d/%d] [Batch %d/%d] [Loss: %f (%f), Acc: %.2f%% (%.2f%%)]\"\n",
    "                    #, Acc: %.2f%% (%.2f%%)\n",
    "                % (\n",
    "                    epoch,\n",
    "                    num_epochs,\n",
    "                    batch_idx,\n",
    "                    len(dataloaders[phase]),\n",
    "                    loss.item(),\n",
    "                    np.mean(epoch_metrics[\"loss\"]),\n",
    "                    acc,\n",
    "                    np.mean(epoch_metrics[\"acc\"]),\n",
    "                    )\n",
    "                )\n",
    "                if torch.cuda.is_available():\n",
    "                    torch.cuda.empty_cache()\n",
    "                del loss\n",
    "            epoch_acc = np.mean(epoch_metrics[\"acc\"])\n",
    "            epoch_loss = np.mean(epoch_metrics[\"loss\"])\n",
    "            print('')\n",
    "            print('acc:',correct*100/total)\n",
    "            if(phase == 'train'):\n",
    "                losses.append(epoch_loss)\n",
    "                acc_all.append(epoch_acc)\n",
    "                save = {\n",
    "                    'model':'convlstmvgg',\n",
    "                    'epoch':epoch,\n",
    "                    'train_loss':epoch_loss,\n",
    "                    'train_acc':epoch_acc,\n",
    "                    'dict':model.module.state_dict(),\n",
    "                    'lr':lr\n",
    "                }\n",
    "                torch.save(save,'./weights_att1/convlstmvgg.h5')\n",
    "            print('')\n",
    "            print('{} Accuracy: {}'.format(phase,epoch_acc.item()))\n",
    "    return losses,acc_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from efficientnet_pytorch import EfficientNet\n",
    "from ConvLSTM_pytorch.convlstm import ConvLSTM\n",
    "size = 14\n",
    "class Model(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Model, self).__init__()\n",
    "        model = models.vgg16_bn(pretrained = True)\n",
    "        model = nn.Sequential(*[model.features[i] for i in range(43)])\n",
    "        self.model = model\n",
    "        self.c1 = ConvLSTM(  input_size=(size,size),\n",
    "                             input_dim=512,\n",
    "                             hidden_dim=[64, 128],\n",
    "                             kernel_size=(5,5),\n",
    "                             num_layers=2,\n",
    "                             batch_first = True,\n",
    "                             bias=True,\n",
    "                             return_all_layers = False)\n",
    "        self.fc1 = nn.Linear(6272*4,1000)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.bn1 = nn.BatchNorm1d(1000)\n",
    "        self.bn2 = nn.BatchNorm1d(256)\n",
    "        self.bn3 = nn.BatchNorm1d(10)\n",
    "        self.fc2 = nn.Linear(1000,256)\n",
    "        self.fc3 = nn.Linear(256,4)\n",
    "        self.dp = nn.Dropout(0.1)\n",
    "    def forward(self, x):\n",
    "        x = self.model(x)\n",
    "        x = x.view(-1,100,512,size,size).detach()\n",
    "        x = self.c1(x)\n",
    "        x = x[0][0][:,-1,:,:,:]\n",
    "        x = x.view(-1,6272*4).detach()\n",
    "        x = self.dp(self.relu(self.fc1(x)))\n",
    "        x = self.dp(self.relu(self.fc2(x)))\n",
    "        x = self.dp(self.fc3(x))\n",
    "        return x\n",
    "model = Model().to('cuda')\n",
    "model = nn.DataParallel(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!git clone https://github.com/ndrplz/ConvLSTM_pytorch\n",
    "from ConvLSTM_pytorch.convlstm import ConvLSTM\n",
    "size = 3\n",
    "class Model(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Model, self).__init__()\n",
    "        model = models.densenet121(pretrained = True).to('cuda')\n",
    "        modules= list(model.children())[0]\n",
    "        model = nn.Sequential(*modules)\n",
    "        self.model = model\n",
    "        self.c1 = ConvLSTM(  input_size=(size,size),\n",
    "                             input_dim= 1024,\n",
    "                             hidden_dim=[128, 512],\n",
    "                             kernel_size=(5,5),\n",
    "                             num_layers=2,\n",
    "                             batch_first = True,\n",
    "                             bias=True,\n",
    "                             return_all_layers=False)\n",
    "        self.fc1 = nn.Linear(512*size*size,1000)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.bn1 = nn.BatchNorm1d(1000)\n",
    "        self.bn2 = nn.BatchNorm1d(256)\n",
    "        self.bn3 = nn.BatchNorm1d(10)\n",
    "        self.fc2 = nn.Linear(1000,256)\n",
    "        self.fc3 = nn.Linear(256,4)\n",
    "        self.dp = nn.Dropout(0.2)\n",
    "    def forward(self, x):\n",
    "        x = self.model(x)\n",
    "        x = x.view(-1,150,1024,size,size).detach()\n",
    "        x = self.c1(x)\n",
    "        x = x[0][0][:,-1,:,:,:]\n",
    "        x = x.view(-1,512*size*size)\n",
    "        x = self.dp(self.relu(self.fc1(x)))\n",
    "        x = self.dp(self.relu(self.fc2(x)))\n",
    "        x = self.dp(self.fc3(x))\n",
    "        return x\n",
    "model = Model().to('cuda')\n",
    "model = nn.DataParallel(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------Epoch: 0 ------------------\n",
      "\n",
      "-------------------train------------------\n",
      "[Epoch 0/10] [Batch 402/1315] [Loss: 0.001477 (0.141576), Acc: 100.00% (94.23%)]"
     ]
    }
   ],
   "source": [
    "from Modular_code.clr import OneCycle\n",
    "train_loader = DataLoader(train_data,batch_size = 4,num_workers = 8,shuffle = True) \n",
    "valid_loader = DataLoader(val_data,batch_size = 4,num_workers = 8)\n",
    "dataloaders = {'train':train_loader,'val':valid_loader}\n",
    "l1,a1 = train(model,dataloaders,10,0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#regression\n",
    "os.makedirs('./weights_att1',exist_ok = True)\n",
    "import sys\n",
    "import cv2\n",
    "from torch.autograd import Variable\n",
    "device = 'cuda'\n",
    "criterion = nn.MSELoss().to(device)\n",
    "def update_lr(optimizer, lr):\n",
    "    for g in optimizer.param_groups:\n",
    "        g['lr'] = lr\n",
    "def update_mom(optimizer, mom):\n",
    "    for g in optimizer.param_groups:\n",
    "        g['momentum'] = mom\n",
    "\n",
    "def train(model,dataloaders,device,num_epochs,lr,batch_size,patience):\n",
    "    i = 0\n",
    "    phase1 = dataloaders.keys()\n",
    "    losses = list()\n",
    "    acc_all = list()\n",
    "    train_loader = dataloaders['train']\n",
    "    iteration = 0\n",
    "    iteration1 = 0\n",
    "    onecyc = OneCycle(len(train_loader)*num_epochs,lr)\n",
    "    optimizer = RAdam(model.parameters(), lr=lr)\n",
    "    for epoch in range(num_epochs):\n",
    "        print('------------------Epoch: {} ------------------'.format(epoch))\n",
    "        if(epoch%20==0 and epoch!=0):\n",
    "            lr = 0.9*lr\n",
    "            num_epochs = num_epochs-20\n",
    "            onecyc = OneCycle(len(train_loader)*num_epochs,lr)\n",
    "            optimizer = RAdam(model.parameters(), lr=lr)\n",
    "        \n",
    "        epoch_metrics = {\"loss\": [], \"acc\": []}\n",
    "        for phase in phase1:\n",
    "            print('')\n",
    "            print('-------------------{}------------------'.format(phase))\n",
    "            if(phase  == 'train'):\n",
    "                model = model.train()\n",
    "            else:\n",
    "                model = model.eval()\n",
    "            for  batch_idx, (data, target) in enumerate(dataloaders[phase]):\n",
    "                bs = data.size(0)\n",
    "                data, target = Variable(data), Variable(target)\n",
    "                data = data.type(torch.FloatTensor).to(device)\n",
    "                target = target.type(torch.FloatTensor).to(device)\n",
    "                optimizer.zero_grad()\n",
    "                output = model(data)\n",
    "                del data\n",
    "                loss = criterion(output.squeeze(), target)\n",
    "                #acc = 100 * (output.detach().argmax(1) == target).cpu().numpy().mean()\n",
    "                del output,target\n",
    "                epoch_metrics[\"loss\"].append(loss.item())\n",
    "                #epoch_metrics[\"acc\"].append(acc)\n",
    "                sys.stdout.write(\n",
    "                \"\\r[Epoch %d/%d] [Batch %d/%d] [Loss: %f (%f)]\"\n",
    "                    #, Acc: %.2f%% (%.2f%%)\n",
    "                % (\n",
    "                    epoch,\n",
    "                    num_epochs,\n",
    "                    batch_idx,\n",
    "                    len(dataloaders[phase]),\n",
    "                    loss.item(),\n",
    "                    np.mean(epoch_metrics[\"loss\"])#,\n",
    "                    #acc,\n",
    "                   # np.mean(epoch_metrics[\"acc\"]),\n",
    "                    )\n",
    "                )\n",
    "\n",
    "                if(phase =='train'):\n",
    "                    loss.backward()\n",
    "                    optimizer.step()\n",
    "                    lr,_ = onecyc.calc()\n",
    "                    update_lr(optimizer, lr)\n",
    "                    iteration = iteration+1\n",
    "                    #writer.add_scalar('data/acc',np.mean(epoch_metrics[\"acc\"]) , iteration)\n",
    "                    writer.add_scalar('data/loss',np.mean(epoch_metrics[\"loss\"]) , iteration)\n",
    "                if(phase=='val'):\n",
    "                    iteration1 = iteration1+1\n",
    "                    #writer.add_scalar('data/valacc',np.mean(epoch_metrics[\"acc\"]) , iteration1)\n",
    "                    writer.add_scalar('data/valloss',np.mean(epoch_metrics[\"loss\"]) , iteration1)\n",
    "                if torch.cuda.is_available():\n",
    "                    torch.cuda.empty_cache()\n",
    "         #   epoch_acc = np.mean(epoch_metrics[\"acc\"])\n",
    "            epoch_loss = np.mean(epoch_metrics[\"loss\"])\n",
    "            if(phase == 'train'):\n",
    "                losses.append(epoch_loss)\n",
    "                #acc_all.append(epoch_acc)\n",
    "                #writer.add_scalar('data/accep',np.mean(epoch_metrics[\"acc\"]) , epoch)\n",
    "                writer.add_scalar('data/lossep',np.mean(epoch_metrics[\"loss\"]) , epoch)\n",
    "                save = {\n",
    "                    'model':'101-b0',\n",
    "                    'epoch':epoch,\n",
    "                    'train_loss':epoch_loss,\n",
    "                    #'train_acc':epoch_acc,\n",
    "                    'dict':model.module.state_dict(),\n",
    "                    'lr':lr\n",
    "                }\n",
    "                torch.save(save,'./weights_att1/slow_fast101-b0-1.h5')\n",
    "            print('')\n",
    "          #  print('{} Accuracy: {}'.format(phase,epoch_acc.item()))\n",
    "    return losses,acc_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "__all__ = ['resnet50', 'resnet101','resnet152', 'resnet200']\n",
    "\n",
    "\n",
    "\n",
    "class Bottleneck(nn.Module):\n",
    "    expansion = 4\n",
    "\n",
    "    def __init__(self, inplanes, planes, stride=1, downsample=None, head_conv=1):\n",
    "        super(Bottleneck, self).__init__()\n",
    "        if head_conv == 1:\n",
    "            self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False)\n",
    "            self.bn1 = nn.BatchNorm3d(planes)\n",
    "        elif head_conv == 3:\n",
    "            self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=(3, 1, 1), bias=False, padding=(1, 0, 0))\n",
    "            self.bn1 = nn.BatchNorm3d(planes)\n",
    "        else:\n",
    "            raise ValueError(\"Unsupported head_conv!\")\n",
    "        self.conv2 = nn.Conv3d(\n",
    "            planes, planes, kernel_size=(1, 3, 3), stride=(1,stride,stride), padding=(0, 1, 1), bias=False)\n",
    "        self.bn2 = nn.BatchNorm3d(planes)\n",
    "        self.conv3 = nn.Conv3d(planes, planes * 4, kernel_size=1, bias=False)\n",
    "        self.bn3 = nn.BatchNorm3d(planes * 4)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.downsample = downsample\n",
    "        self.stride = stride\n",
    "\n",
    "    def forward(self, x):\n",
    "        residual = x\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv3(out)\n",
    "        out = self.bn3(out)\n",
    "\n",
    "        if self.downsample is not None:\n",
    "            residual = self.downsample(x)\n",
    "        out += residual\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "class SlowFast(nn.Module):\n",
    "    def __init__(self, block=Bottleneck, layers=[3, 4, 6, 3], class_num=10, dropout=0.2):\n",
    "        super(SlowFast, self).__init__()\n",
    "\n",
    "        self.fast_inplanes = 8\n",
    "        self.fast_conv1 = nn.Conv3d(3, 8, kernel_size=(5, 7, 7), stride=(1, 2, 2), padding=(2, 3, 3), bias=False)\n",
    "        self.fast_bn1 = nn.BatchNorm3d(8)\n",
    "        self.fast_relu = nn.ReLU(inplace=True)\n",
    "        self.fast_maxpool = nn.MaxPool3d(kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1))\n",
    "        self.fast_res2 = self._make_layer_fast(block, 8, layers[0], head_conv=3)\n",
    "        self.fast_res3 = self._make_layer_fast(\n",
    "            block, 16, layers[1], stride=2, head_conv=3)\n",
    "        self.fast_res4 = self._make_layer_fast(\n",
    "            block, 32, layers[2], stride=2, head_conv=3)\n",
    "        self.fast_res5 = self._make_layer_fast(\n",
    "            block, 64, layers[3], stride=2, head_conv=3)\n",
    "        \n",
    "        self.lateral_p1 = nn.Conv3d(8, 8*2, kernel_size=(5, 1, 1), stride=(8, 1 ,1), bias=False, padding=(2, 0, 0))\n",
    "        self.lateral_res2 = nn.Conv3d(32,32*2, kernel_size=(5, 1, 1), stride=(8, 1 ,1), bias=False, padding=(2, 0, 0))\n",
    "        self.lateral_res3 = nn.Conv3d(64,64*2, kernel_size=(5, 1, 1), stride=(8, 1 ,1), bias=False, padding=(2, 0, 0))\n",
    "        self.lateral_res4 = nn.Conv3d(128,128*2, kernel_size=(5, 1, 1), stride=(8, 1 ,1), bias=False, padding=(2, 0, 0))\n",
    "\n",
    "        self.slow_inplanes = 64+64//8*2\n",
    "        self.slow_conv1 = nn.Conv3d(3, 64, kernel_size=(1, 7, 7), stride=(1, 2, 2), padding=(0, 3, 3), bias=False)\n",
    "        self.slow_bn1 = nn.BatchNorm3d(64)\n",
    "        self.slow_relu = nn.ReLU(inplace=True)\n",
    "        self.slow_maxpool = nn.MaxPool3d(kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1))\n",
    "        self.slow_res2 = self._make_layer_slow(block, 64, layers[0], head_conv=1)\n",
    "        self.slow_res3 = self._make_layer_slow(\n",
    "            block, 128, layers[1], stride=2, head_conv=1)\n",
    "        self.slow_res4 = self._make_layer_slow(\n",
    "            block, 256, layers[2], stride=2, head_conv=3)\n",
    "        self.slow_res5 = self._make_layer_slow(\n",
    "            block, 512, layers[3], stride=2, head_conv=3)\n",
    "        self.dp = nn.Dropout(0.2)\n",
    "        self.fc = nn.Linear(768, 2, bias=False)\n",
    "        model = models.video.mc3_18(pretrained  = True)\n",
    "        model.fc = Identity()\n",
    "        for param in model.parameters():\n",
    "            param.requires_grad = False\n",
    "        self.SlowPath = model\n",
    "    def forward(self, input):\n",
    "        fast = self.FastPath(input[:, :, :, :, :])\n",
    "        slow = self.SlowPath(input[:, :, ::2, :, :])\n",
    "        x = torch.cat([slow, fast], dim=1)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "\n",
    "    def FastPath(self, input):\n",
    "        lateral = []\n",
    "        x = self.fast_conv1(input)\n",
    "        x = self.fast_bn1(x)\n",
    "        x = self.fast_relu(x)\n",
    "        pool1 = self.fast_maxpool(x)\n",
    "        res2 = self.fast_res2(pool1)\n",
    "        \n",
    "        res3 = self.fast_res3(res2)\n",
    "\n",
    "        res4 = self.fast_res4(res3)\n",
    "\n",
    "        res5 = self.fast_res5(res4)\n",
    "        x = nn.AdaptiveAvgPool3d(1)(res5)\n",
    "        x = x.view(-1, x.size(1))\n",
    "\n",
    "        return x\n",
    "\n",
    "    def _make_layer_fast(self, block, planes, blocks, stride=1, head_conv=1):\n",
    "        downsample = None\n",
    "        if stride != 1 or self.fast_inplanes != planes * block.expansion:\n",
    "            downsample = nn.Sequential(\n",
    "                nn.Conv3d(\n",
    "                    self.fast_inplanes,\n",
    "                    planes * block.expansion,\n",
    "                    kernel_size=1,\n",
    "                    stride=(1,stride,stride),\n",
    "                    bias=False), nn.BatchNorm3d(planes * block.expansion))\n",
    "\n",
    "        layers = []\n",
    "        layers.append(block(self.fast_inplanes, planes, stride, downsample, head_conv=head_conv))\n",
    "        self.fast_inplanes = planes * block.expansion\n",
    "        for i in range(1, blocks):\n",
    "            layers.append(block(self.fast_inplanes, planes, head_conv=head_conv))\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def _make_layer_slow(self, block, planes, blocks, stride=1, head_conv=1):\n",
    "        downsample = None\n",
    "        if stride != 1 or self.slow_inplanes != planes * block.expansion:\n",
    "            downsample = nn.Sequential(\n",
    "                nn.Conv3d(\n",
    "                    self.slow_inplanes,\n",
    "                    planes * block.expansion,\n",
    "                    kernel_size=1,\n",
    "                    stride=(1,stride,stride),\n",
    "                    bias=False), nn.BatchNorm3d(planes * block.expansion))\n",
    "\n",
    "        layers = []\n",
    "        layers.append(block(self.slow_inplanes, planes, stride, downsample, head_conv=head_conv))\n",
    "        self.slow_inplanes = planes * block.expansion\n",
    "        for i in range(1, blocks):\n",
    "            layers.append(block(self.slow_inplanes, planes, head_conv=head_conv))\n",
    "  \n",
    "        self.slow_inplanes = planes * block.expansion + planes * block.expansion//8*2\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def resnet50(**kwargs):\n",
    "    \"\"\"Constructs a ResNet-50 model.\n",
    "    \"\"\"\n",
    "    model = SlowFast(Bottleneck, [3, 4, 6, 3], **kwargs)\n",
    "    return model\n",
    "\n",
    "\n",
    "def resnet101(**kwargs):\n",
    "    \"\"\"Constructs a ResNet-101 model.\n",
    "    \"\"\"\n",
    "    model = SlowFast(Bottleneck, [3, 4, 23, 3], **kwargs)\n",
    "    return model\n",
    "\n",
    "\n",
    "def resnet152(**kwargs):\n",
    "    \"\"\"Constructs a ResNet-101 model.\n",
    "    \"\"\"\n",
    "    model = SlowFast(Bottleneck, [3, 8, 36, 3], **kwargs)\n",
    "    return model\n",
    "\n",
    "\n",
    "def resnet200(**kwargs):\n",
    "    \"\"\"Constructs a ResNet-101 model.\n",
    "    \"\"\"\n",
    "    model = SlowFast(Bottleneck, [3, 24, 36, 3], **kwargs)\n",
    "    return model"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}