Ejemplo n.º 1
0
def build_model(repo='', filename=''):
    """
    parser = argparse.ArgumentParser(description='CIFAR 100 Ensemble Prediction')
    
    parser.add_argument('--optimize', type=int, default=0, help='Optimization flag. Set to 1 to perform a randomized '
                                                                'search to maximise classification accuracy. \n'
                                                                'Set to -1 to get non weighted classification accuracy')
    
    parser.add_argument('--num_tests', type=int, default=20, help='Number of tests to perform when optimizing the '
                                                                  'ensemble weights for maximizing classification accuracy')
    
    parser.add_argument('--model', type=str, default='wrn', help='Type of model to train')
    
    # Wide ResNet Parameters
    parser.add_argument('--wrn_N', type=int, default=2, help='Number of WRN blocks. Computed as N = (n - 4) / 6.')
    parser.add_argument('--wrn_k', type=int, default=4, help='Width factor of WRN')
    
    # DenseNet Parameters
    parser.add_argument('--dn_depth', type=int, default=40, help='Depth of DenseNet')
    parser.add_argument('--dn_growth_rate', type=int, default=12, help='Growth rate of DenseNet')
    
    args = parser.parse_args()
    """
    N = 2
    k = 4
    (trainX, trainY), (testX, testY) = cifar100.load_data()
    nb_classes = len(np.unique(testY))

    trainX = trainX.astype('float32')
    trainX /= 255.0
    testX = testX.astype('float32')
    testX /= 255.0

    trainY = kutils.to_categorical(trainY)
    testY_cat = kutils.to_categorical(testY)

    if K.image_dim_ordering() == "th":
        init = (3, 32, 32)
    else:
        init = (32, 32, 3)

    model = WRN.create_wide_residual_network(init,
                                             nb_classes=100,
                                             N=N,
                                             k=k,
                                             dropout=0.00)
    model_prefix = 'WRN-CIFAR100-%d-%d' % (N * 6 + 4, k)
    model.compile(loss="categorical_crossentropy",
                  optimizer="sgd",
                  metrics=["acc"])
    import os
    filename = os.path.join(repo, filename)
    if os.path.exists(filename):
        model.load_weights(filename)
    print("Finished compiling")
    return model, ((trainX, trainY), (testX, testY))
Ejemplo n.º 2
0
generator = ImageDataGenerator(rotation_range=15,
                               width_shift_range=5. / 32,
                               height_shift_range=5. / 32,
                               horizontal_flip=False)

generator.fit(trainX, seed=0, augment=True)

if K.image_dim_ordering() == "th":
    init = (3, img_rows, img_cols)
else:
    init = (img_rows, img_cols, 3)

if model_type == "wrn":
    model = WRN.create_wide_residual_network(init,
                                             nb_classes=100,
                                             N=args.wrn_N,
                                             k=args.wrn_k,
                                             dropout=0.00)

    model_prefix = 'WRN-CIFAR100-%d-%d' % (args.wrn_N * 6 + 4, args.wrn_k)
else:
    model = DN.create_dense_net(nb_classes=100,
                                img_dim=init,
                                depth=args.dn_depth,
                                nb_dense_block=1,
                                growth_rate=args.dn_growth_rate,
                                nb_filter=16,
                                dropout_rate=0.2)

    model_prefix = 'DenseNet-CIFAR100-%d-%d' % (args.dn_depth,
                                                args.dn_growth_rate)
Ejemplo n.º 3
0
def build_model(repo='', filename=''):
    parser = argparse.ArgumentParser(
        description='CIFAR 10 Ensemble Prediction')

    parser.add_argument('--M', type=int, default=5, help='Number of snapshots')
    parser.add_argument('--nb_epoch',
                        type=int,
                        default=200,
                        help='Number of training epochs')
    parser.add_argument('--alpha_zero',
                        type=float,
                        default=0.1,
                        help='Initial learning rate')

    parser.add_argument('--model',
                        type=str,
                        default='wrn',
                        help='Type of model to train')

    # Wide ResNet Parameters
    parser.add_argument(
        '--wrn_N',
        type=int,
        default=2,
        help='Number of WRN blocks. Computed as N = (n - 4) / 6.')
    parser.add_argument('--wrn_k',
                        type=int,
                        default=4,
                        help='Width factor of WRN')

    # DenseNet Parameters
    parser.add_argument('--dn_depth',
                        type=int,
                        default=40,
                        help='Depth of DenseNet')
    parser.add_argument('--dn_growth_rate',
                        type=int,
                        default=12,
                        help='Growth rate of DenseNet')

    args = parser.parse_args()
    ''' Snapshot major parameters '''
    M = args.M  # number of snapshots
    nb_epoch = T = args.nb_epoch  # number of epochs
    alpha_zero = args.alpha_zero  # initial learning rate

    model_type = str(args.model).lower()
    assert model_type in [
        'wrn', 'dn'
    ], 'Model type must be one of "wrn" for Wide ResNets or "dn" for DenseNets'

    snapshot = SnapshotCallbackBuilder(T, M, alpha_zero)

    batch_size = 128 if model_type == "wrn" else 64
    img_rows, img_cols = 32, 32

    (trainX, trainY), (testX, testY) = cifar10.load_data()

    trainX = trainX.astype('float32')
    trainX /= 255.0
    testX = testX.astype('float32')
    testX /= 255.0

    trainY_cat = kutils.to_categorical(trainY)
    testY_cat = kutils.to_categorical(testY)

    if K.image_dim_ordering() == "th":
        init = (3, img_rows, img_cols)
    else:
        init = (img_rows, img_cols, 3)

    model = WRN.create_wide_residual_network(init,
                                             nb_classes=10,
                                             N=args.wrn_N,
                                             k=args.wrn_k,
                                             dropout=0.00)

    model_prefix = 'WRN-CIFAR10-%d-%d' % (args.wrn_N * 6 + 4, args.wrn_k)
    model.compile(loss="categorical_crossentropy",
                  optimizer="sgd",
                  metrics=["acc"])
    import os
    filename = os.path.join(repo, filename)
    if os.path.exists(filename):
        model.load_weights(filename)
    print("Finished compiling")
    return model, ((trainX, trainY_cat), (testX, testY))