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)
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)
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)
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)
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)
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)
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)
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
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)
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)
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
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}
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]
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)
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])
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)
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]
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
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
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]))
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]))
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)
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
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
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)
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
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
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)
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))
# 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)
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()
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)
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
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)
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()
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]]
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
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
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())
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')
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], '^')
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)
# 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())
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
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]
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)
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')
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)
#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], :, :, :]
# 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