diff --git a/mainalex20view.py b/mainalex20view.py
deleted file mode 100755
index 32053a4..0000000
--- a/mainalex20view.py
+++ /dev/null
@@ -1,341 +0,0 @@
-import argparse
-import os
-import shutil
-import time
-
-import torch
-import torch.nn as nn
-import torch.nn.parallel
-import torch.backends.cudnn as cudnn
-import torch.optim
-import torch.utils.data
-import torchvision.transforms as transforms
-import torchvision.datasets as datasets
-import alexnetgru20view
-from dataset20view import MVDataSet
-from transforms import *
-
-
-parser = argparse.ArgumentParser(description='PyTorch ImageNet Training')
-
-
-model_names = '123'
-parser.add_argument('--arch', '-a', metavar='ARCH', default='vgg19',
-                    choices=model_names,
-                    help='model architecture: ' + ' | '.join(model_names) +
-                    ' (default: vgg19)')
-
-
-
-parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
-                    help='number of data loading workers (default: 4)')
-parser.add_argument('--epochs', default=40, type=int, metavar='N',
-                    help='number of total epochs to run')
-parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
-                    help='manual epoch number (useful on restarts)')
-parser.add_argument('-b', '--batch-size', default=64, type=int,
-                    metavar='N', help='mini-batch size (default: 128)')
-parser.add_argument('--lr', '--learning-rate', default=0.005, type=float,
-                    metavar='LR', help='initial learning rate')
-parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
-                    help='momentum')
-parser.add_argument('--weight-decay', '--wd', default=5e-4, type=float,
-                    metavar='W', help='weight decay (default: 5e-4)')
-parser.add_argument('--print-freq', '-p', default=20, type=int,
-                    metavar='N', help='print frequency (default: 20)')
-parser.add_argument('--resume', default='', type=str, metavar='PATH',
-                    help='path to latest checkpoint (default: none)')
-parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
-                    help='evaluate model on validation set')
-parser.add_argument('--pretrained', dest='pretrained', action='store_true',
-                    help='use pre-trained model')
-parser.add_argument('--half', dest='half', action='store_true',
-                    help='use half-precision(16-bit) ')
-parser.add_argument('--save-dir', dest='save_dir',
-                    help='The directory used to save the trained models',
-                    default='save_temp', type=str)
-
-
-best_prec1 = 0
-
-
-def main():
-    global args, best_prec1
-    args = parser.parse_args()
-
-
-    # Check the save_dir exists or not
-    if not os.path.exists(args.save_dir):
-        os.makedirs(args.save_dir)
-
-    model = alexnetgru20view.alexnet(pretrained = True,)
-    model.features = torch.nn.DataParallel(model.features)
-    train_augmentation = model.get_augmentation()
-
-    model.cuda()
-    if args.resume:
-        if os.path.isfile(args.resume):
-            print("=> loading checkpoint '{}'".format(args.resume))
-            checkpoint = torch.load(args.resume)
-            args.start_epoch = checkpoint['epoch']
-            best_prec1 = checkpoint['best_prec1']
-            model.load_state_dict(checkpoint['state_dict'])
-            print("=> loaded checkpoint '{}' (epoch {})"
-                  .format(args.evaluate, checkpoint['epoch']))
-        else:
-            print ("=> no checkpoint found at '{}'".format(args.resume))
-
-    cudnn.benchmark = True
-
-    #normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
-    #                                 std=[0.229, 0.224, 0.225])
-
-    normalize = GroupNormalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])
-
-    crop_size = model.crop_size
-    scale_size = model.scale_size
-
-    train_loader = torch.utils.data.DataLoader(
-        MVDataSet("", "trainmodel40.txt", num_segments=0,
-                   new_length=1,
-                   modality="RGB",
-                   image_tmpl="_{:03d}.png",
-                   transform=torchvision.transforms.Compose([
-                       train_augmentation,
-                       #GroupScale(int(scale_size)),
-                       #GroupCenterCrop(crop_size),
-                       Stack(roll=False),
-                       ToTorchFormatTensor(div=True),
-                       normalize,
-                   ])),
-        batch_size=args.batch_size, shuffle=True,
-        num_workers=args.workers, pin_memory=True)
-
-    val_loader = torch.utils.data.DataLoader(
-        MVDataSet("", "testmodel40.txt", num_segments=0,
-                   new_length=1,
-                   modality="RGB",
-                   image_tmpl="_{:03d}.png",
-                   random_shift=False,
-                   transform=torchvision.transforms.Compose([
-                       GroupScale(int(scale_size)),
-                       GroupCenterCrop(crop_size),
-                       Stack(roll=False),
-                       ToTorchFormatTensor(div=True),
-                       normalize,
-                   ])),
-        batch_size=args.batch_size, shuffle=False,
-        num_workers=args.workers, pin_memory=True)
-
-
-    # define loss function (criterion) and pptimizer
-    criterion = nn.CrossEntropyLoss().cuda()
-
-    if args.half:
-        model.half()
-        criterion.half()
-
-    count = 0
-    change = []
-    freeze = []
-
-    for m in model.features.modules():
-            if isinstance(m, torch.nn.Conv2d) or isinstance(m, torch.nn.Conv1d):
-                ps = list(m.parameters())
-                count += 1
-                if count > 1:
-                    change.extend(ps)
-                else:
-                    freeze.extend(ps)
-
-    optimizer = torch.optim.SGD( [
-            {'params': freeze, 'lr_mult': 1, 'decay_mult': 1},
-            {'params': change, 'lr_mult': 1, 'decay_mult': 1},
-            {'params': model.classifier.parameters(), 'lr_mult': 1, 'decay_mult': 1},
-            {'params': model.fc.parameters(), 'lr_mult': 1, 'decay_mult': 1},
-            {'params': model.gru.parameters(), 'lr_mult': 1, 'decay_mult': 1},
-        ], args.lr,momentum=args.momentum,weight_decay=args.weight_decay)
-
-
-    if args.evaluate:
-        validate(val_loader, model, criterion)
-        return
-
-    for epoch in range(args.start_epoch, args.epochs):
-        adjust_learning_rate(optimizer, epoch)
-
-        train(train_loader, model, criterion, optimizer, epoch)
-        prec1 = validate(val_loader, model, criterion)
-
-        # remember best prec@1 and save checkpoint
-        is_best = prec1 > best_prec1
-        best_prec1 = max(prec1, best_prec1)
-        save_checkpoint({
-            'epoch': epoch + 1,
-            'state_dict': model.state_dict(),
-            'best_prec1': best_prec1,
-        }, is_best, filename=os.path.join(args.save_dir, 'checkpoint_{}.tar'.format(epoch)))
-
-
-def train(train_loader, model, criterion, optimizer, epoch):
-    """
-        Run one train epoch
-    """
-    batch_time = AverageMeter()
-    data_time = AverageMeter()
-    losses = AverageMeter()
-    top1 = AverageMeter()
-
-    # switch to train mode
-    model.train()
-
-    end = time.time()
-    for i, (input, target) in enumerate(train_loader):
-
-        inputsz = input.size()
-        #input = input.view((inputsz[0]*inputsz[1]/3,3,inputsz[2],inputsz[3]))
-
-        # measure data loading time
-        data_time.update(time.time() - end)
-        target = target.cuda()
-        #target = target.cuda(async=True)
-        input_var = torch.autograd.Variable(input).cuda()
-        input_var = input_var.view((inputsz[0]*inputsz[1]//3,3,inputsz[2],inputsz[3]))
-
-        target_var = torch.autograd.Variable(target)
-        if args.half:
-            input_var = input_var.half()
-
-        # compute output
-        output = model(input_var)
-        loss = criterion(output, target_var)
-
-        # compute gradient and do SGD step
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-
-        output = output.float()
-        loss = loss.float()
-        # measure accuracy and record loss
-        prec1 = accuracy(output.data, target)[0]
-        losses.update(loss.data[0], input.size(0))
-        top1.update(prec1[0], input.size(0))
-
-        # measure elapsed time
-        batch_time.update(time.time() - end)
-        end = time.time()
-
-        if i % args.print_freq == 0:
-            print('Epoch: [{0}][{1}/{2}]\t'
-                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
-                  'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
-                  'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
-                  'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
-                      epoch, i, len(train_loader), batch_time=batch_time,
-                      data_time=data_time, loss=losses, top1=top1))
-
-
-def validate(val_loader, model, criterion):
-    """
-    Run evaluation
-    """
-    batch_time = AverageMeter()
-    losses = AverageMeter()
-    top1 = AverageMeter()
-
-    # switch to evaluate mode
-    model.eval()
-
-    end = time.time()
-    for i, (input, target) in enumerate(val_loader):
-        inputsz = input.size()
-        input = input.view((inputsz[0]*inputsz[1]//3,3,inputsz[2],inputsz[3]))
-        target = target.cuda()
-        #target = target.cuda(async=True)
-        input_var = torch.autograd.Variable(input, volatile=True).cuda()
-        target_var = torch.autograd.Variable(target, volatile=True)
-
-        if args.half:
-            input_var = input_var.half()
-
-        # compute output
-        output = model(input_var)
-        loss = criterion(output, target_var)
-
-        output = output.float()
-        loss = loss.float()
-
-        # measure accuracy and record loss
-        prec1 = accuracy(output.data, target)[0]
-        losses.update(loss.data[0], input.size(0))
-        top1.update(prec1[0], input.size(0))
-
-        # measure elapsed time
-        batch_time.update(time.time() - end)
-        end = time.time()
-
-        if i % args.print_freq == 0:
-            print('Test: [{0}/{1}]\t'
-                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
-                  'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
-                  'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
-                      i, len(val_loader), batch_time=batch_time, loss=losses,
-                      top1=top1))
-
-    print(' * Prec@1 {top1.avg:.3f}'
-          .format(top1=top1))
-
-    return top1.avg
-
-def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
-    """
-    Save the training model
-    """
-    torch.save(state, filename)
-
-class AverageMeter(object):
-    """Computes and stores the average and current value"""
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.val = 0
-        self.avg = 0
-        self.sum = 0
-        self.count = 0
-
-    def update(self, val, n=1):
-        self.val = val
-        self.sum += val * n
-        self.count += n
-        self.avg = self.sum / self.count
-
-
-def adjust_learning_rate(optimizer, epoch):
-    print("come here")
-    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
-    lr = args.lr * (0.5 ** (epoch // 10))
-    for param_group in optimizer.param_groups: 
-        print("come on")
-        param_group['lr'] = lr * param_group['lr_mult']
-        param_group['weight_decay'] = args.weight_decay * param_group['decay_mult']
-
-def accuracy(output, target, topk=(1,)):
-    """Computes the precision@k for the specified values of k"""
-    maxk = max(topk)
-    batch_size = target.size(0)
-
-    _, pred = output.topk(maxk, 1, True, True)
-    pred = pred.t()
-    correct = pred.eq(target.view(1, -1).expand_as(pred))
-
-    res = []
-    for k in topk:
-        correct_k = correct[:k].view(-1).float().sum(0)
-        res.append(correct_k.mul_(100.0 / batch_size))
-    return res
-
-
-if __name__ == '__main__':
-    main()
diff --git a/mainalex6view.py b/mainalex6view.py
deleted file mode 100755
index 10f1d71..0000000
--- a/mainalex6view.py
+++ /dev/null
@@ -1,345 +0,0 @@
-import argparse
-import os
-import shutil
-import time
-
-import torch
-import torch.nn as nn
-import torch.nn.parallel
-import torch.backends.cudnn as cudnn
-import torch.optim
-import torch.utils.data
-import torchvision.transforms as transforms
-import torchvision.datasets as datasets
-import alexnetgru6view
-from dataset6view import MVDataSet
-from transforms import *
-
-
-parser = argparse.ArgumentParser(description='PyTorch ImageNet Training')
-
-
-model_names = '123'
-parser.add_argument('--arch', '-a', metavar='ARCH', default='vgg19',
-                    choices=model_names,
-                    help='model architecture: ' + ' | '.join(model_names) +
-                    ' (default: vgg19)')
-
-
-
-parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
-                    help='number of data loading workers (default: 4)')
-parser.add_argument('--epochs', default=30, type=int, metavar='N',
-                    help='number of total epochs to run')
-parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
-                    help='manual epoch number (useful on restarts)')
-parser.add_argument('-b', '--batch-size', default=128, type=int,
-                    metavar='N', help='mini-batch size (default: 128)')
-parser.add_argument('--lr', '--learning-rate', default=0.005, type=float,
-                    metavar='LR', help='initial learning rate')
-parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
-                    help='momentum')
-parser.add_argument('--weight-decay', '--wd', default=5e-4, type=float,
-                    metavar='W', help='weight decay (default: 5e-4)')
-parser.add_argument('--print-freq', '-p', default=20, type=int,
-                    metavar='N', help='print frequency (default: 20)')
-parser.add_argument('--resume', default='', type=str, metavar='PATH',
-                    help='path to latest checkpoint (default: none)')
-parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
-                    help='evaluate model on validation set')
-parser.add_argument('--pretrained', dest='pretrained', action='store_true',
-                    help='use pre-trained model')
-parser.add_argument('--half', dest='half', action='store_true',
-                    help='use half-precision(16-bit) ')
-parser.add_argument('--save-dir', dest='save_dir',
-                    help='The directory used to save the trained models',
-                    default='save_temp', type=str)
-
-
-best_prec1 = 0
-
-
-def main():
-    global args, best_prec1
-    args = parser.parse_args()
-
-
-    # Check the save_dir exists or not
-    if not os.path.exists(args.save_dir):
-        os.makedirs(args.save_dir)
-
-    model = alexnetgru6view.alexnet(pretrained = True,)
-    model.features = torch.nn.DataParallel(model.features)
-    train_augmentation = model.get_augmentation()
-
-    model.cuda()
-    if args.resume:
-        if os.path.isfile(args.resume):
-            print("=> loading checkpoint '{}'".format(args.resume))
-            checkpoint = torch.load(args.resume)
-            args.start_epoch = checkpoint['epoch']
-            best_prec1 = checkpoint['best_prec1']
-            model.load_state_dict(checkpoint['state_dict'])
-            print("=> loaded checkpoint '{}' (epoch {})"
-                  .format(args.evaluate, checkpoint['epoch']))
-        else:
-            print ("=> no checkpoint found at '{}'".format(args.resume))
-
-    cudnn.benchmark = True
-
-    normalize = GroupNormalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])
-
-    crop_size = model.crop_size
-    scale_size = model.scale_size
-
-    train_loader = torch.utils.data.DataLoader(
-        MVDataSet("", "trainmodel40.txt", num_segments=0,
-                   new_length=1,
-                   modality="RGB",
-                   image_tmpl="_{:03d}.jpg",
-                   transform=torchvision.transforms.Compose([
-                       train_augmentation,
-                       Stack(roll=False),
-                       ToTorchFormatTensor(div=True),
-                       normalize,
-                   ])),
-        batch_size=args.batch_size, shuffle=True,
-        num_workers=args.workers, pin_memory=True)
-
-    val_loader = torch.utils.data.DataLoader(
-        MVDataSet("", "testmodel40.txt", num_segments=0,
-                   new_length=1,
-                   modality="RGB",
-                   image_tmpl="_{:03d}.jpg",
-                   random_shift=False,
-                   transform=torchvision.transforms.Compose([
-                       GroupScale(int(scale_size)),
-                       GroupCenterCrop(crop_size),
-                       Stack(roll=False),
-                       ToTorchFormatTensor(div=True),
-                       normalize,
-                   ])),
-        batch_size=args.batch_size, shuffle=False,
-        num_workers=args.workers, pin_memory=True)
-
-
-    # define loss function (criterion) and pptimizer
-    criterion = nn.CrossEntropyLoss().cuda()
-
-    if args.half:
-        model.half()
-        criterion.half()
-
-    count = 0
-    change = []
-    freeze = []
-
-    for m in model.features.modules():
-            if isinstance(m, torch.nn.Conv2d) or isinstance(m, torch.nn.Conv1d):
-                ps = list(m.parameters())
-                count += 1
-                if count > 3:
-                    change.extend(ps)
-                else:
-                    freeze.extend(ps)
-
-    optimizer = torch.optim.SGD( [
-            {'params': freeze, 'lr_mult': 1, 'decay_mult': 1},
-            {'params': change, 'lr_mult': 1, 'decay_mult': 1},
-            {'params': model.gru.parameters(), 'lr_mult': 1, 'decay_mult': 1},
-            {'params': model.classifier.parameters(), 'lr_mult': 1, 'decay_mult': 1},
-            {'params': model.fc.parameters(), 'lr_mult': 1, 'decay_mult': 1},
-        ], args.lr,momentum=args.momentum,weight_decay=args.weight_decay)
-
-
-
-
-    if args.evaluate:
-        validate(val_loader, model, criterion)
-        return
-
-    for epoch in range(args.start_epoch, args.epochs):
-        adjust_learning_rate(optimizer, epoch)
-        train(train_loader, model, criterion, optimizer, epoch)
-        prec1 = validate(val_loader, model, criterion)
-
-        # remember best prec@1 and save checkpoint
-        is_best = prec1 > best_prec1
-        best_prec1 = max(prec1, best_prec1)
-        save_checkpoint({
-            'epoch': epoch + 1,
-            'state_dict': model.state_dict(),
-            'best_prec1': best_prec1,
-        }, is_best, filename=os.path.join(args.save_dir, 'checkpoint_{}.tar'.format(epoch)))
-
-
-def train(train_loader, model, criterion, optimizer, epoch):
-    """
-        Run one train epoch
-    """
-    batch_time = AverageMeter()
-    data_time = AverageMeter()
-    losses = AverageMeter()
-    top1 = AverageMeter()
-
-    # switch to train mode
-    model.train()
-
-    end = time.time()
-    for i, (input, target) in enumerate(train_loader):
-
-        inputsz = input.size()
-
-        #input = input.view((inputsz[0]*inputsz[1]/3,3,inputsz[2],inputsz[3]))
-
-        # measure data loading time
-        data_time.update(time.time() - end)
-
-        target = target.cuda(async=True)
-        input_var = torch.autograd.Variable(input).cuda()
-        input_var = input_var.view((-1,3)+inputsz[-2:])
-
-        #input_var2 = torch.autograd.Variable(input2).cuda()
-        #input_var2 = input_var2.view((-1,3)+inputsz[-2:])
-        #print(input_var2[1] - input_var[1])
-
- 
-        target_var = torch.autograd.Variable(target)
-        if args.half:
-            input_var = input_var.half()
-
-        # compute output
-        output = model(input_var)
-        #output2 = model(input_var2)
-        
-        loss = criterion(output, target_var)
-
-        # compute gradient and do SGD step
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-
-        output = output.float()
-        loss = loss.float()
-        # measure accuracy and record loss
-        prec1 = accuracy(output.data, target)[0]
-        losses.update(loss.data[0], input.size(0))
-        top1.update(prec1[0], input.size(0))
-
-        # measure elapsed time
-        batch_time.update(time.time() - end)
-        end = time.time()
-
-        if i % args.print_freq == 0:
-            print('Epoch: [{0}][{1}/{2}]\t'
-                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
-                  'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
-                  'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
-                  'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
-                      epoch, i, len(train_loader), batch_time=batch_time,
-                      data_time=data_time, loss=losses, top1=top1))
-
-
-def validate(val_loader, model, criterion):
-    """
-    Run evaluation
-    """
-    batch_time = AverageMeter()
-    losses = AverageMeter()
-    top1 = AverageMeter()
-
-    # switch to evaluate mode
-    model.eval()
-
-    end = time.time()
-    for i, (input,target) in enumerate(val_loader):
-        inputsz = input.size()
-        input = input.view((inputsz[0]*inputsz[1]/3,3,inputsz[2],inputsz[3]))
-
-        target = target.cuda(async=True)
-        input_var = torch.autograd.Variable(input, volatile=True).cuda()
-        target_var = torch.autograd.Variable(target, volatile=True)
-
-        if args.half:
-            input_var = input_var.half()
-
-        # compute output
-        output = model(input_var)
-        loss = criterion(output, target_var)
-
-        output = output.float()
-        loss = loss.float()
-
-        # measure accuracy and record loss
-        prec1 = accuracy(output.data, target)[0]
-        losses.update(loss.data[0], input.size(0))
-        top1.update(prec1[0], input.size(0))
-
-        # measure elapsed time
-        batch_time.update(time.time() - end)
-        end = time.time()
-
-        if i % args.print_freq == 0:
-            print('Test: [{0}/{1}]\t'
-                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
-                  'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
-                  'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
-                      i, len(val_loader), batch_time=batch_time, loss=losses,
-                      top1=top1))
-
-    print(' * Prec@1 {top1.avg:.3f}'
-          .format(top1=top1))
-
-    return top1.avg
-
-def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
-    """
-    Save the training model
-    """
-    torch.save(state, filename)
-
-class AverageMeter(object):
-    """Computes and stores the average and current value"""
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.val = 0
-        self.avg = 0
-        self.sum = 0
-        self.count = 0
-
-    def update(self, val, n=1):
-        self.val = val
-        self.sum += val * n
-        self.count += n
-        self.avg = self.sum / self.count
-
-
-def adjust_learning_rate(optimizer, epoch):
-    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
-    lr = args.lr * (0.5 ** (epoch // 5))
-    
-    for param_group in optimizer.param_groups:
-        param_group['lr'] = lr * param_group['lr_mult']
-        param_group['weight_decay'] = args.weight_decay * param_group['decay_mult']
-
-
-def accuracy(output, target, topk=(1,)):
-    """Computes the precision@k for the specified values of k"""
-    maxk = max(topk)
-    batch_size = target.size(0)
-
-    _, pred = output.topk(maxk, 1, True, True)
-    pred = pred.t()
-    correct = pred.eq(target.view(1, -1).expand_as(pred))
-
-    res = []
-    for k in topk:
-        correct_k = correct[:k].view(-1).float().sum(0)
-        res.append(correct_k.mul_(100.0 / batch_size))
-    return res
-
-
-if __name__ == '__main__':
-    main()