Exemplo n.º 1
0
def test_nested_sequential(in_tmpdir):
    (x_train, y_train), (x_test, y_test) = _get_test_data()

    inner = Sequential()
    inner.add(Dense(num_hidden, input_shape=(input_dim,)))
    inner.add(Activation('relu'))
    inner.add(Dense(num_class))

    middle = Sequential()
    middle.add(inner)

    model = Sequential()
    model.add(middle)
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test))
    model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2, validation_split=0.1)
    model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=0)
    model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, shuffle=False)

    model.train_on_batch(x_train[:32], y_train[:32])

    loss = model.evaluate(x_test, y_test, verbose=0)

    model.predict(x_test, verbose=0)
    model.predict_classes(x_test, verbose=0)
    model.predict_proba(x_test, verbose=0)

    fname = 'test_nested_sequential_temp.h5'
    model.save_weights(fname, overwrite=True)

    inner = Sequential()
    inner.add(Dense(num_hidden, input_shape=(input_dim,)))
    inner.add(Activation('relu'))
    inner.add(Dense(num_class))

    middle = Sequential()
    middle.add(inner)

    model = Sequential()
    model.add(middle)
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate(x_test, y_test, verbose=0)
    assert(loss == nloss)

    # test serialization
    config = model.get_config()
    Sequential.from_config(config)

    model.summary()
    json_str = model.to_json()
    model_from_json(json_str)

    yaml_str = model.to_yaml()
    model_from_yaml(yaml_str)
def build_model(x_data, y_data, x_test, y_test):
    print(x_data[0])
    print(y_data[0])
    model = Sequential()
    model.add(Dense(input_shape=[x_data.shape[1]],output_dim=300, kernel_initializer= initializers.Zeros()))
    model.add(Activation('linear'))
#    model.add(Dropout(0.1))
#    model.add(Activation('relu'))
    model.add(Dense(output_dim=100))
    model.add(Activation('tanh'))
#    model.add(Dense(output_dim=100))
#    model.add(Activation('relu'))
    model.add(Dense(output_dim=1))
    model.add(Activation('sigmoid'))
    sgd = SGD(lr=0.01, decay=0.0001, momentum=0.2, nesterov=True)
    model.compile(loss='binary_crossentropy', optimizer=sgd)
    model.fit(x_data, y_data, batch_size=10000, nb_epoch=20, shuffle=True, validation_split=0.2)
    preds = model.predict_proba(x_data)
    result = metrics.roc_auc_score(y_data, preds)
    print(result)
    print("test")
    preds = model.predict_proba(x_test)
    for i in range(0, 50):
        print("result=%.4f, %.4f" %(preds[i], y_test[i])) 
    result = metrics.roc_auc_score(y_test, preds)
    print(result)
Exemplo n.º 3
0
def test_nested_sequential():
    (X_train, y_train), (X_test, y_test) = _get_test_data()

    inner = Sequential()
    inner.add(Dense(nb_hidden, input_shape=(input_dim,)))
    inner.add(Activation("relu"))
    inner.add(Dense(nb_class))

    middle = Sequential()
    middle.add(inner)

    model = Sequential()
    model.add(middle)
    model.add(Activation("softmax"))
    model.compile(loss="categorical_crossentropy", optimizer="rmsprop")

    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(X_test, y_test))
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_split=0.1)
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False)

    model.train_on_batch(X_train[:32], y_train[:32])

    loss = model.evaluate(X_test, y_test, verbose=0)

    model.predict(X_test, verbose=0)
    model.predict_classes(X_test, verbose=0)
    model.predict_proba(X_test, verbose=0)

    fname = "test_nested_sequential_temp.h5"
    model.save_weights(fname, overwrite=True)

    inner = Sequential()
    inner.add(Dense(nb_hidden, input_shape=(input_dim,)))
    inner.add(Activation("relu"))
    inner.add(Dense(nb_class))

    middle = Sequential()
    middle.add(inner)

    model = Sequential()
    model.add(middle)
    model.add(Activation("softmax"))
    model.compile(loss="categorical_crossentropy", optimizer="rmsprop")
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate(X_test, y_test, verbose=0)
    assert loss == nloss

    # test serialization
    config = model.get_config()
    new_model = Sequential.from_config(config)

    model.summary()
    json_str = model.to_json()
    new_model = model_from_json(json_str)

    yaml_str = model.to_yaml()
    new_model = model_from_yaml(yaml_str)
Exemplo n.º 4
0
def test_merge_overlap():
    left = Sequential()
    left.add(Dense(nb_hidden, input_shape=(input_dim,)))
    left.add(Activation('relu'))

    model = Sequential()
    model.add(Merge([left, left], mode='sum'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=1, validation_data=(X_test, y_test))
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=2, validation_data=(X_test, y_test))
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=2, validation_split=0.1)
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=1, validation_split=0.1)
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False)

    model.train_on_batch(X_train[:32], y_train[:32])

    loss = model.evaluate(X_train, y_train, verbose=0)
    assert(loss < 0.7)
    model.predict(X_test, verbose=0)
    model.predict_classes(X_test, verbose=0)
    model.predict_proba(X_test, verbose=0)
    model.get_config(verbose=0)

    fname = 'test_merge_overlap_temp.h5'
    model.save_weights(fname, overwrite=True)
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate(X_train, y_train, verbose=0)
    assert(loss == nloss)
Exemplo n.º 5
0
def test_merge_sum():
    (X_train, y_train), (X_test, y_test) = _get_test_data()
    left = Sequential()
    left.add(Dense(nb_hidden, input_shape=(input_dim,)))
    left.add(Activation('relu'))

    right = Sequential()
    right.add(Dense(nb_hidden, input_shape=(input_dim,)))
    right.add(Activation('relu'))

    model = Sequential()
    model.add(Merge([left, right], mode='sum'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=([X_test, X_test], y_test))
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_split=0.1)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False)

    loss = model.evaluate([X_test, X_test], y_test, verbose=0)

    model.predict([X_test, X_test], verbose=0)
    model.predict_classes([X_test, X_test], verbose=0)
    model.predict_proba([X_test, X_test], verbose=0)

    # test weight saving
    fname = 'test_merge_sum_temp.h5'
    model.save_weights(fname, overwrite=True)
    left = Sequential()
    left.add(Dense(nb_hidden, input_shape=(input_dim,)))
    left.add(Activation('relu'))
    right = Sequential()
    right.add(Dense(nb_hidden, input_shape=(input_dim,)))
    right.add(Activation('relu'))
    model = Sequential()
    model.add(Merge([left, right], mode='sum'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))
    model.load_weights(fname)
    os.remove(fname)
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    nloss = model.evaluate([X_test, X_test], y_test, verbose=0)
    assert(loss == nloss)

    # test serialization
    config = model.get_config()
    Sequential.from_config(config)

    model.summary()
    json_str = model.to_json()
    model_from_json(json_str)

    yaml_str = model.to_yaml()
    model_from_yaml(yaml_str)
Exemplo n.º 6
0
    def test_merge_concat(self):
        print('Test merge: concat')
        left = Sequential()
        left.add(Dense(nb_hidden, input_shape=(input_dim,)))
        left.add(Activation('relu'))

        right = Sequential()
        right.add(Dense(nb_hidden, input_shape=(input_dim,)))
        right.add(Activation('relu'))

        model = Sequential()
        model.add(Merge([left, right], mode='concat'))
        model.add(Dense(nb_class))
        model.add(Activation('softmax'))
        model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

        model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_data=([X_test, X_test], y_test))
        model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_data=([X_test, X_test], y_test))
        model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_split=0.1)
        model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_split=0.1)
        model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
        model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False)

        loss = model.evaluate([X_train, X_train], y_train, verbose=0)
        print('loss:', loss)
        if loss > 0.7:
            raise Exception('Score too low, learning issue.')
        model.predict([X_test, X_test], verbose=0)
        model.predict_classes([X_test, X_test], verbose=0)
        model.predict_proba([X_test, X_test], verbose=0)
        model.get_config(verbose=0)

        print('test weight saving')
        fname = 'test_merge_concat_temp.h5'
        model.save_weights(fname, overwrite=True)
        left = Sequential()
        left.add(Dense(nb_hidden, input_shape=(input_dim,)))
        left.add(Activation('relu'))

        right = Sequential()
        right.add(Dense(nb_hidden, input_shape=(input_dim,)))
        right.add(Activation('relu'))

        model = Sequential()
        model.add(Merge([left, right], mode='concat'))

        model.add(Dense(nb_class))
        model.add(Activation('softmax'))

        model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
        model.load_weights(fname)
        os.remove(fname)

        nloss = model.evaluate([X_train, X_train], y_train, verbose=0)
        assert(loss == nloss)
Exemplo n.º 7
0
def test_siamese_1():
    (X_train, y_train), (X_test, y_test) = _get_test_data()
    left = Sequential()
    left.add(Dense(nb_hidden, input_shape=(input_dim,)))
    left.add(Activation('relu'))

    right = Sequential()
    right.add(Dense(nb_hidden, input_shape=(input_dim,)))
    right.add(Activation('relu'))

    model = Sequential()
    model.add(Siamese(Dense(nb_hidden), [left, right], merge_mode='sum'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_data=([X_test, X_test], y_test))
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_data=([X_test, X_test], y_test))
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_split=0.1)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_split=0.1)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False)

    loss = model.evaluate([X_test, X_test], y_test, verbose=0)
    assert(loss < 0.8)

    model.predict([X_test, X_test], verbose=0)
    model.predict_classes([X_test, X_test], verbose=0)
    model.predict_proba([X_test, X_test], verbose=0)
    model.get_config(verbose=0)

    # test weight saving
    fname = 'test_siamese_1.h5'
    model.save_weights(fname, overwrite=True)
    left = Sequential()
    left.add(Dense(nb_hidden, input_shape=(input_dim,)))
    left.add(Activation('relu'))

    right = Sequential()
    right.add(Dense(nb_hidden, input_shape=(input_dim,)))
    right.add(Activation('relu'))

    model = Sequential()
    model.add(Siamese(Dense(nb_hidden), [left, right], merge_mode='sum'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))

    model.load_weights(fname)
    os.remove(fname)
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    nloss = model.evaluate([X_test, X_test], y_test, verbose=0)
    assert(loss == nloss)
Exemplo n.º 8
0
    def test_sequential(self):
        print('Test sequential')
        model = Sequential()
        model.add(Dense(nb_hidden, input_shape=(input_dim,)))
        model.add(Activation('relu'))
        model.add(Dense(nb_class))
        model.add(Activation('softmax'))
        model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

        model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=1, validation_data=(X_test, y_test))
        model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=2, validation_data=(X_test, y_test))
        model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=2, validation_split=0.1)
        model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=1, validation_split=0.1)
        model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
        model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False)

        model.train_on_batch(X_train[:32], y_train[:32])

        loss = model.evaluate(X_train, y_train, verbose=0)
        print('loss:', loss)
        if loss > 0.7:
            raise Exception('Score too low, learning issue.')
        model.predict(X_test, verbose=0)
        model.predict_classes(X_test, verbose=0)
        model.predict_proba(X_test, verbose=0)
        model.get_config(verbose=0)

        print('test weight saving')
        fname = 'test_sequential_temp.h5'
        model.save_weights(fname, overwrite=True)
        model = Sequential()
        model.add(Dense(nb_hidden, input_shape=(input_dim,)))
        model.add(Activation('relu'))
        model.add(Dense(nb_class))
        model.add(Activation('softmax'))
        model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
        model.load_weights(fname)
        os.remove(fname)

        nloss = model.evaluate(X_train, y_train, verbose=0)
        assert(loss == nloss)

        # test json serialization
        json_data = model.to_json()
        model = model_from_json(json_data)

        # test yaml serialization
        yaml_data = model.to_yaml()
        model = model_from_yaml(yaml_data)
Exemplo n.º 9
0
def getDNN(df, random_split=None):
    df_tr, df_val = split(df, rand_ratio=random_split)
    
    X, Y = to_array(df.drop("validation", axis=1))
    Xtr, Ytr = to_array(df_tr)
    Xval, Yval = to_array(df_val)

    scaler = MinMaxScaler((0, 1))
    Xtr = scaler.fit_transform(Xtr)
    Xval = scaler.transform(Xval)

    # Start create model
    print("Create a DNN Classifier")
    model = Sequential()

    model.add(Dense(100, input_dim=Xtr.shape[1], activation='tanh'))
    model.add(PReLU())
    model.add(Dropout(0.2))
    model.add(Dense(80, activation='linear'))
    model.add(ELU(alpha=0.3))
    model.add(Dropout(0.2))
    model.add(Dense(60, activation='tanh'))
    model.add(PReLU())
    model.add(Dropout(0.2))
    model.add(Dense(40, activation='linear'))
    model.add(ELU(alpha=0.1))
    model.add(Dropout(0.2))
    model.add(Dense(15, activation='linear'))
    model.add(PReLU())
    model.add(Dropout(0.2))
    model.add(Dense(1, activation='sigmoid'))

    # trainer = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
    trainer = Adadelta(lr=0.1, tho=0.98, epsilon=1e-7)
    model.compile(loss='binary_crossentropy', optimizer=trainer)
    
    print(Ytr, Yval)
    model.fit(Xtr, Ytr, nb_epoch=30, batch_size=32, verbose=1, validation_data=(Xval, Yval))


    pred_tr = model.predict_proba(Xtr)
    pred = model.predict_proba(Xval)
    print("auc on train: {}".format(roc_auc_score(Ytr, pred_tr)))
    print("auc on validation: {}".format(roc_auc_score(Yval, pred)))

    X = scaler.fit_transform(X)
    model.fit(X, Y, nb_epoch=30, batch_size=32)
    return model, scaler
Exemplo n.º 10
0
def train(in_dim, out_dim, X_train, Y_train, X_test, Y_test):
    model = Sequential()
    model.add(Dense(100000, input_dim = in_dim, init='uniform'))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))

    model.add(Dense(100000, init='uniform'))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))

    model.add(Dense(out_dim, init='uniform'))
    model.add(Activation('softmax'))

    model.compile(loss='categorical_crossentropy', optimizer='sgd',\
            metrics=['accuracy'])

    hist = model.fit(X_train, Y_train, nb_epoch=5, batch_size=32,\
            validation_split=0.1, shuffle=True)
    print(hist.history)

    loss_and_metrics = model.evaluate(X_test, Y_test, batch_size=32)

    classes = model.predict_classes(X_test, batch_size=32)

    proba = model.predict_proba(X_test, batch_size=32)
Exemplo n.º 11
0
def brain(x_train, y_train, x_test, y_test):
    from keras.models import Sequential
    from keras.layers.core import Dense, Activation
    from keras.optimizers import SGD

    number_of_classes = y_train.shape[1]
    model = Sequential()

    model.add(Dense(output_dim=64, input_dim=x_train.shape[1]))
    model.add(Activation("relu"))
    model.add(Dense(output_dim=number_of_classes))
    model.add(Activation("sigmoid"))

    #model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
    model.compile(loss='binary_crossentropy',
                  optimizer='sgd',#SGD(lr=0.01, momentum=0.9, nesterov=True),
                  metrics=['accuracy']
                 )
    model.fit(x_train, y_train, nb_epoch=5, batch_size=32)

    loss_and_metrics = model.evaluate(x_test, y_test, batch_size=32)
    print("Metrics:")
    print(loss_and_metrics)

    classes = model.predict_classes(x_test, batch_size=32)
    proba = model.predict_proba(x_test, batch_size=32)
Exemplo n.º 12
0
def build_and_fit_model(X_train,y_train,X_test=None,y_test=None,hn=32,dp=0.5,layers=1,epochs=1,batches=64,verbose=0):
    input_dim=X_train.shape[1]
    output_dim=len(labels_train.unique())
    Y_train=y_train.cat.rename_categories(range(len(y_train.unique())))
#     print output_dim
    model = Sequential()
    model.add(Dense(input_dim, hn, init='glorot_uniform'))
    model.add(PReLU((hn,)))
    model.add(Dropout(dp))

    for i in range(layers):
      model.add(Dense(hn, hn, init='glorot_uniform'))
      model.add(PReLU((hn,)))
      model.add(BatchNormalization((hn,)))
      model.add(Dropout(dp))

    model.add(Dense(hn, output_dim, init='glorot_uniform'))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='adam')
    
    if X_test is not None:
        Y_test=y_test.cat.rename_categories(range(len(y_test.unique())))
        fitting=model.fit(X_train, Y_train, nb_epoch=epochs, batch_size=batches,verbose=verbose,validation_data=(X_test,Y_test))
        test_score = log_loss(y_test, model.predict_proba(X_test,verbose=0))
    else:
        model.fit(X_train, Y_train, nb_epoch=epochs, batch_size=batches,verbose=verbose)
        fitting=0
        test_score = 0
    return test_score, fitting, model
Exemplo n.º 13
0
def f_nn(params):   
    from keras.models import Sequential
    from keras.layers.core import Dense, Dropout, Activation
    from keras.optimizers import Adadelta, Adam, rmsprop

    print ('Params testing: ', params)
    model = Sequential()
    model.add(Dense(output_dim=params['units1'], input_dim = X.shape[1])) 
    model.add(Activation(params['activation1']))
    model.add(Dropout(params['dropout1']))

    model.add(Dense(output_dim=params['units2'], init = "glorot_uniform")) 
    model.add(Activation(params['activation2']))
    model.add(Dropout(params['dropout2']))

    if params['choice']['layers']== 'three':
        model.add(Dense(output_dim=params['choice']['units3'], init = "glorot_uniform")) 
        model.add(Activation(params['choice']['activation3']))
        model.add(Dropout(params['choice']['dropout3']))    

    model.add(Dense(2))
    model.add(Activation('sigmoid'))
    model.compile(loss='binary_crossentropy', optimizer=params['optimizer'])

    model.fit(X, y, nb_epoch=params['nb_epochs'], batch_size=params['batch_size'], verbose = 1)

    pred_auc =model.predict_proba(X_val, batch_size = 128, verbose = 1)
    acc = log_loss(y_val, pred_auc)

    print("\n")
    print('logloss:', acc)
    sys.stdout.flush() 
    return {'loss': acc, 'status': STATUS_OK}
Exemplo n.º 14
0
class MLP(Classifier):
    def __init__(self, runDimRed, dimRedType='', sampleType=1, numDrivers=1, numTrips=1):
        self.runDimRed = runDimRed
        super(MLP, self).__init__('MultilayerPerceptron', dimRedType, sampleType, numDrivers, numTrips)
        self.initmodel()
        self.sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)

    def initmodel(self):
        self.model = Sequential()
        self.model.add(Dense(64, input_dim=50, init='uniform'))
        self.model.add(Activation('tanh'))
        self.model.add(Dropout(0.5))
        self.model.add(Dense(64, init='uniform'))
        self.model.add(Activation('tanh'))
        self.model.add(Dropout(0.5))
        self.model.add(Dense(1, init='uniform'))
        self.model.add(Activation('softmax'))

    def runClassifier(self, _driverId, numComponents=0):
        X, Y = self.randomSampler(_driverId)
        if self.runDimRed:
            X = self.dimRed(X, Y, numComponents)

        self.ids = self.globalFeatureHash[_driverId].keys()

        self.model.compile(loss='mean_squared_error', optimizer=self.sgd)
        self.model.fit(X, Y, nb_epoch=500)

        self.label = self.model.predict_proba(X).T[0]
Exemplo n.º 15
0
def test_merge_recursivity():
    left = Sequential()
    left.add(Dense(nb_hidden, input_shape=(input_dim,)))
    left.add(Activation('relu'))

    right = Sequential()
    right.add(Dense(nb_hidden, input_shape=(input_dim,)))
    right.add(Activation('relu'))

    righter = Sequential()
    righter.add(Dense(nb_hidden, input_shape=(input_dim,)))
    righter.add(Activation('relu'))

    intermediate = Sequential()
    intermediate.add(Merge([left, right], mode='sum'))
    intermediate.add(Dense(nb_hidden))
    intermediate.add(Activation('relu'))

    model = Sequential()
    model.add(Merge([intermediate, righter], mode='sum'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_data=([X_test, X_test, X_test], y_test))
    model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_data=([X_test, X_test, X_test], y_test))
    model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_split=0.1)
    model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_split=0.1)
    model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False)

    loss = model.evaluate([X_train, X_train, X_train], y_train, verbose=0)
    assert(loss < 0.7)

    model.predict([X_test, X_test, X_test], verbose=0)
    model.predict_classes([X_test, X_test, X_test], verbose=0)
    model.predict_proba([X_test, X_test, X_test], verbose=0)
    model.get_config(verbose=0)

    fname = 'test_merge_recursivity_temp.h5'
    model.save_weights(fname, overwrite=True)
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate([X_train, X_train, X_train], y_train, verbose=0)
    assert(loss == nloss)
Exemplo n.º 16
0
	def classifier(self):
		level='one'
		data_instance=Load_scale_data(self.config)
		X_0,X_1,uid_0,uid_1=data_instance.load_train_X_separate()
		X_0_train,X_0_test=train_test_split(X_0,test_size=0.2)
		X_1_train,X_1_test=train_test_split(X_1,test_size=0.2)
		
		X_train=np.vstack((X_1_train,X_0_train))
		X_test=np.vstack((X_1_test,X_0_test))

		y_train=np.hstack((np.ones(len(X_1_train)),np.zeros(len(X_0_train))))	
		y_test=np.hstack((np.ones(len(X_1_test)),np.zeros(len(X_0_test))))


		batch_size = 128
		nb_classes = 2
		nb_epoch = 10

		# the data, shuffled and split between train and test sets

		X_train = X_train.astype('float32')
		X_test = X_test.astype('float32')

		print(X_train.shape[0], 'train samples')
		print(X_test.shape[0], 'test samples')

		# convert class vectors to binary class matrices
		Y_train = np_utils.to_categorical(y_train, nb_classes)
		Y_test = np_utils.to_categorical(y_test, nb_classes)


		model = Sequential() 
		model.add(Dense(50,input_shape=(X_train.shape[1],)))
		model.add(Activation('relu'))
		model.add(Dropout(0.2))
		model.add(Dense(50)) 
		model.add(Activation('linear'))
		model.add(Dropout(0.2))
		model.add(Dense(2))
		model.add(Activation('sigmoid'))

		#model.summary()
		sgd = SGD(lr=0.001, decay=1e-6, momentum=0.01, nesterov=True)
		model.compile(loss='binary_crossentropy', optimizer=sgd,metrics=['accuracy'])

		history = model.fit(X_train, Y_train,
                    batch_size=batch_size, nb_epoch=nb_epoch,
                    verbose=1, validation_data=(X_test, Y_test))

		score = model.evaluate(X_test, Y_test, verbose=0)
		y_pred=model.predict_proba(X_test)
		print y_pred
		print len(y_pred[:,0]),sum(y_pred[:,0])

		auc_score=metrics.roc_auc_score(y_test,y_pred[:,0])
		print auc_score
		print('Test score:', score[0])
		print('Test accuracy:', score[1])
Exemplo n.º 17
0
def test_merge_overlap():
    (X_train, y_train), (X_test, y_test) = _get_test_data()
    left = Sequential()
    left.add(Dense(nb_hidden, input_shape=(input_dim,)))
    left.add(Activation('relu'))

    model = Sequential()
    model.add(Merge([left, left], mode='sum'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(X_test, y_test))
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_split=0.1)
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False)

    model.train_on_batch(X_train[:32], y_train[:32])

    loss = model.evaluate(X_test, y_test, verbose=0)
    model.predict(X_test, verbose=0)
    model.predict_classes(X_test, verbose=0)
    model.predict_proba(X_test, verbose=0)

    fname = 'test_merge_overlap_temp.h5'
    print(model.layers)
    model.save_weights(fname, overwrite=True)
    print(model.trainable_weights)

    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate(X_test, y_test, verbose=0)
    assert(loss == nloss)

    # test serialization
    config = model.get_config()
    new_model = Sequential.from_config(config)

    model.summary()
    json_str = model.to_json()
    new_model = model_from_json(json_str)

    yaml_str = model.to_yaml()
    new_model = model_from_yaml(yaml_str)
Exemplo n.º 18
0
def glm_bernoulli_keras(Xr, Yr, Xt):
    model = Sequential()
    model.add(Dense(1, input_dim=np.shape(Xr)[1], init='uniform', activation='linear'))
    model.add(Lambda(lambda x: np.exp(x)))
    #model.compile(loss='poisson', optimizer='rmsprop')
    model.compile(loss='binary_crossentropy',optimizer='rmsprop')
    model.fit(Xr, Yr, nb_epoch=3, batch_size=16, verbose=0, validation_split=0.0)
    Yt = model.predict_proba(Xt, verbose=0)
    return Yt[:,0]
Exemplo n.º 19
0
def test_merge_concat():
    (X_train, y_train), (X_test, y_test) = _get_test_data()

    left = Sequential(name="branch_1")
    left.add(Dense(nb_hidden, input_shape=(input_dim,), name="dense_1"))
    left.add(Activation("relu", name="relu_1"))

    right = Sequential(name="branch_2")
    right.add(Dense(nb_hidden, input_shape=(input_dim,), name="dense_2"))
    right.add(Activation("relu", name="relu_2"))

    model = Sequential(name="merged_branches")
    model.add(Merge([left, right], mode="concat", name="merge"))
    model.add(Dense(nb_class, name="final_dense"))
    model.add(Activation("softmax", name="softmax"))
    model.compile(loss="categorical_crossentropy", optimizer="rmsprop")

    model.fit(
        [X_train, X_train],
        y_train,
        batch_size=batch_size,
        nb_epoch=nb_epoch,
        verbose=0,
        validation_data=([X_test, X_test], y_test),
    )
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_split=0.1)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False)

    loss = model.evaluate([X_test, X_test], y_test, verbose=0)

    model.predict([X_test, X_test], verbose=0)
    model.predict_classes([X_test, X_test], verbose=0)
    model.predict_proba([X_test, X_test], verbose=0)
    model.get_config()

    fname = "test_merge_concat_temp.h5"
    model.save_weights(fname, overwrite=True)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate([X_test, X_test], y_test, verbose=0)
    assert loss == nloss
Exemplo n.º 20
0
def blstm_II_2layers(X, y, word_vec_len=300, batch_size=100, nb_epoch=10, threshold=0.5):
    words_size = 13033
    max_sentence_length = 47   # cut texts after this number of words (among top max_features most common words)

    # 数据shuffle
    indices = permutation(X.shape[0])  # shape[0]表示第0轴的长度,通常是训练数据的数量
    X = X[indices]
    y = y[indices]

    X_train, X_test = X[:0.9*len(X)], X[0.9*len(X):]
    y_train, y_test = y[:0.9*len(y)], y[0.9*len(y):]
    print len(X_train), 'train sequences'
    print len(X_test), 'test sequences'

    print "Pad sequences (samples x time)"
    X_train = sequence.pad_sequences(X_train, maxlen=max_sentence_length)
    X_test = sequence.pad_sequences(X_test, maxlen=max_sentence_length)
    print 'X_train shape:', X_train.shape
    print 'X_test shape:', X_test.shape
    print 'y_train shape:', y_train.shape
    print 'y_test shape:', y_test.shape

    print('Build model...')
    model = Sequential()

    model.add(Embedding(words_size+1, word_vec_len))
    # Stacked up BiDirectionLSTM layers
    model.add(BiDirectionLSTM(word_vec_len, 100, output_mode='sum', return_sequences=True))
    model.add(BiDirectionLSTM(100, 100, output_mode='sum', return_sequences=True))

    # MLP layers
    model.add(Reshape(100 * max_sentence_length, ))
    model.add(BatchNormalization((100 * max_sentence_length,)))
    model.add(Dense(100 * max_sentence_length, 50, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(50, 1, activation='sigmoid'))

    # sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
    # model.compile(loss='binary_crossentropy', optimizer=sgd, class_mode='binary')
    model.compile(loss='binary_crossentropy', optimizer='adagrad', class_mode='binary')

    print("Train...")
    model.fit(X_train, y_train, shuffle=True, batch_size=batch_size, nb_epoch=nb_epoch, validation_split=0.1, show_accuracy=True)

    probas = model.predict_proba(X_test)
    for threshold in [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]:
        classes = get_class(probas, threshold)
        accuracy = accuracy_score(y_test, classes)
        precision = precision_score(y_test, classes)
        recall = recall_score(y_test, classes)
        f1 = f1_score(y_test, classes)
        print '========阈值为%f时的结果========' % threshold
        print 'accuracy:', accuracy
        print 'precision:', precision
        print 'recall:', recall
        print 'F1:', f1
Exemplo n.º 21
0
class KerasNNReg(BaseEstimator):
    def __init__(self, dims=66, nb_classes=1, nb_epoch=30, learning_rate=0.5, validation_split=0.0, batch_size=64,
                 loss='mean_absolute_error', verbose=1):
        self.dims = dims
        self.nb_classes = nb_classes
        self.nb_epoch = nb_epoch
        self.learning_rate = learning_rate
        self.validation_split = validation_split
        self.batch_size = batch_size
        self.loss = loss
        self.verbose = verbose

        # Embedding
        # model_store = Sequential()
        # model_store.add(Embedding(1115, 50, input_length=1))
        # model_store.add(Reshape(dims=(50,)))
        # models.append(model_store)


        self.model = Sequential()
        # self.model.add(Merge(models, mode='concat'))
        # Keras model
        self.model.add(Dense(output_dim=1024, input_dim=dims, init='uniform'))
        self.model.add(Activation('sigmoid'))
        self.model.add(BatchNormalization())
        #self.model.add(Dropout(0.0))

        self.model.add(Dense(output_dim=512, init='uniform'))
        self.model.add(Activation('sigmoid'))
        self.model.add(BatchNormalization())
        #self.model.add(Dropout(0.0))

        #self.model.add(Dense(output_dim=256, init='uniform'))
        #self.model.add(Activation('relu'))
        # self.model.add(Dropout(0.1))

        self.model.add(Dense(1))
        # self.model.add(Activation('sigmoid'))

        print('Compiling Keras Deep Net with loss: %s' % (str(loss)))
        self.model.compile(loss=loss, optimizer='rmsprop')

    def fit(self, X, y, sample_weight=None):
        print('Fitting  Keras Deep Net for regression with batch_size %d, epochs %d  and learning rate: %f' % (
        self.batch_size, self.nb_epoch, self.learning_rate))
        self.model.fit(X, y, nb_epoch=self.nb_epoch, batch_size=self.batch_size,
                       validation_split=self.validation_split)

    def predict_proba(self, Xtest):
        ypred = self.model.predict_proba(Xtest, batch_size=self.batch_size, verbose=self.verbose)
        return ypred

    def predict(self, Xtest):
        ypred = self.model.predict(Xtest, batch_size=self.batch_size, verbose=self.verbose)
        return ypred
def build_model(x_data, y_data, x_test, y_test):
    model = Sequential()
    model.add(Dense(input_shape=[x_data.shape[1]],output_dim=100, kernel_initializer= initializers.RandomNormal()))
    model.add(Activation('linear'))
    #model.add(Dropout(0.4))
    #model.add(Activation('relu'))
    model.add(Dense(output_dim=100))
    model.add(Activation('tanh'))
#    model.add(Dense(output_dim=100))
#    model.add(Activation('relu'))
    model.add(Dense(output_dim=3))
    model.add(Activation('softmax'))
    sgd = SGD(lr=0.01, decay=0.0001, momentum=0.2, nesterov=True)
    model.compile(loss='categorical_crossentropy', optimizer=sgd)
    model.fit(x_data, y_data, batch_size=100, nb_epoch=20, shuffle=True, validation_split=0.2)
    preds = model.predict_proba(x_data)
    result = metrics.roc_auc_score(y_data[:,2], preds[:,2])
    print(result)
    print("test")
    preds = model.predict_proba(x_test)
    pred1 = utils.to_categorical(model.predict_classes(x_test))
    for i in range(0, 50):
        print("result=%.4f, %.4f" %(preds[i][0], y_test[i][2])) 
    result = metrics.roc_auc_score(y_test[:,2], preds[:,2])
    print(result)
    print(y_test[0])
    print(pred1[0])
    result = confusion_matrix(y_test, pred1)
    print(result)
    num = [0.0001, 0, 0]
    res_list = numpy.hstack((y_test[:,2].reshape(y_test.shape[0],1), preds[:,2].reshape(preds.shape[0],1)))
    res_sorted = sorted(res_list, key = lambda x:x[1], reverse = True)
    for i in range(0, y_test.shape[0]):
        if  i<=3 and res_sorted[i][1] >= 0.4:
            print("single result = %s " %(res_sorted[i]))
            num[0] += 1
        if res_sorted[i][1]>=0.4 and res_sorted[i][0]== 1  and i<=3:
            num[1] += 1
        if y_test[i][2] == 1:
           num[2] += 1
    print("process result = %.4f\t%d\t%d\t%dt\t%.4f" %(num[0], num[1], num[2], preds.shape[0], num[1]/num[0]))
Exemplo n.º 23
0
def build_model(x_data, y_data, x_test, y_test):
    model = Sequential()
    model.add(Dense(input_shape=[x_data.shape[1]],output_dim=1000, kernel_initializer= initializers.RandomNormal()))
    model.add(Activation('tanh'))
#    model.add(Dropout(0.4))
#    model.add(Activation('linear'))
    model.add(Dense(output_dim=1000, kernel_initializer= initializers.RandomNormal()))
    model.add(Activation('tanh'))
#    model.add(Dense(output_dim=100))
#    model.add(Activation('relu'))
    model.add(Dense(output_dim=1, kernel_initializer= initializers.RandomNormal()))
    model.add(Activation('sigmoid'))
    sgd = SGD(lr=0.005, decay=0.0001, momentum=0.2, nesterov=True)
    model.compile(loss='binary_crossentropy', metrics=['accuracy'], optimizer=sgd)
#    model.fit(x_data, y_data, batch_size=4, nb_epoch=20, shuffle=True, validation_split=0.2)
    model.fit(x_data, y_data)
    preds = model.predict_proba(x_data)
    result = metrics.roc_auc_score(y_data, preds)
    print(result)
    print("test")
    preds = model.predict_proba(x_test)
    for i in range(0, 10):
        print("result=%.4f, %.4f" %(preds[i], y_test[i])) 
    result = metrics.roc_auc_score(y_test, preds)
    print(result)
    num = [0.0001, 0, 0]
    res_list = numpy.hstack((y_test, preds))
    res_sorted = sorted(res_list, key = lambda x:x[1], reverse = True)
    for i in range(0, y_test.shape[0]):
        if  i<=3 and res_sorted[i][1] >= 0.5:
            print("single result = %s" %(res_sorted[i]))
            num[0] += 1
        if res_sorted[i][1]>=0.5 and res_sorted[i][0]== 1  and i<=3:
            num[1] += 1
        if y_test[i] == 1:
           num[2] += 1
    for i in model.model.metrics_names:
        print("gradient update = %s" %(i))
    print("process_result: %.4f %d %d %d %.4f" %(num[0], num[1], num[2], preds.shape[0], num[1]/num[0]))
Exemplo n.º 24
0
def build_NN(X_train,y_train_nn,X_cal,y_cal,X_test):
    cal_prob,test_prob = 0,0
    nb_classes = y_train_nn.shape[1]
    dims = X_train.shape[1]

    for i in range(5):
        print("--Building and Training model %s" % i)
        seed = randrange(1,10000)
        np.random.seed(seed)

        model = Sequential()

        model.add(Dense(dims, 512, init='glorot_uniform'))
        model.add(PReLU((512,)))
        model.add(BatchNormalization((512,)))
        model.add(Dropout(0.5))

        model.add(Dense(512, 512, init='glorot_uniform'))
        model.add(PReLU((512,)))
        model.add(BatchNormalization((512,)))
        model.add(Dropout(0.5))

        model.add(Dense(512, 512, init='glorot_uniform'))
        model.add(PReLU((512,)))
        model.add(BatchNormalization((512,)))
        model.add(Dropout(0.5))

        model.add(Dense(512, nb_classes, init='glorot_uniform'))
        model.add(Activation('softmax'))

        model.compile(loss='categorical_crossentropy', optimizer="adam")

        model.fit(X_train, y_train_nn, nb_epoch=20, batch_size=16, validation_split=0.15)

        cal_prob += model.predict_proba(X_cal)
        test_prob += model.predict_proba(X_test)
    cal_prob,test_prob = cal_prob/10.,test_prob/10.
    print("Avg NN Model Loss: %0.4f" % of.logloss_mc(y_cal,cal_prob))
    return(cal_prob,test_prob)
Exemplo n.º 25
0
def testNN(X_train, X_test, y_train, y_test, hiddenSize=256, nepochs=500, dropouts=0.25):
    """
    Train a Neural Network with dropouts and predict test data.

    :param X_train: training data
    :param X_test: test data
    :param y_train: training labels
    :param y_test: test labels
    :param hiddenSize: set the number of hidden nodes in each layer
    :param nepochs: number of times to update the weights
    :param dropouts: dropout fraction - randomly drop units from each layer

    :return: predictions for the test data
    """
    # specify sequential model - input, two middle layers, and output layer
    model = Sequential()

    # input layer
    model.add(Dense(hiddenSize, input_dim=X_train.shape[1], init='glorot_uniform', activation='relu'))
    model.add(Dropout(dropouts))

    # hidden layers
    model.add(Dense(hiddenSize, activation='relu'))
    model.add(Dropout(dropouts))
    model.add(Dense(hiddenSize, activation='relu'))
    model.add(Dropout(dropouts))

    # output layer
    model.add(Dense(1, activation='sigmoid'))

    # set the optimizer and compile
    opt = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
    #opt = RMSprop(lr=0.001, rho=0.9, epsilon=1e-06)
    model.compile(loss='binary_crossentropy', optimizer=opt)

    # fit the model using training data
    model.fit(X_train, y_train, nb_epoch=nepochs, batch_size=8192,
              validation_split=0.1, show_accuracy=True, verbose=1,
              callbacks=[EarlyStopping(monitor='val_loss', patience=10)])
    print('Training completed...')

    # make a figure of the model
    keras.utils.visualize_util.plot(model, to_file='model.png')

    print('predict test data...')
    yhat = model.predict_proba(X_test, batch_size=5000)
    auc = metrics.roc_auc_score(y_test, yhat)
    print('Results:')
    print('NN AUC:', auc)

    return yhat
Exemplo n.º 26
0
def build_model(x_data, y_data, x_test, y_test):
    model = Sequential()
    model.add(LSTM(input_shape=[x_data.shape[1], 1],  output_dim =10, return_sequences = True))
    model.add(Flatten())
    model.add(Activation('linear'))
    model.add(Dense(output_dim=20))
    model.add(Activation('linear'))
    model.add(Dense(output_dim=10))
    model.add(Activation('tanh'))
    model.add(Dense(output_dim=4))
    model.add(Activation('sigmoid'))
    sgd = SGD(lr=0.1, decay=1e-5, momentum=0.9, nesterov=True)
    model.compile(loss='categorical_crossentropy', optimizer=sgd)

    model.fit(x_data, y_data, batch_size=1000, nb_epoch=50, validation_split=0.2)
    preds = model.predict_proba(x_data)
    result = metrics.roc_auc_score(y_data, preds)
    print(result)

    preds = model.predict_proba(x_test)
    result = metrics.roc_auc_score(y_test, preds)
    print(result)
    return model
Exemplo n.º 27
0
    def test_merge_recursivity(self):
        print('Test merge recursivity')

        left = Sequential()
        left.add(Dense(input_dim, nb_hidden))
        left.add(Activation('relu'))

        right = Sequential()
        right.add(Dense(input_dim, nb_hidden))
        right.add(Activation('relu'))

        righter = Sequential()
        righter.add(Dense(input_dim, nb_hidden))
        righter.add(Activation('relu'))

        intermediate = Sequential()
        intermediate.add(Merge([left, right], mode='sum'))
        intermediate.add(Dense(nb_hidden, nb_hidden))
        intermediate.add(Activation('relu'))

        model = Sequential()
        model.add(Merge([intermediate, righter], mode='sum'))

        model.add(Dense(nb_hidden, nb_class))
        model.add(Activation('softmax'))

        model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

        model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_data=([X_test, X_test, X_test], y_test))
        model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_data=([X_test, X_test, X_test], y_test))
        model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=0, validation_split=0.1)
        model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=0, validation_split=0.1)
        model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
        model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False)

        loss = model.evaluate([X_train, X_train, X_train], y_train, verbose=0)
        print('loss:', loss)
        if loss > 0.6:
            raise Exception('Score too low, learning issue.')
        preds = model.predict([X_test, X_test, X_test], verbose=0)
        classes = model.predict_classes([X_test, X_test, X_test], verbose=0)
        probas = model.predict_proba([X_test, X_test, X_test], verbose=0)
        print(model.get_config(verbose=1))

        model.save_weights('temp.h5', overwrite=True)
        model.load_weights('temp.h5')

        nloss = model.evaluate([X_train, X_train, X_train], y_train, verbose=0)
        print(nloss)
        assert(loss == nloss)
Exemplo n.º 28
0
def run_neural_net(X, y):
    print 'running neural network...'
    model = Sequential()
    
    #split 80/20 train test
    sss = StratifiedShuffleSplit(y, n_iter = 1, test_size = 0.2, random_state = 42)
    for train_index, test_index in sss:
        X_train, X_test = X[train_index], X[test_index]
        y_train, y_test = y[train_index], y[test_index]

    #Oversampling of unbalanced dataset
    sm = SMOTE(kind = 'regular', verbose = True)
    X_train, y_train = sm.fit_transform(X_train, y_train)
    X_train, y_train = sm.fit_transform(X_train, y_train)

    y_train = y_train.reshape(y_train.shape[0],1)
    y_test = y_test.reshape(y_test.shape[0],1)
    y_train, y_test = [np_utils.to_categorical(x) for x in (y_train, y_test)]
    # Dense(64) is a fully-connected layer with 64 hidden units.
    # in the first layer, you must specify the expected input data shape:
    # here, 20-dimensional vectors.
    #tr = ThresholdedReLU(theta = 0.3)
    model.add(Dense(input_dim=X.shape[1], output_dim=1000, init='uniform',activation='relu'))
    #model.add(Activation('relu'))
    model.add(Dropout(0.2))
    model.add(Dense(output_dim=1000, init='uniform'))
    model.add(Activation('relu'))
    model.add(Dropout(0.2))
    model.add(Dense(output_dim=1000, init='uniform'))
    model.add(Activation('relu'))
    model.add(Dropout(0.2))
    model.add(Dense(output_dim=2, init='uniform'))
    model.add(Activation('softmax'))
    #sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(loss='binary_crossentropy', optimizer='adam')
    model.fit(X_train, y_train, nb_epoch=10, batch_size = 200)
    score = model.evaluate(X_test, y_test, show_accuracy=True)
    pred = model.predict_proba(X_test) #get back probabilities
    pred2 = model.predict_classes(X_test) #get back predictions
    fpr, tpr, thresholds = roc_curve(y_test[:,1], pred[:,1])
    
    #get the AUC
    AUC = roc_auc_score(y_test[:,1], pred[:,1])
    
    #get the AUC for precision and recall curve
    AUC2 = average_precision_score(y_test[:,1], pred[:,1])
    recall = recall_score(y_test[:,1], pred2)
    precision = precision_score(y_test[:,1], pred2)
    print score
    return model, X_train, y_train, X_test, y_test, score
Exemplo n.º 29
0
def train_ensemble(X_train, X_test, Y_train, n_models=6):
    n_categs = Y_train.shape[1]
    for i in range(n_models):
        print('---' * 20)
        print('Training model #: {}'.format(i + 1))
        print('---' * 20)

        model = Sequential()

        dim = random.choice(np.arange(512, 769))
        model.add(Dense(output_dim=dim, input_dim=X_train.shape[1],
                        init="glorot_uniform", W_constraint=maxnorm(1)))
        model.add(PReLU())
        model.add(Dropout(0.6))

        model.add(Dense(output_dim=n_categs, init="glorot_uniform",
                        W_constraint=maxnorm(1)))
        model.add(Activation("softmax"))
        model.compile(loss='categorical_crossentropy',
                      optimizer='adagrad')
        print("Training model...")

        epoch = random.choice(np.arange(100, 400))

        model.fit(X_train, Y_train, nb_epoch=epoch, batch_size=512)

        if i == 0:
            probs = model.predict_proba(X_test, batch_size=512)
        else:
            probs += model.predict_proba(X_test, batch_size=512)

    probs /= n_models
    column_names, index = get_extra()
    df_out = pd.DataFrame(data=np.c_[index, probs], columns=column_names)
    df_out['VisitNumber'] = np.int32(df_out['VisitNumber'])
    df_out.to_csv('nnEnsemble.csv', index=False)
    return df_out
Exemplo n.º 30
0
def test_merge_concat():
    (X_train, y_train), (X_test, y_test) = _get_test_data()

    left = Sequential(name='branch_1')
    left.add(Dense(nb_hidden, input_shape=(input_dim,), name='dense_1'))
    left.add(Activation('relu', name='relu_1'))

    right = Sequential(name='branch_2')
    right.add(Dense(nb_hidden, input_shape=(input_dim,), name='dense_2'))
    right.add(Activation('relu', name='relu_2'))

    model = Sequential(name='merged_branches')
    model.add(Merge([left, right], mode='concat', name='merge'))
    model.add(Dense(nb_class, name='final_dense'))
    model.add(Activation('softmax', name='softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=([X_test, X_test], y_test))
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_split=0.1)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False)

    loss = model.evaluate([X_test, X_test], y_test, verbose=0)

    model.predict([X_test, X_test], verbose=0)
    model.predict_classes([X_test, X_test], verbose=0)
    model.predict_proba([X_test, X_test], verbose=0)
    model.get_config()

    fname = 'test_merge_concat_temp.h5'
    model.save_weights(fname, overwrite=True)
    model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0)
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate([X_test, X_test], y_test, verbose=0)
    assert(loss == nloss)
Exemplo n.º 31
0
class Model(object):

    FILE_PATH = './store/model.h5'

    def __init__(self):
        self.model = None

    def build_model(self, dataset, nb_classes=2):
        self.model = Sequential()

        self.model.add(
            Convolution2D(32,
                          3,
                          3,
                          border_mode='same',
                          input_shape=dataset.X_train.shape[1:]))
        self.model.add(Activation('relu'))
        self.model.add(Convolution2D(32, 3, 3))
        self.model.add(Activation('relu'))
        self.model.add(MaxPooling2D(pool_size=(2, 2)))
        self.model.add(Dropout(0.25))

        self.model.add(Convolution2D(64, 3, 3, border_mode='same'))
        self.model.add(Activation('relu'))
        self.model.add(Convolution2D(64, 3, 3))
        self.model.add(Activation('relu'))
        self.model.add(MaxPooling2D(pool_size=(2, 2)))
        self.model.add(Dropout(0.25))

        self.model.add(Flatten())
        self.model.add(Dense(512))
        self.model.add(Activation('relu'))
        self.model.add(Dropout(0.5))
        self.model.add(Dense(nb_classes))
        self.model.add(Activation('softmax'))

        self.model.summary()

    def train(self,
              dataset,
              batch_size=32,
              nb_epoch=40,
              data_augmentation=True):
        # let's train the model using SGD + momentum (how original).
        sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
        self.model.compile(loss='categorical_crossentropy',
                           optimizer=sgd,
                           metrics=['accuracy'])
        if not data_augmentation:
            print('Not using data augmentation.')
            self.model.fit(dataset.X_train,
                           dataset.Y_train,
                           batch_size=batch_size,
                           nb_epoch=nb_epoch,
                           validation_data=(dataset.X_valid, dataset.Y_valid),
                           shuffle=True)
        else:
            print('Using real-time data augmentation.')

            # this will do preprocessing and realtime data augmentation
            datagen = ImageDataGenerator(
                featurewise_center=False,  # set input mean to 0 over the dataset
                samplewise_center=False,  # set each sample mean to 0
                featurewise_std_normalization=
                False,  # divide inputs by std of the dataset
                samplewise_std_normalization=
                False,  # divide each input by its std
                zca_whitening=False,  # apply ZCA whitening
                rotation_range=
                20,  # randomly rotate images in the range (degrees, 0 to 180)
                width_shift_range=
                0.2,  # randomly shift images horizontally (fraction of total width)
                height_shift_range=
                0.2,  # randomly shift images vertically (fraction of total height)
                horizontal_flip=True,  # randomly flip images
                vertical_flip=False)  # randomly flip images

            # compute quantities required for featurewise normalization
            # (std, mean, and principal components if ZCA whitening is applied)
            datagen.fit(dataset.X_train)

            # fit the model on the batches generated by datagen.flow()
            self.model.fit_generator(
                datagen.flow(dataset.X_train,
                             dataset.Y_train,
                             batch_size=batch_size),
                samples_per_epoch=dataset.X_train.shape[0],
                nb_epoch=nb_epoch,
                validation_data=(dataset.X_valid, dataset.Y_valid))

    def save(self, file_path=FILE_PATH):
        print('Model Saved.')
        self.model.save(file_path)

    def load(self, file_path=FILE_PATH):
        print('Model Loaded.')
        self.model = load_model(file_path)

    def predict(self, image):
        if image.shape != (1, 3, IMAGE_SIZE, IMAGE_SIZE):
            image = resize_with_pad(image)
            image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))
        image = image.astype('float32')
        image /= 255
        result = self.model.predict_proba(image)
        print(result)
        result = self.model.predict_classes(image)

        return result[0]

    def evaluate(self, dataset):
        score = self.model.evaluate(dataset.X_test, dataset.Y_test, verbose=0)
        print("%s: %.2f%%" % (self.model.metrics_names[1], score[1] * 100))
Exemplo n.º 32
0


# print(X)
# define and fit the final model


model = Sequential()
model.add(Dense(25, input_dim=3, activation='relu'))
model.add(Dense(25, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(arrX, arrY, epochs=64, verbose=1)
# new instances where we do not know the answer

ynew = model.predict_proba(arrX[0:30])

for i in range(0,30):
    print("X=%s, Predicted=%s, arrY=%s" % (arrX[i], ynew[i], arrY[i]))


# model.save('notSkipping_nn2_1hr.h5')  # creates a HDF5 file 'notSkipping_nn2_1hr.h5'

trainYArr = []
actionRetrainArr = []
yLabel = []
volumeRetrainArr = []

def appendLatestTradeExample(previous_price, previous_predictedPrice, actionTaken, actualPrice, volume):
    global trainYArr
    global actionRetrainArr
img_model.add(MaxPooling2D(pool_size=(2, 2), strides=(2,2), border_mode="same"))
img_model.add(Flatten())
img_model.add(Dense(1024))
img_model.add(Activation("relu"))
img_model.add(Dropout(0.5))

feat_model = Sequential()
feat_model.add(Dense(1024, input_dim=192))
feat_model.add(Activation("sigmoid"))
'''
model = Sequential()
#try dot product
#model.add(Merge([img_model, feat_model], mode='concat'))
model.add(Dense(1024, input_dim=192))
model.add(Activation("sigmoid"))
model.add(Dense(512))
model.add(Activation("sigmoid"))
model.add(Dense(99))
model.add(Activation("softmax"))
if os.path.exists("weights.h5"):
    model.load_weights("weights.h5")
model.compile(optimizer="rmsprop",
              loss="categorical_crossentropy",
              metrics=["accuracy"])

model.fit(train, labels, nb_epoch=100, batch_size=128)
model.save_weights("weights.h5")

preds = model.predict_proba(test)
make_submit(preds)
Exemplo n.º 34
0
def test_nested_sequential(in_tmpdir):
    (x_train, y_train), (x_test, y_test) = _get_test_data()

    inner = Sequential()
    inner.add(Dense(num_hidden, input_shape=(input_dim, )))
    inner.add(Activation('relu'))
    inner.add(Dense(num_classes))

    middle = Sequential()
    middle.add(inner)

    model = Sequential()
    model.add(middle)
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=1,
              validation_data=(x_test, y_test))
    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=2,
              validation_split=0.1)
    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=0)
    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=1,
              shuffle=False)

    model.train_on_batch(x_train[:32], y_train[:32])

    loss = model.evaluate(x_test, y_test, verbose=0)

    model.predict(x_test, verbose=0)
    model.predict_classes(x_test, verbose=0)
    model.predict_proba(x_test, verbose=0)

    fname = 'test_nested_sequential_temp.h5'
    model.save_weights(fname, overwrite=True)

    inner = Sequential()
    inner.add(Dense(num_hidden, input_shape=(input_dim, )))
    inner.add(Activation('relu'))
    inner.add(Dense(num_classes))

    middle = Sequential()
    middle.add(inner)

    model = Sequential()
    model.add(middle)
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate(x_test, y_test, verbose=0)
    assert (loss == nloss)

    # Test serialization
    config = model.get_config()
    Sequential.from_config(config)

    model.summary()
    json_str = model.to_json()
    model_from_json(json_str)

    yaml_str = model.to_yaml()
    model_from_yaml(yaml_str)
                  decay=1e-6,
                  momentum=0.95,
                  nesterov=True,
                  clipnorm=1.0)

        model.compile(loss='poisson', optimizer=adam)
        model.fit(C_Bind,
                  Y_Bind,
                  nb_epoch=10,
                  show_accuracy=True,
                  verbose=0,
                  validation_data=(C_Bind, Y_Bind))

        # -----------------------------------------------------

        proba_bind = model.predict_proba(C, batch_size=200, verbose=0)
        proba_bind_new = RD.rand_new(proba_bind, delta[i])
        class_bind_new = RD.make_new_class(proba_bind_new)
        s_nn_hat_Bind = hstack((zeros(k), class_bind_new, zeros(k)))
        x_nn_hat_Bind = N_DUDE.denoise_with_s(z[i], s_nn_hat_Bind, k)
        error_nn_Bind = N_DUDE.error_rate(x, x_nn_hat_Bind)

        print '1-D N-DUDE Context Bind=', error_nn_Bind

        Error_One_NN_DUDE_Bind_RD[i, k] = error_nn_Bind
        X_hat_One_NN_DUDE_Bind_RD[k_max * i + k - 1, :] = x_nn_hat_Bind

        s_class = 3
        s_nn_hat_cat_Bind = np_utils.to_categorical(s_nn_hat_Bind, s_class)
        emp_dist = dot(Z[i * n:(i + 1) * n, ],
                       L[i * alpha_size:(i + 1) * alpha_size, ])
def main():
    start_time = time.time()

    parser = argparse.ArgumentParser(
        prog='trainLSTM_MLP.py',
        description='Train LSTM-MLP model for visual question answering')
    parser.add_argument('--mlp-hidden-units',
                        type=int,
                        default=1024,
                        metavar='<mlp-hidden-units>')
    parser.add_argument('--lstm-hidden-units',
                        type=int,
                        default=512,
                        metavar='<lstm-hidden-units>')
    parser.add_argument('--mlp-hidden-layers',
                        type=int,
                        default=3,
                        metavar='<mlp-hidden-layers>')
    parser.add_argument('--lstm-hidden-layers',
                        type=int,
                        default=1,
                        metavar='<lstm-hidden-layers>')
    parser.add_argument('--dropout',
                        type=float,
                        default=0.5,
                        metavar='<dropout-rate>')
    parser.add_argument('--mlp-activation',
                        type=str,
                        default='tanh',
                        metavar='<activation-function>')
    parser.add_argument('--num-epochs',
                        type=int,
                        default=100,
                        metavar='<num-epochs>')
    parser.add_argument('--batch-size',
                        type=int,
                        default=128,
                        metavar='<batch-size>')
    parser.add_argument('--learning-rate',
                        type=float,
                        default=0.001,
                        metavar='<learning-rate>')
    parser.add_argument('--dev-accuracy-path',
                        type=str,
                        required=True,
                        metavar='<accuracy-path>')
    args = parser.parse_args()

    word_vec_dim = 300
    vgg_img_dim = 4096
    inc_img_dim = 2048
    max_len = 30
    ######################
    #      Load Data     #
    ######################

    print('Loading data...')

    train_id_pairs, train_image_ids = LoadIds('train')
    dev_id_pairs, dev_image_ids = LoadIds('dev')

    train_questions = LoadQuestions('train')
    dev_questions = LoadQuestions('dev')

    train_choices = LoadChoices('train')
    dev_choices = LoadChoices('dev')

    train_answers = LoadAnswers('train')
    dev_answers = LoadAnswers('dev')

    print('Finished loading data.')
    print('Time: %f s' % (time.time() - start_time))

    ######################
    # Model Descriptions #
    ######################
    print('Generating and compiling model...')

    # VGG model (VGG features)
    vgg_model = Sequential()
    vgg_model.add(Reshape(input_shape=(vgg_img_dim, ), dims=(vgg_img_dim, )))

    # Inception model
    inception_model = Sequential()
    inception_model.add(
        Reshape(input_shape=(inc_img_dim, ), dims=(inc_img_dim, )))

    # language model (LSTM)
    language_model = Sequential()
    if args.lstm_hidden_layers == 1:
        language_model.add(
            LSTM(output_dim=args.lstm_hidden_units,
                 return_sequences=False,
                 input_shape=(max_len, word_vec_dim)))
    else:
        language_model.add(
            LSTM(output_dim=args.lstm_hidden_units,
                 return_sequences=True,
                 input_shape=(max_len, word_vec_dim)))
        for i in range(args.lstm_hidden_layers - 2):
            language_model.add(
                LSTM(output_dim=args.lstm_hidden_units, return_sequences=True))
        language_model.add(
            LSTM(output_dim=args.lstm_hidden_units, return_sequences=False))

    # feedforward model (MLP)
    model = Sequential()
    model.add(
        Merge([language_model, vgg_model, inception_model],
              mode='concat',
              concat_axis=1))
    for i in range(args.mlp_hidden_layers):
        model.add(Dense(args.mlp_hidden_units, init='uniform'))
        model.add(Activation(args.mlp_activation))
        model.add(Dropout(args.dropout))
    model.add(Dense(word_vec_dim))
    model.add(Activation('softmax'))

    json_string = model.to_json()
    model_filename = 'models/2feats_lstm_units_%i_layers_%i_mlp_units_%i_layers_%i_%s_lr%.1e_dropout%.1f' % (
        args.lstm_hidden_units, args.lstm_hidden_layers, args.mlp_hidden_units,
        args.mlp_hidden_layers, args.mlp_activation, args.learning_rate,
        args.dropout)
    open(model_filename + '.json', 'w').write(json_string)

    # loss and optimizer
    rmsprop = RMSprop(lr=args.learning_rate)
    model.compile(loss='categorical_crossentropy', optimizer=rmsprop)
    print('Compilation finished.')
    print('Time: %f s' % (time.time() - start_time))

    ########################################
    #  Load CNN Features and Word Vectors  #
    ########################################

    # load VGG features
    print('Loading VGG features...')
    VGG_features, vgg_img_map = LoadVGGFeatures()
    print('VGG features loaded')
    print('Time: %f s' % (time.time() - start_time))

    # load Inception features
    print('Loading Inception features...')
    INC_features, inc_img_map = LoadInceptionFeatures()
    print('Inception features loaded')
    print('Time: %f s' % (time.time() - start_time))

    # load GloVe vectors
    print('Loading GloVe vectors...')
    word_embedding, word_map = LoadGloVe()
    print('GloVe vectors loaded')
    print('Time: %f s' % (time.time() - start_time))

    ######################
    #    Make Batches    #
    ######################

    print('Making batches...')

    # training batches
    train_question_batches = [
        b for b in MakeBatches(
            train_questions, args.batch_size, fillvalue=train_questions[-1])
    ]
    train_answer_batches = [
        b for b in MakeBatches(train_answers['toks'],
                               args.batch_size,
                               fillvalue=train_answers['toks'][-1])
    ]
    train_image_batches = [
        b for b in MakeBatches(
            train_image_ids, args.batch_size, fillvalue=train_image_ids[-1])
    ]
    train_indices = list(range(len(train_question_batches)))

    # validation batches
    dev_question_batches = [
        b for b in MakeBatches(
            dev_questions, args.batch_size, fillvalue=dev_questions[-1])
    ]
    dev_answer_batches = [
        b for b in MakeBatches(dev_answers['labs'],
                               args.batch_size,
                               fillvalue=dev_answers['labs'][-1])
    ]
    dev_choice_batches = [
        b for b in MakeBatches(
            dev_choices, args.batch_size, fillvalue=dev_choices[-1])
    ]
    dev_image_batches = [
        b for b in MakeBatches(
            dev_image_ids, args.batch_size, fillvalue=dev_image_ids[-1])
    ]

    print('Finished making batches.')
    print('Time: %f s' % (time.time() - start_time))

    ######################
    #      Training      #
    ######################

    acc_file = open(args.dev_accuracy_path, 'w')
    dev_accs = []
    max_acc = -1
    max_acc_epoch = -1

    # define interrupt handler
    def PrintDevAcc():
        print('Max validation accuracy epoch: %i' % max_acc_epoch)
        print(dev_accs)

    def InterruptHandler(sig, frame):
        print(str(sig))
        PrintDevAcc()
        sys.exit(-1)

    signal.signal(signal.SIGINT, InterruptHandler)
    signal.signal(signal.SIGTERM, InterruptHandler)

    # print training information
    print('-' * 80)
    print('Training Information')
    print('# of LSTM hidden units: %i' % args.lstm_hidden_units)
    print('# of LSTM hidden layers: %i' % args.lstm_hidden_layers)
    print('# of MLP hidden units: %i' % args.mlp_hidden_units)
    print('# of MLP hidden layers: %i' % args.mlp_hidden_layers)
    print('Dropout: %f' % args.dropout)
    print('MLP activation function: %s' % args.mlp_activation)
    print('# of training epochs: %i' % args.num_epochs)
    print('Batch size: %i' % args.batch_size)
    print('Learning rate: %f' % args.learning_rate)
    print('# of train questions: %i' % len(train_questions))
    print('# of dev questions: %i' % len(dev_questions))
    print('-' * 80)
    acc_file.write('-' * 80 + '\n')
    acc_file.write('Training Information\n')
    acc_file.write('# of LSTM hidden units: %i\n' % args.lstm_hidden_units)
    acc_file.write('# of LSTM hidden layers: %i\n' % args.lstm_hidden_layers)
    acc_file.write('# of MLP hidden units: %i\n' % args.mlp_hidden_units)
    acc_file.write('# of MLP hidden layers: %i\n' % args.mlp_hidden_layers)
    acc_file.write('Dropout: %f\n' % args.dropout)
    acc_file.write('MLP activation function: %s\n' % args.mlp_activation)
    acc_file.write('# of training epochs: %i\n' % args.num_epochs)
    acc_file.write('Batch size: %i\n' % args.batch_size)
    acc_file.write('Learning rate: %f\n' % args.learning_rate)
    acc_file.write('# of train questions: %i\n' % len(train_questions))
    acc_file.write('# of dev questions: %i\n' % len(dev_questions))
    acc_file.write('-' * 80 + '\n')

    # start training
    print('Training started...')
    for k in range(args.num_epochs):
        print('-' * 80)
        print('Epoch %i' % (k + 1))
        progbar = generic_utils.Progbar(len(train_indices) * args.batch_size)
        # shuffle batch indices
        random.shuffle(train_indices)
        for i in train_indices:
            X_question_batch = GetQuestionsTensor(train_question_batches[i],
                                                  word_embedding, word_map)
            X_vgg_image_batch = GetImagesMatrix(train_image_batches[i],
                                                vgg_img_map, VGG_features)
            X_inc_image_batch = GetImagesMatrix(train_image_batches[i],
                                                inc_img_map, INC_features)
            Y_answer_batch = GetAnswersMatrix(train_answer_batches[i],
                                              word_embedding, word_map)
            loss = model.train_on_batch(
                [X_question_batch, X_vgg_image_batch, X_inc_image_batch],
                Y_answer_batch)
            loss = loss[0].tolist()
            progbar.add(args.batch_size, values=[('train loss', loss)])
        print('Time: %f s' % (time.time() - start_time))

        # evaluate on dev set
        pbar = generic_utils.Progbar(
            len(dev_question_batches) * args.batch_size)

        dev_correct = 0

        # feed forward
        for i in range(len(dev_question_batches)):
            X_question_batch = GetQuestionsTensor(dev_question_batches[i],
                                                  word_embedding, word_map)
            X_vgg_image_batch = GetImagesMatrix(dev_image_batches[i],
                                                vgg_img_map, VGG_features)
            X_inc_image_batch = GetImagesMatrix(dev_image_batches[i],
                                                inc_img_map, INC_features)
            prob = model.predict_proba(
                [X_question_batch, X_vgg_image_batch, X_inc_image_batch],
                args.batch_size,
                verbose=0)

            # get word vecs of choices
            choice_feats = GetChoicesTensor(dev_choice_batches[i],
                                            word_embedding, word_map)
            similarity = np.zeros((5, args.batch_size), float)
            # calculate cosine distances
            for j in range(5):
                similarity[j] = np.diag(
                    cosine_similarity(prob, choice_feats[j]))
            # take argmax of cosine distances
            pred = np.argmax(similarity, axis=0) + 1

            if i != (len(dev_question_batches) - 1):
                dev_correct += np.count_nonzero(dev_answer_batches[i] == pred)
            else:
                num_padding = args.batch_size * len(
                    dev_question_batches) - len(dev_questions)
                last_idx = args.batch_size - num_padding
                dev_correct += np.count_nonzero(
                    dev_answer_batches[:last_idx] == pred[:last_idx])
            pbar.add(args.batch_size)

        dev_acc = float(dev_correct) / len(dev_questions)
        dev_accs.append(dev_acc)
        print('Validation Accuracy: %f' % dev_acc)
        print('Time: %f s' % (time.time() - start_time))

        if dev_acc > max_acc:
            max_acc = dev_acc
            max_acc_epoch = k
            model.save_weights(model_filename + '_best.hdf5', overwrite=True)

    model.save_weights(model_filename + '_epoch_{:03d}.hdf5'.format(k + 1))
    print(dev_accs)
    for acc in dev_accs:
        acc_file.write('%f\n' % acc)
    print('Best validation accuracy: %f; epoch#%i' % (max_acc,
                                                      (max_acc_epoch + 1)))
    acc_file.write('Best validation accuracy: %f; epoch#%i\n' %
                   (max_acc, (max_acc_epoch + 1)))
    print('Training finished.')
    acc_file.write('Training finished.\n')
    print('Time: %f s' % (time.time() - start_time))
    acc_file.write('Time: %f s\n' % (time.time() - start_time))
    acc_file.close()
Exemplo n.º 37
0
def sequential_model():
    #preprocessing for removing stopwords
    x = train['comment_text'].apply(stopwords_removal)
    label_train = train[label_list].values
    x_test = test['comment_text'].apply(stopwords_removal)
    max_features = 20000
    max_text_length = 300
    dimensions_initial = 50
    filters = 250
    kernel_size = 3
    dimensions_final = 100
    batch_count = 32
    nEpochs = 1

    #tokenizer
    x_tokenizer = text.Tokenizer(num_words=max_features)
    x_tokenizer.fit_on_texts(list(x))
    x_tokenized = x_tokenizer.texts_to_sequences(x)
    x_test_tokenized = x_tokenizer.texts_to_sequences(x_test)
    x_train_val = sequence.pad_sequences(x_tokenized, maxlen=max_text_length)
    x_testing = sequence.pad_sequences(x_test_tokenized,
                                       maxlen=max_text_length)

    #train - validation split
    x_train, x_validation, y_train, y_validation = train_test_split(
        x_train_val, label_train, test_size=0.1, random_state=1)

    #defining sequential model
    classifier_model = Sequential()
    classifier_model.add(
        Embedding(max_features,
                  dimensions_initial,
                  input_length=max_text_length))
    classifier_model.add(Dropout(0.2))
    classifier_model.add(
        Conv1D(filters,
               kernel_size,
               activation='relu',
               padding='valid',
               strides=1))
    classifier_model.add(GlobalMaxPooling1D())
    classifier_model.add(Dense(dimensions_final))
    classifier_model.add(Dropout(0.2))
    classifier_model.add(Activation('sigmoid'))
    classifier_model.add(Dense(6))
    classifier_model.add(Activation('relu'))

    #compilation and metrics definition
    classifier_model.compile(optimizer='rmsprop',
                             metrics=['accuracy'],
                             loss='binary_crossentropy')
    classifier_model.summary()
    classifier_model.fit(x_train,
                         y_train,
                         batch_size=batch_count,
                         epochs=nEpochs,
                         verbose=1,
                         validation_data=(x_validation, y_validation))

    #predict model on testing data set
    y_prediction = classifier_model.predict(x_testing, verbose=1)

    #validation feature and label
    val_pred = classifier_model.predict_proba(x_validation)
    val_true = y_validation

    #read sample submission csv and write predicted values to a new csv
    sample_submission = pd.read_csv("sample_submission.csv")
    sample_submission[label_list] = y_prediction
    sample_submission.to_csv("results.csv", index=False)
Exemplo n.º 38
0
            train_y,
            validation_data=(np.expand_dims(test_x, 2), test_y),
            batch_size=512,
            nb_epoch=500,  # training epoch
            callbacks=[history])

        fpr = dict()
        tpr = dict()
        roc_auc = dict()

        n_class = [0, 1, 2, 3, 5, 12]
        n_classes = len(n_class)

        test_y_pred = model.predict_classes(np.expand_dims(test_x, 2))
        y_pred_val = model.predict_classes(np.expand_dims(x_test, 2))
        y_pred_prob_val = model.predict_proba(np.expand_dims(x_test, 2))

        for k in range(n_classes):
            fpr[k], tpr[k], _ = roc_curve(y_test[:, k], y_pred_prob_val[:, k])
            roc_auc[k] = auc(fpr[k], tpr[k])

        lw = 2
        # First aggregate all false positive rates
        all_fpr = np.unique(np.concatenate([fpr[k] for k in range(n_classes)]))
        # Then interpolate all ROC curves at this points
        mean_tpr = np.zeros_like(all_fpr)
        for h in range(n_classes):
            mean_tpr += interp(all_fpr, fpr[h], tpr[h])
        # Finally average it and comput AUC
        mean_tpr /= n_classes
        # PLot all ROC curves
Exemplo n.º 39
0
model.add(PReLU((testVal, )))
model.add(BatchNormalization((testVal, )))
model.add(Dropout(0.2))

model.add(Dense(testVal, nb_classes, init='glorot_uniform'))
model.add(Activation('softmax'))

model.compile(loss='categorical_crossentropy', optimizer="adadelta")

print("Training model...")

model.fit(X, y, nb_epoch=100, batch_size=5, validation_split=0.01)

print("Generating results...")

proba = model.predict_proba(X)
print(model.evaluate(X, y, show_accuracy=True))
print(proba)
print(model.predict_classes(X), labels)
print(classification_report(labels - 1, model.predict_classes(X)))

plt.figure()
plt.scatter(proba[:, 0], proba[:, 1])

savefig('Classified.png', bbox_inches='tight')

print("Unshuffled")
X, labels = load_data('both.csv', train=False)
X = scaler.transform(X)
y, encoder = preprocess_labels(labels)
newProba = model.predict_proba(X)
Exemplo n.º 40
0
from keras.models import Sequential
from keras.layers.core import Dense, Activation

# Building the model
xor = Sequential()

# Add required layers
xor.add(Dense(32, input_dim=X.shape[1]))
xor.add(Activation('tanh'))

xor.add(Dense(1))
xor.add(Activation('sigmoid'))

# Specify loss as "binary_crossentropy", optimizer as "adam",
# and add the accuracy metric
xor.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])

# Uncomment this line to print the model architecture
xor.summary()

# Fitting the model
history = xor.fit(X, y, epochs=50, verbose=0)

# Scoring the model
score = xor.evaluate(X, y)
print("\nAccuracy: ", score[-1])

# Checking the predictions
print("\nPredictions:")
print(xor.predict_proba(X))
model.add(Dense(num_classes, activation='softmax'))

model.summary()

model.compile(loss='sparse_categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])
class_weight = {0: 6., 1: 6., 2: 3., 3: 3., 4: 1.}

batch_size = 32
num_classes = 2
epochs = 100
history = model.fit(X_train,
                    y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=2,
                    validation_data=(X_test, y_test),
                    class_weight=class_weight)

import numpy as np

a = np.argmax(model.predict_proba(df_test), axis=1)

import csv
csvfile = open('KKS-NN-Dead-NDead.csv', 'w', newline='')
obj = csv.writer(csvfile)
for i in a:
    obj.writerow(str(i))
csvfile.close()
Exemplo n.º 42
0
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD

model = Sequential({Dense(input_dim=2, units=1), Activation('sigmoid')})
model.compile(loss='binary_crossentropy', optimizer=SGD(lr=0.1))
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
Y = np.array([[0], [1], [1], [1]])

model.fit(X, Y, epochs=200, batch_size=1)
classes = model.predict_classes(X, batch_size=1)
prob = model.predict_proba(X, batch_size=1)

print('classfied:')
print(Y == classes)
print()
print('output probability:')
print(prob)

print("Evaluating...")
milli_sec3 = int(round(time.time() * 1000))

number_of_elements = 20
count = 0
count0 = 0
iterator = test_generator(testing_data, BS, test_lenght, itemId2, testItems)

for k in range(0, len(testing_data), BS):
    #print("k=%d"%k)
    X_test, y_test, test_features, test_labels, test_items = next(iterator)

    preds = model.predict_classes(X_test, verbose=0)
    predictions = model.predict_proba(X_test, verbose=0)

    for i in range(0, predictions.shape[0]):
        if (i + k < len(testing_data)):
            for j in range(0, test_lenght[i + k] - 1):
                temp = predictions[i, j, :]
                idx = (-temp).argsort()[:number_of_elements]
                for z in range(0, number_of_elements):
                    index = idx[z]
                    if (test_labels[i, j] == index):
                        count0 = count0 + 1
                        index2 = itemId2[itemId2.iloc[:, 1] == index]
                        #index2=index2.iloc[:,0]
                        #table2=table[ table.iloc[:,1]==index2]
                        table2 = items_clusters[items_clusters["Cluster"] ==
                                                index2.iloc[0, 0]]
Exemplo n.º 44
0
def create_decision_data(df, date, ls):
    
#     df = df[df['Date'] <= date]
    
    dl = [['Stock Symbol','last_day_value','next_day_forecast','AIC','next_day_value']]

    for i in ls[0:1]: #### Change later
        # try:
        df2 = df.loc[df['Stock Symbol'] == i].drop(columns = 'Stock Symbol')
        # df2.isnull().sum()
        df2['Date'] = pd.to_datetime(df2['Date'], format='%Y-%m-%d', errors='coerce')
        # df['Date'] = pd.to_datetime(df.Date,format='%Y-%m-%d')
        df2.index = df2['Date']
        train_length=len(df2['Date'] <= date)
        # val_length=len([df2['Date'] > date])
        # print (len(df2['Date'] <= date))

        #creating dataframe
        data = df2.sort_index(ascending=True, axis=0)
        new_data = pd.DataFrame(index=range(0,len(df)),columns=['Date', 'Close'])
        for i in range(0,len(data)):
            new_data['Date'][i] = data['Date'][i]
            new_data['Close'][i] = data['Close'][i]

        #setting index
        new_data.index = new_data.Date
        new_data.drop('Date', axis=1, inplace=True)

        #creating train and test sets
        dataset = new_data.values

        train = dataset[0:train_length,:]
        valid = dataset[train_length:,:]
        # print(train.shape, valid.shape)

        #converting dataset into x_train and y_train
        scaler = MinMaxScaler(feature_range=(0, 1))
        scaled_data = scaler.fit_transform(dataset)

        x_train, y_train = [], []
        for i in range(60,len(train)):
            x_train.append(scaled_data[i-60:i,0])
            y_train.append(scaled_data[i,0])
        x_train, y_train = np.array(x_train), np.array(y_train)


        # print(x_train.shape,y_train.shape)
        x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))

        # create and fit the LSTM network
        model = Sequential()
        model.add(LSTM(units=50, return_sequences=True, input_shape=(x_train.shape[1],1)))
        model.add(LSTM(units=50))
        model.add(Dense(1))

        model.compile(loss='mean_squared_error', optimizer='adam')
        model.fit(x_train, y_train, epochs=1, batch_size=1, verbose=2)

        #predicting 246 values, using past 60 from the train data
        inputs = new_data[len(new_data) - len(valid) - 60:].values
        inputs = inputs.reshape(-1,1)
        inputs  = scaler.transform(inputs)

        X_test = []
        for i in range(60,inputs.shape[0]):
            X_test.append(inputs[i-60:i,0])
        X_test = np.array(X_test)

        X_test = np.reshape(X_test, (X_test.shape[0],X_test.shape[1],1))
        closing_price = model.predict(X_test)
        forecast = scaler.inverse_transform(closing_price)
        confidence=model.predict_proba(X_test)



        # close_prices = model.make_future_dataframe(periods=len(df2v))
        # forecast = model.predict(close_prices)

        next_day_forecast = forecast[['yhat','ds']][:1]


        next_day_forecast = forecast[0,0]
        confidence_next_day = confidence[0,0]
        next_day_value = valid[:1,0]
        last_day_value = train[-1:,0]
        dl.append([i, last_day_value, next_day_forecast, confidence_next_day, next_day_value])
        # except:
        #     print('Error with ',i)

    df3 = pd.DataFrame(dl)
    df3.columns = df3.iloc[0]
    df3 = df3.drop(df3.index[0])
    df3['diff'] = df3['next_day_forecast'] - df3['last_day_value']
    df3 = df3.sort_values('diff', ascending = False)
    return df3
Exemplo n.º 45
0
def run_cross_validation_with_only_epi_data(epi_dataset, exp_name):

    sample_matrices = epi_dataset['reshaped_sample_matrices']
    sample_label = epi_dataset['reshaped_sample_labels']
    # sample_regions = epi_dataset['sample_region']

    row, col = sample_matrices[0].shape
    num_classes = 2

    num_sample = len(sample_label)
    N1 = int(num_sample * 0.5)
    N2 = int(num_sample * 0.6)

    X_train = sample_matrices[0:N1]
    X_valid = sample_matrices[N1:N2]
    X_test = sample_matrices[N2:num_sample]

    all_data = sample_matrices[0:num_sample]

    # X_train = getScaledData(X_train)
    # X_valid = getScaledData(X_valid)
    # X_test = getScaledData(X_test)

    Y_train = sample_label[0:N1]
    Y_valid = sample_label[N1:N2]
    Y_test = sample_label[N2:num_sample]

    all_y = sample_label[0:num_sample]

    # convert class vectors to binary class matrices
    Y_train_one_hot = keras.utils.to_categorical(Y_train, num_classes)
    Y_valid_one_hot = keras.utils.to_categorical(Y_valid, num_classes)
    Y_test_one_hot = keras.utils.to_categorical(Y_test, num_classes)

    # train_regions = sample_regions[0:N1]
    # valid_regions = sample_regions[N1:N2]
    # test_regions = sample_regions[N2:num_sample]

    all_y_one_hot = keras.utils.to_categorical(all_y, num_classes)

    input_shape = (row, col)
    class_weight = {
        1: 0.65,
        0: 0.35
    }  # adding class weights since the dataset is imbalanced

    model = Sequential()
    model.add(Conv1D(128, 3, activation='relu', input_shape=input_shape))
    model.add(Conv1D(64, 3, activation='relu'))
    model.add(MaxPooling1D(pool_size=2, padding='same'))
    model.add(Dropout(0.25))
    model.add(Conv1D(64, 3, activation='relu'))
    model.add(MaxPooling1D(pool_size=2, padding='same'))
    model.add(Dropout(0.25))
    model.add(Flatten())

    model.add(Dense(128, activation='relu'))
    model.add(Dropout(0.25))
    model.add(Dense(64, activation='relu'))
    model.add(Dropout(0.25))
    model.add(Dense(32, activation='relu'))
    model.add(Dropout(0.25))
    model.add(Dense(num_classes, activation='softmax'))

    model.summary()

    check_pointer_file_name = exp_name
    model.compile(loss='binary_crossentropy',
                  optimizer=keras.optimizers.SGD(),
                  metrics=['accuracy'])
    check_pointer = ModelCheckpoint(filepath=str(check_pointer_file_name) +
                                    '.hdf5',
                                    verbose=1,
                                    monitor='val_loss',
                                    save_best_only=True)
    early_stopper = EarlyStopping(monitor='val_loss', patience=10, verbose=0)

    history = model.fit(
        X_train,
        Y_train_one_hot,
        batch_size=32,
        class_weight=class_weight,
        epochs=100,
        verbose=1,
        shuffle=True,
        validation_data=(X_valid, Y_valid_one_hot),
        callbacks=[check_pointer, early_stopper],
    )

    # history = model.fit(all_data, all_y_one_hot,
    #           batch_size = 32,
    #           class_weight=class_weight,
    #           epochs = 100,
    #           verbose = 1,
    #           shuffle = True,
    #           validation_data = (X_valid, Y_valid_one_hot),
    #           callbacks = [check_pointer, early_stopper],
    #           )

    # model evaluation
    # test_loss, test_acc = model.evaluate(X_test, Y_test_one_hot, verbose=0)

    # training performance evaluation
    Y_pred_train = model.predict(X_train)
    Y_pred_label_train = np.argmax(np.round(Y_pred_train), axis=1)
    Y_pred_prob_train = model.predict_proba(X_train)
    Y_pred_prob_train = Y_pred_prob_train[:, 1]
    fpr_train, tpr_train, threshold_train = metrics.roc_curve(
        Y_train, Y_pred_prob_train)
    precision_train, recall_train, threshold_train = metrics.precision_recall_curve(
        Y_train, Y_pred_prob_train)

    roc_auc_train = metrics.roc_auc_score(Y_train, Y_pred_label_train)
    f1_score_train = metrics.f1_score(Y_train, Y_pred_label_train)

    # from confusion matrix
    conf = metrics.confusion_matrix(Y_train, Y_pred_label_train)
    TP_train = conf[0, 0]
    FP_train = conf[0, 1]
    FN_train = conf[1, 0]
    TN_train = conf[1, 1]

    sensitivity_train = float(TP_train) / float(TP_train + FN_train)
    specificity_train = float(TN_train) / float(TN_train + FP_train)
    accuracy_train = float(TP_train + TN_train) / float(TP_train + FP_train +
                                                        FN_train + TN_train)
    prec_train = float(TP_train) / float(TP_train + FP_train)

    print(classification_report(Y_train, Y_pred_label_train, labels=[0, 1]))

    # testing performance evaluation
    Y_pred_test = model.predict(X_test)
    Y_pred_label_test = np.argmax(np.round(Y_pred_test), axis=1)
    Y_pred_prob_test = model.predict_proba(X_test)
    Y_pred_prob_test = Y_pred_prob_test[:, 1]
    fpr_test, tpr_test, threshold_test = metrics.roc_curve(
        Y_test, Y_pred_prob_test)
    precision_test, recall_test, threshold_test = metrics.precision_recall_curve(
        Y_test, Y_pred_prob_test)

    roc_auc_test = metrics.roc_auc_score(Y_test, Y_pred_label_test)
    f1_score_test = metrics.f1_score(Y_test, Y_pred_label_test)

    # from confusion matrix
    conf = metrics.confusion_matrix(Y_test, Y_pred_label_test)
    TP_test = conf[0, 0]
    FP_test = conf[0, 1]
    FN_test = conf[1, 0]
    TN_test = conf[1, 1]

    sensitivity_test = float(TP_test) / float(TP_test + FN_test)
    specificity_test = float(TN_test) / float(TN_test + FP_test)
    accuracy_test = float(TP_test + TN_test) / float(TP_test + FP_test +
                                                     FN_test + TN_test)
    prec_test = float(TP_test) / float(TP_test + FP_test)

    print(classification_report(Y_test, Y_pred_label_test, labels=[0, 1]))

    # dictionary to store evaluation stat
    evaluationInfo = {
        'roc_auc_train': roc_auc_train,
        'sensitivity_train': sensitivity_train,
        'specificity_train': specificity_train,
        'accuracy_train': accuracy_train,
        'precision_train': prec_train,
        'f1_train': f1_score_train,
        'roc_auc_test': roc_auc_test,
        'sensitivity_test': sensitivity_test,
        'specificity_test': specificity_test,
        'accuracy_test': accuracy_test,
        'precision_test': prec_test,
        'f1_test': f1_score_test,
        'history': history,
    }

    ########## These files are for plotting AUC and AUC-PR #########
    # f_fpr = open(str(exp_name) + '_fpr.txt', 'a')
    # f_tpr = open(str(exp_name) + '_tpr.txt', 'a')
    # f_precision = open(str(exp_name) + '_precision.txt', 'a')
    # f_recall = open(str(exp_name) + '_recall.txt', 'a')
    # f_validation = open(str(exp_name) + '_for_validation.txt', 'a')
    #
    # write_data_on_file(fpr_test, f_fpr)
    # f_fpr.close()
    #
    # write_data_on_file(tpr_test, f_tpr)
    # f_tpr.close()
    #
    # write_data_on_file(precision_test, f_precision)
    # f_precision.close()
    #
    # write_data_on_file(recall_test, f_recall)
    # f_recall.close()

    # for i in range(len(Y_pred_label_test)):
    #     f_validation.write(str(test_regions[i]) + '\t' + str(Y_pred_label_test[i]) + '\t' + str(Y_test[i]) + '\n')
    # f_validation.close()

    return evaluationInfo
Exemplo n.º 46
0
                        validation_data = (setTest, labels), callbacks = [earlystop])
    # show plot
    scatter(range(0, 300), history.history['loss'], [0, 300], [min(history.history['loss']),
            max(history.history['loss'])], 'Epoch', 'Loss', 'Training Loss', 'trainig_loss.pdf')
    # save history
    joblib.dump(history.history, open('./keras_hist.pkl', 'wb'))
    # save model
    model.save('./keras_jet_conv2d_for_drone.h5')
if not model:
    # check if model does exist
    print('ERROR: Could not load or create Keras model. Exiting...')
    sys.exit(1)
# get full keras response space on data
refs = []
for point in all_data:
    prob = model.predict_proba(point)[0][0]
    refs.append(prob)
refs = np.asarray(refs)
labels_ref = np.concatenate((np.ones(len(sig_img)), np.zeros(len(bkg_img))))

# create advanced drone

drone = AdvancedModel()
drone.add(Conv2D(n_filters = 10, kernel_size = (3, 3), activation = relu,
                 input_shape = (3, 15, 15), data_format = 'channels_first'))
drone.add(MaxPool2D(pool_size = (2,2), strides = 1))
drone.add(Conv2D(n_filters = 10, kernel_size = (2, 2), activation = relu))
drone.add(MaxPool2D(pool_size = (2,2), strides = 1))
drone.add(Conv2D(n_filters = 10, kernel_size = (2, 2), activation = relu))
drone.add(MaxPool2D(pool_size = (2,2), strides = 1))
drone.add(Flatten())
Exemplo n.º 47
0
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.show()
# "Loss"
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.show()

#---------------------------------------------------------------------------------
performace = classifier.evaluate(X_test,y_test)

y_pred = classifier.predict_classes(X_test)

result = classifier.predict(X_test)

prob = classifier.predict_proba(X_test)

np.savetxt("prob.csv",prob,fmt="%s",delimiter=",")

from keras.models import load_model

classifier.save('FCN.h5')

model = load_model('FCN.h5')
Exemplo n.º 48
0
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD

model = Sequential()
model.add(Dense(input_dim=M, units=K))
model.add(Activation('softmax'))

model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.1))

minibatch_size = 50
model.fit(X, Y, epochs=20, batch_size=minibatch_size)

X_, Y_ = shuffle(X, Y)
classes = model.predict_classes(X_[0:10], batch_size=minibatch_size)
prob = model.predict_proba(X_[0:10], batch_size=1)

print('classified:')
print(np.argmax(model.predict(X_[0:10]), axis=1) == classes)
print()
print('output probability:')
print(prob)

## データのグラフ
#import matplotlib as mpl
#mpl.use('Agg')
#import matplotlib.pyplot as plt
#fig = plt.figure()
#fig_sub1 = fig.add_subplot(111)
#fig_sub1.plot(X1[:,0], X1[:,1], 'o')
#fig_sub1.plot(X2[:,0], X2[:,1], '^')
Exemplo n.º 49
0
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(len(le.classes_)))
model.add(Activation('softmax'))

model.compile(loss='categorical_crossentropy',
              optimizer='rmsprop',
              metrics=['categorical_accuracy'])

model.fit(X_train,
          categorical_labels,
          epochs=100,
          batch_size=20,
          workers=-1,
          use_multiprocessing=True,
          validation_split=0.20)

model.save_weights('../../text_graph_fc_model.h5')

y_pred = model.predict_proba(X_test)

# Write predictions to a file
with open('text_cnn_submit.csv', 'w') as csvfile:
    writer = csv.writer(csvfile, delimiter=',')
    lst = le.classes_.tolist()
    lst.insert(0, "Host")
    writer.writerow(lst)
    for i, test_host in enumerate(test_hosts):
        lst = y_pred[i, :].tolist()
        lst.insert(0, test_host)
        writer.writerow(lst)
Exemplo n.º 50
0
	# Output
	[
		[ 2.],
		[ 4.5]
	],
	[-6.5]
])'''

train_x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
train_y = np.array([[0], [1], [1], [1]])

print('OR gate implemented by neural network')
tbCallBack = TensorBoard(log_dir='log', histogram_freq=0, write_graph=True, write_images=True)
model.fit(train_x, train_y, batch_size=1, epochs=1000, verbose=0, callbacks=[tbCallBack])
# tensorboard --logdir=log

print(model.predict_proba(train_x))

print('[0, 0] => ', model.predict(np.array([[0, 0]]))[0][0])
print('[0, 1] => ', model.predict(np.array([[0, 1]]))[0][0])
print('[1, 0] => ', model.predict(np.array([[1, 0]]))[0][0])
print('[1, 1] => ', model.predict(np.array([[1, 1]]))[0][0])

# Layer weight
'''for layer in model.layers:
	weights = layer.get_weights()
	print(layer.name + ':')
	print(weights)'''

print(model.get_weights())
Exemplo n.º 51
0
                 validation_split=0.25,
                 shuffle=True)

# visualizing losses and accuracy
train_loss = hist.history['loss']
val_loss = hist.history['val_loss']
train_acc = (hist.history['acc'])
val_acc = (hist.history['val_acc'])

score = model.evaluate(X_test, Y_test, verbose=0)  # accuracy check
print('Test accuracy:', score[1])  # Prints test accuracy

y_pred = model.predict_classes(
    X_test)  # Predicts classes of all images in test data

p = model.predict_proba(X_test)  # To predict probability

print('\nConfusion Matrix')
print(confusion_matrix(np.argmax(Y_test, axis=1),
                       y_pred))  # Prints Confusion matrix for analysis

# Serialize model to JSON
model_json = model.to_json()
with open("model.json", "w") as json_file:
    json_file.write(model_json)

# Serialize weights to H5
model.save_weights("model.h5")
print("Saved model to disk")

# X_test and Y_test are saved so model can be tested
Exemplo n.º 52
0
class Model:
    
    MODEL_PATH = './me.face.model.h5'

    def __init__(self):
        self.model = None 
        
    #建立模型
    def build_model(self, dataset, nb_classes = 2):
        #构建一个空的网络模型,它是一个线性堆叠模型,各神经网络层会被顺序添加,专业名称为序贯模型或线性堆叠模型
        self.model = Sequential() 
        
        #以下代码将顺序添加CNN网络需要的各层,一个add就是一个网络层
        self.model.add(Convolution2D(32, 3, 3, border_mode='same', 
                                     input_shape = dataset.input_shape))    #1 2维卷积层
        self.model.add(Activation('relu'))                                  #2 激活函数层
        
        self.model.add(Convolution2D(32, 3, 3))                             #3 2维卷积层                             
        self.model.add(Activation('relu'))                                  #4 激活函数层
        
        self.model.add(MaxPooling2D(pool_size=(2, 2)))                      #5 池化层
        self.model.add(Dropout(0.25))                                       #6 Dropout层

        self.model.add(Convolution2D(64, 3, 3, border_mode='same'))         #7  2维卷积层
        self.model.add(Activation('relu'))                                  #8  激活函数层
        
        self.model.add(Convolution2D(64, 3, 3))                             #9  2维卷积层
        self.model.add(Activation('relu'))                                  #10 激活函数层
        
        self.model.add(MaxPooling2D(pool_size=(2, 2)))                      #11 池化层
        self.model.add(Dropout(0.25))                                       #12 Dropout层

        self.model.add(Flatten())                                           #13 Flatten层
        self.model.add(Dense(512))                                          #14 Dense层,又被称作全连接层
        self.model.add(Activation('relu'))                                  #15 激活函数层   
        self.model.add(Dropout(0.5))                                        #16 Dropout层
        self.model.add(Dense(nb_classes))                                   #17 Dense层
        self.model.add(Activation('softmax'))                               #18 分类层,输出最终结果
        
        #输出模型概况
        self.model.summary()

    #训练模型
    def train(self, dataset, batch_size = 20, nb_epoch = 10, data_augmentation = True):        
        sgd = SGD(lr = 0.01, decay = 1e-6, 
                  momentum = 0.9, nesterov = True) #采用SGD+momentum的优化器进行训练,首先生成一个优化器对象  
        self.model.compile(loss='categorical_crossentropy',
                           optimizer=sgd,
                           metrics=['accuracy'])   #完成实际的模型配置工作
        
        #不使用数据提升,所谓的提升就是从我们提供的训练数据中利用旋转、翻转、加噪声等方法创造新的
        #训练数据,有意识的提升训练数据规模,增加模型训练量
        if not data_augmentation:            
            self.model.fit(dataset.train_images,
                           dataset.train_labels,
                           batch_size = batch_size,
                           nb_epoch = nb_epoch,
                           validation_data = (dataset.valid_images, dataset.valid_labels),
                           shuffle = True)
        #使用实时数据提升
        else:            
            #定义数据生成器用于数据提升,其返回一个生成器对象datagen,datagen每被调用一
            #次其生成一组数据(顺序生成),节省内存,其实就是python的数据生成器
            datagen = ImageDataGenerator(
                featurewise_center = False,             #是否使输入数据去中心化(均值为0),
                samplewise_center  = False,             #是否使输入数据的每个样本均值为0
                featurewise_std_normalization = False,  #是否数据标准化(输入数据除以数据集的标准差)
                samplewise_std_normalization  = False,  #是否将每个样本数据除以自身的标准差
                zca_whitening = False,                  #是否对输入数据施以ZCA白化
                rotation_range = 20,                    #数据提升时图片随机转动的角度(范围为0~180)
                width_shift_range  = 0.2,               #数据提升时图片水平偏移的幅度(单位为图片宽度的占比,0~1之间的浮点数)
                height_shift_range = 0.2,               #同上,只不过这里是垂直
                horizontal_flip = True,                 #是否进行随机水平翻转
                vertical_flip = False)                  #是否进行随机垂直翻转

            #计算整个训练样本集的数量以用于特征值归一化、ZCA白化等处理
            datagen.fit(dataset.train_images)                        

            #利用生成器开始训练模型
            self.model.fit_generator(datagen.flow(dataset.train_images, dataset.train_labels,
                                                   batch_size = batch_size),
                                     samples_per_epoch = dataset.train_images.shape[0],
                                     nb_epoch = nb_epoch,
                                     validation_data = (dataset.valid_images, dataset.valid_labels))    

    
    def save_model(self, file_path = MODEL_PATH):
        self.model.save(file_path)
 
    def load_model(self, file_path = MODEL_PATH):
        self.model = load_model(file_path)

    #识别人脸
    def face_predict(self, image):    
        #依然是根据后端系统确定维度顺序
        if K.image_dim_ordering() == 'th' and image.shape != (1, 3, IMAGE_SIZE, IMAGE_SIZE):
            image = resize_image(image)                             #尺寸必须与训练集一致都应该是IMAGE_SIZE x IMAGE_SIZE
            image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))   #与模型训练不同,这次只是针对1张图片进行预测    
        elif K.image_dim_ordering() == 'tf' and image.shape != (1, IMAGE_SIZE, IMAGE_SIZE, 3):
            image = resize_image(image)
            image = image.reshape((1, IMAGE_SIZE, IMAGE_SIZE, 3))                    
        
        #浮点并归一化
        image = image.astype('float32')
        image /= 255
        
        #给出输入属于各个类别的概率,我们是二值类别,则该函数会给出输入图像属于0和1的概率各为多少
        result = self.model.predict_proba(image)
        print('result:', result)
        
        #给出类别预测:0或者1
        result = self.model.predict_classes(image)        

        #返回类别预测结果
        return result[0]        
Exemplo n.º 53
0
model.add(BatchNormalization())
model.add(Dropout(0.5))

model.add(Dense(units=512, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))

model.add(Dense(units=1))
model.add(Activation('sigmoid'))

# Compile model
model.compile(loss='binary_crossentropy',
              optimizer='sgd',
              metrics=['accuracy'])

scaler = StandardScaler().fit(x_train)
x_train, x_test = scaler.transform(x_train), scaler.transform(x_test)

model.fit(x_train,
          y_train,
          epochs=80,
          batch_size=128,
          callbacks=[EarlyStopping(monitor='loss', patience=20)],
          validation_data=(x_test, y_test))
y_pre = model.predict_proba(x_test)
scores_train = roc_auc_score(y_train, model.predict_proba(x_train))
scores = roc_auc_score(y_test, y_pre)

print("\nnnModel Report")
print("AUC Score (Train): %f" % scores_train)
print("AUC Score (Test): %f" % scores)
Exemplo n.º 54
0
model.compile(loss='binary_crossentropy',
              optimizer=adam,
              metrics=['categorical_accuracy'])

# learning schedule callback
history = History()
lrate = LearningRateScheduler(step_decay)
callbacks_list = [lrate, history]

#model Fitting
print "Training..."
model.fit(X_train,
          y_train,
          validation_data=(X_test, y_test),
          nb_epoch=2000,
          batch_size=X_train.shape[0],
          callbacks=callbacks_list,
          verbose=1)
#model.fit(X_train, y_train,validation_data=(X_test,y_test),nb_epoch=550, batch_size=X_train.shape[0],class_weight={0:1, 1:6756.0/271}, callbacks=callbacks_list, verbose=1)

#Model prediction
predicted = model.predict_proba(X_test, batch_size=25)
predicted1 = model.predict_proba(X_val, batch_size=25)
y_val = numpy.argmax(y_val, 1)
yt = numpy.argmax(y_test, 1)
print "\n\nROC_AUC Val Data: ", roc_auc_score(y_val, predicted1[:, 1])

numpy.save("Prediction.npy", predicted)
numpy.save("Xtest.npy", X_test)
model.save('H8_student.h5')
Exemplo n.º 55
0
def test_sequential(in_tmpdir):
    (x_train, y_train), (x_test, y_test) = _get_test_data()

    # TODO: factor out
    def data_generator(x, y, batch_size=50):
        index_array = np.arange(len(x))
        while 1:
            batches = make_batches(len(x_test), batch_size)
            for batch_index, (batch_start, batch_end) in enumerate(batches):
                batch_ids = index_array[batch_start:batch_end]
                x_batch = x[batch_ids]
                y_batch = y[batch_ids]
                yield (x_batch, y_batch)

    model = Sequential()
    model.add(Dense(num_hidden, input_shape=(input_dim, )))
    model.add(Activation('relu'))
    model.add(Dense(num_classes))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=1,
              validation_data=(x_test, y_test))
    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=2,
              validation_split=0.1)
    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=0)
    model.fit(x_train,
              y_train,
              batch_size=batch_size,
              epochs=epochs,
              verbose=1,
              shuffle=False)

    model.train_on_batch(x_train[:32], y_train[:32])

    loss = model.evaluate(x_test, y_test)

    prediction = model.predict_generator(data_generator(x_test, y_test),
                                         1,
                                         max_queue_size=2,
                                         verbose=1)
    gen_loss = model.evaluate_generator(data_generator(x_test, y_test, 50),
                                        1,
                                        max_queue_size=2)
    pred_loss = K.eval(
        K.mean(
            losses.get(model.loss)(K.variable(y_test),
                                   K.variable(prediction))))

    assert (np.isclose(pred_loss, loss))
    assert (np.isclose(gen_loss, loss))

    model.predict(x_test, verbose=0)
    model.predict_classes(x_test, verbose=0)
    model.predict_proba(x_test, verbose=0)

    fname = 'test_sequential_temp.h5'
    model.save_weights(fname, overwrite=True)
    model = Sequential()
    model.add(Dense(num_hidden, input_shape=(input_dim, )))
    model.add(Activation('relu'))
    model.add(Dense(num_classes))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
    model.load_weights(fname)
    os.remove(fname)

    nloss = model.evaluate(x_test, y_test, verbose=0)
    assert (loss == nloss)

    # Test serialization
    config = model.get_config()
    assert 'name' in config
    new_model = Sequential.from_config(config)
    assert new_model.weights  # Model should be built.

    model.summary()
    json_str = model.to_json()
    model_from_json(json_str)

    yaml_str = model.to_yaml()
    model_from_yaml(yaml_str)
Exemplo n.º 56
0
#pyplot.plot(inv_ypred)
#pyplot.plot(inv_y)
#pyplot.show()

####### NEEDS A LITTLE BIT OF WORK BUT YOU CAN RUN IT AND SEE IF IT WORKS #########
#IV-Prediction on real Test Data

#load test data
test = pd.read_csv('test.csv', index_col='time')
test.drop(['Unnamed: 0'], axis=1, inplace=True)
test.index.name = 'time'

test_id = test['id']
test.drop(['id', 'crew', 'experiment'], axis=1, inplace=True)

# Feature Scaling
values_test = test.values
scaler = MinMaxScaler(feature_range=(0, 1))
values_test[:, 0:2] = scaler.fit_transform(values[:, 0:24])

#Predict probabilities of Ids in Test data
Test = pd.DataFrame(values)
pred = classifier.predict_proba(Test)

sub = pd.DataFrame(pred, columns=['A', 'B', 'C', 'D'])
sub['id'] = test_id
cols = sub.columns.tolist()
cols = cols[-1:] + cols[:-1]
sub = sub[cols]
sub.to_csv("Test_prob.csv", index=False)
from keras.models import Sequential
from keras.layers import Dense

#Initialising ANN
classifier = Sequential()

#Adding the Input layer and First hidden layers
classifier.add(
    Dense(output_dim=3, init='uniform', activation='relu', input_dim=2))

#Adding Output Layer   if dependencies param > 2  change output_dim=x and activation=softmax
classifier.add(Dense(output_dim=3, init='uniform', activation='softmax'))

#Part 3 - Make Prediction and Evaluating the model if dependencies param > 2  change loss='categorical_crossentropy'
classifier.compile(optimizer='adam',
                   loss='categorical_crossentropy',
                   metrics=['accuracy'])

# Fitting ANN to the Training set
classifier.fit(X_train, y_train, batch_size=10, nb_epoch=25)

# Predicting the Test set results
classes = classifier.predict_classes(X_test, batch_size=10)
proba = classifier.predict_proba(X_test, batch_size=10)

# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix

y_test = y_test.astype(int)
cm = confusion_matrix(y_test, classes)
	print('Evaluating Test Accuracy Without Acquisition')
	score, acc = model.evaluate(X_test, Y_test, show_accuracy=True, verbose=0)

	all_accuracy = acc

	print('Starting Active Learning in Experiment ', e)




	for i in range(acquisition_iterations):
		print('POOLING ITERATION', i)

		print('Using trained model for Entropy Calculation')

		Class_Probability = model.predict_proba(X_Pool, batch_size=batch_size, verbose=1)
		Class_Log_Probability = np.log2(Class_Probability)
		Entropy_Each_Cell = - np.multiply(Class_Probability, Class_Log_Probability)

		Entropy = np.sum(Entropy_Each_Cell, axis=1)	# summing across rows of the array

		#x_pool_index = 	np.unravel_index(Entropy.argmax(), Entropy.shape)	#for finding the maximum value np.amax(Entropy)
		x_pool_index = Entropy.argsort()[-Queries:][::-1]

		# THIS FINDS THE INDEX OF THE MINIMUM
		# a_1d = Entropy.flatten()
		# x_pool_index = a_1d.argsort()[-N:]

		#saving pooled images
		# for im in range(x_pool_index[0:2].shape[0]):
		# 	Image = X_Pool[x_pool_index[im], :, :, :]
Exemplo n.º 59
0
        # hidden layer 1
        model.add(Dense(units=combination[1], activation=combination[-2], input_dim=x_train.shape[1], init='RandomNormal'))
        model.add(Dropout(rate=0.5))
        model.add(BatchNormalization())
        if combination[2] > 0:
            # hidden layer 2
            model.add(Dense(units=combination[2], activation=combination[-2], input_dim=x_train.shape[1]))
            model.add(Dropout(rate=0.5))
            model.add(BatchNormalization())
            if combination[3] > 0:
                # hidden layer 3
                model.add(Dense(units=combination[3], activation=combination[-2], input_dim=x_train.shape[1]))
                model.add(Dropout(rate=0.5))
                model.add(BatchNormalization())
        model.add(Dense(units=1, activation='sigmoid'))
        if combination[-1] == 'SGD':
            model.compile(loss='binary_crossentropy',
                  optimizer=keras.optimizers.SGD(lr=combination[-3], momentum=0.9),
                  metrics=['accuracy'])
        elif combination[-1] == 'Adagrad':
            model.compile(loss='binary_crossentropy',
                  optimizer=keras.optimizers.Adagrad(lr=combination[-3], epsilon=1e-08),
                  metrics=['accuracy'])
        hist = model.fit(x_train, y_train, epochs=50, shuffle=True, validation_split=0.33, callbacks=[early_stopping], verbose=0)
        loss_and_metrics = model.evaluate(x_test, y_test, verbose=0)
        y_pred = model.predict_proba(x_test, verbose=0)
        auc = roc_auc_score(y_test, y_pred)
        # print(loss_and_metrics)
        fout.write(','.join([str(x) for x in combination + tuple(loss_and_metrics) + (auc, hist.history['acc'][-1], hist.history['val_acc'][-1])])+'\n')
    fout.close()
score = model.evaluate(val_x, val_y, verbose=0)


# In[205]:

score


# In[181]:

test_x.shape


# In[182]:

pred = model.predict_proba(test_x)


# In[183]:

submit_df = pd.DataFrame(pred, columns=[1, 2, 3, 4])


# In[184]:

submit_df.head()


# In[185]:

submit_df.shape