def __init__(self, args, depth=3):
super(Submodel, self).__init__()
self.args = args
self.depth = depth
input_channel = 4
if self.args.add_noise:
input_channel = 5
channel = 64 / args.submodel_div
print('dalong log : check channel in SubModel ={}'.format(channel))
self.BayerMosaic = layers.BayerMosaicLayer(args.bayer_type)
self.Crop = layers.CropLayer()
self.layer1 = OrderedDict()
self.pack_layer = layers.PackBayerMosaicLayer(args.bayer_type)
for index in range(depth):
in_channel = 64
out_channel = 64
if index == 0:
in_channel = input_channel
if index == depth - 1:
out_channel = 12
self.layer1['layer_{}'.format(index)] = nn.Sequential(
nn.Conv2d(in_channel, out_channel, kernel_size=3, padding=1),
nn.LeakyReLU(negative_slope=0.2),
)
self.layer1 = nn.Sequential(self.layer1)
self.postLayer1 = nn.Sequential(
nn.ConvTranspose2d(12, 3, kernel_size=2, stride=2, groups=3),
nn.LeakyReLU(negative_slope=0.2))
self.postLayer2 = nn.Sequential(
nn.Conv2d(6, 3, kernel_size=3, padding=1),
nn.LeakyReLU(negative_slope=0.2),
nn.Conv2d(3, 3, kernel_size=3, padding=1),
)
self.init_params()
def __init__(self, weight=1.0, normalize=True):
super(VGGLoss, self).__init__()
self.normalize = normalize;
self.weight = weight
vgg = tmodels.vgg16(pretrained=True).features
slices_idx = [
[0, 4],
[4, 9],
[9, 16],
[16, 23],
[23, 30],
]
self.net = torch.nn.Sequential()
for i, idx in enumerate(slices_idx):
seq = torch.nn.Sequential()
for j in range(idx[0], idx[1]):
seq.add_module(str(j), vgg[j])
self.net.add_module(str(i), seq)
for p in self.parameters():
p.requires_grad = False
self.mse = nn.MSELoss()
self.CropLayer = layers.CropLayer();
def __init__(self, args):
super(FastDenoisaicking, self).__init__()
self.pack = layers.PackBayerMosaicLayer(args.bayer_type, pack_depth=1)
self.GMpreprocess = layers.GMPreprocess()
self.RBpreprocess = layers.RBPreprocess()
self.Lpreprocess = layers.LPreprocess()
self.crop = layers.CropLayer()
self.down_layer1 = nn.Sequential(
nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1),
nn.LeakyReLU(negative_slope=0.2),
nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
nn.LeakyReLU(negative_slope=0.2),
)
self.down_layer2 = nn.Sequential(
nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
nn.LeakyReLU(negative_slope=0.2),
nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
nn.LeakyReLU(negative_slope=0.2),
)
self.down_layer3 = nn.Sequential(
nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
nn.LeakyReLU(negative_slope=0.2),
nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
)
self.pool = nn.AdaptiveAvgPool2d(1)
self.fc1 = nn.Sequential(
nn.Linear(512, 512),
nn.LeakyReLU(negative_slope=0.2),
)
self.h2a = nn.Linear(512, 23**2)
self.h2b = nn.Linear(512, 23**2)
self.h1 = nn.Linear(512, 23**2)
self.init_params()
def __init__(self, args):
super(BayerNetwork, self).__init__()
self.mosaic_mask = layers.BayerMosaicLayer(bayer_type=args.bayer_type)
self.crop_like = layers.CropLayer()
self.depth = args.depth
self.width = args.width
layers1 = OrderedDict([
("pack_mosaic", nn.Conv2d(3, 4, 2, stride=2)
), # Downsample 2x2 to re-establish translation invariance
])
for i in range(self.depth):
n_out = self.width
n_in = self.width
if i == 0:
n_in = 4
if i == self.depth - 1:
n_out = 2 * self.width
layers1["conv{}".format(i + 1)] = nn.Conv2d(n_in, n_out, 3)
layers1["relu{}".format(i + 1)] = nn.ReLU(inplace=True)
self.main_processor = nn.Sequential(layers1)
self.residual_predictor = nn.Conv2d(self.width, 12, 1)
self.upsampler = nn.ConvTranspose2d(12, 3, 2, stride=2, groups=3)
self.fullres_processor = nn.Sequential(
OrderedDict([
("post_conv", nn.Conv2d(6, self.width, 3)),
("post_relu", nn.ReLU(inplace=True)),
("output", nn.Conv2d(self.width, 3, 1)),
]))
self.init_params()
def __init__(self,pixel_weight = 1,percep_weight = 1):
super(pixel_perceptural_loss,self).__init__();
self.pixel_weight = pixel_weight;
self.percep_weight = percep_weight;
self.pixel = nn.L1Loss();
self.percep = VGGLoss();
self.CropLayer = layers.CropLayer();
def __init__(self,
depth,
channel,
ksize,
pad=0,
batchnorm=True,
bayer_type='GRBG'):
super(DemosaicNet, self).__init__()
self.bayer_type = bayer_type
# Pack the input to 4D inputs
self.packmosaic = layers.PackBayerMosaicLayer()
# conv_block
self.preconv = layers.lowlevel_block(1, 4, channel, ksize, pad,
batchnorm)
self.block1 = layers.lowlevel_block(depth - 2, channel, channel, ksize,
pad, batchnorm)
self.conv15 = layers.lowlevel_block(1,
channel,
12,
ksize,
pad=0,
batchnorm=batchnorm)
# unpack the residul array to original inputs
self.unpack = layers.UnpackBayerMosaicLayer()
# original Mosaic array for 3 channels
self.mosaic_mask = layers.BayerMosaicLayer(bayer_type=self.bayer_type)
# crop the input with regard to reference
self.crop_layer = layers.CropLayer()
# full resolution convolution
self.fullres_conv1 = layers.lowlevel_block(1, 6, channel, ksize, pad,
batchnorm)
self.fullres_conv2 = nn.Conv2d(channel,
3,
kernel_size=1,
stride=1,
padding=pad)
# init the parameters
self.init_params()
def __init__(self):
super(L2Loss,self).__init__();
self.pixel_loss = torch.nn.MSELoss();
self.perceptural_loss = 0;
self.CropLayer = layers.CropLayer();
def __init__(self): super(PSNR, self).__init__() self.mse = nn.MSELoss() self.CropLayer = layers.CropLayer();