update codes

Author: guyuchao

.idea/gan.iml

@@ -0,0 +1,9 @@
+import numpy as np
+from sklearn.metrics import precision_recall_curve
+import os
+class Criterion:
+    def precision_recall(self,dst,epoch,ytrue,ypred):
+        precision, recall, thresholds = precision_recall_curve(ytrue, ypred)
+        np.save(os.path.join(dst,"P%s"%epoch),precision)
+        np.save(os.path.join(dst, "R%s" % epoch), recall)
+        np.save(os.path.join(dst, "T%s" % epoch), thresholds)

.idea/misc.xml

@@ -0,0 +1,113 @@
+import os
+import os.path as osp
+import numpy as np
+from PIL import Image
+from gycutils.gycaug import ColorAug,Add_Gaussion_noise,Random_horizontal_flip,Random_vertical_flip,Compose_imglabel,Random_crop
+import collections
+import torch
+import torchvision
+from transform import ReLabel, ToLabel, Scale
+from torch.utils import data
+from transform import HorizontalFlip, VerticalFlip
+from torchvision.transforms import Compose
+from torchvision.transforms import Compose, CenterCrop, Normalize, ToTensor
+
+def default_loader(path):
+    return Image.open(path)
+
+class VOCDataSet(data.Dataset):
+    def __init__(self, root, split="train", img_transform=None, label_transform=None,image_label_transform=None):
+        self.root = root
+        self.split = split
+        # self.mean_bgr = np.array([104.00698793, 116.66876762, 122.67891434])
+        self.files = collections.defaultdict(list)
+        self.img_transform = img_transform
+        self.label_transform = label_transform
+        self.image_label_transform=image_label_transform
+        self.h_flip = HorizontalFlip()
+        self.v_flip = VerticalFlip()
+
+        data_dir = osp.join(root, "eyedata",split)
+        # for split in ["train", "trainval", "val"]:
+        imgsets_dir = osp.join(data_dir,  "img")
+        for name in os.listdir(imgsets_dir):
+            name = os.path.splitext(name)[0]
+            img_file = osp.join(data_dir, "img/%s.tif" % name)
+            label_file = osp.join(data_dir, "label/%s.gif" % name)
+            self.files[split].append({
+                "img": img_file,
+                "label": label_file
+            })
+
+    def __len__(self):
+        return len(self.files[self.split])
+
+    def __getitem__(self, index):
+        datafiles = self.files[self.split][index]
+
+        img_file = datafiles["img"]
+        img = Image.open(img_file).convert('RGB')
+        # img = img.resize((256, 256), Image.NEAREST)
+        # img = np.array(img, dtype=np.uint8)
+
+        label_file = datafiles["label"]
+        label = Image.open(label_file).convert("P")
+        #label_size = label.size
+        # label image has categorical value, not continuous, so we have to
+        # use NEAREST not BILINEAR
+        # label = label.resize((256, 256), Image.NEAREST)
+        # label = np.array(label, dtype=np.uint8)
+        # label[label == 255] = 21
+
+        if self.image_label_transform is not None:
+            img,label=self.image_label_transform(img,label)
+
+        if self.img_transform is not None:
+            imgs= self.img_transform(img)
+            # img_h = self.img_transform(self.h_flip(img))
+            # img_v = self.img_transform(self.v_flip(img))
+
+            #imgs = [img_o]
+
+        #else:
+            #imgs = img
+
+        if self.label_transform is not None:
+            labels= self.label_transform(label)
+            # label_h = self.label_transform(self.h_flip(label))
+            # label_v = self.label_transform(self.v_flip(label))
+            #labels = [label_o]
+        #else:
+            #labels = label
+        return imgs, labels
+
+if __name__ == '__main__':
+
+    input_transform = Compose([
+        ColorAug(),
+        Add_Gaussion_noise(prob=0.5),
+        #Scale((512, 512), Image.BILINEAR),
+        ToTensor(),
+        Normalize([.485, .456, .406], [.229, .224, .225]),
+
+    ])
+    target_transform = Compose([
+        #Scale((512, 512), Image.NEAREST),
+        #ToSP(512),
+        ToLabel(),
+        ReLabel(255, 1),
+    ])
+
+    img_label_transform = Compose_imglabel([
+        Random_crop(512,512),
+        Random_horizontal_flip(0.5),
+        Random_vertical_flip(0.5),
+    ])
+    dst = VOCDataSet("./", img_transform=input_transform,label_transform=target_transform,image_label_transform=img_label_transform)
+    trainloader = data.DataLoader(dst, batch_size=1)
+
+    for i, data in enumerate(trainloader):
+        imgs, labels = data
+
+
+

.idea/modules.xml

@@ -0,0 +1,125 @@
+from torch import nn
+from torchvision import models
+import torch.nn.functional as F
+import torch
+
+
+class block(nn.Module):
+    def __init__(self,in_filters,n_filters):
+        super(block,self).__init__()
+        self.deconv1 = nn.Sequential(
+            nn.Conv2d(in_filters, n_filters, 3, stride=1, padding=1),
+            nn.BatchNorm2d(n_filters),
+            nn.ReLU())
+    def forward(self, x):
+        x=self.deconv1(x)
+        return x
+
+class generator(nn.Module):
+    # initializers
+    def __init__(self, n_filters=32):
+        super(generator, self).__init__()
+        self.down1=nn.Sequential(
+            block(3,n_filters),
+            block(n_filters,n_filters),
+            nn.MaxPool2d((2,2)))
+        self.down2 = nn.Sequential(
+            block(n_filters, 2*n_filters),
+            block(2*n_filters, 2*n_filters),
+            nn.MaxPool2d((2, 2)))
+        self.down3 = nn.Sequential(
+            block(2*n_filters, 4*n_filters),
+            block(4*n_filters, 4*n_filters),
+            nn.MaxPool2d((2, 2)))
+        self.down4 = nn.Sequential(
+            block(4*n_filters, 8 * n_filters),
+            block(8 * n_filters, 8 * n_filters),
+            nn.MaxPool2d((2, 2)))
+        self.down5 = nn.Sequential(
+            block(8 * n_filters, 16 * n_filters),
+            block(16 * n_filters, 16 * n_filters))
+
+        self.up1=nn.Sequential(
+            block(16 * n_filters+8*n_filters, 8 * n_filters),
+            block(8 * n_filters, 8 * n_filters))
+        self.up2 = nn.Sequential(
+            block(8 * n_filters+4*n_filters, 4 * n_filters),
+            block(4 * n_filters, 4 * n_filters))
+        self.up3 = nn.Sequential(
+            block(4 * n_filters+2*n_filters,2 * n_filters),
+            block(2 * n_filters, 2 * n_filters))
+        self.up4 = nn.Sequential(
+            block(2 * n_filters+n_filters,  n_filters),
+            block( n_filters,  n_filters))
+
+        self.out=nn.Sequential(
+            nn.Conv2d(n_filters,1,kernel_size=1)
+        )
+    # forward method
+    def forward(self, x):
+        #print(x.size())
+        x1=self.down1(x)
+        #print(x1.size())
+        x2=self.down2(x1)
+        #print(x2.size())
+        x3 = self.down3(x2)
+        #print(x3.size())
+        x4 = self.down4(x3)
+        #print(x4.size())
+        x5 = self.down5(x4)
+        #print(x5.size())
+        x = self.up1(F.upsample(torch.cat((x4,x5),dim=1),scale_factor=2))
+        x = self.up2(F.upsample(torch.cat((x, x3), dim=1), scale_factor=2))
+        x = self.up3(F.upsample(torch.cat((x, x2), dim=1), scale_factor=2))
+        x = self.up4(F.upsample(torch.cat((x, x1), dim=1), scale_factor=2))
+        x=F.sigmoid(self.out(x))
+        return x#b,1,w,h
+
+class discriminator(nn.Module):
+    def __init__(self,n_filters):
+        super(discriminator,self).__init__()
+        self.down1 = nn.Sequential(
+            block(4, n_filters),
+            block(n_filters, n_filters),
+            nn.MaxPool2d((2, 2)))
+        self.down2 = nn.Sequential(
+            block(n_filters, 2 * n_filters),
+            block(2 * n_filters, 2 * n_filters),
+            nn.MaxPool2d((2, 2)))
+        self.down3 = nn.Sequential(
+            block(2 * n_filters, 4 * n_filters),
+            block(4 * n_filters, 4 * n_filters),
+            nn.MaxPool2d((2, 2)))
+        self.down4 = nn.Sequential(
+            block(4 * n_filters, 8 * n_filters),
+            block(8 * n_filters, 8 * n_filters),
+            nn.MaxPool2d((2, 2)))
+        self.down5 = nn.Sequential(
+            block(8 * n_filters, 16 * n_filters),
+            block(16 * n_filters, 16 * n_filters))
+        self.out = nn.Linear(16*n_filters,1)
+    def forward(self, x):
+        x=self.down1(x)
+        #print(x.size())
+        x = self.down2(x)
+        #print(x.size())
+        x = self.down3(x)
+        #print(x.size())
+        x = self.down4(x)
+        #print(x.size())
+        x = self.down5(x)
+        #print(x.size())
+        x=F.avg_pool2d(x, kernel_size=x.size()[2:]).view(x.size()[0], -1)
+
+
+        x=self.out(x)
+        x = F.sigmoid(x)
+        #print(x.size())
+        return x#b,1
+
+
+if __name__=='__main__':
+    from torch.nn.functional import Variable
+    D=discriminator(32).cuda()
+    t=Variable(torch.ones((2,4,512,512)).cuda())
+    print(D(t).size())