Esempio n. 1
0
 def input_transform(self, crop_size):
     return Compose([
         CenterCrop(crop_size),
         Resize(crop_size // self.upscale_factor),
         ToTensor(),
     ])
def main():
    import argparse
    import json
    import os
    params = {}
    params['num_workers'] = 6
    params['learning_rate'] = 1e-6
    params['momentum'] = 0.9
    params['weight_decay'] = 0.0005
    params['gamma'] = 0.1
    params['step_size'] = 3
    params['num_classes'] = 2
    params['epochs'] = 50
    params['batch_size'] = 4
    params['patience'] = 20
    params['test_size'] = 0.2
    params['image_dir'] = '/home/ktdiedrich/data/lung-xray/CXR_pngs'
    params['mask_dir'] = '/home/ktdiedrich/data/lung-xray/masks'
    params['output_dir'] = '/home/ktdiedrich/output/lung-xray/models2'
    params['checkpoint_epochs'] = 5
    parser = argparse.ArgumentParser(description='Detect objects')
    parser.add_argument("--output_dir",
                        "-o",
                        type=str,
                        help="output directory [{}]".format(
                            params['output_dir']),
                        default=params['output_dir'])
    parser.add_argument('--image_dir',
                        "-i",
                        type=str,
                        help='images [{}]'.format(params['image_dir']),
                        default=params['image_dir'])
    parser.add_argument('--mask_dir',
                        "-M",
                        type=str,
                        help='masks of training objects [{}]'.format(
                            params['mask_dir']),
                        default=params['mask_dir'])
    parser.add_argument("--num_workers",
                        '-w',
                        type=int,
                        action='store',
                        default=params['num_workers'],
                        help="worker threads, default {}".format(
                            params['num_workers']))
    parser.add_argument("--num_classes",
                        '-c',
                        type=int,
                        action='store',
                        default=params['num_classes'],
                        help="classes [{}]".format(params['num_classes']))
    args = parser.parse_args()

    params['image_dir'] = args.image_dir
    params['mask_dir'] = args.mask_dir
    params['output_dir'] = args.output_dir
    params['num_workers'] = args.num_workers
    params['num_classes'] = args.num_classes

    if not os.path.exists(params['output_dir']):
        os.makedirs(params['output_dir'])

    with open(os.path.join(params['output_dir'], 'params.json'), 'w') as fp:
        json.dump(params, fp)

    transform_train = Compose(
        [Resize([h, w]),
         ToTensor(), Normalize(mean=mean, std=std)])

    transform_val = Compose(
        [Resize([h, w]),
         ToTensor(), Normalize(mean=mean, std=std)])

    mask_transform = Compose([Resize([h, w]), ToTensor()])

    train_ds_full = SegmentationDataset(path2img=params['image_dir'],
                                        path2masks=params['mask_dir'],
                                        transform=transform_train,
                                        mask_transform=mask_transform)

    val_ds_full = SegmentationDataset(path2img=params['image_dir'],
                                      path2masks=params['mask_dir'],
                                      transform=transform_val,
                                      mask_transform=mask_transform)

    sss = ShuffleSplit(n_splits=1,
                       test_size=params['test_size'],
                       random_state=0)

    indices = range(len(train_ds_full))

    for train_index, val_index in sss.split(indices):
        print("train = {}".format(len(train_index)))
        print("-" * 10)
        print("valid = {}".format(len(val_index)))

    train_ds = Subset(train_ds_full, train_index)
    print("Train data subset = {}".format(len(train_ds)))

    val_ds = Subset(val_ds_full, val_index)
    print("Valid data subset = {}".format(len(val_ds)))

    train_dl = DataLoader(train_ds,
                          batch_size=params['batch_size'],
                          shuffle=True,
                          collate_fn=collate_fn,
                          num_workers=params['num_workers'])
    val_dl = DataLoader(val_ds,
                        batch_size=params['batch_size'],
                        shuffle=False,
                        collate_fn=collate_fn,
                        num_workers=params['num_workers'])
    model = deeplabv3_resnet50(pretrained=False,
                               num_classes=params['num_classes'])
    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    model = model.to(device)
    # ## Define Loss Function
    criterion = nn.CrossEntropyLoss(reduction="sum")
    # ## Optimizer
    opt = optim.Adam(model.parameters(), lr=params['learning_rate'])
    lr_scheduler = ReduceLROnPlateau(opt,
                                     mode='min',
                                     factor=0.5,
                                     patience=params['patience'],
                                     verbose=1)
    current_lr = get_lr(opt)
    print('current lr={}'.format(current_lr))

    path2models = os.path.join(params['output_dir'])
    if not os.path.exists(path2models):
        os.makedirs(path2models)

    params_train = {
        "num_epochs": params['epochs'],
        "optimizer": opt,
        "loss_func": criterion,
        "train_dl": train_dl,
        "val_dl": val_dl,
        "output_dir": params['output_dir'],
        "checkpoint_epochs": params['checkpoint_epochs'],
        "lr_scheduler": lr_scheduler,
        "path2weights": os.path.join(path2models, "weights.pt")
    }

    model, loss_hist, _ = train_val(model, params_train, device)

    num_epochs = params_train["num_epochs"]

    plot_loss(loss_hist=loss_hist,
              num_epochs=num_epochs,
              output_dir=params['output_dir'])
from folder2lmdb import ImageFolderLMDB
from torch.utils.data import DataLoader
from torchvision.transforms import Resize

if __name__ == "__main__":
    transform = Resize((224, 224))
    path = "/home/jiang/share/dataset/imagenet/train.lmdb"
    dataset = ImageFolderLMDB(path, transform)
    data_loader = DataLoader(dataset, batch_size=256, num_workers=10)
    for img, label in data_loader:
        # pass
        print(img.shape)
        print(label.shape)
Esempio n. 4
0
import random

import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision.datasets.mnist import MNIST
from torchvision.transforms import Compose, Resize, ToTensor, CenterCrop

from einops import rearrange

from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

MNIST_TRANSFORM = Compose((CenterCrop((16, 16)), Resize(4, 4), ToTensor()))

X, y = next(
    iter(
        DataLoader(
            MNIST(
                "/mnt/hdd_1tb/datasets/mnist/dataset_source",
                train=True,
                download=False,
                transform=MNIST_TRANSFORM,
            ),
            shuffle=True,
            batch_size=60000,
        )))
X = rearrange(X, "b () h w -> b (h w)").numpy()
train_size = 50000
X_train = X[:train_size]
y_train = y[:train_size]
Esempio n. 5
0
if args.model == 'resnet':
    model = model.segmentNetwork().cuda()
    resize_dim = (400, 400)
    convert_to = 'L'
elif args.model == 'unet11':
    model = unet11(out_filters=3).cuda()
    resize_dim = (224, 224)
    convert_to = 'RGB'
elif args.model == 'unet16':
    model = unet16(out_filters=3).cuda()
    resize_dim = (224, 224)
    convert_to = 'RGB'

if args.no_normalize:
    transforms = Compose([Resize(resize_dim),ToTensor()])
else:
    transforms = Compose([Resize(resize_dim),ToTensor(),normalize])
convert_to = 'RGB'

if args.input_type == 'dicom':
    dataset = iap.DicomSegment(args.img_path, transforms, convert_to)
elif args.input_type == 'png' and args.non_montgomery:
    dataset = iap.LungTest(args.img_path, transforms, convert_to)
elif args.input_type == 'png':
    dataset = iap.lungSegmentDataset(
        os.path.join(args.img_path, "CXR_png"),
        os.path.join(args.img_path, "ManualMask/leftMask/"),
        os.path.join(args.img_path, "ManualMask/rightMask/"),
        imagetransform=transforms,
        labeltransform=Compose([Resize((224, 224)),ToTensor()]),
Esempio n. 6
0
    def __init__(self, mode, roidb_file=VG_SGG_FN, dict_file=VG_SGG_DICT_FN,
                 image_file=IM_DATA_FN, filter_empty_rels=True, num_im=-1, num_val_im=5000,
                 filter_duplicate_rels=True, filter_non_overlap=True,
                 use_proposals=False):
        """
        Torch dataset for VisualGenome
        :param mode: Must be train, test, or val
        :param roidb_file:  HDF5 containing the GT boxes, classes, and relationships
        :param dict_file: JSON Contains mapping of classes/relationships to words
        :param image_file: HDF5 containing image filenames
        :param filter_empty_rels: True if we filter out images without relationships between
                             boxes. One might want to set this to false if training a detector.
        :param filter_duplicate_rels: Whenever we see a duplicate relationship we'll sample instead
        :param num_im: Number of images in the entire dataset. -1 for all images.
        :param num_val_im: Number of images in the validation set (must be less than num_im
               unless num_im is -1.)
        :param proposal_file: If None, we don't provide proposals. Otherwise file for where we get RPN
            proposals
        """
        if mode not in ('test', 'train', 'val'):
            raise ValueError("Mode must be in test, train, or val. Supplied {}".format(mode))
        self.mode = mode

        # Initialize
        self.roidb_file = roidb_file
        self.dict_file = dict_file
        self.image_file = image_file
        self.filter_non_overlap = filter_non_overlap
        self.filter_duplicate_rels = filter_duplicate_rels and self.mode == 'train'

        self.split_mask, self.gt_boxes, self.gt_classes, self.relationships = load_graphs_one_shot(
            self.roidb_file, self.mode, num_im, num_val_im=num_val_im,
            filter_empty_rels=filter_empty_rels,
            filter_non_overlap=self.filter_non_overlap and self.is_train,
        )

        self.filenames = load_image_filenames(image_file)
        self.filenames = [self.filenames[i] for i in np.where(self.split_mask)[0]]

        self.ind_to_classes, self.ind_to_predicates = load_info(dict_file)

        if use_proposals:
            print("Loading proposals", flush=True)
            p_h5 = h5py.File(PROPOSAL_FN, 'r')
            rpn_rois = p_h5['rpn_rois']
            rpn_scores = p_h5['rpn_scores']
            rpn_im_to_roi_idx = np.array(p_h5['im_to_roi_idx'][self.split_mask])
            rpn_num_rois = np.array(p_h5['num_rois'][self.split_mask])

            self.rpn_rois = []
            for i in range(len(self.filenames)):
                rpn_i = np.column_stack((
                    rpn_scores[rpn_im_to_roi_idx[i]:rpn_im_to_roi_idx[i] + rpn_num_rois[i]],
                    rpn_rois[rpn_im_to_roi_idx[i]:rpn_im_to_roi_idx[i] + rpn_num_rois[i]],
                ))
                self.rpn_rois.append(rpn_i)
        else:
            self.rpn_rois = None

        # You could add data augmentation here. But we didn't.
        # tform = []
        # if self.is_train:
        #     tform.append(RandomOrder([
        #         Grayscale(),
        #         Brightness(),
        #         Contrast(),
        #         Sharpness(),
        #         Hue(),
        #     ]))

        tform = [
            SquarePad(),
            Resize(IM_SCALE),
            ToTensor(),
            Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
        ]
        self.transform_pipeline = Compose(tform)
Esempio n. 7
0
        'normal', 'calcified densities', 'nodule', 'fibrotic band',
        'volume loss', 'pneumothorax', 'infiltrates', 'atelectasis',
        'pleural thickening', 'pleural effusion',
        'costophrenic angle blunting', 'cardiomegaly', 'aortic elongation',
        'mediastinal enlargement', 'mass', 'thoracic cage deformation',
        'fracture', 'hemidiaphragm elevation'
    ]
    radiographic_findings_opacity = ['opacity']
    locations_labels = [
        'loc left', 'loc right', 'loc upper', 'loc middle', 'loc lower',
        'loc pleural', 'loc mediastinum'
    ]

    # Transforms
    transforms_train = transforms.Compose([
        Resize(512),
        RandomHorizontalFlip(),
        RandomRotation(10),
        ToTensor(),
        Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
    transforms_train_loc = transforms.Compose([
        Resize_loc(512),
        RandomHorizontalFlip_loc(),
        RandomRotation_loc(10),
        ToTensor_loc(),
        Normalize_loc(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])

    transforms_test = transforms.Compose([
        Resize(512),
Esempio n. 8
0
    # Construct dataset variables
    image_resolution = (300, 300)

    # Construct training dataset and loader
    train_transform = Compose([
        Lambda(maybe_blur),
        Lambda(maybe_darken_a_lot),
        Lambda(maybe_rotate),
        Lambda(maybe_random_perspective),
        Lambda(maybe_random_crop),
        Lambda(maybe_random_erase),
        ColorJitter(brightness=(.1, .8),
                    contrast=.05,
                    saturation=.05,
                    hue=.005),
        Resize(image_resolution),
        Grayscale(num_output_channels=3),
        ToTensor(),
        Normalize((.5, .5, .5), (.5, .5, .5))
    ])
    train_dataset = UsageBasedDataset(train_root,
                                      usage=150,
                                      transform=train_transform)
    train_loader = DataLoader(train_dataset,
                              batch_size=8,
                              shuffle=True,
                              pin_memory=True,
                              drop_last=True,
                              num_workers=4)

    # Construct evaluation transformation
Esempio n. 9
0
        plt.plot(trainErrsTotal, '-', label="train total", color=(0.5, 0, 0.8))

        #plt.plot( testErrsTotal, '-', label = "test total", color = (0.5,0.8,0) )

        plt.yscale('log')
        plt.grid(True)
        plt.legend()
        plt.savefig("./errors")

    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                     std=[0.229, 0.224, 0.225])
    img_size = (224, 224)
    composed = Compose([
        ToPILImage(),
        Resize(img_size),
        RandomHorizontalFlip(),
        RandomGrayscale(p=0.5),
        RandomRotation(degrees=30, center=None),
        ToTensor(), normalize
    ])

    train_dataset = HumpbackWhaleDataset(csv_file='./train.csv',
                                         root_dir="./train",
                                         transform=composed)
    #test_dataset = TitanicDataset(csvFile = 'test.csv')

    train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                               batch_size=100,
                                               shuffle=True,
                                               num_workers=4)
Esempio n. 10
0
 def observation(self, observation):
     transforms = Compose([Resize(self.shape), Normalize(0, 255)])
     observation = transforms(observation).squeeze(0)
     return observation
Esempio n. 11
0
def main():
    # batch_size = 100
    batch_size = 1
    print("here")
    sk_root = '../256x256/sketch/tx_000000000000'
    sk_root = '../256x256/photo/tx_000000000000'
    sk_root ='../test_pair/sketch'
    in_size = 225
    in_size = 224
    train_dataset = DataSet.ImageDataset(sk_root, transform=Compose([Resize(in_size), ToTensor()]))
    train_dataloader = DataLoader(train_dataset, batch_size=batch_size, pin_memory=True, num_workers=os.cpu_count(),
                         shuffle=True, drop_last=True)

    test_dataset = DataSet.ImageDataset(sk_root, transform=Compose([Resize(in_size), ToTensor()]),train=False)
    test_dataloader = DataLoader(test_dataset, batch_size=batch_size, pin_memory=True, num_workers=os.cpu_count(),
                         shuffle=True, drop_last=True)

    num_class = len(train_dataset.classes)
    embed_size = -1
    model = getResnet(num_class=num_class, pretrain=True)
    model.train()
    if torch.cuda.is_available():
        model = model.cuda()
    
    crit = torch.nn.CrossEntropyLoss()
    optim = torch.optim.Adam(model.parameters())
    # optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
    # Tensorboard stuff
    # writer = tb.SummaryWriter('./logs')



    count = 0
    epochs = 2
    prints_interval = 1
    max_chpt = 3
    max_acu = -1
    chpt_num = 0
    activation = {}
    def get_activation(name):
        def hook(model, input, output):
            activation[name] = output

        return hook


    model.avgpool.register_forward_hook(get_activation('avgpool'))
    for e in range(epochs):
        print('epoch',e,'started')
        avg_loss = 0
        for i, (X, Y) in enumerate(train_dataloader):

            activation = {}




            if torch.cuda.is_available():
                X, Y = X.cuda(), Y.cuda()

            optim.zero_grad()
            to_image = transforms.ToPILImage()
            output = model(X)
            print(activation['avgpool'].shape)
            loss = crit(output, Y)
            avg_loss += loss.item()
            if i == 0:
                print(loss)
            if i % prints_interval == 0:
                print(f'[Training] {i}/{e}/{epochs} -> Loss: {avg_loss/(i+1)}')
                # writer.add_scalar('train-loss', loss.item(), count)
            loss.backward()

            optim.step()

            count += 1
        print('epoch',e,'loss',avg_loss/len(train_dataloader))
        correct, total, accuracy= 0, 0, 0
        # model.eval()
        for i, (X, Y) in enumerate(test_dataloader):

            if torch.cuda.is_available():
                X, Y = X.cuda(), Y.cuda()
            output = model(X)
            _, predicted = torch.max(output, 1)
            total += Y.size(0)
            correct += (predicted == Y).sum().item()


        accuracy = (correct / total) * 100

        print(f'[Testing] -/{e}/{epochs} -> Accuracy: {accuracy} %',total,correct)
        # model.train()
        if accuracy >= max_acu:
            path = 'checkpoint'+str(chpt_num)+'.pt'
            max_acu = accuracy
            chpt_num= (chpt_num+1)%max_chpt
            set_checkpoint(epoch=e,model=model,optimizer=optim,train_loss=avg_loss/len(train_dataloader),accurate=accuracy,path=path)
            path = 'best.pt'
            set_checkpoint(epoch=e,model=model,optimizer=optim,train_loss=avg_loss/len(train_dataloader),accurate=accuracy,path=path)
Esempio n. 12
0
            #64*4,8,8 => 64*8,4,4
            Conv2d(config.DISCRIMINATOR_FEATURES_NUM * 4, config.DISCRIMINATOR_FEATURES_NUM * 8,
                   kernel_size=4, stride=2, padding=1, bias=False),
            BatchNorm2d(config.DISCRIMINATOR_FEATURES_NUM * 8),
            LeakyReLU(0.2, inplace=True),

            Conv2d(config.DISCRIMINATOR_FEATURES_NUM * 8, 1, kernel_size=4, stride=1, padding=0, bias=False),
            Sigmoid()
        )
    def forward(self, input):
        return self.mainNetwork(input).view(-1)

if PHRASE == "TRAIN":
    transforms = Compose([
        Resize(config.IMAGE_SIZE),
        CenterCrop(config.IMAGE_SIZE),
        ToTensor(),
        Normalize((0.5,0.5,0.5), (0.5,0.5,0.5))
    ])
    dataset = ImageFolder(config.DATA_PATH, transform=transforms)
    dataLoader = DataLoader(dataset=dataset, batch_size=config.BATCH_SIZE,
                            shuffle=True,num_workers=config.NUM_WORKERS_LOAD_IMAGE,
                            drop_last=True)
    netG, netD = DataParallel(GeneratorNet()), DataParallel(DiscriminatorNet())
    map_location = lambda storage, loc: storage

    optimizer_generator = Adam(netG.parameters(), config.LR_GENERATOR, betas=(config.BETA1, 0.999))
    optimizer_discriminator = Adam(netD.parameters(), config.LR_DISCRIMINATOR,betas=(config.BETA1, 0.999))

    criterion = BCELoss()
Esempio n. 13
0
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision.transforms import Compose, CenterCrop, Normalize, Resize
from torchvision.transforms import ToTensor, ToPILImage

from dataset import cityscapes
from erfnet import ERFNet
from transform import Relabel, ToLabel, Colorize
from iouEval import iouEval, getColorEntry

NUM_CHANNELS = 3
NUM_CLASSES = 20

image_transform = ToPILImage()
input_transform_cityscapes = Compose([
    Resize(512, Image.BILINEAR),
    ToTensor(),
])
target_transform_cityscapes = Compose([
    Resize(512, Image.NEAREST),
    ToLabel(),
    Relabel(255, 19),  #ignore label to 19
])


def main(args):

    modelpath = args.loadDir + args.loadModel
    weightspath = args.loadDir + args.loadWeights

    print("Loading model: " + modelpath)
Esempio n. 14
0
def input_transform(crop_size, upscale_factor):
    return Compose([
        CenterCrop(crop_size),
        Resize(crop_size // upscale_factor, interpolation=Image.BICUBIC)
    ])
Esempio n. 15
0
            test_dataset=test_set,
            n_experiences=n_experiences,
            task_labels=False,
            per_exp_classes=per_exp_classes,
            seed=seed,
            fixed_class_order=fixed_class_order,
            shuffle=shuffle,
            train_transform=train_transform,
            eval_transform=eval_transform,
        )


def _get_cub200_dataset(root):
    train_set = CUB200(root, train=True)
    test_set = CUB200(root, train=False)

    return train_set, test_set


__all__ = ["SplitCUB200"]

if __name__ == "__main__":
    import sys

    benchmark_instance = SplitCUB200(5,
                                     train_transform=Compose(
                                         [ToTensor(),
                                          Resize((128, 128))]))
    check_vision_benchmark(benchmark_instance, show_without_transforms=False)
    sys.exit(0)
Esempio n. 16
0
NetD = Discriminator()
BCE_LOSS = BCELoss()
G_optimizer = Adam(NetG.parameters(),
                   lr=CONFIG["LEARNING_RATE"],
                   betas=(0.5, 0.999))
D_optimizer = Adam(NetD.parameters(),
                   lr=CONFIG["LEARNING_RATE"],
                   betas=(0.5, 0.999))

if CONFIG["GPU_NUMS"] > 0:
    NetG = NetG.cuda()
    NetD = NetD.cuda()
    BCE_LOSS = BCE_LOSS.cuda()

transform = Compose([
    Resize((CONFIG["IMAGE_SIZE"], CONFIG["IMAGE_SIZE"])),
    ToTensor(),
    Normalize(mean=[0.5] * 3, std=[0.5] * 3)
])
train_loader = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
    root=CONFIG["DATA_PATH"], transform=transform),
                                           batch_size=CONFIG["BATCH_SIZE"],
                                           shuffle=True)


def one_hot(target):
    y = torch.zeros(target.size()[0], 10)

    for i in range(target.size()[0]):
        y[i, target[i]] = 1
import os
import inspect
from functools import partial
from hyperseg.datasets.cityscapes import CityscapesDataset
from torchvision.transforms import Resize
from hyperseg.test import main

if __name__ == '__main__':
    project_dir = os.path.dirname(inspect.getabsfile(main))
    exp_name = os.path.splitext(os.path.basename(__file__))[
        0]  # Make sure the config and model have the same base name
    exp_dir = os.path.join('tests', exp_name)
    model = os.path.join('weights', exp_name + '.pth')
    data_dir = 'data/cityscapes'  # Download from: https://www.cityscapes-dataset.com
    test_dataset = partial(CityscapesDataset, data_dir, 'val', 'fine',
                           'semantic')
    img_transforms = [Resize([768, 1536])]

    os.chdir(project_dir)
    os.makedirs(exp_dir, exist_ok=True)
    main(exp_dir,
         model=model,
         test_dataset=test_dataset,
         img_transforms=img_transforms,
         forced=True)
Esempio n. 18
0
siamese_net = SiameseNet(emb_net)
clsf_net = ResidualNetwork(emb_net=emb_net, nb_classes=15)
assert id(emb_net) == id(siamese_net.emb_net)
assert id(emb_net) == id(clsf_net.emb_net)

# Dataset
from utils.datasets import DeepFashionDataset
from torchvision.transforms import Compose
from torchvision.transforms import Resize
from torchvision.transforms import ToTensor
from torchvision.transforms import Normalize
from config.deep_fashion import DeepFashionConfig as cfg
from torch.utils.data import DataLoader
from utils.datasets import Siamesize
trans = Compose([
    Resize(cfg.sizes),
    ToTensor(),
    Normalize(cfg.mean, cfg.std),
])
# dataset
train_ds = DeepFashionDataset(cfg.root_dir, 'train', transform=trans)
val_ds = DeepFashionDataset(cfg.root_dir, 'val', transform=trans)
siamese_train_ds = Siamesize(train_ds)
# loader
loader_kwargs = {
    'pin_memory': True,
    'batch_size': 100,
    'num_workers': 4,
}
s_train_loader = DataLoader(siamese_train_ds, **loader_kwargs)
train_loader = DataLoader(val_ds, **loader_kwargs)
Esempio n. 19
0
def create_image_dataloader(batch_size, target_image_size, data_location):
    target_dimensions = (target_image_size, target_image_size)
    transformations = Compose([Resize(target_dimensions), ToTensor()])
    image_folder = ImageFolder(root=data_location, transform=transformations)
    return DataLoader(image_folder, batch_size=batch_size, shuffle=True)
def get_transform(target_size=224):
    return Compose([
        Resize((target_size, target_size)),
        ToTensor(),
        Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
Esempio n. 21
0
def train_lr_transform(crop_size, upscale_factor):
    return Compose([
        ToPILImage(),
        Resize(crop_size // upscale_factor, interpolation=Image.BICUBIC),
        ToTensor()
    ])
Esempio n. 22
0
def display_transform():
    return Compose([ToPILImage(), Resize(448), CenterCrop(448), ToTensor()])
Esempio n. 23
0
    def __init__(self, opt, val=False):
        super(CustomImageNet1K, self).__init__()
        dir_dataset = os.path.join(opt.path_ImageNet, "Val" if val else "Train")
       
        #list_dir = sorted(glob(os.path.join(dir_dataset, '*')))
       
        #self.list_input = [] #sorted(glob(os.path.join(dir_dataset, 'val' if val else 'train', '*'))) #.JPEG')))
        #for dir in list_dir:
        #    self.list_input.extend(glob(os.path.join(dir_dataset, dir, "*.JPEG")))
        self.list_input = sorted(glob(os.path.join(dir_dataset, "*.JPEG")))
        assert len(self.list_input) > 0, "Please check the path of dataset. Current path is set as {}".format(dir_dataset)
        if val:
            # path_label = "/mnt/home/gishin/training_WNID2class.txt"
            path_label = opt.path_label_val
            dict_WNID2label = dict()
#            with open(path_label, 'r') as txt_file:
#                csv_file = reader(txt_file, delimiter=',')
#                print(csv_file)
#                for i, row in enumerate(csv_file):
                    
#                    if i != 0:
#                        if int(row[1]) - 1 == 1000:
#                            break
#                        dict_WNID2label.update({row[0]: int(row[1]) - 1})  # -1 is for making the label start from 0.
                    
#                    else:
#                        pass
#            self.label = dict_WNID2label
            # print(len(self.list_input))
#            path_label = os.path.join("/mnt/home/gishin/ILSVRC2012_validation_ground_truth.txt")
            
            label = list()
            with open(path_label, 'r') as txt_file:
                for i, row in enumerate(txt_file):
                    dict_WNID2label.update({i: int(row) - 1})
                    # label.append(int(row) - 1)
            self.label = dict_WNID2label

            self.transform = Compose([Resize(256),
                                      CenterCrop(224),
                                      ToTensor(),
                                      Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])

        else:
            # path_label = "/mnt/home/gishin/training_WNID2class.txt"
            path_label = opt.path_label_train
            dict_WNID2label = dict()
            with open(path_label, 'r') as txt_file:
                csv_file = reader(txt_file, delimiter=',')
                for i, row in enumerate(csv_file):
                    if i != 0:
                        if int(row[1]) - 1 == 1000:
                            break
                        dict_WNID2label.update({row[0]: int(row[1]) - 1})  # -1 is for making the label start from 0.
                        
                    else:
                        pass
            self.label = dict_WNID2label

            self.transform = Compose([RandomResizedCrop(224),
                                      RandomHorizontalFlip(),
                                      ToTensor(),
                                      Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
        self.val = val
Esempio n. 24
0
def load(name: str,
         device: Union[str, torch.device] = "cuda"
         if torch.cuda.is_available() else "cpu",
         jit=True,
         pretrained=True,
         model_path=None):
    if name not in _MODELS:
        raise RuntimeError(
            f"Model {name} not found; available models = {available_models()}")

    if not model_path:
        model_path = _download(_MODELS[name])

    model = torch.jit.load(model_path,
                           map_location=device if jit else "cpu").eval()
    n_px = model.input_resolution.item()

    transform = Compose([
        Resize(n_px, interpolation=Image.BICUBIC),
        CenterCrop(n_px),
        lambda image: image.convert("RGB"),
        ToTensor(),
        Normalize((0.48145466, 0.4578275, 0.40821073),
                  (0.26862954, 0.26130258, 0.27577711)),
    ])

    if not jit:
        model = build_model(model.state_dict(), pretrained).to(device)
        return model, transform

    # patch the device names
    device_holder = torch.jit.trace(
        lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
    device_node = [
        n for n in device_holder.graph.findAllNodes("prim::Constant")
        if "Device" in repr(n)
    ][-1]

    def patch_device(module):
        graphs = [module.graph] if hasattr(module, "graph") else []
        if hasattr(module, "forward1"):
            graphs.append(module.forward1.graph)

        for graph in graphs:
            for node in graph.findAllNodes("prim::Constant"):
                if "value" in node.attributeNames() and str(
                        node["value"]).startswith("cuda"):
                    node.copyAttributes(device_node)

    model.apply(patch_device)
    patch_device(model.encode_image)
    patch_device(model.encode_text)

    # patch dtype to float32 on CPU
    if device == "cpu":
        float_holder = torch.jit.trace(lambda: torch.ones([]).float(),
                                       example_inputs=[])
        float_input = list(float_holder.graph.findNode("aten::to").inputs())[1]
        float_node = float_input.node()

        def patch_float(module):
            graphs = [module.graph] if hasattr(module, "graph") else []
            if hasattr(module, "forward1"):
                graphs.append(module.forward1.graph)

            for graph in graphs:
                for node in graph.findAllNodes("aten::to"):
                    inputs = list(node.inputs())
                    for i in [
                            1, 2
                    ]:  # dtype can be the second or third argument to aten::to()
                        if inputs[i].node()["value"] == 5:
                            inputs[i].node().copyAttributes(float_node)

        model.apply(patch_float)
        patch_float(model.encode_image)
        patch_float(model.encode_text)

        model.float()

    return model, transform
Esempio n. 25
0
        self.sigma = sigma

    def forward(self, tensor):
        kernel_size = int(
            randrange(self.kernel_size[0] - 1, self.kernel_size[1])) * 2 + 1
        return gaussian_blur(
            tensor, (kernel_size, kernel_size),
            [torch.empty(1).uniform_(self.sigma[0], self.sigma[1]).item()])

    def __repr__(self):
        return self.__class__.__name__ + f"(kernel_size={self.kernel_size}, sigma={self.sigma})"


clean_transform = Compose(
    [Grayscale(),
     Resize((90, 90)),
     ToTensor(),
     Normalize((0.5), (0.5))])

noise_transform = Compose([
    Grayscale(),
    Resize((90, 90)),
    RandomApply(RandomAffine(degrees=(-20, 20), fillcolor=255)),
    RandomApply(RandomAffine(degrees=0, scale=(0.85, 1.15), fillcolor=255)),
    RandomApply(RandomAffine(degrees=0, translate=(0.1, 0.1), fillcolor=255)),
    RandomApply(ColorJitter(brightness=0.1, )),
    ToTensor(),
    RandomApply(RandomGaussianNoise()),
    RandomApply(RandomGaussianBlur(kernel_size=(1, 5))),
    Normalize((0.5), (0.5))
])
Esempio n. 26
0
def forward_hook(module, inputs, outputs):
    print('%s input shape: %s, output shape: %s' %
          (module.name, repr(inputs[0].shape), repr(outputs[0].shape)))


def backward_hook(module, grad_in, grad_out):
    print('in %s backward hook' % module.name)


if __name__ == '__main__':
    model = resnet18()
    model.cuda()

    dataset = CIFAR100('../../data/',
                       train=True,
                       transform=Compose([Resize((224, 224)),
                                          ToTensor()]))
    loader = DataLoader(dataset)

    x, y = next(iter(loader))
    x = x.to(0)

    from tacklebox.hook_management import HookManager
    hookmngr = HookManager()

    hookmngr.register_forward_hook(forward_hook,
                                   conv=model.conv1,
                                   activate=False)
    hookmngr.register_forward_pre_hook(pre_hook, model.conv1, activate=False)
    hookmngr.register_backward_hook(backward_hook, model.conv1)
Esempio n. 27
0
from utils.common import load_yaml

Modular = False
###
if Modular:
    # Modularity and Abstract
    from PIL import Image
    from torchvision.transforms import Compose, CenterCrop, Normalize, Resize
    from torchvision.transforms import ToTensor, ToPILImage
    from eval.erfnet import ERFNet
    from eval.transform import Relabel, Colorize
    NUM_CLASSES = 20

    image_transform = ToPILImage()
    input_transform_cityscapes = Compose([
        Resize((160, 384), Image.BILINEAR),
        ToTensor(),
        #Normalize([.485, .456, .406], [.229, .224, .225]),
    ])

    cityscapes_trainIds2labelIds = Compose([
        Relabel(19, 255),
        Relabel(18, 33),
        Relabel(17, 32),
        Relabel(16, 31),
        Relabel(15, 28),
        Relabel(14, 27),
        Relabel(13, 26),
        Relabel(12, 25),
        Relabel(11, 24),
        Relabel(10, 23),
Esempio n. 28
0
    HR = 'E:/pngs_cut20/gt'  # (3840, 2160)  3840/960 = 2160/540 = 4
    L_files = glob.glob(os.path.join(LR, "*"))
    H_files = glob.glob(os.path.join(HR, "*"))
    # L_files = L_files[0:100]   #####################
    # H_files = H_files[0:100]   #####################

    L_files = np.array(L_files)
    H_files = np.array(H_files)
    train_val_scale = 0.95
    train_L = L_files[0:int(len(L_files) * train_val_scale)]
    train_H = H_files[0:int(len(H_files) * train_val_scale)]
    val_L = L_files[int(len(L_files) * train_val_scale):]
    val_H = H_files[int(len(H_files) * train_val_scale):]
    print(len(train_L),len(val_L))
    train_set = DatasetFromFolder(train_L, train_H, input_transform=Compose(
        [Resize((216, 384), interpolation=Image.BICUBIC), transforms.ToTensor()]),
                                  target_transform=transforms.ToTensor())
    val_set = DatasetFromFolder(val_L, val_H, input_transform=Compose(
        [Resize((216, 384), interpolation=Image.BICUBIC), transforms.ToTensor()]),
                                target_transform=transforms.ToTensor())
    train_loader = DataLoader(dataset=train_set, num_workers=num_workers, batch_size=BATCH_SIZE, drop_last=True,shuffle=True)
    val_loader = DataLoader(dataset=val_set, num_workers=num_workers, batch_size=BATCH_SIZE, drop_last=True,shuffle=False)

    #准备模型
    seed = random.randint(1, 10000)
    torch.manual_seed(seed)
    if cuda:
        torch.cuda.manual_seed(seed)
    cudnn.benchmark = True

    model = VDSR()
Esempio n. 29
0
def main(args):
    normalize = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    transform = Compose([Resize(256), CenterCrop(224), ToTensor(), normalize])

    dataset = ImageDataset(args.image_folder,
                           transform=transform,
                           return_paths=True)
    # n_images = len(dataset)
    dataloader = DataLoader(dataset,
                            shuffle=False,
                            batch_size=args.batch_size,
                            pin_memory=True,
                            num_workers=0)

    model = models.resnet50(pretrained=True).to(args.device)
    model.eval()

    config = tf.ConfigProto(intra_op_parallelism_threads=1,
                            inter_op_parallelism_threads=1,
                            allow_soft_placement=True,
                            device_count={'CPU': 1})
    sess = tf.Session(config=config)
    x_op = tf.placeholder(tf.float32, shape=(
        None,
        3,
        224,
        224,
    ))

    tf_model = convert_pytorch_model_to_tf(model, args.device)
    cleverhans_model = CallableModelWrapper(tf_model, output_layer='logits')

    # compute clip_min and clip_max suing a full black and a full white image
    clip_min = normalize(torch.zeros(3, 1, 1)).min().item()
    clip_max = normalize(torch.ones(3, 1, 1)).max().item()

    eps = args.eps / 255.
    eps_iter = 20
    nb_iter = 10
    args.ord = np.inf if args.ord < 0 else args.ord
    grad_params = {'eps': eps, 'ord': args.ord}
    common_params = {'clip_min': clip_min, 'clip_max': clip_max}
    iter_params = {'eps_iter': eps_iter / 255., 'nb_iter': nb_iter}

    attack_name = ''
    if args.attack == 'fgsm':
        attack_name = '_L{}_eps{}'.format(args.ord, args.eps)
        attack_op = FastGradientMethod(cleverhans_model, sess=sess)
        attack_params = {**common_params, **grad_params}
    elif args.attack == 'iter':
        attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps,
                                                     eps_iter, nb_iter)
        attack_op = BasicIterativeMethod(cleverhans_model, sess=sess)
        attack_params = {**common_params, **grad_params, **iter_params}
    elif args.attack == 'm-iter':
        attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps,
                                                     eps_iter, nb_iter)
        attack_op = MomentumIterativeMethod(cleverhans_model, sess=sess)
        attack_params = {**common_params, **grad_params, **iter_params}
    elif args.attack == 'pgd':
        attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps,
                                                     eps_iter, nb_iter)
        attack_op = MadryEtAl(cleverhans_model, sess=sess)
        attack_params = {**common_params, **grad_params, **iter_params}
    elif args.attack == 'jsma':
        attack_op = SaliencyMapMethod(cleverhans_model, sess=sess)
        attack_params = {'theta': eps, 'symbolic_impl': False, **common_params}
    elif args.attack == 'deepfool':
        attack_op = DeepFool(cleverhans_model, sess=sess)
        attack_params = common_params
    elif args.attack == 'cw':
        attack_op = CarliniWagnerL2(cleverhans_model, sess=sess)
        attack_params = common_params
    elif args.attack == 'lbfgs':
        attack_op = LBFGS(cleverhans_model, sess=sess)
        target = np.zeros((1, 1000))
        target[0, np.random.randint(1000)] = 1
        y = tf.placeholder(tf.float32, target.shape)
        attack_params = {'y_target': y, **common_params}

    attack_name = args.attack + attack_name

    print('Running [{}]. Params: {}'.format(args.attack.upper(),
                                            attack_params))

    adv_x_op = attack_op.generate(x_op, **attack_params)
    adv_preds_op = tf_model(adv_x_op)
    preds_op = tf_model(x_op)

    n_success = 0
    n_processed = 0
    progress = tqdm(dataloader)
    for paths, x in progress:

        progress.set_description('ATTACK')

        z, adv_x, adv_z = sess.run([preds_op, adv_x_op, adv_preds_op],
                                   feed_dict={
                                       x_op: x,
                                       y: target
                                   })

        src, dst = np.argmax(z, axis=1), np.argmax(adv_z, axis=1)
        success = src != dst
        success_paths = np.array(paths)[success]
        success_adv_x = adv_x[success]
        success_src = src[success]
        success_dst = dst[success]

        n_success += success_adv_x.shape[0]
        n_processed += x.shape[0]

        progress.set_postfix(
            {'Success': '{:3.2%}'.format(n_success / n_processed)})
        progress.set_description('SAVING')

        for p, a, s, d in zip(success_paths, success_adv_x, success_src,
                              success_dst):
            path = '{}_{}_src{}_dst{}.npz'.format(p, attack_name, s, d)
            path = os.path.join(args.out_folder, path)
            np.savez_compressed(path, img=a)
Esempio n. 30
0
BCE_LOSS = BCELoss()
if CONFIG["GPU_NUMS"] > 0:
    Net_D.cuda()
    Net_G.cuda()
    BCE_LOSS = BCE_LOSS.cuda()
G_optimizer = Adam(Net_G.parameters(),
                   lr=CONFIG["LEARNING_RATE"],
                   betas=CONFIG["BETAS"])
D_optimizer = Adam(Net_D.parameters(),
                   lr=CONFIG["LEARNING_RATE"],
                   betas=CONFIG["BETAS"])
'''
数据读入与预处理
'''
transforms = Compose([
    Resize(CONFIG["IMAGE_SIZE"]),
    CenterCrop(CONFIG["IMAGE_SIZE"]),
    ToTensor(),
    Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

dataset = ImageFolder(root='/input/Faces/Eyeglasses', transform=transforms)
train_loader = torch.utils.data.DataLoader(dataset,
                                           batch_size=CONFIG["BATCH_SIZE"],
                                           shuffle=True)


def one_hot(target):
    y = torch.zeros(target.size()[0], 10)

    for i in range(target.size()[0]):