code stringlengths 17 6.64M |
|---|
class SelectiveLoadModule(torch.nn.Module):
'Only load layers in trained models with the same name.'
def __init__(self):
super(SelectiveLoadModule, self).__init__()
def forward(self, x):
return x
def load_state_dict(self, state_dict):
'Override the function to ignore redunda... |
class ConvLayer(torch.nn.Module):
'Reflection padded convolution layer.'
def __init__(self, in_channels, out_channels, kernel_size, stride, bias=True):
super(ConvLayer, self).__init__()
reflection_padding = int(np.floor((kernel_size / 2)))
self.reflection_pad = torch.nn.ReflectionPad2... |
class ConvTanh(ConvLayer):
def __init__(self, in_channels, out_channels, kernel_size, stride):
super(ConvTanh, self).__init__(in_channels, out_channels, kernel_size, stride)
self.tanh = torch.nn.Tanh()
def forward(self, x):
out = super(ConvTanh, self).forward(x)
return ((self... |
class ConvInstRelu(ConvLayer):
def __init__(self, in_channels, out_channels, kernel_size, stride):
super(ConvInstRelu, self).__init__(in_channels, out_channels, kernel_size, stride)
self.instance = torch.nn.InstanceNorm2d(out_channels, affine=True)
self.relu = torch.nn.ReLU()
def for... |
class UpsampleConvLayer(torch.nn.Module):
'Upsamples the input and then does a convolution.\n This method gives better results compared to ConvTranspose2d.\n ref: http://distill.pub/2016/deconv-checkerboard/\n '
def __init__(self, in_channels, out_channels, kernel_size, stride, upsample=None):
... |
class UpsampleConvInstRelu(UpsampleConvLayer):
def __init__(self, in_channels, out_channels, kernel_size, stride, upsample=None):
super(UpsampleConvInstRelu, self).__init__(in_channels, out_channels, kernel_size, stride, upsample)
self.instance = torch.nn.InstanceNorm2d(out_channels, affine=True)... |
class ResidualBlock(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1):
super(ResidualBlock, self).__init__()
self.conv1 = ConvLayer(in_channels, out_channels, kernel_size, stride)
self.in1 = torch.nn.InstanceNorm2d(out_channels, affine=True)
... |
class ReCoNet(SelectiveLoadModule):
def __init__(self):
super(ReCoNet, self).__init__()
self.conv1 = ConvInstRelu(3, 32, kernel_size=9, stride=1)
self.conv2 = ConvInstRelu(32, 64, kernel_size=3, stride=2)
self.conv3 = ConvInstRelu(64, 128, kernel_size=3, stride=2)
self.res... |
class BaseModel(object):
def name(self):
return 'BaseModel'
def get_image_paths(self):
pass
def initialize(self, opt):
self.opt = opt
self.gpu_ids = opt.gpu_ids
self.isTrain = opt.isTrain
self.Tensor = (torch.cuda.FloatTensor if self.gpu_ids else torch.Te... |
class CycleGANModel(GANModel):
def name(self):
return 'CycleGANModel'
def initialize(self, opt):
GANModel.initialize(self, opt)
if self.isTrain:
self.criterionCycle = torch.nn.L1Loss()
self.criterionIdt = torch.nn.L1Loss()
def test(self):
self.rea... |
class BaseOptions(object):
def __init__(self):
self.parser = argparse.ArgumentParser()
self.initialized = False
def initialize(self):
self.parser.add_argument('--dataroot', required=True, help='path to images (should have subfolders trainA, trainB, valA, valB, etc)')
self.par... |
class TestOptions(BaseOptions):
def initialize(self):
BaseOptions.initialize(self)
self.parser.add_argument('--ntest', type=int, default=float('inf'), help='# of test examples.')
self.parser.add_argument('--results_dir', type=str, default='./results', help='saves results_cycle here.')
... |
class TrainOptions(BaseOptions):
def initialize(self):
BaseOptions.initialize(self)
self.parser.add_argument('--display_freq', type=int, default=100, help='frequency of showing training results_cycle on screen')
self.parser.add_argument('--print_freq', type=int, default=100, help='frequen... |
class BaseDataLoader(object):
def __init__(self):
pass
def initialize(self, opt):
self.opt = opt
pass
def load_data(self):
return None
|
def CreateDataLoader(opt):
if (opt.align_data > 0):
from cyclegan_arch.data.aligned_data_loader import AlignedDataLoader
data_loader = AlignedDataLoader()
else:
from unaligned_data_loader import UnalignedDataLoader
data_loader = UnalignedDataLoader()
print(data_loader.name(... |
def is_image_file(filename):
return any((filename.endswith(extension) for extension in IMG_EXTENSIONS))
|
def make_dataset(dir):
images = []
assert os.path.isdir(dir), ('%s is not a valid directory' % dir)
for (root, _, fnames) in sorted(os.walk(dir)):
for fname in fnames:
if is_image_file(fname):
path = os.path.join(root, fname)
images.append(path)
retu... |
def default_loader(path):
return Image.open(path).convert('RGB')
|
class ImageFolder(data.Dataset):
def __init__(self, root, transform=None, return_paths=False, loader=default_loader):
imgs = make_dataset(root)
if (len(imgs) == 0):
raise RuntimeError(((('Found 0 images in: ' + root) + '\nSupported image extensions are: ') + ','.join(IMG_EXTENSIONS)))... |
class PairedData(object):
def __init__(self, data_loader_A, data_loader_B, max_dataset_size, flip):
self.data_loader_A = data_loader_A
self.data_loader_B = data_loader_B
self.stop_A = False
self.stop_B = False
self.max_dataset_size = max_dataset_size
self.flip = fl... |
class UnalignedDataLoader(BaseDataLoader):
def initialize(self, opt):
BaseDataLoader.initialize(self, opt)
transformations = [transforms.Scale(opt.loadSize), transforms.RandomCrop(opt.fineSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
transform = tra... |
class DistanceGANModel(CycleGANModel):
def __init__(self, dataset):
super(CycleGANModel, self).__init__()
self.dataset = dataset
def name(self):
return 'DistanceGANModel'
def initialize(self, opt):
CycleGANModel.initialize(self, opt)
self.use_self_distance = opt.... |
class GANModel(BaseModel):
def name(self):
return 'GANModel'
def initialize(self, opt):
BaseModel.initialize(self, opt)
self.A_to_B = opt.A_to_B
self.B_to_A = opt.B_to_A
nb = opt.batchSize
size = opt.fineSize
self.input_A = self.Tensor(nb, opt.input_nc... |
def get_loader(config):
'Builds and returns Dataloader for MNIST and SVHN dataset.'
transform = transforms.Compose([transforms.Scale(config.image_size), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
svhn = datasets.SVHN(root=config.svhn_path, download=True, transform=tran... |
def str2bool(v):
return (v.lower() in 'true')
|
def main(config):
(svhn_loader, mnist_loader, svhn_test_loader, mnist_test_loader) = get_loader(config)
solver = Solver(config, svhn_loader, mnist_loader)
cudnn.benchmark = True
if (not os.path.exists(config.model_path)):
os.makedirs(config.model_path)
if (not os.path.exists(config.sample_... |
def deconv(c_in, c_out, k_size, stride=2, pad=1, bn=True):
'Custom deconvolutional layer for simplicity.'
layers = []
layers.append(nn.ConvTranspose2d(c_in, c_out, k_size, stride, pad, bias=False))
if bn:
layers.append(nn.BatchNorm2d(c_out))
return nn.Sequential(*layers)
|
def conv(c_in, c_out, k_size, stride=2, pad=1, bn=True):
'Custom convolutional layer for simplicity.'
layers = []
layers.append(nn.Conv2d(c_in, c_out, k_size, stride, pad, bias=False))
if bn:
layers.append(nn.BatchNorm2d(c_out))
return nn.Sequential(*layers)
|
class G12(nn.Module):
'Generator for transfering from mnist to svhn'
def __init__(self, conf, conv_dim=64, svhn_input=None):
super(G12, self).__init__()
self.config = conf
self.conv1 = conv(1, conv_dim, 4)
self.conv2 = conv(conv_dim, (conv_dim * 2), 4)
self.conv3 = con... |
class G21(nn.Module):
'Generator for transfering from svhn to mnist'
def __init__(self, conf, conv_dim=64, svhn_input=None):
super(G21, self).__init__()
self.config = conf
self.conv1 = conv(3, conv_dim, 4)
self.conv2 = conv(conv_dim, (conv_dim * 2), 4)
self.conv3 = con... |
class D1(nn.Module):
'Discriminator for mnist.'
def __init__(self, conv_dim=64):
super(D1, self).__init__()
self.conv1 = conv(1, conv_dim, 4, bn=False)
self.conv2 = conv(conv_dim, (conv_dim * 2), 4)
self.conv3 = conv((conv_dim * 2), (conv_dim * 4), 4)
self.fc = conv((c... |
class D2(nn.Module):
'Discriminator for svhn.'
def __init__(self, conv_dim=64):
super(D2, self).__init__()
self.conv1 = conv(3, conv_dim, 4, bn=False)
self.conv2 = conv(conv_dim, (conv_dim * 2), 4)
self.conv3 = conv((conv_dim * 2), (conv_dim * 4), 4)
self.fc = conv((co... |
def create_model(opt, dataset=None):
print(opt.model)
if (opt.model == 'gan'):
from .gan_model import GANModel
model = GANModel()
elif (opt.model == 'cycle_gan'):
from .cycle_gan_model import CycleGANModel
model = CycleGANModel()
elif (opt.model == 'distance_gan'):
... |
def weights_init(m):
classname = m.__class__.__name__
if (classname.find('Conv') != (- 1)):
m.weight.data.normal_(0.0, 0.02)
elif ((classname.find('BatchNorm2d') != (- 1)) or (classname.find('InstanceNorm2d') != (- 1))):
m.weight.data.normal_(1.0, 0.02)
m.bias.data.fill_(0)
|
def get_norm_layer(norm_type):
if (norm_type == 'batch'):
norm_layer = nn.BatchNorm2d
elif (norm_type == 'instance'):
norm_layer = nn.InstanceNorm2d
else:
print(('normalization layer [%s] is not found' % norm))
return norm_layer
|
def define_G(input_nc, output_nc, ngf, which_model_netG, norm='batch', use_dropout=False, gpu_ids=[]):
netG = None
use_gpu = (len(gpu_ids) > 0)
norm_layer = get_norm_layer(norm_type=norm)
if use_gpu:
assert torch.cuda.is_available()
if (which_model_netG == 'resnet_9blocks'):
netG =... |
def define_D(input_nc, ndf, which_model_netD, n_layers_D=3, norm='batch', use_sigmoid=False, gpu_ids=[]):
netD = None
use_gpu = (len(gpu_ids) > 0)
norm_layer = get_norm_layer(norm_type=norm)
if use_gpu:
assert torch.cuda.is_available()
if (which_model_netD == 'basic'):
netD = NLaye... |
def print_network(net):
num_params = 0
for param in net.parameters():
num_params += param.numel()
print(net)
print(('Total number of parameters: %d' % num_params))
|
class GANLoss(nn.Module):
def __init__(self, use_lsgan=True, target_real_label=1.0, target_fake_label=0.0, tensor=torch.FloatTensor):
super(GANLoss, self).__init__()
self.real_label = target_real_label
self.fake_label = target_fake_label
self.real_label_var = None
self.fak... |
class ResnetGenerator(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, gpu_ids=[]):
assert (n_blocks >= 0)
super(ResnetGenerator, self).__init__()
self.input_nc = input_nc
self.output_nc = output_nc
self.... |
class ResnetBlock(nn.Module):
def __init__(self, dim, padding_type, norm_layer, use_dropout):
super(ResnetBlock, self).__init__()
self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout)
def build_conv_block(self, dim, padding_type, norm_layer, use_dropout):
... |
class UnetGenerator(nn.Module):
def __init__(self, input_nc, output_nc, num_downs, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, gpu_ids=[]):
super(UnetGenerator, self).__init__()
self.gpu_ids = gpu_ids
assert (input_nc == output_nc)
unet_block = UnetSkipConnectionBlock((n... |
class UnetSkipConnectionBlock(nn.Module):
def __init__(self, outer_nc, inner_nc, submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False):
super(UnetSkipConnectionBlock, self).__init__()
self.outermost = outermost
downconv = nn.Conv2d(outer_nc, inner... |
class NLayerDiscriminator(nn.Module):
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_sigmoid=False, gpu_ids=[]):
super(NLayerDiscriminator, self).__init__()
self.gpu_ids = gpu_ids
kw = 4
padw = int(np.ceil(((kw - 1) / 2)))
sequence = [nn.Co... |
class HTML():
def __init__(self, web_dir, title, reflesh=0):
self.title = title
self.web_dir = web_dir
self.img_dir = os.path.join(self.web_dir, 'images')
if (not os.path.exists(self.web_dir)):
os.makedirs(self.web_dir)
if (not os.path.exists(self.img_dir)):
... |
class ImagePool():
def __init__(self, pool_size):
self.pool_size = pool_size
if (self.pool_size > 0):
self.num_imgs = 0
self.images = []
def query(self, images):
if (self.pool_size == 0):
return images
return_images = []
for image i... |
def encode(buf, width, height):
' buf: must be bytes or a bytearray in py3, a regular string in py2. formatted RGBRGB... '
assert (((width * height) * 3) == len(buf))
bpp = 3
def raw_data():
row_bytes = (width * bpp)
for row_start in range((((height - 1) * width) * bpp), (- 1), (- row... |
def tensor2im(image_tensor, imtype=np.uint8):
image_numpy = image_tensor[0].cpu().float().numpy()
image_numpy = (((np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0) * 255.0)
return image_numpy.astype(imtype)
|
def diagnose_network(net, name='network'):
mean = 0.0
count = 0
for param in net.parameters():
if (param.grad is not None):
mean += torch.mean(torch.abs(param.grad.data))
count += 1
if (count > 0):
mean = (mean / count)
print(name)
print(mean)
|
def save_image(image_numpy, image_path):
image_pil = Image.fromarray(image_numpy)
image_pil.save(image_path)
|
def info(object, spacing=10, collapse=1):
'Print methods and doc strings.\n Takes module, class, list, dictionary, or string.'
methodList = [e for e in dir(object) if isinstance(getattr(object, e), collections.Callable)]
processFunc = ((collapse and (lambda s: ' '.join(s.split()))) or (lambda s: s))
... |
def varname(p):
for line in inspect.getframeinfo(inspect.currentframe().f_back)[3]:
m = re.search('\\bvarname\\s*\\(\\s*([A-Za-z_][A-Za-z0-9_]*)\\s*\\)', line)
if m:
return m.group(1)
|
def print_numpy(x, val=True, shp=False):
x = x.astype(np.float64)
if shp:
print('shape,', x.shape)
if val:
x = x.flatten()
print(('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % (np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x))))
|
def mkdirs(paths):
if (isinstance(paths, list) and (not isinstance(paths, str))):
for path in paths:
mkdir(path)
else:
mkdir(paths)
|
def mkdir(path):
if (not os.path.exists(path)):
os.makedirs(path)
|
class Visualizer():
def __init__(self, opt):
self.display_id = opt.display_id
self.use_html = (opt.isTrain and (not opt.no_html))
self.win_size = opt.display_winsize
self.name = opt.name
if (self.display_id > 0):
import visdom
self.vis = visdom.Visd... |
class DiscoGANAnglePairing(DiscoGAN):
def get_data(self):
if (self.args.task_name == 'car2car'):
data_A = get_cars(test=False, ver=180, half='first', image_size=self.args.image_size)
data_B = get_cars(test=False, ver=180, half='last', image_size=self.args.image_size)
t... |
class Options(object):
def __init__(self):
self.parser = argparse.ArgumentParser(description='PyTorch implementation of DistanceGAN based on DiscoGAN')
self.initialized = False
def initialize(self):
self.parser.add_argument('--cuda', type=str, default='true', help='Set cuda usage')
... |
class AnglePairingOptions(Options):
def initialize(self):
self.parser.add_argument('--cuda', type=str, default='true', help='Set cuda usage')
self.parser.add_argument('--task_name', type=str, default='car2car', help='Set data name')
self.parser.add_argument('--epoch_size', type=int, defau... |
class DistanceGANAnglePairing(DistanceGAN):
def get_data(self):
if (self.args.task_name == 'car2car'):
data_A = get_cars(test=False, ver=180, half='first', image_size=self.args.image_size)
data_B = get_cars(test=False, ver=180, half='last', image_size=self.args.image_size)
... |
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.conv1 = nn.Conv2d(3, 64, 4, 2, 1, bias=False)
self.relu1 = nn.LeakyReLU(0.2, inplace=True)
self.conv2 = nn.Conv2d(64, (64 * 2), 4, 2, 1, bias=False)
self.bn2 = nn.BatchNorm2d((64... |
class Generator(nn.Module):
def __init__(self, num_layers=4):
super(Generator, self).__init__()
if (num_layers == 5):
self.main = nn.Sequential(nn.Conv2d(3, 64, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(64, (64 * 2), 4, 2, 1, bias=False), nn.BatchNorm2d((64 * 2)... |
def CreateDataLoader(opt):
data_loader = CustomDatasetDataLoader()
print(data_loader.name())
data_loader.initialize(opt)
return data_loader
|
def CreateDataset(opt):
if (opt.dataset_mode == 'aligned'):
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif (opt.dataset_mode == 'unaligned'):
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif (opt.dataset_... |
class CustomDatasetDataLoader(BaseDataLoader):
def name(self):
return 'CustomDatasetDataLoader'
def initialize(self, opt):
BaseDataLoader.initialize(self, opt)
self.dataset = CreateDataset(opt)
self.dataloader = torch.utils.data.DataLoader(self.dataset, batch_size=opt.batchSi... |
class BaseDataLoader():
def __init__(self):
pass
def initialize(self, opt):
self.opt = opt
pass
def load_data(self):
return None
|
class BaseDataset(data.Dataset):
def __init__(self):
super(BaseDataset, self).__init__()
def name(self):
return 'BaseDataset'
def initialize(self, opt):
pass
|
def get_transform(opt):
transform_list = []
if (opt.resize_or_crop == 'resize_and_crop'):
osize = [opt.loadSize, opt.loadSize]
transform_list.append(transforms.Scale(osize, Image.BICUBIC))
transform_list.append(transforms.RandomCrop(opt.fineSize))
elif (opt.resize_or_crop == 'crop'... |
def __scale_width(img, target_width):
(ow, oh) = img.size
if (ow == target_width):
return img
w = target_width
h = int(((target_width * oh) / ow))
return img.resize((w, h), Image.BICUBIC)
|
def is_image_file(filename):
return any((filename.endswith(extension) for extension in IMG_EXTENSIONS))
|
def make_dataset(dir, max_items=(- 1), start=0):
images = []
assert os.path.isdir(dir), ('%s is not a valid directory' % dir)
for (root, _, fnames) in sorted(os.walk(dir)):
for fname in fnames:
if is_image_file(fname):
path = os.path.join(root, fname)
im... |
def default_loader(path):
return Image.open(path).convert('RGB')
|
class ImageFolder(data.Dataset):
def __init__(self, root, transform=None, return_paths=False, loader=default_loader):
imgs = make_dataset(root)
if (len(imgs) == 0):
raise RuntimeError(((('Found 0 images in: ' + root) + '\nSupported image extensions are: ') + ','.join(IMG_EXTENSIONS)))... |
class SingleDataset(BaseDataset):
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_A = os.path.join(opt.dataroot)
self.A_paths = make_dataset(self.dir_A)
self.A_paths = sorted(self.A_paths)
self.transform = get_transform(opt)
def __g... |
class UnalignedDataset(BaseDataset):
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_A = os.path.join(opt.dataroot, (opt.phase + opt.A))
self.dir_B = os.path.join(opt.dataroot, (opt.phase + opt.B))
self.A_paths = make_dataset(self.dir_A, max_ite... |
def get_file_paths(folder):
image_file_paths = []
for (root, dirs, filenames) in os.walk(folder):
filenames = sorted(filenames)
for filename in filenames:
input_path = os.path.abspath(root)
file_path = os.path.join(input_path, filename)
if (filename.endswith... |
def align_images(a_file_paths, b_file_paths, target_path):
if (not os.path.exists(target_path)):
os.makedirs(target_path)
for i in range(len(a_file_paths)):
img_a = Image.open(a_file_paths[i])
img_b = Image.open(b_file_paths[i])
assert (img_a.size == img_b.size)
aligned... |
def create_model(opt):
print(opt.model)
if (opt.model == 'ost'):
assert (opt.dataset_mode == 'unaligned')
from .ost import OSTModel
model = OSTModel()
elif (opt.model == 'autoencoder'):
assert (opt.dataset_mode == 'single')
from .autoencoder_model import AutoEncoder... |
class BaseModel(object):
def name(self):
return 'BaseModel'
def initialize(self, opt):
self.opt = opt
self.gpu_ids = opt.gpu_ids
self.isTrain = opt.isTrain
self.Tensor = (torch.cuda.FloatTensor if self.gpu_ids else torch.Tensor)
self.load_dir = os.path.join(op... |
class pixel_norm(nn.Module):
def forward(self, x, epsilon=1e-08):
return (x * torch.rsqrt((torch.mean(x.pow(2), dim=1, keepdim=True) + epsilon)))
|
def weights_init_normal(m):
classname = m.__class__.__name__
if (classname.find('Conv') != (- 1)):
init.normal(m.weight.data, 0.0, 0.02)
elif (classname.find('Linear') != (- 1)):
init.normal(m.weight.data, 0.0, 0.02)
elif (classname.find('BatchNorm2d') != (- 1)):
init.normal(m.... |
def weights_init_xavier(m):
classname = m.__class__.__name__
if (classname.find('Conv') != (- 1)):
init.xavier_normal(m.weight.data, gain=0.02)
elif (classname.find('Linear') != (- 1)):
init.xavier_normal(m.weight.data, gain=0.02)
elif (classname.find('BatchNorm2d') != (- 1)):
... |
def weights_init_kaiming(m):
classname = m.__class__.__name__
if (classname.find('Conv') != (- 1)):
init.kaiming_normal(m.weight.data, a=0, mode='fan_in')
elif (classname.find('Linear') != (- 1)):
init.kaiming_normal(m.weight.data, a=0, mode='fan_in')
elif (classname.find('BatchNorm2d'... |
def weights_init_orthogonal(m):
classname = m.__class__.__name__
print(classname)
if (classname.find('Conv') != (- 1)):
init.orthogonal(m.weight.data, gain=1)
elif (classname.find('Linear') != (- 1)):
init.orthogonal(m.weight.data, gain=1)
elif (classname.find('BatchNorm2d') != (- ... |
def init_weights(net, init_type='normal'):
print(('initialization method [%s]' % init_type))
if (init_type == 'normal'):
net.apply(weights_init_normal)
elif (init_type == 'xavier'):
net.apply(weights_init_xavier)
elif (init_type == 'kaiming'):
net.apply(weights_init_kaiming)
... |
def get_norm_layer(norm_type='instance'):
if (norm_type == 'batch'):
norm_layer = functools.partial(nn.BatchNorm2d, affine=True)
elif (norm_type == 'instance'):
norm_layer = functools.partial(nn.InstanceNorm2d, affine=False)
elif (norm_type == 'none'):
norm_layer = None
else:
... |
def get_scheduler(optimizer, opt):
if (opt.lr_policy == 'lambda'):
def lambda_rule(epoch):
lr_l = (1.0 - (max(0, (((epoch + 1) + opt.epoch_count) - opt.niter)) / float((opt.niter_decay + 1))))
return lr_l
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)
... |
def define_ED(input_nc, output_nc, ngf, which_model_netG, norm='batch', use_dropout=False, init_type='normal', gpu_ids=[], n_downsampling=2, start=0, end=2, input_layer=True, output_layer=True, n_blocks_encoder=9, n_blocks_decoder=9, start_dec=0, end_dec=1):
use_gpu = (len(gpu_ids) > 0)
norm_layer = get_norm_... |
def define_G(input_nc, output_nc, ngf, which_model_netG, norm='batch', use_dropout=False, init_type='normal', gpu_ids=[]):
netG = None
use_gpu = (len(gpu_ids) > 0)
norm_layer = get_norm_layer(norm_type=norm)
if use_gpu:
assert torch.cuda.is_available()
if (which_model_netG == 'resnet_9bloc... |
def define_D(input_nc, ndf, which_model_netD, n_layers_D=3, norm='batch', use_sigmoid=False, init_type='normal', gpu_ids=[]):
use_gpu = (len(gpu_ids) > 0)
norm_layer = get_norm_layer(norm_type=norm)
if use_gpu:
assert torch.cuda.is_available()
if (which_model_netD == 'basic'):
netD = N... |
def print_network(net):
num_params = 0
for param in net.parameters():
num_params += param.numel()
print(net)
print(('Total number of parameters: %d' % num_params))
|
class GANLoss(nn.Module):
def __init__(self, use_lsgan=True, target_real_label=1.0, target_fake_label=0.0, tensor=torch.FloatTensor):
super(GANLoss, self).__init__()
self.real_label = target_real_label
self.fake_label = target_fake_label
self.real_label_var = None
self.fak... |
class ResnetEncoder(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, gpu_ids=[], padding_type='reflect', n_downsampling=2, start=0, end=2, input_layer=True, n_blocks=6):
assert (n_blocks >= 0)
super(ResnetEncoder, self).__init__()
s... |
class ResnetDecoder(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, gpu_ids=[], padding_type='reflect', n_downsampling=2, start=0, end=2, output_layer=True, n_blocks=6):
assert (n_blocks >= 0)
super(ResnetDecoder, self).__init__()
... |
class ResnetGenerator(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, gpu_ids=[], padding_type='reflect'):
assert (n_blocks >= 0)
super(ResnetGenerator, self).__init__()
self.input_nc = input_nc
self.output_nc =... |
class ResnetBlock(nn.Module):
def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):
super(ResnetBlock, self).__init__()
self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias)
def build_conv_block(self, dim, padding_type, norm_layer, ... |
class UnetGenerator(nn.Module):
def __init__(self, input_nc, output_nc, num_downs, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, gpu_ids=[]):
super(UnetGenerator, self).__init__()
self.gpu_ids = gpu_ids
unet_block = UnetSkipConnectionBlock((ngf * 8), (ngf * 8), input_nc=None, subm... |
class UnetSkipConnectionBlock(nn.Module):
def __init__(self, outer_nc, inner_nc, input_nc=None, submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False):
super(UnetSkipConnectionBlock, self).__init__()
self.outermost = outermost
if (type(norm_layer) ... |
class NLayerDiscriminator(nn.Module):
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_sigmoid=False, gpu_ids=[]):
super(NLayerDiscriminator, self).__init__()
self.gpu_ids = gpu_ids
if (type(norm_layer) == functools.partial):
use_bias = (norm_lay... |
class PixelDiscriminator(nn.Module):
def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d, use_sigmoid=False, gpu_ids=[]):
super(PixelDiscriminator, self).__init__()
self.gpu_ids = gpu_ids
if (type(norm_layer) == functools.partial):
use_bias = (norm_layer.func == nn.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.