コード例 #1
0
def main(dataset_name, net_name, xp_path, data_path, load_model, objective, nu,
         device, seed, batch_size, n_jobs_dataloader, normal_class, isize,
         rep_dim):

    # Set seed
    if seed != -1:
        random.seed(seed)
        np.random.seed(seed)
        torch.manual_seed(seed)

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class, isize)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(objective, nu)
    deep_SVDD.set_network(net_name, rep_dim)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    deep_SVDD.load_model(model_path=load_model)
    # Test model
    deep_SVDD.test(dataset,
                   device=device,
                   n_jobs_dataloader=n_jobs_dataloader,
                   batch_size=batch_size)
    print(deep_SVDD.results['test_auc'])

    # Save results, model, and configuration
    deep_SVDD.save_results(export_json=xp_path + '/results_test.json')
コード例 #2
0
def main(dataset_name, net_name, xp_path, data_path, load_config, load_model, objective, nu, device, seed,
         optimizer_name, lr, n_epochs, lr_milestone, batch_size, weight_decay, pretrain, ae_optimizer_name, ae_lr,
         ae_n_epochs, ae_lr_milestone, ae_batch_size, ae_weight_decay, n_jobs_dataloader, normal_class):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """

    # Get configuration
    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # Print arguments
    logger.info('Log file is %s.' % log_file)
    logger.info('Data path is %s.' % data_path)
    logger.info('Export path is %s.' % xp_path)

    logger.info('Dataset: %s' % dataset_name)
    logger.info('Normal class: %d' % normal_class)
    logger.info('Network: %s' % net_name)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)

    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])

    # Set seed
    if cfg.settings['seed'] != -1:
        random.seed(cfg.settings['seed'])
        np.random.seed(cfg.settings['seed'])
        torch.manual_seed(cfg.settings['seed'])
        logger.info('Set seed to %d.' % cfg.settings['seed'])

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(cfg.settings['objective'], cfg.settings['nu'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=True)
        logger.info('Loading model from %s.' % load_model)

    logger.info('Pretraining: %s' % pretrain)
    if pretrain:
        # Log pretraining details
        logger.info('Pretraining optimizer: %s' % cfg.settings['ae_optimizer_name'])
        logger.info('Pretraining learning rate: %g' % cfg.settings['ae_lr'])
        logger.info('Pretraining epochs: %d' % cfg.settings['ae_n_epochs'])
        logger.info('Pretraining learning rate scheduler milestones: %s' % (cfg.settings['ae_lr_milestone'],))
        logger.info('Pretraining batch size: %d' % cfg.settings['ae_batch_size'])
        logger.info('Pretraining weight decay: %g' % cfg.settings['ae_weight_decay'])

        # Pretrain model on dataset (via autoencoder)
        deep_SVDD.pretrain(dataset,
                           optimizer_name=cfg.settings['ae_optimizer_name'],
                           lr=cfg.settings['ae_lr'],
                           n_epochs=cfg.settings['ae_n_epochs'],
                           lr_milestones=cfg.settings['ae_lr_milestone'],
                           batch_size=cfg.settings['ae_batch_size'],
                           weight_decay=cfg.settings['ae_weight_decay'],
                           device=device,
                           n_jobs_dataloader=n_jobs_dataloader)

    # Log training details
    logger.info('Training optimizer: %s' % cfg.settings['optimizer_name'])
    logger.info('Training learning rate: %g' % cfg.settings['lr'])
    logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
    logger.info('Training learning rate scheduler milestones: %s' % (cfg.settings['lr_milestone'],))
    logger.info('Training batch size: %d' % cfg.settings['batch_size'])
    logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])

    # Train model on dataset
    deep_SVDD.train(dataset,
                    optimizer_name=cfg.settings['optimizer_name'],
                    lr=cfg.settings['lr'],
                    n_epochs=cfg.settings['n_epochs'],
                    lr_milestones=cfg.settings['lr_milestone'],
                    batch_size=cfg.settings['batch_size'],
                    weight_decay=cfg.settings['weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader)

    # Test model
    deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    # Plot most anomalous and most normal (within-class) test samples
    indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
    indices, labels, scores = np.array(indices), np.array(labels), np.array(scores)
    idx_sorted = indices[labels == 0][np.argsort(scores[labels == 0])]  # sorted from lowest to highest anomaly score

    if dataset_name in ('mnist', 'cifar10'):

        if dataset_name == 'mnist':
            X_normals = dataset.test_set.test_data[idx_sorted[:32], ...].unsqueeze(1)
            X_outliers = dataset.test_set.test_data[idx_sorted[-32:], ...].unsqueeze(1)

        if dataset_name == 'cifar10':
            X_normals = torch.tensor(np.transpose(dataset.test_set.test_data[idx_sorted[:32], ...], (0, 3, 1, 2)))
            X_outliers = torch.tensor(np.transpose(dataset.test_set.test_data[idx_sorted[-32:], ...], (0, 3, 1, 2)))

        plot_images_grid(X_normals, export_img=xp_path + '/normals', title='Most normal examples', padding=2)
        plot_images_grid(X_outliers, export_img=xp_path + '/outliers', title='Most anomalous examples', padding=2)

    # Save results, model, and configuration
    deep_SVDD.save_results(export_json=xp_path + '/results.json')
    deep_SVDD.save_model(export_model=xp_path + '/model.tar')
    cfg.save_config(export_json=xp_path + '/config.json')
コード例 #3
0
ファイル: main.py プロジェクト: tianzhaotju/HAE
def main(dataset_name, net_name, xp_path, data_path, load_config, load_model,
         objective, nu, device, seed, optimizer_name, lr, n_epochs,
         lr_milestone, batch_size, weight_decay, pretrain, ae_optimizer_name,
         ae_lr, ae_n_epochs, ae_lr_milestone, ae_batch_size, ae_weight_decay,
         n_jobs_dataloader, ae_loss_type, ae_only, normal_class, ae_test_only):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """

    # Get configuration
    mean = [
        (0.36607818518032215, 0.3528722483374472, 0.3585191239764038),  # 0
        (0.4487305946663354, 0.4487305946663354, 0.4487305946663354),  # 1
        (0.3923340318128373, 0.26295472525674995, 0.22025334692657814),  # 2
        (0.4536255693657713, 0.4682865838881645, 0.4452575836280415),  # 3
        (0.672454086143443, 0.4779993567370712, 0.35007702036667776),  # 4
        (0.5352967021800805, 0.5314880132137422, 0.547828897157147),  # 5
        (0.3267409463643222, 0.41484389522093523, 0.46695618025405883),  # 6
        (0.6926364358307354, 0.662149771557822, 0.6490556404776292),  # 7
        (0.24011281595607017, 0.1769201147939173, 0.17123964257174726),  # 8
        (0.21251877631977975, 0.23440739849813622, 0.2363959074824541),  # 9
        (0.3025230547246622, 0.30300693821061303, 0.32466943588225744),  # 10
        (0.7214971293922232, 0.7214971293922232, 0.7214971293922232),  # 11
        (0.20453672401964704, 0.19061953742573437, 0.1973630989492544),  # 12
        (0.38709726938081024, 0.27680750921869235, 0.24161576675737736),  # 13
        (0.39719792798156195, 0.39719792798156195, 0.39719792798156195),  # 14
    ]
    std = [
        (0.1334089197933497, 0.13091438558839882, 0.11854704285817017),  # 0
        (0.16192189716258867, 0.16192189716258867, 0.16192189716258867),  # 1
        (0.0527090063203568, 0.035927180158353854, 0.026535684323885065),  # 2
        (0.11774565267141425, 0.13039328961987165, 0.12533147519872007),  # 3
        (0.07714836895006975, 0.06278302787607731, 0.04349760909698915),  # 4
        (0.36582285759516936, 0.3661720233895615, 0.34943018535446296),  # 5
        (0.14995070226373788, 0.2117666336616603, 0.23554648659289779),  # 6
        (0.23612927993223184, 0.25644744015075704, 0.25718179933681784),  # 7
        (0.168789697373752, 0.07563237349131141, 0.043146545992581754),  # 8
        (0.15779873915363898, 0.18099161937329614, 0.15159372072430388),  # 9
        (0.15720102988319967, 0.1803989691876269, 0.15113407058442763),  # 10
        (0.13265686578689692, 0.13265686578689692, 0.13265686578689692),  # 11
        (0.2316392849251032, 0.21810285502082638, 0.19743939091294657),  # 12
        (0.20497542590257026, 0.14190994609091834, 0.11531548927488476),  # 13
        (0.3185215984033291, 0.3185215984033291, 0.3185215984033291),  # 14
    ]

    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

    xp_path = xp_path + '/'

    xp_path = xp_path + str(normal_class)
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # Print arguments
    logger.info('Log file is %s.' % log_file)
    logger.info('Data path is %s.' % data_path)
    logger.info('Export path is %s.' % xp_path)
    logger.info('Dataset: %s' % dataset_name)
    logger.info('Normal class: %s' % normal_class)
    logger.info('Network: %s' % net_name)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)

    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])

    # Set seed
    if cfg.settings['seed'] != -1:
        random.seed(cfg.settings['seed'])
        np.random.seed(cfg.settings['seed'])
        torch.manual_seed(cfg.settings['seed'])
        logger.info('Set seed to %d.' % cfg.settings['seed'])

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(cfg.settings['objective'], cfg.settings['nu'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=True)
        logger.info('Loading model from %s.' % load_model)

    logger.info('Pretraining: %s' % pretrain)
    if pretrain:
        # Log pretraining details
        logger.info('Pretraining optimizer: %s' %
                    cfg.settings['ae_optimizer_name'])
        logger.info('Pretraining learning rate: %g' % cfg.settings['ae_lr'])
        logger.info('Pretraining epochs: %d' % cfg.settings['ae_n_epochs'])
        logger.info('Pretraining learning rate scheduler milestones: %s' %
                    (cfg.settings['ae_lr_milestone'], ))
        logger.info('Pretraining batch size: %d' %
                    cfg.settings['ae_batch_size'])
        logger.info('Pretraining weight decay: %g' %
                    cfg.settings['ae_weight_decay'])

        # Pretrain model on dataset (via autoencoder)
        model_save_path = './models/' + dataset_name + '/' + str(
            normal_class) + '_' + str(
                ae_n_epochs) + '_' + ae_loss_type + '.pth'

        if ae_test_only == False:
            deep_SVDD.pretrain(
                dataset,
                optimizer_name=cfg.settings['ae_optimizer_name'],
                lr=cfg.settings['ae_lr'],
                n_epochs=cfg.settings['ae_n_epochs'],
                lr_milestones=cfg.settings['ae_lr_milestone'],
                batch_size=cfg.settings['ae_batch_size'],
                weight_decay=cfg.settings['ae_weight_decay'],
                device=device,
                n_jobs_dataloader=n_jobs_dataloader,
                dataset_name=dataset_name,
                ae_loss_type=ae_loss_type,
                ae_only=ae_only,
                model_save_path=model_save_path)
        else:
            deep_SVDD.load_test(
                dataset,
                optimizer_name=cfg.settings['ae_optimizer_name'],
                lr=cfg.settings['ae_lr'],
                n_epochs=cfg.settings['ae_n_epochs'],
                lr_milestones=cfg.settings['ae_lr_milestone'],
                batch_size=cfg.settings['ae_batch_size'],
                weight_decay=cfg.settings['ae_weight_decay'],
                device=device,
                n_jobs_dataloader=n_jobs_dataloader,
                dataset_name=dataset_name,
                ae_loss_type=ae_loss_type,
                ae_only=ae_only,
                model_save_path=model_save_path)

        # Plot most anomalous and most normal (within-class) test samples
        exit(0)
        indices, labels, scores = zip(*deep_SVDD.results['ae_test_scores'])
        indices, labels, scores = np.array(indices), np.array(
            labels), np.array(scores)
        idx_sorted = indices[labels == 0][np.argsort(scores[
            labels == 0])]  # sorted from lowest to highest anomaly score

        if dataset_name in ('mnist', 'cifar10', 'object', 'texture'):

            if dataset_name == 'mnist':
                X_normals = dataset.test_set.test_data[idx_sorted[:32],
                                                       ...].unsqueeze(1)
                X_outliers = dataset.test_set.test_data[idx_sorted[-32:],
                                                        ...].unsqueeze(1)

            if dataset_name == 'cifar10':
                X_normals = torch.tensor(
                    np.transpose(
                        dataset.test_set.test_data[idx_sorted[:32], ...],
                        (0, 3, 1, 2)))
                X_outliers = torch.tensor(
                    np.transpose(
                        dataset.test_set.test_data[idx_sorted[-32:], ...],
                        (0, 3, 1, 2)))

            if dataset_name == 'object':
                # 22 3 256 256
                X_normals = torch.tensor(dataset.test_data[idx_sorted[:32],
                                                           ...])
                X_outliers = torch.tensor(dataset.test_data[idx_sorted[-32:],
                                                            ...])

                for i in range(3):
                    X_normals[:, i, :, :] *= std[normal_class][i]
                    X_normals[:, i, :, :] += mean[normal_class][i]
                    X_outliers[:, i, :, :] *= std[normal_class][i]
                    X_outliers[:, i, :, :] += mean[normal_class][i]

            #plot_images_grid(X_normals, export_img=xp_path + '/AE_normals', title='Most normal examples', padding=2)
            #plot_images_grid(X_outliers, export_img=xp_path + '/AE_outliers', title='Most anomalous examples', padding=2)
            if ae_only:
                exit(0)
    # Log training details
    logger.info('Training optimizer: %s' % cfg.settings['optimizer_name'])
    logger.info('Training learning rate: %g' % cfg.settings['lr'])
    logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
    logger.info('Training learning rate scheduler milestones: %s' %
                (cfg.settings['lr_milestone'], ))
    logger.info('Training batch size: %d' % cfg.settings['batch_size'])
    logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])

    # Train model on dataset
    deep_SVDD.train(dataset,
                    optimizer_name=cfg.settings['optimizer_name'],
                    lr=cfg.settings['lr'],
                    n_epochs=cfg.settings['n_epochs'],
                    lr_milestones=cfg.settings['lr_milestone'],
                    batch_size=cfg.settings['batch_size'],
                    weight_decay=cfg.settings['weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader,
                    dataset_name=dataset_name)

    # Test model
    deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    # Plot most anomalous and most normal (within-class) test samples
    indices, labels, scores, _, _ = zip(*deep_SVDD.results['test_scores'])
    indices, labels, scores = np.array(indices), np.array(labels), np.array(
        scores)
    idx_sorted = indices[labels == 0][np.argsort(
        scores[labels == 0])]  # sorted from lowest to highest anomaly score

    if dataset_name in ('mnist', 'cifar10', 'object', 'texture'):

        if dataset_name == 'mnist':
            X_normals = dataset.test_set.test_data[idx_sorted[:32],
                                                   ...].unsqueeze(1)
            X_outliers = dataset.test_set.test_data[idx_sorted[-32:],
                                                    ...].unsqueeze(1)

        if dataset_name == 'cifar10':
            X_normals = torch.tensor(
                np.transpose(dataset.test_set.test_data[idx_sorted[:32], ...],
                             (0, 3, 1, 2)))
            X_outliers = torch.tensor(
                np.transpose(dataset.test_set.test_data[idx_sorted[-32:], ...],
                             (0, 3, 1, 2)))

        if dataset_name == 'object':
            # 22 3 256 256
            X_normals = torch.tensor(dataset.test_data[idx_sorted[:32], ...])
            X_outliers = torch.tensor(dataset.test_data[idx_sorted[-32:], ...])
            for i in range(3):
                X_normals[:, i, :, :] *= std[normal_class][i]
                X_normals[:, i, :, :] += mean[normal_class][i]
                X_outliers[:, i, :, :] *= std[normal_class][i]
                X_outliers[:, i, :, :] += mean[normal_class][i]

        plot_images_grid(X_normals,
                         export_img=xp_path + '/normals',
                         title='Most normal examples',
                         padding=2)
        plot_images_grid(X_outliers,
                         export_img=xp_path + '/outliers',
                         title='Most anomalous examples',
                         padding=2)
コード例 #4
0
def main(dataset_name, net_name, xp_path, data_path, load_config, load_model, load_ae_model, objective, nu, number_clusters, device, seed,
         optimizer_name, lr, n_epochs, lr_milestone, batch_size, weight_decay, pretrain, ae_optimizer_name, ae_lr,
         ae_n_epochs, ae_lr_milestone, ae_batch_size, ae_weight_decay, n_jobs_dataloader, normal_class):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """

    # Get configuration
    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)
    
    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])
    logger.info('Number of hyperphere centers: %d' % cfg.settings['number_clusters'])
    
    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(xp_path, cfg.settings['objective'], cfg.settings['nu'], cfg.settings['number_clusters'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=False)
        logger.info('Loading model from %s.' % load_model)

    # import pdb; pdb.set_trace()
    # Test model
    deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    # import pdb; pdb.set_trace()

    # Plot most anomalous and most normal (within-class) test samples
    indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
    indices, labels, scores = np.array(indices), np.array(labels), np.array(scores)
    idx_sorted = indices[labels == 0][np.argsort(scores[labels == 0])]  # sorted from lowest to highest anomaly score

    ### NEW ### 
    # idx_sorted_normal = indices[labels == 0][np.argsort(scores[labels == 0])]  # normal images sorted from lowest to highest anomaly score
    # idx_sorted_outlier = indices[labels == 1][np.argsort(scores[labels == 1])]  # anomaly images sorted from lowest to highest anomaly score

    # Lowest to highest uncertainty scores
    idx_sorted_all = indices[np.argsort(scores)]
    labels_sorted_all = labels[np.argsort(scores)]
    scores_sorted_all = np.sort(scores)
    for i in range(128):
        idx = idx_sorted_all[i]   
        X = dataset.test_set[idx][0].unsqueeze(1)
        plot_images_labels(X, label = labels_sorted_all[i], export_img=xp_path + '/images/img_'+str(i), title='Score = {:4.2f}'.format(scores_sorted_all[i]), padding=2)
    # Assemble Gallery
    folder = xp_path + '/images'
    image_paths = [os.path.join(folder, f) 
                for f in os.listdir(folder) if f.endswith('.png')]

    # Random selection of images
    image_array = random.sample(image_paths, k=128)

    # Create and save image grid
    image = concat_images(image_array, (100, 100), (16, 8))
    image.save(os.path.join(folder,'gallery_128.png'), 'PNG')

    # for i in range(32):
    #     idx = idx_sorted_all[i]   
    #     X = dataset.test_set[idx][0].unsqueeze(1)
    #     plot_images_labels(X, label = labels_sorted_all[i], export_img=xp_path + '/simple_img_'+str(i), title='Simplest Example: Score = {:4.2f}'.format(scores_sorted_all[i]), padding=2)

    # # Highest to lowest uncertainty scores
    # idx_sorted_all = np.flip(idx_sorted_all)
    # labels_sorted_all = np.flip(labels_sorted_all)
    # scores_sorted_all = np.flip(scores_sorted_all)

    # for i in range(32):
    #     idx = idx_sorted_all[i]
    #     X = dataset.test_set[idx][0].unsqueeze(1)
    #     plot_images_labels(X, label = labels_sorted_all[i], export_img=xp_path + '/difficult_img_'+str(i), title='Difficult Example: Score = {:4.2f}'.format(scores_sorted_all[i]), padding=2)

    import pdb; pdb.set_trace()

    # X_n = [dataset.test_set[i][0] for i in idx_sorted_normal[-8:]]
    # X_n = torch.cat(X_n).unsqueeze(1)
    # X_o = [dataset.test_set[i][0] for i in idx_sorted_outlier[-8:]]
    # X_o = torch.cat(X_o).unsqueeze(1)

    # # import pdb; pdb.set_trace()
    # plot_images_labels(X_n, label = 0, export_img=xp_path + '/normals', title='Hardest normal examples', padding=2)
    # # import pdb; pdb.set_trace()
    # plot_images_labels(X_o, label = 1, export_img=xp_path + '/outliers', title='Hardest outlier examples', padding=2)
    ### - ###

    # From clean images, extract the ones model predicts as normal with highest confidence
    X_normals = [dataset.test_set[i][0] for i in idx_sorted[:64]]
    X_normals = torch.cat(X_normals).unsqueeze(1)

    # From clean images, extract the ones model predicts as normal with lowest confidence
    X_outliers = [dataset.test_set[i][0] for i in idx_sorted[-64:]]
    X_outliers = torch.cat(X_outliers).unsqueeze(1)

    plot_images_grid(X_normals, export_img=xp_path + '/normals_64', title='Most normal examples', padding=2)
    plot_images_grid(X_outliers, export_img=xp_path + '/outliers_64', title='Most anomalous examples', padding=2)
コード例 #5
0
def main(dataset_name, net_name, xp_path, data_path, load_config, load_model,
         load_ae_model, objective, nu, number_clusters, device, seed,
         optimizer_name, lr, n_epochs, lr_milestone, batch_size, weight_decay,
         pretrain, ae_optimizer_name, ae_lr, ae_n_epochs, ae_lr_milestone,
         ae_batch_size, ae_weight_decay, n_jobs_dataloader, normal_class):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """

    # Get configuration
    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # Print arguments
    logger.info('Log file is %s.' % log_file)
    logger.info('Data path is %s.' % data_path)
    logger.info('Export path is %s.' % xp_path)

    logger.info('Dataset: %s' % dataset_name)
    logger.info('Normal class: %d' % normal_class)
    logger.info('Network: %s' % net_name)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)

    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])
    logger.info('Number of hyperphere centers: %d' %
                cfg.settings['number_clusters'])

    # Set seed
    if cfg.settings['seed'] != -1:
        random.seed(cfg.settings['seed'])
        np.random.seed(cfg.settings['seed'])
        torch.manual_seed(cfg.settings['seed'])
        logger.info('Set seed to %d.' % cfg.settings['seed'])

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(xp_path, cfg.settings['objective'],
                         cfg.settings['nu'], cfg.settings['number_clusters'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=True)
        logger.info('Loading model from %s.' % load_model)
    # If specified, load pretrained AE model (autoencoder weights)
    if load_ae_model:
        deep_SVDD.load_pretrained_AE_model(model_path=load_ae_model)
        logger.info('Loading pretrained AE model from %s.' % load_ae_model)

    logger.info('Pretraining: %s' % pretrain)
    if pretrain:
        # Log pretraining details
        logger.info('Pretraining optimizer: %s' %
                    cfg.settings['ae_optimizer_name'])
        logger.info('Pretraining learning rate: %g' % cfg.settings['ae_lr'])
        logger.info('Pretraining epochs: %d' % cfg.settings['ae_n_epochs'])
        logger.info('Pretraining learning rate scheduler milestones: %s' %
                    (cfg.settings['ae_lr_milestone'], ))
        logger.info('Pretraining batch size: %d' %
                    cfg.settings['ae_batch_size'])
        logger.info('Pretraining weight decay: %g' %
                    cfg.settings['ae_weight_decay'])

        # Pretrain model on dataset (via autoencoder)
        deep_SVDD.pretrain(dataset,
                           optimizer_name=cfg.settings['ae_optimizer_name'],
                           lr=cfg.settings['ae_lr'],
                           n_epochs=cfg.settings['ae_n_epochs'],
                           lr_milestones=cfg.settings['ae_lr_milestone'],
                           batch_size=cfg.settings['ae_batch_size'],
                           weight_decay=cfg.settings['ae_weight_decay'],
                           device=device,
                           n_jobs_dataloader=n_jobs_dataloader)

    # Log training details
    logger.info('Training optimizer: %s' % cfg.settings['optimizer_name'])
    logger.info('Training learning rate: %g' % cfg.settings['lr'])
    logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
    logger.info('Training learning rate scheduler milestones: %s' %
                (cfg.settings['lr_milestone'], ))
    logger.info('Training batch size: %d' % cfg.settings['batch_size'])
    logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])

    # Train model on dataset
    deep_SVDD.train(dataset,
                    optimizer_name=cfg.settings['optimizer_name'],
                    lr=cfg.settings['lr'],
                    n_epochs=cfg.settings['n_epochs'],
                    lr_milestones=cfg.settings['lr_milestone'],
                    batch_size=cfg.settings['batch_size'],
                    weight_decay=cfg.settings['weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader)

    # Test model
    deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    # Save results, model, and configuration
    deep_SVDD.save_results(export_json=xp_path + '/results.json')
    if pretrain:
        deep_SVDD.save_model(export_model=xp_path + '/model.tar')
    else:
        deep_SVDD.save_model(export_model=xp_path + '/model.tar',
                             save_ae=False)
    cfg.save_config(export_json=xp_path + '/config.json')
    # Save cluster centers
    np.save(os.path.join(xp_path, 'centers.npy'), np.asarray(deep_SVDD.c))

    # Plot most anomalous and most normal (within-class) test samples
    indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
    indices, labels, scores = np.array(indices), np.array(labels), np.array(
        scores)
    idx_sorted = indices[labels == 0][np.argsort(
        scores[labels == 0])]  # sorted from lowest to highest anomaly score

    if dataset_name in ('mnist', 'cifar10', 'cycif'):

        if dataset_name == 'mnist':
            X_normals = dataset.test_set.test_data[idx_sorted[:32],
                                                   ...].unsqueeze(1)
            X_outliers = dataset.test_set.test_data[idx_sorted[-32:],
                                                    ...].unsqueeze(1)

            plot_images_grid(X_normals,
                             export_img=xp_path + '/normals',
                             title='Most normal examples',
                             padding=2)
            plot_images_grid(X_outliers,
                             export_img=xp_path + '/outliers',
                             title='Most anomalous examples',
                             padding=2)

        if dataset_name == 'cifar10':
            X_normals = torch.tensor(
                np.transpose(dataset.test_set.test_data[idx_sorted[:32], ...],
                             (0, 3, 1, 2)))
            X_outliers = torch.tensor(
                np.transpose(dataset.test_set.test_data[idx_sorted[-32:], ...],
                             (0, 3, 1, 2)))

            plot_images_grid(X_normals,
                             export_img=xp_path + '/normals',
                             title='Most normal examples',
                             padding=2)
            plot_images_grid(X_outliers,
                             export_img=xp_path + '/outliers',
                             title='Most anomalous examples',
                             padding=2)

        if dataset_name == 'cycif':
            # # Lowest to highest uncertainty scores
            # idx_sorted_all = indices[np.argsort(scores)]
            # labels_sorted_all = labels[np.argsort(scores)]
            # scores_sorted_all = np.sort(scores)

            # for i in range(32):
            #     idx = idx_sorted_all[i]
            #     X = dataset.test_set[idx][0].unsqueeze(1)
            #     # From test images, extract the ones model predicts as normal with highest confidence (better)
            #     plot_images_labels(X, label = labels_sorted_all[i], export_img=xp_path + '/images/simple_img_'+str(i), title='Simplest Example: Score = {:4.2f}'.format(scores_sorted_all[i]), padding=2)

            # # Highest to lowest uncertainty scores
            # idx_sorted_all = np.flip(idx_sorted_all)
            # labels_sorted_all = np.flip(labels_sorted_all)
            # scores_sorted_all = np.flip(scores_sorted_all)

            # for i in range(32):
            #     idx = idx_sorted_all[i]
            #     X = dataset.test_set[idx][0].unsqueeze(1)
            #     # From test images, extract the ones model predicts as normal with lowest confidence (worse)
            #     plot_images_labels(X, label = labels_sorted_all[i], export_img=xp_path + '/images/difficult_img_'+str(i), title='Difficult Example: Score = {:4.2f}'.format(scores_sorted_all[i]), padding=2)

            # Lowest to highest uncertainty scores
            idx_sorted_all = indices[np.argsort(scores)]
            labels_sorted_all = labels[np.argsort(scores)]
            scores_sorted_all = np.sort(scores)
            for i in range(128):
                idx = idx_sorted_all[i]
                X = dataset.test_set[idx][0].unsqueeze(1)
                plot_images_labels(
                    X,
                    label=labels_sorted_all[i],
                    export_img=xp_path + '/images/img_' + str(i),
                    title='Score = {:4.2f}'.format(scores_sorted_all[i]),
                    padding=2)
            # Assemble Gallery
            folder = xp_path + '/images'
            image_paths = [
                os.path.join(folder, f) for f in os.listdir(folder)
                if f.endswith('.png')
            ]

            # Random selection of images
            image_array = random.sample(image_paths, k=128)

            # Create and save image grid
            image = concat_images(image_array, (100, 100), (16, 8))
            image.save(os.path.join(folder, 'gallery_128.png'), 'PNG')
コード例 #6
0
def main(dataset_name, net_name, xp_path, data_path, load_config, load_model,
         objective, nu, device, seed, optimizer_name, lr, n_epochs,
         lr_milestone, batch_size, weight_decay, pretrain, ae_optimizer_name,
         ae_lr, ae_n_epochs, ae_lr_milestone, ae_batch_size, ae_weight_decay,
         n_jobs_dataloader, normal_class, save_points_outside_r):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """

    # Get configuration
    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # Print arguments
    logger.info('Log file is %s.' % log_file)
    logger.info('Data path is %s.' % data_path)
    logger.info('Export path is %s.' % xp_path)

    logger.info('Dataset: %s' % dataset_name)
    logger.info('Normal class: %d' % normal_class)
    logger.info('Network: %s' % net_name)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)

    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])

    # Set seed
    if cfg.settings['seed'] != -1:
        random.seed(cfg.settings['seed'])
        np.random.seed(cfg.settings['seed'])
        torch.manual_seed(cfg.settings['seed'])
        logger.info('Set seed to %d.' % cfg.settings['seed'])

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(cfg.settings['objective'], cfg.settings['nu'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=False)
        logger.info('Loading model from %s.' % load_model)

    logger.info('Pretraining: %s' % pretrain)
    if pretrain:
        # Log pretraining details
        logger.info('Pretraining optimizer: %s' %
                    cfg.settings['ae_optimizer_name'])
        logger.info('Pretraining learning rate: %g' % cfg.settings['ae_lr'])
        logger.info('Pretraining epochs: %d' % cfg.settings['ae_n_epochs'])
        logger.info('Pretraining learning rate scheduler milestones: %s' %
                    (cfg.settings['ae_lr_milestone'], ))
        logger.info('Pretraining batch size: %d' %
                    cfg.settings['ae_batch_size'])
        logger.info('Pretraining weight decay: %g' %
                    cfg.settings['ae_weight_decay'])

        # Pretrain model on dataset (via autoencoder)
        deep_SVDD.pretrain(dataset,
                           optimizer_name=cfg.settings['ae_optimizer_name'],
                           lr=cfg.settings['ae_lr'],
                           n_epochs=cfg.settings['ae_n_epochs'],
                           lr_milestones=cfg.settings['ae_lr_milestone'],
                           batch_size=cfg.settings['ae_batch_size'],
                           weight_decay=cfg.settings['ae_weight_decay'],
                           device=device,
                           n_jobs_dataloader=n_jobs_dataloader)

    # Log training details
    logger.info('Training optimizer: %s' % cfg.settings['optimizer_name'])
    logger.info('Training learning rate: %g' % cfg.settings['lr'])
    logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
    logger.info('Training learning rate scheduler milestones: %s' %
                (cfg.settings['lr_milestone'], ))
    logger.info('Training batch size: %d' % cfg.settings['batch_size'])
    logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])

    # Train model on dataset
    deep_SVDD.train(dataset,
                    optimizer_name=cfg.settings['optimizer_name'],
                    lr=cfg.settings['lr'],
                    n_epochs=cfg.settings['n_epochs'],
                    lr_milestones=cfg.settings['lr_milestone'],
                    batch_size=cfg.settings['batch_size'],
                    weight_decay=cfg.settings['weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader)

    if save_points_outside_r:
        logger.info('Saving points outside of r')
        deep_SVDD.savePointsOutsideR(dataset,
                                     device=device,
                                     n_jobs_dataloader=n_jobs_dataloader)

    # Test model
    deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    deep_SVDD.save_results(export_json=xp_path + '/results.json')
    deep_SVDD.save_model(export_model=xp_path + '/model.tar')
    cfg.save_config(export_json=xp_path + '/config.json')
コード例 #7
0
ファイル: main.py プロジェクト: JAVersteeg/Deep-SVDD-PyTorch
def main(dataset_name, net_name, xp_path, data_path, load_config, load_model,
         objective, nu, device, seed, optimizer_name, lr, n_epochs,
         lr_milestone, batch_size, weight_decay, pretrain, ae_optimizer_name,
         ae_lr, ae_n_epochs, ae_lr_milestone, ae_batch_size, ae_weight_decay,
         n_jobs_dataloader, normal_class, img_name):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """

    # Get configuration
    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # Current date and time
    logger.info('Current date and time is %s.' % datetime.now())

    # () arguments
    logger.info('Log file is %s.' % log_file)
    logger.info('Data path is %s.' % data_path)
    logger.info('Export path is %s.' % xp_path)

    logger.info('Dataset: %s' % dataset_name)
    logger.info('Normal class: %d' % normal_class)
    logger.info('Network: %s' % net_name)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)

    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-parameter: %.2f' % cfg.settings['nu'])

    # Set seed
    if cfg.settings['seed'] != -1:
        random.seed(cfg.settings['seed'])
        np.random.seed(cfg.settings['seed'])
        torch.manual_seed(cfg.settings['seed'])
        logger.info('Set seed to %d.' % cfg.settings['seed'])

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(cfg.settings['objective'], cfg.settings['nu'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=True)
        logger.info('Loading model from %s.' % load_model)

    logger.info('Pretraining: %s' % pretrain)
    if pretrain:
        # Log pretraining details
        logger.info('Pretraining optimizer: %s' %
                    cfg.settings['ae_optimizer_name'])
        logger.info('Pretraining learning rate: %g' % cfg.settings['ae_lr'])
        logger.info('Pretraining epochs: %d' % cfg.settings['ae_n_epochs'])
        logger.info('Pretraining learning rate scheduler milestones: %s' %
                    (cfg.settings['ae_lr_milestone'], ))
        logger.info('Pretraining batch size: %d' %
                    cfg.settings['ae_batch_size'])
        logger.info('Pretraining weight decay: %g' %
                    cfg.settings['ae_weight_decay'])

        # Pretrain model on dataset (via autoencoder)
        deep_SVDD.pretrain(dataset,
                           optimizer_name=cfg.settings['ae_optimizer_name'],
                           lr=cfg.settings['ae_lr'],
                           n_epochs=cfg.settings['ae_n_epochs'],
                           lr_milestones=cfg.settings['ae_lr_milestone'],
                           batch_size=cfg.settings['ae_batch_size'],
                           weight_decay=cfg.settings['ae_weight_decay'],
                           device=device,
                           n_jobs_dataloader=n_jobs_dataloader)

    # Log training details
    logger.info('Training optimizer: %s' % cfg.settings['optimizer_name'])
    logger.info('Training learning rate: %g' % cfg.settings['lr'])
    logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
    logger.info('Training learning rate scheduler milestones: %s' %
                (cfg.settings['lr_milestone'], ))
    logger.info('Training batch size: %d' % cfg.settings['batch_size'])
    logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])

    # Train model on dataset
    deep_SVDD.train(dataset,
                    optimizer_name=cfg.settings['optimizer_name'],
                    lr=cfg.settings['lr'],
                    n_epochs=cfg.settings['n_epochs'],
                    lr_milestones=cfg.settings['lr_milestone'],
                    batch_size=cfg.settings['batch_size'],
                    weight_decay=cfg.settings['weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader)

    # Test model
    deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    # Plot most anomalous and most normal (within-class) test samples
    indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
    indices, labels, scores = np.array(indices), np.array(labels), np.array(
        scores)

    idx_all_sorted = indices[np.argsort(scores)]
    idx_normal_sorted = indices[labels == 0][np.argsort(
        scores[labels == 0])]  # sorted from lowest to highest anomaly score
    idx_outlier_sorted = indices[labels == 1][np.argsort(scores[labels == 1])]
    idx_sorted = indices[np.argsort(scores)]

    test_auc = deep_SVDD.results['test_auc']

    if dataset_name in ('mnist', 'cifar10', 'fashion', 'crack', 'crack128'):
        if dataset_name == 'mnist':
            X_normals = dataset.test_set.test_data[idx_sorted_normal[:32],
                                                   ...].unsqueeze(1)
            X_outliers = dataset.test_set.test_data[idx_sorted_normal[-32:],
                                                    ...].unsqueeze(1)

        if dataset_name == 'cifar10':
            X_normals = torch.tensor(
                np.transpose(
                    dataset.test_set.test_data[idx_sorted_normal[:32], ...],
                    (0, 3, 1, 2)))
            X_outliers = torch.tensor(
                np.transpose(
                    dataset.test_set.test_data[idx_sorted_normal[-32:], ...],
                    (0, 3, 1, 2)))

        if dataset_name == 'fashion':
            X_normals = torch.reshape(
                torch.tensor(dataset.test_set.data[idx_sorted_normal[:32],
                                                   ...]),
                (32, 28, 28)).unsqueeze(1)
            X_outliers = torch.reshape(
                torch.tensor(dataset.test_set.data[idx_sorted_normal[-32:],
                                                   ...]),
                (32, 28, 28)).unsqueeze(1)

        plot_imgs = True
        indices, labels, scores = zip(
            *deep_SVDD.results['test_scores (corner)'])
        indices, labels, scores = np.array(indices), np.array(
            labels), np.array(scores)
        idx_all_sorted = indices[np.argsort(
            scores)]  # from lowest to highest score
        idx_normal_sorted = indices[labels == 0][np.argsort(
            scores[labels == 0])]  # from lowest to highest score
        idx_outlier_sorted = indices[labels == 1][np.argsort(
            scores[labels == 1])]  # from lowest to highest score

        if dataset_name == 'crack':
            mid = len(idx_all_sorted) / 2
            if len(idx_all_sorted) > 64 and len(
                    idx_normal_sorted) > 64 and len(idx_outlier_sorted) > 100:
                #X_middle = torch.reshape(torch.tensor(dataset.test_set.data[idx_all_sorted[int(mid-312):int(mid+313)], ...]), (625,64,64)).unsqueeze(1)
                X_all_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[:64],
                                                     ...]),
                    (64, 64, 64)).unsqueeze(1)
                X_all_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[-144:],
                                                     ...]),
                    (144, 64, 64)).unsqueeze(1)
                X_normals_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[:64],
                                                     ...]),
                    (64, 64, 64)).unsqueeze(1)
                X_normals_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[-64:],
                                                     ...]),
                    (64, 64, 64)).unsqueeze(1)
                X_outliers_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[:100],
                                                     ...]),
                    (100, 64, 64)).unsqueeze(1)
                X_outliers_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[-100:],
                                                     ...]),
                    (100, 64, 64)).unsqueeze(1)
            else:
                plot_imgs = False
                X_all_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[:1], ...]),
                    (1, 64, 64)).unsqueeze(1)
                X_all_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[-1:],
                                                     ...]),
                    (1, 64, 64)).unsqueeze(1)
                X_normals_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[:1],
                                                     ...]),
                    (1, 64, 64)).unsqueeze(1)
                X_normals_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[-1:],
                                                     ...]),
                    (1, 64, 64)).unsqueeze(1)
                X_outliers_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[:1],
                                                     ...]),
                    (1, 64, 64)).unsqueeze(1)
                X_outliers_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[-1:],
                                                     ...]),
                    (1, 64, 64)).unsqueeze(1)

        if dataset_name == 'crack128':
            mid = len(idx_all_sorted) / 2
            if len(idx_all_sorted) > 64 and len(
                    idx_normal_sorted) > 64 and len(idx_outlier_sorted) > 100:

                #X_middle = torch.reshape(torch.tensor(dataset.test_set.data[idx_all_sorted[int(mid-312):int(mid+313)], ...]), (625,128,128)).unsqueeze(1)
                X_all_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[:64],
                                                     ...]),
                    (64, 128, 128)).unsqueeze(1)
                X_all_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[-144:],
                                                     ...]),
                    (144, 128, 128)).unsqueeze(1)
                X_normals_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[:64],
                                                     ...]),
                    (64, 128, 128)).unsqueeze(1)
                X_normals_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[-64:],
                                                     ...]),
                    (64, 128, 128)).unsqueeze(1)
                X_outliers_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[:100],
                                                     ...]),
                    (100, 128, 128)).unsqueeze(1)
                X_outliers_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[-100:],
                                                     ...]),
                    (100, 128, 128)).unsqueeze(1)
            else:
                plot_imgs = False
                X_all_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[:1], ...]),
                    (1, 128, 128)).unsqueeze(1)
                X_all_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_all_sorted[-1:],
                                                     ...]),
                    (1, 128, 128)).unsqueeze(1)
                X_normals_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[:1],
                                                     ...]),
                    (1, 128, 128)).unsqueeze(1)
                X_normals_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_normal_sorted[-1:],
                                                     ...]),
                    (1, 128, 128)).unsqueeze(1)
                X_outliers_normal = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[:1],
                                                     ...]),
                    (1, 128, 128)).unsqueeze(1)
                X_outliers_outlier = torch.reshape(
                    torch.tensor(
                        dataset.test_set_corner.data[idx_outlier_sorted[-1:],
                                                     ...]),
                    (1, 128, 128)).unsqueeze(1)

        if plot_imgs:
            #plot_images_grid(X_middle, export_img=xp_path + '/plots/' + img_name + '_all_middle_', title='All samples', padding=2, nrow=25)
            #plot_images_grid(X_all_normal, export_img=xp_path + '/plots/' + img_name + '_all_low_', title='Least anomalous samples', padding=2, nrow=8)
            plot_images_grid(X_all_outlier,
                             export_img=xp_path + '/plots/' + img_name +
                             '_all_high_',
                             title='Most anomalous samples',
                             padding=2,
                             nrow=12)
            #plot_images_grid(X_normals_normal, export_img=xp_path + '/plots/' + img_name + '_normals_low_', title='Least anomalous normal samples', padding=2, nrow=8)
            plot_images_grid(X_normals_outlier,
                             export_img=xp_path + '/plots/' + img_name +
                             '_normals_high_',
                             title='Most anmalous normal samples',
                             padding=2,
                             nrow=8)
            plot_images_grid(X_outliers_normal,
                             export_img=xp_path + '/plots/' + img_name +
                             '_outliers_low_',
                             title='Least anomalous anomaly samples',
                             padding=2,
                             nrow=10)
            plot_images_grid(X_outliers_outlier,
                             export_img=xp_path + '/plots/' + img_name +
                             '_outliers_high_',
                             title='Most anomalous anomaly samples',
                             padding=2,
                             nrow=10)

        test_auc = deep_SVDD.results['test_auc']
        test_auc_corner = deep_SVDD.results['test_auc (corner)']
        plot_images_hist(
            scores[labels == 0],
            scores[labels == 1],
            export_img=xp_path + '/plots/' + img_name + '_hist_corner',
            title=
            'Deep SVDD Anomaly scores of normal and crack samples (with corner cracks)',
            auc=test_auc_corner)

        indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
        indices, labels, scores = np.array(indices), np.array(
            labels), np.array(scores)
        plot_images_hist(
            scores[labels == 0],
            scores[labels == 1],
            export_img=xp_path + '/plots/' + img_name + '_hist',
            title='Deep SVDD anomaly scores of normal and crack samples',
            auc=test_auc)

    # Save results, model, and configuration
    deep_SVDD.save_results(export_json=xp_path + '/results.json')
    deep_SVDD.save_model(export_model=xp_path + '/model.tar')
    cfg.save_config(export_json=xp_path + '/config.json')
コード例 #8
0
def main(dataset_name, net_name, xp_path, data_path, load_data, load_config,
         load_model, objective, nu, device, seed, optimizer_name, lr, n_epochs,
         lr_milestone, batch_size, weight_decay, pretrain, ae_optimizer_name,
         ae_lr, ae_n_epochs, ae_lr_milestone, ae_batch_size, ae_weight_decay,
         n_jobs_dataloader, normal_class):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural n etwork to use.
    :arg XP_PATH: Export path for loggi ng the experiment.
    :arg DATA_PATH: Root path of data.  
    """

    # Get configuration
    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # Print arguments
    logger.info('Log file is %s.' % log_file)
    logger.info('Data path is %s.' % data_path)
    logger.info('Export path is %s.' % xp_path)

    logger.info('Dataset: %s' % dataset_name)
    logger.info('Normal class: %d' % normal_class)
    logger.info('Network: %s' % net_name)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)

    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])

    # Set seed
    if cfg.settings['seed'] != -1:
        random.seed(cfg.settings['seed'])
        np.random.seed(cfg.settings['seed'])
        torch.manual_seed(cfg.settings['seed'])
        logger.info('Set seed to %d.' % cfg.settings['seed'])

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    if dataset_name == 'campus':
        train_path = 'train/OK'
        test_path = 'test'
        train_image, test_image, test_label = train_test_numpy_load(
            data_path, train_path, test_path, load_data)
        dataset = load_campus_dataset(dataset_name, data_path, train_image,
                                      test_image, test_label)
    else:
        dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(cfg.settings['objective'], cfg.settings['nu'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=True)
        logger.info('Loading model from %s.' % load_model)

    # logger.info('Pretraining: %s' % pretrain)
    if pretrain:
        # Log pretraining details
        logger.info('Pretraining optimizer: %s' %
                    cfg.settings['ae_optimizer_name'])
        logger.info('Pretraining learning rate: %g' % cfg.settings['ae_lr'])
        logger.info('Pretraining epochs: %d' % cfg.settings['ae_n_epochs'])
        logger.info('Pretraining learning rate scheduler milestones: %s' %
                    (cfg.settings['ae_lr_milestone'], ))
        logger.info('Pretraining batch size: %d' %
                    cfg.settings['ae_batch_size'])
        logger.info('Pretraining weight decay: %g' %
                    cfg.settings['ae_weight_decay'])

        # Pretrain model on dataset (via autoencoder)
        deep_SVDD.pretrain(dataset,
                           optimizer_name=cfg.settings['ae_optimizer_name'],
                           lr=cfg.settings['ae_lr'],
                           n_epochs=cfg.settings['ae_n_epochs'],
                           lr_milestones=cfg.settings['ae_lr_milestone'],
                           batch_size=cfg.settings['ae_batch_size'],
                           weight_decay=cfg.settings['ae_weight_decay'],
                           device=device,
                           n_jobs_dataloader=n_jobs_dataloader,
                           test_image=test_image)

    # Log training details
    logger.info('Training optimizer: %s' % cfg.settings['optimizer_name'])
    logger.info('Training learning rate: %g' % cfg.settings['lr'])
    logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
    logger.info('Training learning rate scheduler milestones: %s' %
                (cfg.settings['lr_milestone'], ))
    logger.info('Training batch size: %d' % cfg.settings['batch_size'])
    logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])

    # Train model on dataset
    deep_SVDD.train(dataset,
                    optimizer_name=cfg.settings['optimizer_name'],
                    lr=cfg.settings['lr'],
                    n_epochs=cfg.settings['n_epochs'],
                    lr_milestones=cfg.settings['lr_milestone'],
                    batch_size=cfg.settings['batch_size'],
                    weight_decay=cfg.settings['weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader)
    # plot t_sne
    # deep_SVDD.t_sne(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader, data_path=data_path, xp_path=xp_path)

    # Test model
    deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    # Plot most anomalous and most normal (within-class) test samples
    indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
    indices, labels, scores = np.array(indices), np.array(labels), np.array(
        scores)

    if dataset_name in ('mnist', 'cifar10', 'campus'):

        if dataset_name == 'mnist':
            X_normals = dataset.test_set.test_data[idx_sorted[:32],
                                                   ...].unsqueeze(1)
            X_outliers = dataset.test_set.test_data[idx_sorted[-32:],
                                                    ...].unsqueeze(1)

        if dataset_name == 'cifar10':
            X_normals = torch.tensor(
                np.transpose(dataset.test_set.test_data[idx_sorted[:32], ...],
                             (0, 3, 1, 2)))
            X_outliers = torch.tensor(
                np.transpose(dataset.test_set.test_data[idx_sorted[-32:], ...],
                             (0, 3, 1, 2)))

        if dataset_name == 'campus':
            test_score_path = os.path.join(xp_path, 'test_score.pickle')
            with open(test_score_path, 'wb') as f:
                pickle.dump(deep_SVDD.results['test_scores'], f,
                            pickle.HIGHEST_PROTOCOL)

        if dataset_name == 'campus':
            fpr = dict()
            tpr = dict()
            roc_auc = dict()
            fpr, tpr, threshold = roc_curve(labels, scores)
            roc_auc = auc(fpr, tpr)
            plt.figure()
            lw = 2
            plt.plot(fpr,
                     tpr,
                     color='darkorange',
                     lw=lw,
                     label='ROC curve (area= %0.2f)' % roc_auc)
            plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
            plt.xlim([0.0, 1.0])
            plt.ylim([0.0, 1.05])
            plt.xlabel('False Positive Rate')
            plt.ylabel('True Positive Rate')
            plt.title('Receiver operating characteristic example')
            plt.legend(loc="lower right")
            plt.savefig(os.path.join(xp_path, 'auc_roc.png'))
        else:
            plot_images_grid(X_normals,
                             export_img=xp_path + '/normals',
                             title='Most normal examples',
                             padding=2)
            plot_images_grid(X_outliers,
                             export_img=xp_path + '/outliers',
                             title='Most anomalous examples',
                             padding=2)

    # Save results, model, and configuration
    deep_SVDD.save_results(export_json=xp_path + '/results.json')
    deep_SVDD.save_model(export_model=xp_path + '/model.tar')
    cfg.save_config(export_json=xp_path + '/config.json')
コード例 #9
0
ファイル: main.py プロジェクト: MUST-AI-Lab/Deep-SVDD
def main(dataset_name, net_name, xp_path, data_path, load_config, load_model, objective, nu, focal_parameter, update_center_epochs, device, seed,
         optimizer_name, lr, n_epochs, lr_milestone, batch_size, weight_decay, pretrain, ae_optimizer_name, ae_lr,
         ae_n_epochs, ae_lr_milestone, ae_batch_size, ae_weight_decay, n_jobs_dataloader, normal_class):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """

    # Get configuration
    cfg = Config(locals().copy())

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    log_file = xp_path + '/log.txt'
    file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)

    # Print arguments
    logger.info('Log file is %s.' % log_file)
    logger.info('Data path is %s.' % data_path)
    logger.info('Export path is %s.' % xp_path)

    logger.info('Dataset: %s' % dataset_name)
    logger.info('Normal class: %d' % normal_class)
    logger.info('Network: %s' % net_name)

    # If specified, load experiment config from JSON-file
    if load_config:
        cfg.load_config(import_json=load_config)
        logger.info('Loaded configuration from %s.' % load_config)

    # Print configuration
    logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
    logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])
    logger.info('focal_parameter: %.2f' % cfg.settings['focal_parameter'])
    logger.info('update_center_epochs: %d' % cfg.settings['update_center_epochs'])

    # Set seed
    if cfg.settings['seed'] != -1:
        random.seed(cfg.settings['seed'])
        os.environ['PYTHONHASHSEED'] = str(seed)
        np.random.seed(cfg.settings['seed'])
        torch.manual_seed(cfg.settings['seed'])
        torch.cuda.manual_seed(cfg.settings['seed'])
        torch.cuda.manual_seed_all(cfg.settings['seed'])
        cudnn.benchmark = False
        torch.backends.cudnn.deterministic = True
        logger.info('Set seed to %d.' % cfg.settings['seed'])

    # Default device to 'cpu' if cuda is not available
    if not torch.cuda.is_available():
        device = 'cpu'
    logger.info('Computation device: %s' % device)
    logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

    # Load data
    dataset = load_dataset(dataset_name, data_path, normal_class)

    # Initialize DeepSVDD model and set neural network \phi
    deep_SVDD = DeepSVDD(cfg.settings['objective'], cfg.settings['nu'], cfg.settings['focal_parameter'], cfg.settings['update_center_epochs'])
    deep_SVDD.set_network(net_name)
    # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
    if load_model:
        deep_SVDD.load_model(model_path=load_model, load_ae=True)
        logger.info('Loading model from %s.' % load_model)

    logger.info('Pretraining: %s' % pretrain)
    if pretrain:
        # Log pretraining details
        logger.info('Pretraining optimizer: %s' % cfg.settings['ae_optimizer_name'])
        logger.info('Pretraining learning rate: %g' % cfg.settings['ae_lr'])
        logger.info('Pretraining epochs: %d' % cfg.settings['ae_n_epochs'])
        logger.info('Pretraining learning rate scheduler milestones: %s' % (cfg.settings['ae_lr_milestone'],))
        logger.info('Pretraining batch size: %d' % cfg.settings['ae_batch_size'])
        logger.info('Pretraining weight decay: %g' % cfg.settings['ae_weight_decay'])

        # Pretrain model on dataset (via autoencoder)
        deep_SVDD.pretrain(dataset,
                           optimizer_name=cfg.settings['ae_optimizer_name'],
                           lr=cfg.settings['ae_lr'],
                           n_epochs=cfg.settings['ae_n_epochs'],
                           lr_milestones=cfg.settings['ae_lr_milestone'],
                           batch_size=cfg.settings['ae_batch_size'],
                           weight_decay=cfg.settings['ae_weight_decay'],
                           device=device,
                           n_jobs_dataloader=n_jobs_dataloader)

    # Log training details
    logger.info('Training optimizer: %s' % cfg.settings['optimizer_name'])
    logger.info('Training learning rate: %g' % cfg.settings['lr'])
    logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
    logger.info('Training learning rate scheduler milestones: %s' % (cfg.settings['lr_milestone'],))
    logger.info('Training batch size: %d' % cfg.settings['batch_size'])
    logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])

    # record test AUC after each 100 epoch
    # f_get_para = open('../log/mnist_test/100_AUC.txt', 'w')
    # f_get_para.write("\r\n \r\nrecord test AUC each 100 epoch   \r\n \r\n \r\n")
    # f_get_para.close()
    #
    # f_get_para = open('../log/mnist_test/get_param.txt', 'w')
    # f_get_para.write("\r\n \r\nrecord test AUC each very epoch   \r\n \r\n \r\n")
    # f_get_para.close()

    # Train model on dataset
    deep_SVDD.train(dataset,
                    optimizer_name=cfg.settings['optimizer_name'],
                    lr=cfg.settings['lr'],
                    n_epochs=cfg.settings['n_epochs'],
                    lr_milestones=cfg.settings['lr_milestone'],
                    batch_size=cfg.settings['batch_size'],
                    weight_decay=cfg.settings['weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader)

    # Test model
    # deep_SVDD.test(dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

    # Plot most anomalous and most normal (within-class) test samples
    # indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
    # indices, labels, scores = np.array(indices), np.array(labels), np.array(scores)
    # idx_sorted = indices[labels == 0][np.argsort(scores[labels == 0])]  # sorted from lowest to highest anomaly score
    #
    # if dataset_name in ('mnist', 'cifar10'):
    #
    #     if dataset_name == 'mnist':
    #         X_normals = dataset.test_set.test_data[idx_sorted[:32], ...].unsqueeze(1)
    #         X_outliers = dataset.test_set.test_data[idx_sorted[-32:], ...].unsqueeze(1)
    #
    #     if dataset_name == 'cifar10':
    #         X_normals = torch.tensor(np.transpose(dataset.test_set.test_data[idx_sorted[:32], ...], (0, 3, 1, 2)))
    #         X_outliers = torch.tensor(np.transpose(dataset.test_set.test_data[idx_sorted[-32:], ...], (0, 3, 1, 2)))
    #
    #     plot_images_grid(X_normals, export_img=xp_path + '/normals', title='Most normal examples', padding=2)
    #     plot_images_grid(X_outliers, export_img=xp_path + '/outliers', title='Most anomalous examples', padding=2)
    #
    # # Save results, model, and configuration
    # deep_SVDD.save_results(export_json=xp_path + '/results.json')
    # deep_SVDD.save_model(export_model=xp_path + '/model.tar')
    # cfg.save_config(export_json=xp_path + '/config.json')

    # plot curves
    loss_plot = deep_SVDD.trainer.Loss_list
    accuracy_plot = deep_SVDD.trainer.Accuracy_list
    x1 = range(0, n_epochs)
    y1 = accuracy_plot
    x2 = range(0, n_epochs)
    y2 = loss_plot
    plt.subplot(2, 1, 1)
    plt.plot(x1, y1, 'o-')
    plt.title('Class %d vs focal %.2f' % (normal_class, focal_parameter))
    plt.ylabel('Test accuracy')
    plt.subplot(2, 1, 2)
    plt.plot(x2, y2, '.-')
    plt.xlabel('Test loss vs. epoches')
    plt.ylabel('Test loss')
    plt.savefig("accuracy_loss focal %.2f .jpg" % focal_parameter)
コード例 #10
0
ファイル: main.py プロジェクト: wogong/Deep-SVDD-PyTorch
def main(dataset_name, net_name, load_config, load_model, objective, nu,
         device, seed, optimizer_name, lr, n_epochs, lr_milestone, batch_size,
         weight_decay, pretrain, ae_optimizer_name, ae_lr, ae_n_epochs,
         ae_lr_milestone, ae_batch_size, ae_weight_decay, n_jobs_dataloader,
         ratio, run_times):
    """
    Deep SVDD, a fully deep method for anomaly detection.

    :arg DATASET_NAME: Name of the dataset to load.
    :arg NET_NAME: Name of the neural network to use.
    :arg XP_PATH: Export path for logging the experiment.
    :arg DATA_PATH: Root path of data.
    """
    class_num = 10
    if dataset_name == 'cifar100':
        class_num = 20
    for run_index in range(run_times):
        #for ratio in [0.05, 0.1, 0.15, 0.2, 0.25]:
        for i in range(class_num):
            normal_class = i
            class_name = get_class_name_from_index(normal_class, dataset_name)
            os.makedirs(os.path.join(RESULTS_DIR), exist_ok=True)
            # Get configuration
            cfg = Config(locals().copy())

            # Set up logging
            logging.basicConfig(level=logging.INFO)
            logger = logging.getLogger()
            logger.setLevel(logging.INFO)
            formatter = logging.Formatter(
                '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

            xp_path = RESULTS_DIR

            log_file = xp_path + '/log.txt'
            file_handler = logging.FileHandler(log_file)
            file_handler.setLevel(logging.INFO)
            file_handler.setFormatter(formatter)
            logger.addHandler(file_handler)

            # Print arguments
            logger.info('Log file is %s.' % log_file)
            logger.info('Export path is %s.' % xp_path)

            logger.info('Dataset: %s' % dataset_name)
            logger.info('Normal class: %d' % normal_class)
            logger.info('Network: %s' % net_name)

            # If specified, load experiment config from JSON-file
            if load_config:
                cfg.load_config(import_json=load_config)
                logger.info('Loaded configuration from %s.' % load_config)

            # Print configuration
            logger.info('Deep SVDD objective: %s' % cfg.settings['objective'])
            logger.info('Nu-paramerter: %.2f' % cfg.settings['nu'])

            # Set seed
            cfg.settings['seed'] = run_index
            if cfg.settings['seed'] != -1:
                random.seed(cfg.settings['seed'])
                np.random.seed(cfg.settings['seed'])
                torch.manual_seed(cfg.settings['seed'])
                logger.info('Set seed to %d.' % cfg.settings['seed'])

            # Default device to 'cpu' if cuda is not available
            if not torch.cuda.is_available():
                device = 'cpu'
            logger.info('Computation device: %s' % device)
            logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)

            # Load data
            dataset = load_dataset(dataset_name, normal_class, ratio)

            # Initialize DeepSVDD model and set neural network \phi
            deep_SVDD = DeepSVDD(cfg.settings['objective'], cfg.settings['nu'])
            deep_SVDD.set_network(net_name)
            # If specified, load Deep SVDD model (radius R, center c, network weights, and possibly autoencoder weights)
            if load_model:
                deep_SVDD.load_model(model_path=load_model, load_ae=True)
                logger.info('Loading model from %s.' % load_model)

            logger.info('Pretraining: %s' % pretrain)
            if pretrain:
                # Log pretraining details
                logger.info('Pretraining optimizer: %s' %
                            cfg.settings['ae_optimizer_name'])
                logger.info('Pretraining learning rate: %g' %
                            cfg.settings['ae_lr'])
                logger.info('Pretraining epochs: %d' %
                            cfg.settings['ae_n_epochs'])
                logger.info(
                    'Pretraining learning rate scheduler milestones: %s' %
                    (cfg.settings['ae_lr_milestone'], ))
                logger.info('Pretraining batch size: %d' %
                            cfg.settings['ae_batch_size'])
                logger.info('Pretraining weight decay: %g' %
                            cfg.settings['ae_weight_decay'])

                # Pretrain model on dataset (via autoencoder)
                deep_SVDD.pretrain(
                    dataset,
                    optimizer_name=cfg.settings['ae_optimizer_name'],
                    lr=cfg.settings['ae_lr'],
                    n_epochs=cfg.settings['ae_n_epochs'],
                    lr_milestones=cfg.settings['ae_lr_milestone'],
                    batch_size=cfg.settings['ae_batch_size'],
                    weight_decay=cfg.settings['ae_weight_decay'],
                    device=device,
                    n_jobs_dataloader=n_jobs_dataloader)

            # Log training details
            logger.info('Training optimizer: %s' %
                        cfg.settings['optimizer_name'])
            logger.info('Training learning rate: %g' % cfg.settings['lr'])
            logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
            logger.info('Training learning rate scheduler milestones: %s' %
                        (cfg.settings['lr_milestone'], ))
            logger.info('Training batch size: %d' % cfg.settings['batch_size'])
            logger.info('Training weight decay: %g' %
                        cfg.settings['weight_decay'])

            # Train model on dataset
            deep_SVDD.train(dataset,
                            optimizer_name=cfg.settings['optimizer_name'],
                            lr=cfg.settings['lr'],
                            n_epochs=cfg.settings['n_epochs'],
                            lr_milestones=cfg.settings['lr_milestone'],
                            batch_size=cfg.settings['batch_size'],
                            weight_decay=cfg.settings['weight_decay'],
                            device=device,
                            n_jobs_dataloader=n_jobs_dataloader)

            # Test model
            scores, labels = deep_SVDD.test(
                dataset, device=device, n_jobs_dataloader=n_jobs_dataloader)

            res_file_name = '{}_dsvdd-{}_{}_{}.npz'.format(
                dataset_name, ratio, class_name,
                datetime.now().strftime('%Y-%m-%d-%H%M'))
            res_file_path = os.path.join(RESULTS_DIR, dataset_name,
                                         res_file_name)
            os.makedirs(os.path.join(RESULTS_DIR, dataset_name), exist_ok=True)
            save_roc_pr_curve_data(scores, labels, res_file_path)

            # Plot most anomalous and most normal (within-class) test samples
            # indices, labels, scores = zip(*deep_SVDD.results['test_scores'])
            # indices, labels, scores = np.array(indices), np.array(labels), np.array(scores)
            # idx_sorted = indices[labels == 0][np.argsort(scores[labels == 0])]  # sorted from lowest to highest anomaly score
            #
            # if dataset_name in ('mnist', 'cifar10'):
            #
            #     if dataset_name == 'mnist':
            #         X_normals = dataset.test_set.test_data[idx_sorted[:32], ...].unsqueeze(1)
            #         X_outliers = dataset.test_set.test_data[idx_sorted[-32:], ...].unsqueeze(1)
            #
            #     if dataset_name == 'cifar10':
            #         X_normals = torch.tensor(np.transpose(dataset.test_set.test_data[idx_sorted[:32], ...], (0, 3, 1, 2)))
            #         X_outliers = torch.tensor(np.transpose(dataset.test_set.test_data[idx_sorted[-32:], ...], (0, 3, 1, 2)))
            #
            #     plot_images_grid(X_normals, export_img=xp_path + '/normals', title='Most normal examples', padding=2)
            #     plot_images_grid(X_outliers, export_img=xp_path + '/outliers', title='Most anomalous examples', padding=2)

            # Save results, model, and configuration
            logger.info('finish class {} training.'.format(class_name))
    logger.info('send exp finish mail.')
    send_mailgun()