{"cells":[{"metadata":{},"cell_type":"markdown","source":"## pytorch_seresnext101-32x4d+kfold+focal loss v3.0\n\n\n* fold = 4\n* epoch = 3\n* γ=0.4"},{"metadata":{"trusted":true},"cell_type":"code","source":"!nvidia-smi","execution_count":1,"outputs":[{"output_type":"stream","text":"Thu Jun  6 05:42:45 2019       \r\n+-----------------------------------------------------------------------------+\r\n| NVIDIA-SMI 410.104      Driver Version: 410.104      CUDA Version: 10.0     |\r\n|-------------------------------+----------------------+----------------------+\r\n| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\r\n| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\r\n|===============================+======================+======================|\r\n|   0  Tesla P100-PCIE...  On   | 00000000:00:04.0 Off |                    0 |\r\n| N/A   48C    P0    28W / 250W |      0MiB / 16280MiB |      0%      Default |\r\n+-------------------------------+----------------------+----------------------+\r\n                                                                               \r\n+-----------------------------------------------------------------------------+\r\n| Processes:                                                       GPU Memory |\r\n|  GPU       PID   Type   Process name                             Usage      |\r\n|=============================================================================|\r\n|  No running processes found                                                 |\r\n+-----------------------------------------------------------------------------+\r\n","name":"stdout"}]},{"metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","trusted":true},"cell_type":"code","source":"import torch\nfrom torch import nn, optim\nimport torch.nn.functional as F\nimport matplotlib.pyplot as plt\nimport sys\nimport time\nimport numpy as np\nimport math\nimport pandas as pd\nfrom PIL import Image, ImageOps, ImageFilter\nfrom datetime import datetime\nfrom torch.autograd import Variable\nfrom torch.utils.data import Dataset, DataLoader\nimport torchvision.transforms as transforms\nfrom torchvision import datasets, models, transforms\nimport random\nimport datetime\nimport os\n\nfrom sklearn import preprocessing \nfrom sklearn.model_selection import KFold\n\ndevice = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\nprint(device)","execution_count":2,"outputs":[{"output_type":"stream","text":"cuda:0\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# os.chdir(\"../input/pretrained_PyTorch/\")\n# os.getcwd()","execution_count":3,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train = pd.read_csv(\"../input/imet-2019-fgvc6/train.csv\")\nlable = pd.read_csv(\"../input/imet-2019-fgvc6/labels.csv\")\ntest = pd.read_csv(\"../input/imet-2019-fgvc6/sample_submission.csv\")","execution_count":4,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"lable_length = len(lable)\ntrain_length = len(train)\ntest_length = len(test)\nprint(train_length)\nprint(lable_length)\nprint(test_length)","execution_count":5,"outputs":[{"output_type":"stream","text":"109237\n1103\n7443\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(np.array(lable)[397])\nprint(np.array(lable)[398])\nc_length = len(np.array(lable)[:398])\nt_length = len(np.array(lable)[398:])\nprint(c_length)\nprint(t_length)","execution_count":6,"outputs":[{"output_type":"stream","text":"[397 'culture::zurich']\n[398 'tag::abbies']\n398\n705\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"#np.array(test)","execution_count":7,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test.head","execution_count":8,"outputs":[{"output_type":"execute_result","execution_count":8,"data":{"text/plain":"<bound method NDFrame.head of                     id attribute_ids\n0     10023b2cc4ed5f68         0 1 2\n1     100fbe75ed8fd887         0 1 2\n2     101b627524a04f19         0 1 2\n3     10234480c41284c6         0 1 2\n4     1023b0e2636dcea8         0 1 2\n5      1039cd6cf85845c         0 1 2\n6      103a5b3f83fbe88         0 1 2\n7     10413aaae8d6a9a2         0 1 2\n8     10423822b93a65ab         0 1 2\n9     1052bf702cb099f7         0 1 2\n10     10543c918a43a8d         0 1 2\n11    105c9a3453da79c3         0 1 2\n12    1060688bbf6eac87         0 1 2\n13    106a247caeabd15a         0 1 2\n14    106e21606add59f3         0 1 2\n15    107c38495881b6c9         0 1 2\n16    108815dd3752ab64         0 1 2\n17    10943defdd5d5e89         0 1 2\n18    10a39a78c44ef27c         0 1 2\n19     10ab70df067bdb4         0 1 2\n20    10b28e3de3566582         0 1 2\n21    10b32964331a6cc3         0 1 2\n22    10b4562e7fa6f668         0 1 2\n23    10db1c338e1d822f         0 1 2\n24    10e0c215f5f3084e         0 1 2\n25    10e95bead8e0b35b         0 1 2\n26    1100d7b0f24fee88         0 1 2\n27    11099b321e8c7066         0 1 2\n28    110df388fd5c50e4         0 1 2\n29    113520ea0138f76d         0 1 2\n...                ...           ...\n7413  ff2da1f0ed3e3ebe         0 1 2\n7414  ff3a9fa43f8eab9c         0 1 2\n7415  ff44490e20740a19         0 1 2\n7416  ff481bb029678d5d         0 1 2\n7417  ff4c3570fb7b90d3         0 1 2\n7418  ff4f548d08414709         0 1 2\n7419  ff668377a518ea5f         0 1 2\n7420  ff6a549b2d7a0e76         0 1 2\n7421  ff6ee1b37c8dc1ae         0 1 2\n7422  ff85460d6b853b49         0 1 2\n7423   ff8721b85d1b5a5         0 1 2\n7424  ff8bef7d0de52b31         0 1 2\n7425  ff92504c82c41e0f         0 1 2\n7426  ff9d4b77c124c9f2         0 1 2\n7427  ff9ddf70cb1c2674         0 1 2\n7428  ffaf8c3fe0b1d9b6         0 1 2\n7429  ffb61df4a6734772         0 1 2\n7430  ffb73f95b8721900         0 1 2\n7431  ffb937b55755323e         0 1 2\n7432  ffbcf8b91a8e8ce0         0 1 2\n7433  ffbf4849bde21b0a         0 1 2\n7434  ffc96e053345419d         0 1 2\n7435  ffcb16053099d795         0 1 2\n7436  ffcf745289465074         0 1 2\n7437  ffd1372fe67e65f0         0 1 2\n7438  ffd79eadf642221b         0 1 2\n7439  ffd96986aa333f4d         0 1 2\n7440  ffe54b454396d97c         0 1 2\n7441  ffe7d7db4e4aa37f         0 1 2\n7442  ffed0a4aca0d5457         0 1 2\n\n[7443 rows x 2 columns]>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"#np.array(train)","execution_count":9,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def creatData(train,lable_length):\n    train = np.array(train)\n    trainA_data = []\n    lab_data = []\n    #trainC_data = []\n    #trainT_data = []\n    for t in range(train_length):\n        v = np.zeros(lable_length)\n        #print(train[t,1])\n        lab = []\n        for s in train[t,1].split(\" \"):\n            #print(s)\n            v[int(s)] = 1\n            lab.append(int(s))\n        trainA_data.append([train[t,0],v])\n        lab_data.append([train[t,0],np.array(lab)])\n        #trainC_data.append([train[t,0],v[:c_length]])\n        #trainT_data.append([train[t,0],v[c_length:]])\n    return np.array(trainA_data),np.array(lab_data)\n    #return np.array(trainA_data)#,np.array(trainC_data),np.array(trainT_data)","execution_count":10,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_a,train_lab = creatData(train,lable_length)\n#train_a,train_c,train_t = creatData(train,lable_length)\n#train_t.shape()","execution_count":11,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_lab[0]","execution_count":12,"outputs":[{"output_type":"execute_result","execution_count":12,"data":{"text/plain":"array(['1000483014d91860', array([147, 616, 813])], dtype=object)"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"### Remove the item that only have one feature (not work well)"},{"metadata":{"trusted":true},"cell_type":"code","source":"def dfilter(data,th):\n    dfilter = []\n    for i in range(len(data)):\n        if train_a[i][1].sum()>th:\n            dfilter.append(train_a[i])\n    return np.array(dfilter)","execution_count":13,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"datafilter = dfilter(train_a,1) # remain feature great then 1","execution_count":14,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(f\"amount of image before: {len(train_a)}\")\n\nprint(f\"amount of image after: {len(datafilter)}\")","execution_count":15,"outputs":[{"output_type":"stream","text":"amount of image before: 109237\namount of image after: 104913\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# not use\ndatafilter = train_a","execution_count":16,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"image_resize = 200\ndata_transforms2 = transforms.Compose([\n    transforms.Resize((image_resize,image_resize)),\n    #transforms.RandomResizedCrop(250),\n    #transforms.RandomHorizontalFlip(),\n    transforms.ToTensor(),\n    transforms.Normalize(\n            [0.485, 0.456, 0.406], \n            [0.229, 0.224, 0.225])\n    ])\n\n\ndata_transforms = transforms.Compose([\n    transforms.Resize((image_resize,image_resize)),\n    #transforms.RandomResizedCrop(250),\n    #transforms.RandomHorizontalFlip(),\n    transforms.ToTensor(),\n    #transforms.Normalize(\n    #        [0.485, 0.456, 0.406], \n    #        [0.229, 0.224, 0.225])\n    ])\n\ntrain_transformer = transforms.Compose([\n    transforms.Resize((128,128)),              # resize the image to \n    #transforms.RandomHorizontalFlip(),  # randomly flip image horizontally\n    #transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n    transforms.ToTensor(),           # transform it into a PyTorch Tensor\n    #transforms.Normalize(mean = (0.5, 0.5, 0.5), std = (0.5, 0.5, 0.5))\n])","execution_count":17,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class trainDataset(Dataset):\n    def __init__(self, train_lib, transform,transform2):\n        self.filenames = train_lib[:,0]\n        self.labels = train_lib[:,1]\n        self.transform = transform\n        self.transform2 = transform2\n        #self.new_feature = \n\n    def __len__(self):\n        return len(self.filenames)\n\n    def __getitem__(self, idx):\n        img = Image.open(\"../input/imet-2019-fgvc6/train/\"+format(self.filenames[idx])+'.png')  # PIL image\n        #image= image.filter(ImageFilter.EDGE_ENHANCE)\n        #image2 = image.filter(ImageFilter.FIND_EDGES)\n        image = self.transform(img)\n        image2 = self.transform2(img)\n        #return image, self.labels[idx]\n        return image,image2, self.labels[idx]\n","execution_count":18,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class testDataset(Dataset):\n    def __init__(self, test_lib, transform,transform2):\n        test_lib = np.array(test_lib)\n        self.filenames = test_lib[:,0]\n        #self.labels = test_lib[:,1]\n        self.transform = transform\n        self.transform2 = transform2\n\n    def __len__(self):\n        return len(self.filenames)\n\n    def __getitem__(self, idx):\n        img = Image.open(\"../input/imet-2019-fgvc6/test/\"+format(self.filenames[idx])+'.png')  # PIL image\n        #image= image.filter(ImageFilter.EDGE_ENHANCE)\n        #image2 = image.filter(ImageFilter.FIND_EDGES)\n        image = self.transform(img)\n        image2 = self.transform2(img)\n        #return image,self.filenames[idx]\n        return image,image2,self.filenames[idx]","execution_count":19,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"trainA_dataloader = DataLoader(trainDataset(datafilter, data_transforms,data_transforms2),batch_size=32, shuffle=True,num_workers=2, pin_memory=True)\n#trainC_dataloader = DataLoader(trainDataset(train_c, data_transforms,data_transforms2),batch_size=32, shuffle=True,num_workers=2, pin_memory=True)\n#trainT_dataloader = DataLoader(trainDataset(train_t, data_transforms,data_transforms2),batch_size=32, shuffle=True,num_workers=2, pin_memory=True)","execution_count":20,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"score_dataloader = DataLoader(trainDataset(datafilter[:1000], data_transforms,data_transforms2),batch_size=32, shuffle=False,num_workers=2, pin_memory=True)","execution_count":21,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_dataloader = DataLoader(testDataset(test, data_transforms,data_transforms2),batch_size=32,shuffle=False,num_workers=2, pin_memory=True)","execution_count":22,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(10,10))\nplt.subplot(2,2,1)\nplt.imshow(transforms.ToPILImage()(trainA_dataloader.dataset[15][0]).convert('RGB'))\nplt.subplot(2,2,2)\nplt.imshow(transforms.ToPILImage()(trainA_dataloader.dataset[15][1]).convert('RGB'))\nplt.subplot(2,2,3)\nplt.imshow(transforms.ToPILImage()(trainA_dataloader.dataset[29][0]).convert('RGB'))\nplt.subplot(2,2,4)\nplt.imshow(transforms.ToPILImage()(trainA_dataloader.dataset[29][1]).convert('RGB'))\n","execution_count":23,"outputs":[{"output_type":"execute_result","execution_count":23,"data":{"text/plain":"<matplotlib.image.AxesImage at 0x7f643e2651d0>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 720x720 with 4 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"#(np.array(trainC_dataloader.dataset[4][0]).shape)","execution_count":24,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# https://github.com/Cadene/pretrained-models.pytorch/blob/master/pretrainedmodels/models/senet.py\n\"\"\"\nResNet code gently borrowed from\nhttps://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py\n\"\"\"\nfrom __future__ import print_function, division, absolute_import\nfrom collections import OrderedDict\nimport math\n\nimport torch.nn as nn\nfrom torch.utils import model_zoo\n\n__all__ = ['SENet', 'senet154', 'se_resnet50', 'se_resnet101', 'se_resnet152',\n           'se_resnext50_32x4d', 'se_resnext101_32x4d']\n\npretrained_settings = {\n    'senet154': {\n        'imagenet': {\n            'url': 'http://data.lip6.fr/cadene/pretrainedmodels/senet154-c7b49a05.pth',\n            'input_space': 'RGB',\n            'input_size': [3, 224, 224],\n            'input_range': [0, 1],\n            'mean': [0.485, 0.456, 0.406],\n            'std': [0.229, 0.224, 0.225],\n            'num_classes': 1000\n        }\n    },\n    'se_resnet50': {\n        'imagenet': {\n            'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se_resnet50-ce0d4300.pth',\n            'input_space': 'RGB',\n            'input_size': [3, 224, 224],\n            'input_range': [0, 1],\n            'mean': [0.485, 0.456, 0.406],\n            'std': [0.229, 0.224, 0.225],\n            'num_classes': 1000\n        }\n    },\n    'se_resnet101': {\n        'imagenet': {\n            'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se_resnet101-7e38fcc6.pth',\n            'input_space': 'RGB',\n            'input_size': [3, 224, 224],\n            'input_range': [0, 1],\n            'mean': [0.485, 0.456, 0.406],\n            'std': [0.229, 0.224, 0.225],\n            'num_classes': 1000\n        }\n    },\n    'se_resnet152': {\n        'imagenet': {\n            'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se_resnet152-d17c99b7.pth',\n            'input_space': 'RGB',\n            'input_size': [3, 224, 224],\n            'input_range': [0, 1],\n            'mean': [0.485, 0.456, 0.406],\n            'std': [0.229, 0.224, 0.225],\n            'num_classes': 1000\n        }\n    },\n    'se_resnext50_32x4d': {\n        'imagenet': {\n            'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se_resnext50_32x4d-a260b3a4.pth',\n            'input_space': 'RGB',\n            'input_size': [3, 224, 224],\n            'input_range': [0, 1],\n            'mean': [0.485, 0.456, 0.406],\n            'std': [0.229, 0.224, 0.225],\n            'num_classes': 1000\n        }\n    },\n    'se_resnext101_32x4d': {\n        'imagenet': {\n            'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se_resnext101_32x4d-3b2fe3d8.pth',\n            'input_space': 'RGB',\n            'input_size': [3, 224, 224],\n            'input_range': [0, 1],\n            'mean': [0.485, 0.456, 0.406],\n            'std': [0.229, 0.224, 0.225],\n            'num_classes': 1000\n        }\n    },\n}\n\n\nclass SEModule(nn.Module):\n\n    def __init__(self, channels, reduction):\n        super(SEModule, self).__init__()\n        self.avg_pool = nn.AdaptiveAvgPool2d(1)\n        self.fc1 = nn.Conv2d(channels, channels // reduction, kernel_size=1,\n                             padding=0)\n        self.relu = nn.ReLU(inplace=True)\n        self.fc2 = nn.Conv2d(channels // reduction, channels, kernel_size=1,\n                             padding=0)\n        self.sigmoid = nn.Sigmoid()\n\n    def forward(self, x):\n        module_input = x\n        x = self.avg_pool(x)\n        x = self.fc1(x)\n        x = self.relu(x)\n        x = self.fc2(x)\n        x = self.sigmoid(x)\n        return module_input * x\n\n\nclass Bottleneck(nn.Module):\n    \"\"\"\n    Base class for bottlenecks that implements `forward()` method.\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\n        out = self.se_module(out) + residual\n        out = self.relu(out)\n\n        return out\n\n\nclass SEBottleneck(Bottleneck):\n    \"\"\"\n    Bottleneck for SENet154.\n    \"\"\"\n    expansion = 4\n\n    def __init__(self, inplanes, planes, groups, reduction, stride=1,\n                 downsample=None):\n        super(SEBottleneck, self).__init__()\n        self.conv1 = nn.Conv2d(inplanes, planes * 2, kernel_size=1, bias=False)\n        self.bn1 = nn.BatchNorm2d(planes * 2)\n        self.conv2 = nn.Conv2d(planes * 2, planes * 4, kernel_size=3,\n                               stride=stride, padding=1, groups=groups,\n                               bias=False)\n        self.bn2 = nn.BatchNorm2d(planes * 4)\n        self.conv3 = nn.Conv2d(planes * 4, planes * 4, kernel_size=1,\n                               bias=False)\n        self.bn3 = nn.BatchNorm2d(planes * 4)\n        self.relu = nn.ReLU(inplace=True)\n        self.se_module = SEModule(planes * 4, reduction=reduction)\n        self.downsample = downsample\n        self.stride = stride\n\n\nclass SEResNetBottleneck(Bottleneck):\n    \"\"\"\n    ResNet bottleneck with a Squeeze-and-Excitation module. It follows Caffe\n    implementation and uses `stride=stride` in `conv1` and not in `conv2`\n    (the latter is used in the torchvision implementation of ResNet).\n    \"\"\"\n    expansion = 4\n\n    def __init__(self, inplanes, planes, groups, reduction, stride=1,\n                 downsample=None):\n        super(SEResNetBottleneck, self).__init__()\n        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False,\n                               stride=stride)\n        self.bn1 = nn.BatchNorm2d(planes)\n        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1,\n                               groups=groups, bias=False)\n        self.bn2 = nn.BatchNorm2d(planes)\n        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)\n        self.bn3 = nn.BatchNorm2d(planes * 4)\n        self.relu = nn.ReLU(inplace=True)\n        self.se_module = SEModule(planes * 4, reduction=reduction)\n        self.downsample = downsample\n        self.stride = stride\n\n\nclass SEResNeXtBottleneck(Bottleneck):\n    \"\"\"\n    ResNeXt bottleneck type C with a Squeeze-and-Excitation module.\n    \"\"\"\n    expansion = 4\n\n    def __init__(self, inplanes, planes, groups, reduction, stride=1,\n                 downsample=None, base_width=4):\n        super(SEResNeXtBottleneck, self).__init__()\n        width = math.floor(planes * (base_width / 64)) * groups\n        self.conv1 = nn.Conv2d(inplanes, width, kernel_size=1, bias=False,\n                               stride=1)\n        self.bn1 = nn.BatchNorm2d(width)\n        self.conv2 = nn.Conv2d(width, width, kernel_size=3, stride=stride,\n                               padding=1, groups=groups, bias=False)\n        self.bn2 = nn.BatchNorm2d(width)\n        self.conv3 = nn.Conv2d(width, planes * 4, kernel_size=1, bias=False)\n        self.bn3 = nn.BatchNorm2d(planes * 4)\n        self.relu = nn.ReLU(inplace=True)\n        self.se_module = SEModule(planes * 4, reduction=reduction)\n        self.downsample = downsample\n        self.stride = stride\n\n\nclass SENet(nn.Module):\n\n    def __init__(self, block, layers, groups, reduction, dropout_p=0.2,\n                 inplanes=128, input_3x3=True, downsample_kernel_size=3,\n                 downsample_padding=1, num_classes=1000):\n        \"\"\"\n        Parameters\n        ----------\n        block (nn.Module): Bottleneck class.\n            - For SENet154: SEBottleneck\n            - For SE-ResNet models: SEResNetBottleneck\n            - For SE-ResNeXt models:  SEResNeXtBottleneck\n        layers (list of ints): Number of residual blocks for 4 layers of the\n            network (layer1...layer4).\n        groups (int): Number of groups for the 3x3 convolution in each\n            bottleneck block.\n            - For SENet154: 64\n            - For SE-ResNet models: 1\n            - For SE-ResNeXt models:  32\n        reduction (int): Reduction ratio for Squeeze-and-Excitation modules.\n            - For all models: 16\n        dropout_p (float or None): Drop probability for the Dropout layer.\n            If `None` the Dropout layer is not used.\n            - For SENet154: 0.2\n            - For SE-ResNet models: None\n            - For SE-ResNeXt models: None\n        inplanes (int):  Number of input channels for layer1.\n            - For SENet154: 128\n            - For SE-ResNet models: 64\n            - For SE-ResNeXt models: 64\n        input_3x3 (bool): If `True`, use three 3x3 convolutions instead of\n            a single 7x7 convolution in layer0.\n            - For SENet154: True\n            - For SE-ResNet models: False\n            - For SE-ResNeXt models: False\n        downsample_kernel_size (int): Kernel size for downsampling convolutions\n            in layer2, layer3 and layer4.\n            - For SENet154: 3\n            - For SE-ResNet models: 1\n            - For SE-ResNeXt models: 1\n        downsample_padding (int): Padding for downsampling convolutions in\n            layer2, layer3 and layer4.\n            - For SENet154: 1\n            - For SE-ResNet models: 0\n            - For SE-ResNeXt models: 0\n        num_classes (int): Number of outputs in `last_linear` layer.\n            - For all models: 1000\n        \"\"\"\n        super(SENet, self).__init__()\n        self.inplanes = inplanes\n        if input_3x3:\n            layer0_modules = [\n                ('conv1', nn.Conv2d(3, 64, 3, stride=2, padding=1,\n                                    bias=False)),\n                ('bn1', nn.BatchNorm2d(64)),\n                ('relu1', nn.ReLU(inplace=True)),\n                ('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1,\n                                    bias=False)),\n                ('bn2', nn.BatchNorm2d(64)),\n                ('relu2', nn.ReLU(inplace=True)),\n                ('conv3', nn.Conv2d(64, inplanes, 3, stride=1, padding=1,\n                                    bias=False)),\n                ('bn3', nn.BatchNorm2d(inplanes)),\n                ('relu3', nn.ReLU(inplace=True)),\n            ]\n        else:\n            layer0_modules = [\n                ('conv1', nn.Conv2d(3, inplanes, kernel_size=7, stride=2,\n                                    padding=3, bias=False)),\n                ('bn1', nn.BatchNorm2d(inplanes)),\n                ('relu1', nn.ReLU(inplace=True)),\n            ]\n        # To preserve compatibility with Caffe weights `ceil_mode=True`\n        # is used instead of `padding=1`.\n        layer0_modules.append(('pool', nn.MaxPool2d(3, stride=2,\n                                                    ceil_mode=True)))\n        self.layer0 = nn.Sequential(OrderedDict(layer0_modules))\n        self.layer1 = self._make_layer(\n            block,\n            planes=64,\n            blocks=layers[0],\n            groups=groups,\n            reduction=reduction,\n            downsample_kernel_size=1,\n            downsample_padding=0\n        )\n        self.layer2 = self._make_layer(\n            block,\n            planes=128,\n            blocks=layers[1],\n            stride=2,\n            groups=groups,\n            reduction=reduction,\n            downsample_kernel_size=downsample_kernel_size,\n            downsample_padding=downsample_padding\n        )\n        self.layer3 = self._make_layer(\n            block,\n            planes=256,\n            blocks=layers[2],\n            stride=2,\n            groups=groups,\n            reduction=reduction,\n            downsample_kernel_size=downsample_kernel_size,\n            downsample_padding=downsample_padding\n        )\n        self.layer4 = self._make_layer(\n            block,\n            planes=512,\n            blocks=layers[3],\n            stride=2,\n            groups=groups,\n            reduction=reduction,\n            downsample_kernel_size=downsample_kernel_size,\n            downsample_padding=downsample_padding\n        )\n        self.avg_pool = nn.AvgPool2d(7, stride=1)\n        self.dropout = nn.Dropout(dropout_p) if dropout_p is not None else None\n        self.last_linear = nn.Linear(512 * block.expansion, num_classes)\n\n    def _make_layer(self, block, planes, blocks, groups, reduction, stride=1,\n                    downsample_kernel_size=1, downsample_padding=0):\n        downsample = None\n        if stride != 1 or self.inplanes != planes * block.expansion:\n            downsample = nn.Sequential(\n                nn.Conv2d(self.inplanes, planes * block.expansion,\n                          kernel_size=downsample_kernel_size, stride=stride,\n                          padding=downsample_padding, bias=False),\n                nn.BatchNorm2d(planes * block.expansion),\n            )\n\n        layers = []\n        layers.append(block(self.inplanes, planes, groups, reduction, stride,\n                            downsample))\n        self.inplanes = planes * block.expansion\n        for i in range(1, blocks):\n            layers.append(block(self.inplanes, planes, groups, reduction))\n\n        return nn.Sequential(*layers)\n\n    def features(self, x):\n        x = self.layer0(x)\n        x = self.layer1(x)\n        x = self.layer2(x)\n        x = self.layer3(x)\n        x = self.layer4(x)\n        return x\n\n    def logits(self, x):\n        x = self.avg_pool(x)\n        if self.dropout is not None:\n            x = self.dropout(x)\n        x = x.view(x.size(0), -1)\n        x = self.last_linear(x)\n        return x\n\n    def forward(self, x):\n        x = self.features(x)\n        x = self.logits(x)\n        return x\n\n\ndef initialize_pretrained_model(model, num_classes, settings):\n    assert num_classes == settings['num_classes'], \\\n        'num_classes should be {}, but is {}'.format(\n            settings['num_classes'], num_classes)\n    model.load_state_dict(model_zoo.load_url(settings['url']))\n    model.input_space = settings['input_space']\n    model.input_size = settings['input_size']\n    model.input_range = settings['input_range']\n    model.mean = settings['mean']\n    model.std = settings['std']\n\n\ndef senet154(num_classes=1000, pretrained='imagenet'):\n    model = SENet(SEBottleneck, [3, 8, 36, 3], groups=64, reduction=16,\n                  dropout_p=0.2, num_classes=num_classes)\n    if pretrained is not None:\n        settings = pretrained_settings['senet154'][pretrained]\n        initialize_pretrained_model(model, num_classes, settings)\n    return model\n\n\ndef se_resnet50(num_classes=1000, pretrained='imagenet'):\n    model = SENet(SEResNetBottleneck, [3, 4, 6, 3], groups=1, reduction=16,\n                  dropout_p=None, inplanes=64, input_3x3=False,\n                  downsample_kernel_size=1, downsample_padding=0,\n                  num_classes=num_classes)\n    if pretrained is not None:\n        settings = pretrained_settings['se_resnet50'][pretrained]\n        initialize_pretrained_model(model, num_classes, settings)\n    return model\n\n\ndef se_resnet101(num_classes=1000, pretrained='imagenet'):\n    model = SENet(SEResNetBottleneck, [3, 4, 23, 3], groups=1, reduction=16,\n                  dropout_p=None, inplanes=64, input_3x3=False,\n                  downsample_kernel_size=1, downsample_padding=0,\n                  num_classes=num_classes)\n    if pretrained is not None:\n        settings = pretrained_settings['se_resnet101'][pretrained]\n        initialize_pretrained_model(model, num_classes, settings)\n    return model\n\n\ndef se_resnet152(num_classes=1000, pretrained='imagenet'):\n    model = SENet(SEResNetBottleneck, [3, 8, 36, 3], groups=1, reduction=16,\n                  dropout_p=None, inplanes=64, input_3x3=False,\n                  downsample_kernel_size=1, downsample_padding=0,\n                  num_classes=num_classes)\n    if pretrained is not None:\n        settings = pretrained_settings['se_resnet152'][pretrained]\n        initialize_pretrained_model(model, num_classes, settings)\n    return model\n\n\ndef se_resnext50_32x4d(num_classes=1000, pretrained='imagenet'):\n    model = SENet(SEResNeXtBottleneck, [3, 4, 6, 3], groups=32, reduction=16,\n                  dropout_p=None, inplanes=64, input_3x3=False,\n                  downsample_kernel_size=1, downsample_padding=0,\n                  num_classes=num_classes)\n    if pretrained is not None:\n        settings = pretrained_settings['se_resnext50_32x4d'][pretrained]\n        initialize_pretrained_model(model, num_classes, settings)\n    return model\n\n\ndef se_resnext101_32x4d(num_classes=1000, pretrained='imagenet'):\n    model = SENet(SEResNeXtBottleneck, [3, 4, 23, 3], groups=32, reduction=16,\n                  dropout_p=None, inplanes=64, input_3x3=False,\n                  downsample_kernel_size=1, downsample_padding=0,\n                  num_classes=num_classes)\n    if pretrained is not None:\n        settings = pretrained_settings['se_resnext101_32x4d'][pretrained]\n        initialize_pretrained_model(model, num_classes, settings)\n    return model","execution_count":25,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from shutil import copyfile\nfrom os.path import isfile, join, abspath, exists, isdir, expanduser\nfrom os import listdir, makedirs, getcwd, remove\n\ncache_dir = expanduser(join('~', '.torch'))\nif not exists(cache_dir):\n    makedirs(cache_dir)\nmodels_dir = join(cache_dir, 'models/')\nif not exists(models_dir):\n    makedirs(models_dir)\n    \ncopyfile(\"../input/pretrained-pytorch/densenet201-c1103571.pth\", models_dir+\"densenet201-c1103571.pth\")\ncopyfile(\"../input/pretrained-pytorch/resnet50-19c8e357.pth\", models_dir+\"resnet50-19c8e357.pth\")\ncopyfile(\"../input/pretrained-se-resnet/se_resnext101_32x4d-3b2fe3d8.pth\", models_dir+\"se_resnext101_32x4d-3b2fe3d8.pth\")","execution_count":26,"outputs":[{"output_type":"execute_result","execution_count":26,"data":{"text/plain":"'/tmp/.torch/models/se_resnext101_32x4d-3b2fe3d8.pth'"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"!ls ~/.torch/models ","execution_count":27,"outputs":[{"output_type":"stream","text":"densenet201-c1103571.pth  se_resnext101_32x4d-3b2fe3d8.pth\r\nresnet50-19c8e357.pth\r\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"class Ensemble(nn.Module):\n    def __init__(self, modelA, modelB,input_length,output_length):\n        super(Ensemble, self).__init__()\n        self.modelA = modelA\n        self.modelB = modelB\n        self.classifier = nn.Linear(input_length, output_length)\n        \n    def forward(self, xin,xin2):\n        x1 = self.modelA(xin)\n        x2 = self.modelB(xin2)\n        x = torch.cat((x1, x2), dim=1)\n        x = self.classifier(F.relu(x))\n        return x\n\n    \n# efficientNet = EfficientNet.from_name('efficientnet-b7') \n# efficientNet._fc = nn.Linear(in_features=1280, out_features=lable_length)\n\n\nseresnext_model = se_resnext101_32x4d(pretrained='imagenet')\nseresnext_model.last_linear = nn.Linear(in_features=2048, out_features=lable_length, bias=True)\n\n#densenet_model = models.densenet201(pretrained=True)\n#densenet_model.load_state_dict(torch.load( models_dir+\"densenet201-c1103571.pth\"))\n#densenet_model.classifier= nn.Linear(in_features=1920,out_features=lable_length)\n\n#efficientNet = EfficientNet(width_coeff=2.0, depth_coeff=3.1,drop_connect_rate=0.5,num_classes = lable_length)\n\nresnet_model = models.resnet50(pretrained=True)\n#resnet_model.load_state_dict(torch.load(\"../models/resnet50.pth\"))\nresnet_model.fc= nn.Linear(in_features=2048, out_features=lable_length)\n\n#model = Ensemble(seresnext_model, resnet_model,lable_length*2,lable_length)\n#model.to(device)\n\nmodel = seresnext_model\nmodel.to(device)","execution_count":28,"outputs":[{"output_type":"execute_result","execution_count":28,"data":{"text/plain":"SENet(\n  (layer0): Sequential(\n    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n    (relu1): ReLU(inplace)\n    (pool): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n  )\n  (layer1): Sequential(\n    (0): SEResNeXtBottleneck(\n      (conv1): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(256, 16, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(16, 256, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n      (downsample): Sequential(\n        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      )\n    )\n    (1): SEResNeXtBottleneck(\n      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(256, 16, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(16, 256, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (2): SEResNeXtBottleneck(\n      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(256, 16, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(16, 256, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n  )\n  (layer2): Sequential(\n    (0): SEResNeXtBottleneck(\n      (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(32, 512, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n      (downsample): Sequential(\n        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      )\n    )\n    (1): SEResNeXtBottleneck(\n      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(32, 512, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (2): SEResNeXtBottleneck(\n      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(32, 512, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (3): SEResNeXtBottleneck(\n      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(32, 512, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n  )\n  (layer3): Sequential(\n    (0): SEResNeXtBottleneck(\n      (conv1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n      (downsample): Sequential(\n        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      )\n    )\n    (1): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (2): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (3): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (4): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (5): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (6): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (7): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (8): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (9): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (10): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (11): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (12): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (13): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (14): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (15): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (16): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (17): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (18): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (19): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (20): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (21): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (22): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(64, 1024, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n  )\n  (layer4): Sequential(\n    (0): SEResNeXtBottleneck(\n      (conv1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(2048, 128, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(128, 2048, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n      (downsample): Sequential(\n        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      )\n    )\n    (1): SEResNeXtBottleneck(\n      (conv1): Conv2d(2048, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(2048, 128, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(128, 2048, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n    (2): SEResNeXtBottleneck(\n      (conv1): Conv2d(2048, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)\n      (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (conv3): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n      (relu): ReLU(inplace)\n      (se_module): SEModule(\n        (avg_pool): AdaptiveAvgPool2d(output_size=1)\n        (fc1): Conv2d(2048, 128, kernel_size=(1, 1), stride=(1, 1))\n        (relu): ReLU(inplace)\n        (fc2): Conv2d(128, 2048, kernel_size=(1, 1), stride=(1, 1))\n        (sigmoid): Sigmoid()\n      )\n    )\n  )\n  (avg_pool): AvgPool2d(kernel_size=7, stride=1, padding=0)\n  (last_linear): Linear(in_features=2048, out_features=1103, bias=True)\n)"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"def train(epoch,fnum,dloader):\n    model.train()\n    for step, (x,x2,y) in enumerate(dloader):\n        data = Variable(x).cuda()   # batch x\n        #data2 = Variable(x2).cuda()\n        target = Variable(y).cuda()   # batch y\n        #print(data.size())\n        #print(data2.size())\n        #print(target.size())\n        #output = model(data,data2)\n        output = model(data)\n\n        loss = loss_func(output, target.float())   # cross entropy loss\n        optimizer.zero_grad()           # clear gradients for this training step\n        loss.backward()                 # backpropagation, compute gradients\n        optimizer.step()                # apply gradients\n        if step==0:\n            start = time.time()\n            #break\n            ti = 0\n        elif step==100:\n            ti = time.time()-start #total time = ti*(length/100)\n            #print(ti)\n            ti = ti*(len(dloader)/100)\n        if step % 100 == 0:\n            second = ti*(((len(dloader)-step)/len(dloader)))#*(5-epoch)*(4-fnum)\n            print('Train Fold:{}/4  Ep: {}/3 [{}/{} ({:.0f}%)]\\t Loss: {:.6f}\\t Remain : {} '.\n                     format(fnum+1,\n                            epoch+1, \n                            step * len(data), \n                            len(dloader.dataset),\n                            100.*step/len(dloader), \n                            loss.data.item(),\n                            datetime.timedelta(seconds = int(second))))\n        data.cpu()\n        #data2.cpu()\n        target.cpu()\n        torch.cuda.empty_cache()\n    print(\"Finish\")","execution_count":29,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def val(dloader):\n    model.eval()\n    los = []\n    for step, (x,x2, y) in enumerate(dloader):\n        data = Variable(x).cuda()\n        #data2 = Variable(x2).cuda()\n        target = Variable(y).cuda()\n        \n        #output = model(data,data2)\n        output = model(data)\n        \n        loss = loss_func(output, target.float())\n        los.append(loss.item())\n        \n        \n        if step %100 == 0:\n            print('[{}/{} ({:.1f}%)]'.format(step * len(data), \n                                        len(dloader.dataset),\n                                        100.*step/len(dloader)))\n        data.cpu()\n        #data2.cpu()\n        target.cpu()\n        torch.cuda.empty_cache()\n    los = np.array(los)\n    avg_val_loss = los.sum()/len(los)\n    print(f\"Avg val loss: {avg_val_loss:.8f}\")\n    #return ans,out\n    ","execution_count":30,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class FocalLoss(nn.Module):\n    def __init__(self, gamma):\n        super().__init__()\n        self.gamma = gamma\n        \n    def forward(self, input, target):\n        # Inspired by the implementation of binary_cross_entropy_with_logits\n        if not (target.size() == input.size()):\n            raise ValueError(\"Target size ({}) must be the same as input size ({})\".format(target.size(), input.size()))\n\n        max_val = (-input).clamp(min=0)\n        loss = input - input * target + max_val + ((-max_val).exp() + (-input - max_val).exp()).log()\n\n        # This formula gives us the log sigmoid of 1-p if y is 0 and of p if y is 1\n        invprobs = F.logsigmoid(-input * (target * 2 - 1))\n        loss = (invprobs * self.gamma).exp() * loss\n        \n        return loss.mean()","execution_count":31,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fold = KFold(n_splits = 4, random_state = 10)\nfor fold_num, (trn_idx, val_idx) in enumerate(fold.split(datafilter)):\n    Ftrain_dataloader = datafilter[trn_idx, :]\n    Fval_dataloader = datafilter[val_idx, :]\n\n    val_dataloader = DataLoader(trainDataset(Fval_dataloader, data_transforms,data_transforms2),batch_size=32, shuffle=False,num_workers=2, pin_memory=True)\n    train_dataloader = DataLoader(trainDataset(Ftrain_dataloader, data_transforms,data_transforms2),batch_size=32, shuffle=True,num_workers=2, pin_memory=True)\n    for epoch in range(3):\n        ###########################################\n        if epoch==0:\n            optimizer = torch.optim.Adam(model.parameters(), lr=0.0001/(2**epoch))\n        else:\n            optimizer = torch.optim.SGD(model.parameters(), lr=0.0001,momentum=0.9, weight_decay=1e-4)\n        #optimizer = torch.optim.Adam(model.parameters(), lr=0.00002/(2**epoch))\n        #optimizer = torch.optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=1e-4)\n        loss_func = FocalLoss(0.4)\n        #loss_func = torch.nn.MSELoss()\n        ###########################################\n        train(epoch,fold_num,train_dataloader) \n        val(val_dataloader)","execution_count":null,"outputs":[{"output_type":"stream","text":"Train Fold:1/4  Ep: 1/3 [0/81927 (0%)]\t Loss: 0.536362\t Remain : 0:00:00 \n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"torch.cuda.empty_cache()\n!nvidia-smi","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"torch.save(model, 'net.pkl')\n#model = torch.load('net.pkl')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def findPre(output,gate):\n    a = ''\n    output = np.array(output)\n    m = np.max(output)\n\n    for i in range(len(output)):\n        #s = np.where(v[i] > 0.95, 1, 0)\n        if output[i]>gate:\n            #print(output[i])\n            a = a + format(i)+' '\n            \n    #print(a)\n    return a\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def test(model,dloader,threshold):\n    model = model.eval().cuda()\n    #lengthD = len(dloader.dataset)\n    ans = []\n    out = []\n    for step, (x,x2, y) in enumerate(dloader):\n        data = Variable(x).cuda()\n        #data2 = Variable(x2).cuda()\n        #data = Variable(x)\n        target = y\n        #output = model(data,data2)\n        output = model(data).detach()\n        \n        #data.cpu()   # batch x\n        #data2.cpu()   # batch x\n        #target.cpu()   # batch y\n        #torch.cuda.empty_cache()\n        \n        v = output.cpu()\n        v = torch.sigmoid(v)\n        \n        v = torch.sigmoid(v)\n        v = np.array(v)\n        v = preprocessing.minmax_scale(v, feature_range=(0,1),axis=1)\n        for i in range(len(v)):\n            out.append(np.where(v[i] > threshold, 1, 0))\n            s = findPre(v[i],threshold)\n            ans.append([target[i],s])\n        if step %10 == 0:\n            print('[{}/{} ({:.1f}%)]'.format(step * len(data), \n                                        len(dloader.dataset),\n                                        100.*step/len(dloader)))\n            \n        data.cpu()\n        #data2.detach()\n        #target.detach()\n        torch.cuda.empty_cache()\n    print(\"Finish\")\n    return ans,out\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.metrics import fbeta_score\n\ndef makeScore(pre,ans):\n    pre = np.array(pre)\n    va = fbeta_score(y_pred=pre, y_true=ans, beta=2, average=\"samples\")\n    print(\"Score : {:.5f}\".format(va))\n    return va\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def findThreshold():\n    score = []\n    candidates = np.arange(0, 1.0, 0.01)\n    for th in candidates:\n        print(\"Threshold : {:.2f}\".format(th))\n        _,pre = test(model = model,dloader = score_dataloader,threshold = th)\n        #return pre\n        score.append(makeScore(np.array(pre),np.array(train_a[:1000,1].tolist())))\n        print(\"=============================\")\n    pm = np.array(score).argmax()\n    best_th, best_score = candidates[pm], score[pm]\n    return best_th, best_score","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"bt, bs = findThreshold()\nprint(\"Best Threshold : {:.2f}\".format(bt))\nprint(\"Best Score : {:.5f}\".format(bs))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"torch.cuda.empty_cache()\n!nvidia-smi","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sub,_ = test(model = model,dloader = test_dataloader,threshold = bt)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sub =  pd.DataFrame(sub)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sub = sub.rename(index=str, columns={0: \"id\", 1: \"attribute_ids\"})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sub.head","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sub.to_csv('submission.csv', index=False)","execution_count":null,"outputs":[]}],"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.5.2"}},"nbformat":4,"nbformat_minor":1}