import imageio
import numpy as np
import sys
import matplotlib.pyplot as plt
from datetime import datetime
from load_dataset import load_train_patch, load_val_data
from model import PUNET
import utils
import vgg
# Processing command arguments
dataset_dir, model_dir, result_dir, vgg_dir, dslr_dir, phone_dir,\
arch, LEVEL, inst_norm, num_maps_base, restore_iter, patch_w, patch_h,\
batch_size, train_size, learning_rate, eval_step, num_train_iters, save_mid_imgs = \
utils.process_command_args(sys.argv)
# Defining the size of the input and target image patches
PATCH_WIDTH, PATCH_HEIGHT = patch_w//2, patch_h//2
DSLR_SCALE = float(1) / (2 ** (max(LEVEL,0) - 1))
TARGET_WIDTH = int(PATCH_WIDTH * DSLR_SCALE)
TARGET_HEIGHT = int(PATCH_HEIGHT * DSLR_SCALE)
TARGET_DEPTH = 3
TARGET_SIZE = TARGET_WIDTH * TARGET_HEIGHT * TARGET_DEPTH
np.random.seed(0)
# Defining the model architecture
with tf.Graph().as_default(), tf.compat.v1.Session() as sess:
time_start = datetime.now()
from torch.autograd import Variable
import numpy
from load_data import *
import loss
# defining size of the training image patches
PATCH_WIDTH = 100
PATCH_HEIGHT = 100
PATCH_SIZE = PATCH_WIDTH * PATCH_HEIGHT * 3
# processing command arguments
phone, batch_size, train_size, learning_rate, num_train_iters, \
w_content, w_color, w_texture, w_tv, w_ssim,\
dped_dir, vgg_dir, eval_step = lutils.process_command_args(sys.argv)
#np.random.seed(0)
# loading training and test data
print("Loading test data...")
test_data, test_answ = load_test_data(phone, dped_dir, PATCH_SIZE)
print("Test data was loaded\n")
print("Loading training data...")
train_data = trainset(dped_dir + '/iphone/', dped_dir + '/canon/')
#train_data = trainset(dped_dir + '/train/raw/', dped_dir + '/train/target/')
trainloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
print("Training data was loaded\n")
# <resolution> = {orig, high, medium, small, tiny}
# <use_gpu> = {true, false}
from scipy import misc
import numpy as np
import tensorflow as tf
from model import resnet
import utils
import os
import sys
from PIL import Image
import pywt
import cv2
# process command arguments
phone, resolution, use_gpu = utils.process_command_args(sys.argv)
# get all available image resolutions
res_sizes = utils.get_resolutions()
# get the specified image resolution
IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_SIZE = utils.get_specified_res(
res_sizes, phone, resolution)
# disable gpu if specified
config = tf.ConfigProto(
device_count={'GPU': 0}) if use_gpu == "false" else None
# create placeholders for input images
x_ = tf.compat.v1.placeholder(tf.float32, [None, IMAGE_SIZE])
x_image = tf.reshape(x_, [-1, IMAGE_HEIGHT, IMAGE_WIDTH, 3])
import sys
from load_data import LoadData, LoadVisualData
from msssim import MSSSIM
from model import PyNET
from vgg import vgg_19
from utils import normalize_batch, process_command_args
to_image = transforms.Compose([transforms.ToPILImage()])
np.random.seed(0)
torch.manual_seed(0)
# Processing command arguments
level, batch_size, learning_rate, restore_epoch, num_train_epochs, dataset_dir = process_command_args(
sys.argv)
dslr_scale = float(1) / (2**(level - 1))
# Dataset size
TRAIN_SIZE = 46839
TEST_SIZE = 1204
def train_model():
torch.backends.cudnn.deterministic = True
device = torch.device("cuda")
print("CUDA visible devices: " + str(torch.cuda.device_count()))
print("CUDA Device Name: " + str(torch.cuda.get_device_name(device)))
import vgg
from load_dataset import load_test_data, load_batch
from ssim import MultiScaleSSIM
# defining size of the training image patches
PATCH_WIDTH = 100
PATCH_HEIGHT = 100
PATCH_SIZE = PATCH_WIDTH * PATCH_HEIGHT * 3
# processing command arguments
phone, batch_size, train_size, learning_rate, num_train_iters, \
w_content, w_color, w_texture, w_tv, \
dped_dir, vgg_dir, eval_step, run, kernel_size, depth, blocks, \
parametric, s_conv, convdeconv = utils.process_command_args(sys.argv)
dirname = phone + "_" + run
if run == "":
dirname = phone
np.random.seed(0)
# loading training and test data
print("Loading testing data...")
test_data, test_answ = load_test_data(phone, dped_dir, PATCH_SIZE)
print("Loading training data...")
train_data, train_answ = load_batch(phone, dped_dir, train_size, PATCH_SIZE)
import sys
from load_dataset import load_test_data, load_batch
import models
import utils
# defining size of the training image patches
PATCH_WIDTH = 360
PATCH_HEIGHT = 240
PATCH_SIZE = PATCH_WIDTH * PATCH_HEIGHT * 3
# processing command arguments
batch_size, train_size, learning_rate, num_train_iters, \
w_color, dped_dir, eval_step = utils.process_command_args(sys.argv)
np.random.seed(0)
# loading training and test data
print("Loading test data...")
test_data, test_answ = load_test_data(PATCH_SIZE)
print("Test data was loaded\n")
print("Loading training data...")
train_data, train_answ = load_batch(dped_dir, train_size, PATCH_SIZE)
print("Training data was loaded\n")
TEST_SIZE = test_data.shape[0]
num_test_batches = int(test_data.shape[0] / batch_size)
from ssim import MultiScaleSSIM
import models
import utils
import vgg
from lpips.lpips_tf import lpips
# defining size of the training image patches
PATCH_WIDTH = 100
PATCH_HEIGHT = 100
PATCH_SIZE = PATCH_WIDTH * PATCH_HEIGHT * 3
# processing command arguments
phone, batch_size, train_size, starter_learning_rate, num_train_iters, \
w_content, w_color, w_gray, w_gradient, w_tv, w_laplacian, \
dped_dir, vgg_dir, eval_step, log_step, name = utils.process_command_args(sys.argv)
np.random.seed(0)
# loading training and test data
print("Loading test data...")
test_data, test_answ = load_test_data(phone, dped_dir, PATCH_SIZE)
print("Test data was loaded\n")
print("Loading training data...")
train_data, train_answ, num_of_image = load_batch(phone, dped_dir, train_size, PATCH_SIZE)
print("Training data was loaded\n")
print("Loading validation data...")
valid_data, valid_answ = load_valid_data(phone, dped_dir, PATCH_SIZE, num_of_image)
