docs: 면담확인서 업로드 및 코드 업로드

+The MIT License (MIT)
+
+Copyright (c) 2017-     Jiu XU
+Copyright (c) 2017-     Rakuten, Inc
+Copyright (c) 2017-     Rakuten Institute of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file

+# PyTorch VDSR
+Implementation of CVPR2016 Paper: "Accurate Image Super-Resolution Using 
+Very Deep Convolutional Networks"(http://cv.snu.ac.kr/research/VDSR/) in PyTorch
+
+## Usage
+### Training
+```
+usage: main_vdsr.py [-h] [--batchSize BATCHSIZE] [--nEpochs NEPOCHS] [--lr LR]
+               [--step STEP] [--cuda] [--resume RESUME]
+               [--start-epoch START_EPOCH] [--clip CLIP] [--threads THREADS]
+               [--momentum MOMENTUM] [--weight-decay WEIGHT_DECAY]
+               [--pretrained PRETRAINED] [--gpus GPUS]
+               
+optional arguments:
+  -h, --help            Show this help message and exit
+  --batchSize           Training batch size
+  --nEpochs             Number of epochs to train for
+  --lr                  Learning rate. Default=0.01
+  --step                Learning rate decay, Default: n=10 epochs
+  --cuda                Use cuda
+  --resume              Path to checkpoint
+  --clip                Clipping Gradients. Default=0.4
+  --threads             Number of threads for data loader to use Default=1
+  --momentum            Momentum, Default: 0.9
+  --weight-decay        Weight decay, Default: 1e-4
+  --pretrained PRETRAINED
+                        path to pretrained model (default: none)
+  --gpus GPUS           gpu ids (default: 0)
+```
+An example of training usage is shown as follows:
+```
+python main_vdsr.py --cuda --gpus 0
+```
+
+### Evaluation
+```
+usage: eval.py [-h] [--cuda] [--model MODEL] [--dataset DATASET]
+               [--scale SCALE] [--gpus GPUS]
+
+PyTorch VDSR Eval
+
+optional arguments:
+  -h, --help         show this help message and exit
+  --cuda             use cuda?
+  --model MODEL      model path
+  --dataset DATASET  dataset name, Default: Set5
+  --gpus GPUS        gpu ids (default: 0)
+```
+An example of training usage is shown as follows:
+```
+python eval.py --cuda --dataset Set5
+```
+
+### Demo
+```
+usage: demo.py [-h] [--cuda] [--model MODEL] [--image IMAGE] [--scale SCALE] [--gpus GPUS]
+               
+optional arguments:
+  -h, --help            Show this help message and exit
+  --cuda                Use cuda
+  --model               Model path. Default=model/model_epoch_50.pth
+  --image               Image name. Default=butterfly_GT
+  --scale               Scale factor, Default: 4
+  --gpus GPUS           gpu ids (default: 0)
+```
+An example of usage is shown as follows:
+```
+python eval.py --model model/model_epoch_50.pth --dataset Set5 --cuda
+```
+
+### Prepare Training dataset
+  - We provide a simple hdf5 format training sample in data folder with 'data' and 'label' keys, the training data is generated with Matlab Bicubic Interplotation, please refer [Code for Data Generation](https://github.com/twtygqyy/pytorch-vdsr/tree/master/data) for creating training files.
+
+### Performance
+  - We provide a pretrained VDSR model trained on [291](https://drive.google.com/open?id=1Rt3asDLuMgLuJvPA1YrhyjWhb97Ly742) images with data augmentation
+  - No bias is used in this implementation, and the gradient clipping's implementation is different from paper
+  - Performance in PSNR on Set5
+  
+| Scale        | VDSR Paper          | VDSR PyTorch|
+| ------------- |:-------------:| -----:|
+| 2x      | 37.53      | 37.65 |
+| 3x      | 33.66      | 33.77|
+| 4x      | 31.35      | 31.45 |
+
+### Result
+From left to right are ground truth, bicubic and vdsr
+<p>
+  <img src='Set5/butterfly_GT.bmp' height='200' width='200'/>
+  <img src='result/input.bmp' height='200' width='200'/>
+  <img src='result/output.bmp' height='200' width='200'/>
+</p>

+from torch.utils.data import Dataset
+from PIL import Image
+import os
+from glob import glob
+from torchvision import transforms
+from torch.utils.data.dataset import Dataset
+from torchvision import transforms
+import torch
+import pdb
+import math
+import numpy as np
+class FeatureDataset(Dataset):
+    def __init__(self, data_path, datatype, rescale_factor,valid):
+        self.data_path = data_path
+        self.datatype = datatype
+        self.rescale_factor = rescale_factor
+        if not os.path.exists(data_path):
+            raise Exception(f"[!] {self.data_path} not existed")
+        if(valid):
+            self.hr_path = os.path.join(self.data_path,'valid')
+            self.hr_path = os.path.join(self.hr_path,self.datatype)
+        else:
+            self.hr_path = os.path.join(self.data_path,'LR_2')
+            self.hr_path = os.path.join(self.hr_path,self.datatype)
+        print(self.hr_path)
+        self.hr_path = sorted(glob(os.path.join(self.hr_path, "*.*")))
+        self.hr_imgs = []
+        w,h = Image.open(self.hr_path[0]).size
+        self.width = int(w/16)
+        self.height = int(h/16)     
+        self.lwidth = int(self.width/self.rescale_factor)
+        self.lheight = int(self.height/self.rescale_factor)
+        print("lr: ({} {}), hr: ({} {})".format(self.lwidth,self.lheight,self.width,self.height))
+        for hr in self.hr_path:
+            hr_image = Image.open(hr)#.convert('RGB')\
+            for i in range(16):
+                for j in range(16):
+                    (left,upper,right,lower) = (i*self.width,j*self.height,(i+1)*self.width,(j+1)*self.height)
+                    crop = hr_image.crop((left,upper,right,lower))
+                    self.hr_imgs.append(crop)
+        
+    def __getitem__(self, idx):
+        hr_image = self.hr_imgs[idx]
+        transform = transforms.Compose([
+            transforms.Resize((self.lheight,self.lwidth),3),
+            transforms.ToTensor()
+        ])
+        return transform(hr_image), transforms.ToTensor()(hr_image)
+
+    def __len__(self):
+        return len(self.hr_path*16*16)
+
+def get_data_loader(data_path, feature_type, rescale_factor, batch_size, num_workers):
+    full_dataset = FeatureDataset(data_path,feature_type,rescale_factor,False)
+    train_size = int(0.9 * len(full_dataset))
+    test_size = len(full_dataset) - train_size
+    train_dataset, test_dataset = torch.utils.data.random_split(full_dataset, [train_size, test_size])
+    torch.manual_seed(3334)
+    train_loader = torch.utils.data.DataLoader(dataset=train_dataset,batch_size=batch_size,shuffle=True,num_workers=num_workers, pin_memory=False)
+    test_loader = torch.utils.data.DataLoader(dataset=test_dataset,batch_size=batch_size,shuffle=False,num_workers=num_workers, pin_memory=True)
+
+    return train_loader, test_loader
+
+def get_infer_dataloader(data_path, feature_type, rescale_factor, batch_size, num_workers):
+    dataset = FeatureDataset(data_path,feature_type,rescale_factor,True)
+    data_loader = torch.utils.data.DataLoader(dataset=dataset,batch_size=batch_size,shuffle=False,num_workers=num_workers,pin_memory=False)
+    return data_loader
\ No newline at end of file

+import torch.utils.data as data
+import torch
+import h5py
+
+class DatasetFromHdf5(data.Dataset):
+    def __init__(self, file_path):
+        super(DatasetFromHdf5, self).__init__()
+        hf = h5py.File(file_path)
+        self.data = hf.get('data')
+        self.target = hf.get('label')
+
+    def __getitem__(self, index):
+        return torch.from_numpy(self.data[index,:,:,:]).float(), torch.from_numpy(self.target[index,:,:,:]).float()
+        
+    def __len__(self):
+        return self.data.shape[0]
\ No newline at end of file

+import argparse, os
+import torch
+from torch.autograd import Variable
+from scipy.ndimage import imread
+from PIL import Image
+import numpy as np
+import time, math
+import matplotlib.pyplot as plt
+
+parser = argparse.ArgumentParser(description="PyTorch VDSR Demo")
+parser.add_argument("--cuda", action="store_true", help="use cuda?")
+parser.add_argument("--model", default="model/model_epoch_50.pth", type=str, help="model path")
+parser.add_argument("--image", default="butterfly_GT", type=str, help="image name")
+parser.add_argument("--scale", default=4, type=int, help="scale factor, Default: 4")
+parser.add_argument("--gpus", default="0", type=str, help="gpu ids (default: 0)")
+
+def PSNR(pred, gt, shave_border=0):
+    height, width = pred.shape[:2]
+    pred = pred[shave_border:height - shave_border, shave_border:width - shave_border]
+    gt = gt[shave_border:height - shave_border, shave_border:width - shave_border]
+    imdff = pred - gt
+    rmse = math.sqrt(np.mean(imdff ** 2))
+    if rmse == 0:
+        return 100
+    return 20 * math.log10(255.0 / rmse)
+    
+def colorize(y, ycbcr): 
+    img = np.zeros((y.shape[0], y.shape[1], 3), np.uint8)
+    img[:,:,0] = y
+    img[:,:,1] = ycbcr[:,:,1]
+    img[:,:,2] = ycbcr[:,:,2]
+    img = Image.fromarray(img, "YCbCr").convert("RGB")
+    return img
+
+opt = parser.parse_args()
+cuda = opt.cuda
+
+if cuda:
+    print("=> use gpu id: '{}'".format(opt.gpus))
+    os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpus
+    if not torch.cuda.is_available():
+            raise Exception("No GPU found or Wrong gpu id, please run without --cuda")
+
+
+model = torch.load(opt.model, map_location=lambda storage, loc: storage)["model"]
+
+im_gt_ycbcr = imread("Set5/" + opt.image + ".bmp", mode="YCbCr")
+im_b_ycbcr = imread("Set5/"+ opt.image + "_scale_"+ str(opt.scale) + ".bmp", mode="YCbCr")
+    
+im_gt_y = im_gt_ycbcr[:,:,0].astype(float)
+im_b_y = im_b_ycbcr[:,:,0].astype(float)
+
+psnr_bicubic = PSNR(im_gt_y, im_b_y,shave_border=opt.scale)
+
+im_input = im_b_y/255.
+
+im_input = Variable(torch.from_numpy(im_input).float()).view(1, -1, im_input.shape[0], im_input.shape[1])
+
+if cuda:
+    model = model.cuda()
+    im_input = im_input.cuda()
+else:
+    model = model.cpu()
+
+start_time = time.time()
+out = model(im_input)
+elapsed_time = time.time() - start_time
+
+out = out.cpu()
+
+im_h_y = out.data[0].numpy().astype(np.float32)
+
+im_h_y = im_h_y * 255.
+im_h_y[im_h_y < 0] = 0
+im_h_y[im_h_y > 255.] = 255.
+
+psnr_predicted = PSNR(im_gt_y, im_h_y[0,:,:], shave_border=opt.scale)
+
+im_h = colorize(im_h_y[0,:,:], im_b_ycbcr)
+im_gt = Image.fromarray(im_gt_ycbcr, "YCbCr").convert("RGB")
+im_b = Image.fromarray(im_b_ycbcr, "YCbCr").convert("RGB")
+
+print("Scale=",opt.scale)
+print("PSNR_predicted=", psnr_predicted)
+print("PSNR_bicubic=", psnr_bicubic)
+print("It takes {}s for processing".format(elapsed_time))
+
+fig = plt.figure()
+ax = plt.subplot("131")
+ax.imshow(im_gt)
+ax.set_title("GT")
+
+ax = plt.subplot("132")
+ax.imshow(im_b)
+ax.set_title("Input(bicubic)")
+
+ax = plt.subplot("133")
+ax.imshow(im_h)
+ax.set_title("Output(vdsr)")
+plt.show()

+import argparse, os
+import torch
+from torch.autograd import Variable
+import numpy as np
+import time, math, glob
+import scipy.io as sio
+
+parser = argparse.ArgumentParser(description="PyTorch VDSR Eval")
+parser.add_argument("--cuda", action="store_true", help="use cuda?")
+parser.add_argument("--model", default="model/model_epoch_50.pth", type=str, help="model path")
+parser.add_argument("--dataset", default="Set5", type=str, help="dataset name, Default: Set5")
+parser.add_argument("--gpus", default="0", type=str, help="gpu ids (default: 0)")
+
+def PSNR(pred, gt, shave_border=0):
+    height, width = pred.shape[:2]
+    pred = pred[shave_border:height - shave_border, shave_border:width - shave_border]
+    gt = gt[shave_border:height - shave_border, shave_border:width - shave_border]
+    imdff = pred - gt
+    rmse = math.sqrt(np.mean(imdff ** 2))
+    if rmse == 0:
+        return 100
+    return 20 * math.log10(255.0 / rmse)
+
+opt = parser.parse_args()
+cuda = opt.cuda
+
+if cuda:
+    print("=> use gpu id: '{}'".format(opt.gpus))
+    os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpus
+    if not torch.cuda.is_available():
+            raise Exception("No GPU found or Wrong gpu id, please run without --cuda")
+
+model = torch.load(opt.model, map_location=lambda storage, loc: storage)["model"]
+
+scales = [2,3,4]
+
+image_list = glob.glob(opt.dataset+"_mat/*.*") 
+
+for scale in scales:
+    avg_psnr_predicted = 0.0
+    avg_psnr_bicubic = 0.0
+    avg_elapsed_time = 0.0
+    count = 0.0
+    for image_name in image_list:
+        if str(scale) in image_name:
+            count += 1
+            print("Processing ", image_name)
+            im_gt_y = sio.loadmat(image_name)['im_gt_y']
+            im_b_y = sio.loadmat(image_name)['im_b_y']
+                       
+            im_gt_y = im_gt_y.astype(float)
+            im_b_y = im_b_y.astype(float)
+
+            psnr_bicubic = PSNR(im_gt_y, im_b_y,shave_border=scale)
+            avg_psnr_bicubic += psnr_bicubic
+
+            im_input = im_b_y/255.
+
+            im_input = Variable(torch.from_numpy(im_input).float()).view(1, -1, im_input.shape[0], im_input.shape[1])
+
+            if cuda:
+                model = model.cuda()
+                im_input = im_input.cuda()
+            else:
+                model = model.cpu()
+
+            start_time = time.time()
+            HR = model(im_input)
+            elapsed_time = time.time() - start_time
+            avg_elapsed_time += elapsed_time
+
+            HR = HR.cpu()
+
+            im_h_y = HR.data[0].numpy().astype(np.float32)
+
+            im_h_y = im_h_y * 255.
+            im_h_y[im_h_y < 0] = 0
+            im_h_y[im_h_y > 255.] = 255.
+            im_h_y = im_h_y[0,:,:]
+
+            psnr_predicted = PSNR(im_gt_y, im_h_y,shave_border=scale)
+            avg_psnr_predicted += psnr_predicted
+
+    print("Scale=", scale)
+    print("Dataset=", opt.dataset)
+    print("PSNR_predicted=", avg_psnr_predicted/count)
+    print("PSNR_bicubic=", avg_psnr_bicubic/count)
+    print("It takes average {}s for processing".format(avg_elapsed_time/count))

+import argparse, os
+import torch
+import random
+import torch.backends.cudnn as cudnn
+import torch.nn as nn
+import torch.optim as optim
+from torch.autograd import Variable
+from torch.utils.data import DataLoader
+from vdsr import Net
+from dataset import DatasetFromHdf5
+## Custom
+from data import FeatureDataset
+
+# Training settings
+parser = argparse.ArgumentParser(description="PyTorch VDSR")
+parser.add_argument("--batchSize", type=int, default=128, help="Training batch size")
+parser.add_argument("--nEpochs", type=int, default=50, help="Number of epochs to train for")
+parser.add_argument("--lr", type=float, default=0.1, help="Learning Rate. Default=0.1")
+parser.add_argument("--step", type=int, default=10, help="Sets the learning rate to the initial LR decayed by momentum every n epochs, Default: n=10")
+parser.add_argument("--cuda", action="store_true", help="Use cuda?")
+parser.add_argument("--resume", default="", type=str, help="Path to checkpoint (default: none)")
+parser.add_argument("--start-epoch", default=1, type=int, help="Manual epoch number (useful on restarts)")
+parser.add_argument("--clip", type=float, default=0.4, help="Clipping Gradients. Default=0.4")
+# 1->3 custom
+parser.add_argument("--threads", type=int, default=3, help="Number of threads for data loader to use, Default: 1")
+parser.add_argument("--momentum", default=0.9, type=float, help="Momentum, Default: 0.9")
+parser.add_argument("--weight-decay", "--wd", default=1e-4, type=float, help="Weight decay, Default: 1e-4")
+parser.add_argument('--pretrained', default='', type=str, help='path to pretrained model (default: none)')
+parser.add_argument("--gpus", default="0", type=str, help="gpu ids (default: 0)")
+## custom
+parser.add_argument("--dataPath", type=str)
+parser.add_argument("--featureType", type=str, default="p2")
+parser.add_argument("--scaleFactor",type=int, default=4)
+
+# parser.add_argument("--trainingData", type=DataLoader)
+
+
+def main():
+    global opt, model
+    opt = parser.parse_args()
+    print(opt)
+
+    cuda = opt.cuda
+    if cuda:
+        print("=> use gpu id: '{}'".format(opt.gpus))
+        os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpus
+        if not torch.cuda.is_available():
+                raise Exception("No GPU found or Wrong gpu id, please run without --cuda")
+
+    opt.seed = random.randint(1, 10000)
+    print("Random Seed: ", opt.seed)
+    torch.manual_seed(opt.seed)
+    if cuda:
+        torch.cuda.manual_seed(opt.seed)
+
+    cudnn.benchmark = True
+
+    print("===> Loading datasets")
+
+    if os.path.isfile('dataloader/training_data_loader.pth'):
+        training_data_loader = torch.load('dataloader/training_data_loader.pth')
+    else:
+        train_set = FeatureDataset(opt.dataPath,opt.featureType,opt.scaleFactor,False)
+        train_size = 100 #우선은 100개만
+        test_size = len(train_set) - train_size
+        train_dataset, test_dataset = torch.utils.data.random_split(train_set, [train_size, test_size])
+        training_data_loader = DataLoader(dataset=train_dataset, num_workers=3, batch_size=8, shuffle=True, pin_memory=False)
+        torch.save(training_data_loader, 'dataloader/training_data_loader.pth'.format(DataLoader))
+
+    print("===> Building model")
+    model = Net(opt.scaleFactor)
+    criterion = nn.MSELoss(size_average=False)
+
+    print("===> Setting GPU")
+    if cuda:
+        model = model.cuda()
+        criterion = criterion.cuda()
+
+    # optionally resume from a checkpoint
+    if opt.resume:
+        if os.path.isfile(opt.resume):
+            print("=> loading checkpoint '{}'".format(opt.resume))
+            checkpoint = torch.load(opt.resume)
+            opt.start_epoch = checkpoint["epoch"] + 1
+            model.load_state_dict(checkpoint["model"].state_dict())
+        else:
+            print("=> no checkpoint found at '{}'".format(opt.resume))
+
+    # optionally copy weights from a checkpoint
+    if opt.pretrained:
+        if os.path.isfile(opt.pretrained):
+            print("=> loading model '{}'".format(opt.pretrained))
+            weights = torch.load(opt.pretrained)
+            model.load_state_dict(weights['model'].state_dict())
+        else:
+            print("=> no model found at '{}'".format(opt.pretrained))  
+
+    print("===> Setting Optimizer")
+    optimizer = optim.SGD(model.parameters(), lr=opt.lr, momentum=opt.momentum, weight_decay=opt.weight_decay)
+
+    print("===> Training")
+    for epoch in range(opt.start_epoch, opt.nEpochs + 1):
+        train(training_data_loader, optimizer, model, criterion, epoch)
+        save_checkpoint(model, epoch)
+
+def adjust_learning_rate(optimizer, epoch):
+    """Sets the learning rate to the initial LR decayed by 10 every 10 epochs"""
+    lr = opt.lr * (0.1 ** (epoch // opt.step))
+    return lr
+
+def train(training_data_loader, optimizer, model, criterion, epoch):
+    lr = adjust_learning_rate(optimizer, epoch-1)
+
+    for param_group in optimizer.param_groups:
+        param_group["lr"] = lr
+
+    print("Epoch = {}, lr = {}".format(epoch, optimizer.param_groups[0]["lr"]))
+
+    model.train()
+
+    for iteration, batch in enumerate(training_data_loader, 1):
+        input, target = Variable(batch[0]), Variable(batch[1], requires_grad=False)
+
+        if opt.cuda:
+            input = input.cuda()
+            target = target.cuda()
+
+        loss = criterion(model(input), target)
+        optimizer.zero_grad()
+        loss.backward() 
+        nn.utils.clip_grad_norm(model.parameters(),opt.clip) 
+        optimizer.step()
+
+        if iteration%10 == 0:
+            # loss.data[0] --> loss.data
+            print("===> Epoch[{}]({}/{}): Loss: {:.10f}".format(epoch, iteration, len(training_data_loader), loss.data))
+
+def save_checkpoint(model, epoch):
+    model_out_path = "checkpoint/" + "model_epoch_{}.pth".format(epoch)
+    state = {"epoch": epoch ,"model": model}
+    if not os.path.exists("checkpoint/"):
+        os.makedirs("checkpoint/")
+
+    torch.save(state, model_out_path)
+
+    print("Checkpoint saved to {}".format(model_out_path))
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file

+import torch
+import torch.nn as nn
+from math import sqrt
+
+class Conv_ReLU_Block(nn.Module):
+    def __init__(self):
+        super(Conv_ReLU_Block, self).__init__()
+        self.conv = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1, bias=False)
+        self.relu = nn.ReLU(inplace=True)
+        
+    def forward(self, x):
+        return self.relu(self.conv(x))
+        
+class Net(nn.Module):
+    def __init__(self,upscale_factor):
+        super(Net, self).__init__()
+        self.residual_layer = self.make_layer(Conv_ReLU_Block, 18)
+        self.input = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=1, bias=False)
+        self.output = nn.Conv2d(in_channels=64, out_channels=1, kernel_size=3, stride=1, padding=1, bias=False)
+        self.upsample = nn.Upsample(scale_factor=upscale_factor, mode='bicubic')
+        self.relu = nn.ReLU(inplace=True)
+    
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, sqrt(2. / n))
+                
+    def make_layer(self, block, num_of_layer):
+        layers = []
+        for _ in range(num_of_layer):
+            layers.append(block())
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.upsample(x)
+        residual = x
+        out = self.relu(self.input(x))
+        out = self.residual_layer(out)
+        out = self.output(out)
+        out = torch.add(out,residual)
+        return out
+ 
\ No newline at end of file