Пример #1
0
        dataset_sizes = {'train': len(train_data), 'test': len(test_data)}
        dataloaders = dict()
        dataloaders['train'] = data.DataLoader(train_data,
                                            batch_size=args.batch_size,
                                            shuffle=True,
                                            num_workers=args.workers
                                            )

        dataloaders['test'] = data.DataLoader(test_data,
                                            batch_size=args.batch_size,
                                            shuffle=False,
                                            num_workers=args.workers
                                            )

        if args.model in ['VGG11_bn', 'ResNet18', 'DenseNet3_40', 'LeNet', 'VGG11']:
            model = Network().construct(args.model, config)
        else:
            raise Exception('Unknown model: {}'.format())

        model = model.to(device)
        if args.dp:
            model = nn.DataParallel(model, args.dp)
            
        criterion = nn.CrossEntropyLoss()

        optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=args.mom, weight_decay=args.weight_decay)
        scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=args.milestones, gamma=args.lr_gamma)
        acc_list = train(model,
                    optimizer,
                    scheduler,
                    dataloaders,
Пример #2
0
        raise Exception('Unknown dataset: {}'.format(args.dataset))

    dataloaders = dict()
    dataloaders['train'] = data.DataLoader(train_data,
                                           batch_size=args.batch_size,
                                           shuffle=True,
                                           num_workers=args.workers)

    dataloaders['test'] = data.DataLoader(test_data,
                                          batch_size=args.batch_size,
                                          shuffle=False,
                                          num_workers=args.workers)

    # if args.model in ['VGG11', 'VGG11_bn', 'VGG13', 'VGG13_bn', 'VGG16', 'VGG16_bn', 'VGG19', 'VGG19_bn', 'ResNet18', 'DenseNet3_40', 'LeNet', 'MobileNet', 'FullyConnected']:
    if args.model in model_choices:
        model = Network().construct(args.model, config)
    else:
        raise Exception('Unknown model: {}'.format())

    model = model.to(device)

    if args.loss == 'ce':
        criterion = nn.CrossEntropyLoss()
    else:
        raise Exception('Only cross entropy is allowed: {}'.format(args.loss))

    if args.optimizer == 'sgd':
        optimizer = optim.SGD(model.parameters(),
                              lr=args.learning_rate,
                              weight_decay=args.weight_decay,
                              momentum=0.9)
Пример #3
0
    dataloaders = dict()
    dataloaders['train'] = data.DataLoader(train_data,
                                           batch_size=args.batch_size,
                                           shuffle=True,
                                           num_workers=args.workers
                                           )

    dataloaders['test'] = data.DataLoader(test_data,
                                          batch_size=args.batch_size,
                                          shuffle=False,
                                          num_workers=args.workers
                                          )

    # if args.model in ['VGG11', 'VGG11_bn', 'VGG13', 'VGG13_bn', 'VGG16', 'VGG16_bn', 'VGG19', 'VGG19_bn', 'ResNet18', 'DenseNet3_40', 'LeNet', 'MobileNet', 'FullyConnected']:
    if args.model in model_choices:
        model = Network().construct(args.model, config)
    else:
        raise Exception('Unknown model: {}'.format())

    model = model.to(device)

    if args.loss == 'ce':
        criterion = nn.CrossEntropyLoss()
    else:
        raise Exception('Only cross entropy is allowed: {}'.format(args.loss))

    if args.optimizer == 'sgd':
        optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay, momentum=0.9)
    elif args.optimizer == 'adam':
        optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay)
    else:
            else:
                raise Exception('Unknown dataset: {}'.format(args.dataset))

            dataloaders = dict()
            dataloaders['train'] = data.DataLoader(train_data,
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   num_workers=args.workers)

            dataloaders['test'] = data.DataLoader(test_data,
                                                  batch_size=args.batch_size,
                                                  shuffle=False,
                                                  num_workers=args.workers)

            if args.model in model_choices:
                model = Network().construct(args.model, config)
            else:
                raise Exception('Unknown model: {}'.format())

            model = model.to(device)

            if args.loss == 'ce':
                criterion = nn.CrossEntropyLoss()
            else:
                raise Exception('Only cross entropy is allowed: {}'.format(
                    args.loss))

            if args.optimizer == 'sgd':
                optimizer = optim.SGD(model.parameters(),
                                      lr=args.learning_rate,
                                      weight_decay=args.weight_decay,
Пример #5
0
            padded_im_size = 32
            num_classes = 11
            im_size = 32
            epc_seed = 0
            config = Config(input_ch=input_ch,
                        padded_im_size=padded_im_size,
                        num_classes=num_classes,
                        im_size=im_size,
                        epc_seed=epc_seed
                        )
            dataset_sizes = {'train': 73257, 'test': 26032}
        else:    
            raise Exception('Should not have reached here')

        if model_name in model_choices:
            model = Network().construct(model_name, config)
        else:
            raise Exception('Unknown model: {}'.format()) 
 
        full_eigenspectrums_path = osp.join(ckpt_dir, 'training_eigenspectrum_full.npy')
        full_eigenspectrums = np.load(full_eigenspectrums_path)
        valid_layers = get_valid_layers(model)
        
        match_sum = {layer_name: 0 for layer_name in valid_layers}
        epoch_dists_key = model_name + '+' + dataset
        epoch_dists[epoch_dists_key] = np.zeros(50)
        distances[epoch_dists_key]= {layer_name: np.zeros(50) for layer_name in valid_layers}
        valid_model_layers[epoch_dists_key] = valid_layers
        for layer_name in valid_layers:
            for epoch in range(50):
                layerwise_eigenspectrums_paths = osp.join(ckpt_dir, 'training_eigenspectrums_epoch_{}_layer_{}.npz'.format(epoch, layer_name))
        import pdb
        pdb.set_trace()

    assert osp.exists(args.run), '{} was not found'.format(args.run)
    assert osp.isdir(args.run), '{} is not a directory'.format(args.run)

    images_dir = osp.join(args.run, 'images')

    assert osp.exists(images_dir), '{} was not found'.format(images_dir)
    assert osp.isdir(images_dir), '{} is not a directory'.format(images_dir)

    collective_dir = osp.join(images_dir, 'collective')
    if not osp.exists(collective_dir):
        os.makedirs(collective_dir)

    model = Network().construct(args.model, Config())

    text_size = 30
    font = ImageFont.truetype("Roboto-Light.ttf", text_size)
    not_found = list()

    num_layers = 0
    height, width = None, None
    for layer_name, _ in model.named_parameters():
        if height is None:
            dummy_image_path = osp.join(
                images_dir, '{}_{}p_tsne.png'.format(layer_name,
                                                     args.perplexity))
            assert osp.exists(dummy_image_path)
            dummy_image = Image.open(dummy_image_path)
            height = dummy_image.height
                                           shuffle=True,
                                           num_workers=args.workers)

    dataloaders['test'] = data.DataLoader(test_data,
                                          batch_size=args.batch_size,
                                          shuffle=True,
                                          num_workers=args.workers)

    if args.dataset == 'cifar100':
        info.num_classes = 100
    if args.model == 'efficient':
        model = EfficientNetB0()
    elif args.model.startswith('vgg'):
        model = VGG(args.model)
    elif args.model == 'resnet18':
        model = Network().construct('ResNet18', Config())
    elif args.model == 'resnet34':
        model = ResNet34(num_classes=10)
    elif args.model == 'resnet50':
        model = ResNet50()
    elif args.model == 'resnet101':
        model = ResNet101()
    elif args.model == 'densenet121':
        model = DenseNet121()
    elif args.model == 'mobilenet':
        model = MobileNet()
    elif args.model == 'mobilenetv2':
        model = MobileNetV2()
    elif args.model == 'lenet':
        model = LeNet()
    elif args.model == 'densenet40':