def main_separatemodels(): X1, X2, y = generate_data2(TRAINING_SIZE) X1_test, X2_test, y_test = generate_data2(TEST_SIZE) print('Defining network...', file=sys.stderr) firstlstm = Sequential() firstlstm.add(Embedding(VOCABULARY_SIZE, EMBEDDING_DIMENSION)) firstlstm.add(LSTM(EMBEDDING_DIMENSION, HIDDEN_DIMENSION, return_sequences=False)) secondlstm = Sequential() secondlstm.add(Embedding(VOCABULARY_SIZE, EMBEDDING_DIMENSION)) secondlstm.add(LSTM(EMBEDDING_DIMENSION, HIDDEN_DIMENSION, return_sequences=False)) model = Sequential() model.add(Merge([firstlstm, secondlstm], mode='concat')) model.add(Dense(HIDDEN_DIMENSION + HIDDEN_DIMENSION, 1, activation='sigmoid')) print('Compiling...', file=sys.stderr) model.compile(loss='binary_crossentropy', optimizer='adam', class_mode="binary") print('Training...', file=sys.stderr) model.fit([X1, X2], y, batch_size=BATCH_SIZE, nb_epoch=EPOCHS, validation_split=0.05, show_accuracy=True) print("Testing...", file=sys.stderr) score, acc = model.evaluate([X1_test, X2_test], y_test, batch_size=BATCH_SIZE, show_accuracy=True) print("Testing performance = " + str(score) + ", acc = " + str(acc))
def test_TensorBoard_with_ReduceLROnPlateau(tmpdir): import shutil np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) cbks = [ callbacks.ReduceLROnPlateau( monitor='val_loss', factor=0.5, patience=4, verbose=1), callbacks.TensorBoard( log_dir=filepath)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=2) assert os.path.isdir(filepath) shutil.rmtree(filepath) assert not tmpdir.listdir()
def model(X_train, X_test, y_train, y_test, maxlen, max_features): embedding_size = 300 pool_length = 4 lstm_output_size = 100 batch_size = 200 nb_epoch = 1 model = Sequential() model.add(Embedding(max_features, embedding_size, input_length=maxlen)) model.add(Dropout({{uniform(0, 1)}})) # Note that we use unnamed parameters here, which is bad style, but is used here # to demonstrate that it works. Always prefer named parameters. model.add(Convolution1D({{choice([64, 128])}}, {{choice([6, 8])}}, border_mode='valid', activation='relu', subsample_length=1)) model.add(MaxPooling1D(pool_length=pool_length)) model.add(LSTM(lstm_output_size)) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print('Train...') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_data=(X_test, y_test)) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score:', score) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def train_rnn(character_corpus, seq_len, train_test_split_ratio): model = Sequential() model.add(Embedding(character_corpus.char_num(), 256)) model.add(LSTM(256, 5120, activation='sigmoid', inner_activation='hard_sigmoid', return_sequences=True)) model.add(Dropout(0.5)) model.add(TimeDistributedDense(5120, character_corpus.char_num())) model.add(Activation('time_distributed_softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') seq_X, seq_Y = character_corpus.make_sequences(seq_len) print "Sequences are made" train_seq_num = train_test_split_ratio*seq_X.shape[0] X_train = seq_X[:train_seq_num] Y_train = to_time_distributed_categorical(seq_Y[:train_seq_num], character_corpus.char_num()) X_test = seq_X[train_seq_num:] Y_test = to_time_distributed_categorical(seq_Y[train_seq_num:], character_corpus.char_num()) print "Begin train model" checkpointer = ModelCheckpoint(filepath="model.step", verbose=1, save_best_only=True) model.fit(X_train, Y_train, batch_size=256, nb_epoch=100, verbose=2, validation_data=(X_test, Y_test), callbacks=[checkpointer]) print "Model is trained" score = model.evaluate(X_test, Y_test, batch_size=512) print "valid score = ", score return model
def test_EarlyStopping(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) mode = 'max' monitor = 'val_acc' patience = 0 cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)] history = model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=20) mode = 'auto' monitor = 'val_acc' patience = 2 cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)] history = model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=20)
def train(): print('Build model...') model = Sequential() model.add(Embedding(max_features, 128, input_length=maxlen, dropout=0.2)) model.add(LSTM(128, dropout_W=0.2, dropout_U=0.2)) # try using a GRU instead, for fun model.add(Dense(1)) model.add(Activation('sigmoid')) # try using different optimizers and different optimizer configs model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print('Train...') print(X_train.shape) print(y_train.shape) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=15, validation_data=(X_test, y_test)) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score:', score) print('Test accuracy:', acc) with open("save_weight_lstm.pickle", mode="wb") as f: pickle.dump(model.get_weights(),f)
def create_model(x_train, y_train, x_test, y_test): """ Create your model... """ layer_1_size = {{quniform(12, 256, 4)}} l1_dropout = {{uniform(0.001, 0.7)}} params = { 'l1_size': layer_1_size, 'l1_dropout': l1_dropout } num_classes = 10 model = Sequential() model.add(Dense(int(layer_1_size), activation='relu')) model.add(Dropout(l1_dropout)) model.add(Dense(num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=RMSprop(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=128, epochs=10, validation_data=(x_test, y_test)) score, acc = model.evaluate(x_test, y_test, verbose=0) out = { 'loss': -acc, 'score': score, 'status': STATUS_OK, 'model_params': params, } # optionally store a dump of your model here so you can get it from the database later temp_name = tempfile.gettempdir()+'/'+next(tempfile._get_candidate_names()) + '.h5' model.save(temp_name) with open(temp_name, 'rb') as infile: model_bytes = infile.read() out['model_serial'] = model_bytes return out
def imdb_lstm(): max_features = 20000 maxlen = 80 # cut texts after this number of words (among top max_features most common words) batch_size = 32 (X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words=max_features) print type(X_train) exit(0) 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=maxlen) X_test = sequence.pad_sequences(X_test, maxlen=maxlen) print('X_train shape:', X_train.shape) print('X_test shape:', X_test.shape) print('Build model...') model = Sequential() model.add(Embedding(max_features, 128, dropout=0.2)) model.add(LSTM(128, dropout_W=0.2, dropout_U=0.2)) # try using a GRU instead, for fun model.add(Dense(1)) model.add(Activation('sigmoid')) # try using different optimizers and different optimizer configs model.compile(loss='binary_crossentropy', optimizer='adam',metrics=['accuracy']) print('Train...') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=15, validation_data=(X_test, y_test)) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score:', score) print('Test accuracy:', acc)
def CNN_3_layer(activation): Xtrain, ytrain, XCV, yCV, Xtest, ytest = load_data("mnist.pkl.gz") Xtrain = Xtrain.reshape(Xtrain.shape[0], 1, 28, 28) Xtest = Xtest.reshape(Xtest.shape[0], 1, 28, 28) XCV = Xtest.reshape(XCV.shape[0], 1, 28, 28) # 0~9 ten classes ytrain = np_utils.to_categorical(ytrain, 10) ytest = np_utils.to_categorical(ytest, 10) yCV = np_utils.to_categorical(yCV, 10) # Build the model model = Sequential() model.add(Convolution2D(32,3,3,border_mode='valid',input_shape=(1,28,28))) model.add(Activation(activation)) model.add(Convolution2D(32,3,3)) model.add(Activation(activation)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(16,3,3)) model.add(Activation(activation)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128)) model.add(Activation(activation)) model.add(Dropout(0.5)) model.add(Dense(10)) model.add(Activation('softmax')) # fit module print "fit module" model.compile(loss='categorical_crossentropy',optimizer='adadelta',metrics=['accuracy']) model.fit(Xtrain,ytrain,batch_size=100,nb_epoch=20,verbose=1,validation_data=(XCV,yCV)) score = model.evaluate(Xtest,ytest, verbose=0) print score[0] print score[1]
class MLP: ''' [(output_dim, input_dim, init, activation, dropout)] ''' def __init__(self\ , structure\ , sgd_params_init = sgd_params(0.1,1e-6,0.9,True)\ , loss_name = 'mean_squared_error'): self.model = Sequential() for layers in structure: self.model.add(Dense(output_dim = layers.output_dim\ , input_dim = layers.input_dim\ , init = layers.init\ , activation = layers.activation)) if layers.dropout != None: self.model.add(Dropout(layers.dropout)) sgd = SGD(lr = sgd_params_init.lr\ , decay = sgd_params_init.decay\ , momentum = sgd_params_init.momentum\ , nesterov = sgd_params_init.nesterov) self.model.compile(loss = loss_name, optimizer = sgd) def train(self, X_train, y_train, nb_epoch = 20, batch_size = 16): self.model.fit(X_train, y_train, nb.epoch, batch_size) def test(self, X_test, y_test, batch_size = 16): return self.model.evaluate(X_test, y_test, batch_size)
def train_the_nn(features, label, look_back = 1): model = Sequential() model.add(Dense(8, input_dim=look_back, activation='relu')) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer = 'adam') model.fit(features, label, nb_epoch=200, batch_size=2, verbose=2) return model
def trainNN(): # POSITIVE training data posPX, posSX = getAllWindowedMinMaxPositiveTrainingData('./sample/example30', preSize=10, postSize=20) posPY = np.array([[1]] * len(posPX)) posSY = np.array([[1]] * len(posSX)) # NEGATIVE training data negX = getSomeWindowedMinMaxNegativeTrainingData('./sample/example30/', size=30, num=200) negY = np.array([[0]] * 200) # ALL training data X = np.concatenate([posPX, posSX, negX]) Y = np.concatenate([posPY, posSY, negY]) # 使用keras创建神经网络 # Sequential是指一层层堆叠的神经网络 # Dense是指全连接层 # 定义model model = Sequential() model.add(Dense(50, input_dim=30, activation='sigmoid')) model.add(Dense(50, activation='sigmoid')) model.add(Dense(10, activation='sigmoid')) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) # model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) model.fit(X, Y, epochs=200, batch_size=32) model.save('model.h5') return model
def generateModel(self,docSeries): topics = docSeries.topicSeries.keys() seriesLength = 50 sequenceTuples = [] for j in range(len(topics)): topic = topics[j] topicLength = len(docSeries.topicSeries[topic]) for i in range(0,topicLength): if i+seriesLength < topicLength: sequenceTuples.append((docSeries.topicSeries[topic][i:i+seriesLength],j)) random.shuffle(sequenceTuples) X = [] y = [] for s,l in sequenceTuples: X.append(s) y.append(l) X = np.array(X).astype(np.uint8) y = np_utils.to_categorical(np.array(y)).astype(np.bool) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1) print len(X_train),len(y_train) print X.shape,y.shape model = Sequential() model.add(Embedding(50, 64, input_length = seriesLength, mask_zero = True)) model.add(LSTM(64,init='glorot_uniform',inner_init='orthogonal',activation='tanh',inner_activation='hard_sigmoid',return_sequences=False)) model.add(Dropout(0.5)) model.add(Dense(len(topics))) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', class_mode='categorical') early_stopping = EarlyStopping(patience=5, verbose=1) model.fit(X_train, y_train,nb_epoch=20,show_accuracy=True,verbose=1,shuffle=True) preds = model.predict_classes(X_test, batch_size=64, verbose=0) print '\n' print(classification_report(np.argmax(y_test, axis=1), preds, target_names=topics))
def trainModel(): inputs, correctOutputs = getNNData() print("Collected data") trainingInputs = inputs[:len(inputs)//2] trainingOutputs = correctOutputs[:len(correctOutputs)//2] testInputs = inputs[len(inputs)//2:] testOutputs = correctOutputs[len(correctOutputs)//2:] model = Sequential() model.add(Dense(24, input_shape=(24, ))) model.add(Activation('tanh')) model.add(Dense(24)) model.add(Activation('tanh')) model.add(Dense(5)) model.add(Activation('softmax')) model.summary() model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)) model.fit(trainingInputs, trainingOutputs, validation_data=(testInputs, testOutputs)) score = model.evaluate(testInputs, testOutputs, verbose=0) print(score) json_string = model.to_json() open('my_model_architecture.json', 'w').write(json_string) model.save_weights('my_model_weights.h5', overwrite=True)
def main(): train_X = np.load('train_X.npy') train_y = np.load('train_y.npy') test_X = np.load('test_X.npy') test_y = np.load('test_y.npy') model = Sequential() model.add(Flatten(input_shape=(15,60,2))) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(900)) model.add(Activation('sigmoid')) print model.summary() adam = Adam(0.001) #adagrad = Adagrad(lr=0.01) model.compile(loss='mse', optimizer=adam) model.fit(train_X, train_y, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(test_X, test_y)) model.save_weights('model.h5', overwrite=True)
def model(X_train, X_test, Y_train, Y_test): model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([400, 512, 600])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) nb_epoch = 10 batch_size = 128 model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def runNN(train_X, train_y, test_X, test_y=None): #sc = preprocessing.StandardScaler() #train_X = sc.fit_transform(train_X) #test_X = sc.transform(test_X) train_y = np_utils.to_categorical(train_y, 2) model = Sequential() model.add(Dense(train_X.shape[1], 100, init='he_uniform')) model.add(Activation('relu')) model.add(Dropout(0.2)) model.add(Dense(100, 50, init='he_uniform')) model.add(Activation('relu')) model.add(Dropout(0.4)) model.add(Dense(50, 25, init='he_uniform')) model.add(Activation('relu')) model.add(Dropout(0.4)) model.add(Dense(25, 2, init='he_uniform')) model.add(Activation('softmax')) #sgd_opt = SGD(lr=0.01) model.compile(loss='binary_crossentropy', optimizer='adam') model.fit(train_X, train_y, batch_size=256, nb_epoch=50, validation_split=0.05, verbose=2) preds = model.predict(test_X, verbose=0)[:,1] print preds[:10] print "Test preds shape : ",preds.shape print "ROC AUC score : ", metrics.roc_auc_score(test_y, preds)
def model(X_train, X_test, y_train, y_test, max_features, maxlen): model = Sequential() model.add(Embedding(max_features, 128, input_length=maxlen)) model.add(LSTM(128)) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) early_stopping = EarlyStopping(monitor='val_loss', patience=4) checkpointer = ModelCheckpoint(filepath='keras_weights.hdf5', verbose=1, save_best_only=True) model.fit(X_train, y_train, batch_size={{choice([32, 64, 128])}}, nb_epoch=1, validation_split=0.08, callbacks=[early_stopping, checkpointer]) score, acc = model.evaluate(X_test, y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def get_ts_model( trainX, trainY, look_back = 1, nb_epochs = 100 ): model = Sequential() # takes input array of shape (*, 1) where (2,1) - (row,col) array example looks like [23] # [43] model.add(LSTM(20, input_shape=(None , look_back) )) #model.add(LSTM(20, batch_input_shape=(None, None, look_back), return_sequences= True )) #print(model.summary) model.add( Dense(1) ) model.add(Dense(1)) model.add(Dense(1)) model.add(Dense(1)) model.add(Dense(1)) model.add(Dense(1)) #model.add(LSTM(1, return_sequences= True)) #model.add(LSTM(1)) # outputs array of shape (*,1) #model.add(Dense(1)) #model.compile(loss='mean_absolute_error', optimizer='SGD') # mape #model.compile(loss='poisson', optimizer='adam') # mape model.compile( loss = 'mean_squared_error', optimizer = 'adam' ) # values closer to zero are better. #model.compile(loss='mean_squared_error', optimizer='adagrad') # Values of MSE are used for comparative purposes of two or more statistical meythods. Heavily weight outliers, i.e weighs large errors more heavily than the small ones. # "In cases where this is undesired, mean absolute error is used. # REF: Available loss functions https://keras.io/objectives. print('Start : Training model') # default configuration model.fit(trainX, trainY, nb_epoch=nb_epochs, batch_size=1, verbose=2) #model.fit(trainX, trainY, nb_epoch=100, batch_size=1, verbose=2) print('Ends : Training Model') return 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}
def model(X_train, Y_train, X_test, Y_test): ''' Model providing function: Create Keras model with double curly brackets dropped-in as needed. Return value has to be a valid python dictionary with two customary keys: - loss: Specify a numeric evaluation metric to be minimized - status: Just use STATUS_OK and see hyperopt documentation if not feasible The last one is optional, though recommended, namely: - model: specify the model just created so that we can later use it again. ''' model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([256, 512, 1024])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) model.fit(X_train, Y_train, batch_size={{choice([64, 128])}}, nb_epoch=1, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def evaluate(lr, pos): (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = (X_train.astype("float32")).reshape((60000, 784)) X_test = (X_test.astype("float32")).reshape((10000, 784)) X_train /= 255 X_test /= 255 Y_train = np_utils.to_categorical(y_train, 10) Y_test = np_utils.to_categorical(y_test, 10) model = Sequential() model.add(Dense(output_dim=layer1, input_dim=784)) if pos == 0: model.add(BatchNormalization()) model.add(Activation("relu")) model.add(Dense(output_dim=layer2, input_dim=layer1)) if pos == 1: model.add(BatchNormalization()) model.add(Activation("relu")) model.add(Dense(output_dim=10, input_dim=layer2)) if pos == 2: model.add(BatchNormalization()) model.add(Activation("softmax")) model.compile( loss="categorical_crossentropy", optimizer=SGD(lr=lr, momentum=0.9, nesterov=True), metrics=["accuracy"] ) model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=(X_test, Y_test)) score = model.evaluate(X_test, Y_test, verbose=0) return score[1]
def ann(self): #print self.company.X_train.shape[1] model = Sequential() model.add(Dense(input_dim=self.search_inputs.X_train.shape[1], output_dim=10, init="glorot_uniform")) model.add(Activation('tanh')) model.add(Dropout(0.1)) model.add(Dense(input_dim=10, output_dim=10, init="uniform")) model.add(Activation('tanh')) model.add(Dropout(0.5)) model.add(Dense(input_dim=10, output_dim=1, init="glorot_uniform")) model.add(Activation("linear")) sgd = SGD(lr=0.3, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='mean_squared_error', optimizer='sgd') early_stopping = EarlyStopping(monitor='val_loss', patience=25) #epoch_score = model.evaluate(X_score, y_score, batch_size = 16) # this doesn't work # first model print "fitting first model" model.fit(self.search_inputs.X_train, self.search_inputs.y_train, nb_epoch=100, validation_split=.1, batch_size=100, verbose = 1, show_accuracy = True, shuffle = True, callbacks=[early_stopping]) #score = model.evaluate(self.company.X_cv, self.company.y_cv, show_accuracy=True, batch_size=16) self.ann_preds = model.predict(self.search_inputs.X_test) #just in case (like w/ svr) for i in range(0,len(self.ann_preds) - 1): if self.ann_preds[i] < 1: self.ann_preds[i] = 1.00 elif self.ann_preds[i] > 3: self.ann_preds[i] = 3.00 self.search_inputs.fin_df['relevance'] = np.array(self.ann_preds) # easy swap in / out final_file_ann = self.search_inputs.fin_df.to_csv(self.fin_file_name+'_ann.csv', float_format='%.5f', index=False)
def OptKeras(h1, h2, h3, d1, d2, d3, d4, ne): model = Sequential() model.add(Dense(dims, h1, init='glorot_uniform')) model.add(PReLU((h1,))) model.add(BatchNormalization((h1,))) model.add(Dropout(d1)) model.add(Dense(h1, h2, init='glorot_uniform')) model.add(PReLU((h2,))) model.add(BatchNormalization((h2,))) model.add(Dropout(d2)) model.add(Dense(h2, h3, init='glorot_uniform')) model.add(PReLU((h3,))) model.add(BatchNormalization((h3,))) model.add(Dropout(d3)) model.add(Dense(h3, nb_classes, init='glorot_uniform')) model.add(Activation('softmax')) sgd = SGD(lr = 0.1, decay = 1e-6, momentum = 0.9, nesterov = True) model.compile(loss='categorical_crossentropy', optimizer=sgd) print("Training model...kkk") model.fit(X, y, nb_epoch = ne, batch_size=1024, validation_split=0.2)
def test_LambdaCallback(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) # Start an arbitrary process that should run during model training and be terminated after training has completed. def f(): while True: pass p = multiprocessing.Process(target=f) p.start() cleanup_callback = callbacks.LambdaCallback(on_train_end=lambda logs: p.terminate()) cbks = [cleanup_callback] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=5) p.join() assert not p.is_alive()
class MotifScoreRNN(Model): def __init__(self, input_shape, gru_size=10, tdd_size=4): self.model = Sequential() self.model.add(GRU(gru_size, return_sequences=True, input_shape=input_shape)) if tdd_size is not None: self.model.add(TimeDistributedDense(tdd_size)) self.model.add(Flatten()) self.model.add(Dense(1)) self.model.add(Activation('sigmoid')) print('Compiling model...') self.model.compile(optimizer='adam', loss='binary_crossentropy') def train(self, X, y, validation_data): print('Training model...') multitask = y.shape[1] > 1 if not multitask: num_positives = y.sum() num_sequences = len(y) num_negatives = num_sequences - num_positives self.model.fit( X, y, batch_size=128, nb_epoch=100, validation_data=validation_data, class_weight={True: num_sequences / num_positives, False: num_sequences / num_negatives} if not multitask else None, callbacks=[EarlyStopping(monitor='val_loss', patience=10)], verbose=True) def predict(self, X): return self.model.predict(X, batch_size=128, verbose=False)
def train_model(): # (X_train, Y_train, X_test, Y_test) = prapare_train() X_ = [] with open('../data/train_matrix.out') as train_file: X_train = json.load(train_file) for x in X_train: a = len(x) print a/2 x1 = x[:a/2] x2 = x[a/2:] x3 = [] x3.append(x1) x3.append(x2) X_.append(x3) # X_test = pickle.load('../data/test_matrix.out') Y_train = [1,0,0]*3 # Y_test = [1,0,0]*3 # print len(X_train) - len(Y_train) # print len(X_test) - len(Y_test) model = Sequential() model = get_nn_model() model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # model.fit(X_train, Y_train, # batch_size=batch_size, # nb_epoch=nb_epoch, # validation_data=(X_test, Y_test)) #2 model.fit(X_, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_split = 0.2) print 'ok'
def model(X_train, Y_train, X_test, Y_test): from keras.models import Sequential from keras.layers.core import Dense, Dropout, Activation from keras.optimizers import RMSprop model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([256, 512, 1024])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms) model.fit(X_train, Y_train, batch_size={{choice([64, 128])}}, nb_epoch=1, show_accuracy=True, verbose=2, validation_data=(X_test, Y_test)) score = model.evaluate(X_test, Y_test, show_accuracy=True, verbose=0) print('Test accuracy:', score[1]) return {'loss': -score[1], 'status': STATUS_OK}
def lstm(trainData, trainMark, testData, embedding_dim, embedding_matrix, maxlen, output_len): # 填充数据,将每个序列长度保持一致 trainData = list(sequence.pad_sequences(trainData, maxlen=maxlen, dtype='float64')) # sequence返回的是一个numpy数组,pad_sequences用于填充指定长度的序列,长则阶段,短则补0,由于下面序号为0时,对应值也为0,因此可以这样 testData = list(sequence.pad_sequences(testData, maxlen=maxlen, dtype='float64')) # sequence返回的是一个numpy数组,pad_sequences用于填充指定长度的序列,长则阶段,短则补0 # 建立lstm神经网络模型 model = Sequential() # 多个网络层的线性堆叠,可以通过传递一个layer的list来构造该模型,也可以通过.add()方法一个个的加上层 # model.add(Dense(256, input_shape=(train_total_vova_len,))) #使用全连接的输入层 model.add(Embedding(len(embedding_matrix), embedding_dim, weights=[embedding_matrix], mask_zero=False, input_length=maxlen)) # 指定输入层,将高维的one-hot转成低维的embedding表示,第一个参数大或等于0的整数,输入数据最大下标+1,第二个参数大于0的整数,代表全连接嵌入的维度 # lstm层,也是比较核心的层 model.add(LSTM(256)) # 256对应Embedding输出维度,128是输入维度可以推导出来 model.add(Dropout(0.5)) # 每次在参数更新的时候以一定的几率断开层的链接,用于防止过拟合 model.add(Dense(output_len)) # 全连接,这里用于输出层,1代表输出层维度,128代表LSTM层维度可以自行推导出来 model.add(Activation('softmax')) # 输出用sigmoid激活函数 # 编译该模型,categorical_crossentropy(亦称作对数损失,logloss),adam是一种优化器,class_mode表示分类模式 model.compile(loss='categorical_crossentropy', optimizer='sgd') # 正式运行该模型,我知道为什么了,因为没有补0!!每个array的长度是不一样的,因此才会报错 X = np.array(list(trainData)) # 输入数据 print("X:", X) Y = np.array(list(trainMark)) # 标签 print("Y:", Y) # batch_size:整数,指定进行梯度下降时每个batch包含的样本数 # nb_epoch:整数,训练的轮数,训练数据将会被遍历nb_epoch次 model.fit(X, Y, batch_size=200, nb_epoch=10) # 该函数的X、Y应该是多个输入:numpy list(其中每个元素为numpy.array),单个输入:numpy.array # 进行预测 A = np.array(list(testData)) # 输入数据 print("A:", A) classes = model.predict(A) # 这个是预测的数据 return classes
def dnn_class(X_train,y_train,X_test,y_test): model=Sequential() model.add(Dense(1000,input_dim=1583,kernel_initializer="glorot_uniform",activation="relu")) model.add(BatchNormalization()) model.add(Dense(1000,kernel_initializer="glorot_uniform",activation="relu")) model.add(BatchNormalization()) # ============================================================================= # model.add(Dropout(0.6)) # ============================================================================= model.add(Dense(1,activation="sigmoid",kernel_initializer="glorot_uniform")) adam=Adam(lr=0.01) # model.add(Dense(units=1,activation="relu",kernel_initializer="glorot_uniform")) sgd=SGD(lr=0.01, momentum=0.01, decay=0.0, nesterov=True) rms=RMSprop(lr=0.005) model.compile(optimizer=adam,loss="binary_crossentropy",metrics=["accuracy"]) callbacks=[EarlyStopping(monitor='val_loss', patience=2), ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True)] print(model.summary()) model.fit(X_train,y_train,batch_size=4,epochs=50,verbose=1,callbacks=callbacks,validation_data=(X_test,y_test)) pkl_filename = "keras_model.joblib" with open(pkl_filename, 'wb') as file: joblib.dump(model, file) y_pred=model.predict_classes(X_test) print(y_pred) evaluation2(y_test,y_pred,model,X_test,X_train,y_train)