我们从Python开源项目中，提取了以下37个代码示例，用于说明如何使用keras.models.Graph()。
def get_graph(num_users, num_items, latent_dim): model = Graph() model.add_input(name='user_input', input_shape=(num_users,)) model.add_input(name='positive_item_input', input_shape=(num_items,)) model.add_input(name='negative_item_input', input_shape=(num_items,)) model.add_node(layer=Dense(latent_dim, input_shape = (num_users,)), name='user_latent', input='user_input') model.add_shared_node(layer=Dense(latent_dim, input_shape = (num_items,)), name='item_latent', inputs=['positive_item_input', 'negative_item_input'], merge_mode=None, outputs=['positive_item_latent', 'negative_item_latent']) model.add_node(layer=Activation('linear'), name='user_pos', inputs=['user_latent', 'positive_item_latent'], merge_mode='dot', dot_axes=1) model.add_node(layer=Activation('linear'), name='user_neg', inputs=['user_latent', 'negative_item_latent'], merge_mode='dot', dot_axes=1) model.add_output(name='triplet_loss_out', inputs=['user_pos', 'user_neg']) model.compile(loss={'triplet_loss_out': ranking_loss}, optimizer=Adam())#Adagrad(lr=0.1, epsilon=1e-06)) return model
def test_1o_1i(self): print('test a non-sequential graph with 1 input and 1 output') graph = Graph() graph.add_input(name='input1', ndim=2) graph.add_node(Dense(32, 16), name='dense1', input='input1') graph.add_node(Dense(32, 4), name='dense2', input='input1') graph.add_node(Dense(16, 4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') graph.compile('rmsprop', {'output1':'mse'}) history = graph.fit({'input1':X_train, 'output1':y_train}, nb_epoch=10) out = graph.predict({'input1':X_test}) assert(type(out == dict)) assert(len(out) == 1) loss = graph.test_on_batch({'input1':X_test, 'output1':y_test}) loss = graph.train_on_batch({'input1':X_test, 'output1':y_test}) loss = graph.evaluate({'input1':X_test, 'output1':y_test}) print(loss) assert(loss < 1.4)
def test_1o_1i_2(self): print('test a more complex non-sequential graph with 1 input and 1 output') graph = Graph() graph.add_input(name='input1', ndim=2) graph.add_node(Dense(32, 16), name='dense1', input='input1') graph.add_node(Dense(32, 4), name='dense2-0', input='input1') graph.add_node(Activation('relu'), name='dense2', input='dense2-0') graph.add_node(Dense(4, 16), name='dense3', input='dense2') graph.add_node(Dense(16, 4), name='dense4', inputs=['dense1', 'dense3'], merge_mode='sum') graph.add_output(name='output1', inputs=['dense2', 'dense4'], merge_mode='sum') graph.compile('rmsprop', {'output1':'mse'}) history = graph.fit({'input1':X_train, 'output1':y_train}, nb_epoch=10) out = graph.predict({'input1':X_train}) assert(type(out == dict)) assert(len(out) == 1) loss = graph.test_on_batch({'input1':X_test, 'output1':y_test}) loss = graph.train_on_batch({'input1':X_test, 'output1':y_test}) loss = graph.evaluate({'input1':X_test, 'output1':y_test}) print(loss) assert(loss < 1.4) graph.get_config(verbose=1)
def test_1o_2i(self): print('test a non-sequential graph with 2 inputs and 1 output') graph = Graph() graph.add_input(name='input1', ndim=2) graph.add_input(name='input2', ndim=2) graph.add_node(Dense(32, 16), name='dense1', input='input1') graph.add_node(Dense(32, 4), name='dense2', input='input2') graph.add_node(Dense(16, 4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') graph.compile('rmsprop', {'output1':'mse'}) history = graph.fit({'input1':X_train, 'input2':X2_train, 'output1':y_train}, nb_epoch=10) out = graph.predict({'input1':X_test, 'input2':X2_test}) assert(type(out == dict)) assert(len(out) == 1) loss = graph.test_on_batch({'input1':X_test, 'input2':X2_test, 'output1':y_test}) loss = graph.train_on_batch({'input1':X_test, 'input2':X2_test, 'output1':y_test}) loss = graph.evaluate({'input1':X_test, 'input2':X2_test, 'output1':y_test}) print(loss) assert(loss < 1.4) graph.get_config(verbose=1)
def test_recursive(self): print('test layer-like API') graph = containers.Graph() graph.add_input(name='input1', ndim=2) graph.add_node(Dense(32, 16), name='dense1', input='input1') graph.add_node(Dense(32, 4), name='dense2', input='input1') graph.add_node(Dense(16, 4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') seq = Sequential() seq.add(Dense(32, 32, name='first_seq_dense')) seq.add(graph) seq.add(Dense(4, 4, name='last_seq_dense')) seq.compile('rmsprop', 'mse') history = seq.fit(X_train, y_train, batch_size=10, nb_epoch=10) loss = seq.evaluate(X_test, y_test) print(loss) assert(loss < 1.4) loss = seq.evaluate(X_test, y_test, show_accuracy=True) pred = seq.predict(X_test) seq.get_config(verbose=1)
def build_model(nb_filters=32, nb_pool=2, nb_conv=3): C_1 = 64 C_2 = 32 C_3 = 16 c = Convolution2D(C_1, nb_conv, nb_conv, border_mode='same', input_shape=(3, 32, 32)) mp = MaxPooling2D(pool_size=(nb_pool, nb_pool)) c2 = Convolution2D(C_2, nb_conv, nb_conv, border_mode='same', input_shape=(3, 32, 32)) mp2 = MaxPooling2D(pool_size=(nb_pool, nb_pool)) d = Dense(100) encoder = get_encoder(c, c2, d, mp, mp2) decoder = get_decoder(C_1, C_2, C_3, c, c2, d, mp, mp2, nb_pool) graph = Graph() graph.add_input(name='input', input_shape=(3, 32, 32)) graph.add_node(encoder, name='encoder', input='input') graph.add_node(decoder, name='decoder', input='encoder') graph.add_output(name='autoencoder_feedback', input='decoder') graph.compile('rmsprop', {'autoencoder_feedback': 'mean_squared_error'}) return graph
def face_valid_net(): #a graph model keras_model = Graph() #input 2268 dim #two input layer keras_model.add_input(name="input1", input_shape=(2622,)) keras_model.add_input(name="input2", input_shape=(2622,)) #two dense layer keras_model.add_node(layer=Dense(1000, activation='relu'), name='dense1', input='input1') keras_model.add_node(layer=Dense(1000, activation='relu'), name='dense2', input='input2') #concat layer keras_model.add_node(layer=Dense(200, activation='relu'),name='dense3', inputs=['dense1', 'dense2'], merge_mode='concat') #sotmax keras_model.add_node(layer=Dense(1, activation='sigmoid'), name='dense4', input='dense3') keras_model.add_output('output', input='dense4') #add soft max or min_max or maxpooling keras_model.compile('adadelta', {'output': 'mean_squared_error'}) return keras_model #history = keras_model.fit({'input1':X_train, 'input2':X2_train, 'output':y_train}, nb_epoch=10) #predictions = graph.predict({'input1':X_test, 'input2':X2_test}) # {'output':...}
def test_1o_1i(self): print('test a non-sequential graph with 1 input and 1 output') graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') graph.compile('rmsprop', {'output1': 'mse'}) history = graph.fit({'input1': X_train, 'output1': y_train}, nb_epoch=10) out = graph.predict({'input1': X_test}) assert(type(out == dict)) assert(len(out) == 1) loss = graph.test_on_batch({'input1': X_test, 'output1': y_test}) loss = graph.train_on_batch({'input1': X_test, 'output1': y_test}) loss = graph.evaluate({'input1': X_test, 'output1': y_test}) print(loss) assert(loss < 2.5)
def test_1o_1i_2(self): print('test a more complex non-sequential graph with 1 input and 1 output') graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2-0', input='input1') graph.add_node(Activation('relu'), name='dense2', input='dense2-0') graph.add_node(Dense(16), name='dense3', input='dense2') graph.add_node(Dense(4), name='dense4', inputs=['dense1', 'dense3'], merge_mode='sum') graph.add_output(name='output1', inputs=['dense2', 'dense4'], merge_mode='sum') graph.compile('rmsprop', {'output1': 'mse'}) history = graph.fit({'input1': X_train, 'output1': y_train}, nb_epoch=10) out = graph.predict({'input1': X_train}) assert(type(out == dict)) assert(len(out) == 1) loss = graph.test_on_batch({'input1': X_test, 'output1': y_test}) loss = graph.train_on_batch({'input1': X_test, 'output1': y_test}) loss = graph.evaluate({'input1': X_test, 'output1': y_test}) print(loss) assert(loss < 2.5) graph.get_config(verbose=1)
def test_1o_2i(self): print('test a non-sequential graph with 2 inputs and 1 output') graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_input(name='input2', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input2') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') graph.compile('rmsprop', {'output1': 'mse'}) history = graph.fit({'input1': X_train, 'input2': X2_train, 'output1': y_train}, nb_epoch=10) out = graph.predict({'input1': X_test, 'input2': X2_test}) assert(type(out == dict)) assert(len(out) == 1) loss = graph.test_on_batch({'input1': X_test, 'input2': X2_test, 'output1': y_test}) loss = graph.train_on_batch({'input1': X_test, 'input2': X2_test, 'output1': y_test}) loss = graph.evaluate({'input1': X_test, 'input2': X2_test, 'output1': y_test}) print(loss) assert(loss < 3.0) graph.get_config(verbose=1)
def test_recursive(self): print('test layer-like API') graph = containers.Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') seq = Sequential() seq.add(Dense(32, input_shape=(32,))) seq.add(graph) seq.add(Dense(4)) seq.compile('rmsprop', 'mse') history = seq.fit(X_train, y_train, batch_size=10, nb_epoch=10) loss = seq.evaluate(X_test, y_test) print(loss) assert(loss < 2.5) loss = seq.evaluate(X_test, y_test, show_accuracy=True) pred = seq.predict(X_test) seq.get_config(verbose=1)
def test_create_output(self): print('test create_output argument') graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_node(Dense(4), name='output1', inputs=['dense2', 'dense3'], merge_mode='sum', create_output=True) graph.compile('rmsprop', {'output1': 'mse'}) history = graph.fit({'input1': X_train, 'output1': y_train}, nb_epoch=10) out = graph.predict({'input1': X_test}) assert(type(out == dict)) assert(len(out) == 1) loss = graph.test_on_batch({'input1': X_test, 'output1': y_test}) loss = graph.train_on_batch({'input1': X_test, 'output1': y_test}) loss = graph.evaluate({'input1': X_test, 'output1': y_test}) print(loss) assert(loss < 2.5)
def get_static_model(model_props, anaphoricity=False): if model_props.static_layers == 0: return None graph = Graph() graph.add_input(name='X', input_shape=(model_props.single_size if anaphoricity else model_props.pair_size,)) graph.add_node(Dense(1000, activation='relu'), name='h1', input='X') graph.add_node(Dropout(0.5), name='h1drop', input='h1') if model_props.static_layers > 1: graph.add_node(Dense(500, activation='relu'), name='h2', input='h1drop') graph.add_node(Dropout(0.5), name='h2drop', input='h2') if model_props.static_layers > 2: graph.add_node(Dense(500, activation='relu'), name='h3', input='h2drop') graph.add_node(Dropout(0.5), name='h3drop', input='h3') graph.add_output('out', input='h' + str(min(model_props.top_layers, model_props.static_layers)) + 'drop') print "Compiling {:} model".format("anaphoricity" if anaphoricity else "pair") graph.compile(loss={'out': 'mse'}, optimizer=SGD()) return graph
def get_model(model_props): graph = Graph() graph.add_input(name='pair_features', input_shape=(model_props.pair_input_size,)) graph.add_input(name='mention_features', input_shape=(model_props.anaphoricity_input_size,)) graph.add_input(name='starts', input_shape=(1,), dtype='int32') graph.add_input(name='ends', input_shape=(1,), dtype='int32') anaphoricity_repr = add_model(graph, 'anaphoricity', 'mention_features', model_props) graph.add_node(Dense(1), name='anaphoricity_score', input=anaphoricity_repr) graph.add_node(Dense(1), name='scaled_anaphoricity_score', input='anaphoricity_score') pair_repr = add_model(graph, '', 'pair_features', model_props) graph.add_node(Identity(), name='cluster_reprs', inputs=[pair_repr, 'starts', 'ends'], merge_mode='i' + model_props.pooling) graph.add_node(Dense(1), name='merge_scores', input='cluster_reprs') graph.add_node(Dense(1), name='scaled_merge_scores', input='merge_scores') graph.add_node(Identity(), name='action_scores', inputs=['scaled_merge_scores', 'scaled_anaphoricity_score'], concat_axis=0) graph.add_output(name='costs', input='action_scores') opt = Adam(lr=model_props.learning_rate, beta_1=0.9, beta_2=0.99, epsilon=1e-6) print "Compiling clustering model" graph.compile(loss={'costs': risk if model_props.risk_objective else max_margin}, optimizer=opt) return graph, opt
def build_keras_model_sg(index_size,vector_size, context_size, #code_dim, sub_batch_size=256, learn_vectors=True,learn_hidden=True, model=None): kerasmodel = Graph() kerasmodel.add_input(name='point' , input_shape=(1,), dtype=int) kerasmodel.add_input(name='index' , input_shape=(1,), dtype=int) kerasmodel.add_node(Embedding(index_size, vector_size, input_length=sub_batch_size,weights=[model.syn0]),name='embedding', input='index') kerasmodel.add_node(Embedding(context_size, vector_size, input_length=sub_batch_size,weights=[model.keras_syn1]),name='embedpoint', input='point') kerasmodel.add_node(Lambda(lambda x:x.sum(2)) , name='merge',inputs=['embedding','embedpoint'], merge_mode='mul') kerasmodel.add_node(Activation('sigmoid'), name='sigmoid', input='merge') kerasmodel.add_output(name='code',input='sigmoid') kerasmodel.compile('rmsprop', {'code':'mse'}) return kerasmodel
def build_keras_model_cbow(index_size,vector_size, context_size, #code_dim, sub_batch_size=1, model=None,cbow_mean=False): kerasmodel = Graph() kerasmodel.add_input(name='point' , input_shape=(sub_batch_size,), dtype='int') kerasmodel.add_input(name='index' , input_shape=(1,), dtype='int') kerasmodel.add_node(Embedding(index_size, vector_size, weights=[model.syn0]),name='embedding', input='index') kerasmodel.add_node(Embedding(context_size, vector_size, input_length=sub_batch_size,weights=[model.keras_syn1]),name='embedpoint', input='point') if cbow_mean: kerasmodel.add_node(Lambda(lambda x:x.mean(1),output_shape=(vector_size,)),name='average',input='embedding') else: kerasmodel.add_node(Lambda(lambda x:x.sum(1),output_shape=(vector_size,)),name='average',input='embedding') kerasmodel.add_node(Activation('sigmoid'), name='sigmoid',inputs=['average','embedpoint'], merge_mode='dot',dot_axes=-1) kerasmodel.add_output(name='code',input='sigmoid') kerasmodel.compile('rmsprop', {'code':'mse'}) return kerasmodel
def fit_model(self, X, Y, use_attention, att_context, bidirectional): print >>sys.stderr, "Input shape:", X.shape, Y.shape early_stopping = EarlyStopping(patience = 2) num_classes = len(self.label_ind) if bidirectional: tagger = Graph() tagger.add_input(name='input', input_shape=X.shape[1:]) if use_attention: tagger.add_node(TensorAttention(X.shape[1:], context=att_context), name='attention', input='input') lstm_input_node = 'attention' else: lstm_input_node = 'input' tagger.add_node(LSTM(X.shape[-1]/2, return_sequences=True), name='forward', input=lstm_input_node) tagger.add_node(LSTM(X.shape[-1]/2, return_sequences=True, go_backwards=True), name='backward', input=lstm_input_node) tagger.add_node(TimeDistributedDense(num_classes, activation='softmax'), name='softmax', inputs=['forward', 'backward'], merge_mode='concat', concat_axis=-1) tagger.add_output(name='output', input='softmax') tagger.summary() tagger.compile('adam', {'output':'categorical_crossentropy'}) tagger.fit({'input':X, 'output':Y}, validation_split=0.1, callbacks=[early_stopping], show_accuracy=True, nb_epoch=100, batch_size=10) else: tagger = Sequential() word_proj_dim = 50 if use_attention: _, input_len, timesteps, input_dim = X.shape tagger.add(HigherOrderTimeDistributedDense(input_dim=input_dim, output_dim=word_proj_dim)) att_input_shape = (input_len, timesteps, word_proj_dim) print >>sys.stderr, "Attention input shape:", att_input_shape tagger.add(Dropout(0.5)) tagger.add(TensorAttention(att_input_shape, context=att_context)) else: _, input_len, input_dim = X.shape tagger.add(TimeDistributedDense(input_dim=input_dim, input_length=input_len, output_dim=word_proj_dim)) tagger.add(LSTM(input_dim=word_proj_dim, output_dim=word_proj_dim, input_length=input_len, return_sequences=True)) tagger.add(TimeDistributedDense(num_classes, activation='softmax')) tagger.summary() tagger.compile(loss='categorical_crossentropy', optimizer='adam') tagger.fit(X, Y, validation_split=0.1, callbacks=[early_stopping], show_accuracy=True, batch_size=10) return tagger
def test_2o_1i_weights(self): print('test a non-sequential graph with 1 input and 2 outputs') graph = Graph() graph.add_input(name='input1', ndim=2) graph.add_node(Dense(32, 16), name='dense1', input='input1') graph.add_node(Dense(32, 4), name='dense2', input='input1') graph.add_node(Dense(16, 1), name='dense3', input='dense1') graph.add_output(name='output1', input='dense2') graph.add_output(name='output2', input='dense3') graph.compile('rmsprop', {'output1':'mse', 'output2':'mse'}) history = graph.fit({'input1':X_train, 'output1':y_train, 'output2':y2_train}, nb_epoch=10) out = graph.predict({'input1':X_test}) assert(type(out == dict)) assert(len(out) == 2) loss = graph.test_on_batch({'input1':X_test, 'output1':y_test, 'output2':y2_test}) loss = graph.train_on_batch({'input1':X_test, 'output1':y_test, 'output2':y2_test}) loss = graph.evaluate({'input1':X_test, 'output1':y_test, 'output2':y2_test}) print(loss) assert(loss < 2.5) print('test weight saving') graph.save_weights('temp.h5', overwrite=True) graph = Graph() graph.add_input(name='input1', ndim=2) graph.add_node(Dense(32, 16), name='dense1', input='input1') graph.add_node(Dense(32, 4), name='dense2', input='input1') graph.add_node(Dense(16, 1), name='dense3', input='dense1') graph.add_output(name='output1', input='dense2') graph.add_output(name='output2', input='dense3') graph.compile('rmsprop', {'output1':'mse', 'output2':'mse'}) graph.load_weights('temp.h5') nloss = graph.evaluate({'input1':X_test, 'output1':y_test, 'output2':y2_test}) print(nloss) assert(loss == nloss)
def create_model(word_coding): """ Create the LSTM model :param word_coding: :return: """ model = Graph() model.add_input(name='input', input_shape=(sd_len, input_dim)) model.add_node(TimeDistributedDense(input_dim=input_dim, output_dim=lstm_hdim, input_length=sd_len), name=layerNames[0], input='input') model.add_node(BatchNormalization(), name=layerNames[1], input=layerNames[0]) model.add_node(LSTM(input_dim=lstm_hdim, output_dim=lstm_hdim, return_sequences=True), name=layerNames[2] + 'left', input=layerNames[1]) model.add_node(BatchNormalization(), name=layerNames[3] + 'left', input=layerNames[2] + 'left') model.add_node(LSTM(input_dim=lstm_hdim, output_dim=lstm_hdim, return_sequences=True, go_backwards=True), name=layerNames[2] + 'right', input=layerNames[1]) model.add_node(BatchNormalization(), name=layerNames[3] + 'right', input=layerNames[2] + 'right') model.add_node(LSTM(input_dim=lstm_hdim, output_dim=lstm_hdim, return_sequences=False), name=layerNames[6] + 'left', input=layerNames[3] + 'left') model.add_node(LSTM(input_dim=lstm_hdim, output_dim=lstm_hdim, return_sequences=False, go_backwards=True), name=layerNames[6] + 'right', input=layerNames[3] + 'right') model.add_node(BatchNormalization(), name=layerNames[7], inputs=[layerNames[6] + 'left', layerNames[6] + 'right']) model.add_node(Dropout(0.2), name=layerNames[8], input=layerNames[7]) model.add_node(Dense(input_dim=bridge_dim, output_dim=dense_dim), name=layerNames[9], input=layerNames[8]) model.add_node(ELU(), name=layerNames[10], input=layerNames[9]) model.add_node(Dropout(0.2), name=layerNames[11], input=layerNames[10]) model.add_node(Dense(input_dim=dense_dim, output_dim=len(word_coding)), name=layerNames[12], input=layerNames[11]) model.add_node(Activation('softmax'), name=layerNames[13], input=layerNames[12]) model.add_output(name='output1', input=layerNames[13]) model.compile(optimizer='rmsprop', loss={'output1': 'categorical_crossentropy'}) return model
def create_graph_model(): model = Graph() model.add_input(name='input', input_shape=(784,)) model.add_node(Dense(50, activation='relu'), name='d1', input='input') model.add_node(Dense(10, activation='softmax'), name='d2', input='d1') model.add_output(name='output', input='d2') return model
def test_2o_1i_weights(self): print('test a non-sequential graph with 1 input and 2 outputs') graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(1), name='dense3', input='dense1') graph.add_output(name='output1', input='dense2') graph.add_output(name='output2', input='dense3') graph.compile('rmsprop', {'output1': 'mse', 'output2': 'mse'}) history = graph.fit({'input1': X_train, 'output1': y_train, 'output2': y2_train}, nb_epoch=10) out = graph.predict({'input1': X_test}) assert(type(out == dict)) assert(len(out) == 2) loss = graph.test_on_batch({'input1': X_test, 'output1': y_test, 'output2': y2_test}) loss = graph.train_on_batch({'input1': X_test, 'output1': y_test, 'output2': y2_test}) loss = graph.evaluate({'input1': X_test, 'output1': y_test, 'output2': y2_test}) print(loss) assert(loss < 4.) print('test weight saving') graph.save_weights('temp.h5', overwrite=True) graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(1), name='dense3', input='dense1') graph.add_output(name='output1', input='dense2') graph.add_output(name='output2', input='dense3') graph.compile('rmsprop', {'output1': 'mse', 'output2': 'mse'}) graph.load_weights('temp.h5') nloss = graph.evaluate({'input1': X_test, 'output1': y_test, 'output2': y2_test}) print(nloss) assert(loss == nloss)
def test_count_params(self): print('test count params') nb_units = 100 nb_classes = 2 graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_input(name='input2', input_shape=(32,)) graph.add_node(Dense(nb_units), name='dense1', input='input1') graph.add_node(Dense(nb_classes), name='dense2', input='input2') graph.add_node(Dense(nb_classes), name='dense3', input='dense1') graph.add_output(name='output', inputs=['dense2', 'dense3'], merge_mode='sum') n = 32 * nb_units + nb_units n += 32 * nb_classes + nb_classes n += nb_units * nb_classes + nb_classes self.assertEqual(n, graph.count_params()) graph.compile('rmsprop', {'output': 'binary_crossentropy'}) self.assertEqual(n, graph.count_params())
def model_picture(model, to_file='local/model.png'): graph = pydot.Dot(graph_type='digraph') if isinstance(model,Sequential): previous_node = None written_nodes = [] n = 1 for node in model.get_config()['layers']: # append number in case layers have same name to differentiate if (node['name'] + str(n)) in written_nodes: n += 1 current_node = pydot.Node(node['name'] + str(n)) written_nodes.append(node['name'] + str(n)) graph.add_node(current_node) if previous_node: graph.add_edge(pydot.Edge(previous_node, current_node)) previous_node = current_node graph.write_png(to_file) elif isinstance(model,Graph): # don't need to append number for names since all nodes labeled for input_node in model.input_config: graph.add_node(pydot.Node(input_node['name'])) # intermediate and output nodes have input defined for layer_config in [model.node_config, model.output_config]: for node in layer_config: graph.add_node(pydot.Node(node['name'])) # possible to have multiple 'inputs' vs 1 'input' if node['inputs']: for e in node['inputs']: graph.add_edge(pydot.Edge(e, node['name'])) else: graph.add_edge(pydot.Edge(node['input'], node['name'])) graph.write_png(to_file)
def train_breaker(datafilename, sentence_num=1000, puncs=u',?.?!???', \ RNN=recurrent.GRU, HIDDEN_SIZE=128, EPOCH_SIZE=10, validate=True): wordtable = WordTable() wordtable.parse(datafilename, sentence_num) X, Y = [], [] for line in open(datafilename).readlines()[:sentence_num]: line = line.strip().decode('utf-8') line = re.sub(ur'(^[{0}]+)|([{0}]+$)'.format(puncs),'',line) words = wordtable.encode(re.sub(ur'[{0}]'.format(puncs),'',line)) breaks = re.sub(ur'0[{0}]+'.format(puncs),'1',re.sub(ur'[^{0}]'.format(puncs),'0',line)) if len(words) >= 30 and len(words) <= 50 and breaks.count('1') >= 4: x = np.zeros((len(words), wordtable.capacity), dtype=np.bool) y = np.zeros((len(breaks), 2), dtype=np.bool) for idx in xrange(len(words)): x[idx][words[idx]] = True y[idx][int(breaks[idx])] = True X.append(x) Y.append(y) print 'total sentence: ', len(X) if validate: # Set apart 10% for validation split_at = len(X) - len(X)/10 X_train, X_val = X[:split_at], X[split_at:] y_train, y_val = Y[:split_at], Y[split_at:] else: X_train, y_train = X, Y model = Graph() model.add_input(name='input', input_shape=(None, wordtable.capacity)) model.add_node(RNN(HIDDEN_SIZE, return_sequences=True), name='forward', input='input') model.add_node(TimeDistributedDense(2, activation='softmax'), name='softmax', input='forward') model.add_output(name='output', input='softmax') model.compile('adam', {'output': 'categorical_crossentropy'}) for epoch in xrange(EPOCH_SIZE): print "epoch: ", epoch for idx, (seq, label) in enumerate(zip(X_train, y_train)): loss, accuracy = model.train_on_batch({'input':np.array([seq]), 'output':np.array([label])}, accuracy=True) if idx % 20 == 0: print "\tidx={0}, loss={1}, accuracy={2}".format(idx, loss, accuracy) if validate: _Y, _P = [], [] for (seq, label) in zip(X_val, y_val): y = label.argmax(axis=-1) p = model.predict({'input':np.array([seq])})['output'][0].argmax(axis=-1) _Y.extend(list(y)) _P.extend(list(p)) _Y, _P = np.array(_Y), np.array(_P) print "should break right: ", ((_P == 1)*(_Y == 1)).sum() print "should break wrong: ", ((_P == 0)*(_Y == 1)).sum() print "should not break right: ", ((_P == 0)*(_Y == 0)).sum() print "should not break wrong: ", ((_P == 1)*(_Y == 0)).sum() with open('wordtable_json.txt','w') as wordtable_file: wordtable_file.write(wordtable.to_json()) with open('model_json.txt','w') as model_file: model_file.write(model.to_json()) model.save_weights('model_weights.h5', overwrite=True)
def __init__(self, embedding_mat=None, maxlen_doc=7, maxlen_sent=50, filter_length=[3, 4, 5, 6], nb_filters=200, n_vocab=10000, embedding_dims=300, hidden_gru=64, n_classes=5): if embedding_mat is not None: self.n_vocab, self.embedding_dims = embedding_mat.shape else: self.n_vocab = n_vocab self.embedding_dims = embedding_dims self.maxlen_doc = maxlen_doc self.maxlen_sent = maxlen_sent self.filter_length = filter_length self.nb_filters = nb_filters self.hidden_gru = hidden_gru print "Building the model" #graph model model=Graph() model.add_input(name='input', input_shape=(self.maxlen_doc*self.maxlen_sent,), dtype='int') #Model embedding layer, for word index-> word embedding transformation model.add_node(Embedding(self.n_vocab, self.embedding_dims, weights=[self.embedding_mat], input_length=self.maxlen_sent*self.maxlen_doc), name='embedding', input='input') model.add_node(Reshape((self.maxlen_doc, 1, self.maxlen_sent, self.embedding_dims)), name='reshape_5d', input='embedding') #define the different filters conv_layer = [] for each_length in filter_length: model.add_node(TimeDistributedConvolution2D(self.nb_filters/len(filter_length), each_length, self.embedding_dims, border_mode='valid', input_shape=(self.maxlen_doc,1,self.maxlen_sent, self.embedding_dims)), name='conv_{}'.format(each_length), input='reshape_5d') model.add_node(Activation('relu'), name='relu_conv_{}'.format(each_length), input='conv_{}'.format(each_length)) model.add_node(TimeDistributedMaxPooling2D(pool_size=(int(self.maxlen_sent - each_length+1), 1), border_mode='valid'), name='pool_conv_{}'.format(each_length), input='relu_conv_{}'.format(each_length)) model.add_node(TimeDistributedFlatten(), name='flatten_conv_{}'.format(each_length), input='pool_conv_{}'.format(each_length)) conv_layer.append('flatten_conv_{}'.format(each_length)) # model.add_node(Activation('relu'), name='relu', inputs=conv_layer) print conv_layer model.add_node(GRU(self.hidden_gru), name='gru_forward', inputs=conv_layer) model.add_node(GRU(self.hidden_gru, go_backwards=True), name='gru_backward', inputs=conv_layer) model.add_node(Dropout(0.5), name='gru_outputs', inputs=['gru_forward', 'gru_backward']) model.add_node(Dense(n_classes), name='full_con', input='gru_outputs') model.add_node(Activation('softmax'), name='prob', input='full_con') model.add_output(name='pred', input='prob') model.compile('rmsprop', loss = {'pred': 'categorical_crossentropy'})
def model(sequence_length=None): graph = Graph() graph.add_input(name='input', input_shape=(sequence_length, embedding_dim)) for fsz in filter_sizes: conv = Convolution1D(nb_filter=num_filters, filter_length=fsz, border_mode='valid', activation='relu', subsample_length=1, input_dim=embedding_dim, input_length=sequence_length) pool = MaxPooling1D(pool_length=sequence_length - fsz + 1) graph.add_node(conv, name='conv-%s' % fsz, input='input') graph.add_node(pool, name='maxpool-%s' % fsz, input='conv-%s' % fsz) graph.add_node( Flatten(), name='flatten-%s' % fsz, input='maxpool-%s' % fsz) if len(filter_sizes) > 1: graph.add_output(name='output', inputs=['flatten-%s' % fsz for fsz in filter_sizes], merge_mode='concat') else: graph.add_output(name='output', input='flatten-%s' % filter_sizes[0]) # main sequential model model = Sequential() model.add( Embedding( vocab_size, embedding_dim, input_length=sequence_length, weights=[embedding_weights])) model.add( Dropout( dropout_prob[0], input_shape=( sequence_length, embedding_dim))) model.add(graph) model.add(Dense(hidden_dims)) model.add(Dropout(dropout_prob[1])) model.add(Activation('relu')) return model # Input Layer with all the query, similar and non similar documents.
def model(sequence_length=None): graph = Graph() graph.add_input(name='input', input_shape=(sequence_length, embedding_dim)) for fsz in filter_sizes: conv = Convolution1D(nb_filter=num_filters, filter_length=fsz, border_mode='valid', activation='relu', subsample_length=1, input_dim=embedding_dim, input_length=sequence_length) pool = MaxPooling1D(pool_length=sequence_length - fsz + 1) graph.add_node(conv, name='conv-%s' % fsz, input='input') graph.add_node(pool, name='maxpool-%s' % fsz, input='conv-%s' % fsz) graph.add_node( Flatten(), name='flatten-%s' % fsz, input='maxpool-%s' % fsz) if len(filter_sizes) > 1: graph.add_output(name='output', inputs=['flatten-%s' % fsz for fsz in filter_sizes], merge_mode='concat') else: graph.add_output(name='output', input='flatten-%s' % filter_sizes[0]) # main sequential model model = Sequential() if conf.feature_level == "word": model.add( Embedding( vocab_size, embedding_dim, input_length=sequence_length, weights=[embedding_weights])) elif conf.feature_level == "char" or conf.feature_level == "ngram": model.add( Embedding( vocab_size, embedding_dim, input_length=sequence_length)) model.add( Dropout( dropout_prob[0], input_shape=( sequence_length, embedding_dim))) model.add(graph) model.add(Dense(hidden_dims)) # model.add(Dropout(dropout_prob[1])) model.add(Activation('relu')) return model # Input Layer with all the query, similar and non similar documents.
def model(sequence_length=None): graph = Graph() graph.add_input(name='input', input_shape=(sequence_length, embedding_dim)) for fsz in filter_sizes: conv = Convolution1D(nb_filter=num_filters, filter_length=fsz, border_mode='valid', activation='relu', subsample_length=1, input_dim=embedding_dim, input_length=sequence_length) pool = MaxPooling1D(pool_length=sequence_length - fsz + 1) graph.add_node(conv, name='conv-%s' % fsz, input='input') graph.add_node(pool, name='maxpool-%s' % fsz, input='conv-%s' % fsz) graph.add_node( Flatten(), name='flatten-%s' % fsz, input='maxpool-%s' % fsz) if len(filter_sizes) > 1: graph.add_output(name='output', inputs=['flatten-%s' % fsz for fsz in filter_sizes], merge_mode='concat') else: graph.add_output(name='output', input='flatten-%s' % filter_sizes[0]) # main sequential model model = Sequential() model.add( Embedding( vocab_size, embedding_dim, input_length=sequence_length, weights=[embedding_weights])) model.add( Dropout( dropout_prob[0], input_shape=( sequence_length, embedding_dim))) model.add(graph) model.add(Dense(hidden_dims)) # model.add(Dropout(dropout_prob[1])) model.add(Activation('relu')) return model # Input Layer with all the query, similar and non similar documents.
def _init_convolutional_NFQ(self): """Initialize a convolutional NFQ network. TODO: Allow customization of the network topology. """ # ConvNet to process the input image cnn = Sequential() cnn.add(Convolution2D(nb_filter=16, nb_row=8, nb_col=8, input_shape=(1, 64, 64), subsample=(4, 4))) cnn.add(Activation('relu')) cnn.add(Dropout(0.25)) cnn.add(Convolution2D(nb_filter=32, nb_row=4, nb_col=4, subsample=(2, 2))) cnn.add(Activation('relu')) cnn.add(Dropout(0.25)) cnn.add(Flatten()) # Combine the ConvNet output with the action to get the Q-value estimate graph = Graph() # State and action inputs graph.add_input(name='input_state', input_shape=self.state_dim) graph.add_input(name='input_action', input_shape=(self.nb_actions,)) graph.add_node(cnn, name='cnn', input='input_state') graph.add_node(Dense(256), name='nfq_dense_0', inputs=['cnn', 'input_action']) graph.add_node(Activation('relu'), name='nfq_activation_0', input='nfq_dense_0') graph.add_node(Dropout(0.25), name='nfq_dropout', input='nfq_dense_0') graph.add_node(Dense(1), name='nfq_output_dense', input='nfq_dropout') # Unscaled output graph.add_output(name='output_q_value', input='nfq_output_dense') graph.compile(loss={'output_q_value': 'mse'}, optimizer=RMSprop(lr=self.lr)) return graph
def build_keras_model_dbow(index_size,vector_size, #vocab_size, context_size, sub_batch_size=1, doctag_vectors=None, hidden_vectors=None, learn_doctags=True, learn_hidden=True, model=None, ): """ >>> index_size=3 >>> vector_size=2 >>> context_siz=3 >>> sub_batch_size=2 >>> doctag_vectors=np.array([[-1.1,2.2],[-3.2,-4.3],[-1.1,-1.4]],'float32') >>> hidden_vectors=np.array([[-1,2],[3,4],[5,6]],'float32') >>> kerasmodel=build_keras_model_dbow(index_size=3,vector_size=2,context_size=3,sub_batch_size=2,doctag_vectors=doctag_vectors,hidden_vectors=hidden_vectors) >>> ind=[[0,1],[1,0]] >>> ipt=[[0,1],[1,2]] >>> tmp1=kerasmodel.predict({'index':np.array(ind),'point':np.array(ipt)})['code'] >>> tmp2=np.array([np.sum(doctag_vectors[ind[i]]*hidden_vectors[ipt[i]], axis=1) for i in range(2)]) >>> np.linalg.norm(1/(1+np.exp(-tmp2))-tmp1) < 0.001 True """ kerasmodel = Graph() kerasmodel.add_input(name='point' , input_shape=(sub_batch_size,), dtype=int) kerasmodel.add_input(name='index' , input_shape=(sub_batch_size,), dtype=int) if hidden_vectors is None : kerasmodel.add_node(Embedding(context_size, vector_size, input_length=sub_batch_size, ),name='embedpoint', input='point') else: kerasmodel.add_node(Embedding(context_size, vector_size, input_length=sub_batch_size, weights=[hidden_vectors]),name='embedpoint', input='point') if doctag_vectors is None : kerasmodel.add_node(Embedding(index_size , vector_size, input_length=sub_batch_size, ),name='embedindex' , input='index') else: kerasmodel.add_node(Embedding(index_size , vector_size, input_length=sub_batch_size, weights=[doctag_vectors]),name='embedindex' , input='index') kerasmodel.add_node(Lambda(lambda x:x.sum(2)) , name='merge',inputs=['embedindex','embedpoint'], merge_mode='mul') kerasmodel.add_node(Activation('sigmoid'), name='sigmoid', input='merge') kerasmodel.add_output(name='code',input='sigmoid') kerasmodel.compile('rmsprop', {'code':'mse'}) return kerasmodel
def build_keras_model_dm(index_size,vector_size,vocab_size, context_size, maxwords, cbow_mean=False, learn_doctags=True, learn_words=True, learn_hidden=True, model=None , word_vectors=None,doctag_vectors=None,hidden_vectors=None, sub_batch_size=1 ): """ >>> word_vectors=np.array([[1,2],[3,4],[5,6]]) >>> doctag_vectors=np.array([[10,20],[30,40]]) >>> hidden_vectors=np.array([[1,0],[0,1]]) >>> sub_batch_size=2 >>> kerasmodel=build_keras_model_dm(index_size=2,vector_size=2,vocab_size=3,context_size=2,maxwords=2,sub_batch_size=sub_batch_size,word_vectors=word_vectors,doctag_vectors=doctag_vectors,hidden_vectors=hidden_vectors, learn_words=True ) >>> ind=[[0],[1]] >>> iwd=[[1,0],[1,1]] >>> ipt=[[1,0],[0,1]] >>> tmp1=kerasmodel.predict({'index':np.array(ind),'iword':np.array(iwd),'point':np.array(ipt)})['code'] >>> tmp2=np.array([ [(word_vectors[iwd[i]].sum(0)+doctag_vectors[i]).dot(hidden_vectors[j]) for j in ipt[i] ] for i in range(2)]) >>> np.linalg.norm(1/(1+np.exp(-tmp2))-tmp1) < 0.001 True """ kerasmodel = Graph() kerasmodel.add_input(name='index',input_shape=(1,) , dtype=int) if doctag_vectors is None : kerasmodel.add_node(Embedding(index_size, vector_size,trainable=learn_doctags,input_length=1 ),name='embedindex', input='index') else: kerasmodel.add_node(Embedding(index_size, vector_size,trainable=learn_doctags,input_length=1 ,weights=[doctag_vectors]),name='embedindex', input='index') kerasmodel.add_input(name='iword',input_shape=(maxwords,), dtype=int) if word_vectors is None : kerasmodel.add_node(Embedding(vocab_size, vector_size,trainable=learn_words ,input_length=maxwords ),name='embedword', input='iword') else: kerasmodel.add_node(Embedding(vocab_size, vector_size,trainable=learn_words ,input_length=maxwords,weights=[word_vectors ]),name='embedword', input='iword') kerasmodel.add_input(name='point',input_shape=(sub_batch_size,) , dtype=int) if hidden_vectors is None : kerasmodel.add_node(Embedding(context_size, vector_size,trainable=learn_hidden ,input_length=sub_batch_size ),name='embedpoint', input='point') else: kerasmodel.add_node(Embedding(context_size, vector_size,trainable=learn_hidden ,input_length=sub_batch_size ,weights=[hidden_vectors]),name='embedpoint', input='point') if cbow_mean: kerasmodel.add_node(Lambda(lambda x:x.mean(1),output_shape=(vector_size,)), name='merge',inputs=['embedindex','embedword'], merge_mode='concat', concat_axis=1) else: kerasmodel.add_node(Lambda(lambda x:x.sum(1),output_shape=(vector_size,)), name='merge',inputs=['embedindex','embedword'], merge_mode='concat', concat_axis=1) kerasmodel.add_node(Activation('sigmoid'), name='sigmoid',inputs=['merge','embedpoint'], merge_mode='dot',dot_axes=-1) kerasmodel.add_output(name='code',input='sigmoid') kerasmodel.compile('rmsprop', {'code':'mse'}) return kerasmodel
def build_keras_model_dm_concat(index_size,vector_size,vocab_size, #code_dim, context_size, window_size, learn_doctags=True, learn_words=True, learn_hidden=True, model=None , word_vectors=None,doctag_vectors=None,hidden_vectors=None ): """ >>> syn0=np.array([[1,-2],[-1,2],[2,-2]],'float32') >>> word_vectors=syn0 >>> syn1=np.array([[-1,2,1,-5,4,1,-2,3,-4,5],[3,4,-4,1,-2,6,-7,8,9,1],[5,-6,-8,7,6,-1,2,-3,4,5]],'float32') >>> hidden_vectors=syn1 >>> doctag_vectors=np.array([[-1.1,2.2],[-3.2,-4.3],[-1.1,-1.4]],'float32') >>> kerasmodel=build_keras_model_dm_concat(index_size=3,vector_size=2,vocab_size=3,context_size=3,window_size=2,word_vectors=word_vectors,doctag_vectors=doctag_vectors,hidden_vectors=hidden_vectors) >>> ind=[[0],[1]] >>> iwd=[[0,0,1,2],[1,1,2,0]] >>> ipt=[[0],[1]] >>> tmp1=kerasmodel.predict({'index':np.array(ind),'iword':np.array(iwd),'point':np.array(ipt)})['code'] >>> tmp2=np.array([[np.vstack((doctag_vectors[ind[i]],word_vectors[iwd[i]])).flatten().dot(hidden_vectors[j]) for j in ipt[i] ] for i in range(2)]) >>> np.linalg.norm(1/(1+np.exp(-tmp2))-tmp1) < 0.001 True """ kerasmodel = Graph() kerasmodel.add_input(name='iword' , input_shape=(1,), dtype=int) kerasmodel.add_input(name='index' , input_shape=(1,), dtype=int) if word_vectors is None: kerasmodel.add_node(Embedding(vocab_size, vector_size,input_length=2*window_size,trainable=learn_words,),name='embedword', input='iword') else: kerasmodel.add_node(Embedding(vocab_size, vector_size,input_length=2*window_size,trainable=learn_words,weights=[word_vectors]),name='embedword', input='iword') if doctag_vectors is None: kerasmodel.add_node(Embedding(index_size, vector_size,input_length=1,trainable=learn_doctags,), name='embedindex', input='index') else: kerasmodel.add_node(Embedding(index_size, vector_size,input_length=1,trainable=learn_doctags,weights=[doctag_vectors]), name='embedindex', input='index') kerasmodel.add_input(name='point',input_shape=(1,) , dtype=int) if hidden_vectors is None: kerasmodel.add_node(Embedding(context_size, (2*window_size+1)*vector_size,input_length=1, trainable=learn_hidden,),name='embedpoint', input='point') else: kerasmodel.add_node(Embedding(context_size, (2*window_size+1)*vector_size,input_length=1, trainable=learn_hidden,weights=[hidden_vectors]),name='embedpoint', input='point') kerasmodel.add_node(Flatten(),name='merge',inputs=['embedindex','embedword'],merge_mode='concat', concat_axis=1) kerasmodel.add_node(Activation('sigmoid'), name='sigmoid',inputs=['merge','embedpoint'], merge_mode='dot',dot_axes=-1) kerasmodel.add_output(name='code',input='sigmoid') kerasmodel.compile('rmsprop', {'code':'mse'}) return kerasmodel
