added thesis

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/*
+Scripts/*
+Include/*
+Lib/*
+logs/*
+WiggleGAN_mod.py
+WiggleGAN_noCycle.py

WiggleGAN.py

@@ -0,0 +1,833 @@
+import utils, torch, time, os, pickle
+import numpy as np
+import torch.nn as nn
+import torch.cuda as cu
+import torch.optim as optim
+import pickle
+from torchvision import transforms
+from torchvision.utils import save_image
+from utils import augmentData, RGBtoL, LtoRGB
+from PIL import Image
+from dataloader import dataloader
+from torch.autograd import Variable
+import matplotlib.pyplot as plt
+import random
+from datetime import date
+from statistics import mean
+from architectures import depth_generator_UNet, \
+    depth_discriminator_noclass_UNet
+
+
+class WiggleGAN(object):
+    def __init__(self, args):
+        # parameters
+        self.epoch = args.epoch
+        self.sample_num = 100
+        self.nCameras = args.cameras
+        self.batch_size = args.batch_size
+        self.save_dir = args.save_dir
+        self.result_dir = args.result_dir
+        self.dataset = args.dataset
+        self.log_dir = args.log_dir
+        self.gpu_mode = args.gpu_mode
+        self.model_name = args.gan_type
+        self.input_size = args.input_size
+        self.class_num = (args.cameras - 1) * 2  # un calculo que hice en paint
+        self.sample_num = self.class_num ** 2
+        self.imageDim = args.imageDim
+        self.epochVentaja = args.epochV
+        self.cantImages = args.cIm
+        self.visdom = args.visdom
+        self.lambdaL1 = args.lambdaL1
+        self.depth = args.depth
+        self.name_wiggle = args.name_wiggle
+
+        self.clipping = args.clipping
+        self.WGAN = False
+        if (self.clipping > 0):
+            self.WGAN = True
+
+        self.seed = str(random.randint(0, 99999))
+        self.seed_load = args.seedLoad
+        self.toLoad = False
+        if (self.seed_load != "-0000"):
+            self.toLoad = True
+
+        self.zGenFactor = args.zGF
+        self.zDisFactor = args.zDF
+        self.bFactor = args.bF
+        self.CR = False
+        if (self.zGenFactor > 0 or self.zDisFactor > 0 or self.bFactor > 0):
+            self.CR = True
+
+        self.expandGen = args.expandGen
+        self.expandDis = args.expandDis
+
+        self.wiggleDepth = args.wiggleDepth
+        self.wiggle = False
+        if (self.wiggleDepth > 0):
+            self.wiggle = True
+
+
+
+        # load dataset
+
+        self.onlyGen = args.lrD <= 0 
+
+        if not self.wiggle:
+            self.data_loader = dataloader(self.dataset, self.input_size, self.batch_size, self.imageDim, split='train',
+                                      trans=not self.CR)
+
+            self.data_Validation = dataloader(self.dataset, self.input_size, self.batch_size, self.imageDim,
+                                          split='validation')
+
+            self.dataprint = self.data_Validation.__iter__().__next__()
+
+            data = self.data_loader.__iter__().__next__().get('x_im')
+
+
+            if not self.onlyGen:
+              self.D = depth_discriminator_noclass_UNet(input_dim=3, output_dim=1, input_shape=data.shape,
+                                                        class_num=self.class_num,
+                                                        expand_net=self.expandDis, depth = self.depth, wgan = self.WGAN)
+              self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2))
+
+        self.data_Test = dataloader(self.dataset, self.input_size, self.batch_size, self.imageDim, split='test')
+        self.dataprint_test = self.data_Test.__iter__().__next__()
+
+        # networks init
+
+        self.G = depth_generator_UNet(input_dim=4, output_dim=3, class_num=self.class_num, expand_net=self.expandGen, depth = self.depth)
+        self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2))
+
+
+        if self.gpu_mode:
+            self.G.cuda()
+            if not self.wiggle and not self.onlyGen:
+                self.D.cuda()
+            self.BCE_loss = nn.BCELoss().cuda()
+            self.CE_loss = nn.CrossEntropyLoss().cuda()
+            self.L1 = nn.L1Loss().cuda()
+            self.MSE = nn.MSELoss().cuda()
+            self.BCEWithLogitsLoss = nn.BCEWithLogitsLoss().cuda()
+        else:
+            self.BCE_loss = nn.BCELoss()
+            self.CE_loss = nn.CrossEntropyLoss()
+            self.MSE = nn.MSELoss()
+            self.L1 = nn.L1Loss()
+            self.BCEWithLogitsLoss = nn.BCEWithLogitsLoss()
+
+        print('---------- Networks architecture -------------')
+        utils.print_network(self.G)
+        if not self.wiggle and not self.onlyGen:
+            utils.print_network(self.D)
+        print('-----------------------------------------------')
+
+        temp = torch.zeros((self.class_num, 1))
+        for i in range(self.class_num):
+            temp[i, 0] = i
+
+        temp_y = torch.zeros((self.sample_num, 1))
+        for i in range(self.class_num):
+            temp_y[i * self.class_num: (i + 1) * self.class_num] = temp
+
+        self.sample_y_ = torch.zeros((self.sample_num, self.class_num)).scatter_(1, temp_y.type(torch.LongTensor), 1)
+        if self.gpu_mode:
+             self.sample_y_ = self.sample_y_.cuda()
+
+        if (self.toLoad):
+            self.load()
+
+    def train(self):
+
+        if self.visdom:
+            random.seed(time.time())
+            today = date.today()
+
+            vis = utils.VisdomLinePlotter(env_name='Cobo_depth_Train-Plots_' + str(today) + '_' + self.seed)
+            visValidation = utils.VisdomLinePlotter(env_name='Cobo_depth_Train-Plots_' + str(today) + '_' + self.seed)
+            visEpoch = utils.VisdomLineTwoPlotter(env_name='Cobo_depth_Train-Plots_' + str(today) + '_' + self.seed)
+            visImages = utils.VisdomImagePlotter(env_name='Cobo_depth_Images_' + str(today) + '_' + self.seed)
+            visImagesTest = utils.VisdomImagePlotter(env_name='Cobo_depth_ImagesTest_' + str(today) + '_' + self.seed)
+
+            visLossGTest = utils.VisdomLinePlotter(env_name='Cobo_depth_Train-Plots_' + str(today) + '_' + self.seed)
+            visLossGValidation = utils.VisdomLinePlotter(env_name='Cobo_depth_Train-Plots_' + str(today) + '_' + self.seed)
+
+            visLossDTest = utils.VisdomLinePlotter(env_name='Cobo_depth_Train-Plots_' + str(today) + '_' + self.seed)
+            visLossDValidation = utils.VisdomLinePlotter(env_name='Cobo_depth_Train-Plots_' + str(today) + '_' + self.seed)
+
+        self.train_hist = {}
+        self.epoch_hist = {}
+        self.details_hist = {}
+        self.train_hist['D_loss_train'] = []
+        self.train_hist['G_loss_train'] = []
+        self.train_hist['D_loss_Validation'] = []
+        self.train_hist['G_loss_Validation'] = []
+        self.train_hist['per_epoch_time'] = []
+        self.train_hist['total_time'] = []
+
+        self.details_hist['G_T_Comp_im'] = []
+        self.details_hist['G_T_BCE_fake_real'] = []
+        self.details_hist['G_T_Cycle'] = []
+        self.details_hist['G_zCR'] = []
+
+        self.details_hist['G_V_Comp_im'] = []
+        self.details_hist['G_V_BCE_fake_real'] = []
+        self.details_hist['G_V_Cycle'] = []
+
+        self.details_hist['D_T_BCE_fake_real_R'] = []
+        self.details_hist['D_T_BCE_fake_real_F'] = []
+        self.details_hist['D_zCR'] = []
+        self.details_hist['D_bCR'] = []
+
+        self.details_hist['D_V_BCE_fake_real_R'] = []
+        self.details_hist['D_V_BCE_fake_real_F'] = []
+
+        self.epoch_hist['D_loss_train'] = []
+        self.epoch_hist['G_loss_train'] = []
+        self.epoch_hist['D_loss_Validation'] = []
+        self.epoch_hist['G_loss_Validation'] = []
+
+        ##Para poder tomar el promedio por epoch
+        iterIniTrain = 0
+        iterFinTrain = 0
+
+        iterIniValidation = 0
+        iterFinValidation = 0
+
+        maxIter = self.data_loader.dataset.__len__() // self.batch_size
+        maxIterVal = self.data_Validation.dataset.__len__() // self.batch_size
+
+        if (self.WGAN):
+            one = torch.tensor(1, dtype=torch.float).cuda()
+            mone = one * -1
+        else:
+            self.y_real_ = torch.ones(self.batch_size, 1)
+            self.y_fake_ = torch.zeros(self.batch_size, 1)
+            if self.gpu_mode:
+                self.y_real_, self.y_fake_ = self.y_real_.cuda(), self.y_fake_.cuda()
+
+        print('training start!!')
+        start_time = time.time()
+
+        for epoch in range(self.epoch):
+
+            if (epoch < self.epochVentaja):
+                ventaja = True
+            else:
+                ventaja = False
+
+            self.G.train()
+
+            if not self.onlyGen:
+              self.D.train()
+            epoch_start_time = time.time()
+
+
+            # TRAIN!!!
+            for iter, data in enumerate(self.data_loader):
+
+                x_im = data.get('x_im')
+                x_dep = data.get('x_dep')
+                y_im = data.get('y_im')
+                y_dep = data.get('y_dep')
+                y_ = data.get('y_')
+
+                # x_im  = imagenes normales
+                # x_dep = profundidad de images
+                # y_im  = imagen con el angulo cambiado
+                # y_    = angulo de la imagen = tengo que tratar negativos
+
+                # Aumento mi data
+                if (self.CR):
+                    x_im_aug, y_im_aug = augmentData(x_im, y_im)
+                    x_im_vanilla = x_im
+
+                    if self.gpu_mode:
+                        x_im_aug, y_im_aug = x_im_aug.cuda(), y_im_aug.cuda()
+
+                if iter >= maxIter:
+                    break
+
+                if self.gpu_mode:
+                    x_im, y_, y_im, x_dep, y_dep = x_im.cuda(), y_.cuda(), y_im.cuda(), x_dep.cuda(), y_dep.cuda()
+
+                # update D network
+                if not ventaja and not self.onlyGen:
+
+                    for p in self.D.parameters():  # reset requires_grad
+                        p.requires_grad = True  # they are set to False below in netG update
+
+                    self.D_optimizer.zero_grad()
+
+                    # Real Images
+                    D_real, D_features_real = self.D(y_im, x_im, y_dep, y_)  ## Es la funcion forward `` g(z) x
+
+                    # Fake Images
+                    G_, G_dep = self.G( y_, x_im, x_dep)
+                    D_fake, D_features_fake = self.D(G_, x_im, G_dep, y_)
+
+                    # Losses
+                    #  GAN Loss
+                    if (self.WGAN): # de WGAN
+                        D_loss_real_fake_R = - torch.mean(D_real)
+                        D_loss_real_fake_F = torch.mean(D_fake)
+                        #D_loss_real_fake_R = - D_loss_real_fake_R_positive
+
+                    else:       # de Gan normal
+                        D_loss_real_fake_R = self.BCEWithLogitsLoss(D_real, self.y_real_)
+                        D_loss_real_fake_F = self.BCEWithLogitsLoss(D_fake, self.y_fake_)
+
+                    D_loss = D_loss_real_fake_F + D_loss_real_fake_R
+
+                    if self.CR:
+
+                        # Fake Augmented Images bCR
+                        x_im_aug_bCR, G_aug_bCR = augmentData(x_im_vanilla, G_.data.cpu())
+
+                        if self.gpu_mode:
+                            G_aug_bCR, x_im_aug_bCR = G_aug_bCR.cuda(), x_im_aug_bCR.cuda()
+
+                        D_fake_bCR, D_features_fake_bCR = self.D(G_aug_bCR, x_im_aug_bCR, G_dep, y_)
+                        D_real_bCR, D_features_real_bCR = self.D(y_im_aug, x_im_aug, y_dep, y_)
+
+                        # Fake Augmented Images zCR
+                        G_aug_zCR, G_dep_aug_zCR = self.G(y_, x_im_aug, x_dep)
+                        D_fake_aug_zCR, D_features_fake_aug_zCR = self.D(G_aug_zCR, x_im_aug, G_dep_aug_zCR, y_)
+
+                        #  bCR Loss (*)
+                        D_loss_real = self.MSE(D_features_real, D_features_real_bCR)
+                        D_loss_fake = self.MSE(D_features_fake, D_features_fake_bCR)
+                        D_bCR = (D_loss_real + D_loss_fake) * self.bFactor
+
+                        #  zCR Loss
+                        D_zCR = self.MSE(D_features_fake, D_features_fake_aug_zCR) * self.zDisFactor
+
+                        D_CR_losses = D_bCR + D_zCR
+                        #D_CR_losses.backward(retain_graph=True)
+
+                        D_loss += D_CR_losses
+
+                        self.details_hist['D_bCR'].append(D_bCR.detach().item())
+                        self.details_hist['D_zCR'].append(D_zCR.detach().item())
+                    else:
+                        self.details_hist['D_bCR'].append(0)
+                        self.details_hist['D_zCR'].append(0)
+
+                    self.train_hist['D_loss_train'].append(D_loss.detach().item())
+                    self.details_hist['D_T_BCE_fake_real_R'].append(D_loss_real_fake_R.detach().item())
+                    self.details_hist['D_T_BCE_fake_real_F'].append(D_loss_real_fake_F.detach().item())
+                    if self.visdom:
+                      visLossDTest.plot('Discriminator_losses',
+                                           ['D_T_BCE_fake_real_R','D_T_BCE_fake_real_F', 'D_bCR', 'D_zCR'], 'train',
+                                           self.details_hist)
+                    #if self.WGAN:
+                    #    D_loss_real_fake_F.backward(retain_graph=True)
+                    #    D_loss_real_fake_R_positive.backward(mone)
+                    #else:
+                    #    D_loss_real_fake.backward()
+                    D_loss.backward()
+
+                    self.D_optimizer.step()
+
+                    #WGAN
+                    if (self.WGAN):
+                        for p in self.D.parameters():
+                            p.data.clamp_(-self.clipping, self.clipping) #Segun paper si el valor es muy chico lleva al banishing gradient
+                    # Si se aplicaria la mejora en las WGANs tendiramos que sacar los batch normalizations de la red
+
+
+                # update G network
+                self.G_optimizer.zero_grad()
+
+                G_, G_dep = self.G(y_, x_im, x_dep)
+
+                if not ventaja and not self.onlyGen:
+                    for p in self.D.parameters():
+                        p.requires_grad = False  # to avoid computation
+
+                    # Fake images
+                    D_fake, _ = self.D(G_, x_im, G_dep, y_)
+
+                    if (self.WGAN):
+                        G_loss_fake = -torch.mean(D_fake) #de WGAN
+                    else:
+                        G_loss_fake = self.BCEWithLogitsLoss(D_fake, self.y_real_)
+
+                    # loss between images (*)
+                    #G_join = torch.cat((G_, G_dep), 1)
+                    #y_join = torch.cat((y_im, y_dep), 1)
+
+                    G_loss_Comp = self.L1(G_, y_im) 
+                    if self.depth:
+                      G_loss_Comp += self.L1(G_dep, y_dep)
+
+                    G_loss_Dif_Comp = G_loss_Comp * self.lambdaL1
+
+                    reverse_y = - y_ + 1
+                    reverse_G, reverse_G_dep = self.G(reverse_y, G_, G_dep)
+                    G_loss_Cycle = self.L1(reverse_G, x_im) 
+                    if self.depth:
+                      G_loss_Cycle += self.L1(reverse_G_dep, x_dep) 
+                    G_loss_Cycle = G_loss_Cycle * self.lambdaL1/2
+
+
+                    if (self.CR):
+                        # Fake images augmented
+
+                        G_aug, G_dep_aug = self.G(y_, x_im_aug, x_dep)
+                        D_fake_aug, _ = self.D(G_aug, x_im, G_dep_aug, y_)
+
+                        if (self.WGAN):
+                            G_loss_fake = - (torch.mean(D_fake)+torch.mean(D_fake_aug))/2
+                        else:
+                            G_loss_fake = ( self.BCEWithLogitsLoss(D_fake, self.y_real_) +
+                                            self.BCEWithLogitsLoss(D_fake_aug,self.y_real_)) / 2
+
+                        # loss between images (*)
+                        #y_aug_join = torch.cat((y_im_aug, y_dep), 1)
+                        #G_aug_join = torch.cat((G_aug, G_dep_aug), 1)
+
+                        G_loss_Comp_Aug = self.L1(G_aug, y_im_aug)
+                        if self.depth:
+                           G_loss_Comp_Aug += self.L1(G_dep_aug, y_dep)
+                        G_loss_Dif_Comp = (G_loss_Comp + G_loss_Comp_Aug)/2 * self.lambdaL1
+
+
+                    G_loss = G_loss_fake + G_loss_Dif_Comp + G_loss_Cycle
+
+                    self.details_hist['G_T_BCE_fake_real'].append(G_loss_fake.detach().item())
+                    self.details_hist['G_T_Comp_im'].append(G_loss_Dif_Comp.detach().item())
+                    self.details_hist['G_T_Cycle'].append(G_loss_Cycle.detach().item())
+                    self.details_hist['G_zCR'].append(0)
+
+
+                else:
+
+                    G_loss = self.L1(G_, y_im) 
+                    if self.depth:
+                      G_loss += self.L1(G_dep, y_dep)
+                    G_loss = G_loss * self.lambdaL1
+                    self.details_hist['G_T_Comp_im'].append(G_loss.detach().item())
+                    self.details_hist['G_T_BCE_fake_real'].append(0)
+                    self.details_hist['G_T_Cycle'].append(0)
+                    self.details_hist['G_zCR'].append(0)
+
+                G_loss.backward()
+                self.G_optimizer.step()
+                self.train_hist['G_loss_train'].append(G_loss.detach().item())
+                if self.onlyGen:
+                  self.train_hist['D_loss_train'].append(0)
+
+                iterFinTrain += 1
+
+                if self.visdom:
+                  visLossGTest.plot('Generator_losses',
+                                      ['G_T_Comp_im', 'G_T_BCE_fake_real', 'G_zCR','G_T_Cycle'],
+                                       'train', self.details_hist)
+
+                  vis.plot('loss', ['D_loss_train', 'G_loss_train'], 'train', self.train_hist)
+
+            ##################Validation####################################
+            with torch.no_grad():
+
+                self.G.eval()
+                if not self.onlyGen:
+                  self.D.eval()
+
+                for iter, data in enumerate(self.data_Validation):
+
+                    # Aumento mi data
+                    x_im = data.get('x_im')
+                    x_dep = data.get('x_dep')
+                    y_im = data.get('y_im')
+                    y_dep = data.get('y_dep')
+                    y_ = data.get('y_')
+                    # x_im  = imagenes normales
+                    # x_dep = profundidad de images
+                    # y_im  = imagen con el angulo cambiado
+                    # y_    = angulo de la imagen = tengo que tratar negativos
+
+                    # x_im  = torch.Tensor(list(x_im))
+                    # x_dep = torch.Tensor(x_dep)
+                    # y_im  = torch.Tensor(y_im)
+                    # print(y_.shape[0])
+                    if iter == maxIterVal:
+                        # print ("Break")
+                        break
+                    # print (y_.type(torch.LongTensor).unsqueeze(1))
+
+
+                    # print("y_vec_", y_vec_)
+                    # print ("z_", z_)
+
+                    if self.gpu_mode:
+                        x_im, y_, y_im, x_dep, y_dep = x_im.cuda(), y_.cuda(), y_im.cuda(), x_dep.cuda(), y_dep.cuda()
+                    # D network
+
+                    if not ventaja and not self.onlyGen:
+                        # Real Images
+                        D_real, _ = self.D(y_im, x_im, y_dep,y_)  ## Es la funcion forward `` g(z) x
+
+                        # Fake Images
+                        G_, G_dep = self.G(y_, x_im, x_dep)
+                        D_fake, _ = self.D(G_, x_im, G_dep, y_)
+                        # Losses
+                        #  GAN Loss
+                        if (self.WGAN):  # de WGAN
+                            D_loss_real_fake_R = - torch.mean(D_real)
+                            D_loss_real_fake_F = torch.mean(D_fake)
+
+                        else:  # de Gan normal
+                            D_loss_real_fake_R = self.BCEWithLogitsLoss(D_real, self.y_real_)
+                            D_loss_real_fake_F = self.BCEWithLogitsLoss(D_fake, self.y_fake_)
+
+                        D_loss_real_fake = D_loss_real_fake_F + D_loss_real_fake_R
+
+                        D_loss = D_loss_real_fake
+
+                        self.train_hist['D_loss_Validation'].append(D_loss.item())
+                        self.details_hist['D_V_BCE_fake_real_R'].append(D_loss_real_fake_R.item())
+                        self.details_hist['D_V_BCE_fake_real_F'].append(D_loss_real_fake_F.item())
+                        if self.visdom:
+                          visLossDValidation.plot('Discriminator_losses',
+                                                     ['D_V_BCE_fake_real_R','D_V_BCE_fake_real_F'], 'Validation',
+                                                     self.details_hist)
+
+                    # G network
+
+                    G_, G_dep = self.G(y_, x_im, x_dep)
+
+                    if not ventaja and not self.onlyGen:
+                        # Fake images
+                        D_fake,_ = self.D(G_, x_im, G_dep, y_)
+
+                        #Loss GAN
+                        if (self.WGAN):
+                            G_loss = -torch.mean(D_fake)  # porWGAN
+                        else:
+                            G_loss = self.BCEWithLogitsLoss(D_fake, self.y_real_) #de GAN NORMAL
+
+                        self.details_hist['G_V_BCE_fake_real'].append(G_loss.item())
+
+                        #Loss comparation
+                        #G_join = torch.cat((G_, G_dep), 1)
+                        #y_join = torch.cat((y_im, y_dep), 1)
+
+                        G_loss_Comp = self.L1(G_, y_im)
+                        if self.depth:
+                          G_loss_Comp += self.L1(G_dep, y_dep)
+                        G_loss_Comp = G_loss_Comp * self.lambdaL1
+
+                        reverse_y = - y_ + 1                  
+                        reverse_G, reverse_G_dep = self.G(reverse_y, G_, G_dep)
+                        G_loss_Cycle = self.L1(reverse_G, x_im) 
+                        if self.depth:
+                          G_loss_Cycle += self.L1(reverse_G_dep, x_dep) 
+                        G_loss_Cycle = G_loss_Cycle * self.lambdaL1/2
+
+                        G_loss += G_loss_Comp + G_loss_Cycle 
+
+
+                        self.details_hist['G_V_Comp_im'].append(G_loss_Comp.item())
+                        self.details_hist['G_V_Cycle'].append(G_loss_Cycle.detach().item())
+
+                    else:
+                        G_loss = self.L1(G_, y_im) 
+                        if self.depth:
+                          G_loss += self.L1(G_dep, y_dep)
+                        G_loss = G_loss * self.lambdaL1
+                        self.details_hist['G_V_Comp_im'].append(G_loss.item())
+                        self.details_hist['G_V_BCE_fake_real'].append(0)
+                        self.details_hist['G_V_Cycle'].append(0)
+
+                    self.train_hist['G_loss_Validation'].append(G_loss.item())
+                    if self.onlyGen:
+                      self.train_hist['D_loss_Validation'].append(0)
+
+
+                    iterFinValidation += 1
+                    if self.visdom:
+                      visLossGValidation.plot('Generator_losses', ['G_V_Comp_im', 'G_V_BCE_fake_real','G_V_Cycle'],
+                                                 'Validation', self.details_hist)
+                      visValidation.plot('loss', ['D_loss_Validation', 'G_loss_Validation'], 'Validation',
+                                           self.train_hist)
+
+            ##Vis por epoch
+
+            if ventaja or self.onlyGen:
+                self.epoch_hist['D_loss_train'].append(0)
+                self.epoch_hist['D_loss_Validation'].append(0)
+            else:
+                #inicioTr = (epoch - self.epochVentaja) * (iterFinTrain - iterIniTrain)
+                #inicioTe = (epoch - self.epochVentaja) * (iterFinValidation - iterIniValidation)
+                self.epoch_hist['D_loss_train'].append(mean(self.train_hist['D_loss_train'][iterIniTrain: -1]))
+                self.epoch_hist['D_loss_Validation'].append(mean(self.train_hist['D_loss_Validation'][iterIniValidation: -1]))
+
+            self.epoch_hist['G_loss_train'].append(mean(self.train_hist['G_loss_train'][iterIniTrain:iterFinTrain]))
+            self.epoch_hist['G_loss_Validation'].append(
+                mean(self.train_hist['G_loss_Validation'][iterIniValidation:iterFinValidation]))
+            if self.visdom:
+              visEpoch.plot('epoch', epoch,
+                               ['D_loss_train', 'G_loss_train', 'D_loss_Validation', 'G_loss_Validation'],
+                               self.epoch_hist)
+
+            self.train_hist['D_loss_train'] = self.train_hist['D_loss_train'][-1:]
+            self.train_hist['G_loss_train'] = self.train_hist['G_loss_train'][-1:]
+            self.train_hist['D_loss_Validation'] = self.train_hist['D_loss_Validation'][-1:]
+            self.train_hist['G_loss_Validation'] = self.train_hist['G_loss_Validation'][-1:]
+            self.train_hist['per_epoch_time'] = self.train_hist['per_epoch_time'][-1:]
+            self.train_hist['total_time'] = self.train_hist['total_time'][-1:]
+
+            self.details_hist['G_T_Comp_im'] = self.details_hist['G_T_Comp_im'][-1:]
+            self.details_hist['G_T_BCE_fake_real'] = self.details_hist['G_T_BCE_fake_real'][-1:]
+            self.details_hist['G_T_Cycle'] = self.details_hist['G_T_Cycle'][-1:]
+            self.details_hist['G_zCR'] = self.details_hist['G_zCR'][-1:]
+
+            self.details_hist['G_V_Comp_im'] = self.details_hist['G_V_Comp_im'][-1:]
+            self.details_hist['G_V_BCE_fake_real'] = self.details_hist['G_V_BCE_fake_real'][-1:]
+            self.details_hist['G_V_Cycle'] = self.details_hist['G_V_Cycle'][-1:]
+
+            self.details_hist['D_T_BCE_fake_real_R'] = self.details_hist['D_T_BCE_fake_real_R'][-1:]
+            self.details_hist['D_T_BCE_fake_real_F'] = self.details_hist['D_T_BCE_fake_real_F'][-1:]
+            self.details_hist['D_zCR'] = self.details_hist['D_zCR'][-1:]
+            self.details_hist['D_bCR'] = self.details_hist['D_bCR'][-1:]
+
+            self.details_hist['D_V_BCE_fake_real_R'] = self.details_hist['D_V_BCE_fake_real_R'][-1:]
+            self.details_hist['D_V_BCE_fake_real_F'] = self.details_hist['D_V_BCE_fake_real_F'][-1:]
+            ##Para poder tomar el promedio por epoch
+            iterIniTrain = 1
+            iterFinTrain = 1
+
+            iterIniValidation = 1
+            iterFinValidation = 1
+
+            self.train_hist['per_epoch_time'].append(time.time() - epoch_start_time)
+
+            if epoch % 10 == 0:
+                self.save(str(epoch))
+                with torch.no_grad():
+                    if self.visdom:
+                      self.visualize_results(epoch, dataprint=self.dataprint, visual=visImages)
+                      self.visualize_results(epoch, dataprint=self.dataprint_test, visual=visImagesTest)
+                    else:
+                      imageName = self.model_name + '_' + 'Train' + '_' + str(self.seed) + '_' + str(epoch)
+                      self.visualize_results(epoch, dataprint=self.dataprint, name= imageName)
+                      self.visualize_results(epoch, dataprint=self.dataprint_test, name= imageName)
+
+
+        self.train_hist['total_time'].append(time.time() - start_time)
+        print("Avg one epoch time: %.2f, total %d epochs time: %.2f" % (np.mean(self.train_hist['per_epoch_time']),
+                                                                        self.epoch, self.train_hist['total_time'][0]))
+        print("Training finish!... save training results")
+
+        self.save()
+        #utils.generate_animation(self.result_dir + '/' + self.dataset + '/' + self.model_name + '/' + self.model_name,
+        #                         self.epoch)
+        #utils.loss_plot(self.train_hist, os.path.join(self.save_dir, self.dataset, self.model_name), self.model_name)
+
+    def visualize_results(self, epoch, dataprint, visual="", name= "test"):
+        with torch.no_grad():
+            self.G.eval()
+
+            #if not os.path.exists(self.result_dir + '/' + self.dataset + '/' + self.model_name):
+            #    os.makedirs(self.result_dir + '/' + self.dataset + '/' + self.model_name)
+
+            # print("sample z: ",self.sample_z_,"sample y:", self.sample_y_)
+
+            ##Podria hacer un loop
+            # .zfill(4)
+            #newSample = None
+            #print(dataprint.shape)
+
+            #newSample = torch.tensor([])
+
+            #se que es ineficiente pero lo hago cada 10 epoch nomas
+            newSample = []
+            iter = 1
+            for x_im,x_dep in zip(dataprint.get('x_im'), dataprint.get('x_dep')):
+                if (iter > self.cantImages):
+                    break
+
+                #x_im = (x_im + 1) / 2
+                #imgX = transforms.ToPILImage()(x_im)
+                #imgX.show()
+
+                x_im_input = x_im.repeat(2, 1, 1, 1)
+                x_dep_input = x_dep.repeat(2, 1, 1, 1)
+
+                sizeImage = x_im.shape[2]
+
+                sample_y_ = torch.zeros((self.class_num, 1, sizeImage, sizeImage))
+                for i in range(self.class_num):
+                    if(int(i % self.class_num) == 1):
+                        sample_y_[i] = torch.ones(( 1, sizeImage, sizeImage))
+
+                if self.gpu_mode:
+                    sample_y_, x_im_input, x_dep_input = sample_y_.cuda(), x_im_input.cuda(), x_dep_input.cuda()
+
+                G_im, G_dep = self.G(sample_y_, x_im_input, x_dep_input)
+
+                newSample.append(x_im.squeeze(0))
+                newSample.append(x_dep.squeeze(0).expand(3, -1, -1))
+
+
+
+                if self.wiggle:
+                    im_aux, im_dep_aux = G_im, G_dep
+                    for i in range(0, 2):
+                        index = i
+                        for j in range(0, self.wiggleDepth):
+
+                            # print(i,j)
+
+                            if (j == 0 and i == 1):
+                                # para tomar el original
+                                im_aux, im_dep_aux = G_im, G_dep
+                                newSample.append(G_im.cpu()[0].squeeze(0))
+                                newSample.append(G_im.cpu()[1].squeeze(0))
+                            elif (i == 1):
+                                # por el problema de las iteraciones proximas
+                                index = 0
+
+                            # imagen generada
+
+
+                            x = im_aux[index].unsqueeze(0)
+                            x_dep = im_dep_aux[index].unsqueeze(0)
+
+                            y = sample_y_[i].unsqueeze(0)
+
+                            if self.gpu_mode:
+                                y, x, x_dep = y.cuda(), x.cuda(), x_dep.cuda()
+
+                            im_aux, im_dep_aux = self.G(y, x, x_dep)
+
+                            newSample.append(im_aux.cpu()[0])
+                else:
+
+                    newSample.append(G_im.cpu()[0])
+                    newSample.append(G_im.cpu()[1])
+                    newSample.append(G_dep.cpu()[0].expand(3, -1, -1))
+                    newSample.append(G_dep.cpu()[1].expand(3, -1, -1))
+                    # sadadas
+
+                iter+=1
+
+            if self.visdom:
+                visual.plot(epoch, newSample, int(len(newSample) /self.cantImages))
+            else:
+                utils.save_wiggle(newSample, self.cantImages, name)
+        ##TENGO QUE HACER QUE SAMPLES TENGAN COMO MAXIMO self.class_num * self.class_num
+
+        # utils.save_images(newSample[:, :, :, :], [image_frame_dim * cantidadIm , image_frame_dim * (self.class_num+2)],
+        #                  self.result_dir + '/' + self.dataset + '/' + self.model_name + '/' + self.model_name + '_epoch%04d' % epoch + '.png')
+
+    def show_plot_images(self, images, cols=1, titles=None):
+        """Display a list of images in a single figure with matplotlib.
+
+        Parameters
+        ---------
+        images: List of np.arrays compatible with plt.imshow.
+
+        cols (Default = 1): Number of columns in figure (number of rows is
+                            set to np.ceil(n_images/float(cols))).
+
+        titles: List of titles corresponding to each image. Must have
+                the same length as titles.
+        """
+        # assert ((titles is None) or (len(images) == len(titles)))
+        n_images = len(images)
+        if titles is None: titles = ['Image (%d)' % i for i in range(1, n_images + 1)]
+        fig = plt.figure()
+        for n, (image, title) in enumerate(zip(images, titles)):
+            a = fig.add_subplot(np.ceil(n_images / float(cols)), cols, n + 1)
+            # print(image)
+            image = (image + 1) * 255.0
+            # print(image)
+            # new_im = Image.fromarray(image)
+            # print(new_im)
+            if image.ndim == 2:
+                plt.gray()
+            # print("spi imshape ", image.shape)
+            plt.imshow(image)
+            a.set_title(title)
+        fig.set_size_inches(np.array(fig.get_size_inches()) * n_images)
+        plt.show()
+
+    def joinImages(self, data):
+        nData = []
+        for i in range(self.class_num):
+            nData.append(data)
+        nData = np.array(nData)
+        nData = torch.tensor(nData.tolist())
+        nData = nData.type(torch.FloatTensor)
+
+        return nData
+
+    def save(self, epoch=''):
+        save_dir = os.path.join(self.save_dir, self.dataset, self.model_name)
+
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+
+        torch.save(self.G.state_dict(),
+                   os.path.join(save_dir, self.model_name + '_' + self.seed + '_' + epoch + '_G.pkl'))
+        if not self.onlyGen:
+          torch.save(self.D.state_dict(),
+                   os.path.join(save_dir, self.model_name + '_' + self.seed + '_' + epoch + '_D.pkl'))
+
+        with open(os.path.join(save_dir, self.model_name + '_history_ '+self.seed+'.pkl'), 'wb') as f:
+            pickle.dump(self.train_hist, f)
+
+    def load(self):
+        save_dir = os.path.join(self.save_dir, self.dataset, self.model_name)
+
+        self.G.load_state_dict(torch.load(os.path.join(save_dir, self.model_name + '_' + self.seed_load + '_G.pkl')))
+        if not self.wiggle:
+            self.D.load_state_dict(torch.load(os.path.join(save_dir, self.model_name + '_' + self.seed_load + '_D.pkl')))
+
+    def wiggleEf(self):
+        seed, epoch = self.seed_load.split('_')
+        if self.visdom:
+            visWiggle = utils.VisdomImagePlotter(env_name='Cobo_depth_wiggle_' + seed)
+            self.visualize_results(epoch=epoch, dataprint=self.dataprint_test, visual=visWiggle)
+        else:
+            self.visualize_results(epoch=epoch, dataprint=self.dataprint_test, visual=None, name = self.name_wiggle)
+
+    def recreate(self):
+
+      dataloader_recreate = dataloader(self.dataset, self.input_size, self.batch_size, self.imageDim, split='score')
+      with torch.no_grad():
+        self.G.eval()
+        accum = 0
+        for data_batch in dataloader_recreate.__iter__():
+          
+          #{'x_im': x1, 'x_dep': x1_dep, 'y_im': x2, 'y_dep': x2_dep, 'y_': torch.ones(1, self.imageDim, self.imageDim)}
+          left,left_depth,right,right_depth,direction = data_batch.values()
+
+          if self.gpu_mode:
+            left,left_depth,right,right_depth,direction = left.cuda(),left_depth.cuda(),right.cuda(),right_depth.cuda(),direction.cuda()
+
+          G_right, G_right_dep = self.G( direction, left, left_depth)
+          
+          reverse_direction = direction * 0 
+          G_left, G_left_dep = self.G( reverse_direction, right, right_depth)
+
+          for index in range(0,self.batch_size):
+            image_right = (G_right[index] + 1.0)/2.0
+            image_right_dep = (G_right_dep[index] + 1.0)/2.0
+
+            image_left = (G_left[index] + 1.0)/2.0
+            image_left_dep = (G_left_dep[index] + 1.0)/2.0
+
+            
+
+            save_image(image_right, os.path.join("results","recreate_dataset","CAM1","n_{num:0{width}}.png".format(num = index+accum, width = 4)))
+            save_image(image_right_dep, os.path.join("results","recreate_dataset","CAM1","d_{num:0{width}}.png".format(num = index+accum, width = 4)))
+
+            save_image(image_left, os.path.join("results","recreate_dataset","CAM0","n_{num:0{width}}.png".format(num = index+accum, width = 4)))
+            save_image(image_left_dep, os.path.join("results","recreate_dataset","CAM0","d_{num:0{width}}.png".format(num = index+accum, width = 4)))
+          accum+= self.batch_size
+          
+    

WiggleResults/split.py

@@ -0,0 +1,91 @@
+import os
+from PIL import Image
+import argparse
+
+parser = argparse.ArgumentParser(description='change to useful name')
+parser.add_argument('--dim', default=128, type=int, help='dimention image')
+args = parser.parse_args()
+
+path = "."
+dirs = os.listdir(path)
+
+dim = args.dim
+
+def gif_order (data, center=True):
+    gif = []
+    base = 1
+
+    #primera mitad
+    i = int((len(data)-2)/2)
+    while(i > base ):
+        gif.append(data[i])
+        #print(i)
+        i -= 1
+
+
+    #el del medio izq
+    gif.append(data[int((len(data)-2)/2) + 1])
+    #print(int((len(data)-2)/2) + 1)
+
+    #el inicial
+    if center:
+        gif.append(data[0])
+    #print(0)
+
+    # el del medio der
+    gif.append(data[int((len(data) - 2) / 2) + 2])
+    #print(int((len(data) - 2) / 2) +2)
+    #segunda mitad
+    i = int((len(data)-2)/2) + 3
+    while (i < len(data)):
+        gif.append(data[i])
+        #print(i)
+        i += 1
+    #print("---------")
+
+    invertedgif = gif[::-1]
+    invertedgif = invertedgif[1:]
+
+    gif = gif[1:] + invertedgif
+    #print(gif)
+    #for image in gif:
+    #    image.show()
+    #gsdfgsfgf
+    return gif
+
+
+# This would print all the files and directories
+for file in dirs:
+    if ".jpg" in file or ".png" in file:
+        rowImages = []
+        im = Image.open("./" + file)
+        width, height = im.size
+        im = im.convert('RGB')
+
+        #CROP (left, top, right, bottom)
+
+        pointleft = 3
+        pointtop = 3
+        i = 0
+        while (pointtop < height):
+            while (pointleft < width):
+                im1 = im.crop((pointleft, pointtop, dim+pointleft, dim+pointtop))
+                rowImages.append(im1.quantize())
+                #im1.show()
+                pointleft+= dim+4
+            # Ya tengo todas las imagenes podria hacer el gif aca
+            rowImages = gif_order(rowImages,center=False)
+            name = file[:-4] + "_" + str(i) + '.gif'
+            rowImages[0].save(name, save_all=True,format='GIF', append_images=rowImages[1:], optimize=True, duration=100, loop=0)
+            pointtop += dim + 4
+            pointleft = 3
+            rowImages = []
+            i+=1
+        #im2 = im.crop((width / 2, 0, width, height))
+        # im2.show()
+
+        #im1.save("./2" + file[:-4] + ".png")
+        #im2.save("./" + file[:-4] + ".png")
+
+    # Deleted
+    #os.remove("data/" + file)

app.py

@@ -16,7 +16,6 @@ def calculate_depth(model_type, img):
 
     img.save(filename, "JPEG")
 
-    #model_type = "DPT_Hybrid" 
     midas = torch.hub.load("intel-isl/MiDaS", model_type)
     
     device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
@@ -61,18 +60,19 @@ def wiggle_effect(slider):
 
 with gr.Blocks() as demo:
     gr.Markdown("Start typing below and then click **Run** to see the output.")
-    inp = []
-
+    
+    
+    ## Depth Estimation
     midas_models = ["DPT_Large","DPT_Hybrid","MiDaS_small"]
-
-    inp.append(gr.inputs.Dropdown(midas_models, default="MiDaS_small", label="Depth estimation model type"))
-
+    inp = [gr.inputs.Dropdown(midas_models, default="MiDaS_small", label="Depth estimation model type")]
     with gr.Row():
         inp.append(gr.Image(type="pil", label="Input"))
         out = gr.Image(type="file", label="depth_estimation")
     btn = gr.Button("Calculate depth")
     btn.click(fn=calculate_depth, inputs=inp, outputs=out)
 
+
+    ## Wigglegram
     inp = [gr.Slider(1,15, default = 2, label='StepCycles',step= 1)]
     with gr.Row():
         out = [ gr.Image(type="file", label="Output_images"), #TODO change to gallery 

architectures.py

@@ -0,0 +1,1094 @@
+import torch.nn as nn
+import utils, torch
+from torch.autograd import Variable
+import torch.nn.functional as F
+
+
+class generator(nn.Module):
+    # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
+    # Architecture : FC1024_BR-FC7x7x128_BR-(64)4dc2s_BR-(1)4dc2s_S
+    def __init__(self, input_dim=4, output_dim=1, input_shape=3, class_num=10, height=10, width=10):
+        super(generator, self).__init__()
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        # print ("self.output_dim", self.output_dim)
+        self.class_num = class_num
+        self.input_shape = list(input_shape)
+        self.toPreDecov = 1024
+        self.toDecov = 1
+        self.height = height
+        self.width = width
+
+        self.input_shape[1] = self.input_dim  # esto cambio despues por colores
+
+        # print("input shpe gen",self.input_shape)
+
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(self.input_dim, 10, 4, 2, 1),  # para mi el 2 tendria que ser 1
+            nn.Conv2d(10, 4, 4, 2, 1),
+            nn.BatchNorm2d(4),
+            nn.LeakyReLU(0.2),
+            nn.Conv2d(4, 3, 4, 2, 1),
+            nn.BatchNorm2d(3),
+            nn.LeakyReLU(0.2),
+        )
+
+        self.n_size = self._get_conv_output(self.input_shape)
+        # print ("self.n_size",self.n_size)
+        self.cubic = (self.n_size // 8192)
+        # print("self.cubic: ",self.cubic)
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(self.n_size, self.n_size),
+            nn.BatchNorm1d(self.n_size),
+            nn.LeakyReLU(0.2),
+        )
+
+        self.preDeconv = nn.Sequential(
+            ##############RED SUPER CHICA PARA QUE ANDE TO DO PORQUE RAM Y MEMORY
+
+            # nn.Linear(self.toPreDecov + self.zdim + self.class_num, 1024),
+            # nn.BatchNorm1d(1024),
+            # nn.LeakyReLU(0.2),
+            # nn.Linear(1024, self.toDecov * self.height // 64  * self.width// 64),
+            # nn.BatchNorm1d(self.toDecov * self.height // 64  * self.width// 64),
+            # nn.LeakyReLU(0.2),
+            # nn.Linear(self.toDecov * self.height // 64 * self.width // 64 , self.toDecov * self.height // 32 * self.width // 32),
+            # nn.BatchNorm1d(self.toDecov * self.height // 32 * self.width // 32),
+            # nn.LeakyReLU(0.2),
+            # nn.Linear(self.toDecov * self.height // 32 * self.width // 32,
+            #         1 * self.height * self.width),
+            # nn.BatchNorm1d(1 * self.height * self.width),
+            # nn.LeakyReLU(0.2),
+
+            nn.Linear(self.n_size + self.class_num, 400),
+            nn.BatchNorm1d(400),
+            nn.LeakyReLU(0.2),
+            nn.Linear(400, 800),
+            nn.BatchNorm1d(800),
+            nn.LeakyReLU(0.2),
+            nn.Linear(800, self.output_dim * self.height * self.width),
+            nn.BatchNorm1d(self.output_dim * self.height * self.width),
+            nn.Tanh(),  # Cambio porque hago como que termino ahi
+
+        )
+
+        """
+        self.deconv = nn.Sequential(
+            nn.ConvTranspose2d(self.toDecov, 2, 4, 2, 0),
+            nn.BatchNorm2d(2),
+            nn.ReLU(),
+            nn.ConvTranspose2d(2, self.output_dim, 4, 2, 1),
+            nn.Tanh(), #esta recomendado que la ultima sea TanH de la Generadora da valores entre -1 y 1
+        )
+        """
+        utils.initialize_weights(self)
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        # print("inShape:",input.shape)
+        output_feat = self.conv1(input.squeeze())
+        # print ("output_feat",output_feat.shape)
+        n_size = output_feat.data.view(bs, -1).size(1)
+        # print ("n",n_size // 4)
+        return n_size // 4
+
+    def forward(self, clase, im):
+        ##Esto es lo que voy a hacer
+        # Cat entre la imagen y la profundidad
+        # print ("H",self.height,"W",self.width)
+        # imDep = imDep[:, None, :, :]
+        # im = im[:, None, :, :]
+        x = im
+
+        # Ref Conv de ese cat
+        x = self.conv1(x)
+        x = x.view(x.size(0), -1)
+        # print ("x:", x.shape)
+        x = self.fc1(x)
+        # print ("x:",x.shape)
+
+        # cat entre el ruido y la clase
+        y = clase
+        # print("Cat entre input y clase", y.shape) #podria separarlo, unir primero con clase y despues con ruido
+
+        # Red Lineal que une la Conv con el cat anterior
+        x = torch.cat([x, y], 1)
+        x = self.preDeconv(x)
+        # print ("antes de deconv", x.shape)
+        x = x.view(-1, self.output_dim, self.height, self.width)
+        # print("Despues View: ", x.shape)
+        # Red que saca produce la imagen final
+        # x = self.deconv(x)
+        # print("La salida de la generadora es: ",x.shape)
+
+        return x
+
+
+class discriminator(nn.Module):
+    # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
+    # Architecture : (64)4c2s-(128)4c2s_BL-FC1024_BL-FC1_S
+    def __init__(self, input_dim=1, output_dim=1, input_shape=2, class_num=10):
+        super(discriminator, self).__init__()
+        self.input_dim = input_dim * 2  # ya que le doy el origen
+        self.output_dim = output_dim
+        self.input_shape = list(input_shape)
+        self.class_num = class_num
+
+        self.input_shape[1] = self.input_dim  # esto cambio despues por colores
+        # print(self.input_shape)
+
+        """""
+          in_channels (int): Number of channels in the input image
+          out_channels (int): Number of channels produced by the convolution
+          kernel_size (int or tuple): Size of the convolving kernel -  lo que se agarra para la conv
+          stride (int or tuple, optional): Stride of the convolution. Default: 1
+          padding (int or tuple, optional): Zero-padding added to both sides of the input.
+          """""
+
+        """
+          nn.Conv2d(self.input_dim, 64, 4, 2, 1), #para mi el 2 tendria que ser 1
+          nn.LeakyReLU(0.2),
+          nn.Conv2d(64, 32, 4, 2, 1),
+          nn.LeakyReLU(0.2),
+          nn.MaxPool2d(4, stride=2),
+          nn.Conv2d(32, 32, 4, 2, 1),
+          nn.LeakyReLU(0.2),
+          nn.MaxPool2d(4, stride=2),
+          nn.Conv2d(32, 20, 4, 2, 1),
+          nn.BatchNorm2d(20),
+          nn.LeakyReLU(0.2),
+          """
+
+        self.conv = nn.Sequential(
+
+            nn.Conv2d(self.input_dim, 4, 4, 2, 1),  # para mi el 2 tendria que ser 1
+            nn.LeakyReLU(0.2),
+            nn.Conv2d(4, 8, 4, 2, 1),
+            nn.BatchNorm2d(8),
+            nn.LeakyReLU(0.2),
+            nn.Conv2d(8, 16, 4, 2, 1),
+            nn.BatchNorm2d(16),
+
+        )
+
+        self.n_size = self._get_conv_output(self.input_shape)
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(self.n_size // 4, 1024),
+            nn.BatchNorm1d(1024),
+            nn.LeakyReLU(0.2),
+            nn.Linear(1024, 512),
+            nn.BatchNorm1d(512),
+            nn.LeakyReLU(0.2),
+            nn.Linear(512, 256),
+            nn.BatchNorm1d(256),
+            nn.LeakyReLU(0.2),
+            nn.Linear(256, 128),
+            nn.BatchNorm1d(128),
+            nn.LeakyReLU(0.2),
+            nn.Linear(128, 64),
+            nn.BatchNorm1d(64),
+            nn.LeakyReLU(0.2),
+        )
+        self.dc = nn.Sequential(
+            nn.Linear(64, self.output_dim),
+            nn.Sigmoid(),
+        )
+        self.cl = nn.Sequential(
+            nn.Linear(64, self.class_num),
+            nn.Sigmoid(),
+        )
+        utils.initialize_weights(self)
+
+        # generate input sample and forward to get shape
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        output_feat = self.conv(input.squeeze())
+        n_size = output_feat.data.view(bs, -1).size(1)
+        return n_size
+
+    def forward(self, input, origen):
+        # esto va a cambiar cuando tenga color
+        # if (len(input.shape) <= 3):
+        #    input = input[:, None, :, :]
+        # im = im[:, None, :, :]
+        # print("D in shape",input.shape)
+
+        # print(input.shape)
+        # print("this si X:", x)
+        # print("now shape", x.shape)
+        x = input
+        x = x.type(torch.FloatTensor)
+        x = x.to(device='cuda:0')
+
+        x = torch.cat((x, origen), 1)
+        x = self.conv(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc1(x)
+        d = self.dc(x)
+        c = self.cl(x)
+
+        return d, c
+
+
+#######################################################################################################################
+class UnetConvBlock(nn.Module):
+    '''
+    Convolutional block of a U-Net:
+    Conv2d - Batch normalization - LeakyReLU
+    Conv2D - Batch normalization - LeakyReLU
+    Basic Dropout (optional)
+    '''
+
+    def __init__(self, in_size, out_size, dropout=0.0, stride=1, batch_norm = True):
+        '''
+        Constructor of the convolutional block
+        '''
+        super(UnetConvBlock, self).__init__()
+
+        # Convolutional layer with IN_SIZE --> OUT_SIZE
+        conv1 = nn.Conv2d(in_channels=in_size, out_channels=out_size, kernel_size=3, stride=1,
+                          padding=1)  # podria aplicar stride 2
+        # Activation unit
+        activ_unit1 = nn.LeakyReLU(0.2)
+        # Add batch normalization if necessary
+        if batch_norm:
+            self.conv1 = nn.Sequential(conv1, nn.BatchNorm2d(out_size), activ_unit1)
+        else:
+            self.conv1 = nn.Sequential(conv1, activ_unit1)
+
+        # Convolutional layer with OUT_SIZE --> OUT_SIZE
+        conv2 = nn.Conv2d(in_channels=out_size, out_channels=out_size, kernel_size=3, stride=stride,
+                          padding=1)  # podria aplicar stride 2
+        # Activation unit
+        activ_unit2 = nn.LeakyReLU(0.2)
+
+        # Add batch normalization
+        if batch_norm:
+            self.conv2 = nn.Sequential(conv2, nn.BatchNorm2d(out_size), activ_unit2)
+        else:
+            self.conv2 = nn.Sequential(conv2, activ_unit2)
+        # Dropout
+        if dropout > 0.0:
+            self.drop = nn.Dropout(dropout)
+        else:
+            self.drop = None
+
+    def forward(self, inputs):
+        '''
+        Do a forward pass
+        '''
+        outputs = self.conv1(inputs)
+        outputs = self.conv2(outputs)
+        if not (self.drop is None):
+            outputs = self.drop(outputs)
+        return outputs
+
+
+class UnetDeSingleConvBlock(nn.Module):
+    '''
+    DeConvolutional block of a U-Net:
+    Conv2d - Batch normalization - LeakyReLU
+    Basic Dropout (optional)
+    '''
+
+    def __init__(self, in_size, out_size, dropout=0.0, stride=1, padding=1, batch_norm = True ):
+        '''
+        Constructor of the convolutional block
+        '''
+        super(UnetDeSingleConvBlock, self).__init__()
+
+        # Convolutional layer with IN_SIZE --> OUT_SIZE
+        conv1 = nn.Conv2d(in_channels=in_size, out_channels=out_size, kernel_size=3, stride=stride, padding=1)
+        # Activation unit
+        activ_unit1 = nn.LeakyReLU(0.2)
+        # Add batch normalization if necessary
+        if batch_norm:
+            self.conv1 = nn.Sequential(conv1, nn.BatchNorm2d(out_size), activ_unit1)
+        else:
+            self.conv1 = nn.Sequential(conv1, activ_unit1)
+
+        # Dropout
+        if dropout > 0.0:
+            self.drop = nn.Dropout(dropout)
+        else:
+            self.drop = None
+
+    def forward(self, inputs):
+        '''
+        Do a forward pass
+        '''
+        outputs = self.conv1(inputs)
+        if not (self.drop is None):
+            outputs = self.drop(outputs)
+        return outputs
+
+
+class UnetDeconvBlock(nn.Module):
+    '''
+    DeConvolutional block of a U-Net:
+    UnetDeSingleConvBlock (skip_connection)
+    Cat last_layer + skip_connection
+    UnetDeSingleConvBlock ( Cat )
+    Basic Dropout (optional)
+    '''
+
+    def __init__(self, in_size_layer, in_size_skip_con, out_size, dropout=0.0):
+        '''
+        Constructor of the convolutional block
+        '''
+        super(UnetDeconvBlock, self).__init__()
+
+        self.conv1 = UnetDeSingleConvBlock(in_size_skip_con, in_size_skip_con, dropout)
+        self.conv2 = UnetDeSingleConvBlock(in_size_layer + in_size_skip_con, out_size, dropout)
+
+        # Dropout
+        if dropout > 0.0:
+            self.drop = nn.Dropout(dropout)
+        else:
+            self.drop = None
+
+    def forward(self, inputs_layer, inputs_skip):
+        '''
+        Do a forward pass
+        '''
+
+        outputs = self.conv1(inputs_skip)
+
+        #outputs = changeDim(outputs, inputs_layer)
+
+        outputs = torch.cat((inputs_layer, outputs), 1)
+        outputs = self.conv2(outputs)
+
+        return outputs
+
+
+class UpBlock(nn.Module):
+    """Upscaling then double conv"""
+
+    def __init__(self, in_size_layer, in_size_skip_con, out_size, bilinear=True):
+        super(UpBlock, self).__init__()
+
+        # if bilinear, use the normal convolutions to reduce the number of channels
+        if bilinear:
+            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
+        else:
+            self.up = nn.ConvTranspose2d(in_size_layer // 2, in_size_layer // 2, kernel_size=2, stride=2)
+
+        self.conv = UnetDeconvBlock(in_size_layer, in_size_skip_con, out_size)
+
+    def forward(self, inputs_layer, inputs_skip):
+
+        inputs_layer = self.up(inputs_layer)
+
+        # input is CHW
+        #inputs_layer = changeDim(inputs_layer, inputs_skip)
+
+        return self.conv(inputs_layer, inputs_skip)
+
+
+class lastBlock(nn.Module):
+    '''
+    DeConvolutional block of a U-Net:
+    Conv2d - Batch normalization - LeakyReLU
+    Basic Dropout (optional)
+    '''
+
+    def __init__(self, in_size, out_size, dropout=0.0):
+        '''
+        Constructor of the convolutional block
+        '''
+        super(lastBlock, self).__init__()
+
+        # Convolutional layer with IN_SIZE --> OUT_SIZE
+        conv1 = nn.Conv2d(in_channels=in_size, out_channels=out_size, kernel_size=3, stride=1, padding=1)
+        # Activation unit
+        activ_unit1 = nn.Tanh()
+        # Add batch normalization if necessary
+        self.conv1 = nn.Sequential(conv1, nn.BatchNorm2d(out_size), activ_unit1)
+
+        # Dropout
+        if dropout > 0.0:
+            self.drop = nn.Dropout(dropout)
+        else:
+            self.drop = None
+
+    def forward(self, inputs):
+        '''
+        Do a forward pass
+        '''
+        outputs = self.conv1(inputs)
+        if not (self.drop is None):
+            outputs = self.drop(outputs)
+        return outputs
+
+
+################
+
+class generator_UNet(nn.Module):
+    # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
+    # Architecture : FC1024_BR-FC7x7x128_BR-(64)4dc2s_BR-(1)4dc2s_S
+    def __init__(self, input_dim=4, output_dim=1, input_shape=3, class_num=2, expand_net=3):
+        super(generator_UNet, self).__init__()
+        self.input_dim = input_dim + 1  # por la clase
+        self.output_dim = output_dim
+        # print ("self.output_dim", self.output_dim)
+        self.class_num = class_num
+        self.input_shape = list(input_shape)
+
+        self.input_shape[1] = self.input_dim  # esto cambio despues por colores
+
+        self.expandNet = expand_net  # 5
+
+        # Downsampling
+        self.conv1 = UnetConvBlock(self.input_dim, pow(2, self.expandNet), stride=1)
+        # self.maxpool1 = nn.MaxPool2d(kernel_size=2)
+        self.conv2 = UnetConvBlock(pow(2, self.expandNet), pow(2, self.expandNet + 1), stride=2)
+        # self.maxpool2 = nn.MaxPool2d(kernel_size=2)
+        self.conv3 = UnetConvBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 2), stride=2)
+        # self.maxpool3 = nn.MaxPool2d(kernel_size=2)
+        # Middle ground
+        self.conv4 = UnetDeSingleConvBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), stride=2)
+        # UpSampling
+        self.up1 = UpBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), pow(2, self.expandNet + 1),
+                           bilinear=True)
+        self.up2 = UpBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 1), pow(2, self.expandNet),
+                           bilinear=True)
+        self.up3 = UpBlock(pow(2, self.expandNet), pow(2, self.expandNet), 8, bilinear=True)
+        self.last = lastBlock(8, self.output_dim)
+
+        utils.initialize_weights(self)
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        # print("inShape:",input.shape)
+        output_feat = self.conv1(input.squeeze())  ##CAMBIAR
+        # print ("output_feat",output_feat.shape)
+        n_size = output_feat.data.view(bs, -1).size(1)
+        # print ("n",n_size // 4)
+        return n_size // 4
+
+    def forward(self, clase, im):
+        x = im
+
+        ##PARA TENER LA CLASE DEL CORRIMIENTO
+        cl = ((clase == 1))
+        cl = cl[:, 1]
+        cl = cl.type(torch.FloatTensor)
+        max = (clase.size())[1] - 1
+        cl = cl / float(max)
+
+        ##crear imagen layer de corrimiento
+        tam = im.size()
+        layerClase = torch.ones([tam[0], tam[2], tam[3]], dtype=torch.float32, device="cuda:0")
+        for idx, item in enumerate(layerClase):
+            layerClase[idx] = item * cl[idx]
+        layerClase = layerClase.unsqueeze(0)
+        layerClase = layerClase.transpose(1, 0)
+
+        ##unir layer el rgb de la imagen
+        x = torch.cat((x, layerClase), 1)
+
+        x1 = self.conv1(x)
+        x2 = self.conv2(x1)  # self.maxpool1(x1))
+        x3 = self.conv3(x2)  # self.maxpool2(x2))
+        x4 = self.conv4(x3)  # self.maxpool3(x3))
+        x = self.up1(x4, x3)
+        x = self.up2(x, x2)
+        x = self.up3(x, x1)
+        x = changeDim(x, im)
+        x = self.last(x)
+
+        return x
+
+
+class discriminator_UNet(nn.Module):
+    # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
+    # Architecture : (64)4c2s-(128)4c2s_BL-FC1024_BL-FC1_S
+    def __init__(self, input_dim=1, output_dim=1, input_shape=[2, 2], class_num=10, expand_net = 2):
+        super(discriminator_UNet, self).__init__()
+        self.input_dim = input_dim * 2  # ya que le doy el origen
+        self.output_dim = output_dim
+        self.input_shape = list(input_shape)
+        self.class_num = class_num
+
+        self.input_shape[1] = self.input_dim  # esto cambio despues por colores
+
+        self.expandNet = expand_net  # 4
+
+        # Downsampling
+        self.conv1 = UnetConvBlock(self.input_dim, pow(2, self.expandNet), stride=1, dropout=0.3)
+        self.conv2 = UnetConvBlock(pow(2, self.expandNet), pow(2, self.expandNet + 1), stride=2, dropout=0.5)
+        self.conv3 = UnetConvBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 2), stride=2, dropout=0.4)
+
+        # Middle ground
+        self.conv4 = UnetDeSingleConvBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), stride=2,
+                                           dropout=0.3)
+
+        self.n_size = self._get_conv_output(self.input_shape)
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(self.n_size // 4, 1024),
+            nn.BatchNorm1d(1024),
+            nn.LeakyReLU(0.2),
+        )
+
+        self.dc = nn.Sequential(
+            nn.Linear(1024, self.output_dim),
+            # nn.Sigmoid(),
+        )
+        self.cl = nn.Sequential(
+            nn.Linear(1024, self.class_num),
+            nn.Softmax(dim=1),  # poner el que la suma da 1
+        )
+        utils.initialize_weights(self)
+
+        # generate input sample and forward to get shape
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        x = input.squeeze()
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        n_size = x.data.view(bs, -1).size(1)
+        return n_size
+
+    def forward(self, input, origen):
+        # esto va a cambiar cuando tenga color
+        # if (len(input.shape) <= 3):
+        #    input = input[:, None, :, :]
+        # im = im[:, None, :, :]
+        # print("D in shape",input.shape)
+
+        # print(input.shape)
+        # print("this si X:", x)
+        # print("now shape", x.shape)
+        x = input
+        x = x.type(torch.FloatTensor)
+        x = x.to(device='cuda:0')
+
+        x = torch.cat((x, origen), 1)
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc1(x)
+        d = self.dc(x)
+        c = self.cl(x)
+
+        return d, c
+
+
+def changeDim(x, y):
+    ''' Change dim-image from x to y '''
+
+    diffY = torch.tensor([y.size()[2] - x.size()[2]])
+    diffX = torch.tensor([y.size()[3] - x.size()[3]])
+    x = F.pad(x, [diffX // 2, diffX - diffX // 2,
+                  diffY // 2, diffY - diffY // 2])
+    return x
+
+
+########################################      ACGAN        ###########################################################
+
+class depth_generator(nn.Module):
+    # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
+    # Architecture : FC1024_BR-FC7x7x128_BR-(64)4dc2s_BR-(1)4dc2s_S
+    def __init__(self, input_dim=4, output_dim=1, input_shape=3, class_num=10, zdim=1, height=10, width=10):
+        super(depth_generator, self).__init__()
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.class_num = class_num
+        # print ("self.output_dim", self.output_dim)
+        self.input_shape = list(input_shape)
+        self.zdim = zdim
+        self.toPreDecov = 1024
+        self.toDecov = 1
+        self.height = height
+        self.width = width
+
+        self.input_shape[1] = self.input_dim  # esto cambio despues por colores
+
+        # print("input shpe gen",self.input_shape)
+
+        self.conv1 = nn.Sequential(
+            ##############RED SUPER CHICA PARA QUE ANDE TO DO PORQUE RAM Y MEMORY
+            nn.Conv2d(self.input_dim, 2, 4, 2, 1),  # para mi el 2 tendria que ser 1
+            nn.Conv2d(2, 1, 4, 2, 1),
+            nn.BatchNorm2d(1),
+            nn.LeakyReLU(0.2),
+        )
+
+        self.n_size = self._get_conv_output(self.input_shape)
+        # print ("self.n_size",self.n_size)
+        self.cubic = (self.n_size // 8192)
+        # print("self.cubic: ",self.cubic)
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(self.n_size, self.n_size),
+            nn.BatchNorm1d(self.n_size),
+            nn.LeakyReLU(0.2),
+        )
+
+        self.preDeconv = nn.Sequential(
+            ##############RED SUPER CHICA PARA QUE ANDE TO DO PORQUE RAM Y MEMORY
+
+            # nn.Linear(self.toPreDecov + self.zdim + self.class_num, 1024),
+            # nn.BatchNorm1d(1024),
+            # nn.LeakyReLU(0.2),
+            # nn.Linear(1024, self.toDecov * self.height // 64  * self.width// 64),
+            # nn.BatchNorm1d(self.toDecov * self.height // 64  * self.width// 64),
+            # nn.LeakyReLU(0.2),
+            # nn.Linear(self.toDecov * self.height // 64 * self.width // 64 , self.toDecov * self.height // 32 * self.width // 32),
+            # nn.BatchNorm1d(self.toDecov * self.height // 32 * self.width // 32),
+            # nn.LeakyReLU(0.2),
+            # nn.Linear(self.toDecov * self.height // 32 * self.width // 32,
+            #         1 * self.height * self.width),
+            # nn.BatchNorm1d(1 * self.height * self.width),
+            # nn.LeakyReLU(0.2),
+
+            nn.Linear(self.n_size + self.zdim + self.class_num, 50),
+            nn.BatchNorm1d(50),
+            nn.LeakyReLU(0.2),
+            nn.Linear(50, 200),
+            nn.BatchNorm1d(200),
+            nn.LeakyReLU(0.2),
+            nn.Linear(200, self.output_dim * self.height * self.width),
+            nn.BatchNorm1d(self.output_dim * self.height * self.width),
+            nn.Tanh(),  # Cambio porque hago como que termino ahi
+
+        )
+
+        """
+        self.deconv = nn.Sequential(
+            nn.ConvTranspose2d(self.toDecov, 2, 4, 2, 0),
+            nn.BatchNorm2d(2),
+            nn.ReLU(),
+            nn.ConvTranspose2d(2, self.output_dim, 4, 2, 1),
+            nn.Tanh(), #esta recomendado que la ultima sea TanH de la Generadora da valores entre -1 y 1
+        )
+        """
+        utils.initialize_weights(self)
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        # print("inShape:",input.shape)
+        output_feat = self.conv1(input.squeeze())
+        # print ("output_feat",output_feat.shape)
+        n_size = output_feat.data.view(bs, -1).size(1)
+        # print ("n",n_size // 4)
+        return n_size // 4
+
+    def forward(self, input, clase, im, imDep):
+        ##Esto es lo que voy a hacer
+        # Cat entre la imagen y la profundidad
+        print ("H", self.height, "W", self.width)
+        # imDep = imDep[:, None, :, :]
+        # im = im[:, None, :, :]
+        print ("imdep", imDep.shape)
+        print ("im", im.shape)
+        x = torch.cat([im, imDep], 1)
+
+        # Ref Conv de ese cat
+        x = self.conv1(x)
+        x = x.view(x.size(0), -1)
+        print ("x:", x.shape)
+        x = self.fc1(x)
+        # print ("x:",x.shape)
+
+        # cat entre el ruido y la clase
+        y = torch.cat([input, clase], 1)
+        print("Cat entre input y clase", y.shape)  # podria separarlo, unir primero con clase y despues con ruido
+
+        # Red Lineal que une la Conv con el cat anterior
+        x = torch.cat([x, y], 1)
+        x = self.preDeconv(x)
+        print ("antes de deconv", x.shape)
+        x = x.view(-1, self.output_dim, self.height, self.width)
+        print("Despues View: ", x.shape)
+        # Red que saca produce la imagen final
+        # x = self.deconv(x)
+        print("La salida de la generadora es: ", x.shape)
+
+        return x
+
+
+class depth_discriminator(nn.Module):
+    # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
+    # Architecture : (64)4c2s-(128)4c2s_BL-FC1024_BL-FC1_S
+    def __init__(self, input_dim=1, output_dim=1, input_shape=2, class_num=10):
+        super(depth_discriminator, self).__init__()
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.input_shape = list(input_shape)
+        self.class_num = class_num
+
+        self.input_shape[1] = self.input_dim  # esto cambio despues por colores
+        print(self.input_shape)
+
+        """""
+          in_channels (int): Number of channels in the input image
+          out_channels (int): Number of channels produced by the convolution
+          kernel_size (int or tuple): Size of the convolving kernel -  lo que se agarra para la conv
+          stride (int or tuple, optional): Stride of the convolution. Default: 1
+          padding (int or tuple, optional): Zero-padding added to both sides of the input.
+          """""
+
+        """
+          nn.Conv2d(self.input_dim, 64, 4, 2, 1), #para mi el 2 tendria que ser 1
+          nn.LeakyReLU(0.2),
+          nn.Conv2d(64, 32, 4, 2, 1),
+          nn.LeakyReLU(0.2),
+          nn.MaxPool2d(4, stride=2),
+          nn.Conv2d(32, 32, 4, 2, 1),
+          nn.LeakyReLU(0.2),
+          nn.MaxPool2d(4, stride=2),
+          nn.Conv2d(32, 20, 4, 2, 1),
+          nn.BatchNorm2d(20),
+          nn.LeakyReLU(0.2),
+          """
+
+        self.conv = nn.Sequential(
+
+            nn.Conv2d(self.input_dim, 4, 4, 2, 1),  # para mi el 2 tendria que ser 1
+            nn.LeakyReLU(0.2),
+            nn.Conv2d(4, 8, 4, 2, 1),
+            nn.BatchNorm2d(8),
+            nn.LeakyReLU(0.2),
+            nn.Conv2d(8, 16, 4, 2, 1),
+            nn.BatchNorm2d(16),
+
+        )
+
+        self.n_size = self._get_conv_output(self.input_shape)
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(self.n_size // 4, 1024),
+            nn.BatchNorm1d(1024),
+            nn.LeakyReLU(0.2),
+            nn.Linear(1024, 512),
+            nn.BatchNorm1d(512),
+            nn.LeakyReLU(0.2),
+            nn.Linear(512, 256),
+            nn.BatchNorm1d(256),
+            nn.LeakyReLU(0.2),
+            nn.Linear(256, 128),
+            nn.BatchNorm1d(128),
+            nn.LeakyReLU(0.2),
+            nn.Linear(128, 64),
+            nn.BatchNorm1d(64),
+            nn.LeakyReLU(0.2),
+        )
+        self.dc = nn.Sequential(
+            nn.Linear(64, self.output_dim),
+            nn.Sigmoid(),
+        )
+        self.cl = nn.Sequential(
+            nn.Linear(64, self.class_num),
+            nn.Sigmoid(),
+        )
+        utils.initialize_weights(self)
+
+        # generate input sample and forward to get shape
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        output_feat = self.conv(input.squeeze())
+        n_size = output_feat.data.view(bs, -1).size(1)
+        return n_size
+
+    def forward(self, input, im):
+        # esto va a cambiar cuando tenga color
+        # if (len(input.shape) <= 3):
+        #    input = input[:, None, :, :]
+        # im = im[:, None, :, :]
+        print("D in shape", input.shape)
+        print("D im shape", im.shape)
+        x = torch.cat([input, im], 1)
+        print(input.shape)
+        # print("this si X:", x)
+        # print("now shape", x.shape)
+        x = x.type(torch.FloatTensor)
+        x = x.to(device='cuda:0')
+        x = self.conv(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc1(x)
+        d = self.dc(x)
+        c = self.cl(x)
+
+        return d, c
+
+
+class depth_generator_UNet(nn.Module):
+    # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
+    # Architecture : FC1024_BR-FC7x7x128_BR-(64)4dc2s_BR-(1)4dc2s_S
+    def __init__(self, input_dim=4, output_dim=1, class_num=10, expand_net=3, depth=True):
+        super(depth_generator_UNet, self).__init__()
+
+        if depth:
+          self.input_dim = input_dim + 1
+        else:
+          self.input_dim = input_dim
+        self.output_dim = output_dim 
+        self.class_num = class_num
+        # print ("self.output_dim", self.output_dim)
+
+        self.expandNet = expand_net  # 5
+        self.depth = depth
+
+        # Downsampling
+        self.conv1 = UnetConvBlock(self.input_dim, pow(2, self.expandNet))
+        # self.maxpool1 = nn.MaxPool2d(kernel_size=2)
+        self.conv2 = UnetConvBlock(pow(2, self.expandNet), pow(2, self.expandNet + 1), stride=2)
+        # self.maxpool2 = nn.MaxPool2d(kernel_size=2)
+        self.conv3 = UnetConvBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 2), stride=2)
+        # self.maxpool3 = nn.MaxPool2d(kernel_size=2)
+        # Middle ground
+        self.conv4 = UnetDeSingleConvBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), stride=2)
+        # UpSampling
+        self.up1 = UpBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), pow(2, self.expandNet + 1))
+        self.up2 = UpBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 1), pow(2, self.expandNet))
+        self.up3 = UpBlock(pow(2, self.expandNet), pow(2, self.expandNet), 8)
+        self.last = lastBlock(8, self.output_dim)
+
+        if depth:
+          self.upDep1 = UpBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), pow(2, self.expandNet + 1))
+          self.upDep2 = UpBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 1), pow(2, self.expandNet))
+          self.upDep3 = UpBlock(pow(2, self.expandNet), pow(2, self.expandNet), 8)
+          self.lastDep = lastBlock(8, 1)
+
+
+
+        utils.initialize_weights(self)
+
+
+    def forward(self, clase, im, imDep):
+        ##Hago algo con el z?
+        #print (im.shape)
+        #print (z.shape)
+        #print (z)
+        #imz = torch.repeat_interleave(z, repeats=torch.tensor([2, 2]), dim=1)
+        #print (imz.shape)
+        #print (imz)
+        #sdadsadas
+        if self.depth:
+          x = torch.cat([im, imDep], 1)
+          x = torch.cat((x, clase), 1)
+        else:
+          x = torch.cat((im, clase), 1)
+        ##unir layer el rgb de la imagen
+        
+
+        x1 = self.conv1(x)
+        x2 = self.conv2(x1)  # self.maxpool1(x1))
+        x3 = self.conv3(x2)  # self.maxpool2(x2))
+        x4 = self.conv4(x3)  # self.maxpool3(x3))
+
+        x = self.up1(x4, x3)
+        x = self.up2(x, x2)
+        x = self.up3(x, x1)
+        #x = changeDim(x, im)
+        x = self.last(x)
+
+        #x = x[:, :3, :, :] #cambio teorico
+
+        if self.depth:
+          dep = self.upDep1(x4, x3)
+          dep = self.upDep2(dep, x2)
+          dep = self.upDep3(dep, x1)
+          # x = changeDim(x, im)
+          dep = self.lastDep(dep)
+          return x, dep
+        else:
+          return x,imDep
+
+
+class depth_discriminator_UNet(nn.Module):
+    def __init__(self, input_dim=1, output_dim=1, input_shape=[8, 7, 128, 128], class_num=2, expand_net=2):
+        super(depth_discriminator_UNet, self).__init__()
+        self.input_dim = input_dim * 2 + 1
+
+        #discriminator_UNet.__init__(self, input_dim=self.input_dim, output_dim=output_dim, input_shape=input_shape,
+        #                            class_num=class_num, expand_net = expand_net)
+
+        self.output_dim = output_dim
+        self.input_shape = list(input_shape)
+        self.class_num = class_num
+        self.expandNet = expand_net
+
+        self.input_dim = input_dim * 2 + 1 # ya que le doy el origen + mapa de profundidad
+        self.conv1 = UnetConvBlock(self.input_dim, pow(2, self.expandNet), stride=1, dropout=0.3)
+        self.conv2 = UnetConvBlock(pow(2, self.expandNet), pow(2, self.expandNet + 1), stride=2, dropout=0.2)
+        self.conv3 = UnetConvBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 2), stride=2, dropout=0.2)
+        self.conv4 = UnetDeSingleConvBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), stride=2,
+                                           dropout=0.3)
+
+        self.input_shape[1] = self.input_dim
+        self.n_size = self._get_conv_output(self.input_shape)
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(self.n_size, 1024),
+        )
+
+        self.BnLr = nn.Sequential(
+            nn.BatchNorm1d(1024),
+            nn.LeakyReLU(0.2),
+        )
+
+        self.dc = nn.Sequential(
+            nn.Linear(1024, self.output_dim),
+            #nn.Sigmoid(),
+        )
+        self.cl = nn.Sequential(
+            nn.Linear(1024, self.class_num),
+            # nn.Softmax(dim=1),  # poner el que la suma da 1
+        )
+
+        utils.initialize_weights(self)
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        x = input.squeeze()
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = x.view(x.size(0), -1)
+        return x.shape[1]
+
+    def forward(self, input, origen, dep):
+        # esto va a cambiar cuando tenga color
+        # if (len(input.shape) <= 3):
+        #    input = input[:, None, :, :]
+        # im = im[:, None, :, :]
+        # print("D in shape",input.shape)
+
+        # print(input.shape)
+        # print("this si X:", x)
+        # print("now shape", x.shape)
+        x = input
+
+        x = torch.cat((x, origen), 1)
+        x = torch.cat((x, dep), 1)
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = x.view(x.size(0), -1)
+        features = self.fc1(x)
+        x = self.BnLr(features)
+        d = self.dc(x)
+        c = self.cl(x)
+
+        return d, c, features
+
+class depth_discriminator_noclass_UNet(nn.Module):
+    def __init__(self, input_dim=1, output_dim=1, input_shape=[8, 7, 128, 128], class_num=2, expand_net=2, depth=True, wgan = False):
+        super(depth_discriminator_noclass_UNet, self).__init__()
+
+        #discriminator_UNet.__init__(self, input_dim=self.input_dim, output_dim=output_dim, input_shape=input_shape,
+        #                            class_num=class_num, expand_net = expand_net)
+
+        self.output_dim = output_dim
+        self.input_shape = list(input_shape)
+        self.class_num = class_num
+        self.expandNet = expand_net
+        self.depth = depth
+        self.wgan = wgan
+
+        if depth:
+          self.input_dim = input_dim * 2 + 2 # ya que le doy el origen + Dep + class
+        else:
+          self.input_dim = input_dim * 2 + 1 # ya que le doy el origen + class
+        self.conv1 = UnetConvBlock(self.input_dim, pow(2, self.expandNet), stride=1, dropout=0.0, batch_norm = False )
+        self.conv2 = UnetConvBlock(pow(2, self.expandNet), pow(2, self.expandNet + 1), stride=2, dropout=0.0, batch_norm = False )
+        self.conv3 = UnetConvBlock(pow(2, self.expandNet + 1), pow(2, self.expandNet + 2), stride=2, dropout=0.0, batch_norm = False )
+        self.conv4 = UnetConvBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 3), stride=2, dropout=0.0, batch_norm = False )
+        self.conv5 = UnetDeSingleConvBlock(pow(2, self.expandNet + 3), pow(2, self.expandNet + 2), stride=1, dropout=0.0, batch_norm = False )
+
+        self.lastconvs = []
+        imagesize = self.input_shape[2] / 8
+        while imagesize > 4:
+          self.lastconvs.append(UnetDeSingleConvBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 2), stride=2, dropout=0.0, batch_norm = False ))
+          imagesize = imagesize/2
+        else:
+          self.lastconvs.append(UnetDeSingleConvBlock(pow(2, self.expandNet + 2), pow(2, self.expandNet + 1), stride=1, dropout=0.0, batch_norm = False ))
+
+        self.input_shape[1] = self.input_dim
+        self.n_size = self._get_conv_output(self.input_shape)
+
+        for layer in self.lastconvs:
+          layer = layer.cuda()
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(self.n_size, 256),
+        )
+
+        self.BnLr = nn.Sequential(
+            nn.BatchNorm1d(256),
+            nn.LeakyReLU(0.2),
+        )
+
+        self.dc = nn.Sequential(
+            nn.Linear(256, self.output_dim),
+            #nn.Sigmoid(),
+        )
+
+        utils.initialize_weights(self)
+
+    def _get_conv_output(self, shape):
+        bs = 1
+        input = Variable(torch.rand(bs, *shape))
+        x = input.squeeze()
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = self.conv5(x)
+        for layer in self.lastconvs:
+          x = layer(x)
+        x = x.view(x.size(0), -1)
+        return x.shape[1]
+
+    def forward(self, input, origen, dep, clase):
+        # esto va a cambiar cuando tenga color
+        # if (len(input.shape) <= 3):
+        #    input = input[:, None, :, :]
+        # im = im[:, None, :, :]
+        # print("D in shape",input.shape)
+
+        # print(input.shape)
+        # print("this si X:", x)
+        # print("now shape", x.shape)
+        x = input
+        ##unir layer el rgb de la imagen
+        x = torch.cat((x, clase), 1)
+
+        x = torch.cat((x, origen), 1)
+        if self.depth:
+          x = torch.cat((x, dep), 1)
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = self.conv5(x)
+        for layer in self.lastconvs:
+          x = layer(x)
+        feature_vector = x.view(x.size(0), -1)
+        x = self.fc1(feature_vector)
+        x = self.BnLr(x)
+        d = self.dc(x)
+
+        return d, feature_vector

config.ini

@@ -0,0 +1,259 @@
+
+[validation]
+total = 50
+0 = 2822
+1 = 3038
+2 = 3760
+3 = 3512
+4 = 3349
+5 = 2812
+6 = 3383
+7 = 3606
+8 = 3612
+9 = 3666
+10 = 2933
+11 = 3613
+12 = 2881
+13 = 3609
+14 = 3066
+15 = 3654
+16 = 2821
+17 = 2784
+18 = 3186
+19 = 3138
+20 = 3187
+21 = 3482
+22 = 2701
+23 = 3320
+24 = 3716
+25 = 3501
+26 = 3441
+27 = 3768
+28 = 3158
+29 = 2841
+30 = 3466
+31 = 3547
+32 = 2920
+33 = 3439
+34 = 2669
+35 = 3183
+36 = 2760
+37 = 3605
+38 = 2941
+39 = 3729
+40 = 2958
+41 = 3745
+42 = 3417
+43 = 3218
+44 = 3093
+45 = 3699
+46 = 3255
+47 = 3616
+48 = 3623
+49 = 3590
+50 = 3496
+[test]
+total = 1
+[train]
+total = 200
+0 = 3192
+1 = 3086
+2 = 3205
+3 = 3061
+4 = 2688
+5 = 3347
+6 = 2850
+7 = 3508
+8 = 3285
+9 = 3487
+10 = 3433
+11 = 2687
+12 = 2860
+13 = 3353
+14 = 3526
+15 = 3112
+16 = 3123
+17 = 3109
+18 = 2825
+19 = 3114
+20 = 3413
+21 = 2876
+22 = 2910
+23 = 3339
+24 = 3011
+25 = 2753
+26 = 3551
+27 = 2942
+28 = 2998
+29 = 3370
+30 = 3560
+31 = 3446
+32 = 3017
+33 = 3703
+34 = 3327
+35 = 3498
+36 = 2884
+37 = 2934
+38 = 2671
+39 = 2871
+40 = 2727
+41 = 3144
+42 = 3393
+43 = 3693
+44 = 2761
+45 = 2895
+46 = 3537
+47 = 3735
+48 = 2755
+49 = 2710
+50 = 3379
+51 = 3475
+52 = 2750
+53 = 3390
+54 = 3189
+55 = 2817
+56 = 3765
+57 = 3653
+58 = 2776
+59 = 3568
+60 = 2782
+61 = 3079
+62 = 3283
+63 = 2999
+64 = 3586
+65 = 2740
+66 = 3651
+67 = 3549
+68 = 3106
+69 = 3160
+70 = 3092
+71 = 2940
+72 = 3603
+73 = 3733
+74 = 3371
+75 = 3290
+76 = 3091
+77 = 2978
+78 = 3730
+79 = 2961
+80 = 2748
+81 = 3094
+82 = 2914
+83 = 3490
+84 = 3120
+85 = 3759
+86 = 2715
+87 = 3287
+88 = 3723
+89 = 3776
+90 = 3305
+91 = 2830
+92 = 3313
+93 = 3368
+94 = 2944
+95 = 2925
+96 = 3780
+97 = 2680
+98 = 3622
+99 = 3065
+100 = 2905
+101 = 3346
+102 = 3397
+103 = 2875
+104 = 3262
+105 = 2783
+106 = 3485
+107 = 3234
+108 = 3330
+109 = 3099
+110 = 3625
+111 = 3540
+112 = 3523
+113 = 3279
+114 = 3280
+115 = 3428
+116 = 3372
+117 = 3497
+118 = 3626
+119 = 2733
+120 = 3578
+121 = 3593
+122 = 3700
+123 = 3167
+124 = 2848
+125 = 2775
+126 = 3726
+127 = 3425
+128 = 3751
+129 = 3520
+130 = 3458
+131 = 3164
+132 = 3381
+133 = 2873
+134 = 2890
+135 = 3548
+136 = 3728
+137 = 2745
+138 = 3041
+139 = 3663
+140 = 3098
+141 = 3631
+142 = 3127
+143 = 3704
+144 = 3658
+145 = 3629
+146 = 3467
+147 = 2676
+148 = 3178
+149 = 3275
+150 = 3324
+151 = 2756
+152 = 3200
+153 = 3034
+154 = 3749
+155 = 3558
+156 = 3173
+157 = 3792
+158 = 2681
+159 = 3367
+160 = 3579
+161 = 3155
+162 = 3128
+163 = 2816
+164 = 2973
+165 = 3246
+166 = 3129
+167 = 3762
+168 = 2939
+169 = 2929
+170 = 3711
+171 = 3608
+172 = 2679
+173 = 3214
+174 = 3687
+175 = 3291
+176 = 2700
+177 = 3131
+178 = 3597
+179 = 3519
+180 = 3481
+181 = 2725
+182 = 3761
+183 = 3610
+184 = 3073
+185 = 3135
+186 = 2891
+187 = 3769
+188 = 3557
+189 = 2967
+190 = 2697
+191 = 2861
+192 = 2956
+193 = 3052
+194 = 2995
+195 = 3054
+196 = 3588
+197 = 2960
+198 = 2952
+199 = 2766
+200 = 2917

dataloader.py

@@ -0,0 +1,301 @@
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+from torch.utils.data import Dataset
+import torch
+from configparser import ConfigParser
+import matplotlib.pyplot as plt
+import os
+import torch as th
+from PIL import Image
+import numpy as np
+import random
+from PIL import ImageMath
+import random
+
+def dataloader(dataset, input_size, batch_size,dim,split='train', trans=False):
+    #transform = transforms.Compose([transforms.Resize((input_size, input_size)), transforms.ToTensor(),
+    #                                transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))])
+    if dataset == 'mnist':
+        data_loader = DataLoader(
+            datasets.MNIST('data/mnist', train=True, download=True, transform=transform),
+            batch_size=batch_size, shuffle=True)
+    elif dataset == 'fashion-mnist':
+        data_loader = DataLoader(
+            datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transform),
+            batch_size=batch_size, shuffle=True)
+    elif dataset == 'cifar10':
+        data_loader = DataLoader(
+            datasets.CIFAR10('data/cifar10', train=True, download=True, transform=transform),
+            batch_size=batch_size, shuffle=True)
+    elif dataset == 'svhn':
+        data_loader = DataLoader(
+            datasets.SVHN('data/svhn', split=split, download=True, transform=transform),
+            batch_size=batch_size, shuffle=True)
+    elif dataset == 'stl10':
+        data_loader = DataLoader(
+            datasets.STL10('data/stl10', split=split, download=True, transform=transform),
+            batch_size=batch_size, shuffle=True)
+    elif dataset == 'lsun-bed':
+        data_loader = DataLoader(
+            datasets.LSUN('data/lsun', classes=['bedroom_train'], transform=transform),
+            batch_size=batch_size, shuffle=True)
+    elif dataset == '4cam':
+        if split == 'score':
+            cams = ScoreDataset(root_dir=os.getcwd() + '/Images/Score-Test', dim=dim, name=split, cant_images=300) #hardcode is bad but quick
+            return DataLoader(cams, batch_size=batch_size, shuffle=False, num_workers=0)
+        if split != 'test':
+            cams = ImagesDataset(root_dir=os.getcwd() + '/Images/ActualDataset', dim=dim, name=split, transform=trans)
+            return DataLoader(cams, batch_size=batch_size, shuffle=True, num_workers=0)
+        else:
+            cams = TestingDataset(root_dir=os.getcwd() + '/Images/Input-Test', dim=dim, name=split)
+            return DataLoader(cams, batch_size=batch_size, shuffle=False, num_workers=0)
+
+    return data_loader
+
+
+class ImagesDataset(Dataset):
+    """My dataset."""
+
+    def __init__(self, root_dir, dim, name, transform):
+        """
+        Args:
+            root_dir (string): Directory with all the images.
+            transform (callable, optional): Optional transform to be applied
+                on a sample.
+        """
+        self.root_dir = root_dir
+        self.nCameras = 2
+        self.imageDim = dim
+        self.name = name
+        self.parser = ConfigParser()
+        self.parser.read('config.ini')
+        self.transform = transform
+
+    def __len__(self):
+
+        return self.parser.getint(self.name, 'total')
+        #oneCameRoot = self.root_dir + '\CAM1'
+        #return int(len([name for name in os.listdir(oneCameRoot) if os.path.isfile(os.path.join(oneCameRoot, name))])/2) #por el depth
+
+
+    def __getitem__(self, idx):
+        if th.is_tensor(idx):
+            idx = idx.tolist()
+        idx = self.parser.get(self.name, str(idx))
+        if self.transform:
+            brighness = random.uniform(0.7, 1.2)
+            saturation = random.uniform(0, 2)
+            contrast = random.uniform(0.4, 2)
+            gamma = random.uniform(0.7, 1.3)
+            hue = random.uniform(-0.3, 0.3)  # 0.01
+
+        oneCameRoot = self.root_dir + '/CAM0'
+
+        # foto normal
+        img_name = os.path.join(oneCameRoot, "n_" + idx + ".png")
+        img = Image.open(img_name).convert('RGB')  # .convert('L')
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        if self.transform:
+            img = transforms.functional.adjust_gamma(img, gamma)
+            img = transforms.functional.adjust_brightness(img, brighness)
+            img = transforms.functional.adjust_contrast(img, contrast)
+            img = transforms.functional.adjust_saturation(img, saturation)
+            img = transforms.functional.adjust_hue(img, hue)
+        x1 = transforms.ToTensor()(img)
+        x1 = (x1 * 2) - 1
+
+        # foto produndidad
+        img_name = os.path.join(oneCameRoot, "d_" + idx + ".png")
+        img = Image.open(img_name).convert('I')
+        img = convert_I_to_L(img)
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x1_dep = transforms.ToTensor()(img)
+        x1_dep = (x1_dep * 2) - 1
+
+        oneCameRoot = self.root_dir + '/CAM1'
+
+        # foto normal
+        img_name = os.path.join(oneCameRoot, "n_" + idx + ".png")
+        img = Image.open(img_name).convert('RGB')  # .convert('L')
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        if self.transform:
+            img = transforms.functional.adjust_gamma(img, gamma)
+            img = transforms.functional.adjust_brightness(img, brighness)
+            img = transforms.functional.adjust_contrast(img, contrast)
+            img = transforms.functional.adjust_saturation(img, saturation)
+            img = transforms.functional.adjust_hue(img, hue)
+        x2 = transforms.ToTensor()(img)
+        x2 = (x2 * 2) - 1
+
+        # foto produndidad
+        img_name = os.path.join(oneCameRoot, "d_" + idx + ".png")
+        img = Image.open(img_name).convert('I')
+        img = convert_I_to_L(img)
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x2_dep = transforms.ToTensor()(img)
+        x2_dep = (x2_dep * 2) - 1
+
+
+        #random izq o derecha
+        if (bool(random.getrandbits(1))):
+            sample = {'x_im': x1, 'x_dep': x1_dep, 'y_im': x2, 'y_dep': x2_dep, 'y_': torch.ones(1, self.imageDim, self.imageDim)}
+        else:
+            sample = {'x_im': x2, 'x_dep': x2_dep, 'y_im': x1, 'y_dep': x1_dep, 'y_': torch.zeros(1, self.imageDim, self.imageDim)}
+
+        return sample
+
+    def __iter__(self):
+
+        for i in range(this.__len__()):
+            list.append(this.__getitem__(i))
+        return iter(list)
+
+class TestingDataset(Dataset):
+    """My dataset."""
+
+    def __init__(self, root_dir, dim, name):
+        """
+        Args:
+            root_dir (string): Directory with all the images.
+            transform (callable, optional): Optional transform to be applied
+                on a sample.
+        """
+        self.root_dir = root_dir
+        self.imageDim = dim
+        self.name = name
+        files = os.listdir(self.root_dir)
+        self.files = [ele for ele in files if not ele.endswith('_d.png')]
+
+    def __len__(self):
+
+        #return self.parser.getint(self.name, 'total')
+        #oneCameRoot = self.root_dir + '\CAM1'
+        #return int(len([name for name in os.listdir(self.root_dir) if os.path.isfile(os.path.join(self.root_dir, name))])/2) #por el depth
+        return len(self.files)
+
+
+    def __getitem__(self, idx):
+        if th.is_tensor(idx):
+            idx = idx.tolist()
+
+        # foto normal
+        img_name = os.path.join(self.root_dir, self.files[idx])
+        img = Image.open(img_name).convert('RGB')  # .convert('L')
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x1 = transforms.ToTensor()(img)
+        x1 = (x1 * 2) - 1
+
+
+        # foto produndidad
+        img_name = os.path.join(self.root_dir , self.files[idx][:-4] + "_d.png")
+        img = Image.open(img_name).convert('I')
+        img = convert_I_to_L(img)
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x1_dep = transforms.ToTensor()(img)
+        x1_dep = (x1_dep * 2) - 1
+
+        sample = {'x_im': x1, 'x_dep': x1_dep}
+
+        return sample
+
+    def __iter__(self):
+
+        for i in range(this.__len__()):
+            list.append(this.__getitem__(i))
+        return iter(list)
+
+
+def show_image(t_data, grey=False):
+
+    #from numpy
+    t_data2 = t_data.transpose(1, 2, 0)
+    t_data2 = t_data2 * 255.0
+    t_data2 = t_data2.astype(np.uint8)
+    if (not grey):
+        outIm = Image.fromarray(t_data2, mode='RGB')
+    else:
+        t_data2 = np.squeeze(t_data2, axis=2)
+        outIm = Image.fromarray(t_data2, mode='L')
+    outIm.show()
+
+def convert_I_to_L(img):
+    array = np.uint8(np.array(img) / 256) #el numero esta bien, sino genera espacios en negro en la imagen
+    return Image.fromarray(array)
+
+class ScoreDataset(Dataset):
+    """My dataset."""
+
+    def __init__(self, root_dir, dim, name, cant_images):
+        """
+        Args:
+            root_dir (string): Directory with all the images.
+            transform (callable, optional): Optional transform to be applied
+                on a sample.
+        """
+        self.root_dir = root_dir
+        self.nCameras = 2
+        self.imageDim = dim
+        self.name = name
+        self.size = cant_images
+
+    def __len__(self):
+
+        return self.size 
+
+
+    def __getitem__(self, idx):
+
+        oneCameRoot = self.root_dir + '/CAM0'
+
+        idx = "{:04d}".format(idx)
+        # foto normal
+        img_name = os.path.join(oneCameRoot, "n_" + idx + ".png")
+        img = Image.open(img_name).convert('RGB')  # .convert('L')
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x1 = transforms.ToTensor()(img)
+        x1 = (x1 * 2) - 1
+
+        # foto produndidad
+        img_name = os.path.join(oneCameRoot, "d_" + idx + ".png")
+        img = Image.open(img_name).convert('I')
+        img = convert_I_to_L(img)
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x1_dep = transforms.ToTensor()(img)
+        x1_dep = (x1_dep * 2) - 1
+
+        oneCameRoot = self.root_dir + '/CAM1'
+
+        # foto normal
+        img_name = os.path.join(oneCameRoot, "n_" + idx + ".png")
+        img = Image.open(img_name).convert('RGB')  # .convert('L')
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x2 = transforms.ToTensor()(img)
+        x2 = (x2 * 2) - 1
+
+        # foto produndidad
+        img_name = os.path.join(oneCameRoot, "d_" + idx + ".png")
+        img = Image.open(img_name).convert('I')
+        img = convert_I_to_L(img)
+        if (img.size[0] != self.imageDim or img.size[1] != self.imageDim):
+            img = img.resize((self.imageDim, self.imageDim))
+        x2_dep = transforms.ToTensor()(img)
+        x2_dep = (x2_dep * 2) - 1
+
+
+        sample = {'x_im': x1, 'x_dep': x1_dep, 'y_im': x2, 'y_dep': x2_dep, 'y_': torch.ones(1, self.imageDim, self.imageDim)}
+        return sample
+
+    def __iter__(self):
+
+        for i in range(self.__len__()):
+            list.append(self.__getitem__(i))
+        return iter(list)

epochData.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:baf9bf7acbc95f817b9f79d9be24fe553e8beeacda79854ebcfe9fc2707df120
+size 210

main.py

@@ -0,0 +1,136 @@
+import argparse
+import os
+import torch
+from WiggleGAN import WiggleGAN
+#from MyACGAN import MyACGAN
+#from MyGAN import MyGAN
+
+"""parsing and configuration"""
+
+
+def parse_args():
+    desc = "Pytorch implementation of GAN collections"
+    parser = argparse.ArgumentParser(description=desc)
+
+    parser.add_argument('--gan_type', type=str, default='WiggleGAN',
+                        choices=['MyACGAN', 'MyGAN', 'WiggleGAN'],
+                        help='The type of GAN')
+    parser.add_argument('--dataset', type=str, default='4cam',
+                        choices=['mnist', 'fashion-mnist', 'cifar10', 'cifar100', 'svhn', 'stl10', 'lsun-bed', '4cam'],
+                        help='The name of dataset')
+    parser.add_argument('--split', type=str, default='', help='The split flag for svhn and stl10')
+    parser.add_argument('--epoch', type=int, default=50, help='The number of epochs to run')
+    parser.add_argument('--batch_size', type=int, default=16, help='The size of batch')
+    parser.add_argument('--input_size', type=int, default=10, help='The size of input image')
+    parser.add_argument('--save_dir', type=str, default='models',
+                        help='Directory name to save the model')
+    parser.add_argument('--result_dir', type=str, default='results', help='Directory name to save the generated images')
+    parser.add_argument('--log_dir', type=str, default='logs', help='Directory name to save training logs')
+    parser.add_argument('--lrG', type=float, default=0.0002)
+    parser.add_argument('--lrD', type=float, default=0.001)
+    parser.add_argument('--beta1', type=float, default=0.5)
+    parser.add_argument('--beta2', type=float, default=0.999)
+    parser.add_argument('--gpu_mode', type=str2bool, default=True)
+    parser.add_argument('--benchmark_mode', type=str2bool, default=True)
+    parser.add_argument('--cameras', type=int, default=2)
+    parser.add_argument('--imageDim', type=int, default=128)
+    parser.add_argument('--epochV', type=int, default=0)
+    parser.add_argument('--cIm', type=int, default=4)
+    parser.add_argument('--seedLoad', type=str, default="-0000")
+    parser.add_argument('--zGF', type=float, default=0.2)
+    parser.add_argument('--zDF', type=float, default=0.2)
+    parser.add_argument('--bF', type=float, default=0.2)
+    parser.add_argument('--expandGen', type=int, default=3)
+    parser.add_argument('--expandDis', type=int, default=3)
+    parser.add_argument('--wiggleDepth', type=int, default=-1)
+    parser.add_argument('--visdom', type=str2bool, default=True)
+    parser.add_argument('--lambdaL1', type=int, default=100)
+    parser.add_argument('--clipping', type=float, default=-1)
+    parser.add_argument('--depth', type=str2bool, default=True)
+    parser.add_argument('--recreate', type=str2bool, default=False)
+    parser.add_argument('--name_wiggle', type=str, default='wiggle-result')
+
+    return check_args(parser.parse_args())
+
+
+"""checking arguments"""
+
+def str2bool(v):
+    if isinstance(v, bool):
+       return v
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+
+
+def check_args(args):
+    # --save_dir
+    if not os.path.exists(args.save_dir):
+        os.makedirs(args.save_dir)
+
+    # --result_dir
+    if not os.path.exists(args.result_dir):
+        os.makedirs(args.result_dir)
+
+    # --result_dir
+    if not os.path.exists(args.log_dir):
+        os.makedirs(args.log_dir)
+
+    # --epoch
+    try:
+        assert args.epoch >= 1
+    except:
+        print('number of epochs must be larger than or equal to one')
+
+    # --batch_size
+    try:
+        assert args.batch_size >= 1
+    except:
+        print('batch size must be larger than or equal to one')
+
+    return args
+
+
+"""main"""
+
+
+def main():
+    # parse arguments
+    args = parse_args()
+    if args is None:
+        exit()
+
+    if args.benchmark_mode:
+        torch.backends.cudnn.benchmark = True
+
+        # declare instance for GAN
+    if args.gan_type == 'WiggleGAN':
+        gan = WiggleGAN(args)
+    #elif args.gan_type == 'MyACGAN':
+    #    gan = MyACGAN(args)
+    #elif args.gan_type == 'MyGAN':
+    #    gan = MyGAN(args)
+    else:
+        raise Exception("[!] There is no option for " + args.gan_type)
+
+    # launch the graph in a session
+    if (args.wiggleDepth < 0 and not args.recreate):
+        print(" [*] Training Starting!")
+        gan.train()
+        print(" [*] Training finished!")
+    else:
+      if not args.recreate:
+            print(" [*] Wiggle Started!")
+            gan.wiggleEf()
+            print(" [*] Wiggle finished!")
+      else:
+            print(" [*] Dataset recreation Started")
+            gan.recreate()
+            print(" [*] Dataset recreation finished")
+
+
+if __name__ == '__main__':
+    main()

models/4cam/WiggleGAN/WiggleGAN_31219_110_G.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4b39604e99319045e9070632a7aa31cd5adbd0220126515093856f97af622ff
+size 1252850

models/4cam/WiggleGAN/WiggleGAN_66942_110_G.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da994f51205701f9754dc1688cffd12b72f593f37c61833ec4b7c8860e152236
+size 1252850

models/4cam/WiggleGAN/WiggleGAN_70466_110_G.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:310b22bf4f5375174b23347b85b64c9de7934cafec6a61b3d647bfb7f24b5ae7
+size 1252850

models/4cam/WiggleGAN/WiggleGAN_70944_110_G.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5734a5e102c75e4afde944f2898171fb34373c002b651ca84901ed9f55ae385d
+size 1252850

models/4cam/WiggleGAN/WiggleGAN_74962_110_G.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d06a0da4295b6b6c5277f3cf987327a60818460780fb3aec42e514cbc3f71c71
+size 1252850

models/4cam/WiggleGAN/WiggleGAN_82122_110_G.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:170c8e095c66665ef87f199e5308a39d90fe2f5d0f2dfa5d8c789675657e0423
+size 1252850

models/4cam/WiggleGAN/WiggleGAN_92332_110_G.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a9cbec7ad0978008bcda05a96865b71016663278ed18c935b25875f7b08a979
+size 1252850

pyvenv.cfg

@@ -0,0 +1,3 @@
+home = C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64
+include-system-site-packages = false
+version = 3.7.8

requirements.txt

@@ -1,4 +1,27 @@
 timm
-Pillow
+opencv-python
+certifi==2019.11.28
+chardet==3.0.4
+cycler==0.10.0
+idna==2.8
+imageio==2.5.0
+jsonpatch==1.24
+jsonpointer==2.0
+kiwisolver==1.1.0
+matplotlib==3.1.1
+numpy==1.17.2
+Pillow==6.1.0
+pyparsing==2.4.2
+python-dateutil==2.8.0
+PyYAML==5.1.2
+pyzmq==18.1.1
+requests==2.22.0
+scipy==1.1.0
+six==1.12.0
+urllib3==1.25.7
+visdom==0.1.8.9
+websocket-client==0.56.0
+tornado==6.0.3
 torch
-opencv-python
+torchfile==0.1.0
+torchvision==0.2.1

utils.py

@@ -0,0 +1,369 @@
+import os, gzip, torch
+import torch.nn as nn
+import numpy as np
+import scipy.misc
+import imageio
+import matplotlib.pyplot as plt
+from PIL import Image
+from torchvision import datasets, transforms
+import visdom
+import random
+
+def save_wiggle(images, rows=1, name="test"):
+
+
+    width = images[0].shape[1]
+    height = images[0].shape[2]
+    columns = int(len(images)/rows)
+    rows = int(rows)
+    margin = 4
+
+    total_width = (width + margin) * columns
+    total_height = (height + margin) * rows
+
+    new_im = Image.new('RGB', (total_width, total_height))
+
+    transToPil = transforms.ToPILImage()
+
+    x_offset = 3
+    y_offset = 3
+    for y in range(rows):
+        for x in range(columns):
+            im = images[x+y*columns]
+            im = transToPil((im+1)/2)
+            new_im.paste(im, (x_offset, y_offset))
+            x_offset += width + margin
+        x_offset = 3
+        y_offset += height + margin
+
+    new_im.save('./WiggleResults/' + name + '.jpg')
+
+def load_mnist(dataset):
+    data_dir = os.path.join("./data", dataset)
+
+    def extract_data(filename, num_data, head_size, data_size):
+        with gzip.open(filename) as bytestream:
+            bytestream.read(head_size)
+            buf = bytestream.read(data_size * num_data)
+            data = np.frombuffer(buf, dtype=np.uint8).astype(np.float)
+        return data
+
+    data = extract_data(data_dir + '/train-images-idx3-ubyte.gz', 60000, 16, 28 * 28)
+    trX = data.reshape((60000, 28, 28, 1))
+
+    data = extract_data(data_dir + '/train-labels-idx1-ubyte.gz', 60000, 8, 1)
+    trY = data.reshape((60000))
+
+    data = extract_data(data_dir + '/t10k-images-idx3-ubyte.gz', 10000, 16, 28 * 28)
+    teX = data.reshape((10000, 28, 28, 1))
+
+    data = extract_data(data_dir + '/t10k-labels-idx1-ubyte.gz', 10000, 8, 1)
+    teY = data.reshape((10000))
+
+    trY = np.asarray(trY).astype(np.int)
+    teY = np.asarray(teY)
+
+    X = np.concatenate((trX, teX), axis=0)
+    y = np.concatenate((trY, teY), axis=0).astype(np.int)
+
+    seed = 547
+    np.random.seed(seed)
+    np.random.shuffle(X)
+    np.random.seed(seed)
+    np.random.shuffle(y)
+
+    y_vec = np.zeros((len(y), 10), dtype=np.float)
+    for i, label in enumerate(y):
+        y_vec[i, y[i]] = 1
+
+    X = X.transpose(0, 3, 1, 2) / 255.
+    # y_vec = y_vec.transpose(0, 3, 1, 2)
+
+    X = torch.from_numpy(X).type(torch.FloatTensor)
+    y_vec = torch.from_numpy(y_vec).type(torch.FloatTensor)
+    return X, y_vec
+
+def load_celebA(dir, transform, batch_size, shuffle):
+    # transform = transforms.Compose([
+    #     transforms.CenterCrop(160),
+    #     transform.Scale(64)
+    #     transforms.ToTensor(),
+    #     transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
+    # ])
+
+    # data_dir = 'data/celebA'  # this path depends on your computer
+    dset = datasets.ImageFolder(dir, transform)
+    data_loader = torch.utils.data.DataLoader(dset, batch_size, shuffle)
+
+    return data_loader
+
+
+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)
+
+def save_images(images, size, image_path):
+    return imsave(images, size, image_path)
+
+def imsave(images, size, path):
+    image = np.squeeze(merge(images, size))
+    return scipy.misc.imsave(path, image)
+
+def merge(images, size):
+    #print ("shape", images.shape)
+    h, w = images.shape[1], images.shape[2]
+    if (images.shape[3] in (3,4)):
+        c = images.shape[3]
+        img = np.zeros((h * size[0], w * size[1], c))
+        for idx, image in enumerate(images):
+            i = idx % size[1]
+            j = idx // size[1]
+            img[j * h:j * h + h, i * w:i * w + w, :] = image
+        return img
+    elif images.shape[3]== 1:
+        img = np.zeros((h * size[0], w * size[1]))
+        for idx, image in enumerate(images):
+            #print("indez ",idx)
+            i = idx % size[1]
+            j = idx // size[1]
+            img[j * h:j * h + h, i * w:i * w + w] = image[:,:,0]
+        return img
+    else:
+        raise ValueError('in merge(images,size) images parameter ''must have dimensions: HxW or HxWx3 or HxWx4')
+
+def generate_animation(path, num):
+    images = []
+    for e in range(num):
+        img_name = path + '_epoch%04d' % (e+1) + '.png'
+        images.append(imageio.imread(img_name))
+    imageio.mimsave(path + '_generate_animation.gif', images, fps=5)
+
+def loss_plot(hist, path = 'Train_hist.png', model_name = ''):
+    x1 = range(len(hist['D_loss_train']))
+    x2 = range(len(hist['G_loss_train']))
+
+    y1 = hist['D_loss_train']
+    y2 = hist['G_loss_train']
+
+    if (x1 != x2):
+        y1 = [0.0] * (len(y2) - len(y1)) + y1
+        x1 = x2
+
+    plt.plot(x1, y1, label='D_loss_train')
+
+    plt.plot(x2, y2, label='G_loss_train')
+
+    plt.xlabel('Iter')
+    plt.ylabel('Loss')
+
+    plt.legend(loc=4)
+    plt.grid(True)
+    plt.tight_layout()
+
+    path = os.path.join(path, model_name + '_loss.png')
+
+    plt.savefig(path)
+
+    plt.close()
+
+def initialize_weights(net):
+    for m in net.modules():
+        if isinstance(m, nn.Conv2d):
+            m.weight.data.normal_(0, 0.02)
+            m.bias.data.zero_()
+        elif isinstance(m, nn.ConvTranspose2d):
+            m.weight.data.normal_(0, 0.02)
+            m.bias.data.zero_()
+        elif isinstance(m, nn.Linear):
+            m.weight.data.normal_(0, 0.02)
+            m.bias.data.zero_()
+
+class VisdomLinePlotter(object):
+    """Plots to Visdom"""
+    def __init__(self, env_name='main'):
+        self.viz = visdom.Visdom()
+        self.env = env_name
+        self.ini = False
+        self.count = 1
+    def plot(self, var_name,names, split_name, hist):
+
+
+
+        x = []
+        y = []
+        for i, name in enumerate(names):
+            x.append(self.count)
+            y.append(hist[name])
+        self.count+=1
+        #x1 = (len(hist['D_loss_' +split_name]))
+        #x2 = (len(hist['G_loss_' +split_name]))
+
+        #y1 = hist['D_loss_'+split_name]
+        #y2 = hist['G_loss_'+split_name]
+
+
+        np.array(x)
+
+
+        for i,n in enumerate(names):
+            x[i] = np.arange(1, x[i]+1)
+
+        if not self.ini:
+            for i, name in enumerate(names):
+                if i == 0:
+                    self.win = self.viz.line(X=x[i], Y=np.array(y[i]), env=self.env,name = name,opts=dict(
+                        title=var_name + '_'+split_name, showlegend = True
+                    ))
+                else:
+                    self.viz.line(X=x[i], Y=np.array(y[i]), env=self.env,win=self.win, name=name, update='append')
+            self.ini = True
+        else:
+            x[0] = np.array([x[0][-2], x[0][-1]])
+
+            for i,n in enumerate(names):
+                y[i] = np.array([y[i][-2], y[i][-1]])
+                self.viz.line(X=x[0], Y=np.array(y[i]), env=self.env, win=self.win, name=n, update='append')
+
+
+class VisdomLineTwoPlotter(VisdomLinePlotter):
+
+    def plot(self, var_name, epoch,names, hist):
+
+        x1 = epoch
+        y1 = hist[names[0]]
+        y2 = hist[names[1]]
+        y3 = hist[names[2]]
+        y4 = hist[names[3]]
+
+
+        #y1 = hist['D_loss_' + split_name]
+        #y2 = hist['G_loss_' + split_name]
+        #y3 = hist['D_loss_' + split_name2]
+        #y4 = hist['G_loss_' + split_name2]
+
+
+        #x1 = np.arange(1, x1+1)
+
+        if not self.ini:
+            self.win = self.viz.line(X=np.array([x1]), Y=np.array(y1), env=self.env,name = names[0],opts=dict(
+                title=var_name,
+                showlegend = True,
+                linecolor = np.array([[0, 0, 255]])
+            ))
+            self.viz.line(X=np.array([x1]), Y=np.array(y2), env=self.env,win=self.win, name=names[1],
+                          update='append', opts=dict(
+                    linecolor=np.array([[255, 153, 51]])
+                ))
+            self.viz.line(X=np.array([x1]), Y=np.array(y3), env=self.env, win=self.win, name=names[2],
+                          update='append', opts=dict(
+                    linecolor=np.array([[0, 51, 153]])
+                ))
+            self.viz.line(X=np.array([x1]), Y=np.array(y4), env=self.env, win=self.win, name=names[3],
+                          update='append', opts=dict(
+                    linecolor=np.array([[204, 51, 0]])
+                ))
+            self.ini = True
+        else:
+
+            y4 = np.array([y4[-2], y4[-1]])
+            y3 = np.array([y3[-2], y3[-1]])
+            y2 = np.array([y2[-2], y2[-1]])
+            y1 = np.array([y1[-2], y1[-1]])
+            x1 = np.array([x1 - 1, x1])
+            self.viz.line(X=x1, Y=np.array(y1), env=self.env, win=self.win, name=names[0], update='append')
+            self.viz.line(X=x1, Y=np.array(y2), env=self.env, win=self.win, name=names[1], update='append')
+            self.viz.line(X=x1, Y=np.array(y3), env=self.env, win=self.win, name=names[2],
+                          update='append')
+            self.viz.line(X=x1, Y=np.array(y4), env=self.env, win=self.win, name=names[3],
+                          update='append')
+
+class VisdomImagePlotter(object):
+    """Plots to Visdom"""
+    def __init__(self, env_name='main'):
+        self.viz = visdom.Visdom()
+        self.env = env_name
+    def plot(self, epoch,images,rows):
+
+        list_images = []
+        for image in images:
+            #transforms.ToPILImage()(image)
+            image = (image + 1)/2
+            image = image.detach().numpy() * 255
+            list_images.append(image)
+        self.viz.images(
+            list_images,
+            padding=2,
+            nrow =rows,
+            opts=dict(title="epoch: " + str(epoch)),
+            env=self.env
+        )
+
+
+def augmentData(x,y, randomness = 1, percent_noise = 0.1):
+    """
+    :param x: image X
+    :param y: image Y
+    :param randomness: Value of randomness (between 1 and 0)
+    :return: data x,y augmented
+    """
+
+
+    sampleX = torch.tensor([])
+    sampleY = torch.tensor([])
+
+    for aumX, aumY in zip(x,y):
+
+        # Preparing to get image # transforms.ToPILImage()(pil_to_tensor.squeeze_(0))
+        #percent_noise = percent_noise
+        #noise = torch.randn(aumX.shape)
+
+        #aumX = noise * percent_noise + aumX * (1 - percent_noise)
+        #aumY = noise * percent_noise + aumY * (1 - percent_noise)
+
+        aumX = (aumX + 1) / 2
+        aumY = (aumY + 1) / 2
+
+        imgX = transforms.ToPILImage()(aumX)
+        imgY = transforms.ToPILImage()(aumY)
+
+        # Values for augmentation #
+        brighness = random.uniform(0.7, 1.2)* randomness + (1-randomness)
+        saturation = random.uniform(0, 2)* randomness + (1-randomness)
+        contrast = random.uniform(0.4, 2)* randomness + (1-randomness)
+        gamma = random.uniform(0.7, 1.3)* randomness + (1-randomness)
+        hue = random.uniform(-0.3, 0.3)* randomness #0.01
+
+        imgX = transforms.functional.adjust_gamma(imgX, gamma)
+        imgX = transforms.functional.adjust_brightness(imgX, brighness)
+        imgX = transforms.functional.adjust_contrast(imgX, contrast)
+        imgX = transforms.functional.adjust_saturation(imgX, saturation)
+        imgX = transforms.functional.adjust_hue(imgX, hue)
+        #imgX.show()
+
+        imgY = transforms.functional.adjust_gamma(imgY, gamma)
+        imgY = transforms.functional.adjust_brightness(imgY, brighness)
+        imgY = transforms.functional.adjust_contrast(imgY, contrast)
+        imgY = transforms.functional.adjust_saturation(imgY, saturation)
+        imgY = transforms.functional.adjust_hue(imgY, hue)
+        #imgY.show()
+
+        sx = transforms.ToTensor()(imgX)
+        sx = (sx * 2)-1
+
+        sy = transforms.ToTensor()(imgY)
+        sy = (sy * 2)-1
+
+        sampleX = torch.cat((sampleX, sx.unsqueeze_(0)), 0)
+        sampleY = torch.cat((sampleY, sy.unsqueeze_(0)), 0)
+    return sampleX,sampleY
+
+def RGBtoL (x):
+
+    return x[:,0,:,:].unsqueeze(0).transpose(0,1)
+
+def LtoRGB (x):
+
+    return x.repeat(1, 3, 1, 1)