def build_partial_cnn1(img_rows, img_cols): model = Sequential() #model.add(Convolution2D(nb_filter=100, nb_row=5, nb_col=5, model.add(Convolution2D(nb_filter=10, nb_row=2, nb_col=2, init='glorot_uniform', activation='linear', border_mode='valid', input_shape=(1, img_rows, img_cols))) model.add(Activation('relu')) #model.add(MaxPooling2D(pool_size=(2, 2))) #model.add(Convolution2D(nb_filter=100, nb_row=5, nb_col=5, '''model.add(Convolution2D(nb_filter=512, nb_row=5, nb_col=5, init='glorot_uniform', activation='linear', border_mode='valid')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) #model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(256)) model.add(Activation('relu')) model.add(Dropout(0.5))''' return model
def create(self): language_model = Sequential() self.textual_embedding(language_model, mask_zero=True) self.temporal_pooling(language_model) language_model.add(DropMask()) #language_model.add(BatchNormalization(mode=1)) self.language_model = language_model visual_model_factory = \ select_sequential_visual_model[self._config.trainable_perception_name]( self._config.visual_dim) visual_model = visual_model_factory.create() visual_dimensionality = visual_model_factory.get_dimensionality() self.visual_embedding(visual_model, visual_dimensionality) #visual_model.add(BatchNormalization(mode=1)) self.visual_model = visual_model if self._config.multimodal_merge_mode == 'dot': self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)])) else: self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode)) self.deep_mlp() self.add(Dense(self._config.output_dim)) self.add(Activation('softmax'))
def create(self): language_model = Sequential() self.textual_embedding(language_model, mask_zero=True) self.stacked_RNN(language_model) language_model.add(self._config.recurrent_encoder( self._config.hidden_state_dim, return_sequences=False, go_backwards=self._config.go_backwards)) self.language_model = language_model visual_model_factory = \ select_sequential_visual_model[self._config.trainable_perception_name]( self._config.visual_dim) visual_model = visual_model_factory.create() visual_dimensionality = visual_model_factory.get_dimensionality() self.visual_embedding(visual_model, visual_dimensionality) #visual_model = Sequential() #self.visual_embedding(visual_model) self.visual_model = visual_model if self._config.multimodal_merge_mode == 'dot': self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)])) else: self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode)) self.add(Dropout(0.5)) self.add(Dense(self._config.output_dim)) self.add(RepeatVector(self._config.max_output_time_steps)) self.add(self._config.recurrent_decoder( self._config.hidden_state_dim, return_sequences=True)) self.add(Dropout(0.5)) self.add(TimeDistributedDense(self._config.output_dim)) self.add(Activation('softmax'))
def define_model(lr, momentum): # CONFIG model = Sequential() # Create Layers # CONVNET layers = [] #layers.append(GaussianNoise(0.02)) layers.append(Convolution2D(8, 9, 9, activation = "relu", input_shape=(1,100,100))) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(16, 7, 7, activation = "relu")) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(32, 5, 5, activation = "relu")) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(64, 3, 3, activation = "relu")) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(250, 3, 3, activation= "relu")) # MLP layers.append(Flatten()) layers.append(Dense(125, activation="relu")) layers.append(Dense(2, activation="softmax")) # Adding Layers for layer in layers: model.add(layer) # COMPILE (learning rate, momentum, objective...) sgd = SGD(lr=lr, momentum=momentum) model.compile(loss="categorical_crossentropy", optimizer=sgd) return model
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()
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 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_img_clf(self): print('image classification data:') (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=1000, nb_test=200, input_shape=(3, 8, 8), classification=True, nb_class=2) print('X_train:', X_train.shape) print('X_test:', X_test.shape) print('y_train:', y_train.shape) print('y_test:', y_test.shape) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(Convolution2D(8, 8, 8, input_shape=(3, 8, 8))) model.add(Activation('sigmoid')) model.add(Flatten()) model.add(Dense(y_test.shape[-1])) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd') history = model.fit(X_train, y_train, nb_epoch=12, batch_size=16, validation_data=(X_test, y_test), show_accuracy=True, verbose=0) print(history.history['val_acc'][-1]) self.assertTrue(history.history['val_acc'][-1] > 0.9)
def __init__(self): model = Sequential() model.add(Embedding(115227, 50, input_length=75, weights=pre_weights)) model.compile(loss=MCE, optimizer="adadelta") print "Build Network Completed..." self.model = model self.vocab = {"get_index":{}, "get_word":[]}
def test_multiprocessing_predict_error(): batch_size = 32 good_batches = 5 def myGenerator(): """Raises an exception after a few good batches""" for i in range(good_batches): yield (np.random.randint(batch_size, 256, (500, 2)), np.random.randint(batch_size, 2, 500)) raise RuntimeError model = Sequential() model.add(Dense(1, input_shape=(2, ))) model.compile(loss='mse', optimizer='adadelta') samples = batch_size * (good_batches + 1) with pytest.raises(Exception): model.predict_generator( myGenerator(), samples, 1, nb_worker=4, pickle_safe=True, ) with pytest.raises(Exception): model.predict_generator( myGenerator(), samples, 1, pickle_safe=False, )
def test_simple_keras_udf(self): """ Simple Keras sequential model """ # Notice that the input layer for a image UDF model # must be of shape (width, height, numChannels) # The leading batch size is taken care of by Keras with IsolatedSession(using_keras=True) as issn: model = Sequential() model.add(Flatten(input_shape=(640,480,3))) model.add(Dense(units=64)) model.add(Activation('relu')) model.add(Dense(units=10)) model.add(Activation('softmax')) # Initialize the variables init_op = tf.global_variables_initializer() issn.run(init_op) makeGraphUDF(issn.graph, 'my_keras_model_udf', model.outputs, {tfx.op_name(issn.graph, model.inputs[0]): 'image_col'}) # Run the training procedure # Export the graph in this IsolatedSession as a GraphFunction # gfn = issn.asGraphFunction(model.inputs, model.outputs) fh_name = "test_keras_simple_sequential_model" registerKerasImageUDF(fh_name, model) self._assert_function_exists(fh_name)
def test_multiprocessing_predicting(): reached_end = False arr_data = np.random.randint(0, 256, (500, 2)) def myGenerator(): batch_size = 32 n_samples = 500 while True: batch_index = np.random.randint(0, n_samples - batch_size) start = batch_index end = start + batch_size X = arr_data[start: end] yield X # Build a NN model = Sequential() model.add(Dense(1, input_shape=(2, ))) model.compile(loss='mse', optimizer='adadelta') model.predict_generator(myGenerator(), val_samples=320, max_q_size=10, nb_worker=2, pickle_safe=True) model.predict_generator(myGenerator(), val_samples=320, max_q_size=10, pickle_safe=False) reached_end = True assert reached_end
def ae(data, feature_dim, train, test, learning_rate, lr_decay, reg_fn, l, momentum, evaluation): ''' Autoencoder ''' batch_size=len(train) data_dim = data.shape[1] model = single_layer_autoencoder(data_dim, feature_dim, reg_fn(l), learning_rate, lr_decay, momentum) model.fit(data[train], data[train], batch_size=batch_size, nb_epoch=nb_epoch, verbose=verbose) output = model.predict(data) # Reconstruction model_rec = Sequential() model_rec.add(Dense(data_dim, input_dim=feature_dim, activation=activation, weights=model.layers[0].decoder.get_weights()[0:2])) model_rec.layers[0].get_input(False) # Get input from testing data model_rec.compile(loss='mse', optimizer='sgd') if evaluation: data_rec = model_rec.predict(output[test]) loss = mean_squared_error(data[test], data_rec) return loss name = 'Autoencoder' return output, name, model_rec.predict
class MLP(BaseEstimator): def __init__(self, verbose=0, model=None, final_activation='sigmoid'): self.verbose = verbose self.model = model self.final_activation = final_activation def fit(self, X, y): if not self.model: self.model = Sequential() self.model.add(Dense(1000, input_dim=X.shape[1])) self.model.add(Activation('relu')) self.model.add(Dropout(0.5)) self.model.add(Dense(y.shape[1])) self.model.add(Activation(self.final_activation)) self.model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.01)) self.model.fit_generator(generator=_batch_generator(X, y, 256, True), samples_per_epoch=X.shape[0], nb_epoch=20, verbose=self.verbose) def predict(self, X): pred = self.predict_proba(X) return sparse.csr_matrix(pred > 0.2) def predict_proba(self, X): pred = self.model.predict_generator(generator=_batch_generatorp(X, 512), val_samples=X.shape[0]) return pred
def getVggModel(): """Pretrained VGG16 model with fine-tunable last two layers""" input_image = Input(shape = (160,320,3)) model = Sequential() model.add(Lambda(lambda x: x/255.0 -0.5,input_shape=(160,320,3))) model.add(Cropping2D(cropping=((70,25),(0,0)))) base_model = VGG16(input_tensor=input_image, include_top=False) for layer in base_model.layers[:-3]: layer.trainable = False W_regularizer = l2(0.01) x = base_model.get_layer("block5_conv3").output x = AveragePooling2D((2, 2))(x) x = Dropout(0.5)(x) x = BatchNormalization()(x) x = Dropout(0.5)(x) x = Flatten()(x) x = Dense(4096, activation="elu", W_regularizer=l2(0.01))(x) x = Dropout(0.5)(x) x = Dense(2048, activation="elu", W_regularizer=l2(0.01))(x) x = Dense(2048, activation="elu", W_regularizer=l2(0.01))(x) x = Dense(1, activation="linear")(x) return Model(input=input_image, output=x)
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 baseline_model(): model = Sequential() model.add(Dense(4, input_dim=4, init='normal', activation='relu')) model.add(Dense(3, init='normal', activation='sigmoid')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def Simple(layers, func, ipt): model = Sequential() #model.add(BatchNormalization(input_shape = [ipt])) model.add(Dense(layers[0], input_dim = ipt, activation = func[0])) for i in range(1, len(layers)): model.add(Dense(layers[i], activation = func[i])) return model
def test_sequential_model_saving(): model = Sequential() model.add(Dense(2, input_dim=3)) model.add(Dense(3)) model.compile(loss='mse', optimizer='rmsprop', metrics=['acc']) x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) out = model.predict(x) fname = 'tmp_' + str(np.random.randint(10000)) + '.h5' save_model(model, fname) new_model = load_model(fname) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05) # test that new updates are the same with both models x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) new_model.train_on_batch(x, y) out = model.predict(x) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05) # test load_weights on model file model.load_weights(fname) os.remove(fname)
def make_model(self): model = Sequential() model.add(Dense(units=200,input_shape=(6400,), activation="relu")) model.add(Dense(6, activation="softmax")) model.compile(loss='sparse_categorical_crossentropy', optimizer=RMSprop(lr=0.01)) self.model = model
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)
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 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 make_fc_model(self): ''' creates a fully convolutional model from self.model ''' # get index of first dense layer in model behead_ix = self._get_behead_index(self.model_layer_names) model_layers = self.model.layers[:behead_ix] # shape of image entering FC layers inp_shape = self.model.layers[behead_ix - 1].get_output_shape_at(-1) # replace dense layers with convolutions model = Sequential() model_layers += [Convolution2D(2048, 1, 1)] model_layers += [Activation('relu')] model_layers += [Convolution2D(2048, 1, 1)] model_layers += [Activation('relu')] model_layers += [Convolution2D(self.nb_classes, inp_shape[-1], inp_shape[-1])] # must be same shape as target vector (None, num_classes, 1) model_layers += [Reshape((self.nb_classes-1,1))] model_layers += [Activation('softmax')] print 'Compiling Fully Convolutional Model...' for process in model_layers: model.add(process) sgd = SGD(lr=self.lr_1, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer='sgd') print 'Done.' return model
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 __init__(self, restore=None, session=None, Dropout=Dropout, num_labels=10): self.num_channels = 1 self.image_size = 28 self.num_labels = num_labels model = Sequential() nb_filters = 64 layers = [Conv2D(nb_filters, (5, 5), strides=(2, 2), padding="same", input_shape=(28, 28, 1)), Activation('relu'), Conv2D(nb_filters, (3, 3), strides=(2, 2), padding="valid"), Activation('relu'), Conv2D(nb_filters, (3, 3), strides=(1, 1), padding="valid"), Activation('relu'), Flatten(), Dense(32), Activation('relu'), Dropout(.5), Dense(num_labels)] for layer in layers: model.add(layer) if restore != None: model.load_weights(restore) self.model = model
def create(self): language_model = Sequential() self.textual_embedding(language_model, mask_zero=True) self.language_model = language_model visual_model_factory = \ select_sequential_visual_model[self._config.trainable_perception_name]( self._config.visual_dim) visual_model = visual_model_factory.create() visual_dimensionality = visual_model_factory.get_dimensionality() self.visual_embedding(visual_model, visual_dimensionality) #visual_model = Sequential() #self.visual_embedding(visual_model) # the below should contain all zeros zero_model = Sequential() zero_model.add(RepeatVector(self._config.max_input_time_steps)-1) visual_model.add(Merge[visual_model, zero_model], mode='concat') self.visual_model = visual_model if self._config.multimodal_merge_mode == 'dot': self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)])) else: self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode)) self.add(self._config.recurrent_encoder( self._config.hidden_state_dim, return_sequences=False, go_backwards=self._config.go_backwards)) self.deep_mlp() self.add(Dense(self._config.output_dim)) self.add(Activation('softmax'))
def test_sequential_fit_generator(): (x_train, y_train), (x_test, y_test) = _get_test_data() def data_generator(train): if train: max_batch_index = len(x_train) // batch_size else: max_batch_index = len(x_test) // batch_size i = 0 while 1: if train: yield (x_train[i * batch_size: (i + 1) * batch_size], y_train[i * batch_size: (i + 1) * batch_size]) else: yield (x_test[i * batch_size: (i + 1) * batch_size], y_test[i * batch_size: (i + 1) * batch_size]) i += 1 i = i % max_batch_index model = Sequential() model.add(Dense(num_hidden, input_shape=(input_dim,))) model.add(Activation('relu')) model.add(Dense(num_class)) model.pop() model.add(Dense(num_class)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit_generator(data_generator(True), 5, epochs) model.fit_generator(data_generator(True), 5, epochs, validation_data=(x_test, y_test)) model.fit_generator(data_generator(True), 5, epochs, validation_data=data_generator(False), validation_steps=3) model.fit_generator(data_generator(True), 5, epochs, max_queue_size=2) model.evaluate(x_train, y_train)
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 get_nn_model(token_dict_size): _logger.info('Initializing NN model with the following params:') _logger.info('Input dimension: %s (token vector size)' % TOKEN_REPRESENTATION_SIZE) _logger.info('Hidden dimension: %s' % HIDDEN_LAYER_DIMENSION) _logger.info('Output dimension: %s (token dict size)' % token_dict_size) _logger.info('Input seq length: %s ' % INPUT_SEQUENCE_LENGTH) _logger.info('Output seq length: %s ' % ANSWER_MAX_TOKEN_LENGTH) _logger.info('Batch size: %s' % SAMPLES_BATCH_SIZE) model = Sequential() seq2seq = SimpleSeq2seq( input_dim=TOKEN_REPRESENTATION_SIZE, input_length=INPUT_SEQUENCE_LENGTH, hidden_dim=HIDDEN_LAYER_DIMENSION, output_dim=token_dict_size, output_length=ANSWER_MAX_TOKEN_LENGTH, depth=1 ) model.add(seq2seq) model.compile(loss='mse', optimizer='rmsprop') model.save_weights(NN_MODEL_PATH) # use previously saved model if it exists _logger.info('Looking for a model %s' % NN_MODEL_PATH) if os.path.isfile(NN_MODEL_PATH): _logger.info('Loading previously calculated weights...') model.load_weights(NN_MODEL_PATH) _logger.info('Model is built') return model