load_options.dataroot, "train",
        torchvision.transforms.Compose([
            torchvision.transforms.Resize(opt.sizex, Image.NEAREST),
            torchvision.transforms.CenterCrop(opt.sizex),
            torchvision.transforms.ToTensor(),
        ]))
if opt.dataset == 'flowers':
    dataset = datasets.FlowersDataset(
        load_options.dataroot, "train",
        torchvision.transforms.Compose([
            torchvision.transforms.Resize(opt.sizex, Image.NEAREST),
            torchvision.transforms.CenterCrop(opt.sizex),
            torchvision.transforms.ToTensor(),
        ]))
if opt.dataset == 'cmnist':
    dataset = datasets.CMNISTDataset(dataPath=load_options.dataroot,
                                     sets='train')

loader = torch.utils.data.DataLoader(dataset,
                                     batch_size=load_options.batch_size,
                                     shuffle=True)
xData, mData = next(iter(loader))
xData = xData.to(device)
mData = mData.to(device)

## Use the same z for all images in batch: ##
# z = torch.randn(1, opt.nMasks, opt.nz, 1, 1).repeat(batch_size, 1, 1, 1, 1).to(device)

## or use different z: ##
z = torch.randn(load_options.batch_size, opt.nMasks, opt.nz, 1, 1).to(device)

with torch.no_grad():
예제 #2
0
                                                           transforms.ToTensor(),
                                       ]))
    testset = datasets.FlowersDataset(opt.dataroot,
                                      "test",
                                      transforms.Compose([transforms.Resize(opt.sizex, Image.NEAREST),
                                                          transforms.CenterCrop(opt.sizex),
                                                          transforms.ToTensor(),
                                      ]))
    valset = datasets.FlowersDataset(opt.dataroot,
                                     "val",
                                     transforms.Compose([transforms.Resize(opt.sizex, Image.NEAREST),
                                                         transforms.CenterCrop(opt.sizex),
                                                         transforms.ToTensor(),
                                     ]))
if opt.dataset == 'cmnist':
    trainset = datasets.CMNISTDataset(dataPath=opt.dataroot,
                                      sets='train')
    testset = datasets.CMNISTDataset(dataPath=opt.dataroot,
                                     sets='test')
    valset = datasets.CMNISTDataset(dataPath=opt.dataroot,
                                    sets='val')

trainloader = torch.utils.data.DataLoader(trainset, batch_size=opt.batchSize, shuffle=True, num_workers=4, drop_last=True)
       
def weights_init_ortho(m):
    if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d) or isinstance(m, nn.Linear):
        nn.init.orthogonal_(m.weight, opt.initOrthoGain)
        
netEncM = models._netEncM(sizex=opt.sizex, nIn=opt.nx, nMasks=opt.nMasks, nRes=opt.nResM, nf=opt.nfM, temperature=opt.temperature).to(device)
netGenX = models._netGenX(sizex=opt.sizex, nOut=opt.nx, nc=opt.nz, nf=opt.nfX, nMasks=opt.nMasks, selfAtt=opt.useSelfAttG).to(device)
netDX = models._resDiscriminator128(nIn=opt.nx, nf=opt.nfD, selfAtt=opt.useSelfAttD).to(device)
예제 #3
0
파일: train.py 프로젝트: jizongFox/ReDO
            transforms.Resize(opt.sizex, Image.NEAREST),
            transforms.CenterCrop(opt.sizex),
            transforms.ToTensor(),
        ]),
    )
    valset = datasets.FlowersDataset(
        opt.dataroot,
        "val",
        transforms.Compose([
            transforms.Resize(opt.sizex, Image.NEAREST),
            transforms.CenterCrop(opt.sizex),
            transforms.ToTensor(),
        ]),
    )
if opt.dataset == "cmnist":
    trainset = datasets.CMNISTDataset(dataPath=opt.dataroot, sets="train")
    testset = datasets.CMNISTDataset(dataPath=opt.dataroot, sets="test")
    valset = datasets.CMNISTDataset(dataPath=opt.dataroot, sets="val")

trainloader = torch.utils.data.DataLoader(trainset,
                                          batch_size=opt.batchSize,
                                          shuffle=True,
                                          num_workers=4,
                                          drop_last=True)


def weights_init_ortho(m):
    if (isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d)
            or isinstance(m, nn.Linear)):
        nn.init.orthogonal_(m.weight, opt.initOrthoGain)