Beispiel #1
0
def test(args):
    if args.gpu:
        ctx = [mx.gpu(0)]
    else:
        ctx = [mx.cpu(0)]
    if args.dataset == "Sony":
        out_channels = 12
        scale = 2
    else:
        out_channels = 27
        scale = 3

    # load data
    test_transform = utils.Compose([utils.ToTensor()])
    test_dataset = data.MyDataset(args.dataset,
                                  "test",
                                  transform=test_transform)
    test_loader = gluon.data.DataLoader(test_dataset,
                                        batch_size=1,
                                        last_batch='discard')
    unet = net.UNet(out_channels, scale)
    unet.load_params(args.model, ctx=ctx)
    batches = 0
    avg_psnr = 0.
    for img, gt in test_loader:
        batches += 1
        imgs = gluon.utils.split_and_load(img[0], ctx)
        label = gluon.utils.split_and_load(gt[0], ctx)
        outputs = []
        for x in imgs:
            outputs.append(unet(x))
        metric.update(label, outputs)
        avg_psnr += 10 * math.log10(1 / metric.get()[1])
        metric.reset()
    avg_psnr /= batches
    print('Test avg psnr: {:.3f}'.format(avg_psnr))
Beispiel #2
0
import torch.nn as nn
import bilinear_model
from torch.autograd import Variable
import data
from collections import OrderedDict
import os
import torch.backends.cudnn as cudnn
import math

os.environ["CUDA_VISIBLE_DEVICES"] = "1"

trainset = data.MyDataset('./CUB200/train_images_shuffle.txt',
                          transform=transforms.Compose([
                              transforms.Resize(448),
                              transforms.RandomHorizontalFlip(),
                              transforms.CenterCrop(448),
                              transforms.ToTensor(),
                              transforms.Normalize(mean=(0.485, 0.456, 0.406),
                                                   std=(0.229, 0.224, 0.225))
                          ]))
trainloader = torch.utils.data.DataLoader(trainset,
                                          batch_size=16,
                                          shuffle=True,
                                          num_workers=4)

testset = data.MyDataset('./CUB200/test_images_shuffle.txt',
                         transform=transforms.Compose([
                             transforms.Resize(448),
                             transforms.CenterCrop(448),
                             transforms.ToTensor(),
                             transforms.Normalize(mean=(0.485, 0.456, 0.406),
import model
import accuracy

parser = argparse.ArgumentParser(description='Compare to Tesseract OCR')
parser.add_argument('-m',
                    '--model',
                    metavar='m',
                    type=str,
                    default='model.pth')
parser.add_argument('input_dir', type=str, help='Input directory')

args = parser.parse_args()

device = torch.device('cpu')

dataset = data.MyDataset(args.input_dir)

net = model.MyNet().to(device)
net.load_state_dict(torch.load(args.model, map_location='cpu'))
net.eval()
torch.no_grad()

time_sum_tess = 0
time_sum_mynet = 0

accuracy_sum_tess = 0.0
accuracy_sum_mynet = 0.0

accuracy_worst_tess = float('inf')
accuracy_worst_mynet = float('inf')
Beispiel #4
0
import torchvision.transforms as transforms
import torch.nn as nn
from torch.autograd import Variable
import data
from collections import OrderedDict
import os
import torch.backends.cudnn as cudnn
import math
from PIL import Image
import han_model
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

trainset = data.MyDataset('D:/Zhen/LMX/LMX/data/train_images_shuffle.txt', transform=transforms.Compose([
                                                transforms.Resize((512, 512), Image.BILINEAR),
                                                transforms.RandomHorizontalFlip(),
                                                transforms.RandomCrop(448),
                                                transforms.ToTensor(),
                                                transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
                                                ]))
trainloader = torch.utils.data.DataLoader(trainset, batch_size=16,
                                          shuffle=True, num_workers=4)

testset = data.MyDataset('D:/Zhen/LMX/LMX/data/test_images_shuffle.txt', transform=transforms.Compose([
                                                transforms.Resize((512, 512), Image.BILINEAR),
                                                transforms.CenterCrop(448),
                                                transforms.ToTensor(),
                                                transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
                                                ]))
testloader = torch.utils.data.DataLoader(testset, batch_size=8,
                                         shuffle=False, num_workers=4)
cudnn.benchmark = True
Beispiel #5
0
def train(args):
    np.random.seed(args.seed)
    if args.gpu:
        ctx = [mx.gpu(0)]
    else:
        ctx = [mx.cpu(0)]
    if args.dataset == "Sony":
        out_channels = 12
        scale = 2
    else:
        out_channels = 27
        scale = 3

    # load data
    train_transform = utils.Compose([
        utils.RandomCrop(args.patch_size, scale),
        utils.RandomFlipLeftRight(),
        utils.RandomFlipTopBottom(),
        utils.RandomTranspose(),
        utils.ToTensor(),
    ])
    train_dataset = data.MyDataset(args.dataset,
                                   "train",
                                   transform=train_transform)
    val_transform = utils.Compose([utils.ToTensor()])
    val_dataset = data.MyDataset(args.dataset, "val", transform=val_transform)
    train_loader = gluon.data.DataLoader(train_dataset,
                                         shuffle=True,
                                         batch_size=args.batch_size,
                                         last_batch='rollover')
    val_loader = gluon.data.DataLoader(val_dataset,
                                       batch_size=1,
                                       last_batch='discard')
    unet = net.UNet(out_channels, scale)
    unet.initialize(init=initializer.Xavier(), ctx=ctx)

    # optimizer and loss
    trainer = gluon.Trainer(unet.collect_params(), 'adam',
                            {'learning_rate': args.lr})
    l1_loss = gluon.loss.L1Loss()

    print "Start training now.."
    for i in range(args.epochs):
        total_loss = 0
        count = 0
        profiler.set_state('run')
        for batch_id, (img, gt) in enumerate(train_loader):
            batch_size = img.shape[0]
            count += batch_size
            img_list = gluon.utils.split_and_load(img[0], ctx)
            gt_list = gluon.utils.split_and_load(gt[0], ctx)
            with autograd.record():
                preds = [unet(x) for x in img_list]
                losses = []
                for ii in range(len(preds)):
                    loss = l1_loss(gt_list[ii], preds[ii])
                    losses.append(loss)
            for loss in losses:
                loss.backward()
            total_loss += sum([l.sum().asscalar() for l in losses])
            avg_loss = total_loss / count
            trainer.step(batch_size)
            metric.update(gt_list, preds)
            F.waitall()
            profiler.set_state('stop')
            print profiler.dumps()
            break
            gt_save = gt_list[0]
            output_save = preds[0]

            if (batch_id + 1) % 100 == 0:
                message = "Epoch {}: [{}/{}]: l1_loss: {:.4f}".format(
                    i + 1, count, len(train_dataset), avg_loss)
                print message
        temp = F.concat(gt_save, output_save, dim=3)
        temp = temp.asnumpy().reshape(temp.shape[2], temp.shape[3], 3)
        scipy.misc.toimage(temp * 255,
                           high=255,
                           low=0,
                           cmin=0,
                           cmax=255,
                           mode='RGB').save(args.save_model_dir +
                                            '%04d_%05d_00_train.jpg' %
                                            (i + 1, count))

        # evaluate
        batches = 0
        avg_psnr = 0.
        for img, gt in val_loader:
            batches += 1
            imgs = gluon.utils.split_and_load(img[0], ctx)
            label = gluon.utils.split_and_load(gt[0], ctx)
            outputs = []
            for x in imgs:
                outputs.append(unet(x))
            metric.update(label, outputs)
            avg_psnr += 10 * math.log10(1 / metric.get()[1])
            metric.reset()
        avg_psnr /= batches
        print('Epoch {}: validation avg psnr: {:.3f}'.format(i + 1, avg_psnr))

        # save model
        if (i + 1) % args.save_freq == 0:
            save_model_filename = "Epoch_" + str(i + 1) + ".params"
            save_model_path = os.path.join(args.save_model_dir,
                                           save_model_filename)
            unet.save_params(save_model_path)
            print("\nCheckpoint, trained model saved at", save_model_path)

    # save model
    save_model_filename = "Final_Epoch_" + str(i + 1) + ".params"
    save_model_path = os.path.join(args.save_model_dir, save_model_filename)
    unet.save_params(save_model_path)
    print("\nCheckpoint, trained model saved at", save_model_path)
Beispiel #6
0
import torchvision.transforms as transforms
import torch.nn as nn
from torch.autograd import Variable
import data
from collections import OrderedDict
import os
import torch.backends.cudnn as cudnn
import math
from PIL import Image
import hbp_model
os.environ["CUDA_VISIBLE_DEVICES"] = "1"

trainset = data.MyDataset('/data/guijun/caffe-20160312/examples/compact_bilinear/train_images_shuffle.txt', transform=transforms.Compose([
                                                transforms.Resize((600, 600), Image.BILINEAR),
                                                transforms.RandomHorizontalFlip(),

                                                transforms.RandomCrop(448),
                                                transforms.ToTensor(),
                                                transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
                                                ]))
trainloader = torch.utils.data.DataLoader(trainset, batch_size=16,
                                          shuffle=True, num_workers=4)

testset = data.MyDataset('/data/guijun/caffe-20160312/examples/compact_bilinear/test_images_shuffle.txt', transform=transforms.Compose([
                                                transforms.Resize((600, 600), Image.BILINEAR),
                                                transforms.CenterCrop(448),
                                                transforms.ToTensor(),
                                                transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
                                                ]))
testloader = torch.utils.data.DataLoader(testset, batch_size=8,
                                         shuffle=False, num_workers=4)
cudnn.benchmark = True
import numpy as np

import models
import data
import utils

parser = argparse.ArgumentParser("Test multimodal VAE.")
parser.add_argument("-opts", help="option file", type=str, required=True)
parser.add_argument("-banned", help="banned modalities", nargs="+", type=int, required=True)
parser.add_argument("-prefix", help="output prefix", type=str, required=True)
args = parser.parse_args()

opts = yaml.safe_load(open(args.opts, "r"))
print(yaml.dump(opts))

testset = data.MyDataset("data", modality=["endpoint", "joint"], action=["grasp", "move"], mode="test")

model = models.MultiVAE(
    in_blocks=opts["in_blocks"],
    in_shared=opts["in_shared"],
    out_shared=opts["out_shared"],
    out_blocks=opts["out_blocks"],
    init=opts["init_method"])
model.to(opts["device"])
model.load(opts["save"], "multivae_last")
model.cpu().eval()
print(model)

out_folder = os.path.join(opts["save"], "outs")
yje = torch.zeros(7)
zje = torch.zeros(7)
Beispiel #8
0
from matplotlib.backends.backend_pdf import PdfPages

import models
import data
import utils

parser = argparse.ArgumentParser("Test multimodal VAE.")
parser.add_argument("-opts", help="option file", type=str, required=True)
parser.add_argument("-banned", help="banned modalities", nargs="+", type=int, required=True)
parser.add_argument("-prefix", help="output prefix", type=str, required=True)
args = parser.parse_args()

opts = yaml.safe_load(open(args.opts, "r"))
print(yaml.dump(opts))

trainset = data.MyDataset(opts["data"], modality=opts["modality"], action=opts["action"], mode="train")
testset = data.MyDataset(opts["data"], modality=opts["modality"], action=opts["action"], mode="test")

model = models.MultiVAE(
    in_blocks=opts["in_blocks"],
    in_shared=opts["in_shared"],
    out_shared=opts["out_shared"],
    out_blocks=opts["out_blocks"],
    init=opts["init_method"])
model.to(opts["device"])
model.load(opts["save"], "multivae_best")
model.cpu().eval()
print(model)

out_folder = os.path.join(opts["save"], "outs")
if not os.path.exists(out_folder):
Beispiel #9
0
opts = yaml.safe_load(open(args.opts, "r"))
if not os.path.exists(opts["save"]):
    os.makedirs(opts["save"])
opts["time"] = time.asctime(time.localtime(time.time()))
dev = opts["device"]
file = open(os.path.join(opts["save"], "opts.yaml"), "w")
yaml.dump(opts, file)
file.close()
print(yaml.dump(opts))

logdir = os.path.join(opts["save"], "log")
writer = SummaryWriter(logdir)

idx = torch.randperm(opts["traj_count"])[:opts["traj_count"]].tolist()

trainset = data.MyDataset(opts["data"], modality=opts["modality"], action=opts["action"], mode="train", traj_list=idx)
valset = data.MyDataset(opts["data"], modality=opts["modality"], action=opts["action"], mode="val")

trainloader = torch.utils.data.DataLoader(trainset, batch_size=opts["batch_size"], shuffle=True)
valloader = torch.utils.data.DataLoader(valset, batch_size=10000, shuffle=False)
val_sample = iter(valloader).next()
x_val = trainset.normalize(val_sample)
x_val = [x.to(dev) for x in x_val]

model = models.MultiVAE(
    in_blocks=opts["in_blocks"],
    in_shared=opts["in_shared"],
    out_shared=opts["out_shared"],
    out_blocks=opts["out_blocks"],
    init=opts["init_method"])
model.to(dev)
Beispiel #10
0
    transform = torchvision.transforms.Compose([
        torchvision.transforms.Resize(config.image_size),
        # RandomCrop(224),
        torchvision.transforms.RandomHorizontalFlip(),
        torchvision.transforms.ToTensor()
    ])
    test_transform = torchvision.transforms.Compose([
        torchvision.transforms.Resize(config.image_size),
        # CenterCrop(224),
        torchvision.transforms.ToTensor()
    ])

    print('Loading dataset ...')
    src_dataset = data.MyDataset(path=src_domain_dir,
                                 labels='all',
                                 transform=transform)
    label2index = src_dataset.label2index
    tgt_dataset = data.MyDataset(path=tgt_domain_dir,
                                 labels=data.shared_classes,
                                 transform=transform,
                                 label2index=label2index)
    src_test_dataset = data.MyDataset(path=src_domain_dir,
                                      labels='all',
                                      transform=test_transform,
                                      label2index=label2index)
    tgt_test_dataset = data.MyDataset(path=tgt_domain_dir,
                                      labels=data.shared_classes,
                                      transform=test_transform,
                                      label2index=label2index)